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