private static SourceGroup[] getSourceGroups(Project project) {
    Sources projectSources = ProjectUtils.getSources(project);
    // first, try to get resources
    SourceGroup[] resources = projectSources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_RESOURCES);
    if (resources.length > 0) {
        return resources;
    }
    // try to create it
    SourceGroup resourcesSourceGroup = SourceGroupModifier.createSourceGroup(
        project, JavaProjectConstants.SOURCES_TYPE_RESOURCES, JavaProjectConstants.SOURCES_HINT_MAIN);
    if (resourcesSourceGroup != null) {
        return new SourceGroup[] {resourcesSourceGroup};
    }
    // fallback to java sources
    return projectSources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
}
 

/**
 * Finds a Java source group the given file belongs to.
 * 
 * @param  file  {@code FileObject} to find a {@code SourceGroup} for
 * @return  the found {@code SourceGroup}, or {@code null} if the given
 *          file does not belong to any Java source group
 */
private static SourceGroup findSourceGroup(FileObject file) {
    final Project project = FileOwnerQuery.getOwner(file);
    if (project == null) {
        return null;
    }

    Sources src = ProjectUtils.getSources(project);
    SourceGroup[] srcGrps = src.getSourceGroups(SOURCES_TYPE_JAVA);
    for (SourceGroup srcGrp : srcGrps) {
        FileObject rootFolder = srcGrp.getRootFolder();
        if (((file == rootFolder) || FileUtil.isParentOf(rootFolder, file)) 
                && srcGrp.contains(file)) {
            return srcGrp;
        }
    }
    return null;
}
 

private static boolean openFromClasspath(FileObject fo, String value) {
    int colonOffset = value.indexOf(":");   //NOI18N
    String subPath = value.substring(colonOffset + 1);
    Project project = FileOwnerQuery.getOwner(fo);
    if (project != null) {
        List<SourceGroup> groups = new ArrayList<>();
        Sources sources = ProjectUtils.getSources(project);
        groups.addAll(Arrays.asList(sources.getSourceGroups("doc_root"))); //NOI18N
        groups.addAll(Arrays.asList(sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA)));
        for (SourceGroup sourceGroup : groups) {
            FileObject fileObject = sourceGroup.getRootFolder().getFileObject(subPath);
            if (fileObject != null) {
                openFile(fileObject);
                return true;
            }
        }
    }
    return false;
}
 

/**
 * Finds a Java source group the given file belongs to.
 * 
 * @param  file  {@literal FileObject} to find a {@literal SourceGroup} for
 * @return  the found {@literal SourceGroup}, or {@literal null} if the given
 *          file does not belong to any Java source group
 */
private static SourceGroup findSourceGroup(FileObject file) {
    final Project project = FileOwnerQuery.getOwner(file);
    if (project == null) {
        return null;
    }

    Sources src = ProjectUtils.getSources(project);
    SourceGroup[] srcGrps = src.getSourceGroups(SOURCES_TYPE_JAVA);
    for (SourceGroup srcGrp : srcGrps) {
        FileObject rootFolder = srcGrp.getRootFolder();
        if (((file == rootFolder) || FileUtil.isParentOf(rootFolder, file)) 
                && srcGrp.contains(file)) {
            return srcGrp;
        }
    }
    return null;
}
 

@Override
public void setUp() throws Exception {
    MockLookup.setLayersAndInstances();

    // in an attempt to find the cause of issue 90762
    Logger.getLogger(PersistenceScopesHelper.class.getName()).setLevel(Level.FINEST);
    // setup the project
    File f = new File(getDataDir().getAbsolutePath(), "projects/ApplicationClient1");
    project = (Project) ProjectSupport.openProject(f);
    Sources src = project.getLookup().lookup(Sources.class);
    SourceGroup[] groups = src.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    root = groups[0].getRootFolder();
    provider = project.getLookup().lookup(AppClientPersistenceProvider.class);
    persistenceLocation = project.getProjectDirectory().getFileObject("src/conf");

    FileObject persistenceXml = persistenceLocation.getFileObject("persistence.xml");
    if (persistenceXml != null) {
        persistenceXml.delete();
    }
}
 

