window.h File Reference

#include <inttypes.h>
#include "guitypes.h"

Go to the source code of this file.

Classes
struct	_window_class_t
struct	_window_t

Macros
#define	WINDOW_CLS_FRAME   0
#define	WINDOW_CLS_TEXT   1
#define	WINDOW_CLS_NUMB   2
#define	WINDOW_CLS_ICON   3
#define	WINDOW_CLS_LIST   4
#define	WINDOW_CLS_EDIT   5
#define	WINDOW_CLS_SPIN   6
#define	WINDOW_CLS_TXIC   7
#define	WINDOW_CLS_TERM   8
#define	WINDOW_CLS_MENU   9
#define	WINDOW_CLS_MSGBOX   10
#define	WINDOW_CLS_PROGRESS   11
#define	WINDOW_CLS_USER   128
#define	WINDOW_FLG_VISIBLE   0x00000001
#define	WINDOW_FLG_ENABLED   0x00000002
#define	WINDOW_FLG_INVALID   0x00000004
#define	WINDOW_FLG_FOCUSED   0x00000008
#define	WINDOW_FLG_CHECKED   0x00000010
#define	WINDOW_FLG_CAPTURE   0x00000020
#define	WINDOW_FLG_DISABLED   0x00000040
#define	WINDOW_FLG_FREEMEM   0x00004000
#define	WINDOW_FLG_PARENT   0x00008000
#define	WINDOW_FLG_USER   0x00010000
#define	WINDOW_EVENT_BTN_DN   0x01
#define	WINDOW_EVENT_BTN_UP   0x02
#define	WINDOW_EVENT_ENC_DN   0x03
#define	WINDOW_EVENT_ENC_UP   0x04
#define	WINDOW_EVENT_FOCUS0   0x05
#define	WINDOW_EVENT_FOCUS1   0x06
#define	WINDOW_EVENT_CAPT_0   0x07
#define	WINDOW_EVENT_CAPT_1   0x08
#define	WINDOW_EVENT_CLICK   0x09
#define	WINDOW_EVENT_CHANGE   0x0a
#define	WINDOW_EVENT_CHANGING   0x0b
#define	WINDOW_EVENT_LOOP   0x0c
#define	WINDOW_EVENT_TIMER   0x0d
#define	WINDOW_EVENT_MESSAGE   0x0e

Typedefs
typedef struct _window_t	window_t
typedef void()	window_init_t(void *window)
typedef void()	window_done_t(void *window)
typedef void()	window_draw_t(void *window)
typedef void()	window_event_t(void *window, uint8_t event, void *param)
typedef struct _window_list_t	window_list_t
typedef void()	window_list_item_t(window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)
typedef struct _window_class_t	window_class_t

