Changeset 67121 in vbox for trunk/src/VBox

Timestamp:

May 26, 2017 4:09:51 PM (8 years ago)

Author:

vboxsync

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

115792

Message:

FE/Qt: Selector UI: Tools pane: Snapshot pane: Reordering.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/selector

Files:

• UISnapshotPane.cpp (modified) (10 diffs)
• UISnapshotPane.h (modified) (6 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/selector/UISnapshotPane.cpp

@@ -521 +521 @@
     : QIWithRetranslateUI<QWidget>(pParent)
     , m_enmSessionState(KSessionState_Null)
-    , m_pCurrentSnapshotItem(0)
+    , m_fShapshotOperationsAllowed(false)
     , m_pLockReadWrite(0)
+    , m_pIconSnapshotOffline(0)
+    , m_pIconSnapshotOnline(0)
+    , m_pTimerUpdateAge(0)
     , m_pToolBar(0)
     , m_pActionTakeSnapshot(0)
+    , m_pActionDeleteSnapshot(0)
     , m_pActionRestoreSnapshot(0)
-    , m_pActionDeleteSnapshot(0)
     , m_pActionShowSnapshotDetails(0)
     , m_pActionCloneSnapshot(0)
-    , m_pTimerUpdateAge(0)
-    , m_fShapshotOperationsAllowed(false)
-    , m_pIconSnapshotOffline(0)
-    , m_pIconSnapshotOnline(0)
     , m_pSnapshotTree(0)
+    , m_pCurrentSnapshotItem(0)
 {
     /* Prepare: */
@@ -580 +580 @@
     /* Translate actions names: */
     m_pActionTakeSnapshot->setText(tr("&Take..."));
+    m_pActionDeleteSnapshot->setText(tr("&Delete"));
     m_pActionRestoreSnapshot->setText(tr("&Restore"));
-    m_pActionDeleteSnapshot->setText(tr("&Delete"));
     m_pActionShowSnapshotDetails->setText(tr("D&etails..."));
     m_pActionCloneSnapshot->setText(tr("&Clone..."));
     /* Translate actions tool-tips: */
     m_pActionTakeSnapshot->setToolTip(tr("Take Snapshot (%1)").arg(m_pActionTakeSnapshot->shortcut().toString()));
+    m_pActionDeleteSnapshot->setToolTip(tr("Delete Snapshot (%1)").arg(m_pActionDeleteSnapshot->shortcut().toString()));
     m_pActionRestoreSnapshot->setToolTip(tr("Restore Snapshot (%1)").arg(m_pActionRestoreSnapshot->shortcut().toString()));
-    m_pActionDeleteSnapshot->setToolTip(tr("Delete Snapshot (%1)").arg(m_pActionDeleteSnapshot->shortcut().toString()));
     m_pActionShowSnapshotDetails->setToolTip(tr("Show Snapshot Details (%1)").arg(m_pActionShowSnapshotDetails->shortcut().toString()));
     m_pActionCloneSnapshot->setToolTip(tr("Clone Virtual Machine (%1)").arg(m_pActionCloneSnapshot->shortcut().toString()));
     /* Translate actions status-tips: */
     m_pActionTakeSnapshot->setStatusTip(tr("Take a snapshot of the current virtual machine state"));
+    m_pActionDeleteSnapshot->setStatusTip(tr("Delete selected snapshot of the virtual machine"));
     m_pActionRestoreSnapshot->setStatusTip(tr("Restore selected snapshot of the virtual machine"));
-    m_pActionDeleteSnapshot->setStatusTip(tr("Delete selected snapshot of the virtual machine"));
     m_pActionShowSnapshotDetails->setStatusTip(tr("Display a window with selected snapshot details"));
     m_pActionCloneSnapshot->setStatusTip(tr("Clone selected virtual machine"));
@@ -609 +609 @@
 }
 
+void UISnapshotPane::sltMachineDataChange(QString strMachineID)
+{
+    /* Make sure it's our VM: */
+    if (strMachineID != m_strMachineID)
+        return;
+
+    /* Prevent snapshot editing in the meantime: */
+    QWriteLocker locker(m_pLockReadWrite);
+
+    /* Recache state current item: */
+    currentStateItem()->recache();
+}
+
+void UISnapshotPane::sltMachineStateChange(QString strMachineID, KMachineState enmState)
+{
+    /* Make sure it's our VM: */
+    if (strMachineID != m_strMachineID)
+        return;
+
+    /* Prevent snapshot editing in the meantime: */
+    QWriteLocker locker(m_pLockReadWrite);
+
+    /* Recache new machine state: */
+    currentStateItem()->recache();
+    currentStateItem()->updateCurrentState(enmState);
+}
+
+void UISnapshotPane::sltSessionStateChange(QString strMachineID, KSessionState enmState)
+{
+    /* Make sure it's our VM: */
+    if (strMachineID != m_strMachineID)
+        return;
+
+    /* Prevent snapshot editing in the meantime: */
+    QWriteLocker locker(m_pLockReadWrite);
+
+    /* Recache new session state: */
+    m_enmSessionState = enmState;
+    sltCurrentItemChanged(m_pSnapshotTree->currentItem());
+}
+
+void UISnapshotPane::sltUpdateSnapshotsAge()
+{
+    /* Stop timer if active: */
+    if (m_pTimerUpdateAge->isActive())
+        m_pTimerUpdateAge->stop();
+
+    /* Search for smallest snapshot age to optimize timer timeout: */
+    const SnapshotAgeFormat age = traverseSnapshotAge(m_pSnapshotTree->invisibleRootItem());
+    switch (age)
+    {
+        case SnapshotAgeFormat_InSeconds: m_pTimerUpdateAge->setInterval(5 * 1000); break;
+        case SnapshotAgeFormat_InMinutes: m_pTimerUpdateAge->setInterval(60 * 1000); break;
+        case SnapshotAgeFormat_InHours:   m_pTimerUpdateAge->setInterval(60 * 60 * 1000); break;
+        case SnapshotAgeFormat_InDays:    m_pTimerUpdateAge->setInterval(24 * 60 * 60 * 1000); break;
+        default:                          m_pTimerUpdateAge->setInterval(0); break;
+    }
+
+    /* Restart timer if necessary: */
+    if (m_pTimerUpdateAge->interval() > 0)
+        m_pTimerUpdateAge->start();
+}
+
 void UISnapshotPane::sltCurrentItemChanged(QTreeWidgetItem *pItem)
 {
@@ -648 +711 @@
                 && !m_pCurrentSnapshotItem))
     );
