00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
#include <qapplication.h>
00050
#include <qptrlist.h>
00051
#include <qptrdict.h>
00052
#include <qguardedptr.h>
00053
#include <qwhatsthis.h>
00054
#include <qfocusdata.h>
00055
00056
00057
#ifdef Q_WS_X11
00058
00059
# include <X11/X.h>
00060
# include <X11/Xlib.h>
00061
# include <X11/Xutil.h>
00062
# include <X11/Xatom.h>
00063
# define XK_MISCELLANY
00064
# define XK_LATIN1
00065
# include <X11/keysymdef.h>
00066
# include <kdebug.h>
00067
# include <kxerrorhandler.h>
00068
00069
00070
# include <config.h>
00071
# ifdef HAVE_UNISTD_H
00072
# include <unistd.h>
00073
# ifdef HAVE_USLEEP
00074
# define USLEEP(x) usleep(x)
00075
# else
00076
# define USLEEP(x) sleep(0)
00077
# endif
00078
# else
00079
# define USLEEP(x) sleep(0)
00080
# endif
00081
00082
# include "qxembed.h"
00083
00084
00085
# ifndef XK_ISO_Left_Tab
00086
# define XK_ISO_Left_Tab 0xFE20
00087
# endif
00088
00089
00090
const int XFocusOut = FocusOut;
00091
const int XFocusIn = FocusIn;
00092
const int XKeyPress = KeyPress;
00093
const int XKeyRelease = KeyRelease;
00094
# undef KeyRelease
00095
# undef KeyPress
00096
# undef FocusOut
00097
# undef FocusIn
00098
00099
00100
extern Atom qt_wm_protocols;
00101
extern Atom qt_wm_delete_window;
00102
extern Atom qt_wm_take_focus;
00103
extern Atom qt_wm_state;
00104
extern Time qt_x_time;
00105
00106
00107
static Atom xembed = 0;
00108
static Atom context_help = 0;
00109
00110
00111
#define XEMBED_EMBEDDED_NOTIFY 0
00112
#define XEMBED_WINDOW_ACTIVATE 1
00113
#define XEMBED_WINDOW_DEACTIVATE 2
00114
#define XEMBED_REQUEST_FOCUS 3
00115
#define XEMBED_FOCUS_IN 4
00116
#define XEMBED_FOCUS_OUT 5
00117
#define XEMBED_FOCUS_NEXT 6
00118
#define XEMBED_FOCUS_PREV 7
00119
00120
00121
00122
#define XEMBED_FOCUS_CURRENT 0
00123
#define XEMBED_FOCUS_FIRST 1
00124
#define XEMBED_FOCUS_LAST 2
00125
00126
00127
00128
00129
class QXEmbedData
00130 {
00131
public:
00132 QXEmbedData(){
00133 autoDelete =
true;
00134 xplain =
false;
00135 xgrab =
false;
00136 mapAfterRelease =
false;
00137 lastPos =
QPoint(0,0);
00138 }
00139 ~QXEmbedData(){};
00140
00141
bool autoDelete;
00142
bool xplain;
00143
bool xgrab;
00144
bool mapAfterRelease;
00145
QWidget* focusProxy;
00146
QPoint lastPos;
00147 };
00148
00149
namespace
00150
{
00151
00152
00153
class QXEmbedAppFilter :
public QObject
00154 {
00155
public:
00156 QXEmbedAppFilter() { qApp->installEventFilter(
this ); }
00157 ~QXEmbedAppFilter() { };
00158
bool eventFilter(
QObject *,
QEvent * );
00159 };
00160 }
00161
00162
00163
static QXEmbedAppFilter* filter = 0;
00164
00165
static QPtrDict<QGuardedPtr<QWidget> > *focusMap = 0;
00166
00167
static XKeyEvent last_key_event;
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
class QPublicWidget :
public QWidget
00178 {
00179
public:
00180 QTLWExtra* topData() {
return QWidget::topData(); }
00181
QFocusData *focusData(){
return QWidget::focusData(); }
00182
bool focusNextPrev(
bool b) {
return focusNextPrevChild(b); }
00183 };
00184
00185
00186
00187
typedef int (*QX11EventFilter) (XEvent*);
00188
extern QX11EventFilter qt_set_x11_event_filter (QX11EventFilter filter);
00189
static QX11EventFilter oldFilter = 0;
00190
00191
00192
00193
static void sendXEmbedMessage( WId window,
long message,
long detail = 0,
00194
long data1 = 0,
long data2 = 0)
00195 {
00196
if (!window)
return;
00197 XEvent ev;
00198 memset(&ev, 0,
sizeof(ev));
00199 ev.xclient.type = ClientMessage;
00200 ev.xclient.window = window;
00201 ev.xclient.message_type = xembed;
00202 ev.xclient.format = 32;
00203 ev.xclient.data.l[0] = qt_x_time;
00204 ev.xclient.data.l[1] = message;
00205 ev.xclient.data.l[2] = detail;
00206 ev.xclient.data.l[3] = data1;
00207 ev.xclient.data.l[4] = data2;
00208 XSendEvent(qt_xdisplay(), window,
false, NoEventMask, &ev);
00209 }
00210
00211
00212
00213
static void sendClientMessage(Window window, Atom a,
long x)
00214 {
00215
if (!window)
return;
00216 XEvent ev;
00217 memset(&ev, 0,
sizeof(ev));
00218 ev.xclient.type = ClientMessage;
00219 ev.xclient.window = window;
00220 ev.xclient.message_type = a;
00221 ev.xclient.format = 32;
00222 ev.xclient.data.l[0] = x;
00223 ev.xclient.data.l[1] = qt_x_time;
00224 XSendEvent(qt_xdisplay(), window,
false, NoEventMask, &ev);
00225 }
00226
00227
00228
00229
static void sendFocusMessage(Window window,
int type,
int mode,
int detail)
00230 {
00231
if (!window)
return;
00232 XEvent ev;
00233 memset(&ev, 0,
sizeof(ev));
00234 ev.xfocus.type = type;
00235 ev.xfocus.window = window;
00236 ev.xfocus.mode = mode;
00237 ev.xfocus.detail = detail;
00238 XSendEvent(qt_xdisplay(), window,
false, FocusChangeMask, &ev);
00239 }
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
bool QXEmbedAppFilter::eventFilter(
QObject *o,
QEvent * e)
00301 {
00302
static bool obeyFocus =
false;
00303
switch ( e->type() ) {
00304
case QEvent::MouseButtonPress:
00305
00306
if ( !((
QWidget*)o)->isActiveWindow() )
00307 obeyFocus =
true;
00308
break;
00309
case QEvent::FocusIn:
00310
00311
00312
00313
00314
if ( qApp->focusWidget() == o &&
00315 ((QPublicWidget*)qApp->focusWidget()->topLevelWidget())->topData()->embedded ) {
00316
QFocusEvent* fe = (
QFocusEvent*) e;
00317
if ( obeyFocus || fe->reason() == QFocusEvent::Mouse ||
00318 fe->reason() == QFocusEvent::Shortcut ) {
00319
00320
00321
00322
00323 WId window = ((QPublicWidget*)qApp->focusWidget()->topLevelWidget())->topData()->parentWinId;
00324 focusMap->remove( qApp->focusWidget()->topLevelWidget() );
00325 sendXEmbedMessage( window, XEMBED_REQUEST_FOCUS );
00326 }
else if ( fe->reason() == QFocusEvent::ActiveWindow ) {
00327
00328
00329
00330
00331
00332 focusMap->remove( qApp->focusWidget()->topLevelWidget() );
00333 focusMap->insert( qApp->focusWidget()->topLevelWidget(),
00334
new QGuardedPtr<QWidget>(qApp->focusWidget()->topLevelWidget()->focusWidget() ) );
00335
00336
00337 qApp->focusWidget()->clearFocus();
00338
00339 }
00340 obeyFocus =
false;
00341 }
00342
break;
00343
case QEvent::KeyPress:
00344
if (qApp->focusWidget() == o &&
00345 ((QPublicWidget*)qApp->focusWidget()->topLevelWidget())->topData()->embedded ) {
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
QKeyEvent *k = (
QKeyEvent *)e;
00359
QWidget *w = qApp->focusWidget();
00360
00361
bool res =
false;
00362
bool tabForward =
true;
00363
if ( !(k->state() & ControlButton || k->state() & AltButton) ) {
00364
if ( k->key() == Key_Backtab || (k->key() == Key_Tab && (k->state() & ShiftButton)) ) {
00365 QFocusEvent::setReason( QFocusEvent::Backtab );
00366 res = ((QPublicWidget*)w)->focusNextPrev( tabForward =
false );
00367 QFocusEvent::resetReason();
00368 }
else if ( k->key() == Key_Tab ) {
00369 QFocusEvent::setReason( QFocusEvent::Tab );
00370 res = ((QPublicWidget*)w)->focusNextPrev( tabForward =
true );
00371 QFocusEvent::resetReason();
00372 }
00373 }
00374
if (res) {
00375
00376
00377
QFocusData *fd = ((QPublicWidget*)w)->focusData();
00378 WId window = ((QPublicWidget*)w->topLevelWidget())->topData()->parentWinId;
00379
QWidget *cw = 0;
00380
QWidget *fw = fd->home();
00381
if (tabForward && window) {
00382
while (cw != w && cw != fw && cw != w->topLevelWidget())
00383 cw = fd->prev();
00384
if (cw != w)
00385 sendXEmbedMessage( window, XEMBED_FOCUS_NEXT );
00386 }
else if (window) {
00387
while (cw != w && cw != fw && cw != w->topLevelWidget())
00388 cw = fd->next();
00389
if (cw != w)
00390 sendXEmbedMessage( window, XEMBED_FOCUS_PREV );
00391 }
00392
00393
return true;
00394 }
00395 }
00396
break;
00397
default:
00398
break;
00399 }
00400
00401
return false;
00402 }
00403
00404
00405
00406
static int qxembed_x11_event_filter( XEvent* e)
00407 {
00408
switch ( e->type ) {
00409
case XKeyPress:
00410
case XKeyRelease: {
00411
00412 last_key_event = e->xkey;
00413
break;
00414 }
00415
case ClientMessage:
00416
if ( e->xclient.message_type == xembed ) {
00417
00418
00419 Time msgtime = (Time) e->xclient.data.l[0];
00420
long message = e->xclient.data.l[1];
00421
long detail = e->xclient.data.l[2];
00422
00423
if ( msgtime > qt_x_time )
00424 qt_x_time = msgtime;
00425
QWidget* w = QWidget::find( e->xclient.window );
00426
if ( !w )
00427
break;
00428
switch ( message) {
00429
case XEMBED_EMBEDDED_NOTIFY: {
00430
00431 QTLWExtra *extra = ((QPublicWidget*)w->topLevelWidget())->topData();
00432 extra->embedded = 1;
00433 extra->parentWinId = e->xclient.data.l[3];
00434 w->topLevelWidget()->show();
00435
break;
00436 }
00437
case XEMBED_WINDOW_ACTIVATE: {
00438
00439
00440
00441
00442
00443 XEvent ev;
00444 memset(&ev, 0,
sizeof(ev));
00445 ev.xfocus.display = qt_xdisplay();
00446 ev.xfocus.type = XFocusIn;
00447 ev.xfocus.window = w->topLevelWidget()->winId();
00448 ev.xfocus.mode = NotifyNormal;
00449 ev.xfocus.detail = NotifyAncestor;
00450 qApp->x11ProcessEvent( &ev );
00451 }
00452
break;
00453
case XEMBED_WINDOW_DEACTIVATE: {
00454
00455
00456
00457 XEvent ev;
00458 memset(&ev, 0,
sizeof(ev));
00459 ev.xfocus.display = qt_xdisplay();
00460 ev.xfocus.type = XFocusOut;
00461 ev.xfocus.window = w->topLevelWidget()->winId();
00462 ev.xfocus.mode = NotifyNormal;
00463 ev.xfocus.detail = NotifyAncestor;
00464 qApp->x11ProcessEvent( &ev );
00465 }
00466
break;
00467
case XEMBED_FOCUS_IN:
00468
00469 {
00470
00471
QWidget* focusCurrent = 0;
00472
QGuardedPtr<QWidget>* fw = focusMap->find( w->topLevelWidget() );
00473
if ( fw ) {
00474 focusCurrent = *fw;
00475
00476 focusMap->remove( w->topLevelWidget() );
00477 }
00478
switch ( detail ) {
00479
case XEMBED_FOCUS_CURRENT:
00480
00481
if ( focusCurrent )
00482 focusCurrent->setFocus();
00483
else if ( !w->topLevelWidget()->focusWidget() )
00484 w->topLevelWidget()->setFocus();
00485
break;
00486
case XEMBED_FOCUS_FIRST:
00487 {
00488
00489 QFocusEvent::setReason( QFocusEvent::Tab );
00490 w->topLevelWidget()->setFocus();
00491 ((QPublicWidget*)w->topLevelWidget())->focusNextPrev(
true);
00492 QFocusEvent::resetReason();
00493 }
00494
break;
00495
case XEMBED_FOCUS_LAST:
00496 {
00497
00498 QFocusEvent::setReason( QFocusEvent::Backtab );
00499 w->topLevelWidget()->setFocus();
00500 ((QPublicWidget*)w->topLevelWidget())->focusNextPrev(
false);
00501 QFocusEvent::resetReason();
00502 }
00503
break;
00504
default:
00505
break;
00506 }
00507 }
00508
break;
00509
case XEMBED_FOCUS_OUT:
00510
00511
00512
00513
if ( w->topLevelWidget()->focusWidget() ) {
00514 focusMap->insert( w->topLevelWidget(),
00515
new QGuardedPtr<QWidget>(w->topLevelWidget()->focusWidget() ) );
00516 w->topLevelWidget()->focusWidget()->clearFocus();
00517 }
00518
break;
00519
default:
00520
break;
00521 }
00522 }
else if ( e->xclient.format == 32 && e->xclient.message_type ) {
00523
if ( e->xclient.message_type == qt_wm_protocols ) {
00524
QWidget* w = QWidget::find( e->xclient.window );
00525
if ( !w )
00526
break;
00527
00528
00529
00530
00531
00532
00533
00534 Atom a = e->xclient.data.l[0];
00535
if ( a == qt_wm_take_focus ) {
00536
00537
if ( (ulong) e->xclient.data.l[1] > qt_x_time )
00538 qt_x_time = e->xclient.data.l[1];
00539
00540
00541
00542
00543
if ( w->isActiveWindow() ) {
00544
QEvent e( QEvent::WindowActivate );
00545 QApplication::sendEvent( w, &e );
00546 }
00547 }
00548 }
00549 }
00550
break;
00551
default:
00552
break;
00553 }
00554
00555
if ( oldFilter )
00556
return oldFilter( e );
00557
00558
return false;
00559 }
00560
00561
00562
00563
00564
00565
00566
00567
00568 void QXEmbed::initialize()
00569 {
00570
static bool is_initialized =
false;
00571
if ( is_initialized )
00572
return;
00573
00574
00575 xembed = XInternAtom( qt_xdisplay(),
"_XEMBED",
false );
00576
00577 oldFilter = qt_set_x11_event_filter( qxembed_x11_event_filter );
00578
00579 focusMap =
new QPtrDict<QGuardedPtr<QWidget> >;
00580 focusMap->setAutoDelete(
true );
00581
00582 filter =
new QXEmbedAppFilter;
00583
00584 is_initialized =
true;
00585 }
00586
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602
00603
00604
00605
00606
00607
00608 QXEmbed::QXEmbed(
QWidget *parent,
const char *name, WFlags f)
00609 :
QWidget(parent, name, f)
00610 {
00611
00612 d =
new QXEmbedData;
00613
00614
00615
00616
00617
00618
00619 d->focusProxy =
new QWidget(
this,
"xembed_focus" );
00620 d->focusProxy->setGeometry( -1, -1, 1, 1 );
00621
00622
00623
00624
initialize();
00625 window = 0;
00626 setFocusPolicy(StrongFocus);
00627 setKeyCompression(
false );
00628
00629
00630 (
void) topData();
00631
00632
00633
00634
00635 XSelectInput(qt_xdisplay(), winId(),
00636 KeyPressMask | KeyReleaseMask |
00637 ButtonPressMask | ButtonReleaseMask |
00638 KeymapStateMask |
00639 ButtonMotionMask |
00640 PointerMotionMask |
00641 EnterWindowMask | LeaveWindowMask |
00642 FocusChangeMask |
00643 ExposureMask |
00644 StructureNotifyMask |
00645 SubstructureRedirectMask |
00646 SubstructureNotifyMask
00647 );
00648
00649
00650
00651 topLevelWidget()->installEventFilter(
this );
00652 qApp->installEventFilter(
this );
00653
00654
00655
00656
if ( qApp->activeWindow() == topLevelWidget() )
00657
if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00658 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00659 RevertToParent, qt_x_time );
00660
00661 setAcceptDrops(
true );
00662 }
00663
00664
00665 QXEmbed::~QXEmbed()
00666 {
00667
00668
if ( d && d->xgrab)
00669 XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
00670
if ( window && (
autoDelete() || !d->xplain ))
00671 {
00672
00673
00674
00675
#if 0
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
#else
00687
if(
autoDelete())
00688 XUnmapWindow( qt_xdisplay(), window );
00689
#endif
00690
XReparentWindow(qt_xdisplay(), window, qt_xrootwin(), 0, 0);
00691
if( !d->xplain )
00692 XRemoveFromSaveSet( qt_xdisplay(), window );
00693
if( d->mapAfterRelease )
00694 XMapWindow( qt_xdisplay(), window );
00695 XSync(qt_xdisplay(),
false);
00696
00697
if(
autoDelete() )
00698
00699
00700
00701
00702
sendDelete();
00703 }
00704 window = 0;
00705
00706
00707 Window focus;
00708
int revert;
00709 XGetInputFocus( qt_xdisplay(), &focus, &revert );
00710
if( focus == d->focusProxy->winId())
00711 XSetInputFocus( qt_xdisplay(), topLevelWidget()->winId(), RevertToParent, qt_x_time );
00712
00713
delete d;
00714 }
00715
00716
00717
00718
00719
00720 void QXEmbed::sendDelete(
void )
00721 {
00722
if (window)
00723 {
00724 sendClientMessage(window, qt_wm_protocols, qt_wm_delete_window);
00725 XFlush( qt_xdisplay() );
00726 }
00727 }
00728
00729
00730
00731
00732
00733
00734
00735
00736 void QXEmbed::setProtocol( Protocol proto )
00737 {
00738
if (window == 0) {
00739 d->xplain =
false;
00740
if (proto == XPLAIN)
00741 d->xplain =
true;
00742 }
00743 }
00744
00745
00746 QXEmbed::Protocol
QXEmbed::protocol()
00747 {
00748
if (d->xplain)
00749
return XPLAIN;
00750
return XEMBED;
00751 }
00752
00753
00754
00755
void QXEmbed::resizeEvent(
QResizeEvent*)
00756 {
00757
if (window != 0)
00758 XResizeWindow(qt_xdisplay(), window, width(), height());
00759 }
00760
00761
00762
void QXEmbed::showEvent(
QShowEvent*)
00763 {
00764
if (window != 0)
00765 XMapRaised(qt_xdisplay(), window);
00766 }
00767
00768
00769
00770
bool QXEmbed::eventFilter(
QObject *o,
QEvent * e)
00771 {
00772
00773
switch ( e->type() ) {
00774
case QEvent::WindowActivate:
00775
if ( o == topLevelWidget() ) {
00776
00777
00778
if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00779
if (! hasFocus() )
00780 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00781 RevertToParent, qt_x_time );
00782
if (d->xplain)
00783
00784 checkGrab();
00785
else
00786
00787 sendXEmbedMessage( window, XEMBED_WINDOW_ACTIVATE );
00788 }
00789
break;
00790
case QEvent::WindowDeactivate:
00791
if ( o == topLevelWidget() ) {
00792
if (d->xplain)
00793
00794 checkGrab();
00795
else
00796
00797 sendXEmbedMessage( window, XEMBED_WINDOW_DEACTIVATE );
00798 }
00799
break;
00800
case QEvent::Move:
00801 {
00802
QWidget* pos =
this;
00803
while( pos != o && pos != topLevelWidget())
00804 pos = pos->parentWidget();
00805
if( pos == o ) {
00806
00807
00808
QPoint globalPos = mapToGlobal(
QPoint(0,0));
00809
if (globalPos != d->lastPos) {
00810 d->lastPos = globalPos;
00811 sendSyntheticConfigureNotifyEvent();
00812 }
00813 }
00814 }
00815
break;
00816
default:
00817
break;
00818 }
00819
return false;
00820 }
00821
00822
00823
bool QXEmbed::event(
QEvent * e)
00824 {
00825
return QWidget::event( e );
00826 }
00827
00828
00829
00830
00831
00832
00833
00834
void QXEmbed::keyPressEvent(
QKeyEvent *)
00835 {
00836
if (!window)
00837
return;
00838 last_key_event.window = window;
00839 XSendEvent(qt_xdisplay(), window,
false, KeyPressMask, (XEvent*)&last_key_event);
00840
00841 }
00842
00843
00844
00845
void QXEmbed::keyReleaseEvent(
QKeyEvent *)
00846 {
00847
if (!window)
00848
return;
00849 last_key_event.window = window;
00850 XSendEvent(qt_xdisplay(), window,
false, KeyReleaseMask, (XEvent*)&last_key_event);
00851 }
00852
00853
00854
void QXEmbed::focusInEvent(
QFocusEvent * e ){
00855
if (!window)
00856
return;
00857
00858
00859
if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00860
if ( qApp->activeWindow() == topLevelWidget() )
00861
00862
00863
00864 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00865 RevertToParent, qt_x_time );
00866
if (d->xplain) {
00867
00868 checkGrab();
00869
00870
00871
00872 sendFocusMessage(window, XFocusIn, NotifyNormal, NotifyPointer );
00873 }
else {
00874
00875
00876
int detail = XEMBED_FOCUS_CURRENT;
00877
00878
00879
00880
if ( e->reason() == QFocusEvent::Tab )
00881 detail = XEMBED_FOCUS_FIRST;
00882
else if ( e->reason() == QFocusEvent::Backtab )
00883 detail = XEMBED_FOCUS_LAST;
00884 sendXEmbedMessage( window, XEMBED_FOCUS_IN, detail);
00885 }
00886 }
00887
00888
00889
void QXEmbed::focusOutEvent(
QFocusEvent * ){
00890
if (!window)
00891
return;
00892
if (d->xplain) {
00893
00894 checkGrab();
00895
00896 sendFocusMessage(window, XFocusOut, NotifyNormal, NotifyPointer );
00897 }
else {
00898
00899 sendXEmbedMessage( window, XEMBED_FOCUS_OUT );
00900 }
00901
00902
00903
00904
00905
00906
00907
00908
if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00909
if ( qApp->activeWindow() == topLevelWidget() )
00910
00911
00912
00913
00914 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00915 RevertToParent, qt_x_time );
00916 }
00917
00918
00919
00920
00921
static bool wstate_withdrawn( WId winid )
00922 {
00923 Atom type;
00924
int format;
00925
unsigned long length, after;
00926
unsigned char *data;
00927
int r = XGetWindowProperty( qt_xdisplay(), winid, qt_wm_state, 0, 2,
00928
false, AnyPropertyType, &type, &format,
00929 &length, &after, &data );
00930
bool withdrawn =
true;
00931
00932
00933
if ( r == Success && data && format == 32 ) {
00934 Q_UINT32 *wstate = (Q_UINT32*)data;
00935 withdrawn = (*wstate == WithdrawnState );
00936 XFree( (
char *)data );
00937 }
00938
return withdrawn;
00939 }
00940
00941
00942
00943
static int get_parent(WId winid, Window *out_parent)
00944 {
00945 Window root, *children=0;
00946
unsigned int nchildren;
00947
int st = XQueryTree(qt_xdisplay(), winid, &root, out_parent, &children, &nchildren);
00948
if (st && children)
00949 XFree(children);
00950
return st;
00951 }
00952
00953
00954
00955 void QXEmbed::embed(WId w)
00956 {
00957
kdDebug() <<
"*** Embed " << w <<
" into " << winId() <<
". window=" << window <<
endl;
00958
if (!w)
00959
return;
00960
00961
00962
bool has_window = (w == window);
00963 window = w;
00964
if ( !has_window ) {
00965
KXErrorHandler errhandler;
00966
00967
00968
00969
if ( !wstate_withdrawn(window) ) {
00970 XWithdrawWindow(qt_xdisplay(), window, qt_xscreen());
00971 QApplication::flushX();
00972
00973
while (!wstate_withdrawn(window))
00974 USLEEP(1000);
00975 }
00976
00977
00978
00979
00980 Window parent = 0;
00981 get_parent(w, &parent);
00982
kdDebug() <<
QString(
"> before reparent: parent=0x%1").arg(parent,0,16) <<
endl;
00983
for (
int i = 0; i < 50; i++) {
00984
00985
00986
if( !d->xplain )
00987 XAddToSaveSet( qt_xdisplay(), w );
00988 XReparentWindow(qt_xdisplay(), w, winId(), 0, 0);
00989
if (get_parent(w, &parent) && parent == winId()) {
00990
kdDebug() <<
QString(
"> Loop %1: ").arg(i)
00991 <<
QString(
"> reparent of 0x%1").arg(w,0,16)
00992 <<
QString(
" into 0x%1").arg(winId(),0,16)
00993 <<
QString(
" successful") <<
endl;
00994
break;
00995 }
00996
kdDebug() <<
QString(
"> Loop %1: ").arg(i)
00997 <<
QString(
"> reparent of 0x%1").arg(w,0,16)
00998 <<
QString(
" into 0x%1").arg(winId(),0,16)
00999 <<
QString(
" failed") <<
endl;
01000 USLEEP(1000);
01001 }
01002
if( parent != winId())
01003 window = 0;
01004 }
01005 }
01006
01007
01008
01009 WId
QXEmbed::embeddedWinId()
const
01010
{
01011
return window;
01012 }
01013
01014
01015
01016
01017
bool QXEmbed::focusNextPrevChild(
bool next )
01018 {
01019
if ( window )
01020
01021
01022
01023
01024
01025
01026
return false;
01027
else
01028
01029
return QWidget::focusNextPrevChild( next );
01030 }
01031
01032
01033
01034
bool QXEmbed::x11Event( XEvent* e)
01035 {
01036
switch ( e->type ) {
01037
case DestroyNotify:
01038
if ( e->xdestroywindow.window == window ) {
01039
01040 window = 0;
01041
windowChanged( window );
01042 emit
embeddedWindowDestroyed();
01043 }
01044
break;
01045
case ReparentNotify:
01046
if ( e->xreparent.window == d->focusProxy->winId() )
01047
break;
01048
if ( window && e->xreparent.window == window &&
01049 e->xreparent.parent != winId() ) {
01050
01051 window = 0;
01052
windowChanged( window );
01053 emit
embeddedWindowDestroyed();
01054
01055
01056
01057
if( !d->xplain )
01058 XRemoveFromSaveSet( qt_xdisplay(), window );
01059 }
else if ( e->xreparent.parent == winId()){
01060
01061 window = e->xreparent.window;
01062
01063
01064
if( !d->xplain )
01065 XAddToSaveSet( qt_xdisplay(), window );
01066 XResizeWindow(qt_xdisplay(), window, width(), height());
01067 XMapRaised(qt_xdisplay(), window);
01068
01069 sendSyntheticConfigureNotifyEvent();
01070
01071 extraData()->xDndProxy = window;
01072
if ( parent() ) {
01073
01074
01075
QEvent * layoutHint =
new QEvent( QEvent::LayoutHint );
01076 QApplication::postEvent( parent(), layoutHint );
01077 }
01078
windowChanged( window );
01079
if (d->xplain) {
01080
01081 checkGrab();
01082
if ( hasFocus() )
01083
01084 sendFocusMessage(window, XFocusIn, NotifyNormal, NotifyPointer );
01085 }
else {
01086
01087 sendXEmbedMessage( window, XEMBED_EMBEDDED_NOTIFY, 0, (
long) winId() );
01088
if (isActiveWindow())
01089 sendXEmbedMessage( window, XEMBED_WINDOW_ACTIVATE);
01090
else
01091 sendXEmbedMessage( window, XEMBED_WINDOW_DEACTIVATE);
01092
if ( hasFocus() )
01093 sendXEmbedMessage( window, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT );
01094 }
01095 }
01096
break;
01097
case ButtonPress:
01098
if (d->xplain && d->xgrab) {
01099
01100
01101 QFocusEvent::setReason( QFocusEvent::Mouse );
01102 setFocus();
01103 QFocusEvent::resetReason();
01104
01105 XAllowEvents(qt_xdisplay(), ReplayPointer, CurrentTime);
01106
01107
return true;
01108 }
01109
break;
01110
case ButtonRelease:
01111
if (d->xplain && d->xgrab) {
01112
01113 XAllowEvents(qt_xdisplay(), SyncPointer, CurrentTime);
01114
return true;
01115 }
01116
break;
01117
case MapRequest:
01118
01119
if ( window && e->xmaprequest.window == window )
01120 XMapRaised(qt_xdisplay(), window );
01121
break;
01122
case ClientMessage:
01123
01124
01125
if ( e->xclient.format == 32 && e->xclient.message_type == xembed ) {
01126
long message = e->xclient.data.l[1];
01127
switch ( message ) {
01128
01129
01130
01131
case XEMBED_FOCUS_NEXT:
01132 QWidget::focusNextPrevChild(
true );
01133
break;
01134
case XEMBED_FOCUS_PREV:
01135 QWidget::focusNextPrevChild(
false );
01136
break;
01137
01138
case XEMBED_REQUEST_FOCUS:
01139
if( ((QPublicWidget*)topLevelWidget())->topData()->embedded ) {
01140 WId window = ((QPublicWidget*)topLevelWidget())->topData()->parentWinId;
01141 sendXEmbedMessage( window, XEMBED_REQUEST_FOCUS );
01142 }
else {
01143 QFocusEvent::setReason( QFocusEvent::Mouse );
01144 setFocus();
01145 QFocusEvent::resetReason();
01146 }
01147
break;
01148
default:
01149
break;
01150 }
01151 }
01152
break;
01153
01154
case ConfigureRequest:
01155
01156
01157
if (e->xconfigurerequest.window == window)
01158 {
01159 sendSyntheticConfigureNotifyEvent();
01160 }
01161
break;
01162
case MotionNotify:
01163
01164
case EnterNotify:
01165
01166
if ( QWhatsThis::inWhatsThisMode() )
01167 enterWhatsThisMode();
01168
break;
01169
default:
01170
break;
01171 }
01172
return false;
01173 }
01174
01175
01176
01177
01178
void QXEmbed::enterWhatsThisMode()
01179 {
01180
01181
01182
01183
01184 QWhatsThis::leaveWhatsThisMode();
01185
if ( !context_help )
01186 context_help = XInternAtom( x11Display(),
"_NET_WM_CONTEXT_HELP",
false );
01187 sendClientMessage(window , qt_wm_protocols, context_help );
01188 }
01189
01190
01191
01192 void QXEmbed::windowChanged( WId )
01193 {
01194 }
01195
01196
01197
01198
01199 bool QXEmbed::processClientCmdline(
QWidget* client,
int& argc,
char ** argv )
01200 {
01201
int myargc = argc;
01202 WId window = 0;
01203
int i, j;
01204
01205 j = 1;
01206
for ( i=1; i<myargc; i++ ) {
01207
if ( argv[i] && *argv[i] !=
'-' ) {
01208 argv[j++] = argv[i];
01209
continue;
01210 }
01211
QCString arg = argv[i];
01212
if ( strcmp(arg,
"-embed") == 0 && i < myargc-1 ) {
01213
QCString s = argv[++i];
01214 window = s.toInt();
01215 }
else
01216 argv[j++] = argv[i];
01217 }
01218 argc = j;
01219
01220
if ( window != 0 ) {
01221
embedClientIntoWindow( client, window );
01222
return true;
01223 }
01224
01225
return false;
01226 }
01227
01228
01229
01230
01231 void QXEmbed::embedClientIntoWindow(
QWidget* client, WId window)
01232 {
01233
initialize();
01234 XReparentWindow(qt_xdisplay(), client->winId(), window, 0, 0);
01235
01236 ((
QXEmbed*)client)->topData()->embedded =
true;
01237 ((
QXEmbed*)client)->topData()->parentWinId = window;
01238
01239
01240 client->show();
01241 }
01242
01243
01244
01245
01246
01247
QSizePolicy QXEmbed::sizePolicy()
const
01248
{
01249
return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
01250 }
01251
01252
01253
01254
QSize QXEmbed::sizeHint()
const
01255
{
01256
return minimumSizeHint();
01257 }
01258
01259
01260
QSize QXEmbed::minimumSizeHint()
const
01261
{
01262
int minw = 0;
01263
int minh = 0;
01264
if ( window ) {
01265 XSizeHints size;
01266
long msize;
01267
if (XGetWMNormalHints(qt_xdisplay(), window, &size, &msize)
01268 && ( size.flags & PMinSize) ) {
01269 minw = size.min_width;
01270 minh = size.min_height;
01271 }
01272 }
01273
01274
return QSize( minw, minh );
01275 }
01276
01277
01278
01279 void QXEmbed::setAutoDelete(
bool b)
01280 {
01281 d->autoDelete = b;
01282 }
01283
01284
01285 bool QXEmbed::autoDelete()
const
01286
{
01287
return d->autoDelete;
01288 }
01289
01290
01291
bool QXEmbed::customWhatsThis()
const
01292
{
01293
return true;
01294 }
01295
01296
01297
01298
01299
01300
01301
void QXEmbed::checkGrab()
01302 {
01303
if (d->xplain && isActiveWindow() && !hasFocus()) {
01304
if (! d->xgrab)
01305 XGrabButton(qt_xdisplay(), AnyButton, AnyModifier, winId(),
01306
false, ButtonPressMask, GrabModeSync, GrabModeAsync,
01307 None, None );
01308 d->xgrab =
true;
01309 }
else {
01310
if (d->xgrab)
01311 XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
01312 d->xgrab =
false;
01313 }
01314 }
01315
01316
01317
01318
void QXEmbed::sendSyntheticConfigureNotifyEvent()
01319 {
01320
01321
01322
01323
QPoint globalPos = mapToGlobal(
QPoint(0,0));
01324
if (window) {
01325 XConfigureEvent c;
01326 memset(&c, 0,
sizeof(c));
01327 c.type = ConfigureNotify;
01328 c.display = qt_xdisplay();
01329 c.send_event = True;
01330 c.event = window;
01331 c.window = winId();
01332 c.x = globalPos.x();
01333 c.y = globalPos.y();
01334 c.width = width();
01335 c.height = height();
01336 c.border_width = 0;
01337 c.above = None;
01338 c.override_redirect = 0;
01339 XSendEvent( qt_xdisplay(), c.event,
true, StructureNotifyMask, (XEvent*)&c );
01340 }
01341 }
01342
01343
01344
void QXEmbed::reparent(
QWidget * parent, WFlags f,
const QPoint & p,
bool showIt )
01345 {
01346
01347
01348
01349
01350 Q_ASSERT( window == 0 );
01351 QWidget::reparent( parent, f, p, showIt );
01352 }
01353
01354
01355
#include "qxembed.moc"
01356
#endif // Q_WS_X11