LCOV - app.info - objdir/dist/include/skia/SkColor.h

LCOV - code coverage report
| Current view: | directory - objdir/dist/include/skia - SkColor.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 3 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 1 | 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                 : static inline SkColor SkColorSetA(SkColor c, U8CPU a) {
          71                 :     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