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 while (!wstate_withdrawn(window))
00977 USLEEP(1000);
00978 }
00979
00980
00981
00982
00983 Window parent = 0;
00984 get_parent(w, &parent);
00985 kdDebug() << QString("> before reparent: parent=0x%1").arg(parent,0,16) << endl;
00986 for (int i = 0; i < 50; i++) {
00987
00988
00989 if( !d->xplain )
00990 XAddToSaveSet( qt_xdisplay(), w );
00991 XReparentWindow(qt_xdisplay(), w, winId(), 0, 0);
00992 if (get_parent(w, &parent) && parent == winId()) {
00993 kdDebug() << QString("> Loop %1: ").arg(i)
00994 << QString("> reparent of 0x%1").arg(w,0,16)
00995 << QString(" into 0x%1").arg(winId(),0,16)
00996 << QString(" successful") << endl;
00997 break;
00998 }
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(" failed") << endl;
01003 USLEEP(1000);
01004 }
01005 if( parent != winId())
01006 window = 0;
01007 }
01008 }
01009
01010
01011
01012 WId QXEmbed::embeddedWinId() const
01013 {
01014 return window;
01015 }
01016
01017
01018
01019
01020 bool QXEmbed::focusNextPrevChild( bool next )
01021 {
01022 if ( window )
01023
01024
01025
01026
01027
01028
01029 return false;
01030 else
01031
01032 return QWidget::focusNextPrevChild( next );
01033 }
01034
01035
01036
01037 bool QXEmbed::x11Event( XEvent* e)
01038 {
01039 switch ( e->type ) {
01040 case DestroyNotify:
01041 if ( e->xdestroywindow.window == window ) {
01042
01043 window = 0;
01044 windowChanged( window );
01045 emit embeddedWindowDestroyed();
01046 }
01047 break;
01048 case ReparentNotify:
01049 if ( e->xreparent.window == d->focusProxy->winId() )
01050 break;
01051 if ( window && e->xreparent.window == window &&
01052 e->xreparent.parent != winId() ) {
01053
01054 window = 0;
01055 windowChanged( window );
01056 emit embeddedWindowDestroyed();
01057
01058
01059
01060 if( !d->xplain )
01061 XRemoveFromSaveSet( qt_xdisplay(), window );
01062 } else if ( e->xreparent.parent == winId()){
01063
01064 window = e->xreparent.window;
01065
01066
01067 if( !d->xplain )
01068 XAddToSaveSet( qt_xdisplay(), window );
01069 XResizeWindow(qt_xdisplay(), window, width(), height());
01070 XMapRaised(qt_xdisplay(), window);
01071
01072 sendSyntheticConfigureNotifyEvent();
01073
01074 extraData()->xDndProxy = window;
01075 if ( parent() ) {
01076
01077
01078 QEvent * layoutHint = new QEvent( QEvent::LayoutHint );
01079 QApplication::postEvent( parent(), layoutHint );
01080 }
01081 windowChanged( window );
01082 if (d->xplain) {
01083
01084 checkGrab();
01085 if ( hasFocus() )
01086
01087 sendFocusMessage(window, XFocusIn, NotifyNormal, NotifyPointer );
01088 } else {
01089
01090 sendXEmbedMessage( window, XEMBED_EMBEDDED_NOTIFY, 0, (long) winId() );
01091 if (isActiveWindow())
01092 sendXEmbedMessage( window, XEMBED_WINDOW_ACTIVATE);
01093 else
01094 sendXEmbedMessage( window, XEMBED_WINDOW_DEACTIVATE);
01095 if ( hasFocus() )
01096 sendXEmbedMessage( window, XEMBED_FOCUS_IN, XEMBED_FOCUS_CURRENT );
01097 }
01098 }
01099 break;
01100 case ButtonPress:
01101 if (d->xplain && d->xgrab) {
01102
01103
01104 QFocusEvent::setReason( QFocusEvent::Mouse );
01105 setFocus();
01106 QFocusEvent::resetReason();
01107
01108 XAllowEvents(qt_xdisplay(), ReplayPointer, CurrentTime);
01109
01110 return true;
01111 }
01112 break;
01113 case ButtonRelease:
01114 if (d->xplain && d->xgrab) {
01115
01116 XAllowEvents(qt_xdisplay(), SyncPointer, CurrentTime);
01117 return true;
01118 }
01119 break;
01120 case MapRequest:
01121
01122 if ( window && e->xmaprequest.window == window )
01123 XMapRaised(qt_xdisplay(), window );
01124 break;
01125 case ClientMessage:
01126
01127
01128 if ( e->xclient.format == 32 && e->xclient.message_type == xembed ) {
01129 long message = e->xclient.data.l[1];
01130 switch ( message ) {
01131
01132
01133
01134 case XEMBED_FOCUS_NEXT:
01135 QWidget::focusNextPrevChild( true );
01136 break;
01137 case XEMBED_FOCUS_PREV:
01138 QWidget::focusNextPrevChild( false );
01139 break;
01140
01141 case XEMBED_REQUEST_FOCUS:
01142 if( ((QPublicWidget*)topLevelWidget())->topData()->embedded ) {
01143 WId window = ((QPublicWidget*)topLevelWidget())->topData()->parentWinId;
01144 sendXEmbedMessage( window, XEMBED_REQUEST_FOCUS );
01145 } else {
01146 QFocusEvent::setReason( QFocusEvent::Mouse );
01147 setFocus();
01148 QFocusEvent::resetReason();
01149 }
01150 break;
01151 default:
01152 break;
01153 }
01154 }
01155 break;
01156
01157 case ConfigureRequest:
01158
01159
01160 if (e->xconfigurerequest.window == window)
01161 {
01162 sendSyntheticConfigureNotifyEvent();
01163 }
01164 break;
01165 case MotionNotify:
01166
01167 case EnterNotify:
01168
01169 if ( QWhatsThis::inWhatsThisMode() )
01170 enterWhatsThisMode();
01171 break;
01172 default:
01173 break;
01174 }
01175 return false;
01176 }
01177
01178
01179
01180
01181 void QXEmbed::enterWhatsThisMode()
01182 {
01183
01184
01185
01186
01187 QWhatsThis::leaveWhatsThisMode();
01188 if ( !context_help )
01189 context_help = XInternAtom( x11Display(), "_NET_WM_CONTEXT_HELP", false );
01190 sendClientMessage(window , qt_wm_protocols, context_help );
01191 }
01192
01193
01194
01195 void QXEmbed::windowChanged( WId )
01196 {
01197 }
01198
01199
01200
01201
01202 bool QXEmbed::processClientCmdline( QWidget* client, int& argc, char ** argv )
01203 {
01204 int myargc = argc;
01205 WId window = 0;
01206 int i, j;
01207
01208 j = 1;
01209 for ( i=1; i<myargc; i++ ) {
01210 if ( argv[i] && *argv[i] != '-' ) {
01211 argv[j++] = argv[i];
01212 continue;
01213 }
01214 QCString arg = argv[i];
01215 if ( !strcmp(arg,"-embed") && i < myargc-1 ) {
01216 QCString s = argv[++i];
01217 window = s.toInt();
01218 } else
01219 argv[j++] = argv[i];
01220 }
01221 argc = j;
01222
01223 if ( window ) {
01224 embedClientIntoWindow( client, window );
01225 return true;
01226 }
01227
01228 return false;
01229 }
01230
01231
01232
01233
01234 void QXEmbed::embedClientIntoWindow(QWidget* client, WId window)
01235 {
01236 initialize();
01237 XReparentWindow(qt_xdisplay(), client->winId(), window, 0, 0);
01238
01239 ((QXEmbed*)client)->topData()->embedded = true;
01240 ((QXEmbed*)client)->topData()->parentWinId = window;
01241
01242
01243 client->show();
01244 }
01245
01246
01247
01248
01249
01250 QSizePolicy QXEmbed::sizePolicy() const
01251 {
01252 return QSizePolicy( QSizePolicy::Expanding, QSizePolicy::Expanding );
01253 }
01254
01255
01256
01257 QSize QXEmbed::sizeHint() const
01258 {
01259 return minimumSizeHint();
01260 }
01261
01262
01263 QSize QXEmbed::minimumSizeHint() const
01264 {
01265 int minw = 0;
01266 int minh = 0;
01267 if ( window ) {
01268 XSizeHints size;
01269 long msize;
01270 if (XGetWMNormalHints(qt_xdisplay(), window, &size, &msize)
01271 && ( size.flags & PMinSize) ) {
01272 minw = size.min_width;
01273 minh = size.min_height;
01274 }
01275 }
01276
01277 return QSize( minw, minh );
01278 }
01279
01280
01281
01282 void QXEmbed::setAutoDelete( bool b)
01283 {
01284 d->autoDelete = b;
01285 }
01286
01287
01288 bool QXEmbed::autoDelete() const
01289 {
01290 return d->autoDelete;
01291 }
01292
01293
01294 bool QXEmbed::customWhatsThis() const
01295 {
01296 return true;
01297 }
01298
01299
01300
01301
01302
01303
01304 void QXEmbed::checkGrab()
01305 {
01306 if (d->xplain && isActiveWindow() && !hasFocus()) {
01307 if (! d->xgrab)
01308 XGrabButton(qt_xdisplay(), AnyButton, AnyModifier, winId(),
01309 false, ButtonPressMask, GrabModeSync, GrabModeAsync,
01310 None, None );
01311 d->xgrab = true;
01312 } else {
01313 if (d->xgrab)
01314 XUngrabButton( qt_xdisplay(), AnyButton, AnyModifier, winId() );
01315 d->xgrab = false;
01316 }
01317 }
01318
01319
01320
01321 void QXEmbed::sendSyntheticConfigureNotifyEvent()
01322 {
01323
01324
01325
01326 QPoint globalPos = mapToGlobal(QPoint(0,0));
01327 if (window) {
01328 XConfigureEvent c;
01329 memset(&c, 0, sizeof(c));
01330 c.type = ConfigureNotify;
01331 c.display = qt_xdisplay();
01332 c.send_event = True;
01333 c.event = window;
01334 c.window = winId();
01335 c.x = globalPos.x();
01336 c.y = globalPos.y();
01337 c.width = width();
01338 c.height = height();
01339 c.border_width = 0;
01340 c.above = None;
01341 c.override_redirect = 0;
01342 XSendEvent( qt_xdisplay(), c.event, true, StructureNotifyMask, (XEvent*)&c );
01343 }
01344 }
01345
01346
01347 void QXEmbed::reparent( QWidget * parent, WFlags f, const QPoint & p, bool showIt )
01348 {
01349
01350
01351
01352
01353 Q_ASSERT( !window );
01354 QWidget::reparent( parent, f, p, showIt );
01355 }
01356
01357
01358 #include "qxembed.moc"
01359 #endif // Q_WS_X11