| /****************************************************************************** |
| * Copyright (c) 2008 Oracle |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Konstantin Komissarchik - initial implementation and ongoing maintenance |
| ******************************************************************************/ |
| |
| package org.eclipse.wst.common.project.facet.ui; |
| |
| import java.lang.reflect.InvocationTargetException; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.jface.dialogs.ErrorDialog; |
| import org.eclipse.jface.operation.IRunnableWithProgress; |
| import org.eclipse.jface.wizard.IWizardContainer; |
| import org.eclipse.jface.wizard.IWizardPage; |
| import org.eclipse.jface.wizard.Wizard; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.swt.events.DisposeEvent; |
| import org.eclipse.swt.events.DisposeListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.wst.common.project.facet.core.FacetedProjectFramework; |
| import org.eclipse.wst.common.project.facet.core.FacetedProjectFrameworkException; |
| import org.eclipse.wst.common.project.facet.core.IActionDefinition; |
| import org.eclipse.wst.common.project.facet.core.ICategory; |
| import org.eclipse.wst.common.project.facet.core.IFacetedProject; |
| import org.eclipse.wst.common.project.facet.core.IFacetedProjectWorkingCopy; |
| import org.eclipse.wst.common.project.facet.core.IPreset; |
| import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion; |
| import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager; |
| import org.eclipse.wst.common.project.facet.core.IFacetedProject.Action; |
| import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectEvent; |
| import org.eclipse.wst.common.project.facet.core.events.IFacetedProjectListener; |
| import org.eclipse.wst.common.project.facet.core.util.IFilter; |
| import org.eclipse.wst.common.project.facet.core.util.IFilter.IFilterEvent; |
| import org.eclipse.wst.common.project.facet.core.util.IFilter.IFilterListener; |
| import org.eclipse.wst.common.project.facet.ui.internal.FacetUiPlugin; |
| import org.eclipse.wst.common.project.facet.ui.internal.FacetsSelectionPage; |
| |
| /** |
| * @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a> |
| */ |
| |
| public class ModifyFacetedProjectWizard |
| |
| extends Wizard |
| |
| { |
| private IFacetedProjectWorkingCopy fpjwc; |
| private final WizardContext context = new WizardContext(); |
| private boolean showFacetsSelectionPage; |
| private FacetsSelectionPage facetsSelectionPage; |
| private FacetPages[] facetPages = new FacetPages[ 0 ]; |
| private Composite pageContainer; |
| private final List<IWizardPage> pagesToDispose = new ArrayList<IWizardPage>(); |
| private final List<Runnable> delayedActions; |
| private final List<Runnable> onDisposeActions; |
| private final boolean disposeWorkingCopy; |
| |
| public ModifyFacetedProjectWizard() |
| { |
| this( (IFacetedProject) null ); |
| } |
| |
| public ModifyFacetedProjectWizard( final IFacetedProject fproj ) |
| { |
| this( fproj == null |
| ? FacetedProjectFramework.createNewProject() |
| : fproj.createWorkingCopy(), true ); |
| } |
| |
| public ModifyFacetedProjectWizard( final IFacetedProjectWorkingCopy fpjwc ) |
| { |
| this( fpjwc, false ); |
| } |
| |
| private ModifyFacetedProjectWizard( final IFacetedProjectWorkingCopy fpjwc, |
| final boolean disposeWorkingCopy ) |
| { |
| try |
| { |
| this.fpjwc = fpjwc; |
| this.delayedActions = new ArrayList<Runnable>(); |
| this.onDisposeActions = new ArrayList<Runnable>(); |
| this.disposeWorkingCopy = disposeWorkingCopy; |
| this.facetsSelectionPage = null; |
| this.showFacetsSelectionPage = true; |
| |
| setNeedsProgressMonitor( true ); |
| setForcePreviousAndNextButtons( true ); |
| setWindowTitle( Resources.wizardTitle ); |
| } |
| catch( RuntimeException e ) |
| { |
| FacetUiPlugin.log( e ); |
| throw e; |
| } |
| } |
| |
| public final IFacetedProjectWorkingCopy getFacetedProjectWorkingCopy() |
| { |
| return this.fpjwc; |
| } |
| |
| public void setFacetedProjectWorkingCopy( final IFacetedProjectWorkingCopy fpjwc ) |
| { |
| this.fpjwc = fpjwc; |
| } |
| |
| public final IFacetedProject getFacetedProject() |
| { |
| IFacetedProject fproj = this.fpjwc.getFacetedProject(); |
| |
| if( fproj == null ) |
| { |
| final String projectName = this.fpjwc.getProjectName(); |
| |
| if( projectName != null ) |
| { |
| final IProject proj |
| = ResourcesPlugin.getWorkspace().getRoot().getProject( projectName ); |
| |
| try |
| { |
| fproj = ProjectFacetsManager.create( proj ); |
| } |
| catch( CoreException e ) |
| { |
| FacetUiPlugin.log( e ); |
| } |
| } |
| } |
| |
| return fproj; |
| } |
| |
| public void addPages() |
| { |
| final IFacetedProjectListener listener = new IFacetedProjectListener() |
| { |
| public void handleEvent( final IFacetedProjectEvent event ) |
| { |
| final Runnable runnable = new Runnable() |
| { |
| public void run() |
| { |
| handleSelectedFacetsChangedEvent(); |
| } |
| }; |
| |
| Display.getDefault().asyncExec( runnable ); |
| } |
| }; |
| |
| this.fpjwc.addListener( listener, IFacetedProjectEvent.Type.PROJECT_FACETS_CHANGED ); |
| |
| this.onDisposeActions.add |
| ( |
| new Runnable() |
| { |
| public void run() |
| { |
| ModifyFacetedProjectWizard.this.fpjwc.removeListener( listener ); |
| } |
| } |
| ); |
| |
| if( getShowFacetsSelectionPage() ) |
| { |
| this.facetsSelectionPage = new FacetsSelectionPage( getBaseFacets(), this.fpjwc ); |
| addPage( this.facetsSelectionPage ); |
| } |
| } |
| |
| public int getPageCount() |
| { |
| return getPages().length; |
| } |
| |
| public IWizardPage[] getPages() |
| { |
| final List<IWizardPage> list = new ArrayList<IWizardPage>(); |
| |
| if( this.facetsSelectionPage != null ) |
| { |
| list.add( this.facetsSelectionPage ); |
| } |
| |
| for( int i = 0; i < this.facetPages.length; i++ ) |
| { |
| list.addAll( this.facetPages[ i ].pages ); |
| } |
| |
| return list.toArray( new IWizardPage[ list.size() ] ); |
| } |
| |
| public IWizardPage getPage( final String pageName ) |
| { |
| final IWizardPage[] pages = getPages(); |
| |
| for( int i = 0; i < pages.length; i++ ) |
| { |
| final IWizardPage page = pages[ i ]; |
| |
| if( page.getName().equals( pageName ) ) |
| { |
| return page; |
| } |
| } |
| |
| return null; |
| } |
| |
| public IWizardPage getStartingPage() |
| { |
| return getPages()[ 0 ]; |
| } |
| |
| public IWizardPage getNextPage( final IWizardPage page ) |
| { |
| final IWizardPage[] pages = getPages(); |
| |
| int pos = -1; |
| |
| for( int i = 0; i < pages.length; i++ ) |
| { |
| if( pages[ i ] == page ) |
| { |
| pos = i; |
| } |
| } |
| |
| if( pos == pages.length - 1 ) |
| { |
| return null; |
| } |
| else |
| { |
| return pages[ pos + 1 ]; |
| } |
| } |
| |
| public IWizardPage getPreviousPage( final IWizardPage page ) |
| { |
| final IWizardPage[] pages = getPages(); |
| |
| int pos = -1; |
| |
| for( int i = 0; i < pages.length; i++ ) |
| { |
| if( pages[ i ] == page ) |
| { |
| pos = i; |
| } |
| } |
| |
| if( pos == 0 ) |
| { |
| return null; |
| } |
| else |
| { |
| return pages[ pos - 1 ]; |
| } |
| } |
| |
| public boolean canFinish() |
| { |
| if( this.facetsSelectionPage != null && ! this.facetsSelectionPage.isPageComplete() ) |
| { |
| return false; |
| } |
| |
| final IWizardPage[] pages = getPages(); |
| |
| for( int i = 0; i < pages.length; i++ ) |
| { |
| if( ! pages[ i ].isPageComplete() ) |
| { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| public void createPageControls( final Composite container ) |
| { |
| super.createPageControls( container ); |
| this.pageContainer = container; |
| handleSelectedFacetsChangedEvent(); |
| executeDelayedActions(); |
| } |
| |
| public boolean performFinish() |
| { |
| for( int i = 0; i < this.facetPages.length; i++ ) |
| { |
| for( IFacetWizardPage fp : this.facetPages[ i ].pages ) |
| { |
| fp.transferStateToConfig(); |
| } |
| } |
| |
| final IWorkspaceRunnable wr = new IWorkspaceRunnable() |
| { |
| public void run( final IProgressMonitor monitor ) |
| |
| throws CoreException |
| |
| { |
| performFinish( monitor ); |
| } |
| }; |
| |
| final IRunnableWithProgress op = new IRunnableWithProgress() |
| { |
| public void run( final IProgressMonitor monitor ) |
| |
| throws InvocationTargetException, InterruptedException |
| |
| { |
| try |
| { |
| final IWorkspace ws = ResourcesPlugin.getWorkspace(); |
| ws.run( wr, ws.getRoot(), IWorkspace.AVOID_UPDATE, monitor ); |
| } |
| catch( CoreException e ) |
| { |
| throw new InvocationTargetException( e ); |
| } |
| } |
| }; |
| |
| try |
| { |
| getContainer().run( true, false, op ); |
| } |
| catch( InterruptedException e ) |
| { |
| return false; |
| } |
| catch( InvocationTargetException e ) |
| { |
| final Throwable te = e.getTargetException(); |
| |
| if( te instanceof CoreException ) |
| { |
| IStatus st = ( (CoreException) te ).getStatus(); |
| final String msg = st.getMessage(); |
| |
| if( ! ( te instanceof FacetedProjectFrameworkException ) || |
| ! ( (FacetedProjectFrameworkException) te ).isExpected() ) |
| { |
| FacetUiPlugin.log( st ); |
| } |
| |
| final Throwable cause = st.getException(); |
| |
| if( cause instanceof CoreException ) |
| { |
| st = ( (CoreException) cause ).getStatus(); |
| } |
| |
| ErrorDialog.openError( getShell(), Resources.errDlgTitle, msg, st ); |
| } |
| else |
| { |
| throw new RuntimeException( e.getTargetException() ); |
| } |
| } |
| |
| return true; |
| } |
| |
| protected void performFinish( final IProgressMonitor monitor ) |
| |
| throws CoreException |
| |
| { |
| this.fpjwc.commitChanges( monitor ); |
| } |
| |
| public void syncWithPresetsModel( final Combo combo ) |
| { |
| syncWithPresetsModel( this.fpjwc, combo ); |
| } |
| |
| public static void syncWithPresetsModel( final IFacetedProjectWorkingCopy fpjwc, |
| final Combo combo ) |
| { |
| syncWithPresetsModel( fpjwc, combo, null ); |
| } |
| |
| public static void syncWithPresetsModel( final IFacetedProjectWorkingCopy fpjwc, |
| final Combo combo, |
| final IFilter<IPreset> filter ) |
| { |
| final List<IPreset> sortedPresets = new ArrayList<IPreset>(); |
| |
| // Contents : model -> view |
| |
| final IFacetedProjectListener availablePresetsChangedListener = new IFacetedProjectListener() |
| { |
| public void handleEvent( final IFacetedProjectEvent event ) |
| { |
| final Runnable runnable = new Runnable() |
| { |
| public void run() |
| { |
| if( combo.isDisposed() ) |
| { |
| return; |
| } |
| |
| synchronized( sortedPresets ) |
| { |
| sortedPresets.clear(); |
| |
| if( filter != null ) |
| { |
| for( IPreset preset : fpjwc.getAvailablePresets() ) |
| { |
| if( filter.check( preset ) ) |
| { |
| sortedPresets.add( preset ); |
| } |
| } |
| } |
| else |
| { |
| sortedPresets.addAll( fpjwc.getAvailablePresets() ); |
| } |
| |
| Collections.sort |
| ( |
| sortedPresets, |
| new Comparator<IPreset>() |
| { |
| public int compare( final IPreset p1, |
| final IPreset p2 ) |
| { |
| if( p1 == p2 ) |
| { |
| return 0; |
| } |
| else |
| { |
| return p1.getLabel().compareTo( p2.getLabel() ); |
| } |
| } |
| } |
| ); |
| |
| final IPreset selectedPreset = fpjwc.getSelectedPreset(); |
| |
| combo.removeAll(); |
| combo.add( Resources.customPreset ); |
| |
| if( selectedPreset == null ) |
| { |
| combo.select( 0 ); |
| } |
| |
| for( IPreset preset : sortedPresets ) |
| { |
| combo.add( preset.getLabel() ); |
| |
| if( selectedPreset != null && |
| preset.getId().equals( selectedPreset.getId() ) ) |
| { |
| combo.select( combo.getItemCount() - 1 ); |
| } |
| } |
| } |
| } |
| }; |
| |
| Display.getDefault().asyncExec( runnable ); |
| } |
| }; |
| |
| fpjwc.addListener( availablePresetsChangedListener, |
| IFacetedProjectEvent.Type.AVAILABLE_PRESETS_CHANGED ); |
| |
| if( filter != null ) |
| { |
| filter.addListener |
| ( |
| new IFilterListener<IPreset>() |
| { |
| public void handleEvent( final IFilterEvent<IPreset> event ) |
| { |
| availablePresetsChangedListener.handleEvent( null ); |
| } |
| }, |
| IFilterEvent.Type.FILTER_CHANGED |
| ); |
| } |
| |
| final IFacetedProjectListener selectedPresetChangedListener = new IFacetedProjectListener() |
| { |
| public void handleEvent( final IFacetedProjectEvent event ) |
| { |
| final Runnable runnable = new Runnable() |
| { |
| public void run() |
| { |
| synchronized( sortedPresets ) |
| { |
| final IPreset preset = fpjwc.getSelectedPreset(); |
| final int index; |
| |
| if( preset == null ) |
| { |
| index = -1; |
| } |
| else |
| { |
| index = sortedPresets.indexOf( preset ); |
| } |
| |
| combo.select( index + 1 ); |
| } |
| } |
| }; |
| |
| Display.getDefault().asyncExec( runnable ); |
| } |
| }; |
| |
| fpjwc.addListener( selectedPresetChangedListener, |
| IFacetedProjectEvent.Type.SELECTED_PRESET_CHANGED ); |
| |
| // Selection : view -> model |
| |
| combo.addSelectionListener |
| ( |
| new SelectionAdapter() |
| { |
| public void widgetSelected( final SelectionEvent e ) |
| { |
| synchronized( sortedPresets ) |
| { |
| final int selection = combo.getSelectionIndex(); |
| final String presetId; |
| |
| if( selection == 0 ) |
| { |
| presetId = null; |
| } |
| else |
| { |
| presetId = sortedPresets.get( selection - 1 ).getId(); |
| } |
| |
| fpjwc.setSelectedPreset( presetId ); |
| } |
| } |
| } |
| ); |
| |
| // Trigger initial UI population. |
| |
| availablePresetsChangedListener.handleEvent( null ); |
| |
| // Make sure to remove working copy listeners when the widget is disposed. |
| |
| combo.addDisposeListener |
| ( |
| new DisposeListener() |
| { |
| public void widgetDisposed( final DisposeEvent event ) |
| { |
| fpjwc.removeListener( availablePresetsChangedListener ); |
| fpjwc.removeListener( selectedPresetChangedListener ); |
| } |
| } |
| ); |
| } |
| |
| public void setCategoryExpandedState( final ICategory category, |
| final boolean expanded ) |
| { |
| if( this.facetsSelectionPage != null && this.facetsSelectionPage.panel != null ) |
| { |
| this.facetsSelectionPage.panel.setCategoryExpandedState( category, true ); |
| } |
| else |
| { |
| final Runnable action = new Runnable() |
| { |
| public void run() |
| { |
| setCategoryExpandedState( category, expanded ); |
| } |
| }; |
| |
| this.delayedActions.add( action ); |
| } |
| } |
| |
| public boolean getShowFacetsSelectionPage() |
| { |
| return this.showFacetsSelectionPage; |
| } |
| |
| public void setShowFacetsSelectionPage( final boolean showFacetsSelectionPage ) |
| { |
| this.showFacetsSelectionPage = showFacetsSelectionPage; |
| } |
| |
| public void dispose() |
| { |
| super.dispose(); |
| |
| for( int i = 0; i < this.facetPages.length; i++ ) |
| { |
| this.pagesToDispose.addAll( this.facetPages[ i ].pages ); |
| } |
| |
| for( IWizardPage page : this.pagesToDispose ) |
| { |
| page.dispose(); |
| } |
| |
| for( Runnable onDisposeAction : this.onDisposeActions ) |
| { |
| try |
| { |
| onDisposeAction.run(); |
| } |
| catch( Exception e ) |
| { |
| FacetUiPlugin.log( e ); |
| } |
| } |
| |
| if( this.disposeWorkingCopy ) |
| { |
| this.fpjwc.dispose(); |
| } |
| } |
| |
| private static final class FacetPages |
| { |
| public Action action; |
| public List<IFacetWizardPage> pages; |
| } |
| |
| private void handleSelectedFacetsChangedEvent() |
| { |
| // Don't do anything until there are no more validation errors. |
| |
| if( this.fpjwc.validate().getSeverity() == IStatus.ERROR) |
| { |
| return; |
| } |
| |
| // Get the set of actions and sort them. |
| |
| final Set<IProjectFacetVersion> base = getBaseFacets(); |
| final Set<Action> actions = getFacetedProjectWorkingCopy().getProjectFacetActions(); |
| final List<Action> sortedActions = new ArrayList<Action>( actions ); |
| ProjectFacetsManager.sort( base, sortedActions ); |
| |
| // Recalculate the sequence of wizard pages. |
| |
| final List<FacetPages> newFacetPages = new ArrayList<FacetPages>(); |
| final boolean[] markers = new boolean[ this.facetPages.length ]; |
| boolean changed = false; |
| |
| for( Action action : sortedActions ) |
| { |
| final IProjectFacetVersion fv = action.getProjectFacetVersion(); |
| FacetPages fp = findFacetPages( action, markers ); |
| |
| if( fp == null ) |
| { |
| final IActionDefinition actiondef; |
| |
| try |
| { |
| actiondef = fv.getActionDefinition( base, action.getType() ); |
| } |
| catch( CoreException e ) |
| { |
| FacetUiPlugin.log( e ); |
| continue; |
| } |
| |
| final List<IFacetWizardPage> pages |
| = ProjectFacetsUiManager.getWizardPages( actiondef.getId() ); |
| |
| if( ! pages.isEmpty() ) |
| { |
| fp = new FacetPages(); |
| fp.action = action; |
| fp.pages = pages; |
| |
| for( IFacetWizardPage page : fp.pages ) |
| { |
| page.setWizard( this ); |
| page.setWizardContext( this.context ); |
| page.setConfig( action.getConfig() ); |
| |
| if( page.getControl() == null ) |
| { |
| page.createControl( this.pageContainer ); |
| page.getControl().setVisible( false ); |
| } |
| } |
| |
| changed = true; |
| } |
| } |
| |
| if( fp != null ) |
| { |
| newFacetPages.add( fp ); |
| } |
| } |
| |
| for( int i = 0; i < this.facetPages.length; i++ ) |
| { |
| if( ! markers[ i ] ) |
| { |
| for( IFacetWizardPage page : this.facetPages[ i ].pages ) |
| { |
| page.setWizard( null ); |
| this.pagesToDispose.add( page ); |
| } |
| |
| changed = true; |
| } |
| } |
| |
| if( changed ) |
| { |
| this.facetPages = new FacetPages[ newFacetPages.size() ]; |
| newFacetPages.toArray( this.facetPages ); |
| |
| this.pageContainer.layout( true, true ); |
| |
| final IWizardContainer wizardContainer = getContainer(); |
| |
| if( wizardContainer.getCurrentPage() != null ) |
| { |
| wizardContainer.updateButtons(); |
| } |
| } |
| } |
| |
| private FacetPages findFacetPages( final Action action, |
| final boolean[] markers ) |
| { |
| for( int i = 0; i < this.facetPages.length; i++ ) |
| { |
| final FacetPages fp = this.facetPages[ i ]; |
| |
| if( fp.action == action ) |
| { |
| markers[ i ] = true; |
| return fp; |
| } |
| } |
| |
| return null; |
| } |
| |
| private Set<IProjectFacetVersion> getBaseFacets() |
| { |
| final IFacetedProject fproj = this.fpjwc.getFacetedProject(); |
| |
| if( fproj == null ) |
| { |
| return Collections.emptySet(); |
| } |
| else |
| { |
| return fproj.getProjectFacets(); |
| } |
| } |
| |
| private void executeDelayedActions() |
| { |
| for( Runnable r : this.delayedActions ) |
| { |
| try |
| { |
| r.run(); |
| } |
| catch( Exception e ) |
| { |
| FacetUiPlugin.log( e ); |
| } |
| } |
| } |
| |
| /** |
| * @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a> |
| */ |
| |
| private final class WizardContext |
| |
| implements IWizardContext |
| |
| { |
| public String getProjectName() |
| { |
| return getFacetedProjectWorkingCopy().getProjectName(); |
| } |
| |
| public Set<IProjectFacetVersion> getSelectedProjectFacets() |
| { |
| return getFacetedProjectWorkingCopy().getProjectFacets(); |
| } |
| |
| public boolean isProjectFacetSelected( final IProjectFacetVersion fv ) |
| { |
| return getSelectedProjectFacets().contains( fv ); |
| } |
| |
| public Set<Action> getActions() |
| { |
| return getFacetedProjectWorkingCopy().getProjectFacetActions(); |
| } |
| |
| public Action getAction( final Action.Type type, |
| final IProjectFacetVersion f ) |
| { |
| for( Action action : getActions() ) |
| { |
| if( action.getType() == type && action.getProjectFacetVersion() == f ) |
| { |
| return action; |
| } |
| } |
| |
| return null; |
| } |
| |
| public Object getConfig( final IProjectFacetVersion fv, |
| final Action.Type type, |
| final String pjname ) |
| { |
| final Action action = getAction( type, fv ); |
| return action != null ? action.getConfig() : null; |
| } |
| } |
| |
| private static final class Resources |
| |
| extends NLS |
| |
| { |
| public static String wizardTitle; |
| public static String errDlgTitle; |
| public static String customPreset; |
| |
| static |
| { |
| initializeMessages( ModifyFacetedProjectWizard.class.getName(), |
| Resources.class ); |
| } |
| } |
| |
| } |
