MythTV  master
standardsettings.cpp
Go to the documentation of this file.
1 #include "standardsettings.h"
2 #include <QApplication>
3 #include <QCoreApplication>
4 #include <QThread>
5 #include <utility>
6 
7 #include <mythcontext.h>
8 #include <mythmainwindow.h>
9 #include <mythdialogbox.h>
10 #include <mythuispinbox.h>
11 #include <mythuitext.h>
12 #include <mythuibutton.h>
13 #include <mythuifilebrowser.h>
14 #include "mythlogging.h"
15 
17 {
18  setting->updateButton(this);
19 }
20 
22 {
23  QList<StandardSetting *>::const_iterator i;
24  for (i = m_children.constBegin(); i != m_children.constEnd(); ++i)
25  delete *i;
26  m_children.clear();
27 
28  QMap<QString, QList<StandardSetting *> >::const_iterator iMap;
29  for (iMap = m_targets.constBegin(); iMap != m_targets.constEnd(); ++iMap)
30  {
31  for (i = (*iMap).constBegin(); i != (*iMap).constEnd(); ++i)
32  delete *i;
33  }
34  m_targets.clear();
35 }
36 
38 {
39  auto *item = new MythUIButtonListItemSetting(list, m_label);
40  item->SetData(QVariant::fromValue(this));
41  connect(this, &StandardSetting::ShouldRedraw,
43  updateButton(item);
44  return item;
45 }
46 
47 void StandardSetting::setEnabled(bool enabled)
48 {
49  m_enabled = enabled;
50  emit ShouldRedraw(this);
51 }
52 
53 void StandardSetting::setReadOnly(bool readonly)
54 {
55  m_readonly = readonly;
56  emit ShouldRedraw(this);
57 }
58 
59 void StandardSetting::setVisible(bool visible)
60 {
61  m_visible = visible;
62  emit settingsChanged(this);
63 }
64 
66 {
67  m_parent = parent;
68 }
69 
71 {
72  if (!child)
73  return;
74 
75  m_children.append(child);
76  child->setParent(this);
77 }
78 
80 {
81  m_children.removeAll(child);
82  emit settingsChanged(this);
83 }
84 
85 bool StandardSetting::keyPressEvent(QKeyEvent * /*e*/)
86 {
87  return false;
88 }
89 
96 {
97  item->setVisible(m_visible);
98  item->DisplayState("standard", "widgettype");
99  item->setEnabled(isEnabled());
100  item->SetText(m_label);
101  item->SetText(m_settingValue, "value");
102  item->SetText(getHelpText(), "description");
103  item->setDrawArrow(haveSubSettings());
104 }
105 
106 void StandardSetting::addTargetedChildren(const QString &value,
107  std::initializer_list<StandardSetting *> settings)
108 {
109  m_targets[value].reserve(settings.size());
110  for (auto *setting : qAsConst(settings))
111  {
112  m_targets[value].append(setting);
113  setting->setParent(this);
114  }
115 }
116 void StandardSetting::addTargetedChild(const QString &value,
117  StandardSetting * setting)
118 {
119  m_targets[value].append(setting);
120  setting->setParent(this);
121 }
122 
123 void StandardSetting::removeTargetedChild(const QString &value,
124  StandardSetting *child)
125 {
126  if (m_targets.contains(value))
127  {
128  m_targets[value].removeAll(child);
129  delete child;
130  }
131 }
132 
133 void StandardSetting::clearTargetedSettings(const QString &value)
134 {
135  if (m_targets.contains(value))
136  {
137  for (auto *setting : qAsConst(m_targets[value]))
138  {
139  delete setting;
140  }
141  m_targets[value].clear();
142  }
143 }
144 
145 QList<StandardSetting *> *StandardSetting::getSubSettings()
146 {
147  if (m_targets.contains(m_settingValue) &&
148  !m_targets[m_settingValue].empty())
149  return &m_targets[m_settingValue];
150  return &m_children;
151 }
152 
154 {
155  QList<StandardSetting *> *subSettings = getSubSettings();
156  return subSettings && !subSettings->empty();
157 }
158 
160 {
161  m_children.clear();
162 }
163 
164 void StandardSetting::setValue(int newValue)
165 {
166  setValue(QString::number(newValue));
167 }
168 
169 void StandardSetting::setValue(const QString &newValue)
170 {
171  if (m_settingValue != newValue)
172  {
173  m_settingValue = newValue;
174  m_haveChanged = true;
175 
176  emit valueChanged(newValue);
177  emit valueChanged(this);
178  }
179  emit ShouldRedraw(this);
180 }
181 
186 {
187  if (m_haveChanged)
188  {
189  LOG(VB_GENERAL, LOG_DEBUG,
190  QString("Setting '%1' changed to %2").arg(getLabel(), getValue()));
191  return true;
192  }
193 
194  //we check only the relevant children
195  QList<StandardSetting *> *children = getSubSettings();
196  if (!children)
197  return false;
198 
199  QList<StandardSetting *>::const_iterator i;
200  bool haveChanged = false;
201  for (i = children->constBegin(); !haveChanged && i != children->constEnd();
202  ++i)
203  haveChanged = (*i)->haveChanged();
204 
205  return haveChanged;
206 }
207 
208 void StandardSetting::setChanged(bool changed)
209 {
210  m_haveChanged = changed;
211 }
212 
214 {
215  if (m_storage)
216  m_storage->Load();
217 
218  m_haveChanged = false;
219 
220  QList<StandardSetting *>::const_iterator i;
221  for (i = m_children.constBegin(); i != m_children.constEnd(); ++i)
222  (*i)->Load();
223 
224  QMap<QString, QList<StandardSetting *> >::const_iterator iMap;
225  for (iMap = m_targets.constBegin(); iMap != m_targets.constEnd(); ++iMap)
226  {
227  for (i = (*iMap).constBegin(); i != (*iMap).constEnd(); ++i)
228  (*i)->Load();
229  }
230 }
231 
233 {
234  if (m_storage)
235  m_storage->Save();
236 
237  //we save only the relevant children
238  QList<StandardSetting *> *children = getSubSettings();
239  if (children)
240  {
241  for (auto i = children->constBegin(); i != children->constEnd(); ++i)
242  (*i)->Save();
243  }
244 
245  if (!m_haveChanged)
246  return;
247 
248  m_haveChanged = false;
249  emit ChangeSaved();
250 }
251 
252 void StandardSetting::setName(const QString &name)
253 {
254  m_name = name;
255  if (m_label.isEmpty())
256  setLabel(name);
257 }
258 
260 {
261  if (name == m_name)
262  return this;
263 
264  for (auto *setting : qAsConst(*getSubSettings()))
265  {
266  StandardSetting *s = setting->byName(name);
267  if (s)
268  return s;
269  }
270  return nullptr;
271 }
272 
273 void StandardSetting::MoveToThread(QThread *thread)
274 {
275  moveToThread(thread);
276 
277  QList<StandardSetting *>::const_iterator i;
278  for (i = m_children.constBegin(); i != m_children.constEnd(); ++i)
279  (*i)->MoveToThread(thread);
280 
281  QMap<QString, QList<StandardSetting *> >::const_iterator iMap;
282  for (iMap = m_targets.constBegin(); iMap != m_targets.constEnd(); ++iMap)
283  {
284  for (i = (*iMap).constBegin(); i != (*iMap).constEnd(); ++i)
285  (*i)->MoveToThread(thread);
286  }
287 }
288 
289 /******************************************************************************
290  Group Setting
291 *******************************************************************************/
293 {
294  if (!isEnabled())
295  return;
296 
297  if (isReadOnly())
298  return;
299 
300  auto *dce = new DialogCompletionEvent("leveldown", 0, "", "");
301  QCoreApplication::postEvent(screen, dce);
302 }
303 
305 {
306  item->DisplayState("group", "widgettype");
307  item->setEnabled(isEnabled());
308  item->SetText(m_label);
309  item->SetText(m_settingValue, "value");
310  item->SetText(getHelpText(), "description");
311  item->setDrawArrow(haveSubSettings());
312 }
313 
315 {
316  setLabel(label);
317 }
318 
320 {
321  emit clicked();
322 }
323 
325 {
326  if (getValue() == "0")
327  {
328  // Generate a new, unique ID
329  QString querystr = "INSERT INTO " + m_table +
330  " (" + m_column + ") VALUES (0);";
331 
332  MSqlQuery query(MSqlQuery::InitCon());
333 
334  if (!query.exec(querystr))
335  {
336  MythDB::DBError("inserting row", query);
337  return;
338  }
339  // XXX -- HACK BEGIN:
340  // lastInsertID fails with "QSqlQuery::value: not positioned on a valid
341  // record" if we get a invalid QVariant we workaround the problem by
342  // taking advantage of mysql always incrementing the auto increment
343  // pointer this breaks if someone modifies the auto increment pointer
344  //setValue(query.lastInsertId().toInt());
345 
346  QVariant var = query.lastInsertId();
347 
348 #if QT_VERSION < QT_VERSION_CHECK(6,0,0)
349  auto id = static_cast<QMetaType::Type>(var.type());
350 #else
351  auto id = var.typeId();
352 #endif
353  if (id != QMetaType::UnknownType)
354  setValue(var.toInt());
355  else
356  {
357  querystr = "SELECT MAX(" + m_column + ") FROM " +
358  m_table + ";";
359  if (query.exec(querystr) && query.next())
360  {
361  int lii = query.value(0).toInt();
362  lii = lii ? lii : 1;
363  setValue(lii);
364  }
365  else
366  {
367  LOG(VB_GENERAL, LOG_EMERG,
368  "Can't determine the Id of the last insert "
369  "QSqlQuery.lastInsertId() failed, the workaround "
370  "failed too!");
371  }
372  }
373  // XXX -- HACK END:
374  }
375 }
376 
377 AutoIncrementSetting::AutoIncrementSetting(QString _table, QString _column) :
378  m_table(std::move(_table)), m_column(std::move(_column))
379 {
380  setValue("0");
381 }
382 
383 /******************************************************************************
384  Text Setting
385 *******************************************************************************/
386 
388 {
389  m_passwordEcho = b;
390 }
391 
393 {
394  if (!isEnabled())
395  return;
396 
397  if (isReadOnly())
398  return;
399 
400  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
401 
402  auto *settingdialog =
403  new MythTextInputDialog(popupStack, getLabel(), FilterNone,
405 
406  if (settingdialog->Create())
407  {
408  settingdialog->SetReturnEvent(screen, "editsetting");
409  popupStack->AddScreen(settingdialog);
410  }
411  else
412  delete settingdialog;
413 }
414 
416 {
417  if (m_settingValue != dce->GetResultText())
418  setValue(dce->GetResultText());
419 }
420 
421 
423 {
425  item->DisplayState("textedit", "widgettype");
426 }
427 
428 
429 /******************************************************************************
430  Directory Setting
431 *******************************************************************************/
432 
434 {
435  if (!isEnabled())
436  return;
437 
438  if (isReadOnly())
439  return;
440 
441  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
442 
443  auto *settingdialog = new MythUIFileBrowser(popupStack, m_settingValue);
444  settingdialog->SetTypeFilter(m_typeFilter);
445  settingdialog->SetNameFilter(m_nameFilter);
446 
447  if (settingdialog->Create())
448  {
449  settingdialog->SetReturnEvent(screen, "editsetting");
450  popupStack->AddScreen(settingdialog);
451  }
452  else
453  delete settingdialog;
454 }
455 
457 {
458  if (m_settingValue != dce->GetResultText())
459  setValue(dce->GetResultText());
460 }
461 
463 {
465  item->DisplayState("filebrowser", "widgettype");
466 }
467 
468 
469 /******************************************************************************
470  ComboBoxSetting
471 *******************************************************************************/
473 {
474  m_labels.clear();
475  m_values.clear();
476 }
477 
479 {
480  if (value >= 0 && value < m_values.size())
481  {
483  m_isSet = true;
484  }
485 }
486 
487 int MythUIComboBoxSetting::getValueIndex(const QString &value) const
488 {
489  return m_values.indexOf(value);
490 }
491 
493 {
494  int index = getValueIndex(getValue());
495  return (index >= 0) ? m_labels.at(index) : QString("");
496 }
497 
498 void MythUIComboBoxSetting::addSelection(const QString &label, QString value,
499  bool select)
500 {
501  value = value.isEmpty() ? label : value;
502  m_labels.push_back(label);
503  m_values.push_back(value);
504 
505  if (select || !m_isSet)
506  {
508  if (!m_isSet)
509  m_isSet = true;
510  }
511 }
512 
514 {
515  m_isSet = false;
516  m_labels.clear();
517  m_values.clear();
518 }
519 
521 {
522  item->DisplayState("combobox", "widgettype");
523  item->setEnabled(isEnabled());
524  item->SetText(m_label);
525  int indexValue = m_values.indexOf(m_settingValue);
526  if (indexValue >= 0)
527  item->SetText(m_labels.value(indexValue), "value");
528  else
529  item->SetText(m_settingValue, "value");
530  item->SetText(getHelpText(), "description");
531  item->setDrawArrow(haveSubSettings());
532 }
533 
535 {
536  if (!isEnabled())
537  return;
538 
539  if (isReadOnly())
540  return;
541 
542  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
543 
544  auto *menuPopup = new MythDialogBox(getLabel(), popupStack, "optionmenu");
545 
546  if (menuPopup->Create())
547  {
548  popupStack->AddScreen(menuPopup);
549 
550  //connect(menuPopup, &MythDialogBox::haveResult,
551  //this, qOverload<const QString&>(&MythUIComboBoxSetting::setValue));
552 
553  menuPopup->SetReturnEvent(screen, "editsetting");
554 
555  if (m_rewrite)
556  {
557  menuPopup->AddButtonV(QObject::tr("New entry"),
558  QString("NEWENTRY"),
559  false,
560  m_settingValue == "");
561  }
562  for (int i = 0; i < m_labels.size() && !m_values.empty(); ++i)
563  {
564  QString value = m_values.at(i);
565  menuPopup->AddButtonV(m_labels.at(i),
566  value,
567  false,
568  value == m_settingValue);
569  }
570  }
571  else
572  delete menuPopup;
573 }
574 
575 void MythUIComboBoxSetting::setValue(const QString& newValue)
576 {
577  StandardSetting::setValue(newValue);
578  m_isSet = true;
579 }
580 
582 {
583  if (dce->GetResult() != -1)
584  {
585  if (m_rewrite && dce->GetData().toString() == "NEWENTRY")
586  {
587  MythScreenStack *popupStack =
588  GetMythMainWindow()->GetStack("popup stack");
589 
590  auto *settingdialog =
591  new MythTextInputDialog(popupStack, getLabel(), FilterNone,
592  false, m_settingValue);
593 
594  if (settingdialog->Create())
595  {
596  connect(settingdialog, &MythTextInputDialog::haveResult,
597  this, qOverload<const QString&>(&MythUIComboBoxSetting::setValue));
598  popupStack->AddScreen(settingdialog);
599  }
600  else
601  delete settingdialog;
602  }
603  else if (m_settingValue != dce->GetData().toString())
604  StandardSetting::setValue(dce->GetData().toString());
605  }
606 }
607 
608 void MythUIComboBoxSetting::fillSelectionsFromDir(const QDir &dir, bool absPath)
609 {
610  QFileInfoList entries = dir.entryInfoList();
611  for (const auto& fi : qAsConst(entries))
612  {
613  if (absPath)
614  addSelection( fi.absoluteFilePath() );
615  else
616  addSelection( fi.fileName() );
617  }
618 }
619 
621 {
622  return m_labels.size();
623 }
624 
625 /******************************************************************************
626  SpinBox Setting
627 *******************************************************************************/
629  int step, int pageMultiple,
630  QString special_value_text)
631  : StandardSetting(_storage),
632  m_min(min),
633  m_max(max),
634  m_step(step),
635  m_pageMultiple(pageMultiple),
636  m_specialValueText(std::move(special_value_text))
637 {
638  // We default to 0 unless 0 is out of range.
639  if (m_min > 0 || m_max < 0)
640  m_settingValue = QString::number(m_min);
641 
642  // The settings pages were coded to assume a parameter true/false
643  // meaning allow_single_step. Many pages use this but it was not
644  // implemented. It is difficult to implement using the current
645  // UI widget design. So I have changed it so you can specify
646  // the size of pageup / pagedown increments as an integer instead.
647  // For compatibility with callers still using true to indicate
648  // allowing single step, the code will set the step size as 1 and
649  // the pageup / pagedown as the requested step.
650 
651  if (m_pageMultiple == 1)
652  {
653  m_pageMultiple = step;
654  m_step = 1;
655  }
656  if (m_pageMultiple == 0)
657  {
658  m_pageMultiple = 5;
659  }
660 }
661 
663 {
664  item->DisplayState("spinbox", "widgettype");
665  item->setEnabled(isEnabled());
666  item->SetText(m_label);
667  if (m_settingValue.toInt() == m_min && !m_specialValueText.isEmpty())
668  item->SetText(m_specialValueText, "value");
669  else
670  item->SetText(m_settingValue, "value");
671  item->SetText(getHelpText(), "description");
672  item->setDrawArrow(haveSubSettings());
673 }
674 
676 {
677  return m_settingValue.toInt();
678 }
679 
681 {
682  if (!isEnabled())
683  return;
684 
685  if (isReadOnly())
686  return;
687 
688  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
689 
690  auto *settingdialog = new MythSpinBoxDialog(popupStack, getLabel());
691 
692  if (settingdialog->Create())
693  {
694  settingdialog->SetRange(m_min, m_max, m_step, m_pageMultiple);
695  if (!m_specialValueText.isEmpty())
696  settingdialog->AddSelection(m_specialValueText, m_min);
697  settingdialog->SetValue(m_settingValue);
698  settingdialog->SetReturnEvent(screen, "editsetting");
699  popupStack->AddScreen(settingdialog);
700  }
701  else
702  delete settingdialog;
703 }
704 
706 {
707  if (m_settingValue != dce->GetResultText())
708  setValue(dce->GetResultText());
709 }
710 
711 /******************************************************************************
712  MythUICheckBoxSetting
713 *******************************************************************************/
714 
716  StandardSetting(_storage)
717 {
718 }
719 
720 void MythUICheckBoxSetting::setValue(const QString &value)
721 {
723  if (haveChanged())
724  emit valueChanged(value == "1");
725 }
726 
728 {
729  StandardSetting::setValue(value ? "1" : "0");
730  if (haveChanged())
731  emit valueChanged(value);
732 }
733 
735 {
737  item->DisplayState("checkbox", "widgettype");
738  item->setCheckable(true);
739  item->SetText("", "value");
740  if (m_settingValue == "1")
742  else
744 }
745 
747 {
748  if (!isEnabled())
749  return;
750 
751  if (isReadOnly())
752  return;
753 
754  auto *dce = new DialogCompletionEvent("editsetting", 0, "", "");
755  QCoreApplication::postEvent(screen, dce);
756 }
757 
759 {
760  setValue(!boolValue());
761 }
762 
763 /******************************************************************************
764  Standard setting dialog
765 *******************************************************************************/
766 
768 {
769  if (m_settingsTree)
770  m_settingsTree->deleteLater();
771 }
772 
774 {
775  if (!LoadWindowFromXML("standardsetting-ui.xml", "settingssetup", this))
776  return false;
777 
778  bool error = false;
779  UIUtilE::Assign(this, m_title, "title", &error);
780  UIUtilW::Assign(this, m_groupHelp, "grouphelp", &error);
781  UIUtilE::Assign(this, m_buttonList, "settingslist", &error);
782 
783  UIUtilW::Assign(this, m_selectedSettingHelp, "selectedsettinghelp");
784 
785  if (error)
786  {
787  LOG(VB_GENERAL, LOG_ERR, "Theme elements missing.");
788  return false;
789  }
790 
795 
796  BuildFocusList();
797 
799 
800  return true;
801 }
802 
804 {
805  if (!item)
806  return;
807 
808  auto *setting = item->GetData().value<StandardSetting*>();
809  if (setting && m_selectedSettingHelp)
810  {
811  disconnect(m_selectedSettingHelp);
812  m_selectedSettingHelp->SetText(setting->getHelpText());
814  }
815 }
816 
818 {
819  auto* setting = item->GetData().value<StandardSetting*>();
820  if (setting)
821  setting->edit(this);
822 }
823 
825 {
826  if (event->type() == DialogCompletionEvent::kEventType)
827  {
828  auto *dce = dynamic_cast<DialogCompletionEvent*>(event);
829  if (dce == nullptr)
830  return;
831  QString resultid = dce->GetId();
832 
833  if (resultid == "leveldown")
834  {
835  //a GroupSetting have been clicked
836  LevelDown();
837  }
838  else if (resultid == "editsetting")
839  {
841  if (item)
842  {
843  auto *ss = item->GetData().value<StandardSetting*>();
844  if (ss)
845  ss->resultEdit(dce);
846  }
847  }
848  else if (resultid == "exit")
849  {
850  int buttonnum = dce->GetResult();
851  if (buttonnum == 0)
852  {
853  Save();
855  if (m_settingsTree)
857  }
858  else if (buttonnum == 1)
860  }
861  }
862 }
863 
865 {
866  if (m_settingsTree)
867  {
868  m_settingsTree->Load();
869  m_settingsTree->MoveToThread(QApplication::instance()->thread());
870  }
871 }
872 
874 {
876 }
877 
879 {
880  return m_settingsTree;
881 }
882 
884  StandardSetting *groupSettings, StandardSetting *selectedSetting)
885 {
886  if (!groupSettings)
887  return;
888 
890  {
891  disconnect(m_currentGroupSetting,
892  &StandardSetting::settingsChanged, nullptr, nullptr);
894  }
895 
896  m_currentGroupSetting = groupSettings;
898 
900  if (m_groupHelp)
901  {
903  }
904  updateSettings(selectedSetting);
905  connect(m_currentGroupSetting,
908 }
909 
911 {
912  m_buttonList->Reset();
914  return;
915 
916  QList<StandardSetting *> *settings =
918  if (!settings)
919  return;
920 
921  QList<StandardSetting *>::const_iterator i;
922  MythUIButtonListItem *selectedItem = nullptr;
923  for (i = settings->constBegin(); i != settings->constEnd(); ++i)
924  {
925  if ((*i)->isVisible())
926  {
927  if (selectedSetting == (*i))
928  selectedItem = (*i)->createButton(m_buttonList);
929  else
930  (*i)->createButton(m_buttonList);
931  }
932  }
933  if (selectedItem)
934  m_buttonList->SetItemCurrent(selectedItem);
936 }
937 
939 {
940  if (m_settingsTree)
941  m_settingsTree->Save();
942 }
943 
945 {
947  return;
948 
950  {
953  }
954 }
955 
957 {
959  if (item)
960  {
961  auto *ss = item->GetData().value<StandardSetting*>();
962  if (ss && ss->haveSubSettings() && ss->isEnabled())
964  }
965 }
966 
968 {
970  {
971  QString label = tr("Exit ?");
972 
973  MythScreenStack *popupStack =
974  GetMythMainWindow()->GetStack("popup stack");
975 
976  auto * menuPopup = new MythDialogBox(label, popupStack, "exitmenu");
977 
978  if (menuPopup->Create())
979  {
980  popupStack->AddScreen(menuPopup);
981 
982  menuPopup->SetReturnEvent(this, "exit");
983 
984  menuPopup->AddButton(tr("Save then Exit"));
985  menuPopup->AddButton(tr("Exit without saving changes"));
986  menuPopup->AddButton(tr("Cancel"));
987  }
988  else
989  delete menuPopup;
990  }
991  else
993 }
994 
995 static QKeyEvent selectEvent
996  (QKeyEvent(QEvent::KeyPress,0,Qt::NoModifier,"SELECT"));
997 static QKeyEvent deleteEvent
998  (QKeyEvent(QEvent::KeyPress,0,Qt::NoModifier,"DELETE"));
999 
1001 {
1002  QStringList actions;
1003 
1004  bool handled = m_buttonList->keyPressEvent(e);
1005  if (handled)
1006  return true;
1007 
1008  handled = GetMythMainWindow()->TranslateKeyPress("Global", e, actions);
1009 
1010  //send the key to the selected Item first
1012  if (item)
1013  {
1014  auto *ss = item->GetData().value<StandardSetting*>();
1015  if (ss)
1016  handled = ss->keyPressEvent(e);
1017  }
1018  if (handled)
1019  return true;
1020 
1021  for (int i = 0; i < actions.size() && !handled; i++)
1022  {
1023  QString action = actions[i];
1024  handled = true;
1025 
1026  if (action == "LEFT")
1027  {
1028  if (m_currentGroupSetting &&
1030  Close();
1031  else
1032  LevelUp();
1033  }
1034  else if (action == "RIGHT")
1035  LevelDown();
1036  else if (action == "EDIT")
1037  {
1039  }
1040  else if (action == "DELETE")
1041  deleteEntry();
1042  else
1043  handled = MythScreenType::keyPressEvent(e);
1044  }
1045 
1046  return handled;
1047 }
1048 
1050 {
1052  if (!item)
1053  return;
1054 
1055  auto *source = item->GetData().value<GroupSetting*>();
1056  if (!source)
1057  return;
1058  // m_title->GetText() for screen title
1059  auto *menu = new MythMenu(source->getLabel(), this, "mainmenu");
1060  menu->AddItem(tr("Edit"), &StandardSettingDialog::editEntry);
1061  if (source->canDelete())
1062  menu->AddItem(tr("Delete"), &StandardSettingDialog::deleteSelected);
1063 
1064  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
1065 
1066  auto *menuPopup = new MythDialogBox(menu, popupStack, "menudialog");
1067  menuPopup->SetReturnEvent(this, "mainmenu");
1068 
1069  if (menuPopup->Create())
1070  popupStack->AddScreen(menuPopup);
1071  else
1072  delete menuPopup;
1073 }
1074 
1076 {
1078 }
1079 
1081 {
1083 }
1084 
1086 {
1088  if (!item)
1089  return;
1090 
1091  auto *source = item->GetData().value<GroupSetting*>();
1092  if (!source)
1093  return;
1094 
1095  if (source->canDelete())
1096  {
1097  QString message = tr("Do you want to delete the '%1' entry?")
1098  .arg(source->getLabel());
1100  }
1101 }
1102 
1104 {
1105  if (ok)
1106  {
1108  if (!item)
1109  return;
1110  auto *source = item->GetData().value<GroupSetting*>();
1111  if (!source)
1112  return;
1113  source->deleteEntry();
1114 // m_settingsTree->removeChild(source);
1115  source->getParent()->removeChild(source);
1116  m_buttonList->RemoveItem(item);
1117  }
1118 
1119 }
MythUISpinBoxSetting::MythUISpinBoxSetting
MythUISpinBoxSetting(Storage *_storage, int min, int max, int step, int pageMultiple=8, QString special_value_text=QString())
Definition: standardsettings.cpp:628
MythScreenType::LoadInBackground
void LoadInBackground(const QString &message="")
Definition: mythscreentype.cpp:285
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:802
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:124
MythUIComboBoxSetting::clearSelections
void clearSelections()
Definition: standardsettings.cpp:513
MythUITextEditSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:392
MythUIButtonList::GetItemCurrent
MythUIButtonListItem * GetItemCurrent() const
Definition: mythuibuttonlist.cpp:1590
StandardSetting::haveSubSettings
virtual bool haveSubSettings()
Definition: standardsettings.cpp:153
StandardSetting::setName
virtual void setName(const QString &name)
Definition: standardsettings.cpp:252
MythUICheckBoxSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:734
StandardSettingDialog::m_currentGroupSetting
StandardSetting * m_currentGroupSetting
Definition: standardsettings.h:515
mythuitext.h
StandardSetting::getLabel
QString getLabel(void) const
Definition: standardsettings.h:35
MythUIComboBoxSetting::fillSelectionsFromDir
void fillSelectionsFromDir(const QDir &dir, bool absPath=true)
Definition: standardsettings.cpp:608
FilterNone
@ FilterNone
Definition: mythuitextedit.h:19
StandardSetting::Close
virtual void Close(void)
Definition: standardsettings.h:77
StandardSetting::setValue
virtual void setValue(const QString &newValue)
Definition: standardsettings.cpp:169
DialogCompletionEvent::GetId
QString GetId()
Definition: mythdialogbox.h:52
error
static void error(const char *str,...)
Definition: vbi.cpp:42
StandardSetting::clearTargetedSettings
void clearTargetedSettings(const QString &value)
Definition: standardsettings.cpp:133
StandardSetting::Open
virtual void Open(void)
Definition: standardsettings.h:76
MythUIButtonListItem::DisplayState
void DisplayState(const QString &state, const QString &name)
Definition: mythuibuttonlist.cpp:3506
StandardSetting::helpTextChanged
void helpTextChanged(const QString &newValue)
MythScreenType::Close
virtual void Close()
Definition: mythscreentype.cpp:385
StandardSetting::removeTargetedChild
void removeTargetedChild(const QString &value, StandardSetting *child)
Definition: standardsettings.cpp:123
StandardSettingDialog::m_buttonList
MythUIButtonList * m_buttonList
Definition: standardsettings.h:497
MythUIComboBoxSetting::m_rewrite
bool m_rewrite
Definition: standardsettings.h:254
StandardSettingDialog::m_title
MythUIText * m_title
Definition: standardsettings.h:510
MythUIButtonList::RemoveItem
void RemoveItem(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1488
StandardSetting::m_readonly
bool m_readonly
Definition: standardsettings.h:113
DialogCompletionEvent::kEventType
static Type kEventType
Definition: mythdialogbox.h:57
MSqlQuery::lastInsertId
QVariant lastInsertId()
Return the id of the last inserted row.
Definition: mythdbcon.cpp:907
MythUIButtonList::itemSelected
void itemSelected(MythUIButtonListItem *item)
StandardSetting::m_label
QString m_label
Definition: standardsettings.h:114
StandardSetting::m_settingValue
QString m_settingValue
Definition: standardsettings.h:111
mythdialogbox.h
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:201
MythScreenStack
Definition: mythscreenstack.h:16
StandardSettingDialog::GetGroupSettings
GroupSetting * GetGroupSettings(void) const
Definition: standardsettings.cpp:878
MythUITextEditSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:422
MythUIButtonListItem::FullChecked
@ FullChecked
Definition: mythuibuttonlist.h:34
GroupSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:304
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:603
MythUISpinBoxSetting::m_pageMultiple
int m_pageMultiple
Definition: standardsettings.h:351
MythUIComboBoxSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:534
StandardSetting::clearSettings
virtual void clearSettings()
Definition: standardsettings.cpp:159
ButtonStandardSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:319
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
StandardSetting::addTargetedChild
void addTargetedChild(const QString &value, StandardSetting *setting)
Definition: standardsettings.cpp:116
MythScreenType
Screen in which all other widgets are contained and rendered.
Definition: mythscreentype.h:44
StandardSettingDialog::m_selectedSettingHelp
MythUIText * m_selectedSettingHelp
Definition: standardsettings.h:512
StandardSetting::m_name
QString m_name
Definition: standardsettings.h:116
StandardSettingDialog::~StandardSettingDialog
~StandardSettingDialog() override
Definition: standardsettings.cpp:767
MythUIButtonListItem::setVisible
void setVisible(bool flag)
Definition: mythuibuttonlist.h:100
MythUIComboBoxSetting::~MythUIComboBoxSetting
~MythUIComboBoxSetting() override
Definition: standardsettings.cpp:472
MythTextInputDialog::haveResult
void haveResult(QString)
ButtonStandardSetting::ButtonStandardSetting
ButtonStandardSetting(const QString &label)
Definition: standardsettings.cpp:314
menu
static MythThemedMenu * menu
Definition: mythtv/programs/mythtv-setup/main.cpp:53
StandardSetting::m_haveChanged
bool m_haveChanged
Definition: standardsettings.h:120
StandardSettingDialog::Close
void Close(void) override
Definition: standardsettings.cpp:967
MythUIComboBoxSetting::m_labels
QVector< QString > m_labels
Definition: standardsettings.h:250
StandardSetting::haveChanged
bool haveChanged()
Return true if the setting have changed or any of its children.
Definition: standardsettings.cpp:185
AutoIncrementSetting::m_column
QString m_column
Definition: standardsettings.h:138
StandardSettingDialog::updateSettings
void updateSettings(StandardSetting *selectedSetting=nullptr)
Definition: standardsettings.cpp:910
ButtonStandardSetting::clicked
void clicked()
MythUIButtonListItem::SetText
void SetText(const QString &text, const QString &name="", const QString &state="")
Definition: mythuibuttonlist.cpp:3271
StandardSettingDialog::LevelDown
void LevelDown()
Definition: standardsettings.cpp:956
StandardSetting::m_enabled
bool m_enabled
Definition: standardsettings.h:112
MythUIFileBrowserSetting::m_typeFilter
QDir::Filters m_typeFilter
Definition: standardsettings.h:201
StandardSettingDialog::editEntry
void editEntry(void)
Definition: standardsettings.cpp:1075
MythUIButtonListItem
Definition: mythuibuttonlist.h:27
StandardSetting::setChanged
void setChanged(bool changed)
Definition: standardsettings.cpp:208
StandardSetting::settingsChanged
void settingsChanged(StandardSetting *selectedSetting=nullptr)
StandardSetting::addChild
virtual void addChild(StandardSetting *child)
Definition: standardsettings.cpp:70
StandardSettingDialog::Create
bool Create(void) override
Definition: standardsettings.cpp:773
StandardSettingDialog::setCurrentGroupSetting
void setCurrentGroupSetting(StandardSetting *groupSettings, StandardSetting *selectedSetting=nullptr)
Definition: standardsettings.cpp:883
mythlogging.h
StandardSetting::getSubSettings
virtual QList< StandardSetting * > * getSubSettings()
Definition: standardsettings.cpp:145
StandardSetting::createButton
MythUIButtonListItem * createButton(MythUIButtonList *list)
Definition: standardsettings.cpp:37
MythUIComboBoxSetting::resultEdit
void resultEdit(DialogCompletionEvent *dce) override
Definition: standardsettings.cpp:581
MythUIButtonListItem::setCheckable
void setCheckable(bool flag)
Definition: mythuibuttonlist.cpp:3562
MythUIButtonList::itemClicked
void itemClicked(MythUIButtonListItem *item)
MythMainWindow::TranslateKeyPress
bool TranslateKeyPress(const QString &Context, QKeyEvent *Event, QStringList &Actions, bool AllowJumps=true)
Get a list of actions for a keypress in the given context.
Definition: mythmainwindow.cpp:1116
MythUISpinBoxSetting::m_specialValueText
QString m_specialValueText
Definition: standardsettings.h:352
MythUITextEditSetting::resultEdit
void resultEdit(DialogCompletionEvent *dce) override
Definition: standardsettings.cpp:415
StandardSetting::resultEdit
virtual void resultEdit(DialogCompletionEvent *dce)=0
AutoIncrementSetting::Save
void Save(void) override
Definition: standardsettings.cpp:324
MythUIButtonList::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythuibuttonlist.cpp:2490
MythDialogBox
Basic menu dialog, message and a list of options.
Definition: mythdialogbox.h:166
Storage::Load
virtual void Load(void)=0
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:535
MythUISpinBoxSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:662
GroupSetting::deleteEntry
virtual void deleteEntry(void)
Definition: standardsettings.h:449
StandardSetting::getParent
StandardSetting * getParent() const
Definition: standardsettings.h:49
MythDB::DBError
static void DBError(const QString &where, const MSqlQuery &query)
Definition: mythdb.cpp:200
MythUISpinBoxSetting::intValue
int intValue()
Definition: standardsettings.cpp:675
MythUITextEditSetting::SetPasswordEcho
void SetPasswordEcho(bool b)
Definition: standardsettings.cpp:387
MythUIFileBrowserSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:462
StandardSetting::Load
virtual void Load(void)
Definition: standardsettings.cpp:213
MythUICheckBoxSetting::valueChanged
void valueChanged(bool)
MythScreenType::BuildFocusList
void BuildFocusList(void)
Definition: mythscreentype.cpp:205
MythUICheckBoxSetting::resultEdit
void resultEdit(DialogCompletionEvent *dce) override
Definition: standardsettings.cpp:758
MythUIComboBoxSetting::getValueIndex
int getValueIndex(const QString &value) const
Definition: standardsettings.cpp:487
StandardSetting::Save
virtual void Save(void)
Definition: standardsettings.cpp:232
StandardSettingDialog::Save
void Save()
Definition: standardsettings.cpp:938
MythUIFileBrowserSetting::resultEdit
void resultEdit(DialogCompletionEvent *dce) override
Definition: standardsettings.cpp:456
StandardSetting::m_targets
QMap< QString, QList< StandardSetting * > > m_targets
Definition: standardsettings.h:124
GroupSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:292
mythuifilebrowser.h
StandardSetting::setReadOnly
virtual void setReadOnly(bool readonly)
Definition: standardsettings.cpp:53
StandardSetting::getValue
virtual QString getValue(void) const
Definition: standardsettings.h:52
MythUISpinBoxSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:680
MythUICheckBoxSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:746
MythUIButtonListItem::GetData
QVariant GetData()
Definition: mythuibuttonlist.cpp:3587
StandardSetting::keyPressEvent
virtual bool keyPressEvent(QKeyEvent *event)
Definition: standardsettings.cpp:85
MythUIComboBoxSetting::m_isSet
bool m_isSet
Definition: standardsettings.h:255
MythUISpinBoxSetting::m_min
int m_min
Definition: standardsettings.h:348
StandardSetting::ShouldRedraw
void ShouldRedraw(StandardSetting *setting)
MythUITextEditSetting::m_passwordEcho
bool m_passwordEcho
Definition: standardsettings.h:159
Storage::Save
virtual void Save(void)=0
MythUIFileBrowser
Definition: mythuifilebrowser.h:76
MythUIComboBoxSetting::updateButton
void updateButton(MythUIButtonListItem *item) override
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:520
UIUtilDisp::Assign
static bool Assign(ContainerType *container, UIType *&item, const QString &name, bool *err=nullptr)
Definition: mythuiutils.h:27
StandardSetting::setLabel
virtual void setLabel(QString str)
Definition: standardsettings.h:34
StandardSettingDialog::m_groupHelp
MythUIText * m_groupHelp
Definition: standardsettings.h:511
standardsettings.h
mythuispinbox.h
StandardSetting::valueChanged
void valueChanged(const QString &newValue)
deleteEvent
static QKeyEvent deleteEvent(QKeyEvent(QEvent::KeyPress, 0, Qt::NoModifier,"DELETE"))
AutoIncrementSetting::AutoIncrementSetting
AutoIncrementSetting(QString _table, QString _column)
Definition: standardsettings.cpp:377
StandardSetting::setEnabled
virtual void setEnabled(bool enabled)
Definition: standardsettings.cpp:47
MythMenu
Definition: mythdialogbox.h:99
MythUIComboBoxSetting::addSelection
void addSelection(const QString &label, QString value=QString(), bool select=false)
Definition: standardsettings.cpp:498
MythScreenType::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythscreentype.cpp:397
StandardSettingDialog::customEvent
void customEvent(QEvent *event) override
Definition: standardsettings.cpp:824
GroupSetting::applyChange
virtual void applyChange()
Definition: standardsettings.h:446
StandardSettingDialog::settingSelected
void settingSelected(MythUIButtonListItem *item)
Definition: standardsettings.cpp:803
StandardSettingDialog::Init
void Init(void) override
Used after calling Load() to assign data to widgets and other UI initilisation which is prohibited in...
Definition: standardsettings.cpp:873
XMLParseBase::LoadWindowFromXML
static bool LoadWindowFromXML(const QString &xmlfile, const QString &windowname, MythUIType *parent)
Definition: xmlparsebase.cpp:692
StandardSetting::MoveToThread
void MoveToThread(QThread *thread)
Definition: standardsettings.cpp:273
MythUISpinBoxSetting::resultEdit
void resultEdit(DialogCompletionEvent *dce) override
Definition: standardsettings.cpp:705
StandardSetting::edit
virtual void edit(MythScreenType *screen)=0
StandardSetting::byName
StandardSetting * byName(const QString &name)
Definition: standardsettings.cpp:259
StandardSetting::removeChild
virtual void removeChild(StandardSetting *child)
Definition: standardsettings.cpp:79
MythUIButtonListItem::setEnabled
void setEnabled(bool flag)
Definition: mythuibuttonlist.cpp:3577
std
Definition: mythchrono.h:23
StandardSetting::isEnabled
bool isEnabled() const
Definition: standardsettings.h:45
StandardSetting::getHelpText
QString getHelpText(void) const
Definition: standardsettings.h:38
DialogCompletionEvent
Event dispatched from MythUI modal dialogs to a listening class containing a result of some form.
Definition: mythdialogbox.h:41
StandardSettingDialog::Load
void Load(void) override
Load data which will ultimately be displayed on-screen or used to determine what appears on-screen (S...
Definition: standardsettings.cpp:864
MythUISpinBoxSetting::m_max
int m_max
Definition: standardsettings.h:349
MythUIText::SetText
virtual void SetText(const QString &text)
Definition: mythuitext.cpp:133
MythUIFileBrowserSetting::m_nameFilter
QStringList m_nameFilter
Definition: standardsettings.h:204
mythcontext.h
MythUIButtonList::Reset
void Reset() override
Reset the widget to it's original state, should not reset changes made by the theme.
Definition: mythuibuttonlist.cpp:114
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:104
StandardSettingDialog::m_settingsTree
GroupSetting * m_settingsTree
Definition: standardsettings.h:514
MythUIButtonList::SetItemCurrent
void SetItemCurrent(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1557
MythUIButtonListItemSetting
Definition: standardsettings.h:17
build_compdb.action
action
Definition: build_compdb.py:9
MythUICheckBoxSetting::MythUICheckBoxSetting
MythUICheckBoxSetting(Storage *_storage=nullptr)
Definition: standardsettings.cpp:715
StandardSetting::ChangeSaved
void ChangeSaved()
MythUIButtonListItem::setDrawArrow
void setDrawArrow(bool flag)
Definition: mythuibuttonlist.cpp:3567
StandardSetting::m_parent
StandardSetting * m_parent
Definition: standardsettings.h:122
MythUIButtonListItemSetting::ShouldUpdate
void ShouldUpdate(StandardSetting *setting)
Definition: standardsettings.cpp:16
StandardSetting::~StandardSetting
~StandardSetting() override
Definition: standardsettings.cpp:21
StandardSetting::m_visible
bool m_visible
Definition: standardsettings.h:117
mythuibutton.h
MythMainWindow::GetStack
MythScreenStack * GetStack(const QString &Stackname)
Definition: mythmainwindow.cpp:322
StandardSetting::setVisible
void setVisible(bool visible)
Definition: standardsettings.cpp:59
StandardSetting
Definition: standardsettings.h:29
StandardSettingDialog::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: standardsettings.cpp:1000
StandardSettingDialog::LevelUp
void LevelUp()
Definition: standardsettings.cpp:944
DialogCompletionEvent::GetResult
int GetResult() const
Definition: mythdialogbox.h:53
MythTextInputDialog
Dialog prompting the user to enter a text string.
Definition: mythdialogbox.h:313
StandardSettingDialog::settingClicked
void settingClicked(MythUIButtonListItem *item)
Definition: standardsettings.cpp:817
StandardSetting::setParent
void setParent(StandardSetting *parent)
Definition: standardsettings.cpp:65
StandardSettingDialog::deleteEntry
void deleteEntry(void)
Definition: standardsettings.cpp:1085
MythUIButtonList
List widget, displays list items in a variety of themeable arrangements and can trigger signals when ...
Definition: mythuibuttonlist.h:151
MythSpinBoxDialog
Dialog prompting the user to enter a number using a spin box.
Definition: mythdialogbox.h:354
StandardSetting::addTargetedChildren
void addTargetedChildren(const QString &value, std::initializer_list< StandardSetting * > settings)
Definition: standardsettings.cpp:106
StandardSetting::updateButton
virtual void updateButton(MythUIButtonListItem *item)
This method is called whenever the UI need to reflect a change Reimplement this If you widget need a ...
Definition: standardsettings.cpp:95
mythmainwindow.h
MythUIComboBoxSetting::getValueLabel
QString getValueLabel(void) const
Definition: standardsettings.cpp:492
MythUICheckBoxSetting::setValue
void setValue(const QString &newValue) override
Definition: standardsettings.cpp:720
StandardSettingDialog::deleteEntryConfirmed
void deleteEntryConfirmed(bool ok)
Definition: standardsettings.cpp:1103
Storage
Definition: mythstorage.h:23
StandardSetting::m_children
QList< StandardSetting * > m_children
Definition: standardsettings.h:123
MythUIButtonListItem::setChecked
void setChecked(CheckState state)
Definition: mythuibuttonlist.cpp:3551
MythScreenStack::AddScreen
virtual void AddScreen(MythScreenType *screen, bool allowFade=true)
Definition: mythscreenstack.cpp:50
MythUIFileBrowserSetting::edit
void edit(MythScreenType *screen) override
Definition: standardsettings.cpp:433
ShowOkPopup
MythConfirmationDialog * ShowOkPopup(const QString &message, bool showCancel)
Non-blocking version of MythPopupBox::showOkPopup()
Definition: mythdialogbox.cpp:558
selectEvent
static QKeyEvent selectEvent(QKeyEvent(QEvent::KeyPress, 0, Qt::NoModifier,"SELECT"))
StandardSetting::m_storage
Storage * m_storage
Definition: standardsettings.h:121
StandardSetting::isReadOnly
bool isReadOnly() const
Definition: standardsettings.h:46
MythUIComboBoxSetting::setValue
void setValue(int value) override
Definition: standardsettings.cpp:478
MythUIComboBoxSetting::m_values
QVector< QString > m_values
Definition: standardsettings.h:251
AutoIncrementSetting::m_table
QString m_table
Definition: standardsettings.h:137
StandardSettingDialog::deleteSelected
void deleteSelected(void)
Definition: standardsettings.cpp:1080
StandardSettingDialog::ShowMenu
void ShowMenu(void) override
Definition: standardsettings.cpp:1049
MythUIComboBoxSetting::size
virtual int size(void) const
Definition: standardsettings.cpp:620
GroupSetting
Definition: standardsettings.h:435
MythUISpinBoxSetting::m_step
int m_step
Definition: standardsettings.h:350
MythUIButtonListItem::NotChecked
@ NotChecked
Definition: mythuibuttonlist.h:32
DialogCompletionEvent::GetData
QVariant GetData()
Definition: mythdialogbox.h:55
DialogCompletionEvent::GetResultText
QString GetResultText()
Definition: mythdialogbox.h:54
MythUICheckBoxSetting::boolValue
bool boolValue()
Definition: standardsettings.h:403