private static Union2<LogicalViewProvider,org.openide.util.Pair<Sources,SourceGroup[]>> createData(
        final Project p,
        final int type) {
    switch (type) {
        case LOGICAL_VIEW:
            final LogicalViewProvider lvp = p.getLookup().lookup(LogicalViewProvider.class);
            if (lvp != null) {
                return Union2.createFirst(lvp);
            }
        case PHYSICAL_VIEW:
            final Sources s = ProjectUtils.getSources(p);
            final SourceGroup[] groups = s.getSourceGroups(Sources.TYPE_GENERIC);                
            return Union2.createSecond(org.openide.util.Pair.of(s, groups));
        default:
            throw new IllegalArgumentException(Integer.toString(type));
    }
}
 

private SourceGroup[] getSourceGroups(Project project, FileObject file) {
    // #239027
    if (FileUtil.getMIMEType(file, JSON_MIME_TYPE, null) != null) {
        return ProjectUtils.getSources(project).getSourceGroups(Sources.TYPE_GENERIC);
    }
    ClientSideProject clientSideProject = getClientSideProject(project);
    if (clientSideProject == null) {
        // #231347
        return ProjectUtils.getSources(project).getSourceGroups(Sources.TYPE_GENERIC);
    }
    SourceGroup[] allGroups = ClientSideProjectUtilities.getSourceGroups(project);
    if (!FileUtilities.isHtmlFile(file)
            && !FileUtilities.isCssFile(file)) {
        // not html or css -> return all source groups
        return allGroups;
    }
    // html or css file -> return only sources or site root
    List<SourceGroup> groups = new ArrayList<>();
    groups.addAll(Arrays.asList(ClientSideProjectUtilities.getSourceGroups(project, WebClientProjectConstants.SOURCES_TYPE_HTML5_SITE_ROOT)));
    groups.addAll(Arrays.asList(ClientSideProjectUtilities.getSourceGroups(project, WebClientProjectConstants.SOURCES_TYPE_HTML5)));
    if (!groups.isEmpty()) {
        return groups.toArray(new SourceGroup[groups.size()]);
    }
    return allGroups;
}
 

public void testManuallyDeletedSourceGroup() throws Exception { // #204545
    TestFileUtils.writeFile(d, "pom.xml", "<project><modelVersion>4.0.0</modelVersion><groupId>g</groupId><artifactId>a</artifactId><version>0</version></project>");
    FileObject main = FileUtil.createFolder(d, "src/main/java");
    FileObject test = FileUtil.createFolder(d, "src/test/java");
    Project p = ProjectManager.getDefault().findProject(d);
    Sources s = ProjectUtils.getSources(p);
    SourceGroup[] grps = s.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    assertEquals(2, grps.length);
    assertEquals(main, grps[0].getRootFolder());
    assertEquals(test, grps[1].getRootFolder());
    MockChangeListener l = new MockChangeListener();
    s.addChangeListener(l);
    test.getParent().delete();
    l.assertEvent();
    grps = s.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    assertEquals(1, grps.length);
    assertEquals(main, grps[0].getRootFolder());
}
 

public static SourceGroup[] getSourceGroups(Project project) {
    SourceGroup[] sourceGroups = null;

    Sources sources = ProjectUtils.getSources(project);
    SourceGroup[] docRoot = sources.getSourceGroups(TYPE_DOC_ROOT);
    SourceGroup[] srcRoots = getJavaSourceGroups(project);

    if (docRoot != null && srcRoots != null) {
        sourceGroups = new SourceGroup[docRoot.length + srcRoots.length];
        System.arraycopy(docRoot, 0, sourceGroups, 0, docRoot.length);
        System.arraycopy(srcRoots, 0, sourceGroups, docRoot.length, srcRoots.length);
    }

    if (sourceGroups == null || sourceGroups.length == 0) {
        sourceGroups = sources.getSourceGroups(Sources.TYPE_GENERIC);
    }
    return sourceGroups;
}
 

/**
 * Convenience method to obtain the source root folder.
 * @param project the Project object
 * @return the FileObject of the source root folder
 */
