Cppcheck report - GATE C/C++ Framework: gate/platform/winrt/winrtapp.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/results.h"
#include "gate/platform/winrt/winrtapp.h"
#include "gate/blobs.h"


typedef union
{
    gate_winrt_IInspectable_vtbl    vtbl_inspectable;
    wrt_IFrameworkView_vtbl         vtbl_frameworkview;
} gate_app_frameworkview_vtbl_t;

typedef struct
{
    gate_winrt_object_base_t    obj_base;

    gate_winrt_app_t*           parent_app;
    gate_bool_t                 app_shutdown;
    wrt_ICoreApplicationView*   core_application_view;
    wrt_ICoreWindow*            core_window;

    wrt_EventRegistrationToken  event_size_changed_token;
    wrt_IEventHandler*          event_size_changed;

    wrt_EventRegistrationToken  event_visibility_changed_token;
    wrt_IEventHandler*          event_visibility_changed;

    wrt_EventRegistrationToken  event_activated_token;
    wrt_IEventHandler*          event_activated;

    wrt_EventRegistrationToken  event_closed_token;
    wrt_IEventHandler*          event_closed;

} gate_frameworkview_t;


static wrt_result WRT_ABI gate_frameworkview_Initialize(wrt_IFrameworkView* This, wrt_ICoreApplicationView* applicationView)
{
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;
    gate_winrt_release(self->core_application_view);
    self->core_application_view = applicationView;
    gate_winrt_retain(self->core_application_view);
    return 0;
}

static gate_result_t gate_frameworkview_size_changed(void* context, gate_winrt_IInspectable* sender, void* e_args, void* param)
{
    gate_frameworkview_t* view = (gate_frameworkview_t*)context;
    wrt_IWindowSizeChangedEventArgs* args = (wrt_IWindowSizeChangedEventArgs*)e_args;
    wrt_Size sz = GATE_INIT_EMPTY;
    args->lpVtbl->get_Size(args, &sz);
    if (view->parent_app->on_resize)
    {
        view->parent_app->on_resize(view->parent_app, (gate_int32_t)sz.Width, (gate_int32_t)sz.Height);
    }
    return 0;
}

static gate_result_t gate_frameworkview_visibility_changed(void* context, gate_winrt_IInspectable* sender, void* e_args, void* param)
{
    wrt_IVisibilityChangedEventArgs* args = (wrt_IVisibilityChangedEventArgs*)e_args;
    wrt_boolean visible = 0;
    args->lpVtbl->get_Visible(args, &visible);
    return 0;
}

static gate_result_t gate_frameworkview_activated(void* context, gate_winrt_IInspectable* sender, void* e_args, void* param)
{
    gate_frameworkview_t* view = (gate_frameworkview_t*)context;<--- Variable 'view' is assigned a value that is never used.
    wrt_IWindowActivatedEventArgs* args = (wrt_IWindowActivatedEventArgs*)e_args;
    wrt_CoreWindowActivationState state;
    args->lpVtbl->get_WindowActivationState(args, &state);
    /*
    if(CoreWindowActivationState_Deactivated != state)
    {
        wrt_result result = view->core_window->lpVtbl->Activate(view->core_window);
    }
    */
    return 0;
}


static gate_result_t gate_frameworkview_close(void* context, gate_winrt_IInspectable* sender, void* e_args, void* param)
{
    gate_frameworkview_t* view = (gate_frameworkview_t*)context;
    wrt_ICoreWindowEventArgs* args = (wrt_ICoreWindowEventArgs*)e_args;
    view->app_shutdown = true;
    args->lpVtbl->put_Handled(args, 1);
    return 0;
}



static wrt_result WRT_ABI gate_frameworkview_SetWindow(wrt_IFrameworkView* This, wrt_ICoreWindow* window)
{
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;
    wrt_result res;

    gate_winrt_release(self->core_window);
    self->core_window = window;
    gate_winrt_retain(self->core_window);

    if (window)
    {

        self->event_size_changed = (wrt_IEventHandler*)gate_winrt_eventhandler_create(
            &wrt_IEventHandler_SizeChanged_iid, wrt_IEventHandler_SizeChanged_classname,
            &gate_frameworkview_size_changed, This, NULL);
        res = window->lpVtbl->add_SizeChanged(window, self->event_size_changed, &self->event_size_changed_token);<--- Variable 'res' is reassigned a value before the old one has been used.


        self->event_visibility_changed = (wrt_IEventHandler*)gate_winrt_eventhandler_create(
            &wrt_IEventHandler_VisibilityChanged_iid, wrt_IEventHandler_VisibilityChanged_classname,
            &gate_frameworkview_visibility_changed, This, NULL);
        res = window->lpVtbl->add_VisibilityChanged(window, self->event_visibility_changed, &self->event_visibility_changed_token);<--- Variable 'res' is reassigned a value before the old one has been used.<--- Variable 'res' is reassigned a value before the old one has been used.


        self->event_activated = (wrt_IEventHandler*)gate_winrt_eventhandler_create(
            &wrt_IEventHandler_WindowActivatedEventArgs_iid, wrt_IEventHandler_WindowActivatedEventArgs_classname,
            &gate_frameworkview_activated, This, NULL);
        res = window->lpVtbl->add_Activated(window, self->event_activated, &self->event_activated_token);<--- Variable 'res' is reassigned a value before the old one has been used.<--- Variable 'res' is reassigned a value before the old one has been used.


        self->event_closed = (wrt_IEventHandler*)gate_winrt_eventhandler_create(
            &wrt_IEventHandler_CoreWindowEventArgs_iid, wrt_IEventHandler_CoreWindowEventArgs_classname,
            &gate_frameworkview_close, This, NULL);
        res = window->lpVtbl->add_Closed(window, self->event_closed, &self->event_closed_token);<--- Variable 'res' is reassigned a value before the old one has been used.<--- Variable 'res' is reassigned a value before the old one has been used.

        res = window->lpVtbl->Activate(window);<--- Variable 'res' is reassigned a value before the old one has been used.
    }

    if (self->parent_app->on_init)
    {
        self->parent_app->on_init(self->parent_app, self, self->core_application_view, window);
    }


    return 0;
}
static wrt_result WRT_ABI gate_frameworkview_Load(wrt_IFrameworkView* This, wrt_string entryPoint)
{
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;<--- Variable 'self' is assigned a value that is never used.
    return 0;
}
static wrt_result WRT_ABI gate_frameworkview_Run(wrt_IFrameworkView* This)
{
    wrt_result ret = 0;
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;

    wrt_ICoreDispatcher* dispatcher = NULL;
    wrt_result error_code;

    do
    {
        error_code = self->core_window->lpVtbl->get_Dispatcher(self->core_window, &dispatcher);
        if (error_code)
        {
            ret = error_code;
            break;
        }

        while (!self->app_shutdown)
        {
            if (gate_atomic_int_get(&self->parent_app->ui_thread_state) != GATE_WINRT_UI_THREAD_STATE_RUNNING)
            {
                break;
            }

            error_code = dispatcher->lpVtbl->ProcessEvents(dispatcher, CoreProcessEventsOption_ProcessOneAndAllPending);

            if (self->parent_app->on_render)
            {
                self->parent_app->on_render(self->parent_app);
            }


            /*
            CoreWindow^ wnd = CoreWindow::GetForCurrentThread();
                wnd->Dispatcher->ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);

            IUnknown* ptr = reinterpret_cast<IUnknown*>(wnd);
            IID iop_iid = { 0x45D64A29, 0xA63E, 0x4CB6, { 0xB4, 0x98, 0x57, 0x81, 0xD2, 0x98, 0xCB, 0x4F } };
            //"45D64A29-A63E-4CB6-B498-5781D298CB4F"
            ICoreWindowInteropTest* ptr_iop = NULL;
            HRESULT hr = ptr->QueryInterface(iop_iid, (void**)&ptr_iop);
            if(SUCCEEDED(hr))
            {
                HWND hwnd = NULL;
                ptr_iop->get_WindowHandle(&hwnd);
                ptr_iop->Release();
            }
            */
        }
    } while (0);

    gate_winrt_release(dispatcher);
    return ret;
}
static wrt_result WRT_ABI gate_frameworkview_Uninitialize(wrt_IFrameworkView* This)
{
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;

    if (self->core_window && self->event_size_changed)
    {
        self->core_window->lpVtbl->remove_SizeChanged(self->core_window, self->event_size_changed_token);
        gate_winrt_release(self->event_size_changed);
        self->event_size_changed = NULL;
    }

    if (self->core_window && self->event_visibility_changed)
    {
        self->core_window->lpVtbl->remove_VisibilityChanged(self->core_window, self->event_visibility_changed_token);
        gate_winrt_release(self->event_visibility_changed);
        self->event_visibility_changed = NULL;
    }

    if (self->core_window && self->event_activated)
    {
        self->core_window->lpVtbl->remove_Activated(self->core_window, self->event_activated_token);
        gate_winrt_release(self->event_activated);
        self->event_activated = NULL;
    }

    if (self->core_window && self->event_closed)
    {
        self->core_window->lpVtbl->remove_Closed(self->core_window, self->event_closed_token);
        gate_winrt_release(self->event_closed);
        self->event_closed = NULL;
    }

    gate_winrt_release(self->core_application_view);
    self->core_application_view = NULL;

    gate_winrt_release(self->core_window);
    self->core_window = NULL;
    return 0;
}

