UIDetailsModel.cpp@ 103977

Last change on this file since 103977 was 103710, checked in by vboxsync, 11 months ago

FE/Qt: Get rid of unwanted UICommon includes across whole the GUI.

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

Property svn:mergeinfo set to (toggle deleted branches)

/branches/VBox-3.0/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	58652,70973
/branches/VBox-3.2/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	66309,66318
/branches/VBox-4.0/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	70873
/branches/VBox-4.1/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	74233
/branches/VBox-4.2/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsModel.cpp	91503-91504,91506-91508,91510,91514-91515,91521
/branches/VBox-4.3/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsModel.cpp	91223
/branches/VBox-4.3/trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsModel.cpp	91223
/branches/dsen/gui/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	79076-79078,79089,79109-79110,79112-79113,79127-79130,79134,79141,79151,79155,79157-79159,79193,79197
/branches/dsen/gui2/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsModel.cpp	79562-79569,79572-79573,79578,79581-79582,79590-79591,79598-79599,79602-79603,79605-79606,79632,79635,79637,79644
/branches/dsen/gui3/src/VBox/Frontends/VirtualBox/src/selector/graphics/details/UIGDetailsModel.cpp	79645-79692
/trunk/src/VBox/Frontends/VirtualBox/src/selector/graphics/chooser/UIGChooserModel.cpp	79225,79271

File size: 45.0 KB

Line
1	/* $Id: UIDetailsModel.cpp 103710 2024-03-06 16:53:27Z vboxsync $ */
2	/** @file
3	* VBox Qt GUI - UIDetailsModel class implementation.
4	*/
5
6	/*
7	* Copyright (C) 2012-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28	/* Qt includes: */
29	#include <QAction>
30	#include <QGraphicsScene>
31	#include <QGraphicsSceneContextMenuEvent>
32	#include <QGraphicsView>
33	#include <QMenu>
34	#include <QMetaEnum>
35
36	/* GUI includes: */
37	#include "UIConverter.h"
38	#include "UIDesktopWidgetWatchdog.h"
39	#include "UIDetails.h"
40	#include "UIDetailsContextMenu.h"
41	#include "UIDetailsElement.h"
42	#include "UIDetailsGroup.h"
43	#include "UIDetailsModel.h"
44	#include "UIDetailsView.h"
45	#include "UIExtraDataManager.h"
46
47	/* Other VBox includes: */
48	#include "iprt/assert.h"
49
50
51	/*********************************************************************************************************************************
52	* Class UIDetailsModel implementation. *
53	*********************************************************************************************************************************/
54
55	UIDetailsModel::UIDetailsModel(UIDetails *pParent)
56	: QObject(pParent)
57	, m_pDetails(pParent)
58	, m_pScene(0)
59	, m_pRoot(0)
60	, m_pAnimationCallback(0)
61	, m_pContextMenu(0)
62	{
63	prepare();
64	}
65
66	UIDetailsModel::~UIDetailsModel()
67	{
68	cleanup();
69	}
70
71	void UIDetailsModel::init()
72	{
73	/* Install root as event-filter for scene view,
74	* we need QEvent::Scroll events from it: */
75	root()->installEventFilterHelper(view());
76	}
77
78	QGraphicsScene *UIDetailsModel::scene() const
79	{
80	return m_pScene;
81	}
82
83	UIDetailsView *UIDetailsModel::view() const
84	{
85	return scene() && !scene()->views().isEmpty() ? qobject_cast<UIDetailsView*>(scene()->views().first()) : 0;
86	}
87
88	QGraphicsView *UIDetailsModel::paintDevice() const
89	{
90	return scene() && !scene()->views().isEmpty() ? scene()->views().first() : 0;
91	}
92
93	QGraphicsItem *UIDetailsModel::itemAt(const QPointF &position) const
94	{
95	return scene()->itemAt(position, QTransform());
96	}
97
98	UIDetailsItem *UIDetailsModel::root() const
99	{
100	return m_pRoot;
101	}
102
103	void UIDetailsModel::updateLayout()
104	{
105	/* Initialize variables: */
106	AssertPtrReturnVoid(view());
107	AssertPtrReturnVoid(root());
108	const QSize viewportSize = view()->size();
109	const int iViewportWidth = viewportSize.width();
110	const int iViewportHeight = root()->minimumSizeHint().toSize().height();
111
112	/* Move root: */
113	root()->setPos(0, 0);
114	/* Resize root: */
115	root()->resize(iViewportWidth, iViewportHeight);
116	/* Layout root content: */
117	root()->updateLayout();
118	}
119
120	void UIDetailsModel::setItems(const QList<UIVirtualMachineItem*> &items)
121	{
122	m_pRoot->buildGroup(items);
123	}
124
125	void UIDetailsModel::setCategories(const QMap<DetailsElementType, bool> &categories)
126	{
127	m_categories = categories;
128	m_pRoot->rebuildGroup();
129	m_pContextMenu->updateCategoryStates();
130
131	/* Save categories: */
132	gEDataManager->setSelectorWindowDetailsElements(m_categories);
133	}
134
135	void UIDetailsModel::setOptionsGeneral(UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral fOptionsGeneral)
136	{
137	m_fOptionsGeneral = fOptionsGeneral;
138	m_pRoot->rebuildGroup();
139	m_pContextMenu->updateOptionStates(DetailsElementType_General);
140
141	/* Save general options: */
142	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
143	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeGeneral");
144	if (iEnumIndex != -1)
145	{
146	bool fDefault = true;
147	QStringList options;
148	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
149	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
150	{
151	/* Prepare current option type: */
152	const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOptionType =
153	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
154	/* Skip invalid and default types: */
155	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid
156	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default)
157	continue;
158	/* If option type enabled: */
159	if (m_fOptionsGeneral & enmOptionType)
160	{
161	/* Add it to the list: */
162	options << gpConverter->toInternalString(enmOptionType);
163	/* Make sure item is included by default: */
164	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default & enmOptionType))
165	fDefault = false;
166	}
167	/* If option type disabled: */
168	else
169	{
170	/* Make sure item is excluded by default: */
171	if (UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default & enmOptionType)
172	fDefault = false;
173	}
174	/* Save options: */
175	if (!fDefault)
176	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_General, options);
177	else
178	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_General, QStringList());
179	}
180	}
181	}
182
183	void UIDetailsModel::setOptionsSystem(UIExtraDataMetaDefs::DetailsElementOptionTypeSystem fOptionsSystem)
184	{
185	m_fOptionsSystem = fOptionsSystem;
186	m_pRoot->rebuildGroup();
187	m_pContextMenu->updateOptionStates(DetailsElementType_System);
188
189	/* Save system options: */
190	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
191	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSystem");
192	if (iEnumIndex != -1)
193	{
194	bool fDefault = true;
195	QStringList options;
196	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
197	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
198	{
199	/* Prepare current option type: */
200	const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOptionType =
201	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
202	/* Skip invalid and default types: */
203	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Invalid
204	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Default)
205	continue;
206	/* If option type enabled: */
207	if (m_fOptionsSystem & enmOptionType)
208	{
209	/* Add it to the list: */
210	options << gpConverter->toInternalString(enmOptionType);
211	/* Make sure item is included by default: */
212	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Default & enmOptionType))
213	fDefault = false;
214	}
215	/* If option type disabled: */
216	else
217	{
218	/* Make sure item is excluded by default: */
219	if (UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Default & enmOptionType)
220	fDefault = false;
221	}
222	/* Save options: */
223	if (!fDefault)
224	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_System, options);
225	else
226	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_System, QStringList());
227	}
228	}
229	}
230
231	void UIDetailsModel::setOptionsDisplay(UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay fOptionsDisplay)
232	{
233	m_fOptionsDisplay = fOptionsDisplay;
234	m_pRoot->rebuildGroup();
235	m_pContextMenu->updateOptionStates(DetailsElementType_Display);
236
237	/* Save display options: */
238	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
239	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeDisplay");
240	if (iEnumIndex != -1)
241	{
242	bool fDefault = true;
243	QStringList options;
244	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
245	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
246	{
247	/* Prepare current option type: */
248	const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOptionType =
249	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
250	/* Skip invalid and default types: */
251	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Invalid
252	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Default)
253	continue;
254	/* If option type enabled: */
255	if (m_fOptionsDisplay & enmOptionType)
256	{
257	/* Add it to the list: */
258	options << gpConverter->toInternalString(enmOptionType);
259	/* Make sure item is included by default: */
260	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Default & enmOptionType))
261	fDefault = false;
262	}
263	/* If option type disabled: */
264	else
265	{
266	/* Make sure item is excluded by default: */
267	if (UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Default & enmOptionType)
268	fDefault = false;
269	}
270	/* Save options: */
271	if (!fDefault)
272	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Display, options);
273	else
274	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Display, QStringList());
275	}
276	}
277	}
278
279	void UIDetailsModel::setOptionsStorage(UIExtraDataMetaDefs::DetailsElementOptionTypeStorage fOptionsStorage)
280	{
281	m_fOptionsStorage = fOptionsStorage;
282	m_pRoot->rebuildGroup();
283	m_pContextMenu->updateOptionStates(DetailsElementType_Storage);
284
285	/* Save storage options: */
286	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
287	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeStorage");
288	if (iEnumIndex != -1)
289	{
290	bool fDefault = true;
291	QStringList options;
292	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
293	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
294	{
295	/* Prepare current option type: */
296	const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOptionType =
297	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
298	/* Skip invalid and default types: */
299	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Invalid
300	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Default)
301	continue;
302	/* If option type enabled: */
303	if (m_fOptionsStorage & enmOptionType)
304	{
305	/* Add it to the list: */
306	options << gpConverter->toInternalString(enmOptionType);
307	/* Make sure item is included by default: */
308	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Default & enmOptionType))
309	fDefault = false;
310	}
311	/* If option type disabled: */
312	else
313	{
314	/* Make sure item is excluded by default: */
315	if (UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Default & enmOptionType)
316	fDefault = false;
317	}
318	/* Save options: */
319	if (!fDefault)
320	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Storage, options);
321	else
322	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Storage, QStringList());
323	}
324	}
325	}
326
327	void UIDetailsModel::setOptionsAudio(UIExtraDataMetaDefs::DetailsElementOptionTypeAudio fOptionsAudio)
328	{
329	m_fOptionsAudio = fOptionsAudio;
330	m_pRoot->rebuildGroup();
331	m_pContextMenu->updateOptionStates(DetailsElementType_Audio);
332
333	/* Save audio options: */
334	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
335	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeAudio");
336	if (iEnumIndex != -1)
337	{
338	bool fDefault = true;
339	QStringList options;
340	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
341	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
342	{
343	/* Prepare current option type: */
344	const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOptionType =
345	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
346	/* Skip invalid and default types: */
347	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Invalid
348	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Default)
349	continue;
350	/* If option type enabled: */
351	if (m_fOptionsAudio & enmOptionType)
352	{
353	/* Add it to the list: */
354	options << gpConverter->toInternalString(enmOptionType);
355	/* Make sure item is included by default: */
356	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Default & enmOptionType))
357	fDefault = false;
358	}
359	/* If option type disabled: */
360	else
361	{
362	/* Make sure item is excluded by default: */
363	if (UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Default & enmOptionType)
364	fDefault = false;
365	}
366	/* Save options: */
367	if (!fDefault)
368	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Audio, options);
369	else
370	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Audio, QStringList());
371	}
372	}
373	}
374
375	void UIDetailsModel::setOptionsNetwork(UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork fOptionsNetwork)
376	{
377	m_fOptionsNetwork = fOptionsNetwork;
378	m_pRoot->rebuildGroup();
379	m_pContextMenu->updateOptionStates(DetailsElementType_Network);
380
381	/* Save network options: */
382	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
383	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeNetwork");
384	if (iEnumIndex != -1)
385	{
386	bool fDefault = true;
387	QStringList options;
388	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
389	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
390	{
391	/* Prepare current option type: */
392	const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOptionType =
393	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
394	/* Skip invalid and default types: */
395	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid
396	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Default)
397	continue;
398	/* If option type enabled: */
399	if (m_fOptionsNetwork & enmOptionType)
400	{
401	/* Add it to the list: */
402	options << gpConverter->toInternalString(enmOptionType);
403	/* Make sure item is included by default: */
404	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Default & enmOptionType))
405	fDefault = false;
406	}
407	/* If option type disabled: */
408	else
409	{
410	/* Make sure item is excluded by default: */
411	if (UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Default & enmOptionType)
412	fDefault = false;
413	}
414	/* Save options: */
415	if (!fDefault)
416	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Network, options);
417	else
418	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Network, QStringList());
419	}
420	}
421	}
422
423	void UIDetailsModel::setOptionsSerial(UIExtraDataMetaDefs::DetailsElementOptionTypeSerial fOptionsSerial)
424	{
425	m_fOptionsSerial = fOptionsSerial;
426	m_pRoot->rebuildGroup();
427	m_pContextMenu->updateOptionStates(DetailsElementType_Serial);
428
429	/* Save serial options: */
430	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
431	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSerial");
432	if (iEnumIndex != -1)
433	{
434	bool fDefault = true;
435	QStringList options;
436	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
437	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
438	{
439	/* Prepare current option type: */
440	const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOptionType =
441	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
442	/* Skip invalid and default types: */
443	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Invalid
444	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Default)
445	continue;
446	/* If option type enabled: */
447	if (m_fOptionsSerial & enmOptionType)
448	{
449	/* Add it to the list: */
450	options << gpConverter->toInternalString(enmOptionType);
451	/* Make sure item is included by default: */
452	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Default & enmOptionType))
453	fDefault = false;
454	}
455	/* If option type disabled: */
456	else
457	{
458	/* Make sure item is excluded by default: */
459	if (UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Default & enmOptionType)
460	fDefault = false;
461	}
462	/* Save options: */
463	if (!fDefault)
464	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Serial, options);
465	else
466	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Serial, QStringList());
467	}
468	}
469	}
470
471	void UIDetailsModel::setOptionsUsb(UIExtraDataMetaDefs::DetailsElementOptionTypeUsb fOptionsUsb)
472	{
473	m_fOptionsUsb = fOptionsUsb;
474	m_pRoot->rebuildGroup();
475	m_pContextMenu->updateOptionStates(DetailsElementType_USB);
476
477	/* Save USB options: */
478	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
479	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeUsb");
480	if (iEnumIndex != -1)
481	{
482	bool fDefault = true;
483	QStringList options;
484	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
485	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
486	{
487	/* Prepare current option type: */
488	const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOptionType =
489	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
490	/* Skip invalid and default types: */
491	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Invalid
492	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Default)
493	continue;
494	/* If option type enabled: */
495	if (m_fOptionsUsb & enmOptionType)
496	{
497	/* Add it to the list: */
498	options << gpConverter->toInternalString(enmOptionType);
499	/* Make sure item is included by default: */
500	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Default & enmOptionType))
501	fDefault = false;
502	}
503	/* If option type disabled: */
504	else
505	{
506	/* Make sure item is excluded by default: */
507	if (UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Default & enmOptionType)
508	fDefault = false;
509	}
510	/* Save options: */
511	if (!fDefault)
512	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_USB, options);
513	else
514	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_USB, QStringList());
515	}
516	}
517	}
518
519	void UIDetailsModel::setOptionsSharedFolders(UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders fOptionsSharedFolders)
520	{
521	m_fOptionsSharedFolders = fOptionsSharedFolders;
522	m_pRoot->rebuildGroup();
523	m_pContextMenu->updateOptionStates(DetailsElementType_SF);
524
525	/* Save shared folders options: */
526	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
527	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSharedFolders");
528	if (iEnumIndex != -1)
529	{
530	bool fDefault = true;
531	QStringList options;
532	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
533	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
534	{
535	/* Prepare current option type: */
536	const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOptionType =
537	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
538	/* Skip invalid and default types: */
539	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Invalid
540	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Default)
541	continue;
542	/* If option type enabled: */
543	if (m_fOptionsSharedFolders & enmOptionType)
544	{
545	/* Add it to the list: */
546	options << gpConverter->toInternalString(enmOptionType);
547	/* Make sure item is included by default: */
548	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Default & enmOptionType))
549	fDefault = false;
550	}
551	/* If option type disabled: */
552	else
553	{
554	/* Make sure item is excluded by default: */
555	if (UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Default & enmOptionType)
556	fDefault = false;
557	}
558	/* Save options: */
559	if (!fDefault)
560	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_SF, options);
561	else
562	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_SF, QStringList());
563	}
564	}
565	}
566
567	void UIDetailsModel::setOptionsUserInterface(UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface fOptionsUserInterface)
568	{
569	m_fOptionsUserInterface = fOptionsUserInterface;
570	m_pRoot->rebuildGroup();
571	m_pContextMenu->updateOptionStates(DetailsElementType_UI);
572
573	/* Save user interface options: */
574	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
575	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeUserInterface");
576	if (iEnumIndex != -1)
577	{
578	bool fDefault = true;
579	QStringList options;
580	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
581	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
582	{
583	/* Prepare current option type: */
584	const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOptionType =
585	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
586	/* Skip invalid and default types: */
587	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Invalid
588	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Default)
589	continue;
590	/* If option type enabled: */
591	if (m_fOptionsUserInterface & enmOptionType)
592	{
593	/* Add it to the list: */
594	options << gpConverter->toInternalString(enmOptionType);
595	/* Make sure item is included by default: */
596	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Default & enmOptionType))
597	fDefault = false;
598	}
599	/* If option type disabled: */
600	else
601	{
602	/* Make sure item is excluded by default: */
603	if (UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Default & enmOptionType)
604	fDefault = false;
605	}
606	/* Save options: */
607	if (!fDefault)
608	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_UI, options);
609	else
610	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_UI, QStringList());
611	}
612	}
613	}
614
615	void UIDetailsModel::setOptionsDescription(UIExtraDataMetaDefs::DetailsElementOptionTypeDescription fOptionsDescription)
616	{
617	m_fOptionsDescription = fOptionsDescription;
618	m_pRoot->rebuildGroup();
619	m_pContextMenu->updateOptionStates(DetailsElementType_Description);
620
621	/* Save description options: */
622	const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
623	const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeDescription");
624	if (iEnumIndex != -1)
625	{
626	bool fDefault = true;
627	QStringList options;
628	const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
629	for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
630	{
631	/* Prepare current option type: */
632	const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOptionType =
633	static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
634	/* Skip invalid and default types: */
635	if ( enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Invalid
636	\|\| enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Default)
637	continue;
638	/* If option type enabled: */
639	if (m_fOptionsDescription & enmOptionType)
640	{
641	/* Add it to the list: */
642	options << gpConverter->toInternalString(enmOptionType);
643	/* Make sure item is included by default: */
644	if (!(UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Default & enmOptionType))
645	fDefault = false;
646	}
647	/* If option type disabled: */
648	else
649	{
650	/* Make sure item is excluded by default: */
651	if (UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Default & enmOptionType)
652	fDefault = false;
653	}
654	/* Save options: */
655	if (!fDefault)
656	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Description, options);
657	else
658	gEDataManager->setVBoxManagerDetailsPaneElementOptions(DetailsElementType_Description, QStringList());
659	}
660	}
661	}
662
663	void UIDetailsModel::sltHandleViewResize()
664	{
665	updateLayout();
666	}
667
668	void UIDetailsModel::sltHandleToggleStarted()
669	{
670	m_pRoot->stopBuildingGroup();
671	}
672
673	void UIDetailsModel::sltHandleToggleFinished()
674	{
675	m_pRoot->rebuildGroup();
676	}
677
678	void UIDetailsModel::sltHandleExtraDataCategoriesChange()
679	{
680	loadDetailsCategories();
681	m_pContextMenu->updateCategoryStates();
682	m_pRoot->rebuildGroup();
683	}
684
685	void UIDetailsModel::sltHandleExtraDataOptionsChange(DetailsElementType enmType)
686	{
687	loadDetailsOptions(enmType);
688	m_pContextMenu->updateOptionStates(enmType);
689	m_pRoot->rebuildGroup();
690	}
691
692	bool UIDetailsModel::eventFilter(QObject pObject, QEvent pEvent)
693	{
694	/* Handle allowed context-menu events: */
695	if (pObject == scene() && pEvent->type() == QEvent::GraphicsSceneContextMenu)
696	return processContextMenuEvent(static_cast<QGraphicsSceneContextMenuEvent*>(pEvent));
697
698	/* Call to base-class: */
699	return QObject::eventFilter(pObject, pEvent);
700	}
701
702	void UIDetailsModel::sltToggleElements(DetailsElementType type, bool fToggled)
703	{
704	/* Make sure it is not started yet: */
705	if (m_pAnimationCallback)
706	return;
707
708	/* Prepare/configure animation callback: */
709	m_pAnimationCallback = new UIDetailsElementAnimationCallback(this, type, fToggled);
710	connect(m_pAnimationCallback, &UIDetailsElementAnimationCallback::sigAllAnimationFinished,
711	this, &UIDetailsModel::sltToggleAnimationFinished, Qt::QueuedConnection);
712	/* For each the set of the group: */
713	foreach (UIDetailsItem *pSetItem, m_pRoot->items())
714	{
715	/* For each the element of the set: */
716	foreach (UIDetailsItem *pElementItem, pSetItem->items())
717	{
718	/* Get each element: */
719	UIDetailsElement *pElement = pElementItem->toElement();
720	/* Check if this element is of required type: */
721	if (pElement->elementType() == type)
722	{
723	if (fToggled && pElement->isClosed())
724	{
725	m_pAnimationCallback->addNotifier(pElement);
726	pElement->open();
727	}
728	else if (!fToggled && pElement->isOpened())
729	{
730	m_pAnimationCallback->addNotifier(pElement);
731	pElement->close();
732	}
733	}
734	}
735	}
736	/* Update layout: */
737	updateLayout();
738	}
739
740	void UIDetailsModel::sltToggleAnimationFinished(DetailsElementType enmType, bool fToggled)
741	{
742	/* Cleanup animation callback: */
743	delete m_pAnimationCallback;
744	m_pAnimationCallback = 0;
745
746	/* Mark animation finished: */
747	foreach (UIDetailsItem *pSetItem, m_pRoot->items())
748	{
749	foreach (UIDetailsItem *pElementItem, pSetItem->items())
750	{
751	UIDetailsElement *pElement = pElementItem->toElement();
752	if (pElement->elementType() == enmType)
753	pElement->markAnimationFinished();
754	}
755	}
756	/* Update layout: */
757	updateLayout();
758
759	/* Update element open/close status: */
760	if (m_categories.contains(enmType))
761	{
762	m_categories[enmType] = fToggled;
763	gEDataManager->setSelectorWindowDetailsElements(m_categories);
764	}
765	}
766
767	void UIDetailsModel::prepare()
768	{
769	/* Prepare things: */
770	prepareScene();
771	prepareRoot();
772	prepareContextMenu();
773	loadSettings();
774	}
775
776	void UIDetailsModel::prepareScene()
777	{
778	m_pScene = new QGraphicsScene(this);
779	if (m_pScene)
780	m_pScene->installEventFilter(this);
781	}
782
783	void UIDetailsModel::prepareRoot()
784	{
785	m_pRoot = new UIDetailsGroup(scene());
786	}
787
788	void UIDetailsModel::prepareContextMenu()
789	{
790	m_pContextMenu = new UIDetailsContextMenu(this);
791	}
792
793	void UIDetailsModel::loadSettings()
794	{
795	loadDetailsCategories();
796	loadDetailsOptions();
797	}
798
799	void UIDetailsModel::loadDetailsCategories()
800	{
801	m_categories = gEDataManager->selectorWindowDetailsElements();
802	m_pContextMenu->updateCategoryStates();
803	}
804
805	void UIDetailsModel::loadDetailsOptions(DetailsElementType enmType /* = DetailsElementType_Invalid */)
806	{
807	/* We will handle DetailsElementType_Invalid as a request to load everything. */
808
809	if (enmType == DetailsElementType_General \|\| enmType == DetailsElementType_Invalid)
810	{
811	m_fOptionsGeneral = UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid;
812	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_General))
813	{
814	const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOption =
815	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>(strOption);
816	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid)
817	m_fOptionsGeneral = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>(m_fOptionsGeneral \| enmOption);
818	}
819	if (m_fOptionsGeneral == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid)
820	m_fOptionsGeneral = UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default;
821	}
822
823	if (enmType == DetailsElementType_System \|\| enmType == DetailsElementType_Invalid)
824	{
825	m_fOptionsSystem = UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Invalid;
826	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_System))
827	{
828	const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOption =
829	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>(strOption);
830	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Invalid)
831	m_fOptionsSystem = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>(m_fOptionsSystem \| enmOption);
832	}
833	if (m_fOptionsSystem == UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Invalid)
834	m_fOptionsSystem = UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Default;
835	}
836
837	if (enmType == DetailsElementType_Display \|\| enmType == DetailsElementType_Invalid)
838	{
839	m_fOptionsDisplay = UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Invalid;
840	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Display))
841	{
842	const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOption =
843	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>(strOption);
844	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Invalid)
845	m_fOptionsDisplay = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>(m_fOptionsDisplay \| enmOption);
846	}
847	if (m_fOptionsDisplay == UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Invalid)
848	m_fOptionsDisplay = UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Default;
849	}
850
851	if (enmType == DetailsElementType_Storage \|\| enmType == DetailsElementType_Invalid)
852	{
853	m_fOptionsStorage = UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Invalid;
854	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Storage))
855	{
856	const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOption =
857	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>(strOption);
858	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Invalid)
859	m_fOptionsStorage = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>(m_fOptionsStorage \| enmOption);
860	}
861	if (m_fOptionsStorage == UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Invalid)
862	m_fOptionsStorage = UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Default;
863	}
864
865	if (enmType == DetailsElementType_Audio \|\| enmType == DetailsElementType_Invalid)
866	{
867	m_fOptionsAudio = UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Invalid;
868	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Audio))
869	{
870	const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOption =
871	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>(strOption);
872	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Invalid)
873	m_fOptionsAudio = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>(m_fOptionsAudio \| enmOption);
874	}
875	if (m_fOptionsAudio == UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Invalid)
876	m_fOptionsAudio = UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Default;
877	}
878
879	if (enmType == DetailsElementType_Network \|\| enmType == DetailsElementType_Invalid)
880	{
881	m_fOptionsNetwork = UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid;
882	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Network))
883	{
884	const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOption =
885	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>(strOption);
886	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid)
887	m_fOptionsNetwork = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>(m_fOptionsNetwork \| enmOption);
888	}
889	if (m_fOptionsNetwork == UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid)
890	m_fOptionsNetwork = UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Default;
891	}
892
893	if (enmType == DetailsElementType_Serial \|\| enmType == DetailsElementType_Invalid)
894	{
895	m_fOptionsSerial = UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Invalid;
896	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Serial))
897	{
898	const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOption =
899	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>(strOption);
900	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Invalid)
901	m_fOptionsSerial = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>(m_fOptionsSerial \| enmOption);
902	}
903	if (m_fOptionsSerial == UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Invalid)
904	m_fOptionsSerial = UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Default;
905	}
906
907	if (enmType == DetailsElementType_USB \|\| enmType == DetailsElementType_Invalid)
908	{
909	m_fOptionsUsb = UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Invalid;
910	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_USB))
911	{
912	const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOption =
913	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>(strOption);
914	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Invalid)
915	m_fOptionsUsb = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>(m_fOptionsUsb \| enmOption);
916	}
917	if (m_fOptionsUsb == UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Invalid)
918	m_fOptionsUsb = UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Default;
919	}
920
921	if (enmType == DetailsElementType_SF \|\| enmType == DetailsElementType_Invalid)
922	{
923	m_fOptionsSharedFolders = UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Invalid;
924	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_SF))
925	{
926	const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOption =
927	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>(strOption);
928	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Invalid)
929	m_fOptionsSharedFolders = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>(m_fOptionsSharedFolders \| enmOption);
930	}
931	if (m_fOptionsSharedFolders == UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Invalid)
932	m_fOptionsSharedFolders = UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Default;
933	}
934
935	if (enmType == DetailsElementType_UI \|\| enmType == DetailsElementType_Invalid)
936	{
937	m_fOptionsUserInterface = UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Invalid;
938	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_UI))
939	{
940	const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOption =
941	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>(strOption);
942	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Invalid)
943	m_fOptionsUserInterface = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>(m_fOptionsUserInterface \| enmOption);
944	}
945	if (m_fOptionsUserInterface == UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Invalid)
946	m_fOptionsUserInterface = UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Default;
947	}
948
949	if (enmType == DetailsElementType_Description \|\| enmType == DetailsElementType_Invalid)
950	{
951	m_fOptionsDescription = UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Invalid;
952	foreach (const QString &strOption, gEDataManager->vboxManagerDetailsPaneElementOptions(DetailsElementType_Description))
953	{
954	const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOption =
955	gpConverter->fromInternalString<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>(strOption);
956	if (enmOption != UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Invalid)
957	m_fOptionsDescription = static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>(m_fOptionsDescription \| enmOption);
958	}
959	if (m_fOptionsDescription == UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Invalid)
960	m_fOptionsDescription = UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Default;
961	}
962
963	m_pContextMenu->updateOptionStates();
964	}
965
966	void UIDetailsModel::cleanupContextMenu()
967	{
968	delete m_pContextMenu;
969	m_pContextMenu = 0;
970	}
971
972	void UIDetailsModel::cleanupRoot()
973	{
974	delete m_pRoot;
975	m_pRoot = 0;
976	}
977
978	void UIDetailsModel::cleanupScene()
979	{
980	delete m_pScene;
981	m_pScene = 0;
982	}
983
984	void UIDetailsModel::cleanup()
985	{
986	/* Cleanup things: */
987	cleanupContextMenu();
988	cleanupRoot();
989	cleanupScene();
990	}
991
992	bool UIDetailsModel::processContextMenuEvent(QGraphicsSceneContextMenuEvent *pEvent)
993	{
994	/* Pass preview context menu instead: */
995	if (QGraphicsItem *pItem = itemAt(pEvent->scenePos()))
996	if (pItem->type() == UIDetailsItemType_Preview)
997	return false;
998
999	/* Adjust the menu then show it: */
1000	const QRect availableGeo = gpDesktop->availableGeometry(pEvent->screenPos());
1001	QRect geo(pEvent->screenPos(), m_pContextMenu->minimumSizeHint());
1002	if (geo.topRight().x() > availableGeo.topRight().x())
1003	geo.adjust(availableGeo.topRight().x() - geo.topRight().x(), 0,
1004	availableGeo.topRight().x() - geo.topRight().x(), 0);
1005	if (geo.bottomLeft().y() > availableGeo.bottomLeft().y())
1006	geo.adjust(0, availableGeo.bottomLeft().y() - geo.bottomLeft().y(),
1007	0, availableGeo.bottomLeft().y() - geo.bottomLeft().y());
1008	m_pContextMenu->resize(geo.size());
1009	m_pContextMenu->move(geo.topLeft());
1010	m_pContextMenu->show();
1011
1012	/* Filter: */
1013	return true;
1014	}
1015
1016
1017	/*********************************************************************************************************************************
1018	* Class UIDetailsElementAnimationCallback implementation. *
1019	*********************************************************************************************************************************/
1020
1021	UIDetailsElementAnimationCallback::UIDetailsElementAnimationCallback(QObject *pParent, DetailsElementType enmType, bool fToggled)
1022	: QObject(pParent)
1023	, m_enmType(enmType)
1024	, m_fToggled(fToggled)
1025	{
1026	}
1027
1028	void UIDetailsElementAnimationCallback::addNotifier(UIDetailsElement *pItem)
1029	{
1030	/* Connect notifier: */
1031	connect(pItem, &UIDetailsElement::sigToggleElementFinished,
1032	this, &UIDetailsElementAnimationCallback::sltAnimationFinished);
1033	/* Remember notifier: */
1034	m_notifiers << pItem;
1035	}
1036
1037	void UIDetailsElementAnimationCallback::sltAnimationFinished()
1038	{
1039	/* Determine notifier: */
1040	UIDetailsElement pItem = qobject_cast<UIDetailsElement>(sender());
1041	/* Disconnect notifier: */
1042	disconnect(pItem, &UIDetailsElement::sigToggleElementFinished,
1043	this, &UIDetailsElementAnimationCallback::sltAnimationFinished);
1044	/* Remove notifier: */
1045	m_notifiers.removeAll(pItem);
1046	/* Check if we finished: */
1047	if (m_notifiers.isEmpty())
1048	emit sigAllAnimationFinished(m_enmType, m_fToggled);
1049	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsModel.cpp@ 103977

Download in other formats: