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