VirtualBox

Ignore:
Timestamp:
Feb 8, 2023 12:59:38 PM (2 years ago)
Author:
vboxsync
Message:

FE/Qt: bugref:10322: Runtime UI: Rework CKeyboard wrapper usage the way it's fully encapsulated inside UISession.

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

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VirtualBox/src/notificationcenter/UINotificationObjects.cpp

    r98482 r98500  
    6161#include "CHostNetworkInterface.h"
    6262#include "CHostOnlyNetwork.h"
     63#include "CKeyboard.h"
    6364#include "CMediumAttachment.h"
    6465#include "CNATNetwork.h"
     
    922923        QApplication::translate("UIMessageCenter", "Failed to assign update agent parameter.") +
    923924        UIErrorString::formatErrorInfo(comAgent));
     925}
     926
     927/* static */
     928void UINotificationMessage::cannotChangeKeyboardParameter(const CKeyboard &comKeyboard)
     929{
     930    createMessage(
     931        QApplication::translate("UIMessageCenter", "Keyboard failure ..."),
     932        QApplication::translate("UIMessageCenter", "Failed to assign keyboard parameter.") +
     933        UIErrorString::formatErrorInfo(comKeyboard));
    924934}
    925935
  • trunk/src/VBox/Frontends/VirtualBox/src/notificationcenter/UINotificationObjects.h

    r98482 r98500  
    7272class CCloudProfile;
    7373class CEmulatedUSB;
     74class CKeyboard;
    7475class CNetworkAdapter;
    7576class CVirtualBox;
     
    381382          * @param  comAgent  Brings the object parameter being changed for. */
    382383        static void cannotChangeUpdateAgentParameter(const CUpdateAgent &comAgent);
     384        /** Notifies about inability to change IKeyboard parameter.
     385          * @param  comKeyboard  Brings the object parameter being changed for. */
     386        static void cannotChangeKeyboardParameter(const CKeyboard &comKeyboard);
    383387        /** Notifies about inability to change IVirtualSystemDescription parameter.
    384388          * @param  comVsd  Brings the object parameter being changed for. */
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIKeyboardHandler.cpp

    r98451 r98500  
    6161#include "UIMouseHandler.h"
    6262#include "UINotificationCenter.h"
    63 #include "UISession.h"
    6463#ifdef VBOX_WS_MAC
    6564# include "UICocoaApplication.h"
     
    7473# include "VBoxUtils-x11.h"
    7574#endif
    76 
    77 /* COM includes: */
    78 #include "CKeyboard.h"
    7975
    8076/* Other VBox includes: */
     
    440436                    codes << ((idxCode & 0x7F) | 0x80);
    441437                }
    442                 keyboard().PutScancodes(codes);
     438                uimachine()->putScancodes(codes);
    443439                fSentRESEND = true;
    444440            }
    445441            if (m_pressedKeys[i] & IsKeyPressed)
    446                 keyboard().PutScancode(i | 0x80);
     442                uimachine()->putScancode(i | 0x80);
    447443            else
    448444            {
     
    450446                codes[0] = 0xE0;
    451447                codes[1] = i | 0x80;
    452                 keyboard().PutScancodes(codes);
     448                uimachine()->putScancodes(codes);
    453449            }
    454450        }
     
    723719                /* And release left Ctrl key early (if required): */
    724720                if (m_pAltGrMonitor->isLeftControlReleaseNeeded())
    725                     keyboard().PutScancode(0x1D | 0x80);
     721                    uimachine()->putScancode(0x1D | 0x80);
    726722            }
    727723
     
    10901086}
    10911087
    1092 CKeyboard &UIKeyboardHandler::keyboard() const
    1093 {
    1094     return machineLogic()->uisession()->keyboard();
    1095 }
    1096 
    10971088/* Event handler for prepared listener(s): */
    10981089bool UIKeyboardHandler::eventFilter(QObject *pWatchedObject, QEvent *pEvent)
     
    12411232                            combo[3] = 0xd7 + (pKeyEvent->key() - Qt::Key_F11); /* F11-F12 up   */
    12421233                        }
    1243                         keyboard().PutScancodes(combo);
     1234                        uimachine()->putScancodes(combo);
    12441235                    }
    12451236                    /* Process hot keys not processed in keyEvent() (as in case of non-alphanumeric keys): */
     
    15931584}
    15941585
    1595 void UIKeyboardHandler::keyEventReleaseHostComboKeys(const CKeyboard &constKeyboard)
    1596 {
    1597     /* Get keyboard: */
    1598     CKeyboard keyboard(constKeyboard);
    1599     /* We have to make guest to release pressed keys from the host-combination: */
    1600     QList<uint8_t> hostComboScans = m_pressedHostComboKeys.values();
    1601     for (int i = 0 ; i < hostComboScans.size(); ++i)
    1602     {
    1603         uint8_t uScan = hostComboScans[i];
    1604         if (m_pressedKeys[uScan] & IsKeyPressed)
    1605         {
    1606             keyboard.PutScancode(uScan | 0x80);
    1607         }
    1608         else if (m_pressedKeys[uScan] & IsExtKeyPressed)
    1609         {
    1610             QVector<LONG> scancodes(2);
    1611             scancodes[0] = 0xE0;
    1612             scancodes[1] = uScan | 0x80;
    1613             keyboard.PutScancodes(scancodes);
    1614         }
    1615         m_pressedKeys[uScan] = 0;
    1616     }
    1617 }
    1618 
    16191586bool UIKeyboardHandler::keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey /* = 0 */)
    16201587{
     
    17491716            for (uint i = 0; i < uCodesCount; ++i)
    17501717                scancodes.append(pCodes[i]);
    1751             keyboard().PutScancodes(scancodes);
     1718            uimachine()->putScancodes(scancodes);
    17521719        }
    17531720
     
    17551722        if (isHostComboStateChanged && m_bIsHostComboPressed)
    17561723        {
    1757             keyEventReleaseHostComboKeys(keyboard());
     1724            /* We have to make guest to release pressed keys from the host-combination: */
     1725            foreach (const uint8_t &uScan, m_pressedHostComboKeys.values())
     1726            {
     1727                if (m_pressedKeys[uScan] & IsKeyPressed)
     1728                {
     1729                    uimachine()->putScancode(uScan | 0x80);
     1730                }
     1731                else if (m_pressedKeys[uScan] & IsExtKeyPressed)
     1732                {
     1733                    QVector<LONG> scancodes(2);
     1734                    scancodes[0] = 0xE0;
     1735                    scancodes[1] = uScan | 0x80;
     1736                    uimachine()->putScancodes(scancodes);
     1737                }
     1738                m_pressedKeys[uScan] = 0;
     1739            }
    17581740        }
    17591741    }
     
    19311913            if (!(ns & IsKeyPressed))
    19321914                codes[0] |= 0x80;
    1933             keyboard().PutScancode(codes[0]);
     1915            uimachine()->putScancode(codes[0]);
    19341916        }
    19351917        else if ((os & IsExtKeyPressed) != (ns & IsExtKeyPressed))
     
    19391921            if (!(ns & IsExtKeyPressed))
    19401922                codes[1] |= 0x80;
    1941             keyboard().PutScancodes(codes);
     1923            uimachine()->putScancodes(codes);
    19421924        }
    19431925    }
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIKeyboardHandler.h

    r98451 r98500  
    5555class UIMachineView;
    5656class UIMachineWindow;
    57 class CKeyboard;
    5857#ifdef VBOX_WS_WIN
    5958class WinAltGrMonitor;
     
    148147    UIActionPool *actionPool() const;
    149148    UIMachine *uimachine() const;
    150 
    151     /** Returns the console's keyboard reference. */
    152     CKeyboard &keyboard() const;
    153149
    154150    /* Event handler for registered machine-view(s): */
     
    171167    bool keyEventHostComboHandled(int iKey, wchar_t *pUniKey, bool isHostComboStateChanged, bool *pfResult);
    172168    void keyEventHandleHostComboRelease(ulong uScreenId);
    173     void keyEventReleaseHostComboKeys(const CKeyboard &keyboard);
    174169    /* Separate function to handle most of existing keyboard-events: */
    175170    bool keyEvent(int iKey, uint8_t uScan, int fFlags, ulong uScreenId, wchar_t *pUniKey = 0);
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachine.cpp

    r98490 r98500  
    441441{
    442442    return uisession()->isGuestSupportsSeamless();
     443}
     444
     445void UIMachine::putScancode(LONG iCode)
     446{
     447    uisession()->putScancode(iCode);
     448}
     449
     450void UIMachine::putScancodes(const QVector<LONG> &codes)
     451{
     452    uisession()->putScancodes(codes);
     453}
     454
     455void UIMachine::putCad()
     456{
     457    uisession()->putCad();
     458}
     459
     460void UIMachine::releaseKeys()
     461{
     462    uisession()->releaseKeys();
     463}
     464
     465void UIMachine::putUsageCode(LONG iUsageCode, LONG iUsagePage, BOOL fKeyRelease)
     466{
     467    uisession()->putUsageCode(iUsageCode, iUsagePage, fKeyRelease);
    443468}
    444469
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachine.h

    r98490 r98500  
    314314        /** Returns the keyboard-state. */
    315315        int keyboardState() const { return m_iKeyboardState; }
     316
     317        /** Sends a scan @a iCode to VM's keyboard. */
     318        void putScancode(LONG iCode);
     319        /** Sends a list of scan @a codes to VM's keyboard. */
     320        void putScancodes(const QVector<LONG> &codes);
     321        /** Sends the CAD sequence to VM's keyboard. */
     322        void putCad();
     323        /** Releases all keys. */
     324        void releaseKeys();
     325        /** Sends a USB HID @a iUsageCode and @a iUsagePage to VM's keyboard.
     326          * The @a fKeyRelease flag is set when the key is being released. */
     327        void putUsageCode(LONG iUsageCode, LONG iUsagePage, BOOL fKeyRelease);
    316328    /** @} */
    317329
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

    r98451 r98500  
    312312{
    313313    return uisession()->mouse();
    314 }
    315 
    316 CKeyboard& UIMachineLogic::keyboard() const
    317 {
    318     return uisession()->keyboard();
    319314}
    320315
     
    20402035    {
    20412036        QWidget *pCenterWidget = windowManager().realParentWindow(activeMachineWindow());
    2042         m_pSoftKeyboardDialog = new UISoftKeyboard(0, uimachine(), uisession(),
    2043                                                    pCenterWidget, machine().GetName());
     2037        m_pSoftKeyboardDialog = new UISoftKeyboard(0, uimachine(), pCenterWidget, machine().GetName());
    20442038        connect(m_pSoftKeyboardDialog, &UISoftKeyboard::sigClose, this, &UIMachineLogic::sltCloseSoftKeyboardDefault);
    20452039    }
     
    20672061void UIMachineLogic::sltTypeCAD()
    20682062{
    2069     keyboard().PutCAD();
    2070     AssertWrapperOk(keyboard());
     2063    uimachine()->putCad();
    20712064}
    20722065
     
    20812074    sequence[4] = 0x38 | 0x80; /* Alt up */
    20822075    sequence[5] = 0x1d | 0x80; /* Ctrl up */
    2083     keyboard().PutScancodes(sequence);
    2084     AssertWrapperOk(keyboard());
     2076    uimachine()->putScancodes(sequence);
    20852077}
    20862078#endif /* VBOX_WS_X11 */
     
    20952087    sequence[4] = 0x46 | 0x80; /* Break up */
    20962088    sequence[5] = 0x1d | 0x80; /* Ctrl up */
    2097     keyboard().PutScancodes(sequence);
    2098     AssertWrapperOk(keyboard());
     2089    uimachine()->putScancodes(sequence);
    20992090}
    21002091
     
    21062097    sequence[2] = 0xE0;        /* Extended flag */
    21072098    sequence[3] = 0x52 | 0x80; /* Insert up */
    2108     keyboard().PutScancodes(sequence);
    2109     AssertWrapperOk(keyboard());
     2099    uimachine()->putScancodes(sequence);
    21102100}
    21112101
     
    21212111    sequence[6] = 0xE0;        /* Extended flag */
    21222112    sequence[7] = 0x2A | 0x80; /* Print.. up */
    2123     keyboard().PutScancodes(sequence);
    2124     AssertWrapperOk(keyboard());
     2113    uimachine()->putScancodes(sequence);
    21252114}
    21262115
     
    21382127    sequence[8] = 0x2A | 0x80; /* Print.. up */
    21392128    sequence[9] = 0x38 | 0x80; /* Alt up */
    2140     keyboard().PutScancodes(sequence);
    2141     AssertWrapperOk(keyboard());
     2129    uimachine()->putScancodes(sequence);
    21422130}
    21432131
     
    21652153    }
    21662154
    2167     keyboard().PutScancodes(codes);
    2168     AssertWrapperOk(keyboard());
     2155    uimachine()->putScancodes(codes);
    21692156}
    21702157
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.h

    r98451 r98500  
    6060class CGuest;
    6161class CMouse;
    62 class CKeyboard;
    6362class CMachineDebugger;
    6463class CSnapshot;
     
    131130    /** Returns the console's mouse reference. */
    132131    CMouse& mouse() const;
    133     /** Returns the console's keyboard reference. */
    134     CKeyboard& keyboard() const;
    135132    /** Returns the console's debugger reference. */
    136133    CMachineDebugger& debugger() const;
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

    r98490 r98500  
    264264
    265265    return fOk;
     266}
     267
     268void UISession::putScancode(LONG iCode)
     269{
     270    CKeyboard comKeyboard = keyboard();
     271    comKeyboard.PutScancode(iCode);
     272    if (!comKeyboard.isOk())
     273        UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
     274}
     275
     276void UISession::putScancodes(const QVector<LONG> &codes)
     277{
     278    CKeyboard comKeyboard = keyboard();
     279    comKeyboard.PutScancodes(codes);
     280    if (!comKeyboard.isOk())
     281        UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
     282}
     283
     284void UISession::putCad()
     285{
     286    CKeyboard comKeyboard = keyboard();
     287    comKeyboard.PutCAD();
     288    if (!comKeyboard.isOk())
     289        UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
     290}
     291
     292void UISession::releaseKeys()
     293{
     294    CKeyboard comKeyboard = keyboard();
     295    comKeyboard.ReleaseKeys();
     296    if (!comKeyboard.isOk())
     297        UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
     298}
     299
     300void UISession::putUsageCode(LONG iUsageCode, LONG iUsagePage, BOOL fKeyRelease)
     301{
     302    CKeyboard comKeyboard = keyboard();
     303    comKeyboard.PutUsageCode(iUsageCode, iUsagePage, fKeyRelease);
     304    if (!comKeyboard.isOk())
     305        UINotificationMessage::cannotChangeKeyboardParameter(comKeyboard);
    266306}
    267307
  • trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.h

    r98490 r98500  
    232232    /** @} */
    233233
     234    /** @name Keyboard stuff.
     235     ** @{ */
     236        /** Sends a scan @a iCode to VM's keyboard. */
     237        void putScancode(LONG iCode);
     238        /** Sends a list of scan @a codes to VM's keyboard. */
     239        void putScancodes(const QVector<LONG> &codes);
     240        /** Sends the CAD sequence to VM's keyboard. */
     241        void putCad();
     242        /** Releases all keys. */
     243        void releaseKeys();
     244        /** Sends a USB HID @a iUsageCode and @a iUsagePage to VM's keyboard.
     245          * The @a fKeyRelease flag is set when the key is being released. */
     246        void putUsageCode(LONG iUsageCode, LONG iUsagePage, BOOL fKeyRelease);
     247    /** @} */
     248
    234249    /** @name Guest additions stuff.
    235250     ** @{ */
  • trunk/src/VBox/Frontends/VirtualBox/src/softkeyboard/UISoftKeyboard.cpp

    r98384 r98500  
    5757#include "UIMessageCenter.h"
    5858#include "UIModalWindowManager.h"
    59 #include "UISession.h"
    6059#include "UISoftKeyboard.h"
    6160#include "UICommon.h"
     
    39243923*********************************************************************************************************************************/
    39253924
    3926 UISoftKeyboard::UISoftKeyboard(QWidget *pParent, UIMachine *pMachine, UISession *pSession,
     3925UISoftKeyboard::UISoftKeyboard(QWidget *pParent, UIMachine *pMachine,
    39273926                               QWidget *pCenterWidget, QString strMachineName /* = QString() */)
    39283927    : QMainWindowWithRestorableGeometryAndRetranslateUi(pParent)
    39293928    , m_pMachine(pMachine)
    3930     , m_pSession(pSession)
    39313929    , m_pCenterWidget(pCenterWidget)
    39323930    , m_pMainLayout(0)
     
    39883986        }
    39893987    }
    3990     keyboard().ReleaseKeys();
     3988    m_pMachine->releaseKeys();
    39913989    emit sigClose();
    39923990    event->ignore();
     
    40414039void UISoftKeyboard::sltPutKeyboardSequence(QVector<LONG> sequence)
    40424040{
    4043     keyboard().PutScancodes(sequence);
     4041    m_pMachine->putScancodes(sequence);
    40444042}
    40454043
     
    40474045{
    40484046    for (int i = 0; i < sequence.size(); ++i)
    4049         keyboard().PutUsageCode(sequence[i].first, sequence[i].second, false);
     4047        m_pMachine->putUsageCode(sequence[i].first, sequence[i].second, false);
    40504048}
    40514049
     
    40534051{
    40544052    for (int i = 0; i < sequence.size(); ++i)
    4055         keyboard().PutUsageCode(sequence[i].first, sequence[i].second, true);
     4053        m_pMachine->putUsageCode(sequence[i].first, sequence[i].second, true);
    40564054}
    40574055
     
    42394237    if (m_pLayoutEditor)
    42404238        m_pLayoutEditor->reset();
    4241     keyboard().ReleaseKeys();
     4239    m_pMachine->releaseKeys();
    42424240    update();
    42434241}
     
    43774375void UISoftKeyboard::sltReleaseKeys()
    43784376{
    4379     keyboard().ReleaseKeys();
     4377    m_pMachine->releaseKeys();
    43804378}
    43814379
     
    44724470}
    44734471
    4474 CKeyboard& UISoftKeyboard::keyboard() const
    4475 {
    4476     return m_pSession->keyboard();
    4477 }
    4478 
    44794472#include "UISoftKeyboard.moc"
  • trunk/src/VBox/Frontends/VirtualBox/src/softkeyboard/UISoftKeyboard.h

    r98384 r98500  
    4343
    4444/* Forward declarations: */
    45 class CKeyboard;
    4645class QHBoxLayout;
    4746class QToolButton;
     
    4948class UILayoutSelector;
    5049class UIMachine;
    51 class UISession;
    5250class UISoftKeyboardKey;
    5351class UISoftKeyboardSettingsWidget;
     
    7270public:
    7371
    74     UISoftKeyboard(QWidget *pParent, UIMachine *pMachine, UISession *pSession,
     72    UISoftKeyboard(QWidget *pParent, UIMachine *pMachine,
    7573                   QWidget *pCenterWidget, QString strMachineName = QString());
    7674    ~UISoftKeyboard();
     
    130128    void updateStatusBarMessage(const QString &strLayoutName);
    131129    void updateLayoutSelectorList();
    132     CKeyboard& keyboard() const;
    133130
    134131    UIMachine     *m_pMachine;
    135     UISession     *m_pSession;
    136132    QWidget       *m_pCenterWidget;
    137133    QHBoxLayout   *m_pMainLayout;
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