summaryrefslogtreecommitdiffstats
path: root/src/kernel/qwidget_x11.cpp
diff options
context:
space:
mode:
authorTimothy Pearson <[email protected]>2011-11-08 12:31:36 -0600
committerTimothy Pearson <[email protected]>2011-11-08 12:31:36 -0600
commitd796c9dd933ab96ec83b9a634feedd5d32e1ba3f (patch)
tree6e3dcca4f77e20ec8966c666aac7c35bd4704053 /src/kernel/qwidget_x11.cpp
downloadtqt3-d796c9dd933ab96ec83b9a634feedd5d32e1ba3f.tar.gz
tqt3-d796c9dd933ab96ec83b9a634feedd5d32e1ba3f.zip
Test conversion to TQt3 from Qt3 8c6fc1f8e35fd264dd01c582ca5e7549b32ab731
Diffstat (limited to 'src/kernel/qwidget_x11.cpp')
-rw-r--r--src/kernel/qwidget_x11.cpp3039
1 files changed, 3039 insertions, 0 deletions
diff --git a/src/kernel/qwidget_x11.cpp b/src/kernel/qwidget_x11.cpp
new file mode 100644
index 000000000..1ce4d3ba7
--- /dev/null
+++ b/src/kernel/qwidget_x11.cpp
@@ -0,0 +1,3039 @@
+/****************************************************************************
+**
+** Implementation of TQWidget and TQWindow classes for X11
+**
+** Created : 931031
+**
+** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
+**
+** This file is part of the kernel module of the TQt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free TQt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing retquirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at [email protected].
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.TQPL
+** included in the packaging of this file. Licensees holding valid TQt
+** Commercial licenses may use this file in accordance with the TQt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+#include "qapplication.h"
+#include "qapplication_p.h"
+#include "qnamespace.h"
+#include "qpaintdevicemetrics.h"
+#include "qpainter.h"
+#include "qbitmap.h"
+#include "qobjectlist.h"
+#include "qlayout.h"
+#include "qtextcodec.h"
+#include "qdatetime.h"
+#include "qcursor.h"
+#include "qt_x11_p.h"
+#include <stdlib.h>
+
+// NOT REVISED
+
+// defined in qapplication_x11.cpp
+extern Window qt_x11_wm_client_leader;
+extern void qt_x11_create_wm_client_leader();
+
+// defined in qapplication_x11.cpp
+void qt_insert_sip( TQWidget*, int, int );
+int qt_sip_count( TQWidget* );
+bool qt_wstate_iconified( WId );
+void qt_updated_rootinfo();
+
+#ifndef QT_NO_IM
+#include "qinputcontext.h"
+#include "qinputcontextfactory.h"
+#endif
+
+// Paint event clipping magic
+extern void qt_set_paintevent_clipping( TQPaintDevice* dev, const TQRegion& region);
+extern void qt_clear_paintevent_clipping();
+
+extern bool qt_dnd_enable( TQWidget* w, bool on );
+extern bool qt_nograb();
+
+// defined in qapplication_x11.cpp
+extern void qt_deferred_map_add( TQWidget* );
+extern void qt_deferred_map_take( TQWidget* );
+extern bool qt_deferred_map_contains(TQWidget *);
+
+static TQWidget *mouseGrb = 0;
+static TQWidget *keyboardGrb = 0;
+
+// defined in qapplication_x11.cpp
+extern Time qt_x_time;
+extern Time qt_x_user_time;
+
+#ifndef QT_NO_XSYNC
+extern Atom qt_net_wm_sync_request_counter;
+extern Atom qt_net_wm_sync_request;
+extern bool qt_use_xsync;
+#endif
+
+// defined in qfont_x11.cpp
+extern bool qt_has_xft;
+
+int qt_x11_create_desktop_on_screen = -1;
+
+/*****************************************************************************
+ TQWidget member functions
+ *****************************************************************************/
+
+// defined in qapplication_x11.cpp
+extern Atom qt_wm_state;
+extern Atom qt_wm_change_state;
+extern Atom qt_wm_delete_window;
+extern Atom qt_wm_take_focus;
+extern Atom qt_wm_client_leader;
+extern Atom qt_window_role;
+extern Atom qt_sm_client_id;
+extern Atom qt_utf8_string;
+extern Atom qt_net_wm_context_help;
+extern Atom qt_net_wm_ping;
+extern Atom qt_xa_motif_wm_hints;
+extern Atom qt_net_wm_name;
+extern Atom qt_net_wm_icon_name;
+extern Atom qt_net_wm_state;
+extern Atom qt_net_wm_state_modal;
+extern Atom qt_net_wm_state_max_v;
+extern Atom qt_net_wm_state_max_h;
+extern Atom qt_net_wm_state_fullscreen;
+extern Atom qt_net_wm_state_above;
+extern Atom qt_net_wm_state_stays_on_top;
+extern Atom qt_net_wm_window_type;
+extern Atom qt_net_wm_window_type_normal;
+extern Atom qt_net_wm_window_type_dialog;
+extern Atom qt_net_wm_window_type_toolbar;
+extern Atom qt_net_wm_window_type_menu;
+extern Atom qt_net_wm_window_type_utility;
+extern Atom qt_net_wm_window_type_splash;
+extern Atom qt_net_wm_window_type_override;
+extern Atom qt_net_wm_window_type_dropdown_menu;
+extern Atom qt_net_wm_window_type_popup_menu;
+extern Atom qt_net_wm_window_type_combo;
+extern Atom qt_net_wm_window_type_dnd;
+extern Atom qt_net_wm_window_type_tooltip;
+extern Atom qt_net_wm_pid;
+extern Atom qt_net_wm_user_time;
+extern Atom qt_enlightenment_desktop;
+extern Atom qt_net_virtual_roots;
+extern bool qt_broken_wm;
+
+// defined in qapplication_x11.cpp
+extern bool qt_net_supports(Atom);
+extern unsigned long *qt_net_virtual_root_list;
+
+#if defined (QT_TABLET_SUPPORT)
+extern XDevice *devStylus;
+extern XDevice *devEraser;
+extern XEventClass event_list_stylus[7];
+extern XEventClass event_list_eraser[7];
+extern int qt_curr_events_stylus;
+extern int qt_curr_events_eraser;
+#endif
+
+const uint stdWidgetEventMask = // X event mask
+ (uint)(
+ KeyPressMask | KeyReleaseMask |
+ ButtonPressMask | ButtonReleaseMask |
+ KeymapStateMask |
+ ButtonMotionMask |
+ EnterWindowMask | LeaveWindowMask |
+ FocusChangeMask |
+ ExposureMask |
+ PropertyChangeMask |
+ StructureNotifyMask
+ );
+
+const uint stdDesktopEventMask = // X event mask
+ (uint)(
+ KeymapStateMask |
+ EnterWindowMask | LeaveWindowMask |
+ PropertyChangeMask
+ );
+
+
+/*
+ The qt_ functions below are implemented in qwidgetcreate_x11.cpp.
+*/
+
+Window qt_XCreateWindow( const TQWidget *creator,
+ Display *display, Window parent,
+ int x, int y, uint w, uint h,
+ int borderwidth, int depth,
+ uint windowclass, Visual *visual,
+ ulong valuemask, XSetWindowAttributes *attributes );
+Window qt_XCreateSimpleWindow( const TQWidget *creator,
+ Display *display, Window parent,
+ int x, int y, uint w, uint h, int borderwidth,
+ ulong border, ulong background );
+void qt_XDestroyWindow( const TQWidget *destroyer,
+ Display *display, Window window );
+
+Q_EXPORT void qt_x11_enforce_cursor( TQWidget * w )
+{
+ if ( w->testWState( TQt::WState_OwnCursor ) ) {
+ TQCursor * oc = TQApplication::overrideCursor();
+ if ( oc ) {
+ XDefineCursor( w->x11Display(), w->winId(), oc->handle() );
+ } else if ( w->isEnabled() ) {
+ XDefineCursor( w->x11Display(), w->winId(), w->cursor().handle() );
+ } else {
+ // enforce the windows behavior of clearing the cursor on
+ // disabled widgets
+ XDefineCursor( w->x11Display(), w->winId(), None );
+ }
+ } else {
+ XDefineCursor( w->x11Display(), w->winId(), None );
+ }
+}
+
+Q_EXPORT void qt_wait_for_window_manager( TQWidget* w )
+{
+ TQApplication::flushX();
+ XEvent ev;
+ TQTime t;
+ t.start();
+ while ( !XCheckTypedWindowEvent( w->x11Display(), w->winId(), ReparentNotify, &ev ) ) {
+ if ( XCheckTypedWindowEvent( w->x11Display(), w->winId(), MapNotify, &ev ) )
+ break;
+ if ( t.elapsed() > 500 )
+ return; // give up, no event available
+ qApp->syncX(); // non-busy wait
+ }
+ qApp->x11ProcessEvent( &ev );
+ if ( XCheckTypedWindowEvent( w->x11Display(), w->winId(), ConfigureNotify, &ev ) )
+ qApp->x11ProcessEvent( &ev );
+}
+
+static void qt_net_change_wm_state(const TQWidget* w, bool set, Atom one, Atom two = 0)
+{
+ if (w->isShown()) {
+ // managed by WM
+ XEvent e;
+ e.xclient.type = ClientMessage;
+ e.xclient.message_type = qt_net_wm_state;
+ e.xclient.display = w->x11Display();
+ e.xclient.window = w->winId();
+ e.xclient.format = 32;
+ e.xclient.data.l[ 0 ] = set ? 1 : 0;
+ e.xclient.data.l[ 1 ] = one;
+ e.xclient.data.l[ 2 ] = two;
+ e.xclient.data.l[ 3 ] = 0;
+ e.xclient.data.l[ 4 ] = 0;
+ XSendEvent(w->x11Display(), RootWindow(w->x11Display(), w->x11Screen()),
+ False, (SubstructureNotifyMask|SubstructureRedirectMask), &e);
+ } else {
+ Atom ret;
+ int format = 0, status;
+ unsigned char *data = 0;
+ unsigned long nitems = 0, after = 0;
+ Atom *old_states = 0;
+ status = XGetWindowProperty(w->x11Display(), w->winId(),
+ qt_net_wm_state, 0, 1024, False,
+ XA_ATOM, &ret, &format, &nitems,
+ &after, &data);
+ if (status == Success && ret == XA_ATOM && format == 32 && nitems > 0)
+ old_states = (Atom *) data;
+ else
+ nitems = 0;
+
+ Atom *new_states = new Atom[nitems + 2];
+ int i, j = 0;
+ for (i = 0; i < (int)nitems; ++i) {
+ if (old_states[i] && old_states[i] != one && old_states[i] != two)
+ new_states[j++] = old_states[i];
+ }
+
+ if (set) {
+ if (one) new_states[j++] = one;
+ if (two) new_states[j++] = two;
+ }
+
+ if (j)
+ XChangeProperty(w->x11Display(), w->winId(), qt_net_wm_state, XA_ATOM, 32,
+ PropModeReplace, (uchar *) new_states, j);
+ else
+ XDeleteProperty(w->x11Display(), w->winId(), qt_net_wm_state);
+
+ delete [] new_states;
+ if (data) XFree(data);
+ }
+}
+
+/*!
+ Creates a new widget window if \a window is 0, otherwise sets the
+ widget's window to \a window.
+
+ Initializes the window (sets the geometry etc.) if \a
+ initializeWindow is TRUE. If \a initializeWindow is FALSE, no
+ initialization is performed. This parameter only makes sense if \a
+ window is a valid window.
+
+ Destroys the old window if \a destroyOldWindow is TRUE. If \a
+ destroyOldWindow is FALSE, you are responsible for destroying the
+ window yourself (using platform native code).
+
+ The TQWidget constructor calls create(0,TRUE,TRUE) to create a
+ window for this widget.
+*/
+
+void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow)
+{
+ if ( testWState(WState_Created) && window == 0 )
+ return;
+
+ // set created flag
+ setWState( WState_Created );
+
+ bool popup = testWFlags(WType_Popup);
+ bool dialog = testWFlags(WType_Dialog);
+ bool desktop = testWFlags(WType_Desktop);
+
+ // top-level widget
+ if ( !parentWidget() || parentWidget()->isDesktop() )
+ setWFlags( WType_TopLevel );
+
+ // these are top-level, too
+ if ( dialog || popup || desktop || testWFlags(WStyle_Splash))
+ setWFlags( WType_TopLevel );
+
+ // a popup stays on top
+ if ( popup )
+ setWFlags(WStyle_StaysOnTop);
+
+ bool topLevel = testWFlags(WType_TopLevel);
+ Window parentw, destroyw = 0;
+ WId id;
+
+ // always initialize
+ if ( !window )
+ initializeWindow = TRUE;
+
+ if ( desktop &&
+ qt_x11_create_desktop_on_screen >= 0 &&
+ qt_x11_create_desktop_on_screen != x11Screen() ) {
+ // desktop on a certain screen other than the default requested
+ TQPaintDeviceX11Data* xd = getX11Data( TRUE );
+ xd->x_screen = qt_x11_create_desktop_on_screen;
+ xd->x_depth = TQPaintDevice::x11AppDepth( xd->x_screen );
+ xd->x_cells = TQPaintDevice::x11AppCells( xd->x_screen );
+ xd->x_colormap = TQPaintDevice::x11AppColormap( xd->x_screen );
+ xd->x_defcolormap = TQPaintDevice::x11AppDefaultColormap( xd->x_screen );
+ xd->x_visual = TQPaintDevice::x11AppVisual( xd->x_screen );
+ xd->x_defvisual = TQPaintDevice::x11AppDefaultVisual( xd->x_screen );
+ setX11Data( xd );
+ } else if ( parentWidget() && parentWidget()->x11Screen() != x11Screen() ) {
+ // if we have a parent widget, move to its screen if necessary
+ TQPaintDeviceX11Data* xd = getX11Data( TRUE );
+ xd->x_screen = parentWidget()->x11Screen();
+ xd->x_depth = TQPaintDevice::x11AppDepth( xd->x_screen );
+ xd->x_cells = TQPaintDevice::x11AppCells( xd->x_screen );
+ xd->x_colormap = TQPaintDevice::x11AppColormap( xd->x_screen );
+ xd->x_defcolormap = TQPaintDevice::x11AppDefaultColormap( xd->x_screen );
+ xd->x_visual = TQPaintDevice::x11AppVisual( xd->x_screen );
+ xd->x_defvisual = TQPaintDevice::x11AppDefaultVisual( xd->x_screen );
+ setX11Data( xd );
+ }
+
+ //get display, screen number, root window and desktop geometry for
+ //the current screen
+ Display *dpy = x11Display();
+ int scr = x11Screen();
+ Window root_win = RootWindow( dpy, scr );
+ int sw = DisplayWidth(dpy,scr);
+ int sh = DisplayHeight(dpy,scr);
+
+ if ( desktop ) { // desktop widget
+ dialog = popup = FALSE; // force these flags off
+ crect.setRect( 0, 0, sw, sh );
+ } else if ( topLevel ) { // calc pos/size from screen
+ crect.setRect( sw/4, 3*sh/10, sw/2, 4*sh/10 );
+ } else { // child widget
+ crect.setRect( 0, 0, 100, 30 );
+ }
+
+ parentw = topLevel ? root_win : parentWidget()->winId();
+
+ XSetWindowAttributes wsa;
+
+ if ( window ) { // override the old window
+ if ( destroyOldWindow )
+ destroyw = winid;
+ id = window;
+ setWinId( window );
+ XWindowAttributes a;
+ XGetWindowAttributes( dpy, window, &a );
+ crect.setRect( a.x, a.y, a.width, a.height );
+
+ if ( a.map_state == IsUnmapped )
+ clearWState( WState_Visible );
+ else
+ setWState( WState_Visible );
+
+ TQPaintDeviceX11Data* xd = getX11Data( TRUE );
+
+ // find which screen the window is on...
+ xd->x_screen = TQPaintDevice::x11AppScreen(); // by default, use the default :)
+ int i;
+ for ( i = 0; i < ScreenCount( dpy ); i++ ) {
+ if ( RootWindow( dpy, i ) == a.root ) {
+ xd->x_screen = i;
+ break;
+ }
+ }
+
+ xd->x_depth = a.depth;
+ xd->x_cells = DisplayCells( dpy, xd->x_screen );
+ xd->x_visual = a.visual;
+ xd->x_defvisual = ( XVisualIDFromVisual( a.visual ) ==
+ XVisualIDFromVisual( (Visual*)x11AppVisual(x11Screen()) ) );
+ xd->x_colormap = a.colormap;
+ xd->x_defcolormap = ( a.colormap == x11AppColormap( x11Screen() ) );
+ setX11Data( xd );
+ } else if ( desktop ) { // desktop widget
+ id = (WId)parentw; // id = root window
+ TQWidget *otherDesktop = find( id ); // is there another desktop?
+ if ( otherDesktop && otherDesktop->testWFlags(WPaintDesktop) ) {
+ otherDesktop->setWinId( 0 ); // remove id from widget mapper
+ setWinId( id ); // make sure otherDesktop is
+ otherDesktop->setWinId( id ); // found first
+ } else {
+ setWinId( id );
+ }
+ } else {
+ if ( x11DefaultVisual() && x11DefaultColormap() ) {
+ id = (WId)qt_XCreateSimpleWindow( this, dpy, parentw,
+ crect.left(), crect.top(),
+ crect.width(), crect.height(),
+ 0,
+ black.pixel(x11Screen()),
+ bg_col.pixel(x11Screen()) );
+ } else {
+ wsa.background_pixel = bg_col.pixel(x11Screen());
+ wsa.border_pixel = black.pixel(x11Screen());
+ wsa.colormap = (Colormap)x11Colormap();
+ id = (WId)qt_XCreateWindow( this, dpy, parentw,
+ crect.left(), crect.top(),
+ crect.width(), crect.height(),
+ 0, x11Depth(), InputOutput,
+ (Visual*)x11Visual(),
+ CWBackPixel|CWBorderPixel|CWColormap,
+ &wsa );
+ }
+
+ setWinId( id ); // set widget id/handle + hd
+ }
+
+#ifndef QT_NO_XFTFREETYPE
+ if (rendhd) {
+ XftDrawDestroy( (XftDraw *) rendhd );
+ rendhd = 0;
+ }
+
+ if ( qt_has_xft )
+ rendhd = (HANDLE) XftDrawCreate( dpy, id, (Visual *) x11Visual(),
+ x11Colormap() );
+#endif // QT_NO_XFTFREETYPE
+
+ // NET window states
+ long net_winstates[6] = { 0, 0, 0, 0, 0, 0 };
+ int curr_winstate = 0;
+
+ struct {
+ ulong flags, functions, decorations;
+ long input_mode;
+ ulong status;
+ } mwmhints;
+
+ mwmhints.flags = mwmhints.functions = 0L;
+ mwmhints.decorations = (1L << 0); // MWM_DECOR_ALL
+ mwmhints.input_mode = 0L;
+ mwmhints.status = 0L;
+
+ if (topLevel && ! (desktop || popup)) {
+ ulong wsa_mask = 0;
+
+ if ( testWFlags(WStyle_Splash) ) {
+ if (qt_net_supports(qt_net_wm_window_type_splash)) {
+ clearWFlags( WX11BypassWM );
+ } else {
+ setWFlags( WX11BypassWM | WStyle_Tool | WStyle_NoBorder );
+ }
+ }
+ if (testWFlags(WStyle_Customize)) {
+ mwmhints.decorations = 0L;
+ mwmhints.flags |= (1L << 1); // MWM_HINTS_DECORATIONS
+
+ if ( testWFlags( WStyle_NormalBorder | WStyle_DialogBorder ) ) {
+ mwmhints.decorations |= (1L << 1); // MWM_DECOR_BORDER
+ mwmhints.decorations |= (1L << 2); // MWM_DECOR_RESIZEH
+ }
+
+ if ( testWFlags( WStyle_Title ) )
+ mwmhints.decorations |= (1L << 3); // MWM_DECOR_TITLE
+
+ if ( testWFlags( WStyle_SysMenu ) )
+ mwmhints.decorations |= (1L << 4); // MWM_DECOR_MENU
+
+ if ( testWFlags( WStyle_Minimize ) )
+ mwmhints.decorations |= (1L << 5); // MWM_DECOR_MINIMIZE
+
+ if ( testWFlags( WStyle_Maximize ) )
+ mwmhints.decorations |= (1L << 6); // MWM_DECOR_MAXIMIZE
+
+ if (testWFlags(WStyle_Tool)) {
+ wsa.save_under = True;
+ wsa_mask |= CWSaveUnder;
+ }
+ } else if (testWFlags(WType_Dialog)) {
+ setWFlags(WStyle_NormalBorder | WStyle_Title |
+ WStyle_SysMenu | WStyle_ContextHelp);
+ } else {
+ setWFlags(WStyle_NormalBorder | WStyle_Title |
+ WStyle_MinMax | WStyle_SysMenu);
+
+ // maximized netwm state
+ if (testWFlags(WState_Maximized)) {
+ net_winstates[curr_winstate++] = qt_net_wm_state_max_v;
+ net_winstates[curr_winstate++] = qt_net_wm_state_max_h;
+ }
+ }
+
+ // stays on top
+ if (testWFlags(WStyle_StaysOnTop)) {
+ net_winstates[curr_winstate++] = qt_net_wm_state_above;
+ net_winstates[curr_winstate++] = qt_net_wm_state_stays_on_top;
+ }
+
+ if (testWFlags(WShowModal)) {
+ mwmhints.input_mode = 3L; // MWM_INPUT_FULL_APPLICATION_MODAL
+ mwmhints.flags |= (1L << 2); // MWM_HINTS_INPUT_MODE
+
+ net_winstates[curr_winstate++] = qt_net_wm_state_modal;
+ }
+
+ if ( testWFlags( WX11BypassWM ) ) {
+ wsa.override_redirect = True;
+ wsa_mask |= CWOverrideRedirect;
+ }
+
+ if ( wsa_mask && initializeWindow )
+ XChangeWindowAttributes( dpy, id, wsa_mask, &wsa );
+ } else {
+ if (! testWFlags(WStyle_Customize))
+ setWFlags(WStyle_NormalBorder | WStyle_Title |
+ WStyle_MinMax | WStyle_SysMenu);
+ }
+
+
+ if ( !initializeWindow ) {
+ // do no initialization
+ } else if ( popup ) { // popup widget
+ wsa.override_redirect = True;
+ wsa.save_under = True;
+ XChangeWindowAttributes( dpy, id, CWOverrideRedirect | CWSaveUnder,
+ &wsa );
+ x11SetWindowType();
+ } else if ( topLevel && !desktop ) { // top-level widget
+ TQWidget *p = parentWidget(); // real parent
+ if (p)
+ p = p->topLevelWidget();
+
+ if (dialog || testWFlags(WStyle_DialogBorder) || testWFlags(WStyle_Tool)) {
+ if ( p )
+ XSetTransientForHint( dpy, id, p->winId() );
+ else // application-modal
+ XSetTransientForHint( dpy, id, root_win );
+ }
+
+ // find the real client leader, i.e. a toplevel without parent
+ while ( p && p->parentWidget())
+ p = p->parentWidget()->topLevelWidget();
+
+ XSizeHints size_hints;
+ size_hints.flags = USSize | PSize | PWinGravity;
+ size_hints.x = crect.left();
+ size_hints.y = crect.top();
+ size_hints.width = crect.width();
+ size_hints.height = crect.height();
+ size_hints.win_gravity =
+ TQApplication::reverseLayout() ? NorthEastGravity : NorthWestGravity;
+
+ XWMHints wm_hints; // window manager hints
+ wm_hints.input = True;
+ wm_hints.initial_state = NormalState;
+ wm_hints.flags = InputHint | StateHint;
+ if ( !qt_x11_wm_client_leader )
+ qt_x11_create_wm_client_leader();
+
+ wm_hints.window_group = qt_x11_wm_client_leader;
+ wm_hints.flags |= WindowGroupHint;
+
+ XClassHint class_hint;
+ class_hint.res_name = (char *) qAppName(); // application name
+ class_hint.res_class = (char *) qAppClass(); // application class
+
+ XSetWMProperties( dpy, id, 0, 0, 0, 0, &size_hints, &wm_hints, &class_hint );
+
+ XResizeWindow( dpy, id, crect.width(), crect.height() );
+ XStoreName( dpy, id, qAppName() );
+ Atom protocols[5];
+ int n = 0;
+ protocols[n++] = qt_wm_delete_window; // support del window protocol
+ protocols[n++] = qt_wm_take_focus; // support take focus window protocol
+ protocols[n++] = qt_net_wm_ping; // support _NET_WM_PING protocol
+#ifndef QT_NO_XSYNC
+ protocols[n++] = qt_net_wm_sync_request;// support the _NET_WM_SYNC_RETQUEST protocol
+#endif
+ if ( testWFlags( WStyle_ContextHelp ) )
+ protocols[n++] = qt_net_wm_context_help;
+ XSetWMProtocols( dpy, id, protocols, n );
+
+ // set mwm hints
+ if ( mwmhints.flags != 0l )
+ XChangeProperty(dpy, id, qt_xa_motif_wm_hints, qt_xa_motif_wm_hints, 32,
+ PropModeReplace, (unsigned char *) &mwmhints, 5);
+ else
+ XDeleteProperty(dpy, id, qt_xa_motif_wm_hints);
+
+ x11SetWindowType();
+
+ // set _NET_WM_WINDOW_STATE
+ if (curr_winstate > 0)
+ XChangeProperty(dpy, id, qt_net_wm_state, XA_ATOM, 32, PropModeReplace,
+ (unsigned char *) net_winstates, curr_winstate);
+ else
+ XDeleteProperty(dpy, id, qt_net_wm_state);
+
+ // set _NET_WM_PID
+ long curr_pid = getpid();
+ XChangeProperty(dpy, id, qt_net_wm_pid, XA_CARDINAL, 32, PropModeReplace,
+ (unsigned char *) &curr_pid, 1);
+
+#ifndef QT_NO_XSYNC
+ // set _NET_WM_SYNC_COUNTER
+ createSyncCounter();
+ long counterVal = topData()->syncCounter;
+ XChangeProperty( dpy, id, qt_net_wm_sync_request_counter, XA_CARDINAL, 32, PropModeReplace,
+ (unsigned char*) &counterVal, 1);
+#endif
+
+ // when we create a toplevel widget, the frame strut should be dirty
+ fstrut_dirty = 1;
+
+ // declare the widget's object name as window role
+ XChangeProperty( dpy, id,
+ qt_window_role, XA_STRING, 8, PropModeReplace,
+ (unsigned char *)name(), qstrlen( name() ) );
+
+ // set client leader property
+ XChangeProperty( dpy, id, qt_wm_client_leader,
+ XA_WINDOW, 32, PropModeReplace,
+ (unsigned char *)&qt_x11_wm_client_leader, 1 );
+ } else {
+ // non-toplevel widgets don't have a frame, so no need to
+ // update the strut
+ fstrut_dirty = 0;
+ }
+
+ if ( initializeWindow ) {
+ // don't erase when resizing
+ wsa.bit_gravity =
+ TQApplication::reverseLayout() ? NorthEastGravity : NorthWestGravity;
+ XChangeWindowAttributes( dpy, id, CWBitGravity, &wsa );
+ }
+
+ setWState( WState_MouseTracking );
+ setMouseTracking( FALSE ); // also sets event mask
+ if ( desktop ) {
+ setWState( WState_Visible );
+ } else if ( topLevel ) { // set X cursor
+ setWState( WState_OwnCursor );
+ if ( initializeWindow )
+ qt_x11_enforce_cursor( this );
+ }
+
+ if ( destroyw )
+ qt_XDestroyWindow( this, dpy, destroyw );
+
+#if !defined(QT_NO_IM_EXTENSIONS)
+ ic = 0;
+#endif
+}
+
+
+/*!
+ Frees up window system resources. Destroys the widget window if \a
+ destroyWindow is TRUE.
+
+ destroy() calls itself recursively for all the child widgets,
+ passing \a destroySubWindows for the \a destroyWindow parameter.
+ To have more control over destruction of subwidgets, destroy
+ subwidgets selectively first.
+
+ This function is usually called from the TQWidget destructor.
+*/
+
+void TQWidget::destroy( bool destroyWindow, bool destroySubWindows )
+{
+ deactivateWidgetCleanup();
+ if ( testWState(WState_Created) ) {
+ clearWState( WState_Created );
+ if ( children() ) {
+ TQObjectListIt it(*children());
+ register TQObject *obj;
+ while ( (obj=it.current()) ) { // destroy all widget children
+ ++it;
+ if ( obj->isWidgetType() )
+ ((TQWidget*)obj)->destroy(destroySubWindows,
+ destroySubWindows);
+ }
+ }
+ if ( mouseGrb == this )
+ releaseMouse();
+ if ( keyboardGrb == this )
+ releaseKeyboard();
+ if ( isTopLevel() )
+ qt_deferred_map_take( this );
+ if ( testWFlags(WShowModal) ) // just be sure we leave modal
+ qt_leave_modal( this );
+ else if ( testWFlags(WType_Popup) )
+ qApp->closePopup( this );
+
+#ifndef QT_NO_XFTFREETYPE
+ if ( rendhd) {
+ if ( destroyWindow )
+ XftDrawDestroy( (XftDraw *) rendhd );
+ else
+ free( (void*) rendhd );
+ rendhd = 0;
+ }
+#endif // QT_NO_XFTFREETYPE
+
+ if ( testWFlags(WType_Desktop) ) {
+ if ( acceptDrops() )
+ qt_dnd_enable( this, FALSE );
+ } else {
+ if ( destroyWindow )
+ qt_XDestroyWindow( this, x11Display(), winid );
+ }
+#ifndef QT_NO_XSYNC
+ destroySyncCounter();
+#endif
+ setWinId( 0 );
+
+ extern void qPRCleanup( TQWidget *widget ); // from qapplication_x11.cpp
+ if ( testWState(WState_Reparented) )
+ qPRCleanup(this);
+
+ if( this == icHolderWidget() ) {
+ destroyInputContext();
+ } else {
+ // release previous focus information participating with
+ // preedit preservation of qic
+ TQInputContext *qic = getInputContext();
+ if ( qic )
+ qic->releaseComposingWidget( this );
+ }
+ }
+}
+
+void TQWidget::reparentSys( TQWidget *parent, WFlags f, const TQPoint &p, bool showIt )
+{
+ extern void qPRCreate( const TQWidget *, Window );
+
+ Display *dpy = x11Display();
+ TQCursor oldcurs;
+ bool setcurs = testWState(WState_OwnCursor);
+ if ( setcurs ) {
+ oldcurs = cursor();
+ unsetCursor();
+ }
+
+ // dnd unregister (we will register again below)
+ bool accept_drops = acceptDrops();
+ setAcceptDrops( FALSE );
+
+ // clear mouse tracking, re-enabled below
+ bool mouse_tracking = hasMouseTracking();
+ clearWState(WState_MouseTracking);
+
+ TQWidget* oldtlw = topLevelWidget();
+ TQWidget *oldparent = parentWidget();
+ WId old_winid = winid;
+ if ( testWFlags(WType_Desktop) )
+ old_winid = 0;
+ setWinId( 0 );
+
+ // hide and reparent our own window away. Otherwise we might get
+ // destroyed when emitting the child remove event below. See TQWorkspace.
+ XUnmapWindow( x11Display(), old_winid );
+ XReparentWindow( x11Display(), old_winid,
+ RootWindow( x11Display(), x11Screen() ), 0, 0 );
+
+ if ( this == icHolderWidget() ) {
+ // input contexts are sometimes associated with toplevel widgets, so
+ // we need destroy the context here. if we are reparenting back to
+ // toplevel, then we may have another context created, otherwise we
+ // will use our new ic holder's context
+ destroyInputContext();
+ }
+
+#ifndef QT_NO_XSYNC
+ destroySyncCounter();
+#endif
+
+ if ( isTopLevel() || !parent ) // we are toplevel, or reparenting to toplevel
+ topData()->parentWinId = 0;
+
+ if ( parent != parentObj ) {
+ if ( parentObj ) // remove from parent
+ parentObj->removeChild( this );
+ if ( parent ) // insert into new parent
+ parent->insertChild( this );
+ }
+ bool enable = isEnabled(); // remember status
+ FocusPolicy fp = focusPolicy();
+ TQSize s = size();
+ TQPixmap *bgp = (TQPixmap *)backgroundPixmap();
+ TQColor bgc = bg_col; // save colors
+ TQString capt= caption();
+ widget_flags = f;
+ clearWState( WState_Created | WState_Visible | WState_ForceHide );
+ create();
+ if ( isTopLevel() || (!parent || parent->isVisible() ) )
+ setWState( WState_ForceHide ); // new widgets do not show up in already visible parents
+
+ const TQObjectList *chlist = children();
+ if ( chlist ) { // reparent children
+ TQObjectList childList(*chlist);
+ TQObjectListIt it(childList); // iterate over copy
+ TQObject *obj;
+ while ( (obj=it.current()) ) {
+ if ( obj->isWidgetType() ) {
+ TQWidget *w = (TQWidget *)obj;
+ if ( !w->isTopLevel() ) {
+ XReparentWindow( x11Display(), w->winId(), winId(),
+ w->geometry().x(), w->geometry().y() );
+ } else if ( w->isPopup()
+ || w->testWFlags(WStyle_DialogBorder)
+ || w->testWFlags(WType_Dialog)
+ || w->testWFlags(WStyle_Tool) ) {
+ /*
+ when reparenting toplevel windows with toplevel-transient children,
+ we need to make sure that the window manager gets the updated
+ WM_TRANSIENT_FOR information... unfortunately, some window managers
+ don't handle changing WM_TRANSIENT_FOR before the toplevel window is
+ visible, so we unmap and remap all toplevel-transient children *after*
+ the toplevel parent has been mapped. thankfully, this is easy in TQt :)
+ */
+ XUnmapWindow(w->x11Display(), w->winId());
+ XSetTransientForHint(w->x11Display(), w->winId(), winId());
+ TQApplication::postEvent(w, new TQEvent(TQEvent::ShowWindowRequest));
+ }
+ }
+ ++it;
+ }
+ }
+ qPRCreate( this, old_winid );
+ if ( bgp )
+ XSetWindowBackgroundPixmap( dpy, winid, bgp->handle() );
+ else
+ XSetWindowBackground( dpy, winid, bgc.pixel(x11Screen()) );
+
+ if (isTopLevel()) {
+ // preserve maximized/fullscreen flags and the normal geometry
+ uint save_state = widget_state & (WState_Maximized | WState_FullScreen);
+ const TQRect r = topData()->normalGeometry;
+ setGeometry(p.x(), p.y(), s.width(), s.height());
+ widget_state |= save_state;
+ topData()->normalGeometry = r;
+ } else {
+ setGeometry(p.x(), p.y(), s.width(), s.height());
+ }
+
+ setEnabled( enable );
+ setFocusPolicy( fp );
+ if ( !capt.isNull() ) {
+ extra->topextra->caption = TQString::null;
+ setCaption( capt );
+ }
+ if ( showIt )
+ show();
+ if ( old_winid )
+ qt_XDestroyWindow( this, dpy, old_winid );
+ if ( setcurs )
+ setCursor(oldcurs);
+
+ reparentFocusWidgets( oldtlw );
+
+ // re-register dnd
+ if (oldparent)
+ oldparent->checkChildrenDnd();
+
+ if ( accept_drops )
+ setAcceptDrops( TRUE );
+ else {
+ checkChildrenDnd();
+ topData()->dnd = 0;
+ qt_dnd_enable(this, (extra && extra->children_use_dnd));
+ }
+
+ // re-enable mouse tracking
+ if (mouse_tracking)
+ setMouseTracking(mouse_tracking);
+}
+
+// Sets the EWMH (netwm) window type. Needed as a separate function
+// because create() may be too soon in some cases.
+void TQWidget::x11SetWindowType( X11WindowType type )
+{
+ // NET window types
+ long net_wintypes[7] = { 0, 0, 0, 0, 0, 0, 0 };
+ int curr_wintype = 0;
+ if( testWFlags(WType_Desktop))
+ return;
+ if( type == X11WindowTypeSelect ) {
+ if ( testWFlags(WStyle_Splash)) {
+ if (qt_net_supports(qt_net_wm_window_type_splash)) {
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_splash;
+ }
+ } else if (inherits("TQToolBar")) {
+ // toolbar netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_toolbar;
+ } else if (testWFlags(WStyle_Customize) && testWFlags(WStyle_Tool)) {
+ // utility netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_utility;
+ } else if (testWFlags(WType_Dialog)) {
+ // dialog netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_dialog;
+ }
+ } else if( type == X11WindowTypeCombo ) {
+ // combo netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_combo;
+ } else if( type == X11WindowTypeDND ) {
+ // dnd netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_dnd;
+ } else if( type == X11WindowTypeDropdown ) {
+ // dropdown netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_dropdown_menu;
+ } else if( type == X11WindowTypePopup ) {
+ // popup netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_popup_menu;
+ } else if( type == X11WindowTypeMenu ) {
+ // menu netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_menu;
+ } else if( type == X11WindowTypeTooltip ) {
+ // tooltip netwm type
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_tooltip;
+ }
+
+ // normal netwm type - default
+ net_wintypes[curr_wintype++] = qt_net_wm_window_type_normal;
+ // set _NET_WM_WINDOW_TYPE
+ if (curr_wintype > 0)
+ XChangeProperty(x11Display(), winId(), qt_net_wm_window_type, XA_ATOM, 32, PropModeReplace,
+ (unsigned char *) net_wintypes, curr_wintype);
+ else
+ XDeleteProperty(x11Display(), winId(), qt_net_wm_window_type);
+}
+
+void TQWidget::x11SetWindowTransient( TQWidget* parent )
+{
+ XSetTransientForHint( x11Display(), winId(), parent->winId());
+}
+
+/*!
+ Translates the widget coordinate \a pos to global screen
+ coordinates. For example, \c{mapToGlobal(TQPoint(0,0))} would give
+ the global coordinates of the top-left pixel of the widget.
+
+ \sa mapFromGlobal() mapTo() mapToParent()
+*/
+
+TQPoint TQWidget::mapToGlobal( const TQPoint &pos ) const
+{
+ int x, y;
+ Window child;
+ XTranslateCoordinates( x11Display(), winId(),
+ TQApplication::desktop()->screen(x11Screen())->winId(),
+ pos.x(), pos.y(), &x, &y, &child );
+ return TQPoint( x, y );
+}
+
+/*!
+ Translates the global screen coordinate \a pos to widget
+ coordinates.
+
+ \sa mapToGlobal() mapFrom() mapFromParent()
+*/
+
+TQPoint TQWidget::mapFromGlobal( const TQPoint &pos ) const
+{
+ int x, y;
+ Window child;
+ XTranslateCoordinates( x11Display(),
+ TQApplication::desktop()->screen(x11Screen())->winId(),
+ winId(), pos.x(), pos.y(), &x, &y, &child );
+ return TQPoint( x, y );
+}
+
+/*!
+ When a widget gets focus, it should call setMicroFocusHint() with
+ some appropriate position and size, \a x, \a y, \a width and \a
+ height. This has no \e visual effect, it just provides hints to
+ any system-specific input handling tools.
+
+ The \a text argument should be TRUE if this is a position for text
+ input.
+
+ In the Windows version of TQt, this method sets the system caret,
+ which is used for user Accessibility focus handling. If \a text
+ is TRUE, it also sets the IME composition window in Far East Asian
+ language input systems.
+
+ In the X11 version of TQt, if \a text is TRUE, this method sets the
+ input method focus point in the preedit (XIM "spot" point) for
+ complex language input handling.
+
+ The font \a f is a rendering hint to the currently active input method.
+ If \a f is 0 the widget's font is used.
+
+ \sa microFocusHint()
+*/
+void TQWidget::setMicroFocusHint(int x, int y, int width, int height,
+ bool text, TQFont *f )
+{
+#ifndef QT_NO_IM
+ if ( text ) {
+ // trigger input context creation if it hasn't happened already
+ createInputContext();
+
+ TQInputContext *qic = getInputContext();
+ if(qic) {
+ TQPoint gp = mapToGlobal( TQPoint( x, y ) );
+ qic->setMicroFocus(gp.x(), gp.y(), width, height, f);
+ }
+ }
+#endif
+
+ if ( TQRect( x, y, width, height ) != microFocusHint() ) {
+ createExtra();
+ extraData()->micro_focus_hint.setRect( x, y, width, height );
+ }
+}
+
+
+void TQWidget::setFontSys( TQFont * )
+{
+ // Nothing
+}
+
+
+void TQWidget::setBackgroundColorDirect( const TQColor &color )
+{
+ bg_col = color;
+ if ( extra && extra->bg_pix ) { // kill the background pixmap
+ delete extra->bg_pix;
+ extra->bg_pix = 0;
+ }
+ XSetWindowBackground( x11Display(), winId(), bg_col.pixel(x11Screen()) );
+}
+
+static int allow_null_pixmaps = 0;
+
+
+void TQWidget::setBackgroundPixmapDirect( const TQPixmap &pixmap )
+{
+ TQPixmap old;
+ if ( extra && extra->bg_pix )
+ old = *extra->bg_pix;
+ if ( !allow_null_pixmaps && pixmap.isNull() ) {
+ XSetWindowBackground( x11Display(), winId(), bg_col.pixel(x11Screen()) );
+ if ( extra && extra->bg_pix ) {
+ delete extra->bg_pix;
+ extra->bg_pix = 0;
+ }
+ } else {
+ TQPixmap pm = pixmap;
+ if (!pm.isNull()) {
+ if ( pm.depth() == 1 && TQPixmap::defaultDepth() > 1 ) {
+ pm = TQPixmap( pixmap.size() );
+ bitBlt( &pm, 0, 0, &pixmap, 0, 0, pm.width(), pm.height() );
+ }
+ }
+ if ( extra && extra->bg_pix )
+ delete extra->bg_pix;
+ else
+ createExtra();
+ extra->bg_pix = new TQPixmap( pm );
+ Q_CHECK_PTR( extra->bg_pix );
+ extra->bg_pix->x11SetScreen( x11Screen() );
+ XSetWindowBackgroundPixmap( x11Display(), winId(), extra->bg_pix->handle() );
+ if ( testWFlags(WType_Desktop) ) // save rootinfo later
+ qt_updated_rootinfo();
+ }
+}
+
+
+/*!
+ Sets the window-system background of the widget to nothing.
+
+ Note that "nothing" is actually a pixmap that isNull(), thus you
+ can check for an empty background by checking backgroundPixmap().
+
+ \sa setBackgroundPixmap(), setBackgroundColor()
+*/
+void TQWidget::setBackgroundEmpty()
+{
+ allow_null_pixmaps++;
+ setErasePixmap(TQPixmap());
+ allow_null_pixmaps--;
+}
+
+
+void TQWidget::setBackgroundX11Relative()
+{
+ XSetWindowBackgroundPixmap( x11Display(), winId(), ParentRelative );
+}
+
+void TQWidget::setCursor( const TQCursor &cursor )
+{
+ if ( cursor.handle() != arrowCursor.handle()
+ || (extra && extra->curs) ) {
+ createExtra();
+ delete extra->curs;
+ extra->curs = new TQCursor(cursor);
+ }
+ setWState( WState_OwnCursor );
+ qt_x11_enforce_cursor( this );
+ XFlush( x11Display() );
+}
+
+void TQWidget::unsetCursor()
+{
+ if ( extra ) {
+ delete extra->curs;
+ extra->curs = 0;
+ }
+ if ( !isTopLevel() )
+ clearWState( WState_OwnCursor );
+ qt_x11_enforce_cursor( this );
+ XFlush( x11Display() );
+}
+
+static XTextProperty*
+qstring_to_xtp( const TQString& s )
+{
+ static XTextProperty tp = { 0, 0, 0, 0 };
+ static bool free_prop = TRUE; // we can't free tp.value in case it references
+ // the data of the static TQCString below.
+ if ( tp.value ) {
+ if ( free_prop )
+ XFree( tp.value );
+ tp.value = 0;
+ free_prop = TRUE;
+ }
+
+ static const TQTextCodec* mapper = TQTextCodec::codecForLocale();
+ int errCode = 0;
+ if ( mapper ) {
+ TQCString mapped = mapper->fromUnicode(s);
+ char* tl[2];
+ tl[0] = mapped.data();
+ tl[1] = 0;
+ errCode = XmbTextListToTextProperty( TQPaintDevice::x11AppDisplay(),
+ tl, 1, XStdICCTextStyle, &tp );
+#if defined(QT_DEBUG)
+ if ( errCode < 0 )
+ qDebug( "qstring_to_xtp result code %d", errCode );
+#endif
+ }
+ if ( !mapper || errCode < 0 ) {
+ static TQCString qcs;
+ qcs = s.ascii();
+ tp.value = (uchar*)qcs.data();
+ tp.encoding = XA_STRING;
+ tp.format = 8;
+ tp.nitems = qcs.length();
+ free_prop = FALSE;
+ }
+
+ // ### If we knew WM could understand unicode, we could use
+ // ### a much simpler, cheaper encoding...
+ /*
+ tp.value = (XChar2b*)s.unicode();
+ tp.encoding = XA_UNICODE; // wish
+ tp.format = 16;
+ tp.nitems = s.length();
+ */
+
+ return &tp;
+}
+
+void TQWidget::setCaption( const TQString &caption )
+{
+ if ( TQWidget::caption() == caption )
+ return;
+
+ topData()->caption = caption;
+ XSetWMName( x11Display(), winId(), qstring_to_xtp(caption) );
+
+ TQCString net_wm_name = caption.utf8();
+ XChangeProperty(x11Display(), winId(), qt_net_wm_name, qt_utf8_string, 8,
+ PropModeReplace, (unsigned char *)net_wm_name.data(),
+ net_wm_name.length());
+
+ TQEvent e( TQEvent::CaptionChange );
+ TQApplication::sendEvent( this, &e );
+}
+
+void TQWidget::setIcon( const TQPixmap &pixmap )
+{
+ if ( extra && extra->topextra ) {
+ delete extra->topextra->icon;
+ extra->topextra->icon = 0;
+ } else {
+ createTLExtra();
+ }
+ Pixmap icon_pixmap = 0;
+ Pixmap mask_pixmap = 0;
+ if ( !pixmap.isNull() ) {
+ TQPixmap* pm = new TQPixmap( pixmap );
+ extra->topextra->icon = pm;
+ if ( !pm->mask() )
+ pm->setMask( pm->createHeuristicMask() ); // may do detach()
+ icon_pixmap = pm->handle();
+ if ( pm->mask() )
+ mask_pixmap = pm->mask()->handle();
+ }
+ XWMHints *h = XGetWMHints( x11Display(), winId() );
+ XWMHints wm_hints;
+ bool got_hints = h != 0;
+ if ( !got_hints ) {
+ h = &wm_hints;
+ h->flags = 0;
+ }
+ h->icon_pixmap = icon_pixmap;
+ h->icon_mask = mask_pixmap;
+ h->flags |= IconPixmapHint | IconMaskHint;
+ XSetWMHints( x11Display(), winId(), h );
+ if ( got_hints )
+ XFree( (char *)h );
+ TQEvent e( TQEvent::IconChange );
+ TQApplication::sendEvent( this, &e );
+}
+
+void TQWidget::setIconText( const TQString &iconText )
+{
+ if (TQWidget::iconText() == iconText)
+ return;
+
+ topData()->iconText = iconText;
+ XSetWMIconName( x11Display(), winId(), qstring_to_xtp(iconText) );
+
+ TQCString net_wm_icon_name = iconText.utf8();
+ XChangeProperty(x11Display(), winId(), qt_net_wm_icon_name, qt_utf8_string, 8, PropModeReplace,
+ (unsigned char *) net_wm_icon_name.data(), net_wm_icon_name.length());
+}
+
+void TQWidget::setMouseTracking( bool enable )
+{
+ bool gmt = TQApplication::hasGlobalMouseTracking();
+ if ( !enable == !testWState(WState_MouseTracking) && !gmt )
+ return;
+ uint m = (enable || gmt) ? (uint)PointerMotionMask : 0;
+ if ( enable )
+ setWState( WState_MouseTracking );
+ else
+ clearWState( WState_MouseTracking );
+ if ( testWFlags(WType_Desktop) ) { // desktop widget?
+ TQWidget* main_desktop = find( winId() );
+ if ( main_desktop->testWFlags(WPaintDesktop) )
+ XSelectInput( x11Display(), winId(),
+ stdDesktopEventMask | ExposureMask );
+ else
+ XSelectInput( x11Display(), winId(), stdDesktopEventMask );
+ } else {
+ XSelectInput( x11Display(), winId(),
+ m | stdWidgetEventMask );
+#if defined (QT_TABLET_SUPPORT)
+ if ( devStylus != NULL ) {
+ XSelectExtensionEvent( x11Display(), winId(), event_list_stylus,
+ qt_curr_events_stylus );
+ }
+ if ( devEraser != NULL ) {
+ XSelectExtensionEvent( x11Display(), winId(), event_list_eraser,
+ qt_curr_events_eraser );
+ }
+#endif
+ }
+}
+
+
+/*!
+ Grabs the mouse input.
+
+ This widget receives all mouse events until releaseMouse() is
+ called; other widgets get no mouse events at all. Keyboard
+ events are not affected. Use grabKeyboard() if you want to grab
+ that.
+
+ \warning Bugs in mouse-grabbing applications very often lock the
+ terminal. Use this function with extreme caution, and consider
+ using the \c -nograb command line option while debugging.
+
+ It is almost never necessary to grab the mouse when using TQt, as
+ TQt grabs and releases it sensibly. In particular, TQt grabs the
+ mouse when a mouse button is pressed and keeps it until the last
+ button is released.
+
+ Note that only visible widgets can grab mouse input. If
+ isVisible() returns FALSE for a widget, that widget cannot call
+ grabMouse().
+
+ \sa releaseMouse() grabKeyboard() releaseKeyboard() grabKeyboard()
+ focusWidget()
+*/
+
+void TQWidget::grabMouse()
+{
+ if ( isVisible() && !qt_nograb() ) {
+ if ( mouseGrb )
+ mouseGrb->releaseMouse();
+#if defined(QT_CHECK_STATE)
+ int status =
+#endif
+ XGrabPointer( x11Display(), winId(), False,
+ (uint)( ButtonPressMask | ButtonReleaseMask |
+ PointerMotionMask | EnterWindowMask |
+ LeaveWindowMask ),
+ GrabModeAsync, GrabModeAsync,
+ None, None, qt_x_time );
+#if defined(QT_CHECK_STATE)
+ if ( status ) {
+ const char *s =
+ status == GrabNotViewable ? "\"GrabNotViewable\"" :
+ status == AlreadyGrabbed ? "\"AlreadyGrabbed\"" :
+ status == GrabFrozen ? "\"GrabFrozen\"" :
+ status == GrabInvalidTime ? "\"GrabInvalidTime\"" :
+ "<?>";
+ qWarning( "Grabbing the mouse failed with %s", s );
+ }
+#endif
+ mouseGrb = this;
+ }
+}
+
+/*!
+ \overload
+
+ Grabs the mouse input and changes the cursor shape.
+
+ The cursor will assume shape \a cursor (for as long as the mouse
+ focus is grabbed) and this widget will be the only one to receive
+ mouse events until releaseMouse() is called().
+
+ \warning Grabbing the mouse might lock the terminal.
+
+ \sa releaseMouse(), grabKeyboard(), releaseKeyboard(), setCursor()
+*/
+
+void TQWidget::grabMouse( const TQCursor &cursor )
+{
+ if ( !qt_nograb() ) {
+ if ( mouseGrb )
+ mouseGrb->releaseMouse();
+#if defined(QT_CHECK_STATE)
+ int status =
+#endif
+ XGrabPointer( x11Display(), winId(), False,
+ (uint)(ButtonPressMask | ButtonReleaseMask |
+ PointerMotionMask | EnterWindowMask | LeaveWindowMask),
+ GrabModeAsync, GrabModeAsync,
+ None, cursor.handle(), qt_x_time );
+#if defined(QT_CHECK_STATE)
+ if ( status ) {
+ const char *s =
+ status == GrabNotViewable ? "\"GrabNotViewable\"" :
+ status == AlreadyGrabbed ? "\"AlreadyGrabbed\"" :
+ status == GrabFrozen ? "\"GrabFrozen\"" :
+ status == GrabInvalidTime ? "\"GrabInvalidTime\"" :
+ "<?>";
+ qWarning( "Grabbing the mouse failed with %s", s );
+ }
+#endif
+ mouseGrb = this;
+ }
+}
+
+/*!
+ Releases the mouse grab.
+
+ \sa grabMouse(), grabKeyboard(), releaseKeyboard()
+*/
+
+void TQWidget::releaseMouse()
+{
+ if ( !qt_nograb() && mouseGrb == this ) {
+ XUngrabPointer( x11Display(), qt_x_time );
+ XFlush( x11Display() );
+ mouseGrb = 0;
+ }
+}
+
+/*!
+ Grabs the keyboard input.
+
+ This widget reveives all keyboard events until releaseKeyboard()
+ is called; other widgets get no keyboard events at all. Mouse
+ events are not affected. Use grabMouse() if you want to grab that.
+
+ The focus widget is not affected, except that it doesn't receive
+ any keyboard events. setFocus() moves the focus as usual, but the
+ new focus widget receives keyboard events only after
+ releaseKeyboard() is called.
+
+ If a different widget is currently grabbing keyboard input, that
+ widget's grab is released first.
+
+ \sa releaseKeyboard() grabMouse() releaseMouse() focusWidget()
+*/
+
+void TQWidget::grabKeyboard()
+{
+ if ( !qt_nograb() ) {
+ if ( keyboardGrb )
+ keyboardGrb->releaseKeyboard();
+ XGrabKeyboard( x11Display(), winid, False, GrabModeAsync, GrabModeAsync,
+ qt_x_time );
+ keyboardGrb = this;
+ }
+}
+
+/*!
+ Releases the keyboard grab.
+
+ \sa grabKeyboard(), grabMouse(), releaseMouse()
+*/
+
+void TQWidget::releaseKeyboard()
+{
+ if ( !qt_nograb() && keyboardGrb == this ) {
+ XUngrabKeyboard( x11Display(), qt_x_time );
+ keyboardGrb = 0;
+ }
+}
+
+
+/*!
+ Returns the widget that is currently grabbing the mouse input.
+
+ If no widget in this application is currently grabbing the mouse,
+ 0 is returned.
+
+ \sa grabMouse(), keyboardGrabber()
+*/
+
+TQWidget *TQWidget::mouseGrabber()
+{
+ return mouseGrb;
+}
+
+/*!
+ Returns the widget that is currently grabbing the keyboard input.
+
+ If no widget in this application is currently grabbing the
+ keyboard, 0 is returned.
+
+ \sa grabMouse(), mouseGrabber()
+*/
+
+TQWidget *TQWidget::keyboardGrabber()
+{
+ return keyboardGrb;
+}
+
+/*!
+ Sets the top-level widget containing this widget to be the active
+ window.
+
+ An active window is a visible top-level window that has the
+ keyboard input focus.
+
+ This function performs the same operation as clicking the mouse on
+ the title bar of a top-level window. On X11, the result depends on
+ the Window Manager. If you want to ensure that the window is
+ stacked on top as well you should also call raise(). Note that the
+ window must be visible, otherwise setActiveWindow() has no effect.
+
+ On Windows, if you are calling this when the application is not
+ currently the active one then it will not make it the active
+ window. It will flash the task bar entry blue to indicate that
+ the window has done something. This is because Microsoft do not
+ allow an application to interrupt what the user is currently doing
+ in another application.
+
+ \sa isActiveWindow(), topLevelWidget(), show()
+*/
+
+void TQWidget::setActiveWindow()
+{
+ TQWidget *tlw = topLevelWidget();
+ if ( tlw->isVisible() && !tlw->topData()->embedded && !qt_deferred_map_contains(tlw) ) {
+ XSetInputFocus( x11Display(), tlw->winId(), RevertToNone, qt_x_time);
+ focusInputContext();
+ }
+}
+
+
+/*!
+ Updates the widget unless updates are disabled or the widget is
+ hidden.
+
+ This function does not cause an immediate repaint; instead it
+ schedules a paint event for processing when TQt returns to the main
+ event loop. This permits TQt to optimize for more speed and less
+ flicker than a call to repaint() does.
+
+ Calling update() several times normally results in just one
+ paintEvent() call.
+
+ TQt normally erases the widget's area before the paintEvent() call.
+ If the \c WRepaintNoErase widget flag is set, the widget is
+ responsible for painting all its pixels itself.
+
+ \sa repaint(), paintEvent(), setUpdatesEnabled(), erase(),
+ setWFlags()
+*/
+
+void TQWidget::update()
+{
+ if ( (widget_state & (WState_Visible|WState_BlockUpdates)) ==
+ WState_Visible )
+ TQApplication::postEvent( this, new TQPaintEvent( clipRegion(), !testWFlags(WRepaintNoErase) ) );
+}
+
+/*!
+ \overload
+
+ Updates a rectangle (\a x, \a y, \a w, \a h) inside the widget
+ unless updates are disabled or the widget is hidden.
+
+ This function does not cause an immediate repaint; instead it
+ schedules a paint event for processing when TQt returns to the main
+ event loop. This permits TQt to optimize for more speed and less
+ flicker and a call to repaint() does.
+
+ Calling update() several times normally results in just one
+ paintEvent() call.
+
+ If \a w is negative, it is replaced with \c{width() - x}. If \a h
+ is negative, it is replaced width \c{height() - y}.
+
+ TQt normally erases the specified area before the paintEvent()
+ call. If the \c WRepaintNoErase widget flag is set, the widget is
+ responsible for painting all its pixels itself.
+
+ \sa repaint(), paintEvent(), setUpdatesEnabled(), erase()
+*/
+
+void TQWidget::update( int x, int y, int w, int h )
+{
+ if ( w && h &&
+ (widget_state & (WState_Visible|WState_BlockUpdates)) == WState_Visible ) {
+ if ( w < 0 )
+ w = crect.width() - x;
+ if ( h < 0 )
+ h = crect.height() - y;
+ if ( w != 0 && h != 0 )
+ TQApplication::postEvent( this,
+ new TQPaintEvent( clipRegion().intersect(TQRect(x,y,w,h)),
+ !testWFlags( WRepaintNoErase ) ) );
+ }
+}
+
+/*!
+ \overload void TQWidget::update( const TQRect &r )
+
+ Updates a rectangle \a r inside the widget unless updates are
+ disabled or the widget is hidden.
+
+ This function does not cause an immediate repaint; instead it
+ schedules a paint event for processing when TQt returns to the main
+ event loop. This permits TQt to optimize for more speed and less
+ flicker and a call to repaint() does.
+
+ Calling update() several times normally results in just one
+ paintEvent() call.
+*/
+
+/*!
+ \overload void TQWidget::repaint( bool erase )
+
+ This version repaints the entire widget.
+*/
+
+/*!
+ \overload void TQWidget::repaint()
+
+ This version erases and repaints the entire widget.
+*/
+
+/*!
+ Repaints the widget directly by calling paintEvent() immediately,
+ unless updates are disabled or the widget is hidden.
+
+ If \a erase is TRUE, TQt erases the area \a (x, y, w, h) before the
+ paintEvent() call.
+
+ If \a w is negative, it is replaced with \c{width() - x}, and if
+ \a h is negative, it is replaced width \c{height() - y}.
+
+ We suggest only using repaint() if you need an immediate repaint,
+ for example during animation. In almost all circumstances update()
+ is better, as it permits TQt to optimize for speed and minimize
+ flicker.
+
+ \warning If you call repaint() in a function which may itself be
+ called from paintEvent(), you may get infinite recursion. The
+ update() function never causes recursion.
+
+ \sa update(), paintEvent(), setUpdatesEnabled(), erase()
+*/
+
+void TQWidget::repaint( int x, int y, int w, int h, bool erase )
+{
+ if ( (widget_state & (WState_Visible|WState_BlockUpdates)) == WState_Visible ) {
+ if ( x > crect.width() || y > crect.height() )
+ return;
+ if ( w < 0 )
+ w = crect.width() - x;
+ if ( h < 0 )
+ h = crect.height() - y;
+ TQRect r(x,y,w,h);
+ if ( r.isEmpty() )
+ return; // nothing to do
+ TQPaintEvent e( r, erase );
+ if ( r != rect() )
+ qt_set_paintevent_clipping( this, r );
+ if ( erase && w != 0 && h != 0 ) {
+ if ( backgroundOrigin() == WidgetOrigin )
+ XClearArea( x11Display(), winId(), x, y, w, h, False );
+ else
+ this->erase( x, y, w, h);
+ }
+ TQApplication::sendEvent( this, &e );
+ qt_clear_paintevent_clipping();
+ }
+}
+
+/*!
+ \overload
+
+ Repaints the widget directly by calling paintEvent() directly,
+ unless updates are disabled or the widget is hidden.
+
+ Erases the widget region \a reg if \a erase is TRUE.
+
+ Only use repaint if your widget needs to be repainted immediately,
+ for example when doing some animation. In all other cases, use
+ update(). Calling update() many times in a row will generate a
+ single paint event.
+
+ \warning If you call repaint() in a function which may itself be
+ called from paintEvent(), you may get infinite recursion. The
+ update() function never causes recursion.
+
+ \sa update(), paintEvent(), setUpdatesEnabled(), erase()
+*/
+
+void TQWidget::repaint( const TQRegion& reg, bool erase )
+{
+ if ( (widget_state & (WState_Visible|WState_BlockUpdates)) == WState_Visible ) {
+ TQPaintEvent e( reg, erase );
+ qt_set_paintevent_clipping( this, reg );
+ if ( erase )
+ this->erase(reg);
+ TQApplication::sendEvent( this, &e );
+ qt_clear_paintevent_clipping();
+ }
+}
+
+/*!
+ \overload void TQWidget::repaint( const TQRect &r, bool erase )
+
+ Repaints the widget directly by calling paintEvent() directly,
+ unless updates are disabled or the widget is hidden.
+
+ Erases the widget region \a r if \a erase is TRUE.
+*/
+
+void TQWidget::setWindowState(uint newstate)
+{
+ bool needShow = FALSE;
+ uint oldstate = windowState();
+ if (isTopLevel()) {
+ TQTLWExtra *top = topData();
+
+ if ((oldstate & WindowMaximized) != (newstate & WindowMaximized)) {
+ if (qt_net_supports(qt_net_wm_state_max_h) && qt_net_supports(qt_net_wm_state_max_v)) {
+ qt_net_change_wm_state(this, (newstate & WindowMaximized),
+ qt_net_wm_state_max_h, qt_net_wm_state_max_v);
+ } else if (! (newstate & WindowFullScreen)) {
+ if (newstate & WindowMaximized) {
+ // save original geometry
+ const TQRect normalGeometry = geometry();
+
+ if (isVisible()) {
+ updateFrameStrut();
+ const TQRect maxRect = TQApplication::desktop()->availableGeometry(this);
+ const TQRect r = top->normalGeometry;
+ setGeometry(maxRect.x() + top->fleft,
+ maxRect.y() + top->ftop,
+ maxRect.width() - top->fleft - top->fright,
+ maxRect.height() - top->ftop - top->fbottom);
+ top->normalGeometry = r;
+ }
+
+ if (top->normalGeometry.width() < 0)
+ top->normalGeometry = normalGeometry;
+ } else {
+ // restore original geometry
+ setGeometry(top->normalGeometry);
+ }
+ }
+ }
+
+ if ((oldstate & WindowFullScreen) != (newstate & WindowFullScreen)) {
+ if (qt_net_supports(qt_net_wm_state_fullscreen)) {
+ qt_net_change_wm_state(this, (newstate & WindowFullScreen),
+ qt_net_wm_state_fullscreen);
+ } else {
+ needShow = isVisible();
+
+ if (newstate & WindowFullScreen) {
+ const TQRect normalGeometry = TQRect(pos(), size());
+
+ top->savedFlags = getWFlags();
+ reparent(0, WType_TopLevel | WStyle_Customize | WStyle_NoBorder |
+ // preserve some widget flags
+ (getWFlags() & 0xffff0000),
+ mapToGlobal(TQPoint(0, 0)));
+ const TQRect r = top->normalGeometry;
+ setGeometry(qApp->desktop()->screenGeometry(this));
+ top->normalGeometry = r;
+
+ if ( top->normalGeometry.width() < 0 )
+ top->normalGeometry = normalGeometry;
+ } else {
+ reparent( 0, top->savedFlags, mapToGlobal(TQPoint(0, 0)) );
+
+ if (newstate & WindowMaximized) {
+ // from fullscreen to maximized
+ updateFrameStrut();
+ const TQRect maxRect = TQApplication::desktop()->availableGeometry(this);
+ const TQRect r = top->normalGeometry;
+ setGeometry(maxRect.x() + top->fleft,
+ maxRect.y() + top->ftop,
+ maxRect.width() - top->fleft - top->fright,
+ maxRect.height() - top->ftop - top->fbottom);
+ top->normalGeometry = r;
+ } else {
+ // restore original geometry
+ setGeometry(top->normalGeometry);
+ }
+ }
+ }
+ }
+
+ if ((oldstate & WindowMinimized) != (newstate & WindowMinimized)) {
+ if (isVisible()) {
+ if (newstate & WindowMinimized) {
+ XEvent e;
+ e.xclient.type = ClientMessage;
+ e.xclient.message_type = qt_wm_change_state;
+ e.xclient.display = x11Display();
+ e.xclient.window = winid;
+ e.xclient.format = 32;
+ e.xclient.data.l[0] = IconicState;
+ e.xclient.data.l[1] = 0;
+ e.xclient.data.l[2] = 0;
+ e.xclient.data.l[3] = 0;
+ e.xclient.data.l[4] = 0;
+ XSendEvent(x11Display(), RootWindow(x11Display(), x11Screen()),
+ False, (SubstructureNotifyMask|SubstructureRedirectMask), &e);
+ } else {
+ XMapWindow(x11Display(), winId());
+ }
+ }
+
+ needShow = FALSE;
+ }
+ }
+
+ widget_state &= ~(WState_Minimized | WState_Maximized | WState_FullScreen);
+ if (newstate & WindowMinimized)
+ widget_state |= WState_Minimized;
+ if (newstate & WindowMaximized)
+ widget_state |= WState_Maximized;
+ if (newstate & WindowFullScreen)
+ widget_state |= WState_FullScreen;
+
+ if (needShow)
+ show();
+
+ if (newstate & WindowActive)
+ setActiveWindow();
+
+ TQEvent e(TQEvent::WindowStateChange);
+ TQApplication::sendEvent(this, &e);
+}
+
+/*!
+ \internal
+ Platform-specific part of TQWidget::show().
+*/
+
+void TQWidget::showWindow()
+{
+ if ( isTopLevel() ) {
+ XWMHints *h = XGetWMHints( x11Display(), winId() );
+ XWMHints wm_hints;
+ bool got_hints = h != 0;
+ if ( !got_hints ) {
+ h = &wm_hints;
+ h->flags = 0;
+ }
+ h->initial_state = testWState(WState_Minimized) ? IconicState : NormalState;
+ h->flags |= StateHint;
+ XSetWMHints( x11Display(), winId(), h );
+ if ( got_hints )
+ XFree( (char *)h );
+
+ if (qt_x_user_time != CurrentTime) {
+ XChangeProperty(x11Display(), winId(), qt_net_wm_user_time, XA_CARDINAL,
+ 32, PropModeReplace, (unsigned char *) &qt_x_user_time, 1);
+ }
+
+ if (!topData()->embedded &&
+ topData()->parentWinId &&
+ topData()->parentWinId != TQPaintDevice::x11AppRootWindow(x11Screen()) &&
+ !isMinimized() ) {
+ qt_deferred_map_add( this );
+ return;
+ }
+
+ if (isMaximized() && !isFullScreen()
+ && !(qt_net_supports(qt_net_wm_state_max_h)
+ && qt_net_supports(qt_net_wm_state_max_v))) {
+ XMapWindow( x11Display(), winId() );
+ qt_wait_for_window_manager(this);
+
+ // if the wm was not smart enough to adjust our size, do that manually
+ updateFrameStrut();
+ TQRect maxRect = TQApplication::desktop()->availableGeometry(this);
+
+ TQTLWExtra *top = topData();
+ TQRect normalRect = top->normalGeometry;
+
+ setGeometry(maxRect.x() + top->fleft,
+ maxRect.y() + top->ftop,
+ maxRect.width() - top->fleft - top->fright,
+ maxRect.height() - top->ftop - top->fbottom);
+
+ // restore the original normalGeometry
+ top->normalGeometry = normalRect;
+ // internalSetGeometry() clears the maximized flag... make sure we set it back
+ setWState(WState_Maximized);
+
+ return;
+ }
+
+ if (isFullScreen() && !qt_net_supports(qt_net_wm_state_fullscreen)) {
+ XMapWindow(x11Display(), winId());
+ qt_wait_for_window_manager(this);
+ return;
+ }
+ }
+ XMapWindow( x11Display(), winId() );
+}
+
+
+/*!
+ \internal
+ Platform-specific part of TQWidget::hide().
+*/
+
+void TQWidget::hideWindow()
+{
+ clearWState( WState_Exposed );
+ deactivateWidgetCleanup();
+ if ( isTopLevel() ) {
+ qt_deferred_map_take( this );
+ if ( winId() ) // in nsplugin, may be 0
+ XWithdrawWindow( x11Display(), winId(), x11Screen() );
+
+ TQTLWExtra *top = topData();
+ crect.moveTopLeft( TQPoint(crect.x() - top->fleft, crect.y() - top->ftop ) );
+
+ // zero the frame strut and mark it dirty
+ top->fleft = top->fright = top->ftop = top->fbottom = 0;
+ fstrut_dirty = TRUE;
+
+ XFlush( x11Display() );
+ } else {
+ if ( winId() ) // in nsplugin, may be 0
+ XUnmapWindow( x11Display(), winId() );
+ }
+}
+
+/*!
+ Raises this widget to the top of the parent widget's stack.
+
+ After this call the widget will be visually in front of any
+ overlapping sibling widgets.
+
+ \sa lower(), stackUnder()
+*/
+
+void TQWidget::raise()
+{
+ TQWidget *p = parentWidget();
+ if ( p && p->childObjects && p->childObjects->findRef(this) >= 0 )
+ p->childObjects->append( p->childObjects->take() );
+ XRaiseWindow( x11Display(), winId() );
+}
+
+/*!
+ Lowers the widget to the bottom of the parent widget's stack.
+
+ After this call the widget will be visually behind (and therefore
+ obscured by) any overlapping sibling widgets.
+
+ \sa raise(), stackUnder()
+*/
+
+void TQWidget::lower()
+{
+ TQWidget *p = parentWidget();
+ if ( p && p->childObjects && p->childObjects->findRef(this) >= 0 )
+ p->childObjects->insert( 0, p->childObjects->take() );
+ XLowerWindow( x11Display(), winId() );
+}
+
+
+/*!
+ Places the widget under \a w in the parent widget's stack.
+
+ To make this work, the widget itself and \a w must be siblings.
+
+ \sa raise(), lower()
+*/
+void TQWidget::stackUnder( TQWidget* w)
+{
+ TQWidget *p = parentWidget();
+ if ( !w || isTopLevel() || p != w->parentWidget() || this == w )
+ return;
+ if ( p && p->childObjects && p->childObjects->findRef(w) >= 0 && p->childObjects->findRef(this) >= 0 ) {
+ p->childObjects->take();
+ p->childObjects->insert( p->childObjects->findRef(w), this );
+ }
+ Window stack[2];
+ stack[0] = w->winId();;
+ stack[1] = winId();
+ XRestackWindows( x11Display(), stack, 2 );
+}
+
+
+
+/*
+ The global variable qt_widget_tlw_gravity defines the window gravity of
+ the next top level window to be created. We do this when setting the
+ main widget's geometry and the "-geometry" command line option contains
+ a negative position.
+*/
+
+int qt_widget_tlw_gravity = NorthWestGravity;
+
+static void do_size_hints( TQWidget* widget, TQWExtra *x )
+{
+ XSizeHints s;
+ s.flags = 0;
+ if ( x ) {
+ s.x = widget->x();
+ s.y = widget->y();
+ s.width = widget->width();
+ s.height = widget->height();
+ if ( x->minw > 0 || x->minh > 0 ) { // add minimum size hints
+ s.flags |= PMinSize;
+ s.min_width = x->minw;
+ s.min_height = x->minh;
+ }
+ if ( x->maxw < TQWIDGETSIZE_MAX || x->maxh < TQWIDGETSIZE_MAX ) {
+ s.flags |= PMaxSize; // add maximum size hints
+ s.max_width = x->maxw;
+ s.max_height = x->maxh;
+ }
+ if ( x->topextra &&
+ (x->topextra->incw > 0 || x->topextra->inch > 0) )
+ { // add resize increment hints
+ s.flags |= PResizeInc | PBaseSize;
+ s.width_inc = x->topextra->incw;
+ s.height_inc = x->topextra->inch;
+ s.base_width = x->topextra->basew;
+ s.base_height = x->topextra->baseh;
+ }
+
+ if ( x->topextra && x->topextra->uspos) {
+ s.flags |= USPosition;
+ s.flags |= PPosition;
+ }
+ if ( x->topextra && x->topextra->ussize) {
+ s.flags |= USSize;
+ s.flags |= PSize;
+ }
+ }
+ s.flags |= PWinGravity;
+ s.win_gravity = qt_widget_tlw_gravity; // usually NorthWest
+ // reset in case it was set
+ qt_widget_tlw_gravity =
+ TQApplication::reverseLayout() ? NorthEastGravity : NorthWestGravity;
+ XSetWMNormalHints( widget->x11Display(), widget->winId(), &s );
+}
+
+
+void TQWidget::internalSetGeometry( int x, int y, int w, int h, bool isMove )
+{
+ Display *dpy = x11Display();
+
+ if ( testWFlags(WType_Desktop) )
+ return;
+ if (isTopLevel()) {
+ if (!qt_net_supports(qt_net_wm_state_max_h)
+ && !qt_net_supports(qt_net_wm_state_max_v))
+ clearWState(WState_Maximized);
+ if (!qt_net_supports(qt_net_wm_state_fullscreen))
+ clearWState(WState_FullScreen);
+ topData()->normalGeometry = TQRect(0, 0, -1, -1);
+ } else {
+ // for TQWorkspace
+ clearWState(WState_Maximized);
+ clearWState(WState_FullScreen);
+ }
+ if ( extra ) { // any size restrictions?
+ w = TQMIN(w,extra->maxw);
+ h = TQMIN(h,extra->maxh);
+ w = TQMAX(w,extra->minw);
+ h = TQMAX(h,extra->minh);
+ }
+ if ( w < 1 ) // invalid size
+ w = 1;
+ if ( h < 1 )
+ h = 1;
+ TQPoint oldPos( pos() );
+ TQSize oldSize( size() );
+ TQRect oldGeom( crect );
+ TQRect r( x, y, w, h );
+
+ // We only care about stuff that changes the geometry, or may
+ // cause the window manager to change its state
+ if ( !isTopLevel() && oldGeom == r )
+ return;
+
+ crect = r;
+ bool isResize = size() != oldSize;
+
+ if ( isTopLevel() ) {
+ if ( isMove )
+ topData()->uspos = 1;
+ if ( isResize )
+ topData()->ussize = 1;
+ do_size_hints( this, extra );
+ }
+
+ if ( isMove ) {
+ if (! qt_broken_wm)
+ // pos() is right according to ICCCM 4.1.5
+ XMoveResizeWindow( dpy, winid, pos().x(), pos().y(), w, h );
+ else
+ // work around 4Dwm's incompliance with ICCCM 4.1.5
+ XMoveResizeWindow( dpy, winid, x, y, w, h );
+ } else if ( isResize )
+ XResizeWindow( dpy, winid, w, h );
+
+ if ( isVisible() ) {
+ if ( isMove && pos() != oldPos ) {
+ if ( ! qt_broken_wm ) {
+ // pos() is right according to ICCCM 4.1.5
+ TQMoveEvent e( pos(), oldPos );
+ TQApplication::sendEvent( this, &e );
+ } else {
+ // work around 4Dwm's incompliance with ICCCM 4.1.5
+ TQMoveEvent e( crect.topLeft(), oldGeom.topLeft() );
+ TQApplication::sendEvent( this, &e );
+ }
+ }
+ if ( isResize ) {
+
+ // set config pending only on resize, see qapplication_x11.cpp, translateConfigEvent()
+ setWState( WState_ConfigPending );
+
+ TQResizeEvent e( size(), oldSize );
+ TQApplication::sendEvent( this, &e );
+ }
+ } else {
+ if ( isMove && pos() != oldPos ) {
+ if ( ! qt_broken_wm )
+ // pos() is right according to ICCCM 4.1.5
+ TQApplication::postEvent( this, new TQMoveEvent( pos(), oldPos ) );
+ else
+ // work around 4Dwm's incompliance with ICCCM 4.1.5
+ TQApplication::postEvent( this, new TQMoveEvent( crect.topLeft(),
+ oldGeom.topLeft() ) );
+ }
+ if ( isResize )
+ TQApplication::postEvent( this,
+ new TQResizeEvent( size(), oldSize ) );
+ }
+}
+
+
+/*!
+ \overload
+
+ This function corresponds to setMinimumSize( TQSize(minw, minh) ).
+ Sets the minimum width to \a minw and the minimum height to \a
+ minh.
+*/
+
+void TQWidget::setMinimumSize( int minw, int minh )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( minw < 0 || minh < 0 )
+ qWarning("TQWidget::setMinimumSize: The smallest allowed size is (0,0)");
+#endif
+ createExtra();
+ if ( extra->minw == minw && extra->minh == minh )
+ return;
+ extra->minw = minw;
+ extra->minh = minh;
+ if ( minw > width() || minh > height() ) {
+ bool resized = testWState( WState_Resized );
+ resize( TQMAX(minw,width()), TQMAX(minh,height()) );
+ if ( !resized )
+ clearWState( WState_Resized ); // not a user resize
+ }
+ if ( testWFlags(WType_TopLevel) )
+ do_size_hints( this, extra );
+ updateGeometry();
+}
+
+/*!
+ \overload
+
+ This function corresponds to setMaximumSize( TQSize(\a maxw, \a
+ maxh) ). Sets the maximum width to \a maxw and the maximum height
+ to \a maxh.
+*/
+void TQWidget::setMaximumSize( int maxw, int maxh )
+{
+#if defined(QT_CHECK_RANGE)
+ if ( maxw > TQWIDGETSIZE_MAX || maxh > TQWIDGETSIZE_MAX ) {
+ qWarning("TQWidget::setMaximumSize: (%s/%s) "
+ "The largest allowed size is (%d,%d)",
+ name( "unnamed" ), className(), TQWIDGETSIZE_MAX,
+ TQWIDGETSIZE_MAX );
+ maxw = TQMIN( maxw, TQWIDGETSIZE_MAX );
+ maxh = TQMIN( maxh, TQWIDGETSIZE_MAX );
+ }
+ if ( maxw < 0 || maxh < 0 ) {
+ qWarning("TQWidget::setMaximumSize: (%s/%s) Negative sizes (%d,%d) "
+ "are not possible",
+ name( "unnamed" ), className(), maxw, maxh );
+ maxw = TQMAX( maxw, 0 );
+ maxh = TQMAX( maxh, 0 );
+ }
+#endif
+ createExtra();
+ if ( extra->maxw == maxw && extra->maxh == maxh )
+ return;
+ extra->maxw = maxw;
+ extra->maxh = maxh;
+ if ( maxw < width() || maxh < height() ) {
+ bool resized = testWState( WState_Resized );
+ resize( TQMIN(maxw,width()), TQMIN(maxh,height()) );
+ if ( !resized )
+ clearWState( WState_Resized ); // not a user resize
+ }
+ if ( testWFlags(WType_TopLevel) )
+ do_size_hints( this, extra );
+ updateGeometry();
+}
+
+/*!
+ \overload
+
+ Sets the x (width) size increment to \a w and the y (height) size
+ increment to \a h.
+*/
+void TQWidget::setSizeIncrement( int w, int h )
+{
+ TQTLWExtra* x = topData();
+ if ( x->incw == w && x->inch == h )
+ return;
+ x->incw = w;
+ x->inch = h;
+ if ( testWFlags(WType_TopLevel) )
+ do_size_hints( this, extra );
+}
+
+/*!
+ \overload
+
+ This corresponds to setBaseSize( TQSize(\a basew, \a baseh) ). Sets
+ the widgets base size to width \a basew and height \a baseh.
+*/
+void TQWidget::setBaseSize( int basew, int baseh )
+{
+ createTLExtra();
+ TQTLWExtra* x = topData();
+ if ( x->basew == basew && x->baseh == baseh )
+ return;
+ x->basew = basew;
+ x->baseh = baseh;
+ if ( testWFlags(WType_TopLevel) )
+ do_size_hints( this, extra );
+}
+
+/*!
+ \overload void TQWidget::erase()
+
+ This version erases the entire widget.
+*/
+
+/*!
+ \overload void TQWidget::erase( const TQRect &r )
+
+ Erases the specified area \a r in the widget without generating a
+ \link paintEvent() paint event\endlink.
+*/
+
+/*!
+ Erases the specified area \a (x, y, w, h) in the widget without
+ generating a \link paintEvent() paint event\endlink.
+
+ If \a w is negative, it is replaced with \c{width() - x}. If \a h
+ is negative, it is replaced width \c{height() - y}.
+
+ Child widgets are not affected.
+
+ \sa repaint()
+*/
+
+void TQWidget::erase( int x, int y, int w, int h )
+{
+ extern void qt_erase_rect( TQWidget*, const TQRect& ); // in qpainer_x11.cpp
+ if ( w < 0 )
+ w = crect.width() - x;
+ if ( h < 0 )
+ h = crect.height() - y;
+ if ( w != 0 && h != 0 )
+ qt_erase_rect( this, TQRect(x, y, w, h ) );
+}
+
+/*!
+ \overload
+
+ Erases the area defined by \a reg, without generating a \link
+ paintEvent() paint event\endlink.
+
+ Child widgets are not affected.
+*/
+
+void TQWidget::erase( const TQRegion& reg )
+{
+ extern void qt_erase_region( TQWidget*, const TQRegion& ); // in qpainer_x11.cpp
+ qt_erase_region( this, reg );
+}
+
+/*!
+ Scrolls the widget including its children \a dx pixels to the
+ right and \a dy downwards. Both \a dx and \a dy may be negative.
+
+ After scrolling, scroll() sends a paint event for the the part
+ that is read but not written. For example, when scrolling 10
+ pixels rightwards, the leftmost ten pixels of the widget need
+ repainting. The paint event may be delivered immediately or later,
+ depending on some heuristics (note that you might have to force
+ processing of paint events using TQApplication::sendPostedEvents()
+ when using scroll() and move() in combination).
+
+ \sa TQScrollView erase() bitBlt()
+*/
+
+void TQWidget::scroll( int dx, int dy )
+{
+ scroll( dx, dy, TQRect() );
+}
+
+/*!
+ \overload
+
+ This version only scrolls \a r and does not move the children of
+ the widget.
+
+ If \a r is empty or invalid, the result is undefined.
+
+ \sa TQScrollView erase() bitBlt()
+*/
+void TQWidget::scroll( int dx, int dy, const TQRect& r )
+{
+ if ( testWState( WState_BlockUpdates ) && !children() )
+ return;
+ bool valid_rect = r.isValid();
+ bool just_update = TQABS( dx ) > width() || TQABS( dy ) > height();
+ if ( just_update )
+ update();
+ TQRect sr = valid_rect?r:clipRegion().boundingRect();
+ int x1, y1, x2, y2, w=sr.width(), h=sr.height();
+ if ( dx > 0 ) {
+ x1 = sr.x();
+ x2 = x1+dx;
+ w -= dx;
+ } else {
+ x2 = sr.x();
+ x1 = x2-dx;
+ w += dx;
+ }
+ if ( dy > 0 ) {
+ y1 = sr.y();
+ y2 = y1+dy;
+ h -= dy;
+ } else {
+ y2 = sr.y();
+ y1 = y2-dy;
+ h += dy;
+ }
+
+ if ( dx == 0 && dy == 0 )
+ return;
+
+ Display *dpy = x11Display();
+ GC gc = qt_xget_readonly_gc( x11Screen(), FALSE );
+ // Want expose events
+ if ( w > 0 && h > 0 && !just_update ) {
+ XSetGraphicsExposures( dpy, gc, True );
+ XCopyArea( dpy, winId(), winId(), gc, x1, y1, w, h, x2, y2);
+ XSetGraphicsExposures( dpy, gc, False );
+ }
+
+ if ( !valid_rect && children() ) { // scroll children
+ TQPoint pd( dx, dy );
+ TQObjectListIt it(*children());
+ register TQObject *object;
+ while ( it ) { // move all children
+ object = it.current();
+ if ( object->isWidgetType() ) {
+ TQWidget *w = (TQWidget *)object;
+ w->move( w->pos() + pd );
+ }
+ ++it;
+ }
+ }
+
+ if ( just_update )
+ return;
+
+ // Don't let the server be bogged-down with repaint events
+ bool repaint_immediately = qt_sip_count( this ) < 3;
+
+ if ( dx ) {
+ int x = x2 == sr.x() ? sr.x()+w : sr.x();
+ if ( repaint_immediately )
+ repaint( x, sr.y(), TQABS(dx), sr.height(), !testWFlags(WRepaintNoErase) );
+ else
+ XClearArea( dpy, winid, x, sr.y(), TQABS(dx), sr.height(), True );
+ }
+ if ( dy ) {
+ int y = y2 == sr.y() ? sr.y()+h : sr.y();
+ if ( repaint_immediately )
+ repaint( sr.x(), y, sr.width(), TQABS(dy), !testWFlags(WRepaintNoErase) );
+ else
+ XClearArea( dpy, winid, sr.x(), y, sr.width(), TQABS(dy), True );
+ }
+
+ qt_insert_sip( this, dx, dy ); // #### ignores r
+}
+
+
+/*!
+ \overload void TQWidget::drawText( const TQPoint &pos, const TQString& str )
+
+ Draws the string \a str at position \a pos.
+*/
+
+/*!
+ Draws the string \a str at position \a(x, y).
+
+ The \a y position is the base line position of the text. The text
+ is drawn using the default font and the default foreground color.
+
+ This function is provided for convenience. You will generally get
+ more flexible results and often higher speed by using a a \link
+ TQPainter painter\endlink instead.
+
+ \sa setFont(), foregroundColor(), TQPainter::drawText()
+*/
+
+void TQWidget::drawText( int x, int y, const TQString &str )
+{
+ if ( testWState(WState_Visible) ) {
+ TQPainter paint;
+ paint.begin( this );
+ paint.drawText( x, y, str );
+ paint.end();
+ }
+}
+
+
+/*!
+ Internal implementation of the virtual TQPaintDevice::metric()
+ function.
+
+ Use the TQPaintDeviceMetrics class instead.
+
+ \a m is the metric to get.
+*/
+
+int TQWidget::metric( int m ) const
+{
+ int val;
+ if ( m == TQPaintDeviceMetrics::PdmWidth ) {
+ val = crect.width();
+ } else if ( m == TQPaintDeviceMetrics::PdmHeight ) {
+ val = crect.height();
+ } else {
+ Display *dpy = x11Display();
+ int scr = x11Screen();
+ switch ( m ) {
+ case TQPaintDeviceMetrics::PdmDpiX:
+ case TQPaintDeviceMetrics::PdmPhysicalDpiX:
+ val = TQPaintDevice::x11AppDpiX( scr );
+ break;
+ case TQPaintDeviceMetrics::PdmDpiY:
+ case TQPaintDeviceMetrics::PdmPhysicalDpiY:
+ val = TQPaintDevice::x11AppDpiY( scr );
+ break;
+ case TQPaintDeviceMetrics::PdmWidthMM:
+ val = (DisplayWidthMM(dpy,scr)*crect.width())/
+ DisplayWidth(dpy,scr);
+ break;
+ case TQPaintDeviceMetrics::PdmHeightMM:
+ val = (DisplayHeightMM(dpy,scr)*crect.height())/
+ DisplayHeight(dpy,scr);
+ break;
+ case TQPaintDeviceMetrics::PdmNumColors:
+ val = x11Cells();
+ break;
+ case TQPaintDeviceMetrics::PdmDepth:
+ val = x11Depth();
+ break;
+ default:
+ val = 0;
+#if defined(QT_CHECK_RANGE)
+ qWarning( "TQWidget::metric: Invalid metric command" );
+#endif
+ }
+ }
+ return val;
+}
+
+void TQWidget::createSysExtra()
+{
+ extra->xDndProxy = 0;
+ extra->children_use_dnd = FALSE;
+ extra->compress_events = TRUE;
+}
+
+void TQWidget::deleteSysExtra()
+{
+}
+
+void TQWidget::createTLSysExtra()
+{
+#if defined(QT_NO_IM_EXTENSIONS)
+ // created lazily
+ extra->topextra->xic = 0;
+#endif
+#ifndef QT_NO_XSYNC
+ extra->topextra->syncCounter = 0;
+ extra->topextra->syncRequestValue[0] = 0;
+ extra->topextra->syncRequestValue[1] = 0;
+#endif
+}
+
+void TQWidget::deleteTLSysExtra()
+{
+ // don't destroy input context here. it will be destroyed in
+ // TQWidget::destroy() destroyInputContext();
+}
+
+/*
+ examine the children of our parent up the tree and set the
+ children_use_dnd extra data appropriately... this is used to keep DND enabled
+ for widgets that are reparented and don't have DND enabled, BUT *DO* have
+ children (or children of children ...) with DND enabled...
+*/
+void TQWidget::checkChildrenDnd()
+{
+ TQWidget *widget = this;
+ const TQObjectList *children;
+ const TQObject *object;
+ const TQWidget *child;
+ while (widget && ! widget->isDesktop()) {
+ // note: this isn't done for the desktop widget
+
+ bool children_use_dnd = FALSE;
+ children = widget->children();
+ if ( children ) {
+ TQObjectListIt it(*children);
+ while ( (object = it.current()) ) {
+ ++it;
+ if ( object->isWidgetType() ) {
+ child = (const TQWidget *) object;
+ children_use_dnd = (children_use_dnd ||
+ child->acceptDrops() ||
+ (child->extra &&
+ child->extra->children_use_dnd));
+ }
+ }
+ }
+
+ widget->createExtra();
+ widget->extra->children_use_dnd = children_use_dnd;
+
+ widget = widget->parentWidget();
+ }
+}
+
+
+#ifndef QT_NO_XSYNC
+// create a window's XSyncCounter
+void TQWidget::createSyncCounter()
+{
+ if( !qt_use_xsync || !isTopLevel() || topData()->syncCounter )
+ return;
+ XSyncValue zero;
+ XSyncIntToValue( &zero, 0 );
+ topData()->syncCounter = XSyncCreateCounter( x11Display(), zero );
+}
+
+// destroy a window's XSyncCounter
+void TQWidget::destroySyncCounter()
+{
+ if( !qt_use_xsync || !extra || !extra->topextra
+ || !extra->topextra->syncCounter )
+ return;
+ XSyncDestroyCounter( x11Display(), extra->topextra->syncCounter );
+ extra->topextra->syncCounter = 0;
+}
+
+// increment a window's XSyncCounter
+void TQWidget::incrementSyncCounter()
+{
+ if( qt_use_xsync && topData()->syncCounter &&
+ !(topData()->syncRequestValue[0] == 0 &&
+ topData()->syncRequestValue[1] == 0) ) {
+ XSyncValue val;
+ XSyncIntsToValue( &val, topData()->syncRequestValue[ 0 ], topData()->syncRequestValue[ 1 ] );
+ XSyncSetCounter( x11Display(), topData()->syncCounter, val );
+ topData()->syncRequestValue[0] = topData()->syncRequestValue[1] = 0;
+ }
+}
+
+// handle _NET_WM_SYNC_RETQUEST
+void TQWidget::handleSyncRequest( void* ev )
+{
+ XEvent* xev = (XEvent*)ev;
+ topData()->syncRequestValue[ 0 ] = xev->xclient.data.l[ 2 ];
+ topData()->syncRequestValue[ 1 ] = xev->xclient.data.l[ 3 ];
+}
+#endif // QT_NO_XSYNC
+
+
+/*!
+ \property TQWidget::acceptDrops
+ \brief whether drop events are enabled for this widget
+
+ Setting this property to TRUE announces to the system that this
+ widget \e may be able to accept drop events.
+
+ If the widget is the desktop (TQWidget::isDesktop()), this may
+ fail if another application is using the desktop; you can call
+ acceptDrops() to test if this occurs.
+
+ \warning
+ Do not modify this property in a Drag&Drop event handler.
+*/
+bool TQWidget::acceptDrops() const
+{
+ return testWState( WState_DND );
+}
+
+void TQWidget::setAcceptDrops( bool on )
+{
+ if ( testWState(WState_DND) != on ) {
+ if ( qt_dnd_enable( this, on ) ) {
+ if ( on )
+ setWState( WState_DND );
+ else
+ clearWState( WState_DND );
+ }
+
+ checkChildrenDnd();
+ }
+}
+
+/*!
+ \overload
+
+ Causes only the parts of the widget which overlap \a region to be
+ visible. If the region includes pixels outside the rect() of the
+ widget, window system controls in that area may or may not be
+ visible, depending on the platform.
+
+ Note that this effect can be slow if the region is particularly
+ complex.
+
+ \sa setMask(), clearMask()
+*/
+
+void TQWidget::setMask( const TQRegion& region )
+{
+ XShapeCombineRegion( x11Display(), winId(), ShapeBounding, 0, 0,
+ region.handle(), ShapeSet );
+}
+
+/*!
+ Causes only the pixels of the widget for which \a bitmap has a
+ corresponding 1 bit to be visible. Use TQt::color0 to draw
+ transparent regions and TQt::color1 to draw opaque regions of the
+ bitmap.
+
+ If the region includes pixels outside the rect() of the widget,
+ window system controls in that area may or may not be visible,
+ depending on the platform.
+
+ Note that this effect can be slow if the region is particularly
+ complex.
+
+ See \c examples/tux for an example of masking for transparency.
+
+ \sa setMask(), clearMask()
+*/
+
+void TQWidget::setMask( const TQBitmap &bitmap )
+{
+ TQBitmap bm = bitmap;
+ if ( bm.x11Screen() != x11Screen() )
+ bm.x11SetScreen( x11Screen() );
+ XShapeCombineMask( x11Display(), winId(), ShapeBounding, 0, 0,
+ bm.handle(), ShapeSet );
+}
+
+/*!
+ Removes any mask set by setMask().
+
+ \sa setMask()
+*/
+
+void TQWidget::clearMask()
+{
+ XShapeCombineMask( x11Display(), winId(), ShapeBounding, 0, 0,
+ None, ShapeSet );
+}
+
+/*!\reimp
+ */
+void TQWidget::setName( const char *name )
+{
+ TQObject::setName( name );
+ if ( isTopLevel() ) {
+ XChangeProperty( x11Display(), winId(),
+ qt_window_role, XA_STRING, 8, PropModeReplace,
+ (unsigned char *)name, qstrlen( name ) );
+ }
+}
+
+
+/*!
+ \internal
+
+ Computes the frame rectangle when needed. This is an internal function, you
+ should never call this.
+*/
+
+void TQWidget::updateFrameStrut() const
+{
+ TQWidget *that = (TQWidget *) this;
+
+ if (! isVisible() || isDesktop()) {
+ that->fstrut_dirty = (! isVisible());
+ return;
+ }
+
+ Atom type_ret;
+ Window l = winId(), w = winId(), p, r; // target window, it's parent, root
+ Window *c;
+ int i_unused;
+ unsigned int nc;
+ unsigned char *data_ret;
+ unsigned long l_unused;
+
+ while (XQueryTree(TQPaintDevice::x11AppDisplay(), w, &r, &p, &c, &nc)) {
+ if (c && nc > 0)
+ XFree(c);
+
+ if (! p) {
+ qWarning("TQWidget::updateFrameStrut(): ERROR - no parent");
+ return;
+ }
+
+ // if the parent window is the root window, an Enlightenment virtual root or
+ // a NET WM virtual root window, stop here
+ data_ret = 0;
+ if (p == r ||
+ (XGetWindowProperty(TQPaintDevice::x11AppDisplay(), p,
+ qt_enlightenment_desktop, 0, 1, False, XA_CARDINAL,
+ &type_ret, &i_unused, &l_unused, &l_unused,
+ &data_ret) == Success &&
+ type_ret == XA_CARDINAL)) {
+ if (data_ret)
+ XFree(data_ret);
+
+ break;
+ } else if (qt_net_supports(qt_net_virtual_roots) && qt_net_virtual_root_list) {
+ int i = 0;
+ while (qt_net_virtual_root_list[i] != 0) {
+ if (qt_net_virtual_root_list[i++] == p)
+ break;
+ }
+ }
+
+ l = w;
+ w = p;
+ }
+
+ // we have our window
+ int transx, transy;
+ XWindowAttributes wattr;
+ if (XTranslateCoordinates(TQPaintDevice::x11AppDisplay(), l, w,
+ 0, 0, &transx, &transy, &p) &&
+ XGetWindowAttributes(TQPaintDevice::x11AppDisplay(), w, &wattr)) {
+ TQTLWExtra *top = that->topData();
+ top->fleft = transx;
+ top->ftop = transy;
+ top->fright = wattr.width - crect.width() - top->fleft;
+ top->fbottom = wattr.height - crect.height() - top->ftop;
+
+ // add the border_width for the window managers frame... some window managers
+ // do not use a border_width of zero for their frames, and if we the left and
+ // top strut, we ensure that pos() is absolutely correct. frameGeometry()
+ // will still be incorrect though... perhaps i should have foffset as well, to
+ // indicate the frame offset (equal to the border_width on X).
+ // - Brad
+ top->fleft += wattr.border_width;
+ top->fright += wattr.border_width;
+ top->ftop += wattr.border_width;
+ top->fbottom += wattr.border_width;
+ }
+
+ that->fstrut_dirty = 0;
+}
+
+
+/*!
+ This function returns the widget holding the TQInputContext
+ instance for this widget. The instance is used for text input to
+ this widget, switching input method, etc.
+
+ By default, this function delegates the role of returning input
+ context holder widget to TQApplication::locateICHolderWidget().
+
+ This definition enables application developer to change the
+ mapping of widgets to TQInputContext instance simply by overriding
+ TQApplication::locateICHolderWidget().
+
+ \sa TQApplication::locateICHolderWidget()
+*/
+TQWidget *TQWidget::icHolderWidget()
+{
+ return qApp->locateICHolderWidget(this);
+}
+
+
+/*!
+ This function returns the TQInputContext instance for this widget.
+ This instance is used for text input to this widget, etc.
+ It is simply the accessor function.
+*/
+TQInputContext *TQWidget::getInputContext()
+{
+ TQInputContext *qic = 0;
+
+// #if !defined(QT_NO_IM_EXTENSIONS)
+ if ( isInputMethodEnabled() ) {
+#if !defined(QT_NO_IM_EXTENSIONS)
+ qic = icHolderWidget()->ic;
+#else
+// {
+ // icHolderWidget is always topLevelWidget
+ TQTLWExtra *topdata = icHolderWidget()->topData();
+ qic = (TQInputContext *)topdata->xic;
+#endif
+ }
+
+ return qic;
+}
+
+
+/*!
+ This function replaces the TQInputContext instance used for text
+ input to this widget. The \a identifierName is the identifier name
+ of newly choosed input method.
+*/
+void TQWidget::changeInputContext( const TQString& identifierName )
+{
+ TQWidget *icWidget = icHolderWidget();
+#if !defined(QT_NO_IM_EXTENSIONS)
+ TQInputContext **qicp = &icWidget->ic;
+#else
+ TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic;
+#endif
+
+ if( *qicp )
+ delete *qicp;
+ // an input context that has the identifierName is generated.
+ TQInputContext *qic = TQInputContextFactory::create( identifierName, icWidget );
+ *qicp = qic;
+ if ( qic ) {
+ TQObject::connect( qic, SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
+ qApp, SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
+ TQObject::connect( qic, SIGNAL(deletionRequested()),
+ icWidget, SLOT(destroyInputContext()) );
+ }
+}
+
+
+/*!
+ \internal
+ This is an internal function, you should never call this.
+
+ This function is called to generate an input context
+ according to a configuration for default input method
+
+ When QT_NO_IM_EXTENSIONS is not set, input context is
+ generated only when isInputMethodEnabled() returns TRUE.
+*/
+void TQWidget::createInputContext()
+{
+// #if !defined(QT_NO_IM_EXTENSIONS)
+ if( !isInputMethodEnabled() || TQApplication::closingDown() )
+ return;
+// #endif
+
+ TQWidget *icWidget = icHolderWidget();
+#ifndef QT_NO_IM
+#if !defined(QT_NO_IM_EXTENSIONS)
+ TQInputContext **qicp = &icWidget->ic;
+#else
+ TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic;
+#endif
+
+ if ( ! *qicp ) {
+ // an input context of the default input method is generated.
+ TQInputContext *qic = TQInputContextFactory::create( TQApplication::defaultInputMethod(), icWidget );
+
+ *qicp = qic;
+ if ( qic ) {
+ TQObject::connect( qic, SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
+ qApp, SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
+ TQObject::connect( qic, SIGNAL(deletionRequested()),
+ icWidget, SLOT(destroyInputContext()) );
+ }
+ }
+#endif // QT_NO_IM
+}
+
+
+/*!
+ \internal
+
+ This slot is used to destroy the input context that belonging
+ to the widget itself, so icHolderWidget()->ic is not fetched.
+
+ \sa TQInputContext::deletionRequested()
+*/
+void TQWidget::destroyInputContext()
+{
+#ifndef QT_NO_IM
+#if !defined(QT_NO_IM_EXTENSIONS)
+ TQInputContext **qicp = &ic;
+#else
+ if ( ! extra || ! extra->topextra )
+ return;
+
+ TQInputContext **qicp = (TQInputContext **)&extra->topextra->xic;
+#endif
+
+ if( *qicp )
+ delete *qicp;
+
+ *qicp = 0;
+#endif // QT_NO_IM
+}
+
+
+/*!
+ This function is called when text widgets need to be neutral state to
+ execute text operations properly. See qlineedit.cpp and qtextedit.cpp as
+ example.
+
+ Ordinary reset that along with changing focus to another widget,
+ moving the cursor, etc, is implicitly handled via
+ unfocusInputContext() because whether reset or not when such
+ situation is a responsibility of input methods. So we delegate the
+ responsibility to the input context via unfocusInputContext(). See
+ 'Preedit preservation' section of the class description of
+ TQInputContext for further information.
+
+ \sa TQInputContext, unfocusInputContext(), TQInputContext::unsetFocus()
+*/
+void TQWidget::resetInputContext()
+{
+#ifndef QT_NO_IM
+ // trigger input context creation if it hasn't happened already
+ createInputContext();
+
+ TQInputContext *qic = getInputContext();
+ if( qic )
+ qic->reset();
+#endif // QT_NO_IM
+}
+
+
+/*!
+ \internal
+ This is an internal function, you should never call this.
+
+ This function is called to focus associated input context. The
+ code intends to eliminate duplicate focus for the context even if
+ the context is shared between widgets
+
+ \sa TQInputContext::setFocus()
+ */
+void TQWidget::focusInputContext()
+{
+#ifndef QT_NO_IM
+ TQWidget* tlw = topLevelWidget();
+
+ if (!tlw->isPopup() || isInputMethodEnabled()) {
+ // trigger input context creation if it hasn't happened already
+ createInputContext();
+
+ TQInputContext *qic = getInputContext();
+ if ( qic ) {
+ if( qic->focusWidget() != this ) {
+ qic->setFocusWidget( this );
+ qic->setFocus();
+ }
+ }
+ }
+#endif // QT_NO_IM
+}
+
+
+/*!
+ \internal
+ This is an internal function, you should never call this.
+
+ This function is called to remove focus from associated input
+ context.
+
+ \sa TQInputContext::unsetFocus()
+ */
+void TQWidget::unfocusInputContext()
+{
+#ifndef QT_NO_IM
+ // trigger input context creation if it hasn't happened already
+ createInputContext();
+
+ TQInputContext *qic = getInputContext();
+ if ( qic ) {
+ // may be caused reset() in some input methods
+ qic->unsetFocus();
+ qic->setFocusWidget( 0 );
+ }
+#endif // QT_NO_IM
+}
+
+
+/*!
+ This function is called to send mouse event to associated input
+ context by derived text widgets. A derived text widget must be
+ calculate \a x as character offset at the mouse cursor in the
+ preedit.
+
+ \sa TQInputContext::mouseHandler()
+ */
+void TQWidget::sendMouseEventToInputContext( int x, TQEvent::Type type,
+ TQt::ButtonState button,
+ TQt::ButtonState state )
+{
+#ifndef QT_NO_IM
+ // trigger input context creation if it hasn't happened already
+ createInputContext();
+
+ TQInputContext *qic = getInputContext();
+ if ( qic ) {
+ // may be causing reset() in some input methods
+ qic->mouseHandler( x, type, button, state );
+ }
+#endif // QT_NO_IM
+}
+
+
+void TQWidget::setWindowOpacity(double)
+{
+}
+
+double TQWidget::windowOpacity() const
+{
+ return 1.0;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-14 21:18:37 +0000