Merge branch 'master' of http://scm.trinitydesktop.org/scm/git/qt3

28 files changed, 1078 insertions, 560 deletions

diff --git a/src/kernel/qapplication.cpp b/src/kernel/qapplication.cpp
index 51aa247..5b43301 100644
--- a/src/kernel/qapplication.cpp
+++ b/src/kernel/qapplication.cpp
@@ -68,6 +68,7 @@
 #if defined(QT_THREAD_SUPPORT)
 #  include "qmutex.h"
 #  include "qthread.h"
+#  include <private/qthreadinstance_p.h>
 #endif // QT_THREAD_SUPPORT
 
 #include <stdlib.h>
@@ -383,7 +384,25 @@ Q_EXPORT Qt::HANDLE qt_get_application_thread_id()
 }
 #endif // QT_THREAD_SUPPORT
 
+#ifndef QT_THREAD_SUPPORT
 QEventLoop *QApplication::eventloop = 0;	// application event loop
+#endif
+
+#ifdef QT_THREAD_SUPPORT
+QEventLoop* QApplication::currentEventLoop() {
+	QThread* thread = QThread::currentThreadObject();
+	if (thread) {
+		if (thread->d) {
+			return thread->d->eventLoop;
+		}
+	}
+	return NULL;
+}
+#else
+QEventLoop* QApplication::currentEventLoop() {
+	return QApplication::eventloop;
+}
+#endif
 
 #ifndef QT_NO_ACCEL
 extern bool qt_dispatchAccelEvent( QWidget*, QKeyEvent* ); // def in qaccel.cpp
@@ -516,6 +535,41 @@ QClipboard	      *qt_clipboard = 0;	// global clipboard object
 #endif
 QWidgetList * qt_modal_stack=0;		// stack of modal widgets
 
+#ifdef QT_THREAD_SUPPORT
+// thread wrapper for the main() thread
+class QCoreApplicationThread : public QThread
+{
+public:
+    inline QCoreApplicationThread()
+    {
+        QThreadInstance::setCurrentThread(this);
+
+        // thread should be running and not finished for the lifetime
+        // of the application (even if QCoreApplication goes away)
+        d->running = true;
+        d->finished = false;
+        d->eventLoop = NULL;
+    }
+    inline ~QCoreApplicationThread()
+    {
+        // avoid warning from QThread
+        d->running = false;
+    }
+private:
+    inline void run()
+    {
+        // this function should never be called, it is implemented
+        // only so that we can instantiate the object
+        qFatal("QCoreApplicationThread: internal error");
+    }
+};
+
+static QCoreApplicationThread qt_main_thread;
+static QThread *mainThread() { return &qt_main_thread; }
+#else
+static QThread* mainThread() { return QThread::currentThread(); }
+#endif
+
 // Definitions for posted events
 struct QPostEvent {
     QPostEvent( QObject *r, QEvent *e ): receiver( r ), event( e ) {}
@@ -818,8 +872,8 @@ void QApplication::construct( int &argc, char **argv, Type type )
     initialize( argc, argv );
     if ( qt_is_gui_used )
 	qt_maxWindowRect = desktop()->rect();
-    if ( eventloop )
-	eventloop->appStartingUp();
+    if ( currentEventLoop() )
+	currentEventLoop()->appStartingUp();
 }
 
 /*!
@@ -874,8 +928,8 @@ QApplication::QApplication( Display* dpy, HANDLE visual, HANDLE colormap )
 
     if ( qt_is_gui_used )
 	qt_maxWindowRect = desktop()->rect();
-    if ( eventloop )
-	eventloop->appStartingUp();
+    if ( currentEventLoop() )
+	currentEventLoop()->appStartingUp();
 }
 
 /*!
@@ -916,13 +970,26 @@ QApplication::QApplication(Display *dpy, int argc, char **argv,
 
     if ( qt_is_gui_used )
 	qt_maxWindowRect = desktop()->rect();
-    if ( eventloop )
-	eventloop->appStartingUp();
+    if ( currentEventLoop() )
+	currentEventLoop()->appStartingUp();
 }
 
 
 #endif // Q_WS_X11
 
+#ifdef QT_THREAD_SUPPORT
+QThread* QApplication::guiThread() {
+	return mainThread();
+}
+
+bool QApplication::isGuiThread() {
+	return (QThread::currentThreadObject() == guiThread());
+}
+#else
+bool QApplication::isGuiThread() {
+	return true;
+}
+#endif
 
 void QApplication::init_precmdline()
 {
@@ -1030,8 +1097,8 @@ QApplication::~QApplication()
     }
 #endif
 
-    if ( eventloop )
-	eventloop->appClosingDown();
+    if ( currentEventLoop() )
+	currentEventLoop()->appClosingDown();
     if ( postRList ) {
 	QVFuncList::Iterator it = postRList->begin();
 	while ( it != postRList->end() ) {	// call post routines
@@ -2698,8 +2765,28 @@ bool QApplication::internalNotify( QObject *receiver, QEvent * e)
 
     }
 
-    if (!handled)
+    if (!handled) {
+#if defined(QT_THREAD_SUPPORT)
+	int locklevel = 0;
+	int llcount;
+	if (QApplication::qt_mutex) {
+	    QApplication::qt_mutex->lock();	// 1 of 2
+	    locklevel = qt_mutex->level() - 1;
+	    for (llcount=0; llcount<locklevel; llcount++) {
+		QApplication::qt_mutex->unlock();
+	    }
+	    QApplication::qt_mutex->unlock();	// 2 of 2
+	}
+#endif
 	consumed = receiver->event( e );
+#if defined(QT_THREAD_SUPPORT)
+	if (QApplication::qt_mutex) {
+	    for (llcount=0; llcount<locklevel; llcount++) {
+		QApplication::qt_mutex->lock();
+	    }
+	}
+#endif
+    }
     e->spont = FALSE;
     return consumed;
 }
@@ -2793,9 +2880,10 @@ void QApplication::processOneEvent()
 */
 QEventLoop *QApplication::eventLoop()
 {
-    if ( !eventloop && !is_app_closing )
+    if ( !currentEventLoop() && !is_app_closing ) {
 	(void) new QEventLoop( qApp, "default event loop" );
-    return eventloop;
+    }
+    return currentEventLoop();
 }
 
 
@@ -3263,8 +3351,23 @@ void QApplication::postEvent( QObject *receiver, QEvent *event )
     l->append( pe );
     globalPostedEvents->append( pe );
 
-    if (eventloop)
-	eventloop->wakeUp();
+#ifdef QT_THREAD_SUPPORT
+    if ( event->type() == QEvent::MetaCall ) {
+	// Wake up the receiver thread event loop
+	QThread* thread = receiver->contextThreadObject();
+	if (thread) {
+		if (thread->d) {
+			if (thread->d->eventLoop) {
+				thread->d->eventLoop->wakeUp();
+			}
+		}
+	}
+	return;
+    }
+#endif
+
+    if (currentEventLoop())
+	currentEventLoop()->wakeUp();
 }
 
 
@@ -3326,7 +3429,8 @@ void QApplication::sendPostedEvents( QObject *receiver, int event_type )
 		 && ( receiver == 0 // we send to all receivers
 		      || receiver == pe->receiver ) // we send to THAT receiver
 		 && ( event_type == 0 // we send all types
-		      || event_type == pe->event->type() ) ) { // we send THAT type
+		      || event_type == pe->event->type() ) // we send THAT type
+		 && ( (!pe->receiver) || (pe->receiver->contextThreadObject() == QThread::currentThreadObject()) ) ) { // only send if active thread is receiver object owning thread
 		// first, we diddle the event so that we can deliver
 		// it, and that noone will try to touch it later.
 		pe->event->posted = FALSE;
diff --git a/src/kernel/qapplication.h b/src/kernel/qapplication.h
index c34ff45..5611164 100644
--- a/src/kernel/qapplication.h
+++ b/src/kernel/qapplication.h
@@ -63,6 +63,7 @@ class QWSDecoration;
 
 #ifdef QT_THREAD_SUPPORT
 class QMutex;
+class QThread;
 #endif // QT_THREAD_SUPPORT
 
 
@@ -369,7 +370,9 @@ private:
 #ifndef QT_NO_CURSOR
     static QCursor  *app_cursor;
 #endif
+#ifndef QT_THREAD_SUPPORT
     static QEventLoop* eventloop;
+#endif
     static int	     app_tracking;
     static bool	     is_app_running;
     static bool	     is_app_closing;
@@ -425,6 +428,7 @@ private:
     static void      removePostedEvent( QEvent * );
     static void      removePostedEvents( QObject *receiver, int event_type );
 
+    friend class QObject;
     friend class QWidget;
     friend class QETWidget;
     friend class QDialog;
@@ -444,6 +448,15 @@ private: // Disabled copy constructor and operator=
     QApplication( const QApplication & );
     QApplication &operator=( const QApplication & );
 #endif
+
+private:
+    static QEventLoop* currentEventLoop();
+
+public:
+#ifdef QT_THREAD_SUPPORT
+    static QThread* guiThread();
+#endif
+    static bool isGuiThread();
 };
 
 inline int QApplication::argc() const
diff --git a/src/kernel/qapplication_x11.cpp b/src/kernel/qapplication_x11.cpp
index 2873b9e..c2c0288 100644
--- a/src/kernel/qapplication_x11.cpp
+++ b/src/kernel/qapplication_x11.cpp
@@ -430,7 +430,7 @@ static bool qt_x11EventFilter( XEvent* ev )
 //XIM		qt_xim			= 0;
 Q_EXPORT XIMStyle	qt_xim_style		= 0;
 Q_EXPORT XIMStyle	qt_xim_preferred_style	= 0;
-Q_EXPORT static XIMStyle xim_default_style	= XIMPreeditCallbacks | XIMStatusNothing;
+static XIMStyle xim_default_style	= XIMPreeditCallbacks | XIMStatusNothing;
 #endif
 
 Q_EXPORT int qt_ximComposingKeycode=0;
@@ -5889,7 +5889,7 @@ static Bool qt_net_wm_sync_request_scanner(Display*, XEvent* event, XPointer arg
 {
     return (event->type == ClientMessage && event->xclient.window == *(Window*)arg
         && event->xclient.message_type == qt_wm_protocols
-        && event->xclient.data.l[ 0 ] == qt_net_wm_sync_request );
+        && ((unsigned int)event->xclient.data.l[ 0 ]) == qt_net_wm_sync_request );
 }
 #endif
 
diff --git a/src/kernel/qdragobject.cpp b/src/kernel/qdragobject.cpp
index 4f3353b..d48d79f 100644
--- a/src/kernel/qdragobject.cpp
+++ b/src/kernel/qdragobject.cpp
@@ -1749,9 +1749,9 @@ QColorDrag::QColorDrag( QWidget *dragsource, const char *name )
 
 void QColorDrag::setColor( const QColor &col )
 {
-    short r = (col.red()   << 8) | col.red();
-    short g = (col.green() << 8) | col.green();
-    short b = (col.blue()  << 8) | col.blue();
+    unsigned short r = (col.red()   << 8) | col.red();
+    unsigned short g = (col.green() << 8) | col.green();
+    unsigned short b = (col.blue()  << 8) | col.blue();
 
     // make sure we transmit data in network order
     r = htons(r);
diff --git a/src/kernel/qevent.h b/src/kernel/qevent.h
index 6512b9a..9587b8f 100644
--- a/src/kernel/qevent.h
+++ b/src/kernel/qevent.h
@@ -137,6 +137,8 @@ public:
 	HelpRequest = 95,			// CE (?)  button pressed
 	WindowStateChange = 96,			// window state has changed
 	IconDrag = 97,                          // proxy icon dragged
+	MetaCall = 98,				// meta method call (internal)
+	ThreadChange = 99,			// thread changed
 	User = 1000,				// first user event id
 	MaxUser = 65535				// last user event id
     };
diff --git a/src/kernel/qeventloop.cpp b/src/kernel/qeventloop.cpp
index 1f6a130..5eadb9e 100644
--- a/src/kernel/qeventloop.cpp
+++ b/src/kernel/qeventloop.cpp
@@ -41,6 +41,11 @@
 #include "qapplication.h"
 #include "qdatetime.h"
 
+#ifdef QT_THREAD_SUPPORT
+#  include "qthread.h"
+#  include "qthreadinstance_p.h"
+#endif
+
 /*!
     \class QEventLoop
     \brief The QEventLoop class manages the event queue.
@@ -100,15 +105,27 @@ QEventLoop::QEventLoop( QObject *parent, const char *name )
     : QObject( parent, name )
 {
 #if defined(QT_CHECK_STATE)
-    if ( QApplication::eventloop )
-	qFatal( "QEventLoop: there must be only one event loop object. \nConstruct it before QApplication." );
-    // for now ;)
+    if ( QApplication::currentEventLoop() )
+	qFatal( "QEventLoop: there must be only one event loop object per thread. \nIf this is supposed to be the main GUI event loop, construct it before QApplication." );
+    if (!QThread::currentThreadObject()) {
+	qFatal( "QEventLoop: this object can only be used in threads constructed via QThread." );
+    }
 #endif // QT_CHECK_STATE
 
     d = new QEventLoopPrivate;
 
     init();
+
+#ifdef QT_THREAD_SUPPORT
+    QThread* thread = QThread::currentThreadObject();
+    if (thread) {
+        if (thread->d) {
+            thread->d->eventLoop = this;
+        }
+    }
+#else
     QApplication::eventloop = this;
+#endif
 }
 
 /*!
@@ -118,7 +135,16 @@ QEventLoop::~QEventLoop()
 {
     cleanup();
     delete d;
+#ifdef QT_THREAD_SUPPORT
+    QThread* thread = QThread::currentThreadObject();
+    if (thread) {
+        if (thread->d) {
+            thread->d->eventLoop = 0;
+        }
+    }
+#else
     QApplication::eventloop = 0;
+#endif
 }
 
 /*!
diff --git a/src/kernel/qeventloop.h b/src/kernel/qeventloop.h
index 25f80cd..a3ee01d 100644
--- a/src/kernel/qeventloop.h
+++ b/src/kernel/qeventloop.h
@@ -102,25 +102,6 @@ public:
 
     virtual void wakeUp();
 
-#ifdef Q_QDOC
-#else // Q_QDOC
-#if defined(QT_USE_GLIBMAINLOOP)
-	
-    // glib main loop support
-
-    /* internal: used to fit glib-main-loop gsource concept */
-
-    bool gsourcePrepare(GSource *gs, int * timeout);
-    bool gsourceCheck(GSource * gs);
-    bool gsourceDispatch(GSource * gs);
-
-    bool processX11Events();
-
-    // end glib main loop support
-	
-#endif //QT_USE_GLIBMAINLOOP
-#endif // Q_QDOC
-
     void setSingleToolkitEventHandling(bool enabled);
 
 signals:
@@ -145,6 +126,24 @@ private:
     QEventLoopPrivate *d;
 
     friend class QApplication;
+
+#ifdef Q_QDOC
+#else // Q_QDOC
+#if defined(QT_USE_GLIBMAINLOOP)
+
+    // glib main loop support
+    /* internal: used to fit glib-main-loop gsource concept */
+public:
+    bool gsourcePrepare(GSource *gs, int * timeout);
+    bool gsourceCheck(GSource * gs);
+    bool gsourceDispatch(GSource * gs);
+
+    bool processX11Events();
+
+    // end glib main loop support
+	
+#endif //QT_USE_GLIBMAINLOOP
+#endif // Q_QDOC
 };
 
 #endif // QEVENTLOOP_H
diff --git a/src/kernel/qeventloop_glib_p.h b/src/kernel/qeventloop_glib_p.h
index 7de324d..663f20e 100644
--- a/src/kernel/qeventloop_glib_p.h
+++ b/src/kernel/qeventloop_glib_p.h
@@ -84,49 +84,51 @@ struct QSockNotGPollFD
 class QEventLoopPrivate
 {
 public:
-    QEventLoopPrivate()
-    {
-	reset();
-    }
-
-    void reset() {
-        looplevel = 0;
-        quitcode = 0;
-        quitnow = FALSE;
-        exitloop = FALSE;
-        shortcut = FALSE;
-        singletoolkit = TRUE;
-    }
-
-    int looplevel;
-    int quitcode;
-    unsigned int quitnow  : 1;
-    unsigned int exitloop : 1;
-    unsigned int shortcut : 1;
-
+	QEventLoopPrivate()
+	{
 #if defined(Q_WS_X11)
-    int xfd;
-	
-	GPollFD x_gPollFD; 
-	
+		xfd = -1;
+		x_gPollFD.fd = -1;
 #endif // Q_WS_X11
+		reset();
+	}
+
+	void reset() {
+		looplevel = 0;
+		quitcode = 0;
+		quitnow = FALSE;
+		exitloop = FALSE;
+		shortcut = FALSE;
+		singletoolkit = TRUE;
+	}
+	
+	int looplevel;
+	int quitcode;
+	unsigned int quitnow  : 1;
+	unsigned int exitloop : 1;
+	unsigned int shortcut : 1;
 
-    int thread_pipe[2];
+#if defined(Q_WS_X11)
+	int xfd;
+	GPollFD x_gPollFD;
+#endif // Q_WS_X11
 
+	int thread_pipe[2];
 	GPollFD threadPipe_gPollFD;
-	
-    QPtrList<QSockNotGPollFD> sn_list;
-    // pending socket notifiers list
-    QPtrList<QSockNotGPollFD> sn_pending_list;
-	
+	QPtrList<QSockNotGPollFD> sn_list;
+
+	// pending socket notifiers list
+	QPtrList<QSockNotGPollFD> sn_pending_list;
+
 	// store flags for one iteration
-	uint pev_flags;  	
-	
+	uint pev_flags;
+
 	// My GSource
-	
 	GSource * gSource;
 	bool singletoolkit;
 
+	// main context
+	GMainContext *ctx;
 };
 
 #endif // QEVENTLOOP_GLIB_P_H
diff --git a/src/kernel/qeventloop_unix.cpp b/src/kernel/qeventloop_unix.cpp
index b0ad8b9..80c8f29 100644
--- a/src/kernel/qeventloop_unix.cpp
+++ b/src/kernel/qeventloop_unix.cpp
@@ -40,6 +40,7 @@
 #include "qeventloop.h"
 #include "qapplication.h"
 #include "qbitarray.h"
+#include "qmutex.h"
 #include <stdlib.h>
 #include <sys/types.h>
 
@@ -561,6 +562,8 @@ int QEventLoop::activateTimers()
 	    n_act++;
 	QTimerEvent e( t->id );
 	QApplication::sendEvent( t->obj, &e );	// send event
+	if ( !timerList )	// sendEvent allows other threads to execute, therefore we must check for list existence when it returns!
+	    return 0;
 	if ( timerList->findRef( begin ) == -1 )
 	    begin = 0;
     }
diff --git a/src/kernel/qeventloop_unix_glib.cpp b/src/kernel/qeventloop_unix_glib.cpp
index 6852f6b..6a890ce 100644
--- a/src/kernel/qeventloop_unix_glib.cpp
+++ b/src/kernel/qeventloop_unix_glib.cpp
@@ -44,6 +44,7 @@
 #include "qeventloop.h"
 #include "qapplication.h"
 #include "qbitarray.h"
+#include "qmutex.h"
 #include <stdlib.h>
 #include <sys/types.h>
 
@@ -369,9 +370,9 @@ void QEventLoop::registerSocketNotifier( QSocketNotifier *notifier )
          return;
     }
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("register socket notifier %d\n", sockfd);
-	#endif
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("register socket notifier %d\n", sockfd);
+#endif
 	
     QPtrList<QSockNotGPollFD>  *list = &d->sn_list;
     QSockNotGPollFD *sn;
@@ -424,9 +425,9 @@ void QEventLoop::unregisterSocketNotifier( QSocketNotifier *notifier )
          return;
     }
 	
-	#ifdef DEBUG_QT_GLIBMAINLOOP 
-		printf("unregister socket notifier %d\n", sockfd);
-	#endif	
+#ifdef DEBUG_QT_GLIBMAINLOOP 
+	printf("unregister socket notifier %d\n", sockfd);
+#endif	
 
     QPtrList<QSockNotGPollFD> *list = &d->sn_list;
     QSockNotGPollFD *sn;
@@ -457,9 +458,9 @@ void QEventLoop::setSocketNotifierPending( QSocketNotifier *notifier )
 	return;
     }
 	
-	#ifdef DEBUG_QT_GLIBMAINLOOP 
-		printf("set socket notifier pending %d\n", sockfd);
-	#endif	
+#ifdef DEBUG_QT_GLIBMAINLOOP 
+	printf("set socket notifier pending %d\n", sockfd);
+#endif	
 
     QPtrList<QSockNotGPollFD> *list = &d->sn_list;
     QSockNotGPollFD *sn;
@@ -505,7 +506,9 @@ void QEventLoop::wakeUp()
     size_t nbytes = 0;
     char c = 0;
     if ( ::ioctl( d->thread_pipe[0], FIONREAD, (char*)&nbytes ) >= 0 && nbytes == 0 ) {
-	::write(  d->thread_pipe[1], &c, 1  );
+	if (::write(  d->thread_pipe[1], &c, 1  ) < 0) {
+		// Failed!
+	}
     }
 }
 
@@ -576,17 +579,14 @@ int QEventLoop::activateSocketNotifiers()
     while ( (sn=it.current()) ) {
         ++it;
         d->sn_pending_list.removeRef( sn );
-        if ( sn->pending ) {
-			
-			#ifdef DEBUG_QT_GLIBMAINLOOP 
-				printf("activate sn  : send event fd=%d\n", sn->gPollFD.fd );
-			#endif	
-			
-			
-            sn->pending = FALSE;
-            QApplication::sendEvent( sn->obj, &event );
-            n_act++;
-	    }
+        if ( sn->pending ) {	
+#ifdef DEBUG_QT_GLIBMAINLOOP 
+		printf("activate sn  : send event fd=%d\n", sn->gPollFD.fd );
+#endif	
+		sn->pending = FALSE;
+		QApplication::sendEvent( sn->obj, &event );
+		n_act++;
+	}
     }
 
     return n_act;
diff --git a/src/kernel/qeventloop_x11.cpp b/src/kernel/qeventloop_x11.cpp
index 833be69..5ee41ca 100644
--- a/src/kernel/qeventloop_x11.cpp
+++ b/src/kernel/qeventloop_x11.cpp
@@ -146,55 +146,57 @@ bool QEventLoop::processEvents( ProcessEventsFlags flags )
     if ( qt_is_gui_used ) {
 	QApplication::sendPostedEvents();
 
-	// Two loops so that posted events accumulate
-	while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
-	    // also flushes output buffer
-	    while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
-		if ( d->shortcut ) {
-		    return FALSE;
-		}
-
-		XNextEvent( QPaintDevice::x11AppDisplay(), &event );
-
-		if ( flags & ExcludeUserInput ) {
-		    switch ( event.type ) {
-		    case ButtonPress:
-		    case ButtonRelease:
-		    case MotionNotify:
-		    case XKeyPress:
-		    case XKeyRelease:
-		    case EnterNotify:
-		    case LeaveNotify:
-			continue;
-
-		    case ClientMessage:
-			{
-			    // from qapplication_x11.cpp
-			    extern Atom qt_wm_protocols;
-			    extern Atom qt_wm_take_focus;
-			    extern Atom qt_qt_scrolldone;
-
-			    // only keep the wm_take_focus and
-			    // qt_qt_scrolldone protocols, discard all
-			    // other client messages
-			    if ( event.xclient.format != 32 )
-				continue;
-
-			    if ( event.xclient.message_type == qt_wm_protocols ||
-				 (Atom) event.xclient.data.l[0] == qt_wm_take_focus )
-				break;
-			    if ( event.xclient.message_type == qt_qt_scrolldone )
-				break;
+	if (QApplication::isGuiThread()) {
+		// Two loops so that posted events accumulate
+		while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
+			// also flushes output buffer
+			while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
+				if ( d->shortcut ) {
+					return FALSE;
+				}
+		
+				XNextEvent( QPaintDevice::x11AppDisplay(), &event );
+		
+				if ( flags & ExcludeUserInput ) {
+					switch ( event.type ) {
+						case ButtonPress:
+						case ButtonRelease:
+						case MotionNotify:
+						case XKeyPress:
+						case XKeyRelease:
+						case EnterNotify:
+						case LeaveNotify:
+							continue;
+				
+						case ClientMessage:
+							{
+							// from qapplication_x11.cpp
+							extern Atom qt_wm_protocols;
+							extern Atom qt_wm_take_focus;
+							extern Atom qt_qt_scrolldone;
+				
+							// only keep the wm_take_focus and
+							// qt_qt_scrolldone protocols, discard all
+							// other client messages
+							if ( event.xclient.format != 32 )
+								continue;
+				
+							if ( event.xclient.message_type == qt_wm_protocols ||
+								(Atom) event.xclient.data.l[0] == qt_wm_take_focus )
+								break;
+							if ( event.xclient.message_type == qt_qt_scrolldone )
+								break;
+							}
+				
+						default: break;
+					}
+				}
+		
+				nevents++;
+				if ( qApp->x11ProcessEvent( &event ) == 1 )
+				return TRUE;
 			}
-
-		    default: break;
-		    }
 		}
-
-		nevents++;
-		if ( qApp->x11ProcessEvent( &event ) == 1 )
-		    return TRUE;
-	    }
 	}
     }
 
@@ -261,7 +263,7 @@ bool QEventLoop::processEvents( ProcessEventsFlags flags )
 	FD_ZERO( &d->sn_vec[2].select_fds );
     }
 
-    if ( qt_is_gui_used ) {
+    if ( qt_is_gui_used && QApplication::isGuiThread() ) {
 	// select for events on the event socket - only on X11
 	FD_SET( d->xfd, &d->sn_vec[0].select_fds );
 	highest = QMAX( highest, d->xfd );
@@ -282,7 +284,8 @@ bool QEventLoop::processEvents( ProcessEventsFlags flags )
     // unlock the GUI mutex and select.  when we return from this function, there is
     // something for us to do
 #if defined(QT_THREAD_SUPPORT)
-    locker.mutex()->unlock();
+    if ( locker.mutex() ) locker.mutex()->unlock();
+    else return false;
 #endif
 
     int nsel;
@@ -296,7 +299,8 @@ bool QEventLoop::processEvents( ProcessEventsFlags flags )
 
     // relock the GUI mutex before processing any pending events
 #if defined(QT_THREAD_SUPPORT)
-    locker.mutex()->lock();
+    if ( locker.mutex() ) locker.mutex()->lock();
+    else return false;
 #endif
 
     // we are awake, broadcast it
diff --git a/src/kernel/qeventloop_x11_glib.cpp b/src/kernel/qeventloop_x11_glib.cpp
index 59ab8a1..877ff44 100644
--- a/src/kernel/qeventloop_x11_glib.cpp
+++ b/src/kernel/qeventloop_x11_glib.cpp
@@ -39,7 +39,6 @@
 **
 **********************************************************************/
 
-
 #include "qeventloop_glib_p.h" // includes qplatformdefs.h
 #include "qeventloop.h"
 #include "qapplication.h"
@@ -49,58 +48,85 @@
 
 #if defined(QT_THREAD_SUPPORT)
 #  include "qmutex.h"
+#  include "qthread.h"
 #endif // QT_THREAD_SUPPORT
 
 #include <errno.h>
 
 #include <glib.h>
 
+// #define DEBUG_QT_GLIBMAINLOOP 1
+
 // Qt-GSource Structure and Callbacks
 
 typedef struct {
-    GSource source;
-    QEventLoop * qeventLoop;
+	GSource source;
+	QEventLoop * qeventLoop;
 } QtGSource;
 
-static gboolean qt_gsource_prepare  ( GSource *source,
-	gint *timeout );
+static gboolean qt_gsource_prepare  ( GSource *source, gint *timeout );
 static gboolean qt_gsource_check    ( GSource *source );
-static gboolean qt_gsource_dispatch ( GSource *source,
-    GSourceFunc  callback, gpointer user_data );
+static gboolean qt_gsource_dispatch ( GSource *source, GSourceFunc  callback, gpointer user_data );
 
 static GSourceFuncs qt_gsource_funcs = {
-    qt_gsource_prepare,
-    qt_gsource_check,
-    qt_gsource_dispatch,
-    NULL,
-    NULL,
-    NULL
+	qt_gsource_prepare,
+	qt_gsource_check,
+	qt_gsource_dispatch,
+	NULL,
+	NULL,
+	NULL
 };
 
 // forward main loop callbacks to QEventLoop methods!
 
 static gboolean qt_gsource_prepare  ( GSource *source,
-	gint *timeout ) 
+	gint *timeout )
 {
-    QtGSource * qtGSource;
-	qtGSource = (QtGSource*) source;
-    return qtGSource->qeventLoop->gsourcePrepare(source, timeout); 
+	QtGSource * qtGSource = (QtGSource*) source;
+	QEventLoop* candidateEventLoop = qtGSource->qeventLoop;
+	QEventLoop* activeThreadEventLoop = QApplication::eventLoop();
+
+	if (candidateEventLoop == activeThreadEventLoop) {
+		return candidateEventLoop->gsourcePrepare(source, timeout);
+	}
+	else {
+		// Prepare failed
+		return FALSE;
+	}
 }
 
 static gboolean qt_gsource_check    ( GSource *source ) 
 {
-    QtGSource * qtGSource = (QtGSource*) source;
-    return qtGSource->qeventLoop->gsourceCheck(source); 
+	QtGSource * qtGSource = (QtGSource*) source;
+	QEventLoop* candidateEventLoop = qtGSource->qeventLoop;
+	QEventLoop* activeThreadEventLoop = QApplication::eventLoop();
+
+	if (candidateEventLoop == activeThreadEventLoop) {
+		return candidateEventLoop->gsourceCheck(source);
+	}
+	else {
+		// Check failed
+		return FALSE;
+	}
 }
 
 static gboolean qt_gsource_dispatch ( GSource *source,
     GSourceFunc  callback, gpointer user_data ) 
 {
-    Q_UNUSED(callback);
-    Q_UNUSED(user_data);
+	Q_UNUSED(callback);
+	Q_UNUSED(user_data);
 
-    QtGSource * qtGSource = (QtGSource*) source;
-    return qtGSource->qeventLoop->gsourceDispatch(source); 
+	QtGSource * qtGSource = (QtGSource*) source;
+	QEventLoop* candidateEventLoop = qtGSource->qeventLoop;
+	QEventLoop* activeThreadEventLoop = QApplication::eventLoop();
+
+	if (candidateEventLoop == activeThreadEventLoop) {
+		return candidateEventLoop->gsourceDispatch(source);
+	}
+	else {
+		// Dispatch failed
+		return FALSE;
+	}
 }
 
 
@@ -134,339 +160,329 @@ static QVFuncList *qt_postselect_handler = 0;
 
 void qt_install_preselect_handler( VFPTR handler )
 {
-    if ( !qt_preselect_handler )
-	qt_preselect_handler = new QVFuncList;
-    qt_preselect_handler->append( handler );
+	if ( !qt_preselect_handler ) {
+		qt_preselect_handler = new QVFuncList;
+	}
+	qt_preselect_handler->append( handler );
 }
+
 void qt_remove_preselect_handler( VFPTR handler )
 {
-    if ( qt_preselect_handler ) {
-	QVFuncList::Iterator it = qt_preselect_handler->find( handler );
-	if ( it != qt_preselect_handler->end() )
-		qt_preselect_handler->remove( it );
-    }
+	if ( qt_preselect_handler ) {
+		QVFuncList::Iterator it = qt_preselect_handler->find( handler );
+		if ( it != qt_preselect_handler->end() ) {
+			qt_preselect_handler->remove( it );
+		}
+	}
 }
+
 void qt_install_postselect_handler( VFPTR handler )
 {
-    if ( !qt_postselect_handler )
-	qt_postselect_handler = new QVFuncList;
-    qt_postselect_handler->prepend( handler );
+	if ( !qt_postselect_handler ) {
+		qt_postselect_handler = new QVFuncList;
+	}
+	qt_postselect_handler->prepend( handler );
 }
+
 void qt_remove_postselect_handler( VFPTR handler )
 {
-    if ( qt_postselect_handler ) {
-	QVFuncList::Iterator it = qt_postselect_handler->find( handler );
-	if ( it != qt_postselect_handler->end() )
-		qt_postselect_handler->remove( it );
-    }
+	if ( qt_postselect_handler ) {
+		QVFuncList::Iterator it = qt_postselect_handler->find( handler );
+		if ( it != qt_postselect_handler->end() ) {
+			qt_postselect_handler->remove( it );
+		}
+	}
 }
 
-
 void QEventLoop::init()
 {
 	// initialize ProcessEventFlags (all events & wait for more)
-	
 	d->pev_flags = AllEvents | WaitForMore;	
-	
-    // initialize the common parts of the event loop
-    if (pipe( d->thread_pipe ) < 0) {
-	// Error!
-    }
-    fcntl(d->thread_pipe[0], F_SETFD, FD_CLOEXEC);
-    fcntl(d->thread_pipe[1], F_SETFD, FD_CLOEXEC);
-
-    // intitialize the X11 parts of the event loop
-    d->xfd = -1;
-    if ( qt_is_gui_used )
-        d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() );
-
-    // new GSource
-
-    QtGSource * qtGSource = (QtGSource*) g_source_new(&qt_gsource_funcs,
-                             sizeof(QtGSource));
-                             
-    g_source_set_can_recurse ((GSource*)qtGSource, TRUE);
-
-    qtGSource->qeventLoop = this;
-	
-    // init main loop and attach gsource
-	
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside init(1)\n");
-	#endif		
-	
-    g_main_loop_new (NULL, 1);
-	
-    g_source_attach( (GSource*)qtGSource, NULL );
 
-	d->gSource = (GSource*) qtGSource;
-	
+	// initialize the common parts of the event loop
+	if (pipe( d->thread_pipe ) < 0) {
+		// Error!
+	}
+	fcntl(d->thread_pipe[0], F_SETFD, FD_CLOEXEC);
+	fcntl(d->thread_pipe[1], F_SETFD, FD_CLOEXEC);
+
+	// intitialize the X11 parts of the event loop
+	d->xfd = -1;
+	if ( qt_is_gui_used && QApplication::isGuiThread() ) {
+		d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() );
+	}
+
+	// new main context for thread
+	d->ctx = g_main_context_new();
+	g_main_context_push_thread_default(d->ctx);
+
+	// new GSource
+	QtGSource * qtGSource = (QtGSource*) g_source_new(&qt_gsource_funcs, sizeof(QtGSource));
+	g_source_set_can_recurse ((GSource*)qtGSource, TRUE);
+	qtGSource->qeventLoop = this;
+
+	// init main loop and attach gsource
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside init(1)\n");
+#endif
+
+	g_main_loop_new (d->ctx, 1);
+	g_source_attach( (GSource*)qtGSource, d->ctx );
+	d->gSource = (GSource*)qtGSource;
+
 	// poll for X11 events
