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 
164  connect(m_buttonList, SIGNAL(itemClicked(MythUIButtonListItem*)),
165  SLOT(Select(MythUIButtonListItem*)));
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 
220  if (menuItem->m_subMenu)
221  {
223  m_currentMenu = menuItem->m_subMenu;
224  updateMenu();
225  return;
226  }
227 
228  if (menuItem->m_useSlot)
229  {
230  const char *slot = menuItem->m_data.value < const char * >();
231  if (slot)
232  {
233  connect(this, SIGNAL(Selected()), m_currentMenu->m_retObject, slot,
234  Qt::QueuedConnection);
235  emit Selected();
236  }
237  else if (menuItem->m_data.value<MythUIButtonCallback>())
238  {
240  menuItem->m_data.value<MythUIButtonCallback>(),
241  Qt::QueuedConnection);
242  emit Selected();
243  }
244  }
245 
246  SendEvent(m_buttonList->GetItemPos(item), item->GetText(), menuItem->m_data);
247  }
248  else
249  {
250  if (m_useSlots)
251  {
252  const char *slot = item->GetData().value<const char *>();
253  if (slot)
254  {
255  connect(this, SIGNAL(Selected()), m_retObject, slot,
256  Qt::QueuedConnection);
257  emit Selected();
258  }
259  else if (item->GetData().value<MythUIButtonCallback>())
260  {
261  connect(this, &MythDialogBox::Selected, m_retObject,
262  item->GetData().value<MythUIButtonCallback>(),
263  Qt::QueuedConnection);
264  emit Selected();
265  }
266  }
267 
268  SendEvent(m_buttonList->GetItemPos(item), item->GetText(), item->GetData());
269  }
270 
271  if (m_ScreenStack)
272  m_ScreenStack->PopScreen(nullptr, false);
273 }
274 
275 void MythDialogBox::SetReturnEvent(QObject *retobject,
276  const QString &resultid)
277 {
278  m_retObject = retobject;
279  m_id = resultid;
280 }
281 
282 void MythDialogBox::SetBackAction(const QString &text, QVariant data)
283 {
284  m_backtext = text;
285  m_backdata = std::move(data);
286 }
287 
288 void MythDialogBox::SetExitAction(const QString &text, QVariant data)
289 {
290  m_exittext = text;
291  m_exitdata = std::move(data);
292 }
293 
294 void MythDialogBox::SetText(const QString &text)
295 {
296  if (m_textarea)
297  m_textarea->SetText(text);
298 }
299 
300 void MythDialogBox::AddButton(const QString &title, QVariant data, bool newMenu,
301  bool setCurrent)
302 {
303  auto *button = new MythUIButtonListItem(m_buttonList, title);
304  button->SetData(std::move(data));
305  button->setDrawArrow(newMenu);
306 
307  if (setCurrent)
308  m_buttonList->SetItemCurrent(button);
309  // GetVisibleCount here makes sure that the dialog size is
310  // calculated correctly
312 }
313 
314 void MythDialogBox::AddButton(const QString &title, const char *slot,
315  bool newMenu, bool setCurrent)
316 {
317  auto *button = new MythUIButtonListItem(m_buttonList, title);
318 
319  m_useSlots = true;
320 
321  if (slot)
322  button->SetData(QVariant::fromValue(slot));
323  button->setDrawArrow(newMenu);
324 
325  if (setCurrent)
326  m_buttonList->SetItemCurrent(button);
327  // GetVisibleCount here makes sure that the dialog size is
328  // calculated correctly
330 }
331 
332 bool MythDialogBox::keyPressEvent(QKeyEvent *event)
333 {
334  if (GetFocusWidget()->keyPressEvent(event))
335  return true;
336 
337  bool handled = false;
338  QStringList actions;
339  handled = GetMythMainWindow()->TranslateKeyPress("qt", event, actions);
340 
341  for (int i = 0; i < actions.size() && !handled; i++)
342  {
343  QString action = actions[i];
344  handled = true;
345 
346  if (action == "ESCAPE")
347  {
349  if (m_exitdata == 0 && m_exittext.isEmpty())
350  Close();
351  }
352  else if ((action == "LEFT" &&
354  (action == "UP" &&
356  {
358  {
360  updateMenu();
361  return true;
362  }
363 
365  Close();
366  }
367  else if (action == "MENU")
368  {
369  SendEvent(-2);
370  Close();
371  }
372  else if ((action == "RIGHT" &&
374  (action == "DOWN" &&
376  {
378  }
379  else
380  handled = false;
381  }
382 
383  if (!handled && MythScreenType::keyPressEvent(event))
384  handled = true;
385 
386  return handled;
387 }
388 
390 {
391  bool handled = false;
392  if (event->gesture() == MythGestureEvent::Click)
393  {
394  switch (event->GetButton())
395  {
397  SendEvent(-2);
398  Close();
399  handled = true;
400  break;
401  default :
402  break;
403  }
404 
405  }
406 
407  if (!handled && MythScreenType::gestureEvent(event))
408  handled = true;
409 
410  return handled;
411 }
412 
413 void MythDialogBox::SendEvent(int res, const QString& text, const QVariant& data)
414 {
415  if (m_currentMenu)
416  {
417  emit Closed(m_currentMenu->m_resultid, res);
418 
420  return;
421 
422  auto *dce = new DialogCompletionEvent(m_currentMenu->m_resultid, res, text, data);
423  QCoreApplication::postEvent(m_currentMenu->m_retObject, dce);
424  }
425  else
426  {
427  emit Closed(m_id, res);
428 
429  if (!m_retObject)
430  return;
431 
432  auto *dce = new DialogCompletionEvent(m_id, res, text, data);
433  QCoreApplication::postEvent(m_retObject, dce);
434  }
435 }
436 
438 
440 {
441  if (!CopyWindowFromBase("MythConfirmationDialog", this))
442  return false;
443 
444  MythUIButton *okButton = nullptr;
445  MythUIButton *cancelButton = nullptr;
446 
447  bool err = false;
448  UIUtilE::Assign(this, m_messageText, "message", &err);
449  UIUtilE::Assign(this, okButton, "ok", &err);
450  UIUtilE::Assign(this, cancelButton, "cancel", &err);
451 
452  if (err)
453  {
454  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythConfirmationDialog'");
455  return false;
456  }
457 
458  if (m_showCancel)
459  {
460  connect(cancelButton, SIGNAL(Clicked()), SLOT(Cancel()));
461  }
462  else
463  cancelButton->SetVisible(false);
464 
465  connect(okButton, SIGNAL(Clicked()), SLOT(Confirm()));
466 
468 
469  BuildFocusList();
470 
471  if (m_showCancel)
472  SetFocusWidget(cancelButton);
473  else
474  SetFocusWidget(okButton);
475 
476  return true;
477 }
478 
480 {
481  if (GetFocusWidget()->keyPressEvent(event))
482  return true;
483 
484  bool handled = false;
485  QStringList actions;
486  handled = GetMythMainWindow()->TranslateKeyPress("qt", event, actions);
487 
488  for (int i = 0; i < actions.size() && !handled; i++)
489  {
490  QString action = actions[i];
491  handled = true;
492 
493  if (action == "ESCAPE")
494  sendResult(false);
495  else
496  handled = false;
497  }
498 
499  if (!handled && MythScreenType::keyPressEvent(event))
500  handled = true;
501 
502  return handled;
503 }
504 
505 void MythConfirmationDialog::SetMessage(const QString &message)
506 {
507  m_message = message;
508  if (m_messageText)
510 }
511 
513  const QString &resultid)
514 {
515  m_retObject = retobject;
516  m_id = resultid;
517 }
518 
520 {
521  sendResult(true);
522 }
523 
525 {
526  sendResult(false);
527 }
528 
530 {
531  emit haveResult(ok);
532 
533  if (m_retObject)
534  {
535  int res = 0;
536  if (ok)
537  res = 1;
538 
539  auto *dce = new DialogCompletionEvent(m_id, res, "", m_resultData);
540  QCoreApplication::postEvent(m_retObject, dce);
541  m_retObject = nullptr;
542  }
543 
544  Close();
545 }
546 
550 MythConfirmationDialog *ShowOkPopup(const QString &message, QObject *parent,
551  const char *slot, bool showCancel)
552 {
553  QString LOC = "ShowOkPopup('" + message + "') - ";
554  MythScreenStack *stk = nullptr;
555 
557 
558  if (win)
559  stk = win->GetStack("popup stack");
560  else
561  {
562  LOG(VB_GENERAL, LOG_ERR, LOC + "no main window?");
563  return nullptr;
564  }
565 
566  if (!stk)
567  {
568  LOG(VB_GENERAL, LOG_ERR, LOC + "no popup stack? "
569  "Is there a MythThemeBase?");
570  return nullptr;
571  }
572 
573  auto *pop = new MythConfirmationDialog(stk, message, showCancel);
574  if (pop->Create())
575  {
576  stk->AddScreen(pop);
577  if (parent && slot)
578  QObject::connect(pop, SIGNAL(haveResult(bool)), parent, slot,
579  Qt::QueuedConnection);
580  }
581  else
582  {
583  delete pop;
584  pop = nullptr;
585  LOG(VB_GENERAL, LOG_ERR, LOC + "Couldn't Create() Dialog");
586  }
587 
588  return pop;
589 }
590 
592 {
593  if (!dialog)
594  return true; // No dialog is treated as user pressing OK
595 
596  // Local event loop processes events whilst we wait
597  QEventLoop block;
598 
599  // Quit when dialog exits
600  QObject::connect(dialog, &MythConfirmationDialog::haveResult,
601  &block, [&block](bool result)
602  { block.exit(result ? 1 : 0); });
603 
604  // Block and return dialog result
605  return block.exec() != 0;
606 }
607 
609 
611 {
612  if (!CopyWindowFromBase("MythTextInputDialog", this))
613  return false;
614 
615  MythUIText *messageText = nullptr;
616  MythUIButton *okButton = nullptr;
617  MythUIButton *cancelButton = nullptr;
618 
619  bool err = false;
620  UIUtilE::Assign(this, m_textEdit, "input", &err);
621  UIUtilE::Assign(this, messageText, "message", &err);
622  UIUtilE::Assign(this, okButton, "ok", &err);
623  UIUtilW::Assign(this, cancelButton, "cancel");
624 
625  if (err)
626  {
627  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythTextInputDialog'");
628  return false;
629  }
630 
631  if (cancelButton)
632  connect(cancelButton, SIGNAL(Clicked()), SLOT(Close()));
633  connect(okButton, SIGNAL(Clicked()), SLOT(sendResult()));
634 
638 
639  messageText->SetText(m_message);
640 
641  BuildFocusList();
642 
643  return true;
644 }
645 
646 void MythTextInputDialog::SetReturnEvent(QObject *retobject,
647  const QString &resultid)
648 {
649  m_retObject = retobject;
650  m_id = resultid;
651 }
652 
654 {
655  QString inputString = m_textEdit->GetText();
656  emit haveResult(inputString);
657 
658  if (m_retObject)
659  {
660  auto *dce = new DialogCompletionEvent(m_id, 0, inputString, "");
661  QCoreApplication::postEvent(m_retObject, dce);
662  }
663 
664  Close();
665 }
666 
668 
670  QString message)
671  : MythScreenType(parent, "mythspinboxpopup"),
672  m_spinBox(nullptr),
673  m_message(std::move(message)),
674  m_retObject(nullptr),
675  m_id("")
676 {
677 }
678 
680 {
681  if (!CopyWindowFromBase("MythSpinBoxDialog", this))
682  return false;
683 
684  MythUIText *messageText = nullptr;
685  MythUIButton *okButton = nullptr;
686  MythUIButton *cancelButton = nullptr;
687 
688  bool err = false;
689  UIUtilE::Assign(this, m_spinBox, "input", &err);
690  UIUtilE::Assign(this, messageText, "message", &err);
691  UIUtilE::Assign(this, okButton, "ok", &err);
692  UIUtilW::Assign(this, cancelButton, "cancel");
693 
694  if (err)
695  {
696  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythSpinBoxDialog'");
697  return false;
698  }
699 
700  if (cancelButton)
701  connect(cancelButton, SIGNAL(Clicked()), SLOT(Close()));
702  connect(okButton, SIGNAL(Clicked()), SLOT(sendResult()));
703 
704  messageText->SetText(m_message);
705  BuildFocusList();
706 
707  return true;
708 }
709 
714 void MythSpinBoxDialog::SetRange(int low, int high, int step, uint pageMultiple)
715 {
716  m_spinBox->SetRange(low, high, step, pageMultiple);
717 }
718 
722 void MythSpinBoxDialog::AddSelection(const QString& label, int value)
723 {
724  m_spinBox->AddSelection(value, label);
725 }
726 
731 void MythSpinBoxDialog::SetValue (const QString & value)
732 {
733  m_spinBox->SetValue(value);
734 }
735 
740 {
741  m_spinBox->SetValue(value);
742 }
743 
744 void MythSpinBoxDialog::SetReturnEvent(QObject *retobject,
745  const QString &resultid)
746 {
747  m_retObject = retobject;
748  m_id = resultid;
749 }
750 
752 {
753  QString inputString = m_spinBox->GetValue();
754  emit haveResult(inputString);
755 
756  if (m_retObject)
757  {
758  auto *dce = new DialogCompletionEvent(m_id, 0, inputString, "");
759  QCoreApplication::postEvent(m_retObject, dce);
760  }
761 
762  Close();
763 }
764 
766 
767 
783  const QString &title,
784  const QStringList &list,
785  bool matchAnywhere,
786  const QString &defaultValue)
787  : MythScreenType(parent, "mythsearchdialogpopup")
788 {
789  m_list = list;
790  m_matchAnywhere = matchAnywhere;
791  m_title = title;
792  m_defaultValue = defaultValue;
793 
794  m_titleText = nullptr;
795  m_matchesText = nullptr;
796  m_textEdit = nullptr;
797  m_itemList = nullptr;
798 
799  m_id = "";
800  m_retObject = nullptr;
801 }
802 
804 {
805  if (!CopyWindowFromBase("MythSearchDialog", this))
806  return false;
807 
808  MythUIButton *okButton = nullptr;
809  MythUIButton *cancelButton = nullptr;
810 
811  bool err = false;
812  UIUtilE::Assign(this, m_textEdit, "input", &err);
813  UIUtilE::Assign(this, m_titleText, "title", &err);
814  UIUtilW::Assign(this, m_matchesText, "matches");
815  UIUtilE::Assign(this, m_itemList, "itemlist", &err);
816  UIUtilE::Assign(this, okButton, "ok", &err);
817  UIUtilW::Assign(this, cancelButton, "cancel");
818 
819  if (err)
820  {
821  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythSearchDialog'");
822  return false;
823  }
824 
825  if (cancelButton)
826  connect(cancelButton, SIGNAL(Clicked()), SLOT(Close()));
827 
828  connect(okButton, SIGNAL(Clicked()), SLOT(slotSendResult()));
829 
830  connect(m_itemList, SIGNAL(itemClicked(MythUIButtonListItem*)),
831  SLOT(slotSendResult()));
832 
834  connect(m_textEdit, SIGNAL(valueChanged()), SLOT(slotUpdateList()));
835 
837  if (m_matchesText)
838  m_matchesText->SetText(tr("%n match(es)", "", 0));
839 
840  BuildFocusList();
841 
842  slotUpdateList();
843 
844  return true;
845 }
846 
847 void MythUISearchDialog::SetReturnEvent(QObject *retobject,
848  const QString &resultid)
849 {
850  m_retObject = retobject;
851  m_id = resultid;
852 }
853 
855 {
856  if (!m_itemList->GetItemCurrent())
857  return;
858 
859  QString result = m_itemList->GetValue();
860 
861  emit haveResult(result);
862 
863  if (m_retObject)
864  {
865  auto *dce = new DialogCompletionEvent(m_id, 0, result, "");
866  QCoreApplication::postEvent(m_retObject, dce);
867  }
868 
869  Close();
870 }
871 
873 {
874  m_itemList->Reset();
875 
876  for (int x = 0; x < m_list.size(); x++)
877  {
878  QString item = m_list.at(x);
879 
880  if (m_matchAnywhere)
881  {
882  if (!item.contains(m_textEdit->GetText(), Qt::CaseInsensitive))
883  continue;
884  }
885  else
886  {
887  if (!item.startsWith(m_textEdit->GetText(), Qt::CaseInsensitive))
888  continue;
889  }
890 
891  // add item to list
892  new MythUIButtonListItem(m_itemList, item, nullptr, false);
893  }
894 
896 
897  if (m_matchesText)
898  m_matchesText->SetText(tr("%n match(es)", "", 0));
899 }
900 
902 
904  QString message,
905  int resolutionFlags,
906  QDateTime startTime,
907  int rangeLimit)
908  : MythScreenType(parent, "timepopup"),
909  m_message(std::move(message)), m_startTime(std::move(startTime)),
910  m_resolution(resolutionFlags), m_rangeLimit(rangeLimit),
911  m_dateList(nullptr), m_timeList(nullptr), m_retObject(nullptr)
912 {
913 }
914 
916 {
917  if (!CopyWindowFromBase("MythTimeInputDialog", this))
918  return false;
919 
920  MythUIText *messageText = nullptr;
921  MythUIButton *okButton = nullptr;
922 
923  bool err = false;
924  UIUtilE::Assign(this, messageText, "message", &err);
925  UIUtilE::Assign(this, m_dateList, "dates", &err);
926  UIUtilE::Assign(this, m_timeList, "times", &err);
927  UIUtilE::Assign(this, okButton, "ok", &err);
928 
929  if (err)
930  {
931  LOG(VB_GENERAL, LOG_ERR, "Cannot load screen 'MythTimeInputDialog'");
932  return false;
933  }
934 
935  m_dateList->SetVisible(false);
936  m_timeList->SetVisible(false);
937 
938  // Date
939  if (kNoDate != (m_resolution & 0xF))
940  {
941  const QDate startdate(m_startTime.toLocalTime().date());
942  QDate date(startdate);
943 
944  int limit = 0;
946  {
947  limit += m_rangeLimit;
948  }
949  if (m_resolution & kPastDates)
950  {
951  limit += m_rangeLimit;
952  date = date.addDays(0-m_rangeLimit);
953  }
954 
955  QString text;
956  bool selected = false;
957  for (int x = 0; x <= limit; x++)
958  {
959  selected = false;
960  if (m_resolution & kDay)
961  {
962  date = date.addDays(1);
964  if (m_rangeLimit >= 356)
965  flags |= MythDate::kAddYear;
966  text = MythDate::toString(date, flags);
967 
968  if (date == startdate)
969  selected = true;
970  }
971  else if (m_resolution & kMonth)
972  {
973  date = date.addMonths(1);
974  text = date.toString("MMM yyyy");
975 
976  if ((date.month() == startdate.month()) &&
977  (date.year() == startdate.year()))
978  selected = true;
979  }
980  else if (m_resolution & kYear)
981  {
982  date = date.addYears(1);
983  text = date.toString("yyyy");
984  if (date.year() == startdate.year())
985  selected = true;
986  }
987 
988  auto *item = new MythUIButtonListItem(m_dateList, text, nullptr, false);
989  item->SetData(QVariant(date));
990 
991  if (selected)
992  m_dateList->SetItemCurrent(item);
993  }
994  m_dateList->SetVisible(true);
995  }
996 
997  // Time
998  if (kNoTime != (m_resolution & 0xF0))
999  {
1000  QDate startdate(m_startTime.toLocalTime().date());
1001  QTime starttime(m_startTime.toLocalTime().time());
1002  QTime time(0,0,0);
1003  QString text;
1004  bool selected = false;
1005 
1006  int limit = (m_resolution & kMinutes) ? (60 * 24) : 24;
1007 
1008  for (int x = 0; x < limit; x++)
1009  {
1010  selected = false;
1011  if (m_resolution & kMinutes)
1012  {
1013  time = time.addSecs(60);
1014  QDateTime dt = QDateTime(startdate, time, Qt::LocalTime);
1015  text = MythDate::toString(dt, MythDate::kTime);
1016 
1017  if (time == starttime)
1018  selected = true;
1019  }
1020  else if (m_resolution & kHours)
1021  {
1022  time = time.addSecs(60*60);
1023  text = time.toString("hh:00");
1024 
1025  if (time.hour() == starttime.hour())
1026  selected = true;
1027  }
1028 
1029  auto *item = new MythUIButtonListItem(m_timeList, text, nullptr, false);
1030  item->SetData(QVariant(time));
1031 
1032  if (selected)
1033  m_timeList->SetItemCurrent(item);
1034  }
1035  m_timeList->SetVisible(true);
1036  }
1037 
1038  if (messageText && !m_message.isEmpty())
1039  messageText->SetText(m_message);
1040 
1041  connect(okButton, SIGNAL(Clicked()), SLOT(okClicked()));
1042 
1043  BuildFocusList();
1044 
1045  return true;
1046 }
1047 
1048 void MythTimeInputDialog::SetReturnEvent(QObject* retobject,
1049  const QString& resultid)
1050 {
1051  m_retObject = retobject;
1052  m_id = resultid;
1053 }
1054 
1056 {
1057  QDate date = m_dateList->GetDataValue().toDate();
1058  QTime time = m_timeList->GetDataValue().toTime();
1059 
1060  QDateTime dateTime = QDateTime(date, time, Qt::LocalTime).toUTC();
1061 
1062  emit haveResult(dateTime);
1063 
1064  if (m_retObject)
1065  {
1066  QVariant data(dateTime);
1067  auto *dce = new DialogCompletionEvent(m_id, 0, "", data);
1068  QCoreApplication::postEvent(m_retObject, dce);
1069  }
1070 
1071  Close();
1072 }
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:591
MythMainWindow::GetMainStack
MythScreenStack * GetMainStack()
Definition: mythmainwindow.cpp:304
MythDialogBox::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:275
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:751
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:439
ShowOkPopup
MythConfirmationDialog * ShowOkPopup(const QString &message, QObject *parent, const char *slot, bool showCancel)
Non-blocking version of MythPopupBox::showOkPopup()
Definition: mythdialogbox.cpp:550
MythUISearchDialog::m_titleText
MythUIText * m_titleText
Definition: mythdialogbox.h:368
MythSpinBoxDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:679
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:413
MythUISearchDialog::slotSendResult
void slotSendResult(void)
Definition: mythdialogbox.cpp:854
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:633
MythSpinBoxDialog::MythSpinBoxDialog
MythSpinBoxDialog(MythScreenStack *parent, QString message)
Definition: mythdialogbox.cpp:669
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:1106
MythTimeInputDialog::kYear
@ kYear
Definition: mythdialogbox.h:401
MythConfirmationDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:512
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:282
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:847
LOC
#define LOC
Definition: audioconvert.cpp:38
MythConfirmationDialog::haveResult
void haveResult(bool)
mythdialogbox.h
MythScreenStack
Definition: mythscreenstack.h:15
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:44
mythuistatetype.h
MythUITextEdit::GetText
QString GetText(void) const
Definition: mythuitextedit.h:47
MythSpinBoxDialog::AddSelection
void AddSelection(const QString &label, int value)
Definition: mythdialogbox.cpp:722
MythConfirmationDialog::sendResult
void sendResult(bool ok)
Definition: mythdialogbox.cpp:529
MythTextInputDialog::haveResult
void haveResult(QString)
MythConfirmationDialog::m_showCancel
bool m_showCancel
Definition: mythdialogbox.h:245
MythConfirmationDialog::Confirm
void Confirm(void)
Definition: mythdialogbox.cpp:519
MythDialogBox::Select
void Select(MythUIButtonListItem *item)
Definition: mythdialogbox.cpp:211
menu
static MythThemedMenu * menu
Definition: mythtv/programs/mythtv-setup/main.cpp:55
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:309
mythuibuttonlist.h
MythUISearchDialog::Create
bool Create(void) override
Definition: mythdialogbox.cpp:803
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:479
MythTimeInputDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:1048
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:27
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:332
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:903
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
MythGestureEvent::RightButton
@ RightButton
Definition: mythgesture.h:84
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
MythGestureEvent::gesture
Gesture gesture(void) const
Get the gesture type.
Definition: mythgesture.h:109
MythDialogBox::SetExitAction
void SetExitAction(const QString &text, QVariant data)
Definition: mythdialogbox.cpp:288
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:782
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:300
MythDialogBox::SetText
void SetText(const QString &text)
Definition: mythdialogbox.cpp:294
MythScreenType::BuildFocusList
void BuildFocusList(void)
Definition: mythscreentype.cpp:222
MythTimeInputDialog::okClicked
void okClicked(void)
Definition: mythdialogbox.cpp:1055
XMLParseBase::CopyWindowFromBase
static bool CopyWindowFromBase(const QString &windowname, MythScreenType *win)
Definition: xmlparsebase.cpp:917
MythMenu::m_parentMenu
MythMenu * m_parentMenu
Definition: mythdialogbox.h:120
MythUIButton
A single button widget.
Definition: mythuibutton.h:21
MythMenuItem
Definition: mythdialogbox.h:69
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:389
MythUIButtonList::GetDataValue
QVariant GetDataValue() const
Definition: mythuibuttonlist.cpp:1619
MythGestureEvent::Click
@ Click
Definition: mythgesture.h:75
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:3588
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:731
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
MythGestureEvent::GetButton
Button GetButton(void) const
Definition: mythgesture.h:121
MythDate::kSimplify
@ kSimplify
Do Today/Yesterday/Tomorrow transform.
Definition: mythdate.h:23
MythUIButtonListItem::GetText
QString GetText(const QString &name="") const
Definition: mythuibuttonlist.cpp:3313
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:714
MythMenu
Definition: mythdialogbox.h:92
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:28
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:872
MythDate::kAddYear
@ kAddYear
Add year to string if not included.
Definition: mythdate.h:22
MythConfirmationDialog
Dialog asking for user confirmation. Ok and optional Cancel button.
Definition: mythdialogbox.h:221
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:610
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:41
MythUISearchDialog::m_itemList
MythUIButtonList * m_itemList
Definition: mythdialogbox.h:366
MythTimeInputDialog::Create
bool Create() override
Definition: mythdialogbox.cpp:915
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:135
MythUIType::SetVisible
virtual void SetVisible(bool visible)
Definition: mythuitype.cpp:1080
MythTextInputDialog::SetReturnEvent
void SetReturnEvent(QObject *retobject, const QString &resultid)
Definition: mythdialogbox.cpp:646
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:113
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:107
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:744
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:505
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
MythTimeInputDialog::kFutureDates
@ kFutureDates
Definition: mythdialogbox.h:411
MythScreenType::m_ScreenStack
MythScreenStack * m_ScreenStack
Definition: mythscreentype.h:128
MythMenu::m_retObject
QObject * m_retObject
Definition: mythdialogbox.h:124
MythGestureEvent
A custom event that represents a mouse gesture.
Definition: mythgesture.h:39
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:293
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:524
MythMainWindow
Definition: mythmainwindow.h:32
MythTextInputDialog::sendResult
void sendResult()
Definition: mythdialogbox.cpp:653
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