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