-	
-    if ( qt_is_gui_used ) {
-	    
-		
+	if ( qt_is_gui_used && QApplication::isGuiThread() ) {
 		d->x_gPollFD.fd = d->xfd;
-		d->x_gPollFD.events = G_IO_IN | G_IO_HUP;
-		g_source_add_poll(d->gSource, &d->x_gPollFD); 	
-    }
+		d->x_gPollFD.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
+		g_source_add_poll(d->gSource, &d->x_gPollFD);
+	}
 
 	// poll thread-pipe
-	
 	d->threadPipe_gPollFD.fd = d->thread_pipe[0];
-	d->threadPipe_gPollFD.events = G_IO_IN | G_IO_HUP;
+	d->threadPipe_gPollFD.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
 	
 	g_source_add_poll(d->gSource, &d->threadPipe_gPollFD); 
 	
-	#ifdef DEBUG_QT_GLIBMAINLOOP 
-		printf("inside init(2)\n");
-	#endif		
+#ifdef DEBUG_QT_GLIBMAINLOOP 
+	printf("inside init(2)\n");
+#endif
 	
 }
 
 void QEventLoop::cleanup()
 {
-    // cleanup the common parts of the event loop
-    close( d->thread_pipe[0] );
-    close( d->thread_pipe[1] );
-    cleanupTimers();
+	// cleanup the common parts of the event loop
+	close( d->thread_pipe[0] );
+	close( d->thread_pipe[1] );
+	cleanupTimers();
+
+	// cleanup the X11 parts of the event loop
+	d->xfd = -1;
+
+	// unref the main context
+	g_main_context_unref(d->ctx);
 
-    // cleanup the X11 parts of the event loop
-    d->xfd = -1;
-	
 	// todo: destroy gsource
 }
 
 bool QEventLoop::processEvents( ProcessEventsFlags flags )
 {
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside processEvents(1) looplevel=%d\n", d->looplevel );
-	#endif	
-    ProcessEventsFlags save_flags;
-    int rval;
-    save_flags = d->pev_flags;
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside processEvents(1) looplevel=%d\n", d->looplevel );
+#endif
 	
-    d->pev_flags = flags;
-
-    rval = g_main_context_iteration(NULL, flags & WaitForMore ? TRUE : FALSE);	
-
-    d->pev_flags = save_flags;
+	ProcessEventsFlags save_flags;
+	int rval;
+	save_flags = d->pev_flags;
+	
+	d->pev_flags = flags;
+	
+	rval = g_main_context_iteration(d->ctx, flags & WaitForMore ? TRUE : FALSE);
 	
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside processEvents(2) looplevel=%d rval=%d\n", d->looplevel, rval );
-	#endif	
+	d->pev_flags = save_flags;
 	
-    return rval; // were events processed?
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside processEvents(2) looplevel=%d rval=%d\n", d->looplevel, rval );
+#endif	
+	
+	return rval; // were events processed?
 }
 
 
 bool QEventLoop::processX11Events()
 {
 	ProcessEventsFlags flags = d->pev_flags;
-    // process events from the X server
-    XEvent event;
-    int	   nevents = 0;
+	// process events from the X server
+	XEvent event;
+	int nevents = 0;
 
 #if defined(QT_THREAD_SUPPORT)
-    QMutexLocker locker( QApplication::qt_mutex );
+	QMutexLocker locker( QApplication::qt_mutex );
 #endif
 
-    // handle gui and posted events
-    if ( qt_is_gui_used ) {
-	QApplication::sendPostedEvents();
-
-	// Two loops so that posted events accumulate
-	while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
-	    // also flushes output buffer
-	    while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
-		if ( d->shortcut ) {
-		    return FALSE;
-		}
-
-		XNextEvent( QPaintDevice::x11AppDisplay(), &event );
-
-		if ( flags & ExcludeUserInput ) {
-		    switch ( event.type ) {
-		    case ButtonPress:
-		    case ButtonRelease:
-		    case MotionNotify:
-		    case XKeyPress:
-		    case XKeyRelease:
-		    case EnterNotify:
-		    case LeaveNotify:
-			continue;
-
-		    case ClientMessage:
-			{
-			    // from qapplication_x11.cpp
-			    extern Atom qt_wm_protocols;
-			    extern Atom qt_wm_take_focus;
-			    extern Atom qt_qt_scrolldone;
-
-			    // only keep the wm_take_focus and
-			    // qt_qt_scrolldone protocols, discard all
-			    // other client messages
-			    if ( event.xclient.format != 32 )
-				continue;
-
-			    if ( event.xclient.message_type == qt_wm_protocols ||
-				 (Atom) event.xclient.data.l[0] == qt_wm_take_focus )
-				break;
-			    if ( event.xclient.message_type == qt_qt_scrolldone )
-				break;
+	// handle gui and posted events
+	if ( qt_is_gui_used ) {
+		QApplication::sendPostedEvents();
+
+		if (QApplication::isGuiThread()) {
+			// Two loops so that posted events accumulate
+			while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
+				// also flushes output buffer
+				while ( XPending( QPaintDevice::x11AppDisplay() ) ) {
+					if ( d->shortcut ) {
+						return FALSE;
+					}
+			
+					XNextEvent( QPaintDevice::x11AppDisplay(), &event );
+			
+					if ( flags & ExcludeUserInput ) {
+						switch ( event.type ) {
+							case ButtonPress:
+							case ButtonRelease:
+							case MotionNotify:
+							case XKeyPress:
+							case XKeyRelease:
+							case EnterNotify:
+							case LeaveNotify:
+								continue;
+					
+							case ClientMessage:
+								{
+								// from qapplication_x11.cpp
+								extern Atom qt_wm_protocols;
+								extern Atom qt_wm_take_focus;
+								extern Atom qt_qt_scrolldone;
+					
+								// only keep the wm_take_focus and
+								// qt_qt_scrolldone protocols, discard all
+								// other client messages
+								if ( event.xclient.format != 32 )
+									continue;
+					
+								if ( event.xclient.message_type == qt_wm_protocols ||
+									(Atom) event.xclient.data.l[0] == qt_wm_take_focus )
+									break;
+								if ( event.xclient.message_type == qt_qt_scrolldone )
+									break;
+								}
+					
+							default: break;
+						}
+					}
+			
+					nevents++;
+					if ( qApp->x11ProcessEvent( &event ) == 1 ) {
+						return TRUE;
+					}
+				}
 			}
-
-		    default: break;
-		    }
 		}
-
-		nevents++;
-		if ( qApp->x11ProcessEvent( &event ) == 1 )
-		    return TRUE;
-	    }
 	}
-    }
+	
+	if ( d->shortcut ) {
+		return FALSE;
+	}
 
-    if ( d->shortcut ) {
+	QApplication::sendPostedEvents();
+	
+	const uint exclude_all = ExcludeSocketNotifiers | 0x08;
+	// 0x08 == ExcludeTimers for X11 only
+	if ( nevents > 0 && ( flags & exclude_all ) == exclude_all && ( flags & WaitForMore ) ) {
+		return TRUE;
+	}
 	return FALSE;
-    }
-
-    QApplication::sendPostedEvents();
-
-    const uint exclude_all = ExcludeSocketNotifiers | 0x08;
-    // 0x08 == ExcludeTimers for X11 only
-    if ( nevents > 0 && ( flags & exclude_all ) == exclude_all &&
-	 ( flags & WaitForMore ) ) {
-	    return TRUE;
-    }
-    return FALSE;
 }
