2022年6月27日 (月) 10:32時点における版

https://docs.lvgl.io/8.2/overview/style.html

英文	自動翻訳

Colors

The color module handles all color-related functions like changing color depth, creating colors from hex code, converting between color depths, mixing colors, etc.

The type lv_color_t is used to store a color. Its fields are set according to LV_COLOR_DEPTH in lv_conf.h. (See below)

You may set LV_COLOR_16_SWAP in lv_conf.h to swap bytes of RGB565 colors. You may need this when sending 16-bit colors via a byte-oriented interface like SPI. As 16-bit numbers are stored in little-endian format (lower byte at the lower address), the interface will send the lower byte first. However, displays usually need the higher byte first. A mismatch in the byte order will result in highly distorted colors.

Creating colors

RGB

Create colors from Red, Green and Blue channel values:

//All channels are 0-255
lv_color_t c = lv_color_make(red, green, blue);

//From hex code 0x000000..0xFFFFFF interpreted as RED + GREEN + BLUE
lv_color_t c = lv_color_hex(0x123456); 

//From 3 digits. Same as lv_color_hex(0x112233)
lv_color_t c = lv_color_hex3(0x123);

HSV

Create colors from Hue, Saturation and Value values:

//h = 0..359, s = 0..100, v = 0..100
lv_color_t c = lv_color_hsv_to_rgb(h, s, v);

//All channels are 0-255
lv_color_hsv_t c_hsv = lv_color_rgb_to_hsv(r, g, b);


//From lv_color_t variable
lv_color_hsv_t c_hsv = lv_color_to_hsv(color);

Palette

LVGL includes Material Design's palette of colors. In this system all named colors have a nominal main color as well as four darker and five lighter variants.

The names of the colors are as follows:

LV_PALETTE_RED
LV_PALETTE_PINK
LV_PALETTE_PURPLE
LV_PALETTE_DEEP_PURPLE
LV_PALETTE_INDIGO
LV_PALETTE_BLUE
LV_PALETTE_LIGHT_BLUE
LV_PALETTE_CYAN
LV_PALETTE_TEAL
LV_PALETTE_GREEN
LV_PALETTE_LIGHT_GREEN
LV_PALETTE_LIME
LV_PALETTE_YELLOW
LV_PALETTE_AMBER
LV_PALETTE_ORANGE
LV_PALETTE_DEEP_ORANGE
LV_PALETTE_BROWN
LV_PALETTE_BLUE_GREY
LV_PALETTE_GREY

To get the main color use lv_color_t c = lv_palette_main(LV_PALETTE_...).

For the lighter variants of a palette color use lv_color_t c = lv_palette_lighten(LV_PALETTE_..., v). v can be 1..5. For the darker variants of a palette color use lv_color_t c = lv_palette_darken(LV_PALETTE_..., v). v can be 1..4.

Modify and mix colors

The following functions can modify a color:

// Lighten a color. 0: no change, 255: white
lv_color_t c = lv_color_lighten(c, lvl);

// Darken a color. 0: no change, 255: black
lv_color_t c = lv_color_darken(lv_color_t c, lv_opa_t lvl);

// Lighten or darken a color. 0: black, 128: no change 255: white
lv_color_t c = lv_color_change_lightness(lv_color_t c, lv_opa_t lvl);


// Mix two colors with a given ratio 0: full c2, 255: full c1, 128: half c1 and half c2
lv_color_t c = lv_color_mix(c1, c2, ratio);

Built-in colors

lv_color_white() and lv_color_black() return 0xFFFFFF and 0x000000 respectively.

Opacity

To describe opacity the lv_opa_t type is created from uint8_t. Some special purpose defines are also introduced:

LV_OPA_TRANSP Value: 0, means no opacity making the color completely transparent
LV_OPA_10 Value: 25, means the color covers only a little
LV_OPA_20 ... OPA_80 follow logically
LV_OPA_90 Value: 229, means the color near completely covers
LV_OPA_COVER Value: 255, means the color completely covers (full opacity)

You can also use the LV_OPA_* defines in lv_color_mix() as a mixing ratio.

Color types

The following variable types are defined by the color module:

