KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > mountainminds > eclemma > internal > ui > coverageview > CoverageView


1 /*******************************************************************************
2  * Copyright (c) 2006, 2007 Mountainminds GmbH & Co. KG
3  * This software is provided under the terms of the Eclipse Public License v1.0
4  * See http://www.eclipse.org/legal/epl-v10.html.
5  *
6  * $Id: CoverageView.java 398 2007-08-30 18:20:31Z mtnminds $
7  *
8  * Contributors:
9  * Brock Janiczak - link with selection option (SF #1774547)
10  ******************************************************************************/

11 package com.mountainminds.eclemma.internal.ui.coverageview;
12
13 import java.text.DecimalFormat JavaDoc;
14
15 import org.eclipse.jdt.core.IPackageFragmentRoot;
16 import org.eclipse.jdt.ui.IContextMenuConstants;
17 import org.eclipse.jdt.ui.actions.IJavaEditorActionDefinitionIds;
18 import org.eclipse.jdt.ui.actions.JdtActionConstants;
19 import org.eclipse.jdt.ui.actions.OpenAction;
20 import org.eclipse.jface.action.IAction;
21 import org.eclipse.jface.action.IMenuListener;
22 import org.eclipse.jface.action.IMenuManager;
23 import org.eclipse.jface.action.IToolBarManager;
24 import org.eclipse.jface.action.MenuManager;
25 import org.eclipse.jface.action.Separator;
26 import org.eclipse.jface.viewers.ILabelProvider;
27 import org.eclipse.jface.viewers.ILabelProviderListener;
28 import org.eclipse.jface.viewers.IOpenListener;
29 import org.eclipse.jface.viewers.ISelectionChangedListener;
30 import org.eclipse.jface.viewers.IStructuredSelection;
31 import org.eclipse.jface.viewers.ITableLabelProvider;
32 import org.eclipse.jface.viewers.OpenEvent;
33 import org.eclipse.jface.viewers.SelectionChangedEvent;
34 import org.eclipse.jface.viewers.TreeViewer;
35 import org.eclipse.jface.viewers.Viewer;
36 import org.eclipse.jface.viewers.ViewerFilter;
37 import org.eclipse.swt.SWT;
38 import org.eclipse.swt.graphics.Image;
39 import org.eclipse.swt.widgets.Composite;
40 import org.eclipse.swt.widgets.Tree;
41 import org.eclipse.swt.widgets.TreeColumn;
42 import org.eclipse.ui.IKeyBindingService;
43 import org.eclipse.ui.IMemento;
44 import org.eclipse.ui.IViewSite;
45 import org.eclipse.ui.IWorkbenchActionConstants;
46 import org.eclipse.ui.PartInitException;
47 import org.eclipse.ui.actions.ActionFactory;
48 import org.eclipse.ui.dialogs.PropertyDialogAction;
49 import org.eclipse.ui.model.WorkbenchLabelProvider;
50 import org.eclipse.ui.part.ViewPart;
51 import org.eclipse.ui.texteditor.IWorkbenchActionDefinitionIds;
52
53 import com.mountainminds.eclemma.core.CoverageTools;
54 import com.mountainminds.eclemma.core.ICoverageSession;
55 import com.mountainminds.eclemma.core.ISessionListener;
56 import com.mountainminds.eclemma.core.analysis.ICounter;
57 import com.mountainminds.eclemma.core.analysis.IJavaCoverageListener;
58 import com.mountainminds.eclemma.core.analysis.IJavaElementCoverage;
59 import com.mountainminds.eclemma.internal.ui.ContextHelp;
60 import com.mountainminds.eclemma.internal.ui.EclEmmaUIPlugin;
61 import com.mountainminds.eclemma.internal.ui.UIMessages;
62 import com.mountainminds.eclemma.internal.ui.actions.ExportSessionAction;
63 import com.mountainminds.eclemma.internal.ui.actions.ImportSessionAction;
64 import com.mountainminds.eclemma.internal.ui.actions.MergeSessionsAction;
65 import com.mountainminds.eclemma.internal.ui.actions.RefreshSessionAction;
66 import com.mountainminds.eclemma.internal.ui.actions.RemoveActiveSessionAction;
67 import com.mountainminds.eclemma.internal.ui.actions.RemoveAllSessionsAction;
68
69 /**
70  * Implementation of the coverage view.
71  *
72  * @author Marc R. Hoffmann
73  * @version $Revision: 398 $
74  */

