[wxWidgets.git] / src / dfb / nonownedwnd.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/dfb/nonownedwnd.cpp
// Purpose:     implementation of wxNonOwnedWindow
// Author:      Vaclav Slavik
// Created:     2006-12-24
// RCS-ID:      $Id$
// Copyright:   (c) 2006 REA Elektronik GmbH
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/toplevel.h"

#ifndef WX_PRECOMP
    #include "wx/app.h"
#endif // WX_PRECOMP

#include "wx/hashmap.h"
#include "wx/evtloop.h"
#include "wx/dfb/private.h"

#define TRACE_EVENTS "events"
#define TRACE_PAINT  "paint"

// ============================================================================
// globals
// ============================================================================

// mapping of DirectFB windows to wxTLWs:
WX_DECLARE_HASH_MAP(DFBWindowID, wxNonOwnedWindow*,
                    wxIntegerHash, wxIntegerEqual,
                    wxDfbWindowsMap);
static wxDfbWindowsMap gs_dfbWindowsMap;

// ============================================================================
// helpers
// ============================================================================

// Queue of paint requests
class wxDfbQueuedPaintRequests
{
public:
    ~wxDfbQueuedPaintRequests() { Clear(); }

    // Adds paint request to the queue
    void Add(const wxRect& rect)
    {
        // We use a simple implementation here for now: all refresh requests
        // are merged together into single rectangle that is superset of
        // all the requested rectangles. This wastes some blitting and painting
        // time, but OTOH, EVT_PAINT handler is called only once per window.
        m_invalidated.Union(rect);
    }

    // Is the queue empty?
    bool IsEmpty() const { return m_invalidated.IsEmpty(); }

    // Empties the queue
    void Clear() { m_invalidated = wxRect(); }

    // Gets the next request in the queue, returns true if there was one,
    // false if the queue was empty
    bool GetNext(wxRect& rect)
    {
        if ( m_invalidated.IsEmpty() )
            return false;

        rect = m_invalidated;
        Clear(); // there's only one item in the queue
        return true;
    }

private:
    // currently invalidated region
    wxRect m_invalidated;
};

// ============================================================================
// wxNonOwnedWindow
// ============================================================================

// ----------------------------------------------------------------------------
// creation & destruction
// ----------------------------------------------------------------------------

void wxNonOwnedWindow::Init()
{
    m_isShown = false;
    m_sizeSet = false;
    m_opacity = 255;
    m_toPaint = new wxDfbQueuedPaintRequests;
    m_isPainting = false;
}

bool wxNonOwnedWindow::Create(wxWindow *parent,
                                 wxWindowID id,
                                 const wxPoint& pos,
                                 const wxSize& size,
                                 long style,
                                 const wxString &name)
{
    wxCHECK_MSG( pos.x >= 0 && pos.y >= 0, false, "invalid position" );
    wxCHECK_MSG( size.x > 0 && size.y > 0, false, "invalid size" );

    m_tlw = this;

    // create DirectFB window:
    wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
    wxCHECK_MSG( layer, false, "no display layer" );

    DFBWindowDescription desc;
    desc.flags = (DFBWindowDescriptionFlags)
                   (DWDESC_CAPS |
                    DWDESC_WIDTH | DWDESC_HEIGHT | DWDESC_POSX | DWDESC_POSY);
    desc.caps = DWCAPS_DOUBLEBUFFER;
    desc.posx = pos.x;
    desc.posy = pos.y;
    desc.width = size.x;
    desc.height = size.y;
    m_dfbwin = layer->CreateWindow(&desc);
    if ( !m_dfbwin )
        return false;

    // add the new TLW to DFBWindowID->wxTLW map:
    DFBWindowID winid;
    if ( !m_dfbwin->GetID(&winid) )
        return false;
    gs_dfbWindowsMap[winid] = this;

    // TLWs are created initially hidden:
    if ( !m_dfbwin->SetOpacity(wxALPHA_TRANSPARENT) )
        return false;

    if ( !wxWindow::Create(NULL, id, pos, size, style, name) )
        return false;

    SetParent(parent);
    if ( parent )
        parent->AddChild(this);

    if ( style & (wxSTAY_ON_TOP | wxPOPUP_WINDOW) )
    {
        m_dfbwin->SetStackingClass(DWSC_UPPER);
    }

    // direct events in this window to the global event buffer:
    m_dfbwin->AttachEventBuffer(wxEventLoop::GetDirectFBEventBuffer());

    return true;
}

