Java 类org.eclipse.ui.IWorkbenchWindow 实例源码

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    /*MessageDialog.openInformation(
            window.getShell(),
            "Plugin",
            "Hello, Eclipse world");*/

    // Pfad vom Projekt
    if (window != null)
    {
        IStructuredSelection selection = (IStructuredSelection) window.getSelectionService().getSelection();
        Object firstElement = selection.getFirstElement();
        if (firstElement instanceof IAdaptable)
        {
            IProject project = (IProject)((IAdaptable)firstElement).getAdapter(IProject.class);
            IPath path = project.getFullPath();
            System.out.println("Projekt: "+path);
            StartEGL.start(""+path);
        }
    }

    return null;
}

@Override
public boolean checkCondition() throws Exception {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {
            IWorkbenchWindow ww = PlatformUI.getWorkbench().getActiveWorkbenchWindow();

            if (ww == null)
                return;
            IWorkbenchPage page = ww.getActivePage();
            if (page == null)
                return;
            IEditorReference[] part = page.getEditorReferences();
            if (part == null)
                return;
            for (IEditorReference iEditorReference : part) {
                if( title.equals(iEditorReference.getTitle()) ) 
                    found = true;
            }
        }
    });
    return !found;
}

/**
 * Called before any tests have been run.
 *
 * @param description
 *            describes the tests to be run
 */
@Override
public void testRunStarted(Description description) throws Exception {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {

            IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
            try {
                N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView(
                        N4IDEXpectView.ID);
                view.notifySessionStarted(description);
            } catch (PartInitException e) {
                N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
            }
        }
    });
}

public static void notifyDbChanged(DbInfo dbinfo) {
    String action = Activator.getDefault().getPreferenceStore().getString(PG_EDIT_PREF.EDITOR_UPDATE_ACTION);
    if (action.equals(PG_EDIT_PREF.NO_ACTION)) {
        return;
    }
    for (IWorkbenchWindow wnd : PlatformUI.getWorkbench().getWorkbenchWindows()) {
        for (IWorkbenchPage page : wnd.getPages()) {
            for (IEditorReference ref : page.getEditorReferences()) {
                IEditorPart ed = ref.getEditor(false);
                if (ed instanceof ProjectEditorDiffer) {
                    notifyDbChanged(dbinfo, (ProjectEditorDiffer) ed, action.equals(PG_EDIT_PREF.UPDATE));
                }
            }
        }
    }
}

/**
 * Called when an atomic test has finished, whether the test succeeds or fails.
 *
 * @param description
 *            the description of the test that just ran
 */
@Override
public void testFinished(Description description) throws Exception {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {

            IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
            try {
                N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView(
                        N4IDEXpectView.ID);
                view.notifyFinishedExecutionOf(description);
            } catch (PartInitException e) {
                N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
            }
        }
    });
}

/**
 * Called when an atomic test fails.
 *
 * @param failure
 *            describes the test that failed and the exception that was thrown
 */
@Override
public void testFailure(Failure failure) throws Exception {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {

            IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
            try {
                N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView(
                        N4IDEXpectView.ID);
                view.notifyFailedExecutionOf(failure);
            } catch (PartInitException e) {
                N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
            }
        }
    });
}

/**
 * Called when an atomic test flags that it assumes a condition that is false
 *
 * describes the test that failed and the {@link AssumptionViolatedException} that was thrown
 */
@Override
public void testAssumptionFailure(Failure failure) {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {

            IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
            try {
                N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView(
                        N4IDEXpectView.ID);
                view.notifyFailedExecutionOf(failure);
            } catch (PartInitException e) {
                N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
            }
        }
    });
}

/**
 * Called when a test will not be run, generally because a test method is annotated with {@link org.junit.Ignore}.
 *
 * @param description
 *            describes the test that will not be run
 */
@Override
public void testIgnored(Description description) throws Exception {
    Display.getDefault().syncExec(new Runnable() {
        @Override
        public void run() {

            IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
            try {
                N4IDEXpectView view = (N4IDEXpectView) windows[0].getActivePage().showView(
                        N4IDEXpectView.ID);
                view.notifyIgnoredExecutionOf(description);
            } catch (PartInitException e) {
                N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
            }
        }
    });
}

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {

    IStructuredSelection selection = (IStructuredSelection) HandlerUtil.getCurrentSelectionChecked(event);

    IWorkbenchWindow[] windows = N4IDEXpectUIPlugin.getDefault().getWorkbench().getWorkbenchWindows();
    try {
        view = (N4IDEXpectView) windows[0].getActivePage().showView(
                N4IDEXpectView.ID);
    } catch (PartInitException e) {
        N4IDEXpectUIPlugin.logError("cannot refresh test view window", e);
    }

    Description desc = (Description) selection.getFirstElement();
    if (desc.isTest() && view.testsExecutionStatus.hasFailed(desc)) {
        Throwable failureException = view.testsExecutionStatus.getFailure(desc).getException();

        if (failureException instanceof ComparisonFailure) {
            ComparisonFailure cf = (ComparisonFailure) failureException;
            // display comparison view
            displayComparisonView(cf, desc);
        }
    }
    return null;
}

private void tryValidateManifestInEditor(final IResourceDelta delta) {
    if (isWorkbenchRunning()) {
        Display.getDefault().asyncExec(() -> {
            final IWorkbenchWindow window = getWorkbench().getActiveWorkbenchWindow();
            if (null != window) {
                final IWorkbenchPage page = window.getActivePage();
                for (final IEditorReference editorRef : page.getEditorReferences()) {
                    if (isEditorForResource(editorRef, delta.getResource())) {
                        final IWorkbenchPart part = editorRef.getPart(true);
                        if (part instanceof XtextEditor) {
                            editorCallback.afterSave((XtextEditor) part);
                            return;
                        }
                    }
                }
            }
        });
    }
}

@Override
public Object execute(final ExecutionEvent event) throws ExecutionException {
  this.decoratorManager = Activator.getDefault().getWorkbench().getDecoratorManager();

  if (!this.isHidden) {
    this.isHidden = true;
    this.setStore(false);
    this.setDecorator(false);
  } else {
    this.isHidden = false;
    this.setStore(true);
    this.setDecorator(true);
  }
  this.store.needsSaving();

  final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
  final ICommandService commandService = window.getService(ICommandService.class);
  if (commandService != null) {
    commandService.refreshElements(COMMAND_ID, null);
  }
  return null;
}

@Test
public void testGenerateFromFile() throws Exception {
    IWorkbenchWindow iww = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    IJavaProject pj = ProjectHelper.getOrCreateSimpleGW4EProject(PROJECT_NAME,true,false);
    IFile file = (IFile) ResourceManager.getResource(pj.getProject().getFullPath().append("src/test/resources/Simple.json").toString());


    GraphWalkerFacade.generateFromFile(iww, GenerationFactory.get(file), new NullProgressMonitor());

    IFile interf = (IFile) ResourceManager.getResource(
            pj.getProject().getFullPath().append("target/generated-test-sources/Simple.java").toString());
    assertTrue(interf.exists());
    IFile impl = (IFile) ResourceManager
            .getResource(pj.getProject().getFullPath().append("src/test/java/SimpleImpl.java").toString());
    assertTrue(impl.exists());
}

private boolean closeEditorIfAlreadyOpen(IPath jobFilePath, String fileName) {

        String jobPathRelative = StringUtils.removeStart(jobFilePath.toString(), "..");
        jobPathRelative = StringUtils.removeStart(jobPathRelative, "/");
        String jobPathAbsolute = StringUtils.replace(jobPathRelative, "/", "\\");
        IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        if (activeWorkbenchWindow != null) {
            IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
            for (IEditorReference editorRefrence : activePage.getEditorReferences()) {
                if (StringUtils.equals(editorRefrence.getTitleToolTip(), jobPathRelative)
                        || StringUtils.equals(editorRefrence.getTitleToolTip(), jobPathAbsolute)
                        || fileName.equals(editorRefrence.getTitleToolTip())) {
                    IEditorPart editor = editorRefrence.getEditor(true);
                    if (!activePage.closeEditor(editor, true)) {
                        LOGGER.debug("Editor not closed");
                    }
                    LOGGER.debug("Editor closed");
                    return true;
                }
            }
        }
        return false;
    }

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbench workbench = PlatformUI.getWorkbench();
    if (workbench==null){
        return null;
    }
    IWorkbenchWindow activeWorkbenchWindow = workbench.getActiveWorkbenchWindow();
    if (activeWorkbenchWindow==null){
        return null;
    }
    IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
    if (activePage==null){
        return null;
    }
    IEditorPart editor = activePage.getActiveEditor();

    if (editor instanceof BatchEditor){
        executeOnBatchEditor((BatchEditor) editor);
    }
    return null;
}

public Object execute(ExecutionEvent event) throws ExecutionException {

        final INewWizard wizard = new NewModelWizard();

        // Initialize the selection
        final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        final ISelectionService service = window.getSelectionService();
        final IStructuredSelection selection = (IStructuredSelection)service
                .getSelection("org.eclipse.sirius.ui.tools.views.model.explorer"); //$NON-NLS-1$
        wizard.init(PlatformUI.getWorkbench(), selection);

        // Open the new model wizard
        final WizardDialog dialog = new WizardDialog(window.getShell(), wizard);
        dialog.open();
        return null;
    }

@Override
public final Object execute ( final ExecutionEvent event ) throws ExecutionException
{
    final IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked ( event );

    final Object value = event.getParameter ( PARAMETER_NAME_VIEW_ID );

    try
    {
        final String[] viewIds = ( (String)value ).split ( ":" );
        if ( viewIds.length == 1 )
        {
            openView ( viewIds[0], null, window );
        }
        else if ( viewIds.length == 2 )
        {
            openView ( viewIds[0], viewIds[1], window );
        }
    }
    catch ( final PartInitException e )
    {
        throw new ExecutionException ( "Part could not be initialized", e ); //$NON-NLS-1$
    }

    return null;
}

/**
 * Opens the view with the given identifier.
 * 
 * @param viewId
 *            The view to open; must not be <code>null</code>
 * @throws PartInitException
 *             If the part could not be initialized.
 */
private final void openView ( final String viewId, final String secondaryId, final IWorkbenchWindow activeWorkbenchWindow ) throws PartInitException
{

    final IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage ();
    if ( activePage == null )
    {
        return;
    }
    if ( secondaryId != null )
    {
        activePage.showView ( viewId, secondaryId, IWorkbenchPage.VIEW_ACTIVATE );
    }
    else
    {
        activePage.showView ( viewId );
    }

}

@Override
protected void makeActions ( final IWorkbenchWindow window )
{
    this.exitAction = ActionFactory.QUIT.create ( window );
    register ( this.exitAction );

    this.aboutAction = ActionFactory.ABOUT.create ( window );
    register ( this.aboutAction );

    this.newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create ( window );
    register ( this.newWindowAction );

    register ( ActionFactory.NEW_WIZARD_DROP_DOWN.create ( window ) );
    register ( ActionFactory.NEW.create ( window ) );
    register ( ActionFactory.INTRO.create ( window ) );
    register ( ActionFactory.SAVE.create ( window ) );

    this.showViews = ContributionItemFactory.VIEWS_SHORTLIST.create ( window );
    this.newWizards = ContributionItemFactory.NEW_WIZARD_SHORTLIST.create ( window );

    register ( ActionFactory.NEW_EDITOR.create ( window ) );
    register ( ActionFactory.PREFERENCES.create ( window ) );
}

@Override
public Object execute(final ExecutionEvent event) throws ExecutionException {
  final IWorkbenchWindow activeWorkbenchWindow = HandlerUtil.getActiveWorkbenchWindow(event);
  final ISourceProviderService service =
      activeWorkbenchWindow.getService(ISourceProviderService.class);
  final AnalysisSourceProvider sourceProvider =
      (AnalysisSourceProvider) service.getSourceProvider(AnalysisSourceProvider.ANALYSIS_STATE);

  final Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
      if (sourceProvider.getEvaluationState() == EvaluationState.OPEN) {
        Visualization.evaluatorOpen = false;
        sourceProvider.setEvaluationState(EvaluationState.CLOSE);
      } else if (sourceProvider.getEvaluationState() == EvaluationState.CLOSE) {
        Visualization.evaluatorOpen = true;
        sourceProvider.setEvaluationState(EvaluationState.OPEN);
      }
      Visualization.showViz();
    }
  });
  thread.start();
  return true;
}

