include/docmodel/color/ComplexColor.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  */
  10
  11 #pragma once
  12
  13 #include <docmodel/dllapi.h>
  14 #include <tools/color.hxx>
  15 #include <docmodel/theme/ThemeColorType.hxx>
  16 #include <docmodel/color/Transformation.hxx>
  17 #include <o3tl/hash_combine.hxx>
  18
  19 #include <vector>
  20
  21 namespace model
  22 {
  23 enum class ColorType
  24 {
  25     Unused,
  26     RGB,
  27     CRGB,
  28     HSL,
  29     Theme,
  30     Palette,
  31     System,
  32     Placeholder
  33 };
  34
  35 enum class SystemColorType
  36 {
  37     Unused,
  38     DarkShadow3D,
  39     Light3D,
  40     ActiveBorder,
  41     ActiveCaption,
  42     AppWorkspace,
  43     Background,
  44     ButtonFace,
  45     ButtonHighlight,
  46     ButtonShadow,
  47     ButtonText,
  48     CaptionText,
  49     GradientActiveCaption,
  50     GradientInactiveCaption,
  51     GrayText,
  52     Highlight,
  53     HighlightText,
  54     HotLight,
  55     InactiveBorder,
  56     InactiveCaption,
  57     InactiveCaptionText,
  58     InfoBack,
  59     InfoText,
  60     Menu,
  61     MenuBar,
  62     MenuHighlight,
  63     MenuText,
  64     ScrollBar,
  65     Window,
  66     WindowFrame,
  67     WindowText
  68 };
  69
  70 /** Definition of a color with multiple representations
  71  *
  72  * A color that can be expresses as a RGB, CRGB or HSL representation or
  73  * a more abstract representation as for example system color, palette,
  74  * theme color or a placeholder. In these representations the
  75  * color needs to be additionally
  76  *
  77  * The color can also have transformations defined, which in addition
  78  * manipulates the resulting color (i.e. tints, shades, alpha,...).
  79  */
  80 class DOCMODEL_DLLPUBLIC ComplexColor
  81 {
  82 private:
  83     ColorType meType = ColorType::Unused;
  84
  85     double mnComponent1 = 0.0; // Red, Hue
  86     double mnComponent2 = 0.0; // Green, Saturation
  87     double mnComponent3 = 0.0; // Blue, Luminance
  88
  89     SystemColorType meSystemColorType = SystemColorType::Unused;
  90     ::Color maLastColor;
  91
  92     ThemeColorType meThemeColorType = ThemeColorType::Unknown;
  93     ThemeColorUsage meThemeColorUsage = ThemeColorUsage::Unknown;
  94
  95     std::vector<Transformation> maTransformations;
  96
  97     ::Color maFinalColor;
  98
  99 public:
 100     ColorType getType() const { return meType; }
 101     void setType(ColorType eType) { meType = eType; }
 102
 103     ThemeColorType getThemeColorType() const { return meThemeColorType; }
 104     bool isValidThemeType() const
 105     {
 106         return meType == model::ColorType::Theme && meThemeColorType != ThemeColorType::Unknown;
 107     }
 108
 109     ThemeColorUsage getThemeColorUsage() const { return meThemeColorUsage; }
 110     void setThemeColorUsage(ThemeColorUsage eThemeColorUsage)
 111     {
 112         meThemeColorUsage = eThemeColorUsage;
 113     }
 114
 115     SystemColorType getSystemColorType() const { return meSystemColorType; }
 116
 117     void setSystemColorType(SystemColorType eSystemColorType)
 118     {
 119         meSystemColorType = eSystemColorType;
 120         meType = ColorType::System;
 121     }
 122
 123     Color getRGBColor() const { return Color(mnComponent1, mnComponent2, mnComponent3); }
 124
 125     std::vector<Transformation> const& getTransformations() const { return maTransformations; }
 126
 127     void setTransformations(std::vector<Transformation> const& rTransformations)
 128     {
 129         maTransformations = rTransformations;
 130     }
 131
 132     void addTransformation(Transformation const& rTransform)
 133     {
 134         maTransformations.push_back(rTransform);
 135     }
 136
 137     void removeTransformations(TransformationType eType)
 138     {
 139         std::erase_if(maTransformations, [eType](Transformation const& rTransform) {
 140             return rTransform.meType == eType;
 141         });
 142     }
 143
 144     void clearTransformations() { maTransformations.clear(); }
 145
 146     double getRed() const { return mnComponent1; }
 147     double getGreen() const { return mnComponent2; }
 148     double getBlue() const { return mnComponent3; }
 149
 150     void setCRGB(sal_Int32 nR, sal_Int32 nG, sal_Int32 nB)
 151     {
 152         mnComponent1 = nR;
 153         mnComponent2 = nG;
 154         mnComponent3 = nB;
 155         meType = ColorType::CRGB;
 156     }
 157
 158     Color getRGB() const { return Color(mnComponent1, mnComponent2, mnComponent3); }
 159
 160     void setColor(Color const& rColor)
 161     {
 162         mnComponent1 = rColor.GetRed();
 163         mnComponent2 = rColor.GetGreen();
 164         mnComponent3 = rColor.GetBlue();
 165         maFinalColor = rColor;
 166         meType = ColorType::RGB;
 167     }
 168
 169     void setRGB(sal_Int32 nRGB)
 170     {
 171         ::Color aColor(ColorTransparency, nRGB);
 172         setColor(aColor);
 173     }
 174
 175     void setHSL(sal_Int32 nH, sal_Int32 nS, sal_Int32 nL)
 176     {
 177         mnComponent1 = nH;
 178         mnComponent2 = nS;
 179         mnComponent3 = nL;
 180         meType = ColorType::HSL;
 181     }
 182
 183     void setSystemColor(SystemColorType eSystemColorType, sal_Int32 nRGB)
 184     {
 185         maLastColor = ::Color(ColorTransparency, nRGB);
 186         meSystemColorType = eSystemColorType;
 187         meType = ColorType::System;
 188     }
 189
 190     void setThemePlaceholder() { meType = ColorType::Placeholder; }
 191
 192     void setThemeColor(ThemeColorType eType)
 193     {
 194         meThemeColorType = eType;
 195         meType = ColorType::Theme;
 196     }
 197
 198     bool operator==(const ComplexColor& rComplexColor) const
 199     {
 200         return meType == rComplexColor.meType && mnComponent1 == rComplexColor.mnComponent1
 201                && mnComponent2 == rComplexColor.mnComponent2
 202                && mnComponent3 == rComplexColor.mnComponent3
 203                && meSystemColorType == rComplexColor.meSystemColorType
 204                && maLastColor == rComplexColor.maLastColor
 205                && meThemeColorType == rComplexColor.meThemeColorType
 206                && maTransformations.size() == rComplexColor.maTransformations.size()
 207                && std::equal(maTransformations.begin(), maTransformations.end(),
 208                              rComplexColor.maTransformations.begin());
 209     }
 210
 211     /** Applies the defined transformations to the input color */
 212     Color applyTransformations(Color const& rColor) const
 213     {
 214         Color aColor(rColor);
 215
 216         for (auto const& rTransform : maTransformations)
 217         {
 218             switch (rTransform.meType)
 219             {
 220                 case TransformationType::Tint:
 221                     aColor.ApplyTintOrShade(rTransform.mnValue);
 222                     break;
 223                 case TransformationType::Shade:
 224                     aColor.ApplyTintOrShade(-rTransform.mnValue);
 225                     break;
 226                 case TransformationType::LumMod:
 227                     aColor.ApplyLumModOff(rTransform.mnValue, 0);
 228                     break;
 229                 case TransformationType::LumOff:
 230                     aColor.ApplyLumModOff(10000, rTransform.mnValue);
 231                     break;
 232                 default:
 233                     break;
 234             }
 235         }
 236         return aColor;
 237     }
 238
 239     void setFinalColor(Color const& rColor) { maFinalColor = rColor; }
 240
 241     Color const& getFinalColor() const { return maFinalColor; }
 242
 243     std::size_t getHash() const
 244     {
 245         std::size_t seed = 0;
 246         o3tl::hash_combine(seed, meType);
 247         o3tl::hash_combine(seed, mnComponent1);
 248         o3tl::hash_combine(seed, mnComponent2);
 249         o3tl::hash_combine(seed, mnComponent3);
 250         o3tl::hash_combine(seed, meSystemColorType);
 251         o3tl::hash_combine(seed, sal_uInt32(maLastColor));
 252         for (auto const& rTransform : maTransformations)
 253             o3tl::hash_combine(seed, rTransform);
 254         o3tl::hash_combine(seed, sal_uInt32(maFinalColor));
 255         return seed;
 256     }
 257
 258     static model::ComplexColor createRGB(Color const& rColor)
 259     {
 260         model::ComplexColor aComplexColor;
 261         aComplexColor.setColor(rColor);
 262         return aComplexColor;
 263     }
 264
 265     static model::ComplexColor Theme(ThemeColorType eThemeColorType)
 266     {
 267         model::ComplexColor aComplexColor;
 268         aComplexColor.setThemeColor(eThemeColorType);
 269         return aComplexColor;
 270     }
 271 };
 272
 273 } // end of namespace model
 274
 275 namespace std
 276 {
 277 template <> struct hash<model::ComplexColor>
 278 {
 279     std::size_t operator()(model::ComplexColor const& rColor) const { return rColor.getHash(); }
 280 };
 281 }
 282
 283 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */