Example usage for org.eclipse.jdt.core IPackageFragmentRoot K_SOURCE

List of usage examples for org.eclipse.jdt.core IPackageFragmentRoot K_SOURCE

  1. HOME
  2. Java
  3. org.eclipse.jdt
  4. org.eclipse.jdt.core.*
  5. IPackageFragmentRoot
  6. K_SOURCE

Introduction

In this page you can find the example usage for org.eclipse.jdt.core IPackageFragmentRoot K_SOURCE.

Prototype

int K_SOURCE

To view the source code for org.eclipse.jdt.core IPackageFragmentRoot K_SOURCE.

Click Source Link

Document

Kind constant for a source path root.

Usage

From source file:org.eclipse.che.plugin.java.server.JavaNavigation.java

License:Open Source License

private List<PackageFragmentRoot> toPackageRoots(IJavaProject javaProject, boolean includePackages)
        throws JavaModelException {
    IPackageFragmentRoot[] packageFragmentRoots = javaProject.getPackageFragmentRoots();
    List<PackageFragmentRoot> result = new ArrayList<>();
    for (IPackageFragmentRoot packageFragmentRoot : packageFragmentRoots) {
        if (packageFragmentRoot.getKind() == IPackageFragmentRoot.K_SOURCE) {
            PackageFragmentRoot root = DtoFactory.newDto(PackageFragmentRoot.class);
            root.setPath(packageFragmentRoot.getPath().toOSString());
            root.setProjectPath(packageFragmentRoot.getJavaProject().getPath().toOSString());
            if (includePackages) {
                root.setPackageFragments(toPackageFragments(packageFragmentRoot));
            }/*  w ww . j  a  v  a 2 s.  c  o m*/
            result.add(root);
        }
    }
    return result;
}

From source file:org.eclipse.e4.internal.tools.wizards.classes.AbstractNewClassPage.java

License:Open Source License

private IPackageFragmentRoot choosePackageRoot() {
    IJavaElement initElement = clazz.getFragmentRoot();
    Class[] acceptedClasses = new Class[] { IPackageFragmentRoot.class, IJavaProject.class };
    TypedElementSelectionValidator validator = new TypedElementSelectionValidator(acceptedClasses, false) {
        @Override/*from w w  w .ja  v  a  2 s  .c o m*/
        public boolean isSelectedValid(Object element) {
            try {
                if (element instanceof IJavaProject) {
                    IJavaProject jproject = (IJavaProject) element;
                    IPath path = jproject.getProject().getFullPath();
                    return (jproject.findPackageFragmentRoot(path) != null);
                } else if (element instanceof IPackageFragmentRoot) {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                }
                return true;
            } catch (JavaModelException e) {
                JavaPlugin.log(e.getStatus()); // just log, no UI in validation
            }
            return false;
        }
    };

    acceptedClasses = new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
    ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
        @Override
        public boolean select(Viewer viewer, Object parent, Object element) {
            if (element instanceof IPackageFragmentRoot) {
                try {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                } catch (JavaModelException e) {
                    JavaPlugin.log(e.getStatus()); // just log, no UI in validation
                    return false;
                }
            }
            return super.select(viewer, parent, element);
        }
    };

    StandardJavaElementContentProvider provider = new StandardJavaElementContentProvider();
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
    ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
    dialog.setValidator(validator);
    dialog.setComparator(new JavaElementComparator());
    dialog.setTitle(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_title);
    dialog.setMessage(NewWizardMessages.NewContainerWizardPage_ChooseSourceContainerDialog_description);
    dialog.addFilter(filter);
    dialog.setInput(JavaCore.create(fWorkspaceRoot));
    dialog.setInitialSelection(initElement);
    dialog.setHelpAvailable(false);

    if (dialog.open() == Window.OK) {
        Object element = dialog.getFirstResult();
        if (element instanceof IJavaProject) {
            IJavaProject jproject = (IJavaProject) element;
            return jproject.getPackageFragmentRoot(jproject.getProject());
        } else if (element instanceof IPackageFragmentRoot) {
            return (IPackageFragmentRoot) element;
        }
        return null;
    }
    return null;
}

From source file:org.eclipse.e4.internal.tools.wizards.project.E4NewProjectWizard.java

License:Open Source License

/**
 * create products extension detail/*from ww  w  .  j  a v a 2 s . c  o  m*/
 * 
 * @param project
 */
