← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Frontends/VirtualBox/src/runtime/UIMachine.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer
  • Date: 2013-03-07 16:38:36 UTC
  • mfrom: (1.1.13) (3.1.20 experimental)
  • Revision ID: package-import@ubuntu.com-20130307163836-p93jpbgx39tp3gb4
Tags: 4.2.8-dfsg-0ubuntu1
http://bugs.debian.org/691148
http://bugs.debian.org/700823
https://launchpad.net/bugs/1101867
http://bugs.debian.org/700479
http://bugs.debian.org/686994
http://bugs.debian.org/680053
* New upstream release. (Closes: #691148)
  - Fixes compatibility with kernel 3.8. (Closes: #700823; LP: #1101867)
* Switch to my @debian.org email address.
* Move package to contrib as virtualbox 4.2 needs a non-free compiler to
  build the BIOS.
* Build-depend on libdevmapper-dev.
* Refresh patches.
  - Drop 36-fix-ftbfs-xserver-112.patch, cve-2012-3221.patch,
    CVE-2013-0420.patch 37-kcompat-3.6.patch and 38-kcompat-3.7.patch.
* Drop all virtualbox-ose transitional packages.
* Drop the virtualbox-fuse package as vdfuse fails to build with
  virtualbox 4.2.
* Update install files and VBox.sh.
* Bump required kbuild version to 0.1.9998svn2577.
* Fix path to VBoxCreateUSBNode.sh in virtualbox.postinst. (Closes: #700479)
* Add an init script to virtuabox-guest-x11 which loads the vboxvideo
  kernel module. The X Server 1.13 doesn't load it anymore. (Closes: #686994)
* Update man pages. (Closes: #680053)
* Add 36-python-multiarch.patch from Rico Tzschichholz to fix detection of
  python in multiarch paths using pkg-config.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Frontends/VirtualBox/src/runtime/UIMachine.cpp
6
6
 */
7
7
 
8
8
/*
9
 
 * Copyright (C) 2010 Oracle Corporation
 
9
 * Copyright (C) 2010-2012 Oracle Corporation
10
10
 *
11
11
 * This file is part of VirtualBox Open Source Edition (OSE), as
12
12
 * available from http://www.virtualbox.org. This file is free software;
17
17
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18
18
 */
19
19
 
20
 
/* Global includes */
 
20
/* Global includes: */
21
21
#include <QTimer>
22
22
 
23
 
/* Local includes */
 
23
/* Local includes: */
24
24
#include "VBoxGlobal.h"
25
25
#include "UIMachine.h"
26
26
#include "UISession.h"
27
27
#include "UIActionPoolRuntime.h"
28
28
#include "UIMachineLogic.h"
29
29
#include "UIMachineWindow.h"
30
 
 
31
30
#ifdef Q_WS_MAC
32
31
# include <ApplicationServices/ApplicationServices.h>
33
32
#endif /* Q_WS_MAC */
34
33
 
 
34
/* Visual state interface: */
35
35
class UIVisualState : public QObject
36
36
{
37
37
    Q_OBJECT;
38
38
 
 
39
signals:
 
40
 
 
41
    /* Signal to change-state: */
 
42
    void sigChangeVisualState(UIVisualStateType newVisualStateType);
 
43
 
39
44
public:
40
45
 
41
 
    /* Visual state holder constructor: */
 
46
    /* Constructor: */
42
47
    UIVisualState(QObject *pParent, UISession *pSession)
43
48
        : QObject(pParent)
44
49
        , m_pSession(pSession)
51
56
        connect(this, SIGNAL(sigChangeVisualState(UIVisualStateType)), parent(), SLOT(sltChangeVisualState(UIVisualStateType)));
52
57
    }
53
58
 
54
 
    /* Public getters: */
55
 
    UIMachineLogic* machineLogic() const  { return m_pMachineLogic; }
 
59
    /* Destructor: */
 
60
    ~UIVisualState()
 
61
    {
 
62
        /* Cleanup/delete machine logic if exists: */
 
63
        if (m_pMachineLogic)
 
64
        {
 
65
            /* Cleanup the logic object: */
 
66
            m_pMachineLogic->cleanup();
 
67
            /* Destroy the logic object: */
 
68
            UIMachineLogic::destroy(m_pMachineLogic);
 
69
        }
 
70
    }
 
71
 
 
72
    /* Visual state type getter: */
56
73
    virtual UIVisualStateType visualStateType() const = 0;
57
74
 
 
75
    /* Machine logic getter: */
 
76
    UIMachineLogic* machineLogic() const { return m_pMachineLogic; }
 
77
 
 
78
    /* Method to prepare change one visual state to another: */
58
79
    virtual bool prepareChange(UIVisualStateType previousVisualStateType)
59
80
    {
60
81
        m_pMachineLogic = UIMachineLogic::create(this, m_pSession, visualStateType());
77
98
        return fResult;
78
99
    }
79
100
 
80
 
    virtual void change() = 0;
 
101
    /* Method to change one visual state to another: */
 
102
    virtual void change()
 
103
    {
 
104
        /* Prepare the logic object: */
 
105
        m_pMachineLogic->prepare();
 
106
    }
81
107
 
 
108
    /* Method to finish change one visual state to another: */
82
109
    virtual void finishChange()
83
110
    {
84
111
#ifdef Q_WS_MAC
94
121
#endif /* Q_WS_MAC */
95
122
    }
96
123
 
97
 
 
98
 
signals:
99
 
 
100
 
    /* Signal to change-state: */
101
 
    void sigChangeVisualState(UIVisualStateType visualStateType);
102
 
 
103
124
protected:
104
125
 
105
 
    /* Protected members: */
 
126
    /* Variables: */
106
127
    UISession *m_pSession;
107
128
    UIMachineLogic *m_pMachineLogic;
108
129
#ifdef Q_WS_MAC
110
131
#endif /* Q_WS_MAC */
111
132
};
112
133
 
 
134
/* Normal visual state implementation: */
113
135
class UIVisualStateNormal : public UIVisualState
114
136
{
115
137
    Q_OBJECT;
116
138
 
117
139
public:
118
140
 
119
 
    /* Normal visual state holder constructor: */
 
141
    /* Constructor: */
120
142
    UIVisualStateNormal(QObject *pParent, UISession *pSession)
121
143
        : UIVisualState(pParent, pSession) {}
122
144
 
 
145
private slots:
 
146
 
 
147
    /* State-change handlers: */
 
148
    void sltGoToFullscreenMode() { emit sigChangeVisualState(UIVisualStateType_Fullscreen); }
 
149
    void sltGoToSeamlessMode() { emit sigChangeVisualState(UIVisualStateType_Seamless); }
 
150
    void sltGoToScaleMode() { emit sigChangeVisualState(UIVisualStateType_Scale); }
 
151
 
 
152
private:
 
153
 
 
154
    /* Visual state type getter: */
123
155
    UIVisualStateType visualStateType() const { return UIVisualStateType_Normal; }
124
156
 
 
157
    /* Method to change previous visual state to this one: */
125
158
    void change()
126
159
    {
 
160
        /* Call to base-class: */
 
161
        UIVisualState::change();
 
162
 
127
163
        /* Connect action handlers: */
128
164
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SIGNAL(triggered(bool)),
129
165
                this, SLOT(sltGoToFullscreenMode()), Qt::QueuedConnection);
131
167
                this, SLOT(sltGoToSeamlessMode()), Qt::QueuedConnection);
132
168
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Scale), SIGNAL(triggered(bool)),
133
169
                this, SLOT(sltGoToScaleMode()), Qt::QueuedConnection);
134
 
 
135
 
        /* Initialize the logic object: */
136
 
        m_pMachineLogic->initialize();
137
 
    }
