glcd.c File Reference

#include "glcd.h"
#include "cl_list.h"
#include "glcd_config.h"
#include "glcd_lowlevel.h"
#include "glcd_processor.h"
#include <LPC17xx.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
#include "font_msgothic.h"
#include "font_system.h"

Go to the source code of this file.

Classes
struct	__RLItem

Macros
#define	VISIBLE_MASK   (0x1)
#define	RENDERED_MASK   (0x2)
#define	RLITEM_SET_VISIBLE(obj)   ((obj)->metadata |= VISIBLE_MASK)
#define	RLITEM_SET_RENDERED(obj)   ((obj)->metadata |= RENDERED_MASK)
#define	RLITEM_UNSET_VISIBLE(obj)   ((obj)->metadata &= ~VISIBLE_MASK)
#define	RLITEM_UNSET_RENDERED(obj)   ((obj)->metadata &= ~RENDERED_MASK)
#define	RLITEM_IS_VISIBLE(obj)   ((obj)->metadata & VISIBLE_MASK)
#define	RLITEM_IS_RENDERED(obj)   ((obj)->metadata & RENDERED_MASK)

Functions
_PRIVATE bool	bboxes_intersect (const LCD_BBox *const a, const LCD_BBox *const b)
_PRIVATE bool	alloc_component_object (const LCD_Component *const src, LCD_Component *dest)
_PRIVATE void	dealloc_component_object (LCD_Component *const comp)
_PRIVATE LCD_Error	render (struct __RLItem *const item)
_PRIVATE LCD_Error	unrender (struct __RLItem *const item, bool redraw_underneath)
LCD_Error	LCD_Init (LCD_Orientation orientation, MEM_Allocator *const alloc, const LCD_Color *const clear_to)
	Initializes TFT LCD Controller.
bool	LCD_IsInitialized (void)
	Checks if the LCD has been initialized.
u16	LCD_GetWidth (void)
	Returns the width of the screen at the current orientation.
u16	LCD_GetHeight (void)
	Returns the height of the screen at the current orientation.
LCD_Coordinate	LCD_GetSize (void)
	Returns the size of the screen at the current orientation.
LCD_Coordinate	LCD_GetCenter (void)
	Returns the center of the screen at the current orientation.
LCD_Color	LCD_GetPointColor (LCD_Coordinate point)
	Returns the RGB565 color of the pixel at the specified coordinates.
LCD_Error	LCD_SetPointColor (LCD_Color color, LCD_Coordinate point)
	Sets the color of the pixel at the specified coordinates.
LCD_Error	LCD_SetBackgroundColor (LCD_Color color, bool redraw_objects)
	Sets the background color of the screen.
LCD_Error	LCD_RMAdd (LCD_Obj *const obj, LCD_ObjID *out_id, u8 options)
	Adds a new object to the render list, and returns its ID (if out_id is not NULL) through the out_id pointer.
LCD_Error	LCD_RMRemove (LCD_ObjID id, bool redraw_underneath)
	Removes an object from the render list by its ID. It also deallocates the memory used by that object in the memory arena.
LCD_Error	LCD_RMClear (void)
	Removes all visible and non-visible objects from the screen.
LCD_Error	LCD_RMRender (void)
	Manually triggers an update of the screen. Useful when you want to add multiple objects at once, and only update the screen at the end.
LCD_Error	LCD_RMRenderTemporary (LCD_Obj *const obj)
	Renders the object immediately, without adding neither to the render list nor to the memory arena. This is useful for objects that are not frequently updated, and that you don't want to store in the memory arena.
LCD_Error	LCD_RMSetVisibility (LCD_ObjID id, bool visible, bool redraw_underneath)
	Shows/hides an object on/from the screen without modifying the render list.
bool	LCD_RMIsVisible (LCD_ObjID id)
	Returns whether an object is visible on the screen or not.
LCD_Error	LCD_RMMove (LCD_ObjID id, LCD_Coordinate new_pos, bool redraw_underneath)
	Moves an object in the render list to a new position. It also updates the object's position in the RL itself, and in the memory arena.
LCD_Error	LCD_FMAddFont (LCD_Font font, LCD_FontID *out_id)
	Adds a new font to the font manager, and returns its ID through the out_id pointer.
LCD_Error	LCD_FMRemoveFont (LCD_FontID id)
	Removes a font from the font manager by its ID.
LCD_Error	LCD_GetBBox (LCD_ObjID id, LCD_BBox *out_bbox)
	Returns the bounding box of an object in the render list.
LCD_Error	LCD_CalcBBoxForObject (const LCD_Obj *const obj, LCD_BBox *out_bbox)
	Returns the bounding box of a temporary object.
LCD_Error	LCD_DEBUG_RenderBBox (LCD_ObjID id)
	Debug function to render the bounding box of a component.

Variables
_PRIVATE bool	s_initialized = false
	Whether the LCD has been initialized.
_PRIVATE MEM_Allocator *	s_allocator
	The memory allocator used to allocate the objects.
_USED_EXTERNALLY u16	LCDMaxX
	Current LCD maximum X and Y coordinates.
_USED_EXTERNALLY u16	LCDMaxY
_USED_EXTERNALLY LCD_Color	LCDCurrentBGColor = LCD_COL_BLACK
	Current background color of the screen.
_USED_EXTERNALLY LCD_Font	LCDFontList [GLCD_MAX_FONTS] = {0}
	The list of fonts that have been loaded into the LCD.
_USED_EXTERNALLY u8	LCDFontListSize = 0
_PRIVATE CL_List *	s_render_list
	Render list, containing all the components to be rendered & metadata.
_PRIVATE u32	s_render_list_id_ctr = 0

Macro Definition Documentation

RENDERED_MASK

#define RENDERED_MASK   (0x2)

Definition at line 41 of file glcd.c.

RLITEM_IS_RENDERED

#define RLITEM_IS_RENDERED

(

obj

)

((obj)->metadata & RENDERED_MASK)

Definition at line 50 of file glcd.c.

RLITEM_IS_VISIBLE

#define RLITEM_IS_VISIBLE

(

obj

)

((obj)->metadata & VISIBLE_MASK)

Definition at line 49 of file glcd.c.

RLITEM_SET_RENDERED

#define RLITEM_SET_RENDERED

(

obj

)

((obj)->metadata |= RENDERED_MASK)

Definition at line 44 of file glcd.c.

RLITEM_SET_VISIBLE

#define RLITEM_SET_VISIBLE

(

obj

)

((obj)->metadata |= VISIBLE_MASK)

Definition at line 43 of file glcd.c.

RLITEM_UNSET_RENDERED

#define RLITEM_UNSET_RENDERED

(

obj

)

((obj)->metadata &= ~RENDERED_MASK)

Definition at line 47 of file glcd.c.

RLITEM_UNSET_VISIBLE

#define RLITEM_UNSET_VISIBLE

(

obj

)

((obj)->metadata &= ~VISIBLE_MASK)

Definition at line 46 of file glcd.c.

VISIBLE_MASK

#define VISIBLE_MASK   (0x1)

Definition at line 40 of file glcd.c.

Function Documentation

alloc_component_object()

_PRIVATE bool alloc_component_object	(	const LCD_Component *const	src,
		LCD_Component *	dest
	)

Definition at line 68 of file glcd.c.

{
    dest->pos = src->pos;
    dest->type = src->type;
    dest->cached_bbox = src->cached_bbox;
 
    switch (src->type)
    {
    case LCD_COMP_LINE:
        if ((dest->object.line = MEM_Alloc(s_allocator, sizeof(LCD_Line))) == NULL)
            return false;
 
        memcpy(dest->object.line, src->object.line, sizeof(LCD_Line));
        return true;
    case LCD_COMP_RECT:
        if ((dest->object.rect = MEM_Alloc(s_allocator, sizeof(LCD_Rect))) == NULL)
            return false;
 
        memcpy(dest->object.rect, src->object.rect, sizeof(LCD_Rect));
        return true;
    case LCD_COMP_CIRCLE:
        if ((dest->object.circle = MEM_Alloc(s_allocator, sizeof(LCD_Circle))) == NULL)
            return false;
 
        memcpy(dest->object.circle, src->object.circle, sizeof(LCD_Circle));
        return true;
    case LCD_COMP_IMAGE:
        if ((dest->object.image = MEM_Alloc(s_allocator, sizeof(LCD_Image))) == NULL)
            return false;
 
        memcpy(dest->object.image, src->object.image, sizeof(LCD_Image));
        return true;
    case LCD_COMP_TEXT:
        if ((dest->object.text = MEM_Alloc(s_allocator, sizeof(LCD_Text))) == NULL)
            return false;
 
        memcpy(dest->object.text, src->object.text, sizeof(LCD_Text));
        return true;
    case LCD_COMP_BUTTON:
        if ((dest->object.button = MEM_Alloc(s_allocator, sizeof(LCD_Button))) == NULL)
            return false;
 
        memcpy(dest->object.button, src->object.button, sizeof(LCD_Button));
        return true;
    }
 
    return false; // Should never reach this
}

