Cppcheck report - GATE C/C++ Framework: gate/ui/graphics_winapi.c

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright (c) 2018-2026, Stefan Meislinger <sm@opengate.at>                |
| All rights reserved.                                                       |
|                                                                            |
| Redistribution and use in source and binary forms, with or without         |
| modification, are permitted provided that the following conditions are met:|
|                                                                            |
| 1. Redistributions of source code must retain the above copyright notice,  |
|    this list of conditions and the following disclaimer.                   |
| 2. Redistributions in binary form must reproduce the above copyright       |
|    notice, this list of conditions and the following disclaimer in the     |
|    documentation and/or other materials provided with the distribution.    |
|                                                                            |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
| AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE  |
| IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE    |
| LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR        |
| CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF       |
| SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS   |
| INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN    |
| CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)    |
| ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF     |
| THE POSSIBILITY OF SUCH DAMAGE.                                            |
+----------------------------------------------------------------------------+
*/

#include "gate/ui/graphics.h"
#include "gate/results.h"

#if defined(GATE_UI_WINAPI)

#include "gate/ui/gateui_winapi.h"
#include "gate/platforms.h"
#include "gate/debugging.h"
#include <shellapi.h>

#if !defined(GATE_SYS_WIN16)
#include <commctrl.h>
#endif

#define GATE_UI_GRAPHICS_HDC(graph)     ((HDC)(graph)->resources[0])
#define GATE_UI_GRAPHICS_BACKUP(graph)  ((HBITMAP)(graph)->resources[1])
#define GATE_UI_GRAPHICS_WINDOW(graph)  ((HWND)(graph)->resources[2])
#define GATE_UI_GRAPHICS_BYTEBUFFER(graph)  ((void*)(graph)->resources[3])

gate_result_t gate_ui_graphics_create_virtual(gate_ui_graphics_t* graph, gate_ui_host_t* host, gate_uint32_t width, gate_uint32_t height)
{
    HWND desk = GetDesktopWindow();
    HDC deskdc = GetDC(desk);
    HDC dc;
    HBITMAP bmp;
    gate_mem_clear(graph, sizeof(gate_ui_graphics_t));
    dc = CreateCompatibleDC(deskdc);
    if (dc == NULL)
    {
        ReleaseDC(desk, deskdc);
        return GATE_RESULT_FAILED;
    }
    bmp = CreateCompatibleBitmap(deskdc, (int)width, (int)height);
    ReleaseDC(desk, deskdc);
    if (bmp == NULL)
    {
        DeleteDC(dc);
        return GATE_RESULT_OUTOFRESOURCES;
    }
    graph->host = host;
    graph->width = width;
    graph->height = height;
    graph->resources[0] = dc;
    graph->resources[1] = SelectObject(dc, (HGDIOBJ)bmp);
    return GATE_RESULT_OK;
}

typedef struct gate_ui_bitmap_header_class
{
    BITMAPINFO  info;
    RGBQUAD     palette[256];
}  gate_ui_bitmap_header_t;

static gate_size_t resolve_color_index(gate_uint8_t r, gate_uint8_t g, gate_uint8_t b)
{
    const gate_size_t nr = ((gate_size_t)r + 26u) / 51u;
    const gate_size_t ng = ((gate_size_t)g + 26u) / 51u;
    const gate_size_t nb = ((gate_size_t)b + 26u) / 51u;

    const gate_size_t ndx = nr * 36u + ng * 6u + nb;
    return ndx;
}

static DWORD create_palette_8(RGBQUAD* ptr_quad)
{
    unsigned short r, g, b;
    for (r = 0; r < 6; ++r)
    {
        for (g = 0; g < 6; ++g)
        {
            for (b = 0; b < 6; ++b)
            {
                ptr_quad->rgbBlue = (unsigned char)(b * 51);
                ptr_quad->rgbGreen = (unsigned char)(g * 51);
                ptr_quad->rgbRed = (unsigned char)(r * 51);
                ptr_quad->rgbReserved = 0;
                ++ptr_quad;
            }
        }
    }
    return 216;
}

gate_result_t gate_ui_graphics_create_image(gate_ui_graphics_t* graph, gate_ui_host_t* host, gate_uint32_t width, gate_uint32_t height, gate_uint32_t depth)
{
    gate_result_t ret;
    HWND desk = GetDesktopWindow();
    HDC deskdc = GetDC(desk);
    HDC dc = NULL;
    HBITMAP hbitmap;
    HBITMAP hbackup;
    gate_ui_bitmap_header_t bitmapinfo;
    gate_uint8_t r;
    gate_size_t linelen;
    gate_size_t bufferlen;
    void* buffer;
    RGBQUAD* ptr_quad;

    do
    {
        gate_mem_clear(graph, sizeof(gate_ui_graphics_t));

        if (deskdc == NULL)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }
        dc = CreateCompatibleDC(deskdc);
        if (dc == NULL)
        {
            ret = GATE_RESULT_OUTOFRESOURCES;
            break;
        }


        bitmapinfo.info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
        bitmapinfo.info.bmiHeader.biWidth = width;
        bitmapinfo.info.bmiHeader.biHeight = height;
        bitmapinfo.info.bmiHeader.biPlanes = 1;
        bitmapinfo.info.bmiHeader.biBitCount = depth;
        bitmapinfo.info.bmiHeader.biCompression = BI_RGB;
        bitmapinfo.info.bmiHeader.biSizeImage = 0;
        bitmapinfo.info.bmiHeader.biXPelsPerMeter = 0;
        bitmapinfo.info.bmiHeader.biYPelsPerMeter = 0;
        bitmapinfo.info.bmiHeader.biClrImportant = 0;

        if (depth == 1)
        {
            bitmapinfo.info.bmiHeader.biClrUsed = 2;

            /* black */
            bitmapinfo.info.bmiColors[0].rgbBlue = 0;
            bitmapinfo.info.bmiColors[0].rgbGreen = 0;
            bitmapinfo.info.bmiColors[0].rgbRed = 0;
            bitmapinfo.info.bmiColors[0].rgbReserved = 0;

            /* white */
            bitmapinfo.info.bmiColors[1].rgbBlue = 255;
            bitmapinfo.info.bmiColors[1].rgbGreen = 255;
            bitmapinfo.info.bmiColors[1].rgbRed = 255;
            bitmapinfo.info.bmiColors[1].rgbReserved = 0;
        }
        else if (depth < 8)
        {
            static gate_color_rgb_t vga_pal[16];
            static gate_bool_t vga_pal_init = false;
            if (!vga_pal_init)
            {
                gate_color_palette_rgb4_create(vga_pal);
                vga_pal_init = true;
            }

            bitmapinfo.info.bmiHeader.biClrUsed = 16;
            ptr_quad = &bitmapinfo.info.bmiColors[0];
            for (r = 0; r < 16; ++r)
            {
                ptr_quad->rgbBlue = vga_pal[r].b;
                ptr_quad->rgbGreen = vga_pal[r].g;
                ptr_quad->rgbRed = vga_pal[r].r;
                ptr_quad->rgbReserved = 0;
                ++ptr_quad;
            }
        }
        else if (depth < 16)
        {
            ptr_quad = &bitmapinfo.info.bmiColors[0];
            bitmapinfo.info.bmiHeader.biClrUsed = create_palette_8(ptr_quad);
        }
        else
        {
            bitmapinfo.info.bmiHeader.biClrUsed = 0;
        }

        linelen = (bitmapinfo.info.bmiHeader.biWidth * (LONG)bitmapinfo.info.bmiHeader.biBitCount + 7) / 8;
        if (linelen % 4 != 0)
        {
            linelen += (4 - (linelen % 4));
        }
        bufferlen = linelen * bitmapinfo.info.bmiHeader.biHeight;
#if defined(GATE_SYS_WIN16)
        buffer = gate_mem_alloc(bufferlen);
        gate_mem_clear(buffer, bufferlen);
        hbitmap = CreateDIBitmap(deskdc, &bitmapinfo.info.bmiHeader, CBM_INIT, buffer, &bitmapinfo.info, DIB_RGB_COLORS);
#else
        buffer = NULL;
        hbitmap = CreateDIBSection(deskdc, &bitmapinfo.info, DIB_RGB_COLORS, &buffer, NULL, 0);
#endif
        if (hbitmap == NULL)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }
        hbackup = SelectObject(dc, hbitmap);

        graph->width = width;
        graph->height = height;
        graph->host = host;
        graph->resources[0] = dc;
        graph->resources[1] = hbackup;
        graph->resources[2] = NULL;
        graph->resources[3] = buffer;
        ret = GATE_RESULT_OK;

    } while (0);

    if (deskdc != NULL)
    {
        ReleaseDC(desk, deskdc);
    }

    return ret;
}