public static FileObject getSourceRoot(Project project) {
    if (project == null) {
        return null;
    }

    // Search the ${src.dir} Source Package Folder first, use the first source group if failed.
    Sources src = ProjectUtils.getSources(project);
    SourceGroup[] grp = src.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    for (int i = 0; i < grp.length; i++) {
        if ("${src.dir}".equals(grp[i].getName())) { // NOI18N
            return grp[i].getRootFolder();
        }
    }
    if (grp.length != 0) {
        return grp[0].getRootFolder();
    }

    return null;
}
 

boolean isBeanValidationSupported() {
    if (project == null) {
        return false;
    }

    final String notNullAnnotation = "javax.validation.constraints.NotNull";    //NOI18N
    Sources sources = ProjectUtils.getSources(project);
    SourceGroup groups[] = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    if (groups == null || groups.length < 1) {
        return false;
    }
    SourceGroup firstGroup = groups[0];
    FileObject fo = firstGroup.getRootFolder();
    ClassPath compile = ClassPath.getClassPath(fo, ClassPath.COMPILE);
    if (compile == null) {
        return false;
    }
    return compile.findResource(notNullAnnotation.replace('.', '/') + ".class") != null;//NOI18N
}
 

protected boolean enable(Node[] node) {
    if (node.length == 0) {
        return false;
    }
    DataObject dobj = node[0].getLookup().lookup(DataObject.class);
    if (dobj == null) {
        return false;
    }
    FileObject fo = dobj.getPrimaryFile();
    Project project = FileOwnerQuery.getOwner(fo);
    if(project == null)
        return false;
    Sources sources = ProjectUtils.getSources(project);
    SourceGroup[] srcGrps = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    if (srcGrps == null || srcGrps.length == 0) {
        return false;
    } else {
        return true;
    }
}
 

protected boolean enable(Node[] node) {
    if (node.length == 0) {
        return false;
    }
    DataObject dobj = node[0].getLookup().lookup(DataObject.class);
    if (dobj == null) {
        return false;
    }
    FileObject fo = dobj.getPrimaryFile();
    Project project = FileOwnerQuery.getOwner(fo);
    if(project == null)
        return false;
    Sources sources = ProjectUtils.getSources(project);
    SourceGroup[] srcGrps = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    if (srcGrps == null || srcGrps.length == 0) {
        return false;
    } else {
        return true;
    }
}
 

private void initCombos() {
        Sources sources = ProjectUtils.getSources(project);
        SourceGroup[] sourceGroupsJava = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        if (sourceGroupsJava == null) {
            throw new IllegalStateException(
                    NbBundle.getMessage(FXMLTemplateWizardIterator.class,
                    "MSG_ConfigureFXMLPanel_SGs_Error")); // NOI18N
        }
        support = new SourceGroupSupport(JavaProjectConstants.SOURCES_TYPE_JAVA);
        support.addSourceGroups(sourceGroupsJava); //must exist

        comboBoxSourceRoot.setModel(new DefaultComboBoxModel(support.getSourceGroups().toArray()));
//        SourceGroupSupport.SourceGroupProxy preselectedGroup = support.getParent().getCurrentSourceGroup();
//        ignoreRootCombo = true;
//        comboBoxSourceRoot.setSelectedItem(preselectedGroup);
//        ignoreRootCombo = false;
//        comboBoxPackage.getEditor().setItem(support.getParent().getCurrentPackageName());
        updatePackages();
        updateText();
        updateResult();
    }
 

public static FileObject getClientConfigFolder(Project p) {
    WsitProvider wsitProvider = p.getLookup().lookup(WsitProvider.class);
    if (wsitProvider != null) {
        return wsitProvider.getConfigFilesFolder(true);
    }

    // proceed with default folder (META-INF) if the provider is not found
    FileObject folder = null;
    Sources sources = ProjectUtils.getSources(p);
    if (sources == null) return null;
    SourceGroup[] sourceGroups = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);        
    if ((sourceGroups != null) && (sourceGroups.length > 0)) {
        folder = sourceGroups[0].getRootFolder();
        if (folder != null) {
            folder = folder.getFileObject("META-INF");
        }
        if ((folder == null) || (!folder.isValid())) {
            try {
                folder = sourceGroups[0].getRootFolder().createFolder("META-INF");
            } catch (IOException ex) {
                logger.log(Level.SEVERE, null, ex);
            }
        }
    }
    return folder;
}
 