-    m_pActionRestoreSnapshot->setEnabled(
-           !fBusy
+    m_pActionDeleteSnapshot->setEnabled(
+           m_fShapshotOperationsAllowed
+        && fCanTakeDeleteSnapshot
         && m_pCurrentSnapshotItem
         && pSnapshotItem
         && !pSnapshotItem->isCurrentStateItem()
     );
-    m_pActionDeleteSnapshot->setEnabled(
-           m_fShapshotOperationsAllowed
-        && fCanTakeDeleteSnapshot
+    m_pActionRestoreSnapshot->setEnabled(
+           !fBusy
         && m_pCurrentSnapshotItem
         && pSnapshotItem
@@ -689 +752 @@
     if (m_pCurrentSnapshotItem && !pSnapshotItem->isCurrentStateItem())
     {
+        menu.addAction(m_pActionDeleteSnapshot);
+        menu.addSeparator();
         menu.addAction(m_pActionRestoreSnapshot);
-        menu.addAction(m_pActionDeleteSnapshot);
         menu.addAction(m_pActionShowSnapshotDetails);
         menu.addSeparator();
@@ -738 +802 @@
         restoreSnapshot(true /* suppress non-critical warnings */);
     }
-}
-
-void UISnapshotPane::sltMachineDataChange(QString strMachineID)
-{
-    /* Make sure it's our VM: */
-    if (strMachineID != m_strMachineID)
-        return;
-
-    /* Prevent snapshot editing in the meantime: */
-    QWriteLocker locker(m_pLockReadWrite);
-
-    /* Recache state current item: */
-    currentStateItem()->recache();
-}
-
-void UISnapshotPane::sltMachineStateChange(QString strMachineID, KMachineState enmState)
-{
-    /* Make sure it's our VM: */
-    if (strMachineID != m_strMachineID)
-        return;
-
-    /* Prevent snapshot editing in the meantime: */
-    QWriteLocker locker(m_pLockReadWrite);
-
-    /* Recache new machine state: */
-    currentStateItem()->recache();
-    currentStateItem()->updateCurrentState(enmState);
-}
-
-void UISnapshotPane::sltSessionStateChange(QString strMachineID, KSessionState enmState)
-{
-    /* Make sure it's our VM: */
-    if (strMachineID != m_strMachineID)
-        return;
-
-    /* Prevent snapshot editing in the meantime: */
-    QWriteLocker locker(m_pLockReadWrite);
-
-    /* Recache new session state: */
-    m_enmSessionState = enmState;
-    sltCurrentItemChanged(m_pSnapshotTree->currentItem());
-}
-
-void UISnapshotPane::sltUpdateSnapshotsAge()
-{
-    /* Stop timer if active: */
-    if (m_pTimerUpdateAge->isActive())
-        m_pTimerUpdateAge->stop();
-
-    /* Search for smallest snapshot age to optimize timer timeout: */
-    const SnapshotAgeFormat age = traverseSnapshotAge(m_pSnapshotTree->invisibleRootItem());
-    switch (age)
-    {
-        case SnapshotAgeFormat_InSeconds: m_pTimerUpdateAge->setInterval(5 * 1000); break;
-        case SnapshotAgeFormat_InMinutes: m_pTimerUpdateAge->setInterval(60 * 1000); break;
-        case SnapshotAgeFormat_InHours:   m_pTimerUpdateAge->setInterval(60 * 60 * 1000); break;
-        case SnapshotAgeFormat_InDays:    m_pTimerUpdateAge->setInterval(24 * 60 * 60 * 1000); break;
-        default:                          m_pTimerUpdateAge->setInterval(0); break;
-    }
-
-    /* Restart timer if necessary: */
-    if (m_pTimerUpdateAge->interval() > 0)
-        m_pTimerUpdateAge->start();
 }
 
@@ -944 +945 @@
         layout()->addWidget(m_pSnapshotTree);
     }
+}
+
+void UISnapshotPane::refreshAll()
+{
+    /* Prevent snapshot editing in the meantime: */
+    QWriteLocker locker(m_pLockReadWrite);
+
+    /* If VM is null, just updated the current itm: */
+    if (m_comMachine.isNull())
+    {
+        sltCurrentItemChanged();
+        return;
+    }
+
+    /* Remember the selected item and it's first child: */
+    QString strSelectedItem, strFirstChildOfSelectedItem;
+    const UISnapshotItem *pSnapshotItem = UISnapshotItem::toSnapshotItem(m_pSnapshotTree->currentItem());
+    if (pSnapshotItem)
+    {
+        strSelectedItem = pSnapshotItem->snapshotID();
+        if (pSnapshotItem->child(0))
+            strFirstChildOfSelectedItem = UISnapshotItem::toSnapshotItem(pSnapshotItem->child(0))->snapshotID();
+    }
+
+    /* Clear the tree: */
+    m_pSnapshotTree->clear();
+
+    /* If machine has snapshots: */
+    if (m_comMachine.GetSnapshotCount() > 0)
+    {
+        /* Get the first snapshot: */
+        const CSnapshot comSnapshot = m_comMachine.FindSnapshot(QString());
+
+        /* Populate snapshot tree: */
+        populateSnapshots(comSnapshot, 0);
+        /* And make sure it has current snapshot item: */
+        Assert(m_pCurrentSnapshotItem);
+
+        /* Add the "current state" item as a child to current snapshot item: */
+        UISnapshotItem *pCsi = new UISnapshotItem(this, m_pCurrentSnapshotItem, m_comMachine);
+        pCsi->setBold(true);
+        pCsi->recache();
+
+        /* Search for a previously selected item: */
+        UISnapshotItem *pCurrentItem = findItem(strSelectedItem);
+        if (pCurrentItem == 0)
+            pCurrentItem = findItem(strFirstChildOfSelectedItem);
+        if (pCurrentItem == 0)
+            pCurrentItem = currentStateItem();
+
+        /* Choose current item: */
+        m_pSnapshotTree->scrollToItem(pCurrentItem);
+        m_pSnapshotTree->setCurrentItem(pCurrentItem);
+        sltCurrentItemChanged(pCurrentItem);
+    }
+    /* If machine has no snapshots: */
+    else
+    {
+        /* There is no current snapshot item: */
+        m_pCurrentSnapshotItem = 0;
+
+        /* Add the "current state" item as a child of snapshot tree: */
+        UISnapshotItem *pCsi = new UISnapshotItem(this, m_pSnapshotTree, m_comMachine);
+        pCsi->setBold(true);
+        pCsi->recache();
+
+        /* Choose current item: */
+        m_pSnapshotTree->setCurrentItem(pCsi);
+        sltCurrentItemChanged(pCsi);
+    }
+
+    /* Update age: */
+    sltUpdateSnapshotsAge();
+
+    /* Adjust snapshot tree: */
+    m_pSnapshotTree->resizeColumnToContents(0);
+}
+
+void UISnapshotPane::populateSnapshots(const CSnapshot &comSnapshot, QITreeWidgetItem *pItem)
+{
+    /* Create a child of passed item: */
+    UISnapshotItem *pSnapshotItem = pItem ? new UISnapshotItem(this, pItem, comSnapshot) :
+                                            new UISnapshotItem(this, m_pSnapshotTree, comSnapshot);
+    /* And recache it's content: */
+    pSnapshotItem->recache();
+
+    /* Mark current snapshot item bold and remember it: */
+    CSnapshot comCurrentSnapshot = m_comMachine.GetCurrentSnapshot();
+    if (!comCurrentSnapshot.isNull() && comCurrentSnapshot.GetId() == comSnapshot.GetId())
+    {
+        pSnapshotItem->setBold(true);
+        m_pCurrentSnapshotItem = pSnapshotItem;
+    }
+
+    /* Walk through the children recursively: */
+    foreach (const CSnapshot &comIteratedSnapshot, comSnapshot.GetChildren())
+        populateSnapshots(comIteratedSnapshot, pSnapshotItem);
+
+    /* Expand the newly created item: */
+    pSnapshotItem->setExpanded(true);
+    /* And mark it as editable: */
+    pSnapshotItem->setFlags(pSnapshotItem->flags() | Qt::ItemIsEditable);
 }
 