@SuppressWarnings("restriction")
public void createApplicationResources(IProject project, IProgressMonitor monitor) {
    Map<String, String> map = fApplicationPage.getData();
    isMinimalist = !map.get(NewApplicationWizardPage.richSample).equalsIgnoreCase("TRUE");
    if (map == null || map.get(NewApplicationWizardPage.PRODUCT_NAME) == null)
        return;

    // If the project has invalid characters, the plug-in name would replace
    // them with underscores, product name does the same
    String pluginName = fPluginData.getId();

    // If there's no Activator created we create default package
    if (!fPluginData.doGenerateClass()) {
        String packageName = fPluginData.getId();
        IPath path = new Path(packageName.replace('.', '/'));
        if (fPluginData.getSourceFolderName().trim().length() > 0)
            path = new Path(fPluginData.getSourceFolderName()).append(path);

        try {
            CoreUtility.createFolder(project.getFolder(path));
        } catch (CoreException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragment fragment = null;

    try {
        for (IPackageFragment element : javaProject.getPackageFragments()) {
            if (element.getKind() == IPackageFragmentRoot.K_SOURCE) {
                fragment = element;
            }
        }
    } catch (JavaModelException e1) {
        e1.printStackTrace();
    }

    createApplicationModel(project, pluginName, fragment);

    String cssPath = map.get(NewApplicationWizardPage.APPLICATION_CSS_PROPERTY);
    if (cssPath != null && cssPath.trim().length() > 0) {
        IFile file = project.getFile(cssPath);

        try {
            prepareFolder(file.getParent(), monitor);

            URL corePath = ResourceLocator.getProjectTemplateFiles("css/default.css");
            file.create(corePath.openStream(), true, monitor);
        } catch (Exception e) {
            PDEPlugin.logException(e);
        }
    }

    String template_id = "common";
    Set<String> binaryExtentions = new HashSet<String>();
    binaryExtentions.add(".gif");
    binaryExtentions.add(".png");

    Map<String, String> keys = new HashMap<String, String>();
    keys.put("projectName", pluginName);
    keys.put("productFileName", map.get(NewApplicationWizardPage.PRODUCT_NAME));
    String elementName = fragment.getElementName();
    keys.put("packageName", (elementName.equals("") ? "" : elementName + ".") + "handlers");
    keys.put("packageName2", (elementName.equals("") ? "" : elementName + ".") + "parts");
    keys.put("programArgs",
            "true".equalsIgnoreCase(map.get(NewApplicationWizardPage.CLEAR_PERSISTED_STATE))
                    ? "-clearPersistedState"
                    : "");
    try {
        URL corePath = ResourceLocator.getProjectTemplateFiles(template_id);
        IRunnableWithProgress op = new TemplateOperation(corePath, project, keys, binaryExtentions,
                isMinimalist);
        getContainer().run(false, true, op);
    } catch (Exception e) {
        PDEPlugin.logException(e);
    }
    if (!isMinimalist) {
        try {
            URL corePath = ResourceLocator.getProjectTemplateFiles("src");
            IRunnableWithProgress op = new TemplateOperation(corePath, (IContainer) fragment.getResource(),
                    keys, binaryExtentions, isMinimalist);
            getContainer().run(false, true, op);
        } catch (Exception e) {
            PDEPlugin.logException(e);
        }
    }
}

From source file:org.eclipse.e4.tools.ui.designer.utils.ClassLoaderHelper.java

License:Open Source License

private static URL findResourceURL(IJavaProject javaProject, Set<IJavaProject> visited, boolean isFirstProject,
        String name) {// www.ja v a  2 s  . co  m
    if (visited.contains(javaProject))
        return null;
    visited.add(javaProject);
    try {
        IPath outPath = javaProject.getProject().getLocation().removeLastSegments(1)
                .append(javaProject.getOutputLocation());
        outPath = outPath.addTrailingSeparator();
        {
            URL url = toURL(outPath.append(name));
            if (url != null) {
                return url;
            }
        }
        for (IPackageFragmentRoot fragment : javaProject.getPackageFragmentRoots()) {
            if (fragment.getKind() == IPackageFragmentRoot.K_SOURCE) {
                URL url = toURL(fragment.getResource().getLocation().append(name));
                if (url != null) {
                    return url;
                }
            }
        }
        // urls.add(out);
        IClasspathEntry[] entries = javaProject.getResolvedClasspath(true);
        for (IClasspathEntry entry : entries) {
            switch (entry.getEntryKind()) {
            case IClasspathEntry.CPE_LIBRARY: {
                // TODO
                IClasspathEntry resolveEntry = JavaCore.getResolvedClasspathEntry(entry);
                File file = resolveEntry.getPath().toFile();
                IPath path = resolveEntry.getPath();
                if (!file.exists()) {
                    String projectName = path.segment(0);
                    IProject project = javaProject.getProject().getWorkspace().getRoot()
                            .getProject(projectName);
                    path = project.getLocation().append(path.removeFirstSegments(1));
                }
                String spec = "jar:file:" + path.toString() + "!/" + name;
                try {
                    URL url2 = new URL(spec);
                    url2.getContent();
                    return url2;
                } catch (Exception e) {
                }
            }
                break;
            case IClasspathEntry.CPE_CONTAINER:

                break;
            case IClasspathEntry.CPE_VARIABLE: {
                {
                    // TODO
                    URL url = toURL(outPath.append(name));
                    if (url != null) {
                        return url;
                    }
                }
            }
                break;
            case IClasspathEntry.CPE_PROJECT: {
                if (isFirstProject || entry.isExported()) {
                    URL url = findResourceURL(getJavaProject(entry), visited, false, name);
                    if (url != null) {
                        return url;
                    }
                }
                break;
            }
            }
        }
    } catch (JavaModelException e) {
        e.printStackTrace();
    }
    return null;
}

From source file:org.eclipse.e4.tools.ui.designer.wizards.E4NewProjectWizard.java

License:Open Source License

/**
 * create products extension detail//  w  w  w  .  ja  v a  2  s  .  c o  m
 * 
 * @param project
 */
@SuppressWarnings("restriction")
public void createApplicationResources(IProject project, IProgressMonitor monitor) {
    Map<String, String> map = fApplicationPage.getData();
    if (map == null || map.get(NewApplicationWizardPage.PRODUCT_NAME) == null)
        return;

    String projectName = map.get(NewApplicationWizardPage.PRODUCT_NAME);
    String xmiPath = map.get(NewApplicationWizardPage.APPLICATION_XMI_PROPERTY);

    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragment fragment = null;
    try {
        for (IPackageFragment element : javaProject.getPackageFragments()) {
            if (element.getKind() == IPackageFragmentRoot.K_SOURCE) {
                fragment = element;
            }
        }
    } catch (JavaModelException e1) {
        e1.printStackTrace();
    }

    if (xmiPath != null && xmiPath.trim().length() > 0) {
        // Create a resource set
        //
        ResourceSet resourceSet = new ResourceSetImpl();

        // Get the URI of the model file.
        //
        URI fileURI = URI.createPlatformResourceURI(project.getName() + "/" + xmiPath, true);

        // Create a resource for this file.
        //
        Resource resource = resourceSet.createResource(fileURI);

        MApplication application = MApplicationFactory.INSTANCE.createApplication();

        application.setElementId("org.eclipse.e4.ide.application");

        MBindingContext rootContext = MCommandsFactory.INSTANCE.createBindingContext();
        rootContext.setElementId("org.eclipse.ui.contexts.dialogAndWindow");
        rootContext.setName("In Dialog and Windows");

        MBindingContext childContext = MCommandsFactory.INSTANCE.createBindingContext();
        childContext.setElementId("org.eclipse.ui.contexts.window");
        childContext.setName("In Windows");
        rootContext.getChildren().add(childContext);

        childContext = MCommandsFactory.INSTANCE.createBindingContext();
        childContext.setElementId("org.eclipse.ui.contexts.dialog");
        childContext.setName("In Dialogs");
        rootContext.getChildren().add(childContext);

        application.getRootContext().add(rootContext);
        application.getBindingContexts().add(rootContext);

        resource.getContents().add((EObject) application);

        // Create Quit command
        MCommand quitCommand = createCommand("quitCommand", "QuitHandler", "Ctrl+Q", projectName, fragment,
                application);

        MCommand openCommand = createCommand("openCommand", "OpenHandler", "Ctrl+O", projectName, fragment,
                application);

        MCommand saveCommand = createCommand("saveCommand", "SaveHandler", "Ctrl+S", projectName, fragment,
                application);

        MCommand aboutCommand = createCommand("aboutCommand", "AboutHandler", "Ctrl+A", projectName, fragment,
                application);

        MTrimmedWindow mainWindow = MBasicFactory.INSTANCE.createTrimmedWindow();
        application.getChildren().add(mainWindow);
        {
            mainWindow.setLabel(projectName);
            mainWindow.setWidth(500);
            mainWindow.setHeight(400);

            // Menu
            {
                MMenu menu = MMenuFactory.INSTANCE.createMenu();
                mainWindow.setMainMenu(menu);
                menu.setElementId("menu:org.eclipse.ui.main.menu");

                MMenu fileMenuItem = MMenuFactory.INSTANCE.createMenu();
                menu.getChildren().add(fileMenuItem);
                fileMenuItem.setLabel("File");
                {
                    MHandledMenuItem menuItemOpen = MMenuFactory.INSTANCE.createHandledMenuItem();
                    fileMenuItem.getChildren().add(menuItemOpen);
                    menuItemOpen.setLabel("Open");
                    menuItemOpen.setIconURI("platform:/plugin/" + project.getName() + "/icons/sample.gif");
                    menuItemOpen.setCommand(openCommand);

                    MHandledMenuItem menuItemSave = MMenuFactory.INSTANCE.createHandledMenuItem();
                    fileMenuItem.getChildren().add(menuItemSave);
                    menuItemSave.setLabel("Save");
                    menuItemSave.setIconURI("platform:/plugin/" + project.getName() + "/icons/save_edit.gif");
                    menuItemSave.setCommand(saveCommand);

                    MHandledMenuItem menuItemQuit = MMenuFactory.INSTANCE.createHandledMenuItem();
                    fileMenuItem.getChildren().add(menuItemQuit);
                    menuItemQuit.setLabel("Quit");
                    menuItemQuit.setCommand(quitCommand);
                }
                MMenu helpMenuItem = MMenuFactory.INSTANCE.createMenu();
                menu.getChildren().add(helpMenuItem);
                helpMenuItem.setLabel("Help");
                {
                    MHandledMenuItem menuItemAbout = MMenuFactory.INSTANCE.createHandledMenuItem();
                    helpMenuItem.getChildren().add(menuItemAbout);
                    menuItemAbout.setLabel("About");
                    menuItemAbout.setCommand(aboutCommand);
                }
            }

            // PerspectiveStack
            {
                MPerspectiveStack perspectiveStack = MAdvancedFactory.INSTANCE.createPerspectiveStack();
                mainWindow.getChildren().add(perspectiveStack);

                MPerspective perspective = MAdvancedFactory.INSTANCE.createPerspective();
                perspectiveStack.getChildren().add(perspective);
                {
                    // Part Container
                    MPartSashContainer partSashContainer = MBasicFactory.INSTANCE.createPartSashContainer();
                    perspective.getChildren().add(partSashContainer);

                    MPartStack partStack = MBasicFactory.INSTANCE.createPartStack();
                    partSashContainer.getChildren().add(partStack);
                    //
                    //                  MPart part = MApplicationFactory.eINSTANCE.createPart();
                    //                  partStack.getChildren().add(part);
                    //                  part.setLabel("Main");
                }

                // WindowTrim
                {
                    MTrimBar trimBar = MBasicFactory.INSTANCE.createTrimBar();
                    mainWindow.getTrimBars().add(trimBar);

                    MToolBar toolBar = MMenuFactory.INSTANCE.createToolBar();
                    toolBar.setElementId("toolbar:org.eclipse.ui.main.toolbar");
                    trimBar.getChildren().add(toolBar);

                    MHandledToolItem toolItemOpen = MMenuFactory.INSTANCE.createHandledToolItem();
                    toolBar.getChildren().add(toolItemOpen);
                    toolItemOpen.setIconURI("platform:/plugin/" + project.getName() + "/icons/sample.gif");
                    toolItemOpen.setCommand(openCommand);

                    MHandledToolItem toolItemSave = MMenuFactory.INSTANCE.createHandledToolItem();
                    toolBar.getChildren().add(toolItemSave);
                    toolItemSave.setIconURI("platform:/plugin/" + project.getName() + "/icons/save_edit.gif");
                    toolItemSave.setCommand(saveCommand);
                }
            }
        }
        Map<Object, Object> options = new HashMap<Object, Object>();
        options.put(XMLResource.OPTION_ENCODING, "UTF-8");
        try {
            resource.save(options);
        } catch (IOException e) {
            PDEPlugin.logException(e);
        }
    }

    String cssPath = map.get(NewApplicationWizardPage.APPLICATION_CSS_PROPERTY);
    if (cssPath != null && cssPath.trim().length() > 0) {
        IFile file = project.getFile(cssPath);

        try {
            prepareFolder(file.getParent(), monitor);

            URL corePath = ResourceLocator.getProjectTemplateFiles("css/default.css");
            file.create(corePath.openStream(), true, monitor);
        } catch (Exception e) {
            PDEPlugin.logException(e);
        }
    }

    // IFolder folder = project.getFolder("icons");
    // try {
    // folder.create(true, true, monitor);
    // Bundle bundle = Platform
    // .getBundle("org.eclipse.e4.tools.ui.designer");
    //
    // for (String fileName : new String[] { "sample.gif", "save_edit.gif"
    // }) {
    // URL sampleUrl = bundle.getEntry("resources/icons/" + fileName);
    // sampleUrl = FileLocator.resolve(sampleUrl);
    // InputStream inputStream = sampleUrl.openStream();
    // IFile file = folder.getFile(fileName);
    // file.create(inputStream, true, monitor);
    // }
    // } catch (Exception e) {
    // PDEPlugin.logException(e);
    // }

    String template_id = "common";
    Set<String> binaryExtentions = new HashSet<String>();
    binaryExtentions.add(".gif");
    binaryExtentions.add(".png");

    Map<String, String> keys = new HashMap<String, String>();
    keys.put("projectName", projectName);
    keys.put("packageName", fragment.getElementName() + ".handlers");

    try {
        URL corePath = ResourceLocator.getProjectTemplateFiles(template_id);
        IRunnableWithProgress op = new TemplateOperation(corePath, project, keys, binaryExtentions);
        getContainer().run(false, true, op);
    } catch (Exception e) {
        PDEPlugin.logException(e);
    }

    try {
        URL corePath = ResourceLocator.getProjectTemplateFiles("src");
        IRunnableWithProgress op = new TemplateOperation(corePath, (IContainer) fragment.getResource(), keys,
                binaryExtentions);
        getContainer().run(false, true, op);
    } catch (Exception e) {
        PDEPlugin.logException(e);
    }
}

From source file:org.eclipse.e4.xwt.tools.ui.designer.dialogs.AccessorConfigurationDialog.java

License:Open Source License

/**
 * Uses the standard container selection dialog to choose the new value for the container field.
 *///from   w  w w  . j  a v a 2 s. c o m
private IPackageFragmentRoot chooseSourceContainer(IPackageFragmentRoot root) {
    Class[] acceptedClasses = new Class[] { IPackageFragmentRoot.class, IJavaProject.class };
    TypedElementSelectionValidator validator = new TypedElementSelectionValidator(acceptedClasses, false) {
        public boolean isSelectedValid(Object element) {
            try {
                if (element instanceof IJavaProject) {
                    IJavaProject jproject = (IJavaProject) element;
                    IPath path = jproject.getProject().getFullPath();
                    return (jproject.findPackageFragmentRoot(path) != null);
                } else if (element instanceof IPackageFragmentRoot) {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                }
                return true;
            } catch (JavaModelException e) {
                JavaPlugin.log(e.getStatus()); // just log, no ui in validation
            }
            return false;
        }
    };

    acceptedClasses = new Class[] { IJavaModel.class, IPackageFragmentRoot.class, IJavaProject.class };
    ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
        public boolean select(Viewer viewer, Object parent, Object element) {
            if (element instanceof IPackageFragmentRoot) {
                try {
                    return (((IPackageFragmentRoot) element).getKind() == IPackageFragmentRoot.K_SOURCE);
                } catch (JavaModelException e) {
                    JavaPlugin.log(e.getStatus()); // just log, no ui in validation
                    return false;
                }
            }
            return super.select(viewer, parent, element);
        }
    };

    StandardJavaElementContentProvider provider = new StandardJavaElementContentProvider();
    ILabelProvider labelProvider = new JavaElementLabelProvider(JavaElementLabelProvider.SHOW_DEFAULT);
    ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(), labelProvider, provider);
    dialog.setValidator(validator);
    dialog.setComparator(new JavaElementComparator());
    dialog.setTitle("Source Folder Selection");
    dialog.setMessage("Choose a source folder:");
    dialog.addFilter(filter);
    dialog.setInput(JavaCore.create(ResourcesPlugin.getWorkspace().getRoot()));

    if (dialog.open() == Window.OK) {
        Object element = dialog.getFirstResult();
        if (element instanceof IJavaProject) {
            IJavaProject jproject = (IJavaProject) element;
            return jproject.getPackageFragmentRoot(jproject.getProject());
        } else if (element instanceof IPackageFragmentRoot) {
            return (IPackageFragmentRoot) element;
        }
        return null;
    }
    return root;
}

