VirtualBox

Changeset 20433 in vbox for trunk/src


Ignore:
Timestamp:
Jun 9, 2009 12:40:36 PM (16 years ago)
Author:
vboxsync
Message:

VBoxSDL: made it compile with SDL1.3 to support multiple guest monitors (disabled)

Location:
trunk/src/VBox/Frontends/VBoxSDL
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.cpp

    r19844 r20433  
    6666}
    6767#endif /* VBOX_SECURELABEL */
     68
     69static SDL_Surface *gWMIcon;                    /**< the application icon */
     70static RTNATIVETHREAD gSdlNativeThread;         /**< the SDL thread */
    6871
    6972//
    … …  
    8386 * @param iFixedHeight   fixed SDL height (-1 means not set)
    8487 */
    85 VBoxSDLFB::VBoxSDLFB(bool fFullscreen, bool fResizable, bool fShowSDLConfig,
     88VBoxSDLFB::VBoxSDLFB(uint32_t uScreenId,
     89                     bool fFullscreen, bool fResizable, bool fShowSDLConfig,
    8690                     bool fKeepHostRes, uint32_t u32FixedWidth,
    8791                     uint32_t u32FixedHeight, uint32_t u32FixedBPP)
    … …  
    9498#endif
    9599
     100    mScreenId       = uScreenId;
    96101    mScreen         = NULL;
     102#ifdef VBOX_WITH_SDL13
     103    mWindow         = 0;
     104    mTexture        = 0;
     105#endif
    97106    mSurfVRAM       = NULL;
    98107    mfInitialized   = false;
    … …  
    105114    mFixedSDLHeight = u32FixedHeight;
    106115    mFixedSDLBPP    = u32FixedBPP;
    107     mDefaultSDLBPP  = 32;
    108116    mCenterXOffset  = 0;
    109117    mCenterYOffset  = 0;
    … …  
    122130    mLabelOffs      = 0;
    123131#endif
    124     mWMIcon         = NULL;
    125 
    126     /* memorize the thread that inited us, that's the SDL thread */
    127     mSdlNativeThread = RTThreadNativeSelf();
    128132
    129133    rc = RTCritSectInit(&mUpdateLock);
    130134    AssertMsg(rc == VINF_SUCCESS, ("Error from RTCritSectInit!\n"));
     135
     136    resizeGuest();
     137    Assert(mScreen);
     138    mfInitialized = true;
     139}
     140
     141VBoxSDLFB::~VBoxSDLFB()
     142{
     143    LogFlow(("VBoxSDLFB::~VBoxSDLFB\n"));
     144    if (mSurfVRAM)
     145    {
     146        SDL_FreeSurface(mSurfVRAM);
     147        mSurfVRAM = NULL;
     148    }
     149    mScreen = NULL;
     150
     151#ifdef VBOX_SECURELABEL
     152    if (mLabelFont)
     153        pTTF_CloseFont(mLabelFont);
     154    if (pTTF_Quit)
     155        pTTF_Quit();
     156#endif
     157
     158    RTCritSectDelete(&mUpdateLock);
     159}
     160
     161void VBoxSDLFB::init(bool fShowSDLConfig)
     162{
     163    LogFlow(("VBoxSDLFB::init\n"));
     164
     165    /* memorize the thread that inited us, that's the SDL thread */
     166    gSdlNativeThread = RTThreadNativeSelf();
    131167
    132168#ifdef RT_OS_WINDOWS
    … …  
    143179    RTEnvSet("SDL_VIDEO_X11_DGAMOUSE", "0");
    144180#endif
    145     rc = SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_NOPARACHUTE);
     181    int rc = SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_NOPARACHUTE);
    146182    if (rc != 0)
    147183    {
    … …  
    154190    if (videoInfo)
    155191    {
    156         switch (videoInfo->vfmt->BitsPerPixel)
    157         {
    158             case 16: mDefaultSDLBPP = 16; break;
    159             case 24: mDefaultSDLBPP = 24; break;
    160             default:
    161             case 32: mDefaultSDLBPP = 32; break;
    162         }
    163 
    164192        /* output what SDL is capable of */
    165         if (mfShowSDLConfig)
     193        if (fShowSDLConfig)
    166194            RTPrintf("SDL capabilities:\n"
    167195                     "  Hardware surface support:                    %s\n"
    … …  
    193221    if (12320 == g_cbIco64x01)
    194222    {
    195         mWMIcon = SDL_AllocSurface(SDL_SWSURFACE, 64, 64, 24, 0xff, 0xff00, 0xff0000, 0);
     223        gWMIcon = SDL_AllocSurface(SDL_SWSURFACE, 64, 64, 24, 0xff, 0xff00, 0xff0000, 0);
    196224        /** @todo make it as simple as possible. No PNM interpreter here... */
    197         if (mWMIcon)
     225        if (gWMIcon)
    198226        {
    199             memcpy(mWMIcon->pixels, g_abIco64x01+32, g_cbIco64x01-32);
    200             SDL_WM_SetIcon(mWMIcon, NULL);
     227            memcpy(gWMIcon->pixels, g_abIco64x01+32, g_cbIco64x01-32);
     228            SDL_WM_SetIcon(gWMIcon, NULL);
    201229        }
    202230    }
    203 
    204     resizeGuest();
    205     Assert(mScreen);
    206     mfInitialized = true;
    207 }
    208 
    209 VBoxSDLFB::~VBoxSDLFB()
    210 {
    211     LogFlow(("VBoxSDLFB::~VBoxSDLFB\n"));
    212     RTCritSectDelete(&mUpdateLock);
    213 }
    214 
     231}
     232
     233/**
     234 * Terminate SDL
     235 *
     236 * @remarks must be called from the SDL thread!
     237 */
     238void VBoxSDLFB::uninit()
     239{
     240    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
     241    SDL_QuitSubSystem(SDL_INIT_VIDEO);
     242    if (gWMIcon)
     243    {
     244        SDL_FreeSurface(gWMIcon);
     245        gWMIcon = NULL;
     246    }
     247}
    215248
    216249/**
    … …  
    280313        return E_INVALIDARG;
    281314
    282     if (mSurfVRAM)
    283     {
    284         *address = (BYTE *) mSurfVRAM->pixels;
    285     }
    286     else
     315    if (!mSurfVRAM)
    287316    {
    288317        /* That's actually rather bad. */
    … …  
    290319        return E_FAIL;
    291320    }
     321
     322    *address = (BYTE *) mSurfVRAM->pixels;
    292323    LogFlow(("VBoxSDL::GetAddress returning %p\n", *address));
    293324    return S_OK;
    … …  
    425456    SDL_Event event;
    426457    event.type       = SDL_USEREVENT;
     458    event.user.code  = mScreenId;
    427459    event.user.type  = SDL_USER_EVENT_UPDATERECT;
    428460    // 16 bit is enough for coordinates
    … …  
    502534    event.type       = SDL_USEREVENT;
    503535    event.user.type  = SDL_USER_EVENT_RESIZE;
     536    event.user.code  = mScreenId;
    504537
    505538    /* Try multiple times if necessary */
    … …  
    593626{
    594627    LogFlowFunc (("mGuestXRes: %d, mGuestYRes: %d\n", mGuestXRes, mGuestYRes));
    595     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(),
     628    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(),
    596629              ("Wrong thread! SDL is not threadsafe!\n"));
    597630
    … …  
    643676    if (mUsesGuestVRAM)
    644677    {
    645 
    646678        /* Create a source surface from guest VRAM. */
    647679        mSurfVRAM = SDL_CreateRGBSurfaceFrom(mPtrVRAM, mGuestXRes, mGuestYRes, mBitsPerPixel,
    648680                                             mBytesPerLine, Rmask, Gmask, Bmask, Amask);
     681        LogRel(("mSurfVRAM from guest %d x %d\n", mGuestXRes,  mGuestYRes));
    649682    }
    650683    else
    … …  
    653686        mSurfVRAM = SDL_CreateRGBSurface(SDL_SWSURFACE, mGuestXRes, mGuestYRes, mBitsPerPixel,
    654687                                         Rmask, Gmask, Bmask, Amask);
     688        LogRel(("mSurfVRAM from SDL %d x %d\n", mGuestXRes,  mGuestYRes));
    655689    }
    656690    LogFlow(("VBoxSDL:: created VRAM surface %p\n", mSurfVRAM));
    … …  
    751785    mTopOffset = 0;
    752786
     787#if defined(VBOX_WITH_SDL13)
     788    int sdlWindowFlags = SDL_WINDOW_SHOWN;
     789    if (mfResizable)
     790        sdlWindowFlags |= SDL_WINDOW_RESIZABLE;
     791    if (!mWindow)
     792    {
     793        SDL_DisplayMode desktop_mode;
     794        int x = 40 + mScreenId * 20;
     795        int y = 40 + mScreenId * 15;
     796
     797        SDL_GetDesktopDisplayMode(&desktop_mode);
     798        /* create new window */
     799       
     800        char szTitle[64];
     801        RTStrPrintf(szTitle, sizeof(szTitle), "SDL window %d", mScreenId);
     802        mWindow = SDL_CreateWindow(szTitle, x, y,
     803                                   newWidth, newHeight, sdlWindowFlags);
     804        if (SDL_CreateRenderer(mWindow, -1,
     805                               SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0)
     806            AssertReleaseFailed();
     807
     808        SDL_GetRendererInfo(&mRenderInfo);
     809
     810        mTexture = SDL_CreateTexture(desktop_mode.format,
     811                                     SDL_TEXTUREACCESS_STREAMING, newWidth, newHeight);
     812        if (!mTexture)
     813            AssertReleaseFailed();
     814    }
     815    else
     816    {
     817        int w, h;
     818        uint32_t format;
     819        int access;
     820
     821        /* resize current window */
     822        SDL_GetWindowSize(mWindow, &w, &h);
     823
     824        if (w != (int)newWidth || h != (int)newHeight)
     825            SDL_SetWindowSize(mWindow, newWidth, newHeight);
     826
     827        SDL_QueryTexture(mTexture, &format, &access, &w, &h);
     828        SDL_SelectRenderer(mWindow);
     829        SDL_DestroyTexture(mTexture);
     830        mTexture = SDL_CreateTexture(format, access, newWidth, newHeight);
     831        if (!mTexture)
     832            AssertReleaseFailed();
     833    }
     834
     835    void *pixels;
     836    int pitch;
     837    int w, h, bpp;
     838    uint32_t Rmask, Gmask, Bmask, Amask;
     839    uint32_t format;
     840
     841    if (SDL_QueryTexture(mTexture, &format, NULL, &w, &h) < 0)
     842        AssertReleaseFailed();
     843
     844    if (!SDL_PixelFormatEnumToMasks(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask))
     845        AssertReleaseFailed();
     846
     847    if (SDL_QueryTexturePixels(mTexture, &pixels, &pitch) == 0)
     848    {
     849        mScreen = SDL_CreateRGBSurfaceFrom(pixels, w, h, bpp, pitch,
     850                                           Rmask, Gmask, Bmask, Amask);
     851    }
     852    else
     853    {
     854        mScreen = SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);
     855        AssertReleaseFailed();
     856    }
     857
     858    SDL_SetClipRect(mScreen, NULL);
     859
     860#else
    753861    /*
    754862     * Now set the screen resolution and get the surface pointer
    … …  
    756864     */
    757865    mScreen = SDL_SetVideoMode(newWidth, newHeight, 0, sdlFlags);
     866#endif
    758867#ifdef VBOX_SECURELABEL
    759868    /*
    … …  
    816925{
    817926#ifdef VBOXSDL_WITH_X11
    818     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
     927    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
    819928#endif
    820929    Assert(mScreen);
    … …  
    822931    if (!mScreen || !mSurfVRAM)
    823932        return;
    824 
     933   
    825934    /* the source and destination rectangles */
    826935    SDL_Rect srcRect;
    … …  
    880989    dstRect.h = RT_MAX(0, h - yCutoffGuest);
    881990
    882     //RTPrintf("y = %d h = %d mapped to srcY %d srcH %d mapped to dstY = %d dstH %d (guestrel: %d, mLabelHeight: %d, mTopOffset: %d)\n",
    883     //         y, h, srcRect.y, srcRect.h, dstRect.y, dstRect.h, fGuestRelative, mLabelHeight, mTopOffset);
    884 
    885991    /*
    886992     * Now we just blit
    … …  
    888994    SDL_BlitSurface(mSurfVRAM, &srcRect, mScreen, &dstRect);
    889995    /* hardware surfaces don't need update notifications */
     996#if defined(VBOX_WITH_SDL13)
     997    AssertRelease(mScreen->flags & SDL_PREALLOC);
     998    SDL_SelectRenderer(mWindow);
     999    SDL_DirtyTexture(mTexture, 1, &dstRect);
     1000    AssertRelease(mRenderInfo.flags & SDL_RENDERER_PRESENTCOPY);
     1001    SDL_RenderCopy(mTexture, &dstRect, &dstRect);
     1002    SDL_RenderPresent();
     1003#else
    8901004    if ((mScreen->flags & SDL_HWSURFACE) == 0)
    8911005        SDL_UpdateRect(mScreen, dstRect.x, dstRect.y, dstRect.w, dstRect.h);
     1006#endif
    8921007
    8931008#ifdef VBOX_SECURELABEL
    … …  
    9041019void VBoxSDLFB::repaint()
    9051020{
    906     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
     1021    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
    9071022    LogFlow(("VBoxSDLFB::repaint\n"));
    9081023    update(0, 0, mScreen->w, mScreen->h, false /* fGuestRelative */);
    9091024}
    9101025
    911 bool VBoxSDLFB::getFullscreen()
    912 {
    913     LogFlow(("VBoxSDLFB::getFullscreen\n"));
    914     return mfFullscreen;
    915 }
    916 
    9171026/**
    9181027 * Toggle fullscreen mode
    … …  
    9221031void VBoxSDLFB::setFullscreen(bool fFullscreen)
    9231032{
    924     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
     1033    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
    9251034    LogFlow(("VBoxSDLFB::SetFullscreen: fullscreen: %d\n", fFullscreen));
    9261035    mfFullscreen = fFullscreen;
    … …  
    9651074}
    9661075
    967 /**
    968  * Returns the current x offset of the start of the guest screen
    969  *
    970  * @returns current x offset in pixels
    971  */
    972 int VBoxSDLFB::getXOffset()
    973 {
    974     /* there can only be an offset for centering */
    975     return mCenterXOffset;
    976 }
    977 
    978 /**
    979  * Returns the current y offset of the start of the guest screen
    980  *
    981  * @returns current y offset in pixels
    982  */
    983 int VBoxSDLFB::getYOffset()
    984 {
    985     /* we might have a top offset and a center offset */
    986     return mTopOffset + mCenterYOffset;
    987 }
    988 
    9891076#ifdef VBOX_SECURELABEL
    9901077/**
    … …  
    10511138{
    10521139#ifdef VBOXSDL_WITH_X11
    1053     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
     1140    AssertMsg(gSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
    10541141#endif
    10551142    /* only when the function is present */
    … …  
    10861173}
    10871174#endif /* VBOX_SECURELABEL */
    1088 
    1089 /**
    1090  * Terminate SDL
    1091  *
    1092  * @remarks must be called from the SDL thread!
    1093  */
    1094 void VBoxSDLFB::uninit()
    1095 {
    1096     AssertMsg(mSdlNativeThread == RTThreadNativeSelf(), ("Wrong thread! SDL is not threadsafe!\n"));
    1097     if (mSurfVRAM)
    1098     {
    1099         SDL_FreeSurface(mSurfVRAM);
    1100         mSurfVRAM = NULL;
    1101     }
    1102     SDL_QuitSubSystem(SDL_INIT_VIDEO);
    1103 #ifdef VBOX_SECURELABEL
    1104     if (mLabelFont)
    1105         pTTF_CloseFont(mLabelFont);
    1106     if (pTTF_Quit)
    1107         pTTF_Quit();
    1108 #endif
    1109     mScreen = NULL;
    1110     if (mWMIcon)
    1111     {
    1112         SDL_FreeSurface(mWMIcon);
    1113         mWMIcon = NULL;
    1114     }
    1115 }
    11161175
    11171176// IFramebufferOverlay

  • trunk/src/VBox/Frontends/VBoxSDL/Framebuffer.h

    r19844 r20433  
    4242extern DECLSPEC void (SDLCALL *pTTF_Quit)(void);
    4343}
    44 #endif /* VBOX_SECURELABEL */
     44#endif /* VBOX_SECURELABEL && !VBOX_WITH_SDL13 */
    4545
    4646class VBoxSDLFBOverlay;
    … …  
    5050{
    5151public:
    52     VBoxSDLFB(bool fFullscreen = false, bool fResizable = true, bool fShowSDLConfig = false,
     52    VBoxSDLFB(uint32_t uScreenId,
     53              bool fFullscreen = false, bool fResizable = true, bool fShowSDLConfig = false,
    5354              bool fKeepHostRes = false, uint32_t u32FixedWidth = ~(uint32_t)0,
    5455              uint32_t u32FixedHeight = ~(uint32_t)0, uint32_t u32FixedBPP = ~(uint32_t)0);
    5556    virtual ~VBoxSDLFB();
     57
     58    static void init(bool fShowSDLConfig);
     59    static void uninit();
    5660
    5761#ifdef RT_OS_WINDOWS
    … …  
    118122    void update(int x, int y, int w, int h, bool fGuestRelative);
    119123    void repaint();
    120     bool getFullscreen();
    121124    void setFullscreen(bool fFullscreen);
    122     int  getXOffset();
    123     int  getYOffset();
    124125    void getFullscreenGeometry(uint32_t *width, uint32_t *height);
     126    uint32_t getScreenId() { return mScreenId; }
    125127    uint32_t getGuestXRes() { return mGuestXRes; }
    126128    uint32_t getGuestYRes() { return mGuestYRes; }
     129    int32_t getOriginX() { return mOriginX; }
     130    int32_t getOriginY() { return mOriginY; }
     131    int32_t getXOffset() { return mCenterXOffset; }
     132    int32_t getYOffset() { return mCenterYOffset; }
     133#ifdef VBOX_WITH_SDL13
     134    bool hasWindow(SDL_WindowID id) { return mScreen && mWindow == id; }
     135#endif
    127136#ifdef VBOX_SECURELABEL
    128137    int  initSecureLabel(uint32_t height, char *font, uint32_t pointsize, uint32_t labeloffs);
    … …  
    131140    void paintSecureLabel(int x, int y, int w, int h, bool fForce);
    132141#endif
    133     void uninit();
    134142    void setWinId(uint64_t winId) { mWinId = winId; }
     143    void setOrigin(int32_t axOrigin, int32_t ayOrigin) { mOriginX = axOrigin; mOriginY = ayOrigin; }
     144    bool getFullscreen() { return mfFullscreen; }
    135145
    136146private:
    137     /** the sdl thread */
    138     RTNATIVETHREAD mSdlNativeThread;
    139147    /** current SDL framebuffer pointer (also includes screen width/height) */
    140148    SDL_Surface *mScreen;
     149#ifdef VBOX_WITH_SDL13
     150    /** the SDL window */
     151    SDL_WindowID mWindow;
     152    /** the texture */
     153    SDL_TextureID mTexture;
     154    /** render info */
     155    SDL_RendererInfo mRenderInfo;
     156#endif
    141157    /** false if constructor failed */
    142158    bool mfInitialized;
     159    /** the screen number of this framebuffer */
     160    uint32_t mScreenId;
    143161    /** maximum possible screen width in pixels (~0 = no restriction) */
    144162    uint32_t mMaxScreenWidth;
    … …  
    149167    /** current guest screen height in pixels */
    150168    ULONG mGuestYRes;
     169    int32_t mOriginX;
     170    int32_t mOriginY;
    151171    /** fixed SDL screen width (~0 = not set) */
    152172    uint32_t mFixedSDLWidth;
    … …  
    155175    /** fixed SDL bits per pixel (~0 = not set) */
    156176    uint32_t mFixedSDLBPP;
    157     /** default BPP */
    158     uint32_t mDefaultSDLBPP;
    159177    /** Y offset in pixels, i.e. guest-nondrawable area at the top */
    160178    uint32_t mTopOffset;
    … …  
    189207    /** secure label offset from the top of the secure label */
    190208    uint32_t mLabelOffs;
     209
    191210#endif
    192211#ifdef RT_OS_WINDOWS
    … …  
    201220    BOOL mUsesGuestVRAM;
    202221    BOOL mfSameSizeRequested;
    203 
    204     /** the application Icon */
    205     SDL_Surface *mWMIcon;
    206222};
    207223

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

    r18422 r20433  
    6666
    6767VBoxSDL_DEFS       =
    68 ifdef VBOX_WITH_SECURELABEL
    69  VBoxSDL_DEFS     += VBOX_SECURELABEL
     68ifdef VBOX_WITH_SDL13
     69 VBoxSDL_DEFS     += VBOX_WITH_SDL13
     70else
     71 ifdef VBOX_WITH_SECURELABEL
     72  VBoxSDL_DEFS    += VBOX_SECURELABEL
     73 endif
    7074endif
    7175ifdef VBOX_WITH_VRDP

  • trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

    r20374 r20433  
    148148static void    InputGrabStart(void);
    149149static void    InputGrabEnd(void);
    150 static void    SendMouseEvent(int dz, int button, int down);
     150static void    SendMouseEvent(VBoxSDLFB *fb, int dz, int button, int down);
    151151static void    UpdateTitlebar(TitlebarMode mode, uint32_t u32User = 0);
    152152static void    SetPointerShape(const PointerShapeChangeData *data);
    … …  
    158158static int     WaitSDLEvent(SDL_Event *event);
    159159static void    SetFullscreen(bool enable);
     160#ifdef VBOX_WITH_SDL13
     161static VBoxSDLFB * getFbFromWinId(SDL_WindowID id);
     162#endif
    160163
    161164
    … …  
    188191static BOOL gfGuestScrollLockPressed = FALSE;
    189192static BOOL gfACPITerm = FALSE;
    190 static BOOL gfXCursorEnabled = TRUE;
     193static BOOL gfXCursorEnabled = FALSE;
    191194static int  gcGuestNumLockAdaptions = 2;
    192195static int  gcGuestCapsLockAdaptions = 2;
    … …  
    206209static ComPtr<IProgress> gProgress;
    207210
    208 static VBoxSDLFB  *gpFrameBuffer = NULL;
     211static unsigned   gcMonitors = 1;
     212static VBoxSDLFB  *gpFramebuffer[64];
     213//static VBoxSDLFB  *gpFramebufferCurrent = NULL;
    209214static SDL_Cursor *gpDefaultCursor = NULL;
    210215#ifdef VBOXSDL_WITH_X11
    … …  
    215220#endif
    216221static SDL_Cursor *gpCustomCursor = NULL;
     222#ifndef VBOX_WITH_SDL13
    217223static WMcursor   *gpCustomOrigWMcursor = NULL;
     224#endif
    218225static SDL_Cursor *gpOffCursor = NULL;
    219226static SDL_TimerID gSdlResizeTimer = NULL;
    220227static SDL_TimerID gSdlQuitTimer = NULL;
    221228
    222 #ifdef VBOXSDL_WITH_X11
     229#if defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITH_SDL13)
    223230static SDL_SysWMinfo gSdlInfo;
    224231#endif
    … …  
    19611968#endif
    19621969
    1963     // create our SDL framebuffer instance
    1964     gpFrameBuffer = new VBoxSDLFB(fFullscreen, fResizable, fShowSDLConfig, false,
    1965                                   fixedWidth, fixedHeight, fixedBPP);
    1966 
    1967     if (!gpFrameBuffer)
    1968     {
    1969         RTPrintf("Error: could not create framebuffer object!\n");
    1970         goto leave;
     1970    /* static initialization of the SDL stuff */
     1971    VBoxSDLFB::init(fShowSDLConfig);
     1972
     1973    gMachine->COMGETTER(MonitorCount)(&gcMonitors);
     1974    if (gcMonitors > 64)
     1975        gcMonitors = 64;
     1976
     1977    for (unsigned i = 0; i < gcMonitors; i++)
     1978    {
     1979        // create our SDL framebuffer instance
     1980        gpFramebuffer[i] = new VBoxSDLFB(i, fFullscreen, fResizable, fShowSDLConfig, false,
     1981                                         fixedWidth, fixedHeight, fixedBPP);
     1982
     1983        if (!gpFramebuffer[i])
     1984        {
     1985            RTPrintf("Error: could not create framebuffer object!\n");
     1986            goto leave;
     1987        }
    19711988    }
    19721989
    19731990#ifdef VBOX_WIN32_UI
    1974     gpFrameBuffer->setWinId(winId);
    1975 #endif
    1976 
    1977     if (!gpFrameBuffer->initialized())
    1978         goto leave;
    1979     gpFrameBuffer->AddRef();
    1980     if (fFullscreen)
    1981         SetFullscreen(true);
     1991    gpFramebuffer[0]->setWinId(winId);
     1992#endif
     1993
     1994    for (unsigned i = 0; i < gcMonitors; i++)
     1995    {
     1996        if (!gpFramebuffer[i]->initialized())
     1997            goto leave;
     1998        gpFramebuffer[i]->AddRef();
     1999        if (fFullscreen)
     2000            SetFullscreen(true);
     2001    }
    19822002
    19832003#ifdef VBOX_SECURELABEL
    … …  
    20112031            rcVBox = RTLdrGetSymbol(gLibrarySDL_ttf, "TTF_Quit", (void**)&pTTF_Quit);
    20122032        if (RT_SUCCESS(rcVBox))
    2013             rcVBox = gpFrameBuffer->initSecureLabel(SECURE_LABEL_HEIGHT, secureLabelFontFile, secureLabelPointSize, secureLabelFontOffs);
     2033            rcVBox = gpFramebuffer[0]->initSecureLabel(SECURE_LABEL_HEIGHT, secureLabelFontFile, secureLabelPointSize, secureLabelFontOffs);
    20142034        if (RT_FAILURE(rcVBox))
    20152035        {
    … …  
    20242044         * Now update the label
    20252045         */
    2026         gpFrameBuffer->setSecureLabelColor(secureLabelColorFG, secureLabelColorBG);
    2027         gpFrameBuffer->setSecureLabelText(labelUtf8.raw());
     2046        gpFramebuffer[0]->setSecureLabelColor(secureLabelColorFG, secureLabelColorBG);
     2047        gpFramebuffer[0]->setSecureLabelText(labelUtf8.raw());
    20282048    }
    20292049#endif
    … …  
    20372057#endif
    20382058
    2039     // register our framebuffer
    2040     rc = gDisplay->SetFramebuffer(VBOX_VIDEO_PRIMARY_SCREEN, gpFrameBuffer);
    2041     if (rc != S_OK)
    2042     {
    2043         RTPrintf("Error: could not register framebuffer object!\n");
    2044         goto leave;
    2045     }
     2059    for (unsigned i = 0; i < gcMonitors; i++)
     2060    {
     2061        // register our framebuffer
     2062        rc = gDisplay->SetFramebuffer(i, gpFramebuffer[i]);
     2063        if (rc != S_OK)
     2064        {
     2065            RTPrintf("Error: could not register framebuffer object!\n");
     2066            goto leave;
     2067        }
     2068        IFramebuffer *dummyFb;
     2069        int xOrigin, yOrigin;
     2070        rc = gDisplay->GetFramebuffer(i, &dummyFb, &xOrigin, &yOrigin);
     2071        gpFramebuffer[i]->setOrigin(xOrigin, yOrigin);
     2072    }
     2073//    gpFramebufferCurrent = gpFramebuffer[0];
    20462074
    20472075    // register a callback for global events
    … …  
    21442172    gpDefaultCursor = SDL_GetCursor();
    21452173
    2146 #ifdef VBOXSDL_WITH_X11
     2174#if !defined(VBOX_WITH_SDL13)
     2175# if defined(VBOXSDL_WITH_X11)
    21472176    /* Get Window Manager info. We only need the X11 display. */
    21482177    SDL_VERSION(&gSdlInfo.version);
    21492178    if (!SDL_GetWMInfo(&gSdlInfo))
    2150     {
    21512179        RTPrintf("Error: could not get SDL Window Manager info -- no Xcursor support!\n");
    2152         gfXCursorEnabled = FALSE;
    2153     }
    2154 
    2155 # if !defined(VBOX_WITHOUT_XCURSOR)
     2180    else
     2181        gfXCursorEnabled = TRUE;
     2182
     2183#  if !defined(VBOX_WITHOUT_XCURSOR)
    21562184    /* SDL uses its own (plain) default cursor. Use the left arrow cursor instead which might look
    21572185     * much better if a mouse cursor theme is installed. */
    … …  
    21622190        SDL_SetCursor(gpDefaultCursor);
    21632191    }
    2164 # endif
    2165 #endif /* VBOXSDL_WITH_X11 */
     2192#  endif
     2193# endif /* VBOXSDL_WITH_X11 */
    21662194
    21672195    /* create a fake empty cursor */
    … …  
    21722200        gpCustomCursor->wm_cursor = NULL;
    21732201    }
     2202#endif /* !VBOX_WITH_SDL13 */
    21742203
    21752204    /*
    … …  
    22762305                    {
    22772306                        LogFlow(("SDL_USER_EVENT_RESIZE\n"));
    2278                         gpFrameBuffer->resizeGuest();
     2307                        IFramebuffer *dummyFb;
     2308                        int xOrigin, yOrigin;
     2309                        gpFramebuffer[event.user.code]->resizeGuest();
     2310                        /* update xOrigin, yOrigin -> mouse */
     2311                        rc = gDisplay->GetFramebuffer(event.user.code, &dummyFb, &xOrigin, &yOrigin);
     2312                        gpFramebuffer[event.user.code]->setOrigin(xOrigin, yOrigin);
    22792313                        /* notify the display that the resize has been completed */
    2280                         gDisplay->ResizeCompleted(0);
     2314                        gDisplay->ResizeCompleted(event.user.code);
    22812315                        break;
    22822316                    }
    … …  
    24002434             * The screen needs to be repainted.
    24012435             */
     2436#ifdef VBOX_WITH_SDL13
     2437            case SDL_WINDOWEVENT:
     2438            {
     2439                switch (event.window.event)
     2440                {
     2441                    case SDL_WINDOWEVENT_EXPOSED:
     2442                    {
     2443                        VBoxSDLFB *fb = getFbFromWinId(event.window.windowID);
     2444                        if (fb)
     2445                            fb->repaint();
     2446                        break;
     2447                    }
     2448                    case SDL_WINDOWEVENT_FOCUS_GAINED:
     2449                    {
     2450                        /* XXX hack */
     2451//                        gpFramebufferCurrent = getFbFromWinId(event.window.windowID);
     2452                        break;
     2453                    }
     2454                    default:
     2455                        break;
     2456                }
     2457            }
     2458#else
    24022459            case SDL_VIDEOEXPOSE:
    24032460            {
    2404                 /// @todo that somehow doesn't seem to work!
    2405                 gpFrameBuffer->repaint();
     2461                gpFramebuffer[0]->repaint();
    24062462                break;
    24072463            }
     2464#endif
    24082465
    24092466            /*
    … …  
    25432600                if (gfGrabbed || UseAbsoluteMouse())
    25442601                {
    2545                     SendMouseEvent(0, 0, 0);
     2602                    VBoxSDLFB *fb;
     2603#ifdef VBOX_WITH_SDL13
     2604                    fb = getFbFromWinId(event.motion.windowID);
     2605#else
     2606                    fb = NULL;
     2607#endif
     2608                    SendMouseEvent(fb, 0, 0, 0);
    25462609                }
    25472610                break;
    … …  
    25962659                    }
    25972660
    2598                     SendMouseEvent(dz, event.type == SDL_MOUSEBUTTONDOWN, bev->button);
     2661                    VBoxSDLFB *fb;
     2662#ifdef VBOX_WITH_SDL13
     2663                    fb = getFbFromWinId(event.button.windowID);
     2664#else
     2665                    fb = NULL;
     2666#endif
     2667                    SendMouseEvent(fb, dz, event.type == SDL_MOUSEBUTTONDOWN, bev->button);
    25992668                }
    26002669                break;
    … …  
    26712740                        x, y, w, h));
    26722741
    2673                 Assert(gpFrameBuffer);
    2674                 gpFrameBuffer->update(x, y, w, h, true /* fGuestRelative */);
     2742                Assert(gpFramebuffer[event.user.code]);
     2743                gpFramebuffer[event.user.code]->update(x, y, w, h, true /* fGuestRelative */);
    26752744
    26762745                #undef DECODEX
    … …  
    27052774            {
    27062775                LogFlow(("SDL_USER_EVENT_RESIZE\n"));
    2707                 gpFrameBuffer->resizeGuest();
     2776                IFramebuffer *dummyFb;
     2777                int xOrigin, yOrigin;
     2778                gpFramebuffer[event.user.code]->resizeGuest();
     2779                /* update xOrigin, yOrigin -> mouse */
     2780                rc = gDisplay->GetFramebuffer(event.user.code, &dummyFb, &xOrigin, &yOrigin);
     2781                gpFramebuffer[event.user.code]->setOrigin(xOrigin, yOrigin);
    27082782                /* notify the display that the resize has been completed */
    2709                 gDisplay->ResizeCompleted(0);
     2783                gDisplay->ResizeCompleted(event.user.code);
    27102784                break;
    27112785            }
    … …  
    27592833                 * Now update the label
    27602834                 */
    2761                 gpFrameBuffer->setSecureLabelText(labelUtf8.raw());
     2835                gpFramebuffer[0]->setSecureLabelText(labelUtf8.raw());
    27622836                break;
    27632837            }
    … …  
    28532927    }
    28542928
     2929#ifndef VBOX_WITH_SDL13
    28552930    /* restore the default cursor and free the custom one if any */
    28562931    if (gpDefaultCursor)
    28572932    {
    2858 #ifdef VBOXSDL_WITH_X11
     2933# ifdef VBOXSDL_WITH_X11
    28592934        Cursor pDefaultTempX11Cursor = *(Cursor*)gpDefaultCursor->wm_cursor;
    28602935        *(Cursor*)gpDefaultCursor->wm_cursor = gpDefaultOrigX11Cursor;
    2861 #endif /* VBOXSDL_WITH_X11 */
     2936# endif /* VBOXSDL_WITH_X11 */
    28622937        SDL_SetCursor(gpDefaultCursor);
    2863 #if defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITHOUT_XCURSOR)
     2938# if defined(VBOXSDL_WITH_X11) && !defined(VBOX_WITHOUT_XCURSOR)
    28642939        if (gfXCursorEnabled)
    28652940            XFreeCursor(gSdlInfo.info.x11.display, pDefaultTempX11Cursor);
    2866 #endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
     2941# endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
    28672942    }
    28682943
    … …  
    28742949        if (pCustomTempWMCursor)
    28752950        {
    2876 #if defined (RT_OS_WINDOWS)
     2951# if defined (RT_OS_WINDOWS)
    28772952            ::DestroyCursor(*(HCURSOR *) pCustomTempWMCursor);
    2878 #elif defined (VBOXSDL_WITH_X11) && !defined (VBOX_WITHOUT_XCURSOR)
     2953# elif defined (VBOXSDL_WITH_X11) && !defined (VBOX_WITHOUT_XCURSOR)
    28792954            if (gfXCursorEnabled)
    28802955                XFreeCursor(gSdlInfo.info.x11.display, *(Cursor *) pCustomTempWMCursor);
    2881 #endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
     2956# endif /* VBOXSDL_WITH_X11 && !VBOX_WITHOUT_XCURSOR */
    28822957            free(pCustomTempWMCursor);
    28832958        }
    28842959    }
     2960#endif
    28852961
    28862962    LogFlow(("Releasing mouse, keyboard, vrdpserver, display, console...\n"));
    28872963    if (gDisplay)
    2888         gDisplay->SetFramebuffer(VBOX_VIDEO_PRIMARY_SCREEN, NULL);
     2964    {
     2965        for (unsigned i = 0; i < gcMonitors; i++)
     2966            gDisplay->SetFramebuffer(0, NULL);
     2967    }
    28892968    gMouse = NULL;
    28902969    gKeyboard = NULL;
    … …  
    28952974    gProgress = NULL;
    28962975    // we can only uninitialize SDL here because it is not threadsafe
    2897     if (gpFrameBuffer)
    2898     {
    2899         LogFlow(("Releasing framebuffer...\n"));
    2900         gpFrameBuffer->uninit();
    2901         gpFrameBuffer->Release();
    2902     }
     2976
     2977    for (unsigned i = 0; i < gcMonitors; i++)
     2978    {     
     2979        if (gpFramebuffer[i])
     2980        {
     2981            LogFlow(("Releasing framebuffer...\n"));
     2982            gpFramebuffer[i]->Release();
     2983            gpFramebuffer[i] = NULL;
     2984        }
     2985    }
     2986
     2987    VBoxSDLFB::uninit();
     2988
    29032989#ifdef VBOX_SECURELABEL
    29042990    /* must do this after destructing the framebuffer */
    … …  
    31373223
    31383224#ifdef VBOXSDL_WITH_X11
     3225# ifdef VBOX_WITH_SDL13
     3226
     3227    switch (ev->keysym.sym)
     3228    {
     3229        case SDLK_ESCAPE:           return 0x01;
     3230        case SDLK_EXCLAIM:
     3231        case SDLK_1:                return 0x02;
     3232        case SDLK_AT:
     3233        case SDLK_2:                return 0x03;
     3234        case SDLK_HASH:
     3235        case SDLK_3:                return 0x04;
     3236        case SDLK_DOLLAR:
     3237        case SDLK_4:                return 0x05;
     3238        /* % */
     3239        case SDLK_5:                return 0x06;
     3240        case SDLK_CARET:
     3241        case SDLK_6:                return 0x07;
     3242        case SDLK_AMPERSAND:
     3243        case SDLK_7:                return 0x08;
     3244        case SDLK_ASTERISK:
     3245        case SDLK_8:                return 0x09;
     3246        case SDLK_LEFTPAREN:
     3247        case SDLK_9:                return 0x0a;
     3248        case SDLK_RIGHTPAREN:
     3249        case SDLK_0:                return 0x0b;
     3250        case SDLK_UNDERSCORE:
     3251        case SDLK_MINUS:            return 0x0c;
     3252        case SDLK_PLUS:             return 0x0d;
     3253        case SDLK_BACKSPACE:        return 0x0e;
     3254        case SDLK_TAB:              return 0x0f;
     3255        case SDLK_q:                return 0x10;
     3256        case SDLK_w:                return 0x11;
     3257        case SDLK_e:                return 0x12;
     3258        case SDLK_r:                return 0x13;
     3259        case SDLK_t:                return 0x14;
     3260        case SDLK_y:                return 0x15;
     3261        case SDLK_u:                return 0x16;
     3262        case SDLK_i:                return 0x17;
     3263        case SDLK_o:                return 0x18;
     3264        case SDLK_p:                return 0x19;
     3265        case SDLK_RETURN:           return 0x1c;
     3266        case SDLK_KP_ENTER:         return 0x1c | 0x100;
     3267        case SDLK_LCTRL:            return 0x1d;
     3268        case SDLK_RCTRL:            return 0x1d | 0x100;
     3269        case SDLK_a:                return 0x1e;
     3270        case SDLK_s:                return 0x1f;
     3271        case SDLK_d:                return 0x20;
     3272        case SDLK_f:                return 0x21;
     3273        case SDLK_g:                return 0x22;
     3274        case SDLK_h:                return 0x23;
     3275        case SDLK_j:                return 0x24;
     3276        case SDLK_k:                return 0x25;
     3277        case SDLK_l:                return 0x26;
     3278        case SDLK_COLON:            return 0x27;
     3279        case SDLK_QUOTEDBL:
     3280        case SDLK_QUOTE:            return 0x28;
     3281        case SDLK_BACKQUOTE:        return 0x29;
     3282        case SDLK_LSHIFT:           return 0x2a;
     3283        case SDLK_z:                return 0x2c;
     3284        case SDLK_x:                return 0x2d;
     3285        case SDLK_c:                return 0x2e;
     3286        case SDLK_v:                return 0x2f;
     3287        case SDLK_b:                return 0x30;
     3288        case SDLK_n:                return 0x31;
     3289        case SDLK_m:                return 0x32;
     3290        case SDLK_LESS:             return 0x33;
     3291        case SDLK_GREATER:          return 0x34;
     3292        case SDLK_KP_DIVIDE:        /*??*/
     3293        case SDLK_QUESTION:         return 0x35;
     3294        case SDLK_RSHIFT:           return 0x36;
     3295        case SDLK_KP_MULTIPLY:
     3296        case SDLK_PRINT:            return 0x37; /* fixme */
     3297        case SDLK_LALT:             return 0x38;
     3298        case SDLK_MODE: /* alt gr*/
     3299        case SDLK_RALT:             return 0x38 | 0x100;
     3300        case SDLK_SPACE:            return 0x39;
     3301        case SDLK_CAPSLOCK:         return 0x3a;
     3302        case SDLK_F1:               return 0x3b;
     3303        case SDLK_F2:               return 0x3c;
     3304        case SDLK_F3:               return 0x3d;
     3305        case SDLK_F4:               return 0x3e;
     3306        case SDLK_F5:               return 0x3f;
     3307        case SDLK_F6:               return 0x40;
     3308        case SDLK_F7:               return 0x41;
     3309        case SDLK_F8:               return 0x42;
     3310        case SDLK_F9:               return 0x43;
     3311        case SDLK_F10:              return 0x44;
     3312        case SDLK_PAUSE:            return 0x45; /* not right */
     3313        case SDLK_NUMLOCK:          return 0x45;
     3314        case SDLK_SCROLLOCK:        return 0x46;
     3315        case SDLK_KP7:              return 0x47;
     3316        case SDLK_HOME:             return 0x47 | 0x100;
     3317        case SDLK_KP8:              return 0x48;
     3318        case SDLK_UP:               return 0x48 | 0x100;
     3319        case SDLK_KP9:              return 0x49;
     3320        case SDLK_PAGEUP:           return 0x49 | 0x100;
     3321        case SDLK_KP_MINUS:         return 0x4a;
     3322        case SDLK_KP4:              return 0x4b;
     3323        case SDLK_LEFT:             return 0x4b | 0x100;
     3324        case SDLK_KP5:              return 0x4c;
     3325        case SDLK_KP6:              return 0x4d;
     3326        case SDLK_RIGHT:            return 0x4d | 0x100;
     3327        case SDLK_KP_PLUS:          return 0x4e;
     3328        case SDLK_KP1:              return 0x4f;
     3329        case SDLK_END:              return 0x4f | 0x100;
     3330        case SDLK_KP2:              return 0x50;
     3331        case SDLK_DOWN:             return 0x50 | 0x100;
     3332        case SDLK_KP3:              return 0x51;
     3333        case SDLK_PAGEDOWN:         return 0x51 | 0x100;
     3334        case SDLK_KP0:              return 0x52;
     3335        case SDLK_INSERT:           return 0x52 | 0x100;
     3336        case SDLK_KP_PERIOD:        return 0x53;
     3337        case SDLK_DELETE:           return 0x53 | 0x100;
     3338        case SDLK_SYSREQ:           return 0x54;
     3339        case SDLK_F11:              return 0x57;
     3340        case SDLK_F12:              return 0x58;
     3341        case SDLK_F13:              return 0x5b;
     3342        case SDLK_F14:              return 0x5c;
     3343        case SDLK_F15:              return 0x5d;
     3344        case SDLK_MENU:             return 0x5d | 0x100;
     3345        default:
     3346                                    return 0;
     3347    }
    31393348    // workaround for SDL keyboard translation issues on Linux
    31403349    // keycodes > 0x100 are sent as 0xe0 keycode
    … …  
    31433352    // work on other hosts or on other servers on Linux hosts.
    31443353    // For a more general approach, see the Wine code in the GUI.
     3354
     3355# else
    31453356    static const uint16_t x_keycode_to_pc_keycode[61] =
    31463357    {
    … …  
    32903501        keycode -= 8;
    32913502    }
    3292 #ifdef RT_OS_LINUX
     3503# ifdef RT_OS_LINUX
    32933504    else if (keycode < 158 && guseEvdevKeymap)
    32943505    {
    … …  
    32963507        keycode = evdev_keycode_to_pc_keycode[keycode - 97];
    32973508    }
    3298 #endif
     3509# endif
    32993510    else if (keycode < 158)
    33003511    {
    … …  
    33163527        keycode = 0;
    33173528    }
    3318 
     3529# endif
    33193530#elif defined(RT_OS_DARWIN)
    33203531    /* This is derived partially from SDL_QuartzKeys.h and partially from testing. */
    … …  
    34913702
    34923703#elif RT_OS_OS2
    3493         keycode = Keyevent2KeycodeFallback(ev);
     3704    keycode = Keyevent2KeycodeFallback(ev);
    34943705#endif /* RT_OS_DARWIN */
    34953706    return keycode;
    … …  
    35253736static void ProcessKey(SDL_KeyboardEvent *ev)
    35263737{
    3527 #if defined(DEBUG) || defined(VBOX_WITH_STATISTICS)
     3738#if (defined(DEBUG) || defined(VBOX_WITH_STATISTICS)) && !defined(VBOX_WITH_SDL13)
    35283739    if (gMachineDebugger && ev->type == SDL_KEYDOWN)
    35293740    {
    … …  
    37914002    SDL_WM_GrabInput(SDL_GRAB_ON);
    37924003    // dummy read to avoid moving the mouse
    3793     SDL_GetRelativeMouseState(NULL, NULL);
     4004    SDL_GetRelativeMouseState(
     4005#ifdef VBOX_WITH_SDL13
     4006                              0,
     4007#endif
     4008                              NULL, NULL);
    37944009    gfGrabbed = TRUE;
    37954010    UpdateTitlebar(TITLEBAR_NORMAL);
    … …  
    38164031 * @param dz  Relative mouse wheel movement
    38174032 */
    3818 static void SendMouseEvent(int dz, int down, int button)
     4033static void SendMouseEvent(VBoxSDLFB *fb, int dz, int down, int button)
    38194034{
    38204035    int  x, y, state, buttons;
    38214036    bool abs;
     4037
     4038#ifdef VBOX_WITH_SDL13
     4039    if (!fb)
     4040    {
     4041        SDL_GetMouseState(0, &x, &y);
     4042        RTPrintf("MouseEvent: Cannot find fb mouse = %d,%d\n", x, y);
     4043        return;
     4044    }
     4045#endif
    38224046
    38234047    /*
    … …  
    38354059
    38364060    /* only used if abs == TRUE */
    3837     int  xMin = gpFrameBuffer->getXOffset();
    3838     int  yMin = gpFrameBuffer->getYOffset();
    3839     int  xMax = xMin + (int)gpFrameBuffer->getGuestXRes();
    3840     int  yMax = yMin + (int)gpFrameBuffer->getGuestYRes();
    3841 
    3842     state = abs ? SDL_GetMouseState(&x, &y) : SDL_GetRelativeMouseState(&x, &y);
     4061    int  xOrigin = fb->getOriginX();
     4062    int  yOrigin = fb->getOriginY();
     4063    int  xMin = fb->getXOffset() + xOrigin;
     4064    int  yMin = fb->getYOffset() + yOrigin;
     4065    int  xMax = xMin + (int)fb->getGuestXRes();
     4066    int  yMax = yMin + (int)fb->getGuestYRes();
     4067
     4068    state = abs ? SDL_GetMouseState(
     4069#ifdef VBOX_WITH_SDL13
     4070                                    0,
     4071#endif
     4072                                    &x, &y)
     4073                : SDL_GetRelativeMouseState(
     4074#ifdef VBOX_WITH_SDL13
     4075                                            0,
     4076#endif
     4077                                            &x, &y);
    38434078
    38444079    /*
    … …  
    38554090    if (abs)
    38564091    {
     4092        x += xOrigin;
     4093        y += yOrigin;
     4094
    38574095        /*
    38584096         * Check if the mouse event is inside the guest area. This solves the
    … …  
    39374175             * or state it in PutMouseEventAbsolute() docs?
    39384176             */
    3939             gMouse->PutMouseEventAbsolute(x + 1 - xMin,
    3940                                           y + 1 - yMin,
     4177            gMouse->PutMouseEventAbsolute(x + 1 - xMin + xOrigin,
     4178                                          y + 1 - yMin + yOrigin,
    39414179                                          dz, buttons | tmp_button);
    39424180        }
    … …  
    39564194         * or state it in PutMouseEventAbsolute() docs?
    39574195         */
    3958         gMouse->PutMouseEventAbsolute(x + 1 - xMin,
    3959                                       y + 1 - yMin,
     4196        gMouse->PutMouseEventAbsolute(x + 1 - xMin + xOrigin,
     4197                                      y + 1 - yMin + yOrigin,
    39604198                                      dz, buttons);
    39614199    }
    … …  
    45214759                }
    45224760
     4761#ifndef VBOX_WITH_SDL13
    45234762                Cursor cur = XcursorImageLoadCursor (gSdlInfo.info.x11.display, img);
    45244763                Assert (cur);
    … …  
    45464785                    ok = true;
    45474786                }
     4787#endif
    45484788            }
    45494789            XcursorImageDestroy (img);
    … …  
    46304870            if (machineState == MachineState_Running)
    46314871                gConsole->Pause();
    4632             SetFullscreen(!gpFrameBuffer->getFullscreen());
     4872            SetFullscreen(!gpFramebuffer[0]->getFullscreen());
    46334873            if (machineState == MachineState_Running)
    46344874                gConsole->Resume();
    … …  
    48825122        int rc = SDL_PushEvent(event);
    48835123        RTSemEventSignal(g_EventSemSDLEvents);
     5124#ifdef VBOX_WITH_SDL13
     5125        if (rc == 1)
     5126#else
    48845127        if (rc == 0)
     5128#endif
    48855129            return 0;
    4886         Log(("PushSDLEventForSure: waiting for 2ms\n"));
     5130        Log(("PushSDLEventForSure: waiting for 2ms (rc = %d)\n", rc));
    48875131        RTThreadSleep(2);
    48885132    }
    … …  
    49005144{
    49015145    int rc = SDL_PushEvent(event);
     5146#ifdef VBOX_WITH_SDL13
     5147    bool fSuccess = (rc == 1);
     5148#else
     5149    bool fSuccess = (rc == 0);
     5150#endif
     5151
    49025152    RTSemEventSignal(g_EventSemSDLEvents);
    4903     AssertMsg(!rc, ("SDL_PushEvent returned SDL error\n"));
     5153    AssertMsg(fSuccess, ("SDL_PushEvent returned SDL error\n"));
    49045154    /* A global counter is faster than SDL_PeepEvents() */
    4905     if (!rc)
     5155    if (fSuccess)
    49065156        ASMAtomicIncS32(&g_cNotifyUpdateEventsPending);
    49075157    /* In order to not flood the SDL event queue, yield the CPU or (if there are already many
    … …  
    49245174static void SetFullscreen(bool enable)
    49255175{
    4926     if (enable == gpFrameBuffer->getFullscreen())
     5176    if (enable == gpFramebuffer[0]->getFullscreen())
    49275177        return;
    49285178
    … …  
    49325182         * The old/default way: SDL will resize the host to fit the guest screen resolution.
    49335183         */
    4934         gpFrameBuffer->setFullscreen(enable);
     5184        gpFramebuffer[0]->setFullscreen(enable);
    49355185    }
    49365186    else
    … …  
    49445194        {
    49455195            /* switch to fullscreen */
    4946             gmGuestNormalXRes = gpFrameBuffer->getGuestXRes();
    4947             gmGuestNormalYRes = gpFrameBuffer->getGuestYRes();
    4948             gpFrameBuffer->getFullscreenGeometry(&NewWidth, &NewHeight);
     5196            gmGuestNormalXRes = gpFramebuffer[0]->getGuestXRes();
     5197            gmGuestNormalYRes = gpFramebuffer[0]->getGuestYRes();
     5198            gpFramebuffer[0]->getFullscreenGeometry(&NewWidth, &NewHeight);
    49495199        }
    49505200        else
    … …  
    49565206        if (NewWidth != 0 && NewHeight != 0)
    49575207        {
    4958             gpFrameBuffer->setFullscreen(enable);
     5208            gpFramebuffer[0]->setFullscreen(enable);
    49595209            gfIgnoreNextResize = TRUE;
    49605210            gDisplay->SetVideoModeHint(NewWidth, NewHeight, 0, 0);
    … …  
    49625212    }
    49635213}
     5214
     5215#ifdef VBOX_WITH_SDL13
     5216static VBoxSDLFB * getFbFromWinId(SDL_WindowID id)
     5217{
     5218    for (unsigned i = 0; i < gcMonitors; i++)
     5219        if (gpFramebuffer[i]->hasWindow(id))
     5220            return gpFramebuffer[i];
     5221
     5222    return NULL;
     5223}
     5224#endif
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