Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented two-window approach for wxX11.

Browse Source 
Implemented wxSTAY_ON_TOP the way Qt does it.
  Added group window support.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@14764 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
2002-03-24 22:17:53 +00:00
parent df0e1b64e3
commit ab6b6b15e0
11 changed files with 462 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/wx/univ/window.h
View File

@@ -51,6 +51,12 @@ enum
wxCONTROL_DIRTY = 0x80000000
};
#ifdef __WXX11__
#define wxUSE_TWO_WINDOWS 1
#else
#define wxUSE_TWO_WINDOWS 0
#endif
// ----------------------------------------------------------------------------
// wxWindow
// ----------------------------------------------------------------------------

4
include/wx/x11/private.h
View File

@@ -34,6 +34,10 @@ extern void wxDeleteWindowFromTable(Window w);
extern wxWindow *wxGetWindowFromTable(Window w);
extern bool wxAddWindowToTable(Window w, wxWindow *win);
extern void wxDeleteClientWindowFromTable(Window w);
extern wxWindow *wxGetClientWindowFromTable(Window w);
extern bool wxAddClientWindowToTable(Window w, wxWindow *win);
// ----------------------------------------------------------------------------
// TranslateXXXEvent() functions - translate X event to wxWindow one
// ----------------------------------------------------------------------------

4
include/wx/x11/reparent.h
View File

@@ -63,8 +63,8 @@ class wxAdoptedWindow: public wxWindow
wxAdoptedWindow(WXWindow window);
~wxAdoptedWindow();
void SetHandle(WXWindow window) { m_mainWidget = window; }
WXWindow GetHandle() const { return GetXWindow(); }
void SetHandle(WXWindow window) { m_mainWindow = window; }
WXWindow GetHandle() const { return GetMainWindow(); }
};
#endif

30
include/wx/x11/window.h
View File

@@ -103,12 +103,11 @@ public:
// accessors
// ---------
// Get main widget for this window, e.g. a text widget
// Get main X11 window
virtual WXWindow GetMainWindow() const;
// Get the underlying X window and display
WXWindow GetXWindow() const;
WXDisplay *GetXDisplay() const;
// Get X11 window representing the client area
virtual WXWindow GetClientWindow() const;
void SetLastClick(int button, long timestamp)
{ m_lastButton = button; m_lastTS = timestamp; }
@@ -123,6 +122,9 @@ public:
// Generates paint events from m_updateRegion
void SendPaintEvents();
// Generates paint events from flag
void SendNcPaintEvents();
// Generates erase events from m_clearRegion
void SendEraseEvents();
@@ -132,6 +134,14 @@ public:
// Return clear region
wxRegion &GetClearRegion() { return m_clearRegion; }
void NeedUpdateNcAreaInIdle( bool update = TRUE ) { m_updateNcArea = update; }
// Inserting into main window instead of client
// window. This is mostly for a wxWindow's own
// scrollbars.
void SetInsertIntoMain( bool insert = TRUE ) { m_insertIntoMain = insert; }
bool GetInsertIntoMain() { return m_insertIntoMain; }
// sets the fore/background colour for the given widget
static void DoChangeForegroundColour(WXWindow widget, wxColour& foregroundColour);
static void DoChangeBackgroundColour(WXWindow widget, wxColour& backgroundColour, bool changeArmColour = FALSE);
@@ -148,10 +158,6 @@ public:
// For compatibility across platforms (not in event table)
void OnIdle(wxIdleEvent& WXUNUSED(event)) {}
// Go up to a toplevel window and query which window has the focus.
// May return NULL.
wxWindow *GetFocusWidget();
protected:
// Responds to colour changes: passes event on to children.
void OnSysColourChanged(wxSysColourChangedEvent& event);
@@ -161,10 +167,14 @@ protected:
int m_lastButton; // last pressed button
protected:
WXWindow m_mainWidget;
WXWindow m_mainWindow;
WXWindow m_clientWindow;
bool m_insertIntoMain;
bool m_winCaptured;
wxRegion m_clearRegion;
bool m_clipPaintRegion;
bool m_winCaptured; // ????
bool m_updateNcArea;
bool m_needsInputFocus; // Input focus set in OnIdle
// implement the base class pure virtuals

17
src/univ/winuniv.cpp
View File

@@ -132,9 +132,15 @@ bool wxWindow::Create(wxWindow *parent,
// if we should always have the scrollbar, do show it
if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
{
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( TRUE );
#endif
m_scrollbarVert = new wxScrollBar(this, -1,
wxDefaultPosition, wxDefaultSize,
wxSB_VERTICAL);
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( FALSE );
#endif
// and position it
PositionScrollbars();
@@ -456,7 +462,7 @@ void wxWindow::OnSize(wxSizeEvent& event)
PositionScrollbars();
}
#ifndef __WXMSW__
#if 0 // ndef __WXMSW__
// Refresh the area (strip) previously occupied by the border
if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ) && IsShown())
@@ -581,8 +587,11 @@ wxPoint wxWindow::GetClientAreaOrigin() const
{
wxPoint pt = wxWindowBase::GetClientAreaOrigin();
#if wxUSE_TWO_WINDOWS
#else
if ( m_renderer )
pt += m_renderer->GetBorderDimensions(GetBorder()).GetPosition();
#endif
return pt;
}
@@ -771,10 +780,16 @@ void wxWindow::SetScrollbar(int orient,
if ( !scrollbar )
{
// create it
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( TRUE );
#endif
scrollbar = new wxScrollBar(this, -1,
wxDefaultPosition, wxDefaultSize,
orient & wxVERTICAL ? wxSB_VERTICAL
: wxSB_HORIZONTAL);
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( FALSE );
#endif
if ( orient & wxVERTICAL )
m_scrollbarVert = scrollbar;
else

68
src/x11/app.cpp
View File

@@ -49,6 +49,7 @@
extern wxList wxPendingDelete;
wxHashTable *wxWidgetHashTable = NULL;
wxHashTable *wxClientWidgetHashTable = NULL;
wxApp *wxTheApp = NULL;
@@ -119,6 +120,7 @@ bool wxApp::Initialize()
#endif
wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
wxClientWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
wxModule::RegisterModules();
if (!wxModule::InitializeModules()) return FALSE;
@@ -134,6 +136,8 @@ void wxApp::CleanUp()
delete wxWidgetHashTable;
wxWidgetHashTable = NULL;
delete wxClientWidgetHashTable;
wxClientWidgetHashTable = NULL;
wxModule::CleanUpModules();
@@ -466,10 +470,16 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
// has been destroyed, assume a 1:1 match between
// Window and wxWindow, so if it's not in the table,
// it must have been destroyed.
win = wxGetWindowFromTable(window);
if (!win)
return FALSE;
{
#if wxUSE_TWO_WINDOWS
win = wxGetClientWindowFromTable(window);
if (!win)
#endif
return FALSE;
}
#ifdef __WXDEBUG__
wxString windowClass = win->GetClassInfo()->GetClassName();
@@ -479,30 +489,49 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
{
case Expose:
{
//wxLogDebug("Expose: %s", windowClass.c_str());
win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
#if wxUSE_TWO_WINDOWS
if (event->xexpose.window != (Window)win->GetClientWindow())
{
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = FALSE;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, expose_predicate, (XPointer) &info ))
{
// Don't worry about optimizing redrawing the border etc.
}
win->NeedUpdateNcAreaInIdle();
}
else
#endif
{
win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
XExposeEventGetWidth(event), XExposeEventGetHeight(event));
#if !wxUSE_NANOX
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = FALSE;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, expose_predicate, (XPointer) &info ))
{
win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
XEvent tmp_event;
wxExposeInfo info;
info.window = event->xexpose.window;
info.found_non_matching = FALSE;
while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, expose_predicate, (XPointer) &info ))
{
win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
}
win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
tmp_event.xexpose.width, tmp_event.xexpose.height );
}
#endif
if (win->GetMainWindow() == win->GetClientWindow())
win->NeedUpdateNcAreaInIdle();
// Only erase background, paint in idle time.
win->SendEraseEvents();
// Only erase background, paint in idle time.
win->SendEraseEvents();
//win->Update();
}
return TRUE;
}
@@ -580,7 +609,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
if (event->update.utype == GR_UPDATE_SIZE)
#endif
{
//wxLogDebug("ConfigureNotify: %s", windowClass.c_str());
if (win->IsTopLevel() && win->IsShown())
{
wxTopLevelWindowX11 *tlw = (wxTopLevelWindowX11 *) win;

74
src/x11/dcclient.cpp
View File

@@ -2030,53 +2030,24 @@ int wxWindowDC::GetDepth() const
return -1;
}
// ----------------------------------------------------------------------------
// wxPaintDC
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
wxPaintDC::wxPaintDC(wxWindow* win)
: wxClientDC(win)
{
#if USE_PAINT_REGION
if (!win->GetClipPaintRegion())
return;
m_paintClippingRegion = win->GetUpdateRegion();
Region region = (Region) m_paintClippingRegion.GetX11Region();
if (region)
{
m_paintClippingRegion = win->GetUpdateRegion();
Region region2 = (Region) m_paintClippingRegion.GetX11Region();
if (region2)
{
m_currentClippingRegion.Union( m_paintClippingRegion );
XSetRegion( (Display*) m_display, (GC) m_penGC, region2 );
XSetRegion( (Display*) m_display, (GC) m_brushGC, region2 );
XSetRegion( (Display*) m_display, (GC) m_textGC, region2 );
XSetRegion( (Display*) m_display, (GC) m_bgGC, region2 );
}
}
#endif // USE_PAINT_REGION
}
//-----------------------------------------------------------------------------
// wxClientDC
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxClientDC, wxWindowDC)
wxClientDC::wxClientDC( wxWindow *win )
: wxWindowDC( win )
wxClientDC::wxClientDC( wxWindow *window )
: wxWindowDC( window )
{
wxCHECK_RET( win, _T("NULL window in wxClientDC::wxClientDC") );
wxCHECK_RET( window, _T("NULL window in wxClientDC::wxClientDC") );
#ifdef __WXUNIVERSAL__
wxPoint ptOrigin = win->GetClientAreaOrigin();
m_window = (WXWindow*) window->GetClientWindow();
#if wxUSE_TWO_WINDOWS
#else
wxPoint ptOrigin = window->GetClientAreaOrigin();
SetDeviceOrigin(ptOrigin.x, ptOrigin.y);
wxSize size = win->GetClientSize();
wxSize size = window->GetClientSize();
SetClippingRegion(wxPoint(0, 0), size);
#endif // __WXUNIVERSAL__
}
@@ -2088,6 +2059,33 @@ void wxClientDC::DoGetSize(int *width, int *height) const
m_owner->GetClientSize( width, height );
}
// ----------------------------------------------------------------------------
// wxPaintDC
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxPaintDC, wxClientDC)
wxPaintDC::wxPaintDC(wxWindow* window)
: wxClientDC(window)
{
#if USE_PAINT_REGION
if (!window->GetClipPaintRegion())
return;
m_paintClippingRegion = window->GetUpdateRegion();
Region region = (Region) m_paintClippingRegion.GetX11Region();
if (region)
{
m_currentClippingRegion.Union( m_paintClippingRegion );
XSetRegion( (Display*) m_display, (GC) m_penGC, region );
XSetRegion( (Display*) m_display, (GC) m_brushGC, region );
XSetRegion( (Display*) m_display, (GC) m_textGC, region );
XSetRegion( (Display*) m_display, (GC) m_bgGC, region );
}
#endif // USE_PAINT_REGION
}
// ----------------------------------------------------------------------------
// wxDCModule
// ----------------------------------------------------------------------------

