VirtualBox

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


Ignore:
Timestamp:
Feb 1, 2012 1:33:09 PM (13 years ago)
Author:
vboxsync
Message:

FE/Qt: 5956: Provide user feedback for network related operations: Network Access Manager GUI, initial implementation.

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
2 added
33 edited

Legend:

Unmodified
Added
Removed

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

    r39797 r39932  
    55
    66#
    7 # Copyright (C) 2006-2011 Oracle Corporation
     7# Copyright (C) 2006-2012 Oracle Corporation
    88#
    99# This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    274274        src/net/UINetworkManager.h \
    275275        src/net/UIUpdateManager.h \
     276        src/net/UINetworkCustomer.h \
    276277        src/runtime/UIActionPoolRuntime.h \
    277278        src/runtime/UIConsoleEventHandler.h \
    … …  
    369370        src/globals/UIActionPool.cpp \
    370371        src/globals/UIExtraDataEventHandler.cpp \
     372        src/net/UINetworkManager.cpp \
    371373        src/net/UIUpdateManager.cpp \
    372374        src/runtime/UIActionPoolRuntime.cpp \
    … …  
    442444        src/net/UIUpdateDefs.cpp \
    443445        src/net/UIUpdateManager.cpp \
     446        src/net/UINetworkCustomer.cpp \
    444447        src/runtime/UIActionPoolRuntime.cpp \
    445448        src/runtime/UIConsoleEventHandler.cpp \

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIToolButton.h

    r34538 r39932  
    66
    77/*
    8  * Copyright (C) 2009 Oracle Corporation
     8 * Copyright (C) 2009-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2020#define __QIToolButton_h__
    2121
    22 /* Qt includes */
     22/* Global includes: */
    2323#include <QToolButton>
    2424
     25/* QToolButton reimplementation: */
    2526class QIToolButton: public QToolButton
    2627{
    … …  
    2829
    2930public:
    30     QIToolButton (QWidget *aParent = 0)
    31       : QToolButton (aParent)
     31
     32    QIToolButton(QWidget *pParent = 0)
     33        : QToolButton(pParent)
    3234    {
    3335#ifdef Q_WS_MAC
    34         setStyleSheet ("QToolButton { border: 0px none black; margin: 2px 4px 0px 4px; } QToolButton::menu-indicator {image: none;}");
     36        setStyleSheet("QToolButton { border: 0px none black; margin: 2px 4px 0px 4px; } QToolButton::menu-indicator {image: none;}");
    3537#endif /* Q_WS_MAC */
     38    }
     39
     40    void removeBorder()
     41    {
     42        setStyleSheet("QToolButton { border: 0px }");
    3643    }
    3744};

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPool.cpp

    r38902 r39932  
    303303        setText(vboxGlobal().insertKeyToActionText(QApplication::translate("UIMessageCenter", "&Reset All Warnings"), gMS->shortcut(UIMachineShortcuts::ResetWarningsShortcut)));
    304304        setStatusTip(QApplication::translate("UIMessageCenter", "Go back to showing all suppressed warnings and messages"));
     305    }
     306};
     307
     308class ShowNetworkAccessManagerAction : public UISimpleAction
     309{
     310    Q_OBJECT;
     311
     312public:
     313
     314    ShowNetworkAccessManagerAction(QObject *pParent)
     315        : UISimpleAction(pParent, ":/nw_16px.png", ":/nw_disabled_16px.png")
     316    {
     317        switch (gActionPool->type())
     318        {
     319            case UIActionPoolType_Selector:
     320                setShortcut(gSS->keySequence(UISelectorShortcuts::NetworkAccessManager));
     321                break;
     322            case UIActionPoolType_Runtime:
     323                setShortcut(gMS->keySequence(UIMachineShortcuts::NetworkAccessManager));
     324                break;
     325        }
     326        retranslateUi();
     327    }
     328
     329protected:
     330
     331    void retranslateUi()
     332    {
     333        setText(vboxGlobal().insertKeyToActionText(QApplication::translate("UIMessageCenter", "Network Access Manager..."), gMS->shortcut(UIMachineShortcuts::NetworkAccessManager)));
     334        setStatusTip(QApplication::translate("UIMessageCenter", "Show Network Access Manager"));
    305335    }
    306336};
    … …  
    479509    m_pool[UIActionIndex_Simple_Web] = new ShowWebAction(this);
    480510    m_pool[UIActionIndex_Simple_ResetWarnings] = new PerformResetWarningsAction(this);
     511    m_pool[UIActionIndex_Simple_NetworkAccessManager] = new ShowNetworkAccessManagerAction(this);
    481512#ifdef VBOX_WITH_REGISTRATION
    482513    m_pool[UIActionIndex_Simple_Register] = new PerformRegisterAction(this);
    … …  
    503534        delete m_pool[UIActionIndex_Simple_ResetWarnings];
    504535    m_pool[UIActionIndex_Simple_ResetWarnings] = new PerformResetWarningsAction(this);
     536    if (m_pool[UIActionIndex_Simple_NetworkAccessManager])
     537        delete m_pool[UIActionIndex_Simple_NetworkAccessManager];
     538    m_pool[UIActionIndex_Simple_NetworkAccessManager] = new ShowNetworkAccessManagerAction(this);
    505539#ifdef VBOX_WITH_REGISTRATION
    506540    if (m_pool[UIActionIndex_Simple_Register])

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIActionPool.h

    r38902 r39932  
    4444    UIActionIndex_Simple_Web,
    4545    UIActionIndex_Simple_ResetWarnings,
     46    UIActionIndex_Simple_NetworkAccessManager,
    4647#ifdef VBOX_WITH_REGISTRATION
    4748    UIActionIndex_Simple_Register,

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIMessageCenter.cpp

    r39451 r39932  
    3737#include "UISelectorWindow.h"
    3838#include "UIProgressDialog.h"
    39 #include "UIDownloaderUserManual.h"
     39#include "UINetworkManager.h"
     40#ifdef VBOX_OSE
     41# include "UIDownloaderUserManual.h"
     42#endif /* VBOX_OSE */
    4043#include "UIMachine.h"
    4144#include "VBoxAboutDlg.h"
    … …  
    431434}
    432435
     436/**
     437 *  Returns network access manager window if visible
     438 *  and window returned by mainWindowShown() otherwise.
     439 */
     440QWidget* UIMessageCenter::networkManagerOrMainWindowShown() const
     441{
     442    return gNetworkManager->window()->isVisible() ? gNetworkManager->window() : mainWindowShown();
     443}
     444
     445/**
     446 *  Returns network access manager window if visible
     447 *  and window returned by mainMachineWindowShown() otherwise.
     448 */
     449QWidget* UIMessageCenter::networkManagerOrMainMachineWindowShown() const
     450{
     451    return gNetworkManager->window()->isVisible() ? gNetworkManager->window() : mainMachineWindowShown();
     452}
     453
    433454bool UIMessageCenter::askForOverridingFile(const QString& strPath, QWidget *pParent /* = NULL */)
    434455{
    … …  
    17031724}
    17041725
    1705 int UIMessageCenter::cannotFindGuestAdditions(const QString &strSrc1,
    1706                                               const QString &strSrc2)
    1707 {
    1708     return message(mainMachineWindowShown(), Question,
     1726bool UIMessageCenter::cannotFindGuestAdditions(const QString &strSrc1, const QString &strSrc2)
     1727{
     1728    return messageYesNo(mainMachineWindowShown(), Question,
    17091729                    tr("<p>Could not find the VirtualBox Guest Additions "
    17101730                       "CD image file <nobr><b>%1</b></nobr> or "
    17111731                       "<nobr><b>%2</b>.</nobr></p><p>Do you wish to "
    17121732                       "download this CD image from the Internet?</p>")
    1713                         .arg(strSrc1).arg(strSrc2),
    1714                     0, /* pcszAutoConfirmId */
    1715                     QIMessageBox::Yes | QIMessageBox::Default,
    1716                     QIMessageBox::No | QIMessageBox::Escape);
    1717 }
    1718 
    1719 void UIMessageCenter::cannotDownloadGuestAdditions(const QString &strUrl,
    1720                                                    const QString &strReason)
    1721 {
    1722     message(mainMachineWindowShown(), Error,
    1723              tr("<p>Failed to download the VirtualBox Guest Additions CD "
    1724                 "image from <nobr><a href=\"%1\">%2</a>.</nobr></p><p>%3</p>")
    1725                  .arg(strUrl).arg(strUrl).arg(strReason));
     1733                       .arg(strSrc1).arg(strSrc2));
    17261734}
    17271735
    … …  
    17391747{
    17401748    QLocale loc(VBoxGlobal::languageId());
    1741     return messageOkCancel(mainMachineWindowShown(), Question,
    1742         tr("<p>Are you sure you want to download the VirtualBox "
    1743            "Guest Additions CD image from "
    1744            "<nobr><a href=\"%1\">%2</a></nobr> "
    1745            "(size %3 bytes)?</p>").arg(strUrl).arg(strUrl).arg(loc.toString(uSize)),
    1746         0, /* pcszAutoConfirmId */
    1747         tr("Download", "additions"));
    1748 }
    1749 
    1750 bool UIMessageCenter::confirmMountAdditions(const QString &strUrl,
    1751                                             const QString &strSrc)
    1752 {
    1753     return messageOkCancel(mainMachineWindowShown(), Question,
    1754         tr("<p>The VirtualBox Guest Additions CD image has been "
    1755            "successfully downloaded from "
    1756            "<nobr><a href=\"%1\">%2</a></nobr> "
    1757            "and saved locally as <nobr><b>%3</b>.</nobr></p>"
    1758            "<p>Do you wish to register this CD image and mount it "
    1759            "on the virtual CD/DVD drive?</p>")
    1760             .arg(strUrl).arg(strUrl).arg(strSrc),
    1761         0, /* pcszAutoConfirmId */
    1762         tr("Mount", "additions"));
     1749    return messageOkCancel(networkManagerOrMainMachineWindowShown(), Question,
     1750                           tr("<p>Are you sure you want to download the VirtualBox "
     1751                              "Guest Additions CD image from "
     1752                              "<nobr><a href=\"%1\">%2</a></nobr> "
     1753                              "(size %3 bytes)?</p>").arg(strUrl).arg(strUrl).arg(loc.toString(uSize)),
     1754                           0, /* pcszAutoConfirmId */
     1755                           tr("Download", "additions"));
     1756}
     1757
     1758bool UIMessageCenter::confirmMountAdditions(const QString &strUrl, const QString &strSrc)
     1759{
     1760    return messageOkCancel(networkManagerOrMainMachineWindowShown(), Question,
     1761                           tr("<p>The VirtualBox Guest Additions CD image has been "
     1762                              "successfully downloaded from "
     1763                              "<nobr><a href=\"%1\">%2</a></nobr> "
     1764                              "and saved locally as <nobr><b>%3</b>.</nobr></p>"
     1765                              "<p>Do you wish to register this CD image and mount it "
     1766                              "on the virtual CD/DVD drive?</p>")
     1767                               .arg(strUrl).arg(strUrl).arg(strSrc),
     1768                           0, /* pcszAutoConfirmId */
     1769                           tr("Mount", "additions"));
    17631770}
    17641771
    17651772void UIMessageCenter::warnAboutAdditionsCantBeSaved(const QString &strTarget)
    17661773{
    1767     message(mainWindowShown(), Error,
     1774    message(networkManagerOrMainMachineWindowShown(), Error,
    17681775            tr("<p>Failed to save the downloaded file as <nobr><b>%1</b>.</nobr></p>")
    17691776               .arg(QDir::toNativeSeparators(strTarget)));
    … …  
    17841791{
    17851792    QLocale loc(VBoxGlobal::languageId());
    1786     return messageOkCancel(mainWindowShown(), Question,
     1793    return messageOkCancel(networkManagerOrMainWindowShown(), Question,
    17871794                           tr("<p>Are you sure you want to download the VirtualBox "
    17881795                              "User Manual from "
    … …  
    17931800}
    17941801
    1795 void UIMessageCenter::warnAboutUserManualCantBeDownloaded(const QString &strURL, const QString &strReason)
    1796 {
    1797     message(mainWindowShown(), Error,
    1798             tr("<p>Failed to download the VirtualBox User Manual "
    1799                "from <nobr><a href=\"%1\">%2</a>.</nobr></p><p>%3</p>")
    1800                .arg(strURL).arg(strURL).arg(strReason));
    1801 }
    1802 
    18031802void UIMessageCenter::warnAboutUserManualDownloaded(const QString &strURL, const QString &strTarget)
    18041803{
    1805     message(mainWindowShown(), Warning,
     1804    message(networkManagerOrMainWindowShown(), Warning,
    18061805            tr("<p>The VirtualBox User Manual has been "
    18071806               "successfully downloaded from "
    … …  
    18131812void UIMessageCenter::warnAboutUserManualCantBeSaved(const QString &strURL, const QString &strTarget)
    18141813{
    1815     message(mainWindowShown(), Error,
     1814    message(networkManagerOrMainWindowShown(), Error,
    18161815            tr("<p>The VirtualBox User Manual has been "
    18171816               "successfully downloaded from "
    … …  
    18241823bool UIMessageCenter::proposeDownloadExtensionPack(const QString &strExtPackName, const QString &strExtPackVersion)
    18251824{
    1826     return messageOkCancel(mainWindowShown(), Question,
     1825    return messageOkCancel(mainWindowShown(),
     1826                           Question,
    18271827                           tr("<p>You have an old version (%1) of the <b><nobr>%2</nobr></b> installed.</p>"
    18281828                              "<p>Do you wish to download latest one from the Internet?</p>")
    … …  
    18481848{
    18491849    QLocale loc(VBoxGlobal::languageId());
    1850     return messageOkCancel(mainWindowShown(), Question,
     1850    return messageOkCancel(networkManagerOrMainWindowShown(), Question,
    18511851                           tr("<p>Are you sure you want to download the <b><nobr>%1</nobr></b> "
    18521852                              "from <nobr><a href=\"%2\">%2</a></nobr> (size %3 bytes)?</p>")
    … …  
    18581858bool UIMessageCenter::proposeInstallExtentionPack(const QString &strExtPackName, const QString &strFrom, const QString &strTo)
    18591859{
    1860     return messageOkCancel(mainWindowShown(), Question,
     1860    return messageOkCancel(networkManagerOrMainWindowShown(), Question,
    18611861                           tr("<p>The <b><nobr>%1</nobr></b> has been "
    18621862                              "successfully downloaded from <nobr><a href=\"%2\">%2</a></nobr> "
    … …  
    18701870void UIMessageCenter::warnAboutExtentionPackCantBeSaved(const QString &strExtPackName, const QString &strFrom, const QString &strTo)
    18711871{
    1872     message(mainWindowShown(), Error,
     1872    message(networkManagerOrMainWindowShown(), Error,
    18731873            tr("<p>The <b><nobr>%1</nobr></b> has been "
    18741874               "successfully downloaded from <nobr><a href=\"%2\">%2</a></nobr> "
    … …  
    18761876               "<p>Please choose another location for that file.</p>")
    18771877               .arg(strExtPackName, strFrom, strTo));
    1878 }
    1879 
    1880 void UIMessageCenter::cannotDownloadExtensionPack(const QString &strExtPackName, const QString &strFrom, const QString &strError)
    1881 {
    1882     message(mainWindowShown(), Error,
    1883             tr("<p>Failed to download the <b><nobr>%1</nobr></b> "
    1884                "from <nobr><a href=\"%2\">%2</a>.</nobr></p><p>%3</p>")
    1885                .arg(strExtPackName, strFrom, strError));
    18861878}
    18871879
    … …  
    19261918}
    19271919
    1928 void UIMessageCenter::showUpdateSuccess(QWidget *pParent,
    1929                                         const QString &strVersion,
    1930                                         const QString &strLink)
    1931 {
    1932     message(pParent, Info,
     1920void UIMessageCenter::showUpdateSuccess(const QString &strVersion, const QString &strLink)
     1921{
     1922    message(networkManagerOrMainWindowShown(), Info,
    19331923            tr("<p>A new version of VirtualBox has been released! Version <b>%1</b> is available at <a href=\"http://www.virtualbox.org/\">virtualbox.org</a>.</p>"
    19341924               "<p>You can download this version using the link:</p>"
    … …  
    19371927}
    19381928
    1939 void UIMessageCenter::showUpdateFailure(QWidget *pParent,
    1940                                         const QString &strReason)
    1941 {
    1942     message(pParent, Error,
    1943             tr("<p>Unable to obtain the new version information "
    1944                "due to the following error:</p><p><b>%1</b></p>")
    1945             .arg(strReason));
    1946 }
    1947 
    1948 void UIMessageCenter::showUpdateNotFound(QWidget *pParent)
    1949 {
    1950     message(pParent, Info,
    1951             tr("You are already running the most recent version of VirtualBox."
    1952                ""));
     1929void UIMessageCenter::showUpdateNotFound()
     1930{
     1931    message(networkManagerOrMainWindowShown(), Info,
     1932            tr("You are already running the most recent version of VirtualBox."));
     1933}
     1934
     1935bool UIMessageCenter::askAboutCancelAllNetworkRequest(QWidget *pParent)
     1936{
     1937    return messageOkCancel(pParent, Question, tr("Do you wish to cancel all current network requests?"));
     1938}
     1939
     1940bool UIMessageCenter::askAboutCancelOrLeaveAllNetworkRequest(QWidget *pParent)
     1941{
     1942    return messageYesNo(pParent, Question, tr("Do you wish to cancel all current network requests or leave them at the background?"),
     1943                        0 /* auto-confirm id */, tr("Cancel All"), tr("Leave At Background"));
    19531944}
    19541945
    … …  
    29622953    QString strShortFileName = QFileInfo(strUserManualFileName1).fileName();
    29632954    QString strUserManualFileName2 = QDir(vboxGlobal().virtualBox().GetHomeFolder()).absoluteFilePath(strShortFileName);
     2955    /* Show if user manual already present: */
    29642956    if (QFile::exists(strUserManualFileName1))
    29652957        sltShowUserManual(strUserManualFileName1);
    29662958    else if (QFile::exists(strUserManualFileName2))
    29672959        sltShowUserManual(strUserManualFileName2);
    2968     else if (!UIDownloaderUserManual::current() && askAboutUserManualDownload(strUserManualFileName1))
    2969     {
    2970         /* Create and configure the User Manual downloader: */
     2960    /* If downloader is running already: */
     2961    else if (UIDownloaderUserManual::current())
     2962    {
     2963        /* Just show network access manager: */
     2964        gNetworkManager->show();
     2965    }
     2966    /* Else propose to download user manual: */
     2967    else if (askAboutUserManualDownload(strUserManualFileName1))
     2968    {
     2969        /* Create User Manual downloader: */
    29712970        UIDownloaderUserManual *pDl = UIDownloaderUserManual::create();
    2972         CVirtualBox vbox = vboxGlobal().virtualBox();
    2973         pDl->addSource(QString("http://download.virtualbox.org/virtualbox/%1/").arg(vboxGlobal().vboxVersionStringNormalized()) + strShortFileName);
    2974         pDl->addSource(QString("http://download.virtualbox.org/virtualbox/") + strShortFileName);
    2975         pDl->setTarget(strUserManualFileName2);
    2976         pDl->setParentWidget(mainWindowShown());
    2977         /* After downloading finished => show the User Manual: */
     2971        /* After downloading finished => show User Manual: */
    29782972        connect(pDl, SIGNAL(sigDownloadFinished(const QString&)), this, SLOT(sltShowUserManual(const QString&)));
    29792973        /* Start downloading: */

  • trunk/src/VBox/Frontends/VirtualBox/src/globals/UIMessageCenter.h

    r39451 r39932  
    157157    QWidget* mainWindowShown() const;
    158158    QWidget* mainMachineWindowShown() const;
     159    QWidget* networkManagerOrMainWindowShown() const;
     160    QWidget* networkManagerOrMainMachineWindowShown() const;
    159161
    160162    bool askForOverridingFile(const QString& strPath, QWidget *pParent  = NULL);
    … …  
    297299
    298300    void remindAboutGuestAdditionsAreNotActive(QWidget *pParent);
    299     int cannotFindGuestAdditions(const QString &strSrc1, const QString &strSrc2);
    300     void cannotDownloadGuestAdditions(const QString &strUrl, const QString &strReason);
     301    bool cannotFindGuestAdditions(const QString &strSrc1, const QString &strSrc2);
    301302    void cannotMountGuestAdditions(const QString &strMachineName);
    302303    bool confirmDownloadAdditions(const QString &strUrl, qulonglong uSize);
    … …  
    306307    bool askAboutUserManualDownload(const QString &strMissedLocation);
    307308    bool confirmUserManualDownload(const QString &strURL, qulonglong uSize);
    308     void warnAboutUserManualCantBeDownloaded(const QString &strURL, const QString &strReason);
    309309    void warnAboutUserManualDownloaded(const QString &strURL, const QString &strTarget);
    310310    void warnAboutUserManualCantBeSaved(const QString &strURL, const QString &strTarget);
    … …  
    315315    bool proposeInstallExtentionPack(const QString &strExtPackName, const QString &strFrom, const QString &strTo);
    316316    void warnAboutExtentionPackCantBeSaved(const QString &strExtPackName, const QString &strFrom, const QString &strTo);
    317     void cannotDownloadExtensionPack(const QString &strExtPackName, const QString &strFrom, const QString &strError);
    318317
    319318    void cannotConnectRegister(QWidget *pParent,
    … …  
    323322                            const QString &strResult);
    324323
    325     void showUpdateSuccess(QWidget *pParent,
    326                            const QString &strVersion,
    327                            const QString &strLink);
    328     void showUpdateFailure(QWidget *pParent,
    329                            const QString &strReason);
    330     void showUpdateNotFound(QWidget *pParent);
     324    void showUpdateSuccess(const QString &strVersion, const QString &strLink);
     325    void showUpdateNotFound();
     326
     327    bool askAboutCancelAllNetworkRequest(QWidget *pParent);
     328    bool askAboutCancelOrLeaveAllNetworkRequest(QWidget *pParent);
    331329
    332330    bool confirmInputCapture(bool *pfAutoConfirmed = NULL);

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloader.cpp

    r39379 r39932  
    77
    88/*
    9  * Copyright (C) 2006-2011 Oracle Corporation
     9 * Copyright (C) 2006-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919
    2020/* Global includes: */
    21 #include <QProgressBar>
    2221#include <QNetworkReply>
    2322
    2423/* Local includes: */
    2524#include "UIDownloader.h"
    26 #include "UINetworkManager.h"
    2725#include "VBoxGlobal.h"
    2826#include "UIMessageCenter.h"
     27#include "VBoxUtils.h"
     28
     29#if 0
     30/* Global includes: */
     31#include <QProgressBar>
     32
     33/* Local includes: */
    2934#include "UISpecialControls.h"
    30 #include "VBoxUtils.h"
    3135
    3236/* UIMiniProgressWidget stuff: */
    … …  
    98102    m_pProgressBar->setValue(cDone);
    99103}
    100 
     104#endif
     105
     106/* Starting routine: */
     107void UIDownloader::start()
     108{
     109    startDelayedAcknowledging();
     110}
     111
     112/* Acknowledging start: */
     113void UIDownloader::sltStartAcknowledging()
     114{
     115    /* Set state to acknowledging: */
     116    m_state = UIDownloaderState_Acknowledging;
     117
     118    /* Send HEAD requests: */
     119    QList<QNetworkRequest> requests;
     120    for (int i = 0; i < m_sources.size(); ++i)
     121        requests << QNetworkRequest(m_sources[i]);
     122
     123    /* Create network request set: */
     124    createNetworkRequest(requests, UINetworkRequestType_HEAD, tr("Looking for %1...").arg(m_strDescription));
     125}
     126
     127/* Downloading start: */
     128void UIDownloader::sltStartDownloading()
     129{
     130    /* Set state to acknowledging: */
     131    m_state = UIDownloaderState_Downloading;
     132
     133    /* Send GET request: */
     134    QNetworkRequest request(m_source);
     135
     136    /* Create network request: */
     137    createNetworkRequest(request, UINetworkRequestType_GET, tr("Downloading %1...").arg(m_strDescription));
     138}
     139
     140#if 0
     141/* Cancel-button stuff: */
     142void UIDownloader::sltCancel()
     143{
     144    /* Delete downloader: */
     145    deleteLater();
     146}
     147#endif
     148
     149/* Constructor: */
     150UIDownloader::UIDownloader()
     151{
     152    /* Choose initial state: */
     153    m_state = UIDownloaderState_Null;
     154
     155    /* Connect listeners: */
     156    connect(this, SIGNAL(sigToStartAcknowledging()), this, SLOT(sltStartAcknowledging()), Qt::QueuedConnection);
     157    connect(this, SIGNAL(sigToStartDownloading()), this, SLOT(sltStartDownloading()), Qt::QueuedConnection);
     158}
     159
     160/* Network-reply progress handler: */
     161void UIDownloader::processNetworkReplyProgress(qint64 iReceived, qint64 iTotal)
     162{
     163    /* Unused variables: */
     164    Q_UNUSED(iReceived);
     165    Q_UNUSED(iTotal);
     166
     167#if 0
     168    emit sigDownloadProgress(iReceived, iTotal);
     169#endif
     170}
     171
     172/* Network-reply canceled handler: */
     173void UIDownloader::processNetworkReplyCanceled(QNetworkReply *pNetworkReply)
     174{
     175    /* Unused variables: */
     176    Q_UNUSED(pNetworkReply);
     177
     178    /* Delete downloader: */
     179    deleteLater();
     180}
     181
     182/* Network-reply finished handler: */
     183void UIDownloader::processNetworkReplyFinished(QNetworkReply *pNetworkReply)
     184{
     185    /* Process reply: */
     186    switch (m_state)
     187    {
     188        case UIDownloaderState_Acknowledging:
     189        {
     190            handleAcknowledgingResult(pNetworkReply);
     191            break;
     192        }
     193        case UIDownloaderState_Downloading:
     194        {
     195            handleDownloadingResult(pNetworkReply);
     196            break;
     197        }
     198        default:
     199            break;
     200    }
     201}
     202
     203/* Handle acknowledging result: */
     204void UIDownloader::handleAcknowledgingResult(QNetworkReply *pNetworkReply)
     205{
     206    /* Get the final source: */
     207    m_source = pNetworkReply->url();
     208
     209    /* Ask for downloading: */
     210    if (askForDownloadingConfirmation(pNetworkReply))
     211    {
     212        /* Start downloading: */
     213        startDelayedDownloading();
     214    }
     215    else
     216    {
     217        /* Delete downloader: */
     218        deleteLater();
     219    }
     220}
     221
     222/* Handle downloading result: */
     223void UIDownloader::handleDownloadingResult(QNetworkReply *pNetworkReply)
     224{
     225    /* Handle downloaded object: */
     226    handleDownloadedObject(pNetworkReply);
     227
     228    /* Delete downloader: */
     229    deleteLater();
     230}
     231
     232#if 0
    101233/* UIDownloader stuff: */
    102234UIMiniProgressWidget* UIDownloader::progressWidget(QWidget *pParent) const
    … …  
    117249    return pWidget;
    118250}
    119 
    120 void UIDownloader::start()
    121 {
    122     startDelayedAcknowledging();
    123 }
    124 
    125 UIDownloader::UIDownloader()
    126 {
    127     connect(this, SIGNAL(sigToStartAcknowledging()), this, SLOT(sltStartAcknowledging()), Qt::QueuedConnection);
    128     connect(this, SIGNAL(sigToStartDownloading()), this, SLOT(sltStartDownloading()), Qt::QueuedConnection);
    129     connect(this, SIGNAL(sigDownloadingStarted(UIDownloadType)), gNetworkManager, SIGNAL(sigDownloaderCreated(UIDownloadType)));
    130 }
    131 
    132 /* Start acknowledging: */
    133 void UIDownloader::sltStartAcknowledging()
    134 {
    135     /* Setup HEAD request: */
    136     QNetworkRequest request;
    137     request.setUrl(m_source);
    138     QNetworkReply *pReply = gNetworkManager->head(request);
    139     connect(pReply, SIGNAL(finished()), this, SLOT(sltFinishAcknowledging()));
    140 }
    141 
    142 /* Finish acknowledging: */
    143 void UIDownloader::sltFinishAcknowledging()
    144 {
    145     /* Get corresponding network reply object: */
    146     QNetworkReply *pReply = qobject_cast<QNetworkReply*>(sender());
    147     /* And ask it for suicide: */
    148     pReply->deleteLater();
    149 
    150     /* Handle normal reply: */
    151     if (pReply->error() == QNetworkReply::NoError)
    152         handleAcknowledgingResult(pReply);
    153     /* Handle errors: */
    154     else
    155         handleError(pReply);
    156 }
    157 
    158 /* Handle acknowledging result: */
    159 void UIDownloader::handleAcknowledgingResult(QNetworkReply *pReply)
    160 {
    161     /* Check if redirection required: */
    162     QUrl redirect = pReply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
    163     if (redirect.isValid())
    164     {
    165         /* Set new source: */
    166         UIDownloader::setSource(redirect.toString());
    167         /* Start redirecting: */
    168         startDelayedAcknowledging();
    169         return;
    170     }
    171 
    172     /* Ask for downloading confirmation: */
    173     if (askForDownloadingConfirmation(pReply))
    174     {
    175         /* Start downloading: */
    176         startDelayedDownloading();
    177         return;
    178     }
    179 
    180     /* Delete downloader: */
    181     deleteLater();
    182 }
    183 
    184 /* Start downloading: */
    185 void UIDownloader::sltStartDownloading()
    186 {
    187     /* Setup GET request: */
    188     QNetworkRequest request;
    189     request.setUrl(m_source);
    190     QNetworkReply *pReply = gNetworkManager->get(request);
    191     connect(pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SIGNAL(sigDownloadProgress(qint64, qint64)));
    192     connect(pReply, SIGNAL(finished()), this, SLOT(sltFinishDownloading()));
    193 }
    194 
    195 /* Finish downloading: */
    196 void UIDownloader::sltFinishDownloading()
    197 {
    198     /* Get corresponding network reply object: */
    199     QNetworkReply *pReply = qobject_cast<QNetworkReply*>(sender());
    200     /* And ask it for suicide: */
    201     pReply->deleteLater();
    202 
    203     /* Handle normal reply: */
    204     if (pReply->error() == QNetworkReply::NoError)
    205         handleDownloadingResult(pReply);
    206     /* Handle errors: */
    207     else
    208         handleError(pReply);
    209 }
    210 
    211 /* Handle downloading result: */
    212 void UIDownloader::handleDownloadingResult(QNetworkReply *pReply)
    213 {
    214     /* Handle downloaded object: */
    215     handleDownloadedObject(pReply);
    216 
    217     /* Delete downloader: */
    218     deleteLater();
    219 }
    220 
    221 /* Handle simple errors: */
    222 void UIDownloader::handleError(QNetworkReply *pReply)
    223 {
    224     /* Show error message: */
    225     warnAboutNetworkError(pReply->errorString());
    226 
    227     /* Delete downloader: */
    228     deleteLater();
    229 }
    230 
    231 /* Cancel-button stuff: */
    232 void UIDownloader::sltCancel()
    233 {
    234     /* Delete downloader: */
    235     deleteLater();
    236 }
    237 
     251#endif
     252

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloader.h

    r39326 r39932  
    66
    77/*
    8  * Copyright (C) 2006-2011 Oracle Corporation
     8 * Copyright (C) 2006-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2424#include <QUrl>
    2525#include <QPointer>
     26#include <QList>
    2627
    2728/* Local includes: */
    2829#include "UINetworkDefs.h"
     30#include "UINetworkCustomer.h"
    2931
     32/* Forward declarations: */
     33class QNetworkReply;
     34
     35#if 0
    3036/* Forward declarations: */
    3137class QProgressBar;
    3238class UIMiniCancelButton;
    33 class QNetworkReply;
    3439
    3540/**
    … …  
    7883    QString m_strSource;
    7984};
     85#endif
    8086
    8187/**
    82  * The UIDownloader class is QObject class re-implementation which
    83  * allows background http downloading.
     88 * The UIDownloader class is UINetworkCustomer class extension
     89 * which allows background http downloading.
    8490 * This class is not supposed to be used itself and made for sub-classing only.
    85  *
    86  * This class has two parts:
    87  * 1. Acknowledging (getting information about target presence and size).
    88  * 2. Downloading (starting and handling file downloading process).
    89  * Every subclass can determine using or not those two parts and handling
    90  * the result of those parts itself.
    9191 */
    92 class UIDownloader : public QObject
     92class UIDownloader : public UINetworkCustomer
    9393{
    9494    Q_OBJECT;
    9595
    96 public:
    97 
    98     /* Parent stuff: */
    99     virtual void setParentWidget(QWidget *pParent) { m_pParent = pParent; }
    100     virtual QWidget* parentWidget() const { return m_pParent; }
    101 
    102     /* Source stuff: */
    103     virtual void setSource(const QString &strSource) { m_source = strSource; }
    104     virtual QString source() const { return m_source.toString(); }
    105 
    106     /* Target stuff: */
    107     virtual void setTarget(const QString &strTarget) { m_strTarget = strTarget; }
    108     virtual QString target() const { return m_strTarget; }
    109 
    110     /* Create UIMiniProgressWidget for particular parent: */
    111     UIMiniProgressWidget* progressWidget(QWidget *pParent = 0) const;
    112 
    113     /* Starting stuff: */
    114     virtual void start();
    115 
    11696signals:
    117 
    118     /* Signal to notify listeners about source-change: */
    119     void sigSourceChanged(const QString &strNewSource);
    12097
    12198    /* Signal to start acknowledging: */
    … …  
    124101    void sigToStartDownloading();
    125102
     103#if 0
     104    /* Notifies listeners about source-change: */
     105    void sigSourceChanged(const QString &strNewSource);
     106
    126107    /* Notifies about downloading progress: */
    127108    void sigDownloadProgress(qint64 cDone, qint64 cTotal);
     109#endif
    128110
    129     /* Notifies network manager about downloading started: */
    130     void sigDownloadingStarted(UIDownloadType downloadType);
     111public:
     112
     113    /* Starting routine: */
     114    virtual void start();
     115
     116private slots:
     117
     118    /* Acknowledging part: */
     119    void sltStartAcknowledging();
     120    /* Downloading part: */
     121    void sltStartDownloading();
     122
     123#if 0
     124    /* Common slots: */
     125    void sltCancel();
     126#endif
    131127
    132128protected:
    133129
     130    /* UIDownloader states: */
     131    enum UIDownloaderState
     132    {
     133        UIDownloaderState_Null,
     134        UIDownloaderState_Acknowledging,
     135        UIDownloaderState_Downloading
     136    };
     137
    134138    /* Constructor: */
    135139    UIDownloader();
     140
     141    /* Source stuff,
     142     * allows to set/get one or more sources to try to download from: */
     143    void addSource(const QString &strSource) { m_sources << QUrl(strSource); }
     144    void setSource(const QString &strSource) { m_sources.clear(); addSource(strSource); }
     145    const QList<QUrl>& sources() const { return m_sources; }
     146    const QUrl& source() const { return m_source; }
     147
     148    /* Target stuff,
     149     * allows to set/get downloaded file destination: */
     150    void setTarget(const QString &strTarget) { m_strTarget = strTarget; }
     151    const QString& target() const { return m_strTarget; }
     152
     153    /* Description stuff,
     154     * allows to set/get Network Customer description for Network Access Manager: */
     155    void setDescription(const QString &strDescription) { m_strDescription = strDescription; }
    136156
    137157    /* Start delayed acknowledging: */
    … …  
    140160    void startDelayedDownloading() { emit sigToStartDownloading(); }
    141161
     162    /* Network-reply progress handler: */
     163    void processNetworkReplyProgress(qint64 iReceived, qint64 iTotal);
     164    /* Network-reply cancel handler: */
     165    void processNetworkReplyCanceled(QNetworkReply *pNetworkReply);
     166    /* Network-reply finish handler: */
     167    void processNetworkReplyFinished(QNetworkReply *pNetworkReply);
     168
    142169    /* Handle acknowledging result: */
    143     virtual void handleAcknowledgingResult(QNetworkReply *pReply);
     170    virtual void handleAcknowledgingResult(QNetworkReply *pNetworkReply);
    144171    /* Handle downloading result: */
    145     virtual void handleDownloadingResult(QNetworkReply *pReply);
    146     /* Handle errors: */
    147     virtual void handleError(QNetworkReply *pReply);
     172    virtual void handleDownloadingResult(QNetworkReply *pNetworkReply);
    148173
     174    /* Pure virtual function to ask user about downloading confirmation: */
     175    virtual bool askForDownloadingConfirmation(QNetworkReply *pNetworkReply) = 0;
     176    /* Pure virtual function to handle downloaded object: */
     177    virtual void handleDownloadedObject(QNetworkReply *pNetworkReply) = 0;
     178
     179#if 0
    149180    /* Pure virtual function to create UIMiniProgressWidget sub-class: */
    150181    virtual UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const = 0;
    151     /* Pure virtual function to ask user about downloading confirmation: */
    152     virtual bool askForDownloadingConfirmation(QNetworkReply *pReply) = 0;
    153     /* Pure virtual function to handle downloaded object: */
    154     virtual void handleDownloadedObject(QNetworkReply *pReply) = 0;
    155     /* Pure virtual function to warn user about issues: */
    156     virtual void warnAboutNetworkError(const QString &strError) = 0;
    157 
    158 private slots:
    159 
    160     /* Acknowledging part: */
    161     void sltStartAcknowledging();
    162     void sltFinishAcknowledging();
    163 
    164     /* Downloading part: */
    165     void sltStartDownloading();
    166     void sltFinishDownloading();
    167 
    168     /* Common slots: */
    169     void sltCancel();
     182    /* Create UIMiniProgressWidget for particular parent: */
     183    UIMiniProgressWidget* progressWidget(QWidget *pParent = 0) const;
     184#endif
    170185
    171186private:
    172187
    173188    /* Private variables: */
     189    UIDownloaderState m_state;
     190    QPointer<QWidget> m_pParent;
     191    QList<QUrl> m_sources;
    174192    QUrl m_source;
    175193    QString m_strTarget;
    176     QPointer<QWidget> m_pParent;
     194    QString m_strDescription;
    177195};
    178196

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderAdditions.cpp

    r39326 r39932  
    77
    88/*
    9  * Copyright (C) 2006-2011 Oracle Corporation
     9 * Copyright (C) 2006-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919
    2020/* Global includes: */
    21 #include <QAction>
     21#include <QNetworkReply>
    2222#include <QDir>
    2323#include <QFile>
    24 #include <QNetworkReply>
    2524
    2625/* Local includes: */
    2726#include "UIDownloaderAdditions.h"
    2827#include "QIFileDialog.h"
     28#include "VBoxGlobal.h"
    2929#include "UIMessageCenter.h"
    3030
    31 UIDownloaderAdditions *UIDownloaderAdditions::m_pInstance = 0;
     31/* Static stuff: */
     32UIDownloaderAdditions* UIDownloaderAdditions::m_spInstance = 0;
    3233
    33 UIDownloaderAdditions *UIDownloaderAdditions::create()
     34UIDownloaderAdditions* UIDownloaderAdditions::create()
    3435{
    35     if (!m_pInstance)
    36         m_pInstance = new UIDownloaderAdditions;
    37     return m_pInstance;
     36    if (!m_spInstance)
     37        m_spInstance = new UIDownloaderAdditions;
     38    return m_spInstance;
    3839}
    3940
    40 UIDownloaderAdditions *UIDownloaderAdditions::current()
     41UIDownloaderAdditions* UIDownloaderAdditions::current()
    4142{
    42     return m_pInstance;
     43    return m_spInstance;
    4344}
    4445
    45 void UIDownloaderAdditions::setAction(QAction *pAction)
    46 {
    47     m_pAction = pAction;
    48     if (m_pAction)
    49         m_pAction->setEnabled(false);
    50 }
    51 
    52 QAction *UIDownloaderAdditions::action() const
    53 {
    54     return m_pAction;
    55 }
    56 
     46/* Starting routine: */
    5747void UIDownloaderAdditions::start()
    5848{
    5949    /* Call for base-class: */
    6050    UIDownloader::start();
     51#if 0
    6152    /* Notify about downloading started: */
    62     emit sigDownloadingStarted(UIDownloadType_Additions);
     53    notifyDownloaderCreated(UIDownloadType_Additions);
     54#endif
    6355}
    6456
     57/* Constructor: */
    6558UIDownloaderAdditions::UIDownloaderAdditions()
    66     : UIDownloader()
    6759{
     60    /* Prepare instance: */
     61    if (!m_spInstance)
     62        m_spInstance = this;
     63
     64    /* Set description: */
     65    setDescription(tr("VirtualBox Guest Additions"));
     66
     67    /* Prepare source/target: */
     68    const QString &strName = QString("VBoxGuestAdditions_%1.iso").arg(vboxGlobal().vboxVersionStringNormalized());
     69    const QString &strSource = QString("http://download.virtualbox.org/virtualbox/%1/").arg(vboxGlobal().vboxVersionStringNormalized()) + strName;
     70    const QString &strTarget = QDir(vboxGlobal().virtualBox().GetHomeFolder()).absoluteFilePath(strName);
     71
     72    /* Set source/target: */
     73    setSource(strSource);
     74    setTarget(strTarget);
    6875}
    6976
     77/* Destructor: */
    7078UIDownloaderAdditions::~UIDownloaderAdditions()
    7179{
    72     if (m_pAction)
    73         m_pAction->setEnabled(true);
    74     if (m_pInstance == this)
    75         m_pInstance = 0;
     80    /* Cleanup instance: */
     81    if (m_spInstance == this)
     82        m_spInstance = 0;
    7683}
    7784
    78 UIMiniProgressWidget* UIDownloaderAdditions::createProgressWidgetFor(QWidget *pParent) const
     85/* Virtual stuff reimplementations: */
     86bool UIDownloaderAdditions::askForDownloadingConfirmation(QNetworkReply *pReply)
    7987{
    80     return new UIMiniProgressWidgetAdditions(source(), pParent);
     88    return msgCenter().confirmDownloadAdditions(source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    8189}
    8290
    83 bool UIDownloaderAdditions::askForDownloadingConfirmation(QNetworkReply *pReply)
    84 {
    85     return msgCenter().confirmDownloadAdditions(source(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    86 }
    87 
     91/* Virtual stuff reimplementations: */
    8892void UIDownloaderAdditions::handleDownloadedObject(QNetworkReply *pReply)
    8993{
    … …  
    100104            file.write(receivedData);
    101105            file.close();
     106
    102107            /* Warn user about additions image loaded and saved, propose to mount it: */
    103             if (msgCenter().confirmMountAdditions(source(), QDir::toNativeSeparators(target())))
     108            if (msgCenter().confirmMountAdditions(source().toString(), QDir::toNativeSeparators(target())))
    104109                emit sigDownloadFinished(target());
    105110            break;
    106111        }
    107         else
    108         {
    109             /* Warn user about additions image loaded but was not saved: */
    110             msgCenter().warnAboutAdditionsCantBeSaved(target());
    111         }
    112112
    113         /* Ask the user about additions image file save location: */
    114         QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(), parentWidget(),
     113        /* Warn user about additions image was downloaded but was NOT saved: */
     114        msgCenter().warnAboutAdditionsCantBeSaved(target());
     115
     116        /* Ask the user for another location for the additions image file: */
     117        QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(),
     118                                                               msgCenter().networkManagerOrMainMachineWindowShown(),
    115119                                                               tr("Select folder to save Guest Additions image to"), true);
    116120
    117         /* Check if user set new target: */
     121        /* Check if user had really set a new target: */
    118122        if (!strTarget.isNull())
    119123            setTarget(QDir(strTarget).absoluteFilePath(QFileInfo(target()).fileName()));
    … …  
    123127}
    124128
    125 void UIDownloaderAdditions::warnAboutNetworkError(const QString &strError)
     129#if 0
     130UIMiniProgressWidget* UIDownloaderAdditions::createProgressWidgetFor(QWidget *pParent) const
    126131{
    127     return msgCenter().cannotDownloadGuestAdditions(source(), strError);
     132    return new UIMiniProgressWidgetAdditions(source(), pParent);
    128133}
     134#endif
    129135

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderAdditions.h

    r39326 r39932  
    66
    77/*
    8  * Copyright (C) 2006-2011 Oracle Corporation
     8 * Copyright (C) 2006-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2121
    2222/* Local includes: */
    23 #include "QIWithRetranslateUI.h"
    2423#include "UIDownloader.h"
    2524
     25#if 0
     26/* Local includes: */
     27# include "QIWithRetranslateUI.h"
     28
     29/**
     30 * The UIMiniProgressWidgetAdditions class is UIMiniProgressWidget class re-implementation
     31 * which embeds into the dialog's status-bar and reflects background http downloading.
     32 */
    2633class UIMiniProgressWidgetAdditions : public QIWithRetranslateUI<UIMiniProgressWidget>
    2734{
    … …  
    3037public:
    3138
     39    /* Constructor: */
    3240    UIMiniProgressWidgetAdditions(const QString &strSource, QWidget *pParent = 0)
    3341        : QIWithRetranslateUI<UIMiniProgressWidget>(pParent)
    … …  
    3947protected:
    4048
     49    /* Translating stuff: */
    4150    void retranslateUi()
    4251    {
    … …  
    4655    }
    4756};
     57#endif
    4858
     59/**
     60 * The UIDownloaderAdditions class is UIDownloader class extension
     61 * which allows background http downloading.
     62 */
    4963class UIDownloaderAdditions : public UIDownloader
    5064{
    5165    Q_OBJECT;
    5266
     67signals:
     68
     69    /* Notifies listeners about file was downloaded: */
     70    void sigDownloadFinished(const QString &strFile);
     71
    5372public:
    5473
     74    /* Static stuff: */
    5575    static UIDownloaderAdditions* create();
    5676    static UIDownloaderAdditions* current();
    5777
    58     void setAction(QAction *pAction);
    59     QAction *action() const;
    60 
     78    /* Starting routine: */
    6179    void start();
    62 
    63 signals:
    64 
    65     void sigDownloadFinished(const QString &strFile);
    6680
    6781private:
    6882
     83    /* Constructor/destructor: */
    6984    UIDownloaderAdditions();
    7085    ~UIDownloaderAdditions();
    7186
    72     UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     87    /* Virtual stuff reimplementations: */
    7388    bool askForDownloadingConfirmation(QNetworkReply *pReply);
    7489    void handleDownloadedObject(QNetworkReply *pReply);
    75     void warnAboutNetworkError(const QString &strError);
     90#if 0
     91    UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     92#endif
    7693
    77     /* Private member variables: */
    78     static UIDownloaderAdditions *m_pInstance;
    79 
    80     /* Action to be blocked: */
    81     QPointer<QAction> m_pAction;
     94    /* Static instance variable: */
     95    static UIDownloaderAdditions *m_spInstance;
    8296};
    8397

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderExtensionPack.cpp

    r39878 r39932  
    33 *
    44 * VBox frontends: Qt GUI ("VirtualBox"):
    5  * UIDownloader for extension pack
     5 * UIDownloaderExtensionPack class implementation
    66 */
    77
    88/*
    9  * Copyright (C) 2011 Oracle Corporation
     9 * Copyright (C) 2011-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919
    2020/* Global includes: */
     21#include <QNetworkReply>
    2122#include <QDir>
    2223#include <QFile>
    23 #include <QNetworkReply>
    2424#include <iprt/sha.h>
    2525
    2626/* Local includes: */
    2727#include "UIDownloaderExtensionPack.h"
     28#include "QIFileDialog.h"
    2829#include "VBoxGlobal.h"
    2930#include "UIMessageCenter.h"
    30 #include "QIFileDialog.h"
    3131#include "VBoxDefs.h"
    3232
    … …  
    3434using namespace VBoxGlobalDefs;
    3535
    36 /* UIMiniProgressWidget stuff: */
    37 UIMiniProgressWidgetExtension::UIMiniProgressWidgetExtension(const QString &strSource, QWidget *pParent /* = 0 */)
    38     : QIWithRetranslateUI<UIMiniProgressWidget>(pParent)
     36/* Static stuff: */
     37UIDownloaderExtensionPack* UIDownloaderExtensionPack::m_spInstance = 0;
     38
     39UIDownloaderExtensionPack* UIDownloaderExtensionPack::create()
    3940{
    40     sltSetSource(strSource);
    41     retranslateUi();
     41    if (!m_spInstance)
     42        m_spInstance = new UIDownloaderExtensionPack;
     43    return m_spInstance;
    4244}
    4345
    44 void UIMiniProgressWidgetExtension::retranslateUi()
     46UIDownloaderExtensionPack* UIDownloaderExtensionPack::current()
    4547{
    46     setCancelButtonToolTip(tr("Cancel the <nobr><b>%1</b></nobr> download").arg(UI_ExtPackName));
    47     setProgressBarToolTip(tr("Downloading the <nobr><b>%1</b></nobr> from <nobr><b>%2</b>...</nobr>")
    48                              .arg(UI_ExtPackName, source()));
     48    return m_spInstance;
    4949}
    5050
    51 /* UIDownloaderExtensionPack stuff: */
    52 UIDownloaderExtensionPack* UIDownloaderExtensionPack::m_pInstance = 0;
    53 
    54 /* static */
    55 UIDownloaderExtensionPack* UIDownloaderExtensionPack::create()
    56 {
    57     if (!m_pInstance)
    58         m_pInstance = new UIDownloaderExtensionPack;
    59     return m_pInstance;
    60 }
    61 
    62 /* static */
    63 UIDownloaderExtensionPack* UIDownloaderExtensionPack::current()
    64 {
    65     return m_pInstance;
    66 }
    67 
     51/* Starting routine: */
    6852void UIDownloaderExtensionPack::start()
    6953{
    7054    /* Call for base-class: */
    7155    UIDownloader::start();
     56#if 0
    7257    /* Notify about downloading started: */
    73     emit sigDownloadingStarted(UIDownloadType_ExtensionPack);
     58    notifyDownloaderCreated(UIDownloadType_ExtensionPack);
     59#endif
    7460}
    7561
     62/* Constructor: */
    7663UIDownloaderExtensionPack::UIDownloaderExtensionPack()
    7764{
    7865    /* Prepare instance: */
    79     if (!m_pInstance)
    80         m_pInstance = this;
     66    if (!m_spInstance)
     67        m_spInstance = this;
     68
     69    /* Set description: */
     70    setDescription(tr("VirtualBox Extension Pack"));
    8171
    8272    /* Prepare source/target: */
    … …  
    9686}
    9787
     88/* Destructor: */
    9889UIDownloaderExtensionPack::~UIDownloaderExtensionPack()
    9990{
    10091    /* Cleanup instance: */
    101     if (m_pInstance == this)
    102         m_pInstance = 0;
     92    if (m_spInstance == this)
     93        m_spInstance = 0;
    10394}
    10495
    105 UIMiniProgressWidget* UIDownloaderExtensionPack::createProgressWidgetFor(QWidget *pParent) const
    106 {
    107     return new UIMiniProgressWidgetExtension(source(), pParent);
    108 }
    109 
     96/* Virtual stuff reimplementations: */
    11097bool UIDownloaderExtensionPack::askForDownloadingConfirmation(QNetworkReply *pReply)
    11198{
    112     return msgCenter().confirmDownloadExtensionPack(UI_ExtPackName, source(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
     99    return msgCenter().confirmDownloadExtensionPack(UI_ExtPackName, source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    113100}
    114101
    … …  
    117104    /* Read received data into buffer: */
    118105    QByteArray receivedData(pReply->readAll());
    119 
    120106    /* Serialize the incoming buffer into the file: */
    121     for (;;)
     107    while (true)
    122108    {
    123109        /* Try to open file for writing: */
    … …  
    129115            file.close();
    130116
    131             /* Calc the SHA-256 on the bytes, creating a string. */
     117            /* Calc the SHA-256 on the bytes, creating a string: */
    132118            uint8_t abHash[RTSHA256_HASH_SIZE];
    133119            RTSha256(receivedData.constData(), receivedData.length(), abHash);
    … …  
    141127
    142128            /* Notify listener about extension pack was downloaded: */
    143             emit sigNotifyAboutExtensionPackDownloaded(source(), target(), &szDigest[0]);
     129            emit sigDownloadFinished(source().toString(), target(), &szDigest[0]);
    144130            break;
    145131        }
    146132
    147         /* Warn the user about extension pack was downloaded but was NOT saved, explain it: */
    148         msgCenter().warnAboutExtentionPackCantBeSaved(UI_ExtPackName, source(), QDir::toNativeSeparators(target()));
     133        /* Warn the user about extension pack was downloaded but was NOT saved: */
     134        msgCenter().warnAboutExtentionPackCantBeSaved(UI_ExtPackName, source().toString(), QDir::toNativeSeparators(target()));
    149135
    150136        /* Ask the user for another location for the extension pack file: */
    151         QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(), parentWidget(),
     137        QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(),
     138                                                               msgCenter().networkManagerOrMainWindowShown(),
    152139                                                               tr("Select folder to save %1 to").arg(UI_ExtPackName), true);
    153140
    … …  
    160147}
    161148
    162 void UIDownloaderExtensionPack::warnAboutNetworkError(const QString &strError)
     149#if 0
     150UIMiniProgressWidget* UIDownloaderExtensionPack::createProgressWidgetFor(QWidget *pParent) const
    163151{
    164     return msgCenter().cannotDownloadExtensionPack(UI_ExtPackName, source(), strError);
     152    return new UIMiniProgressWidgetExtension(source(), pParent);
    165153}
     154#endif
    166155

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderExtensionPack.h

    r39878 r39932  
    22 *
    33 * VBox frontends: Qt GUI ("VirtualBox"):
    4  * UIDownloader for extension pack
     4 * UIDownloaderExtensionPack class declaration
    55 */
    66
    77/*
    8  * Copyright (C) 2011 Oracle Corporation
     8 * Copyright (C) 2011-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2121
    2222/* Local includes: */
    23 #include "QIWithRetranslateUI.h"
    2423#include "UIDownloader.h"
    2524
    26 /* UIMiniProgressWidget reimplementation for the VirtualBox extension pack downloading: */
     25#if 0
     26/* Local includes: */
     27# include "QIWithRetranslateUI.h"
     28
     29/**
     30 * The UIMiniProgressWidgetExtension class is UIMiniProgressWidget class re-implementation
     31 * which embeds into the dialog's status-bar and reflects background http downloading.
     32 */
    2733class UIMiniProgressWidgetExtension : public QIWithRetranslateUI<UIMiniProgressWidget>
    2834{
    … …  
    3238
    3339    /* Constructor: */
    34     UIMiniProgressWidgetExtension(const QString &strSource, QWidget *pParent = 0);
     40    UIMiniProgressWidgetExtension(const QString &strSource, QWidget *pParent = 0)
     41        : QIWithRetranslateUI<UIMiniProgressWidget>(pParent)
     42    {
     43        sltSetSource(strSource);
     44        retranslateUi();
     45    }
    3546
    3647private:
    3748
    3849    /* Translating stuff: */
    39     void retranslateUi();
     50    void retranslateUi()
     51    {
     52        setCancelButtonToolTip(tr("Cancel the <nobr><b>%1</b></nobr> download").arg(UI_ExtPackName));
     53        setProgressBarToolTip(tr("Downloading the <nobr><b>%1</b></nobr> from <nobr><b>%2</b>...</nobr>")
     54                                 .arg(UI_ExtPackName, source()));
     55    }
    4056};
     57#endif
    4158
    42 /* UIDownloader reimplementation for the VirtualBox Extension Pack updating: */
     59/**
     60 * The UIDownloaderExtensionPack class is UIDownloader class extension
     61 * which allows background http downloading.
     62 */
    4363class UIDownloaderExtensionPack : public UIDownloader
    4464{
    4565    Q_OBJECT;
    4666
     67signals:
     68
     69    /* Notify listeners about file was downloaded: */
     70    void sigDownloadFinished(const QString &strSource, const QString &strTarget, QString strHash);
     71
    4772public:
    4873
    49     /* Create downloader: */
     74    /* Static stuff: */
    5075    static UIDownloaderExtensionPack* create();
    51     /* Return downloader: */
    5276    static UIDownloaderExtensionPack* current();
    5377
    54     /* Starts downloading: */
     78    /* Starting routine: */
    5579    void start();
    56 
    57 signals:
    58 
    59     /* Notify listeners about extension pack downloaded: */
    60     void sigNotifyAboutExtensionPackDownloaded(const QString &strSource, const QString &strTarget, QString strHash);
    6180
    6281private:
    … …  
    6685    ~UIDownloaderExtensionPack();
    6786
    68     /* Virtual methods reimplementations: */
    69     UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     87    /* Virtual stuff reimplementations: */
    7088    bool askForDownloadingConfirmation(QNetworkReply *pReply);
    7189    void handleDownloadedObject(QNetworkReply *pReply);
    72     void warnAboutNetworkError(const QString &strError);
     90#if 0
     91    UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     92#endif
    7393
    74     /* Variables: */
    75     static UIDownloaderExtensionPack *m_pInstance;
     94    /* Static instance variable: */
     95    static UIDownloaderExtensionPack *m_spInstance;
    7696};
    7797

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderUserManual.cpp

    r39326 r39932  
    77
    88/*
    9  * Copyright (C) 2006-2011 Oracle Corporation
     9 * Copyright (C) 2006-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1919
    2020/* Global includes: */
    21 #include <QAction>
     21#include <QNetworkReply>
    2222#include <QDir>
    2323#include <QFile>
    24 #include <QNetworkReply>
    2524
    2625/* Local includes: */
    2726#include "UIDownloaderUserManual.h"
    2827#include "QIFileDialog.h"
     28#include "VBoxGlobal.h"
    2929#include "UIMessageCenter.h"
    3030
    31 UIDownloaderUserManual *UIDownloaderUserManual::m_pInstance = 0;
     31/* Static stuff: */
     32UIDownloaderUserManual* UIDownloaderUserManual::m_spInstance = 0;
    3233
    33 UIDownloaderUserManual *UIDownloaderUserManual::create()
     34UIDownloaderUserManual* UIDownloaderUserManual::create()
    3435{
    35     if (!m_pInstance)
    36         m_pInstance = new UIDownloaderUserManual;
    37     return m_pInstance;
     36    if (!m_spInstance)
     37        m_spInstance = new UIDownloaderUserManual;
     38    return m_spInstance;
    3839}
    3940
    40 UIDownloaderUserManual *UIDownloaderUserManual::current()
     41UIDownloaderUserManual* UIDownloaderUserManual::current()
    4142{
    42     return m_pInstance;
    43 }
    44 
    45 void UIDownloaderUserManual::setSource(const QString &strSource)
    46 {
    47     /* Erase the list first: */
    48     m_sourcesList.clear();
    49     /* And add there passed value: */
    50     addSource(strSource);
    51 }
    52 
    53 void UIDownloaderUserManual::addSource(const QString &strSource)
    54 {
    55     /* Append passed value: */
    56     m_sourcesList << strSource;
     43    return m_spInstance;
    5744}
    5845
    5946void UIDownloaderUserManual::start()
    6047{
    61     /* Start downloading: */
    62     startDownloading();
     48    /* Call for base-class: */
     49    UIDownloader::start();
     50#if 0
    6351    /* Notify about downloading started: */
    64     emit sigDownloadingStarted(UIDownloadType_UserManual);
     52    notifyDownloaderCreated(UIDownloadType_UserManual);
     53#endif
    6554}
    6655
    6756UIDownloaderUserManual::UIDownloaderUserManual()
    68     : UIDownloader()
    6957{
     58    /* Prepare instance: */
     59    if (!m_spInstance)
     60        m_spInstance = this;
     61
     62    /* Set description: */
     63    setDescription(tr("VirtualBox User Manual"));
     64
     65    /* Compose User Manual filename: */
     66    QString strUserManualFullFileName = vboxGlobal().helpFile();
     67    QString strUserManualShortFileName = QFileInfo(strUserManualFullFileName).fileName();
     68
     69    /* Add sources: */
     70    addSource(QString("http://download.virtualbox.org/virtualbox/%1/").arg(vboxGlobal().vboxVersionStringNormalized()) + strUserManualShortFileName);
     71    addSource(QString("http://download.virtualbox.org/virtualbox/") + strUserManualShortFileName);
     72
     73    /* Set target: */
     74    QString strUserManualDestination = QDir(vboxGlobal().virtualBox().GetHomeFolder()).absoluteFilePath(strUserManualShortFileName);
     75    setTarget(strUserManualDestination);
    7076}
    7177
    7278UIDownloaderUserManual::~UIDownloaderUserManual()
    7379{
    74     if (m_pInstance == this)
    75         m_pInstance = 0;
    76 }
    77 
    78 void UIDownloaderUserManual::startDownloading()
    79 {
    80     /* If at least one source to try left: */
    81     if (!m_sourcesList.isEmpty())
    82     {
    83         /* Set the first of left sources as current one: */
    84         UIDownloader::setSource(m_sourcesList.takeFirst());
    85         /* Warn process-bar(s) about source was changed: */
    86         emit sigSourceChanged(source());
    87         /* Try to download: */
    88         startDelayedAcknowledging();
    89     }
    90 }
    91 
    92 void UIDownloaderUserManual::handleError(QNetworkReply *pReply)
    93 {
    94     /* Check if other sources present: */
    95     if (!m_sourcesList.isEmpty())
    96     {
    97         /* Restart acknowledging: */
    98         startDownloading();
    99     }
    100     else
    101     {
    102         /* Call for base-class: */
    103         UIDownloader::handleError(pReply);
    104     }
    105 }
    106 
    107 UIMiniProgressWidget* UIDownloaderUserManual::createProgressWidgetFor(QWidget *pParent) const
    108 {
    109     return new UIMiniProcessWidgetUserManual(pParent);
     80    /* Cleanup instance: */
     81    if (m_spInstance == this)
     82        m_spInstance = 0;
    11083}
    11184
    11285bool UIDownloaderUserManual::askForDownloadingConfirmation(QNetworkReply *pReply)
    11386{
    114     return msgCenter().confirmUserManualDownload(source(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
     87    return msgCenter().confirmUserManualDownload(source().toString(), pReply->header(QNetworkRequest::ContentLengthHeader).toInt());
    11588}
    11689
    … …  
    129102            file.write(receivedData);
    130103            file.close();
     104
    131105            /* Warn user about User Manual document loaded and saved: */
    132             msgCenter().warnAboutUserManualDownloaded(source(), QDir::toNativeSeparators(target()));
     106            msgCenter().warnAboutUserManualDownloaded(source().toString(), QDir::toNativeSeparators(target()));
    133107            /* Warn listener about User Manual was downloaded: */
    134108            emit sigDownloadFinished(target());
    135109            break;
    136110        }
    137         else
    138         {
    139             /* Warn user about User Manual document loaded but was not saved: */
    140             msgCenter().warnAboutUserManualCantBeSaved(source(), QDir::toNativeSeparators(target()));
    141         }
    142111
    143         /* Ask the user about User Manual file save location: */
    144         QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(), parentWidget(),
     112        /* Warn user about User Manual document was downloaded but was NOT saved: */
     113        msgCenter().warnAboutUserManualCantBeSaved(source().toString(), QDir::toNativeSeparators(target()));
     114
     115        /* Ask the user for another location for User Manual file: */
     116        QString strTarget = QIFileDialog::getExistingDirectory(QFileInfo(target()).absolutePath(),
     117                                                               msgCenter().networkManagerOrMainWindowShown(),
    145118                                                               tr("Select folder to save User Manual to"), true);
    146119
    147         /* Check if user set new target: */
     120        /* Check if user had really set a new target: */
    148121        if (!strTarget.isNull())
    149122            setTarget(QDir(strTarget).absoluteFilePath(QFileInfo(target()).fileName()));
    … …  
    153126}
    154127
    155 void UIDownloaderUserManual::warnAboutNetworkError(const QString &strError)
     128#if 0
     129UIMiniProgressWidget* UIDownloaderUserManual::createProgressWidgetFor(QWidget *pParent) const
    156130{
    157     return msgCenter().warnAboutUserManualCantBeDownloaded(source(), strError);
     131    return new UIMiniProcessWidgetUserManual(pParent);
    158132}
     133#endif
    159134

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIDownloaderUserManual.h

    r39326 r39932  
    66
    77/*
    8  * Copyright (C) 2010-2011 Oracle Corporation
     8 * Copyright (C) 2010-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2121
    2222/* Local includes: */
    23 #include "QIWithRetranslateUI.h"
    2423#include "UIDownloader.h"
    2524
     25#if 0
     26/* Local includes: */
     27# include "QIWithRetranslateUI.h"
     28
     29/**
     30 * The UIMiniProcessWidgetUserManual class is UIMiniProgressWidget class re-implementation
     31 * which embeds into the dialog's status-bar and reflects background http downloading.
     32 */
    2633class UIMiniProcessWidgetUserManual : public QIWithRetranslateUI<UIMiniProgressWidget>
    2734{
    … …  
    3037public:
    3138
     39    /* Constructor: */
    3240    UIMiniProcessWidgetUserManual(QWidget *pParent = 0)
    3341        : QIWithRetranslateUI<UIMiniProgressWidget>(pParent)
    … …  
    3846private slots:
    3947
     48    /* Source change stuff: */
    4049    void sltSetSource(const QString &strSource)
    4150    {
    … …  
    4655private:
    4756
     57    /* Translating stuff: */
    4858    void retranslateUi()
    4959    {
    … …  
    5464    }
    5565};
     66#endif
    5667
     68/**
     69 * The UIDownloaderUserManual class is UIDownloader class extension
     70 * which allows background http downloading.
     71 */
    5772class UIDownloaderUserManual : public UIDownloader
    5873{
    5974    Q_OBJECT;
    6075
     76signals:
     77
     78    /* Notifies listeners about file was downloaded: */
     79    void sigDownloadFinished(const QString &strFile);
     80
    6181public:
    6282
     83    /* Static stuff: */
    6384    static UIDownloaderUserManual* create();
    6485    static UIDownloaderUserManual* current();
    6586
    66     void setSource(const QString &strSource);
    67     void addSource(const QString &strSource);
    68 
     87    /* Starting routine: */
    6988    void start();
    70 
    71 signals:
    72 
    73     void sigSourceChanged(const QString &strSource);
    74     void sigDownloadFinished(const QString &strFile);
    7589
    7690private:
    7791
     92    /* Constructor/destructor: */
    7893    UIDownloaderUserManual();
    7994    ~UIDownloaderUserManual();
    8095
    81     void startDownloading();
    82 
    83     void handleError(QNetworkReply *pReply);
    84 
    85     UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     96    /* Virtual stuff reimplementations: */
    8697    bool askForDownloadingConfirmation(QNetworkReply *pReply);
    8798    void handleDownloadedObject(QNetworkReply *pReply);
    88     void warnAboutNetworkError(const QString &strError);
     99#if 0
     100    UIMiniProgressWidget* createProgressWidgetFor(QWidget *pParent) const;
     101#endif
    89102
    90     /* Private member variables: */
    91     static UIDownloaderUserManual *m_pInstance;
    92 
    93     /* List of sources to try to download from: */
    94     QList<QString> m_sourcesList;
     103    /* Static instance variable: */
     104    static UIDownloaderUserManual *m_spInstance;
    95105};
    96106

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkDefs.h

    r39326 r39932  
    2020#define __UINetworkDefs_h__
    2121
     22/* Network request types: */
     23enum UINetworkRequestType
     24{
     25    UINetworkRequestType_HEAD,
     26    UINetworkRequestType_GET
     27};
     28
     29#if 0
    2230/* Download types: */
    2331enum UIDownloadType
    … …  
    2836    UIDownloadType_Max
    2937};
     38#endif
    3039
    3140#endif // __UINetworkDefs_h__

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkManager.cpp

    r38421 r39932  
    33 *
    44 * VBox frontends: Qt GUI ("VirtualBox"):
    5  * UINetworkManager class implementation
     5 * UINetworkManager stuff implementation
    66 */
    77
    88/*
    9  * Copyright (C) 2011 Oracle Corporation
     9 * Copyright (C) 2011-2012 Oracle Corporation
    1010 *
    1111 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    1818 */
    1919
     20/* Global includes: */
     21#include <QWidget>
     22#include <QTimer>
     23#include <QGridLayout>
     24#include <QProgressBar>
     25#include <QTextEdit>
     26#include <QMainWindow>
     27#include <QVBoxLayout>
     28#include <QLabel>
     29#include <QPushButton>
     30#include <QStatusBar>
     31#include <QKeyEvent>
     32#include <QNetworkReply>
     33
    2034/* Local includes: */
    2135#include "UINetworkManager.h"
    22 
    23 /* static */
     36#include "UINetworkCustomer.h"
     37#include "QIWithRetranslateUI.h"
     38#include "VBoxGlobal.h"
     39#include "UIMessageCenter.h"
     40#include "UIIconPool.h"
     41#include "QIDialogButtonBox.h"
     42#include "UIPopupBox.h"
     43#include "QIToolButton.h"
     44
     45/* Network-request widget: */
     46class UINetworkRequestWidget : public QIWithRetranslateUI<UIPopupBox>
     47{
     48    Q_OBJECT;
     49
     50signals:
     51
     52    /* Signal to retry network-request: */
     53    void sigRetry();
     54    /* Signal to cancel network-request: */
     55    void sigCancel();
     56
     57public:
     58
     59    /* Constructor: */
     60    UINetworkRequestWidget(QWidget *pParent, UINetworkRequest *pNetworkRequest)
     61        : QIWithRetranslateUI<UIPopupBox>(pParent)
     62        , m_pNetworkRequest(pNetworkRequest)
     63        , m_pTimer(new QTimer(this))
     64        , m_pContentWidget(new QWidget(this))
     65        , m_pMainLayout(new QGridLayout(m_pContentWidget))
     66        , m_pProgressBar(new QProgressBar(m_pContentWidget))
     67        , m_pRetryButton(new QIToolButton(m_pContentWidget))
     68        , m_pCancelButton(new QIToolButton(m_pContentWidget))
     69        , m_pErrorPane(new QTextEdit(m_pContentWidget))
     70    {
     71        /* Setup self: */
     72        setTitleIcon(UIIconPool::iconSet(":/nw_16px.png"));
     73        setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     74        setContentWidget(m_pContentWidget);
     75        setOpen(true);
     76
     77        /* Prepare listeners for m_pNetworkRequest: */
     78        connect(m_pNetworkRequest, SIGNAL(sigProgress(qint64, qint64)), this, SLOT(sltSetProgress(qint64, qint64)));
     79        connect(m_pNetworkRequest, SIGNAL(sigStarted()), this, SLOT(sltSetProgressToStarted()));
     80        connect(m_pNetworkRequest, SIGNAL(sigFinished()), this, SLOT(sltSetProgressToFinished()));
     81        connect(m_pNetworkRequest, SIGNAL(sigFailed(const QString&)), this, SLOT(sltSetProgressToFailed(const QString&)));
     82
     83        /* Setup timer: */
     84        m_pTimer->setInterval(5000);
     85        connect(m_pTimer, SIGNAL(timeout()), this, SLOT(sltTimeIsOut()));
     86
     87        /* Setup progress-bar: */
     88        m_pProgressBar->setRange(0, 0);
     89        m_pProgressBar->setMaximumHeight(16);
     90
     91        /* Setup retry-button: */
     92        m_pRetryButton->setHidden(true);
     93        m_pRetryButton->removeBorder();
     94        m_pRetryButton->setFocusPolicy(Qt::NoFocus);
     95        m_pRetryButton->setIcon(UIIconPool::iconSet(":/refresh_16px.png"));
     96        connect(m_pRetryButton, SIGNAL(clicked(bool)), this, SIGNAL(sigRetry()));
     97
     98        /* Setup cancel-button: */
     99        m_pCancelButton->removeBorder();
     100        m_pCancelButton->setFocusPolicy(Qt::NoFocus);
     101        m_pCancelButton->setIcon(UIIconPool::iconSet(":/delete_16px.png"));
     102        connect(m_pCancelButton, SIGNAL(clicked(bool)), this, SIGNAL(sigCancel()));
     103
     104        /* Setup error-label: */
     105        m_pErrorPane->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Ignored);
     106        m_pErrorPane->viewport()->setAutoFillBackground(false);
     107        m_pErrorPane->setFrameShape(QFrame::NoFrame);
     108        m_pErrorPane->setReadOnly(true);
     109
     110        /* Layout content: */
     111        m_pMainLayout->addWidget(m_pProgressBar, 0, 0);
     112        m_pMainLayout->addWidget(m_pRetryButton, 0, 1);
     113        m_pMainLayout->addWidget(m_pCancelButton, 0, 2);
     114        m_pMainLayout->addWidget(m_pErrorPane, 1, 0, 1, 3);
     115
     116        /* Retranslate UI: */
     117        retranslateUi();
     118    }
     119
     120private slots:
     121
     122    /* Retranslate UI: */
     123    void retranslateUi()
     124    {
     125        /* Get corresponding title: */
     126        const QString &strTitle = m_pNetworkRequest->description();
     127
     128        /* Set popup title (default if missed): */
     129        setTitle(strTitle.isEmpty() ? UINetworkManager::tr("Network Request") : strTitle);
     130
     131        /* Translate retry button: */
     132        m_pRetryButton->setStatusTip(UINetworkManager::tr("Repeat network request..."));
     133
     134        /* Translate cancel button: */
     135        m_pCancelButton->setStatusTip(UINetworkManager::tr("Cancel network request..."));
     136    }
     137
     138    /* Updates current network-request progess: */
     139    void sltSetProgress(qint64 iReceived, qint64 iTotal)
     140    {
     141        /* Restart timer: */
     142        m_pTimer->start();
     143
     144        /* Set current progress to passed: */
     145        m_pProgressBar->setRange(0, iTotal);
     146        m_pProgressBar->setValue(iReceived);
     147    }
     148
     149    /* Set current network-request progress to 'started': */
     150    void sltSetProgressToStarted()
     151    {
     152        /* Start timer: */
     153        m_pTimer->start();
     154
     155        /* Set current progress to 'started': */
     156        m_pProgressBar->setRange(0, 1);
     157        m_pProgressBar->setValue(0);
     158
     159        /* Hide 'retry' button: */
     160        m_pRetryButton->setHidden(true);
     161
     162        /* Hide error label: */
     163        m_pErrorPane->setPlainText(QString());
     164        m_pErrorPane->setMinimumHeight(0);
     165    }
     166
     167    /* Set current network-request progress to 'finished': */
     168    void sltSetProgressToFinished()
     169    {
     170        /* Stop timer: */
     171        m_pTimer->stop();
     172
     173        /* Set current progress to 'started': */
     174        m_pProgressBar->setRange(0, 1);
     175        m_pProgressBar->setValue(1);
     176    }
     177
     178    /* Set current network-request progress to 'failed': */
     179    void sltSetProgressToFailed(const QString &strError)
     180    {
     181        /* Stop timer: */
     182        m_pTimer->stop();
     183
     184        /* Set current progress to 'failed': */
     185        m_pProgressBar->setRange(0, 1);
     186        m_pProgressBar->setValue(1);
     187
     188        /* Show 'retry' button: */
     189        m_pRetryButton->setHidden(false);
     190
     191        /* Show error label: */
     192        m_pErrorPane->setPlainText(UINetworkManager::tr("Error: %1.").arg(strError));
     193        m_pErrorPane->setMinimumHeight(m_pErrorPane->document()->size().toSize().height());
     194    }
     195
     196    /* Handle frozen progress: */
     197    void sltTimeIsOut()
     198    {
     199        /* Stop timer: */
     200        m_pTimer->stop();
     201
     202        /* Set current progress to unknown: */
     203        m_pProgressBar->setRange(0, 0);
     204    }
     205
     206private:
     207
     208    /* Objects: */
     209    UINetworkRequest *m_pNetworkRequest;
     210    QTimer *m_pTimer;
     211
     212    /* Widgets: */
     213    QWidget *m_pContentWidget;
     214    QGridLayout *m_pMainLayout;
     215    QProgressBar *m_pProgressBar;
     216    QIToolButton *m_pRetryButton;
     217    QIToolButton *m_pCancelButton;
     218    QTextEdit *m_pErrorPane;
     219};
     220
     221/* Network requests dialog: */
     222class UINetworkManagerDialog : public QIWithRetranslateUI<QMainWindow>
     223{
     224    Q_OBJECT;
     225
     226signals:
     227
     228    /* Signal to cancel all network-requests: */
     229    void sigCancelNetworkRequests();
     230
     231public slots:
     232
     233    /* Show the dialog, make sure its visible: */
     234    void showNormal()
     235    {
     236        /* Show (restore if neessary): */
     237        QMainWindow::showNormal();
     238
     239        /* Raise above the others: */
     240        raise();
     241
     242        /* Activate: */
     243        activateWindow();
     244    }
     245
     246public:
     247
     248    /* Constructor: */
     249    UINetworkManagerDialog(QWidget *pParent = 0)
     250        : QIWithRetranslateUI<QMainWindow>(pParent)
     251    {
     252        /* Do not count that window as important for application,
     253         * it will NOT be taken into account when other top-level windows will be closed: */
     254        setAttribute(Qt::WA_QuitOnClose, false);
     255
     256        /* Set minimum width: */
     257        setMinimumWidth(500);
     258
     259        /* Prepare central-widget: */
     260        setCentralWidget(new QWidget);
     261
     262        /* Create main-layout: */
     263        m_pMainLayout = new QVBoxLayout(centralWidget());
     264        m_pMainLayout->setMargin(6);
     265
     266        /* Create description-label: */
     267        m_pLabel = new QLabel(centralWidget());
     268        m_pLabel->setAlignment(Qt::AlignCenter);
     269        m_pLabel->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
     270
     271        /* Create button-box: */
     272        m_pButtonBox = new QIDialogButtonBox(QDialogButtonBox::Cancel, Qt::Horizontal, centralWidget());
     273        connect(m_pButtonBox, SIGNAL(rejected()), this, SLOT(sltHandleCancelAllButtonPress()));
     274        m_pButtonBox->setHidden(true);
     275
     276        /* Layout content: */
     277        m_pMainLayout->addWidget(m_pLabel);
     278        m_pMainLayout->addStretch();
     279        m_pMainLayout->addWidget(m_pButtonBox);
     280
     281        /* Create status-bar: */
     282        setStatusBar(new QStatusBar);
     283
     284        /* Translate dialog: */
     285        retranslateUi();
     286    }
     287
     288    /* Add network-request widget: */
     289    UINetworkRequestWidget* addNetworkRequestWidget(UINetworkRequest *pNetworkRequest)
     290    {
     291        /* Make sure network-request is really exists: */
     292        AssertMsg(pNetworkRequest, ("Network-request doesn't exists!\n"));
     293
     294        /* Create new network-request widget: */
     295        UINetworkRequestWidget *pNetworkRequestWidget = new UINetworkRequestWidget(this, pNetworkRequest);
     296        m_pMainLayout->insertWidget(m_pMainLayout->count() - 2 /* before button-box and stretch */, pNetworkRequestWidget);
     297        m_widgets.insert(pNetworkRequest->uuid(), pNetworkRequestWidget);
     298
     299        /* Hide label: */
     300        m_pLabel->setHidden(true);
     301        /* Show button-box: */
     302        m_pButtonBox->setHidden(false);
     303        /* Show dialog: */
     304        showNormal();
     305
     306        /* Return network-request widget: */
     307        return pNetworkRequestWidget;
     308    }
     309
     310    /* Remove network-request widget: */
     311    void removeNetworkRequestWidget(const QUuid &uuid)
     312    {
     313        /* Make sure network-request widget still present: */
     314        AssertMsg(m_widgets.contains(uuid), ("Network-request widget already removed!\n"));
     315
     316        /* Delete corresponding network-request widget: */
     317        delete m_widgets.value(uuid);
     318        m_widgets.remove(uuid);
     319
     320        /* Check if dialog is empty: */
     321        if (m_widgets.isEmpty())
     322        {
     323            /* Show label: */
     324            m_pLabel->setHidden(false);
     325            /* Hide button-box: */
     326            m_pButtonBox->setHidden(true);
     327            /* Hide dialog: */
     328            hide();
     329        }
     330    }
     331
     332private slots:
     333
     334    /* Handler for 'Cancel All' button press: */
     335    void sltHandleCancelAllButtonPress()
     336    {
     337        /* Ask if user wants to cancel all current network-requests: */
     338        if (msgCenter().askAboutCancelAllNetworkRequest(this))
     339            emit sigCancelNetworkRequests();
     340    }
     341
     342private:
     343
     344    /* Translate whole dialog: */
     345    void retranslateUi()
     346    {
     347        /* Set window caption: */
     348        setWindowTitle(UINetworkManager::tr("Network Access Manager"));
     349
     350        /* Set description-label text: */
     351        m_pLabel->setText(UINetworkManager::tr("There are no network activities currently..."));
     352
     353        /* Set buttons-box text: */
     354        m_pButtonBox->button(QDialogButtonBox::Cancel)->setText(UINetworkManager::tr("&Cancel All"));
     355        m_pButtonBox->button(QDialogButtonBox::Cancel)->setStatusTip(UINetworkManager::tr("Cancel all current network requests..."));
     356    }
     357
     358    /* Overloaded show-event: */
     359    void showEvent(QShowEvent *pShowEvent)
     360    {
     361        /* Resize to minimum size: */
     362        resize(minimumSize());
     363
     364        /* Center according current main application window: */
     365        vboxGlobal().centerWidget(this, vboxGlobal().mainWindow(), false);
     366
     367        /* Pass event to the base-class: */
     368        QMainWindow::showEvent(pShowEvent);
     369    }
     370
     371    /* Overloaded close-event: */
     372    void closeEvent(QCloseEvent *pCloseEvent)
     373    {
     374        /* If there are network-requests present
     375         * ask if user wants to cancel all current network-requests
     376         * or leave them working at the background: */
     377        if (!m_widgets.isEmpty() &&
     378            msgCenter().askAboutCancelOrLeaveAllNetworkRequest(this))
     379            emit sigCancelNetworkRequests();
     380
     381        /* Pass event to the base-class: */
     382        QMainWindow::closeEvent(pCloseEvent);
     383    }
     384
     385    /* Overloaded keypress-event: */
     386    void keyPressEvent(QKeyEvent *pKeyPressEvent)
     387    {
     388        /* 'Escape' key used to close the dialog: */
     389        if (pKeyPressEvent->key() == Qt::Key_Escape)
     390        {
     391            close();
     392            return;
     393        }
     394
     395        /* Pass event to the base-class: */
     396        QMainWindow::keyPressEvent(pKeyPressEvent);
     397    }
     398
     399    /* Main layout: */
     400    QVBoxLayout *m_pMainLayout;
     401    QLabel *m_pLabel;
     402    QIDialogButtonBox *m_pButtonBox;
     403
     404    /* Popup-widget map: */
     405    QMap<QUuid, UINetworkRequestWidget*> m_widgets;
     406};
     407
     408/* Constructor: */
     409UINetworkRequest::UINetworkRequest(UINetworkManager *pNetworkManager,
     410                                   UINetworkManagerDialog *pNetworkManagerDialog,
     411                                   const QNetworkRequest &request, UINetworkRequestType type,
     412                                   const QString &strDescription, UINetworkCustomer *pCustomer)
     413    : QObject(pNetworkManager)
     414    , m_pNetworkManagerDialog(pNetworkManagerDialog)
     415    , m_pNetworkRequestWidget(0)
     416    , m_uuid(QUuid::createUuid())
     417    , m_requests(QList<QNetworkRequest>() << request)
     418    , m_iCurrentRequestIndex(0)
     419    , m_type(type)
     420    , m_strDescription(strDescription)
     421    , m_pCustomer(pCustomer)
     422{
     423    /* Initialize: */
     424    initialize();
     425}
     426
     427UINetworkRequest::UINetworkRequest(UINetworkManager *pNetworkManager,
     428                                   UINetworkManagerDialog *pNetworkManagerDialog,
     429                                   const QList<QNetworkRequest> &requests, UINetworkRequestType type,
     430                                   const QString &strDescription, UINetworkCustomer *pCustomer)
     431    : QObject(pNetworkManager)
     432    , m_pNetworkManagerDialog(pNetworkManagerDialog)
     433    , m_pNetworkRequestWidget(0)
     434    , m_uuid(QUuid::createUuid())
     435    , m_requests(requests)
     436    , m_iCurrentRequestIndex(0)
     437    , m_type(type)
     438    , m_strDescription(strDescription)
     439    , m_pCustomer(pCustomer)
     440{
     441    /* Initialize: */
     442    initialize();
     443}
     444
     445/* Destructor: */
     446UINetworkRequest::~UINetworkRequest()
     447{
     448    /* Destroy network-reply: */
     449    cleanupNetworkReply();
     450
     451    /* Destroy network-request widget: */
     452    m_pNetworkManagerDialog->removeNetworkRequestWidget(m_uuid);
     453}
     454
     455/* Network-reply progress handler: */
     456void UINetworkRequest::sltHandleNetworkReplyProgress(qint64 iReceived, qint64 iTotal)
     457{
     458    /* Notify UINetworkManager: */
     459    emit sigProgress(m_uuid, iReceived, iTotal);
     460    /* Notify UINetworkRequestWidget: */
     461    emit sigProgress(iReceived, iTotal);
     462}
     463
     464/* Network-reply finish handler: */
     465void UINetworkRequest::sltHandleNetworkReplyFinish()
     466{
     467    /* Get sender network reply: */
     468    QNetworkReply *pNetworkReply = static_cast<QNetworkReply*>(sender());
     469
     470    /* If network-request was canceled: */
     471    if (pNetworkReply->error() == QNetworkReply::OperationCanceledError)
     472    {
     473        /* Notify UINetworkManager: */
     474        emit sigCanceled(m_uuid);
     475    }
     476    /* If network-reply has no errors: */
     477    else if (pNetworkReply->error() == QNetworkReply::NoError)
     478    {
     479        /* Check if redirection required: */
     480        QUrl redirect = pNetworkReply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
     481        if (redirect.isValid())
     482        {
     483            /* Cleanup current network-reply first: */
     484            cleanupNetworkReply();
     485
     486            /* Choose redirect-source as current: */
     487            m_request.setUrl(redirect);
     488
     489            /* Create new network-reply finally: */
     490            prepareNetworkReply();
     491        }
     492        else
     493        {
     494            /* Notify UINetworkRequestWidget: */
     495            emit sigFinished();
     496            /* Notify UINetworkManager: */
     497            emit sigFinished(m_uuid);
     498        }
     499    }
     500    /* If some error occured: */
     501    else
     502    {
     503        /* Check if we have other requests in set: */
     504        if (m_iCurrentRequestIndex < m_requests.size() - 1)
     505        {
     506            /* Cleanup current network-reply first: */
     507            cleanupNetworkReply();
     508
     509            /* Choose next network-request as current: */
     510            ++m_iCurrentRequestIndex;
     511            m_request = m_requests[m_iCurrentRequestIndex];
     512
     513            /* Create new network-reply finally: */
     514            prepareNetworkReply();
     515        }
     516        else
     517        {
     518            /* Notify UINetworkRequestWidget: */
     519            emit sigFailed(pNetworkReply->errorString());
     520            /* Notify UINetworkManager: */
     521            emit sigFailed(m_uuid, pNetworkReply->errorString());
     522        }
     523    }
     524}
     525
     526/* Slot to retry network-request: */
     527void UINetworkRequest::sltRetry()
     528{
     529    /* Cleanup current network-reply first: */
     530    cleanupNetworkReply();
     531
     532    /* Choose first network-request as current: */
     533    m_iCurrentRequestIndex = 0;
     534    m_request = m_requests[m_iCurrentRequestIndex];
     535
     536    /* Create new network-reply finally: */
     537    prepareNetworkReply();
     538}
     539
     540/* Slot to cancel network-request: */
     541void UINetworkRequest::sltCancel()
     542{
     543    /* Abort network-reply if present: */
     544    abortNetworkReply();
     545}
     546
     547/* Initialize: */
     548void UINetworkRequest::initialize()
     549{
     550    /* Prepare listeners for parent(): */
     551    connect(parent(), SIGNAL(sigCancelNetworkRequests()), this, SLOT(sltCancel()));
     552
     553    /* Create network-request widget: */
     554    m_pNetworkRequestWidget = m_pNetworkManagerDialog->addNetworkRequestWidget(this);
     555
     556    /* Prepare listeners for m_pNetworkRequestWidget: */
     557    connect(m_pNetworkRequestWidget, SIGNAL(sigRetry()), this, SLOT(sltRetry()));
     558    connect(m_pNetworkRequestWidget, SIGNAL(sigCancel()), this, SLOT(sltCancel()));
     559
     560    /* Choose first network-request as current: */
     561    m_iCurrentRequestIndex = 0;
     562    m_request = m_requests[m_iCurrentRequestIndex];
     563
     564    /* Create network-reply: */
     565    prepareNetworkReply();
     566}
     567
     568/* Prepare network-reply: */
     569void UINetworkRequest::prepareNetworkReply()
     570{
     571    /* Make network-request: */
     572    switch (m_type)
     573    {
     574        case UINetworkRequestType_HEAD:
     575        {
     576            m_pReply = gNetworkManager->head(m_request);
     577            break;
     578        }
     579        case UINetworkRequestType_GET:
     580        {
     581            m_pReply = gNetworkManager->get(m_request);
     582            break;
     583        }
     584        default:
     585            break;
     586    }
     587
     588    /* Prepare listeners for m_pReply: */
     589    AssertMsg(m_pReply, ("Unable to make network-request!\n"));
     590    connect(m_pReply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(sltHandleNetworkReplyProgress(qint64, qint64)));
     591    connect(m_pReply, SIGNAL(finished()), this, SLOT(sltHandleNetworkReplyFinish()));
     592
     593    /* Notify UINetworkRequestWidget: */
     594    emit sigStarted();
     595}
     596
     597/* Cleanup network-reply: */
     598void UINetworkRequest::cleanupNetworkReply()
     599{
     600    /* Destroy current reply: */
     601    AssertMsg(m_pReply, ("Network-reply already destroyed!\n"));
     602    m_pReply->disconnect();
     603    m_pReply->deleteLater();
     604    m_pReply = 0;
     605}
     606
     607/* Abort network-reply: */
     608void UINetworkRequest::abortNetworkReply()
     609{
     610    /* Abort network-reply if present: */
     611    if (m_pReply)
     612    {
     613        if (m_pReply->isRunning())
     614            m_pReply->abort();
     615        else if (m_pReply->isFinished())
     616            emit sigCanceled(m_uuid);
     617    }
     618}
     619
     620/* Instance: */
    24621UINetworkManager* UINetworkManager::m_pInstance = 0;
    25622
    26 /* static */
     623/* Create singleton: */
    27624void UINetworkManager::create()
    28625{
    … …  
    35632}
    36633
    37 /* static */
     634/* Destroy singleton: */
    38635void UINetworkManager::destroy()
    39636{
    … …  
    46643}
    47644
     645/* Network Access Manager GUI window: */
     646QWidget* UINetworkManager::window() const
     647{
     648    return m_pNetworkProgressDialog;
     649}
     650
     651/* Show Network Access Manager GUI: */
     652void UINetworkManager::show()
     653{
     654    /* Just show the dialog: */
     655    m_pNetworkProgressDialog->showNormal();
     656}
     657
     658/* Network-request creation wrapper for UINetworkCustomer: */
     659void UINetworkManager::createNetworkRequest(const QNetworkRequest &request, UINetworkRequestType type,
     660                                            const QString &strDescription, UINetworkCustomer *pCustomer)
     661{
     662    /* Create new network-request: */
     663    UINetworkRequest *pNetworkRequest = new UINetworkRequest(this, m_pNetworkProgressDialog,
     664                                                             request, type, strDescription, pCustomer);
     665    /* Prepare created network-request: */
     666    prepareNetworkRequest(pNetworkRequest);
     667}
     668
     669/* Network request (set) creation wrapper for UINetworkCustomer: */
     670void UINetworkManager::createNetworkRequest(const QList<QNetworkRequest> &requests, UINetworkRequestType type,
     671                                            const QString &strDescription, UINetworkCustomer *pCustomer)
     672{
     673    /* Create new network-request: */
     674    UINetworkRequest *pNetworkRequest = new UINetworkRequest(this, m_pNetworkProgressDialog,
     675                                                             requests, type, strDescription, pCustomer);
     676    /* Prepare created network-request: */
     677    prepareNetworkRequest(pNetworkRequest);
     678}
     679
    48680/* Constructor: */
    49681UINetworkManager::UINetworkManager()
    … …  
    69701void UINetworkManager::prepare()
    70702{
     703    /* Prepare network manager GUI: */
     704    m_pNetworkProgressDialog = new UINetworkManagerDialog;
     705
     706    /* Prepare listeners for m_pNetworkProgressDialog: */
     707    connect(m_pNetworkProgressDialog, SIGNAL(sigCancelNetworkRequests()), this, SIGNAL(sigCancelNetworkRequests()));
    71708}
    72709
    … …  
    74711void UINetworkManager::cleanup()
    75712{
    76 }
    77 
     713    /* Cleanup network-requests first: */
     714    cleanupNetworkRequests();
     715
     716    /* Cleanup network manager GUI: */
     717    delete m_pNetworkProgressDialog;
     718}
     719
     720/* Prepare network-request: */
     721void UINetworkManager::prepareNetworkRequest(UINetworkRequest *pNetworkRequest)
     722{
     723    /* Prepare listeners for pNetworkRequest: */
     724    connect(pNetworkRequest, SIGNAL(sigProgress(const QUuid&, qint64, qint64)), this, SLOT(sltHandleNetworkRequestProgress(const QUuid&, qint64, qint64)));
     725    connect(pNetworkRequest, SIGNAL(sigCanceled(const QUuid&)), this, SLOT(sltHandleNetworkRequestCancel(const QUuid&)));
     726    connect(pNetworkRequest, SIGNAL(sigFinished(const QUuid&)), this, SLOT(sltHandleNetworkRequestFinish(const QUuid&)));
     727    connect(pNetworkRequest, SIGNAL(sigFailed(const QUuid&, const QString&)), this, SLOT(sltHandleNetworkRequestFailure(const QUuid&, const QString&)));
     728
     729    /* Add this request into internal map: */
     730    m_requests.insert(pNetworkRequest->uuid(), pNetworkRequest);
     731}
     732
     733/* Cleanup network-request: */
     734void UINetworkManager::cleanupNetworkRequest(const QUuid &uuid)
     735{
     736    /* Cleanup network-request map: */
     737    delete m_requests[uuid];
     738    m_requests.remove(uuid);
     739}
     740
     741/* Cleanup all network-requests: */
     742void UINetworkManager::cleanupNetworkRequests()
     743{
     744    /* Get all the request IDs: */
     745    const QList<QUuid> &uuids = m_requests.keys();
     746    /* Cleanup corresponding requests: */
     747    for (int i = 0; i < uuids.size(); ++i)
     748        cleanupNetworkRequest(uuids[i]);
     749}
     750
     751#if 0
     752/* Downloader creation notificator: */
     753void UINetworkManager::notifyDownloaderCreated(UIDownloadType downloaderType)
     754{
     755    emit sigDownloaderCreated(downloaderType);
     756}
     757#endif
     758
     759/* Slot to handle network-request progress: */
     760void UINetworkManager::sltHandleNetworkRequestProgress(const QUuid &uuid, qint64 iReceived, qint64 iTotal)
     761{
     762    /* Make sure corresponding map contains received ID: */
     763    AssertMsg(m_requests.contains(uuid), ("Network-request NOT found!\n"));
     764
     765    /* Get corresponding network-request: */
     766    UINetworkRequest *pNetworkRequest = m_requests.value(uuid);
     767
     768    /* Get corresponding customer: */
     769    UINetworkCustomer *pNetworkCustomer = pNetworkRequest->customer();
     770
     771    /* Send to customer to process: */
     772    pNetworkCustomer->processNetworkReplyProgress(iReceived, iTotal);
     773}
     774
     775/* Slot to handle network-request cancel: */
     776void UINetworkManager::sltHandleNetworkRequestCancel(const QUuid &uuid)
     777{
     778    /* Make sure corresponding map contains received ID: */
     779    AssertMsg(m_requests.contains(uuid), ("Network-request NOT found!\n"));
     780
     781    /* Get corresponding network-request: */
     782    UINetworkRequest *pNetworkRequest = m_requests.value(uuid);
     783
     784    /* Get corresponding customer: */
     785    UINetworkCustomer *pNetworkCustomer = pNetworkRequest->customer();
     786
     787    /* Send to customer to process: */
     788    pNetworkCustomer->processNetworkReplyCanceled(pNetworkRequest->reply());
     789
     790    /* Cleanup network-request: */
     791    cleanupNetworkRequest(uuid);
     792}
     793
     794/* Slot to handle network-request finish: */
     795void UINetworkManager::sltHandleNetworkRequestFinish(const QUuid &uuid)
     796{
     797    /* Make sure corresponding map contains received ID: */
     798    AssertMsg(m_requests.contains(uuid), ("Network-request NOT found!\n"));
     799
     800    /* Get corresponding network-request: */
     801    UINetworkRequest *pNetworkRequest = m_requests.value(uuid);
     802
     803    /* Get corresponding customer: */
     804    UINetworkCustomer *pNetworkCustomer = pNetworkRequest->customer();
     805
     806    /* Send to customer to process: */
     807    pNetworkCustomer->processNetworkReplyFinished(pNetworkRequest->reply());
     808
     809    /* Cleanup network-request: */
     810    cleanupNetworkRequest(uuid);
     811}
     812
     813/* Slot to handle network-request failure: */
     814void UINetworkManager::sltHandleNetworkRequestFailure(const QUuid &uuid, const QString &strError)
     815{
     816    /* Just show the dialog: */
     817    show();
     818    Q_UNUSED(uuid);
     819    Q_UNUSED(strError);
     820}
     821
     822#include "UINetworkManager.moc"
     823

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UINetworkManager.h

    r39326 r39932  
    22 *
    33 * VBox frontends: Qt GUI ("VirtualBox"):
    4  * UINetworkManager class declaration
     4 * UINetworkManager stuff declaration
    55 */
    66
    77/*
    8  * Copyright (C) 2011 Oracle Corporation
     8 * Copyright (C) 2011-2012 Oracle Corporation
    99 *
    1010 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2222/* Global includes: */
    2323#include <QNetworkAccessManager>
     24#include <QUuid>
     25#include <QMap>
     26#include <QNetworkRequest>
     27#include <QNetworkReply>
     28#include <QPointer>
    2429
    2530/* Local inludes: */
    2631#include "UINetworkDefs.h"
     32
     33/* Forward declarations: */
     34class UINetworkManager;
     35class UINetworkCustomer;
     36class UINetworkRequestWidget;
     37class UINetworkManagerDialog;
     38
     39/* Network request contianer: */
     40class UINetworkRequest : public QObject
     41{
     42    Q_OBJECT;
     43
     44signals:
     45
     46    /* Notifications to UINetworkManager: */
     47    void sigProgress(const QUuid &uuid, qint64 iReceived, qint64 iTotal);
     48    void sigCanceled(const QUuid &uuid);
     49    void sigFinished(const QUuid &uuid);
     50    void sigFailed(const QUuid &uuid, const QString &strError);
     51
     52    /* Notifications to UINetworkRequestWidget: */
     53    void sigProgress(qint64 iReceived, qint64 iTotal);
     54    void sigStarted();
     55    void sigFinished();
     56    void sigFailed(const QString &strError);
     57
     58public:
     59
     60    /* Constructor/destructor: */
     61    UINetworkRequest(UINetworkManager *pNetworkManager,
     62                     UINetworkManagerDialog *pNetworkManagerDialog,
     63                     const QNetworkRequest &request, UINetworkRequestType type,
     64                     const QString &strDescription, UINetworkCustomer *pCustomer);
     65    UINetworkRequest(UINetworkManager *pNetworkManager,
     66                     UINetworkManagerDialog *pNetworkManagerDialog,
     67                     const QList<QNetworkRequest> &requests, UINetworkRequestType type,
     68                     const QString &strDescription, UINetworkCustomer *pCustomer);
     69    ~UINetworkRequest();
     70
     71    /* Getters: */
     72    const QUuid& uuid() const { return m_uuid; }
     73    const QString& description() const { return m_strDescription; }
     74    UINetworkCustomer* customer() { return m_pCustomer; }
     75    QNetworkReply* reply() { return m_pReply; }
     76
     77private slots:
     78
     79    /* Network-reply progress handler: */
     80    void sltHandleNetworkReplyProgress(qint64 iReceived, qint64 iTotal);
     81    /* Network-reply finish handler: */
     82    void sltHandleNetworkReplyFinish();
     83
     84    /* Slot to retry network-request: */
     85    void sltRetry();
     86    /* Slot to cancel network-request: */
     87    void sltCancel();
     88
     89private:
     90
     91    /* Initialize: */
     92    void initialize();
     93
     94    /* Prepare network-reply: */
     95    void prepareNetworkReply();
     96    /* Cleanup network-reply: */
     97    void cleanupNetworkReply();
     98    /* Abort network-reply: */
     99    void abortNetworkReply();
     100
     101    /* Widgets: */
     102    UINetworkManagerDialog *m_pNetworkManagerDialog;
     103    UINetworkRequestWidget *m_pNetworkRequestWidget;
     104
     105    /* Variables: */
     106    QUuid m_uuid;
     107    QList<QNetworkRequest> m_requests;
     108    QNetworkRequest m_request;
     109    int m_iCurrentRequestIndex;
     110    UINetworkRequestType m_type;
     111    QString m_strDescription;
     112    UINetworkCustomer *m_pCustomer;
     113    QPointer<QNetworkReply> m_pReply;
     114};
    27115
    28116/* QNetworkAccessManager class reimplementation providing
    … …  
    32120    Q_OBJECT;
    33121
     122signals:
     123
     124    /* Notification to UINetworkRequest: */
     125    void sigCancelNetworkRequests();
     126
     127#if 0
     128    /* Signal to notify listeners about downloader creation: */
     129    void sigDownloaderCreated(UIDownloadType downloaderType);
     130#endif
     131
    34132public:
    35133
    … …  
    41139    static void destroy();
    42140
    43 signals:
    44 
    45     /* Signal to notify listeners about downloader creation: */
    46     void sigDownloaderCreated(UIDownloadType downloaderType);
     141    /* Network Access Manager GUI window: */
     142    QWidget* window() const;
     143
     144public slots:
     145
     146    /* Show Network Access Manager GUI: */
     147    void show();
     148
     149protected:
     150
     151    /* Allow UINetworkCustomer to implicitly use next mothods: */
     152    friend class UINetworkCustomer;
     153    /* Network-request creation wrapper for UINetworkCustomer: */
     154    void createNetworkRequest(const QNetworkRequest &request, UINetworkRequestType type,
     155                              const QString &strDescription, UINetworkCustomer *pCustomer);
     156    /* Network request (set) creation wrapper for UINetworkCustomer: */
     157    void createNetworkRequest(const QList<QNetworkRequest> &requests, UINetworkRequestType type,
     158                              const QString &strDescription, UINetworkCustomer *pCustomer);
    47159
    48160private:
    … …  
    56168    void cleanup();
    57169
     170    /* Network-request prepare helper: */
     171    void prepareNetworkRequest(UINetworkRequest *pNetworkRequest);
     172    /* Network-request cleanup helper: */
     173    void cleanupNetworkRequest(const QUuid &uuid);
     174    /* Network-requests cleanup helper: */
     175    void cleanupNetworkRequests();
     176
     177#if 0
     178    /* Downloader creation notification: */
     179    void notifyDownloaderCreated(UIDownloadType downloaderType);
     180#endif
     181
     182private slots:
     183
     184    /* Slot to handle network-request progress: */
     185    void sltHandleNetworkRequestProgress(const QUuid &uuid, qint64 iReceived, qint64 iTotal);
     186    /* Slot to handle network-request cancel: */
     187    void sltHandleNetworkRequestCancel(const QUuid &uuid);
     188    /* Slot to handle network-request finish: */
     189    void sltHandleNetworkRequestFinish(const QUuid &uuid);
     190    /* Slot to handle network-request failure: */
     191    void sltHandleNetworkRequestFailure(const QUuid &uuid, const QString &strError);
     192
     193private:
     194
    58195    /* Instance: */
    59196    static UINetworkManager *m_pInstance;
     197
     198    /* Network-request map: */
     199    QMap<QUuid, UINetworkRequest*> m_requests;
     200
     201    /* Network manager UI: */
     202    UINetworkManagerDialog *m_pNetworkProgressDialog;
    60203};
    61 
    62204#define gNetworkManager UINetworkManager::instance()
    63205

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIUpdateManager.cpp

    r39878 r39932  
    2828#include "UIUpdateManager.h"
    2929#include "UINetworkManager.h"
     30#include "UINetworkCustomer.h"
    3031#include "VBoxGlobal.h"
    3132#include "UIMessageCenter.h"
    … …  
    3940
    4041/* Interface representing update step: */
    41 class UIUpdateStep : public QObject
     42class UIUpdateStep : public UINetworkCustomer
    4243{
    4344    Q_OBJECT;
     45
     46signals:
     47
     48    /* Completion-signal of the step: */
     49    void sigStepComplete();
    4450
    4551public:
    … …  
    5258    }
    5359
    54 signals:
    55 
    56     /* Completion-signal of the step: */
    57     void sigStepComplete();
    58 
    5960protected slots:
    6061
    6162    /* Starting-slot of the step: */
    6263    virtual void sltStartStep() = 0;
     64
     65protected:
     66
     67    /* Network pregress handler dummy: */
     68    void processNetworkReplyProgress(qint64, qint64) {}
     69    /* Network reply canceled handler dummy: */
     70    void processNetworkReplyCanceled(QNetworkReply*) {}
     71    /* Network reply canceled handler dummy: */
     72    void processNetworkReplyFinished(QNetworkReply*) {}
    6373};
    6474
    … …  
    6777{
    6878    Q_OBJECT;
     79
     80signals:
     81
     82    /* Starting-signal of the queue: */
     83    void sigStartQueue();
     84
     85    /* Completion-signal of the queue: */
     86    void sigQueueFinished();
    6987
    7088public:
    … …  
    107125        emit sigStartQueue();
    108126    }
    109 
    110 signals:
    111 
    112     /* Starting-signal of the queue: */
    113     void sigStartQueue();
    114 
    115     /* Completion-signal of the queue: */
    116     void sigQueueFinished();
    117127
    118128private:
    … …  
    139149
    140150    /* Startup slot: */
    141     void sltStartStep()
     151    void sltStartStep() { prepareNetworkRequest(); }
     152
     153private:
     154
     155    /* Prepare network request: */
     156    void prepareNetworkRequest()
    142157    {
    143158        /* Calculate the count of checks left: */
    … …  
    173188        QString strUserAgent(QString("VirtualBox %1 <%2>").arg(vboxGlobal().virtualBox().GetVersion()).arg(vboxGlobal().platformInfo()));
    174189
    175         /* Setup GET request: */
     190        /* Send GET request: */
    176191        QNetworkRequest request;
    177192        request.setUrl(url);
    178193        request.setRawHeader("User-Agent", strUserAgent.toAscii());
    179         QNetworkReply *pReply = gNetworkManager->get(request);
    180         connect(pReply, SIGNAL(finished()), this, SLOT(sltHandleCheckReply()));
    181     }
    182 
    183     /* Finishing slot: */
    184     void sltHandleCheckReply()
    185     {
    186         /* Get corresponding network reply object: */
    187         QNetworkReply *pReply = qobject_cast<QNetworkReply*>(sender());
    188         /* And ask it for suicide: */
    189         pReply->deleteLater();
    190 
    191         /* Handle normal result: */
    192         if (pReply->error() == QNetworkReply::NoError)
    193         {
    194             /* Deserialize incoming data: */
    195             QString strResponseData(pReply->readAll());
    196 
    197             /* Newer version of necessary package found: */
    198             if (strResponseData.indexOf(QRegExp("^\\d+\\.\\d+\\.\\d+ \\S+$")) == 0)
    199             {
    200                 QStringList response = strResponseData.split(" ", QString::SkipEmptyParts);
    201                 msgCenter().showUpdateSuccess(vboxGlobal().mainWindow(), response[0], response[1]);
    202             }
    203             /* No newer version of necessary package found: */
    204             else
    205             {
    206                 if (m_fForceCall)
    207                     msgCenter().showUpdateNotFound(vboxGlobal().mainWindow());
    208             }
    209 
    210             /* Save left count of checks: */
    211             int cCount = 1;
    212             QString strCount = vboxGlobal().virtualBox().GetExtraData(VBoxDefs::GUI_UpdateCheckCount);
    213             if (!strCount.isEmpty())
    214             {
    215                 bool ok = false;
    216                 int c = strCount.toLongLong(&ok);
    217                 if (ok) cCount = c;
    218             }
    219             vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_UpdateCheckCount, QString("%1").arg((qulonglong)cCount + 1));
    220         }
    221         /* Handle errors: */
     194        createNetworkRequest(request, UINetworkRequestType_GET, tr("Checking for a new VirtualBox version..."));
     195    }
     196
     197    /* Handle network reply canceled: */
     198    void processNetworkReplyCanceled(QNetworkReply* /* pReply */)
     199    {
     200        /* Notify about step completion: */
     201        emit sigStepComplete();
     202    }
     203
     204    /* Handle network reply: */
     205    void processNetworkReplyFinished(QNetworkReply *pReply)
     206    {
     207        /* Deserialize incoming data: */
     208        QString strResponseData(pReply->readAll());
     209
     210        /* Newer version of necessary package found: */
     211        if (strResponseData.indexOf(QRegExp("^\\d+\\.\\d+\\.\\d+ \\S+$")) == 0)
     212        {
     213            QStringList response = strResponseData.split(" ", QString::SkipEmptyParts);
     214            msgCenter().showUpdateSuccess(response[0], response[1]);
     215        }
     216        /* No newer version of necessary package found: */
    222217        else
    223218        {
    224219            if (m_fForceCall)
    225                 msgCenter().showUpdateFailure(vboxGlobal().mainWindow(), pReply->errorString());
    226         }
     220                msgCenter().showUpdateNotFound();
     221        }
     222
     223        /* Save left count of checks: */
     224        int cCount = 1;
     225        QString strCount = vboxGlobal().virtualBox().GetExtraData(VBoxDefs::GUI_UpdateCheckCount);
     226        if (!strCount.isEmpty())
     227        {
     228            bool ok = false;
     229            int c = strCount.toLongLong(&ok);
     230            if (ok) cCount = c;
     231        }
     232        vboxGlobal().virtualBox().SetExtraData(VBoxDefs::GUI_UpdateCheckCount, QString("%1").arg((qulonglong)cCount + 1));
    227233
    228234        /* Notify about step completion: */
    … …  
    309315        /* Create and configure the Extension Pack downloader: */
    310316        UIDownloaderExtensionPack *pDl = UIDownloaderExtensionPack::create();
    311         pDl->setParentWidget(msgCenter().mainWindowShown());
    312317        /* After downloading finished => propose to install the Extension Pack: */
    313         connect(pDl, SIGNAL(sigNotifyAboutExtensionPackDownloaded(const QString &, const QString &, QString)),
    314                 this, SLOT(sltHandleDownloadedExtensionPack(const QString &, const QString &, QString)));
     318        connect(pDl, SIGNAL(sigDownloadFinished(const QString&, const QString&, QString)),
     319                this, SLOT(sltHandleDownloadedExtensionPack(const QString&, const QString&, QString)));
    315320        /* Also, destroyed downloader is a signal to finish the step: */
    316321        connect(pDl, SIGNAL(destroyed(QObject*)), this, SIGNAL(sigStepComplete()));
    … …  
    361366UIUpdateManager::UIUpdateManager()
    362367    : m_pQueue(new UIUpdateQueue(this))
     368    , m_fIsRunning(false)
    363369    , m_uTime(1 /* day */ * 24 /* hours */ * 60 /* minutes */ * 60 /* seconds */ * 1000 /* ms */)
    364370{
    … …  
    386392void UIUpdateManager::sltCheckIfUpdateIsNecessary(bool fForceCall /* = false */)
    387393{
     394    /* If already running => just open Network Access Manager GUI: */
     395    if (m_fIsRunning)
     396    {
     397        gNetworkManager->show();
     398        return;
     399    }
     400
     401    /* Set as running: */
     402    m_fIsRunning = true;
     403
    388404    /* Load/decode curent update data: */
    389405    VBoxUpdateData currentData(vboxGlobal().virtualBox().GetExtraData(VBoxDefs::GUI_UpdateDate));
    … …  
    414430    QTimer::singleShot(m_uTime, this, SLOT(sltCheckIfUpdateIsNecessary()));
    415431#endif /* VBOX_WITH_UPDATE_REQUEST */
     432
     433    /* Set as not running: */
     434    m_fIsRunning = false;
    416435}
    417436

  • trunk/src/VBox/Frontends/VirtualBox/src/net/UIUpdateManager.h

    r39337 r39932  
    6363    static UIUpdateManager* m_pInstance;
    6464    UIUpdateQueue *m_pQueue;
     65    bool m_fIsRunning;
    6566    quint64 m_uTime;
    6667};

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

    r39581 r39932  
    2222#include "QIFileDialog.h"
    2323#include "UIActionPoolRuntime.h"
     24#include "UINetworkManager.h"
    2425#include "UIDownloaderAdditions.h"
    2526#include "UIIconPool.h"
    … …  
    15001501    }
    15011502
    1502     /* Download the required image */
    1503     int result = msgCenter().cannotFindGuestAdditions(QDir::toNativeSeparators(strSrc1), QDir::toNativeSeparators(strSrc2));
    1504     if (result == QIMessageBox::Yes)
    1505     {
    1506         /* Create and configure the Additions downloader: */
     1503    /* If downloader is running already: */
     1504    if (UIDownloaderAdditions::current())
     1505    {
     1506        /* Just show network access manager: */
     1507        gNetworkManager->show();
     1508    }
     1509    /* Else propose to download additions: */
     1510    else if (msgCenter().cannotFindGuestAdditions(QDir::toNativeSeparators(strSrc1), QDir::toNativeSeparators(strSrc2)))
     1511    {
     1512        /* Create Additions downloader: */
    15071513        UIDownloaderAdditions *pDl = UIDownloaderAdditions::create();
    1508         const QString &source = QString("http://download.virtualbox.org/virtualbox/%1/").arg(vboxGlobal().vboxVersionStringNormalized()) + name;
    1509         const QString &target = QDir(vboxGlobal().virtualBox().GetHomeFolder()).absoluteFilePath(name);
    1510         pDl->setSource(source);
    1511         pDl->setTarget(target);
    1512         pDl->setAction(gActionPool->action(UIActionIndexRuntime_Simple_InstallGuestTools));
    1513         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    15141514        /* After downloading finished => propose to install the Additions: */
    1515         connect(pDl, SIGNAL(sigDownloadFinished(const QString&)),
    1516                 uisession(), SLOT(sltInstallGuestAdditionsFrom(const QString&)));
     1515        connect(pDl, SIGNAL(sigDownloadFinished(const QString&)), uisession(), SLOT(sltInstallGuestAdditionsFrom(const QString&)));
    15171516        /* Start downloading: */
    15181517        pDl->start();
    … …  
    17041703        if (RT_SUCCESS(rc))
    17051704        {
    1706             if (   DBGGUIVT_ARE_VERSIONS_COMPATIBLE(m_pDbgGuiVT->u32Version, DBGGUIVT_VERSION) 
     1705            if (   DBGGUIVT_ARE_VERSIONS_COMPATIBLE(m_pDbgGuiVT->u32Version, DBGGUIVT_VERSION)
    17071706                || m_pDbgGuiVT->u32EndVersion == m_pDbgGuiVT->u32Version)
    17081707            {

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineMenuBar.cpp

    r39326 r39932  
    2626#include "UIExtraDataEventHandler.h"
    2727#include "UIImageTools.h"
     28#include "UINetworkManager.h"
    2829
    2930/* Global includes */
    … …  
    270271    pMenu->addSeparator();
    271272
     273    pMenu->addAction(gActionPool->action(UIActionIndex_Simple_NetworkAccessManager));
    272274#ifdef VBOX_WITH_REGISTRATION
    273275    pMenu->addAction(gActionPool->action(UIActionIndex_Simple_Register));
    … …  
    300302    VBoxGlobal::connect(gActionPool->action(UIActionIndex_Simple_ResetWarnings), SIGNAL(triggered()),
    301303                        &msgCenter(), SLOT(sltResetSuppressedMessages()));
     304    VBoxGlobal::connect(gActionPool->action(UIActionIndex_Simple_NetworkAccessManager), SIGNAL(triggered()),
     305                        gNetworkManager, SLOT(show()));
    302306#ifdef VBOX_WITH_REGISTRATION
    303307    VBoxGlobal::connect(gActionPool->action(UIActionIndex_Simple_Register), SIGNAL(triggered()),

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineShortcuts.cpp

    r38477 r39932  
    5858    m_Shortcuts[WebShortcut]                   = UIKeySequence("Web");
    5959    m_Shortcuts[ResetWarningsShortcut]         = UIKeySequence("ResetWarnings");
     60    m_Shortcuts[NetworkAccessManager]          = UIKeySequence("NetworkAccessManager");
    6061#ifdef VBOX_WITH_REGISTRATION
    6162    m_Shortcuts[RegisterShortcut]              = UIKeySequence("Register");

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineShortcuts.h

    r38477 r39932  
    5656        WebShortcut,
    5757        ResetWarningsShortcut,
     58        NetworkAccessManager,
    5859#ifdef VBOX_WITH_REGISTRATION
    5960        RegisterShortcut,

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineLogicNormal.cpp

    r39326 r39932  
    7878    /* Prepare normal machine window: */
    7979    prepareMachineWindows();
    80 
    81     /* If there is an Additions download running, update the parent window information. */
    82     if (UIDownloaderAdditions *pDl = UIDownloaderAdditions::current())
    83         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    84 
    85     /* If there is an User Manual download running, update the parent window information. */
    86     if (UIDownloaderUserManual *pDl = UIDownloaderUserManual::current())
    87         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    88 
    89     /* If there is an Extension Pack download running, update the parent window information. */
    90     if (UIDownloaderExtensionPack *pDl = UIDownloaderExtensionPack::current())
    91         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    9280
    9381#ifdef Q_WS_MAC

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.cpp

    r39365 r39932  
    170170}
    171171
     172#if 0
    172173void UIMachineWindowNormal::sltEmbedDownloader(UIDownloadType downloaderType)
    173174{
    … …  
    196197    }
    197198}
     199#endif
    198200
    199201void UIMachineWindowNormal::sltUpdateIndicators()
    … …  
    445447    statusBar()->addPermanentWidget(pIndicatorBox, 0);
    446448
     449#if 0
    447450    /* Add the additions downloader progress bar to the status bar,
    448451     * if a download is actually running: */
    … …  
    456459     * if a download is actually running: */
    457460    tryToEmbedDownloaderForExtensionPack();
     461#endif
    458462
    459463    /* Create & start timer to update LEDs: */
    … …  
    473477    connect(&vboxGlobal().settings(), SIGNAL(propertyChanged(const char *, const char *)),
    474478            this, SLOT(sltProcessGlobalSettingChange(const char *, const char *)));
     479#if 0
    475480    /* Setup network manager listener: */
    476481    connect(gNetworkManager, SIGNAL(sigDownloaderCreated(UIDownloadType)), this, SLOT(sltEmbedDownloader(UIDownloadType)));
     482#endif
    477483}
    478484

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/normal/UIMachineWindowNormal.h

    r39326 r39932  
    6464    void sltTryClose();
    6565
     66#if 0
    6667    /* Network manager handler: */
    6768    void sltEmbedDownloader(UIDownloadType downloaderType);
     69#endif
    6870
    6971private:
    … …  
    106108    void updateIndicatorState(QIStateIndicator *pIndicator, KDeviceType deviceType);
    107109
     110#if 0
    108111    /* Network manager helpers: */
    109112    void tryToEmbedDownloaderForAdditions() { sltEmbedDownloader(UIDownloadType_Additions); }
    110113    void tryToEmbedDownloaderForUserManual() { sltEmbedDownloader(UIDownloadType_UserManual); }
    111114    void tryToEmbedDownloaderForExtensionPack() { sltEmbedDownloader(UIDownloadType_ExtensionPack); }
     115#endif
    112116
    113117    /* Indicators pool: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineLogicScale.cpp

    r38476 r39932  
    9898    prepareMachineWindows();
    9999
    100     /* If there is an Additions download running, update the parent window information. */
    101     if (UIDownloaderAdditions *pDl = UIDownloaderAdditions::current())
    102         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    103 
    104     /* If there is an Extension Pack download running, update the parent window information. */
    105     if (UIDownloaderExtensionPack *pDl = UIDownloaderExtensionPack::current())
    106         pDl->setParentWidget(mainMachineWindow()->machineWindow());
    107 
    108100#ifdef Q_WS_MAC
    109101    /* Prepare dock: */

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/UISelectorShortcuts.cpp

    r38800 r39932  
    5050    m_Shortcuts[WebShortcut]                 = UIKeySequence("Web");
    5151    m_Shortcuts[ResetWarningsShortcut]       = UIKeySequence("ResetWarnings");
     52    m_Shortcuts[NetworkAccessManager]        = UIKeySequence("NetworkAccessManager");
    5253#ifdef VBOX_WITH_REGISTRATION
    5354    m_Shortcuts[RegisterShortcut]            = UIKeySequence("Register");

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/UISelectorShortcuts.h

    r38800 r39932  
    5252        WebShortcut,
    5353        ResetWarningsShortcut,
     54        NetworkAccessManager,
    5455#ifdef VBOX_WITH_REGISTRATION
    5556        RegisterShortcut,

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/UISelectorWindow.cpp

    r39878 r39932  
    11861186}
    11871187
     1188#if 0
    11881189void UISelectorWindow::sltEmbedDownloader(UIDownloadType downloaderType)
    11891190{
    … …  
    12061207    }
    12071208}
     1209#endif
    12081210
    12091211void UISelectorWindow::retranslateUi()
    … …  
    14771479    pMenu->addAction(m_pResetWarningsAction);
    14781480    pMenu->addSeparator();
     1481    m_pNetworkAccessManager = gActionPool->action(UIActionIndex_Simple_NetworkAccessManager);
     1482    pMenu->addAction(m_pNetworkAccessManager);
    14791483#ifdef VBOX_WITH_REGISTRATION
    14801484    m_pRegisterAction = gActionPool->action(UIActionIndex_Simple_Register);
    … …  
    16041608    connect(&vboxGlobal(), SIGNAL(mediumEnumFinished(const VBoxMediaList &)), this, SLOT(sltMediumEnumFinished(const VBoxMediaList &)));
    16051609
     1610#if 0
    16061611    /* Network manager connections: */
    16071612    connect(gNetworkManager, SIGNAL(sigDownloaderCreated(UIDownloadType)), this, SLOT(sltEmbedDownloader(UIDownloadType)));
     1613#endif
    16081614
    16091615    /* Menu-bar connections: */
    … …  
    16431649    connect(m_pWebAction, SIGNAL(triggered()), &msgCenter(), SLOT(sltShowHelpWebDialog()));
    16441650    connect(m_pResetWarningsAction, SIGNAL(triggered()), &msgCenter(), SLOT(sltResetSuppressedMessages()));
     1651    connect(m_pNetworkAccessManager, SIGNAL(triggered()), gNetworkManager, SLOT(show()));
    16451652#ifdef VBOX_WITH_REGISTRATION
    16461653    connect(m_pRegisterAction, SIGNAL(triggered()), &vboxGlobal(), SLOT(showRegistrationDialog()));

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/UISelectorWindow.h

    r39601 r39932  
    128128    void sltMediumEnumFinished(const VBoxMediaList &mediumList);
    129129
     130#if 0
    130131    /* Downloading handler: */
    131132    void sltEmbedDownloader(UIDownloadType downloaderType);
     133#endif
    132134
    133135private:
    … …  
    215217    UIActionInterface *m_pWebAction;
    216218    UIActionInterface *m_pResetWarningsAction;
     219    UIActionInterface *m_pNetworkAccessManager;
    217220#ifdef VBOX_WITH_REGISTRATION
    218221    UIActionInterface *m_pRegisterAction;

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UISpecialControls.cpp

    r30694 r39932  
    126126    setShortcut(QKeySequence(Qt::Key_Escape));
    127127    setIcon(UIIconPool::defaultIcon(UIIconPool::DialogCancelIcon));
    128 }
    129 
    130 void UIMiniCancelButton::removeBorder()
    131 {
    132     setStyleSheet("QToolButton { border: 0px }");
    133128}
    134129

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/UISpecialControls.h

    r30694 r39932  
    158158public:
    159159    UIMiniCancelButton(QWidget *pParent = 0);
    160     void removeBorder();
    161160
    162161protected:
Note: See TracChangeset for help on using the changeset viewer.

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