lv_color1_t Monochrome color. Also has R, G, B fields for compatibility but they are always the same value (1 byte)
lv_color8_t A structure to store R (3 bit),G (3 bit),B (2 bit) components for 8-bit colors (1 byte)
lv_color16_t A structure to store R (5 bit),G (6 bit),B (5 bit) components for 16-bit colors (2 byte)
lv_color32_t A structure to store R (8 bit),G (8 bit), B (8 bit) components for 24-bit colors (4 byte)
lv_color_t Equal to lv_color1/8/16/24_t depending on the configured color depth setting
lv_color_int_t uint8_t, uint16_t or uint32_t depending on the color depth setting. Used to build color arrays from plain numbers.
lv_opa_t A simple uint8_t type to describe opacity.

The lv_color_t, lv_color1_t, lv_color8_t, lv_color16_t and lv_color32_t types have four fields:

ch.red red channel
ch.green green channel
ch.blue blue channel
full* red + green + blue as one number

You can set the current color depth in lv_conf.h, by setting the LV_COLOR_DEPTH define to 1 (monochrome), 8, 16 or 32.

Convert color

You can convert a color from the current color depth to another. The converter functions return with a number, so you have to use the full field to map a converted color back into a structure:

lv_color_t c;
c.red   = 0x38;
c.green = 0x70;
c.blue  = 0xCC;

lv_color1_t c1;
c1.full = lv_color_to1(c);	/*Return 1 for light colors, 0 for dark colors*/

lv_color8_t c8;
c8.full = lv_color_to8(c);	/*Give a 8 bit number with the converted color*/

lv_color16_t c16;
c16.full = lv_color_to16(c); /*Give a 16 bit number with the converted color*/

lv_color32_t c24;
c32.full = lv_color_to32(c);	/*Give a 32 bit number with the converted color*/

API

Typedefs

typedef lv_color_t (*lv_color_filter_cb_t)(const struct _lv_color_filter_dsc_t*, lv_color_t, lv_opa_t)[1]

typedef struct _lv_color_filter_dsc_t lv_color_filter_dsc_t[2]

Enums

enum [anonymou[3]s][4]

Opacity perc[5]entages.[6] Values:

enumerator LV_OPA_TRANSP[7]
enumerator LV_[8]OPA_0[9]
enumerato[10]r LV_OPA_10[11]
enumerator[12] LV_OPA_20[13]
enumerator[14] LV_OPA_30[15]
enumerator[16] LV_OPA_40[17]
enumerator[18] LV_OPA_50[19]
enumerator[20] LV_OPA_60[21]
enumerator[22] LV_OPA_70[23]
enumerator[24] LV_OPA_80[25]
enumerator[26] LV_OPA_90[27]
enumerator[28] LV_OPA_100[29]
enumerator [30]LV_OPA_COVER[31]

enum lv_pal[32]ette_t[33]

Values:

en[34]umerator LV_PALETTE_RED[35]
enumerator LV_P[36]ALETTE_PINK[37]
enumerator LV_PA[38]LETTE_PURPLE[39]
enumerator LV_PALE[40]TTE_DEEP_PURPLE[41]
enumerator LV_PALETTE_I[42]NDIGO[43]
enumerator LV_PALE[44]TTE_BLUE[45]
enumerator LV_PA[46]LETTE_LIGHT_BLUE[47]
enumerator LV_PALETTE_[48]CYAN[49]
enumerator LV_PA[50]LETTE_TEAL[51]
enumerator LV_PA[52]LETTE_GREEN[53]
enumerator LV_PAL[54]ETTE_LIGHT_GREEN[55]
enumerator LV_PALETTE_L[56]IME[57]
enumerator LV_PA[58]LETTE_YELLOW[59]
enumerator LV_PALE[60]TTE_AMBER[61]
enumerator LV_PAL[62]ETTE_ORANGE[63]
enumerator LV_PALE[64]TTE_DEEP_ORANGE[65]
enumerator LV_PALETTE_B[66]ROWN[67]
enumerator LV_PAL[68]ETTE_BLUE_GREY[69]
enumerator LV_PALETTE[70]_GREY[71]
enumerator _LV_P[72]ALETTE_LAST[73]
enumerator LV_PAL[74]ETTE_NONE[75]

Functions

LV_[76]EXPORT_CONST_INT(LV_COLOR_DEPTH)[77]

LV_EXPORT_CONST_INT(LV_CO[78]LOR_16_SWAP)[79]

typedef LV_CONCAT3 (uint, L[80]V_COLOR_SIZE, _t) lv_color_int_t

