guitypes.h File Reference

#include <inttypes.h>
#include <stdio.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	_point_ui16_t
struct	_rect_ui16_t
struct	_font_t
struct	_padding_ui8_t
struct	_bitmap_t
struct	_resource_entry_t
struct	_gui_defaults_t

Macros
#define	ALIGN_LEFT   0x00
#define	ALIGN_HCENTER   0x01
#define	ALIGN_RIGHT   0x02
#define	ALIGN_HMASK   0x03
#define	ALIGN_TOP   0x00
#define	ALIGN_VCENTER   0x10
#define	ALIGN_BOTTOM   0x20
#define	ALIGN_VMASK   0x30
#define	ALIGN_MASK   0x33
#define	ALIGN_CENTER   (ALIGN_HCENTER | ALIGN_VCENTER)
#define	ALIGN_LEFT_TOP   (ALIGN_LEFT | ALIGN_TOP)
#define	ALIGN_LEFT_CENTER   (ALIGN_LEFT | ALIGN_VCENTER)
#define	ALIGN_LEFT_BOTTOM   (ALIGN_LEFT | ALIGN_BOTTOM)
#define	ALIGN_RIGHT_TOP   (ALIGN_RIGHT | ALIGN_TOP)
#define	ALIGN_RIGHT_CENTER   (ALIGN_RIGHT | ALIGN_VCENTER)
#define	ALIGN_RIGHT_BOTTOM   (ALIGN_RIGHT | ALIGN_BOTTOM)
#define	ALIGN_CENTER_TOP   (ALIGN_HCENTER | ALIGN_TOP)
#define	ALIGN_CENTER_BOTTOM   (ALIGN_HCENTER | ALIGN_BOTTOM)
#define	ROPFN_COPY   0x00
#define	ROPFN_INVERT   0x01
#define	ROPFN_SWAPBW   0x02
#define	ROPFN_DISABLE   0x04
#define	FONT_FLG_SWAP   0x00000001
#define	FONT_FLG_LSBF   0x00000002
#define	COLOR_BLACK   0x00000000L
#define	COLOR_WHITE   0x00ffffffL
#define	COLOR_RED   0x000000ffL
#define	COLOR_RED_ALERT   0x002646e7L
#define	COLOR_LIME   0x0000ff00L
#define	COLOR_BLUE   0x00ff0000L
#define	COLOR_YELLOW   0x0000ffffL
#define	COLOR_CYAN   0x00ffff00L
#define	COLOR_MAGENTA   0x00ff00ffL
#define	COLOR_SILVER   0x00c0c0c0L
#define	COLOR_GRAY   0x00808080L
#define	COLOR_MAROON   0x00000080L
#define	COLOR_OLIVE   0x00008080L
#define	COLOR_GREEN   0x00008000L
#define	COLOR_PURPLE   0x00800080L
#define	COLOR_TEAL   0x00808000L
#define	COLOR_NAVY   0x00800000L
#define	COLOR_ORANGE   0x001B65F8L
#define	RESOURCE_TYPE_RAW   0
#define	RESOURCE_TYPE_TXT   1
#define	RESOURCE_TYPE_FNT   2
#define	RESOURCE_TYPE_BMP   3
#define	RESOURCE_TYPE_PNG   4
#define	RESOURCE_TABLE_BEGIN   const resource_entry_t resource_table[] = {
#define	RESOURCE_TABLE_END
#define	RESOURCE_ENTRY_NUL()   { 0, 0 },
#define	RESOURCE_ENTRY_PNG(v)   { v, sizeof(v) },
#define	RESOURCE_ENTRY_FNT(v)   { (uint8_t *)&v, sizeof(font_t) },

Typedefs
typedef uint32_t	color_t
typedef struct _point_ui16_t	point_ui16_t
typedef struct _rect_ui16_t	rect_ui16_t
typedef struct _font_t	font_t
typedef struct _padding_ui8_t	padding_ui8_t
typedef struct _bitmap_t	bitmap_t
typedef struct _resource_entry_t	resource_entry_t
typedef struct _gui_defaults_t	gui_defaults_t