static void gate_frameworkview_destructor(gate_winrt_object_base_t* This)
{
    gate_frameworkview_t* self = (gate_frameworkview_t*)This;
    gate_frameworkview_Uninitialize((wrt_IFrameworkView*)self);
}

static gate_app_frameworkview_vtbl_t app_frameworkview_vtbl = GATE_INIT_EMPTY;

static gate_frameworkview_t* gate_frameworkview_construct(gate_winrt_app_t* parent_app)
{
    gate_frameworkview_t* ret = NULL;
    do
    {
        ret = gate_winrt_alloc(sizeof(gate_frameworkview_t));
        if (ret == NULL)
        {
            break;
        }
        gate_mem_clear(ret, sizeof(gate_frameworkview_t));
        app_frameworkview_vtbl.vtbl_frameworkview.Initialize = &gate_frameworkview_Initialize;
        app_frameworkview_vtbl.vtbl_frameworkview.SetWindow = &gate_frameworkview_SetWindow;
        app_frameworkview_vtbl.vtbl_frameworkview.Load = &gate_frameworkview_Load;
        app_frameworkview_vtbl.vtbl_frameworkview.Run = &gate_frameworkview_Run;
        app_frameworkview_vtbl.vtbl_frameworkview.Uninitialize = &gate_frameworkview_Uninitialize;

        gate_winrt_object_base_init(&ret->obj_base, &app_frameworkview_vtbl.vtbl_inspectable,
            wrt_IFrameworkView_classname, 0, &gate_frameworkview_destructor,
            (const IID*)&wrt_IFrameworkView_iid, NULL, NULL, NULL);

        ret->parent_app = parent_app;
        ret->parent_app->framework_view = ret;

    } while (0);
    return ret;
}






typedef union
{
    wrt_IFrameworkViewSource_vtbl	vtbl_frameworkviewsource;
    gate_winrt_IInspectable_vtbl	vtbl_inspectable;
} gate_app_frameworkviewsource_vtbl_t;

typedef struct
{
    gate_winrt_object_base_t	obj_base;

    gate_winrt_app_t* parent_app;

} gate_frameworkviewsource_t;

static wrt_result WRT_ABI gate_frameworkviewsource_CreateView(wrt_IFrameworkViewSource* This, wrt_IFrameworkView** viewProvider)
{
    gate_frameworkviewsource_t* self = (gate_frameworkviewsource_t*)This;
    gate_frameworkview_t* view = gate_frameworkview_construct(self->parent_app);
    if (view == NULL)
    {
        return gate_winrt_create_hresult(GATE_RESULT_OUTOFMEMORY);
    }
    else
    {
        *viewProvider = (wrt_IFrameworkView*)view;
        return gate_winrt_create_hresult(GATE_RESULT_OK);
    }
}