138
 
 
139
 
private slots:
140
 
 
141
 
    void sltGoToFullscreenMode()
142
 
    {
143
 
        /* Change visual state to fullscreen: */
144
 
        emit sigChangeVisualState(UIVisualStateType_Fullscreen);
145
 
    }
146
 
 
147
 
    void sltGoToSeamlessMode()
148
 
    {
149
 
        /* Change visual state to seamless: */
150
 
        emit sigChangeVisualState(UIVisualStateType_Seamless);
151
 
    }
152
 
 
153
 
    void sltGoToScaleMode()
154
 
    {
155
 
        /* Change visual state to scale: */
156
 
        emit sigChangeVisualState(UIVisualStateType_Scale);
157
170
    }
158
171
};
159
172
 
 
173
/* Fullscreen visual state implementation: */
160
174
class UIVisualStateFullscreen : public UIVisualState
161
175
{
162
176
    Q_OBJECT;
163
177
 
164
178
public:
165
179
 
166
 
    /* Fullscreen visual state holder constructor: */
 
180
    /* Constructor: */
167
181
    UIVisualStateFullscreen(QObject *pParent, UISession *pSession)
168
182
        : UIVisualState(pParent, pSession)
169
183
    {
178
192
        }
179
193
    }
180
194
 
181
 
    /* Fullscreen visual state holder destructor: */
 
195
    /* Destructor: */
182
196
    virtual ~UIVisualStateFullscreen()
183
197
    {
184
198
        /* This visual state should take care of own action: */
192
206
        }
193
207
    }
194
208
 
 
209
private slots:
 
210
 
 
211
    /* State-change handlers: */
 
212
    void sltGoToNormalMode() { emit sigChangeVisualState(UIVisualStateType_Normal); }
 
213
    void sltGoToSeamlessMode() { emit sigChangeVisualState(UIVisualStateType_Seamless); }
 
214
    void sltGoToScaleMode() { emit sigChangeVisualState(UIVisualStateType_Scale); }
 
215
 
 
216
private:
 
217
 
 
218
    /* Visual state type getter: */
195
219
    UIVisualStateType visualStateType() const { return UIVisualStateType_Fullscreen; }
196
220
 
 
221
    /* Method to change previous visual state to this one: */
197
222
    void change()
198
223
    {
 
224
        /* Call to base-class: */
 
225
        UIVisualState::change();
 
226
 
199
227
        /* Connect action handlers: */
200
228
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Fullscreen), SIGNAL(triggered(bool)),
201
229
                this, SLOT(sltGoToNormalMode()), Qt::QueuedConnection);
203
231
                this, SLOT(sltGoToSeamlessMode()), Qt::QueuedConnection);
204
232
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Scale), SIGNAL(triggered(bool)),
205
233
                this, SLOT(sltGoToScaleMode()), Qt::QueuedConnection);
206
 
 
207
 
        /* Initialize the logic object: */
208
 
        m_pMachineLogic->initialize();
209
 
    }
210
 
 
211
 
private slots:
212
 
 
213
 
    void sltGoToNormalMode()
214
 
    {
215
 
        /* Change visual state to normal: */
216
 
        emit sigChangeVisualState(UIVisualStateType_Normal);
217
 
    }
218
 
 
219
 
    void sltGoToSeamlessMode()
220
 
    {
221
 
        /* Change visual state to seamless: */
222
 
        emit sigChangeVisualState(UIVisualStateType_Seamless);
223
 
    }
224
 
 
225
 
    void sltGoToScaleMode()
226
 
    {
227
 
        /* Change visual state to scale: */
228
 
        emit sigChangeVisualState(UIVisualStateType_Scale);
229
234
    }
230
235
};
231
236
 
 
237
/* Seamless visual state implementation: */
232
238
class UIVisualStateSeamless : public UIVisualState
233
239
{
234
240
    Q_OBJECT;
235
241
 
236
242
public:
237
243
 
238
 
    /* Seamless visual state holder constructor: */
 
244
    /* Constructor: */
239
245
    UIVisualStateSeamless(QObject *pParent, UISession *pSession)
240
246
        : UIVisualState(pParent, pSession)
241
247
    {
250
256
        }
251
257
    }
252
258
 
253
 
    /* Seamless visual state holder destructor: */
 
259
    /* Destructor: */
254
260
    virtual ~UIVisualStateSeamless()
255
261
    {
256
262
        /* This visual state should take care of own action: */
264
270
        }
265
271
    }
266
272
 
 
273
private slots:
 
274
 
 
275
    /* State-change handlers: */
 
276
    void sltGoToNormalMode() { emit sigChangeVisualState(UIVisualStateType_Normal); }
 
277
    void sltGoToFullscreenMode() { emit sigChangeVisualState(UIVisualStateType_Fullscreen); }
 
278
    void sltGoToScaleMode() { emit sigChangeVisualState(UIVisualStateType_Scale); }
 
279
 
 
280
private:
 
281
 
 
282
    /* Visual state type getter: */
267
283
    UIVisualStateType visualStateType() const { return UIVisualStateType_Seamless; }
268
284
 
 
285
    /* Method to change previous visual state to this one: */
269
286
    void change()
270
287
    {
 
288
        /* Call to base-class: */
 
289
        UIVisualState::change();
 
290
 
271
291
        /* Connect action handlers: */
272
292
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SIGNAL(triggered(bool)),
273
293
                this, SLOT(sltGoToNormalMode()), Qt::QueuedConnection);
275
295
                this, SLOT(sltGoToFullscreenMode()), Qt::QueuedConnection);
276
296
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Scale), SIGNAL(triggered(bool)),
277
297
                this, SLOT(sltGoToScaleMode()), Qt::QueuedConnection);
278
 
 
279
 
        /* Initialize the logic object: */
280
 
        m_pMachineLogic->initialize();
281
 
    }
282
 
 
283
 
private slots:
284
 
 
285
 
    void sltGoToNormalMode()
286
 
    {
287
 
        /* Change visual state to normal: */
288
 
        emit sigChangeVisualState(UIVisualStateType_Normal);
289
 
    }
290
 
 
291
 
    void sltGoToFullscreenMode()
292
 
    {
293
 
        /* Change visual state to fullscreen: */
294
 
        emit sigChangeVisualState(UIVisualStateType_Fullscreen);
295
 
    }
296
 
 
297
 
    void sltGoToScaleMode()
298
 
    {
299
 
        /* Change visual state to scale: */
300
 
        emit sigChangeVisualState(UIVisualStateType_Scale);
301
298
    }
302
299
};
303
300
 
 
301
/* Scale visual state implementation: */
304
302
class UIVisualStateScale : public UIVisualState
305
303
{
306
304
    Q_OBJECT;
307
305
 
308
306
public:
309
307
 
310
 
    /* Scale visual state holder constructor: */
 
308
    /* Constructor: */
311
309
    UIVisualStateScale(QObject *pParent, UISession *pSession)
312
310
        : UIVisualState(pParent, pSession)
313
311
    {
322
320
        }
323
321
    }
324
322
 
325
 
    /* Seamless visual state holder destructor: */
 
323
    /* Destructor: */
326
324
    virtual ~UIVisualStateScale()
327
325
    {
328
326
        /* This visual state should take care of own action: */
336
334
        }
337
335
    }
338
336
 
 
337
private slots:
 
338
 
 
339
    /* State-change handlers: */
 
340
    void sltGoToNormalMode() { emit sigChangeVisualState(UIVisualStateType_Normal); }
 
341
    void sltGoToFullscreenMode() { emit sigChangeVisualState(UIVisualStateType_Fullscreen); }
 
342
    void sltGoToSeamlessMode() { emit sigChangeVisualState(UIVisualStateType_Seamless); }
 
343
 
 
344
private:
 
345
 
 
346
    /* Visual state type getter: */
339
347
    UIVisualStateType visualStateType() const { return UIVisualStateType_Scale; }
340
348
 
 
349
    /* Method to change previous visual state to this one: */
341
350
    void change()
342
351
    {
 
352
        /* Call to base-class: */
 
353
        UIVisualState::change();
 
354
 
343
355
        /* Connect action handlers: */
344
356
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Scale), SIGNAL(triggered(bool)),
345
357
                this, SLOT(sltGoToNormalMode()), Qt::QueuedConnection);
347
359
                this, SLOT(sltGoToFullscreenMode()), Qt::QueuedConnection);
348
360
        connect(gActionPool->action(UIActionIndexRuntime_Toggle_Seamless), SIGNAL(triggered(bool)),
349
361
                this, SLOT(sltGoToSeamlessMode()), Qt::QueuedConnection);
350
 
 
351
 
        /* Initialize the logic object: */
352
 
        m_pMachineLogic->initialize();
353
 
    }
354
 
 
355
 
private slots:
356
 
 
357
 
    void sltGoToNormalMode()
358
 
    {
359
 
        /* Change visual state to normal: */
360
 
        emit sigChangeVisualState(UIVisualStateType_Normal);
361
 
    }
362
 
 
363
 
    void sltGoToFullscreenMode()
364
 
    {
365
 
        /* Change visual state to fullscreen: */
366
 
        emit sigChangeVisualState(UIVisualStateType_Fullscreen);
367
 
    }
368
 
 
369
 
    void sltGoToSeamlessMode()
370
 
    {
371
 
        /* Change visual state to seamless: */
372
 
        emit sigChangeVisualState(UIVisualStateType_Seamless);
373
362
    }
374
363
};
375
364
 
381
370
    , m_pSession(0)
382
371
    , m_pVisualState(0)