wxNonOwnedWindow::~wxNonOwnedWindow()
{
    SendDestroyEvent();

    // destroy all children before we destroy the underlying DirectFB window,
    // so that if any of them does something with the TLW, it will still work:
    DestroyChildren();

    // it's safe to delete the underlying DirectFB window now:
    wxDELETE(m_toPaint);

    if ( !m_dfbwin )
        return;

    // remove the TLW from DFBWindowID->wxTLW map:
    DFBWindowID winid;
    if ( m_dfbwin->GetID(&winid) )
        gs_dfbWindowsMap.erase(winid);

    m_dfbwin->Destroy();
    m_dfbwin.Reset();
}

// ----------------------------------------------------------------------------
// window size & position
// ----------------------------------------------------------------------------

void wxNonOwnedWindow::DoGetPosition(int *x, int *y) const
{
    m_dfbwin->GetPosition(x, y);
}

void wxNonOwnedWindow::DoGetSize(int *width, int *height) const
{
    m_dfbwin->GetSize(width, height);
}

void wxNonOwnedWindow::DoMoveWindow(int x, int y, int width, int height)
{
    wxPoint curpos = GetPosition();
    if ( curpos.x != x || curpos.y != y )
    {
        m_dfbwin->MoveTo(x, y);
    }

    wxSize cursize = GetSize();
    if ( cursize.x != width || cursize.y != height )
    {
        // changing window's size changes its surface:
        InvalidateDfbSurface();

        m_dfbwin->Resize(width, height);

        // we must repaint the window after it changed size:
        if ( IsShown() )
            DoRefreshWindow();
    }
}

// ----------------------------------------------------------------------------
// showing and hiding
// ----------------------------------------------------------------------------

bool wxNonOwnedWindow::Show(bool show)
{
    // NB: this calls wxWindow::Show() and so ensures DoRefreshWindow() is
    //     called on the window -- we'll need that below
    if ( !wxWindow::Show(show) )
        return false;

    // If this is the first time Show was called, send size event,
    // so that the frame can adjust itself (think auto layout or single child)
    if ( !m_sizeSet )
    {
        m_sizeSet = true;
        wxSizeEvent event(GetSize(), GetId());
        event.SetEventObject(this);
        HandleWindowEvent(event);
    }

    // make sure the window is fully painted, with all pending updates, before
    // DFB WM shows it, otherwise it would attempt to show either empty (=
    // black) window surface (if shown for the first time) or it would show
    // window with outdated content; note that the window was already refreshed
    // in the wxWindow::Show() call above:
    if ( show )
        Update();

    // hide/show the window by setting its opacity to 0/full:
    m_dfbwin->SetOpacity(show ? m_opacity : 0);

    if ( show )
    {
        wxWindow *focused = FindFocus();
        if ( focused && focused->GetTLW() == this )
        {
            // focus is on this frame or its children, apply it to DirectFB
            SetDfbFocus();
        }
        // else: don't do anything, if this is wxFrame or wxDialog that should
        //       get focus when it's shown,
        //       wxTopLevelWindowDFB::HandleFocusEvent() will do it as soon as
        //       the event loop starts
    }

    return true;
}

void wxNonOwnedWindow::Raise()
{
    m_dfbwin->RaiseToTop();
}

void wxNonOwnedWindow::Lower()
{
    m_dfbwin->LowerToBottom();
}

// ----------------------------------------------------------------------------
// surfaces and painting
// ----------------------------------------------------------------------------

wxIDirectFBSurfacePtr wxNonOwnedWindow::ObtainDfbSurface() const
{
    return m_dfbwin->GetSurface();
}

