Cppcheck - HTML report - GATE C/C++ Framework

/* 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/timers.h"
#include "gate/results.h"

#if defined(GATE_UI_WINAPI)

#include "gate/platforms.h"
#include "gate/ui/gateui_winapi.h"


static gate_bool_t gate_ui_timer_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 hwndCtrl;
    gate_ui_timer_t* timer;<--- The scope of the variable 'timer' can be reduced. [+]The scope of the variable 'timer' 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.

    if (ctrl != NULL)
    {
        hwndCtrl = GATE_UI_WINAPI_GET_HWND(ctrl);
        if (hwnd == hwndCtrl)
        {
            timer = (gate_ui_timer_t*)ctrl;
            switch (msg)
            {
            case WM_TIMER:
            {
                if (timer->on_interval != NULL)
                {
                    timer->on_interval(ctrl);
                }
                *lresult = 0;
                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.
            }
            }
        }
    }
    return false;
}


gate_result_t gate_ui_timer_create(gate_ui_timer_t* timer, gate_ui_host_t* host, void* userparam)
{
    gate_result_t ret;
    gate_uint32_t styles, exstyles;
    gate_ui_position_t position;

    position.pos.x = 0;
    position.pos.y = 0;
    position.size.width = 1;
    position.size.height = 1;

    gate_mem_clear(timer, sizeof(gate_ui_timer_t));

    exstyles = 0;
    styles = WS_DISABLED;
    /*styles |= WS_GROUP | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;*/

#if !defined(GATE_SYS_WINCE)
    /*styles |= (WS_OVERLAPPED | WS_CAPTION);*/
#endif

    ret = gate_ui_winapi_create(&timer->ctrl, host, NULL, NULL, &position, styles, exstyles, NULL, userparam, false);
    if (GATE_SUCCEEDED(ret))
    {
        gate_ui_winapi_register_event(host, GATE_UI_WINAPI_GET_HWND(&timer->ctrl), WM_TIMER, &gate_ui_timer_events, &timer->ctrl);
    }
    return ret;
}

#ifndef USER_TIMER_MINIMUM
#define USER_TIMER_MINIMUM 0x0a
#endif
#ifndef USER_TIMER_MAXIMUM
#define USER_TIMER_MAXIMUM 0x7FFFFFFF
#endif

gate_result_t gate_ui_timer_start(gate_ui_timer_t* timer, gate_uint32_t interval)
{
    HWND hwnd = GATE_UI_WINAPI_GET_HWND(&timer->ctrl);
    if (interval < USER_TIMER_MINIMUM) interval = USER_TIMER_MINIMUM;
    if (interval > USER_TIMER_MAXIMUM) interval = USER_TIMER_MAXIMUM;
    EnableWindow(hwnd, TRUE);
    if (0 != SetTimer(hwnd, 1, interval, NULL))
    {
        return GATE_RESULT_OK;
    }
    else
    {
        EnableWindow(hwnd, FALSE);
        return GATE_RESULT_FAILED;
    }
}

gate_bool_t gate_ui_timer_is_started(gate_ui_timer_t* timer)
{
    HWND hwnd = GATE_UI_WINAPI_GET_HWND(&timer->ctrl);
    return IsWindowEnabled(hwnd) == FALSE ? false : true;
}


gate_result_t gate_ui_timer_stop(gate_ui_timer_t* timer)
{
    HWND hwnd = GATE_UI_WINAPI_GET_HWND(&timer->ctrl);
    if (KillTimer(hwnd, 1))
    {
        EnableWindow(hwnd, FALSE);
        return GATE_RESULT_OK;
    }
    else
    {
        return GATE_RESULT_FAILED;
    }
}

#endif /* GATE_UI_WINAPI */


#if defined(GATE_UI_GTK)

#include "gate/ui/gateui_gtk.h"

typedef struct gate_ui_gtk_timer_param
{
    gate_ui_timer_t* timer;
    gate_bool_t started;
} gate_ui_gtk_timer_param_t;

static gboolean gate_ui_gtk_timer_callback(gpointer user_data)
{
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)user_data;
    if (!param)
    {
        return FALSE;
    }
    if (param->started)
    {
        if (NULL != param->timer)
        {
            if (NULL != param->timer->on_interval)
            {
                param->timer->on_interval(&param->timer->ctrl);
            }
        }
    }

    if (!param->started)
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

