Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2008 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package org.eclipse.ui.views.markers.internal; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.SubProgressMonitor; import org.eclipse.jface.viewers.ViewerComparator; import org.eclipse.osgi.util.NLS; import org.eclipse.ui.internal.ide.Policy; /** * The MarkerAdapter is the adapter for the deferred update of markers. * * @since 3.1 * */ public class MarkerAdapter { class MarkerCategory extends MarkerNode { MarkerAdapter markerAdapter; int start; int end; private ConcreteMarker[] children; private String name; /** * Create a new instance of the receiver that has the markers between * startIndex and endIndex showing. * * @param adapter * @param startIndex * @param endIndex */ MarkerCategory(MarkerAdapter adapter, int startIndex, int endIndex, String categoryName) { markerAdapter = adapter; start = startIndex; end = endIndex; name = categoryName; } /* * (non-Javadoc) * * @see org.eclipse.ui.views.markers.internal.MarkerNode#getChildren() */ public MarkerNode[] getChildren() { if (children == null) { // Return nothing while a build is going on as this could be // stale if (building) { return Util.EMPTY_MARKER_ARRAY; } ConcreteMarker[] allMarkers = markerAdapter.lastMarkers.toArray(); int totalSize = getDisplayedSize(); children = new ConcreteMarker[totalSize]; System.arraycopy(allMarkers, start, children, 0, totalSize); // Sort them locally now view.getTableSorter().sort(view.getViewer(), children); for (int i = 0; i < children.length; i++) { children[i].setCategory(this); } } return children; } /** * Return the number of errors being displayed. * * @return int */ int getDisplayedSize() { if (view.getMarkerLimit() > 0) { return Math.min(getTotalSize(), view.getMarkerLimit()); } return getTotalSize(); } /* * (non-Javadoc) * * @see org.eclipse.ui.views.markers.internal.MarkerNode#getParent() */ public MarkerNode getParent() { return null; } /* * (non-Javadoc) * * @see org.eclipse.ui.views.markers.internal.MarkerNode#getDescription() */ public String getDescription() { int size = end - start + 1; if (size <= view.getMarkerLimit()) { if (size == 1) return NLS.bind(MarkerMessages.Category_One_Item_Label, new Object[] { name }); return NLS.bind(MarkerMessages.Category_Label, new Object[] { name, String.valueOf(getDisplayedSize()) }); } return NLS.bind(MarkerMessages.Category_Limit_Label, new Object[] { name, String.valueOf(getDisplayedSize()), String.valueOf(getTotalSize()) }); } /** * Get the total size of the receiver. * * @return int */ private int getTotalSize() { return end - start + 1; } /* * (non-Javadoc) * * @see org.eclipse.ui.views.markers.internal.MarkerNode#isConcrete() */ public boolean isConcrete() { return false; } /* * (non-Javadoc) * * @see org.eclipse.ui.views.markers.internal.MarkerNode#getConcreteRepresentative() */ public ConcreteMarker getConcreteRepresentative() { return markerAdapter.lastMarkers.getMarker(start); } /** * Return the name of the receiver. * * @return String */ public String getName() { return name; } } MarkerView view; private MarkerList lastMarkers; private MarkerCategory[] categories; private boolean building = true;// Start with nothing until we have // something /** * Create a new instance of the receiver. * * @param markerView */ MarkerAdapter(MarkerView markerView) { view = markerView; } /** * Return the category sorter for the receiver. This should only be called * in hierarchal mode or there will be a ClassCastException. * * @return CategorySorter */ public CategoryComparator getCategorySorter() { return (CategoryComparator) view.getViewer().getComparator(); } /** * Build all of the markers in the receiver. * * @param collector * @param monitor */ public void buildAllMarkers(IProgressMonitor monitor) { building = true; MarkerList newMarkers; try { int markerLimit = view.getMarkerLimit(); monitor.beginTask(MarkerMessages.MarkerView_19, markerLimit == -1 ? 60 : 100); try { monitor.subTask(MarkerMessages.MarkerView_waiting_on_changes); if (monitor.isCanceled()) return; monitor.subTask(MarkerMessages.MarkerView_searching_for_markers); SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 10); MarkerFilter[] filters = view.getEnabledFilters(); if (filters.length > 0) newMarkers = MarkerList.compute(filters, subMonitor, true); else // Grab any filter as a disabled filter gives all of them newMarkers = MarkerList.compute(new MarkerFilter[] { view.getAllFilters()[0] }, subMonitor, true); if (monitor.isCanceled()) return; view.refreshMarkerCounts(monitor); } catch (CoreException e) { Policy.handle(e); newMarkers = new MarkerList(); return; } if (monitor.isCanceled()) return; ViewerComparator sorter = view.getViewer().getComparator(); if (markerLimit == -1 || isShowingHierarchy()) { sorter.sort(view.getViewer(), newMarkers.toArray()); } else { monitor.subTask(MarkerMessages.MarkerView_18); SubProgressMonitor mon = new SubProgressMonitor(monitor, 40); newMarkers = SortUtil.getFirst(newMarkers, (Comparator) sorter, markerLimit, mon); if (monitor.isCanceled()) return; sorter.sort(view.getViewer(), newMarkers.toArray()); } if (newMarkers.getSize() == 0) { categories = new MarkerCategory[0]; lastMarkers = newMarkers; monitor.done(); return; } monitor.subTask(MarkerMessages.MarkerView_queueing_updates); if (monitor.isCanceled()) return; if (isShowingHierarchy()) { MarkerCategory[] newCategories = buildHierarchy(newMarkers, 0, newMarkers.getSize() - 1, 0); if (monitor.isCanceled()) return; categories = newCategories; } lastMarkers = newMarkers; monitor.done(); } finally { building = false; } } /** * Return whether or not a hierarchy is showing. * * @return boolean */ boolean isShowingHierarchy() { ViewerComparator sorter = view.getViewer().getComparator(); if (sorter instanceof CategoryComparator) { return ((CategoryComparator) sorter).getCategoryField() != null; } return false; } /** * Break the marker up into categories * * @param markers * @param start * the start index in the markers * @param end * the last index to check * @param sortIndex - * the parent of the field * @param parent * @return MarkerCategory[] or <code>null</code> if we are at the bottom * of the tree */ MarkerCategory[] buildHierarchy(MarkerList markers, int start, int end, int sortIndex) { CategoryComparator sorter = getCategorySorter(); if (sortIndex > 0) { return null;// Are we out of categories? } Collection categories = new ArrayList(); Object previous = null; int categoryStart = start; Object[] elements = markers.getArray(); for (int i = start; i <= end; i++) { if (previous != null) { // Are we at a category boundary? if (sorter.compare(previous, elements[i], sortIndex, false) != 0) { categories.add(new MarkerCategory(this, categoryStart, i - 1, getNameForIndex(markers, categoryStart))); categoryStart = i; } } previous = elements[i]; } if (end >= categoryStart) { categories.add(new MarkerCategory(this, categoryStart, end, getNameForIndex(markers, categoryStart))); } // Flatten single categories // if (categories.size() == 1) { // return buildHierarchy(markers, start, end, sortIndex + 1, parent); // } MarkerCategory[] nodes = new MarkerCategory[categories.size()]; categories.toArray(nodes); return nodes; } /** * Get the name for the category from the marker at categoryStart in * markers. * * @param markers * @param categoryStart * @return String */ private String getNameForIndex(MarkerList markers, int categoryStart) { return getCategorySorter().getCategoryField().getValue(markers.toArray()[categoryStart]); } /** * Return the current list of markers. * * @return MarkerList */ public MarkerList getCurrentMarkers() { if (lastMarkers == null) {// First time? view.scheduleMarkerUpdate(Util.SHORT_DELAY); building = true; } if (building) { return new MarkerList(); } return lastMarkers; } /** * Return the elements in the adapter. * * @param root * @return Object[] */ public Object[] getElements() { if (lastMarkers == null) {// First time? view.scheduleMarkerUpdate(Util.SHORT_DELAY); building = true; } if (building) { return Util.EMPTY_MARKER_ARRAY; } if (isShowingHierarchy() && categories != null) { return categories; } return lastMarkers.toArray(); } /** * Return whether or not the receiver has markers without scheduling * anything if it doesn't. * * @return boolean <code>true</code> if the markers have not been * calculated. */ public boolean hasNoMarkers() { return lastMarkers == null; } /** * Return the categories for the receiver. * * @return MarkerCategory[] or <code>null</code> if there are no * categories. */ public MarkerCategory[] getCategories() { if (building) { return null; } return categories; } /** * Return whether or not the receiver is building. * @return boolean */ boolean isBuilding() { return building; } }