Moving around

• Ctrl+J — Incremental Search
• Ctrl+Shift+T — Search a type, with search on typing. You can use only the upcase letters (e.g. type “MIL” to find MouseInputListener)
• Ctrl+F6 — Switch between last used files
• F3 — Open declaration
• F4-- 查看类体系
  
• Ctrl+Alt+H — Open Call Hierarchy

Editing

• Ctrl+1 — Quick Fix: press while cursor is positioned at member variable, parameter, selection, warnings, errors, …
• Ctrl+Space — Context Assist: press after a ., or to use macros (for, while, sysout, …). Press in class-scope to automatically create method declarations.
• Ctrl+Shift+O — Organize Imports
• Ctrl+Shift+F — Reformat source
• Alt+Shift+T — Show Refactor Quick Menu

In case these hotkeys are not enough or you have forgotten which hotkey does what, you can always press Ctrl+Shift+L to get a nice list of all the hotkeys.

Today I want to show how to add a sorter to your JFace-Table. The requirement is to sort descending und ascending by clicking on the TableColumn-Header.

The inital view with sorting

The ascending sorting after a click on the ID-Column header.

JFace already provides sorting-functionality. We just have to provide something like an alogrithm to arrange the items. For that we implemented the CollectionSorter that uses the default Collator from ViewerSorter. Now look at the Sorter:

Initializing the Sorter with a default column

This sorter you can use everywhere, you just have to modify the Creation of the Collator-Keys.

Direction Indicator
This feature will be aviable in Eclipse 3.2

Download the JFace TableSorter Plugin (Requires Model-Plugin)
Download the JFace TableSorter RCP (source included)

From my experience, perspectives are really useful for representing blocks of funtionality, something like a workflow or a set of requirements that are bundled. The perspective-bar is a very nice feature, necessary in the JDT but has a great disadvantage: The lack of integrity.

In my opinion perspectives have different goals: On the one hand they have to provide different user-roles different presentations of an application and on the other hand they have to bundle different views that are responsible for a special set of functionality.

Unfortunately the Eclipse-Framework doesn’t provide the approach to use this nice bar for different user-roles. Neither it’s possible to contribute to this bar nor to filter or hide perspectives. This is confusing, because everywhere you contribute your items, action, views, etc. to the workbench, but not in this special case. You have to reimplement the perspective-bar if you want to provide special behavior.

The art or reimplementing

The easiest way is to declare some actions, registering a perspective-listener and contributing the actions, depending from your business logic to a coolbar of the workbench-window. But that’s ugly, isn’t it?

I want to have a big and colored perspective-switcher (like in Lotus Notes) without implementing a new Presentation using the org.eclipse.ui.themes Extension-Point. But that’s not so easy, because Eclipse doesn’t have a special “Area”, something like a Composite where I can provide something, that’s always present.

A first try

I just had an idea. Using a standalone-View that is in all perspectives on the same place could simulate a fully customizable perspective-bar. Although it’s not a satisfying solution it’s the first step of a better fully controllable perspective-switcher.

(The Example RCP with two Perspectives)

Download

Download the Perspective-Switcher Example as RCP (Source included - 9,3 Mbyte)
CVS-Checkout (more info)

2 Comments »

