I have an eclipse plugin which has multiple classes which make some UI contributions.
The contribution is done through the deprecated org.eclipse.ui.actionSets and the classes implement the IWorkbenchWindowActionDelegate which require an implementation of the selectionChanged(IAction action, ISelection selection).
The selectionChanged method is triggered on any selection change (another file opened, another item selected in Project Explorer, some text is selected in the editor(this one triggers several calls of the method)).
Is there a filtering or something which I can do to limit the selectionChanged observed objects. For example, for class A, trigger the selectionChanged only if the opened file in editor changes)?
No, there is no way to filter that.
Selections coming from text editors with be instances of ITextSelection, other selections will usually be instances of IStructuredSelection so you can check for those instances to do simple filtering in your code.
Related
I have created a new stereotype based on "Requirement" and has exported it as profile. When I double click on an instantiation of that type, a menu appears that contains the default properties of the type "Requirement". It contains some tabs (e.g. the "Files" tab) that are useless to me.
Is there a way to eliminate this tabs?
How can I modify the default tabs of the properties dialog (open by double click on an element)?
A word of warning: be careful when stereotyping Requirements - the relationship between the element stereotype and the requirement types configured into the project (Settings - Project Types) is a bit murky.
That said, there is no way to modify EA's dialogs. What you can do is create your own property dialog and have EA open that when the user double-clicks the element.
In order to achieve this, you need to create an Add-In which catches the Context Item Event EA_OnContextItemDoubleClicked. In your event handler, return true to inform EA that you're handling the event (which prevents EA from opening the default property dialog), and open your own custom dialog.
The same event is fired when the user hits Enter with the element selected. The default property dialog can still be opened by pressing Alt-Enter.
As an alternative, you might want to look into the third-party extension eaForms, which allows you to create your own custom property dialogs without writing your own Add-In.
I need to create dynamically buttons in main toolbar. I found a solution, but I can create just one button (dynamic contribution item - class extending ContributionItem). But I need to create more than one button, but I cannot find the solution.
I'm fighting with task to create plugin, which parses a XML file containing structure of menu and toolbars. We've already done this plugin for Visual Studio. Its quite easy in principle, but I found swiftly, that not for Eclipse. There is one small but critical otherness. Plugins are implemented declaratively in Eclipse. The file plugin.xml is the gist of plugin's infrastructure, Java code is just ancillary.
The customer wants to refresh the menu and toolbar whenever the selected project is changed. Eclipse lacks several features needed to get the task done. Main menu and main toolbar are cteated at Eclipse's start-up and then they can be hardly rebuilt.
In the most cases the conditions defined at enabledWhen/visibleWhen elements are sufficient to filter contributions according to the context (active part, selected object, whatever else).
If you need to have more freedom, please try E4 ToolControl that allows you to implement your own UI elements:
#PostConstruct
public void createControls(Composite parent) {
//your custom code here
}
More details here https://www.vogella.com/tutorials/EclipseRCP/article.html#toolcontrols
From my understanding you want to have different buttons on the main toolbar depending on the selection of the project explorer (eg. 1 project is java project, the other is javascript etc.). First you will have to contribute to the main toolbar. I think there are some tutorial available so google will help.
The main steps are:
1. create a command (org.eclipse.ui.commmands)
2. create a handler (org.eclipse.ui.handlers) with the previously declared command id
3. contribute to the main toolbar (org.eclipse.ui.menus) with menucontribution and commandId with the following locationURI: toolbar:org.eclipse.ui.main.toolbar?after=misc
showing/hiding, enabling/disabling a menu item/button also can be done declaratively or "mixed". Declaratively means eg. using enabledWhen/visibleWhen...
Mixed means using property tester (org.eclipse.core.expressions.propertyTester). With this you can define your "enablement logic" in Java code.
In Eclipse e4 the UI is generated from a, EMF based, model. The Application.e4xmi serves as a base for that model. Contributions to the model can be done via fragments, which are again XML, or via processors. Processors are written in Java and use e4 services, like the part service, to modify the model at runtime.
I think you want to write a processor that parses your custom XML and modifies the eclipse e4 model accordingly.
I created the menu item in the "File" menu as a command. For this command there is a handler implementing the IHandler interface. This handler contains the isEnabled method. I am trying to use this method to enable/disable my menu item, but that method is called only once when I click on the "File" menu. When clicked for the second, third etc. times, the isEnabled method is not called again even if I changed the state of page (open/close editors) before.
What should I do? Maybe this method is not intended for control menu items?
Are you subclassing org.eclipse.core.commands.AbstractHandler? You should use setBaseEnabled(boolean) to update the state of your handler (which would update your command).
It's only valid to change enabled state in your handler as long as you also fire the HandlerEvent. It's usually easier to call setBaseEnabled(boolean) which will fire the event for you.
If you're trying to enable/disable the menu, than you should use core expressions.
I've already explained how to do that in this answer:
Eclipse RCP menus & actions: Configure or code?
The part that you're interested in starts with:
For activating/deactivating a menu[...]
I hope this is what you're looking for.
i need to retrieve the Package Explorer action bars to set a GlobalAction (setGlobalActionHandler). I'm using Eclipse 3.6.
Ideas?
Thanks!
Not tested, but this old 2006 thread might still present the right principle:
Certain standard menu entries can be shared among several views and editors.
So called global or retargetable actions and include tools like undo/redo, cut/copy/paste, print, find, delete, and more. (look at class IWorkbenchActionFactory).
Each view or editor is allowed to contribute a handler for these actions; when a new part becomes active, its handler takes control of that action. A view has to register its global action handlers in the createPartControl method:
IActionBars actionBars = getViewSite().getActionBars();
actionBars.setGlobalActionHandler(
IWorkbenchActionFactory.COPY,
myCopyAction);
In order to override copy/paste implementation of Package Explorer you need to get its ViewSite.
I have a plugin which contains class A that brings up a view defined in class B via the following line of code:
(VideoLogView) PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().showView("Videolog.VideoLogView");
What I need to do in the createPartControl() method of the view (class B object) is access a method in the class A object.
How can this be done?
Thanks.
Look like you are facing the classic issue of "how do I pass arguments to my view" ?
This thread illustrates it best:
I was facing the same problem at the beggining of my RCP project. I was getting weird about the fact that there was no way to pass an argument to a view as the viewed model.
Why? Because (emphasis mine):
You are on an opened, pluggable platform.
You contribute to existing developments, others should be able to contribute to yours.
Therefore you will not "pass" arguments to a view, this would lock the whole thing into a non-opened design.
Instead, your view will ask the platform (or will listen to the platform) to determine which information to manage.
Other views (from other plugins that don't yet exist) might also want to manage the same information on the same event.
What you should do then is to ask the workbench for the current selection. I guess your view is opening on a double click action or simple selection so the object you want to manage in your view will be currently selected.
This is how you could retrieve the workbench selection from your view :
ISelection s = this.getSite().getWorkbenchWindow().getSelectionService().getSelection();
where "this" is a ViewPart.
Then you have to make your initial view (the one initiating the view creation from a given event like DoubleClick) a selection provider. A JFace viewer is a selection provider, so you can use it if you're using jface, or you can implement the ISelectionProvider interface when you're using custom SWT controls (that was my case).
The article "Eclipse Workbench: Using the Selection Service" can also give you some pointers.