bboxes_intersect()

_PRIVATE bool bboxes_intersect ( const LCD_BBox *const  a, const LCD_BBox *const  b  )

inline

Definition at line 58 of file glcd.c.

{
    // Check for overlap along the x-axis: left edge of a is to the left of the right edge of b
    // AND the right edge of a is to the right of the left edge of b
    return (a->top_left.x < b->bottom_right.x) && (a->bottom_right.x > b->top_left.x) &&
           // Check for overlap along the y-axis: top edge of a is above the bottom edge of b
           // AND the bottom edge of a is below the top edge of b
           (a->top_left.y < b->bottom_right.y) && (a->bottom_right.y > b->top_left.y);
}

dealloc_component_object()

_PRIVATE void dealloc_component_object

(

LCD_Component *const

comp

)

Definition at line 117 of file glcd.c.

{
    switch (comp->type)
    {
    case LCD_COMP_LINE:
        MEM_Free(s_allocator, comp->object.line);
        break;
    case LCD_COMP_RECT:
        MEM_Free(s_allocator, comp->object.rect);
        break;
    case LCD_COMP_CIRCLE:
        MEM_Free(s_allocator, comp->object.circle);
        break;
    case LCD_COMP_IMAGE:
        MEM_Free(s_allocator, comp->object.image);
        break;
    case LCD_COMP_TEXT:
        MEM_Free(s_allocator, comp->object.text);
        break;
    case LCD_COMP_BUTTON:
        MEM_Free(s_allocator, comp->object.button);
        break;
    }
}

LCD_CalcBBoxForObject()

LCD_Error LCD_CalcBBoxForObject	(	const LCD_Obj *const	obj,
		LCD_BBox *	out_bbox
	)

Returns the bounding box of a temporary object.

Parameters

obj	The object to get the bounding box of.
out_bbox	The bounding box of the object, if it was found.

Returns

LCD_Error The error code.

Definition at line 621 of file glcd.c.

{
    if (!obj || !out_bbox)
        return LCD_ERR_NULL_PARAMS;
 
    if (!obj->comps || obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    const bool res = __LCD_PROC_DoProcessObject(obj, out_bbox, MD_BBOX);
    return res ? LCD_ERR_OK : LCD_ERR_DURING_BBOX_CALC;
}

LCD_DEBUG_RenderBBox()

LCD_Error LCD_DEBUG_RenderBBox

(

LCD_ObjID

id

)

Debug function to render the bounding box of a component.

Parameters

id	The ID of the object to render the bounding box of.

Returns

LCD_Error The error code.

Definition at line 635 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return LCD_ERR_INVALID_OBJ;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item)
        return LCD_ERR_INVALID_OBJ;
 
    if (!item->obj || !item->obj->comps || item->obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    const LCD_Dimension dim = {
        .width = abs(item->obj->bbox.bottom_right.x - item->obj->bbox.top_left.x),
        .height = abs(item->obj->bbox.bottom_right.y - item->obj->bbox.top_left.y),
    };
 
    // A bbox is always a rectangle, so we can render it as a rectangle directly.
    // clang-format off
    const LCD_Obj obj = LCD_OBJECT_DEFINE(
        LCD_RECT(item->obj->bbox.top_left, {
            .width = dim.width, .height = dim.height,
            .edge_color = LCD_COL_RED, .fill_color = LCD_COL_NONE,
        }),
        LCD_LINE({
            .from = item->obj->bbox.top_left,
            .to = item->obj->bbox.bottom_right,
            .color = LCD_COL_GREEN,
        }),
        LCD_LINE({
            .from = (LCD_Coordinate){
                .x = item->obj->bbox.top_left.x + dim.width, 
                .y = item->obj->bbox.top_left.y,
            },
            .to = (LCD_Coordinate){
                .x = item->obj->bbox.top_left.x, 
                .y = item->obj->bbox.top_left.y + dim.height
            },
            .color = LCD_COL_BLUE,
        })
    );
 
    const bool res = __LCD_PROC_DoProcessObject(&obj, NULL, MD_DRAW_BBOX);
    // clang-format on
 
    return res ? LCD_ERR_OK : LCD_ERR_DURING_RENDER;
}

LCD_FMAddFont()