typedef LV_CONCAT3 (lv_color, LV_COLOR_DEPTH, _t) lv_color_t

static inline uint8_t lv_color_to1(lv_color_t color)[81]

static inline uint8_t lv_color_to8(lv_colo[82]r_t color)[83]

static inline uint16_t lv_color_to16(lv_co[84]lor_t color)[85]

static inline uint32_t lv_color_to32(lv_colo[86]r_t color)[87]

static inline uint8_t lv_color_brightness(lv[88]_color_t color)[89]

Get the brightness of a color

Parameters: color --[90] a color
Returns: the brightness [0..255]

static inline lv_color_t lv_color_make(uint8_t r, uint8_t g, uint8_t b)[91]

static inline lv_color_t lv_color_hex(uint32_t c)[92]

[93]static inline lv_color_t lv_color_hex3([94]uint32_t c)[95]

static inline void lv_color_filter_dsc_i[96]nit(lv_color_filter_dsc_t *dsc, lv_color_filter_cb_t cb)[97]

lv_color_t lv_color_lighten(lv_color_t c, lv_opa_t lvl)[98]

lv_color_t lv_color[99]_darken(lv_color_t c, lv_o[100]pa_t lvl)[101]

lv_color_t lv_color_change_lightness(lv_colo[102]r_t c, lv_opa_t lvl)[103]

lv_color_t lv_color_hsv_to_rgb(uint16_t h, uint8_t s, [104]uint8_t v)[105]

Convert a HSV color to RGB

Parameters

h -- hue [0..3[106]59]
s -- saturation [0..100]
v -- value [0..100]

Returns: the given RGB color in RGB (with LV_COLOR_DEPTH depth)

lv_color_hsv_t lv_color_rgb_to_hsv(uint8_t r8, uint8_t g8, uint8_t b8)[107]

Convert a 32-bit RGB color to HSV

Parameters

r8 -- 8-bit r[108]ed
g8 -- 8-bit green
b8 -- 8-bit blue

Returns: the given RGB color in HSV

lv_color_hsv_t lv_color_to_hsv(lv_color_t color)[109]

Convert a color to HSV

Parameters: colo[110]r -- color
Returns: the given color in HSV

static inline lv_color_t lv_color_chroma_key(void)[111]

Just a wrapper around LV_COLOR_CHROMA_KEY beca[112]use it might be more convenient to use a function is some cases

Returns: LV_COLOR_CHROMA_KEY

lv_color_t lv_palette_main(lv_palette_t p)[113]

static inline lv_color_t lv_colo[114]r_white(void)[115]

static inline lv_color_t lv_color_b[116]lack(void)[117]

lv_color_t lv_palette_lighten(lv_pa[118]lette_t p, uint8_t lvl)[119]

lv_color_t lv_palette_darken(lv_palette_t p, uin[120]t8_t lvl)[121]

union lv_color1_t[122]

Public Member[123]s

uint8_[124]t full[125]
ui[126]nt8_t blue[127]
ui[128]nt8_t green[129]
uin[130]t8_t red[131]
u[132]nion lv_color1_t::[anonymous] ch[133]

union lv_color8_t[134]

[135]

Public Member[136]s

uint8_t blue[137]
ui[138]nt8_t green[139]
uin[140]t8_t red[141]
s[142]truct lv_color8_t::[anonymous] ch[143]
uint8_t full[144]

[145]

[146]union lv_color16_t[147]

Public Members[148]

uint16_t blue[149]
uin[150]t16_t green[151]
uint[152]16_t red[153]
ui[154]nt16_t green_h[155]
uint16[156]_t green_l[157]
struct[158] lv_color16_t::[anonymous] ch[159]
uint16_t full[160]

[161]

u[162]nion lv_color32_t[163]

Public Members[164]

uint8_t blue[165]
ui[166]nt8_t green[167]
uin[168]t8_t red[169]
u[170]int8_t alpha[171]
str[172]uct lv_color32_t::[anonymous] ch[173]
uint32_t full[174]

[175]

s[176]truct lv_color_hsv_t[177]

Public Members

[178]uint16_t h[179]
[180]uint8_t s[181]
[182]uint8_t v[183]

[184]

struct _lv_color_filter_dsc_t[185]

Public Members

lv_colo[186]r_filter_cb_t filter_cb[187]
void *user_data

[188]

戻る : Previous

「App:Library:LVGL:docs:Overview:Colors」の版間の差分