Changeset 2540 in vbox for trunk

Timestamp:

May 8, 2007 4:06:27 PM (18 years ago)

Author:

vboxsync

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

20981

Message:

Main & All Frontends: Improved console window activation helper APIs (still no success on X11, works well on Win32, the old method of activation is disabled).

Location:

trunk/src/VBox

Files:

• Frontends/VBoxSDL/VBoxSDL.cpp (modified) (2 diffs)
• Frontends/VirtualBox/include/VBoxVMListBox.h (modified) (2 diffs)
• Frontends/VirtualBox/src/VBoxConsoleView.cpp (modified) (8 diffs)
• Frontends/VirtualBox/src/VBoxVMListBox.cpp (modified) (8 diffs)
• Frontends/VirtualBox/src/main.cpp (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (2 diffs)
• Main/MachineImpl.cpp (modified) (3 diffs)
• Main/SessionImpl.cpp (modified) (2 diffs)
• Main/idl/VirtualBox.xidl (modified) (5 diffs)
• Main/include/ConsoleImpl.h (modified) (1 diff)
• Main/include/DisplayImpl.h (modified) (1 diff)
• Main/include/MachineImpl.h (modified) (1 diff)
• Main/include/SessionImpl.h (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

@@ -38 +38 @@
 #include <X11/cursorfont.h>      /* for XC_left_ptr */
 #include <X11/Xcursor/Xcursor.h>
+#endif
+
 #include <SDL_syswm.h>           /* for SDL_GetWMInfo() */
-#endif
 
 #include "VBoxSDL.h"
@@ -506 +507 @@
         if (!canShow)
             return E_POINTER;
-        /* @todo return TRUE if gConsole is not NULL */
+#if defined (__LINUX__)
+        /// @todo see the big comment in Frontends/VirtualBox/src/VBoxVMListBoxItem::switchTo()
         *canShow = FALSE;
+#else
+        SDL_SysWMinfo info;
+        SDL_VERSION(&info.version);
+        *canShow = !!SDL_GetWMInfo(&info);
+#endif
         return S_OK;
     }
 
-    STDMETHOD(OnShowWindow)()
-    {
-        /* @todo implement */
-        return E_NOTIMPL;
+    STDMETHOD(OnShowWindow) (ULONG64 *winId)
+    {
+        SDL_SysWMinfo info;
+        SDL_VERSION(&info.version);
+        if (SDL_GetWMInfo(&info))
+        {
+#if defined (__LINUX__)
+            *winId = (ULONG64) info.info.x11.window;
+#elif defined (__WIN__)
+            *winId = (ULONG64) info.window;
+#else
+            AssertFailed();
+            return E_FAIL;
+#endif
+            return S_OK;
+        }
+        AssertFailed();
+        return E_FAIL;
     }
 

trunk/src/VBox/Frontends/VirtualBox/include/VBoxVMListBox.h

@@ -133 +133 @@
     ULONG snapshotCount() const { return mSnapshotCount; }
 
+    /// @todo see comments in #switchTo() in VBoxVMListBox.cpp
+#if 0
     bool canSwitchTo() const { return mWinId != (WId) ~0; }
+#endif
+    bool canSwitchTo() const;
     bool switchTo();
 
@@ -161 +165 @@
 
     ULONG mPid;
+    /// @todo see comments in #switchTo() in VBoxVMListBox.cpp
+#if 0
     WId mWinId;
+#endif
 };
 

trunk/src/VBox/Frontends/VirtualBox/src/VBoxConsoleView.cpp

@@ -280 +280 @@
     VBoxConsoleCallback (VBoxConsoleView *v) {
 #if defined (Q_WS_WIN)
-        refcnt = 0;
-#endif
-        view = v;
+        mRefCnt = 0;
+#endif
+        mView = v;
     }
 
@@ -291 +291 @@
 #if defined (Q_WS_WIN)
     STDMETHOD_(ULONG, AddRef)() {
-        return ::InterlockedIncrement (&refcnt);
+        return ::InterlockedIncrement (&mRefCnt);
     }
     STDMETHOD_(ULONG, Release)()
     {
-        long cnt = ::InterlockedDecrement (&refcnt);
+        long cnt = ::InterlockedDecrement (&mRefCnt);
         if (cnt == 0)
             delete this;
@@ -322 +322 @@
                                           BYTE *shape)
     {
-        QApplication::postEvent (
-            view, new MousePointerChangeEvent (visible, alpha, xhot, yhot,
-                                               width, height,
-                                               shape)
-        );
+        QApplication::postEvent (mView,
+                                 new MousePointerChangeEvent (visible, alpha,
+                                                              xhot, yhot,
+                                                              width, height, shape));
         return S_OK;
     }
@@ -332 +331 @@
     STDMETHOD(OnMouseCapabilityChange)(BOOL supportsAbsolute, BOOL needsHostCursor)
     {
-        QApplication::postEvent (view, new MouseCapabilityEvent (supportsAbsolute, needsHostCursor));
+        QApplication::postEvent (mView,
+                                 new MouseCapabilityEvent (supportsAbsolute,
+                                                           needsHostCursor));
         return S_OK;
     }
@@ -339 +340 @@
     {
         LogFlowFunc (("machineState=%d\n", machineState));
-        QApplication::postEvent (
-            view, new StateChangeEvent ((CEnums::MachineState) machineState));
+        QApplication::postEvent (mView,
+                                 new StateChangeEvent (
+                                     (CEnums::MachineState) machineState));
         return S_OK;
     }
@@ -346 +348 @@
     STDMETHOD(OnAdditionsStateChange)()
     {
-        CGuest guest = view->console().GetGuest();
+        CGuest guest = mView->console().GetGuest();
         LogFlowFunc (("ver=%s, active=%d\n",
                       guest.GetAdditionsVersion().latin1(),
@@ -356 +358 @@
     STDMETHOD(OnKeyboardLedsChange)(BOOL fNumLock, BOOL fCapsLock, BOOL fScrollLock)
     {
-        QApplication::postEvent (
-            view, new ModifierKeyChangeEvent (fNumLock, fCapsLock, fScrollLock));
+        QApplication::postEvent (mView,
+                                 new ModifierKeyChangeEvent (fNumLock, fCapsLock,
+                                                             fScrollLock));
         return S_OK;
     }
@@ -363 +366 @@
     STDMETHOD(OnRuntimeError)(BOOL fatal, IN_BSTRPARAM id, IN_BSTRPARAM message)
     {
-        QApplication::postEvent (
-            view, new RuntimeErrorEvent (!!fatal, QString::fromUcs2 (id),
-                                         QString::fromUcs2 (message)));
+        QApplication::postEvent (mView,
+                                 new RuntimeErrorEvent (!!fatal,
+                                                        QString::fromUcs2 (id),
+                                                        QString::fromUcs2 (message)));
         return S_OK;
     }
 
-    STDMETHOD(OnCanShowWindow)(BOOL *canShow)
+    STDMETHOD(OnCanShowWindow) (BOOL *canShow)
     {
         if (!canShow)
             return E_POINTER;
-        /* @todo return TRUE... */
+
+#if defined (Q_WS_X11)
+        /// @todo see the big comment in VBoxVMListBoxItem::switchTo()
         *canShow = FALSE;
+#else
+        *canShow = TRUE;
+#endif
         return S_OK;
     }
 
-    STDMETHOD(OnShowWindow)()
-    {
-        /* @todo implement */
-        return E_NOTIMPL;
+    STDMETHOD(OnShowWindow) (ULONG64 *winId)
+    {
+        if (!winId)
+            return E_POINTER;
+
+        /* Return the ID of the top-level console window. */
+        *winId = (ULONG64) mView->topLevelWidget()->winId();
+
+        return S_OK;
     }
 
 protected:
 
-    VBoxConsoleView *view;
+    VBoxConsoleView *mView;
 
 #if defined (Q_WS_WIN)
 private:
-    long refcnt;
+    long mRefCnt;
 #endif
 };

trunk/src/VBox/Frontends/VirtualBox/src/VBoxVMListBox.cpp

@@ -34 +34 @@
 #include <qfileinfo.h>
 
-#if defined (Q_WS_MAC)
+#if defined (Q_WS_X11)
+# include <X11/Xlib.h>
+#elif defined (Q_WS_MAC)
 # include <Carbon/Carbon.h>
 #endif
@@ -42 +44 @@
 // Helpers
 ////////////////////////////////////////////////////////////////////////////////
+
+/// @todo Remove. See @c todo in #switchTo() below.
+#if 0
 
 #if defined (Q_WS_WIN32)
@@ -136 +141 @@
 }
 
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // VBoxVMListBoxItem class
@@ -367 +374 @@
         {
             mPid = mMachine.GetSessionPid();
+    /// @todo Remove. See @c todo in #switchTo() below.
+#if 0
             mWinId = FindWindowIdFromPid (mPid);
+#endif
         }
         else
         {
             mPid = (ULONG) ~0;
+    /// @todo Remove. See @c todo in #switchTo() below.
+#if 0
             mWinId = (WId) ~0;
+#endif
         }
     }
@@ -393 +406 @@
 
         mPid = (ULONG) ~0;
+    /// @todo Remove. See @c todo in #switchTo() below.
+#if 0
         mWinId = (WId) ~0;
+#endif
     }
 
@@ -507 +523 @@
 
 /** 
+ * Returns @a true if we can activate and bring the VM console window to
+ * foreground, and @a false otherwise.
+ */
+bool VBoxVMListBoxItem::canSwitchTo() const
+{
+    return const_cast <CMachine &> (mMachine).CanShowConsoleWindow();
+
+    /// @todo Remove. See @c todo in #switchTo() below.
+#if 0
+    return mWinId != (WId) ~0;
+#endif
+}
+
+/** 
  * Tries to switch to the main window of the VM process.
  * 
@@ -513 +543 @@
 bool VBoxVMListBoxItem::switchTo()
 {
+    WId id = (WId) mMachine.ShowConsoleWindow();
+    AssertWrapperOk (mMachine);
+    if (!mMachine.isOk())
+        return false;
+
+    /* winId = 0 it means the console window has already done everything
+     * necessary to implement the "show window" semantics. */
+    if (id == 0)
+        return true;
+
+#if defined (Q_WS_WIN32)
+
+    if (IsIconic (id))
+        ShowWindow (id, SW_RESTORE);
+    else if (!IsWindowVisible (id))
+        ShowWindow (id, SW_SHOW);
+
+    return SetForegroundWindow (id);
+
+#elif defined (Q_WS_X11)
+
+    /// @todo I've tried XRaiseWindow, XConfigureWindow, XRestackWindows and
+    /// XSetInputFocus here but couldn't get a useless result under
+    /// metacity/Ubuntu-7.04.  XSetInputFocus works, but XRaiseWindow and
+    /// friends don't -- when it comes to bringing the window represented by
+    /// the given id (or its parent) to front, on top of all other top-level
+    /// windows. As a result, we would get input focus to a possibly invisible
+    /// (obscured by others) window!.. I've found one way to steal raise
+    /// window events from Metacity and prevent it from applying focus
+    /// stealing prevention (by settings override_redirect to True on the id's
+    /// parent using using XChangeWindowAttributes), but the result didn't
+    /// satisfy me: the raised console window started to behave like an
+    /// always-on-top window until moved or minimized which is wrong. Also,
+    /// there is little hope that this approach will work for other window
+    /// managers with "strong" focus stealing prevention algorithms, so I
+    /// decided to completely disable this feature on X11 -- Until someone has
+    /// enough time to find an acceptable solution that will work constantly
+    /// well under at least selected window managers, and will be simply
+    /// disabled on those where it doesn't work.
+
+    return false;
+
+#elif defined (Q_WS_MAC)
+
+    /// @todo (r=dmik) Knut, everything you have to do here is to raise the
+    /// given window over all other top-level windows and give it focus. Ah,
+    /// and deiconify/show it first if it is minimized/hidden. I really hope
+    /// it's better on Mac than on X11. If not, feel free to revert to the
+    /// previous pid-based behavior.
+
+    return false;
+
+#endif
+
+    return false;
+
+    /// @todo Below is the old method of switching to the console window
+    //  based on the process ID of the console process. It should go away
+    //  after the new (callback-based) method is fully tested.
+#if 0
+
     if (!canSwitchTo())
         return false;
@@ -575 +666 @@
 
     return false;
+
+#endif
 
 #endif

trunk/src/VBox/Frontends/VirtualBox/src/main.cpp

@@ -135 +135 @@
 
     QIApplication a (argc, argv);
+
+    /* weird palette test */
+#if 0
+    QPalette pal = a.palette();
+    pal.setColor (QColorGroup::Background, Qt::red);
+    pal.setBrush (QColorGroup::Background,
+                  QBrush (QColor(),
+                          QPixmap::fromMimeSource ("about_16px.png")));
+    a.setPalette (pal);
+#endif
 
 #ifdef Q_WS_X11

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -3546 +3546 @@
  *  @note Locks this object for reading.
  */
-HRESULT Console::onShowWindow (BOOL aCheck, BOOL *aCanShow)
+HRESULT Console::onShowWindow (BOOL aCheck, BOOL *aCanShow, ULONG64 *aWinId)
 {
     AssertReturn (aCanShow, E_POINTER);
+    AssertReturn (aWinId, E_POINTER);
 
     *aCanShow = FALSE;
+    *aWinId = 0;
 
     AutoCaller autoCaller (this);
@@ -3576 +3578 @@
         while (it != mCallbacks.end())
         {
-            rc = (*it++)->OnShowWindow();
+            ULONG64 winId = 0;
+            rc = (*it++)->OnShowWindow (&winId);
+            AssertComRC (rc);
             if (FAILED (rc))
                 return rc;
+            /* only one callback may return non-null winId */
+            Assert (*aWinId == 0 || winId == 0);
+            if (*aWinId == 0)
+                *aWinId = winId;
         }
     }

trunk/src/VBox/Main/MachineImpl.cpp

@@ -2301 +2301 @@
 
     /* start with No */
-    aCanShow = FALSE;
+    *aCanShow = FALSE;
 
     AutoCaller autoCaller (this);
@@ -2322 +2322 @@
         return S_OK;
 
-    return directControl->OnShowWindow (TRUE /* aCheck */, aCanShow);
-}
-
-STDMETHODIMP Machine::ShowConsoleWindow()
-{
+    ULONG64 dummy;
+    return directControl->OnShowWindow (TRUE /* aCheck */, aCanShow, &dummy);
+}
+
+STDMETHODIMP Machine::ShowConsoleWindow (ULONG64 *aWinId)
+{
+    if (!aWinId)
+        return E_POINTER;
+
     AutoCaller autoCaller (this);
     AssertComRCReturn (autoCaller.rc(), autoCaller.rc());
@@ -2347 +2351 @@
 
     BOOL dummy;
-    return directControl->OnShowWindow (FALSE /* aCheck */, &dummy);
+    return directControl->OnShowWindow (FALSE /* aCheck */, &dummy, aWinId);
 }
 

