]> git.saurik.com Git - wxWidgets.git/blob - src/mgl/window.cpp
projects / wxWidgets.git / blob
? search:


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