You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tqt3/src/kernel/qwidget_x11.cpp

3160 lines
91 KiB

/****************************************************************************
**
** 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 <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 "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());
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
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 )
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 )
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());
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)
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 = &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;
}