Changeset 22847 in vbox for trunk/src/VBox/Main/glue

Timestamp:

Sep 8, 2009 8:37:54 PM (16 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

52083

Message:

Python, COM glue: event processing API

Location:

trunk/src/VBox/Main/glue

Files:

• EventQueue.cpp (modified) (5 diffs)
• initterm.cpp (modified) (3 diffs)

trunk/src/VBox/Main/glue/EventQueue.cpp

@@ -69 +69 @@
 
 #endif // !defined (RT_OS_WINDOWS)
+
+EventQueue* EventQueue::mMainQueue = NULL;
 
 /**
@@ -146 +148 @@
 }
 
+/* static */ int EventQueue::init()
+{
+    mMainQueue = new EventQueue();
+#if defined (VBOX_WITH_XPCOM)
+    nsCOMPtr<nsIEventQueue> q;
+    nsresult rv = NS_GetMainEventQ(getter_AddRefs(q));
+    Assert(NS_SUCCEEDED(rv));
+    Assert(q == mMainQueue->mEventQ);
+    PRBool fIsNative = PR_FALSE;
+    rv = mMainQueue->mEventQ->IsQueueNative(&fIsNative);
+    Assert(NS_SUCCEEDED(rv) && fIsNative);
+#endif
+    return VINF_SUCCESS;
+}
+
+/* static */ int EventQueue::deinit()
+{
+    delete mMainQueue;
+    mMainQueue = NULL;
+    return VINF_SUCCESS;
+}
+
+/* static */ EventQueue* EventQueue::getMainEventQueue()
+{
+    return mMainQueue;
+}
+
+#ifdef RT_OS_DARWIN
+static int
+timedWaitForEventsOnDarwin(nsIEventQueue *pQueue, PRInt32 cMsTimeout)
+{
+  // This deals with the common case where the caller is the main
+  // application thread and the queue is a native one.
+  OSStatus       orc       = -1;
+  CFTimeInterval rdTimeout = (double)cMsTimeout / 1000;
+  orc = CFRunLoopRunInMode(kCFRunLoopDefaultMode, rdTimeout, true /*returnAfterSourceHandled*/);
+  if (orc == kCFRunLoopRunHandledSource)
+    orc = CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.0, false /*returnAfterSourceHandled*/);
+  if (!orc || orc == kCFRunLoopRunHandledSource)
+    return VINF_SUCCESS;
+
+  if (orc != kCFRunLoopRunTimedOut) 
+  {
+      NS_WARNING("Unexpected status code from CFRunLoopRunInMode");
+  }
+
+  return VERR_TIMEOUT;
+}
+#endif
+
+#ifdef RT_OS_WINDOWS
+static int
+processPendingEventsOnWindows()
+{
+    MSG Msg;
+    int rc = VERR_TIMEOUT;
+    while (PeekMessage(&Msg, NULL /*hWnd*/, 0 /*wMsgFilterMin*/, 0 /*wMsgFilterMax*/, PM_REMOVE))
+    {
+        if (Msg.message == WM_QUIT)
+            rc = VERR_INTERRUPTED;
+        DispatchMessage(&Msg);
+        if (rc == VERR_INTERRUPTED)
+            break;
+        rc = VINF_SUCCESS; 
+    }    
+    return rc;
+}
+/** For automatic cleanup,   */
+class MyThreadHandle
+{
+public:
+  HANDLE mh;
+  
+  MyThreadHandle()
+  {
+    if (!DuplicateHandle(GetCurrentProcess(), 
+                         GetCurrentThread(), 
+                         GetCurrentProcess(),
+                         &mh, 
+                         0 /*dwDesiredAccess*/, 
+                         FALSE /*bInheritHandle*/,
+                         DUPLICATE_SAME_ACCESS))
+      mh = INVALID_HANDLE_VALUE;
+  }
+
+  ~MyThreadHandle()
+  {
+    CloseHandle(mh);
+    mh = INVALID_HANDLE_VALUE;
+  }
+};
+#endif
+#include <stdio.h>
+int EventQueue::processEventQueue(uint32_t cMsTimeout)
+{
+    int rc = VINF_SUCCESS;
+#if defined (VBOX_WITH_XPCOM)
+    do {
+      PRBool fHasEvents = PR_FALSE;
+      nsresult rc;
+      
+      rc = mEventQ->PendingEvents(&fHasEvents);
+      if (NS_FAILED (rc))
+          return VERR_INTERNAL_ERROR_3;
+
+      if (fHasEvents || cMsTimeout == 0)
+          break;
+
+      /**
+       * Unfortunately, WaitForEvent isn't interruptible with Ctrl-C,
+       * while select() is.
+       */
+
+      if (cMsTimeout == RT_INDEFINITE_WAIT)
+      {
+#if 0
+          PLEvent *pEvent = NULL;
+          int rc1 = mEventQ->WaitForEvent(&pEvent);
+          if (NS_FAILED(rc1) || pEvent == NULL)
+          {
+                rc = VERR_INTERRUPTED;
+                break;
+          }
+          mEventQ->HandleEvent(pEvent);
+          break;
+#else
+          /* Pretty close to forever */
+          cMsTimeout = 0xffff0000;
+#endif
+      }
+      
+      /* Bit tricky part - perform timed wait */
+#  ifdef RT_OS_DARWIN
+      rc = timedWaitForEventsOnDarwin(mEventQ, cMsTimeout);
+#  else
+      int fd = mEventQ->GetEventQueueSelectFD();
+      fd_set fdsetR, fdsetE;
+      struct timeval tv;
+      
+      FD_ZERO(&fdsetR);
+      FD_SET(fd, &fdsetR);
+      
+      fdsetE = fdsetR;
+      tv.tv_sec = (PRInt64)cMsTimeout / 1000;
+      tv.tv_usec = ((PRInt64)cMsTimeout % 1000) * 1000;
+
+      int aCode = select(fd + 1, &fdsetR, NULL, &fdsetE, &tv);
+      if (aCode == 0)
+        rc = VERR_TIMEOUT;
+      else if (aCode == EINTR)
+        rc = VERR_INTERRUPTED;
+      else if (aCode < 0)
+        rc = VERR_INTERNAL_ERROR_4;
+      
+#  endif      
+    } while (0);
+
+    mEventQ->ProcessPendingEvents();
+#else /* Windows */
+    do {
+        int aCode = processPendingEventsOnWindows();
+        if (aCode != VERR_TIMEOUT || cMsTimeout == 0)
+        {
+            rc = aCode;
+            break;
+        }
+        
+        if (cMsTimeout == RT_INDEFINITE_WAIT)
+        {
+            Event* aEvent = NULL;
+          
+            fHasEvent = waitForEvent(&aEvent);
+            if (fHasEvent)
+              handleEvent(aEvent);
+            else
+              rc = VERR_INTERRUPTED;
+            break;
+        }
+
+        /* Perform timed wait */
+        MyThreadHandle aHandle;
+
+        DWORD aCode = MsgWaitForMultipleObjects(1, &aHandle.mh, 
+                                             TRUE /*fWaitAll*/, 
+                                             0 /*ms*/, 
+                                             QS_ALLINPUT);
+        if (aCode == WAIT_TIMEOUT)
+            rc = VERR_TIMEOUT;
+        else if (aCode == WAIT_OBJECT_0)
+            rc = VINF_SUCCESS;
+        else
+            rc = VERR_INTERNAL_ERROR_4;
+    } while (0);
+
+    processPendingEventsOnWindows();
+#endif
+    return rc;
+
+}
+
+int EventQueue::interruptEventQueueProcessing()
+{
+    postEvent(NULL);
+    return VINF_SUCCESS;
+}
+
 /**
  *  Posts an event to this event loop asynchronously.
@@ -287 +495 @@
 
 #else
-
-/** For automatic cleanup.  */
-class MyThreadHandle
-{
-public:
-    HANDLE mh;
-
-    MyThreadHandle(HANDLE hThread)
-    {
-        if (!DuplicateHandle(GetCurrentProcess(), hThread, GetCurrentProcess(),
-                             &mh, 0 /*dwDesiredAccess*/, FALSE /*bInheritHandle*/,
-                             DUPLICATE_SAME_ACCESS))
-            mh = INVALID_HANDLE_VALUE;
-    }
-
-    ~MyThreadHandle()
-    {
-        CloseHandle(mh);
-        mh = INVALID_HANDLE_VALUE;
-    }
-};
 
 /** COM version of nsIEventQueue::PendingEvents. */
@@ -386 +573 @@
         return VERR_NOT_FOUND;
 #else
-    MyThreadHandle q(GetCurrentThread());
+    MyThreadHandle q;
 #endif
 
@@ -530 +717 @@
     return VINF_SUCCESS;
 }
-
 }
 /* namespace com */

trunk/src/VBox/Main/glue/initterm.cpp

@@ -53 +53 @@
 #include "VBox/com/com.h"
 #include "VBox/com/assert.h"
+#include "VBox/com/EventQueue.h"
 
 #include "../include/Logging.h"
@@ -497 +498 @@
     AssertComRC (rc);
 
+    EventQueue::init();
+
     return rc;
 }
@@ -503 +506 @@
 {
     HRESULT rc = S_OK;
+
+    EventQueue::deinit();
 
 #if !defined (VBOX_WITH_XPCOM)