← Back to branch summary

~ubuntu-branches/ubuntu/karmic/virtualbox-ose/karmic-updates

« back to all changes in this revision

Viewing changes to src/VBox/Main/VirtualBoxCallbackImpl.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-09-14 18:25:07 UTC
  • mfrom: (0.4.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090914182507-c98g07mq16hjmn6d
Tags: 3.0.6-dfsg-1ubuntu1
https://launchpad.net/bugs/429697
https://launchpad.net/bugs/267097
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/379878
* Merge from debian unstable (LP: #429697), remaining changes:
  - Enable DKMS support on virtualbox host and guest modules (LP: #267097)
    - Drop virtualbox-ose{-guest,}-modules-* package templates
    - Recommend *-source instead of *-modules packages
    - Replace error messages related to missing/mismatched
      kernel module accordingly
  - Autoload kernel module
    - LOAD_VBOXDRV_MODULE=1 in virtualbox-ose.default
  - Disable update action
    - patches/u01-disable-update-action.dpatch
  - Virtualbox should go in Accessories, not in System tools (LP: #288590)
    - virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add apport hook
    - virtualbox-ose.files/source_virtualbox-ose.py
    - virtualbox-ose.install
  - Add launchpad integration
    - control
    - lpi-bug.xpm
    - patches/u02-lp-integration.dpatch
  - virtualbox, virtualbox-* (names of the upstream proprietary packages)
    conflict with virtualbox-ose (LP: #379878)
* Make debug package depend on normal or guest utils package
* Drop patches/22-pulseaudio-stubs.dpatch (applied upstream)
* Rename Ubuntu specific patches to uXX-*.dpatch
* Fix lintian warnings in maintainer scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Main/VirtualBoxCallbackImpl.cpp
 
1
/** @file
 
2
 *
 
3
 * VBox Client callback COM Class implementation
 
4
 */
 
5
 
 
6
/*
 
7
 * Copyright (C) 2009 Sun Microsystems, Inc.
 
8
 *
 
9
 * This file is part of VirtualBox Open Source Edition (OSE), as
 
10
 * available from http://www.virtualbox.org. This file is free software;
 
11
 * you can redistribute it and/or modify it under the terms of the GNU
 
12
 * General Public License (GPL) as published by the Free Software
 
13
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 
14
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 
15
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 
16
 *
 
17
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 
18
 * Clara, CA 95054 USA or visit http://www.sun.com if you need
 
19
 * additional information or have any questions.
 
20
 */
 
21
 
 
22
#include "VirtualBoxCallbackImpl.h"
 
23
#include "Logging.h"
 
24
 
 
25
HRESULT CallbackWrapper::FinalConstruct()
 
26
{
 
27
    return S_OK;
 
28
}
 
29
 
 
30
void CallbackWrapper::FinalRelease()
 
31
{
 
32
}
 
33
 
 
34
// public initializers/uninitializers only for internal purposes
 
35
HRESULT CallbackWrapper::init()
 
36
{
 
37
    return S_OK;
 
38
}
 
39
 
 
40
void CallbackWrapper::uninit(bool aFinalRelease)
 
41
{
 
42
}
 
43
 
 
44
// ILocalOwner methods
 
45
/////////////////////////////////////////////////////////////////////////////
 
46
 
 
47
STDMETHODIMP CallbackWrapper::SetLocalObject(IUnknown *aCallback)
 
48
{
 
49
    if (aCallback == NULL)
 
50
    {
 
51
        mVBoxCallback.setNull();
 
52
        mConsoleCallback.setNull();
 
53
        return S_OK;
 
54
    }
 
55
 
 
56
    if (!VALID_PTR (aCallback))
 
57
        return E_POINTER;
 
58
 
 
59
    mVBoxCallback = aCallback;
 
60
    mConsoleCallback = aCallback;
 
61
 
 
62
    // or some other error code?
 
63
    AssertReturn(!!mVBoxCallback || !!mConsoleCallback, E_FAIL);
 
64
 
 
65
    return S_OK;
 
66
}
 
67
 
 
68
// IVirtualBoxCallback methods
 
69
/////////////////////////////////////////////////////////////////////////////
 
70
STDMETHODIMP CallbackWrapper::OnMachineStateChange(IN_BSTR machineId, MachineState_T state)
 
71
{
 
72
    if (mVBoxCallback.isNull())
 
73
        return S_OK;
 
74
 
 
75
    return mVBoxCallback->OnMachineStateChange(machineId, state);
 
76
}
 
77
 
 
78
STDMETHODIMP CallbackWrapper::OnMachineDataChange(IN_BSTR machineId)
 
79
{
 
80
    AutoReadLock alock(this);
 
81
 
 
82
    if (mVBoxCallback.isNull())
 
83
        return S_OK;
 
84
 
 
85
    return mVBoxCallback->OnMachineDataChange(machineId);
 
86
}
 
87
 
 
88
 
 
89
STDMETHODIMP CallbackWrapper::OnExtraDataCanChange(IN_BSTR machineId, IN_BSTR key, IN_BSTR value,
 
90
                                           BSTR *error, BOOL *changeAllowed)
 
91
{
 
92
    if (mVBoxCallback.isNull())
 
93
        return S_OK;
 
94
 
 
95
    return mVBoxCallback->OnExtraDataCanChange(machineId, key, value, error, changeAllowed);
 
96
}
 
97
 
 
98
STDMETHODIMP CallbackWrapper::OnExtraDataChange(IN_BSTR machineId, IN_BSTR key, IN_BSTR value)
 
99
{
 
100
    if (mVBoxCallback.isNull())
 
101
        return S_OK;
 
102
 
 
103
    return mVBoxCallback->OnExtraDataChange(machineId, key, value);
 
104
}
 
105
 
 
106
STDMETHODIMP CallbackWrapper::OnMediaRegistered(IN_BSTR mediaId, DeviceType_T mediaType,
 
107
                              BOOL registered)
 
108
{
 
109
    if (mVBoxCallback.isNull())
 
110
        return S_OK;
 
111
 
 
112
    return mVBoxCallback->OnMediaRegistered(mediaId, mediaType, registered);
 
113
}
 
114
 
 
115
 
 
116
STDMETHODIMP CallbackWrapper::OnMachineRegistered(IN_BSTR aMachineId, BOOL registered)
 
117
{
 
118
    if (mVBoxCallback.isNull())
 
119
        return S_OK;
 
120
 
 
121
    return mVBoxCallback->OnMachineRegistered(aMachineId, registered);
 
122
}
 
123
 
 
124
STDMETHODIMP CallbackWrapper::OnSessionStateChange(IN_BSTR aMachineId, SessionState_T state)
 
125
{
 
126
    if (mVBoxCallback.isNull())
 
127
        return S_OK;
 
128
 
 
129
    return mVBoxCallback->OnSessionStateChange(aMachineId, state);
 
130
}
 
131
 
 
132
STDMETHODIMP CallbackWrapper::OnSnapshotTaken(IN_BSTR aMachineId, IN_BSTR aSnapshotId)
 
133
{
 
134
    if (mVBoxCallback.isNull())
 
135
        return S_OK;
 
136
 
 
137
    return mVBoxCallback->OnSnapshotTaken(aMachineId, aSnapshotId);
 
138
}
 
139
 
 
140
STDMETHODIMP CallbackWrapper::OnSnapshotDiscarded(IN_BSTR aMachineId, IN_BSTR aSnapshotId)
 
141
{
 
142
    if (mVBoxCallback.isNull())
 
143
        return S_OK;
 
144
 
 
145
    return mVBoxCallback->OnSnapshotDiscarded(aMachineId, aSnapshotId);
 
146
}
 
147
 
 
148
STDMETHODIMP CallbackWrapper::OnSnapshotChange(IN_BSTR aMachineId, IN_BSTR aSnapshotId)
 
149
{
 
150
    if (mVBoxCallback.isNull())
 
151
        return S_OK;
 
152
 
 
153
    return mVBoxCallback->OnSnapshotChange(aMachineId, aSnapshotId);
 
154
}
 
155
 
 
156
STDMETHODIMP CallbackWrapper::OnGuestPropertyChange(IN_BSTR aMachineId, IN_BSTR key, IN_BSTR value, IN_BSTR flags)
 
157
{
 
158
    if (mVBoxCallback.isNull())
 
159
        return S_OK;
 
160
 
 
161
    return mVBoxCallback->OnGuestPropertyChange(aMachineId, key, value, flags);
 
162
}
 
163
 
 
164
 
 
165
// IConsoleCallback methods
 
166
/////////////////////////////////////////////////////////////////////////////
 
167
STDMETHODIMP CallbackWrapper::OnMousePointerShapeChange(BOOL visible, BOOL alpha, ULONG xHot, ULONG yHot,
 
168
                                                        ULONG width, ULONG height, BYTE *shape)
 
169
{
 
170
    if (mConsoleCallback.isNull())
 
171
        return S_OK;
 
172
 
 
173
    return mConsoleCallback->OnMousePointerShapeChange(visible, alpha, xHot, yHot, width, height, shape);
 
174
}
 
175
 
 
176
 
 
177
STDMETHODIMP CallbackWrapper::OnMouseCapabilityChange(BOOL supportsAbsolute, BOOL needsHostCursor)
 
178
{
 
179
    if (mConsoleCallback.isNull())
 
180
        return S_OK;
 
181
 
 
182
    return mConsoleCallback->OnMouseCapabilityChange(supportsAbsolute, needsHostCursor);
 
183
}
 
184
 
 
185
STDMETHODIMP  CallbackWrapper::OnKeyboardLedsChange(BOOL fNumLock, BOOL fCapsLock, BOOL fScrollLock)
 
186
{
 
187
    if (mConsoleCallback.isNull())
 
188
        return S_OK;
 
189
 
 
190
    return mConsoleCallback->OnKeyboardLedsChange(fNumLock, fCapsLock, fScrollLock);
 
191
}
 
192
 
 
193
STDMETHODIMP CallbackWrapper::OnStateChange(MachineState_T machineState)
 
194
{
 
195
    if (mConsoleCallback.isNull())
 
196
        return S_OK;
 
197
 
 
198
    return mConsoleCallback->OnStateChange(machineState);
 
199
}
 
200
 
 
201
STDMETHODIMP CallbackWrapper::OnAdditionsStateChange()
 
202
{
 
203
    if (mConsoleCallback.isNull())
 
204
        return S_OK;
 
205
 
 
206
    return mConsoleCallback->OnAdditionsStateChange();
 
207
}
 
208
 
 
209
STDMETHODIMP CallbackWrapper::OnDVDDriveChange()
 
210
{
 
211
    if (mConsoleCallback.isNull())
 
212
        return S_OK;
 
213
 
 
214
    return mConsoleCallback->OnDVDDriveChange();
 
215
}
 
216
 
 
217
STDMETHODIMP CallbackWrapper::OnFloppyDriveChange()
 
218
{
 
219
    if (mConsoleCallback.isNull())
 
220
        return S_OK;
 
221
 
 
222
    return mConsoleCallback->OnFloppyDriveChange();
 
223
}
 
224
 
 
225
STDMETHODIMP CallbackWrapper::OnNetworkAdapterChange(INetworkAdapter *aNetworkAdapter)
 
226
{
 
227
    if (mConsoleCallback.isNull())
 
228
        return S_OK;
 
229
 
 
230
    return mConsoleCallback->OnNetworkAdapterChange(aNetworkAdapter);
 
231
}
 
232
 
 
233
STDMETHODIMP CallbackWrapper::OnSerialPortChange(ISerialPort *aSerialPort)
 
234
{
 
235
    if (mConsoleCallback.isNull())
 
236
        return S_OK;
 
237
 
 
238
    return mConsoleCallback->OnSerialPortChange(aSerialPort);
 
239
}
 
240
 
 
241
STDMETHODIMP CallbackWrapper::OnParallelPortChange(IParallelPort *aParallelPort)
 
242
{
 
243
    if (mConsoleCallback.isNull())
 
244
        return S_OK;
 
245
 
 
246
    return mConsoleCallback->OnParallelPortChange(aParallelPort);
 
247
}
 
248
STDMETHODIMP CallbackWrapper::OnVRDPServerChange()
 
249
{
 
250
    if (mConsoleCallback.isNull())
 
251
        return S_OK;
 
252
 
 
253
    return mConsoleCallback->OnVRDPServerChange();
 
254
}
 
255
 
 
256
STDMETHODIMP CallbackWrapper::OnUSBControllerChange()
 
257
{
 
258
    if (mConsoleCallback.isNull())
 
259
        return S_OK;
 
260
 
 
261
    return mConsoleCallback->OnUSBControllerChange();
 
262
}
 
263
 
 
264
STDMETHODIMP CallbackWrapper::OnUSBDeviceStateChange(IUSBDevice *aDevice,
 
265
                                                        BOOL aAttached,
 
266
                                                        IVirtualBoxErrorInfo *aError)
 
267
{
 
268
    if (mConsoleCallback.isNull())
 
269
        return S_OK;
 
270
 
 
271
    return mConsoleCallback->OnUSBDeviceStateChange(aDevice, aAttached, aError);
 
272
}
 
273
 
 
274
STDMETHODIMP CallbackWrapper::OnSharedFolderChange(Scope_T aScope)
 
275
{
 
276
    if (mConsoleCallback.isNull())
 
277
        return S_OK;
 
278
 
 
279
    return mConsoleCallback->OnSharedFolderChange(aScope);
 
280
}
 
281
 
 
282
STDMETHODIMP CallbackWrapper::OnStorageControllerChange()
 
283
{
 
284
    if (mConsoleCallback.isNull())
 
285
        return S_OK;
 
286
 
 
287
    return mConsoleCallback->OnStorageControllerChange();
 
288
}
 
289
 
 
290
STDMETHODIMP CallbackWrapper::OnRuntimeError(BOOL fFatal, IN_BSTR id, IN_BSTR message)
 
291
{
 
292
    if (mConsoleCallback.isNull())
 
293
        return S_OK;
 
294
 
 
295
    return mConsoleCallback->OnRuntimeError(fFatal, id, message);
 
296
}
 
297
 
 
298
STDMETHODIMP CallbackWrapper::OnCanShowWindow(BOOL *canShow)
 
299
{
 
300
    if (mConsoleCallback.isNull())
 
301
        return S_OK;
 
302
 
 
303
    return mConsoleCallback->OnCanShowWindow(canShow);
 
304
}
 
305
 
 
306
STDMETHODIMP CallbackWrapper::OnShowWindow(ULONG64 *winId)
 
307
{
 
308
    if (mConsoleCallback.isNull())
 
309
        return S_OK;
 
310
 
 
311
    return mConsoleCallback->OnShowWindow(winId);
 
312
}