src/graphics/FGrpColor.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 /*
  19  * @file        FGrpColor.cpp
  20  * @brief       This is the implementation file for Color class.
  21  *
  22  * This file contains implementation of Color class.
  23  *
  24  */
  25
  26 #include <FGrpColor.h>
  27
  28
  29 namespace Tizen { namespace Graphics
  30 {
  31
  32 Color::Color(void)
  33         : __color(0)
  34         , __pImpl(null)
  35 {
  36 }
  37
  38 Color::Color(const Color& rhs)
  39         : __color(0)
  40         , __pImpl(null)
  41 {
  42         __color = rhs.GetRGB32();
  43 }
  44
  45 Color::Color(byte red, byte green, byte blue, byte alpha)
  46         : __color(0)
  47         , __pImpl(null)
  48 {
  49         SetColorComponents(red, green, blue, alpha);
  50 }
  51
  52 Color::Color(unsigned int rgb, bool hasAlpha)
  53         : __pImpl(null)
  54 {
  55         SetRGB32(rgb, hasAlpha);
  56 }
  57
  58 Color::~Color(void)
  59 {
  60 }
  61
  62 bool
  63 Color::operator ==(const Color& rhs) const
  64 {
  65         return (__color == rhs.__color);
  66 }
  67
  68 bool
  69 Color::operator !=(const Color& rhs) const
  70 {
  71         return (!operator ==(rhs));
  72 }
  73
  74 Color&
  75 Color::operator =(const Color& rhs)
  76 {
  77         if (this == &rhs)
  78         {
  79                 return *this;
  80         }
  81
  82         __color = rhs.GetRGB32();
  83
  84         return (*this);
  85 }
  86
  87 bool
  88 Color::Equals(const Tizen::Base::Object& rhs) const
  89 {
  90         if (&rhs == null)
  91         {
  92                 return false;
  93         }
  94
  95         const Color* pColor = dynamic_cast <const Color*>(&rhs);
  96
  97         if (pColor == null)
  98         {
  99                 return false;
 100         }
 101
 102         return (*this == *pColor);
 103 }
 104
 105 int
 106 Color::GetHashCode(void) const
 107 {
 108         return int(__color);
 109 }
 110
 111 byte
 112 Color::GetAlpha(void) const
 113 {
 114         return byte((__color >> 24) & 0xFF);
 115 }
 116
 117 byte
 118 Color::GetRed(void) const
 119 {
 120         return byte((__color >> 16) & 0xFF);
 121 }
 122
 123 byte
 124 Color::GetGreen(void) const
 125 {
 126         return byte((__color >> 8) & 0xFF);
 127 }
 128
 129 byte
 130 Color::GetBlue(void) const
 131 {
 132         return byte((__color >> 0) & 0xFF);
 133 }
 134
 135 void
 136 Color::GetColorComponents(byte& red, byte& green, byte& blue, byte& alpha) const
 137 {
 138         red = GetRed();
 139         green = GetGreen();
 140         blue = GetBlue();
 141         alpha = GetAlpha();
 142 }
 143
 144 unsigned int
 145 Color::GetRGB32(void) const
 146 {
 147         return __color;
 148 }
 149
 150 void
 151 Color::SetAlpha(byte alpha)
 152 {
 153         __color &= (0x00FFFFFF);
 154         __color |= ((alpha & 0xFF) << 24);
 155 }
 156
 157 void
 158 Color::SetRed(byte red)
 159 {
 160         __color &= (0xFF00FFFF);
 161         __color |= ((red & 0xFF) << 16);
 162 }
 163
 164 void
 165 Color::SetGreen(byte green)
 166 {
 167         __color &= (0xFFFF00FF);
 168         __color |= ((green & 0xFF) << 8);
 169 }
 170
 171 void
 172 Color::SetBlue(byte blue)
 173 {
 174         __color &= (0xFFFFFF00);
 175         __color |= ((blue & 0xFF) << 0);
 176 }
 177
 178 void
 179 Color::SetColorComponents(byte red, byte green, byte blue, byte alpha)
 180 {
 181         SetRed(red);
 182         SetGreen(green);
 183         SetBlue(blue);
 184         SetAlpha(alpha);
 185 }
 186
 187 void
 188 Color::SetRGB32(unsigned int rgb, bool hasAlpha)
 189 {
 190         __color = ((hasAlpha ? rgb : (0xFF000000 | rgb)));
 191 }
 192
 193 Color
 194 Color::GetColor(ColorId colorId)
 195 {
 196         Color color(0xFF000000);
 197
 198         switch (colorId)
 199         {
 200         case COLOR_ID_BLACK:
 201                 color.SetRGB32(0xFF000000);
 202                 break;
 203         case COLOR_ID_BLUE:
 204                 color.SetRGB32(0xFF0000FF);
 205                 break;
 206         case COLOR_ID_CYAN:
 207                 color.SetRGB32(0xFF00FFFF);
 208                 break;
 209         case COLOR_ID_GREEN:
 210                 color.SetRGB32(0xFF00FF00);
 211                 break;
 212         case COLOR_ID_GREY:
 213                 color.SetRGB32(0xFFC0C0C0);
 214                 break;
 215         case COLOR_ID_MAGENTA:
 216                 color.SetRGB32(0xFFFF00FF);
 217                 break;
 218         case COLOR_ID_RED:
 219                 color.SetRGB32(0xFFFF0000);
 220                 break;
 221         case COLOR_ID_VIOLET:
 222                 color.SetRGB32(0xFF4F2F4F);
 223                 break;
 224         case COLOR_ID_YELLOW:
 225                 color.SetRGB32(0xFFFFFF00);
 226                 break;
 227         case COLOR_ID_WHITE:
 228                 color.SetRGB32(0xFFFFFFFF);
 229                 break;
 230         }
 231
 232         return color;
 233 }
 234
 235 }} // Tizen::Graphics