75 public class CoverageView extends ViewPart {
76   
77   public static final String JavaDoc ID = "com.mountainminds.eclemma.ui.CoverageView"; //$NON-NLS-1$
78

79   /**
80    * Placeholder element for displaying "Loading..." in the coverage view.
81    */

82   public static final Object JavaDoc LOADING_ELEMENT = new Object JavaDoc();
83
84   private static final DecimalFormat JavaDoc COVERAGE_VALUE = new DecimalFormat JavaDoc(UIMessages.CoverageView_columnCoverageValue);
85   
86   private ViewSettings settings = new ViewSettings();
87   
88   protected static final int COLUMN_ELEMENT = 0;
89   protected static final int COLUMN_RATIO = 1;
90   protected static final int COLUMN_COVERED = 2;
91   protected static final int COLUMN_TOTAL = 3;
92   
93   private Tree tree;
94   private TreeColumn column0;
95   private TreeColumn column1;
96   private TreeColumn column2;
97   private TreeColumn column3;
98   private TreeViewer viewer;
99   
100   
101   // Actions
102
private OpenAction openAction;
103   private IAction relaunchSessionAction;
104   private IAction removeActiveSessionAction;
105   private IAction removeAllSessionsAction;
106   private IAction mergeSessionsAction;
107   private IAction selectSessionAction;
108   private IAction importAction;
109   private IAction exportAction;
110   private IAction refreshAction;
111   private PropertyDialogAction propertiesAction;
112   
113   private SelectionTracker selectiontracker;
114   private CoverageViewSorter sorter = new CoverageViewSorter(settings, this);
115   
116   private ISessionListener listener = new ISessionListener() {
117     public void sessionAdded(ICoverageSession newSession) {
118       updateActions();
119     }
120     public void sessionRemoved(ICoverageSession oldSession) {
121       updateActions();
122     }
123     public void sessionActivated(ICoverageSession session) {
124       updateActions();
125     }
126   };
127   
128   private IJavaCoverageListener coverageListener = new IJavaCoverageListener() {
129     public void coverageChanged() {
130       tree.getDisplay().asyncExec(new Runnable JavaDoc() {
131         public void run() {
132           viewer.setInput(CoverageTools.getJavaModelCoverage());
133         }
134       });
135     }
136   };
137   
138   private ITableLabelProvider labelprovider = new ITableLabelProvider() {
139     
140     private ILabelProvider delegate = new WorkbenchLabelProvider();
141
142     public Image getColumnImage(Object JavaDoc element, int columnIndex) {
143       if (element == LOADING_ELEMENT) {
144         return null;
145       }
146       switch (columnIndex) {
147         case COLUMN_ELEMENT:
148           return delegate.getImage(element);
149         case COLUMN_RATIO:
150           ICounter counter = settings.getCounterMode().getCounter(CoverageTools.getCoverageInfo(element));
151           if (counter.getTotalCount() == 0) {
152             return null;
153           } else {
154             return EclEmmaUIPlugin.getCoverageImage(counter.getRatio());
155           }
156       }
157       return null;
158     }
159     
160     private String JavaDoc getSimpleTextForJavaElement(Object JavaDoc element) {
161       if (element instanceof IPackageFragmentRoot) {
162         // tweak label if the package fragment root is the project itself:
163
IPackageFragmentRoot root = (IPackageFragmentRoot) element;
164         if (root.getElementName().length() == 0) {
165           element = root.getJavaProject();
166         }
167       }
168       return delegate.getText(element);
169     }
170
171     private String JavaDoc getTextForJavaElement(Object JavaDoc element) {
172       String JavaDoc text = getSimpleTextForJavaElement(element);
173       switch (settings.getEntryMode()) {
174         case ViewSettings.ENTRYMODE_PACKAGEROOTS:
175           if (element instanceof IPackageFragmentRoot) {
176             text += " - " + getTextForJavaElement(((IPackageFragmentRoot) element).getJavaProject()); //$NON-NLS-1$
177
}
178           break;
179       }
180       return text;
181     }
182
183     
184     public String JavaDoc getColumnText(Object JavaDoc element, int columnIndex) {
185       if (element == LOADING_ELEMENT) {
186         return columnIndex == COLUMN_ELEMENT ? UIMessages.CoverageView_loadingMessage : ""; //$NON-NLS-1$
187
}
188       ICounter counter = settings.getCounterMode().getCounter(CoverageTools.getCoverageInfo(element));
189       switch (columnIndex) {
190         case COLUMN_ELEMENT:
191           return getTextForJavaElement(element);
192         case COLUMN_RATIO:
193           if (counter.getTotalCount() == 0) {
194             return ""; //$NON-NLS-1$
195
} else {
196             return COVERAGE_VALUE.format(new Double JavaDoc(counter.getRatio()));
197           }
198         case COLUMN_COVERED:
199           return String.valueOf(counter.getCoveredCount());
200         case COLUMN_TOTAL:
201           return String.valueOf(counter.getTotalCount());
202       }
203       return ""; //$NON-NLS-1$
204
}
205     
206     public boolean isLabelProperty(Object JavaDoc element, String JavaDoc property) {
207       return delegate.isLabelProperty(element, property);
208     }
209     public void addListener(ILabelProviderListener listener) {
210       delegate.addListener(listener);
211     }
212     public void removeListener(ILabelProviderListener listener) {
213       delegate.removeListener(listener);
214     }
215     public void dispose() {
216       delegate.dispose();
217     }
218   };
219   
220   public void init(IViewSite site, IMemento memento) throws PartInitException {
221     super.init(site, memento);
222     settings.init(memento);
223
224   }
225
226   public void saveState(IMemento memento) {
227     int[] widths = settings.getColumnWidths();
228     widths[0] = column0.getWidth();
229     widths[1] = column1.getWidth();
230     widths[2] = column2.getWidth();
231     widths[3] = column3.getWidth();
232     settings.save(memento);
233     super.saveState(memento);
234   }
235
236   public void createPartControl(Composite parent) {
237     ContextHelp.setHelp(parent, ContextHelp.COVERAGE_VIEW);
238     tree = new Tree(parent, SWT.NONE);
239     tree.setHeaderVisible(true);
240     tree.setLinesVisible(true);
241     int[] widths = settings.getColumnWidths();
242     column0 = new TreeColumn(tree, SWT.NONE);
243     column0.setWidth(widths[0]);
244     sorter.addColumn(column0, COLUMN_ELEMENT);
245     column1 = new TreeColumn(tree, SWT.RIGHT);
246     column1.setWidth(widths[1]);
247     sorter.addColumn(column1, COLUMN_RATIO);
248     column2 = new TreeColumn(tree, SWT.RIGHT);
249     column2.setWidth(widths[2]);
250     sorter.addColumn(column2, COLUMN_COVERED);
251     column3 = new TreeColumn(tree, SWT.RIGHT);
252     column3.setWidth(widths[3]);
253     sorter.addColumn(column3, COLUMN_TOTAL);
254     updateColumnHeaders();
255     
256     viewer = new TreeViewer(tree);
257     viewer.addFilter(new ViewerFilter() {
258       public boolean select(Viewer viewer, Object JavaDoc parentElement, Object JavaDoc element) {
259         if (element == LOADING_ELEMENT) {
260           return true;
261         } else {
262           IJavaElementCoverage c = CoverageTools.getCoverageInfo(element);
263           if (c == null || c.getInstructionCounter().getTotalCount() == 0) {
264             return false;
265           }
266           if (settings.getHideUnusedTypes()) {
267             ICounter cnt = c.getTypeCounter();
268             return cnt.getTotalCount() == 0 || cnt.getCoveredCount() != 0;
269           }
270           return true;
271         }
272       }
273     });
274     viewer.setSorter(sorter);
275     viewer.setContentProvider(new CoveredElementsContentProvider(settings));
276     viewer.setLabelProvider(labelprovider);
277     viewer.setInput(CoverageTools.getJavaModelCoverage());
278     viewer.addSelectionChangedListener(new ISelectionChangedListener() {
279       public void selectionChanged(SelectionChangedEvent event) {
280         openAction.selectionChanged((IStructuredSelection) event.getSelection());
281         propertiesAction.selectionChanged(event);
282       }
283     });
284     getSite().setSelectionProvider(viewer);
285     
286     selectiontracker = new SelectionTracker(this, viewer);
287     
288     createActions();
289     updateActions();
290     configureToolbar();
291     
292     viewer.addOpenListener(new IOpenListener() {
293       public void open(OpenEvent event) {
294         openAction.run((IStructuredSelection) event.getSelection());
295       }
296     });
297     
298     MenuManager menuMgr = new MenuManager("#PopupMenu"); //$NON-NLS-1$
299
menuMgr.setRemoveAllWhenShown(true);
300     tree.setMenu(menuMgr.createContextMenu(tree));
301     menuMgr.addMenuListener(new IMenuListener() {
302       public void menuAboutToShow(IMenuManager menuMgr) {
303         configureContextMenu(menuMgr);
304       }
305     });
306     
307     CoverageTools.getSessionManager().addSessionListener(listener);
308     CoverageTools.addJavaCoverageListener(coverageListener);
309   }
310   
311   protected void createActions() {
312     IKeyBindingService kb = getSite().getKeyBindingService();
313     openAction = new OpenAction(getSite());
314     openAction.setActionDefinitionId(IJavaEditorActionDefinitionIds.OPEN_EDITOR);
315     getViewSite().getActionBars().setGlobalActionHandler(JdtActionConstants.OPEN, openAction);
316     openAction.setEnabled(false);
317     kb.registerAction(openAction);
318     relaunchSessionAction = new RelaunchSessionAction();
319     kb.registerAction(relaunchSessionAction);
320     removeActiveSessionAction = new RemoveActiveSessionAction();
321     kb.registerAction(removeActiveSessionAction);
322     removeAllSessionsAction = new RemoveAllSessionsAction();
323     kb.registerAction(removeAllSessionsAction);
324     mergeSessionsAction = new MergeSessionsAction(getSite().getWorkbenchWindow());
325     kb.registerAction(mergeSessionsAction);
326     selectSessionAction = new SelectSessionAction();
327     kb.registerAction(selectSessionAction);
328     importAction = new ImportSessionAction(getSite().getWorkbenchWindow());
329     kb.registerAction(importAction);
330     exportAction = new ExportSessionAction(getSite().getWorkbenchWindow());
331     kb.registerAction(exportAction);
332     refreshAction = new RefreshSessionAction();
333     kb.registerAction(refreshAction);
334     getViewSite().getActionBars().setGlobalActionHandler(ActionFactory.REFRESH.getId(), refreshAction);
335     propertiesAction = new PropertyDialogAction(getSite(), viewer);
336     propertiesAction.setActionDefinitionId(IWorkbenchActionDefinitionIds.PROPERTIES);
337     getViewSite().getActionBars().setGlobalActionHandler(ActionFactory.PROPERTIES.getId(), propertiesAction);
338   }
339   
340   protected void configureToolbar() {
341     IToolBarManager tbm = getViewSite().getActionBars().getToolBarManager();
342     tbm.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
343     tbm.add(new Separator());
344     tbm.add(relaunchSessionAction);
345     tbm.add(new Separator());
346     tbm.add(removeActiveSessionAction);
347     tbm.add(removeAllSessionsAction);
348     tbm.add(mergeSessionsAction);
349     tbm.add(selectSessionAction);
350     tbm.add(new Separator());
351     tbm.add(new CollapseAllAction(viewer));
352     tbm.add(new LinkWithSelectionAction(settings, selectiontracker));
353     
354     IMenuManager mm = getViewSite().getActionBars().getMenuManager();
355     mm.add(new SelectEntryModeAction(ViewSettings.ENTRYMODE_PROJECTS, settings, this));
356     mm.add(new SelectEntryModeAction(ViewSettings.ENTRYMODE_PACKAGEROOTS, settings, this));
357     mm.add(new SelectEntryModeAction(ViewSettings.ENTRYMODE_PACKAGES, settings, this));
358     mm.add(new SelectEntryModeAction(ViewSettings.ENTRYMODE_TYPES, settings, this));
359     mm.add(new Separator());
360     mm.add(new SelectCounterModeAction(0, settings, this));
361     mm.add(new SelectCounterModeAction(1, settings, this));
362     mm.add(new SelectCounterModeAction(2, settings, this));
363     mm.add(new SelectCounterModeAction(3, settings, this));
364     mm.add(new SelectCounterModeAction(4, settings, this));
365     mm.add(new Separator());
366     mm.add(new HideUnusedTypesAction(settings, this));
367     mm.add(new Separator());
368     mm.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
369   }
370   
371   public void configureContextMenu(IMenuManager mm) {
372     mm.add(openAction);
373     mm.add(new Separator());
374     mm.add(importAction);
375     mm.add(exportAction);
376     mm.add(new Separator());
377     mm.add(refreshAction);
378     mm.add(new Separator(IContextMenuConstants.GROUP_ADDITIONS));
379     mm.add(propertiesAction);
380   }
381
382   public void setFocus() {
383     tree.setFocus();
384   }
385
386   public void dispose() {
387     CoverageTools.removeJavaCoverageListener(coverageListener);
388     CoverageTools.getSessionManager().removeSessionListener(listener);
389     selectiontracker.dispose();
390     super.dispose();
391   }
392   
393   protected void updateColumnHeaders() {
394     String JavaDoc[] columns = settings.getCounterMode().getColumnHeaders();
395     column0.setText(columns[0]);
396     column1.setText(columns[1]);
397     column2.setText(columns[2]);
398     column3.setText(columns[3]);
399   }
400   
401   protected void updateActions() {
402     tree.getDisplay().asyncExec(new Runnable JavaDoc() {
403       public void run() {
404         ICoverageSession active = CoverageTools.getSessionManager().getActiveSession();
405         setContentDescription(active == null ? "" : active.getDescription()); //$NON-NLS-1$
406
relaunchSessionAction.setEnabled(active != null && active.getLaunchConfiguration() != null);
407         ICoverageSession[] sessions = CoverageTools.getSessionManager().getSessions();
408         boolean atLeastOne = sessions.length >= 1;
409         removeActiveSessionAction.setEnabled(atLeastOne);
410         removeAllSessionsAction.setEnabled(atLeastOne);
411         exportAction.setEnabled(atLeastOne);
412         refreshAction.setEnabled(atLeastOne);
413         selectSessionAction.setEnabled(atLeastOne);
414         boolean atLeastTwo = sessions.length >= 2;
415         mergeSessionsAction.setEnabled(atLeastTwo);
416       }
417     });
418   }
419
420   protected void refreshViewer() {
421     viewer.refresh();
422   }
423   
424 }
425
Popular Tags