<extension id="printingExperimentalContributionItemProvider" name="Printing_Experimental" point="org.eclipse.gmf.runtime.common.ui.services.action.contributionItemProviders">

      <contributionItemProvider class="org.eclipse.gmf.runtime.diagram.ui.render.internal.providers.PrintingExperimentalContributionItemProvider">

         <Priority name="Low">

         </Priority>

         <partContribution class="org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart">

            <partAction menubarPath="/file/print" id="printExperimentalAction">

            </partAction>

         </partContribution>

      </contributionItemProvider>

   </extension>

/******************************************************************************

 * Copyright (c) 2008 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.render.internal.providers;

import org.eclipse.gmf.runtime.common.ui.services.action.contributionitem.AbstractContributionItemProvider;

import org.eclipse.gmf.runtime.common.ui.util.IWorkbenchPartDescriptor;

import org.eclipse.jface.action.IAction;

/**

 * This class is strictly temporary while we introduce the printing via the

 * Print Service API.

 * 

 * @author James Bruck (jbruck)

 */

public class PrintingExperimentalContributionItemProvider extends

		AbstractContributionItemProvider {

	/**

	 * @see org.eclipse.gmf.runtime.common.ui.services.action.contributionitem.AbstractContributionItemProvider#createAction(java.lang.String, org.eclipse.gmf.runtime.common.ui.services.contributionitem.IWorkbenchPartDescriptor)

	 */

	protected IAction createAction(

		String actionId,

		IWorkbenchPartDescriptor partDescriptor) {

		if (actionId.equals(PrintExperimentalAction.ID))

			return new PrintExperimentalAction();

		return super.createAction(actionId, partDescriptor);

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.internal.providers;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.gef.RootEditPart;

import org.eclipse.gmf.runtime.common.core.util.Log;

import org.eclipse.gmf.runtime.common.core.util.Trace;

import org.eclipse.gmf.runtime.common.ui.action.actions.IPrintActionHelper;

import org.eclipse.gmf.runtime.diagram.core.preferences.PreferencesHint;

import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart;

import org.eclipse.gmf.runtime.diagram.ui.editparts.IDiagramPreferenceSupport;

import org.eclipse.gmf.runtime.diagram.ui.parts.DiagramEditor;

import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramGraphicalViewer;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.actions.EnhancedPrintActionHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.DiagramUIPrintingRenderDebugOptions;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.DiagramUIPrintingRenderPlugin;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.JPSDiagramPrinter;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.JPSDiagramPrinterHelper;

import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;

import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.IWorkbenchWindowActionDelegate;

import org.eclipse.ui.PlatformUI;

/**

 * This class is strictly temporary while we introduce the printing via the

 * Print Service API.

 * 

 * @author James Bruck (jbruck)

 */

public class PrintExperimentalAction extends Action implements

		IWorkbenchWindowActionDelegate {

	/**

	 * ID for this page setup action

	 */

	public static final String ID = "printExperimentalAction";//$NON-NLS-1$

	/**

	 * Constructor sets the id and label that is displayed in the menu bar.

	 */

	public PrintExperimentalAction() {

		setId(ID);

		setText("Print (Experimental)..."); //$NON-NLS-1$

	}

	/**

	 * We override the print to always use the newer JPS printing options.

	 */

	public void run() {

		IPrintActionHelper helper = new EnhancedPrintActionHelper() {

			@Override

			public void doPrint(IWorkbenchPart workbenchPart) {

				DiagramEditor diagramEditor = null;

				if (workbenchPart instanceof DiagramEditor) {

					diagramEditor = (DiagramEditor) workbenchPart;

				} else {

					Log.error(DiagramUIPrintingRenderPlugin.getInstance(),

							IStatus.ERROR, "Invalid IWorkbenchPart"); //$NON-NLS-1$

					IllegalArgumentException e = new IllegalArgumentException(

							"Invalid IWorkbenchPart."); //$NON-NLS-1$

					Trace

							.throwing(

									DiagramUIPrintingRenderPlugin.getInstance(),

									DiagramUIPrintingRenderDebugOptions.EXCEPTIONS_THROWING,

									EnhancedPrintActionHelper.class,

									"doPrint()", e); //$NON-NLS-1$

					throw e;

				}

				IDiagramGraphicalViewer viewer = diagramEditor

						.getDiagramGraphicalViewer();

				RootEditPart rootEP = (viewer == null) ? null : viewer

						.getRootEditPart();

				PreferencesHint preferencesHint = (rootEP instanceof IDiagramPreferenceSupport) ? ((IDiagramPreferenceSupport) rootEP)

						.getPreferencesHint()

						: PreferencesHint.USE_DEFAULTS;

				IMapMode mapMode = (rootEP instanceof DiagramRootEditPart) ? ((DiagramRootEditPart) rootEP)

						.getMapMode()

						: MapModeUtil.getMapMode();

				JPSDiagramPrinterHelper

						.getDiagramPrinterHelper()

						.printWithSettings(diagramEditor, createDiagramMap(),

								new JPSDiagramPrinter(preferencesHint, mapMode));

			}

		};

		helper.doPrint(PlatformUI.getWorkbench().getActiveWorkbenchWindow()

				.getActivePage().getActivePart());

	}

	/**

	 * The run method does the real run action. From IActionDelegate

	 */

	public void run(IAction action) {

		run();

	}

	/**

	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#dispose()

	 */

	public void dispose() {

		// do nothing

	}

	/**

	 * @see org.eclipse.ui.IWorkbenchWindowActionDelegate#init(IWorkbenchWindow)

	 */

	public void init(IWorkbenchWindow window) {

		// do nothing

	}

	/**

	 * @see org.eclipse.ui.IActionDelegate#selectionChanged(IAction, ISelection)

	 */

	public void selectionChanged(IAction action, ISelection selection) {

		//do nothing

	}

}

import org.eclipse.core.runtime.Platform;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.JPSDiagramPrinter;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.JPSDiagramPrinterHelper;

import org.eclipse.gmf.runtime.notation.Diagram;

/******************************************************************************

 * Copyright (c) 2008 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.render.dialogs;

import org.eclipse.gmf.runtime.common.ui.action.actions.IPrintActionHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.l10n.DiagramUIPrintingMessages;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.printpreview.PrintPreviewHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.actions.EnhancedPrintActionHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.internal.printpreview.RenderedPrintPreviewHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.model.PrintOptions;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

/**

 * A section of the JPS print dialog that handles extra actions. In this case,

 * we contribute print preview capabilities.

 * 

 * @author Christian Damus (cdamus)

 * @author James Bruck (jbruck)

 */

class ActionsBlock extends DialogBlock {

	private final PrintOptions options;

	private Button printPreview;

	private PrintPreviewHelper printPreviewHelper;

	private IPrintActionHelper printActionHelper;

	ActionsBlock(IDialogUnitConverter dluConverter, PrintOptions options) {

		super(dluConverter);

		this.options = options;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.gmf.runtime.common.ui.printing.internal.dialogs.DialogBlock#createContents(org.eclipse.swt.widgets.Composite)

	 */

	public Control createContents(Composite parent) {

		printPreview = new Button(parent, SWT.PUSH);

		printPreview.setData(new Integer(2));

		printPreview

				.setText(DiagramUIPrintingMessages.JPSPrintDialog_Button_PrintPreview);

		printPreview.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent event) {

				buttonPressed(((Integer) event.widget.getData()).intValue());

			}

		});

		layoutVerticalIndent(layoutAlignLeft(printPreview));

		return printPreview;

	}

	/**

	 * Bring up the print preview with printing disabled.

	 * 

	 * @param buttonId

	 */

	protected void buttonPressed(int buttonId) {

		switch (buttonId) {

		case -1:

			break;

		default:

			getPrintPreviewHelper().enablePrinting(false);

		    getPrintPreviewHelper().doPrintPreview(getPrintActionHelper());

		}

	}

	/**

	 * Return the print preview helper responsible for performing the print

	 * preview.

	 * 

	 * @return PrintPreviewHelper the print preview helper.

	 */

	private PrintPreviewHelper getPrintPreviewHelper() {

		if (printPreviewHelper == null) {

			printPreviewHelper = new RenderedPrintPreviewHelper();

		}		

		return printPreviewHelper;

	}

	private IPrintActionHelper getPrintActionHelper() {

		if (printActionHelper == null) {

			printActionHelper = new EnhancedPrintActionHelper();

		}

		return printActionHelper;

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.dialogs;

import java.util.List;

import java.util.Locale;

import javax.print.DocFlavor;

import javax.print.PrintService;

import javax.print.PrintServiceLookup;

import javax.print.attribute.AttributeSet;

import javax.print.attribute.HashPrintServiceAttributeSet;

import javax.print.attribute.PrintServiceAttributeSet;

import javax.print.attribute.standard.PrinterLocation;

import javax.print.attribute.standard.PrinterMakeAndModel;

import javax.print.attribute.standard.PrinterMessageFromOperator;

import javax.print.attribute.standard.PrinterName;

import javax.print.attribute.standard.PrinterState;

import org.eclipse.core.databinding.DataBindingContext;

import org.eclipse.core.databinding.beans.BeansObservables;

import org.eclipse.core.databinding.observable.Realm;

import org.eclipse.core.databinding.observable.value.IObservableValue;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.l10n.DiagramUIPrintingMessages;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.model.PrintDestination;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.model.PrintOptions;

import org.eclipse.jface.databinding.viewers.ViewersObservables;

import org.eclipse.jface.viewers.ComboViewer;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Label;

/**

 * A section of the JPS print dialog that adds printer options.

 * 

 * @author Christian Damus (cdamus)

 * @author James Bruck (jbruck)

 */

class PrinterBlock extends DialogBlock {

	private final DataBindingContext bindings;

	private final PrintOptions options;

	private List<PrintDestination> destinations = new java.util.ArrayList<PrintDestination>();

	private ComboViewer combo;

	private Label resultStatusLabel;

	private Label resultTypeLabel;

	private Label resultWhereLabel;

	private Label resultCommentLabel;

	PrinterBlock(IDialogUnitConverter dluConverter,

			DataBindingContext bindings, PrintOptions options) {

		super(dluConverter);

		this.bindings = bindings;

		this.options = options;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see org.eclipse.gmf.runtime.common.ui.printing.internal.dialogs.DialogBlock#createContents(org.eclipse.swt.widgets.Composite)

	 */

	public Control createContents(Composite parent) {

		final Realm realm = bindings.getValidationRealm();

		Composite result = group(parent,

				DiagramUIPrintingMessages.JPSPrintDialog_Printer);

		layout(result, 3);

		label(result, DiagramUIPrintingMessages.JPSPrintDialog_Name);

		combo = combo(result);

		//

		// The JPS API does not correctly return the printer status

		// information under windows. These options will be temporarily disabled

		// until a workaround can be discovered.

		//

		// combo.addSelectionChangedListener(new ISelectionChangedListener() {

		//

		// public void selectionChanged(SelectionChangedEvent event) {

		// if (event != null) {

		// handlePrinterSelectionChanged(event);

		// }

		// }

		//		});

		layoutFillHorizontal(combo.getControl());

		Button propertiesButton = button(result,

				DiagramUIPrintingMessages.JPSPrintDialog_Properties);

		propertiesButton.setEnabled(false);

		propertiesButton.addSelectionListener(new SelectionAdapter() {

			public void widgetSelected(SelectionEvent e) {

				// TODO: Introduce new dialog in phase 2

			}

		});

		IObservableValue destination = BeansObservables.observeValue(realm,

				options, PrintOptions.PROPERTY_DESTINATION);

		bindings.bindValue(ViewersObservables.observeSingleSelection(combo),

				destination, null, null);

		// Label statusLabel = label(result, "Status:");

		// layoutAlignLeft(statusLabel);

		// resultStatusLabel = label(result, "");

		// layoutFillHorizontal(layoutSpanHorizontal(resultStatusLabel, 2));

		//				

		// Label typeLabel = label(result, "Type:");

		// layoutAlignLeft(typeLabel);

		// resultTypeLabel = label(result, "");

		// layoutFillHorizontal(layoutSpanHorizontal(resultTypeLabel, 2));

		// 

		// Label whereLabel = label(result, "Where:");

		// layoutAlignLeft(whereLabel);

		// resultWhereLabel = label(result, "");

		// layoutFillHorizontal(layoutSpanHorizontal(resultWhereLabel, 2));

		// 

		// Label commentLabel = label(result, "Comment:");

		// layoutAlignLeft(commentLabel);

		// resultCommentLabel = label(result, "");

		// layoutFillHorizontal(resultCommentLabel);

		Button printToFile = check(result,

				DiagramUIPrintingMessages.JPSPrintDialog_PrintToFile);

		layoutSpanHorizontal(printToFile, 3);

		// TODO: implement in phase 2

		printToFile.setEnabled(false);

		init();

		return result;

	}

	/**

	 * When the printer selection has changed, we update the status information.

	 * The print service API does not currently update the status correctly in Windows

	 * 

	 * This will be re-enabled when a workaround for obtaining printer attributes will 

	 * be discovered.

	 * 

	 * @param selectionChangedEvent

	 */

	private void handlePrinterSelectionChanged(

			SelectionChangedEvent selectionChangedEvent) {

		StructuredSelection selection = (StructuredSelection) selectionChangedEvent

				.getSelection();

		if (selection != null) {

			PrintDestination destination = (PrintDestination) selection

					.getFirstElement();

			if (destination != null) {

				String printerName = destination.getName();

				AttributeSet attributes = new HashPrintServiceAttributeSet(

						new PrinterName(printerName, Locale.getDefault()));

				PrintService[] services = PrintServiceLookup

						.lookupPrintServices(

								DocFlavor.SERVICE_FORMATTED.PRINTABLE,

								attributes);

				PrintService printService = services[0];

				PrintServiceAttributeSet printServiceAttributes = printService

						.getAttributes();

				PrinterState printerState = (PrinterState) printServiceAttributes

						.get(PrinterState.class);

				PrinterLocation printerLocation = (PrinterLocation) printServiceAttributes

						.get(PrinterLocation.class);

				PrinterMakeAndModel printerMakeAndModel = (PrinterMakeAndModel) printServiceAttributes

						.get(PrinterMakeAndModel.class);

				PrinterMessageFromOperator printerComment = (PrinterMessageFromOperator) printServiceAttributes

						.get(PrinterMessageFromOperator.class);

				if (printerState != null) {

					resultStatusLabel.setText(printerState.getName());

				}

				if (printerLocation != null) {

					resultWhereLabel.setText(printerLocation.getName());

				}

				if (printerComment != null) {

					resultCommentLabel.setText(printerComment.getName());

				}

				if (printerMakeAndModel != null) {

					resultTypeLabel.setText(printerMakeAndModel.getName());

				}

			}

		}

	}

	/**

	 * At initialization time, we lookup all the print services and select the default one.

	 */

	private void init() {

		PrintService[] printServices = PrintServiceLookup.lookupPrintServices(

				null, null);

		PrintService defaultPrintService = PrintServiceLookup

				.lookupDefaultPrintService();

		for (PrintService printService : printServices) {

			destinations.add(new PrintDestination(printService.getName()));

		}

		PrintDestination defaultPrintDestination = getPrinterByName(defaultPrintService.getName());

		combo.setContentProvider(new PrinterContentProvider());

		combo.setLabelProvider(new PrinterLabelProvider());

		initializePrinterCombo(defaultPrintDestination);

	}

	/**

	 * Initialize the list of printers.

     *

	 * @param selection

	 */

	private void initializePrinterCombo(PrintDestination selection) {

		combo.setInput(destinations);

		combo.setSelection(new StructuredSelection(selection));

	}

	/**

	 * 

	 * @param name

	 * @return

	 */

	private PrintDestination getPrinterByName(String name) {

		PrintDestination result = null;

		for (PrintDestination printDestination : destinations) {

			if (printDestination.getName().equals(name)) {

				result = printDestination;

				break;

			}

		}

		return result;

	}

	/**

	 * A helper class used to retrieve label text

	 * 

	 * @author Christian Damus (cdamus)

	 * @author James Bruck (jbruck)

	 */

	private class PrinterContentProvider implements IStructuredContentProvider {

		public Object[] getElements(Object inputElement) {

			return destinations.toArray();

		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

			// input never changes

		}

		public void dispose() {

			// nothing to dispose

		}

	}

	private class PrinterLabelProvider extends LabelProvider {

		public String getText(Object element) {

			return ((PrintDestination) element).getName();

		}

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.util;

import java.util.List;

import org.eclipse.gmf.runtime.common.ui.printing.IPrintHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.dialogs.JPSPrintDialog;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.model.PrintOptions;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.swt.printing.PrinterData;

import org.eclipse.ui.PlatformUI;

/**

 * Default implementation of a print-helper.

 * 

 * @author Christian W. Damus (cdamus)

 */

public class PrintHelper implements IPrintHelper {

	private final PrintOptions options = new PrintOptions();

	public PrintHelper() {

		initPrintOptions();

	}

	/**

	 * Initialize the default options.

	 */

	private void initPrintOptions() {

		options.setPercentScaling(true);

		options.setScaleFactor(100);

		options.setFitToPagesWidth(1);

		options.setFitToPagesHeight(1);

		options.setAllPages(true);

		options.setRangeFrom(1);

		options.setRangeTo(1);

		options.setCopies(1);

		options.setCollate(false);

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.gmf.runtime.common.ui.printing.IPrintHelper#openPrintDlg(java.util.List)

	 */

	public PrinterData openPrintDlg(List diagramList) {

		PrinterData result = null;

		JPSPrintDialog dlg = new JPSPrintDialog(PlatformUI.getWorkbench()

				.getActiveWorkbenchWindow(), options);

		if (dlg.open() == IDialogConstants.OK_ID) {

			if (options.getDestination() != null) {

				result = options.getDestination().getPrinterData();

			}

		} else {

			// revert

			initPrintOptions();

		}

		return result;

	}

	public boolean getDlgCollate() {

		return options.isCollate();

	}

	public int getDlgNumberOfCopies() {

		return options.getCopies();

	}

	public int getDlgPagesFrom() {

		return options.getRangeFrom();

	}

	public int getDlgPagesTo() {

		return options.getRangeTo();

	}

	public boolean getDlgPrintRangeAll() {

		return options.isAllPages();

	}

	public boolean getDlgPrintRangePages() {

		return !getDlgPrintRangeAll();

	}

	public int getDlgScaleFitToM() {

		return options.getFitToPagesWidth();

	}

	public int getDlgScaleFitToN() {

		return options.getFitToPagesHeight();

	}

	public int getDlgScalePercent() {

		return options.isPercentScaling() ? options.getScaleFactor() : -1;

	}

	public void setDlgOrientation(boolean landscape) {

		// TODO Auto-generated method stub

	}

	public void setDlgPaperSize(int index, double width, double length) {

		// TODO Auto-generated method stub

	}

	public boolean getDlgDiagramPrintRangeCurrent() {

		// TODO Not supported by the JPS dialog

		return true;

	}

	public boolean getDlgDiagramPrintRangeSelection() {

		// TODO Not supported by the JPS dialog

		return false;

	}

	public boolean isDlgDiagramSelected(int index) {

		// TODO Not supported by the JPS dialog

		return false;

	}

	public boolean getDlgDiagramPrintRangeAll() {

		// TODO Not supported by the JPS dialog

		return false;

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.dialogs;

import org.eclipse.core.databinding.DataBindingContext;

import org.eclipse.core.databinding.beans.BeansObservables;

import org.eclipse.core.databinding.observable.Realm;

import org.eclipse.core.databinding.observable.value.ComputedValue;

import org.eclipse.core.databinding.observable.value.IObservableValue;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.l10n.DiagramUIPrintingMessages;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.model.PrintOptions;

import org.eclipse.jface.databinding.swt.SWTObservables;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Control;

import org.eclipse.swt.widgets.Text;

/**

 * A section of the JPS print dialog that adds scaling support.

 * 

 * @author Christian Damus (cdamus)

 * @author James Bruck (jbruck)

 */

class ScalingBlock extends DialogBlock {

	private final DataBindingContext bindings;

	private final PrintOptions options;

	ScalingBlock(IDialogUnitConverter dluConverter,

			DataBindingContext bindings, PrintOptions options) {

		super(dluConverter);

		this.bindings = bindings;

		this.options = options;

	}

	/*

	 * (non-Javadoc)

	 * @see org.eclipse.gmf.runtime.common.ui.printing.internal.dialogs.DialogBlock#createContents(org.eclipse.swt.widgets.Composite)

	 */

	public Control createContents(Composite parent) {

		final Realm realm = bindings.getValidationRealm();

		Composite result = group(parent,

				DiagramUIPrintingMessages.JPSPrintDialog_Scaling);

		layout(result, 5);

		Button adjustRadio = radio(result,

				DiagramUIPrintingMessages.JPSPrintDialog_Adjust);

		layoutSpanHorizontal(adjustRadio, 2);

		Text textScale = text(result, 20);

		layoutSpanHorizontal(blank(result), 2);

		final IObservableValue scalingValue = BeansObservables.observeValue(

				realm, options, PrintOptions.PROPERTY_PERCENT_SCALING);

		bindings.bindValue(SWTObservables.observeSelection(adjustRadio),

				scalingValue, null, null);

		bindings.bindValue(SWTObservables.observeText(textScale, SWT.Modify),

				BeansObservables.observeValue(realm, options,

						PrintOptions.PROPERTY_SCALE_FACTOR), null, null);

		bindings.bindValue(SWTObservables.observeEnabled(textScale),

				scalingValue, null, null);

		Button fitToRadio = radio(result,

				DiagramUIPrintingMessages.JPSPrintDialog_FitTo);

		IObservableValue fitToValue = new ComputedValue(realm) {

			protected Object calculate() {

				return Boolean.valueOf(!((Boolean) scalingValue.getValue())

						.booleanValue());

			}

		};

		bindings.bindValue(SWTObservables.observeSelection(fitToRadio),

				fitToValue, null, null);

		layoutHorizontalIndent(layoutAlignRight(label(result,

				DiagramUIPrintingMessages.JPSPrintDialog_PagesWide)));

		Text textWide = text(result, 20);

		layoutHorizontalIndent(layoutAlignRight(label(result,

				DiagramUIPrintingMessages.JPSPrintDialog_PagesTall)));

		Text textTall = text(result, 20);

		bindings.bindValue(SWTObservables.observeText(textWide, SWT.Modify),

				BeansObservables.observeValue(realm, options,

						PrintOptions.PROPERTY_FIT_TO_WIDTH), null, null);

		bindings.bindValue(SWTObservables.observeEnabled(textWide), fitToValue,

				null, null);

		bindings.bindValue(SWTObservables.observeText(textTall, SWT.Modify),

				BeansObservables.observeValue(realm, options,

						PrintOptions.PROPERTY_FIT_TO_HEIGHT), null, null);

		bindings.bindValue(SWTObservables.observeEnabled(textTall), fitToValue,

				null, null);

		return result;

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.model;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

/**

 * This class is used as the model in the MVC infrastructure required for databindings

 * used with the JPS dialog.

 *

 * @author Christian Damus (cdamus)

 * @author James Bruck (jbruck)

 */

abstract class PrintModelElement {

    protected final PropertyChangeSupport bean = new PropertyChangeSupport(this);

    public PrintModelElement() {

        super();

    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {

        bean.addPropertyChangeListener(listener);

    }

    public void addPropertyChangeListener(String propertyName,

            PropertyChangeListener listener) {

        bean.addPropertyChangeListener(propertyName, listener);

    }

    public PropertyChangeListener[] getPropertyChangeListeners() {

        return bean.getPropertyChangeListeners();

    }

    public PropertyChangeListener[] getPropertyChangeListeners(

            String propertyName) {

        return bean.getPropertyChangeListeners(propertyName);

    }

    public boolean hasListeners(String propertyName) {

        return bean.hasListeners(propertyName);

    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {

        bean.removePropertyChangeListener(listener);

    }

    public void removePropertyChangeListener(String propertyName,

            PropertyChangeListener listener) {

        bean.removePropertyChangeListener(propertyName, listener);

    }

    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {

        bean.firePropertyChange(propertyName, oldValue, newValue);

    }

    protected void firePropertyChange(String propertyName, int oldValue, int newValue) {

        bean.firePropertyChange(propertyName, oldValue, newValue);

    }

    protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {

        bean.firePropertyChange(propertyName, oldValue, newValue);

    }

}

/******************************************************************************

 * Copyright (c) 2008 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.render.internal;

import java.awt.print.PageFormat;

import java.awt.print.PrinterException;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import javax.print.Doc;

import javax.print.DocFlavor;

import javax.print.DocPrintJob;

import javax.print.PrintException;

import javax.print.PrintService;

import javax.print.PrintServiceLookup;

import javax.print.SimpleDoc;

import javax.print.attribute.AttributeSet;

import javax.print.attribute.HashDocAttributeSet;

import javax.print.attribute.HashPrintRequestAttributeSet;

import javax.print.attribute.HashPrintServiceAttributeSet;

import javax.print.attribute.PrintRequestAttributeSet;

import javax.print.attribute.standard.Copies;

import javax.print.attribute.standard.JobName;

import javax.print.attribute.standard.MediaSizeName;

import javax.print.attribute.standard.OrientationRequested;

import javax.print.attribute.standard.PrinterName;

import javax.print.attribute.standard.SheetCollate;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.geometry.Rectangle;

import org.eclipse.gef.LayerConstants;

import org.eclipse.gef.RootEditPart;

import org.eclipse.gmf.runtime.common.core.util.Log;

import org.eclipse.gmf.runtime.common.core.util.Trace;

import org.eclipse.gmf.runtime.common.ui.printing.IPrintHelper;

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.editparts.DiagramEditPart;

import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramRootEditPart;

import org.eclipse.gmf.runtime.diagram.ui.internal.pagesetup.PageInfoHelper;

import org.eclipse.gmf.runtime.diagram.ui.internal.pagesetup.PageSetupPageType;

import org.eclipse.gmf.runtime.diagram.ui.internal.pagesetup.PageInfoHelper.PageMargins;

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.printing.internal.DiagramPrintingDebugOptions;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.DiagramPrintingPlugin;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.DiagramPrintingStatusCodes;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.l10n.DiagramUIPrintingMessages;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.util.DiagramPrinter;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.util.PrintHelperUtil;

import org.eclipse.gmf.runtime.diagram.ui.printing.util.DiagramPrinterUtil;

import org.eclipse.gmf.runtime.diagram.ui.util.DiagramEditorUtil;

import org.eclipse.gmf.runtime.draw2d.ui.internal.graphics.ScaledGraphics;

import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode;

import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;

import org.eclipse.gmf.runtime.draw2d.ui.render.awt.internal.graphics.GraphicsToGraphics2DAdaptor;

import org.eclipse.gmf.runtime.notation.Diagram;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.resource.JFaceResources;

import org.eclipse.swt.graphics.FontData;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

/**

 * This class supports printing using the Java Print Service API.

 * The logic of calculating page break etc. follows that of SWT printing

 * but the actual printing is done asynchronously in a platform independent way.

 * 

 * Much of the paging code was derived from the previous DiagramPrinter.

 *

 * @author James Bruck (jbruck)

 */

public class JPSDiagramPrinter extends DiagramPrinter implements

		java.awt.print.Printable {

	private PrintService printService;

	private PageData[] pages;

	private IPrintHelper printHelper;

	public JPSDiagramPrinter(PreferencesHint preferencesHint, IMapMode mm) {

		super(preferencesHint, mm);

		this.preferencesHint = preferencesHint;

		this.mapMode = mm;

	}

	public JPSDiagramPrinter(PreferencesHint preferencesHint) {

		this(preferencesHint, MapModeUtil.getMapMode());

	}

	public void setPrintHelper(IPrintHelper helper) {

		this.printHelper = helper;

	}

	/**

	 * Create a new print service given a printer name.

	 * 

	 * @param printerName

	 */

	public void setPrinter(String printerName) {

		AttributeSet attributes = new HashPrintServiceAttributeSet(

				new PrinterName(printerName, Locale.getDefault()));

		PrintService[] services = PrintServiceLookup.lookupPrintServices(

				DocFlavor.SERVICE_FORMATTED.PRINTABLE, attributes);

		printService = services[0];

	}

	/**

	 * Prints the contents of the diagram editor part.

	 */

	public void run() {

		Iterator<Diagram> it = diagrams.iterator();

		Shell shell = new Shell();

		try {

			while (it.hasNext()) {

				Diagram diagram = it.next();

				DiagramEditor openedDiagramEditor = DiagramEditorUtil

						.findOpenedDiagramEditorForID(ViewUtil

								.getIdStr(diagram));

				DiagramEditPart dgrmEP = openedDiagramEditor == null ? PrintHelperUtil

						.createDiagramEditPart(diagram, preferencesHint, shell)

						: openedDiagramEditor.getDiagramEditPart();

				boolean loadedPreferences = openedDiagramEditor != null

						|| PrintHelperUtil.initializePreferences(dgrmEP,

								preferencesHint);

				RootEditPart rep = dgrmEP.getRoot();

				if (rep instanceof DiagramRootEditPart) {

					this.mapMode = ((DiagramRootEditPart) rep).getMapMode();

				}

				IPreferenceStore preferenceStore = ((DiagramGraphicalViewer) dgrmEP

						.getViewer()).getWorkspaceViewerPreferenceStore();

				if (preferenceStore

						.getBoolean(WorkspaceViewerProperties.PREF_USE_WORKSPACE_SETTINGS)) {

					if (dgrmEP.getDiagramPreferencesHint().getPreferenceStore() != null) {

						preferenceStore = (IPreferenceStore) dgrmEP

								.getDiagramPreferencesHint()

								.getPreferenceStore();

					}

				}

				doPrintDiagram(printService.createPrintJob(), dgrmEP,

						loadedPreferences, preferenceStore);

			}

		} finally {

			dispose();

			shell.dispose();

		}

	}

	/**

	 * Print the diagram figure using specified scale factor.

	 * 

	 * @param dgrmEP The diagram edit part to print

	 * @param loadedPreferences true if existing prefs could be loaded

     * 		successfully, false if not and defaults are being used.  This parameter

     * 		is important to obtain the correct page break bounds.

	 * @param fPreferences the preferenceStore that could either contain

     * 		existing preferences or defaults

	 */

	protected void printToScale(DiagramEditPart dgrmEP,

			boolean loadedPreferences, IPreferenceStore fPreferences) {

		Rectangle figureBounds = PrintHelperUtil.getPageBreakBounds(dgrmEP,

				loadedPreferences);

		org.eclipse.draw2d.geometry.Point pageBounds = PageInfoHelper

				.getPageSize(fPreferences, getMapMode());

		//

		// Translate to offset initial figure position

		//

		translated = new Point((int) (-figureBounds.x * userScale),

				(int) (-figureBounds.y * userScale));

		//

		// Calculate the number of page rows and columns

		//

		int numRows = 0, numCols = 0;

		PageMargins margins = adjustMarginsToScale(PageInfoHelper

				.getPageMargins(fPreferences, getMapMode()));

		FontData fontData = JFaceResources.getDefaultFont().getFontData()[0];

		org.eclipse.draw2d.geometry.Point pageCount = getPageCount(dgrmEP,

				figureBounds, pageBounds, true);

		numCols = pageCount.x;

		numRows = pageCount.y;

		int row = 1, col = 1, finalRow = 0, finalColumn = 0;

		List<PageData> pageList = new java.util.ArrayList<PageData>();

		if (this.printRangePageSelection) {

			//

			// Print only the pages specified in the page range...

			//

			row = calculateRowFromPage(this.pageFrom, numCols);

			col = calculateColumnFromPage(this.pageFrom, numCols, row);

			finalRow = calculateRowFromPage(this.pageTo, numCols);

			finalColumn = calculateColumnFromPage(this.pageTo, numCols,

					finalRow);

		}

		//

		// Print the pages in row, column order

		//

		for (; row <= numRows; row++) {

			for (; col <= numCols; col++) {

				pageList.add(new PageData(pageList.size(), row, col, dgrmEP,

						figureBounds, margins, fontData, fPreferences));

				if (row == finalRow && col == finalColumn

						&& this.printRangePageSelection == true) {

					break;

				}

			}

			if (row == finalRow && col == finalColumn

					&& this.printRangePageSelection == true) {

				break;

			}

			col = 1;

		}

		pages =  pageList.toArray(new PageData[pageList.size()]);

	}

	/**

	 * Print the diagram figure to fit the number and rows and columns

     * specified by the user.

	 * 

	 * @param dgrmEP The diagram edit part to print

	 * @param loadedPreferences true if existing prefs could be loaded

     * 		successfully, false if not and defaults are being used.  This parameter

     * 		is important to obtain the correct page break bounds.

	 * @param fPreferences the preferenceStore that could either contain

     * 		existing preferences or defaults

	 */

	protected void printToPages(DiagramEditPart dgrmEP,

			boolean loadedPreferences, IPreferenceStore fPreferences) {

		Rectangle figureBounds = PrintHelperUtil.getPageBreakBounds(dgrmEP,

				loadedPreferences);

		org.eclipse.draw2d.geometry.Point pageBounds = PageInfoHelper

				.getPageSize(fPreferences, getMapMode());

		org.eclipse.draw2d.geometry.Point pageCount = getPageCount(dgrmEP,

				figureBounds, pageBounds, false);

		int numCols = pageCount.x;

		int numRows = pageCount.y;

		float actualWidth = 0;

		float actualHeight = 0;

		if (this.rows == 1 && this.columns == 1 && fitToPage) {

			figureBounds = dgrmEP.getChildrenBounds();

			actualWidth = figureBounds.width;

			actualHeight = figureBounds.height;

		} else {

			actualWidth = numCols * pageBounds.x;

			actualHeight = numRows * pageBounds.y;

		}

		int totalHeight = (this.rows * pageBounds.y);

		int totalWidth = (this.columns * pageBounds.x);

		float vScale = totalHeight / actualHeight;

		float hScale = totalWidth / actualWidth;

		this.userScale = Math.min(hScale, vScale);

		PageMargins margins = adjustMarginsToScale(PageInfoHelper

				.getPageMargins(fPreferences, getMapMode()));

		translated = new Point((int) (-figureBounds.x * userScale),

				(int) (-figureBounds.y * userScale));

		FontData fontData = JFaceResources.getDefaultFont().getFontData()[0];

		int row = 1, col = 1, finalRow = 0, finalColumn = 0;

		List<PageData> pageList = new java.util.ArrayList<PageData>();

		if (this.printRangePageSelection) {

			//

			// Print only the pages specified in the page range

			// this corresponds to the physical pages, not the print range of

			// pages on one physical page.

			//

			row = calculateRowFromPage(this.pageFrom, this.columns);

			col = calculateColumnFromPage(this.pageFrom, this.columns, row);

			finalRow = calculateRowFromPage(this.pageTo, this.columns);

			finalColumn = calculateColumnFromPage(this.pageTo, this.columns,

					finalRow);

		}

		for (; row <= rows; row++) {

			for (; col <= columns; col++) {

				pageList.add(new PageData(pageList.size(), row, col, dgrmEP,

						figureBounds, margins, fontData, fPreferences));

				if (row == finalRow && col == finalColumn

						&& this.printRangePageSelection == true) {

					break;

				}

			}

			if (row == finalRow && col == finalColumn

					&& this.printRangePageSelection == true) {

				break;

			}

			col = 1;

		}

		pages = pageList.toArray(new PageData[pageList.size()]);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see java.awt.print.Printable#print(java.awt.Graphics,

	 *      java.awt.print.PageFormat, int)

	 */

	public int print(java.awt.Graphics printGraphics, PageFormat pageFormat,

			int pageIndex) throws PrinterException {

		if (pageIndex >= pages.length) {

			return java.awt.print.Printable.NO_SUCH_PAGE;

		}

		try {

			swtGraphics = new GraphicsToGraphics2DAdaptor(

					(java.awt.Graphics2D) printGraphics, new Rectangle(0, 0,

							(int) pageFormat.getWidth(), (int) pageFormat

									.getHeight()));

			graphics = createMapModeGraphics(new ScaledGraphics(swtGraphics));

			//

			// Take into account screen display DPI and the graphic DPI

			// 72.0 DPI is an AWT constant @see java.awt.Graphics2D

			//

			graphics.scale(72.0 / display_dpi.x);

			drawPage(pages[pageIndex]);

		} finally {

			dispose();

		}

		return java.awt.print.Printable.PAGE_EXISTS;

	}

	/**

	 * Set printing options in a format that is suitable for the Java print service

	 * 

	 * @param jobName  The printer job name to use

	 * @param fPreferences obtain page information from preferences

	 * @return PrintRequestAttribute set suitable for Java print service

	 */

	protected PrintRequestAttributeSet initializePrintOptions(

			String jobName,

			IPreferenceStore fPreferences) {

		PrintRequestAttributeSet printRequestAttributeSet = new HashPrintRequestAttributeSet();

		if (fPreferences

				.getBoolean(WorkspaceViewerProperties.PREF_USE_PORTRAIT)) {

			printRequestAttributeSet.add(OrientationRequested.PORTRAIT);

		} else {

			printRequestAttributeSet.add(OrientationRequested.LANDSCAPE);

		}

		String pageSize = fPreferences

				.getString(WorkspaceViewerProperties.PREF_PAGE_SIZE);

		if (pageSize.compareToIgnoreCase(PageSetupPageType.LETTER.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.NA_LETTER);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.LEGAL

				.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.NA_LEGAL);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.EXECUTIVE

				.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.EXECUTIVE);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.A3.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.ISO_A3);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.A4.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.ISO_A4);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.B4.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.ISO_B4);

		} else if (pageSize.compareToIgnoreCase(PageSetupPageType.B5.getName()) == 0) {

			printRequestAttributeSet.add(MediaSizeName.ISO_B5);

		}

		printRequestAttributeSet.add(new Copies(printHelper

				.getDlgNumberOfCopies()));

		if (printHelper.getDlgCollate()) {

			printRequestAttributeSet.add(SheetCollate.COLLATED);

		} else {

			printRequestAttributeSet.add(SheetCollate.UNCOLLATED);

		}

		printRequestAttributeSet.add(new JobName(jobName, Locale.getDefault()));

		return printRequestAttributeSet;

	}

	/**

	 * Prints to scale or prints to rows x columns pages

	 * 

	 * @param printJob

	 * @param diagramEditPart

	 * @param loadedPreferences

	 * @param fPreferences

	 */

	protected void doPrintDiagram(DocPrintJob printJob,

			DiagramEditPart diagramEditPart, boolean loadedPreferences,

			IPreferenceStore fPreferences) {

		if (isScaledPercent) {

			printToScale(diagramEditPart, loadedPreferences, fPreferences);

		} else {

			printToPages(diagramEditPart, loadedPreferences, fPreferences);

		}

		PrintRequestAttributeSet printRequestAttributeSet = initializePrintOptions(

				diagramEditPart

				.getDiagramView().getName(), fPreferences);

		Doc doc = new SimpleDoc(this, DocFlavor.SERVICE_FORMATTED.PRINTABLE,

				new HashDocAttributeSet());

		try {

			printJob.print(doc, printRequestAttributeSet);

		} catch (PrintException e) {

			Trace.catching(DiagramPrintingPlugin.getInstance(),

					DiagramPrintingDebugOptions.EXCEPTIONS_CATCHING,

					DiagramPrinterUtil.class, e.getMessage(), e);

			Log.warning(DiagramPrintingPlugin.getInstance(),

					DiagramPrintingStatusCodes.RESOURCE_FAILURE,

					e.getMessage(), e);

			MessageDialog

					.openError(

							Display.getDefault().getActiveShell(),

							DiagramUIPrintingMessages.JPSDiagramPrinterUtil_ErrorTitle,

							DiagramUIPrintingMessages.JPSDiagramPrinterUtil_ErrorMessage);

		}

	}

	/**

	 * 

	 * This method paints a portion of the diagram. (The area painted

     * representing one page.)

     * 

	 * @param page indicates which page to print.

	 */

	protected void drawPage(PageData page) {

		this.graphics.pushState();

		internalDrawPage(page.diagram, page.bounds, page.preferences,

				page.margins, graphics, page.row, page.column, false);

		// TODO: Re-enable printing of header and footer in phase 2

		this.graphics.popState();

	}

	/**

	 * The real rendering of the page to the given graphical object occurs here.

	 */

	protected void internalDrawPage(DiagramEditPart dgrmEP,

			Rectangle figureBounds, IPreferenceStore fPreferences,

			PageMargins margins, Graphics g, int rowIndex, int colIndex,

			boolean RTL_ENABLED) {

		org.eclipse.draw2d.geometry.Point pageSize = PageInfoHelper

				.getPageSize(fPreferences, false, getMapMode());

		int width = pageSize.x, height = pageSize.y;

		g.pushState();

		g.translate(translated.x, translated.y);

		g.scale(userScale);

		int translateX = -(width * (colIndex - 1));

		int translateY = -(height * (rowIndex - 1));

		int scaledTranslateX = (int) (translateX / userScale);

		int scaledTranslateY = (int) (translateY / userScale);

		int scaledWidth = (int) (width / userScale);

		int scaledHeight = (int) (height / userScale);

		if (RTL_ENABLED) {

			scaledTranslateX += (margins.left * (colIndex - 1))

					+ (margins.right * (colIndex));

			scaledTranslateY += ((margins.top * rowIndex) + (margins.bottom * (rowIndex - 1)));

		} else {

			scaledTranslateX += ((margins.left * colIndex) + (margins.right * (colIndex - 1)));

			scaledTranslateY += ((margins.top * rowIndex) + (margins.bottom * (rowIndex - 1)));

		}

		g.translate(scaledTranslateX, scaledTranslateY);

		Rectangle clip = new Rectangle(

				(scaledWidth - margins.left - margins.right) * (colIndex - 1)

						+ figureBounds.x, (scaledHeight

						- margins.bottom - margins.top)

						* (rowIndex - 1) + figureBounds.y, scaledWidth

						- margins.right - margins.left, scaledHeight

						- margins.top - margins.bottom);

		g.clipRect(clip);

		dgrmEP.getLayer(LayerConstants.PRINTABLE_LAYERS).paint(g);

		g.popState();

	}

	/**

	 *  Adjust the page margins to be compatible with the user scale.

	 *  

	 * @param margins the page margins to adjust

	 * @return adjusted page margins

	 */

	private PageMargins adjustMarginsToScale(PageMargins margins) {

		margins.left /= userScale;

		margins.top /= userScale;

		margins.bottom /= userScale;

		margins.right /= userScale;

		return margins;

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.internal;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import org.eclipse.gmf.runtime.common.core.util.Log;

import org.eclipse.gmf.runtime.common.core.util.Trace;

import org.eclipse.gmf.runtime.common.ui.printing.IPrintHelper;

import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart;

import org.eclipse.gmf.runtime.diagram.ui.parts.IDiagramWorkbenchPart;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.DiagramPrintingDebugOptions;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.DiagramPrintingPlugin;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.DiagramPrintingStatusCodes;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.l10n.DiagramUIPrintingMessages;

import org.eclipse.gmf.runtime.diagram.ui.printing.internal.util.DiagramPrinterHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.render.util.PrintHelper;

import org.eclipse.gmf.runtime.diagram.ui.printing.util.DiagramPrinterUtil;

import org.eclipse.gmf.runtime.notation.Diagram;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.swt.printing.PrinterData;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IEditorPart;

/**

 * Utility for using the DiagramPrinter to print diagrams after displaying

 * a print dialog box to the user.  Diagrams are printed using the

 * DiagramPrinter and respect the settings chosen by the user in the print

 * dialog. 

 * 

 * This class uses the java print service API to accomplish its task.

 * This class was derived from @see org.eclipse.gmf.runtime.diagram.ui.printing.util.DiagramPrinterUtil

 * 

 * This class is subject to change/removal during phase 2 of printing enhancements

 * 

 */

public class JPSDiagramPrinterHelper extends DiagramPrinterHelper {

	private static JPSDiagramPrinterHelper jpsDiagramPrinterHelper;

	public static JPSDiagramPrinterHelper getDiagramPrinterHelper() {

		if(jpsDiagramPrinterHelper == null){

			jpsDiagramPrinterHelper = new JPSDiagramPrinterHelper();

		}

		return jpsDiagramPrinterHelper;

	}

	/**

	 * Prevent instantiation.

	 */

	private JPSDiagramPrinterHelper() {

	}

	/**

	 * Opens up the print diagrams dialog, allows the user to choose the

	 * settings, and prints.

	 * 

	 * @param editorPart

	 *            current editor part

	 * @param diagramMap

	 *            map of String names to Diagram objects. Should be initialized

	 *            by caller of this method. String names will show up in the

	 *            print dialog that allows the user to choose which diagrams to

	 *            print from a list.

	 * @param jpsDiagramPrinter

	 *            the diagram printer that does the work of actually printing the diagrams

	 */

	public void printWithSettings(IEditorPart editorPart,

			Map<String, Diagram> diagramMap, JPSDiagramPrinter jpsDiagramPrinter) {

		try {

			IPrintHelper helper = new PrintHelper();

			List<String> diagramNames = new ArrayList<String>(diagramMap

					.keySet());

			PrinterData printerData = collectPrintInformation(

					jpsDiagramPrinter, helper, diagramNames, editorPart,

					diagramMap);

			if (printerData != null) {

				jpsDiagramPrinter.setPrinter(printerData.name);

				jpsDiagramPrinter.setDisplayDPI(Display.getDefault().getDPI());

				jpsDiagramPrinter.setPrintHelper(helper);

				if (helper.getDlgDiagramPrintRangeCurrent()) {

					DiagramEditPart dgrmEP = ((IDiagramWorkbenchPart) editorPart)

							.getDiagramEditPart();

					assert dgrmEP != null;

					jpsDiagramPrinter

							.setDiagrams(Collections.singletonList(dgrmEP

									.getDiagramView().getDiagram()));

				} else if (helper.getDlgDiagramPrintRangeAll()) {

					jpsDiagramPrinter.setDiagrams(diagramMap.values());

				} else if (helper.getDlgDiagramPrintRangeSelection()) {

					Object obj;

					List<Diagram> list = new ArrayList<Diagram>();

					for (int i = 0; i < diagramNames.size(); i++) {

						if (helper.isDlgDiagramSelected(i)) {

							obj = diagramMap.get(diagramNames.get(i));

							if (obj instanceof Diagram) {

								list.add((Diagram) obj);

							}

						}

					}

					jpsDiagramPrinter.setDiagrams(list);

				}

				printDiagrams(jpsDiagramPrinter, helper);

			}

		} catch (Throwable e) {

			Trace.catching(DiagramPrintingPlugin.getInstance(),

					DiagramPrintingDebugOptions.EXCEPTIONS_CATCHING,

					DiagramPrinterUtil.class, e.getMessage(), e);

			Log.warning(DiagramPrintingPlugin.getInstance(),

					DiagramPrintingStatusCodes.RESOURCE_FAILURE,

					e.getMessage(), e);

			MessageDialog

					.openError(

							Display.getDefault().getActiveShell(),

							DiagramUIPrintingMessages.JPSDiagramPrinterUtil_ErrorTitle,

							DiagramUIPrintingMessages.JPSDiagramPrinterUtil_ErrorMessage);

		}

	}

}

/******************************************************************************

 * Copyright (c) 2008 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.render.model;

import org.eclipse.swt.printing.PrinterData;

/**

 * This class is used as part of the infrastructure required for data-bindings

 * used with the JPS dialog.

 *

 * @author Christian Damus (cdamus)

 * @author James Bruck (jbruck)

 */

public class PrintDestination extends PrintModelElement {

    public static String PROPERTY_NAME = "name"; //$NON-NLS-1$

    public static String PROPERTY_PRINT_TO_FILE = "printToFile"; //$NON-NLS-1$

    public static String PROPERTY_FILE_PATH = "filePath"; //$NON-NLS-1$

    protected PrinterData printerData;

    public PrinterData getPrinterData(){

    	if(printerData == null){

    		printerData = new PrinterData();

    	}

    	return printerData;

    }

    public PrintDestination(String printerName) {

    	getPrinterData().name = printerName;

    }

    public String getName() {

        return getPrinterData().name;

    }

    public void setName(String name) {

        String oldName = this.getPrinterData().name;

        this.getPrinterData().name = name;

        firePropertyChange(PROPERTY_NAME, oldName, name);

    }

    public boolean isPrintToFile() {

        return getPrinterData().printToFile;

    }

    public void setPrintToFile(boolean printToFile) {

        boolean oldToFile = getPrinterData().printToFile;

        getPrinterData().printToFile = printToFile;

        firePropertyChange(PROPERTY_PRINT_TO_FILE, oldToFile, printToFile);

    }

    public String getFilePath() {

        return getPrinterData().fileName;

    }

    public void setFilePath(String filePath) {

        String oldPath = getPrinterData().fileName;

        getPrinterData().fileName = filePath;

        firePropertyChange(PROPERTY_FILE_PATH, oldPath, filePath);

    }

}