| /****************************************************************************** |
| * Copyright (c) 2008, 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.printing.internal.util; |
| |
| import java.io.File; |
| |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.gef.RootEditPart; |
| import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint; |
| import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; |
| import org.eclipse.gmf.runtime.diagram.ui.OffscreenEditPartFactory; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIPlugin; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.editparts.PageBreakEditPart; |
| 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.parts.DiagramEditor; |
| import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramGraphicalViewer; |
| import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer; |
| import org.eclipse.gmf.runtime.diagram.ui.util.DiagramEditorUtil; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.jface.preference.PreferenceStore; |
| import org.eclipse.swt.widgets.Shell; |
| |
| /** |
| * Helper to assist in making an off screen diagram suitable for printing or |
| * previewing. |
| * |
| * @author James Bruck (jbruck) |
| */ |
| public class PrintHelperUtil { |
| |
| // |
| // The following printing attributes are saved across |
| // the preview and print dialogs. |
| // |
| private static int scaleFactor = 100; |
| private static int scaleWidth = 1; |
| private static int scaleHeight = 1; |
| |
| public static int getScale() { |
| return scaleFactor; |
| } |
| |
| public static void setScale(int scale) { |
| scaleFactor = scale; |
| } |
| |
| public static int getScaleToWidth() { |
| return scaleWidth; |
| } |
| |
| public static void setScaleToWidth(int width) { |
| scaleWidth = width; |
| } |
| |
| public static int getScaleToHeight() { |
| return scaleHeight; |
| } |
| |
| public static void setScaleToHeight(int height) { |
| scaleHeight = height; |
| } |
| |
| /** |
| * Creates a <code>DiagramEditPart</code> given the <code>Diagram</code> |
| * without opening an editor. |
| * |
| * @param diagram the <code>Diagram</code> |
| * @param preferencesHint the preferences hint to use for intiializing the |
| * preferences of the root edit part |
| * @return the new populated <code>DiagramEditPart</code> |
| * @deprecated Please use |
| * {@link #createDiagramEditPart(Diagram, PreferencesHint, Shell)} |
| * instead as this method does not dispose the new Shell that it |
| * creates. |
| */ |
| public static DiagramEditPart createDiagramEditPart(Diagram diagram, |
| PreferencesHint preferencesHint) { |
| return createDiagramEditPart(diagram, preferencesHint, new Shell()); |
| } |
| |
| /** |
| * Creates a <code>DiagramEditPart</code> given the <code>Diagram</code> |
| * without opening an editor. |
| * |
| * @param diagram the <code>Diagram</code> |
| * @param preferencesHint the preferences hint to use for intiializing the |
| * preferences of the root edit part |
| * @return the new populated <code>DiagramEditPart</code> |
| */ |
| public static DiagramEditPart createDiagramEditPart(Diagram diagram, |
| PreferencesHint preferencesHint, Shell shell) { |
| DiagramEditPart diagramEditPart = OffscreenEditPartFactory.getInstance().createDiagramEditPart( |
| diagram, shell, preferencesHint); |
| // since some of the diagram updates are ASync we need to give the |
| // inter-thread messages a chance to get processed before we |
| // continue; check bugzilla 170332 |
| while (shell.getDisplay().readAndDispatch ()){ |
| // nothing special to do |
| } |
| return diagramEditPart; |
| } |
| |
| /** |
| * Initialize the preferences for a diagram edit part, specifically |
| * including page breaks and margins. |
| * |
| * Typically, the diagram edit part is created using |
| * createDiagramEditPart() and the diagram edit part is passed in as the |
| * first parameter of this method. |
| * |
| * @param diagramEditPart the DiagramEditPart to pass in |
| * @param preferencesHint the preferences hint to use for intiializing the preferences |
| * |
| * @return true if the preferences could be loaded, false if they weren't |
| * loaded and defaults had to be used instead |
| */ |
| public static boolean initializePreferences(DiagramEditPart diagramEditPart, PreferencesHint preferencesHint) { |
| assert diagramEditPart.getViewer() instanceof DiagramGraphicalViewer; |
| |
| DiagramGraphicalViewer viewer = (DiagramGraphicalViewer)diagramEditPart.getViewer(); |
| |
| boolean loadedPreferences = true; |
| |
| IPreferenceStore fPreferences = getPreferenceStoreForDiagram(diagramEditPart); |
| |
| if (fPreferences == null) { |
| loadedPreferences = false; |
| //leave at default x and y |
| PreferenceStore defaults = new PreferenceStore(); |
| DiagramEditor.addDefaultPreferences(defaults, preferencesHint); |
| |
| fPreferences = getWorkspacePreferenceStore(preferencesHint); |
| } else if (!fPreferences |
| .getBoolean(WorkspaceViewerProperties.PREF_USE_DIAGRAM_SETTINGS)) { |
| //if we aren't supposed to use the diagram settings, switch to the |
| //workspace settings |
| |
| //we have to use the page break x and y settings from the diagram |
| int x = fPreferences.getInt(WorkspaceViewerProperties.PAGEBREAK_X), y = fPreferences |
| .getInt(WorkspaceViewerProperties.PAGEBREAK_Y); |
| |
| //minor performance optimization, use the existing |
| //preferences from the workspace instead of making a new one |
| fPreferences = getWorkspacePreferenceStore(preferencesHint); |
| fPreferences.setValue(WorkspaceViewerProperties.PAGEBREAK_X, x); |
| fPreferences.setValue(WorkspaceViewerProperties.PAGEBREAK_Y, y); |
| } |
| |
| viewer.hookWorkspacePreferenceStore(fPreferences); |
| |
| diagramEditPart.refreshPageBreaks(); |
| |
| return loadedPreferences; |
| } |
| |
| /** |
| * Returns the workspace viewer <code>PreferenceStore</code> for a given diagram edit part. |
| * |
| * @param diagramEP the DiagramEditPart to obtain the preference store for |
| * |
| * @return the <code>PreferenceStore</code> for the given diagram edit part |
| * Could return null if it couldn't be loaded |
| */ |
| private static IPreferenceStore getPreferenceStoreForDiagram(DiagramEditPart diagramEP) { |
| // Try to load it |
| String id = ViewUtil.getIdStr(diagramEP.getDiagramView()); |
| |
| //try and get preferences from the open diagrams first |
| //loadedPreferences will be set to true only if the preferences could |
| // be |
| //successfully loaded |
| IPreferenceStore fPreferences = loadPreferencesFromOpenDiagram(id); |
| if (fPreferences != null) { |
| //loadPreferencesFromOpenDiagram will have set preferences |
| return fPreferences; |
| } |
| |
| IPath path = DiagramUIPlugin.getInstance().getStateLocation(); |
| |
| String fileName = path.toString() + "/" + id;//$NON-NLS-1$ |
| java.io.File file = new File(fileName); |
| fPreferences = new PreferenceStore(fileName); |
| if (file.exists()) { |
| // Load it |
| try { |
| ((PreferenceStore) fPreferences).load(); |
| |
| return fPreferences; |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| return null; //fPreferences couldn't be loaded |
| } |
| |
| /** |
| * Load the preferences from an open diagram that has the given guid. |
| * |
| * @param id guid of the open diagram to load the preferences for |
| */ |
| private static IPreferenceStore loadPreferencesFromOpenDiagram(String id) { |
| |
| DiagramEditor diagramEditor = DiagramEditorUtil.findOpenedDiagramEditorForID(id); |
| if (diagramEditor != null) { |
| IDiagramGraphicalViewer viewer = diagramEditor |
| .getDiagramGraphicalViewer(); |
| if (diagramEditor.getDiagramEditPart().getRoot() instanceof DiagramRootEditPart) { |
| PageBreakEditPart pageBreakEditPart = ((DiagramRootEditPart) diagramEditor |
| .getDiagramEditPart().getRoot()).getPageBreakEditPart(); |
| pageBreakEditPart.resize(diagramEditor.getDiagramEditPart() |
| .getChildrenBounds()); |
| pageBreakEditPart.updatePreferenceStore(); |
| } |
| if (viewer instanceof DiagramGraphicalViewer) { |
| DiagramGraphicalViewer diagramGraphicalViewer = (DiagramGraphicalViewer) viewer; |
| |
| // preferences loaded |
| return diagramGraphicalViewer |
| .getWorkspaceViewerPreferenceStore(); |
| } |
| } |
| |
| // no matching guid found |
| return null; |
| } |
| |
| /** |
| * Return the preference store for the given PreferenceHint |
| * @param preferencesHint to return the preference store for. |
| * |
| * @return preference store for the given PreferenceHint |
| */ |
| private static IPreferenceStore getWorkspacePreferenceStore(PreferencesHint preferencesHint) { |
| return (IPreferenceStore) preferencesHint.getPreferenceStore(); |
| } |
| |
| /** |
| * Returns the page break bounds on the diagram. If the bounds cannot be |
| * found the diagram bounds is returned. |
| * |
| * @param dgrmEP the diagram edit part to return the page break bounds for |
| * @param loadedPreferences true if preferences were previously loaded, |
| * false if they couldn't be. For consistency when printing, we have to |
| * treat page breaks differently depending on whether preferences were |
| * successfully loaded or not. |
| * |
| * @return Rectangle with the page break bounds for the given diagram edit |
| * part. If the page break bounds cannot be found the diagram bounds |
| * Rectangle is returned. |
| */ |
| public static Rectangle getPageBreakBounds(DiagramEditPart dgrmEP, boolean loadedPreferences) { |
| |
| Rectangle pageBreakBounds = null; |
| assert dgrmEP.getViewer() instanceof DiagramGraphicalViewer; |
| |
| |
| //get the preferences in use... |
| IPreferenceStore fPreferences = ((DiagramGraphicalViewer)dgrmEP.getViewer()).getWorkspaceViewerPreferenceStore(); |
| |
| if (fPreferences.getBoolean(WorkspaceViewerProperties.PREF_USE_WORKSPACE_SETTINGS)) { |
| |
| //get workspace settings... |
| if (dgrmEP.getDiagramPreferencesHint().getPreferenceStore() != null) |
| fPreferences = (IPreferenceStore)dgrmEP.getDiagramPreferencesHint().getPreferenceStore(); |
| } |
| |
| RootEditPart rootEditPart = dgrmEP.getRoot(); |
| if (rootEditPart instanceof DiagramRootEditPart) { |
| DiagramRootEditPart diagramRootEditPart = (DiagramRootEditPart) rootEditPart; |
| PageBreakEditPart pageBreakEditPart = diagramRootEditPart |
| .getPageBreakEditPart(); |
| |
| if (pageBreakEditPart != null) { |
| //resize must be called. Otherwise you get the 64 x 32 default |
| pageBreakEditPart.resize(dgrmEP.getChildrenBounds()); |
| |
| if (loadedPreferences) { |
| //if preferences were loaded, we'll always do this for |
| //consistency when printing. |
| //this is necessary when printing using workspace |
| //preferences, which is "if (getWorkspacePreferenceStore() |
| //== fPreferences)" |
| |
| //if preferences were not loaded, we do not set the figure |
| //location. we'll just leave them at defaults. |
| org.eclipse.draw2d.geometry.Point p = new org.eclipse.draw2d.geometry.Point( |
| fPreferences |
| .getInt(WorkspaceViewerProperties.PAGEBREAK_X), |
| fPreferences |
| .getInt(WorkspaceViewerProperties.PAGEBREAK_Y)); |
| pageBreakEditPart.set(p, PageInfoHelper.getChildrenBounds( |
| (DiagramEditPart) diagramRootEditPart.getContents(), |
| PageBreaksFigure.class)); |
| } |
| |
| pageBreakBounds = pageBreakEditPart.getFigure().getBounds(); |
| } else { |
| pageBreakBounds = dgrmEP.getFigure().getBounds(); |
| } |
| } |
| |
| return pageBreakBounds; |
| } |
| |
| } |