LibreOffice Module oox (master)  1
color.cxx
Go to the documentation of this file.
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 <oox/drawingml/color.hxx>
21 #include <algorithm>
22 #include <math.h>
23 #include <osl/diagnose.h>
24 #include <sal/log.hxx>
28 #include <oox/token/namespaces.hxx>
29 #include <oox/token/tokens.hxx>
30 
31 namespace oox::drawingml {
32 
33 namespace {
34 
36 struct PresetColorsPool
37 {
38  typedef ::std::vector< ::Color > ColorVector;
39 
40  ColorVector maDmlColors;
41  ColorVector maVmlColors;
42  ColorVector maHighlightColors;
43 
44  explicit PresetColorsPool();
45 };
46 
47 PresetColorsPool::PresetColorsPool() :
48  maDmlColors( static_cast< size_t >( XML_TOKEN_COUNT ), API_RGB_TRANSPARENT ),
49  maVmlColors( static_cast< size_t >( XML_TOKEN_COUNT ), API_RGB_TRANSPARENT ),
50  maHighlightColors( static_cast<size_t>(XML_TOKEN_COUNT), API_RGB_TRANSPARENT )
51 {
52  // predefined colors in DrawingML (map XML token identifiers to RGB values)
53  static const std::pair<sal_Int32, ::Color> spnDmlColors[] =
54  {
55  {XML_aliceBlue, ::Color(0xF0F8FF)}, {XML_antiqueWhite, ::Color(0xFAEBD7)},
56  {XML_aqua, ::Color(0x00FFFF)}, {XML_aquamarine, ::Color(0x7FFFD4)},
57  {XML_azure, ::Color(0xF0FFFF)}, {XML_beige, ::Color(0xF5F5DC)},
58  {XML_bisque, ::Color(0xFFE4C4)}, {XML_black, ::Color(0x000000)},
59  {XML_blanchedAlmond, ::Color(0xFFEBCD)}, {XML_blue, ::Color(0x0000FF)},
60  {XML_blueViolet, ::Color(0x8A2BE2)}, {XML_brown, ::Color(0xA52A2A)},
61  {XML_burlyWood, ::Color(0xDEB887)}, {XML_cadetBlue, ::Color(0x5F9EA0)},
62  {XML_chartreuse, ::Color(0x7FFF00)}, {XML_chocolate, ::Color(0xD2691E)},
63  {XML_coral, ::Color(0xFF7F50)}, {XML_cornflowerBlue, ::Color(0x6495ED)},
64  {XML_cornsilk, ::Color(0xFFF8DC)}, {XML_crimson, ::Color(0xDC143C)},
65  {XML_cyan, ::Color(0x00FFFF)}, {XML_deepPink, ::Color(0xFF1493)},
66  {XML_deepSkyBlue, ::Color(0x00BFFF)}, {XML_dimGray, ::Color(0x696969)},
67  {XML_dkBlue, ::Color(0x00008B)}, {XML_dkCyan, ::Color(0x008B8B)},
68  {XML_dkGoldenrod, ::Color(0xB8860B)}, {XML_dkGray, ::Color(0xA9A9A9)},
69  {XML_dkGreen, ::Color(0x006400)}, {XML_dkKhaki, ::Color(0xBDB76B)},
70  {XML_dkMagenta, ::Color(0x8B008B)}, {XML_dkOliveGreen, ::Color(0x556B2F)},
71  {XML_dkOrange, ::Color(0xFF8C00)}, {XML_dkOrchid, ::Color(0x9932CC)},
72  {XML_dkRed, ::Color(0x8B0000)}, {XML_dkSalmon, ::Color(0xE9967A)},
73  {XML_dkSeaGreen, ::Color(0x8FBC8B)}, {XML_dkSlateBlue, ::Color(0x483D8B)},
74  {XML_dkSlateGray, ::Color(0x2F4F4F)}, {XML_dkTurquoise, ::Color(0x00CED1)},
75  {XML_dkViolet, ::Color(0x9400D3)}, {XML_dodgerBlue, ::Color(0x1E90FF)},
76  {XML_firebrick, ::Color(0xB22222)}, {XML_floralWhite, ::Color(0xFFFAF0)},
77  {XML_forestGreen, ::Color(0x228B22)}, {XML_fuchsia, ::Color(0xFF00FF)},
78  {XML_gainsboro, ::Color(0xDCDCDC)}, {XML_ghostWhite, ::Color(0xF8F8FF)},
79  {XML_gold, ::Color(0xFFD700)}, {XML_goldenrod, ::Color(0xDAA520)},
80  {XML_gray, ::Color(0x808080)}, {XML_green, ::Color(0x008000)},
81  {XML_greenYellow, ::Color(0xADFF2F)}, {XML_honeydew, ::Color(0xF0FFF0)},
82  {XML_hotPink, ::Color(0xFF69B4)}, {XML_indianRed, ::Color(0xCD5C5C)},
83  {XML_indigo, ::Color(0x4B0082)}, {XML_ivory, ::Color(0xFFFFF0)},
84  {XML_khaki, ::Color(0xF0E68C)}, {XML_lavender, ::Color(0xE6E6FA)},
85  {XML_lavenderBlush, ::Color(0xFFF0F5)}, {XML_lawnGreen, ::Color(0x7CFC00)},
86  {XML_lemonChiffon, ::Color(0xFFFACD)}, {XML_lime, ::Color(0x00FF00)},
87  {XML_limeGreen, ::Color(0x32CD32)}, {XML_linen, ::Color(0xFAF0E6)},
88  {XML_ltBlue, ::Color(0xADD8E6)}, {XML_ltCoral, ::Color(0xF08080)},
89  {XML_ltCyan, ::Color(0xE0FFFF)}, {XML_ltGoldenrodYellow, ::Color(0xFAFA78)},
90  {XML_ltGray, ::Color(0xD3D3D3)}, {XML_ltGreen, ::Color(0x90EE90)},
91  {XML_ltPink, ::Color(0xFFB6C1)}, {XML_ltSalmon, ::Color(0xFFA07A)},
92  {XML_ltSeaGreen, ::Color(0x20B2AA)}, {XML_ltSkyBlue, ::Color(0x87CEFA)},
93  {XML_ltSlateGray, ::Color(0x778899)}, {XML_ltSteelBlue, ::Color(0xB0C4DE)},
94  {XML_ltYellow, ::Color(0xFFFFE0)}, {XML_magenta, ::Color(0xFF00FF)},
95  {XML_maroon, ::Color(0x800000)}, {XML_medAquamarine, ::Color(0x66CDAA)},
96  {XML_medBlue, ::Color(0x0000CD)}, {XML_medOrchid, ::Color(0xBA55D3)},
97  {XML_medPurple, ::Color(0x9370DB)}, {XML_medSeaGreen, ::Color(0x3CB371)},
98  {XML_medSlateBlue, ::Color(0x7B68EE)}, {XML_medSpringGreen, ::Color(0x00FA9A)},
99  {XML_medTurquoise, ::Color(0x48D1CC)}, {XML_medVioletRed, ::Color(0xC71585)},
100  {XML_midnightBlue, ::Color(0x191970)}, {XML_mintCream, ::Color(0xF5FFFA)},
101  {XML_mistyRose, ::Color(0xFFE4E1)}, {XML_moccasin, ::Color(0xFFE4B5)},
102  {XML_navajoWhite, ::Color(0xFFDEAD)}, {XML_navy, ::Color(0x000080)},
103  {XML_oldLace, ::Color(0xFDF5E6)}, {XML_olive, ::Color(0x808000)},
104  {XML_oliveDrab, ::Color(0x6B8E23)}, {XML_orange, ::Color(0xFFA500)},
105  {XML_orangeRed, ::Color(0xFF4500)}, {XML_orchid, ::Color(0xDA70D6)},
106  {XML_paleGoldenrod, ::Color(0xEEE8AA)}, {XML_paleGreen, ::Color(0x98FB98)},
107  {XML_paleTurquoise, ::Color(0xAFEEEE)}, {XML_paleVioletRed, ::Color(0xDB7093)},
108  {XML_papayaWhip, ::Color(0xFFEFD5)}, {XML_peachPuff, ::Color(0xFFDAB9)},
109  {XML_peru, ::Color(0xCD853F)}, {XML_pink, ::Color(0xFFC0CB)},
110  {XML_plum, ::Color(0xDDA0DD)}, {XML_powderBlue, ::Color(0xB0E0E6)},
111  {XML_purple, ::Color(0x800080)}, {XML_red, ::Color(0xFF0000)},
112  {XML_rosyBrown, ::Color(0xBC8F8F)}, {XML_royalBlue, ::Color(0x4169E1)},
113  {XML_saddleBrown, ::Color(0x8B4513)}, {XML_salmon, ::Color(0xFA8072)},
114  {XML_sandyBrown, ::Color(0xF4A460)}, {XML_seaGreen, ::Color(0x2E8B57)},
115  {XML_seaShell, ::Color(0xFFF5EE)}, {XML_sienna, ::Color(0xA0522D)},
116  {XML_silver, ::Color(0xC0C0C0)}, {XML_skyBlue, ::Color(0x87CEEB)},
117  {XML_slateBlue, ::Color(0x6A5ACD)}, {XML_slateGray, ::Color(0x708090)},
118  {XML_snow, ::Color(0xFFFAFA)}, {XML_springGreen, ::Color(0x00FF7F)},
119  {XML_steelBlue, ::Color(0x4682B4)}, {XML_tan, ::Color(0xD2B48C)},
120  {XML_teal, ::Color(0x008080)}, {XML_thistle, ::Color(0xD8BFD8)},
121  {XML_tomato, ::Color(0xFF6347)}, {XML_turquoise, ::Color(0x40E0D0)},
122  {XML_violet, ::Color(0xEE82EE)}, {XML_wheat, ::Color(0xF5DEB3)},
123  {XML_white, ::Color(0xFFFFFF)}, {XML_whiteSmoke, ::Color(0xF5F5F5)},
124  {XML_yellow, ::Color(0xFFFF00)}, {XML_yellowGreen, ::Color(0x9ACD32)}
125  };
126  for(auto const& nEntry : spnDmlColors)
127  maDmlColors[ static_cast< size_t >(nEntry.first) ] = nEntry.second;
128 
129  // predefined colors in VML (map XML token identifiers to RGB values)
130  static const std::pair<sal_Int32, ::Color> spnVmlColors[] =
131  {
132  {XML_aqua, ::Color(0x00FFFF)}, {XML_black, ::Color(0x000000)},
133  {XML_blue, ::Color(0x0000FF)}, {XML_fuchsia, ::Color(0xFF00FF)},
134  {XML_gray, ::Color(0x808080)}, {XML_green, ::Color(0x008000)},
135  {XML_lime, ::Color(0x00FF00)}, {XML_maroon, ::Color(0x800000)},
136  {XML_navy, ::Color(0x000080)}, {XML_olive, ::Color(0x808000)},
137  {XML_purple, ::Color(0x800080)}, {XML_red, ::Color(0xFF0000)},
138  {XML_silver, ::Color(0xC0C0C0)}, {XML_teal, ::Color(0x008080)},
139  {XML_white, ::Color(0xFFFFFF)}, {XML_yellow, ::Color(0xFFFF00)}
140  };
141  for(auto const& nEntry : spnVmlColors)
142  maVmlColors[ static_cast< size_t >(nEntry.first) ] = nEntry.second;
143 
144  // predefined highlight colors in DML (map XML token identifiers to RGB values)
145  static const std::pair<sal_Int32, ::Color> spnHighlightColors[] =
146  {
147  // tdf#131841 Predefined color for OOXML highlight.
148  {XML_black, ::Color(0x000000)}, {XML_blue, ::Color(0x0000FF)},
149  {XML_cyan, ::Color(0x00FFFF)}, {XML_darkBlue, ::Color(0x00008B)},
150  {XML_darkCyan, ::Color(0x008B8B)}, {XML_darkGray, ::Color(0xA9A9A9)},
151  {XML_darkGreen, ::Color(0x006400)}, {XML_darkMagenta, ::Color(0x800080)},
152  {XML_darkRed, ::Color(0x8B0000)}, {XML_darkYellow, ::Color(0x808000)},
153  {XML_green, ::Color(0x00FF00)}, {XML_lightGray, ::Color(0xD3D3D3)},
154  {XML_magenta, ::Color(0xFF00FF)}, {XML_red, ::Color(0xFF0000)},
155  {XML_white, ::Color(0xFFFFFF)}, {XML_yellow, ::Color(0xFFFF00)}
156  };
157  for (auto const& nEntry : spnHighlightColors)
158  maHighlightColors[static_cast<size_t>(nEntry.first)] = nEntry.second;
159 }
160 
161 struct StaticPresetColorsPool : public ::rtl::Static< PresetColorsPool, StaticPresetColorsPool > {};
162 
163 const double DEC_GAMMA = 2.3;
164 const double INC_GAMMA = 1.0 / DEC_GAMMA;
165 
166 void lclRgbToRgbComponents( sal_Int32& ornR, sal_Int32& ornG, sal_Int32& ornB, ::Color nRgb )
167 {
168  ornR = nRgb.GetRed();
169  ornG = nRgb.GetGreen();
170  ornB = nRgb.GetBlue();
171 }
172 
173 sal_Int32 lclRgbComponentsToRgb( sal_Int32 nR, sal_Int32 nG, sal_Int32 nB )
174 {
175  return static_cast< sal_Int32 >( (nR << 16) | (nG << 8) | nB );
176 }
177 
178 sal_Int32 lclRgbCompToCrgbComp( sal_Int32 nRgbComp )
179 {
180  return static_cast< sal_Int32 >( nRgbComp * MAX_PERCENT / 255 );
181 }
182 
183 sal_Int32 lclCrgbCompToRgbComp( sal_Int32 nCrgbComp )
184 {
185  return static_cast< sal_Int32 >( nCrgbComp * 255 / MAX_PERCENT );
186 }
187 
188 sal_Int32 lclGamma( sal_Int32 nComp, double fGamma )
189 {
190  return static_cast< sal_Int32 >( pow( static_cast< double >( nComp ) / MAX_PERCENT, fGamma ) * MAX_PERCENT + 0.5 );
191 }
192 
193 void lclSetValue( sal_Int32& ornValue, sal_Int32 nNew, sal_Int32 nMax = MAX_PERCENT )
194 {
195  OSL_ENSURE( (0 <= nNew) && (nNew <= nMax), "lclSetValue - invalid value" );
196  if( (0 <= nNew) && (nNew <= nMax) )
197  ornValue = nNew;
198 }
199 
200 void lclModValue( sal_Int32& ornValue, sal_Int32 nMod, sal_Int32 nMax = MAX_PERCENT )
201 {
202  OSL_ENSURE( (0 <= nMod), "lclModValue - invalid modificator" );
203  ornValue = getLimitedValue< sal_Int32, double >( static_cast< double >( ornValue ) * nMod / MAX_PERCENT, 0, nMax );
204 }
205 
206 void lclOffValue( sal_Int32& ornValue, sal_Int32 nOff, sal_Int32 nMax = MAX_PERCENT )
207 {
208  OSL_ENSURE( (-nMax <= nOff) && (nOff <= nMax), "lclOffValue - invalid offset" );
209  ornValue = getLimitedValue< sal_Int32, sal_Int32 >( ornValue + nOff, 0, nMax );
210 }
211 
212 } // namespace
213 
215  meMode( COLOR_UNUSED ),
216  mnC1( 0 ),
217  mnC2( 0 ),
218  mnC3( 0 ),
219  mnAlpha( MAX_PERCENT )
220 {
221 }
222 
223 ::Color Color::getDmlPresetColor( sal_Int32 nToken, ::Color nDefaultRgb )
224 {
225  /* Do not pass nDefaultRgb to ContainerHelper::getVectorElement(), to be
226  able to catch the existing vector entries without corresponding XML
227  token identifier. */
228  ::Color nRgbValue = ContainerHelper::getVectorElement( StaticPresetColorsPool::get().maDmlColors, nToken, API_RGB_TRANSPARENT );
229  return (sal_Int32(nRgbValue) >= 0) ? nRgbValue : nDefaultRgb;
230 }
231 
232 ::Color Color::getVmlPresetColor( sal_Int32 nToken, ::Color nDefaultRgb )
233 {
234  /* Do not pass nDefaultRgb to ContainerHelper::getVectorElement(), to be
235  able to catch the existing vector entries without corresponding XML
236  token identifier. */
237  ::Color nRgbValue = ContainerHelper::getVectorElement( StaticPresetColorsPool::get().maVmlColors, nToken, API_RGB_TRANSPARENT );
238  return (sal_Int32(nRgbValue) >= 0) ? nRgbValue : nDefaultRgb;
239 }
240 
241 ::Color Color::getHighlightColor(sal_Int32 nToken, ::Color nDefaultRgb)
242 {
243  /* Do not pass nDefaultRgb to ContainerHelper::getVectorElement(), to be
244  able to catch the existing vector entries without corresponding XML
245  token identifier. */
246  ::Color nRgbValue = ContainerHelper::getVectorElement( StaticPresetColorsPool::get().maHighlightColors, nToken, API_RGB_TRANSPARENT );
247  return (sal_Int32(nRgbValue) >= 0) ? nRgbValue : nDefaultRgb;
248 }
249 
251 {
253 }
254 
255 void Color::setSrgbClr( ::Color nRgb )
256 {
257  setSrgbClr(sal_Int32(nRgb));
258 }
259 
260 void Color::setSrgbClr( sal_Int32 nRgb )
261 {
262  OSL_ENSURE( (0 <= nRgb) && (nRgb <= 0xFFFFFF), "Color::setSrgbClr - invalid RGB value" );
263  meMode = COLOR_RGB;
264  lclRgbToRgbComponents( mnC1, mnC2, mnC3, ::Color(ColorTransparency, nRgb) );
265 }
266 
267 void Color::setScrgbClr( sal_Int32 nR, sal_Int32 nG, sal_Int32 nB )
268 {
269  OSL_ENSURE( (0 <= nR) && (nR <= MAX_PERCENT), "Color::setScrgbClr - invalid red value" );
270  OSL_ENSURE( (0 <= nG) && (nG <= MAX_PERCENT), "Color::setScrgbClr - invalid green value" );
271  OSL_ENSURE( (0 <= nB) && (nB <= MAX_PERCENT), "Color::setScrgbClr - invalid blue value" );
272  meMode = COLOR_CRGB;
273  mnC1 = getLimitedValue< sal_Int32, sal_Int32 >( nR, 0, MAX_PERCENT );
274  mnC2 = getLimitedValue< sal_Int32, sal_Int32 >( nG, 0, MAX_PERCENT );
275  mnC3 = getLimitedValue< sal_Int32, sal_Int32 >( nB, 0, MAX_PERCENT );
276 }
277 
278 void Color::setHslClr( sal_Int32 nHue, sal_Int32 nSat, sal_Int32 nLum )
279 {
280  OSL_ENSURE( (0 <= nHue) && (nHue <= MAX_DEGREE), "Color::setHslClr - invalid hue value" );
281  OSL_ENSURE( (0 <= nSat) && (nSat <= MAX_PERCENT), "Color::setHslClr - invalid saturation value" );
282  OSL_ENSURE( (0 <= nLum) && (nLum <= MAX_PERCENT), "Color::setHslClr - invalid luminance value" );
283  meMode = COLOR_HSL;
284  mnC1 = getLimitedValue< sal_Int32, sal_Int32 >( nHue, 0, MAX_DEGREE );
285  mnC2 = getLimitedValue< sal_Int32, sal_Int32 >( nSat, 0, MAX_PERCENT );
286  mnC3 = getLimitedValue< sal_Int32, sal_Int32 >( nLum, 0, MAX_PERCENT );
287 }
288 
289 void Color::setPrstClr( sal_Int32 nToken )
290 {
291  ::Color nRgbValue = getDmlPresetColor( nToken, API_RGB_TRANSPARENT );
292  OSL_ENSURE( sal_Int32(nRgbValue) >= 0, "Color::setPrstClr - invalid preset color token" );
293  if( sal_Int32(nRgbValue) >= 0 )
294  setSrgbClr( nRgbValue );
295 }
296 
297 void Color::setHighlight(sal_Int32 nToken)
298 {
299  ::Color nRgbValue = getHighlightColor(nToken, API_RGB_TRANSPARENT);
300  OSL_ENSURE( sal_Int32(nRgbValue) >= 0, "Color::setPrstClr - invalid preset color token" );
301  if ( sal_Int32(nRgbValue) >= 0 )
302  setSrgbClr( nRgbValue );
303 }
304 
305 void Color::setSchemeClr( sal_Int32 nToken )
306 {
307  OSL_ENSURE( nToken != XML_TOKEN_INVALID, "Color::setSchemeClr - invalid color token" );
308  meMode = (nToken == XML_phClr) ? COLOR_PH : COLOR_SCHEME;
309  mnC1 = nToken;
310 }
311 
312 void Color::setPaletteClr( sal_Int32 nPaletteIdx )
313 {
314  OSL_ENSURE( nPaletteIdx >= 0, "Color::setPaletteClr - invalid palette index" );
316  mnC1 = nPaletteIdx;
317 }
318 
319 void Color::setSysClr( sal_Int32 nToken, sal_Int32 nLastRgb )
320 {
321  OSL_ENSURE( (-1 <= nLastRgb) && (nLastRgb <= 0xFFFFFF), "Color::setSysClr - invalid RGB value" );
323  mnC1 = nToken;
324  mnC2 = nLastRgb;
325 }
326 
327 void Color::addTransformation( sal_Int32 nElement, sal_Int32 nValue )
328 {
329  /* Execute alpha transformations directly, store other transformations in
330  a vector, they may depend on a scheme base color which will be resolved
331  in Color::getColor(). */
332  sal_Int32 nToken = getBaseToken( nElement );
333  switch( nToken )
334  {
335  case XML_alpha: lclSetValue( mnAlpha, nValue ); break;
336  case XML_alphaMod: lclModValue( mnAlpha, nValue ); break;
337  case XML_alphaOff: lclOffValue( mnAlpha, nValue ); break;
338  default: maTransforms.emplace_back( nToken, nValue );
339  }
340  sal_Int32 nSize = maInteropTransformations.getLength();
341  maInteropTransformations.realloc(nSize + 1);
343  maInteropTransformations[nSize].Value <<= nValue;
344 }
345 
347 {
348  sal_Int32 nValue = getLimitedValue< sal_Int32, double >( fTint * MAX_PERCENT + 0.5, -MAX_PERCENT, MAX_PERCENT );
349  if( nValue < 0 )
350  maTransforms.emplace_back( XML_shade, nValue + MAX_PERCENT );
351  else if( nValue > 0 )
352  maTransforms.emplace_back( XML_tint, MAX_PERCENT - nValue );
353 }
354 
356 {
357  sal_Int32 nValue = getLimitedValue< sal_Int32, double >( fTint * MAX_PERCENT + 0.5, -MAX_PERCENT, MAX_PERCENT );
358  maTransforms.emplace_back( XLS_TOKEN( tint ), nValue );
359 }
360 
362 {
363  maTransforms.clear();
364  maInteropTransformations.realloc(0);
366 }
367 
368 OUString Color::getColorTransformationName( sal_Int32 nElement )
369 {
370  switch( nElement )
371  {
372  case XML_red: return "red";
373  case XML_redMod: return "redMod";
374  case XML_redOff: return "redOff";
375  case XML_green: return "green";
376  case XML_greenMod: return "greenMod";
377  case XML_greenOff: return "greenOff";
378  case XML_blue: return "blue";
379  case XML_blueMod: return "blueMod";
380  case XML_blueOff: return "blueOff";
381  case XML_alpha: return "alpha";
382  case XML_alphaMod: return "alphaMod";
383  case XML_alphaOff: return "alphaOff";
384  case XML_hue: return "hue";
385  case XML_hueMod: return "hueMod";
386  case XML_hueOff: return "hueOff";
387  case XML_sat: return "sat";
388  case XML_satMod: return "satMod";
389  case XML_satOff: return "satOff";
390  case XML_lum: return "lum";
391  case XML_lumMod: return "lumMod";
392  case XML_lumOff: return "lumOff";
393  case XML_shade: return "shade";
394  case XML_tint: return "tint";
395  case XML_gray: return "gray";
396  case XML_comp: return "comp";
397  case XML_inv: return "inv";
398  case XML_gamma: return "gamma";
399  case XML_invGamma: return "invGamma";
400  }
401  SAL_WARN( "oox.drawingml", "Color::getColorTransformationName - unexpected transformation type" );
402  return OUString();
403 }
404 
405 sal_Int32 Color::getColorTransformationToken( std::u16string_view sName )
406 {
407  if( sName == u"red" )
408  return XML_red;
409  else if( sName == u"redMod" )
410  return XML_redMod;
411  else if( sName == u"redOff" )
412  return XML_redOff;
413  else if( sName == u"green" )
414  return XML_green;
415  else if( sName == u"greenMod" )
416  return XML_greenMod;
417  else if( sName == u"greenOff" )
418  return XML_greenOff;
419  else if( sName == u"blue" )
420  return XML_blue;
421  else if( sName == u"blueMod" )
422  return XML_blueMod;
423  else if( sName == u"blueOff" )
424  return XML_blueOff;
425  else if( sName == u"alpha" )
426  return XML_alpha;
427  else if( sName == u"alphaMod" )
428  return XML_alphaMod;
429  else if( sName == u"alphaOff" )
430  return XML_alphaOff;
431  else if( sName == u"hue" )
432  return XML_hue;
433  else if( sName == u"hueMod" )
434  return XML_hueMod;
435  else if( sName == u"hueOff" )
436  return XML_hueOff;
437  else if( sName == u"sat" )
438  return XML_sat;
439  else if( sName == u"satMod" )
440  return XML_satMod;
441  else if( sName == u"satOff" )
442  return XML_satOff;
443  else if( sName == u"lum" )
444  return XML_lum;
445  else if( sName == u"lumMod" )
446  return XML_lumMod;
447  else if( sName == u"lumOff" )
448  return XML_lumOff;
449  else if( sName == u"shade" )
450  return XML_shade;
451  else if( sName == u"tint" )
452  return XML_tint;
453  else if( sName == u"gray" )
454  return XML_gray;
455  else if( sName == u"comp" )
456  return XML_comp;
457  else if( sName == u"inv" )
458  return XML_inv;
459  else if( sName == u"gamma" )
460  return XML_gamma;
461  else if( sName == u"invGamma" )
462  return XML_invGamma;
463 
464  SAL_WARN( "oox.drawingml", "Color::getColorTransformationToken - unexpected transformation type" );
465  return XML_TOKEN_INVALID;
466 }
467 
468 bool Color::equals(const Color& rOther, const GraphicHelper& rGraphicHelper, ::Color nPhClr) const
469 {
470  if (getColor(rGraphicHelper, nPhClr) != rOther.getColor(rGraphicHelper, nPhClr))
471  return false;
472 
473  return getTransparency() == rOther.getTransparency();
474 }
475 
477 {
479 }
480 
481 ::Color Color::getColor( const GraphicHelper& rGraphicHelper, ::Color nPhClr ) const
482 {
483  const sal_Int32 nTempC1 = mnC1;
484  const sal_Int32 nTempC2 = mnC2;
485  const sal_Int32 nTempC3 = mnC3;
486  const ColorMode eTempMode = meMode;
487 
488  switch( meMode )
489  {
490  case COLOR_UNUSED: mnC1 = sal_Int32(API_RGB_TRANSPARENT); break;
491 
492  case COLOR_RGB: break; // nothing to do
493  case COLOR_CRGB: break; // nothing to do
494  case COLOR_HSL: break; // nothing to do
495 
496  case COLOR_SCHEME: setResolvedRgb( rGraphicHelper.getSchemeColor( mnC1 ) ); break;
497  case COLOR_PALETTE: setResolvedRgb( rGraphicHelper.getPaletteColor( mnC1 ) ); break;
498  case COLOR_SYSTEM: setResolvedRgb( rGraphicHelper.getSystemColor( mnC1, ::Color(ColorTransparency, mnC2) ) ); break;
499  case COLOR_PH: setResolvedRgb( nPhClr ); break;
500 
501  case COLOR_FINAL: return ::Color(ColorTransparency, mnC1);
502  }
503 
504  // if color is UNUSED or turns to UNUSED in setResolvedRgb, do not perform transformations
505  if( meMode != COLOR_UNUSED )
506  {
507  for (auto const& transform : maTransforms)
508  {
509  switch( transform.mnToken )
510  {
511  case XML_red: toCrgb(); lclSetValue( mnC1, transform.mnValue ); break;
512  case XML_redMod: toCrgb(); lclModValue( mnC1, transform.mnValue ); break;
513  case XML_redOff: toCrgb(); lclOffValue( mnC1, transform.mnValue ); break;
514  case XML_green: toCrgb(); lclSetValue( mnC2, transform.mnValue ); break;
515  case XML_greenMod: toCrgb(); lclModValue( mnC2, transform.mnValue ); break;
516  case XML_greenOff: toCrgb(); lclOffValue( mnC2, transform.mnValue ); break;
517  case XML_blue: toCrgb(); lclSetValue( mnC3, transform.mnValue ); break;
518  case XML_blueMod: toCrgb(); lclModValue( mnC3, transform.mnValue ); break;
519  case XML_blueOff: toCrgb(); lclOffValue( mnC3, transform.mnValue ); break;
520 
521  case XML_hue: toHsl(); lclSetValue( mnC1, transform.mnValue, MAX_DEGREE ); break;
522  case XML_hueMod: toHsl(); lclModValue( mnC1, transform.mnValue, MAX_DEGREE ); break;
523  case XML_hueOff: toHsl(); lclOffValue( mnC1, transform.mnValue, MAX_DEGREE ); break;
524  case XML_sat: toHsl(); lclSetValue( mnC2, transform.mnValue ); break;
525  case XML_satMod: toHsl(); lclModValue( mnC2, transform.mnValue ); break;
526  case XML_satOff: toHsl(); lclOffValue( mnC2, transform.mnValue ); break;
527 
528  case XML_lum:
529  toHsl();
530  lclSetValue( mnC3, transform.mnValue );
531  // if color changes to black or white, it will stay gray if luminance changes again
532  if( (mnC3 == 0) || (mnC3 == MAX_PERCENT) ) mnC2 = 0;
533  break;
534  case XML_lumMod:
535  toHsl();
536  lclModValue( mnC3, transform.mnValue );
537  // if color changes to black or white, it will stay gray if luminance changes again
538  if( (mnC3 == 0) || (mnC3 == MAX_PERCENT) ) mnC2 = 0;
539  break;
540  case XML_lumOff:
541  toHsl();
542  lclOffValue( mnC3, transform.mnValue );
543  // if color changes to black or white, it will stay gray if luminance changes again
544  if( (mnC3 == 0) || (mnC3 == MAX_PERCENT) ) mnC2 = 0;
545  break;
546 
547  case XML_shade:
548  // shade: 0% = black, 100% = original color
549  toCrgb();
550  OSL_ENSURE( (0 <= transform.mnValue) && (transform.mnValue <= MAX_PERCENT), "Color::getColor - invalid shade value" );
551  if( (0 <= transform.mnValue) && (transform.mnValue <= MAX_PERCENT) )
552  {
553  double fFactor = static_cast< double >( transform.mnValue ) / MAX_PERCENT;
554  mnC1 = static_cast< sal_Int32 >( mnC1 * fFactor );
555  mnC2 = static_cast< sal_Int32 >( mnC2 * fFactor );
556  mnC3 = static_cast< sal_Int32 >( mnC3 * fFactor );
557  }
558  break;
559  case XML_tint:
560  // tint: 0% = white, 100% = original color
561  toCrgb();
562  OSL_ENSURE( (0 <= transform.mnValue) && (transform.mnValue <= MAX_PERCENT), "Color::getColor - invalid tint value" );
563  if( (0 <= transform.mnValue) && (transform.mnValue <= MAX_PERCENT) )
564  {
565  double fFactor = static_cast< double >( transform.mnValue ) / MAX_PERCENT;
566  mnC1 = static_cast< sal_Int32 >( MAX_PERCENT - (MAX_PERCENT - mnC1) * fFactor );
567  mnC2 = static_cast< sal_Int32 >( MAX_PERCENT - (MAX_PERCENT - mnC2) * fFactor );
568  mnC3 = static_cast< sal_Int32 >( MAX_PERCENT - (MAX_PERCENT - mnC3) * fFactor );
569  }
570  break;
571  case XLS_TOKEN( tint ):
572  // Excel tint: move luminance relative to current value
573  toHsl();
574  OSL_ENSURE( (-MAX_PERCENT <= transform.mnValue) && (transform.mnValue <= MAX_PERCENT), "Color::getColor - invalid tint value" );
575  if( (-MAX_PERCENT <= transform.mnValue) && (transform.mnValue < 0) )
576  {
577  // negative: luminance towards 0% (black)
578  lclModValue( mnC3, transform.mnValue + MAX_PERCENT );
579  }
580  else if( (0 < transform.mnValue) && (transform.mnValue <= MAX_PERCENT) )
581  {
582  // positive: luminance towards 100% (white)
583  mnC3 = MAX_PERCENT - mnC3;
584  lclModValue( mnC3, MAX_PERCENT - transform.mnValue );
585  mnC3 = MAX_PERCENT - mnC3;
586  }
587  break;
588 
589  case XML_gray:
590  // change color to gray, weighted RGB: 22% red, 72% green, 6% blue
591  toRgb();
592  mnC1 = mnC2 = mnC3 = (mnC1 * 22 + mnC2 * 72 + mnC3 * 6) / 100;
593  break;
594 
595  case XML_comp:
596  // comp: rotate hue by 180 degrees, do not change lum/sat
597  toHsl();
598  mnC1 = (mnC1 + (180 * PER_DEGREE)) % MAX_DEGREE;
599  break;
600  case XML_inv:
601  // invert percentual RGB values
602  toCrgb();
603  mnC1 = MAX_PERCENT - mnC1;
604  mnC2 = MAX_PERCENT - mnC2;
605  mnC3 = MAX_PERCENT - mnC3;
606  break;
607 
608  case XML_gamma:
609  // increase gamma of color
610  toCrgb();
611  mnC1 = lclGamma( mnC1, INC_GAMMA );
612  mnC2 = lclGamma( mnC2, INC_GAMMA );
613  mnC3 = lclGamma( mnC3, INC_GAMMA );
614  break;
615  case XML_invGamma:
616  // decrease gamma of color
617  toCrgb();
618  mnC1 = lclGamma( mnC1, DEC_GAMMA );
619  mnC2 = lclGamma( mnC2, DEC_GAMMA );
620  mnC3 = lclGamma( mnC3, DEC_GAMMA );
621  break;
622  }
623  }
624 
625  // store resulting RGB value in mnC1
626  toRgb();
627  mnC1 = lclRgbComponentsToRgb( mnC1, mnC2, mnC3 );
628  }
629  else // if( meMode != COLOR_UNUSED )
630  {
631  mnC1 = sal_Int32(API_RGB_TRANSPARENT);
632  }
633 
634  sal_Int32 nRet = mnC1;
635  // Restore the original values when the color depends on one of the input
636  // parameters (rGraphicHelper or nPhClr)
637  if( eTempMode >= COLOR_SCHEME && eTempMode <= COLOR_PH )
638  {
639  mnC1 = nTempC1;
640  mnC2 = nTempC2;
641  mnC3 = nTempC3;
642  meMode = eTempMode;
643  }
644  else
645  {
647  }
648  if( meMode == COLOR_FINAL )
649  maTransforms.clear();
650  return ::Color(ColorTransparency, nRet);
651 }
652 
654 {
655  return mnAlpha < MAX_PERCENT;
656 }
657 
658 sal_Int16 Color::getTransparency() const
659 {
660  return sal_Int16(std::round( (1.0 * (MAX_PERCENT - mnAlpha)) / PER_PERCENT) );
661 }
662 
663 // private --------------------------------------------------------------------
664 
665 void Color::setResolvedRgb( ::Color nRgb ) const
666 {
667  meMode = (sal_Int32(nRgb) < 0) ? COLOR_UNUSED : COLOR_RGB;
668  lclRgbToRgbComponents( mnC1, mnC2, mnC3, nRgb );
669 }
670 
671 void Color::toRgb() const
672 {
673  switch( meMode )
674  {
675  case COLOR_RGB:
676  // nothing to do
677  break;
678  case COLOR_CRGB:
679  meMode = COLOR_RGB;
680  mnC1 = lclCrgbCompToRgbComp( lclGamma( mnC1, INC_GAMMA ) );
681  mnC2 = lclCrgbCompToRgbComp( lclGamma( mnC2, INC_GAMMA ) );
682  mnC3 = lclCrgbCompToRgbComp( lclGamma( mnC3, INC_GAMMA ) );
683  break;
684  case COLOR_HSL:
685  {
686  meMode = COLOR_RGB;
687  double fR = 0.0, fG = 0.0, fB = 0.0;
688  if( (mnC2 == 0) || (mnC3 == MAX_PERCENT) )
689  {
690  fR = fG = fB = static_cast< double >( mnC3 ) / MAX_PERCENT;
691  }
692  else if( mnC3 > 0 )
693  {
694  // base color from hue
695  double fHue = static_cast< double >( mnC1 ) / MAX_DEGREE * 6.0; // interval [0.0, 6.0)
696  if( fHue <= 1.0 ) { fR = 1.0; fG = fHue; } // red...yellow
697  else if( fHue <= 2.0 ) { fR = 2.0 - fHue; fG = 1.0; } // yellow...green
698  else if( fHue <= 3.0 ) { fG = 1.0; fB = fHue - 2.0; } // green...cyan
699  else if( fHue <= 4.0 ) { fG = 4.0 - fHue; fB = 1.0; } // cyan...blue
700  else if( fHue <= 5.0 ) { fR = fHue - 4.0; fB = 1.0; } // blue...magenta
701  else { fR = 1.0; fB = 6.0 - fHue; } // magenta...red
702 
703  // apply saturation
704  double fSat = static_cast< double >( mnC2 ) / MAX_PERCENT;
705  fR = (fR - 0.5) * fSat + 0.5;
706  fG = (fG - 0.5) * fSat + 0.5;
707  fB = (fB - 0.5) * fSat + 0.5;
708 
709  // apply luminance
710  double fLum = 2.0 * static_cast< double >( mnC3 ) / MAX_PERCENT - 1.0; // interval [-1.0, 1.0]
711  if( fLum < 0.0 )
712  {
713  double fShade = fLum + 1.0; // interval [0.0, 1.0] (black...full color)
714  fR *= fShade;
715  fG *= fShade;
716  fB *= fShade;
717  }
718  else if( fLum > 0.0 )
719  {
720  double fTint = 1.0 - fLum; // interval [0.0, 1.0] (white...full color)
721  fR = 1.0 - ((1.0 - fR) * fTint);
722  fG = 1.0 - ((1.0 - fG) * fTint);
723  fB = 1.0 - ((1.0 - fB) * fTint);
724  }
725  }
726  mnC1 = static_cast< sal_Int32 >( fR * 255.0 + 0.5 );
727  mnC2 = static_cast< sal_Int32 >( fG * 255.0 + 0.5 );
728  mnC3 = static_cast< sal_Int32 >( fB * 255.0 + 0.5 );
729  }
730  break;
731  default:
732  OSL_FAIL( "Color::toRgb - unexpected color mode" );
733  }
734 }
735 
736 void Color::toCrgb() const
737 {
738  switch( meMode )
739  {
740  case COLOR_HSL:
741  toRgb();
742  [[fallthrough]];
743  case COLOR_RGB:
744  meMode = COLOR_CRGB;
745  mnC1 = lclGamma( lclRgbCompToCrgbComp( mnC1 ), DEC_GAMMA );
746  mnC2 = lclGamma( lclRgbCompToCrgbComp( mnC2 ), DEC_GAMMA );
747  mnC3 = lclGamma( lclRgbCompToCrgbComp( mnC3 ), DEC_GAMMA );
748  break;
749  case COLOR_CRGB:
750  // nothing to do
751  break;
752  default:
753  OSL_FAIL( "Color::toCrgb - unexpected color mode" );
754  }
755 }
756 
757 void Color::toHsl() const
758 {
759  switch( meMode )
760  {
761  case COLOR_CRGB:
762  toRgb();
763  [[fallthrough]];
764  case COLOR_RGB:
765  {
766  meMode = COLOR_HSL;
767  double fR = static_cast< double >( mnC1 ) / 255.0; // red [0.0, 1.0]
768  double fG = static_cast< double >( mnC2 ) / 255.0; // green [0.0, 1.0]
769  double fB = static_cast< double >( mnC3 ) / 255.0; // blue [0.0, 1.0]
770  double fMin = ::std::min( ::std::min( fR, fG ), fB );
771  double fMax = ::std::max( ::std::max( fR, fG ), fB );
772  double fD = fMax - fMin;
773 
774  using ::rtl::math::approxEqual;
775 
776  // hue: 0deg = red, 120deg = green, 240deg = blue
777  if( fD == 0.0 ) // black/gray/white
778  mnC1 = 0;
779  else if( approxEqual(fMax, fR, 64) ) // magenta...red...yellow
780  mnC1 = static_cast< sal_Int32 >( ((fG - fB) / fD * 60.0 + 360.0) * PER_DEGREE + 0.5 ) % MAX_DEGREE;
781  else if( approxEqual(fMax, fG, 64) ) // yellow...green...cyan
782  mnC1 = static_cast< sal_Int32 >( ((fB - fR) / fD * 60.0 + 120.0) * PER_DEGREE + 0.5 );
783  else // cyan...blue...magenta
784  mnC1 = static_cast< sal_Int32 >( ((fR - fG) / fD * 60.0 + 240.0) * PER_DEGREE + 0.5 );
785 
786  // luminance: 0% = black, 50% = full color, 100% = white
787  mnC3 = static_cast< sal_Int32 >( (fMin + fMax) / 2.0 * MAX_PERCENT + 0.5 );
788 
789  // saturation: 0% = gray, 100% = full color
790  if( (mnC3 == 0) || (mnC3 == MAX_PERCENT) ) // black/white
791  mnC2 = 0;
792  else if( mnC3 <= 50 * PER_PERCENT ) // dark...full color
793  mnC2 = static_cast< sal_Int32 >( fD / (fMin + fMax) * MAX_PERCENT + 0.5 );
794  else // full color...light
795  mnC2 = static_cast< sal_Int32 >( fD / (2.0 - fMax - fMin) * MAX_PERCENT + 0.5 );
796  }
797  break;
798  case COLOR_HSL:
799  // nothing to do
800  break;
801  default:
802  OSL_FAIL( "Color::toHsl - unexpected color mode" );
803  }
804 }
805 
806 } // namespace oox
807 
808 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Relative RGB (r/g/b: 0...100000).
Definition: color.hxx:129
Provides helper functions for colors, device measurement conversion, graphics, and graphic objects ha...
bool hasTransparency() const
Returns true, if the color is transparent.
Definition: color.cxx:653
Absolute RGB (r/g/b: 0...255).
Definition: color.hxx:128
virtual ::Color getSchemeColor(sal_Int32 nToken) const
Derived classes may implement to resolve a scheme color from the passed XML token identifier...
const char * sName
Definition: olehelper.cxx:92
const ::Color API_RGB_TRANSPARENT(ColorTransparency, 0xffffffff)
Transparent color for API calls.
void setSysClr(sal_Int32 nToken, sal_Int32 nLastRgb)
Sets a system color from the a:sysClr element.
Definition: color.cxx:319
void setSchemeClr(sal_Int32 nToken)
Sets a scheme color from the a:schemeClr element.
Definition: color.cxx:305
sal_uInt8 GetRed() const
const sal_Int32 PER_DEGREE
void setHighlight(sal_Int32 nToken)
Sets a predefined color from the w:highlight element.
Definition: color.cxx:297
static const VectorType::value_type * getVectorElement(const VectorType &rVector, sal_Int32 nIndex)
Returns the pointer to an existing element of the passed vector, or a null pointer, if the passed index is out of bounds.
const sal_Int32 PER_PERCENT
void setPaletteClr(sal_Int32 nPaletteIdx)
Sets a palette color index.
Definition: color.cxx:312
::Color getSystemColor(sal_Int32 nToken,::Color nDefaultRgb=API_RGB_TRANSPARENT) const
Returns a system color specified by the passed XML token identifier.
Placeholder color in theme style lists.
Definition: color.hxx:134
sal_Int32 mnC3
Green, green%, saturation, or system default RGB.
Definition: color.hxx:150
sal_Int32 mnC2
Red, red%, hue, scheme token, palette index, system token, or final RGB.
Definition: color.hxx:149
bool equals(const Color &rOther, const GraphicHelper &rGraphicHelper,::Color nPhClr) const
Compares this color with rOther.
Definition: color.cxx:468
std::vector< Transformation > maTransforms
Current color mode.
Definition: color.hxx:147
void setHslClr(sal_Int32 nHue, sal_Int32 nSat, sal_Int32 nLum)
Sets the HSL values from the a:hslClr element.
Definition: color.cxx:278
css::uno::Sequence< css::beans::PropertyValue > maInteropTransformations
Scheme name from the a:schemeClr element for interoperability purposes.
Definition: color.hxx:155
static sal_Int32 getColorTransformationToken(std::u16string_view sName)
Translates between color transformation token names and the corresponding token.
Definition: color.cxx:405
void toRgb() const
Converts the color components to RGB values.
Definition: color.cxx:671
XML_TOKEN_INVALID
HSL (hue: 0...21600000, sat/lum: 0...100000).
Definition: color.hxx:130
sal_uInt8 GetBlue() const
ColorMode meMode
void setScrgbClr(sal_Int32 nR, sal_Int32 nG, sal_Int32 nB)
Sets the percentual RGB values from the a:scrgbClr element.
Definition: color.cxx:267
::Color getDmlPresetColor(sal_Int32 nToken,::Color nDefaultRgb)
Returns the RGB value for the passed DrawingML color token, or nDefaultRgb on error.
Definition: color.cxx:223
sal_Int32 mnAlpha
Blue, blue%, or luminance.
Definition: color.hxx:151
::Color getColor(const GraphicHelper &rGraphicHelper,::Color nPhClr=API_RGB_TRANSPARENT) const
Returns the final RGB color value.
Definition: color.cxx:481
void clearTransformations()
Removes all color transformations.
Definition: color.cxx:361
ColorVector maDmlColors
Definition: color.cxx:40
::Color getVmlPresetColor(sal_Int32 nToken,::Color nDefaultRgb)
Returns the RGB value for the passed VML color token, or nDefaultRgb on error.
Definition: color.cxx:232
const sal_Int32 MAX_PERCENT
::Color getHighlightColor(sal_Int32 nToken,::Color nDefaultRgb)
Returns the RGB value for the passed VML color token, or nDefaultRgb on error.
Definition: color.cxx:241
void toCrgb() const
Converts the color components to CRGB values (gamma corrected percentage).
Definition: color.cxx:736
float u
const sal_Int32 MAX_DEGREE
void addTransformation(sal_Int32 nElement, sal_Int32 nValue=-1)
Inserts the passed color transformation.
Definition: color.cxx:327
void setResolvedRgb(::Color nRgb) const
Internal helper for getColor().
Definition: color.cxx:665
ColorTransparency
void clearTransparence()
Removes transparence from the color.
Definition: color.cxx:476
ColorVector maHighlightColors
Predefined colors in VML, indexed by XML token.
Definition: color.cxx:42
void setPrstClr(sal_Int32 nToken)
Sets a predefined color from the a:prstClr element.
Definition: color.cxx:289
virtual ::Color getPaletteColor(sal_Int32 nPaletteIdx) const
Derived classes may implement to resolve a palette index to an RGB color.
sal_uInt8 GetGreen() const
void addChartTintTransformation(double fTint)
Inserts Chart specific color tint (-1.0...0.0 = shade, 0.0...1.0 = tint).
Definition: color.cxx:346
DefTokenId nToken
Color from application defined palette.
Definition: color.hxx:132
void setSrgbClr(sal_Int32 nRgb)
Sets an RGB value (hexadecimal RRGGBB) from the a:srgbClr element.
Definition: color.cxx:260
void addExcelTintTransformation(double fTint)
Inserts Excel specific color tint (-1.0...0.0 = shade, 0.0...1.0 = tint).
Definition: color.cxx:355
sal_Int32 mnC1
Color transformations.
Definition: color.hxx:148
static OUString getColorTransformationName(sal_Int32 nElement)
Translates between color transformation tokens and their names.
Definition: color.cxx:368
ColorMode meMode
Definition: color.hxx:145
void setUnused()
Sets the color to unused state.
Definition: color.cxx:250
sal_Int16 getTransparency() const
Returns the transparency of the color (0 = opaque, 100 = full transparent).
Definition: color.cxx:658
#define SAL_WARN(area, stream)
Color is not used, or undefined.
Definition: color.hxx:127
Color from system palette.
Definition: color.hxx:133
ColorVector maVmlColors
Predefined colors in DrawingML, indexed by XML token.
Definition: color.cxx:41
constexpr Color()
sal_Int16 nValue
void toHsl() const
Converts the color components to HSL values.
Definition: color.cxx:757