blob: f085065c1ea63fd5a40aa7427421d5f12faab25b (
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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/* -*- 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 <sal/config.h>
#include <drawinglayer/primitive2d/baseprimitive2d.hxx>
#include <vcl/font.hxx>
#include <rtl/ref.hxx>
#include <vcl/rendercontext/State.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
// predefines
namespace drawinglayer::geometry { class ViewInformation2D; }
class GDIMetaFile;
namespace wmfemfhelper { class PropertyHolder; }
namespace wmfemfhelper
{
/** Helper class to buffer and hold a Primitive target vector. It
encapsulates the new/delete functionality and allows to work
on pointers of the implementation classes. All data will
be converted to uno sequences of uno references when accessing the
data.
*/
class TargetHolder
{
private:
drawinglayer::primitive2d::Primitive2DContainer aTargets;
public:
TargetHolder();
~TargetHolder();
sal_uInt32 size() const;
void append(const rtl::Reference<drawinglayer::primitive2d::BasePrimitive2D> & pCandidate)
{
append(pCandidate.get());
}
void append(drawinglayer::primitive2d::Primitive2DContainer xCandidate)
{
aTargets.append(std::move(xCandidate));
}
void append(drawinglayer::primitive2d::BasePrimitive2D* pCandidate);
drawinglayer::primitive2d::Primitive2DContainer getPrimitive2DSequence(const PropertyHolder& rPropertyHolder);
};
/** Helper class which builds a stack on the TargetHolder class */
class TargetHolders
{
private:
std::vector< TargetHolder* > maTargetHolders;
public:
TargetHolders();
sal_uInt32 size() const;
void Push();
void Pop();
TargetHolder& Current();
~TargetHolders();
};
/** helper class for graphic context
This class allows to hold a complete representation of classic
VCL OutputDevice state. This data is needed for correct
interpretation of the MetaFile action flow.
*/
class PropertyHolder
{
private:
/// current transformation (aka MapMode)
basegfx::B2DHomMatrix maTransformation;
MapUnit maMapUnit;
/// current colors
basegfx::BColor maLineColor;
basegfx::BColor maFillColor;
basegfx::BColor maTextColor;
basegfx::BColor maTextFillColor;
basegfx::BColor maTextLineColor;
basegfx::BColor maOverlineColor;
/// clipping
basegfx::B2DPolyPolygon maClipPolyPolygon;
/// font, etc.
vcl::Font maFont;
RasterOp maRasterOp;
vcl::text::ComplexTextLayoutFlags mnLayoutMode;
LanguageType maLanguageType;
vcl::PushFlags mnPushFlags;
/// contains all active markers
bool mbLineColor : 1;
bool mbFillColor : 1;
bool mbTextColor : 1;
bool mbTextFillColor : 1;
bool mbTextLineColor : 1;
bool mbOverlineColor : 1;
bool mbClipPolyPolygonActive : 1;
public:
PropertyHolder();
/// read/write accesses
const basegfx::B2DHomMatrix& getTransformation() const { return maTransformation; }
void setTransformation(const basegfx::B2DHomMatrix& rNew) { if (rNew != maTransformation) maTransformation = rNew; }
MapUnit getMapUnit() const { return maMapUnit; }
void setMapUnit(MapUnit eNew) { if (eNew != maMapUnit) maMapUnit = eNew; }
const basegfx::BColor& getLineColor() const { return maLineColor; }
void setLineColor(const basegfx::BColor& rNew) { if (rNew != maLineColor) maLineColor = rNew; }
bool getLineColorActive() const { return mbLineColor; }
void setLineColorActive(bool bNew) { if (bNew != mbLineColor) mbLineColor = bNew; }
const basegfx::BColor& getFillColor() const { return maFillColor; }
void setFillColor(const basegfx::BColor& rNew) { if (rNew != maFillColor) maFillColor = rNew; }
bool getFillColorActive() const { return mbFillColor; }
void setFillColorActive(bool bNew) { if (bNew != mbFillColor) mbFillColor = bNew; }
const basegfx::BColor& getTextColor() const { return maTextColor; }
void setTextColor(const basegfx::BColor& rNew) { if (rNew != maTextColor) maTextColor = rNew; }
bool getTextColorActive() const { return mbTextColor; }
void setTextColorActive(bool bNew) { if (bNew != mbTextColor) mbTextColor = bNew; }
const basegfx::BColor& getTextFillColor() const { return maTextFillColor; }
void setTextFillColor(const basegfx::BColor& rNew) { if (rNew != maTextFillColor) maTextFillColor = rNew; }
bool getTextFillColorActive() const { return mbTextFillColor; }
void setTextFillColorActive(bool bNew) { if (bNew != mbTextFillColor) mbTextFillColor = bNew; }
const basegfx::BColor& getTextLineColor() const { return maTextLineColor; }
void setTextLineColor(const basegfx::BColor& rNew) { if (rNew != maTextLineColor) maTextLineColor = rNew; }
bool getTextLineColorActive() const { return mbTextLineColor; }
void setTextLineColorActive(bool bNew) { if (bNew != mbTextLineColor) mbTextLineColor = bNew; }
const basegfx::BColor& getOverlineColor() const { return maOverlineColor; }
void setOverlineColor(const basegfx::BColor& rNew) { if (rNew != maOverlineColor) maOverlineColor = rNew; }
bool getOverlineColorActive() const { return mbOverlineColor; }
void setOverlineColorActive(bool bNew) { if (bNew != mbOverlineColor) mbOverlineColor = bNew; }
const basegfx::B2DPolyPolygon& getClipPolyPolygon() const { return maClipPolyPolygon; }
void setClipPolyPolygon(const basegfx::B2DPolyPolygon& rNew) { if (rNew != maClipPolyPolygon) maClipPolyPolygon = rNew; }
bool getClipPolyPolygonActive() const { return mbClipPolyPolygonActive; }
void setClipPolyPolygonActive(bool bNew) { if (bNew != mbClipPolyPolygonActive) mbClipPolyPolygonActive = bNew; }
const vcl::Font& getFont() const { return maFont; }
void setFont(const vcl::Font& rFont) { if (rFont != maFont) maFont = rFont; }
const RasterOp& getRasterOp() const { return maRasterOp; }
void setRasterOp(const RasterOp& rRasterOp) { if (rRasterOp != maRasterOp) maRasterOp = rRasterOp; }
bool isRasterOpInvert() const { return (RasterOp::Xor == maRasterOp || RasterOp::Invert == maRasterOp); }
bool isRasterOpForceBlack() const { return RasterOp::N0 == maRasterOp; }
bool isRasterOpActive() const { return isRasterOpInvert() || isRasterOpForceBlack(); }
vcl::text::ComplexTextLayoutFlags getLayoutMode() const { return mnLayoutMode; }
void setLayoutMode(vcl::text::ComplexTextLayoutFlags nNew) { if (nNew != mnLayoutMode) mnLayoutMode = nNew; }
LanguageType getLanguageType() const { return maLanguageType; }
void setLanguageType(LanguageType aNew) { if (aNew != maLanguageType) maLanguageType = aNew; }
vcl::PushFlags getPushFlags() const { return mnPushFlags; }
void setPushFlags(vcl::PushFlags nNew) { if (nNew != mnPushFlags) mnPushFlags = nNew; }
bool getLineOrFillActive() const { return (mbLineColor || mbFillColor); }
};
/** stack for properties
This class builds a stack based on the PropertyHolder
class. It encapsulates the pointer/new/delete usage to
make it safe and implements the push/pop as needed by a
VCL Metafile interpreter. The critical part here are the
flag values VCL OutputDevice uses here; not all stuff is
pushed and thus needs to be copied at pop.
*/
class PropertyHolders
{
private:
std::vector< PropertyHolder* > maPropertyHolders;
public:
PropertyHolders();
void PushDefault();
void Push(vcl::PushFlags nPushFlags);
void Pop();
PropertyHolder& Current();
~PropertyHolders();
};
drawinglayer::primitive2d::Primitive2DContainer interpretMetafile(
const GDIMetaFile& rMetaFile,
const drawinglayer::geometry::ViewInformation2D& rViewInformation);
void HandleNewClipRegion(
const basegfx::B2DPolyPolygon& rClipPolyPolygon,
TargetHolders& rTargetHolders,
PropertyHolders& rPropertyHolders);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
