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( topLevelWidget(), "xembed_focus" );
00620 d->focusProxy->setGeometry( -1, -1, 1, 1 );
00621 d->focusProxy->show();
00622
00623 QApplication::sendPostedEvents( d->focusProxy, 0 );
00624
00625
00626
00627 initialize();
00628 window = 0;
00629 setFocusPolicy(StrongFocus);
00630 setKeyCompression( false );
00631
00632
00633 (void) topData();
00634
00635
00636
00637
00638 XSelectInput(qt_xdisplay(), winId(),
00639 KeyPressMask | KeyReleaseMask |
00640 ButtonPressMask | ButtonReleaseMask |
00641 KeymapStateMask |
00642 ButtonMotionMask |
00643 PointerMotionMask |
00644 EnterWindowMask | LeaveWindowMask |
00645 FocusChangeMask |
00646 ExposureMask |
00647 StructureNotifyMask |
00648 SubstructureRedirectMask |
00649 SubstructureNotifyMask
00650 );
00651
00652
00653
00654 topLevelWidget()->installEventFilter( this );
00655 qApp->installEventFilter( this );
00656
00657
00658
00659 if ( qApp->activeWindow() == topLevelWidget() )
00660 if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00661 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00662 RevertToParent, qt_x_time );
00663
00664 setAcceptDrops( true );
00665 }
00666
00667
00668 QXEmbed::~QXEmbed()
00669 {
00670
00671 if ( d && d->xgrab)
00672 XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
00673 if ( window && ( autoDelete() || !d->xplain ))
00674 {
00675
00676
00677
00678 #if 0
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689 #else
00690 if( autoDelete())
00691 XUnmapWindow( qt_xdisplay(), window );
00692 #endif
00693 XReparentWindow(qt_xdisplay(), window, qt_xrootwin(), 0, 0);
00694 if( !d->xplain )
00695 XRemoveFromSaveSet( qt_xdisplay(), window );
00696 if( d->mapAfterRelease )
00697 XMapWindow( qt_xdisplay(), window );
00698 XSync(qt_xdisplay(), false);
00699
00700 if( autoDelete() )
00701
00702
00703
00704
00705 sendDelete();
00706 }
00707 window = 0;
00708
00709
00710 Window focus;
00711 int revert;
00712 XGetInputFocus( qt_xdisplay(), &focus, &revert );
00713 if( focus == d->focusProxy->winId())
00714 XSetInputFocus( qt_xdisplay(), topLevelWidget()->winId(), RevertToParent, qt_x_time );
00715
00716 delete d;
00717 }
00718
00719
00720
00721
00722
00723 void QXEmbed::sendDelete( void )
00724 {
00725 if (window)
00726 {
00727 sendClientMessage(window, qt_wm_protocols, qt_wm_delete_window);
00728 XFlush( qt_xdisplay() );
00729 }
00730 }
00731
00732
00733
00734
00735
00736
00737
00738
00739 void QXEmbed::setProtocol( Protocol proto )
00740 {
00741 if (!window) {
00742 d->xplain = false;
00743 if (proto == XPLAIN)
00744 d->xplain = true;
00745 }
00746 }
00747
00748
00749 QXEmbed::Protocol QXEmbed::protocol()
00750 {
00751 if (d->xplain)
00752 return XPLAIN;
00753 return XEMBED;
00754 }
00755
00756
00757
00758 void QXEmbed::resizeEvent(QResizeEvent*)
00759 {
00760 if (window)
00761 XResizeWindow(qt_xdisplay(), window, width(), height());
00762 }
00763
00764
00765 void QXEmbed::showEvent(QShowEvent*)
00766 {
00767 if (window)
00768 XMapRaised(qt_xdisplay(), window);
00769 }
00770
00771
00772
00773 bool QXEmbed::eventFilter( QObject *o, QEvent * e)
00774 {
00775
00776 switch ( e->type() ) {
00777 case QEvent::WindowActivate:
00778 if ( o == topLevelWidget() ) {
00779
00780
00781 if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00782 if (! hasFocus() )
00783 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00784 RevertToParent, qt_x_time );
00785 if (d->xplain)
00786
00787 checkGrab();
00788 else
00789
00790 sendXEmbedMessage( window, XEMBED_WINDOW_ACTIVATE );
00791 }
00792 break;
00793 case QEvent::WindowDeactivate:
00794 if ( o == topLevelWidget() ) {
00795 if (d->xplain)
00796
00797 checkGrab();
00798 else
00799
00800 sendXEmbedMessage( window, XEMBED_WINDOW_DEACTIVATE );
00801 }
00802 break;
00803 case QEvent::Move:
00804 {
00805 QWidget* pos = this;
00806 while( pos != o && pos != topLevelWidget())
00807 pos = pos->parentWidget();
00808 if( pos == o ) {
00809
00810
00811 QPoint globalPos = mapToGlobal(QPoint(0,0));
00812 if (globalPos != d->lastPos) {
00813 d->lastPos = globalPos;
00814 sendSyntheticConfigureNotifyEvent();
00815 }
00816 }
00817 }
00818 break;
00819 default:
00820 break;
00821 }
00822 return false;
00823 }
00824
00825
00826 bool QXEmbed::event( QEvent * e)
00827 {
00828 return QWidget::event( e );
00829 }
00830
00831
00832
00833
00834
00835
00836
00837 void QXEmbed::keyPressEvent( QKeyEvent *)
00838 {
00839 if (!window)
00840 return;
00841 last_key_event.window = window;
00842 XSendEvent(qt_xdisplay(), window, false, KeyPressMask, (XEvent*)&last_key_event);
00843
00844 }
00845
00846
00847
00848 void QXEmbed::keyReleaseEvent( QKeyEvent *)
00849 {
00850 if (!window)
00851 return;
00852 last_key_event.window = window;
00853 XSendEvent(qt_xdisplay(), window, false, KeyReleaseMask, (XEvent*)&last_key_event);
00854 }
00855
00856
00857 void QXEmbed::focusInEvent( QFocusEvent * e ){
00858 if (!window)
00859 return;
00860
00861
00862 if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00863 if ( qApp->activeWindow() == topLevelWidget() )
00864
00865
00866
00867 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00868 RevertToParent, qt_x_time );
00869 if (d->xplain) {
00870
00871 checkGrab();
00872
00873
00874
00875 sendFocusMessage(window, XFocusIn, NotifyNormal, NotifyPointer );
00876 } else {
00877
00878
00879 int detail = XEMBED_FOCUS_CURRENT;
00880
00881
00882
00883 if ( e->reason() == QFocusEvent::Tab )
00884 detail = XEMBED_FOCUS_FIRST;
00885 else if ( e->reason() == QFocusEvent::Backtab )
00886 detail = XEMBED_FOCUS_LAST;
00887 sendXEmbedMessage( window, XEMBED_FOCUS_IN, detail);
00888 }
00889 }
00890
00891
00892 void QXEmbed::focusOutEvent( QFocusEvent * ){
00893 if (!window)
00894 return;
00895 if (d->xplain) {
00896
00897 checkGrab();
00898
00899 sendFocusMessage(window, XFocusOut, NotifyNormal, NotifyPointer );
00900 } else {
00901
00902 sendXEmbedMessage( window, XEMBED_FOCUS_OUT );
00903 }
00904
00905
00906
00907
00908
00909
00910
00911 if ( !((QPublicWidget*) topLevelWidget())->topData()->embedded )
00912 if ( qApp->activeWindow() == topLevelWidget() )
00913
00914
00915
00916
00917 XSetInputFocus( qt_xdisplay(), d->focusProxy->winId(),
00918 RevertToParent, qt_x_time );
00919 }
00920
00921
00922
00923
00924 static bool wstate_withdrawn( WId winid )
00925 {
00926 Atom type;
00927 int format;
00928 unsigned long length, after;
00929 unsigned char *data;
00930 int r = XGetWindowProperty( qt_xdisplay(), winid, qt_wm_state, 0, 2,
00931 false, AnyPropertyType, &type, &format,
00932 &length, &after, &data );
00933 bool withdrawn = true;
00934
00935
00936 if ( r == Success && data && format == 32 ) {
00937 Q_UINT32 *wstate = (Q_UINT32*)data;
00938 withdrawn = (*wstate == WithdrawnState );
00939 XFree( (char *)data );
00940 }
00941 return withdrawn;
00942 }
00943
00944
00945
00946 static int get_parent(WId winid, Window *out_parent)
00947 {
00948 Window root, *children=0;
00949 unsigned int nchildren;
00950 int st = XQueryTree(qt_xdisplay(), winid, &root, out_parent, &children, &nchildren);
00951 if (st && children)
00952 XFree(children);
00953 return st;
00954 }
00955
00956
00957
00958 void QXEmbed::embed(WId w)
00959 {
00960 kdDebug() << "*** Embed " << w << " into " << winId() << ". window=" << window << endl;
00961 if (!w)
00962 return;
00963
00964
00965 bool has_window = (w == window);
00966 window = w;
00967 if ( !has_window ) {
00968 KXErrorHandler errhandler;
00969
00970
00971
00972 if ( !wstate_withdrawn(window) ) {
00973 XWithdrawWindow(qt_xdisplay(), window, qt_xscreen());
00974 QApplication::flushX();
00975
00976 for (int i=0; i < 10000; ++i) {
00977 if (wstate_withdrawn(window)) {
00978 Window parent = 0;
00979 get_parent(w, &parent);
00980 if (parent == qt_xrootwin()) break;
00981 }
00982 USLEEP(1000);
00983 }
00984 }
00985
00986
00987
00988
00989 Window parent = 0;
00990 get_parent(w, &parent);
00991 kdDebug() << QString("> before reparent: parent=0x%1").arg(parent,0,16) << endl;
00992 for (int i = 0; i < 50; i++) {
00993
00994
00995 if( !d->xplain )
00996 XAddToSaveSet( qt_xdisplay(), w );
00997 XReparentWindow(qt_xdisplay(), w, winId(), 0, 0);
00998 if (get_parent(w, &parent) && parent == winId()) {
00999 kdDebug() << QString("> Loop %1: ").arg(i)
01000 << QString("> reparent of 0x%1").arg(w,0,16)
01001 << QString(" into 0x%1").arg(winId(),0,16)
01002 << QString(" successful") << endl;
01003 break;
01004 }
01005 kdDebug() << QString("> Loop %1: ").arg(i)
01006 << QString("> reparent of 0x%1").arg(w,0,16)
01007 << QString(" into 0x%1").arg(winId(),0,16)
01008 << QString(" failed") << endl;
01009 USLEEP(1000);
01010 }
01011 if( parent != winId())
01012 window = 0;
01013 }
01014 }
01015
01016
01017
01018 WId QXEmbed::embeddedWinId() const
01019 {
01020 return window;
01021 }
01022
01023
01024
01025
01026 bool QXEmbed::focusNextPrevChild( bool next )
01027 {
01028 if ( window )
01029
01030
01031
01032
01033
01034
01035 return false;
01036 else
01037
01038 return QWidget::focusNextPrevChild( next );
01039 }
01040
01041
01042
01043 bool QXEmbed::x11Event( XEvent* e)
01044 {
01045 switch ( e->type ) {
01046 case DestroyNotify:
01047 if ( e->xdestroywindow.window == window ) {
01048
01049 window = 0;
01050 windowChanged( window );
01051 emit embeddedWindowDestroyed();
01052 }
01053 break;
01054 case ReparentNotify:
01055 if ( e->xreparent.window == d->focusProxy->winId() )
01056 break;
01057 if ( window && e->xreparent.window == window &&
01058 e->xreparent.parent != winId() ) {
01059
01060 window = 0;
01061 windowChanged( window );
01062 emit embeddedWindowDestroyed();
01063
01064
01065
01066 if( !d->xplain )
01067 XRemoveFromSaveSet( qt_xdisplay(), window );
01068 } else if ( e->xreparent.parent == winId()){
01069
01070 window = e->xreparent.window;
01071
01072
01073 if( !d->xplain )
01074 XAddToSaveSet( qt_xdisplay(), window );
01075 XResizeWindow(qt_xdisplay(), window, width(), height());
01076 XMapRaised(qt_xdisplay(), window);
01077
01078 sendSyntheticConfigureNotifyEvent();
01079
01080 extraData()->xDndProxy = window;
01081 if ( parent() ) {
01082
01083
01084 QEvent * layoutHint = new QEvent( QEvent::LayoutHint );
01085 QApplication::postEvent( parent(), layoutHint );
01086 }
01087 windowChanged( window );
01088 if (d->xplain) {
01089
01090 checkGrab();
01091 if ( hasFocus() )
01092
01093 sendFocusMessage(window, XFocusIn, NotifyNormal, NotifyPointer );
01094 } else {
01095
01096 sendXEmbedMessage( window, XEMBED_EMBEDDED_NOTIFY, 0, (long) winId() );
01097 if (isActiveWindow())
01098 sendXEmbedMessage( window, XEMBED_WINDOW_ACTIVATE);
01099 else
01100 sendXEmbedMessage( window, XEMBED_WINDOW_DEACTIVATE);
01101 if ( hasFocus() )
01102 sendXEmbedMessage( window, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT );
01103 }
01104 }
01105 break;
01106 case ButtonPress:
01107 if (d->xplain && d->xgrab) {
01108
01109
01110 QFocusEvent::setReason( QFocusEvent::Mouse );
01111 setFocus();
01112 QFocusEvent::resetReason();
01113
01114 XAllowEvents(qt_xdisplay(), ReplayPointer, CurrentTime);
01115
01116 return true;
01117 }
01118 break;
01119 case ButtonRelease:
01120 if (d->xplain && d->xgrab) {
01121
01122 XAllowEvents(qt_xdisplay(), SyncPointer, CurrentTime);
01123 return true;
01124 }
01125 break;
01126 case MapRequest:
01127
01128 if ( window && e->xmaprequest.window == window )
01129 XMapRaised(qt_xdisplay(), window );
01130 break;
01131 case ClientMessage:
01132
01133
01134 if ( e->xclient.format == 32 && e->xclient.message_type == xembed ) {
01135 long message = e->xclient.data.l[1];
01136 switch ( message ) {
01137
01138
01139
01140 case XEMBED_FOCUS_NEXT:
01141 QWidget::focusNextPrevChild( true );
01142 break;
01143 case XEMBED_FOCUS_PREV:
01144 QWidget::focusNextPrevChild( false );
01145 break;
01146
01147 case XEMBED_REQUEST_FOCUS:
01148 if( ((QPublicWidget*)topLevelWidget())->topData()->embedded ) {
01149 WId window = ((QPublicWidget*)topLevelWidget())->topData()->parentWinId;
01150 sendXEmbedMessage( window, XEMBED_REQUEST_FOCUS );
01151 } else {
01152 QFocusEvent::setReason( QFocusEvent::Mouse );
01153 setFocus();
01154 QFocusEvent::resetReason();
01155 }
01156 break;
01157 default:
01158 break;
01159 }
01160 }
01161 break;
01162
01163 case ConfigureRequest:
01164
01165
01166 if (e->xconfigurerequest.window == window)
01167 {
01168 sendSyntheticConfigureNotifyEvent();
01169 }
01170 break;
01171 case MotionNotify:
01172
01173 case EnterNotify:
01174
01175 if ( QWhatsThis::inWhatsThisMode() )
01176 enterWhatsThisMode();
01177 break;
01178 default:
01179 break;
01180 }
01181 return false;
01182 }
01183
01184
01185
01186
01187 void QXEmbed::enterWhatsThisMode()
01188 {
01189
01190
01191
01192
01193 QWhatsThis::leaveWhatsThisMode();
01194 if ( !context_help )
01195 context_help = XInternAtom( x11Display(), "_NET_WM_CONTEXT_HELP", false );
01196 sendClientMessage(window , qt_wm_protocols, context_help );
01197 }
01198
01199
01200
01201 void QXEmbed::windowChanged( WId )
01202 {
01203 }
01204
01205
01206
01207
01208 bool QXEmbed::processClientCmdline( QWidget* client, int& argc, char ** argv )
01209 {
01210 int myargc = argc;
01211 WId window = 0;
01212 int i, j;
01213
01214 j = 1;
01215 for ( i=1; i<myargc; i++ ) {
01216 if ( argv[i] && *argv[i] != '-' ) {
01217 argv[j++] = argv[i];
01218 continue;
01219 }
01220 QCString arg = argv[i];
01221 if ( !strcmp(arg,"-embed") && i < myargc-1 ) {
01222 QCString s = argv[++i];
01223 window = s.toInt();
01224 } else
01225 argv[j++] = argv[i];
01226 }
01227 argc = j;
01228
01229 if ( window ) {
01230 embedClientIntoWindow( client, window );
01231 return true;
01232 }
01233
01234 return false;
01235 }
01236
01237
01238
01239
01240 void QXEmbed::embedClientIntoWindow(QWidget* client, WId window)
01241 {
01242 initialize();
01243 XReparentWindow(qt_xdisplay(), client->winId(), window, 0, 0);
01244
01245 ((QXEmbed*)client)->topData()->embedded = true;
01246 ((QXEmbed*)client)->topData()->parentWinId = window;
01247
01248
01249 client->show();
01250 }
01251
01252
01253
01254
01255
01256 QSizePolicy QXEmbed::sizePolicy() const
01257 {
01258 return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
01259 }
01260
01261
01262
01263 QSize QXEmbed::sizeHint() const
01264 {
01265 return minimumSizeHint();
01266 }
01267
01268
01269 QSize QXEmbed::minimumSizeHint() const
01270 {
01271 int minw = 0;
01272 int minh = 0;
01273 if ( window ) {
01274 XSizeHints size;
01275 long msize;
01276 if (XGetWMNormalHints(qt_xdisplay(), window, &size, &msize)
01277 && ( size.flags & PMinSize) ) {
01278 minw = size.min_width;
01279 minh = size.min_height;
01280 }
01281 }
01282
01283 return QSize( minw, minh );
01284 }
01285
01286
01287
01288 void QXEmbed::setAutoDelete( bool b)
01289 {
01290 d->autoDelete = b;
01291 }
01292
01293
01294 bool QXEmbed::autoDelete() const
01295 {
01296 return d->autoDelete;
01297 }
01298
01299
01300 bool QXEmbed::customWhatsThis() const
01301 {
01302 return true;
01303 }
01304
01305
01306
01307
01308
01309
01310 void QXEmbed::checkGrab()
01311 {
01312 if (d->xplain && isActiveWindow() && !hasFocus()) {
01313 if (! d->xgrab)
01314 XGrabButton(qt_xdisplay(), AnyButton, AnyModifier, winId(),
01315 false, ButtonPressMask, GrabModeSync, GrabModeAsync,
01316 None, None );
01317 d->xgrab = true;
01318 } else {
01319 if (d->xgrab)
01320 XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
01321 d->xgrab = false;
01322 }
01323 }
01324
01325
01326
01327 void QXEmbed::sendSyntheticConfigureNotifyEvent()
01328 {
01329
01330
01331
01332 QPoint globalPos = mapToGlobal(QPoint(0,0));
01333 if (window) {
01334 #if 0
01335 XConfigureEvent c;
01336 memset(&c, 0, sizeof(c));
01337 c.type = ConfigureNotify;
01338 c.display = qt_xdisplay();
01339 c.send_event = True;
01340 c.event = window;
01341 c.window = window;
01342 c.x = globalPos.x();
01343 c.y = globalPos.y();
01344 c.width = width();
01345 c.height = height();
01346 c.border_width = 0;
01347 c.above = None;
01348 c.override_redirect = 0;
01349 XSendEvent( qt_xdisplay(), c.event, true, StructureNotifyMask, (XEvent*)&c );
01350 #endif
01351
01352 XSetWindowBorderWidth( qt_xdisplay(), window, 1 );
01353 XSetWindowBorderWidth( qt_xdisplay(), window, 0 );
01354 }
01355 }
01356
01357
01358 void QXEmbed::reparent( QWidget * parent, WFlags f, const QPoint & p, bool showIt )
01359 {
01360
01361
01362
01363
01364 Q_ASSERT( !window );
01365 QWidget::reparent( parent, f, p, showIt );
01366 }
01367
01368
01369 #include "qxembed.moc"
01370 #endif // Q_WS_X11