-
-
+	
+	
 bool QEventLoop::gsourcePrepare(GSource *gs, int * timeout) 
 {
 	Q_UNUSED(gs);
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourcePrepare(1)\n");
-	#endif	
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourcePrepare(1)\n");
+#endif	
 
 	ProcessEventsFlags flags = d->pev_flags;
-	
+		
 #if defined(QT_THREAD_SUPPORT)
-    QMutexLocker locker( QApplication::qt_mutex );
+	QMutexLocker locker( QApplication::qt_mutex );
 #endif
-
-    // don't block if exitLoop() or exit()/quit() has been called.
-    bool canWait = d->exitloop || d->quitnow ? FALSE : (flags & WaitForMore);
-
-    // Process timers and socket notifiers - the common UNIX stuff
-
-    // return the maximum time we can wait for an event.
-    static timeval zerotm;
-    timeval *tm = 0;
-    if ( ! ( flags & 0x08 ) ) {			// 0x08 == ExcludeTimers for X11 only
-	    tm = qt_wait_timer();			// wait for timer or X event
-	    if ( !canWait ) {
-	        if ( !tm )
-                    tm = &zerotm;
-	        tm->tv_sec  = 0;			// no time to wait
-	        tm->tv_usec = 0;
-	    }
-    }
-
-	// include or exclude SocketNotifiers (by setting or cleaning poll events)  
 	
-    if ( ! ( flags & ExcludeSocketNotifiers ) ) {
-        QPtrListIterator<QSockNotGPollFD> it( d->sn_list );
-        QSockNotGPollFD *sn;
-        while ( (sn=it.current()) ) {
-            ++it;		
-		    sn->gPollFD.events = sn->events;  // restore poll events
+	// don't block if exitLoop() or exit()/quit() has been called.
+	bool canWait = d->exitloop || d->quitnow ? FALSE : (flags & WaitForMore);
+	
+	// Process timers and socket notifiers - the common UNIX stuff
+	
+	// return the maximum time we can wait for an event.
+	static timeval zerotm;
+	timeval *tm = 0;
+	if ( ! ( flags & 0x08 ) ) {				// 0x08 == ExcludeTimers for X11 only
+		tm = qt_wait_timer();				// wait for timer or X event
+		if ( !canWait ) {
+			if ( !tm ) {
+				tm = &zerotm;
+			}
+			tm->tv_sec  = 0;			// no time to wait
+			tm->tv_usec = 0;
 		}
-	} else {
-        QPtrListIterator<QSockNotGPollFD> it( d->sn_list );
-        QSockNotGPollFD *sn;
-        while ( (sn=it.current()) ) {
-            ++it;		
-		    sn->gPollFD.events = 0;  // delete poll events
+	}
+	
+	// include or exclude SocketNotifiers (by setting or cleaning poll events)
+	if ( ! ( flags & ExcludeSocketNotifiers ) ) {
+		QPtrListIterator<QSockNotGPollFD> it( d->sn_list );
+		QSockNotGPollFD *sn;
+		while ( (sn=it.current()) ) {
+			++it;		
+			sn->gPollFD.events = sn->events;  // restore poll events
+		}
+	}
+	else {
+		QPtrListIterator<QSockNotGPollFD> it( d->sn_list );
+		QSockNotGPollFD *sn;
+		while ( (sn=it.current()) ) {
+			++it;		
+			sn->gPollFD.events = 0;  // delete poll events
 		}
 	}
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourcePrepare(2) canwait=%d\n", canWait);
-	#endif 
-
-    if ( canWait )
-	   emit aboutToBlock();
-
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourcePrepare(2) canwait=%d\n", canWait);
+#endif 
 	
-    if ( qt_preselect_handler ) {
-	   QVFuncList::Iterator it, end = qt_preselect_handler->end();
-	   for ( it = qt_preselect_handler->begin(); it != end; ++it )
-	       (**it)();
-    }
-
-    // unlock the GUI mutex and select.  when we return from this function, there is
-    // something for us to do
-#if defined(QT_THREAD_SUPPORT)
-    locker.mutex()->unlock();
-#endif
+	if ( canWait ) {
+		emit aboutToBlock();
+	}
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP 
-		printf("inside gsourcePrepare(2.1) canwait=%d\n", canWait);
-	#endif 	
+	if ( qt_preselect_handler ) {
+		QVFuncList::Iterator it, end = qt_preselect_handler->end();
+		for ( it = qt_preselect_handler->begin(); it != end; ++it )
+			(**it)();
+	}
 
+#ifdef DEBUG_QT_GLIBMAINLOOP 
+	printf("inside gsourcePrepare(2.1) canwait=%d\n", canWait);
+#endif
+	
 	// do we have to dispatch events?
-    if (hasPendingEvents()) { 
+	if (hasPendingEvents()) {
 		*timeout = 0; // no time to stay in poll
-		
-		#ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourcePrepare(3a)\n");
-		#endif		
-		
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourcePrepare(3a)\n");
+#endif
 		return FALSE;
-    }
-
+	}
+	
 	// stay in poll until something happens?
 	if (!tm) { // fixme
 		*timeout = -1; // wait forever
-		#ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourcePrepare(3b) timeout=%d \n", *timeout);
-		#endif	
-		
-		
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourcePrepare(3b) timeout=%d \n", *timeout);
+#endif
 		return FALSE;
 	}
-	
-	// else timeout >=0 
+		
+	// else timeout >=0
 	*timeout = tm->tv_sec * 1000 + tm->tv_usec/1000;
 	
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourcePrepare(3c) timeout=%d \n", *timeout);
-	#endif	
-	
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourcePrepare(3c) timeout=%d \n", *timeout);
+#endif
 
-    return FALSE;
+	return FALSE;
 }
 
 
 bool QEventLoop::gsourceCheck(GSource *gs) {
 	Q_UNUSED(gs);
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourceCheck(1)\n");
-	#endif
-
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourceCheck(1)\n");
+#endif
 
 	// Socketnotifier events?
-
 	QPtrList<QSockNotGPollFD> *list = &d->sn_list;
-
 	//if ( list ) {
-
-
 		QSockNotGPollFD *sn = list->first();
 		while ( sn ) {
 			if ( sn->gPollFD.revents )
@@ -476,45 +492,43 @@ bool QEventLoop::gsourceCheck(GSource *gs) {
 	//}
 
 	if (d->x_gPollFD.revents) {
-		#ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourceCheck(2) xfd!\n");
-		#endif
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourceCheck(2) xfd!\n");
+#endif
 
 		return TRUE;  // we got events!
 	}
-    if (d->threadPipe_gPollFD.revents) {
-		#ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourceCheck(2) threadpipe!!\n");
-		#endif
+	if (d->threadPipe_gPollFD.revents) {
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourceCheck(2) threadpipe!!\n");
+#endif
 
 		return TRUE;  // we got events!
 	}
-    if (hasPendingEvents()) {
-		#ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourceCheck(2) pendingEvents!\n");
-		#endif
+	if (hasPendingEvents()) {
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourceCheck(2) pendingEvents!\n");
+#endif
 
 		return TRUE; // we got more X11 events!
 	}
-    // check if we have timers to activate?
 
+	// check if we have timers to activate?
 	timeval * tm =qt_wait_timer();
+	if (tm && (tm->tv_sec == 0 && tm->tv_usec == 0 )) {
+#ifdef DEBUG_QT_GLIBMAINLOOP
+		printf("inside gsourceCheck(2) qtwaittimer!\n");
+#endif
+	
+		return TRUE;
+	}
 
-    if (tm && (tm->tv_sec == 0 && tm->tv_usec == 0 )) {
-		 #ifdef DEBUG_QT_GLIBMAINLOOP
-			printf("inside gsourceCheck(2) qtwaittimer!\n");
-		 #endif
-
-         return TRUE;
-    }
-
-    // nothing to dispatch
-
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourceCheck(2) nothing to dispatch!\n");
-	#endif
+	// nothing to dispatch
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourceCheck(2) nothing to dispatch!\n");
+#endif
 
-    return FALSE;
+	return FALSE;
 }
 
 
@@ -526,44 +540,41 @@ bool QEventLoop::gsourceDispatch(GSource *gs) {
 	QMutexLocker locker( QApplication::qt_mutex );
 #endif
 #if defined(QT_THREAD_SUPPORT)
-	locker.mutex()->lock();
+	if (locker.mutex()) locker.mutex()->lock();
 #endif
 
 	int nevents=0;
-
 	ProcessEventsFlags flags = d->pev_flags;
 
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourceDispatch(1)\n");
-	#endif
-
-    // we are awake, broadcast it
-    emit awake();
-    emit qApp->guiThreadAwake();
-
-    // some other thread woke us up... consume the data on the thread pipe so that
-    // select doesn't immediately return next time
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourceDispatch(1)\n");
+#endif
 
+	// we are awake, broadcast it
+	emit awake();
+	emit qApp->guiThreadAwake();
+	
+	// some other thread woke us up... consume the data on the thread pipe so that
+	// select doesn't immediately return next time
+	
 	if ( d->threadPipe_gPollFD.revents) {
-	    char c;
-	    if (::read( d->thread_pipe[0], &c, 1 ) < 0) {
-		// Error!
-	    }
-    }
+		char c;
+		if (::read( d->thread_pipe[0], &c, 1 ) < 0) {
+			// Error!
+		}
+	}
 
-    if ( qt_postselect_handler ) {
-	    QVFuncList::Iterator it, end = qt_postselect_handler->end();
-	    for ( it = qt_postselect_handler->begin(); it != end; ++it )
-	        (**it)();
-    }
+	if ( qt_postselect_handler ) {
+		QVFuncList::Iterator it, end = qt_postselect_handler->end();
+		for ( it = qt_postselect_handler->begin(); it != end; ++it )
+			(**it)();
+	}
 
-    // activate socket notifiers
-    if ( ! ( flags & ExcludeSocketNotifiers )) {
+	// activate socket notifiers
+	if ( ! ( flags & ExcludeSocketNotifiers )) {
 		// if select says data is ready on any socket, then set the socket notifier
 		// to pending
 		// if ( &d->sn_list ) {
-
-
 			QPtrList<QSockNotGPollFD> *list = &d->sn_list;
 			QSockNotGPollFD *sn = list->first();
 			while ( sn ) {
@@ -572,40 +583,38 @@ bool QEventLoop::gsourceDispatch(GSource *gs) {
 				sn = list->next();
 			}
 		// }
-
+	
 		nevents += activateSocketNotifiers();
-    }
+	}
 
-    // activate timers
-    if ( ! ( flags & 0x08 ) ) {
+	// activate timers
+	if ( ! ( flags & 0x08 ) ) {
 		// 0x08 == ExcludeTimers for X11 only
 		nevents += activateTimers();
-    }
-
-
+	}
 
 	// return true if we handled events, false otherwise
 	//return (nevents > 0);
 
 	// now process x11 events!
-
-	#ifdef DEBUG_QT_GLIBMAINLOOP
-		printf("inside gsourceDispatch(2) hasPendingEvents=%d\n", hasPendingEvents());
-	#endif
-
+#ifdef DEBUG_QT_GLIBMAINLOOP
+	printf("inside gsourceDispatch(2) hasPendingEvents=%d\n", hasPendingEvents());
+#endif
 
 	if (hasPendingEvents()) {
-
 		// color approx. optimization - only on X11
 		qt_reset_color_avail();
 
+#if defined(QT_THREAD_SUPPORT)
+		if (locker.mutex()) locker.mutex()->unlock();
+#endif
 		processX11Events();
-
 	}
-
+	else {
 #if defined(QT_THREAD_SUPPORT)
-    locker.mutex()->unlock();
+		if (locker.mutex()) locker.mutex()->unlock();
 #endif
+	}
 
 	if (d->singletoolkit) {
 		return TRUE;	// Eat the event
@@ -617,21 +626,27 @@ bool QEventLoop::gsourceDispatch(GSource *gs) {
 
 bool QEventLoop::hasPendingEvents() const
 {
-    extern uint qGlobalPostedEventsCount(); // from qapplication.cpp
-    return ( qGlobalPostedEventsCount() || ( qt_is_gui_used  ? XPending( QPaintDevice::x11AppDisplay() ) : 0));
+	extern uint qGlobalPostedEventsCount(); // from qapplication.cpp
+	return ( qGlobalPostedEventsCount() || ( (qt_is_gui_used && QApplication::isGuiThread())  ? XPending( QPaintDevice::x11AppDisplay() ) : 0));
 }
 
 void QEventLoop::appStartingUp()
 {
-    if ( qt_is_gui_used )
-        d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() );
+	if ( qt_is_gui_used ) {
+		d->xfd = XConnectionNumber( QPaintDevice::x11AppDisplay() );
+		if ( (d->x_gPollFD.fd == -1) && QApplication::isGuiThread() ) {
+			d->x_gPollFD.fd = d->xfd;
+			d->x_gPollFD.events = G_IO_IN | G_IO_HUP | G_IO_ERR;
+			g_source_add_poll(d->gSource, &d->x_gPollFD);
+		}
+	}
 }
 
 void QEventLoop::appClosingDown()
 {
-    d->xfd = -1;
+	d->xfd = -1;
 }
 
 void QEventLoop::setSingleToolkitEventHandling(bool enabled) {
-    d->singletoolkit = enabled;
+	d->singletoolkit = enabled;
 }
\ No newline at end of file
diff --git a/src/kernel/qimage.cpp b/src/kernel/qimage.cpp
index b55a0e7..214fc85 100644
--- a/src/kernel/qimage.cpp
+++ b/src/kernel/qimage.cpp
@@ -5424,6 +5424,7 @@ static void write_pbm_image( QImageIO *iio )
 class QImageIOFrameGrabber : public QImageConsumer {
 public:
     QImageIOFrameGrabber() : framecount(0) { }
+    virtual ~QImageIOFrameGrabber() { }
 
     QImageDecoder *decoder;
     int framecount;
diff --git a/src/kernel/qinputcontext.cpp b/src/kernel/qinputcontext.cpp
index 5433ae4..3b2d476 100644
--- a/src/kernel/qinputcontext.cpp
+++ b/src/kernel/qinputcontext.cpp
@@ -477,6 +477,7 @@ bool QInputContext::isComposing() const
 */
 bool QInputContext::filterEvent( const QEvent *event )
 {
+    Q_UNUSED(event);
     return FALSE;
 }
 
@@ -679,6 +680,11 @@ void QInputContext::unsetFocus()
 */
 void QInputContext::setMicroFocus( int x, int y, int w, int h, QFont *f )
 {
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(w);
+    Q_UNUSED(h);
+    Q_UNUSED(f);
 }
 
 
@@ -705,6 +711,9 @@ void QInputContext::mouseHandler( int x, QEvent::Type type,
 				  Qt::ButtonState button,
 				  Qt::ButtonState state )
 {
+    Q_UNUSED(x);
+    Q_UNUSED(button);
+    Q_UNUSED(state);
     // Default behavior for simple ephemeral input contexts. Some
     // complex input contexts should not be reset here.
     if ( type == QEvent::MouseButtonPress ||
diff --git a/src/kernel/qinputcontext_x11.cpp b/src/kernel/qinputcontext_x11.cpp
index 8bdfa5e..e7c82c1 100644
--- a/src/kernel/qinputcontext_x11.cpp
+++ b/src/kernel/qinputcontext_x11.cpp
@@ -67,6 +67,8 @@
 */
 bool QInputContext::x11FilterEvent( QWidget *keywidget, XEvent *event )
 {
+    Q_UNUSED(keywidget);
+    Q_UNUSED(event);
     return FALSE;
 }
 
diff --git a/src/kernel/qjpegio.cpp b/src/kernel/qjpegio.cpp
index 5d2a1b1..bdb4c27 100644
--- a/src/kernel/qjpegio.cpp
+++ b/src/kernel/qjpegio.cpp
@@ -80,7 +80,7 @@ void my_error_exit (j_common_ptr cinfo)
     my_error_mgr* myerr = (my_error_mgr*) cinfo->err;
     char buffer[JMSG_LENGTH_MAX];
     (*cinfo->err->format_message)(cinfo, buffer);
-    qWarning(buffer);
+    qWarning("%s", buffer);
     longjmp(myerr->setjmp_buffer, 1);
 }
 
diff --git a/src/kernel/qnetworkprotocol.cpp b/src/kernel/qnetworkprotocol.cpp
index 4173584..e6c4a6a 100644
--- a/src/kernel/qnetworkprotocol.cpp
+++ b/src/kernel/qnetworkprotocol.cpp
@@ -381,6 +381,14 @@ public:
     of these values.
 */
 
+QNetworkProtocolFactoryBase::QNetworkProtocolFactoryBase() {
+	//
+}
+
+QNetworkProtocolFactoryBase::~QNetworkProtocolFactoryBase() {
+	//
+}
+
 /*!
     Constructor of the network protocol base class. Does some
     initialization and connecting of signals and slots.
diff --git a/src/kernel/qnetworkprotocol.h b/src/kernel/qnetworkprotocol.h
index 096a9ad..fa350e3 100644
--- a/src/kernel/qnetworkprotocol.h
+++ b/src/kernel/qnetworkprotocol.h
@@ -64,6 +64,10 @@ template <class T> class QValueList;
 class Q_EXPORT QNetworkProtocolFactoryBase
 {
 public:
+   QNetworkProtocolFactoryBase();
+   virtual ~QNetworkProtocolFactoryBase();
+
+public:
    virtual QNetworkProtocol *createObject() = 0;
 
 };
diff --git a/src/kernel/qobject.cpp b/src/kernel/qobject.cpp
index 7e01dec..13486f4 100644
--- a/src/kernel/qobject.cpp
+++ b/src/kernel/qobject.cpp
@@ -50,22 +50,107 @@
 #include "qptrvector.h"
 
 #ifdef QT_THREAD_SUPPORT
-#include <qmutex.h>
+#include "qmutex.h"
 #include <private/qmutexpool_p.h>
+#include "qthread.h"
 #endif
 
 #include <ctype.h>
-
+#include <stdlib.h>
 
 #ifndef QT_NO_USERDATA
 class QObjectPrivate : public QPtrVector<QObjectUserData>
+#else
+class QObjectPrivate {
+#endif
 {
 public:
+#ifndef QT_NO_USERDATA
     QObjectPrivate( uint s ) : QPtrVector<QObjectUserData>(s){ setAutoDelete( TRUE ); }
+#endif
+    QThread* ownThread;
 };
-#else
-class QObjectPrivate {
+
+#if defined(QT_THREAD_SUPPORT)
+
+void QObject::moveToThread_helper(QThread *targetThread)
+{
+    QEvent e(QEvent::ThreadChange);
+    QApplication::sendEvent(this, &e);
+
+    if (childObjects) {
+        QObject *child;
+        QObjectListIt it(*childObjects);
+        while ( (child=it.current()) ) {
+            ++it;
+            child->moveToThread_helper(targetThread);
+        }
+    }
+}
+
+void QObject::setThreadObject_helper(QThread *targetThread)
+{
+    d->ownThread = targetThread;
+
+    if (childObjects) {
+        QObject *child;
+        QObjectListIt it(*childObjects);
+        while ( (child=it.current()) ) {
+            ++it;
+            child->moveToThread_helper(targetThread);
+        }
+    }
+}
+
+/*!
+    Changes the thread affinity for this object and its children. The
+    object cannot be moved if it has a parent. Event processing will
+    continue in the \a targetThread. To move an object to the main
+    thread, pass QApplication::guiThread() as the \a targetThread.
+
+    Note that all active timers for the object will be reset. The
+    timers are first stopped in the current thread and restarted (with
+    the same interval) in the \a targetThread. As a result, constantly
+    moving an object between threads can postpone timer events
+    indefinitely.
+
+    \sa contextThreadObject()
+ */
+void QObject::moveToThread(QThread *targetThread)
+{
+    QMutexLocker locker( QApplication::qt_mutex );
+
+    if (parentObj) {
+#if defined(QT_DEBUG)
+        qWarning( "QObject::moveToThread: Cannot move objects with a parent" );
+#endif
+        return;
+    }
+    if (isWidget) {
+#if defined(QT_DEBUG)
+        qWarning( "QObject::moveToThread: Widgets cannot be moved to a new thread" );
+#endif
+        return;
+    }
+
+    QThread *objectThread = contextThreadObject();
+    QThread *currentThread = QThread::currentThreadObject();
+
+    if (objectThread != currentThread) {
+#if defined(QT_DEBUG)
+        qWarning( "QObject::moveToThread: Current thread is not the object's thread" );
+#endif
+        return;
+    }
+
+    if (objectThread == targetThread) {
+        return;
+    }
+
+    moveToThread_helper(targetThread);
+    setThreadObject_helper(targetThread);
 }
+
 #endif
 
 class QSenderObjectList : public QObjectList, public QShared
@@ -75,6 +160,41 @@ public:
     QObject *currentSender;
 };
 
+class Q_EXPORT QMetaCallEvent : public QEvent
+{
+public:
+    enum MetaCallType {
+	MetaCallEmit	= 0,
+	MetaCallInvoke	= 1
+    };
+
+public:
+    QMetaCallEvent(int id, QObject *sender, QUObject *data, MetaCallType type);
+    ~QMetaCallEvent();
+
+    inline int id() const { return id_; }
+    inline QObject *sender() const { return sender_; }
+    inline QUObject *data() const { return data_; }
+    inline MetaCallType type() const { return type_; }
+
+private:
+    const int id_;
+    QObject *sender_;
+    QUObject *data_;
+    const MetaCallType type_;
+};
+
+/*! \internal
+ */
+QMetaCallEvent::QMetaCallEvent(int id, QObject *sender, QUObject *data, MetaCallType type)
+    :QEvent(MetaCall), id_(id), sender_(sender), data_(data), type_(type)
+{ }
+
+/*! \internal
+ */
+QMetaCallEvent::~QMetaCallEvent()
+{ }
+
 /*!
     \class Qt qnamespace.h
 
@@ -269,7 +389,21 @@ void *qt_find_obj_child( QObject *parent, const char *type, const char *name )
     return 0;
 }
 
+#ifdef QT_THREAD_SUPPORT
 
+/*!
+    Returns a pointer to the QThread* associated with
+    the current thread affinity of this object.
+
+    \sa moveToThread()
+ */
+
+QThread* QObject::contextThreadObject() const
+{
+    return d->ownThread;
+}
+
+#endif
 
 #ifndef QT_NO_PRELIMINARY_SIGNAL_SPY
 /*
@@ -436,6 +570,11 @@ QObject::QObject( QObject *parent, const char *name )
 	insert_tree( this );
 	isTree = TRUE;
     }
+
+    if ( !d )
+	d = new QObjectPrivate(0);
+
+    d->ownThread = QThread::currentThreadObject();
 }
 
 
@@ -720,6 +859,36 @@ QObject* QObject::child( const char *objName, const char *inheritsClass,
     return obj;
 }
 
+/*! \internal */
+QUObject* deepCopyQUObjectArray(QUObject* origArray)
+{
+    QUObject* newArray;
+    int count = 0;
+    while (!((origArray+count)->isLastObject)) {
+	count++;
+    }
+    count++;
+    newArray = (QUObject*)malloc(sizeof(QUObject)*count);
+    for (int i=0; i<count; i++) {
+	(origArray+i)->deepCopy(newArray+i);
+    }
+    return newArray;
+}
+
+/*! \internal */
+void destroyDeepCopiedQUObjectArray(QUObject* uArray)
+{
+    int count = 0;
+    while (!((uArray+count)->isLastObject)) {
+	count++;
+    }
+    count++;
+    for (int i=0; i<count; i++) {
+	(uArray+i)->~QUObject();
+    }
+    free(uArray);
+}
+
 /*!
     \fn bool QObject::isWidgetType() const
 
@@ -777,6 +946,40 @@ bool QObject::event( QEvent *e )
 	delete this;
 	return TRUE;
 
+    case QEvent::MetaCall:
+	{
+	    QMetaCallEvent* metaEvent = dynamic_cast<QMetaCallEvent*>(e);
+	    if (metaEvent) {
+		if (d->ownThread == QThread::currentThreadObject()) {
+		    QSenderObjectList* sol;
+		    QObject* oldSender = 0;
+		    sol = senderObjects;
+		    if ( sol ) {
+			oldSender = sol->currentSender;
+			sol->ref();
+			sol->currentSender = metaEvent->sender();
+		    }
+		    QUObject *o = metaEvent->data();
+		    if (metaEvent->type() == QMetaCallEvent::MetaCallEmit) {
+			qt_emit( metaEvent->id(), o );
+		    }
+		    if (metaEvent->type() == QMetaCallEvent::MetaCallInvoke) {
+			qt_invoke( metaEvent->id(), o );
+		    }
+		    if (sol ) {
+			sol->currentSender = oldSender;
+			if ( sol->deref() ) {
+			    delete sol;
+			}
+		    }
+		}
+		else {
+		    qWarning("QObject: Ignoring metacall event from non-owning thread");
+		}
+		destroyDeepCopiedQUObjectArray(metaEvent->data());
+	    }
+	}
+
     default:
 	if ( e->type() >= QEvent::User ) {
 	    customEvent( (QCustomEvent*) e );
@@ -2337,6 +2540,7 @@ void QObject::activate_signal( int signal )
 	if ( !signalsBlocked() && signal >= 0 &&
 	     ( !connections || !connections->at( signal ) ) ) {
 	    QUObject o[1];
+	    o[0].isLastObject = true;
 	    qt_spy_signal( this, signal, o );
 	    return;
 	}
@@ -2349,6 +2553,7 @@ void QObject::activate_signal( int signal )
     if ( !clist )
 	return;
     QUObject o[1];
+    o[0].isLastObject = true;
     activate_signal( clist, o );
 }
 
@@ -2364,6 +2569,8 @@ void QObject::activate_signal( QConnectionList *clist, QUObject *o )
 	qt_spy_signal( this, connections->findRef( clist), o );
 #endif
 
+    const QThread *currentThread = QThread::currentThreadObject();
+
     QObject *object;
     QSenderObjectList* sol;
     QObject* oldSender = 0;
@@ -2377,10 +2584,26 @@ void QObject::activate_signal( QConnectionList *clist, QUObject *o )
 	    sol->ref();
 	    sol->currentSender = this;
 	}
-	if ( c->memberType() == QSIGNAL_CODE )
-	    object->qt_emit( c->member(), o );
-	else
-	    object->qt_invoke( c->member(), o );
+	if ( c->memberType() == QSIGNAL_CODE ) {
+	    if (object->d->ownThread == currentThread) {
+		object->qt_emit( c->member(), o );
+	    }
+	    else {
+		if (object->d->ownThread && !object->d->ownThread->finished()) {
+		    QApplication::postEvent(object, new QMetaCallEvent(c->member(), this, deepCopyQUObjectArray(o), QMetaCallEvent::MetaCallEmit));
+		}
+	    }
+	}
+	else {
+	    if (object->d->ownThread == currentThread) {
+		object->qt_invoke( c->member(), o );
+	    }
+	    else {
+		if (object->d->ownThread && !object->d->ownThread->finished()) {
+		    QApplication::postEvent(object, new QMetaCallEvent(c->member(), this, deepCopyQUObjectArray(o), QMetaCallEvent::MetaCallInvoke));
+		}
+	    }
+	}
 	if ( sol ) {
 	    sol->currentSender = oldSender;
 	    if ( sol->deref() )
@@ -2401,10 +2624,26 @@ void QObject::activate_signal( QConnectionList *clist, QUObject *o )
 		sol->ref();
 		sol->currentSender = this;
 	    }
-	    if ( c->memberType() == QSIGNAL_CODE )
-		object->qt_emit( c->member(), o );
-	    else
-		object->qt_invoke( c->member(), o );
+	    if ( c->memberType() == QSIGNAL_CODE ) {
+		if (object->d->ownThread == currentThread) {
+		    object->qt_emit( c->member(), o );
+		}
+		else {
+		    if (object->d->ownThread && !object->d->ownThread->finished()) {
+			QApplication::postEvent(object, new QMetaCallEvent(c->member(), this, deepCopyQUObjectArray(o), QMetaCallEvent::MetaCallEmit));
+		    }
+		}
+	    }
+	    else {
+		if (object->d->ownThread == currentThread) {
+		    object->qt_invoke( c->member(), o );
+		}
+		else {
+		    if (object->d->ownThread && !object->d->ownThread->finished()) {
+			QApplication::postEvent(object, new QMetaCallEvent(c->member(), this, deepCopyQUObjectArray(o), QMetaCallEvent::MetaCallInvoke));
+		    }
+		}
+	    }
 	    if (sol ) {
 		sol->currentSender = oldSender;
 		if ( sol->deref() )
@@ -2435,39 +2674,42 @@ void QObject::activate_signal( QConnectionList *clist, QUObject *o )
 */
 
 #ifndef QT_NO_PRELIMINARY_SIGNAL_SPY
-#define ACTIVATE_SIGNAL_WITH_PARAM(FNAME,TYPE)				      \
-void QObject::FNAME( int signal, TYPE param )				      \
-{									      \
-    if ( qt_preliminary_signal_spy ) { \
-	if ( !signalsBlocked() && signal >= 0 && \
-	     ( !connections || !connections->at( signal ) ) ) { \
-	    QUObject o[2];							      \
-	    static_QUType_##TYPE.set( o+1, param );					      \
-	    qt_spy_signal( this, signal, o ); \
-	    return; \
-	} \
-    } \
-    if ( !connections || signalsBlocked() || signal < 0 )		      \
-	return;								      \
-    QConnectionList *clist = connections->at( signal );			      \
-    if ( !clist )							      \
-	return;								      \
-    QUObject o[2];							      \
-    static_QUType_##TYPE.set( o+1, param );					      \
-    activate_signal( clist, o );					      \
+#define ACTIVATE_SIGNAL_WITH_PARAM(FNAME,TYPE)					\
+void QObject::FNAME( int signal, TYPE param )					\
+{										\
+    if ( qt_preliminary_signal_spy ) {						\
+	if ( !signalsBlocked() && signal >= 0 &&				\
+	     ( !connections || !connections->at( signal ) ) ) {			\
+	    QUObject o[2];							\
+	    o[1].isLastObject = true;						\
+	    static_QUType_##TYPE.set( o+1, param );				\
+	    qt_spy_signal( this, signal, o );					\
+	    return;								\
+	}									\
+    }										\
+    if ( !connections || signalsBlocked() || signal < 0 )			\
+	return;									\
+    QConnectionList *clist = connections->at( signal );			\
+    if ( !clist )								\
+	return;									\
+    QUObject o[2];								\
+    o[1].isLastObject = true;							\
+    static_QUType_##TYPE.set( o+1, param );					\
+    activate_signal( clist, o );						\
 }
 #else
-#define ACTIVATE_SIGNAL_WITH_PARAM(FNAME,TYPE)				      \
-void QObject::FNAME( int signal, TYPE param )				      \
-{									      \
-    if ( !connections || signalsBlocked() || signal < 0 )		      \
-	return;								      \
-    QConnectionList *clist = connections->at( signal );			      \
-    if ( !clist )							      \
-	return;								      \
-    QUObject o[2];							      \
-    static_QUType_##TYPE.set( o+1, param );					      \
-    activate_signal( clist, o );					      \
+#define ACTIVATE_SIGNAL_WITH_PARAM(FNAME,TYPE)					\
+void QObject::FNAME( int signal, TYPE param )					\
+{										\
+    if ( !connections || signalsBlocked() || signal < 0 )			\
+	return;									\
+    QConnectionList *clist = connections->at( signal );			\
+    if ( !clist )								\
+	return;									\
+    QUObject o[2];								\
+    o[1].isLastObject = true;							\
+    static_QUType_##TYPE.set( o+1, param );					\
+    activate_signal( clist, o );						\
 }
 
 #endif
diff --git a/src/kernel/qobject.h b/src/kernel/qobject.h
index 6de28db..2f469ba 100644
--- a/src/kernel/qobject.h
+++ b/src/kernel/qobject.h
@@ -63,6 +63,10 @@ class QObjectUserData;
 #endif
 struct QUObject;
 
+#ifdef QT_THREAD_SUPPORT
+class QThread;
+#endif
+
 class Q_EXPORT QObject: public Qt
 {
     Q_OBJECT
@@ -217,6 +221,18 @@ private:	// Disabled copy constructor and operator=
     QObject( const QObject & );
     QObject &operator=( const QObject & );
 #endif
+
+public:
+#ifdef QT_THREAD_SUPPORT
+    QThread* contextThreadObject() const;
+    void moveToThread(QThread *targetThread);
+#endif
+
+private:
+#ifdef QT_THREAD_SUPPORT
+    void moveToThread_helper(QThread *targetThread);
+    void setThreadObject_helper(QThread *targetThread);
+#endif
 };
 
 
diff --git a/src/kernel/qpaintdevice_x11.cpp b/src/kernel/qpaintdevice_x11.cpp
index a755c01..5941657 100644
--- a/src/kernel/qpaintdevice_x11.cpp
+++ b/src/kernel/qpaintdevice_x11.cpp
@@ -529,11 +529,16 @@ static void create_dpis()
     Q_CHECK_PTR( dpisX );
     Q_CHECK_PTR( dpisY );
     for ( i = 0; i < screens; i++ ) {
-	dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5)
-
-		     / (DisplayWidthMM(dpy,i)*10);
-	dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5)
-		     / (DisplayHeightMM(dpy,i)*10);
+       if (DisplayWidthMM(dpy,i) < 1)
+               dpisX[ i ] = 75; // default the dpi to 75.
+       else
+               dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5)
+                     / (DisplayWidthMM(dpy,i)*10);
+       if (DisplayHeightMM(dpy,i) < 1)
+               dpisY[ i ] = 75; // default the dpi to 75.
+       else
+               dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5)
+                     / (DisplayHeightMM(dpy,i)*10);
     }
 }
 
diff --git a/src/kernel/qprocess_unix.cpp b/src/kernel/qprocess_unix.cpp
index 2a4a2fd..c6066d4 100644
--- a/src/kernel/qprocess_unix.cpp
+++ b/src/kernel/qprocess_unix.cpp
@@ -379,7 +379,9 @@ void QProcessManager::sigchldHnd( int fd )
     }
 
     char tmp;
-    ::read( fd, &tmp, sizeof(tmp) );
+    if (::read( fd, &tmp, sizeof(tmp) ) < 0) {
+	qWarning( "Could not read from file descriptor" );
+    }
 #if defined(QT_QPROCESS_DEBUG)
     qDebug( "QProcessManager::sigchldHnd()" );
 #endif
@@ -562,7 +564,9 @@ QT_SIGNAL_RETTYPE qt_C_sigchldHnd( QT_SIGNAL_ARGS )
 	return;
 
     char a = 1;
-    ::write( QProcessPrivate::procManager->sigchldFd[0], &a, sizeof(a) );
+    if (::write( QProcessPrivate::procManager->sigchldFd[0], &a, sizeof(a) ) < 0) {
+	qWarning( "Could not write to file descriptor" );
+    }
 }
 
 
diff --git a/src/kernel/qscriptengine_x11.cpp b/src/kernel/qscriptengine_x11.cpp
index 7d2b77d..b87680b 100644
--- a/src/kernel/qscriptengine_x11.cpp
+++ b/src/kernel/qscriptengine_x11.cpp
@@ -2725,11 +2725,7 @@ static bool khmer_shape_syllable(QOpenType *openType, QShaperItem *item)
 
 #ifndef QT_NO_XFTFREETYPE
     if (openType) {
-	unsigned short logClusters[16];
-	for (int i = 0; i < len; ++i)
-	    logClusters[i] = i;
-
- 	uint where[16];
+	uint where[16];
 
         for (int i = 0; i < len; ++i) {
             where[i] = ~(PreSubstProperty
@@ -3236,11 +3232,7 @@ static bool myanmar_shape_syllable(QOpenType *openType, QShaperItem *item, bool
 
 #ifndef QT_NO_XFTFREETYPE
     if (openType) {
-	unsigned short logClusters[32];
-	for (int i = 0; i < len; ++i)
-	    logClusters[i] = i;
-
- 	uint where[32];
+	uint where[32];
 
         for (int i = 0; i < len; ++i) {
             where[i] = ~(PreSubstProperty
diff --git a/src/kernel/qstyle.h b/src/kernel/qstyle.h
index cf7a235..0efc386 100644
--- a/src/kernel/qstyle.h
+++ b/src/kernel/qstyle.h
@@ -290,6 +290,7 @@ class Q_EXPORT QStyleControlElementData {
 		QString caption;
 		QStyleControlElementGenericWidgetData topLevelWidgetData;
 		Q_UINT32 topLevelWidgetFlags;
+		QPixmap paletteBgPixmap;
 };
 
 class Q_EXPORT QStyleWidgetActionRequestData {
@@ -1070,6 +1071,18 @@ public:
 	// bool - whether or not the upper two button drawing areas should be combined into one
 	SH_ScrollBar_CombineSubLineRegionDrawingAreas,
 
+	// Qt::QRgb - color of the popup menu arrow (active, menuitem enabled)
+	SH_PopupMenu_SubMenuArrowColorActiveEnabled,
+
+	// Qt::QRgb - color of the popup menu arrow (active, menuitem disabled)
+	SH_PopupMenu_SubMenuArrowColorActiveDisabled,
+
+	// Qt::QRgb - color of the popup menu arrow (inactive, menuitem enabled)
+	SH_PopupMenu_SubMenuArrowColorInactiveEnabled,
+
+	// Qt::QRgb - color of the popup menu arrow (active, menuitem disabled)
+	SH_PopupMenu_SubMenuArrowColorInactiveDisabled,
+
 	// do not add any values below/greater than this
 	SH_CustomBase =		0xf0000000
     };
diff --git a/src/kernel/qthread.cpp b/src/kernel/qthread.cpp
index 1653a51..cfe8c56 100644
--- a/src/kernel/qthread.cpp
+++ b/src/kernel/qthread.cpp
@@ -41,6 +41,7 @@
 #include "qplatformdefs.h"
 
 #include "qthread.h"
+#include "qeventloop.h"
 #include <private/qthreadinstance_p.h>
 
 #ifndef QT_H
@@ -238,4 +239,20 @@ void QThread::postEvent( QObject * receiver, QEvent * event )
 }
 #endif
 
+QEventLoopThread::QEventLoopThread() : QThread()
+{
+    //
+}
+
+QEventLoopThread::~QEventLoopThread()
+{
+    //
+}
+
+void QEventLoopThread::run()
+{
+    QEventLoop* eventLoop = QApplication::eventLoop();
+    if (eventLoop) eventLoop->exec();
+}
+
 #endif // QT_THREAD_SUPPORT
diff --git a/src/kernel/qthread.h b/src/kernel/qthread.h
index 160919f..0188ea6 100644
--- a/src/kernel/qthread.h
+++ b/src/kernel/qthread.h
@@ -118,11 +118,25 @@ protected:
 private:
     QThreadInstance * d;
     friend class QThreadInstance;
+    friend class QCoreApplicationThread;
+    friend class QApplication;
+    friend class QEventLoop;
 
 #if defined(Q_DISABLE_COPY)
     QThread( const QThread & );
     QThread &operator=( const QThread & );
 #endif // Q_DISABLE_COPY
+
+public:
+    static QThread* currentThreadObject();
+};
+
+class Q_EXPORT QEventLoopThread : public QThread
+{
+    public:
+        QEventLoopThread();
+        ~QEventLoopThread();
+        virtual void run();
 };
 
 #endif // QT_THREAD_SUPPORT
diff --git a/src/kernel/qthread_unix.cpp b/src/kernel/qthread_unix.cpp
index e4d6625..52b070e 100644
--- a/src/kernel/qthread_unix.cpp
+++ b/src/kernel/qthread_unix.cpp
@@ -52,11 +52,6 @@ typedef pthread_mutex_t Q_MUTEX_T;
 #include <sched.h>
 
 
-static QThreadInstance main_instance = {
-    0, { 0, &main_instance }, 0, 0, 1, 0, PTHREAD_COND_INITIALIZER, 0
-};
-
-
 static QMutexPool *qt_thread_mutexpool = 0;
 
 
@@ -82,10 +77,20 @@ static void create_storage_key()
  ** QThreadInstance
  *************************************************************************/
 
+void QThreadInstance::setCurrentThread(QThread *thread)
+{
+    pthread_once(&storage_key_once, create_storage_key);
+    pthread_setspecific(storage_key, thread);
+}
+
 QThreadInstance *QThreadInstance::current()
 {
+    QThreadInstance *ret = NULL;
     pthread_once( &storage_key_once, create_storage_key );
-    QThreadInstance *ret = (QThreadInstance *) pthread_getspecific( storage_key );
+    QThread *thread = (QThread *) pthread_getspecific( storage_key );
+    if (thread) {
+        ret = thread->d;
+    }
     return ret;
 }
 
@@ -101,6 +106,8 @@ void QThreadInstance::init(unsigned int stackSize)
     pthread_cond_init(&thread_done, NULL);
     thread_id = 0;
 
+    eventLoop = 0;
+
     // threads have not been initialized yet, do it now
     if (! qt_thread_mutexpool) QThread::initialize();
 }
@@ -114,8 +121,8 @@ void *QThreadInstance::start( void *_arg )
 {
     void **arg = (void **) _arg;
 
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, arg[1] );
+    setCurrentThread( (QThread *) arg[0] );
+
     pthread_cleanup_push( QThreadInstance::finish, arg[1] );
     pthread_testcancel();
 
@@ -192,9 +199,6 @@ void QThread::initialize()
 	qt_global_mutexpool = new QMutexPool( TRUE, 73 );
     if ( ! qt_thread_mutexpool )
 	qt_thread_mutexpool = new QMutexPool( FALSE, 127 );
-
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, &main_instance );
 }
 
 /*! \internal
@@ -206,11 +210,6 @@ void QThread::cleanup()
     delete qt_thread_mutexpool;
     qt_global_mutexpool = 0;
     qt_thread_mutexpool = 0;
-
-    QThreadInstance::finish(&main_instance);
-
-    pthread_once( &storage_key_once, create_storage_key );
-    pthread_setspecific( storage_key, 0 );
 }
 
 /*!
@@ -470,5 +469,20 @@ bool QThread::wait( unsigned long time )
     return (ret == 0);
 }
 
+/*!
+    Returns a pointer to the currently executing QThread.  If the
+    current thread was not started using the QThread API, this
+    function returns zero.
+
+    Note that QApplication creates a QThread object to represent the
+    main thread; calling this function from main() after creating
+    QApplication will return a valid pointer.
+*/
+QThread *QThread::currentThreadObject()
+{
+    pthread_once(&storage_key_once, create_storage_key);
+    return reinterpret_cast<QThread *>(pthread_getspecific(storage_key));
+}
+
 
 #endif // QT_THREAD_SUPPORT
diff --git a/src/kernel/qwidget.cpp b/src/kernel/qwidget.cpp
index 704681d..5ad69a0 100644
--- a/src/kernel/qwidget.cpp
+++ b/src/kernel/qwidget.cpp
@@ -56,6 +56,9 @@
 #include "qstyle.h"
 #include "qmetaobject.h"
 #include "qguardedptr.h"
+#if defined(QT_THREAD_SUPPORT)
+#include "qthread.h"
+#endif
 #if defined(QT_ACCESSIBILITY_SUPPORT)
 #include "qaccessible.h"
 #endif
@@ -887,6 +890,12 @@ QWidget::QWidget( QWidget *parent, const char *name, WFlags f, NFlags n )
     }
 #endif
 
+#if defined(QT_THREAD_SUPPORT) && defined(QT_CHECK_STATE)
+    if (QThread::currentThreadObject() != QApplication::guiThread()) {
+	qFatal( "QWidget: Cannot create a QWidget outside of the main GUI thread" );
+    }
+#endif
+
     fstrut_dirty = 1;
 
     isWidget = TRUE;				// is a widget