Functions
static uint16_t	swap_ui16 (uint16_t val)
static uint16_t	swap_ui32 (uint32_t val)
static color_t	color_rgb (uint8_t r, uint8_t g, uint8_t b)
static uint16_t	color_to_565 (color_t clr)
static color_t	color_from_565 (uint16_t clr565)
static color_t	color_alpha (color_t clr0, color_t clr1, uint8_t alpha)
static point_ui16_t	point_ui16 (uint16_t x, uint16_t y)
static rect_ui16_t	rect_ui16 (uint16_t x, uint16_t y, uint16_t w, uint16_t h)
static padding_ui8_t	padding_ui8 (uint8_t l, uint8_t t, uint8_t r, uint8_t b)
static int	point_in_rect_ui16 (point_ui16_t pt, rect_ui16_t rc)
static int	rect_in_rect_ui16 (rect_ui16_t rc, rect_ui16_t rc1)
static int	rect_empty_ui16 (rect_ui16_t rc)
rect_ui16_t	rect_intersect_ui16 (rect_ui16_t rc, rect_ui16_t rc1)
rect_ui16_t	rect_ui16_add_padding_ui8 (rect_ui16_t rc, padding_ui8_t pad)
rect_ui16_t	rect_ui16_sub_padding_ui8 (rect_ui16_t rc, padding_ui8_t pad)
rect_ui16_t	rect_align_ui16 (rect_ui16_t rc, rect_ui16_t rc1, uint8_t align)
point_ui16_t	font_meas_text (font_t *pf, const char *str)
int	font_line_chars (font_t *pf, const char *str, uint16_t line_width)
point_ui16_t	icon_meas (const uint8_t *pi)
const uint8_t *	resource_ptr (uint16_t id)
uint16_t	resource_size (uint16_t id)
FILE *	resource_fopen (uint16_t id, const char *opentype)
font_t *	resource_font (uint16_t id)

Macro Definition Documentation

ALIGN_LEFT

#define ALIGN_LEFT   0x00

ALIGN_HCENTER

#define ALIGN_HCENTER   0x01

ALIGN_RIGHT

#define ALIGN_RIGHT   0x02

ALIGN_HMASK

#define ALIGN_HMASK   0x03

ALIGN_TOP

#define ALIGN_TOP   0x00

ALIGN_VCENTER

#define ALIGN_VCENTER   0x10

ALIGN_BOTTOM

#define ALIGN_BOTTOM   0x20

ALIGN_VMASK

#define ALIGN_VMASK   0x30

ALIGN_MASK

#define ALIGN_MASK   0x33

ALIGN_CENTER

#define ALIGN_CENTER   (ALIGN_HCENTER | ALIGN_VCENTER)

ALIGN_LEFT_TOP

#define ALIGN_LEFT_TOP   (ALIGN_LEFT | ALIGN_TOP)

ALIGN_LEFT_CENTER

#define ALIGN_LEFT_CENTER   (ALIGN_LEFT | ALIGN_VCENTER)

ALIGN_LEFT_BOTTOM

#define ALIGN_LEFT_BOTTOM   (ALIGN_LEFT | ALIGN_BOTTOM)

ALIGN_RIGHT_TOP

#define ALIGN_RIGHT_TOP   (ALIGN_RIGHT | ALIGN_TOP)

ALIGN_RIGHT_CENTER

#define ALIGN_RIGHT_CENTER   (ALIGN_RIGHT | ALIGN_VCENTER)

ALIGN_RIGHT_BOTTOM

#define ALIGN_RIGHT_BOTTOM   (ALIGN_RIGHT | ALIGN_BOTTOM)

ALIGN_CENTER_TOP

#define ALIGN_CENTER_TOP   (ALIGN_HCENTER | ALIGN_TOP)

ALIGN_CENTER_BOTTOM

#define ALIGN_CENTER_BOTTOM   (ALIGN_HCENTER | ALIGN_BOTTOM)

ROPFN_COPY

#define ROPFN_COPY   0x00

ROPFN_INVERT

#define ROPFN_INVERT   0x01

ROPFN_SWAPBW

#define ROPFN_SWAPBW   0x02

ROPFN_DISABLE

#define ROPFN_DISABLE   0x04

FONT_FLG_SWAP

#define FONT_FLG_SWAP   0x00000001

FONT_FLG_LSBF

#define FONT_FLG_LSBF   0x00000002

COLOR_BLACK

#define COLOR_BLACK   0x00000000L

COLOR_WHITE

#define COLOR_WHITE   0x00ffffffL

COLOR_RED

#define COLOR_RED   0x000000ffL

COLOR_RED_ALERT

