org.deved.antlride.internal.ui.editor.AntlrEditor.java Source code

Java tutorial

Introduction

Here is the source code for org.deved.antlride.internal.ui.editor.AntlrEditor.java

Source

/*******************************************************************************
 * Copyright (c) 2007, 2008 Edgar Espina.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
     
 *******************************************************************************/
package org.deved.antlride.internal.ui.editor;

import java.util.HashMap;
import java.util.Map;

import org.deved.antlride.common.ui.text.editor.AntlrBaseEditor;
import org.deved.antlride.core.AntlrLanguageToolkit;
import org.deved.antlride.core.build.AntlrSourceParserRepository;
import org.deved.antlride.core.model.IGrammar;
import org.deved.antlride.core.model.IModelElement;
import org.deved.antlride.core.model.ast.AntlrModelElementLocator;
import org.deved.antlride.core.resources.AntlrPackages;
import org.deved.antlride.internal.ui.actions.AntlrGenerateActionGroup;
import org.deved.antlride.internal.ui.preferences.AntlrBuilderPreferencesPage;
import org.deved.antlride.internal.ui.text.AntlrTextTools;
import org.deved.antlride.internal.ui.text.folding.AntlrFoldingStructureProvider;
import org.deved.antlride.ui.AntlrPreferenceConstants;
import org.deved.antlride.ui.AntlrUI;
import org.deved.antlride.ui.AntlrUIConstants;
import org.deved.antlride.ui.AntlrWorkbenchAdapter;
import org.deved.antlride.ui.text.AntlrTextPartitions;
import org.eclipse.core.filebuffers.IDocumentSetupParticipant;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
import org.eclipse.dltk.core.ISourceModule;
import org.eclipse.dltk.internal.ui.editor.ScriptOutlinePage;
import org.eclipse.dltk.ui.text.folding.IFoldingStructureProvider;
import org.eclipse.draw2d.ColorConstants;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.text.TextSelection;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.INavigationLocation;
import org.eclipse.ui.IPartService;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.actions.ActionGroup;
import org.eclipse.ui.dialogs.PreferencesUtil;
import org.eclipse.ui.dialogs.PropertyDialogAction;
import org.eclipse.ui.model.IWorkbenchAdapter;
import org.eclipse.ui.texteditor.AbstractTextEditor;
import org.eclipse.ui.texteditor.ITextEditor;
import org.eclipse.ui.texteditor.ITextEditorActionConstants;
import org.eclipse.ui.texteditor.TextSelectionNavigationLocation;

public class AntlrEditor extends AntlrBaseEditor {

    public static final String EDITOR_CONTEXT_MENU_ID = "#AntlrEditorContext";

    private class AntlrStructuredSelectionProvider implements ISelectionProvider {

        public void addSelectionChangedListener(ISelectionChangedListener listener) {
        }

        public ISelection getSelection() {
            IModelElement element = getSelectedElement();
            if (element == null)
                return new StructuredSelection();
            IWorkbenchAdapter workbenchAdapter = new AntlrWorkbenchAdapter(element);
            return new StructuredSelection(workbenchAdapter);
        }

        public void removeSelectionChangedListener(ISelectionChangedListener listener) {
        }

        public void setSelection(ISelection selection) {
        }
    }

    private class AntlrTextSelectionNavigationLocation extends TextSelectionNavigationLocation {

        public AntlrTextSelectionNavigationLocation(ITextEditor part, boolean initialize) {
            super(part, initialize);
        }

        @Override
        protected IEditorPart getEditorPart() {
            IEditorPart editorPart = super.getEditorPart();
            AntlrEditor editor = null;
            if (editorPart != null) {
                editor = (AntlrEditor) editorPart.getAdapter(AntlrEditor.class);
            }
            return editor;
        }
    }

    public AntlrEditor() {
    }

    @Override
    public Object getAdapter(Class required) {
        if (required == AntlrEditor.class) {
            return this;
        }
        return super.getAdapter(required);
    }

    private IWorkbenchPart getActivePart() {
        IWorkbenchWindow window = getSite().getWorkbenchWindow();
        IPartService service = window.getPartService();
        IWorkbenchPart part = service.getActivePart();
        return part;
    }

    @Override
    protected void doSetInput(IEditorInput input) throws CoreException {
        String[] packageNames = AntlrPackages.getAvailablePackageNames();
        if (packageNames.length == 0) {
            Display.getDefault().asyncExec(new Runnable() {

                public void run() {
                    // synchronized (lock) {
                    while (getActivePart() == null) {
                        try {
                            Thread.sleep(200L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    AntlrEditor.this.setFocus();
                    String[] pkgs = AntlrPackages.getAvailablePackageNames();
                    if (pkgs.length == 0 && (getActivePart() instanceof AntlrMultiPageEditor)) {
                        Shell shell = Display.getDefault().getActiveShell();
                        boolean yes = MessageDialog.openQuestion(shell, "No package defined",
                                "In order to build your grammar you must to create an ANTLR package. Would you like to define one now?");
                        if (yes) {
                            Map<String, Object> data = new HashMap<String, Object>();
                            data.put("PropertyAndPreferencePage.nolink", Boolean.TRUE);
                            String id = AntlrBuilderPreferencesPage.PREFERENCE_PAGE_ID;
                            PreferencesUtil.createPreferenceDialogOn(shell, id, new String[] { id }, data).open();
                        }
                    }
                    // }
                }
            });
        }
        super.doSetInput(input);
    }

    @Override
    public void createActions() {
        super.createActions();
        Action action = new PropertyDialogAction(getEditorSite(), new AntlrStructuredSelectionProvider());// new
        // AddBreakpointsActionDelegate(this);
        action.setText("ANTLR Breakpoints");//$NON-NLS-1$
        setAction("AddBreakpointsAction", action); //$NON-NLS-1$
        markAsStateDependentAction("AddBreakpointsAction", true); //$NON-NLS-1$

        // action = new ToggleCommentAction(DLTKEditorMessages
        //            .getBundleForConstructedKeys(), "ToggleComment.", this); //$NON-NLS-1$
        // action
        // .setActionDefinitionId(IScriptEditorActionDefinitionIds.TOGGLE_COMMENT);
        //      setAction("ToggleComment", action); //$NON-NLS-1$
        // ((ToggleCommentAction) action).configure(getSourceViewer(),
        // getSourceViewerConfiguration());
        //      markAsStateDependentAction("ToggleComment", true); //$NON-NLS-1$
    }

    protected ActionGroup createGenerateActionGroup() {
        return new AntlrGenerateActionGroup(this, ITextEditorActionConstants.GROUP_EDIT);
    }

    @Override
    public void editorContextMenuAboutToShow(IMenuManager menu) {
        super.editorContextMenuAboutToShow(menu);
        menu.insertBefore(ITextEditorActionConstants.GROUP_OPEN,
                new Separator(ITextEditorActionConstants.GROUP_GENERATE));
        // menu.insertBefore(ITextEditorActionConstants.GROUP_OPEN, new
        // GroupMarker(ITextEditorActionConstants.GROUP_GENERATE));
        IAction action = getAddBreakpointsAction();
        // menu.appendToGroup(ITextEditorActionConstants.GROUP_GENERATE, new
        // Separator());
        menu.appendToGroup(ITextEditorActionConstants.GROUP_GENERATE, action);
    }

    private IAction getAddBreakpointsAction() {
        return getAction("AddBreakpointsAction");
    }

    @Override
    protected String getEditorContextId() {
        return AntlrUI.PLUGIN_ID + ".antlrEditorScope";
    }

    @Override
    protected String getPartitionId() {
        return AntlrTextPartitions.ANTLR_PARTITIONING;
    }

    @Override
    protected IDocumentSetupParticipant createDocumentSetupParticipant() {
        return new AntlrDocumentSetupParticipant();
    }

    @Override
    protected ScriptOutlinePage doCreateOutlinePage() {
        return new AntlrOutlinePage(this, getScriptPreferenceStore());
    }

    @Override
    public String getEditorId() {
        return AntlrUIConstants.EDITOR_ID;
    }

    @Override
    protected void setPreferenceStore(IPreferenceStore store) {
        store.addPropertyChangeListener(new IPropertyChangeListener() {

            public void propertyChange(PropertyChangeEvent event) {
                if (event.getProperty().equals(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND)) {
                    IPreferenceStore preferenceStore = AntlrUI.getDefault().getPreferenceStore();
                    preferenceStore.setValue(AntlrPreferenceConstants.EDITOR_BACKGROUND_COLOR,
                            event.getNewValue().toString());
                } else if (event.getProperty()
                        .equals(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT)) {
                    IPreferenceStore preferenceStore = AntlrUI.getDefault().getPreferenceStore();
                    PreferenceConverter.setValue(preferenceStore, AntlrPreferenceConstants.EDITOR_BACKGROUND_COLOR,
                            ColorConstants.white.getRGB());
                }
            }
        });
        IPreferenceStore preferenceStore = AntlrUI.getDefault().getPreferenceStore();
        if (store.getBoolean(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND_SYSTEM_DEFAULT)) {
            PreferenceConverter.setValue(preferenceStore, AntlrPreferenceConstants.EDITOR_BACKGROUND_COLOR,
                    ColorConstants.white.getRGB());
        } else {
            preferenceStore.setValue(AntlrPreferenceConstants.EDITOR_BACKGROUND_COLOR,
                    store.getString(AbstractTextEditor.PREFERENCE_COLOR_BACKGROUND));
        }
        super.setPreferenceStore(store);
    }

    @Override
    protected IFoldingStructureProvider createFoldingStructureProvider() {
        return new AntlrFoldingStructureProvider(/* this */);
    }

    private IModelElement getSelectedElement() {
        TextSelection textSelection = (TextSelection) getSelectionProvider().getSelection();
        ISourceModule sourceModule = getSourceModule();
        IGrammar grammar = AntlrSourceParserRepository.getGrammar(sourceModule);
        AntlrModelElementLocator locator = new AntlrModelElementLocator(grammar);
        IModelElement element = locator.getElementAt(textSelection.getOffset());
        return element;
    }

    @Override
    public IDLTKLanguageToolkit getLanguageToolkit() {
        return AntlrLanguageToolkit.getDefault();
    }

    @Override
    public IPreferenceStore getScriptPreferenceStore() {
        return AntlrUI.getDefault().getPreferenceStore();
    }

    @Override
    public AntlrTextTools getTextTools() {
        return AntlrUI.getDefault().getTextTools();
    }

    @Override
    protected String getPairMatcherCharacters() {
        return "{}()[]";
    }

    @Override
    protected String getContextMenuId() {
        return EDITOR_CONTEXT_MENU_ID;
    }

    @Override
    public INavigationLocation createEmptyNavigationLocation() {
        return new AntlrTextSelectionNavigationLocation(this, false);
    }

    @Override
    public INavigationLocation createNavigationLocation() {
        return new AntlrTextSelectionNavigationLocation(this, true);
    }
}