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

/* GATE PROJECT LICENSE:
+----------------------------------------------------------------------------+
| Copyright(c) 2018-2025, 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/splitters.h"
#include "gate/results.h"

#if defined(GATE_UI_WINAPI)

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

static BOOL SetWindowPosIfRequired(HWND hWnd, HWND hWndInsertAfter, int X, int Y, int cx, int cy, UINT uFlags)
{
    RECT rect;
    POINT point;
    HWND hWndParent;
    BOOL ret = TRUE;

#if !defined(GATE_SYS_WIN16)
    ret =
#endif
        GetWindowRect(hWnd, &rect);
    if (ret)
    {
        hWndParent = GetParent(hWnd);

        point.x = rect.left;
        point.y = rect.top;

        if (hWndParent != NULL)
        {
            ScreenToClient(hWndParent, &point);
        }
        if ((X != point.x) || (Y != point.y) ||
            (cx != rect.right - rect.left) || (cy != rect.bottom - rect.top)
            )
        {
            ret = SetWindowPos(hWnd, hWndInsertAfter, X, Y, cx, cy, uFlags);
        }
        else
        {
            ret = FALSE;
        }
    }
    return ret;
}


static void gate_ui_splitter_resize(gate_ui_splitter_t* splitter, HWND hwndFirst, HWND hwndSecond)
{
    gate_ui_size_t sz;
    gate_result_t ret;
    gate_ui_host_t* host = GATE_UI_WINAPI_GET_HOST(&splitter->ctrl);
    gate_uint32_t lineheight = gate_ui_host_default_line_height(host);
    gate_uint32_t length;
    gate_int32_t separator;
    UINT showflags = SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER | SWP_DRAWFRAME;
    do
    {
        ret = gate_ui_winapi_get_size(&splitter->ctrl, &sz);
        if (GATE_FAILED(ret)) break;

        separator = lineheight / 5;
        if (separator < 1) separator = 1;

        if (splitter->vertical)
        {
            length = sz.height;
        }
        else
        {
            length = sz.width;
        }
        if (length < splitter->minimum * 3 / 2)
        {
            ret = GATE_RESULT_FAILED;
            break;
        }


        if (splitter->value > length - splitter->minimum)
        {
            splitter->value = length - splitter->minimum;
        }

        if (splitter->value < splitter->minimum)
        {
            splitter->value = splitter->minimum;
        }

        if (splitter->vertical)
        {
            if (hwndFirst != NULL)
            {
                SetWindowPosIfRequired(hwndFirst, NULL, 0, 0, sz.width, splitter->value - separator, showflags);
            }
            if (hwndSecond != NULL)
            {
                SetWindowPosIfRequired(hwndSecond, NULL, 0, splitter->value + separator, sz.width, sz.height - splitter->value - separator, showflags);
            }
        }
        else
        {
            if (hwndFirst != NULL)
            {
                SetWindowPosIfRequired(hwndFirst, NULL, 0, 0, splitter->value - separator, sz.height, showflags);
            }
            if (hwndSecond != NULL)
            {
                SetWindowPosIfRequired(hwndSecond, NULL, splitter->value + separator, 0, sz.width - splitter->value - separator, sz.height, showflags);
            }
        }
    } while (0);

}

static gate_bool_t gate_ui_splitter_events(void* hwnd, gate_ui_ctrl_t* ctrl, gate_uint32_t msg, gate_uintptr_t wParam, gate_intptr_t lParam, gate_intptr_t* lresult)
{
    HWND hwnd_ctrl;
    gate_ui_splitter_t* splitter;
    POINT pnt;
    HWND hwnd_parent;
    RECT rect;
    HDC hdc;
    HBRUSH hbr_bk_gnd = NULL;
    gate_ui_host_t* host = NULL;
    static HCURSOR hcursor = NULL;
#if defined(GATE_UI_WINAPI_DARKMODE_SUPPORT)
    gate_ui_color_t col;
#endif

    if (ctrl != NULL)
    {
        hwnd_ctrl = GATE_UI_WINAPI_GET_HWND(ctrl);
        if (hwnd == hwnd_ctrl)
        {
            if (hcursor == NULL)
            {
                hcursor = LoadCursor(NULL, IDC_SIZEWE);
            }

            splitter = (gate_ui_splitter_t*)ctrl;
            switch (msg)
            {
#if !defined(GATE_SYS_WIN16)
            case WM_CTLCOLOREDIT:
            case WM_CTLCOLORBTN:
            case WM_CTLCOLORLISTBOX:
            case WM_CTLCOLORMSGBOX:
            case WM_CTLCOLORSCROLLBAR:
            case WM_CTLCOLORDLG:
            case WM_CTLCOLORSTATIC:
            {
                *lresult = SendMessage(GetParent((HWND)hwnd), msg, wParam, lParam);
                return true;
                break;
<--- Consecutive return, break, continue, goto or throw statements are unnecessary. [+]
Consecutive return, break, continue, goto or throw statements are unnecessary. The second statement can never be executed, and so should be removed.
            }
#endif /* GATE_SYS_WIN16 */
            case WM_ERASEBKGND:
            {
                hwnd_parent = GetParent(hwnd_ctrl);
                hdc = (HDC)wParam;

#if defined(GATE_UI_WINAPI_DARKMODE_SUPPORT)
                if (gate_ui_winapi_is_darkmode_applied(hwnd_ctrl))
                {
                    host = GATE_UI_WINAPI_GET_HOST(ctrl);

                    gate_ui_host_default_color(host, GATE_UI_COLOR_CONTROL, &col);
                    hbr_bk_gnd = (HBRUSH)gate_ui_winapi_host_get_brush(host, &col);
                }
                else
#endif /* GATE_UI_WINAPI_DARKMODE_SUPPORT */
                {
                    hbr_bk_gnd = (HBRUSH)gate_ui_winapi_get_syscolor_brush(
                        gate_ui_winapi_get_syscolor_index(GATE_UI_COLOR_CONTROL));
                }

                if (hbr_bk_gnd)
                {
                    GetClientRect(hwnd_ctrl, &rect);
                    FillRect(hdc, &rect, hbr_bk_gnd);
                    *lresult = 1;
                    return true;
                }
                break;
            }
            case WM_SIZE:
            {
                gate_ui_splitter_update(splitter);
                break;
            }
            case WM_SETCURSOR:
            {
                GetCursorPos(&pnt);
                if (hwnd == WindowFromPoint(pnt))
                {
                    SetCursor(hcursor);
                    *lresult = TRUE;
                    return true;
                }
                break;
            }
            case WM_LBUTTONDOWN:
            {
                splitter->drag_mode = true;
                splitter->click_point.x = GET_X_LPARAM(lParam);
                splitter->click_point.y = GET_Y_LPARAM(lParam);
                SetCapture(hwnd_ctrl);
                break;
            }
            case WM_MOUSEMOVE:
            {
                if (splitter->drag_mode)
                {
                    if ((splitter->click_point.x != GET_X_LPARAM(lParam))
                        || (splitter->click_point.y != GET_Y_LPARAM(lParam))
                        )
                    {
                        if (splitter->vertical)
                        {
                            splitter->click_point.y = GET_Y_LPARAM(lParam);
                            if (splitter->click_point.y < 0) splitter->click_point.y = 0;
                            splitter->value = splitter->click_point.y;
                        }
                        else
                        {
                            splitter->click_point.x = GET_X_LPARAM(lParam);
                            if (splitter->click_point.x < 0) splitter->click_point.x = 0;
                            splitter->value = splitter->click_point.x;
                        }
                        gate_ui_splitter_update(splitter);
                    }
                }
                break;
            }
            case WM_LBUTTONUP:
            {
                splitter->drag_mode = false;
                ReleaseCapture();
                break;
            }
            }
        }
    }
    return false;
}

