Java tutorial
/* * Copyright (C) 2009 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_LAYOUT_HEIGHT; import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH; import static com.android.SdkConstants.ATTR_TEXT; import static com.android.SdkConstants.VALUE_WRAP_CONTENT; import static com.android.SdkConstants.XMLNS_ANDROID; import static com.android.SdkConstants.XMLNS_URI; import com.android.ide.common.api.InsertType; import com.android.ide.common.api.Rect; import com.android.ide.common.api.RuleAction.Toggle; import com.android.ide.common.rendering.LayoutLibrary; import com.android.ide.common.rendering.api.Capability; import com.android.ide.common.rendering.api.LayoutLog; import com.android.ide.common.rendering.api.RenderSession; import com.android.ide.common.rendering.api.ViewInfo; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.editors.IconFactory; import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; import com.android.ide.eclipse.adt.internal.editors.descriptors.DocumentDescriptor; import com.android.ide.eclipse.adt.internal.editors.descriptors.ElementDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.CustomViewDescriptorService; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeFactory; import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; import com.android.ide.eclipse.adt.internal.editors.layout.gre.PaletteMetadataDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.gre.ViewMetadataRepository; import com.android.ide.eclipse.adt.internal.editors.layout.gre.ViewMetadataRepository.RenderMode; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.ide.eclipse.adt.internal.preferences.AdtPrefs; import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.sdklib.IAndroidTarget; import com.android.utils.Pair; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.action.Separator; import org.eclipse.jface.resource.ImageDescriptor; import org.eclipse.swt.SWT; import org.eclipse.swt.custom.CLabel; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.DragSource; import org.eclipse.swt.dnd.DragSourceEvent; import org.eclipse.swt.dnd.DragSourceListener; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.MenuDetectEvent; import org.eclipse.swt.events.MenuDetectListener; import org.eclipse.swt.events.MouseAdapter; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.MouseTrackListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.RGB; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Menu; import org.eclipse.swt.widgets.ToolBar; import org.eclipse.swt.widgets.ToolItem; import org.eclipse.wb.internal.core.editor.structure.IPage; import org.w3c.dom.Attr; import org.w3c.dom.Document; import org.w3c.dom.Element; import java.awt.image.BufferedImage; import java.io.IOException; import java.io.StringWriter; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; /** * A palette control for the {@link GraphicalEditorPart}. * <p/> * The palette contains several groups, each with a UI name (e.g. layouts and views) and each * with a list of element descriptors. * <p/> * * TODO list: * - The available items should depend on the actual GLE2 Canvas selection. Selected android * views should force filtering on what they accept can be dropped on them (e.g. TabHost, * TableLayout). Should enable/disable them, not hide them, to avoid shuffling around. * - Optional: a text filter * - Optional: have context-sensitive tools items, e.g. selection arrow tool, * group selection tool, alignment, etc. */ public class PaletteControl extends Composite { /** * Wrapper to create a {@link PaletteControl} */ static class PalettePage implements IPage { private final GraphicalEditorPart mEditorPart; private PaletteControl mControl; PalettePage(GraphicalEditorPart editor) { mEditorPart = editor; } @Override public void createControl(Composite parent) { mControl = new PaletteControl(parent, mEditorPart); } @Override public Control getControl() { return mControl; } @Override public void dispose() { mControl.dispose(); } @Override public void setToolBar(IToolBarManager toolBarManager) { } /** * Add tool bar items to the given toolbar * * @param toolbar the toolbar to add items into */ void createToolbarItems(final ToolBar toolbar) { final ToolItem popupMenuItem = new ToolItem(toolbar, SWT.PUSH); popupMenuItem.setToolTipText("View Menu"); popupMenuItem.setImage(IconFactory.getInstance().getIcon("view_menu")); popupMenuItem.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { Rectangle bounds = popupMenuItem.getBounds(); // Align menu horizontally with the toolbar button and // vertically with the bottom of the toolbar Point point = toolbar.toDisplay(bounds.x, bounds.y + bounds.height); mControl.showMenu(point.x, point.y); } }); } @Override public void setFocus() { mControl.setFocus(); } } /** * The parent grid layout that contains all the {@link Toggle} and * {@link IconTextItem} widgets. */ private GraphicalEditorPart mEditor; private Color mBackground; private Color mForeground; /** The palette modes control various ways to visualize and lay out the views */ private static enum PaletteMode { /** Show rendered previews of the views */ PREVIEW("Show Previews", true), /** Show rendered previews of the views, scaled down to 75% */ SMALL_PREVIEW("Show Small Previews", true), /** Show rendered previews of the views, scaled down to 50% */ TINY_PREVIEW("Show Tiny Previews", true), /** Show an icon + text label */ ICON_TEXT("Show Icon and Text", false), /** Show only icons, packed multiple per row */ ICON_ONLY("Show Only Icons", true); PaletteMode(String actionLabel, boolean wrap) { mActionLabel = actionLabel; mWrap = wrap; } public String getActionLabel() { return mActionLabel; } public boolean getWrap() { return mWrap; } public boolean isPreview() { return this == PREVIEW || this == SMALL_PREVIEW || this == TINY_PREVIEW; } public boolean isScaledPreview() { return this == SMALL_PREVIEW || this == TINY_PREVIEW; } private final String mActionLabel; private final boolean mWrap; }; /** Token used in preference string to record alphabetical sorting */ private static final String VALUE_ALPHABETICAL = "alpha"; //$NON-NLS-1$ /** Token used in preference string to record categories being turned off */ private static final String VALUE_NO_CATEGORIES = "nocat"; //$NON-NLS-1$ /** Token used in preference string to record auto close being turned off */ private static final String VALUE_NO_AUTOCLOSE = "noauto"; //$NON-NLS-1$ private final PreviewIconFactory mPreviewIconFactory = new PreviewIconFactory(this); private PaletteMode mPaletteMode = null; /** Use alphabetical sorting instead of natural order? */ private boolean mAlphabetical; /** Use categories instead of a single large list of views? */ private boolean mCategories = true; /** Auto-close the previous category when new categories are opened */ private boolean mAutoClose = true; private AccordionControl mAccordion; private String mCurrentTheme; private String mCurrentDevice; private IAndroidTarget mCurrentTarget; private AndroidTargetData mCurrentTargetData; /** * Create the composite. * @param parent The parent composite. * @param editor An editor associated with this palette. */ public PaletteControl(Composite parent, GraphicalEditorPart editor) { super(parent, SWT.NONE); mEditor = editor; } /** Reads UI mode from persistent store to preserve palette mode across IDE sessions */ private void loadPaletteMode() { String paletteModes = AdtPrefs.getPrefs().getPaletteModes(); if (paletteModes.length() > 0) { String[] tokens = paletteModes.split(","); //$NON-NLS-1$ try { mPaletteMode = PaletteMode.valueOf(tokens[0]); } catch (Throwable t) { mPaletteMode = PaletteMode.values()[0]; } mAlphabetical = paletteModes.contains(VALUE_ALPHABETICAL); mCategories = !paletteModes.contains(VALUE_NO_CATEGORIES); mAutoClose = !paletteModes.contains(VALUE_NO_AUTOCLOSE); } else { mPaletteMode = PaletteMode.SMALL_PREVIEW; } } /** * Returns the most recently stored version of auto-close-mode; this is the last * user-initiated setting of the auto-close mode (we programmatically switch modes when * you enter icons-only mode, and set it back to this when going to any other mode) */ private boolean getSavedAutoCloseMode() { return !AdtPrefs.getPrefs().getPaletteModes().contains(VALUE_NO_AUTOCLOSE); } /** Saves UI mode to persistent store to preserve palette mode across IDE sessions */ private void savePaletteMode() { StringBuilder sb = new StringBuilder(); sb.append(mPaletteMode); if (mAlphabetical) { sb.append(',').append(VALUE_ALPHABETICAL); } if (!mCategories) { sb.append(',').append(VALUE_NO_CATEGORIES); } if (!mAutoClose) { sb.append(',').append(VALUE_NO_AUTOCLOSE); } AdtPrefs.getPrefs().setPaletteModes(sb.toString()); } private void refreshPalette() { IAndroidTarget oldTarget = mCurrentTarget; mCurrentTarget = null; mCurrentTargetData = null; mCurrentTheme = null; mCurrentDevice = null; reloadPalette(oldTarget); } @Override protected void checkSubclass() { // Disable the check that prevents subclassing of SWT components } @Override public void dispose() { if (mBackground != null) { mBackground.dispose(); mBackground = null; } if (mForeground != null) { mForeground.dispose(); mForeground = null; } super.dispose(); } /** * Returns the currently displayed target * * @return the current target, or null */ public IAndroidTarget getCurrentTarget() { return mCurrentTarget; } /** * Returns the currently displayed theme (in palette modes that support previewing) * * @return the current theme, or null */ public String getCurrentTheme() { return mCurrentTheme; } /** * Returns the currently displayed device (in palette modes that support previewing) * * @return the current device, or null */ public String getCurrentDevice() { return mCurrentDevice; } /** Returns true if previews in the palette should be made available */ private boolean previewsAvailable() { // Not layoutlib 5 -- we require custom background support to do // a decent job with previews LayoutLibrary layoutLibrary = mEditor.getLayoutLibrary(); return layoutLibrary != null && layoutLibrary.supports(Capability.CUSTOM_BACKGROUND_COLOR); } /** * Loads or reloads the palette elements by using the layout and view descriptors from the * given target data. * * @param target The target that has just been loaded */ public void reloadPalette(IAndroidTarget target) { ConfigurationChooser configChooser = mEditor.getConfigurationChooser(); String theme = configChooser.getThemeName(); String device = configChooser.getDeviceName(); if (device == null) { return; } AndroidTargetData targetData = target != null ? Sdk.getCurrent().getTargetData(target) : null; if (target == mCurrentTarget && targetData == mCurrentTargetData && mCurrentTheme != null && mCurrentTheme.equals(theme) && mCurrentDevice != null && mCurrentDevice.equals(device)) { return; } mCurrentTheme = theme; mCurrentTarget = target; mCurrentTargetData = targetData; mCurrentDevice = device; mPreviewIconFactory.reset(); if (targetData == null) { return; } Set<String> expandedCategories = null; if (mAccordion != null) { expandedCategories = mAccordion.getExpandedCategories(); // We auto-expand all categories when showing icons-only. When returning to some // other mode we don't want to retain all categories open. if (expandedCategories.size() > 3) { expandedCategories = null; } } // Erase old content and recreate new for (Control c : getChildren()) { c.dispose(); } if (mPaletteMode == null) { loadPaletteMode(); assert mPaletteMode != null; } // Ensure that the palette mode is supported on this version of the layout library if (!previewsAvailable()) { if (mPaletteMode.isPreview()) { mPaletteMode = PaletteMode.ICON_TEXT; } } if (mPaletteMode.isPreview()) { if (mForeground != null) { mForeground.dispose(); mForeground = null; } if (mBackground != null) { mBackground.dispose(); mBackground = null; } RGB background = mPreviewIconFactory.getBackgroundColor(); if (background != null) { mBackground = new Color(getDisplay(), background); } RGB foreground = mPreviewIconFactory.getForegroundColor(); if (foreground != null) { mForeground = new Color(getDisplay(), foreground); } } List<String> headers = Collections.emptyList(); final Map<String, List<ViewElementDescriptor>> categoryToItems; categoryToItems = new HashMap<String, List<ViewElementDescriptor>>(); headers = new ArrayList<String>(); List<Pair<String, List<ViewElementDescriptor>>> paletteEntries = ViewMetadataRepository.get() .getPaletteEntries(targetData, mAlphabetical, mCategories); for (Pair<String, List<ViewElementDescriptor>> pair : paletteEntries) { String category = pair.getFirst(); List<ViewElementDescriptor> categoryItems = pair.getSecond(); headers.add(category); categoryToItems.put(category, categoryItems); } headers.add("Custom & Library Views"); // Set the categories to expand the first item if // (1) we don't have a previously selected category, or // (2) there's just one category anyway, or // (3) the set of categories have changed so our previously selected category // doesn't exist anymore (can happen when you toggle "Show Categories") if ((expandedCategories == null && headers.size() > 0) || headers.size() == 1 || (expandedCategories != null && expandedCategories.size() >= 1 && !headers.contains(expandedCategories.iterator().next().replace("&&", "&")))) { //$NON-NLS-1$ //$NON-NLS-2$ // Expand the first category if we don't have a previous selection (e.g. refresh) expandedCategories = Collections.singleton(headers.get(0)); } boolean wrap = mPaletteMode.getWrap(); // Pack icon-only view vertically; others stretch to fill palette region boolean fillVertical = mPaletteMode != PaletteMode.ICON_ONLY; mAccordion = new AccordionControl(this, SWT.NONE, headers, fillVertical, wrap, expandedCategories) { @Override protected Composite createChildContainer(Composite parent, Object header, int style) { assert categoryToItems != null; List<ViewElementDescriptor> list = categoryToItems.get(header); final Composite composite; if (list == null) { assert header.equals("Custom & Library Views"); Composite wrapper = new Composite(parent, SWT.NONE); GridLayout gridLayout = new GridLayout(1, false); gridLayout.marginWidth = gridLayout.marginHeight = 0; gridLayout.horizontalSpacing = gridLayout.verticalSpacing = 0; gridLayout.marginBottom = 3; wrapper.setLayout(gridLayout); if (mPaletteMode.isPreview() && mBackground != null) { wrapper.setBackground(mBackground); } composite = super.createChildContainer(wrapper, header, style); if (mPaletteMode.isPreview() && mBackground != null) { composite.setBackground(mBackground); } composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1)); Button refreshButton = new Button(wrapper, SWT.PUSH | SWT.FLAT); refreshButton.setLayoutData(new GridData(SWT.CENTER, SWT.CENTER, false, false, 1, 1)); refreshButton.setText("Refresh"); refreshButton.setImage(IconFactory.getInstance().getIcon("refresh")); //$NON-NLS-1$ refreshButton.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { CustomViewFinder finder = CustomViewFinder.get(mEditor.getProject()); finder.refresh(new ViewFinderListener(composite)); } }); wrapper.layout(true); } else { composite = super.createChildContainer(parent, header, style); if (mPaletteMode.isPreview() && mBackground != null) { composite.setBackground(mBackground); } } addMenu(composite); return composite; } @Override protected void createChildren(Composite parent, Object header) { assert categoryToItems != null; List<ViewElementDescriptor> list = categoryToItems.get(header); if (list == null) { assert header.equals("Custom & Library Views"); addCustomItems(parent); return; } else { for (ViewElementDescriptor desc : list) { createItem(parent, desc); } } } }; addMenu(mAccordion); for (CLabel headerLabel : mAccordion.getHeaderLabels()) { addMenu(headerLabel); } setLayout(new FillLayout()); // Expand All for icon-only mode, but don't store it as the persistent auto-close mode; // when we enter other modes it will read back whatever persistent mode. if (mPaletteMode == PaletteMode.ICON_ONLY) { mAccordion.expandAll(true); mAccordion.setAutoClose(false); } else { mAccordion.setAutoClose(getSavedAutoCloseMode()); } layout(true); } protected void addCustomItems(final Composite parent) { final CustomViewFinder finder = CustomViewFinder.get(mEditor.getProject()); Collection<String> allViews = finder.getAllViews(); if (allViews == null) { // Not yet initialized: trigger an async refresh finder.refresh(new ViewFinderListener(parent)); return; } // Remove previous content for (Control c : parent.getChildren()) { c.dispose(); } // Add new views for (final String fqcn : allViews) { CustomViewDescriptorService service = CustomViewDescriptorService.getInstance(); ViewElementDescriptor desc = service.getDescriptor(mEditor.getProject(), fqcn); if (desc == null) { // The descriptor lookup performs validation steps of the class, and may // in some cases determine that this is not a view and will return null; // guard against that. continue; } Control item = createItem(parent, desc); // Add control-click listener on custom view items to you can warp to // (and double click listener too -- the more discoverable, the better.) if (item instanceof IconTextItem) { IconTextItem it = (IconTextItem) item; it.addMouseListener(new MouseAdapter() { @Override public void mouseDoubleClick(MouseEvent e) { AdtPlugin.openJavaClass(mEditor.getProject(), fqcn); } @Override public void mouseDown(MouseEvent e) { if ((e.stateMask & SWT.MOD1) != 0) { AdtPlugin.openJavaClass(mEditor.getProject(), fqcn); } } }); } } } /* package */ GraphicalEditorPart getEditor() { return mEditor; } private Control createItem(Composite parent, ViewElementDescriptor desc) { Control item = null; switch (mPaletteMode) { case SMALL_PREVIEW: case TINY_PREVIEW: case PREVIEW: { ImageDescriptor descriptor = mPreviewIconFactory.getImageDescriptor(desc); if (descriptor != null) { Image image = descriptor.createImage(); ImageControl imageControl = new ImageControl(parent, SWT.None, image); if (mPaletteMode.isScaledPreview()) { // Try to preserve the overall size since rendering sizes typically // vary with the dpi - so while the scaling factor for a 160 dpi // rendering the scaling factor should be 0.5, for a 320 dpi one the // scaling factor should be half that, 0.25. float scale = 1.0f; if (mPaletteMode == PaletteMode.SMALL_PREVIEW) { scale = 0.75f; } else if (mPaletteMode == PaletteMode.TINY_PREVIEW) { scale = 0.5f; } ConfigurationChooser chooser = mEditor.getConfigurationChooser(); int dpi = chooser.getConfiguration().getDensity().getDpiValue(); while (dpi > 160) { scale = scale / 2; dpi = dpi / 2; } imageControl.setScale(scale); } imageControl.setHoverColor(getDisplay().getSystemColor(SWT.COLOR_WHITE)); if (mBackground != null) { imageControl.setBackground(mBackground); } String toolTip = desc.getUiName(); // It appears pretty much none of the descriptors have tooltips //String descToolTip = desc.getTooltip(); //if (descToolTip != null && descToolTip.length() > 0) { // toolTip = toolTip + "\n" + descToolTip; //} imageControl.setToolTipText(toolTip); item = imageControl; } else { // Just use an Icon+Text item for these for now item = new IconTextItem(parent, desc); if (mForeground != null) { item.setForeground(mForeground); item.setBackground(mBackground); } } break; } case ICON_TEXT: { item = new IconTextItem(parent, desc); break; } case ICON_ONLY: { item = new ImageControl(parent, SWT.None, desc.getGenericIcon()); item.setToolTipText(desc.getUiName()); break; } default: throw new IllegalArgumentException("Not yet implemented"); } final DragSource source = new DragSource(item, DND.DROP_COPY); source.setTransfer(new Transfer[] { SimpleXmlTransfer.getInstance() }); source.addDragListener(new DescDragSourceListener(desc)); item.addDisposeListener(new DisposeListener() { @Override public void widgetDisposed(DisposeEvent e) { source.dispose(); } }); addMenu(item); return item; } /** * An Item widget represents one {@link ElementDescriptor} that can be dropped on the * GLE2 canvas using drag'n'drop. */ private static class IconTextItem extends CLabel implements MouseTrackListener { private boolean mMouseIn; public IconTextItem(Composite parent, ViewElementDescriptor desc) { super(parent, SWT.NONE); mMouseIn = false; setText(desc.getUiName()); setImage(desc.getGenericIcon()); setToolTipText(desc.getTooltip()); addMouseTrackListener(this); } @Override public int getStyle() { int style = super.getStyle(); if (mMouseIn) { style |= SWT.SHADOW_IN; } return style; } @Override public void mouseEnter(MouseEvent e) { if (!mMouseIn) { mMouseIn = true; redraw(); } } @Override public void mouseExit(MouseEvent e) { if (mMouseIn) { mMouseIn = false; redraw(); } } @Override public void mouseHover(MouseEvent e) { // pass } } /** * A {@link DragSourceListener} that deals with drag'n'drop of * {@link ElementDescriptor}s. */ private class DescDragSourceListener implements DragSourceListener { private final ViewElementDescriptor mDesc; private SimpleElement[] mElements; public DescDragSourceListener(ViewElementDescriptor desc) { mDesc = desc; } @Override public void dragStart(DragSourceEvent e) { // See if we can find out the bounds of this element from a preview image. // Preview images are created before the drag source listener is notified // of the started drag. Rect bounds = null; Rect dragBounds = null; createDragImage(e); if (mImage != null && !mIsPlaceholder) { int width = mImageLayoutBounds.width; int height = mImageLayoutBounds.height; assert mImageLayoutBounds.x == 0; assert mImageLayoutBounds.y == 0; bounds = new Rect(0, 0, width, height); double scale = mEditor.getCanvasControl().getScale(); int scaledWidth = (int) (scale * width); int scaledHeight = (int) (scale * height); int x = -scaledWidth / 2; int y = -scaledHeight / 2; dragBounds = new Rect(x, y, scaledWidth, scaledHeight); } SimpleElement se = new SimpleElement(SimpleXmlTransfer.getFqcn(mDesc), null /* parentFqcn */, bounds /* bounds */, null /* parentBounds */); if (mDesc instanceof PaletteMetadataDescriptor) { PaletteMetadataDescriptor pm = (PaletteMetadataDescriptor) mDesc; pm.initializeNew(se); } mElements = new SimpleElement[] { se }; // Register this as the current dragged data GlobalCanvasDragInfo dragInfo = GlobalCanvasDragInfo.getInstance(); dragInfo.startDrag(mElements, null /* selection */, null /* canvas */, null /* removeSource */); dragInfo.setDragBounds(dragBounds); dragInfo.setDragBaseline(mBaseline); e.doit = true; } @Override public void dragSetData(DragSourceEvent e) { // Provide the data for the drop when requested by the other side. if (SimpleXmlTransfer.getInstance().isSupportedType(e.dataType)) { e.data = mElements; } } @Override public void dragFinished(DragSourceEvent e) { // Unregister the dragged data. GlobalCanvasDragInfo.getInstance().stopDrag(); mElements = null; if (mImage != null) { mImage.dispose(); mImage = null; } } // TODO: Figure out the right dimensions to use for rendering. // We WILL crop this after rendering, but for performance reasons it would be good // not to make it much larger than necessary since to crop this we rely on // actually scanning pixels. /** * Width of the rendered preview image (before it is cropped), although the actual * width may be smaller (since we also take the device screen's size into account) */ private static final int MAX_RENDER_HEIGHT = 400; /** * Height of the rendered preview image (before it is cropped), although the * actual width may be smaller (since we also take the device screen's size into * account) */ private static final int MAX_RENDER_WIDTH = 500; /** Amount of alpha to multiply into the image (divided by 256) */ private static final int IMG_ALPHA = 128; /** The image shown during the drag */ private Image mImage; /** The non-effect bounds of the drag image */ private Rectangle mImageLayoutBounds; private int mBaseline = -1; /** * If true, the image is a preview of the view, and if not it is a "fallback" * image of some sort, such as a rendering of the palette item itself */ private boolean mIsPlaceholder; private void createDragImage(DragSourceEvent event) { mBaseline = -1; Pair<Image, Rectangle> preview = renderPreview(); if (preview != null) { mImage = preview.getFirst(); mImageLayoutBounds = preview.getSecond(); } else { mImage = null; mImageLayoutBounds = null; } mIsPlaceholder = mImage == null; if (mIsPlaceholder) { // Couldn't render preview (or the preview is a blank image, such as for // example the preview of an empty layout), so instead create a placeholder // image // Render the palette item itself as an image Control control = ((DragSource) event.widget).getControl(); GC gc = new GC(control); Point size = control.getSize(); Display display = getDisplay(); final Image image = new Image(display, size.x, size.y); gc.copyArea(image, 0, 0); gc.dispose(); BufferedImage awtImage = SwtUtils.convertToAwt(image); if (awtImage != null) { awtImage = ImageUtils.createDropShadow(awtImage, 3 /* shadowSize */, 0.7f /* shadowAlpha */, 0x000000 /* shadowRgb */); mImage = SwtUtils.convertToSwt(display, awtImage, true, IMG_ALPHA); } else { ImageData data = image.getImageData(); data.alpha = IMG_ALPHA; // Changing the ImageData -after- constructing an image on it // has no effect, so we have to construct a new image. Luckily these // are tiny images. mImage = new Image(display, data); } image.dispose(); } event.image = mImage; if (!mIsPlaceholder) { // Shift the drag feedback image up such that it's centered under the // mouse pointer double scale = mEditor.getCanvasControl().getScale(); event.offsetX = (int) (scale * mImageLayoutBounds.width / 2); event.offsetY = (int) (scale * mImageLayoutBounds.height / 2); } } /** * Performs the actual rendering of the descriptor into an image and returns the * image as well as the layout bounds of the image (not including drop shadow etc) */ private Pair<Image, Rectangle> renderPreview() { ViewMetadataRepository repository = ViewMetadataRepository.get(); RenderMode renderMode = repository.getRenderMode(mDesc.getFullClassName()); if (renderMode == RenderMode.SKIP) { return null; } // Create blank XML document Document document = DomUtilities.createEmptyDocument(); // Insert our target view's XML into it as a node GraphicalEditorPart editor = getEditor(); LayoutEditorDelegate layoutEditorDelegate = editor.getEditorDelegate(); String viewName = mDesc.getXmlLocalName(); Element element = document.createElement(viewName); // Set up a proper name space Attr attr = document.createAttributeNS(XMLNS_URI, XMLNS_ANDROID); attr.setValue(ANDROID_URI); element.getAttributes().setNamedItemNS(attr); element.setAttributeNS(ANDROID_URI, ATTR_LAYOUT_WIDTH, VALUE_WRAP_CONTENT); element.setAttributeNS(ANDROID_URI, ATTR_LAYOUT_HEIGHT, VALUE_WRAP_CONTENT); // This doesn't apply to all, but doesn't seem to cause harm and makes for a // better experience with text-oriented views like buttons and texts element.setAttributeNS(ANDROID_URI, ATTR_TEXT, DescriptorsUtils.getBasename(mDesc.getUiName())); // Is this a palette variation? if (mDesc instanceof PaletteMetadataDescriptor) { PaletteMetadataDescriptor pm = (PaletteMetadataDescriptor) mDesc; pm.initializeNew(element); } document.appendChild(element); // Construct UI model from XML AndroidTargetData data = layoutEditorDelegate.getEditor().getTargetData(); DocumentDescriptor documentDescriptor; if (data == null) { documentDescriptor = new DocumentDescriptor("temp", null/*children*/);//$NON-NLS-1$ } else { documentDescriptor = data.getLayoutDescriptors().getDescriptor(); } UiDocumentNode model = (UiDocumentNode) documentDescriptor.createUiNode(); model.setEditor(layoutEditorDelegate.getEditor()); model.setUnknownDescriptorProvider(editor.getModel().getUnknownDescriptorProvider()); model.loadFromXmlNode(document); // Call the create-hooks such that we for example insert mandatory // children into views like the DialerFilter, apply image source attributes // to ImageButtons, etc. LayoutCanvas canvas = editor.getCanvasControl(); NodeFactory nodeFactory = canvas.getNodeFactory(); UiElementNode parent = model.getUiRoot(); UiElementNode child = parent.getUiChildren().get(0); if (child instanceof UiViewElementNode) { UiViewElementNode childUiNode = (UiViewElementNode) child; NodeProxy childNode = nodeFactory.create(childUiNode); // Applying create hooks as part of palette render should // not trigger model updates layoutEditorDelegate.getEditor().setIgnoreXmlUpdate(true); try { canvas.getRulesEngine().callCreateHooks(layoutEditorDelegate.getEditor(), null, childNode, InsertType.CREATE_PREVIEW); childNode.applyPendingChanges(); } catch (Throwable t) { AdtPlugin.log(t, "Failed calling creation hooks for widget %1$s", viewName); } finally { layoutEditorDelegate.getEditor().setIgnoreXmlUpdate(false); } } Integer overrideBgColor = null; boolean hasTransparency = false; LayoutLibrary layoutLibrary = editor.getLayoutLibrary(); if (layoutLibrary != null && layoutLibrary.supports(Capability.CUSTOM_BACKGROUND_COLOR)) { // It doesn't matter what the background color is as long as the alpha // is 0 (fully transparent). We're using red to make it more obvious if // for some reason the background is painted when it shouldn't be. overrideBgColor = new Integer(0x00FF0000); } RenderSession session = null; try { // Use at most the size of the screen for the preview render. // This is important since when we fill the size of certain views (like // a SeekBar), we want it to at most be the width of the screen, and for small // screens the RENDER_WIDTH was wider. LayoutLog silentLogger = new LayoutLog(); session = RenderService.create(editor).setModel(model) .setMaxRenderSize(MAX_RENDER_WIDTH, MAX_RENDER_HEIGHT).setLog(silentLogger) .setOverrideBgColor(overrideBgColor).setDecorations(false).createRenderSession(); } catch (Throwable t) { // Previews can fail for a variety of reasons -- let's not bug // the user with it return null; } if (session != null) { if (session.getResult().isSuccess()) { BufferedImage image = session.getImage(); if (image != null) { BufferedImage cropped; Rect initialCrop = null; ViewInfo viewInfo = null; List<ViewInfo> viewInfoList = session.getRootViews(); if (viewInfoList != null && viewInfoList.size() > 0) { viewInfo = viewInfoList.get(0); mBaseline = viewInfo.getBaseLine(); } if (viewInfo != null) { int x1 = viewInfo.getLeft(); int x2 = viewInfo.getRight(); int y2 = viewInfo.getBottom(); int y1 = viewInfo.getTop(); initialCrop = new Rect(x1, y1, x2 - x1, y2 - y1); } if (hasTransparency) { cropped = ImageUtils.cropBlank(image, initialCrop); } else { // Find out what the "background" color is such that we can properly // crop it out of the image. To do this we pick out a pixel in the // bottom right unpainted area. Rather than pick the one in the far // bottom corner, we pick one as close to the bounds of the view as // possible (but still outside of the bounds), such that we can // deal with themes like the dialog theme. int edgeX = image.getWidth() - 1; int edgeY = image.getHeight() - 1; if (viewInfo != null) { if (viewInfo.getRight() < image.getWidth() - 1) { edgeX = viewInfo.getRight() + 1; } if (viewInfo.getBottom() < image.getHeight() - 1) { edgeY = viewInfo.getBottom() + 1; } } int edgeColor = image.getRGB(edgeX, edgeY); cropped = ImageUtils.cropColor(image, edgeColor, initialCrop); } if (cropped != null) { int width = initialCrop != null ? initialCrop.w : cropped.getWidth(); int height = initialCrop != null ? initialCrop.h : cropped.getHeight(); boolean needsContrast = hasTransparency && !ImageUtils.containsDarkPixels(cropped); cropped = ImageUtils.createDropShadow(cropped, hasTransparency ? 3 : 5 /* shadowSize */, !hasTransparency ? 0.6f : needsContrast ? 0.8f : 0.7f/*alpha*/, 0x000000 /* shadowRgb */); double scale = canvas.getScale(); if (scale != 1L) { cropped = ImageUtils.scale(cropped, scale, scale); } Display display = getDisplay(); int alpha = (!hasTransparency || !needsContrast) ? IMG_ALPHA : -1; Image swtImage = SwtUtils.convertToSwt(display, cropped, true, alpha); Rectangle imageBounds = new Rectangle(0, 0, width, height); return Pair.of(swtImage, imageBounds); } } } session.dispose(); } return null; } /** * Utility method to print out the contents of the given XML document. This is * really useful when working on the preview code above. I'm including all the * code inside a constant false, which means the compiler will omit all the code, * but I'd like to leave it in the code base and by doing it this way rather than * as commented out code the code won't be accidentally broken. */ @SuppressWarnings("all") private void dumpDocument(Document document) { // Diagnostics: print out the XML that we're about to render if (false) { // Will be omitted by the compiler org.apache.xml.serialize.OutputFormat outputFormat = new org.apache.xml.serialize.OutputFormat( "XML", "ISO-8859-1", true); //$NON-NLS-1$ //$NON-NLS-2$ outputFormat.setIndent(2); outputFormat.setLineWidth(100); outputFormat.setIndenting(true); outputFormat.setOmitXMLDeclaration(true); outputFormat.setOmitDocumentType(true); StringWriter stringWriter = new StringWriter(); // Using FQN here to avoid having an import above, which will result // in a deprecation warning, and there isn't a way to annotate a single // import element with a SuppressWarnings. org.apache.xml.serialize.XMLSerializer serializer = new org.apache.xml.serialize.XMLSerializer( stringWriter, outputFormat); serializer.setNamespaces(true); try { serializer.serialize(document.getDocumentElement()); System.out.println(stringWriter.toString()); } catch (IOException e) { e.printStackTrace(); } } } } /** Action for switching view modes via radio buttons */ private class PaletteModeAction extends Action { private final PaletteMode mMode; PaletteModeAction(PaletteMode mode) { super(mode.getActionLabel(), IAction.AS_RADIO_BUTTON); mMode = mode; boolean selected = mMode == mPaletteMode; setChecked(selected); setEnabled(!selected); } @Override public void run() { if (isEnabled()) { mPaletteMode = mMode; refreshPalette(); savePaletteMode(); } } } /** Action for toggling various checkbox view modes - categories, sorting, etc */ private class ToggleViewOptionAction extends Action { private final int mAction; final static int TOGGLE_CATEGORY = 1; final static int TOGGLE_ALPHABETICAL = 2; final static int TOGGLE_AUTO_CLOSE = 3; final static int REFRESH = 4; final static int RESET = 5; ToggleViewOptionAction(String title, int action, boolean checked) { super(title, (action == REFRESH || action == RESET) ? IAction.AS_PUSH_BUTTON : IAction.AS_CHECK_BOX); mAction = action; if (checked) { setChecked(checked); } } @Override public void run() { switch (mAction) { case TOGGLE_CATEGORY: mCategories = !mCategories; refreshPalette(); break; case TOGGLE_ALPHABETICAL: mAlphabetical = !mAlphabetical; refreshPalette(); break; case TOGGLE_AUTO_CLOSE: mAutoClose = !mAutoClose; mAccordion.setAutoClose(mAutoClose); break; case REFRESH: mPreviewIconFactory.refresh(); refreshPalette(); break; case RESET: mAlphabetical = false; mCategories = true; mAutoClose = true; mPaletteMode = PaletteMode.SMALL_PREVIEW; refreshPalette(); break; } savePaletteMode(); } } private void addMenu(Control control) { control.addMenuDetectListener(new MenuDetectListener() { @Override public void menuDetected(MenuDetectEvent e) { showMenu(e.x, e.y); } }); } private void showMenu(int x, int y) { MenuManager manager = new MenuManager() { @Override public boolean isDynamic() { return true; } }; boolean previews = previewsAvailable(); for (PaletteMode mode : PaletteMode.values()) { if (mode.isPreview() && !previews) { continue; } manager.add(new PaletteModeAction(mode)); } if (mPaletteMode.isPreview()) { manager.add(new Separator()); manager.add(new ToggleViewOptionAction("Refresh Previews", ToggleViewOptionAction.REFRESH, false)); } manager.add(new Separator()); manager.add( new ToggleViewOptionAction("Show Categories", ToggleViewOptionAction.TOGGLE_CATEGORY, mCategories)); manager.add(new ToggleViewOptionAction("Sort Alphabetically", ToggleViewOptionAction.TOGGLE_ALPHABETICAL, mAlphabetical)); manager.add(new Separator()); manager.add(new ToggleViewOptionAction("Auto Close Previous", ToggleViewOptionAction.TOGGLE_AUTO_CLOSE, mAutoClose)); manager.add(new Separator()); manager.add(new ToggleViewOptionAction("Reset", ToggleViewOptionAction.RESET, false)); Menu menu = manager.createContextMenu(PaletteControl.this); menu.setLocation(x, y); menu.setVisible(true); } private final class ViewFinderListener implements CustomViewFinder.Listener { private final Composite mParent; private ViewFinderListener(Composite parent) { mParent = parent; } @Override public void viewsUpdated(Collection<String> customViews, Collection<String> thirdPartyViews) { addCustomItems(mParent); mParent.layout(true); } } }