static gate_app_frameworkviewsource_vtbl_t app_frameworkviewsource_vtbl = GATE_INIT_EMPTY;

static gate_frameworkviewsource_t* gate_frameworkviewsource_construct(gate_winrt_app_t* parent_app)
{
    gate_frameworkviewsource_t* ret = NULL;
    do
    {
        ret = gate_winrt_alloc(sizeof(gate_frameworkviewsource_t));
        if (ret == NULL)
        {
            break;
        }
        gate_mem_clear(ret, sizeof(gate_frameworkviewsource_t));
        app_frameworkviewsource_vtbl.vtbl_frameworkviewsource.CreateView = &gate_frameworkviewsource_CreateView;
        gate_winrt_object_base_init(&ret->obj_base, &app_frameworkviewsource_vtbl.vtbl_inspectable,
            wrt_IFrameworkViewSource_classname, 0, NULL,
            (const IID*)&wrt_IFrameworkViewSource_iid, NULL, NULL, NULL);

        ret->parent_app = parent_app;
    } while (0);
    return ret;
}



gate_result_t gate_winrt_app_init(gate_winrt_app_t* wrt_app)
{
    gate_result_t ret = GATE_RESULT_OK;
    gate_mem_clear(wrt_app, sizeof(gate_winrt_app_t));
    do
    {
        if (NULL == gate_slotlist_create(&wrt_app->events, sizeof(gate_blob_t), &gate_blob_copy_constructor, &gate_blob_destructor))
        {
            ret = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        ret = gate_mutex_create(&wrt_app->mutex);
        GATE_BREAK_IF_FAILED(ret);

        ret = gate_synccondition_create(&wrt_app->signal);
        if (GATE_FAILED(ret))
        {
            gate_mutex_destroy(&wrt_app->mutex);
            break;
        }
    } while (0);

    return ret;
}

gate_result_t gate_winrt_app_uninit(gate_winrt_app_t* wrt_app)
{
    gate_result_t ret = GATE_RESULT_OK;
    do
    {
        gate_synccondition_destroy(&wrt_app->signal);
        gate_mutex_destroy(&wrt_app->mutex);

        gate_mem_clear(wrt_app, sizeof(gate_winrt_app_t));
    } while (0);
    return ret;
}

static gate_thread_native_return_type gate_winrt_ui_thread(gate_thread_native_param_type param)
{
    gate_winrt_app_t* wrt_app = (gate_winrt_app_t*)param;
    gate_thread_native_return_type ret = (gate_thread_native_return_type)GATE_RESULT_OK;
    gate_result_t result;
    gate_bool_t uninit_required = false;
    wrt_ICoreApplication* core_app = NULL;
    gate_frameworkviewsource_t* view_source = NULL;
    wrt_result res;
    do
    {
        gate_atomic_int_set(&wrt_app->ui_thread_state, GATE_WINRT_UI_THREAD_STATE_RUNNING);

        result = gate_winrt_thread_init();
        GATE_BREAK_IF_FAILED(result);
        uninit_required = true;

        result = gate_winrt_get_class_wstr(wrt_CoreApplication_classname,
            (const IID*)&wrt_ICoreApplication_iid,
            &core_app);
        GATE_BREAK_IF_FAILED(result);

        view_source = gate_frameworkviewsource_construct(wrt_app);
        if (view_source == NULL)
        {
            result = GATE_RESULT_OUTOFMEMORY;
            break;
        }

        res = core_app->lpVtbl->Run(core_app, (wrt_IFrameworkViewSource*)view_source);
        result = gate_winrt_translate_hresult(res);

    } while (0);

    gate_winrt_release(view_source);
    gate_winrt_release(core_app);

    if (uninit_required)
    {
        gate_winrt_thread_uninit();
    }

    gate_atomic_int_set(&wrt_app->ui_thread_state, GATE_WINRT_UI_THREAD_STATE_STOPPED);

    return ret;
}

gate_result_t gate_winrt_app_start(gate_winrt_app_t* wrt_app)
{
    gate_result_t ret;
    if (!gate_atomic_int_update_if(&wrt_app->ui_thread_state, GATE_WINRT_UI_THREAD_STATE_STOPPED, GATE_WINRT_UI_THREAD_STATE_STARTING))
    {
        return GATE_RESULT_INVALIDSTATE;
    }

    do
    {
        ret = gate_thread_start_native(&gate_winrt_ui_thread, wrt_app, &wrt_app->ui_thread, &wrt_app->ui_thread_id);
        GATE_BREAK_IF_FAILED(ret);
    } while (0);

    if (GATE_FAILED(ret))
    {
        gate_atomic_int_set(&wrt_app->ui_thread_state, GATE_WINRT_UI_THREAD_STATE_STOPPED);
    }

    return ret;
}

gate_bool_t gate_winrt_app_is_started(gate_winrt_app_t* wrt_app)
{
    return gate_atomic_int_get(&wrt_app->ui_thread_state) == GATE_WINRT_UI_THREAD_STATE_RUNNING;
}

gate_result_t gate_winrt_app_stop(gate_winrt_app_t* wrt_app)
{
    gate_result_t ret = GATE_RESULT_INVALIDSTATE;
    gate_result_t thread_result;
    gate_frameworkview_t* ptr_view = (gate_frameworkview_t*)wrt_app->framework_view;

    if (gate_atomic_int_update_if(&wrt_app->ui_thread_state, GATE_WINRT_UI_THREAD_STATE_RUNNING, GATE_WINRT_UI_THREAD_STATE_STOPPING))
    {
        if (ptr_view)
        {
            ptr_view->app_shutdown = true;
        }

        ret = gate_thread_join(&wrt_app->ui_thread, &thread_result);<--- Variable 'ret' is reassigned a value before the old one has been used.

        ret = GATE_RESULT_OK;<--- Variable 'ret' is reassigned a value before the old one has been used.
    }

    return ret;
}

gate_result_t gate_winrt_app_post_event(gate_winrt_app_t* wrt_app, gate_blob_t const* blob)
{
    gate_result_t ret;
    do
    {
        ret = gate_mutex_acquire(&wrt_app->mutex);
        GATE_BREAK_IF_FAILED(ret);

        gate_slotlist_add(&wrt_app->events, blob);

        gate_mutex_release(&wrt_app->mutex);
    } while (0);
    return ret;
}

gate_result_t gate_winrt_app_await_event(gate_winrt_app_t* wrt_app, gate_blob_t* blob, gate_uint32_t timeout_ms)
{
    gate_result_t ret;
    gate_blob_t const* ptr_blob;
    gate_slotlist_iterator_t iter;
    do
    {
        ret = gate_mutex_acquire(&wrt_app->mutex);
        GATE_BREAK_IF_FAILED(ret);
        do
        {
            if (gate_slotlist_length(&wrt_app->events) == 0)
            {
                ret = gate_synccondition_timed_wait(&wrt_app->signal, &wrt_app->mutex, timeout_ms);
                GATE_BREAK_IF_FAILED(ret);
            }
            if (gate_slotlist_length(&wrt_app->events) == 0)
            {
                ret = GATE_RESULT_NOTAVAILABLE;
                break;
            }

            ptr_blob = (gate_blob_t const*)gate_slotlist_first(&wrt_app->events, &iter);
            if (!ptr_blob)
            {
                ret = GATE_RESULT_NOTAVAILABLE;
                break;
            }
            if (blob)
            {
                if (!gate_blob_create_clone(blob, ptr_blob))
                {
                    ret = GATE_RESULT_OUTOFMEMORY;
                    break;
                }
                gate_slotlist_remove(&wrt_app->events, &iter);
            }

            ret = GATE_RESULT_OK;
        } while (0);

        gate_mutex_release(&wrt_app->mutex);
    } while (0);

    return ret;
}