plugins/org.eclipse.oomph.ui/src/org/eclipse/oomph/ui/FilteredTreeWithoutWorkbench.java - oomph/org.eclipse.oomph - Git at Google

 /*
  * Copyright (c) 2016, 2018 Eike Stepper (Loehne, Germany) and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v2.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v20.html
  *
  * Contributors:
  *    Eike Stepper - initial API and implementation
  */
 package org.eclipse.oomph.ui;

 import org.eclipse.oomph.util.ReflectUtil;
 import org.eclipse.oomph.util.StringUtil;

 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.jface.viewers.CheckboxTreeViewer;
 import org.eclipse.jface.viewers.IContentProvider;
 import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.TreeItem;
 import org.eclipse.ui.dialogs.FilteredTree;
 import org.eclipse.ui.dialogs.PatternFilter;
 import org.eclipse.ui.progress.WorkbenchJob;

 import java.lang.reflect.Method;

 /**
  * This subclass is useful because the refresh job won't schedule if there is no workbench, which is the case in the installer wizard.
  * This supports an optional expansion filter that can be used to control how the tree is expanded after a match.
  * This also supports controlling the number of items that will be expanded after a match.
  *
  * @author Ed Merks
  */
 public class FilteredTreeWithoutWorkbench extends FilteredTree
 {
   private final Object refreshJobFamily = new Object();

   private final ExpansionFilter expansionFilter;

   private int expansionCount;

   public FilteredTreeWithoutWorkbench(Composite parent, int style)
   {
     super(parent, style, new PatternFilter(), true);
     expansionFilter = null;
   }

   public FilteredTreeWithoutWorkbench(Composite parent, int style, PatternFilter patternFilter, ExpansionFilter expansionFilter)
   {
     super(parent, style, patternFilter, true);
     this.expansionFilter = expansionFilter;
   }

   public void setExpansionCount(int expansionCount)
   {
     this.expansionCount = expansionCount;
   }

   @Override
   public void clearText()
   {
     super.clearText();
   }

   public Object getRefreshJobFamily()
   {
     return refreshJobFamily;
   }

   @Override
   protected WorkbenchJob doCreateRefreshJob()
   {
     return new WorkbenchJob("Refresh Filter")
     {
       @Override
       public IStatus runInUIThread(IProgressMonitor monitor)
       {
         if (treeViewer.getControl().isDisposed())
         {
           return Status.CANCEL_STATUS;
         }

         PatternFilter patternFilter = getPatternFilter();

         String text = getFilterString();
         if (StringUtil.isEmpty(text))
         {
           patternFilter.setPattern(null);
           treeViewer.refresh(true);
           refreshed();
           return Status.OK_STATUS;
         }

         boolean initial = initialText != null && initialText.equals(text);
         if (initial)
         {
           patternFilter.setPattern(null);
         }
         else
         {
           patternFilter.setPattern(text);
         }

         Control redrawFalseControl = treeComposite != null ? treeComposite : treeViewer.getControl();

         try
         {
           redrawFalseControl.setRedraw(false);
           if (Boolean.FALSE.equals(ReflectUtil.getValue("narrowingDown", FilteredTreeWithoutWorkbench.this)))
           {
             TreeItem[] is = treeViewer.getTree().getItems();
             for (int i = 0; i < is.length; i++)
             {
               TreeItem item = is[i];
               if (item.getExpanded())
               {
                 treeViewer.setExpandedState(item.getData(), false);
               }
             }
           }

           treeViewer.refresh(true);

           if (text.length() > 0 && !initial)
           {
             TreeItem[] items = getViewer().getTree().getItems();
             int treeHeight = getViewer().getTree().getBounds().height;
             int numVisibleItems = treeHeight / getViewer().getTree().getItemHeight();
             long stopTime = 200 + System.currentTimeMillis();
             boolean cancel = false;
             if (items.length > 0 && recursiveExpand(items, monitor, stopTime, new int[] { expansionCount == 0 ? numVisibleItems : expansionCount }))
             {
               cancel = true;
             }

             updateToolbar(true);

             if (cancel)
             {
               return Status.CANCEL_STATUS;
             }
           }
           else
           {
             updateToolbar(false);
           }

         }
         finally
         {
           TreeItem[] items = getViewer().getTree().getItems();
           if (items.length > 0 && getViewer().getTree().getSelectionCount() == 0)
           {
             treeViewer.getTree().setTopItem(items[0]);
           }

           redrawFalseControl.setRedraw(true);

           refreshed();
         }

         return Status.OK_STATUS;
       }

       private boolean recursiveExpand(TreeItem[] items, IProgressMonitor monitor, long cancelTime, int[] numItemsLeft)
       {
         boolean canceled = false;
         for (int i = 0; !canceled && i < items.length; i++)
         {
           TreeItem item = items[i];
           boolean visible = numItemsLeft[0]-- >= 0;
           if (monitor.isCanceled() || !visible && System.currentTimeMillis() > cancelTime)
           {
             canceled = true;
           }
           else
           {
             Object itemData = item.getData();
             if (itemData != null && (expansionFilter == null || expansionFilter.shouldExpand(itemData)))
             {
               if (!item.getExpanded())
               {
                 treeViewer.setExpandedState(itemData, true);
               }

               TreeItem[] children = item.getItems();
               if (items.length > 0)
               {
                 canceled = recursiveExpand(children, monitor, cancelTime, numItemsLeft);
               }
             }
           }
         }

         return canceled;
       }

       @Override
       public Display getDisplay()
       {
         return UIUtil.getDisplay();
       }

       @Override
       public boolean shouldSchedule()
       {
         return true;
       }

       @Override
       public boolean shouldRun()
       {
         return true;
       }

       @Override
       public boolean belongsTo(Object family)
       {
         return family == refreshJobFamily;
       }
     };
   }

   protected void refreshed()
   {
   }

   public static interface ExpansionFilter
   {
     public boolean shouldExpand(Object element);
   }

   /**
    * @author Eike Stepper
    */
   public static class WithCheckboxes extends FilteredTreeWithoutWorkbench
   {
     private static final Method CLEAR_CACHES_METHOD;

     static
     {
       Method clearCachesMethod = null;

       try
       {
         clearCachesMethod = ReflectUtil.getMethod(PatternFilter.class, "clearCaches");
       }
       catch (Throwable t)
       {
         //$FALL-THROUGH$
       }

       CLEAR_CACHES_METHOD = clearCachesMethod;
     }

     public WithCheckboxes(Composite parent, int style, PatternFilter patternFilter, ExpansionFilter expansionFilter)
     {
       super(parent, style, patternFilter, expansionFilter);
     }

     public WithCheckboxes(Composite parent, int style)
     {
       super(parent, style);
     }

     @Override
     public CheckboxTreeViewer getViewer()
     {
       return (CheckboxTreeViewer)super.getViewer();
     }

     @Override
     protected TreeViewer doCreateTreeViewer(Composite parent, int style)
     {
       return new NotifyingCheckboxTreeViewer(parent, style);
     }

     /**
      * @author Eike Stepper
      */
     class NotifyingCheckboxTreeViewer extends CheckboxTreeViewer
     {
       public NotifyingCheckboxTreeViewer(Composite parent, int style)
       {
         super(parent, style);
       }

       @Override
       public void add(Object parentElementOrTreePath, Object childElement)
       {
         clearPatternFilterCaches();
         super.add(parentElementOrTreePath, childElement);
       }

       @Override
       public void add(Object parentElementOrTreePath, Object[] childElements)
       {
         clearPatternFilterCaches();
         super.add(parentElementOrTreePath, childElements);
       }

       @Override
       public void insert(Object parentElementOrTreePath, Object element, int position)
       {
         clearPatternFilterCaches();
         super.insert(parentElementOrTreePath, element, position);
       }

       @Override
       public void refresh()
       {
         clearPatternFilterCaches();
         super.refresh();
       }

       @Override
       public void refresh(boolean updateLabels)
       {
         clearPatternFilterCaches();
         super.refresh(updateLabels);
       }

       @Override
       public void refresh(Object element)
       {
         clearPatternFilterCaches();
         super.refresh(element);
       }

       @Override
       public void refresh(Object element, boolean updateLabels)
       {
         clearPatternFilterCaches();
         super.refresh(element, updateLabels);
       }

       @Override
       public void remove(Object elementsOrTreePaths)
       {
         clearPatternFilterCaches();
         super.remove(elementsOrTreePaths);
       }

       @Override
       public void remove(Object parent, Object[] elements)
       {
         clearPatternFilterCaches();
         super.remove(parent, elements);
       }

       @Override
       public void remove(Object[] elementsOrTreePaths)
       {
         clearPatternFilterCaches();
         super.remove(elementsOrTreePaths);
       }

       @Override
       public void replace(Object parentElementOrTreePath, int index, Object element)
       {
         clearPatternFilterCaches();
         super.replace(parentElementOrTreePath, index, element);
       }

       @Override
       public void setChildCount(Object elementOrTreePath, int count)
       {
         clearPatternFilterCaches();
         super.setChildCount(elementOrTreePath, count);
       }

       @Override
       public void setContentProvider(IContentProvider provider)
       {
         clearPatternFilterCaches();
         super.setContentProvider(provider);
       }

       @Override
       public void setHasChildren(Object elementOrTreePath, boolean hasChildren)
       {
         clearPatternFilterCaches();
         super.setHasChildren(elementOrTreePath, hasChildren);
       }

       @Override
       protected void inputChanged(Object input, Object oldInput)
       {
         clearPatternFilterCaches();
         super.inputChanged(input, oldInput);
       }

       private void clearPatternFilterCaches()
       {
         if (CLEAR_CACHES_METHOD != null)
         {
           try
           {
             CLEAR_CACHES_METHOD.invoke(getPatternFilter());
           }
           catch (Throwable ex)
           {
             //$FALL-THROUGH$
           }
         }
       }
     }
   }
 }
	/*
	* Copyright (c) 2016, 2018 Eike Stepper (Loehne, Germany) and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v2.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v20.html
	*
	* Contributors:
	* Eike Stepper - initial API and implementation
	*/
	package org.eclipse.oomph.ui;

	import org.eclipse.oomph.util.ReflectUtil;
	import org.eclipse.oomph.util.StringUtil;

	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Status;
	import org.eclipse.jface.viewers.CheckboxTreeViewer;
	import org.eclipse.jface.viewers.IContentProvider;
	import org.eclipse.jface.viewers.TreeViewer;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.TreeItem;
	import org.eclipse.ui.dialogs.FilteredTree;
	import org.eclipse.ui.dialogs.PatternFilter;
	import org.eclipse.ui.progress.WorkbenchJob;

	import java.lang.reflect.Method;

	/**
	* This subclass is useful because the refresh job won't schedule if there is no workbench, which is the case in the installer wizard.
	* This supports an optional expansion filter that can be used to control how the tree is expanded after a match.
	* This also supports controlling the number of items that will be expanded after a match.
	*
	* @author Ed Merks
	*/
	public class FilteredTreeWithoutWorkbench extends FilteredTree
	{
	private final Object refreshJobFamily = new Object();

	private final ExpansionFilter expansionFilter;

	private int expansionCount;

	public FilteredTreeWithoutWorkbench(Composite parent, int style)
	{
	super(parent, style, new PatternFilter(), true);
	expansionFilter = null;
	}

	public FilteredTreeWithoutWorkbench(Composite parent, int style, PatternFilter patternFilter, ExpansionFilter expansionFilter)
	{
	super(parent, style, patternFilter, true);
	this.expansionFilter = expansionFilter;
	}

	public void setExpansionCount(int expansionCount)
	{
	this.expansionCount = expansionCount;
	}

	@Override
	public void clearText()
	{
	super.clearText();
	}

	public Object getRefreshJobFamily()
	{
	return refreshJobFamily;
	}

	@Override
	protected WorkbenchJob doCreateRefreshJob()
	{
	return new WorkbenchJob("Refresh Filter")
	{
	@Override
	public IStatus runInUIThread(IProgressMonitor monitor)
	{
	if (treeViewer.getControl().isDisposed())
	{
	return Status.CANCEL_STATUS;
	}

	PatternFilter patternFilter = getPatternFilter();

	String text = getFilterString();
	if (StringUtil.isEmpty(text))
	{
	patternFilter.setPattern(null);
	treeViewer.refresh(true);
	refreshed();
	return Status.OK_STATUS;
	}

	boolean initial = initialText != null && initialText.equals(text);
	if (initial)
	{
	patternFilter.setPattern(null);
	}
	else
	{
	patternFilter.setPattern(text);
	}

	Control redrawFalseControl = treeComposite != null ? treeComposite : treeViewer.getControl();

	try
	{
	redrawFalseControl.setRedraw(false);
	if (Boolean.FALSE.equals(ReflectUtil.getValue("narrowingDown", FilteredTreeWithoutWorkbench.this)))
	{
	TreeItem[] is = treeViewer.getTree().getItems();
	for (int i = 0; i < is.length; i++)
	{
	TreeItem item = is[i];
	if (item.getExpanded())
	{
	treeViewer.setExpandedState(item.getData(), false);
	}
	}
	}

	treeViewer.refresh(true);

	if (text.length() > 0 && !initial)
	{
	TreeItem[] items = getViewer().getTree().getItems();
	int treeHeight = getViewer().getTree().getBounds().height;
	int numVisibleItems = treeHeight / getViewer().getTree().getItemHeight();
	long stopTime = 200 + System.currentTimeMillis();
	boolean cancel = false;
	if (items.length > 0 && recursiveExpand(items, monitor, stopTime, new int[] { expansionCount == 0 ? numVisibleItems : expansionCount }))
	{
	cancel = true;
	}

	updateToolbar(true);

	if (cancel)
	{
	return Status.CANCEL_STATUS;
	}
	}
	else
	{
	updateToolbar(false);
	}

	}
	finally
	{
	TreeItem[] items = getViewer().getTree().getItems();
	if (items.length > 0 && getViewer().getTree().getSelectionCount() == 0)
	{
	treeViewer.getTree().setTopItem(items[0]);
	}

	redrawFalseControl.setRedraw(true);

	refreshed();
	}

	return Status.OK_STATUS;
	}

	private boolean recursiveExpand(TreeItem[] items, IProgressMonitor monitor, long cancelTime, int[] numItemsLeft)
	{
	boolean canceled = false;
	for (int i = 0; !canceled && i < items.length; i++)
	{
	TreeItem item = items[i];
	boolean visible = numItemsLeft[0]-- >= 0;
	if (monitor.isCanceled() \|\| !visible && System.currentTimeMillis() > cancelTime)
	{
	canceled = true;
	}
	else
	{
	Object itemData = item.getData();
	if (itemData != null && (expansionFilter == null \|\| expansionFilter.shouldExpand(itemData)))
	{
	if (!item.getExpanded())
	{
	treeViewer.setExpandedState(itemData, true);
	}

	TreeItem[] children = item.getItems();
	if (items.length > 0)
	{
	canceled = recursiveExpand(children, monitor, cancelTime, numItemsLeft);
	}
	}
	}
	}

	return canceled;
	}

	@Override
	public Display getDisplay()
	{
	return UIUtil.getDisplay();
	}

	@Override
	public boolean shouldSchedule()
	{
	return true;
	}

	@Override
	public boolean shouldRun()
	{
	return true;
	}

	@Override
	public boolean belongsTo(Object family)
	{
	return family == refreshJobFamily;
	}
	};
	}

	protected void refreshed()
	{
	}

	public static interface ExpansionFilter
	{
	public boolean shouldExpand(Object element);
	}

	/**
	* @author Eike Stepper
	*/
	public static class WithCheckboxes extends FilteredTreeWithoutWorkbench
	{
	private static final Method CLEAR_CACHES_METHOD;

	static
	{
	Method clearCachesMethod = null;

	try
	{
	clearCachesMethod = ReflectUtil.getMethod(PatternFilter.class, "clearCaches");
	}
	catch (Throwable t)
	{
	//$FALL-THROUGH$
	}

	CLEAR_CACHES_METHOD = clearCachesMethod;
	}

	public WithCheckboxes(Composite parent, int style, PatternFilter patternFilter, ExpansionFilter expansionFilter)
	{
	super(parent, style, patternFilter, expansionFilter);
	}

	public WithCheckboxes(Composite parent, int style)
	{
	super(parent, style);
	}

	@Override
	public CheckboxTreeViewer getViewer()
	{
	return (CheckboxTreeViewer)super.getViewer();
	}

	@Override
	protected TreeViewer doCreateTreeViewer(Composite parent, int style)
	{
	return new NotifyingCheckboxTreeViewer(parent, style);
	}

	/**
	* @author Eike Stepper
	*/
	class NotifyingCheckboxTreeViewer extends CheckboxTreeViewer
	{
	public NotifyingCheckboxTreeViewer(Composite parent, int style)
	{
	super(parent, style);
	}

	@Override
	public void add(Object parentElementOrTreePath, Object childElement)
	{
	clearPatternFilterCaches();
	super.add(parentElementOrTreePath, childElement);
	}

	@Override
	public void add(Object parentElementOrTreePath, Object[] childElements)
	{
	clearPatternFilterCaches();
	super.add(parentElementOrTreePath, childElements);
	}

	@Override
	public void insert(Object parentElementOrTreePath, Object element, int position)
	{
	clearPatternFilterCaches();
	super.insert(parentElementOrTreePath, element, position);
	}

	@Override
	public void refresh()
	{
	clearPatternFilterCaches();
	super.refresh();
	}

	@Override
	public void refresh(boolean updateLabels)
	{
	clearPatternFilterCaches();
	super.refresh(updateLabels);
	}

	@Override
	public void refresh(Object element)
	{
	clearPatternFilterCaches();
	super.refresh(element);
	}

	@Override
	public void refresh(Object element, boolean updateLabels)
	{
	clearPatternFilterCaches();
	super.refresh(element, updateLabels);
	}

	@Override
	public void remove(Object elementsOrTreePaths)
	{
	clearPatternFilterCaches();
	super.remove(elementsOrTreePaths);
	}

	@Override
	public void remove(Object parent, Object[] elements)
	{
	clearPatternFilterCaches();
	super.remove(parent, elements);
	}

	@Override
	public void remove(Object[] elementsOrTreePaths)
	{
	clearPatternFilterCaches();
	super.remove(elementsOrTreePaths);
	}

	@Override
	public void replace(Object parentElementOrTreePath, int index, Object element)
	{
	clearPatternFilterCaches();
	super.replace(parentElementOrTreePath, index, element);
	}

	@Override
	public void setChildCount(Object elementOrTreePath, int count)
	{
	clearPatternFilterCaches();
	super.setChildCount(elementOrTreePath, count);
	}

	@Override
	public void setContentProvider(IContentProvider provider)
	{
	clearPatternFilterCaches();
	super.setContentProvider(provider);
	}

	@Override
	public void setHasChildren(Object elementOrTreePath, boolean hasChildren)
	{
	clearPatternFilterCaches();
	super.setHasChildren(elementOrTreePath, hasChildren);
	}

	@Override
	protected void inputChanged(Object input, Object oldInput)
	{
	clearPatternFilterCaches();
	super.inputChanged(input, oldInput);
	}

	private void clearPatternFilterCaches()
	{
	if (CLEAR_CACHES_METHOD != null)
	{
	try
	{
	CLEAR_CACHES_METHOD.invoke(getPatternFilter());
	}
	catch (Throwable ex)
	{
	//$FALL-THROUGH$
	}
	}
	}
	}
	}
	}