]> git.saurik.com Git - wxWidgets.git/blame - src/x11/window.cpp
Build fix for motif.
[wxWidgets.git] / src / x11 / window.cpp
CommitLineData
83df96d6 1/////////////////////////////////////////////////////////////////////////////
9eddec69 2// Name: src/x11/window.cpp
83df96d6
JS
3// Purpose: wxWindow
4// Author: Julian Smart
5// Modified by:
6// Created: 17/09/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
65571936 9// Licence: wxWindows licence
83df96d6
JS
10/////////////////////////////////////////////////////////////////////////////
11
521bf4ff
WS
12// for compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#if defined(__BORLANDC__)
32d4c30a
WS
16 #pragma hdrstop
17#endif
18
83df96d6
JS
19// ============================================================================
20// declarations
21// ============================================================================
22
23// ----------------------------------------------------------------------------
24// headers
25// ----------------------------------------------------------------------------
26
e4db172a
WS
27#include "wx/window.h"
28
29#ifndef WX_PRECOMP
30 #include "wx/hash.h"
31 #include "wx/log.h"
670f9935 32 #include "wx/app.h"
de6185e2 33 #include "wx/utils.h"
8e609c82 34 #include "wx/panel.h"
76b49cf4 35 #include "wx/frame.h"
da80ae71 36 #include "wx/dc.h"
ed4b0fdc 37 #include "wx/dcclient.h"
f1e01716 38 #include "wx/button.h"
3b3dc801 39 #include "wx/menu.h"
fdf565fe 40 #include "wx/dialog.h"
c0badb70 41 #include "wx/timer.h"
9eddec69 42 #include "wx/settings.h"
246c5004 43 #include "wx/msgdlg.h"
851dee09 44 #include "wx/scrolbar.h"
2a673eb1 45 #include "wx/listbox.h"
e4db172a
WS
46#endif
47
83df96d6 48#include "wx/layout.h"
83df96d6
JS
49#include "wx/scrolwin.h"
50#include "wx/module.h"
51#include "wx/menuitem.h"
2b5f62a0 52#include "wx/fontutil.h"
a17a79ba 53#include "wx/univ/renderer.h"
83df96d6
JS
54
55#if wxUSE_DRAG_AND_DROP
56 #include "wx/dnd.h"
57#endif
58
bc797f4c 59#include "wx/x11/private.h"
7266b672 60#include "X11/Xutil.h"
83df96d6
JS
61
62#include <string.h>
63
83df96d6
JS
64// ----------------------------------------------------------------------------
65// global variables for this module
66// ----------------------------------------------------------------------------
67
83df96d6 68static wxWindow* g_captureWindow = NULL;
c2c0dabf 69static GC g_eraseGC;
83df96d6 70
83df96d6
JS
71// ----------------------------------------------------------------------------
72// macros
73// ----------------------------------------------------------------------------
74
75#define event_left_is_down(x) ((x)->xbutton.state & Button1Mask)
76#define event_middle_is_down(x) ((x)->xbutton.state & Button2Mask)
77#define event_right_is_down(x) ((x)->xbutton.state & Button3Mask)
78
79// ----------------------------------------------------------------------------
80// event tables
81// ----------------------------------------------------------------------------
82
8354aa92 83IMPLEMENT_ABSTRACT_CLASS(wxWindowX11, wxWindowBase)
83df96d6 84
bc797f4c
JS
85BEGIN_EVENT_TABLE(wxWindowX11, wxWindowBase)
86 EVT_SYS_COLOUR_CHANGED(wxWindowX11::OnSysColourChanged)
bc797f4c 87END_EVENT_TABLE()
83df96d6
JS
88
89// ============================================================================
90// implementation
91// ============================================================================
92
93// ----------------------------------------------------------------------------
94// helper functions
95// ----------------------------------------------------------------------------
96
83df96d6
JS
97// ----------------------------------------------------------------------------
98// constructors
99// ----------------------------------------------------------------------------
100
bc797f4c 101void wxWindowX11::Init()
83df96d6 102{
7266b672 103 // X11-specific
ab6b6b15
RR
104 m_mainWindow = (WXWindow) 0;
105 m_clientWindow = (WXWindow) 0;
ffd84c94
WS
106 m_insertIntoMain = false;
107 m_updateNcArea = false;
7de59551 108
ffd84c94
WS
109 m_winCaptured = false;
110 m_needsInputFocus = false;
111 m_isShown = true;
83df96d6
JS
112 m_lastTS = 0;
113 m_lastButton = 0;
83df96d6
JS
114}
115
116// real construction (Init() must have been called before!)
bc797f4c 117bool wxWindowX11::Create(wxWindow *parent, wxWindowID id,
ffd84c94
WS
118 const wxPoint& pos,
119 const wxSize& size,
120 long style,
121 const wxString& name)
83df96d6 122{
ffd84c94 123 wxCHECK_MSG( parent, false, wxT("can't create wxWindow without parent") );
83df96d6
JS
124
125 CreateBase(parent, id, pos, size, style, wxDefaultValidator, name);
126
3cd0b8c5 127 parent->AddChild(this);
83df96d6 128
3cd0b8c5
RR
129 Display *xdisplay = (Display*) wxGlobalDisplay();
130 int xscreen = DefaultScreen( xdisplay );
7e4501ee 131 Visual *xvisual = DefaultVisual( xdisplay, xscreen );
3cd0b8c5 132 Colormap cm = DefaultColormap( xdisplay, xscreen );
b513212d 133
3cd0b8c5 134 m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE);
7de59551
RD
135 m_backgroundColour.CalcPixel( (WXColormap) cm );
136
3cd0b8c5 137 m_foregroundColour = *wxBLACK;
7de59551 138 m_foregroundColour.CalcPixel( (WXColormap) cm );
3cd0b8c5 139
f41bc3e3 140 Window xparent = (Window) parent->GetClientAreaWindow();
7de59551 141
ab6b6b15
RR
142 // Add window's own scrollbars to main window, not to client window
143 if (parent->GetInsertIntoMain())
144 {
145 // wxLogDebug( "Inserted into main: %s", GetName().c_str() );
146 xparent = (Window) parent->GetMainWindow();
147 }
7de59551 148
1cfb7d2c
RR
149 // Size (not including the border) must be nonzero (or a Value error results)!
150 // Note: The Xlib manual doesn't mention this restriction of XCreateWindow.
2f12683e 151 wxSize size2(size);
1cfb7d2c 152 if (size2.x <= 0)
2b5f62a0 153 size2.x = 20;
1cfb7d2c 154 if (size2.y <= 0)
2b5f62a0 155 size2.y = 20;
b513212d 156
2f12683e 157 wxPoint pos2(pos);
ffd84c94 158 if (pos2.x == wxDefaultCoord)
2b5f62a0 159 pos2.x = 0;
ffd84c94 160 if (pos2.y == wxDefaultCoord)
2b5f62a0 161 pos2.y = 0;
7de59551 162
ab6b6b15 163#if wxUSE_TWO_WINDOWS
2b5f62a0 164 bool need_two_windows =
ab6b6b15
RR
165 ((( wxSUNKEN_BORDER | wxRAISED_BORDER | wxSIMPLE_BORDER | wxHSCROLL | wxVSCROLL ) & m_windowStyle) != 0);
166#else
ffd84c94 167 bool need_two_windows = false;
ab6b6b15
RR
168#endif
169
8601b2e1
JS
170#if wxUSE_NANOX
171 long xattributes = 0;
172#else
7e4501ee 173 XSetWindowAttributes xattributes;
ab6b6b15 174 long xattributes_mask = 0;
7de59551 175
ab6b6b15 176 xattributes_mask |= CWBackPixel;
7e4501ee 177 xattributes.background_pixel = m_backgroundColour.GetPixel();
7de59551 178
ab6b6b15 179 xattributes_mask |= CWBorderPixel;
7e4501ee 180 xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
7de59551 181
2f12683e 182 xattributes_mask |= CWEventMask;
8601b2e1 183#endif
7de59551 184
ab6b6b15 185 if (need_two_windows)
2f12683e 186 {
8601b2e1
JS
187#if wxUSE_NANOX
188 long backColor, foreColor;
189 backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
190 foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
7de59551
RD
191
192 Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
8601b2e1
JS
193 0, 0, InputOutput, xvisual, backColor, foreColor);
194 XSelectInput( xdisplay, xwindow,
195 GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
196 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
197 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
198 PropertyChangeMask );
7de59551 199
8601b2e1
JS
200#else
201 // Normal X11
7de59551 202 xattributes.event_mask =
ab6b6b15
RR
203 ExposureMask | StructureNotifyMask | ColormapChangeMask;
204
7de59551 205 Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
ab6b6b15 206 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
8601b2e1
JS
207
208#endif
7de59551 209
ab6b6b15 210 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
7de59551 211
ab6b6b15
RR
212 m_mainWindow = (WXWindow) xwindow;
213 wxAddWindowToTable( xwindow, (wxWindow*) this );
7de59551 214
ab6b6b15 215 XMapWindow( xdisplay, xwindow );
8601b2e1 216
7de59551
RD
217#if !wxUSE_NANOX
218 xattributes.event_mask =
ab6b6b15
RR
219 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
220 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
221 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
222 PropertyChangeMask | VisibilityChangeMask ;
223
e441e1f4 224 if (!HasFlag( wxFULL_REPAINT_ON_RESIZE ))
ab6b6b15
RR
225 {
226 xattributes_mask |= CWBitGravity;
227 xattributes.bit_gravity = StaticGravity;
228 }
8601b2e1 229#endif
7de59551 230
065722d7
RR
231 if (HasFlag( wxSUNKEN_BORDER) || HasFlag( wxRAISED_BORDER))
232 {
233 pos2.x = 2;
234 pos2.y = 2;
235 size2.x -= 4;
236 size2.y -= 4;
7de59551 237 }
1cfb7d2c 238 else if (HasFlag( wxSIMPLE_BORDER ))
065722d7
RR
239 {
240 pos2.x = 1;
241 pos2.y = 1;
242 size2.x -= 2;
243 size2.y -= 2;
7de59551 244 }
1cfb7d2c 245 else
065722d7
RR
246 {
247 pos2.x = 0;
248 pos2.y = 0;
249 }
1cfb7d2c
RR
250
251 // Make again sure the size is nonzero.
252 if (size2.x <= 0)
253 size2.x = 1;
254 if (size2.y <= 0)
255 size2.y = 1;
256
7de59551 257#if wxUSE_NANOX
8601b2e1
JS
258 backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
259 foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
7de59551
RD
260
261 xwindow = XCreateWindowWithColor( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y,
8601b2e1
JS
262 0, 0, InputOutput, xvisual, backColor, foreColor);
263 XSelectInput( xdisplay, xwindow,
264 GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
265 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
266 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
267 PropertyChangeMask );
7de59551 268
8601b2e1 269#else
7de59551 270 xwindow = XCreateWindow( xdisplay, xwindow, pos2.x, pos2.y, size2.x, size2.y,
ab6b6b15 271 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
8601b2e1 272#endif
7de59551 273
ab6b6b15 274 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
7de59551 275
ab6b6b15
RR
276 m_clientWindow = (WXWindow) xwindow;
277 wxAddClientWindowToTable( xwindow, (wxWindow*) this );
7de59551 278
ab6b6b15 279 XMapWindow( xdisplay, xwindow );
2f12683e 280 }
ab6b6b15
RR
281 else
282 {
283 // wxLogDebug( "No two windows needed %s", GetName().c_str() );
8601b2e1
JS
284#if wxUSE_NANOX
285 long backColor, foreColor;
286 backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
287 foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
7de59551
RD
288
289 Window xwindow = XCreateWindowWithColor( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
8601b2e1
JS
290 0, 0, InputOutput, xvisual, backColor, foreColor);
291 XSelectInput( xdisplay, xwindow,
292 GR_EVENT_MASK_CLOSE_REQ | ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
293 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
294 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
295 PropertyChangeMask );
7de59551 296
8601b2e1 297#else
7de59551 298 xattributes.event_mask =
ab6b6b15
RR
299 ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
300 ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
301 KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
302 PropertyChangeMask | VisibilityChangeMask ;
2f12683e 303
e441e1f4 304 if (!HasFlag( wxFULL_REPAINT_ON_RESIZE ))
ab6b6b15
RR
305 {
306 xattributes_mask |= CWBitGravity;
065722d7 307 xattributes.bit_gravity = NorthWestGravity;
ab6b6b15 308 }
7de59551
RD
309
310 Window xwindow = XCreateWindow( xdisplay, xparent, pos2.x, pos2.y, size2.x, size2.y,
ab6b6b15 311 0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
8601b2e1 312#endif
7de59551 313
ab6b6b15 314 XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
7de59551 315
ab6b6b15
RR
316 m_mainWindow = (WXWindow) xwindow;
317 m_clientWindow = m_mainWindow;
318 wxAddWindowToTable( xwindow, (wxWindow*) this );
7de59551 319
ab6b6b15
RR
320 XMapWindow( xdisplay, xwindow );
321 }
b513212d 322
b28d3abf 323 // Is a subwindow, so map immediately
ffd84c94 324 m_isShown = true;
83df96d6
JS
325
326 // Without this, the cursor may not be restored properly (e.g. in splitter
327 // sample).
328 SetCursor(*wxSTANDARD_CURSOR);
329 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
15c69343
JS
330
331 // Don't call this, it can have nasty repercussions for composite controls,
332 // for example
333 // SetSize(pos.x, pos.y, size.x, size.y);
83df96d6 334
ffd84c94 335 return true;
83df96d6
JS
336}
337
338// Destructor
7266b672 339wxWindowX11::~wxWindowX11()
83df96d6 340{
7de59551
RD
341 SendDestroyEvent();
342
83df96d6 343 if (g_captureWindow == this)
2b5f62a0 344 g_captureWindow = NULL;
7de59551 345
ffd84c94 346 m_isBeingDeleted = true;
7de59551 347
d02cb44e 348 DestroyChildren();
83df96d6 349
ab6b6b15 350 if (m_clientWindow != m_mainWindow)
83df96d6 351 {
ab6b6b15
RR
352 // Destroy the cleint window
353 Window xwindow = (Window) m_clientWindow;
354 wxDeleteClientWindowFromTable( xwindow );
7e4501ee 355 XDestroyWindow( wxGlobalDisplay(), xwindow );
ab6b6b15 356 m_clientWindow = NULL;
83df96d6 357 }
7de59551 358
ab6b6b15
RR
359 // Destroy the window
360 Window xwindow = (Window) m_mainWindow;
361 wxDeleteWindowFromTable( xwindow );
362 XDestroyWindow( wxGlobalDisplay(), xwindow );
363 m_mainWindow = NULL;
83df96d6
JS
364}
365
366// ---------------------------------------------------------------------------
367// basic operations
368// ---------------------------------------------------------------------------
369
bc797f4c 370void wxWindowX11::SetFocus()
83df96d6 371{
ab6b6b15 372 Window xwindow = (Window) m_clientWindow;
7de59551 373
86fd8bda 374 wxCHECK_RET( xwindow, wxT("invalid window") );
7de59551 375
10e0e1be
JS
376 // Don't assert; we might be trying to set the focus for a panel
377 // with only static controls, so the panel returns false from AcceptsFocus.
378 // The app should be not be expected to deal with this.
379 if (!AcceptsFocus())
380 return;
7de59551 381
9b8270da
RR
382#if 0
383 if (GetName() == "scrollBar")
384 {
385 char *crash = NULL;
386 *crash = 0;
387 }
388#endif
7de59551 389
3a0b23eb
JS
390 if (wxWindowIsVisible(xwindow))
391 {
58ec2255
JS
392 wxLogTrace( _T("focus"), _T("wxWindowX11::SetFocus: %s"), GetClassInfo()->GetClassName());
393 // XSetInputFocus( wxGlobalDisplay(), xwindow, RevertToParent, CurrentTime );
394 XSetInputFocus( wxGlobalDisplay(), xwindow, RevertToNone, CurrentTime );
ffd84c94 395 m_needsInputFocus = false;
3a0b23eb
JS
396 }
397 else
398 {
ffd84c94 399 m_needsInputFocus = true;
3a0b23eb 400 }
83df96d6
JS
401}
402
403// Get the window with the focus
0fe02759 404wxWindow *wxWindowBase::DoFindFocus()
83df96d6 405{
86fd8bda 406 Window xfocus = (Window) 0;
b513212d 407 int revert = 0;
bc797f4c 408
86fd8bda
RR
409 XGetInputFocus( wxGlobalDisplay(), &xfocus, &revert);
410 if (xfocus)
83df96d6 411 {
86fd8bda 412 wxWindow *win = wxGetWindowFromTable( xfocus );
288efe84
JS
413 if (!win)
414 {
415 win = wxGetClientWindowFromTable( xfocus );
416 }
b513212d
JS
417
418 return win;
83df96d6
JS
419 }
420
b513212d 421 return NULL;
83df96d6
JS
422}
423
b513212d
JS
424// Enabling/disabling handled by event loop, and not sending events
425// if disabled.
bc797f4c 426bool wxWindowX11::Enable(bool enable)
83df96d6
JS
427{
428 if ( !wxWindowBase::Enable(enable) )
ffd84c94 429 return false;
7de59551 430
ffd84c94 431 return true;
83df96d6
JS
432}
433
bc797f4c 434bool wxWindowX11::Show(bool show)
83df96d6 435{
7edcafa4 436 wxWindowBase::Show(show);
83df96d6 437
ab6b6b15
RR
438 Window xwindow = (Window) m_mainWindow;
439 Display *xdisp = wxGlobalDisplay();
83df96d6 440 if (show)
b513212d 441 {
7e4501ee 442 // wxLogDebug( "Mapping window of type %s", GetName().c_str() );
ab6b6b15 443 XMapWindow(xdisp, xwindow);
b513212d 444 }
83df96d6 445 else
b513212d 446 {
7e4501ee 447 // wxLogDebug( "Unmapping window of type %s", GetName().c_str() );
ab6b6b15 448 XUnmapWindow(xdisp, xwindow);
b513212d 449 }
83df96d6 450
ffd84c94 451 return true;
83df96d6
JS
452}
453
454// Raise the window to the top of the Z order
bc797f4c 455void wxWindowX11::Raise()
83df96d6 456{
ab6b6b15
RR
457 if (m_mainWindow)
458 XRaiseWindow( wxGlobalDisplay(), (Window) m_mainWindow );
83df96d6
JS
459}
460
461// Lower the window to the bottom of the Z order
bc797f4c 462void wxWindowX11::Lower()
83df96d6 463{
ab6b6b15
RR
464 if (m_mainWindow)
465 XLowerWindow( wxGlobalDisplay(), (Window) m_mainWindow );
83df96d6
JS
466}
467
ffd84c94
WS
468void wxWindowX11::SetLabel(const wxString& WXUNUSED(label))
469{
470 // TODO
471}
472
473wxString wxWindowX11::GetLabel() const
474{
475 // TODO
476 return wxEmptyString;
477}
478
bc797f4c 479void wxWindowX11::DoCaptureMouse()
83df96d6 480{
7edcafa4
JS
481 if ((g_captureWindow != NULL) && (g_captureWindow != this))
482 {
4362c705 483 wxFAIL_MSG(wxT("Trying to capture before mouse released."));
7edcafa4 484
346d4fcd
RR
485 // Core dump now
486 int *tmp = NULL;
487 (*tmp) = 1;
488 return;
7edcafa4 489 }
7de59551 490
346d4fcd 491 if (m_winCaptured)
83df96d6
JS
492 return;
493
ab6b6b15 494 Window xwindow = (Window) m_clientWindow;
346d4fcd 495
86fd8bda 496 wxCHECK_RET( xwindow, wxT("invalid window") );
7de59551 497
7edcafa4
JS
498 g_captureWindow = (wxWindow*) this;
499
346d4fcd 500 if (xwindow)
b513212d 501 {
346d4fcd 502 int res = XGrabPointer(wxGlobalDisplay(), xwindow,
b513212d
JS
503 FALSE,
504 ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
505 GrabModeAsync,
2b5f62a0 506 GrabModeAsync,
b513212d
JS
507 None,
508 None, /* cursor */ // TODO: This may need to be set to the cursor of this window
346d4fcd 509 CurrentTime );
b513212d 510
b28d3abf 511 if (res != GrabSuccess)
b513212d 512 {
346d4fcd 513 wxString msg;
2b5f62a0 514 msg.Printf(wxT("Failed to grab pointer for window %s"), this->GetClassInfo()->GetClassName());
346d4fcd
RR
515 wxLogDebug(msg);
516 if (res == GrabNotViewable)
2b5f62a0 517 wxLogDebug( wxT("This is not a viewable window - perhaps not shown yet?") );
7de59551 518
346d4fcd 519 g_captureWindow = NULL;
b28d3abf 520 return;
b513212d 521 }
346d4fcd 522
ffd84c94 523 m_winCaptured = true;
b513212d 524 }
83df96d6
JS
525}
526
bc797f4c 527void wxWindowX11::DoReleaseMouse()
83df96d6
JS
528{
529 g_captureWindow = NULL;
7de59551 530
83df96d6
JS
531 if ( !m_winCaptured )
532 return;
533
ab6b6b15 534 Window xwindow = (Window) m_clientWindow;
b513212d 535
346d4fcd 536 if (xwindow)
b28d3abf 537 {
346d4fcd 538 XUngrabPointer( wxGlobalDisplay(), CurrentTime );
b28d3abf 539 }
7de59551 540
9691c806 541 // wxLogDebug( "Ungrabbed pointer in %s", GetName().c_str() );
83df96d6 542
ffd84c94 543 m_winCaptured = false;
83df96d6
JS
544}
545
bc797f4c 546bool wxWindowX11::SetFont(const wxFont& font)
83df96d6
JS
547{
548 if ( !wxWindowBase::SetFont(font) )
549 {
550 // nothing to do
ffd84c94 551 return false;
83df96d6
JS
552 }
553
ffd84c94 554 return true;
83df96d6
JS
555}
556
bc797f4c 557bool wxWindowX11::SetCursor(const wxCursor& cursor)
83df96d6
JS
558{
559 if ( !wxWindowBase::SetCursor(cursor) )
560 {
561 // no change
ffd84c94 562 return false;
83df96d6
JS
563 }
564
ab6b6b15 565 Window xwindow = (Window) m_clientWindow;
86fd8bda 566
ffd84c94 567 wxCHECK_MSG( xwindow, false, wxT("invalid window") );
7de59551 568
86fd8bda 569 wxCursor cursorToUse;
83df96d6 570 if (m_cursor.Ok())
86fd8bda 571 cursorToUse = m_cursor;
83df96d6 572 else
86fd8bda 573 cursorToUse = *wxSTANDARD_CURSOR;
83df96d6 574
86fd8bda 575 Cursor xcursor = (Cursor) cursorToUse.GetCursor();
83df96d6 576
e88be8c9 577 XDefineCursor( wxGlobalDisplay(), xwindow, xcursor );
83df96d6 578
ffd84c94 579 return true;
83df96d6
JS
580}
581
582// Coordinates relative to the window
bc797f4c 583void wxWindowX11::WarpPointer (int x, int y)
83df96d6 584{
ab6b6b15 585 Window xwindow = (Window) m_clientWindow;
86fd8bda
RR
586
587 wxCHECK_RET( xwindow, wxT("invalid window") );
7de59551 588
86fd8bda 589 XWarpPointer( wxGlobalDisplay(), None, xwindow, 0, 0, 0, 0, x, y);
83df96d6
JS
590}
591
83df96d6 592// Does a physical scroll
bc797f4c 593void wxWindowX11::ScrollWindow(int dx, int dy, const wxRect *rect)
83df96d6 594{
fc9be1cf
RR
595 // No scrolling requested.
596 if ((dx == 0) && (dy == 0)) return;
7de59551 597
fc9be1cf
RR
598 if (!m_updateRegion.IsEmpty())
599 {
600 m_updateRegion.Offset( dx, dy );
7de59551 601
fc9be1cf
RR
602 int cw = 0;
603 int ch = 0;
604 GetSize( &cw, &ch ); // GetClientSize() ??
605 m_updateRegion.Intersect( 0, 0, cw, ch );
606 }
7de59551 607
fc9be1cf
RR
608 if (!m_clearRegion.IsEmpty())
609 {
610 m_clearRegion.Offset( dx, dy );
7de59551 611
fc9be1cf
RR
612 int cw = 0;
613 int ch = 0;
614 GetSize( &cw, &ch ); // GetClientSize() ??
615 m_clearRegion.Intersect( 0, 0, cw, ch );
616 }
7de59551 617
f41bc3e3 618 Window xwindow = (Window) GetClientAreaWindow();
7e085304
RR
619
620 wxCHECK_RET( xwindow, wxT("invalid window") );
621
622 Display *xdisplay = wxGlobalDisplay();
623
624 GC xgc = XCreateGC( xdisplay, xwindow, 0, NULL );
625 XSetGraphicsExposures( xdisplay, xgc, True );
626
e88be8c9
RR
627 int s_x = 0;
628 int s_y = 0;
4125131b
RR
629 int cw;
630 int ch;
631 if (rect)
632 {
633 s_x = rect->x;
634 s_y = rect->y;
7de59551 635
4125131b
RR
636 cw = rect->width;
637 ch = rect->height;
638 }
639 else
640 {
641 s_x = 0;
642 s_y = 0;
643 GetClientSize( &cw, &ch );
644 }
7de59551 645
ab6b6b15
RR
646#if wxUSE_TWO_WINDOWS
647 wxPoint offset( 0,0 );
648#else
4125131b
RR
649 wxPoint offset = GetClientAreaOrigin();
650 s_x += offset.x;
651 s_y += offset.y;
ab6b6b15 652#endif
7de59551 653
7e085304
RR
654 int w = cw - abs(dx);
655 int h = ch - abs(dy);
7de59551 656
7e085304 657 if ((h < 0) || (w < 0))
83df96d6 658 {
7e085304 659 Refresh();
83df96d6
JS
660 }
661 else
662 {
4125131b 663 wxRect rect;
f809133f
RR
664 if (dx < 0) rect.x = cw+dx + offset.x; else rect.x = s_x;
665 if (dy < 0) rect.y = ch+dy + offset.y; else rect.y = s_y;
4125131b
RR
666 if (dy != 0) rect.width = cw; else rect.width = abs(dx);
667 if (dx != 0) rect.height = ch; else rect.height = abs(dy);
7de59551 668
4125131b
RR
669 int d_x = s_x;
670 int d_y = s_y;
7de59551 671
4125131b
RR
672 if (dx < 0) s_x += -dx;
673 if (dy < 0) s_y += -dy;
e88be8c9
RR
674 if (dx > 0) d_x = dx + offset.x;
675 if (dy > 0) d_y = dy + offset.y;
7e085304
RR
676
677 XCopyArea( xdisplay, xwindow, xwindow, xgc, s_x, s_y, w, h, d_x, d_y );
7de59551 678
e88be8c9 679 // wxLogDebug( "Copy: s_x %d s_y %d w %d h %d d_x %d d_y %d", s_x, s_y, w, h, d_x, d_y );
7e085304 680
e88be8c9 681 // wxLogDebug( "Update: %d %d %d %d", rect.x, rect.y, rect.width, rect.height );
7e085304
RR
682
683 m_updateRegion.Union( rect );
684 m_clearRegion.Union( rect );
83df96d6 685 }
7de59551 686
7e085304 687 XFreeGC( xdisplay, xgc );
271f05f7
JS
688
689 // Move Clients, but not the scrollbars
690 // FIXME: There may be a better method to move a lot of Windows within X11
691 wxScrollBar *sbH = ((wxWindow *) this)->GetScrollbar( wxHORIZONTAL );
692 wxScrollBar *sbV = ((wxWindow *) this)->GetScrollbar( wxVERTICAL );
693 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
694 while ( node )
695 {
696 // Only propagate to non-top-level windows
697 wxWindow *win = node->GetData();
698 if ( win->GetParent() && win != sbH && win != sbV )
699 {
700 wxPoint pos = win->GetPosition();
701 // Add the delta to the old Position
702 pos.x += dx;
703 pos.y += dy;
704 win->SetPosition(pos);
705 }
706 node = node->GetNext();
707 }
83df96d6
JS
708}
709
710// ---------------------------------------------------------------------------
711// drag and drop
712// ---------------------------------------------------------------------------
713
714#if wxUSE_DRAG_AND_DROP
715
bc797f4c 716void wxWindowX11::SetDropTarget(wxDropTarget * WXUNUSED(pDropTarget))
83df96d6
JS
717{
718 // TODO
719}
720
721#endif
722
723// Old style file-manager drag&drop
bc797f4c 724void wxWindowX11::DragAcceptFiles(bool WXUNUSED(accept))
83df96d6
JS
725{
726 // TODO
727}
728
729// ----------------------------------------------------------------------------
730// tooltips
731// ----------------------------------------------------------------------------
732
733#if wxUSE_TOOLTIPS
734
bc797f4c 735void wxWindowX11::DoSetToolTip(wxToolTip * WXUNUSED(tooltip))
83df96d6
JS
736{
737 // TODO
738}
739
740#endif // wxUSE_TOOLTIPS
741
83df96d6
JS
742// ---------------------------------------------------------------------------
743// moving and resizing
744// ---------------------------------------------------------------------------
745
bc797f4c 746bool wxWindowX11::PreResize()
83df96d6 747{
ffd84c94 748 return true;
83df96d6
JS
749}
750
751// Get total size
bc797f4c 752void wxWindowX11::DoGetSize(int *x, int *y) const
83df96d6 753{
ab6b6b15 754 Window xwindow = (Window) m_mainWindow;
86fd8bda
RR
755
756 wxCHECK_RET( xwindow, wxT("invalid window") );
7de59551 757
59db9cfa 758 //XSync(wxGlobalDisplay(), False);
e941874b 759
86fd8bda
RR
760 XWindowAttributes attr;
761 Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
762 wxASSERT(status);
7de59551 763
86fd8bda
RR
764 if (status)
765 {
766 *x = attr.width /* + 2*m_borderSize */ ;
767 *y = attr.height /* + 2*m_borderSize */ ;
83df96d6 768 }
83df96d6
JS
769}
770
bc797f4c 771void wxWindowX11::DoGetPosition(int *x, int *y) const
83df96d6 772{
ab6b6b15 773 Window window = (Window) m_mainWindow;
b513212d 774 if (window)
83df96d6 775 {
59db9cfa 776 //XSync(wxGlobalDisplay(), False);
b513212d
JS
777 XWindowAttributes attr;
778 Status status = XGetWindowAttributes(wxGlobalDisplay(), window, & attr);
779 wxASSERT(status);
7de59551 780
b513212d
JS
781 if (status)
782 {
783 *x = attr.x;
784 *y = attr.y;
7de59551 785
b513212d
JS
786 // We may be faking the client origin. So a window that's really at (0, 30)
787 // may appear (to wxWin apps) to be at (0, 0).
788 if (GetParent())
789 {
790 wxPoint pt(GetParent()->GetClientAreaOrigin());
791 *x -= pt.x;
792 *y -= pt.y;
793 }
794 }
83df96d6 795 }
83df96d6
JS
796}
797
bc797f4c 798void wxWindowX11::DoScreenToClient(int *x, int *y) const
83df96d6 799{
b513212d 800 Display *display = wxGlobalDisplay();
bc797f4c 801 Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
ab6b6b15 802 Window thisWindow = (Window) m_clientWindow;
83df96d6
JS
803
804 Window childWindow;
805 int xx = *x;
806 int yy = *y;
807 XTranslateCoordinates(display, rootWindow, thisWindow, xx, yy, x, y, &childWindow);
808}
809
bc797f4c 810void wxWindowX11::DoClientToScreen(int *x, int *y) const
83df96d6 811{
b513212d 812 Display *display = wxGlobalDisplay();
bc797f4c 813 Window rootWindow = RootWindowOfScreen(DefaultScreenOfDisplay(display));
ab6b6b15 814 Window thisWindow = (Window) m_clientWindow;
83df96d6
JS
815
816 Window childWindow;
817 int xx = *x;
818 int yy = *y;
819 XTranslateCoordinates(display, thisWindow, rootWindow, xx, yy, x, y, &childWindow);
820}
821
822
823// Get size *available for subwindows* i.e. excluding menu bar etc.
bc797f4c 824void wxWindowX11::DoGetClientSize(int *x, int *y) const
83df96d6 825{
ab6b6b15 826 Window window = (Window) m_mainWindow;
b513212d
JS
827
828 if (window)
829 {
830 XWindowAttributes attr;
3cd0b8c5 831 Status status = XGetWindowAttributes( wxGlobalDisplay(), window, &attr );
b513212d 832 wxASSERT(status);
7de59551 833
b513212d
JS
834 if (status)
835 {
836 *x = attr.width ;
837 *y = attr.height ;
838 }
839 }
83df96d6
JS
840}
841
bc797f4c 842void wxWindowX11::DoSetSize(int x, int y, int width, int height, int sizeFlags)
83df96d6 843{
df0e1b64 844 // wxLogDebug("DoSetSize: %s (%ld) %d, %d %dx%d", GetClassInfo()->GetClassName(), GetId(), x, y, width, height);
7de59551 845
ab6b6b15 846 Window xwindow = (Window) m_mainWindow;
83df96d6 847
27398643
RR
848 wxCHECK_RET( xwindow, wxT("invalid window") );
849
850 XWindowAttributes attr;
851 Status status = XGetWindowAttributes( wxGlobalDisplay(), xwindow, &attr );
852 wxCHECK_RET( status, wxT("invalid window attributes") );
7de59551 853
27398643
RR
854 int new_x = attr.x;
855 int new_y = attr.y;
856 int new_w = attr.width;
857 int new_h = attr.height;
7de59551 858
ffd84c94 859 if (x != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
83df96d6 860 {
27398643 861 int yy = 0;
e5053ade 862 AdjustForParentClientOrigin( x, yy, sizeFlags);
27398643 863 new_x = x;
83df96d6 864 }
ffd84c94 865 if (y != wxDefaultCoord || (sizeFlags & wxSIZE_ALLOW_MINUS_ONE))
83df96d6 866 {
27398643 867 int xx = 0;
e5053ade 868 AdjustForParentClientOrigin( xx, y, sizeFlags);
27398643 869 new_y = y;
83df96d6 870 }
ffd84c94 871 if (width != wxDefaultCoord)
83df96d6 872 {
27398643
RR
873 new_w = width;
874 if (new_w <= 0)
875 new_w = 20;
83df96d6 876 }
ffd84c94 877 if (height != wxDefaultCoord)
b513212d 878 {
27398643
RR
879 new_h = height;
880 if (new_h <= 0)
881 new_h = 20;
b513212d 882 }
7de59551 883
27398643 884 DoMoveWindow( new_x, new_y, new_w, new_h );
83df96d6
JS
885}
886
bc797f4c 887void wxWindowX11::DoSetClientSize(int width, int height)
83df96d6 888{
df0e1b64 889 // wxLogDebug("DoSetClientSize: %s (%ld) %dx%d", GetClassInfo()->GetClassName(), GetId(), width, height);
7de59551 890
ab6b6b15 891 Window xwindow = (Window) m_mainWindow;
83df96d6 892
27398643 893 wxCHECK_RET( xwindow, wxT("invalid window") );
83df96d6 894
2f12683e 895 XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
7de59551 896
ab6b6b15
RR
897 if (m_mainWindow != m_clientWindow)
898 {
899 xwindow = (Window) m_clientWindow;
7de59551 900
a17a79ba
RR
901 wxWindow *window = (wxWindow*) this;
902 wxRenderer *renderer = window->GetRenderer();
903 if (renderer)
ab6b6b15 904 {
a17a79ba
RR
905 wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
906 width -= border.x + border.width;
907 height -= border.y + border.height;
ab6b6b15 908 }
7de59551 909
ab6b6b15
RR
910 XResizeWindow( wxGlobalDisplay(), xwindow, width, height );
911 }
83df96d6
JS
912}
913
ab6b6b15
RR
914void wxWindowX11::DoMoveWindow(int x, int y, int width, int height)
915{
916 Window xwindow = (Window) m_mainWindow;
917
918 wxCHECK_RET( xwindow, wxT("invalid window") );
919
920#if !wxUSE_NANOX
921
922 XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, width, height );
923 if (m_mainWindow != m_clientWindow)
924 {
925 xwindow = (Window) m_clientWindow;
7de59551 926
a17a79ba
RR
927 wxWindow *window = (wxWindow*) this;
928 wxRenderer *renderer = window->GetRenderer();
929 if (renderer)
ab6b6b15 930 {
a17a79ba
RR
931 wxRect border = renderer->GetBorderDimensions( (wxBorder)(m_windowStyle & wxBORDER_MASK) );
932 x = border.x;
933 y = border.y;
934 width -= border.x + border.width;
935 height -= border.y + border.height;
936 }
937 else
ab6b6b15
RR
938 {
939 x = 0;
940 y = 0;
941 }
7de59551 942
ab6b6b15
RR
943 wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
944 if (sb && sb->IsShown())
945 {
946 wxSize size = sb->GetSize();
947 height -= size.y;
948 }
949 sb = window->GetScrollbar( wxVERTICAL );
950 if (sb && sb->IsShown())
951 {
952 wxSize size = sb->GetSize();
953 width -= size.x;
954 }
7de59551 955
288efe84 956 XMoveResizeWindow( wxGlobalDisplay(), xwindow, x, y, wxMax(1, width), wxMax(1, height) );
ab6b6b15 957 }
7de59551
RD
958
959#else
ab6b6b15
RR
960
961 XWindowChanges windowChanges;
962 windowChanges.x = x;
963 windowChanges.y = y;
964 windowChanges.width = width;
965 windowChanges.height = height;
966 windowChanges.stack_mode = 0;
967 int valueMask = CWX | CWY | CWWidth | CWHeight;
968
969 XConfigureWindow( wxGlobalDisplay(), xwindow, valueMask, &windowChanges );
7de59551 970
ab6b6b15
RR
971#endif
972}
973
024f89f9 974void wxWindowX11::DoSetSizeHints(int minW, int minH, int maxW, int maxH, int incW, int incH)
83df96d6
JS
975{
976 m_minWidth = minW;
977 m_minHeight = minH;
978 m_maxWidth = maxW;
979 m_maxHeight = maxH;
980
461e93f9 981#if !wxUSE_NANOX
b513212d
JS
982 XSizeHints sizeHints;
983 sizeHints.flags = 0;
7de59551 984
b513212d 985 if (minW > -1 && minH > -1)
83df96d6 986 {
b513212d
JS
987 sizeHints.flags |= PMinSize;
988 sizeHints.min_width = minW;
989 sizeHints.min_height = minH;
990 }
991 if (maxW > -1 && maxH > -1)
992 {
993 sizeHints.flags |= PMaxSize;
994 sizeHints.max_width = maxW;
995 sizeHints.max_height = maxH;
996 }
997 if (incW > -1 && incH > -1)
998 {
999 sizeHints.flags |= PResizeInc;
1000 sizeHints.width_inc = incW;
1001 sizeHints.height_inc = incH;
83df96d6
JS
1002 }
1003
ab6b6b15 1004 XSetWMNormalHints(wxGlobalDisplay(), (Window) m_mainWindow, &sizeHints );
2f12683e 1005#endif
83df96d6
JS
1006}
1007
1008// ---------------------------------------------------------------------------
1009// text metrics
1010// ---------------------------------------------------------------------------
1011
bc797f4c 1012int wxWindowX11::GetCharHeight() const
83df96d6 1013{
4837b89e
JS
1014 wxFont font(GetFont());
1015 wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
83df96d6 1016
2b5f62a0
VZ
1017#if wxUSE_UNICODE
1018 // There should be an easier way.
1019 PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
4837b89e 1020 pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
2b5f62a0
VZ
1021 pango_layout_set_text(layout, "H", 1 );
1022 int w,h;
1023 pango_layout_get_pixel_size(layout, &w, &h);
1024 g_object_unref( G_OBJECT( layout ) );
7de59551 1025
2b5f62a0
VZ
1026 return h;
1027#else
4837b89e 1028 WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
83df96d6
JS
1029
1030 int direction, ascent, descent;
1031 XCharStruct overall;
1032 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1033 &descent, &overall);
1034
1035 // return (overall.ascent + overall.descent);
1036 return (ascent + descent);
2b5f62a0 1037#endif
83df96d6
JS
1038}
1039
bc797f4c 1040int wxWindowX11::GetCharWidth() const
83df96d6 1041{
4837b89e
JS
1042 wxFont font(GetFont());
1043 wxCHECK_MSG( font.Ok(), 0, wxT("valid window font needed") );
83df96d6 1044
2b5f62a0
VZ
1045#if wxUSE_UNICODE
1046 // There should be an easier way.
1047 PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
4837b89e 1048 pango_layout_set_font_description( layout, font.GetNativeFontInfo()->description );
2b5f62a0
VZ
1049 pango_layout_set_text(layout, "H", 1 );
1050 int w,h;
1051 pango_layout_get_pixel_size(layout, &w, &h);
1052 g_object_unref( G_OBJECT( layout ) );
7de59551 1053
2b5f62a0
VZ
1054 return w;
1055#else
4837b89e 1056 WXFontStructPtr pFontStruct = font.GetFontStruct(1.0, wxGlobalDisplay());
83df96d6
JS
1057
1058 int direction, ascent, descent;
1059 XCharStruct overall;
1060 XTextExtents ((XFontStruct*) pFontStruct, "x", 1, &direction, &ascent,
1061 &descent, &overall);
1062
1063 return overall.width;
2b5f62a0 1064#endif
83df96d6
JS
1065}
1066
bc797f4c 1067void wxWindowX11::GetTextExtent(const wxString& string,
ffd84c94
WS
1068 int *x, int *y,
1069 int *descent, int *externalLeading,
1070 const wxFont *theFont) const
83df96d6 1071{
4837b89e 1072 wxFont fontToUse = GetFont();
0d1dff01 1073 if (theFont) fontToUse = *theFont;
83df96d6 1074
0d1dff01
RR
1075 wxCHECK_RET( fontToUse.Ok(), wxT("invalid font") );
1076
ffd84c94 1077 if (string.empty())
2b5f62a0
VZ
1078 {
1079 if (x) (*x) = 0;
1080 if (y) (*y) = 0;
1081 return;
1082 }
1083
1084#if wxUSE_UNICODE
1085 PangoLayout *layout = pango_layout_new( wxTheApp->GetPangoContext() );
7de59551 1086
2b5f62a0
VZ
1087 PangoFontDescription *desc = fontToUse.GetNativeFontInfo()->description;
1088 pango_layout_set_font_description(layout, desc);
7de59551 1089
2b5f62a0
VZ
1090 const wxCharBuffer data = wxConvUTF8.cWC2MB( string );
1091 pango_layout_set_text(layout, (const char*) data, strlen( (const char*) data ));
7de59551 1092
2b5f62a0
VZ
1093 PangoLayoutLine *line = (PangoLayoutLine *)pango_layout_get_lines(layout)->data;
1094
7de59551 1095
2b5f62a0
VZ
1096 PangoRectangle rect;
1097 pango_layout_line_get_extents(line, NULL, &rect);
7de59551 1098
2b5f62a0
VZ
1099 if (x) (*x) = (wxCoord) (rect.width / PANGO_SCALE);
1100 if (y) (*y) = (wxCoord) (rect.height / PANGO_SCALE);
1101 if (descent)
1102 {
1103 // Do something about metrics here
1104 (*descent) = 0;
1105 }
1106 if (externalLeading) (*externalLeading) = 0; // ??
1107
1108 g_object_unref( G_OBJECT( layout ) );
1109#else
ab6b6b15 1110 WXFontStructPtr pFontStruct = fontToUse.GetFontStruct(1.0, wxGlobalDisplay());
83df96d6
JS
1111
1112 int direction, ascent, descent2;
1113 XCharStruct overall;
851dee09 1114 int slen = string.length();
83df96d6 1115
461e93f9 1116 XTextExtents((XFontStruct*) pFontStruct, (char*) string.c_str(), slen,
83df96d6
JS
1117 &direction, &ascent, &descent2, &overall);
1118
1119 if ( x )
1120 *x = (overall.width);
1121 if ( y )
1122 *y = (ascent + descent2);
1123 if (descent)
1124 *descent = descent2;
1125 if (externalLeading)
1126 *externalLeading = 0;
2b5f62a0 1127#endif
83df96d6
JS
1128}
1129
1130// ----------------------------------------------------------------------------
1131// painting
1132// ----------------------------------------------------------------------------
1133
bc797f4c 1134void wxWindowX11::Refresh(bool eraseBack, const wxRect *rect)
83df96d6 1135{
d02cb44e
RR
1136 if (eraseBack)
1137 {
1138 if (rect)
1139 {
1140 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1141 m_clearRegion.Union( rect->x, rect->y, rect->width, rect->height );
1142 }
1143 else
1144 {
1145 int height,width;
1146 GetSize( &width, &height );
7de59551 1147
d02cb44e
RR
1148 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1149 m_clearRegion.Clear();
1150 m_clearRegion.Union( 0, 0, width, height );
1151 }
1152 }
83df96d6 1153
83df96d6
JS
1154 if (rect)
1155 {
d02cb44e
RR
1156 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1157 m_updateRegion.Union( rect->x, rect->y, rect->width, rect->height );
83df96d6
JS
1158 }
1159 else
1160 {
0d1dff01
RR
1161 int height,width;
1162 GetSize( &width, &height );
7de59551 1163
d02cb44e
RR
1164 // Schedule for later Updating in ::Update() or ::OnInternalIdle().
1165 m_updateRegion.Clear();
1166 m_updateRegion.Union( 0, 0, width, height );
83df96d6 1167 }
d02cb44e 1168}
83df96d6 1169
d02cb44e
RR
1170void wxWindowX11::Update()
1171{
ab6b6b15
RR
1172 if (m_updateNcArea)
1173 {
065722d7 1174 // wxLogDebug("wxWindowX11::UpdateNC: %s", GetClassInfo()->GetClassName());
ab6b6b15
RR
1175 // Send nc paint events.
1176 SendNcPaintEvents();
1177 }
7de59551 1178
d02cb44e 1179 if (!m_updateRegion.IsEmpty())
83df96d6 1180 {
ab6b6b15 1181 // wxLogDebug("wxWindowX11::Update: %s", GetClassInfo()->GetClassName());
887dd52f
RR
1182 // Actually send erase events.
1183 SendEraseEvents();
7de59551 1184
887dd52f
RR
1185 // Actually send paint events.
1186 SendPaintEvents();
83df96d6 1187 }
83df96d6
JS
1188}
1189
887dd52f 1190void wxWindowX11::SendEraseEvents()
83df96d6 1191{
2f12683e 1192 if (m_clearRegion.IsEmpty()) return;
7de59551 1193
ab6b6b15 1194 wxClientDC dc( (wxWindow*)this );
2f12683e 1195 dc.SetClippingRegion( m_clearRegion );
7de59551 1196
2f12683e
RR
1197 wxEraseEvent erase_event( GetId(), &dc );
1198 erase_event.SetEventObject( this );
0b5c0e1a 1199
c2c0dabf 1200 if (!GetEventHandler()->ProcessEvent(erase_event) )
2f12683e 1201 {
2f12683e 1202 Display *xdisplay = wxGlobalDisplay();
f41bc3e3 1203 Window xwindow = (Window) GetClientAreaWindow();
c2c0dabf 1204 XSetForeground( xdisplay, g_eraseGC, m_backgroundColour.GetPixel() );
7de59551 1205
2f12683e
RR
1206 wxRegionIterator upd( m_clearRegion );
1207 while (upd)
1934d291 1208 {
c2c0dabf 1209 XFillRectangle( xdisplay, xwindow, g_eraseGC,
2f12683e
RR
1210 upd.GetX(), upd.GetY(), upd.GetWidth(), upd.GetHeight() );
1211 upd ++;
1934d291 1212 }
83df96d6 1213 }
7de59551 1214
2f12683e 1215 m_clearRegion.Clear();
887dd52f
RR
1216}
1217
887dd52f
RR
1218void wxWindowX11::SendPaintEvents()
1219{
df0e1b64
JS
1220 // wxLogDebug("SendPaintEvents: %s (%ld)", GetClassInfo()->GetClassName(), GetId());
1221
ffd84c94 1222 m_clipPaintRegion = true;
7de59551 1223
1934d291
RR
1224 wxPaintEvent paint_event( GetId() );
1225 paint_event.SetEventObject( this );
1226 GetEventHandler()->ProcessEvent( paint_event );
7de59551 1227
0b5c0e1a 1228 m_updateRegion.Clear();
7de59551 1229
ffd84c94 1230 m_clipPaintRegion = false;
83df96d6
JS
1231}
1232
ab6b6b15
RR
1233void wxWindowX11::SendNcPaintEvents()
1234{
a17a79ba
RR
1235 wxWindow *window = (wxWindow*) this;
1236
1237 // All this for drawing the small square between the scrollbars.
1238 int width = 0;
1239 int height = 0;
1240 int x = 0;
1241 int y = 0;
1242 wxScrollBar *sb = window->GetScrollbar( wxHORIZONTAL );
1243 if (sb && sb->IsShown())
1244 {
1245 height = sb->GetSize().y;
1246 y = sb->GetPosition().y;
7de59551 1247
a17a79ba
RR
1248 sb = window->GetScrollbar( wxVERTICAL );
1249 if (sb && sb->IsShown())
1250 {
1251 width = sb->GetSize().x;
1252 x = sb->GetPosition().x;
1253
1254 Display *xdisplay = wxGlobalDisplay();
1255 Window xwindow = (Window) GetMainWindow();
1256 Colormap cm = (Colormap) wxTheApp->GetMainColormap( wxGetDisplay() );
1257 wxColour colour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
1258 colour.CalcPixel( (WXColormap) cm );
7de59551 1259
a17a79ba 1260 XSetForeground( xdisplay, g_eraseGC, colour.GetPixel() );
7de59551 1261
a17a79ba
RR
1262 XFillRectangle( xdisplay, xwindow, g_eraseGC, x, y, width, height );
1263 }
1264 }
7de59551 1265
ab6b6b15
RR
1266 wxNcPaintEvent nc_paint_event( GetId() );
1267 nc_paint_event.SetEventObject( this );
1268 GetEventHandler()->ProcessEvent( nc_paint_event );
7de59551 1269
ffd84c94 1270 m_updateNcArea = false;
ab6b6b15
RR
1271}
1272
83df96d6
JS
1273// ----------------------------------------------------------------------------
1274// event handlers
1275// ----------------------------------------------------------------------------
1276
1277// Responds to colour changes: passes event on to children.
bc797f4c 1278void wxWindowX11::OnSysColourChanged(wxSysColourChangedEvent& event)
83df96d6 1279{
ac32ba44 1280 wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
83df96d6
JS
1281 while ( node )
1282 {
1283 // Only propagate to non-top-level windows
1284 wxWindow *win = node->GetData();
1285 if ( win->GetParent() )
1286 {
1287 wxSysColourChangedEvent event2;
687706f5 1288 event.SetEventObject(win);
83df96d6
JS
1289 win->GetEventHandler()->ProcessEvent(event2);
1290 }
1291
1292 node = node->GetNext();
1293 }
1294}
1295
58ec2255
JS
1296// See handler for InFocus case in app.cpp for details.
1297wxWindow* g_GettingFocus = NULL;
1298
0d1dff01 1299void wxWindowX11::OnInternalIdle()
83df96d6 1300{
0d1dff01
RR
1301 // Update invalidated regions.
1302 Update();
7de59551 1303
83df96d6
JS
1304 // This calls the UI-update mechanism (querying windows for
1305 // menu/toolbar/control state information)
e6d82295 1306 if (wxUpdateUIEvent::CanUpdate((wxWindow*) this))
e39af974 1307 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
3a0b23eb
JS
1308
1309 // Set the input focus if couldn't do it before
1310 if (m_needsInputFocus)
ff6b424a 1311 {
4cae9a20
JS
1312#if 0
1313 wxString msg;
1314 msg.Printf("Setting focus for %s from OnInternalIdle\n", GetClassInfo()->GetClassName());
1315 printf(msg.c_str());
2b5f62a0
VZ
1316#endif
1317 SetFocus();
7de59551 1318
4cae9a20
JS
1319 // If it couldn't set the focus now, there's
1320 // no point in trying again.
ffd84c94 1321 m_needsInputFocus = false;
ff6b424a 1322 }
58ec2255 1323 g_GettingFocus = NULL;
83df96d6
JS
1324}
1325
83df96d6 1326// ----------------------------------------------------------------------------
77ffb593 1327// function which maintain the global hash table mapping Widgets to wxWidgets
83df96d6
JS
1328// ----------------------------------------------------------------------------
1329
b8033a5d 1330static bool DoAddWindowToTable(wxWindowHash *hash, Window w, wxWindow *win)
83df96d6 1331{
b8033a5d 1332 if ( !hash->insert(wxWindowHash::value_type(w, win)).second )
83df96d6 1333 {
b8033a5d
VZ
1334 wxLogDebug( wxT("Widget table clash: new widget is 0x%08x, %s"),
1335 (unsigned int)w, win->GetClassInfo()->GetClassName());
ffd84c94 1336 return false;
83df96d6
JS
1337 }
1338
2b5f62a0
VZ
1339 wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x <-> window %p (%s)"),
1340 (unsigned int) w, win, win->GetClassInfo()->GetClassName());
83df96d6 1341
ffd84c94 1342 return true;
83df96d6
JS
1343}
1344
b8033a5d 1345static inline wxWindow *DoGetWindowFromTable(wxWindowHash *hash, Window w)
83df96d6 1346{
b8033a5d
VZ
1347 wxWindowHash::iterator i = hash->find(w);
1348 return i == hash->end() ? NULL : i->second;
83df96d6
JS
1349}
1350
b8033a5d 1351static inline void DoDeleteWindowFromTable(wxWindowHash *hash, Window w)
83df96d6 1352{
b8033a5d
VZ
1353 wxLogTrace( wxT("widget"), wxT("XWindow 0x%08x deleted"), (unsigned int) w);
1354
1355 hash->erase(w);
83df96d6
JS
1356}
1357
1358// ----------------------------------------------------------------------------
b8033a5d 1359// public wrappers
83df96d6
JS
1360// ----------------------------------------------------------------------------
1361
b8033a5d 1362bool wxAddWindowToTable(Window w, wxWindow *win)
ab6b6b15 1363{
b8033a5d
VZ
1364 return DoAddWindowToTable(wxWidgetHashTable, w, win);
1365}
ab6b6b15 1366
b8033a5d
VZ
1367wxWindow *wxGetWindowFromTable(Window w)
1368{
1369 return DoGetWindowFromTable(wxWidgetHashTable, w);
1370}
ab6b6b15 1371
b8033a5d
VZ
1372void wxDeleteWindowFromTable(Window w)
1373{
1374 DoDeleteWindowFromTable(wxWidgetHashTable, w);
1375}
83df96d6 1376
b8033a5d
VZ
1377bool wxAddClientWindowToTable(Window w, wxWindow *win)
1378{
1379 return DoAddWindowToTable(wxClientWidgetHashTable, w, win);
ab6b6b15
RR
1380}
1381
1382wxWindow *wxGetClientWindowFromTable(Window w)
83df96d6 1383{
b8033a5d 1384 return DoGetWindowFromTable(wxClientWidgetHashTable, w);
83df96d6
JS
1385}
1386
ab6b6b15 1387void wxDeleteClientWindowFromTable(Window w)
83df96d6 1388{
b8033a5d 1389 DoDeleteWindowFromTable(wxClientWidgetHashTable, w);
83df96d6
JS
1390}
1391
ab6b6b15
RR
1392// ----------------------------------------------------------------------------
1393// X11-specific accessors
1394// ----------------------------------------------------------------------------
1395
bc797f4c 1396WXWindow wxWindowX11::GetMainWindow() const
83df96d6 1397{
ab6b6b15
RR
1398 return m_mainWindow;
1399}
1400
f41bc3e3 1401WXWindow wxWindowX11::GetClientAreaWindow() const
ab6b6b15
RR
1402{
1403 return m_clientWindow;
83df96d6
JS
1404}
1405
83df96d6
JS
1406// ----------------------------------------------------------------------------
1407// TranslateXXXEvent() functions
1408// ----------------------------------------------------------------------------
1409
1b0fb34b 1410bool wxTranslateMouseEvent(wxMouseEvent& wxevent, wxWindow *win, Window window, XEvent *xevent)
83df96d6 1411{
461e93f9 1412 switch (XEventGetType(xevent))
83df96d6 1413 {
1b0fb34b
JS
1414 case EnterNotify:
1415 case LeaveNotify:
83df96d6
JS
1416 case ButtonPress:
1417 case ButtonRelease:
1418 case MotionNotify:
1419 {
1420 wxEventType eventType = wxEVT_NULL;
1421
461e93f9 1422 if (XEventGetType(xevent) == EnterNotify)
83df96d6 1423 {
1b0fb34b
JS
1424 //if (local_event.xcrossing.mode!=NotifyNormal)
1425 // return ; // Ignore grab events
1426 eventType = wxEVT_ENTER_WINDOW;
1427 // canvas->GetEventHandler()->OnSetFocus();
1428 }
461e93f9 1429 else if (XEventGetType(xevent) == LeaveNotify)
1b0fb34b
JS
1430 {
1431 //if (local_event.xcrossingr.mode!=NotifyNormal)
1432 // return ; // Ignore grab events
1433 eventType = wxEVT_LEAVE_WINDOW;
1434 // canvas->GetEventHandler()->OnKillFocus();
83df96d6 1435 }
461e93f9 1436 else if (XEventGetType(xevent) == MotionNotify)
83df96d6
JS
1437 {
1438 eventType = wxEVT_MOTION;
1439 }
461e93f9 1440 else if (XEventGetType(xevent) == ButtonPress)
83df96d6 1441 {
461e93f9 1442 wxevent.SetTimestamp(XButtonEventGetTime(xevent));
83df96d6 1443 int button = 0;
461e93f9 1444 if (XButtonEventLChanged(xevent))
83df96d6
JS
1445 {
1446 eventType = wxEVT_LEFT_DOWN;
83df96d6
JS
1447 button = 1;
1448 }
461e93f9 1449 else if (XButtonEventMChanged(xevent))
83df96d6
JS
1450 {
1451 eventType = wxEVT_MIDDLE_DOWN;
83df96d6
JS
1452 button = 2;
1453 }
461e93f9 1454 else if (XButtonEventRChanged(xevent))
83df96d6
JS
1455 {
1456 eventType = wxEVT_RIGHT_DOWN;
83df96d6
JS
1457 button = 3;
1458 }
1459
1460 // check for a double click
1b0fb34b 1461 // TODO: where can we get this value from?
b513212d 1462 //long dclickTime = XtGetMultiClickTime(wxGlobalDisplay());
7266b672 1463 long dclickTime = 200;
83df96d6
JS
1464 long ts = wxevent.GetTimestamp();
1465
1466 int buttonLast = win->GetLastClickedButton();
1467 long lastTS = win->GetLastClickTime();
1468 if ( buttonLast && buttonLast == button && (ts - lastTS) < dclickTime )
1469 {
1470 // I have a dclick
1471 win->SetLastClick(0, ts);
1472 if ( eventType == wxEVT_LEFT_DOWN )
1473 eventType = wxEVT_LEFT_DCLICK;
1474 else if ( eventType == wxEVT_MIDDLE_DOWN )
1475 eventType = wxEVT_MIDDLE_DCLICK;
1476 else if ( eventType == wxEVT_RIGHT_DOWN )
1477 eventType = wxEVT_RIGHT_DCLICK;
1478 }
1479 else
1480 {
1481 // not fast enough or different button
1482 win->SetLastClick(button, ts);
1483 }
1484 }
461e93f9 1485 else if (XEventGetType(xevent) == ButtonRelease)
83df96d6 1486 {
461e93f9 1487 if (XButtonEventLChanged(xevent))
83df96d6
JS
1488 {
1489 eventType = wxEVT_LEFT_UP;
83df96d6 1490 }
461e93f9 1491 else if (XButtonEventMChanged(xevent))
83df96d6
JS
1492 {
1493 eventType = wxEVT_MIDDLE_UP;
83df96d6 1494 }
461e93f9 1495 else if (XButtonEventRChanged(xevent))
83df96d6
JS
1496 {
1497 eventType = wxEVT_RIGHT_UP;
83df96d6 1498 }
ffd84c94 1499 else return false;
83df96d6
JS
1500 }
1501 else
1502 {
ffd84c94 1503 return false;
83df96d6
JS
1504 }
1505
1506 wxevent.SetEventType(eventType);
1507
461e93f9
JS
1508 wxevent.m_x = XButtonEventGetX(xevent);
1509 wxevent.m_y = XButtonEventGetY(xevent);
83df96d6
JS
1510
1511 wxevent.m_leftDown = ((eventType == wxEVT_LEFT_DOWN)
461e93f9 1512 || (XButtonEventLIsDown(xevent)
83df96d6
JS
1513 && (eventType != wxEVT_LEFT_UP)));
1514 wxevent.m_middleDown = ((eventType == wxEVT_MIDDLE_DOWN)
461e93f9 1515 || (XButtonEventMIsDown(xevent)
83df96d6
JS
1516 && (eventType != wxEVT_MIDDLE_UP)));
1517 wxevent.m_rightDown = ((eventType == wxEVT_RIGHT_DOWN)
461e93f9 1518 || (XButtonEventRIsDown (xevent)
83df96d6
JS
1519 && (eventType != wxEVT_RIGHT_UP)));
1520
461e93f9
JS
1521 wxevent.m_shiftDown = XButtonEventShiftIsDown(xevent);
1522 wxevent.m_controlDown = XButtonEventCtrlIsDown(xevent);
1523 wxevent.m_altDown = XButtonEventAltIsDown(xevent);
1524 wxevent.m_metaDown = XButtonEventMetaIsDown(xevent);
83df96d6
JS
1525
1526 wxevent.SetId(win->GetId());
1527 wxevent.SetEventObject(win);
1528
ffd84c94 1529 return true;
83df96d6
JS
1530 }
1531 }
ffd84c94 1532 return false;
83df96d6
JS
1533}
1534
2b5f62a0 1535bool wxTranslateKeyEvent(wxKeyEvent& wxevent, wxWindow *win, Window WXUNUSED(win), XEvent *xevent, bool isAscii)
83df96d6 1536{
461e93f9 1537 switch (XEventGetType(xevent))
83df96d6
JS
1538 {
1539 case KeyPress:
1540 case KeyRelease:
1541 {
1542 char buf[20];
1543
1544 KeySym keySym;
83df96d6
JS
1545 (void) XLookupString ((XKeyEvent *) xevent, buf, 20, &keySym, NULL);
1546 int id = wxCharCodeXToWX (keySym);
2b5f62a0
VZ
1547 // id may be WXK_xxx code - these are outside ASCII range, so we
1548 // can't just use toupper() on id.
1549 // Only change this if we want the raw key that was pressed,
1550 // and don't change it if we want an ASCII value.
1551 if (!isAscii && (id >= 'a' && id <= 'z'))
1552 {
1553 id = id + 'A' - 'a';
1554 }
83df96d6 1555
461e93f9
JS
1556 wxevent.m_shiftDown = XKeyEventShiftIsDown(xevent);
1557 wxevent.m_controlDown = XKeyEventCtrlIsDown(xevent);
1558 wxevent.m_altDown = XKeyEventAltIsDown(xevent);
1559 wxevent.m_metaDown = XKeyEventMetaIsDown(xevent);
83df96d6 1560 wxevent.SetEventObject(win);
2b5f62a0 1561 wxevent.m_keyCode = id;
461e93f9 1562 wxevent.SetTimestamp(XKeyEventGetTime(xevent));
83df96d6 1563
461e93f9
JS
1564 wxevent.m_x = XKeyEventGetX(xevent);
1565 wxevent.m_y = XKeyEventGetY(xevent);
83df96d6 1566
2b5f62a0 1567 return id > -1;
83df96d6
JS
1568 }
1569 default:
1570 break;
1571 }
ffd84c94 1572 return false;
83df96d6
JS
1573}
1574
1575// ----------------------------------------------------------------------------
1576// Colour stuff
1577// ----------------------------------------------------------------------------
1578
bc797f4c 1579bool wxWindowX11::SetBackgroundColour(const wxColour& col)
83df96d6 1580{
56cb684a 1581 wxWindowBase::SetBackgroundColour(col);
83df96d6 1582
3cd0b8c5
RR
1583 Display *xdisplay = (Display*) wxGlobalDisplay();
1584 int xscreen = DefaultScreen( xdisplay );
1585 Colormap cm = DefaultColormap( xdisplay, xscreen );
1586
ba696cfa 1587 m_backgroundColour.CalcPixel( (WXColormap) cm );
7de59551 1588
c2c0dabf
RR
1589 // We don't set the background colour as we paint
1590 // the background ourselves.
1591 // XSetWindowBackground( xdisplay, (Window) m_clientWindow, m_backgroundColour.GetPixel() );
7de59551 1592
ffd84c94 1593 return true;
83df96d6
JS
1594}
1595
bc797f4c 1596bool wxWindowX11::SetForegroundColour(const wxColour& col)
83df96d6
JS
1597{
1598 if ( !wxWindowBase::SetForegroundColour(col) )
ffd84c94 1599 return false;
83df96d6 1600
ffd84c94 1601 return true;
83df96d6
JS
1602}
1603
83df96d6
JS
1604// ----------------------------------------------------------------------------
1605// global functions
1606// ----------------------------------------------------------------------------
1607
1608wxWindow *wxGetActiveWindow()
1609{
1610 // TODO
54385bdb 1611 wxFAIL_MSG(wxT("Not implemented"));
83df96d6
JS
1612 return NULL;
1613}
1614
1615/* static */
1616wxWindow *wxWindowBase::GetCapture()
1617{
1618 return (wxWindow *)g_captureWindow;
1619}
1620
1621
1622// Find the wxWindow at the current mouse position, returning the mouse
1623// position.
1624wxWindow* wxFindWindowAtPointer(wxPoint& pt)
1625{
1626 return wxFindWindowAtPoint(wxGetMousePosition());
1627}
1628
1629// Get the current mouse position.
1630wxPoint wxGetMousePosition()
1631{
461e93f9
JS
1632#if wxUSE_NANOX
1633 /* TODO */
1634 return wxPoint(0, 0);
1635#else
b513212d 1636 Display *display = wxGlobalDisplay();
83df96d6
JS
1637 Window rootWindow = RootWindowOfScreen (DefaultScreenOfDisplay(display));
1638 Window rootReturn, childReturn;
1639 int rootX, rootY, winX, winY;
1640 unsigned int maskReturn;
1641
1642 XQueryPointer (display,
2b5f62a0
VZ
1643 rootWindow,
1644 &rootReturn,
83df96d6
JS
1645 &childReturn,
1646 &rootX, &rootY, &winX, &winY, &maskReturn);
1647 return wxPoint(rootX, rootY);
461e93f9 1648#endif
83df96d6
JS
1649}
1650
1651
1652// ----------------------------------------------------------------------------
1653// wxNoOptimize: switch off size optimization
1654// ----------------------------------------------------------------------------
1655
1656int wxNoOptimize::ms_count = 0;
1657
c2c0dabf
RR
1658
1659// ----------------------------------------------------------------------------
1660// wxDCModule
1661// ----------------------------------------------------------------------------
1662
1663class wxWinModule : public wxModule
1664{
1665public:
1666 bool OnInit();
1667 void OnExit();
1668
1669private:
1670 DECLARE_DYNAMIC_CLASS(wxWinModule)
1671};
1672
1673IMPLEMENT_DYNAMIC_CLASS(wxWinModule, wxModule)
1674
1675bool wxWinModule::OnInit()
1676{
1677 Display *xdisplay = wxGlobalDisplay();
1678 int xscreen = DefaultScreen( xdisplay );
1679 Window xroot = RootWindow( xdisplay, xscreen );
1680 g_eraseGC = XCreateGC( xdisplay, xroot, 0, NULL );
1681 XSetFillStyle( xdisplay, g_eraseGC, FillSolid );
7de59551 1682
ffd84c94 1683 return true;
c2c0dabf
RR
1684}
1685
1686void wxWinModule::OnExit()
1687{
1688 Display *xdisplay = wxGlobalDisplay();
1689 XFreeGC( xdisplay, g_eraseGC );
1690}