LCD_Error LCD_FMAddFont	(	LCD_Font	font,
		LCD_FontID *	out_id
	)

Adds a new font to the font manager, and returns its ID through the out_id pointer.

Parameters

font	The font to add
out_id	The ID of the font, if it was added successfully to the font manager.

Returns

LCD_Error The error code.

Definition at line 577 of file glcd.c.

{
    if (LCDFontListSize >= GLCD_MAX_FONTS)
        return LCD_ERR_FONT_LIST_FULL;
 
    *out_id = LCDFontListSize;
    LCDFontList[*out_id] = font;
    LCDFontListSize++;
    return LCD_ERR_OK;
}

LCD_FMRemoveFont()

LCD_Error LCD_FMRemoveFont

(

LCD_FontID

id

)

Removes a font from the font manager by its ID.

Parameters

id	The ID of the font to remove from the font manager.

Returns

LCD_Error The error code.

Definition at line 588 of file glcd.c.

{
    if (id >= LCDFontListSize || id <= 1) // Cannot remove the default fonts
        return LCD_ERR_INVALID_FONT_ID;
 
    for (u32 i = id; i < LCDFontListSize - 1; i++)
        LCDFontList[i] = LCDFontList[i + 1];
 
    LCDFontListSize--;
    return LCD_ERR_OK;
}

LCD_GetBBox()

LCD_Error LCD_GetBBox	(	LCD_ObjID	id,
		LCD_BBox *	out_bbox
	)

Returns the bounding box of an object in the render list.

Parameters

id	The ID of the object to get the bounding box of.
out_bbox	The bounding box of the object, if it was found.

Returns

LCD_Error The error code.

Definition at line 602 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (!out_bbox)
        return LCD_ERR_NULL_PARAMS;
 
    if (id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return LCD_ERR_INVALID_OBJ;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item || !item->obj)
        return LCD_ERR_INVALID_OBJ;
 
    *out_bbox = item->obj->bbox;
    return LCD_ERR_INVALID_OBJ;
}

LCD_GetCenter()

LCD_Coordinate LCD_GetCenter

(

void

)

Returns the center of the screen at the current orientation.

Definition at line 233 of file glcd.c.

{ return s_initialized ? (LCD_Coordinate){LCDMaxX / 2, LCDMaxY / 2} : (LCD_Coordinate){0}; }

LCD_GetHeight()

u16 LCD_GetHeight

(

void

)

Returns the height of the screen at the current orientation.

Definition at line 229 of file glcd.c.

{ return s_initialized ? LCDMaxY : 0; }

LCD_GetPointColor()

LCD_Color LCD_GetPointColor

(

LCD_Coordinate

point

)

Returns the RGB565 color of the pixel at the specified coordinates.

Parameters

point

The coordinates of the pixel

Returns

The RGB565 color of the pixel

Definition at line 237 of file glcd.c.

{
    if (point.x >= LCDMaxX || point.y >= LCDMaxY || !s_initialized)
        return LCD_COL_NONE;
 
    return __LCD_LL_GetPointColor(point.x, point.y);
}

LCD_GetSize()

LCD_Coordinate LCD_GetSize

(

void

)

Returns the size of the screen at the current orientation.

Definition at line 231 of file glcd.c.

{ return s_initialized ? (LCD_Coordinate){LCDMaxX, LCDMaxY} : (LCD_Coordinate){0}; }

LCD_GetWidth()

u16 LCD_GetWidth

(

void

)

Returns the width of the screen at the current orientation.

Definition at line 227 of file glcd.c.

{ return s_initialized ? LCDMaxX : 0; }

LCD_Init()

LCD_Error LCD_Init	(	LCD_Orientation	orientation,
		MEM_Allocator *const	alloc,
		const LCD_Color *const	clear_to
	)

Initializes TFT LCD Controller.

Parameters

orientation	The orientation of the screen, from the LCD_Orientation enum
alloc	The memory allocator to use for the LCD objects
clear_to	[OPTIONAL] The color to clear the screen with

Returns

LCD_Error The error code.

Definition at line 200 of file glcd.c.

{
    __LCD_LL_Init(orientation);
 
    // Loading the two default fonts: MS Gothic & System
    LCDFontList[0] = Font_MSGothic;
    LCDFontList[1] = Font_System;
    LCDFontListSize = 2;
 
    // Allocating the render list
    s_render_list = CL_ListAlloc(alloc, sizeof(struct __RLItem));
    if (!s_render_list)
        return LCD_ERR_NO_MEMORY;
 
    s_allocator = alloc;
    s_initialized = true;
 
    if (clear_to)
        LCD_SetBackgroundColor(*clear_to, false);
 
    return LCD_ERR_OK;
}