private SWTBotShell showPreferenceDialogMAC() {
    final IWorkbench workbench = PlatformUI.getWorkbench();
    workbench.getDisplay().asyncExec(new Runnable() {
        public void run() {
            IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();
            if (window != null) {
                Menu appMenu = workbench.getDisplay().getSystemMenu();
                for (MenuItem item : appMenu.getItems()) {
                    if (item.getText().startsWith("Preferences")) {
                        Event event = new Event();
                        event.time = (int) System.currentTimeMillis();
                        event.widget = item;
                        event.display = workbench.getDisplay();
                        item.setSelection(true);
                        item.notifyListeners(SWT.Selection, event);
                        break;
                    }
                }
            }
        }
    });
    return  getPreferenceDialog() ;
}

protected IFile getSelectedFile() {
    IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    if (window == null) {
        return null;
    }

    ISelection selection = window.getSelectionService().getSelection();
    if (! (selection instanceof IStructuredSelection)){
        return null;
    }
    IStructuredSelection structuredSelection = (IStructuredSelection) selection;

    Object firstElement = structuredSelection.getFirstElement();
    if (!(firstElement instanceof IAdaptable)) {
        return null;
    }

    IFile file = (IFile) ((IAdaptable) firstElement).getAdapter(IFile.class);
    return file;
}

@Override
public Object execute(final ExecutionEvent event) throws ExecutionException {
  final IWorkbenchWindow activeWorkbenchWindow = HandlerUtil.getActiveWorkbenchWindow(event);
  final ISourceProviderService service =
      activeWorkbenchWindow.getService(ISourceProviderService.class);
  final AnalysisSourceProvider sourceProvider =
      (AnalysisSourceProvider) service.getSourceProvider(AnalysisSourceProvider.ANALYSIS_STATE);
  sourceProvider.setActive(ReasoningType.DISCOVER_ATOM);

  final Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
      final AlloyDiscovering alloyDiscovering = new AlloyDiscovering();
      final boolean discovering =
          alloyDiscovering.discovering();
      if (!discovering) {
        Visualization.sourceProvider.setPassive();
      }
      Visualization.showViz();
    }
  });
  thread.start();
  return true;
}

protected void search(String pattern, SearchType type, boolean withRef) {               
    IWorkbench workbench = PlatformUI.getWorkbench();
    IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();
    IWorkbenchPage workbenchPage = workbenchWindow.getActivePage();
    IEditorPart editorPart = workbenchPage.getActiveEditor();
    if (editorPart instanceof IWithAvroSchemaEditor) {
        AvroSchemaEditor schemaEditor = ((IWithAvroSchemaEditor) editorPart).getEditor();           
        AvroContext masterContext = schemaEditor.getContext().getMaster();
        SearchNodeContext searchNodeContext = masterContext.getSearchNodeContext();
        if (pattern == null || pattern.trim().isEmpty()) {
            searchNodeContext.reset();
        } else if (searchNodeContext.searchNodes(type, pattern, withRef)) {
            AvroNode node = searchNodeContext.next();
            schemaEditor.getContentPart()
                .getSchemaViewer(AvroContext.Kind.MASTER)
                .setSelection(new StructuredSelection(node), true);
        }
        refreshCommands(editorPart, SearchNodePropertyTester.PROPERTIES);
    }
}

/**
 * the command has been executed, so extract extract the needed information
 * from the application context.
 */
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow window = HandlerUtil
            .getActiveWorkbenchWindowChecked(event);
    final Display display = Display.getDefault();
    final Shell shell = window.getShell();
    Locale.setDefault(Locale.ENGLISH);
    final TipDayEx tipDayEx = new TipDayEx();
    for (String tipMessage : new String[] { "This is the first tip",
            "This is the second tip", "This is the third tip",
            "This is the forth tip", "This is the fifth tip" }) {
        tipDayEx.addTip(String.format(
                "<h4>%s</h4>" + "<b>%s</b> " + "<u>%s</u> " + "<i>%s</i> " + "%s "
                        + "%s<br/>" + "<p color=\"#A00000\">%s</p>",
                tipMessage, tipMessage, tipMessage, tipMessage, tipMessage,
                tipMessage, tipMessage));

    }
    tipDayEx.open(shell, display);
    return null;
}

/**
 * Note: it compares marker's resource file name and open editors' file name.
 *
 * @param marker
 * @return if marker's editor is open, return editor, else return null
 */