From source file:org.eclipse.e4.xwt.tools.ui.designer.loader.XWTVisualLoader.java

License:Open Source License

public synchronized Control loadWithOptions(URL url, Map<String, Object> options) throws Exception {
    IWorkspace workspace = ResourcesPlugin.getWorkspace();
    IWorkspaceRoot root = workspace.getRoot();
    String fileStr = url.getFile();
    if (fileStr.indexOf(PathHelper.WHITE_SPACE_ASCII) != -1) {
        fileStr = fileStr.replace(PathHelper.WHITE_SPACE_ASCII, " ");
    }//  w w  w . ja  v  a 2s  .  co  m
    IFile file = root.getFileForLocation(new Path(fileStr));
    if (file != null) {
        try {
            // the url given an binary file of project, we need find the source file of it and the load and open.
            IProject project = file.getProject();
            String fullPath = file.getFullPath().toString();
            IJavaProject javaProject = JavaCore.create(project);
            String outputPath = javaProject.getOutputLocation().toString();
            if (fullPath != null && outputPath != null && fullPath.startsWith(outputPath)) {
                String fileSourcePath = fullPath.substring(outputPath.length());
                IPackageFragmentRoot[] allPackageFragmentRoots = javaProject.getAllPackageFragmentRoots();
                for (IPackageFragmentRoot pRoot : allPackageFragmentRoots) {
                    if (pRoot.getKind() == IPackageFragmentRoot.K_SOURCE) {
                        IFolder resource = (IFolder) pRoot.getResource();
                        IFile sourceFile = resource.getFile(new Path(fileSourcePath));
                        if (sourceFile != null && sourceFile.exists()) {
                            file = sourceFile;
                            break;
                        }
                    }
                }
            }
        } catch (Exception e) {
        }
    }
    if (file != null) {
        IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
        IEditorPart activeEditor = activePage.getActiveEditor();
        try {
            XWTDesigner designer = (XWTDesigner) activePage.openEditor(new FileEditorInput(file),
                    XWTDesigner.EDITOR_ID, false);
            XamlDocument xamlDocument = (XamlDocument) designer.getDocumentRoot();
            XWTModelBuilder builder = null;
            if (xamlDocument == null) {
                builder = new XWTModelBuilder();
                builder.doLoad(designer, null);
                xamlDocument = builder.getDiagram();
            }
            Control control = (Control) new XWTProxy(file).load(xamlDocument.getRootElement(), options);
            if (builder != null) {
                builder.dispose();
            }
            return control;
        } finally {
            activePage.activate(activeEditor);
        }
    }
    return null;
}

From source file:org.eclipse.e4.xwt.tools.ui.designer.wizards.ExternalizeStringsWizard.java

License:Open Source License

private void getDefaultAccessorContents() {
    IFile inputFile = designer.getFile();

    IContainer container = inputFile.getParent();
    IJavaElement javaElement = JavaCore.create(container);
    IPackageFragmentRoot defaultRoot = null;
    if (javaElement != null && javaElement.exists()) {
        IJavaProject javaProject = JavaCore.create(inputFile.getProject());
        try {// w  w w. j a va2  s  .com
            IPackageFragmentRoot fragmentRoot[] = javaProject.getAllPackageFragmentRoots();
            for (int i = 0; i < fragmentRoot.length; i++) {
                if (fragmentRoot[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
                    defaultRoot = fragmentRoot[i];
                    for (IJavaElement element : defaultRoot.getChildren()) {
                        if (element.getElementType() == IJavaElement.PACKAGE_FRAGMENT) {
                            javaElement = element;
                        }
                    }
                    break;
                }
            }
        } catch (JavaModelException e) {
            e.printStackTrace();
        }
    }
    if (javaElement == null || !(javaElement instanceof IPackageFragment)) {
        String projectName = inputFile.getProject().getName();
        externalizeStringsWizardPage.setErrorMessage("The project " + projectName + " has not source folder.");
        return;
    }

    externalizeStringsWizardPage.setDefaultRoot(defaultRoot);
    externalizeStringsWizardPage.setDefaultFolder(defaultRoot.getResource().getFullPath().toString());
    externalizeStringsWizardPage.setDefaultPackage(javaElement.getElementName());
}

From source file:org.eclipse.emf.importer.java.builder.JavaEcoreBuilder.java

License:Open Source License

protected IPath analyzeProject(IProject project) throws Exception {
    // Walk the project looking for .java files to analyze.
    ////from w w  w  .ja  v  a 2 s  . co m
    IJavaProject javaProject = JavaCore.create(project);
    IPackageFragmentRoot[] packageFragmentRoots = javaProject.getPackageFragmentRoots();
    Set<IResource> visited = new HashSet<IResource>();
    for (int i = 0; i < packageFragmentRoots.length; ++i) {
        if (packageFragmentRoots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
            traverse((IContainer) packageFragmentRoots[i].getUnderlyingResource(), visited);
        }
    }

    for (Map.Entry<EGenericType, EGenericType> entry : ecoreEGenericTypeToJavaEGenericTypeMap.entrySet()) {
        EGenericType ecoreEGenericType = entry.getKey();
        EGenericType javaEGenericType = entry.getValue();
        EModelElement eModelElement = null;
        for (EObject eObject = ecoreEGenericType.eContainer(); eObject != null; eObject = eObject
                .eContainer()) {
            if (eObject instanceof EModelElement) {
                eModelElement = (EModelElement) eObject;
                break;
            }
        }
        RequiredClassifierType requiredClassifierType = ecoreEGenericType.eContainer() instanceof EClass
                || ecoreEGenericType.eContainer() instanceof EReference
                        ? RequiredClassifierType.CLASS
                        : eAttributes.contains(ecoreEGenericType.eContainer())
                                ? RequiredClassifierType.DATA_TYPE
                                : RequiredClassifierType.NONE;
        resolve(eModelElement, ecoreEGenericType, requiredClassifierType);
        if (javaEGenericType != null) {
            resolve(eModelElement, javaEGenericType, requiredClassifierType);
        }

        if (javaEGenericType != null) {
            resolve(eModelElement, ecoreEGenericType, javaEGenericType);
        }
    }

    for (Map.Entry<EGenericType, EGenericType> entry : ecoreEGenericTypeToJavaEGenericTypeMap.entrySet()) {
        EGenericType ecoreEGenericType = entry.getKey();
        EGenericType javaEGenericType = entry.getValue();
        EModelElement eModelElement = null;
        for (EObject eObject = ecoreEGenericType.eContainer(); eObject != null; eObject = eObject
                .eContainer()) {
            if (eObject instanceof EModelElement) {
                eModelElement = (EModelElement) eObject;
                break;
            }
        }

        if (javaEGenericType == null) {
            resolve(eModelElement, ecoreEGenericType, javaEGenericType);
        }
        used(ecoreEGenericType);
    }

    for (EStructuralFeature eStructuralFeature : eStructuralFeatures) {
        EGenericType eGenericType = eStructuralFeature.getEGenericType();
        EClassifier eClassifier = eGenericType.getERawType();

        // If we have resolved to an EClass but we have an EAttribute, we can change it to be an EReference.
        //
        if (eClassifier instanceof EClass && eStructuralFeature instanceof EAttribute) {
            EAttribute eAttribute = (EAttribute) eStructuralFeature;
            EClass container = eAttribute.getEContainingClass();
            EReference eReference = EcoreFactory.eINSTANCE.createEReference();
            eReference.setChangeable(eAttribute.isChangeable());
            eReference.setVolatile(eAttribute.isVolatile());
            eReference.setTransient(eAttribute.isTransient());
            eReference.setDerived(eAttribute.isDerived());
            eReference.setUnsettable(eAttribute.isUnsettable());
            eReference.setLowerBound(eAttribute.getLowerBound());
            eReference.setUpperBound(eAttribute.getUpperBound());
            eReference.setName(eStructuralFeature.getName());
            eReference.setEGenericType(eGenericType);
            eReference.getEAnnotations().addAll(eStructuralFeature.getEAnnotations());
            container.getEStructuralFeatures()
                    .add(container.getEStructuralFeatures().indexOf(eStructuralFeature), eReference);
            container.getEStructuralFeatures().remove(eStructuralFeature);
            eStructuralFeature = eReference;
        } else if (eClassifier instanceof EDataType && eStructuralFeature instanceof EReference) {
            EReference eReference = (EReference) eStructuralFeature;
            EClass container = eReference.getEContainingClass();
            EAttribute eAttribute = EcoreFactory.eINSTANCE.createEAttribute();
            eAttribute.setChangeable(eReference.isChangeable());
            eAttribute.setVolatile(eReference.isVolatile());
            eAttribute.setTransient(eReference.isTransient());
            eAttribute.setDerived(eReference.isDerived());
            eAttribute.setUnsettable(eReference.isUnsettable());
            eAttribute.setLowerBound(eReference.getLowerBound());
            eAttribute.setUpperBound(eReference.getUpperBound());
            eAttribute.setName(eStructuralFeature.getName());
            eAttribute.setEGenericType(eGenericType);
            eAttribute.getEAnnotations().addAll(eStructuralFeature.getEAnnotations());
            container.getEStructuralFeatures().remove(eStructuralFeature);
            eStructuralFeature = eAttribute;
            eReferenceToOppositeNameMap.remove(eReference);
        }

        if (eClassifier.getEPackage() == null) {
            error(CodeGenEcorePlugin.INSTANCE.getString("_UI_TheTypeDoesNotResolveCorrectly_message",
                    new Object[] { eClassifier.getInstanceTypeName() }));

            eGenericType = EcoreFactory.eINSTANCE.createEGenericType();
            eGenericType.setEClassifier(eClassifier instanceof EClass ? EcorePackage.Literals.EOBJECT
                    : EcorePackage.Literals.EJAVA_OBJECT);
        }
    }

    // Now we need to hook up opposites by finding the named feature in the type.
    //
    for (Map.Entry<EReference, String> entry : eReferenceToOppositeNameMap.entrySet()) {
        EReference eReference = entry.getKey();
        String oppositeName = entry.getValue();
        EClass eClass = (EClass) eReference.getEType();
        // TODO handle class cast exception better.
        EReference eOpposite = (EReference) eClass.getEStructuralFeature(oppositeName);
        if (eOpposite == null) {
            error(CodeGenEcorePlugin.INSTANCE.getString("_UI_TheAttributeIsNotAMemberOf_message",
                    new Object[] { oppositeName, eClass.getName() }));
        } else if (eOpposite.getEOpposite() != eReference && eOpposite.getEOpposite() != null) {
            error(CodeGenEcorePlugin.INSTANCE.getString("_UI_TheOppositeAlreadyHasOpposite_message",
                    new Object[] { oppositeName, eOpposite.getEOpposite().getName(),
                            eOpposite.getEOpposite().getEContainingClass().getName() }));
        } else {
            eReference.setEOpposite(eOpposite);
            eOpposite.setEOpposite(eReference);

            used(eOpposite);

            // Containers are transient by default unless explicitly annotated otherwise.
            //
            if (eOpposite.isContainment() && !transientEReferenceWithOpposite.contains(eReference)) {
                eReference.setTransient(true);
            }
        }
    }

    // Now we need to hook up keys by finding the named feature in the type.
    //
    for (Map.Entry<EReference, List<String>> entry : eReferenceToKeyNamesMap.entrySet()) {
        EReference eReference = entry.getKey();
        EClass eClass = (EClass) eReference.getEType();
        for (String keyName : entry.getValue()) {
            EStructuralFeature eKey = eClass.getEStructuralFeature(keyName);
            if (eKey == null) {
                error(CodeGenEcorePlugin.INSTANCE.getString("_UI_TheAttributeIsNotAMemberOf_message",
                        new Object[] { keyName, eClass.getName() }));
            } else if (!(eKey instanceof EAttribute)) {
                // TODO Ignore for now.
            } else {
                eReference.getEKeys().add((EAttribute) eKey);
                used(eKey);
            }
        }
    }

    // Clean up the temporary container annotations for holding map entry classes until they are for sure needed.
    //
    for (EPackage ePackage : packageNameToEPackageMap.values()) {
        EAnnotation eAnnotation = ePackage.getEAnnotation(MAP_ENTRY_CLASS_CONTAINER_ANNOTATION_SOURCE);
        if (eAnnotation != null) {
            EcoreUtil.remove(eAnnotation);
        }
    }

    // Now we should sort.
    //
    for (Map.Entry<EPackage, Map<Object, Integer>> entry : ePackageToOrderingMap.entrySet()) {
        EPackage ePackage = entry.getKey();
        Map<Object, Integer> nameToIDMap = entry.getValue();

        sort(ePackage.getEClassifiers(), nameToIDMap);
        for (EClassifier eClassifier : ePackage.getEClassifiers()) {
            if (eClassifier instanceof EClass) {
                EClass eClass = (EClass) eClassifier;
                sort(eClass.getEStructuralFeatures(), nameToIDMap);
            }
        }
    }

    // Find the fragment root so that we can generate to the right location (by default).
    //
    IPath targetFragmentRoot = project.getFullPath();
    for (int i = 0; i < packageFragmentRoots.length; ++i) {
        if (packageFragmentRoots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
            IPath path = packageFragmentRoots[i].getUnderlyingResource().getFullPath();
            if (targetFragmentRoot.isPrefixOf(path)) {
                targetFragmentRoot = path;
                break;
            }
        }
    }

    facadeHelper.reset();
    return targetFragmentRoot;
}

From source file:org.eclipse.fx.ide.css.validation.CssDslJavaValidator.java

License:Open Source License

@SuppressWarnings("restriction")
@Check/*w  ww.j a  v  a 2  s.c  om*/
public void checkDeclaration(css_declaration dec) {
    //      System.err.println("CHECK DECL " + dec);
    css_property property = dec.getProperty();

    // Only validate files who are:
    // * in a plug-in project
    //   - when css is part of build.properties bin.includes
    //   - when css is part of the source-folder
    IFile file = Utils.getFile(dec.eResource());

    //TODO We should add a service possibility to contribute these lookups
    boolean validate = false;

    try {
        if (file.getProject().hasNature("org.eclipse.pde.PluginNature")) { //$NON-NLS-1$
            // validate = true;
            IFile properties = PDEProject.getBuildProperties(file.getProject());
            Properties p = new Properties();
            try (InputStream in = properties.getContents()) {
                p.load(in);
                String includes = p.getProperty("bin.includes"); //$NON-NLS-1$
                if (includes != null) {
                    IPath path = file.getProjectRelativePath();
                    for (String s : includes.split(",")) { //$NON-NLS-1$
                        if (path.toString().startsWith(s.trim())) {
                            validate = true;
                            break;
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (!validate && file.getProject().hasNature("org.eclipse.jdt.core.javanature")) { //$NON-NLS-1$
            IJavaProject jp = JavaCore.create(file.getProject());
            for (IPackageFragmentRoot r : jp.getPackageFragmentRoots()) {
                if (r.getKind() == IPackageFragmentRoot.K_SOURCE) {
                    if (file.getProjectRelativePath().toString()
                            .startsWith(r.getPath().removeFirstSegments(1).toString())) {
                        validate = true;
                        break;
                    }
                }
            }
        }
    } catch (CoreException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    if (!validate) {
        return;
    }

    if (dec.eContainer() instanceof font_face) {
        if ("font-family".equals(property.getName())) {
            if (dec.getValueTokens().stream().filter(this::filterWS).count() != 1) {
                error("Font family has to define a name", dec,
                        CssDslPackage.Literals.CSS_DECLARATION__VALUE_TOKENS);
            } else {
                if (!(dec.getValueTokens().stream().filter(this::filterWS).findFirst()
                        .get() instanceof IdentifierTok)) {
                    CssTok tok = dec.getValueTokens().stream().filter(this::filterWS).findFirst().get();
                    error("Invalid font family name", dec, CssDslPackage.Literals.CSS_DECLARATION__VALUE_TOKENS,
                            dec.getValueTokens().indexOf(tok));
                }
            }
        } else if ("src".equals(property.getName())) {
            if (dec.getValueTokens().stream().filter(this::filterWS).count() == 0) {
                error("At least one URL is required", dec,
                        CssDslPackage.Literals.CSS_DECLARATION__VALUE_TOKENS);
            } else {
                dec.getValueTokens().stream().filter(this::filterWS).filter(this::filterSymbol)
                        .filter((t) -> !(t instanceof UrlTok)).forEach((t) -> {
                            error("Only url-values are allowed", dec,
                                    CssDslPackage.Literals.CSS_DECLARATION__VALUE_TOKENS,
                                    dec.getValueTokens().indexOf(t));
                        });
            }
        } else if ("font-stretch".equals(property.getName())) {

        } else if ("font-style".equals(property.getName())) {

        } else if ("font-weight".equals(property.getName())) {

        } else if ("unicode-range".equals(property.getName())) {

        } else {
            warning("Unknown property: \"" + property.getName() + "\"", property,
                    CssDslPackage.Literals.CSS_PROPERTY__NAME);
        }

        return;
    }

    List<Proposal> properties = ext.getPropertyProposalsForSelector(file, dec, null);
    //extension.getAllProperties(uri);

    boolean known = false;
    for (Proposal p : properties) {
        if (p.getProposal().equals(property.getName())) {
            known = true;
            break;
        }
    }

    if (!known) {
        ICompositeNode node = NodeModelUtils.getNode(dec.getProperty());

        boolean suppress = node.getText().contains("@SuppressWarning");
        if (!suppress && !PREDEFINED_VAR_PROPS.contains(property.getName())
                && !property.getName().startsWith("-var")) { //$NON-NLS-1$
            warning("Unknown property: \"" + property.getName() + "\"", property,
                    CssDslPackage.Literals.CSS_PROPERTY__NAME);
        }
    } else {

        ruleset rs = (ruleset) dec.eContainer();
        List<selector> selectors = rs.getSelectors();
        //         Set<CssProperty> selectorProps = new HashSet<>();
        //         for (selector selector : selectors) {
        //            selectorProps.addAll(extension.getPropertiesForSelector(uri, selector));
        //         }

        List<Proposal> selectorProps = ext.getPropertyProposalsForSelector(Utils.getFile(dec.eResource()), dec,
                selectors);

        if (selectorProps.size() > 0) {
            boolean supported = false;
            for (Proposal p : selectorProps) {
                if (p.getProposal().equals(property.getName())) {
                    supported = true;
                    break;
                }
            }

            if (!supported) {
                ICompositeNode node = NodeModelUtils.getNode(dec.getProperty());

                boolean suppress = node.getText().contains("@SuppressWarning"); //$NON-NLS-1$

                if (!PREDEFINED_VAR_PROPS.contains(property.getName())
                        && !property.getName().startsWith("-var")) {
                    warning("\"" + property.getName() + "\" is not supported by the given selectors",
                            CssDslPackage.Literals.CSS_DECLARATION__PROPERTY);
                }
            }
        }

        //         List<ValidationResult> result = extension.validateProperty(uri, null, property.getName(), tokens);

        //         System.err.println(result);
        //
        //         System.err.println("validation of " + property.getName());

        //         if (!result.isEmpty()) {
        //            for (ValidationResult r : result) {
        //               if (r.status == ValidationStatus.ERROR) {
        //                  if (r.object != null) {
        //                     if (r.object instanceof FuncTok) {
        //                        FuncTok f = (FuncTok) r.object;
        //                        error(r.message, f, CssDslPackage.Literals.FUNC_TOK__NAME, -1);
        //                     }
        //                     else {
        //                        error(r.message, r.object, null, 0);
        //                     }
        //                  }
        //                  else {
        //                     error(r.message, dec, CssDslPackage.Literals.CSS_DECLARATION__VALUE_TOKENS, r.index);
        //                  }
        //               }
        //            }
        //         }
    }
}