1. Well this could be achieved if you create your own ApplicationWorkbenchWindowAdvisor like I did it to create logo for my RCP application, but you can use it for this task too. You can find what I mean if you look at http://birosoft.zexxo.net/demo/UpdateDemo.htm
   . ApplicationLogo class in my case is a simple composite.

   Source example:

   package com.birosoft.workday.platform.intro;

   import org.eclipse.core.runtime.Preferences;
   import org.eclipse.swt.SWT;
   import org.eclipse.swt.graphics.Point;
   import org.eclipse.swt.layout.FormAttachment;
   import org.eclipse.swt.layout.FormData;
   import org.eclipse.swt.layout.FormLayout;
   import org.eclipse.swt.widgets.Composite;
   import org.eclipse.swt.widgets.Control;
   import org.eclipse.swt.widgets.CoolBar;
   import org.eclipse.swt.widgets.Menu;
   import org.eclipse.swt.widgets.Shell;
   import org.eclipse.ui.PlatformUI;
   import org.eclipse.ui.application.ActionBarAdvisor;
   import org.eclipse.ui.application.IActionBarConfigurer;
   import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
   import org.eclipse.ui.application.WorkbenchWindowAdvisor;
   import org.eclipse.ui.internal.WorkbenchWindow;
   import org.eclipse.ui.internal.progress.ProgressRegion;

   import com.birosoft.workday.platform.Activator;

   public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
   private Control logo;

   private Control toolbar;

   private Control page;

   private Control statusline;

   private ProgressRegion progressRegion;

   public ApplicationWorkbenchWindowAdvisor(
   IWorkbenchWindowConfigurer configurer) {
   super(configurer);
   }

   public ActionBarAdvisor createActionBarAdvisor(
   IActionBarConfigurer configurer) {
   return new ApplicationActionBarAdvisor(configurer);
   }

   public void preWindowOpen() {
   IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
   Preferences prefs = Activator.getDefault().getPluginPreferences();
   if (prefs.getInt(Application.APP_WIN_WIDTH) == 0
   || prefs.getInt(Application.APP_WIN_HEIGHT) == 0) {
   configurer.setInitialSize(new Point(800, 600));
   } else {
   int width = prefs.getInt(Application.APP_WIN_WIDTH);
   int height = prefs.getInt(Application.APP_WIN_HEIGHT);
   configurer.setInitialSize(new Point(width, height));
   }
   configurer.setShowCoolBar(true);
   configurer.setShowStatusLine(true);
   configurer.setShowProgressIndicator(true);
   configurer.setTitle(”Birosoft Workday Client - ”
   + Application.getCurrentClient().toString() + ” (”
   + Application.getUsername() + “)”);
   }

   public void postWindowOpen() {
   IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
   Preferences prefs = Activator.getDefault().getPluginPreferences();
   if (prefs.getInt(Application.APP_WIN_POS_X) == 0
   || prefs.getInt(Application.APP_WIN_POS_Y) == 0) {
   configurer.getWindow().getShell().setLocation(0, 0);
   } else {
   int x = prefs.getInt(Application.APP_WIN_POS_X);
   int y = prefs.getInt(Application.APP_WIN_POS_Y);
   configurer.getWindow().getShell().setLocation(x, y);
   }
   }

   @Override
   public void postWindowClose() {
   Preferences prefs = Activator.getDefault().getPluginPreferences();
   Point size = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
   .getShell().getSize();
   prefs.setValue(Application.APP_WIN_WIDTH, size.x);
   prefs.setValue(Application.APP_WIN_HEIGHT, size.y);
   Point position = PlatformUI.getWorkbench().getActiveWorkbenchWindow()
   .getShell().getLocation();
   prefs.setValue(Application.APP_WIN_POS_X, position.x);
   prefs.setValue(Application.APP_WIN_POS_Y, position.y);
   super.postWindowClose();
   }

   public void createWindowContents(Shell shell) {
   IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
   Menu menu = configurer.createMenuBar();
   shell.setMenuBar(menu);
   FormLayout layout = new FormLayout();
   layout.marginWidth = 0;
   layout.marginHeight = 0;
   shell.setLayout(layout);
   logo = new ApplicationLogo(
   getWindowConfigurer().getWindow().getShell(), SWT.NONE);
   Application.setApplicationLogo(((ApplicationLogo) logo));
   toolbar = configurer.createCoolBarControl(shell);
   ((CoolBar) toolbar).setLocked(true);
   page = configurer.createPageComposite(shell);
   statusline = configurer.createStatusLineControl(shell);
   createProgressIndicator(shell);

   // The layout method does the work of connecting the
   // controls together.
   layoutNormal();
   }

   private void layoutNormal() {
   // APPLOGO
   FormData data = new FormData();
   data.top = new FormAttachment(0, 0);
   data.left = new FormAttachment(0, 0);
   data.right = new FormAttachment(100, 0);
   logo.setLayoutData(data);
   // TOOLBAR
   data = new FormData();
   data.top = new FormAttachment(logo, 5, SWT.BOTTOM);
   data.left = new FormAttachment(0, 0);
   data.right = new FormAttachment(page, 0, SWT.LEFT);
   toolbar.setLayoutData(data);
   // STATUS LINE
   data = new FormData();
   data.bottom = new FormAttachment(100, 0);
   data.left = new FormAttachment(0, 0);
   data.right = new FormAttachment(100, 0);
   statusline.setLayoutData(data);
   // PAGE CONTENTS
   data = new FormData();
   data.top = new FormAttachment(logo, 5, SWT.BOTTOM);
   // data.left = new FormAttachment(toolbar, 0, SWT.RIGHT);
   data.left = new FormAttachment(0, 5);
   data.right = new FormAttachment(100, -5);
   data.bottom = new FormAttachment(statusline);
   page.setLayoutData(data);
   layout();
   }

   private void layout() {
   getWindowConfigurer().getWindow().getShell().layout(true);
   if (page != null) {
   ((Composite) page).layout(true);
   }
   }

   /**
   * Create the progress indicator for the receiver.
   * @param shell the parent shell
   */
   private void createProgressIndicator(Shell shell) {
   if (getWindowConfigurer().getShowProgressIndicator()) {
   WorkbenchWindow window = (WorkbenchWindow) getWindowConfigurer()
   .getWindow();
   progressRegion = new ProgressRegion();
   progressRegion.createContents(shell, window);
   }
   }

   }

   Comment by Mickey — 13. March 2007 @ 19:41

