LCOV - code coverage report
Current view: directory - gfx/skia/include/core - SkColor.h (source / functions) Found Hit Coverage
Test: app.info Lines: 5 0 0.0 %
Date: 2012-06-02 Functions: 2 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       4                 :  *
       5                 :  * Use of this source code is governed by a BSD-style license that can be
       6                 :  * found in the LICENSE file.
       7                 :  */
       8                 : 
       9                 : 
      10                 : #ifndef SkColor_DEFINED
      11                 : #define SkColor_DEFINED
      12                 : 
      13                 : #include "SkScalar.h"
      14                 : 
      15                 : /** \file SkColor.h
      16                 : 
      17                 :     Types and macros for colors
      18                 : */
      19                 : 
      20                 : /** 8-bit type for an alpha value. 0xFF is 100% opaque, 0x00 is 100% transparent.
      21                 : */
      22                 : typedef uint8_t SkAlpha;
      23                 : /** 32 bit ARGB color value, not premultiplied. The color components are always in
      24                 :     a known order. This is different from SkPMColor, which has its bytes in a configuration
      25                 :     dependent order, to match the format of kARGB32 bitmaps. SkColor is the type used to
      26                 :     specify colors in SkPaint and in gradients.
      27                 : */
      28                 : typedef uint32_t SkColor;
      29                 : 
      30                 : /** Return a SkColor value from 8 bit component values
      31                 : */
      32               0 : static inline SkColor SkColorSetARGBInline(U8CPU a, U8CPU r, U8CPU g, U8CPU b)
      33                 : {
      34               0 :     SkASSERT(a <= 255 && r <= 255 && g <= 255 && b <= 255);
      35                 : 
      36               0 :     return (a << 24) | (r << 16) | (g << 8) | (b << 0);
      37                 : }
      38                 : 
      39                 : #define SkColorSetARGBMacro(a, r, g, b) \
      40                 :     static_cast<SkColor>( \
      41                 :         (static_cast<U8CPU>(a) << 24) | \
      42                 :         (static_cast<U8CPU>(r) << 16) | \
      43                 :         (static_cast<U8CPU>(g) << 8) | \
      44                 :         (static_cast<U8CPU>(b) << 0))
      45                 : 
      46                 : /** gcc will generate static initializers for code of this form:
      47                 :  * static const SkColor kMyColor = SkColorSetARGB(0xFF, 0x01, 0x02, 0x03)
      48                 :  * if SkColorSetARGB() is a static inline, but not if it's a macro.
      49                 :  */
      50                 : #if defined(NDEBUG)
      51                 : #define SkColorSetARGB(a, r, g, b) SkColorSetARGBMacro(a, r, g, b)
      52                 : #else
      53                 : #define SkColorSetARGB(a, r, g, b) SkColorSetARGBInline(a, r, g, b)
      54                 : #endif
      55                 : 
      56                 : /** Return a SkColor value from 8 bit component values, with an implied value
      57                 :     of 0xFF for alpha (fully opaque)
      58                 : */
      59                 : #define SkColorSetRGB(r, g, b)  SkColorSetARGB(0xFF, r, g, b)
      60                 : 
      61                 : /** return the alpha byte from a SkColor value */
      62                 : #define SkColorGetA(color)      (((color) >> 24) & 0xFF)
      63                 : /** return the red byte from a SkColor value */
      64                 : #define SkColorGetR(color)      (((color) >> 16) & 0xFF)
      65                 : /** return the green byte from a SkColor value */
      66                 : #define SkColorGetG(color)      (((color) >>  8) & 0xFF)
      67                 : /** return the blue byte from a SkColor value */
      68                 : #define SkColorGetB(color)      (((color) >>  0) & 0xFF)
      69                 : 
      70               0 : static inline SkColor SkColorSetA(SkColor c, U8CPU a) {
      71               0 :     return (c & 0x00FFFFFF) | (a << 24);
      72                 : }
      73                 : 
      74                 : // common colors
      75                 : 
      76                 : #define SK_ColorBLACK   0xFF000000  //!< black SkColor value
      77                 : #define SK_ColorDKGRAY  0xFF444444  //!< dark gray SkColor value
      78                 : #define SK_ColorGRAY    0xFF888888  //!< gray SkColor value
      79                 : #define SK_ColorLTGRAY  0xFFCCCCCC  //!< light gray SkColor value
      80                 : #define SK_ColorWHITE   0xFFFFFFFF  //!< white SkColor value
      81                 : 
      82                 : #define SK_ColorRED     0xFFFF0000  //!< red SkColor value
      83                 : #define SK_ColorGREEN   0xFF00FF00  //!< green SkColor value
      84                 : #define SK_ColorBLUE    0xFF0000FF  //!< blue SkColor value
      85                 : #define SK_ColorYELLOW  0xFFFFFF00  //!< yellow SkColor value
      86                 : #define SK_ColorCYAN    0xFF00FFFF  //!< cyan SkColor value
      87                 : #define SK_ColorMAGENTA 0xFFFF00FF  //!< magenta SkColor value
      88                 : 
      89                 : ////////////////////////////////////////////////////////////////////////
      90                 : 
      91                 : /** Convert RGB components to HSV.
      92                 :         hsv[0] is Hue [0 .. 360)
      93                 :         hsv[1] is Saturation [0...1]
      94                 :         hsv[2] is Value [0...1]
      95                 :     @param red  red component value [0..255]
      96                 :     @param green  green component value [0..255]
      97                 :     @param blue  blue component value [0..255]
      98                 :     @param hsv  3 element array which holds the resulting HSV components.
      99                 : */
     100                 : SK_API void SkRGBToHSV(U8CPU red, U8CPU green, U8CPU blue, SkScalar hsv[3]);
     101                 : 
     102                 : /** Convert the argb color to its HSV components.
     103                 :         hsv[0] is Hue [0 .. 360)
     104                 :         hsv[1] is Saturation [0...1]
     105                 :         hsv[2] is Value [0...1]
     106                 :     @param color the argb color to convert. Note: the alpha component is ignored.
     107                 :     @param hsv  3 element array which holds the resulting HSV components.
     108                 : */
     109                 : static inline void SkColorToHSV(SkColor color, SkScalar hsv[3])
     110                 : {
     111                 :     SkRGBToHSV(SkColorGetR(color), SkColorGetG(color), SkColorGetB(color), hsv);
     112                 : }
     113                 : 
     114                 : /** Convert HSV components to an ARGB color. The alpha component is passed through unchanged.
     115                 :         hsv[0] is Hue [0 .. 360)
     116                 :         hsv[1] is Saturation [0...1]
     117                 :         hsv[2] is Value [0...1]
     118                 :     If hsv values are out of range, they are pinned.
     119                 :     @param alpha the alpha component of the returned argb color.
     120                 :     @param hsv  3 element array which holds the input HSV components.
     121                 :     @return the resulting argb color
     122                 : */
     123                 : SK_API SkColor SkHSVToColor(U8CPU alpha, const SkScalar hsv[3]);
     124                 : 
     125                 : /** Convert HSV components to an ARGB color. The alpha component set to 0xFF.
     126                 :         hsv[0] is Hue [0 .. 360)
     127                 :         hsv[1] is Saturation [0...1]
     128                 :         hsv[2] is Value [0...1]
     129                 :     If hsv values are out of range, they are pinned.
     130                 :     @param hsv  3 element array which holds the input HSV components.
     131                 :     @return the resulting argb color
     132                 : */
     133                 : static inline SkColor SkHSVToColor(const SkScalar hsv[3])
     134                 : {
     135                 :     return SkHSVToColor(0xFF, hsv);
     136                 : }
     137                 : 
     138                 : ////////////////////////////////////////////////////////////////////////
     139                 : 
     140                 : /** 32 bit ARGB color value, premultiplied. The byte order for this value is
     141                 :     configuration dependent, matching the format of kARGB32 bitmaps. This is different
     142                 :     from SkColor, which is nonpremultiplied, and is always in the same byte order.
     143                 : */
     144                 : typedef uint32_t SkPMColor;
     145                 : 
     146                 : /** Return a SkPMColor value from unpremultiplied 8 bit component values
     147                 : */
     148                 : SK_API SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
     149                 : /** Return a SkPMColor value from a SkColor value. This is done by multiplying the color
     150                 :     components by the color's alpha, and by arranging the bytes in a configuration
     151                 :     dependent order, to match the format of kARGB32 bitmaps.
     152                 : */
     153                 : SK_API SkPMColor SkPreMultiplyColor(SkColor c);
     154                 : 
     155                 : /** Define a function pointer type for combining two premultiplied colors
     156                 : */
     157                 : typedef SkPMColor (*SkXfermodeProc)(SkPMColor src, SkPMColor dst);
     158                 : 
     159                 : /** Define a function pointer type for combining a premultiplied src color
     160                 :     and a 16bit device color.
     161                 : */
     162                 : typedef uint16_t (*SkXfermodeProc16)(SkPMColor src, uint16_t dst);
     163                 : 
     164                 : #endif
     165                 : 

Generated by: LCOV version 1.7