gate_result_t gate_ui_graphics_create_image_from(gate_ui_graphics_t* graph, gate_ui_host_t* host, gate_rasterimage_t const* rasterimage)
{
    
    gate_uint32_t x, y;
    gate_result_t ret;
#if defined(GATE_WIN32_ANSI)

#   if 0
    /* use 8-bit DIB */
    ret = gate_ui_graphics_create_image(graph, host, rasterimage->width, rasterimage->height, 8);
    if (GATE_SUCCEEDED(ret))
    {
        gate_uint8_t* ptrbytes = (gate_uint8_t*)GATE_UI_GRAPHICS_BYTEBUFFER(graph);
        unsigned line_patch = (unsigned)(rasterimage->width % 4);
        if (line_patch != 0)
        {
            line_patch = 4 - line_patch;
        }
        for (y = 0; y != rasterimage->height; ++y)
        {
            gate_color_t const* ptrpixels = (gate_color_t const*)gate_rasterimage_get_line_ptr(rasterimage, (rasterimage->height - 1 - y));
            for (x = 0; x != rasterimage->width; ++x)
            {
                gate_uint16_t col16;
                col16 = (((gate_uint16_t)ptrpixels->r + 25) / 51) * 36;
                col16 += (((gate_uint16_t)ptrpixels->g + 25) / 51) * 6;
                col16 += (((gate_uint16_t)ptrpixels->b + 25) / 51);

                *(ptrbytes++) = (gate_uint8_t)(col16 & 0xff);
                ++ptrpixels;
            }
            ptrbytes += line_patch;
        }
    }
#   else
    /* use 16-bit DIB */
    ret = gate_ui_graphics_create_image(graph, host, rasterimage->width, rasterimage->height, 16);
    if (GATE_SUCCEEDED(ret))
    {
        gate_uint8_t* ptrbytes = (gate_uint8_t*)GATE_UI_GRAPHICS_BYTEBUFFER(graph);
        unsigned line_patch = (unsigned)(rasterimage->width % 2) * 2;
        for (y = 0; y != rasterimage->height; ++y)
        {
            gate_color_t const* ptrpixels = (gate_color_t const*)gate_rasterimage_get_line_ptr(rasterimage, (rasterimage->height - 1 - y));
            for (x = 0; x != rasterimage->width; ++x)
            {
                gate_uint16_t col16
                    = ((gate_uint16_t)(ptrpixels->b & 0xF8) >> 3)
                    | ((gate_uint16_t)(ptrpixels->g & 0xF8) << 2)
                    | ((gate_uint16_t)(ptrpixels->r & 0xF8) << 7);

                *(ptrbytes++) = (gate_uint8_t)(col16 & 0xff);
                *(ptrbytes++) = (gate_uint8_t)(col16 >> 8);
                ++ptrpixels;
            }
            ptrbytes += line_patch;
        }
    }
#   endif

#else
    ret = gate_ui_graphics_create_image(graph, host, rasterimage->width, rasterimage->height, 32);
    if (GATE_SUCCEEDED(ret))
    {
        gate_uint8_t* ptrbytes = (gate_uint8_t*)GATE_UI_GRAPHICS_BYTEBUFFER(graph);
        for (y = 0; y != rasterimage->height; ++y)
        {
            if ((rasterimage->pixel_format == GATE_IMAGE_PIXELFORMAT_DEFAULT) 
             || (rasterimage->pixel_format == GATE_IMAGE_PIXELFORMAT_RGBA)
             || (rasterimage->pixel_format == GATE_IMAGE_PIXELFORMAT_RGB32)
            )
            {
                gate_color_t const* ptrpixels = (gate_color_t const*)gate_rasterimage_get_line_ptr(rasterimage, (rasterimage->height - 1 - y));
                for (x = 0; x != rasterimage->width; ++x)
                {
                    *(ptrbytes++) = ptrpixels->b;
                    *(ptrbytes++) = ptrpixels->g;
                    *(ptrbytes++) = ptrpixels->r;
                    *(ptrbytes++) = 0;
                    ++ptrpixels;
                }
            }
            else
            {
                unsigned const line = rasterimage->height - 1 - y;
                for (x = 0; x != rasterimage->width; ++x)
                {
                    gate_color_t pixel;
                    gate_rasterimage_get_pixel(rasterimage, x, line, &pixel);
                    *(ptrbytes++) = pixel.b;
                    *(ptrbytes++) = pixel.g;
                    *(ptrbytes++) = pixel.r;
                    *(ptrbytes++) = 0;
                }
            }
        }
    }
#endif
    return ret;
}


