We use a DSL generated with Xtext. We added template proposals to our editor as described in the documentation , it works great - templates are available on 'Ctrl+space' and on the preferences page. However, they are NOT visible in the templates view - a standard view in Eclipse where the template proposals are usually displayed.
Normally, Eclipse templates are added by use of the org.eclipse.ui.editors.templates extension point, but it is not used in our plugin.xml generated by Xtext.
Is it possible to display Xtext templates in the standard templates view and if yes, how can we do it?
UPD:
As pointed by Zoltán in his comment, even though the templates view is placed inside the "Generic" group, it heavily depends on the JDT. That's a limitation of this view. An alternative approach to display all templates in a view next to the editor is described in another post
If you are talking about the General/*Templates* view from the Show view dialog, as opposed to its category, is JDT-specific - at least according to the Plug-in spy it is contributed by the
org.eclipse.jdt.ui plug-in, and it only displays Java related templates (I have other template-supported languages available in my setup, and none of them are displayed in the view).
In other words, even if it is possible to extend this list by the Xtext templates (but I think, it is not), you are to be very careful about it, as it might introduce potentitally unwanted JDT UI dependencies for your project.
Related
I am starting a new eclipse plug-in project and trying to evaluate what is the best approach.
What is the goal: I want to create a plug-in that adds a View/Editor stacked on the Editor of the C/C++ perspective from the CDT plug-in. Similar to XML editors that have highlighted text editor view and a view that contains a form to be filled and automatically creates xml code.
The best way would probably be to extend the existing C/C++ perspective from the CDT plug-in. How this is done wtih the 3.X API is explained here [1,2]. Basically you use the org.eclipse.ui.perspectiveExtensions extension point to add views realtive to the views in the perspective.
But how can this be done with the e4 API and the model fragment? Is this possible with compatibility layer?
I think another possibility would be to add views contained in the C/C++ perspective through the combability layer to my own perspective like the package explorer. This has the adavantage that already existing 3.X views (like the package explorer) can be used but also have the advantages of the e4 API.
Or would it even be the best to create a pure 3.X plug-in because my plug-in is mainly based on another perspective/plug-in?
Hope somebody can help me here :)
I don't think it is possible to extend a 3.x perspective using e4 model fragments. It is certainly easier to stick to the 3.x style.
You can use e4 style views by using the e4view style view on the org.eclipse.ui.views extension point.
I noticed #javadoc view in my eclipse. Could you please tell me what is the use of this and how to use it.
Eclipse actually does provide decent tools for creating your own JavaDoc, which is a good idea, as then others who have to use your code will have the ability to see what it does.
There is a keyboard shortcut for adding a block for a class or method (on Mac it's Command-Shift-J I think, but search Javadoc in the key mappings.
You can define templates for adding things like links, which are pretty important, that make creation of JavaDoc go very quickly
When you document in Eclipse, it is intelligent enough to point to existing docs, so say you make an interface, you document the methods in the interface, then inside each implementer, if you created them after the interface, you will get a block that points you back to the interface
When you have added your own, or other people on your team have, this view let's you see what that will look like, so it's got a dual purpose: for making it easier to read the markup of others' JavaDoc, and for previewing your own.
The view you are showing is the Eclipse # Javadoc view. The Javadoc view shows the Javadoc of the element selected in the Java editor or in a Java view.
To use it, simply open a Java file that contains Javadoc in the Java view (or use the Java perspective). Once you do so the Javadoc view will automatically populate.
I am trying to develop an eclipse plugin that does some documentation check on java code and highlights some lines of code in the editor.
To achieve my goal, I DON'T want to create a new editor in eclipse, I simply want to extend the default java editor to draw a line under (or highlight) the methods that do not satisfy some set of predetermined requirements.
Do I need to create a PresentationReconciler? If yes, how do I make the JDT or workbench use my reconciler.
I have never done plugin development and this is my first attempt.
Several starting points for you:
Annotations are an UI feature of JFace's text editor that allows you to visually mark some places in an open editor.
Markers are a Workbench feature, more high-level. They are generic "objects that may be associated with Workbench resources", and they can display in several places: in text editors (as annotations) or in the Problems view, for example.
Depending on what you want to do, you would plug in your plug-in into extension points related to either of those.
The Eclipse Java editor is located in the org.eclipse.jdt.internal.ui.javaeditor.JavaEditor package.
The "internal" in the package name means that the Eclipse development team can change how the Java editor works with new revisions.
Try this help page: Juno Help on syntax highlighting
At the end of the page, it describes how to dynamically add a PresentationReconciler, which is used for syntax highlighting. See if that fits the problem that you want to solve.
I assume you already have a plugin project.
In your plugin.xml, open the tab Extensions, click Add..., search for org.eclipse.ui.editors, then you should see a template named Editor, which will produce a simple xml editor to experiment and play with. Also, you will be able to see the needed structure to define a custom editor.
Hope this helps...
I don't know if you still have a need for this, but you are going to want to use Annotations to keep track of what parts of the editor you need to highlight.
For actually doing the graphical effect of highlighting, you could do syntax highlighting via a PresentationReconciler, but I have no experience with that.
We used a technique we borrowed from http://editbox.sourceforge.net/, replacing the background image of the editor Shell. Its open source, so check it out. (Our code might also help -- its at https://github.com/IDE4edu/EclipseEditorOverlay )
Basically, I have an eclipse plug-in which, among other things, adds three tabs to the Properties View, by using the extension points provided by eclipse (org.eclipse.ui.views.properties.tabbed.propertyContributor, org.eclipse.ui.views.properties.tabbed.propertyTabs and org.eclipse.ui.views.properties.tabbed.propertySections).
I am creating a plug-in to add a new tab (and some different properties) (see image).
Can you please give me some indications on how to do this, considering that there are no extension points offered by this plug-in for this. Is it possible to create a new tab by using the extension points provided by eclipse (mentioned above) in such a way that my tab appears under the three already added?
(I am pretty new in the plug-in area... all the tutorials I found showed how to create some tabs from scratch, where there is nothing added in the Properties View already).
Many thanks!
Here is the solution I found so far (I still need to explore it a bit more - I might be able to add some more details):
I created a fragment - the trick with the fragment is to either set the "host plugin" the RCP plugin or, if you set the "host plugin" a different plugin than the RCP, but which is in the Dependencies list of the RCP, you have to export the product first; don't forget to include the fragment in the Dependencies list of the product.
I extended the plugin org.eclipse.ui.views.properties.tabbed.propertyTabs and set the same contributorId as in the original plugin (the one with the 3 tabs) and created my new tab ("My Tab" in the image)
I created the sections I needed for this tab, again setting the same contributorId
I need to customize the look & feel of my RCP application.
I took a look at Eclipse Presentation API and I suppose it allows to customize everything in workbench except controls.
So is there any solution to customize controls?
I made some research work and implemented some ad-hoc SWT cunstomization using control canvas drawning. May be there are better solutions?
In Swing you can use Synth theme. It would be great if some 'skin' framework exists for SWT.
One way of customizing an RCP app is by using a plugin_customization.ini file. Like this:
Create a new file called "plugin_customization.ini" in the root of your project.
If you have not already done so, create a product configuration and define a Product.
In your plugin's manifest editor, on the "Extensions" tab, locate the "org.eclipse.core.runtime.products" extension, expand the node, right click on your product node and select "New > property" from the context menu.
Enter "preferenceCustomization" in the "name" field and "plugin_customization.ini" in the "value" field.
Select "File > Save" from the main menu.
You can then customize a lot of things simply by editing plugin_customization.ini file. For example, adding the following line
org.eclipse.ui/SHOW_TRADITIONAL_STYLE_TABS=false
will give you rounded tabs on your views and editors (similar to those that Eclipse IDE has) instead of the default ones.
You can find other constants that you can use in IWorkbenchPreferenceConstants javadoc.
Also, check out the Eclipse skins project, if you haven't already.
There is also the possibility to use CSS to change the look & feel of your app, but that is still in development and can be buggy
As for customizing the SWT controls themselves, the only way to do that (apart from small customizations such as changing the background colour of a control etc.) is by creating your own custom controls by extending Canvas or Composite, but you already know that. Keep in mind that the point of SWT is to use native controls, so if you desire the ability to completely customize your controls, perhaps using Swing would be a better option. However, if you're going to use Swing, it may be better to use another RCP entirely - namely, NetBeans RCP. I haven't tried it out yet, but I know that whereas Eclipse RCP uses SWT as a widget toolkit, NetBeans RCP relies on Swing, so that may save you from some headaches regarding compatibility problems and so on.
The new Eclipse 4 work contains plugins that allow the L&F to be customized using CSS. These plugins can be run in a 3.7 Eclipse environment. See Kai's blog for a presentation on the subject: http://www.toedter.com/blog/?p=477
The Eclipse 4 Styling Tutorial has a slide (p.66) on where to get an 3.7 based RCP example.