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

/////////////////////////////////////////////////////////////////////////////
// Name:        src/dfb/toplevel.cpp
// Purpose:     Top level window, abstraction of wxFrame and wxDialog
// Author:      Vaclav Slavik
// Created:     2006-08-10
// 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 _T("events")
#define TRACE_PAINT  _T("paint")

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

// mapping of DirectFB windows to wxTLWs:
WX_DECLARE_HASH_MAP(DFBWindowID, wxTopLevelWindowDFB*,
                    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;
};

// ============================================================================
// wxTopLevelWindowDFB
// ============================================================================

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

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

bool wxTopLevelWindowDFB::Create(wxWindow *parent,
                                 wxWindowID id,
                                 const wxString& title,
                                 const wxPoint& posOrig,
                                 const wxSize& sizeOrig,
                                 long style,
                                 const wxString &name)
{
    m_tlw = this;

    // always create a frame of some reasonable, even if arbitrary, size (at
    // least for MSW compatibility)
    wxSize size(sizeOrig);
    if ( size.x == wxDefaultCoord || size.y == wxDefaultCoord )
    {
        wxSize sizeDefault = GetDefaultSize();
        if ( size.x == wxDefaultCoord )
            size.x = sizeDefault.x;
        if ( size.y == wxDefaultCoord )
            size.y = sizeDefault.y;
    }

    wxPoint pos(posOrig);
    if ( pos.x == wxDefaultCoord )
        pos.x = 0;
    if ( pos.y == wxDefaultCoord )
        pos.y = 0;

    // create DirectFB window:
    wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
    wxCHECK_MSG( layer, false, _T("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);

    wxTopLevelWindows.Append(this);
    m_title = title;

    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;
}

wxTopLevelWindowDFB::~wxTopLevelWindowDFB()
{
    m_isBeingDeleted = true;

    wxTopLevelWindows.DeleteObject(this);

    if ( wxTheApp->GetTopWindow() == this )
        wxTheApp->SetTopWindow(NULL);

    if ( wxTopLevelWindows.empty() && wxTheApp->GetExitOnFrameDelete() )
    {
        wxTheApp->ExitMainLoop();
    }

    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 wxTopLevelWindowDFB::DoGetPosition(int *x, int *y) const
{
    m_dfbwin->GetPosition(x, y);
}

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

void wxTopLevelWindowDFB::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
// ----------------------------------------------------------------------------

#warning "FIXME: the rest of this file is almost same as for MGL, merge it"
bool wxTopLevelWindowDFB::ShowFullScreen(bool show, long style)
{
    if (show == m_fsIsShowing) return false; // return what?

    m_fsIsShowing = show;

    if (show)
    {
        m_fsSaveStyle = m_windowStyle;
        m_fsSaveFlag = style;
        GetPosition(&m_fsSaveFrame.x, &m_fsSaveFrame.y);
        GetSize(&m_fsSaveFrame.width, &m_fsSaveFrame.height);

        if ( style & wxFULLSCREEN_NOCAPTION )
            m_windowStyle &= ~wxCAPTION;
        if ( style & wxFULLSCREEN_NOBORDER )
            m_windowStyle = wxSIMPLE_BORDER;

        int x, y;
        wxDisplaySize(&x, &y);
        SetSize(0, 0, x, y);
    }
    else
    {
        m_windowStyle = m_fsSaveStyle;
        SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
                m_fsSaveFrame.width, m_fsSaveFrame.height);
    }

    return true;
}

bool wxTopLevelWindowDFB::Show(bool show)
{
    if ( !wxTopLevelWindowBase::Show(show) )
        return false;

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

    // 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);
        GetEventHandler()->ProcessEvent(event);
    }

    if ( show )
    {
        wxWindow *focused = wxWindow::FindFocus();
        if ( focused && focused->GetTLW() == this )
        {
            SetDfbFocus();
        }
        else if ( AcceptsFocus() )
        {
            // FIXME: we should probably always call SetDfbFocus instead
            // and call SetFocus() from wxActivateEvent/DWET_GOTFOCUS
            // handler
            SetFocus();
        }
    }

    return true;
}

bool wxTopLevelWindowDFB::SetTransparent(wxByte alpha)
{
    if ( IsShown() )
    {
        if ( !m_dfbwin->SetOpacity(alpha) )
            return false;
    }

    m_opacity = alpha;
    return true;
}

// ----------------------------------------------------------------------------
// maximize, minimize etc.
// ----------------------------------------------------------------------------

void wxTopLevelWindowDFB::Maximize(bool maximize)
{
    int x, y, w, h;
    wxClientDisplayRect(&x, &y, &w, &h);

    if ( maximize && !m_isMaximized )
    {
        m_isMaximized = true;

        GetPosition(&m_savedFrame.x, &m_savedFrame.y);
        GetSize(&m_savedFrame.width, &m_savedFrame.height);

        SetSize(x, y, w, h);
    }
    else if ( !maximize && m_isMaximized )
    {
        m_isMaximized = false;
        SetSize(m_savedFrame.x, m_savedFrame.y,
                m_savedFrame.width, m_savedFrame.height);
    }
}

bool wxTopLevelWindowDFB::IsMaximized() const
{
    return m_isMaximized;
}

void wxTopLevelWindowDFB::Restore()
{
    if ( IsMaximized() )
    {
        Maximize(false);
    }
}

void wxTopLevelWindowDFB::Iconize(bool WXUNUSED(iconize))
{
    wxFAIL_MSG(wxT("Iconize not supported under wxDFB"));
}

bool wxTopLevelWindowDFB::IsIconized() const
{
    return false;
}


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

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

void wxTopLevelWindowDFB::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;

#ifdef __WXDEBUG__
    int requestsCount = 0;
#endif

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

        wxLogTrace(TRACE_PAINT,
                   _T("%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,
               _T("%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 wxTopLevelWindowDFB::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,
               _T("%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 wxTopLevelWindowDFB::Update()
{
    HandleQueuedPaintRequests();
}

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

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

    GetDirectFBWindow()->RequestFocus();
}

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

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

    wxTopLevelWindowDFB *tlw = gs_dfbWindowsMap[event.window_id];
    wxWindow *recipient = NULL;
    void (wxWindow::*handlerFunc)(const wxDFBWindowEvent&) = NULL;

    switch ( event.type )
    {
        case DWET_KEYDOWN:
        case DWET_KEYUP:
        {
            recipient = wxWindow::FindFocus();
            handlerFunc = &wxWindowDFB::HandleKeyEvent;
            break;
        }

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

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

    if ( !recipient )
    {
        wxLogTrace(TRACE_EVENTS, _T("ignoring event: no recipient window"));
        return;
    }

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

    // process the event:
    (recipient->*handlerFunc)(event_);
}

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

void wxTopLevelWindowDFB::OnInternalIdle()
{
    wxTopLevelWindowBase::OnInternalIdle();
    HandleQueuedPaintRequests();
}
Commit	Line	Data
b3c86150 VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/dfb/toplevel.cpp
	3	// Purpose: Top level window, abstraction of wxFrame and wxDialog
	4	// Author: Vaclav Slavik
	5	// Created: 2006-08-10
	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"
b3c86150 VS	18	#endif // WX_PRECOMP
	19
	20	#include "wx/hashmap.h"
	21	#include "wx/evtloop.h"
	22	#include "wx/dfb/private.h"
	23
	24	#define TRACE_EVENTS _T("events")
	25	#define TRACE_PAINT _T("paint")
	26
	27	// ============================================================================
	28	// globals
	29	// ============================================================================
	30
	31	// mapping of DirectFB windows to wxTLWs:
	32	WX_DECLARE_HASH_MAP(DFBWindowID, wxTopLevelWindowDFB*,
	33	wxIntegerHash, wxIntegerEqual,
	34	wxDfbWindowsMap);
	35	static wxDfbWindowsMap gs_dfbWindowsMap;
	36
	37	// ============================================================================
	38	// helpers
	39	// ============================================================================
	40
14ac4e3a VS	41	// Queue of paint requests
	42	class wxDfbQueuedPaintRequests
	43	{
	44	public:
	45	~wxDfbQueuedPaintRequests() { Clear(); }
	46
	47	// Adds paint request to the queue
20671963	48	void Add(const wxRect& rect)
93259e59 VS	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	}
14ac4e3a VS	56
14ac4e3a VS	57	// Is the queue empty?
93259e59	58	bool IsEmpty() const { return m_invalidated.IsEmpty(); }
14ac4e3a VS	59
14ac4e3a VS	60	// Empties the queue
93259e59	61	void Clear() { m_invalidated = wxRect(); }
14ac4e3a	62
93259e59 VS	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	}
14ac4e3a VS	74
14ac4e3a VS	75	private:
93259e59 VS	76	// currently invalidated region
93259e59 VS	77	wxRect m_invalidated;
14ac4e3a	78	};
b3c86150 VS	79
	80	// ============================================================================
	81	// wxTopLevelWindowDFB
	82	// ============================================================================
	83
	84	// ----------------------------------------------------------------------------
	85	// creation & destruction
	86	// ----------------------------------------------------------------------------
	87
	88	void wxTopLevelWindowDFB::Init()
	89	{
	90	m_isShown = false;
	91	m_isMaximized = false;
	92	m_fsIsShowing = false;
	93	m_sizeSet = false;
	94	m_opacity = 255;
	95	m_toPaint = new wxDfbQueuedPaintRequests;
20671963	96	m_isPainting = false;
b3c86150 VS	97	}
	98
	99	bool wxTopLevelWindowDFB::Create(wxWindow *parent,
	100	wxWindowID id,
	101	const wxString& title,
	102	const wxPoint& posOrig,
	103	const wxSize& sizeOrig,
	104	long style,
	105	const wxString &name)
	106	{
	107	m_tlw = this;
	108
	109	// always create a frame of some reasonable, even if arbitrary, size (at
	110	// least for MSW compatibility)
	111	wxSize size(sizeOrig);
	112	if ( size.x == wxDefaultCoord \|\| size.y == wxDefaultCoord )
	113	{
	114	wxSize sizeDefault = GetDefaultSize();
	115	if ( size.x == wxDefaultCoord )
	116	size.x = sizeDefault.x;
	117	if ( size.y == wxDefaultCoord )
	118	size.y = sizeDefault.y;
	119	}
	120
	121	wxPoint pos(posOrig);
	122	if ( pos.x == wxDefaultCoord )
	123	pos.x = 0;
	124	if ( pos.y == wxDefaultCoord )
	125	pos.y = 0;
	126
	127	// create DirectFB window:
a5b31f4e	128	wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
b3c86150 VS	129	wxCHECK_MSG( layer, false, _T("no display layer") );
	130
	131	DFBWindowDescription desc;
	132	desc.flags = (DFBWindowDescriptionFlags)
	133	(DWDESC_CAPS \|
	134	DWDESC_WIDTH \| DWDESC_HEIGHT \| DWDESC_POSX \| DWDESC_POSY);
	135	desc.caps = DWCAPS_DOUBLEBUFFER;
	136	desc.posx = pos.x;
	137	desc.posy = pos.y;
	138	desc.width = size.x;
	139	desc.height = size.y;
52c8d32a	140	m_dfbwin = layer->CreateWindow(&desc);
82c74d89	141	if ( !m_dfbwin )
b3c86150 VS	142	return false;
	143
	144	// add the new TLW to DFBWindowID->wxTLW map:
	145	DFBWindowID winid;
52c8d32a	146	if ( !m_dfbwin->GetID(&winid) )
b3c86150 VS	147	return false;
	148	gs_dfbWindowsMap[winid] = this;
	149
	150	// TLWs are created initially hidden:
52c8d32a	151	if ( !m_dfbwin->SetOpacity(wxALPHA_TRANSPARENT) )
b3c86150 VS	152	return false;
b3c86150 VS	153
20671963 VS	154	if ( !wxWindow::Create(NULL, id, pos, size, style, name) )
20671963 VS	155	return false;
b3c86150 VS	156
	157	SetParent(parent);
	158	if ( parent )
	159	parent->AddChild(this);
	160
	161	wxTopLevelWindows.Append(this);
	162	m_title = title;
	163
	164	if ( style & (wxSTAY_ON_TOP \| wxPOPUP_WINDOW) )
	165	{
52c8d32a	166	m_dfbwin->SetStackingClass(DWSC_UPPER);
b3c86150 VS	167	}
	168
	169	// direct events in this window to the global event buffer:
52c8d32a	170	m_dfbwin->AttachEventBuffer(wxEventLoop::GetDirectFBEventBuffer());
b3c86150 VS	171
	172	return true;
	173	}
	174
	175	wxTopLevelWindowDFB::~wxTopLevelWindowDFB()
	176	{
	177	m_isBeingDeleted = true;
	178
	179	wxTopLevelWindows.DeleteObject(this);
	180
	181	if ( wxTheApp->GetTopWindow() == this )
	182	wxTheApp->SetTopWindow(NULL);
	183
	184	if ( wxTopLevelWindows.empty() && wxTheApp->GetExitOnFrameDelete() )
	185	{
	186	wxTheApp->ExitMainLoop();
	187	}
	188
b3c86150 VS	189	wxDELETE(m_toPaint);
b3c86150 VS	190
82c74d89 VS	191	if ( !m_dfbwin )
	192	return;
	193
b3c86150 VS	194	// remove the TLW from DFBWindowID->wxTLW map:
b3c86150 VS	195	DFBWindowID winid;
52c8d32a	196	if ( m_dfbwin->GetID(&winid) )
b3c86150	197	gs_dfbWindowsMap.erase(winid);
82c74d89 VS	198
	199	m_dfbwin->Destroy();
	200	m_dfbwin.Reset();
b3c86150 VS	201	}
	202
	203	// ----------------------------------------------------------------------------
	204	// window size & position
	205	// ----------------------------------------------------------------------------
	206
	207	void wxTopLevelWindowDFB::DoGetPosition(int x, int y) const
	208	{
52c8d32a	209	m_dfbwin->GetPosition(x, y);
b3c86150 VS	210	}
	211
	212	void wxTopLevelWindowDFB::DoGetSize(int width, int height) const
	213	{
52c8d32a	214	m_dfbwin->GetSize(width, height);
b3c86150 VS	215	}
	216
	217	void wxTopLevelWindowDFB::DoMoveWindow(int x, int y, int width, int height)
	218	{
	219	wxPoint curpos = GetPosition();
	220	if ( curpos.x != x \|\| curpos.y != y )
	221	{
52c8d32a	222	m_dfbwin->MoveTo(x, y);
b3c86150 VS	223	}
	224
	225	wxSize cursize = GetSize();
	226	if ( cursize.x != width \|\| cursize.y != height )
	227	{
7807a2b4 VS	228	// changing window's size changes its surface:
	229	InvalidateDfbSurface();
	230
52c8d32a	231	m_dfbwin->Resize(width, height);
7807a2b4	232
b3c86150	233	// we must repaint the window after it changed size:
20671963 VS	234	if ( IsShown() )
20671963 VS	235	DoRefreshWindow();
b3c86150 VS	236	}
	237	}
	238
	239	// ----------------------------------------------------------------------------
	240	// showing and hiding
	241	// ----------------------------------------------------------------------------
	242
	243	#warning "FIXME: the rest of this file is almost same as for MGL, merge it"
	244	bool wxTopLevelWindowDFB::ShowFullScreen(bool show, long style)
	245	{
	246	if (show == m_fsIsShowing) return false; // return what?
	247
	248	m_fsIsShowing = show;
	249
	250	if (show)
	251	{
	252	m_fsSaveStyle = m_windowStyle;
	253	m_fsSaveFlag = style;
	254	GetPosition(&m_fsSaveFrame.x, &m_fsSaveFrame.y);
	255	GetSize(&m_fsSaveFrame.width, &m_fsSaveFrame.height);
	256
	257	if ( style & wxFULLSCREEN_NOCAPTION )
	258	m_windowStyle &= ~wxCAPTION;
	259	if ( style & wxFULLSCREEN_NOBORDER )
	260	m_windowStyle = wxSIMPLE_BORDER;
	261
	262	int x, y;
	263	wxDisplaySize(&x, &y);
	264	SetSize(0, 0, x, y);
	265	}
	266	else
	267	{
	268	m_windowStyle = m_fsSaveStyle;
	269	SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
	270	m_fsSaveFrame.width, m_fsSaveFrame.height);
	271	}
	272
	273	return true;
	274	}
	275
	276	bool wxTopLevelWindowDFB::Show(bool show)
	277	{
	278	if ( !wxTopLevelWindowBase::Show(show) )
	279	return false;
	280
	281	// hide/show the window by setting its opacity to 0/full:
52c8d32a	282	m_dfbwin->SetOpacity(show ? m_opacity : 0);
b3c86150 VS	283
	284	// If this is the first time Show was called, send size event,
	285	// so that the frame can adjust itself (think auto layout or single child)
	286	if ( !m_sizeSet )
	287	{
	288	m_sizeSet = true;
	289	wxSizeEvent event(GetSize(), GetId());
	290	event.SetEventObject(this);
	291	GetEventHandler()->ProcessEvent(event);
	292	}
	293
4ff28c37 VS	294	if ( show )
	295	{
	296	wxWindow *focused = wxWindow::FindFocus();
	297	if ( focused && focused->GetTLW() == this )
	298	{
	299	SetDfbFocus();
	300	}
	301	else if ( AcceptsFocus() )
	302	{
	303	// FIXME: we should probably always call SetDfbFocus instead
	304	// and call SetFocus() from wxActivateEvent/DWET_GOTFOCUS
	305	// handler
	306	SetFocus();
	307	}
	308	}
b3c86150 VS	309
	310	return true;
	311	}
	312
	313	bool wxTopLevelWindowDFB::SetTransparent(wxByte alpha)
	314	{
	315	if ( IsShown() )
	316	{
52c8d32a	317	if ( !m_dfbwin->SetOpacity(alpha) )
b3c86150 VS	318	return false;
	319	}
	320
	321	m_opacity = alpha;
	322	return true;
	323	}
	324
	325	// ----------------------------------------------------------------------------
	326	// maximize, minimize etc.
	327	// ----------------------------------------------------------------------------
	328
	329	void wxTopLevelWindowDFB::Maximize(bool maximize)
	330	{
	331	int x, y, w, h;
	332	wxClientDisplayRect(&x, &y, &w, &h);
	333
	334	if ( maximize && !m_isMaximized )
	335	{
	336	m_isMaximized = true;
	337
	338	GetPosition(&m_savedFrame.x, &m_savedFrame.y);
	339	GetSize(&m_savedFrame.width, &m_savedFrame.height);
	340
	341	SetSize(x, y, w, h);
	342	}
	343	else if ( !maximize && m_isMaximized )
	344	{
	345	m_isMaximized = false;
	346	SetSize(m_savedFrame.x, m_savedFrame.y,
	347	m_savedFrame.width, m_savedFrame.height);
	348	}
	349	}
	350
	351	bool wxTopLevelWindowDFB::IsMaximized() const
	352	{
	353	return m_isMaximized;
	354	}
	355
	356	void wxTopLevelWindowDFB::Restore()
	357	{
	358	if ( IsMaximized() )
	359	{
	360	Maximize(false);
	361	}
	362	}
	363
	364	void wxTopLevelWindowDFB::Iconize(bool WXUNUSED(iconize))
	365	{
	366	wxFAIL_MSG(wxT("Iconize not supported under wxDFB"));
	367	}
	368
	369	bool wxTopLevelWindowDFB::IsIconized() const
	370	{
	371	return false;
	372	}
	373
	374
	375	// ----------------------------------------------------------------------------
	376	// surfaces and painting
	377	// ----------------------------------------------------------------------------
	378
52c8d32a	379	wxIDirectFBSurfacePtr wxTopLevelWindowDFB::ObtainDfbSurface() const
b3c86150	380	{
52c8d32a	381	return m_dfbwin->GetSurface();
b3c86150 VS	382	}
	383
	384	void wxTopLevelWindowDFB::HandleQueuedPaintRequests()
	385	{
14ac4e3a	386	if ( m_toPaint->IsEmpty() )
b3c86150 VS	387	return; // nothing to do
b3c86150 VS	388
14ac4e3a VS	389	if ( IsFrozen() \|\| !IsShown() )
	390	{
	391	// nothing to do if the window is frozen or hidden; clear the queue
	392	// and return (note that it's OK to clear the queue even if the window
	393	// is frozen, because Thaw() calls Refresh()):
	394	m_toPaint->Clear();
	395	return;
	396	}
	397
b3c86150 VS	398	// process queued paint requests:
	399	wxRect winRect(wxPoint(0, 0), GetSize());
	400	wxRect paintedRect;
	401
20671963 VS	402	// important note: all DCs created from now until m_isPainting is reset to
	403	// false will not update the front buffer as this flag indicates that we'll
	404	// blit the entire back buffer to front soon
	405	m_isPainting = true;
	406
93259e59 VS	407	#ifdef __WXDEBUG__
	408	int requestsCount = 0;
	409	#endif
20671963	410
93259e59 VS	411	wxRect request;
93259e59 VS	412	while ( m_toPaint->GetNext(request) )
b3c86150	413	{
93259e59 VS	414	#ifdef __WXDEBUG__
	415	requestsCount++;
	416	#endif
	417	wxRect clipped(request);
b3c86150 VS	418	clipped.Intersect(winRect);
	419	if ( clipped.IsEmpty() )
	420	continue; // nothing to refresh
	421
20671963 VS	422	wxLogTrace(TRACE_PAINT,
	423	_T("%p ('%s'): processing paint request [%i,%i,%i,%i]"),
	424	this, GetName().c_str(),
	425	clipped.x, clipped.y, clipped.GetRight(), clipped.GetBottom());
	426
	427	PaintWindow(clipped);
b3c86150 VS	428
	429	// remember rectangle covering all repainted areas:
	430	if ( paintedRect.IsEmpty() )
	431	paintedRect = clipped;
	432	else
	433	paintedRect.Union(clipped);
	434	}
	435
20671963 VS	436	m_isPainting = false;
20671963 VS	437
14ac4e3a	438	m_toPaint->Clear();
b3c86150 VS	439
	440	if ( paintedRect.IsEmpty() )
	441	return; // no painting occurred, no need to flip
	442
20671963 VS	443	// Flip the surface to make the changes visible. Note that the rectangle we
	444	// flip is superset of the union of repainted rectangles (created as
	445	// "rectangles union" by wxRect::Union) and so some parts of the back
	446	// buffer that we didn't touch in this HandleQueuedPaintRequests call will
	447	// be copied to the front buffer as well. This is safe/correct thing to do
	448	// only because wx always use wxIDirectFBSurface::FlipToFront() and so
	449	// the back and front buffers contain the same data.
	450	//
	451	// Note that we do _not_ split m_toPaint into disjoint rectangles and
	452	// do FlipToFront() for each of them, because that could result in visible
	453	// updating of the screen; instead, we prefer to flip everything at once.
	454
b3c86150 VS	455	DFBRegion r = {paintedRect.GetLeft(), paintedRect.GetTop(),
	456	paintedRect.GetRight(), paintedRect.GetBottom()};
	457	DFBRegion *rptr = (winRect == paintedRect) ? NULL : &r;
	458
20671963 VS	459	GetDfbSurface()->FlipToFront(rptr);
	460
	461	wxLogTrace(TRACE_PAINT,
93259e59	462	_T("%p ('%s'): processed %i paint requests, flipped surface: [%i,%i,%i,%i]"),
20671963	463	this, GetName().c_str(),
93259e59	464	requestsCount,
20671963 VS	465	paintedRect.x, paintedRect.y,
20671963 VS	466	paintedRect.GetRight(), paintedRect.GetBottom());
b3c86150 VS	467	}
b3c86150 VS	468
20671963	469	void wxTopLevelWindowDFB::DoRefreshRect(const wxRect& rect)
b3c86150	470	{
bb78b682 VS	471	// don't overlap outside of the window (NB: 'rect' is in window coords):
	472	wxRect r(rect);
	473	r.Intersect(wxRect(GetSize()));
	474	if ( r.IsEmpty() )
	475	return;
20671963 VS	476
	477	wxLogTrace(TRACE_PAINT,
	478	_T("%p ('%s'): [TLW] refresh rect [%i,%i,%i,%i]"),
	479	this, GetName().c_str(),
	480	rect.x, rect.y, rect.GetRight(), rect.GetBottom());
	481
14ac4e3a	482	// defer painting until idle time or until Update() is called:
20671963	483	m_toPaint->Add(rect);
b3c86150 VS	484	}
	485
	486	void wxTopLevelWindowDFB::Update()
	487	{
	488	HandleQueuedPaintRequests();
	489	}
	490
	491	// ---------------------------------------------------------------------------
	492	// events handling
	493	// ---------------------------------------------------------------------------
	494
4ff28c37 VS	495	void wxTopLevelWindowDFB::SetDfbFocus()
	496	{
	497	wxCHECK_RET( IsShown(), _T("cannot set focus to hidden window") );
	498	wxASSERT_MSG( FindFocus() && FindFocus()->GetTLW() == this,
	499	_T("setting DirectFB focus to unexpected window") );
	500
	501	GetDirectFBWindow()->RequestFocus();
	502	}
	503
b3c86150 VS	504	/* static */
	505	void wxTopLevelWindowDFB::HandleDFBWindowEvent(const wxDFBWindowEvent& event_)
	506	{
	507	const DFBWindowEvent& event = event_;
	508
	509	if ( gs_dfbWindowsMap.find(event.window_id) == gs_dfbWindowsMap.end() )
	510	{
	511	wxLogTrace(TRACE_EVENTS,
	512	_T("received event for unknown DirectFB window, ignoring"));
	513	return;
	514	}
	515
	516	wxTopLevelWindowDFB *tlw = gs_dfbWindowsMap[event.window_id];
	517	wxWindow *recipient = NULL;
	518	void (wxWindow::*handlerFunc)(const wxDFBWindowEvent&) = NULL;
	519
	520	switch ( event.type )
	521	{
	522	case DWET_KEYDOWN:
	523	case DWET_KEYUP:
	524	{
	525	recipient = wxWindow::FindFocus();
	526	handlerFunc = &wxWindowDFB::HandleKeyEvent;
	527	break;
	528	}
	529
	530	case DWET_NONE:
	531	case DWET_ALL:
	532	{
	533	wxFAIL_MSG( _T("invalid event type") );
	534	break;
	535	}
a43c3ed0 VZ	536
	537	default:
	538	// we're not interested in them here
	539	break;
b3c86150 VS	540	}
	541
	542	if ( !recipient )
	543	{
	544	wxLogTrace(TRACE_EVENTS, _T("ignoring event: no recipient window"));
	545	return;
	546	}
	547
	548	wxCHECK_RET( recipient && recipient->GetTLW() == tlw,
	549	_T("event recipient not in TLW which received the event") );
	550
	551	// process the event:
	552	(recipient->*handlerFunc)(event_);
	553	}
	554
	555	// ---------------------------------------------------------------------------
	556	// idle events processing
	557	// ---------------------------------------------------------------------------
	558
	559	void wxTopLevelWindowDFB::OnInternalIdle()
	560	{
	561	wxTopLevelWindowBase::OnInternalIdle();
	562	HandleQueuedPaintRequests();
	563	}