问题描述
我有一个 eclipse 插件，我想在这个插件中执行某些操作，但是在 eclipse 应用程序打开之后.
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
public void postWindowCreate()
但启动应用程序时似乎无法进入此功能
but it seems that I can't get inside this function when launching the application
有什么想法吗?
推荐答案
你用e4吗?那么也许以下链接可能会有所帮助:http://www.eclipse.org/forums/index.php/m/886197/
Do you use e4? Then maybe the following link may help: http://www.eclipse.org/forums/index.php/m/886197/
好的，你定义自己的应用程序吗?
OK, do you define your own application?
org.eclipse.ui.application.WorkbenchWindowAdvisor提供的方法是你需要的吗?(例如 preWindowOpen()、preWindowShellClose()、postWindowRestore()、postWindowCreate()、...)
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:
你需要 3 个类，一个实现 org.eclipse.equinox.app.IApplication 例如MyApp，一种扩展 org.eclipse.ui.application.WorkbenchAdvisor 例如MyAdvisor，以及一个扩展 org.eclipse.ui.application.WorkbenchWindowAdvisor 例如我的窗口顾问.
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.
然后在 MyApp 中你可能会调用类似
Then in MyApp you will probably call something like
PlatformUI.createAndRunWorkbench(display, new MyAdvisor());
您实际启动工作台并提供您自己的 WorkbenchWindowAdvisor 的位置.在 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);
}
您在其中提供 WorkbenchWindowAdvisor.在 MyWindowAdvisor 类中，您最终可以覆盖适当的函数，例如
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();
}
然后是扩展点架构(将所有YOUR-xxx"替换为您自己的包/插件名称和命名空间):
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'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 中，您需要保留对扩展的引用
Then, in your MyWindowAdvisor you need to keep a reference to the extensions
// 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();
}
}
}
并在每个事件"函数中调用扩展的方法:
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.
这篇关于打开eclipse插件后如何执行操作的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！