gate_result_t gate_ui_splitter_create(
    gate_ui_splitter_t* splitter, gate_ui_ctrl_t* parent,
    gate_ui_position_t const* position,
    gate_bool_t vertical,
    gate_uint32_t flags,
    void* userparam
)
{
    gate_result_t ret;
    gate_uint32_t styles = 0;
    gate_uint32_t exstyles = 0;
    gate_ui_host_t* host;
<--- The scope of the variable 'host' can be reduced. [+]
The scope of the variable 'host' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.
    gate_ui_size_t clientsize;
    HWND hwnd;
    HWND hwndParent;

    do
    {
        host = gate_ui_ctrl_get_host(parent);
        if (host == NULL)
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }
        hwndParent = GATE_UI_WINAPI_GET_HWND(parent);
        if (hwndParent == NULL)
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        gate_mem_clear(splitter, sizeof(gate_ui_splitter_t));
        splitter->minimum = 32;
        splitter->vertical = vertical;
#if !defined(GATE_SYS_WINCE) && !defined(GATE_SYS_WIN16)
        exstyles = WS_EX_CONTROLPARENT;
#endif
        styles = WS_CHILD | WS_CLIPCHILDREN;

        if (!GATE_FLAG_ENABLED(flags, GATE_UI_FLAG_ENABLED)) styles |= WS_DISABLED;
        if (GATE_FLAG_ENABLED(flags, GATE_UI_FLAG_VISIBLE)) styles |= WS_VISIBLE;

        ret = gate_ui_winapi_create(&splitter->ctrl, host, hwndParent, NULL, position, styles, exstyles, NULL, userparam, false);
        if (GATE_SUCCEEDED(ret))
        {
            hwnd = GATE_UI_WINAPI_GET_HWND(&splitter->ctrl);
            gate_ui_winapi_get_size(&splitter->ctrl, &clientsize);
            splitter->value = (vertical ? clientsize.height : clientsize.width) / 2;

            gate_ui_winapi_register_event(host, hwnd, WM_SIZE, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_SETCURSOR, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_LBUTTONDOWN, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_LBUTTONUP, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_MOUSEMOVE, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_ERASEBKGND, &gate_ui_splitter_events, &splitter->ctrl);

#if !defined(GATE_SYS_WIN16)
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORDLG, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORSTATIC, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLOREDIT, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORBTN, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORLISTBOX, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORMSGBOX, &gate_ui_splitter_events, &splitter->ctrl);
            gate_ui_winapi_register_event(host, hwnd, WM_CTLCOLORSCROLLBAR, &gate_ui_splitter_events, &splitter->ctrl);
#endif

        }
    } while (0);

    return ret;
}

