Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	gx_window_event_process.c	Lines:	68	68	100.0 %
Date:	2026-03-06 19:21:09	Branches:	38	38	100.0 %


/***************************************************************************
 * Copyright (c) 2024 Microsoft Corporation
 * Copyright (c) 2026-present Eclipse ThreadX contributors
 *
 * This program and the accompanying materials are made available under the
 * terms of the MIT License which is available at
 * https://opensource.org/licenses/MIT.
 *
 * SPDX-License-Identifier: MIT
 **************************************************************************/


/**************************************************************************/
/**************************************************************************/
/**                                                                       */
/** GUIX Component                                                        */
/**                                                                       */
/**   Window Management (Window)                                          */
/**                                                                       */
/**************************************************************************/

#define GX_SOURCE_CODE


/* Include necessary system files.  */

#include "gx_api.h"
#include "gx_system.h"
#include "gx_widget.h"
#include "gx_window.h"
#include "gx_utility.h"


/**************************************************************************/
/*                                                                        */
/*  FUNCTION                                               RELEASE        */
/*                                                                        */
/*    _gx_window_event_process                            PORTABLE C      */
/*                                                           6.1          */
/*  AUTHOR                                                                */
/*                                                                        */
/*    Kenneth Maxwell, Microsoft Corporation                              */
/*                                                                        */
/*  DESCRIPTION                                                           */
/*                                                                        */
/*    This function processes events for the specified window.            */
/*                                                                        */
/*  INPUT                                                                 */
/*                                                                        */
/*    window                                Window's widget control block */
/*    event_ptr                             Incoming event to process     */
/*                                                                        */
/*  OUTPUT                                                                */
/*                                                                        */
/*    status                                Completion status             */
/*                                                                        */
/*  CALLS                                                                 */
/*                                                                        */
/*    _gx_widget_shift                      Shift a widget                */
/*    _gx_window_view_update_detect         Detect changes to the window  */
/*                                            viewport                    */
/*    _gx_widget_event_process              Call widget event processing  */
/*    _gx_window_cilent_scroll              Scroll window client area     */
/*    _gx_widget_front_move                 Move window to front          */
/*                                                                        */
/*  CALLED BY                                                             */
/*                                                                        */
/*    Application Code                                                    */
/*    GUIX Internal Code                                                  */
/*                                                                        */
/**************************************************************************/
UINT  _gx_window_event_process(GX_WINDOW *window, GX_EVENT *event_ptr)
{

UINT       status;
GX_WIDGET *widget;
GX_WIDGET *parent;
GX_VALUE   xShift;
GX_VALUE   yShift;

    status = GX_SUCCESS;
    widget = (GX_WIDGET *)window;

    /* Process relative to the type of event.  */
    switch (event_ptr -> gx_event_type)
    {
    case GX_EVENT_PEN_DOWN:
        /* if this window is moveable, go into move mode */
        if (window -> gx_widget_status & GX_STATUS_MOVABLE)
        {
            window -> gx_window_move_mode = GX_TRUE;
            window -> gx_window_move_start = event_ptr -> gx_event_payload.gx_event_pointdata;
            /* Return successful status.  */
            return(GX_SUCCESS);
        }
        else
        {
            status =  _gx_widget_event_process(widget, event_ptr);
        }
        break;

    case GX_EVENT_PEN_DRAG:
        if (window -> gx_window_move_mode)
        {
            xShift = (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_pointdata.gx_point_x -
                                window -> gx_window_move_start.gx_point_x);
            yShift = (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_pointdata.gx_point_y -
                                window -> gx_window_move_start.gx_point_y);

            window -> gx_window_move_start = event_ptr -> gx_event_payload.gx_event_pointdata;

            _gx_widget_shift(widget, xShift, yShift, GX_TRUE);
        }
        else
        {
            status = _gx_widget_event_process(widget, event_ptr);
        }
        return(status);

    case GX_EVENT_PEN_UP:
        if (window -> gx_window_move_mode)
        {
            window -> gx_window_move_mode = GX_FALSE;
        }
        else
        {
            status = _gx_widget_event_process(widget, event_ptr);
        }
        break;

    case GX_EVENT_FOCUS_GAINED:
        /* first do default handling */

        if (widget -> gx_widget_status & GX_STATUS_ACCEPTS_FOCUS)
        {
            _gx_widget_event_process(widget, event_ptr);

            /* If this window owns focus, try to assign focus to client child */
            if (_gx_system_focus_owner == GX_NULL ||
                _gx_system_focus_owner == widget)
            {
                _gx_widget_child_focus_assign(widget);
            }

            /* Now move window to front.  */
            if (window -> gx_widget_type != GX_TYPE_ROOT_WINDOW)
            {
                if (_gx_widget_front_move(widget, GX_NULL) != GX_NO_CHANGE)
                {
                    /* if I am a top-level window and I moved in front, then
                       the viewport lists need to be updated.
                     */
                    _gx_window_view_update_detect(window);
                }
            }
        }
        break;

    case GX_EVENT_HIDE:
        /* do the default handling */
        status = _gx_widget_event_process(widget, event_ptr);

        /* if this window is child of root, viewports must be updated */
        _gx_window_view_update_detect(window);
        break;

    case GX_EVENT_CLOSE:
        _gx_widget_detach(widget);
        return GX_EVENT_CLOSE;

    case GX_EVENT_SHOW:
        /* do the default handling */
        status = _gx_widget_event_process(widget, event_ptr);

        _gx_widget_nav_order_initialize(widget);

        /* if this window is child of root, viewports must be updated */
        _gx_window_view_update_detect(window);

        /* if this window is in front, claim focus */
        if (widget -> gx_widget_type != GX_TYPE_ROOT_WINDOW &&
            !(widget -> gx_widget_status & GX_STATUS_HAS_FOCUS))
        {
            parent = widget;
            while (parent && widget -> gx_widget_next == GX_NULL)
            {
                parent = widget -> gx_widget_parent;

                if (parent)
                {
                    if (parent -> gx_widget_type == GX_TYPE_ROOT_WINDOW)
                    {
                        _gx_system_focus_claim((GX_WIDGET *)window);
                        break;
                    }
                    widget = parent;
                    parent = widget -> gx_widget_parent;
                }
            }
        }

        break;

    case GX_EVENT_VERTICAL_SCROLL:
        _gx_window_scroll(window, 0, (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_intdata[1] - event_ptr -> gx_event_payload.gx_event_intdata[0]));
        break;

    case GX_EVENT_HORIZONTAL_SCROLL:
        _gx_window_scroll(window, (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_intdata[1] - event_ptr -> gx_event_payload.gx_event_intdata[0]), 0);
        break;

    default:

        /* Call the widget default processing.  */
        status =  _gx_widget_event_process(widget, event_ptr);
    }
    /* Return widget event processing status.  */
    return(status);
}