383
372
{
384
 
    /* Storing self: */
 
373
    /* Store self pointer: */
385
374
    if (m_ppThis)
386
375
        *m_ppThis = this;
387
376
 
388
 
    /* Create UISession object: */
 
377
    /* Create UI session: */
389
378
    m_pSession = new UISession(this, m_session);
390
379
 
391
380
    /* Preventing application from closing in case of window(s) closed: */
405
394
{
406
395
    /* Save machine settings: */
407
396
    saveMachineSettings();
408
 
    /* Erase itself pointer: */
409
 
    *m_ppThis = 0;
410
 
    /* Delete uisession children in backward direction: */
 
397
 
 
398
    /* Delete visual state: */
411
399
    delete m_pVisualState;
412
400
    m_pVisualState = 0;
 
401
 
 
402
    /* Delete UI session: */
413
403
    delete m_pSession;
414
404
    m_pSession = 0;
 
405
 
 
406
    /* Free session finally: */
415
407
    m_session.UnlockMachine();
416
408
    m_session.detach();
 
409
 
 
410
    /* Clear self pointer: */
 
411
    *m_ppThis = 0;
 
412
 
417
413
    /* Quit application: */
418
414
    QApplication::quit();
419
415
}
420
416
 
421
417
QWidget* UIMachine::mainWindow() const
422
418
{
423
 
    if (machineLogic() &&
424
 
        machineLogic()->mainMachineWindow() &&
425
 
        machineLogic()->mainMachineWindow()->machineWindow())
426
 
        return machineLogic()->mainMachineWindow()->machineWindow();
 
419
    if (machineLogic() && machineLogic()->mainMachineWindow())
 
420
        return machineLogic()->mainMachineWindow();
427
421
    else
428
422
        return 0;
429
423
}
430
424
 
431
 
void UIMachine::sltChangeVisualState(UIVisualStateType visualStateType)
 
425
void UIMachine::sltChangeVisualState(UIVisualStateType newVisualStateType)
432
426
{
433
427
    /* Create new state: */
434
428
    UIVisualState *pNewVisualState = 0;
435
 
    switch (visualStateType)
 
429
    switch (newVisualStateType)
436
430
    {
437
431
        case UIVisualStateType_Normal:
438
432
        {
462
456
            break;
463
457
    }
464
458
 
 
459
    /* Get previous visual state type: */
465
460
    UIVisualStateType previousVisualStateType = UIVisualStateType_Normal;
466
461
    if (m_pVisualState)
467
462
        previousVisualStateType = m_pVisualState->visualStateType();
527
522
        if (!fIsSomeExtendedModeChosen)
528
523
        {
529
524
            /* Test 'scale' flag: */
530
 
            QString strScaleSettings = machine.GetExtraData(VBoxDefs::GUI_Scale);
 
525
            QString strScaleSettings = machine.GetExtraData(GUI_Scale);
531
526
            if (strScaleSettings == "on")
532
527
            {
533
528
                fIsSomeExtendedModeChosen = true;
539
534
        if (!fIsSomeExtendedModeChosen)
540
535
        {
541
536
            /* Test 'seamless' flag: */
542
 
            QString strSeamlessSettings = machine.GetExtraData(VBoxDefs::GUI_Seamless);
 
537
            QString strSeamlessSettings = machine.GetExtraData(GUI_Seamless);
543
538
            if (strSeamlessSettings == "on")
544
539
            {
545
540
                fIsSomeExtendedModeChosen = true;
552
547
        if (!fIsSomeExtendedModeChosen)
553
548
        {
554
549
            /* Test 'fullscreen' flag: */
555
 
            QString strFullscreenSettings = machine.GetExtraData(VBoxDefs::GUI_Fullscreen);
 
550
            QString strFullscreenSettings = machine.GetExtraData(GUI_Fullscreen);
556
551
            if (strFullscreenSettings == "on")
557
552
            {
558
553
                fIsSomeExtendedModeChosen = true;
571
566
    /* Save extra-data settings: */
572
567
    {
573
568
        /* Set 'scale' flag: */
574
 
        machine.SetExtraData(VBoxDefs::GUI_Scale, m_pVisualState &&
 
569
        machine.SetExtraData(GUI_Scale, m_pVisualState &&
575
570
                             m_pVisualState->visualStateType() == UIVisualStateType_Scale ? "on" : QString());
576
571
 
577
572
        /* Set 'seamless' flag: */
578
 
        machine.SetExtraData(VBoxDefs::GUI_Seamless, m_pVisualState &&
 
573
        machine.SetExtraData(GUI_Seamless, m_pVisualState &&
579
574
                             m_pVisualState->visualStateType() == UIVisualStateType_Seamless ? "on" : QString());
580
575
 
581
576
        /* Set 'fullscreen' flag: */
582
 
        machine.SetExtraData(VBoxDefs::GUI_Fullscreen, m_pVisualState &&
 
577
        machine.SetExtraData(GUI_Fullscreen, m_pVisualState &&
583
578
                             m_pVisualState->visualStateType() == UIVisualStateType_Fullscreen ? "on" : QString());
584
579
    }
585
580
}