trunk/src/VBox/Main/SessionImpl.cpp

@@ -590 +590 @@
 }
 
-STDMETHODIMP Session::OnShowWindow (BOOL aCheck, BOOL *aCanShow)
+STDMETHODIMP Session::OnShowWindow (BOOL aCheck, BOOL *aCanShow, ULONG64 *aWinId)
 {
     AutoCaller autoCaller (this);
@@ -599 +599 @@
                   mType == SessionType_DirectSession, E_FAIL);
 
-    return mConsole->onShowWindow (aCheck, aCanShow);
+    return mConsole->onShowWindow (aCheck, aCanShow, aWinId);
 }
 

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -2585 +2585 @@
         <method name="showConsoleWindow">
             <desc>
-                Returns @c true if the VM console process can activate the
-                console window and bring it to foreground on the desktop of
-                the host PC.
+                Activates the console window and brings it to foreground on
+                the desktop of the host PC. Many modern window managers on
+                many platforms implement some sort of focus stealing
+                prevention logic, so that it may be impossible to activate
+                a window without the help of the currently active
+                application. In this case, this method will return a non-zero
+                identifier that represents the top-level window of the VM
+                console process. The caller, if it represents a currently
+                active process, is responsible to use this identifier (in a
+                platform-dependent manner) to perform actual window
+                activation.
                 <note>
                     This method will fail if a session for this machine is not
