include/drawinglayer/primitive2d/textprimitive2d.hxx

   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 #pragma once
  21
  22 #include <drawinglayer/drawinglayerdllapi.h>
  23
  24 #include <drawinglayer/primitive2d/BufferedDecompositionPrimitive2D.hxx>
  25 #include <drawinglayer/attribute/fontattribute.hxx>
  26 #include <basegfx/polygon/b2dpolypolygon.hxx>
  27 #include <basegfx/matrix/b2dhommatrix.hxx>
  28 #include <rtl/ustring.hxx>
  29 #include <tools/color.hxx>
  30 #include <tools/long.hxx>
  31 #include <basegfx/color/bcolor.hxx>
  32 #include <com/sun/star/lang/Locale.hpp>
  33 #include <memory>
  34 #include <vector>
  35
  36 namespace drawinglayer::primitive2d
  37 {
  38 class TextLayouterDevice;
  39 }
  40
  41 class SalLayout;
  42
  43 namespace drawinglayer::primitive2d
  44 {
  45 /** TextSimplePortionPrimitive2D class
  46
  47     This is the basic primitive for representing a text portion. It contains
  48     all needed information. If it is not handled by a renderer, its decomposition
  49     will provide the text tools::PolyPolygon outlines as filled polygons, correctly
  50     transformed.
  51
  52     To get better text quality, it is suggested to handle this primitive directly
  53     in a renderer. In that case, e.g. hintings on the system can be supported.
  54
  55     @param maTextTransform
  56     The text transformation contains the text start position (always baselined)
  57     as translation, the FontSize as scale (where width relative to height defines
  58     font scaling and width == height means no font scaling) and the font rotation
  59     and shear.
  60     When shear is used and a renderer does not support it, it may be better to use
  61     the decomposition which will do everything correctly. Same is true for mirroring
  62     which would be expressed as negative scalings.
  63
  64     @param rText
  65     The text to be used. Only a part may be used, but a bigger part of the string
  66     may be necessary for correct layouting (e.g. international)
  67
  68     @param aTextPosition
  69     The index to the first character to use from rText
  70
  71     @param aTextLength
  72     The number of characters to use from rText
  73
  74     @param rDXArray
  75     The distances between the characters. This parameter may be empty, in that case
  76     the renderer is responsible to do something useful. If it is given, it has to be of
  77     the size aTextLength. Its values are in logical coordinates and describe the
  78     distance for each character to use. This is independent from the font width which
  79     is given with maTextTransform. The first value is the offset to use from the start
  80     point in FontCoordinateSystem X-Direction (given by maTextTransform) to the start
  81     point of the second character
  82
  83     @param rKashidaArray
  84     The Kashida insertion positions.
  85
  86     @param rFontAttribute
  87     The font definition
  88
  89     @param rLocale
  90     The locale to use
  91
  92     @param rFontColor
  93     The font color to use
  94
  95     @param bFilled
  96
  97     @param nWidthToFill
  98
  99     @param rTextFillColor
 100     Text background color (has nothing to do with bFilled and nWidthToFill)
 101
 102  */
 103 class DRAWINGLAYER_DLLPUBLIC TextSimplePortionPrimitive2D : public BufferedDecompositionPrimitive2D
 104 {
 105 private:
 106     /// text transformation (FontCoordinateSystem)
 107     basegfx::B2DHomMatrix maTextTransform;
 108
 109     /// The text, used from maTextPosition up to maTextPosition + maTextLength
 110     OUString maText;
 111
 112     /// The index from where on maText is used
 113     sal_Int32 mnTextPosition;
 114
 115     /// The length for maText usage, starting from maTextPosition
 116     sal_Int32 mnTextLength;
 117
 118     /// The DX array in logic units
 119     std::vector<double> maDXArray;
 120
 121     /// The Kashida array
 122     std::vector<sal_Bool> maKashidaArray;
 123
 124     /// The font definition
 125     attribute::FontAttribute maFontAttribute;
 126
 127     /// The Locale for the text
 128     css::lang::Locale maLocale;
 129
 130     /// font color
 131     basegfx::BColor maFontColor;
 132
 133     /// The fill color of the text
 134     Color maTextFillColor;
 135
 136     /// #i96669# internal: add simple range buffering for this primitive
 137     basegfx::B2DRange maB2DRange;
 138
 139 protected:
 140     /// local decomposition.
 141     virtual Primitive2DReference
 142     create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const override;
 143
 144 public:
 145     /// helpers to create a TextLayouterDevice and SalLayout, e.g. needed for SDPRs
 146     // and decompose. NOTE: the TextLayouterDevice is filled, but should always only
 147     // be used temporary (do not try to buffer)
 148     void createTextLayouter(TextLayouterDevice& rTextLayouter) const;
 149     std::unique_ptr<SalLayout> createSalLayout(TextLayouterDevice& rTextLayouter) const;
 150
 151     /// constructor
 152     TextSimplePortionPrimitive2D(basegfx::B2DHomMatrix aNewTransform, OUString aText,
 153                                  sal_Int32 nTextPosition, sal_Int32 nTextLength,
 154                                  std::vector<double>&& rDXArray,
 155                                  std::vector<sal_Bool>&& rKashidaArray,
 156                                  attribute::FontAttribute aFontAttribute, css::lang::Locale aLocale,
 157                                  const basegfx::BColor& rFontColor,
 158                                  const Color& rTextFillColor = COL_TRANSPARENT);
 159
 160     /** get text outlines as polygons and their according ObjectTransformation. Handles all
 161         the necessary VCL outline extractions, scaling adaptations and other stuff.
 162      */
 163     void getTextOutlinesAndTransformation(basegfx::B2DPolyPolygonVector& rTarget,
 164                                           basegfx::B2DHomMatrix& rTransformation) const;
 165
 166     /// data read access
 167     const basegfx::B2DHomMatrix& getTextTransform() const { return maTextTransform; }
 168     const OUString& getText() const { return maText; }
 169     sal_Int32 getTextPosition() const { return mnTextPosition; }
 170     sal_Int32 getTextLength() const { return mnTextLength; }
 171     const ::std::vector<double>& getDXArray() const { return maDXArray; }
 172     const ::std::vector<sal_Bool>& getKashidaArray() const { return maKashidaArray; }
 173     const attribute::FontAttribute& getFontAttribute() const { return maFontAttribute; }
 174     const css::lang::Locale& getLocale() const { return maLocale; }
 175     const basegfx::BColor& getFontColor() const { return maFontColor; }
 176     const Color& getTextFillColor() const { return maTextFillColor; }
 177
 178     /// helpers for determining various decoration states
 179     virtual bool hasTextRelief() const;
 180     virtual bool hasShadow() const;
 181     virtual bool hasTextDecoration() const;
 182     bool hasOutline() const;
 183
 184     /// compare operator
 185     virtual bool operator==(const BasePrimitive2D& rPrimitive) const override;
 186
 187     /// get range
 188     virtual basegfx::B2DRange
 189     getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;
 190
 191     /// provide unique ID
 192     virtual sal_uInt32 getPrimitive2DID() const override;
 193 };
 194
 195 /// small helper to have a compare operator for Locale
 196 bool DRAWINGLAYER_DLLPUBLIC LocalesAreEqual(const css::lang::Locale& rA,
 197                                             const css::lang::Locale& rB);
 198
 199 } // end of namespace drawinglayer::primitive2d
 200
 201 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */