VirtualBox

Changeset 57047 in vbox


Ignore:
Timestamp:
Jul 21, 2015 4:59:24 PM (10 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
101768
Message:

FE/Qt: 5978: Mini-toolbar: Finally, heavy and complex rework for the geometry adjustment mechanism, including both hosts and both modes.

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

Legend:

Unmodified
Added
Removed

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

    r57046 r57047  
    309309    const QRect workingArea = QApplication::desktop()->screenGeometry(iHostScreen);
    310310
    311 #ifndef Q_WS_MAC
     311#if   defined(Q_WS_WIN) || defined(Q_WS_X11)
    312312    /* Set appropriate geometry for window: */
    313313    move(workingArea.topLeft());
    314314    resize(workingArea.size());
    315 #else /* Q_WS_MAC */
     315
     316    /* If there is a mini-toolbar: */
     317    if (m_pMiniToolBar)
     318    {
     319        /* Set appropriate geometry for mini-toolbar: */
     320        m_pMiniToolBar->move(workingArea.topLeft());
     321        m_pMiniToolBar->resize(workingArea.size());
     322    }
     323#elif defined(Q_WS_MAC)
    316324    /* Make sure this window has fullscreen logic: */
    317325    UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
    … …  
    390398#endif /* !Q_WS_X11 */
    391399
    392 #ifdef Q_WS_MAC
     400#if defined(Q_WS_MAC)
    393401        /* ML and next using native stuff, so we can call for simple show(),
    394402         * Lion and previous using Qt stuff, so we should call for showFullScreen(): */
    … …  
    404412            showFullScreen();
    405413        }
    406 #else /* !Q_WS_MAC */
     414#elif defined(Q_WS_WIN) || defined(Q_WS_X11)
    407415        /* Show window in fullscreen mode: */
    408416        showFullScreen();
    409 #endif /* !Q_WS_MAC */
     417
     418        /* If there is a mini-toolbar: */
     419        if (m_pMiniToolBar)
     420        {
     421            /* Show mini-toolbar in full-screen mode: */
     422            m_pMiniToolBar->showFullScreen();
     423        }
     424#endif /* Q_WS_WIN || Q_WS_X11 */
    410425
    411426#ifdef Q_WS_X11
    … …  
    415430            /* Tell recent window managers which host-screen this window should be mapped to: */
    416431            VBoxGlobal::setFullScreenMonitorX11(this, pFullscreenLogic->hostScreenForGuestScreen(m_uScreenId));
    417         }
    418 #endif /* Q_WS_X11 */
    419 
    420     /* Adjust machine-view size if necessary: */
    421     adjustMachineViewSize();
    422 
    423 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
    424         /* If there is a mini-toolbar: */
    425         if (m_pMiniToolBar)
    426         {
    427 # if   defined(Q_WS_WIN)
    428             /* Show mini-toolbar: */
    429             m_pMiniToolBar->show();
    430 # elif defined(Q_WS_X11)
    431             /* Allow mini-toolbar to be located on full-screen area: */
    432             m_pMiniToolBar->showFullScreen();
    433             /* On modern window managers: */
    434             if (fSupportsNativeFullScreen)
     432
     433            /* If there is a mini-toolbar: */
     434            if (m_pMiniToolBar)
    435435            {
    436                 /* We also can map mini-toolbar directly on corresponding machine-window: */
     436                /* Tell recent window managers which host-screen this mini-toolbar should be mapped to: */
    437437                VBoxGlobal::setFullScreenMonitorX11(m_pMiniToolBar, pFullscreenLogic->hostScreenForGuestScreen(m_uScreenId));
    438438            }
    439 # endif /* Q_WS_X11 */
    440         }
    441 #endif /* Q_WS_WIN || Q_WS_X11 */
     439        }
     440#endif /* Q_WS_X11 */
    442441
    443442        /* Make sure machine-view have focus: */
    444443        m_pMachineView->setFocus();
    445444    }
    446 }
    447 
    448 void UIMachineWindowFullscreen::adjustMachineViewSize()
    449 {
    450     /* Call to base-class: */
    451     UIMachineWindow::adjustMachineViewSize();
    452 
    453 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
    454     /* If mini-toolbar present: */
    455     if (m_pMiniToolBar)
    456     {
    457         /* Make sure this window has fullscreen logic: */
    458         const UIMachineLogicFullscreen *pFullscreenLogic = qobject_cast<UIMachineLogicFullscreen*>(machineLogic());
    459         AssertPtrReturnVoid(pFullscreenLogic);
    460 
    461         /* Which host-screen should that machine-window located on? */
    462         const int iHostScreen = pFullscreenLogic->hostScreenForGuestScreen(m_uScreenId);
    463 
    464 # ifndef Q_WS_X11
    465         /* Move mini-toolbar into appropriate place: */
    466         m_pMiniToolBar->adjustGeometry(iHostScreen);
    467 # else /* Q_WS_X11 */
    468         /* On modern WMs we are mapping mini-toolbar to corresponding host-screen directly. */
    469         const bool fSupportsNativeFullScreen = VBoxGlobal::supportsFullScreenMonitorsProtocolX11() &&
    470                                                !gEDataManager->legacyFullscreenModeRequested();
    471         /* Adjust mini-toolbar and move into appropriate place if necessary: */
    472         m_pMiniToolBar->adjustGeometry(fSupportsNativeFullScreen ? -1 : iHostScreen);
    473 # endif /* Q_WS_X11 */
    474     }
    475 #endif /* Q_WS_WIN || Q_WS_X11 */
    476445}
    477446

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

    r57027 r57047  
    9797    void showInNecessaryMode();
    9898
    99     /** Adjusts machine-view size to correspond current machine-window size. */
    100     virtual void adjustMachineViewSize();
    101 
    10299#if defined(Q_WS_WIN) || defined(Q_WS_X11)
    103100    /** Common update routine. */

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

    r57046 r57047  
    181181    move(workingArea.topLeft());
    182182    resize(workingArea.size());
     183
     184#if defined(Q_WS_WIN) || defined(Q_WS_X11)
     185    /* If there is a mini-toolbar: */
     186    if (m_pMiniToolBar)
     187    {
     188        /* Set appropriate geometry for mini-toolbar: */
     189        m_pMiniToolBar->move(workingArea.topLeft());
     190        m_pMiniToolBar->resize(workingArea.size());
     191    }
     192#endif /* Q_WS_WIN || Q_WS_X11 */
    183193}
    184194
    … …  
    217227        show();
    218228
    219         /* Adjust machine-view size if necessary: */
    220         adjustMachineViewSize();
    221 
    222229#if defined(Q_WS_WIN) || defined(Q_WS_X11)
    223230        /* If there is a mini-toolbar: */
    224231        if (m_pMiniToolBar)
    225232        {
    226 # if   defined(Q_WS_WIN)
    227233            /* Show mini-toolbar in normal mode: */
    228234            m_pMiniToolBar->show();
    229 # elif defined(Q_WS_X11)
    230             /* Show mini-toolbar in maximized mode: */
    231             m_pMiniToolBar->showMaximized();
    232 # endif /* Q_WS_X11 */
    233235        }
    234236#endif /* Q_WS_WIN || Q_WS_X11 */
    … …  
    237239        m_pMachineView->setFocus();
    238240    }
    239 }
    240 
    241 void UIMachineWindowSeamless::adjustMachineViewSize()
    242 {
    243     /* Call to base-class: */
    244     UIMachineWindow::adjustMachineViewSize();
    245 
    246 #if defined(Q_WS_WIN) || defined(Q_WS_X11)
    247     /* If mini-toolbar present: */
    248     if (m_pMiniToolBar)
    249     {
    250         /* Make sure this window has seamless logic: */
    251         const UIMachineLogicSeamless *pSeamlessLogic = qobject_cast<UIMachineLogicSeamless*>(machineLogic());
    252         AssertPtrReturnVoid(pSeamlessLogic);
    253 
    254         /* Which host-screen should that machine-window located on? */
    255         const int iHostScreen = pSeamlessLogic->hostScreenForGuestScreen(m_uScreenId);
    256 
    257         /* Move mini-toolbar into appropriate place: */
    258         m_pMiniToolBar->adjustGeometry(iHostScreen);
    259     }
    260 #endif /* Q_WS_WIN || Q_WS_X11 */
    261241}
    262242

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

    r57027 r57047  
    6969    void showInNecessaryMode();
    7070
    71     /** Adjusts machine-view size to correspond current machine-window size. */
    72     virtual void adjustMachineViewSize();
    73 
    7471#if defined(Q_WS_WIN) || defined(Q_WS_X11)
    7572    /** Common update routine. */

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

    r57026 r57047  
    470470}
    471471
    472 void UIMiniToolBar::adjustGeometry(int iHostScreen /* = -1 */)
    473 {
    474 #ifndef Q_WS_X11
    475     /* This method could be called before parent-widget
    476      * become visible, we should skip everything in that case: */
    477     if (QApplication::desktop()->screenNumber(parentWidget()) == -1)
    478         return;
    479 
    480     /* Determine host-screen number if necessary: */
    481     if (iHostScreen == -1)
    482         iHostScreen = QApplication::desktop()->screenNumber(parentWidget());
    483 
    484     /* Reset toolbar geometry: */
    485     m_pEmbeddedToolbar->move(0, 0);
     472void UIMiniToolBar::adjustGeometry()
     473{
     474    /* Resize embedded-toolbar to minimum size: */
    486475    m_pEmbeddedToolbar->resize(m_pEmbeddedToolbar->sizeHint());
    487476
    488     /* Adjust window geometry: */
    489     resize(m_pEmbeddedToolbar->size());
    490     QRect screenRect;
     477    /* Calculate embedded-toolbar position: */
    491478    int iX = 0, iY = 0;
    492     switch (m_geometryType)
    493     {
    494         case GeometryType_Available: screenRect = QApplication::desktop()->availableGeometry(iHostScreen); break;
    495         case GeometryType_Full:      screenRect = QApplication::desktop()->screenGeometry(iHostScreen); break;
     479    iX = width() / 2 - m_pEmbeddedToolbar->width() / 2;
     480    switch (m_alignment)
     481    {
     482        case Qt::AlignTop:    iY = 0; break;
     483        case Qt::AlignBottom: iY = height() - m_pEmbeddedToolbar->height(); break;
    496484        default: break;
    497485    }
    498     iX = screenRect.x() + screenRect.width() / 2 - width() / 2;
     486
     487    /* Update auto-hide animation: */
     488    m_shownToolbarPosition = QPoint(iX, iY);
    499489    switch (m_alignment)
    500490    {
    501         case Qt::AlignTop:    iY = screenRect.y(); break;
    502         case Qt::AlignBottom: iY = screenRect.y() + screenRect.height() - height(); break;
    503         default: break;
    504     }
    505     move(iX, iY);
    506 
    507     /* Recalculate auto-hide animation: */
    508     m_shownToolbarPosition = m_pEmbeddedToolbar->pos();
    509     switch (m_alignment)
    510     {
    511         case Qt::AlignTop:
    512             m_hiddenToolbarPosition = m_shownToolbarPosition - QPoint(0, m_pEmbeddedToolbar->height() - 3);
    513             break;
    514         case Qt::AlignBottom:
    515             m_hiddenToolbarPosition = m_shownToolbarPosition + QPoint(0, m_pEmbeddedToolbar->height() - 3);
    516             break;
     491        case Qt::AlignTop:    m_hiddenToolbarPosition = m_shownToolbarPosition - QPoint(0, m_pEmbeddedToolbar->height() - 3); break;
     492        case Qt::AlignBottom: m_hiddenToolbarPosition = m_shownToolbarPosition + QPoint(0, m_pEmbeddedToolbar->height() - 3); break;
    517493    }
    518494    m_pAnimation->update();
    … …  
    524500        m_pEmbeddedToolbar->move(m_hiddenToolbarPosition);
    525501
     502#ifdef Q_WS_X11
     503    /* Adjust window mask: */
     504    setMask(m_pEmbeddedToolbar->geometry());
     505#endif /* Q_WS_X11 */
     506
    526507    /* Simulate toolbar auto-hiding: */
    527508    simulateToolbarAutoHiding();
    528 
    529 #else /* Q_WS_X11 */
    530 
    531     /* This method could be called before parent-widget
    532      * become visible, we should skip everything in that case: */
    533     if (QApplication::desktop()->screenNumber(parentWidget()) == -1)
    534         return;
    535 
    536     /* Determine host-screen number if necessary: */
    537     bool fMoveToHostScreen = true;
    538     if (iHostScreen == -1)
    539     {
    540         fMoveToHostScreen = false;
    541         iHostScreen = QApplication::desktop()->screenNumber(this);
    542     }
    543 
    544     /* Choose window geometry: */
    545     QRect screenRect;
    546     switch (m_geometryType)
    547     {
    548         case GeometryType_Available: screenRect = QApplication::desktop()->availableGeometry(iHostScreen); break;
    549         case GeometryType_Full:      screenRect = QApplication::desktop()->screenGeometry(iHostScreen); break;
    550         default: break;
    551     }
    552 
    553     /* Move to corresponding host-screen: */
    554     if (fMoveToHostScreen)
    555         move(screenRect.topLeft());
    556 
    557     /* Resize embedded-toolbar to minimum size: */
    558     m_pEmbeddedToolbar->resize(m_pEmbeddedToolbar->sizeHint());
    559 
    560     /* Calculate embedded-toolbar position: */
    561     int iX = 0, iY = 0;
    562     iX = screenRect.width() / 2 - m_pEmbeddedToolbar->width() / 2;
    563     switch (m_alignment)
    564     {
    565         case Qt::AlignTop:    iY = 0; break;
    566         case Qt::AlignBottom: iY = screenRect.height() - m_pEmbeddedToolbar->height(); break;
    567         default: break;
    568     }
    569 
    570     /* Update auto-hide animation: */
    571     m_shownToolbarPosition = QPoint(iX, iY);
    572     switch (m_alignment)
    573     {
    574         case Qt::AlignTop:    m_hiddenToolbarPosition = m_shownToolbarPosition - QPoint(0, m_pEmbeddedToolbar->height() - 3); break;
    575         case Qt::AlignBottom: m_hiddenToolbarPosition = m_shownToolbarPosition + QPoint(0, m_pEmbeddedToolbar->height() - 3); break;
    576     }
    577     m_pAnimation->update();
    578 
    579     /* Update embedded-toolbar geometry if known: */
    580     if (property("AnimationState").toString() == "Final")
    581         m_pEmbeddedToolbar->move(m_shownToolbarPosition);
    582     else
    583         m_pEmbeddedToolbar->move(m_hiddenToolbarPosition);
    584 
    585     /* Adjust window mask: */
    586     setMask(m_pEmbeddedToolbar->geometry());
    587 
    588     /* Simulate toolbar auto-hiding: */
    589     simulateToolbarAutoHiding();
    590 #endif /* Q_WS_X11 */
    591509}
    592510
    … …  
    757675}
    758676
    759 #ifdef Q_WS_X11
    760677void UIMiniToolBar::resizeEvent(QResizeEvent*)
    761678{
    … …  
    763680    adjustGeometry();
    764681}
    765 #endif /* Q_WS_X11 */
    766682
    767683bool UIMiniToolBar::eventFilter(QObject *pWatched, QEvent *pEvent)

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

    r57023 r57047  
    9393    void addMenus(const QList<QMenu*> &menus);
    9494
    95     /** Adjusts geometry according to @a iHostScreen. */
    96     void adjustGeometry(int iHostScreen = -1);
     95    /** Adjusts geometry. */
     96    void adjustGeometry();
    9797
    9898private slots:
    … …  
    124124    void leaveEvent(QEvent *pEvent);
    125125
    126 #ifdef Q_WS_X11
    127     /** X11: Resize @a pEvent handler. */
     126    /** Resize @a pEvent handler. */
    128127    void resizeEvent(QResizeEvent *pEvent);
    129 #endif /* Q_WS_X11 */
    130128
    131129    /** Filters @a pEvent if <i>this</i> object has been
Note: See TracChangeset for help on using the changeset viewer.

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