Implementazione componenti

I componenti registrati con il punto di estensione tipi assomigliano ai componenti delle parti. Possono utilizzare un insieme di dipendenze nel costruzione e devono implementare l'interfaccia per cui sono registrati. Questo esempio mostra l'implementazione di NullNameableService.

/**
 * Default implementation of the Nameable service. All methods are no-ops.
 *
 * @since 3.1
 */
public class NullNameableService implements INameable {

    /**
     * Component constructor. Do not invoke directly.
     */
    public NullNameableService() {}

    public void setName(String newName) {}
    public void setContentDescription(String contentDescription) {}
    public void setImage(ImageDescriptor theImage) {}
    public void setTooltip(String toolTip) {}
}

Si tratta di un esempio semplice, in quanto la classe non effettua alcuna azione, ma tuttavia dimostra un modello comune. Il servizio INameable viene utilizzato per informare l'elemento principale sullo stato dell'elemento secondario. Con questo tipo di interfaccia, l'implementazione predefinita, tipicamente non effettua alcuna operazione. Se l'elemento principale non rileva lo stato del secondario, il secondario può essere ignorato. Per convenzione, si utilizza il prefisso "Null" per indicare che si tratta di un componente che non effettua alcuna azione. Questo tipo di oggetto generalmente è registrato come singleton perché è troppo dispendioso creare più istanze di un oggetto così irrilevante. I client dovrebbero verificare che le nuove interfacce che riportano lo stato, abbiano la funzione di molteplicità.

Se lo scopo delle interfacce è di assegnare risorse o generare output, l'implementazione predefinita generalmente effettua operazioni più utili. Il seguente esempio mostra l'implementazione della classe DefaultMessageDialogs. Poiché questa classe è rivolta alla generazione dell'output interattivo, dispone di un'utile implementazione predefinita e non supporta la funzione di molteplicità. Poiché questa classe deve accedere ad un componente delle parti, non può essere un singleton. Per convenzione, si utilizza il prefisso classi "Default" per indicare che si tratta di un componente predefinito con uno scopo.

/**
 * Default implementation of the IMessageDialogs interface. Takes the part's
 * control as context and allows the part to open dialogs in a child shell.
 *
 * @since 3.1
 */
public class DefaultMessageDialogs implements IMessageDialogs {

    private Composite control;
   
    /**
     * Component constructor. Do not invoke directly.
     */
    public DefaultMessageDialogs(Composite control) {
        this.control = control;
    }
   
    public void open(IStatus message) {
        if (message.getSeverity() == IStatus.ERROR) {
            ErrorDialog.openError(control.getShell(), null, null, message);
        } else {
            open(message.getSeverity(), message.getMessage());
        }
    }

    public void openError(String message, Throwable cause) {
        open(new Status(IStatus.ERROR,
                WorkbenchPlugin.getDefault().getBundle().getSymbolicName(),
                IStatus.OK,
                message,
                cause));
    }
   
    public void open(int severity, String message) {
        if (severity == IStatus.ERROR) {
            MessageDialog.openError(control.getShell(), null, message);
        } else if (severity == IStatus.WARNING) {
            MessageDialog.openWarning(control.getShell(), null, message);
        } else {
            MessageDialog.openInformation(control.getShell(), null, message);
        }   
    }
}

Di seguito è riportata la markup del punto di estensione per DefaultMessageDialog.

<extension point="org.eclipse.core.component.types">
      <component
            initializer="org.eclipse.ui.part.SiteInitializer"
            interface="org.eclipse.ui.part.services.IMessageDialogs"
            implementation="org.eclipse.ui.internal.part.services.DefaultMessageDialogs"
            singleton="false"/>
</extension>