@@ -2593 +2601 @@
                 </note>
             </desc>
+            <param name="winId" type="unsigned long long" dir="return">
+                <desc>
+                  Platform-dependent identifier of the top-level VM console
+                  window, or zero if this method has performed all actions
+                  necessary to implement the <i>show window</i> semantics for
+                  the given platform and/or VirtualBox front-end.
+                </desc>
+            </param>
         </method>
 
@@ -2819 +2835 @@
                 method should return a failure.
 
+                Note that many modern window managers on many platforms
+                implement some sort of focus stealing prevention logic, so
+                that it may be impossible to activate a window without the
+                help of the currently active application (which is supposedly
+                an initiator of this notification). In this case, this method
+                must return a non-zero identifier that represents the
+                top-level window of the VM console process. The caller, if it
+                represents a currently active process, is responsible to use
+                this identifier (in a platform-dependent manner) to perform
+                actual window activation.
+
+                This method must set @a winId to zero if it has performed all
+                actions necessary to complete the request and the console
+                window is now active and in foreground, to indicate that no
+                further action is required on the caller's side.
+
                 <note>
                     This notification is not designed to be implemented by
@@ -2828 +2860 @@
                 </note>
             </desc>
+            <param name="winId" type="unsigned long long" dir="return">
+                <desc>
+                    Platform-dependent identifier of the top-level VM console
+                    window, or zero if this method has performed all actions
+                    necessary to implement the <i>show window</i> semantics for
+                    the given platform and/or this VirtualBox front-end.
+                </desc>
+            </param>
         </method>
 
@@ -7415 +7455 @@
             <param name="check" type="boolean" dir="in"/>
             <param name="canShow" type="boolean" dir="out"/>
+            <param name="winId" type="unsigned long long" dir="out"/>
         </method>
 

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -199 +199 @@
     void onKeyboardLedsChange (bool fNumLock, bool fCapsLock, bool fScrollLock);
     void onRuntimeError (BOOL aFatal, INPTR BSTR aErrorID, INPTR BSTR aMessage);
-    HRESULT onShowWindow (BOOL aCheck, BOOL *aCanShow);
+    HRESULT onShowWindow (BOOL aCheck, BOOL *aCanShow, ULONG64 *aWinId);
 
     static const PDMDRVREG DrvStatusReg;

trunk/src/VBox/Main/include/DisplayImpl.h

@@ -115 +115 @@
     }
 
-    STDMETHOD(OnShowWindow)()
-    {
+    STDMETHOD(OnShowWindow)(ULONG64 *winId)
+    {
+        if (winId)
+            *winId = 0;
         return S_OK;
     }

trunk/src/VBox/Main/include/MachineImpl.h

@@ -367 +367 @@
     STDMETHOD(RemoveSharedFolder) (INPTR BSTR aName);
     STDMETHOD(CanShowConsoleWindow) (BOOL *aCanShow);
-    STDMETHOD(ShowConsoleWindow)();
+    STDMETHOD(ShowConsoleWindow) (ULONG64 *aWinId);
 
     // public methods only for internal purposes

trunk/src/VBox/Main/include/SessionImpl.h

@@ -102 +102 @@
     STDMETHOD(OnUSBDeviceAttach) (IUSBDevice *aDevice);
     STDMETHOD(OnUSBDeviceDetach) (INPTR GUIDPARAM aId);
-    STDMETHOD(OnShowWindow) (BOOL aCheck, BOOL *aCanShow);
+    STDMETHOD(OnShowWindow) (BOOL aCheck, BOOL *aCanShow, ULONG64 *aWinId);
 
     // for VirtualBoxSupportErrorInfoImpl