gate_result_t gate_ui_graphics_create_ctrl(gate_ui_graphics_t* graph, gate_ui_ctrl_t* ctrl)
{
    HWND hwnd = (HWND)GATE_UI_WINAPI_GET_HWND(ctrl);
    RECT rect;

    gate_mem_clear(graph, sizeof(gate_ui_graphics_t));

    GetClientRect(hwnd, &rect);

    graph->host = GATE_UI_WINAPI_GET_HOST(ctrl);
    graph->width = rect.right - rect.left;
    graph->height = rect.bottom - rect.top;
    graph->resources[0] = GetDC(hwnd);
    graph->resources[2] = hwnd;
    return GATE_RESULT_OK;
}
gate_result_t gate_ui_graphics_create_native(gate_ui_graphics_t* graph, gate_ui_host_t* host, void* graphics, void* param, gate_int32_t width, gate_int32_t height)
{
    GATE_UNUSED_ARG(param);
    gate_mem_clear(graph, sizeof(gate_ui_graphics_t));
    graph->host = host;
    graph->resources[0] = graphics;
    graph->resources[3] = (void*)(gate_intptr_t)(-1);   ///< no-release flag
    graph->width = width;
    graph->height = height;
    return GATE_RESULT_OK;
}
gate_result_t gate_ui_graphics_destroy(gate_ui_graphics_t* graph)
{
    gate_bool_t success = true;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    HBITMAP hbmp = GATE_UI_GRAPHICS_BACKUP(graph);
    HWND hwnd = GATE_UI_GRAPHICS_WINDOW(graph);
    void* buffer_ptr = GATE_UI_GRAPHICS_BYTEBUFFER(graph);

    if (-1 == (gate_intptr_t)buffer_ptr)
    {
        // no-release flag is active
    }
    else
    {
        if (hbmp != NULL)
        {
            success &= (FALSE != DeleteObject(SelectObject(hdc, (HGDIOBJ)hbmp)));
        }

        if (hwnd != NULL)
        {
            success &= (0 != ReleaseDC(hwnd, hdc));
        }
        else
        {
            success &= (FALSE != DeleteDC(hdc));
        }

        if (buffer_ptr != NULL)
        {
#if defined(GATE_SYS_WIN16)
            gate_mem_dealloc(buffer_ptr);
#else
            /* win32 dib section will release the buffer bits automatically */
#endif
        }

    }

    return success ? GATE_RESULT_OK : GATE_RESULT_FAILED;
}

gate_int32_t gate_ui_graphics_width(gate_ui_graphics_t* graph)
{
    return (graph != NULL) ? graph->width : 0;
}
gate_int32_t gate_ui_graphics_height(gate_ui_graphics_t* graph)
{
    return (graph != NULL) ? graph->height : 0;
}

#ifndef CLR_INVALID
#define CLR_INVALID 0xffffffff
#endif

gate_result_t gate_ui_graphics_set_pixel(gate_ui_graphics_t* graph, gate_ui_point_t pos, gate_ui_color_t col)
{
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    COLORREF colref = RGB(col.r, col.g, col.b);
    COLORREF result = SetPixel(hdc, (int)pos.x, (int)pos.y, colref);
    if (result == CLR_INVALID)
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        return GATE_RESULT_OK;
    }
}
gate_result_t gate_ui_graphics_get_pixel(gate_ui_graphics_t* graph, gate_ui_point_t pos, gate_ui_color_t* col)
{
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    COLORREF colref = GetPixel(hdc, (int)pos.x, (int)pos.y);
    if (colref == CLR_INVALID)
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        col->r = GetRValue(colref);
        col->g = GetGValue(colref);
        col->b = GetBValue(colref);
        col->a = 255;
        return GATE_RESULT_OK;
    }
}
gate_result_t gate_ui_graphics_draw(gate_ui_graphics_t* graph, gate_ui_graphics_t* srcgraph,
    gate_ui_point_t const* dst, gate_ui_size_t const* size, gate_ui_point_t const* srcpos)
{
    HDC hdc_dst = GATE_UI_GRAPHICS_HDC(graph);
    HDC hdc_src = GATE_UI_GRAPHICS_HDC(srcgraph);
    int dst_x = dst ? dst->x : 0;
    int dst_y = dst ? dst->y : 0;
    int width = size ? size->width : -1;
    int height = size ? size->height : -1;
    int src_x = srcpos ? srcpos->x : 0;
    int src_y = srcpos ? srcpos->y : 0;

    if (width < 0)
    {
        width += gate_ui_graphics_width(srcgraph) + 1;
    }
    if (height < 0)
    {
        height += gate_ui_graphics_height(srcgraph) + 1;
    }

    if (FALSE == BitBlt(hdc_dst, dst_x, dst_y, width, height, hdc_src, src_x, src_y, SRCCOPY))
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        return GATE_RESULT_OK;
    }
}

gate_result_t gate_ui_graphics_draw_ex(gate_ui_graphics_t* graph, gate_ui_graphics_t* src_graph,
    gate_ui_position_t const* dest_rect, gate_ui_position_t const* src_rect)
{
    HDC hdc_dst = GATE_UI_GRAPHICS_HDC(graph);
    HDC hdc_src = GATE_UI_GRAPHICS_HDC(src_graph);
    int dst_x = dest_rect ? dest_rect->pos.x : 0;
    int dst_y = dest_rect ? dest_rect->pos.y : 0;
    int dst_width = dest_rect ? dest_rect->size.width : -1;
    int dst_height = dest_rect ? dest_rect->size.height : -1;
    int src_x = src_rect ? src_rect->pos.x : 0;
    int src_y = src_rect ? src_rect->pos.y : 0;
    int src_width = src_rect ? src_rect->size.width : -1;
    int src_height = src_rect ? src_rect->size.height : -1;

    if (dst_width < 0)
    {
        dst_width += gate_ui_graphics_width(graph) + 1;
    }
    if (dst_height < 0)
    {
        dst_height += gate_ui_graphics_height(graph) + 1;
    }

    if (src_width < 0)
    {
        src_width += gate_ui_graphics_width(src_graph) + 1;
    }
    if (src_height < 0)
    {
        src_height += gate_ui_graphics_height(src_graph) + 1;
    }
#if defined(COLORONCOLOR) && !defined(__MINGW32CE__)
    SetStretchBltMode(hdc_dst, COLORONCOLOR);
#endif

    if (FALSE == StretchBlt(hdc_dst, dst_x, dst_y, dst_width, dst_height, hdc_src,
        src_x, src_y, src_width, src_height, SRCCOPY))
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        return GATE_RESULT_OK;
    }
}

