case-study/jdt-after/ui/org/eclipse/jdt/internal/ui/browsing/PackagesViewFlatContentProvider.java

   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  *******************************************************************************/
  11 package org.eclipse.jdt.internal.ui.browsing;
  12
  13 import java.util.ArrayList;
  14 import java.util.List;
  15
  16 import org.eclipse.swt.widgets.Control;
  17 import org.eclipse.swt.widgets.Display;
  18
  19 import org.eclipse.jface.viewers.IStructuredContentProvider;
  20 import org.eclipse.jface.viewers.StructuredViewer;
  21 import org.eclipse.jface.viewers.TableViewer;
  22
  23 import org.eclipse.jdt.core.IJavaElement;
  24 import org.eclipse.jdt.core.IJavaElementDelta;
  25 import org.eclipse.jdt.core.IJavaProject;
  26 import org.eclipse.jdt.core.IPackageFragment;
  27 import org.eclipse.jdt.core.IPackageFragmentRoot;
  28 import org.eclipse.jdt.core.JavaModelException;
  29
  30 import org.eclipse.jdt.ui.JavaElementLabels;
  31
  32 /**
  33  * Table content provider for the hierarchical layout in the packages view.
  34  * <p>
  35  * XXX: The standard Java browsing part content provider needs and calls
  36  * the browsing part/view. This class currently doesn't need to do so
  37  * but might be required to later.
  38  * </p>
  39  */
  40 //TODO: made public and added setRefreshLoggingEnabled(..) to track down https://bugs.eclipse.org/bugs/show_bug.cgi?id=243132
  41 public class PackagesViewFlatContentProvider extends LogicalPackagesProvider implements IStructuredContentProvider {
  42
  43         private boolean fRefreshLoggingEnabled;
  44
  45         public void setRefreshLoggingEnabled(boolean enabled) {
  46                 fRefreshLoggingEnabled= enabled;
  47         }
  48
  49         PackagesViewFlatContentProvider(StructuredViewer viewer) {
  50                 super(viewer);
  51         }
  52
  53         /*
  54          * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)
  55          */
  56         public Object[] getChildren(Object parentElement) {
  57
  58                 if(parentElement instanceof IJavaElement){
  59                         IJavaElement element= (IJavaElement) parentElement;
  60
  61                         int type= element.getElementType();
  62
  63                         try {
  64                                 switch (type) {
  65                                         case IJavaElement.JAVA_PROJECT :
  66                                                 IJavaProject project= (IJavaProject) element;
  67                                                 IPackageFragment[] children= getPackageFragments(project.getPackageFragments());
  68                                                 if(isInCompoundState()) {
  69                                                         fMapToLogicalPackage.clear();
  70                                                         fMapToPackageFragments.clear();
  71                                                         return combineSamePackagesIntoLogialPackages(children);
  72                                                 } else
  73                                                         return children;
  74
  75                                         case IJavaElement.PACKAGE_FRAGMENT_ROOT :
  76                                                 fMapToLogicalPackage.clear();
  77                                                 fMapToPackageFragments.clear();
  78                                                 IPackageFragmentRoot root= (IPackageFragmentRoot) element;
  79                                                 return root.getChildren();
  80
  81                                         case IJavaElement.PACKAGE_FRAGMENT :
  82                                                 //no children in flat view
  83                                                 break;
  84
  85                                         default :
  86                                                 //do nothing, empty array returned
  87                                 }
  88                         } catch (JavaModelException e) {
  89                                 return NO_CHILDREN;
  90                         }
  91
  92                 }
  93                 return NO_CHILDREN;
  94         }
  95
  96         /*
  97          * Weeds out packageFragments from external jars and folders
  98          */
  99         private IPackageFragment[] getPackageFragments(IPackageFragment[] iPackageFragments) {
 100                 List<IPackageFragment> list= new ArrayList<IPackageFragment>();
 101                 for (int i= 0; i < iPackageFragments.length; i++) {
 102                         IPackageFragment fragment= iPackageFragments[i];
 103                         IJavaElement el= fragment.getParent();
 104                         if (el instanceof IPackageFragmentRoot) {
 105                                 IPackageFragmentRoot root= (IPackageFragmentRoot) el;
 106                                 if (root.isExternal())
 107                                         continue;
 108                         }
 109                         list.add(fragment);
 110                 }
 111                 return list.toArray(new IPackageFragment[list.size()]);
 112         }
 113
 114         /*
 115          * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
 116          */
 117         public Object[] getElements(Object inputElement) {
 118                 return getChildren(inputElement);
 119         }
 120
 121         @Override
 122         protected void processDelta(IJavaElementDelta delta) throws JavaModelException {
 123
 124                 int kind= delta.getKind();
 125                 final IJavaElement element= delta.getElement();
 126
 127                 if (fRefreshLoggingEnabled) {
 128                         String elementLabel= JavaElementLabels.getElementLabel(element, JavaElementLabels.ALL_FULLY_QUALIFIED);
 129                         new Exception("Delta for: " + elementLabel).printStackTrace(System.out); //$NON-NLS-1$
 130                 }
 131
 132                 if (isClassPathChange(delta)) {
 133                         Object input= fViewer.getInput();
 134                         if (input != null) {
 135                                 if (fInputIsProject && input.equals(element.getJavaProject())) {
 136                                         postRefresh(input);
 137                                         return;
 138                                 } else if (!fInputIsProject && input.equals(element)) {
 139                                         if (element.exists())
 140                                                 postRefresh(input);
 141                                         else
 142                                                 postRemove(input);
 143                                         return;
 144                                 }
 145                         }
 146                 }
 147
 148                 if (kind == IJavaElementDelta.REMOVED) {
 149                         Object input= fViewer.getInput();
 150                         if (input != null && input.equals(element)) {
 151                                         postRemove(input);
 152                                         return;
 153                         }
 154                 }
 155
 156                 if (element instanceof IPackageFragment) {
 157                         final IPackageFragment frag= (IPackageFragment) element;
 158
 159                         if (kind == IJavaElementDelta.REMOVED) {
 160                                 removeElement(frag);
 161
 162                         } else if (kind == IJavaElementDelta.ADDED) {
 163                                 addElement(frag);
 164
 165                         } else if (kind == IJavaElementDelta.CHANGED) {
 166                                 //just refresh
 167                                 Object toBeRefreshed= element;
 168
 169                                 IPackageFragment pkgFragment= (IPackageFragment) element;
 170                                 LogicalPackage logicalPkg= findLogicalPackage(pkgFragment);
 171                                 //deal with packages that have been filtered and are now visible
 172                                 if (logicalPkg != null)
 173                                         toBeRefreshed= findElementToRefresh(logicalPkg);
 174                                 else
 175                                         toBeRefreshed= findElementToRefresh(pkgFragment);
 176
 177                                 postRefresh(toBeRefreshed);
 178                         }
 179                         //in this view there will be no children of PackageFragment to refresh
 180                         return;
 181                 }
 182                 processAffectedChildren(delta);
 183         }
 184
 185         //test to see if element to be refreshed is being filtered out
 186         //and if so refresh the viewers input element (JavaProject or PackageFragmentRoot)
 187         private Object findElementToRefresh(IPackageFragment fragment) {
 188                 if (fViewer.testFindItem(fragment) == null) {
 189                         if(fInputIsProject)
 190                                 return fragment.getJavaProject();
 191                         else return fragment.getParent();
 192                 }
 193                 return fragment;
 194         }
 195
 196         //test to see if element to be refreshed is being filtered out
 197         //and if so refresh the viewers input element (JavaProject or PackageFragmentRoot)
 198         private Object findElementToRefresh(LogicalPackage logicalPackage) {
 199                 return logicalPackage.generated_107260625128017049(this);
 200         }
 201
 202         private void processAffectedChildren(IJavaElementDelta delta) throws JavaModelException {
 203                 IJavaElementDelta[] children= delta.getAffectedChildren();
 204                 for (int i= 0; i < children.length; i++) {
 205                         IJavaElementDelta elementDelta= children[i];
 206                         processDelta(elementDelta);
 207                 }
 208         }
 209
 210         void postAdd(final Object child) {
 211                 postRunnable(new Runnable() {
 212                         public void run() {
 213                                 Control ctrl = fViewer.getControl();
 214                                 if (ctrl != null && !ctrl.isDisposed()) {
 215                                         ((TableViewer)fViewer).add(child);
 216                                 }
 217                         }
 218                 });
 219         }
 220
 221
 222         void postRemove(final Object object) {
 223                 postRunnable(new Runnable() {
 224                         public void run() {
 225                                 Control ctrl = fViewer.getControl();
 226                                 if (ctrl != null && !ctrl.isDisposed()) {
 227                                         ((TableViewer)fViewer).remove(object);
 228                                 }
 229                         }
 230                 });
 231         }
 232
 233         private void postRunnable(final Runnable r) {
 234                 Control ctrl= fViewer.getControl();
 235                 if (ctrl != null && !ctrl.isDisposed()) {
 236                 //      fBrowsingPart.setProcessSelectionEvents(false);
 237                         try {
 238                                 Display currentDisplay= Display.getCurrent();
 239                                 if (currentDisplay != null && currentDisplay.equals(ctrl.getDisplay()))
 240                                         ctrl.getDisplay().syncExec(r);
 241                                 else
 242                                         ctrl.getDisplay().asyncExec(r);
 243                         } finally {
 244                 //              fBrowsingPart.setProcessSelectionEvents(true);
 245                         }
 246                 }
 247         }
 248
 249         private void removeElement(IPackageFragment frag) {
 250                 String key= getKey(frag);
 251                 LogicalPackage lp= fMapToLogicalPackage.get(key);
 252
 253                 if(lp != null){
 254                         lp.generated_6417398543703521005(frag, key, this);
 255                         return;
 256                 } else {
 257                         fMapToPackageFragments.remove(key);
 258                         postRemove(frag);
 259                 }
 260         }
 261
 262         private void postRefresh(final Object element) {
 263                 if (fRefreshLoggingEnabled) {
 264                         new Exception("postRefresh: " + element).printStackTrace(System.out); //$NON-NLS-1$
 265                 }
 266
 267                 postRunnable(new Runnable() {
 268                         public void run() {
 269                                 Control ctrl= fViewer.getControl();
 270                                 if (ctrl != null && !ctrl.isDisposed()) {
 271                                         fViewer.refresh(element);
 272                                 }
 273                         }
 274                 });
 275         }
 276
 277         private void addElement(IPackageFragment frag) {
 278                 String key= getKey(frag);
 279                 LogicalPackage lp= fMapToLogicalPackage.get(key);
 280
 281                 if(lp != null && lp.belongs(frag)){
 282                         lp.add(frag);
 283                         return;
 284                 }
 285
 286                 IPackageFragment fragment= fMapToPackageFragments.get(key);
 287                 if(fragment != null){
 288                         //must create a new LogicalPackage
 289                         if(!fragment.equals(frag)){
 290                                 lp= new LogicalPackage(fragment);
 291                                 lp.generated_4157276551819242824(frag, key, this, fragment);
 292
 293                                 return;
 294                         }
 295                 }
 296
 297                 else {
 298                         fMapToPackageFragments.put(key, frag);
 299                         postAdd(frag);
 300                 }
 301         }
 302 }