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