/**************************************************************************** ** ** 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 requirements 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 sales@trolltech.com. ** ** 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 "ntqapplication.h" #include "qapplication_p.h" #include "ntqnamespace.h" #include "ntqpaintdevicemetrics.h" #include "ntqpainter.h" #include "ntqbitmap.h" #include "ntqimage.h" #include "ntqobjectlist.h" #include "ntqlayout.h" #include "ntqtextcodec.h" #include "ntqdatetime.h" #include "ntqcursor.h" #include "qt_x11_p.h" #include // 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 "ntqinputcontext.h" #include "ntqinputcontextfactory.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 tqt_x_time; extern Time tqt_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 tqt_has_xft; int qt_x11_create_desktop_on_screen = -1; /***************************************************************************** TQWidget member functions *****************************************************************************/ // defined in qapplication_x11.cpp extern Atom tqt_wm_state; extern Atom qt_wm_change_state; extern Atom tqt_wm_delete_window; extern Atom tqt_wm_take_focus; extern Atom qt_wm_client_leader; extern Atom tqt_window_role; extern Atom tqt_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_action; extern Atom qt_net_wm_action_move; extern Atom qt_net_wm_action_resize; extern Atom qt_net_wm_action_minimize; extern Atom qt_net_wm_action_shade; extern Atom qt_net_wm_action_stick; extern Atom qt_net_wm_action_max_h; extern Atom qt_net_wm_action_max_v; extern Atom qt_net_wm_action_fullscreen; extern Atom qt_net_wm_action_change_desktop; extern Atom qt_net_wm_action_close; extern Atom qt_net_wm_action_above; extern Atom qt_net_wm_action_below; 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 tqt_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 tqt_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 tqApp->syncX(); // non-busy wait } tqApp->x11ProcessEvent( &ev ); if ( XCheckTypedWindowEvent( w->x11Display(), w->winId(), ConfigureNotify, &ev ) ) tqApp->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 ( tqt_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 }; long net_winactions[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; int curr_winstate = 0; int curr_winaction = 0; // Add all default actions that cannot be turned off net_winactions[curr_winaction++] = qt_net_wm_action_stick; net_winactions[curr_winaction++] = qt_net_wm_action_fullscreen; net_winactions[curr_winaction++] = qt_net_wm_action_change_desktop; net_winactions[curr_winaction++] = qt_net_wm_action_above; net_winactions[curr_winaction++] = qt_net_wm_action_below; 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 ( testNFlags(WX11DisableResize) ) { mwmhints.functions |= (1L << 1); // MWM_FUNC_RESIZE mwmhints.functions |= (1L << 0); // MWM_FUNC_ALL mwmhints.flags |= (1L << 0); // MWM_HINTS_FUNCTIONS } else { net_winactions[curr_winaction++] = qt_net_wm_action_resize; } if ( testNFlags(WX11DisableMove) ) { mwmhints.functions |= (1L << 2); // MWM_FUNC_MOVE mwmhints.functions |= (1L << 0); // MWM_FUNC_ALL mwmhints.flags |= (1L << 0); // MWM_HINTS_FUNCTIONS } else { net_winactions[curr_winaction++] = qt_net_wm_action_move; } if ( testNFlags(WX11DisableMinimize) ) { mwmhints.functions |= (1L << 3); // MWM_FUNC_MINIMIZE mwmhints.functions |= (1L << 0); // MWM_FUNC_ALL mwmhints.flags |= (1L << 0); // MWM_HINTS_FUNCTIONS } else { net_winactions[curr_winaction++] = qt_net_wm_action_minimize; } if ( testNFlags(WX11DisableMaximize) ) { mwmhints.functions |= (1L << 4); // MWM_FUNC_MAXIMIZE mwmhints.functions |= (1L << 0); // MWM_FUNC_ALL mwmhints.flags |= (1L << 0); // MWM_HINTS_FUNCTIONS } else { net_winactions[curr_winaction++] = qt_net_wm_action_max_h; net_winactions[curr_winaction++] = qt_net_wm_action_max_v; } if ( testNFlags(WX11DisableClose) ) { mwmhints.functions |= (1L << 5); // MWM_FUNC_CLOSE mwmhints.functions |= (1L << 0); // MWM_FUNC_ALL mwmhints.flags |= (1L << 0); // MWM_HINTS_FUNCTIONS } else { net_winactions[curr_winaction++] = qt_net_wm_action_close; } if ( ! testNFlags(WX11DisableShade) ) { net_winactions[curr_winaction++] = qt_net_wm_action_shade; } 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 ); XClassHint class_hint; class_hint.res_name = (char *) tqAppName(); // application name class_hint.res_class = (char *) tqAppClass(); // application class XSetClassHint( dpy, id, &class_hint ); } 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 *) tqAppName(); // application name class_hint.res_class = (char *) tqAppClass(); // 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, tqAppName() ); Atom protocols[5]; int n = 0; protocols[n++] = tqt_wm_delete_window; // support del window protocol protocols[n++] = tqt_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_REQUEST 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); // 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_ALLOWED_ACTIONS if (curr_winaction > 0) XChangeProperty(dpy, id, qt_net_wm_action, XA_ATOM, 32, PropModeReplace, (unsigned char *) net_winactions, curr_winaction); else XDeleteProperty(dpy, id, qt_net_wm_action); #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; } else { // non-toplevel widgets don't have a frame, so no need to // update the strut fstrut_dirty = 0; } if (initializeWindow && (popup || (topLevel && !desktop))) { // properties set on all toplevel windows x11SetWindowType(); // set _NET_WM_PID long curr_pid = getpid(); XChangeProperty(dpy, id, qt_net_wm_pid, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &curr_pid, 1); // declare the widget's object name as window role XChangeProperty( dpy, id, tqt_window_role, XA_STRING, 8, PropModeReplace, (unsigned char *)name(), tqstrlen( name() ) ); // set client leader property if ( !qt_x11_wm_client_leader ) qt_x11_create_wm_client_leader(); XChangeProperty( dpy, id, qt_wm_client_leader, XA_WINDOW, 32, PropModeReplace, (unsigned char *)&qt_x11_wm_client_leader, 1 ); } 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 ) tqt_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()); 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 tqt_leave_modal( this ); else if ( testWFlags(WType_Popup) ) tqApp->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 ); TQ_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 ); tqt_x11_enforce_cursor( this ); XFlush( x11Display() ); } void TQWidget::unsetCursor() { if ( extra ) { delete extra->curs; extra->curs = 0; } if ( !isTopLevel() ) clearWState( WState_OwnCursor ); tqt_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 ) tqDebug( "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; TQPixmap* pm = NULL; if ( !pixmap.isNull() ) { if (pixmap.depth() == 24) { pm = new TQPixmap( pixmap ); } else { // With most window managers, only 24-bit icon pixmaps are allowed in the WM hints, otherwise corrupt icons will be displayed // Convert provided pixmaps to 24-bit here int w = pixmap.width(); int h = pixmap.height(); pm = new TQPixmap( pixmap.width(), pixmap.height(), 24 ); TQImage iconImage = pixmap.convertToImage(); // Load the new 24-bit RGB pixmap with data GC gc; pm->detach(); TQt::HANDLE pmHandle = pm->handle(); gc = XCreateGC(x11Display(), pmHandle, 0, 0); for (int y = 0; y < h; ++y) { TQRgb *ls = (TQRgb *)iconImage.scanLine( y ); for (int x = 0; x < w; ++x) { TQRgb l = ls[x]; int r = int( tqRed( l ) ); int g = int( tqGreen( l ) ); int b = int( tqBlue( l ) ); XSetForeground(x11Display(), gc, (r << 16) | (g << 8) | b ); XDrawPoint(x11Display(), pmHandle, gc, x, y); } } XFreeGC(x11Display(), gc); } 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, tqt_x_time ); #if defined(QT_CHECK_STATE) if ( status ) { const char *s = status == GrabNotViewable ? "\"GrabNotViewable\"" : status == AlreadyGrabbed ? "\"AlreadyGrabbed\"" : status == GrabFrozen ? "\"GrabFrozen\"" : status == GrabInvalidTime ? "\"GrabInvalidTime\"" : ""; tqWarning( "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 != this ) { 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(), tqt_x_time ); #if defined(QT_CHECK_STATE) if ( status ) { const char *s = status == GrabNotViewable ? "\"GrabNotViewable\"" : status == AlreadyGrabbed ? "\"AlreadyGrabbed\"" : status == GrabFrozen ? "\"GrabFrozen\"" : status == GrabInvalidTime ? "\"GrabInvalidTime\"" : ""; tqWarning( "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(), tqt_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 != this ) { if ( keyboardGrb ) { keyboardGrb->releaseKeyboard(); } XGrabKeyboard( x11Display(), winid, False, GrabModeAsync, GrabModeAsync, tqt_x_time ); keyboardGrb = this; } } } /*! Releases the keyboard grab. \sa grabKeyboard(), grabMouse(), releaseMouse() */ void TQWidget::releaseKeyboard() { if ( !qt_nograb() && keyboardGrb == this ) { XUngrabKeyboard( x11Display(), tqt_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, tqt_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(tqApp->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 (tqt_x_user_time != CurrentTime) { XChangeProperty(x11Display(), winId(), qt_net_wm_user_time, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &tqt_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() ); tqt_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()); tqt_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 ) tqWarning("TQWidget::setMinimumSize: minw=%d, minh=%d. The smallest allowed size is (0,0)", minw, minh); #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 ) { tqWarning("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 ) { tqWarning("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 = tqt_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()); 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) tqWarning( "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_REQUEST 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(), tqt_window_role, XA_STRING, 8, PropModeReplace, (unsigned char *)name, tqstrlen( 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) { tqWarning("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 tqApp->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 *)), tqApp, 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 *)), tqApp, 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 = ⁣ #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; }