initial (not yet working) code for DirectFB port
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@40865 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
993
src/dfb/window.cpp
Normal file
993
src/dfb/window.cpp
Normal file
@@ -0,0 +1,993 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: src/dfb/window.cpp
|
||||
// Purpose: wxWindow
|
||||
// Author: Vaclav Slavik
|
||||
// (based on GTK, MSW, MGL implementations)
|
||||
// Created: 2006-80-10
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) 2006 REA Elektronik GmbH
|
||||
// Licence: wxWindows licence
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ===========================================================================
|
||||
// declarations
|
||||
// ===========================================================================
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// headers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#include "wx/window.h"
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/dcclient.h"
|
||||
#endif
|
||||
|
||||
#include "wx/caret.h"
|
||||
|
||||
#include "wx/dfb/private.h"
|
||||
|
||||
#define TRACE_EVENTS _T("events")
|
||||
#define TRACE_PAINT _T("paint")
|
||||
|
||||
// ===========================================================================
|
||||
// implementation
|
||||
// ===========================================================================
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// global variables
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// the window that has keyboard focus:
|
||||
static wxWindowDFB *gs_focusedWindow = NULL;
|
||||
// the window that is about to be focused after currently focused
|
||||
// one looses focus:
|
||||
static wxWindow *gs_toBeFocusedWindow = NULL;
|
||||
// the window that has mouse capture
|
||||
static wxWindowDFB *gs_mouseCapture = NULL;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// event tables
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// in wxUniv this class is abstract because it doesn't have DoPopupMenu()
|
||||
IMPLEMENT_ABSTRACT_CLASS(wxWindowDFB, wxWindowBase)
|
||||
|
||||
BEGIN_EVENT_TABLE(wxWindowDFB, wxWindowBase)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constructors and such
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
void wxWindowDFB::Init()
|
||||
{
|
||||
m_isShown = true;
|
||||
m_frozenness = 0;
|
||||
m_tlw = NULL;
|
||||
}
|
||||
|
||||
// Destructor
|
||||
wxWindowDFB::~wxWindowDFB()
|
||||
{
|
||||
SendDestroyEvent();
|
||||
|
||||
m_isBeingDeleted = true;
|
||||
|
||||
if ( gs_mouseCapture == this )
|
||||
ReleaseMouse();
|
||||
|
||||
#warning "FIXME: what to do with gs_activeFrame here and elsewhere?"
|
||||
#if 0
|
||||
if (gs_activeFrame == this)
|
||||
{
|
||||
gs_activeFrame = NULL;
|
||||
// activate next frame in Z-order:
|
||||
if ( m_wnd->prev )
|
||||
{
|
||||
wxWindowDFB *win = (wxWindowDFB*)m_wnd->prev->userData;
|
||||
win->SetFocus();
|
||||
}
|
||||
else if ( m_wnd->next )
|
||||
{
|
||||
wxWindowDFB *win = (wxWindowDFB*)m_wnd->next->userData;
|
||||
win->SetFocus();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if ( gs_focusedWindow == this )
|
||||
KillFocus();
|
||||
|
||||
DestroyChildren();
|
||||
}
|
||||
|
||||
// real construction (Init() must have been called before!)
|
||||
bool wxWindowDFB::Create(wxWindow *parent,
|
||||
wxWindowID id,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
long style,
|
||||
const wxString& name)
|
||||
{
|
||||
if ( !m_tlw && parent )
|
||||
m_tlw = parent->GetTLW();
|
||||
|
||||
if ( !CreateBase(parent, id, pos, size, style, wxDefaultValidator, name) )
|
||||
return false;
|
||||
|
||||
if ( parent )
|
||||
parent->AddChild(this);
|
||||
|
||||
int x, y, w, h;
|
||||
x = pos.x, y = pos.y;
|
||||
if ( x == -1 ) x = 0;
|
||||
if ( y == -1 ) y = 0;
|
||||
w = WidthDefault(size.x);
|
||||
h = HeightDefault(size.y);
|
||||
SetSize(x, y, w, h);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// surface access
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
IDirectFBSurfacePtr wxWindowDFB::ObtainDfbSurface() const
|
||||
{
|
||||
wxCHECK_MSG( m_parent, NULL, _T("parentless window?") );
|
||||
|
||||
IDirectFBSurfacePtr parentSurface(m_parent->GetDfbSurface());
|
||||
wxCHECK_MSG( parentSurface, NULL, _T("invalid parent surface") );
|
||||
|
||||
wxRect r(GetRect());
|
||||
AdjustForParentClientOrigin(r.x, r.y, 0);
|
||||
DFBRectangle rect = { r.x, r.y, r.width, r.height };
|
||||
|
||||
IDirectFBSurfacePtr surface;
|
||||
DFB_CALL( parentSurface->GetSubSurface(parentSurface, &rect, &surface) );
|
||||
return surface;
|
||||
}
|
||||
|
||||
IDirectFBSurfacePtr wxWindowDFB::GetDfbSurface()
|
||||
{
|
||||
if ( !m_surface )
|
||||
{
|
||||
m_surface = ObtainDfbSurface();
|
||||
wxASSERT_MSG( m_surface, _T("invalid DirectFB surface") );
|
||||
}
|
||||
|
||||
return m_surface;
|
||||
}
|
||||
|
||||
void wxWindowDFB::InvalidateDfbSurface()
|
||||
{
|
||||
m_surface = NULL;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// basic operations
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
void wxWindowDFB::SetFocus()
|
||||
{
|
||||
if ( gs_focusedWindow == this ) return;
|
||||
|
||||
wxWindowDFB *oldFocusedWindow = gs_focusedWindow;
|
||||
|
||||
if ( gs_focusedWindow )
|
||||
{
|
||||
gs_toBeFocusedWindow = (wxWindow*)this;
|
||||
gs_focusedWindow->KillFocus();
|
||||
gs_toBeFocusedWindow = NULL;
|
||||
}
|
||||
|
||||
#warning "FIXME: implement in terms of DWET_{GOT,LOST}FOCUS"
|
||||
|
||||
IDirectFBWindowPtr dfbwin(m_tlw->GetDirectFBWindow());
|
||||
#warning "FIXME: RequestFocus() may only be called on visible TLW"
|
||||
if ( !DFB_CALL( dfbwin->RequestFocus(dfbwin) ) )
|
||||
return;
|
||||
|
||||
gs_focusedWindow = this;
|
||||
|
||||
#warning "FIXME: keep this or not? not, think multiapp core"
|
||||
#if 0
|
||||
wxWindowDFB *active = wxGetTopLevelParent((wxWindow*)this);
|
||||
if ( !(m_windowStyle & wxPOPUP_WINDOW) && active != gs_activeFrame )
|
||||
{
|
||||
if ( gs_activeFrame )
|
||||
{
|
||||
wxActivateEvent event(wxEVT_ACTIVATE, false, gs_activeFrame->GetId());
|
||||
event.SetEventObject(gs_activeFrame);
|
||||
gs_activeFrame->GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
|
||||
gs_activeFrame = active;
|
||||
wxActivateEvent event(wxEVT_ACTIVATE, true, gs_activeFrame->GetId());
|
||||
event.SetEventObject(gs_activeFrame);
|
||||
gs_activeFrame->GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
#endif
|
||||
|
||||
wxFocusEvent event(wxEVT_SET_FOCUS, GetId());
|
||||
event.SetEventObject(this);
|
||||
event.SetWindow((wxWindow*)oldFocusedWindow);
|
||||
GetEventHandler()->ProcessEvent(event);
|
||||
|
||||
#if wxUSE_CARET
|
||||
// caret needs to be informed about focus change
|
||||
wxCaret *caret = GetCaret();
|
||||
if ( caret )
|
||||
caret->OnSetFocus();
|
||||
#endif // wxUSE_CARET
|
||||
}
|
||||
|
||||
void wxWindowDFB::KillFocus()
|
||||
{
|
||||
if ( gs_focusedWindow != this ) return;
|
||||
gs_focusedWindow = NULL;
|
||||
|
||||
if ( m_isBeingDeleted ) return;
|
||||
|
||||
#if wxUSE_CARET
|
||||
// caret needs to be informed about focus change
|
||||
wxCaret *caret = GetCaret();
|
||||
if ( caret )
|
||||
caret->OnKillFocus();
|
||||
#endif // wxUSE_CARET
|
||||
|
||||
wxFocusEvent event(wxEVT_KILL_FOCUS, GetId());
|
||||
event.SetEventObject(this);
|
||||
event.SetWindow(gs_toBeFocusedWindow);
|
||||
GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// this wxWindowBase function is implemented here (in platform-specific file)
|
||||
// because it is static and so couldn't be made virtual
|
||||
// ----------------------------------------------------------------------------
|
||||
wxWindow *wxWindowBase::DoFindFocus()
|
||||
{
|
||||
return (wxWindow*)gs_focusedWindow;
|
||||
}
|
||||
|
||||
bool wxWindowDFB::Show(bool show)
|
||||
{
|
||||
if ( !wxWindowBase::Show(show) )
|
||||
return false;
|
||||
|
||||
// Unlike Refresh(), DoRefreshWindow() doesn't check visibility, so
|
||||
// call it to force refresh of either this window (if showing) or its
|
||||
// parent area at the place of this window (if hiding):
|
||||
DoRefreshWindow();
|
||||
|
||||
#warning "FIXME: all of this must be implemented for DFB"
|
||||
#if 0
|
||||
DFB_wmShowWindow(m_wnd, show);
|
||||
|
||||
if (!show && gs_activeFrame == this)
|
||||
{
|
||||
// activate next frame in Z-order:
|
||||
if ( m_wnd->prev )
|
||||
{
|
||||
wxWindowDFB *win = (wxWindowDFB*)m_wnd->prev->userData;
|
||||
win->SetFocus();
|
||||
}
|
||||
else if ( m_wnd->next )
|
||||
{
|
||||
wxWindowDFB *win = (wxWindowDFB*)m_wnd->next->userData;
|
||||
win->SetFocus();
|
||||
}
|
||||
else
|
||||
{
|
||||
gs_activeFrame = NULL;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Raise the window to the top of the Z order
|
||||
void wxWindowDFB::Raise()
|
||||
{
|
||||
wxFAIL_MSG( _T("Raise() not implemented") );
|
||||
}
|
||||
|
||||
// Lower the window to the bottom of the Z order
|
||||
void wxWindowDFB::Lower()
|
||||
{
|
||||
wxFAIL_MSG( _T("Lower() not implemented") );
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoCaptureMouse()
|
||||
{
|
||||
#warning "implement this"
|
||||
#if 0
|
||||
if ( gs_mouseCapture )
|
||||
DFB_wmUncaptureEvents(gs_mouseCapture->m_wnd, wxDFB_CAPTURE_MOUSE);
|
||||
#endif
|
||||
gs_mouseCapture = this;
|
||||
#if 0
|
||||
DFB_wmCaptureEvents(m_wnd, EVT_MOUSEEVT, wxDFB_CAPTURE_MOUSE);
|
||||
#endif
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoReleaseMouse()
|
||||
{
|
||||
wxASSERT_MSG( gs_mouseCapture == this, wxT("attempt to release mouse, but this window hasn't captured it") );
|
||||
|
||||
#warning "implement this"
|
||||
#if 0
|
||||
DFB_wmUncaptureEvents(m_wnd, wxDFB_CAPTURE_MOUSE);
|
||||
#endif
|
||||
gs_mouseCapture = NULL;
|
||||
}
|
||||
|
||||
/* static */ wxWindow *wxWindowBase::GetCapture()
|
||||
{
|
||||
return (wxWindow*)gs_mouseCapture;
|
||||
}
|
||||
|
||||
bool wxWindowDFB::SetCursor(const wxCursor& cursor)
|
||||
{
|
||||
if ( !wxWindowBase::SetCursor(cursor) )
|
||||
{
|
||||
// no change
|
||||
return false;
|
||||
}
|
||||
|
||||
#warning "implement this"
|
||||
#if 0
|
||||
if ( m_cursor.Ok() )
|
||||
DFB_wmSetWindowCursor(m_wnd, *m_cursor.GetDFBCursor());
|
||||
else
|
||||
DFB_wmSetWindowCursor(m_wnd, *wxSTANDARD_CURSOR->GetDFBCursor());
|
||||
#endif
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void wxWindowDFB::WarpPointer(int x, int y)
|
||||
{
|
||||
int w, h;
|
||||
wxDisplaySize(&w, &h);
|
||||
|
||||
ClientToScreen(&x, &y);
|
||||
if ( x < 0 ) x = 0;
|
||||
if ( y < 0 ) y = 0;
|
||||
if ( x >= w ) x = w-1;
|
||||
if ( y >= h ) y = h-1;
|
||||
|
||||
IDirectFBDisplayLayerPtr layer = wxDfbGetDisplayLayer();
|
||||
wxCHECK_RET( layer, _T("no display layer") );
|
||||
|
||||
layer->WarpCursor(layer, x, y);
|
||||
}
|
||||
|
||||
// Set this window to be the child of 'parent'.
|
||||
bool wxWindowDFB::Reparent(wxWindowBase *parent)
|
||||
{
|
||||
if ( !wxWindowBase::Reparent(parent) )
|
||||
return false;
|
||||
|
||||
#warning "implement this"
|
||||
wxFAIL_MSG( _T("reparenting not yet implemented") );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// moving and resizing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
// Get total size
|
||||
void wxWindowDFB::DoGetSize(int *x, int *y) const
|
||||
{
|
||||
if (x) *x = m_rect.width;
|
||||
if (y) *y = m_rect.height;
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoGetPosition(int *x, int *y) const
|
||||
{
|
||||
if (x) *x = m_rect.x;
|
||||
if (y) *y = m_rect.y;
|
||||
}
|
||||
|
||||
static wxPoint GetScreenPosOfClientOrigin(const wxWindowDFB *win)
|
||||
{
|
||||
wxCHECK_MSG( win, wxPoint(0, 0), _T("no window provided") );
|
||||
|
||||
wxPoint pt(win->GetPosition() + win->GetClientAreaOrigin());
|
||||
|
||||
if ( !win->IsTopLevel() )
|
||||
pt += GetScreenPosOfClientOrigin(win->GetParent());
|
||||
|
||||
return pt;
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoScreenToClient(int *x, int *y) const
|
||||
{
|
||||
wxPoint o = GetScreenPosOfClientOrigin(this);
|
||||
|
||||
if (x) *x -= o.x;
|
||||
if (y) *y -= o.y;
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoClientToScreen(int *x, int *y) const
|
||||
{
|
||||
wxPoint o = GetScreenPosOfClientOrigin(this);
|
||||
|
||||
if (x) *x += o.x;
|
||||
if (y) *y += o.y;
|
||||
}
|
||||
|
||||
// Get size *available for subwindows* i.e. excluding menu bar etc.
|
||||
void wxWindowDFB::DoGetClientSize(int *x, int *y) const
|
||||
{
|
||||
DoGetSize(x, y);
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoMoveWindow(int x, int y, int width, int height)
|
||||
{
|
||||
wxRect oldpos(m_rect);
|
||||
wxRect newpos(x, y, width, height);
|
||||
|
||||
m_rect = newpos;
|
||||
|
||||
// window's position+size changed and so did the subsurface that covers it
|
||||
InvalidateDfbSurface();
|
||||
|
||||
if ( IsShown() )
|
||||
{
|
||||
// queue both former and new position of the window for repainting:
|
||||
wxWindow *parent = GetParent();
|
||||
wxPoint origin(parent->GetClientAreaOrigin());
|
||||
oldpos.Offset(origin);
|
||||
newpos.Offset(origin);
|
||||
parent->RefreshRect(oldpos);
|
||||
parent->RefreshRect(newpos);
|
||||
}
|
||||
}
|
||||
|
||||
// set the size of the window: if the dimensions are positive, just use them,
|
||||
// but if any of them is equal to -1, it means that we must find the value for
|
||||
// it ourselves (unless sizeFlags contains wxSIZE_ALLOW_MINUS_ONE flag, in
|
||||
// which case -1 is a valid value for x and y)
|
||||
//
|
||||
// If sizeFlags contains wxSIZE_AUTO_WIDTH/HEIGHT flags (default), we calculate
|
||||
// the width/height to best suit our contents, otherwise we reuse the current
|
||||
// width/height
|
||||
void wxWindowDFB::DoSetSize(int x, int y, int width, int height, int sizeFlags)
|
||||
{
|
||||
// get the current size and position...
|
||||
int currentX, currentY;
|
||||
GetPosition(¤tX, ¤tY);
|
||||
int currentW,currentH;
|
||||
GetSize(¤tW, ¤tH);
|
||||
|
||||
if ( x == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
|
||||
x = currentX;
|
||||
if ( y == -1 && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
|
||||
y = currentY;
|
||||
|
||||
// ... and don't do anything (avoiding flicker) if it's already ok
|
||||
if ( x == currentX && y == currentY &&
|
||||
width == currentW && height == currentH )
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AdjustForParentClientOrigin(x, y, sizeFlags);
|
||||
|
||||
wxSize size(-1, -1);
|
||||
if ( width == -1 )
|
||||
{
|
||||
if ( sizeFlags & wxSIZE_AUTO_WIDTH )
|
||||
{
|
||||
size = DoGetBestSize();
|
||||
width = size.x;
|
||||
}
|
||||
else
|
||||
{
|
||||
// just take the current one
|
||||
width = currentW;
|
||||
}
|
||||
}
|
||||
|
||||
if ( height == -1 )
|
||||
{
|
||||
if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
|
||||
{
|
||||
if ( size.x == -1 )
|
||||
{
|
||||
size = DoGetBestSize();
|
||||
}
|
||||
//else: already called DoGetBestSize() above
|
||||
|
||||
height = size.y;
|
||||
}
|
||||
else
|
||||
{
|
||||
// just take the current one
|
||||
height = currentH;
|
||||
}
|
||||
}
|
||||
|
||||
int maxWidth = GetMaxWidth(),
|
||||
minWidth = GetMinWidth(),
|
||||
maxHeight = GetMaxHeight(),
|
||||
minHeight = GetMinHeight();
|
||||
|
||||
if ( minWidth != -1 && width < minWidth ) width = minWidth;
|
||||
if ( maxWidth != -1 && width > maxWidth ) width = maxWidth;
|
||||
if ( minHeight != -1 && height < minHeight ) height = minHeight;
|
||||
if ( maxHeight != -1 && height > maxHeight ) height = maxHeight;
|
||||
|
||||
if ( m_rect.x != x || m_rect.y != y ||
|
||||
m_rect.width != width || m_rect.height != height )
|
||||
{
|
||||
DoMoveWindow(x, y, width, height);
|
||||
|
||||
wxSize newSize(width, height);
|
||||
wxSizeEvent event(newSize, GetId());
|
||||
event.SetEventObject(this);
|
||||
GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoSetClientSize(int width, int height)
|
||||
{
|
||||
SetSize(width, height);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// text metrics
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
int wxWindowDFB::GetCharHeight() const
|
||||
{
|
||||
wxWindowDC dc((wxWindow*)this);
|
||||
return dc.GetCharHeight();
|
||||
}
|
||||
|
||||
int wxWindowDFB::GetCharWidth() const
|
||||
{
|
||||
wxWindowDC dc((wxWindow*)this);
|
||||
return dc.GetCharWidth();
|
||||
}
|
||||
|
||||
void wxWindowDFB::GetTextExtent(const wxString& string,
|
||||
int *x, int *y,
|
||||
int *descent, int *externalLeading,
|
||||
const wxFont *theFont) const
|
||||
{
|
||||
wxWindowDC dc((wxWindow*)this);
|
||||
dc.GetTextExtent(string, x, y, descent, externalLeading, (wxFont*)theFont);
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// painting
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
void wxWindowDFB::Clear()
|
||||
{
|
||||
wxClientDC dc((wxWindow *)this);
|
||||
wxBrush brush(GetBackgroundColour(), wxSOLID);
|
||||
dc.SetBackground(brush);
|
||||
dc.Clear();
|
||||
}
|
||||
|
||||
void wxWindowDFB::Refresh(bool eraseBack, const wxRect *rect)
|
||||
{
|
||||
if ( !IsShown() || IsFrozen() )
|
||||
return;
|
||||
|
||||
if ( rect )
|
||||
DoRefreshRect(*rect, eraseBack);
|
||||
else
|
||||
DoRefreshWindow(eraseBack);
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoRefreshWindow(bool eraseBack)
|
||||
{
|
||||
DoRefreshRect(wxRect(wxPoint(0, 0), GetSize()), eraseBack);
|
||||
}
|
||||
|
||||
void wxWindowDFB::DoRefreshRect(const wxRect& rect, bool eraseBack)
|
||||
{
|
||||
wxWindow *parent = GetParent();
|
||||
wxCHECK_RET( parent, _T("no parent") );
|
||||
|
||||
// convert the refresh rectangle to parent's coordinates and
|
||||
// recursively refresh the parent:
|
||||
wxRect r(rect);
|
||||
r.Offset(GetPosition());
|
||||
r.Offset(parent->GetClientAreaOrigin());
|
||||
|
||||
parent->DoRefreshRect(r, eraseBack);
|
||||
}
|
||||
|
||||
void wxWindowDFB::Update()
|
||||
{
|
||||
if ( !IsShown() || IsFrozen() )
|
||||
return;
|
||||
|
||||
GetParent()->Update();
|
||||
}
|
||||
|
||||
void wxWindowDFB::Freeze()
|
||||
{
|
||||
m_frozenness++;
|
||||
}
|
||||
|
||||
void wxWindowDFB::Thaw()
|
||||
{
|
||||
wxASSERT_MSG( IsFrozen(), _T("Thaw() without matching Freeze()") );
|
||||
|
||||
if ( --m_frozenness == 0 )
|
||||
{
|
||||
if ( IsShown() )
|
||||
Refresh();
|
||||
}
|
||||
}
|
||||
|
||||
void wxWindowDFB::PaintWindow(const wxRect& rect, bool eraseBackground)
|
||||
{
|
||||
if ( IsFrozen() )
|
||||
return; // don't paint anything if the window is frozen
|
||||
|
||||
wxLogTrace(TRACE_PAINT,
|
||||
_T("%p ('%s'): paiting region [x=%i,y=%i,w=%i,h=%i]"),
|
||||
this, GetName().c_str(),
|
||||
rect.x, rect.y, rect.width, rect.height);
|
||||
|
||||
m_updateRegion = rect;
|
||||
|
||||
// FIXME_DFB: don't waste time rendering the area if it's fully covered
|
||||
// by some children, go directly to rendering the children
|
||||
|
||||
#if wxUSE_CARET
|
||||
// must hide caret temporarily, otherwise we'd get rendering artifacts
|
||||
wxCaret *caret = GetCaret();
|
||||
if ( caret )
|
||||
caret->Hide();
|
||||
#endif // wxUSE_CARET
|
||||
|
||||
if ( eraseBackground )
|
||||
{
|
||||
wxWindowDC dc((wxWindow*)this);
|
||||
wxEraseEvent eventEr(m_windowId, &dc);
|
||||
eventEr.SetEventObject(this);
|
||||
GetEventHandler()->ProcessEvent(eventEr);
|
||||
}
|
||||
|
||||
wxNcPaintEvent eventNc(GetId());
|
||||
eventNc.SetEventObject(this);
|
||||
GetEventHandler()->ProcessEvent(eventNc);
|
||||
|
||||
wxPaintEvent eventPt(GetId());
|
||||
eventPt.SetEventObject(this);
|
||||
GetEventHandler()->ProcessEvent(eventPt);
|
||||
|
||||
#if wxUSE_CARET
|
||||
if ( caret )
|
||||
caret->Show();
|
||||
#endif // wxUSE_CARET
|
||||
|
||||
wxPoint origin = GetClientAreaOrigin();
|
||||
wxWindowList& children = GetChildren();
|
||||
for ( wxWindowList::iterator i = children.begin();
|
||||
i != children.end(); ++i )
|
||||
{
|
||||
wxWindow *child = *i;
|
||||
|
||||
// compute child's area to repaint
|
||||
wxRect childrect(child->GetRect());
|
||||
childrect.Offset(origin);
|
||||
childrect.Intersect(rect);
|
||||
if ( childrect.IsEmpty() )
|
||||
continue;
|
||||
|
||||
// and repaint it:
|
||||
wxPoint childpos(child->GetPosition());
|
||||
childrect.Offset(-childpos.x, -childpos.y);
|
||||
childrect.Offset(-origin.x, -origin.y);
|
||||
child->PaintWindow(childrect, eraseBackground);
|
||||
}
|
||||
|
||||
m_updateRegion.Clear();
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// events handling
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#define KEY(dfb, wx) \
|
||||
case dfb: \
|
||||
wxLogTrace(TRACE_EVENTS, \
|
||||
_T("key " #dfb " mapped to " #wx)); \
|
||||
return wx
|
||||
|
||||
// returns translated keycode, i.e. the one for KEYUP/KEYDOWN where 'a'..'z' is
|
||||
// translated to 'A'..'Z'
|
||||
static long GetTranslatedKeyCode(DFBInputDeviceKeyIdentifier key_id)
|
||||
{
|
||||
switch ( key_id )
|
||||
{
|
||||
KEY(DIKI_UNKNOWN, 0);
|
||||
|
||||
KEY(DIKI_A, 'A');
|
||||
KEY(DIKI_B, 'B');
|
||||
KEY(DIKI_C, 'C');
|
||||
KEY(DIKI_D, 'D');
|
||||
KEY(DIKI_E, 'E');
|
||||
KEY(DIKI_F, 'F');
|
||||
KEY(DIKI_G, 'G');
|
||||
KEY(DIKI_H, 'H');
|
||||
KEY(DIKI_I, 'I');
|
||||
KEY(DIKI_J, 'J');
|
||||
KEY(DIKI_K, 'K');
|
||||
KEY(DIKI_L, 'L');
|
||||
KEY(DIKI_M, 'M');
|
||||
KEY(DIKI_N, 'N');
|
||||
KEY(DIKI_O, 'O');
|
||||
KEY(DIKI_P, 'P');
|
||||
KEY(DIKI_Q, 'Q');
|
||||
KEY(DIKI_R, 'R');
|
||||
KEY(DIKI_S, 'S');
|
||||
KEY(DIKI_T, 'T');
|
||||
KEY(DIKI_U, 'U');
|
||||
KEY(DIKI_V, 'V');
|
||||
KEY(DIKI_W, 'W');
|
||||
KEY(DIKI_X, 'X');
|
||||
KEY(DIKI_Y, 'Y');
|
||||
KEY(DIKI_Z, 'Z');
|
||||
|
||||
KEY(DIKI_0, '0');
|
||||
KEY(DIKI_1, '1');
|
||||
KEY(DIKI_2, '2');
|
||||
KEY(DIKI_3, '3');
|
||||
KEY(DIKI_4, '4');
|
||||
KEY(DIKI_5, '5');
|
||||
KEY(DIKI_6, '6');
|
||||
KEY(DIKI_7, '7');
|
||||
KEY(DIKI_8, '8');
|
||||
KEY(DIKI_9, '9');
|
||||
|
||||
KEY(DIKI_F1, WXK_F1);
|
||||
KEY(DIKI_F2, WXK_F2);
|
||||
KEY(DIKI_F3, WXK_F3);
|
||||
KEY(DIKI_F4, WXK_F4);
|
||||
KEY(DIKI_F5, WXK_F5);
|
||||
KEY(DIKI_F6, WXK_F6);
|
||||
KEY(DIKI_F7, WXK_F7);
|
||||
KEY(DIKI_F8, WXK_F8);
|
||||
KEY(DIKI_F9, WXK_F9);
|
||||
KEY(DIKI_F10, WXK_F10);
|
||||
KEY(DIKI_F11, WXK_F11);
|
||||
KEY(DIKI_F12, WXK_F12);
|
||||
|
||||
KEY(DIKI_SHIFT_L, WXK_SHIFT);
|
||||
KEY(DIKI_SHIFT_R, WXK_SHIFT);
|
||||
KEY(DIKI_CONTROL_L, WXK_CONTROL);
|
||||
KEY(DIKI_CONTROL_R, WXK_CONTROL);
|
||||
KEY(DIKI_ALT_L, WXK_ALT);
|
||||
KEY(DIKI_ALT_R, WXK_ALT);
|
||||
KEY(DIKI_META_L, 0);
|
||||
KEY(DIKI_META_R, 0);
|
||||
KEY(DIKI_SUPER_L, 0);
|
||||
KEY(DIKI_SUPER_R, 0);
|
||||
KEY(DIKI_HYPER_L, 0);
|
||||
KEY(DIKI_HYPER_R, 0);
|
||||
|
||||
KEY(DIKI_CAPS_LOCK, 0);
|
||||
KEY(DIKI_NUM_LOCK, WXK_NUMLOCK);
|
||||
KEY(DIKI_SCROLL_LOCK, 0);
|
||||
|
||||
KEY(DIKI_ESCAPE, WXK_ESCAPE);
|
||||
KEY(DIKI_LEFT, WXK_LEFT);
|
||||
KEY(DIKI_RIGHT, WXK_RIGHT);
|
||||
KEY(DIKI_UP, WXK_UP);
|
||||
KEY(DIKI_DOWN, WXK_DOWN);
|
||||
KEY(DIKI_TAB, WXK_TAB);
|
||||
KEY(DIKI_ENTER, WXK_RETURN);
|
||||
KEY(DIKI_SPACE, WXK_SPACE);
|
||||
KEY(DIKI_BACKSPACE, WXK_BACK);
|
||||
KEY(DIKI_INSERT, WXK_INSERT);
|
||||
KEY(DIKI_DELETE, WXK_DELETE);
|
||||
KEY(DIKI_HOME, WXK_HOME);
|
||||
KEY(DIKI_END, WXK_END);
|
||||
KEY(DIKI_PAGE_UP, WXK_PAGEUP);
|
||||
KEY(DIKI_PAGE_DOWN, WXK_PAGEDOWN);
|
||||
KEY(DIKI_PRINT, WXK_PRINT);
|
||||
KEY(DIKI_PAUSE, WXK_PAUSE);
|
||||
|
||||
KEY(DIKI_QUOTE_LEFT, '`');
|
||||
KEY(DIKI_MINUS_SIGN, '-');
|
||||
KEY(DIKI_EQUALS_SIGN, '=');
|
||||
KEY(DIKI_BRACKET_LEFT, '[');
|
||||
KEY(DIKI_BRACKET_RIGHT, ']');
|
||||
KEY(DIKI_BACKSLASH, '\\');
|
||||
KEY(DIKI_SEMICOLON, ';');
|
||||
KEY(DIKI_QUOTE_RIGHT, '\'');
|
||||
KEY(DIKI_COMMA, ',');
|
||||
KEY(DIKI_PERIOD, '.');
|
||||
KEY(DIKI_SLASH, '/');
|
||||
|
||||
KEY(DIKI_LESS_SIGN, '<');
|
||||
|
||||
KEY(DIKI_KP_DIV, WXK_NUMPAD_DIVIDE);
|
||||
KEY(DIKI_KP_MULT, WXK_NUMPAD_MULTIPLY);
|
||||
KEY(DIKI_KP_MINUS, WXK_NUMPAD_SUBTRACT);
|
||||
KEY(DIKI_KP_PLUS, WXK_NUMPAD_ADD);
|
||||
KEY(DIKI_KP_ENTER, WXK_NUMPAD_ENTER);
|
||||
KEY(DIKI_KP_SPACE, WXK_NUMPAD_SPACE);
|
||||
KEY(DIKI_KP_TAB, WXK_NUMPAD_TAB);
|
||||
KEY(DIKI_KP_F1, WXK_NUMPAD_F1);
|
||||
KEY(DIKI_KP_F2, WXK_NUMPAD_F2);
|
||||
KEY(DIKI_KP_F3, WXK_NUMPAD_F3);
|
||||
KEY(DIKI_KP_F4, WXK_NUMPAD_F4);
|
||||
KEY(DIKI_KP_EQUAL, WXK_NUMPAD_EQUAL);
|
||||
KEY(DIKI_KP_SEPARATOR, WXK_NUMPAD_SEPARATOR);
|
||||
|
||||
KEY(DIKI_KP_DECIMAL, WXK_NUMPAD_DECIMAL);
|
||||
KEY(DIKI_KP_0, WXK_NUMPAD0);
|
||||
KEY(DIKI_KP_1, WXK_NUMPAD1);
|
||||
KEY(DIKI_KP_2, WXK_NUMPAD2);
|
||||
KEY(DIKI_KP_3, WXK_NUMPAD3);
|
||||
KEY(DIKI_KP_4, WXK_NUMPAD4);
|
||||
KEY(DIKI_KP_5, WXK_NUMPAD5);
|
||||
KEY(DIKI_KP_6, WXK_NUMPAD6);
|
||||
KEY(DIKI_KP_7, WXK_NUMPAD7);
|
||||
KEY(DIKI_KP_8, WXK_NUMPAD8);
|
||||
KEY(DIKI_KP_9, WXK_NUMPAD9);
|
||||
|
||||
case DIKI_KEYDEF_END:
|
||||
case DIKI_NUMBER_OF_KEYS:
|
||||
wxFAIL_MSG( _T("invalid key_id value") );
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0; // silence compiler warnings
|
||||
}
|
||||
|
||||
// returns untranslated keycode, i.e. for EVT_CHAR, where characters are left in
|
||||
// the form they were entered (lowercase, diacritics etc.)
|
||||
static long GetUntraslatedKeyCode(DFBInputDeviceKeyIdentifier key_id,
|
||||
DFBInputDeviceKeySymbol key_symbol)
|
||||
{
|
||||
switch ( DFB_KEY_TYPE(key_symbol) )
|
||||
{
|
||||
case DIKT_UNICODE:
|
||||
#if wxUSE_UNICODE
|
||||
return key_symbol;
|
||||
#else
|
||||
if ( key_symbol < 128 )
|
||||
return key_symbol;
|
||||
else
|
||||
{
|
||||
#if wxUSE_WCHAR_T
|
||||
wchar_t chr = key_symbol;
|
||||
wxCharBuffer buf(wxConvUI->cWC2MB(&chr, 1, NULL));
|
||||
if ( buf )
|
||||
return *buf; // may be 0 if failed
|
||||
else
|
||||
#endif // wxUSE_WCHAR_T
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
default:
|
||||
return GetTranslatedKeyCode(key_id);
|
||||
}
|
||||
}
|
||||
|
||||
#undef KEY
|
||||
|
||||
void wxWindowDFB::HandleKeyEvent(const wxDFBWindowEvent& event_)
|
||||
{
|
||||
if ( !IsEnabled() )
|
||||
return;
|
||||
|
||||
const DFBWindowEvent& e = event_;
|
||||
|
||||
wxLogTrace(TRACE_EVENTS,
|
||||
_T("handling key %s event for window %p ('%s')"),
|
||||
e.type == DWET_KEYUP ? _T("up") : _T("down"),
|
||||
this, GetName().c_str());
|
||||
|
||||
// fill in wxKeyEvent fields:
|
||||
wxKeyEvent event;
|
||||
event.SetEventObject(this);
|
||||
event.SetTimestamp(wxDFB_EVENT_TIMESTAMP(e));
|
||||
event.m_rawCode = e.key_code;
|
||||
event.m_keyCode = GetTranslatedKeyCode(e.key_id);
|
||||
event.m_scanCode = 0; // not used by wx at all
|
||||
#if wxUSE_UNICODE
|
||||
event.m_uniChar = e.key_symbol;
|
||||
#endif
|
||||
event.m_shiftDown = ( e.modifiers & DIMM_SHIFT ) != 0;
|
||||
event.m_controlDown = ( e.modifiers & DIMM_CONTROL ) != 0;
|
||||
event.m_altDown = ( e.modifiers & DIMM_ALT ) != 0;
|
||||
event.m_metaDown = ( e.modifiers & DIMM_META ) != 0;
|
||||
|
||||
// translate coordinates from TLW-relative to this window-relative:
|
||||
event.m_x = e.x;
|
||||
event.m_y = e.y;
|
||||
GetTLW()->ClientToScreen(&event.m_x, &event.m_y);
|
||||
this->ScreenToClient(&event.m_x, &event.m_y);
|
||||
|
||||
if ( e.type == DWET_KEYUP )
|
||||
{
|
||||
event.SetEventType(wxEVT_KEY_UP);
|
||||
GetEventHandler()->ProcessEvent(event);
|
||||
}
|
||||
else
|
||||
{
|
||||
bool isTab = (event.m_keyCode == WXK_TAB);
|
||||
|
||||
event.SetEventType(wxEVT_KEY_DOWN);
|
||||
|
||||
if ( GetEventHandler()->ProcessEvent(event) )
|
||||
return;
|
||||
|
||||
// only send wxEVT_CHAR event if not processed yet:
|
||||
event.m_keyCode = GetUntraslatedKeyCode(e.key_id, e.key_symbol);
|
||||
if ( event.m_keyCode != 0 )
|
||||
{
|
||||
event.SetEventType(wxEVT_CHAR);
|
||||
if ( GetEventHandler()->ProcessEvent(event) )
|
||||
return;
|
||||
}
|
||||
|
||||
// Synthetize navigation key event, but do it only if the TAB key
|
||||
// wasn't handled yet:
|
||||
if ( isTab && GetParent() && GetParent()->HasFlag(wxTAB_TRAVERSAL) )
|
||||
{
|
||||
wxNavigationKeyEvent navEvent;
|
||||
navEvent.SetEventObject(GetParent());
|
||||
// Shift-TAB goes in reverse direction:
|
||||
navEvent.SetDirection(!event.m_shiftDown);
|
||||
// Ctrl-TAB changes the (parent) window, i.e. switch notebook page:
|
||||
navEvent.SetWindowChange(event.m_controlDown);
|
||||
navEvent.SetCurrentFocus(wxStaticCast(this, wxWindow));
|
||||
GetParent()->GetEventHandler()->ProcessEvent(navEvent);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// idle events processing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
void wxWindowDFB::OnInternalIdle()
|
||||
{
|
||||
if (wxUpdateUIEvent::CanUpdate(this))
|
||||
UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
|
||||
}
|
||||
|
||||
|
||||
// Find the wxWindow at the current mouse position, returning the mouse
|
||||
// position.
|
||||
wxWindow* wxFindWindowAtPointer(wxPoint& pt)
|
||||
{
|
||||
return wxFindWindowAtPoint(pt = wxGetMousePosition());
|
||||
}
|
||||
|
||||
wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
|
||||
{
|
||||
wxFAIL_MSG( _T("wxFindWindowAtPoint not implemented") );
|
||||
return NULL;
|
||||
}
|
||||
Reference in New Issue
Block a user