#define COLOR_RED_ALERT   0x002646e7L

COLOR_LIME

#define COLOR_LIME   0x0000ff00L

COLOR_BLUE

#define COLOR_BLUE   0x00ff0000L

COLOR_YELLOW

#define COLOR_YELLOW   0x0000ffffL

COLOR_CYAN

#define COLOR_CYAN   0x00ffff00L

COLOR_MAGENTA

#define COLOR_MAGENTA   0x00ff00ffL

COLOR_SILVER

#define COLOR_SILVER   0x00c0c0c0L

COLOR_GRAY

#define COLOR_GRAY   0x00808080L

COLOR_MAROON

#define COLOR_MAROON   0x00000080L

COLOR_OLIVE

#define COLOR_OLIVE   0x00008080L

COLOR_GREEN

#define COLOR_GREEN   0x00008000L

COLOR_PURPLE

#define COLOR_PURPLE   0x00800080L

COLOR_TEAL

#define COLOR_TEAL   0x00808000L

COLOR_NAVY

#define COLOR_NAVY   0x00800000L

COLOR_ORANGE

#define COLOR_ORANGE   0x001B65F8L

RESOURCE_TYPE_RAW

#define RESOURCE_TYPE_RAW   0

RESOURCE_TYPE_TXT

#define RESOURCE_TYPE_TXT   1

RESOURCE_TYPE_FNT

#define RESOURCE_TYPE_FNT   2

RESOURCE_TYPE_BMP

#define RESOURCE_TYPE_BMP   3

RESOURCE_TYPE_PNG

#define RESOURCE_TYPE_PNG   4

RESOURCE_TABLE_BEGIN

#define RESOURCE_TABLE_BEGIN   const resource_entry_t resource_table[] = {

RESOURCE_TABLE_END

#define RESOURCE_TABLE_END

Value:

}                                                            \
    ;                                                            \
    const uint16_t resource_table_size = sizeof(resource_table); \
    const uint16_t resource_count = sizeof(resource_table) / sizeof(resource_entry_t);

RESOURCE_ENTRY_NUL

#define RESOURCE_ENTRY_NUL

(

)

{ 0, 0 },

RESOURCE_ENTRY_PNG

#define RESOURCE_ENTRY_PNG

(

v

)

{ v, sizeof(v) },

RESOURCE_ENTRY_FNT

#define RESOURCE_ENTRY_FNT

(

v

)

{ (uint8_t *)&v, sizeof(font_t) },

Typedef Documentation

color_t

typedef uint32_t color_t

point_ui16_t

typedef struct _point_ui16_t point_ui16_t

rect_ui16_t

typedef struct _rect_ui16_t rect_ui16_t

font_t

typedef struct _font_t font_t

padding_ui8_t

typedef struct _padding_ui8_t padding_ui8_t

bitmap_t

typedef struct _bitmap_t bitmap_t

resource_entry_t

typedef struct _resource_entry_t resource_entry_t

gui_defaults_t

typedef struct _gui_defaults_t gui_defaults_t

Function Documentation

swap_ui16()

static uint16_t swap_ui16 ( uint16_t  val )

static

                                               {
    return (val >> 8) | ((val & 0xff) << 8);
}

Here is the caller graph for this function:

swap_ui32()

static uint16_t swap_ui32 ( uint32_t  val )

static

                                               {
    return (val >> 16) | ((val & 0xffff) << 16);
}

color_rgb()

static color_t color_rgb ( uint8_t  r, uint8_t  g, uint8_t  b  )

static

                                                                 {
    return r | ((uint32_t)g << 8) | ((uint32_t)b << 16);
}

Here is the caller graph for this function:

color_to_565()

static uint16_t color_to_565 ( color_t  clr )

static

                                                 {
    return swap_ui16(((clr >> 19) & 0x001f) | ((clr >> 5) & 0x07e0) | ((clr << 8) & 0xf800));
}

Here is the call graph for this function:

color_from_565()

static color_t color_from_565 ( uint16_t  clr565 )

static

                                                      {
    //TODO
    return 0;
}

color_alpha()

static color_t color_alpha ( color_t  clr0, color_t  clr1, uint8_t  alpha  )

