]> git.saurik.com Git - wxWidgets.git/blame - src/dfb/nonownedwnd.cpp
add support for alpha in color dialog on OSX, see #14127
[wxWidgets.git] / src / dfb / nonownedwnd.cpp
CommitLineData
42b0d8b9
VS
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/dfb/nonownedwnd.cpp
fd2be5df 3// Purpose: implementation of wxNonOwnedWindow
42b0d8b9
VS
4// Author: Vaclav Slavik
5// Created: 2006-12-24
6// RCS-ID: $Id$
7// Copyright: (c) 2006 REA Elektronik GmbH
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx.h".
12#include "wx/wxprec.h"
13
14#include "wx/toplevel.h"
15
16#ifndef WX_PRECOMP
17 #include "wx/app.h"
18#endif // WX_PRECOMP
19
20#include "wx/hashmap.h"
21#include "wx/evtloop.h"
22#include "wx/dfb/private.h"
23
a5001e93
VS
24#define TRACE_EVENTS "events"
25#define TRACE_PAINT "paint"
42b0d8b9
VS
26
27// ============================================================================
28// globals
29// ============================================================================
30
31// mapping of DirectFB windows to wxTLWs:
32WX_DECLARE_HASH_MAP(DFBWindowID, wxNonOwnedWindow*,
33 wxIntegerHash, wxIntegerEqual,
34 wxDfbWindowsMap);
35static wxDfbWindowsMap gs_dfbWindowsMap;
36
37// ============================================================================
38// helpers
39// ============================================================================
40
41// Queue of paint requests
42class wxDfbQueuedPaintRequests
43{
44public:
45 ~wxDfbQueuedPaintRequests() { Clear(); }
46
47 // Adds paint request to the queue
48 void Add(const wxRect& rect)
49 {
50 // We use a simple implementation here for now: all refresh requests
51 // are merged together into single rectangle that is superset of
52 // all the requested rectangles. This wastes some blitting and painting
53 // time, but OTOH, EVT_PAINT handler is called only once per window.
54 m_invalidated.Union(rect);
55 }
56
57 // Is the queue empty?
58 bool IsEmpty() const { return m_invalidated.IsEmpty(); }
59
60 // Empties the queue
61 void Clear() { m_invalidated = wxRect(); }
62
63 // Gets the next request in the queue, returns true if there was one,
64 // false if the queue was empty
65 bool GetNext(wxRect& rect)
66 {
67 if ( m_invalidated.IsEmpty() )
68 return false;
69
70 rect = m_invalidated;
71 Clear(); // there's only one item in the queue
72 return true;
73 }
74
75private:
76 // currently invalidated region
77 wxRect m_invalidated;
78};
79
80// ============================================================================
81// wxNonOwnedWindow
82// ============================================================================
83
84// ----------------------------------------------------------------------------
85// creation & destruction
86// ----------------------------------------------------------------------------
87
88void wxNonOwnedWindow::Init()
89{
90 m_isShown = false;
91 m_sizeSet = false;
92 m_opacity = 255;
93 m_toPaint = new wxDfbQueuedPaintRequests;
94 m_isPainting = false;
95}
96
97bool wxNonOwnedWindow::Create(wxWindow *parent,
98 wxWindowID id,
99 const wxPoint& pos,
100 const wxSize& size,
101 long style,
102 const wxString &name)
103{
a5001e93
VS
104 wxCHECK_MSG( pos.x >= 0 && pos.y >= 0, false, "invalid position" );
105 wxCHECK_MSG( size.x > 0 && size.y > 0, false, "invalid size" );
42b0d8b9
VS
106
107 m_tlw = this;
108
109 // create DirectFB window:
110 wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
a5001e93 111 wxCHECK_MSG( layer, false, "no display layer" );
42b0d8b9
VS
112
113 DFBWindowDescription desc;
114 desc.flags = (DFBWindowDescriptionFlags)
115 (DWDESC_CAPS |
116 DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY);
117 desc.caps = DWCAPS_DOUBLEBUFFER;
118 desc.posx = pos.x;
119 desc.posy = pos.y;
120 desc.width = size.x;
121 desc.height = size.y;
122 m_dfbwin = layer->CreateWindow(&desc);
123 if ( !m_dfbwin )
124 return false;
125
126 // add the new TLW to DFBWindowID->wxTLW map:
127 DFBWindowID winid;
128 if ( !m_dfbwin->GetID(&winid) )
129 return false;
130 gs_dfbWindowsMap[winid] = this;
131
132 // TLWs are created initially hidden:
133 if ( !m_dfbwin->SetOpacity(wxALPHA_TRANSPARENT) )
134 return false;
135
136 if ( !wxWindow::Create(NULL, id, pos, size, style, name) )
137 return false;
138
139 SetParent(parent);
140 if ( parent )
141 parent->AddChild(this);
142
143 if ( style & (wxSTAY_ON_TOP | wxPOPUP_WINDOW) )
144 {
145 m_dfbwin->SetStackingClass(DWSC_UPPER);
146 }
147
148 // direct events in this window to the global event buffer:
149 m_dfbwin->AttachEventBuffer(wxEventLoop::GetDirectFBEventBuffer());
150
151 return true;
152}
153
154wxNonOwnedWindow::~wxNonOwnedWindow()
155{
c6212a0c 156 SendDestroyEvent();
42b0d8b9
VS
157
158 // destroy all children before we destroy the underlying DirectFB window,
159 // so that if any of them does something with the TLW, it will still work:
160 DestroyChildren();
161
162 // it's safe to delete the underlying DirectFB window now:
163 wxDELETE(m_toPaint);
164
165 if ( !m_dfbwin )
166 return;
167
168 // remove the TLW from DFBWindowID->wxTLW map:
169 DFBWindowID winid;
170 if ( m_dfbwin->GetID(&winid) )
171 gs_dfbWindowsMap.erase(winid);
172
173 m_dfbwin->Destroy();
174 m_dfbwin.Reset();
175}
176
177// ----------------------------------------------------------------------------
178// window size & position
179// ----------------------------------------------------------------------------
180
181void wxNonOwnedWindow::DoGetPosition(int *x, int *y) const
182{
183 m_dfbwin->GetPosition(x, y);
184}
185
186void wxNonOwnedWindow::DoGetSize(int *width, int *height) const
187{
188 m_dfbwin->GetSize(width, height);
189}
190
191void wxNonOwnedWindow::DoMoveWindow(int x, int y, int width, int height)
192{
193 wxPoint curpos = GetPosition();
194 if ( curpos.x != x || curpos.y != y )
195 {
196 m_dfbwin->MoveTo(x, y);
197 }
198
199 wxSize cursize = GetSize();
200 if ( cursize.x != width || cursize.y != height )
201 {
202 // changing window's size changes its surface:
203 InvalidateDfbSurface();
204
205 m_dfbwin->Resize(width, height);
206
207 // we must repaint the window after it changed size:
208 if ( IsShown() )
209 DoRefreshWindow();
210 }
211}
212
213// ----------------------------------------------------------------------------
214// showing and hiding
215// ----------------------------------------------------------------------------
216
217bool wxNonOwnedWindow::Show(bool show)
218{
219 // NB: this calls wxWindow::Show() and so ensures DoRefreshWindow() is
220 // called on the window -- we'll need that below
221 if ( !wxWindow::Show(show) )
222 return false;
223
224 // If this is the first time Show was called, send size event,
225 // so that the frame can adjust itself (think auto layout or single child)
226 if ( !m_sizeSet )
227 {
228 m_sizeSet = true;
229 wxSizeEvent event(GetSize(), GetId());
230 event.SetEventObject(this);
937013e0 231 HandleWindowEvent(event);
42b0d8b9
VS
232 }
233
234 // make sure the window is fully painted, with all pending updates, before
235 // DFB WM shows it, otherwise it would attempt to show either empty (=
236 // black) window surface (if shown for the first time) or it would show
237 // window with outdated content; note that the window was already refreshed
238 // in the wxWindow::Show() call above:
239 if ( show )
240 Update();
241
242 // hide/show the window by setting its opacity to 0/full:
243 m_dfbwin->SetOpacity(show ? m_opacity : 0);
244
245 if ( show )
fd2be5df
VS
246 {
247 wxWindow *focused = FindFocus();
248 if ( focused && focused->GetTLW() == this )
249 {
250 // focus is on this frame or its children, apply it to DirectFB
251 SetDfbFocus();
252 }
253 // else: don't do anything, if this is wxFrame or wxDialog that should
254 // get focus when it's shown,
255 // wxTopLevelWindowDFB::HandleFocusEvent() will do it as soon as
256 // the event loop starts
257 }
42b0d8b9
VS
258
259 return true;
260}
261
84e45580
VS
262void wxNonOwnedWindow::Raise()
263{
264 m_dfbwin->RaiseToTop();
265}
266
267void wxNonOwnedWindow::Lower()
268{
269 m_dfbwin->LowerToBottom();
270}
271
42b0d8b9
VS
272// ----------------------------------------------------------------------------
273// surfaces and painting
274// ----------------------------------------------------------------------------
275
276wxIDirectFBSurfacePtr wxNonOwnedWindow::ObtainDfbSurface() const
277{
278 return m_dfbwin->GetSurface();
279}
280
281void wxNonOwnedWindow::HandleQueuedPaintRequests()
282{
283 if ( m_toPaint->IsEmpty() )
284 return; // nothing to do
285
286 if ( IsFrozen() || !IsShown() )
287 {
288 // nothing to do if the window is frozen or hidden; clear the queue
289 // and return (note that it's OK to clear the queue even if the window
290 // is frozen, because Thaw() calls Refresh()):
291 m_toPaint->Clear();
292 return;
293 }
294
295 // process queued paint requests:
296 wxRect winRect(wxPoint(0, 0), GetSize());
297 wxRect paintedRect;
298
299 // important note: all DCs created from now until m_isPainting is reset to
300 // false will not update the front buffer as this flag indicates that we'll
301 // blit the entire back buffer to front soon
302 m_isPainting = true;
303
42b0d8b9 304 int requestsCount = 0;
42b0d8b9
VS
305
306 wxRect request;
307 while ( m_toPaint->GetNext(request) )
308 {
42b0d8b9 309 requestsCount++;
42b0d8b9
VS
310 wxRect clipped(request);
311 clipped.Intersect(winRect);
312 if ( clipped.IsEmpty() )
313 continue; // nothing to refresh
314
315 wxLogTrace(TRACE_PAINT,
a5001e93 316 "%p ('%s'): processing paint request [%i,%i,%i,%i]",
42b0d8b9
VS
317 this, GetName().c_str(),
318 clipped.x, clipped.y, clipped.GetRight(), clipped.GetBottom());
319
320 PaintWindow(clipped);
321
322 // remember rectangle covering all repainted areas:
323 if ( paintedRect.IsEmpty() )
324 paintedRect = clipped;
325 else
326 paintedRect.Union(clipped);
327 }
328
329 m_isPainting = false;
330
331 m_toPaint->Clear();
332
333 if ( paintedRect.IsEmpty() )
334 return; // no painting occurred, no need to flip
335
336 // Flip the surface to make the changes visible. Note that the rectangle we
337 // flip is *superset* of the union of repainted rectangles (created as
338 // "rectangles union" by wxRect::Union) and so some parts of the back
339 // buffer that we didn't touch in this HandleQueuedPaintRequests call will
340 // be copied to the front buffer as well. This is safe/correct thing to do
341 // *only* because wx always use wxIDirectFBSurface::FlipToFront() and so
342 // the back and front buffers contain the same data.
343 //
344 // Note that we do _not_ split m_toPaint into disjoint rectangles and
345 // do FlipToFront() for each of them, because that could result in visible
346 // updating of the screen; instead, we prefer to flip everything at once.
347
348 DFBRegion r = {paintedRect.GetLeft(), paintedRect.GetTop(),
349 paintedRect.GetRight(), paintedRect.GetBottom()};
350 DFBRegion *rptr = (winRect == paintedRect) ? NULL : &r;
351
352 GetDfbSurface()->FlipToFront(rptr);
353
354 wxLogTrace(TRACE_PAINT,
a5001e93 355 "%p ('%s'): processed %i paint requests, flipped surface: [%i,%i,%i,%i]",
42b0d8b9
VS
356 this, GetName().c_str(),
357 requestsCount,
358 paintedRect.x, paintedRect.y,
359 paintedRect.GetRight(), paintedRect.GetBottom());
360}
361
362void wxNonOwnedWindow::DoRefreshRect(const wxRect& rect)
363{
364 // don't overlap outside of the window (NB: 'rect' is in window coords):
365 wxRect r(rect);
366 r.Intersect(wxRect(GetSize()));
367 if ( r.IsEmpty() )
368 return;
369
370 wxLogTrace(TRACE_PAINT,
a5001e93 371 "%p ('%s'): [TLW] refresh rect [%i,%i,%i,%i]",
42b0d8b9
VS
372 this, GetName().c_str(),
373 rect.x, rect.y, rect.GetRight(), rect.GetBottom());
374
375 // defer painting until idle time or until Update() is called:
376 m_toPaint->Add(rect);
377}
378
379void wxNonOwnedWindow::Update()
380{
381 HandleQueuedPaintRequests();
382}
383
384// ---------------------------------------------------------------------------
385// events handling
386// ---------------------------------------------------------------------------
387
fd2be5df
VS
388namespace
389{
390
391static wxNonOwnedWindow *gs_insideDFBFocusHandlerOf = NULL;
392
393struct InsideDFBFocusHandlerSetter
394{
395 InsideDFBFocusHandlerSetter(wxNonOwnedWindow *win)
396 {
397 wxASSERT( gs_insideDFBFocusHandlerOf == NULL );
398 gs_insideDFBFocusHandlerOf = win;
399 }
400 ~InsideDFBFocusHandlerSetter()
401 {
402 gs_insideDFBFocusHandlerOf = NULL;
403 }
404};
405
406} // anonymous namespace
407
408
42b0d8b9
VS
409void wxNonOwnedWindow::SetDfbFocus()
410{
a5001e93 411 wxCHECK_RET( IsShown(), "cannot set focus to hidden window" );
42b0d8b9 412 wxASSERT_MSG( FindFocus() && FindFocus()->GetTLW() == this,
a5001e93 413 "setting DirectFB focus to unexpected window" );
42b0d8b9 414
fd2be5df
VS
415 // Don't set DirectFB focus if we're called from HandleFocusEvent() on
416 // this window, because we already have the focus in that case. Not only
417 // would it be unnecessary, it would be harmful: RequestFocus() adds
418 // an event to DirectFB event queue and calling it when in
419 // HandleFocusEvent() could result in a window being focused when it
420 // should not be. Consider this example:
421 //
422 // tlw1->SetFocus(); // (1)
423 // tlw2->SetFocus(); // (2)
424 //
425 // This results in adding these events to DFB queue:
426 //
427 // DWET_GOTFOCUS(tlw1)
428 // DWET_LOSTFOCUS(tlw1)
429 // DWET_GOTFOCUS(tlw2)
430 //
431 // Note that the events are processed by event loop, i.e. not between
432 // execution of lines (1) and (2) above. So by the time the first
433 // DWET_GOTFOCUS event is handled, tlw2->SetFocus() was already executed.
434 // If we onconditionally called RequestFocus() from here, handling the
435 // first event would result in this change to the event queue:
436 //
437 // DWET_LOSTFOCUS(tlw1)
438 // DWET_GOTFOCUS(tlw2) // (3)
439 // DWET_LOSTFOCUS(tlw2)
440 // DWET_GOTFOCUS(tlw1)
441 //
442 // And the focus would get back to tlw1 even though that's not what we
443 // wanted.
444
445 if ( gs_insideDFBFocusHandlerOf == this )
446 return;
447
42b0d8b9
VS
448 GetDirectFBWindow()->RequestFocus();
449}
450
451/* static */
452void wxNonOwnedWindow::HandleDFBWindowEvent(const wxDFBWindowEvent& event_)
453{
454 const DFBWindowEvent& event = event_;
455
456 if ( gs_dfbWindowsMap.find(event.window_id) == gs_dfbWindowsMap.end() )
457 {
458 wxLogTrace(TRACE_EVENTS,
a5001e93 459 "received event for unknown DirectFB window, ignoring");
42b0d8b9
VS
460 return;
461 }
462
463 wxNonOwnedWindow *tlw = gs_dfbWindowsMap[event.window_id];
42b0d8b9
VS
464
465 switch ( event.type )
466 {
467 case DWET_KEYDOWN:
468 case DWET_KEYUP:
469 {
6954a1e2
VS
470 wxWindow *recipient = wxWindow::FindFocus();
471 if ( !recipient )
472 {
473 wxLogTrace(TRACE_EVENTS,
a5001e93 474 "ignoring event: no recipient window");
6954a1e2
VS
475 return;
476 }
477
478 wxCHECK_RET( recipient && recipient->GetTLW() == tlw,
a5001e93 479 "event recipient not in TLW which received the event" );
6954a1e2
VS
480
481 recipient->HandleKeyEvent(event_);
42b0d8b9
VS
482 break;
483 }
484
6954a1e2
VS
485 case DWET_GOTFOCUS:
486 case DWET_LOSTFOCUS:
fd2be5df
VS
487 {
488 InsideDFBFocusHandlerSetter inside(tlw);
489 tlw->HandleFocusEvent(event_);
490 }
6954a1e2
VS
491 break;
492
42b0d8b9
VS
493 case DWET_NONE:
494 case DWET_ALL:
a5001e93 495 wxFAIL_MSG( "invalid event type" );
42b0d8b9 496 break;
42b0d8b9
VS
497
498 default:
499 // we're not interested in them here
500 break;
501 }
42b0d8b9
VS
502}
503
504// ---------------------------------------------------------------------------
505// idle events processing
506// ---------------------------------------------------------------------------
507
508void wxNonOwnedWindow::OnInternalIdle()
509{
510 wxWindow::OnInternalIdle();
511 HandleQueuedPaintRequests();
512}