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