public void initialize(WizardDescriptor wizard) {
        
        wiz = wizard;
        project = Templates.getProject(wiz);
        SourceGroup[] sourceGroups = SourceGroups.getJavaSourceGroups(project);
        
        //create the Java Project chooser
//        firstPanel = JavaTemplates.createPackageChooser(project, sourceGroups, new BottomPanel());
        
        if (sourceGroups.length == 0) {
            SourceGroup[] genericSourceGroups = ProjectUtils.getSources(project).getSourceGroups(Sources.TYPE_GENERIC);
            firstPanel = new FinishableProxyWizardPanel(Templates.createSimpleTargetChooser(project, genericSourceGroups, new BottomPanel()), sourceGroups, false);
        } else
            firstPanel = new FinishableProxyWizardPanel(JavaTemplates.createPackageChooser(project, sourceGroups, new BottomPanel(), true));
        
        JComponent c = (JComponent) firstPanel.getComponent();
        Utils.changeLabelInComponent(c, NbBundle.getMessage(LogicalHandlerWizard.class, "LBL_JavaTargetChooserPanelGUI_ClassName_Label"), //NOI18N
                NbBundle.getMessage(LogicalHandlerWizard.class, "LBL_LogicalHandler_Name") ); //NOI18N
        c.putClientProperty(WizardDescriptor.PROP_CONTENT_DATA, //NOI18N
                HANDLER_STEPS);
        c.putClientProperty(WizardDescriptor.PROP_CONTENT_SELECTED_INDEX, //NOI18N
                Integer.valueOf(0));
        c.getAccessibleContext().setAccessibleDescription
                (HANDLER_STEPS[0]);
        wizardPanels = new WizardDescriptor.Panel[] {firstPanel};
    }
 

public void testSourceRootDeletion() throws Exception {
    // Cf. #40845. Need to fire a change if a root is deleted while project is open.
    Sources s = sh.createSources();
    SourceGroup[] groups = s.getSourceGroups("java");
    assertEquals("should have src1dir plus src3dir", 2, groups.length);
    assertEquals("group #1 is src1dir", src1dir, groups[0].getRootFolder());
    assertEquals("group #2 is src3dir", src3dir, groups[1].getRootFolder());
    MockChangeListener l = new MockChangeListener();
    s.addChangeListener(l);
    src3dir.delete();
    l.msg("got a change after src3dir deleted").assertEvent();
    groups = s.getSourceGroups("java");
    assertEquals("should have just src1dir", 1, groups.length);
    assertEquals("group #1 is src1dir", src1dir, groups[0].getRootFolder());
    src1dir.delete();
    l.msg("got a change after src1dir deleted").assertEvent();
    groups = s.getSourceGroups("java");
    assertEquals("should have no dirs", 0, groups.length);
    FileObject src5dir = scratch.createFolder("nonesuch");
    l.msg("got a change after src5dir created").assertEvent();
    groups = s.getSourceGroups("java");
    assertEquals("should have src15dir now", 1, groups.length);
    assertEquals("group #1 is src5dir", src5dir, groups[0].getRootFolder());
}
 

public static void removeImplClass(Project project, String implClass) {
    Sources sources = project.getLookup().lookup(Sources.class);
    String resource = implClass.replace('.','/')+".java"; //NOI18N
    if (sources!=null) {
        SourceGroup[] srcGroup = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
        for (int i=0;i<srcGroup.length;i++) {
            final FileObject srcRoot = srcGroup[i].getRootFolder();
            final FileObject implClassFo = srcRoot.getFileObject(resource);
            if (implClassFo!=null) {
                try {
                    FileSystem fs = implClassFo.getFileSystem();
                    fs.runAtomicAction(new AtomicAction() {
                        public void run() {
                            deleteFile(implClassFo);
                        }
                    });
                } catch (IOException ex) {
                    ErrorManager.getDefault().notify(ex);
                }
                return;
            }
        }
    }
}
 

@Override
protected void setUp() throws Exception {
    super.setUp();
    AbstractIndenter.inUnitTestRun = true;

    MockMimeLookup.setInstances(MimePath.parse("text/javascript"), JsTokenId.javascriptLanguage());
    HtmlIndentTaskFactory htmlReformatFactory = new HtmlIndentTaskFactory();
    MockMimeLookup.setInstances(MimePath.parse("text/html"), htmlReformatFactory, new HtmlKit("text/html"), HTMLTokenId.language());
    
    FileObject srcFo = getTestFile("angularTestProject");
    Sources sources = new TestSources(srcFo);
    ClassPathProvider classpathProvider = new TestClassPathProvider(srcFo, createClassPathsForTest());
    MockLookup.setInstances(new TestProjectFactory(classpathProvider, sources));
    
    IndexingManager.getDefault().refreshIndexAndWait(srcFo.getURL(), null, true);
    
}
 

@Override
public synchronized void setScope(TaskScanningScope scope, Callback callback) {
    //cancel all current operations:
    cancelAllCurrent();
    
    this.scope = scope;
    this.callback = callback;
    
    if (scope == null || callback == null)
        return ;
    
    for (FileObject file : scope.getLookup().lookupAll(FileObject.class)) {
        enqueue(new Work(file, callback));
    }
    
    for (Project p : scope.getLookup().lookupAll(Project.class)) {
        for (SourceGroup generic : ProjectUtils.getSources(p).getSourceGroups(Sources.TYPE_GENERIC)) {
            for (FileObject root : Utilities.findIndexedRootsUnderDirectory(p, generic.getRootFolder())) {
                enqueue(new Work(root, callback));
            }
        }
    }
}
 

public static ClassPath getClassPath(Project project, String type) {
    ClassPathProvider provider = project.getLookup().lookup(ClassPathProvider.class);
    if (provider == null) {
        return null;
    }
    Sources sources = project.getLookup().lookup(Sources.class);
    if (sources == null) {
        return null;
    }
    SourceGroup[] sourceGroups = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    List<ClassPath> classPaths = new ArrayList<ClassPath>(sourceGroups.length);
    for (SourceGroup sourceGroup : sourceGroups) {
        String sourceGroupId = sourceGroup.getName();
        if (sourceGroupId != null && sourceGroupId.contains("test")) {
            // NOI18N
            continue;
        }
        FileObject rootFolder = sourceGroup.getRootFolder();
        ClassPath path = provider.findClassPath(rootFolder, type);
        classPaths.add(path);
    }
    return ClassPathSupport.createProxyClassPath(classPaths.toArray(new ClassPath[classPaths.size()]));
}
 

@Override
public Sources initSources(Project project, CommonProjectHelper h, Values e) {
    AntProjectHelperImpl ih = (AntProjectHelperImpl) h;
    PropertyEvaluatorImpl ip = (PropertyEvaluatorImpl) e;
    SourcesHelper sourcesHelper = new SourcesHelper(project, ih.delegate, ip.delegate);
    sourcesHelper.sourceRoot("${" + ClientSideProjectConstants.PROJECT_SOURCE_FOLDER + "}") //NOI18N
            .displayName(org.openide.util.NbBundle.getMessage(ClientSideProjectSources.class, "SOURCES"))
            .add() // adding as principal root, continuing configuration
            .type(WebClientProjectConstants.SOURCES_TYPE_HTML5).add(); // adding as typed root
    sourcesHelper.sourceRoot("${" + ClientSideProjectConstants.PROJECT_SITE_ROOT_FOLDER + "}") //NOI18N
            .displayName(org.openide.util.NbBundle.getMessage(ClientSideProjectSources.class, "SITE_ROOT"))
            .add() // adding as principal root, continuing configuration
            .type(WebClientProjectConstants.SOURCES_TYPE_HTML5_SITE_ROOT).add(); // adding as typed root
    sourcesHelper.sourceRoot("${" + ClientSideProjectConstants.PROJECT_TEST_FOLDER + "}") //NOI18N
            .displayName(org.openide.util.NbBundle.getMessage(ClientSideProjectSources.class, "UNIT_TESTS"))
            .add() // adding as principal root, continuing configuration
            .type(WebClientProjectConstants.SOURCES_TYPE_HTML5_TEST).add(); // adding as typed root
    sourcesHelper.sourceRoot("${" + ClientSideProjectConstants.PROJECT_TEST_SELENIUM_FOLDER + "}") //NOI18N
            .displayName(org.openide.util.NbBundle.getMessage(ClientSideProjectSources.class, "SELENIUM_TESTS"))
            .add() // adding as principal root, continuing configuration
            .type(WebClientProjectConstants.SOURCES_TYPE_HTML5_TEST_SELENIUM).add(); // adding as typed root
    sourcesHelper.registerExternalRoots(FileOwnerQuery.EXTERNAL_ALGORITHM_TRANSIENT);
    return sourcesHelper.createSources();
}
 

private static SourceGroup[] checkNotNull (SourceGroup[] groups, Sources sources) {
    List<SourceGroup> sourceGroups = new ArrayList<SourceGroup> ();
    for (SourceGroup sourceGroup : groups)
        if (sourceGroup == null)
            Exceptions.printStackTrace (new NullPointerException (sources + " returns null SourceGroup!"));
        else
            sourceGroups.add (sourceGroup);
    return sourceGroups.toArray (new SourceGroup [sourceGroups.size ()]);
}
 

public static SourceGroup[] getJavaSourceGroups(PUDataObject dObj) throws java.io.IOException {
    Project proj = FileOwnerQuery.getOwner(dObj.getPrimaryFile());
    if (proj == null) {
        return new SourceGroup[]{};
    }
    Sources sources = ProjectUtils.getSources(proj);
    SourceGroup[] toRet = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_RESOURCES);
    if (toRet != null && toRet.length != 0) {
        return toRet;
    }
    return sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
}
 

/** Returns WebPages for the project, where the fo is located.
 */
public static SourceGroup[] getDocBaseGroups(FileObject fo) throws java.io.IOException {
    Project proj = FileOwnerQuery.getOwner(fo);
    if (proj==null) return new SourceGroup[]{};
    Sources sources = ProjectUtils.getSources(proj);
    return sources.getSourceGroups(WebProjectConstants.TYPE_DOC_ROOT);
}
 

public void testDelegateLookup() throws IOException {
    //Assert we have enclosing project
    assertNotNull(owner);
    //Assert we have correct Lookup in enclosing project
    assertNotNull(owner.getLookup().lookup(Sources.class));
    assertNotNull(owner.getLookup().lookup(SourcesImpl.class));
    assertNotNull(owner.getLookup().lookup(ProjectOpenedHook.class));
    assertNotNull(owner.getLookup().lookup(ProjectOpenedHookImpl.class));
    assertNotNull(owner.getLookup().lookup(ProjectInformation.class));
    assertNotNull(owner.getLookup().lookup(ProjectInformationImpl.class));
    //Test delegating lookup
    final Lookup lkp = ProjectConvertors.createDelegateToOwnerLookup(automaticProjectHome);
    assertNotNull(lkp);
    //Test do not have black listed services
    assertNull(lkp.lookup(ProjectOpenedHook.class));
    assertNull(lkp.lookup(ProjectOpenedHookImpl.class));
    assertNull(lkp.lookup(ProjectInformation.class));
    assertNull(lkp.lookup(ProjectInformationImpl.class));
    //Test have other services
    assertNotNull(lkp.lookup(Sources.class));
    assertNotNull(lkp.lookup(SourcesImpl.class));
    //Close lookup
    ((Closeable)lkp).close();
    //Nothing should be in the Lookup
    assertNull(lkp.lookup(ProjectOpenedHook.class));
    assertNull(lkp.lookup(ProjectOpenedHookImpl.class));
    assertNull(lkp.lookup(ProjectInformation.class));
    assertNull(lkp.lookup(ProjectInformationImpl.class));
    assertNull(lkp.lookup(Sources.class));
    assertNull(lkp.lookup(SourcesImpl.class));
}
 