Generated by: GCOVR (Version 4.1)

Line	Branch	Exec	Source
1			/***************************************************************************
2			* Copyright (c) 2024 Microsoft Corporation
3			* Copyright (c) 2026-present Eclipse ThreadX contributors
4			*
5			* This program and the accompanying materials are made available under the
6			* terms of the MIT License which is available at
7			* https://opensource.org/licenses/MIT.
8			*
9			* SPDX-License-Identifier: MIT
10			**************************************************************************/
11
12
13			/**************************************************************************/
14			/**************************************************************************/
15			/** */
16			/** GUIX Component */
17			/** */
18			/** Window Management (Window) */
19			/** */
20			/**************************************************************************/
21
22			#define GX_SOURCE_CODE
23
24
25			/* Include necessary system files. */
26
27			#include "gx_api.h"
28			#include "gx_system.h"
29			#include "gx_widget.h"
30			#include "gx_window.h"
31			#include "gx_utility.h"
32
33
34			/**************************************************************************/
35			/* */
36			/* FUNCTION RELEASE */
37			/* */
38			/* _gx_window_event_process PORTABLE C */
39			/* 6.1 */
40			/* AUTHOR */
41			/* */
42			/* Kenneth Maxwell, Microsoft Corporation */
43			/* */
44			/* DESCRIPTION */
45			/* */
46			/* This function processes events for the specified window. */
47			/* */
48			/* INPUT */
49			/* */
50			/* window Window's widget control block */
51			/* event_ptr Incoming event to process */
52			/* */
53			/* OUTPUT */
54			/* */
55			/* status Completion status */
56			/* */
57			/* CALLS */
58			/* */
59			/* _gx_widget_shift Shift a widget */
60			/* _gx_window_view_update_detect Detect changes to the window */
61			/* viewport */
62			/* _gx_widget_event_process Call widget event processing */
63			/* _gx_window_cilent_scroll Scroll window client area */
64			/* _gx_widget_front_move Move window to front */
65			/* */
66			/* CALLED BY */
67			/* */
68			/* Application Code */
69			/* GUIX Internal Code */
70			/* */
71			/**************************************************************************/
72		53014	UINT _gx_window_event_process(GX_WINDOW window, GX_EVENT event_ptr)
73			{
74
75			UINT status;
76			GX_WIDGET *widget;
77			GX_WIDGET *parent;
78			GX_VALUE xShift;
79			GX_VALUE yShift;
80
81		53014	status = GX_SUCCESS;
82		53014	widget = (GX_WIDGET *)window;
83
84			/* Process relative to the type of event. */
85	✓✓✓✓ ✓✓✓✓ ✓✓	53014	switch (event_ptr -> gx_event_type)
86			{
87		9839	case GX_EVENT_PEN_DOWN:
88			/* if this window is moveable, go into move mode */
89	✓✓	9839	if (window -> gx_widget_status & GX_STATUS_MOVABLE)
90			{
91		2001	window -> gx_window_move_mode = GX_TRUE;
92		2001	window -> gx_window_move_start = event_ptr -> gx_event_payload.gx_event_pointdata;
93			/* Return successful status. */
94		2001	return(GX_SUCCESS);
95			}
96			else
97			{
98		7838	status = _gx_widget_event_process(widget, event_ptr);
99			}
100		7838	break;
101
102		2378	case GX_EVENT_PEN_DRAG:
103	✓✓	2378	if (window -> gx_window_move_mode)
104			{
105		2000	xShift = (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_pointdata.gx_point_x -
106		2000	window -> gx_window_move_start.gx_point_x);
107		2000	yShift = (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_pointdata.gx_point_y -
108		2000	window -> gx_window_move_start.gx_point_y);
109
110		2000	window -> gx_window_move_start = event_ptr -> gx_event_payload.gx_event_pointdata;
111
112		2000	_gx_widget_shift(widget, xShift, yShift, GX_TRUE);
113			}
114			else
115			{
116		378	status = _gx_widget_event_process(widget, event_ptr);
117			}
118		2378	return(status);
119
120		6374	case GX_EVENT_PEN_UP:
121	✓✓	6374	if (window -> gx_window_move_mode)
122			{
123		2000	window -> gx_window_move_mode = GX_FALSE;
124			}
125			else
126			{
127		4374	status = _gx_widget_event_process(widget, event_ptr);
128			}
129		6374	break;
130
131		5429	case GX_EVENT_FOCUS_GAINED:
132			/* first do default handling */
133
134	✓✓	5429	if (widget -> gx_widget_status & GX_STATUS_ACCEPTS_FOCUS)
135			{
136		5427	_gx_widget_event_process(widget, event_ptr);
137
138			/* If this window owns focus, try to assign focus to client child */
139	✓✓	5427	if (_gx_system_focus_owner == GX_NULL \|\|
140	✓✓	5426	_gx_system_focus_owner == widget)
141			{
142		4179	_gx_widget_child_focus_assign(widget);
143			}
144
145			/* Now move window to front. */
146	✓✓	5427	if (window -> gx_widget_type != GX_TYPE_ROOT_WINDOW)
147			{
148	✓✓	4437	if (_gx_widget_front_move(widget, GX_NULL) != GX_NO_CHANGE)
149			{
150			/* if I am a top-level window and I moved in front, then
151			the viewport lists need to be updated.
152			*/
153		865	_gx_window_view_update_detect(window);
154			}
155			}
156			}
157		5429	break;
158
159		1906	case GX_EVENT_HIDE:
160			/* do the default handling */
161		1906	status = _gx_widget_event_process(widget, event_ptr);
162
163			/* if this window is child of root, viewports must be updated */
164		1906	_gx_window_view_update_detect(window);
165		1906	break;
166
167		2	case GX_EVENT_CLOSE:
168		2	_gx_widget_detach(widget);
169		2	return GX_EVENT_CLOSE;
170
171		5294	case GX_EVENT_SHOW:
172			/* do the default handling */
173		5294	status = _gx_widget_event_process(widget, event_ptr);
174
175		5294	_gx_widget_nav_order_initialize(widget);
176
177			/* if this window is child of root, viewports must be updated */
178		5294	_gx_window_view_update_detect(window);
179
180			/* if this window is in front, claim focus */
181	✓✓	5294	if (widget -> gx_widget_type != GX_TYPE_ROOT_WINDOW &&
182	✓✓	4446	!(widget -> gx_widget_status & GX_STATUS_HAS_FOCUS))
183			{
184		4286	parent = widget;
185	✓✓✓✓	9287	while (parent && widget -> gx_widget_next == GX_NULL)
186			{
187		2358	parent = widget -> gx_widget_parent;
188
189	✓✓	2358	if (parent)
190			{
191	✓✓	2355	if (parent -> gx_widget_type == GX_TYPE_ROOT_WINDOW)
192			{
193		1643	_gx_system_focus_claim((GX_WIDGET *)window);
194		1643	break;
195			}
196		712	widget = parent;
197		712	parent = widget -> gx_widget_parent;
198			}
199			}
200			}
201
202		5294	break;
203
204		132	case GX_EVENT_VERTICAL_SCROLL:
205		132	_gx_window_scroll(window, 0, (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_intdata[1] - event_ptr -> gx_event_payload.gx_event_intdata[0]));
206		132	break;
207
208		1418	case GX_EVENT_HORIZONTAL_SCROLL:
209		1418	_gx_window_scroll(window, (GX_VALUE)(event_ptr -> gx_event_payload.gx_event_intdata[1] - event_ptr -> gx_event_payload.gx_event_intdata[0]), 0);
210		1418	break;
211
212		20242	default:
213
214			/* Call the widget default processing. */
215		20242	status = _gx_widget_event_process(widget, event_ptr);
216			}
217			/* Return widget event processing status. */
218		48633	return(status);
219			}
220