LCD_IsInitialized()

bool LCD_IsInitialized

(

void

)

Checks if the LCD has been initialized.

Returns

Whether the LCD has been initialized

Definition at line 225 of file glcd.c.

{ return s_initialized; }

LCD_RMAdd()

LCD_Error LCD_RMAdd	(	LCD_Obj *const	obj,
		LCD_ObjID *	out_id,
		u8	options
	)

Adds a new object to the render list, and returns its ID (if out_id is not NULL) through the out_id pointer.

Parameters

obj	The object to add
out_id	The ID of the object, or NULL on error.
options	Adding preferences, from the LCD_RMAddOption enum.

Returns

LCD_Error The error code.

Note

Accepting the obj as a const * to simulate the r-value reference in C++, where it's possible to pass a temporary (LCD_Obj&&) to the function, and then move the object to the memory arena. This is not possible in C. If used with the two macros LCD_OBJECT an LCD_RENDER_IMM, the object is passed as r-value reference!

Definition at line 292 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (!obj)
        return LCD_ERR_NULL_PARAMS;
 
    if (!obj->comps || obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    if (obj->comps_size > GLCD_MAX_COMPS_PER_OBJECT)
        return LCD_ERR_TOO_MANY_COMPS_IN_OBJ;
 
    // Allocating an object:
    LCD_Obj *new_obj = MEM_Alloc(s_allocator, sizeof(LCD_Obj));
    if (!new_obj)
    {
        *out_id = -1;
        return LCD_ERR_NO_MEMORY;
    }
 
    // Allocating the components of the object
    new_obj->comps = MEM_Alloc(s_allocator, obj->comps_size * sizeof(LCD_Component));
    if (!new_obj->comps)
    {
        *out_id = -1;
        MEM_Free(s_allocator, new_obj);
        return LCD_ERR_NO_MEMORY;
    }
 
    // Copying the object
    new_obj->comps_size = obj->comps_size;
    new_obj->bbox = (LCD_BBox){0}; // BBox will be calculated by the processor
 
    // Each component has an object, which is a union of all the possible components. Since the
    // union contains pointers, we need to allocate them separately, based on the type attribute.
    for (u8 i = 0; i < obj->comps_size; i++)
    {
        if (!alloc_component_object(&obj->comps[i], &new_obj->comps[i]))
        {
            *out_id = -1;
            MEM_Free(s_allocator, new_obj->comps);
            MEM_Free(s_allocator, new_obj);
            return LCD_ERR_NO_MEMORY;
        }
    }
 
    // Adding the object to the render list
    const struct __RLItem item = {
        .id = s_render_list_id_ctr++,
        .obj = new_obj,
        .metadata = (options & LCD_ADD_OBJ_OPT_DONT_MARK_VISIBLE) ? 0 : VISIBLE_MASK,
    };
 
    if (CL_ListPushBack(s_render_list, &item) != CL_ERR_OK)
    {
        *out_id = -1;
        for (u8 i = 0; i < new_obj->comps_size; i++)
            dealloc_component_object(&new_obj->comps[i]);
 
        MEM_Free(s_allocator, new_obj->comps);
        MEM_Free(s_allocator, new_obj);
        return LCD_ERR_NO_MEMORY;
    }
 
    *out_id = item.id;
    return LCD_ERR_OK;
}

LCD_RMClear()

LCD_Error LCD_RMClear

(

void

)

Removes all visible and non-visible objects from the screen.

Returns

LCD_Error The error code.

Definition at line 395 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (CL_ListIsEmpty(s_render_list))
        return LCD_ERR_OK;
 
    // Clearing the render list
    CL_LIST_FOREACH_PTR(struct __RLItem, item, s_render_list, {
        for (u8 i = 0; i < item->obj->comps_size; i++)
            dealloc_component_object(&item->obj->comps[i]);
 
        MEM_Free(s_allocator, item->obj->comps);
        MEM_Free(s_allocator, item->obj);
    });
 
    CL_ListClear(s_render_list);
 
    // Clearing the screen
    __LCD_LL_FillScreen(LCDCurrentBGColor);
 
    s_render_list_id_ctr = 0;
    return LCD_ERR_OK;
}

LCD_RMIsVisible()

bool LCD_RMIsVisible

(

LCD_ObjID

id

)

Returns whether an object is visible on the screen or not.

Parameters

id	The ID of the object to check

Returns

Whether the object is visible or not

Definition at line 495 of file glcd.c.

{
    if (!s_initialized || id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return false;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item)
        return false;
 
    return RLITEM_IS_VISIBLE(item);
}

LCD_RMMove()

LCD_Error LCD_RMMove	(	LCD_ObjID	id,
		LCD_Coordinate	new_pos,
		bool	redraw_underneath
	)

Moves an object in the render list to a new position. It also updates the object's position in the RL itself, and in the memory arena.

Parameters

id	The ID of the object to move
new_pos	The new position of the object, which will replace the old one
redraw_underneath	Whether to redraw the objects that are below the object prior to the move

Returns

LCD_Error The error code.

Note

As of now, this method moves the oject by translating each components' coordinate by an offset calculated from the top-left corner of the bounding box of the object itself, returned by the LCD_GetObjBBox() method. This may be imprecise!

Definition at line 507 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return LCD_ERR_INVALID_OBJ;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item)
        return LCD_ERR_INVALID_OBJ;
 
    // Additional checks
    if (!item->obj || !item->obj->comps || item->obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    // Starting by de-rendering the previous object
    LCD_Error err;
    if ((err = unrender(item, redraw_underneath)) != LCD_ERR_OK)
        return err;
 
    // Iterating through each component and update its position
    i16 dx, dy;
    LCD_Component *comp;
    for (u16 i = 0; i < item->obj->comps_size; i++)
    {
        comp = &(item->obj->comps[i]);
        switch (comp->type)
        {
        case LCD_COMP_LINE: {
            // For a line, we need to calculate the BBox, and calculate the offset that
            // needs to be applied to the from & to coordinates with the top-left corner
            // of the BBox, and new_pos, which in this case is interpreted as the new
            // top-left corner of the line.
            LCD_BBox *bbox = &item->obj->bbox;
            dx = new_pos.x - bbox->top_left.x;
            dy = new_pos.y - bbox->top_left.y;
 
            comp->object.line->from.x += dx;
            comp->object.line->from.y += dy;
            comp->object.line->to.x += dx;
            comp->object.line->to.y += dy;
            break;
        }
        case LCD_COMP_CIRCLE:
            dx = new_pos.x - comp->object.circle->center.x;
            dy = new_pos.y - comp->object.circle->center.y;
 
            // Calculate the offset
            comp->object.circle->center.x += dx;
            comp->object.circle->center.y += dy;
            break;
        case LCD_COMP_RECT:
        case LCD_COMP_IMAGE:
        case LCD_COMP_TEXT:
        case LCD_COMP_BUTTON:
            dx = new_pos.x - comp->pos.x;
            dy = new_pos.y - comp->pos.y;
 
            comp->pos.x += dx;
            comp->pos.y += dy;
            break;
        }
    }
 
    return render(item);
}

LCD_RMRemove()

LCD_Error LCD_RMRemove	(	LCD_ObjID	id,
		bool	redraw_underneath
	)

Removes an object from the render list by its ID. It also deallocates the memory used by that object in the memory arena.

Parameters

id	The ID of the object to remove
redraw_underneath	Whether to redraw the objects that are below the removed object

Returns

LCD_Error The error code.

Definition at line 362 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return LCD_ERR_INVALID_OBJ;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item)
        return LCD_ERR_INVALID_OBJ;
 
    // Additional checks
    if (!item->obj || !item->obj->comps || item->obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    // Un-rendering the object
    LCD_Error err;
    if ((err = unrender(item, redraw_underneath)) != LCD_ERR_OK)
        return err;
 
    // Deallocating the object
    for (u8 i = 0; i < item->obj->comps_size; i++)
        dealloc_component_object(&item->obj->comps[i]);
 
    MEM_Free(s_allocator, item->obj->comps);
    MEM_Free(s_allocator, item->obj);
    CL_ListRemoveAt(s_render_list, id, NULL);
 
    s_render_list_id_ctr--;
    return LCD_ERR_OK;
}

LCD_RMRender()

LCD_Error LCD_RMRender

(

void

)

Manually triggers an update of the screen. Useful when you want to add multiple objects at once, and only update the screen at the end.

Returns

LCD_Error The error code.

Definition at line 421 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    LCD_Error err;
    CL_LIST_FOREACH_PTR(struct __RLItem, itm, s_render_list, {
        if (RLITEM_IS_VISIBLE(itm) && !RLITEM_IS_RENDERED(itm))
        {
            if ((err = render(itm)) != LCD_ERR_OK)
                return err;
        }
    });
 
    return LCD_ERR_OK;
}

LCD_RMRenderTemporary()

LCD_Error LCD_RMRenderTemporary

(

LCD_Obj *const

obj

)

Renders the object immediately, without adding neither to the render list nor to the memory arena. This is useful for objects that are not frequently updated, and that you don't want to store in the memory arena.

Note

To remove an object rendered you must call LCD_SetBackgroundColor(), effectively clearing the screen and redrawing only the objects stored.

Parameters

obj	The object to render immediately

Returns

LCD_Error The error code.

Note

Accepting the obj as a const * to simulate the r-value reference in C++, where it's possible to pass a temporary (LCD_Obj&&) to the function, and then move the object to the memory arena. This is not possible in C. If used with the two macros LCD_OBJECT an LCD_RENDER_IMM, the object is passed as r-value reference!

Definition at line 438 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (!obj || !obj->comps || obj->comps_size <= 0)
        return LCD_ERR_INVALID_OBJ;
 
    return __LCD_PROC_DoProcessObject(obj, NULL, MD_DRAW_BBOX) ? LCD_ERR_OK : LCD_ERR_DURING_RENDER;
}

LCD_RMSetVisibility()

LCD_Error LCD_RMSetVisibility	(	LCD_ObjID	id,
		bool	visible,
		bool	redraw_underneath
	)

Shows/hides an object on/from the screen without modifying the render list.

Parameters

id	The ID of the object to hide
visible	Whether the object should be visible or not
redraw_underneath	Whether to redraw the objects that are below the current one.

Returns

LCD_Error The error code.

Definition at line 449 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (id < 0 || (u32)id >= CL_ListSize(s_render_list))
        return LCD_ERR_INVALID_OBJ;
 
    struct __RLItem *item = NULL;
    if (CL_ListGetPtr(s_render_list, id, (void **)&item) != CL_ERR_OK || !item)
        return LCD_ERR_INVALID_OBJ;
 
    // Additional checks
    if (!item->obj || !item->obj->comps || item->obj->comps_size == 0)
        return LCD_ERR_INVALID_OBJ;
 
    // If item is already visible, and we want to make it visible, we can skip the operation.
    if (visible && RLITEM_IS_VISIBLE(item))
        return LCD_ERR_OK;
 
    // If item is not visible, and we want to make it invisible, we can skip the operation.
    if (!visible && !RLITEM_IS_VISIBLE(item))
        return LCD_ERR_OK;
 
    // If we want to make the object visible, we need to render it.
    if (visible)
    {
        item->metadata |= VISIBLE_MASK;
        if (render(item) == LCD_ERR_OK)
            return LCD_ERR_OK;
        else
        {
            item->metadata &= ~VISIBLE_MASK;
            return LCD_ERR_DURING_RENDER;
        }
    }
 
    // If we want to make the object invisible, we need to un-render it.
    item->metadata &= ~VISIBLE_MASK;
    if (unrender(item, redraw_underneath) == LCD_ERR_OK)
        return LCD_ERR_OK;
 
    item->metadata |= VISIBLE_MASK;
    return LCD_ERR_DURING_UNRENDER;
}

LCD_SetBackgroundColor()

LCD_Error LCD_SetBackgroundColor	(	LCD_Color	color,
		bool	redraw_objects
	)

Sets the background color of the screen.

Parameters

color	The RGB565 color to set
redraw_objects	If true, the object that were previously visible are re-rendered on top of the new background color.

Returns

LCD_Error The error code.

Note

This function clears the screen, then re-renders all the objects in the render list with the new background color.

Definition at line 264 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (color == LCD_COL_NONE)
        return LCD_ERR_OK;
 
    if ((color & ~(0xFFFF)) != 0)
        color = RGB8_TO_RGB565(color);
 
    LCDCurrentBGColor = color;
    __LCD_LL_FillScreen(color);
 
    // No object is displayed anymore, so we need to change the rendered
    // property of each object in the render queue to false, so that after
    // calling LCD_RMRender(), they will be re-rendered with the new background.
    CL_LIST_FOREACH_PTR(struct __RLItem, itm, s_render_list, { RLITEM_UNSET_RENDERED(itm); });
 
    // If we don't need to redraw the objects, we can return now.
    if (!redraw_objects)
        return LCD_ERR_OK;
 
    return LCD_RMRender();
}

LCD_SetPointColor()

LCD_Error LCD_SetPointColor	(	LCD_Color	color,
		LCD_Coordinate	point
	)

Sets the color of the pixel at the specified coordinates.

Parameters

color	The RGB565 color to set
point	The coordinates of the pixel to color

Returns

LCD_Error The error code.

Definition at line 245 of file glcd.c.

{
    if (!s_initialized)
        return LCD_ERR_UNINITIALIZED;
 
    if (color == LCD_COL_NONE)
        return LCD_ERR_OK;
 
    // Checking if color is already 565
    if ((color & ~(0xFFFF)) != 0)
        color = RGB8_TO_RGB565(color);
 
    if (point.x >= LCDMaxX || point.y >= LCDMaxY)
        return LCD_ERR_COORDS_OUT_OF_BOUNDS;
 
    __LCD_LL_SetPointColor(color, point.x, point.y);
    return LCD_ERR_OK;
}

render()

_PRIVATE LCD_Error render ( struct __RLItem *const  item )

inline

Definition at line 147 of file glcd.c.

{
    // If the object is already rendered, skip it.
    if (RLITEM_IS_RENDERED(item))
        return LCD_ERR_OK;
 
    if (__LCD_PROC_DoProcessObject(item->obj, &item->obj->bbox, MD_DRAW_BBOX))
    {
        RLITEM_SET_RENDERED(item);
        return LCD_ERR_OK;
    }
 
    return LCD_ERR_DURING_RENDER;
}

unrender()

_PRIVATE LCD_Error unrender	(	struct __RLItem *const	item,
		bool	redraw_underneath
	)

Definition at line 165 of file glcd.c.

{
    // If the object is not rendered, skip it
    if (!RLITEM_IS_RENDERED(item))
        return LCD_ERR_OK;
 
    // If we don't need to redraw the objects underneath, we can apply a rougher method for deleting,
    // which is faster. It's up to the caller to decide whether to redraw the objects underneath or not.
    if (__LCD_PROC_DoProcessObject(item->obj, &item->obj->bbox,
                                   redraw_underneath ? MD_DELETE : (MD_DELETE | MD_DELETE_FAST)))
        RLITEM_UNSET_RENDERED(item);
 
    if (!redraw_underneath)
        return RLITEM_IS_RENDERED(item) ? LCD_ERR_DURING_UNRENDER : LCD_ERR_OK;
 
    // If we need to redraw the objects underneath, we need to find out which objects
    // are underneath the object we just un-rendered, and mark them as un-rendered too.
    const LCD_BBox *const bbox = &item->obj->bbox;
    CL_LIST_FOREACH_PTR(struct __RLItem, itm, s_render_list, {
        // Skipping the object we just un-rendered, or invisible ones.
        if (itm->id == item->id || !RLITEM_IS_VISIBLE(itm))
            continue;
 
        if (bboxes_intersect(bbox, &itm->obj->bbox))
            RLITEM_UNSET_RENDERED(itm);
    });
 
    return LCD_RMRender();
}

Variable Documentation

LCDCurrentBGColor

_USED_EXTERNALLY LCD_Color LCDCurrentBGColor = LCD_COL_BLACK

Current background color of the screen.

Definition at line 25 of file glcd.c.

LCDFontList

_USED_EXTERNALLY LCD_Font LCDFontList[GLCD_MAX_FONTS] = {0}

The list of fonts that have been loaded into the LCD.

Definition at line 28 of file glcd.c.

{0};

LCDFontListSize

_USED_EXTERNALLY u8 LCDFontListSize = 0

Definition at line 29 of file glcd.c.

LCDMaxX

_USED_EXTERNALLY u16 LCDMaxX

Current LCD maximum X and Y coordinates.

Definition at line 22 of file glcd.c.

LCDMaxY

_USED_EXTERNALLY u16 LCDMaxY

Definition at line 22 of file glcd.c.

s_allocator

_PRIVATE MEM_Allocator* s_allocator

The memory allocator used to allocate the objects.

Definition at line 19 of file glcd.c.

s_initialized

_PRIVATE bool s_initialized = false

Whether the LCD has been initialized.

Definition at line 16 of file glcd.c.

s_render_list

_PRIVATE CL_List* s_render_list

Render list, containing all the components to be rendered & metadata.

Definition at line 53 of file glcd.c.

s_render_list_id_ctr

_PRIVATE u32 s_render_list_id_ctr = 0

Definition at line 54 of file glcd.c.