public static SourceGroup[] getSourceGroups(Project project) {
    Sources sources = ProjectUtils.getSources(project);
    List<SourceGroup> res = new ArrayList<SourceGroup>();
    res.addAll(Arrays.asList(sources.getSourceGroups(WebClientProjectConstants.SOURCES_TYPE_HTML5)));
    res.addAll(Arrays.asList(sources.getSourceGroups(WebClientProjectConstants.SOURCES_TYPE_HTML5_SITE_ROOT)));
    res.addAll(Arrays.asList(sources.getSourceGroups(WebClientProjectConstants.SOURCES_TYPE_HTML5_TEST)));
    res.addAll(Arrays.asList(sources.getSourceGroups(WebClientProjectConstants.SOURCES_TYPE_HTML5_TEST_SELENIUM)));
    return res.toArray(new SourceGroup[res.size()]);
}
 

/**
 * Initialize panels representing individual wizard's steps and sets
 * various properties for them influencing wizard appearance.
 */
private WizardDescriptor.Panel[] getPanels() {
    if (panels == null) {
        Project p = Templates.getProject(wizard);
        SourceGroup[] groups = ProjectUtils.getSources(p).getSourceGroups(Sources.TYPE_GENERIC);
        ConfigFileManager manager = getConfigFileManager(p);
        List<ConfigFileGroup> configFileGroups = manager != null ? manager.getConfigFileGroups() : null;
        SpringXMLConfigGroupPanel configGroupPanel = configFileGroups != null && !configFileGroups.isEmpty() ? new SpringXMLConfigGroupPanel(configFileGroups) : null;
        WizardDescriptor.Panel targetChooser = Templates.createSimpleTargetChooser(p, groups, configGroupPanel);

        panels = new WizardDescriptor.Panel[] {
            targetChooser,
            new SpringXMLConfigNamespacesPanel(),
        };
        String[] steps = createSteps();
        for (int i = 0; i < panels.length; i++) {
            Component c = panels[i].getComponent();
            if (steps[i] == null) {
                // Default step name to component name of panel. Mainly
                // useful for getting the name of the target chooser to
                // appear in the list of steps.
                steps[i] = c.getName();
            }
            if (c instanceof JComponent) { // assume Swing components
                JComponent jc = (JComponent) c;
                // Sets step number of a component
                jc.putClientProperty(WizardDescriptor.PROP_CONTENT_SELECTED_INDEX, new Integer(i)); // NOI18N
                // Sets steps names for a panel
                jc.putClientProperty(WizardDescriptor.PROP_CONTENT_DATA, steps); // NOI18N
                // Turn on subtitle creation on each step
                jc.putClientProperty(WizardDescriptor.PROP_AUTO_WIZARD_STYLE, Boolean.TRUE); // NOI18N
                // Show steps on the left side with the image on the background
                jc.putClientProperty(WizardDescriptor.PROP_CONTENT_DISPLAYED, Boolean.TRUE); // NOI18N
                // Turn on numbering of all steps
                jc.putClientProperty(WizardDescriptor.PROP_CONTENT_NUMBERED, Boolean.TRUE); // NOI18N
            }
        }
    }
    return panels;
}
 

@Override
protected void beforeLookup(Template<?> template) {
    if (template.getType() == Sources.class) {
        try {
            //state.notifyDeleted();
            projectDirectory.delete();
        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        }
    }
}
 

public void initialize(WizardDescriptor wizardDescriptor) {
    wiz = wizardDescriptor;
    Project project = Templates.getProject(wiz);
    Sources sources = ProjectUtils.getSources(project);
    SourceGroup[] sourceGroups = sources.getSourceGroups(JavaProjectConstants.SOURCES_TYPE_JAVA);
    panels = new WizardDescriptor.Panel[] {JavaTemplates.createPackageChooser(project,sourceGroups)};
    Wizards.mergeSteps(wiz, panels, STEPS);
}