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


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