3
src/x11/popupwin.cpp
View File

@@ -78,7 +78,8 @@ bool wxPopupWindow::Create( wxWindow *parent, int style )
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask );
m_mainWidget = (WXWindow) xwindow;
m_mainWindow = (WXWindow) xwindow;
m_clientWindow = (WXWindow) xwindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
// Set background to None which will prevent X11 from clearing the

30
src/x11/reparent.cpp
View File

@@ -94,7 +94,7 @@ wxAdoptedWindow::wxAdoptedWindow()
wxAdoptedWindow::wxAdoptedWindow(WXWindow window)
{
m_mainWidget = window;
m_mainWindow = window;
}
wxAdoptedWindow::~wxAdoptedWindow()
@@ -131,15 +131,15 @@ bool wxReparenter::Reparent(wxWindow* newParent, wxAdoptedWindow* toReparent)
int parentOffset = 0;
old = XSetErrorHandler(ErrorHandler);
XReparentWindow((Display*) newParent->GetXDisplay(),
(Window) toReparent->GetXWindow(),
(Window) newParent->GetXWindow(),
0, 0);
XReparentWindow( wxGlobalDisplay(),
(Window) toReparent->GetMainWindow(),
(Window) newParent->GetMainWindow(),
0, 0);
if (!XQueryTree((Display*) newParent->GetXDisplay(),
(Window) toReparent->GetXWindow(),
&returnroot, &returnparent,
&children, &numchildren) || Xerror)
if (!XQueryTree( wxGlobalDisplay(),
(Window) toReparent->GetMainWindow(),
&returnroot, &returnparent,
&children, &numchildren) || Xerror)
{
XSetErrorHandler(old);
return TRUE;
@@ -160,14 +160,14 @@ bool wxReparenter::Reparent(wxWindow* newParent, wxAdoptedWindow* toReparent)
*/
for (each=0; each<numchildren; each++)
{
XGetWindowAttributes((Display*) newParent->GetXDisplay(),
children[each], &xwa);
XGetWindowAttributes( wxGlobalDisplay(),
children[each], &xwa);
fprintf(stderr,
"Reparenting child at offset %d and position %d, %d.\n",
parentOffset, parentOffset+xwa.x, parentOffset+xwa.y);
XReparentWindow((Display*) newParent->GetXDisplay(),
children[each], (Window) newParent->GetXWindow(),
xwa.x, xwa.y);
XReparentWindow( wxGlobalDisplay(),
children[each], (Window) newParent->GetMainWindow(),
xwa.x, xwa.y);
}
}
@@ -187,7 +187,7 @@ bool wxReparenter::WaitAndReparent(wxWindow* newParent, wxAdoptedWindow* toRepar
sm_exactMatch = exactMatch;
sm_name = windowName;
Display* display = (Display*) newParent->GetXDisplay() ;
Display* display = wxGlobalDisplay();
XSelectInput(display,
RootWindowOfScreen(DefaultScreenOfDisplay(display)),
SubstructureNotifyMask);

55
src/x11/toplevel.cpp
View File

@@ -123,12 +123,18 @@ bool wxTopLevelWindowX11::Create(wxWindow *parent,
xattributes.background_pixel = m_backgroundColour.GetPixel();
xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
if (HasFlag( wxNO_BORDER ))
{
xattributes_mask |= CWOverrideRedirect;
xattributes.override_redirect = True;
}
if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
{
xattributes_mask |= CWBitGravity;
xattributes.bit_gravity = StaticGravity;
}
xattributes_mask |= CWEventMask;
xattributes.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
@@ -147,7 +153,9 @@ bool wxTopLevelWindowX11::Create(wxWindow *parent,
0, 0, InputOutput, xvisual, backColor, foreColor);
#endif
m_mainWidget = (WXWindow) xwindow;
m_mainWindow = (WXWindow) xwindow;
m_clientWindow = (WXWindow) xwindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
#if wxUSE_NANOX
XSelectInput( xdisplay, xwindow,
@@ -168,20 +176,26 @@ bool wxTopLevelWindowX11::Create(wxWindow *parent,
PropertyChangeMask
);
#endif
wxAddWindowToTable( xwindow, (wxWindow*) this );
// Set background to None which will prevent X11 from clearing the
// background completely.
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
#if !wxUSE_NANOX
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
if (HasFlag( wxSTAY_ON_TOP ))
{
if (GetParent() && GetParent()->GetMainWindow())
{
Window xparentwindow = (Window) GetParent()->GetMainWindow();
XSetTransientForHint( xdisplay, xwindow, xparentwindow );
Window xroot = RootWindow( xdisplay, xscreen );
XSetTransientForHint( xdisplay, xwindow, xroot );
}
else
{
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
{
if (GetParent() && GetParent()->GetMainWindow())
{
Window xparentwindow = (Window) GetParent()->GetMainWindow();
XSetTransientForHint( xdisplay, xwindow, xparentwindow );
}
}
}
@@ -193,7 +207,12 @@ bool wxTopLevelWindowX11::Create(wxWindow *parent,
XSetWMNormalHints( xdisplay, xwindow, &size_hints);
XWMHints wm_hints;
wm_hints.flags = InputHint | StateHint /* | WindowGroupHint */;
wm_hints.flags = InputHint | StateHint;
if (GetParent())
{
wm_hints.flags |= WindowGroupHint;
wm_hints.window_group = (Window) GetParent()->GetMainWindow();
}
wm_hints.input = True;
wm_hints.initial_state = NormalState;
XSetWMHints( xdisplay, xwindow, &wm_hints);
@@ -266,6 +285,8 @@ void wxTopLevelWindowX11::OnInternalIdle()
bool wxTopLevelWindowX11::Show(bool show)
{
XSync( wxGlobalDisplay(), False );
// Nano-X has to force a size event,
// else there's no initial size.
#if wxUSE_NANOX
@@ -619,7 +640,7 @@ void wxTopLevelWindowX11::DoSetClientSize(int width, int height)
size_hints.flags = PSize;
size_hints.width = width + (oldSize.x - oldClientSize.x);
size_hints.height = height + (oldSize.y - oldClientSize.y);
XSetWMNormalHints( (Display*) GetXDisplay(), (Window) GetMainWindow(),
XSetWMNormalHints( wxGlobalDisplay(), (Window) GetMainWindow(),
&size_hints);
// This seems to be necessary or resizes don't get performed
@@ -644,11 +665,11 @@ void wxTopLevelWindowX11::DoSetSize(int x, int y, int width, int height, int siz
wxWindowX11::DoSetSize(x, y, width, height, sizeFlags);
#endif
XSync(wxGlobalDisplay(), False);
Window window = (Window) m_mainWidget;
Window window = (Window) m_mainWindow;
if (!window)
return ;
Display *display = (Display*) GetXDisplay();
Display *display = wxGlobalDisplay();
Window root = RootWindowOfScreen(DefaultScreenOfDisplay(display));
Window parent_window = window,
next_parent = window;
@@ -708,7 +729,7 @@ void wxTopLevelWindowX11::DoSetSize(int x, int y, int width, int height, int siz
size_hints.height = height;
size_hints.x = x;
size_hints.y = y;
XSetWMNormalHints( (Display*) GetXDisplay(), (Window) GetMainWindow(),
XSetWMNormalHints( wxGlobalDisplay(), (Window) GetMainWindow(),
&size_hints);
// This seems to be necessary or resizes don't get performed.
@@ -727,11 +748,11 @@ void wxTopLevelWindowX11::DoSetSize(int x, int y, int width, int height, int siz
void wxTopLevelWindowX11::DoGetPosition(int *x, int *y) const
{
XSync(wxGlobalDisplay(), False);
Window window = (Window) m_mainWidget;
Window window = (Window) m_mainWindow;
if (!window)
return ;
Display *display = (Display*) GetXDisplay();
Display *display = wxGlobalDisplay();
Window root = RootWindowOfScreen(DefaultScreenOfDisplay(display));
Window parent_window = window,
next_parent = window;
@@ -758,7 +779,7 @@ void wxTopLevelWindowX11::DoGetPosition(int *x, int *y) const
if (y) *y = yy;
#else
XWindowAttributes attr;
Status status = XGetWindowAttributes((Display*) GetXDisplay(), parent_window, & attr);
Status status = XGetWindowAttributes( wxGlobalDisplay(), parent_window, & attr);
if (status)
{
if (x) *x = attr.x;

485
src/x11/window.cpp
View File

@@ -36,6 +36,7 @@
#include "wx/msgdlg.h"
#include "wx/frame.h"
#include "wx/scrolwin.h"
#include "wx/scrolbar.h"
#include "wx/module.h"
#include "wx/menuitem.h"
#include "wx/log.h"
@@ -59,6 +60,7 @@
// ----------------------------------------------------------------------------
extern wxHashTable *wxWidgetHashTable;
extern wxHashTable *wxClientWidgetHashTable;
static wxWindow* g_captureWindow = NULL;
// ----------------------------------------------------------------------------
@@ -97,7 +99,10 @@ void wxWindowX11::Init()
InitBase();
// X11-specific
m_mainWidget = (WXWindow) 0;
m_mainWindow = (WXWindow) 0;
m_clientWindow = (WXWindow) 0;
m_insertIntoMain = FALSE;
m_winCaptured = FALSE;
m_needsInputFocus = FALSE;
m_isShown = TRUE;
@@ -139,7 +144,14 @@ bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
m_foregroundColour = *wxBLACK;
m_foregroundColour.CalcPixel( (WXColormap) cm );
Window xparent = (Window) parent->GetMainWindow();
Window xparent = (Window) parent->GetClientWindow();
// Add window's own scrollbars to main window, not to client window
if (parent->GetInsertIntoMain())
{
// wxLogDebug( "Inserted into main: %s", GetName().c_str() );
xparent = (Window) parent->GetMainWindow();
}
wxSize size2(size);
if (size2.x == -1)
@@ -154,29 +166,89 @@ bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
pos2.y = 0;
#if !wxUSE_NANOX
#if wxUSE_TWO_WINDOWS
bool need_two_windows =
((( wxSUNKEN_BORDER | wxRAISED_BORDER | wxSIMPLE_BORDER | wxHSCROLL | wxVSCROLL ) & m_windowStyle) != 0);
#else
bool need_two_windows = FALSE;
#endif
XSetWindowAttributes xattributes;
long xattributes_mask = 0;
long xattributes_mask =
CWBorderPixel | CWBackPixel;
xattributes_mask |= CWBackPixel;
xattributes.background_pixel = m_backgroundColour.GetPixel();
xattributes_mask |= CWBorderPixel;
xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
xattributes_mask |= CWEventMask;
xattributes.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask | VisibilityChangeMask ;
if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
if (need_two_windows)
{
xattributes_mask |= CWBitGravity;
xattributes.bit_gravity = StaticGravity;
}
xattributes.event_mask =
ExposureMask | StructureNotifyMask | ColormapChangeMask;
Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
m_mainWindow = (WXWindow) xwindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
XMapWindow( xdisplay, xwindow );
xattributes.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask | VisibilityChangeMask ;
if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
{
xattributes_mask |= CWBitGravity;
xattributes.bit_gravity = StaticGravity;
}
xwindow = XCreateWindow( xdisplay, xwindow, 0, 0, size2.x, size2.y,
0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
m_clientWindow = (WXWindow) xwindow;
wxAddClientWindowToTable( xwindow, (wxWindow*) this );
XMapWindow( xdisplay, xwindow );
}
else
{
// wxLogDebug( "No two windows needed %s", GetName().c_str() );
xattributes.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask | VisibilityChangeMask ;
if (HasFlag( wxNO_FULL_REPAINT_ON_RESIZE ))
{
xattributes_mask |= CWBitGravity;
xattributes.bit_gravity = StaticGravity;
}
Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
m_mainWindow = (WXWindow) xwindow;
m_clientWindow = m_mainWindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
XMapWindow( xdisplay, xwindow );
}
#else
int extraFlags = GR_EVENT_MASK_CLOSE_REQ;
@@ -192,24 +264,22 @@ bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask );
#endif
m_mainWidget = (WXWindow) xwindow;
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
m_mainWindow = (WXWindow) xwindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
XMapWindow( xdisplay, xwindow );
#endif
// Is a subwindow, so map immediately
m_isShown = TRUE;
XMapWindow( xdisplay, xwindow );
// Without this, the cursor may not be restored properly (e.g. in splitter
// sample).
SetCursor(*wxSTANDARD_CURSOR);
SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
// Set background to None which will prevent X11 from clearing the
// background comletely.
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
// Don't call this, it can have nasty repercussions for composite controls,
// for example
@@ -226,22 +296,25 @@ wxWindowX11::~wxWindowX11()
m_isBeingDeleted = TRUE;
// X11-specific actions first
Window xwindow = (Window) m_mainWidget;
if (m_parent)
m_parent->RemoveChild( this );
DestroyChildren();
// Destroy the window
if (xwindow)
if (m_clientWindow != m_mainWindow)
{
XSelectInput( wxGlobalDisplay(), xwindow, NoEventMask);
wxDeleteWindowFromTable( xwindow );
// Destroy the cleint window
Window xwindow = (Window) m_clientWindow;
wxDeleteClientWindowFromTable( xwindow );
XDestroyWindow( wxGlobalDisplay(), xwindow );
m_mainWidget = NULL;
m_clientWindow = NULL;
}
// Destroy the window
Window xwindow = (Window) m_mainWindow;
wxDeleteWindowFromTable( xwindow );
XDestroyWindow( wxGlobalDisplay(), xwindow );
m_mainWindow = NULL;
}
// ---------------------------------------------------------------------------
@@ -250,7 +323,7 @@ wxWindowX11::~wxWindowX11()
void wxWindowX11::SetFocus()
{
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -292,19 +365,6 @@ wxWindow *wxWindowBase::FindFocus()
return NULL;
}
wxWindow *wxWindowX11::GetFocusWidget()
{
wxWindow *win = (wxWindow*) this;
while (!win->IsTopLevel())
{
win = win->GetParent();
if (!win)
return (wxWindow*) NULL;
}
return win;
}
// Enabling/disabling handled by event loop, and not sending events
// if disabled.
bool wxWindowX11::Enable(bool enable)
@@ -319,18 +379,17 @@ bool wxWindowX11::Show(bool show)
{
wxWindowBase::Show(show);
Window xwin = (Window) GetXWindow();
Display *xdisp = (Display*) GetXDisplay();
Window xwindow = (Window) m_mainWindow;
Display *xdisp = wxGlobalDisplay();
if (show)
{
// wxLogDebug( "Mapping window of type %s", GetName().c_str() );
XMapWindow(xdisp, xwin);
XSync(xdisp, False);
XMapWindow(xdisp, xwindow);
}
else
{
// wxLogDebug( "Unmapping window of type %s", GetName().c_str() );
XUnmapWindow(xdisp, xwin);
XUnmapWindow(xdisp, xwindow);
}
return TRUE;
@@ -339,15 +398,15 @@ bool wxWindowX11::Show(bool show)
// Raise the window to the top of the Z order
void wxWindowX11::Raise()
{
if (m_mainWidget)
XRaiseWindow( wxGlobalDisplay(), (Window) m_mainWidget );
if (m_mainWindow)
XRaiseWindow( wxGlobalDisplay(), (Window) m_mainWindow );
}
// Lower the window to the bottom of the Z order
void wxWindowX11::Lower()
{
if (m_mainWidget)
XLowerWindow( wxGlobalDisplay(), (Window) m_mainWidget );
if (m_mainWindow)
XLowerWindow( wxGlobalDisplay(), (Window) m_mainWindow );
}
void wxWindowX11::DoCaptureMouse()
@@ -365,7 +424,7 @@ void wxWindowX11::DoCaptureMouse()
if (m_winCaptured)
return;
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -395,44 +454,6 @@ void wxWindowX11::DoCaptureMouse()
return;
}
// wxLogDebug("Grabbed pointer in %s", GetName().c_str() );
#if 0
res = XGrabButton(wxGlobalDisplay(), AnyButton, AnyModifier,
(Window) GetMainWindow(),
FALSE,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask,
GrabModeAsync,
GrabModeAsync,
None,
None);
if (res != GrabSuccess)
{
wxLogDebug("Failed to grab mouse buttons.");
XUngrabPointer(wxGlobalDisplay(), CurrentTime);
return;
}
#endif
#if 0
res = XGrabKeyboard(wxGlobalDisplay(), (Window) GetMainWindow(),
ShiftMask | LockMask | ControlMask | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask,
FALSE,
GrabModeAsync,
GrabModeAsync,
CurrentTime);
if (res != GrabSuccess)
{
wxLogDebug("Failed to grab keyboard.");
XUngrabPointer(wxGlobalDisplay(), CurrentTime);
XUngrabButton(wxGlobalDisplay(), AnyButton, AnyModifier,
(Window) GetMainWindow());
return;
}
#endif
m_winCaptured = TRUE;
}
}
@@ -444,15 +465,11 @@ void wxWindowX11::DoReleaseMouse()
if ( !m_winCaptured )
return;
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
if (xwindow)
{
XUngrabPointer( wxGlobalDisplay(), CurrentTime );
#if 0
XUngrabButton( wxGlobalDisplay(), AnyButton, AnyModifier, xwindow);
XUngrabKeyboard( wxGlobalDisplay(), CurrentTime );
#endif
}
// wxLogDebug( "Ungrabbed pointer in %s", GetName().c_str() );
@@ -479,7 +496,7 @@ bool wxWindowX11::SetCursor(const wxCursor& cursor)
return FALSE;
}
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
wxCHECK_MSG( xwindow, FALSE, wxT("invalid window") );
@@ -499,7 +516,7 @@ bool wxWindowX11::SetCursor(const wxCursor& cursor)
// Coordinates relative to the window
void wxWindowX11::WarpPointer (int x, int y)
{
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -532,7 +549,7 @@ void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
m_clearRegion.Intersect( 0, 0, cw, ch );
}
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) GetClientWindow();
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -560,9 +577,13 @@ void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
GetClientSize( &cw, &ch );
}
#if wxUSE_TWO_WINDOWS
wxPoint offset( 0,0 );
#else
wxPoint offset = GetClientAreaOrigin();
s_x += offset.x;
s_y += offset.y;
#endif
int w = cw - abs(dx);
int h = ch - abs(dy);
@@ -644,7 +665,7 @@ bool wxWindowX11::PreResize()
// Get total size
void wxWindowX11::DoGetSize(int *x, int *y) const
{
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_mainWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -663,7 +684,7 @@ void wxWindowX11::DoGetSize(int *x, int *y) const
void wxWindowX11::DoGetPosition(int *x, int *y) const
{
Window window = (Window) m_mainWidget;
Window window = (Window) m_mainWindow;
if (window)
{
//XSync(wxGlobalDisplay(), False);
@@ -692,7 +713,7 @@ void wxWindowX11::DoScreenToClient(int *x, int *y) const
{
Display *display = wxGlobalDisplay();
Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
Window thisWindow = (Window) m_mainWidget;
Window thisWindow = (Window) m_clientWindow;
Window childWindow;
int xx = *x;
@@ -704,7 +725,7 @@ void wxWindowX11::DoClientToScreen(int *x, int *y) const
{
Display *display = wxGlobalDisplay();
Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
Window thisWindow = (Window) m_mainWidget;
Window thisWindow = (Window) m_clientWindow;
Window childWindow;
int xx = *x;
@@ -716,11 +737,10 @@ void wxWindowX11::DoClientToScreen(int *x, int *y) const
// Get size *available for subwindows* i.e. excluding menu bar etc.
void wxWindowX11::DoGetClientSize(int *x, int *y) const
{
Window window = (Window) m_mainWidget;
Window window = (Window) m_mainWindow;
if (window)
{
//XSync(wxGlobalDisplay(), False); // Is this really a good idea?
XWindowAttributes attr;
Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
wxASSERT(status);
@@ -736,8 +756,8 @@ void wxWindowX11::DoGetClientSize(int *x, int *y) const
void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
{
// wxLogDebug("DoSetSize: %s (%ld) %d, %d %dx%d", GetClassInfo()->GetClassName(), GetId(), x, y, width, height);
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_mainWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
@@ -749,8 +769,7 @@ void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
int new_y = attr.y;
int new_w = attr.width;
int new_h = attr.height;
if (x != -1 || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
{
int yy = 0;
@@ -788,41 +807,30 @@ void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
void wxWindowX11::DoSetClientSize(int width, int height)
{
// wxLogDebug("DoSetClientSize: %s (%ld) %dx%d", GetClassInfo()->GetClassName(), GetId(), width, height);
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_mainWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
#if 1
XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
#if 0
wxSizeEvent event(wxSize(width, height), GetId());
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event);
#endif
#else
XWindowAttributes attr;
Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
wxCHECK_RET( status, wxT("invalid window attributes") );
if (m_mainWindow != m_clientWindow)
{
xwindow = (Window) m_clientWindow;
int new_x = attr.x;
int new_y = attr.y;
int new_w = attr.width;
int new_h = attr.height;
if (width != -1)
new_w = width;
if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
{
width -= 4;
height -= 4;
} else
if (HasFlag( wxSIMPLE_BORDER ))
{
width -= 2;
height -= 2;
}
if (height != -1)
new_h = height;
DoMoveWindow( new_x, new_y, new_w, new_h );
#endif
XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
}
}
// For implementation purposes - sometimes decorations make the client area
@@ -832,6 +840,70 @@ wxPoint wxWindowX11::GetClientAreaOrigin() const
return wxPoint(0, 0);
}
void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
{
Window xwindow = (Window) m_mainWindow;
wxCHECK_RET( xwindow, wxT("invalid window") );
#if !wxUSE_NANOX
XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
if (m_mainWindow != m_clientWindow)
{
xwindow = (Window) m_clientWindow;
if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
{
x = 2;
y = 2;
width -= 4;
height -= 4;
} else
if (HasFlag( wxSIMPLE_BORDER ))
{
x = 1;
y = 1;
width -= 2;
height -= 2;
} else
{
x = 0;
y = 0;
}
wxWindow *window = (wxWindow*) this;
wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
if (sb && sb->IsShown())
{
wxSize size = sb->GetSize();
height -= size.y;
}
sb = window->GetScrollbar( wxVERTICAL );
if (sb && sb->IsShown())
{
wxSize size = sb->GetSize();
width -= size.x;
}
XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
}
#else
XWindowChanges windowChanges;
windowChanges.x = x;
windowChanges.y = y;
windowChanges.width = width;
windowChanges.height = height;
windowChanges.stack_mode = 0;
int valueMask = CWX | CWY | CWWidth | CWHeight;
XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
#endif
}
void wxWindowX11::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
{
m_minWidth = minW;
@@ -862,48 +934,7 @@ void wxWindowX11::SetSizeHints(int minW, int minH, int maxW, int maxH, int incW,
sizeHints.height_inc = incH;
}
XSetWMNormalHints(wxGlobalDisplay(), (Window) GetMainWindow(), & sizeHints);
#endif
}
void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
{
Window xwindow = (Window) GetMainWindow();
wxCHECK_RET( xwindow, wxT("invalid window") );
#if !wxUSE_NANOX
XWindowAttributes attr;
Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
wxCHECK_RET( status, wxT("invalid window attributes") );
if (attr.width == width && attr.height == height)
{
XMoveWindow( wxGlobalDisplay(), xwindow, x, y );
return;
}
if (attr.x == x && attr.y == y)
{
XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
return;
}
XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
#else
XWindowChanges windowChanges;
windowChanges.x = x;
windowChanges.y = y;
windowChanges.width = width;
windowChanges.height = height;
windowChanges.stack_mode = 0;
int valueMask = CWX | CWY | CWWidth | CWHeight;
XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
XSetWMNormalHints(wxGlobalDisplay(), (Window) m_mainWindow, &sizeHints );
#endif
}
@@ -915,7 +946,7 @@ int wxWindowX11::GetCharHeight() const
{
wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, wxGlobalDisplay());
int direction, ascent, descent;
XCharStruct overall;
@@ -930,7 +961,7 @@ int wxWindowX11::GetCharWidth() const
{
wxCHECK_MSG( m_font.Ok(), 0, "valid window font needed" );
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, GetXDisplay());
WXFontStructPtr pFontStruct = m_font.GetFontStruct(1.0, wxGlobalDisplay());
int direction, ascent, descent;
XCharStruct overall;
@@ -950,7 +981,7 @@ void wxWindowX11::GetTextExtent(const wxString& string,
wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, GetXDisplay());
WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
int direction, ascent, descent2;
XCharStruct overall;
@@ -1018,9 +1049,15 @@ void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
void wxWindowX11::Update()
{
if (m_updateNcArea)
{
// Send nc paint events.
SendNcPaintEvents();
}
if (!m_updateRegion.IsEmpty())
{
// wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
// wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
// Actually send erase events.
SendEraseEvents();
@@ -1031,17 +1068,17 @@ void wxWindowX11::Update()
void wxWindowX11::Clear()
{
wxClientDC dc((wxWindow*) this);
wxBrush brush(GetBackgroundColour(), wxSOLID);
dc.SetBackground(brush);
dc.Clear();
// wxClientDC dc((wxWindow*) this);
// wxBrush brush(GetBackgroundColour(), wxSOLID);
// dc.SetBackground(brush);
// dc.Clear();
}
void wxWindowX11::SendEraseEvents()
{
if (m_clearRegion.IsEmpty()) return;
wxWindowDC dc( (wxWindow*)this );
wxClientDC dc( (wxWindow*)this );
dc.SetClippingRegion( m_clearRegion );
wxEraseEvent erase_event( GetId(), &dc );
@@ -1049,7 +1086,7 @@ void wxWindowX11::SendEraseEvents()
if (!GetEventHandler()->ProcessEvent(erase_event))
{
Window xwindow = (Window) GetMainWindow();
Window xwindow = (Window) m_clientWindow;
Display *xdisplay = wxGlobalDisplay();
GC xgc = XCreateGC( xdisplay, xwindow, 0, NULL );
XSetFillStyle( xdisplay, xgc, FillSolid );
@@ -1073,10 +1110,6 @@ void wxWindowX11::SendPaintEvents()
m_clipPaintRegion = TRUE;
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
GetEventHandler()->ProcessEvent( nc_paint_event );
wxPaintEvent paint_event( GetId() );
paint_event.SetEventObject( this );
GetEventHandler()->ProcessEvent( paint_event );
@@ -1086,6 +1119,13 @@ void wxWindowX11::SendPaintEvents()
m_clipPaintRegion = FALSE;
}
void wxWindowX11::SendNcPaintEvents()
{
wxNcPaintEvent nc_paint_event( GetId() );
nc_paint_event.SetEventObject( this );
GetEventHandler()->ProcessEvent( nc_paint_event );
}
// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------
@@ -1157,6 +1197,38 @@ void wxDeleteWindowFromTable(Window w)
wxWidgetHashTable->Delete((long)w);
}
// ----------------------------------------------------------------------------
// function which maintain the global hash table mapping client widgets
// ----------------------------------------------------------------------------
bool wxAddClientWindowToTable(Window w, wxWindow *win)
{
wxWindow *oldItem = NULL;
if ((oldItem = (wxWindow *)wxClientWidgetHashTable->Get ((long) w)))
{
wxLogDebug("Client window table clash: new window is %ld, %s",
(long)w, win->GetClassInfo()->GetClassName());
return FALSE;
}
wxClientWidgetHashTable->Put((long) w, win);
wxLogTrace("widget", "XWindow 0x%08x <-> window %p (%s)",
w, win, win->GetClassInfo()->GetClassName());
return TRUE;
}
wxWindow *wxGetClientWindowFromTable(Window w)
{
return (wxWindow *)wxClientWidgetHashTable->Get((long) w);
}
void wxDeleteClientWindowFromTable(Window w)
{
wxClientWidgetHashTable->Delete((long)w);
}
// ----------------------------------------------------------------------------
// add/remove window from the table
// ----------------------------------------------------------------------------
@@ -1165,21 +1237,14 @@ void wxDeleteWindowFromTable(Window w)
// X11-specific accessors
// ----------------------------------------------------------------------------
// Get the underlying X window
WXWindow wxWindowX11::GetXWindow() const
{
return GetMainWindow();
}
// Get the underlying X display
WXDisplay *wxWindowX11::GetXDisplay() const
{
return wxGetDisplay();
}
WXWindow wxWindowX11::GetMainWindow() const
{
return m_mainWidget;
return m_mainWindow;
}
WXWindow wxWindowX11::GetClientWindow() const
{
return m_clientWindow;
}
// ----------------------------------------------------------------------------