gate_result_t gate_ui_graphics_draw_image(gate_ui_graphics_t* graph, gate_rasterimage_t const* srcimage,
    gate_ui_point_t const* dst, gate_ui_size_t const* size, gate_ui_point_t const* srcpos)
{
    gate_ui_graphics_t src_graph;
    gate_result_t ret = gate_ui_graphics_create_image_from(&src_graph, graph->host, srcimage);
    if (GATE_SUCCEEDED(ret))
    {
        ret = gate_ui_graphics_draw(graph, &src_graph, dst, size, srcpos);
        gate_ui_graphics_destroy(&src_graph);
    }
    return ret;
}


gate_result_t gate_ui_graphics_line(gate_ui_graphics_t* graph, gate_ui_point_t from, gate_ui_point_t to, gate_ui_color_t col, gate_uint32_t linewidth)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    COLORREF colref = RGB(col.r, col.g, col.b);
    HPEN hpen = CreatePen(PS_SOLID, linewidth, colref);
    HGDIOBJ hselpen = SelectObject(hdc, (HGDIOBJ)hpen);
    if (MoveToEx(hdc, (int)from.x, (int)from.y, NULL))
    {
        if (LineTo(hdc, (int)to.x, (int)to.y))
        {
            SetPixel(hdc, (int)to.x, (int)to.y, colref);
            ret = GATE_RESULT_OK;
        }
    }
    DeleteObject(SelectObject(hdc, hselpen));
    return ret;
}
gate_result_t gate_ui_graphics_rect(gate_ui_graphics_t* graph, gate_ui_position_t rect, gate_ui_color_t const* colline, gate_uint32_t linewidth, gate_ui_color_t const* colfill)
{
    gate_result_t success = true;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    RECT r;
    HGDIOBJ hbackup;
    HBRUSH hbrush;
    HPEN hpen;
    COLORREF colref;

    if (colfill != NULL)
    {
        colref = RGB(colfill->r, colfill->g, colfill->b);
        hbrush = CreateSolidBrush(colref);
        r.left = rect.pos.x;
        r.top = rect.pos.y;
        r.right = rect.pos.x + rect.size.width + 1;
        r.bottom = rect.pos.y + rect.size.height + 1;
        success &= (0 != FillRect(hdc, &r, hbrush));
        DeleteObject(hbrush);
    }
    if (colline != NULL)
    {
        colref = RGB(colline->r, colline->g, colline->b);
        hpen = CreatePen(PS_SOLID, (int)linewidth, colref);
        hbackup = SelectObject(hdc, hpen);
        success &= (FALSE != MoveToEx(hdc, rect.pos.x, rect.pos.y, NULL));
        success &= (FALSE != LineTo(hdc, rect.pos.x + rect.size.width, rect.pos.y));
        success &= (FALSE != LineTo(hdc, rect.pos.x + rect.size.width, rect.pos.y + rect.size.height));
        success &= (FALSE != LineTo(hdc, rect.pos.x, rect.pos.y + rect.size.height));
        success &= (FALSE != LineTo(hdc, rect.pos.x, rect.pos.y));
        DeleteObject(SelectObject(hdc, hbackup));
    }
    return success ? GATE_RESULT_OK : GATE_RESULT_FAILED;
}
gate_result_t gate_ui_graphics_polygon(gate_ui_graphics_t* graph, gate_ui_point_t const* points, gate_size_t pointcount, gate_ui_color_t const* colline, gate_uint32_t linewidth, gate_ui_color_t const* colfill)
{
    gate_result_t success = true;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    HGDIOBJ hbackup;
    HGDIOBJ hbackup2;
    HPEN hpen;
    HBRUSH hbrush;
    COLORREF colref;
    gate_size_t ndx;
    POINT pnts[1024];

    if (colfill != NULL)
    {
        colref = RGB(colfill->r, colfill->g, colfill->b);
        if (pointcount > sizeof(pnts) / sizeof(pnts[0]))
        {
            pointcount = sizeof(pnts) / sizeof(pnts[0]);
        }
        for (ndx = 0; ndx < pointcount; ++ndx)
        {
            pnts[ndx].x = (int)points[ndx].x;
            pnts[ndx].y = (int)points[ndx].y;
        }
        hpen = CreatePen(PS_NULL, 0, 0);
        hbackup = SelectObject(hdc, (HGDIOBJ)hpen);
        hbrush = CreateSolidBrush(colref);
        hbackup2 = SelectObject(hdc, (HGDIOBJ)hbrush);

        success &= (FALSE != Polygon(hdc, pnts, (int)pointcount));

        DeleteObject(SelectObject(hdc, hbackup2));
        DeleteObject(SelectObject(hdc, hbackup));
    }

    if (colline != NULL)
    {
        colref = RGB(colline->r, colline->g, colline->b);
        hpen = CreatePen(PS_SOLID, linewidth, colref);
        hbackup = SelectObject(hdc, (HGDIOBJ)hpen);
        success &= (FALSE != MoveToEx(hdc, (int)points[0].x, (int)points[0].y, NULL));
        for (ndx = 1; ndx != pointcount; ++ndx)
        {
            success &= (FALSE != LineTo(hdc, (int)points[ndx].x, (int)points[ndx].y));
        }
        success &= (FALSE != LineTo(hdc, (int)points[0].x, (int)points[0].y));
        DeleteObject(SelectObject(hdc, hbackup));
    }
    return success ? GATE_RESULT_OK : GATE_RESULT_FAILED;
}

#if defined(GATE_SYS_WIN16)

static BOOL GetTextExtentExPoint(HDC hdc, LPCSTR lpszString, int cchString, int nMaxExtent, LPINT lpnFit, LPINT lpnDx, LPSIZE lpSize)
{
    SIZE sz;
    SIZE szchr;
    GATE_UNUSED_ARG(nMaxExtent);
    GATE_UNUSED_ARG(lpnFit);
    sz.cx = 0;
    sz.cy = 0;
    while (cchString-- > 0)
    {
        GetTextExtentPoint(hdc, lpszString, 1, &szchr);
        sz.cx += szchr.cx;
        *lpnDx = szchr.cx;

        ++lpszString;
        ++lpnDx;
    }
    lpSize->cx = sz.cx;
    lpSize->cy = sz.cy;
    return TRUE;
}

#define GetTextExtentPoint32 GetTextExtentPoint

#endif

gate_result_t gate_ui_graphics_get_char_size(gate_ui_graphics_t* graph, gate_ui_font_t const* font,
    gate_char32_t const* chars, gate_size_t charcount, gate_int32_t* charlens)
{
    /* NOTICE: this function only supports up to 2048 characters! */
    gate_result_t ret = GATE_RESULT_FAILED;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    TCHAR buffer[2048];
    int lengths[2048];
    gate_size_t bufferused = gate_win32_utf32_2_winstr(chars, charcount, buffer, sizeof(buffer) / sizeof(buffer[0]));
    HGDIOBJ hbackup;
    HFONT hfont = (HFONT)gate_ui_winapi_create_font(font);
    SIZE sz = { 0, 0 };
    gate_size_t index;

    hbackup = SelectObject(hdc, (HGDIOBJ)hfont);

    if (FALSE == GetTextExtentExPoint(hdc, buffer, (int)bufferused, 0, NULL, lengths, &sz))
    {
        gate_win32_print_lasterror(&ret, NULL, 0);
    }
    else
    {
        for (index = 0; index != bufferused; ++index)
        {
            charlens[index] = lengths[index];
        }
        ret = GATE_RESULT_OK;
    }

    DeleteObject(SelectObject(hdc, hbackup));
    return ret;
}
gate_result_t gate_ui_graphics_get_text_size(gate_ui_graphics_t* graph, gate_ui_font_t const* font,
    gate_string_t const* txt, gate_int32_t* width, gate_int32_t* height)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    HGDIOBJ hbackup = NULL;
    TCHAR buffer[4096];
    gate_size_t bufferused = gate_win32_utf8_2_winstr(txt->str, txt->length, buffer, sizeof(buffer) / sizeof(buffer[0]));
    HFONT hfont = (HFONT)gate_ui_winapi_create_font(font);
    SIZE sz = { 0, 0 };

    hbackup = SelectObject(hdc, (HGDIOBJ)hfont);

    if (FALSE == GetTextExtentPoint32(hdc, buffer, (int)bufferused, &sz))
    {
        gate_win32_print_lasterror(&ret, NULL, 0);
    }
    else
    {
        if (width)
        {
            *width = (gate_int32_t)sz.cx;
        }
        if (height)
        {
            *height = (gate_int32_t)sz.cy;
        }
        ret = GATE_RESULT_OK;
    }

    DeleteObject(SelectObject(hdc, hbackup));
    return ret;
}
gate_result_t gate_ui_graphics_print(gate_ui_graphics_t* graph, gate_ui_font_t const* font,
    gate_string_t const* text, gate_ui_position_t const* pos)
{
    gate_bool_t success = true;
    HDC hdc = GATE_UI_GRAPHICS_HDC(graph);
    HGDIOBJ hbackup;
    HFONT hfont = (HFONT)gate_ui_winapi_create_font(font);
    TCHAR buffer[4096];
    RECT rect;
    UINT flags = DT_LEFT | DT_NOPREFIX | DT_NOCLIP;
    gate_size_t bufferused = gate_win32_utf8_2_winstr(text->str, text->length, buffer, sizeof(buffer) / sizeof(buffer[0]));
    rect.left = pos->pos.x;
    rect.top = pos->pos.y;
    if ((pos->size.width == 0) && (pos->size.height == 0))
    {
        rect.bottom = graph->width;
        rect.right = graph->height;
    }
    else
    {
        rect.bottom = pos->pos.x + pos->size.width + 1;
        rect.right = pos->pos.y + pos->size.height + 1;
        flags |= DT_VCENTER;
    }
    SetTextColor(hdc, RGB(font->color.r, font->color.g, font->color.b));
    SetBkMode(hdc, TRANSPARENT);
    hbackup = SelectObject(hdc, (HGDIOBJ)hfont);
    success &= ((0 != DrawText(hdc, buffer, (int)bufferused, &rect, flags)) ? true : false);
    DeleteObject(SelectObject(hdc, hbackup));
    return success ? GATE_RESULT_OK : GATE_RESULT_FAILED;
}

void* gate_ui_graphics_handle(gate_ui_graphics_t* graph)
{
    return (void*)GATE_UI_GRAPHICS_HDC(graph);
}
void* gate_ui_graphics_surface(gate_ui_graphics_t* graph)
{
    return (void*)GATE_UI_GRAPHICS_WINDOW(graph);
}


/*****************************
 * icon WIN32 implementation *
 *****************************/

gate_result_t gate_ui_icon_create_native(gate_ui_icon_t* icon, gate_ui_host_t* host, void* handle, gate_uint32_t flags)
{
    icon->host = host;
    icon->resources[0] = handle;
    icon->flags = flags;
    return GATE_RESULT_OK;
}

typedef UINT(WINAPI* ExtractIconEx_funcptr_t)(LPCTSTR lpszFile, int nIconIndex, HICON* phiconLarge, HICON* phiconSmall, UINT nIcons);
static ExtractIconEx_funcptr_t ExtractIconEx_function = NULL;

static HICON gate_ui_extract_icon(LPCTSTR file, int icon_index, gate_uint32_t flags)
{
    gate_bool_t is_small = GATE_FLAG_ENABLED(flags, GATE_UI_ICON_FLAG_SMALL);
    HICON hicon = NULL;
    HMODULE hmod;
    UINT extracted;
    do
    {
        if (ExtractIconEx_function == NULL)
        {
            hmod = gate_win32_get_shell_module();
            if (hmod != NULL)
            {
                gate_win32_get_proc_address(hmod, GATE_WINAPI_DUAL_NAME("ExtractIconEx"), &ExtractIconEx_function);
            }
        }
        if (ExtractIconEx_function != NULL)
        {
            extracted = ExtractIconEx_function(file, icon_index, is_small ? NULL : &hicon, is_small ? &hicon : NULL, 1);
            if (extracted == 0)
            {
                hicon = NULL;
            }
        }
    } while (0);
    return hicon;
}

gate_result_t gate_ui_icon_create_stock(gate_ui_icon_t* icon, gate_ui_host_t* host, gate_uint32_t stock_id, gate_uint32_t flags)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HICON hicon = NULL;

#if defined(GATE_SYS_WINCE)
    hicon = LoadCursor(NULL, IDC_APPSTARTING);
#else
    LPCTSTR icon_source_file = _T("shell32.dll");
    int icon_source_index = -1;
    int icon_source_index_alt = -1;

    switch (stock_id)
    {
    case GATE_UI_ICON_STOCK_APP:            icon_source_index = 2; break;
    case GATE_UI_ICON_STOCK_DOCUMENT:       icon_source_index = 1; break;
    case GATE_UI_ICON_STOCK_FOLDER:         icon_source_index = 3; break;
    case GATE_UI_ICON_STOCK_FOLDEROPEN:     icon_source_index = 4; break;
    case GATE_UI_ICON_STOCK_NEWFILE:        icon_source_index = 70; icon_source_index_alt = 1; break;
    case GATE_UI_ICON_STOCK_OPENFILE:       icon_source_index = 126; icon_source_index_alt = 85; break;
    case GATE_UI_ICON_STOCK_SAVEFILE:       icon_source_index = 258; icon_source_index_alt = 6; break;
    case GATE_UI_ICON_STOCK_PRINTER:        icon_source_index = 16; break;
    case GATE_UI_ICON_STOCK_CUT:            icon_source_index = 259; icon_source_index_alt = 65; break;
    case GATE_UI_ICON_STOCK_COPY:           icon_source_index = 134; icon_source_index_alt = 54; break;
    case GATE_UI_ICON_STOCK_PASTE:          icon_source_index = 260; icon_source_index_alt = 66; break;
    case GATE_UI_ICON_STOCK_DELETE:         icon_source_index = 131; icon_source_index_alt = 105; break;
    case GATE_UI_ICON_STOCK_FIND:           icon_source_index = 22; break;
    case GATE_UI_ICON_STOCK_HELP:           icon_source_index = 23; break;

    case GATE_UI_ICON_STOCK_STORAGE:        icon_source_index = 8; icon_source_index_alt = 8; break;
    case GATE_UI_ICON_STOCK_COMPUTER:       icon_source_index = 15; icon_source_index_alt = 15; break;
    case GATE_UI_ICON_STOCK_NETWORK:        icon_source_index = 18; icon_source_index_alt = 18; break;
    case GATE_UI_ICON_STOCK_GLOBE:          icon_source_index = 13; icon_source_index_alt = 13; break;
    case GATE_UI_ICON_STOCK_SETTINGS:       icon_source_index = 90; icon_source_index_alt = 21; break;
    case GATE_UI_ICON_STOCK_HOME:           icon_source_index = 150; icon_source_index_alt = 39; break;
    case GATE_UI_ICON_STOCK_IMAGE:          icon_source_index = 117; icon_source_index_alt = 34; break;
    case GATE_UI_ICON_STOCK_AUDIO:          icon_source_index = 116; icon_source_index_alt = 40; break;
    case GATE_UI_ICON_STOCK_VIDEO:          icon_source_index = 115; icon_source_index_alt = 79; break;
    case GATE_UI_ICON_STOCK_MAIL:           icon_source_index = 156; icon_source_index_alt = 91; break;

    default:                                break;
    }

    if (icon_source_index < 0)
    {
        return GATE_RESULT_NOMATCH;
    }

    hicon = gate_ui_extract_icon(icon_source_file, icon_source_index, flags);
    if ((hicon == NULL) && (icon_source_index_alt >= 0))
    {
        hicon = gate_ui_extract_icon(icon_source_file, icon_source_index_alt, flags);
    }
#endif

    if (hicon == NULL)
    {
        return GATE_RESULT_NOTAVAILABLE;
    }

    ret = gate_ui_icon_create_native(icon, host, (void*)hicon, (flags & GATE_UI_ICON_FLAG_SMALL) | GATE_UI_ICON_FLAG_STOCK);
    if (GATE_FAILED(ret))
    {
        DestroyIcon(hicon);
    }
    else
    {
        icon->resources[1] = (void*)(gate_uintptr_t)stock_id;
    }
    return ret;
}

#if defined(GATE_SYS_WIN16)

static HICON gate_ui_icon_create_from_image(gate_ui_host_t* host, gate_rasterimage_t const* image, gate_uint32_t hx, gate_uint32_t hy)
{
    /* TODO */
    return CreateIcon(NULL, 32, 32, 2, 2, NULL, NULL);
}

#else /* GATE_SYS_WIN16 */

static HICON gate_ui_icon_create_from_image(gate_ui_host_t* host, gate_rasterimage_t const* image, gate_uint32_t hx, gate_uint32_t hy)
{
    HICON ret = NULL;

    do
    {
        gate_ui_position_t imagerect;
        gate_ui_color_t maskcolor = { 255, 255, 255, 255 };
        gate_ui_point_t pos;
        gate_uint32_t icon_flags = 0;
        static COLORREF color_black = RGB(0, 0, 0);
        static COLORREF color_white = RGB(255, 255, 255);
        COLORREF color_bg = GetSysColor(COLOR_3DFACE);

        ICONINFO iconinfo;

        HBITMAP hbmptmp1 = NULL;
        HBITMAP hbmptmp2 = NULL;
        HBITMAP bmpmask = NULL;
        HBITMAP bmpimage = NULL;
        HDC desk = NULL;
        HDC hmask = NULL;
        HDC himage = NULL;
        gate_color_t const* ptrpixels;

        iconinfo.fIcon = TRUE;
        iconinfo.xHotspot = hx;
        iconinfo.yHotspot = hy;
        iconinfo.hbmMask = NULL;
        iconinfo.hbmColor = NULL;

        imagerect.pos.x = 0;
        imagerect.pos.y = 0;
        imagerect.size.width = image->width;
        imagerect.size.height = image->height;

        desk = GetDC(NULL);
        hmask = CreateCompatibleDC(desk);
        himage = CreateCompatibleDC(desk);

        bmpmask = CreateBitmap(image->width, image->height, 1, 1, NULL);
        bmpimage = CreateCompatibleBitmap(desk, image->width, image->height);

        hbmptmp1 = (HBITMAP)SelectObject(hmask, bmpmask);
        hbmptmp2 = (HBITMAP)SelectObject(himage, bmpimage);

        ptrpixels = (gate_color_t const*)gate_rasterimage_get_line_ptr(image, 0);
        for (pos.y = 0; pos.y != image->height; ++pos.y)
        {
            for (pos.x = 0; pos.x != image->width; ++pos.x)
            {
                SetPixel(hmask, pos.x, pos.y, (ptrpixels->a > 127) ? color_black : color_white);
                SetPixel(himage, pos.x, pos.y, (ptrpixels->a > 127) ? RGB(ptrpixels->r, ptrpixels->g, ptrpixels->b) : color_black);
                ++ptrpixels;
            }
        }
        SelectObject(hmask, hbmptmp1);
        SelectObject(himage, hbmptmp2);
        DeleteDC(hmask);
        DeleteDC(himage);
        ReleaseDC(NULL, desk);

        if (image->height < 24)
        {
            icon_flags |= GATE_UI_ICON_FLAG_SMALL;
        }
        if (image->height > 40)
        {
            icon_flags |= GATE_UI_ICON_FLAG_LARGE;
        }

        iconinfo.hbmMask = bmpmask;
        iconinfo.hbmColor = bmpimage;

        ret = CreateIconIndirect(&iconinfo);
        GATE_DEBUG_ASSERT(ret != NULL);

        DeleteObject(bmpmask);
        DeleteObject(bmpimage);
    } while (0);

    return ret;
}

#endif /* GATE_SYS_WIN16 */

gate_result_t gate_ui_icon_create_image(gate_ui_icon_t* icon, gate_ui_host_t* host, gate_rasterimage_t const* image)
{
    gate_result_t ret = GATE_RESULT_NOTIMPLEMENTED;
    HICON hicon = gate_ui_icon_create_from_image(host, image, 0, 0);
    if (hicon == NULL)
    {
        ret = GATE_RESULT_FAILED;
    }
    else
    {
        icon->resources[0] = hicon;
        icon->resources[1] = NULL;
        icon->host = host;
        if (image->height < 28)
        {
            icon->flags = GATE_UI_ICON_FLAG_SMALL;
        }
        else if (image->height > 36)
        {
            icon->flags = GATE_UI_ICON_FLAG_LARGE;
        }

        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_ui_icon_create_file(gate_ui_icon_t* icon, gate_ui_host_t* host, gate_string_t const* filepath)
{
    gate_result_t ret = GATE_RESULT_NOTIMPLEMENTED;
    /* TODO */
    return ret;
}
gate_result_t gate_ui_icon_copy(gate_ui_icon_t* dsticon, gate_ui_icon_t const* srcicon)
{
    gate_result_t ret = GATE_RESULT_OK;
    dsticon->host = srcicon->host;

#if !defined(GATE_SYS_WINCE)
    if (!GATE_FLAG_ENABLED(srcicon->flags, GATE_UI_ICON_FLAG_STOCK))
    {
        /* managed icon */
        dsticon->flags = srcicon->flags;
#if defined(GATE_SYS_WIN16)
        dsticon->resources[0] = (void*)CopyIcon(NULL, (HICON)srcicon->resources[0]);
#else
        dsticon->resources[0] = (void*)CopyIcon((HICON)srcicon->resources[0]);
#endif
        if (dsticon->resources[0] == NULL)
        {
            ret = GATE_RESULT_FAILED;
        }
        dsticon->resources[1] = NULL;
    }
    else
#endif
    {
        dsticon->resources[0] = srcicon->resources[0];
        dsticon->resources[1] = srcicon->resources[1];
    }
    return ret;
}

gate_result_t gate_ui_icon_destroy(gate_ui_icon_t* icon)
{
    gate_result_t ret = GATE_RESULT_OK;
    if (!GATE_FLAG_ENABLED(icon->flags, GATE_UI_ICON_FLAG_STOCK))
    {
        /* managed icon */
        if (!DestroyIcon((HICON)icon->resources[0]))
        {
            ret = GATE_RESULT_FAILED;
        }
    }
    return ret;
}



/******************
 * iconlist WIN32 *
 ******************/
#if !defined(ILC_COLOR16) && defined(ILC_COLOR)
#   define ILC_COLOR16 ILC_COLOR
#endif

gate_result_t gate_ui_iconlist_create(gate_ui_iconlist_t* ilst, gate_ui_host_t* host, gate_int32_t width, gate_int32_t height)
{
#if defined(GATE_SYS_WIN16)
    return GATE_RESULT_NOTIMPLEMENTED;
#else
    int const x = (int)width;
    int const y = (int)height;
    static UINT const flags = ILC_COLOR16 | ILC_MASK;<--- Skipping configuration 'GATE_UI_WINAPI;ILC_COLOR;ILC_COLOR16' since the value of 'ILC_COLOR16' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
    HIMAGELIST hlst = (HIMAGELIST)gate_ui_winapi_imagelist_create(x, y, flags, 1, 1);
    if (!hlst)
    {
        return GATE_RESULT_FAILED;
    }
    gate_ui_winapi_imagelist_set_bkcolor(hlst, NULL);
    gate_mem_clear(ilst, sizeof(gate_ui_iconlist_t));
    ilst->host = host;
    ilst->flags = 0;
    ilst->width = width;
    ilst->height = height;
    ilst->resources[0] = hlst;
    return GATE_RESULT_OK;
#endif
}

gate_result_t gate_ui_iconlist_destroy(gate_ui_iconlist_t* ilst)
{
#if defined(GATE_SYS_WIN16)
    return GATE_RESULT_NOTIMPLEMENTED;
#else
    if (ilst->resources[0] != NULL)
    {
        gate_ui_winapi_imagelist_destroy((HIMAGELIST)ilst->resources[0]);
    }
    gate_mem_clear(ilst, sizeof(gate_ui_iconlist_t));
    return GATE_RESULT_OK;
#endif
}
gate_size_t gate_ui_iconlist_count(gate_ui_iconlist_t* ilst)
{
    return 0;
}
gate_result_t gate_ui_iconlist_add_icon(gate_ui_iconlist_t* ilst, gate_ui_icon_t const* icon, gate_intptr_t* icon_key)
{
#if defined(GATE_SYS_WIN16)
    return GATE_RESULT_NOTIMPLEMENTED;
#else
    HIMAGELIST hlst = (HIMAGELIST)ilst->resources[0];
    int index;

    if (!hlst)
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    index = gate_ui_winapi_imagelist_replace_icon(hlst, -1, (HICON)icon->resources[0]);
    if (index < 0)
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        if (icon_key)
        {
            *icon_key = index;
        }
        return GATE_RESULT_OK;
    }
#endif
}

gate_result_t gate_ui_iconlist_add_image(gate_ui_iconlist_t* ilst, gate_rasterimage_t const* image, gate_intptr_t* icon_key)
{
#if defined(GATE_SYS_WIN16)
    return GATE_RESULT_NOTIMPLEMENTED;
#else
    gate_ui_icon_t icon = GATE_INIT_EMPTY;
    gate_result_t ret = gate_ui_icon_create_image(&icon, ilst->host, image);
    if (GATE_SUCCEEDED(ret))
    {
        ret = gate_ui_iconlist_add_icon(ilst, &icon, icon_key);
        gate_ui_icon_destroy(&icon);
    }
    return ret;
#endif
}

gate_result_t gate_ui_iconlist_get_icon(gate_ui_iconlist_t* ilst, gate_intptr_t icon_key, gate_ui_icon_t* icon)
{
#if defined(GATE_SYS_WIN16)
    return GATE_RESULT_NOTIMPLEMENTED;
#else
    UINT flags = ILD_TRANSPARENT;
    gate_uint32_t icon_flags;
    HICON hicon = (HICON)gate_ui_winapi_imagelist_get_icon((HIMAGELIST)ilst->resources[0], (int)icon_key, flags);
    if (!hicon)
    {
        return GATE_RESULT_FAILED;
    }
    else
    {
        icon_flags = GATE_UI_ICON_FLAG_STOCK;
        if (ilst->height < 24)
        {
            icon_flags |= GATE_UI_ICON_FLAG_SMALL;
        }
        if (ilst->height > 40)
        {
            icon_flags |= GATE_UI_ICON_FLAG_LARGE;
        }
        return gate_ui_icon_create_native(icon, ilst->host, hicon, icon_flags);
    }
#endif
}

void* gate_ui_iconlist_get_handle(gate_ui_iconlist_t* ilst, gate_intptr_t icon_key)
{
#if defined(GATE_SYS_WIN16)
    return NULL;
#else
    UINT flags = ILD_TRANSPARENT;
    HICON hicon = (HICON)gate_ui_winapi_imagelist_get_icon((HIMAGELIST)ilst->resources[0], (int)icon_key, flags);
    return (void*)hicon;
#endif
}





/****************
 * cursor WIN32 *
 ****************/

#ifndef IDC_APPSTARTING
#define IDC_APPSTARTING IDC_WAIT
#endif

#ifndef IDC_NO
#define IDC_NO IDC_ICON
#endif

gate_result_t gate_ui_cursor_create_stock(gate_ui_cursor_t* cursor, gate_ui_host_t* host, gate_enumint_t stock_id)
{
    LPCTSTR resourceId = NULL;
    HCURSOR hcursor = NULL;

    GATE_DEBUG_ASSERT(cursor != NULL);
    GATE_DEBUG_ASSERT(host != NULL);

    gate_mem_clear(cursor, sizeof(gate_ui_cursor_t));

    switch (stock_id)
    {
    case GATE_UI_CURSOR_STOCK_POINTER:              resourceId = IDC_ARROW; break;
    case GATE_UI_CURSOR_STOCK_BUSY:                 resourceId = IDC_WAIT; break;
    case GATE_UI_CURSOR_STOCK_STARTING:             resourceId = IDC_APPSTARTING; break;
    case GATE_UI_CURSOR_STOCK_HAND:                 resourceId = /*IDC_HAND*/ IDC_UPARROW; break;
    case GATE_UI_CURSOR_STOCK_TEXT:                 resourceId = IDC_IBEAM; break;
    case GATE_UI_CURSOR_STOCK_REJECTED:             resourceId = IDC_NO; break;
    case GATE_UI_CURSOR_STOCK_SIZE_ALL:             resourceId = IDC_SIZE; break;
    case GATE_UI_CURSOR_STOCK_SIZE_LEFTRIGHT:       resourceId = IDC_SIZEWE; break;
    case GATE_UI_CURSOR_STOCK_SIZE_UPDOWN:          resourceId = IDC_SIZENS; break;
    case GATE_UI_CURSOR_STOCK_SIZE_LEFTUPRIGHTDOWN: resourceId = IDC_SIZENWSE; break;
    case GATE_UI_CURSOR_STOCK_SIZE_RIGHTUPKEFTDOWN: resourceId = IDC_SIZENESW; break;
    default:    return GATE_RESULT_INVALIDARG;
    }

    hcursor = LoadCursor(NULL, resourceId);
    if (NULL == hcursor)
    {
        return GATE_RESULT_FAILED;
    }
    cursor->host = host;
    cursor->resources[0] = (void*)hcursor;
    cursor->resources[1] = NULL;
    cursor->flags = GATE_UI_CURSOR_FLAG_STOCK;
    return GATE_RESULT_OK;
}
gate_result_t gate_ui_cursor_create_native(gate_ui_cursor_t* cursor, gate_ui_host_t* host, void* handle, gate_enumint_t flags)
{
    cursor->host = host;
    cursor->resources[0] = handle;
    cursor->resources[1] = NULL;
    cursor->flags = flags;
    return GATE_RESULT_OK;
}
gate_result_t gate_ui_cursor_create_image(gate_ui_cursor_t* cursor, gate_ui_host_t* host, gate_rasterimage_t const* image, gate_uint16_t x, gate_uint16_t y)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    HCURSOR hcursor = (HCURSOR)gate_ui_icon_create_from_image(host, image, x, y);
    if (hcursor)
    {
        cursor->resources[0] = (void*)hcursor;
        cursor->resources[1] = NULL;
        cursor->host = host;
        cursor->flags = 0;
        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_ui_cursor_create_file(gate_ui_cursor_t* cursor, gate_ui_host_t* host, gate_string_t const* filepath)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}

gate_result_t gate_ui_cursor_copy(gate_ui_cursor_t* dsticon, gate_ui_cursor_t const* srcicon)
{
    gate_result_t ret = GATE_RESULT_FAILED;
#if !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WIN16)
    if (!GATE_FLAG_ENABLED(srcicon->flags, GATE_UI_CURSOR_FLAG_STOCK))
    {
        dsticon->resources[0] = (void*)CopyImage((HANDLE)srcicon->resources[0], IMAGE_CURSOR, 0, 0, 0);
        if (dsticon->resources[0] != NULL)
        {
            dsticon->resources[1] = NULL;
            dsticon->host = srcicon->host;
            dsticon->flags = 0;
            ret = GATE_RESULT_OK;
        }
    }
    else
#endif /* ! GATE_SYS_WINCE */
    {
        gate_mem_copy(dsticon, srcicon, sizeof(gate_ui_cursor_t));
        ret = GATE_RESULT_OK;
    }
    return ret;
}
gate_result_t gate_ui_cursor_destroy(gate_ui_cursor_t* cursor)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    if (cursor)
    {
        ret = GATE_RESULT_OK;
        if (!GATE_FLAG_ENABLED(cursor->flags, GATE_UI_CURSOR_FLAG_STOCK))
        {
#if !defined(GATE_SYS_WINCE)
            if (!DestroyCursor((HCURSOR)cursor->resources[0]))
            {
                ret = GATE_RESULT_FAILED;
            }
#endif
        }
    }
    return ret;
}

#endif  /* GATE_UI_WINAPI */