gate_result_t gate_ui_splitter_set(gate_ui_splitter_t* splitter, gate_uint32_t const* minimum, gate_uint32_t const* value)
{
    gate_result_t ret = GATE_RESULT_OK;
    HWND hwnd = GATE_UI_WINAPI_GET_HWND(&splitter->ctrl);

    if (minimum != NULL)
    {
        splitter->minimum = *minimum;
    }
    if (value != NULL)
    {
        splitter->value = *value;
    }

    if (hwnd != NULL)
    {
        ret = gate_ui_splitter_update(splitter);
    }
    return ret;
}

struct gate_ui_splitter_enum_child_windows
{
    HWND	parent;
    HWND	first;
    HWND	second;
};

static BOOL CALLBACK gate_ui_splitter_enum_children(HWND hwnd, LPARAM lParam)
{
    struct gate_ui_splitter_enum_child_windows* param = (struct gate_ui_splitter_enum_child_windows*)(gate_intptr_t)lParam;
    if (GetParent(hwnd) == param->parent)
    {
        if (param->first == NULL)
        {
            param->first = hwnd;
        }
        else if (param->second == NULL)
        {
            param->second = hwnd;
        }
    }
    return TRUE;
}


gate_result_t gate_ui_splitter_update(gate_ui_splitter_t* splitter)
{
    gate_result_t ret = GATE_RESULT_INVALIDARG;
    HWND hwnd = GATE_UI_WINAPI_GET_HWND(&splitter->ctrl);
    struct gate_ui_splitter_enum_child_windows children;

    if (hwnd != NULL)
    {
        children.parent = hwnd;
        children.first = NULL;
        children.second = NULL;
#if defined(GATE_SYS_WINCE)
        children.first = GetWindow(hwnd, GW_CHILD);
        ret = GATE_RESULT_FAILED;<--- Variable 'ret' is reassigned a value before the old one has been used.
        if (children.first != NULL)
        {
            children.second = GetWindow(children.first, GW_HWNDNEXT);
        }
#else
        EnumChildWindows(hwnd, &gate_ui_splitter_enum_children, (LPARAM)(gate_intptr_t)&children);
#endif
        if ((children.first != NULL) || (children.second != NULL))
        {
            gate_ui_splitter_resize(splitter, children.first, children.second);
        }
        ret = GATE_RESULT_OK;<--- Variable 'ret' is reassigned a value before the old one has been used.
    }
    return ret;
}

gate_result_t gate_ui_splitter_set_first(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    GATE_UNUSED_ARG(splitter);
    GATE_UNUSED_ARG(ctrl);
    return GATE_RESULT_OK;
}
gate_result_t gate_ui_splitter_set_second(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    GATE_UNUSED_ARG(splitter);
    GATE_UNUSED_ARG(ctrl);
    return GATE_RESULT_OK;
}



#endif	/* GATE_UI_WINAPI */


#if defined(GATE_UI_GTK)

#include "gate/ui/gateui_gtk.h"


static gboolean gate_ui_gtk_splitter_refresh_idle_callback(gpointer user_data)
{
    gate_ui_splitter_t* splitter = (gate_ui_splitter_t*)user_data;
    gate_ui_gtk_ctrl_refresh(&splitter->ctrl);
    return FALSE;	/* FALSE means: do not invoke this callback again (until next call to g_idle_add()) */
}


static gate_result_t gate_ui_gtk_splitter_refresh(gate_ui_ctrl_t* ctrl)
{
    gate_ui_splitter_t* splitter = (gate_ui_splitter_t*)ctrl;
    g_idle_add(&gate_ui_gtk_splitter_refresh_idle_callback, splitter);
    return gate_ui_gtk_ctrl_refresh(ctrl);
}

static gate_result_t gate_ui_gtk_splitter_destroy(gate_ui_ctrl_t* ctrl)
{
    return gate_ui_gtk_ctrl_destroy_native(ctrl);
}


static gate_ui_gtk_dispatcher_t gate_ui_gtk_splitter_dispatcher =
{
    NULL /*get_text_length*/,
    NULL /*get_text*/,
    NULL /*set_text*/,
    NULL /*get_state*/,
    NULL /*set_state*/,
    &gate_ui_gtk_splitter_refresh,
    &gate_ui_gtk_splitter_destroy
};


gate_result_t gate_ui_splitter_create(
    gate_ui_splitter_t* splitter, gate_ui_ctrl_t* parent,
    gate_ui_position_t const* position,
    gate_bool_t vertical,
    gate_uint32_t flags,
    void* userparam
)
{
    GtkWidget* widget;
    gate_ui_host_t* host = GATE_UI_GTK_GET_CTRL_HOST(parent);

    gate_mem_clear(splitter, sizeof(gate_ui_splitter_t));
    widget = gtk_paned_new(vertical ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL);
    if (widget == NULL)
    {
        return GATE_RESULT_FAILED;
    }

    gate_ui_gtk_ctrl_init(&splitter->ctrl, widget, host, userparam, parent,
        &gate_ui_gtk_splitter_dispatcher, false, true, position, &flags);

    return GATE_RESULT_OK;
}

gate_result_t gate_ui_splitter_set(gate_ui_splitter_t* splitter,
    gate_uint32_t const* minimum, gate_uint32_t const* value)
{
    gate_result_t ret = GATE_RESULT_OK;
    GtkWidget* container = GATE_UI_GTK_GET_CTRL_WIDGET(&splitter->ctrl);

    if (value)
    {
        gtk_paned_set_position(GTK_PANED(container), (gint)*value);
    }
    return ret;
}

gate_result_t gate_ui_splitter_update(gate_ui_splitter_t* splitter)
{
    gate_result_t ret = GATE_RESULT_OK;
    GtkWidget* container = GATE_UI_GTK_GET_CTRL_WIDGET(&splitter->ctrl);<--- Variable 'container' is assigned a value that is never used.

    return ret;
}

gate_result_t gate_ui_splitter_set_first(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    gate_result_t ret = GATE_RESULT_OK;
    GtkWidget* widget = GATE_UI_GTK_GET_CTRL_WIDGET(&splitter->ctrl);
    GtkWidget* child = GATE_UI_GTK_GET_CTRL_WIDGET(ctrl);
    GtkContainer* container = GTK_CONTAINER(widget);<--- Variable 'container' is assigned a value that is never used.

    gtk_paned_add1(GTK_PANED(widget), child);
    if (!gtk_widget_get_realized(child))
    {
        gtk_widget_realize(child);
    }

    return ret;
}
gate_result_t gate_ui_splitter_set_second(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    gate_result_t ret = GATE_RESULT_OK;
    GtkWidget* widget = GATE_UI_GTK_GET_CTRL_WIDGET(&splitter->ctrl);
    GtkWidget* child = GATE_UI_GTK_GET_CTRL_WIDGET(ctrl);
    GtkContainer* container = GTK_CONTAINER(widget);<--- Variable 'container' is assigned a value that is never used.

    gtk_paned_add2(GTK_PANED(widget), child);
    if (!gtk_widget_get_realized(child))
    {
        gtk_widget_realize(child);
    }

    return ret;
}

#endif	/* GATE_UI_GTK */



