Commit | Line | Data |
---|---|---|
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: | |
32 | WX_DECLARE_HASH_MAP(DFBWindowID, wxNonOwnedWindow*, | |
33 | wxIntegerHash, wxIntegerEqual, | |
34 | wxDfbWindowsMap); | |
35 | static wxDfbWindowsMap gs_dfbWindowsMap; | |
36 | ||
37 | // ============================================================================ | |
38 | // helpers | |
39 | // ============================================================================ | |
40 | ||
41 | // Queue of paint requests | |
42 | class wxDfbQueuedPaintRequests | |
43 | { | |
44 | public: | |
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 | ||
75 | private: | |
76 | // currently invalidated region | |
77 | wxRect m_invalidated; | |
78 | }; | |
79 | ||
80 | // ============================================================================ | |
81 | // wxNonOwnedWindow | |
82 | // ============================================================================ | |
83 | ||
84 | // ---------------------------------------------------------------------------- | |
85 | // creation & destruction | |
86 | // ---------------------------------------------------------------------------- | |
87 | ||
88 | void 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 | ||
97 | bool 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 | ||
154 | wxNonOwnedWindow::~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 | ||
181 | void wxNonOwnedWindow::DoGetPosition(int *x, int *y) const | |
182 | { | |
183 | m_dfbwin->GetPosition(x, y); | |
184 | } | |
185 | ||
186 | void wxNonOwnedWindow::DoGetSize(int *width, int *height) const | |
187 | { | |
188 | m_dfbwin->GetSize(width, height); | |
189 | } | |
190 | ||
191 | void 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 | ||
217 | bool 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 |
262 | void wxNonOwnedWindow::Raise() |
263 | { | |
264 | m_dfbwin->RaiseToTop(); | |
265 | } | |
266 | ||
267 | void wxNonOwnedWindow::Lower() | |
268 | { | |
269 | m_dfbwin->LowerToBottom(); | |
270 | } | |
271 | ||
42b0d8b9 VS |
272 | // ---------------------------------------------------------------------------- |
273 | // surfaces and painting | |
274 | // ---------------------------------------------------------------------------- | |
275 | ||
276 | wxIDirectFBSurfacePtr wxNonOwnedWindow::ObtainDfbSurface() const | |
277 | { | |
278 | return m_dfbwin->GetSurface(); | |
279 | } | |
280 | ||
281 | void 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 | ||
362 | void 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 | ||
379 | void wxNonOwnedWindow::Update() | |
380 | { | |
381 | HandleQueuedPaintRequests(); | |
382 | } | |
383 | ||
384 | // --------------------------------------------------------------------------- | |
385 | // events handling | |
386 | // --------------------------------------------------------------------------- | |
387 | ||
fd2be5df VS |
388 | namespace |
389 | { | |
390 | ||
391 | static wxNonOwnedWindow *gs_insideDFBFocusHandlerOf = NULL; | |
392 | ||
393 | struct 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 |
409 | void 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 */ | |
452 | void 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 | ||
508 | void wxNonOwnedWindow::OnInternalIdle() | |
509 | { | |
510 | wxWindow::OnInternalIdle(); | |
511 | HandleQueuedPaintRequests(); | |
512 | } |