Exemplo n.º 1
0
 public boolean performFinish() {
   try {
     String perspId = selection.getAttribute("perspectiveId"); // $NON-NLS-1$
     IWorkbenchPage page = PDEPlugin.getActivePage();
     if (perspId != null && switchPerspective) {
       PlatformUI.getWorkbench().showPerspective(perspId, page.getWorkbenchWindow());
     }
     SampleOperation op =
         new SampleOperation(selection, namesPage.getProjectNames(), new ImportOverwriteQuery());
     getContainer().run(true, true, op);
     IFile sampleManifest = op.getSampleManifest();
     if (selectRevealEnabled) {
       selectReveal(getShell());
     }
     if (activitiesEnabled) enableActivities();
     if (sampleEditorNeeded && sampleManifest != null) IDE.openEditor(page, sampleManifest, true);
   } catch (InvocationTargetException e) {
     PDEPlugin.logException(e);
     return false;
   } catch (InterruptedException e) {
     // PDEPlugin.logException(e);
     return false;
   } catch (CoreException e) {
     PDEPlugin.logException(e);
     return false;
   } catch (OperationCanceledException e) {
     return false;
   }
   return true;
 }
Exemplo n.º 2
0
  /*private void doSelectReveal() {
  	if (selection == null || createdProjects==null)
  		return;
  	String viewId = selection.getAttribute("targetViewId"); //$NON-NLS-1$
  	if (viewId == null)
  		return;
  	IWorkbenchWindow window = PlatformUI.getWorkbench()
  			.getActiveWorkbenchWindow();
  	if (window == null)
  		return;
  	IWorkbenchPage page = window.getActivePage();
  	if (page == null)
  		return;
  	IViewPart view = page.findView(viewId);
  	if (view == null || !(view instanceof ISetSelectionTarget))
  		return;
  	ISetSelectionTarget target = (ISetSelectionTarget) view;
  	IConfigurationElement[] projects = selection.getChildren("project"); //$NON-NLS-1$

  	ArrayList items = new ArrayList();
  	for (int i = 0; i < projects.length; i++) {
  		String path = projects[i].getAttribute("selectReveal"); //$NON-NLS-1$
  		if (path == null)
  			continue;
  		IResource resource = createdProjects[i].findMember(path);
  		if (resource.exists())
  			items.add(resource);
  	}
  	if (items.size() > 0)
  		target.selectReveal(new StructuredSelection(items));
  }
  */
  public void enableActivities() {
    IConfigurationElement[] elements = selection.getChildren("activity"); // $NON-NLS-1$
    HashSet activitiesToEnable = new HashSet();
    IWorkbenchActivitySupport workbenchActivitySupport =
        PlatformUI.getWorkbench().getActivitySupport();

    for (int i = 0; i < elements.length; i++) {
      IConfigurationElement element = elements[i];
      String id = element.getAttribute("id"); // $NON-NLS-1$
      if (id == null) continue;
      activitiesToEnable.add(id);
    }
    HashSet set =
        new HashSet(workbenchActivitySupport.getActivityManager().getEnabledActivityIds());
    set.addAll(activitiesToEnable);
    workbenchActivitySupport.setEnabledActivityIds(set);
  }
 private void handleAddWorkingSet() {
   IWorkingSetManager manager = PlatformUI.getWorkbench().getWorkingSetManager();
   IWorkingSetSelectionDialog dialog =
       manager.createWorkingSetSelectionDialog(PDEPlugin.getActiveWorkbenchShell(), true);
   if (dialog.open() == Window.OK) {
     IWorkingSet[] workingSets = dialog.getSelection();
     IProduct product = getProduct();
     IProductModelFactory factory = product.getModel().getFactory();
     ArrayList<IProductPlugin> pluginList = new ArrayList<IProductPlugin>();
     for (int i = 0; i < workingSets.length; i++) {
       IAdaptable[] elements = workingSets[i].getElements();
       for (int j = 0; j < elements.length; j++) {
         IPluginModelBase model = findModel(elements[j]);
         if (model != null) {
           IProductPlugin plugin = factory.createPlugin();
           IPluginBase base = model.getPluginBase();
           plugin.setId(base.getId());
           pluginList.add(plugin);
         }
       }
     }
     product.addPlugins(pluginList.toArray(new IProductPlugin[pluginList.size()]));
   }
 }
Exemplo n.º 4
0
/**
 * A menu for opening file revisions in the workbench.
 *
 * <p>An <code>OpenWithMenu</code> is used to populate a menu with "Open With" actions. One action
 * is added for each editor which is applicable to the selected file. If the user selects one of
 * these items, the corresponding editor is opened on the file.
 */
public class OpenWithMenu extends ContributionItem {

  private IStructuredSelection selection;

  private HistoryPage page;

  private IEditorRegistry registry = PlatformUI.getWorkbench().getEditorRegistry();

  private static Hashtable imageCache = new Hashtable(11);

  /** The id of this action. */
  public static final String ID = PlatformUI.PLUGIN_ID + ".OpenWithMenu"; // $NON-NLS-1$

  /**
   * Match both the input and id, so that different types of editor can be opened on the same input.
   */
  private static final int MATCH_BOTH = IWorkbenchPage.MATCH_INPUT | IWorkbenchPage.MATCH_ID;

  /*
   * Compares the labels from two IEditorDescriptor objects
   */
  private static final Comparator comparer =
      new Comparator() {
        private Collator collator = Collator.getInstance();

        public int compare(Object arg0, Object arg1) {
          String s1 = ((IEditorDescriptor) arg0).getLabel();
          String s2 = ((IEditorDescriptor) arg1).getLabel();
          return collator.compare(s1, s2);
        }
      };

  /**
   * Constructs a new instance of <code>OpenWithMenu</code>.
   *
   * @param page the page where the editor is opened if an item within the menu is selected
   */
  public OpenWithMenu(HistoryPage page) {
    super(ID);
    this.page = page;
  }

  /**
   * Returns an image to show for the corresponding editor descriptor.
   *
   * @param editorDesc the editor descriptor, or null for the system editor
   * @return the image or null
   */
  private Image getImage(IEditorDescriptor editorDesc) {
    ImageDescriptor imageDesc = getImageDescriptor(editorDesc);
    if (imageDesc == null) {
      return null;
    }
    Image image = (Image) imageCache.get(imageDesc);
    if (image == null) {
      image = imageDesc.createImage();
      imageCache.put(imageDesc, image);
    }
    return image;
  }

  /** Returns the image descriptor for the given editor descriptor, or null if it has no image. */
  private ImageDescriptor getImageDescriptor(IEditorDescriptor editorDesc) {
    ImageDescriptor imageDesc = null;
    if (editorDesc == null) {
      imageDesc = registry.getImageDescriptor(getFileRevision().getName());
      // TODO: is this case valid, and if so, what are the implications
      // for content-type editor bindings?
    } else {
      imageDesc = editorDesc.getImageDescriptor();
    }
    if (imageDesc == null) {
      if (editorDesc.getId().equals(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID)) {
        imageDesc = registry.getSystemExternalEditorImageDescriptor(getFileRevision().getName());
      }
    }
    return imageDesc;
  }

  /**
   * Creates the menu item for the editor descriptor.
   *
   * @param menu the menu to add the item to
   * @param descriptor the editor descriptor, or null for the system editor
   * @param preferredEditor the descriptor of the preferred editor, or <code>null</code>
   */
  private MenuItem createMenuItem(
      Menu menu, final IEditorDescriptor descriptor, final IEditorDescriptor preferredEditor) {
    // XXX: Would be better to use bold here, but SWT does not support it.
    final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
    boolean isPreferred =
        preferredEditor != null && descriptor.getId().equals(preferredEditor.getId());
    menuItem.setSelection(isPreferred);
    menuItem.setText(descriptor.getLabel());
    Image image = getImage(descriptor);
    if (image != null) {
      menuItem.setImage(image);
    }
    Listener listener =
        new Listener() {
          public void handleEvent(Event event) {
            switch (event.type) {
              case SWT.Selection:
                if (menuItem.getSelection()) {
                  openEditor(descriptor, false);
                }
                break;
            }
          }
        };
    menuItem.addListener(SWT.Selection, listener);
    return menuItem;
  }

  /**
   * Creates the Other... menu item
   *
   * @param menu the menu to add the item to
   */
  private void createOtherMenuItem(final Menu menu) {
    final IFileRevision fileResource = getFileRevision();
    if (fileResource == null) {
      return;
    }
    new MenuItem(menu, SWT.SEPARATOR);
    final MenuItem menuItem = new MenuItem(menu, SWT.PUSH);
    menuItem.setText(TeamUIMessages.LocalHistoryPage_OpenWithMenu_Other);
    Listener listener =
        new Listener() {
          public void handleEvent(Event event) {
            switch (event.type) {
              case SWT.Selection:
                EditorSelectionDialog dialog = new EditorSelectionDialog(menu.getShell());
                dialog.setMessage(
                    NLS.bind(
                        TeamUIMessages.LocalHistoryPage_OpenWithMenu_OtherDialogDescription,
                        fileResource.getName()));
                if (dialog.open() == Window.OK) {
                  IEditorDescriptor editor = dialog.getSelectedEditor();
                  if (editor != null) {
                    openEditor(editor, editor.isOpenExternal());
                  }
                }
                break;
            }
          }
        };
    menuItem.addListener(SWT.Selection, listener);
  }

  public void fill(Menu menu, int index) {
    final IFileRevision fileRevision = getFileRevision();
    if (fileRevision == null) {
      return;
    }

    IEditorDescriptor defaultTextEditor =
        registry.findEditor("org.eclipse.ui.DefaultTextEditor"); // $NON-NLS-1$
    IEditorDescriptor preferredEditor = Utils.getDefaultEditor(fileRevision);

    Object[] editors = Utils.getEditors(fileRevision);
    Collections.sort(Arrays.asList(editors), comparer);
    boolean defaultFound = false;

    // Check that we don't add it twice. This is possible
    // if the same editor goes to two mappings.
    ArrayList alreadyMapped = new ArrayList();

    for (int i = 0; i < editors.length; i++) {
      IEditorDescriptor editor = (IEditorDescriptor) editors[i];
      if (!alreadyMapped.contains(editor)) {
        createMenuItem(menu, editor, preferredEditor);
        if (defaultTextEditor != null && editor.getId().equals(defaultTextEditor.getId())) {
          defaultFound = true;
        }
        alreadyMapped.add(editor);
      }
    }

    // Only add a separator if there is something to separate
    if (editors.length > 0) {
      new MenuItem(menu, SWT.SEPARATOR);
    }

    // Add default editor. Check it if it is saved as the preference.
    if (!defaultFound && defaultTextEditor != null) {
      createMenuItem(menu, defaultTextEditor, preferredEditor);
    }

    // TODO : We might perhaps enable inplace and system external editors menu items
    /*// Add system editor
    IEditorDescriptor descriptor = registry
    		.findEditor(IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID);
    final MenuItem systemEditorMenuItem = createMenuItem(menu, descriptor,
    		preferredEditor);
    systemEditorMenuItem.setEnabled(false);

    // Add system in-place editor
    descriptor = registry
    		.findEditor(IEditorRegistry.SYSTEM_INPLACE_EDITOR_ID);

    final MenuItem inPlaceEditorMenuItem = (descriptor != null) ? createMenuItem(
    		menu, descriptor, preferredEditor)
    		: null;
    if (inPlaceEditorMenuItem != null)
    	inPlaceEditorMenuItem.setEnabled(false);

    Job job = new Job("updateOpenWithMenu") { //$NON-NLS-1$
    	protected IStatus run(IProgressMonitor monitor) {
    		try {
    			final boolean isFile = fileRevision.getStorage(monitor) instanceof IFile;
    			Display.getDefault().asyncExec(new Runnable() {
    				public void run() {
    					if (inPlaceEditorMenuItem != null
    							&& !inPlaceEditorMenuItem.isDisposed())
    						inPlaceEditorMenuItem.setEnabled(isFile);
    					if (!systemEditorMenuItem.isDisposed())
    						systemEditorMenuItem.setEnabled(isFile);
    				}
    			});
    			return Status.OK_STATUS;
    		} catch (CoreException e) {
    			return new Status(IStatus.WARNING, TeamUIPlugin.ID, null, e);
    		}
    	};
    };
    job.setSystem(true);
    job.schedule();*/

    createDefaultMenuItem(menu, fileRevision);

    // add Other... menu item
    createOtherMenuItem(menu);
  }

  public void createDefaultMenuItem(Menu menu, final IFileRevision revision) {
    final MenuItem menuItem = new MenuItem(menu, SWT.RADIO);
    menuItem.setSelection(Utils.getDefaultEditor(revision) == null);
    menuItem.setText(TeamUIMessages.LocalHistoryPage_OpenWithMenu_DefaultEditorDescription);

    Listener listener =
        new Listener() {
          public void handleEvent(Event event) {
            switch (event.type) {
              case SWT.Selection:
                if (menuItem.getSelection()) {
                  openEditor(Utils.getDefaultEditor(revision), false);
                }
                break;
            }
          }
        };

    menuItem.addListener(SWT.Selection, listener);
  }

  /** Opens the given editor on the selected file revision. */
  protected void openEditor(IEditorDescriptor editorDescriptor, boolean openUsingDescriptor) {
    IFileRevision fileRevision = getFileRevision();
    if (fileRevision == null) {
      return;
    }
    try {
      IProgressMonitor monitor = new NullProgressMonitor();
      IStorage storage = fileRevision.getStorage(monitor);
      boolean isFile = storage instanceof IFile;

      if (openUsingDescriptor) {
        // discouraged access to open system editors
        ((WorkbenchPage) (page.getSite().getPage()))
            .openEditorFromDescriptor(
                isFile
                    ? new FileEditorInput((IFile) storage)
                    : (IEditorInput)
                        FileRevisionEditorInput.createEditorInputFor(fileRevision, monitor),
                editorDescriptor,
                true,
                null);
      } else {
        String editorId =
            editorDescriptor == null
                ? IEditorRegistry.SYSTEM_EXTERNAL_EDITOR_ID
                : editorDescriptor.getId();
        page.getSite()
            .getPage()
            .openEditor(
                isFile
                    ? new FileEditorInput((IFile) storage)
                    : (IEditorInput)
                        FileRevisionEditorInput.createEditorInputFor(fileRevision, monitor),
                editorId,
                true,
                MATCH_BOTH);
      }
    } catch (PartInitException e) {
      StatusAdapter statusAdapter = new StatusAdapter(e.getStatus());
      statusAdapter.setProperty(
          IStatusAdapterConstants.TITLE_PROPERTY, TeamUIMessages.LocalHistoryPage_OpenEditorError);
      StatusManager.getManager().handle(statusAdapter, StatusManager.SHOW);
    } catch (CoreException e) {
      StatusAdapter statusAdapter = new StatusAdapter(e.getStatus());
      statusAdapter.setProperty(
          IStatusAdapterConstants.TITLE_PROPERTY, TeamUIMessages.LocalHistoryPage_OpenEditorError);
      StatusManager.getManager().handle(statusAdapter, StatusManager.LOG);
    }
  }

  private IFileRevision getFileRevision() {
    IStructuredSelection structSel = selection;

    IFileRevision revision = null;

    if (structSel == null) return null;

    Object[] objArray = structSel.toArray();

    for (int i = 0; i < objArray.length; i++) {
      Object tempRevision = objArray[i];
      // If not a revision, don't try opening
      if (tempRevision instanceof AbstractHistoryCategory) continue;

      revision = (IFileRevision) tempRevision;
    }
    return revision;
  }

  /*
   * (non-Javadoc) Returns whether this menu is dynamic.
   */
  public boolean isDynamic() {
    return true;
  }

  public void selectionChanged(IStructuredSelection selection) {
    if (selection instanceof IStructuredSelection) {
      this.selection = selection;
    } else {
      this.selection = StructuredSelection.EMPTY;
    }
  }
}
Exemplo n.º 5
0
 /**
  * Returns the default title image.
  *
  * @return the default image
  */
 protected Image getDefaultImage() {
   return PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_DEF_VIEW);
 }