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