如何在eclipse插件打开后执行动作

Question

我有一个eclipse插件，我想在此插件中执行某些操作，但在eclipse应用程序打开后。

我试图通过重写

public void postWindowCreate()

做到这一点，但它似乎是启动应用程序

任何想法时，我不能这个功能里面得到什么？

Answer 1

你使用e4吗？那么也许下面的链接可以帮助：http://www.eclipse.org/forums/index.php/m/886197/

编辑：

OK，定义你自己的应用程序？

org.eclipse.ui.application.WorkbenchWindowAdvisor提供的方法是您需要的吗？ （例如preWindowOpen()，preWindowShellClose()，postWindowRestore()，postWindowCreate()，...）

我还需要该功能，所以这里就是我如何做到这一点：

你需要3个班，一个实施org.eclipse.equinox.app.IApplication例如MyApp，其延伸org.eclipse.ui.application.WorkbenchAdvisor例如MyAdvisor，以及延伸org.eclipse.ui.application.WorkbenchWindowAdvisor例如MyWindowAdvisor。

然后在MyApp的，你可能会调用类似

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

，你真正开始的工作台，并提供自己的WorkbenchWindowAdvisor。在MyAdvisor中，您必须覆盖：

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

其中您提供了WorkbenchWindowAdvisor。在类MyWindowAdvisor中，您最终可以覆盖相应的功能，例如

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

当然，你必须运行这个工作相应的应用程序;） 好了，现在，提供任意插件来处理这些事件，你可以定义一个扩展点。

首先，您需要一个界面来定义您要收听的“事件”，例如，：

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(); 
} 

然后扩展点模式（用自己的包/插件名称，命名空间全部替换 “YOUR-XXX”）：

<?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> 

然后，在你MyWindowAdvisor您需要保留对扩展名的引用

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

加载/初始化扩展

//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(); 
     } 
    } 
} 

，并在每一个“事件”函数调用扩展方法：

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

的最后一步是提供每一个扩展和类插件，你需要听这些工作台窗口事件。