Chapter 4 - Description of GUIX Services

UINT gx_accordion_menu_create(
    GX_ACCORDION_MENU *accordion,
    GX_CONST GX_CHAR *name,
    GX_WIDGET *parent,
    ULONG style,
    USHORT accordion_menu_id,
    GX_CONST GX_RECTANGLE *size);

GX_ACCORDION_MENU my_accordion;
GX_MENU menu_1;
GX_MENU item_1;
GX_RECTANGLE size;

gx_utility_rectangle_define(&size, 100, 100, 300, 150);

status = gx_accordion_menu_create(&my_accordion, "my_accordion",
                                  parent, GX_STYLE_ENABLED,
                                  MY_ACCORDION_ID, &size);

gx_menu_create(&menu_1, "menu_1", &my_accordion,
               GX_STRING_ID_MENU_1, GX_ID_NONE,
               GX_STYLE_ENABLED | GX_TYLE_BORDER_THIN, 0, &size);

gx_menu_create(&item_1, "item_1", &my_accordion,
               GX_STRING_ID_ITEM_1, GX_ID_NONE,
               GX_STYLE_ENABLED | GX_STYLE_BORDER_THIN, 0, &size);

gx_text_offset_set(&item_1, 30, 0);

gx_menu_insert(&menu_1, &item_1);

/* If status is GX_SUCCESS the accordion menu was successfully created. */

VOID gx_accordion_menu_draw(GX_ACCORDION_MENU *accordion);

/* Define a custom accordion menu draw function. */

VOID my_accordion_menu_draw(GX_ACCORDION_MENU *accordion)
{
    /* Call default accordion menu draw. */
    gx_accordion_menu_draw(accordion);

    /* Add custom drawing here. */
}

UINT gx_accordion_menu_event_process(
    GX_ACCORDION_MENU *accordion,
    GX_EVENT *event_ptr);

/* Call generic accordion menu event processing as part of custom event processing function. */

UINT custom_accordion_event_process(GX_ACCORDION_MENU *accordion, GX_EVENT *event)
{
    UINT status = GX_SUCCESS;

    switch(event->gx_event_type)
    {
    case xyz:
        /* Insert custom event handling here. */
        break;

    default:
        /* Pass all other events to the default accordion menu event processing. */
        status = gx_accordion_menu_event_process(accordion, event);
        break;
    }
    return status;
}

UINT gx_accordion_menu_position(GX_ACCORDION_MENU *accordion);

/* Position menu items in the accordion menu "my_accordion". */
status = gx_accordion_menu_position(&my_accordion);

/* If status is GX_SUCCESS the children in the accordion menu
"my_accordion" are positioned. */

UINT gx_animation_canvas_define(
    GX_ANIMATION *animation,
    GX_CANVAS *canvas);

GX_ANIMATION animation;
GX_CANVAS animation_canvas;
GX_ROOT_WINDOW animation_root;
/* Create animation canvas. */
status = gx_canvas_create(
        &animation_canvas, /* Canvas control block. */
        "animation_canvas", /* Name of canvas. */
        display, /* Display control block. */
        GX_ANIMATION_MANAGED, /* Type of canvas. */
        width, /* Width of canvas. */
        height, /* Height of canvas. */
        memory_area, /* Memory area of canvas. */
        memory_size /* Size of canvas memory. */
        );
if (status == GX_SUCCESS)
{
    /* Create the root window for the canvas. */
    status = gx_window_root_create(
        &animation_root, /* Root window control block. */
        "animation_root", /* Name of root window. */
        &animation_canvas, /* Canvas of the root window. */ GX_STYLE_NONE, /* Style of the window. */
        GX_ID_NONE, /* Root window ID. */
        &root_size /* Window size. */
        );
}
if (status == GX_SUCCESS)
{
    /* Define canvas for the animation. */
    status = gx_animation_canvas_define(&animation,
                &animation_canvas);
}
/* If status is GX_SUCCESS the new canvas was successfully set to the animation manager. */

UINT gx_animation_create(GX_ANIMATION *animation);

GX_ANIMATION *animation;

/* Allocate an animation control from system pool. */
gx_system_animation_get(&animation);

/* Initialize the control block. */

if (animation)
{
    status = gx_animation_create(animation);
}

/* If status is GX_SUCCESS the new animation controller was successfully created and initialized. */

UINT gx_animation_delete(GX_ANIMATION *animation, GX_WIDGET *parent);

GX_ANIMATION *animation;

/* Allocate an animation control from system pool. */
gx_system_animation_get(&animation);

if (animation)
{
    /* Create an animation. */
    gx_animation_create(animation);

    /* Delete an animation. */
    status = gx_animation_delete(animation, GX_NULL);
}

/* If status is GX_SUCCESS the animation controller was successfully deleted and returned back to system animation pool. */

status = gx_animation_delete(GX_NULL, parent);

/* If status is GX_SUCCESS all the animations belong to the parent were successfully deleted. */

UINT gx_animation_drag_disable(
    GX_ANIMATION *animation,
    GX_WIDGET *widget);

GX_ANIMATION animation;
GX_WIDGET *animation_parent;

/* Disable screen drag animation of "animation_parent". */
status = gx_animation_drag_disable(&animation, animation_parent);

/* If status is GX_SUCCESS the screen drag hook has been removed
    from the event process of "animation_parent". */

UINT gx_animation_drag_enable(
    GX_ANIMATION *animation,
    GX_WIDGET *widget,
    GX_ANIMATION_INFO *info);

GX_ANIMATION animation;
GX_ANIMATION_INFO info;
GX_WIDGET *animation_parent;
GX_WIDGET *screen_list[] = {
    screen_1,
    screen_2,
    screen_3,
    GX_NULL
}

