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) {
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)
00758 XResizeWindow(qt_xdisplay(), window, width(), height());
00759 }
00760
00761
00762 void QXEmbed::showEvent(QShowEvent*)
00763 {
00764 if (window)
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") && 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 ) {
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 );
01351 QWidget::reparent( parent, f, p, showIt );
01352 }
01353
01354
01355 #include "qxembed.moc"
01356 #endif // Q_WS_X11