Changeset 86161 in vbox for trunk/src/VBox

Timestamp:

Sep 17, 2020 5:24:19 PM (4 years ago)

Author:

vboxsync

Message:

FE/Qt: bugref:9653: UIProgressDialog: Rework UIProgress to be based on IProgress events purely, not on Qt timer.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• settings/machine/UIMachineSettingsGeneral.cpp (modified) (1 diff)
• widgets/UIProgressDialog.cpp (modified) (1 diff)
• widgets/UIProgressDialog.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsGeneral.cpp

@@ -1153 +1153 @@
                     }
 
-                    /* Create encryption update progress dialog: */
-                    QPointer<UIProgress> pDlg;
+                    /* Create encryption update progress object: */
+                    QPointer<UIProgress> pObject;
                     if (fSuccess)
                     {
-                        pDlg = new UIProgress(comProgress);
-                        connect(pDlg.data(), &UIProgress::sigProgressChange,
-                                this, &UIMachineSettingsGeneral::sigOperationProgressChange,
-                                Qt::QueuedConnection);
-                        connect(pDlg.data(), &UIProgress::sigProgressError,
-                            this, &UIMachineSettingsGeneral::sigOperationProgressError,
-                                Qt::BlockingQueuedConnection);
-                        pDlg->run(350);
-                        if (pDlg)
-                            delete pDlg;
-                        else
+                        pObject = new UIProgress(comProgress);
+                        if (pObject)
                         {
-                            // Premature application shutdown,
-                            // exit immediately:
-                            return true;
+                            connect(pObject.data(), &UIProgress::sigProgressChange,
+                                    this, &UIMachineSettingsGeneral::sigOperationProgressChange,
+                                    Qt::QueuedConnection);
+                            connect(pObject.data(), &UIProgress::sigProgressError,
+                                    this, &UIMachineSettingsGeneral::sigOperationProgressError,
+                                    Qt::BlockingQueuedConnection);
+                            pObject->run();
+                            if (pObject)
+                                delete pObject;
+                            else
+                            {
+                                // Premature application shutdown,
+                                // exit immediately:
+                                return true;
+                            }
                         }
                     }

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIProgressDialog.cpp

@@ -551 +551 @@
     : QObject(pParent)
     , m_comProgress(comProgress)
-    , m_cOperations(m_comProgress.GetOperationCount())
+    , m_pEventHandler(0)
     , m_fEnded(false)
 {
-}
-
-void UIProgress::run(int iRefreshInterval)
-{
-    /* Make sure the CProgress still valid: */
-    if (!m_comProgress.isOk())
+    prepare();
+}
+
+UIProgress::~UIProgress()
+{
+    cleanup();
+}
+
+void UIProgress::run()
+{
+    /* Make sure progress hasn't aborted/finished already: */
+    if (!m_comProgress.isOk() || m_comProgress.GetCompleted())
         return;
 
-    /* Start the refresh timer: */
-    int id = startTimer(iRefreshInterval);
-
-    /* Create a local event-loop: */
-    {
-        QEventLoop eventLoop;
-        m_pEventLoop = &eventLoop;
-
-        /* Guard ourself for the case
-         * we destroyed ourself in our event-loop: */
-        QPointer<UIProgress> guard = this;
-
-        /* Start the blocking event-loop: */
-        eventLoop.exec();
-
-        /* Are we still valid? */
-        if (guard.isNull())
-            return;
-
-        m_pEventLoop = 0;
-    }
-
-    /* Kill the refresh timer: */
-    killTimer(id);
-}
-
-void UIProgress::timerEvent(QTimerEvent *)
-{
-    /* Make sure the UIProgress still 'running': */
-    if (m_fEnded)
+    /* We are creating a locally-scoped event-loop object,
+     * but holding a pointer to it for a control needs: */
+    QEventLoop eventLoop;
+    m_pEventLoop = &eventLoop;
+
+    /* Guard ourself for the case
+     * we self-destroyed in our event-loop: */
+    QPointer<UIProgress> guard = this;
+
+    /* Start the blocking event-loop: */
+    eventLoop.exec();
+
+    /* Event-loop object unblocked,
+     * Are we still valid? */
+    if (guard.isNull())
         return;
 
-    /* If progress had failed or finished: */
-    if (!m_comProgress.isOk() || m_comProgress.GetCompleted())
-    {
-        /* Notify listeners about the operation progress error: */
-        if (!m_comProgress.isOk() || m_comProgress.GetResultCode() != 0)
-            emit sigProgressError(UIErrorString::formatErrorInfo(m_comProgress));
-
-        /* Exit from the event-loop if there is any: */
-        if (m_pEventLoop)
-            m_pEventLoop->exit();
-
-        /* Mark UIProgress as 'ended': */
-        m_fEnded = true;
-
-        /* Return early: */
-        return;
-    }
-
-    /* If CProgress was not yet canceled: */
-    if (!m_comProgress.GetCanceled())
-    {
-        /* Notify listeners about the operation progress update: */
-        emit sigProgressChange(m_cOperations, m_comProgress.GetOperationDescription(),
-                               m_comProgress.GetOperation() + 1, m_comProgress.GetPercent());
-    }
-}
+    /* Cleanup the pointer finally: */
+    m_pEventLoop = 0;
+}
+
+void UIProgress::sltHandleProgressPercentageChange(const QUuid &, const int iPercent)
+{
+    emit sigProgressChange(m_comProgress.GetOperationCount(),
+                           m_comProgress.GetOperationDescription(),
+                           m_comProgress.GetOperation(),
+                           iPercent);
+}
+
+void UIProgress::sltHandleProgressTaskComplete(const QUuid &)
+{
+    /* Notify listeners about the operation progress error: */
+    if (!m_comProgress.isOk() || m_comProgress.GetResultCode() != 0)
+        emit sigProgressError(UIErrorString::formatErrorInfo(m_comProgress));
+
+    /* Exit from the event-loop if there is any: */
+    if (m_pEventLoop)
+        m_pEventLoop->exit();
+}
+
+void UIProgress::prepare()
+{
+    /* Create CProgress event handler: */
+    m_pEventHandler = new UIProgressEventHandler(this, m_comProgress);
+    connect(m_pEventHandler, &UIProgressEventHandler::sigProgressPercentageChange,
+            this, &UIProgress::sltHandleProgressPercentageChange);
+    connect(m_pEventHandler, &UIProgressEventHandler::sigProgressTaskComplete,
+            this, &UIProgress::sltHandleProgressTaskComplete);
+}
+
+void UIProgress::cleanup()
+{
+    /* Destroy CProgress event handler: */
+    delete m_pEventHandler;
+    m_pEventHandler = 0;
+}

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIProgressDialog.h

@@ -199 +199 @@
       * @param  comProgress   Brings the progress reference. */
     UIProgress(CProgress &comProgress, QObject *pParent = 0);
-
-    /** Executes the progress-handler within its loop with passed @a iRefreshInterval. */
-    void run(int iRefreshInterval);
+    /** Destructs progress handler. */
+    virtual ~UIProgress() /* override */;
+
+    /** Executes the progress-handler within its loop. */
+    void run();
+
+private slots:
+
+    /** Handles percentage changed event for progress with @a uProgressId to @a iPercent. */
+    void sltHandleProgressPercentageChange(const QUuid &uProgressId, const int iPercent);
+    /** Handles task completed event for progress with @a uProgressId. */
+    void sltHandleProgressTaskComplete(const QUuid &uProgressId);
 
 private:
 
-    /** Handles timer @a pEvent. */
-    virtual void timerEvent(QTimerEvent *pEvent) /* override */;
+    /** Prepares all. */
+    void prepare();
+    /** Prepares event handler. */
+    void prepareEventHandler();
+    /** Cleanups event handler. */
+    void cleanupEventHandler();
+    /** Cleanups all. */
+    void cleanup();
 
     /** Holds the progress reference. */
     CProgress &m_comProgress;
 
-    /** Holds the amount of operations. */
-    const ulong  m_cOperations;
+    /** Holds the progress event handler instance. */
+    UIProgressEventHandler *m_pEventHandler;
+
     /** Holds whether the progress has ended. */
-    bool         m_fEnded;
+    bool  m_fEnded;
 
     /** Holds the personal event-loop instance. */