memset(&info, 0, sizeof(GX_ANIMATION_INFO);
info.gx_animation_parent = animation_parent;

/* If GX_STYLE_ANIMATION_WRAP is set, the screen list will wrap itself. */
info.gx_animation_style = GX_ANIMATION_SCREEN_DRAG |
                          GX_ANIMATION_HORIZONTAL |
                          GX_STYLE_ANIMATION_WRAP;
info.gx_animation_frame_interval = 1;
info.gx_animation_slide_screen_list = screen_list;

status = gx_animation_drag_enable(&animation, animation_parent,
                                  info);

/* If status is GX_SUCCESS the screen slide animation event
    process function has been set as a hook procedure of
    "animation_parent". */

UINT gx_animation_landing_speed_set(
    GX_ANIMATION *animation,
    USHORT shift_per_step);

/* Set landing speed of "my_animation" to 20. */
status = gx_animation_landing_peed_set(&my_animation, 20);

/* If status is GX_SUCCESS the landing speed is successfully set to 20. */

UINT gx_animation_start(
    GX_ANIMATION *animation,
    GX_ANIMATION_INFO *params);

GX_ANIMATION_INFO params;
GX_ANIMATION *animation;

/* Obtain an animation control block pointer. */
gx_system_animation_get(&animation);
if (animation)
{
    /* Define a slide down and to the right. */
    params.gx_animation_start_position.gx_point_x = 0;
    params.gx_animation_start_position.gx_point_y = 0;
    params.gx_animation_end_position.gx_point_x = 100;
    params.gx_animation_end_position.gx_point_y = 200;
    params.gx_animation_style= GX_ANIMATION_TRANSLATE;
    params.gx_animation_target = &my_window;
    params.gx_animation_parent = root_window;
    params.gx_animation_start_alpha = 255;
    params.gx_animation_end_alpha = 255;

    params.gx_animation_delay_before = 0;
    params.gx_animation_steps = 10;
    params.gx_animation_tick_rate = 2;

    status = gx_animation_start(&animation, &params);
}

/* If status is GX_SUCCESS the animation is initiated. */

UINT gx_animation_stop(GX_ANIMATION *animation);

GX_ANIMATION animation;

status = gx_animation_stop(&animation);

/* If status is GX_SUCCESS the animation is stopped. */

UINT gx_binres_font_load(GX_UBYTE *root_address, UINT font_index, GX_UBYTE *buffer, ULONG *buffer_size);

#define FONT_BUFFER_SIZE 1024

/* Specify address that binary resource data is located. */
GX_UBYTE *root_address = 0x60000000;
GX_CHAR   buffer[FONT_BUFFER_SIZE];
ULONG     buffer_size = FONT_BUFFER_SIZE;

status = gx_binres_font_load(root_address, 0, buffer, &buffer_size);

/* If status is GX_SUCCESS, the first font in the binary data was successfully loaded. */

UINT gx_binres_language_count_get(
    GX_UBYTE *root_address,
    GX_VALUE *returned_count);

GX_VALUE language_count = 0;

/* Specify address that binary resource data is located. */
GX_UBYTE *root_address = 0x60000000;

status = gx_binres_language_count_get(root_address, &language_count);

/* If status is GX_SUCCESS, the language table was successfully loaded. */

UINT gx_binres_language_info_load(
    GX_UBYTE *root_address,
    GX_LANGUAGE_HEADER *put_info);

typedef struct GX_LANGUAGE_HEADER_STRUCT{
    USHORT gx_language_header_magic_number;
    USHORT gx_language_header_index;
    UCHAR gx_language_header_name[GX_LANGUAGE_HEADER_NAME_SIZE];
    ULONG  gx_language_header_data_size;
} GX_LANGUAGE_HEADER;

GX_LANGUAGE_HEADER language_info[4];

/* Specify address that binary resource data is located. */
GX_UBYTE    *root_address = 0x60000000;

status = gx_binres_language_info_load(root_address,
    language_info);
/* If status is GX_SUCCESS, the language table was successfully loaded. */

UINT gx_binres_language_table_load(
    GX_UBYTE *root_address,
    GX_UBYTE **returned_language_table);

GX_UBYTE ***language_table = GX_NULL;

/* Specify address that binary resource data is located. */
GX_UBYTE *root_address = 0x60000000;

status = gx_binres_language_table_load(root_address, &language_table);

/* If status is GX_SUCCESS, the language table was successfully loaded. */

UINT gx_binres_language_table_load_ext(
    GX_UBYTE *root_address,
    GX_STRING **returned_language_table);

GX_STRING **language_table = GX_NULL;

/* Specify address that binary resource data is located. */
GX_UBYTE *root_address = 0x60000000;

status = gx_binres_language_table_load_ext(root_address, &language_table);

/* If status is GX_SUCCESS, the language table was successfully loaded. */

UINT gx_binres_pixelmap_load(GX_UBYTE *root_address, UINT map_index, GX_PIXELMAP *pixelmap);

#define FONT_BUFFER_SIZE 1024

/* Specify address that binary resource data is located. */
GX_UBYTE *root_address = 0x60000000;
GX_PIXELMAP pixelmap;

status = gx_binres_pixelmap_load(root_address, 0, &pixelmap);

/* If status is GX_SUCCESS, the first pixelmap in the binary data was successfully loaded. */

UINT gx_binres_theme_load(
    GX_UBYTE *root_address,
    INT theme_id, GX_THEME **returned_theme);

GX_CHAR *theme = GX_NULL;
GX_UBYTE *root_address = 0x60000000;
INT theme_id = 0;

status = gx_binres_theme_load(root_address, theme_id, &theme);

/* If status is GX_SUCCESS, the theme was successfully loaded. */

UINT gx_brush_default(GX_BRUSH *brush);

/*Reset the brush to its default value. */
status = gx_brush_default(&my_brush);

/* If status is GX_SUCCESS the brush was successfully reset to its default value. */

UINT gx_brush_define(
    GX_BRUSH *brush,
    GX_COLOR line_color,
    GX_COLOR fill_color,
    UINT style);

/* Define a brush. */
status = gx_brush_define(&my_brush, GX_COLOR_BLACK, GX_COLOR_BLACK,
                         GX_STYLE_BORDER_NONE);

/* If status is GX_SUCCESS the brush was successfully created. */

VOID gx_button_background_draw(GX_BUTTON *button);

VOID custom_button_draw(GX_BUTTON *button)
{
    /* Draw button background. */
    gx_button_background_draw(button);

    /* Add custom drawing here. */

    /* Draw child widgets. */
    gx_widget_children_draw((GX_WIDGET *)button);
}

UINT gx_button_create(
    GX_BUTTON *button,
    GX_CONST GX_CHAR *name,
    GX_WIDGET *parent,
    ULONG style,
    USHORT button_id,
    GX_CONST GX_RECTANGLE *size);

GX_BUTTON my_top_button;

/* Create a stop button. */
status = gx_button_create(&my_stop_button, "my stop button",
                            &my_parent_window,
                            GX_STYLE_BUTTON_TOGGLE,
                            MY_STOP_BUTTON_ID, &size);

/* If status is GX_SUCCESS the stop button was successfully created. */

UINT gx_button_deselect(
    GX_BUTTON *button,
    GX_BOOL gen_event);

/* Deselect button. */
status = gx_button_deselect(&my_stop_button, GX_TRUE);

/* If status is GX_SUCCESS the stop button was successfully deselected. */

VOID gx_button_draw(GX_BUTTON *button);

/* Write a custom button draw function. */
VOID custom_button_draw(GX_BUTTON *button)
{
    /* Call default button draw. */
    gx_button_draw(button);

    /* Add custom drawing here. */
}

UINT gx_button_event_process(
    GX_BUTTON *button,
    GX_EVENT *event);

/* Call generic button event processing as part of custom event processing function. */

UINT custom_button_event_process(GX_BUTTON *button,
                                 GX_EVENT *event)
{
    UINT status = GX_SUCCESS;

    switch(event->gx_event_type)
    {
    case xyz:
        /* Insert custom event handling here. */
        break;
    default:
        /* Pass all other events to the default button event processing. */
        status = gx_button_event_process(button, event);
        break;
    }
    return status;
}

UINT gx_button_select(GX_BUTTON *button);

/* Select button. */
status = gx_button_select(&my_stop_button);

/* If status is GX_SUCCESS the stop button was successfully selected. */

UINT  _gx_canvas_aligned_text_draw(
    GX_CONST GX_STRING *string,
    GX_RECTANGLE *rectangle,
    ULONG alignment);

GX_RECTANGLE rectangle;
GX_STRING string;

/* Define text drawing area. */
gx_utility_rectangle_define(&rectangle, 0, 0, 100, 100);

/* Define string. */
string.gx_string_ptr = "example";
string.gx_string_length = sizeof("example") - 1;

/* Draw string with center alignment. */
status = gx_canvas_aligned_text_draw(&string, &rectangle, GX_STYLE_TEXT_CENTER);

/* If status is GX_SUCCESS the string has been drawn to the center of the specified rectangle. */

UINT gx_canvas_alpha_set(
    GX_CANVAS *canvas,
    GX_UBYTE alpha);

/* Set the alpha-blend value of "my_canvas". */
status = gx_canvas_alpha_set(&my_canvas, GX_ALPHA_VALUE_OPAQUE);

/* If status is GX_SUCCESS the alpha-blend value was successfully set. */

UINT gx_canvas_arc_draw(
    INT xcenter,
    INT ycenter,
    UINT r,
    INT start_angle,
    INT end_angle);

/* Draw a circle arc from 0 degree to 90 degree in clockwise. */
status = gx_canvas_arc_draw(100, 100, 50, 0, 90);

/* If status is GX_SUCCESS the arc has been drawn on "my_canvas". */

UINT gx_canvas_block_move(
    GX_RECTANGLE *block,
    GX_VALUE x_shift,
    GX_VALUE y_shift,
    GX_RECTANGLE *dirty);

GX_RECTANGLE invalid;
GX_RECTANGLE move;

/* Define 100 x 100 pixel rectangle. */
gx_utility_rectangle_define(&move, 0, 0, 99, 99);

/* Move this rectangle 10 pixels to the right. */
status = gx_canvas_block_move(&move, 10, 0, &invalid);

/* If status is GX_SUCCESS, then 'invalid' marks the area that needs to be redrawn after the block move. */

UINT gx_canvas_circle_draw(
    INT xcenter,
    INT ycenter,
    UINT r);

/* Draw a circle of radius 10 centered at (100, 100). */
status = gx_canvas_circle_draw(100, 100, 50);

/* If status is GX_SUCCESS the circle has been drawn on "my_canvas". */

UINT gx_canvas_create(
    GX_CANVAS *canvas,
    GX_CONST GX_CHAR *name,
    GX_DISPLAY *display,
    UINT type,
    UINT width,
    UINT height,
    GX_COLOR *memory_area,
    ULONG memory_size);

/* Define global canvas memory area. */
GX_COLOR my_canvas_memory[272*480];

…

/* Create "my_canvas". */
status = gx_canvas_create(&my_canvas, "my canvas", &my_display,
                    (GX_CANVAS_MANAGED | GX_CANVAS_VISIBLE),
                    272, 480,
                    my_canvas_memory,
                    sizeof(default_canvas_memory));

/* If status is GX_SUCCESS the 272 x 480 canvas was successfully created. */

UINT gx_canvas_delete(GX_CANVAS *canvas);

/* Delete "my_canvas". */
status = gx_canvas_delete (&my_canvas);

/* If status is GX_SUCCESS my_canvas was deleted. */

UINT gx_canvas_drawing_complete(
    GX_CANVAS *canvas,
    GX_BOOL flush);

/* Complete drawing on "my_canvas" and flush to display. */
status = gx_canvas_drawing_complete(&my_canvas, GX_TRUE);

/* If status is GX_SUCCESS the canvas drawing was successfully completed. */

UINT gx_canvas_drawing_initiate(
    GX_CANVAS *canvas,
    GX_WIDGET *who,
    GX_RECTANGLE *dirty_area);

/* Initiate drawing on "my_canvas", my_widget.gx_widget_size
specify the area the application wants GUIX to redraw. */
status = gx_canvas_drawing_initiate(&my_canvas, &my_widget, &my_widget.gx_widget_size);

/* If status is GX_SUCCESS the canvas drawing was successfully initiated. */

UINT gx_canvas_ellipse_draw(
    INT xcenter,
    INT ycenter,
    INT a,
    dINT b);

/* Draw an ellipse of semi-major radius 100, semi-minor radius 50
   and centered at (200, 200). */
status = gx_canvas_ellipse_draw(200, 200, 100, 50);

/* If status is GX_SUCCESS the ellipse has been drawn on "my_canvas". */

UINT gx_canvas_hardware_layer_bind(
    GX_CANVAS *canvas,
    INT layer);

/* Binds the canvas to the hardware graphics layer 1. */
status = gx_canvas_hardware_layer_bind(&my_canvas, 1);

/* If status is GX_SUCCESS, the drawing canvas is bound to the hardware graphics. */

UINT gx_canvas_hide(GX_CANVAS *canvas);

/* Make my_canvas invisible. */
status = gx_canvas_hide(&my_canvas);

/* If status is GX_SUCCESS, the canvas has been hidden. */

UINT gx_canvas_line_draw(
    GX_VALUE x_start,
    GX_VALUE y_start,
    GX_VALUE x_end,
    GX_VALUE y_end);

/* Draw line on canvas. */
status = gx_canvas_line_draw(0, 1, 320, 480);

/* If status is GX_SUCCESS, the line has been drawn to canvas. */

UINT gx_canvas_memory_define(
    GX_CANVAS *canvas,
    GX_COLOR *memory,
    ULONG memsize);

/* Assign canvas memory block. */
status = gx_canvas_memory_define(canvas,
    (GX_COLOR *) DRAM_MEMORY,
    (640 * 480 * 2));

/* If status is GX_SUCCESS, the canvas memory pointer has be reassigned. */

UINT gx_canvas_mouse_define(GX_CANVAS *canvas,
    GX_MOUSE_CURSOR_INFO *info);

/* Set mouse cursor info. */
GX_MOUSE_CURSOR_INFO mouse_cursor;
mouse_cursor.gx_mouse_cursor_image_id = GX_PIXELMAP_ID_MOUSE;
mouse_cursor.gx_mouse_cursor_hotspot_x = 0;
mouse_cursor.gx_mouse_cursor_hotspot_y = 0;

status = gx_canvas_mouse_define(&my_canvas, &mouse_cursor);

/* If status is GX_SUCCESS the mouse info of "my_canvas" has been
set successfully. */

UINT gx_canvas_mouse_hide(GX_CANVAS *canvas);

/* Hide the mouse cursor. */
status = gx_canvas_mouse_hide(&my_canvas);

/* If status is GX_SUCCESS the mouse cursor of "my_canvas" has been
hidden successfully. */

UINT gx_canvas_mouse_show(GX_CANVAS *canvas);

/* Make mouse cursor hidden ". */
status = gx_canvas_mouse_show(&my_canvas);

/* If status is GX_SUCCESS the mouse of "my_canvas" has been
hidden successfully. */

UINT gx_canvas_offset_set(
    GX_CANVAS *canvas,
    GX_VALUE x,
    GX_VALUE y);

/* Set display offset for "my_canvas". */
status = gx_canvas_offset_set(&my_canvas, 20, 30);

/* If status is GX_SUCCESS the canvas drawing is now offset from
position 20,30. */

UINT gx_canvas_pie_draw(
    INT xcenter,
    INT ycenter,
    UINT r,
    INT start_angle,
    INT end_angle);

/* Draw a pie from 0 degree to 90 degree in clockwise. */
status = gx_canvas_pie_draw(100, 100, 50, 0, 90);

/* If status is GX_SUCCESS the pie has been drawn to canvas. */

UINT gx_canvas_pixel_draw(GX_POINT position);

GX_POINT point; /* The x,y position you want to draw to. */
GX_RECTANGLE drawto; /* The rectangle bounding your drawing. */
GX_CANVAS *mycanvas; /* The canvas you want to draw to. */

/* Calculate 1x1 pixel drawing area. */
gx_utility_rectangle_define(&drawto,
    point.gx_point_x, point.gx_point_y,
    point.gx_point_x, point.gx_point_y);

/* Get my canvas. */
gx_widget_canvas_get(win, &mycanvas);

/* Open my canvas for drawing. */
gx_canvas_drawing_initiate(mycanvas, win, &drawto);

/* Setup my brush colors. Use any color ID in your resources. */
gx_context_line_color_set(GX_COLOR_ID_WINDOW_BORDER);

/* Draw a pixel. */
status = gx_canvas_pixel_draw(point);

/* Close the canvas. */
gx_canvas_drawing_complete(mycanvas, GX_TRUE);

/* If status is GX_SUCCESS, the pixel was successfully drawn to mycanvas. */

UINT gx_canvas_pixelmap_blend(
    GX_VALUE x_position,
    GX_VALUE y_position,
    GX_PIXELMAP *pixelmap,
    GX_UBYTE alpha);

/* Draw pixelmap on active canvas. */

GX_PIXELMAP *map;
gx_system_pixelmap_get(ID_MY_PIXELMAP, &map);

status = gx_canvas_pixelmap_blend(10, 20, map, 128);

/* If status is GX_SUCCESS the pixelmap has been blended onto the current canvas. */

UINT gx_canvas_pixelmap_draw(
    GX_VALUE x_position,
    GX_VALUE y_position,
    GX_PIXELMAP *pixelmap);

/* Draw pixelmap on canvas. */
status = gx_canvas_pixelmap_draw(10, 20, &my_pixelmap);

/* If status is GX_SUCCESS the pixelmap "my_pixelmap" has been drawn. */

UINT gx_canvas_pixelmap_get(GX_PIXELMAP *pixelmap);

/* Draw pixelmap on active canvas. */

GX_PIXELMAP *map;

status = gx_canvas_pixelmap_get(map);

/* If status is GX_SUCCESS the pixelmap has been retrieved. */

UINT gx_canvas_pixelmap_rotate(
    GX_VALUE x_position,
    GX_VALUE y_position,
    GX_PIXELMAP *pixelmap,
    INT angle,
    INT rot_cx,
    INT rot_cy);

/* Rotate "src_pixelmap" by 30 degree in clockwise direction and draw in on canvas. */
status = gx_canvas_pixelmap_rotate(10, 20, &my_pixelmap, 30, -1, -1);

/* If status is GX_SUCCESS the rotated pixelmap "my_pixelmap" has been drawn. */

UINT gx_canvas_pixelmap_tile(
    GX_RECTANGLE *fill,
    GX_PIXELMAP *pixelmap);

/* Tile pixelmap on canvas. */
status = gx_canvas_pixelmap_tile(&tile_area, &my_pixelmap);

/* If status is GX_SUCCESS the pixelmap "my_pixelmap" has been tiled on canvas. */

UINT gx_canvas_polygon_draw(
    GX_POINT *point_array,
    INT number_of_points);

GX_POINT my_polygon[4] =
{
    { 208, 63 },
    { 274, 63 },
    { 274, 163 },
    { 208, 163 }
};

/* Draw polygon "my_polygon" on canvas. */
status = gx_canvas_polygon_draw(&my_polygon, 4);

/* If status is GX_SUCCESS the polygon "my_polygon" has been drawn. */

UINT gx_canvas_rectangle_draw(GX_RECTANGLE *rectangle);

/* Draw rectangle "my_rectangle" on canvas. */
status = gx_canvas_rectangle_draw(&my_rectangle);

/* If status is GX_SUCCESS the rectangle "my_rectangle" has been drawn. */

UINT gx_canvas_rotated_text_draw(
    const GX_CHAR *text,
    GX_VALUE xCenter,
    GX_VALUE yCenter,
    INT angle);

void my_window_draw(GX_WINDOW *window)
{

    GX_VALUE xpos = 100;
    GX_VALUE ypos = 100;
    INT dynamic_count = 1234567;
    GX_CHAR dynamic_text[10];

    /* Call default window draw routine. */
    gx_window_draw(window);

    /* Set font. */
    gx_context_font_set(GX_FONT_ID_SMALL_BOLD);

    /* Convert int value to string. */
    gx_utility_ltoa(dynamic_count, dynamic_text, 20);

    /* Draw rotate text. */
    gx_canvas_rotated_text_draw(dynamic_text, xpos, ypos, 45);
}

UINT gx_canvas_rotated_text_draw_ext(
    GX_CONST GX_STRING *text,
    GX_VALUE xCenter,
    GX_VALUE yCenter,
    INT angle);

void my_window_draw(GX_WINDOW *window)
{

    GX_VALUE xpos = 100;
    GX_VALUE ypos = 100;
    INT dynamic_count = 1234567;
    GX_CHAR dynamic_text[10];
    GX_STRING string;

    /* Call default window draw routine. */
    gx_window_draw(window);

    /* Set font. */
    gx_context_font_set(GX_FONT_ID_SMALL_BOLD);

    /* Convert int value to string. */
    gx_utility_ltoa(dynamic_count, dynamic_text, 20);

    string.gx_string_ptr = dynamic_text;
    string.gx_string_length = strlen(dynamic_text);

    /* Draw rotate text. */
    gx_canvas_rotated_text_draw_ext(&string, xpos, ypos, 45);
}

UINT gx_canvas_shift(
    GX_CANVAS *canvas,
    GX_VALUE x, GX_VALUE y);

/* Shift canvas "my_canvas". */
status = gx_canvas_shift(&my_canvas, 10, 15);

/* If status is GX_SUCCESS the canvas has been shifted by 10 pixels
    on the X axis and 15 on the Y axis. */

UINT gx_canvas_show(GX_CANVAS *canvas);

/* Make this canvas visible. */
status = gx_canvas_show(&my_canvas);

/* If status is GX_SUCCESS the canvas drawing is now visible. */

UINT gx_canvas_text_draw(
    GX_VALUE x_start,
    GX_VALUE y_start,
    GX_CONST GX_CHAR *string,
    INT length);

/* Draw text "example" on current canvas". */
status = gx_canvas_text_draw(10, 20, "example", 7);

/* Draw all of a string of unknown length on the current canvas. */
status = gx_canvas_text_draw(10, 40, string_ptr, -1);

/* If status is GX_SUCCESS the text "example" has been drawn. */

UINT gx_canvas_text_draw_ext(
    GX_VALUE x_start,
    GX_VALUE y_start,
    GX_CONST GX_STRING *string);

GX_STRING string;
string.gx_string_ptr = "example";
string.gx_string_length = 7;

/* Draw text "example" on current canvas". */
status = gx_canvas_text_draw_ext(10, 20, &string);

/* If status is GX_SUCCESS the text "example" has been drawn. */

UINT gx_checkbox_create(
    GX_CHECKBOX *checkbox,
    GX_CONST GX_CHAR *name,
    GX_WIDGET *parent,
    GX_RESOURCE_ID text_id,
    ULONG style,
    USHORT checkbox_id,
    GX_CONST GX_RECTANGLE *size);

/* Create "my_checkbox". */
status = gx_checkbox_create(&my_checkbox, "my_checkbox",
    &my_parent,
    MY_CHECKBOX_TEXT_RESOURCE_ID, GX_STYLE_BORDER_RAISED,
    MY_CHECKBOX_ID,
    &size);

/* If status is GX_SUCCESS the checkbox "my_checkbox" has been created. */

VOID gx_checkbox_draw(GX_CHECKBOX *checkbox);

/* Write a custom checkbox draw function. */
VOID custom_checkbox_draw(GX_CHECKBOX *checkbox)
{
    /* Call default checkbox draw. */
    gx_checkbox_draw(checkbox);

    /* Add custom drawing here. */
}

UINT gx_checkbox_event_process(
    GX_CHECKBOX *checkbox,
    GX_EVENT *event_ptr);

/* Call generic checkbox event processing as part of custom event processing function. */
UINT custom_checkbox_event_process(GX_CHECKBOX *checkbox, GX_EVENT *event)
{
    UINT status = GX_SUCCESS;

    switch(event->gx_event_type)
    {
    case xyz:
        /* Insert custom event handling here. */
        break;

    default:
        /* Pass all other events to the default checkbox event processing. */
        status = gx_checkbox_event_process(checkbox, event);
        break;
    }
    return status;
}

UINT gx_checkbox_pixelmap_set(
    GX_CHECKBOX *checkbox,
    GX_RESOURCE_ID unchecked_id,
    GX_RESOURCE_ID checked_id,
    GX_RESOURCE_ID unchecked_disabled_id,
    GX_RESOURCE_ID checked_disabled_id);

/* Select "my_checkbox". */
status = gx_checkbox_pixelmap_set(&my_checkbox,
    PIXELMAP_UNCHECKED_ID,
    PIXELMAP_CHECKED_ID, PIXELMAP_UNCHECKED_DISABLED_ID,
    PIXELMAP_CHECKED_DISABLED_ID));