2. Yes, you’re right.
   Thanks for your addition

   Comment by Tom Seidel — 13. March 2007 @ 19:58

Product branding with Eclipse RCP

Since it is possible to build RCP applications with Eclipse, the possibilities to give your application a more personal touch through the PDE have also increased. Typical elements are for example splash-screens, program-icons or welcome-screens. But in the most cases that is not enough. The customer often has a corporate identity with logos, special colors, fonts,etc. which must be also integrated within the application.

Step 1: Implementing a banner with integrated Toolbar

An often required UI-element is a banner on top of your views with a company logo or the name of your product and a toolbar where the key features of the application are accessible. This is possible if your overwrite the method WorkbenchWindowAdvisor#createWindowContents(Shell shell). Eclipse layouts and creates typical elements of your workbench like the Coolbar, MenuBar and the Statusline. If you overwrite this method you have the freedom to arrange the content of your window but you also have to care for the correct initialization of all UI-elements needed. This step is very effective and your application looks much more personalized (see picture).

Part of the banner with a two-buttons toolbar

Step 2: Implement your own Viewpart-Title Area

The most characteristic element to indicate a “typical Eclipse application” is the look of a viewpart with the curved title and the appended action bar.
With the form enhancements in Eclipse 3.3M5 and the features with custom titles a new and interesting possibility is provided to use this feature also as title in your viewparts. You just have to add the views as standalone views to your perspective layout and implement the title in your viewpart. With the ability to customize the colors (see org.eclipse.ui.forms.FormColors) you can show up views that nobody would associate with a “typical Eclipse application” (see Image).

Viewparts with Form-Headings and Actionbar (on the right: with Subheader)

Step 3: Move your Progress Indicator

This is an optional step, depending on your requirements. In nearly every application you have jobs for background-processes where you need a progress indicator to give the user a feedback about the job-status. The default-location of the progress indicator is on the bottom of your application window outside the page contents. It doesn’t make sense in small applications, that this little, but important widget needs the whole bottom of your workbench-window, especially if you don’t have a status-bar. So why not place the progress-bar somewhere else, e.g. in a viewpart?- In spite of the “Discouraged Access Warning” you can implement the org.eclipse.ui.internal.progress.ProgressRegion wherever you want (see picture).

Progress Region in a viewpart

Example

I have implemented a small RCP application, which uses the mentioned UI-customizations (see picture). Check it out (or download) to see, how easyily an individual UI can be implemented. But remember: The discussed issues can be realized only for a special type of RCPs. If you have to customize your “Next generation IDE” with 100 views and editors, please use the presentation framework.

The example application

Conclusion

There are many ways to customize your Eclipse RCP Application. Based on the special requirements of your personal application you have to choose the best toolkit to reach your goal.
Maybe you also have a simple way to customize your RCP product. Let me know.

Downloads

Download the UI Customization Example as RCP (Source included - 11 Mbyte)
CVS-Checkout (more info)

2 Comments »

1. Note that overriding the WorkbenchWindowAdvisor#createWindowContents(Shell shell) method has some disadvantages, as discussed in this bug[1].

   [1] https://bugs.eclipse.org/bugs/show_bug.cgi?id=73821

   Comment by Kris — 16. April 2007 @ 17:13

2. And overriding the WorkbenchWindowAdvisor#createWindowContents(Shell shell) does not allow to use “Welcome” view because your banner will be always on top. In this case you should to hide banner manually because eclipse api hides only coolbar.

   Comment by MByte — 17. April 2007 @ 08:37

eclipse rcp 相关的资料

FAQ Can I make a job run in the UI thread?

How to Correctly and Uniformly Use Progress Monitors

FAQ Why do I get an invalid thread access exception?

FAQ Why should I use the new progress service?

FAQ How do I switch from using a Progress dialog to the Progress view?

另外，获取插件/rcp 的workspace的路径：