org.cordovastudio.editors.designer.actions.DesignerActionPanel.java Source code

Java tutorial

Introduction

Here is the source code for org.cordovastudio.editors.designer.actions.DesignerActionPanel.java

Source

/*
 * Copyright 2000-2012 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.cordovastudio.editors.designer.actions;

import com.intellij.openapi.actionSystem.*;
import com.intellij.openapi.wm.IdeFocusManager;
import com.intellij.ui.IdeBorderFactory;
import com.intellij.ui.SideBorder;
import com.intellij.util.ui.UIUtil;
import org.cordovastudio.editors.designer.CordovaDesignerToolWindowManager;
import org.cordovastudio.editors.designer.designSurface.ComponentSelectionListener;
import org.cordovastudio.editors.designer.designSurface.CordovaDesignerEditorPanel;
import org.cordovastudio.editors.designer.designSurface.editableArea.IEditableArea;
import org.cordovastudio.editors.designer.model.RadComponent;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.util.List;

/**
 * @author Alexander Lobas
 */
public class DesignerActionPanel implements DataProvider {
    public static final String TOOLBAR = "DesignerToolbar";

    private final DefaultActionGroup myActionGroup;
    private final DefaultActionGroup myStaticGroup = new DefaultActionGroup();
    private final DefaultActionGroup myDynamicGroup = new DefaultActionGroup();
    private final DefaultActionGroup myPopupGroup = new DefaultActionGroup();
    private final DefaultActionGroup myDynamicPopupGroup = new DefaultActionGroup();

    protected final JComponent myToolbar;
    protected final CordovaDesignerEditorPanel myDesigner;
    private final CommonEditActionsProvider myCommonEditActionsProvider;
    private final JComponent myShortcuts;

    public DesignerActionPanel(CordovaDesignerEditorPanel designer, JComponent shortcuts) {
        myDesigner = designer;
        myCommonEditActionsProvider = new CommonEditActionsProvider(designer);
        myShortcuts = shortcuts;

        createInplaceEditingAction(myShortcuts).setDesignerPanel(designer);

        myActionGroup = createActionGroup();
        myToolbar = createToolbar();

        ActionManager actionManager = ActionManager.getInstance();
        myPopupGroup.add(actionManager.getAction(IdeActions.ACTION_CUT));
        myPopupGroup.add(actionManager.getAction(IdeActions.ACTION_COPY));
        myPopupGroup.add(actionManager.getAction(IdeActions.ACTION_PASTE));
        myPopupGroup.addSeparator();
        myPopupGroup.add(actionManager.getAction(IdeActions.ACTION_DELETE));
        myPopupGroup.addSeparator();
        myPopupGroup.add(createSelectActionGroup(designer));
        myPopupGroup.addSeparator();
        myPopupGroup.add(myDynamicPopupGroup);

        designer.getSurfaceArea().addSelectionListener(new ComponentSelectionListener() {
            @Override
            public void selectionChanged(IEditableArea area) {
                updateSelectionActions(area.getSelection());
            }
        });
    }

    protected DefaultActionGroup createActionGroup() {
        DefaultActionGroup group = new DefaultActionGroup();
        group.add(myStaticGroup);
        group.add(myDynamicGroup);
        return group;
    }