/* If status is GX_SUCCESS the pixelmaps are assigned to the checkbox "my_checkbox". */

UINT gx_checkbox_select(GX_CHECKBOX *checkbox);

/* Select "my_checkbox". */
status = gx_checkbox_select(&my_checkbox);

/* If status is GX_SUCCESS the checkbox "my_checkbox" has been toggled. */

UINT gx_circular_gauge_angle_get(
    GX_CIRCULAR_GAUGE *gauge,
    INT *angle);

INT current_angle;

/* Retrieve the current needle angle of "my_gauge". */
status = gx_circular_gauge_angle_get(&my_gauge, &current_angle);

/* If status is GX_SUCCESS the current needle angle of "my_gauge" has been retrieved. */

UINT gx_circular_gauge_angle_set(
    GX_CIRCULAR_GAUGE *gauge,
    INT angle);

/* Set target angle of "my_gauge" to 180. */
status = gx_circular_gauge_angle_set(&my_gauge, 180);

/* If status is GX_SUCCESS the circular gauge of "my_gauge" has been set. */

UINT gx_circular_gauge_animation_set(
    GX_CIRCULAR_GAUGE *gauge,
    INT steps,
    INT delay);

/* Set animation steps and delay time of circular gauge "my_gauge"
    to 30 and 1, the needle of "my_gauge" will rotate from
    current angle to target angle by 30 steps with 1 tick delay between every step. */
