drawinglayer/source/processor2d/textaspolygonextractor2d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
  21 #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
  22 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  23 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
  24 #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
  25 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  26
  27
  28 namespace drawinglayer
  29 {
  30     namespace processor2d
  31     {
  32         void TextAsPolygonExtractor2D::processBasePrimitive2D(const primitive2d::BasePrimitive2D& rCandidate)
  33         {
  34             switch(rCandidate.getPrimitive2DID())
  35             {
  36                 case PRIMITIVE2D_ID_TEXTDECORATEDPORTIONPRIMITIVE2D :
  37                 {
  38                     // TextDecoratedPortionPrimitive2D can produce the following primitives
  39                     // when being decomposed:
  40                     //
  41                     // - TextSimplePortionPrimitive2D
  42                     // - PolygonWavePrimitive2D
  43                     //      - PolygonStrokePrimitive2D
  44                     // - PolygonStrokePrimitive2D
  45                     //      - PolyPolygonColorPrimitive2D
  46                     //      - PolyPolygonHairlinePrimitive2D
  47                     //          - PolygonHairlinePrimitive2D
  48                     // - ShadowPrimitive2D
  49                     //      - ModifiedColorPrimitive2D
  50                     //      - TransformPrimitive2D
  51                     // - TextEffectPrimitive2D
  52                     //      - ModifiedColorPrimitive2D
  53                     //      - TransformPrimitive2D
  54                     //      - GroupPrimitive2D
  55
  56                     // encapsulate with flag and use decomposition
  57                     mnInText++;
  58                     process(rCandidate.get2DDecomposition(getViewInformation2D()));
  59                     mnInText--;
  60
  61                     break;
  62                 }
  63                 case PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D :
  64                 {
  65                     // TextSimplePortionPrimitive2D can produce the following primitives
  66                     // when being decomposed:
  67                     //
  68                     // - PolyPolygonColorPrimitive2D
  69                     // - TextEffectPrimitive2D
  70                     //      - ModifiedColorPrimitive2D
  71                     //      - TransformPrimitive2D
  72                     //      - GroupPrimitive2D
  73
  74                     // encapsulate with flag and use decomposition
  75                     mnInText++;
  76                     process(rCandidate.get2DDecomposition(getViewInformation2D()));
  77                     mnInText--;
  78
  79                     break;
  80                 }
  81
  82                 // as can be seen from the TextSimplePortionPrimitive2D and the
  83                 // TextDecoratedPortionPrimitive2D, inside of the mnInText marks
  84                 // the following primitives can occur containing geometry data
  85                 // from text decomposition:
  86                 //
  87                 // - PolyPolygonColorPrimitive2D
  88                 // - PolygonHairlinePrimitive2D
  89                 // - PolyPolygonHairlinePrimitive2D (for convenience)
  90                 //
  91                 case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D :
  92                 {
  93                     if(mnInText)
  94                     {
  95                         const primitive2d::PolyPolygonColorPrimitive2D& rPoPoCoCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate));
  96                         basegfx::B2DPolyPolygon aPolyPolygon(rPoPoCoCandidate.getB2DPolyPolygon());
  97
  98                         if(aPolyPolygon.count())
  99                         {
 100                             // transform the PolyPolygon
 101                             aPolyPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
 102
 103                             // get evtl. corrected color
 104                             const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoPoCoCandidate.getBColor()));
 105
 106                             // add to result vector
 107                             maTarget.push_back(TextAsPolygonDataNode(aPolyPolygon, aColor, true));
 108                         }
 109                     }
 110
 111                     break;
 112                 }
 113                 case PRIMITIVE2D_ID_POLYGONHAIRLINEPRIMITIVE2D :
 114                 {
 115                     if(mnInText)
 116                     {
 117                         const primitive2d::PolygonHairlinePrimitive2D& rPoHaCandidate(static_cast< const primitive2d::PolygonHairlinePrimitive2D& >(rCandidate));
 118                         basegfx::B2DPolygon aPolygon(rPoHaCandidate.getB2DPolygon());
 119
 120                         if(aPolygon.count())
 121                         {
 122                             // transform the Polygon
 123                             aPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
 124
 125                             // get evtl. corrected color
 126                             const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoHaCandidate.getBColor()));
 127
 128                             // add to result vector
 129                             maTarget.push_back(TextAsPolygonDataNode(basegfx::B2DPolyPolygon(aPolygon), aColor, false));
 130                         }
 131                     }
 132
 133                     break;
 134                 }
 135                 case PRIMITIVE2D_ID_POLYPOLYGONHAIRLINEPRIMITIVE2D :
 136                 {
 137                     if(mnInText)
 138                     {
 139                         const primitive2d::PolyPolygonHairlinePrimitive2D& rPoPoHaCandidate(static_cast< const primitive2d::PolyPolygonHairlinePrimitive2D& >(rCandidate));
 140                         basegfx::B2DPolyPolygon aPolyPolygon(rPoPoHaCandidate.getB2DPolyPolygon());
 141
 142                         if(aPolyPolygon.count())
 143                         {
 144                             // transform the Polygon
 145                             aPolyPolygon.transform(getViewInformation2D().getObjectToViewTransformation());
 146
 147                             // get evtl. corrected color
 148                             const basegfx::BColor aColor(maBColorModifierStack.getModifiedColor(rPoPoHaCandidate.getBColor()));
 149
 150                             // add to result vector
 151                             maTarget.push_back(TextAsPolygonDataNode(aPolyPolygon, aColor, false));
 152                         }
 153                     }
 154
 155                     break;
 156                 }
 157
 158                 // usage of color modification stack is needed
 159                 case PRIMITIVE2D_ID_MODIFIEDCOLORPRIMITIVE2D :
 160                 {
 161                     const primitive2d::ModifiedColorPrimitive2D& rModifiedColorCandidate(static_cast< const primitive2d::ModifiedColorPrimitive2D& >(rCandidate));
 162
 163                     if(!rModifiedColorCandidate.getChildren().empty())
 164                     {
 165                         maBColorModifierStack.push(rModifiedColorCandidate.getColorModifier());
 166                         process(rModifiedColorCandidate.getChildren());
 167                         maBColorModifierStack.pop();
 168                     }
 169
 170                     break;
 171                 }
 172
 173                 // usage of transformation stack is needed
 174                 case PRIMITIVE2D_ID_TRANSFORMPRIMITIVE2D :
 175                 {
 176                     // remember current transformation and ViewInformation
 177                     const primitive2d::TransformPrimitive2D& rTransformCandidate(static_cast< const primitive2d::TransformPrimitive2D& >(rCandidate));
 178                     const geometry::ViewInformation2D aLastViewInformation2D(getViewInformation2D());
 179
 180                     // create new transformations for CurrentTransformation and for local ViewInformation2D
 181                     const geometry::ViewInformation2D aViewInformation2D(
 182                         getViewInformation2D().getObjectTransformation() * rTransformCandidate.getTransformation(),
 183                         getViewInformation2D().getViewTransformation(),
 184                         getViewInformation2D().getViewport(),
 185                         getViewInformation2D().getVisualizedPage(),
 186                         getViewInformation2D().getViewTime(),
 187                         getViewInformation2D().getExtendedInformationSequence());
 188                     updateViewInformation(aViewInformation2D);
 189
 190                     // process content
 191                     process(rTransformCandidate.getChildren());
 192
 193                     // restore transformations
 194                     updateViewInformation(aLastViewInformation2D);
 195
 196                     break;
 197                 }
 198
 199                 // ignorable primitives
 200                 case PRIMITIVE2D_ID_SCENEPRIMITIVE2D :
 201                 case PRIMITIVE2D_ID_WRONGSPELLPRIMITIVE2D :
 202                 case PRIMITIVE2D_ID_MARKERARRAYPRIMITIVE2D :
 203                 case PRIMITIVE2D_ID_POINTARRAYPRIMITIVE2D :
 204                 case PRIMITIVE2D_ID_BITMAPPRIMITIVE2D :
 205                 case PRIMITIVE2D_ID_METAFILEPRIMITIVE2D :
 206                 case PRIMITIVE2D_ID_MASKPRIMITIVE2D :
 207                 {
 208                     break;
 209                 }
 210
 211                 default :
 212                 {
 213                     // process recursively
 214                     process(rCandidate.get2DDecomposition(getViewInformation2D()));
 215                     break;
 216                 }
 217             }
 218         }
 219
 220         TextAsPolygonExtractor2D::TextAsPolygonExtractor2D(const geometry::ViewInformation2D& rViewInformation)
 221         :   BaseProcessor2D(rViewInformation),
 222             maTarget(),
 223             maBColorModifierStack(),
 224             mnInText(0)
 225         {
 226         }
 227
 228         TextAsPolygonExtractor2D::~TextAsPolygonExtractor2D()
 229         {
 230         }
 231     } // end of namespace processor2d
 232 } // end of namespace drawinglayer
 233
 234 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */