office-gobmx/drawinglayer
Armin Le Grand 75d9f7a433 Complete drawinglayer attributes
All DrawingLayer Atrributes used for ptimitives need a default
constructor. Since the o3tl::cow_wrapper is used in combination
with a static default incarnation of the impl class it is better
to define that. Also needed is a working isDefault() implementation
that compares the impl class to the static default. Added missing
stuff for this.

Change-Id: I98e9fee7343112cd979b972229423ac0ef3994a6
Reviewed-on: https://gerrit.libreoffice.org/24496
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Armin Le Grand <Armin.Le.Grand@cib.de>
2016-05-01 13:46:04 +00:00
..
inc/pch tdf#94306 remove unused boost dependencies 2016-04-13 19:47:09 +00:00
qa/unit drawinglayer, sw: indentation fixes 2016-04-19 13:55:47 +02:00
source Complete drawinglayer attributes 2016-05-01 13:46:04 +00:00
CppunitTest_drawinglayer_border.mk tdf#99315 VclPixelProcessor2D: fix double border line width 2016-04-18 19:06:39 +00:00
drawinglayer.component
Library_drawinglayer.mk
Makefile
Module_drawinglayer.mk Related: tdf#99315 BorderLinePrimitive2D: fix solid line primitive width 2016-04-15 14:46:00 +00:00
README

Drawing API that can specify what to draw via a kind of display list.

Example of the DrawingLayer use is eg. in svx/source/xoutdev/xtabhtch.cxx:121.
A stripped down version with extended comments:

     // Create a hatch primitive (here a rectangle that will be filled with
     // the appropriate hatching, but has no border).
     // This will not draw it yet; it's so far only constructed to add it to a
     // display list later.
     const drawinglayer::primitive2d::Primitive2DReference aHatchPrimitive(
         new drawinglayer::primitive2d::PolyPolygonHatchPrimitive2D(...));

     // Create a rectangle around the hatch, to give it a border.
     const drawinglayer::primitive2d::Primitive2DReference aBlackRectanglePrimitive(
         new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(...));

     // Here we want to render to a virtual device (to later obtain the bitmap
     // out of that), so prepare it.
     VirtualDevice aVirtualDevice;

     // Create processor and draw primitives, to get it ready for rendering.
     std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(
         drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice(...));

     if (pProcessor2D)
     {
         // Fill-in the display list.
         drawinglayer::primitive2d::Primitive2DSequence aSequence(2);

         aSequence[0] = aHatchPrimitive;
         aSequence[1] = aBlackRectanglePrimitive;

         // Render it to the virtual device.
         pProcessor2D->process(aSequence);
         pProcessor2D.reset();
     }

     // Obtain the bitmap that was rendered from the virtual device, to re-use
     // it in the widget.
     aRetval = aVirtualDevice.GetBitmap(Point(0, 0), aVirtualDevice.GetOutputSizePixel());

== DrawingLayer glossary ==

Primitives - classes that represent what should be drawn.  It holds the data
what to draw, but does not contain any kind of the rendering.  Some of the
primitives are 'Basic primitives', that are primitives that cannot be
decomposed.  The rest of the primitives can be decomposed to the basic
primitives.

Decomposition - a way how to break down the more complicated primitives into
the basic primitives, and represent them via them; this logically makes the
plain Primitive2DSequence display list a hierarchy.
Eg. PolygonMarkerPrimitive2D can be decomposed to 2 hairlines
PolyPolygonHairlinePrimitive2D's, each with different color.

Processor - a class that goes through the hierarchy of the Primitives, and
renders it some way.  Various processors, like VclPixelProcessor2D (renders to
the screen), VclMetafileProcessor2D (renders to the VCL metafile, eg. for
printing), etc.

== How to Implement a new Primitive ("something new to draw") ==

* Create an ancestor of BasePrimitive2D
  (or of its ancestor if it fits the purpose better)

  * Assign it an ID [in drawinglayer_primitivetypes2d.hxx]

  * Implement its decomposition
    [virtual Primitive2DSequence create2DDecomposition(...)]

* Extend the (various) processor(s)
  If you need more than relying on just the decomposition

== Where is DrawingLayer used ==

* SdrObject(s) (rectangles, Circles, predefined shapes etc.)

* Selections

* Various smaller cases to 'just draw something'

  * Draw to a virtual device, and use the resulting bitmap (like the example
    above)

* Custom widgets (like the Header / Footer indicator button)