VirtualBox

Changeset 60362 in vbox for trunk


Ignore:
Timestamp:
Apr 6, 2016 2:29:17 PM (9 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:8317: don't depend on Q_WS_ but define our own VBOX_WS_ macros, this is more sane and also works around a bug in older versions of Qt5

Location:
trunk/src/VBox/Frontends/VirtualBox
Files:
145 edited

Legend:

Unmodified
Added
Removed

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

    r60252 r60362  
    113113VirtualBox_DEFS.win       += UNICODE QT_DLL
    114114ifdef VBOX_WITH_ICHAT_THEATER
    115  VirtualBox_DEFS.darwin += VBOX_WITH_ICHAT_THEATER
    116 endif
    117 ifdef VBOX_WITH_QTGUI_V5
    118  # These important for us Qt4 defines missed in Qt5:
    119  VirtualBox_DEFS.linux     += Q_WS_X11
    120  VirtualBox_DEFS.solaris   += Q_WS_X11
    121  VirtualBox_DEFS.freebsd   += Q_WS_X11
    122  VirtualBox_DEFS.darwin    += Q_WS_MAC
    123  VirtualBox_DEFS.win       += Q_WS_WIN
    124 endif # VBOX_WITH_QTGUI_V5
    125 VirtualBox_DEFS          += \
     115 VirtualBox_DEFS.darwin   += VBOX_WITH_ICHAT_THEATER
     116endif
     117VirtualBox_DEFS.linux     += VBOX_WS_X11
     118VirtualBox_DEFS.solaris   += VBOX_WS_X11
     119VirtualBox_DEFS.freebsd   += VBOX_WS_X11
     120VirtualBox_DEFS.darwin    += VBOX_WS_MAC
     121VirtualBox_DEFS.win       += VBOX_WS_WIN
     122VirtualBox_DEFS           += \
    126123        $(if $(VBOX_WITH_ADDITIONS_AUTOUPDATE_UI),VBOX_WITH_ADDITIONS_AUTOUPDATE_UI) \
    127124        $(if $(VBOX_WITH_UPDATE_REQUEST),VBOX_WITH_UPDATE_REQUEST) \

  • trunk/src/VBox/Frontends/VirtualBox/src/UIMediumTypeChangeDialog.cpp

    r52722 r60362  
    4242    : QIWithRetranslateUI<QIDialog>(pParent)
    4343{
    44 #ifdef Q_WS_MAC
     44#ifdef VBOX_WS_MAC
    4545    setWindowFlags(Qt::Sheet);
    46 #else /* Q_WS_MAC */
     46#else /* VBOX_WS_MAC */
    4747    /* Enable size-grip: */
    4848    setSizeGripEnabled(true);
    49 #endif /* Q_WS_MAC */
     49#endif /* VBOX_WS_MAC */
    5050
    5151    /* Search for corresponding medium: */

  • trunk/src/VBox/Frontends/VirtualBox/src/UIVMInfoDialog.cpp

    r59200 r60362  
    341341            if (isVisible() && (windowState() & (Qt::WindowMaximized | Qt::WindowMinimized | Qt::WindowFullScreen)) == 0)
    342342            {
    343 #ifdef Q_WS_MAC
     343#ifdef VBOX_WS_MAC
    344344                QMoveEvent *pMoveEvent = static_cast<QMoveEvent*>(pEvent);
    345345                m_geometry.moveTo(pMoveEvent->pos());
    346 #else /* Q_WS_MAC */
     346#else /* VBOX_WS_MAC */
    347347                m_geometry.moveTo(geometry().x(), geometry().y());
    348 #endif /* !Q_WS_MAC */
     348#endif /* !VBOX_WS_MAC */
    349349            }
    350350            break;
    … …  
    402402    connect(m_pMachineWindow, SIGNAL(destroyed(QObject*)), this, SLOT(suicide()));
    403403
    404 #ifdef Q_WS_MAC
     404#ifdef VBOX_WS_MAC
    405405    /* No window-icon on Mac OX X, because it acts as proxy icon which isn't necessary here. */
    406406    setWindowIcon(QIcon());
    407 #else /* !Q_WS_MAC */
     407#else /* !VBOX_WS_MAC */
    408408    /* Assign window-icon(s: */
    409409    setWindowIcon(UIIconPool::iconSetFull(":/session_info_32px.png", ":/session_info_16px.png"));
    410 #endif /* !Q_WS_MAC */
     410#endif /* !VBOX_WS_MAC */
    411411
    412412    /* Prepare central-widget: */
    … …  
    521521        /* Load geometry: */
    522522        m_geometry = gEDataManager->informationWindowGeometry(this, m_pMachineWindow, vboxGlobal().managedVMUuid());
    523 #ifdef Q_WS_MAC
     523#ifdef VBOX_WS_MAC
    524524        move(m_geometry.topLeft());
    525525        resize(m_geometry.size());
    526 #else /* Q_WS_MAC */
     526#else /* VBOX_WS_MAC */
    527527        setGeometry(m_geometry);
    528 #endif /* !Q_WS_MAC */
     528#endif /* !VBOX_WS_MAC */
    529529        LogRel2(("GUI: UIVMInfoDialog: Geometry loaded to: Origin=%dx%d, Size=%dx%d\n",
    530530                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    541541    {
    542542        /* Save geometry: */
    543 #ifdef Q_WS_MAC
     543#ifdef VBOX_WS_MAC
    544544        gEDataManager->setInformationWindowGeometry(m_geometry, ::darwinIsWindowMaximized(this), vboxGlobal().managedVMUuid());
    545 #else /* Q_WS_MAC */
     545#else /* VBOX_WS_MAC */
    546546        gEDataManager->setInformationWindowGeometry(m_geometry, isMaximized(), vboxGlobal().managedVMUuid());
    547 #endif /* !Q_WS_MAC */
     547#endif /* !VBOX_WS_MAC */
    548548        LogRel2(("GUI: UIVMInfoDialog: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
    549549                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));

  • trunk/src/VBox/Frontends/VirtualBox/src/UIVMLogViewer.cpp

    r59833 r60362  
    183183                m_pNextPrevButtons->setEnabled(0, false);
    184184                m_pNextPrevButtons->setEnabled(1, false);
    185 #ifndef Q_WS_MAC
     185#ifndef VBOX_WS_MAC
    186186                /* No icons on the Mac: */
    187187                m_pNextPrevButtons->setIcon(0, UIIconPool::defaultIcon(UIIconPool::UIDefaultIconType_ArrowBack, this));
    188188                m_pNextPrevButtons->setIcon(1, UIIconPool::defaultIcon(UIIconPool::UIDefaultIconType_ArrowForward, this));
    189 #endif /* !Q_WS_MAC */
     189#endif /* !VBOX_WS_MAC */
    190190                /* Add Next/Prev button-box to main-layout: */
    191191                m_pMainLayout->addWidget(m_pNextPrevButtons);
    … …  
    10291029        /* Load geometry: */
    10301030        m_geometry = gEDataManager->logWindowGeometry(this, defaultGeometry);
    1031 #ifdef Q_WS_MAC
     1031#ifdef VBOX_WS_MAC
    10321032        move(m_geometry.topLeft());
    10331033        resize(m_geometry.size());
    1034 #else /* !Q_WS_MAC */
     1034#else /* !VBOX_WS_MAC */
    10351035        setGeometry(m_geometry);
    1036 #endif /* !Q_WS_MAC */
     1036#endif /* !VBOX_WS_MAC */
    10371037        LogRel2(("GUI: UIVMLogViewer: Geometry loaded to: Origin=%dx%d, Size=%dx%d\n",
    10381038                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    10501050        /* Save geometry: */
    10511051        const QRect saveGeometry = geometry();
    1052 #ifdef Q_WS_MAC
     1052#ifdef VBOX_WS_MAC
    10531053        gEDataManager->setLogWindowGeometry(saveGeometry, ::darwinIsWindowMaximized(this));
    1054 #else /* !Q_WS_MAC */
     1054#else /* !VBOX_WS_MAC */
    10551055        gEDataManager->setLogWindowGeometry(saveGeometry, isMaximized());
    1056 #endif /* !Q_WS_MAC */
     1056#endif /* !VBOX_WS_MAC */
    10571057        LogRel2(("GUI: UIVMLogViewer: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
    10581058                 saveGeometry.x(), saveGeometry.y(), saveGeometry.width(), saveGeometry.height()));

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxFBOverlay.cpp

    r58866 r60362  
    4747# include <VBox/VBoxGL2D.h>
    4848
    49 #ifdef Q_WS_MAC
     49#ifdef VBOX_WS_MAC
    5050# include "VBoxUtils-darwin.h"
    51 #endif /* Q_WS_MAC */
     51#endif /* VBOX_WS_MAC */
    5252
    5353#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    44444444    }
    44454445
    4446 #ifdef Q_WS_MAC
     4446#ifdef VBOX_WS_MAC
    44474447    /* Take the backing-scale-factor into account: */
    44484448    if (mSizeInfo.useUnscaledHiDPIOutput())
    … …  
    44574457        }
    44584458    }
    4459 #endif /* Q_WS_MAC */
     4459#endif /* VBOX_WS_MAC */
    44604460
    44614461    /* we do not to miss notify updates, because we have to update bg textures for it,

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobalSettings.cpp

    r55346 r60362  
    3535# include "CVirtualBox.h"
    3636
    37 # ifdef Q_WS_MAC
     37# ifdef VBOX_WS_MAC
    3838/* Namespaces: */
    3939using namespace UIExtraDataDefs;
    40 # endif /* Q_WS_MAC */
     40# endif /* VBOX_WS_MAC */
    4141
    4242#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    5252{
    5353    /* default settings */
    54 #if defined (Q_WS_WIN)
     54#if defined (VBOX_WS_WIN)
    5555    hostCombo = "163"; // VK_RCONTROL
    56 #elif defined (Q_WS_X11)
     56#elif defined (VBOX_WS_X11)
    5757    hostCombo = "65508"; // XK_Control_R
    58 #elif defined (Q_WS_MAC)
     58#elif defined (VBOX_WS_MAC)
    5959    hostCombo = "55"; // QZ_LMETA
    6060#else

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxLicenseViewer.cpp

    r52722 r60362  
    4040    , mDisagreeButton (0)
    4141{
    42 #ifndef Q_WS_WIN
     42#ifndef VBOX_WS_WIN
    4343    /* Application icon. On Win32, it's built-in to the executable. */
    4444    setWindowIcon (QIcon (":/VirtualBox_48px.png"));

  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxTakeSnapshotDlg.cpp

    r52722 r60362  
    2727# include "UIMessageCenter.h"
    2828# include "VBoxUtils.h"
    29 # ifdef Q_WS_MAC
     29# ifdef VBOX_WS_MAC
    3030#  include "UIMachineWindowNormal.h"
    3131#  include "VBoxSnapshotsWgt.h"
    32 # endif /* Q_WS_MAC */
     32# endif /* VBOX_WS_MAC */
    3333
    3434/* COM includes: */

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackend.h

    r60260 r60362  
    8282template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>();
    8383#endif /* VBOX_WITH_DEBUGGER_GUI */
    84 #ifdef Q_WS_MAC
     84#ifdef VBOX_WS_MAC
    8585template<> bool canConvert<UIExtraDataMetaDefs::MenuWindowActionType>();
    86 #endif /* Q_WS_MAC */
     86#endif /* VBOX_WS_MAC */
    8787template<> bool canConvert<UIVisualStateType>();
    8888template<> bool canConvert<DetailsElementType>();
    … …  
    9999template<> bool canConvert<ScalingOptimizationType>();
    100100template<> bool canConvert<HiDPIOptimizationType>();
    101 #ifndef Q_WS_MAC
     101#ifndef VBOX_WS_MAC
    102102template<> bool canConvert<MiniToolbarAlignment>();
    103 #endif /* !Q_WS_MAC */
     103#endif /* !VBOX_WS_MAC */
    104104
    105105/* Declare COM canConvert specializations: */
    … …  
    151151template<> UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType fromInternalString<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>(const QString &strRuntimeMenuDebuggerActionType);
    152152#endif /* VBOX_WITH_DEBUGGER_GUI */
    153 #ifdef Q_WS_MAC
     153#ifdef VBOX_WS_MAC
    154154template<> QString toInternalString(const UIExtraDataMetaDefs::MenuWindowActionType &menuWindowActionType);
    155155template<> UIExtraDataMetaDefs::MenuWindowActionType fromInternalString<UIExtraDataMetaDefs::MenuWindowActionType>(const QString &strMenuWindowActionType);
    156 #endif /* Q_WS_MAC */
     156#endif /* VBOX_WS_MAC */
    157157template<> QString toInternalString(const UIVisualStateType &visualStateType);
    158158template<> UIVisualStateType fromInternalString<UIVisualStateType>(const QString &strVisualStateType);
    … …  
    188188template<> QString toInternalString(const HiDPIOptimizationType &optimizationType);
    189189template<> HiDPIOptimizationType fromInternalString<HiDPIOptimizationType>(const QString &strOptimizationType);
    190 #ifndef Q_WS_MAC
     190#ifndef VBOX_WS_MAC
    191191template<> QString toInternalString(const MiniToolbarAlignment &miniToolbarAlignment);
    192192template<> MiniToolbarAlignment fromInternalString<MiniToolbarAlignment>(const QString &strMiniToolbarAlignment);
    193 #endif /* !Q_WS_MAC */
     193#endif /* !VBOX_WS_MAC */
    194194template<> QString toString(const InformationElementType &informationElementType);
    195195template<> InformationElementType fromString<InformationElementType>(const QString &strInformationElementType);

  • trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

    r60260 r60362  
    4949template<> bool canConvert<UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType>() { return true; }
    5050#endif /* VBOX_WITH_DEBUGGER_GUI */
    51 #ifdef Q_WS_MAC
     51#ifdef VBOX_WS_MAC
    5252template<> bool canConvert<UIExtraDataMetaDefs::MenuWindowActionType>() { return true; }
    53 #endif /* Q_WS_MAC */
     53#endif /* VBOX_WS_MAC */
    5454template<> bool canConvert<UIVisualStateType>() { return true; }
    5555template<> bool canConvert<DetailsElementType>() { return true; }
    … …  
    6666template<> bool canConvert<ScalingOptimizationType>() { return true; }
    6767template<> bool canConvert<HiDPIOptimizationType>() { return true; }
    68 #ifndef Q_WS_MAC
     68#ifndef VBOX_WS_MAC
    6969template<> bool canConvert<MiniToolbarAlignment>() { return true; }
    70 #endif /* !Q_WS_MAC */
     70#endif /* !VBOX_WS_MAC */
    7171
    7272/* QString <= SizeSuffix: */
    … …  
    445445    switch (menuApplicationActionType)
    446446    {
    447 #ifdef Q_WS_MAC
     447#ifdef VBOX_WS_MAC
    448448        case UIExtraDataMetaDefs::MenuApplicationActionType_About:                strResult = "About"; break;
    449 #endif /* Q_WS_MAC */
     449#endif /* VBOX_WS_MAC */
    450450        case UIExtraDataMetaDefs::MenuApplicationActionType_Preferences:          strResult = "Preferences"; break;
    451451#ifdef VBOX_GUI_WITH_NETWORK_MANAGER
    … …  
    471471     * to search through the keys using 'case-insensitive' rule: */
    472472    QStringList keys;               QList<UIExtraDataMetaDefs::MenuApplicationActionType> values;
    473 #ifdef Q_WS_MAC
     473#ifdef VBOX_WS_MAC
    474474    keys << "About";                values << UIExtraDataMetaDefs::MenuApplicationActionType_About;
    475 #endif /* Q_WS_MAC */
     475#endif /* VBOX_WS_MAC */
    476476    keys << "Preferences";          values << UIExtraDataMetaDefs::MenuApplicationActionType_Preferences;
    477477#ifdef VBOX_GUI_WITH_NETWORK_MANAGER
    … …  
    497497        case UIExtraDataMetaDefs::MenuHelpActionType_Contents:             strResult = "Contents"; break;
    498498        case UIExtraDataMetaDefs::MenuHelpActionType_WebSite:              strResult = "WebSite"; break;
    499 #ifndef Q_WS_MAC
     499#ifndef VBOX_WS_MAC
    500500        case UIExtraDataMetaDefs::MenuHelpActionType_About:                strResult = "About"; break;
    501 #endif /* !Q_WS_MAC */
     501#endif /* !VBOX_WS_MAC */
    502502        case UIExtraDataMetaDefs::MenuHelpActionType_All:                  strResult = "All"; break;
    503503        default:
    … …  
    518518    keys << "Contents";             values << UIExtraDataMetaDefs::MenuHelpActionType_Contents;
    519519    keys << "WebSite";              values << UIExtraDataMetaDefs::MenuHelpActionType_WebSite;
    520 #ifndef Q_WS_MAC
     520#ifndef VBOX_WS_MAC
    521521    keys << "About";                values << UIExtraDataMetaDefs::MenuHelpActionType_About;
    522 #endif /* !Q_WS_MAC */
     522#endif /* !VBOX_WS_MAC */
    523523    keys << "All";                  values << UIExtraDataMetaDefs::MenuHelpActionType_All;
    524524    /* Invalid type for unknown words: */
    … …  
    586586        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless:             strResult = "Seamless"; break;
    587587        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale:                strResult = "Scale"; break;
    588 #ifndef Q_WS_MAC
     588#ifndef VBOX_WS_MAC
    589589        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_MinimizeWindow:       strResult = "MinimizeWindow"; break;
    590 #endif /* !Q_WS_MAC */
     590#endif /* !VBOX_WS_MAC */
    591591        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow:         strResult = "AdjustWindow"; break;
    592592        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize:      strResult = "GuestAutoresize"; break;
    … …  
    598598        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_MenuBar:              strResult = "MenuBar"; break;
    599599        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_MenuBarSettings:      strResult = "MenuBarSettings"; break;
    600 #ifndef Q_WS_MAC
     600#ifndef VBOX_WS_MAC
    601601        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_ToggleMenuBar:        strResult = "ToggleMenuBar"; break;
    602 #endif /* !Q_WS_MAC */
     602#endif /* !VBOX_WS_MAC */
    603603        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar:            strResult = "StatusBar"; break;
    604604        case UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBarSettings:    strResult = "StatusBarSettings"; break;
    … …  
    626626    keys << "Seamless";             values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Seamless;
    627627    keys << "Scale";                values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_Scale;
    628 #ifndef Q_WS_MAC
     628#ifndef VBOX_WS_MAC
    629629    keys << "MinimizeWindow";       values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_MinimizeWindow;
    630 #endif /* !Q_WS_MAC */
     630#endif /* !VBOX_WS_MAC */
    631631    keys << "AdjustWindow";         values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_AdjustWindow;
    632632    keys << "GuestAutoresize";      values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_GuestAutoresize;
    … …  
    638638    keys << "MenuBar";              values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_MenuBar;
    639639    keys << "MenuBarSettings";      values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_MenuBarSettings;
    640 #ifndef Q_WS_MAC
     640#ifndef VBOX_WS_MAC
    641641    keys << "ToggleMenuBar";        values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_ToggleMenuBar;
    642 #endif /* !Q_WS_MAC */
     642#endif /* !VBOX_WS_MAC */
    643643    keys << "StatusBar";            values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar;
    644644    keys << "StatusBarSettings";    values << UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBarSettings;
    … …  
    664664        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_KeyboardSettings:  strResult = "KeyboardSettings"; break;
    665665        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCAD:           strResult = "TypeCAD"; break;
    666 #ifdef Q_WS_X11
     666#ifdef VBOX_WS_X11
    667667        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCABS:          strResult = "TypeCABS"; break;
    668 #endif /* Q_WS_X11 */
     668#endif /* VBOX_WS_X11 */
    669669        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCtrlBreak:     strResult = "TypeCtrlBreak"; break;
    670670        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeInsert:        strResult = "TypeInsert"; break;
    … …  
    690690    keys << "KeyboardSettings";  values << UIExtraDataMetaDefs::RuntimeMenuInputActionType_KeyboardSettings;
    691691    keys << "TypeCAD";           values << UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCAD;
    692 #ifdef Q_WS_X11
     692#ifdef VBOX_WS_X11
    693693    keys << "TypeCABS";          values << UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCABS;
    694 #endif /* Q_WS_X11 */
     694#endif /* VBOX_WS_X11 */
    695695    keys << "TypeCtrlBreak";     values << UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCtrlBreak;
    696696    keys << "TypeInsert";        values << UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeInsert;
    … …  
    805805#endif /* VBOX_WITH_DEBUGGER_GUI */
    806806
    807 #ifdef Q_WS_MAC
     807#ifdef VBOX_WS_MAC
    808808/* QString <= UIExtraDataMetaDefs::MenuWindowActionType: */
    809809template<> QString toInternalString(const UIExtraDataMetaDefs::MenuWindowActionType &menuWindowActionType)
    … …  
    839839    return values.at(keys.indexOf(QRegExp(strMenuWindowActionType, Qt::CaseInsensitive)));
    840840}
    841 #endif /* Q_WS_MAC */
     841#endif /* VBOX_WS_MAC */
    842842
    843843/* QString <= UIVisualStateType: */
    … …  
    15441544}
    15451545
    1546 #ifndef Q_WS_MAC
     1546#ifndef VBOX_WS_MAC
    15471547/* QString <= MiniToolbarAlignment: */
    15481548template<> QString toInternalString(const MiniToolbarAlignment &miniToolbarAlignment)
    … …  
    15731573    return values.at(keys.indexOf(QRegExp(strMiniToolbarAlignment, Qt::CaseInsensitive)));
    15741574}
    1575 #endif /* !Q_WS_MAC */
     1575#endif /* !VBOX_WS_MAC */
    15761576
    15771577/* QString <= InformationElementType: */

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIAdvancedSlider.cpp

    r57215 r60362  
    7777        /* We want to acquire SC_SliderTickmarks sub-control rectangle
    7878         * and fill it with necessary background colors: */
    79 #ifdef Q_WS_MAC
     79#ifdef VBOX_WS_MAC
    8080        /* Under MacOS X SC_SliderTickmarks is not fully reliable
    8181         * source of the information we need, providing us with incorrect width.
    … …  
    8383        QRect ticks = style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderTickmarks, this);
    8484        ticks.setRect((s.width() - available) / 2, s.height() - ticks.y(), available, ticks.height());
    85 #else /* Q_WS_MAC */
     85#else /* VBOX_WS_MAC */
    8686        /* Under Windows SC_SliderTickmarks is fully unreliable
    8787         * source of the information we need, providing us with empty rectangle.
    … …  
    9393                      style()->subControlRect(QStyle::CC_Slider, &opt, QStyle::SC_SliderGroove, this);
    9494        ticks.setRect((s.width() - available) / 2, ticks.bottom() + 1, available, s.height() - ticks.bottom() - 1);
    95 #endif /* Q_WS_MAC */
     95#endif /* VBOX_WS_MAC */
    9696
    9797        if ((m_minOpt != -1 &&

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIAdvancedToolBar.cpp

    r52733 r60362  
    7979    /* Create main-layout: */
    8080    m_pMainLayout = new QHBoxLayout(this);
    81 #if defined (Q_WS_WIN)
     81#if defined (VBOX_WS_WIN)
    8282    m_pMainLayout->setContentsMargins(1, 1, 1, 1);
    83 #elif defined (Q_WS_X11)
     83#elif defined (VBOX_WS_X11)
    8484    m_pMainLayout->setContentsMargins(0, 0, 0, 0);
    8585#else

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIDialog.cpp

    r54538 r60362  
    125125    /* Make sure layout is polished: */
    126126    adjustSize();
    127 #ifdef Q_WS_MAC
     127#ifdef VBOX_WS_MAC
    128128    /* And dialog have fixed size: */
    129129    setFixedSize(size());
    130 #endif /* Q_WS_MAC */
     130#endif /* VBOX_WS_MAC */
    131131
    132132    /* Explicit centering according to our parent: */

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIFileDialog.cpp

    r59090 r60362  
    2626# include "QIFileDialog.h"
    2727
    28 # ifdef Q_WS_WIN
     28# ifdef VBOX_WS_WIN
    2929/* Qt includes */
    3030#  include <QEvent>
    … …  
    3434/* WinAPI includes */
    3535#  include "shlobj.h"
    36 # endif /* !Q_WS_WIN */
     36# endif /* !VBOX_WS_WIN */
    3737
    3838#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    3939
    4040
    41 #ifdef Q_WS_WIN
     41#ifdef VBOX_WS_WIN
    4242
    4343static QString extractFilter (const QString &aRawFilter)
    … …  
    210210};
    211211
    212 #endif /* Q_WS_WIN */
     212#endif /* VBOX_WS_WIN */
    213213
    214214QIFileDialog::QIFileDialog (QWidget *aParent, Qt::WindowFlags aFlags)
    … …  
    235235                                            bool aResolveSymlinks)
    236236{
    237 #if defined(Q_WS_WIN) && (QT_VERSION < 0x050000)
     237#if defined(VBOX_WS_WIN) && (QT_VERSION < 0x050000)
    238238
    239239    /**
    … …  
    325325    return loopObject.result();
    326326
    327 #elif defined (Q_WS_X11) && (QT_VERSION < 0x040400)
     327#elif defined (VBOX_WS_X11) && (QT_VERSION < 0x040400)
    328328
    329329    /* Here is workaround for Qt4.3 bug with QFileDialog which crushes when
    … …  
    343343    }
    344344    return dlg.exec() ? dlg.selectedFiles() [0] : QString::null;
    345 #elif defined (Q_WS_MAC) && (QT_VERSION >= 0x040600)
     345#elif defined (VBOX_WS_MAC) && (QT_VERSION >= 0x040600)
    346346
    347347    /* After 4.5 exec ignores the Qt::Sheet flag.
    … …  
    366366
    367367    QFileDialog::Options o;
    368 # if defined (Q_WS_X11)
     368# if defined (VBOX_WS_X11)
    369369    /** @todo see http://bugs.kde.org/show_bug.cgi?id=210904, make it conditional
    370370     *        when this bug is fixed (xtracker 5167).
    … …  
    403403                                       bool           fConfirmOverwrite /* = false */)
    404404{
    405 #if defined(Q_WS_WIN) && (QT_VERSION < 0x050000)
     405#if defined(VBOX_WS_WIN) && (QT_VERSION < 0x050000)
    406406
    407407    /* Further code (WinAPI call to GetSaveFileName() in other thread)
    … …  
    540540    return loopObject.result();
    541541
    542 #elif defined (Q_WS_X11) && (QT_VERSION < 0x040400)
     542#elif defined (VBOX_WS_X11) && (QT_VERSION < 0x040400)
    543543
    544544    /* Here is workaround for Qt4.3 bug with QFileDialog which crushes when
    … …  
    564564    return dlg.exec() == QDialog::Accepted ? dlg.selectedFiles().value (0, "") : QString::null;
    565565
    566 #elif defined (Q_WS_MAC) && (QT_VERSION >= 0x040600) && (QT_VERSION < 0x050000)
     566#elif defined (VBOX_WS_MAC) && (QT_VERSION >= 0x040600) && (QT_VERSION < 0x050000)
    567567
    568568    /* After 4.5 exec ignores the Qt::Sheet flag.
    … …  
    602602
    603603    QFileDialog::Options o;
    604 # if defined (Q_WS_X11)
     604# if defined (VBOX_WS_X11)
    605605    /** @todo see http://bugs.kde.org/show_bug.cgi?id=210904, make it conditional
    606606     *        when this bug is fixed (xtracker 5167)
    … …  
    671671{
    672672/* It seems, running QFileDialog in separate thread is NOT needed under windows any more: */
    673 #if defined (Q_WS_WIN) && (QT_VERSION < 0x040403)
     673#if defined (VBOX_WS_WIN) && (QT_VERSION < 0x040403)
    674674
    675675    /**
    … …  
    796796    return QStringList() << loopObject.result();
    797797
    798 #elif defined (Q_WS_X11) && (QT_VERSION < 0x040400)
     798#elif defined (VBOX_WS_X11) && (QT_VERSION < 0x040400)
    799799
    800800    /* Here is workaround for Qt4.3 bug with QFileDialog which crushes when
    … …  
    821821    return dlg.exec() == QDialog::Accepted ? dlg.selectedFiles() : QStringList() << QString::null;
    822822
    823 #elif defined (Q_WS_MAC) && (QT_VERSION >= 0x040600) && (QT_VERSION < 0x050000)
     823#elif defined (VBOX_WS_MAC) && (QT_VERSION >= 0x040600) && (QT_VERSION < 0x050000)
    824824
    825825    /* After 4.5 exec ignores the Qt::Sheet flag.
    … …  
    862862    if (!aResolveSymlinks)
    863863        o |= QFileDialog::DontResolveSymlinks;
    864 # if defined (Q_WS_X11)
     864# if defined (VBOX_WS_X11)
    865865    /** @todo see http://bugs.kde.org/show_bug.cgi?id=210904, make it conditional
    866866     *        when this bug is fixed (xtracker 5167)
    … …  
    901901}
    902902
    903 #if defined Q_WS_WIN
     903#if defined VBOX_WS_WIN
    904904#include "QIFileDialog.moc"
    905905#endif

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QILineEdit.cpp

    r59028 r60362  
    2222/* Qt includes: */
    2323# if QT_VERSION < 0x050000
    24 #  ifdef Q_WS_WIN
     24#  ifdef VBOX_WS_WIN
    2525#   include <QLibrary>
    26 #  endif /* Q_WS_WIN */
     26#  endif /* VBOX_WS_WIN */
    2727# endif /* QT_VERSION < 0x050000 */
    2828
    … …  
    3232/* Other VBox includes: */
    3333# if QT_VERSION < 0x050000
    34 #  ifdef Q_WS_WIN
     34#  ifdef VBOX_WS_WIN
    3535#   include "iprt/ldr.h"
    36 #  endif /* Q_WS_WIN */
     36#  endif /* VBOX_WS_WIN */
    3737# endif /* QT_VERSION < 0x050000 */
    3838
    3939/* External includes: */
    4040# if QT_VERSION < 0x050000
    41 #  ifdef Q_WS_WIN
     41#  ifdef VBOX_WS_WIN
    4242#   include <Windows.h>
    43 #  endif /* Q_WS_WIN */
     43#  endif /* VBOX_WS_WIN */
    4444# endif /* QT_VERSION < 0x050000 */
    4545
    … …  
    4949#include <QStyleOptionFrame>
    5050#if QT_VERSION < 0x050000
    51 # ifdef Q_WS_WIN
     51# ifdef VBOX_WS_WIN
    5252#  include <QWindowsVistaStyle>
    53 # endif /* Q_WS_WIN */
     53# endif /* VBOX_WS_WIN */
    5454#endif /* QT_VERSION < 0x050000 */
    5555
    … …  
    8181
    8282#if QT_VERSION < 0x050000
    83 # ifdef Q_WS_WIN
     83# ifdef VBOX_WS_WIN
    8484    /* Vista l&f style has a bug where the last parameter of sizeFromContents
    8585     * function ('widget' what corresponds to 'this' in our class) is ignored.
    … …  
    9898            sa -= QSize(23, 0);
    9999    }
    100 # endif /* Q_WS_WIN */
     100# endif /* VBOX_WS_WIN */
    101101#endif /* QT_VERSION < 0x050000 */
    102102

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIListView.cpp

    r59099 r60362  
    2222/* Qt includes: */
    2323# include <QtGlobal>
    24 # ifdef Q_WS_MAC
     24# ifdef VBOX_WS_MAC
    2525#  include <QApplication>
    2626#  include <QPainter>
    27 # endif /* Q_WS_MAC */
     27# endif /* VBOX_WS_MAC */
    2828
    2929#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    3030
    3131/* Qt includes: */
    32 #ifdef Q_WS_MAC
     32#ifdef VBOX_WS_MAC
    3333# if QT_VERSION < 0x050000
    3434#  include <qmacstyle_mac.h>
    3535# endif /* QT_VERSION < 0x050000 */
    36 #endif /* Q_WS_MAC */
     36#endif /* VBOX_WS_MAC */
    3737
    3838/* GUI includes: */
    … …  
    4343    :QListView (aParent)
    4444{
    45 #ifdef Q_WS_MAC
     45#ifdef VBOX_WS_MAC
    4646    /* Track if the application lost the focus */
    4747    connect (QCoreApplication::instance(), SIGNAL (focusChanged (QWidget *, QWidget *)),
    … …  
    5757    static_cast<QMacStyle *> (style())->setFocusRectPolicy (this, QMacStyle::FocusDisabled);
    5858# endif /* QT_VERSION < 0x050000 */
    59 #endif /* Q_WS_MAC */
     59#endif /* VBOX_WS_MAC */
    6060}
    6161
    6262void QIListView::focusChanged (QWidget * /* aOld */, QWidget *aNow)
    6363{
    64 #ifdef Q_WS_MAC
     64#ifdef VBOX_WS_MAC
    6565    QColor bgColor (212, 221, 229);
    6666    if (aNow == NULL)
    … …  
    7070    viewport()->setPalette (pal);
    7171    viewport()->setAutoFillBackground(true);
    72 #else /* !Q_WS_MAC */
     72#else /* !VBOX_WS_MAC */
    7373    Q_UNUSED (aNow);
    74 #endif /* !Q_WS_MAC */
     74#endif /* !VBOX_WS_MAC */
    7575}
    7676
    … …  
    8080                                     const QModelIndex &aIndex) const
    8181{
    82 #ifdef Q_WS_MAC
     82#ifdef VBOX_WS_MAC
    8383    Q_UNUSED (aIndex);
    8484    /* Macify for Leopard */
    … …  
    122122        aPainter->fillRect(aOption.rect, bgColor);
    123123    }
    124 #else /* !Q_WS_MAC */
     124#else /* !VBOX_WS_MAC */
    125125    QItemDelegate::drawBackground (aPainter, aOption, aIndex);
    126 #endif /* !Q_WS_MAC */
     126#endif /* !VBOX_WS_MAC */
    127127}
    128128

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIMainDialog.cpp

    r58853 r60362  
    230230            break;
    231231        }
    232 #ifdef Q_WS_MAC
     232#ifdef VBOX_WS_MAC
    233233        /* Special handling for Period key: */
    234234        case Qt::Key_Period:
    … …  
    241241            break;
    242242        }
    243 #endif /* Q_WS_MAC */
     243#endif /* VBOX_WS_MAC */
    244244        /* Special handling for Return/Enter key: */
    245245        case Qt::Key_Return:

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIMenu.cpp

    r52730 r60362  
    3131void QIMenu::sltHighlightFirstAction()
    3232{
    33 #ifdef Q_WS_WIN
     33#ifdef VBOX_WS_WIN
    3434    /* Windows host requires window-activation: */
    3535    activateWindow();
    36 #endif /* Q_WS_WIN */
     36#endif /* VBOX_WS_WIN */
    3737    /* Focus next child: */
    3838    QMenu::focusNextChild();

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIMessageBox.cpp

    r58867 r60362  
    171171    {
    172172        /* Configure main-layout: */
    173 #ifdef Q_WS_MAC
     173#ifdef VBOX_WS_MAC
    174174        pMainLayout->setContentsMargins(40, 11, 40, 11);
    175175        pMainLayout->setSpacing(15);
    176 #else /* !Q_WS_MAC */
     176#else /* !VBOX_WS_MAC */
    177177        pMainLayout->setContentsMargins(11, 11, 11, 11);
    178178        pMainLayout->setSpacing(10);
    179 #endif /* !Q_WS_MAC */
     179#endif /* !VBOX_WS_MAC */
    180180        /* Create top-layout: */
    181181        QHBoxLayout *pTopLayout = new QHBoxLayout;

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIProcess.cpp

    r52730 r60362  
    2424
    2525/* External includes: */
    26 #ifdef Q_WS_X11
     26#ifdef VBOX_WS_X11
    2727# include <sys/wait.h>
    28 #endif /* Q_WS_X11 */
     28#endif /* VBOX_WS_X11 */
    2929
    3030
    … …  
    4949        result = process.readAllStandardOutput();
    5050    process.setProcessState(QProcess::NotRunning);
    51 #ifdef Q_WS_X11
     51#ifdef VBOX_WS_X11
    5252    int iStatus;
    5353    if (process.pid() > 0)
    5454        waitpid(process.pid(), &iStatus, 0);
    55 #endif /* Q_WS_X11 */
     55#endif /* VBOX_WS_X11 */
    5656    return result;
    5757}

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QISplitter.cpp

    r52730 r60362  
    146146    , m_fPolished(false)
    147147    , m_type(Shade)
    148 #ifdef Q_WS_MAC
     148#ifdef VBOX_WS_MAC
    149149    , m_fHandleGrabbed(false)
    150 #endif /* Q_WS_MAC */
     150#endif /* VBOX_WS_MAC */
    151151{
    152152    qApp->installEventFilter(this);
    … …  
    157157    , m_fPolished(false)
    158158    , m_type(Shade)
    159 #ifdef Q_WS_MAC
     159#ifdef VBOX_WS_MAC
    160160    , m_fHandleGrabbed(false)
    161 #endif /* Q_WS_MAC */
     161#endif /* VBOX_WS_MAC */
    162162{
    163163    qApp->installEventFilter (this);
    … …  
    177177        }
    178178    }
    179 #ifdef Q_WS_MAC
     179#ifdef VBOX_WS_MAC
    180180    /* Special handling on the Mac. Cause there the horizontal handle is only 1
    181181     * pixel wide, its hard to catch. Therefor we make some invisible area
    … …  
    255255        }
    256256    }
    257 #endif /* Q_WS_MAC */
     257#endif /* VBOX_WS_MAC */
    258258
    259259    return QSplitter::eventFilter(pWatched, pEvent);

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

    r55401 r60362  
    5151    bool m_fPolished;
    5252    Type m_type;
    53 #ifdef Q_WS_MAC
     53#ifdef VBOX_WS_MAC
    5454    bool m_fHandleGrabbed;
    55 #endif /* Q_WS_MAC */
     55#endif /* VBOX_WS_MAC */
    5656
    5757    QColor m_color1;

  • trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIStatusBarIndicator.cpp

    r55917 r60362  
    2727# include <QStyle>
    2828# include <QLabel>
    29 # ifdef Q_WS_MAC
     29# ifdef VBOX_WS_MAC
    3030#  include <QContextMenuEvent>
    31 # endif /* Q_WS_MAC */
     31# endif /* VBOX_WS_MAC */
    3232
    3333/* GUI includes: */
    … …  
    4545}
    4646
    47 #ifdef Q_WS_MAC
     47#ifdef VBOX_WS_MAC
    4848void QIStatusBarIndicator::mousePressEvent(QMouseEvent *pEvent)
    4949{
    … …  
    6464        QWidget::mousePressEvent(pEvent);
    6565}
    66 #endif /* Q_WS_MAC */
     66#endif /* VBOX_WS_MAC */
    6767
    6868void QIStatusBarIndicator::mouseDoubleClickEvent(QMouseEvent *pEvent)

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

    r55401 r60362  
    4949protected:
    5050
    51 #ifdef Q_WS_MAC
     51#ifdef VBOX_WS_MAC
    5252    /** Mac OS X: Mouse-press-event handler.
    5353      *           Make the left button also show the context-menu to make things
    5454      *           simpler for users with single mouse button mice (laptops++). */
    5555    virtual void mousePressEvent(QMouseEvent *pEvent);
    56 #endif /* Q_WS_MAC */
     56#endif /* VBOX_WS_MAC */
    5757    /** Mouse-double-click-event handler. */
    5858    virtual void mouseDoubleClickEvent(QMouseEvent *pEvent);

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

    r55401 r60362  
    3333        :QTabWidget(pParent)
    3434    {
    35 #ifdef Q_WS_MAC
     35#ifdef VBOX_WS_MAC
    3636        /* I don't know why, but for some languages there is ElideRight the
    3737           default on Mac OS X. Fix this. */
    3838        setElideMode(Qt::ElideNone);
    39 #endif /* Q_WS_MAC */
     39#endif /* VBOX_WS_MAC */
    4040    }
    4141};

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

    r55401 r60362  
    3232        : QToolButton(pParent)
    3333    {
    34 #ifdef Q_WS_MAC
     34#ifdef VBOX_WS_MAC
    3535        /* Keep size-hint alive: */
    3636        const QSize sh = sizeHint();
    3737        setStyleSheet("QToolButton { border: 0px none black; margin: 0px 0px 0px 0px; } QToolButton::menu-indicator {image: none;}");
    3838        setFixedSize(sh);
    39 #else /* !Q_WS_MAC */
     39#else /* !VBOX_WS_MAC */
    4040        setAutoRaise(true);
    41 #endif /* !Q_WS_MAC */
     41#endif /* !VBOX_WS_MAC */
    4242    }
    4343
    … …  
    4545    virtual void setAutoRaise(bool fEnable)
    4646    {
    47 #ifdef Q_WS_MAC
     47#ifdef VBOX_WS_MAC
    4848        /* Ignore for Mac OS X: */
    4949        Q_UNUSED(fEnable);
    50 #else /* !Q_WS_MAC */
     50#else /* !VBOX_WS_MAC */
    5151        /* Call to base-class: */
    5252        QToolButton::setAutoRaise(fEnable);
    53 #endif /* !Q_WS_MAC */
     53#endif /* !VBOX_WS_MAC */
    5454    }
    5555

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

    r55401 r60362  
    2525
    2626/* External includes: */
    27 #ifdef Q_WS_X11
     27#ifdef VBOX_WS_X11
    2828#include <limits.h>
    29 #endif /* Q_WS_X11 */
     29#endif /* VBOX_WS_X11 */
    3030
    3131/* Forward declarations: */

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.cpp

    r60260 r60362  
    8282const char* UIExtraDataDefs::GUI_PreventSnapshotOperations = "GUI/PreventSnapshotOperations";
    8383const char* UIExtraDataDefs::GUI_FirstRun = "GUI/FirstRun";
    84 #ifndef Q_WS_MAC
     84#ifndef VBOX_WS_MAC
    8585const char* UIExtraDataDefs::GUI_MachineWindowIcons = "GUI/MachineWindowIcons";
    8686const char* UIExtraDataDefs::GUI_MachineWindowNamePostfix = "GUI/MachineWindowNamePostfix";
    87 #endif /* !Q_WS_MAC */
     87#endif /* !VBOX_WS_MAC */
    8888const char* UIExtraDataDefs::GUI_LastNormalWindowPosition = "GUI/LastNormalWindowPosition";
    8989const char* UIExtraDataDefs::GUI_LastScaleWindowPosition = "GUI/LastScaleWindowPosition";
    9090const char* UIExtraDataDefs::GUI_Geometry_State_Max = "max";
    91 #ifndef Q_WS_MAC
     91#ifndef VBOX_WS_MAC
    9292const char* UIExtraDataDefs::GUI_MenuBar_Enabled = "GUI/MenuBar/Enabled";
    93 #endif /* !Q_WS_MAC */
     93#endif /* !VBOX_WS_MAC */
    9494const char* UIExtraDataDefs::GUI_RestrictedRuntimeMenus = "GUI/RestrictedRuntimeMenus";
    9595const char* UIExtraDataDefs::GUI_RestrictedRuntimeApplicationMenuActions = "GUI/RestrictedRuntimeApplicationMenuActions";
    … …  
    101101const char* UIExtraDataDefs::GUI_RestrictedRuntimeDebuggerMenuActions = "GUI/RestrictedRuntimeDebuggerMenuActions";
    102102#endif /* VBOX_WITH_DEBUGGER_GUI */
    103 #ifdef Q_WS_MAC
     103#ifdef VBOX_WS_MAC
    104104const char* UIExtraDataDefs::GUI_RestrictedRuntimeWindowMenuActions = "GUI/RestrictedRuntimeWindowMenuActions";
    105 #endif /* Q_WS_MAC */
     105#endif /* VBOX_WS_MAC */
    106106const char* UIExtraDataDefs::GUI_RestrictedRuntimeHelpMenuActions = "GUI/RestrictedRuntimeHelpMenuActions";
    107107const char* UIExtraDataDefs::GUI_RestrictedVisualStates = "GUI/RestrictedVisualStates";
    … …  
    109109const char* UIExtraDataDefs::GUI_Seamless = "GUI/Seamless";
    110110const char* UIExtraDataDefs::GUI_Scale = "GUI/Scale";
    111 #ifdef Q_WS_X11
     111#ifdef VBOX_WS_X11
    112112const char* UIExtraDataDefs::GUI_Fullscreen_LegacyMode = "GUI/Fullscreen/LegacyMode";
    113 #endif /* Q_WS_X11 */
     113#endif /* VBOX_WS_X11 */
    114114const char* UIExtraDataDefs::GUI_AutoresizeGuest = "GUI/AutoresizeGuest";
    115115const char* UIExtraDataDefs::GUI_LastVisibilityStatusForGuestScreen = "GUI/LastVisibilityStatusForGuestScreen";
    … …  
    126126const char* UIExtraDataDefs::GUI_HiDPI_UnscaledOutput = "GUI/HiDPI/UnscaledOutput";
    127127const char* UIExtraDataDefs::GUI_HiDPI_Optimization = "GUI/HiDPI/Optimization";
    128 #ifndef Q_WS_MAC
     128#ifndef VBOX_WS_MAC
    129129const char* UIExtraDataDefs::GUI_ShowMiniToolBar = "GUI/ShowMiniToolBar";
    130130const char* UIExtraDataDefs::GUI_MiniToolBarAutoHide = "GUI/MiniToolBarAutoHide";
    131131const char* UIExtraDataDefs::GUI_MiniToolBarAlignment = "GUI/MiniToolBarAlignment";
    132 #endif /* !Q_WS_MAC */
     132#endif /* !VBOX_WS_MAC */
    133133const char* UIExtraDataDefs::GUI_StatusBar_Enabled = "GUI/StatusBar/Enabled";
    134134const char* UIExtraDataDefs::GUI_RestrictedStatusBarIndicators = "GUI/RestrictedStatusBarIndicators";
    135135const char* UIExtraDataDefs::GUI_StatusBar_IndicatorOrder = "GUI/StatusBar/IndicatorOrder";
    136 #ifdef Q_WS_MAC
     136#ifdef VBOX_WS_MAC
    137137const char* UIExtraDataDefs::GUI_RealtimeDockIconUpdateEnabled = "GUI/RealtimeDockIconUpdateEnabled";
    138138const char* UIExtraDataDefs::GUI_RealtimeDockIconUpdateMonitor = "GUI/RealtimeDockIconUpdateMonitor";
    139139const char* UIExtraDataDefs::GUI_DockIconDisableOverlay = "GUI/DockIconDisableOverlay";
    140 #endif /* Q_WS_MAC */
     140#endif /* VBOX_WS_MAC */
    141141const char* UIExtraDataDefs::GUI_PassCAD = "GUI/PassCAD";
    142142const char* UIExtraDataDefs::GUI_MouseCapturePolicy = "GUI/MouseCapturePolicy";

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataDefs.h

    r60260 r60362  
    140140        /** Holds whether this machine is first time started. */
    141141        extern const char* GUI_FirstRun;
    142 #ifndef Q_WS_MAC
     142#ifndef VBOX_WS_MAC
    143143        /** Except Mac OS X: Holds redefined machine-window icon names. */
    144144        extern const char* GUI_MachineWindowIcons;
    145145        /** Except Mac OS X: Holds redefined machine-window name postfix. */
    146146        extern const char* GUI_MachineWindowNamePostfix;
    147 #endif /* !Q_WS_MAC */
     147#endif /* !VBOX_WS_MAC */
    148148        /** Prefix used by composite extra-data keys,
    149149          * which holds normal machine-window geometry per screen-index. */
    … …  
    154154        /** Holds machine-window geometry maximized state flag. */
    155155        extern const char* GUI_Geometry_State_Max;
    156 #ifndef Q_WS_MAC
     156#ifndef VBOX_WS_MAC
    157157        /** Holds Runtime UI menu-bar availability status. */
    158158        extern const char* GUI_MenuBar_Enabled;
    159 #endif /* !Q_WS_MAC */
     159#endif /* !VBOX_WS_MAC */
    160160        /** Holds restricted Runtime UI menu types. */
    161161        extern const char* GUI_RestrictedRuntimeMenus;
    … …  
    174174        extern const char* GUI_RestrictedRuntimeDebuggerMenuActions;
    175175#endif /* VBOX_WITH_DEBUGGER_GUI */
    176 #ifdef Q_WS_MAC
     176#ifdef VBOX_WS_MAC
    177177        /** Mac OS X: Holds restricted Runtime UI action types for 'Window' menu. */
    178178        extern const char* GUI_RestrictedRuntimeWindowMenuActions;
    179 #endif /* Q_WS_MAC */
     179#endif /* VBOX_WS_MAC */
    180180        /** Holds restricted Runtime UI action types for Help menu. */
    181181        extern const char* GUI_RestrictedRuntimeHelpMenuActions;
    … …  
    188188        /** Holds whether scaled visual-state is requested. */
    189189        extern const char* GUI_Scale;
    190 #ifdef Q_WS_X11
     190#ifdef VBOX_WS_X11
    191191        /** Holds whether legacy full-screen mode is requested. */
    192192        extern const char* GUI_Fullscreen_LegacyMode;
    193 #endif /* Q_WS_X11 */
     193#endif /* VBOX_WS_X11 */
    194194        /** Holds whether guest-screen auto-resize according machine-window size is enabled. */
    195195        extern const char* GUI_AutoresizeGuest;
    … …  
    221221        /** Holds Runtime UI HiDPI optimization type. */
    222222        extern const char* GUI_HiDPI_Optimization;
    223 #ifndef Q_WS_MAC
     223#ifndef VBOX_WS_MAC
    224224        /** Holds whether mini-toolbar is enabled for full and seamless screens. */
    225225        extern const char* GUI_ShowMiniToolBar;
    … …  
    228228        /** Holds mini-toolbar alignment. */
    229229        extern const char* GUI_MiniToolBarAlignment;
    230 #endif /* !Q_WS_MAC */
     230#endif /* !VBOX_WS_MAC */
    231231        /** Holds Runtime UI status-bar availability status. */
    232232        extern const char* GUI_StatusBar_Enabled;
    … …  
    235235        /** Holds Runtime UI status-bar indicator order. */
    236236        extern const char* GUI_StatusBar_IndicatorOrder;
    237 #ifdef Q_WS_MAC
     237#ifdef VBOX_WS_MAC
    238238        /** Mac OS X: Holds whether Dock icon should be updated at runtime. */
    239239        extern const char* GUI_RealtimeDockIconUpdateEnabled;
    … …  
    242242        /** Mac OS X: Holds whether Dock icon should have overlay disabled. */
    243243        extern const char* GUI_DockIconDisableOverlay;
    244 #endif /* Q_WS_MAC */
     244#endif /* VBOX_WS_MAC */
    245245        /** Holds whether machine should pass CAD to guest. */
    246246        extern const char* GUI_PassCAD;
    … …  
    426426        RuntimeMenuInputActionType_KeyboardSettings  = RT_BIT(1),
    427427        RuntimeMenuInputActionType_TypeCAD           = RT_BIT(2),
    428 #ifdef Q_WS_X11
     428#ifdef VBOX_WS_X11
    429429        RuntimeMenuInputActionType_TypeCABS          = RT_BIT(3),
    430 #endif /* Q_WS_X11 */
     430#endif /* VBOX_WS_X11 */
    431431        RuntimeMenuInputActionType_TypeCtrlBreak     = RT_BIT(4),
    432432        RuntimeMenuInputActionType_TypeInsert        = RT_BIT(5),
    … …  
    662662};
    663663
    664 #ifndef Q_WS_MAC
     664#ifndef VBOX_WS_MAC
    665665/** Runtime UI: Mini-toolbar alignment. */
    666666enum MiniToolbarAlignment
    … …  
    669669    MiniToolbarAlignment_Top
    670670};
    671 #endif /* !Q_WS_MAC */
     671#endif /* !VBOX_WS_MAC */
    672672
    673673/** Runtime UI: Information-element types. */

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp

    r60260 r60362  
    13401340void UIExtraDataManagerWindow::prepareThis()
    13411341{
    1342 #ifndef Q_WS_MAC
     1342#ifndef VBOX_WS_MAC
    13431343    /* Apply window icons: */
    13441344    setWindowIcon(UIIconPool::iconSetFull(":/edataman_32px.png",
    13451345                                          ":/edataman_16px.png"));
    1346 #endif /* !Q_WS_MAC */
     1346#endif /* !VBOX_WS_MAC */
    13471347
    13481348    /* Apply window title: */
    … …  
    14281428                         m_pMainLayout == centralWidget()->layout());
    14291429        {
    1430 #ifdef Q_WS_MAC
     1430#ifdef VBOX_WS_MAC
    14311431            /* No spacing/margins on the Mac: */
    14321432            m_pMainLayout->setContentsMargins(0, 0, 0, 0);
    14331433            m_pMainLayout->insertSpacing(0, 10);
    1434 #else /* !Q_WS_MAC */
     1434#else /* !VBOX_WS_MAC */
    14351435            /* Set spacing/margin like in the selector window: */
    14361436            m_pMainLayout->setSpacing(5);
    14371437            m_pMainLayout->setContentsMargins(5, 5, 5, 5);
    1438 #endif /* !Q_WS_MAC */
     1438#endif /* !VBOX_WS_MAC */
    14391439            /* Prepare tool-bar: */
    14401440            prepareToolBar();
    … …  
    14661466        m_pToolBar->addAction(m_pActionSave);
    14671467        /* Integrate tool-bar into dialog: */
    1468 #ifdef Q_WS_MAC
     1468#ifdef VBOX_WS_MAC
    14691469        /* Enable unified tool-bars on Mac OS X. Available on Qt >= 4.3: */
    14701470        addToolBar(m_pToolBar);
    14711471        m_pToolBar->enableMacToolbar();
    1472 #else /* !Q_WS_MAC */
     1472#else /* !VBOX_WS_MAC */
    14731473        /* Add tool-bar into main-layout: */
    14741474        m_pMainLayout->addWidget(m_pToolBar);
    1475 #endif /* !Q_WS_MAC */
     1475#endif /* !VBOX_WS_MAC */
    14761476    }
    14771477}
    … …  
    16741674        /* Load geometry: */
    16751675        m_geometry = gEDataManager->extraDataManagerGeometry(this);
    1676 #ifdef Q_WS_MAC
     1676#ifdef VBOX_WS_MAC
    16771677        move(m_geometry.topLeft());
    16781678        resize(m_geometry.size());
    1679 #else /* Q_WS_MAC */
     1679#else /* VBOX_WS_MAC */
    16801680        setGeometry(m_geometry);
    1681 #endif /* !Q_WS_MAC */
     1681#endif /* !VBOX_WS_MAC */
    16821682        LogRel2(("GUI: UIExtraDataManagerWindow: Geometry loaded to: Origin=%dx%d, Size=%dx%d\n",
    16831683                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    17041704    {
    17051705        /* Save geometry: */
    1706 #ifdef Q_WS_MAC
     1706#ifdef VBOX_WS_MAC
    17071707        gEDataManager->setExtraDataManagerGeometry(m_geometry, ::darwinIsWindowMaximized(this));
    1708 #else /* Q_WS_MAC */
     1708#else /* VBOX_WS_MAC */
    17091709        gEDataManager->setExtraDataManagerGeometry(m_geometry, isMaximized());
    1710 #endif /* !Q_WS_MAC */
     1710#endif /* !VBOX_WS_MAC */
    17111711        LogRel2(("GUI: UIExtraDataManagerWindow: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
    17121712                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    17421742            if (isVisible() && (windowState() & (Qt::WindowMaximized | Qt::WindowMinimized | Qt::WindowFullScreen)) == 0)
    17431743            {
    1744 #ifdef Q_WS_MAC
     1744#ifdef VBOX_WS_MAC
    17451745                QMoveEvent *pMoveEvent = static_cast<QMoveEvent*>(pEvent);
    17461746                m_geometry.moveTo(pMoveEvent->pos());
    1747 #else /* !Q_WS_MAC */
     1747#else /* !VBOX_WS_MAC */
    17481748                m_geometry.moveTo(geometry().x(), geometry().y());
    1749 #endif /* !Q_WS_MAC */
     1749#endif /* !VBOX_WS_MAC */
    17501750            }
    17511751            break;
    … …  
    19571957           << GUI_PreventReconfiguration << GUI_PreventSnapshotOperations
    19581958           << GUI_FirstRun
    1959 #ifndef Q_WS_MAC
     1959#ifndef VBOX_WS_MAC
    19601960           << GUI_MachineWindowIcons << GUI_MachineWindowNamePostfix
    1961 #endif /* !Q_WS_MAC */
     1961#endif /* !VBOX_WS_MAC */
    19621962           << GUI_LastNormalWindowPosition << GUI_LastScaleWindowPosition
    19631963           << GUI_RestrictedRuntimeMenus
    … …  
    19701970           << GUI_RestrictedRuntimeDebuggerMenuActions
    19711971#endif /* VBOX_WITH_DEBUGGER_GUI */
    1972 #ifdef Q_WS_MAC
     1972#ifdef VBOX_WS_MAC
    19731973           << GUI_RestrictedRuntimeWindowMenuActions
    1974 #endif /* Q_WS_MAC */
     1974#endif /* VBOX_WS_MAC */
    19751975           << GUI_RestrictedRuntimeHelpMenuActions
    19761976           << GUI_RestrictedVisualStates
    19771977           << GUI_Fullscreen << GUI_Seamless << GUI_Scale
    1978 #ifdef Q_WS_X11
     1978#ifdef VBOX_WS_X11
    19791979           << GUI_Fullscreen_LegacyMode
    1980 #endif /* Q_WS_X11 */
     1980#endif /* VBOX_WS_X11 */
    19811981           << GUI_AutoresizeGuest << GUI_LastVisibilityStatusForGuestScreen << GUI_LastGuestSizeHint
    19821982           << GUI_VirtualScreenToHostScreen << GUI_AutomountGuestScreens
    … …  
    19881988           << GUI_HiDPI_UnscaledOutput
    19891989           << GUI_HiDPI_Optimization
    1990 #ifndef Q_WS_MAC
     1990#ifndef VBOX_WS_MAC
    19911991           << GUI_ShowMiniToolBar << GUI_MiniToolBarAutoHide << GUI_MiniToolBarAlignment
    1992 #endif /* !Q_WS_MAC */
     1992#endif /* !VBOX_WS_MAC */
    19931993           << GUI_StatusBar_Enabled << GUI_RestrictedStatusBarIndicators << GUI_StatusBar_IndicatorOrder
    1994 #ifdef Q_WS_MAC
     1994#ifdef VBOX_WS_MAC
    19951995           << GUI_RealtimeDockIconUpdateEnabled << GUI_RealtimeDockIconUpdateMonitor << GUI_DockIconDisableOverlay
    1996 #endif /* Q_WS_MAC */
     1996#endif /* VBOX_WS_MAC */
    19971997           << GUI_PassCAD
    19981998           << GUI_MouseCapturePolicy
    … …  
    24812481
    24822482    /* In Windows Qt fails to reposition out of screen window properly, so doing it ourselves: */
    2483 #ifdef Q_WS_WIN
     2483#ifdef VBOX_WS_WIN
    24842484    /* Make sure resulting geometry is within current bounds: */
    24852485    if (fOk && !availableGeometry.contains(geometry))
    24862486        geometry = VBoxGlobal::getNormalized(geometry, QRegion(availableGeometry));
    2487 #endif /* Q_WS_WIN */
     2487#endif /* VBOX_WS_WIN */
    24882488
    24892489    /* As final fallback, move default-geometry to available-geometry' center: */
    … …  
    27122712}
    27132713
    2714 #ifndef Q_WS_MAC
     2714#ifndef VBOX_WS_MAC
    27152715QStringList UIExtraDataManager::machineWindowIconNames(const QString &strID)
    27162716{
    … …  
    27222722    return extraDataString(GUI_MachineWindowNamePostfix, strID);
    27232723}
    2724 #endif /* !Q_WS_MAC */
     2724#endif /* !VBOX_WS_MAC */
    27252725
    27262726QRect UIExtraDataManager::machineWindowGeometry(UIVisualStateType visualStateType, ulong uScreenIndex, const QString &strID)
    … …  
    28002800}
    28012801
    2802 #ifndef Q_WS_MAC
     2802#ifndef VBOX_WS_MAC
    28032803bool UIExtraDataManager::menuBarEnabled(const QString &strID)
    28042804{
    … …  
    28122812    setExtraDataString(GUI_MenuBar_Enabled, toFeatureRestricted(!fEnabled), strID);
    28132813}
    2814 #endif /* !Q_WS_MAC */
     2814#endif /* !VBOX_WS_MAC */
    28152815
    28162816UIExtraDataMetaDefs::MenuType UIExtraDataManager::restrictedRuntimeMenuTypes(const QString &strID)
    … …  
    31763176#endif /* VBOX_WITH_DEBUGGER_GUI */
    31773177
    3178 #ifdef Q_WS_MAC
     3178#ifdef VBOX_WS_MAC
    31793179UIExtraDataMetaDefs::MenuWindowActionType UIExtraDataManager::restrictedRuntimeMenuWindowActionTypes(const QString &strID)
    31803180{
    … …  
    32233223    setExtraDataStringList(GUI_RestrictedRuntimeWindowMenuActions, result, strID);
    32243224}
    3225 #endif /* Q_WS_MAC */
     3225#endif /* VBOX_WS_MAC */
    32263226
    32273227UIExtraDataMetaDefs::MenuHelpActionType UIExtraDataManager::restrictedRuntimeMenuHelpActionTypes(const QString &strID)
    … …  
    33023302}
    33033303
    3304 #ifdef Q_WS_X11
     3304#ifdef VBOX_WS_X11
    33053305bool UIExtraDataManager::legacyFullscreenModeRequested()
    33063306{
    … …  
    33083308    return isFeatureAllowed(GUI_Fullscreen_LegacyMode);
    33093309}
    3310 #endif /* Q_WS_X11 */
     3310#endif /* VBOX_WS_X11 */
    33113311
    33123312bool UIExtraDataManager::guestScreenAutoResizeEnabled(const QString &strID)
    … …  
    34623462}
    34633463
    3464 #ifndef Q_WS_MAC
     3464#ifndef VBOX_WS_MAC
    34653465bool UIExtraDataManager::miniToolbarEnabled(const QString &strID)
    34663466{
    … …  
    35083508    setExtraDataString(GUI_MiniToolBarAlignment, QString(), strID);
    35093509}
    3510 #endif /* Q_WS_MAC */
     3510#endif /* VBOX_WS_MAC */
    35113511
    35123512bool UIExtraDataManager::statusBarEnabled(const QString &strID)
    … …  
    35743574}
    35753575
    3576 #ifdef Q_WS_MAC
     3576#ifdef VBOX_WS_MAC
    35773577bool UIExtraDataManager::realtimeDockIconUpdateEnabled(const QString &strID)
    35783578{
    … …  
    36083608    setExtraDataString(GUI_DockIconDisableOverlay, toFeatureAllowed(fDisabled), strID);
    36093609}
    3610 #endif /* Q_WS_MAC */
     3610#endif /* VBOX_WS_MAC */
    36113611
    36123612bool UIExtraDataManager::passCADtoGuest(const QString &strID)
    … …  
    36933693
    36943694    /* In Windows Qt fails to reposition out of screen window properly, so doing it ourselves: */
    3695 #ifdef Q_WS_WIN
     3695#ifdef VBOX_WS_WIN
    36963696    /* Make sure resulting geometry is within current bounds: */
    36973697    if (fOk && !availableGeometry.contains(geometry))
    36983698        geometry = VBoxGlobal::getNormalized(geometry, QRegion(availableGeometry));
    3699 #endif /* Q_WS_WIN */
     3699#endif /* VBOX_WS_WIN */
    37003700
    37013701    /* As a fallback, move default-geometry to pParentWidget' geometry center: */
    … …  
    38523852
    38533853    /* In Windows Qt fails to reposition out of screen window properly, so doing it ourselves: */
    3854 #ifdef Q_WS_WIN
     3854#ifdef VBOX_WS_WIN
    38553855    /* Make sure resulting geometry is within current bounds: */
    38563856    if (fOk && !availableGeometry.contains(geometry))
    38573857        geometry = VBoxGlobal::getNormalized(geometry, QRegion(availableGeometry));
    3858 #endif /* Q_WS_WIN */
     3858#endif /* VBOX_WS_WIN */
    38593859
    38603860    /* As final fallback, move default-geometry to available-geometry' center: */
    … …  
    39653965
    39663966    /* In Windows Qt fails to reposition out of screen window properly, so doing it ourselves: */
    3967 #ifdef Q_WS_WIN
     3967#ifdef VBOX_WS_WIN
    39683968    /* Get available-geometry [of screen with point (iX, iY) if possible]: */
    39693969    const QRect availableGeometry = fOk ? vboxGlobal().availableGeometry(QPoint(iX, iY)) :
    … …  
    39733973    if (!availableGeometry.contains(geometry))
    39743974        geometry = VBoxGlobal::getNormalized(geometry, QRegion(availableGeometry));
    3975 #endif /* Q_WS_WIN */
     3975#endif /* VBOX_WS_WIN */
    39763976
    39773977    /* Return result: */
    … …  
    40404040            if (strKey == GUI_HidLedsSync)
    40414041                emit sigHidLedsSyncStateChange(!isFeatureRestricted(strKey, strMachineID));
    4042 #ifdef Q_WS_MAC
     4042#ifdef VBOX_WS_MAC
    40434043            /* 'Dock icon' appearance changed (allowed if not restricted)? */
    40444044            else if (strKey == GUI_RealtimeDockIconUpdateEnabled ||
    … …  
    40484048            else if (strKey == GUI_DockIconDisableOverlay)
    40494049                emit sigDockIconOverlayAppearanceChange(isFeatureAllowed(strKey, strMachineID));
    4050 #endif /* Q_WS_MAC */
     4050#endif /* VBOX_WS_MAC */
    40514051        }
    40524052
    40534053        /* Menu-bar configuration change: */
    40544054        if (
    4055 #ifndef Q_WS_MAC
     4055#ifndef VBOX_WS_MAC
    40564056            strKey == GUI_MenuBar_Enabled ||
    4057 #endif /* !Q_WS_MAC */
     4057#endif /* !VBOX_WS_MAC */
    40584058            strKey == GUI_RestrictedRuntimeMenus ||
    40594059            strKey == GUI_RestrictedRuntimeApplicationMenuActions ||
    … …  
    40654065            strKey == GUI_RestrictedRuntimeDebuggerMenuActions ||
    40664066#endif /* VBOX_WITH_DEBUGGER_GUI */
    4067 #ifdef Q_WS_MAC
     4067#ifdef VBOX_WS_MAC
    40684068            strKey == GUI_RestrictedRuntimeWindowMenuActions ||
    4069 #endif /* Q_WS_MAC */
     4069#endif /* VBOX_WS_MAC */
    40704070            strKey == GUI_RestrictedRuntimeHelpMenuActions)
    40714071            emit sigMenuBarConfigurationChange(strMachineID);

  • trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.h

    r60260 r60362  
    298298        void setMachineFirstTimeStarted(bool fFirstTimeStarted, const QString &strID);
    299299
    300 #ifndef Q_WS_MAC
     300#ifndef VBOX_WS_MAC
    301301        /** Except Mac OS X: Returns redefined machine-window icon names. */
    302302        QStringList machineWindowIconNames(const QString &strID);
    303303        /** Except Mac OS X: Returns redefined machine-window name postfix. */
    304304        QString machineWindowNamePostfix(const QString &strID);
    305 #endif /* !Q_WS_MAC */
     305#endif /* !VBOX_WS_MAC */
    306306
    307307        /** Returns geometry for machine-window with @a uScreenIndex in @a visualStateType. */
    … …  
    312312        void setMachineWindowGeometry(UIVisualStateType visualStateType, ulong uScreenIndex, const QRect &geometry, bool fMaximized, const QString &strID);
    313313
    314 #ifndef Q_WS_MAC
     314#ifndef VBOX_WS_MAC
    315315        /** Returns whether Runtime UI menu-bar is enabled. */
    316316        bool menuBarEnabled(const QString &strID);
    317317        /** Defines whether Runtime UI menu-bar is @a fEnabled. */
    318318        void setMenuBarEnabled(bool fEnabled, const QString &strID);
    319 #endif /* !Q_WS_MAC */
     319#endif /* !VBOX_WS_MAC */
    320320
    321321        /** Returns restricted Runtime UI menu types. */
    … …  
    356356#endif /* VBOX_WITH_DEBUGGER_GUI */
    357357
    358 #ifdef Q_WS_MAC
     358#ifdef VBOX_WS_MAC
    359359        /** Mac OS X: Returns restricted Runtime UI action types for Window menu. */
    360360        UIExtraDataMetaDefs::MenuWindowActionType restrictedRuntimeMenuWindowActionTypes(const QString &strID);
    361361        /** Mac OS X: Defines restricted Runtime UI action types for Window menu. */
    362362        void setRestrictedRuntimeMenuWindowActionTypes(UIExtraDataMetaDefs::MenuWindowActionType types, const QString &strID);
    363 #endif /* Q_WS_MAC */
     363#endif /* VBOX_WS_MAC */
    364364
    365365        /** Returns restricted Runtime UI action types for Help menu. */
    … …  
    376376        void setRequestedVisualState(UIVisualStateType visualState, const QString &strID);
    377377
    378 #ifdef Q_WS_X11
     378#ifdef VBOX_WS_X11
    379379        /** Returns whether legacy full-screen mode is requested. */
    380380        bool legacyFullscreenModeRequested();
    381 #endif /* Q_WS_X11 */
     381#endif /* VBOX_WS_X11 */
    382382
    383383        /** Returns whether guest-screen auto-resize according machine-window size is enabled. */
    … …  
    425425        HiDPIOptimizationType hiDPIOptimizationType(const QString &strID);
    426426
    427 #ifndef Q_WS_MAC
     427#ifndef VBOX_WS_MAC
    428428        /** Returns whether mini-toolbar is enabled for full and seamless screens. */
    429429        bool miniToolbarEnabled(const QString &strID);
    … …  
    440440        /** Returns mini-toolbar @a alignment. */
    441441        void setMiniToolbarAlignment(Qt::AlignmentFlag alignment, const QString &strID);
    442 #endif /* Q_WS_MAC */
     442#endif /* VBOX_WS_MAC */
    443443
    444444        /** Returns whether Runtime UI status-bar is enabled. */
    … …  
    457457        void setStatusBarIndicatorOrder(const QList<IndicatorType> &list, const QString &strID);
    458458
    459 #ifdef Q_WS_MAC
     459#ifdef VBOX_WS_MAC
    460460        /** Mac OS X: Returns whether Dock icon should be updated at runtime. */
    461461        bool realtimeDockIconUpdateEnabled(const QString &strID);
    … …  
    472472        /** Mac OS X: Defines whether Dock icon overlay is @a fDisabled. */
    473473        void setDockIconDisableOverlay(bool fDisabled, const QString &strID);
    474 #endif /* Q_WS_MAC */
     474#endif /* VBOX_WS_MAC */
    475475
    476476        /** Returns whether machine should pass CAD to guest. */

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

    r57880 r60362  
    6666UIMenu::UIMenu()
    6767    : m_fShowToolTip(false)
    68 #ifdef Q_WS_MAC
     68#ifdef VBOX_WS_MAC
    6969    , m_fConsumable(false)
    7070    , m_fConsumed(false)
    71 #endif /* Q_WS_MAC */
     71#endif /* VBOX_WS_MAC */
    7272{
    7373}
    … …  
    926926}
    927927
    928 #ifdef Q_WS_MAC
     928#ifdef VBOX_WS_MAC
    929929bool UIActionPool::isAllowedInMenuWindow(UIExtraDataMetaDefs::MenuWindowActionType type) const
    930930{
    … …  
    940940    m_invalidations << UIActionIndex_M_Window;
    941941}
    942 #endif /* Q_WS_MAC */
     942#endif /* VBOX_WS_MAC */
    943943
    944944bool UIActionPool::isAllowedInMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType type) const

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

    r55415 r60362  
    108108    void setShowToolTip(bool fShowToolTips) { m_fShowToolTip = fShowToolTips; }
    109109
    110 #ifdef Q_WS_MAC
     110#ifdef VBOX_WS_MAC
    111111    /** Mac OS X: Returns whether this menu is consumable by the menu-bar. */
    112112    bool isConsumable() const { return m_fConsumable; }
    … …  
    118118    /** Mac OS X: Defines whether this menu is @a fConsumed by the menu-bar. */
    119119    void setConsumed(bool fConsumed) { m_fConsumed = fConsumed; }
    120 #endif /* Q_WS_MAC */
     120#endif /* VBOX_WS_MAC */
    121121
    122122protected:
    … …  
    130130    bool m_fShowToolTip;
    131131
    132 #ifdef Q_WS_MAC
     132#ifdef VBOX_WS_MAC
    133133    /** Mac OS X: Holds whether this menu can be consumed by the menu-bar. */
    134134    bool m_fConsumable;
    135135    /** Mac OS X: Holds whether this menu is consumed by the menu-bar. */
    136136    bool m_fConsumed;
    137 #endif /* Q_WS_MAC */
     137#endif /* VBOX_WS_MAC */
    138138};
    139139
    … …  
    430430    void setRestrictionForMenuApplication(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuApplicationActionType restriction);
    431431
    432 #ifdef Q_WS_MAC
     432#ifdef VBOX_WS_MAC
    433433    /** Mac OS X: Returns whether the action with passed @a type is allowed in the 'Window' menu. */
    434434    bool isAllowedInMenuWindow(UIExtraDataMetaDefs::MenuWindowActionType type) const;
    435435    /** Mac OS X: Defines 'Window' menu @a restriction for passed @a level. */
    436436    void setRestrictionForMenuWindow(UIActionRestrictionLevel level, UIExtraDataMetaDefs::MenuWindowActionType restriction);
    437 #endif /* Q_WS_MAC */
     437#endif /* VBOX_WS_MAC */
    438438
    439439    /** Returns whether the action with passed @a type is allowed in the 'Help' menu. */
    … …  
    523523    /** Holds restricted action types of the 'Application' menu. */
    524524    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::MenuApplicationActionType> m_restrictedActionsMenuApplication;
    525 #ifdef Q_WS_MAC
     525#ifdef VBOX_WS_MAC
    526526    /** Mac OS X: Holds restricted action types of the 'Window' menu. */
    527527    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::MenuWindowActionType> m_restrictedActionsMenuWindow;
    528 #endif /* Q_WS_MAC */
     528#endif /* VBOX_WS_MAC */
    529529    /** Holds restricted action types of the Help menu. */
    530530    QMap<UIActionRestrictionLevel, UIExtraDataMetaDefs::MenuHelpActionType> m_restrictedActionsMenuHelp;

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

    r59094 r60362  
    5959        , SetRegionEventType
    6060        , ModifierKeyChangeEventType
    61 #ifdef Q_WS_WIN
     61#ifdef VBOX_WS_WIN
    6262        , ShellExecuteEventType
    63 #endif /* Q_WS_WIN */
     63#endif /* VBOX_WS_WIN */
    6464        , ActivateActionEventType
    65 #ifdef Q_WS_MAC
     65#ifdef VBOX_WS_MAC
    6666        , ShowWindowEventType
    67 #endif /* Q_WS_MAC */
     67#endif /* VBOX_WS_MAC */
    6868        , AddVDMUrlsEventType
    6969#ifdef VBOX_GUI_USE_QGL
    … …  
    9090using namespace UIDefs /* if header included */;
    9191
    92 #ifdef Q_WS_MAC
     92#ifdef VBOX_WS_MAC
    9393/** Mac OS X: Known OS releases. */
    9494enum MacOSXRelease
    … …  
    103103    MacOSXRelease_New,
    104104};
    105 #endif /* Q_WS_MAC */
     105#endif /* VBOX_WS_MAC */
    106106
    107107/** Common UI: Size suffixes. */

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

    r58880 r60362  
    6464    /* Apply visual and mouse-event mask for that 1 pixel: */
    6565    setMask(QRect(0, 0, 1, 1));
    66 #ifdef Q_WS_X11
     66#ifdef VBOX_WS_X11
    6767    /* For composite WMs make this 1 pixel transparent: */
    6868    if (vboxGlobal().isCompositingManagerRunning())
    6969        setAttribute(Qt::WA_TranslucentBackground);
    70 #else /* !Q_WS_X11 */
     70#else /* !VBOX_WS_X11 */
    7171    /* Make this 1 pixel transparent: */
    7272    setAttribute(Qt::WA_TranslucentBackground);
    73 #endif /* !Q_WS_X11 */
     73#endif /* !VBOX_WS_X11 */
    7474}
    7575

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

    r58603 r60362  
    175175        case UIDefaultIconType_MessageBoxWarning:
    176176        {
    177 #ifdef Q_WS_MAC
     177#ifdef VBOX_WS_MAC
    178178            /* At least in Qt 4.3.4/4.4 RC1 SP_MessageBoxWarning is the application
    179179             * icon. So change this to the critical icon. (Maybe this would be
    180180             * fixed in a later Qt version) */
    181181            icon = pStyle->standardIcon(QStyle::SP_MessageBoxCritical, 0, pWidget);
    182 #else /* Q_WS_MAC */
     182#else /* VBOX_WS_MAC */
    183183            icon = pStyle->standardIcon(QStyle::SP_MessageBoxWarning, 0, pWidget);
    184 #endif /* !Q_WS_MAC */
     184#endif /* !VBOX_WS_MAC */
    185185            break;
    186186        }
    … …  
    238238    icon.addPixmap(pixmap, mode, state);
    239239
    240 #ifdef Q_WS_MAC
     240#ifdef VBOX_WS_MAC
    241241# ifdef VBOX_GUI_WITH_HIDPI
    242242    /* Test if HiDPI icons are enabled. Works only with a patched version of Qt 4.x
    … …  
    248248    return;
    249249# endif /* !VBOX_GUI_WITH_HIDPI */
    250 #endif /* Q_WS_MAC */
     250#endif /* VBOX_WS_MAC */
    251251
    252252    /* Parse name to prefix and suffix: */

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

    r59911 r60362  
    2626# include <QThread>
    2727# include <QProcess>
    28 # ifdef Q_WS_MAC
     28# ifdef VBOX_WS_MAC
    2929#  include <QPushButton>
    30 # endif /* Q_WS_MAC */
     30# endif /* VBOX_WS_MAC */
    3131
    3232/* GUI includes: */
    … …  
    4949# include "VBoxAboutDlg.h"
    5050# include "UIHostComboEditor.h"
    51 # ifdef Q_WS_MAC
     51# ifdef VBOX_WS_MAC
    5252#  include "VBoxUtils-darwin.h"
    53 # endif /* Q_WS_MAC */
    54 # ifdef Q_WS_WIN
     53# endif /* VBOX_WS_MAC */
     54# ifdef VBOX_WS_WIN
    5555#  include <Htmlhelp.h>
    56 # endif /* Q_WS_WIN */
     56# endif /* VBOX_WS_WIN */
    5757
    5858/* COM includes: */
    … …  
    25042504        errMsg = msg->pszDefine;
    25052505
    2506 #ifdef Q_WS_WIN
     2506#ifdef VBOX_WS_WIN
    25072507    PCRTWINERRMSG winMsg = NULL;
    25082508
    … …  
    25152515            errMsg = winMsg->pszDefine;
    25162516    }
    2517 #endif /* Q_WS_WIN */
     2517#endif /* VBOX_WS_WIN */
    25182518
    25192519    if (errMsg != NULL && *errMsg != '\0')
    … …  
    25402540        errMsg = msg->pszDefine;
    25412541
    2542 #ifdef Q_WS_WIN
     2542#ifdef VBOX_WS_WIN
    25432543    PCRTWINERRMSG winMsg = NULL;
    25442544
    … …  
    25512551            errMsg = winMsg->pszDefine;
    25522552    }
    2553 #endif /* Q_WS_WIN */
     2553#endif /* VBOX_WS_WIN */
    25542554
    25552555    if (errMsg != NULL && *errMsg != '\0')
    … …  
    26752675void UIMessageCenter::sltShowUserManual(const QString &strLocation)
    26762676{
    2677 #if defined (Q_WS_WIN)
     2677#if defined (VBOX_WS_WIN)
    26782678    HtmlHelp(GetDesktopWindow(), strLocation.utf16(), HH_DISPLAY_TOPIC, NULL);
    2679 #elif defined (Q_WS_X11)
     2679#elif defined (VBOX_WS_X11)
    26802680# ifndef VBOX_OSE
    26812681    char szViewerPath[RTPATH_MAX];
    … …  
    26872687    vboxGlobal().openURL("file://" + strLocation);
    26882688# endif /* #ifdef VBOX_OSE */
    2689 #elif defined (Q_WS_MAC)
     2689#elif defined (VBOX_WS_MAC)
    26902690    vboxGlobal().openURL("file://" + strLocation);
    26912691#endif
    … …  
    27842784    if (info.isBasicAvailable())
    27852785    {
    2786 #if defined (Q_WS_WIN)
     2786#if defined (VBOX_WS_WIN)
    27872787        haveResultCode = info.isFullAvailable();
    27882788        bool haveComponent = true;
    27892789        bool haveInterfaceID = true;
    2790 #else /* defined (Q_WS_WIN) */
     2790#else /* defined (VBOX_WS_WIN) */
    27912791        haveResultCode = true;
    27922792        bool haveComponent = info.isFullAvailable();

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

    r60347 r60362  
    3838# include <QLocale>
    3939# include <QSpinBox>
    40 # ifdef Q_WS_WIN
     40# ifdef VBOX_WS_WIN
    4141#  include <QEventLoop>
    42 # endif /* Q_WS_WIN */
    43 # ifdef Q_WS_X11
     42# endif /* VBOX_WS_WIN */
     43# ifdef VBOX_WS_X11
    4444#  include <QTextBrowser>
    4545#  include <QScrollBar>
    4646#  include <QX11Info>
    47 # endif /* Q_WS_X11 */
     47# endif /* VBOX_WS_X11 */
    4848# ifdef VBOX_GUI_WITH_PIDFILE
    4949#  include <QTextStream>
    … …  
    7474# include "UIIconPool.h"
    7575# include "UIVirtualBoxEventHandler.h"
    76 # ifdef Q_WS_X11
     76# ifdef VBOX_WS_X11
    7777#  include "UIHostComboEditor.h"
    7878#  include "UIDesktopWidgetWatchdog.h"
    … …  
    8080#   include "VBoxLicenseViewer.h"
    8181#  endif /* VBOX_OSE */
    82 # endif /* Q_WS_X11 */
    83 # ifdef Q_WS_MAC
     82# endif /* VBOX_WS_X11 */
     83# ifdef VBOX_WS_MAC
    8484#  include "VBoxUtils-darwin.h"
    8585#  include "UIMachineWindowFullscreen.h"
    8686#  include "UIMachineWindowSeamless.h"
    87 # endif /* Q_WS_MAC */
     87# endif /* VBOX_WS_MAC */
    8888# ifdef VBOX_WITH_VIDEOHWACCEL
    8989#  include "VBoxFBOverlay.h"
    … …  
    120120# include <iprt/system.h>
    121121# include <iprt/stream.h>
    122 # ifdef Q_WS_X11
     122# ifdef VBOX_WS_X11
    123123#  include <iprt/mem.h>
    124 # endif /* Q_WS_X11 */
     124# endif /* VBOX_WS_X11 */
    125125# include <VBox/sup.h>
    126126# include <VBox/com/Guid.h>
    127127
    128128/* External includes: */
    129 # ifdef Q_WS_WIN
     129# ifdef VBOX_WS_WIN
    130130#  include "shlobj.h"
    131 # endif /* Q_WS_WIN */
     131# endif /* VBOX_WS_WIN */
    132132
    133133#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    155155/* External includes: */
    156156# include <math.h>
    157 #ifdef Q_WS_MAC
     157#ifdef VBOX_WS_MAC
    158158# include <sys/utsname.h>
    159 #endif /* Q_WS_MAC */
    160 #ifdef Q_WS_X11
     159#endif /* VBOX_WS_MAC */
     160#ifdef VBOX_WS_X11
    161161# undef BOOL /* typedef CARD8 BOOL in Xmd.h conflicts with #define BOOL PRBool
    162162              * in COMDefs.h. A better fix would be to isolate X11-specific
    … …  
    168168# include <X11/extensions/Xinerama.h>
    169169# define BOOL PRBool
    170 #endif /* Q_WS_X11 */
     170#endif /* VBOX_WS_X11 */
    171171
    172172
    … …  
    223223VBoxGlobal::VBoxGlobal()
    224224    : mValid (false)
    225 #ifdef Q_WS_MAC
     225#ifdef VBOX_WS_MAC
    226226    , m_osRelease(MacOSXRelease_Old)
    227 #endif /* Q_WS_MAC */
     227#endif /* VBOX_WS_MAC */
    228228    , m_fWrappersValid(false)
    229229    , m_fVBoxSVCAvailable(true)
    230230    , m_fSeparateProcess(false)
    231231    , m_pMediumEnumerator(0)
    232 #ifdef Q_WS_X11
     232#ifdef VBOX_WS_X11
    233233    , m_fCompositingManagerRunning(false)
    234234    , m_enmWindowManagerType(X11WMType_Unknown)
    235235    , m_pDesktopWidgetWatchdog(0)
    236 #endif /* Q_WS_X11 */
     236#endif /* VBOX_WS_X11 */
    237237#if defined(DEBUG_bird)
    238238    , mAgressiveCaching(false)
    … …  
    308308}
    309309
    310 #ifdef Q_WS_MAC
     310#ifdef VBOX_WS_MAC
    311311/* static */
    312312MacOSXRelease VBoxGlobal::determineOsRelease()
    … …  
    334334    return MacOSXRelease_Old;
    335335}
    336 #endif /* Q_WS_MAC */
     336#endif /* VBOX_WS_MAC */
    337337
    338338int VBoxGlobal::screenCount() const
    … …  
    356356const QRect VBoxGlobal::screenGeometry(int iHostScreenIndex /* = -1 */) const
    357357{
    358 #ifdef Q_WS_X11
     358#ifdef VBOX_WS_X11
    359359    /* Make sure desktop-widget watchdog already created: */
    360360    AssertPtrReturn(m_pDesktopWidgetWatchdog, QApplication::desktop()->screenGeometry(iHostScreenIndex));
    361361    /* Redirect call to UIDesktopWidgetWatchdog: */
    362362    return m_pDesktopWidgetWatchdog->screenGeometry(iHostScreenIndex);
    363 #endif /* Q_WS_X11 */
     363#endif /* VBOX_WS_X11 */
    364364
    365365    /* Redirect call to QDesktopWidget: */
    … …  
    369369const QRect VBoxGlobal::availableGeometry(int iHostScreenIndex /* = -1 */) const
    370370{
    371 #ifdef Q_WS_X11
     371#ifdef VBOX_WS_X11
    372372    /* Make sure desktop-widget watchdog already created: */
    373373    AssertPtrReturn(m_pDesktopWidgetWatchdog, QApplication::desktop()->availableGeometry(iHostScreenIndex));
    374374    /* Redirect call to UIDesktopWidgetWatchdog: */
    375375    return m_pDesktopWidgetWatchdog->availableGeometry(iHostScreenIndex);
    376 #endif /* Q_WS_X11 */
     376#endif /* VBOX_WS_X11 */
    377377
    378378    /* Redirect call to QDesktopWidget: */
    … …  
    501501}
    502502
    503 #ifdef Q_WS_X11
     503#ifdef VBOX_WS_X11
    504504QList<QRect> XGetDesktopList()
    505505{
    … …  
    616616    return result;
    617617}
    618 #endif /* ifdef Q_WS_X11 */
     618#endif /* ifdef VBOX_WS_X11 */
    619619
    620620/**
    … …  
    22002200        startMediumEnumeration();
    22012201
    2202 #ifdef Q_WS_X11
     2202#ifdef VBOX_WS_X11
    22032203    /* As X11 do not have functionality for providing human readable key names,
    22042204     * we keep a table of them, which must be updated when the language is changed. */
    22052205    UINativeHotKey::retranslateKeyNames();
    2206 #endif /* Q_WS_X11 */
     2206#endif /* VBOX_WS_X11 */
    22072207}
    22082208
    … …  
    24132413    if (fResetToC)
    24142414        sLoadedLangId = "C";
    2415 #ifdef Q_WS_MAC
     2415#ifdef VBOX_WS_MAC
    24162416    /* Qt doesn't translate the items in the Application menu initially.
    24172417     * Manually trigger an update. */
    24182418    ::darwinRetranslateAppMenu();
    2419 #endif /* Q_WS_MAC */
     2419#endif /* VBOX_WS_MAC */
    24202420}
    24212421
    24222422QString VBoxGlobal::helpFile() const
    24232423{
    2424 #if defined (Q_WS_WIN)
     2424#if defined (VBOX_WS_WIN)
    24252425    const QString name = "VirtualBox";
    24262426    const QString suffix = "chm";
    2427 #elif defined (Q_WS_MAC)
     2427#elif defined (VBOX_WS_MAC)
    24282428    const QString name = "UserManual";
    24292429    const QString suffix = "pdf";
    2430 #elif defined (Q_WS_X11)
     2430#elif defined (VBOX_WS_X11)
    24312431# if defined VBOX_OSE
    24322432    const QString name = "UserManual";
    … …  
    27252725    /* ensure the widget is within the available desktop area */
    27262726    QRect newGeo = normalizeGeometry (geo, deskGeo, aCanResize);
    2727 #ifdef Q_WS_MAC
     2727#ifdef VBOX_WS_MAC
    27282728    /* No idea why, but Qt doesn't respect if there is a unified toolbar on the
    27292729     * ::move call. So manually add the height of the toolbar before setting
    … …  
    27312731    if (w)
    27322732        newGeo.translate (0, ::darwinWindowToolBarHeight (aWidget));
    2733 #endif /* Q_WS_MAC */
     2733#endif /* VBOX_WS_MAC */
    27342734
    27352735    aWidget->move (newGeo.topLeft());
    … …  
    31513151QString VBoxGlobal::systemLanguageId()
    31523152{
    3153 #if defined (Q_WS_MAC)
     3153#if defined (VBOX_WS_MAC)
    31543154    /* QLocale return the right id only if the user select the format of the
    31553155     * language also. So we use our own implementation */
    … …  
    31673167}
    31683168
    3169 #if defined (Q_WS_X11)
     3169#if defined (VBOX_WS_X11)
    31703170
    31713171static char *XXGetProperty (Display *aDpy, Window aWnd,
    … …  
    32423242    bool result = true;
    32433243
    3244 #if defined (Q_WS_WIN)
     3244#if defined (VBOX_WS_WIN)
    32453245
    32463246    HWND handle = (HWND)aWId;
    … …  
    32533253    result &= !!SetForegroundWindow (handle);
    32543254
    3255 #elif defined (Q_WS_X11)
     3255#elif defined (VBOX_WS_X11)
    32563256
    32573257    Display *dpy = QX11Info::display();
    … …  
    33073307}
    33083308
    3309 #ifdef Q_WS_X11
     3309#ifdef VBOX_WS_X11
    33103310/* This method tests whether the current X11 window manager supports full-screen mode as we need it.
    33113311 * Unfortunately the EWMH specification was not fully clear about whether we can expect to find
    … …  
    34593459    }
    34603460}
    3461 #endif /* Q_WS_X11 */
     3461#endif /* VBOX_WS_X11 */
    34623462
    34633463/**
    … …  
    35013501QString VBoxGlobal::insertKeyToActionText(const QString &strText, const QString &strKey)
    35023502{
    3503 #ifdef Q_WS_MAC
     3503#ifdef VBOX_WS_MAC
    35043504    QString pattern("%1 (Host+%2)");
    35053505#else
    … …  
    39333933        if (args.at(i).startsWith("-"))
    39343934            break;
    3935 #ifdef Q_WS_MAC
     3935#ifdef VBOX_WS_MAC
    39363936        QString strArg = ::darwinResolveAlias(args.at(i));
    3937 #else /* Q_WS_MAC */
     3937#else /* VBOX_WS_MAC */
    39383938        QString strArg = args.at(i);
    3939 #endif /* !Q_WS_MAC */
     3939#endif /* !VBOX_WS_MAC */
    39403940        if (   !strArg.isEmpty()
    39413941            && QFile::exists(strArg))
    … …  
    39753975    connect(qApp, SIGNAL(aboutToQuit()), this, SLOT(cleanup()));
    39763976
    3977 #ifdef Q_WS_MAC
     3977#ifdef VBOX_WS_MAC
    39783978    /* Determine OS release early: */
    39793979    m_osRelease = determineOsRelease();
    3980 #endif /* Q_WS_MAC */
     3980#endif /* VBOX_WS_MAC */
    39813981
    39823982    /* Create message-center: */
    … …  
    40564056    UIVisualStateType visualStateType = UIVisualStateType_Invalid;
    40574057
    4058 #ifdef Q_WS_X11
     4058#ifdef VBOX_WS_X11
    40594059    /* Check whether we have compositing manager running: */
    40604060    m_fCompositingManagerRunning = X11IsCompositingManagerRunning();
    … …  
    40654065    /* Create desktop-widget watchdog instance: */
    40664066    m_pDesktopWidgetWatchdog = new UIDesktopWidgetWatchdog(this);
    4067 #endif /* Q_WS_X11 */
     4067#endif /* VBOX_WS_X11 */
    40684068
    40694069#ifdef VBOX_WITH_DEBUGGER_GUI
    … …  
    47064706bool VBoxGlobal::switchToMachine(CMachine &machine)
    47074707{
    4708 #ifdef Q_WS_MAC
     4708#ifdef VBOX_WS_MAC
    47094709    ULONG64 id = machine.ShowConsoleWindow();
    47104710#else
    … …  
    47204720        return true;
    47214721
    4722 #if defined (Q_WS_WIN) || defined (Q_WS_X11)
     4722#if defined (VBOX_WS_WIN) || defined (VBOX_WS_X11)
    47234723
    47244724    return vboxGlobal().activateWindow(id, true);
    47254725
    4726 #elif defined (Q_WS_MAC)
     4726#elif defined (VBOX_WS_MAC)
    47274727    /*
    47284728     * This is just for the case were the other process cannot steal
    … …  
    47514751        return false;
    47524752
    4753 #if defined (Q_WS_WIN)
     4753#if defined (VBOX_WS_WIN)
    47544754
    47554755    HWND hwnd = mWinId;
    … …  
    47874787    return true;
    47884788
    4789 #elif defined (Q_WS_X11)
     4789#elif defined (VBOX_WS_X11)
    47904790
    47914791    return false;
    47924792
    4793 #elif defined (Q_WS_MAC)
     4793#elif defined (VBOX_WS_MAC)
    47944794
    47954795    ProcessSerialNumber psn;
    … …  
    48494849    AllowSetForegroundWindow(ASFW_ANY);
    48504850#endif /* Q_OS_WIN */
    4851 #ifdef Q_WS_X11
     4851#ifdef VBOX_WS_X11
    48524852    /* Make sure VM process will start on the same display as the VM selector: */
    48534853    const char *pDisplay = RTEnvGet("DISPLAY");
    … …  
    48574857    if (pXauth)
    48584858        strEnv.append(QString("XAUTHORITY=%1\n").arg(pXauth));
    4859 #endif /* Q_WS_X11 */
     4859#endif /* VBOX_WS_X11 */
    48604860    QString strType;
    48614861    switch (enmLaunchMode)

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

    r59887 r60362  
    2727#include <QFileIconProvider>
    2828#include <QReadWriteLock>
    29 #ifdef Q_WS_MAC
     29#ifdef VBOX_WS_MAC
    3030# include <QSet>
    31 #endif /* Q_WS_MAC */
     31#endif /* VBOX_WS_MAC */
    3232
    3333/* GUI includes: */
    … …  
    3535#include "UIMediumDefs.h"
    3636#include "VBoxGlobalSettings.h"
    37 #ifdef Q_WS_X11
     37#ifdef VBOX_WS_X11
    3838# include "VBoxX11Helper.h"
    39 #endif /* Q_WS_X11 */
     39#endif /* VBOX_WS_X11 */
    4040
    4141/* COM includes: */
    … …  
    4848
    4949/* Other includes: */
    50 #ifdef Q_WS_X11
     50#ifdef VBOX_WS_X11
    5151# include <X11/Xdefs.h>
    52 #endif /* Q_WS_X11 */
     52#endif /* VBOX_WS_X11 */
    5353
    5454/* Forward declarations: */
    … …  
    6666class UIIconPoolGeneral;
    6767class UIThreadPool;
    68 #ifdef Q_WS_X11
     68#ifdef VBOX_WS_X11
    6969class UIDesktopWidgetWatchdog;
    70 #endif /* Q_WS_X11 */
     70#endif /* VBOX_WS_X11 */
    7171
    7272// VBoxGlobal class
    … …  
    119119    bool isSeparateProcess() const { return m_fSeparateProcess; }
    120120
    121 #ifdef Q_WS_MAC
     121#ifdef VBOX_WS_MAC
    122122    /** Mac OS X: Returns #MacOSXRelease determined using <i>uname</i> call. */
    123123    static MacOSXRelease determineOsRelease();
    124124    /** Mac OS X: Returns #MacOSXRelease determined during VBoxGlobal prepare routine. */
    125125    MacOSXRelease osRelease() const { return m_osRelease; }
    126 #endif /* Q_WS_MAC */
     126#endif /* VBOX_WS_MAC */
    127127
    128128    /** Try to acquire COM cleanup protection token for reading. */
    … …  
    203203    QList<QUrl> &argUrlList() { return m_ArgUrlList; }
    204204
    205 #ifdef Q_WS_X11
     205#ifdef VBOX_WS_X11
    206206    /** X11: Returns whether the Window Manager we are running at is composition one. */
    207207    bool isCompositingManagerRunning() const { return m_fCompositingManagerRunning; }
    208208    /** X11: Returns the type of the Window Manager we are running under. */
    209209    X11WMType typeOfWindowManager() const { return m_enmWindowManagerType; }
    210 #endif /* Q_WS_X11 */
     210#endif /* VBOX_WS_X11 */
    211211
    212212    /** Returns whether we should restore current snapshot before VM started. */
    … …  
    417417    static bool activateWindow (WId aWId, bool aSwitchDesktop = true);
    418418
    419 #ifdef Q_WS_X11
     419#ifdef VBOX_WS_X11
    420420    /** X11: Test whether the current window manager supports full screen mode. */
    421421    static bool supportsFullScreenMonitorsProtocolX11();
    … …  
    429429    /** X11: Sets _NET_WM_STATE_FULLSCREEN flag for passed @a pWidget. */
    430430    static void setFullScreenFlag(QWidget *pWidget);
    431 #endif /* Q_WS_X11 */
     431#endif /* VBOX_WS_X11 */
    432432
    433433    static QString removeAccelMark (const QString &aText);
    … …  
    528528    bool mValid;
    529529
    530 #ifdef Q_WS_MAC
     530#ifdef VBOX_WS_MAC
    531531    /** Mac OS X: Holds the #MacOSXRelease determined using <i>uname</i> call. */
    532532    MacOSXRelease m_osRelease;
    533 #endif /* Q_WS_MAC */
     533#endif /* VBOX_WS_MAC */
    534534
    535535    /** COM cleanup protection token. */
    … …  
    569569    mutable QReadWriteLock m_mediumEnumeratorDtorRwLock;
    570570
    571 #ifdef Q_WS_X11
     571#ifdef VBOX_WS_X11
    572572    /** X11: Holds whether the Window Manager we are running at is composition one. */
    573573    bool m_fCompositingManagerRunning;
    … …  
    580580        UIDesktopWidgetWatchdog *m_pDesktopWidgetWatchdog;
    581581    /** @} */
    582 #endif /* Q_WS_X11 */
     582#endif /* VBOX_WS_X11 */
    583583
    584584    /** The --aggressive-caching / --no-aggressive-caching option. */
    … …  
    630630#endif
    631631
    632 #if defined (Q_WS_WIN)
     632#if defined (VBOX_WS_WIN)
    633633    DWORD dwHTMLHelpCookie;
    634634#endif

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

    r58866 r60362  
    276276};
    277277
    278 #ifdef Q_WS_MAC
     278#ifdef VBOX_WS_MAC
    279279# include "VBoxUtils-darwin.h"
    280 #endif /* Q_WS_MAC */
     280#endif /* VBOX_WS_MAC */
    281281
    282282#endif // !___VBoxUtils_h___

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

    r59910 r60362  
    2828# include "UISelectorWindow.h"
    2929# include "UIModalWindowManager.h"
    30 # ifdef Q_WS_MAC
     30# ifdef VBOX_WS_MAC
    3131#  include "VBoxUtils.h"
    3232#  include "UICocoaApplication.h"
    33 # endif /* Q_WS_MAC */
     33# endif /* VBOX_WS_MAC */
    3434
    3535/* Other VBox includes: */
    … …  
    4141# else /* !VBOX_WITH_HARDENING */
    4242#  include <iprt/initterm.h>
    43 #  ifdef Q_WS_MAC
     43#  ifdef VBOX_WS_MAC
    4444#   include <iprt/asm.h>
    45 #  endif /* Q_WS_MAC */
     45#  endif /* VBOX_WS_MAC */
    4646# endif /* !VBOX_WITH_HARDENING */
    47 # ifdef Q_WS_X11
     47# ifdef VBOX_WS_X11
    4848#  include <iprt/env.h>
    49 # endif /* Q_WS_X11 */
     49# endif /* VBOX_WS_X11 */
    5050
    5151#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    5252
    5353/* Qt includes: */
    54 #ifdef Q_WS_X11
     54#ifdef VBOX_WS_X11
    5555# ifdef Q_OS_SOLARIS
    5656#  include <QPlastiqueStyle>
    … …  
    5959#  include <QFontDatabase>
    6060# endif /* !Q_OS_SOLARIS */
    61 #endif /* Q_WS_X11 */
     61#endif /* VBOX_WS_X11 */
    6262
    6363/* Other VBox includes: */
    … …  
    6969
    7070/* Other includes: */
    71 #ifdef Q_WS_MAC
     71#ifdef VBOX_WS_MAC
    7272# include <dlfcn.h>
    7373# include <sys/mman.h>
    74 #endif /* Q_WS_MAC */
    75 #ifdef Q_WS_X11
     74#endif /* VBOX_WS_MAC */
     75#ifdef VBOX_WS_X11
    7676# include <dlfcn.h>
    7777# include <unistd.h>
    … …  
    9090#  endif /* !RT_ARCH_AMD64 */
    9191# endif /* RT_OS_LINUX && DEBUG */
    92 #endif /* Q_WS_X11 */
     92#endif /* VBOX_WS_X11 */
    9393
    9494
    … …  
    133133
    134134
    135 #ifdef Q_WS_MAC
     135#ifdef VBOX_WS_MAC
    136136/**
    137137 * Mac OS X: Really ugly hack to bypass a set-uid check in AppKit.
    … …  
    151151        ASMAtomicWriteU32((volatile uint32_t *)pvAddr, 0xccc3c031); /* xor eax, eax; ret; int3 */
    152152}
    153 #endif /* Q_WS_MAC */
    154 
    155 #ifdef Q_WS_X11
     153#endif /* VBOX_WS_MAC */
     154
     155#ifdef VBOX_WS_X11
    156156/** X11: For versions of Xlib which are aware of multi-threaded environments this function
    157157  *      calls for XInitThreads() which initializes Xlib support for concurrent threads.
    … …  
    224224}
    225225# endif /* RT_OS_LINUX && DEBUG */
    226 #endif /* Q_WS_X11 */
     226#endif /* VBOX_WS_X11 */
    227227
    228228#if QT_VERSION >= 0x050000
    … …  
    235235{
    236236    NOREF(context);
    237 # ifndef Q_WS_X11
     237# ifndef VBOX_WS_X11
    238238    NOREF(strMessage);
    239 # endif /* !Q_WS_X11 */
     239# endif /* !VBOX_WS_X11 */
    240240    switch (type)
    241241    {
    … …  
    245245        case QtWarningMsg:
    246246            Log(("Qt WARNING: %s\n", strMessage.toUtf8().constData()));
    247 # ifdef Q_WS_X11
     247# ifdef VBOX_WS_X11
    248248            /* Needed for instance for the message ``cannot connect to X server'': */
    249249            RTStrmPrintf(g_pStdErr, "Qt WARNING: %s\n", strMessage.toUtf8().constData());
    250 # endif /* Q_WS_X11 */
     250# endif /* VBOX_WS_X11 */
    251251            break;
    252252        case QtCriticalMsg:
    253253            Log(("Qt CRITICAL: %s\n", strMessage.toUtf8().constData()));
    254 # ifdef Q_WS_X11
     254# ifdef VBOX_WS_X11
    255255            /* Needed for instance for the message ``cannot connect to X server'': */
    256256            RTStrmPrintf(g_pStdErr, "Qt CRITICAL: %s\n", strMessage.toUtf8().constData());
    257 # endif /* Q_WS_X11 */
     257# endif /* VBOX_WS_X11 */
    258258            break;
    259259        case QtFatalMsg:
    260260            Log(("Qt FATAL: %s\n", strMessage.toUtf8().constData()));
    261 # ifdef Q_WS_X11
     261# ifdef VBOX_WS_X11
    262262            /* Needed for instance for the message ``cannot connect to X server'': */
    263263            RTStrmPrintf(g_pStdErr, "Qt FATAL: %s\n", strMessage.toUtf8().constData());
    264 # endif /* Q_WS_X11 */
     264# endif /* VBOX_WS_X11 */
    265265    }
    266266}
    … …  
    272272static void QtMessageOutput(QtMsgType type, const char *pMsg)
    273273{
    274 # ifndef Q_WS_X11
     274# ifndef VBOX_WS_X11
    275275    NOREF(pMsg);
    276 # endif /* !Q_WS_X11 */
     276# endif /* !VBOX_WS_X11 */
    277277    switch (type)
    278278    {
    … …  
    282282        case QtWarningMsg:
    283283            Log(("Qt WARNING: %s\n", pMsg));
    284 # ifdef Q_WS_X11
     284# ifdef VBOX_WS_X11
    285285            /* Needed for instance for the message ``cannot connect to X server'': */
    286286            RTStrmPrintf(g_pStdErr, "Qt WARNING: %s\n", pMsg);
    287 # endif /* Q_WS_X11 */
     287# endif /* VBOX_WS_X11 */
    288288            break;
    289289        case QtCriticalMsg:
    290290            Log(("Qt CRITICAL: %s\n", pMsg));
    291 # ifdef Q_WS_X11
     291# ifdef VBOX_WS_X11
    292292            /* Needed for instance for the message ``cannot connect to X server'': */
    293293            RTStrmPrintf(g_pStdErr, "Qt CRITICAL: %s\n", pMsg);
    294 # endif /* Q_WS_X11 */
     294# endif /* VBOX_WS_X11 */
    295295            break;
    296296        case QtFatalMsg:
    297297            Log(("Qt FATAL: %s\n", pMsg));
    298 # ifdef Q_WS_X11
     298# ifdef VBOX_WS_X11
    299299            /* Needed for instance for the message ``cannot connect to X server'': */
    300300            RTStrmPrintf(g_pStdErr, "Qt FATAL: %s\n", pMsg);
    301 # endif /* Q_WS_X11 */
     301# endif /* VBOX_WS_X11 */
    302302    }
    303303}
    … …  
    371371    do
    372372    {
    373 #ifdef Q_WS_MAC
     373#ifdef VBOX_WS_MAC
    374374        /* Hide setuid root from AppKit: */
    375375        HideSetUidRootFromAppKit();
    376 #endif /* Q_WS_MAC */
    377 
    378 #ifdef Q_WS_X11
     376#endif /* VBOX_WS_MAC */
     377
     378#ifdef VBOX_WS_X11
    379379        /* Make sure multi-threaded environment is safe: */
    380380        if (!MakeSureMultiThreadingIsSafe())
    381381            break;
    382 #endif /* Q_WS_X11 */
     382#endif /* VBOX_WS_X11 */
    383383
    384384        /* Console help preprocessing: */
    … …  
    407407#endif /* VBOX_WITH_HARDENING */
    408408
    409 #ifdef Q_WS_MAC
     409#ifdef VBOX_WS_MAC
    410410        /* Apply font fixes (before QApplication get created and instantiated font-hints): */
    411411        switch (VBoxGlobal::determineOsRelease())
    … …  
    419419        /* Instantiate own NSApplication before QApplication do it for us: */
    420420        UICocoaApplication::instance();
    421 #endif /* Q_WS_MAC */
    422 
    423 #ifdef Q_WS_X11
     421#endif /* VBOX_WS_MAC */
     422
     423#ifdef VBOX_WS_X11
    424424# if defined(RT_OS_LINUX) && defined(DEBUG)
    425425        /* Install signal handler to backtrace the call stack: */
    426426        InstallSignalHandler();
    427427# endif /* RT_OS_LINUX && DEBUG */
    428 #endif /* Q_WS_X11 */
     428#endif /* VBOX_WS_X11 */
    429429
    430430#if QT_VERSION >= 0x050000
    … …  
    439439        QApplication a(argc, argv);
    440440
    441 #ifdef Q_WS_WIN
     441#ifdef VBOX_WS_WIN
    442442        /* Drag in the sound drivers and DLLs early to get rid of the delay taking
    443443         * place when the main menu bar (or any action from that menu bar) is
    … …  
    447447         * thread to several seconds). */
    448448        PlaySound(NULL, NULL, 0);
    449 #endif /* Q_WS_WIN */
    450 
    451 #ifdef Q_WS_MAC
     449#endif /* VBOX_WS_WIN */
     450
     451#ifdef VBOX_WS_MAC
    452452# ifdef VBOX_GUI_WITH_HIDPI
    453453        /* Enable HiDPI icons.
    … …  
    459459        /* Disable menu icons on MacOS X host: */
    460460        ::darwinDisableIconsInMenus();
    461 #endif /* Q_WS_MAC */
    462 
    463 #ifdef Q_WS_X11
     461#endif /* VBOX_WS_MAC */
     462
     463#ifdef VBOX_WS_X11
    464464        /* Make all widget native.
    465465         * We did it to avoid various Qt crashes while testing widget attributes or acquiring winIds.
    … …  
    500500            break;
    501501        }
    502 #endif /* Q_WS_X11 */
     502#endif /* VBOX_WS_X11 */
    503503
    504504        /* Create modal-window manager: */
    … …  
    554554int main(int argc, char **argv, char **envp)
    555555{
    556 #ifdef Q_WS_X11
     556#ifdef VBOX_WS_X11
    557557    /* Make sure multi-threaded environment is safe: */
    558558    if (!MakeSureMultiThreadingIsSafe())
    559559        return 1;
    560 #endif /* Q_WS_X11 */
     560#endif /* VBOX_WS_X11 */
    561561
    562562    /* Initialize VBox Runtime.
    … …  
    662662extern "C" DECLEXPORT(void) TrustedError(const char *pszWhere, SUPINITOP enmWhat, int rc, const char *pszMsgFmt, va_list va)
    663663{
    664 # ifdef Q_WS_MAC
     664# ifdef VBOX_WS_MAC
    665665    /* Hide setuid root from AppKit: */
    666666    HideSetUidRootFromAppKit();
    667 # endif /* Q_WS_MAC */
     667# endif /* VBOX_WS_MAC */
    668668
    669669    char szMsgBuf[_16K];
    … …  
    749749    }
    750750
    751 # ifdef Q_WS_X11
     751# ifdef VBOX_WS_X11
    752752    /* We have to to make sure that we display the error-message
    753753     * after the parent displayed its own message. */
    754754    sleep(2);
    755 # endif /* Q_WS_X11 */
     755# endif /* VBOX_WS_X11 */
    756756
    757757    /* Update strText with strDetails: */

  • trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMediumManager.cpp

    r59094 r60362  
    4949# include "CMediumAttachment.h"
    5050
    51 # ifdef Q_WS_MAC
     51# ifdef VBOX_WS_MAC
    5252#  include "UIWindowMenuManager.h"
    53 # endif /* Q_WS_MAC */
     53# endif /* VBOX_WS_MAC */
    5454
    5555#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    10871087    }
    10881088
    1089 #ifdef Q_WS_MAC
     1089#ifdef VBOX_WS_MAC
    10901090    /* Prepare 'Window' menu: */
    10911091    AssertPtrReturnVoid(gpWindowMenuManager);
    10921092    menuBar()->addMenu(gpWindowMenuManager->createMenu(this));
    10931093    gpWindowMenuManager->addWindow(this);
    1094 #endif /* Q_WS_MAC */
     1094#endif /* VBOX_WS_MAC */
    10951095}
    10961096
    … …  
    11541154        /* Integrate tool-bar into dialog: */
    11551155        QVBoxLayout *pMainLayout = qobject_cast<QVBoxLayout*>(centralWidget()->layout());
    1156 #ifdef Q_WS_MAC
     1156#ifdef VBOX_WS_MAC
    11571157        /* Enable unified tool-bars on Mac OS X. Available on Qt >= 4.3: */
    11581158        addToolBar(m_pToolBar);
    … …  
    11611161        pMainLayout->setContentsMargins(0, 0, 0, 0);
    11621162        pMainLayout->insertSpacing(0, 10);
    1163 #else /* !Q_WS_MAC */
     1163#else /* !VBOX_WS_MAC */
    11641164        /* Add the tool-bar: */
    11651165        pMainLayout->insertWidget(0, m_pToolBar);
    … …  
    11671167        pMainLayout->setSpacing(5);
    11681168        pMainLayout->setContentsMargins(5, 5, 5, 5);
    1169 #endif /* !Q_WS_MAC */
     1169#endif /* !VBOX_WS_MAC */
    11701170    }
    11711171}
    … …  
    13951395    UIMediumItem *pMediumItem = mediumItem(type);
    13961396
    1397 #ifdef Q_WS_MAC
     1397#ifdef VBOX_WS_MAC
    13981398    /* Set the file for the proxy icon: */
    13991399    if (pMediumItem == currentMediumItem())
    14001400        setWindowFilePath(pMediumItem ? pMediumItem->location() : QString());
    1401 #endif /* Q_WS_MAC */
     1401#endif /* VBOX_WS_MAC */
    14021402
    14031403    /* Make sure current medium-item visible: */
    … …  
    17151715void UIMediumManager::cleanupMenuBar()
    17161716{
    1717 #ifdef Q_WS_MAC
     1717#ifdef VBOX_WS_MAC
    17181718    /* Cleanup 'Window' menu: */
    17191719    AssertPtrReturnVoid(gpWindowMenuManager);
    17201720    gpWindowMenuManager->removeWindow(this);
    17211721    gpWindowMenuManager->destroyMenu(this);
    1722 #endif /* Q_WS_MAC */
     1722#endif /* VBOX_WS_MAC */
    17231723}
    17241724
    … …  
    17751775
    17761776    /* Translate tool-bar: */
    1777 #ifdef Q_WS_MAC
     1777#ifdef VBOX_WS_MAC
    17781778    /* There is a bug in Qt Cocoa which result in showing a "more arrow" when
    17791779       the necessary size of the toolbar is increased. Also for some languages
    … …  
    17821782    if (m_pToolBar)
    17831783        m_pToolBar->updateLayout();
    1784 #endif /* Q_WS_MAC */
     1784#endif /* VBOX_WS_MAC */
    17851785
    17861786    /* Translate tab-widget: */
    … …  
    18531853    {
    18541854        m_pProgressBar->setText(QApplication::translate("VBoxMediaManagerDlg", "Checking accessibility"));
    1855 #ifdef Q_WS_MAC
     1855#ifdef VBOX_WS_MAC
    18561856        /* Make sure that the widgets aren't jumping around
    18571857         * while the progress-bar get visible. */
    … …  
    18601860        if (m_pButtonBox)
    18611861            m_pButtonBox->setMinimumHeight(h + 12);
    1862 #endif /* Q_WS_MAC */
     1862#endif /* VBOX_WS_MAC */
    18631863    }
    18641864

  • trunk/src/VBox/Frontends/VirtualBox/src/platform/darwin/VBoxIChatTheaterWrapper.h

    r52727 r60362  
    1919#define ___VBoxIChatTheaterWrapper_h
    2020
    21 #if defined (Q_WS_MAC) && defined (VBOX_WITH_ICHAT_THEATER)
     21#if defined (VBOX_WS_MAC) && defined (VBOX_WITH_ICHAT_THEATER)
    2222
    2323# include <ApplicationServices/ApplicationServices.h>

  • trunk/src/VBox/Frontends/VirtualBox/src/precomp.h

    r59094 r60362  
    102102#include <QListWidget>
    103103#include <QLocale>
    104 #ifdef Q_WS_MAC
     104#ifdef VBOX_WS_MAC
    105105//# include <QMacCocoaViewContainer> - only used once / only used in Objective C++
    106106#endif
    … …  
    205205#include <QWizard>
    206206#include <QWizardPage>
    207 #ifdef Q_WS_X11
     207#ifdef VBOX_WS_X11
    208208# include <QX11Info>
    209209#endif
    … …  
    216216 * System specific headers.
    217217 */
    218 #ifdef Q_WS_WIN
     218#ifdef VBOX_WS_WIN
    219219# include <shlobj.h>
    220220# include <Windows.h>
    … …  
    669669#include "VBoxUtils.h"
    670670#include "VBoxVersion.h"
    671 #ifdef Q_WS_X11
     671#ifdef VBOX_WS_X11
    672672# include "VBoxX11Helper.h"
    673673#endif

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

    r58674 r60362  
    298298    QKeySequence defaultShortcut(UIActionPoolType) const
    299299    {
    300 #ifdef Q_WS_MAC
     300#ifdef VBOX_WS_MAC
    301301        return QKeySequence("U");
    302 #else /* Q_WS_MAC */
     302#else /* VBOX_WS_MAC */
    303303        return QKeySequence("H");
    304 #endif /* !Q_WS_MAC */
     304#endif /* !VBOX_WS_MAC */
    305305    }
    306306
    … …  
    10641064};
    10651065
    1066 #ifdef Q_WS_X11
     1066#ifdef VBOX_WS_X11
    10671067class UIActionSimplePerformTypeCABS : public UIActionSimple
    10681068{
    … …  
    10991099    }
    11001100};
    1101 #endif /* Q_WS_X11 */
     1101#endif /* VBOX_WS_X11 */
    11021102
    11031103class UIActionSimplePerformTypeCtrlBreak : public UIActionSimple
    … …  
    18611861    }
    18621862};
    1863 #endif /* Q_WS_MAC */
     1863#endif /* VBOX_WS_MAC */
    18641864
    18651865UIActionPoolRuntime::UIActionPoolRuntime(bool fTemporary /* = false */)
    … …  
    21092109    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_Settings] = new UIActionSimpleKeyboardSettings(this);
    21102110    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD] = new UIActionSimplePerformTypeCAD(this);
    2111 #ifdef Q_WS_X11
     2111#ifdef VBOX_WS_X11
    21122112    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS] = new UIActionSimplePerformTypeCABS(this);
    2113 #endif /* Q_WS_X11 */
     2113#endif /* VBOX_WS_X11 */
    21142114    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak] = new UIActionSimplePerformTypeCtrlBreak(this);
    21152115    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeInsert] = new UIActionSimplePerformTypeInsert(this);
    … …  
    21432143#endif /* VBOX_WITH_DEBUGGER_GUI */
    21442144
    2145 #ifdef Q_WS_MAC
     2145#ifdef VBOX_WS_MAC
    21462146    /* 'Dock' actions: */
    21472147    m_pool[UIActionIndexRT_M_Dock] = new UIActionMenuDock(this);
    … …  
    21502150    m_pool[UIActionIndexRT_M_Dock_M_DockSettings_T_DisableMonitor] = new UIActionToggleDockDisableMonitor(this);
    21512151    m_pool[UIActionIndexRT_M_Dock_M_DockSettings_T_DisableOverlay] = new UIActionToggleDockIconDisableOverlay(this);
    2152 #endif /* Q_WS_MAC */
     2152#endif /* VBOX_WS_MAC */
    21532153
    21542154    /* Prepare update-handlers for known menus: */
    … …  
    22052205    m_restrictedActionsMenuDebug[UIActionRestrictionLevel_Base] =       gEDataManager->restrictedRuntimeMenuDebuggerActionTypes(strMachineID);
    22062206#endif /* VBOX_WITH_DEBUGGER_GUI */
    2207 #ifdef Q_WS_MAC
     2207#ifdef VBOX_WS_MAC
    22082208    m_restrictedActionsMenuWindow[UIActionRestrictionLevel_Base] =      gEDataManager->restrictedRuntimeMenuWindowActionTypes(strMachineID);
    2209 #endif /* Q_WS_MAC */
     2209#endif /* VBOX_WS_MAC */
    22102210    m_restrictedActionsMenuHelp[UIActionRestrictionLevel_Base] =        gEDataManager->restrictedRuntimeMenuHelpActionTypes(strMachineID);
    22112211
    … …  
    25752575    /* 'Menu Bar Settings' action: */
    25762576    addAction(pMenu, action(UIActionIndexRT_M_View_M_MenuBar_S_Settings));
    2577 #ifndef Q_WS_MAC
     2577#ifndef VBOX_WS_MAC
    25782578    /* 'Toggle Menu Bar' action: */
    25792579    addAction(pMenu, action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility));
    2580 #endif /* !Q_WS_MAC */
     2580#endif /* !VBOX_WS_MAC */
    25812581
    25822582    /* Mark menu as valid: */
    … …  
    28232823    /* 'Type CAD' action: */
    28242824    fSeparator = addAction(pMenu, action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD)) || fSeparator;
    2825 #ifdef Q_WS_X11
     2825#ifdef VBOX_WS_X11
    28262826    /* 'Type CABS' action: */
    28272827    fSeparator = addAction(pMenu, action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS)) || fSeparator;
    2828 #endif /* Q_WS_X11 */
     2828#endif /* VBOX_WS_X11 */
    28292829    /* 'Type Ctrl-Break' action: */
    28302830    fSeparator = addAction(pMenu, action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak)) || fSeparator;

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

    r58674 r60362  
    8282    UIActionIndexRT_M_Input_M_Keyboard_S_Settings,
    8383    UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD,
    84 #ifdef Q_WS_X11
     84#ifdef VBOX_WS_X11
    8585    UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS,
    86 #endif /* Q_WS_X11 */
     86#endif /* VBOX_WS_X11 */
    8787    UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak,
    8888    UIActionIndexRT_M_Input_M_Keyboard_S_TypeInsert,
    … …  
    116116#endif /* VBOX_WITH_DEBUGGER_GUI */
    117117
    118 #ifdef Q_WS_MAC
     118#ifdef VBOX_WS_MAC
    119119    /* 'Dock' menu actions: */
    120120    UIActionIndexRT_M_Dock,
    … …  
    123123    UIActionIndexRT_M_Dock_M_DockSettings_T_DisableMonitor,
    124124    UIActionIndexRT_M_Dock_M_DockSettings_T_DisableOverlay,
    125 #endif /* Q_WS_MAC */
     125#endif /* VBOX_WS_MAC */
    126126
    127127    /* Maximum index: */

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

    r60260 r60362  
    2626# include "VBoxGlobal.h"
    2727# include "UISession.h"
    28 # ifdef Q_WS_MAC
     28# ifdef VBOX_WS_MAC
    2929#  include "VBoxUtils.h"
    30 # endif /* Q_WS_MAC */
     30# endif /* VBOX_WS_MAC */
    3131
    3232/* COM includes: */
    … …  
    307307void UIConsoleEventHandlerProxy::sltShowWindow(qint64 &winId)
    308308{
    309 #ifdef Q_WS_MAC
     309#ifdef VBOX_WS_MAC
    310310    /* First of all, just ask the GUI thread to show the machine-window: */
    311311    winId = 0;
    … …  
    317317        winId = ::darwinGetCurrentProcessId();
    318318    }
    319 #else /* !Q_WS_MAC */
     319#else /* !VBOX_WS_MAC */
    320320    /* Return the ID of the top-level machine-window. */
    321321    winId = (ULONG64)m_pSession->mainMachineWindowId();
    322 #endif /* !Q_WS_MAC */
     322#endif /* !VBOX_WS_MAC */
    323323}
    324324

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

    r59819 r60362  
    6060#include <math.h>
    6161
    62 #ifdef Q_WS_X11
     62#ifdef VBOX_WS_X11
    6363/* X11 includes: */
    6464# include <QX11Info>
    … …  
    6767#  undef Bool // Qt5 vs Xlib gift..
    6868# endif /* QT_VERSION >= 0x050000 */
    69 #endif /* Q_WS_X11 */
     69#endif /* VBOX_WS_X11 */
    7070
    7171
    … …  
    522522
    523523/* COM stuff: */
    524 #ifdef Q_WS_WIN
     524#ifdef VBOX_WS_WIN
    525525static CComModule _Module;
    526 #else /* !Q_WS_WIN */
     526#else /* !VBOX_WS_WIN */
    527527NS_DECL_CLASSINFO(UIFrameBufferPrivate)
    528528NS_IMPL_THREADSAFE_ISUPPORTS1_CI(UIFrameBufferPrivate, IFramebuffer)
    529 #endif /* !Q_WS_WIN */
     529#endif /* !VBOX_WS_WIN */
    530530
    531531
    … …  
    562562    m_iWinId = (m_pMachineView && m_pMachineView->viewport()) ? (LONG64)m_pMachineView->viewport()->winId() : 0;
    563563
    564 #ifdef Q_WS_X11
     564#ifdef VBOX_WS_X11
    565565    /* Sync Qt and X11 Server (see xTracker #7547). */
    566566    XSync(QX11Info::display(), false);
    … …  
    611611    m_iWinId = (m_pMachineView && m_pMachineView->viewport()) ? (LONG64)m_pMachineView->viewport()->winId() : 0;
    612612
    613 #ifdef Q_WS_X11
     613#ifdef VBOX_WS_X11
    614614    /* Sync Qt and X11 Server (see xTracker #7547). */
    615615    XSync(QX11Info::display(), false);
    … …  
    13821382    QPainter painter(m_pMachineView->viewport());
    13831383
    1384 #ifdef Q_WS_MAC
     1384#ifdef VBOX_WS_MAC
    13851385# if QT_VERSION >= 0x050000
    13861386    /* Replace translucent background with black one: */
    … …  
    13891389    painter.setCompositionMode(QPainter::CompositionMode_SourceAtop);
    13901390# endif /* QT_VERSION >= 0x050000 */
    1391 #endif /* Q_WS_MAC */
     1391#endif /* VBOX_WS_MAC */
    13921392
    13931393    /* Draw image rectangle: */
    … …  
    14611461
    14621462#if defined(VBOX_WITH_TRANSLUCENT_SEAMLESS)
    1463 # if defined(Q_WS_WIN) || defined(Q_WS_X11) || QT_VERSION >= 0x050000
     1463# if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11) || QT_VERSION >= 0x050000
    14641464    /* Replace translucent background with black one: */
    14651465    painter.setCompositionMode(QPainter::CompositionMode_Source);
    14661466    painter.fillRect(paintRect, QColor(Qt::black));
    14671467    painter.setCompositionMode(QPainter::CompositionMode_SourceAtop);
    1468 # endif /* Q_WS_WIN || Q_WS_X11 || QT_VERSION >= 0x050000 */
     1468# endif /* VBOX_WS_WIN || VBOX_WS_X11 || QT_VERSION >= 0x050000 */
    14691469#endif /* VBOX_WITH_TRANSLUCENT_SEAMLESS */
    14701470
    … …  
    15091509        }
    15101510
    1511 #ifdef Q_WS_MAC
     1511#ifdef VBOX_WS_MAC
    15121512# ifdef VBOX_GUI_WITH_HIDPI
    15131513        /* Should we
    … …  
    15201520        }
    15211521# endif /* VBOX_GUI_WITH_HIDPI */
    1522 #endif /* Q_WS_MAC */
     1522#endif /* VBOX_WS_MAC */
    15231523    }
    15241524
    … …  
    15691569        }
    15701570
    1571 #ifdef Q_WS_MAC
     1571#ifdef VBOX_WS_MAC
    15721572# ifdef VBOX_GUI_WITH_HIDPI
    15731573        /* Should we
    … …  
    15801580        }
    15811581# endif /* VBOX_GUI_WITH_HIDPI */
    1582 #endif /* Q_WS_MAC */
     1582#endif /* VBOX_WS_MAC */
    15831583    }
    15841584

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

    r59743 r60362  
    2222/* Qt includes: */
    2323# include <QKeyEvent>
    24 # ifdef Q_WS_X11
     24# ifdef VBOX_WS_X11
    2525#  include <QX11Info>
    26 # endif /* Q_WS_X11 */
     26# endif /* VBOX_WS_X11 */
    2727
    2828/* GUI includes: */
    … …  
    4242# include "UIKeyboardHandlerScale.h"
    4343# include "UIMouseHandler.h"
    44 # ifdef Q_WS_MAC
     44# ifdef VBOX_WS_MAC
    4545#  include "UICocoaApplication.h"
    4646#  include "VBoxUtils-darwin.h"
    47 # endif /* Q_WS_MAC */
     47# endif /* VBOX_WS_MAC */
    4848
    4949/* COM includes: */
    … …  
    5151
    5252/* Other VBox includes: */
    53 # ifdef Q_WS_MAC
     53# ifdef VBOX_WS_MAC
    5454#  if QT_VERSION >= 0x050000
    5555#   include "iprt/cpp/utils.h"
    5656#  endif /* QT_VERSION >= 0x050000 */
    57 # endif /* Q_WS_MAC */
     57# endif /* VBOX_WS_MAC */
    5858
    5959#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    6565
    6666/* GUI includes: */
    67 #ifdef Q_WS_MAC
     67#ifdef VBOX_WS_MAC
    6868# include "DarwinKeyboard.h"
    69 #endif /* Q_WS_MAC */
    70 #ifdef Q_WS_WIN
     69#endif /* VBOX_WS_MAC */
     70#ifdef VBOX_WS_WIN
    7171# include "WinKeyboard.h"
    72 #endif /* Q_WS_WIN */
    73 #ifdef Q_WS_X11
     72#endif /* VBOX_WS_WIN */
     73#ifdef VBOX_WS_X11
    7474# include "XKeyboard.h"
    75 #endif /* Q_WS_X11 */
     75#endif /* VBOX_WS_X11 */
    7676
    7777/* External includes: */
    78 #ifdef Q_WS_MAC
     78#ifdef VBOX_WS_MAC
    7979# include <Carbon/Carbon.h>
    80 #endif /* Q_WS_MAC */
    81 #ifdef Q_WS_X11
     80#endif /* VBOX_WS_MAC */
     81#ifdef VBOX_WS_X11
    8282# include <X11/XKBlib.h>
    8383# include <X11/keysym.h>
    … …  
    9595#  include <xcb/xcb.h>
    9696# endif /* QT_VERSION >= 0x050000 */
    97 #endif /* Q_WS_X11 */
     97#endif /* VBOX_WS_X11 */
    9898
    9999/* Enums representing different keyboard-states: */
    … …  
    130130
    131131
    132 #ifdef Q_WS_WIN
     132#ifdef VBOX_WS_WIN
    133133UIKeyboardHandler* UIKeyboardHandler::m_spKeyboardHandler = 0;
    134 #endif /* Q_WS_WIN */
     134#endif /* VBOX_WS_WIN */
    135135
    136136/* Factory function to create keyboard-handler: */
    … …  
    160160    }
    161161
    162 #ifdef Q_WS_WIN
     162#ifdef VBOX_WS_WIN
    163163    /* It is necessary to have static pointer to created handler
    164164     * because windows keyboard-hook works only with static members: */
    165165    m_spKeyboardHandler = pKeyboardHandler;
    166 #endif /* Q_WS_WIN */
     166#endif /* VBOX_WS_WIN */
    167167
    168168    /* Return prepared keyboard-handler: */
    … …  
    173173void UIKeyboardHandler::destroy(UIKeyboardHandler *pKeyboardHandler)
    174174{
    175 #ifdef Q_WS_WIN
     175#ifdef VBOX_WS_WIN
    176176    /* It was necessary to have static pointer to created handler
    177177     * because windows keyboard-hook works only with static members: */
    178178    m_spKeyboardHandler = 0;
    179 #endif /* Q_WS_WIN */
     179#endif /* VBOX_WS_WIN */
    180180
    181181    /* Delete keyboard-handler: */
    … …  
    227227}
    228228
    229 #ifdef Q_WS_X11
     229#ifdef VBOX_WS_X11
    230230# if QT_VERSION < 0x050000
    231231struct CHECKFORX11FOCUSEVENTSDATA
    … …  
    261261}
    262262# endif /* QT_VERSION < 0x050000 */
    263 #endif /* Q_WS_X11 */
     263#endif /* VBOX_WS_X11 */
    264264
    265265void UIKeyboardHandler::captureKeyboard(ulong uScreenId)
    … …  
    272272    if (m_views.contains(uScreenId))
    273273    {
    274 #if defined(Q_WS_MAC)
     274#if defined(VBOX_WS_MAC)
    275275
    276276        /* On Mac, keyboard grabbing is ineffective,
    … …  
    287287        m_views[uScreenId]->grabKeyboard();
    288288
    289 #elif defined(Q_WS_WIN)
     289#elif defined(VBOX_WS_WIN)
    290290
    291291        /* On Win, keyboard grabbing is ineffective,
    … …  
    294294         * S.a. UIKeyboardHandler::eventFilter for more information. */
    295295
    296 #elif defined(Q_WS_X11)
     296#elif defined(VBOX_WS_X11)
    297297
    298298        /* On X11, we are using passive XGrabKey for normal (windowed) mode
    … …  
    371371    if (m_views.contains(m_iKeyboardCaptureViewIndex))
    372372    {
    373 #if defined(Q_WS_MAC)
     373#if defined(VBOX_WS_MAC)
    374374
    375375        /* On Mac, keyboard grabbing is ineffective,
    … …  
    386386        m_views[m_iKeyboardCaptureViewIndex]->releaseKeyboard();
    387387
    388 #elif defined(Q_WS_WIN)
     388#elif defined(VBOX_WS_WIN)
    389389
    390390        /* On Win, keyboard grabbing is ineffective,
    … …  
    393393         * S.a. UIKeyboardHandler::eventFilter for more information. */
    394394
    395 #elif defined(Q_WS_X11)
     395#elif defined(VBOX_WS_X11)
    396396
    397397        /* On X11, we are using passive XGrabKey for normal (windowed) mode
    … …  
    488488    }
    489489
    490 #ifdef Q_WS_MAC
     490#ifdef VBOX_WS_MAC
    491491    unsigned int hostComboModifierMask = 0;
    492492    QList<int> hostCombo = UIHostCombo::toKeyCodeList(m_globalSettings.hostCombo());
    … …  
    497497        alphaLock | kEventKeyModifierNumLockMask |
    498498        (aReleaseHostKey ? 0 : hostComboModifierMask);
    499 #endif /* Q_WS_MAC */
     499#endif /* VBOX_WS_MAC */
    500500
    501501    /* Notify all the listeners: */
    … …  
    524524#endif /* VBOX_WITH_DEBUGGER_GUI */
    525525
    526 #ifdef Q_WS_WIN
     526#ifdef VBOX_WS_WIN
    527527void UIKeyboardHandler::winSkipKeyboardEvents(bool fSkip)
    528528{
    529529    m_fSkipKeyboardEvents = fSkip;
    530530}
    531 #endif /* Q_WS_WIN */
     531#endif /* VBOX_WS_WIN */
    532532
    533533#if QT_VERSION < 0x050000
    534 # if defined(Q_WS_MAC)
     534# if defined(VBOX_WS_MAC)
    535535
    536536bool UIKeyboardHandler::macEventFilter(const void *pvCocoaEvent, EventRef event, ulong uScreenId)
    … …  
    675675}
    676676
    677 # elif defined(Q_WS_WIN)
     677# elif defined(VBOX_WS_WIN)
    678678
    679679bool UIKeyboardHandler::winEventFilter(MSG *pMsg, ulong uScreenId)
    … …  
    840840}
    841841
    842 # elif defined(Q_WS_X11)
     842# elif defined(VBOX_WS_X11)
    843843
    844844static Bool UIKeyboardHandlerCompEvent(Display*, XEvent *pEvent, XPointer pvArg)
    … …  
    974974}
    975975
    976 # endif /* Q_WS_X11 */
     976# endif /* VBOX_WS_X11 */
    977977#else /* QT_VERSION >= 0x050000 */
    978978
    … …  
    990990    bool fResult = false; /* Pass to Qt by default. */
    991991
    992 # if defined(Q_WS_MAC)
     992# if defined(VBOX_WS_MAC)
    993993
    994994    /* Acquire carbon event reference from the cocoa one: */
    … …  
    11251125    }
    11261126
    1127 # elif defined(Q_WS_WIN)
     1127# elif defined(VBOX_WS_WIN)
    11281128
    11291129    /* Ignore this event if m_fSkipKeyboardEvents is set by winSkipKeyboardEvents(). */
    … …  
    12821282    }
    12831283
    1284 # elif defined(Q_WS_X11)
     1284# elif defined(VBOX_WS_X11)
    12851285
    12861286    /* Cast to XCB event: */
    … …  
    14101410                {
    14111411                    /* Capture keyboard: */
    1412 #ifdef Q_WS_WIN
     1412#ifdef VBOX_WS_WIN
    14131413                    if (!isAutoCaptureDisabled() && autoCaptureSetGlobally() &&
    14141414                        GetAncestor((HWND)m_views[theListOfViewIds[i]]->winId(), GA_ROOT) == GetForegroundWindow())
    1415 #else /* !Q_WS_WIN */
     1415#else /* !VBOX_WS_WIN */
    14161416                    if (!isAutoCaptureDisabled() && autoCaptureSetGlobally())
    1417 #endif /* !Q_WS_WIN */
     1417#endif /* !VBOX_WS_WIN */
    14181418                        captureKeyboard(theListOfViewIds[i]);
    14191419                    /* Reset the single-time disable capture flag: */
    … …  
    14501450    , m_fDebuggerActive(false)
    14511451    , m_iKeyboardHookViewIndex(-1)
    1452 #if defined(Q_WS_MAC)
     1452#if defined(VBOX_WS_MAC)
    14531453    , m_uDarwinKeyModifiers(0)
    1454 #elif defined(Q_WS_WIN)
     1454#elif defined(VBOX_WS_WIN)
    14551455    , m_fIsHostkeyInCapture(false)
    14561456    , m_fSkipKeyboardEvents(false)
    14571457    , m_keyboardHook(NULL)
    14581458    , m_pAltGrMonitor(0)
    1459 #endif /* Q_WS_WIN */
     1459#endif /* VBOX_WS_WIN */
    14601460#if QT_VERSION >= 0x050000
    14611461    , m_pPrivateEventFilter(0)
    … …  
    14821482void UIKeyboardHandler::prepareCommon()
    14831483{
    1484 #ifdef Q_WS_WIN
     1484#ifdef VBOX_WS_WIN
    14851485    /* Prepare AltGR monitor: */
    14861486    m_pAltGrMonitor = new WinAltGrMonitor;
    1487 #endif /* Q_WS_WIN */
     1487#endif /* VBOX_WS_WIN */
    14881488
    14891489    /* Machine state-change updater: */
    … …  
    14991499{
    15001500    /* Global settings: */
    1501 #ifdef Q_WS_X11
     1501#ifdef VBOX_WS_X11
    15021502    /* Initialize the X keyboard subsystem: */
    15031503    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
    1504 #endif /* Q_WS_X11 */
     1504#endif /* VBOX_WS_X11 */
    15051505
    15061506    /* Extra data settings: */
    … …  
    15131513void UIKeyboardHandler::cleanupCommon()
    15141514{
    1515 #if defined(Q_WS_MAC)
     1515#if defined(VBOX_WS_MAC)
    15161516
    15171517    /* Cleanup keyboard-hook: */
    … …  
    15241524    }
    15251525
    1526 #elif defined(Q_WS_WIN)
     1526#elif defined(VBOX_WS_WIN)
    15271527
    15281528    /* Cleanup AltGR monitor: */
    … …  
    15381538    }
    15391539
    1540 #endif /* Q_WS_WIN */
     1540#endif /* VBOX_WS_WIN */
    15411541
    15421542#if QT_VERSION >= 0x050000
    … …  
    15921592            case QEvent::FocusIn:
    15931593            {
    1594 #if defined(Q_WS_MAC)
     1594#if defined(VBOX_WS_MAC)
    15951595
    15961596                /* If keyboard-hook is NOT installed;
    … …  
    16181618                }
    16191619
    1620 #elif defined(Q_WS_WIN)
     1620#elif defined(VBOX_WS_WIN)
    16211621
    16221622                /* If keyboard-hook is NOT installed;
    … …  
    16361636                }
    16371637
    1638 #endif /* Q_WS_WIN */
     1638#endif /* VBOX_WS_WIN */
    16391639
    16401640#if QT_VERSION >= 0x050000
    1641 # if defined(Q_WS_WIN) || defined(Q_WS_X11)
     1641# if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    16421642                /* If private event-filter is NOT installed;
    16431643                 * Or installed but NOT for that view: */
    … …  
    16561656                    qApp->installNativeEventFilter(m_pPrivateEventFilter);
    16571657                }
    1658 # endif /* Q_WS_WIN || Q_WS_X11 */
     1658# endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    16591659#endif /* QT_VERSION >= 0x050000 */
    16601660
    … …  
    16651665                {
    16661666                    /* Capture keyboard: */
    1667 #ifdef Q_WS_WIN
     1667#ifdef VBOX_WS_WIN
    16681668                    if (!isAutoCaptureDisabled() && autoCaptureSetGlobally() &&
    16691669                        GetAncestor((HWND)pWatchedView->winId(), GA_ROOT) == GetForegroundWindow())
    1670 #else /* !Q_WS_WIN */
     1670#else /* !VBOX_WS_WIN */
    16711671                    if (!isAutoCaptureDisabled() && autoCaptureSetGlobally())
    1672 #endif /* !Q_WS_WIN */
     1672#endif /* !VBOX_WS_WIN */
    16731673                        captureKeyboard(uScreenId);
    16741674                    /* Reset the single-time disable capture flag: */
    … …  
    16811681            case QEvent::FocusOut:
    16821682            {
    1683 #if defined(Q_WS_MAC)
     1683#if defined(VBOX_WS_MAC)
    16841684
    16851685                /* If keyboard-hook is installed: */
    … …  
    16921692                }
    16931693
    1694 #elif defined(Q_WS_WIN)
     1694#elif defined(VBOX_WS_WIN)
    16951695
    16961696                /* If keyboard-hook is installed: */
    … …  
    17021702                }
    17031703
    1704 #endif /* Q_WS_WIN */
     1704#endif /* VBOX_WS_WIN */
    17051705
    17061706#if QT_VERSION >= 0x050000
    1707 # if defined(Q_WS_WIN) || defined(Q_WS_X11)
     1707# if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    17081708                /* If private event-filter is installed: */
    17091709                if (m_pPrivateEventFilter)
    … …  
    17141714                    m_pPrivateEventFilter = 0;
    17151715                }
    1716 # endif /* Q_WS_WIN || Q_WS_X11 */
     1716# endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    17171717#endif /* QT_VERSION >= 0x050000 */
    17181718
    … …  
    17771777}
    17781778
    1779 #if defined(Q_WS_MAC)
     1779#if defined(VBOX_WS_MAC)
    17801780
    17811781/* static */
    … …  
    18181818}
    18191819
    1820 #elif defined(Q_WS_WIN)
     1820#elif defined(VBOX_WS_WIN)
    18211821
    18221822/* static */
    … …  
    18841884}
    18851885
    1886 #endif /* Q_WS_WIN */
     1886#endif /* VBOX_WS_WIN */
    18871887
    18881888/**
    … …  
    20422042                    if (!uisession()->isMouseSupportsAbsolute() || !uisession()->isMouseIntegrated())
    20432043                    {
    2044 #ifdef Q_WS_X11
     2044#ifdef VBOX_WS_X11
    20452045                        /* Make sure that pending FocusOut events from the
    20462046                         * previous message box are handled, otherwise the
    20472047                         * mouse is immediately ungrabbed: */
    20482048                        qApp->processEvents();
    2049 #endif /* Q_WS_X11 */
     2049#endif /* VBOX_WS_X11 */
    20502050                        if (m_fIsKeyboardCaptured)
    20512051                        {
    … …  
    21162116                                         ( m_bIsHostComboPressed && !fIsFullHostComboPresent);
    21172117
    2118 #ifdef Q_WS_WIN
     2118#ifdef VBOX_WS_WIN
    21192119    if (m_bIsHostComboPressed || isHostComboStateChanged)
    21202120    {
    … …  
    21222122        m_fIsHostkeyInCapture = m_fIsKeyboardCaptured;
    21232123    }
    2124 #endif /* Q_WS_WIN */
     2124#endif /* VBOX_WS_WIN */
    21252125
    21262126    if (keyEventCADHandled(uScan))
    … …  
    22262226    bool fWasProcessed = false;
    22272227
    2228 #if defined(Q_WS_MAC)
     2228#if defined(VBOX_WS_MAC)
    22292229
    22302230    Q_UNUSED(iHotKey);
    … …  
    22322232        fWasProcessed = actionPool()->processHotKey(QKeySequence(Qt::UNICODE_ACCEL + QChar(pHotKey[0]).toUpper().unicode()));
    22332233
    2234 #elif defined(Q_WS_WIN)
     2234#elif defined(VBOX_WS_WIN)
    22352235
    22362236    Q_UNUSED(pHotKey);
    … …  
    22502250    delete[] pList;
    22512251
    2252 #elif defined(Q_WS_X11)
     2252#elif defined(VBOX_WS_X11)
    22532253
    22542254    Q_UNUSED(pHotKey);
    … …  
    22842284     * This function will add up to 6 additional keycodes to codes. */
    22852285
    2286 #if defined(Q_WS_MAC)
     2286#if defined(VBOX_WS_MAC)
    22872287
    22882288    /* if (uisession()->numLockAdaptionCnt()) ... - NumLock isn't implemented by Mac OS X so ignore it. */
    … …  
    23022302    }
    23032303
    2304 #elif defined(Q_WS_WIN)
     2304#elif defined(VBOX_WS_WIN)
    23052305
    23062306    if (uisession()->numLockAdaptionCnt() && (uisession()->isNumLock() ^ !!(GetKeyState(VK_NUMLOCK))))
    … …  
    23252325    }
    23262326
    2327 #elif defined(Q_WS_X11)
     2327#elif defined(VBOX_WS_X11)
    23282328
    23292329    Window   wDummy1, wDummy2;

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

    r59743 r60362  
    3030
    3131/* External includes: */
    32 #ifdef Q_WS_MAC
     32#ifdef VBOX_WS_MAC
    3333# include <Carbon/Carbon.h>
    3434# include <CoreFoundation/CFBase.h>
    35 #endif /* Q_WS_MAC */
     35#endif /* VBOX_WS_MAC */
    3636
    3737/* Forward declarations: */
    … …  
    4444class UIMachineView;
    4545class CKeyboard;
    46 #ifdef Q_WS_WIN
     46#ifdef VBOX_WS_WIN
    4747class WinAltGrMonitor;
    48 #endif /* Q_WS_WIN */
    49 #ifdef Q_WS_X11
     48#endif /* VBOX_WS_WIN */
     49#ifdef VBOX_WS_X11
    5050# if QT_VERSION < 0x050000
    5151typedef union _XEvent XEvent;
    5252# endif /* QT_VERSION < 0x050000 */
    53 #endif /* Q_WS_X11 */
     53#endif /* VBOX_WS_X11 */
    5454#if QT_VERSION >= 0x050000
    5555class KeyboardHandlerEventFilter;
    … …  
    7878
    7979    /* Commands to capture/release keyboard: */
    80 #ifdef Q_WS_X11
     80#ifdef VBOX_WS_X11
    8181# if QT_VERSION < 0x050000
    8282    bool checkForX11FocusEvents(unsigned long hWindow);
    8383# endif /* QT_VERSION < 0x050000 */
    84 #endif /* Q_WS_X11 */
     84#endif /* VBOX_WS_X11 */
    8585    void captureKeyboard(ulong uScreenId);
    8686    void releaseKeyboard();
    … …  
    9292    /* Some getters required by side-code: */
    9393    bool isHostKeyPressed() const { return m_bIsHostComboPressed; }
    94 #ifdef Q_WS_MAC
     94#ifdef VBOX_WS_MAC
    9595    bool isHostKeyAlone() const { return m_bIsHostComboAlone; }
    9696    bool isKeyboardGrabbed() const { return m_iKeyboardHookViewIndex != -1; }
    97 #endif /* Q_WS_MAC */
     97#endif /* VBOX_WS_MAC */
    9898
    9999#ifdef VBOX_WITH_DEBUGGER_GUI
    … …  
    102102#endif
    103103
    104 #ifdef Q_WS_WIN
     104#ifdef VBOX_WS_WIN
    105105    /** Tells the keyboard event handler to skip host keyboard events.
    106106      * Used for HID LEDs sync when on Windows host a keyboard event
    107107      * is generated in order to change corresponding LED. */
    108108    void winSkipKeyboardEvents(bool fSkip);
    109 #endif /* Q_WS_WIN */
     109#endif /* VBOX_WS_WIN */
    110110
    111111#if QT_VERSION < 0x050000
    112 # if defined(Q_WS_MAC)
     112# if defined(VBOX_WS_MAC)
    113113    /** Qt4: Mac: Performs final pre-processing of all the native events. */
    114114    bool macEventFilter(const void *pvCocoaEvent, EventRef event, ulong uScreenId);
    115 # elif defined(Q_WS_WIN)
     115# elif defined(VBOX_WS_WIN)
    116116    /** Qt4: Win: Performs final pre-processing of all the native events. */
    117117    bool winEventFilter(MSG *pMsg, ulong uScreenId);
    118 # elif defined(Q_WS_X11)
     118# elif defined(VBOX_WS_X11)
    119119    /** Qt4: X11: Performs final pre-processing of all the native events. */
    120120    bool x11EventFilter(XEvent *pEvent, ulong uScreenId);
    121 # endif /* Q_WS_X11 */
     121# endif /* VBOX_WS_X11 */
    122122#else /* QT_VERSION >= 0x050000 */
    123123    /** Qt5: Performs pre-processing of all the native events. */
    … …  
    157157    bool eventFilter(QObject *pWatchedObject, QEvent *pEvent);
    158158
    159 #if defined(Q_WS_MAC)
     159#if defined(VBOX_WS_MAC)
    160160    /** Mac: Performs initial pre-processing of all the native keyboard events. */
    161161    static bool macKeyboardProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
    162162    /** Mac: Performs initial pre-processing of all the native keyboard events. */
    163163    bool macKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
    164 #elif defined(Q_WS_WIN)
     164#elif defined(VBOX_WS_WIN)
    165165    /** Win: Performs initial pre-processing of all the native keyboard events. */
    166166    static LRESULT CALLBACK winKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
    167167    /** Win: Performs initial pre-processing of all the native keyboard events. */
    168168    bool winKeyboardEvent(UINT msg, const KBDLLHOOKSTRUCT &event);
    169 #endif /* Q_WS_WIN */
     169#endif /* VBOX_WS_WIN */
    170170
    171171    bool keyEventCADHandled(uint8_t uScan);
    … …  
    220220    int m_iKeyboardHookViewIndex;
    221221
    222 #if defined(Q_WS_MAC)
     222#if defined(VBOX_WS_MAC)
    223223    /** Mac: Holds the current modifiers key mask. */
    224224    UInt32 m_uDarwinKeyModifiers;
    225 #elif defined(Q_WS_WIN)
     225#elif defined(VBOX_WS_WIN)
    226226    /** Win: Currently this is used in winKeyboardEvent() only. */
    227227    bool m_fIsHostkeyInCapture;
    … …  
    234234    /** Win: Holds the keyboard handler reference to be accessible from the keyboard hook. */
    235235    static UIKeyboardHandler *m_spKeyboardHandler;
    236 #endif /* Q_WS_WIN */
     236#endif /* VBOX_WS_WIN */
    237237
    238238#if QT_VERSION >= 0x050000

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

    r55401 r60362  
    3737    UIVisualElement_VideoCapture          = RT_BIT(10),
    3838    UIVisualElement_FeaturesStuff         = RT_BIT(11),
    39 #ifndef Q_WS_MAC
     39#ifndef VBOX_WS_MAC
    4040    UIVisualElement_MiniToolBar           = RT_BIT(12),
    41 #endif /* !Q_WS_MAC */
     41#endif /* !VBOX_WS_MAC */
    4242    UIVisualElement_AllStuff              = 0xFFFF
    4343};

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

    r59911 r60362  
    2727# include <QDateTime>
    2828# include <QImageWriter>
    29 # ifdef Q_WS_MAC
     29# ifdef VBOX_WS_MAC
    3030#  include <QMenuBar>
    31 # endif /* Q_WS_MAC */
    32 # ifdef Q_WS_X11
     31# endif /* VBOX_WS_MAC */
     32# ifdef VBOX_WS_X11
    3333#  include <QX11Info>
    34 # endif /* Q_WS_X11 */
     34# endif /* VBOX_WS_X11 */
    3535
    3636/* GUI includes: */
    … …  
    6565# include "UIExtraDataManager.h"
    6666# include "UIAddDiskEncryptionPasswordDialog.h"
    67 # ifdef Q_WS_MAC
     67# ifdef VBOX_WS_MAC
    6868#  include "DockIconPreview.h"
    6969#  include "UIExtraDataManager.h"
    70 # endif /* Q_WS_MAC */
     70# endif /* VBOX_WS_MAC */
    7171
    7272/* COM includes: */
    … …  
    8484# include "CEmulatedUSB.h"
    8585# include "CNetworkAdapter.h"
    86 # ifdef Q_WS_MAC
     86# ifdef VBOX_WS_MAC
    8787#  include "CGuest.h"
    88 # endif /* Q_WS_MAC */
     88# endif /* VBOX_WS_MAC */
    8989
    9090/* Other VBox includes: */
    … …  
    105105#endif /* VBOX_WITH_XPCOM */
    106106
    107 #ifdef Q_WS_MAC
     107#ifdef VBOX_WS_MAC
    108108# include "DarwinKeyboard.h"
    109 #endif /* Q_WS_MAC */
    110 #ifdef Q_WS_WIN
     109#endif /* VBOX_WS_MAC */
     110#ifdef VBOX_WS_WIN
    111111# include "WinKeyboard.h"
    112 #endif /* Q_WS_WIN */
    113 #ifdef Q_WS_X11
     112#endif /* VBOX_WS_WIN */
     113#ifdef VBOX_WS_X11
    114114# include <XKeyboard.h>
    115 #endif /* Q_WS_X11 */
     115#endif /* VBOX_WS_X11 */
    116116
    117117
    … …  
    195195    prepareMachineWindows();
    196196
    197 #ifdef Q_WS_MAC
     197#ifdef VBOX_WS_MAC
    198198    /* Prepare dock: */
    199199    prepareDock();
    200 #endif /* Q_WS_MAC */
     200#endif /* VBOX_WS_MAC */
    201201
    202202#if 0 /* To early! The debugger needs a VM handle to work. So, must be done after power on.  Moved to initializePostPowerUp. */
    … …  
    224224#endif /* VBOX_WITH_DEBUGGER_GUI */
    225225
    226 #ifdef Q_WS_MAC
     226#ifdef VBOX_WS_MAC
    227227    /* Cleanup dock: */
    228228    cleanupDock();
    229 #endif /* Q_WS_MAC */
     229#endif /* VBOX_WS_MAC */
    230230
    231231    /* Cleanup menu: */
    … …  
    350350}
    351351
    352 #ifdef Q_WS_MAC
     352#ifdef VBOX_WS_MAC
    353353void UIMachineLogic::updateDockIcon()
    354354{
    … …  
    384384    return 0;
    385385}
    386 #endif /* Q_WS_MAC */
     386#endif /* VBOX_WS_MAC */
    387387
    388388void UIMachineLogic::saveState()
    … …  
    634634            break;
    635635        }
    636 #ifdef Q_WS_X11
     636#ifdef VBOX_WS_X11
    637637        case KMachineState_Starting:
    638638        case KMachineState_Restoring:
    … …  
    649649    }
    650650
    651 #ifdef Q_WS_MAC
     651#ifdef VBOX_WS_MAC
    652652    /* Update Dock Overlay: */
    653653    updateDockOverlay();
    654 #endif /* Q_WS_MAC */
     654#endif /* VBOX_WS_MAC */
    655655}
    656656
    … …  
    699699        return;
    700700
    701 #if defined(Q_WS_MAC)
     701#if defined(VBOX_WS_MAC)
    702702    DarwinHidDevicesBroadcastLeds(m_pHostLedsState, uisession()->isNumLock(), uisession()->isCapsLock(), uisession()->isScrollLock());
    703 #elif defined(Q_WS_WIN)
     703#elif defined(VBOX_WS_WIN)
    704704    if (!winHidLedsInSync(uisession()->isNumLock(), uisession()->isCapsLock(), uisession()->isScrollLock()))
    705705    {
    … …  
    737737}
    738738
    739 #ifdef Q_WS_MAC
     739#ifdef VBOX_WS_MAC
    740740void UIMachineLogic::sltShowWindows()
    741741{
    … …  
    754754    }
    755755}
    756 #endif /* Q_WS_MAC */
     756#endif /* VBOX_WS_MAC */
    757757
    758758void UIMachineLogic::sltGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)
    … …  
    809809    , m_pDbgGuiVT(0)
    810810#endif /* VBOX_WITH_DEBUGGER_GUI */
    811 #ifdef Q_WS_MAC
     811#ifdef VBOX_WS_MAC
    812812    , m_fIsDockIconEnabled(true)
    813813    , m_pDockIconPreview(0)
    814814    , m_pDockPreviewSelectMonitorGroup(0)
    815815    , m_DockIconPreviewMonitor(0)
    816 #endif /* Q_WS_MAC */
     816#endif /* VBOX_WS_MAC */
    817817    , m_pHostLedsState(NULL)
    818818    , m_fIsHidLedsSyncEnabled(false)
    … …  
    874874void UIMachineLogic::retranslateUi()
    875875{
    876 #ifdef Q_WS_MAC
     876#ifdef VBOX_WS_MAC
    877877    if (m_pDockPreviewSelectMonitorGroup)
    878878    {
    … …  
    884884        }
    885885    }
    886 #endif /* Q_WS_MAC */
     886#endif /* VBOX_WS_MAC */
    887887    /* Shared Clipboard actions: */
    888888    if (m_pSharedClipboardActions)
    … …  
    898898}
    899899
    900 #ifdef Q_WS_MAC
     900#ifdef VBOX_WS_MAC
    901901void UIMachineLogic::updateDockOverlay()
    902902{
    … …  
    920920        m_pDockIconPreview->updateDockOverlay();
    921921}
    922 #endif /* Q_WS_MAC */
     922#endif /* VBOX_WS_MAC */
    923923
    924924void UIMachineLogic::prepareRequiredFeatures()
    925925{
    926 #ifdef Q_WS_MAC
     926#ifdef VBOX_WS_MAC
    927927# ifdef VBOX_WITH_ICHAT_THEATER
    928928    /* Init shared AV manager: */
    929929    initSharedAVManager();
    930930# endif /* VBOX_WITH_ICHAT_THEATER */
    931 #endif /* Q_WS_MAC */
     931#endif /* VBOX_WS_MAC */
    932932}
    933933
    … …  
    951951    connect(uisession(), SIGNAL(sigRuntimeError(bool, const QString &, const QString &)),
    952952            this, SLOT(sltRuntimeError(bool, const QString &, const QString &)));
    953 #ifdef Q_WS_MAC
     953#ifdef VBOX_WS_MAC
    954954    connect(uisession(), SIGNAL(sigShowWindows()), this, SLOT(sltShowWindows()));
    955 #endif /* Q_WS_MAC */
     955#endif /* VBOX_WS_MAC */
    956956    connect(uisession(), SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
    957957            this, SLOT(sltGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)));
    … …  
    994994    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_View_T_GuestAutoresize));
    995995    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD));
    996 #ifdef Q_WS_X11
     996#ifdef VBOX_WS_X11
    997997    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS));
    998 #endif /* Q_WS_X11 */
     998#endif /* VBOX_WS_X11 */
    999999    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak));
    10001000    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeInsert));
    … …  
    10061006    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_Machine_S_ShowInformation));
    10071007    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_Machine_T_Pause));
    1008 #ifndef Q_WS_MAC
     1008#ifndef VBOX_WS_MAC
    10091009    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_S_MinimizeWindow));
    1010 #endif /* !Q_WS_MAC */
     1010#endif /* !VBOX_WS_MAC */
    10111011    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_S_AdjustWindow));
    10121012    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_S_TakeScreenshot));
    … …  
    10171017    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar));
    10181018    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_S_Settings));
    1019 #ifndef Q_WS_MAC
     1019#ifndef VBOX_WS_MAC
    10201020    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility));
    1021 #endif /* !Q_WS_MAC */
     1021#endif /* !VBOX_WS_MAC */
    10221022    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_M_StatusBar));
    10231023    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings));
    … …  
    10421042    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_Devices_M_SharedFolders_S_Settings));
    10431043    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndexRT_M_Devices_S_InstallGuestTools));
    1044 #ifdef Q_WS_MAC
     1044#ifdef VBOX_WS_MAC
    10451045    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndex_M_Window));
    10461046    m_pRunningOrPausedActions->addAction(actionPool()->action(UIActionIndex_M_Window_S_Minimize));
    1047 #endif /* Q_WS_MAC */
     1047#endif /* VBOX_WS_MAC */
    10481048
    10491049    /* Move actions into running-n-paused-n-stucked actions group: */
    … …  
    10781078
    10791079    /* 'View' actions connections: */
    1080 #ifndef Q_WS_MAC
     1080#ifndef VBOX_WS_MAC
    10811081    connect(actionPool()->action(UIActionIndexRT_M_View_S_MinimizeWindow), SIGNAL(triggered()),
    10821082            this, SLOT(sltMinimizeActiveMachineWindow()), Qt::QueuedConnection);
    1083 #endif /* !Q_WS_MAC */
     1083#endif /* !VBOX_WS_MAC */
    10841084    connect(actionPool()->action(UIActionIndexRT_M_View_S_AdjustWindow), SIGNAL(triggered()),
    10851085            this, SLOT(sltAdjustMachineWindows()));
    … …  
    11001100    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD), SIGNAL(triggered()),
    11011101            this, SLOT(sltTypeCAD()));
    1102 #ifdef Q_WS_X11
     1102#ifdef VBOX_WS_X11
    11031103    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS), SIGNAL(triggered()),
    11041104            this, SLOT(sltTypeCABS()));
    1105 #endif /* Q_WS_X11 */
     1105#endif /* VBOX_WS_X11 */
    11061106    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak), SIGNAL(triggered()),
    11071107            this, SLOT(sltTypeCtrlBreak()));
    … …  
    11361136#endif /* VBOX_WITH_DEBUGGER_GUI */
    11371137
    1138 #ifdef Q_WS_MAC
     1138#ifdef VBOX_WS_MAC
    11391139    /* 'Window' action connections: */
    11401140    connect(actionPool()->action(UIActionIndex_M_Window_S_Minimize), SIGNAL(triggered()),
    11411141            this, SLOT(sltMinimizeActiveMachineWindow()), Qt::QueuedConnection);
    1142 #endif /* Q_WS_MAC */
     1142#endif /* VBOX_WS_MAC */
    11431143}
    11441144
    … …  
    11561156    m_menuUpdateHandlers[UIActionIndexRT_M_Debug] =                     &UIMachineLogic::updateMenuDebug;
    11571157#endif /* VBOX_WITH_DEBUGGER_GUI */
    1158 #ifdef Q_WS_MAC
     1158#ifdef VBOX_WS_MAC
    11591159    m_menuUpdateHandlers[UIActionIndex_M_Window] =                      &UIMachineLogic::updateMenuWindow;
    1160 #endif /* Q_WS_MAC */
     1160#endif /* VBOX_WS_MAC */
    11611161
    11621162    /* Create keyboard/mouse handlers: */
    … …  
    11681168}
    11691169
    1170 #ifdef Q_WS_MAC
     1170#ifdef VBOX_WS_MAC
    11711171void UIMachineLogic::prepareDock()
    11721172{
    … …  
    12651265    updateDockOverlay();
    12661266}
    1267 #endif /* Q_WS_MAC */
     1267#endif /* VBOX_WS_MAC */
    12681268
    12691269#ifdef VBOX_WITH_DEBUGGER_GUI
    … …  
    12821282void UIMachineLogic::loadSettings()
    12831283{
    1284 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     1284#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    12851285    /* Read cached extra-data value: */
    12861286    m_fIsHidLedsSyncEnabled = gEDataManager->hidLedsSyncState(vboxGlobal().managedVMUuid());
    12871287    /* Subscribe to extra-data changes to be able to enable/disable feature dynamically: */
    12881288    connect(gEDataManager, SIGNAL(sigHidLedsSyncStateChange(bool)), this, SLOT(sltHidLedsSyncStateChanged(bool)));
    1289 #endif /* Q_WS_MAC || Q_WS_WIN */
     1289#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
    12901290    /* HID LEDs sync initialization: */
    12911291    sltSwitchKeyboardLedsToGuestLeds();
    … …  
    13061306#endif /* VBOX_WITH_DEBUGGER_GUI */
    13071307
    1308 #ifdef Q_WS_MAC
     1308#ifdef VBOX_WS_MAC
    13091309void UIMachineLogic::cleanupDock()
    13101310{
    … …  
    13151315    }
    13161316}
    1317 #endif /* Q_WS_MAC */
     1317#endif /* VBOX_WS_MAC */
    13181318
    13191319void UIMachineLogic::cleanupHandlers()
    … …  
    13451345    disconnect(uisession(), SIGNAL(sigRuntimeError(bool, const QString &, const QString &)),
    13461346               this, SLOT(sltRuntimeError(bool, const QString &, const QString &)));
    1347 #ifdef Q_WS_MAC
     1347#ifdef VBOX_WS_MAC
    13481348    disconnect(uisession(), SIGNAL(sigShowWindows()), this, SLOT(sltShowWindows()));
    1349 #endif /* Q_WS_MAC */
     1349#endif /* VBOX_WS_MAC */
    13501350    disconnect(uisession(), SIGNAL(sigGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)),
    13511351               this, SLOT(sltGuestMonitorChange(KGuestMonitorChangedEventType, ulong, QRect)));
    … …  
    13731373                case QEvent::WindowActivate:
    13741374                {
    1375 #ifdef Q_WS_WIN
     1375#ifdef VBOX_WS_WIN
    13761376                    /* We should save current lock states as *previous* and
    13771377                     * set current lock states to guest values we have,
    … …  
    13881388                        QTimer::singleShot(100, this, SLOT(sltSwitchKeyboardLedsToGuestLeds()));
    13891389                    }
    1390 #else /* Q_WS_WIN */
     1390#else /* VBOX_WS_WIN */
    13911391                    /* Trigger callback synchronously for now! */
    13921392                    sltSwitchKeyboardLedsToGuestLeds();
    1393 #endif /* !Q_WS_WIN */
     1393#endif /* !VBOX_WS_WIN */
    13941394                    break;
    13951395                }
    … …  
    14431443}
    14441444
    1445 #ifdef Q_WS_X11
     1445#ifdef VBOX_WS_X11
    14461446void UIMachineLogic::sltTypeCABS()
    14471447{
    … …  
    14561456    AssertWrapperOk(keyboard());
    14571457}
    1458 #endif /* Q_WS_X11 */
     1458#endif /* VBOX_WS_X11 */
    14591459
    14601460void UIMachineLogic::sltTypeCtrlBreak()
    … …  
    17181718    }
    17191719
    1720 #ifdef Q_WS_WIN
     1720#ifdef VBOX_WS_WIN
    17211721    /* Due to Qt bug, modal QFileDialog appeared above the active machine-window
    17221722     * does not retreive the focus from the currently focused machine-view,
    … …  
    17251725    if (activeMachineWindow())
    17261726        activeMachineWindow()->machineView()->clearFocus();
    1727 #endif /* Q_WS_WIN */
     1727#endif /* VBOX_WS_WIN */
    17281728
    17291729    /* Request the filename from the user: */
    … …  
    17361736                                                              true /* confirm overwrite */);
    17371737
    1738 #ifdef Q_WS_WIN
     1738#ifdef VBOX_WS_WIN
    17391739    /* Due to Qt bug, modal QFileDialog appeared above the active machine-window
    17401740     * does not retreive the focus from the currently focused machine-view,
    … …  
    17441744    if (activeMachineWindow())
    17451745        activeMachineWindow()->machineView()->setFocus();
    1746 #endif /* Q_WS_WIN */
     1746#endif /* VBOX_WS_WIN */
    17471747
    17481748    if (!strFilename.isEmpty())
    … …  
    17521752
    17531753        /* On X11 Qt Filedialog returns the filepath without the filetype suffix, so adding it ourselves: */
    1754 #ifdef Q_WS_X11
     1754#ifdef VBOX_WS_X11
    17551755        /* Add filetype suffix only if user has not added it explicitly: */
    17561756        if (!strFilename.endsWith(QString(".%1").arg(strFormat)))
    … …  
    17601760            tmpImage.save(QDir::toNativeSeparators(QFile::encodeName(strFilename)),
    17611761                          strFormat.toUtf8().constData());
    1762 #else /* !Q_WS_X11 */
     1762#else /* !VBOX_WS_X11 */
    17631763        tmpImage.save(QDir::toNativeSeparators(QFile::encodeName(strFilename)),
    17641764                      strFormat.toUtf8().constData());
    1765 #endif /* !Q_WS_X11 */
     1765#endif /* !VBOX_WS_X11 */
    17661766    }
    17671767    QFile::remove(strTempFile);
    … …  
    21072107#endif /* VBOX_WITH_DEBUGGER_GUI */
    21082108
    2109 #ifdef Q_WS_MAC
     2109#ifdef VBOX_WS_MAC
    21102110void UIMachineLogic::sltSwitchToMachineWindow()
    21112111{
    … …  
    21842184    gEDataManager->setDockIconDisableOverlay(fDisabled, vboxGlobal().managedVMUuid());
    21852185}
    2186 #endif /* Q_WS_MAC */
     2186#endif /* VBOX_WS_MAC */
    21872187
    21882188void UIMachineLogic::sltSwitchKeyboardLedsToGuestLeds()
    … …  
    22142214        return;
    22152215
    2216 #if defined(Q_WS_MAC)
     2216#if defined(VBOX_WS_MAC)
    22172217    if (m_pHostLedsState == NULL)
    22182218        m_pHostLedsState = DarwinHidDevicesKeepLedsState();
    22192219    DarwinHidDevicesBroadcastLeds(m_pHostLedsState, uisession()->isNumLock(), uisession()->isCapsLock(), uisession()->isScrollLock());
    2220 #elif defined(Q_WS_WIN)
     2220#elif defined(VBOX_WS_WIN)
    22212221    if (m_pHostLedsState == NULL)
    22222222        m_pHostLedsState = WinHidDevicesKeepLedsState();
    … …  
    22492249                 does dispatch loop fun, that's probably the reason for it.  Hopefully not an issue on OS X. */
    22502250        m_pHostLedsState = NULL;
    2251 #if defined(Q_WS_MAC)
     2251#if defined(VBOX_WS_MAC)
    22522252        DarwinHidDevicesApplyAndReleaseLedsState(pvLedState);
    2253 #elif defined(Q_WS_WIN)
     2253#elif defined(VBOX_WS_WIN)
    22542254        keyboardHandler()->winSkipKeyboardEvents(true);
    22552255        WinHidDevicesApplyAndReleaseLedsState(pvLedState);
    … …  
    25222522#endif /* VBOX_WITH_DEBUGGER_GUI */
    25232523
    2524 #ifdef Q_WS_MAC
     2524#ifdef VBOX_WS_MAC
    25252525void UIMachineLogic::updateMenuWindow(QMenu *pMenu)
    25262526{
    … …  
    25452545    }
    25462546}
    2547 #endif /* Q_WS_MAC */
     2547#endif /* VBOX_WS_MAC */
    25482548
    25492549void UIMachineLogic::showGlobalPreferences(const QString &strCategory /* = QString() */, const QString &strControl /* = QString() */)

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

    r58674 r60362  
    134134    void openNetworkSettingsDialog() { sltOpenNetworkSettingsDialog(); }
    135135
    136 #ifdef Q_WS_MAC
     136#ifdef VBOX_WS_MAC
    137137    void updateDockIcon();
    138138    void updateDockIconSize(int screenId, int width, int height);
    139139    UIMachineView* dockPreviewView() const;
    140 #endif /* Q_WS_MAC */
     140#endif /* VBOX_WS_MAC */
    141141
    142142    /** Save VM state, then close Runtime UI. */
    … …  
    206206    void addMachineWindow(UIMachineWindow *pMachineWindow);
    207207    void retranslateUi();
    208 #ifdef Q_WS_MAC
     208#ifdef VBOX_WS_MAC
    209209    bool isDockIconPreviewEnabled() const { return m_fIsDockIconEnabled; }
    210210    void setDockIconPreviewEnabled(bool fIsDockIconPreviewEnabled) { m_fIsDockIconEnabled = fIsDockIconPreviewEnabled; }
    211211    void updateDockOverlay();
    212 #endif /* Q_WS_MAC */
     212#endif /* VBOX_WS_MAC */
    213213
    214214    /* Prepare helpers: */
    … …  
    221221    virtual void prepareMachineWindows() = 0;
    222222    virtual void prepareMenu() {}
    223 #ifdef Q_WS_MAC
     223#ifdef VBOX_WS_MAC
    224224    virtual void prepareDock();
    225 #endif /* Q_WS_MAC */
     225#endif /* VBOX_WS_MAC */
    226226#ifdef VBOX_WITH_DEBUGGER_GUI
    227227    virtual void prepareDebugger();
    … …  
    234234    virtual void cleanupDebugger();
    235235#endif /* VBOX_WITH_DEBUGGER_GUI */
    236 #ifdef Q_WS_MAC
     236#ifdef VBOX_WS_MAC
    237237    virtual void cleanupDock();
    238 #endif /* Q_WS_MAC */
     238#endif /* VBOX_WS_MAC */
    239239    virtual void cleanupMenu() {}
    240240    virtual void cleanupMachineWindows() = 0;
    … …  
    258258    void sltToggleMouseIntegration(bool fEnabled);
    259259    void sltTypeCAD();
    260 #ifdef Q_WS_X11
     260#ifdef VBOX_WS_X11
    261261    void sltTypeCABS();
    262 #endif /* Q_WS_X11 */
     262#endif /* VBOX_WS_X11 */
    263263    void sltTypeCtrlBreak();
    264264    void sltTypeInsert();
    … …  
    346346    void updateMenuDebug(QMenu *pMenu);
    347347#endif /* VBOX_WITH_DEBUGGER_GUI */
    348 #ifdef Q_WS_MAC
     348#ifdef VBOX_WS_MAC
    349349    /** Update 'Window' menu routine. */
    350350    void updateMenuWindow(QMenu *pMenu);
    351 #endif /* Q_WS_MAC */
     351#endif /* VBOX_WS_MAC */
    352352
    353353    /** Show Global Preferences on the page defined by @a strCategory and tab defined by @a strControl. */
    … …  
    395395#endif /* VBOX_WITH_DEBUGGER_GUI */
    396396
    397 #ifdef Q_WS_MAC
     397#ifdef VBOX_WS_MAC
    398398    bool m_fIsDockIconEnabled;
    399399    UIDockIconPreview *m_pDockIconPreview;
    400400    QActionGroup *m_pDockPreviewSelectMonitorGroup;
    401401    int m_DockIconPreviewMonitor;
    402 #endif /* Q_WS_MAC */
     402#endif /* VBOX_WS_MAC */
    403403
    404404    void *m_pHostLedsState;

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

    r59843 r60362  
    4242# include "UIFrameBuffer.h"
    4343# include "VBoxFBOverlay.h"
    44 # ifdef Q_WS_MAC
     44# ifdef VBOX_WS_MAC
    4545#  include "UICocoaApplication.h"
    46 # endif /* Q_WS_MAC */
     46# endif /* VBOX_WS_MAC */
    4747# ifdef VBOX_WITH_DRAG_AND_DROP
    4848#  include "UIDnDHandler.h"
    … …  
    7272
    7373/* GUI includes: */
    74 #ifdef Q_WS_MAC
     74#ifdef VBOX_WS_MAC
    7575# include "DarwinKeyboard.h"
    7676# include "DockIconPreview.h"
    77 #endif /* Q_WS_MAC */
     77#endif /* VBOX_WS_MAC */
    7878
    7979/* COM includes: */
    … …  
    8787#include <VBox/VBoxOGL.h>
    8888#include <VBox/VBoxVideo.h>
    89 #ifdef Q_WS_MAC
     89#ifdef VBOX_WS_MAC
    9090# include <VBox/err.h>
    91 #endif /* Q_WS_MAC */
     91#endif /* VBOX_WS_MAC */
    9292
    9393/* External includes: */
    9494#include <math.h>
    95 #ifdef Q_WS_MAC
     95#ifdef VBOX_WS_MAC
    9696# include <Carbon/Carbon.h>
    97 #endif /* Q_WS_MAC */
    98 #ifdef Q_WS_X11
     97#endif /* VBOX_WS_MAC */
     98#ifdef VBOX_WS_X11
    9999# if QT_VERSION < 0x050000
    100100#  include <X11/XKBlib.h>
    … …  
    112112#  include <xcb/xcb.h>
    113113# endif /* QT_VERSION >= 0x050000 */
    114 #endif /* Q_WS_X11 */
     114#endif /* VBOX_WS_X11 */
    115115
    116116#ifdef DEBUG_andy
    … …  
    371371        frameBuffer()->performRescale();
    372372
    373 #ifdef Q_WS_MAC
     373#ifdef VBOX_WS_MAC
    374374        /* Update MacOS X dock icon size: */
    375375        machineLogic()->updateDockIconSize(screenId(), iWidth, iHeight);
    376 #endif /* Q_WS_MAC */
     376#endif /* VBOX_WS_MAC */
    377377    }
    378378
    … …  
    419419    rect.translate(-contentsX(), -contentsY());
    420420
    421 #ifdef Q_WS_MAC
     421#ifdef VBOX_WS_MAC
    422422    /* Take the backing-scale-factor into account: */
    423423    if (frameBuffer()->useUnscaledHiDPIOutput())
    … …  
    432432        }
    433433    }
    434 #endif /* Q_WS_MAC */
     434#endif /* VBOX_WS_MAC */
    435435
    436436    /* Limit the resulting part by the viewport rectangle: */
    … …  
    611611    , m_pFrameBuffer(0)
    612612    , m_previousState(KMachineState_Null)
    613 #ifdef Q_WS_MAC
     613#ifdef VBOX_WS_MAC
    614614    , m_iHostScreenNumber(0)
    615 #endif /* Q_WS_MAC */
     615#endif /* VBOX_WS_MAC */
    616616    , m_maxGuestSizePolicy(MaxGuestSizePolicy_Invalid)
    617617    , m_u64MaxGuestSize(0)
    … …  
    693693        m_pFrameBuffer->setScalingOptimizationType(gEDataManager->scalingOptimizationType(vboxGlobal().managedVMUuid()));
    694694
    695 #ifdef Q_WS_MAC
     695#ifdef VBOX_WS_MAC
    696696        /* Take backing scale-factor into account: */
    697697        m_pFrameBuffer->setBackingScaleFactor(darwinBackingScaleFactor(machineWindow()));
    698 #endif /* Q_WS_MAC */
     698#endif /* VBOX_WS_MAC */
    699699
    700700        /* Take the scale-factor related attributes into account: */
    … …  
    729729    QSize size;
    730730    {
    731 #ifdef Q_WS_X11
     731#ifdef VBOX_WS_X11
    732732        /* Processing pseudo resize-event to synchronize frame-buffer with stored framebuffer size.
    733733         * On X11 this will be additional done when the machine state was 'saved'. */
    734734        if (machine().GetState() == KMachineState_Saved)
    735735            size = guestScreenSizeHint();
    736 #endif /* Q_WS_X11 */
     736#endif /* VBOX_WS_X11 */
    737737
    738738        /* If there is a preview image saved,
    … …  
    11001100    /* Finally copy the screen-shot to pause-pixmap: */
    11011101    m_pausePixmap = QPixmap::fromImage(screenShot);
    1102 #ifdef Q_WS_MAC
     1102#ifdef VBOX_WS_MAC
    11031103# ifdef VBOX_GUI_WITH_HIDPI
    11041104    /* Adjust backing-scale-factor if necessary: */
    … …  
    11071107        m_pausePixmap.setDevicePixelRatio(dBackingScaleFactor);
    11081108# endif /* VBOX_GUI_WITH_HIDPI */
    1109 #endif /* Q_WS_MAC */
     1109#endif /* VBOX_WS_MAC */
    11101110
    11111111    /* Update scaled pause pixmap: */
    … …  
    11371137    /* Finally copy the screen-shot to pause-pixmap: */
    11381138    m_pausePixmap = QPixmap::fromImage(screenShot);
    1139 #ifdef Q_WS_MAC
     1139#ifdef VBOX_WS_MAC
    11401140# ifdef VBOX_GUI_WITH_HIDPI
    11411141    /* Adjust backing-scale-factor if necessary: */
    … …  
    11441144        m_pausePixmap.setDevicePixelRatio(dBackingScaleFactor);
    11451145# endif /* VBOX_GUI_WITH_HIDPI */
    1146 #endif /* Q_WS_MAC */
     1146#endif /* VBOX_WS_MAC */
    11471147
    11481148    /* Update scaled pause pixmap: */
    … …  
    11631163    /* Update pause pixmap finally: */
    11641164    m_pausePixmapScaled = pausePixmap().scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
    1165 #ifdef Q_WS_MAC
     1165#ifdef VBOX_WS_MAC
    11661166# ifdef VBOX_GUI_WITH_HIDPI
    11671167    /* Adjust backing-scale-factor if necessary: */
    … …  
    11701170        m_pausePixmapScaled.setDevicePixelRatio(dBackingScaleFactor);
    11711171# endif /* VBOX_GUI_WITH_HIDPI */
    1172 #endif /* Q_WS_MAC */
     1172#endif /* VBOX_WS_MAC */
    11731173}
    11741174
    … …  
    11931193    int yRange = frameBufferSize.height() - curViewportSize.height();
    11941194
    1195 #ifdef Q_WS_MAC
     1195#ifdef VBOX_WS_MAC
    11961196    /* Due to Qt 4.x doesn't supports HiDPI directly
    11971197     * we should take the backing-scale-factor into account.
    … …  
    12061206        }
    12071207    }
    1208 #endif /* Q_WS_MAC */
     1208#endif /* VBOX_WS_MAC */
    12091209
    12101210    /* Configure scroll-bars: */
    … …  
    12211221    int iContentsY = contentsY();
    12221222
    1223 #ifdef Q_WS_MAC
     1223#ifdef VBOX_WS_MAC
    12241224    /* Due to Qt 4.x doesn't supports HiDPI directly
    12251225     * we should take the backing-scale-factor into account.
    … …  
    12341234        }
    12351235    }
    1236 #endif /* Q_WS_MAC */
     1236#endif /* VBOX_WS_MAC */
    12371237
    12381238    /* Return point shifted according scroll-bars: */
    … …  
    12941294
    12951295
    1296 #ifdef Q_WS_MAC
     1296#ifdef VBOX_WS_MAC
    12971297void UIMachineView::updateDockIcon()
    12981298{
    … …  
    13291329    return ir;
    13301330}
    1331 #endif /* Q_WS_MAC */
     1331#endif /* VBOX_WS_MAC */
    13321332
    13331333UIVisualStateType UIMachineView::visualStateType() const
    … …  
    13461346    switch (pEvent->type())
    13471347    {
    1348 #ifdef Q_WS_MAC
     1348#ifdef VBOX_WS_MAC
    13491349        /* Event posted OnShowWindow: */
    13501350        case ShowWindowEventType:
    … …  
    13591359            return true;
    13601360        }
    1361 #endif /* Q_WS_MAC */
     1361#endif /* VBOX_WS_MAC */
    13621362
    13631363#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    14331433                break;
    14341434            }
    1435 #ifdef Q_WS_MAC
     1435#ifdef VBOX_WS_MAC
    14361436            case QEvent::Move:
    14371437            {
    … …  
    14571457                break;
    14581458            }
    1459 #endif /* Q_WS_MAC */
     1459#endif /* VBOX_WS_MAC */
    14601460            default:
    14611461                break;
    … …  
    14941494        else
    14951495            painter.drawPixmap(rect.topLeft(), pausePixmapScaled());
    1496 #ifdef Q_WS_MAC
     1496#ifdef VBOX_WS_MAC
    14971497        /* Update the dock icon: */
    14981498        updateDockIcon();
    1499 #endif /* Q_WS_MAC */
     1499#endif /* VBOX_WS_MAC */
    15001500        return;
    15011501    }
    … …  
    15041504    if (m_pFrameBuffer)
    15051505        m_pFrameBuffer->handlePaintEvent(pPaintEvent);
    1506 #ifdef Q_WS_MAC
     1506#ifdef VBOX_WS_MAC
    15071507    /* Update the dock icon if we are in the running state: */
    15081508    if (uisession()->isRunning())
    15091509        updateDockIcon();
    1510 #endif /* Q_WS_MAC */
     1510#endif /* VBOX_WS_MAC */
    15111511}
    15121512
    … …  
    16921692
    16931693#if QT_VERSION < 0x050000
    1694 # if defined(Q_WS_MAC)
     1694# if defined(VBOX_WS_MAC)
    16951695
    16961696bool UIMachineView::macEvent(const void *pvCocoaEvent, EventRef event)
    … …  
    17371737}
    17381738
    1739 # elif defined(Q_WS_WIN)
     1739# elif defined(VBOX_WS_WIN)
    17401740
    17411741bool UIMachineView::winEvent(MSG *pMsg, long* /* piResult */)
    … …  
    17791779}
    17801780
    1781 # elif defined(Q_WS_X11)
     1781# elif defined(VBOX_WS_X11)
    17821782
    17831783bool UIMachineView::x11Event(XEvent *pEvent)
    … …  
    18171817}
    18181818
    1819 # endif /* Q_WS_X11 */
     1819# endif /* VBOX_WS_X11 */
    18201820#else /* QT_VERSION >= 0x050000 */
    18211821
    18221822bool UIMachineView::nativeEvent(const QByteArray &eventType, void *pMessage)
    18231823{
    1824 # if defined(Q_WS_MAC)
     1824# if defined(VBOX_WS_MAC)
    18251825
    18261826    /* Make sure it's generic NSEvent: */
    … …  
    18571857    }
    18581858
    1859 # elif defined(Q_WS_WIN)
     1859# elif defined(VBOX_WS_WIN)
    18601860
    18611861    /* Make sure it's generic MSG event: */
    … …  
    18821882    }
    18831883
    1884 # elif defined(Q_WS_X11)
     1884# elif defined(VBOX_WS_X11)
    18851885
    18861886    /* Make sure it's generic XCB event: */
    … …  
    19241924        size = QSize((int)(size.width() * dScaleFactor), (int)(size.height() * dScaleFactor));
    19251925
    1926 #ifdef Q_WS_MAC
     1926#ifdef VBOX_WS_MAC
    19271927    /* Take the backing-scale-factor into account: */
    19281928    if (frameBuffer()->useUnscaledHiDPIOutput())
    … …  
    19321932            size = QSize(size.width() / dBackingScaleFactor, size.height() / dBackingScaleFactor);
    19331933    }
    1934 #endif /* Q_WS_MAC */
     1934#endif /* VBOX_WS_MAC */
    19351935
    19361936    /* Return result: */
    … …  
    19401940QSize UIMachineView::scaledBackward(QSize size) const
    19411941{
    1942 #ifdef Q_WS_MAC
     1942#ifdef VBOX_WS_MAC
    19431943    /* Take the backing-scale-factor into account: */
    19441944    if (frameBuffer()->useUnscaledHiDPIOutput())
    … …  
    19481948            size = QSize(size.width() * dBackingScaleFactor, size.height() * dBackingScaleFactor);
    19491949    }
    1950 #endif /* Q_WS_MAC */
     1950#endif /* VBOX_WS_MAC */
    19511951
    19521952    /* Take the scale-factor into account: */

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

    r59658 r60362  
    3535/* Other VBox includes: */
    3636#include "VBox/com/ptr.h"
    37 #ifdef Q_WS_MAC
     37#ifdef VBOX_WS_MAC
    3838# if QT_VERSION >= 0x050000
    3939#  include <ApplicationServices/ApplicationServices.h>
    4040# endif /* QT_VERSION >= 0x050000 */
    41 #endif /* Q_WS_MAC */
     41#endif /* VBOX_WS_MAC */
    4242
    4343/* External includes: */
    44 #ifdef Q_WS_MAC
     44#ifdef VBOX_WS_MAC
    4545# include <CoreFoundation/CFBase.h>
    46 #endif /* Q_WS_MAC */
     46#endif /* VBOX_WS_MAC */
    4747
    4848/* Forward declarations: */
    … …  
    5757class CMachine;
    5858class CSession;
    59 #ifdef Q_WS_X11
     59#ifdef VBOX_WS_X11
    6060# if QT_VERSION < 0x050000
    6161typedef union _XEvent XEvent;
    6262# endif /* QT_VERSION < 0x050000 */
    63 #endif /* Q_WS_X11 */
     63#endif /* VBOX_WS_X11 */
    6464#ifdef VBOX_WITH_DRAG_AND_DROP
    6565 class CDnDTarget;
    … …  
    262262    static void dimImage(QImage &img);
    263263    void scrollContentsBy(int dx, int dy);
    264 #ifdef Q_WS_MAC
     264#ifdef VBOX_WS_MAC
    265265    void updateDockIcon();
    266266    CGImageRef vmContentImage();
    267267    CGImageRef frameBuffertoCGImageRef(UIFrameBuffer *pFrameBuffer);
    268 #endif /* Q_WS_MAC */
     268#endif /* VBOX_WS_MAC */
    269269    /** What view mode (normal, fullscreen etc.) are we in? */
    270270    UIVisualStateType visualStateType() const;
    … …  
    346346
    347347#if QT_VERSION < 0x050000
    348 # if defined(Q_WS_MAC)
     348# if defined(VBOX_WS_MAC)
    349349    /** Qt4: Mac: Performs pre-processing of all the native events.
    350350      * @note     Take into account this function is _not_ called by
    … …  
    352352      *           only by the keyboard-hook of the keyboard-handler. */
    353353    virtual bool macEvent(const void *pvCocoaEvent, EventRef event);
    354 # elif defined(Q_WS_WIN)
     354# elif defined(VBOX_WS_WIN)
    355355    /** Qt4: Win: Performs pre-processing of all the native events.
    356356      * @note     Take into account this function is called by
    … …  
    358358      *           because it has required signature. */
    359359    virtual bool winEvent(MSG *pMsg, long *piResult);
    360 # elif defined(Q_WS_X11)
     360# elif defined(VBOX_WS_X11)
    361361    /** Qt4: X11: Performs pre-processing of all the native events.
    362362      * @note     Take into account this function is called by
    … …  
    364364      *           because it has required signature. */
    365365    virtual bool x11Event(XEvent *pEvent);
    366 # endif /* Q_WS_X11 */
     366# endif /* VBOX_WS_X11 */
    367367#else /* QT_VERSION >= 0x050000 */
    368368    /** Qt5: Performs pre-processing of all the native events.
    … …  
    388388    QSize m_sizeHintOverride;
    389389
    390 #ifdef Q_WS_MAC
     390#ifdef VBOX_WS_MAC
    391391    /** Holds current host-screen number. */
    392392    int m_iHostScreenNumber;
    393 #endif /* Q_WS_MAC */
     393#endif /* VBOX_WS_MAC */
    394394
    395395    /** The policy for calculating the maximum guest resolution which we wish

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

    r59911 r60362  
    5656
    5757/* External includes: */
    58 #ifdef Q_WS_X11
     58#ifdef VBOX_WS_X11
    5959# if QT_VERSION < 0x050000
    6060#  include <X11/Xlib.h>
    6161# endif /* QT_VERSION < 0x050000 */
    62 #endif /* Q_WS_X11 */
     62#endif /* VBOX_WS_X11 */
    6363
    6464
    … …  
    181181    , m_pRightSpacer(0)
    182182{
    183 #ifndef Q_WS_MAC
     183#ifndef VBOX_WS_MAC
    184184    /* On Mac OS X window icon referenced in info.plist is used. */
    185185
    … …  
    194194    else
    195195        setWindowIcon(vboxGlobal().vmGuestOSTypeIcon(machine().GetOSTypeId()));
    196 #endif /* !Q_WS_MAC */
     196#endif /* !VBOX_WS_MAC */
    197197}
    198198
    … …  
    261261}
    262262
    263 #ifdef Q_WS_X11
     263#ifdef VBOX_WS_X11
    264264# if QT_VERSION < 0x050000
    265265bool UIMachineWindow::x11Event(XEvent *pEvent)
    … …  
    284284}
    285285# endif /* QT_VERSION < 0x050000 */
    286 #endif /* Q_WS_X11 */
     286#endif /* VBOX_WS_X11 */
    287287
    288288void UIMachineWindow::showEvent(QShowEvent *pShowEvent)
    … …  
    558558            strMachineName += " [" + gpConverter->toString(state) + "]";
    559559        /* Unusual on the Mac. */
    560 #ifndef Q_WS_MAC
     560#ifndef VBOX_WS_MAC
    561561        const QString strUserProductName = uisession()->machineWindowNamePostfix();
    562562        strMachineName += " - " + (strUserProductName.isEmpty() ? defaultWindowTitle() : strUserProductName);
    563 #endif /* !Q_WS_MAC */
     563#endif /* !VBOX_WS_MAC */
    564564        if (machine().GetMonitorCount() > 1)
    565565            strMachineName += QString(" : %1").arg(m_uScreenId + 1);
    … …  
    591591}
    592592
    593 #ifdef Q_WS_MAC
     593#ifdef VBOX_WS_MAC
    594594void UIMachineWindow::handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey)
    595595{
    … …  
    652652    }
    653653}
    654 #endif /* Q_WS_MAC */
    655 
     654#endif /* VBOX_WS_MAC */
     655

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

    r58943 r60362  
    2525#include "QIWithRetranslateUI.h"
    2626#include "UIExtraDataDefs.h"
    27 #ifdef Q_WS_MAC
     27#ifdef VBOX_WS_MAC
    2828# include "VBoxUtils-darwin.h"
    29 #endif /* Q_WS_MAC */
     29#endif /* VBOX_WS_MAC */
    3030
    3131/* COM includes: */
    … …  
    4242class UIMachineView;
    4343class CSession;
    44 #ifdef Q_WS_X11
     44#ifdef VBOX_WS_X11
    4545# if QT_VERSION < 0x050000
    4646typedef union _XEvent XEvent;
    4747# endif /* QT_VERSION < 0x050000 */
    48 #endif /* Q_WS_X11 */
     48#endif /* VBOX_WS_X11 */
    4949
    5050
    … …  
    122122
    123123    /* Event handlers: */
    124 #ifdef Q_WS_X11
     124#ifdef VBOX_WS_X11
    125125# if QT_VERSION < 0x050000
    126126    /** X11: Qt4: Handles all native events. */
    127127    bool x11Event(XEvent *pEvent);
    128128# endif /* QT_VERSION < 0x050000 */
    129 #endif /* Q_WS_X11 */
     129#endif /* VBOX_WS_X11 */
    130130
    131131    /** Show event handler. */
    … …  
    135135    void closeEvent(QCloseEvent *pCloseEvent);
    136136
    137 #ifdef Q_WS_MAC
     137#ifdef VBOX_WS_MAC
    138138    /** Mac OS X: Handles native notifications.
    139139      * @param  strNativeNotificationName  Native notification name. */
    … …  
    144144      * @param  fWithOptionKey  Brings whether the Option key was held. */
    145145    virtual void handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey);
    146 #endif /* Q_WS_MAC */
     146#endif /* VBOX_WS_MAC */
    147147
    148148    /* Prepare helpers: */
    … …  
    176176    static Qt::Alignment viewAlignment(UIVisualStateType visualStateType);
    177177
    178 #ifdef Q_WS_MAC
     178#ifdef VBOX_WS_MAC
    179179    /** Mac OS X: Handles native notifications.
    180180      * @param  strNativeNotificationName  Native notification name.
    … …  
    187187      * @param  pWidget         Brings widget, callback related to. */
    188188    static void handleStandardWindowButtonCallback(StandardWindowButtonType enmButtonType, bool fWithOptionKey, QWidget *pWidget);
    189 #endif /* Q_WS_MAC */
     189#endif /* VBOX_WS_MAC */
    190190
    191191    /* Variables: */

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

    r56757 r60362  
    2727# include <QPainter>
    2828# include <QMenu>
    29 # ifndef Q_WS_MAC
     29# ifndef VBOX_WS_MAC
    3030#  include <QCheckBox>
    31 # endif /* !Q_WS_MAC */
     31# endif /* !VBOX_WS_MAC */
    3232
    3333/* GUI includes: */
    … …  
    5757    , m_pToolBar(0)
    5858    , m_pButtonClose(0)
    59 #ifndef Q_WS_MAC
     59#ifndef VBOX_WS_MAC
    6060    , m_pCheckBoxEnable(0)
    61 #endif /* !Q_WS_MAC */
     61#endif /* !VBOX_WS_MAC */
    6262{
    6363    /* Prepare: */
    … …  
    8181}
    8282
    83 #ifndef Q_WS_MAC
     83#ifndef VBOX_WS_MAC
    8484bool UIMenuBarEditorWidget::isMenuBarEnabled() const
    8585{
    … …  
    101101    m_pCheckBoxEnable->setChecked(fEnabled);
    102102}
    103 #endif /* !Q_WS_MAC */
     103#endif /* !VBOX_WS_MAC */
    104104
    105105void UIMenuBarEditorWidget::setRestrictionsOfMenuBar(UIExtraDataMetaDefs::MenuType restrictions)
    … …  
    308308#endif /* VBOX_WITH_DEBUGGER_GUI */
    309309
    310 #ifdef Q_WS_MAC
     310#ifdef VBOX_WS_MAC
    311311void UIMenuBarEditorWidget::setRestrictionsOfMenuWindow(UIExtraDataMetaDefs::MenuWindowActionType restrictions)
    312312{
    … …  
    337337    }
    338338}
    339 #endif /* Q_WS_MAC */
     339#endif /* VBOX_WS_MAC */
    340340
    341341void UIMenuBarEditorWidget::setRestrictionsOfMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType restrictions)
    … …  
    384384    setRestrictionsOfMenuDebug(gEDataManager->restrictedRuntimeMenuDebuggerActionTypes(machineID()));
    385385#endif /* VBOX_WITH_DEBUGGER_GUI */
    386 #ifdef Q_WS_MAC
     386#ifdef VBOX_WS_MAC
    387387    setRestrictionsOfMenuWindow(gEDataManager->restrictedRuntimeMenuWindowActionTypes(machineID()));
    388 #endif /* Q_WS_MAC */
     388#endif /* VBOX_WS_MAC */
    389389    setRestrictionsOfMenuHelp(gEDataManager->restrictedRuntimeMenuHelpActionTypes(machineID()));
    390390}
    … …  
    534534        }
    535535#endif /* VBOX_WITH_DEBUGGER_GUI */
    536 #ifdef Q_WS_MAC
     536#ifdef VBOX_WS_MAC
    537537        case UIExtraDataMetaDefs::MenuType_Window:
    538538        {
    … …  
    554554            break;
    555555        }
    556 #endif /* Q_WS_MAC */
     556#endif /* VBOX_WS_MAC */
    557557        case UIExtraDataMetaDefs::MenuType_Help:
    558558        {
    … …  
    602602        if (iTop >= 5)
    603603            iTop -= 5;
    604 #ifndef Q_WS_MAC
     604#ifndef VBOX_WS_MAC
    605605        /* Right margin should be bigger for the settings case: */
    606606        if (m_fStartedFromVMSettings)
    607607            iRight += 5;
    608 #endif /* !Q_WS_MAC */
     608#endif /* !VBOX_WS_MAC */
    609609        /* Apply margins/spacing finally: */
    610610        m_pMainLayout->setContentsMargins(iLeft, iTop, iRight, iBottom);
    … …  
    636636            }
    637637        }
    638 #ifndef Q_WS_MAC
     638#ifndef VBOX_WS_MAC
    639639        /* Create enable-checkbox if necessary: */
    640640        else
    … …  
    649649            }
    650650        }
    651 #endif /* !Q_WS_MAC */
     651#endif /* !VBOX_WS_MAC */
    652652    }
    653653
    … …  
    670670    prepareMenuDebug();
    671671#endif /* VBOX_WITH_DEBUGGER_GUI */
    672 #ifdef Q_WS_MAC
     672#ifdef VBOX_WS_MAC
    673673    prepareMenuWindow();
    674 #endif /* Q_WS_MAC */
     674#endif /* VBOX_WS_MAC */
    675675    prepareMenuHelp();
    676676
    … …  
    687687        setRestrictionsOfMenuDebug(gEDataManager->restrictedRuntimeMenuDebuggerActionTypes(machineID()));
    688688#endif /* VBOX_WITH_DEBUGGER_GUI */
    689 #ifdef Q_WS_MAC
     689#ifdef VBOX_WS_MAC
    690690        setRestrictionsOfMenuWindow(gEDataManager->restrictedRuntimeMenuWindowActionTypes(machineID()));
    691 #endif /* Q_WS_MAC */
     691#endif /* VBOX_WS_MAC */
    692692        setRestrictionsOfMenuHelp(gEDataManager->restrictedRuntimeMenuHelpActionTypes(machineID()));
    693693        /* And listen for the menu-bar configuration changes after that: */
    … …  
    697697}
    698698
    699 #ifdef Q_WS_MAC
     699#ifdef VBOX_WS_MAC
    700700QMenu* UIMenuBarEditorWidget::prepareNamedMenu(const QString &strName)
    701701{
    … …  
    734734    return pNamedMenu;
    735735}
    736 #endif /* Q_WS_MAC */
     736#endif /* VBOX_WS_MAC */
    737737
    738738QMenu* UIMenuBarEditorWidget::prepareCopiedMenu(const UIAction *pAction)
    … …  
    843843{
    844844    /* Copy menu: */
    845 #ifdef Q_WS_MAC
     845#ifdef VBOX_WS_MAC
    846846    QMenu *pMenu = prepareNamedMenu("Application");
    847 #else /* !Q_WS_MAC */
     847#else /* !VBOX_WS_MAC */
    848848    QMenu *pMenu = prepareCopiedMenu(actionPool()->action(UIActionIndex_M_Application));
    849 #endif /* !Q_WS_MAC */
     849#endif /* !VBOX_WS_MAC */
    850850    AssertPtrReturnVoid(pMenu);
    851851    {
    852 #ifdef Q_WS_MAC
     852#ifdef VBOX_WS_MAC
    853853        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_M_Application_S_About));
    854854# ifdef VBOX_GUI_WITH_NETWORK_MANAGER
    … …  
    858858        pMenu->addSeparator();
    859859        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_M_Application_S_Preferences));
    860 #else /* !Q_WS_MAC */
     860#else /* !VBOX_WS_MAC */
    861861        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_M_Application_S_Preferences));
    862862        pMenu->addSeparator();
    … …  
    865865# endif /* VBOX_GUI_WITH_NETWORK_MANAGER */
    866866        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_M_Application_S_ResetWarnings));
    867 #endif /* !Q_WS_MAC */
     867#endif /* !VBOX_WS_MAC */
    868868    }
    869869}
    … …  
    966966#endif /* VBOX_WITH_DEBUGGER_GUI */
    967967
    968 #ifdef Q_WS_MAC
     968#ifdef VBOX_WS_MAC
    969969void UIMenuBarEditorWidget::prepareMenuWindow()
    970970{
    … …  
    980980    }
    981981}
    982 #endif /* Q_WS_MAC */
     982#endif /* VBOX_WS_MAC */
    983983
    984984void UIMenuBarEditorWidget::prepareMenuHelp()
    … …  
    991991        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_Simple_WebSite));
    992992        pMenu->addSeparator();
    993 #ifndef Q_WS_MAC
     993#ifndef VBOX_WS_MAC
    994994        prepareCopiedAction(pMenu, actionPool()->action(UIActionIndex_Simple_About));
    995 #endif /* !Q_WS_MAC */
     995#endif /* !VBOX_WS_MAC */
    996996    }
    997997}
    … …  
    10021002    if (!m_fStartedFromVMSettings && m_pButtonClose)
    10031003        m_pButtonClose->setToolTip(tr("Close"));
    1004 #ifndef Q_WS_MAC
     1004#ifndef VBOX_WS_MAC
    10051005    /* Translate enable-checkbox if necessary: */
    10061006    if (m_fStartedFromVMSettings && m_pCheckBoxEnable)
    10071007        m_pCheckBoxEnable->setToolTip(tr("Enable Menu Bar"));
    1008 #endif /* !Q_WS_MAC */
     1008#endif /* !VBOX_WS_MAC */
    10091009}
    10101010
    … …  
    10201020    color1.setAlpha(0);
    10211021    QColor color2 = pal.color(QPalette::Window).darker(200);
    1022 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     1022#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    10231023    QColor color3 = pal.color(QPalette::Window).darker(120);
    1024 #endif /* Q_WS_WIN || Q_WS_X11 */
     1024#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    10251025
    10261026    /* Left corner: */
    … …  
    10631063    painter.fillRect(QRect(width() - 5, 0, 5, height() - 5), grad5); // right line
    10641064
    1065 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     1065#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    10661066    /* Paint frames: */
    10671067    painter.save();
    … …  
    10731073        painter.drawLine(QLine(QPoint(width() - 1 - 5 - 1, 0), QPoint(5 + 1, 0)));
    10741074    painter.restore();
    1075 #endif /* Q_WS_WIN || Q_WS_X11 */
     1075#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    10761076}
    10771077
    10781078
    10791079UIMenuBarEditorWindow::UIMenuBarEditorWindow(UIMachineWindow *pParent, UIActionPool *pActionPool)
    1080 #ifndef Q_WS_MAC
     1080#ifndef VBOX_WS_MAC
    10811081    : UISlidingToolBar(pParent, pParent->menuBar(), new UIMenuBarEditorWidget(0, false, vboxGlobal().managedVMUuid(), pActionPool), UISlidingToolBar::Position_Top)
    1082 #else /* Q_WS_MAC */
     1082#else /* VBOX_WS_MAC */
    10831083    : UISlidingToolBar(pParent, 0, new UIMenuBarEditorWidget(0, false, vboxGlobal().managedVMUuid(), pActionPool), UISlidingToolBar::Position_Top)
    1084 #endif /* Q_WS_MAC */
    1085 {
    1086 }
    1087 
     1084#endif /* VBOX_WS_MAC */
     1085{
     1086}
     1087

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

    r56757 r60362  
    3333class UIAction;
    3434class QIToolButton;
    35 #ifndef Q_WS_MAC
     35#ifndef VBOX_WS_MAC
    3636class QCheckBox;
    37 #endif /* !Q_WS_MAC */
     37#endif /* !VBOX_WS_MAC */
    3838class QHBoxLayout;
    3939class QAction;
    … …  
    8686    void setActionPool(UIActionPool *pActionPool);
    8787
    88 #ifndef Q_WS_MAC
     88#ifndef VBOX_WS_MAC
    8989    /** Returns whether the menu-bar enabled. */
    9090    bool isMenuBarEnabled() const;
    9191    /** Defines whether the menu-bar @a fEnabled. */
    9292    void setMenuBarEnabled(bool fEnabled);
    93 #endif /* !Q_WS_MAC */
     93#endif /* !VBOX_WS_MAC */
    9494
    9595    /** Returns the cached restrictions of menu-bar. */
    … …  
    109109    UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType restrictionsOfMenuDebug() const { return m_restrictionsOfMenuDebug; }
    110110#endif /* VBOX_WITH_DEBUGGER_GUI */
    111 #ifdef Q_WS_MAC
     111#ifdef VBOX_WS_MAC
    112112    /** Mac OS X: Returns the cached restrictions of menu 'Window'. */
    113113    UIExtraDataMetaDefs::MenuWindowActionType restrictionsOfMenuWindow() const { return m_restrictionsOfMenuWindow; }
    114 #endif /* Q_WS_MAC */
     114#endif /* VBOX_WS_MAC */
    115115    /** Returns the cached restrictions of menu 'Help'. */
    116116    UIExtraDataMetaDefs::MenuHelpActionType restrictionsOfMenuHelp() const { return m_restrictionsOfMenuHelp; }
    … …  
    132132    void setRestrictionsOfMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType restrictions);
    133133#endif /* VBOX_WITH_DEBUGGER_GUI */
    134 #ifdef Q_WS_MAC
     134#ifdef VBOX_WS_MAC
    135135    /** Mac OS X: Defines the cached @a restrictions of menu 'Window'. */
    136136    void setRestrictionsOfMenuWindow(UIExtraDataMetaDefs::MenuWindowActionType restrictions);
    137 #endif /* Q_WS_MAC */
     137#endif /* VBOX_WS_MAC */
    138138    /** Defines the cached @a restrictions of menu 'Help'. */
    139139    void setRestrictionsOfMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType restrictions);
    … …  
    152152    void prepare();
    153153
    154 #ifdef Q_WS_MAC
     154#ifdef VBOX_WS_MAC
    155155    /** Prepare named menu routine. */
    156156    QMenu* prepareNamedMenu(const QString &strName);
    157 #endif /* Q_WS_MAC */
     157#endif /* VBOX_WS_MAC */
    158158    /** Prepare copied menu routine. */
    159159    QMenu* prepareCopiedMenu(const UIAction *pAction);
    … …  
    184184    void prepareMenuDebug();
    185185#endif /* VBOX_WITH_DEBUGGER_GUI */
    186 #ifdef Q_WS_MAC
     186#ifdef VBOX_WS_MAC
    187187    /** Mac OS X: Prepare 'Window' menu routine. */
    188188    void prepareMenuWindow();
    189 #endif /* Q_WS_MAC */
     189#endif /* VBOX_WS_MAC */
    190190    /** Prepare 'Help' menu routine. */
    191191    void prepareMenuHelp();
    … …  
    217217        /** Holds the close-button instance. */
    218218        QIToolButton *m_pButtonClose;
    219 #ifndef Q_WS_MAC
     219#ifndef VBOX_WS_MAC
    220220        /** Non Mac OS X: Holds the enable-checkbox instance. */
    221221        QCheckBox *m_pCheckBoxEnable;
    222 #endif /* !Q_WS_MAC */
     222#endif /* !VBOX_WS_MAC */
    223223        /** Holds tool-bar action references. */
    224224        QMap<QString, QAction*> m_actions;
    … …  
    243243        UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType m_restrictionsOfMenuDebug;
    244244#endif /* VBOX_WITH_DEBUGGER_GUI */
    245 #ifdef Q_WS_MAC
     245#ifdef VBOX_WS_MAC
    246246        /** Mac OS X: Holds the cached restrictions of menu 'Window'. */
    247247        UIExtraDataMetaDefs::MenuWindowActionType m_restrictionsOfMenuWindow;
    248 #endif /* Q_WS_MAC */
     248#endif /* VBOX_WS_MAC */
    249249        /** Holds the cached restrictions of menu 'Help'. */
    250250        UIExtraDataMetaDefs::MenuHelpActionType m_restrictionsOfMenuHelp;

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

    r59092 r60362  
    3737# include "UIMouseHandler.h"
    3838# include "UIFrameBuffer.h"
    39 # ifdef Q_WS_MAC
     39# ifdef VBOX_WS_MAC
    4040#  include "VBoxUtils-darwin.h"
    41 # endif /* Q_WS_MAC */
    42 # ifdef Q_WS_WIN
     41# endif /* VBOX_WS_MAC */
     42# ifdef VBOX_WS_WIN
    4343#  include "VBoxUtils-win.h"
    44 # endif /* Q_WS_WIN */
     44# endif /* VBOX_WS_WIN */
    4545
    4646/* COM includes: */
    … …  
    5959
    6060/* External includes: */
    61 #ifdef Q_WS_X11
     61#ifdef VBOX_WS_X11
    6262# if QT_VERSION < 0x050000
    6363#  include <X11/Xlib.h>
    … …  
    6767#  endif /* FocusOut */
    6868# endif /* QT_VERSION < 0x050000 */
    69 #endif /* Q_WS_X11 */
     69#endif /* VBOX_WS_X11 */
    7070
    7171
    … …  
    186186        visibleRectangle = visibleRectangle.intersected(vboxGlobal().availableGeometry(machineLogic()->machineWindows()[m_iMouseCaptureViewIndex]));
    187187
    188 #ifdef Q_WS_WIN
     188#ifdef VBOX_WS_WIN
    189189        /* Move the mouse to the center of the visible area: */
    190190        m_lastMousePos = visibleRectangle.center();
    … …  
    192192        /* Update mouse clipping: */
    193193        updateMouseCursorClipping();
    194 #elif defined (Q_WS_MAC)
     194#elif defined (VBOX_WS_MAC)
    195195        /* Grab all mouse events: */
    196196        ::darwinMouseGrab(m_viewports[m_iMouseCaptureViewIndex]);
    197 #else /* Q_WS_MAC */
     197#else /* VBOX_WS_MAC */
    198198        /* Remember current mouse position: */
    199199        m_lastMousePos = QCursor::pos();
    200200        /* Grab all mouse events: */
    201201        m_viewports[m_iMouseCaptureViewIndex]->grabMouse();
    202 #endif /* !Q_WS_MAC */
     202#endif /* !VBOX_WS_MAC */
    203203
    204204        /* Switch guest mouse to the relative mode: */
    … …  
    224224        /* Return the cursor to where it was when we captured it: */
    225225        QCursor::setPos(m_capturedMousePos);
    226 #ifdef Q_WS_WIN
     226#ifdef VBOX_WS_WIN
    227227        /* Update mouse clipping: */
    228228        updateMouseCursorClipping();
    229 #elif defined(Q_WS_MAC)
     229#elif defined(VBOX_WS_MAC)
    230230        /* Releasing grabbed mouse from that view: */
    231231        ::darwinMouseRelease(m_viewports[m_iMouseCaptureViewIndex]);
    232 #else /* Q_WS_MAC */
     232#else /* VBOX_WS_MAC */
    233233        /* Releasing grabbed mouse from that view: */
    234234        m_viewports[m_iMouseCaptureViewIndex]->releaseMouse();
    235 #endif /* !Q_WS_MAC */
     235#endif /* !VBOX_WS_MAC */
    236236        /* Reset mouse-capture index: */
    237237        m_iMouseCaptureViewIndex = -1;
    … …  
    264264}
    265265
    266 #ifdef Q_WS_X11
     266#ifdef VBOX_WS_X11
    267267# if QT_VERSION < 0x050000
    268268bool UIMouseHandler::x11EventFilter(XEvent *pEvent, ulong /* uScreenId */)
    … …  
    294294}
    295295# endif /* QT_VERSION < 0x050000 */
    296 #endif /* Q_WS_X11 */
     296#endif /* VBOX_WS_X11 */
    297297
    298298/* Machine state-change handler: */
    … …  
    436436        /* Activate it: */
    437437        m_pHoveredWindow->activateWindow();
    438 #ifdef Q_WS_X11
     438#ifdef VBOX_WS_X11
    439439        /* On X11 its not enough to just activate window if you
    440440         * want to raise it also, so we will make it separately: */
    441441        m_pHoveredWindow->raise();
    442 #endif /* Q_WS_X11 */
     442#endif /* VBOX_WS_X11 */
    443443    }
    444444}
    … …  
    503503        if (m_windows.values().contains(pWatchedWidget))
    504504        {
    505 #ifdef Q_WS_WIN
     505#ifdef VBOX_WS_WIN
    506506            /* Handle window events: */
    507507            switch (pEvent->type())
    … …  
    517517                    break;
    518518            }
    519 #endif /* Q_WS_WIN */
     519#endif /* VBOX_WS_WIN */
    520520        }
    521521
    … …  
    553553            switch (pEvent->type())
    554554            {
    555 #ifdef Q_WS_MAC
     555#ifdef VBOX_WS_MAC
    556556                case UIGrabMouseEvent::GrabMouseEvent:
    557557                {
    … …  
    566566                    break;
    567567                }
    568 #endif /* Q_WS_MAC */
     568#endif /* VBOX_WS_MAC */
    569569                case QEvent::MouseMove:
    570570                case QEvent::MouseButtonRelease:
    … …  
    604604                    }
    605605
    606 #ifdef Q_WS_X11
     606#ifdef VBOX_WS_X11
    607607                    /* Make sure that we are focused after a click.  Rather
    608608                     * ugly, but works around a problem with GNOME
    … …  
    611611                    if (pEvent->type() == QEvent::MouseButtonRelease)
    612612                        pWatchedWidget->window()->activateWindow();
    613 #endif /* Q_WS_X11 */
     613#endif /* VBOX_WS_X11 */
    614614                    /* Check if we should activate window under cursor: */
    615615                    if (gEDataManager->activateHoveredMachineWindow() &&
    … …  
    667667                    if (mouseEvent(pWheelEvent->type(), uScreenId,
    668668                                   pWheelEvent->pos(), pWheelEvent->globalPos(),
    669 #ifdef Q_WS_MAC
     669#ifdef VBOX_WS_MAC
    670670                                   /* Qt Cocoa is buggy. It always reports a left button pressed when the
    671671                                    * mouse wheel event occurs. A workaround is to ask the application which
    672672                                    * buttons are pressed currently: */
    673673                                   QApplication::mouseButtons(),
    674 #else /* !Q_WS_MAC */
     674#else /* !VBOX_WS_MAC */
    675675                                   pWheelEvent->buttons(),
    676 #endif /* !Q_WS_MAC */
     676#endif /* !VBOX_WS_MAC */
    677677                                   iDelta, pWheelEvent->orientation()))
    678678                        return true;
    679679                    break;
    680680                }
    681 #ifdef Q_WS_MAC
     681#ifdef VBOX_WS_MAC
    682682                case QEvent::Leave:
    683683                {
    … …  
    697697                    break;
    698698                }
    699 #endif /* Q_WS_MAC */
    700 #ifdef Q_WS_WIN
     699#endif /* VBOX_WS_MAC */
     700#ifdef VBOX_WS_WIN
    701701                case QEvent::Resize:
    702702                {
    … …  
    705705                    break;
    706706                }
    707 #endif /* Q_WS_WIN */
     707#endif /* VBOX_WS_WIN */
    708708                default:
    709709                    break;
    … …  
    715715
    716716/* Try to detect if the mouse event is fake and actually generated by a touch device. */
    717 #ifdef Q_WS_WIN
     717#ifdef VBOX_WS_WIN
    718718#if (WINVER < 0x0601)
    719719typedef enum tagINPUT_MESSAGE_DEVICE_TYPE {
    … …  
    776776}
    777777#else
    778 /* Apparently Q_WS_MAC does not generate fake mouse events.
     778/* Apparently VBOX_WS_MAC does not generate fake mouse events.
    779779 * Other platforms, which have no known method to detect fake events are handled here too.
    780780 */
    … …  
    817817        iMouseButtonsState |= KMouseButtonState_XButton2;
    818818
    819 #ifdef Q_WS_MAC
     819#ifdef VBOX_WS_MAC
    820820    /* Simulate the right click on host-key + left-mouse-button: */
    821821    if (machineLogic()->keyboardHandler()->isHostKeyPressed() &&
    … …  
    823823        iMouseButtonsState == KMouseButtonState_LeftButton)
    824824        iMouseButtonsState = KMouseButtonState_RightButton;
    825 #endif /* Q_WS_MAC */
     825#endif /* VBOX_WS_MAC */
    826826
    827827    int iWheelVertical = 0;
    … …  
    839839    if (uisession()->isMouseCaptured())
    840840    {
    841 #ifdef Q_WS_WIN
     841#ifdef VBOX_WS_WIN
    842842        /* Send pending WM_PAINT events: */
    843843        ::UpdateWindow((HWND)m_viewports[uScreenId]->winId());
    … …  
    847847                              iWheelVertical, iWheelHorizontal, iMouseButtonsState);
    848848
    849 #ifdef Q_WS_WIN
     849#ifdef VBOX_WS_WIN
    850850        /* Bringing mouse to the opposite side to simulate the endless moving: */
    851851
    … …  
    880880        else
    881881            m_lastMousePos = globalPos;
    882 #else /* Q_WS_WIN */
     882#else /* VBOX_WS_WIN */
    883883        int iWe = QApplication::desktop()->width() - 1;
    884884        int iHe = QApplication::desktop()->height() - 1;
    … …  
    897897            m_lastMousePos =  p;
    898898            /* No need for cursor updating on the Mac, there is no one. */
    899 # ifndef Q_WS_MAC
     899# ifndef VBOX_WS_MAC
    900900            QCursor::setPos(m_lastMousePos);
    901 # endif /* Q_WS_MAC */
     901# endif /* VBOX_WS_MAC */
    902902        }
    903903        else
    904904            m_lastMousePos = globalPos;
    905 #endif /* !Q_WS_WIN */
     905#endif /* !VBOX_WS_WIN */
    906906        return true; /* stop further event handling */
    907907    }
    … …  
    940940            }
    941941
    942 #ifdef Q_WS_MAC
     942#ifdef VBOX_WS_MAC
    943943            /* Take the backing-scale-factor into account: */
    944944            if (pFrameBuffer->useUnscaledHiDPIOutput())
    … …  
    951951                }
    952952            }
    953 #endif /* Q_WS_MAC */
     953#endif /* VBOX_WS_MAC */
    954954
    955955#ifdef VBOX_WITH_DRAG_AND_DROP
    … …  
    10241024                    if (ok)
    10251025                    {
    1026 #ifdef Q_WS_X11
     1026#ifdef VBOX_WS_X11
    10271027                        /* Make sure that pending FocusOut events from the previous message box are handled,
    10281028                         * otherwise the mouse is immediately ungrabbed again: */
    10291029                        qApp->processEvents();
    1030 #endif /* Q_WS_X11 */
     1030#endif /* VBOX_WS_X11 */
    10311031                        machineLogic()->keyboardHandler()->captureKeyboard(uScreenId);
    10321032                        const MouseCapturePolicy mcp = gEDataManager->mouseCapturePolicy(vboxGlobal().managedVMUuid());
    … …  
    11011101}
    11021102
    1103 #ifdef Q_WS_WIN
     1103#ifdef VBOX_WS_WIN
    11041104/* This method is actually required only because under win-host
    11051105 * we do not really grab the mouse in case of capturing it: */
    … …  
    11481148    }
    11491149}
    1150 #endif /* Q_WS_WIN */
    1151 
     1150#endif /* VBOX_WS_WIN */
     1151

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

    r58943 r60362  
    3838class CDisplay;
    3939class CMouse;
    40 #ifdef Q_WS_X11
     40#ifdef VBOX_WS_X11
    4141# if QT_VERSION < 0x050000
    4242typedef union _XEvent XEvent;
    4343# endif /* QT_VERSION < 0x050000 */
    44 #endif /* Q_WS_X11 */
     44#endif /* VBOX_WS_X11 */
    4545
    4646
    … …  
    7575    int state() const;
    7676
    77 #ifdef Q_WS_X11
     77#ifdef VBOX_WS_X11
    7878# if QT_VERSION < 0x050000
    7979    /** X11: Qt4: Handles all native events. */
    8080    bool x11EventFilter(XEvent *pEvent, ulong uScreenId);
    8181# endif /* QT_VERSION < 0x050000 */
    82 #endif /* Q_WS_X11 */
     82#endif /* VBOX_WS_X11 */
    8383
    8484protected slots:
    … …  
    123123    bool multiTouchEvent(QTouchEvent *pTouchEvent, ulong uScreenId);
    124124
    125 #ifdef Q_WS_WIN
     125#ifdef VBOX_WS_WIN
    126126    /* This method is actually required only because under win-host
    127127     * we do not really grab the mouse in case of capturing it: */
    128128    void updateMouseCursorClipping();
    129129    QRect m_mouseCursorClippingRect;
    130 #endif /* Q_WS_WIN */
     130#endif /* VBOX_WS_WIN */
    131131
    132132    /* Machine logic parent: */

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

    r60226 r60362  
    2424# include <QDesktopWidget>
    2525# include <QWidget>
    26 # ifdef Q_WS_MAC
     26# ifdef VBOX_WS_MAC
    2727#  include <QTimer>
    28 # endif /* Q_WS_MAC */
     28# endif /* VBOX_WS_MAC */
    2929
    3030/* GUI includes: */
    … …  
    4747#  include "VBoxFBOverlay.h"
    4848# endif /* VBOX_WITH_VIDEOHWACCEL */
    49 # ifdef Q_WS_MAC
     49# ifdef VBOX_WS_MAC
    5050#  include "UIMenuBar.h"
    5151#  include "VBoxUtils-darwin.h"
    52 # endif /* Q_WS_MAC */
     52# endif /* VBOX_WS_MAC */
    5353
    5454# ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
    … …  
    7373
    7474/* Qt includes: */
    75 #ifdef Q_WS_WIN
     75#ifdef VBOX_WS_WIN
    7676# if QT_VERSION >= 0x050000
    7777#  include <QtWin>
    7878# endif /* QT_VERSION >= 0x050000 */
    79 #endif /* Q_WS_WIN */
    80 
    81 #ifdef Q_WS_X11
     79#endif /* VBOX_WS_WIN */
     80
     81#ifdef VBOX_WS_X11
    8282# include <QX11Info>
    8383# include <X11/Xlib.h>
    8484# include <X11/Xutil.h>
    85 #endif /* Q_WS_X11 */
     85#endif /* VBOX_WS_X11 */
    8686
    8787#ifdef VBOX_GUI_WITH_KEYS_RESET_HANDLER
    … …  
    8989#endif
    9090
    91 #ifdef Q_WS_MAC
     91#ifdef VBOX_WS_MAC
    9292/**
    9393 * MacOS X: Application Services: Core Graphics: Display reconfiguration callback.
    … …  
    124124    Q_UNUSED(display);
    125125}
    126 #endif /* Q_WS_MAC */
     126#endif /* VBOX_WS_MAC */
    127127
    128128/* static */
    … …  
    253253
    254254/* Log whether HID LEDs sync is enabled: */
    255 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     255#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    256256    LogRel(("GUI: HID LEDs sync is %s\n",
    257257            uimachine()->machineLogic()->isHidLedsSyncEnabled()
    258258            ? "enabled" : "disabled"));
    259 #else /* !Q_WS_MAC && !Q_WS_WIN */
     259#else /* !VBOX_WS_MAC && !VBOX_WS_WIN */
    260260    LogRel(("GUI: HID LEDs sync is not supported on this platform\n"));
    261 #endif /* !Q_WS_MAC && !Q_WS_WIN */
     261#endif /* !VBOX_WS_MAC && !VBOX_WS_WIN */
    262262
    263263#ifdef VBOX_GUI_WITH_PIDFILE
    … …  
    936936    , m_pMachine(pMachine)
    937937    , m_pActionPool(0)
    938 #ifdef Q_WS_MAC
     938#ifdef VBOX_WS_MAC
    939939    , m_pMenuBar(0)
    940 #endif /* Q_WS_MAC */
     940#endif /* VBOX_WS_MAC */
    941941    /* Common variables: */
    942942    , m_machineStatePrevious(KMachineState_Null)
    943943    , m_machineState(KMachineState_Null)
    944 #ifndef Q_WS_MAC
     944#ifndef VBOX_WS_MAC
    945945    , m_pMachineWindowIcon(0)
    946 #endif /* !Q_WS_MAC */
     946#endif /* !VBOX_WS_MAC */
    947947    , m_requestedVisualStateType(UIVisualStateType_Invalid)
    948 #ifdef Q_WS_WIN
     948#ifdef VBOX_WS_WIN
    949949    , m_alphaCursor(0)
    950 #endif /* Q_WS_WIN */
    951 #ifdef Q_WS_MAC
     950#endif /* VBOX_WS_WIN */
     951#ifdef VBOX_WS_MAC
    952952    , m_pWatchdogDisplayChange(0)
    953 #endif /* Q_WS_MAC */
     953#endif /* VBOX_WS_MAC */
    954954    , m_defaultCloseAction(MachineCloseAction_Invalid)
    955955    , m_restrictedCloseActions(MachineCloseAction_Invalid)
    … …  
    10941094        updateActionRestrictions();
    10951095
    1096 #ifdef Q_WS_MAC
     1096#ifdef VBOX_WS_MAC
    10971097        /* Create Mac OS X menu-bar: */
    10981098        m_pMenuBar = new UIMenuBar;
    … …  
    11051105            updateMenu();
    11061106        }
    1107 #endif /* Q_WS_MAC */
     1107#endif /* VBOX_WS_MAC */
    11081108    }
    11091109}
    … …  
    11131113    connect(this, SIGNAL(sigInitialized()), this, SLOT(sltMarkInitialized()));
    11141114
    1115 #ifdef Q_WS_MAC
     1115#ifdef VBOX_WS_MAC
    11161116    /* Install native display reconfiguration callback: */
    11171117    CGDisplayRegisterReconfigurationCallback(cgDisplayReconfigurationCallback, this);
    1118 #else /* !Q_WS_MAC */
     1118#else /* !VBOX_WS_MAC */
    11191119    /* Install Qt display reconfiguration callbacks: */
    11201120    connect(QApplication::desktop(), SIGNAL(screenCountChanged(int)),
    … …  
    11241124    connect(QApplication::desktop(), SIGNAL(workAreaResized(int)),
    11251125            this, SLOT(sltHandleHostScreenAvailableAreaChange()));
    1126 #endif /* !Q_WS_MAC */
     1126#endif /* !VBOX_WS_MAC */
    11271127}
    11281128
    … …  
    11751175            this, SIGNAL(sigRuntimeError(bool, QString, QString)));
    11761176
    1177 #ifdef Q_WS_MAC
     1177#ifdef VBOX_WS_MAC
    11781178    connect(gConsoleEvents, SIGNAL(sigShowWindow()),
    11791179            this, SIGNAL(sigShowWindows()), Qt::QueuedConnection);
    1180 #endif /* Q_WS_MAC */
     1180#endif /* VBOX_WS_MAC */
    11811181
    11821182    connect(gConsoleEvents, SIGNAL(sigCPUExecutionCapChange()),
    … …  
    11921192    updateHostScreenData();
    11931193
    1194 #ifdef Q_WS_MAC
     1194#ifdef VBOX_WS_MAC
    11951195    /* Prepare display-change watchdog: */
    11961196    m_pWatchdogDisplayChange = new QTimer(this);
    … …  
    12011201                this, SLOT(sltCheckIfHostDisplayChanged()));
    12021202    }
    1203 #endif /* Q_WS_MAC */
     1203#endif /* VBOX_WS_MAC */
    12041204
    12051205    /* Prepare initial screen visibility status: */
    … …  
    12681268        const QString strMachineID = vboxGlobal().managedVMUuid();
    12691269
    1270 #ifndef Q_WS_MAC
     1270#ifndef VBOX_WS_MAC
    12711271        /* Load/prepare user's machine-window icon: */
    12721272        QIcon icon;
    … …  
    12791279        /* Load user's machine-window name postfix: */
    12801280        m_strMachineWindowNamePostfix = gEDataManager->machineWindowNamePostfix(strMachineID);
    1281 #endif /* !Q_WS_MAC */
     1281#endif /* !VBOX_WS_MAC */
    12821282
    12831283        /* Is there should be First RUN Wizard? */
    … …  
    12881288        pGuestAutoresizeSwitch->setChecked(gEDataManager->guestScreenAutoResizeEnabled(strMachineID));
    12891289
    1290 #ifndef Q_WS_MAC
     1290#ifndef VBOX_WS_MAC
    12911291        /* Menu-bar options: */
    12921292        {
    … …  
    13011301            pActionMenuBarSwitch->blockSignals(false);
    13021302        }
    1303 #endif /* !Q_WS_MAC */
     1303#endif /* !VBOX_WS_MAC */
    13041304
    13051305        /* Status-bar options: */
    … …  
    13451345        }
    13461346
    1347 #ifndef Q_WS_MAC
     1347#ifndef VBOX_WS_MAC
    13481348        /* Cleanup user's machine-window icon: */
    13491349        delete m_pMachineWindowIcon;
    13501350        m_pMachineWindowIcon = 0;
    1351 #endif /* !Q_WS_MAC */
     1351#endif /* !VBOX_WS_MAC */
    13521352    }
    13531353}
    … …  
    13811381void UISession::cleanupConnections()
    13821382{
    1383 #ifdef Q_WS_MAC
     1383#ifdef VBOX_WS_MAC
    13841384    /* Remove display reconfiguration callback: */
    13851385    CGDisplayRemoveReconfigurationCallback(cgDisplayReconfigurationCallback, this);
    1386 #endif /* Q_WS_MAC */
     1386#endif /* VBOX_WS_MAC */
    13871387}
    13881388
    13891389void UISession::cleanupActions()
    13901390{
    1391 #ifdef Q_WS_MAC
     1391#ifdef VBOX_WS_MAC
    13921392    /* Destroy Mac OS X menu-bar: */
    13931393    delete m_pMenuBar;
    13941394    m_pMenuBar = 0;
    1395 #endif /* Q_WS_MAC */
     1395#endif /* VBOX_WS_MAC */
    13961396
    13971397    /* Destroy action-pool if necessary: */
    … …  
    14401440void UISession::cleanup()
    14411441{
    1442 #ifdef Q_WS_WIN
     1442#ifdef VBOX_WS_WIN
    14431443    /* Destroy alpha cursor: */
    14441444    if (m_alphaCursor)
    14451445        DestroyIcon(m_alphaCursor);
    1446 #endif /* Q_WS_WIN */
     1446#endif /* VBOX_WS_WIN */
    14471447
    14481448    /* Save settings: */
    … …  
    14651465}
    14661466
    1467 #ifdef Q_WS_MAC
     1467#ifdef VBOX_WS_MAC
    14681468void UISession::updateMenu()
    14691469{
    … …  
    14791479    }
    14801480}
    1481 #endif /* Q_WS_MAC */
     1481#endif /* VBOX_WS_MAC */
    14821482
    14831483/** Generate a BGRA bitmap which approximates a XOR/AND mouse pointer.
    … …  
    15891589    uint srcShapePtrScan = uWidth * 4;
    15901590
    1591 #if defined (Q_WS_WIN)
     1591#if defined (VBOX_WS_WIN)
    15921592
    15931593    BITMAPV5HEADER bi;
    … …  
    17191719        DeleteObject(hBitmap);
    17201720
    1721 #elif defined(Q_WS_X11) || defined(Q_WS_MAC)
     1721#elif defined(VBOX_WS_X11) || defined(VBOX_WS_MAC)
    17221722
    17231723    /* Create a ARGB image out of the shape data: */
    … …  
    17371737    /* Create cursor-pixmap from the image: */
    17381738    QPixmap cursorPixmap = QPixmap::fromImage(image);
    1739 # ifdef Q_WS_MAC
     1739# ifdef VBOX_WS_MAC
    17401740#  ifdef VBOX_GUI_WITH_HIDPI
    17411741    /* Adjust backing-scale-factor: */
    … …  
    17491749        cursorPixmap.setDevicePixelRatio(dBackingScaleFactor);
    17501750#  endif /* VBOX_GUI_WITH_HIDPI */
    1751 # endif /* Q_WS_MAC */
     1751# endif /* VBOX_WS_MAC */
    17521752    /* Set the new cursor: */
    17531753    m_cursor = QCursor(cursorPixmap, uXHot, uYHot);

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

    r60226 r60362  
    4949class CNetworkAdapter;
    5050class CMediumAttachment;
    51 #ifdef Q_WS_MAC
     51#ifdef VBOX_WS_MAC
    5252class QMenuBar;
    53 #else /* !Q_WS_MAC */
     53#else /* !VBOX_WS_MAC */
    5454class QIcon;
    55 #endif /* !Q_WS_MAC */
     55#endif /* !VBOX_WS_MAC */
    5656
    5757/* CConsole callback event types: */
    … …  
    127127    QCursor cursor() const { return m_cursor; }
    128128
    129 #ifndef Q_WS_MAC
     129#ifndef VBOX_WS_MAC
    130130    /** @name Branding stuff.
    131131     ** @{ */
    … …  
    135135    QString machineWindowNamePostfix() const { return m_strMachineWindowNamePostfix; }
    136136    /** @} */
    137 #endif /* !Q_WS_MAC */
     137#endif /* !VBOX_WS_MAC */
    138138
    139139    /** @name Host-screen configuration variables.
    … …  
    388388    void cleanup();
    389389
    390 #ifdef Q_WS_MAC
     390#ifdef VBOX_WS_MAC
    391391    /** Mac OS X: Updates menu-bar content. */
    392392    void updateMenu();
    393 #endif /* Q_WS_MAC */
     393#endif /* VBOX_WS_MAC */
    394394
    395395    /* Common helpers: */
    … …  
    434434    UIActionPool *m_pActionPool;
    435435
    436 #ifdef Q_WS_MAC
     436#ifdef VBOX_WS_MAC
    437437    /** Holds the menu-bar instance. */
    438438    QMenuBar *m_pMenuBar;
    439 #endif /* Q_WS_MAC */
     439#endif /* VBOX_WS_MAC */
    440440
    441441    /* Screen visibility vector: */
    … …  
    456456    QCursor m_cursor;
    457457
    458 #ifndef Q_WS_MAC
     458#ifndef VBOX_WS_MAC
    459459    /** @name Branding variables.
    460460     ** @{ */
    … …  
    464464    QString m_strMachineWindowNamePostfix;
    465465    /** @} */
    466 #endif /* !Q_WS_MAC */
     466#endif /* !VBOX_WS_MAC */
    467467
    468468    /** @name Visual-state configuration variables.
    … …  
    472472    /** @} */
    473473
    474 #if defined(Q_WS_WIN)
     474#if defined(VBOX_WS_WIN)
    475475    HCURSOR m_alphaCursor;
    476476#endif
    … …  
    480480    /** Holds the list of host-screen geometries we currently have. */
    481481    QList<QRect> m_hostScreens;
    482 #ifdef Q_WS_MAC
     482#ifdef VBOX_WS_MAC
    483483    /** Mac OS X: Watchdog timer looking for display reconfiguration. */
    484484    QTimer *m_pWatchdogDisplayChange;
    485 #endif /* Q_WS_MAC */
     485#endif /* VBOX_WS_MAC */
    486486    /** @} */
    487487

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

    r58880 r60362  
    3030# include "UIAnimationFramework.h"
    3131# include "UIMachineWindow.h"
    32 # ifdef Q_WS_MAC
     32# ifdef VBOX_WS_MAC
    3333#  include "VBoxUtils-darwin.h"
    34 # endif /* Q_WS_MAC */
     34# endif /* VBOX_WS_MAC */
    3535
    3636#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    7171    setAttribute(Qt::WA_DeleteOnClose);
    7272
    73 #if   defined(Q_WS_MAC) || defined(Q_WS_WIN)
     73#if   defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    7474    /* Make sure we have no background
    7575     * until the first one paint-event: */
    … …  
    7777    /* Use Qt API to enable translucency: */
    7878    setAttribute(Qt::WA_TranslucentBackground);
    79 #elif defined(Q_WS_X11)
     79#elif defined(VBOX_WS_X11)
    8080    if (vboxGlobal().isCompositingManagerRunning())
    8181    {
    … …  
    8383        setAttribute(Qt::WA_TranslucentBackground);
    8484    }
    85 #endif /* Q_WS_X11 */
     85#endif /* VBOX_WS_X11 */
    8686
    8787    /* Prepare contents: */
    … …  
    154154    }
    155155
    156 #ifdef Q_WS_X11
     156#ifdef VBOX_WS_X11
    157157    if (!vboxGlobal().isCompositingManagerRunning())
    158158    {
    … …  
    160160        setMask(m_pEmbeddedWidget->geometry());
    161161    }
    162 #endif /* Q_WS_X11 */
    163 
    164 #ifdef Q_WS_WIN
     162#endif /* VBOX_WS_X11 */
     163
     164#ifdef VBOX_WS_WIN
    165165    /* Raise tool-window for proper z-order. */
    166166    raise();
    167 #endif /* Q_WS_WIN */
     167#endif /* VBOX_WS_WIN */
    168168
    169169    /* Activate window after it was shown: */
    … …  
    211211    m_pEmbeddedWidget->setGeometry(0, 0, qMax(width(), sh.width()), sh.height());
    212212
    213 #ifdef Q_WS_X11
     213#ifdef VBOX_WS_X11
    214214    if (!vboxGlobal().isCompositingManagerRunning())
    215215    {
    … …  
    217217        setMask(m_pEmbeddedWidget->geometry());
    218218    }
    219 #endif /* Q_WS_X11 */
    220 
    221 #ifdef Q_WS_WIN
     219#endif /* VBOX_WS_X11 */
     220
     221#ifdef VBOX_WS_WIN
    222222    /* Raise tool-window for proper z-order. */
    223223    raise();
    224 #endif /* Q_WS_WIN */
     224#endif /* VBOX_WS_WIN */
    225225}
    226226
    … …  
    274274}
    275275
    276 #ifdef Q_WS_MAC
     276#ifdef VBOX_WS_MAC
    277277bool UISlidingToolBar::event(QEvent *pEvent)
    278278{
    … …  
    296296    return QWidget::event(pEvent);
    297297}
    298 #endif /* Q_WS_MAC */
     298#endif /* VBOX_WS_MAC */
    299299
    300300void UISlidingToolBar::setWidgetGeometry(const QRect &rect)
    … …  
    303303    m_pEmbeddedWidget->setGeometry(rect);
    304304
    305 #ifdef Q_WS_X11
     305#ifdef VBOX_WS_X11
    306306    if (!vboxGlobal().isCompositingManagerRunning())
    307307    {
    … …  
    309309        setMask(m_pEmbeddedWidget->geometry());
    310310    }
    311 #endif /* Q_WS_X11 */
     311#endif /* VBOX_WS_X11 */
    312312}
    313313

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

    r55401 r60362  
    9494    /** Close event handler. */
    9595    virtual void closeEvent(QCloseEvent *pEvent);
    96 #ifdef Q_WS_MAC
     96#ifdef VBOX_WS_MAC
    9797    /** Common event handler. */
    9898    virtual bool event(QEvent *pEvent);
    99 #endif /* Q_WS_MAC */
     99#endif /* VBOX_WS_MAC */
    100100
    101101    /** Defines mdi-sub-window geometry. */

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

    r58867 r60362  
    532532    color1.setAlpha(0);
    533533    QColor color2 = pal.color(QPalette::Window).darker(200);
    534 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     534#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    535535    QColor color3 = pal.color(QPalette::Window).darker(120);
    536 #endif /* Q_WS_WIN || Q_WS_X11 */
     536#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    537537
    538538    /* Left corner: */
    … …  
    575575    painter.fillRect(QRect(width() - 5, 5, 5, height() - 5), grad5); // right line
    576576
    577 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     577#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    578578    /* Paint frames: */
    579579    painter.save();
    … …  
    584584    painter.drawLine(QLine(QPoint(5 + 1, height() - 1),               QPoint(5 + 1, 5 + 1)));
    585585    painter.restore();
    586 #endif /* Q_WS_WIN || Q_WS_X11 */
     586#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    587587
    588588    /* Paint drop token: */

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

    r56180 r60362  
    259259                    m_pDiscardCheckBox = new QCheckBox(this);
    260260                    /* Configure layout: */
    261 #ifdef Q_WS_MAC
     261#ifdef VBOX_WS_MAC
    262262                    pChoiceLayout->setSpacing(15);
    263 #else /* Q_WS_MAC */
     263#else /* VBOX_WS_MAC */
    264264                    pChoiceLayout->setSpacing(6);
    265 #endif /* !Q_WS_MAC */
     265#endif /* !VBOX_WS_MAC */
    266266                    pChoiceLayout->setContentsMargins(0, 0, 0, 0);
    267267                    pChoiceLayout->addWidget(m_pDetachIcon, 0, 0);
    … …  
    276276                }
    277277                /* Configure layout: */
    278 #ifdef Q_WS_MAC
     278#ifdef VBOX_WS_MAC
    279279                pTopRightLayout->setSpacing(15);
    280 #else /* Q_WS_MAC */
     280#else /* VBOX_WS_MAC */
    281281                pTopRightLayout->setSpacing(6);
    282 #endif /* !Q_WS_MAC */
     282#endif /* !VBOX_WS_MAC */
    283283                pTopRightLayout->setContentsMargins(0, 0, 0, 0);
    284284                pTopRightLayout->addWidget(m_pLabel);
    … …  
    302302        /* Configure layout: */
    303303        pMainLayout->setSpacing(20);
    304 #ifdef Q_WS_MAC
     304#ifdef VBOX_WS_MAC
    305305        pMainLayout->setContentsMargins(40, 20, 40, 20);
    306 #endif /* Q_WS_MAC */
     306#endif /* VBOX_WS_MAC */
    307307        pMainLayout->addItem(pTopLayout);
    308308        pMainLayout->addWidget(pButtonBox);

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.cpp

    r59079 r60362  
    3434# include "UIMachineView.h"
    3535# include "QIMenu.h"
    36 # ifdef Q_WS_MAC
     36# ifdef VBOX_WS_MAC
    3737#  include "UICocoaApplication.h"
    3838#  include "UIExtraDataManager.h"
    … …  
    4040#  include "UIFrameBuffer.h"
    4141#  include <Carbon/Carbon.h>
    42 # endif /* Q_WS_MAC */
     42# endif /* VBOX_WS_MAC */
    4343
    4444#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    4848    : UIMachineLogic(pParent, pSession, UIVisualStateType_Fullscreen)
    4949    , m_pPopupMenu(0)
    50 #ifdef Q_WS_MAC
     50#ifdef VBOX_WS_MAC
    5151    , m_fScreensHaveSeparateSpaces(darwinScreensHaveSeparateSpaces())
    52 #endif /* Q_WS_MAC */
     52#endif /* VBOX_WS_MAC */
    5353{
    5454    /* Create multiscreen layout: */
    … …  
    9292{
    9393    Q_UNUSED(uScreenId);
    94 #ifdef Q_WS_MAC
     94#ifdef VBOX_WS_MAC
    9595    return vboxGlobal().osRelease() <= MacOSXRelease_Lion ? Qt::FramelessWindowHint :
    9696           uScreenId == 0 || screensHaveSeparateSpaces() ? Qt::Window : Qt::FramelessWindowHint;
    97 #else /* !Q_WS_MAC */
     97#else /* !VBOX_WS_MAC */
    9898    return Qt::FramelessWindowHint;
    99 #endif /* !Q_WS_MAC */
     99#endif /* !VBOX_WS_MAC */
    100100}
    101101
    … …  
    107107    m_pScreenLayout->rebuild();
    108108
    109 #ifdef Q_WS_MAC
     109#ifdef VBOX_WS_MAC
    110110    /* For Lion and previous: */
    111111    if (vboxGlobal().osRelease() <= MacOSXRelease_Lion)
    … …  
    117117    /* For ML and next revalidate native fullscreen: */
    118118    else revalidateNativeFullScreen();
    119 #else /* !Q_WS_MAC */
     119#else /* !VBOX_WS_MAC */
    120120    /* Make sure all machine-window(s) have proper geometry: */
    121121    foreach (UIMachineWindow *pMachineWindow, machineWindows())
    122122        pMachineWindow->showInNecessaryMode();
    123 #endif /* !Q_WS_MAC */
     123#endif /* !VBOX_WS_MAC */
    124124}
    125125
    … …  
    396396    LogRel(("GUI: UIMachineLogicFullscreen::sltScreenLayoutChanged: Multi-screen layout changed\n"));
    397397
    398 #ifdef Q_WS_MAC
     398#ifdef VBOX_WS_MAC
    399399    /* For Lion and previous: */
    400400    if (vboxGlobal().osRelease() <= MacOSXRelease_Lion)
    … …  
    406406    /* Revalidate native fullscreen for ML and next: */
    407407    else revalidateNativeFullScreen();
    408 #else /* !Q_WS_MAC */
     408#else /* !VBOX_WS_MAC */
    409409    /* Make sure all machine-window(s) have proper geometry: */
    410410    foreach (UIMachineWindow *pMachineWindow, machineWindows())
    411411        pMachineWindow->showInNecessaryMode();
    412 #endif /* !Q_WS_MAC */
     412#endif /* !VBOX_WS_MAC */
    413413}
    414414
    … …  
    420420    m_pScreenLayout->rebuild();
    421421
    422 #ifdef Q_WS_MAC
     422#ifdef VBOX_WS_MAC
    423423    /* Call to base-class for Lion and previous: */
    424424    if (vboxGlobal().osRelease() <= MacOSXRelease_Lion)
    … …  
    426426    /* Revalidate native fullscreen for ML and next: */
    427427    else revalidateNativeFullScreen();
    428 #else /* !Q_WS_MAC */
     428#else /* !VBOX_WS_MAC */
    429429    /* Call to base-class: */
    430430    UIMachineLogic::sltGuestMonitorChange(changeType, uScreenId, screenGeo);
    431 #endif /* !Q_WS_MAC */
     431#endif /* !VBOX_WS_MAC */
    432432}
    433433
    … …  
    439439    m_pScreenLayout->rebuild();
    440440
    441 #ifdef Q_WS_MAC
     441#ifdef VBOX_WS_MAC
    442442    /* Call to base-class for Lion and previous: */
    443443    if (vboxGlobal().osRelease() <= MacOSXRelease_Lion)
    … …  
    445445    /* Revalidate native fullscreen for ML and next: */
    446446    else revalidateNativeFullScreen();
    447 #else /* !Q_WS_MAC */
     447#else /* !VBOX_WS_MAC */
    448448    /* Call to base-class: */
    449449    UIMachineLogic::sltHostScreenCountChange();
    450 #endif /* !Q_WS_MAC */
     450#endif /* !VBOX_WS_MAC */
    451451}
    452452
    … …  
    478478                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar |
    479479                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize));
    480 #ifdef Q_WS_MAC
     480#ifdef VBOX_WS_MAC
    481481    /* Restrict 'Window' menu: */
    482482    actionPool()->toRuntime()->setRestrictionForMenuBar(UIActionRestrictionLevel_Logic,
    483483                                                        UIExtraDataMetaDefs::MenuType_Window);
    484 #endif /* Q_WS_MAC */
     484#endif /* VBOX_WS_MAC */
    485485
    486486    /* Take care of view-action toggle state: */
    … …  
    514514        return;
    515515
    516 #ifdef Q_WS_MAC
     516#ifdef VBOX_WS_MAC
    517517    /* For ML and next: */
    518518    if (vboxGlobal().osRelease() > MacOSXRelease_Lion)
    … …  
    528528     * This is necessary for Qt versions > 4.3.3: */
    529529    darwinSetFrontMostProcess();
    530 #endif /* Q_WS_MAC */
     530#endif /* VBOX_WS_MAC */
    531531
    532532    /* Update the multi-screen layout: */
    … …  
    547547            this, SLOT(sltScreenLayoutChanged()));
    548548
    549 #ifdef Q_WS_MAC
     549#ifdef VBOX_WS_MAC
    550550    /* For ML and next: */
    551551    if (vboxGlobal().osRelease() > MacOSXRelease_Lion)
    … …  
    579579        revalidateNativeFullScreen();
    580580    }
    581 #endif /* Q_WS_MAC */
     581#endif /* VBOX_WS_MAC */
    582582
    583583    /* Mark machine-window(s) created: */
    584584    setMachineWindowsCreated(true);
    585585
    586 #ifdef Q_WS_X11
     586#ifdef VBOX_WS_X11
    587587    switch (vboxGlobal().typeOfWindowManager())
    588588    {
    … …  
    600600            break;
    601601    }
    602 #endif /* Q_WS_X11 */
     602#endif /* VBOX_WS_X11 */
    603603}
    604604
    … …  
    628628        return;
    629629
    630 #ifdef Q_WS_MAC
     630#ifdef VBOX_WS_MAC
    631631    /* For ML and next: */
    632632    if (vboxGlobal().osRelease() > MacOSXRelease_Lion)
    … …  
    636636        UICocoaApplication::instance()->unregisterFromNotificationOfWorkspace("NSWorkspaceActiveSpaceDidChangeNotification", this);
    637637    }
    638 #endif/* Q_WS_MAC */
     638#endif/* VBOX_WS_MAC */
    639639
    640640    /* Mark machine-window(s) destroyed: */
    … …  
    674674    actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
    675675                                                         UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid);
    676 #ifdef Q_WS_MAC
     676#ifdef VBOX_WS_MAC
    677677    /* Allow 'Window' menu: */
    678678    actionPool()->toRuntime()->setRestrictionForMenuBar(UIActionRestrictionLevel_Logic,
    679679                                                        UIExtraDataMetaDefs::MenuType_Invalid);
    680 #endif /* Q_WS_MAC */
     680#endif /* VBOX_WS_MAC */
    681681
    682682    /* Call to base-class: */
    … …  
    684684}
    685685
    686 #ifdef Q_WS_MAC
     686#ifdef VBOX_WS_MAC
    687687void UIMachineLogicFullscreen::revalidateNativeFullScreen(UIMachineWindow *pMachineWindow)
    688688{
    … …  
    882882            revalidateNativeFullScreen(pMachineWindow);
    883883}
    884 #endif /* Q_WS_MAC */
    885 
     884#endif /* VBOX_WS_MAC */
     885

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineLogicFullscreen.h

    r59079 r60362  
    2323
    2424/* Other includes: */
    25 #ifdef Q_WS_MAC
     25#ifdef VBOX_WS_MAC
    2626# include <ApplicationServices/ApplicationServices.h>
    27 #endif /* Q_WS_MAC */
     27#endif /* VBOX_WS_MAC */
    2828
    2929/* Forward declarations: */
    … …  
    4444#endif /* RT_OS_DARWIN */
    4545
    46 #ifdef Q_WS_MAC
     46#ifdef VBOX_WS_MAC
    4747public:
    4848
    4949    /** Returns whether screens have separate spaces. */
    5050    bool screensHaveSeparateSpaces() const { return m_fScreensHaveSeparateSpaces; }
    51 #endif /* Q_WS_MAC */
     51#endif /* VBOX_WS_MAC */
    5252
    5353protected:
    … …  
    127127    void cleanupActionGroups();
    128128
    129 #ifdef Q_WS_MAC
     129#ifdef VBOX_WS_MAC
    130130    /** Mac OS X: Revalidates 'fullscreen' mode for @a pMachineWindow. */
    131131    void revalidateNativeFullScreen(UIMachineWindow *pMachineWindow);
    … …  
    142142    /** Mac OS X: Handles native notification about active space change. */
    143143    void nativeHandlerForActiveSpaceChange(const QMap<QString, QString> &userInfo);
    144 #endif /* Q_WS_MAC */
     144#endif /* VBOX_WS_MAC */
    145145
    146146    /** Holds the popup-menu instance. */
    … …  
    150150    UIMultiScreenLayout *m_pScreenLayout;
    151151
    152 #ifdef Q_WS_MAC
     152#ifdef VBOX_WS_MAC
    153153    /** Mac OS X: Holds whether screens have separate spaces. */
    154154    const bool m_fScreensHaveSeparateSpaces;
    … …  
    158158    /** Mac OS X: Contains machine-window(s) marked as 'invalid fullscreen'. */
    159159    QSet<UIMachineWindow*> m_invalidFullscreenMachineWindows;
    160 #endif /* Q_WS_MAC */
     160#endif /* VBOX_WS_MAC */
    161161
    162162    /* Friend classes: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineViewFullscreen.cpp

    r59380 r60362  
    2424# include <QMainWindow>
    2525# include <QTimer>
    26 # ifdef Q_WS_MAC
     26# ifdef VBOX_WS_MAC
    2727#  include <QMenuBar>
    28 # endif /* Q_WS_MAC */
     28# endif /* VBOX_WS_MAC */
    2929
    3030/* GUI includes: */
    … …  
    4040#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    4141
    42 #ifdef Q_WS_X11
     42#ifdef VBOX_WS_X11
    4343# include <limits.h>
    44 #endif /* Q_WS_X11 */
     44#endif /* VBOX_WS_X11 */
    4545
    4646

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.cpp

    r59814 r60362  
    3232# include "UIMachineWindowFullscreen.h"
    3333# include "UIMachineView.h"
    34 # if   defined(Q_WS_WIN) || defined(Q_WS_X11)
     34# if   defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    3535#  include "UIMachineDefs.h"
    3636#  include "UIMiniToolBar.h"
    37 # elif defined(Q_WS_MAC)
     37# elif defined(VBOX_WS_MAC)
    3838#  include "UIFrameBuffer.h"
    3939#  include "VBoxUtils-darwin.h"
    4040#  include "UICocoaApplication.h"
    41 # endif /* Q_WS_MAC */
     41# endif /* VBOX_WS_MAC */
    4242
    4343/* COM includes: */
    … …  
    4949UIMachineWindowFullscreen::UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId)
    5050    : UIMachineWindow(pMachineLogic, uScreenId)
    51 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     51#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    5252    , m_pMiniToolBar(0)
    53 #endif /* Q_WS_WIN || Q_WS_X11 */
    54 #ifdef Q_WS_MAC
     53#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     54#ifdef VBOX_WS_MAC
    5555    , m_fIsInFullscreenTransition(false)
    56 #endif /* Q_WS_MAC */
    57 {
    58 }
    59 
    60 #ifdef Q_WS_MAC
     56#endif /* VBOX_WS_MAC */
     57{
     58}
     59
     60#ifdef VBOX_WS_MAC
    6161void UIMachineWindowFullscreen::handleNativeNotification(const QString &strNativeNotificationName)
    6262{
    … …  
    114114    }
    115115}
    116 #endif /* Q_WS_MAC */
    117 
    118 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     116#endif /* VBOX_WS_MAC */
     117
     118#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    119119void UIMachineWindowFullscreen::sltMachineStateChanged()
    120120{
    … …  
    133133
    134134    /* Revoke stolen activation: */
    135 #ifdef Q_WS_X11
     135#ifdef VBOX_WS_X11
    136136    raise();
    137 #endif /* Q_WS_X11 */
     137#endif /* VBOX_WS_X11 */
    138138    activateWindow();
    139139}
    140 #endif /* Q_WS_WIN || Q_WS_X11 */
    141 
    142 #ifdef Q_WS_MAC
     140#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     141
     142#ifdef VBOX_WS_MAC
    143143void UIMachineWindowFullscreen::sltEnterNativeFullscreen(UIMachineWindow *pMachineWindow)
    144144{
    … …  
    189189        darwinToggleFullscreenMode(this);
    190190}
    191 #endif /* Q_WS_MAC */
     191#endif /* VBOX_WS_MAC */
    192192
    193193void UIMachineWindowFullscreen::prepareVisualState()
    … …  
    203203    setAutoFillBackground(true);
    204204
    205 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     205#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    206206    /* Prepare mini-toolbar: */
    207207    prepareMiniToolbar();
    208 #endif /* Q_WS_WIN || Q_WS_X11 */
    209 
    210 #ifdef Q_WS_MAC
     208#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     209
     210#ifdef VBOX_WS_MAC
    211211    /* Native fullscreen stuff on ML and next: */
    212212    if (vboxGlobal().osRelease() > MacOSXRelease_Lion)
    … …  
    233233                                                                       UIMachineWindow::handleNativeNotification);
    234234}
    235 #endif /* Q_WS_MAC */
    236 }
    237 
    238 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     235#endif /* VBOX_WS_MAC */
     236}
     237
     238#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    239239void UIMachineWindowFullscreen::prepareMiniToolbar()
    240240{
    … …  
    260260        connect(m_pMiniToolBar, SIGNAL(sigNotifyAboutWindowActivationStolen()),
    261261                this, SLOT(sltRevokeWindowActivation()), Qt::QueuedConnection);
    262 # ifdef Q_WS_X11
     262# ifdef VBOX_WS_X11
    263263        // WORKAROUND:
    264264        // Due to Unity bug we want native full-screen flag to be set
    … …  
    267267        if (vboxGlobal().typeOfWindowManager() == X11WMType_Compiz)
    268268            vboxGlobal().setFullScreenFlag(m_pMiniToolBar);
    269 # endif /* Q_WS_X11 */
    270     }
    271 }
    272 #endif /* Q_WS_WIN || Q_WS_X11 */
    273 
    274 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     269# endif /* VBOX_WS_X11 */
     270    }
     271}
     272#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     273
     274#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    275275void UIMachineWindowFullscreen::cleanupMiniToolbar()
    276276{
    … …  
    285285    m_pMiniToolBar = 0;
    286286}
    287 #endif /* Q_WS_WIN || Q_WS_X11 */
     287#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    288288
    289289void UIMachineWindowFullscreen::cleanupVisualState()
    290290{
    291 #ifdef Q_WS_MAC
     291#ifdef VBOX_WS_MAC
    292292    /* Native fullscreen stuff on ML and next: */
    293293    if (vboxGlobal().osRelease() > MacOSXRelease_Lion)
    … …  
    300300        UICocoaApplication::instance()->unregisterFromNotificationOfWindow("NSWindowDidFailToEnterFullScreenNotification", this);
    301301    }
    302 #endif /* Q_WS_MAC */
    303 
    304 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     302#endif /* VBOX_WS_MAC */
     303
     304#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    305305    /* Cleanup mini-toolbar: */
    306306    cleanupMiniToolbar();
    307 #endif /* Q_WS_WIN || Q_WS_X11 */
     307#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    308308
    309309    /* Call to base-class: */
    … …  
    318318    const QRect workingArea = vboxGlobal().screenGeometry(iHostScreen);
    319319
    320 #if   defined(Q_WS_WIN) || defined(Q_WS_X11)
     320#if   defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    321321    /* Set appropriate geometry for window: */
    322322    resize(workingArea.size());
    … …  
    330330        m_pMiniToolBar->move(workingArea.topLeft());
    331331    }
    332 #elif defined(Q_WS_MAC)
     332#elif defined(VBOX_WS_MAC)
    333333    /* Make sure this window has fullscreen logic: */
    334334    UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
    … …  
    362362        setGeometry(geo);
    363363    }
    364 #endif /* Q_WS_MAC */
     364#endif /* VBOX_WS_MAC */
    365365}
    366366
    … …  
    375375        !pFullscreenLogic->hasHostScreenForGuestScreen(m_uScreenId))
    376376    {
    377 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     377#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    378378        /* If there is a mini-toolbar: */
    379379        if (m_pMiniToolBar)
    … …  
    382382            m_pMiniToolBar->hide();
    383383        }
    384 #endif /* Q_WS_WIN || Q_WS_X11 */
     384#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    385385
    386386        /* Hide window: */
    … …  
    393393            return;
    394394
    395 #ifdef Q_WS_X11
     395#ifdef VBOX_WS_X11
    396396        /* If WM doesn't support native stuff, we need to call for placeOnScreen(): */
    397397        const bool fSupportsNativeFullScreen = VBoxGlobal::supportsFullScreenMonitorsProtocolX11() &&
    … …  
    402402            placeOnScreen();
    403403        }
    404 #else /* !Q_WS_X11 */
     404#else /* !VBOX_WS_X11 */
    405405        /* Make sure window have appropriate geometry: */
    406406        placeOnScreen();
    407 #endif /* !Q_WS_X11 */
    408 
    409 #if defined(Q_WS_MAC)
     407#endif /* !VBOX_WS_X11 */
     408
     409#if defined(VBOX_WS_MAC)
    410410        /* ML and next using native stuff, so we can call for simple show(),
    411411         * Lion and previous using Qt stuff, so we should call for showFullScreen(): */
    … …  
    421421            showFullScreen();
    422422        }
    423 #elif defined(Q_WS_WIN) || defined(Q_WS_X11)
     423#elif defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    424424        /* Show window in fullscreen mode: */
    425425        showFullScreen();
    … …  
    431431            m_pMiniToolBar->showFullScreen();
    432432        }
    433 #endif /* Q_WS_WIN || Q_WS_X11 */
    434 
    435 #ifdef Q_WS_X11
     433#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     434
     435#ifdef VBOX_WS_X11
    436436        /* If WM supports native stuff, we need to map window to corresponding host-screen. */
    437437        if (fSupportsNativeFullScreen)
    … …  
    447447            }
    448448        }
    449 #endif /* Q_WS_X11 */
     449#endif /* VBOX_WS_X11 */
    450450
    451451        /* Adjust machine-view size if necessary: */
    … …  
    457457}
    458458
    459 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     459#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    460460void UIMachineWindowFullscreen::updateAppearanceOf(int iElement)
    461461{
    … …  
    481481    }
    482482}
    483 #endif /* Q_WS_WIN || Q_WS_X11 */
    484 
    485 #ifdef Q_WS_WIN
     483#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     484
     485#ifdef VBOX_WS_WIN
    486486# if QT_VERSION >= 0x050000
    487487void UIMachineWindowFullscreen::showEvent(QShowEvent *pEvent)
    … …  
    497497}
    498498# endif /* QT_VERSION >= 0x050000 */
    499 #endif /* Q_WS_WIN */
    500 
     499#endif /* VBOX_WS_WIN */
     500

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/fullscreen/UIMachineWindowFullscreen.h

    r59814 r60362  
    2222#include "UIMachineWindow.h"
    2323
    24 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     24#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    2525/* Forward declarations: */
    2626class UIMiniToolBar;
    27 #endif /* Q_WS_WIN || Q_WS_X11 */
     27#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    2828
    2929/** UIMachineWindow reimplementation,
    … …  
    5252    UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId);
    5353
    54 #ifdef Q_WS_MAC
     54#ifdef VBOX_WS_MAC
    5555    /** Mac OS X: Handles native notifications @a strNativeNotificationName for 'fullscreen' window. */
    5656    void handleNativeNotification(const QString &strNativeNotificationName);
    5757    /** Mac OS X: Returns whether window is in 'fullscreen' transition. */
    5858    bool isInFullscreenTransition() const { return m_fIsInFullscreenTransition; }
    59 #endif /* Q_WS_MAC */
     59#endif /* VBOX_WS_MAC */
    6060
    6161private slots:
    6262
    63 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     63#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    6464    /** Handles machine state change event. */
    6565    void sltMachineStateChanged();
    … …  
    6767    /** Revokes window activation. */
    6868    void sltRevokeWindowActivation();
    69 #endif /* Q_WS_WIN || Q_WS_X11 */
     69#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    7070
    7171#ifdef RT_OS_DARWIN
    … …  
    8080    /** Prepare visual-state routine. */
    8181    void prepareVisualState();
    82 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     82#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    8383    /** Prepare mini-toolbar routine. */
    8484    void prepareMiniToolbar();
    85 #endif /* Q_WS_WIN || Q_WS_X11 */
     85#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    8686
    87 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     87#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    8888    /** Cleanup mini-toolbar routine. */
    8989    void cleanupMiniToolbar();
    90 #endif /* Q_WS_WIN || Q_WS_X11 */
     90#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    9191    /** Cleanup visual-state routine. */
    9292    void cleanupVisualState();
    … …  
    9797    void showInNecessaryMode();
    9898
    99 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     99#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    100100    /** Common update routine. */
    101101    void updateAppearanceOf(int iElement);
    102 #endif /* Q_WS_WIN || Q_WS_X11 */
     102#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    103103
    104 #ifdef Q_WS_WIN
     104#ifdef VBOX_WS_WIN
    105105# if QT_VERSION >= 0x050000
    106106    /** Win: Handles show @a pEvent. */
    107107    void showEvent(QShowEvent *pEvent);
    108108# endif /* QT_VERSION >= 0x050000 */
    109 #endif /* Q_WS_WIN */
     109#endif /* VBOX_WS_WIN */
    110110
    111 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     111#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    112112    /** Holds the mini-toolbar instance. */
    113113    UIMiniToolBar *m_pMiniToolBar;
    114 #endif /* Q_WS_WIN || Q_WS_X11 */
     114#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    115115
    116 #ifdef Q_WS_MAC
     116#ifdef VBOX_WS_MAC
    117117    /** Mac OS X: Reflects whether window is in 'fullscreen' transition. */
    118118    bool m_fIsInFullscreenTransition;
    119119    /** Mac OS X: Allows 'fullscreen' API access: */
    120120    friend class UIMachineLogicFullscreen;
    121 #endif /* Q_WS_MAC */
     121#endif /* VBOX_WS_MAC */
    122122
    123123    /** Factory support. */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/information/UIVMInformationDialog.cpp

    r60021 r60362  
    139139            if (isVisible() && (windowState() & (Qt::WindowMaximized | Qt::WindowMinimized | Qt::WindowFullScreen)) == 0)
    140140            {
    141 #ifdef Q_WS_MAC
     141#ifdef VBOX_WS_MAC
    142142                QMoveEvent *pMoveEvent = static_cast<QMoveEvent*>(pEvent);
    143143                m_geometry.moveTo(pMoveEvent->pos());
    144 #else /* Q_WS_MAC */
     144#else /* VBOX_WS_MAC */
    145145                m_geometry.moveTo(geometry().x(), geometry().y());
    146 #endif /* !Q_WS_MAC */
     146#endif /* !VBOX_WS_MAC */
    147147            }
    148148            break;
    … …  
    177177    connect(m_pMachineWindow, SIGNAL(destroyed(QObject*)), this, SLOT(suicide()));
    178178
    179 #ifdef Q_WS_MAC
     179#ifdef VBOX_WS_MAC
    180180    /* No window-icon on Mac OX X, because it acts as proxy icon which isn't necessary here. */
    181181    setWindowIcon(QIcon());
    182 #else /* !Q_WS_MAC */
     182#else /* !VBOX_WS_MAC */
    183183    /* Assign window-icon(s: */
    184184    setWindowIcon(UIIconPool::iconSetFull(":/session_info_32px.png", ":/session_info_16px.png"));
    185 #endif /* !Q_WS_MAC */
     185#endif /* !VBOX_WS_MAC */
    186186
    187187    /* Prepare central-widget: */
    … …  
    277277        /* Load geometry: */
    278278        m_geometry = gEDataManager->informationWindowGeometry(this, m_pMachineWindow, vboxGlobal().managedVMUuid());
    279 #ifdef Q_WS_MAC
     279#ifdef VBOX_WS_MAC
    280280        move(m_geometry.topLeft());
    281281        resize(m_geometry.size());
    282 #else /* Q_WS_MAC */
     282#else /* VBOX_WS_MAC */
    283283        setGeometry(m_geometry);
    284 #endif /* !Q_WS_MAC */
     284#endif /* !VBOX_WS_MAC */
    285285        LogRel2(("GUI: UIVMInformationDialog: Geometry loaded to: Origin=%dx%d, Size=%dx%d\n",
    286286                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    297297    {
    298298        /* Save geometry: */
    299 #ifdef Q_WS_MAC
     299#ifdef VBOX_WS_MAC
    300300        gEDataManager->setInformationWindowGeometry(m_geometry, ::darwinIsWindowMaximized(this), vboxGlobal().managedVMUuid());
    301 #else /* Q_WS_MAC */
     301#else /* VBOX_WS_MAC */
    302302        gEDataManager->setInformationWindowGeometry(m_geometry, isMaximized(), vboxGlobal().managedVMUuid());
    303 #endif /* !Q_WS_MAC */
     303#endif /* !VBOX_WS_MAC */
    304304        LogRel2(("GUI: UIVMInformationDialog: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
    305305                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));

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

    r58857 r60362  
    2121
    2222/* Qt includes: */
    23 # ifndef Q_WS_MAC
     23# ifndef VBOX_WS_MAC
    2424#  include <QMainWindow>
    2525#  include <QMenuBar>
    2626#  include <QKeyEvent>
    2727#  include <QTimer>
    28 # endif /* !Q_WS_MAC */
     28# endif /* !VBOX_WS_MAC */
    2929
    3030/* GUI includes: */
    3131# include "UIKeyboardHandlerNormal.h"
    32 # ifndef Q_WS_MAC
     32# ifndef VBOX_WS_MAC
    3333#  include "UIMachineLogic.h"
    3434#  include "UIMachineWindow.h"
    3535#  include "UIShortcutPool.h"
    36 # endif /* !Q_WS_MAC */
     36# endif /* !VBOX_WS_MAC */
    3737
    3838#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    4040
    4141/* Namespaces: */
    42 #ifndef Q_WS_MAC
     42#ifndef VBOX_WS_MAC
    4343using namespace UIExtraDataDefs;
    44 #endif /* !Q_WS_MAC */
     44#endif /* !VBOX_WS_MAC */
    4545
    4646UIKeyboardHandlerNormal::UIKeyboardHandlerNormal(UIMachineLogic* pMachineLogic)
    … …  
    5353}
    5454
    55 #ifndef Q_WS_MAC
     55#ifndef VBOX_WS_MAC
    5656bool UIKeyboardHandlerNormal::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
    5757{
    … …  
    9191                                /* Activate 'active' menu-bar action: */
    9292                                pMenuBar->activeAction()->activate(QAction::Trigger);
    93 #ifdef Q_WS_WIN
     93#ifdef VBOX_WS_WIN
    9494                                /* Windows host needs separate 'focus set'
    9595                                 * to let menubar operate while popped up: */
    9696                                pMenuBar->setFocus();
    97 #endif /* Q_WS_WIN */
     97#endif /* VBOX_WS_WIN */
    9898                            }
    9999                        }
    … …  
    117117    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
    118118}
    119 #endif /* !Q_WS_MAC */
     119#endif /* !VBOX_WS_MAC */
    120120

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

    r55401 r60362  
    3737private:
    3838
    39 #ifndef Q_WS_MAC
     39#ifndef VBOX_WS_MAC
    4040    /** General event-filter. */
    4141    bool eventFilter(QObject *pWatched, QEvent *pEvent);
    42 #endif /* !Q_WS_MAC */
     42#endif /* !VBOX_WS_MAC */
    4343
    4444    /* Friend class: */

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

    r59079 r60362  
    2121
    2222/* Qt includes: */
    23 # ifndef Q_WS_MAC
     23# ifndef VBOX_WS_MAC
    2424#  include <QTimer>
    25 # endif /* !Q_WS_MAC */
     25# endif /* !VBOX_WS_MAC */
    2626
    2727/* GUI includes: */
    … …  
    3636# include "UIExtraDataManager.h"
    3737# include "UIFrameBuffer.h"
    38 # ifndef Q_WS_MAC
     38# ifndef VBOX_WS_MAC
    3939#  include "QIMenu.h"
    40 # else  /* Q_WS_MAC */
     40# else  /* VBOX_WS_MAC */
    4141#  include "VBoxUtils.h"
    42 # endif /* Q_WS_MAC */
     42# endif /* VBOX_WS_MAC */
    4343
    4444/* COM includes: */
    … …  
    5151UIMachineLogicNormal::UIMachineLogicNormal(QObject *pParent, UISession *pSession)
    5252    : UIMachineLogic(pParent, pSession, UIVisualStateType_Normal)
    53 #ifndef Q_WS_MAC
     53#ifndef VBOX_WS_MAC
    5454    , m_pPopupMenu(0)
    55 #endif /* !Q_WS_MAC */
     55#endif /* !VBOX_WS_MAC */
    5656{
    5757}
    … …  
    117117    AssertReturnVoid(isMachineWindowsCreated());
    118118
    119 #ifndef Q_WS_MAC
     119#ifndef VBOX_WS_MAC
    120120    /* Make sure menu-bar is enabled: */
    121121    const bool fEnabled = actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility)->isChecked();
    122122    AssertReturnVoid(fEnabled);
    123 #endif /* !Q_WS_MAC */
     123#endif /* !VBOX_WS_MAC */
    124124
    125125    /* Prevent user from opening another one editor or toggle menu-bar: */
    126126    actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_S_Settings)->setEnabled(false);
    127 #ifndef Q_WS_MAC
     127#ifndef VBOX_WS_MAC
    128128    actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility)->setEnabled(false);
    129 #endif /* !Q_WS_MAC */
     129#endif /* !VBOX_WS_MAC */
    130130    /* Create menu-bar editor: */
    131131    UIMenuBarEditorWindow *pMenuBarEditor = new UIMenuBarEditorWindow(activeMachineWindow(), actionPool());
    … …  
    135135        connect(pMenuBarEditor, SIGNAL(destroyed(QObject*)),
    136136                this, SLOT(sltMenuBarSettingsClosed()));
    137 #ifdef Q_WS_MAC
     137#ifdef VBOX_WS_MAC
    138138        connect(this, SIGNAL(sigNotifyAbout3DOverlayVisibilityChange(bool)),
    139139                pMenuBarEditor, SLOT(sltActivateWindow()));
    140 #endif /* Q_WS_MAC */
     140#endif /* VBOX_WS_MAC */
    141141        /* Show window: */
    142142        pMenuBarEditor->show();
    … …  
    146146void UIMachineLogicNormal::sltMenuBarSettingsClosed()
    147147{
    148 #ifndef Q_WS_MAC
     148#ifndef VBOX_WS_MAC
    149149    /* Make sure menu-bar is enabled: */
    150150    const bool fEnabled = actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility)->isChecked();
    151151    AssertReturnVoid(fEnabled);
    152 #endif /* !Q_WS_MAC */
     152#endif /* !VBOX_WS_MAC */
    153153
    154154    /* Allow user to open editor and toggle menu-bar again: */
    155155    actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_S_Settings)->setEnabled(true);
    156 #ifndef Q_WS_MAC
     156#ifndef VBOX_WS_MAC
    157157    actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility)->setEnabled(true);
    158 #endif /* !Q_WS_MAC */
     158#endif /* !VBOX_WS_MAC */
    159159}
    160160
    … …  
    190190        connect(pStatusBarEditor, SIGNAL(destroyed(QObject*)),
    191191                this, SLOT(sltStatusBarSettingsClosed()));
    192 #ifdef Q_WS_MAC
     192#ifdef VBOX_WS_MAC
    193193        connect(this, SIGNAL(sigNotifyAbout3DOverlayVisibilityChange(bool)),
    194194                pStatusBarEditor, SLOT(sltActivateWindow()));
    195 #endif /* Q_WS_MAC */
     195#endif /* VBOX_WS_MAC */
    196196        /* Show window: */
    197197        pStatusBarEditor->show();
    … …  
    265265    connect(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_S_Settings), SIGNAL(triggered(bool)),
    266266            this, SLOT(sltOpenMenuBarSettings()));
    267 #ifndef Q_WS_MAC
     267#ifndef VBOX_WS_MAC
    268268    connect(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility), SIGNAL(triggered(bool)),
    269269            this, SLOT(sltToggleMenuBar()));
    270 #endif /* !Q_WS_MAC */
     270#endif /* !VBOX_WS_MAC */
    271271    connect(actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings), SIGNAL(triggered(bool)),
    272272            this, SLOT(sltOpenStatusBarSettings()));
    … …  
    285285        return;
    286286
    287 #ifdef Q_WS_MAC // TODO: Is that really need here?
     287#ifdef VBOX_WS_MAC // TODO: Is that really need here?
    288288    /* We have to make sure that we are getting the front most process.
    289289     * This is necessary for Qt versions > 4.3.3: */
    290290    ::darwinSetFrontMostProcess();
    291 #endif /* Q_WS_MAC */
     291#endif /* VBOX_WS_MAC */
    292292
    293293    /* Get monitors count: */
    … …  
    310310}
    311311
    312 #ifndef Q_WS_MAC
     312#ifndef VBOX_WS_MAC
    313313void UIMachineLogicNormal::prepareMenu()
    314314{
    … …  
    322322    }
    323323}
    324 #endif /* !Q_WS_MAC */
    325 
    326 #ifndef Q_WS_MAC
     324#endif /* !VBOX_WS_MAC */
     325
     326#ifndef VBOX_WS_MAC
    327327void UIMachineLogicNormal::cleanupMenu()
    328328{
    … …  
    331331    m_pPopupMenu = 0;
    332332}
    333 #endif /* !Q_WS_MAC */
     333#endif /* !VBOX_WS_MAC */
    334334
    335335void UIMachineLogicNormal::cleanupMachineWindows()
    … …  
    358358    disconnect(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_S_Settings), SIGNAL(triggered(bool)),
    359359               this, SLOT(sltOpenMenuBarSettings()));
    360 #ifndef Q_WS_MAC
     360#ifndef VBOX_WS_MAC
    361361    disconnect(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility), SIGNAL(triggered(bool)),
    362362               this, SLOT(sltToggleMenuBar()));
    363 #endif /* !Q_WS_MAC */
     363#endif /* !VBOX_WS_MAC */
    364364    disconnect(actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_S_Settings), SIGNAL(triggered(bool)),
    365365               this, SLOT(sltOpenStatusBarSettings()));

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

    r55401 r60362  
    7474    void prepareActionConnections();
    7575    void prepareMachineWindows();
    76 #ifndef Q_WS_MAC
     76#ifndef VBOX_WS_MAC
    7777    void prepareMenu();
    78 #endif /* !Q_WS_MAC */
     78#endif /* !VBOX_WS_MAC */
    7979
    8080    /* Cleanup helpers: */
    81 #ifndef Q_WS_MAC
     81#ifndef VBOX_WS_MAC
    8282    void cleanupMenu();
    83 #endif /* !Q_WS_MAC */
     83#endif /* !VBOX_WS_MAC */
    8484    void cleanupMachineWindows();
    8585    void cleanupActionConnections();
    8686
    87 #ifndef Q_WS_MAC
     87#ifndef VBOX_WS_MAC
    8888    /** Holds the popup-menu instance. */
    8989    QMenu *m_pPopupMenu;
    90 #endif /* !Q_WS_MAC */
     90#endif /* !VBOX_WS_MAC */
    9191
    9292    /* Friend classes: */

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

    r59380 r60362  
    100100    UIMachineView::prepareFilters();
    101101
    102 #ifdef Q_WS_WIN
     102#ifdef VBOX_WS_WIN
    103103    /* Install menu-bar event-filter: */
    104104    machineWindow()->menuBar()->installEventFilter(this);
    105 #endif /* Q_WS_WIN */
     105#endif /* VBOX_WS_WIN */
    106106}
    107107

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

    r59164 r60362  
    4040# include "QIStatusBar.h"
    4141# include "QIStatusBarIndicator.h"
    42 # ifndef Q_WS_MAC
     42# ifndef VBOX_WS_MAC
    4343#  include "UIMenuBar.h"
    44 # else  /* Q_WS_MAC */
     44# else  /* VBOX_WS_MAC */
    4545#  include "VBoxUtils.h"
    4646#  include "UIImageTools.h"
    4747#  include "UICocoaApplication.h"
    48 # endif /* Q_WS_MAC */
     48# endif /* VBOX_WS_MAC */
    4949
    5050/* COM includes: */
    … …  
    239239}
    240240
    241 #ifndef Q_WS_MAC
     241#ifndef VBOX_WS_MAC
    242242void UIMachineWindowNormal::prepareMenu()
    243243{
    … …  
    256256    }
    257257}
    258 #endif /* !Q_WS_MAC */
     258#endif /* !VBOX_WS_MAC */
    259259
    260260void UIMachineWindowNormal::prepareStatusBar()
    … …  
    286286    }
    287287
    288 #ifdef Q_WS_MAC
     288#ifdef VBOX_WS_MAC
    289289    /* For the status-bar on Cocoa: */
    290290    setUnifiedTitleAndToolBarOnMac(true);
    291 #endif /* Q_WS_MAC */
     291#endif /* VBOX_WS_MAC */
    292292}
    293293
    … …  
    306306#endif /* VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    307307
    308 #ifdef Q_WS_MAC
     308#ifdef VBOX_WS_MAC
    309309    /* Beta label? */
    310310    if (vboxGlobal().isBeta())
    … …  
    324324                                                                                UIMachineWindow::handleStandardWindowButtonCallback);
    325325    }
    326 #endif /* Q_WS_MAC */
     326#endif /* VBOX_WS_MAC */
    327327}
    328328
    … …  
    334334    /* Load GUI customizations: */
    335335    {
    336 #ifndef Q_WS_MAC
     336#ifndef VBOX_WS_MAC
    337337        /* Update menu-bar visibility: */
    338338        menuBar()->setVisible(actionPool()->action(UIActionIndexRT_M_View_M_MenuBar_T_Visibility)->isChecked());
    339 #endif /* !Q_WS_MAC */
     339#endif /* !VBOX_WS_MAC */
    340340        /* Update status-bar visibility: */
    341341        statusBar()->setVisible(actionPool()->action(UIActionIndexRT_M_View_M_StatusBar_T_Visibility)->isChecked());
    … …  
    390390
    391391        /* Normalize to the optimal size: */
    392 #ifdef Q_WS_X11
     392#ifdef VBOX_WS_X11
    393393        QTimer::singleShot(0, this, SLOT(sltNormalizeGeometry()));
    394 #else /* !Q_WS_X11 */
     394#else /* !VBOX_WS_X11 */
    395395        normalizeGeometry(true /* adjust position */);
    396 #endif /* !Q_WS_X11 */
     396#endif /* !VBOX_WS_X11 */
    397397    }
    398398}
    … …  
    413413void UIMachineWindowNormal::cleanupVisualState()
    414414{
    415 #ifdef Q_WS_MAC
     415#ifdef VBOX_WS_MAC
    416416    /* Unregister 'Zoom' button from using our full-screen since Yosemite: */
    417417    if (vboxGlobal().osRelease() >= MacOSXRelease_Yosemite)
    418418        UICocoaApplication::instance()->unregisterCallbackForStandardWindowButton(this, StandardWindowButtonType_Zoom);
    419 #endif /* Q_WS_MAC */
     419#endif /* VBOX_WS_MAC */
    420420}
    421421
    … …  
    572572}
    573573
    574 #ifndef Q_WS_MAC
     574#ifndef VBOX_WS_MAC
    575575void UIMachineWindowNormal::updateMenu()
    576576{
    … …  
    580580        menuBar()->addMenu(pMenu);
    581581}
    582 #endif /* !Q_WS_MAC */
     582#endif /* !VBOX_WS_MAC */
    583583
    584584bool UIMachineWindowNormal::isMaximizedChecked()
    585585{
    586 #ifdef Q_WS_MAC
     586#ifdef VBOX_WS_MAC
    587587    /* On the Mac the WindowStateChange signal doesn't seems to be delivered
    588588     * when the user get out of the maximized state. So check this ourself. */
    589589    return ::darwinIsWindowMaximized(this);
    590 #else /* Q_WS_MAC */
     590#else /* VBOX_WS_MAC */
    591591    return isMaximized();
    592 #endif /* !Q_WS_MAC */
    593 }
    594 
     592#endif /* !VBOX_WS_MAC */
     593}
     594

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

    r59164 r60362  
    4444private slots:
    4545
    46 #ifdef Q_WS_X11
     46#ifdef VBOX_WS_X11
    4747    /** X11: Performs machine-window async geometry normalization. */
    4848    void sltNormalizeGeometry() { normalizeGeometry(true /* adjust position */); }
    49 #endif /* Q_WS_X11 */
     49#endif /* VBOX_WS_X11 */
    5050
    5151    /** Handles machine state change event. */
    … …  
    8686    /** Prepare session connections routine. */
    8787    void prepareSessionConnections();
    88 #ifndef Q_WS_MAC
     88#ifndef VBOX_WS_MAC
    8989    /** Prepare menu routine. */
    9090    void prepareMenu();
    91 #endif /* !Q_WS_MAC */
     91#endif /* !VBOX_WS_MAC */
    9292    /** Prepare status-bar routine. */
    9393    void prepareStatusBar();
    … …  
    113113    void updateAppearanceOf(int aElement);
    114114
    115 #ifndef Q_WS_MAC
     115#ifndef VBOX_WS_MAC
    116116    /** Updates menu-bar content. */
    117117    void updateMenu();
    118 #endif /* !Q_WS_MAC */
     118#endif /* !VBOX_WS_MAC */
    119119
    120120    /** Common @a pEvent handler. */

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

    r58857 r60362  
    2121
    2222/* Qt includes: */
    23 # ifndef Q_WS_MAC
     23# ifndef VBOX_WS_MAC
    2424#  include <QKeyEvent>
    2525#  include <QTimer>
    26 # endif /* !Q_WS_MAC */
     26# endif /* !VBOX_WS_MAC */
    2727
    2828/* GUI includes: */
    2929# include "UIKeyboardHandlerScale.h"
    30 # ifndef Q_WS_MAC
     30# ifndef VBOX_WS_MAC
    3131#  include "UIMachineLogic.h"
    3232#  include "UIShortcutPool.h"
    33 # endif /* !Q_WS_MAC */
     33# endif /* !VBOX_WS_MAC */
    3434
    3535#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    3636
    3737
    38 #ifndef Q_WS_MAC
     38#ifndef VBOX_WS_MAC
    3939/* Namespaces: */
    4040using namespace UIExtraDataDefs;
    41 #endif /* !Q_WS_MAC */
     41#endif /* !VBOX_WS_MAC */
    4242
    4343UIKeyboardHandlerScale::UIKeyboardHandlerScale(UIMachineLogic* pMachineLogic)
    … …  
    5050}
    5151
    52 #ifndef Q_WS_MAC
     52#ifndef VBOX_WS_MAC
    5353bool UIKeyboardHandlerScale::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
    5454{
    … …  
    8484    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
    8585}
    86 #endif /* !Q_WS_MAC */
     86#endif /* !VBOX_WS_MAC */
    8787

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIKeyboardHandlerScale.h

    r55401 r60362  
    3737private:
    3838
    39 #ifndef Q_WS_MAC
     39#ifndef VBOX_WS_MAC
    4040    /** General event-filter. */
    4141    bool eventFilter(QObject *pWatched, QEvent *pEvent);
    42 #endif /* !Q_WS_MAC */
     42#endif /* !VBOX_WS_MAC */
    4343
    4444    /* Friend class: */

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

    r54217 r60362  
    2121
    2222/* Qt includes: */
    23 # ifndef Q_WS_MAC
     23# ifndef VBOX_WS_MAC
    2424#  include <QTimer>
    25 # endif /* !Q_WS_MAC */
     25# endif /* !VBOX_WS_MAC */
    2626
    2727/* GUI includes: */
    … …  
    3333# include "UIMachineWindow.h"
    3434# include "UIShortcutPool.h"
    35 # ifndef Q_WS_MAC
     35# ifndef VBOX_WS_MAC
    3636#  include "QIMenu.h"
    37 # else  /* Q_WS_MAC */
     37# else  /* VBOX_WS_MAC */
    3838#  include "VBoxUtils.h"
    39 # endif /* Q_WS_MAC */
     39# endif /* VBOX_WS_MAC */
    4040
    4141#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    4444UIMachineLogicScale::UIMachineLogicScale(QObject *pParent, UISession *pSession)
    4545    : UIMachineLogic(pParent, pSession, UIVisualStateType_Scale)
    46 #ifndef Q_WS_MAC
     46#ifndef VBOX_WS_MAC
    4747    , m_pPopupMenu(0)
    48 #endif /* !Q_WS_MAC */
     48#endif /* !VBOX_WS_MAC */
    4949{
    5050}
    … …  
    6363}
    6464
    65 #ifndef Q_WS_MAC
     65#ifndef VBOX_WS_MAC
    6666void UIMachineLogicScale::sltInvokePopupMenu()
    6767{
    … …  
    7373    }
    7474}
    75 #endif /* !Q_WS_MAC */
     75#endif /* !VBOX_WS_MAC */
    7676
    7777void UIMachineLogicScale::prepareActionGroups()
    … …  
    120120        return;
    121121
    122 #ifdef Q_WS_MAC // TODO: Is that really need here?
     122#ifdef VBOX_WS_MAC // TODO: Is that really need here?
    123123    /* We have to make sure that we are getting the front most process.
    124124     * This is necessary for Qt versions > 4.3.3: */
    125125    ::darwinSetFrontMostProcess();
    126 #endif /* Q_WS_MAC */
     126#endif /* VBOX_WS_MAC */
    127127
    128128    /* Get monitors count: */
    … …  
    145145}
    146146
    147 #ifndef Q_WS_MAC
     147#ifndef VBOX_WS_MAC
    148148void UIMachineLogicScale::prepareMenu()
    149149{
    … …  
    157157    }
    158158}
    159 #endif /* !Q_WS_MAC */
    160 
    161 #ifndef Q_WS_MAC
     159#endif /* !VBOX_WS_MAC */
     160
     161#ifndef VBOX_WS_MAC
    162162void UIMachineLogicScale::cleanupMenu()
    163163{
    … …  
    166166    m_pPopupMenu = 0;
    167167}
    168 #endif /* !Q_WS_MAC */
     168#endif /* !VBOX_WS_MAC */
    169169
    170170void UIMachineLogicScale::cleanupMachineWindows()

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

    r59335 r60362  
    3333# include "UIMachineWindowScale.h"
    3434# include "UIMachineView.h"
    35 # ifdef Q_WS_MAC
     35# ifdef VBOX_WS_MAC
    3636#  include "VBoxUtils.h"
    3737#  include "UIImageTools.h"
    3838#  include "UICocoaApplication.h"
    39 # endif /* Q_WS_MAC */
     39# endif /* VBOX_WS_MAC */
    4040
    4141#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    5959}
    6060
    61 #ifdef Q_WS_MAC
     61#ifdef VBOX_WS_MAC
    6262void UIMachineWindowScale::prepareVisualState()
    6363{
    … …  
    8383    }
    8484}
    85 #endif /* Q_WS_MAC */
     85#endif /* VBOX_WS_MAC */
    8686
    8787void UIMachineWindowScale::loadSettings()
    … …  
    138138}
    139139
    140 #ifdef Q_WS_MAC
     140#ifdef VBOX_WS_MAC
    141141void UIMachineWindowScale::cleanupVisualState()
    142142{
    … …  
    145145        UICocoaApplication::instance()->unregisterCallbackForStandardWindowButton(this, StandardWindowButtonType_Zoom);
    146146}
    147 #endif /* Q_WS_MAC */
     147#endif /* VBOX_WS_MAC */
    148148
    149149void UIMachineWindowScale::showInNecessaryMode()
    … …  
    199199}
    200200
    201 #ifdef Q_WS_WIN
     201#ifdef VBOX_WS_WIN
    202202# if QT_VERSION < 0x050000
    203203bool UIMachineWindowScale::winEvent(MSG *pMessage, long *pResult)
    … …  
    246246}
    247247# endif /* QT_VERSION < 0x050000 */
    248 #endif /* Q_WS_WIN */
     248#endif /* VBOX_WS_WIN */
    249249
    250250bool UIMachineWindowScale::isMaximizedChecked()
    251251{
    252 #ifdef Q_WS_MAC
     252#ifdef VBOX_WS_MAC
    253253    /* On the Mac the WindowStateChange signal doesn't seems to be delivered
    254254     * when the user get out of the maximized state. So check this ourself. */
    255255    return ::darwinIsWindowMaximized(this);
    256 #else /* Q_WS_MAC */
     256#else /* VBOX_WS_MAC */
    257257    return isMaximized();
    258 #endif /* !Q_WS_MAC */
    259 }
    260 
     258#endif /* !VBOX_WS_MAC */
     259}
     260

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/scale/UIMachineWindowScale.h

    r59335 r60362  
    3737    /** Prepare main-layout routine. */
    3838    void prepareMainLayout();
    39 #ifdef Q_WS_MAC
     39#ifdef VBOX_WS_MAC
    4040    /** Prepare visual-state routine. */
    4141    void prepareVisualState();
    42 #endif /* Q_WS_MAC */
     42#endif /* VBOX_WS_MAC */
    4343    /** Load settings routine. */
    4444    void loadSettings();
    … …  
    4646    /** Save settings routine. */
    4747    void saveSettings();
    48 #ifdef Q_WS_MAC
     48#ifdef VBOX_WS_MAC
    4949    /** Cleanup visual-state routine. */
    5050    void cleanupVisualState();
    51 #endif /* Q_WS_MAC */
     51#endif /* VBOX_WS_MAC */
    5252
    5353    /** Updates visibility according to visual-state. */
    … …  
    5656    /** Common @a pEvent handler. */
    5757    bool event(QEvent *pEvent);
    58 #ifdef Q_WS_WIN
     58#ifdef VBOX_WS_WIN
    5959# if QT_VERSION < 0x050000
    6060    /** Qt4: Win: Handles all native messages. */
    6161    bool winEvent(MSG *pMessage, long *pResult);
    6262# endif /* QT_VERSION < 0x050000 */
    63 #endif /* Q_WS_WIN */
     63#endif /* VBOX_WS_WIN */
    6464
    6565    /** Returns whether this window is maximized. */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIKeyboardHandlerSeamless.cpp

    r58857 r60362  
    2020#else  /* !VBOX_WITH_PRECOMPILED_HEADERS */
    2121
    22 # ifndef Q_WS_MAC
     22# ifndef VBOX_WS_MAC
    2323/* Qt includes: */
    2424#  include <QKeyEvent>
    2525#  include <QTimer>
    26 # endif /* !Q_WS_MAC */
     26# endif /* !VBOX_WS_MAC */
    2727
    2828/* GUI includes: */
    2929# include "UIKeyboardHandlerSeamless.h"
    30 # ifndef Q_WS_MAC
     30# ifndef VBOX_WS_MAC
    3131#  include "UIMachineLogic.h"
    3232#  include "UIShortcutPool.h"
    33 # endif /* !Q_WS_MAC */
     33# endif /* !VBOX_WS_MAC */
    3434
    3535#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    3636
    3737
    38 #ifndef Q_WS_MAC
     38#ifndef VBOX_WS_MAC
    3939/* Namespaces: */
    4040using namespace UIExtraDataDefs;
    41 #endif /* !Q_WS_MAC */
     41#endif /* !VBOX_WS_MAC */
    4242
    4343UIKeyboardHandlerSeamless::UIKeyboardHandlerSeamless(UIMachineLogic* pMachineLogic)
    … …  
    5050}
    5151
    52 #ifndef Q_WS_MAC
     52#ifndef VBOX_WS_MAC
    5353bool UIKeyboardHandlerSeamless::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
    5454{
    … …  
    8484    return UIKeyboardHandler::eventFilter(pWatchedObject, pEvent);
    8585}
    86 #endif /* !Q_WS_MAC */
     86#endif /* !VBOX_WS_MAC */
    8787

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIKeyboardHandlerSeamless.h

    r55401 r60362  
    3737private:
    3838
    39 #ifndef Q_WS_MAC
     39#ifndef VBOX_WS_MAC
    4040    /** General event-filter. */
    4141    bool eventFilter(QObject *pWatched, QEvent *pEvent);
    42 #endif /* !Q_WS_MAC */
     42#endif /* !VBOX_WS_MAC */
    4343
    4444    /* Friend class: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.cpp

    r59079 r60362  
    2121
    2222/* Qt includes: */
    23 # ifndef Q_WS_MAC
     23# ifndef VBOX_WS_MAC
    2424#  include <QTimer>
    25 # endif /* !Q_WS_MAC */
     25# endif /* !VBOX_WS_MAC */
    2626
    2727/* GUI includes: */
    … …  
    3535# include "UIMultiScreenLayout.h"
    3636# include "UIShortcutPool.h"
    37 # ifndef Q_WS_MAC
     37# ifndef VBOX_WS_MAC
    3838#  include "QIMenu.h"
    39 # else  /* Q_WS_MAC */
     39# else  /* VBOX_WS_MAC */
    4040#  include "VBoxUtils.h"
    41 # endif /* Q_WS_MAC */
     41# endif /* VBOX_WS_MAC */
    4242
    4343#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    4646UIMachineLogicSeamless::UIMachineLogicSeamless(QObject *pParent, UISession *pSession)
    4747    : UIMachineLogic(pParent, pSession, UIVisualStateType_Seamless)
    48 #ifndef Q_WS_MAC
     48#ifndef VBOX_WS_MAC
    4949    , m_pPopupMenu(0)
    50 #endif /* !Q_WS_MAC */
     50#endif /* !VBOX_WS_MAC */
    5151{
    5252    /* Create multiscreen layout: */
    … …  
    164164}
    165165
    166 #ifndef Q_WS_MAC
     166#ifndef VBOX_WS_MAC
    167167void UIMachineLogicSeamless::sltInvokePopupMenu()
    168168{
    … …  
    174174    }
    175175}
    176 #endif /* !Q_WS_MAC */
     176#endif /* !VBOX_WS_MAC */
    177177
    178178void UIMachineLogicSeamless::sltScreenLayoutChanged()
    … …  
    230230                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_StatusBar |
    231231                                                          UIExtraDataMetaDefs::RuntimeMenuViewActionType_Resize));
    232 #ifdef Q_WS_MAC
     232#ifdef VBOX_WS_MAC
    233233    /* Restrict 'Window' menu: */
    234234    actionPool()->toRuntime()->setRestrictionForMenuBar(UIActionRestrictionLevel_Logic,
    235235                                                        UIExtraDataMetaDefs::MenuType_Window);
    236 #endif /* Q_WS_MAC */
     236#endif /* VBOX_WS_MAC */
    237237
    238238    /* Take care of view-action toggle state: */
    … …  
    266266        return;
    267267
    268 #ifdef Q_WS_MAC
     268#ifdef VBOX_WS_MAC
    269269    /* We have to make sure that we are getting the front most process.
    270270     * This is necessary for Qt versions > 4.3.3: */
    271271    darwinSetFrontMostProcess();
    272 #endif /* Q_WS_MAC */
     272#endif /* VBOX_WS_MAC */
    273273
    274274    /* Update the multi-screen layout: */
    … …  
    292292    setMachineWindowsCreated(true);
    293293
    294 #ifdef Q_WS_X11
     294#ifdef VBOX_WS_X11
    295295    switch (vboxGlobal().typeOfWindowManager())
    296296    {
    … …  
    308308            break;
    309309    }
    310 #endif /* Q_WS_X11 */
    311 }
    312 
    313 #ifndef Q_WS_MAC
     310#endif /* VBOX_WS_X11 */
     311}
     312
     313#ifndef VBOX_WS_MAC
    314314void UIMachineLogicSeamless::prepareMenu()
    315315{
    … …  
    323323    }
    324324}
    325 #endif /* !Q_WS_MAC */
    326 
    327 #ifndef Q_WS_MAC
     325#endif /* !VBOX_WS_MAC */
     326
     327#ifndef VBOX_WS_MAC
    328328void UIMachineLogicSeamless::cleanupMenu()
    329329{
    … …  
    332332    m_pPopupMenu = 0;
    333333}
    334 #endif /* !Q_WS_MAC */
     334#endif /* !VBOX_WS_MAC */
    335335
    336336void UIMachineLogicSeamless::cleanupMachineWindows()
    … …  
    376376    actionPool()->toRuntime()->setRestrictionForMenuView(UIActionRestrictionLevel_Logic,
    377377                                                         UIExtraDataMetaDefs::RuntimeMenuViewActionType_Invalid);
    378 #ifdef Q_WS_MAC
     378#ifdef VBOX_WS_MAC
    379379    /* Allow 'Window' menu: */
    380380    actionPool()->toRuntime()->setRestrictionForMenuBar(UIActionRestrictionLevel_Logic,
    381381                                                        UIExtraDataMetaDefs::MenuType_Invalid);
    382 #endif /* Q_WS_MAC */
     382#endif /* VBOX_WS_MAC */
    383383
    384384    /* Call to base-class: */

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineLogicSeamless.h

    r59079 r60362  
    8181    void prepareActionConnections();
    8282    void prepareMachineWindows();
    83 #ifndef Q_WS_MAC
     83#ifndef VBOX_WS_MAC
    8484    void prepareMenu();
    85 #endif /* !Q_WS_MAC */
     85#endif /* !VBOX_WS_MAC */
    8686
    8787    /* Cleanup helpers: */
    88 #ifndef Q_WS_MAC
     88#ifndef VBOX_WS_MAC
    8989    void cleanupMenu();
    90 #endif /* !Q_WS_MAC */
     90#endif /* !VBOX_WS_MAC */
    9191    void cleanupMachineWindows();
    9292    void cleanupActionConnections();

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineViewSeamless.cpp

    r59380 r60362  
    2424# include <QMainWindow>
    2525# include <QTimer>
    26 # ifdef Q_WS_MAC
     26# ifdef VBOX_WS_MAC
    2727#  include <QMenuBar>
    28 # endif /* Q_WS_MAC */
     28# endif /* VBOX_WS_MAC */
    2929
    3030/* GUI includes: */
    … …  
    4444
    4545/* External includes: */
    46 #ifdef Q_WS_X11
     46#ifdef VBOX_WS_X11
    4747# include <limits.h>
    48 #endif /* Q_WS_X11 */
     48#endif /* VBOX_WS_X11 */
    4949
    5050

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.cpp

    r59821 r60362  
    3232# include "UIMachineWindowSeamless.h"
    3333# include "UIMachineView.h"
    34 # if   defined(Q_WS_WIN) || defined(Q_WS_X11)
     34# if   defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    3535#  include "UIMachineDefs.h"
    3636#  include "UIMiniToolBar.h"
    37 # elif defined(Q_WS_MAC)
     37# elif defined(VBOX_WS_MAC)
    3838#  include "VBoxUtils.h"
    39 # endif /* Q_WS_MAC */
     39# endif /* VBOX_WS_MAC */
    4040
    4141/* COM includes: */
    … …  
    4747UIMachineWindowSeamless::UIMachineWindowSeamless(UIMachineLogic *pMachineLogic, ulong uScreenId)
    4848    : UIMachineWindow(pMachineLogic, uScreenId)
    49 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     49#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    5050    , m_pMiniToolBar(0)
    51 #endif /* Q_WS_WIN || Q_WS_X11 */
    52 {
    53 }
    54 
    55 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     51#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     52{
     53}
     54
     55#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    5656void UIMachineWindowSeamless::sltMachineStateChanged()
    5757{
    … …  
    7070
    7171    /* Revoke stolen activation: */
    72 #ifdef Q_WS_X11
     72#ifdef VBOX_WS_X11
    7373    raise();
    74 #endif /* Q_WS_X11 */
     74#endif /* VBOX_WS_X11 */
    7575    activateWindow();
    7676}
    77 #endif /* Q_WS_WIN || Q_WS_X11 */
     77#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    7878
    7979void UIMachineWindowSeamless::prepareVisualState()
    … …  
    8787
    8888#ifdef VBOX_WITH_TRANSLUCENT_SEAMLESS
    89 # if defined(Q_WS_MAC) && QT_VERSION < 0x050000
     89# if defined(VBOX_WS_MAC) && QT_VERSION < 0x050000
    9090    /* Using native API to enable translucent background for the Mac host.
    9191     * - We also want to disable window-shadows which is possible
    … …  
    9393     *   while minimum supported version is 4.7.1 for now: */
    9494    ::darwinSetShowsWindowTransparent(this, true);
    95 # else /* !Q_WS_MAC || QT_VERSION >= 0x050000 */
     95# else /* !VBOX_WS_MAC || QT_VERSION >= 0x050000 */
    9696    /* Using Qt API to enable translucent background:
    9797     * - Under Win host Qt conflicts with 3D stuff (black seamless regions).
    … …  
    9999     *   until version 4.8, but minimum supported version is 4.7.1 for now. */
    100100    setAttribute(Qt::WA_TranslucentBackground);
    101 # endif /* !Q_WS_MAC || QT_VERSION >= 0x050000 */
     101# endif /* !VBOX_WS_MAC || QT_VERSION >= 0x050000 */
    102102#endif /* VBOX_WITH_TRANSLUCENT_SEAMLESS */
    103103
    … …  
    108108#endif /* VBOX_WITH_MASKED_SEAMLESS */
    109109
    110 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     110#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    111111    /* Prepare mini-toolbar: */
    112112    prepareMiniToolbar();
    113 #endif /* Q_WS_WIN || Q_WS_X11 */
    114 }
    115 
    116 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     113#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     114}
     115
     116#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    117117void UIMachineWindowSeamless::prepareMiniToolbar()
    118118{
    … …  
    140140    }
    141141}
    142 #endif /* Q_WS_WIN || Q_WS_X11 */
    143 
    144 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     142#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     143
     144#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    145145void UIMachineWindowSeamless::cleanupMiniToolbar()
    146146{
    … …  
    155155    m_pMiniToolBar = 0;
    156156}
    157 #endif /* Q_WS_WIN || Q_WS_X11 */
     157#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    158158
    159159void UIMachineWindowSeamless::cleanupVisualState()
    160160{
    161 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     161#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    162162    /* Cleanup mini-toolbar: */
    163163    cleanupMiniToolbar();
    164 #endif /* Q_WS_WIN || Q_WS_X11 */
     164#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    165165
    166166    /* Call to base-class: */
    … …  
    179179    move(workingArea.topLeft());
    180180
    181 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     181#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    182182    /* If there is a mini-toolbar: */
    183183    if (m_pMiniToolBar)
    … …  
    187187        m_pMiniToolBar->move(workingArea.topLeft());
    188188    }
    189 #endif /* Q_WS_WIN || Q_WS_X11 */
     189#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    190190}
    191191
    … …  
    200200        !pSeamlessLogic->hasHostScreenForGuestScreen(m_uScreenId))
    201201    {
    202 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     202#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    203203        /* If there is a mini-toolbar: */
    204204        if (m_pMiniToolBar)
    … …  
    207207            m_pMiniToolBar->hide();
    208208        }
    209 #endif /* Q_WS_WIN || Q_WS_X11 */
     209#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    210210
    211211        /* Hide window: */
    … …  
    224224        show();
    225225
    226 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     226#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    227227        /* If there is a mini-toolbar: */
    228228        if (m_pMiniToolBar)
    … …  
    231231            m_pMiniToolBar->show();
    232232        }
    233 #endif /* Q_WS_WIN || Q_WS_X11 */
     233#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    234234
    235235        /* Adjust machine-view size if necessary: */
    … …  
    241241}
    242242
    243 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     243#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    244244void UIMachineWindowSeamless::updateAppearanceOf(int iElement)
    245245{
    … …  
    265265    }
    266266}
    267 #endif /* Q_WS_WIN || Q_WS_X11 */
    268 
    269 #ifdef Q_WS_WIN
     267#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     268
     269#ifdef VBOX_WS_WIN
    270270# if QT_VERSION >= 0x050000
    271271void UIMachineWindowSeamless::showEvent(QShowEvent *pEvent)
    … …  
    281281}
    282282# endif /* QT_VERSION >= 0x050000 */
    283 #endif /* Q_WS_WIN */
     283#endif /* VBOX_WS_WIN */
    284284
    285285#ifdef VBOX_WITH_MASKED_SEAMLESS

  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/seamless/UIMachineWindowSeamless.h

    r59814 r60362  
    2222#include "UIMachineWindow.h"
    2323
    24 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     24#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    2525/* Forward declarations: */
    2626class UIMiniToolBar;
    27 #endif /* Q_WS_WIN || Q_WS_X11 */
     27#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    2828
    2929/** UIMachineWindow reimplementation,
    … …  
    4040private slots:
    4141
    42 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     42#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    4343    /** Handles machine state change event. */
    4444    void sltMachineStateChanged();
    … …  
    4646    /** Revokes window activation. */
    4747    void sltRevokeWindowActivation();
    48 #endif /* Q_WS_WIN || Q_WS_X11 */
     48#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    4949
    5050private:
    … …  
    5252    /** Prepare visual-state routine. */
    5353    void prepareVisualState();
    54 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     54#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    5555    /** Prepare mini-toolbar routine. */
    5656    void prepareMiniToolbar();
    57 #endif /* Q_WS_WIN || Q_WS_X11 */
     57#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    5858
    59 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     59#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    6060    /** Cleanup mini-toolbar routine. */
    6161    void cleanupMiniToolbar();
    62 #endif /* Q_WS_WIN || Q_WS_X11 */
     62#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    6363    /** Cleanup visual-state routine. */
    6464    void cleanupVisualState();
    … …  
    6969    void showInNecessaryMode();
    7070
    71 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     71#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    7272    /** Common update routine. */
    7373    void updateAppearanceOf(int iElement);
    74 #endif /* Q_WS_WIN || Q_WS_X11 */
     74#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    7575
    76 #ifdef Q_WS_WIN
     76#ifdef VBOX_WS_WIN
    7777# if QT_VERSION >= 0x050000
    7878    /** Win: Handles show @a pEvent. */
    7979    void showEvent(QShowEvent *pEvent);
    8080# endif /* QT_VERSION >= 0x050000 */
    81 #endif /* Q_WS_WIN */
     81#endif /* VBOX_WS_WIN */
    8282
    8383#ifdef VBOX_WITH_MASKED_SEAMLESS
    … …  
    8686#endif /* VBOX_WITH_MASKED_SEAMLESS */
    8787
    88 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
     88#if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
    8989    /** Holds the mini-toolbar instance. */
    9090    UIMiniToolBar *m_pMiniToolBar;
    91 #endif /* Q_WS_WIN || Q_WS_X11 */
     91#endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    9292
    9393#ifdef VBOX_WITH_MASKED_SEAMLESS

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

    r58362 r60362  
    4646    void retranslateUi()
    4747    {
    48 #ifdef Q_WS_MAC
     48#ifdef VBOX_WS_MAC
    4949        setName(QApplication::translate("UIActionPool", "&File", "Mac OS X version"));
    50 #else /* Q_WS_MAC */
     50#else /* VBOX_WS_MAC */
    5151        setName(QApplication::translate("UIActionPool", "&File", "Non Mac OS X version"));
    52 #endif /* !Q_WS_MAC */
     52#endif /* !VBOX_WS_MAC */
    5353    }
    5454};
    … …  
    831831    void retranslateUi()
    832832    {
    833 #if defined(Q_WS_MAC)
     833#if defined(VBOX_WS_MAC)
    834834        setName(QApplication::translate("UIActionPool", "S&how in Finder"));
    835835        setStatusTip(QApplication::translate("UIActionPool", "Show the VirtualBox Machine Definition files in Finder"));
    836 #elif defined(Q_WS_WIN)
     836#elif defined(VBOX_WS_WIN)
    837837        setName(QApplication::translate("UIActionPool", "S&how in Explorer"));
    838838        setStatusTip(QApplication::translate("UIActionPool", "Show the VirtualBox Machine Definition files in Explorer"));
    … …  
    862862    void retranslateUi()
    863863    {
    864 #if defined(Q_WS_MAC)
     864#if defined(VBOX_WS_MAC)
    865865        setName(QApplication::translate("UIActionPool", "Cr&eate Alias on Desktop"));
    866866        setStatusTip(QApplication::translate("UIActionPool", "Create alias files to the VirtualBox Machine Definition files on your desktop"));

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

    r59887 r60362  
    6565# include "UIExtraDataManager.h"
    6666# include "VBoxGlobal.h"
    67 # ifdef Q_WS_MAC
     67# ifdef VBOX_WS_MAC
    6868#  include "VBoxUtils.h"
    6969#  include "UIWindowMenuManager.h"
    7070#  include "UIImageTools.h"
    71 # endif /* Q_WS_MAC */
     71# endif /* VBOX_WS_MAC */
    7272
    7373/* Other VBox stuff: */
    7474# include <iprt/buildconfig.h>
    7575# include <VBox/version.h>
    76 # ifdef Q_WS_X11
     76# ifdef VBOX_WS_X11
    7777#  include <iprt/env.h>
    78 # endif /* Q_WS_X11 */
     78# endif /* VBOX_WS_X11 */
    7979
    8080#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    … …  
    115115    , m_pActionPool(0)
    116116    , m_pSplitter(0)
    117 #ifndef Q_WS_MAC
     117#ifndef VBOX_WS_MAC
    118118    , m_pBar(0)
    119 #endif /* !Q_WS_MAC */
     119#endif /* !VBOX_WS_MAC */
    120120    , m_pToolBar(0)
    121121    , m_pContainerDetails(0)
    … …  
    140140    QAction *pShowToolBar = new QAction(tr("Show Toolbar"), 0);
    141141    pShowToolBar->setCheckable(true);
    142 #ifdef Q_WS_MAC
     142#ifdef VBOX_WS_MAC
    143143    pShowToolBar->setChecked(m_pToolBar->isVisible());
    144 #else /* Q_WS_MAC */
     144#else /* VBOX_WS_MAC */
    145145    pShowToolBar->setChecked(m_pBar->isVisible());
    146 #endif /* !Q_WS_MAC */
     146#endif /* !VBOX_WS_MAC */
    147147    actions << pShowToolBar;
    148148    QAction *pShowStatusBar = new QAction(tr("Show Statusbar"), 0);
    … …  
    160160        if (pResult->isChecked())
    161161        {
    162 #ifdef Q_WS_MAC
     162#ifdef VBOX_WS_MAC
    163163            m_pToolBar->show();
    164 #else /* Q_WS_MAC */
     164#else /* VBOX_WS_MAC */
    165165            m_pBar->show();
    166 #endif /* !Q_WS_MAC */
     166#endif /* !VBOX_WS_MAC */
    167167        }
    168168        else
    169169        {
    170 #ifdef Q_WS_MAC
     170#ifdef VBOX_WS_MAC
    171171            m_pToolBar->hide();
    172 #else /* Q_WS_MAC */
     172#else /* VBOX_WS_MAC */
    173173            m_pBar->hide();
    174 #endif /* !Q_WS_MAC */
     174#endif /* !VBOX_WS_MAC */
    175175        }
    176176    }
    … …  
    324324    for (int i = 0; i < list.size(); ++i)
    325325    {
    326 #ifdef Q_WS_MAC
     326#ifdef VBOX_WS_MAC
    327327        QString strFile = ::darwinResolveAlias(list.at(i).toLocalFile());
    328 #else /* Q_WS_MAC */
     328#else /* VBOX_WS_MAC */
    329329        QString strFile = list.at(i).toLocalFile();
    330 #endif /* !Q_WS_MAC */
     330#endif /* !VBOX_WS_MAC */
    331331        if (!strFile.isEmpty() && QFile::exists(strFile))
    332332        {
    … …  
    401401{
    402402    /* Show Import Appliance wizard: */
    403 #ifdef Q_WS_MAC
     403#ifdef VBOX_WS_MAC
    404404    QString strTmpFile = ::darwinResolveAlias(strFileName);
    405 #else /* Q_WS_MAC */
     405#else /* VBOX_WS_MAC */
    406406    QString strTmpFile = strFileName;
    407 #endif /* !Q_WS_MAC */
     407#endif /* !VBOX_WS_MAC */
    408408    UISafePointerWizardImportApp pWizard = new UIWizardImportApp(this, strTmpFile);
    409409    pWizard->prepare();
    … …  
    467467{
    468468    /* Initialize variables: */
    469 #ifdef Q_WS_MAC
     469#ifdef VBOX_WS_MAC
    470470    QString strTmpFile = ::darwinResolveAlias(strFileName);
    471 #else /* Q_WS_MAC */
     471#else /* VBOX_WS_MAC */
    472472    QString strTmpFile = strFileName;
    473 #endif /* !Q_WS_MAC */
     473#endif /* !VBOX_WS_MAC */
    474474    CVirtualBox vbox = vboxGlobal().virtualBox();
    475475    if (strTmpFile.isEmpty())
    … …  
    10251025    sltHandleChooserPaneIndexChange();
    10261026
    1027 #ifdef Q_WS_MAC
     1027#ifdef VBOX_WS_MAC
    10281028    /* Avoid bug in Qt Cocoa which results in showing a "more arrow" on size-hint changes: */
    10291029    m_pToolBar->updateLayout();
    1030 #endif /* Q_WS_MAC */
     1030#endif /* VBOX_WS_MAC */
    10311031}
    10321032
    … …  
    10501050            if (isVisible() && (windowState() & (Qt::WindowMaximized | Qt::WindowMinimized | Qt::WindowFullScreen)) == 0)
    10511051            {
    1052 #ifdef Q_WS_MAC
     1052#ifdef VBOX_WS_MAC
    10531053                QMoveEvent *pMoveEvent = static_cast<QMoveEvent*>(pEvent);
    10541054                m_geometry.moveTo(pMoveEvent->pos());
    1055 #else /* Q_WS_MAC */
     1055#else /* VBOX_WS_MAC */
    10561056                m_geometry.moveTo(geometry().x(), geometry().y());
    1057 #endif /* !Q_WS_MAC */
     1057#endif /* !VBOX_WS_MAC */
    10581058            }
    10591059            break;
    … …  
    10651065            break;
    10661066        }
    1067 #ifdef Q_WS_MAC
     1067#ifdef VBOX_WS_MAC
    10681068        case QEvent::ContextMenu:
    10691069        {
    … …  
    10761076            break;
    10771077        }
    1078 #endif /* Q_WS_MAC */
     1078#endif /* VBOX_WS_MAC */
    10791079        default:
    10801080            break;
    … …  
    11061106}
    11071107
    1108 #ifdef Q_WS_MAC
     1108#ifdef VBOX_WS_MAC
    11091109bool UISelectorWindow::eventFilter(QObject *pObject, QEvent *pEvent)
    11101110{
    … …  
    11341134    return QIWithRetranslateUI<QMainWindow>::eventFilter(pObject, pEvent);
    11351135}
    1136 #endif /* Q_WS_MAC */
     1136#endif /* VBOX_WS_MAC */
    11371137
    11381138void UISelectorWindow::prepare()
    11391139{
    1140 #ifdef Q_WS_MAC
     1140#ifdef VBOX_WS_MAC
    11411141    /* We have to make sure that we are getting the front most process: */
    11421142    ::darwinSetFrontMostProcess();
    1143 #endif /* Q_WS_MAC */
     1143#endif /* VBOX_WS_MAC */
    11441144
    11451145    /* Cache medium data early if necessary: */
    … …  
    11601160    retranslateUi();
    11611161
    1162 #ifdef Q_WS_MAC
     1162#ifdef VBOX_WS_MAC
    11631163    /* Enable unified toolbar: */
    11641164    m_pToolBar->enableMacToolbar();
    … …  
    11731173    /* General event filter: */
    11741174    qApp->installEventFilter(this);
    1175 #endif /* Q_WS_MAC */
     1175#endif /* VBOX_WS_MAC */
    11761176}
    11771177
    … …  
    11821182     * On Mac OS X the icon referenced in info.plist is used.
    11831183     * On X11 we will provide as much icons as we can. */
    1184 #if !(defined (Q_WS_WIN) || defined (Q_WS_MAC))
     1184#if !(defined (VBOX_WS_WIN) || defined (VBOX_WS_MAC))
    11851185    QIcon icon(":/VirtualBox.svg");
    11861186    icon.addFile(":/VirtualBox_48px.png");
    11871187    icon.addFile(":/VirtualBox_64px.png");
    11881188    setWindowIcon(icon);
    1189 #endif /* !Q_WS_WIN && !Q_WS_MAC */
     1189#endif /* !VBOX_WS_WIN && !VBOX_WS_MAC */
    11901190}
    11911191
    … …  
    12191219    m_pMachineMenuAction = menuBar()->addMenu(actionPool()->action(UIActionIndexST_M_Machine)->menu());
    12201220
    1221 #ifdef Q_WS_MAC
     1221#ifdef VBOX_WS_MAC
    12221222    /* Prepare 'Window' menu: */
    12231223    UIWindowMenuManager::create();
    12241224    menuBar()->addMenu(gpWindowMenuManager->createMenu(this));
    12251225    gpWindowMenuManager->addWindow(this);
    1226 #endif /* Q_WS_MAC */
     1226#endif /* VBOX_WS_MAC */
    12271227
    12281228    /* Prepare Help-menu: */
    … …  
    12411241    /* The Application / 'File' menu contents is very different depending on host type. */
    12421242
    1243 #ifdef Q_WS_MAC
     1243#ifdef VBOX_WS_MAC
    12441244    /* 'About' action goes to Application menu: */
    12451245    pMenu->addAction(actionPool()->action(UIActionIndex_M_Application_S_About));
    … …  
    12681268    pMenu->addAction(actionPool()->action(UIActionIndexST_M_File_S_ShowMediumManager));
    12691269
    1270 #else /* !Q_WS_MAC */
     1270#else /* !VBOX_WS_MAC */
    12711271
    12721272    /* 'Preferences' action goes to 'File' menu: */
    … …  
    12981298    /* 'Close' action goes to 'File' menu: */
    12991299    pMenu->addAction(actionPool()->action(UIActionIndexST_M_File_S_Close));
    1300 #endif /* !Q_WS_MAC */
     1300#endif /* !VBOX_WS_MAC */
    13011301}
    13021302
    … …  
    14751475    /* Prepare splitter: */
    14761476    m_pSplitter = new QISplitter(this);
    1477 #ifdef Q_WS_X11
     1477#ifdef VBOX_WS_X11
    14781478    m_pSplitter->setHandleType(QISplitter::Native);
    1479 #endif /* Q_WS_X11 */
     1479#endif /* VBOX_WS_X11 */
    14801480
    14811481    /* Prepare tool-bar: */
    … …  
    15111511
    15121512    /* Layout all the widgets: */
    1513 #ifdef Q_WS_MAC
     1513#ifdef VBOX_WS_MAC
    15141514    addToolBar(m_pToolBar);
    15151515    /* Central widget @ horizontal layout: */
    15161516    setCentralWidget(m_pSplitter);
    15171517    m_pSplitter->addWidget(m_pPaneChooser);
    1518 #else /* !Q_WS_MAC */
     1518#else /* !VBOX_WS_MAC */
    15191519    QWidget *pCentralWidget = new QWidget(this);
    15201520    setCentralWidget(pCentralWidget);
    … …  
    15271527    pCentralLayout->addWidget(m_pSplitter);
    15281528    m_pSplitter->addWidget(m_pPaneChooser);
    1529 #endif /* !Q_WS_MAC */
     1529#endif /* !VBOX_WS_MAC */
    15301530    m_pSplitter->addWidget(m_pContainerDetails);
    15311531
    … …  
    16121612
    16131613    /* Tool-bar connections: */
    1614 #ifndef Q_WS_MAC
     1614#ifndef VBOX_WS_MAC
    16151615    connect(m_pToolBar, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(sltShowSelectorWindowContextMenu(const QPoint&)));
    1616 #else /* Q_WS_MAC */
     1616#else /* VBOX_WS_MAC */
    16171617    /* We want to receive right click notifications on the title bar, so register our own handler: */
    16181618    ::darwinRegisterForUnifiedToolbarContextMenuEvents(this);
    1619 #endif /* Q_WS_MAC */
     1619#endif /* VBOX_WS_MAC */
    16201620
    16211621    /* VM desktop connections: */
    … …  
    16391639        /* Load geometry: */
    16401640        m_geometry = gEDataManager->selectorWindowGeometry(this);
    1641 #ifdef Q_WS_MAC
     1641#ifdef VBOX_WS_MAC
    16421642        move(m_geometry.topLeft());
    16431643        resize(m_geometry.size());
    1644 #else /* Q_WS_MAC */
     1644#else /* VBOX_WS_MAC */
    16451645        setGeometry(m_geometry);
    1646 #endif /* !Q_WS_MAC */
     1646#endif /* !VBOX_WS_MAC */
    16471647        LogRel2(("GUI: UISelectorWindow: Geometry loaded to: Origin=%dx%d, Size=%dx%d\n",
    16481648                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    16701670    /* Restore toolbar and statusbar visibility: */
    16711671    {
    1672 #ifdef Q_WS_MAC
     1672#ifdef VBOX_WS_MAC
    16731673        m_pToolBar->setHidden(!gEDataManager->selectorWindowToolBarVisible());
    1674 #else /* Q_WS_MAC */
     1674#else /* VBOX_WS_MAC */
    16751675        m_pBar->setHidden(!gEDataManager->selectorWindowToolBarVisible());
    1676 #endif /* !Q_WS_MAC */
     1676#endif /* !VBOX_WS_MAC */
    16771677        statusBar()->setHidden(!gEDataManager->selectorWindowStatusBarVisible());
    16781678    }
    … …  
    16831683    /* Save toolbar and statusbar visibility: */
    16841684    {
    1685 #ifdef Q_WS_MAC
     1685#ifdef VBOX_WS_MAC
    16861686        gEDataManager->setSelectorWindowToolBarVisible(!m_pToolBar->isHidden());
    1687 #else /* Q_WS_MAC */
     1687#else /* VBOX_WS_MAC */
    16881688        gEDataManager->setSelectorWindowToolBarVisible(!m_pBar->isHidden());
    1689 #endif /* !Q_WS_MAC */
     1689#endif /* !VBOX_WS_MAC */
    16901690        gEDataManager->setSelectorWindowStatusBarVisible(!statusBar()->isHidden());
    16911691    }
    … …  
    16981698    /* Save window geometry: */
    16991699    {
    1700 #ifdef Q_WS_MAC
     1700#ifdef VBOX_WS_MAC
    17011701        gEDataManager->setSelectorWindowGeometry(m_geometry, ::darwinIsWindowMaximized(this));
    1702 #else /* Q_WS_MAC */
     1702#else /* VBOX_WS_MAC */
    17031703        gEDataManager->setSelectorWindowGeometry(m_geometry, isMaximized());
    1704 #endif /* !Q_WS_MAC */
     1704#endif /* !VBOX_WS_MAC */
    17051705        LogRel2(("GUI: UISelectorWindow: Geometry saved as: Origin=%dx%d, Size=%dx%d\n",
    17061706                 m_geometry.x(), m_geometry.y(), m_geometry.width(), m_geometry.height()));
    … …  
    17101710void UISelectorWindow::cleanupConnections()
    17111711{
    1712 #ifdef Q_WS_MAC
     1712#ifdef VBOX_WS_MAC
    17131713    /* Tool-bar connections: */
    17141714    ::darwinUnregisterForUnifiedToolbarContextMenuEvents(this);
    1715 #endif /* Q_WS_MAC */
     1715#endif /* VBOX_WS_MAC */
    17161716}
    17171717
    17181718void UISelectorWindow::cleanupMenuBar()
    17191719{
    1720 #ifdef Q_WS_MAC
     1720#ifdef VBOX_WS_MAC
    17211721    /* Cleanup 'Window' menu: */
    17221722    UIWindowMenuManager::destroy();
    1723 #endif /* Q_WS_MAC */
     1723#endif /* VBOX_WS_MAC */
    17241724
    17251725    /* Destroy action-pool: */
    … …  
    18331833    actionPool()->action(UIActionIndexST_M_Machine_T_Pause)->blockSignals(false);
    18341834
    1835 #ifdef Q_WS_MAC
     1835#ifdef VBOX_WS_MAC
    18361836    /* Avoid bug in Qt Cocoa which results in showing a "more arrow" on size-hint changes: */
    18371837    m_pToolBar->updateLayout();
    1838 #endif /* Q_WS_MAC */
     1838#endif /* VBOX_WS_MAC */
    18391839}
    18401840
    … …  
    20132013    foreach (UIVMItem *pItem, items)
    20142014        if (pItem->accessible()
    2015 #ifdef Q_WS_MAC
     2015#ifdef VBOX_WS_MAC
    20162016            /* On Mac OS X this are real alias files, which don't work with the old legacy xml files. */
    20172017            && pItem->settingsFile().endsWith(".vbox", Qt::CaseInsensitive)
    2018 #endif /* Q_WS_MAC */
     2018#endif /* VBOX_WS_MAC */
    20192019            )
    20202020            return true;

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

    r57897 r60362  
    179179        /** Handles first Qt show @a pEvent. */
    180180        virtual void polishEvent(QShowEvent *pEvent);
    181 #ifdef Q_WS_MAC
     181#ifdef VBOX_WS_MAC
    182182        /** Mac OS X: Preprocesses any Qt @a pEvent for passed @a pObject. */
    183183        virtual bool eventFilter(QObject *pObject, QEvent *pEvent);
    184 #endif /* Q_WS_MAC */
     184#endif /* VBOX_WS_MAC */
    185185    /** @} */
    186186
    … …  
    271271    QISplitter *m_pSplitter;
    272272
    273 #ifndef Q_WS_MAC
     273#ifndef VBOX_WS_MAC
    274274    /** Holds the main bar instance. */
    275275    UIMainBar *m_pBar;
    276 #endif /* !Q_WS_MAC */
     276#endif /* !VBOX_WS_MAC */
    277277    /** Holds the main toolbar instance. */
    278278    UIToolBar *m_pToolBar;

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

    r54055 r60362  
    2424# include <QStackedWidget>
    2525# include <QToolButton>
    26 # ifdef Q_WS_MAC
     26# ifdef VBOX_WS_MAC
    2727#  include <QTimer>
    28 # endif /* Q_WS_MAC */
     28# endif /* VBOX_WS_MAC */
    2929
    3030/* GUI includes */
    … …  
    4747
    4848
    49 //#ifdef Q_WS_MAC
     49//#ifdef VBOX_WS_MAC
    5050# define USE_TOOLBAR
    51 //#endif /* Q_WS_MAC */
    52 
    53 #ifdef Q_WS_MAC
     51//#endif /* VBOX_WS_MAC */
     52
     53#ifdef VBOX_WS_MAC
    5454static const int gsLeftMargin = 5;
    5555static const int gsTopMargin = 5;
    5656static const int gsRightMargin = 5;
    5757static const int gsBottomMargin = 5;
    58 #else /* Q_WS_MAC */
     58#else /* VBOX_WS_MAC */
    5959static const int gsLeftMargin = 0;
    6060static const int gsTopMargin = 5;
    6161static const int gsRightMargin = 5;
    6262static const int gsBottomMargin = 5;
    63 #endif /* !Q_WS_MAC */
     63#endif /* !VBOX_WS_MAC */
    6464
    6565/* Container to store VM desktop panes. */
    … …  
    255255    }
    256256
    257 #ifdef Q_WS_MAC
     257#ifdef VBOX_WS_MAC
    258258    /* Cocoa stuff should be async...
    259259     * Do not ask me why but otherwise
    260260     * it conflicts with native handlers. */
    261261    QTimer::singleShot(0, this, SLOT(sltInit()));
    262 #else /* !Q_WS_MAC */
     262#else /* !VBOX_WS_MAC */
    263263    sltInit();
    264 #endif /* !Q_WS_MAC */
     264#endif /* !VBOX_WS_MAC */
    265265
    266266    /* Prepare main layout: */
    … …  
    282282            pSpace->setFixedSize(10, 1);
    283283        pToolBar->addWidget(pSpace);
    284 #ifdef Q_WS_MAC
     284#ifdef VBOX_WS_MAC
    285285        pToolBar->updateLayout();
    286 #endif /* Q_WS_MAC */
     286#endif /* VBOX_WS_MAC */
    287287    }
    288288    else

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

    r59031 r60362  
    2929# include "UIConverter.h"
    3030# include "UIExtraDataManager.h"
    31 # ifdef Q_WS_MAC
     31# ifdef VBOX_WS_MAC
    3232#  include <ApplicationServices/ApplicationServices.h>
    33 # endif /* Q_WS_MAC */
     33# endif /* VBOX_WS_MAC */
    3434
    3535/* COM includes: */
    … …  
    4545#if 0
    4646
    47 #if defined (Q_WS_WIN)
     47#if defined (VBOX_WS_WIN)
    4848
    4949struct EnumWindowsProcData
    … …  
    112112static WId FindWindowIdFromPid(ULONG aPid)
    113113{
    114 #if defined (Q_WS_WIN)
     114#if defined (VBOX_WS_WIN)
    115115
    116116    EnumWindowsProcData d = { aPid, (WId) ~0 };
    … …  
    119119    return d.wid;
    120120
    121 #elif defined (Q_WS_X11)
     121#elif defined (VBOX_WS_X11)
    122122
    123123    NOREF(aPid);
    124124    return (WId) ~0;
    125125
    126 #elif defined (Q_WS_MAC)
     126#elif defined (VBOX_WS_MAC)
    127127
    128128    /** @todo Figure out how to get access to another windows of another process...
    … …  
    321321bool UIVMItem::switchTo()
    322322{
    323 #ifdef Q_WS_MAC
     323#ifdef VBOX_WS_MAC
    324324    ULONG64 id = m_machine.ShowConsoleWindow();
    325325#else
    … …  
    335335        return true;
    336336
    337 #if defined (Q_WS_WIN) || defined (Q_WS_X11)
     337#if defined (VBOX_WS_WIN) || defined (VBOX_WS_X11)
    338338
    339339    return vboxGlobal().activateWindow(id, true);
    340340
    341 #elif defined (Q_WS_MAC)
     341#elif defined (VBOX_WS_MAC)
    342342    /*
    343343     * This is just for the case were the other process cannot steal
    … …  
    366366        return false;
    367367
    368 #if defined (Q_WS_WIN)
     368#if defined (VBOX_WS_WIN)
    369369
    370370    HWND hwnd = mWinId;
    … …  
    402402    return true;
    403403
    404 #elif defined (Q_WS_X11)
     404#elif defined (VBOX_WS_X11)
    405405
    406406    return false;
    407407
    408 #elif defined (Q_WS_MAC)
     408#elif defined (VBOX_WS_MAC)
    409409
    410410    ProcessSerialNumber psn;

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserHandlerKeyboard.cpp

    r52730 r60362  
    7474
    7575            /* Was control modifier pressed? */
    76 #ifdef Q_WS_MAC
     76#ifdef VBOX_WS_MAC
    7777            if (pEvent->modifiers() & Qt::ControlModifier &&
    7878                pEvent->modifiers() & Qt::KeypadModifier)
    79 #else /* Q_WS_MAC */
     79#else /* VBOX_WS_MAC */
    8080            if (pEvent->modifiers() == Qt::ControlModifier)
    81 #endif /* !Q_WS_MAC */
     81#endif /* !VBOX_WS_MAC */
    8282            {
    8383                /* Shift item up: */
    … …  
    8787
    8888            /* Was shift modifier pressed? */
    89 #ifdef Q_WS_MAC
     89#ifdef VBOX_WS_MAC
    9090            else if (pEvent->modifiers() & Qt::ShiftModifier &&
    9191                     pEvent->modifiers() & Qt::KeypadModifier)
    92 #else /* Q_WS_MAC */
     92#else /* VBOX_WS_MAC */
    9393            else if (pEvent->modifiers() == Qt::ShiftModifier)
    94 #endif /* !Q_WS_MAC */
     94#endif /* !VBOX_WS_MAC */
    9595            {
    9696                /* Determine focus item position: */
    … …  
    131131
    132132            /* There is no modifiers pressed? */
    133 #ifdef Q_WS_MAC
     133#ifdef VBOX_WS_MAC
    134134            else if (pEvent->modifiers() == Qt::KeypadModifier)
    135 #else /* Q_WS_MAC */
     135#else /* VBOX_WS_MAC */
    136136            else if (pEvent->modifiers() == Qt::NoModifier)
    137 #endif /* !Q_WS_MAC */
     137#endif /* !VBOX_WS_MAC */
    138138            {
    139139                /* Determine focus item position: */
    … …  
    171171
    172172            /* Was control modifier pressed? */
    173 #ifdef Q_WS_MAC
     173#ifdef VBOX_WS_MAC
    174174            if (pEvent->modifiers() & Qt::ControlModifier &&
    175175                pEvent->modifiers() & Qt::KeypadModifier)
    176 #else /* Q_WS_MAC */
     176#else /* VBOX_WS_MAC */
    177177            if (pEvent->modifiers() == Qt::ControlModifier)
    178 #endif /* !Q_WS_MAC */
     178#endif /* !VBOX_WS_MAC */
    179179            {
    180180                /* Shift item down: */
    … …  
    184184
    185185            /* Was shift modifier pressed? */
    186 #ifdef Q_WS_MAC
     186#ifdef VBOX_WS_MAC
    187187            else if (pEvent->modifiers() & Qt::ShiftModifier &&
    188188                     pEvent->modifiers() & Qt::KeypadModifier)
    189 #else /* Q_WS_MAC */
     189#else /* VBOX_WS_MAC */
    190190            else if (pEvent->modifiers() == Qt::ShiftModifier)
    191 #endif /* !Q_WS_MAC */
     191#endif /* !VBOX_WS_MAC */
    192192            {
    193193                /* Determine focus item position: */
    … …  
    228228
    229229            /* There is no modifiers pressed? */
    230 #ifdef Q_WS_MAC
     230#ifdef VBOX_WS_MAC
    231231            else if (pEvent->modifiers() == Qt::KeypadModifier)
    232 #else /* Q_WS_MAC */
     232#else /* VBOX_WS_MAC */
    233233            else if (pEvent->modifiers() == Qt::NoModifier)
    234 #endif /* !Q_WS_MAC */
     234#endif /* !VBOX_WS_MAC */
    235235            {
    236236                /* Determine focus item position: */

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserItemMachine.cpp

    r56012 r60362  
    11051105
    11061106    /* Colors: */
    1107 #ifdef Q_WS_MAC
     1107#ifdef VBOX_WS_MAC
    11081108    m_iHighlightLightness = 115;
    11091109    m_iHoverLightness = 110;
    11101110    m_iHoverHighlightLightness = 120;
    1111 #else /* Q_WS_MAC */
     1111#else /* VBOX_WS_MAC */
    11121112    m_iHighlightLightness = 130;
    11131113    m_iHoverLightness = 155;
    11141114    m_iHoverHighlightLightness = 175;
    1115 #endif /* !Q_WS_MAC */
     1115#endif /* !VBOX_WS_MAC */
    11161116
    11171117    /* Fonts: */

  • trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsElements.cpp

    r58866 r60362  
    404404        }
    405405
    406 #ifdef Q_WS_MAC
     406#ifdef VBOX_WS_MAC
    407407        /* Get 'Unscaled HiDPI Video Output' mode value: */
    408408        const QString strUnscaledHiDPIMode = machine.GetExtraData(UIExtraDataDefs::GUI_HiDPI_UnscaledOutput);
    … …  
    418418                                         QApplication::translate("UIGDetails", "Enabled", "details (display/Unscaled HiDPI Video Output)"));
    419419        }
    420 #endif /* Q_WS_MAC */
     420#endif /* VBOX_WS_MAC */
    421421
    422422        QStringList acceleration;
    … …  
    855855    if (machine.GetAccessible())
    856856    {
    857 #ifndef Q_WS_MAC
     857#ifndef VBOX_WS_MAC
    858858        /* Get menu-bar availability status: */
    859859        const QString strMenubarEnabled = machine.GetExtraData(UIExtraDataDefs::GUI_MenuBar_Enabled);
    … …  
    869869                                                QApplication::translate("UIGDetails", "Disabled", "details (user interface/menu-bar)"));
    870870        }
    871 #endif /* !Q_WS_MAC */
     871#endif /* !VBOX_WS_MAC */
    872872
    873873        /* Get status-bar availability status: */
    … …  
    885885        }
    886886
    887 #ifndef Q_WS_MAC
     887#ifndef VBOX_WS_MAC
    888888        /* Get mini-toolbar availability status: */
    889889        const QString strMiniToolbarEnabled = machine.GetExtraData(UIExtraDataDefs::GUI_ShowMiniToolBar);
    … …  
    921921                                         QApplication::translate("UIGDetails", "Disabled", "details (user interface/mini-toolbar)"));
    922922        }
    923 #endif /* !Q_WS_MAC */
     923#endif /* !VBOX_WS_MAC */
    924924    }
    925925    else

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDialog.cpp

    r59727 r60362  
    4141# include "UIIconPool.h"
    4242# include "UIConverter.h"
    43 # ifdef Q_WS_MAC
     43# ifdef VBOX_WS_MAC
    4444#  include "VBoxUtils.h"
    45 # endif /* Q_WS_MAC */
     45# endif /* VBOX_WS_MAC */
    4646
    4747#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    4848
    49 #ifdef Q_WS_MAC
     49#ifdef VBOX_WS_MAC
    5050# define VBOX_GUI_WITH_TOOLBAR_SETTINGS
    51 #endif /* Q_WS_MAC */
     51#endif /* VBOX_WS_MAC */
    5252
    5353/* Settings Dialog Constructor: */
    … …  
    184184{
    185185    int index = m_pages[cId];
    186 #ifdef Q_WS_MAC
     186#ifdef VBOX_WS_MAC
    187187# if QT_VERSION < 0x050000
    188188    QSize cs = size();
    … …  
    619619
    620620    int iMinWidth = m_pSelector->minWidth();
    621 #ifdef Q_WS_MAC
     621#ifdef VBOX_WS_MAC
    622622    /* Remove all title bar buttons (Buggy Qt): */
    623623    ::darwinSetHidesAllTitleButtons(this);
    … …  
    689689
    690690    sltCategoryChanged(m_pSelector->currentId());
    691 #else /* Q_WS_MAC */
     691#else /* VBOX_WS_MAC */
    692692    /* Resize to the minimum possible size: */
    693693    QSize s = minimumSize();
    … …  
    695695        s.setWidth(iMinWidth);
    696696    resize(s);
    697 #endif /* Q_WS_MAC */
     697#endif /* VBOX_WS_MAC */
    698698}
    699699

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDialog.h

    r55742 r60362  
    165165
    166166    QMap<int, int> m_pages;
    167 #ifdef Q_WS_MAC
     167#ifdef VBOX_WS_MAC
    168168    QList<QSize> m_sizeList;
    169 #endif /* Q_WS_MAC */
     169#endif /* VBOX_WS_MAC */
    170170};
    171171

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsDialogSpecific.cpp

    r59094 r60362  
    6161#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    6262
    63 #ifdef Q_WS_MAC
     63#ifdef VBOX_WS_MAC
    6464# define VBOX_GUI_WITH_TOOLBAR_SETTINGS
    65 #endif /* Q_WS_MAC */
     65#endif /* VBOX_WS_MAC */
    6666
    6767UISettingsDialogGlobal::UISettingsDialogGlobal(QWidget *pParent,
    … …  
    7171{
    7272    /* Window icon: */
    73 #ifndef Q_WS_MAC
     73#ifndef VBOX_WS_MAC
    7474    setWindowIcon(QIcon(":/global_settings_16px.png"));
    75 #endif /* !Q_WS_MAC */
     75#endif /* !VBOX_WS_MAC */
    7676
    7777    /* Creating settings pages: */
    … …  
    323323{
    324324    /* Window icon: */
    325 #ifndef Q_WS_MAC
     325#ifndef VBOX_WS_MAC
    326326    setWindowIcon(QIcon(":/vm_settings_16px.png"));
    327 #endif /* Q_WS_MAC */
     327#endif /* VBOX_WS_MAC */
    328328
    329329    /* Allow to reset first-run flag just when medium enumeration was finished: */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/VBoxSettingsSelector.cpp

    r56217 r60362  
    393393    mTbSelector->setUseTextLabels (true);
    394394    mTbSelector->setIconSize (QSize (32, 32));
    395 #ifdef Q_WS_MAC
     395#ifdef VBOX_WS_MAC
    396396    mTbSelector->setShowToolBarButton (false);
    397 #endif /* Q_WS_MAC */
     397#endif /* VBOX_WS_MAC */
    398398    /* Init the action group for house keeping */
    399399    mActionGroup = new QActionGroup (this);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsExtension.cpp

    r58856 r60362  
    202202     */
    203203    QString displayInfo;
    204 #ifdef Q_WS_WIN
     204#ifdef VBOX_WS_WIN
    205205    if (pParent)
    206206        displayInfo.sprintf("hwnd=%#llx", (uint64_t)(uintptr_t)pParent->winId());
    207 #endif /* Q_WS_WIN */
     207#endif /* VBOX_WS_WIN */
    208208    /* Prepare installation progress: */
    209209    CProgress progress = extPackFile.Install(fReplaceIt, displayInfo);
    … …  
    420420            /** @todo Refuse this if any VMs are running. */
    421421            QString displayInfo;
    422 #ifdef Q_WS_WIN
     422#ifdef VBOX_WS_WIN
    423423            displayInfo.sprintf("hwnd=%#llx", (uint64_t)(uintptr_t)this->winId());
    424 #endif /* Q_WS_WIN */
     424#endif /* VBOX_WS_WIN */
    425425            /* Prepare uninstallation progress: */
    426426            CProgress progress = manager.Uninstall(strSelectedPackageName, false /* forced removal? */, displayInfo);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsInput.cpp

    r59076 r60362  
    6767            m_pSelectorModel, SLOT(sltHandleFilterTextChange(const QString &)));
    6868    QVBoxLayout *pSelectorLayout = new QVBoxLayout(pSelectorTab);
    69 #ifndef Q_WS_WIN
     69#ifndef VBOX_WS_WIN
    7070    /* On Windows host that looks ugly, but
    7171     * On Mac OS X and X11 that deserves it's place. */
    7272    pSelectorLayout->setContentsMargins(0, 0, 0, 0);
    73 #endif /* !Q_WS_WIN */
     73#endif /* !VBOX_WS_WIN */
    7474    pSelectorLayout->setSpacing(1);
    7575    pSelectorLayout->addWidget(m_pSelectorFilterEditor);
    … …  
    8787            m_pMachineModel, SLOT(sltHandleFilterTextChange(const QString &)));
    8888    QVBoxLayout *pMachineLayout = new QVBoxLayout(pMachineTab);
    89 #ifndef Q_WS_WIN
     89#ifndef VBOX_WS_WIN
    9090    /* On Windows host that looks ugly, but
    9191     * On Mac OS X and X11 that deserves it's place. */
    9292    pMachineLayout->setContentsMargins(0, 0, 0, 0);
    93 #endif /* !Q_WS_WIN */
     93#endif /* !VBOX_WS_WIN */
    9494    pMachineLayout->setSpacing(1);
    9595    pMachineLayout->addWidget(m_pMachineFilterEditor);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetwork.cpp

    r58866 r60362  
    489489    }
    490490
    491 #ifndef Q_WS_WIN
     491#ifndef VBOX_WS_WIN
    492492    /* On Windows host that looks ugly, but
    493493     * On Mac OS X and X11 that deserves it's place. */
    494494    m_pLayoutNAT->setContentsMargins(0, 0, 0, 0);
    495495    m_pLayoutHostOnly->setContentsMargins(0, 0, 0, 0);
    496 #endif /* !Q_WS_WIN */
     496#endif /* !VBOX_WS_WIN */
    497497
    498498    /* Apply language settings: */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/global/UIGlobalSettingsNetworkDetailsHost.cpp

    r58455 r60362  
    4343    m_pIPv6Editor->setFixedWidthByText(QString().fill('X', 32) + QString().fill(':', 7));
    4444
    45 #if 0 /* defined (Q_WS_WIN) */
     45#if 0 /* defined (VBOX_WS_WIN) */
    4646    QStyleOption options1;
    4747    options1.initFrom(m_pEnableManualCheckbox);
    … …  
    9898    /* Host Interface: */
    9999    m_pEnableManualCheckbox->setChecked(!m_data.m_interface.m_fDhcpClientEnabled);
    100 #if !0 /* !defined (Q_WS_WIN) */
     100#if !0 /* !defined (VBOX_WS_WIN) */
    101101    /* Disable automatic for all hosts for now: */
    102102    m_pEnableManualCheckbox->setChecked(true);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.cpp

    r57591 r60362  
    101101    displayData.m_cGuestScreenCount = m_machine.GetMonitorCount();
    102102    displayData.m_dScaleFactor = gEDataManager->scaleFactor(m_machine.GetId());
    103 #ifdef Q_WS_MAC
     103#ifdef VBOX_WS_MAC
    104104    displayData.m_fUseUnscaledHiDPIOutput = gEDataManager->useUnscaledHiDPIOutput(m_machine.GetId());
    105 #endif /* Q_WS_MAC */
     105#endif /* VBOX_WS_MAC */
    106106    displayData.m_f3dAccelerationEnabled = m_machine.GetAccelerate3DEnabled();
    107107#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    152152    m_pEditorVideoScreenCount->setValue(displayData.m_cGuestScreenCount);
    153153    m_pEditorGuestScreenScale->setValue((int)(displayData.m_dScaleFactor * 100));
    154 #ifdef Q_WS_MAC
     154#ifdef VBOX_WS_MAC
    155155    m_pCheckBoxUnscaledHiDPIOutput->setChecked(displayData.m_fUseUnscaledHiDPIOutput);
    156 #endif /* Q_WS_MAC */
     156#endif /* VBOX_WS_MAC */
    157157    m_pCheckbox3D->setChecked(displayData.m_f3dAccelerationEnabled);
    158158#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    201201    displayData.m_cGuestScreenCount = m_pEditorVideoScreenCount->value();
    202202    displayData.m_dScaleFactor = (double)m_pEditorGuestScreenScale->value() / 100;
    203 #ifdef Q_WS_MAC
     203#ifdef VBOX_WS_MAC
    204204    displayData.m_fUseUnscaledHiDPIOutput = m_pCheckBoxUnscaledHiDPIOutput->isChecked();
    205 #endif /* Q_WS_MAC */
     205#endif /* VBOX_WS_MAC */
    206206    displayData.m_f3dAccelerationEnabled = m_pCheckbox3D->isChecked();
    207207#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    259259        {
    260260            gEDataManager->setScaleFactor(displayData.m_dScaleFactor, m_machine.GetId());
    261 #ifdef Q_WS_MAC
     261#ifdef VBOX_WS_MAC
    262262            gEDataManager->setUseUnscaledHiDPIOutput(displayData.m_fUseUnscaledHiDPIOutput, m_machine.GetId());
    263 #endif /* Q_WS_MAC */
     263#endif /* VBOX_WS_MAC */
    264264        }
    265265
    … …  
    537537    m_pLabelGuestScreenScaleMax->setEnabled(isMachineInValidMode());
    538538    m_pEditorGuestScreenScale->setEnabled(isMachineInValidMode());
    539 #ifdef Q_WS_MAC
     539#ifdef VBOX_WS_MAC
    540540    m_pLabelHiDPI->setEnabled(isMachineInValidMode());
    541541    m_pCheckBoxUnscaledHiDPIOutput->setEnabled(isMachineInValidMode());
    542 #else /* !Q_WS_MAC */
     542#else /* !VBOX_WS_MAC */
    543543    m_pLabelHiDPI->hide();
    544544    m_pCheckBoxUnscaledHiDPIOutput->hide();
    545 #endif /* !Q_WS_MAC */
     545#endif /* !VBOX_WS_MAC */
    546546    m_pLabelVideoOptions->setEnabled(isMachineOffline());
    547547    m_pCheckbox3D->setEnabled(isMachineOffline());

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsDisplay.h

    r55719 r60362  
    3737        , m_cGuestScreenCount(0)
    3838        , m_dScaleFactor(1.0)
    39 #ifdef Q_WS_MAC
     39#ifdef VBOX_WS_MAC
    4040        , m_fUseUnscaledHiDPIOutput(false)
    41 #endif /* Q_WS_MAC */
     41#endif /* VBOX_WS_MAC */
    4242        , m_f3dAccelerationEnabled(false)
    4343#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    6565               (m_cGuestScreenCount == other.m_cGuestScreenCount) &&
    6666               (m_dScaleFactor == other.m_dScaleFactor) &&
    67 #ifdef Q_WS_MAC
     67#ifdef VBOX_WS_MAC
    6868               (m_fUseUnscaledHiDPIOutput == other.m_fUseUnscaledHiDPIOutput) &&
    69 #endif /* Q_WS_MAC */
     69#endif /* VBOX_WS_MAC */
    7070               (m_f3dAccelerationEnabled == other.m_f3dAccelerationEnabled) &&
    7171#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    9595    int m_cGuestScreenCount;
    9696    double m_dScaleFactor;
    97 #ifdef Q_WS_MAC
     97#ifdef VBOX_WS_MAC
    9898    bool m_fUseUnscaledHiDPIOutput;
    99 #endif /* Q_WS_MAC */
     99#endif /* VBOX_WS_MAC */
    100100    bool m_f3dAccelerationEnabled;
    101101#ifdef VBOX_WITH_VIDEOHWACCEL

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

    r60125 r60362  
    553553    {
    554554        /* Configure Description text editor: */
    555 #ifdef Q_WS_MAC
     555#ifdef VBOX_WS_MAC
    556556        mTeDescription->setMinimumHeight(150);
    557 #endif /* Q_WS_MAC */
     557#endif /* VBOX_WS_MAC */
    558558    }
    559559}

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsInterface.cpp

    r56757 r60362  
    5858    interfaceData.m_statusBarRestrictions = gEDataManager->restrictedStatusBarIndicators(m_machine.GetId());
    5959    interfaceData.m_statusBarOrder = gEDataManager->statusBarIndicatorOrder(m_machine.GetId());
    60 #ifndef Q_WS_MAC
     60#ifndef VBOX_WS_MAC
    6161    interfaceData.m_fMenuBarEnabled = gEDataManager->menuBarEnabled(m_machine.GetId());
    62 #endif /* !Q_WS_MAC */
     62#endif /* !VBOX_WS_MAC */
    6363    interfaceData.m_restrictionsOfMenuBar = gEDataManager->restrictedRuntimeMenuTypes(m_machine.GetId());
    6464    interfaceData.m_restrictionsOfMenuApplication = gEDataManager->restrictedRuntimeMenuApplicationActionTypes(m_machine.GetId());
    … …  
    7070    interfaceData.m_restrictionsOfMenuDebug = gEDataManager->restrictedRuntimeMenuDebuggerActionTypes(m_machine.GetId());
    7171#endif /* VBOX_WITH_DEBUGGER_GUI */
    72 #ifdef Q_WS_MAC
     72#ifdef VBOX_WS_MAC
    7373    interfaceData.m_restrictionsOfMenuWindow = gEDataManager->restrictedRuntimeMenuWindowActionTypes(m_machine.GetId());
    74 #endif /* Q_WS_MAC */
     74#endif /* VBOX_WS_MAC */
    7575    interfaceData.m_restrictionsOfMenuHelp = gEDataManager->restrictedRuntimeMenuHelpActionTypes(m_machine.GetId());
    76 #ifndef Q_WS_MAC
     76#ifndef VBOX_WS_MAC
    7777    interfaceData.m_fShowMiniToolBar = gEDataManager->miniToolbarEnabled(m_machine.GetId());
    7878    interfaceData.m_fMiniToolBarAtTop = gEDataManager->miniToolbarAlignment(m_machine.GetId()) == Qt::AlignTop;
    79 #endif /* !Q_WS_MAC */
     79#endif /* !VBOX_WS_MAC */
    8080
    8181    /* Cache interface data: */
    … …  
    9797    m_pStatusBarEditor->setStatusBarConfiguration(interfaceData.m_statusBarRestrictions,
    9898                                                  interfaceData.m_statusBarOrder);
    99 #ifndef Q_WS_MAC
     99#ifndef VBOX_WS_MAC
    100100    m_pMenuBarEditor->setMenuBarEnabled(interfaceData.m_fMenuBarEnabled);
    101 #endif /* !Q_WS_MAC */
     101#endif /* !VBOX_WS_MAC */
    102102    m_pMenuBarEditor->setRestrictionsOfMenuBar(interfaceData.m_restrictionsOfMenuBar);
    103103    m_pMenuBarEditor->setRestrictionsOfMenuApplication(interfaceData.m_restrictionsOfMenuApplication);
    … …  
    109109    m_pMenuBarEditor->setRestrictionsOfMenuDebug(interfaceData.m_restrictionsOfMenuDebug);
    110110#endif /* VBOX_WITH_DEBUGGER_GUI */
    111 #ifdef Q_WS_MAC
     111#ifdef VBOX_WS_MAC
    112112    m_pMenuBarEditor->setRestrictionsOfMenuWindow(interfaceData.m_restrictionsOfMenuWindow);
    113 #endif /* Q_WS_MAC */
     113#endif /* VBOX_WS_MAC */
    114114    m_pMenuBarEditor->setRestrictionsOfMenuHelp(interfaceData.m_restrictionsOfMenuHelp);
    115 #ifndef Q_WS_MAC
     115#ifndef VBOX_WS_MAC
    116116    m_pCheckBoxShowMiniToolBar->setChecked(interfaceData.m_fShowMiniToolBar);
    117117    m_pComboToolBarAlignment->setChecked(interfaceData.m_fMiniToolBarAtTop);
    118 #endif /* !Q_WS_MAC */
     118#endif /* !VBOX_WS_MAC */
    119119
    120120    /* Polish page finally: */
    … …  
    136136    interfaceData.m_statusBarRestrictions = m_pStatusBarEditor->statusBarIndicatorRestrictions();
    137137    interfaceData.m_statusBarOrder = m_pStatusBarEditor->statusBarIndicatorOrder();
    138 #ifndef Q_WS_MAC
     138#ifndef VBOX_WS_MAC
    139139    interfaceData.m_fMenuBarEnabled = m_pMenuBarEditor->isMenuBarEnabled();
    140 #endif /* !Q_WS_MAC */
     140#endif /* !VBOX_WS_MAC */
    141141    interfaceData.m_restrictionsOfMenuBar = m_pMenuBarEditor->restrictionsOfMenuBar();
    142142    interfaceData.m_restrictionsOfMenuApplication = m_pMenuBarEditor->restrictionsOfMenuApplication();
    … …  
    148148    interfaceData.m_restrictionsOfMenuDebug = m_pMenuBarEditor->restrictionsOfMenuDebug();
    149149#endif /* VBOX_WITH_DEBUGGER_GUI */
    150 #ifdef Q_WS_MAC
     150#ifdef VBOX_WS_MAC
    151151    interfaceData.m_restrictionsOfMenuWindow = m_pMenuBarEditor->restrictionsOfMenuWindow();
    152 #endif /* Q_WS_MAC */
     152#endif /* VBOX_WS_MAC */
    153153    interfaceData.m_restrictionsOfMenuHelp = m_pMenuBarEditor->restrictionsOfMenuHelp();
    154 #ifndef Q_WS_MAC
     154#ifndef VBOX_WS_MAC
    155155    interfaceData.m_fShowMiniToolBar = m_pCheckBoxShowMiniToolBar->isChecked();
    156156    interfaceData.m_fMiniToolBarAtTop = m_pComboToolBarAlignment->isChecked();
    157 #endif /* !Q_WS_MAC */
     157#endif /* !VBOX_WS_MAC */
    158158
    159159    /* Cache interface data: */
    … …  
    180180            gEDataManager->setRestrictedStatusBarIndicators(interfaceData.m_statusBarRestrictions, m_machine.GetId());
    181181            gEDataManager->setStatusBarIndicatorOrder(interfaceData.m_statusBarOrder, m_machine.GetId());
    182 #ifndef Q_WS_MAC
     182#ifndef VBOX_WS_MAC
    183183            gEDataManager->setMenuBarEnabled(interfaceData.m_fMenuBarEnabled, m_machine.GetId());
    184 #endif /* !Q_WS_MAC */
     184#endif /* !VBOX_WS_MAC */
    185185            gEDataManager->setRestrictedRuntimeMenuTypes(interfaceData.m_restrictionsOfMenuBar, m_machine.GetId());
    186186            gEDataManager->setRestrictedRuntimeMenuApplicationActionTypes(interfaceData.m_restrictionsOfMenuApplication, m_machine.GetId());
    … …  
    192192            gEDataManager->setRestrictedRuntimeMenuDebuggerActionTypes(interfaceData.m_restrictionsOfMenuDebug, m_machine.GetId());
    193193#endif /* VBOX_WITH_DEBUGGER_GUI */
    194 #ifdef Q_WS_MAC
     194#ifdef VBOX_WS_MAC
    195195            gEDataManager->setRestrictedRuntimeMenuWindowActionTypes(interfaceData.m_restrictionsOfMenuWindow, m_machine.GetId());
    196 #endif /* Q_WS_MAC */
     196#endif /* VBOX_WS_MAC */
    197197            gEDataManager->setRestrictedRuntimeMenuHelpActionTypes(interfaceData.m_restrictionsOfMenuHelp, m_machine.GetId());
    198 #ifndef Q_WS_MAC
     198#ifndef VBOX_WS_MAC
    199199            gEDataManager->setMiniToolbarEnabled(interfaceData.m_fShowMiniToolBar, m_machine.GetId());
    200200            gEDataManager->setMiniToolbarAlignment(interfaceData.m_fMiniToolBarAtTop ? Qt::AlignTop : Qt::AlignBottom, m_machine.GetId());
    201 #endif /* !Q_WS_MAC */
     201#endif /* !VBOX_WS_MAC */
    202202        }
    203203    }
    … …  
    224224    /* Polish interface availability: */
    225225    m_pMenuBarEditor->setEnabled(isMachineInValidMode());
    226 #ifdef Q_WS_MAC
     226#ifdef VBOX_WS_MAC
    227227    m_pLabelMiniToolBar->hide();
    228228    m_pCheckBoxShowMiniToolBar->hide();
    229229    m_pComboToolBarAlignment->hide();
    230 #else /* !Q_WS_MAC */
     230#else /* !VBOX_WS_MAC */
    231231    m_pLabelMiniToolBar->setEnabled(isMachineInValidMode());
    232232    m_pCheckBoxShowMiniToolBar->setEnabled(isMachineInValidMode());
    233233    m_pComboToolBarAlignment->setEnabled(isMachineInValidMode() && m_pCheckBoxShowMiniToolBar->isChecked());
    234 #endif /* !Q_WS_MAC */
     234#endif /* !VBOX_WS_MAC */
    235235    m_pStatusBarEditor->setEnabled(isMachineInValidMode());
    236236}

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsInterface.h

    r56757 r60362  
    3232    UIDataSettingsMachineInterface()
    3333        : m_fStatusBarEnabled(false)
    34 #ifndef Q_WS_MAC
     34#ifndef VBOX_WS_MAC
    3535        , m_fMenuBarEnabled(false)
    36 #endif /* !Q_WS_MAC */
     36#endif /* !VBOX_WS_MAC */
    3737        , m_restrictionsOfMenuBar(UIExtraDataMetaDefs::MenuType_Invalid)
    3838        , m_restrictionsOfMenuApplication(UIExtraDataMetaDefs::MenuApplicationActionType_Invalid)
    … …  
    4444        , m_restrictionsOfMenuDebug(UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType_Invalid)
    4545#endif /* VBOX_WITH_DEBUGGER_GUI */
    46 #ifdef Q_WS_MAC
     46#ifdef VBOX_WS_MAC
    4747        , m_restrictionsOfMenuWindow(UIExtraDataMetaDefs::MenuWindowActionType_Invalid)
    48 #endif /* Q_WS_MAC */
     48#endif /* VBOX_WS_MAC */
    4949        , m_restrictionsOfMenuHelp(UIExtraDataMetaDefs::MenuHelpActionType_Invalid)
    50 #ifndef Q_WS_MAC
     50#ifndef VBOX_WS_MAC
    5151        , m_fShowMiniToolBar(false)
    5252        , m_fMiniToolBarAtTop(false)
    53 #endif /* !Q_WS_MAC */
     53#endif /* !VBOX_WS_MAC */
    5454    {}
    5555
    … …  
    6060               && (m_statusBarRestrictions == other.m_statusBarRestrictions)
    6161               && (m_statusBarOrder == other.m_statusBarOrder)
    62 #ifndef Q_WS_MAC
     62#ifndef VBOX_WS_MAC
    6363               && (m_fMenuBarEnabled == other.m_fMenuBarEnabled)
    64 #endif /* !Q_WS_MAC */
     64#endif /* !VBOX_WS_MAC */
    6565               && (m_restrictionsOfMenuBar == other.m_restrictionsOfMenuBar)
    6666               && (m_restrictionsOfMenuApplication == other.m_restrictionsOfMenuApplication)
    … …  
    7272               && (m_restrictionsOfMenuDebug == other.m_restrictionsOfMenuDebug)
    7373#endif /* VBOX_WITH_DEBUGGER_GUI */
    74 #ifdef Q_WS_MAC
     74#ifdef VBOX_WS_MAC
    7575               && (m_restrictionsOfMenuWindow == other.m_restrictionsOfMenuWindow)
    76 #endif /* Q_WS_MAC */
     76#endif /* VBOX_WS_MAC */
    7777               && (m_restrictionsOfMenuHelp == other.m_restrictionsOfMenuHelp)
    78 #ifndef Q_WS_MAC
     78#ifndef VBOX_WS_MAC
    7979               && (m_fShowMiniToolBar == other.m_fShowMiniToolBar)
    8080               && (m_fMiniToolBarAtTop == other.m_fMiniToolBarAtTop)
    81 #endif /* !Q_WS_MAC */
     81#endif /* !VBOX_WS_MAC */
    8282               ;
    8383    }
    … …  
    9191    QList<IndicatorType> m_statusBarRestrictions;
    9292    QList<IndicatorType> m_statusBarOrder;
    93 #ifndef Q_WS_MAC
     93#ifndef VBOX_WS_MAC
    9494    bool m_fMenuBarEnabled;
    95 #endif /* !Q_WS_MAC */
     95#endif /* !VBOX_WS_MAC */
    9696    UIExtraDataMetaDefs::MenuType m_restrictionsOfMenuBar;
    9797    UIExtraDataMetaDefs::MenuApplicationActionType m_restrictionsOfMenuApplication;
    … …  
    103103    UIExtraDataMetaDefs::RuntimeMenuDebuggerActionType m_restrictionsOfMenuDebug;
    104104#endif /* VBOX_WITH_DEBUGGER_GUI */
    105 #ifdef Q_WS_MAC
     105#ifdef VBOX_WS_MAC
    106106    UIExtraDataMetaDefs::MenuWindowActionType m_restrictionsOfMenuWindow;
    107 #endif /* Q_WS_MAC */
     107#endif /* VBOX_WS_MAC */
    108108    UIExtraDataMetaDefs::MenuHelpActionType m_restrictionsOfMenuHelp;
    109 #ifndef Q_WS_MAC
     109#ifndef VBOX_WS_MAC
    110110    bool m_fShowMiniToolBar;
    111111    bool m_fMiniToolBarAtTop;
    112 #endif /* !Q_WS_MAC */
     112#endif /* !VBOX_WS_MAC */
    113113};
    114114typedef UISettingsCache<UIDataSettingsMachineInterface> UICacheSettingsMachineInterface;

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSFDetails.cpp

    r52730 r60362  
    6464    adjustSize();
    6565
    66 #ifdef Q_WS_MAC
     66#ifdef VBOX_WS_MAC
    6767    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    6868    setFixedSize(minimumSize());
    69 #endif /* Q_WS_MAC */
     69#endif /* VBOX_WS_MAC */
    7070}
    7171
    … …  
    156156
    157157    QString strFolderName(mPsPath->path());
    158 #if defined (Q_WS_WIN) || defined (Q_OS_OS2)
     158#if defined (VBOX_WS_WIN) || defined (Q_OS_OS2)
    159159    if (strFolderName[0].isLetter() && strFolderName[1] == ':' && strFolderName[2] == 0)
    160160    {
    … …  
    164164        mPsPath->setPath(strFolderName);
    165165    }
    166 #endif /* Q_WS_WIN || Q_OS_OS2 */
     166#endif /* VBOX_WS_WIN || Q_OS_OS2 */
    167167    QDir folder(strFolderName);
    168168    if (!folder.isRoot())
    … …  
    174174    {
    175175        /* Processing root folder: */
    176 #if defined (Q_WS_WIN) || defined (Q_OS_OS2)
     176#if defined (VBOX_WS_WIN) || defined (Q_OS_OS2)
    177177        mLeName->setText(strFolderName.toUpper()[0] + "_DRIVE");
    178 #elif defined (Q_WS_X11)
     178#elif defined (VBOX_WS_X11)
    179179        mLeName->setText("ROOT");
    180180#endif

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp

    r58968 r60362  
    20752075    mTbStorageBar->addAction (mDelCtrAction);
    20762076
    2077 #ifdef Q_WS_MAC
     2077#ifdef VBOX_WS_MAC
    20782078    /* We need a little more space for the focus rect. */
    20792079    mLtStorage->setContentsMargins (3, 0, 3, 0);
    20802080    mLtStorage->setSpacing (3);
    2081 #endif /* Q_WS_MAC */
     2081#endif /* VBOX_WS_MAC */
    20822082
    20832083    /* Setup choose-medium button: */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.h

    r58968 r60362  
    2020
    2121/* Qt includes: */
    22 #include <QtGlobal> /* for Q_WS_MAC */
    23 #ifdef Q_WS_MAC
     22#include <QtGlobal> /* for VBOX_WS_MAC */
     23#ifdef VBOX_WS_MAC
    2424/* Somewhere Carbon.h includes AssertMacros.h which defines the macro "check".
    2525 * In QItemDelegate a class method is called "check" also. As we not used the
    2626 * macro undefine it here. */
    2727# undef check
    28 #endif /* Q_WS_MAC */
     28#endif /* VBOX_WS_MAC */
    2929#include <QItemDelegate>
    3030#include <QPointer>

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsSystem.cpp

    r59877 r60362  
    617617    mTbBootItemUp->setIcon(UIIconPool::iconSet(":/list_moveup_16px.png", ":/list_moveup_disabled_16px.png"));
    618618    mTbBootItemDown->setIcon(UIIconPool::iconSet(":/list_movedown_16px.png", ":/list_movedown_disabled_16px.png"));
    619 #ifdef Q_WS_MAC
     619#ifdef VBOX_WS_MAC
    620620    /* We need a little space for the focus rect: */
    621621    m_pLayoutBootOrder->setContentsMargins(3, 3, 3, 3);
    622622    m_pLayoutBootOrder->setSpacing(3);
    623 #endif /* Q_WS_MAC */
     623#endif /* VBOX_WS_MAC */
    624624    /* Install global event filter
    625625     * to handle boot-table focus in/out events: */

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

    r59092 r60362  
    397397                 * the button hasn't a rectangle shape. This prevents the
    398398                 * display of parts from the current text on the Mac. */
    399 #ifdef Q_WS_MAC
     399#ifdef VBOX_WS_MAC
    400400                /* Use the palette from the tree view, not the one from the
    401401                 * editor. */
    … …  
    403403                p.setBrush(QPalette::Highlight, pParent->palette().brush(QPalette::Highlight));
    404404                e->setPalette(p);
    405 #endif /* Q_WS_MAC */
     405#endif /* VBOX_WS_MAC */
    406406                e->setAutoFillBackground(true);
    407407                e->setBackgroundRole(QPalette::Highlight);
    … …  
    999999}
    10001000
    1001 #ifdef Q_WS_MAC
     1001#ifdef VBOX_WS_MAC
    10021002bool VirtualSystemDelegate::eventFilter(QObject *pObject, QEvent *pEvent)
    10031003{
    … …  
    10181018    return QItemDelegate::eventFilter(pObject, pEvent);
    10191019}
    1020 #endif /* Q_WS_MAC */
     1020#endif /* VBOX_WS_MAC */
    10211021
    10221022////////////////////////////////////////////////////////////////////////////////

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

    r59092 r60362  
    210210    {
    211211        QSize size = QItemDelegate::sizeHint(styleOption, idx);
    212 #ifdef Q_WS_MAC
     212#ifdef VBOX_WS_MAC
    213213        int h = 28;
    214 #else /* Q_WS_MAC */
     214#else /* VBOX_WS_MAC */
    215215        int h = 24;
    216 #endif /* Q_WS_MAC */
     216#endif /* VBOX_WS_MAC */
    217217        size.setHeight(RT_MAX(h, size.height()));
    218218        return size;
    … …  
    221221protected:
    222222
    223 #ifdef Q_WS_MAC
     223#ifdef VBOX_WS_MAC
    224224    bool eventFilter(QObject *pObject, QEvent *pEvent);
    225 #endif /* Q_WS_MAC */
     225#endif /* VBOX_WS_MAC */
    226226
    227227private:

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

    r52730 r60362  
    6868    painter.setClipRect(pEvent->rect());
    6969
    70 #ifdef Q_WS_MAC
     70#ifdef VBOX_WS_MAC
    7171    paintContentDarwin(&painter);
    72 #else /* Q_WS_MAC */
     72#else /* VBOX_WS_MAC */
    7373    paintContent(&painter);
    74 #endif /* !Q_WS_MAC */
     74#endif /* !VBOX_WS_MAC */
    7575}
    7676
    77 #ifdef Q_WS_MAC
     77#ifdef VBOX_WS_MAC
    7878
    7979void UIBar::paintContentDarwin(QPainter *pPainter)
    … …  
    9292}
    9393
    94 #else /* Q_WS_MAC */
     94#else /* VBOX_WS_MAC */
    9595
    9696void UIBar::paintContent(QPainter *pPainter)
    … …  
    113113}
    114114
    115 #endif /* !Q_WS_MAC */
     115#endif /* !VBOX_WS_MAC */
    116116
    117117UIMainBar::UIMainBar(QWidget *pParent /* = 0 */)

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

    r55401 r60362  
    3838    void paintEvent(QPaintEvent *pEvent);
    3939
    40 #ifdef Q_WS_MAC
     40#ifdef VBOX_WS_MAC
    4141    void paintContentDarwin(QPainter *pPainter);
    42 #else /* Q_WS_MAC */
     42#else /* VBOX_WS_MAC */
    4343    void paintContent(QPainter *pPainter);
    44 #endif /* !Q_WS_MAC */
     44#endif /* !VBOX_WS_MAC */
    4545
    4646private:

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

    r56108 r60362  
    167167
    168168    /* Configure layout: */
    169 #ifdef Q_WS_MAC
     169#ifdef VBOX_WS_MAC
    170170    m_pMainLayout->setContentsMargins(10, 10, 15, 10);
    171 #else /* Q_WS_MAC */
     171#else /* VBOX_WS_MAC */
    172172    m_pMainLayout->setContentsMargins(10, 10, 10, 10);
    173 #endif /* !Q_WS_MAC */
     173#endif /* !VBOX_WS_MAC */
    174174
    175175    /* Add strech: */
    … …  
    185185    /* Configure font: */
    186186    QFont currentFont = m_pCheckBox->font();
    187 #ifdef Q_WS_MAC
     187#ifdef VBOX_WS_MAC
    188188    currentFont.setPointSize(currentFont.pointSize() - 2);
    189 #else /* Q_WS_MAC */
     189#else /* VBOX_WS_MAC */
    190190    currentFont.setPointSize(currentFont.pointSize() - 1);
    191 #endif /* !Q_WS_MAC */
     191#endif /* !VBOX_WS_MAC */
    192192    m_pCheckBox->setFont(currentFont);
    193193

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

    r60077 r60362  
    2626# include <QStylePainter>
    2727# include <QTimer>
    28 # ifdef Q_WS_X11
     28# ifdef VBOX_WS_X11
    2929#  include <QX11Info>
    30 # endif /* Q_WS_X11 */
     30# endif /* VBOX_WS_X11 */
    3131
    3232/* GUI includes: */
    … …  
    3636# include "VBoxGlobal.h"
    3737# include "QIToolButton.h"
    38 # ifdef Q_WS_MAC
     38# ifdef VBOX_WS_MAC
    3939#  include "UICocoaApplication.h"
    4040#  include "VBoxUtils-darwin.h"
    41 # endif /* Q_WS_MAC */
     41# endif /* VBOX_WS_MAC */
    4242
    4343#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    4444
    4545/* Qt includes: */
    46 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     46#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    4747# if QT_VERSION >= 0x050000
    4848#  include <QAbstractNativeEventFilter>
    4949# endif /* QT_VERSION >= 0x050000 */
    50 #endif /* Q_WS_MAC || Q_WS_WIN */
     50#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
    5151
    5252/* GUI includes: */
    53 #if defined(Q_WS_MAC)
     53#if defined(VBOX_WS_MAC)
    5454# include "DarwinKeyboard.h"
    55 #elif defined(Q_WS_WIN)
     55#elif defined(VBOX_WS_WIN)
    5656# include "WinKeyboard.h"
    57 #elif defined(Q_WS_X11)
     57#elif defined(VBOX_WS_X11)
    5858# include "XKeyboard.h"
    59 #endif /* Q_WS_X11 */
     59#endif /* VBOX_WS_X11 */
    6060
    6161/* External includes: */
    62 #if defined(Q_WS_MAC)
     62#if defined(VBOX_WS_MAC)
    6363# include <Carbon/Carbon.h>
    64 #elif defined(Q_WS_X11)
     64#elif defined(VBOX_WS_X11)
    6565# include <X11/Xlib.h>
    6666# include <X11/Xutil.h>
    … …  
    7676#  endif /* KeyPress */
    7777# endif /* QT_VERSION < 0x050000 */
    78 #endif /* Q_WS_X11 */
     78#endif /* VBOX_WS_X11 */
    7979
    8080/* Namespaces: */
    … …  
    8282
    8383
    84 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     84#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    8585# if QT_VERSION >= 0x050000
    8686/** QAbstractNativeEventFilter extension
    … …  
    115115};
    116116# endif /* QT_VERSION >= 0x050000 */
    117 #endif /* Q_WS_MAC || Q_WS_WIN */
     117#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
    118118
    119119
    … …  
    122122*********************************************************************************************************************************/
    123123
    124 #ifdef Q_WS_X11
     124#ifdef VBOX_WS_X11
    125125namespace UINativeHotKey
    126126{
    127127    QMap<QString, QString> m_keyNames;
    128128}
    129 #endif /* Q_WS_X11 */
     129#endif /* VBOX_WS_X11 */
    130130
    131131QString UINativeHotKey::toString(int iKeyCode)
    … …  
    133133    QString strKeyName;
    134134
    135 #if defined(Q_WS_MAC)
     135#if defined(VBOX_WS_MAC)
    136136
    137137    UInt32 modMask = DarwinKeyCodeToDarwinModifierMask(iKeyCode);
    … …  
    173173    }
    174174
    175 #elif defined(Q_WS_WIN)
     175#elif defined(VBOX_WS_WIN)
    176176
    177177    /* MapVirtualKey doesn't distinguish between right and left vkeys,
    … …  
    206206    delete[] pKeyName;
    207207
    208 #elif defined(Q_WS_X11)
     208#elif defined(VBOX_WS_X11)
    209209
    210210    if (char *pNativeKeyName = ::XKeysymToString((KeySym)iKeyCode))
    … …  
    230230bool UINativeHotKey::isValidKey(int iKeyCode)
    231231{
    232 #if defined(Q_WS_MAC)
     232#if defined(VBOX_WS_MAC)
    233233
    234234    UInt32 modMask = ::DarwinKeyCodeToDarwinModifierMask(iKeyCode);
    … …  
    248248    }
    249249
    250 #elif defined(Q_WS_WIN)
     250#elif defined(VBOX_WS_WIN)
    251251
    252252    return ((iKeyCode >= VK_SHIFT && iKeyCode <= VK_CAPITAL) ||
    … …  
    258258            iKeyCode == VK_PRINT);
    259259
    260 #elif defined(Q_WS_X11)
     260#elif defined(VBOX_WS_X11)
    261261
    262262    return (IsModifierKey(iKeyCode) /* allow modifiers */ ||
    … …  
    276276}
    277277
    278 #if defined(Q_WS_WIN)
     278#if defined(VBOX_WS_WIN)
    279279
    280280int UINativeHotKey::distinguishModifierVKey(int wParam, int lParam)
    … …  
    317317}
    318318
    319 #elif defined(Q_WS_X11)
     319#elif defined(VBOX_WS_X11)
    320320
    321321void UINativeHotKey::retranslateKeyNames()
    … …  
    335335}
    336336
    337 #endif /* Q_WS_X11 */
     337#endif /* VBOX_WS_X11 */
    338338
    339339
    … …  
    470470    : m_pReleaseTimer(0)
    471471    , m_fStartNewSequence(true)
    472 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     472#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    473473# if QT_VERSION >= 0x050000
    474474    , m_pPrivateEventFilter(0)
    475475# endif /* QT_VERSION >= 0x050000 */
    476 #endif /* Q_WS_MAC || Q_WS_WIN */
    477 #ifdef Q_WS_WIN
     476#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
     477#ifdef VBOX_WS_WIN
    478478    , m_pAltGrMonitor(0)
    479 #endif /* Q_WS_WIN */
     479#endif /* VBOX_WS_WIN */
    480480{
    481481    /* Configure widget: */
    … …  
    490490    connect(m_pReleaseTimer, SIGNAL(timeout()), this, SLOT(sltReleasePendingKeys()));
    491491
    492 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     492#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    493493# if QT_VERSION >= 0x050000
    494494    /* Prepare private event filter: */
    … …  
    496496    qApp->installNativeEventFilter(m_pPrivateEventFilter);
    497497# endif /* QT_VERSION >= 0x050000 */
    498 #endif /* Q_WS_MAC || Q_WS_WIN */
    499 
    500 #if defined(Q_WS_MAC)
     498#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
     499
     500#if defined(VBOX_WS_MAC)
    501501    m_uDarwinKeyModifiers = 0;
    502502# if QT_VERSION < 0x050000
    … …  
    504504    ::DarwinGrabKeyboard(false /* just modifiers */);
    505505# endif /* QT_VERSION < 0x050000 */
    506 #elif defined(Q_WS_WIN)
     506#elif defined(VBOX_WS_WIN)
    507507    /* Prepare AltGR monitor: */
    508508    m_pAltGrMonitor = new WinAltGrMonitor;
    509 #elif defined(Q_WS_X11)
     509#elif defined(VBOX_WS_X11)
    510510    /* Initialize the X keyboard subsystem: */
    511511    initMappedX11Keyboard(QX11Info::display(), vboxGlobal().settings().publicProperty("GUI/RemapScancodes"));
    512 #endif /* Q_WS_X11 */
     512#endif /* VBOX_WS_X11 */
    513513}
    514514
    515515UIHostComboEditorPrivate::~UIHostComboEditorPrivate()
    516516{
    517 #if defined(Q_WS_MAC)
     517#if defined(VBOX_WS_MAC)
    518518# if QT_VERSION < 0x050000
    519519    ::DarwinReleaseKeyboard();
    520520    UICocoaApplication::instance()->unregisterForNativeEvents(RT_BIT_32(10) | RT_BIT_32(11) | RT_BIT_32(12) /* NSKeyDown  | NSKeyUp | | NSFlagsChanged */, UIHostComboEditorPrivate::darwinEventHandlerProc, this);
    521521# endif /* QT_VERSION < 0x050000 */
    522 #elif defined(Q_WS_WIN)
     522#elif defined(VBOX_WS_WIN)
    523523    /* Cleanup AltGR monitor: */
    524524    delete m_pAltGrMonitor;
    525525    m_pAltGrMonitor = 0;
    526 #endif /* Q_WS_WIN */
    527 
    528 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     526#endif /* VBOX_WS_WIN */
     527
     528#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    529529# if QT_VERSION >= 0x050000
    530530    /* Cleanup private event filter: */
    … …  
    533533    m_pPrivateEventFilter = 0;
    534534# endif /* QT_VERSION >= 0x050000 */
    535 #endif /* Q_WS_MAC || Q_WS_WIN */
     535#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
    536536}
    537537
    … …  
    581581bool UIHostComboEditorPrivate::nativeEvent(const QByteArray &eventType, void *pMessage, long *pResult)
    582582{
    583 # if defined(Q_WS_MAC)
     583# if defined(VBOX_WS_MAC)
    584584
    585585    /* Make sure it's generic NSEvent: */
    … …  
    637637    }
    638638
    639 # elif defined(Q_WS_WIN)
     639# elif defined(VBOX_WS_WIN)
    640640
    641641    /* Make sure it's generic MSG event: */
    … …  
    685685    }
    686686
    687 # elif defined(Q_WS_X11)
     687# elif defined(VBOX_WS_X11)
    688688//#  pragma GCC diagnostic push
    689689//#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    … …  
    728728#else /* QT_VERSION < 0x050000 */
    729729
    730 # if defined(Q_WS_MAC)
     730# if defined(VBOX_WS_MAC)
    731731
    732732/* static */
    … …  
    786786}
    787787
    788 # elif defined(Q_WS_WIN)
     788# elif defined(VBOX_WS_WIN)
    789789
    790790bool UIHostComboEditorPrivate::winEvent(MSG *pMsg, long* /* pResult */)
    … …  
    830830}
    831831
    832 # elif defined(Q_WS_X11)
     832# elif defined(VBOX_WS_X11)
    833833#  if RT_GNUC_PREREQ(4, 6)
    834834#   pragma GCC diagnostic push
    … …  
    862862#   pragma GCC diagnostic pop
    863863#  endif
    864 # endif /* Q_WS_X11 */
     864# endif /* VBOX_WS_X11 */
    865865
    866866#endif /* QT_VERSION < 0x050000 */

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

    r59743 r60362  
    3131class QIToolButton;
    3232class UIHostComboEditorPrivate;
    33 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     33#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    3434# if QT_VERSION >= 0x050000
    3535class ComboEditorEventFilter;
    3636# endif /* QT_VERSION >= 0x050000 */
    37 #endif /* Q_WS_MAC || Q_WS_WIN */
    38 #ifdef Q_WS_WIN
     37#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
     38#ifdef VBOX_WS_WIN
    3939class WinAltGrMonitor;
    40 #endif /* Q_WS_WIN */
     40#endif /* VBOX_WS_WIN */
    4141
    4242
    … …  
    4747    QString toString(int iKeyCode);
    4848    bool isValidKey(int iKeyCode);
    49 #if defined(Q_WS_WIN)
     49#if defined(VBOX_WS_WIN)
    5050    int distinguishModifierVKey(int wParam, int lParam);
    51 #elif defined(Q_WS_X11)
     51#elif defined(VBOX_WS_X11)
    5252    void retranslateKeyNames();
    53 #endif /* Q_WS_X11 */
     53#endif /* VBOX_WS_X11 */
    5454}
    5555
    … …  
    152152    bool nativeEvent(const QByteArray &eventType, void *pMessage, long *pResult);
    153153#else /* QT_VERSION < 0x050000 */
    154 # if defined(Q_WS_MAC)
     154# if defined(VBOX_WS_MAC)
    155155    /** Mac: Qt4: Handles all native events (static callback). */
    156156    static bool darwinEventHandlerProc(const void *pvCocoaEvent, const void *pvCarbonEvent, void *pvUser);
    157157    /** Mac: Qt4: Handles all native events. */
    158158    bool darwinKeyboardEvent(const void *pvCocoaEvent, EventRef inEvent);
    159 # elif defined(Q_WS_WIN)
     159# elif defined(VBOX_WS_WIN)
    160160    /** Win: Qt4: Handles all native events. */
    161161    bool winEvent(MSG *pMsg, long *pResult);
    162 # elif defined(Q_WS_X11)
     162# elif defined(VBOX_WS_X11)
    163163    /** X11: Qt4: Handles all native events. */
    164164    bool x11Event(XEvent *pEvent);
    165 # endif /* Q_WS_X11 */
     165# endif /* VBOX_WS_X11 */
    166166#endif /* QT_VERSION < 0x050000 */
    167167
    … …  
    187187    bool m_fStartNewSequence;
    188188
    189 #if defined(Q_WS_MAC) || defined(Q_WS_WIN)
     189#if defined(VBOX_WS_MAC) || defined(VBOX_WS_WIN)
    190190# if QT_VERSION >= 0x050000
    191191    /** Mac, Win: Holds the native event filter instance. */
    … …  
    195195    friend class ComboEditorEventFilter;
    196196# endif /* QT_VERSION >= 0x050000 */
    197 #endif /* Q_WS_MAC || Q_WS_WIN */
    198 
    199 #if defined(Q_WS_MAC)
     197#endif /* VBOX_WS_MAC || VBOX_WS_WIN */
     198
     199#if defined(VBOX_WS_MAC)
    200200    /** Mac: Holds the current modifier key mask. Used to figure out which modifier
    201201      * key was pressed when we get a kEventRawKeyModifiersChanged event. */
    202202    uint32_t m_uDarwinKeyModifiers;
    203 #elif defined(Q_WS_WIN)
     203#elif defined(VBOX_WS_WIN)
    204204    /** Win: Holds the object monitoring key event
    205205      * stream for problematic AltGr events. */
    206206    WinAltGrMonitor *m_pAltGrMonitor;
    207 #endif /* Q_WS_WIN */
     207#endif /* VBOX_WS_WIN */
    208208};
    209209

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

    r58880 r60362  
    272272
    273273    /* Left margin: */
    274 #ifdef Q_WS_X11
     274#ifdef VBOX_WS_X11
    275275    if (vboxGlobal().isCompositingManagerRunning())
    276276        m_spacings << widgetForAction(addWidget(new QWidget));
    277 #else /* !Q_WS_X11 */
     277#else /* !VBOX_WS_X11 */
    278278    m_spacings << widgetForAction(addWidget(new QWidget));
    279 #endif /* !Q_WS_X11 */
     279#endif /* !VBOX_WS_X11 */
    280280
    281281    /* Prepare push-pin: */
    … …  
    327327
    328328    /* Right margin: */
    329 #ifdef Q_WS_X11
     329#ifdef VBOX_WS_X11
    330330    if (vboxGlobal().isCompositingManagerRunning())
    331331        m_spacings << widgetForAction(addWidget(new QWidget));
    332 #else /* !Q_WS_X11 */
     332#else /* !VBOX_WS_X11 */
    333333    m_spacings << widgetForAction(addWidget(new QWidget));
    334 #endif /* !Q_WS_X11 */
     334#endif /* !VBOX_WS_X11 */
    335335
    336336    /* Resize to sizehint: */
    … …  
    340340void UIMiniToolBarPrivate::rebuildShape()
    341341{
    342 #ifdef Q_WS_X11
     342#ifdef VBOX_WS_X11
    343343    if (!vboxGlobal().isCompositingManagerRunning())
    344344        return;
    345 #endif /* Q_WS_X11 */
     345#endif /* VBOX_WS_X11 */
    346346
    347347    /* Rebuild shape: */
    … …  
    496496        m_pEmbeddedToolbar->move(m_hiddenToolbarPosition);
    497497
    498 #ifdef Q_WS_X11
     498#ifdef VBOX_WS_X11
    499499    /* Adjust window mask: */
    500500    setMask(m_pEmbeddedToolbar->geometry());
    501 #endif /* Q_WS_X11 */
     501#endif /* VBOX_WS_X11 */
    502502
    503503    /* Simulate toolbar auto-hiding: */
    … …  
    543543    installEventFilter(this);
    544544
    545 #if   defined(Q_WS_WIN)
     545#if   defined(VBOX_WS_WIN)
    546546    /* No background until first paint-event: */
    547547    setAttribute(Qt::WA_NoSystemBackground);
    548548    /* Enable translucency through Qt API: */
    549549    setAttribute(Qt::WA_TranslucentBackground);
    550 #elif defined(Q_WS_X11)
     550#elif defined(VBOX_WS_X11)
    551551    /* Enable translucency through Qt API if supported: */
    552552    if (vboxGlobal().isCompositingManagerRunning())
    553553        setAttribute(Qt::WA_TranslucentBackground);
    554 #endif /* Q_WS_X11 */
     554#endif /* VBOX_WS_X11 */
    555555
    556556    /* Make sure we have no focus: */
    … …  
    676676    if (pWatched == this && pEvent->type() == QEvent::WindowActivate)
    677677    {
    678 #if   defined(Q_WS_WIN)
     678#if   defined(VBOX_WS_WIN)
    679679        emit sigNotifyAboutWindowActivationStolen();
    680 #elif defined(Q_WS_X11)
     680#elif defined(VBOX_WS_X11)
    681681        switch (vboxGlobal().typeOfWindowManager())
    682682        {
    … …  
    698698            }
    699699        }
    700 #endif /* Q_WS_X11 */
     700#endif /* VBOX_WS_X11 */
    701701    }
    702702
    … …  
    725725    m_pEmbeddedToolbar->move(point);
    726726
    727 #ifdef Q_WS_X11
     727#ifdef VBOX_WS_X11
    728728    /* Update window mask: */
    729729    setMask(m_pEmbeddedToolbar->geometry());
    730 #endif /* Q_WS_X11 */
     730#endif /* VBOX_WS_X11 */
    731731}
    732732

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

    r56039 r60362  
    3030/* GUI includes: */
    3131# include "UIPopupBox.h"
    32 # ifdef Q_WS_MAC
     32# ifdef VBOX_WS_MAC
    3333#  include "UIImageTools.h"
    34 # endif /* Q_WS_MAC */
     34# endif /* VBOX_WS_MAC */
    3535
    3636#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */

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

    r52730 r60362  
    198198QFont UIPopupPaneTextPane::tuneFont(QFont font)
    199199{
    200 #if defined(Q_WS_MAC)
     200#if defined(VBOX_WS_MAC)
    201201    font.setPointSize(font.pointSize() - 2);
    202 #elif defined(Q_WS_X11)
     202#elif defined(VBOX_WS_X11)
    203203    font.setPointSize(font.pointSize() - 1);
    204204#endif

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

    r57880 r60362  
    187187    /* Configure background: */
    188188    setAutoFillBackground(false);
    189 #if defined(Q_WS_WIN) || defined (Q_WS_MAC)
     189#if defined(VBOX_WS_WIN) || defined (VBOX_WS_MAC)
    190190    /* Using Qt API to enable translucent background for the Win/Mac host.
    191191     * - Under x11 host Qt 4.8.3 has it broken wih KDE 4.9 for now: */
    192192    setAttribute(Qt::WA_TranslucentBackground);
    193 #endif /* Q_WS_WIN || Q_WS_MAC */
    194 
    195 #ifdef Q_WS_MAC
     193#endif /* VBOX_WS_WIN || VBOX_WS_MAC */
     194
     195#ifdef VBOX_WS_MAC
    196196    /* Do not hide popup-stack
    197197     * and actually the seamless machine-window too
    198198     * due to Qt bug on window deactivation... */
    199199    setAttribute(Qt::WA_MacAlwaysShowToolWindow);
    200 #endif /* Q_WS_MAC */
     200#endif /* VBOX_WS_MAC */
    201201
    202202    /* Prepare content: */

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

    r60171 r60362  
    580580    {
    581581        /* Configure layout: */
    582 #ifndef Q_WS_WIN
     582#ifndef VBOX_WS_WIN
    583583        /* On Windows host that looks ugly, but
    584584         * On Mac OS X and X11 that deserves it's place. */
    585585        pMainLayout->setContentsMargins(0, 0, 0, 0);
    586 #endif /* !Q_WS_WIN */
     586#endif /* !VBOX_WS_WIN */
    587587        pMainLayout->setSpacing(3);
    588588        /* Create model: */

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

    r56495 r60362  
    3636# include "QILabel.h"
    3737# include "VBoxGlobal.h"
    38 # ifdef Q_WS_MAC
     38# ifdef VBOX_WS_MAC
    3939#  include "VBoxUtils-darwin.h"
    40 # endif /* Q_WS_MAC */
     40# endif /* VBOX_WS_MAC */
    4141
    4242/* COM includes: */
    … …  
    6868    QHBoxLayout *pMainLayout = new QHBoxLayout(this);
    6969
    70 #ifdef Q_WS_MAC
     70#ifdef VBOX_WS_MAC
    7171    ::darwinSetHidesAllTitleButtons(this);
    7272    if (pImage)
    … …  
    7474    else
    7575        pMainLayout->setContentsMargins(6, 6, 6, 6);
    76 #endif /* Q_WS_MAC */
     76#endif /* VBOX_WS_MAC */
    7777
    7878    /* Create image: */
    … …  
    159159         * Apple there is no busy window behavior. A window should always be
    160160         * responsive and it is in our case (We show the progress dialog bar). */
    161 #ifndef Q_WS_MAC
     161#ifndef VBOX_WS_MAC
    162162        if (m_fCancelEnabled)
    163163            QApplication::setOverrideCursor(QCursor(Qt::BusyCursor));
    164164        else
    165165            QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
    166 #endif /* Q_WS_MAC */
     166#endif /* VBOX_WS_MAC */
    167167
    168168        /* Create a local event-loop: */
    … …  
    183183        killTimer(id);
    184184
    185 #ifndef Q_WS_MAC
     185#ifndef VBOX_WS_MAC
    186186        /* Reset the busy cursor */
    187187        QApplication::restoreOverrideCursor();
    188 #endif /* Q_WS_MAC */
     188#endif /* VBOX_WS_MAC */
    189189
    190190        return result();

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

    r54539 r60362  
    149149    : QIWithRetranslateUI<QPushButton>(pParent)
    150150{
    151 #ifdef Q_WS_MAC
     151#ifdef VBOX_WS_MAC
    152152    m_pButtonPressed = false;
    153153    m_pNormalPixmap = new QPixmap(":/help_button_normal_mac_22px.png");
    … …  
    159159                    m_size.width(),
    160160                    m_size.height());
    161 #endif /* Q_WS_MAC */
     161#endif /* VBOX_WS_MAC */
    162162    /* Applying language settings */
    163163    retranslateUi();
    … …  
    183183}
    184184
    185 #ifdef Q_WS_MAC
     185#ifdef VBOX_WS_MAC
    186186UIHelpButton::~UIHelpButton()
    187187{
    … …  
    233233    update();
    234234}
    235 #endif /* Q_WS_MAC */
     235#endif /* VBOX_WS_MAC */
    236236
    237237/********************************************************************************

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

    r55401 r60362  
    187187public:
    188188    UIHelpButton(QWidget *pParent = 0);
    189 #ifdef Q_WS_MAC
     189#ifdef VBOX_WS_MAC
    190190    ~UIHelpButton();
    191191    QSize sizeHint() const;
    192 #endif /* Q_WS_MAC */
     192#endif /* VBOX_WS_MAC */
    193193
    194194    void initFrom(QPushButton *pOther);
    … …  
    197197    void retranslateUi();
    198198
    199 #ifdef Q_WS_MAC
     199#ifdef VBOX_WS_MAC
    200200    void paintEvent(QPaintEvent *pEvent);
    201201
    … …  
    215215    QImage *m_pMask;
    216216    QRect m_BRect;
    217 #endif /* Q_WS_MAC */
     217#endif /* VBOX_WS_MAC */
    218218};
    219219

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

    r59100 r60362  
    2626/* GUI includes: */
    2727# include "UIToolBar.h"
    28 # ifdef Q_WS_MAC
     28# ifdef VBOX_WS_MAC
    2929#  include "VBoxUtils.h"
    3030# endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
    3131
    32 #endif /* Q_WS_MAC */
     32#endif /* VBOX_WS_MAC */
    3333
    3434/* Qt includes: */
    … …  
    5959}
    6060
    61 #ifdef Q_WS_MAC
     61#ifdef VBOX_WS_MAC
    6262void UIToolBar::enableMacToolbar()
    6363{
    … …  
    8585    layout()->activate();
    8686}
    87 #endif /* Q_WS_MAC */
     87#endif /* VBOX_WS_MAC */
    8888
    8989void UIToolBar::prepare()
    … …  
    100100        setStyleSheet("QToolBar { border: 0px none black; }");
    101101#else /* QT_VERSION >= 0x050000 */
    102 # ifdef Q_WS_MAC
     102# ifdef VBOX_WS_MAC
    103103        setStyleSheet("QToolBar { border: 0px none black; }");
    104 # endif /* Q_WS_MAC */
     104# endif /* VBOX_WS_MAC */
    105105#endif /* QT_VERSION >= 0x050000 */
    106106

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

    r55401 r60362  
    4040    void setUseTextLabels(bool fEnable);
    4141
    42 #ifdef Q_WS_MAC
     42#ifdef VBOX_WS_MAC
    4343    /** Mac OS X: Defines whether native tool-bar should be used. */
    4444    void enableMacToolbar();
    … …  
    4747    /** Mac OS X: Updates native tool-bar layout. */
    4848    void updateLayout();
    49 #endif /* Q_WS_MAC */
     49#endif /* VBOX_WS_MAC */
    5050
    5151private:

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

    r56040 r60362  
    5757    CGuestOSType type = vboxGlobal().vmGuestOSType (aOSTypeId);
    5858    /* Looks ugly on the Mac */
    59 #ifndef Q_WS_MAC
     59#ifndef VBOX_WS_MAC
    6060    setIcon (vboxGlobal().vmGuestOSTypeIcon (type.GetId()));
    61 #endif /* Q_WS_MAC */
     61#endif /* VBOX_WS_MAC */
    6262    setText (type.GetDescription());
    6363}

  • trunk/src/VBox/Frontends/VirtualBox/src/widgets/graphics/UIGraphicsButton.cpp

    r52730 r60362  
    107107            QPalette pal = palette();
    108108            QColor buttonColor = pal.color(m_fParentSelected ? QPalette::HighlightedText : QPalette::Mid);
    109 #ifdef Q_WS_MAC
     109#ifdef VBOX_WS_MAC
    110110            /* Mac is using only light standard highlight colors, keeping highlight-text color always black.
    111111             * User can choose a darker (non-standard) highlight color but it will be his visibility problem.
    … …  
    114114            if (m_fParentSelected)
    115115                buttonColor = pal.color(QPalette::Highlight).darker(150);
    116 #endif /* Q_WS_MAC */
     116#endif /* VBOX_WS_MAC */
    117117
    118118            /* Setup: */
    … …  
    145145            QPalette pal = palette();
    146146            QColor buttonColor = pal.color(m_fParentSelected ? QPalette::HighlightedText : QPalette::Mid);
    147 #ifdef Q_WS_MAC
     147#ifdef VBOX_WS_MAC
    148148            /* Mac is using only light standard highlight colors, keeping highlight-text color always black.
    149149             * User can choose a darker (non-standard) highlight color but it will be his visibility problem.
    … …  
    152152            if (m_fParentSelected)
    153153                buttonColor = pal.color(QPalette::Highlight).darker(150);
    154 #endif /* Q_WS_MAC */
     154#endif /* VBOX_WS_MAC */
    155155
    156156            /* Setup: */

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/UIWizard.cpp

    r53237 r60362  
    7878    , m_mode(mode == WizardMode_Auto ? gEDataManager->modeForWizardType(m_type) : mode)
    7979{
    80 #ifdef Q_WS_WIN
     80#ifdef VBOX_WS_WIN
    8181    /* Hide window icon: */
    8282    setWindowIcon(QIcon());
    83 #endif /* Q_WS_WIN */
    84 
    85 #ifdef Q_WS_MAC
     83#endif /* VBOX_WS_WIN */
     84
     85#ifdef VBOX_WS_MAC
    8686    /* Since wizards are now represented as Mac OS X Sheets
    8787     * we would like to have possibility to cancel them. */
    … …  
    9090     * This prevents the using of Enter to jump to the next page. */
    9191    setOptions(options() ^ QWizard::NoDefaultButton);
    92 #endif /* Q_WS_MAC */
     92#endif /* VBOX_WS_MAC */
    9393
    9494    /* All our wizards would like to have window-modality,
    … …  
    170170    }
    171171
    172 #ifndef Q_WS_MAC
     172#ifndef VBOX_WS_MAC
    173173    /* Cleanup watermark: */
    174174    if (!m_strWatermarkName.isEmpty())
    175175        setPixmap(QWizard::WatermarkPixmap, QPixmap());
    176 #endif /* !Q_WS_MAC */
     176#endif /* !VBOX_WS_MAC */
    177177}
    178178
    … …  
    247247        int iCurrentWizardWidth = width();
    248248        int iCurrentWizardHeight = height();
    249 #ifndef Q_WS_MAC
     249#ifndef VBOX_WS_MAC
    250250        /* We should take into account watermark like its assigned already: */
    251251        QPixmap watermarkPixmap(m_strWatermarkName);
    252252        int iWatermarkWidth = watermarkPixmap.width();
    253253        iCurrentWizardWidth += iWatermarkWidth;
    254 #endif /* !Q_WS_MAC */
     254#endif /* !VBOX_WS_MAC */
    255255        /* Calculating nearest to 'golden ratio' label width: */
    256256        int iGoldenRatioWidth = (int)qSqrt(ratio() * iCurrentWizardWidth * iCurrentWizardHeight);
    257257        int iProposedLabelWidth = iGoldenRatioWidth - iMarginsLength;
    258 #ifndef Q_WS_MAC
     258#ifndef VBOX_WS_MAC
    259259        /* We should take into account watermark like its assigned already: */
    260260        iProposedLabelWidth -= iWatermarkWidth;
    261 #endif /* !Q_WS_MAC */
     261#endif /* !VBOX_WS_MAC */
    262262
    263263        /* Choose maximum between current and proposed label width: */
    … …  
    269269    }
    270270
    271 #ifndef Q_WS_MAC
     271#ifndef VBOX_WS_MAC
    272272    /* Really assign watermark: */
    273273    if (!m_strWatermarkName.isEmpty())
    274274        assignWatermarkHelper();
    275 #endif /* !Q_WS_MAC */
    276 }
    277 
    278 #ifndef Q_WS_MAC
     275#endif /* !VBOX_WS_MAC */
     276}
     277
     278#ifndef VBOX_WS_MAC
    279279void UIWizard::assignWatermark(const QString &strWatermark)
    280280{
    281281    if (wizardStyle() != QWizard::AeroStyle
    282 # ifdef Q_WS_WIN
     282# ifdef VBOX_WS_WIN
    283283        /* There is a Qt bug about Windows7 do NOT match conditions for 'aero' wizard-style,
    284284         * so its silently fallbacks to 'modern' one without any notification,
    285285         * so QWizard::wizardStyle() returns QWizard::ModernStyle, while using aero, at least partially. */
    286286        && QSysInfo::windowsVersion() != QSysInfo::WV_WINDOWS7
    287 # endif /* Q_WS_WIN */
     287# endif /* VBOX_WS_WIN */
    288288        )
    289289        m_strWatermarkName = strWatermark;
    … …  
    373373    double dRatio = 1.6;
    374374
    375 #ifdef Q_WS_WIN
     375#ifdef VBOX_WS_WIN
    376376    switch (wizardStyle())
    377377    {
    … …  
    392392            break;
    393393    }
    394 #endif /* Q_WS_WIN */
     394#endif /* VBOX_WS_WIN */
    395395
    396396    switch (m_type)
    … …  
    417417}
    418418
    419 #ifndef Q_WS_MAC
     419#ifndef VBOX_WS_MAC
    420420int UIWizard::proposedWatermarkHeight()
    421421{
    … …  
    516516    setPixmap(QWizard::WatermarkPixmap, pixWatermarkNew);
    517517}
    518 #endif /* !Q_WS_MAC */
    519 
     518#endif /* !VBOX_WS_MAC */
     519

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/UIWizard.h

    r55401 r60362  
    6767
    6868    /* Design stuff: */
    69 #ifndef Q_WS_MAC
     69#ifndef VBOX_WS_MAC
    7070    void assignWatermark(const QString &strWaterMark);
    7171#else
    … …  
    8282    void resizeAccordingLabelWidth(int iLabelWidth);
    8383    double ratio();
    84 #ifndef Q_WS_MAC
     84#ifndef VBOX_WS_MAC
    8585    int proposedWatermarkHeight();
    8686    void assignWatermarkHelper();
    87 #endif /* !Q_WS_MAC */
     87#endif /* !VBOX_WS_MAC */
    8888
    8989    /* Variables: */
    9090    WizardType m_type;
    9191    WizardMode m_mode;
    92 #ifndef Q_WS_MAC
     92#ifndef VBOX_WS_MAC
    9393    QString m_strWatermarkName;
    94 #endif /* !Q_WS_MAC */
     94#endif /* !VBOX_WS_MAC */
    9595};
    9696

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVD.cpp

    r56180 r60362  
    4343    , m_sourceVirtualDisk(sourceVirtualDisk)
    4444{
    45 #ifndef Q_WS_MAC
     45#ifndef VBOX_WS_MAC
    4646    /* Assign watermark: */
    4747    assignWatermark(":/vmw_new_harddisk.png");
    48 #else /* Q_WS_MAC */
     48#else /* VBOX_WS_MAC */
    4949    /* Assign background image: */
    5050    assignBackground(":/vmw_new_harddisk_bg.png");
    51 #endif /* Q_WS_MAC */
     51#endif /* VBOX_WS_MAC */
    5252}
    5353

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevm/UIWizardCloneVM.cpp

    r55977 r60362  
    4040    , m_snapshot(snapshot)
    4141{
    42 #ifndef Q_WS_MAC
     42#ifndef VBOX_WS_MAC
    4343    /* Assign watermark: */
    4444    assignWatermark(":/vmw_clone.png");
    45 #else /* Q_WS_MAC */
     45#else /* VBOX_WS_MAC */
    4646    /* Assign background image: */
    4747    assignBackground(":/vmw_clone_bg.png");
    48 #endif /* Q_WS_MAC */
     48#endif /* VBOX_WS_MAC */
    4949}
    5050

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/exportappliance/UIWizardExportApp.cpp

    r55509 r60362  
    4747    , m_selectedVMNames(selectedVMNames)
    4848{
    49 #ifndef Q_WS_MAC
     49#ifndef VBOX_WS_MAC
    5050    /* Assign watermark: */
    5151    assignWatermark(":/vmw_ovf_export.png");
    52 #else /* Q_WS_MAC */
     52#else /* VBOX_WS_MAC */
    5353    /* Assign background image: */
    5454    assignBackground(":/vmw_ovf_export_bg.png");
    55 #endif /* Q_WS_MAC */
     55#endif /* VBOX_WS_MAC */
    5656}
    5757

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/firstrun/UIWizardFirstRun.cpp

    r52730 r60362  
    3939    , m_fHardDiskWasSet(isBootHardDiskAttached(m_machine))
    4040{
    41 #ifndef Q_WS_MAC
     41#ifndef VBOX_WS_MAC
    4242    /* Assign watermark: */
    4343    assignWatermark(":/vmw_first_run.png");
    44 #else /* Q_WS_MAC */
     44#else /* VBOX_WS_MAC */
    4545    /* Assign background image: */
    4646    assignBackground(":/vmw_first_run_bg.png");
    47 #endif /* Q_WS_MAC */
     47#endif /* VBOX_WS_MAC */
    4848}
    4949

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/importappliance/UIWizardImportApp.cpp

    r52733 r60362  
    145145    , m_strFileName(strFileName)
    146146{
    147 #ifndef Q_WS_MAC
     147#ifndef VBOX_WS_MAC
    148148    /* Assign watermark: */
    149149    assignWatermark(":/vmw_ovf_import.png");
    150 #else /* Q_WS_MAC */
     150#else /* VBOX_WS_MAC */
    151151    /* Assign background image: */
    152152    assignBackground(":/vmw_ovf_import_bg.png");
    153 #endif /* Q_WS_MAC */
     153#endif /* VBOX_WS_MAC */
    154154}
    155155

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVD.cpp

    r56180 r60362  
    4848    , m_uDefaultSize(uDefaultSize)
    4949{
    50 #ifndef Q_WS_MAC
     50#ifndef VBOX_WS_MAC
    5151    /* Assign watermark: */
    5252    assignWatermark(":/vmw_new_harddisk.png");
    53 #else /* Q_WS_MAC */
     53#else /* VBOX_WS_MAC */
    5454    /* Assign background image: */
    5555    assignBackground(":/vmw_new_harddisk_bg.png");
    56 #endif /* Q_WS_MAC */
     56#endif /* VBOX_WS_MAC */
    5757}
    5858

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvm/UIWizardNewVM.cpp

    r58684 r60362  
    5353    , m_iUSBCount(0)
    5454{
    55 #ifndef Q_WS_MAC
     55#ifndef VBOX_WS_MAC
    5656    /* Assign watermark: */
    5757    assignWatermark(":/vmw_new_welcome.png");
    58 #else /* Q_WS_MAC */
     58#else /* VBOX_WS_MAC */
    5959    /* Assign background image: */
    6060    assignBackground(":/vmw_new_welcome_bg.png");
    61 #endif /* Q_WS_MAC */
     61#endif /* VBOX_WS_MAC */
    6262}
    6363
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