    protected JComponent createToolbar() {
        ActionManager actionManager = ActionManager.getInstance();
        ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR, myActionGroup, true);
        actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY);

        JComponent toolbar = actionToolbar.getComponent();
        toolbar.setBorder(IdeBorderFactory.createBorder(SideBorder.BOTTOM));
        toolbar.setVisible(false);

        return toolbar;
    }

    @NotNull
    private ActionGroup createSelectActionGroup(CordovaDesignerEditorPanel designer) {
        final DefaultActionGroup group = new DefaultActionGroup("_Select", true);

        AnAction selectParent = new AnAction("Select Parent", "Select Parent", null) {
            @Override
            public void actionPerformed(AnActionEvent e) {
                myDesigner.getToolProvider()
                        .processKeyEvent(
                                new KeyEvent(myDesigner.getSurfaceArea().getNativeComponent(), KeyEvent.KEY_PRESSED,
                                        0, 0, KeyEvent.VK_ESCAPE, (char) KeyEvent.VK_ESCAPE),
                                myDesigner.getSurfaceArea());
            }
        };
        selectParent.registerCustomShortcutSet(KeyEvent.VK_ESCAPE, 0, null);

        IEditableArea area = designer.getSurfaceArea();

        AnAction selectSiblings = new SelectSiblingsAction(area);
        AnAction selectSameType = new SelectSameTypeAction(area);
        AnAction deselectAllAction = new DeselectAllAction(area);

        AnAction selectAllAction = createSelectAllAction(area);
        registerAction(selectAllAction, "$SelectAll");

        group.add(selectParent);
        group.add(selectSiblings);
        group.add(selectSameType);
        group.addSeparator();
        group.add(selectAllAction);
        group.add(deselectAllAction);

        return group;
    }

    public AnAction createSelectAllAction(IEditableArea area) {
        return new SelectAllAction(area);
    }

    public static StartInplaceEditing createInplaceEditingAction(JComponent shortcuts) {
        StartInplaceEditing action = new StartInplaceEditing();
        action.registerCustomShortcutSet(new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0)),
                shortcuts);
        return action;
    }

    public void registerAction(AnAction action, @NonNls String actionId) {
        action.registerCustomShortcutSet(ActionManager.getInstance().getAction(actionId).getShortcutSet(),
                myShortcuts);
    }

    public JComponent getToolbarComponent() {
        return myToolbar;
    }

    public DefaultActionGroup getActionGroup() {
        return myStaticGroup;
    }

    public DefaultActionGroup getPopupGroup() {
        return myPopupGroup;
    }

    protected DefaultActionGroup getDynamicActionGroup() {
        return myDynamicGroup;
    }

    protected JComponent getShortcuts() {
        return myShortcuts;
    }

    public void update() {
        boolean oldVisible = myToolbar.isVisible();
        boolean newVisible = isVisible(myActionGroup);
        myToolbar.setVisible(newVisible);
        if (oldVisible && newVisible) {
            ((JComponent) myToolbar.getParent()).revalidate();
        }
    }

    private static boolean isVisible(DefaultActionGroup group) {
        if (group.getChildrenCount() == 0) {
            return false;
        }

        for (AnAction action : group.getChildren(null)) {
            if (action instanceof DefaultActionGroup) {
                if (isVisible((DefaultActionGroup) action)) {
                    return true;
                }
            } else {
                return true;
            }
        }
        return false;
    }

    private void updateSelectionActions(List<RadComponent> selection) {
        boolean oldVisible = isVisible(myDynamicGroup);

        if (myDynamicGroup.getChildrenCount() > 0) {
            for (AnAction action : myDynamicGroup.getChildActionsOrStubs()) {
                action.unregisterCustomShortcutSet(myShortcuts);
            }
            myDynamicGroup.removeAll();
        }

        addSelectionActions(selection, myDynamicGroup);

        if (oldVisible || isVisible(myDynamicGroup)) {
            update();
        }
    }

    protected void addSelectionActions(List<RadComponent> selection, DefaultActionGroup group) {
        for (RadComponent parent : RadComponent.getParents(selection)) {
            parent.getLayout().addSelectionActions(myDesigner, group, myShortcuts, selection);
        }
        for (RadComponent component : selection) {
            component.addSelectionActions(myDesigner, group, myShortcuts, selection);
        }
    }

    public ActionGroup getPopupActions(IEditableArea area) {
        if (myDynamicPopupGroup.getChildrenCount() > 0) {
            myDynamicPopupGroup.removeAll();
        }

        WrapInAction.fill(myDesigner, myDynamicPopupGroup, area);

        return myPopupGroup;
    }

    @Override
    public Object getData(@NonNls String dataId) {
        if (PlatformDataKeys.DELETE_ELEMENT_PROVIDER.is(dataId) || PlatformDataKeys.CUT_PROVIDER.is(dataId)
                || PlatformDataKeys.COPY_PROVIDER.is(dataId) || PlatformDataKeys.PASTE_PROVIDER.is(dataId)) {
            JTable table = CordovaDesignerToolWindowManager.getInstance(myDesigner).getPropertyTable();
            Component focusOwner = IdeFocusManager.getInstance(myDesigner.getProject()).getFocusOwner();
            if (!UIUtil.isAncestor(table, focusOwner)) {
                return myCommonEditActionsProvider;
            }
        }
        return null;
    }
}