VirtualBox

Changeset 108555 in vbox for trunk/src/VBox/Frontends


Ignore:
Timestamp:
Mar 13, 2025 5:48:30 PM (5 weeks ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
167952
Message:

FE/Qt: bugref:10814: VBox Manager: Implementing initial version of Management pane which is not yet connected but will be used to unify Management related tools.

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
1 edited
2 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

    r108532 r108555  
    581581        src/manager/UIHomePane.h \
    582582        src/manager/UIMachineToolsWidget.h \
     583        src/manager/UIManagementToolsWidget.h \
    583584        src/manager/UIProgressTaskReadCloudMachineList.h \
    584585        src/manager/UITaskCloudGetSettingsForm.h \
    … …  
    11031104        src/manager/UIHomePane.cpp \
    11041105        src/manager/UIMachineToolsWidget.cpp \
     1106        src/manager/UIManagementToolsWidget.cpp \
    11051107        src/manager/UIProgressTaskReadCloudMachineList.cpp \
    11061108        src/manager/UITaskCloudGetSettingsForm.cpp \

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/UIManagementToolsWidget.cpp

    r108553 r108555  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIGlobalToolsWidget class implementation.
     3 * VBox Qt GUI - UIManagementToolsWidget class implementation.
    44 */
    55
    … …  
    2727
    2828/* Qt includes: */
    29 #include <QGridLayout>
     29#include <QVBoxLayout>
    3030
    3131/* GUI includes: */
    32 #include "QIToolBar.h"
    33 #include "UIChooser.h"
    34 #include "UICommon.h"
    35 #include "UIExtraDataManager.h"
    36 #include "UIGlobalToolsWidget.h"
    37 #include "UIMachineToolsWidget.h"
     32#include "UIManagementToolsWidget.h"
    3833#include "UIToolPane.h"
    39 #include "UITools.h"
    40 #include "UIVirtualBoxEventHandler.h"
    41 #include "UIVirtualMachineItem.h"
    4234
    4335/* Other VBox includes: */
    … …  
    4537
    4638
    47 UIGlobalToolsWidget::UIGlobalToolsWidget(QWidget *pParent, UIActionPool *pActionPool)
     39UIManagementToolsWidget::UIManagementToolsWidget(QWidget *pParent, UIActionPool *pActionPool)
    4840    : QWidget(pParent)
    4941    , m_pActionPool(pActionPool)
    50     , m_pLayout(0)
    51     , m_pMenu(0)
    5242    , m_pPane(0)
    5343{
    … …  
    5545}
    5646
    57 void UIGlobalToolsWidget::addToolBar(QIToolBar *pToolBar)
    58 {
    59     AssertPtrReturnVoid(m_pLayout);
    60     m_pLayout->addWidget(pToolBar, 0, 1);
    61 }
    62 
    63 UIToolPane *UIGlobalToolsWidget::toolPane() const
     47UIToolPane *UIManagementToolsWidget::toolPane() const
    6448{
    6549    return m_pPane;
    6650}
    6751
    68 UIMachineToolsWidget *UIGlobalToolsWidget::machineToolsWidget() const
    69 {
    70     return toolPane()->machineToolsWidget();
    71 }
    72 
    73 UIToolType UIGlobalToolsWidget::menuToolType(UIToolClass enmClass) const
    74 {
    75     AssertPtrReturn(toolMenu(), UIToolType_Invalid);
    76     return toolMenu()->toolsType(enmClass);
    77 }
    78 
    79 void UIGlobalToolsWidget::setMenuToolType(UIToolType enmType)
    80 {
    81     /* Sanity check: */
    82     AssertReturnVoid(enmType != UIToolType_Invalid);
    83 
    84     AssertPtrReturnVoid(toolMenu());
    85     toolMenu()->setToolsType(enmType);
    86 }
    87 
    88 UIToolType UIGlobalToolsWidget::toolType() const
     52UIToolType UIManagementToolsWidget::toolType() const
    8953{
    9054    AssertPtrReturn(toolPane(), UIToolType_Invalid);
    … …  
    9256}
    9357
    94 bool UIGlobalToolsWidget::isToolOpened(UIToolType enmType) const
     58bool UIManagementToolsWidget::isToolOpened(UIToolType enmType) const
    9559{
    9660    /* Sanity check: */
    9761    AssertReturn(enmType != UIToolType_Invalid, false);
    98     /* Make sure new tool type is of Global class: */
    99     AssertReturn(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Global), false);
     62    /* Make sure new tool type is of Management class: */
     63    AssertReturn(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Management), false);
    10064
    10165    AssertPtrReturn(toolPane(), false);
    … …  
    10367}
    10468
    105 void UIGlobalToolsWidget::switchToolTo(UIToolType enmType)
     69void UIManagementToolsWidget::switchToolTo(UIToolType enmType)
    10670{
    10771    /* Sanity check: */
    10872    AssertReturnVoid(enmType != UIToolType_Invalid);
    109     /* Make sure new tool type is of Global class: */
    110     AssertReturnVoid(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Global));
     73    /* Make sure new tool type is of Management class: */
     74    AssertReturnVoid(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Management));
    11175
    11276    /* Open corresponding tool: */
    … …  
    11478    toolPane()->openTool(enmType);
    11579
    116     /* Notify corresponding tool-pane it's active: */
    117     toolPane()->setActive(enmType != UIToolType_Machines && enmType != UIToolType_Managers);
    118     toolPaneMachine()->setActive(enmType == UIToolType_Machines);
    119 
    120     /* Special handling for Activities Global tool,
    121      * start unconditionally updating all cloud VMs: */
    122     if (enmType == UIToolType_Activities)
    123     {
    124         chooser()->setKeepCloudNodesUpdated(true);
    125         toolPane()->setCloudMachineItems(chooser()->cloudMachineItems());
    126     }
    127     /* Otherwise, stop unconditionally updating all cloud VMs,
    128      * (tho they will still be updated if selected) */
    129     else
    130         chooser()->setKeepCloudNodesUpdated(false);
    131 
    13280    /* Let the parent know: */
    13381    emit sigToolTypeChange();
    13482}
    13583
    136 void UIGlobalToolsWidget::closeTool(UIToolType enmType)
     84void UIManagementToolsWidget::closeTool(UIToolType enmType)
    13785{
    13886    /* Sanity check: */
    13987    AssertReturnVoid(enmType != UIToolType_Invalid);
    140     /* Make sure new tool type is of Global class: */
    141     AssertReturnVoid(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Global));
     88    /* Make sure new tool type is of Management class: */
     89    AssertReturnVoid(UIToolStuff::isTypeOfClass(enmType, UIToolClass_Management));
    14290
    14391    AssertPtrReturnVoid(toolPane());
    … …  
    14593}
    14694
    147 QString UIGlobalToolsWidget::currentHelpKeyword() const
     95QString UIManagementToolsWidget::currentHelpKeyword() const
    14896{
    149     if (toolType() == UIToolType_Machines)
    150     {
    151         AssertPtrReturn(machineToolsWidget(), QString());
    152         return machineToolsWidget()->currentHelpKeyword();
    153     }
    154 
    15597    AssertPtrReturn(toolPane(), QString());
    15698    return toolPane()->currentHelpKeyword();
    15799}
    158100
    159 void UIGlobalToolsWidget::sltHandleCommitData()
    160 {
    161     cleanupConnections();
    162 }
    163 
    164 void UIGlobalToolsWidget::sltHandleMachineRegistrationChanged(const QUuid &, const bool fRegistered)
    165 {
    166     /* On any VM registered switch from Home to Machines: */
    167     AssertPtrReturnVoid(toolMenu());
    168     if (fRegistered && toolMenu()->toolsType(UIToolClass_Global) == UIToolType_Home)
    169         setMenuToolType(UIToolType_Machines);
    170 }
    171 
    172 void UIGlobalToolsWidget::sltHandleSettingsExpertModeChange()
    173 {
    174     /* Update tools restrictions: */
    175     emit sigToolMenuUpdate();
    176 }
    177 
    178 void UIGlobalToolsWidget::sltHandleChooserPaneSelectionChange()
    179 {
    180     /* Update tools restrictions: */
    181     emit sigToolMenuUpdate();
    182 }
    183 
    184 void UIGlobalToolsWidget::sltHandleCloudProfileStateChange(const QString &, const QString &)
    185 {
    186     /* If Global Activities tool is currently chosen: */
    187     AssertPtrReturnVoid(toolPane());
    188     if (toolType() == UIToolType_Activities)
    189     {
    190         /* Propagate a set of cloud machine items to Global tool-pane: */
    191         toolPane()->setCloudMachineItems(chooser()->cloudMachineItems());
    192     }
    193 }
    194 
    195 void UIGlobalToolsWidget::sltHandleGlobalToolMenuUpdate()
    196 {
    197     /* Prepare tool restrictions: */
    198     QSet<UIToolType> restrictedTypes;
    199 
    200     /* Restrict some types for Basic mode: */
    201     const bool fExpertMode = gEDataManager->isSettingsInExpertMode();
    202     if (!fExpertMode)
    203         restrictedTypes << UIToolType_Media
    204                         << UIToolType_Network;
    205 
    206     /* Make sure Machines tool is hidden for empty Chooser-pane: */
    207     if (!chooser()->currentItem())
    208         restrictedTypes << UIToolType_Machines;
    209 
    210     /* Make sure no restricted tool is selected: */
    211     if (restrictedTypes.contains(toolMenu()->toolsType(UIToolClass_Global)))
    212         setMenuToolType(UIToolType_Home);
    213 
    214     /* Hide restricted tools in the menu: */
    215     const QList restrictions(restrictedTypes.begin(), restrictedTypes.end());
    216     toolMenu()->setRestrictedToolTypes(UIToolClass_Global, restrictions);
    217 
    218     /* Close all restricted tools (besides the Machines and Management): */
    219     foreach (const UIToolType &enmRestrictedType, restrictedTypes)
    220         if (   enmRestrictedType != UIToolType_Machines
    221             && enmRestrictedType != UIToolType_Managers)
    222             toolPane()->closeTool(enmRestrictedType);
    223 }
    224 
    225 void UIGlobalToolsWidget::sltHandleMachineToolMenuUpdate(UIVirtualMachineItem *pItem)
    226 {
    227     /* Prepare tool restrictions: */
    228     QSet<UIToolType> restrictedTypes;
    229 
    230     /* Restrict some types for Basic mode: */
    231     const bool fExpertMode = gEDataManager->isSettingsInExpertMode();
    232     if (!fExpertMode)
    233         restrictedTypes << UIToolType_FileManager;
    234 
    235     /* Make sure local VM tools are hidden for cloud VMs: */
    236     if (pItem && pItem->itemType() != UIVirtualMachineItemType_Local)
    237         restrictedTypes << UIToolType_Snapshots
    238                         << UIToolType_Logs
    239                         << UIToolType_FileManager;
    240 
    241     /* Make sure no restricted tool is selected: */
    242     if (restrictedTypes.contains(toolMenu()->toolsType(UIToolClass_Machine)))
    243         setMenuToolType(UIToolType_Details);
    244 
    245     /* Hide restricted tools in the menu: */
    246     const QList restrictions(restrictedTypes.begin(), restrictedTypes.end());
    247     toolMenu()->setRestrictedToolTypes(UIToolClass_Machine, restrictions);
    248 
    249     /// @todo finish that
    250     // /* Disable even unrestricted tools for inacccessible VMs: */
    251     // const bool fCurrentItemIsOk = isItemAccessible(pItem);
    252     // toolMenu()->setItemsEnabled(fCurrentItemIsOk);
    253 
    254     /* Close all restricted tools: */
    255     foreach (const UIToolType &enmRestrictedType, restrictedTypes)
    256         toolPaneMachine()->closeTool(enmRestrictedType);
    257 }
    258 
    259 void UIGlobalToolsWidget::sltHandleToolsMenuIndexChange(UIToolType enmType)
    260 {
    261     /* Determine tool class of passed tool type: */
    262     const UIToolClass enmClass = UIToolStuff::castTypeToClass(enmType);
    263 
    264     /* For Global tool class: */
    265     if (enmClass == UIToolClass_Global)
    266     {
    267         /* Mark Machine & Management tools [un]suitable depending on Global tool selected: */
    268         toolMenu()->setUnsuitableToolClass(UIToolClass_Machine, enmType != UIToolType_Machines);
    269         toolMenu()->setUnsuitableToolClass(UIToolClass_Management, enmType != UIToolType_Managers);
    270 
    271         /* Switch tool-pane accordingly: */
    272         switchToolTo(enmType);
    273     }
    274     /* For Machine tool class => switch tool-pane accordingly: */
    275     else if (enmClass == UIToolClass_Machine)
    276         machineToolsWidget()->switchToolTo(enmType);
    277     /* For Management tool class => switch tool-pane accordingly: */
    278     else if (enmClass == UIToolClass_Management)
    279         switchToolTo(enmType);
    280 }
    281 
    282 void UIGlobalToolsWidget::sltSwitchToActivitiesTool()
    283 {
    284     setMenuToolType(UIToolType_Activities);
    285 }
    286 
    287 void UIGlobalToolsWidget::prepare()
     101void UIManagementToolsWidget::prepare()
    288102{
    289103    /* Prepare everything: */
    290104    prepareWidgets();
    291     prepareConnections();
    292 
    293     /* Load settings: */
    294     loadSettings();
    295105}
    296106
    297 void UIGlobalToolsWidget::prepareWidgets()
     107void UIManagementToolsWidget::prepareWidgets()
    298108{
    299109    /* Create layout: */
    300     m_pLayout = new QGridLayout(this);
    301     if (m_pLayout)
     110    QVBoxLayout *pLayout = new QVBoxLayout(this);
     111    if (pLayout)
    302112    {
    303113        /* Configure layout: */
    304         m_pLayout->setContentsMargins(0, 0, 0, 0);
    305         m_pLayout->setSpacing(0);
    306 
    307         /* Create tool-menu: */
    308         m_pMenu = new UITools(this, UIToolClass_Global, actionPool(), Qt::Widget);
    309         if (toolMenu())
    310         {
    311             /* Add into layout: */
    312             m_pLayout->addWidget(toolMenu(), 0, 0, 2, 1);
    313         }
     114        pLayout->setContentsMargins(0, 0, 0, 0);
     115        pLayout->setSpacing(0);
    314116
    315117        /* Create tool-pane: */
    316         m_pPane = new UIToolPane(this, UIToolClass_Global, actionPool());
     118        m_pPane = new UIToolPane(this, UIToolClass_Management, actionPool());
    317119        if (toolPane())
    318120        {
    … …  
    321123
    322124            /* Add into layout: */
    323             m_pLayout->addWidget(toolPane(), 1, 1);
     125            pLayout->addWidget(toolPane());
    324126        }
    325127    }
    326128}
    327 
    328 void UIGlobalToolsWidget::prepareConnections()
    329 {
    330     /* UICommon connections: */
    331     connect(&uiCommon(), &UICommon::sigAskToCommitData,
    332             this, &UIGlobalToolsWidget::sltHandleCommitData);
    333 
    334     /* Global COM event handlers: */
    335     connect(gVBoxEvents, &UIVirtualBoxEventHandler::sigMachineRegistered,
    336             this, &UIGlobalToolsWidget::sltHandleMachineRegistrationChanged);
    337     connect(gEDataManager, &UIExtraDataManager::sigSettingsExpertModeChange,
    338             this, &UIGlobalToolsWidget::sltHandleSettingsExpertModeChange);
    339 
    340     /* Chooser-pane connections: */
    341     connect(chooser(), &UIChooser::sigSelectionChanged,
    342             this, &UIGlobalToolsWidget::sltHandleChooserPaneSelectionChange);
    343     connect(chooser(), &UIChooser::sigCloudProfileStateChange,
    344             this, &UIGlobalToolsWidget::sltHandleCloudProfileStateChange);
    345 
    346     /* Tools-menu connections: */
    347     connect(toolMenu(), &UITools::sigSelectionChanged,
    348             this, &UIGlobalToolsWidget::sltHandleToolsMenuIndexChange);
    349 
    350     /* Tools-pane connections: */
    351     connect(this, &UIGlobalToolsWidget::sigToolMenuUpdate,
    352             this, &UIGlobalToolsWidget::sltHandleGlobalToolMenuUpdate);
    353     connect(machineToolsWidget(), &UIMachineToolsWidget::sigToolMenuUpdate,
    354             this, &UIGlobalToolsWidget::sltHandleMachineToolMenuUpdate);
    355     connect(toolPaneMachine(), &UIToolPane::sigSwitchToActivityOverviewPane,
    356             this, &UIGlobalToolsWidget::sltSwitchToActivitiesTool);
    357 }
    358 
    359 void UIGlobalToolsWidget::loadSettings()
    360 {
    361     /* Acquire & select tools currently chosen in the menu: */
    362     sltHandleToolsMenuIndexChange(toolMenu()->toolsType(UIToolClass_Global));
    363     sltHandleToolsMenuIndexChange(toolMenu()->toolsType(UIToolClass_Machine));
    364 
    365     /* Update Global tools restrictions: */
    366     sltHandleGlobalToolMenuUpdate();
    367     /* Update Machine tools restrictions for currently selected item: */
    368     UIVirtualMachineItem *pItem = machineToolsWidget()->currentItem();
    369     if (pItem)
    370         sltHandleMachineToolMenuUpdate(pItem);
    371 }
    372 
    373 void UIGlobalToolsWidget::cleanupConnections()
    374 {
    375     /* Global COM event handlers: */
    376     disconnect(gVBoxEvents, &UIVirtualBoxEventHandler::sigMachineRegistered,
    377                this, &UIGlobalToolsWidget::sltHandleMachineRegistrationChanged);
    378     disconnect(gEDataManager, &UIExtraDataManager::sigSettingsExpertModeChange,
    379                this, &UIGlobalToolsWidget::sltHandleSettingsExpertModeChange);
    380 
    381     /* Chooser-pane connections: */
    382     disconnect(chooser(), &UIChooser::sigSelectionChanged,
    383                this, &UIGlobalToolsWidget::sltHandleChooserPaneSelectionChange);
    384     disconnect(chooser(), &UIChooser::sigCloudProfileStateChange,
    385                this, &UIGlobalToolsWidget::sltHandleCloudProfileStateChange);
    386 
    387     /* Tools-menu connections: */
    388     disconnect(toolMenu(), &UITools::sigSelectionChanged,
    389                this, &UIGlobalToolsWidget::sltHandleToolsMenuIndexChange);
    390 
    391     /* Tools-pane connections: */
    392     disconnect(this, &UIGlobalToolsWidget::sigToolMenuUpdate,
    393                this, &UIGlobalToolsWidget::sltHandleGlobalToolMenuUpdate);
    394     disconnect(machineToolsWidget(), &UIMachineToolsWidget::sigToolMenuUpdate,
    395                this, &UIGlobalToolsWidget::sltHandleMachineToolMenuUpdate);
    396     disconnect(toolPaneMachine(), &UIToolPane::sigSwitchToActivityOverviewPane,
    397                this, &UIGlobalToolsWidget::sltSwitchToActivitiesTool);
    398 }
    399 
    400 UITools *UIGlobalToolsWidget::toolMenu() const
    401 {
    402     return m_pMenu;
    403 }
    404 
    405 UIChooser *UIGlobalToolsWidget::chooser() const
    406 {
    407     return machineToolsWidget()->chooser();
    408 }
    409 
    410 UIToolPane *UIGlobalToolsWidget::toolPaneMachine() const
    411 {
    412     return machineToolsWidget()->toolPane();
    413 }

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/UIManagementToolsWidget.h

    r108553 r108555  
    11/* $Id$ */
    22/** @file
    3  * VBox Qt GUI - UIGlobalToolsWidget class declaration.
     3 * VBox Qt GUI - UIManagementToolsWidget class declaration.
    44 */
    55
    … …  
    2626 */
    2727
    28 #ifndef FEQT_INCLUDED_SRC_manager_UIGlobalToolsWidget_h
    29 #define FEQT_INCLUDED_SRC_manager_UIGlobalToolsWidget_h
     28#ifndef FEQT_INCLUDED_SRC_manager_UIManagementToolsWidget_h
     29#define FEQT_INCLUDED_SRC_manager_UIManagementToolsWidget_h
    3030#ifndef RT_WITHOUT_PRAGMA_ONCE
    3131# pragma once
    … …  
    3939
    4040/* Forward declarations: */
    41 class QGridLayout;
    42 class QIToolBar;
    4341class UIActionPool;
    44 class UIChooser;
    45 class UIMachineToolsWidget;
    4642class UIToolPane;
    47 class UITools;
    48 class UIVirtualMachineItem;
    4943
    50 /** QWidget extension used as Global Tools Widget instance. */
    51 class UIGlobalToolsWidget : public QWidget
     44/** QWidget extension used as Management Tools Widget instance. */
     45class UIManagementToolsWidget : public QWidget
    5246{
    5347    Q_OBJECT;
    … …  
    5751    /** @name Tools pane stuff.
    5852      * @{ */
    59         /** Notifies about required tool menu update. */
    60         void sigToolMenuUpdate();
    61 
    6253        /** Notifies about Tool type change. */
    6354        void sigToolTypeChange();
    … …  
    6657public:
    6758
    68     /** Constructs Global Tools Widget passing @a pParent to the base-class.
    69       * @param  pActionPool  Brings the action-pool reference.  */
    70     UIGlobalToolsWidget(QWidget *pParent, UIActionPool *pActionPool);
    71 
    72     /** @name Tool-bar stuff.
    73       * @{ */
    74         /** Adds tool-bar into grid layout. */
    75         void addToolBar(QIToolBar *pToolBar);
    76     /** @} */
     59    /** Constructs Management Tools Widget passing @a pParent to the base-class.
     60      * @param  pActionPool  Brings the action-pool reference. */
     61    UIManagementToolsWidget(QWidget *pParent, UIActionPool *pActionPool);
    7762
    7863    /** @name Tools pane stuff.
    … …  
    8065        /** Returns tool-pane instance. */
    8166        UIToolPane *toolPane() const;
    82         /** Returns Machine Tools Widget reference. */
    83         UIMachineToolsWidget *machineToolsWidget() const;
    84 
    85         /** Returns menu tool type for the @a enmClass specified. */
    86         UIToolType menuToolType(UIToolClass enmClass) const;
    87         /** Defines menu tool @a enmType. */
    88         void setMenuToolType(UIToolType enmType);
    8967
    9068        /** Returns pane tool type. */
    … …  
    10482    /** @} */
    10583
    106 private slots:
    107 
    108     /** @name General stuff.
    109       * @{ */
    110         /** Handles request to commit data. */
    111         void sltHandleCommitData();
    112     /** @} */
    113 
    114     /** @name COM event handling stuff.
    115       * @{ */
    116         /** Handles signal about machine registration change.
    117           * @param  uId          Brings [un]registered machine id.
    118           * @param  fRegistered  Brings whether machine was registered, unregistered otherwise. */
    119         void sltHandleMachineRegistrationChanged(const QUuid &uId, const bool fRegistered);
    120 
    121         /** Handles signal about settings expert mode change. */
    122         void sltHandleSettingsExpertModeChange();
    123     /** @} */
    124 
    125     /** @name Chooser pane stuff.
    126       * @{ */
    127         /** Handles Chooser-pane selection change. */
    128         void sltHandleChooserPaneSelectionChange();
    129 
    130         /** Handles state change for cloud profile with certain @a strProviderShortName and @a strProfileName. */
    131         void sltHandleCloudProfileStateChange(const QString &strProviderShortName,
    132                                               const QString &strProfileName);
    133     /** @} */
    134 
    135     /** @name Tools pane stuff.
    136       * @{ */
    137         /** Handles request for Global tools menu update. */
    138         void sltHandleGlobalToolMenuUpdate();
    139         /** Handles request for Machine tools menu update for the @a pItem specified. */
    140         void sltHandleMachineToolMenuUpdate(UIVirtualMachineItem *pItem);
    141 
    142         /** Handles signal about Tools-menu index change.
    143           * @param  enmType  Brings current tool type. */
    144         void sltHandleToolsMenuIndexChange(UIToolType enmType);
    145 
    146         /** Handles signal requesting switch to Activities tool. */
    147         void sltSwitchToActivitiesTool();
    148     /** @} */
    149 
    15084private:
    15185
    … …  
    15690        /** Prepares widgets. */
    15791        void prepareWidgets();
    158         /** Prepares connections. */
    159         void prepareConnections();
    160         /** Loads settings. */
    161         void loadSettings();
    162 
    163         /** Cleanups connections. */
    164         void cleanupConnections();
    16592    /** @} */
    16693
    … …  
    17198    /** @} */
    17299
    173     /** @name Tools stuff.
    174       * @{ */
    175         /** Returns tool-menu instance. */
    176         UITools *toolMenu() const;
    177         /** Returns Machine Tools Widget's chooser-pane reference. */
    178         UIChooser *chooser() const;
    179         /** Returns Machine Tools Widget's tool-pane instance. */
    180         UIToolPane *toolPaneMachine() const;
    181     /** @} */
    182 
    183100    /** Holds the action-pool reference. */
    184101    UIActionPool *m_pActionPool;
    185102
    186     /** Holds the grid-layout instance. */
    187     QGridLayout *m_pLayout;
    188 
    189     /** Holds the tools-menu instance. */
    190     UITools    *m_pMenu;
    191103    /** Holds the tool-pane instance. */
    192104    UIToolPane *m_pPane;
    193105};
    194106
    195 #endif /* !FEQT_INCLUDED_SRC_manager_UIGlobalToolsWidget_h */
     107#endif /* !FEQT_INCLUDED_SRC_manager_UIManagementToolsWidget_h */
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette