bundles/org.simantics.diagram/src/org/simantics/diagram/export/ExportDiagramPdf.java

   1 package org.simantics.diagram.export;
   2
   3 import java.awt.Graphics2D;
   4 import java.awt.RenderingHints;
   5 import java.awt.geom.Rectangle2D;
   6 import java.util.Collection;
   7 import java.util.Collections;
   8 import java.util.List;
   9
  10 import org.eclipse.core.runtime.IProgressMonitor;
  11 import org.eclipse.core.runtime.OperationCanceledException;
  12 import org.osgi.service.prefs.Preferences;
  13 import org.simantics.databoard.Accessors;
  14 import org.simantics.databoard.accessor.RecordAccessor;
  15 import org.simantics.databoard.accessor.UnionAccessor;
  16 import org.simantics.databoard.accessor.error.AccessorConstructionException;
  17 import org.simantics.databoard.accessor.error.AccessorException;
  18 import org.simantics.databoard.accessor.reference.ChildReference;
  19 import org.simantics.databoard.accessor.reference.LabelReference;
  20 import org.simantics.databoard.binding.mutable.Variant;
  21 import org.simantics.databoard.type.RecordType;
  22 import org.simantics.databoard.type.UnionType;
  23 import org.simantics.db.Resource;
  24 import org.simantics.db.common.ResourceArray;
  25 import org.simantics.db.common.primitiverequest.SingleObject;
  26 import org.simantics.db.common.request.Queries;
  27 import org.simantics.db.exception.DatabaseException;
  28 import org.simantics.db.layer0.request.PossibleModel;
  29 import org.simantics.db.layer0.util.SessionGarbageCollection;
  30 import org.simantics.diagram.elements.DiagramNodeUtil;
  31 import org.simantics.diagram.query.DiagramRequests;
  32 import org.simantics.diagram.stubs.DiagramResource;
  33 import org.simantics.export.core.ExportContext;
  34 import org.simantics.export.core.error.ExportException;
  35 import org.simantics.export.core.intf.ExportClass;
  36 import org.simantics.export.core.manager.Content;
  37 import org.simantics.export.core.pdf.ExportPdfWriter;
  38 import org.simantics.export.core.pdf.ExportPdfWriter.Page;
  39 import org.simantics.export.core.util.ExportQueries;
  40 import org.simantics.export.core.util.ExporterUtils;
  41 import org.simantics.g2d.canvas.Hints;
  42 import org.simantics.g2d.canvas.ICanvasContext;
  43 import org.simantics.g2d.canvas.impl.CanvasContext;
  44 import org.simantics.g2d.diagram.DiagramHints;
  45 import org.simantics.g2d.diagram.DiagramUtils;
  46 import org.simantics.g2d.diagram.IDiagram;
  47 import org.simantics.g2d.participant.TransformUtil;
  48 import org.simantics.g2d.scenegraph.ICanvasSceneGraphProvider;
  49 import org.simantics.layer0.Layer0;
  50 import org.simantics.modeling.ModelingResources;
  51 import org.simantics.modeling.template2d.ontology.Template2dResource;
  52 import org.simantics.scenegraph.g2d.G2DPDFRenderingHints;
  53 import org.simantics.scenegraph.g2d.G2DRenderingHints;
  54 import org.simantics.scenegraph.utils.QualityHints;
  55 import org.simantics.simulation.ontology.SimulationResource;
  56 import org.simantics.structural.stubs.StructuralResource2;
  57 import org.simantics.structural2.StructuralVariables;
  58 import org.simantics.utils.datastructures.MapList;
  59 import org.simantics.utils.page.MarginUtils;
  60 import org.simantics.utils.page.MarginUtils.Margins;
  61 import org.simantics.utils.page.PageDesc;
  62 import org.simantics.utils.threads.ThreadUtils;
  63 import org.simantics.utils.threads.WorkerThread;
  64
  65 import com.kitfox.svg.SVGCache;
  66
  67 public class ExportDiagramPdf implements ExportClass {
  68
  69         public static LabelReference P_DIAGRAM_OPTIONS = new LabelReference("Diagram Options");
  70         public static String S_CONTENT_FIT = "Content Fit";
  71         public static ChildReference P_CONTENT_FIT = ChildReference.parsePath("Diagram Options/"+S_CONTENT_FIT);
  72         public static String S_PAGE_SIZE = "Page Size";
  73         public static ChildReference P_PAGE_SIZE = ChildReference.parsePath("Diagram Options/"+S_PAGE_SIZE);
  74
  75         // Diagram export options
  76         RecordType deo, options;
  77         UnionType contentUt, pageUt;
  78
  79         public ExportDiagramPdf() {
  80         options = new RecordType();
  81             deo = new RecordType();
  82                 contentUt = UnionType.newEnum("Use the diagram specific borders", "Fit page by its contents");
  83                 pageUt = UnionType.newEnum("Use the page size from this wizard", "Use diagram specific page sizes");
  84         deo.addComponent(S_CONTENT_FIT, contentUt);
  85         deo.addComponent(S_PAGE_SIZE, pageUt);
  86         options.addComponent(P_DIAGRAM_OPTIONS.label, deo);
  87         }
  88
  89         @Override
  90         public RecordType options(ExportContext context, Collection<String> content) throws ExportException {
  91                 return options;
  92         }
  93
  94         @Override
  95         public void fillDefaultPrefs(ExportContext ctx, Variant options) throws ExportException {
  96                 try {
  97                         RecordAccessor ra = Accessors.getAccessor(options);
  98                         ExporterUtils.setUnionValue(ra, P_CONTENT_FIT, 0);
  99                         ExporterUtils.setUnionValue(ra, P_PAGE_SIZE, 1);
 100                 } catch (AccessorConstructionException e) {
 101                 }
 102         }
 103
 104         @Override
 105         public void export(List<Content> contents,
 106                         Object handle,
 107                         ExportContext ctx,
 108                         Variant options,
 109                         IProgressMonitor monitor,
 110                         MapList<Content, Content> attachmentMap
 111                         ) throws ExportException {
 112
 113                 final ExportPdfWriter writer = (ExportPdfWriter) handle;
 114
 115         WorkerThread workerThread = new WorkerThread("Diagram PDF Painter");
 116         workerThread.start();
 117
 118                 Page page = null;
 119                 try {
 120                         ModelingResources MOD = ModelingResources.getInstance( ctx.session );
 121                         SimulationResource SIMU = SimulationResource.getInstance( ctx.session );
 122                         StructuralResource2 STR = StructuralResource2.getInstance( ctx.session );
 123                         DiagramResource DIA = DiagramResource.getInstance( ctx.session );
 124                         final Template2dResource TMPL = Template2dResource.getInstance( ctx.session );
 125                         Layer0 L0 = Layer0.getInstance( ctx.session );
 126
 127                         for ( Content content : contents ) {
 128                                 if (monitor.isCanceled())
 129                                         throw new OperationCanceledException();
 130
 131                                 // Diagram's composite resource
 132                                 Resource resource = ctx.session.syncRequest( ExportQueries.toResource(content.url) );
 133                                 boolean isComposite = ctx.session.syncRequest( Queries.isInstanceOf(resource, STR.Composite) );
 134                                 if ( !isComposite ) {
 135                                         resource = ctx.session.syncRequest( Queries.possibleObjectWithType(resource, L0.ConsistsOf, STR.Composite) );
 136                                         isComposite = ctx.session.syncRequest( Queries.isInstanceOf(resource, STR.Composite) );
 137                                 }
 138                                 if ( !isComposite ) {
 139                                         throw new ExportException(content.url+" doesnt contain a diagram.");
 140                                 }
 141                                 final Resource composite = resource;
 142                                 final Resource diagram = ctx.session.syncRequest( new SingleObject( composite, MOD.CompositeToDiagram ) );
 143                                 final Resource drawingTemplate = ctx.session.syncRequest( Queries.possibleObject( diagram, TMPL.HasDrawingTemplate ) );
 144                                 final Resource activeProfile = ctx.session.syncRequest( Queries.possibleObject( diagram, DIA.HasActiveProfile ) );
 145                                 final Collection<Resource> activeProfileEntries = activeProfile != null ? ctx.session.syncRequest( Queries.objects(activeProfile, SIMU.IsActive) ) : Collections.<Resource>emptyList();
 146                                 final Resource model = ctx.session.syncRequest( new PossibleModel( composite ) );
 147                                 if ( model==null ) throw new ExportException("Cannot export diagram. Model was not found.");
 148                                 final String diagramName = content.label;
 149
 150                         ResourceArray compositePath = StructuralVariables.getCompositeArray(ctx.session, composite);
 151                         ResourceArray variablePath = compositePath.removeFromBeginning(1);
 152                         final String modelRVI = StructuralVariables.getRVI(ctx.session, variablePath);
 153
 154                         // PageDesc, Read page desc from the graph
 155                                 int tag = getPageFitArea(options);
 156                                 PageDesc diagramPageDesc = ctx.session.syncRequest( DiagramRequests.getPageDesc(diagram, writer.defaultPageDesc));
 157                                 PageDesc wizardPageDesc = writer.defaultPageDesc;
 158                                 PageDesc marginaaliViiva = diagramPageDesc;
 159
 160                                 // Close previous page before starting a new one.
 161                                 if (page != null) {
 162                                         page.close();
 163                                         page = null;
 164                                 }
 165
 166                                 if ( tag == 0 ) {
 167                                         // top,left margin translation is applied to G2D on createGraphics(..)
 168                                         page = writer.createPage( wizardPageDesc );
 169                                         marginaaliViiva = diagramPageDesc;
 170                                 } else {
 171                                         marginaaliViiva = diagramPageDesc;
 172                                         page = writer.createPage( diagramPageDesc );
 173                                 }
 174                                 final PageDesc _marginaaliViiva = marginaaliViiva;
 175                                 final PageDesc _diagramPageDesc = diagramPageDesc;
 176                                 final Page _page = page;
 177                                 final boolean fitDiagramContentsToPageMargins = getContentFitArea(options) == 1;
 178
 179                         final CanvasContext cctx = new CanvasContext( workerThread );
 180                         final Exception[] errors = new Exception[1];
 181                 final ICanvasSceneGraphProvider provider = DiagramNodeUtil.loadSceneGraphProvider(cctx, model, diagram, modelRVI);
 182
 183                 ThreadUtils.syncExec(workerThread, new Runnable() {
 184                     @Override
 185                     public void run() {
 186                                 try {
 187                                         cctx.getDefaultHintContext().setHint(Hints.KEY_PAGE_DESC, _marginaaliViiva);
 188
 189                                         String bottomLabel = diagramName;
 190                                         if ( drawingTemplate != null && activeProfileEntries.contains(TMPL.DrawingTemplate) ) bottomLabel = null;
 191
 192                                 paint(cctx, writer, _page, fitDiagramContentsToPageMargins, bottomLabel, _diagramPageDesc);
 193 //                        } catch (DatabaseException e) {
 194 //                              errors[0] = e;
 195 //                                              } catch (InterruptedException e) {
 196 //                              errors[0] = e;
 197                                                 } finally {
 198                                 provider.dispose();
 199                                 cctx.dispose();
 200                         }
 201                     }
 202                 });
 203                         if ( errors[0] != null ) {
 204                                 throw new ExportException( errors[0] );
 205                         }
 206
 207
 208                         // Add page specific attachments
 209                                 if ( attachmentMap!=null ) {
 210                                         List<Content> ats = attachmentMap.getValues(content);
 211                                         if ( ats != null ) for ( Content at : ats ) page.addAttachment(at);
 212                                 }
 213                         }
 214
 215                         // These still have to be done to keep memory consumption down
 216                         // and avoid OOMs.
 217                         SVGCache.getSVGUniverse().clearUnreferenced();
 218                         SessionGarbageCollection.gc(null, writer.ctx.session, true, null);
 219                         System.gc();
 220
 221                 } catch (DatabaseException e) {
 222                         throw new ExportException( e.getClass().getName()+": "+e.getMessage(), e );
 223                 } catch (InterruptedException e) {
 224                         throw new ExportException( e.getClass().getName()+": "+e.getMessage(), e );
 225                 } finally {
 226                         if ( workerThread!=null ) workerThread.stopDispatchingEvents(true);
 227                         if ( page!=null ) page.close();
 228                 }
 229
 230         }
 231
 232
 233     public void paint(ICanvasContext canvasContext, ExportPdfWriter writer, Page page, boolean fitDiagramContentsToPageMargins, String diagramName, PageDesc diagramPageDesc) {
 234         // Specify rendering template size in points.
 235         Graphics2D g2 = page.createGraphics(false);
 236         try {
 237             QualityHints.HIGH_QUALITY_HINTS.setQuality(g2);
 238                 g2.setRenderingHint(G2DPDFRenderingHints.KEY_EXPORT_PDF_WRITER, writer);
 239                 g2.setRenderingHint(G2DPDFRenderingHints.KEY_PDF_WRITER, writer.pdfCopy);
 240                 g2.setRenderingHint(G2DPDFRenderingHints.KEY_PDF_BYTECONTENT, writer.cb);
 241                 g2.setRenderingHint(G2DPDFRenderingHints.KEY_PDF_FONTMAPPER, writer.fontMapper);
 242             g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
 243
 244                 // Page size in mm
 245                 double pw = page.pageDesc.getWidth();
 246                 double ph = page.pageDesc.getHeight();
 247                 // Drawable area size in mm
 248                 double w = page.getWidth();
 249                 double h = page.getHeight();
 250
 251             // Get margins in mm
 252             if (fitDiagramContentsToPageMargins) {
 253                 Rectangle2D controlArea = new Rectangle2D.Double(0, 0, w, h);
 254                 IDiagram diagram = canvasContext.getDefaultHintContext().getHint(DiagramHints.KEY_DIAGRAM);
 255                 final Rectangle2D diagramRect = DiagramUtils.getContentRect(diagram);
 256                 if (diagramRect != null) {
 257                     canvasContext.getSingleItem(TransformUtil.class).fitArea(controlArea, diagramRect, MarginUtils.NO_MARGINS);
 258                 }
 259             }
 260
 261             /// Margins
 262             // Margin differences
 263             Margins diagramMargins = diagramPageDesc.getMargins();
 264             Margins wizardMargins = page.pageDesc.getMargins();
 265
 266             g2.translate( wizardMargins.left.diagramAbsolute, wizardMargins.top.diagramAbsolute);
 267
 268             double diagramPageWidth  = diagramPageDesc.getOrientedWidth();
 269             double diagramPageHeight = diagramPageDesc.getOrientedHeight();
 270
 271             double wizardPageWidth = page.pageDesc.getOrientedWidth();
 272             double wizardPageHeight = page.pageDesc.getOrientedHeight();
 273
 274             double diagramContentWidth  = diagramPageDesc.getOrientedWidth() - diagramMargins.left.diagramAbsolute - diagramMargins.right.diagramAbsolute;
 275             double diagramContentHeight = diagramPageDesc.getOrientedHeight() - diagramMargins.top.diagramAbsolute - diagramMargins.bottom.diagramAbsolute;
 276
 277             double wizardContentWidth = page.pageDesc.getOrientedWidth() - wizardMargins.left.diagramAbsolute - wizardMargins.right.diagramAbsolute;
 278             double wizardContentHeight = page.pageDesc.getOrientedHeight() - wizardMargins.top.diagramAbsolute - wizardMargins.bottom.diagramAbsolute;
 279
 280             if ( diagramContentWidth!=wizardContentWidth || diagramContentHeight!=wizardContentHeight ) {
 281                 double r1 = wizardContentWidth / diagramContentWidth;
 282                 double r2 = wizardContentHeight / diagramContentHeight;
 283                 double r = Math.min(r1, r2);
 284                 if ( r1 < r2 ) {
 285                         g2.translate(0, wizardContentHeight/2);
 286                 } else {
 287                         g2.translate( wizardContentWidth/2, 0);
 288                 }
 289                 g2.scale(r, r);
 290                 if ( r1 < r2 ) {
 291                         g2.translate(0, -diagramContentHeight/ 2);
 292                 } else {
 293                         g2.translate(-diagramContentWidth/ 2, 0);
 294                 }
 295             }
 296             g2.translate( -diagramMargins.left.diagramAbsolute, -diagramMargins.top.diagramAbsolute);
 297             g2.setRenderingHint(G2DRenderingHints.KEY_CONTROL_BOUNDS, new Rectangle2D.Double(0, 0, w, h));
 298
 299             if (canvasContext.isLocked())
 300                 throw new IllegalStateException("cannot render PDF, canvas context is locked: " + canvasContext);
 301
 302             canvasContext.getSceneGraph().render(g2);
 303
 304 //            // Write diagram name
 305 //            if ( diagramName != null ) {
 306 //                  g2.setColor(Color.black);
 307 //                  java.awt.Font arial = new java.awt.Font("Arial", java.awt.Font.ITALIC, 3);
 308 //                  g2.setFont(arial);
 309 //                  FontMetrics metrics = g2.getFontMetrics();
 310 //                  int width = metrics.stringWidth(diagramName);
 311 ////                System.out.println(diagramName + ", w: " + w + ", width: " + width);
 312 ////                System.out.println(diagramName + ", wizardPageHeight: " + wizardPageHeight + ", wizardMargins: " + wizardMargins);
 313 ////                System.out.println(PageDesc.toPoints(1));
 314 //                  float x = (float) ((w - width) / 2);
 315 //                  float y = (float) (wizardPageHeight - wizardMargins.bottom.diagramAbsolute - PageDesc.toPoints(1));
 316 //                  g2.drawString(diagramName, x, y);
 317 ////                System.out.println(diagramName + ", X: " + x + ", Y: " + y);
 318 //            }
 319
 320         } finally {
 321             g2.dispose();
 322         }
 323     }
 324
 325
 326         @Override
 327         public void savePref(Variant options, Preferences contentScopeNode, Preferences workbenchScopeNode) throws ExportException {
 328                 int tag = getContentFitArea(options);
 329                 if ( tag>=0 ) contentScopeNode.putInt(S_CONTENT_FIT, tag);
 330
 331                 tag = getPageFitArea(options);
 332                 if ( tag>=0 ) contentScopeNode.putInt(S_PAGE_SIZE, tag);
 333         }
 334
 335         @Override
 336         public void loadPref(Variant options, Preferences contentScopeNode, Preferences workbenchScopeNode) throws ExportException {
 337                 try {
 338                         RecordAccessor ra = Accessors.getAccessor(options);
 339
 340                         int tag = contentScopeNode.getInt(S_CONTENT_FIT, -1);
 341                         if ( tag>=0 ) ExporterUtils.setUnionValue(ra, P_CONTENT_FIT, tag);
 342
 343                         tag = contentScopeNode.getInt(S_PAGE_SIZE, -1);
 344                         if ( tag>=0 ) ExporterUtils.setUnionValue(ra, P_PAGE_SIZE, tag);
 345
 346                 } catch (AccessorConstructionException e) {
 347                 }
 348         }
 349
 350         @Override
 351         public List<String> validate(String contentUri, ExportContext context, Variant options) {
 352                 return Collections.emptyList();
 353         }
 354
 355         public static int getContentFitArea(Variant options) {
 356                 try {
 357                         RecordAccessor ra = Accessors.getAccessor(options);
 358                         UnionAccessor ua = ra.getComponent(P_CONTENT_FIT);
 359                         return ua.getTag();
 360                 } catch (AccessorConstructionException e) {
 361                         return -1;
 362                 } catch (AccessorException e) {
 363                         return -1;
 364                 }
 365         }
 366
 367         public static int getPageFitArea(Variant options) {
 368                 try {
 369                         RecordAccessor ra = Accessors.getAccessor(options);
 370                         UnionAccessor ua = ra.getComponent(P_PAGE_SIZE);
 371                         return ua.getTag();
 372                 } catch (AccessorConstructionException e) {
 373                         return -1;
 374                 } catch (AccessorException e) {
 375                         return -1;
 376                 }
 377         }
 378
 379 }