VirtualBox

source: vbox/trunk/src/VBox/Main/VBoxEvents.cpp@ 30386

Last change on this file since 30386 was 30381, checked in by vboxsync, 15 years ago

Main: generic events (disabled)
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.0 KB
Line 
1/* $Id: VBoxEvents.cpp 30381 2010-06-22 22:06:00Z vboxsync $ */
2/** @file
3 * VirtualBox-specific event classes implementation
4 */
5
6/*
7 * Copyright (C) 2010 Oracle Corporation
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#include "EventImpl.h"
18
19/**
20 * @todo: Technically, this file better be autogenerated,
21 * as contains almost no semantic meat. We use aggregation
22 * of VBoxEvent to simplify multiple inheritance ambiguity.
23 */
24#define EVENT_CLASS_TRIVIA(klazz, iface) \
25 public: \
26 DECLARE_NOT_AGGREGATABLE(klazz) \
27 \
28 DECLARE_PROTECT_FINAL_CONSTRUCT() \
29 \
30 BEGIN_COM_MAP(klazz) \
31 COM_INTERFACE_ENTRY(iface) \
32 COM_INTERFACE_ENTRY(IEvent) \
33 COM_INTERFACE_ENTRY(IDispatch) \
34 END_COM_MAP() \
35 \
36 klazz () {} \
37 virtual ~klazz () {} \
38 \
39 HRESULT FinalConstruct() \
40 { \
41 return mEvent.createObject(); \
42 } \
43 void FinalRelease() { \
44 mEvent->FinalRelease(); \
45 } \
46 STDMETHOD(COMGETTER(Type)) (VBoxEventType_T *aType) \
47 { \
48 return mEvent->COMGETTER(Type) (aType); \
49 } \
50 STDMETHOD(COMGETTER(Source)) (IEventSource * *aSource) \
51 { \
52 return mEvent->COMGETTER(Source) (aSource); \
53 } \
54 STDMETHOD(COMGETTER(Waitable)) (BOOL *aWaitable) \
55 { \
56 return mEvent->COMGETTER(Waitable) (aWaitable); \
57 } \
58 STDMETHOD(SetProcessed)() \
59 { \
60 return mEvent->SetProcessed(); \
61 } \
62 STDMETHOD(WaitProcessed)(LONG aTimeout, BOOL *aResult) \
63 { \
64 return mEvent->WaitProcessed(aTimeout, aResult); \
65 } \
66private: \
67 ComObjPtr<VBoxEvent> mEvent;
68
69// operator VBoxEvent&() { return mEvent; }
70// operator IEvent&() { return mEvent; }
71
72
73class ATL_NO_VTABLE MachineStateChangeEvent :
74 public VirtualBoxBase,
75 VBOX_SCRIPTABLE_IMPL(IMachineStateChangeEvent)
76{
77 EVENT_CLASS_TRIVIA(MachineStateChangeEvent, IMachineStateChangeEvent)
78
79public:
80 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aId, MachineState_T aState)
81 {
82 HRESULT rc;
83
84 rc = mEvent->init(aSource, aType, FALSE);
85 if (SUCCEEDED(rc))
86 {
87 mMachineId = aId;
88 mState = aState;
89 }
90 return rc;
91 }
92
93 void uninit()
94 {
95 mEvent->uninit();
96 }
97
98 // IMachineEvent properties
99 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
100 {
101 mMachineId.cloneTo(aMachineId);
102 return S_OK;
103 }
104 // IMachineStateChangeEvent methods
105 STDMETHOD(COMGETTER(State))(MachineState_T * aState)
106 {
107 *aState = mState;
108 return S_OK;
109 }
110
111 private:
112 Bstr mMachineId;
113 MachineState_T mState;
114};
115
116class ATL_NO_VTABLE MachineDataChangeEvent :
117 public VirtualBoxBase,
118 VBOX_SCRIPTABLE_IMPL(IMachineDataChangeEvent)
119{
120 EVENT_CLASS_TRIVIA(MachineDataChangeEvent, IMachineDataChangeEvent)
121
122public:
123 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aId)
124 {
125 HRESULT rc;
126
127 rc = mEvent->init(aSource, aType, FALSE);
128 if (SUCCEEDED(rc))
129 mMachineId = aId;
130
131 return rc;
132 }
133
134 void uninit()
135 {
136 mEvent->uninit();
137 }
138
139 // IMachineEvent properties
140 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
141 {
142 mMachineId.cloneTo(aMachineId);
143 return S_OK;
144 }
145
146 private:
147 Bstr mMachineId;
148};
149
150class ATL_NO_VTABLE MachineRegisteredEvent :
151 public VirtualBoxBase,
152 VBOX_SCRIPTABLE_IMPL(IMachineRegisteredEvent)
153{
154 EVENT_CLASS_TRIVIA(MachineRegisteredEvent, IMachineRegisteredEvent)
155
156public:
157 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aId, BOOL aRegistered)
158 {
159 HRESULT rc;
160
161 rc = mEvent->init(aSource, aType, FALSE);
162 if (SUCCEEDED(rc))
163 {
164 mMachineId = aId;
165 mRegistered = aRegistered;
166 }
167
168 return rc;
169 }
170
171 void uninit()
172 {
173 mEvent->uninit();
174 }
175
176 // IMachineEvent properties
177 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
178 {
179 mMachineId.cloneTo(aMachineId);
180 return S_OK;
181 }
182
183 // IMachineRegisteredEvent properties
184 STDMETHOD(COMGETTER(Registered))(BOOL * aRegistered)
185 {
186 *aRegistered = mRegistered;
187 return S_OK;
188 }
189
190 private:
191 Bstr mMachineId;
192 BOOL mRegistered;
193};
194
195class ATL_NO_VTABLE MachineSessionStateEvent :
196 public VirtualBoxBase,
197 VBOX_SCRIPTABLE_IMPL(IMachineSessionStateEvent)
198{
199 EVENT_CLASS_TRIVIA(MachineSessionStateEvent, IMachineSessionStateEvent)
200
201public:
202 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aId, SessionState_T aState)
203 {
204 HRESULT rc;
205
206 rc = mEvent->init(aSource, aType, FALSE);
207 if (SUCCEEDED(rc))
208 {
209 mMachineId = aId;
210 mState = aState;
211 }
212
213 return rc;
214 }
215
216 void uninit()
217 {
218 mEvent->uninit();
219 }
220
221 // IMachineEvent properties
222 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
223 {
224 mMachineId.cloneTo(aMachineId);
225 return S_OK;
226 }
227
228 // IMachineSessionStateEvent properties
229 STDMETHOD(COMGETTER(State))(SessionState_T * aState)
230 {
231 *aState = mState;
232 return S_OK;
233 }
234
235 private:
236 Bstr mMachineId;
237 SessionState_T mState;
238};
239
240class ATL_NO_VTABLE GuestPropertyChangeEvent :
241 public VirtualBoxBase,
242 VBOX_SCRIPTABLE_IMPL(IGuestPropertyChangeEvent)
243{
244 EVENT_CLASS_TRIVIA(GuestPropertyChangeEvent, IGuestPropertyChangeEvent)
245
246public:
247 HRESULT init (IEventSource* aSource, VBoxEventType_T aType,
248 IN_BSTR aMachineId, IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
249 {
250 HRESULT rc;
251
252 rc = mEvent->init(aSource, aType, FALSE);
253 if (SUCCEEDED(rc))
254 {
255 mMachineId = aMachineId;
256 mName = aName;
257 mValue = aValue;
258 mFlags = aFlags;
259 }
260
261 return rc;
262 }
263
264 void uninit()
265 {
266 mEvent->uninit();
267 }
268
269 // IMachineEvent properties
270 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
271 {
272 mMachineId.cloneTo(aMachineId);
273 return S_OK;
274 }
275
276 // IGuestPropertyChangeEvent properties
277 STDMETHOD(COMGETTER(Name))(BSTR * aName)
278 {
279 mName.cloneTo(aName);
280 return S_OK;
281 }
282 STDMETHOD(COMGETTER(Value))(BSTR * aValue)
283 {
284 mValue.cloneTo(aValue);
285 return S_OK;
286 }
287 STDMETHOD(COMGETTER(Flags))(BSTR * aFlags)
288 {
289 mFlags.cloneTo(aFlags);
290 return S_OK;
291 }
292 private:
293 Bstr mMachineId, mName, mValue, mFlags;
294};
295
296class ATL_NO_VTABLE SnapshotTakenEvent :
297 public VirtualBoxBase,
298 VBOX_SCRIPTABLE_IMPL(ISnapshotTakenEvent)
299{
300 EVENT_CLASS_TRIVIA(SnapshotTakenEvent, ISnapshotTakenEvent)
301
302public:
303 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aMachineId, IN_BSTR aSnapshotId)
304 {
305 HRESULT rc;
306
307 rc = mEvent->init(aSource, aType, FALSE);
308 if (SUCCEEDED(rc))
309 {
310 mMachineId = aMachineId;
311 mSnapshotId = aSnapshotId;
312 }
313
314 return rc;
315 }
316
317 void uninit()
318 {
319 mEvent->uninit();
320 }
321
322 // IMachineEvent properties
323 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
324 {
325 mMachineId.cloneTo(aMachineId);
326 return S_OK;
327 }
328
329 // ISnapshotEvent properties
330 STDMETHOD(COMGETTER(SnapshotId)) (BSTR *aSnapshotId)
331 {
332 mSnapshotId.cloneTo(aSnapshotId);
333 return S_OK;
334 }
335
336 private:
337 Bstr mMachineId, mSnapshotId;
338};
339
340class ATL_NO_VTABLE SnapshotChangeEvent :
341 public VirtualBoxBase,
342 VBOX_SCRIPTABLE_IMPL(ISnapshotChangeEvent)
343{
344 EVENT_CLASS_TRIVIA(SnapshotChangeEvent, ISnapshotChangeEvent)
345
346public:
347 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aMachineId, IN_BSTR aSnapshotId)
348 {
349 HRESULT rc;
350
351 rc = mEvent->init(aSource, aType, FALSE);
352 if (SUCCEEDED(rc))
353 {
354 mMachineId = aMachineId;
355 mSnapshotId = aSnapshotId;
356 }
357
358 return rc;
359 }
360
361 void uninit()
362 {
363 mEvent->uninit();
364 }
365
366 // IMachineEvent properties
367 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
368 {
369 mMachineId.cloneTo(aMachineId);
370 return S_OK;
371 }
372
373 // ISnapshotEvent properties
374 STDMETHOD(COMGETTER(SnapshotId)) (BSTR *aSnapshotId)
375 {
376 mSnapshotId.cloneTo(aSnapshotId);
377 return S_OK;
378 }
379
380 private:
381 Bstr mMachineId, mSnapshotId;
382};
383
384class ATL_NO_VTABLE SnapshotDeletedEvent :
385 public VirtualBoxBase,
386 VBOX_SCRIPTABLE_IMPL(ISnapshotDeletedEvent)
387{
388 EVENT_CLASS_TRIVIA(SnapshotDeletedEvent, ISnapshotDeletedEvent)
389
390public:
391 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aMachineId, IN_BSTR aSnapshotId)
392 {
393 HRESULT rc;
394
395 rc = mEvent->init(aSource, aType, FALSE);
396 if (SUCCEEDED(rc))
397 {
398 mMachineId = aMachineId;
399 mSnapshotId = aSnapshotId;
400 }
401
402 return rc;
403 }
404
405 void uninit()
406 {
407 mEvent->uninit();
408 }
409
410 // IMachineEvent properties
411 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
412 {
413 mMachineId.cloneTo(aMachineId);
414 return S_OK;
415 }
416
417 // ISnapshotEvent properties
418 STDMETHOD(COMGETTER(SnapshotId)) (BSTR *aSnapshotId)
419 {
420 mSnapshotId.cloneTo(aSnapshotId);
421 return S_OK;
422 }
423
424 private:
425 Bstr mMachineId, mSnapshotId;
426};
427
428class ATL_NO_VTABLE ExtraDataChangeEvent :
429 public VirtualBoxBase,
430 VBOX_SCRIPTABLE_IMPL(IExtraDataChangeEvent)
431{
432 EVENT_CLASS_TRIVIA(ExtraDataChangeEvent, IExtraDataChangeEvent)
433
434public:
435 HRESULT init (IEventSource* aSource, VBoxEventType_T aType, IN_BSTR aMachineId, IN_BSTR aKey, IN_BSTR aValue)
436 {
437 HRESULT rc;
438
439 rc = mEvent->init(aSource, aType, FALSE);
440 if (SUCCEEDED(rc))
441 {
442 mMachineId = aMachineId;
443 mKey = aKey;
444 mValue = aValue;
445 }
446
447 return rc;
448 }
449
450 void uninit()
451 {
452 mEvent->uninit();
453 }
454
455 // IExtraDataChangeEvent properties
456 STDMETHOD(COMGETTER(MachineId)) (BSTR *aMachineId)
457 {
458 mMachineId.cloneTo(aMachineId);
459 return S_OK;
460 }
461
462 STDMETHOD(COMGETTER(Key)) (BSTR *aKey)
463 {
464 mKey.cloneTo(aKey);
465 return S_OK;
466 }
467
468 STDMETHOD(COMGETTER(Value)) (BSTR *aValue)
469 {
470 mValue.cloneTo(aValue);
471 return S_OK;
472 }
473
474 private:
475 Bstr mMachineId, mKey, mValue;
476};
477
478
479#ifdef VBOX_WITH_XPCOM
480NS_DECL_CLASSINFO(VBoxEvent)
481NS_IMPL_THREADSAFE_ISUPPORTS1_CI(VBoxEvent, IEvent)
482NS_DECL_CLASSINFO(MachineStateChangeEvent)
483NS_IMPL_THREADSAFE_ISUPPORTS2_CI(MachineStateChangeEvent, IMachineStateChangeEvent, IEvent)
484NS_DECL_CLASSINFO(MachineDataChangeEvent)
485NS_IMPL_THREADSAFE_ISUPPORTS2_CI(MachineDataChangeEvent, IMachineDataChangeEvent, IEvent)
486NS_DECL_CLASSINFO(MachineRegisteredEvent)
487NS_IMPL_THREADSAFE_ISUPPORTS2_CI(MachineRegisteredEvent, IMachineRegisteredEvent, IEvent)
488NS_DECL_CLASSINFO(MachineSessionStateEvent)
489NS_IMPL_THREADSAFE_ISUPPORTS2_CI(MachineSessionStateEvent, IMachineSessionStateEvent, IEvent)
490NS_DECL_CLASSINFO(GuestPropertyChangeEvent)
491NS_IMPL_THREADSAFE_ISUPPORTS2_CI(GuestPropertyChangeEvent, IGuestPropertyChangeEvent, IEvent)
492NS_DECL_CLASSINFO(SnapshotTakenEvent)
493NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SnapshotTakenEvent, ISnapshotTakenEvent, IEvent)
494NS_DECL_CLASSINFO(SnapshotDeletedEvent)
495NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SnapshotDeletedEvent, ISnapshotDeletedEvent, IEvent)
496NS_DECL_CLASSINFO(SnapshotChangeEvent)
497NS_IMPL_THREADSAFE_ISUPPORTS2_CI(SnapshotChangeEvent, ISnapshotChangeEvent, IEvent)
498NS_DECL_CLASSINFO(ExtraDataChangeEvent)
499NS_IMPL_THREADSAFE_ISUPPORTS2_CI(ExtraDataChangeEvent, IExtraDataChangeEvent, IEvent)
500#endif
501
502HRESULT VBoxEventDesc::init(IEventSource* source, VBoxEventType_T aType, ...)
503{
504 va_list args;
505 va_start(args, aType);
506 switch (aType)
507 {
508 case VBoxEventType_OnMachineStateChange:
509 {
510 ComObjPtr<MachineStateChangeEvent> obj; obj.createObject();
511 BSTR aId = va_arg(args, BSTR);
512 MachineState_T aState = va_arg(args, MachineState_T);
513 obj->init(source, aType, aId, aState);
514 obj.queryInterfaceTo(mEvent.asOutParam());
515 break;
516 }
517 case VBoxEventType_OnMachineDataChange:
518 {
519 ComObjPtr<MachineDataChangeEvent> obj; obj.createObject();
520 BSTR aId = va_arg(args, BSTR);
521 obj->init(source, aType, aId);
522 obj.queryInterfaceTo(mEvent.asOutParam());
523 break;
524 }
525 case VBoxEventType_OnMachineRegistered:
526 {
527 ComObjPtr<MachineRegisteredEvent> obj; obj.createObject();
528 BSTR aId = va_arg(args, BSTR);
529 BOOL aRegistered = va_arg(args, BOOL);
530 obj->init(source, aType, aId, aRegistered);
531 obj.queryInterfaceTo(mEvent.asOutParam());
532 break;
533 }
534 case VBoxEventType_OnSessionStateChange:
535 {
536 ComObjPtr<MachineSessionStateEvent> obj; obj.createObject();
537 BSTR aId = va_arg(args, BSTR);
538 SessionState_T aState = va_arg(args, SessionState_T);
539 obj->init(source, aType, aId, aState);
540 obj.queryInterfaceTo(mEvent.asOutParam());
541 break;
542 }
543 case VBoxEventType_OnGuestPropertyChange:
544 {
545 ComObjPtr<GuestPropertyChangeEvent> obj; obj.createObject();
546 BSTR aMachineId = va_arg(args, BSTR);
547 BSTR aName = va_arg(args, BSTR);
548 BSTR aValue = va_arg(args, BSTR);
549 BSTR aFlags = va_arg(args, BSTR);
550 obj->init(source, aType, aMachineId, aName, aValue, aFlags);
551 obj.queryInterfaceTo(mEvent.asOutParam());
552 break;
553 }
554
555 case VBoxEventType_OnSnapshotTaken:
556 {
557 ComObjPtr<SnapshotTakenEvent> obj; obj.createObject();
558 BSTR aMachineId = va_arg(args, BSTR);
559 BSTR aSnapshotId = va_arg(args, BSTR);
560 obj->init(source, aType, aMachineId, aSnapshotId);
561 obj.queryInterfaceTo(mEvent.asOutParam());
562 break;
563 }
564 case VBoxEventType_OnSnapshotDeleted:
565 {
566 ComObjPtr<SnapshotDeletedEvent> obj; obj.createObject();
567 BSTR aMachineId = va_arg(args, BSTR);
568 BSTR aSnapshotId = va_arg(args, BSTR);
569 obj->init(source, aType, aMachineId, aSnapshotId);
570 obj.queryInterfaceTo(mEvent.asOutParam());
571 break;
572 }
573 case VBoxEventType_OnSnapshotChange:
574 {
575 ComObjPtr<SnapshotChangeEvent> obj; obj.createObject();
576 BSTR aMachineId = va_arg(args, BSTR);
577 BSTR aSnapshotId = va_arg(args, BSTR);
578 obj->init(source, aType, aMachineId, aSnapshotId);
579 obj.queryInterfaceTo(mEvent.asOutParam());
580 break;
581 }
582 case VBoxEventType_OnExtraDataChange:
583 {
584 ComObjPtr<ExtraDataChangeEvent> obj; obj.createObject();
585 BSTR aMachineId = va_arg(args, BSTR);
586 BSTR aKey = va_arg(args, BSTR);
587 BSTR aValue = va_arg(args, BSTR);
588 obj->init(source, aType, aMachineId, aKey, aValue);
589 obj.queryInterfaceTo(mEvent.asOutParam());
590 break;
591 }
592
593 default:
594 if (0) AssertFailed();
595 }
596 va_end(args);
597
598 return S_OK;
599}
600
601void VBoxEventDesc::getEvent(IEvent ** aEvent)
602{
603 mEvent.queryInterfaceTo(aEvent);
604}
Note: See TracBrowser for help on using the repository browser.

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