| /* |
| * Copyright (C) 2013 The Android Open Source Project |
| * |
| * 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 com.intellij.android.designer.designSurface; |
| |
| import com.android.tools.idea.configurations.RenderContext; |
| import com.android.tools.idea.configurations.RenderOptionsMenuBuilder; |
| import com.android.tools.idea.rendering.IncludeReference; |
| import com.android.tools.idea.rendering.RefreshRenderAction; |
| import com.android.tools.idea.rendering.RenderResult; |
| import com.android.tools.idea.rendering.SaveScreenshotAction; |
| import com.google.common.collect.Sets; |
| import com.intellij.android.designer.model.RadViewComponent; |
| import com.intellij.android.designer.model.RadViewLayout; |
| import com.intellij.designer.actions.DesignerActionPanel; |
| import com.intellij.designer.designSurface.DesignerEditorPanel; |
| import com.intellij.designer.designSurface.EditableArea; |
| import com.intellij.designer.designSurface.ZoomType; |
| import com.intellij.designer.model.RadComponent; |
| import com.intellij.designer.model.RadLayout; |
| import com.intellij.icons.AllIcons; |
| import com.intellij.openapi.actionSystem.*; |
| import com.intellij.openapi.fileTypes.StdFileTypes; |
| import com.intellij.openapi.keymap.KeymapUtil; |
| import com.intellij.openapi.vfs.VirtualFile; |
| import com.intellij.psi.PsiElement; |
| import com.intellij.psi.PsiFile; |
| import com.intellij.psi.PsiReference; |
| import com.intellij.psi.search.GlobalSearchScope; |
| import com.intellij.psi.xml.XmlFile; |
| import com.intellij.refactoring.psi.SearchUtils; |
| import com.intellij.ui.IdeBorderFactory; |
| import com.intellij.ui.SideBorder; |
| import com.intellij.util.PsiNavigateUtil; |
| import icons.AndroidIcons; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import javax.swing.*; |
| import java.awt.*; |
| import java.util.*; |
| import java.util.List; |
| |
| public class AndroidDesignerActionPanel extends DesignerActionPanel { |
| public AndroidDesignerActionPanel(DesignerEditorPanel designer, JComponent shortcuts) { |
| super(designer, shortcuts); |
| |
| DefaultActionGroup popupGroup = getPopupGroup(); |
| popupGroup.addSeparator(); |
| popupGroup.add(new SaveScreenshotAction((AndroidDesignerEditorPanel)myDesigner)); |
| } |
| |
| @Override |
| protected JComponent createToolbar() { |
| JPanel panel = new JPanel(new BorderLayout()); |
| panel.setBorder(IdeBorderFactory.createBorder(SideBorder.BOTTOM)); |
| |
| // Create a layout where there are three toolbars: |
| // +----------------------------------------------------------------------------+ |
| // | Normal toolbar, minus dynamic actions | |
| // +---------------------------------------------+------------------------------+ |
| // | Dynamic layout actions | Zoom actions and file status | |
| // +---------------------------------------------+------------------------------+ |
| |
| ActionManager actionManager = ActionManager.getInstance(); |
| ActionToolbar actionToolbar = actionManager.createActionToolbar(TOOLBAR, getActionGroup(), true); |
| actionToolbar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY); |
| panel.add(actionToolbar.getComponent(), BorderLayout.NORTH); |
| |
| ActionToolbar layoutToolBar = actionManager.createActionToolbar(TOOLBAR, getDynamicActionGroup(), true); |
| layoutToolBar.setLayoutPolicy(ActionToolbar.WRAP_LAYOUT_POLICY); |
| |
| // The default toolbar layout adds too much spacing between the buttons. Switch to mini mode, |
| // but also set a minimum size which will add *some* padding for our 16x16 icons. |
| layoutToolBar.setMiniMode(true); |
| layoutToolBar.setMinimumButtonSize(new Dimension(22, 24)); |
| |
| ActionToolbar zoomToolBar = actionManager.createActionToolbar(TOOLBAR, getRhsActions(), true); |
| JPanel bottom = new JPanel(new BorderLayout()); |
| bottom.add(layoutToolBar.getComponent(), BorderLayout.WEST); |
| RenderContext context = (AndroidDesignerEditorPanel)myDesigner; |
| RenderOptionsMenuBuilder optionsMenuBuilder = RenderOptionsMenuBuilder.create(context); |
| ActionToolbar optionsToolBar = optionsMenuBuilder.addPreferXmlOption().addDeviceFrameOption().addRetinaOption().build(); |
| JPanel combined = new JPanel(new BorderLayout()); |
| combined.add(zoomToolBar.getComponent(), BorderLayout.WEST); |
| combined.add(optionsToolBar.getComponent(), BorderLayout.EAST); |
| bottom.add(combined, BorderLayout.EAST); |
| |
| panel.add(bottom, BorderLayout.SOUTH); |
| |
| return panel; |
| } |
| |
| @Override |
| protected DefaultActionGroup createActionGroup() { |
| // Like super implementation, but only adding the static group; the dynamic |
| // actions are added to a separate toolbar |
| DefaultActionGroup group = new DefaultActionGroup(); |
| group.add(getActionGroup()); |
| return group; |
| } |
| |
| @Override |
| public void update() { |
| // Overriding super; we don't want to dynamically hide or show the toolbar; it's there all the time |
| } |
| |
| private ActionGroup getRhsActions() { |
| DefaultActionGroup group = new DefaultActionGroup(); |
| |
| group.add(new ToggleAction(null, "Zoom to Fit (0)", AndroidIcons.ZoomFit) { |
| @Override |
| public boolean isSelected(AnActionEvent e) { |
| return ((AndroidDesignerEditorPanel)myDesigner).isZoomToFit(); |
| } |
| |
| @Override |
| public void setSelected(AnActionEvent e, boolean state) { |
| myDesigner.zoom(ZoomType.FIT); |
| } |
| }); |
| group.add(new AnAction(null, "Reset Zoom to 100% (1)", AndroidIcons.ZoomActual) { |
| @Override |
| public void actionPerformed(AnActionEvent e) { myDesigner.zoom(ZoomType.ACTUAL); } |
| }); |
| group.addSeparator(); |
| group.add(new AnAction(null, "Zoom In (+)", AndroidIcons.ZoomIn) { |
| @Override |
| public void actionPerformed(AnActionEvent e) { myDesigner.zoom(ZoomType.IN); } |
| }); |
| group.add(new AnAction(null, "Zoom Out (-)", AndroidIcons.ZoomOut) { |
| @Override |
| public void actionPerformed(AnActionEvent e) { myDesigner.zoom(ZoomType.OUT); } |
| }); |
| |
| String description = "Jump to Source"; |
| KeyboardShortcut shortcut = ActionManager.getInstance().getKeyboardShortcut(IdeActions.ACTION_GOTO_DECLARATION); |
| if (shortcut != null) { |
| description += " (" + KeymapUtil.getShortcutText(shortcut) + ")"; |
| } |
| // Use FilesTypes.Text rather than FileTypes.Xml here to avoid having the icon from |
| // the tab bar replicated right below it |
| group.add(new AnAction(null, description, AllIcons.FileTypes.Text) { |
| @Override |
| public void actionPerformed(AnActionEvent e) { |
| List<RadComponent> selection = myDesigner.getSurfaceArea().getSelection(); |
| if (!selection.isEmpty()) { |
| RadViewComponent component = (RadViewComponent)selection.get(0); |
| PsiNavigateUtil.navigate(component.getTag()); |
| } |
| } |
| |
| @Override |
| public void update(AnActionEvent e) { |
| List<RadComponent> selection = myDesigner.getSurfaceArea().getSelection(); |
| e.getPresentation().setEnabled(!selection.isEmpty()); |
| } |
| }); |
| |
| AndroidDesignerEditorPanel designer = (AndroidDesignerEditorPanel)myDesigner; |
| group.add(new RefreshRenderAction(designer)); |
| |
| return group; |
| } |
| |
| @Override |
| protected void addSelectionActions(List<RadComponent> selection, DefaultActionGroup group) { |
| if (!selection.isEmpty()) { |
| // Segment the selected components into lists of siblings |
| Map<RadComponent, List<RadComponent>> siblingLists = RadComponent.groupSiblings(selection); |
| for (Map.Entry<RadComponent, List<RadComponent>> entry : siblingLists.entrySet()) { |
| @Nullable RadComponent parent = entry.getKey(); |
| @NotNull List<RadComponent> children = entry.getValue(); |
| |
| if (parent != null) { |
| RadLayout layout = parent.getLayout(); |
| if (layout instanceof RadViewLayout) { |
| ((RadViewLayout) layout).addContainerSelectionActions(myDesigner, group, RadViewComponent.getViewComponents(children)); |
| } else { |
| layout.addSelectionActions(myDesigner, group, getShortcuts(), children); |
| } |
| } else if (selection.size() == 1) { |
| // If you select a root layout, offer selection actions on it as well |
| RadLayout selected = selection.get(0).getLayout(); |
| if (selected instanceof RadViewLayout) { |
| ((RadViewLayout) selected).addContainerSelectionActions(myDesigner, group, RadViewComponent.getViewComponents(children)); |
| } |
| } |
| } |
| |
| for (RadComponent component : selection) { |
| component.addSelectionActions(myDesigner, group, getShortcuts(), Collections.singletonList(component)); |
| } |
| } |
| } |
| |
| private DefaultActionGroup myPopupGroup; |
| private final DefaultActionGroup myDynamicBeforeGroup = new DefaultActionGroup(); |
| private final DefaultActionGroup myDynamicAfterGroup = new DefaultActionGroup(); |
| |
| @Override |
| public ActionGroup getPopupActions(EditableArea area) { |
| ActionGroup superActions = super.getPopupActions(area); |
| |
| if (myPopupGroup == null) { |
| myPopupGroup = new DefaultActionGroup(); |
| myPopupGroup.add(myDynamicBeforeGroup); |
| myPopupGroup.add(superActions); |
| myPopupGroup.add(myDynamicAfterGroup); |
| } |
| |
| if (myDynamicBeforeGroup.getChildrenCount() > 0) { |
| myDynamicBeforeGroup.removeAll(); |
| } |
| if (myDynamicAfterGroup.getChildrenCount() > 0) { |
| myDynamicAfterGroup.removeAll(); |
| } |
| |
| addShowIncludedInContextMenuActions(); |
| addSelectionContextMenuActions(area); |
| |
| return myPopupGroup; |
| } |
| |
| private void addSelectionContextMenuActions(EditableArea area) { |
| // Insert selection actions |
| List<RadComponent> selection = area.getSelection(); |
| if (selection.size() == 1) { |
| // Add specific actions |
| RadComponent selected = selection.get(0); |
| if (selected instanceof RadViewComponent) { |
| RadViewComponent viewComponent = (RadViewComponent)selected; |
| AndroidDesignerEditorPanel designer = (AndroidDesignerEditorPanel)myDesigner; |
| viewComponent.addPopupActions(designer, myDynamicBeforeGroup, myDynamicAfterGroup, designer, selection); |
| |
| // Add in actions from the parents |
| RadComponent current = selected.getParent(); |
| while (current != null && current instanceof RadViewComponent) { |
| DefaultActionGroup container = new DefaultActionGroup(((RadViewComponent)current).getId(), true); |
| if (((RadViewComponent)current).addPopupActions(designer, container, container, designer, selection)) { |
| myDynamicAfterGroup.add(container); |
| } |
| current = current.getParent(); |
| } |
| } |
| } |
| } |
| |
| private void addShowIncludedInContextMenuActions() { |
| DefaultActionGroup targetGroup = myDynamicBeforeGroup; |
| AndroidDesignerEditorPanel designer = (AndroidDesignerEditorPanel)myDesigner; |
| XmlFile xmlFile = designer.getXmlFile(); |
| GlobalSearchScope useScope = GlobalSearchScope.projectScope(designer.getProject()); |
| GlobalSearchScope scope = GlobalSearchScope.getScopeRestrictedByFileTypes(useScope, StdFileTypes.XML); |
| Iterable<PsiReference> allReferences = SearchUtils.findAllReferences(xmlFile, scope); |
| Iterator<PsiReference> iterator = allReferences.iterator(); |
| |
| if (iterator.hasNext()) { |
| boolean needSeparator = false; |
| |
| |
| VirtualFile skip = null; |
| String includingLayout = IncludeReference.getIncludingLayout(designer.getXmlFile()); |
| if (includingLayout != null) { |
| targetGroup.add(new ShowIncludedIn(designer, null, "Hide Including Layout")); |
| targetGroup.addSeparator(); |
| RenderResult lastResult = designer.getLastRenderResult(); |
| if (lastResult != null) { |
| IncludeReference includedWithin = lastResult.getIncludedWithin(); |
| if (includedWithin != null && includedWithin != IncludeReference.NONE) { |
| skip = includedWithin.getFromFile(); |
| } |
| } |
| } |
| |
| Set<VirtualFile> files = Sets.newHashSet(); |
| while (iterator.hasNext()) { |
| PsiReference reference = iterator.next(); |
| PsiElement referenceElement = reference.getElement(); |
| if (referenceElement != null) { |
| PsiFile file = referenceElement.getContainingFile(); |
| if (file != null && file != xmlFile) { |
| VirtualFile fromFile = file.getVirtualFile(); |
| if (fromFile != null && fromFile != skip) { |
| files.add(fromFile); |
| } |
| } |
| } |
| } |
| |
| if (!files.isEmpty()) { |
| List<VirtualFile> sorted = new ArrayList<VirtualFile>(files); |
| Collections.sort(sorted, new Comparator<VirtualFile>() { |
| @Override |
| public int compare(VirtualFile f1, VirtualFile f2) { |
| VirtualFile p1 = f1.getParent(); |
| VirtualFile p2 = f2.getParent(); |
| if (p1 != null && p2 != null) { |
| return p1.getName().compareTo(p2.getName()); |
| } |
| return f1.getName().compareTo(f2.getName()); |
| } |
| }); |
| for (VirtualFile fromFile : sorted) { |
| VirtualFile toFile = designer.getVirtualFile(); |
| IncludeReference includeReference = IncludeReference.create(designer.getModule(), fromFile, toFile); |
| String title = String.format("Show Included In %1$s", includeReference.getFromDisplayName()); |
| targetGroup.add(new ShowIncludedIn(designer, includeReference, title)); |
| needSeparator = true; |
| } |
| |
| if (needSeparator) { |
| targetGroup.addSeparator(); |
| } |
| } |
| } |
| } |
| |
| private static class ShowIncludedIn extends AnAction { |
| private final IncludeReference myReference; |
| private final AndroidDesignerEditorPanel myPanel; |
| |
| private ShowIncludedIn(@NotNull AndroidDesignerEditorPanel panel, @Nullable IncludeReference reference, @NotNull String title) { |
| super(title); |
| myPanel = panel; |
| myReference = reference; |
| } |
| |
| @Override |
| public void actionPerformed(AnActionEvent e) { |
| String layout = myReference != null ? myReference.getFromResourceUrl() : null; |
| IncludeReference.setIncludingLayout(myPanel.getProject(), myPanel.getXmlFile(), layout); |
| myPanel.requestRender(); |
| } |
| } |
| } |