void wxNonOwnedWindow::HandleQueuedPaintRequests()
{
    if ( m_toPaint->IsEmpty() )
        return; // nothing to do

    if ( IsFrozen() || !IsShown() )
    {
        // nothing to do if the window is frozen or hidden; clear the queue
        // and return (note that it's OK to clear the queue even if the window
        // is frozen, because Thaw() calls Refresh()):
        m_toPaint->Clear();
        return;
    }

    // process queued paint requests:
    wxRect winRect(wxPoint(0, 0), GetSize());
    wxRect paintedRect;

    // important note: all DCs created from now until m_isPainting is reset to
    // false will not update the front buffer as this flag indicates that we'll
    // blit the entire back buffer to front soon
    m_isPainting = true;

    int requestsCount = 0;

    wxRect request;
    while ( m_toPaint->GetNext(request) )
    {
        requestsCount++;
        wxRect clipped(request);
        clipped.Intersect(winRect);
        if ( clipped.IsEmpty() )
            continue; // nothing to refresh

        wxLogTrace(TRACE_PAINT,
                   "%p ('%s'): processing paint request [%i,%i,%i,%i]",
                   this, GetName().c_str(),
                   clipped.x, clipped.y, clipped.GetRight(), clipped.GetBottom());

        PaintWindow(clipped);

        // remember rectangle covering all repainted areas:
        if ( paintedRect.IsEmpty() )
            paintedRect = clipped;
        else
            paintedRect.Union(clipped);
    }

    m_isPainting = false;

    m_toPaint->Clear();

    if ( paintedRect.IsEmpty() )
        return; // no painting occurred, no need to flip

    // Flip the surface to make the changes visible. Note that the rectangle we
    // flip is *superset* of the union of repainted rectangles (created as
    // "rectangles union" by wxRect::Union) and so some parts of the back
    // buffer that we didn't touch in this HandleQueuedPaintRequests call will
    // be copied to the front buffer as well. This is safe/correct thing to do
    // *only* because wx always use wxIDirectFBSurface::FlipToFront() and so
    // the back and front buffers contain the same data.
    //
    // Note that we do _not_ split m_toPaint into disjoint rectangles and
    // do FlipToFront() for each of them, because that could result in visible
    // updating of the screen; instead, we prefer to flip everything at once.

    DFBRegion r = {paintedRect.GetLeft(), paintedRect.GetTop(),
                   paintedRect.GetRight(), paintedRect.GetBottom()};
    DFBRegion *rptr = (winRect == paintedRect) ? NULL : &r;

    GetDfbSurface()->FlipToFront(rptr);

    wxLogTrace(TRACE_PAINT,
               "%p ('%s'): processed %i paint requests, flipped surface: [%i,%i,%i,%i]",
               this, GetName().c_str(),
               requestsCount,
               paintedRect.x, paintedRect.y,
               paintedRect.GetRight(), paintedRect.GetBottom());
}

void wxNonOwnedWindow::DoRefreshRect(const wxRect& rect)
{
    // don't overlap outside of the window (NB: 'rect' is in window coords):
    wxRect r(rect);
    r.Intersect(wxRect(GetSize()));
    if ( r.IsEmpty() )
        return;

    wxLogTrace(TRACE_PAINT,
               "%p ('%s'): [TLW] refresh rect [%i,%i,%i,%i]",
               this, GetName().c_str(),
               rect.x, rect.y, rect.GetRight(), rect.GetBottom());

    // defer painting until idle time or until Update() is called:
    m_toPaint->Add(rect);
}

void wxNonOwnedWindow::Update()
{
    HandleQueuedPaintRequests();
}

// ---------------------------------------------------------------------------
// events handling
// ---------------------------------------------------------------------------

namespace
{

static wxNonOwnedWindow *gs_insideDFBFocusHandlerOf = NULL;

struct InsideDFBFocusHandlerSetter
{
    InsideDFBFocusHandlerSetter(wxNonOwnedWindow *win)
    {
        wxASSERT( gs_insideDFBFocusHandlerOf == NULL );
        gs_insideDFBFocusHandlerOf = win;
    }
    ~InsideDFBFocusHandlerSetter()
    {
        gs_insideDFBFocusHandlerOf = NULL;
    }
};

} // anonymous namespace