static

                                                                             {
    uint8_t r0 = clr0 & 0xff;
    uint8_t g0 = (clr0 >> 8) & 0xff;
    uint8_t b0 = (clr0 >> 16) & 0xff;
    uint8_t r1 = clr1 & 0xff;
    uint8_t g1 = (clr1 >> 8) & 0xff;
    uint8_t b1 = (clr1 >> 16) & 0xff;
    uint8_t r = ((255 - alpha) * r0 + alpha * r1) / 255;
    uint8_t g = ((255 - alpha) * g0 + alpha * g1) / 255;
    uint8_t b = ((255 - alpha) * b0 + alpha * b1) / 255;
    return color_rgb(r, g, b);
}

Here is the call graph for this function:

Here is the caller graph for this function:

point_ui16()

static point_ui16_t point_ui16 ( uint16_t  x, uint16_t  y  )

static

                                                              {
    point_ui16_t point = { x, y };
    return point;
}

Here is the caller graph for this function:

rect_ui16()

static rect_ui16_t rect_ui16 ( uint16_t  x, uint16_t  y, uint16_t  w, uint16_t  h  )

static

                                                                                    {
    rect_ui16_t rect = { x, y, w, h };
    return rect;
}

padding_ui8()

static padding_ui8_t padding_ui8 ( uint8_t  l, uint8_t  t, uint8_t  r, uint8_t  b  )

static

                                                                                    {
    padding_ui8_t padding = { l, t, r, b };
    return padding;
}

Here is the caller graph for this function:

point_in_rect_ui16()

static int point_in_rect_ui16 ( point_ui16_t  pt, rect_ui16_t  rc  )

static

                                                                      {
    return ((pt.x >= rc.x) && (pt.x < (rc.x + rc.w)) && (pt.y >= rc.y) && (pt.y < (rc.y + rc.h))) ? 1 : 0;
}

Here is the caller graph for this function:

rect_in_rect_ui16()

static int rect_in_rect_ui16 ( rect_ui16_t  rc, rect_ui16_t  rc1  )

static

                                                                     {
    return ((rc.x >= rc1.x) && ((rc.x + rc.w) <= (rc1.x + rc1.w)) && (rc.y >= rc1.y) && ((rc.y + rc.h) <= (rc1.y + rc1.h))) ? 1 : 0;
}

Here is the caller graph for this function:

rect_empty_ui16()

static int rect_empty_ui16 ( rect_ui16_t  rc )

static

                                                  {
    return ((rc.w == 0) || (rc.h == 0)) ? 1 : 0;
}

Here is the caller graph for this function:

rect_intersect_ui16()

