| /****************************************************************************** |
| * Copyright (c) 2002, 2009 IBM Corporation and others. |
| * 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 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| ****************************************************************************/ |
| |
| package org.eclipse.gmf.runtime.diagram.ui.editparts; |
| |
| |
| import org.eclipse.draw2d.FreeformLayer; |
| import org.eclipse.draw2d.FreeformLayeredPane; |
| import org.eclipse.draw2d.Graphics; |
| import org.eclipse.draw2d.LayeredPane; |
| import org.eclipse.draw2d.ScalableFigure; |
| import org.eclipse.draw2d.ScalableFreeformLayeredPane; |
| import org.eclipse.draw2d.Viewport; |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.draw2d.geometry.Translatable; |
| import org.eclipse.gef.Request; |
| import org.eclipse.gef.SnapToGeometry; |
| import org.eclipse.gef.SnapToGrid; |
| import org.eclipse.gef.editparts.GridLayer; |
| import org.eclipse.gef.editparts.ScalableFreeformRootEditPart; |
| import org.eclipse.gef.editparts.ZoomListener; |
| import org.eclipse.gef.editparts.ZoomManager; |
| import org.eclipse.gef.rulers.RulerProvider; |
| import org.eclipse.gmf.runtime.common.core.util.Log; |
| import org.eclipse.gmf.runtime.common.ui.util.DisplayUtils; |
| import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; |
| import org.eclipse.gmf.runtime.diagram.ui.figures.BorderItemsAwareFreeFormLayer; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIPlugin; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIStatusCodes; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.GridLayerEx; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.PageBreakEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.figures.PageBreaksFigure; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.pagesetup.PageInfoHelper; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.properties.WorkspaceViewerProperties; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.ruler.DiagramRuler; |
| import org.eclipse.gmf.runtime.diagram.ui.l10n.DiagramColorRegistry; |
| import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramGraphicalViewer; |
| import org.eclipse.gmf.runtime.diagram.ui.preferences.IPreferenceConstants; |
| import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; |
| import org.eclipse.gmf.runtime.diagram.ui.util.MeasurementUnitHelper; |
| import org.eclipse.gmf.runtime.draw2d.ui.internal.figures.ConnectionLayerEx; |
| import org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.MapModeGraphics; |
| import org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScaledGraphics; |
| import org.eclipse.gmf.runtime.draw2d.ui.internal.mapmode.IMapModeHolder; |
| import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode; |
| import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeTypes; |
| import org.eclipse.gmf.runtime.draw2d.ui.render.internal.graphics.RenderedMapModeGraphics; |
| import org.eclipse.gmf.runtime.draw2d.ui.render.internal.graphics.RenderedScaledGraphics; |
| import org.eclipse.gmf.runtime.gef.ui.internal.editparts.AnimatableZoomManager; |
| import org.eclipse.gmf.runtime.notation.MeasurementUnit; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.util.IPropertyChangeListener; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.graphics.Color; |
| |
| /** |
| * RootEditPart which manages the Diagram's layers and creates the discrete zoom |
| * levels for the <code>ZoomManager</code>. |
| * |
| * @author jcorchis |
| */ |
| public class DiagramRootEditPart |
| extends ScalableFreeformRootEditPart |
| implements ZoomableEditPart, IDiagramPreferenceSupport { |
| |
| private WrapperMapMode mm; |
| |
| /** |
| * @author sshaw |
| * This pattern is necessary because, the constructor of the ScalableFreeformRootEditPart forces |
| * the scalable layered pane class to be instantiated where it gets initialized with the MapMode |
| * of the this root editpart. However, we haven't had a chance to initialize the mapmode value yet since |
| * super must be called first. So, this pattern allows us to set the mapmode into this container after |
| * super is called, but still have the scalable layered pane initialized with the mapmode value. |
| */ |
| private class WrapperMapMode implements IMapModeHolder { |
| |
| public WrapperMapMode() { |
| super(); |
| } |
| |
| IMapMode containedMM = MapModeTypes.DEFAULT_MM; |
| public void setContainedMapMode(IMapMode mm) { |
| this.containedMM = mm; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode#DPtoLP(int) |
| */ |
| public int DPtoLP(int deviceUnit) { |
| return containedMM.DPtoLP(deviceUnit); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode#DPtoLP(org.eclipse.draw2d.geometry.Translatable) |
| */ |
| public Translatable DPtoLP(Translatable t) { |
| return containedMM.DPtoLP(t); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode#LPtoDP(int) |
| */ |
| public int LPtoDP(int logicalUnit) { |
| return containedMM.LPtoDP(logicalUnit); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode#LPtoDP(org.eclipse.draw2d.geometry.Translatable) |
| */ |
| public Translatable LPtoDP(Translatable t) { |
| return containedMM.LPtoDP(t); |
| } |
| |
| public IMapMode getMapMode() { |
| return containedMM; |
| } |
| |
| } |
| |
| /** |
| * Default constructor |
| */ |
| public DiagramRootEditPart() { |
| super(); |
| } |
| |
| /** |
| * @param mu the <code>MeasurementUnit</code> that is used to display all contents |
| * within the root edit part. |
| */ |
| public DiagramRootEditPart(MeasurementUnit mu) { |
| super(); |
| |
| if (getMapMode() != null) |
| mm.setContainedMapMode(MeasurementUnitHelper.getMapMode(mu)); |
| } |
| |
| /** |
| * GEF does not scale the FEEDBACK_LAYER but we do. |
| */ |
| class FeedbackLayer |
| extends FreeformLayer |
| { |
| FeedbackLayer() { |
| setEnabled(false); |
| } |
| } |
| |
| /** |
| * Listener for the workspace preference store. |
| */ |
| private class PreferenceStoreListener implements IPropertyChangeListener { |
| public void propertyChange(org.eclipse.jface.util.PropertyChangeEvent event) { |
| handlePreferenceStorePropertyChanged(event); |
| } |
| } |
| |
| static protected class DiagramScalableFreeformLayeredPane extends |
| org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScalableFreeformLayeredPane implements ZoomListener { |
| |
| private static final Dimension MAX_RENDERED_IMAGE_SIZE = new Dimension(1000, 1000); |
| |
| public DiagramScalableFreeformLayeredPane(IMapMode mm) { |
| super(mm); |
| } |
| |
| /** |
| * @since 1.3 |
| */ |
| protected MapModeGraphics createMapModeGraphics(Graphics graphics) { |
| return new RenderedMapModeGraphics(graphics, getMapMode(), true, MAX_RENDERED_IMAGE_SIZE); |
| } |
| |
| /** |
| * @since 1.3 |
| */ |
| protected ScaledGraphics createScaledGraphics(MapModeGraphics gmm) { |
| return new RenderedScaledGraphics(gmm, true, MAX_RENDERED_IMAGE_SIZE); |
| } |
| |
| /* |
| * (non-Javadoc) |
| * @see org.eclipse.gef.editparts.ZoomListener#zoomChanged(double) |
| */ |
| public void zoomChanged(double zoom) { |
| ScaledGraphics.resetFontCache(); |
| } |
| } |
| |
| private DiagramRuler verticalRuler, horizontalRuler; |
| private AnimatableZoomManager zoomManager; |
| private double[] zoomLevels = {.05, .1, .25, .5, .75, 1, 1.25, 1.5, 1.75, 2, 4}; |
| private PageBreakEditPart pageBreakEditPart; |
| private PreferenceStoreListener listener = new PreferenceStoreListener(); |
| |
| /* Keep layers to enable anti-aliasing */ |
| private ScalableFreeformLayeredPane layers; |
| |
| /** |
| * The hint used to find the appropriate preference store from which general |
| * diagramming preference values for properties of shapes, connections, and |
| * diagrams can be retrieved. This hint is mapped to a preference store in |
| * the {@link DiagramPreferencesRegistry}. |
| */ |
| private PreferencesHint preferencesHint = PreferencesHint.USE_DEFAULTS; |
| private int printableLayerIndex; |
| private GridLayer gridLayer; |
| |
| /** |
| * Initializes the preferenceStore property change |
| * listener. |
| */ |
| private void initPreferenceStoreListener() { |
| IPreferenceStore preferenceStore = |
| (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| preferenceStore.addPropertyChangeListener(listener); |
| } |
| |
| /** |
| * This method removes all listeners to the notational world (views, figures, editpart...etc) |
| * Override this method to remove notational listeners down the hierarchy |
| */ |
| private void removePreferenceStoreListener() { |
| // remove preferenceStore listener |
| IPreferenceStore preferenceStore = |
| (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| preferenceStore.removePropertyChangeListener(listener); |
| listener = null; |
| } |
| |
| /** |
| * Identifies the layer containing the page breaks figure. |
| */ |
| final public static String PAGE_BREAKS_LAYER = "Page Breaks Layer"; //$NON-NLS-1$ |
| |
| /** |
| * Identifies the layers containing printable decoration layer. |
| */ |
| final public static String DECORATION_PRINTABLE_LAYER = "Decoration Printable Layer"; //$NON-NLS-1$ |
| /** |
| * Identifies the layers containing Unprintable decoration layer. |
| */ |
| final public static String DECORATION_UNPRINTABLE_LAYER = "Decoration Unprintable Layer"; //$NON-NLS-1$ |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gef.ui.parts.FreeformGraphicalRootEditPart#createPrintableLayers() |
| */ |
| protected LayeredPane createPrintableLayers() { |
| FreeformLayeredPane layeredPane = new FreeformLayeredPane(); |
| |
| layeredPane.add(new BorderItemsAwareFreeFormLayer(), PRIMARY_LAYER); |
| layeredPane.add(new ConnectionLayerEx(), CONNECTION_LAYER); |
| layeredPane.add(new FreeformLayer(), DECORATION_PRINTABLE_LAYER); |
| |
| return layeredPane; |
| } |
| |
| protected void moveGridLayer(boolean inFront) { |
| if (layers.getChildren().indexOf(gridLayer) > printableLayerIndex && (! inFront)) { |
| layers.remove(gridLayer); |
| layers.add(gridLayer,GRID_LAYER, printableLayerIndex); |
| } else if (layers.getChildren().indexOf(gridLayer) <= printableLayerIndex && inFront) { |
| layers.remove(gridLayer); |
| layers.add(gridLayer,GRID_LAYER, printableLayerIndex+1); |
| } |
| } |
| |
| /** |
| * Creates and returns the scalable layers of this EditPart |
| * |
| * @return ScalableFreeformLayeredPane Pane that contains the scalable layers |
| */ |
| protected ScalableFreeformLayeredPane createScaledLayers() { |
| |
| layers = createScalableFreeformLayeredPane(); |
| |
| layers.add(new FreeformLayer(), PAGE_BREAKS_LAYER); |
| printableLayerIndex = layers.getChildren().size(); |
| layers.add(getPrintableLayers(), PRINTABLE_LAYERS); |
| |
| gridLayer = createGridLayer(); |
| |
| layers.add(gridLayer, GRID_LAYER); |
| |
| layers.add(new FreeformLayer(), DECORATION_UNPRINTABLE_LAYER); |
| return layers; |
| } |
| |
| /** |
| * Creates the <code>ScalableFreeformLayeredPane</code>. |
| * @return the new <code>ScalableFreeformLayeredPane</code> |
| */ |
| protected ScalableFreeformLayeredPane createScalableFreeformLayeredPane() { |
| return new DiagramScalableFreeformLayeredPane(getMapMode()); |
| } |
| |
| /** |
| * Override to set a non-default zoom levels |
| * @return the ZoomManager with the non-default zoom range |
| */ |
| public ZoomManager getZoomManager() { |
| if (zoomManager == null) { |
| zoomManager = new AnimatableZoomManager((ScalableFigure)getScaledLayers(), |
| ((Viewport)getFigure())); |
| zoomManager.setZoomLevels(zoomLevels); |
| refreshEnableZoomAnimation(zoomManager); |
| } |
| |
| return zoomManager; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomTo(double, org.eclipse.draw2d.geometry.Point) |
| */ |
| public void zoomTo(double zoom, Point center) { |
| zoomManager.zoomTo(zoom, center); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomTo(org.eclipse.draw2d.geometry.Rectangle) |
| */ |
| public void zoomTo(Rectangle rect) { |
| zoomManager.zoomTo(rect); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomIn() |
| */ |
| public void zoomIn() { |
| zoomManager.zoomIn(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomIn(org.eclipse.draw2d.geometry.Point) |
| */ |
| public void zoomIn(Point center) { |
| zoomManager.zoomTo(zoomManager.getNextZoomLevel(), center); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomOut() |
| */ |
| public void zoomOut() { |
| zoomManager.zoomOut(); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.editparts.ZoomableEditPart#zoomOut(org.eclipse.draw2d.geometry.Point) |
| */ |
| public void zoomOut(Point center) { |
| zoomManager.zoomTo(zoomManager.getPreviousZoomLevel(), center); |
| } |
| |
| /** |
| * Convience method to access the workspace viewer preferences. |
| * @return PreferenceStore the workspace viewer preference store |
| */ |
| protected IPreferenceStore getWorkspaceViewerPreferences() { |
| if (getViewer() == null) return null; |
| return ((DiagramGraphicalViewer) getViewer()) |
| .getWorkspaceViewerPreferenceStore(); |
| } |
| |
| |
| /** |
| * Get the Grid Spacing from the Plug-ins preference store |
| * |
| * @return grid spacing value. |
| */ |
| public double getGridSpacing() { |
| |
| double gridSpacing = 0; |
| // Check the workspace properties |
| if (getWorkspaceViewerPreferences() != null) |
| gridSpacing = getWorkspaceViewerPreferences().getDouble(WorkspaceViewerProperties.GRIDSPACING); |
| |
| // If the workspace property is not set then get the global preference value |
| if (gridSpacing == 0) { |
| IPreferenceStore pluginStore = (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| gridSpacing = pluginStore.getDouble(IPreferenceConstants.PREF_GRID_SPACING); |
| } |
| return gridSpacing; |
| } |
| |
| /** |
| * Sets the grid line style. |
| * @param color |
| * |
| * @param style |
| */ |
| public void setGridStyle(int style) { |
| if (gridLayer instanceof GridLayerEx) { |
| ((GridLayerEx) gridLayer).setLineStyle(style); |
| } |
| gridLayer.repaint(); |
| } |
| |
| |
| /** |
| * Sets the grid line color. |
| * @param color |
| * |
| * @param gridSpacing |
| */ |
| public void setGridColor(Integer rgbValue) { |
| gridLayer.setForegroundColor(DiagramColorRegistry.getInstance().getColor(rgbValue)); |
| } |
| |
| /** |
| * This method is called to set the grid spacing. The units used |
| * for grid spacing are the same as the rulers current units. |
| * |
| * @param gridSpacing |
| */ |
| public void setGridSpacing(double gridSpacing) { |
| |
| int rulerUnits = RulerProvider.UNIT_INCHES; |
| if (getWorkspaceViewerPreferences() != null) |
| rulerUnits = getWorkspaceViewerPreferences().getInt(WorkspaceViewerProperties.RULERUNIT); |
| |
| // Get the Displays DPIs |
| double dotsPerInch = DisplayUtils.getDisplay().getDPI().x; |
| int spacingInPixels = 0; |
| |
| // Evaluate the Grid Spacing based on the ruler units |
| switch( rulerUnits) { |
| case RulerProvider.UNIT_INCHES: |
| spacingInPixels = (int)Math.round(dotsPerInch * gridSpacing); |
| break; |
| |
| case RulerProvider.UNIT_CENTIMETERS: |
| spacingInPixels = (int)Math.round( dotsPerInch * gridSpacing / 2.54 ); |
| break; |
| |
| default: |
| spacingInPixels = (int)gridSpacing; |
| } |
| |
| int spacing = getMapMode().DPtoLP(spacingInPixels); |
| getViewer().setProperty(SnapToGrid.PROPERTY_GRID_SPACING, |
| new Dimension(spacing, spacing)); |
| } |
| |
| |
| /** |
| * Returns the PageBreakEditPart controlled by this RootEditPart. |
| * @return the <code>PageBreakEditPart</code> |
| */ |
| public PageBreakEditPart getPageBreakEditPart() { |
| if (pageBreakEditPart == null) { |
| pageBreakEditPart = new PageBreakEditPart(); |
| pageBreakEditPart.setParent(this); |
| } |
| return pageBreakEditPart; |
| } |
| |
| /** |
| * Refreshes the page breaks. |
| */ |
| protected void refreshPageBreaks() { |
| if (getWorkspaceViewerPreferences().getBoolean(WorkspaceViewerProperties.VIEWPAGEBREAKS)) |
| showPageBreaks(); |
| else |
| hidePageBreaks(); |
| } |
| |
| /** |
| * Adds the pagebreaks figure to the <code>PAGE_BREAKS_LAYER</code> |
| */ |
| private void showPageBreaks() { |
| getLayer(PAGE_BREAKS_LAYER).add(getPageBreakEditPart().getFigure()); |
| Point p = |
| new Point( |
| getWorkspaceViewerPreferences().getInt( |
| WorkspaceViewerProperties.PAGEBREAK_X), |
| getWorkspaceViewerPreferences().getInt( |
| WorkspaceViewerProperties.PAGEBREAK_Y)); |
| getPageBreakEditPart().set( |
| p, |
| PageInfoHelper.getChildrenBounds( |
| (DiagramEditPart) getContents(), |
| PageBreaksFigure.class)); |
| } |
| |
| /** |
| * Removes the pagebreaks figure from the <code>PAGE_BREAKS_LAYER</code> |
| */ |
| private void hidePageBreaks() { |
| if (getLayer(PAGE_BREAKS_LAYER) |
| .getChildren() |
| .contains(getPageBreakEditPart().getFigure())) { |
| getLayer(PAGE_BREAKS_LAYER).remove( |
| getPageBreakEditPart().getFigure()); |
| |
| getPageBreakEditPart().updatePreferenceStore(); |
| } |
| } |
| |
| /** |
| * Handler for the workspace preference store. Updates the page breaks if |
| * WorksapceViewerProperties.VIEWPAGEBREAKS value is modified. |
| * @param event |
| */ |
| private void handlePreferenceStorePropertyChanged(org.eclipse.jface.util.PropertyChangeEvent event) { |
| if (WorkspaceViewerProperties.VIEWPAGEBREAKS.equals(event.getProperty())) { |
| refreshPageBreaks(); |
| } else if (isPageSizeChange(event.getProperty())) { |
| Rectangle diagramBounds = PageInfoHelper.getChildrenBounds( |
| (DiagramEditPart) getContents(), |
| PageBreaksFigure.class); |
| getPageBreakEditPart().resize(diagramBounds); |
| getPageBreakEditPart().updatePreferenceStore(); |
| refreshPageBreaks(); |
| } else if (WorkspaceViewerProperties.VIEWGRID.equals(event.getProperty())) { |
| // Set the state of the Grid Enabled Property |
| getViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, event.getNewValue()); |
| } else if (WorkspaceViewerProperties.SNAPTOGRID.equals(event.getProperty())) { |
| // Set the state of the Snap to Grid Property |
| getViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, event.getNewValue()); |
| } else if (WorkspaceViewerProperties.SNAPTOGEOMETRY.equals(event.getProperty())) { |
| // Set the state of the Snap to Geometry Property |
| getViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, event.getNewValue()); |
| } else if (WorkspaceViewerProperties.GRIDORDER.equals(event.getProperty())) { |
| // Set the grid level |
| moveGridLayer(((Boolean) event.getNewValue()).booleanValue()); |
| } else if (WorkspaceViewerProperties.GRIDSPACING.equals(event.getProperty())) { |
| // Set the grid spacing |
| Double spacing = (Double) event.getNewValue(); |
| setGridSpacing(spacing.doubleValue()); |
| } else if (WorkspaceViewerProperties.VIEWRULERS.equals(event.getProperty())) { |
| // Set the state of the Ruler Enabled Property |
| getViewer().setProperty(RulerProvider.PROPERTY_RULER_VISIBILITY, |
| event.getNewValue()); |
| } else if (WorkspaceViewerProperties.RULERUNIT.equals(event.getProperty())) { |
| Object newValue = event.getNewValue(); |
| int rulerUnits; |
| |
| if (newValue.getClass() == Integer.class) { |
| rulerUnits = ((Integer) newValue).intValue(); |
| setRulers(rulerUnits); |
| } else if (newValue.getClass() == String.class) { |
| try { |
| rulerUnits = Integer.parseInt((String) newValue); |
| setRulers(rulerUnits); |
| } catch (NumberFormatException e) { |
| Log.error( DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.RESOURCE_FAILURE, e.toString() ); |
| } |
| } else { |
| Log.error( DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.RESOURCE_FAILURE, |
| newValue.getClass().getName()); |
| } |
| |
| // Refresh the Rulers |
| Boolean oldValue = (Boolean)getViewer().getProperty(RulerProvider.PROPERTY_RULER_VISIBILITY); |
| getViewer().setProperty(RulerProvider.PROPERTY_RULER_VISIBILITY, Boolean.FALSE); |
| getViewer().setProperty(RulerProvider.PROPERTY_RULER_VISIBILITY, oldValue ); |
| |
| // Update the Grids |
| double spacing = getGridSpacing(); |
| setGridSpacing(spacing); |
| |
| } else if (WorkspaceViewerProperties.GRIDLINECOLOR.equals(event.getProperty())) { |
| Integer newValue = (Integer) event.getNewValue(); |
| // Set the grid line color |
| setGridColor(newValue); |
| } else if (WorkspaceViewerProperties.GRIDLINESTYLE.equals(event.getProperty())) { |
| Integer newValue = (Integer) event.getNewValue(); |
| // Set the grid line style |
| setGridStyle(newValue.intValue()); |
| } else if (event.getProperty().equals(IPreferenceConstants.PREF_ENABLE_ANIMATED_ZOOM)){ |
| refreshEnableZoomAnimation(getZoomManager()); |
| } else if (event.getProperty().equals(IPreferenceConstants.PREF_ENABLE_ANTIALIAS)){ |
| refreshEnableAntiAlias(); |
| } |
| } |
| |
| /** |
| * @param rulerUnits |
| */ |
| private void setRulers(int rulerUnits) { |
| if( getVerticalRuler() != null ) { |
| getVerticalRuler().setUnit( rulerUnits ); |
| } else { |
| setVerticalRuler(new DiagramRuler(false, rulerUnits, null)); |
| } |
| if( getHorizontalRuler() != null ) { |
| getHorizontalRuler().setUnit( rulerUnits ); |
| } else { |
| setHorizontalRuler(new DiagramRuler(true, rulerUnits, null)); |
| } |
| } |
| |
| /** |
| * |
| */ |
| private void refreshEnableZoomAnimation(ZoomManager zoomMangr) { |
| IPreferenceStore preferenceStore = |
| (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| boolean animatedZoom = preferenceStore.getBoolean( |
| IPreferenceConstants.PREF_ENABLE_ANIMATED_ZOOM); |
| zoomMangr.setZoomAnimationStyle(animatedZoom ? ZoomManager.ANIMATE_ZOOM_IN_OUT : ZoomManager.ANIMATE_NEVER); |
| } |
| |
| /** |
| * Refresh visuals in order to enable anti-aliasing |
| */ |
| public void refreshVisuals() { |
| // Set the anti-aliasing |
| refreshEnableAntiAlias(); |
| } |
| |
| /** |
| * Refreshes anti-alias status on the diagram |
| */ |
| protected void refreshEnableAntiAlias() { |
| IPreferenceStore preferenceStore = |
| (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| boolean antiAlias = preferenceStore.getBoolean( |
| IPreferenceConstants.PREF_ENABLE_ANTIALIAS); |
| if (getLayers() instanceof org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScalableFreeformLayeredPane) |
| ((org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScalableFreeformLayeredPane) layers).setAntiAlias(antiAlias); |
| } |
| |
| /** |
| * Refreshes ruler units on the diagram |
| */ |
| protected void refreshRulerUnits() { |
| if (getWorkspaceViewerPreferences() != null) |
| setRulers(getWorkspaceViewerPreferences().getInt(WorkspaceViewerProperties.RULERUNIT)); |
| } |
| |
| /** |
| * This is a workspace property request. It does not use a <code>Command</code> |
| * to execute since it does not change the model. |
| * @param request |
| */ |
| public void performRequest(Request request) { |
| if (request.getType().equals(RequestConstants.REQ_RECALCULATE_PAGEBREAKS)) { |
| getPageBreakEditPart().calculatePageBreakFigureBounds(); |
| } |
| } |
| |
| /** |
| * Adds a listener to the workspace preference store for changes related to the |
| * page breaks and diagram grid. |
| */ |
| public void activate() { |
| super.activate(); |
| |
| if (getWorkspaceViewerPreferences() != null) |
| getWorkspaceViewerPreferences().addPropertyChangeListener(listener); |
| |
| initPreferenceStoreListener(); |
| |
| ScalableFreeformLayeredPane pane = getLayers(); |
| |
| refreshEnableAntiAlias(); |
| |
| initWorkspaceViewerProperties(); |
| |
| refreshRulerUnits(); |
| |
| if (pane instanceof ZoomListener) { |
| getZoomManager().addZoomListener((ZoomListener)pane); |
| } |
| } |
| |
| private static final int LIGHT_GRAY_RGB = 12632256; |
| |
| /** |
| * Initializes the workspace viewer property that are stored per diagram |
| */ |
| private void initWorkspaceViewerProperties() { |
| IPreferenceStore wsPrefStore = getWorkspaceViewerPreferences(); |
| |
| if (wsPrefStore != null) { |
| if (! wsPrefStore.contains(WorkspaceViewerProperties.GRIDORDER)) { |
| wsPrefStore.setValue(WorkspaceViewerProperties.GRIDORDER, true); |
| } else { |
| moveGridLayer(wsPrefStore.getBoolean(WorkspaceViewerProperties.GRIDORDER)); |
| } |
| if (! wsPrefStore.contains(WorkspaceViewerProperties.GRIDLINECOLOR)) { |
| wsPrefStore.setValue(WorkspaceViewerProperties.GRIDLINECOLOR, LIGHT_GRAY_RGB); |
| } else { |
| setGridColor(Integer.valueOf(wsPrefStore.getInt(WorkspaceViewerProperties.GRIDLINECOLOR))); |
| } |
| if (! wsPrefStore.contains(WorkspaceViewerProperties.GRIDLINESTYLE)) { |
| wsPrefStore.setValue(WorkspaceViewerProperties.GRIDLINESTYLE, SWT.LINE_CUSTOM); |
| } else { |
| setGridStyle(wsPrefStore.getInt(WorkspaceViewerProperties.GRIDLINESTYLE)); |
| } |
| |
| if ((! wsPrefStore.contains(WorkspaceViewerProperties.RULERUNIT)) || |
| (! wsPrefStore.contains(WorkspaceViewerProperties.GRIDSPACING))) { |
| IPreferenceStore preferenceStore = |
| (IPreferenceStore) getPreferencesHint().getPreferenceStore(); |
| // Set the ruler unit to 999 in order to force the setting |
| // and then change it to the appropriate value |
| wsPrefStore.setValue(WorkspaceViewerProperties.RULERUNIT, 999); |
| wsPrefStore.setValue(WorkspaceViewerProperties.RULERUNIT, preferenceStore.getInt(IPreferenceConstants.PREF_RULER_UNITS)); |
| wsPrefStore.setValue(WorkspaceViewerProperties.GRIDSPACING, preferenceStore.getDouble(IPreferenceConstants.PREF_GRID_SPACING)); |
| } |
| } |
| } |
| |
| /** |
| * |
| */ |
| public void deactivate() { |
| if (getPageBreakEditPart() != null) |
| getPageBreakEditPart().updatePreferenceStore(); |
| |
| if (getWorkspaceViewerPreferences() != null) |
| getWorkspaceViewerPreferences().removePropertyChangeListener(listener); |
| removePreferenceStoreListener(); |
| |
| ScalableFreeformLayeredPane pane = getLayers(); |
| if (pane instanceof ZoomListener) { |
| getZoomManager().removeZoomListener((ZoomListener)pane); |
| } |
| |
| super.deactivate(); |
| } |
| |
| /** |
| * Method that returns <code>true</code> if the given parameter corresponds to a |
| * workspace viewer property that affects the size of the page breaks. |
| * @param s workspace viewer property |
| * @return <code>true</code> if the String corresponds to a <code>WorkspaceViewerProperties</code> |
| * that affects the size of the <code>PageBreaksFigure</code> |
| * @see org.eclipse.gmf.runtime.diagram.ui.internal.properties.WorkspaceViewerProperties |
| */ |
| private boolean isPageSizeChange(String s) { |
| if (WorkspaceViewerProperties.PREF_MARGIN_TOP.equals(s) |
| || WorkspaceViewerProperties.PREF_MARGIN_LEFT.equals(s) |
| || WorkspaceViewerProperties.PREF_MARGIN_RIGHT.equals(s) |
| || WorkspaceViewerProperties.PREF_MARGIN_BOTTOM.equals(s) |
| || WorkspaceViewerProperties.PREF_PAGE_SIZE.equals(s) |
| || WorkspaceViewerProperties.PREF_USE_LANDSCAPE.equals(s) |
| || WorkspaceViewerProperties.PREF_USE_PORTRAIT.equals(s) |
| || WorkspaceViewerProperties.PREF_PAGE_HEIGHT.equals(s) |
| || WorkspaceViewerProperties.PREF_PAGE_WIDTH.equals(s) |
| || WorkspaceViewerProperties.PREF_USE_DIAGRAM_SETTINGS.equals(s)) |
| return true; |
| else |
| return false; |
| } |
| |
| |
| /** |
| * |
| * Accessor for scalable layers. Subclasses can access them in order |
| * to update the layer when a relevant preference has been modified |
| * @return |
| */ |
| protected ScalableFreeformLayeredPane getLayers() { |
| return layers; |
| } |
| |
| |
| protected void setLayers(ScalableFreeformLayeredPane layers) { |
| this.layers = layers; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IDiagramPreferenceSupport#setPreferencesHint(org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint) |
| */ |
| public void setPreferencesHint(PreferencesHint preferenceHint) { |
| this.preferencesHint = preferenceHint; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.diagram.ui.editparts.IDiagramPreferenceSupport#getPreferencesHint() |
| */ |
| public PreferencesHint getPreferencesHint() { |
| return preferencesHint; |
| } |
| |
| /** |
| * Clients must define the measurement unit in the <code>Diagram</code> notation |
| * object for their editor to affect this mapping mode object value. |
| * |
| * @return <code>IMapMode</code> that is the coordinate mapping for the Editor from device to |
| * logical coordinates. |
| */ |
| final public IMapMode getMapMode() { |
| if (mm == null) |
| mm = new WrapperMapMode(); |
| return mm; |
| } |
| |
| public DiagramRuler getHorizontalRuler() { |
| return horizontalRuler; |
| } |
| |
| private void setHorizontalRuler(DiagramRuler horizontalRuler) { |
| this.horizontalRuler = horizontalRuler; |
| } |
| |
| |
| public DiagramRuler getVerticalRuler() { |
| return verticalRuler; |
| } |
| |
| |
| private void setVerticalRuler(DiagramRuler verticalRuler) { |
| this.verticalRuler = verticalRuler; |
| } |
| |
| protected GridLayer createGridLayer() { |
| return new GridLayerEx(); |
| } |
| |
| protected GridLayer createGridLayer(int r, int g, int b) { |
| return new GridLayerEx(new Color(null,r,g,b)); |
| } |
| |
| } |
