]> git.uio.no Git - ifi-stolz-refaktor.git/blame - case-study/jdt-before/ui/org/eclipse/jdt/internal/ui/search/JavaSearchResultPage.java
git://git.uio.no / ifi-stolz-refaktor.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Case Study: adding data and statistics
[ifi-stolz-refaktor.git] / case-study / jdt-before / ui / org / eclipse / jdt / internal / ui / search / JavaSearchResultPage.java
CommitLineData
1b2798f6
EK		 1/*******************************************************************************
2 * Copyright (c) 2000, 2011 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * IBM Corporation - initial API and implementation
10 *******************************************************************************/
11package org.eclipse.jdt.internal.ui.search;
12
13import java.util.HashMap;
14
15import org.eclipse.swt.SWT;
16import org.eclipse.swt.dnd.DND;
17import org.eclipse.swt.dnd.Transfer;
18import org.eclipse.swt.widgets.Composite;
19import org.eclipse.swt.widgets.Item;
20import org.eclipse.swt.widgets.Table;
21import org.eclipse.swt.widgets.Tree;
22
23import org.eclipse.core.runtime.CoreException;
24import org.eclipse.core.runtime.IAdaptable;
25
26import org.eclipse.core.resources.IFile;
27import org.eclipse.core.resources.IMarker;
28import org.eclipse.core.resources.IResource;
29
30import org.eclipse.jface.action.Action;
31import org.eclipse.jface.action.IMenuManager;
32import org.eclipse.jface.action.IToolBarManager;
33import org.eclipse.jface.action.MenuManager;
34import org.eclipse.jface.action.Separator;
35import org.eclipse.jface.viewers.ILabelProvider;
36import org.eclipse.jface.viewers.IStructuredSelection;
37import org.eclipse.jface.viewers.ITreeContentProvider;
38import org.eclipse.jface.viewers.OpenEvent;
39import org.eclipse.jface.viewers.StructuredViewer;
40import org.eclipse.jface.viewers.TableViewer;
41import org.eclipse.jface.viewers.TreeViewer;
42import org.eclipse.jface.viewers.Viewer;
43import org.eclipse.jface.viewers.ViewerComparator;
44
45import org.eclipse.ui.IActionBars;
46import org.eclipse.ui.IEditorPart;
47import org.eclipse.ui.IMemento;
48import org.eclipse.ui.PartInitException;
49import org.eclipse.ui.actions.ActionContext;
50import org.eclipse.ui.dialogs.PreferencesUtil;
51import org.eclipse.ui.ide.IDE;
52import org.eclipse.ui.part.IPageSite;
53import org.eclipse.ui.part.IShowInTargetList;
54import org.eclipse.ui.part.ResourceTransfer;
55import org.eclipse.ui.views.navigator.LocalSelectionTransfer;
56
57import org.eclipse.ui.texteditor.ITextEditor;
58
59import org.eclipse.search.ui.IContextMenuConstants;
60import org.eclipse.search.ui.ISearchResultViewPart;
61import org.eclipse.search.ui.NewSearchUI;
62import org.eclipse.search.ui.text.AbstractTextSearchResult;
63import org.eclipse.search.ui.text.AbstractTextSearchViewPage;
64import org.eclipse.search.ui.text.Match;
65
66import org.eclipse.jdt.core.IClassFile;
67import org.eclipse.jdt.core.ICompilationUnit;
68import org.eclipse.jdt.core.IJavaElement;
69import org.eclipse.jdt.core.IMember;
70
71import org.eclipse.jdt.internal.corext.util.Messages;
72
73import org.eclipse.jdt.ui.JavaUI;
74import org.eclipse.jdt.ui.actions.SelectionDispatchAction;
75import org.eclipse.jdt.ui.search.IMatchPresentation;
76
77import org.eclipse.jdt.internal.ui.JavaPlugin;
78import org.eclipse.jdt.internal.ui.JavaPluginImages;
79import org.eclipse.jdt.internal.ui.actions.CopyQualifiedNameAction;
80import org.eclipse.jdt.internal.ui.dnd.EditorInputTransferDragAdapter;
81import org.eclipse.jdt.internal.ui.dnd.JdtViewerDragAdapter;
82import org.eclipse.jdt.internal.ui.dnd.ResourceTransferDragAdapter;
83import org.eclipse.jdt.internal.ui.packageview.SelectionTransferDragAdapter;
84import org.eclipse.jdt.internal.ui.util.ExceptionHandler;
85import org.eclipse.jdt.internal.ui.viewsupport.DecoratingJavaLabelProvider;
86import org.eclipse.jdt.internal.ui.viewsupport.ProblemTableViewer;
87import org.eclipse.jdt.internal.ui.viewsupport.ProblemTreeViewer;
88
89
90public class JavaSearchResultPage extends AbstractTextSearchViewPage implements IAdaptable {
91
92 public static class DecoratorIgnoringViewerSorter extends ViewerComparator {
93
94 private final ILabelProvider fLabelProvider;
95
96 public DecoratorIgnoringViewerSorter(ILabelProvider labelProvider) {
97 fLabelProvider= labelProvider;
98 }
99
100 @Override
101 public int category(Object element) {
102 if (element instanceof IJavaElement || element instanceof IResource)
103 return 1;
104 return 2;
105 }
106
107
108 @Override
109 public int compare(Viewer viewer, Object e1, Object e2) {
110 int cat1 = category(e1);
111 int cat2 = category(e2);
112
113 if (cat1 != cat2) {
114 return cat1 - cat2;
115 }
116 String name1= fLabelProvider.getText(e1);
117 String name2= fLabelProvider.getText(e2);
118 if (name1 == null)
119 name1 = "";//$NON-NLS-1$
120 if (name2 == null)
121 name2 = "";//$NON-NLS-1$
122 return getComparator().compare(name1, name2);
123 }
124 }
125
126
127 private static final int DEFAULT_ELEMENT_LIMIT = 1000;
128 private static final String FALSE = "FALSE"; //$NON-NLS-1$
129 private static final String TRUE = "TRUE"; //$NON-NLS-1$
130 private static final String KEY_GROUPING= "org.eclipse.jdt.search.resultpage.grouping"; //$NON-NLS-1$
131 private static final String KEY_SORTING= "org.eclipse.jdt.search.resultpage.sorting"; //$NON-NLS-1$
132 private static final String KEY_LIMIT_ENABLED= "org.eclipse.jdt.search.resultpage.limit_enabled"; //$NON-NLS-1$
133 private static final String KEY_LIMIT= "org.eclipse.jdt.search.resultpage.limit"; //$NON-NLS-1$
134
135 private static final String GROUP_GROUPING= "org.eclipse.jdt.search.resultpage.grouping"; //$NON-NLS-1$
136 private static final String GROUP_FILTERING = "org.eclipse.jdt.search.resultpage.filtering"; //$NON-NLS-1$
137
138 private NewSearchViewActionGroup fActionGroup;
139 private JavaSearchContentProvider fContentProvider;
140 private int fCurrentSortOrder;
141 private SortAction fSortByNameAction;
142 private SortAction fSortByParentName;
143 private SortAction fSortByPathAction;
144
145 private GroupAction fGroupTypeAction;
146 private GroupAction fGroupFileAction;
147 private GroupAction fGroupPackageAction;
148 private GroupAction fGroupProjectAction;
149
150 private SelectionDispatchAction fCopyQualifiedNameAction;
151
152 private SortingLabelProvider fSortingLabelProvider;
153
154 private int fCurrentGrouping;
155
156 private static final String[] SHOW_IN_TARGETS= new String[] { JavaUI.ID_PACKAGES , JavaPlugin.ID_RES_NAV };
157 public static final IShowInTargetList SHOW_IN_TARGET_LIST= new IShowInTargetList() {
158 public String[] getShowInTargetIds() {
159 return SHOW_IN_TARGETS;
160 }
161 };
162
163 private JavaSearchEditorOpener fEditorOpener= new JavaSearchEditorOpener();
164
165 public JavaSearchResultPage() {
166 fCopyQualifiedNameAction= null;
167
168 initSortActions();
169 initGroupingActions();
170 setElementLimit(new Integer(DEFAULT_ELEMENT_LIMIT));
171 }
172
173 private void initSortActions() {
174 fSortByNameAction= new SortAction(SearchMessages.JavaSearchResultPage_sortByName, this, SortingLabelProvider.SHOW_ELEMENT_CONTAINER);
175 fSortByPathAction= new SortAction(SearchMessages.JavaSearchResultPage_sortByPath, this, SortingLabelProvider.SHOW_PATH);
176 fSortByParentName= new SortAction(SearchMessages.JavaSearchResultPage_sortByParentName, this, SortingLabelProvider.SHOW_CONTAINER_ELEMENT);
177 }
178
179 private void initGroupingActions() {
180 fGroupProjectAction= new GroupAction(SearchMessages.JavaSearchResultPage_groupby_project, SearchMessages.JavaSearchResultPage_groupby_project_tooltip, this, LevelTreeContentProvider.LEVEL_PROJECT);
181 JavaPluginImages.setLocalImageDescriptors(fGroupProjectAction, "prj_mode.gif"); //$NON-NLS-1$
182 fGroupPackageAction= new GroupAction(SearchMessages.JavaSearchResultPage_groupby_package, SearchMessages.JavaSearchResultPage_groupby_package_tooltip, this, LevelTreeContentProvider.LEVEL_PACKAGE);
183 JavaPluginImages.setLocalImageDescriptors(fGroupPackageAction, "package_mode.gif"); //$NON-NLS-1$
184 fGroupFileAction= new GroupAction(SearchMessages.JavaSearchResultPage_groupby_file, SearchMessages.JavaSearchResultPage_groupby_file_tooltip, this, LevelTreeContentProvider.LEVEL_FILE);
185 JavaPluginImages.setLocalImageDescriptors(fGroupFileAction, "file_mode.gif"); //$NON-NLS-1$
186 fGroupTypeAction= new GroupAction(SearchMessages.JavaSearchResultPage_groupby_type, SearchMessages.JavaSearchResultPage_groupby_type_tooltip, this, LevelTreeContentProvider.LEVEL_TYPE);
187 JavaPluginImages.setLocalImageDescriptors(fGroupTypeAction, "type_mode.gif"); //$NON-NLS-1$
188 }
189
190 @Override
191 public void setViewPart(ISearchResultViewPart part) {
192 super.setViewPart(part);
193 fActionGroup= new NewSearchViewActionGroup(part);
194 }
195
196 @Override
197 public void showMatch(Match match, int offset, int length, boolean activate) throws PartInitException {
198 IEditorPart editor= fEditorOpener.openMatch(match);
199
200 if (editor != null && activate)
201 editor.getEditorSite().getPage().activate(editor);
202 Object element= match.getElement();
203 if (editor instanceof ITextEditor) {
204 ITextEditor textEditor= (ITextEditor) editor;
205 textEditor.selectAndReveal(offset, length);
206 } else if (editor != null) {
207 if (element instanceof IFile) {
208 IFile file= (IFile) element;
209 showWithMarker(editor, file, offset, length);
210 }
211 } else if (getInput() instanceof JavaSearchResult) {
212 JavaSearchResult result= (JavaSearchResult) getInput();
213 IMatchPresentation participant= result.getSearchParticpant(element);
214 if (participant != null)
215 participant.showMatch(match, offset, length, activate);
216 }
217 }
218
219 private void showWithMarker(IEditorPart editor, IFile file, int offset, int length) throws PartInitException {
220 try {
221 IMarker marker= file.createMarker(NewSearchUI.SEARCH_MARKER);
222 HashMap<String, Integer> attributes= new HashMap<String, Integer>(4);
223 attributes.put(IMarker.CHAR_START, new Integer(offset));
224 attributes.put(IMarker.CHAR_END, new Integer(offset + length));
225 marker.setAttributes(attributes);
226 IDE.gotoMarker(editor, marker);
227 marker.delete();
228 } catch (CoreException e) {
229 throw new PartInitException(SearchMessages.JavaSearchResultPage_error_marker, e);
230 }
231 }
232
233 private SelectionDispatchAction getCopyQualifiedNameAction() {
234 if (fCopyQualifiedNameAction == null) {
235 fCopyQualifiedNameAction= new CopyQualifiedNameAction(getSite());
236 fCopyQualifiedNameAction.setActionDefinitionId(CopyQualifiedNameAction.ACTION_DEFINITION_ID);
237 }
238 return fCopyQualifiedNameAction;
239 }
240
241 @Override
242 protected void fillContextMenu(IMenuManager mgr) {
243 super.fillContextMenu(mgr);
244 addSortActions(mgr);
245
246 mgr.appendToGroup(IContextMenuConstants.GROUP_EDIT, getCopyQualifiedNameAction());
247
248 fActionGroup.setContext(new ActionContext(getSite().getSelectionProvider().getSelection()));
249 fActionGroup.fillContextMenu(mgr);
250 }
251
252 private void addSortActions(IMenuManager mgr) {
253 if (getLayout() != FLAG_LAYOUT_FLAT)
254 return;
255 MenuManager sortMenu= new MenuManager(SearchMessages.JavaSearchResultPage_sortBylabel);
256 sortMenu.add(fSortByNameAction);
257 sortMenu.add(fSortByPathAction);
258 sortMenu.add(fSortByParentName);
259
260 fSortByNameAction.setChecked(fCurrentSortOrder == fSortByNameAction.getSortOrder());
261 fSortByPathAction.setChecked(fCurrentSortOrder == fSortByPathAction.getSortOrder());
262 fSortByParentName.setChecked(fCurrentSortOrder == fSortByParentName.getSortOrder());
263
264 mgr.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, sortMenu);
265 }
266
267 @Override
268 protected void fillToolbar(IToolBarManager tbm) {
269 super.fillToolbar(tbm);
270
271 IActionBars actionBars = getSite().getActionBars();
272 if (actionBars != null) {
273 actionBars.setGlobalActionHandler(CopyQualifiedNameAction.ACTION_HANDLER_ID, getCopyQualifiedNameAction());
274 }
275
276 if (getLayout() != FLAG_LAYOUT_FLAT)
277 addGroupActions(tbm);
278 }
279
280 private void addGroupActions(IToolBarManager mgr) {
281 mgr.appendToGroup(IContextMenuConstants.GROUP_VIEWER_SETUP, new Separator(GROUP_GROUPING));
282 mgr.appendToGroup(GROUP_GROUPING, fGroupProjectAction);
283 mgr.appendToGroup(GROUP_GROUPING, fGroupPackageAction);
284 mgr.appendToGroup(GROUP_GROUPING, fGroupFileAction);
285 mgr.appendToGroup(GROUP_GROUPING, fGroupTypeAction);
286
287 updateGroupingActions();
288 }
289
290
291 private void updateGroupingActions() {
292 fGroupProjectAction.setChecked(fCurrentGrouping == LevelTreeContentProvider.LEVEL_PROJECT);
293 fGroupPackageAction.setChecked(fCurrentGrouping == LevelTreeContentProvider.LEVEL_PACKAGE);
294 fGroupFileAction.setChecked(fCurrentGrouping == LevelTreeContentProvider.LEVEL_FILE);
295 fGroupTypeAction.setChecked(fCurrentGrouping == LevelTreeContentProvider.LEVEL_TYPE);
296 }
297
298
299 @Override
300 public void dispose() {
301 fActionGroup.dispose();
302 super.dispose();
303 }
304
305 @Override
306 protected void elementsChanged(Object[] objects) {
307 if (fContentProvider != null)
308 fContentProvider.elementsChanged(objects);
309 }
310
311 @Override
312 protected void clear() {
313 if (fContentProvider != null)
314 fContentProvider.clear();
315 }
316
317 private void addDragAdapters(StructuredViewer viewer) {
318 Transfer[] transfers= new Transfer[] { LocalSelectionTransfer.getInstance(), ResourceTransfer.getInstance() };
319 int ops= DND.DROP_COPY | DND.DROP_LINK;
320
321 JdtViewerDragAdapter dragAdapter= new JdtViewerDragAdapter(viewer);
322 dragAdapter.addDragSourceListener(new SelectionTransferDragAdapter(viewer));
323 dragAdapter.addDragSourceListener(new EditorInputTransferDragAdapter(viewer));
324 dragAdapter.addDragSourceListener(new ResourceTransferDragAdapter(viewer));
325 viewer.addDragSupport(ops, transfers, dragAdapter);
326 }
327
328 @Override
329 protected void configureTableViewer(TableViewer viewer) {
330 viewer.setUseHashlookup(true);
331 fSortingLabelProvider= new SortingLabelProvider(this);
332 viewer.setLabelProvider(new DecoratingJavaLabelProvider(fSortingLabelProvider, false));
333 fContentProvider=new JavaSearchTableContentProvider(this);
334 viewer.setContentProvider(fContentProvider);
335 viewer.setComparator(new DecoratorIgnoringViewerSorter(fSortingLabelProvider));
336 setSortOrder(fCurrentSortOrder);
337 addDragAdapters(viewer);
338 }
339
340 @Override
341 protected void configureTreeViewer(TreeViewer viewer) {
342 PostfixLabelProvider postfixLabelProvider= new PostfixLabelProvider(this);
343 viewer.setUseHashlookup(true);
344 viewer.setComparator(new DecoratorIgnoringViewerSorter(postfixLabelProvider));
345 viewer.setLabelProvider(new DecoratingJavaLabelProvider(postfixLabelProvider, false));
346 fContentProvider= new LevelTreeContentProvider(this, fCurrentGrouping);
347 viewer.setContentProvider(fContentProvider);
348 addDragAdapters(viewer);
349 }
350
351 @Override
352 protected TreeViewer createTreeViewer(Composite parent) {
353 return new ProblemTreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
354 }
355
356 @Override
357 protected TableViewer createTableViewer(Composite parent) {
358 return new ProblemTableViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
359 }
360
361 void setSortOrder(int order) {
362 if (fSortingLabelProvider != null) {
363 fCurrentSortOrder= order;
364 StructuredViewer viewer= getViewer();
365 //viewer.getControl().setRedraw(false);
366 fSortingLabelProvider.setOrder(order);
367 //viewer.getControl().setRedraw(true);
368 viewer.refresh();
369 getSettings().put(KEY_SORTING, fCurrentSortOrder);
370 }
371 }
372
373 @Override
374 public void init(IPageSite site) {
375 super.init(site);
376 IMenuManager menuManager = site.getActionBars().getMenuManager();
377 menuManager.insertBefore(IContextMenuConstants.GROUP_PROPERTIES, new Separator(GROUP_FILTERING));
378 fActionGroup.fillActionBars(site.getActionBars());
379 menuManager.appendToGroup(IContextMenuConstants.GROUP_PROPERTIES, new Action(SearchMessages.JavaSearchResultPage_preferences_label) {
380 @Override
381 public void run() {
382 String pageId= "org.eclipse.search.preferences.SearchPreferencePage"; //$NON-NLS-1$
383 String[] displayedPages= { pageId,
384 "org.eclipse.ui.editors.preferencePages.Annotations", //$NON-NLS-1$
385 "org.eclipse.ui.preferencePages.ColorsAndFonts" //$NON-NLS-1$
386 };
387 PreferencesUtil.createPreferenceDialogOn(JavaPlugin.getActiveWorkbenchShell(), pageId, displayedPages, null).open();
388 }
389 });
390 }
391
392 /**
393 * Precondition here: the viewer must be showing a tree with a LevelContentProvider.
394 *
395 * @param grouping the grouping which must be one of the <code>LEVEL_*</code> constants from
396 * {@link LevelTreeContentProvider}
397 */
398 void setGrouping(int grouping) {
399 fCurrentGrouping= grouping;
400 StructuredViewer viewer= getViewer();
401 LevelTreeContentProvider cp= (LevelTreeContentProvider) viewer.getContentProvider();
402 cp.setLevel(grouping);
403 updateGroupingActions();
404 getSettings().put(KEY_GROUPING, fCurrentGrouping);
405 getViewPart().updateLabel();
406 }
407
408 @Override
409 protected StructuredViewer getViewer() {
410 // override so that it's visible in the package.
411 return super.getViewer();
412 }
413
414 /* (non-Javadoc)
415 * @see org.eclipse.search.ui.text.AbstractTextSearchViewPage#restoreState(org.eclipse.ui.IMemento)
416 */
417 @Override
418 public void restoreState(IMemento memento) {
419 super.restoreState(memento);
420
421 int sortOrder= SortingLabelProvider.SHOW_ELEMENT_CONTAINER;
422 int grouping= LevelTreeContentProvider.LEVEL_PACKAGE;
423 int elementLimit= DEFAULT_ELEMENT_LIMIT;
424
425 try {
426 sortOrder= getSettings().getInt(KEY_SORTING);
427 } catch (NumberFormatException e) {
428 }
429 try {
430 grouping= getSettings().getInt(KEY_GROUPING);
431 } catch (NumberFormatException e) {
432 }
433 if (FALSE.equals(getSettings().get(KEY_LIMIT_ENABLED))) {
434 elementLimit= -1;
435 } else {
436 try {
437 elementLimit= getSettings().getInt(KEY_LIMIT);
438 } catch (NumberFormatException e) {
439 }
440 }
441 if (memento != null) {
442 Integer value= memento.getInteger(KEY_GROUPING);
443 if (value != null)
444 grouping= value.intValue();
445 value= memento.getInteger(KEY_SORTING);
446 if (value != null)
447 sortOrder= value.intValue();
448 boolean limitElements= !FALSE.equals(memento.getString(KEY_LIMIT_ENABLED));
449 value= memento.getInteger(KEY_LIMIT);
450 if (value != null)
451 elementLimit= limitElements ? value.intValue() : -1;
452 }
453
454 fCurrentGrouping= grouping;
455 fCurrentSortOrder= sortOrder;
456 setElementLimit(new Integer(elementLimit));
457 }
458
459 /* (non-Javadoc)
460 * @see org.eclipse.search.ui.text.AbstractTextSearchViewPage#saveState(org.eclipse.ui.IMemento)
461 */
462 @Override
463 public void saveState(IMemento memento) {
464 super.saveState(memento);
465 memento.putInteger(KEY_GROUPING, fCurrentGrouping);
466 memento.putInteger(KEY_SORTING, fCurrentSortOrder);
467 int limit= getElementLimit().intValue();
468 if (limit != -1)
469 memento.putString(KEY_LIMIT_ENABLED, TRUE);
470 else
471 memento.putString(KEY_LIMIT_ENABLED, FALSE);
472 memento.putInteger(KEY_LIMIT, limit);
473 }
474
475 private boolean isQueryRunning() {
476 AbstractTextSearchResult result= getInput();
477 if (result != null) {
478 return NewSearchUI.isQueryRunning(result.getQuery());
479 }
480 return false;
481 }
482
483 @Override
484 public String getLabel() {
485 String label= super.getLabel();
486 AbstractTextSearchResult input= getInput();
487 if (input != null && input.getActiveMatchFilters() != null && input.getActiveMatchFilters().length > 0) {
488 if (isQueryRunning()) {
489 String message= SearchMessages.JavaSearchResultPage_filtered_message;
490 return Messages.format(message, new Object[] { label });
491
492 } else {
493 int filteredOut= input.getMatchCount() - getFilteredMatchCount();
494 String message= SearchMessages.JavaSearchResultPage_filteredWithCount_message;
495 return Messages.format(message, new Object[] { label, String.valueOf(filteredOut) });
496 }
497 }
498 return label;
499 }
500
501 private int getFilteredMatchCount() {
502 StructuredViewer viewer= getViewer();
503 if (viewer instanceof TreeViewer) {
504 ITreeContentProvider tp= (ITreeContentProvider) viewer.getContentProvider();
505 return getMatchCount(tp, getRootElements((TreeViewer) getViewer()));
506 } else {
507 return getMatchCount((TableViewer) viewer);
508 }
509 }
510
511 private Object[] getRootElements(TreeViewer viewer) {
512 Tree t= viewer.getTree();
513 Item[] roots= t.getItems();
514 Object[] elements= new Object[roots.length];
515 for (int i = 0; i < elements.length; i++) {
516 elements[i]= roots[i].getData();
517 }
518 return elements;
519 }
520
521 private Object[] getRootElements(TableViewer viewer) {
522 Table t= viewer.getTable();
523 Item[] roots= t.getItems();
524 Object[] elements= new Object[roots.length];
525 for (int i = 0; i < elements.length; i++) {
526 elements[i]= roots[i].getData();
527 }
528 return elements;
529 }
530
531
532 private int getMatchCount(ITreeContentProvider cp, Object[] elements) {
533 int count= 0;
534 for (int j = 0; j < elements.length; j++) {
535 count+= getDisplayedMatchCount(elements[j]);
536 Object[] children = cp.getChildren(elements[j]);
537 count+= getMatchCount(cp, children);
538 }
539 return count;
540 }
541
542 private int getMatchCount(TableViewer viewer) {
543 Object[] elements= getRootElements(viewer);
544 int count= 0;
545 for (int i = 0; i < elements.length; i++) {
546 count+= getDisplayedMatchCount(elements[i]);
547 }
548 return count;
549 }
550
551
552 /* (non-Javadoc)
553 * @see org.eclipse.core.runtime.IAdaptable#getAdapter(java.lang.Class)
554 */
555 public Object getAdapter(Class adapter) {
556 if (IShowInTargetList.class.equals(adapter)) {
557 return SHOW_IN_TARGET_LIST;
558 }
559 return null;
560 }
561
562 @Override
563 protected void handleOpen(OpenEvent event) {
564 Object firstElement= ((IStructuredSelection)event.getSelection()).getFirstElement();
565 if (firstElement instanceof ICompilationUnit ||
566 firstElement instanceof IClassFile ||
567 firstElement instanceof IMember) {
568 if (getDisplayedMatchCount(firstElement) == 0) {
569 try {
570 fEditorOpener.openElement(firstElement);
571 } catch (CoreException e) {
572 ExceptionHandler.handle(e, getSite().getShell(), SearchMessages.JavaSearchResultPage_open_editor_error_title, SearchMessages.JavaSearchResultPage_open_editor_error_message);
573 }
574 return;
575 }
576 }
577 super.handleOpen(event);
578 }
579
580 @Override
581 public void setElementLimit(Integer elementLimit) {
582 super.setElementLimit(elementLimit);
583 int limit= elementLimit.intValue();
584 getSettings().put(KEY_LIMIT, limit);
585 getSettings().put(KEY_LIMIT_ENABLED, limit != -1 ? TRUE : FALSE);
586 }
587}
Refaktor masterproject