MythTV  master
mythdialogbox.cpp
Go to the documentation of this file.
1 
2 #include "mythdialogbox.h"
3 
4 #include <QCoreApplication>
5 #include <QDate>
6 #include <QDateTime>
7 #include <QFileInfo>
8 #include <QString>
9 #include <QStringList>
10 #include <QTime>
11 #include <utility>
12 
13 #include "mythlogging.h"
14 #include "mythdate.h"
15 
16 #include "mythmainwindow.h"
17 #include "mythfontproperties.h"
18 #include "mythuiutils.h"
19 #include "mythuitext.h"
20 #include "mythuiimage.h"
21 #include "mythuibuttonlist.h"
22 #include "mythuibutton.h"
23 #include "mythuistatetype.h"
24 #include "mythuispinbox.h"
25 #include "mythgesture.h"
26 
28  (QEvent::Type) QEvent::registerEventType();
29 
30 // Force this class to have a vtable so that dynamic_cast works.
31 // NOLINTNEXTLINE(modernize-use-equals-default)
33 {
34 }
35 
36 MythMenu::MythMenu(QString text, QObject *retobject, QString resultid) :
37  m_text(std::move(text)), m_resultid(std::move(resultid)), m_retObject(retobject)
38 {
39  Init();
40 }
41 
42 MythMenu::MythMenu(QString title, QString text, QObject *retobject, QString resultid) :
43  m_title(std::move(title)), m_text(std::move(text)), m_resultid(std::move(resultid)),
44  m_retObject(retobject)
45 {
46  Init();
47 }
48 
50 {
51  while (!m_menuItems.isEmpty())
52  {
53  MythMenuItem *item = m_menuItems.takeFirst();
54 
55  delete item->m_subMenu;
56  delete item;
57  }
58 }
59 
60 void MythMenu::AddItem(const QString& title, const char* slot, MythMenu *subMenu, bool selected, bool checked)
61 {
62  auto *item = new MythMenuItem(title, slot, checked, subMenu);
63  AddItem(item, selected, subMenu);
64 }
65 
66 void MythMenu::AddItem(const QString &title, QVariant data, MythMenu *subMenu, bool selected, bool checked)
67 {
68  auto *item = new MythMenuItem(title, std::move(data), checked, subMenu);
69  AddItem(item, selected, subMenu);
70 }
71 
72 void MythMenu::AddItem(const QString &title, const MythUIButtonCallback &slot,
73  MythMenu *subMenu, bool selected, bool checked)
74 {
75  auto *item = new MythMenuItem(title, slot, checked, subMenu);
76  AddItem(item, selected, subMenu);
77 }
78 
79 void MythMenu::AddItem(MythMenuItem *item, bool selected, MythMenu *subMenu)
80 {
81  m_menuItems.append(item);
82 
83  if (selected)
84  m_selectedItem = m_menuItems.indexOf(item);
85 
86  if (subMenu)
87  subMenu->SetParent(this);
88 }
89 
90 void MythMenu::SetSelectedByTitle(const QString& title)
91 {
92  for (auto *item : qAsConst(m_menuItems))
93  {
94  if (!item)
95  continue;
96 
97  if (item->m_text == title)
98  {
99  m_selectedItem = m_menuItems.indexOf(item);
100  break;
101  }
102  }
103 }
104 
105 void MythMenu::SetSelectedByData(const QVariant& data)
106 {
107  for (auto *item : qAsConst(m_menuItems))
108  {
109  if (!item)
110  continue;
111 
112  if (item->m_data == data)
113  {
114  m_selectedItem = m_menuItems.indexOf(item);
115  break;
116  }
117  }
118 }
119 
121 
123 {
124  if (m_menu)
125  {
126  delete m_menu;
127  m_menu = nullptr;
128  }
129 }
130 
132 {
133  QString windowName = (m_fullscreen ? "MythDialogBox" : "MythPopupBox");
134 
135  if (m_osdDialog)
136  {
137  if (!XMLParseBase::LoadWindowFromXML("osd.xml", windowName, this))
138  return false;
139  }
140  else if (!CopyWindowFromBase(windowName, this))
141  return false;
142 
143  bool err = false;
144  UIUtilW::Assign(this, m_titlearea, "title");
145  UIUtilE::Assign(this, m_textarea, "messagearea", &err);
146  UIUtilE::Assign(this, m_buttonList, "list", &err);
147 
148  if (err)
149  {
150  LOG(VB_GENERAL, LOG_ERR, QString("Cannot load screen '%1'")
151  .arg(windowName));
152  return false;
153  }
154 
155  if (m_titlearea)
158 
159  BuildFocusList();
160 
161  if (m_menu)
162  updateMenu();
163 
165  this, &MythDialogBox::Select);
166 
167  return true;
168 }
169 
171 {
172  m_menu = menu;
174  updateMenu();
175 }
176 
178 {
179  if (!m_buttonList)
180  {
181  LOG(VB_GENERAL, LOG_ERR, "UpdateMenu() called before we have a button list to update!");
182  return;
183  }
184 
185  if (!m_currentMenu)
186  return;
187 
188  if (m_titlearea)
190 
192 
193  m_buttonList->Reset();
194 
195  for (int x = 0; x < m_currentMenu->m_menuItems.count(); x++)
196  {
197  MythMenuItem *menuItem = m_currentMenu->m_menuItems.at(x);
198  auto *button = new MythUIButtonListItem(m_buttonList, menuItem->m_text);
199  button->SetData(QVariant::fromValue(menuItem));
200  button->setDrawArrow((menuItem->m_subMenu != nullptr));
201 
202  if (m_currentMenu->m_selectedItem == x)
203  m_buttonList->SetItemCurrent(button);
204  }
205  // GetVisibleCount here makes sure that the dialog size is
206  // calculated correctly
209 }
210 
212 {
213  if (!item)
214  return;
215 
216  if (m_currentMenu)
217  {
218  auto *menuItem = item->GetData().value< MythMenuItem * >();
219  if (menuItem == nullptr)
220  return;
221  if (menuItem->m_subMenu)
222  {
224  m_currentMenu = menuItem->m_subMenu;
225  updateMenu();
226  return;
227  }
228 
229  if (menuItem->m_useSlot)
230  {
231  const char *slot = menuItem->m_data.value < const char * >();
232  if (slot)
233  {
234  connect(this, SIGNAL(Selected()), m_currentMenu->m_retObject, slot,
235  Qt::QueuedConnection);
236  emit Selected();
237  }
238  else if (menuItem->m_data.value<MythUIButtonCallback>())
239  {
241  menuItem->m_data.value<MythUIButtonCallback>(),
242  Qt::QueuedConnection);
243  emit Selected();
244  }
245  }
246 
247  SendEvent(m_buttonList->GetItemPos(item), item->GetText(), menuItem->m_data);
248  }
249  else
250  {
251  if (m_useSlots)
252  {
253  const char *slot = item->GetData().value<const char *>();
254  if (slot)
255  {
256  connect(this, SIGNAL(Selected()), m_retObject, slot,
257  Qt::QueuedConnection);
258  emit Selected();
259  }
260  else if (item->GetData().value<MythUIButtonCallback>())
261  {
262  connect(this, &MythDialogBox::Selected, m_retObject,
263  item->GetData().value<MythUIButtonCallback>(),
264  Qt::QueuedConnection);
265  emit Selected();
266  }
267  }
268 
269  SendEvent(m_buttonList->GetItemPos(item), item->GetText(), item->GetData());
270  }
271 
272  if (m_screenStack)
273  m_screenStack->PopScreen(nullptr, false);
274 }
275 
276 void MythDialogBox::SetReturnEvent(QObject *retobject,
277  const QString &resultid)
278 {
279  m_retObject = retobject;
280  m_id = resultid;
281 }
282 
283 void MythDialogBox::SetBackAction(const QString &text, QVariant data)
284 {
285  m_backtext = text;
286  m_backdata = std::move(data);
287 }
288 
289 void MythDialogBox::SetExitAction(const QString &text, QVariant data)
290 {
291  m_exittext = text;
292  m_exitdata = std::move(data);
293 }
294 
295 void MythDialogBox::SetText(const QString &text)
296 {
297  if (m_textarea)
298  m_textarea->SetText(text);
299 }
300 
301 void MythDialogBox::AddButton(const QString &title, QVariant data, bool newMenu,
302  bool setCurrent)
303 {
304  auto *button = new MythUIButtonListItem(m_buttonList, title);
305  button->SetData(std::move(data));
306  button->setDrawArrow(newMenu);
307 
308  if (setCurrent)
309  m_buttonList->SetItemCurrent(button);
310  // GetVisibleCount here makes sure that the dialog size is
311  // calculated correctly
313 }
314 
315 void MythDialogBox::AddButton(const QString &title, const char *slot,
316  bool newMenu, bool setCurrent)
317 {
318  auto *button = new MythUIButtonListItem(m_buttonList, title);
319 
320  m_useSlots = true;
321 
322  if (slot)
323  button->SetData(QVariant::fromValue(slot));
324  button->setDrawArrow(newMenu);
325 
326  if (setCurrent)
327  m_buttonList->SetItemCurrent(button);
328  // GetVisibleCount here makes sure that the dialog size is
329  // calculated correctly
331 }
332 
333 bool MythDialogBox::keyPressEvent(QKeyEvent *event)
334 {
335  if (GetFocusWidget()->keyPressEvent(event))
336  return true;
337 
338  bool handled = false;
339  QStringList actions;
340  handled = GetMythMainWindow()->TranslateKeyPress("qt", event, actions);
341 
342  for (int i = 0; i < actions.size() && !handled; i++)
343  {
344  QString action = actions[i];
345  handled = true;
346 
347  if (action == "ESCAPE")
348  {
350  if (m_exitdata == 0 && m_exittext.isEmpty())
351  Close();
352  }
353  else if ((action == "LEFT" &&
355  (action == "UP" &&
357  {
359  {
361  updateMenu();
362  return true;
363  }
364 
366  Close();
367  }
368  else if (action == "MENU")
369  {
370  SendEvent(-2);
371  Close();
372  }
373  else if ((action == "RIGHT" &&
375  (action == "DOWN" &&
377  {
379  }
380  else
381  handled = false;
382  }
383 
384  if (!handled && MythScreenType::keyPressEvent(event))
385  handled = true;
386 
387  return handled;
388 }
389 
391 {
392  bool handled = false;
393  if (event->GetGesture() == MythGestureEvent::Click)
394  {
395  switch (event->GetButton())
396  {
397  case Qt::RightButton:
398  SendEvent(-2);
399  Close();
400  handled = true;
401  break;
402  default :
403  break;
404  }
405 
406  }
407 
408  if (!handled && MythScreenType::gestureEvent(event))
409  handled = true;
410 
411  return handled;
412 }
413 
414 void MythDialogBox::SendEvent(int res, const QString& text, const QVariant& data)
415 {
416  if (m_currentMenu)
417  {
418  emit Closed(m_currentMenu->m_resultid, res);
419 
421  return;
422 
423  auto *dce = new DialogCompletionEvent(m_currentMenu->m_resultid, res, text, data);
424  QCoreApplication::postEvent(m_currentMenu->m_retObject, dce);
425  }
426  else
427  {
428  emit Closed(m_id, res);
429 
430  if (!m_retObject)
431  return;
432 
433  auto *dce = new DialogCompletionEvent(m_id, res, text, data);
434  QCoreApplication::postEvent(m_retObject, dce);
435  }
436 }
437 
439 
441 {
442  if (!CopyWindowFromBase("MythConfirmationDialog", this))
443  return false;
444 
445  MythUIButton *okButton = nullptr;
446  MythUIButton *cancelButton = nullptr;
447 
448  bool err = false;
449  UIUtilE::Assign(this, m_messageText, "message", &err);
450  UIUtilE::Assign(this, okButton, "ok", &err);
451  UIUtilE::Assign(this, cancelButton, "cancel", &err);
452 
453  if (err)
454  {
455  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythConfirmationDialog'");
456  return false;
457  }
458 
459  if (m_showCancel)
460  {
461  connect(cancelButton, &MythUIButton::Clicked, this, &MythConfirmationDialog::Cancel);
462  }
463  else
464  cancelButton->SetVisible(false);
465 
466  connect(okButton, &MythUIButton::Clicked, this, &MythConfirmationDialog::Confirm);
467 
469 
470  BuildFocusList();
471 
472  if (m_showCancel)
473  SetFocusWidget(cancelButton);
474  else
475  SetFocusWidget(okButton);
476 
477  return true;
478 }
479 
481 {
482  if (GetFocusWidget()->keyPressEvent(event))
483  return true;
484 
485  bool handled = false;
486  QStringList actions;
487  handled = GetMythMainWindow()->TranslateKeyPress("qt", event, actions);
488 
489  for (int i = 0; i < actions.size() && !handled; i++)
490  {
491  QString action = actions[i];
492  handled = true;
493 
494  if (action == "ESCAPE")
495  sendResult(false);
496  else
497  handled = false;
498  }
499 
500  if (!handled && MythScreenType::keyPressEvent(event))
501  handled = true;
502 
503  return handled;
504 }
505 
506 void MythConfirmationDialog::SetMessage(const QString &message)
507 {
508  m_message = message;
509  if (m_messageText)
511 }
512 
514  const QString &resultid)
515 {
516  m_retObject = retobject;
517  m_id = resultid;
518 }
519 
521 {
522  sendResult(true);
523 }
524 
526 {
527  sendResult(false);
528 }
529 
531 {
532  emit haveResult(ok);
533 
534  if (m_retObject)
535  {
536  int res = 0;
537  if (ok)
538  res = 1;
539 
540  auto *dce = new DialogCompletionEvent(m_id, res, "", m_resultData);
541  QCoreApplication::postEvent(m_retObject, dce);
542  m_retObject = nullptr;
543  }
544 
545  Close();
546 }
547 
551 MythConfirmationDialog *ShowOkPopup(const QString &message, QObject *parent,
552  const char *slot, bool showCancel)
553 {
554  QString LOC = "ShowOkPopup('" + message + "') - ";
555  MythScreenStack *stk = nullptr;
556 
558 
559  if (win)
560  stk = win->GetStack("popup stack");
561  else
562  {
563  LOG(VB_GENERAL, LOG_ERR, LOC + "no main window?");
564  return nullptr;
565  }
566 
567  if (!stk)
568  {
569  LOG(VB_GENERAL, LOG_ERR, LOC + "no popup stack? "
570  "Is there a MythThemeBase?");
571  return nullptr;
572  }
573 
574  auto *pop = new MythConfirmationDialog(stk, message, showCancel);
575  if (pop->Create())
576  {
577  stk->AddScreen(pop);
578  if (parent && slot)
579  QObject::connect(pop, SIGNAL(haveResult(bool)), parent, slot,
580  Qt::QueuedConnection);
581  }
582  else
583  {
584  delete pop;
585  pop = nullptr;
586  LOG(VB_GENERAL, LOG_ERR, LOC + "Couldn't Create() Dialog");
587  }
588 
589  return pop;
590 }
591 
593 {
594  if (!dialog)
595  return true; // No dialog is treated as user pressing OK
596 
597  // Local event loop processes events whilst we wait
598  QEventLoop block;
599 
600  // Quit when dialog exits
601  QObject::connect(dialog, &MythConfirmationDialog::haveResult,
602  &block, [&block](bool result)
603  { block.exit(result ? 1 : 0); });
604 
605  // Block and return dialog result
606  return block.exec() != 0;
607 }
608 
610 
612 {
613  if (!CopyWindowFromBase("MythTextInputDialog", this))
614  return false;
615 
616  MythUIText *messageText = nullptr;
617  MythUIButton *okButton = nullptr;
618  MythUIButton *cancelButton = nullptr;
619 
620  bool err = false;
621  UIUtilE::Assign(this, m_textEdit, "input", &err);
622  UIUtilE::Assign(this, messageText, "message", &err);
623  UIUtilE::Assign(this, okButton, "ok", &err);
624  UIUtilW::Assign(this, cancelButton, "cancel");
625 
626  if (err)
627  {
628  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythTextInputDialog'");
629  return false;
630  }
631 
632  if (cancelButton)
633  connect(cancelButton, &MythUIButton::Clicked, this, &MythScreenType::Close);
634  connect(okButton, &MythUIButton::Clicked, this, &MythTextInputDialog::sendResult);
635 
639 
640  messageText->SetText(m_message);
641 
642  BuildFocusList();
643 
644  return true;
645 }
646 
647 void MythTextInputDialog::SetReturnEvent(QObject *retobject,
648  const QString &resultid)
649 {
650  m_retObject = retobject;
651  m_id = resultid;
652 }
653 
655 {
656  QString inputString = m_textEdit->GetText();
657  emit haveResult(inputString);
658 
659  if (m_retObject)
660  {
661  auto *dce = new DialogCompletionEvent(m_id, 0, inputString, "");
662  QCoreApplication::postEvent(m_retObject, dce);
663  }
664 
665  Close();
666 }
667 
669 
671  QString message)
672  : MythScreenType(parent, "mythspinboxpopup"),
673  m_spinBox(nullptr),
674  m_message(std::move(message)),
675  m_retObject(nullptr),
676  m_id("")
677 {
678 }
679 
681 {
682  if (!CopyWindowFromBase("MythSpinBoxDialog", this))
683  return false;
684 
685  MythUIText *messageText = nullptr;
686  MythUIButton *okButton = nullptr;
687  MythUIButton *cancelButton = nullptr;
688 
689  bool err = false;
690  UIUtilE::Assign(this, m_spinBox, "input", &err);
691  UIUtilE::Assign(this, messageText, "message", &err);
692  UIUtilE::Assign(this, okButton, "ok", &err);
693  UIUtilW::Assign(this, cancelButton, "cancel");
694 
695  if (err)
696  {
697  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythSpinBoxDialog'");
698  return false;
699  }
700 
701  if (cancelButton)
702  connect(cancelButton, &MythUIButton::Clicked, this, &MythScreenType::Close);
703  connect(okButton, &MythUIButton::Clicked, this, &MythSpinBoxDialog::sendResult);
704 
705  messageText->SetText(m_message);
706  BuildFocusList();
707 
708  return true;
709 }
710 
715 void MythSpinBoxDialog::SetRange(int low, int high, int step, uint pageMultiple)
716 {
717  m_spinBox->SetRange(low, high, step, pageMultiple);
718 }
719 
723 void MythSpinBoxDialog::AddSelection(const QString& label, int value)
724 {
725  m_spinBox->AddSelection(value, label);
726 }
727 
732 void MythSpinBoxDialog::SetValue (const QString & value)
733 {
734  m_spinBox->SetValue(value);
735 }
736 
741 {
742  m_spinBox->SetValue(value);
743 }
744 
745 void MythSpinBoxDialog::SetReturnEvent(QObject *retobject,
746  const QString &resultid)
747 {
748  m_retObject = retobject;
749  m_id = resultid;
750 }
751 
753 {
754  QString inputString = m_spinBox->GetValue();
755  emit haveResult(inputString);
756 
757  if (m_retObject)
758  {
759  auto *dce = new DialogCompletionEvent(m_id, 0, inputString, "");
760  QCoreApplication::postEvent(m_retObject, dce);
761  }
762 
763  Close();
764 }
765 
767 
768 
784  const QString &title,
785  const QStringList &list,
786  bool matchAnywhere,
787  const QString &defaultValue)
788  : MythScreenType(parent, "mythsearchdialogpopup")
789 {
790  m_list = list;
791  m_matchAnywhere = matchAnywhere;
792  m_title = title;
793  m_defaultValue = defaultValue;
794 
795  m_titleText = nullptr;
796  m_matchesText = nullptr;
797  m_textEdit = nullptr;
798  m_itemList = nullptr;
799 
800  m_id = "";
801  m_retObject = nullptr;
802 }
803 
805 {
806  if (!CopyWindowFromBase("MythSearchDialog", this))
807  return false;
808 
809  MythUIButton *okButton = nullptr;
810  MythUIButton *cancelButton = nullptr;
811 
812  bool err = false;
813  UIUtilE::Assign(this, m_textEdit, "input", &err);
814  UIUtilE::Assign(this, m_titleText, "title", &err);
815  UIUtilW::Assign(this, m_matchesText, "matches");
816  UIUtilE::Assign(this, m_itemList, "itemlist", &err);
817  UIUtilE::Assign(this, okButton, "ok", &err);
818  UIUtilW::Assign(this, cancelButton, "cancel");
819 
820  if (err)
821  {
822  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythSearchDialog'");
823  return false;
824  }
825 
826  if (cancelButton)
827  connect(cancelButton, &MythUIButton::Clicked, this, &MythScreenType::Close);
828 
829  connect(okButton, &MythUIButton::Clicked, this, &MythUISearchDialog::slotSendResult);
830 
833 
836 
838  if (m_matchesText)
839  m_matchesText->SetText(tr("%n match(es)", "", 0));
840 
841  BuildFocusList();
842 
843  slotUpdateList();
844 
845  return true;
846 }
847 
848 void MythUISearchDialog::SetReturnEvent(QObject *retobject,
849  const QString &resultid)
850 {
851  m_retObject = retobject;
852  m_id = resultid;
853 }
854 
856 {
857  if (!m_itemList->GetItemCurrent())
858  return;
859 
860  QString result = m_itemList->GetValue();
861 
862  emit haveResult(result);
863 
864  if (m_retObject)
865  {
866  auto *dce = new DialogCompletionEvent(m_id, 0, result, "");
867  QCoreApplication::postEvent(m_retObject, dce);
868  }
869 
870  Close();
871 }
872 
874 {
875  m_itemList->Reset();
876 
877  for (int x = 0; x < m_list.size(); x++)
878  {
879  QString item = m_list.at(x);
880 
881  if (m_matchAnywhere)
882  {
883  if (!item.contains(m_textEdit->GetText(), Qt::CaseInsensitive))
884  continue;
885  }
886  else
887  {
888  if (!item.startsWith(m_textEdit->GetText(), Qt::CaseInsensitive))
889  continue;
890  }
891 
892  // add item to list
893  new MythUIButtonListItem(m_itemList, item, nullptr, false);
894  }
895 
897 
898  if (m_matchesText)
899  m_matchesText->SetText(tr("%n match(es)", "", 0));
900 }
901 
903 
905  QString message,
906  int resolutionFlags,
907  QDateTime startTime,
908  int rangeLimit)
909  : MythScreenType(parent, "timepopup"),
910  m_message(std::move(message)), m_startTime(std::move(startTime)),
911  m_resolution(resolutionFlags), m_rangeLimit(rangeLimit),
912  m_dateList(nullptr), m_timeList(nullptr), m_retObject(nullptr)
913 {
914 }
915 
917 {
918  if (!CopyWindowFromBase("MythTimeInputDialog", this))
919  return false;
920 
921  MythUIText *messageText = nullptr;
922  MythUIButton *okButton = nullptr;
923 
924  bool err = false;
925  UIUtilE::Assign(this, messageText, "message", &err);
926  UIUtilE::Assign(this, m_dateList, "dates", &err);
927  UIUtilE::Assign(this, m_timeList, "times", &err);
928  UIUtilE::Assign(this, okButton, "ok", &err);
929 
930  if (err)
931  {
932  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythTimeInputDialog'");
933  return false;
934  }
935 
936  m_dateList->SetVisible(false);
937  m_timeList->SetVisible(false);
938 
939  // Date
940  if (kNoDate != (m_resolution & 0xF))
941  {
942  const QDate startdate(m_startTime.toLocalTime().date());
943  QDate date(startdate);
944 
945  int limit = 0;
947  {
948  limit += m_rangeLimit;
949  }
950  if (m_resolution & kPastDates)
951  {
952  limit += m_rangeLimit;
953  date = date.addDays(0-m_rangeLimit);
954  }
955 
956  QString text;
957  bool selected = false;
958  for (int x = 0; x <= limit; x++)
959  {
960  selected = false;
961  if (m_resolution & kDay)
962  {
963  date = date.addDays(1);
965  if (m_rangeLimit >= 356)
966  flags |= MythDate::kAddYear;
967  text = MythDate::toString(date, flags);
968 
969  if (date == startdate)
970  selected = true;
971  }
972  else if (m_resolution & kMonth)
973  {
974  date = date.addMonths(1);
975  text = date.toString("MMM yyyy");
976 
977  if ((date.month() == startdate.month()) &&
978  (date.year() == startdate.year()))
979  selected = true;
980  }
981  else if (m_resolution & kYear)
982  {
983  date = date.addYears(1);
984  text = date.toString("yyyy");
985  if (date.year() == startdate.year())
986  selected = true;
987  }
988 
989  auto *item = new MythUIButtonListItem(m_dateList, text, nullptr, false);
990  item->SetData(QVariant(date));
991 
992  if (selected)
993  m_dateList->SetItemCurrent(item);
994  }
995  m_dateList->SetVisible(true);
996  }
997 
998  // Time
999  if (kNoTime != (m_resolution & 0xF0))
1000  {
1001  QDate startdate(m_startTime.toLocalTime().date());
1002  QTime starttime(m_startTime.toLocalTime().time());
1003  QTime time(0,0,0);
1004  QString text;
1005  bool selected = false;
1006 
1007  int limit = (m_resolution & kMinutes) ? (60 * 24) : 24;
1008 
1009  for (int x = 0; x < limit; x++)
1010  {
1011  selected = false;
1012  if (m_resolution & kMinutes)
1013  {
1014  time = time.addSecs(60);
1015  QDateTime dt = QDateTime(startdate, time, Qt::LocalTime);
1016  text = MythDate::toString(dt, MythDate::kTime);
1017 
1018  if (time == starttime)
1019  selected = true;
1020  }
1021  else if (m_resolution & kHours)
1022  {
1023  time = time.addSecs(60*60);
1024  text = time.toString("hh:00");
1025 
1026  if (time.hour() == starttime.hour())
1027  selected = true;
1028  }
1029 
1030  auto *item = new MythUIButtonListItem(m_timeList, text, nullptr, false);
1031  item->SetData(QVariant(time));
1032 
1033  if (selected)
1034  m_timeList->SetItemCurrent(item);
1035  }
1036  m_timeList->SetVisible(true);
1037  }
1038 
1039  if (messageText && !m_message.isEmpty())
1040  messageText->SetText(m_message);
1041 
1042  connect(okButton, &MythUIButton::Clicked, this, &MythTimeInputDialog::okClicked);
1043 
1044  BuildFocusList();
1045 
1046  return true;
1047 }
1048 
1049 void MythTimeInputDialog::SetReturnEvent(QObject* retobject,
1050  const QString& resultid)
1051 {
1052  m_retObject = retobject;
1053  m_id = resultid;
1054 }
1055 
1057 {
1058  QDate date = m_dateList->GetDataValue().toDate();
1059  QTime time = m_timeList->GetDataValue().toTime();
1060 
1061  QDateTime dateTime = QDateTime(date, time, Qt::LocalTime).toUTC();
1062 
1063  emit haveResult(dateTime);
1064 
1065  if (m_retObject)
1066  {
1067  QVariant data(dateTime);
1068  auto *dce = new DialogCompletionEvent(m_id, 0, "", data);
1069  QCoreApplication::postEvent(m_retObject, dce);
1070  }
1071 
1072  Close();
1073 }
MythUIButton::Clicked
void Clicked()
MythMenu::m_menuItems
QList< MythMenuItem * > m_menuItems
Definition: mythdialogbox.h:125
MythDialogBox::m_backdata
QVariant m_backdata
Definition: mythdialogbox.h:204
MythDialogBox::m_id
QString m_id
Definition: mythdialogbox.h:195
WaitFor
bool WaitFor(MythConfirmationDialog *dialog)
Blocks until confirmation dialog exits.
Definition: mythdialogbox.cpp:592
MythMainWindow::GetMainStack
MythScreenStack * GetMainStack()
Definition: mythmainwindow.cpp:321
MythDialogBox::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:276
MythDate::toString
QString toString(const QDateTime &raw_dt, uint format)
Returns formatted string representing the time.
Definition: mythdate.cpp:80
MythUIButtonList::GetItemCurrent
MythUIButtonListItem * GetItemCurrent() const
Definition: mythuibuttonlist.cpp:1590
MythUISearchDialog::m_title
QString m_title
Definition: mythdialogbox.h:371
MythTimeInputDialog::kHours
@ kHours
Definition: mythdialogbox.h:407
mythuitext.h
MythMenu::Init
void Init(void)
Definition: mythdialogbox.h:117
MythUIButtonList::GetLayout
LayoutType GetLayout() const
Definition: mythuibuttonlist.h:184
MythSpinBoxDialog::sendResult
void sendResult()
Definition: mythdialogbox.cpp:752
MythUISpinBox::GetValue
QString GetValue(void) const override
Definition: mythuispinbox.h:31
MythDialogBox::m_currentMenu
MythMenu * m_currentMenu
Definition: mythdialogbox.h:209
MythConfirmationDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:440
ShowOkPopup
MythConfirmationDialog * ShowOkPopup(const QString &message, QObject *parent, const char *slot, bool showCancel)
Non-blocking version of MythPopupBox::showOkPopup()
Definition: mythdialogbox.cpp:551
MythUISearchDialog::m_titleText
MythUIText * m_titleText
Definition: mythdialogbox.h:368
MythSpinBoxDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:680
MythGestureEvent::GetGesture
Gesture GetGesture() const
Definition: mythgesture.h:85
MythGestureEvent::GetButton
Qt::MouseButton GetButton() const
Definition: mythgesture.h:88
MythTimeInputDialog::m_id
QString m_id
Definition: mythdialogbox.h:442
MythConfirmationDialog::m_resultData
QVariant m_resultData
Definition: mythdialogbox.h:248
MythSpinBoxDialog::m_spinBox
MythUISpinBox * m_spinBox
Definition: mythdialogbox.h:323
MythTimeInputDialog::kDay
@ kDay
Definition: mythdialogbox.h:403
MythTextInputDialog::m_isPassword
bool m_isPassword
Definition: mythdialogbox.h:287
MythScreenType::Close
virtual void Close()
Definition: mythscreentype.cpp:402
MythDialogBox::m_titlearea
MythUIText * m_titlearea
Definition: mythdialogbox.h:191
MythDialogBox::SendEvent
void SendEvent(int res, const QString &text="", const QVariant &data=0)
Definition: mythdialogbox.cpp:414
MythUISearchDialog::slotSendResult
void slotSendResult(void)
Definition: mythdialogbox.cpp:855
MythDialogBox::m_textarea
MythUIText * m_textarea
Definition: mythdialogbox.h:192
MythSpinBoxDialog::m_id
QString m_id
Definition: mythdialogbox.h:327
title
QString title
Definition: mythplugins/mytharchive/mytharchivehelper/main.cpp:636
MythSpinBoxDialog::MythSpinBoxDialog
MythSpinBoxDialog(MythScreenStack *parent, QString message)
Definition: mythdialogbox.cpp:670
MythMenu::SetSelectedByData
void SetSelectedByData(const QVariant &data)
Definition: mythdialogbox.cpp:105
MythMainWindow::TranslateKeyPress
bool TranslateKeyPress(const QString &context, QKeyEvent *e, QStringList &actions, bool allowJumps=true)
Get a list of actions for a keypress in the given context.
Definition: mythmainwindow.cpp:1139
MythTimeInputDialog::kYear
@ kYear
Definition: mythdialogbox.h:401
MythConfirmationDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:513
MythDialogBox::m_fullscreen
bool m_fullscreen
Definition: mythdialogbox.h:198
MythTimeInputDialog::kPastDates
@ kPastDates
Definition: mythdialogbox.h:412
MythDialogBox::SetBackAction
void SetBackAction(const QString &text, QVariant data)
Definition: mythdialogbox.cpp:283
MythTextInputDialog::m_id
QString m_id
Definition: mythdialogbox.h:289
MythUISearchDialog::haveResult
void haveResult(QString)
DialogCompletionEvent::kEventType
static Type kEventType
Definition: mythdialogbox.h:57
MythUISearchDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:848
LOC
#define LOC
Definition: audioconvert.cpp:38
MythConfirmationDialog::haveResult
void haveResult(bool)
mythdialogbox.h
MythScreenStack
Definition: mythscreenstack.h:16
arg
arg(title).arg(filename).arg(doDelete))
MythDialogBox::m_useSlots
bool m_useSlots
Definition: mythdialogbox.h:196
MythTimeInputDialog::kMonth
@ kMonth
Definition: mythdialogbox.h:402
MythDialogBox::m_exitdata
QVariant m_exitdata
Definition: mythdialogbox.h:206
MythMenu::m_selectedItem
int m_selectedItem
Definition: mythdialogbox.h:126
MythUISearchDialog::m_matchAnywhere
bool m_matchAnywhere
Definition: mythdialogbox.h:374
MythTextInputDialog::m_message
QString m_message
Definition: mythdialogbox.h:284
MythTextInputDialog::m_defaultValue
QString m_defaultValue
Definition: mythdialogbox.h:285
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
MythDialogBox::Closed
void Closed(QString, int)
MythScreenType
Screen in which all other widgets are contained and rendered.
Definition: mythscreentype.h:45
mythuistatetype.h
MythUITextEdit::GetText
QString GetText(void) const
Definition: mythuitextedit.h:47
MythSpinBoxDialog::AddSelection
void AddSelection(const QString &label, int value)
Definition: mythdialogbox.cpp:723
MythConfirmationDialog::sendResult
void sendResult(bool ok)
Definition: mythdialogbox.cpp:530
MythTextInputDialog::haveResult
void haveResult(QString)
MythConfirmationDialog::m_showCancel
bool m_showCancel
Definition: mythdialogbox.h:245
MythConfirmationDialog::Confirm
void Confirm(void)
Definition: mythdialogbox.cpp:520
MythDialogBox::Select
void Select(MythUIButtonListItem *item)
Definition: mythdialogbox.cpp:211
menu
static MythThemedMenu * menu
Definition: mythtv/programs/mythtv-setup/main.cpp:53
MythUISpinBox::SetRange
void SetRange(int low, int high, int step, uint pageMultiple=5)
Set the lower and upper bounds of the spinbox, the interval and page amount.
Definition: mythuispinbox.cpp:25
MythConfirmationDialog::m_message
QString m_message
Definition: mythdialogbox.h:244
MythMainWindow::GetStack
MythScreenStack * GetStack(const QString &stackname)
Definition: mythmainwindow.cpp:326
mythuibuttonlist.h
MythUISearchDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:804
MythTextInputDialog::m_textEdit
MythUITextEdit * m_textEdit
Definition: mythdialogbox.h:283
MythSpinBoxDialog::m_message
QString m_message
Definition: mythdialogbox.h:324
mythuiimage.h
MythConfirmationDialog::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythdialogbox.cpp:480
MythTimeInputDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:1049
MythMenuItem::m_subMenu
MythMenu * m_subMenu
Definition: mythdialogbox.h:85
MythMenu::SetSelectedByTitle
void SetSelectedByTitle(const QString &title)
Definition: mythdialogbox.cpp:90
MythScreenType::GetFocusWidget
MythUIType * GetFocusWidget(void) const
Definition: mythscreentype.cpp:112
MythTextInputDialog::m_filter
InputFilter m_filter
Definition: mythdialogbox.h:286
MythMenu::AddItem
void AddItem(const QString &title, QVariant data=0, MythMenu *subMenu=nullptr, bool selected=false, bool checked=false)
Definition: mythdialogbox.cpp:66
MythUIButtonList::GetItemPos
int GetItemPos(MythUIButtonListItem *item) const
Definition: mythuibuttonlist.cpp:1698
MythSpinBoxDialog::haveResult
void haveResult(QString)
mythuiutils.h
MythUIButtonListItem
Definition: mythuibuttonlist.h:28
MythUISpinBox::SetValue
void SetValue(int val) override
Definition: mythuispinbox.h:26
MythUITextEdit::SetText
void SetText(const QString &text, bool moveCursor=true)
Definition: mythuitextedit.cpp:216
mythdate.h
MythMenuItem::m_text
QString m_text
Definition: mythdialogbox.h:82
MythDialogBox::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythdialogbox.cpp:333
MythDialogBox::m_osdDialog
bool m_osdDialog
Definition: mythdialogbox.h:199
mythfontproperties.h
MythTimeInputDialog::kNoDate
@ kNoDate
Definition: mythdialogbox.h:400
mythlogging.h
MythTimeInputDialog::MythTimeInputDialog
MythTimeInputDialog(MythScreenStack *parent, QString message, int resolutionFlags, QDateTime startTime=QDateTime::currentDateTime(), int rangeLimit=14)
Definition: mythdialogbox.cpp:904
MythTimeInputDialog::kNoTime
@ kNoTime
Definition: mythdialogbox.h:406
MythDialogBox::m_text
QString m_text
Definition: mythdialogbox.h:201
MythDialogBox::SetMenuItems
void SetMenuItems(MythMenu *menu)
Definition: mythdialogbox.cpp:170
MythUIButtonList::itemClicked
void itemClicked(MythUIButtonListItem *item)
MythUIButtonList::GetCurrentPos
int GetCurrentPos() const
Definition: mythuibuttonlist.h:190
MythDialogBox::m_buttonList
MythUIButtonList * m_buttonList
Definition: mythdialogbox.h:193
MythScreenType::SetFocusWidget
bool SetFocusWidget(MythUIType *widget=nullptr)
Definition: mythscreentype.cpp:117
MythDialogBox::SetExitAction
void SetExitAction(const QString &text, QVariant data)
Definition: mythdialogbox.cpp:289
MythTimeInputDialog::m_rangeLimit
int m_rangeLimit
Definition: mythdialogbox.h:434
MythTimeInputDialog::m_timeList
MythUIButtonList * m_timeList
Definition: mythdialogbox.h:439
MythUISearchDialog::MythUISearchDialog
MythUISearchDialog(MythScreenStack *parent, const QString &title, const QStringList &list, bool matchAnywhere=false, const QString &defaultValue="")
the classes constructor
Definition: mythdialogbox.cpp:783
MythDialogBox::Create
bool Create(void) override
Definition: mythdialogbox.cpp:131
MythDialogBox::AddButton
void AddButton(const QString &title, QVariant data=0, bool newMenu=false, bool setCurrent=false)
Definition: mythdialogbox.cpp:301
MythDialogBox::SetText
void SetText(const QString &text)
Definition: mythdialogbox.cpp:295
MythScreenType::BuildFocusList
void BuildFocusList(void)
Definition: mythscreentype.cpp:222
MythTimeInputDialog::okClicked
void okClicked(void)
Definition: mythdialogbox.cpp:1056
XMLParseBase::CopyWindowFromBase
static bool CopyWindowFromBase(const QString &windowname, MythScreenType *win)
Definition: xmlparsebase.cpp:916
MythMenu::m_parentMenu
MythMenu * m_parentMenu
Definition: mythdialogbox.h:120
MythUIButton
A single button widget.
Definition: mythuibutton.h:22
MythMenuItem
Definition: mythdialogbox.h:70
MythTimeInputDialog::kMinutes
@ kMinutes
Definition: mythdialogbox.h:408
MythTextInputDialog::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:288
MythDialogBox::gestureEvent
bool gestureEvent(MythGestureEvent *event) override
Mouse click/movement handler, receives mouse gesture events from the QCoreApplication event loop.
Definition: mythdialogbox.cpp:390
MythUIButtonList::GetDataValue
QVariant GetDataValue() const
Definition: mythuibuttonlist.cpp:1619
MythGestureEvent::Click
@ Click
Definition: mythgesture.h:77
MythUITextEdit::SetPassword
void SetPassword(bool isPassword)
Definition: mythuitextedit.h:50
MythTimeInputDialog::m_dateList
MythUIButtonList * m_dateList
Definition: mythdialogbox.h:438
MythMenu::MythMenu
MythMenu(QString text, QObject *retobject, QString resultid)
Definition: mythdialogbox.cpp:36
MythSpinBoxDialog::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:326
MythTimeInputDialog::haveResult
void haveResult(QDateTime time)
MythUITextEdit::SetFilter
void SetFilter(InputFilter filter)
Definition: mythuitextedit.h:49
MythUIButtonListItem::GetData
QVariant GetData()
Definition: mythuibuttonlist.cpp:3580
uint
unsigned int uint
Definition: compat.h:140
MythUIButtonList::GetVisibleCount
int GetVisibleCount()
Definition: mythuibuttonlist.cpp:1660
MythSpinBoxDialog::SetValue
void SetValue(const QString &value)
Can be called only after MythSpinBoxDialog::Create() return successfully The range need to be set bef...
Definition: mythdialogbox.cpp:732
mythgesture.h
A C++ ripoff of the stroke library for MythTV.
UIUtilDisp::Assign
static bool Assign(ContainerType *container, UIType *&item, const QString &name, bool *err=nullptr)
Definition: mythuiutils.h:27
MythMenu::m_text
QString m_text
Definition: mythdialogbox.h:122
MythUISearchDialog::m_textEdit
MythUITextEdit * m_textEdit
Definition: mythdialogbox.h:367
MythMenu::m_resultid
QString m_resultid
Definition: mythdialogbox.h:123
MythMenu::SetParent
void SetParent(MythMenu *parent)
Definition: mythdialogbox.h:112
MythDate::kSimplify
@ kSimplify
Do Today/Yesterday/Tomorrow transform.
Definition: mythdate.h:23
MythUIButtonListItem::GetText
QString GetText(const QString &name="") const
Definition: mythuibuttonlist.cpp:3305
mythuispinbox.h
MythDialogBox::m_title
QString m_title
Definition: mythdialogbox.h:200
MythSpinBoxDialog::SetRange
void SetRange(int low, int high, int step, uint pageMultiple=5)
Set the lower and upper bounds of the spinbox, the interval and page amount.
Definition: mythdialogbox.cpp:715
MythMenu
Definition: mythdialogbox.h:93
MythDialogBox::Selected
void Selected()
MythUISearchDialog::m_defaultValue
QString m_defaultValue
Definition: mythdialogbox.h:372
MythTimeInputDialog::m_startTime
QDateTime m_startTime
Definition: mythdialogbox.h:432
MythUIText
All purpose text widget, displays a text string.
Definition: mythuitext.h:29
MythScreenType::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: mythscreentype.cpp:414
MythMenu::m_title
QString m_title
Definition: mythdialogbox.h:121
MythUISearchDialog::slotUpdateList
void slotUpdateList(void)
Definition: mythdialogbox.cpp:873
MythDate::kAddYear
@ kAddYear
Add year to string if not included.
Definition: mythdate.h:22
MythConfirmationDialog
Dialog asking for user confirmation.
Definition: mythdialogbox.h:222
MythTimeInputDialog::m_resolution
int m_resolution
Definition: mythdialogbox.h:433
MythUIButtonList::LayoutVertical
@ LayoutVertical
Definition: mythuibuttonlist.h:159
MythTextInputDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:611
XMLParseBase::LoadWindowFromXML
static bool LoadWindowFromXML(const QString &xmlfile, const QString &windowname, MythUIType *parent)
Definition: xmlparsebase.cpp:692
MythUISearchDialog::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:376
MythConfirmationDialog::m_messageText
MythUIText * m_messageText
Definition: mythdialogbox.h:243
DialogCompletionEvent
Event dispatched from MythUI modal dialogs to a listening class containing a result of some form.
Definition: mythdialogbox.h:42
MythUISearchDialog::m_itemList
MythUIButtonList * m_itemList
Definition: mythdialogbox.h:366
MythTimeInputDialog::Create
bool Create() override
Definition: mythdialogbox.cpp:916
MythConfirmationDialog::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:246
MythUIButtonList::GetValue
virtual QString GetValue() const
Definition: mythuibuttonlist.cpp:1609
MythUIText::SetText
virtual void SetText(const QString &text)
Definition: mythuitext.cpp:134
MythUIType::SetVisible
virtual void SetVisible(bool visible)
Definition: mythuitype.cpp:1086
MythTextInputDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:647
MythScreenStack::PopScreen
virtual void PopScreen(MythScreenType *screen=nullptr, bool allowFade=true, bool deleteScreen=true)
Definition: mythscreenstack.cpp:83
DialogCompletionEvent::~DialogCompletionEvent
~DialogCompletionEvent() override
Definition: mythdialogbox.cpp:32
MythConfirmationDialog::m_id
QString m_id
Definition: mythdialogbox.h:247
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:105
MythUISearchDialog::m_list
QStringList m_list
Definition: mythdialogbox.h:373
MythTimeInputDialog::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:441
MythUISearchDialog::m_matchesText
MythUIText * m_matchesText
Definition: mythdialogbox.h:369
MythDialogBox::m_backtext
QString m_backtext
Definition: mythdialogbox.h:203
MythUIButtonList::SetItemCurrent
void SetItemCurrent(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1557
MythSpinBoxDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:745
build_compdb.action
action
Definition: build_compdb.py:9
MythMenu::~MythMenu
~MythMenu(void)
Definition: mythdialogbox.cpp:49
MythConfirmationDialog::SetMessage
void SetMessage(const QString &message)
Definition: mythdialogbox.cpp:506
mythuibutton.h
MythScreenType::gestureEvent
bool gestureEvent(MythGestureEvent *event) override
Mouse click/movement handler, receives mouse gesture events from the QCoreApplication event loop.
Definition: mythscreentype.cpp:456
MythDate::kDateFull
@ kDateFull
Default local time.
Definition: mythdate.h:16
MythUITextEdit::valueChanged
void valueChanged()
MythTimeInputDialog::kFutureDates
@ kFutureDates
Definition: mythdialogbox.h:411
MythMenu::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:124
MythScreenType::m_screenStack
MythScreenStack * m_screenStack
Definition: mythscreentype.h:128
MythGestureEvent
A custom event that represents a mouse gesture.
Definition: mythgesture.h:40
MythDialogBox::~MythDialogBox
~MythDialogBox(void) override
Definition: mythdialogbox.cpp:122
MythUIButtonCallback
std::function< void(void)> MythUIButtonCallback
Definition: mythdialogbox.h:67
MythDate::kTime
@ kTime
Default local time.
Definition: mythdate.h:19
MythUIButtonList::LayoutHorizontal
@ LayoutHorizontal
Definition: mythuibuttonlist.h:159
MythDialogBox::updateMenu
void updateMenu(void)
Definition: mythdialogbox.cpp:177
mythmainwindow.h
MythScreenStack::AddScreen
virtual void AddScreen(MythScreenType *screen, bool allowFade=true)
Definition: mythscreenstack.cpp:49
MythUIType::SetRedraw
void SetRedraw(void)
Definition: mythuitype.cpp:294
MythDialogBox::m_exittext
QString m_exittext
Definition: mythdialogbox.h:205
MythUISpinBox::AddSelection
void AddSelection(int value, const QString &label="")
Add a special label for a value of the spinbox, it does not need to be in the range.
Definition: mythuispinbox.cpp:95
MythTimeInputDialog::m_message
QString m_message
Definition: mythdialogbox.h:431
MythUISearchDialog::m_id
QString m_id
Definition: mythdialogbox.h:377
MythConfirmationDialog::Cancel
void Cancel()
Definition: mythdialogbox.cpp:525
MythMainWindow
Definition: mythmainwindow.h:35
MythTextInputDialog::sendResult
void sendResult()
Definition: mythdialogbox.cpp:654
MythDialogBox::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:194
MythScreenStack::GetTopScreen
virtual MythScreenType * GetTopScreen(void) const
Definition: mythscreenstack.cpp:179
MythDialogBox::m_menu
MythMenu * m_menu
Definition: mythdialogbox.h:208