public static IEditorPart getOpenEditorOfMarker(final IMarker marker) {
  final IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
  for (final IWorkbenchWindow iWorkbenchWindow : windows) {
    final IWorkbenchPage[] pages = iWorkbenchWindow.getPages();
    for (final IWorkbenchPage iWorkbenchPage : pages) {
      final IEditorReference[] editors = iWorkbenchPage.getEditorReferences();
      for (final IEditorReference iEditorReference : editors) {
        try {
          if (iEditorReference instanceof IFileEditorInput) {
            final IFileEditorInput input = (IFileEditorInput) iEditorReference.getEditorInput();
            final IFile file = input.getFile();
            // TODO Caused by: java.lang.NullPointerException when delete marker on ecore editor.
            if (file.getFullPath().equals(marker.getResource().getFullPath())) {
              return iEditorReference.getEditor(false);
            }
          }
        } catch (final PartInitException e) {
          e.printStackTrace();
        }
      }
    }
  }
  return null;
}

protected AvroSchemaEditor getEditor() {

    IWorkbench workbench = PlatformUI.getWorkbench();
       IWorkbenchWindow window = workbench.getActiveWorkbenchWindow();

       if (window != null) {
           IWorkbenchPage workbenchPage = window.getActivePage();
           if (workbenchPage != null) {
            IWorkbenchPart activePart = workbenchPage.getActivePart();                
               if (activePart instanceof IWithAvroSchemaEditor) {
                return ((IWithAvroSchemaEditor) activePart).getEditor();
               }
           }
       }

       return null;
}

public static File getEditedFileFolder() {
    IWorkbenchPage page = null;
    IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
    for (int i = 0; i < windows.length; i++) {
        if (windows[i] != null) {
            IWorkbenchWindow window = windows[i];
            page = windows[i].getActivePage();
            if (page != null)
                break;
        }
    }
    IEditorPart part = page.getActiveEditor();
    FileEditorInput editor = (FileEditorInput) part.getEditorInput();
    IFile file = editor.getFile();
    IFolder folder = (IFolder) file.getParent();
    File f = null;
    try {
        f = ResourceManager.toFile(folder.getFullPath());
    } catch (FileNotFoundException e) {
        ResourceManager.logException(e);
    }
    return f;
}

public static void generateOffline(final IResource resource, IPackageFragment pkg, String classfile , BuildPolicy[]  generators, int timeout, IWorkbenchWindow aww) {
    Job job = new Job("GW4E Offline Generation Source Job") {
        @Override
        public IStatus run(IProgressMonitor monitor) {
            try {
                if (resource instanceof IFile) {
                    SubMonitor subMonitor = SubMonitor.convert(monitor, 120);
                    IFile file = (IFile) resource;
                    if (PreferenceManager.isGraphModelFile(file)) {
                        AbstractPostConversion converter = getOfflineConversion(file,pkg,classfile,generators,timeout);
                        ConversionRunnable runnable = converter.createConversionRunnable(aww);
                        subMonitor.subTask("Processing converter ");
                        SubMonitor child = subMonitor.split(1);
                        runnable.run(child);
                    }                       
                }
            } catch (Exception e) {
                e.printStackTrace();
                ResourceManager.logException(e);
            }
            return Status.OK_STATUS;
        }
    };
    job.setUser(true);
    job.schedule();
}

@Override
public Object execute(final ExecutionEvent event) throws ExecutionException {
  final IWorkbenchWindow activeWorkbenchWindow = HandlerUtil.getActiveWorkbenchWindow(event);
  final ISourceProviderService service =
      activeWorkbenchWindow.getService(ISourceProviderService.class);
  final AnalysisSourceProvider sourceProvider =
      (AnalysisSourceProvider) service.getSourceProvider(AnalysisSourceProvider.ANALYSIS_STATE);
  sourceProvider.setPassive();

  final Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
      AlloyValidator.isCanceled = true;
      AlloyOtherSolutionReasoning.getInstance().finish();
      AlloyOtherSolutionDiscovering.getInstance().finish();
      AlloyOtherSolutionReasoningForAtom.getInstance().finish();
      Visualization.showViz();
    }
  });
  thread.start();
  return true;
}

@Override
public void windowOpened(IWorkbenchWindow window) {
    if (window.getShell() != null) {
        IWorkbenchPage[] pages = window.getPages();
        for (IWorkbenchPage page : pages) {
            pageOpened(page);
        }
        window.addPageListener(this);
    }
}

private void init() {
    if (PlatformUI.isWorkbenchRunning()) {
        IWorkbench workbench = EditorConfigPlugin.getDefault().getWorkbench();
        if (workbench != null) {
            IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
            for (IWorkbenchWindow window : windows) {
                windowOpened(window);
            }
            EditorConfigPlugin.getDefault().getWorkbench().addWindowListener(this);
        }
    }
}

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    if (null == activeWorkbenchWindow) {
        return null;
    }
    IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
    if (null == activePage) {
        return null;
    }
    IWorkbenchPart activePart = activePage.getActivePart();
    if (!(activePart instanceof CommonNavigator)) {
        return null;
    }

    CommonNavigator navigator = (CommonNavigator) activePart;
    CommonViewer commonViewer = navigator.getCommonViewer();

    Tree navigatorTree = commonViewer.getTree();
    List<TreeItem> visibleItems = new ArrayList<>();
    collectChildren(navigatorTree.getItems(), visibleItems);

    List<Object> visibleData = visibleItems.stream().map(i -> i.getData()).collect(Collectors.toList());

    commonViewer.setSelection(new StructuredSelection(visibleData), false);

    return null;
}

private void showConsoleView(final boolean silent) {
    if (PlatformUI.isWorkbenchRunning() && !silent) {
        final IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        final IViewPart view = window.getActivePage().findView(CONSOLE_VIEW_ID);
        if (null != view) {
            view.setFocus();
        }
    }
}

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
    ISelection selection = HandlerUtil.getCurrentSelection(event);
    POJO2DataTypeWizard wizard = new POJO2DataTypeWizard();
    wizard.init(window.getWorkbench(), 
            selection instanceof IStructuredSelection
            ? (IStructuredSelection) selection : StructuredSelection.EMPTY);
    WizardDialog dialog = new WizardDialog(window.getShell(), wizard);
    dialog.open();
    return null;
}

/**
 * Obtains an editor that is currently active.
 * @return the active editor, or <code>null</code> if none
 */
public static IEditorPart getActiveEditor() {
    IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    if (window != null) {
        IEditorPart part = window.getActivePage().getActiveEditor();
        return part;
    }
    return null;
}

/**
 * Returns the active workbench window.
 * @return the active workbench window
 */
public IWorkbenchWindow getActiveWorkbenchWindow() {
    IWorkbench iwb = this.getWorkbench();
    if (iwb!=null) {
        return iwb.getActiveWorkbenchWindow();
    }
    return null;
}

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
    IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    if (activeWorkbenchWindow == null) {
        return null;
    }
    IWorkbenchPage activePage = activeWorkbenchWindow.getActivePage();
    if (activePage == null) {
        return null;
    }
    IEditorPart editor = activePage.getActiveEditor();
    if (editor == null) {
        return null;
    }
    IEditorInput input = editor.getEditorInput();
    if (input == null || ! (input instanceof FileEditorInput)) {
        return null;
    }
    IFile file = ((FileEditorInput) input).getFile();
    if (file != null && file.getType() == IResource.FILE && file.getFileExtension().equals("java")) {
        utils = new ProjectUtils(file.getProject());
        if (utils.isGluonMobileProject()) {
            ISelection selection = HandlerUtil.getCurrentSelection(event);
            Display.getDefault().asyncExec(() -> new JCode(utils, selection,  (JavaEditor) editor));
        }
    }
    return null;
}

public static IWorkbenchWindow getActiveWorkbenchWindow() {
    IWorkbench workbench = getWorkbench();
    if (workbench == null) {
        return null;
    }
    IWorkbenchWindow workbenchWindow = workbench.getActiveWorkbenchWindow();

    if (workbenchWindow != null) {
        return workbenchWindow;
    }
    /* fall back - try to execute in UI */
    WorkbenchWindowRunnable wwr = new WorkbenchWindowRunnable();
    getSafeDisplay().syncExec(wwr);
    return wwr.workbenchWindowFromUI;
}

protected final IWorkbenchPage getActiveWorkbenchPage() {
    IWorkbenchWindow workBenchWindow = getActiveWorkbenchWindow();
    if (workBenchWindow != null) {
        return workBenchWindow.getActivePage();
    }
    return null;
}

public static IStructuredSelection getCurrentSelection() {
    IWorkbenchWindow window = PlatformUI.getWorkbench()
            .getActiveWorkbenchWindow();
    if (window != null) {
        IStructuredSelection selection = (IStructuredSelection) window
                .getSelectionService().getSelection();
        return selection;
    }
    return null;
}