void wxNonOwnedWindow::SetDfbFocus()
{
    wxCHECK_RET( IsShown(), "cannot set focus to hidden window" );
    wxASSERT_MSG( FindFocus() && FindFocus()->GetTLW() == this,
                  "setting DirectFB focus to unexpected window" );

    // Don't set DirectFB focus if we're called from HandleFocusEvent() on
    // this window, because we already have the focus in that case. Not only
    // would it be unnecessary, it would be harmful: RequestFocus() adds
    // an event to DirectFB event queue and calling it when in
    // HandleFocusEvent() could result in a window being focused when it
    // should not be. Consider this example:
    //
    //     tlw1->SetFocus(); // (1)
    //     tlw2->SetFocus(); // (2)
    //
    // This results in adding these events to DFB queue:
    //
    //     DWET_GOTFOCUS(tlw1)
    //     DWET_LOSTFOCUS(tlw1)
    //     DWET_GOTFOCUS(tlw2)
    //
    // Note that the events are processed by event loop, i.e. not between
    // execution of lines (1) and (2) above. So by the time the first
    // DWET_GOTFOCUS event is handled, tlw2->SetFocus() was already executed.
    // If we onconditionally called RequestFocus() from here, handling the
    // first event would result in this change to the event queue:
    //
    //     DWET_LOSTFOCUS(tlw1)
    //     DWET_GOTFOCUS(tlw2) // (3)
    //     DWET_LOSTFOCUS(tlw2)
    //     DWET_GOTFOCUS(tlw1)
    //
    // And the focus would get back to tlw1 even though that's not what we
    // wanted.

    if ( gs_insideDFBFocusHandlerOf == this )
        return;

    GetDirectFBWindow()->RequestFocus();
}

/* static */
void wxNonOwnedWindow::HandleDFBWindowEvent(const wxDFBWindowEvent& event_)
{
    const DFBWindowEvent& event = event_;

    if ( gs_dfbWindowsMap.find(event.window_id) == gs_dfbWindowsMap.end() )
    {
        wxLogTrace(TRACE_EVENTS,
                   "received event for unknown DirectFB window, ignoring");
        return;
    }

    wxNonOwnedWindow *tlw = gs_dfbWindowsMap[event.window_id];

    switch ( event.type )
    {
        case DWET_KEYDOWN:
        case DWET_KEYUP:
        {
            wxWindow *recipient = wxWindow::FindFocus();
            if ( !recipient )
            {
                wxLogTrace(TRACE_EVENTS,
                           "ignoring event: no recipient window");
                return;
            }

            wxCHECK_RET( recipient && recipient->GetTLW() == tlw,
                         "event recipient not in TLW which received the event" );

            recipient->HandleKeyEvent(event_);
            break;
        }

        case DWET_GOTFOCUS:
        case DWET_LOSTFOCUS:
            {
                InsideDFBFocusHandlerSetter inside(tlw);
                tlw->HandleFocusEvent(event_);
            }
            break;

        case DWET_NONE:
        case DWET_ALL:
            wxFAIL_MSG( "invalid event type" );
            break;

        default:
            // we're not interested in them here
            break;
    }
}

// ---------------------------------------------------------------------------
// idle events processing
// ---------------------------------------------------------------------------

void wxNonOwnedWindow::OnInternalIdle()
{
    wxWindow::OnInternalIdle();
    HandleQueuedPaintRequests();
}
Commit	Line	Data
42b0d8b9 VS	1	/////////////////////////////////////////////////////////////////////////////
42b0d8b9 VS	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"
a5001e93 VS	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" );
a5001e93 VS	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()
42b0d8b9 VS	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
6954a1e2 VS	481	recipient->HandleKeyEvent(event_);
42b0d8b9 VS	482	break;
	483	}
	484
6954a1e2 VS	485	case DWET_GOTFOCUS:
6954a1e2 VS	486	case DWET_LOSTFOCUS:
fd2be5df VS	487	{
	488	InsideDFBFocusHandlerSetter inside(tlw);
	489	tlw->HandleFocusEvent(event_);
	490	}
6954a1e2 VS	491	break;
6954a1e2 VS	492
42b0d8b9 VS	493	case DWET_NONE:
42b0d8b9 VS	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	}