@@ -1061 +1164 @@
 }
 
+bool UISnapshotPane::deleteSnapshot()
+{
+    /* Simulate try-catch block: */
+    bool fSuccess = false;
+    do
+    {
+        /* Acquire currently chosen snapshot item: */
+        const UISnapshotItem *pSnapshotItem = UISnapshotItem::toSnapshotItem(m_pSnapshotTree->currentItem());
+        AssertPtr(pSnapshotItem);
+        if (!pSnapshotItem)
+            break;
+
+        /* Get corresponding snapshot: */
+        const CSnapshot comSnapshot = pSnapshotItem->snapshot();
+        Assert(!comSnapshot.isNull());
+        if (comSnapshot.isNull())
+            break;
+
+        /* Ask if user really wants to remove the selected snapshot: */
+        if (!msgCenter().confirmSnapshotRemoval(comSnapshot.GetName()))
+            break;
+
+        /** @todo check available space on the target filesystem etc etc. */
+#if 0
+        if (!msgCenter().warnAboutSnapshotRemovalFreeSpace(comSnapshot.GetName(),
+                                                           "/home/juser/.VirtualBox/Machines/SampleVM/Snapshots/{01020304-0102-0102-0102-010203040506}.vdi",
+                                                           "59 GiB",
+                                                           "15 GiB"))
+            break;
+#endif
+
+        /* Open a session (this call will handle all errors): */
+        CSession comSession;
+        if (m_enmSessionState != KSessionState_Unlocked)
+            comSession = vboxGlobal().openExistingSession(m_strMachineID);
+        else
+            comSession = vboxGlobal().openSession(m_strMachineID);
+        if (comSession.isNull())
+            break;
+
+        /* Simulate try-catch block: */
+        do
+        {
+            /* Remove chosen snapshot: */
+            CMachine comMachine = comSession.GetMachine();
+            CProgress comProgress = comMachine.DeleteSnapshot(pSnapshotItem->snapshotID());
+            if (!comMachine.isOk())
+            {
+                msgCenter().cannotRemoveSnapshot(comMachine,  comSnapshot.GetName(), m_comMachine.GetName());
+                break;
+            }
+
+            /* Show snapshot removing progress: */
+            msgCenter().showModalProgressDialog(comProgress, m_comMachine.GetName(), ":/progress_snapshot_discard_90px.png");
+            if (!comProgress.isOk() || comProgress.GetResultCode() != 0)
+            {
+                msgCenter().cannotRemoveSnapshot(comProgress,  comSnapshot.GetName(), m_comMachine.GetName());
+                break;
+            }
+
+            /* Mark snapshot removing successful: */
+            fSuccess = true;
+        }
+        while (0);
+
+        /* Cleanup try-catch block: */
+        comSession.UnlockMachine();
+    }
+    while (0);
+
+    /* Return result: */
+    return fSuccess;
+}
+
 bool UISnapshotPane::restoreSnapshot(bool fSuppressNonCriticalWarnings /* = false */)
 {
@@ -1136 +1313 @@
 }
 