static gate_uint32_t gate_ui_gtk_timer_get_text_length(gate_ui_ctrl_t* ctrl)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t gate_ui_gtk_timer_get_text(gate_ui_ctrl_t* ctrl, gate_string_t* text)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t gate_ui_gtk_timer_set_text(gate_ui_ctrl_t* ctrl, gate_string_t const* text)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t gate_ui_gtk_timer_get_state(gate_ui_ctrl_t* ctrl, gate_int32_t* value)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)GATE_UI_GTK_GET_CTRL_PRIVATE_ARG(ctrl);
    if (param == NULL)
    {
        ret = GATE_RESULT_INVALIDSTATE;
    }
    else
    {
        if (value)
        {
            *value = param->started ? 1 : 0;
        }
        ret = GATE_RESULT_OK;
    }
    return ret;
}
static gate_result_t gate_ui_gtk_timer_set_state(gate_ui_ctrl_t* ctrl, gate_int32_t value)
{
    return GATE_RESULT_NOTIMPLEMENTED;
}
static gate_result_t gate_ui_gtk_timer_refresh(gate_ui_ctrl_t* ctrl)
{
    return GATE_RESULT_OK;
}
static gate_result_t gate_ui_gtk_timer_destroy(gate_ui_ctrl_t* ctrl)
{
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)GATE_UI_GTK_GET_CTRL_PRIVATE_ARG(ctrl);
    if (param)
    {
        gate_mem_dealloc(param);
        GATE_UI_GTK_SET_CTRL_PRIVATE_ARG(ctrl, NULL);
    }
    return GATE_RESULT_OK;
}

static gate_ui_gtk_dispatcher_t gate_ui_gtk_timer_dispatcher =
{
    &gate_ui_gtk_timer_get_text_length,
    &gate_ui_gtk_timer_get_text,
    &gate_ui_gtk_timer_set_text,
    &gate_ui_gtk_timer_get_state,
    &gate_ui_gtk_timer_set_state,
    &gate_ui_gtk_timer_refresh,
    &gate_ui_gtk_timer_destroy
};


gate_result_t gate_ui_timer_create(
    gate_ui_timer_t* timer, gate_ui_host_t* host,
    void* userparam
)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)gate_mem_alloc(sizeof(gate_ui_gtk_timer_param_t));

    do
    {
        if (param == NULL)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        param->timer = timer;
        param->started = false;

        gate_mem_clear(timer, sizeof(gate_ui_timer_t));

        GATE_UI_GTK_SET_CTRL_WIDGET_DIRECT(&timer->ctrl, GATE_UI_GTK_NO_WIDGET);
        GATE_UI_GTK_SET_CTRL_HOST(&timer->ctrl, host);
        GATE_UI_GTK_SET_CTRL_DISP(&timer->ctrl, &gate_ui_gtk_timer_dispatcher);
        GATE_UI_GTK_SET_CTRL_USER_PARAM(&timer->ctrl, userparam);
        GATE_UI_GTK_SET_CTRL_CONTAINER(&timer->ctrl, NULL);
        GATE_UI_GTK_SET_CTRL_PARENT(&timer->ctrl, NULL);
        GATE_UI_GTK_SET_CTRL_PRIVATE_ARG(&timer->ctrl, param);
        ret = GATE_RESULT_OK;

    } while (0);

    return ret;
}

gate_result_t gate_ui_timer_start(gate_ui_timer_t* timer, gate_uint32_t interval)
{
    gate_result_t ret;
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)GATE_UI_GTK_GET_CTRL_PRIVATE_ARG(&timer->ctrl);
    if (param == NULL)
    {
        ret = GATE_RESULT_INVALIDSTATE;
    }
    else
    {
        param->started = true;
        g_timeout_add(interval, &gate_ui_gtk_timer_callback, param);
        ret = GATE_RESULT_OK;
    }
    return ret;
}

gate_result_t gate_ui_timer_stop(gate_ui_timer_t* timer)
{
    gate_result_t ret;
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)GATE_UI_GTK_GET_CTRL_PRIVATE_ARG(&timer->ctrl);
    if (param == NULL)
    {
        ret = GATE_RESULT_INVALIDSTATE;
    }
    else
    {
        param->started = false;
        GATE_UI_GTK_SET_CTRL_PRIVATE_ARG(&timer->ctrl, NULL);
        ret = GATE_RESULT_OK;
    }
    return ret;
}

gate_bool_t gate_ui_timer_is_started(gate_ui_timer_t* timer)
{
    gate_ui_gtk_timer_param_t* param = (gate_ui_gtk_timer_param_t*)GATE_UI_GTK_GET_CTRL_PRIVATE_ARG(&timer->ctrl);
    if (param == NULL)
    {
        return false;
    }
    else
    {
        return param->started;
    }
}

#endif /* GATE_UI_GTK */



#if defined(GATE_UI_MOTIF)

#include "gate/ui/gateui_motif.h"

gate_result_t gate_ui_timer_create(gate_ui_timer_t* timer, gate_ui_host_t* host, void* userparam)
{
    Widget w = (Widget)(gate_intptr_t)-1;
    GATE_UI_MOTIF_SET_CTRL_HOST(&timer->ctrl, host);
    GATE_UI_MOTIF_SET_CTRL_WIDGET(&timer->ctrl, w);
    GATE_UI_MOTIF_SET_CTRL_CONTAINER(&timer->ctrl, NULL);
    GATE_UI_MOTIF_SET_CTRL_USER_PARAM(&timer->ctrl, userparam);
    GATE_UI_MOTIF_SET_CTRL_PARENT(&timer->ctrl, NULL);
    GATE_UI_MOTIF_SET_CTRL_DISP(&timer->ctrl, NULL);
    GATE_UI_MOTIF_SET_CTRL_PRIVATE_ARG(&timer->ctrl, NULL);
    return GATE_RESULT_OK;
}

typedef struct gate_ui_motif_timer_info_class
{
    gate_ui_timer_t* ctrl;
    XtIntervalId		id;
    gate_uint32_t		interval;
} gate_ui_motif_timer_info_t;

static void gate_ui_timer_callback(XtPointer client_arg, XtIntervalId* id)
{
    gate_ui_motif_timer_info_t* ptr_timerinfo = (gate_ui_motif_timer_info_t*)client_arg;
    gate_ui_timer_t* ptr_timer = NULL;
    unsigned long next_interval = 0;
    XtIntervalId next_id;
    gate_ui_host_t* ptr_host;
    XtAppContext app_context;

    if (!ptr_timerinfo)
    {
        return;
    }

    ptr_timer = ptr_timerinfo->ctrl;
    next_interval = (unsigned long)ptr_timerinfo->interval;

    if (!ptr_timer)
    {
        gate_mem_dealloc(ptr_timerinfo);
        return;
    }

    ptr_host = GATE_UI_MOTIF_GET_CTRL_HOST(&ptr_timer->ctrl);
    if (!ptr_host)
    {
        gate_mem_dealloc(ptr_timerinfo);
        return;
    }
    app_context = (XtAppContext)GATE_UI_MOTIF_GET_HOST_APPHANDLE(ptr_host);
    ptr_timer->on_interval(&ptr_timer->ctrl);
    next_id = XtAppAddTimeOut(app_context, next_interval, &gate_ui_timer_callback, (XtPointer)ptr_timerinfo);
    ptr_timerinfo->id = next_id;
}

gate_result_t gate_ui_timer_start(gate_ui_timer_t* timer, gate_uint32_t interval)
{
    gate_result_t ret = GATE_RESULT_FAILED;
    gate_ui_host_t* ptr_host;<--- The scope of the variable 'ptr_host' can be reduced. [+]The scope of the variable 'ptr_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.
    XtAppContext app_context;
    XtIntervalId id;
    gate_ui_motif_timer_info_t* ptr_timerinfo = NULL;

    do
    {
        ptr_host = GATE_UI_MOTIF_GET_CTRL_HOST(&timer->ctrl);
        app_context = (XtAppContext)GATE_UI_MOTIF_GET_HOST_APPHANDLE(ptr_host);
        ptr_timerinfo = gate_mem_alloc(sizeof(gate_ui_motif_timer_info_t));
        if (NULL == ptr_timerinfo)
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }
        ptr_timerinfo->ctrl = timer;
        ptr_timerinfo->interval = interval;
        id = XtAppAddTimeOut(app_context, interval, &gate_ui_timer_callback, (XtPointer)ptr_timerinfo);
        ptr_timerinfo->id = id;
        GATE_UI_MOTIF_SET_CTRL_PRIVATE_ARG(&timer->ctrl, ptr_timerinfo);
        ret = GATE_RESULT_OK;
    } while (0);

    return ret;
}

gate_result_t gate_ui_timer_stop(gate_ui_timer_t* timer)
{
    gate_ui_motif_timer_info_t* ptr_timerinfo = (gate_ui_motif_timer_info_t*)GATE_UI_MOTIF_GET_CTRL_PRIVATE_ARG(&timer->ctrl);
    XtIntervalId id = (XtIntervalId)(void*)GATE_UI_MOTIF_GET_CTRL_WIDGET(&timer->ctrl);
    if (ptr_timerinfo)
    {
        GATE_UI_MOTIF_SET_CTRL_PRIVATE_ARG(&timer->ctrl, NULL);
        XtRemoveTimeOut(ptr_timerinfo->id);
        gate_mem_dealloc(ptr_timerinfo);
        return GATE_RESULT_OK;
    }
    return GATE_RESULT_INVALIDSTATE;
}

gate_bool_t gate_ui_timer_is_started(gate_ui_timer_t* timer)
{
    gate_ui_motif_timer_info_t* ptr_timerinfo = (gate_ui_motif_timer_info_t*)GATE_UI_MOTIF_GET_CTRL_PRIVATE_ARG(&timer->ctrl);
    if (ptr_timerinfo)
    {
        return true;
    }
    return false;
}

#endif /* GATE_UI_MOTIF */
Cppcheck report - GATE C/C++ Framework: gate/ui/timers.c
