VirtualBox

Changeset 100064 in vbox


Ignore:
Timestamp:
Jun 4, 2023 9:10:01 AM (18 months ago)
Author:
vboxsync
Message:

FE/Qt: bugref:10421. Replacing VBOX_WS_X11 with VBOX_WS_NIX.

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

Legend:

Unmodified
Added
Removed

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

    r99941 r100064  
    115115endif
    116116VirtualBox_DEFS.debug     = VBOX_CHECK_STATE # QT_FATAL_ASSERT
    117 VirtualBox_DEFS.linux     = VBOX_WS_X11 QT_NO_DEPRECATED_WARNINGS
    118 VirtualBox_DEFS.solaris   = VBOX_WS_X11
    119 VirtualBox_DEFS.freebsd   = VBOX_WS_X11
     117VirtualBox_DEFS.linux     = VBOX_WS_NIX QT_NO_DEPRECATED_WARNINGS
     118VirtualBox_DEFS.solaris   = VBOX_WS_NIX
     119VirtualBox_DEFS.freebsd   = VBOX_WS_NIX
    120120VirtualBox_DEFS.darwin    = VBOX_WS_MAC
    121121VirtualBox_DEFS.win       = VBOX_WS_WIN
    … …  
    177177endif
    178178VirtualBoxVM_DEFS.debug     = VBOX_CHECK_STATE # QT_FATAL_ASSERT
    179 VirtualBoxVM_DEFS.linux     = VBOX_WS_X11 QT_NO_DEPRECATED_WARNINGS
    180 VirtualBoxVM_DEFS.solaris   = VBOX_WS_X11
    181 VirtualBoxVM_DEFS.freebsd   = VBOX_WS_X11
     179VirtualBoxVM_DEFS.linux     = VBOX_WS_NIX QT_NO_DEPRECATED_WARNINGS
     180VirtualBoxVM_DEFS.solaris   = VBOX_WS_NIX
     181VirtualBoxVM_DEFS.freebsd   = VBOX_WS_NIX
    182182VirtualBoxVM_DEFS.darwin    = VBOX_WS_MAC
    183183VirtualBoxVM_DEFS.win       = VBOX_WS_WIN
    … …  
    237237endif
    238238UICommon_DEFS.darwin  = VBOX_WS_MAC
    239 UICommon_DEFS.freebsd = VBOX_WS_X11
    240 UICommon_DEFS.linux   = VBOX_WS_X11 QT_NO_DEPRECATED_WARNINGS
    241 UICommon_DEFS.solaris = VBOX_WS_X11
     239UICommon_DEFS.freebsd = VBOX_WS_NIX
     240UICommon_DEFS.linux   = VBOX_WS_NIX QT_NO_DEPRECATED_WARNINGS
     241UICommon_DEFS.solaris = VBOX_WS_NIX
    242242UICommon_DEFS.win     = VBOX_WS_WIN
    243243UICommon_DEFS.debug   = VBOX_CHECK_STATE # QT_FATAL_ASSERT

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

    r98999 r100064  
    813813        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_SoftKeyboard:       strResult = "SoftKeyboard"; break;
    814814        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCAD:            strResult = "TypeCAD"; break;
    815 #ifdef VBOX_WS_X11
     815#ifdef VBOX_WS_NIX
    816816        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCABS:           strResult = "TypeCABS"; break;
    817 #endif /* VBOX_WS_X11 */
     817#endif /* VBOX_WS_NIX */
    818818        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCtrlBreak:      strResult = "TypeCtrlBreak"; break;
    819819        case UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeInsert:         strResult = "TypeInsert"; break;
    … …  
    845845    if (strRuntimeMenuInputActionType.compare("TypeCAD", Qt::CaseInsensitive) == 0)
    846846        return UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCAD;
    847 #ifdef VBOX_WS_X11
     847#ifdef VBOX_WS_NIX
    848848    if (strRuntimeMenuInputActionType.compare("TypeCABS", Qt::CaseInsensitive) == 0)
    849849        return UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCABS;
    850 #endif /* VBOX_WS_X11 */
     850#endif /* VBOX_WS_NIX */
    851851    if (strRuntimeMenuInputActionType.compare("TypeCtrlBreak", Qt::CaseInsensitive) == 0)
    852852        return UIExtraDataMetaDefs::RuntimeMenuInputActionType_TypeCtrlBreak;

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

    r98103 r100064  
    3030
    3131/* External includes: */
    32 #ifdef VBOX_WS_X11
     32#ifdef VBOX_WS_NIX
    3333# include <sys/wait.h>
    3434#endif
    … …  
    6262        result = process.readAllStandardOutput();
    6363    process.setProcessState(QProcess::NotRunning);
    64 #ifdef VBOX_WS_X11
     64#ifdef VBOX_WS_NIX
    6565    int iStatus;
    6666    if (process.processId() > 0)
    6767        waitpid(process.processId(), &iStatus, 0);
    68 #endif /* VBOX_WS_X11 */
     68#endif /* VBOX_WS_NIX */
    6969    return result;
    7070}

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

    r99184 r100064  
    180180const char *UIExtraDataDefs::GUI_Seamless = "GUI/Seamless";
    181181const char *UIExtraDataDefs::GUI_Scale = "GUI/Scale";
    182 #ifdef VBOX_WS_X11
     182#ifdef VBOX_WS_NIX
    183183const char *UIExtraDataDefs::GUI_Fullscreen_LegacyMode = "GUI/Fullscreen/LegacyMode";
    184184const char *UIExtraDataDefs::GUI_DistinguishMachineWindowGroups = "GUI/DistinguishMachineWindowGroups";
    185 #endif /* VBOX_WS_X11 */
     185#endif /* VBOX_WS_NIX */
    186186const char *UIExtraDataDefs::GUI_AutoresizeGuest = "GUI/AutoresizeGuest";
    187187const char *UIExtraDataDefs::GUI_LastVisibilityStatusForGuestScreen = "GUI/LastVisibilityStatusForGuestScreen";

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

    r99184 r100064  
    331331        /** Holds whether scaled visual-state is requested. */
    332332        SHARED_LIBRARY_STUFF extern const char *GUI_Scale;
    333 #ifdef VBOX_WS_X11
     333#ifdef VBOX_WS_NIX
    334334        /** Holds whether legacy full-screen mode is requested. */
    335335        SHARED_LIBRARY_STUFF extern const char *GUI_Fullscreen_LegacyMode;
    336336        /** Holds whether internal machine-window names should be unique. */
    337337        SHARED_LIBRARY_STUFF extern const char *GUI_DistinguishMachineWindowGroups;
    338 #endif /* VBOX_WS_X11 */
     338#endif /* VBOX_WS_NIX */
    339339        /** Holds whether guest-screen auto-resize according machine-window size is enabled. */
    340340        SHARED_LIBRARY_STUFF extern const char *GUI_AutoresizeGuest;
    … …  
    643643        RuntimeMenuInputActionType_SoftKeyboard       = RT_BIT(2),
    644644        RuntimeMenuInputActionType_TypeCAD            = RT_BIT(3),
    645 #ifdef VBOX_WS_X11
     645#ifdef VBOX_WS_NIX
    646646        RuntimeMenuInputActionType_TypeCABS           = RT_BIT(4),
    647647#endif

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

    r99946 r100064  
    19771977           << GUI_RestrictedVisualStates
    19781978           << GUI_Fullscreen << GUI_Seamless << GUI_Scale
    1979 #ifdef VBOX_WS_X11
     1979#ifdef VBOX_WS_NIX
    19801980           << GUI_Fullscreen_LegacyMode
    19811981           << GUI_DistinguishMachineWindowGroups
    … …  
    26002600#elif defined (VBOX_WS_WIN)
    26012601        strHostCombo = "163"; // VK_RCONTROL
    2602 #elif defined (VBOX_WS_X11)
     2602#elif defined (VBOX_WS_NIX)
    26032603        strHostCombo = "65508"; // XK_Control_R
    26042604#else
    … …  
    26552655    if (strAutoCapture.isEmpty())
    26562656    {
    2657 #if defined(VBOX_WS_X11) && defined(DEBUG)
     2657#if defined(VBOX_WS_NIX) && defined(DEBUG)
    26582658        fAutoCapture = false;
    26592659#else
    … …  
    38343834}
    38353835
    3836 #ifdef VBOX_WS_X11
     3836#ifdef VBOX_WS_NIX
    38373837bool UIExtraDataManager::legacyFullscreenModeRequested()
    38383838{
    … …  
    38523852    setExtraDataString(GUI_DistinguishMachineWindowGroups, toFeatureAllowed(fEnabled), uID);
    38533853}
    3854 #endif /* VBOX_WS_X11 */
     3854#endif /* VBOX_WS_NIX */
    38553855
    38563856bool UIExtraDataManager::guestScreenAutoResizeEnabled(const QUuid &uID)
    … …  
    48274827            else if (strKey == GUI_CloudConsoleManager_Restrictions)
    48284828                emit sigCloudConsoleManagerRestrictionChange();
    4829 #if defined(VBOX_WS_X11) || defined(VBOX_WS_WIN)
     4829#if defined(VBOX_WS_NIX) || defined(VBOX_WS_WIN)
    48304830            else if (strKey == GUI_DisableHostScreenSaver)
    48314831                emit sigDisableHostScreenSaverStateChange(isFeatureAllowed(GUI_DisableHostScreenSaver));

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

    r99184 r100064  
    134134#endif /* VBOX_WS_MAC */
    135135
    136 #if defined (VBOX_WS_X11) || defined (VBOX_WS_WIN)
     136#if defined (VBOX_WS_NIX) || defined (VBOX_WS_WIN)
    137137    /* Is emitted when host screen saver inhibition state changes. */
    138138    void sigDisableHostScreenSaverStateChange(bool fDisable);
    … …  
    612612        void setRequestedVisualState(UIVisualStateType visualState, const QUuid &uID);
    613613
    614 #ifdef VBOX_WS_X11
     614#ifdef VBOX_WS_NIX
    615615        /** Returns whether legacy full-screen mode is requested. */
    616616        bool legacyFullscreenModeRequested();
    … …  
    620620        /** Defines whether internal machine-window name should be unique. */
    621621        void setDistinguishMachineWindowGroups(const QUuid &uID, bool fEnabled);
    622 #endif /* VBOX_WS_X11 */
     622#endif /* VBOX_WS_NIX */
    623623
    624624        /** Returns whether guest-screen auto-resize according machine-window size is enabled. */

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

    r98103 r100064  
    4242# include "VBoxUtils-darwin.h"
    4343#endif
    44 #ifdef VBOX_WS_X11
     44#ifdef VBOX_WS_NIX
    4545# include "UICommon.h"
    4646# include "UIDesktopWidgetWatchdog.h"
    … …  
    7171        QMainWindow::moveEvent(pEvent);
    7272
    73 #ifdef VBOX_WS_X11
     73#ifdef VBOX_WS_NIX
    7474        /* Prevent further handling if fake screen detected: */
    7575        if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    … …  
    9696        QMainWindow::resizeEvent(pEvent);
    9797
    98 #ifdef VBOX_WS_X11
     98#ifdef VBOX_WS_NIX
    9999        /* Prevent handling if fake screen detected: */
    100100        if (UIDesktopWidgetWatchdog::isFakeScreenDetected())

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

    r98103 r100064  
    16941694};
    16951695
    1696 #ifdef VBOX_WS_X11
     1696#ifdef VBOX_WS_NIX
    16971697/** X11: Simple action extension, used as 'Perform Type CABS' action class. */
    16981698class UIActionSimpleRuntimePerformTypeCABS : public UIActionSimple
    … …  
    17441744    }
    17451745};
    1746 #endif /* VBOX_WS_X11 */
     1746#endif /* VBOX_WS_NIX */
    17471747
    17481748/** Simple action extension, used as 'Perform Type Ctrl Break' action class. */
    … …  
    33473347    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_SoftKeyboard] = new UIActionSimpleRuntimeShowSoftKeyboard(this);
    33483348    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD] = new UIActionSimpleRuntimePerformTypeCAD(this);
    3349 #ifdef VBOX_WS_X11
     3349#ifdef VBOX_WS_NIX
    33503350    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS] = new UIActionSimpleRuntimePerformTypeCABS(this);
    3351 #endif /* VBOX_WS_X11 */
     3351#endif /* VBOX_WS_NIX */
    33523352    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak] = new UIActionSimpleRuntimePerformTypeCtrlBreak(this);
    33533353    m_pool[UIActionIndexRT_M_Input_M_Keyboard_S_TypeInsert] = new UIActionSimpleRuntimePerformTypeInsert(this);
    … …  
    42364236    /* 'Type CAD' action: */
    42374237    fSeparator = addAction(pMenu, action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD)) || fSeparator;
    4238 #ifdef VBOX_WS_X11
     4238#ifdef VBOX_WS_NIX
    42394239    /* 'Type CABS' action: */
    42404240    fSeparator = addAction(pMenu, action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS)) || fSeparator;

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

    r98103 r100064  
    9494    UIActionIndexRT_M_Input_M_Keyboard_S_SoftKeyboard,
    9595    UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD,
    96 #ifdef VBOX_WS_X11
     96#ifdef VBOX_WS_NIX
    9797    UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS,
    9898#endif

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

    r100033 r100064  
    8888# include "VBoxUtils-win.h"
    8989#endif
    90 #ifdef VBOX_WS_X11
     90#ifdef VBOX_WS_NIX
    9191# include "UIHostComboEditor.h"
    9292#endif
    … …  
    142142# include <sys/utsname.h>
    143143#endif
    144 #ifdef VBOX_WS_X11
     144#ifdef VBOX_WS_NIX
    145145# include <xcb/xcb.h>
    146146#endif
    … …  
    189189    , m_fDataCommitted(false)
    190190#endif
    191 #ifdef VBOX_WS_X11
     191#ifdef VBOX_WS_NIX
    192192    , m_enmWindowManagerType(X11WMType_Unknown)
    193193    , m_fCompositingManagerRunning(false)
    … …  
    243243#endif /* VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    244244
    245 #ifdef VBOX_WS_X11
     245#ifdef VBOX_WS_NIX
    246246    /* Detect display server type: */
    247247    m_enmDisplayServerType = VBGHDisplayServerTypeDetect();
    … …  
    329329    UIVisualStateType visualStateType = UIVisualStateType_Invalid;
    330330
    331 #ifdef VBOX_WS_X11
     331#ifdef VBOX_WS_NIX
    332332    /* Check whether we have compositing manager running: */
    333333    m_fCompositingManagerRunning = NativeWindowSubsystem::isCompositingManagerRunning(X11ServerAvailable());
    … …  
    335335    /* Acquire current Window Manager type: */
    336336    m_enmWindowManagerType = NativeWindowSubsystem::windowManagerType(X11ServerAvailable());
    337 #endif /* VBOX_WS_X11 */
     337#endif /* VBOX_WS_NIX */
    338338
    339339#ifdef VBOX_WITH_DEBUGGER_GUI
    … …  
    12011201        return true;
    12021202
    1203 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     1203#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    12041204
    12051205    return UIDesktopWidgetWatchdog::activateWindow(id, true);
    … …  
    12881288    AllowSetForegroundWindow(ASFW_ANY);
    12891289#endif
    1290 #ifdef VBOX_WS_X11
     1290#ifdef VBOX_WS_NIX
    12911291    /* Make sure VM process will start on the same
    12921292     * display as window this wrapper is called from: */
    … …  
    27792779        refreshMedia();
    27802780
    2781 #ifdef VBOX_WS_X11
     2781#ifdef VBOX_WS_NIX
    27822782    // WORKAROUND:
    27832783    // As X11 do not have functionality for providing human readable key names,
    … …  
    30323032}
    30333033
    3034 #ifdef VBOX_WS_X11
     3034#ifdef VBOX_WS_NIX
    30353035bool UICommon::X11ServerAvailable() const
    30363036{

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

    r100027 r100064  
    4141#include "UILibraryDefs.h"
    4242#include "UIMediumDefs.h"
    43 #ifdef VBOX_WS_X11
     43#ifdef VBOX_WS_NIX
    4444# include "VBoxUtils-nix.h"
    4545#endif
    … …  
    212212#endif
    213213
    214 #ifdef VBOX_WS_X11
     214#ifdef VBOX_WS_NIX
    215215        /** X11: Returns the type of the Window Manager we are running under. */
    216216        X11WMType typeOfWindowManager() const { return m_enmWindowManagerType; }
    … …  
    656656    /** @name Host OS stuff.
    657657     * @{ */
    658 #ifdef VBOX_WS_X11
     658#ifdef VBOX_WS_NIX
    659659        /** X11: Holds the #X11WMType of the Window Manager we are running under. */
    660660        X11WMType             m_enmWindowManagerType;

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

    r99438 r100064  
    4141        return;
    4242
    43 #ifdef VBOX_WS_X11
     43#ifdef VBOX_WS_NIX
    4444    /* As reported in https://www.virtualbox.org/ticket/16348,
    4545     * in X11 QWidget::setCursor(..) call uses RENDER
    … …  
    6767        return;
    6868
    69 #ifdef VBOX_WS_X11
     69#ifdef VBOX_WS_NIX
    7070    /* As reported in https://www.virtualbox.org/ticket/16348,
    7171     * in X11 QGraphicsWidget::setCursor(..) call uses RENDER
    … …  
    9393        return;
    9494
    95 #ifdef VBOX_WS_X11
     95#ifdef VBOX_WS_NIX
    9696    /* As reported in https://www.virtualbox.org/ticket/16348,
    9797     * in X11 QWidget::unsetCursor(..) call uses RENDER
    … …  
    119119        return;
    120120
    121 #ifdef VBOX_WS_X11
     121#ifdef VBOX_WS_NIX
    122122    /* As reported in https://www.virtualbox.org/ticket/16348,
    123123     * in X11 QGraphicsWidget::unsetCursor(..) call uses RENDER

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

    r99479 r100064  
    3333# include <QLibrary>
    3434#endif
    35 #ifdef VBOX_WS_X11
     35#ifdef VBOX_WS_NIX
    3636# include <QTimer>
    3737#endif
    … …  
    4848# include "VBoxUtils-win.h"
    4949#endif
    50 #ifdef VBOX_WS_X11
     50#ifdef VBOX_WS_NIX
    5151# include "UICommon.h"
    5252# include "VBoxUtils-nix.h"
    … …  
    6767/* External includes: */
    6868#include <math.h>
    69 #ifdef VBOX_WS_X11
     69#ifdef VBOX_WS_NIX
    7070# include <xcb/xcb.h>
    7171#endif
    … …  
    122122
    123123
    124 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     124#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    125125
    126126/** QWidget extension used as
    … …  
    252252}
    253253
    254 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     254#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    255255
    256256
    … …  
    287287
    288288UIDesktopWidgetWatchdog::UIDesktopWidgetWatchdog()
    289 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     289#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    290290    : m_enmSynthTestPolicy(DesktopWatchdogPolicy_SynthTest_Both)
    291291#endif
    … …  
    382382QRect UIDesktopWidgetWatchdog::availableGeometry(QScreen *pScreen) const
    383383{
    384 #ifdef VBOX_WS_X11
     384#ifdef VBOX_WS_NIX
    385385# ifdef VBOX_GUI_WITH_CUSTOMIZATIONS1
    386386    // WORKAROUND:
    … …  
    394394    return availableGeometry.isValid() ? availableGeometry : screenGeometry(pScreen);
    395395# endif /* !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    396 #else /* !VBOX_WS_X11 */
     396#else /* !VBOX_WS_NIX */
    397397    /* Just return screen available-geometry: */
    398398    return pScreen->availableGeometry();
    399 #endif /* !VBOX_WS_X11 */
     399#endif /* !VBOX_WS_NIX */
    400400}
    401401
    … …  
    471471}
    472472
    473 #ifdef VBOX_WS_X11
     473#ifdef VBOX_WS_NIX
    474474/* static */
    475475bool UIDesktopWidgetWatchdog::isFakeScreenDetected()
    … …  
    484484           || (qApp->screens().size() == 1 && qApp->screens().first()->name() == ":0.0");
    485485}
    486 #endif /* VBOX_WS_X11 */
     486#endif /* VBOX_WS_NIX */
    487487
    488488/* static */
    … …  
    788788{
    789789    AssertPtrReturnVoid(pWidget);
    790 #ifdef VBOX_WS_X11
     790#ifdef VBOX_WS_NIX
    791791# define QWINDOWSIZE_MAX ((1<<24)-1)
    792792    if (pWidget->isWindow() && pWidget->isVisible() && uiCommon().X11ServerAvailable())
    … …  
    839839        // Configure event will arrive to tell Qt what geometry we want.
    840840        pWidget->setGeometry(x, y, w, h);
    841 # else /* !VBOX_WS_X11 */
     841# else /* !VBOX_WS_NIX */
    842842    pWidget->setGeometry(x, y, w, h);
    843 # endif /* !VBOX_WS_X11 */
     843# endif /* !VBOX_WS_NIX */
    844844}
    845845
    … …  
    860860    fResult &= NativeWindowSubsystem::WinActivateWindow(wId, fSwitchDesktop);
    861861
    862 #elif defined(VBOX_WS_X11)
     862#elif defined(VBOX_WS_NIX)
    863863
    864864    fResult &= NativeWindowSubsystem::activateWindow(uiCommon().X11ServerAvailable(), wId, fSwitchDesktop);
    … …  
    889889            this, &UIDesktopWidgetWatchdog::sltHandleHostScreenWorkAreaResized);
    890890
    891 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     891#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    892892    /* Update host-screen configuration: */
    893893    updateHostScreenConfiguration();
    894 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     894#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    895895
    896896    /* Notify listeners: */
    … …  
    908908               this, &UIDesktopWidgetWatchdog::sltHandleHostScreenWorkAreaResized);
    909909
    910 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     910#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    911911    /* Update host-screen configuration: */
    912912    updateHostScreenConfiguration();
    913 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     913#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    914914
    915915    /* Notify listeners: */
    … …  
    931931            geometry.width(), geometry.height()));
    932932
    933 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     933#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    934934    /* Update host-screen available-geometry: */
    935935    updateHostScreenAvailableGeometry(iHostScreenIndex);
    936 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     936#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    937937
    938938    /* Notify listeners: */
    … …  
    954954            availableGeometry.width(), availableGeometry.height()));
    955955
    956 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     956#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    957957    /* Update host-screen available-geometry: */
    958958    updateHostScreenAvailableGeometry(iHostScreenIndex);
    959 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     959#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    960960
    961961    /* Notify listeners: */
    … …  
    963963}
    964964
    965 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     965#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    966966void UIDesktopWidgetWatchdog::sltHandleHostScreenAvailableGeometryCalculated(int iHostScreenIndex, QRect availableGeometry)
    967967{
    … …  
    984984        emit sigHostScreenWorkAreaRecalculated(iHostScreenIndex);
    985985}
    986 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     986#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    987987
    988988void UIDesktopWidgetWatchdog::prepare()
    … …  
    10011001    }
    10021002
    1003 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     1003#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    10041004    /* Load Synthetic Test policy: */
    10051005    const QString strSynthTestPolicy = QString::fromLocal8Bit(qgetenv(VBox_DesktopWatchdogPolicy_SynthTest));
    … …  
    10081008    /* Update host-screen configuration: */
    10091009    updateHostScreenConfiguration();
    1010 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     1010#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    10111011}
    10121012
    … …  
    10261026    }
    10271027
    1028 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     1028#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    10291029    /* Cleanup existing workers finally: */
    10301030    cleanupExistingWorkers();
    1031 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     1031#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    10321032}
    10331033
    … …  
    10601060}
    10611061
    1062 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     1062#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    10631063bool UIDesktopWidgetWatchdog::isSynchTestRestricted() const
    10641064{
    … …  
    11411141
    11421142# include "UIDesktopWidgetWatchdog.moc"
    1143 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     1143#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */

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

    r98999 r100064  
    3535#include <QObject>
    3636#include <QWindow>
    37 #ifdef VBOX_WS_X11
     37#ifdef VBOX_WS_NIX
    3838# include <QRect>
    3939# include <QVector>
    … …  
    4242/* GUI includes: */
    4343#include "UILibraryDefs.h"
    44 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     44#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    4545# include "UIDefs.h"
    4646#endif
    … …  
    7171    void sigHostScreenWorkAreaResized(int iHostScreenIndex);
    7272
    73 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     73#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    7474    /** Notifies about work-area recalculated for the host-screen with @a iHostScreenIndex. */
    7575    void sigHostScreenWorkAreaRecalculated(int iHostScreenIndex);
    … …  
    121121    static QRegion overallAvailableRegion();
    122122
    123 #ifdef VBOX_WS_X11
     123#ifdef VBOX_WS_NIX
    124124    /** Qt5: X11: Returns whether no or fake screen detected. */
    125125    static bool isFakeScreenDetected();
    … …  
    175175    void sltHandleHostScreenWorkAreaResized(const QRect &availableGeometry);
    176176
    177 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     177#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    178178    /** Handles @a availableGeometry calculation result for the host-screen with @a iHostScreenIndex. */
    179179    void sltHandleHostScreenAvailableGeometryCalculated(int iHostScreenIndex, QRect availableGeometry);
    … …  
    196196    static UIDesktopWidgetWatchdog *s_pInstance;
    197197
    198 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     198#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    199199    /** Returns whether Synthetic Test is restricted according to cached policy. */
    200200    bool isSynchTestRestricted() const;
    … …  
    217217    /** Holds current workers determining host-screen available-geometries. */
    218218    QVector<QWidget*> m_availableGeometryWorkers;
    219 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     219#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    220220};
    221221

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

    r99946 r100064  
    513513    QString err = tr("<p>Failed to acquire the VirtualBox COM object.</p>"
    514514                     "<p>The application will now terminate.</p>");
    515 #if defined(VBOX_WS_X11) || defined(VBOX_WS_MAC)
     515#if defined(VBOX_WS_NIX) || defined(VBOX_WS_MAC)
    516516    if (comClient.lastRC() == NS_ERROR_SOCKET_FAIL)
    517517        err += tr("<p>The reason for this error are most likely wrong permissions of the IPC "

  • trunk/src/VBox/Frontends/VirtualBox/src/helpbrowser/UIHelpBrowserWidget.cpp

    r99910 r100064  
    19831983void UIHelpBrowserWidget::sltShowPrintDialog()
    19841984{
    1985 #ifdef VBOX_WS_X11
     1985#ifdef VBOX_WS_NIX
    19861986    if (!m_pTabManager)
    19871987        return;

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

    r99836 r100064  
    2929#include <QApplication>
    3030#include <QMessageBox>
    31 #ifdef VBOX_WS_X11
     31#ifdef VBOX_WS_NIX
    3232# ifndef Q_OS_SOLARIS
    3333#  include <QFontDatabase>
    … …  
    5656# endif
    5757#endif
    58 #ifdef VBOX_WS_X11
     58#ifdef VBOX_WS_NIX
    5959# include <iprt/env.h>
    6060#endif
    … …  
    7171# include <sys/mman.h>
    7272#endif /* VBOX_WS_MAC */
    73 #ifdef VBOX_WS_X11
     73#ifdef VBOX_WS_NIX
    7474# include <dlfcn.h>
    7575# include <unistd.h>
    … …  
    8989#  endif /* !RT_ARCH_AMD64 */
    9090# endif /* RT_OS_LINUX && DEBUG */
    91 #endif /* VBOX_WS_X11 */
     91#endif /* VBOX_WS_NIX */
    9292
    9393
    … …  
    135135
    136136
    137 #ifdef VBOX_WS_X11
     137#ifdef VBOX_WS_NIX
    138138/** X11: For versions of Xlib which are aware of multi-threaded environments this function
    139139  *      calls for XInitThreads() which initializes Xlib support for concurrent threads.
    … …  
    206206}
    207207# endif /* RT_OS_LINUX && DEBUG */
    208 #endif /* VBOX_WS_X11 */
     208#endif /* VBOX_WS_NIX */
    209209
    210210/** Qt5 message handler, function that prints out
    … …  
    216216{
    217217    NOREF(context);
    218 # ifndef VBOX_WS_X11
     218# ifndef VBOX_WS_NIX
    219219    NOREF(strMessage);
    220220# endif
    … …  
    226226        case QtWarningMsg:
    227227            Log(("Qt WARNING: %s\n", strMessage.toUtf8().constData()));
    228 # ifdef VBOX_WS_X11
     228# ifdef VBOX_WS_NIX
    229229            /* Needed for instance for the message ``cannot connect to X server'': */
    230230            RTStrmPrintf(g_pStdErr, "Qt WARNING: %s\n", strMessage.toUtf8().constData());
    … …  
    233233        case QtCriticalMsg:
    234234            Log(("Qt CRITICAL: %s\n", strMessage.toUtf8().constData()));
    235 # ifdef VBOX_WS_X11
     235# ifdef VBOX_WS_NIX
    236236            /* Needed for instance for the message ``cannot connect to X server'': */
    237237            RTStrmPrintf(g_pStdErr, "Qt CRITICAL: %s\n", strMessage.toUtf8().constData());
    … …  
    240240        case QtFatalMsg:
    241241            Log(("Qt FATAL: %s\n", strMessage.toUtf8().constData()));
    242 # ifdef VBOX_WS_X11
     242# ifdef VBOX_WS_NIX
    243243            /* Needed for instance for the message ``cannot connect to X server'': */
    244244            RTStrmPrintf(g_pStdErr, "Qt FATAL: %s\n", strMessage.toUtf8().constData());
    … …  
    392392    do
    393393    {
    394 #ifdef VBOX_WS_X11
     394#ifdef VBOX_WS_NIX
    395395        /* Make sure multi-threaded environment is safe: */
    396396        if (!MakeSureMultiThreadingIsSafe())
    … …  
    406406            /* Assume pure Wayland (without a X server):*/
    407407            RTEnvSet("QT_QPA_PLATFORM", "wayland");
    408 #endif /* VBOX_WS_X11 */
     408#endif /* VBOX_WS_NIX */
    409409
    410410        /* Console help preprocessing: */
    … …  
    453453#endif /* VBOX_WS_MAC */
    454454
    455 #ifdef VBOX_WS_X11
     455#ifdef VBOX_WS_NIX
    456456# if defined(RT_OS_LINUX) && defined(DEBUG)
    457457        /* Install signal handler to backtrace the call stack: */
    458458        InstallSignalHandler();
    459459# endif /* RT_OS_LINUX && DEBUG */
    460 #endif /* VBOX_WS_X11 */
     460#endif /* VBOX_WS_NIX */
    461461
    462462        /* Install Qt console message handler: */
    … …  
    492492#endif /* VBOX_WS_WIN */
    493493
    494 #ifdef VBOX_WS_X11
     494#ifdef VBOX_WS_NIX
    495495        /* Make all widget native.
    496496         * We did it to avoid various Qt crashes while testing widget attributes or acquiring winIds.
    … …  
    526526            break;
    527527        }
    528 #endif /* VBOX_WS_X11 */
     528#endif /* VBOX_WS_NIX */
    529529
    530530        /* Create modal-window manager: */
    … …  
    638638int main(int argc, char **argv, char **envp)
    639639{
    640 # ifdef VBOX_WS_X11
     640# ifdef VBOX_WS_NIX
    641641    /* Make sure multi-threaded environment is safe: */
    642642    if (!MakeSureMultiThreadingIsSafe())
    643643        return 1;
    644 # endif /* VBOX_WS_X11 */
     644# endif /* VBOX_WS_NIX */
    645645
    646646    /*
    … …  
    857857    }
    858858
    859 # ifdef VBOX_WS_X11
     859# ifdef VBOX_WS_NIX
    860860    /* We have to to make sure that we display the error-message
    861861     * after the parent displayed its own message. */
    862862    sleep(2);
    863 # endif /* VBOX_WS_X11 */
     863# endif /* VBOX_WS_NIX */
    864864
    865865    /* Update strText with strDetails: */

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

    r100027 r100064  
    9292# include "UIMenuBar.h"
    9393#endif
    94 #ifdef VBOX_WS_X11
     94#ifdef VBOX_WS_NIX
    9595# include "UIDesktopWidgetWatchdog.h"
    9696#endif
    … …  
    623623}
    624624
    625 #ifdef VBOX_WS_X11
     625#ifdef VBOX_WS_NIX
    626626void UIVirtualBoxManager::sltHandleHostScreenAvailableAreaChange()
    627627{
    … …  
    635635    move(geo.topLeft());
    636636}
    637 #endif /* VBOX_WS_X11 */
     637#endif /* VBOX_WS_NIX */
    638638
    639639void UIVirtualBoxManager::sltHandleCommitData()
    … …  
    15251525    /* Execute console application finally: */
    15261526    QProcess::startDetached(QString("%1 %2").arg(strPath, arguments.join(' ')));
    1527 #elif defined(VBOX_WS_X11)
     1527#elif defined(VBOX_WS_NIX)
    15281528    /* Gather arguments: */
    15291529    QStringList arguments;
    … …  
    15331533    /* Execute console application finally: */
    15341534    QProcess::startDetached(strPath, arguments);
    1535 #endif /* VBOX_WS_X11 */
     1535#endif /* VBOX_WS_NIX */
    15361536}
    15371537
    … …  
    21552155void UIVirtualBoxManager::prepare()
    21562156{
    2157 #ifdef VBOX_WS_X11
     2157#ifdef VBOX_WS_NIX
    21582158    NativeWindowSubsystem::setWMClass(uiCommon().X11ServerAvailable(), this, "VirtualBox Manager", "VirtualBox Manager");
    21592159#endif
    … …  
    22832283void UIVirtualBoxManager::prepareConnections()
    22842284{
    2285 #ifdef VBOX_WS_X11
     2285#ifdef VBOX_WS_NIX
    22862286    /* Desktop event handlers: */
    22872287    connect(gpDesktop, &UIDesktopWidgetWatchdog::sigHostScreenWorkAreaResized,
    … …  
    31323132#elif defined(VBOX_WS_WIN)
    31333133        pDefaultAction->setProperty("path", "powershell");
    3134 #elif defined(VBOX_WS_X11)
     3134#elif defined(VBOX_WS_NIX)
    31353135        const QPair<QString, QString> terminalData = defaultTerminalData();
    31363136        pDefaultAction->setProperty("path", terminalData.first);
    … …  
    38593859}
    38603860
    3861 #ifdef VBOX_WS_X11
     3861#ifdef VBOX_WS_NIX
    38623862/* static */
    38633863QPair<QString, QString> UIVirtualBoxManager::defaultTerminalData()

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

    r100027 r100064  
    127127    /** @name Common stuff.
    128128      * @{ */
    129 #ifdef VBOX_WS_X11
     129#ifdef VBOX_WS_NIX
    130130        /** Handles host-screen available-area change. */
    131131        void sltHandleHostScreenAvailableAreaChange();
    … …  
    490490        static bool isAtLeastOneItemDetachable(const QList<UIVirtualMachineItem*> &items);
    491491
    492 #ifdef VBOX_WS_X11
     492#ifdef VBOX_WS_NIX
    493493        /** Tries to guess default X11 terminal emulator.
    494494          * @returns Data packed into Qt pair of QString(s),

  • trunk/src/VBox/Frontends/VirtualBox/src/notificationcenter/UINotificationObjects.cpp

    r99664 r100064  
    8181
    8282/* Other VBox stuff: */
    83 #ifdef VBOX_WS_X11
     83#ifdef VBOX_WS_NIX
    8484# include <iprt/env.h>
    8585#endif
    … …  
    22022202    AllowSetForegroundWindow(ASFW_ANY);
    22032203#endif
    2204 #ifdef VBOX_WS_X11
     2204#ifdef VBOX_WS_NIX
    22052205    /* Make sure VM process will start on the same
    22062206     * display as the VirtualBox Manager: */

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

    r99936 r100064  
    5858/* Other includes: */
    5959#include <math.h>
    60 #ifdef VBOX_WS_X11
     60#ifdef VBOX_WS_NIX
    6161# include <X11/Xlib.h>
    6262# undef Bool // Qt5 vs Xlib gift..
    63 #endif /* VBOX_WS_X11 */
     63#endif /* VBOX_WS_NIX */
    6464
    6565
    … …  
    453453    m_iWinId = (m_pMachineView && m_pMachineView->viewport()) ? (LONG64)m_pMachineView->viewport()->winId() : 0;
    454454
    455 #ifdef VBOX_WS_X11
     455#ifdef VBOX_WS_NIX
    456456    if (uiCommon().X11ServerAvailable())
    457457        /* Resync Qt and X11 Server (see xTracker #7547). */

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

    r99838 r100064  
    6969# include "WinKeyboard.h"
    7070#endif
    71 #ifdef VBOX_WS_X11
     71#ifdef VBOX_WS_NIX
    7272# include "XKeyboard.h"
    7373# include "VBoxUtils-nix.h"
    … …  
    8383# include <Carbon/Carbon.h>
    8484#endif
    85 #ifdef VBOX_WS_X11
     85#ifdef VBOX_WS_NIX
    8686# include <X11/XKBlib.h>
    8787# include <X11/keysym.h>
    … …  
    9797# endif /* KeyPress */
    9898# include <xcb/xcb.h>
    99 #endif /* VBOX_WS_X11 */
     99#endif /* VBOX_WS_NIX */
    100100
    101101/* Enums representing different keyboard-states: */
    … …  
    265265         * S.a. UIKeyboardHandler::eventFilter for more information. */
    266266
    267 #elif defined(VBOX_WS_X11)
     267#elif defined(VBOX_WS_NIX)
    268268        if (uiCommon().X11ServerAvailable())
    269269        {
    … …  
    370370         * S.a. UIKeyboardHandler::eventFilter for more information. */
    371371
    372 #elif defined(VBOX_WS_X11)
     372#elif defined(VBOX_WS_NIX)
    373373        if (uiCommon().X11ServerAvailable())
    374374        {
    … …  
    819819    }
    820820
    821 # elif defined(VBOX_WS_X11)
     821# elif defined(VBOX_WS_NIX)
    822822    if (uiCommon().X11ServerAvailable())
    823823    {
    … …  
    999999    , m_keyboardHook(NULL)
    10001000    , m_pAltGrMonitor(0)
    1001 #elif defined(VBOX_WS_X11)
     1001#elif defined(VBOX_WS_NIX)
    10021002    , m_hButtonGrabWindow(0)
    1003 #endif /* VBOX_WS_X11 */
     1003#endif /* VBOX_WS_NIX */
    10041004{
    10051005    /* Prepare: */
    … …  
    10381038{
    10391039    /* Global settings: */
    1040 #ifdef VBOX_WS_X11
     1040#ifdef VBOX_WS_NIX
    10411041    if (uiCommon().X11ServerAvailable())
    10421042    {
    … …  
    10491049        XkbSetDetectableAutoRepeat(NativeWindowSubsystem::X11GetDisplay(), True, NULL);
    10501050    }
    1051 #endif /* VBOX_WS_X11 */
     1051#endif /* VBOX_WS_NIX */
    10521052
    10531053    /* Extra data settings: */
    … …  
    15751575                    {
    15761576                        captureKeyboard(uScreenId);
    1577 #ifdef VBOX_WS_X11
     1577#ifdef VBOX_WS_NIX
    15781578                        /* Make sure that pending FocusOut events from the
    15791579                         * previous message box are handled, otherwise the
    … …  
    15811581                        /// @todo Is that really needed?
    15821582                        qApp->processEvents();
    1583 #endif /* VBOX_WS_X11 */
     1583#endif /* VBOX_WS_NIX */
    15841584                        finaliseCaptureKeyboard();
    15851585                        if (fCaptureMouse)
    … …  
    17881788    delete[] pList;
    17891789
    1790 #elif defined(VBOX_WS_X11)
     1790#elif defined(VBOX_WS_NIX)
    17911791    if (uiCommon().X11ServerAvailable())
    17921792    {
    … …  
    18651865    }
    18661866
    1867 #elif defined(VBOX_WS_X11)
     1867#elif defined(VBOX_WS_NIX)
    18681868    if (uiCommon().X11ServerAvailable())
    18691869    {

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

    r98983 r100064  
    5858class WinAltGrMonitor;
    5959#endif
    60 #ifdef VBOX_WS_X11
     60#ifdef VBOX_WS_NIX
    6161#  include <xcb/xcb.h>
    6262#endif
    … …  
    228228    /** Win: Holds the keyboard handler reference to be accessible from the keyboard hook. */
    229229    static UIKeyboardHandler *m_spKeyboardHandler;
    230 #elif defined(VBOX_WS_X11)
     230#elif defined(VBOX_WS_NIX)
    231231    /** The root window at the time we grab the mouse buttons. */
    232232    xcb_window_t m_hButtonGrabWindow;
    233 #endif /* VBOX_WS_X11 */
     233#endif /* VBOX_WS_NIX */
    234234};
    235235

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

    r99842 r100064  
    16631663    connect(gpDesktop, &UIDesktopWidgetWatchdog::sigHostScreenResized,
    16641664            this, &UIMachine::sltHandleHostScreenGeometryChange);
    1665 # if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     1665# if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    16661666    connect(gpDesktop, &UIDesktopWidgetWatchdog::sigHostScreenWorkAreaRecalculated,
    16671667            this, &UIMachine::sltHandleHostScreenAvailableAreaChange);
    1668 # else /* !VBOX_WS_X11 || VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     1668# else /* !VBOX_WS_NIX || VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    16691669    connect(gpDesktop, &UIDesktopWidgetWatchdog::sigHostScreenWorkAreaResized,
    16701670            this, &UIMachine::sltHandleHostScreenAvailableAreaChange);
    1671 # endif /* !VBOX_WS_X11 || VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     1671# endif /* !VBOX_WS_NIX || VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    16721672#endif /* !VBOX_WS_MAC */
    16731673}
    … …  
    21612161    m_fIsValidPointerShapePresent = true;
    21622162
    2163 #elif defined(VBOX_WS_X11) || defined(VBOX_WS_MAC)
     2163#elif defined(VBOX_WS_NIX) || defined(VBOX_WS_MAC)
    21642164
    21652165    /* Create an ARGB image out of the shape data: */
    … …  
    22032203}
    22042204
    2205 #if defined(VBOX_WS_X11) || defined(VBOX_WS_MAC)
     2205#if defined(VBOX_WS_NIX) || defined(VBOX_WS_MAC)
    22062206/* static */
    22072207void UIMachine::renderCursorPixels(const uint32_t *pu32XOR, const uint8_t *pu8AND,
    … …  
    22912291    }
    22922292}
    2293 #endif /* VBOX_WS_X11 || VBOX_WS_MAC */
     2293#endif /* VBOX_WS_NIX || VBOX_WS_MAC */
    22942294
    22952295#ifdef VBOX_WS_WIN

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

    r99142 r100064  
    905905        void updateMouseState();
    906906
    907 #if defined(VBOX_WS_X11) || defined(VBOX_WS_MAC)
     907#if defined(VBOX_WS_NIX) || defined(VBOX_WS_MAC)
    908908        /** Generate a BGRA bitmap which approximates a XOR/AND mouse pointer.
    909909          *
    … …  
    919919                                       uint32_t u32Width, uint32_t u32Height,
    920920                                       uint32_t *pu32Pixels, uint32_t cbPixels);
    921 #endif /* VBOX_WS_X11 || VBOX_WS_MAC */
     921#endif /* VBOX_WS_NIX || VBOX_WS_MAC */
    922922
    923923#ifdef VBOX_WS_WIN

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

    r99946 r100064  
    8282# include "UINetworkRequestManager.h"
    8383#endif
    84 #ifdef VBOX_WS_X11
     84#ifdef VBOX_WS_NIX
    8585# include "VBoxUtils-nix.h"
    8686#endif
    … …  
    119119# include "VBoxUtils-win.h"
    120120#endif
    121 #ifdef VBOX_WS_X11
     121#ifdef VBOX_WS_NIX
    122122# include <XKeyboard.h>
    123123#endif
    … …  
    498498            break;
    499499        }
    500 #ifdef VBOX_WS_X11
     500#ifdef VBOX_WS_NIX
    501501        case KMachineState_Starting:
    502502        case KMachineState_Restoring:
    … …  
    580580void UIMachineLogic::sltDisableHostScreenSaverStateChanged(bool fDisabled)
    581581{
    582 #if defined(VBOX_WS_X11)
     582#if defined(VBOX_WS_NIX)
    583583    /* Find the methods once and cache them: */
    584584    if (m_methods.isEmpty())
    … …  
    785785UIMachineLogic::~UIMachineLogic()
    786786{
    787 #if defined(VBOX_WS_X11)
     787#if defined(VBOX_WS_NIX)
    788788    qDeleteAll(m_methods.begin(), m_methods.end());
    789789    m_methods.clear();
    … …  
    923923    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_View_T_GuestAutoresize));
    924924    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD));
    925 #ifdef VBOX_WS_X11
     925#ifdef VBOX_WS_NIX
    926926    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS));
    927 #endif /* VBOX_WS_X11 */
     927#endif /* VBOX_WS_NIX */
    928928    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak));
    929929    m_pRunningActions->addAction(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeInsert));
    … …  
    10541054    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCAD), &UIAction::triggered,
    10551055            this, &UIMachineLogic::sltTypeCAD);
    1056 #ifdef VBOX_WS_X11
     1056#ifdef VBOX_WS_NIX
    10571057    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCABS), &UIAction::triggered,
    10581058            this, &UIMachineLogic::sltTypeCABS);
    1059 #endif /* VBOX_WS_X11 */
     1059#endif /* VBOX_WS_NIX */
    10601060    connect(actionPool()->action(UIActionIndexRT_M_Input_M_Keyboard_S_TypeCtrlBreak), &UIAction::triggered,
    10611061            this, &UIMachineLogic::sltTypeCtrlBreak);
    … …  
    13891389    sltSwitchKeyboardLedsToGuestLeds();
    13901390
    1391 #if defined(VBOX_WS_X11) || defined(VBOX_WS_WIN)
     1391#if defined(VBOX_WS_NIX) || defined(VBOX_WS_WIN)
    13921392    connect(gEDataManager, &UIExtraDataManager::sigDisableHostScreenSaverStateChange,
    13931393            this, &UIMachineLogic::sltDisableHostScreenSaverStateChanged);
    … …  
    19421942
    19431943        /* On X11 Qt Filedialog returns the filepath without the filetype suffix, so adding it ourselves: */
    1944 #ifdef VBOX_WS_X11
     1944#ifdef VBOX_WS_NIX
    19451945        /* Add filetype suffix only if user has not added it explicitly: */
    19461946        if (!strFilename.endsWith(QString(".%1").arg(strFormat)))
    … …  
    19501950            tmpImage.save(QDir::toNativeSeparators(QFile::encodeName(strFilename)),
    19511951                          strFormat.toUtf8().constData());
    1952 #else /* !VBOX_WS_X11 */
     1952#else /* !VBOX_WS_NIX */
    19531953        QFile file(strFilename);
    19541954        if (file.open(QIODevice::WriteOnly))
    19551955            tmpImage.save(&file, strFormat.toUtf8().constData());
    1956 #endif /* !VBOX_WS_X11 */
     1956#endif /* !VBOX_WS_NIX */
    19571957    }
    19581958    QFile::remove(strTempFile);
    … …  
    20522052}
    20532053
    2054 #ifdef VBOX_WS_X11
     2054#ifdef VBOX_WS_NIX
    20552055void UIMachineLogic::sltTypeCABS()
    20562056{
    … …  
    20642064    uimachine()->putScancodes(sequence);
    20652065}
    2066 #endif /* VBOX_WS_X11 */
     2066#endif /* VBOX_WS_NIX */
    20672067
    20682068void UIMachineLogic::sltTypeCtrlBreak()

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

    r99946 r100064  
    5252class CUSBDevice;
    5353class CVirtualBoxErrorInfo;
    54 #if defined(VBOX_WS_X11)
     54#if defined(VBOX_WS_NIX)
    5555 struct DBusScreenSaverInhibitMethod;
    5656#endif
    … …  
    266266    void sltCloseSoftKeyboardDefault() { sltCloseSoftKeyboard(true); }
    267267    void sltTypeCAD();
    268 #ifdef VBOX_WS_X11
     268#ifdef VBOX_WS_NIX
    269269    void sltTypeCABS();
    270 #endif /* VBOX_WS_X11 */
     270#endif /* VBOX_WS_NIX */
    271271    void sltTypeCtrlBreak();
    272272    void sltTypeInsert();
    … …  
    407407    /* Holds the cookies returnd by QDBus inhibition calls. Map keys are service name. These are required during uninhibition.*/
    408408    QMap<QString, uint> m_screenSaverInhibitionCookies;
    409 #if defined(VBOX_WS_X11)
     409#if defined(VBOX_WS_NIX)
    410410    QVector<DBusScreenSaverInhibitMethod*> m_methods;
    411411#endif

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

    r100063 r100064  
    8989# include <Carbon/Carbon.h>
    9090#endif
    91 #ifdef VBOX_WS_X11
     91#ifdef VBOX_WS_NIX
    9292#  include <xcb/xcb.h>
    9393#endif
    … …  
    241241    {
    242242        double dScaleFactorFor3D = dScaleFactor;
    243 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     243#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    244244        // WORKAROUND:
    245245        // On Windows and Linux opposing to macOS it's only Qt which can auto scale up,
    … …  
    247247        if (!fUseUnscaledHiDPIOutput)
    248248            dScaleFactorFor3D *= dDevicePixelRatioActual;
    249 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     249#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    250250        uimachine()->notifyScaleFactorChange(m_uScreenId,
    251251                                             (uint32_t)(dScaleFactorFor3D * VBOX_OGL_SCALE_FACTOR_MULTIPLIER),
    … …  
    538538    }
    539539
    540 # elif defined(VBOX_WS_X11)
     540# elif defined(VBOX_WS_NIX)
    541541
    542542    if (uiCommon().X11ServerAvailable())
    … …  
    10031003    {
    10041004        double dScaleFactorFor3D = dScaleFactor;
    1005 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     1005#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    10061006        // WORKAROUND:
    10071007        // On Windows and Linux opposing to macOS it's only Qt which can auto scale up,
    … …  
    10091009        if (!fUseUnscaledHiDPIOutput)
    10101010            dScaleFactorFor3D *= frameBuffer()->devicePixelRatioActual();
    1011 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     1011#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    10121012        uimachine()->notifyScaleFactorChange(m_uScreenId,
    10131013                                             (uint32_t)(dScaleFactorFor3D * VBOX_OGL_SCALE_FACTOR_MULTIPLIER),
    … …  
    12291229        uimachine()->acquireLiveMachineState(enmActualState);
    12301230
    1231 #ifdef VBOX_WS_X11
     1231#ifdef VBOX_WS_NIX
    12321232        // WORKAROUND:
    12331233        // No idea why this was required for X11 before.
    … …  
    12371237            size = storedGuestScreenSizeHint();
    12381238# endif
    1239 #endif /* VBOX_WS_X11 */
     1239#endif /* VBOX_WS_NIX */
    12401240
    12411241        /* If there is a preview image saved, we will resize the framebuffer to the size of that image: */
    … …  
    19581958    QAbstractScrollArea::focusOutEvent(pEvent);
    19591959}
    1960 #ifdef VBOX_WS_X11
     1960#ifdef VBOX_WS_NIX
    19611961void UIMachineView::keyPressEvent(QKeyEvent *pEvent)
    19621962{
    … …  
    21632163    }
    21642164
    2165 #elif defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     2165#elif defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    21662166
    21672167    /* We want to scale the pixmap just once, so let's prepare cumulative multiplier: */

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

    r100043 r100064  
    324324    /** Handles focus-out @a pEvent. */
    325325    void focusOutEvent(QFocusEvent *pEvent);
    326 #ifdef VBOX_WS_X11
     326#ifdef VBOX_WS_NIX
    327327    virtual void keyPressEvent(QKeyEvent *pEvent) override;
    328328    virtual void keyReleaseEvent(QKeyEvent *pEvent) override;

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

    r99438 r100064  
    142142    updateAppearanceOf(UIVisualElement_AllStuff);
    143143
    144 #ifdef VBOX_WS_X11
     144#ifdef VBOX_WS_NIX
    145145    /* Prepare default class/name values: */
    146146    const QString strWindowClass = QString("VirtualBox Machine");

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

    r99012 r100064  
    118118protected slots:
    119119
    120 #ifdef VBOX_WS_X11
     120#ifdef VBOX_WS_NIX
    121121    /** X11: Performs machine-window geometry normalization. */
    122122    void sltNormalizeGeometry() { normalizeGeometry(true /* adjust position */, shouldResizeToGuestDisplay()); }
    123 #endif /* VBOX_WS_X11 */
     123#endif /* VBOX_WS_NIX */
    124124
    125125    /** Performs machine-window activation. */

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

    r100034 r100064  
    5252# include "VBoxUtils-win.h"
    5353#endif
    54 #ifdef VBOX_WS_X11
     54#ifdef VBOX_WS_NIX
    5555# include "VBoxUtils-nix.h"
    5656#endif
    … …  
    311311    RT_NOREF(pMessage, uScreenId);
    312312
    313 # elif defined(VBOX_WS_X11)
     313# elif defined(VBOX_WS_NIX)
    314314
    315315    if (uiCommon().X11ServerAvailable())
    … …  
    507507        /* Activate it: */
    508508        m_pHoveredWindow->activateWindow();
    509 #ifdef VBOX_WS_X11
     509#ifdef VBOX_WS_NIX
    510510        /* On X11 its not enough to just activate window if you
    511511         * want to raise it also, so we will make it separately: */
    512512        m_pHoveredWindow->raise();
    513 #endif /* VBOX_WS_X11 */
     513#endif /* VBOX_WS_NIX */
    514514    }
    515515}
    … …  
    682682                    }
    683683
    684 #ifdef VBOX_WS_X11
     684#ifdef VBOX_WS_NIX
    685685                    /* Make sure that we are focused after a click.  Rather
    686686                     * ugly, but works around a problem with GNOME
    … …  
    689689                    if (pEvent->type() == QEvent::MouseButtonRelease)
    690690                        pWatchedWidget->window()->activateWindow();
    691 #endif /* VBOX_WS_X11 */
     691#endif /* VBOX_WS_NIX */
    692692                    /* Check if we should activate window under cursor: */
    693693                    if (gEDataManager->activateHoveredMachineWindow() &&
    … …  
    715715                {
    716716                    QMouseEvent *pMouseEvent = static_cast<QMouseEvent*>(pEvent);
    717 #ifdef VBOX_WS_X11
     717#ifdef VBOX_WS_NIX
    718718                    /* When the keyboard is captured, we also capture mouse button
    719719                     * events, and release the keyboard and re-capture it delayed
    … …  
    724724                    if (pEvent->type() == QEvent::MouseButtonPress)
    725725                        machineLogic()->keyboardHandler()->finaliseCaptureKeyboard();
    726 #endif /* VBOX_WS_X11 */
     726#endif /* VBOX_WS_NIX */
    727727
    728728                    /* For various mouse click related events
    … …  
    11631163                    if (ok)
    11641164                    {
    1165 #ifdef VBOX_WS_X11
     1165#ifdef VBOX_WS_NIX
    11661166                        /* Make sure that pending FocusOut events from the previous message box are handled,
    11671167                         * otherwise the mouse is immediately ungrabbed again: */
    11681168                        qApp->processEvents();
    1169 #endif /* VBOX_WS_X11 */
     1169#endif /* VBOX_WS_NIX */
    11701170                        machineLogic()->keyboardHandler()->captureKeyboard(uScreenId);
    11711171                        const MouseCapturePolicy mcp = gEDataManager->mouseCapturePolicy(uiCommon().managedVMUuid());

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

    r99843 r100064  
    9191
    9292/* External includes: */
    93 #ifdef VBOX_WS_X11
     93#ifdef VBOX_WS_NIX
    9494# include <X11/Xlib.h>
    9595# include <X11/Xutil.h>
    … …  
    219219    /* Some logging right after we powered up: */
    220220    LogRel(("GUI: Qt version: %s\n", UICommon::qtRTVersionString().toUtf8().constData()));
    221 #ifdef VBOX_WS_X11
     221#ifdef VBOX_WS_NIX
    222222    LogRel(("GUI: X11 Window Manager code: %d\n", (int)uiCommon().typeOfWindowManager()));
    223223#endif

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

    r98885 r100064  
    528528    setMachineWindowsCreated(true);
    529529
    530 #ifdef VBOX_WS_X11
     530#ifdef VBOX_WS_NIX
    531531    switch (uiCommon().typeOfWindowManager())
    532532    {
    … …  
    544544            break;
    545545    }
    546 #endif /* VBOX_WS_X11 */
     546#endif /* VBOX_WS_NIX */
    547547}
    548548

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

    r98859 r100064  
    4848
    4949/* External includes: */
    50 #ifdef VBOX_WS_X11
     50#ifdef VBOX_WS_NIX
    5151# include <limits.h>
    52 #endif /* VBOX_WS_X11 */
     52#endif /* VBOX_WS_NIX */
    5353
    5454

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

    r98885 r100064  
    4343#include "UIMachineWindowFullscreen.h"
    4444#include "UINotificationCenter.h"
    45 #if   defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     45#if   defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    4646# include "UIMachineDefs.h"
    4747# include "UIMiniToolBar.h"
    … …  
    5757UIMachineWindowFullscreen::UIMachineWindowFullscreen(UIMachineLogic *pMachineLogic, ulong uScreenId)
    5858    : UIMachineWindow(pMachineLogic, uScreenId)
    59 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     59#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    6060    , m_pMiniToolBar(0)
    61 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     61#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    6262#ifdef VBOX_WS_MAC
    6363    , m_fIsInFullscreenTransition(false)
    6464#endif /* VBOX_WS_MAC */
    6565    , m_fWasMinimized(false)
    66 #ifdef VBOX_WS_X11
     66#ifdef VBOX_WS_NIX
    6767    , m_fIsMinimizationRequested(false)
    6868    , m_fIsMinimized(false)
    … …  
    126126#endif /* VBOX_WS_MAC */
    127127
    128 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     128#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    129129void UIMachineWindowFullscreen::sltMachineStateChanged()
    130130{
    … …  
    138138void UIMachineWindowFullscreen::sltRevokeWindowActivation()
    139139{
    140 #ifdef VBOX_WS_X11
     140#ifdef VBOX_WS_NIX
    141141    // WORKAROUND:
    142142    // We could be asked to minimize already, but just
    … …  
    151151
    152152    /* Revoke stolen activation: */
    153 #ifdef VBOX_WS_X11
     153#ifdef VBOX_WS_NIX
    154154    raise();
    155 #endif /* VBOX_WS_X11 */
     155#endif /* VBOX_WS_NIX */
    156156    activateWindow();
    157157}
    … …  
    162162    gEDataManager->setAutoHideMiniToolbar(fEnabled, uiCommon().managedVMUuid());
    163163}
    164 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     164#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    165165
    166166#ifdef VBOX_WS_MAC
    … …  
    211211void UIMachineWindowFullscreen::sltShowMinimized()
    212212{
    213 #ifdef VBOX_WS_X11
     213#ifdef VBOX_WS_NIX
    214214    /* Remember that we are asked to minimize: */
    215215    m_fIsMinimizationRequested = true;
    … …  
    237237    setAutoFillBackground(true);
    238238
    239 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     239#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    240240    /* Prepare mini-toolbar: */
    241241    prepareMiniToolbar();
    242 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     242#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    243243
    244244#ifdef VBOX_WS_MAC
    … …  
    266266}
    267267
    268 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     268#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    269269void UIMachineWindowFullscreen::prepareMiniToolbar()
    270270{
    … …  
    295295    }
    296296}
    297 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    298 
    299 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     297#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
     298
     299#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    300300void UIMachineWindowFullscreen::cleanupMiniToolbar()
    301301{
    … …  
    304304    m_pMiniToolBar = 0;
    305305}
    306 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     306#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    307307
    308308void UIMachineWindowFullscreen::cleanupVisualState()
    … …  
    317317#endif /* VBOX_WS_MAC */
    318318
    319 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     319#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    320320    /* Cleanup mini-toolbar: */
    321321    cleanupMiniToolbar();
    322 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     322#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    323323
    324324    /* Call to base-class: */
    … …  
    380380    resize(workingArea.size());
    381381
    382 #elif defined(VBOX_WS_X11)
     382#elif defined(VBOX_WS_NIX)
    383383
    384384    /* Determine whether we should use the native full-screen mode: */
    … …  
    476476    }
    477477
    478 #elif defined(VBOX_WS_X11)
     478#elif defined(VBOX_WS_NIX)
    479479
    480480    /* If window shouldn't be shown or mapped to some host-screen: */
    … …  
    529529}
    530530
    531 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     531#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    532532void UIMachineWindowFullscreen::updateAppearanceOf(int iElement)
    533533{
    … …  
    556556    }
    557557}
    558 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    559 
    560 #ifdef VBOX_WS_X11
     558#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
     559
     560#ifdef VBOX_WS_NIX
    561561void UIMachineWindowFullscreen::changeEvent(QEvent *pEvent)
    562562{
    … …  
    598598    UIMachineWindow::changeEvent(pEvent);
    599599}
    600 #endif /* VBOX_WS_X11 */
     600#endif /* VBOX_WS_NIX */
    601601
    602602#ifdef VBOX_WS_WIN

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

    r98103 r100064  
    3535#include "UIMachineWindow.h"
    3636
    37 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     37#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    3838/* Forward declarations: */
    3939class UIMiniToolBar;
    40 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     40#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    4141
    4242/** UIMachineWindow subclass used as full-screen machine window implementation. */
    … …  
    7575private slots:
    7676
    77 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     77#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    7878    /** Handles machine state change event. */
    7979    void sltMachineStateChanged();
    … …  
    8585      * @param  fEnabled  Brings whether auto-hide is enabled. */
    8686    void sltHandleMiniToolBarAutoHideToggled(bool fEnabled);
    87 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     87#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    8888
    8989#ifdef RT_OS_DARWIN
    … …  
    103103    /** Prepare visual-state routine. */
    104104    void prepareVisualState();
    105 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     105#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    106106    /** Prepare mini-toolbar routine. */
    107107    void prepareMiniToolbar();
    108 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     108#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    109109
    110 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     110#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    111111    /** Cleanup mini-toolbar routine. */
    112112    void cleanupMiniToolbar();
    113 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     113#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    114114    /** Cleanup visual-state routine. */
    115115    void cleanupVisualState();
    … …  
    122122    void showInNecessaryMode();
    123123
    124 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     124#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    125125    /** Common update routine. */
    126126    void updateAppearanceOf(int iElement);
    127 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     127#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    128128
    129 #ifdef VBOX_WS_X11
     129#ifdef VBOX_WS_NIX
    130130    /** X11: Handles @a pEvent about state change. */
    131131    void changeEvent(QEvent *pEvent);
    … …  
    137137#endif
    138138
    139 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     139#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    140140    /** Holds the mini-toolbar instance. */
    141141    UIMiniToolBar *m_pMiniToolBar;
    142 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     142#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    143143
    144144#ifdef VBOX_WS_MAC
    … …  
    152152      * Used to restore minimized state when the window shown again. */
    153153    bool m_fWasMinimized;
    154 #ifdef VBOX_WS_X11
     154#ifdef VBOX_WS_NIX
    155155    /** X11: Holds whether the window minimization is currently requested.
    156156      * Used to prevent accidentally restoring to full-screen state. */

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

    r98849 r100064  
    219219void UIMachineLogicNormal::sltHostScreenAvailableAreaChange()
    220220{
    221 #if defined(VBOX_WS_X11) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
     221#if defined(VBOX_WS_NIX) && !defined(VBOX_GUI_WITH_CUSTOMIZATIONS1)
    222222    /* Prevent handling if fake screen detected: */
    223223    if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    … …  
    228228        if (!pMachineWindow->isMaximized())
    229229            pMachineWindow->restoreCachedGeometry();
    230 #endif /* VBOX_WS_X11 && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
     230#endif /* VBOX_WS_NIX && !VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    231231
    232232    /* Call to base-class: */

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

    r99098 r100064  
    3232#include <QResizeEvent>
    3333#include <QScrollBar>
    34 #ifdef VBOX_WS_X11
     34#ifdef VBOX_WS_NIX
    3535# include <QTimer>
    3636#endif
    … …  
    336336
    337337        /* Normalize to the optimal size: */
    338 #ifdef VBOX_WS_X11
     338#ifdef VBOX_WS_NIX
    339339        QTimer::singleShot(0, this, SLOT(sltNormalizeGeometry()));
    340 #else /* !VBOX_WS_X11 */
     340#else /* !VBOX_WS_NIX */
    341341        normalizeGeometry(true /* adjust position */, shouldResizeToGuestDisplay());
    342 #endif /* !VBOX_WS_X11 */
     342#endif /* !VBOX_WS_NIX */
    343343    }
    344344#endif /* VBOX_GUI_WITH_CUSTOMIZATIONS1 */
    … …  
    371371        case QEvent::Resize:
    372372        {
    373 #ifdef VBOX_WS_X11
     373#ifdef VBOX_WS_NIX
    374374            /* Prevent handling if fake screen detected: */
    375375            if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    376376                break;
    377 #endif /* VBOX_WS_X11 */
     377#endif /* VBOX_WS_NIX */
    378378
    379379            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
    … …  
    398398        case QEvent::Move:
    399399        {
    400 #ifdef VBOX_WS_X11
     400#ifdef VBOX_WS_NIX
    401401            /* Prevent handling if fake screen detected: */
    402402            if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    403403                break;
    404 #endif /* VBOX_WS_X11 */
     404#endif /* VBOX_WS_NIX */
    405405
    406406            if (!isMaximizedChecked())

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

    r98849 r100064  
    8585void UIMachineLogicScale::sltHostScreenAvailableAreaChange()
    8686{
    87 #ifdef VBOX_WS_X11
     87#ifdef VBOX_WS_NIX
    8888    /* Prevent handling if fake screen detected: */
    8989    if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    … …  
    9393    foreach (UIMachineWindow *pMachineWindow, machineWindows())
    9494        pMachineWindow->restoreCachedGeometry();
    95 #endif /* VBOX_WS_X11 */
     95#endif /* VBOX_WS_NIX */
    9696
    9797    /* Call to base-class: */

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

    r98670 r100064  
    7676            double xScaleFactor = (double)scaledSize.width()  / frameBuffer()->width();
    7777            double yScaleFactor = (double)scaledSize.height() / frameBuffer()->height();
    78 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     78#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    7979            // WORKAROUND:
    8080            // On Windows and Linux opposing to macOS it's only Qt which can auto scale up,
    … …  
    8585                yScaleFactor *= dDevicePixelRatioActual;
    8686            }
    87 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     87#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    8888            uimachine()->notifyScaleFactorChange(m_uScreenId,
    8989                                                 (uint32_t)(xScaleFactor * VBOX_OGL_SCALE_FACTOR_MULTIPLIER),
    … …  
    137137            double xScaleFactor = (double)scaledSize.width()  / frameBuffer()->width();
    138138            double yScaleFactor = (double)scaledSize.height() / frameBuffer()->height();
    139 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     139#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    140140            // WORKAROUND:
    141141            // On Windows and Linux opposing to macOS it's only Qt which can auto scale up,
    … …  
    146146                yScaleFactor *= dDevicePixelRatioActual;
    147147            }
    148 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     148#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    149149            uimachine()->notifyScaleFactorChange(m_uScreenId,
    150150                                                 (uint32_t)(xScaleFactor * VBOX_OGL_SCALE_FACTOR_MULTIPLIER),

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

    r98885 r100064  
    3131#include <QSpacerItem>
    3232#include <QResizeEvent>
    33 #ifdef VBOX_WS_X11
     33#ifdef VBOX_WS_NIX
    3434# include <QTimer>
    3535#endif
    … …  
    136136
    137137        /* Normalize to the optimal size: */
    138 #ifdef VBOX_WS_X11
     138#ifdef VBOX_WS_NIX
    139139        QTimer::singleShot(0, this, SLOT(sltNormalizeGeometry()));
    140 #else /* !VBOX_WS_X11 */
     140#else /* !VBOX_WS_NIX */
    141141        normalizeGeometry(true /* adjust position */, true /* resize to fit guest display. ignored in scaled case */);
    142 #endif /* !VBOX_WS_X11 */
     142#endif /* !VBOX_WS_NIX */
    143143    }
    144144}
    … …  
    215215        case QEvent::Resize:
    216216        {
    217 #ifdef VBOX_WS_X11
     217#ifdef VBOX_WS_NIX
    218218            /* Prevent handling if fake screen detected: */
    219219            if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    220220                break;
    221 #endif /* VBOX_WS_X11 */
     221#endif /* VBOX_WS_NIX */
    222222
    223223            QResizeEvent *pResizeEvent = static_cast<QResizeEvent*>(pEvent);
    … …  
    239239        case QEvent::Move:
    240240        {
    241 #ifdef VBOX_WS_X11
     241#ifdef VBOX_WS_NIX
    242242            /* Prevent handling if fake screen detected: */
    243243            if (UIDesktopWidgetWatchdog::isFakeScreenDetected())
    244244                break;
    245 #endif /* VBOX_WS_X11 */
     245#endif /* VBOX_WS_NIX */
    246246
    247247            if (!isMaximizedChecked())

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

    r98849 r100064  
    284284    setMachineWindowsCreated(true);
    285285
    286 #ifdef VBOX_WS_X11
     286#ifdef VBOX_WS_NIX
    287287    switch (uiCommon().typeOfWindowManager())
    288288    {
    … …  
    300300            break;
    301301    }
    302 #endif /* VBOX_WS_X11 */
     302#endif /* VBOX_WS_NIX */
    303303}
    304304

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

    r98859 r100064  
    5050
    5151/* External includes: */
    52 #ifdef VBOX_WS_X11
     52#ifdef VBOX_WS_NIX
    5353# include <limits.h>
    54 #endif /* VBOX_WS_X11 */
     54#endif /* VBOX_WS_NIX */
    5555
    5656

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

    r98675 r100064  
    4040#include "UIMachineView.h"
    4141#include "UIMachineWindowSeamless.h"
    42 #if   defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     42#if   defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    4343# include "UIMachineDefs.h"
    4444# include "UIMiniToolBar.h"
    … …  
    5353UIMachineWindowSeamless::UIMachineWindowSeamless(UIMachineLogic *pMachineLogic, ulong uScreenId)
    5454    : UIMachineWindow(pMachineLogic, uScreenId)
    55 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     55#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    5656    , m_pMiniToolBar(0)
    57 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     57#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    5858    , m_fWasMinimized(false)
    59 #ifdef VBOX_WS_X11
     59#ifdef VBOX_WS_NIX
    6060    , m_fIsMinimizationRequested(false)
    6161    , m_fIsMinimized(false)
    … …  
    6464}
    6565
    66 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     66#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    6767void UIMachineWindowSeamless::sltMachineStateChanged()
    6868{
    … …  
    7676void UIMachineWindowSeamless::sltRevokeWindowActivation()
    7777{
    78 #ifdef VBOX_WS_X11
     78#ifdef VBOX_WS_NIX
    7979    // WORKAROUND:
    8080    // We could be asked to minimize already, but just
    … …  
    8989
    9090    /* Revoke stolen activation: */
    91 #ifdef VBOX_WS_X11
     91#ifdef VBOX_WS_NIX
    9292    raise();
    93 #endif /* VBOX_WS_X11 */
     93#endif /* VBOX_WS_NIX */
    9494    activateWindow();
    9595}
    … …  
    100100    gEDataManager->setAutoHideMiniToolbar(fEnabled, uiCommon().managedVMUuid());
    101101}
    102 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     102#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    103103
    104104void UIMachineWindowSeamless::sltShowMinimized()
    105105{
    106 #ifdef VBOX_WS_X11
     106#ifdef VBOX_WS_NIX
    107107    /* Remember that we are asked to minimize: */
    108108    m_fIsMinimizationRequested = true;
    … …  
    132132#endif /* VBOX_WITH_MASKED_SEAMLESS */
    133133
    134 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     134#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    135135    /* Prepare mini-toolbar: */
    136136    prepareMiniToolbar();
    137 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    138 }
    139 
    140 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     137#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
     138}
     139
     140#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    141141void UIMachineWindowSeamless::prepareMiniToolbar()
    142142{
    … …  
    167167    }
    168168}
    169 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    170 
    171 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     169#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
     170
     171#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    172172void UIMachineWindowSeamless::cleanupMiniToolbar()
    173173{
    … …  
    176176    m_pMiniToolBar = 0;
    177177}
    178 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     178#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    179179
    180180void UIMachineWindowSeamless::cleanupVisualState()
    181181{
    182 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     182#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    183183    /* Cleanup mini-toolbar: */
    184184    cleanupMiniToolbar();
    185 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     185#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    186186
    187187    /* Call to base-class: */
    … …  
    201201    Q_UNUSED(workingArea);
    202202
    203 #ifdef VBOX_WS_X11
     203#ifdef VBOX_WS_NIX
    204204
    205205    /* Make sure we are located on corresponding host-screen: */
    … …  
    273273        placeOnScreen();
    274274
    275 #ifdef VBOX_WS_X11
     275#ifdef VBOX_WS_NIX
    276276        /* Show window: */
    277277        if (!isMaximized())
    … …  
    297297}
    298298
    299 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     299#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    300300void UIMachineWindowSeamless::updateAppearanceOf(int iElement)
    301301{
    … …  
    324324    }
    325325}
    326 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
    327 
    328 #ifdef VBOX_WS_X11
     326#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
     327
     328#ifdef VBOX_WS_NIX
    329329void UIMachineWindowSeamless::changeEvent(QEvent *pEvent)
    330330{
    … …  
    366366    UIMachineWindow::changeEvent(pEvent);
    367367}
    368 #endif /* VBOX_WS_X11 */
     368#endif /* VBOX_WS_NIX */
    369369
    370370#ifdef VBOX_WS_WIN

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

    r98103 r100064  
    3535#include "UIMachineWindow.h"
    3636
    37 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     37#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    3838/* Forward declarations: */
    3939class UIMiniToolBar;
    40 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     40#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    4141
    4242/** UIMachineWindow subclass used as seamless machine window implementation. */
    … …  
    5252private slots:
    5353
    54 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     54#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    5555    /** Handles machine state change event. */
    5656    void sltMachineStateChanged();
    … …  
    6262      * @param  fEnabled  Brings whether auto-hide is enabled. */
    6363    void sltHandleMiniToolBarAutoHideToggled(bool fEnabled);
    64 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     64#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    6565
    6666    /** Shows window in minimized state. */
    … …  
    7171    /** Prepare visual-state routine. */
    7272    void prepareVisualState();
    73 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     73#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    7474    /** Prepare mini-toolbar routine. */
    7575    void prepareMiniToolbar();
    76 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     76#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    7777
    78 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     78#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    7979    /** Cleanup mini-toolbar routine. */
    8080    void cleanupMiniToolbar();
    81 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     81#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    8282    /** Cleanup visual-state routine. */
    8383    void cleanupVisualState();
    … …  
    8888    void showInNecessaryMode();
    8989
    90 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     90#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    9191    /** Common update routine. */
    9292    void updateAppearanceOf(int iElement);
    93 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     93#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    9494
    95 #ifdef VBOX_WS_X11
     95#ifdef VBOX_WS_NIX
    9696    /** X11: Handles @a pEvent about state change. */
    9797    void changeEvent(QEvent *pEvent);
    … …  
    108108#endif /* VBOX_WITH_MASKED_SEAMLESS */
    109109
    110 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     110#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    111111    /** Holds the mini-toolbar instance. */
    112112    UIMiniToolBar *m_pMiniToolBar;
    113 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     113#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    114114
    115115#ifdef VBOX_WITH_MASKED_SEAMLESS
    … …  
    123123      * Used to restore minimized state when the window shown again. */
    124124    bool m_fWasMinimized;
    125 #ifdef VBOX_WS_X11
     125#ifdef VBOX_WS_NIX
    126126    /** X11: Holds whether the window minimization is currently requested.
    127127      * Used to prevent accidentally restoring to seamless state. */

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIDisplayFeaturesEditor.cpp

    r99479 r100064  
    3333/* GUI includes: */
    3434#include "UIDisplayFeaturesEditor.h"
    35 #ifdef VBOX_WS_X11
     35#ifdef VBOX_WS_NIX
    3636# include "VBoxUtils-nix.h"
    3737#endif
    … …  
    141141#if defined(VBOX_WS_WIN)
    142142        m_pCheckBoxDisableHostScreenSaver = new QCheckBox(this);
    143 #elif defined(VBOX_WS_X11)
     143#elif defined(VBOX_WS_NIX)
    144144        if (NativeWindowSubsystem::checkDBusScreenSaverServices())
    145145            m_pCheckBoxDisableHostScreenSaver = new QCheckBox(this);
    146 #endif /* VBOX_WS_X11 */
     146#endif /* VBOX_WS_NIX */
    147147        if (m_pCheckBoxDisableHostScreenSaver)
    148148            m_pLayout->addWidget(m_pCheckBoxDisableHostScreenSaver, 1, 1);

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIHostComboEditor.cpp

    r99802 r100064  
    4949#elif defined(VBOX_WS_WIN)
    5050# include "WinKeyboard.h"
    51 #elif defined(VBOX_WS_X11)
     51#elif defined(VBOX_WS_NIX)
    5252# include "XKeyboard.h"
    5353# include "VBoxUtils-nix.h"
    … …  
    5555
    5656/* Other VBox includes: */
    57 #if defined(VBOX_WS_X11)
     57#if defined(VBOX_WS_NIX)
    5858# include <VBox/VBoxKeyboard.h>
    5959#endif
    … …  
    6262#if defined(VBOX_WS_MAC)
    6363# include <Carbon/Carbon.h>
    64 #elif defined(VBOX_WS_X11)
     64#elif defined(VBOX_WS_NIX)
    6565# include <X11/Xlib.h>
    6666# include <X11/Xutil.h>
    6767# include <X11/keysym.h>
    6868# include <xcb/xcb.h>
    69 #endif /* VBOX_WS_X11 */
     69#endif /* VBOX_WS_NIX */
    7070
    7171/* Namespaces: */
    … …  
    115115*********************************************************************************************************************************/
    116116
    117 #ifdef VBOX_WS_X11
     117#ifdef VBOX_WS_NIX
    118118namespace UINativeHotKey
    119119{
    120120    QMap<QString, QString> m_keyNames;
    121121}
    122 #endif /* VBOX_WS_X11 */
     122#endif /* VBOX_WS_NIX */
    123123
    124124QString UINativeHotKey::toString(int iKeyCode)
    … …  
    197197    }
    198198
    199 #elif defined(VBOX_WS_X11)
     199#elif defined(VBOX_WS_NIX)
    200200
    201201    if (char *pNativeKeyName = ::XKeysymToString((KeySym)iKeyCode))
    … …  
    252252        || iKeyCode == VK_PRINT;
    253253
    254 #elif defined(VBOX_WS_X11)
     254#elif defined(VBOX_WS_NIX)
    255255
    256256    return (IsModifierKey(iKeyCode) /* allow modifiers */ ||
    … …  
    302302        default:           return 0;
    303303
    304 #elif defined(VBOX_WS_X11)
     304#elif defined(VBOX_WS_NIX)
    305305
    306306        case XK_Control_L:         return 0x1D;
    … …  
    369369}
    370370
    371 #elif defined(VBOX_WS_X11)
     371#elif defined(VBOX_WS_NIX)
    372372
    373373void UINativeHotKey::retranslateKeyNames()
    … …  
    387387}
    388388
    389 #endif /* VBOX_WS_X11 */
     389#endif /* VBOX_WS_NIX */
    390390
    391391
    … …  
    568568    /* Prepare AltGR monitor: */
    569569    m_pAltGrMonitor = new WinAltGrMonitor;
    570 #elif defined(VBOX_WS_X11)
     570#elif defined(VBOX_WS_NIX)
    571571    /* Initialize the X keyboard subsystem: */
    572572    if (uiCommon().X11ServerAvailable())
    573573        initMappedX11Keyboard(NativeWindowSubsystem::X11GetDisplay(), gEDataManager->remappedScanCodes());
    574 #endif /* VBOX_WS_X11 */
     574#endif /* VBOX_WS_NIX */
    575575}
    576576
    … …  
    743743    }
    744744
    745 # elif defined(VBOX_WS_X11)
     745# elif defined(VBOX_WS_NIX)
    746746    if (uiCommon().X11ServerAvailable())
    747747    {

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIHostComboEditor.h

    r98103 r100064  
    7373    /** Distinguishes modifier VKey by @a wParam and @a lParam. */
    7474    SHARED_LIBRARY_STUFF int distinguishModifierVKey(int wParam, int lParam);
    75 #elif defined(VBOX_WS_X11)
     75#elif defined(VBOX_WS_NIX)
    7676    /** Retranslates key names. */
    7777    SHARED_LIBRARY_STUFF void retranslateKeyNames();

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UISharedFolderDetailsEditor.cpp

    r99840 r100064  
    218218#if defined (VBOX_WS_WIN) || defined (Q_OS_OS2)
    219219        m_pEditorName->setText(strFolderName.toUpper().left(1) + "_DRIVE");
    220 #elif defined (VBOX_WS_X11)
     220#elif defined (VBOX_WS_NIX)
    221221        m_pEditorName->setText("ROOT");
    222222#endif

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

    r98103 r100064  
    120120    oldData.m_scaleFactors = gEDataManager->scaleFactors(UIExtraDataManager::GlobalID);
    121121    oldData.m_fActivateHoveredMachineWindow = gEDataManager->activateHoveredMachineWindow();
    122 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     122#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    123123    oldData.m_fDisableHostScreenSaver = gEDataManager->disableHostScreenSaver();
    124124#endif
    … …  
    285285            && newData.m_fActivateHoveredMachineWindow != oldData.m_fActivateHoveredMachineWindow)
    286286            /* fSuccess = */ gEDataManager->setActivateHoveredMachineWindow(newData.m_fActivateHoveredMachineWindow);
    287 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     287#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    288288        /* Save whether the host screen saver is to be disable when a vm is running: */
    289289        if (   fSuccess
    290290            && newData.m_fDisableHostScreenSaver != oldData.m_fDisableHostScreenSaver)
    291291            /* fSuccess = */ gEDataManager->setDisableHostScreenSaver(newData.m_fDisableHostScreenSaver);
    292 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     292#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    293293        /* Save font scale factor: */
    294294        if (   fSuccess

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

    r98103 r100064  
    692692    color1.setAlpha(0);
    693693    QColor color2 = pal.color(QPalette::Window).darker(200);
    694 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     694#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    695695    QColor color3 = pal.color(QPalette::Window).darker(120);
    696 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     696#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    697697
    698698    /* Acquire metric: */
    … …  
    738738    painter.fillRect(QRect(width() - iMetric, 0, iMetric, height() - iMetric), grad5); // right line
    739739
    740 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     740#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    741741    /* Paint frames: */
    742742    painter.save();
    … …  
    751751        painter.drawLine(QLine(QPoint(width() - 1 - iMetric - 1, 0), QPoint(iMetric + 1, 0)));
    752752    painter.restore();
    753 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     753#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    754754}
    755755

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

    r98103 r100064  
    4040#include <QVBoxLayout>
    4141#include <QWindow>
    42 #ifdef VBOX_WS_X11
     42#ifdef VBOX_WS_NIX
    4343# include <QWindowStateChangeEvent>
    4444#endif
    … …  
    5050#include "UIDesktopWidgetWatchdog.h"
    5151#include "UICommon.h"
    52 #ifdef VBOX_WS_X11
     52#ifdef VBOX_WS_NIX
    5353# include "UIExtraDataManager.h"
    5454#endif
    … …  
    293293
    294294    /* Left margin: */
    295 #ifdef VBOX_WS_X11
     295#ifdef VBOX_WS_NIX
    296296    if (uiCommon().isCompositingManagerRunning())
    297297        m_spacings << widgetForAction(addWidget(new QWidget));
    298 #else /* !VBOX_WS_X11 */
     298#else /* !VBOX_WS_NIX */
    299299    m_spacings << widgetForAction(addWidget(new QWidget));
    300 #endif /* !VBOX_WS_X11 */
     300#endif /* !VBOX_WS_NIX */
    301301
    302302    /* Prepare push-pin: */
    … …  
    348348
    349349    /* Right margin: */
    350 #ifdef VBOX_WS_X11
     350#ifdef VBOX_WS_NIX
    351351    if (uiCommon().isCompositingManagerRunning())
    352352        m_spacings << widgetForAction(addWidget(new QWidget));
    353 #else /* !VBOX_WS_X11 */
     353#else /* !VBOX_WS_NIX */
    354354    m_spacings << widgetForAction(addWidget(new QWidget));
    355 #endif /* !VBOX_WS_X11 */
     355#endif /* !VBOX_WS_NIX */
    356356}
    357357
    358358void UIMiniToolBarPrivate::rebuildShape()
    359359{
    360 #ifdef VBOX_WS_X11
     360#ifdef VBOX_WS_NIX
    361361    if (!uiCommon().isCompositingManagerRunning())
    362362        return;
    363 #endif /* VBOX_WS_X11 */
     363#endif /* VBOX_WS_NIX */
    364364
    365365    /* Rebuild shape: */
    … …  
    409409    Q_UNUSED(geometryType);
    410410
    411 #ifdef VBOX_WS_X11
     411#ifdef VBOX_WS_NIX
    412412    /* Depending on current WM: */
    413413    switch (uiCommon().typeOfWindowManager())
    … …  
    428428        default: break;
    429429    }
    430 #endif /* VBOX_WS_X11 */
     430#endif /* VBOX_WS_NIX */
    431431
    432432    /* Frameless window by default: */
    … …  
    454454    , m_pHoverLeaveTimer(0)
    455455    , m_pAnimation(0)
    456 #ifdef VBOX_WS_X11
     456#ifdef VBOX_WS_NIX
    457457    , m_fIsParentMinimized(false)
    458458#endif
    … …  
    555555        m_pToolbar->move(m_hiddenToolbarPosition);
    556556
    557 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     557#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    558558    /* Adjust window mask: */
    559559    setMask(m_pToolbar->geometry());
    560 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     560#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    561561}
    562562
    … …  
    569569        /* Just call the method asynchronously, after possible popups opened: */
    570570        QTimer::singleShot(0, this, SLOT(sltCheckWindowActivationSanity()));
    571 #elif defined(VBOX_WS_X11)
     571#elif defined(VBOX_WS_NIX)
    572572        // WORKAROUND:
    573573        // Under certain WMs we can receive stolen activation event too early,
    … …  
    576576        // so we are going to check for window activation in let's say 100ms.
    577577        QTimer::singleShot(100, this, SLOT(sltCheckWindowActivationSanity()));
    578 #endif /* VBOX_WS_X11 */
     578#endif /* VBOX_WS_NIX */
    579579    }
    580580
    … …  
    648648                break;
    649649            }
    650 #ifdef VBOX_WS_X11
     650#ifdef VBOX_WS_NIX
    651651            case QEvent::WindowStateChange:
    652652            {
    … …  
    694694                break;
    695695            }
    696 #endif /* VBOX_WS_X11 */
     696#endif /* VBOX_WS_NIX */
    697697            default:
    698698                break;
    … …  
    818818    hide();
    819819
    820 #elif defined(VBOX_WS_X11)
     820#elif defined(VBOX_WS_NIX)
    821821
    822822    /* Just hide window: */
    … …  
    869869    }
    870870
    871 #elif defined(VBOX_WS_X11)
     871#elif defined(VBOX_WS_NIX)
    872872
    873873    /* Show window in necessary mode: */
    … …  
    979979    }
    980980
    981 #elif defined(VBOX_WS_X11)
     981#elif defined(VBOX_WS_NIX)
    982982
    983983    switch (m_geometryType)
    … …  
    10731073    /* Enable translucency through Qt API: */
    10741074    setAttribute(Qt::WA_TranslucentBackground);
    1075 #elif defined(VBOX_WS_X11)
     1075#elif defined(VBOX_WS_NIX)
    10761076    /* Enable translucency through Qt API if supported: */
    10771077    if (uiCommon().isCompositingManagerRunning())
    10781078        setAttribute(Qt::WA_TranslucentBackground);
    1079 #endif /* VBOX_WS_X11 */
     1079#endif /* VBOX_WS_NIX */
    10801080
    10811081    /* Make sure we have no focus: */
    … …  
    11471147    adjustGeometry();
    11481148
    1149 #ifdef VBOX_WS_X11
     1149#ifdef VBOX_WS_NIX
    11501150    /* Hide mini-toolbar from taskbar and pager: */
    11511151    NativeWindowSubsystem::X11SetSkipTaskBarFlag(this);
    … …  
    11911191    m_pToolbar->move(point);
    11921192
    1193 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     1193#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    11941194    /* Update window mask: */
    11951195    setMask(m_pToolbar->geometry());
    1196 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     1196#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    11971197}
    11981198
    … …  
    12061206bool UIMiniToolBar::isParentMinimized() const
    12071207{
    1208 #ifdef VBOX_WS_X11
     1208#ifdef VBOX_WS_NIX
    12091209    return m_fIsParentMinimized;
    12101210#else

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

    r98103 r100064  
    212212    UIAnimation *m_pAnimation;
    213213
    214 #ifdef VBOX_WS_X11
     214#ifdef VBOX_WS_NIX
    215215    /** X11: Holds whether the parent is currently minimized.
    216216      * Used to restore the full-screen/maximized state

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

    r98103 r100064  
    263263#if defined(VBOX_WS_MAC)
    264264    font.setPointSize(font.pointSize() - 2);
    265 #elif defined(VBOX_WS_X11)
     265#elif defined(VBOX_WS_NIX)
    266266    font.setPointSize(font.pointSize() - 1);
    267267#endif

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

    r98103 r100064  
    213213#if defined(VBOX_WS_MAC)
    214214    font.setPointSize(font.pointSize() - 2);
    215 #elif defined(VBOX_WS_X11)
     215#elif defined(VBOX_WS_NIX)
    216216    font.setPointSize(font.pointSize() - 1);
    217217#endif

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

    r98103 r100064  
    136136    /* Use Qt API to enable translucency: */
    137137    setAttribute(Qt::WA_TranslucentBackground);
    138 #elif defined(VBOX_WS_X11)
     138#elif defined(VBOX_WS_NIX)
    139139    if (uiCommon().isCompositingManagerRunning())
    140140    {
    … …  
    142142        setAttribute(Qt::WA_TranslucentBackground);
    143143    }
    144 #endif /* VBOX_WS_X11 */
     144#endif /* VBOX_WS_NIX */
    145145
    146146    /* Prepare contents: */
    … …  
    212212    }
    213213
    214 #ifdef VBOX_WS_X11
     214#ifdef VBOX_WS_NIX
    215215    if (!uiCommon().isCompositingManagerRunning())
    216216    {
    … …  
    270270    m_pWidget->setGeometry(0, 0, qMax(width(), sh.width()), sh.height());
    271271
    272 #ifdef VBOX_WS_X11
     272#ifdef VBOX_WS_NIX
    273273    if (!uiCommon().isCompositingManagerRunning())
    274274    {
    … …  
    306306    m_pWidget->setGeometry(rect);
    307307
    308 #ifdef VBOX_WS_X11
     308#ifdef VBOX_WS_NIX
    309309    if (!uiCommon().isCompositingManagerRunning())
    310310    {

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

    r100030 r100064  
    525525    color1.setAlpha(0);
    526526    QColor color2 = pal.color(QPalette::Window).darker(200);
    527 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     527#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    528528    QColor color3 = pal.color(QPalette::Window).darker(120);
    529 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     529#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    530530
    531531    /* Acquire metric: */
    … …  
    571571    painter.fillRect(QRect(width() - iMetric, iMetric, iMetric, height() - iMetric), grad5); // right line
    572572
    573 #if defined(VBOX_WS_WIN) || defined(VBOX_WS_X11)
     573#if defined(VBOX_WS_WIN) || defined(VBOX_WS_NIX)
    574574    /* Paint frames: */
    575575    painter.save();
    … …  
    584584                           QPoint(iMetric + 1,               iMetric + 1)));
    585585    painter.restore();
    586 #endif /* VBOX_WS_WIN || VBOX_WS_X11 */
     586#endif /* VBOX_WS_WIN || VBOX_WS_NIX */
    587587
    588588    /* Paint drop token: */
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