Subversion Repositories Kolibri OS

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
1176 andrew_pro 1
/*
2
        main meneger loop libGUI library
3
*/
4
 
5
void LibGUImain(parent_t *WindowParent)
6
{
7
        DWORD                   event,key,value;
8
        header_t                *control;
9
        gui_message_t           *events_message;
10
        gui_timer_t             *seek_timer,*exchange_timer;
11
        gui_callbackevent_t     *seek_calev,*calev,*exchange_calev;
12
        int                     i;
13
        char                    quit;
14
 
15
 
16
        events_message=(struct MESSAGE*)WindowParent->message;
17
 
18
        //tell all child controls of main parent who is main parent
19
        events_message->type=MESSAGE_SET_MAIN_PARENT;
20
        events_message->arg1=(DWORD)WindowParent;
21
        SendMessage((struct HEADER *)WindowParent,events_message);
22
 
23
        //display all created controls in window
24
        gui_draw_window(WindowParent);
25
        events_message->type=MESSAGE_FULL_REDRAW_ALL;
26
        SendMessage((struct HEADER *)WindowParent,events_message);
27
 
28
        events_message->type=0;
29
 
30
        quit=FALSE;
31
        WindowParent->number_callbacks=0;
32
 
33
        while (quit==FALSE)
34
        {
35
                //check for timers
36
                if ((WindowParent->timer_bk!=(DWORD*)NULL) ||
37
                    (WindowParent->number_timers_for_controls!=0)) {event=gui_ksys_wait_event_with_timeout(1);}
38
                        else    {event=gui_ksys_wait_event();}
39
 
40
                //get and chack system events
41
                switch(event)
42
                {
43
                        case KOLIBRIOS_SYS_EVENT_BUTTON_PRESSED:
44
                        {
45
                                if (ControlCheckCallbackEvent(WindowParent,DELETE_EVENT)!=NULL)
46
                                {
47
                                                WindowParent->flags |= FLAG_CONNECT_EVENT_ON;
48
                                                WindowParent->control_for_callback_function[WindowParent->number_callbacks]=
49
                                                (DWORD*)WindowParent;
50
                                                WindowParent->callback_for_control_callback[WindowParent->number_callbacks]=
51
                                                (DWORD*)ControlCheckCallbackEvent(WindowParent,(DWORD)DELETE_EVENT);
52
                                                WindowParent->number_callbacks++;
53
                                }
54
 
55
                                quit=TRUE;
56
                                break;
57
                        }
58
 
59
                        case KOLIBRIOS_SYS_EVENT_REDRAW:
60
                        {
61
                                GetNewWindowSizePos(WindowParent);
62
                                SetWindowSizeRequest(WindowParent,WindowParent->ctrl_sizex,WindowParent->ctrl_sizey);
63
                                gui_draw_window(WindowParent);
64
 
65
                                events_message->type=MESSAGE_FULL_REDRAW_ALL;
66
                                SendMessage((struct HEADER *)WindowParent,events_message);
67
                                break;
68
                        }
69
 
70
                        case KOLIBRIOS_SYS_EVENT_KEYS:
71
                        {
72
                                key=gui_ksys_get_key();
73
 
74
 
75
                                key=key>>8;
76
 
77
                                if (key & 128)
78
                                {
79
                                        events_message->arg1=KEY_UP;
80
                                        events_message->arg2=key & 127;
81
                                }
82
                                        else
83
                                {
84
                                        events_message->arg1=KEY_DOWN;
85
                                        events_message->arg2=key;
86
                                }
87
 
88
                                events_message->type=MESSAGE_KEYS_EVENT;
89
                                SendMessage((struct HEADER *)WindowParent,events_message);
90
                                break;
91
                        }
92
 
93
                        case KOLIBRIOS_SYS_EVENT_MOUSE:
94
                        {
95
                                value=gui_ksys_get_window_mouse_coordinates();
96
 
97
                                events_message->type=MESSAGE_MOUSE_EVENT;
98
                                events_message->arg2=(value & 0xffff)-screen.y;//y
99
                                value=value >>16;
100
                                events_message->arg1=value-screen.x;//x
101
 
102
                                value=gui_ksys_get_mouse_buttons_state();
103
 
104
                                switch(value)
105
                                {
106
                                        case KOLIBRIOS_SYS_MOUSE_BUTTON_LEFT_DOWN:
107
                                        {
108
                                                events_message->arg3=MOUSE_LEFT_BUTTON_DOWN;
109
                                                break;
110
                                        }
111
                                        case KOLIBRIOS_SYS_MOUSE_BUTTON_RIGHT_DOWN:
112
                                        {
113
                                                events_message->arg3=MOUSE_RIGHT_BUTTON_DOWN;
114
                                                break;
115
                                        }
116
                                        case KOLIBRIOS_SYS_MOUSE_BUTTON_MIDDLE_DOWN:
117
                                        {
118
                                                events_message->arg3=MOUSE_MIDDLE_BUTTON_DOWN;
119
                                                break;
120
                                        }
121
                                        case KOLIBRIOS_SYS_MOUSE_BUTTON_4_DOWN:
122
                                        {
123
                                                events_message->arg3=MOUSE_4_BUTTON_DOWN;
124
                                                break;
125
                                        }
126
                                        case KOLIBRIOS_SYS_MOUSE_BUTTON_5_DOWN:
127
                                        {
128
                                                events_message->arg3=MOUSE_5_BUTTON_DOWN;
129
                                                break;
130
                                        }
131
                                        default:
132
                                        {
133
                                                if (events_message->arg3==MOUSE_LEFT_BUTTON_DOWN)
134
                                                {
135
                                                        events_message->arg3=MOUSE_LEFT_BUTTON_UP;
136
                                                        break;
137
                                                }
138
                                                if (events_message->arg3==MOUSE_RIGHT_BUTTON_DOWN)
139
                                                {
140
                                                        events_message->arg3=MOUSE_RIGHT_BUTTON_UP;
141
                                                        break;
142
                                                }
143
                                                if (events_message->arg3==MOUSE_MIDDLE_BUTTON_DOWN)
144
                                                {
145
                                                        events_message->arg3=MOUSE_MIDDLE_BUTTON_UP;
146
                                                        break;
147
                                                }
148
                                                if (events_message->arg3==MOUSE_4_BUTTON_DOWN)
149
                                                {
150
                                                        events_message->arg3=MOUSE_4_BUTTON_UP;
151
                                                        break;
152
                                                }
153
                                                if (events_message->arg3==MOUSE_5_BUTTON_DOWN)
154
                                                {
155
                                                        events_message->arg3=MOUSE_5_BUTTON_UP;
156
                                                        break;
157
                                                }
158
 
159
                                                break;
160
                                        }
161
                                }
162
                                SendMessage((struct HEADER *)WindowParent,events_message);
163
                                break;
164
                        }
165
                }
166
 
167
                //call functions for events
168
                seek_calev=(struct CALLBACKEVENT*)WindowParent->calev_bk;
169
                while(seek_calev!=(struct CALLBACKEVENT*)NULL)
170
                {
171
                        if (seek_calev->event_type==events_message->type)
172
                        {
173
                                CallbackFunctionForEvent=(void(*)(struct MESSAGE *message,void *data))seek_calev->func;
174
                                CallbackFunctionForEvent(events_message,seek_calev->func_data);
175
                        }
176
                        exchange_calev=(struct CALLBACKEVENT*)seek_calev->calev_fd;
177
                        seek_calev=exchange_calev;
178
                }
179
 
180
 
181
                //call timers of controls
182
                if (WindowParent->number_timers_for_controls!=0)
183
                {
184
                        events_message->type=(char)MESSAGE_CALL_TIMER_EVENT;
185
                        SendMessage((struct HEADER *)WindowParent,events_message);
186
                }
187
 
188
                //call callback functions
189
                for(i=0;inumber_callbacks;i++)
190
                {
191
                        control=(struct HEADER*)WindowParent->control_for_callback_function[i];
192
                        //check callback control
193
                        if (control!=(header_t*)NULL)
194
                        {
195
                                if (control->flags & FLAG_CONNECT_EVENT_ON)
196
                                {
197
                                        calev=(struct CALLBACKEVENT*)
198
                                        WindowParent->callback_for_control_callback[i];
199
#ifdef DEBUG
200
        			printf("\ntry to call callback %d for function %d data %d",
201
				(DWORD)calev,
202
				(DWORD)calev->func,
203
				(DWORD)calev->func_data);
204
#endif
205
 
206
                                        CallbackFunction=(void (*)(header_t *Control,void *data))calev->func;
207
                                        CallbackFunction(control,calev->func_data);
208
 
209
                                        control->flags=control->flags & FLAG_CONNECT_EVENT_OFF;
210
                                }
211
                        }
212
                }
213
                WindowParent->number_callbacks=0;
214
 
215
                //call timers of parent window
216
                seek_timer=(struct TIMER*)WindowParent->timer_bk;
217
                while(seek_timer!=(struct TIMER*)NULL)
218
                {
219
                        if (seek_timer->flags & FLAG_TIMER_ON)  Timer(seek_timer);
220
 
221
                        exchange_timer=(struct TIMER*)seek_timer->tmr_fd;
222
                        seek_timer=exchange_timer;
223
                }
224
 
225
                //check for IDL function and call it if enabled
226
                if (WindowParent->IDL_func!=(DWORD*)NULL)
227
                {
228
                        IDL_Function=(void(*)(void *data))WindowParent->IDL_func;
229
                        IDL_Function(WindowParent->IDL_func_data);
230
                }
231
 
232
        }
233
}