#if defined(GATE_UI_MOTIF)

#include "gate/ui/gateui_motif.h"
#include <Xm/Paned.h>

gate_result_t gate_ui_splitter_create(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* parent, gate_ui_position_t const* position,
    gate_bool_t vertical, gate_uint32_t flags, void* userparam)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    Arg args[8];
    unsigned args_count = 0;
    Widget w = NULL;

    do
    {
        if (!splitter || !parent)
        {
            ret = GATE_RESULT_INVALIDARG;
            break;
        }

        XtSetArg(args[args_count], XmNorientation, (vertical ? XmVERTICAL : XmHORIZONTAL)); ++args_count;

        ret = gate_ui_motif_ctrl_create(&splitter->ctrl, xmPanedWidgetClass, userparam, NULL, parent,
            position, &flags, false, NULL, args, args_count);
        GATE_BREAK_IF_FAILED(ret);

        splitter->vertical = vertical;
        splitter->minimum = 0;
        splitter->drag_mode = false;
        splitter->value = 0;

    } while (0);

    return ret;
}


static void apply_splitter_settings_to_children(gate_ui_splitter_t* splitter)
{
    Widget w = NULL;
    WidgetList children = NULL;
    int count = 0;
    int ndx;
<--- The scope of the variable 'ndx' can be reduced. [+]
The scope of the variable 'ndx' can be reduced. Warning: Be careful when fixing this message, especially when there are inner loops. Here is an example where cppcheck will write that the scope for 'i' can be reduced:
void f(int x)
{
    int i = 0;
    if (x) {
        // it's safe to move 'int i = 0;' here
        for (int n = 0; n < 10; ++n) {
            // it is possible but not safe to move 'int i = 0;' here
            do_something(&i);
        }
    }
}
When you see this message it is always safe to reduce the variable scope 1 level.

    w = GATE_UI_MOTIF_GET_CTRL_WIDGET(&splitter->ctrl);
    XmPanedGetPanes(w, &children, &count);
    if (count > 0)
    {
        if (splitter->value != 0)
        {
            XtVaSetValues(children[0],
                XmNpreferredPaneSize, (Cardinal)splitter->value,
                XmNresizeToPreferred, TRUE,
                NULL, NULL);
        }
        if (splitter->minimum != 0)
        {
            for (ndx = 0; ndx != count; ++ndx)
            {
                XtVaSetValues(children[ndx],
                    XmNpaneMinimum, (Cardinal)splitter->minimum,
                    NULL, NULL);
            }
        }
    }
}

gate_result_t gate_ui_splitter_set(gate_ui_splitter_t* splitter, gate_uint32_t const* minimum, gate_uint32_t const* value)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    Widget w = NULL;

    do
    {
        if (!gate_ui_ctrl_is_created(&splitter->ctrl))
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }
        w = GATE_UI_MOTIF_GET_CTRL_WIDGET(&splitter->ctrl);
        if (!w)
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        if (minimum)
        {
            splitter->minimum = *minimum;
        }
        if (value)
        {
            splitter->value = *value;
        }

        apply_splitter_settings_to_children(splitter);

        ret = GATE_RESULT_OK;
    } while (0);
    return ret;
}

gate_result_t gate_ui_splitter_update(gate_ui_splitter_t* splitter)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}

static gate_result_t gate_ui_splitter_add_child(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    Widget w = NULL;
    Widget c = NULL;
    gate_ui_host_t* ptr_host;
    XtAppContext app_context;

    do
    {
        if (!gate_ui_ctrl_is_created(&splitter->ctrl) || !gate_ui_ctrl_is_created(ctrl))
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }
        w = GATE_UI_MOTIF_GET_CTRL_WIDGET(&splitter->ctrl);
        c = GATE_UI_MOTIF_GET_CTRL_WIDGET(ctrl);
        if (!w || !c)
        {
            ret = GATE_RESULT_INVALIDSTATE;
            break;
        }

        apply_splitter_settings_to_children(splitter);

        ret = GATE_RESULT_OK;
    } while (0);
    return ret;
}

gate_result_t gate_ui_splitter_set_first(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    return gate_ui_splitter_add_child(splitter, ctrl);
}

gate_result_t gate_ui_splitter_set_second(gate_ui_splitter_t* splitter, gate_ui_ctrl_t* ctrl)
{
    return gate_ui_splitter_add_child(splitter, ctrl);
}

#endif /* GATE_UI_MOTIF */