Functions
window_t *	window_ptr (int16_t id)
int16_t	window_id (window_t *ptr)
int16_t	window_register_class (window_class_t *cls)
int16_t	window_create (int16_t cls_id, int16_t id_parent, rect_ui16_t rect)
int16_t	window_create_ptr (int16_t cls_id, int16_t id_parent, rect_ui16_t rect, void *ptr)
void	window_destroy (int16_t id)
void	window_destroy_children (int16_t id)
int16_t	window_focused (void)
int16_t	window_capture (void)
int16_t	window_parent (int16_t id)
int16_t	window_prev (int16_t id)
int16_t	window_next (int16_t id)
int16_t	window_prev_enabled (int16_t id)
int16_t	window_next_enabled (int16_t id)
int16_t	window_first_child (int16_t id)
int	window_child_count (int16_t id)
int	window_enabled_child_count (int16_t id)
int	window_is_visible (int16_t id)
int	window_is_enabled (int16_t id)
int	window_is_invalid (int16_t id)
int	window_is_focused (int16_t id)
int	window_is_capture (int16_t id)
void	window_draw (int16_t id)
void	window_draw_children (int16_t id)
void	window_validate (int16_t id)
void	window_invalidate (int16_t id)
void	window_validate_children (int16_t id)
void	window_invalidate_children (int16_t id)
void	window_set_tag (int16_t id, uint8_t tag)
void	_window_set_tag (window_t *wnd, uint8_t tg)
uint8_t	window_get_tag (int16_t id)
int	_window_get_tag (window_t *wnd)
void	window_set_text (int16_t id, const char *text)
char *	window_get_text (int16_t id)
void	window_set_value (int16_t id, float value)
float	window_get_value (int16_t id)
void	window_set_format (int16_t id, const char *format)
char *	window_get_format (int16_t id)
void	window_set_color_back (int16_t id, color_t clr)
color_t	window_get_color_back (int16_t id)
void	window_set_color_text (int16_t id, color_t clr)
color_t	window_get_color_text (int16_t id)
void	window_set_focus (int16_t id)
void	window_set_capture (int16_t id)
void	window_enable (int16_t id)
void	window_disable (int16_t id)
void	window_show (int16_t id)
void	window_hide (int16_t id)
void	window_set_padding (int16_t id, padding_ui8_t padding)
void	window_set_alignment (int16_t id, uint8_t alignment)
void	window_set_item_count (int16_t id, int count)
int	window_get_item_count (int16_t id)
void	window_set_item_index (int16_t id, int index)
int	window_get_item_index (int16_t id)
void	window_set_top_index (int16_t id, int index)
int	window_get_top_index (int16_t id)
void	window_set_icon_id (int16_t id, uint16_t id_res)
uint16_t	window_get_icon_id (int16_t id)
void	window_set_min (int16_t id, float min)
float	window_get_min (int16_t id)
void	window_set_max (int16_t id, float max)
float	window_get_max (int16_t id)
void	window_set_step (int16_t id, float step)
float	window_get_step (int16_t id)
void	window_set_min_max (int16_t id, float min, float max)
void	window_set_min_max_step (int16_t id, float min, float max, float step)
void	window_dispatch_event (window_t *window, uint8_t event, void *param)
void	window_set_item_callback (int16_t id, window_list_item_t *fnc)
void	gui_invalidate (void)
static void	_window_invalidate (window_t *window)

Variables
window_t *	window_focused_ptr
window_t *	window_capture_ptr

Macro Definition Documentation

WINDOW_CLS_FRAME

#define WINDOW_CLS_FRAME   0

WINDOW_CLS_TEXT

#define WINDOW_CLS_TEXT   1

WINDOW_CLS_NUMB

#define WINDOW_CLS_NUMB   2

WINDOW_CLS_ICON

#define WINDOW_CLS_ICON   3

WINDOW_CLS_LIST

#define WINDOW_CLS_LIST   4

WINDOW_CLS_EDIT

#define WINDOW_CLS_EDIT   5

WINDOW_CLS_SPIN

#define WINDOW_CLS_SPIN   6

WINDOW_CLS_TXIC

#define WINDOW_CLS_TXIC   7

WINDOW_CLS_TERM

#define WINDOW_CLS_TERM   8

WINDOW_CLS_MENU

#define WINDOW_CLS_MENU   9

WINDOW_CLS_MSGBOX

#define WINDOW_CLS_MSGBOX   10

WINDOW_CLS_PROGRESS

#define WINDOW_CLS_PROGRESS   11

WINDOW_CLS_USER

#define WINDOW_CLS_USER   128

WINDOW_FLG_VISIBLE

#define WINDOW_FLG_VISIBLE   0x00000001

WINDOW_FLG_ENABLED

#define WINDOW_FLG_ENABLED   0x00000002

WINDOW_FLG_INVALID

#define WINDOW_FLG_INVALID   0x00000004

WINDOW_FLG_FOCUSED

#define WINDOW_FLG_FOCUSED   0x00000008

WINDOW_FLG_CHECKED

#define WINDOW_FLG_CHECKED   0x00000010

WINDOW_FLG_CAPTURE

#define WINDOW_FLG_CAPTURE   0x00000020

WINDOW_FLG_DISABLED

#define WINDOW_FLG_DISABLED   0x00000040

WINDOW_FLG_FREEMEM

#define WINDOW_FLG_FREEMEM   0x00004000

WINDOW_FLG_PARENT

#define WINDOW_FLG_PARENT   0x00008000

WINDOW_FLG_USER

#define WINDOW_FLG_USER   0x00010000

WINDOW_EVENT_BTN_DN

#define WINDOW_EVENT_BTN_DN   0x01

WINDOW_EVENT_BTN_UP

#define WINDOW_EVENT_BTN_UP   0x02