rect_ui16_t rect_intersect_ui16	(	rect_ui16_t	rc,
		rect_ui16_t	rc1
	)

                                                                 {
    uint16_t x[6] = { rc.x, rc.x + rc.w, rc1.x, rc1.x + rc1.w, 0, 0 };
    uint16_t y[6] = { rc.y, rc.y + rc.h, rc1.y, rc1.y + rc1.h, 0, 0 };
    interval_intersect_ui16(x);
    interval_intersect_ui16(y);
    rect_ui16_t rc2 = { x[4], y[4], x[5] - x[4], y[5] - y[4] };
    return rc2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rect_ui16_add_padding_ui8()

rect_ui16_t rect_ui16_add_padding_ui8	(	rect_ui16_t	rc,
		padding_ui8_t	pad
	)

                                                                         {
    rect_ui16_t rect = { 0, 0, rc.w + pad.left + pad.right, rc.h + pad.top + pad.bottom };
    if (rc.x > pad.left)
        rect.x = rc.x - pad.left;
    if (rc.y > pad.top)
        rect.y = rc.y - pad.top;
    return rect;
}

rect_ui16_sub_padding_ui8()

rect_ui16_t rect_ui16_sub_padding_ui8	(	rect_ui16_t	rc,
		padding_ui8_t	pad
	)

                                                                         {
    rect_ui16_t rect = { rc.x + pad.left, rc.y + pad.top, 0, 0 };
    if (rc.w > (pad.left + pad.right))
        rect.w = rc.w - (pad.left + pad.right);
    if (rc.h > (pad.top + pad.bottom))
        rect.h = rc.h - (pad.top + pad.bottom);
    return rect;
}

Here is the caller graph for this function:

rect_align_ui16()

rect_ui16_t rect_align_ui16	(	rect_ui16_t	rc,
		rect_ui16_t	rc1,
		uint8_t	align
	)

                                                                            {
    rect_ui16_t rect = rc1;
    switch (align & ALIGN_HMASK) {
    case ALIGN_LEFT:
        rect.x = rc.x;
        break;
    case ALIGN_RIGHT:
        rect.x = ((rc.x + rc.w) > rc1.w) ? ((rc.x + rc.w) - rc1.w) : 0;
        break;
    case ALIGN_HCENTER:
        if (rc.w >= rc1.w)
            rect.x = rc.x + ((rc.w - rc1.w) / 2);
        else
            rect.x = (rc.x > ((rc1.w - rc.w) / 2)) ? rc.x - ((rc1.w - rc.w) / 2) : 0;
        break;
    }
    switch (align & ALIGN_VMASK) {
    case ALIGN_TOP:
        rect.y = rc.y;
        break;
    case ALIGN_BOTTOM:
        rect.y = ((rc.y + rc.h) > rc1.h) ? ((rc.y + rc.h) - rc1.h) : 0;
        break;
    case ALIGN_VCENTER:
        if (rc.h >= rc1.h)
            rect.y = rc.y + ((rc.h - rc1.h) / 2);
        else
            rect.y = (rc.y > ((rc1.h - rc.h) / 2)) ? rc.y - ((rc1.h - rc.h) / 2) : 0;
        break;
    }
    return rect;
}

Here is the caller graph for this function:

font_meas_text()

point_ui16_t font_meas_text	(	font_t *	pf,
		const char *	str
	)

                                                         {
    int x = 0;
    int y = 0;
    int w = 0;
    int h = 0;
    int char_w = pf->w;
    int char_h = pf->h;
    int len = strlen(str);
    char c;
    while (len--) {
        c = *(str++);
        if (c == '\n') {
            if (x + char_w > w)
                w = x + char_w;
            y += char_h;
            x = 0;
        } else
            x += char_w;
        h = y + char_h;
    }
    if (x > w)
        w = x;
    return point_ui16((uint16_t)w, (uint16_t)h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

font_line_chars()

int font_line_chars	(	font_t *	pf,
		const char *	str,
		uint16_t	line_width
	)

                                                                      {
    int w = 0;
    int char_w = pf->w;
    int len = strlen(str);
    int n = 0;
    char c;
    // This is generally about finding the closest '\n' character within the current line to be drawn.
    // Line is limited by pixel dimension, all characters have the same fixed pixel size
    // Such character may not be found, so n becomes > len
    while ((w + char_w) <= line_width) {
        c = str[n++];
        if (c == '\n')
            break;
        else
            w += char_w;
    }
 
    // if the line width is >= than characters to be printed, skip further search
    // and just return len - i.e. the whole string is to be printed at once.
    if (n >= len)
        return len; // must return here to prevent touching memory beyond str in the next while cycle
 
    while ((n > 0) && ((str[n] != ' ') && (str[n] != '\n'))) {
        n--;
    }
 
    if (n == 0)
        n = line_width / char_w;
    if (n >= len)
        return len;
    return n;
}

Here is the caller graph for this function:

icon_meas()

point_ui16_t icon_meas

(

const uint8_t *

pi

)

                                          {
    point_ui16_t wh = { 0, 0 };
    if (memcmp(pi, "\x89PNG", 4) == 0) {
        wh.x = swap_ui16(*((uint16_t *)(pi + 18)));
        wh.y = swap_ui16(*((uint16_t *)(pi + 22)));
    }
    return wh;
}

Here is the call graph for this function:

Here is the caller graph for this function:

resource_ptr()

const uint8_t* resource_ptr

(

uint16_t

id

)

                                         {
    if (id < resource_count)
        return resource_table[id].ptr;
    return 0;
}

Here is the caller graph for this function:

resource_size()

uint16_t resource_size

(

uint16_t

id

)

                                    {
    if (id < resource_count)
        return resource_table[id].size;
    return 0;
}

resource_fopen()

FILE* resource_fopen	(	uint16_t	id,
		const char *	opentype
	)

                                                        {
    if (id < resource_count)
        return fmemopen((uint8_t *)resource_table[id].ptr, resource_table[id].size, opentype);
    return 0;
}

Here is the caller graph for this function:

resource_font()

font_t* resource_font

(

uint16_t

id

)

                                   {
    if (id < resource_count)
        return (font_t *)resource_table[id].ptr;
    return 0;
}

Here is the caller graph for this function: