Commit | Line | Data |
---|---|---|
32b8ec41 | 1 | ///////////////////////////////////////////////////////////////////////////// |
a4bbc9f7 VS |
2 | // Name: src/mgl/window.cpp |
3 | // Purpose: wxWindow | |
4 | // Author: Vaclav Slavik | |
5 | // (based on GTK & MSW implementations) | |
6 | // RCS-ID: $Id$ | |
eea93267 | 7 | // Copyright: (c) 2001-2002 SciTech Software, Inc. (www.scitechsoft.com) |
65571936 | 8 | // Licence: wxWindows licence |
32b8ec41 VZ |
9 | ///////////////////////////////////////////////////////////////////////////// |
10 | ||
a4bbc9f7 VS |
11 | // =========================================================================== |
12 | // declarations | |
13 | // =========================================================================== | |
14 | ||
15 | // --------------------------------------------------------------------------- | |
16 | // headers | |
17 | // --------------------------------------------------------------------------- | |
32b8ec41 | 18 | |
a4bbc9f7 VS |
19 | // For compilers that support precompilation, includes "wx.h". |
20 | #include "wx/wxprec.h" | |
21 | ||
22 | #ifdef __BORLANDC__ | |
23 | #pragma hdrstop | |
24 | #endif | |
25 | ||
88a7a4e1 WS |
26 | #include "wx/window.h" |
27 | ||
a4bbc9f7 | 28 | #ifndef WX_PRECOMP |
d53fc7c9 | 29 | #include "wx/msgdlg.h" |
a4bbc9f7 | 30 | #include "wx/accel.h" |
a4bbc9f7 VS |
31 | #include "wx/dc.h" |
32 | #include "wx/dcclient.h" | |
33 | #include "wx/utils.h" | |
34 | #include "wx/app.h" | |
35 | #include "wx/panel.h" | |
88a7a4e1 | 36 | #include "wx/intl.h" |
e4db172a | 37 | #include "wx/log.h" |
11dbb4bf | 38 | #include "wx/dcscreen.h" |
3b3dc801 | 39 | #include "wx/menu.h" |
a4bbc9f7 VS |
40 | #endif |
41 | ||
42 | #if wxUSE_DRAG_AND_DROP | |
43 | #include "wx/dnd.h" | |
44 | #endif | |
45 | ||
a4bbc9f7 VS |
46 | #include "wx/sysopt.h" |
47 | #include "wx/mgl/private.h" | |
90eb13e6 | 48 | #include "wx/caret.h" |
a4bbc9f7 VS |
49 | |
50 | #include <mgraph.hpp> | |
51 | ||
52 | #if wxUSE_TOOLTIPS | |
53 | #include "wx/tooltip.h" | |
54 | #endif | |
55 | ||
56 | // --------------------------------------------------------------------------- | |
57 | // global variables | |
58 | // --------------------------------------------------------------------------- | |
59 | ||
60 | // MGL window manager and associated DC. | |
61 | winmng_t *g_winMng = NULL; | |
62 | MGLDevCtx *g_displayDC = NULL; | |
63 | ||
7de59551 | 64 | // the window that has keyboard focus: |
7cdbf02c | 65 | static wxWindowMGL *gs_focusedWindow = NULL; |
7de59551 | 66 | // the window that is about to be focused after currently focused |
eea93267 VS |
67 | // one looses focus: |
68 | static wxWindow *gs_toBeFocusedWindow = NULL; | |
7bdc1879 | 69 | // the window that is currently under mouse cursor: |
7cdbf02c VS |
70 | static wxWindowMGL *gs_windowUnderMouse = NULL; |
71 | // the window that has mouse capture | |
72 | static wxWindowMGL *gs_mouseCapture = NULL; | |
73 | // the frame that is currently active (i.e. its child has focus). It is | |
74 | // used to generate wxActivateEvents | |
75 | static wxWindowMGL *gs_activeFrame = NULL; | |
06414d99 MW |
76 | // track the mouse button state for wxGetMouseState() |
77 | unsigned long g_buttonState = 0; | |
a4bbc9f7 VS |
78 | |
79 | // --------------------------------------------------------------------------- | |
80 | // constants | |
81 | // --------------------------------------------------------------------------- | |
82 | ||
7de59551 | 83 | // Custom identifiers used to distinguish between various event handlers |
a4bbc9f7 VS |
84 | // and capture handlers passed to MGL_wm |
85 | enum | |
86 | { | |
87 | wxMGL_CAPTURE_MOUSE = 1, | |
88 | wxMGL_CAPTURE_KEYB = 2 | |
89 | }; | |
90 | ||
91 | ||
92 | // --------------------------------------------------------------------------- | |
93 | // private functions | |
94 | // --------------------------------------------------------------------------- | |
95 | ||
7cdbf02c VS |
96 | // Returns toplevel grandparent of given window: |
97 | static wxWindowMGL* wxGetTopLevelParent(wxWindowMGL *win) | |
98 | { | |
99 | wxWindowMGL *p = win; | |
100 | while (p && !p->IsTopLevel()) | |
101 | p = p->GetParent(); | |
102 | return p; | |
103 | } | |
104 | ||
d53fc7c9 | 105 | // An easy way to capture screenshots: |
2d1efe3f | 106 | static void wxCaptureScreenshot(bool activeWindowOnly) |
e6daf008 | 107 | { |
d53fc7c9 | 108 | #ifdef __DOS__ |
9a83f860 | 109 | #define SCREENSHOT_FILENAME wxT("sshot%03i.png") |
d53fc7c9 | 110 | #else |
9a83f860 | 111 | #define SCREENSHOT_FILENAME wxT("screenshot-%03i.png") |
d53fc7c9 | 112 | #endif |
e6daf008 | 113 | static int screenshot_num = 0; |
d53fc7c9 | 114 | wxString screenshot; |
7de59551 RD |
115 | |
116 | do | |
d53fc7c9 VS |
117 | { |
118 | screenshot.Printf(SCREENSHOT_FILENAME, screenshot_num++); | |
119 | } while ( wxFileExists(screenshot) && screenshot_num < 1000 ); | |
7de59551 | 120 | |
2d1efe3f VS |
121 | wxRect r(0, 0, g_displayDC->sizex(), g_displayDC->sizey()); |
122 | ||
123 | if ( activeWindowOnly && gs_activeFrame ) | |
124 | { | |
125 | r.Intersect(gs_activeFrame->GetRect()); | |
126 | } | |
7de59551 RD |
127 | |
128 | g_displayDC->savePNGFromDC(screenshot.mb_str(), | |
06534aa1 | 129 | r.x, r. y, r.x+r.width, r.y+r.height); |
7de59551 | 130 | |
9a83f860 | 131 | wxMessageBox(wxString::Format(wxT("Screenshot captured: %s"), |
2b5f62a0 | 132 | screenshot.c_str())); |
e6daf008 | 133 | } |
e6daf008 | 134 | |
7bdc1879 VS |
135 | // --------------------------------------------------------------------------- |
136 | // MGL_WM hooks: | |
137 | // --------------------------------------------------------------------------- | |
138 | ||
b43a9886 | 139 | static void MGLAPI wxWindowPainter(window_t *wnd, MGLDC *dc) |
7bdc1879 VS |
140 | { |
141 | wxWindowMGL *w = (wxWindow*) wnd->userData; | |
7de59551 | 142 | |
544c782d | 143 | if ( w && !(w->GetWindowStyle() & wxTRANSPARENT_WINDOW) ) |
7bdc1879 VS |
144 | { |
145 | MGLDevCtx ctx(dc); | |
146 | w->HandlePaint(&ctx); | |
147 | } | |
ef344ff8 VS |
148 | } |
149 | ||
b43a9886 | 150 | static ibool MGLAPI wxWindowMouseHandler(window_t *wnd, event_t *e) |
ef344ff8 VS |
151 | { |
152 | wxWindowMGL *win = (wxWindowMGL*)MGL_wmGetWindowUserData(wnd); | |
d76048f5 | 153 | wxPoint orig(win->GetClientAreaOrigin()); |
985520bc | 154 | wxPoint where; |
7de59551 | 155 | |
06414d99 MW |
156 | g_buttonState = e->modifiers; |
157 | ||
7de59551 | 158 | MGL_wmCoordGlobalToLocal(win->GetHandle(), |
985520bc VS |
159 | e->where_x, e->where_y, &where.x, &where.y); |
160 | ||
0a89ac9c VS |
161 | for (wxWindowMGL *w = win; w; w = w->GetParent()) |
162 | { | |
7de59551 | 163 | if ( !w->IsEnabled() ) |
0a89ac9c VS |
164 | return FALSE; |
165 | if ( w->IsTopLevel() ) | |
166 | break; | |
167 | } | |
7de59551 | 168 | |
ef344ff8 VS |
169 | wxEventType type = wxEVT_NULL; |
170 | wxMouseEvent event; | |
171 | event.SetEventObject(win); | |
172 | event.SetTimestamp(e->when); | |
d76048f5 VS |
173 | event.m_x = where.x - orig.x; |
174 | event.m_y = where.y - orig.y; | |
318ac890 MW |
175 | event.m_shiftDown = ( e->modifiers & EVT_SHIFTKEY ) != 0; |
176 | event.m_controlDown = ( e->modifiers & EVT_CTRLSTATE ) != 0; | |
177 | event.m_altDown = ( e->modifiers & EVT_LEFTALT ) != 0; | |
178 | event.m_metaDown = ( e->modifiers & EVT_RIGHTALT ) != 0; | |
179 | event.m_leftDown = ( e->modifiers & EVT_LEFTBUT ) != 0; | |
180 | event.m_middleDown = ( e->modifiers & EVT_MIDDLEBUT ) != 0; | |
181 | event.m_rightDown = ( e->modifiers & EVT_RIGHTBUT ) != 0; | |
7de59551 | 182 | |
ef344ff8 VS |
183 | switch (e->what) |
184 | { | |
185 | case EVT_MOUSEDOWN: | |
8f5e92db | 186 | // Change focus if the user clicks outside focused window: |
ad02525d | 187 | if ( win->CanAcceptFocus() && wxWindow::FindFocus() != win ) |
8f5e92db VS |
188 | win->SetFocus(); |
189 | ||
8f5e92db VS |
190 | if ( e->message & EVT_DBLCLICK ) |
191 | { | |
8f5e92db VS |
192 | if ( e->message & EVT_LEFTBMASK ) |
193 | type = wxEVT_LEFT_DCLICK; | |
194 | else if ( e->message & EVT_MIDDLEBMASK ) | |
195 | type = wxEVT_MIDDLE_DCLICK; | |
196 | else if ( e->message & EVT_RIGHTBMASK ) | |
197 | type = wxEVT_RIGHT_DCLICK; | |
198 | } | |
ea98f686 VS |
199 | else |
200 | { | |
201 | if ( e->message & EVT_LEFTBMASK ) | |
202 | type = wxEVT_LEFT_DOWN; | |
203 | else if ( e->message & EVT_MIDDLEBMASK ) | |
204 | type = wxEVT_MIDDLE_DOWN; | |
205 | else if ( e->message & EVT_RIGHTBMASK ) | |
206 | type = wxEVT_RIGHT_DOWN; | |
207 | } | |
a679e129 | 208 | |
ef344ff8 VS |
209 | break; |
210 | ||
211 | case EVT_MOUSEUP: | |
212 | if ( e->message & EVT_LEFTBMASK ) | |
213 | type = wxEVT_LEFT_UP; | |
214 | else if ( e->message & EVT_MIDDLEBMASK ) | |
215 | type = wxEVT_MIDDLE_UP; | |
216 | else if ( e->message & EVT_RIGHTBMASK ) | |
217 | type = wxEVT_RIGHT_UP; | |
218 | break; | |
219 | ||
220 | case EVT_MOUSEMOVE: | |
7cdbf02c VS |
221 | if ( !gs_mouseCapture ) |
222 | { | |
223 | if ( win != gs_windowUnderMouse ) | |
224 | { | |
225 | if ( gs_windowUnderMouse ) | |
226 | { | |
227 | wxMouseEvent event2(event); | |
7de59551 RD |
228 | MGL_wmCoordGlobalToLocal(gs_windowUnderMouse->GetHandle(), |
229 | e->where_x, e->where_y, | |
7cdbf02c VS |
230 | &event2.m_x, &event2.m_y); |
231 | ||
d76048f5 VS |
232 | wxPoint orig(gs_windowUnderMouse->GetClientAreaOrigin()); |
233 | event2.m_x -= orig.x; | |
234 | event2.m_y -= orig.y; | |
235 | ||
7cdbf02c VS |
236 | event2.SetEventObject(gs_windowUnderMouse); |
237 | event2.SetEventType(wxEVT_LEAVE_WINDOW); | |
937013e0 | 238 | gs_windowUnderMouse->HandleWindowEvent(event2); |
7cdbf02c VS |
239 | } |
240 | ||
241 | wxMouseEvent event3(event); | |
242 | event3.SetEventType(wxEVT_ENTER_WINDOW); | |
937013e0 | 243 | win->HandleWindowEvent(event3); |
7cdbf02c VS |
244 | |
245 | gs_windowUnderMouse = win; | |
246 | } | |
247 | } | |
248 | else // gs_mouseCapture | |
ef344ff8 | 249 | { |
7de59551 | 250 | bool inside = (where.x >= 0 && |
7cdbf02c VS |
251 | where.y >= 0 && |
252 | where.x < win->GetSize().x && | |
253 | where.y < win->GetSize().y); | |
254 | if ( (inside && gs_windowUnderMouse != win) || | |
255 | (!inside && gs_windowUnderMouse == win) ) | |
ef344ff8 | 256 | { |
7de59551 | 257 | wxMouseEvent evt(inside ? |
7cdbf02c VS |
258 | wxEVT_ENTER_WINDOW : wxEVT_LEAVE_WINDOW); |
259 | evt.SetEventObject(win); | |
937013e0 | 260 | win->HandleWindowEvent(evt); |
7cdbf02c | 261 | gs_windowUnderMouse = inside ? win : NULL; |
ef344ff8 | 262 | } |
ef344ff8 | 263 | } |
7de59551 | 264 | |
ef344ff8 VS |
265 | type = wxEVT_MOTION; |
266 | break; | |
267 | ||
268 | default: | |
269 | break; | |
270 | } | |
7de59551 | 271 | |
ef344ff8 VS |
272 | if ( type == wxEVT_NULL ) |
273 | { | |
274 | return FALSE; | |
275 | } | |
276 | else | |
277 | { | |
278 | event.SetEventType(type); | |
937013e0 | 279 | return win->HandleWindowEvent(event); |
ef344ff8 VS |
280 | } |
281 | } | |
282 | ||
a679e129 | 283 | static long wxScanToKeyCode(event_t *event, bool translate) |
ef344ff8 | 284 | { |
84c88a17 VS |
285 | // VS: make it __WXDEBUG__-only, since we have lots of wxLogTrace calls |
286 | // here and the arguments would be stored in non-debug executable even | |
287 | // though wxLogTrace would be no-op... | |
288 | #ifdef __WXDEBUG__ | |
289 | #define KEY(mgl_key,wx_key) \ | |
290 | case mgl_key: \ | |
9a83f860 VZ |
291 | wxLogTrace(wxT("keyevents"), \ |
292 | wxT("key " #mgl_key ", mapped to " #wx_key)); \ | |
84c88a17 VS |
293 | key = wx_key; \ |
294 | break; | |
295 | #else | |
296 | #define KEY(mgl_key,wx_key) \ | |
7de59551 | 297 | case mgl_key: key = wx_key; break; |
84c88a17 | 298 | #endif |
2b260bc3 VS |
299 | |
300 | long key = 0; | |
7de59551 | 301 | |
a679e129 | 302 | if ( translate ) |
2b260bc3 | 303 | { |
3fa2676f MW |
304 | bool numlock = (event->modifiers & EVT_NUMLOCK) != 0; |
305 | ||
a679e129 VS |
306 | switch ( EVT_scanCode(event->message) ) |
307 | { | |
308 | KEY (KB_padMinus, WXK_NUMPAD_SUBTRACT) | |
309 | KEY (KB_padPlus, WXK_NUMPAD_ADD) | |
310 | KEY (KB_padTimes, WXK_NUMPAD_MULTIPLY) | |
311 | KEY (KB_padDivide, WXK_NUMPAD_DIVIDE) | |
3fa2676f MW |
312 | KEY (KB_padCenter, numlock ? WXK_NUMPAD5 : WXK_NUMPAD_SEPARATOR) // ? |
313 | KEY (KB_padLeft, numlock ? WXK_NUMPAD4 : WXK_NUMPAD_LEFT) | |
314 | KEY (KB_padRight, numlock ? WXK_NUMPAD6 : WXK_NUMPAD_RIGHT) | |
315 | KEY (KB_padUp, numlock ? WXK_NUMPAD8 : WXK_NUMPAD_UP) | |
316 | KEY (KB_padDown, numlock ? WXK_NUMPAD2 : WXK_NUMPAD_DOWN) | |
317 | KEY (KB_padInsert, numlock ? WXK_NUMPAD0 : WXK_NUMPAD_INSERT) | |
318 | KEY (KB_padDelete, numlock ? WXK_DECIMAL : WXK_NUMPAD_DELETE) | |
319 | KEY (KB_padHome, numlock ? WXK_NUMPAD7 : WXK_NUMPAD_HOME) | |
320 | KEY (KB_padEnd, numlock ? WXK_NUMPAD1 : WXK_NUMPAD_END) | |
321 | KEY (KB_padPageUp, numlock ? WXK_NUMPAD9 : WXK_NUMPAD_PAGEUP) | |
322 | KEY (KB_padPageDown, numlock ? WXK_NUMPAD3 : WXK_NUMPAD_PAGEDOWN) | |
a679e129 VS |
323 | KEY (KB_1, '1') |
324 | KEY (KB_2, '2') | |
325 | KEY (KB_3, '3') | |
326 | KEY (KB_4, '4') | |
327 | KEY (KB_5, '5') | |
328 | KEY (KB_6, '6') | |
329 | KEY (KB_7, '7') | |
330 | KEY (KB_8, '8') | |
331 | KEY (KB_9, '9') | |
332 | KEY (KB_0, '0') | |
333 | KEY (KB_minus, WXK_SUBTRACT) | |
334 | KEY (KB_equals, WXK_ADD) | |
335 | KEY (KB_backSlash, '\\') | |
336 | KEY (KB_Q, 'Q') | |
337 | KEY (KB_W, 'W') | |
338 | KEY (KB_E, 'E') | |
339 | KEY (KB_R, 'R') | |
340 | KEY (KB_T, 'T') | |
341 | KEY (KB_Y, 'Y') | |
342 | KEY (KB_U, 'U') | |
343 | KEY (KB_I, 'I') | |
344 | KEY (KB_O, 'O') | |
345 | KEY (KB_P, 'P') | |
346 | KEY (KB_leftSquareBrace,'[') | |
347 | KEY (KB_rightSquareBrace,']') | |
348 | KEY (KB_A, 'A') | |
349 | KEY (KB_S, 'S') | |
350 | KEY (KB_D, 'D') | |
351 | KEY (KB_F, 'F') | |
352 | KEY (KB_G, 'G') | |
353 | KEY (KB_H, 'H') | |
354 | KEY (KB_J, 'J') | |
355 | KEY (KB_K, 'K') | |
356 | KEY (KB_L, 'L') | |
357 | KEY (KB_semicolon, ';') | |
358 | KEY (KB_apostrophe, '\'') | |
359 | KEY (KB_Z, 'Z') | |
360 | KEY (KB_X, 'X') | |
361 | KEY (KB_C, 'C') | |
362 | KEY (KB_V, 'V') | |
363 | KEY (KB_B, 'B') | |
364 | KEY (KB_N, 'N') | |
365 | KEY (KB_M, 'M') | |
366 | KEY (KB_comma, ',') | |
367 | KEY (KB_period, '.') | |
368 | KEY (KB_divide, WXK_DIVIDE) | |
369 | KEY (KB_space, WXK_SPACE) | |
370 | KEY (KB_tilde, '~') | |
371 | ||
372 | default: break; | |
373 | } | |
374 | } | |
7de59551 | 375 | |
a679e129 VS |
376 | if ( key == 0 ) |
377 | { | |
378 | switch ( EVT_scanCode(event->message) ) | |
379 | { | |
380 | KEY (KB_padEnter, WXK_NUMPAD_ENTER) | |
381 | KEY (KB_F1, WXK_F1) | |
382 | KEY (KB_F2, WXK_F2) | |
383 | KEY (KB_F3, WXK_F3) | |
384 | KEY (KB_F4, WXK_F4) | |
385 | KEY (KB_F5, WXK_F5) | |
386 | KEY (KB_F6, WXK_F6) | |
387 | KEY (KB_F7, WXK_F7) | |
388 | KEY (KB_F8, WXK_F8) | |
389 | KEY (KB_F9, WXK_F9) | |
390 | KEY (KB_F10, WXK_F10) | |
391 | KEY (KB_F11, WXK_F11) | |
392 | KEY (KB_F12, WXK_F12) | |
393 | KEY (KB_left, WXK_LEFT) | |
394 | KEY (KB_right, WXK_RIGHT) | |
395 | KEY (KB_up, WXK_UP) | |
396 | KEY (KB_down, WXK_DOWN) | |
397 | KEY (KB_insert, WXK_INSERT) | |
398 | KEY (KB_delete, WXK_DELETE) | |
399 | KEY (KB_home, WXK_HOME) | |
400 | KEY (KB_end, WXK_END) | |
401 | KEY (KB_pageUp, WXK_PAGEUP) | |
402 | KEY (KB_pageDown, WXK_PAGEDOWN) | |
403 | KEY (KB_capsLock, WXK_CAPITAL) | |
404 | KEY (KB_numLock, WXK_NUMLOCK) | |
405 | KEY (KB_scrollLock, WXK_SCROLL) | |
406 | KEY (KB_leftShift, WXK_SHIFT) | |
407 | KEY (KB_rightShift, WXK_SHIFT) | |
408 | KEY (KB_leftCtrl, WXK_CONTROL) | |
409 | KEY (KB_rightCtrl, WXK_CONTROL) | |
410 | KEY (KB_leftAlt, WXK_ALT) | |
411 | KEY (KB_rightAlt, WXK_ALT) | |
412 | KEY (KB_leftWindows, WXK_START) | |
413 | KEY (KB_rightWindows, WXK_START) | |
414 | KEY (KB_menu, WXK_MENU) | |
415 | KEY (KB_sysReq, WXK_SNAPSHOT) | |
416 | KEY (KB_esc, WXK_ESCAPE) | |
417 | KEY (KB_backspace, WXK_BACK) | |
418 | KEY (KB_tab, WXK_TAB) | |
7de59551 | 419 | KEY (KB_enter, WXK_RETURN) |
a679e129 | 420 | |
7de59551 RD |
421 | default: |
422 | key = EVT_asciiCode(event->message); | |
a679e129 VS |
423 | break; |
424 | } | |
2b260bc3 VS |
425 | } |
426 | ||
544c782d VS |
427 | #undef KEY |
428 | ||
2b260bc3 | 429 | return key; |
ef344ff8 VS |
430 | } |
431 | ||
d53fc7c9 VS |
432 | static bool wxHandleSpecialKeys(wxKeyEvent& event) |
433 | { | |
434 | // Add an easy way to capture screenshots: | |
435 | if ( event.m_keyCode == WXK_SNAPSHOT | |
436 | #ifdef __WXDEBUG__ // FIXME_MGL - remove when KB_sysReq works in MGL! | |
7de59551 RD |
437 | || (event.m_keyCode == WXK_F1 && |
438 | event.m_shiftDown && event.m_controlDown) | |
d53fc7c9 | 439 | #endif |
197b1626 | 440 | ) |
d53fc7c9 | 441 | { |
2d1efe3f | 442 | wxCaptureScreenshot(event.m_altDown/*only active wnd?*/); |
127eab18 | 443 | return true; |
d53fc7c9 | 444 | } |
7de59551 | 445 | |
127eab18 | 446 | return false; |
d53fc7c9 VS |
447 | } |
448 | ||
b43a9886 | 449 | static ibool MGLAPI wxWindowKeybHandler(window_t *wnd, event_t *e) |
2b260bc3 | 450 | { |
2b260bc3 | 451 | wxWindowMGL *win = (wxWindowMGL*)MGL_wmGetWindowUserData(wnd); |
a200c35e VS |
452 | |
453 | if ( !win->IsEnabled() ) return FALSE; | |
454 | ||
985520bc | 455 | wxPoint where; |
7de59551 | 456 | MGL_wmCoordGlobalToLocal(win->GetHandle(), |
985520bc | 457 | e->where_x, e->where_y, &where.x, &where.y); |
7de59551 | 458 | |
2b260bc3 VS |
459 | wxKeyEvent event; |
460 | event.SetEventObject(win); | |
461 | event.SetTimestamp(e->when); | |
127eab18 | 462 | event.m_keyCode = wxScanToKeyCode(e, true); |
2b260bc3 VS |
463 | event.m_x = where.x; |
464 | event.m_y = where.y; | |
318ac890 MW |
465 | event.m_shiftDown = ( e->modifiers & EVT_SHIFTKEY ) != 0; |
466 | event.m_controlDown = ( e->modifiers & EVT_CTRLSTATE ) != 0; | |
467 | event.m_altDown = ( e->modifiers & EVT_LEFTALT ) != 0; | |
468 | event.m_metaDown = ( e->modifiers & EVT_RIGHTALT ) != 0; | |
2b260bc3 VS |
469 | |
470 | if ( e->what == EVT_KEYUP ) | |
471 | { | |
472 | event.SetEventType(wxEVT_KEY_UP); | |
937013e0 | 473 | return win->HandleWindowEvent(event); |
2b260bc3 VS |
474 | } |
475 | else | |
476 | { | |
477 | bool ret; | |
478 | wxKeyEvent event2; | |
479 | ||
480 | event.SetEventType(wxEVT_KEY_DOWN); | |
481 | event2 = event; | |
7de59551 | 482 | |
937013e0 | 483 | ret = win->HandleWindowEvent(event); |
2b260bc3 | 484 | |
84c88a17 VS |
485 | // wxMSW doesn't send char events with Alt pressed |
486 | // Only send wxEVT_CHAR event if not processed yet. Thus, ALT-x | |
d53fc7c9 | 487 | // will only be sent if it is not in an accelerator table: |
127eab18 | 488 | event2.m_keyCode = wxScanToKeyCode(e, false); |
2b260bc3 VS |
489 | if ( !ret && event2.m_keyCode != 0 ) |
490 | { | |
491 | event2.SetEventType(wxEVT_CHAR); | |
937013e0 | 492 | ret = win->HandleWindowEvent(event2); |
2b260bc3 | 493 | } |
7de59551 | 494 | |
84c88a17 | 495 | // Synthetize navigation key event, but do it only if the TAB key |
d53fc7c9 | 496 | // wasn't handled yet: |
84c88a17 VS |
497 | if ( !ret && event.m_keyCode == WXK_TAB && |
498 | win->GetParent() && win->GetParent()->HasFlag(wxTAB_TRAVERSAL) ) | |
499 | { | |
500 | wxNavigationKeyEvent navEvent; | |
501 | navEvent.SetEventObject(win->GetParent()); | |
502 | // Shift-TAB goes in reverse direction: | |
503 | navEvent.SetDirection(!event.m_shiftDown); | |
504 | // Ctrl-TAB changes the (parent) window, i.e. switch notebook page: | |
505 | navEvent.SetWindowChange(event.m_controlDown); | |
506 | navEvent.SetCurrentFocus(wxStaticCast(win, wxWindow)); | |
937013e0 | 507 | ret = win->HandleWindowEvent(navEvent); |
84c88a17 | 508 | } |
7de59551 RD |
509 | |
510 | // Finally, process special meaning keys that are usually | |
d53fc7c9 VS |
511 | // a responsibility of OS or window manager: |
512 | if ( !ret ) | |
513 | ret = wxHandleSpecialKeys(event); | |
7de59551 | 514 | |
2b260bc3 VS |
515 | return ret; |
516 | } | |
7bdc1879 | 517 | } |
a4bbc9f7 VS |
518 | |
519 | // --------------------------------------------------------------------------- | |
520 | // event tables | |
521 | // --------------------------------------------------------------------------- | |
522 | ||
ef344ff8 | 523 | // in wxUniv this class is abstract because it doesn't have DoPopupMenu() |
a4bbc9f7 VS |
524 | IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL, wxWindowBase) |
525 | ||
526 | BEGIN_EVENT_TABLE(wxWindowMGL, wxWindowBase) | |
a4bbc9f7 VS |
527 | END_EVENT_TABLE() |
528 | ||
529 | // =========================================================================== | |
530 | // implementation | |
531 | // =========================================================================== | |
532 | ||
533 | // ---------------------------------------------------------------------------- | |
534 | // constructors and such | |
535 | // ---------------------------------------------------------------------------- | |
536 | ||
1c53456f | 537 | extern wxVideoMode wxGetDefaultDisplayMode(); |
a3e76614 | 538 | |
a4bbc9f7 VS |
539 | void wxWindowMGL::Init() |
540 | { | |
1f43b5c9 VS |
541 | // First of all, make sure window manager is up and running. If it is |
542 | // not the case, initialize it in default display mode | |
543 | if ( !g_winMng ) | |
7b9f73d2 VS |
544 | { |
545 | if ( !wxTheApp->SetDisplayMode(wxGetDefaultDisplayMode()) ) | |
43b2d5e7 | 546 | { |
a1f7eb20 | 547 | wxLogFatalError(_("Cannot initialize display.")); |
43b2d5e7 | 548 | } |
7b9f73d2 | 549 | } |
1f43b5c9 | 550 | |
a4bbc9f7 | 551 | // mgl specific: |
a4bbc9f7 | 552 | m_wnd = NULL; |
127eab18 | 553 | m_isShown = true; |
a4bbc9f7 | 554 | m_paintMGLDC = NULL; |
2b260bc3 | 555 | m_eraseBackground = -1; |
a4bbc9f7 VS |
556 | } |
557 | ||
558 | // Destructor | |
559 | wxWindowMGL::~wxWindowMGL() | |
560 | { | |
7de59551 RD |
561 | SendDestroyEvent(); |
562 | ||
7cdbf02c VS |
563 | if ( gs_mouseCapture == this ) |
564 | ReleaseMouse(); | |
d46330c5 | 565 | |
7cdbf02c | 566 | if (gs_activeFrame == this) |
d46330c5 | 567 | { |
66858adf VS |
568 | gs_activeFrame = NULL; |
569 | // activate next frame in Z-order: | |
570 | if ( m_wnd->prev ) | |
571 | { | |
572 | wxWindowMGL *win = (wxWindowMGL*)m_wnd->prev->userData; | |
573 | win->SetFocus(); | |
574 | } | |
575 | else if ( m_wnd->next ) | |
576 | { | |
577 | wxWindowMGL *win = (wxWindowMGL*)m_wnd->next->userData; | |
578 | win->SetFocus(); | |
d46330c5 | 579 | } |
d46330c5 | 580 | } |
7de59551 | 581 | |
7cdbf02c | 582 | if ( gs_focusedWindow == this ) |
7bdc1879 | 583 | KillFocus(); |
d46330c5 | 584 | |
7cdbf02c VS |
585 | if ( gs_windowUnderMouse == this ) |
586 | gs_windowUnderMouse = NULL; | |
a4bbc9f7 | 587 | |
a4bbc9f7 VS |
588 | DestroyChildren(); |
589 | ||
a4bbc9f7 VS |
590 | if ( m_wnd ) |
591 | MGL_wmDestroyWindow(m_wnd); | |
592 | } | |
593 | ||
594 | // real construction (Init() must have been called before!) | |
595 | bool wxWindowMGL::Create(wxWindow *parent, | |
596 | wxWindowID id, | |
597 | const wxPoint& pos, | |
598 | const wxSize& size, | |
599 | long style, | |
600 | const wxString& name) | |
601 | { | |
a4bbc9f7 | 602 | if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) ) |
127eab18 | 603 | return false; |
a4bbc9f7 | 604 | |
544c782d | 605 | if ( parent ) |
7bdc1879 | 606 | parent->AddChild(this); |
a4bbc9f7 | 607 | |
ef344ff8 VS |
608 | int x, y, w, h; |
609 | x = pos.x, y = pos.y; | |
610 | if ( x == -1 ) | |
611 | x = 0; // FIXME_MGL, something better, see GTK+ | |
612 | if ( y == -1 ) | |
613 | y = 0; // FIXME_MGL, something better, see GTK+ | |
82186005 | 614 | AdjustForParentClientOrigin(x, y, 0); |
ef344ff8 VS |
615 | w = WidthDefault(size.x); |
616 | h = HeightDefault(size.y); | |
7de59551 | 617 | |
72fa862b | 618 | long mgl_style = 0; |
7cdbf02c | 619 | window_t *wnd_parent = parent ? parent->GetHandle() : NULL; |
544c782d | 620 | |
e441e1f4 | 621 | if ( style & wxFULL_REPAINT_ON_RESIZE ) |
544c782d | 622 | { |
72fa862b | 623 | mgl_style |= MGL_WM_FULL_REPAINT_ON_RESIZE; |
544c782d | 624 | } |
72fa862b | 625 | if ( style & wxSTAY_ON_TOP ) |
544c782d | 626 | { |
72fa862b | 627 | mgl_style |= MGL_WM_ALWAYS_ON_TOP; |
544c782d VS |
628 | } |
629 | if ( style & wxPOPUP_WINDOW ) | |
630 | { | |
7cdbf02c | 631 | mgl_style |= MGL_WM_ALWAYS_ON_TOP; |
544c782d | 632 | // it is created hidden as other top level windows |
127eab18 | 633 | m_isShown = false; |
7cdbf02c | 634 | wnd_parent = NULL; |
544c782d | 635 | } |
ef344ff8 | 636 | |
58061670 VS |
637 | window_t *wnd = MGL_wmCreateWindow(g_winMng, wnd_parent, x, y, w, h); |
638 | ||
639 | MGL_wmSetWindowFlags(wnd, mgl_style); | |
640 | MGL_wmShowWindow(wnd, m_isShown); | |
7de59551 | 641 | |
58061670 VS |
642 | SetMGLwindow_t(wnd); |
643 | ||
127eab18 | 644 | return true; |
58061670 VS |
645 | } |
646 | ||
647 | void wxWindowMGL::SetMGLwindow_t(struct window_t *wnd) | |
648 | { | |
649 | if ( m_wnd ) | |
650 | MGL_wmDestroyWindow(m_wnd); | |
651 | ||
652 | m_wnd = wnd; | |
653 | if ( !m_wnd ) return; | |
7de59551 | 654 | |
127eab18 | 655 | m_isShown = (bool)m_wnd->visible; |
ef344ff8 | 656 | |
a4bbc9f7 VS |
657 | MGL_wmSetWindowUserData(m_wnd, (void*) this); |
658 | MGL_wmSetWindowPainter(m_wnd, wxWindowPainter); | |
ef344ff8 VS |
659 | MGL_wmPushWindowEventHandler(m_wnd, wxWindowMouseHandler, EVT_MOUSEEVT, 0); |
660 | MGL_wmPushWindowEventHandler(m_wnd, wxWindowKeybHandler, EVT_KEYEVT, 0); | |
58061670 | 661 | |
a1b806b9 | 662 | if ( m_cursor.IsOk() ) |
58061670 VS |
663 | MGL_wmSetWindowCursor(m_wnd, *m_cursor.GetMGLCursor()); |
664 | else | |
665 | MGL_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetMGLCursor()); | |
a4bbc9f7 VS |
666 | } |
667 | ||
668 | // --------------------------------------------------------------------------- | |
669 | // basic operations | |
670 | // --------------------------------------------------------------------------- | |
671 | ||
672 | void wxWindowMGL::SetFocus() | |
673 | { | |
a46935cb VS |
674 | if ( gs_focusedWindow == this ) return; |
675 | ||
eea93267 VS |
676 | wxWindowMGL *oldFocusedWindow = gs_focusedWindow; |
677 | ||
7cdbf02c | 678 | if ( gs_focusedWindow ) |
eea93267 VS |
679 | { |
680 | gs_toBeFocusedWindow = (wxWindow*)this; | |
7cdbf02c | 681 | gs_focusedWindow->KillFocus(); |
eea93267 VS |
682 | gs_toBeFocusedWindow = NULL; |
683 | } | |
7de59551 | 684 | |
7cdbf02c | 685 | gs_focusedWindow = this; |
7de59551 | 686 | |
2b260bc3 | 687 | MGL_wmCaptureEvents(GetHandle(), EVT_KEYEVT, wxMGL_CAPTURE_KEYB); |
a4bbc9f7 | 688 | |
7cdbf02c | 689 | wxWindowMGL *active = wxGetTopLevelParent(this); |
61bd618f | 690 | if ( !(m_windowStyle & wxPOPUP_WINDOW) && active != gs_activeFrame ) |
a4bbc9f7 | 691 | { |
7cdbf02c VS |
692 | if ( gs_activeFrame ) |
693 | { | |
127eab18 | 694 | wxActivateEvent event(wxEVT_ACTIVATE, false, gs_activeFrame->GetId()); |
7cdbf02c | 695 | event.SetEventObject(gs_activeFrame); |
937013e0 | 696 | gs_activeFrame->HandleWindowEvent(event); |
7cdbf02c VS |
697 | } |
698 | ||
699 | gs_activeFrame = active; | |
127eab18 | 700 | wxActivateEvent event(wxEVT_ACTIVATE, true, gs_activeFrame->GetId()); |
7cdbf02c | 701 | event.SetEventObject(gs_activeFrame); |
937013e0 | 702 | gs_activeFrame->HandleWindowEvent(event); |
a4bbc9f7 | 703 | } |
7de59551 | 704 | |
4d163bf8 VS |
705 | // notify the parent keeping track of focus for the kbd navigation |
706 | // purposes that we got it | |
707 | wxChildFocusEvent eventFocus((wxWindow*)this); | |
937013e0 | 708 | HandleWindowEvent(eventFocus); |
4d163bf8 | 709 | |
a4bbc9f7 VS |
710 | wxFocusEvent event(wxEVT_SET_FOCUS, GetId()); |
711 | event.SetEventObject(this); | |
eea93267 | 712 | event.SetWindow((wxWindow*)oldFocusedWindow); |
937013e0 | 713 | HandleWindowEvent(event); |
869dabf8 VS |
714 | |
715 | #if wxUSE_CARET | |
716 | // caret needs to be informed about focus change | |
717 | wxCaret *caret = GetCaret(); | |
718 | if ( caret ) | |
719 | caret->OnSetFocus(); | |
720 | #endif // wxUSE_CARET | |
a4bbc9f7 | 721 | } |
32b8ec41 | 722 | |
a4bbc9f7 | 723 | void wxWindowMGL::KillFocus() |
32b8ec41 | 724 | { |
7cdbf02c VS |
725 | if ( gs_focusedWindow != this ) return; |
726 | gs_focusedWindow = NULL; | |
a4bbc9f7 | 727 | |
7bdc1879 | 728 | if ( m_isBeingDeleted ) return; |
7de59551 | 729 | |
a4bbc9f7 VS |
730 | MGL_wmUncaptureEvents(GetHandle(), wxMGL_CAPTURE_KEYB); |
731 | ||
732 | #if wxUSE_CARET | |
733 | // caret needs to be informed about focus change | |
734 | wxCaret *caret = GetCaret(); | |
7bdc1879 | 735 | if ( caret ) |
a4bbc9f7 VS |
736 | caret->OnKillFocus(); |
737 | #endif // wxUSE_CARET | |
738 | ||
a4bbc9f7 VS |
739 | wxFocusEvent event(wxEVT_KILL_FOCUS, GetId()); |
740 | event.SetEventObject(this); | |
eea93267 | 741 | event.SetWindow(gs_toBeFocusedWindow); |
937013e0 | 742 | HandleWindowEvent(event); |
32b8ec41 VZ |
743 | } |
744 | ||
a4bbc9f7 VS |
745 | // ---------------------------------------------------------------------------- |
746 | // this wxWindowBase function is implemented here (in platform-specific file) | |
747 | // because it is static and so couldn't be made virtual | |
748 | // ---------------------------------------------------------------------------- | |
0fe02759 | 749 | wxWindow *wxWindowBase::DoFindFocus() |
32b8ec41 | 750 | { |
7cdbf02c | 751 | return (wxWindow*)gs_focusedWindow; |
a4bbc9f7 VS |
752 | } |
753 | ||
754 | bool wxWindowMGL::Show(bool show) | |
755 | { | |
756 | if ( !wxWindowBase::Show(show) ) | |
127eab18 | 757 | return false; |
a4bbc9f7 VS |
758 | |
759 | MGL_wmShowWindow(m_wnd, show); | |
7de59551 | 760 | |
ead60ec5 VS |
761 | if (!show && gs_activeFrame == this) |
762 | { | |
66858adf VS |
763 | // activate next frame in Z-order: |
764 | if ( m_wnd->prev ) | |
765 | { | |
766 | wxWindowMGL *win = (wxWindowMGL*)m_wnd->prev->userData; | |
767 | win->SetFocus(); | |
768 | } | |
769 | else if ( m_wnd->next ) | |
770 | { | |
771 | wxWindowMGL *win = (wxWindowMGL*)m_wnd->next->userData; | |
772 | win->SetFocus(); | |
773 | } | |
774 | else | |
775 | { | |
776 | gs_activeFrame = NULL; | |
ead60ec5 VS |
777 | } |
778 | } | |
779 | ||
127eab18 | 780 | return true; |
a4bbc9f7 VS |
781 | } |
782 | ||
783 | // Raise the window to the top of the Z order | |
784 | void wxWindowMGL::Raise() | |
785 | { | |
786 | MGL_wmRaiseWindow(m_wnd); | |
787 | } | |
788 | ||
789 | // Lower the window to the bottom of the Z order | |
790 | void wxWindowMGL::Lower() | |
791 | { | |
792 | MGL_wmLowerWindow(m_wnd); | |
793 | } | |
794 | ||
4116c221 | 795 | void wxWindowMGL::DoCaptureMouse() |
a4bbc9f7 | 796 | { |
7cdbf02c VS |
797 | if ( gs_mouseCapture ) |
798 | MGL_wmUncaptureEvents(gs_mouseCapture->m_wnd, wxMGL_CAPTURE_MOUSE); | |
799 | ||
800 | gs_mouseCapture = this; | |
a4bbc9f7 VS |
801 | MGL_wmCaptureEvents(m_wnd, EVT_MOUSEEVT, wxMGL_CAPTURE_MOUSE); |
802 | } | |
803 | ||
4116c221 | 804 | void wxWindowMGL::DoReleaseMouse() |
a4bbc9f7 | 805 | { |
63fd5f0b | 806 | wxASSERT_MSG( gs_mouseCapture == this, wxT("attempt to release mouse, but this window hasn't captured it") ); |
7de59551 | 807 | |
a4bbc9f7 | 808 | MGL_wmUncaptureEvents(m_wnd, wxMGL_CAPTURE_MOUSE); |
7cdbf02c | 809 | gs_mouseCapture = NULL; |
a4bbc9f7 VS |
810 | } |
811 | ||
812 | /* static */ wxWindow *wxWindowBase::GetCapture() | |
813 | { | |
7cdbf02c | 814 | return (wxWindow*)gs_mouseCapture; |
a4bbc9f7 VS |
815 | } |
816 | ||
817 | bool wxWindowMGL::SetCursor(const wxCursor& cursor) | |
818 | { | |
819 | if ( !wxWindowBase::SetCursor(cursor) ) | |
820 | { | |
821 | // no change | |
127eab18 | 822 | return false; |
a4bbc9f7 VS |
823 | } |
824 | ||
a1b806b9 | 825 | if ( m_cursor.IsOk() ) |
a4bbc9f7 | 826 | MGL_wmSetWindowCursor(m_wnd, *m_cursor.GetMGLCursor()); |
ef344ff8 VS |
827 | else |
828 | MGL_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetMGLCursor()); | |
a4bbc9f7 | 829 | |
127eab18 | 830 | return true; |
a4bbc9f7 VS |
831 | } |
832 | ||
833 | void wxWindowMGL::WarpPointer(int x, int y) | |
834 | { | |
8014db41 VS |
835 | int w, h; |
836 | wxDisplaySize(&w, &h); | |
837 | ||
a4bbc9f7 | 838 | ClientToScreen(&x, &y); |
8014db41 VS |
839 | if ( x < 0 ) |
840 | x = 0; | |
841 | if ( y < 0 ) | |
842 | y = 0; | |
843 | if ( x >= w ) | |
844 | x = w-1; | |
845 | if ( y >= h ) | |
846 | y = h-1; | |
7de59551 | 847 | |
a4bbc9f7 VS |
848 | EVT_setMousePos(x, y); |
849 | } | |
850 | ||
a4bbc9f7 VS |
851 | // Set this window to be the child of 'parent'. |
852 | bool wxWindowMGL::Reparent(wxWindowBase *parent) | |
853 | { | |
854 | if ( !wxWindowBase::Reparent(parent) ) | |
127eab18 | 855 | return false; |
a4bbc9f7 VS |
856 | |
857 | MGL_wmReparentWindow(m_wnd, parent->GetHandle()); | |
858 | ||
127eab18 | 859 | return true; |
a4bbc9f7 VS |
860 | } |
861 | ||
862 | ||
863 | // --------------------------------------------------------------------------- | |
864 | // drag and drop | |
865 | // --------------------------------------------------------------------------- | |
866 | ||
867 | #if wxUSE_DRAG_AND_DROP | |
868 | ||
869 | void wxWindowMGL::SetDropTarget(wxDropTarget *pDropTarget) | |
870 | { | |
871 | if ( m_dropTarget != 0 ) { | |
872 | m_dropTarget->Revoke(m_hWnd); | |
873 | delete m_dropTarget; | |
874 | } | |
875 | ||
876 | m_dropTarget = pDropTarget; | |
877 | if ( m_dropTarget != 0 ) | |
878 | m_dropTarget->Register(m_hWnd); | |
879 | } | |
880 | // FIXME_MGL | |
881 | #endif // wxUSE_DRAG_AND_DROP | |
882 | ||
883 | // old style file-manager drag&drop support: we retain the old-style | |
884 | // DragAcceptFiles in parallel with SetDropTarget. | |
127eab18 | 885 | void wxWindowMGL::DragAcceptFiles(bool WXUNUSED(accept)) |
a4bbc9f7 VS |
886 | { |
887 | #if 0 // FIXME_MGL | |
888 | HWND hWnd = GetHwnd(); | |
889 | if ( hWnd ) | |
890 | ::DragAcceptFiles(hWnd, (BOOL)accept); | |
891 | #endif | |
892 | } | |
893 | ||
894 | // --------------------------------------------------------------------------- | |
895 | // moving and resizing | |
896 | // --------------------------------------------------------------------------- | |
897 | ||
898 | // Get total size | |
899 | void wxWindowMGL::DoGetSize(int *x, int *y) const | |
900 | { | |
ea98f686 | 901 | wxASSERT_MSG( m_wnd, wxT("invalid window") ); |
7de59551 | 902 | |
a4bbc9f7 VS |
903 | if (x) *x = m_wnd->width; |
904 | if (y) *y = m_wnd->height; | |
905 | } | |
906 | ||
907 | void wxWindowMGL::DoGetPosition(int *x, int *y) const | |
908 | { | |
ea98f686 VS |
909 | wxASSERT_MSG( m_wnd, wxT("invalid window") ); |
910 | ||
911 | int pX = 0, pY = 0; | |
7de59551 | 912 | AdjustForParentClientOrigin(pX, pY, 0); |
e41dcea5 | 913 | |
ea98f686 VS |
914 | if (x) *x = m_wnd->x - pX; |
915 | if (y) *y = m_wnd->y - pY; | |
a4bbc9f7 VS |
916 | } |
917 | ||
918 | void wxWindowMGL::DoScreenToClient(int *x, int *y) const | |
919 | { | |
920 | int ax, ay; | |
985520bc | 921 | MGL_wmCoordGlobalToLocal(m_wnd, 0, 0, &ax, &ay); |
a4bbc9f7 | 922 | if (x) |
985520bc | 923 | (*x) += ax; |
a4bbc9f7 | 924 | if (y) |
985520bc | 925 | (*y) += ay; |
a4bbc9f7 VS |
926 | } |
927 | ||
928 | void wxWindowMGL::DoClientToScreen(int *x, int *y) const | |
929 | { | |
930 | int ax, ay; | |
985520bc | 931 | MGL_wmCoordLocalToGlobal(m_wnd, 0, 0, &ax, &ay); |
a4bbc9f7 | 932 | if (x) |
985520bc | 933 | (*x) += ax; |
a4bbc9f7 | 934 | if (y) |
985520bc | 935 | (*y) += ay; |
a4bbc9f7 VS |
936 | } |
937 | ||
938 | // Get size *available for subwindows* i.e. excluding menu bar etc. | |
939 | void wxWindowMGL::DoGetClientSize(int *x, int *y) const | |
940 | { | |
941 | DoGetSize(x, y); | |
942 | } | |
943 | ||
944 | void wxWindowMGL::DoMoveWindow(int x, int y, int width, int height) | |
945 | { | |
1cdab5d1 MW |
946 | wxRect rcClient(GetClientRect()); |
947 | ||
948 | MGL_wmSetWindowPosition(m_wnd, x, y, width, height); | |
949 | ||
950 | // When the origin or a window stays fixed but the height or width | |
951 | // changes, invalidate the old and new non-client areas | |
952 | if ( !HasFlag(wxFULL_REPAINT_ON_RESIZE) && | |
953 | m_wnd->x == x && m_wnd->y == y && | |
954 | rcClient.Intersect(GetClientRect()) != wxRect(0, 0, width, height) ) | |
955 | { | |
956 | wxRegion rgn(0, 0, width, height); | |
957 | rgn.Subtract(rcClient); | |
958 | ||
959 | // This should work I think, but doesn't seem to: | |
960 | //MGL_wmInvalidateWindowRegion(m_wnd, rgn.GetMGLRegion().rgnPointer()); | |
961 | ||
962 | // Use MGL_wmInvalidateWindowRect instead: | |
963 | for (wxRegionIterator it(rgn); it; it++) | |
964 | { | |
965 | rect_t rc; | |
966 | rc.left = it.GetX(); | |
967 | rc.top = it.GetY(); | |
968 | rc.right = rc.left + it.GetW(); | |
969 | rc.bottom = rc.top + it.GetH(); | |
970 | MGL_wmInvalidateWindowRect(m_wnd, &rc); | |
971 | } | |
972 | } | |
a4bbc9f7 VS |
973 | } |
974 | ||
975 | // set the size of the window: if the dimensions are positive, just use them, | |
976 | // but if any of them is equal to -1, it means that we must find the value for | |
977 | // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in | |
978 | // which case -1 is a valid value for x and y) | |
979 | // | |
980 | // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate | |
981 | // the width/height to best suit our contents, otherwise we reuse the current | |
982 | // width/height | |
983 | void wxWindowMGL::DoSetSize(int x, int y, int width, int height, int sizeFlags) | |
984 | { | |
985 | // get the current size and position... | |
986 | int currentX, currentY; | |
987 | GetPosition(¤tX, ¤tY); | |
988 | int currentW,currentH; | |
989 | GetSize(¤tW, ¤tH); | |
990 | ||
991 | // ... and don't do anything (avoiding flicker) if it's already ok | |
992 | if ( x == currentX && y == currentY && | |
993 | width == currentW && height == currentH ) | |
994 | { | |
995 | return; | |
996 | } | |
997 | ||
998 | if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) ) | |
999 | x = currentX; | |
1000 | if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) ) | |
1001 | y = currentY; | |
1002 | ||
a4bbc9f7 | 1003 | AdjustForParentClientOrigin(x, y, sizeFlags); |
a4bbc9f7 VS |
1004 | |
1005 | wxSize size(-1, -1); | |
1006 | if ( width == -1 ) | |
1007 | { | |
1008 | if ( sizeFlags & wxSIZE_AUTO_WIDTH ) | |
1009 | { | |
1010 | size = DoGetBestSize(); | |
1011 | width = size.x; | |
1012 | } | |
1013 | else | |
1014 | { | |
1015 | // just take the current one | |
1016 | width = currentW; | |
1017 | } | |
1018 | } | |
7de59551 | 1019 | |
a4bbc9f7 VS |
1020 | if ( height == -1 ) |
1021 | { | |
1022 | if ( sizeFlags & wxSIZE_AUTO_HEIGHT ) | |
1023 | { | |
1024 | if ( size.x == -1 ) | |
1025 | { | |
1026 | size = DoGetBestSize(); | |
1027 | } | |
1028 | //else: already called DoGetBestSize() above | |
1029 | ||
1030 | height = size.y; | |
1031 | } | |
1032 | else | |
1033 | { | |
1034 | // just take the current one | |
1035 | height = currentH; | |
1036 | } | |
1037 | } | |
7de59551 | 1038 | |
6feddea3 | 1039 | int maxWidth = GetMaxWidth(), |
7de59551 | 1040 | minWidth = GetMinWidth(), |
6feddea3 VS |
1041 | maxHeight = GetMaxHeight(), |
1042 | minHeight = GetMinHeight(); | |
7de59551 | 1043 | |
6feddea3 VS |
1044 | if ( minWidth != -1 && width < minWidth ) width = minWidth; |
1045 | if ( maxWidth != -1 && width > maxWidth ) width = maxWidth; | |
1046 | if ( minHeight != -1 && height < minHeight ) height = minHeight; | |
1047 | if ( maxHeight != -1 && height > maxHeight ) height = maxHeight; | |
a4bbc9f7 | 1048 | |
7de59551 | 1049 | if ( m_wnd->x != x || m_wnd->y != y || |
88f2a771 VS |
1050 | (int)m_wnd->width != width || (int)m_wnd->height != height ) |
1051 | { | |
1052 | DoMoveWindow(x, y, width, height); | |
a4bbc9f7 | 1053 | |
127eab18 WS |
1054 | wxSize newSize(width, height); |
1055 | wxSizeEvent event(newSize, GetId()); | |
88f2a771 | 1056 | event.SetEventObject(this); |
937013e0 | 1057 | HandleWindowEvent(event); |
88f2a771 | 1058 | } |
a4bbc9f7 VS |
1059 | } |
1060 | ||
1061 | void wxWindowMGL::DoSetClientSize(int width, int height) | |
1062 | { | |
1063 | SetSize(width, height); | |
1064 | } | |
1065 | ||
1066 | // --------------------------------------------------------------------------- | |
1067 | // text metrics | |
1068 | // --------------------------------------------------------------------------- | |
1069 | ||
1070 | int wxWindowMGL::GetCharHeight() const | |
1071 | { | |
1072 | wxScreenDC dc; | |
1073 | dc.SetFont(m_font); | |
1074 | return dc.GetCharHeight(); | |
1075 | } | |
1076 | ||
1077 | int wxWindowMGL::GetCharWidth() const | |
1078 | { | |
1079 | wxScreenDC dc; | |
1080 | dc.SetFont(m_font); | |
1081 | return dc.GetCharWidth(); | |
1082 | } | |
1083 | ||
6de70470 VZ |
1084 | void wxWindowMGL::DoGetTextExtent(const wxString& string, |
1085 | int *x, int *y, | |
1086 | int *descent, | |
1087 | int *externalLeading, | |
1088 | const wxFont *theFont) const | |
a4bbc9f7 VS |
1089 | { |
1090 | wxScreenDC dc; | |
1091 | if (!theFont) | |
1092 | theFont = &m_font; | |
1093 | dc.GetTextExtent(string, x, y, descent, externalLeading, (wxFont*)theFont); | |
1094 | } | |
1095 | ||
a4bbc9f7 | 1096 | |
a4bbc9f7 VS |
1097 | // --------------------------------------------------------------------------- |
1098 | // painting | |
1099 | // --------------------------------------------------------------------------- | |
1100 | ||
2b260bc3 | 1101 | void wxWindowMGL::Refresh(bool eraseBack, const wxRect *rect) |
a4bbc9f7 | 1102 | { |
2b260bc3 VS |
1103 | if ( m_eraseBackground == -1 ) |
1104 | m_eraseBackground = eraseBack; | |
1105 | else | |
1106 | m_eraseBackground |= eraseBack; | |
7de59551 | 1107 | |
a4bbc9f7 VS |
1108 | if ( rect ) |
1109 | { | |
1110 | rect_t r; | |
1111 | r.left = rect->GetLeft(), r.right = rect->GetRight(); | |
1112 | r.top = rect->GetTop(), r.bottom = rect->GetBottom(); | |
1113 | MGL_wmInvalidateWindowRect(GetHandle(), &r); | |
1114 | } | |
1115 | else | |
1116 | MGL_wmInvalidateWindow(GetHandle()); | |
1117 | } | |
1118 | ||
1119 | void wxWindowMGL::Update() | |
1120 | { | |
17808a75 | 1121 | if ( !IsFrozen() ) |
a4bbc9f7 VS |
1122 | MGL_wmUpdateDC(g_winMng); |
1123 | } | |
1124 | ||
17808a75 | 1125 | void wxWindowMGL::DoFreeze() |
a4bbc9f7 | 1126 | { |
127eab18 | 1127 | m_refreshAfterThaw = false; |
a4bbc9f7 VS |
1128 | } |
1129 | ||
17808a75 | 1130 | void wxWindowMGL::DoThaw() |
a4bbc9f7 | 1131 | { |
a4bbc9f7 VS |
1132 | if ( m_refreshAfterThaw ) |
1133 | Refresh(); | |
1134 | } | |
1135 | ||
a4bbc9f7 VS |
1136 | void wxWindowMGL::HandlePaint(MGLDevCtx *dc) |
1137 | { | |
17808a75 | 1138 | if ( IsFrozen() ) |
a4bbc9f7 | 1139 | { |
7de59551 | 1140 | // Don't paint anything if the window is frozen. |
127eab18 | 1141 | m_refreshAfterThaw = true; |
a4bbc9f7 VS |
1142 | return; |
1143 | } | |
7de59551 | 1144 | |
4b6a582b | 1145 | #if wxDEBUG_LEVEL >= 2 |
82186005 VS |
1146 | // FIXME_MGL -- debugging stuff, to be removed! |
1147 | static int debugPaintEvents = -1; | |
1148 | if ( debugPaintEvents == -1 ) | |
1149 | debugPaintEvents = wxGetEnv(wxT("WXMGL_DEBUG_PAINT_EVENTS"), NULL); | |
1150 | if ( debugPaintEvents ) | |
1151 | { | |
1152 | dc->setColorRGB(255,0,255); | |
1153 | dc->fillRect(-1000,-1000,2000,2000); | |
06414d99 | 1154 | wxMilliSleep(50); |
82186005 | 1155 | } |
4b6a582b | 1156 | #endif // wxDEBUG_LEVEL >= 2 |
b8c0528d | 1157 | |
fd495ab3 VS |
1158 | MGLRegion clip; |
1159 | dc->getClipRegion(clip); | |
1160 | m_updateRegion = wxRegion(clip); | |
a4bbc9f7 VS |
1161 | m_paintMGLDC = dc; |
1162 | ||
a679e129 VS |
1163 | #if wxUSE_CARET |
1164 | // must hide caret temporarily, otherwise we'd get rendering artifacts | |
1165 | wxCaret *caret = GetCaret(); | |
1166 | if ( caret ) | |
1167 | caret->Hide(); | |
1168 | #endif // wxUSE_CARET | |
1169 | ||
2b260bc3 | 1170 | if ( m_eraseBackground != 0 ) |
7bdc1879 | 1171 | { |
2b260bc3 VS |
1172 | wxWindowDC dc((wxWindow*)this); |
1173 | wxEraseEvent eventEr(m_windowId, &dc); | |
1174 | eventEr.SetEventObject(this); | |
937013e0 | 1175 | HandleWindowEvent(eventEr); |
7bdc1879 | 1176 | } |
2b260bc3 | 1177 | m_eraseBackground = -1; |
a4bbc9f7 VS |
1178 | |
1179 | wxNcPaintEvent eventNc(GetId()); | |
1180 | eventNc.SetEventObject(this); | |
937013e0 | 1181 | HandleWindowEvent(eventNc); |
7de59551 | 1182 | |
a4bbc9f7 VS |
1183 | wxPaintEvent eventPt(GetId()); |
1184 | eventPt.SetEventObject(this); | |
937013e0 | 1185 | HandleWindowEvent(eventPt); |
a4bbc9f7 | 1186 | |
a679e129 VS |
1187 | #if wxUSE_CARET |
1188 | if ( caret ) | |
1189 | caret->Show(); | |
1190 | #endif // wxUSE_CARET | |
1191 | ||
7bdc1879 | 1192 | m_paintMGLDC = NULL; |
fd495ab3 | 1193 | m_updateRegion.Clear(); |
a4bbc9f7 VS |
1194 | } |
1195 | ||
1196 | ||
1197 | // Find the wxWindow at the current mouse position, returning the mouse | |
1198 | // position. | |
1199 | wxWindow* wxFindWindowAtPointer(wxPoint& pt) | |
1200 | { | |
1201 | return wxFindWindowAtPoint(pt = wxGetMousePosition()); | |
1202 | } | |
1203 | ||
1204 | wxWindow* wxFindWindowAtPoint(const wxPoint& pt) | |
1205 | { | |
1206 | window_t *wnd = MGL_wmGetWindowAtPosition(g_winMng, pt.x, pt.y); | |
1207 | return (wxWindow*)wnd->userData; | |
32b8ec41 | 1208 | } |