How to perform an action after eclipse plugin is opened

Question

I have an eclipse plugin and I want to perform certain action inside this plugin but after eclipse application is opened.

I tried to do it through overriding

Answer 1

Do you use e4? Then maybe the following link may help: http://www.eclipse.org/forums/index.php/m/886197/

Edit:

OK, do you define your own application?

Are the methods provided by org.eclipse.ui.application.WorkbenchWindowAdvisor the ones you need? (e.g. preWindowOpen(), preWindowShellClose(), postWindowRestore(), postWindowCreate(), ...)

I also needed that functionality, so here's how I do it:

You need 3 classes, one implementing org.eclipse.equinox.app.IApplication e.g. MyApp, one which extends org.eclipse.ui.application.WorkbenchAdvisor e.g. MyAdvisor, and one which extends org.eclipse.ui.application.WorkbenchWindowAdvisor e.g. MyWindowAdvisor.

Then in MyApp you will probably call something like

PlatformUI.createAndRunWorkbench(display, new MyAdvisor());

where you actually start the workbench and provide your own WorkbenchWindowAdvisor. In MyAdvisor you have to overwrite:

@Override    
public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
    return new MyWindowAdvisor(configurer);
}

in which you provide your WorkbenchWindowAdvisor. In class MyWindowAdvisor you can finally override the appropriate functions, e.g.

@Override
public void postWindowOpen() {
    //TODO
}

Of course you have to run the appropriate application for this to work ;) OK, now, to provide arbitrary plug-ins to deal with these events, you could define an extension point.

First you need an interface which defines the "events" you want to listen to, e.g.:

public interface IWorkbenchWindowAdvisorHook
{
    /**
     * Performs arbitrary actions before the window is opened.
     * <p>
     * This method is called before the window's controls have been created.
     * Clients must not call this method directly (although super calls are okay).
     * The default implementation does nothing. Subclasses may override.
     * Typical clients will use the window configurer to tweak the
     * workbench window in an application-specific way; however, filling the
     * window's menu bar, tool bar, and status line must be done in 
     * {@link ActionBarAdvisor#fillActionBars}, which is called immediately
     * after this method is called.
     * </p>
     */
    void preWindowOpen();

    /**
     * Performs arbitrary actions as the window's shell is being closed
     * directly, and possibly veto the close.
     * <p>
     * This method is called from a ShellListener associated with the window,
     * for example when the user clicks the window's close button. It is not
     * called when the window is being closed for other reasons, such as if the
     * user exits the workbench via the {@link ActionFactory#QUIT} action.
     * Clients must not call this method directly (although super calls are
     * okay). If this method returns <code>false</code>, then the user's
     * request to close the shell is ignored. This gives the workbench advisor
     * an opportunity to query the user and/or veto the closing of a window
     * under some circumstances.
     * </p>
     * 
     * @return <code>true</code> to allow the window to close, and
     *         <code>false</code> to prevent the window from closing
     * @see org.eclipse.ui.IWorkbenchWindow#close
     * @see WorkbenchAdvisor#preShutdown()
     */
    public boolean preWindowShellClose();

    /**
     * Performs arbitrary actions after the window has been restored, 
     * but before it is opened.
     * <p>
     * This method is called after a previously-saved window has been
     * recreated. This method is not called when a new window is created from
     * scratch. This method is never called when a workbench is started for the
     * very first time, or when workbench state is not saved or restored.
     * Clients must not call this method directly (although super calls are okay).
     * The default implementation does nothing. Subclasses may override.
     * It is okay to call <code>IWorkbench.close()</code> from this method.
     * </p>
     * 
     * @exception WorkbenchException thrown if there are any errors to report
     *   from post-restoration of the window
     */
    void postWindowRestore() throws WorkbenchException;

    /**
     * Performs arbitrary actions after the window has been created (possibly 
     * after being restored), but has not yet been opened.
     * <p>
     * This method is called after the window has been created from scratch, 
     * or when it has been restored from a previously-saved window.  In the latter case,
     * this method is called after <code>postWindowRestore</code>.
     * Clients must not call this method directly (although super calls are okay).
     * The default implementation does nothing. Subclasses may override.
     * </p>
     */
    void postWindowCreate();

    /**
     * Performs arbitrary actions after the window has been opened (possibly 
     * after being restored).
     * <p>
     * This method is called after the window has been opened. This method is 
     * called after the window has been created from scratch, or when
     * it has been restored from a previously-saved window.
     * Clients must not call this method directly (although super calls are okay).
     * The default implementation does nothing. Subclasses may override.
     * </p>
     */
    void postWindowOpen();

    /**
     * Performs arbitrary actions after the window is closed.
     * <p>
     * This method is called after the window's controls have been disposed.
     * Clients must not call this method directly (although super calls are
     * okay). The default implementation does nothing. Subclasses may override.
     * </p>
     */
    void postWindowClose();
}

Then the extension point schema (replace all "YOUR-xxx" with your own package/plug-in names, and namespace):

<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="***YOUR-NAMESPACE***" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="***YOUR-PLUGIN***" id="workbenchWindowHook" name="***YOUR-PACKAGE***.workbenchWindowHook"/>
      </appInfo>
      <documentation>
         An extension to actively hook into the WorkbenchWindowAdvisor&apos;s pre/post methods from other plug-ins.
This is primarily intended for plug-ins that are optional or restricted to some specific products.
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence>
            <element ref="class" minOccurs="1" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>

               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>

               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>

               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="class">
      <annotation>
         <documentation>
            The hook class implementing IWorkbenchWindowAdvisorHook.
         </documentation>
      </annotation>
      <complexType>
         <attribute name="name" type="string" use="required">
            <annotation>
               <documentation>
                  The hook class implementing IWorkbenchWindowAdvisorHook.
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn=":***YOUR-PACKAGE***.IWorkbenchWindowAdvisorHook"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
      </documentation>
   </annotation>
</schema>

Then, in your MyWindowAdvisor you need to keep a reference to the extensions

// the reference list
private List<IWorkbenchWindowAdvisorHook> hooks = new ArrayList<IWorkbenchWindowAdvisorHook>();

load/initialize the extensions

//code for initializing the extensions, must be called in the constructor
private void initExtensions()
{
    IConfigurationElement[] config = Platform.getExtensionRegistry().getConfigurationElementsFor(
            IWorkbenchWindowAdvisorHook.ID);
    for(IConfigurationElement element : config)
    {
        try
        {
            final Object o = element.createExecutableExtension("name"); //$NON-NLS-1$
            if(o instanceof IWorkbenchWindowAdvisorHook)
            {
                hooks.add((IWorkbenchWindowAdvisorHook)o);
            }
        }
        catch(CoreException e)
        {
            e.printStackTrace();
        }
    }
}

and in each "event" function call the extensions' methods:

// example method preWindowOpen()
public void preWindowOpen()
{
    for(IWorkbenchWindowAdvisorHook hook : hooks)
    {
        try
        {
            hook.preWindowOpen();
        }
        catch(Throwable t)
        {
            CorePlugin.logDefaultError(t);
        }
    }
}

The final step is to provide an extension and class in each plug-in you need to listen to these workbench window events.