RCP系统托盘实现方法

 

1.                                         RCP系统托盘气泡提示和右键菜单的实现
3.      实现系统托盘将程序最小化到Windows托盘，是一项有趣而且实用的工作。程序启动后自动最小化到Windows托盘。即使关闭程序，用户也可以随时通过托盘打开，非常方便快捷。
5.     托盘对象简介实现系统托盘首先需要获得Windows托盘对象，托盘对象可以通过Display对象的getSystemTray()方法取得，代码如下：
6. Tray tray = window.getShell().getDisplay().getSystemTray();
9. 托盘对象的创建应该是在能够获得Display对象之后而程序窗口又没有打开之前，即ApplicationWorkbenchWindowAdvisor的postWindowOpen()方法中。
10. 然后，向托盘对象中添加托盘项目TrayItem，并设置托盘项目的文字、图标。托盘项目及其图标应该在程序退出时销毁以释放资源。托盘项目创建方法如下：
11. TrayItem trayItem = new TrayItem(tray, SWT.NONE);
12. trayItem.setImage(trayImage);
13. trayItem.setToolTipText("文字说明");
14.     最后，需要添加托盘项目的事件监听处理，主要有两种，一种是用户单击托盘图标时需要打开程序，其监听事件为：
15. trayItem.addListener(SWT.Selection, new Listener() {
16.      public void handleEvent(Event event) {
17.      //恢复程序界面
18.      }
19. });
20. 另外一种是用户右键单击托盘图标时需要弹出菜单，其监听事件为：
21. trayItem.addListener(SWT.MenuDetect, new Listener() {
22.          public void handleEvent(Event event) {//处理代码}
23.      });
24. 最后还有一个问题，当用户关闭程序时不能关闭托盘图标。这需要复写Application- WorkbenchWindowAdvisor的preWindowShellClose()方法。
26.   系统托盘的具体实现1．创建管理托盘的HookSysTray类，HookSysTray类实现托盘对象的创建和管理，其代码如下。
27. cn.edu.jfcs.sys 
28. import …
29. public class HookSysTray {
30.      private TrayItem trayItem;            //托盘项
31.      private Image trayImage;                   //托盘图标
32.      public HookSysTray() {}
33.      public void createSysTray(final IWorkbenchWindow window) {
34.          trayItem = initTrayItem(window); //初始化托盘
35.          if (trayItem != null) {
36.               trayPopupMenu(window);      //弹出托盘菜单项
37.               trayMinimize(window);       //最小化窗口到托盘
38.          }
39.      }
40.      // 用户单击窗口的最小化按钮时的处理
41.      public void windowMinimized(final Shell shell) {
42.          shell.setMinimized(true);            //最小化窗口
43.          shell.setVisible(false);             //窗口不可见
44.      }
45.      // 最小化程序到托盘
46.      private void trayMinimize(final IWorkbenchWindow window) {
47.          window.getShell().addShellListener(new ShellAdapter() {
48.               public void shellIconified(ShellEvent e) {
49.                    window.getShell().setVisible(false);
50.               }
51.          });
52.         
54.  //用户单击托盘图标时使得主程序窗口可见并恢复为正常大小
55.          trayItem.addListener(SWT.Selection, new Listener() {
56.               public void handleEvent(Event event) {
57.                    Shell shell = window.getShell();
58.                    if (!shell.isVisible()) {
59.                        shell.setVisible(true);
60.                        window.getShell().setMinimized(false);
61.                    }
62.               }
63.          });
64.      }
65.      // 托盘弹出菜单
66.      private void trayPopupMenu(final IWorkbenchWindow window) {
67.          trayItem.addListener(SWT.MenuDetect, new Listener() {
68.               public void handleEvent(Event event) {
69.                    MenuManager trayMenu = new MenuManager();  //创建菜单管理器
70.                    //创建菜单
71.                    Menu menu = trayMenu.createContextMenu(window.getShell());
72.                    fillTrayItem(trayMenu, window);       //给托盘项目加上菜单
73.                    menu.setVisible(true);               //菜单可见
74.               }
75.          });
76.      }
77.      // 构造托盘菜单项
78.      private void fillTrayItem(IMenuManager trayItem,
79.               final IWorkbenchWindow window) {
80.          //创建退出系统菜单
81.          Action exitSystem = new Action("退出系统[&E]", AbstractUIPlugin
82.                    .imageDescriptorFromPlugin(IAppConstants.APPLICATION_ID,
83.                             IImageKey.EXIT_SYSTEM)) {
84.               public void run() {
85.                    PlatformUI.getWorkbench().close();   //退出
86.               }
87.          };
88.          trayItem.add(new Logoff());                    //创建用户注销菜单
89.          trayItem.add(exitSystem);
90.      }
91.      // 初始化托盘项目的文字和图标
92.      private TrayItem initTrayItem(IWorkbenchWindow window) {
93.          //获得系统托盘
94.          final Tray tray = window.getShell().getDisplay().getSystemTray();
95.          if (tray == null)
96.               return null;
97.          trayItem = new TrayItem(tray, SWT.NONE);        //创建托盘项
98.          trayImage = AbstractUIPlugin.imageDescriptorFromPlugin(
99.                    IAppConstants.APPLICATION_ID, IImageKey .WINDOW_IMAGE)                 .createImage();                                    //创建托盘图像
100.          trayItem.setImage(trayImage);                      //设置托盘图标
101.          return trayItem;
102.      }
103.      public void Dispose() {
104.          if (trayItem != null)   trayItem.dispose();         //释放托盘
105.          if (trayImage != null)  trayImage.dispose();   //释放创建的图像资源
106.      }
107. }
108. 程序说明：
109.    程序向Windows托盘增加一个托盘图标和提示文字，并添加“用户注销”和“退出系统”两个托盘项。
110.    MenuManager trayMenu = new MenuManager()是托盘的菜单管理器。
111.    ExitSystem作为“退出系统”托盘项添加到托盘， PlatformUI.getWorkbench().close()用于关闭系统。
112. l   trayItem.add(new Logoff())中的new Logoff()生成“用户注销”Action，并作为托盘项添加到托盘。
113. 2．修改ApplicationWorkbenchWindowAdvisor类l   首先定义一个HookSysTray 对象：
114. private HookSysTray hookSysTray;
115.    添加用于创建hookSysTray对象的createSystemTray()方法：
116. private void createSystemTray() {
117.      hookSysTray = new HookSysTray();
118.      hookSysTray.createSysTray(getWindowConfigurer().getWindow());
119. }
120.    修改postWindowOpen()方法，在该方法中调用createSystemTray()创建系统托盘：
121. public void postWindowOpen() {
122.      // 设置窗口自动居中
123.      Shell shell = getWindowConfigurer().getWindow().getShell();
124.      Rectangle screenSize = Display.getDefault().getClientArea();
125.      Rectangle frameSize = shell.getBounds();
126.      shell.setLocation((screenSize.width - frameSize.width) / 2,
127.               (screenSize.height - frameSize.height) / 2);
128.      createSystemTray();
129. }
130.    改写preWindowShellClose()方法，防止关闭程序时关闭托盘：
131. public boolean preWindowShellClose() {
132.      hookSysTray.windowMinimized(getWindowConfigurer().getWindow().getShell());
133.      return false;
134. }
135.    退出时释放资源：
136. public void dispose() {
137.      hookSysTray.Dispose();
138. }
139.       图片的缓存处理创建图片是一项比较消耗系统资源的工作。众所周知，图片的使用原则是谁创建谁销毁以防止内存泄漏。系统使用图片的地方较多，因此应该统一高效地管理。将图片缓存起来，就可以在需要用到图片时直接从缓存中调用，而不是重新加载。下面是实现图片缓存处理的具体过程。
140. 1．创建缓存CacheImage类CacheImage类负责创建、缓存、销毁图片等工作，以后凡是系统中需要使用图片的地方都由该类负责处理，代码如下。
141. cn.edu.jfcs.sys / CacheImage.java
142. import …
143. public class CacheImage {
144.      private final Map<String, Image> imageMap = new HashMap<String, Image>();
145.      private static CacheImage INSTANCE=new CacheImage();
146.      private CacheImage() {}
147.      //采用单例模式，整个系统共用一个CacheImage唯一实例
148.      public static CacheImage getINSTANCE(){
149.          return INSTANCE;
150.      } 
151.      //获得图像
152.      public Image getImage(String applicationID,String imageName) {
153.          if (imageName == null)
154.               return null;
155.          Image image = (Image) imageMap.get(imageName);
156.          if (image == null) {
157.               image =AbstractUIPlugin.imageDescriptorFromPlugin(
158.                        applicationID,imageName).createImage();
159.               imageMap.put(imageName, image);//图像加入到Map中
160.          }
161.          return image;
162.      }
163.      //释放图像资源
164.      public void dispose() {
165.          //将Map对象转化成Iterator对象
166.          Iterator iterator = imageMap.values().iterator();
167.          while (iterator.hasNext())
168.               ((Image) iterator.next()).dispose();  //释放iterator中的图像资源
169.          imageMap.clear();                         //清除Map对象
170.      }
171. }
172. 2．修改HookSysTray类
174.    去掉private Image trayImage语句。
175.    修改初始化托盘项目initTrayItem()方法：
176. // 初始化托盘项目的文字和图标，代码中的黑体字部分为修改部分，下同。
177. private TrayItem initTrayItem(IWorkbenchWindow window) {
178.      final Tray tray = window.getShell().getDisplay().getSystemTray();
179.      if (tray == null)   return null;
180.      trayItem = new TrayItem(tray, SWT.NONE);
181.      trayItem.setImage(CacheImage.getINSTANCE().getImage(
182.               IAppConstants.APPLICATION_ID, IImageKey.WINDOW_IMAGE));
183.      trayItem.setToolTipText(IAppConstants.APPLICATION_TITLE);
184.      return trayItem;
185. }
187. 3．修改ApplicationWorkbenchWindowAdvisor类的dispose()方法public void dispose() {
188.      hookSysTray.Dispose();
189.      CacheImage.getINSTANCE().dispose();
190. }
191. 图像处理也可以采用图像描述符ImageDescriptor。ImageDescriptor的好处是不需要用户干预，由Java垃圾收集器自动释放和回收。前面创建Action时使用的就是图像描述符。当然，使用图像注册表ImageRegistry也是一个好方法，可以编写一个专门类利用图像注册表进行图像缓存管理。
192.   定时自动显示托盘气泡提示文本气泡提示文本是一种非常友好的向用户展示信息的方式，很多软件的托盘图标都带有气泡提示文本，经常可见的气泡提示文本是向电脑插入U盘时显示的提示文本，其他还有瑞星杀毒软件、卡巴斯基、WindowsXP安全中心等等。Eclipse从3.2版本开始也支持气泡提示文本。
194.     添加气泡提示文本其实非常简单，设置托盘项目trayItem的ToolTip就可以了。下面来实现一个能够每隔30分钟自动显示气泡提示文本的系统托盘，这需要修改初始化托盘项目文字和图标的initTrayItem()方法，黑体为新加代码。
195. private TrayItem initTrayItem(final IWorkbenchWindow window) {
196.      ……
197.      trayItem.setImage(CacheImage.getINSTANCE().getImage(
198.               IAppConstants.APPLICATION_ID, IImageKey.WINDOW_IMAGE));
199.      // 定时显示气泡提示文本
200.      Timer timer = new Timer();                      //创建定时器Timer
201.      timer.schedule(new TimerTask() {
202.          public void run() {
203.               window.getShell().getDisplay().asyncExec(new Runnable() {
204.                    public void run() {
205.                        ToolTip tip = new ToolTip(window.getShell(),
206.                                  SWT.BALLOON | SWT.ICON_INFORMATION);
207.                        tip.setAutoHide(true); //自动隐藏气泡式提示文本
208.                        //设置提示信息
209.                        tip.setMessage(IAppConstants.APPLICATION_TITLE);
210.                        tip.setText("欢迎使用");
211.                        trayItem.setToolTip(tip);
212.                        tip.setVisible(true);  //显示气泡式提示
213.                    }
214.               });
215.          }
216.      }, 0, 30 * 60 * 1000);
217.      return trayItem;
218. }
219. 程序说明：
220.    Timer是一个线程安全的定时器，这里设置的时间间隔为30分钟。为了调试程序时观察效果，可以设置得小一些，例如30秒（30×1000），调试好后再设置时间长些。
221.    SWT.BALLOON设置提示文本为气泡式样，SWT.ICON_INFORMATION则表示带一个信息图标。
222.    注意在Timer线程内部进行改变UI界面的操作时，需要使用window.getShell(). getDisplay().asyncExec()。