WINDOW_EVENT_ENC_DN

#define WINDOW_EVENT_ENC_DN   0x03

WINDOW_EVENT_ENC_UP

#define WINDOW_EVENT_ENC_UP   0x04

WINDOW_EVENT_FOCUS0

#define WINDOW_EVENT_FOCUS0   0x05

WINDOW_EVENT_FOCUS1

#define WINDOW_EVENT_FOCUS1   0x06

WINDOW_EVENT_CAPT_0

#define WINDOW_EVENT_CAPT_0   0x07

WINDOW_EVENT_CAPT_1

#define WINDOW_EVENT_CAPT_1   0x08

WINDOW_EVENT_CLICK

#define WINDOW_EVENT_CLICK   0x09

WINDOW_EVENT_CHANGE

#define WINDOW_EVENT_CHANGE   0x0a

WINDOW_EVENT_CHANGING

#define WINDOW_EVENT_CHANGING   0x0b

WINDOW_EVENT_LOOP

#define WINDOW_EVENT_LOOP   0x0c

WINDOW_EVENT_TIMER

#define WINDOW_EVENT_TIMER   0x0d

WINDOW_EVENT_MESSAGE

#define WINDOW_EVENT_MESSAGE   0x0e

Typedef Documentation

window_t

typedef struct _window_t window_t

window_init_t

typedef void() window_init_t(void *window)

window_done_t

typedef void() window_done_t(void *window)

window_draw_t

typedef void() window_draw_t(void *window)

window_event_t

typedef void() window_event_t(void *window, uint8_t event, void *param)

window_list_t

typedef struct _window_list_t window_list_t

window_list_item_t

typedef void() window_list_item_t(window_list_t *pwindow_list, uint16_t index, const char **pptext, uint16_t *pid_icon)

window_class_t

typedef struct _window_class_t window_class_t

Function Documentation

window_ptr()

window_t* window_ptr

(

int16_t

id

)

                                 {
    return ((id >= 0) && (id < WINDOW_MAX_WINDOWS)) ? windows[id] : 0;
}

Here is the caller graph for this function:

window_id()

int16_t window_id

(

window_t *

ptr

)

                                 {
    return (ptr) ? ptr->id : -1;
}

Here is the caller graph for this function:

window_register_class()

int16_t window_register_class

(

window_class_t *

cls

)

                                                   {
    if ((cls) && (window_user_class_count < WINDOW_MAX_USERCLS)) {
        window_user_classes[window_user_class_count] = cls;
        return WINDOW_CLS_USER + window_user_class_count++;
    }
    return -1;
}

Here is the caller graph for this function:

window_create()

int16_t window_create	(	int16_t	cls_id,
		int16_t	id_parent,
		rect_ui16_t	rect
	)

                                                                           {
    return window_create_ptr(cls_id, id_parent, rect, 0);
}

Here is the call graph for this function:

window_create_ptr()

int16_t window_create_ptr	(	int16_t	cls_id,
		int16_t	id_parent,
		rect_ui16_t	rect,
		void *	ptr
	)

                                                                                          {
    window_class_t *cls = class_ptr(cls_id);
    if (cls) {
        uint32_t flg = WINDOW_FLG_VISIBLE | WINDOW_FLG_INVALID;
        window_t *win = (window_t *)ptr;
        if (win == 0) {
            win = (window_t *)gui_malloc(cls->size);
            flg |= WINDOW_FLG_FREEMEM;
        }
        if (win == 0)
            return -1;
        int16_t id = window_new_id(win);
        if (id >= 0) {
            win->id = id;
            win->id_parent = id_parent;
            win->cls = cls;
            win->flg = flg;
            win->rect = rect;
            win->event = cls->event;
            win->f_tag = 0;
            if (cls->init)
                cls->init(win);
            return id;
        }
        if (win && (ptr == 0))
            gui_free(win);
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_destroy()

void window_destroy

(

int16_t

id

)

                                {
    window_t *window = window_free_id(id);
    uint16_t count = window_count;
    if (window != 0) {
        if (window->f_timer)
            gui_timers_delete_by_window_id(window->id);
        window->id = -1;
        if (window->f_parent)
            window_destroy_children(id);
        if (window->cls->done)
            window->cls->done(window);
        if (window->f_freemem)
            gui_free(window);
        if (window == window_capture_ptr)
            window_capture_ptr = 0;
        if (window == window_focused_ptr)
            window_focused_ptr = 0;
        if (window == window_1)
            window_1 = 0;
        //if (window == window_0) window_0 = 0;
        if (count == 0)
            window_0 = 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_destroy_children()

void window_destroy_children

(

int16_t

id

)

                                         {
    window_t *window;
    int16_t id_child;
    for (id_child = 0; id_child < WINDOW_MAX_WINDOWS; id_child++)
        if (((window = windows[id_child]) != 0) && (window->id_parent == id))
            window_destroy(id_child);
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_focused()

int16_t window_focused

(

void

)

                             {
    return window_focused_ptr ? window_focused_ptr->id : 0;
}

Here is the caller graph for this function:

window_capture()

int16_t window_capture

(

void

)

                             {
    return window_capture_ptr ? window_capture_ptr->id : 0;
}

Here is the caller graph for this function:

window_parent()

int16_t window_parent

(

int16_t

id

)

                                  {
    window_t *win;
    if ((id >= 0) && (id < WINDOW_MAX_WINDOWS) && ((win = windows[id]) != 0))
        return win->id_parent;
    return -1;
}

Here is the caller graph for this function:

window_prev()

int16_t window_prev

(

int16_t

id

)

                                {
    window_t *win;
    if ((id >= 0) && (id < WINDOW_MAX_WINDOWS) && ((win = windows[id]) != 0)) {
        int16_t id_parent = win->id_parent;
        while (--id >= 0)
            if ((win = windows[id]) != 0)
                if (win->id_parent == id_parent)
                    return id;
    }
    return -1;
}

Here is the caller graph for this function:

window_next()

int16_t window_next

(

int16_t

id

)

                                {
    window_t *win;
    if ((id >= 0) && (id < WINDOW_MAX_WINDOWS) && ((win = windows[id]) != 0)) {
        int16_t id_parent = win->id_parent;
        while (++id < WINDOW_MAX_WINDOWS)
            if ((win = windows[id]) != 0)
                if (win->id_parent == id_parent)
                    return id;
    }
    return -1;
}

Here is the caller graph for this function:

window_prev_enabled()

int16_t window_prev_enabled

(

int16_t

id

)

                                        {
    while ((id = window_prev(id)) >= 0)
        if (window_is_enabled(id))
            return id;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_next_enabled()

int16_t window_next_enabled

(

int16_t

id

)

                                        {
    while ((id = window_next(id)) >= 0)
        if (window_is_enabled(id))
            return id;
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_first_child()

int16_t window_first_child

(

int16_t

id

)

                                       {
    int16_t id_parent = id;
    window_t *win;
    if ((id >= 0) && (id < WINDOW_MAX_WINDOWS) && ((win = windows[id]) != 0)) {
        while (++id < WINDOW_MAX_WINDOWS)
            if ((win = windows[id]) != 0)
                if (win->id_parent == id_parent)
                    return id;
    }
    return -1;
}

Here is the caller graph for this function:

window_child_count()

int window_child_count

(

int16_t

id

)

                                   {
    int count = 0;
    if ((id = window_first_child(id)) >= 0) {
        count++;
        while ((id = window_next(id)) >= 0)
            count++;
    }
    return count;
}

Here is the call graph for this function:

window_enabled_child_count()

int window_enabled_child_count

(

int16_t

id

)

                                           {
    int count = 0;
    if ((id = window_first_child(id)) >= 0) {
        if (window_is_enabled(id))
            count++;
        while ((id = window_next(id)) >= 0)
            if (window_is_enabled(id))
                count++;
    }
    return count;
}

Here is the call graph for this function:

window_is_visible()

int window_is_visible

(

int16_t

id

)

                                  {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_visible : 0;
}

Here is the call graph for this function:

window_is_enabled()

int window_is_enabled

(

int16_t

id

)

                                  {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_enabled : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_is_invalid()

int window_is_invalid

(

int16_t

id

)

                                  {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_invalid : 0;
}

Here is the call graph for this function:

window_is_focused()

int window_is_focused

(

int16_t

id

)

                                  {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_focused : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_is_capture()

int window_is_capture

(

int16_t

id

)

                                  {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_capture : 0;
}

Here is the call graph for this function:

window_draw()

void window_draw

(

int16_t

id

)

                             {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        if (window->cls->draw)
            window->cls->draw(window);
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_draw_children()

void window_draw_children

(

int16_t

id

)

                                      {
    window_t *window;
    int16_t id_child;
    for (id_child = 0; id_child < WINDOW_MAX_WINDOWS; id_child++)
        if (((window = windows[id_child]) != 0) && (window->id_parent == id)) {
            if (window_1 && window_1->id != window->id_parent) {
                if (rect_empty_ui16(rect_intersect_ui16(window_1->rect, window->rect)))
                    if (window->cls->draw)
                        window->cls->draw(window);
            } else if (window->cls->draw)
                window->cls->draw(window);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_validate()

void window_validate

(

int16_t

id

)

                                 {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        window->f_invalid = 0;
}

Here is the call graph for this function:

window_invalidate()

void window_invalidate

(

int16_t

id

)

                                   {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        window->f_invalid = 1;
        gui_invalidate();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_validate_children()

void window_validate_children

(

int16_t

id

)

                                          {
    window_t *window;
    int16_t id_child;
    for (id_child = 0; id_child < WINDOW_MAX_WINDOWS; id_child++)
        if (((window = windows[id_child]) != 0) && (window->id_parent == id))
            window->f_invalid = 0;
}

window_invalidate_children()

void window_invalidate_children

(

int16_t

id

)

                                            {
    window_t *window;
    int16_t id_child;
    for (id_child = 0; id_child < WINDOW_MAX_WINDOWS; id_child++)
        if (((window = windows[id_child]) != 0) && (window->id_parent == id))
            window->f_invalid = 1;
    gui_invalidate();
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_tag()

void window_set_tag	(	int16_t	id,
		uint8_t	tag
	)

                                             {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        window->f_tag = tag;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_window_set_tag()

void _window_set_tag	(	window_t *	wnd,
		uint8_t	tg
	)

window_get_tag()

uint8_t window_get_tag

(

int16_t

id

)

                                   {
    window_t *window;
    return ((window = window_ptr(id)) != 0) ? window->f_tag : 0;
}

Here is the call graph for this function:

_window_get_tag()

int _window_get_tag

(

window_t *

wnd

)

window_set_text()

void window_set_text	(	int16_t	id,
		const char *	text
	)

                                                   {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            ((window_text_t *)window)->text = (char *)text;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_text()

char* window_get_text

(

int16_t

id

)

                                  {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            return ((window_text_t *)window)->text;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_value()

void window_set_value	(	int16_t	id,
		float	value
	)

                                               {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_NUMB:
            ((window_numb_t *)window)->value = value;
            break;
        case WINDOW_CLS_SPIN:
            if (value < ((window_spin_t *)window)->min)
                value = ((window_spin_t *)window)->min;
            if (value > ((window_spin_t *)window)->max)
                value = ((window_spin_t *)window)->max;
            ((window_spin_t *)window)->window.value = value;
            ((window_spin_t *)window)->index = (int)((((window_spin_t *)window)->window.value - ((window_spin_t *)window)->min) / ((window_spin_t *)window)->step);
            break;
        case WINDOW_CLS_PROGRESS:
            if (value < ((window_progress_t *)window)->min)
                value = ((window_progress_t *)window)->min;
            if (value > ((window_progress_t *)window)->max)
                value = ((window_progress_t *)window)->max;
            ((window_progress_t *)window)->value = value;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_value()

float window_get_value

(

int16_t

id

)

                                   {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_NUMB:
            return ((window_numb_t *)window)->value;
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->window.value;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_format()

void window_set_format	(	int16_t	id,
		const char *	format
	)

                                                       {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_NUMB:
            ((window_numb_t *)window)->format = (char *)format;
            break;
        case WINDOW_CLS_SPIN:
            ((window_spin_t *)window)->window.format = (char *)format;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_format()

char* window_get_format

(

int16_t

id

)

                                    {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_NUMB:
            return ((window_numb_t *)window)->format;
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->window.format;
        }
    }
    return 0;
}

Here is the call graph for this function:

window_set_color_back()

void window_set_color_back	(	int16_t	id,
		color_t	clr
	)

                                                    {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_FRAME:
            ((window_frame_t *)window)->color_back = clr;
            break;
        case WINDOW_CLS_TEXT:
            ((window_text_t *)window)->color_back = clr;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_color_back()

color_t window_get_color_back

(

int16_t

id

)

                                          {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            return ((window_text_t *)window)->color_back;
        }
    }
    return COLOR_BLACK;
}

Here is the call graph for this function:

window_set_color_text()

void window_set_color_text	(	int16_t	id,
		color_t	clr
	)

                                                    {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            ((window_text_t *)window)->color_text = clr;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_color_text()

color_t window_get_color_text

(

int16_t

id

)

                                          {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            return ((window_text_t *)window)->color_text;
        }
    }
    return COLOR_BLACK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_focus()

void window_set_focus

(

int16_t

id

)

                                  {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        if (window->f_visible && window->f_enabled) {
            if (window_focused_ptr) {
                window_focused_ptr->f_focused = 0;
                window_focused_ptr->f_invalid = 1;
                if (window_focused_ptr->event)
                    window_focused_ptr->event(window_focused_ptr, WINDOW_EVENT_FOCUS0, 0);
            }
            window_focused_ptr = window;
            window->f_focused = 1;
            window->f_invalid = 1;
            if (window->event)
                window->event(window, WINDOW_EVENT_FOCUS1, 0);
            gui_invalidate();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_capture()

void window_set_capture

(

int16_t

id

)

                                    {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        if (window->f_visible && window->f_enabled && window->event) {
            if (window_capture_ptr) {
                window_capture_ptr->f_capture = 0;
                if (window_capture_ptr->event)
                    window_capture_ptr->event(window_capture_ptr, WINDOW_EVENT_CAPT_0, 0);
            }
            window_capture_ptr = window;
            window->f_capture = 1;
            window->event(window, WINDOW_EVENT_CAPT_1, 0);
            gui_invalidate();
        }
    }
}

Here is the call graph for this function:

window_enable()

void window_enable

(

int16_t

id

)

                               {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        window->f_enabled = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_disable()

void window_disable

(

int16_t

id

)

                                {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        window->f_enabled = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_show()

void window_show

(

int16_t

id

)

                             {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        if ((window->f_visible) == 0) {
            window->f_visible = 1;
            _window_invalidate((window_t *)window);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_hide()

void window_hide

(

int16_t

id

)

                             {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        if (window->f_visible) {
            window->f_visible = 0;
            _window_invalidate((window_t *)window);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_padding()

void window_set_padding	(	int16_t	id,
		padding_ui8_t	padding
	)

                                                           {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            ((window_text_t *)window)->padding = padding;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_alignment()

void window_set_alignment	(	int16_t	id,
		uint8_t	alignment
	)

                                                         {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_TEXT:
            ((window_text_t *)window)->alignment = alignment;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_item_count()

void window_set_item_count	(	int16_t	id,
		int	count
	)

                                                  {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            ((window_list_t *)window)->count = count;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_item_count()

int window_get_item_count

(

int16_t

id

)

                                      {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            return ((window_list_t *)window)->count;
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->count;
        }
    }
    return -1;
}

Here is the call graph for this function:

window_set_item_index()

void window_set_item_index	(	int16_t	id,
		int	index
	)

                                                  {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_MENU:
            if (((window_menu_t *)window)->count > index) {
                ((window_menu_t *)window)->index = index;
            }
            break;
        case WINDOW_CLS_LIST:
            if (((window_list_t *)window)->count > index) {
                ((window_list_t *)window)->index = index;
            }
            break;
        case WINDOW_CLS_SPIN:
            if (((window_spin_t *)window)->count > index) {
                ((window_spin_t *)window)->index = index;
                ((window_spin_t *)window)->window.value = ((window_spin_t *)window)->min + ((window_spin_t *)window)->step * ((window_spin_t *)window)->index;
            }
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_item_index()

int window_get_item_index

(

int16_t

id

)

                                      {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            return ((window_list_t *)window)->index;
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->index;
        }
    }
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_top_index()

void window_set_top_index	(	int16_t	id,
		int	index
	)

                                                     {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            ((window_list_t *)window)->top_index = top_index;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

window_get_top_index()

int window_get_top_index

(

int16_t

id

)

                                     {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            return ((window_list_t *)window)->top_index;
        }
    }
    return -1;
}

Here is the call graph for this function:

window_set_icon_id()

void window_set_icon_id	(	int16_t	id,
		uint16_t	id_res
	)

                                                     {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_ICON:
            ((window_icon_t *)window)->id_res = id_res;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_get_icon_id()

uint16_t window_get_icon_id

(

int16_t

id

)

                                        {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_ICON:
            return ((window_icon_t *)window)->id_res;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_set_min()

void window_set_min	(	int16_t	id,
		float	min
	)

                                           {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            ((window_spin_t *)window)->min = min;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

window_get_min()

float window_get_min

(

int16_t

id

)

                                 {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->min;
        }
    return 0;
}

Here is the call graph for this function:

window_set_max()

void window_set_max	(	int16_t	id,
		float	max
	)

                                           {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            ((window_spin_t *)window)->max = max;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

window_get_max()

float window_get_max

(

int16_t

id

)

                                 {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->max;
        }
    return 0;
}

Here is the call graph for this function:

window_set_step()

void window_set_step	(	int16_t	id,
		float	step
	)

                                             {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            ((window_spin_t *)window)->step = step;
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

window_get_step()

float window_get_step

(

int16_t

id

)

                                  {
    window_t *window;
    if ((window = window_ptr(id)) != 0)
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            return ((window_spin_t *)window)->step;
        }
    return 0;
}

Here is the call graph for this function:

window_set_min_max()

void window_set_min_max	(	int16_t	id,
		float	min,
		float	max
	)

                                                          {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            if (((window_spin_t *)window)->window.value < min)
                ((window_spin_t *)window)->window.value = min;
            if (((window_spin_t *)window)->window.value > max)
                ((window_spin_t *)window)->window.value = max;
            ((window_spin_t *)window)->min = min;
            ((window_spin_t *)window)->max = max;
            ((window_spin_t *)window)->count = (int)((max - min) / ((window_spin_t *)window)->step + 1.5F);
            ((window_spin_t *)window)->index = (int)((((window_spin_t *)window)->window.value - min) / ((window_spin_t *)window)->step);
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

window_set_min_max_step()

void window_set_min_max_step	(	int16_t	id,
		float	min,
		float	max,
		float	step
	)

                                                                           {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_SPIN:
            if (((window_spin_t *)window)->window.value < min)
                ((window_spin_t *)window)->window.value = min;
            if (((window_spin_t *)window)->window.value > max)
                ((window_spin_t *)window)->window.value = max;
            ((window_spin_t *)window)->min = min;
            ((window_spin_t *)window)->max = max;
            ((window_spin_t *)window)->step = step;
            ((window_spin_t *)window)->count = (int)((max - min) / step + 1.5F);
            ((window_spin_t *)window)->index = (int)((((window_spin_t *)window)->window.value - min) / step);
            break;
        }
        _window_invalidate((window_t *)window);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

window_dispatch_event()

void window_dispatch_event	(	window_t *	window,
		uint8_t	event,
		void *	param
	)

                                                                         {
    if (window && window->event)
        window->event(window, event, param);
}

Here is the caller graph for this function:

window_set_item_callback()

void window_set_item_callback	(	int16_t	id,
		window_list_item_t *	fnc
	)

                                                                   {
    window_t *window;
    if ((window = window_ptr(id)) != 0) {
        switch (window->cls->cls_id) {
        case WINDOW_CLS_LIST:
            ((window_list_t *)window)->list_item = fnc;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

gui_invalidate()

void gui_invalidate

(

void

)

                          {
    gui_flags |= GUI_FLG_INVALID;
#ifdef GUI_USE_RTOS
    osSignalSet(gui_task_handle, GUI_SIG_REDRAW);
#endif //GUI_USE_RTOS
}

Here is the call graph for this function:

Here is the caller graph for this function:

_window_invalidate()

static void _window_invalidate ( window_t *  window )

static

                                                        {
    if (window) {
        window->flg |= WINDOW_FLG_INVALID;
        gui_invalidate();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

window_focused_ptr

window_t* window_focused_ptr

window_capture_ptr

window_t* window_capture_ptr