/** * Returns with the strategy for the given property change even argument, * * @param event * a property change argument. * @return a strategy encapsulating an actual working set manager modification. */ public WorkingSetManagerModificationStrategy getStrategy(final PropertyChangeEvent event) { if (event == null) { return NOOP; } final String property = event.getProperty(); switch (property) { case CHANGE_WORKING_SET_ADD: return new AddWorkingSetModificationStrategy((IWorkingSet) event.getNewValue()); case CHANGE_WORKING_SET_REMOVE: return new RemoveWorkingSetModificationStrategy((IWorkingSet) event.getOldValue()); case CHANGE_WORKING_SET_LABEL_CHANGE: //$FALL-THROUGH$ case CHANGE_WORKING_SET_NAME_CHANGE: //$FALL-THROUGH$ case CHANGE_WORKING_SET_CONTENT_CHANGE: return new UpdateWorkingSetModificationStraregy( (IWorkingSet) event.getOldValue(), (IWorkingSet) event.getNewValue()); default: return NOOP; } }
@Override public boolean performFinish() { boolean res = super.performFinish(); if( res ) { final IJavaElement newElement = getCreatedElement(); IWorkingSet[] workingSets = fFirstPage.getWorkingSets(); if( workingSets.length > 0 ) { PlatformUI.getWorkbench().getWorkingSetManager().addToWorkingSets(newElement, workingSets); } BasicNewResourceWizard.selectAndReveal(fSecondPage.getJavaProject().getProject(), getWorkbench() .getActiveWorkbenchWindow()); } return res; }
@Test public void resolve__workingset_1_contains_project1__so_one_entry_for_workingset_is_returned() { /* prepare */ ArrayList<IProject> projects = new ArrayList<>(); projects.add(mockedProject1); projects.add(mockedProject2); when(mockedManager.getAllWorkingSets()).thenReturn(new IWorkingSet[]{mockedWorkingSet1}); when(mockedWorkingSet1.getElements()).thenReturn(new IAdaptable[]{mockedProject1Adaptable}); /* execute */ List<WorkingSetData> workingSetDataList = supportToTest.resolveWorkingSetsForProjects(projects, mockedManager); /* test */ assertNotNull(workingSetDataList); assertEquals(1,workingSetDataList.size()); WorkingSetData data = workingSetDataList.iterator().next(); assertEquals(mockedWorkingSet1, data.workingSet); assertTrue(data.projectNamesContainedBefore.contains("project1")); assertFalse(data.projectNamesContainedBefore.contains("project2")); }
/** * <p> * Adds the newly created project to the currently selected working set. * </p> * * @param project the project to be added to the selected working set */ private void addProjectToSelectedWorkingSet(IProject project) { IWorkbench workbench = PlatformUI.getWorkbench(); IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow(); if (workbenchWindow == null) { return; } ISelectionService selectionService = workbenchWindow.getSelectionService(); ISelection selection = selectionService.getSelection(); if (selection instanceof IStructuredSelection) { IStructuredSelection structuredSelection = (IStructuredSelection) selection; Object firstElement = structuredSelection.getFirstElement(); if (firstElement instanceof IAdaptable) { IAdaptable adaptable = (IAdaptable) firstElement; IWorkingSet workingSet = (IWorkingSet) adaptable.getAdapter(IWorkingSet.class); if (workingSet != null) { // new project wizard was invoked by right-clicking a working set IWorkingSetManager workingSetManager = workbench.getWorkingSetManager(); workingSetManager.addToWorkingSets(project, new IWorkingSet[]{workingSet}); } } } }
public static String getLabel(final IWorkingSet workingSet) { Check.notNull(workingSet, "workingSet"); //$NON-NLS-1$ try { final Method getLabelMethod = workingSet.getClass().getMethod("getLabel", new Class[0]); //$NON-NLS-1$ final Object labelResult = getLabelMethod.invoke(workingSet, new Object[0]); if (labelResult != null && labelResult instanceof String) { return (String) labelResult; } } catch (final Exception e) { /* Suppress, Eclipse < 3.1 */ } return workingSet.getName(); }
public static boolean isAggregateWorkingSet(final IWorkingSet workingSet) { Check.notNull(workingSet, "workingSet"); //$NON-NLS-1$ try { final Method isAggregateMethod = workingSet.getClass().getMethod("isAggregateWorkingSet", new Class[0]); //$NON-NLS-1$ final Object aggregateResult = isAggregateMethod.invoke(workingSet, new Object[0]); if (aggregateResult != null && aggregateResult instanceof Boolean) { return ((Boolean) aggregateResult).booleanValue(); } } catch (final Exception e) { /* Suppress, Eclipse < 3.1 */ } return false; }
private void selectWorkingSet() { final IWorkingSetSelectionDialog workingSetDialog = PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSetSelectionDialog(getShell(), false); if (workingSetDialog.open() != IDialogConstants.OK_ID) { return; } final IWorkingSet[] selection = workingSetDialog.getSelection(); final IWorkingSet set = selection.length == 0 ? null : selection[0]; computeWorkingSets(set); if (selection.length > 0) { selectWorkingSet(set); } }
private void selectWorkingSetAction() { IWorkingSetManager manager = PlatformUI.getWorkbench().getWorkingSetManager(); IWorkingSetSelectionDialog dialog = manager.createWorkingSetSelectionDialog(getShell(), true); dialog.open(); IWorkingSet[] sets = dialog.getSelection(); if(sets != null) { workingSets = sets; } else { // dialog cancelled return; } updateWorkingSetScope(); updateWorkingSetLabel(); participantScope.setSelection(false); selectedResourcesScope.setSelection(false); workingSetScope.setSelection(true); }
private void updateWorkingSetScope() { if(workingSets != null) { List allWorkingSetResources = new ArrayList(); for (int i = 0; i < workingSets.length; i++) { IWorkingSet set = workingSets[i]; allWorkingSetResources.addAll(IDE.computeSelectedResources(new StructuredSelection(set.getElements()))); } scopeCheckingElement = true; fViewer.setCheckedElements(allWorkingSetResources.toArray(new IResource[allWorkingSetResources.size()])); scopeCheckingElement = false; setPageComplete(true); } else { scopeCheckingElement = true; fViewer.setCheckedElements(new Object[0]); scopeCheckingElement = false; setPageComplete(false); } }
/** * Initializes GUI elements of {@link NewExtensionWizardPage} */ private void initialize() { ExtensionUtils.getTemplates().stream().forEach(template -> extensionTemplateCombo.add(template)); extensionTemplateCombo.setText("yempty"); IWorkingSet[] workingSets = PlatformUI.getWorkbench().getWorkingSetManager().getAllWorkingSets(); if (workingSets != null) { for (IWorkingSet workingSet: workingSets) { if (!workingSet.getName().startsWith("Aggregate")) { workingSetCombo.add(workingSet.getName()); } } } extensionDirectoryField.setStringValue(getDefaultExtensionLocation()); }
private void addExtensionToWorkingSet(IProgressMonitor monitor) { Display.getDefault().syncExec(new Runnable() { public void run() { if (workingSet != null && !workingSet.equals("")) { IProject proj = ResourcesPlugin.getWorkspace().getRoot().getProject(extension.getName()); IWorkingSet ws = PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(workingSet); if (ws == null) { ws = PlatformUI.getWorkbench().getWorkingSetManager().createWorkingSet(workingSet, new IProject[]{proj}); } else { Set<IProject> projs = new HashSet(Arrays.asList(ws.getElements())); projs.add(proj); ws.setElements(projs.toArray(new IProject[projs.size()])); } } } }); }
@Override public boolean performFinish() { createNewProject(); if (newProject == null) { return false; } IWorkingSet[] workingSets = mainPage.getSelectedWorkingSets(); getWorkbench().getWorkingSetManager().addToWorkingSets(newProject, workingSets); updatePerspective(); selectAndReveal(newProject); return true; }
/** * Instantiates a new workbench tree viewer. * * @param parent the parent * @param selectionStyle the selection style * @param rootElement the root element * @param expand the expand * @param extensions the extensions * @param workingSet the working set */ public WorkbenchTreeViewer(Composite parent, int selectionStyle, IResource rootElement, boolean expand, String[] extensions, IWorkingSet workingSet) { super(parent, selectionStyle | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER); this.extensions = extensions; this.workingSet = workingSet; setUseHashlookup(true); initContentProvider(this); initLabelProvider(this); initFilters(this); this.setInput(rootElement); if (expand) { this.expandToLevel(2); } }
private IJavaElement[] getJavaElements(Object[] elements) { if (elements.length == 0) return new IJavaElement[0]; Set<IJavaElement> result = new HashSet<IJavaElement>(elements.length); for (int i = 0; i < elements.length; i++) { Object selectedElement = elements[i]; if (selectedElement instanceof IJavaElement) { addJavaElements(result, (IJavaElement) selectedElement); } else if (selectedElement instanceof IResource) { addJavaElements(result, (IResource) selectedElement); } else if (selectedElement instanceof LogicalPackage) { addJavaElements(result, (LogicalPackage) selectedElement); } else if (selectedElement instanceof IWorkingSet) { IWorkingSet ws = (IWorkingSet) selectedElement; addJavaElements(result, ws); } else if (selectedElement instanceof IAdaptable) { IResource resource = (IResource) ((IAdaptable) selectedElement).getAdapter(IResource.class); if (resource != null) addJavaElements(result, resource); } } return result.toArray(new IJavaElement[result.size()]); }
private GpsProject(IProject project) throws GpsFileException { name = project.getName(); for (IWorkingSet ws: PlatformUI.getWorkbench().getWorkingSetManager().getAllWorkingSets()) { if (ws.getId() != null && ws.getId().equals("org.eclipse.jdt.ui.JavaWorkingSetPage")) { //$NON-NLS-1$ for (IAdaptable element: ws.getElements()) { if (project.equals(element.getAdapter(IProject.class))) { workingSets.add(ws.getName()); break; } } } } try { repositoryHandler = GpsRepositoryFactory.createHandler(project, this); } catch (Throwable t) { throw new GpsFileException("Cannot serialize project {0}", t, project.getName()); } }
public ValidationStatus validate( IWorkingSet editedWorkingSet, String name, String pattern ) { if( name.isEmpty() ) { return new ValidationStatus( ERROR, MSG_NAME_EMPTY ); } if( pattern.isEmpty() ) { return new ValidationStatus( ERROR, MSG_PATTERN_EMPTY ); } if( !isPatternValid( pattern ) ) { return new ValidationStatus( ERROR, MSG_PATTERN_INVALID ); } if( nameExists( editedWorkingSet, name ) ) { return new ValidationStatus( Severity.WARNING, MSG_NAME_EXISTS ); } if( !pattern.isEmpty() && jdtFeature.isInstalled() && !patternMatchesAnyProject( pattern ) ) { return new ValidationStatus( Severity.WARNING, MSG_JDT_RESTRICTION ); } return new ValidationStatus( Severity.NONE, "" ); }
@Test public void testCreateWorkingSet() { wizard.init( PlatformUI.getWorkbench(), null ); wizard.addPages(); DynamicWorkingSetPage startingPage = ( DynamicWorkingSetPage )wizard.getStartingPage(); IWorkingSet workingSet = startingPage.getSelection(); assertThat( workingSet.getName() ).isEmpty(); assertThat( workingSet.getElements() ).isEmpty(); assertThat( workingSet.isSelfUpdating() ).isTrue(); assertThat( workingSet.isAggregateWorkingSet() ).isFalse(); assertThat( workingSet.isEditable() ).isTrue(); assertThat( workingSet.getId() ).isEqualTo( DynamicWorkingSet.ID ); assertThat( workingSet.getLabel() ).isEmpty(); assertThat( workingSet.getImageDescriptor() ).isNotNull(); }
private String getFromSelection(ParameterDescriptor descriptor) { if (selection == null) { return null; } if (descriptor.getType() == ParameterType.WORKINGSET) { for (Object selected : selection.toArray()) { if (selected instanceof IWorkingSet) { IWorkingSet workingSet = (IWorkingSet) selected; if (!workingSet.isAggregateWorkingSet() && IWorkingSetIDs.JAVA.equals(workingSet.getId())) { ParameterMapping mapping = descriptor.getDisplayMapping(); Pattern labelPattern = Pattern.compile(mapping.getPattern()); Matcher matcher = labelPattern.matcher(workingSet.getName()); return matcher.replaceAll(mapping.getReplacement()); } } } } return null; }
private void recalculateCheckedState(List<IWorkingSet> addedWorkingSets) { Set<IWorkingSet> checkedWorkingSets= new HashSet<IWorkingSet>(); GrayedCheckedModelElement[] elements= fModel.getChecked(); for (int i= 0; i < elements.length; i++) checkedWorkingSets.add(elements[i].getWorkingSet()); if (addedWorkingSets != null) checkedWorkingSets.addAll(addedWorkingSets); fModel= createGrayedCheckedModel(fElements, getAllWorkingSets(), checkedWorkingSets); fTableViewer.setInput(fModel); fTableViewer.refresh(); fTableViewer.setCheckedElements(fModel.getChecked()); fTableViewer.setGrayedElements(fModel.getGrayed()); }
@Override public void run(IStructuredSelection selection) { IWorkingSet ws= getWorkingSet(selection); if (ws == null) return; HashSet<IAdaptable> elements= new HashSet<IAdaptable>(Arrays.asList(ws.getElements())); List<?> selectedElements= selection.toList(); for (Iterator<?> iter= selectedElements.iterator(); iter.hasNext();) { Object object= iter.next(); if (object instanceof IAdaptable) { IAdaptable[] adaptedElements= ws.adaptElements(new IAdaptable[] {(IAdaptable)object}); if (adaptedElements.length == 1) { elements.remove(adaptedElements[0]); } } } ws.setElements(elements.toArray(new IAdaptable[elements.size()])); }
static void restoreState() { SearchUtil.fgLRUWorkingSets= new LRUWorkingSetsList(SearchUtil.LRU_WORKINGSET_LIST_SIZE); SearchUtil.fgSettingsStore= JavaPlugin.getDefault().getDialogSettings().getSection(SearchUtil.DIALOG_SETTINGS_KEY); if (SearchUtil.fgSettingsStore == null) SearchUtil.fgSettingsStore= JavaPlugin.getDefault().getDialogSettings().addNewSection(SearchUtil.DIALOG_SETTINGS_KEY); boolean foundLRU= false; for (int i= SearchUtil.LRU_WORKINGSET_LIST_SIZE - 1; i >= 0; i--) { String[] lruWorkingSetNames= SearchUtil.fgSettingsStore.getArray(SearchUtil.STORE_LRU_WORKING_SET_NAMES + i); if (lruWorkingSetNames != null) { Set<IWorkingSet> workingSets= new HashSet<IWorkingSet>(2); for (int j= 0; j < lruWorkingSetNames.length; j++) { IWorkingSet workingSet= PlatformUI.getWorkbench().getWorkingSetManager().getWorkingSet(lruWorkingSetNames[j]); if (workingSet != null) { workingSets.add(workingSet); } } foundLRU= true; if (!workingSets.isEmpty()) SearchUtil.fgLRUWorkingSets.add(workingSets.toArray(new IWorkingSet[workingSets.size()])); } } if (!foundLRU) // try old preference format restoreFromOldFormat(); }
void perform( SubMonitor monitor, File projectDirectory, IWorkingSet[] workingSets, Archive archive, List<String> taskNames, ShafuConsole console, AtomicReference<Stage> stageRef) throws CoreException { monitor.beginTask(Messages.NewProjectWizard_monitorMain, 100); extractProjectContents(monitor.newChild(20, SubMonitor.SUPPRESS_NONE), projectDirectory, archive); boolean succeed = false; try { stageRef.set(Stage.BUILD); buildProject(monitor.newChild(60, SubMonitor.SUPPRESS_NONE), projectDirectory, taskNames, console); stageRef.set(Stage.DEPLOY); deployProject(monitor.newChild(20, SubMonitor.SUPPRESS_NONE), projectDirectory, workingSets); succeed = true; } finally { if (succeed == false && projectDirectory.exists()) { IoUtils.deleteQuietly(projectDirectory); } } }
/** * Adjusts the relative ordering of the active working sets in fAllWorkingSets according to * fActiveWorkingSets. * * @since 3.7 */ private void adjustOrderingOfAllWorkingSets() { int countActive= 0; for (Iterator<IWorkingSet> iter= fAllWorkingSets.iterator(); iter.hasNext();) { IWorkingSet set= iter.next(); if (fActiveWorkingSets.contains(set)) { IWorkingSet workingSet= fActiveWorkingSets.get(countActive++); if (!workingSet.equals(set)) { int index= fAllWorkingSets.indexOf(workingSet); fAllWorkingSets.set(fAllWorkingSets.indexOf(set), workingSet); fAllWorkingSets.set(index, set); } if (countActive == fActiveWorkingSets.size()) return; } } }
@Override public void fillContextMenu(IMenuManager manager) { IMenuManager javaSearchMM= new MenuManager(MENU_TEXT, IContextMenuConstants.GROUP_SEARCH); addAction(fFindDeclarationsAction, javaSearchMM); addAction(fFindDeclarationsInProjectAction, javaSearchMM); addAction(fFindDeclarationsInHierarchyAction, javaSearchMM); javaSearchMM.add(new Separator()); Iterator<IWorkingSet[]> iter= SearchUtil.getLRUWorkingSets().sortedIterator(); while (iter.hasNext()) { addWorkingSetAction(iter.next(), javaSearchMM); } addAction(fFindDeclarationsInWorkingSetAction, javaSearchMM); if (!javaSearchMM.isEmpty()) manager.appendToGroup(fGroupId, javaSearchMM); }
private boolean isNewTarget(Object element) { if (element == null) return true; if (element instanceof IResource) { return true; } if (element instanceof IJavaElement) { int type= ((IJavaElement)element).getElementType(); return type == IJavaElement.JAVA_PROJECT || type == IJavaElement.PACKAGE_FRAGMENT_ROOT || type == IJavaElement.PACKAGE_FRAGMENT || type == IJavaElement.COMPILATION_UNIT || type == IJavaElement.TYPE; } if (element instanceof IWorkingSet) { String workingSetId= ((IWorkingSet)element).getId(); return IWorkingSetIDs.JAVA.equals(workingSetId) || IWorkingSetIDs.RESOURCE.equals(workingSetId) || IWorkingSetIDs.OTHERS.equals(workingSetId); } return false; }
private void createWorkingSet() { IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager(); IWorkingSetNewWizard wizard= manager.createWorkingSetNewWizard(new String[] {IWorkingSetIDs.JAVA}); // the wizard can't be null since we have at least the Java working set. WizardDialog dialog= new WizardDialog(getShell(), wizard); dialog.create(); if (dialog.open() == Window.OK) { IWorkingSet workingSet= wizard.getSelection(); if (WorkingSetModel.isSupportedAsTopLevelElement(workingSet)) { fAllWorkingSets.add(workingSet); fTableViewer.add(workingSet); fTableViewer.setSelection(new StructuredSelection(workingSet), true); fTableViewer.setChecked(workingSet, true); manager.addWorkingSet(workingSet); fAddedWorkingSets.add(workingSet); } } }
@Override public void run() { Shell shell= getShell(); IWorkingSetManager manager= PlatformUI.getWorkbench().getWorkingSetManager(); IWorkingSetSelectionDialog dialog= manager.createWorkingSetSelectionDialog(shell, false); IWorkingSet workingSet= fActionGroup.getWorkingSet(); if (workingSet != null) dialog.setSelection(new IWorkingSet[]{workingSet}); if (dialog.open() == Window.OK) { IWorkingSet[] result= dialog.getSelection(); if (result != null && result.length > 0) { fActionGroup.setWorkingSet(result[0], true); manager.addRecentWorkingSet(result[0]); } else fActionGroup.setWorkingSet(null, true); } }
public IAdaptable[] adaptElements(IWorkingSet ws, IAdaptable[] elements) { ArrayList<Object> result= new ArrayList<Object>(elements.length); for (int i= 0; i < elements.length; i++) { IAdaptable curr= elements[i]; if (curr instanceof IJavaElement) { result.add(curr); } else if (curr instanceof IResource) { result.add(adaptFromResource((IResource) curr)); } else { Object elem= curr.getAdapter(IJavaElement.class); if (elem == null) { elem= curr.getAdapter(IResource.class); if (elem != null) { elem= adaptFromResource((IResource) elem); } } if (elem != null) { result.add(elem); } // ignore all others } } return result.toArray(new IAdaptable[result.size()]); }
@Override protected int computeAdornmentFlags(Object obj) { if (!(obj instanceof IWorkingSet)) return super.computeAdornmentFlags(obj); IWorkingSet workingSet= (IWorkingSet)obj; IAdaptable[] elements= workingSet.getElements(); int result= 0; for (int i= 0; i < elements.length; i++) { IAdaptable element= elements[i]; int flags= super.computeAdornmentFlags(element); if ((flags & JavaElementImageDescriptor.BUILDPATH_ERROR) != 0) return JavaElementImageDescriptor.BUILDPATH_ERROR; result|= flags; } if ((result & JavaElementImageDescriptor.ERROR) != 0) return JavaElementImageDescriptor.ERROR; else if ((result & JavaElementImageDescriptor.WARNING) != 0) return JavaElementImageDescriptor.WARNING; return 0; }
