summaryrefslogtreecommitdiffstats
path: root/include/drawinglayer/primitive2d/textprimitive2d.hxx
blob: 22ff79a69d6e9d0a2bbbbefc86b434af4b4b2eba (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#pragma once

#include <drawinglayer/drawinglayerdllapi.h>

#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <rtl/ustring.hxx>
#include <tools/color.hxx>
#include <basegfx/color/bcolor.hxx>
#include <vector>
#include <com/sun/star/lang/Locale.hpp>
#include <drawinglayer/attribute/fontattribute.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>


namespace drawinglayer::primitive2d
{
        /** TextSimplePortionPrimitive2D class

            This is the basic primitive for representing a text portion. It contains
            all needed information. If it is not handled by a renderer, its decomposition
            will provide the text tools::PolyPolygon outlines as filled polygons, correctly
            transformed.

            To get better text quality, it is suggested to handle this primitive directly
            in a renderer. In that case, e.g. hintings on the system can be supported.

            @param maTextTransform
            The text transformation contains the text start position (always baselined)
            as translation, the FontSize as scale (where width relative to height defines
            font scaling and width == height means no font scaling) and the font rotation
            and shear.
            When shear is used and a renderer does not support it, it may be better to use
            the decomposition which will do everything correctly. Same is true for mirroring
            which would be expressed as negative scalings.

            @param rText
            The text to be used. Only a part may be used, but a bigger part of the string
            may be necessary for correct layouting (e.g. international)

            @param aTextPosition
            The index to the first character to use from rText

            @param aTextLength
            The number of characters to use from rText

            @param rDXArray
            The distances between the characters. This parameter may be empty, in that case
            the renderer is responsible to do something useful. If it is given, it has to be of
            the size aTextLength. Its values are in logical coordinates and describe the
            distance for each character to use. This is independent from the font width which
            is given with maTextTransform. The first value is the offset to use from the start
            point in FontCoordinateSystem X-Direction (given by maTextTransform) to the start
            point of the second character

            @param rFontAttribute
            The font definition

            @param rLocale
            The locale to use

            @param rFontColor
            The font color to use

            @param bFilled

            @param nWidthToFill

            @param rTextFillColor
            Text background color (has nothing to do with bFilled and nWidthToFill)

         */
        class DRAWINGLAYER_DLLPUBLIC TextSimplePortionPrimitive2D : public BufferedDecompositionPrimitive2D
        {
        private:
            /// text transformation (FontCoordinateSystem)
            basegfx::B2DHomMatrix                   maTextTransform;

            /// The text, used from maTextPosition up to maTextPosition + maTextLength
            OUString                                maText;

            /// The index from where on maText is used
            sal_Int32                               mnTextPosition;

            /// The length for maText usage, starting from maTextPosition
            sal_Int32                               mnTextLength;

            /// The DX array in logic units
            ::std::vector< double >                 maDXArray;

            /// The font definition
            attribute::FontAttribute                maFontAttribute;

            /// The Locale for the text
            css::lang::Locale                       maLocale;

            /// font color
            basegfx::BColor                         maFontColor;

            // Whether to fill a given width with the text
            bool                                    mbFilled;

            // the width to fill
            long                                    mnWidthToFill;

            /// The fill color of the text
            Color                                   maTextFillColor;

            /// #i96669# internal: add simple range buffering for this primitive
            basegfx::B2DRange                       maB2DRange;

        protected:
            /// local decomposition.
            virtual void create2DDecomposition(Primitive2DContainer& rContainer, const geometry::ViewInformation2D& rViewInformation) const override;

        public:
            /// constructor
            TextSimplePortionPrimitive2D(
                const basegfx::B2DHomMatrix& rNewTransform,
                const OUString& rText,
                sal_Int32 nTextPosition,
                sal_Int32 nTextLength,
                const ::std::vector< double >& rDXArray,
                const attribute::FontAttribute& rFontAttribute,
                const css::lang::Locale& rLocale,
                const basegfx::BColor& rFontColor,
                bool bFilled = false,
                long nWidthToFill = 0,
                const Color& rTextFillColor = COL_TRANSPARENT );

            /// helpers
            /** get text outlines as polygons and their according ObjectTransformation. Handles all
                the necessary VCL outline extractions, scaling adaptations and other stuff.
             */
            void getTextOutlinesAndTransformation(basegfx::B2DPolyPolygonVector& rTarget, basegfx::B2DHomMatrix& rTransformation) const;

            /// data read access
            const basegfx::B2DHomMatrix& getTextTransform() const { return maTextTransform; }
            const OUString& getText() const { return maText; }
            sal_Int32 getTextPosition() const { return mnTextPosition; }
            sal_Int32 getTextLength() const { return mnTextLength; }
            const ::std::vector< double >& getDXArray() const { return maDXArray; }
            const attribute::FontAttribute& getFontAttribute() const { return maFontAttribute; }
            const css::lang::Locale& getLocale() const { return  maLocale; }
            const basegfx::BColor& getFontColor() const { return maFontColor; }
            const Color& getTextFillColor() const { return maTextFillColor; }
            bool isFilled() const { return mbFilled; }
            long getWidthToFill() const { return mnWidthToFill; }

            /// compare operator
            virtual bool operator==( const BasePrimitive2D& rPrimitive ) const override;

            /// get range
            virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const override;

            /// provide unique ID
            virtual sal_uInt32 getPrimitive2DID() const override;
        };

        /// small helper to have a compare operator for Locale
        bool DRAWINGLAYER_DLLPUBLIC LocalesAreEqual(const css::lang::Locale& rA, const css::lang::Locale& rB);

} // end of namespace drawinglayer::primitive2d


/* vim:set shiftwidth=4 softtabstop=4 expandtab: */