src/dfb/window.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/dfb/window.cpp
   3 // Purpose:     wxWindow
   4 // Author:      Vaclav Slavik
   5 //              (based on GTK, MSW, MGL implementations)
   6 // Created:     2006-80-10
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2006 REA Elektronik GmbH
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/window.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/dcclient.h"
  31     #include "wx/nonownedwnd.h"
  32 #endif
  33
  34 #include "wx/caret.h"
  35 #include "wx/dynarray.h"
  36
  37 #include "wx/dfb/private.h"
  38 #include "wx/private/overlay.h"
  39
  40 #define TRACE_EVENTS _T("events")
  41 #define TRACE_PAINT  _T("paint")
  42
  43 // ===========================================================================
  44 // implementation
  45 // ===========================================================================
  46
  47 // ---------------------------------------------------------------------------
  48 // global variables
  49 // ---------------------------------------------------------------------------
  50
  51 // the window that has keyboard focus:
  52 static wxWindowDFB *gs_focusedWindow = NULL;
  53 // the window that is about to be focused after currently focused
  54 // one looses focus:
  55 static wxWindow *gs_toBeFocusedWindow = NULL;
  56 // the window that has mouse capture
  57 static wxWindowDFB *gs_mouseCapture = NULL;
  58
  59 // ---------------------------------------------------------------------------
  60 // overlays support
  61 // ---------------------------------------------------------------------------
  62
  63 WX_DEFINE_ARRAY_PTR(wxOverlayImpl*, wxDfbOverlaysList);
  64
  65 // ---------------------------------------------------------------------------
  66 // event tables
  67 // ---------------------------------------------------------------------------
  68
  69 // in wxUniv this class is abstract because it doesn't have DoPopupMenu()
  70 IMPLEMENT_ABSTRACT_CLASS(wxWindowDFB, wxWindowBase)
  71
  72 BEGIN_EVENT_TABLE(wxWindowDFB, wxWindowBase)
  73 END_EVENT_TABLE()
  74
  75 // ----------------------------------------------------------------------------
  76 // constructors and such
  77 // ----------------------------------------------------------------------------
  78
  79 void wxWindowDFB::Init()
  80 {
  81     m_isShown = true;
  82     m_frozenness = 0;
  83     m_tlw = NULL;
  84     m_overlays = NULL;
  85 }
  86
  87 // Destructor
  88 wxWindowDFB::~wxWindowDFB()
  89 {
  90     SendDestroyEvent();
  91
  92     m_isBeingDeleted = true;
  93
  94     if ( gs_mouseCapture == this )
  95         ReleaseMouse();
  96
  97     if ( gs_focusedWindow == this )
  98         DFBKillFocus();
  99
 100     DestroyChildren();
 101 }
 102
 103 // real construction (Init() must have been called before!)
 104 bool wxWindowDFB::Create(wxWindow *parent,
 105                          wxWindowID id,
 106                          const wxPoint& pos,
 107                          const wxSize& size,
 108                          long style,
 109                          const wxString& name)
 110 {
 111     if ( !m_tlw && parent )
 112         m_tlw = parent->GetTLW();
 113
 114     if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
 115         return false;
 116
 117     if ( parent )
 118         parent->AddChild(this);
 119
 120     // set the size to something bogus initially, in case some code tries to
 121     // create wxWindowDC before SetSize() is called below:
 122     m_rect.width = m_rect.height = 1;
 123
 124     int x, y, w, h;
 125     x = pos.x, y = pos.y;
 126     if ( x == -1  ) x = 0;
 127     if ( y == -1 ) y = 0;
 128     w = WidthDefault(size.x);
 129     h = HeightDefault(size.y);
 130     SetSize(x, y, w, h);
 131
 132     return true;
 133 }
 134
 135 // ---------------------------------------------------------------------------
 136 // surface access
 137 // ---------------------------------------------------------------------------
 138
 139 wxIDirectFBSurfacePtr wxWindowDFB::ObtainDfbSurface() const
 140 {
 141     wxCHECK_MSG( m_parent, NULL, _T("parentless window?") );
 142
 143     wxIDirectFBSurfacePtr parentSurface(m_parent->GetDfbSurface());
 144     wxCHECK_MSG( parentSurface, NULL, _T("invalid parent surface") );
 145
 146     wxRect r(GetRect());
 147     AdjustForParentClientOrigin(r.x, r.y, 0);
 148     DFBRectangle rect = { r.x, r.y, r.width, r.height };
 149
 150     return parentSurface->GetSubSurface(&rect);
 151 }
 152
 153 wxIDirectFBSurfacePtr wxWindowDFB::GetDfbSurface()
 154 {
 155     if ( !m_surface )
 156     {
 157         m_surface = ObtainDfbSurface();
 158         wxASSERT_MSG( m_surface, _T("invalid DirectFB surface") );
 159     }
 160
 161     return m_surface;
 162 }
 163
 164 void wxWindowDFB::InvalidateDfbSurface()
 165 {
 166     m_surface = NULL;
 167
 168     // surfaces of the children are subsurfaces of this window's surface,
 169     // so they must be invalidated as well:
 170     wxWindowList& children = GetChildren();
 171     for ( wxWindowList::iterator i = children.begin(); i != children.end(); ++i )
 172     {
 173         (*i)->InvalidateDfbSurface();
 174     }
 175 }
 176
 177 // ---------------------------------------------------------------------------
 178 // basic operations
 179 // ---------------------------------------------------------------------------
 180
 181 void wxWindowDFB::SetFocus()
 182 {
 183     if ( gs_focusedWindow == this )
 184         return; // nothing to do, focused already
 185
 186     wxWindowDFB *oldFocusedWindow = gs_focusedWindow;
 187
 188     if ( gs_focusedWindow )
 189     {
 190         gs_toBeFocusedWindow = (wxWindow*)this;
 191         gs_focusedWindow->DFBKillFocus();
 192         gs_toBeFocusedWindow = NULL;
 193     }
 194
 195     gs_focusedWindow = this;
 196
 197     if ( IsShownOnScreen() &&
 198          (!oldFocusedWindow || oldFocusedWindow->GetTLW() != m_tlw) )
 199     {
 200         m_tlw->SetDfbFocus();
 201     }
 202     // else: do nothing, because DirectFB windows cannot have focus if they
 203     //       are hidden; when the TLW becomes visible, it will set the focus
 204     //       to use from wxTLW::Show()
 205
 206     // notify the parent keeping track of focus for the kbd navigation
 207     // purposes that we got it
 208     wxChildFocusEvent eventFocus((wxWindow*)this);
 209     GetEventHandler()->ProcessEvent(eventFocus);
 210
 211     wxFocusEvent event(wxEVT_SET_FOCUS, GetId());
 212     event.SetEventObject(this);
 213     event.SetWindow((wxWindow*)oldFocusedWindow);
 214     GetEventHandler()->ProcessEvent(event);
 215
 216 #if wxUSE_CARET
 217     // caret needs to be informed about focus change
 218     wxCaret *caret = GetCaret();
 219     if ( caret )
 220         caret->OnSetFocus();
 221 #endif // wxUSE_CARET
 222 }
 223
 224 void wxWindowDFB::DFBKillFocus()
 225 {
 226     wxCHECK_RET( gs_focusedWindow == this,
 227                  _T("killing focus on window that doesn't have it") );
 228
 229     gs_focusedWindow = NULL;
 230
 231     if ( m_isBeingDeleted )
 232         return; // don't send any events from dtor
 233
 234 #if wxUSE_CARET
 235     // caret needs to be informed about focus change
 236     wxCaret *caret = GetCaret();
 237     if ( caret )
 238         caret->OnKillFocus();
 239 #endif // wxUSE_CARET
 240
 241     wxFocusEvent event(wxEVT_KILL_FOCUS, GetId());
 242     event.SetEventObject(this);
 243     event.SetWindow(gs_toBeFocusedWindow);
 244     GetEventHandler()->ProcessEvent(event);
 245 }
 246
 247 // ----------------------------------------------------------------------------
 248 // this wxWindowBase function is implemented here (in platform-specific file)
 249 // because it is static and so couldn't be made virtual
 250 // ----------------------------------------------------------------------------
 251 wxWindow *wxWindowBase::DoFindFocus()
 252 {
 253     return (wxWindow*)gs_focusedWindow;
 254 }
 255
 256 bool wxWindowDFB::Show(bool show)
 257 {
 258     if ( !wxWindowBase::Show(show) )
 259         return false;
 260
 261     // Unlike Refresh(), DoRefreshWindow() doesn't check visibility, so
 262     // call it to force refresh of either this window (if showing) or its
 263     // parent area at the place of this window (if hiding):
 264     DoRefreshWindow();
 265
 266     return true;
 267 }
 268
 269 // Raise the window to the top of the Z order
 270 void wxWindowDFB::Raise()
 271 {
 272     wxFAIL_MSG( _T("Raise() not implemented") );
 273 }
 274
 275 // Lower the window to the bottom of the Z order
 276 void wxWindowDFB::Lower()
 277 {
 278     wxFAIL_MSG( _T("Lower() not implemented") );
 279 }
 280
 281 void wxWindowDFB::DoCaptureMouse()
 282 {
 283 #warning "implement this"
 284 #if 0
 285     if ( gs_mouseCapture )
 286         DFB_wmUncaptureEvents(gs_mouseCapture->m_wnd, wxDFB_CAPTURE_MOUSE);
 287 #endif
 288     gs_mouseCapture = this;
 289 #if 0
 290     DFB_wmCaptureEvents(m_wnd, EVT_MOUSEEVT, wxDFB_CAPTURE_MOUSE);
 291 #endif
 292 }
 293
 294 void wxWindowDFB::DoReleaseMouse()
 295 {
 296     wxASSERT_MSG( gs_mouseCapture == this, wxT("attempt to release mouse, but this window hasn't captured it") );
 297
 298 #warning "implement this"
 299 #if 0
 300     DFB_wmUncaptureEvents(m_wnd, wxDFB_CAPTURE_MOUSE);
 301 #endif
 302     gs_mouseCapture = NULL;
 303 }
 304
 305 /* static */ wxWindow *wxWindowBase::GetCapture()
 306 {
 307     return (wxWindow*)gs_mouseCapture;
 308 }
 309
 310 bool wxWindowDFB::SetCursor(const wxCursor& cursor)
 311 {
 312     if ( !wxWindowBase::SetCursor(cursor) )
 313     {
 314         // no change
 315         return false;
 316     }
 317
 318 #warning "implement this"
 319 #if 0
 320     if ( m_cursor.Ok() )
 321         DFB_wmSetWindowCursor(m_wnd, *m_cursor.GetDFBCursor());
 322     else
 323         DFB_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetDFBCursor());
 324 #endif
 325
 326     return true;
 327 }
 328
 329 void wxWindowDFB::WarpPointer(int x, int y)
 330 {
 331     int w, h;
 332     wxDisplaySize(&w, &h);
 333
 334     ClientToScreen(&x, &y);
 335     if ( x < 0 ) x = 0;
 336     if ( y < 0 ) y = 0;
 337     if ( x >= w ) x = w-1;
 338     if ( y >= h ) y = h-1;
 339
 340     wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
 341     wxCHECK_RET( layer, _T("no display layer") );
 342
 343     layer->WarpCursor(x, y);
 344 }
 345
 346 // Set this window to be the child of 'parent'.
 347 bool wxWindowDFB::Reparent(wxWindowBase *parent)
 348 {
 349     if ( !wxWindowBase::Reparent(parent) )
 350         return false;
 351
 352 #warning "implement this"
 353     wxFAIL_MSG( _T("reparenting not yet implemented") );
 354
 355     return true;
 356 }
 357
 358 // ---------------------------------------------------------------------------
 359 // moving and resizing
 360 // ---------------------------------------------------------------------------
 361
 362 // Get total size
 363 void wxWindowDFB::DoGetSize(int *x, int *y) const
 364 {
 365     if (x) *x = m_rect.width;
 366     if (y) *y = m_rect.height;
 367 }
 368
 369 void wxWindowDFB::DoGetPosition(int *x, int *y) const
 370 {
 371     if (x) *x = m_rect.x;
 372     if (y) *y = m_rect.y;
 373 }
 374
 375 static wxPoint GetScreenPosOfClientOrigin(const wxWindowDFB *win)
 376 {
 377     wxCHECK_MSG( win, wxPoint(0, 0), _T("no window provided") );
 378
 379     wxPoint pt(win->GetPosition() + win->GetClientAreaOrigin());
 380
 381     if ( !win->IsTopLevel() )
 382         pt += GetScreenPosOfClientOrigin(win->GetParent());
 383
 384     return pt;
 385 }
 386
 387 void wxWindowDFB::DoScreenToClient(int *x, int *y) const
 388 {
 389     wxPoint o = GetScreenPosOfClientOrigin(this);
 390
 391     if (x) *x -= o.x;
 392     if (y) *y -= o.y;
 393 }
 394
 395 void wxWindowDFB::DoClientToScreen(int *x, int *y) const
 396 {
 397     wxPoint o = GetScreenPosOfClientOrigin(this);
 398
 399     if (x) *x += o.x;
 400     if (y) *y += o.y;
 401 }
 402
 403 // Get size *available for subwindows* i.e. excluding menu bar etc.
 404 void wxWindowDFB::DoGetClientSize(int *x, int *y) const
 405 {
 406     DoGetSize(x, y);
 407 }
 408
 409 void wxWindowDFB::DoMoveWindow(int x, int y, int width, int height)
 410 {
 411     // NB: [x,y] arguments are in (parent's) window coordinates, while
 412     //     m_rect.{x,y} are in (parent's) client coordinates. That's why we
 413     //     offset by parentOrigin in some places below
 414
 415     wxPoint parentOrigin(0, 0);
 416     AdjustForParentClientOrigin(parentOrigin.x, parentOrigin.y);
 417
 418     wxRect oldpos(m_rect);
 419     oldpos.Offset(parentOrigin);
 420
 421     wxRect newpos(x, y, width, height);
 422
 423     // input [x,y] is in window coords, but we store client coords in m_rect:
 424     m_rect = newpos;
 425     m_rect.Offset(-parentOrigin);
 426
 427     // window's position+size changed and so did the subsurface that covers it
 428     InvalidateDfbSurface();
 429
 430     if ( IsShown() )
 431     {
 432         // queue both former and new position of the window for repainting:
 433         wxWindow *parent = GetParent();
 434
 435         // only refresh the visible parts:
 436         if ( !CanBeOutsideClientArea() )
 437         {
 438             wxRect parentClient(parent->GetClientSize());
 439             oldpos.Intersect(parentClient);
 440             newpos.Intersect(parentClient);
 441         }
 442
 443         parent->RefreshRect(oldpos);
 444         parent->RefreshRect(newpos);
 445     }
 446 }
 447
 448 // set the size of the window: if the dimensions are positive, just use them,
 449 // but if any of them is equal to -1, it means that we must find the value for
 450 // it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
 451 // which case -1 is a valid value for x and y)
 452 //
 453 // If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
 454 // the width/height to best suit our contents, otherwise we reuse the current
 455 // width/height
 456 void wxWindowDFB::DoSetSize(int x, int y, int width, int height, int sizeFlags)
 457 {
 458     // get the current size and position...
 459     int currentX, currentY;
 460     GetPosition(&currentX, &currentY);
 461     int currentW,currentH;
 462     GetSize(&currentW, &currentH);
 463
 464     if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 465         x = currentX;
 466     if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 467         y = currentY;
 468
 469     // ... and don't do anything (avoiding flicker) if it's already ok
 470     if ( x == currentX && y == currentY &&
 471          width == currentW && height == currentH )
 472     {
 473         return;
 474     }
 475
 476     wxSize size(-1, -1);
 477     if ( width == -1 )
 478     {
 479         if ( sizeFlags & wxSIZE_AUTO_WIDTH )
 480         {
 481             size = DoGetBestSize();
 482             width = size.x;
 483         }
 484         else
 485         {
 486             // just take the current one
 487             width = currentW;
 488         }
 489     }
 490
 491     if ( height == -1 )
 492     {
 493         if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
 494         {
 495             if ( size.x == -1 )
 496             {
 497                 size = DoGetBestSize();
 498             }
 499             //else: already called DoGetBestSize() above
 500
 501             height = size.y;
 502         }
 503         else
 504         {
 505             // just take the current one
 506             height = currentH;
 507         }
 508     }
 509
 510     int maxWidth = GetMaxWidth(),
 511         minWidth = GetMinWidth(),
 512         maxHeight = GetMaxHeight(),
 513         minHeight = GetMinHeight();
 514
 515     if ( minWidth != -1 && width < minWidth ) width = minWidth;
 516     if ( maxWidth != -1 && width > maxWidth ) width = maxWidth;
 517     if ( minHeight != -1 && height < minHeight ) height = minHeight;
 518     if ( maxHeight != -1 && height > maxHeight ) height = maxHeight;
 519
 520     if ( m_rect.x != x || m_rect.y != y ||
 521          m_rect.width != width || m_rect.height != height )
 522     {
 523         AdjustForParentClientOrigin(x, y, sizeFlags);
 524         DoMoveWindow(x, y, width, height);
 525
 526         wxSize newSize(width, height);
 527         wxSizeEvent event(newSize, GetId());
 528         event.SetEventObject(this);
 529         GetEventHandler()->ProcessEvent(event);
 530     }
 531 }
 532
 533 void wxWindowDFB::DoSetClientSize(int width, int height)
 534 {
 535     SetSize(width, height);
 536 }
 537
 538 // ---------------------------------------------------------------------------
 539 // text metrics
 540 // ---------------------------------------------------------------------------
 541
 542 int wxWindowDFB::GetCharHeight() const
 543 {
 544     wxWindowDC dc((wxWindow*)this);
 545     return dc.GetCharHeight();
 546 }
 547
 548 int wxWindowDFB::GetCharWidth() const
 549 {
 550     wxWindowDC dc((wxWindow*)this);
 551     return dc.GetCharWidth();
 552 }
 553
 554 void wxWindowDFB::GetTextExtent(const wxString& string,
 555                              int *x, int *y,
 556                              int *descent, int *externalLeading,
 557                              const wxFont *theFont) const
 558 {
 559     wxWindowDC dc((wxWindow*)this);
 560     dc.GetTextExtent(string, x, y, descent, externalLeading, (wxFont*)theFont);
 561 }
 562
 563
 564 // ---------------------------------------------------------------------------
 565 // painting
 566 // ---------------------------------------------------------------------------
 567
 568 void wxWindowDFB::Clear()
 569 {
 570     wxClientDC dc((wxWindow *)this);
 571     wxBrush brush(GetBackgroundColour(), wxSOLID);
 572     dc.SetBackground(brush);
 573     dc.Clear();
 574 }
 575
 576 void wxWindowDFB::Refresh(bool WXUNUSED(eraseBack), const wxRect *rect)
 577 {
 578     if ( !IsShown() || IsFrozen() )
 579         return;
 580
 581     // NB[1]: We intentionally ignore the eraseBack argument here. This is
 582     //        because of the way wxDFB's painting is implemented: the refresh
 583     //        request is propagated up to wxTLW, which is then painted in
 584     //        top-down order. This means that this window's area is first
 585     //        painted by its parent and this window is then painted over it, so
 586     //        it's not safe to not paint this window's background even if
 587     //        eraseBack=false.
 588     // NB[2]: wxWindow::Refresh() takes the rectangle in client coords, but
 589     //        wxUniv translates it to window coords before passing it to
 590     //        wxWindowDFB::Refresh(), so we can directly pass the rect to
 591     //        DoRefreshRect (which takes window, not client, coords) here.
 592     if ( rect )
 593         DoRefreshRect(*rect);
 594     else
 595         DoRefreshWindow();
 596 }
 597
 598 void wxWindowDFB::RefreshWindowRect(const wxRect& rect)
 599 {
 600     if ( !IsShown() || IsFrozen() )
 601         return;
 602
 603     DoRefreshRect(rect);
 604 }
 605
 606 void wxWindowDFB::DoRefreshWindow()
 607 {
 608     // NB: DoRefreshRect() takes window coords, not client, so this is correct
 609     DoRefreshRect(wxRect(GetSize()));
 610 }
 611
 612 void wxWindowDFB::DoRefreshRect(const wxRect& rect)
 613 {
 614     wxWindow *parent = GetParent();
 615     wxCHECK_RET( parent, _T("no parent") );
 616
 617     // don't overlap outside of the window (NB: 'rect' is in window coords):
 618     wxRect r(rect);
 619     r.Intersect(wxRect(GetSize()));
 620     if ( r.IsEmpty() )
 621         return;
 622
 623     wxLogTrace(TRACE_PAINT,
 624                _T("%p ('%s'): refresh rect [%i,%i,%i,%i]"),
 625                this, GetName().c_str(),
 626                rect.x, rect.y, rect.GetRight(), rect.GetBottom());
 627
 628     // convert the refresh rectangle to parent's coordinates and
 629     // recursively refresh the parent:
 630     r.Offset(GetPosition());
 631     r.Offset(parent->GetClientAreaOrigin());
 632
 633     // normal windows cannot extend out of its parent's client area, so don't
 634     // refresh any hidden parts:
 635     if ( !CanBeOutsideClientArea() )
 636         r.Intersect(parent->GetClientRect());
 637
 638     parent->DoRefreshRect(r);
 639 }
 640
 641 void wxWindowDFB::Update()
 642 {
 643     if ( !IsShown() || IsFrozen() )
 644         return;
 645
 646     GetParent()->Update();
 647 }
 648
 649 void wxWindowDFB::Freeze()
 650 {
 651     m_frozenness++;
 652 }
 653
 654 void wxWindowDFB::Thaw()
 655 {
 656     wxASSERT_MSG( IsFrozen(), _T("Thaw() without matching Freeze()") );
 657
 658     if ( --m_frozenness == 0 )
 659     {
 660         if ( IsShown() )
 661             DoRefreshWindow();
 662     }
 663 }
 664
 665 void wxWindowDFB::PaintWindow(const wxRect& rect)
 666 {
 667     wxCHECK_RET( !IsFrozen() && IsShown(), _T("shouldn't be called") );
 668
 669     wxLogTrace(TRACE_PAINT,
 670                _T("%p ('%s'): painting region [%i,%i,%i,%i]"),
 671                this, GetName().c_str(),
 672                rect.x, rect.y, rect.GetRight(), rect.GetBottom());
 673
 674     m_updateRegion = rect;
 675
 676     // FIXME_DFB: don't waste time rendering the area if it's fully covered
 677     //            by some children, go directly to rendering the children
 678
 679     // NB: unconditionally send wxEraseEvent, because our implementation of
 680     //     wxWindow::Refresh() ignores the eraseBack argument
 681     wxWindowDC dc((wxWindow*)this);
 682     wxEraseEvent eventEr(m_windowId, &dc);
 683     eventEr.SetEventObject(this);
 684     GetEventHandler()->ProcessEvent(eventEr);
 685
 686     wxRect clientRect(GetClientRect());
 687
 688     // only send wxNcPaintEvent if drawing at least part of nonclient area:
 689     if ( !clientRect.Contains(rect) )
 690     {
 691         wxNcPaintEvent eventNc(GetId());
 692         eventNc.SetEventObject(this);
 693         GetEventHandler()->ProcessEvent(eventNc);
 694     }
 695     else
 696     {
 697         wxLogTrace(TRACE_PAINT, _T("%p ('%s'): not sending wxNcPaintEvent"),
 698                    this, GetName().c_str());
 699     }
 700
 701     // only send wxPaintEvent if drawing at least part of client area:
 702     if ( rect.Intersects(clientRect) )
 703     {
 704         wxPaintEvent eventPt(GetId());
 705         eventPt.SetEventObject(this);
 706         GetEventHandler()->ProcessEvent(eventPt);
 707     }
 708     else
 709     {
 710         wxLogTrace(TRACE_PAINT, _T("%p ('%s'): not sending wxPaintEvent"),
 711                    this, GetName().c_str());
 712     }
 713
 714     // draw window's overlays on top of the painted window, if we have any:
 715     PaintOverlays(rect);
 716
 717     m_updateRegion.Clear();
 718
 719     // client area portion of 'rect':
 720     wxRect rectClientOnly(rect);
 721     rectClientOnly.Intersect(clientRect);
 722
 723     // paint the children:
 724     wxPoint origin = GetClientAreaOrigin();
 725     wxWindowList& children = GetChildren();
 726     for ( wxWindowList::iterator i = children.begin();
 727           i != children.end(); ++i )
 728     {
 729         wxWindow *child = *i;
 730
 731         if ( child->IsFrozen() || !child->IsShown() )
 732             continue; // don't paint anything if the window is frozen or hidden
 733
 734         // compute child's area to repaint
 735         wxRect childrect(child->GetRect());
 736         childrect.Offset(origin);
 737
 738         if ( child->CanBeOutsideClientArea() )
 739             childrect.Intersect(rect);
 740         else
 741             childrect.Intersect(rectClientOnly);
 742
 743         if ( childrect.IsEmpty() )
 744             continue;
 745
 746         // and repaint it:
 747         childrect.Offset(-child->GetPosition());
 748         childrect.Offset(-origin);
 749         child->PaintWindow(childrect);
 750     }
 751 }
 752
 753 void wxWindowDFB::PaintOverlays(const wxRect& rect)
 754 {
 755     if ( !m_overlays )
 756         return;
 757
 758     for ( wxDfbOverlaysList::const_iterator i = m_overlays->begin();
 759           i != m_overlays->end(); ++i )
 760     {
 761         // FIXME: the cast is necessary for STL build where the iterator
 762         //        (incorrectly) returns void* and not wxOverlayImpl*
 763         wxOverlayImpl *overlay = (wxOverlayImpl*) *i;
 764
 765         wxRect orectOrig(overlay->GetRect());
 766         wxRect orect(orectOrig);
 767         orect.Intersect(rect);
 768         if ( orect.IsEmpty() )
 769             continue;
 770
 771         if ( overlay->IsEmpty() )
 772             continue; // nothing to paint
 773
 774         DFBRectangle dfbRect = { orect.x - orectOrig.x, orect.y - orectOrig.y,
 775                                  orect.width, orect.height };
 776         GetDfbSurface()->Blit
 777                          (
 778                            overlay->GetDirectFBSurface(),
 779                            &dfbRect,
 780                            orect.x, orect.y
 781                          );
 782     }
 783 }
 784
 785 void wxWindowDFB::AddOverlay(wxOverlayImpl *overlay)
 786 {
 787     if ( !m_overlays )
 788         m_overlays = new wxDfbOverlaysList;
 789
 790     m_overlays->Add(overlay);
 791 }
 792
 793 void wxWindowDFB::RemoveOverlay(wxOverlayImpl *overlay)
 794 {
 795     wxCHECK_RET( m_overlays, _T("no overlays to remove") );
 796
 797     m_overlays->Remove(overlay);
 798
 799     if ( m_overlays->empty() )
 800     {
 801         wxDELETE(m_overlays);
 802     }
 803
 804     if ( !m_isBeingDeleted )
 805         RefreshWindowRect(overlay->GetRect());
 806 }
 807
 808
 809 // ---------------------------------------------------------------------------
 810 // events handling
 811 // ---------------------------------------------------------------------------
 812
 813 #define KEY(dfb, wx)                                                \
 814     case dfb:                                                       \
 815           wxLogTrace(TRACE_EVENTS,                                  \
 816                      _T("key " #dfb " mapped to " #wx));            \
 817           return wx
 818
 819 // returns translated keycode, i.e. the one for KEYUP/KEYDOWN where 'a'..'z' is
 820 // translated to 'A'..'Z'
 821 static long GetTranslatedKeyCode(DFBInputDeviceKeyIdentifier key_id)
 822 {
 823     switch ( key_id )
 824     {
 825         KEY(DIKI_UNKNOWN,           0);
 826
 827         KEY(DIKI_A,                 'A');
 828         KEY(DIKI_B,                 'B');
 829         KEY(DIKI_C,                 'C');
 830         KEY(DIKI_D,                 'D');
 831         KEY(DIKI_E,                 'E');
 832         KEY(DIKI_F,                 'F');
 833         KEY(DIKI_G,                 'G');
 834         KEY(DIKI_H,                 'H');
 835         KEY(DIKI_I,                 'I');
 836         KEY(DIKI_J,                 'J');
 837         KEY(DIKI_K,                 'K');
 838         KEY(DIKI_L,                 'L');
 839         KEY(DIKI_M,                 'M');
 840         KEY(DIKI_N,                 'N');
 841         KEY(DIKI_O,                 'O');
 842         KEY(DIKI_P,                 'P');
 843         KEY(DIKI_Q,                 'Q');
 844         KEY(DIKI_R,                 'R');
 845         KEY(DIKI_S,                 'S');
 846         KEY(DIKI_T,                 'T');
 847         KEY(DIKI_U,                 'U');
 848         KEY(DIKI_V,                 'V');
 849         KEY(DIKI_W,                 'W');
 850         KEY(DIKI_X,                 'X');
 851         KEY(DIKI_Y,                 'Y');
 852         KEY(DIKI_Z,                 'Z');
 853
 854         KEY(DIKI_0,                 '0');
 855         KEY(DIKI_1,                 '1');
 856         KEY(DIKI_2,                 '2');
 857         KEY(DIKI_3,                 '3');
 858         KEY(DIKI_4,                 '4');
 859         KEY(DIKI_5,                 '5');
 860         KEY(DIKI_6,                 '6');
 861         KEY(DIKI_7,                 '7');
 862         KEY(DIKI_8,                 '8');
 863         KEY(DIKI_9,                 '9');
 864
 865         KEY(DIKI_F1,                WXK_F1);
 866         KEY(DIKI_F2,                WXK_F2);
 867         KEY(DIKI_F3,                WXK_F3);
 868         KEY(DIKI_F4,                WXK_F4);
 869         KEY(DIKI_F5,                WXK_F5);
 870         KEY(DIKI_F6,                WXK_F6);
 871         KEY(DIKI_F7,                WXK_F7);
 872         KEY(DIKI_F8,                WXK_F8);
 873         KEY(DIKI_F9,                WXK_F9);
 874         KEY(DIKI_F10,               WXK_F10);
 875         KEY(DIKI_F11,               WXK_F11);
 876         KEY(DIKI_F12,               WXK_F12);
 877
 878         KEY(DIKI_SHIFT_L,           WXK_SHIFT);
 879         KEY(DIKI_SHIFT_R,           WXK_SHIFT);
 880         KEY(DIKI_CONTROL_L,         WXK_CONTROL);
 881         KEY(DIKI_CONTROL_R,         WXK_CONTROL);
 882         KEY(DIKI_ALT_L,             WXK_ALT);
 883         KEY(DIKI_ALT_R,             WXK_ALT);
 884         // this key was removed in 0.9.25 but include it for previous versions
 885         // just to avoid gcc warnings about unhandled enum value in switch
 886 #if !wxCHECK_DFB_VERSION(0, 9, 24)
 887         KEY(DIKI_ALTGR,             0);
 888 #endif
 889         KEY(DIKI_META_L,            0);
 890         KEY(DIKI_META_R,            0);
 891         KEY(DIKI_SUPER_L,           0);
 892         KEY(DIKI_SUPER_R,           0);
 893         KEY(DIKI_HYPER_L,           0);
 894         KEY(DIKI_HYPER_R,           0);
 895
 896         KEY(DIKI_CAPS_LOCK,         0);
 897         KEY(DIKI_NUM_LOCK,          WXK_NUMLOCK);
 898         KEY(DIKI_SCROLL_LOCK,       0);
 899
 900         KEY(DIKI_ESCAPE,            WXK_ESCAPE);
 901         KEY(DIKI_LEFT,              WXK_LEFT);
 902         KEY(DIKI_RIGHT,             WXK_RIGHT);
 903         KEY(DIKI_UP,                WXK_UP);
 904         KEY(DIKI_DOWN,              WXK_DOWN);
 905         KEY(DIKI_TAB,               WXK_TAB);
 906         KEY(DIKI_ENTER,             WXK_RETURN);
 907         KEY(DIKI_SPACE,             WXK_SPACE);
 908         KEY(DIKI_BACKSPACE,         WXK_BACK);
 909         KEY(DIKI_INSERT,            WXK_INSERT);
 910         KEY(DIKI_DELETE,            WXK_DELETE);
 911         KEY(DIKI_HOME,              WXK_HOME);
 912         KEY(DIKI_END,               WXK_END);
 913         KEY(DIKI_PAGE_UP,           WXK_PAGEUP);
 914         KEY(DIKI_PAGE_DOWN,         WXK_PAGEDOWN);
 915         KEY(DIKI_PRINT,             WXK_PRINT);
 916         KEY(DIKI_PAUSE,             WXK_PAUSE);
 917
 918         KEY(DIKI_QUOTE_LEFT,        '`');
 919         KEY(DIKI_MINUS_SIGN,        '-');
 920         KEY(DIKI_EQUALS_SIGN,       '=');
 921         KEY(DIKI_BRACKET_LEFT,      '[');
 922         KEY(DIKI_BRACKET_RIGHT,     ']');
 923         KEY(DIKI_BACKSLASH,         '\\');
 924         KEY(DIKI_SEMICOLON,         ';');
 925         KEY(DIKI_QUOTE_RIGHT,       '\'');
 926         KEY(DIKI_COMMA,             ',');
 927         KEY(DIKI_PERIOD,            '.');
 928         KEY(DIKI_SLASH,             '/');
 929
 930         KEY(DIKI_LESS_SIGN,         '<');
 931
 932         KEY(DIKI_KP_DIV,            WXK_NUMPAD_DIVIDE);
 933         KEY(DIKI_KP_MULT,           WXK_NUMPAD_MULTIPLY);
 934         KEY(DIKI_KP_MINUS,          WXK_NUMPAD_SUBTRACT);
 935         KEY(DIKI_KP_PLUS,           WXK_NUMPAD_ADD);
 936         KEY(DIKI_KP_ENTER,          WXK_NUMPAD_ENTER);
 937         KEY(DIKI_KP_SPACE,          WXK_NUMPAD_SPACE);
 938         KEY(DIKI_KP_TAB,            WXK_NUMPAD_TAB);
 939         KEY(DIKI_KP_F1,             WXK_NUMPAD_F1);
 940         KEY(DIKI_KP_F2,             WXK_NUMPAD_F2);
 941         KEY(DIKI_KP_F3,             WXK_NUMPAD_F3);
 942         KEY(DIKI_KP_F4,             WXK_NUMPAD_F4);
 943         KEY(DIKI_KP_EQUAL,          WXK_NUMPAD_EQUAL);
 944         KEY(DIKI_KP_SEPARATOR,      WXK_NUMPAD_SEPARATOR);
 945
 946         KEY(DIKI_KP_DECIMAL,        WXK_NUMPAD_DECIMAL);
 947         KEY(DIKI_KP_0,              WXK_NUMPAD0);
 948         KEY(DIKI_KP_1,              WXK_NUMPAD1);
 949         KEY(DIKI_KP_2,              WXK_NUMPAD2);
 950         KEY(DIKI_KP_3,              WXK_NUMPAD3);
 951         KEY(DIKI_KP_4,              WXK_NUMPAD4);
 952         KEY(DIKI_KP_5,              WXK_NUMPAD5);
 953         KEY(DIKI_KP_6,              WXK_NUMPAD6);
 954         KEY(DIKI_KP_7,              WXK_NUMPAD7);
 955         KEY(DIKI_KP_8,              WXK_NUMPAD8);
 956         KEY(DIKI_KP_9,              WXK_NUMPAD9);
 957
 958         case DIKI_KEYDEF_END:
 959         case DIKI_NUMBER_OF_KEYS:
 960             wxFAIL_MSG( _T("invalid key_id value") );
 961             return 0;
 962     }
 963
 964     return 0; // silence compiler warnings
 965 }
 966
 967 // returns untranslated keycode, i.e. for EVT_CHAR, where characters are left in
 968 // the form they were entered (lowercase, diacritics etc.)
 969 static long GetUntraslatedKeyCode(DFBInputDeviceKeyIdentifier key_id,
 970                                   DFBInputDeviceKeySymbol key_symbol)
 971 {
 972     switch ( DFB_KEY_TYPE(key_symbol) )
 973     {
 974         case DIKT_UNICODE:
 975 #if wxUSE_UNICODE
 976             return key_symbol;
 977 #else
 978             if ( key_symbol < 128 )
 979                 return key_symbol;
 980             else
 981             {
 982 #if wxUSE_WCHAR_T
 983                 wchar_t chr = key_symbol;
 984                 wxCharBuffer buf(wxConvUI->cWC2MB(&chr, 1, NULL));
 985                 if ( buf )
 986                     return *buf; // may be 0 if failed
 987                 else
 988 #endif // wxUSE_WCHAR_T
 989                     return 0;
 990             }
 991 #endif
 992
 993         default:
 994             return GetTranslatedKeyCode(key_id);
 995     }
 996 }
 997
 998 #undef KEY
 999
1000 void wxWindowDFB::HandleKeyEvent(const wxDFBWindowEvent& event_)
1001 {
1002     if ( !IsEnabled() )
1003         return;
1004
1005     const DFBWindowEvent& e = event_;
1006
1007     wxLogTrace(TRACE_EVENTS,
1008                _T("handling key %s event for window %p ('%s')"),
1009                e.type == DWET_KEYUP ? _T("up") : _T("down"),
1010                this, GetName().c_str());
1011
1012     // fill in wxKeyEvent fields:
1013     wxKeyEvent event;
1014     event.SetEventObject(this);
1015     event.SetTimestamp(wxDFB_EVENT_TIMESTAMP(e));
1016     event.m_rawCode = e.key_code;
1017     event.m_keyCode = GetTranslatedKeyCode(e.key_id);
1018     event.m_scanCode = 0; // not used by wx at all
1019 #if wxUSE_UNICODE
1020     event.m_uniChar = e.key_symbol;
1021 #endif
1022     event.m_shiftDown = ( e.modifiers & DIMM_SHIFT ) != 0;
1023     event.m_controlDown = ( e.modifiers & DIMM_CONTROL ) != 0;
1024     event.m_altDown = ( e.modifiers & DIMM_ALT ) != 0;
1025     event.m_metaDown = ( e.modifiers & DIMM_META ) != 0;
1026
1027     // translate coordinates from TLW-relative to this window-relative:
1028     event.m_x = e.x;
1029     event.m_y = e.y;
1030     GetTLW()->ClientToScreen(&event.m_x, &event.m_y);
1031     this->ScreenToClient(&event.m_x, &event.m_y);
1032
1033     if ( e.type == DWET_KEYUP )
1034     {
1035         event.SetEventType(wxEVT_KEY_UP);
1036         GetEventHandler()->ProcessEvent(event);
1037     }
1038     else
1039     {
1040         bool isTab = (event.m_keyCode == WXK_TAB);
1041
1042         event.SetEventType(wxEVT_KEY_DOWN);
1043
1044         if ( GetEventHandler()->ProcessEvent(event) )
1045             return;
1046
1047         // only send wxEVT_CHAR event if not processed yet:
1048         event.m_keyCode = GetUntraslatedKeyCode(e.key_id, e.key_symbol);
1049         if ( event.m_keyCode != 0 )
1050         {
1051             event.SetEventType(wxEVT_CHAR);
1052             if ( GetEventHandler()->ProcessEvent(event) )
1053                 return;
1054         }
1055
1056         // Synthetize navigation key event, but do it only if the TAB key
1057         // wasn't handled yet:
1058         if ( isTab && GetParent() && GetParent()->HasFlag(wxTAB_TRAVERSAL) )
1059         {
1060             wxNavigationKeyEvent navEvent;
1061             navEvent.SetEventObject(GetParent());
1062             // Shift-TAB goes in reverse direction:
1063             navEvent.SetDirection(!event.m_shiftDown);
1064             // Ctrl-TAB changes the (parent) window, i.e. switch notebook page:
1065             navEvent.SetWindowChange(event.m_controlDown);
1066             navEvent.SetCurrentFocus(wxStaticCast(this, wxWindow));
1067             GetParent()->GetEventHandler()->ProcessEvent(navEvent);
1068         }
1069     }
1070 }
1071
1072 // ---------------------------------------------------------------------------
1073 // idle events processing
1074 // ---------------------------------------------------------------------------
1075
1076 void wxWindowDFB::OnInternalIdle()
1077 {
1078     if (wxUpdateUIEvent::CanUpdate(this))
1079         UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
1080 }
1081
1082
1083 // Find the wxWindow at the current mouse position, returning the mouse
1084 // position.
1085 wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1086 {
1087     return wxFindWindowAtPoint(pt = wxGetMousePosition());
1088 }
1089
1090 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
1091 {
1092     wxFAIL_MSG( _T("wxFindWindowAtPoint not implemented") );
1093     return NULL;
1094 }