How to perform an action after eclipse plugin is opened

后端 未结 1 1931
南笙
南笙 2021-01-15 00:47

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

1条回答
  •  无人及你
    2021-01-15 00:56

    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.
         * 

    * 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. *

    */ void preWindowOpen(); /** * Performs arbitrary actions as the window's shell is being closed * directly, and possibly veto the close. *

    * 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 false, 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. *

    * * @return true to allow the window to close, and * false 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. *

    * 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 IWorkbench.close() from this method. *

    * * @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. *

    * 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 postWindowRestore. * Clients must not call this method directly (although super calls are okay). * The default implementation does nothing. Subclasses may override. *

    */ void postWindowCreate(); /** * Performs arbitrary actions after the window has been opened (possibly * after being restored). *

    * 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. *

    */ void postWindowOpen(); /** * Performs arbitrary actions after the window is closed. *

    * 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. *

    */ void postWindowClose(); }

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

    
    
    
    
          
             
          
          
             An extension to actively hook into the WorkbenchWindowAdvisor's pre/post methods from other plug-ins.
    This is primarily intended for plug-ins that are optional or restricted to some specific products.
          
       
    
       
          
             
                
             
          
          
             
                
             
             
                
                   
    
                   
                
             
             
                
                   
    
                   
                
             
             
                
                   
    
                   
                   
                      
                   
                
             
          
       
    
       
          
             
                The hook class implementing IWorkbenchWindowAdvisorHook.
             
          
          
             
                
                   
                      The hook class implementing IWorkbenchWindowAdvisorHook.
                   
                   
                      
                   
                
             
          
       
    
       
          
             
          
          
          
       
    
    

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

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

    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.

    0 讨论(0)
自定义标题
段落格式
字体
字号
代码语言
提交回复
热议问题