| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php |
| * |
| * 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.android.ide.eclipse.adt.internal.editors.layout.gle2; |
| |
| import static com.android.SdkConstants.ANDROID_URI; |
| import static com.android.SdkConstants.ATTR_ID; |
| |
| import com.android.annotations.NonNull; |
| import com.android.ide.common.api.INode; |
| import com.android.ide.common.api.RuleAction; |
| import com.android.ide.common.api.RuleAction.Choices; |
| import com.android.ide.common.api.RuleAction.Separator; |
| import com.android.ide.common.api.RuleAction.Toggle; |
| import com.android.ide.common.layout.BaseViewRule; |
| import com.android.ide.eclipse.adt.internal.editors.IconFactory; |
| import com.android.ide.eclipse.adt.internal.editors.common.CommonXmlEditor; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration; |
| import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; |
| import com.android.ide.eclipse.adt.internal.editors.layout.gre.RulesEngine; |
| import com.android.ide.eclipse.adt.internal.lint.EclipseLintClient; |
| import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; |
| import com.android.sdklib.devices.Device; |
| import com.android.sdklib.devices.Screen; |
| import com.android.sdkuilib.internal.widgets.ResolutionChooserDialog; |
| import com.google.common.base.Strings; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.jface.window.Window; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Event; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.MenuItem; |
| import org.eclipse.swt.widgets.ToolBar; |
| import org.eclipse.swt.widgets.ToolItem; |
| import org.eclipse.ui.ISharedImages; |
| import org.eclipse.ui.PlatformUI; |
| |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| /** |
| * Toolbar shown at the top of the layout editor, which adds a number of context-sensitive |
| * layout actions (as well as zooming controls on the right). |
| */ |
| public class LayoutActionBar extends Composite { |
| private GraphicalEditorPart mEditor; |
| private ToolBar mLayoutToolBar; |
| private ToolBar mLintToolBar; |
| private ToolBar mZoomToolBar; |
| private ToolItem mZoomRealSizeButton; |
| private ToolItem mZoomOutButton; |
| private ToolItem mZoomResetButton; |
| private ToolItem mZoomInButton; |
| private ToolItem mZoomFitButton; |
| private ToolItem mLintButton; |
| private List<RuleAction> mPrevActions; |
| |
| /** |
| * Creates a new {@link LayoutActionBar} and adds it to the given parent. |
| * |
| * @param parent the parent composite to add the actions bar to |
| * @param style the SWT style to apply |
| * @param editor the associated layout editor |
| */ |
| public LayoutActionBar(Composite parent, int style, GraphicalEditorPart editor) { |
| super(parent, style | SWT.NO_FOCUS); |
| mEditor = editor; |
| |
| GridLayout layout = new GridLayout(3, false); |
| setLayout(layout); |
| |
| mLayoutToolBar = new ToolBar(this, /*SWT.WRAP |*/ SWT.FLAT | SWT.RIGHT | SWT.HORIZONTAL); |
| mLayoutToolBar.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false)); |
| mZoomToolBar = createZoomControls(); |
| mZoomToolBar.setLayoutData(new GridData(SWT.END, SWT.BEGINNING, false, false)); |
| mLintToolBar = createLintControls(); |
| |
| GridData lintData = new GridData(SWT.END, SWT.BEGINNING, false, false); |
| lintData.exclude = true; |
| mLintToolBar.setLayoutData(lintData); |
| } |
| |
| @Override |
| public void dispose() { |
| super.dispose(); |
| mPrevActions = null; |
| } |
| |
| /** Updates the layout contents based on the current selection */ |
| void updateSelection() { |
| NodeProxy parent = null; |
| LayoutCanvas canvas = mEditor.getCanvasControl(); |
| SelectionManager selectionManager = canvas.getSelectionManager(); |
| List<SelectionItem> selections = selectionManager.getSelections(); |
| if (selections.size() > 0) { |
| // TODO: better handle multi-selection -- maybe we should disable it or |
| // something. |
| // What if you select children with different parents? Of different types? |
| // etc. |
| NodeProxy node = selections.get(0).getNode(); |
| if (node != null && node.getParent() != null) { |
| parent = (NodeProxy) node.getParent(); |
| } |
| } |
| |
| if (parent == null) { |
| // Show the background's properties |
| CanvasViewInfo root = canvas.getViewHierarchy().getRoot(); |
| if (root == null) { |
| return; |
| } |
| parent = canvas.getNodeFactory().create(root); |
| selections = Collections.emptyList(); |
| } |
| |
| RulesEngine engine = mEditor.getRulesEngine(); |
| List<NodeProxy> selectedNodes = new ArrayList<NodeProxy>(); |
| for (SelectionItem item : selections) { |
| selectedNodes.add(item.getNode()); |
| } |
| List<RuleAction> actions = new ArrayList<RuleAction>(); |
| engine.callAddLayoutActions(actions, parent, selectedNodes); |
| |
| // Place actions in the correct order (the actions may come from different |
| // rules and should be merged properly via sorting keys) |
| Collections.sort(actions); |
| |
| // Add in actions for the child as well, if there is exactly one. |
| // These are not merged into the parent list of actions; they are appended |
| // at the end. |
| int index = -1; |
| String label = null; |
| if (selectedNodes.size() == 1) { |
| List<RuleAction> itemActions = new ArrayList<RuleAction>(); |
| NodeProxy selectedNode = selectedNodes.get(0); |
| engine.callAddLayoutActions(itemActions, selectedNode, null); |
| if (itemActions.size() > 0) { |
| Collections.sort(itemActions); |
| |
| if (!(itemActions.get(0) instanceof RuleAction.Separator)) { |
| actions.add(RuleAction.createSeparator(0)); |
| } |
| label = selectedNode.getStringAttr(ANDROID_URI, ATTR_ID); |
| if (label != null) { |
| label = BaseViewRule.stripIdPrefix(label); |
| index = actions.size(); |
| } |
| actions.addAll(itemActions); |
| } |
| } |
| |
| if (!updateActions(actions)) { |
| updateToolbar(actions, index, label); |
| } |
| mPrevActions = actions; |
| } |
| |
| /** Update the toolbar widgets */ |
| private void updateToolbar(final List<RuleAction> actions, final int labelIndex, |
| final String label) { |
| if (mLayoutToolBar == null || mLayoutToolBar.isDisposed()) { |
| return; |
| } |
| for (ToolItem c : mLayoutToolBar.getItems()) { |
| c.dispose(); |
| } |
| mLayoutToolBar.pack(); |
| addActions(actions, labelIndex, label); |
| mLayoutToolBar.pack(); |
| mLayoutToolBar.layout(); |
| } |
| |
| /** |
| * Attempts to update the existing toolbar actions, if the action list is |
| * similar to the current list. Returns false if this cannot be done and the |
| * contents must be replaced. |
| */ |
| private boolean updateActions(@NonNull List<RuleAction> actions) { |
| List<RuleAction> before = mPrevActions; |
| List<RuleAction> after = actions; |
| |
| if (before == null) { |
| return false; |
| } |
| |
| if (!before.equals(after) || after.size() > mLayoutToolBar.getItemCount()) { |
| return false; |
| } |
| |
| int actionIndex = 0; |
| for (int i = 0, max = mLayoutToolBar.getItemCount(); i < max; i++) { |
| ToolItem item = mLayoutToolBar.getItem(i); |
| int style = item.getStyle(); |
| Object data = item.getData(); |
| if (data != null) { |
| // One action can result in multiple toolbar items (e.g. a choice action |
| // can result in multiple radio buttons), so we've have to replace all of |
| // them with the corresponding new action |
| RuleAction prevAction = before.get(actionIndex); |
| while (prevAction != data) { |
| actionIndex++; |
| if (actionIndex == before.size()) { |
| return false; |
| } |
| prevAction = before.get(actionIndex); |
| if (prevAction == data) { |
| break; |
| } else if (!(prevAction instanceof RuleAction.Separator)) { |
| return false; |
| } |
| } |
| RuleAction newAction = after.get(actionIndex); |
| assert newAction.equals(prevAction); // Maybe I can do this lazily instead? |
| |
| // Update action binding to the new action |
| item.setData(newAction); |
| |
| // Sync button states: the checked state is not considered part of |
| // RuleAction equality |
| if ((style & SWT.CHECK) != 0) { |
| assert newAction instanceof Toggle; |
| Toggle toggle = (Toggle) newAction; |
| item.setSelection(toggle.isChecked()); |
| } else if ((style & SWT.RADIO) != 0) { |
| assert newAction instanceof Choices; |
| Choices choices = (Choices) newAction; |
| String current = choices.getCurrent(); |
| String id = (String) item.getData(ATTR_ID); |
| boolean selected = Strings.nullToEmpty(current).equals(id); |
| item.setSelection(selected); |
| } |
| } else { |
| // Must be a separator, or a label (which we insert for nested widgets) |
| assert (style & SWT.SEPARATOR) != 0 || !item.getText().isEmpty() : item; |
| } |
| } |
| |
| return true; |
| } |
| |
| private void addActions(List<RuleAction> actions, int labelIndex, String label) { |
| if (actions.size() > 0) { |
| // Flag used to indicate that if there are any actions -after- this, it |
| // should be separated from this current action (we don't unconditionally |
| // add a separator at the end of these groups in case there are no more |
| // actions at the end so that we don't have a trailing separator) |
| boolean needSeparator = false; |
| |
| int index = 0; |
| for (RuleAction action : actions) { |
| if (index == labelIndex) { |
| final ToolItem button = new ToolItem(mLayoutToolBar, SWT.PUSH); |
| button.setText(label); |
| needSeparator = false; |
| } |
| index++; |
| |
| if (action instanceof Separator) { |
| addSeparator(mLayoutToolBar); |
| needSeparator = false; |
| continue; |
| } else if (needSeparator) { |
| addSeparator(mLayoutToolBar); |
| needSeparator = false; |
| } |
| |
| if (action instanceof RuleAction.Choices) { |
| RuleAction.Choices choices = (Choices) action; |
| if (!choices.isRadio()) { |
| addDropdown(choices); |
| } else { |
| addSeparator(mLayoutToolBar); |
| addRadio(choices); |
| needSeparator = true; |
| } |
| } else if (action instanceof RuleAction.Toggle) { |
| addToggle((Toggle) action); |
| } else { |
| addPlainAction(action); |
| } |
| } |
| } |
| } |
| |
| /** Add a separator to the toolbar, unless there already is one there at the end already */ |
| private static void addSeparator(ToolBar toolBar) { |
| int n = toolBar.getItemCount(); |
| if (n > 0 && (toolBar.getItem(n - 1).getStyle() & SWT.SEPARATOR) == 0) { |
| ToolItem separator = new ToolItem(toolBar, SWT.SEPARATOR); |
| separator.setWidth(15); |
| } |
| } |
| |
| private void addToggle(Toggle toggle) { |
| final ToolItem button = new ToolItem(mLayoutToolBar, SWT.CHECK); |
| |
| URL iconUrl = toggle.getIconUrl(); |
| String title = toggle.getTitle(); |
| if (iconUrl != null) { |
| button.setImage(IconFactory.getInstance().getIcon(iconUrl)); |
| button.setToolTipText(title); |
| } else { |
| button.setText(title); |
| } |
| button.setData(toggle); |
| |
| button.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| Toggle toggle = (Toggle) button.getData(); |
| toggle.getCallback().action(toggle, getSelectedNodes(), |
| toggle.getId(), button.getSelection()); |
| updateSelection(); |
| } |
| }); |
| if (toggle.isChecked()) { |
| button.setSelection(true); |
| } |
| } |
| |
| private List<INode> getSelectedNodes() { |
| List<SelectionItem> selections = |
| mEditor.getCanvasControl().getSelectionManager().getSelections(); |
| List<INode> nodes = new ArrayList<INode>(selections.size()); |
| for (SelectionItem item : selections) { |
| nodes.add(item.getNode()); |
| } |
| |
| return nodes; |
| } |
| |
| |
| private void addPlainAction(RuleAction menuAction) { |
| final ToolItem button = new ToolItem(mLayoutToolBar, SWT.PUSH); |
| |
| URL iconUrl = menuAction.getIconUrl(); |
| String title = menuAction.getTitle(); |
| if (iconUrl != null) { |
| button.setImage(IconFactory.getInstance().getIcon(iconUrl)); |
| button.setToolTipText(title); |
| } else { |
| button.setText(title); |
| } |
| button.setData(menuAction); |
| |
| button.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| RuleAction menuAction = (RuleAction) button.getData(); |
| menuAction.getCallback().action(menuAction, getSelectedNodes(), menuAction.getId(), |
| false); |
| updateSelection(); |
| } |
| }); |
| } |
| |
| private void addRadio(RuleAction.Choices choices) { |
| List<URL> icons = choices.getIconUrls(); |
| List<String> titles = choices.getTitles(); |
| List<String> ids = choices.getIds(); |
| String current = choices.getCurrent() != null ? choices.getCurrent() : ""; //$NON-NLS-1$ |
| |
| assert icons != null; |
| assert icons.size() == titles.size(); |
| |
| for (int i = 0; i < icons.size(); i++) { |
| URL iconUrl = icons.get(i); |
| String title = titles.get(i); |
| final String id = ids.get(i); |
| final ToolItem item = new ToolItem(mLayoutToolBar, SWT.RADIO); |
| item.setToolTipText(title); |
| item.setImage(IconFactory.getInstance().getIcon(iconUrl)); |
| item.setData(choices); |
| item.setData(ATTR_ID, id); |
| item.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| if (item.getSelection()) { |
| RuleAction.Choices choices = (Choices) item.getData(); |
| choices.getCallback().action(choices, getSelectedNodes(), id, null); |
| updateSelection(); |
| } |
| } |
| }); |
| boolean selected = current.equals(id); |
| if (selected) { |
| item.setSelection(true); |
| } |
| } |
| } |
| |
| private void addDropdown(RuleAction.Choices choices) { |
| final ToolItem combo = new ToolItem(mLayoutToolBar, SWT.DROP_DOWN); |
| URL iconUrl = choices.getIconUrl(); |
| if (iconUrl != null) { |
| combo.setImage(IconFactory.getInstance().getIcon(iconUrl)); |
| combo.setToolTipText(choices.getTitle()); |
| } else { |
| combo.setText(choices.getTitle()); |
| } |
| combo.setData(choices); |
| |
| Listener menuListener = new Listener() { |
| @Override |
| public void handleEvent(Event event) { |
| Menu menu = new Menu(mLayoutToolBar.getShell(), SWT.POP_UP); |
| RuleAction.Choices choices = (Choices) combo.getData(); |
| List<URL> icons = choices.getIconUrls(); |
| List<String> titles = choices.getTitles(); |
| List<String> ids = choices.getIds(); |
| String current = choices.getCurrent() != null ? choices.getCurrent() : ""; //$NON-NLS-1$ |
| |
| for (int i = 0; i < titles.size(); i++) { |
| String title = titles.get(i); |
| final String id = ids.get(i); |
| URL itemIconUrl = icons != null && icons.size() > 0 ? icons.get(i) : null; |
| MenuItem item = new MenuItem(menu, SWT.CHECK); |
| item.setText(title); |
| if (itemIconUrl != null) { |
| Image itemIcon = IconFactory.getInstance().getIcon(itemIconUrl); |
| item.setImage(itemIcon); |
| } |
| |
| boolean selected = id.equals(current); |
| if (selected) { |
| item.setSelection(true); |
| } |
| |
| item.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| RuleAction.Choices choices = (Choices) combo.getData(); |
| choices.getCallback().action(choices, getSelectedNodes(), id, null); |
| updateSelection(); |
| } |
| }); |
| } |
| |
| Rectangle bounds = combo.getBounds(); |
| Point location = new Point(bounds.x, bounds.y + bounds.height); |
| location = combo.getParent().toDisplay(location); |
| menu.setLocation(location.x, location.y); |
| menu.setVisible(true); |
| } |
| }; |
| combo.addListener(SWT.Selection, menuListener); |
| } |
| |
| // ---- Zoom Controls ---- |
| |
| @SuppressWarnings("unused") // SWT constructors have side effects, they are not unused |
| private ToolBar createZoomControls() { |
| ToolBar toolBar = new ToolBar(this, SWT.FLAT | SWT.RIGHT | SWT.HORIZONTAL); |
| |
| IconFactory iconFactory = IconFactory.getInstance(); |
| mZoomRealSizeButton = new ToolItem(toolBar, SWT.CHECK); |
| mZoomRealSizeButton.setToolTipText("Emulate Real Size"); |
| mZoomRealSizeButton.setImage(iconFactory.getIcon("zoomreal")); //$NON-NLS-1$); |
| mZoomRealSizeButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| boolean newState = mZoomRealSizeButton.getSelection(); |
| if (rescaleToReal(newState)) { |
| mZoomOutButton.setEnabled(!newState); |
| mZoomResetButton.setEnabled(!newState); |
| mZoomInButton.setEnabled(!newState); |
| mZoomFitButton.setEnabled(!newState); |
| } else { |
| mZoomRealSizeButton.setSelection(!newState); |
| } |
| } |
| }); |
| |
| mZoomFitButton = new ToolItem(toolBar, SWT.PUSH); |
| mZoomFitButton.setToolTipText("Zoom to Fit (0)"); |
| mZoomFitButton.setImage(iconFactory.getIcon("zoomfit")); //$NON-NLS-1$); |
| mZoomFitButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| rescaleToFit(true); |
| } |
| }); |
| |
| mZoomResetButton = new ToolItem(toolBar, SWT.PUSH); |
| mZoomResetButton.setToolTipText("Reset Zoom to 100% (1)"); |
| mZoomResetButton.setImage(iconFactory.getIcon("zoom100")); //$NON-NLS-1$); |
| mZoomResetButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| resetScale(); |
| } |
| }); |
| |
| // Group zoom in/out separately |
| new ToolItem(toolBar, SWT.SEPARATOR); |
| |
| mZoomOutButton = new ToolItem(toolBar, SWT.PUSH); |
| mZoomOutButton.setToolTipText("Zoom Out (-)"); |
| mZoomOutButton.setImage(iconFactory.getIcon("zoomminus")); //$NON-NLS-1$); |
| mZoomOutButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| rescale(-1); |
| } |
| }); |
| |
| mZoomInButton = new ToolItem(toolBar, SWT.PUSH); |
| mZoomInButton.setToolTipText("Zoom In (+)"); |
| mZoomInButton.setImage(iconFactory.getIcon("zoomplus")); //$NON-NLS-1$); |
| mZoomInButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| rescale(+1); |
| } |
| }); |
| |
| return toolBar; |
| } |
| |
| @SuppressWarnings("unused") // SWT constructors have side effects, they are not unused |
| private ToolBar createLintControls() { |
| ToolBar toolBar = new ToolBar(this, SWT.FLAT | SWT.RIGHT | SWT.HORIZONTAL); |
| |
| // Separate from adjacent toolbar |
| new ToolItem(toolBar, SWT.SEPARATOR); |
| |
| ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages(); |
| mLintButton = new ToolItem(toolBar, SWT.PUSH); |
| mLintButton.setToolTipText("Show Lint Warnings for this Layout"); |
| mLintButton.setImage(sharedImages.getImage(ISharedImages.IMG_OBJS_WARN_TSK)); |
| mLintButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| CommonXmlEditor editor = mEditor.getEditorDelegate().getEditor(); |
| IFile file = editor.getInputFile(); |
| if (file != null) { |
| EclipseLintClient.showErrors(getShell(), file, editor); |
| } |
| } |
| }); |
| |
| return toolBar; |
| } |
| |
| /** |
| * Updates the lint indicator state in the given layout editor |
| */ |
| public void updateErrorIndicator() { |
| updateErrorIndicator(mEditor.getEditedFile()); |
| } |
| |
| /** |
| * Updates the lint indicator state for the given file |
| * |
| * @param file the file to show the indicator status for |
| */ |
| public void updateErrorIndicator(IFile file) { |
| IMarker[] markers = EclipseLintClient.getMarkers(file); |
| updateErrorIndicator(markers.length); |
| } |
| |
| /** |
| * Sets whether the action bar should show the "lint warnings" button |
| * |
| * @param hasLintWarnings whether there are lint errors to be shown |
| */ |
| private void updateErrorIndicator(final int markerCount) { |
| Display display = getDisplay(); |
| if (display.getThread() != Thread.currentThread()) { |
| display.asyncExec(new Runnable() { |
| @Override |
| public void run() { |
| if (!isDisposed()) { |
| updateErrorIndicator(markerCount); |
| } |
| } |
| }); |
| return; |
| } |
| |
| GridData layoutData = (GridData) mLintToolBar.getLayoutData(); |
| Integer existing = (Integer) mLintToolBar.getData(); |
| Integer current = Integer.valueOf(markerCount); |
| if (!current.equals(existing)) { |
| mLintToolBar.setData(current); |
| boolean layout = false; |
| boolean hasLintWarnings = markerCount > 0 && AdtPrefs.getPrefs().isLintOnSave(); |
| if (layoutData.exclude == hasLintWarnings) { |
| layoutData.exclude = !hasLintWarnings; |
| mLintToolBar.setVisible(hasLintWarnings); |
| layout = true; |
| } |
| if (markerCount > 0) { |
| String iconName = ""; |
| switch (markerCount) { |
| case 1: iconName = "lint1"; break; //$NON-NLS-1$ |
| case 2: iconName = "lint2"; break; //$NON-NLS-1$ |
| case 3: iconName = "lint3"; break; //$NON-NLS-1$ |
| case 4: iconName = "lint4"; break; //$NON-NLS-1$ |
| case 5: iconName = "lint5"; break; //$NON-NLS-1$ |
| case 6: iconName = "lint6"; break; //$NON-NLS-1$ |
| case 7: iconName = "lint7"; break; //$NON-NLS-1$ |
| case 8: iconName = "lint8"; break; //$NON-NLS-1$ |
| case 9: iconName = "lint9"; break; //$NON-NLS-1$ |
| default: iconName = "lint9p"; break;//$NON-NLS-1$ |
| } |
| mLintButton.setImage(IconFactory.getInstance().getIcon(iconName)); |
| } |
| if (layout) { |
| layout(); |
| } |
| redraw(); |
| } |
| } |
| |
| /** |
| * Returns true if zooming in/out/to-fit/etc is allowed (which is not the case while |
| * emulating real size) |
| * |
| * @return true if zooming is allowed |
| */ |
| boolean isZoomingAllowed() { |
| return mZoomInButton.isEnabled(); |
| } |
| |
| boolean isZoomingRealSize() { |
| return mZoomRealSizeButton.getSelection(); |
| } |
| |
| /** |
| * Rescales canvas. |
| * @param direction +1 for zoom in, -1 for zoom out |
| */ |
| void rescale(int direction) { |
| LayoutCanvas canvas = mEditor.getCanvasControl(); |
| double s = canvas.getScale(); |
| |
| if (direction > 0) { |
| s = s * 1.2; |
| } else { |
| s = s / 1.2; |
| } |
| |
| // Some operations are faster if the zoom is EXACTLY 1.0 rather than ALMOST 1.0. |
| // (This is because there is a fast-path when image copying and the scale is 1.0; |
| // in that case it does not have to do any scaling). |
| // |
| // If you zoom out 10 times and then back in 10 times, small rounding errors mean |
| // that you end up with a scale=1.0000000000000004. In the cases, when you get close |
| // to 1.0, just make the zoom an exact 1.0. |
| if (Math.abs(s-1.0) < 0.0001) { |
| s = 1.0; |
| } |
| |
| canvas.setScale(s, true /*redraw*/); |
| } |
| |
| /** |
| * Reset the canvas scale to 100% |
| */ |
| void resetScale() { |
| mEditor.getCanvasControl().setScale(1, true /*redraw*/); |
| } |
| |
| /** |
| * Reset the canvas scale to best fit (so content is as large as possible without scrollbars) |
| */ |
| void rescaleToFit(boolean onlyZoomOut) { |
| mEditor.getCanvasControl().setFitScale(onlyZoomOut, true /*allowZoomIn*/); |
| } |
| |
| boolean rescaleToReal(boolean real) { |
| if (real) { |
| return computeAndSetRealScale(true /*redraw*/); |
| } else { |
| // reset the scale to 100% |
| mEditor.getCanvasControl().setScale(1, true /*redraw*/); |
| return true; |
| } |
| } |
| |
| boolean computeAndSetRealScale(boolean redraw) { |
| // compute average dpi of X and Y |
| ConfigurationChooser chooser = mEditor.getConfigurationChooser(); |
| Configuration config = chooser.getConfiguration(); |
| Device device = config.getDevice(); |
| Screen screen = device.getDefaultHardware().getScreen(); |
| double dpi = (screen.getXdpi() + screen.getYdpi()) / 2.; |
| |
| // get the monitor dpi |
| float monitor = AdtPrefs.getPrefs().getMonitorDensity(); |
| if (monitor == 0.f) { |
| ResolutionChooserDialog dialog = new ResolutionChooserDialog(chooser.getShell()); |
| if (dialog.open() == Window.OK) { |
| monitor = dialog.getDensity(); |
| AdtPrefs.getPrefs().setMonitorDensity(monitor); |
| } else { |
| return false; |
| } |
| } |
| |
| mEditor.getCanvasControl().setScale(monitor / dpi, redraw); |
| return true; |
| } |
| } |