status = gx_circular_gauge_animation_set(&my_gauge, 30, 1);

/* If status is GX_SUCCESS the steps and delay time of "my_gauge" has been set. */

VOID gx_circular_gauge_background_draw(GX_CIRCULAR_GAUGE *gauge);

/* Draw circular gauge background. */
gx_circular_gauge_background_draw(&my_circular_gauge);

UINT gx_circular_gauge_create(
    GX_CIRCULAR_GAUGE *gauge,
    GX_CONST GX_CHAR *name,
    GX_WIDGET *parent,
    GX_CIRCULAR_GAUGE_INFO *info,
    GX_RESOURCE_ID background_id,
    ULONG style,
    USHORT circular_gauge_id,
    GX_VALUE xpos,
    GX_VALUE ypos);

GX_CIRCULAR_GAUGE gauge_info;

gauge_info.gx_circular_gauge_info_animation_steps = 30;
gauge_info.gx_circular_gauge_info_animation_delay = 1;
gauge_info.gx_circular_gauge_info_needle_xpos = 140;
gauge_info.gx_circular_gauge_info_needle_ypos = 140;
gauge_info.gx_circular_gauge_info_needle_xcor = 20;
gauge_info.gx_circular_gauge_info_needle_ycor = 88;
gauge_info.gx_circular_gauge_info_needle_pixelmap = GX_PIXELMAP_ID_NEEDLE;

/* Create "my_gauge". */
status = gx_circular_gauge_create(&my_gauge, "my_gauge",
            &my_parent,
            &gauge_info, MY_PIXELMAP_RESOURCE_ID, GX_NULL,
            MY_ICON_ID, 5, 30);

/* If status is GX_SUCCESS the circular gauge "my_gauge" has been created. */

VOID gx_circular_gauge_draw(GX_CIRCULAR_GAUGE *gauge);

/* Write a custom circular gauge draw function. */
VOID custom_gauge_draw(GX_CIRCULAR_GAUGE *gauge)
{
    /* Call default circular gauge draw. */
    gx_circular_gauge_draw(gauge);

    /* Add custom drawing here. */
}

UINT gx_circular_gauge_event_process(
    GX_CIRCULAR_GAUGE *gauge,
    GX_EVENT *event);

/* Call generic circular gauge event processing as part of custom event processing function. */
UINT custom_gauge_event_process(GX_CIRCULAR_GAUGE *gauge,
    GX_EVENT *event)
{
    UINT status = GX_SUCCESS;

    switch(event->gx_event_type)
    {
    case xyz:
        /* Insert custom event handling here. */
        break;

    default:
        /* Pass all other events to the default circular gauge event processing. */
        status = gx_circular_gauge_event_process(gauge, event);
        break;
}
return status;

UINT gx_context_brush_default(GX_DRAW_CONTEXT *context);

/* Set the brush of "my_context" to default. */
status = gx_context_brush_default(&my_context);

/* If status is GX_SUCCESS the brush of "my_context" has been set to default. */

UINT gx_context_brush_define(
    GX_RESOURCE_ID line_color_id,
    GX_RESOURCE_ID fill_color_id,
    UINT style);

/* Define the brush of the current context. */
status = gx_context_brush_define(GX_COLOR_BLACK_ID,
    GX_COLOR_BLACK_ID,
    GX_STYLE_BORDER_NONE);

/* If status is GX_SUCCESS the brush of the current context has been defined. */

UINT gx_context_brush_get(GX_BRUSH **return_brush);

GX_BRUSH *my_brush;

/* Get the brush of the current context. */
status = gx_context_brush_get(&my_brush);

/* If status is GX_SUCCESS the brush of the current context has been retrieved. */

UINT gx_context_brush_pattern_set(ULONG pattern);

/* Set the brush pattern for the current context. */
status = gx_context_brush_pattern_set(0x80808080);

/* If status is GX_SUCCESS the brush pattern of the current context
has been set to the specified pattern. */

UINT gx_context_brush_set(GX_BRUSH *brush);

GX_BRUSH my_brush;
GX_FONT *font;
GX_COLOR fill_color;
GX_COLOR line_color;

/* Retrieve the font that associated with the specified font ID. */
gx_context_font_get(MY_FONT_ID, &font);

/* Retrieve the color that associated with the specified color ID. */
gx_context_color_get(MY_FILL_COLOR_ID, &fill_color);
gx_context_color_get(MY_LINE_COLOR, &line_color);

my_brush.gx_brush_pixelmap = MY_PIXELMAP_ID;
my_brush.gx_brush_font = font;
my_brush.gx_brush_line_pattern = 0x80808080;
my_brush.gx_brush_pattern_mask = 0x80000000;
my_brush.gx_brush_fill_color = fill_color;
my_brush.gx_brush_line_color = line_color;
my_brush.gx_brush_style = GX_BRUSH_SOLID_FILL | GX_BRUSH_ALIAS |
                          GX_BRUSH_PIXELMAP_FILL | GX_BRUSH_ROUND
my_brush.gx_brush_width = 2;
my_brush.gx_brush_alpha = 255;

/* Set the brush of the current context. */
status = gx_context_brush_set(my_brush);

/* If status is GX_SUCCESS the brush of the current context has been set. */

UINT gx_context_brush_style_set(UINT style);

/* Set the brush style of the current context. */
status = gx_context_brush_style_set(GX_BRUSH_ALIAS);

/* If status is GX_SUCCESS the brush style of the current context has been set. */

UINT gx_context_brush_width_set(UINT width);

/* Set the brush width of the current context to 10 pixels. */
status = gx_context_brush_width_set(10); /*

If status is GX_SUCCESS the brush width of the current context has been set to 10. */

UINT gx_context_color_get(
    GX_RESOURCE_ID color_id,
    GX_COLOR *return_color);

GX_COLOR color_value;

/* Get the color value. */
status = gx_context_color_get(MY_BLACK_COLOR_ID, &color_value);

UINT gx_context_fill_color_set(GX_RESOURCE_ID fill_color_id);

/* Set the fill color of the current context to black. */
status = gx_context_fill_color_set(MY_BLACK_COLOR_ID);

/* If status is GX_SUCCESS the fill color of the current context has been set to black. */

UINT gx_context_font_get(
    GX_RESOURCE_ID font_id,
    GX_FONT **return_font);

GX_FONT *my_font;

/* Get the font pointer. */
status = gx_context_font_get(MY_MIDSIZE_FONT, &my_font);

/* If status is GX_SUCCESS, the font that indicated with MY_MIDSIZE_FONT has been successfully retrieved. */

UINT gx_context_font_set(GX_RESOURCE_ID font_id);

/* Set the font of the current context to MY_FONT_ID. */
status = gx_context_font_set(MY_FONT_ID);

/* If status is GX_SUCCESS the font of the current context has been set. */

UINT gx_context_line_color_set(GX_RESOURCE_ID line_color_id);

/* Set the line color of the current context to black. */
status = gx_context_line_color_set(GX_COLOR_BLACK_ID);

/* If status is GX_SUCCESS the line color of the current context has been set to black. */

UINT gx_context_pixelmap_get(
    GX_RESOURCE_ID pixelmap_id,
    GX_PIXELMAP **return_map);

GX_PIXELMAP *map;

/* Get the pixelmap pointer. */
status = gx_context_pixelmap_get(MY_PIXELMAP_ID, &map);

/* If status is GX_SUCCESS, the pixelmap was successfully retrieved. */

UINT gx_context_pixelmap_set(GX_RESOURCE_ID pixelmap_id);

/* Set pixelmap of the current context to MY_PIXELMAP_ID. */
status = gx_context_pixelmap_set(MY_PIXELMAP_ID);

/* If status is GX_SUCCESS the pixelmap of the current context has been set. */

UINT gx_context_raw_brush_define(
    GX_COLOR line_color,
    GX_COLOR fill_color,
    UINT style);

/* Define the raw brush of the current context. */
status = gx_context_raw_brush_define(GX_COLOR_BLACK, GX_COLOR_BLACK, GX_STYLE_BORDER_NONE);

/* If status is GX_SUCCESS the raw brush of the current context has been defined. */

UINT gx_context_raw_fill_color_set(GX_COLOR line_color);

/* Set the raw fill color of the current context. */
status = gx_context_raw_fill_color_set(GX_COLOR_BLACK);

/* If status is GX_SUCCESS the raw fill color of the current context has been set. */

UINT gx_context_raw_line_color_set(GX_COLOR line_color);

/* Set the raw line color of the current context. */
status = gx_context_raw_line_color_set(GX_COLOR_BLACK);

/* If status is GX_SUCCESS the raw line color of the current context has been set. */

UINT gx_context_string_get(GX_RESOURCE_ID string_id, GX_CONST GX_CHAR **return_string);

GX_CHAR *text;

status = gx_context_string_get(GX_ID_ERROR, &text);

/* If status is GX_SUCCESS the string pointer has been returned. */

UINT gx_context_string_get_ext(GX_RESOURCE_ID string_id, GX_STRING *return_string);

GX_STRING string;

/* Set the raw line color of the current context. */
status = gx_context_string_get_ext(ID_ERROR, &string);

/* If status is GX_SUCCESS the string.gx_string_ptr and
string.gx_string_length values have been returned. */

UINT gx_display_active_language_set(
    GX_DISPLAY *display,
    GX_UBYTE language);

/* Change value of color MY_COLOR_ID. */
status = gx_display_active_language_set(&my_display, LANGUAGE_ENGLISH);

/* If status is GX_SUCCESS the active language has been assigned. */

UINT gx_display_color_set(
    GX_DISPLAY *display,
    GX_RESOURCE_ID color_id,
    GX_COLOR new_color);

/* Change value of color MY_COLOR_ID. */
status = gx_display_color_set(&my_display, MY_COLOR_ID, 0x5454);

/* If status is GX_SUCCESS the color has been reassigned. */

UINT gx_display_color_table_set(
    GX_DISPLAY *display,
    GX_COLOR *color_table,
    INT color_count);

GX_COLOR default_table[32] = { … };

/* Change the color table. */
status = gx_display_color_table_set(&my_display, default_table, 32);

/* If status is GX_SUCCESS the color table has been reassigned. */

UINT gx_display_create(
    GX_DISPLAY *display,
    GX_CONST CHAR *name,
    UINT (*display_driver_setup)(GX_DISPLAY *),
    GX_VALUE width,
    GX_VALUE height);

GX_DISPLAY my_display;

UINT my_driver_setup_callback(GX_DISPLAY *display)
{
    …
}

/* Create screen "my_display". */
status = gx_display_create(&my_display, "my display",
                           my_driver_setup_callback, 320, 480);

/* If status is GX_SUCCESS, the screen "my_display" has been created. */

UINT gx_display_delete(
    GX_DISPLAY *display,
    VOID (*display_driver_cleanup)(GX_DISPLAY *));

VOID driver_cleanup_callback(GX_DISPLAY *display)
{
    …
}

/* Delete a display "my_display". */
status = gx_display_delete(&my_display, driver_cleanup_callback);

/* If status is GX_SUCCESS the screen "my_display" has been destroyed. */

UINT gx_display_font_table_set(
    GX_DISPLAY *display,
    GX_FONT **font_table,
    INT table_size);

GX_FONT *font_table[32] = { … };

/* Assign font table. */
status = gx_display_font_table_set(&my_display, font_table, 32);

/* If status is GX_SUCCESS, the font table has been reassigned. */

UINT  _gx_display_language_direction_table_set(
    GX_DISPLAY *display,
    GX_CONST GX_UBYTE *language_direction_table,
    GX_UBYTE num_languages);

GX_CONST GX_UBYTE language_direction_table[2] =
{
    GX_LANGUAGE_DIRECTION_RTL,
    GX_LANGUAGE_DIRECTION_LTR
};

/* Set language direction table. */
status = gx_display_language_direction_table_set(&my_display, language_direction_table, 2);

/* If status is GX_SUCCESS, the language direction table has been set. */

UINT gx_display_language_table_get(
    GX_DISPLAY *display,
    GX_CHAR **table,
    GX_UBYTE *language_count,
    UINT *string_table_size);

GX_CHAR **language_table;
GX_UBYTE language_count;
UINT string_count;

/* Retrieve language table. */
status = gx_display_language_table_get(&my_display,
        &language_table, &language_count, &string_count);

/* If status is GX_SUCCESS, the language table has been retrieved. */

UINT gx_display_language_table_get_ext(
    GX_DISPLAY *display,
    GX_STRING **table,
    GX_UBYTE *language_count,
    UINT *string_table_size);

GX_STRING **language_table;
GX_UBYTE language_count;
UINT string_count;

/* Retrieve language table. */
status = gx_display_language_table_get_ext(&my_display, &language_table, &language_count, &string_count);

/* If status is GX_SUCCESS, the language table has been retrieved. */

UINT gx_display_language_table_set(
    GX_DISPLAY *display,
    GX_CHAR **table,
    GX_UBYTE number_of_languages,
    UINT number_of_strings);

GX_CHAR ***language_table= my_app_language_table;

/* Assign language table. */
status = gx_display_language_table_set(&my_display, language_table, 5, 232);

/* If status is GX_SUCCESS, the language table has been reassigned. */

UINT gx_display_language_table_set_ext(
    GX_DISPLAY *display,
    GX_STRING **table,
    GX_UBYTE number_of_languages,
    UINT number_of_strings);

GX_STRING **language_table = my_app_language_table;

/* Assign the language table. */
status = gx_display_language_table_set_ext(&my_display, language_table, 5, 132);

/* If status is GX_SUCCESS, the language table has been reassigned. */

UINT gx_display_pixelmap_table_set(
    GX_DISPLAY *display,
    GX_PIXELMAP **pixelmap_table,
    INT table_size);

GX_PIXELMAP *pixelmap_table[32] = { … };

/* Assign pixelmap table. */
status = gx_display_pixelmap_table_set(&my_display, pixelmap_table, 32);

/* If status is GX_SUCCESS the pixelmap table has been reassigned. */

UINT gx_display_string_get(
    GX_DISPLAY *display,
    GX_RESOURCE_ID string_id,
    GX_CONST GX_CHAR **string);

GX_CHAR *string;

/* Retrieve string value. */
status = gx_display_string_get(&my_display, GX_STRING_ID_MONDAY, &string);

/* If status is GX_SUCCESS, the string has been retrieved. */

UINT gx_display_string_get_ext(
    GX_DISPLAY *display,
    GX_RESOURCE_ID string_id,
    GX_STRING *string);

GX_STRING string;

/* Retrieve string value. */
status = gx_display_string_get_ext(&my_display, GX_STRING_ID_MONDAY, &string);

/* If status is GX_SUCCESS, the string has been retrieved. */

UINT gx_display_string_table_get(
    GX_DISPLAY *display,
    GX_UBYTE language,
    GX_CHAR ***table,
    UINT *table_size);

GX_CHAR **string_table;
UINT table_size;

/* Retrieve string table. */
status = gx_display_string_table_get(&my_display, LANGUAGE_ENGLISH,
    &string_table, &table_size);

/* If status is GX_SUCCESS, the string table has been retrieved. */

UINT gx_display_string_table_get(
    GX_DISPLAY *display,
    GX_UBYTE language,
    GX_STRING **table,
    UINT *table_size);

GX_STRING *string_table;
UINT table_size;

/* Retrieve string table. */
status = gx_display_string_table_get_ext(&my_display,
    LANGUAGE_ENGLISH, &string_table, &table_size);

/* If status is GX_SUCCESS, the string table has been retrieved. */