Java tutorial
/* ****************************************************************************** * Copyright (c) 2006-2012 XMind Ltd. and others. * * This file is a part of XMind 3. XMind releases 3 and * above are dual-licensed under the Eclipse Public License (EPL), * which is available at http://www.eclipse.org/legal/epl-v10.html * and the GNU Lesser General Public License (LGPL), * which is available at http://www.gnu.org/licenses/lgpl.html * See http://www.xmind.net/license.html for details. * * Contributors: * XMind Ltd. - initial API and implementation *******************************************************************************/ package org.xmind.ui.internal.print.multipage; import java.lang.reflect.InvocationTargetException; import java.util.List; import java.util.Stack; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.draw2d.Graphics; import org.eclipse.draw2d.IFigure; import org.eclipse.draw2d.PositionConstants; import org.eclipse.draw2d.SWTGraphics; import org.eclipse.draw2d.geometry.Dimension; import org.eclipse.draw2d.geometry.Insets; import org.eclipse.draw2d.geometry.Point; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.jface.dialogs.IDialogSettings; import org.eclipse.jface.dialogs.MessageDialog; import org.eclipse.jface.dialogs.ProgressMonitorDialog; import org.eclipse.jface.operation.IRunnableWithProgress; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.swt.SWT; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Transform; import org.eclipse.swt.printing.Printer; import org.eclipse.swt.printing.PrinterData; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Shell; import org.xmind.gef.GEF; import org.xmind.gef.IGraphicalViewer; import org.xmind.gef.draw2d.RotatableWrapLabel; import org.xmind.gef.draw2d.graphics.Rotate90Graphics; import org.xmind.gef.image.FigureRenderer; import org.xmind.gef.image.IExportSourceProvider; import org.xmind.gef.util.Properties; import org.xmind.ui.internal.MindMapMessages; import org.xmind.ui.internal.print.PrintConstants; import org.xmind.ui.internal.print.PrintUtils; import org.xmind.ui.mindmap.GhostShellProvider; import org.xmind.ui.mindmap.IMindMap; import org.xmind.ui.mindmap.IMindMapViewer; import org.xmind.ui.mindmap.MindMapExportViewer; import org.xmind.ui.mindmap.MindMapUI; import org.xmind.ui.mindmap.MindMapViewerExportSourceProvider; import org.xmind.ui.resources.FontUtils; import org.xmind.ui.util.Logger; import org.xmind.ui.util.UnitConvertor; public class MultipagePrintClient extends FigureRenderer { private static class MindMapViewerPrintSourceProvider extends MindMapViewerExportSourceProvider { private IDialogSettings settings; public MindMapViewerPrintSourceProvider(IGraphicalViewer viewer, IDialogSettings settings) { super(viewer); this.settings = settings; } public MindMapViewerPrintSourceProvider(IGraphicalViewer viewer, int margins, IDialogSettings settings) { super(viewer, margins); this.settings = settings; } @Override protected void collectContents(List<IFigure> figures) { if (settings != null && !settings.getBoolean(PrintConstants.NO_BACKGROUND)) { figures.add(getViewer().getLayer(GEF.LAYER_BACKGROUND)); } figures.add(getViewer().getLayer(GEF.LAYER_CONTENTS)); figures.add(getViewer().getLayer(MindMapUI.LAYER_TITLE)); } } // private static final int TEXT_MARGIN = 5; private static final int TEXT_MARGIN = 0; private String jobName; private Shell parentShell; private PrinterData printerData; private IDialogSettings settings; private IMindMap sourceMap; private Printer printer; private Rectangle pageClientArea; private Point dpi; private IExportSourceProvider source; private boolean jobStarted = false; private Transform transform; public MultipagePrintClient(String jobName, Shell parentShell, PrinterData printerData, IDialogSettings settings) { this.jobName = jobName; this.parentShell = parentShell; this.printerData = printerData; this.settings = settings; } public void print(IMindMap sourceMap) { this.sourceMap = sourceMap; if (!start()) return; try { new ProgressMonitorDialog(Display.getCurrent().getActiveShell()).run(false, false, new IRunnableWithProgress() { public void run(final IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { parentShell.getDisplay().syncExec(new Runnable() { public void run() { print(monitor); } }); } }); } catch (InvocationTargetException e) { e.printStackTrace(); } catch (InterruptedException e) { e.printStackTrace(); } } private void print(IProgressMonitor monitor) { Properties properties = new Properties(); properties.set(IMindMapViewer.VIEWER_GRADIENT, Boolean.FALSE); //set plus minus visibility boolean plusVisible = getBoolean(settings, PrintConstants.PLUS_VISIBLE, PrintConstants.DEFAULT_PLUS_VISIBLE); boolean minusVisible = getBoolean(settings, PrintConstants.MINUS_VISIBLE, PrintConstants.DEFAULT_MINUS_VISIBLE); properties.set(IMindMapViewer.PLUS_VISIBLE, plusVisible); properties.set(IMindMapViewer.MINUS_VISIBLE, minusVisible); GhostShellProvider shell = new GhostShellProvider(parentShell.getDisplay()); IGraphicalViewer exportViewer = new MindMapExportViewer(shell, sourceMap, properties); source = new MindMapViewerPrintSourceProvider(exportViewer, 0, settings); setFigures(source.getContents()); int margin = PrintMultipageUtils.getMargin(source.getSourceArea()); setBounds(new Rectangle(source.getSourceArea()).expand(new Insets(margin))); internalPrint(monitor); } private boolean getBoolean(IDialogSettings settings, String key, boolean defaultValue) { boolean value = defaultValue; if (settings.get(key) != null) { value = settings.getBoolean(key); } return value; } private void internalPrint(IProgressMonitor monitor) { Rectangle bounds = getBounds(); int sourceWidth = bounds.width; int sourceHeight = bounds.height; int leftMarginPixel = PrintConstants .toPixel(getDouble(PrintConstants.LEFT_MARGIN, PrintConstants.DEFAULT_MARGIN)); int rightMarginPixel = PrintConstants .toPixel(getDouble(PrintConstants.RIGHT_MARGIN, PrintConstants.DEFAULT_MARGIN)); int topMarginPixel = PrintConstants .toPixel(getDouble(PrintConstants.TOP_MARGIN, PrintConstants.DEFAULT_MARGIN)); int bottomMarginPixel = PrintConstants .toPixel(getDouble(PrintConstants.BOTTOM_MARGIN, PrintConstants.DEFAULT_MARGIN)); //trim per page print content by header and footer height int headerHeight = PrintUtils.getHeaderHeight(settings, PrintConstants.DEFAULT_DPI); int footerHeight = PrintUtils.getBottomHeight(settings, PrintConstants.DEFAULT_DPI); //Calculate the actual needed printed content of the each page according to the default paper size(A4) //Then use the print content to fit different actual paper size int orientation = getInteger(PrintConstants.ORIENTATION, PrintConstants.DEFAULT_ORIENTATION); int perPageWidth = orientation == PrinterData.LANDSCAPE ? PrintConstants.PAGE_LENGTH : PrintConstants.PAGE_SHORT; int usefulPerPageWidth = perPageWidth - leftMarginPixel - rightMarginPixel; int perPageHeight = orientation == PrinterData.PORTRAIT ? PrintConstants.PAGE_LENGTH : PrintConstants.PAGE_SHORT; int usefulPerPageHeight = perPageHeight - topMarginPixel - bottomMarginPixel; usefulPerPageHeight -= headerHeight + footerHeight; int widthPages = getInteger(PrintConstants.WIDTH_PAGES, 1); int heightPages = getInteger(PrintConstants.HEIGHT_PAGES, 1); boolean isAspectRatio = settings.getBoolean(PrintConstants.ASPECT_RATIO_LOCKED); boolean fullWidth = !settings.getBoolean(PrintConstants.FILL_HEIGHT); if (!isAspectRatio) { double fillWidthratio = (double) usefulPerPageWidth * widthPages / sourceWidth; double fillHeightRatio = (double) usefulPerPageHeight * heightPages / sourceHeight; fullWidth = (fillWidthratio <= fillHeightRatio) ? true : false; } double ratio = fullWidth ? ((double) usefulPerPageWidth * widthPages / sourceWidth) : ((double) usefulPerPageHeight * heightPages / sourceHeight); //The actual needed printed content of the each page calculated by the default paper size(A4) int usefulPerPageWidthByRatio = (int) (usefulPerPageWidth / ratio); int usefulPerPageHeightByRatio = (int) (usefulPerPageHeight / ratio); int usefulWidthPages = widthPages; int usefulHeightPages = heightPages; if (fullWidth) { usefulHeightPages = sourceHeight / usefulPerPageHeightByRatio; usefulHeightPages = (sourceHeight % usefulPerPageHeightByRatio == 0) ? usefulHeightPages : usefulHeightPages + 1; } else { usefulWidthPages = sourceWidth / usefulPerPageWidthByRatio; usefulWidthPages = (sourceWidth % usefulPerPageWidthByRatio == 0) ? usefulWidthPages : usefulWidthPages + 1; } //use the print content to fit different actual paper size //actual scale double widthScale = (double) pageClientArea.width / usefulPerPageWidthByRatio; double heightScale = (double) pageClientArea.height / usefulPerPageHeightByRatio; double scale = widthScale < heightScale ? widthScale : heightScale; setScale(scale); //Center then actual printing content after adapting it //page origin int originX = (int) (pageClientArea.width - usefulPerPageWidthByRatio * scale) / 2 + pageClientArea.x; int originY = (int) (pageClientArea.height - usefulPerPageHeightByRatio * scale) / 2 + pageClientArea.y; Rectangle realPageClientArea = new Rectangle(originX, originY, (int) (usefulPerPageWidthByRatio * scale), (int) (usefulPerPageHeightByRatio * scale)); monitor.beginTask(MindMapMessages.MultipagePrint_Printing, widthPages * heightPages); for (int j = 0; j < heightPages; j++) { int y = j * usefulPerPageHeightByRatio; for (int i = 0; i < widthPages; i++) { int x = i * usefulPerPageWidthByRatio; int pageNumber = j * widthPages + i + 1; boolean isValidPage = i < usefulWidthPages && j < usefulHeightPages; render(realPageClientArea, new Point(-x, -y), pageNumber, isValidPage); monitor.worked(1); } } monitor.done(); } private void render(Rectangle realPageClientArea, final Point origin, int pageNumber, boolean isValidPage) { if (!printer.startPage()) { return; } pageClientArea = new Rectangle(realPageClientArea); GC gc = new GC(printer); try { if (isValidPage) { pushState(gc); render(gc, origin); popState(gc); } //remove clipping gc.setClipping((org.eclipse.swt.graphics.Rectangle) null); String headerText = settings.get(PrintConstants.HEADER_TEXT); if (headerText != null && !"".equals(headerText)) { //$NON-NLS-1$ drawHeader(gc, headerText); } String footerText = settings.get(PrintConstants.FOOTER_TEXT); if (footerText != null && !"".equals(footerText)) { //$NON-NLS-1$ drawFooter(gc, footerText); } //remove clipping gc.setClipping((org.eclipse.swt.graphics.Rectangle) null); //draw border using adapted bounds boolean hasBorder = settings.getBoolean(PrintConstants.BORDER); if (hasBorder) { gc.setLineWidth(1); gc.setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK)); gc.drawRectangle(pageClientArea.x - 1, pageClientArea.y - 1, pageClientArea.width + 2, pageClientArea.height + 2); } //draw page number drawPageNumber(gc, "- " + pageNumber + " -"); //$NON-NLS-1$ //$NON-NLS-2$ } finally { gc.dispose(); } printer.endPage(); } private void pushState(GC gc) { Transform tempTransform = new Transform(gc.getDevice()); gc.getTransform(tempTransform); float[] elements = new float[6]; tempTransform.getElements(elements); if (transform != null && !transform.isDisposed()) { transform.dispose(); } transform = new Transform(gc.getDevice(), elements); tempTransform.dispose(); } private void popState(GC gc) { gc.setTransform(transform); } private void drawHeader(GC gc, String text) { Font font = getFont(PrintConstants.HEADER_FONT); try { drawText(gc, text, font, getAlign(PrintConstants.HEADER_ALIGN, PositionConstants.CENTER), true); } finally { font.dispose(); } } private void drawFooter(GC gc, String text) { Font font = getFont(PrintConstants.FOOTER_FONT); try { drawText(gc, text, font, getAlign(PrintConstants.FOOTER_ALIGN, PositionConstants.RIGHT), false); } finally { font.dispose(); } } private void drawPageNumber(GC gc, String text) { int footerAlign = getAlign(PrintConstants.FOOTER_ALIGN, PositionConstants.RIGHT); int pageNumberAlign = (footerAlign == PositionConstants.CENTER ? PositionConstants.RIGHT : PositionConstants.CENTER); drawPageNumber(gc, text, pageNumberAlign); } private Font getFont(String fontKey) { Font font = null; String fontValue = settings.get(fontKey); if (fontValue != null) { FontData[] fontData = FontUtils.toFontData(fontValue); if (fontData != null) { for (FontData fd : fontData) { fd.setHeight(fd.getHeight() * dpi.y / UnitConvertor.getScreenDpi().y); } font = new Font(Display.getCurrent(), fontData); } } if (font == null) { FontData[] defaultFontData = JFaceResources.getDefaultFontDescriptor().getFontData(); int defaultHeight = defaultFontData[0].getHeight(); font = new Font(Display.getCurrent(), FontUtils.newHeight(defaultFontData, defaultHeight * dpi.y / UnitConvertor.getScreenDpi().y)); } return font; } private int getAlign(String alignKey, int defaultAlign) { return PrintConstants.toDraw2DAlignment(settings.get(alignKey), defaultAlign); } private void drawText(GC gc, String text, Font font, int alignment, boolean top) { RotatableWrapLabel label = new RotatableWrapLabel(); label.setText(text); label.setFont(font); label.setTextAlignment(alignment); label.setForegroundColor(parentShell.getDisplay().getSystemColor(SWT.COLOR_BLACK)); int width = pageClientArea.width; int marginWidth = TEXT_MARGIN * dpi.x / UnitConvertor.getScreenDpi().x; width -= marginWidth * 2; Dimension size = label.getPreferredSize(width, -1); int x = -width / 2; org.eclipse.swt.graphics.Rectangle pageBounds = printer.getClientArea(); int y; if (top) { y = -pageClientArea.height / 2 - (pageClientArea.y - pageBounds.y) + Math.max((pageClientArea.y - pageBounds.y - size.height) / 2, marginWidth); } else { y = pageClientArea.height / 2 + (pageBounds.y + pageBounds.height - (pageClientArea.y + pageClientArea.height)) - size.height - Math.max((pageBounds.y + pageBounds.height - (pageClientArea.y + pageClientArea.height) - size.height) / 2, marginWidth); } label.setBounds(new Rectangle(x, y, width, size.height)); SWTGraphics baseGraphics = new SWTGraphics(gc); baseGraphics.translate(pageClientArea.x + pageClientArea.width / 2, pageClientArea.y + pageClientArea.height / 2); Graphics graphics = baseGraphics; Rotate90Graphics rotatedGraphics = null; try { label.paint(graphics); } catch (Throwable e) { Logger.log(e, "Error occurred while printing"); //$NON-NLS-1$ } finally { if (rotatedGraphics != null) { rotatedGraphics.dispose(); } baseGraphics.dispose(); } } private void drawPageNumber(GC gc, String text, int alignment) { RotatableWrapLabel label = new RotatableWrapLabel(); label.setText(text); Font font = Display.getCurrent().getSystemFont(); font = FontUtils.getNewHeight(font, (font.getFontData())[0].getHeight() * dpi.y / UnitConvertor.getScreenDpi().y); label.setFont(font); label.setTextAlignment(alignment); label.setForegroundColor(parentShell.getDisplay().getSystemColor(SWT.COLOR_BLACK)); Rectangle pageBounds = new Rectangle(printer.getClientArea()); int width = pageClientArea.width; int marginWidth = TEXT_MARGIN * dpi.x / UnitConvertor.getScreenDpi().x; width -= marginWidth * 2; Dimension size = label.getPreferredSize(width, -1); int x = -width / 2; int y = pageBounds.height / 2 - size.height - Math.max( (pageBounds.y + pageBounds.height - (pageClientArea.y + pageClientArea.height) - size.height) / 2, marginWidth); label.setBounds(new Rectangle(x, y, width, size.height)); SWTGraphics baseGraphics = new SWTGraphics(gc); baseGraphics.translate(pageBounds.x + pageBounds.width / 2, pageBounds.y + pageBounds.height / 2); Graphics graphics = baseGraphics; Rotate90Graphics rotatedGraphics = null; try { label.paint(graphics); } catch (Throwable e) { Logger.log(e, "Error occurred while printing"); //$NON-NLS-1$ } finally { if (rotatedGraphics != null) { rotatedGraphics.dispose(); } baseGraphics.dispose(); } } private boolean start() { if (printer == null) { printer = new Printer(printerData); } receivePrinterInfo(); if (pageClientArea.width <= 0 || pageClientArea.height <= 0) { Display.getCurrent().asyncExec(new Runnable() { public void run() { MessageDialog.openInformation(Display.getDefault().getActiveShell(), MindMapMessages.MultipagePrint_InvalidMargin_title, MindMapMessages.MultipagePrint_InvalidMargin_message); } }); return false; } if (!jobStarted) { if (!printer.startJob(jobName)) return false; jobStarted = true; } return jobStarted; } private void receivePrinterInfo() { dpi = new Point(printer.getDPI()); pageClientArea = new Rectangle(printer.getClientArea()); int leftMargin = getUserMargin(PrintConstants.LEFT_MARGIN); int rightMargin = getUserMargin(PrintConstants.RIGHT_MARGIN); int topMargin = getUserMargin(PrintConstants.TOP_MARGIN); int bottomMargin = getUserMargin(PrintConstants.BOTTOM_MARGIN); pageClientArea.x += leftMargin; pageClientArea.y += topMargin; pageClientArea.width -= leftMargin + rightMargin; pageClientArea.height -= topMargin + bottomMargin; //trim clientArea by header and footer height int headerHeight = PrintUtils.getHeaderHeight(settings, dpi.y); int footerHeight = PrintUtils.getBottomHeight(settings, dpi.y); pageClientArea.expand(new Insets(-headerHeight, 0, -footerHeight, 0)); } private int getUserMargin(String key) { double marginInch; try { marginInch = settings.getDouble(key); } catch (NumberFormatException e) { marginInch = PrintConstants.DEFAULT_MARGIN; } double dpi; if (PrintConstants.LEFT_MARGIN.equals(key) || PrintConstants.RIGHT_MARGIN.equals(key)) { dpi = this.dpi.x; } else { dpi = this.dpi.y; } return (int) (marginInch * dpi); } public void dispose() { if (printer != null) { if (!printer.isDisposed()) { printer.endJob(); } printer.dispose(); printer = null; } jobStarted = false; if (transform != null) { transform.dispose(); } } protected void createGraphics(Graphics graphics, Stack<Graphics> stack) { graphics.clipRect( new Rectangle(pageClientArea.x, pageClientArea.y, pageClientArea.width, pageClientArea.height)); graphics.translate(pageClientArea.x, pageClientArea.y); if (getScale() > 0) { graphics.scale(getScale()); stack.push(graphics); } Rectangle bounds = getBounds(); graphics.translate(-bounds.x, -bounds.y); } private double getDouble(String key, double defaultValue) { try { return settings.getDouble(key); } catch (NumberFormatException e) { } return defaultValue; } private int getInteger(String key, int defaultValue) { try { return settings.getInt(key); } catch (NumberFormatException e) { } return defaultValue; } }