-bool UISnapshotPane::deleteSnapshot()
-{
-    /* Simulate try-catch block: */
-    bool fSuccess = false;
-    do
-    {
-        /* Acquire currently chosen snapshot item: */
-        const UISnapshotItem *pSnapshotItem = UISnapshotItem::toSnapshotItem(m_pSnapshotTree->currentItem());
-        AssertPtr(pSnapshotItem);
-        if (!pSnapshotItem)
-            break;
-
-        /* Get corresponding snapshot: */
-        const CSnapshot comSnapshot = pSnapshotItem->snapshot();
-        Assert(!comSnapshot.isNull());
-        if (comSnapshot.isNull())
-            break;
-
-        /* Ask if user really wants to remove the selected snapshot: */
-        if (!msgCenter().confirmSnapshotRemoval(comSnapshot.GetName()))
-            break;
-
-        /** @todo check available space on the target filesystem etc etc. */
-#if 0
-        if (!msgCenter().warnAboutSnapshotRemovalFreeSpace(comSnapshot.GetName(),
-                                                           "/home/juser/.VirtualBox/Machines/SampleVM/Snapshots/{01020304-0102-0102-0102-010203040506}.vdi",
-                                                           "59 GiB",
-                                                           "15 GiB"))
-            break;
-#endif
-
-        /* Open a session (this call will handle all errors): */
-        CSession comSession;
-        if (m_enmSessionState != KSessionState_Unlocked)
-            comSession = vboxGlobal().openExistingSession(m_strMachineID);
-        else
-            comSession = vboxGlobal().openSession(m_strMachineID);
-        if (comSession.isNull())
-            break;
-
-        /* Simulate try-catch block: */
-        do
-        {
-            /* Remove chosen snapshot: */
-            CMachine comMachine = comSession.GetMachine();
-            CProgress comProgress = comMachine.DeleteSnapshot(pSnapshotItem->snapshotID());
-            if (!comMachine.isOk())
-            {
-                msgCenter().cannotRemoveSnapshot(comMachine,  comSnapshot.GetName(), m_comMachine.GetName());
-                break;
-            }
-
-            /* Show snapshot removing progress: */
-            msgCenter().showModalProgressDialog(comProgress, m_comMachine.GetName(), ":/progress_snapshot_discard_90px.png");
-            if (!comProgress.isOk() || comProgress.GetResultCode() != 0)
-            {
-                msgCenter().cannotRemoveSnapshot(comProgress,  comSnapshot.GetName(), m_comMachine.GetName());
-                break;
-            }
-
-            /* Mark snapshot removing successful: */
-            fSuccess = true;
-        }
-        while (0);
-
-        /* Cleanup try-catch block: */
-        comSession.UnlockMachine();
-    }
-    while (0);
-
-    /* Return result: */
-    return fSuccess;
-}
-
 void UISnapshotPane::showSnapshotDetails()
 {
@@ -1256 +1359 @@
 }
 
-void UISnapshotPane::refreshAll()
-{
-    /* Prevent snapshot editing in the meantime: */
-    QWriteLocker locker(m_pLockReadWrite);
-
-    /* If VM is null, just updated the current itm: */
-    if (m_comMachine.isNull())
-    {
-        sltCurrentItemChanged();
-        return;
-    }
-
-    /* Remember the selected item and it's first child: */
-    QString strSelectedItem, strFirstChildOfSelectedItem;
-    const UISnapshotItem *pSnapshotItem = UISnapshotItem::toSnapshotItem(m_pSnapshotTree->currentItem());
-    if (pSnapshotItem)
-    {
-        strSelectedItem = pSnapshotItem->snapshotID();
-        if (pSnapshotItem->child(0))
-            strFirstChildOfSelectedItem = UISnapshotItem::toSnapshotItem(pSnapshotItem->child(0))->snapshotID();
-    }
-
-    /* Clear the tree: */
-    m_pSnapshotTree->clear();
-
-    /* If machine has snapshots: */
-    if (m_comMachine.GetSnapshotCount() > 0)
-    {
-        /* Get the first snapshot: */
-        const CSnapshot comSnapshot = m_comMachine.FindSnapshot(QString());
-
-        /* Populate snapshot tree: */
-        populateSnapshots(comSnapshot, 0);
-        /* And make sure it has current snapshot item: */
-        Assert(m_pCurrentSnapshotItem);
-
-        /* Add the "current state" item as a child to current snapshot item: */
-        UISnapshotItem *pCsi = new UISnapshotItem(this, m_pCurrentSnapshotItem, m_comMachine);
-        pCsi->setBold(true);
-        pCsi->recache();
-
-        /* Search for a previously selected item: */
-        UISnapshotItem *pCurrentItem = findItem(strSelectedItem);
-        if (pCurrentItem == 0)
-            pCurrentItem = findItem(strFirstChildOfSelectedItem);
-        if (pCurrentItem == 0)
-            pCurrentItem = currentStateItem();
-
-        /* Choose current item: */
-        m_pSnapshotTree->scrollToItem(pCurrentItem);
-        m_pSnapshotTree->setCurrentItem(pCurrentItem);
-        sltCurrentItemChanged(pCurrentItem);
-    }
-    /* If machine has no snapshots: */
-    else
-    {
-        /* There is no current snapshot item: */
-        m_pCurrentSnapshotItem = 0;
-
-        /* Add the "current state" item as a child of snapshot tree: */
-        UISnapshotItem *pCsi = new UISnapshotItem(this, m_pSnapshotTree, m_comMachine);
-        pCsi->setBold(true);
-        pCsi->recache();
-
-        /* Choose current item: */
-        m_pSnapshotTree->setCurrentItem(pCsi);
-        sltCurrentItemChanged(pCsi);
-    }
-
-    /* Update age: */
-    sltUpdateSnapshotsAge();
-
-    /* Adjust snapshot tree: */
-    m_pSnapshotTree->resizeColumnToContents(0);
-}
-
-void UISnapshotPane::populateSnapshots(const CSnapshot &comSnapshot, QITreeWidgetItem *pItem)
-{
-    /* Create a child of passed item: */
-    UISnapshotItem *pSnapshotItem = pItem ? new UISnapshotItem(this, pItem, comSnapshot) :
-                                            new UISnapshotItem(this, m_pSnapshotTree, comSnapshot);
-    /* And recache it's content: */
-    pSnapshotItem->recache();
-
-    /* Mark current snapshot item bold and remember it: */
-    CSnapshot comCurrentSnapshot = m_comMachine.GetCurrentSnapshot();
-    if (!comCurrentSnapshot.isNull() && comCurrentSnapshot.GetId() == comSnapshot.GetId())
-    {
-        pSnapshotItem->setBold(true);
-        m_pCurrentSnapshotItem = pSnapshotItem;
-    }
-
-    /* Walk through the children recursively: */
-    foreach (const CSnapshot &comIteratedSnapshot, comSnapshot.GetChildren())
-        populateSnapshots(comIteratedSnapshot, pSnapshotItem);
-
-    /* Expand the newly created item: */
-    pSnapshotItem->setExpanded(true);
-    /* And mark it as editable: */
-    pSnapshotItem->setFlags(pSnapshotItem->flags() | Qt::ItemIsEditable);
-}
-
 UISnapshotItem *UISnapshotPane::findItem(const QString &strSnapshotID) const
 {

trunk/src/VBox/Frontends/VirtualBox/src/selector/UISnapshotPane.h

@@ -73 +73 @@
 private slots:
 
-    /** @name Tree-widget handlers.
-      * @{ */
-        /** Handles cursor change to @a pItem. */
-        void sltCurrentItemChanged(QTreeWidgetItem *pItem = 0);
-        /** Handles context menu request for @a point. */
-        void sltContextMenuRequested(const QPoint &point);
-        /** Handles modification for @a pItem. */
-        void sltItemChanged(QTreeWidgetItem *pItem);
-        /** Handles double-click for @a pItem. */
-        void sltItemDoubleClicked(QTreeWidgetItem *pItem);
-    /** @} */
-
     /** @name Main event handlers.
       * @{ */
@@ -115 +103 @@
     /** @} */
 
+    /** @name Tree-widget handlers.
+      * @{ */
+        /** Handles cursor change to @a pItem. */
+        void sltCurrentItemChanged(QTreeWidgetItem *pItem = 0);
+        /** Handles context menu request for @a point. */
+        void sltContextMenuRequested(const QPoint &point);
+        /** Handles modification for @a pItem. */
+        void sltItemChanged(QTreeWidgetItem *pItem);
+        /** Handles double-click for @a pItem. */
+        void sltItemDoubleClicked(QTreeWidgetItem *pItem);
+    /** @} */
+
 private:
 
@@ -141 +141 @@
         /** Proposes to take a snapshot. */
         bool takeSnapshot();
+        /** Proposes to delete the snapshot. */
+        bool deleteSnapshot();
         /** Proposes to restore the snapshot. */
         bool restoreSnapshot(bool fSuppressNonCriticalWarnings = false);
-        /** Proposes to delete the snapshot. */
-        bool deleteSnapshot();
         /** Displays the snapshot details dialog. */
         void showSnapshotDetails();
@@ -170 +170 @@
         /** Holds the cached session state. */
         KSessionState  m_enmSessionState;
-        /** Holds the current snapshot item reference. */
-        UISnapshotItem *m_pCurrentSnapshotItem;
+
+        /** Holds whether the snapshot operations are allowed. */
+        bool  m_fShapshotOperationsAllowed;
+
         /** Holds the snapshot item editing protector. */
         QReadWriteLock *m_pLockReadWrite;
+
+        /** Holds the cached snapshot-item pixmap for 'offline' state. */
+        QIcon *m_pIconSnapshotOffline;
+        /** Holds the cached snapshot-item pixmap for 'online' state. */
+        QIcon *m_pIconSnapshotOnline;
+
+        /** Holds the snapshot age update timer. */
+        QTimer *m_pTimerUpdateAge;
     /** @} */
 
@@ -182 +192 @@
         /** Holds the Take Snapshot action instance. */
         QAction   *m_pActionTakeSnapshot;
+        /** Holds the Delete Snapshot action instance. */
+        QAction   *m_pActionDeleteSnapshot;
         /** Holds the Restore Snapshot action instance. */
         QAction   *m_pActionRestoreSnapshot;
-        /** Holds the Delete Snapshot action instance. */
-        QAction   *m_pActionDeleteSnapshot;
         /** Holds the Show Snapshot Details action instance. */
         QAction   *m_pActionShowSnapshotDetails;
@@ -191 +201 @@
         QAction   *m_pActionCloneSnapshot;
 
-        /** Holds the snapshot age update timer. */
-        QTimer *m_pTimerUpdateAge;
-
-        /** Holds whether the snapshot operations are allowed. */
-        bool  m_fShapshotOperationsAllowed;
-
-        /** Holds the cached snapshot-item pixmap for 'offline' state. */
-        QIcon *m_pIconSnapshotOffline;
-        /** Holds the cached snapshot-item pixmap for 'online' state. */
-        QIcon *m_pIconSnapshotOnline;
-
         /** Holds the snapshot tree instance. */
         UISnapshotTree *m_pSnapshotTree;
+        /** Holds the current snapshot item reference. */
+        UISnapshotItem *m_pCurrentSnapshotItem;
     /** @} */
 };