001: /*******************************************************************************
002: * Copyright (c) 2007 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: ******************************************************************************/package org.eclipse.ui.internal.provisional.views.markers;
011:
012: import java.util.ArrayList;
013: import java.util.Collection;
014: import java.util.HashSet;
015: import java.util.Iterator;
016: import java.util.List;
017:
018: import org.eclipse.core.resources.IFile;
019: import org.eclipse.core.resources.IMarker;
020: import org.eclipse.core.resources.IResource;
021: import org.eclipse.core.resources.mapping.ResourceMapping;
022: import org.eclipse.core.runtime.CoreException;
023: import org.eclipse.core.runtime.IAdaptable;
024: import org.eclipse.core.runtime.IProgressMonitor;
025: import org.eclipse.core.runtime.IStatus;
026: import org.eclipse.core.runtime.Status;
027: import org.eclipse.core.runtime.jobs.Job;
028: import org.eclipse.help.IContext;
029: import org.eclipse.help.IContextProvider;
030: import org.eclipse.jface.action.MenuManager;
031: import org.eclipse.jface.util.OpenStrategy;
032: import org.eclipse.jface.viewers.ColumnWeightData;
033: import org.eclipse.jface.viewers.ILazyTreeContentProvider;
034: import org.eclipse.jface.viewers.IOpenListener;
035: import org.eclipse.jface.viewers.ISelection;
036: import org.eclipse.jface.viewers.IStructuredSelection;
037: import org.eclipse.jface.viewers.OpenEvent;
038: import org.eclipse.jface.viewers.StructuredSelection;
039: import org.eclipse.jface.viewers.TableLayout;
040: import org.eclipse.jface.viewers.TreeViewer;
041: import org.eclipse.jface.viewers.TreeViewerColumn;
042: import org.eclipse.jface.viewers.Viewer;
043: import org.eclipse.jface.window.SameShellProvider;
044: import org.eclipse.jface.window.Window;
045: import org.eclipse.osgi.util.NLS;
046: import org.eclipse.swt.SWT;
047: import org.eclipse.swt.dnd.Clipboard;
048: import org.eclipse.swt.events.HelpEvent;
049: import org.eclipse.swt.events.HelpListener;
050: import org.eclipse.swt.events.TreeAdapter;
051: import org.eclipse.swt.events.TreeEvent;
052: import org.eclipse.swt.layout.FillLayout;
053: import org.eclipse.swt.widgets.Composite;
054: import org.eclipse.swt.widgets.Control;
055: import org.eclipse.swt.widgets.Menu;
056: import org.eclipse.swt.widgets.ScrollBar;
057: import org.eclipse.swt.widgets.Scrollable;
058: import org.eclipse.swt.widgets.Tree;
059: import org.eclipse.swt.widgets.TreeColumn;
060: import org.eclipse.ui.IEditorInput;
061: import org.eclipse.ui.IEditorPart;
062: import org.eclipse.ui.IMemento;
063: import org.eclipse.ui.ISelectionListener;
064: import org.eclipse.ui.IViewSite;
065: import org.eclipse.ui.IWorkbenchPage;
066: import org.eclipse.ui.IWorkbenchPart;
067: import org.eclipse.ui.PartInitException;
068: import org.eclipse.ui.PlatformUI;
069: import org.eclipse.ui.ide.IDE;
070: import org.eclipse.ui.ide.ResourceUtil;
071: import org.eclipse.ui.internal.ide.StatusUtil;
072: import org.eclipse.ui.internal.provisional.views.markers.api.MarkerField;
073: import org.eclipse.ui.internal.provisional.views.markers.api.MarkerItem;
074: import org.eclipse.ui.internal.provisional.views.markers.api.MarkerSupportConstants;
075: import org.eclipse.ui.part.ViewPart;
076: import org.eclipse.ui.progress.IWorkbenchSiteProgressService;
077: import org.eclipse.ui.progress.WorkbenchJob;
078: import org.eclipse.ui.statushandlers.StatusManager;
079: import org.eclipse.ui.views.markers.internal.MarkerGroup;
080: import org.eclipse.ui.views.markers.internal.MarkerMessages;
081: import org.eclipse.ui.views.markers.internal.MarkerSupportRegistry;
082: import org.eclipse.ui.views.tasklist.ITaskListResourceAdapter;
083:
084: /**
085: * The ExtendedMarkersView is the view that shows markers using the
086: * markerGenerators extension point.
087: *
088: * @since 3.4
089: *
090: */
091: public class ExtendedMarkersView extends ViewPart {
092:
093: /**
094: * MarkerSelectionEntry is a cache of the values for a marker entry.
095: *
096: * @since 3.4
097: *
098: */
099: final class MarkerSelectionEntry {
100:
101: Object[] cachedValues;
102:
103: MarkerSelectionEntry(MarkerItem item) {
104: MarkerField[] fields = builder.getGenerator()
105: .getVisibleFields();
106: cachedValues = new Object[fields.length];
107: for (int i = 0; i < fields.length; i++) {
108: cachedValues[i] = fields[i].getValue(item);
109: }
110: }
111:
112: /**
113: * Return whether or not the entry is equivalent to the cached state.
114: *
115: * @param item
116: * @return boolean <code>true</code> if they are equivalent
117: */
118: boolean isEquivalentTo(MarkerItem item) {
119: MarkerField[] fields = builder.getGenerator()
120: .getVisibleFields();
121:
122: if (cachedValues.length != fields.length)
123: return false;
124:
125: for (int i = 0; i < fields.length; i++) {
126: if (cachedValues[i] == fields[i].getValue(item))
127: continue;
128: return false;
129: }
130: return true;
131: }
132:
133: }
134:
135: private static int instanceCount = 0;
136: private static final String TAG_GENERATOR = "markerContentGenerator"; //$NON-NLS-1$
137: private static final String TAG_HORIZONTAL_POSITION = "horizontalPosition"; //$NON-NLS-1$
138: private static final String TAG_VERTICAL_POSITION = "verticalPosition"; //$NON-NLS-1$
139:
140: /**
141: * Return the next secondary id.
142: *
143: * @return String
144: */
145: static String newSecondaryID() {
146: return String.valueOf(instanceCount);
147: }
148:
149: /**
150: * Open the supplied marker in an editor in page
151: *
152: * @param marker
153: * @param page
154: */
155: public static void openMarkerInEditor(IMarker marker,
156: IWorkbenchPage page) {
157: // optimization: if the active editor has the same input as
158: // the
159: // selected marker then
160: // RevealMarkerAction would have been run and we only need
161: // to
162: // activate the editor
163: IEditorPart editor = page.getActiveEditor();
164: if (editor != null) {
165: IEditorInput input = editor.getEditorInput();
166: IFile file = ResourceUtil.getFile(input);
167: if (file != null) {
168: if (marker.getResource().equals(file)) {
169: page.activate(editor);
170: }
171: }
172: }
173:
174: if (marker.getResource() instanceof IFile) {
175: try {
176: IDE.openEditor(page, marker, OpenStrategy
177: .activateOnOpen());
178: } catch (PartInitException e) {
179:
180: // Check for a nested CoreException
181: IStatus status = e.getStatus();
182: if (status != null
183: && status.getException() instanceof CoreException) {
184: status = ((CoreException) status.getException())
185: .getStatus();
186: }
187:
188: if (status == null)
189: StatusManager.getManager().handle(
190: StatusUtil.newStatus(IStatus.ERROR, e
191: .getMessage(), e),
192: StatusManager.SHOW);
193:
194: else
195: StatusManager.getManager().handle(status,
196: StatusManager.SHOW);
197:
198: }
199: }
200: }
201:
202: private CachedMarkerBuilder builder;
203: Collection categoriesToExpand = new HashSet();
204: private Clipboard clipboard;
205:
206: Collection preservedSelection = new ArrayList();
207:
208: private MarkerState state;
209: private Job updateJob;
210:
211: private TreeViewer viewer;
212:
213: /**
214: * Return a new instance of the receiver.
215: */
216: public ExtendedMarkersView() {
217: super ();
218: instanceCount++;
219: }
220:
221: /**
222: * Add the category to the list of expanded categories.
223: *
224: * @param category
225: */
226: public void addExpandedCategory(MarkerCategory category) {
227: categoriesToExpand.add(category.getName());
228:
229: }
230:
231: /**
232: * Create the columns for the receiver.
233: *
234: * @param currentColumns
235: * the columns to refresh
236: */
237: private void createColumns(TreeColumn[] currentColumns) {
238:
239: Tree tree = viewer.getTree();
240: TableLayout layout = new TableLayout();
241:
242: MarkerField[] fields = builder.getGenerator()
243: .getVisibleFields();
244: int totalWeight = 0;
245: for (int i = 0; i < fields.length; i++) {
246: totalWeight += fields[i].getColumnWeight();
247: }
248:
249: // Scale the percentages based on weight
250: float multiplier = 100 / totalWeight;
251:
252: for (int i = 0; i < fields.length; i++) {
253: MarkerField markerField = fields[i];
254: layout.addColumnData(new ColumnWeightData(
255: (int) (markerField.getColumnWeight() * multiplier),
256: true));
257: TreeViewerColumn column;
258: if (i < currentColumns.length)
259: column = new TreeViewerColumn(viewer, currentColumns[i]);
260: else
261: column = new TreeViewerColumn(viewer, SWT.NONE);
262: //Show the help in the first column
263: column.setLabelProvider(new MarkerColumnLabelProvider(
264: markerField, i == 0));
265: column.getColumn().setText(
266: markerField.getColumnHeaderText());
267: if (state.isPrimarySortField(markerField))
268: updateDirectionIndicator(column.getColumn(),
269: markerField);
270: }
271:
272: // Remove extra columns
273: if (currentColumns.length > fields.length) {
274: for (int i = fields.length; i < currentColumns.length; i++) {
275: currentColumns[i].dispose();
276:
277: }
278: }
279:
280: viewer.getTree().setLayout(layout);
281: tree.setLinesVisible(true);
282: tree.setHeaderVisible(true);
283: tree.layout(true);
284:
285: }
286:
287: /*
288: * (non-Javadoc)
289: *
290: * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)
291: */
292: public void createPartControl(Composite parent) {
293: parent.setLayout(new FillLayout());
294:
295: viewer = new MarkersTreeViewer(new Tree(parent, SWT.H_SCROLL
296: | SWT.V_SCROLL | SWT.MULTI | SWT.FULL_SELECTION
297: | SWT.VIRTUAL));
298: viewer.getTree().setLinesVisible(true);
299: viewer.setUseHashlookup(true);
300:
301: createColumns(new TreeColumn[0]);
302:
303: viewer.setContentProvider(getContentProvider(viewer));
304: viewer.getTree().setItemCount(builder.getElements().length);
305:
306: viewer.setInput(builder);
307:
308: Scrollable scrollable = (Scrollable) viewer.getControl();
309: ScrollBar bar = scrollable.getVerticalBar();
310: if (bar != null) {
311: bar.setSelection(getIntValue(TAG_VERTICAL_POSITION));
312: }
313: bar = scrollable.getHorizontalBar();
314: if (bar != null) {
315: bar.setSelection(getIntValue(TAG_HORIZONTAL_POSITION));
316: }
317:
318: getSite().setSelectionProvider(viewer);
319:
320: // Initialise any selection based filtering
321: ISelectionListener listener = getPageSelectionListener();
322: getSite().getPage().addSelectionListener(listener);
323: listener.selectionChanged(getSite().getPage().getActivePart(),
324: getSite().getPage().getSelection());
325:
326: viewer.addOpenListener(new IOpenListener() {
327: public void open(OpenEvent event) {
328: openSelectedMarkers();
329: }
330:
331: });
332:
333: viewer.getTree().addTreeListener(new TreeAdapter() {
334: /*
335: * (non-Javadoc)
336: *
337: * @see org.eclipse.swt.events.TreeAdapter#treeCollapsed(org.eclipse.swt.events.TreeEvent)
338: */
339: public void treeCollapsed(TreeEvent e) {
340: removeExpandedCategory((MarkerCategory) e.item
341: .getData());
342: }
343:
344: /*
345: * (non-Javadoc)
346: *
347: * @see org.eclipse.swt.events.TreeAdapter#treeExpanded(org.eclipse.swt.events.TreeEvent)
348: */
349: public void treeExpanded(TreeEvent e) {
350: addExpandedCategory((MarkerCategory) e.item.getData());
351: }
352: });
353:
354: // Set help on the view itself
355: viewer.getControl().addHelpListener(new HelpListener() {
356: /*
357: * (non-Javadoc)
358: *
359: * @see org.eclipse.swt.events.HelpListener#helpRequested(org.eclipse.swt.events.HelpEvent)
360: */
361: public void helpRequested(HelpEvent e) {
362: Object provider = getAdapter(IContextProvider.class);
363: if (provider == null)
364: return;
365:
366: IContext context = ((IContextProvider) provider)
367: .getContext(viewer.getControl());
368: PlatformUI.getWorkbench().getHelpSystem().displayHelp(
369: context);
370: }
371:
372: });
373:
374: registerContextMenu();
375: }
376:
377: /*
378: * (non-Javadoc)
379: *
380: * @see org.eclipse.ui.part.WorkbenchPart#dispose()
381: */
382: public void dispose() {
383: super .dispose();
384: updateJob.cancel();
385: instanceCount--;
386: if (clipboard != null)
387: clipboard.dispose();
388: }
389:
390: /**
391: * Get all of the filters for the receiver.
392: *
393: * @return Collection of {@link MarkerFieldFilterGroup}
394: */
395: public Collection getAllFilters() {
396: return builder.getGenerator().getAllFilters();
397: }
398:
399: /**
400: * Return the group used for categorisation.
401: * @return MarkerGroup
402: */
403: MarkerGroup getCategoryGroup() {
404: return builder.getCategoryGroup();
405: }
406:
407: /**
408: * Return the clipboard for the receiver.
409: *
410: * @return Clipboard
411: */
412: Clipboard getClipboard() {
413: if (clipboard == null)
414: clipboard = new Clipboard(viewer.getControl().getDisplay());
415: return clipboard;
416: }
417:
418: /**
419: * Return the content provider for the receiver.
420: *
421: * @return ILazyTreeContentProvider
422: */
423: private ILazyTreeContentProvider getContentProvider(
424: final TreeViewer viewer) {
425: return new ILazyTreeContentProvider() {
426:
427: /*
428: * (non-Javadoc)
429: *
430: * @see org.eclipse.jface.viewers.IContentProvider#dispose()
431: */
432: public void dispose() {
433:
434: }
435:
436: /*
437: * (non-Javadoc)
438: *
439: * @see org.eclipse.jface.viewers.ILazyTreeContentProvider#getParent(java.lang.Object)
440: */
441: public Object getParent(Object element) {
442: Object parent = ((MarkerItem) element).getParent();
443: if (parent == null)
444: return builder;
445: return parent;
446: }
447:
448: /*
449: * (non-Javadoc)
450: *
451: * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,
452: * java.lang.Object, java.lang.Object)
453: */
454: public void inputChanged(Viewer viewer, Object oldInput,
455: Object newInput) {
456:
457: }
458:
459: /*
460: * (non-Javadoc)
461: *
462: * @see org.eclipse.jface.viewers.ILazyTreeContentProvider#updateChildCount(java.lang.Object,
463: * int)
464: */
465: public void updateChildCount(Object element,
466: int currentChildCount) {
467:
468: MarkerItem[] children;
469:
470: if (element instanceof MarkerItem) {
471: MarkerItem item = (MarkerItem) element;
472: children = item.getChildren();
473:
474: } else {
475: // If it is not a MarkerItem it is the root
476: CachedMarkerBuilder builder = (CachedMarkerBuilder) element;
477: children = builder.getElements();
478: }
479:
480: // No updates if it hasn't changed
481: if (children.length == currentChildCount)
482: return;
483: viewer.setChildCount(element, children.length);
484:
485: }
486:
487: /*
488: * (non-Javadoc)
489: *
490: * @see org.eclipse.jface.viewers.ILazyTreeContentProvider#updateElement(java.lang.Object,
491: * int)
492: */
493: public void updateElement(Object parent, int index) {
494: Object newItem;
495:
496: if (parent instanceof MarkerItem)
497: newItem = ((MarkerItem) parent).getChildren()[index];
498: else
499: newItem = ((CachedMarkerBuilder) parent)
500: .getElements()[index];
501:
502: viewer.replace(parent, index, newItem);
503: updateChildCount(newItem, -1);
504:
505: if (newItem instanceof MarkerCategory) {
506: viewer.expandToLevel(newItem, 1);
507: }
508:
509: }
510: };
511: }
512:
513: /**
514: * Get the int value for the tag.
515: *
516: * @param tag
517: * @return int
518: */
519: private int getIntValue(String tag) {
520: if (state.useDefaults())
521: return 0;
522:
523: Integer intValue = state.getInteger(tag);
524: return (intValue == null) ? 0 : intValue.intValue();
525: }
526:
527: /**
528: * Return the selection listener for the page selection change.
529: *
530: * @return ISelectionListener
531: */
532: private ISelectionListener getPageSelectionListener() {
533: return new ISelectionListener() {
534: /**
535: * Get an ITaskListResourceAdapter for use by the default/
536: *
537: * @return ITaskListResourceAdapter
538: */
539: private ITaskListResourceAdapter getDefaultTaskListAdapter() {
540: return new ITaskListResourceAdapter() {
541:
542: /*
543: * (non-Javadoc)
544: *
545: * @see org.eclipse.ui.views.tasklist.ITaskListResourceAdapter#getAffectedResource(org.eclipse.core.runtime.IAdaptable)
546: */
547: public IResource getAffectedResource(
548: IAdaptable adaptable) {
549: Object resource = adaptable
550: .getAdapter(IResource.class);
551: if (resource == null)
552: resource = adaptable
553: .getAdapter(IFile.class);
554: if (resource == null)
555: return null;
556: return (IResource) resource;
557:
558: }
559:
560: };
561: }
562:
563: /*
564: * (non-Javadoc)
565: *
566: * @see org.eclipse.ui.ISelectionListener#selectionChanged(org.eclipse.ui.IWorkbenchPart,
567: * org.eclipse.jface.viewers.ISelection)
568: */
569: public void selectionChanged(IWorkbenchPart part,
570: ISelection selection) {
571:
572: List selectedElements = new ArrayList();
573: if (part instanceof IEditorPart) {
574: IEditorPart editor = (IEditorPart) part;
575: IFile file = ResourceUtil.getFile(editor
576: .getEditorInput());
577: if (file == null) {
578: IEditorInput editorInput = editor
579: .getEditorInput();
580: if (editorInput != null) {
581: Object mapping = editorInput
582: .getAdapter(ResourceMapping.class);
583: if (mapping != null) {
584: selectedElements.add(mapping);
585: }
586: }
587: } else {
588: selectedElements.add(file);
589: }
590: } else {
591: if (selection instanceof IStructuredSelection) {
592: for (Iterator iterator = ((IStructuredSelection) selection)
593: .iterator(); iterator.hasNext();) {
594: Object object = iterator.next();
595: if (object instanceof IAdaptable) {
596: ITaskListResourceAdapter taskListResourceAdapter;
597: Object adapter = ((IAdaptable) object)
598: .getAdapter(ITaskListResourceAdapter.class);
599: if (adapter != null
600: && adapter instanceof ITaskListResourceAdapter) {
601: taskListResourceAdapter = (ITaskListResourceAdapter) adapter;
602: } else {
603: taskListResourceAdapter = getDefaultTaskListAdapter();
604: }
605:
606: IResource resource = taskListResourceAdapter
607: .getAffectedResource((IAdaptable) object);
608: if (resource == null) {
609: Object mapping = ((IAdaptable) object)
610: .getAdapter(ResourceMapping.class);
611: if (mapping != null) {
612: selectedElements.add(mapping);
613: }
614: } else {
615: selectedElements.add(resource);
616: }
617: }
618: }
619: }
620: }
621: builder.updateForNewSelection(selectedElements
622: .toArray());
623: }
624:
625: };
626: }
627:
628: /**
629: * Return all of the markers in the current selection
630: *
631: * @return Array of {@link IMarker}
632: */
633: protected IMarker[] getSelectedMarkers() {
634: ISelection selection = getSite().getSelectionProvider()
635: .getSelection();
636: if (selection instanceof IStructuredSelection) {
637: IStructuredSelection structured = (IStructuredSelection) selection;
638: Iterator elements = structured.iterator();
639: Collection result = new ArrayList();
640: while (elements.hasNext()) {
641: MarkerItem next = (MarkerItem) elements.next();
642: if (next.isConcrete())
643: result.add(((MarkerEntry) next).getMarker());
644: }
645: if (result.isEmpty())
646: return MarkerSupportInternalUtilities.EMPTY_MARKER_ARRAY;
647: IMarker[] markers = new IMarker[result.size()];
648: result.toArray(markers);
649: return markers;
650: }
651: return MarkerSupportInternalUtilities.EMPTY_MARKER_ARRAY;
652:
653: }
654:
655: /**
656: * Return a job for updating the receiver.
657: *
658: * @return Job
659: */
660: private Job getUpdateJob(final CachedMarkerBuilder builder) {
661: updateJob = new WorkbenchJob(
662: MarkerMessages.MarkerView_queueing_updates) {
663:
664: /*
665: * (non-Javadoc)
666: *
667: * @see org.eclipse.core.runtime.jobs.Job#belongsTo(java.lang.Object)
668: */
669: public boolean belongsTo(Object family) {
670: return family == MarkerContentGenerator.CACHE_UPDATE_FAMILY;
671: }
672:
673: /**
674: * Return the viewer that is being updated.
675: *
676: * @return TreeViewer
677: */
678: private TreeViewer getViewer() {
679:
680: return viewer;
681: }
682:
683: /*
684: * (non-Javadoc)
685: *
686: * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)
687: */
688: public IStatus runInUIThread(IProgressMonitor monitor) {
689:
690: if (viewer.getControl().isDisposed()) {
691: return Status.CANCEL_STATUS;
692: }
693:
694: if (monitor.isCanceled())
695: return Status.CANCEL_STATUS;
696:
697: getViewer().refresh(true);
698:
699: updateTitle();
700:
701: if (preservedSelection.size() > 0) {
702:
703: Collection newSelection = new ArrayList();
704: MarkerItem[] markerEntries = builder
705: .getVisibleMarkers().toArray();
706:
707: for (int i = 0; i < markerEntries.length; i++) {
708: Iterator preserved = preservedSelection
709: .iterator();
710: while (preserved.hasNext()) {
711: MarkerSelectionEntry next = (MarkerSelectionEntry) preserved
712: .next();
713: if (next.isEquivalentTo(markerEntries[i])) {
714: newSelection.add(markerEntries[i]);
715: continue;
716: }
717: }
718: }
719:
720: getViewer().setSelection(
721: new StructuredSelection(newSelection
722: .toArray()), true);
723: preservedSelection.clear();
724: }
725: if (getViewer().getTree().getItemCount() > 0)
726: getViewer().getTree().setTopItem(
727: getViewer().getTree().getItem(0));
728:
729: return Status.OK_STATUS;
730: }
731:
732: /*
733: * (non-Javadoc)
734: *
735: * @see org.eclipse.ui.progress.WorkbenchJob#shouldRun()
736: */
737: public boolean shouldRun() {
738: return !builder.isBuilding();
739: }
740:
741: };
742:
743: updateJob.setSystem(true);
744: return updateJob;
745: }
746:
747: /**
748: * Return the object that is the input to the viewer.
749: *
750: * @return Object
751: */
752: Object getViewerInput() {
753: return viewer.getInput();
754: }
755:
756: /**
757: * Get all of the fields visible in the receiver.
758: *
759: * @return MarkerField[]
760: */
761: public MarkerField[] getVisibleFields() {
762: return builder.getGenerator().getVisibleFields();
763: }
764:
765: /*
766: * (non-Javadoc)
767: *
768: * @see org.eclipse.ui.part.ViewPart#init(org.eclipse.ui.IViewSite,
769: * org.eclipse.ui.IMemento)
770: */
771: public void init(IViewSite site, IMemento memento)
772: throws PartInitException {
773: super .init(site, memento);
774: MarkerContentGenerator generator = null;
775:
776: if (memento != null) {
777: generator = MarkerSupportRegistry.getInstance()
778: .getGenerator(memento.getID());
779: }
780: if (generator == null)
781: generator = MarkerSupportRegistry.getInstance()
782: .generatorFor(site.getPage().getPerspective());
783: builder = new CachedMarkerBuilder(generator);
784: builder.setUpdateJob(getUpdateJob(builder));
785: Object service = site
786: .getAdapter(IWorkbenchSiteProgressService.class);
787: if (service != null)
788: builder
789: .setProgressService((IWorkbenchSiteProgressService) service);
790: state = new MarkerState(memento);
791: setPartName(generator.getName());
792: }
793:
794: /**
795: * Return whether or not group is enabled.
796: *
797: * @param group
798: * @return boolean
799: */
800: public boolean isEnabled(MarkerFieldFilterGroup group) {
801: return builder.getGenerator().getEnabledFilters().contains(
802: group);
803: }
804:
805: /**
806: * Return whether or not generator is the selected one.
807: *
808: * @param generator
809: * @return boolean
810: */
811: public boolean isShowing(MarkerContentGenerator generator) {
812: return this .builder.getGenerator().equals(generator);
813: }
814:
815: /**
816: * Open the filters dialog for the receiver.
817: */
818: public void openFiltersDialog() {
819: FiltersConfigurationDialog dialog = new FiltersConfigurationDialog(
820: new SameShellProvider(getSite().getWorkbenchWindow()
821: .getShell()), builder.getGenerator()
822: .getAllFilters(), builder.getGenerator()
823: .getFilterConfigurationFields());
824: if (dialog.open() == Window.OK)
825: builder.setFilters(dialog.getFilters());
826:
827: }
828:
829: /**
830: * Open the selected markers
831: */
832: void openSelectedMarkers() {
833: IMarker[] markers = getSelectedMarkers();
834: for (int i = 0; i < markers.length; i++) {
835: IMarker marker = markers[i];
836: IWorkbenchPage page = getSite().getPage();
837:
838: openMarkerInEditor(marker, page);
839: }
840: }
841:
842: /**
843: * Register the context menu for the receiver so that commands may be added
844: * to it.
845: */
846: private void registerContextMenu() {
847: MenuManager contextMenu = new MenuManager();
848: getSite().registerContextMenu(contextMenu, viewer);
849: Control control = viewer.getControl();
850: Menu menu = contextMenu.createContextMenu(control);
851: control.setMenu(menu);
852: }
853:
854: /**
855: * Remove the category from the list of expanded ones.
856: *
857: * @param category
858: */
859: public void removeExpandedCategory(MarkerCategory category) {
860: categoriesToExpand.remove(category.getName());
861:
862: }
863:
864: /**
865: * Preserve the selection for re-selection after the next update.
866: *
867: * @param selection
868: */
869: public void saveSelection(ISelection selection) {
870: preservedSelection.clear();
871: if (selection instanceof IStructuredSelection) {
872: IStructuredSelection structured = (IStructuredSelection) selection;
873: Iterator iterator = structured.iterator();
874: while (iterator.hasNext()) {
875: MarkerItem next = (MarkerItem) iterator.next();
876: if (next.isConcrete()) {
877: preservedSelection.add(new MarkerSelectionEntry(
878: next));
879: }
880: }
881: }
882:
883: }
884:
885: /*
886: * (non-Javadoc)
887: *
888: * @see org.eclipse.ui.part.ViewPart#saveState(org.eclipse.ui.IMemento)
889: */
890: public void saveState(IMemento memento) {
891: super .saveState(memento);
892: memento.createChild(TAG_GENERATOR, builder.generator.getId());
893: }
894:
895: /**
896: * Select all of the elements in the receiver.
897: */
898: void selectAll() {
899: viewer.getTree().selectAll();
900:
901: }
902:
903: /**
904: * Set the category group for the receiver.
905: * @param group
906: */
907: void setCategoryGroup(MarkerGroup group) {
908: builder.setCategoryGroup(group);
909: }
910:
911: /**
912: * Set the content generator for the receiver.
913: *
914: * @param generator
915: */
916: public void setContentGenerator(MarkerContentGenerator generator) {
917: builder.setGenerator(generator);
918: createColumns(viewer.getTree().getColumns());
919: setPartName(generator.getName());
920: }
921:
922: /*
923: * (non-Javadoc)
924: *
925: * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
926: */
927: public void setFocus() {
928: // Do nothing by default
929:
930: }
931:
932: /**
933: * Add group to the enabled filters.
934: *
935: * @param group
936: */
937: public void toggleFilter(MarkerFieldFilterGroup group) {
938: builder.toggleFilter(group);
939:
940: }
941:
942: /**
943: * Update the direction indicator as column is now the primary column.
944: *
945: * @param column
946: * @field {@link MarkerField}
947: */
948: void updateDirectionIndicator(TreeColumn column, MarkerField field) {
949: viewer.getTree().setSortColumn(column);
950: if (state.getSortDirection(field) == MarkerField.ASCENDING)
951: viewer.getTree().setSortDirection(SWT.UP);
952: else
953: viewer.getTree().setSortDirection(SWT.DOWN);
954: }
955:
956: /**
957: * Update the title of the view.
958: */
959: protected void updateTitle() {
960:
961: String status = MarkerSupportConstants.EMPTY_STRING;
962: int filteredCount = builder.getVisibleMarkers().getSize();
963: int totalCount = builder.getTotalMarkerCount();
964: if (filteredCount == totalCount) {
965: status = NLS.bind(MarkerMessages.filter_itemsMessage,
966: new Integer(totalCount));
967: } else {
968: status = NLS
969: .bind(MarkerMessages.filter_matchedMessage,
970: new Integer(filteredCount), new Integer(
971: totalCount));
972: }
973: setContentDescription(status);
974:
975: }
976:
977: }
|