MythTV  master
scheduleeditor.cpp
Go to the documentation of this file.
1 
2 #include "scheduleeditor.h"
3 
4 // QT
5 #include <QCoreApplication>
6 #include <QHash>
7 #include <QString>
8 #include <utility>
9 
10 // Libmyth
11 #include "mythcorecontext.h"
12 #include "storagegroup.h"
13 #include "programtypes.h"
14 #include "recordingtypes.h"
15 
16 // Libmythtv
17 #include "playgroup.h"
18 #include "tv_play.h"
19 #include "recordingprofile.h"
20 #include "cardutil.h"
21 
22 // Libmythui
23 #include "mythmainwindow.h"
24 #include "mythuihelper.h"
25 #include "mythuibuttonlist.h"
26 #include "mythuibutton.h"
27 #include "mythuitext.h"
28 #include "mythuiimage.h"
29 #include "mythuistatetype.h"
30 #include "mythuispinbox.h"
31 #include "mythuicheckbox.h"
32 #include "mythdialogbox.h"
33 #include "mythprogressdialog.h"
34 #include "mythuifilebrowser.h"
35 #include "mythuimetadataresults.h"
36 #include "mythuiimageresults.h"
37 #include "videoutils.h"
38 #include "mythuiutils.h"
39 #include "mythtypes.h"
40 
41 #include "metadataimagehelper.h"
42 
43 // Mythfrontend
44 #include "proglist.h"
45 #include "viewschedulediff.h"
46 
47 #define ENUM_TO_QVARIANT(a) QVariant::fromValue(static_cast<int>(a))
48 
49 //static const QString _Location = QObject::tr("Schedule Editor");
50 
51 // Define the strings inserted into the recordfilter table in the
52 // database. This should make them available to the translators.
53 static QString fs0(QT_TRANSLATE_NOOP("SchedFilterEditor", "New episode"));
54 static QString fs1(QT_TRANSLATE_NOOP("SchedFilterEditor", "Identifiable episode"));
55 static QString fs2(QT_TRANSLATE_NOOP("SchedFilterEditor", "First showing"));
56 static QString fs3(QT_TRANSLATE_NOOP("SchedFilterEditor", "Prime time"));
57 static QString fs4(QT_TRANSLATE_NOOP("SchedFilterEditor", "Commercial free"));
58 static QString fs5(QT_TRANSLATE_NOOP("SchedFilterEditor", "High definition"));
59 static QString fs6(QT_TRANSLATE_NOOP("SchedFilterEditor", "This episode"));
60 static QString fs7(QT_TRANSLATE_NOOP("SchedFilterEditor", "This series"));
61 static QString fs8(QT_TRANSLATE_NOOP("SchedFilterEditor", "This time"));
62 static QString fs9(QT_TRANSLATE_NOOP("SchedFilterEditor", "This day and time"));
63 static QString fs10(QT_TRANSLATE_NOOP("SchedFilterEditor", "This channel"));
64 static QString fs11(QT_TRANSLATE_NOOP("SchedFilterEditor", "No episodes"));
65 
66 void *ScheduleEditor::RunScheduleEditor(ProgramInfo *proginfo, void *player)
67 {
68  auto *rule = new RecordingRule();
69  rule->LoadByProgram(proginfo);
70 
71  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
72  auto *se = new ScheduleEditor(mainStack, rule, static_cast<TV*>(player));
73 
74  if (se->Create())
75  mainStack->AddScreen(se, (player == nullptr));
76  else
77  delete se;
78 
79  return nullptr;
80 }
81 
87 ScheduleEditor::ScheduleEditor(MythScreenStack *parent,
88  RecordingInfo *recInfo, TV *player)
89  : ScheduleCommon(parent, "ScheduleEditor"),
90  SchedOptMixin(*this, nullptr), FilterOptMixin(*this, nullptr),
91  StoreOptMixin(*this, nullptr), PostProcMixin(*this, nullptr),
92  m_recInfo(new RecordingInfo(*recInfo)),
93  m_player(player)
94 {
95  m_recordingRule = new RecordingRule();
96  m_recordingRule->m_recordID = m_recInfo->GetRecordingRuleID();
97  SchedOptMixin::SetRule(m_recordingRule);
98  FilterOptMixin::SetRule(m_recordingRule);
99  StoreOptMixin::SetRule(m_recordingRule);
100  PostProcMixin::SetRule(m_recordingRule);
101 }
102 
103 ScheduleEditor::ScheduleEditor(MythScreenStack *parent,
104  RecordingRule *recRule, TV *player)
105  : ScheduleCommon(parent, "ScheduleEditor"),
106  SchedOptMixin(*this, recRule),
107  FilterOptMixin(*this, recRule),
108  StoreOptMixin(*this, recRule),
109  PostProcMixin(*this, recRule),
110  m_recordingRule(recRule),
111  m_player(player)
112 {
113 }
114 
115 ScheduleEditor::~ScheduleEditor(void)
116 {
117  delete m_recordingRule;
118 
119  // if we have a player, we need to tell we are done
120  if (m_player)
121  {
122  QString message = QString("VIEWSCHEDULED_EXITING");
123  qApp->postEvent(m_player, new MythEvent(message));
124  }
125 }
126 
127 bool ScheduleEditor::Create()
128 {
129  if (!LoadWindowFromXML("schedule-ui.xml", "scheduleeditor", this))
130  return false;
131 
132  bool err = false;
133 
134  UIUtilE::Assign(this, m_rulesList, "rules", &err);
135 
136  UIUtilW::Assign(this, m_schedOptButton, "schedoptions");
137  UIUtilW::Assign(this, m_storeOptButton, "storeoptions");
138  UIUtilW::Assign(this, m_postProcButton, "postprocessing");
139  UIUtilW::Assign(this, m_metadataButton, "metadata");
140  UIUtilW::Assign(this, m_schedInfoButton, "schedinfo");
141  UIUtilW::Assign(this, m_previewButton, "preview");
142  UIUtilW::Assign(this, m_filtersButton, "filters");
143 
144  SchedOptMixin::Create(&err);
145  FilterOptMixin::Create(&err);
146  StoreOptMixin::Create(&err);
147  PostProcMixin::Create(&err);
148 
149  UIUtilW::Assign(this, m_cancelButton, "cancel");
150  UIUtilE::Assign(this, m_saveButton, "save", &err);
151 
152  if (err)
153  {
154  LOG(VB_GENERAL, LOG_ERR, "ScheduleEditor, theme is missing "
155  "required elements");
156  return false;
157  }
158 
159  connect(m_rulesList, SIGNAL(itemSelected(MythUIButtonListItem *)),
160  SLOT(RuleChanged(MythUIButtonListItem *)));
161 
162  if (m_schedOptButton)
163  connect(m_schedOptButton, SIGNAL(Clicked()), SLOT(ShowSchedOpt()));
164  if (m_filtersButton)
165  connect(m_filtersButton, SIGNAL(Clicked()), SLOT(ShowFilters()));
166  if (m_storeOptButton)
167  connect(m_storeOptButton, SIGNAL(Clicked()), SLOT(ShowStoreOpt()));
168  if (m_postProcButton)
169  connect(m_postProcButton, SIGNAL(Clicked()), SLOT(ShowPostProc()));
170  if (m_schedInfoButton)
171  connect(m_schedInfoButton, SIGNAL(Clicked()), SLOT(ShowSchedInfo()));
172  if (m_previewButton)
173  connect(m_previewButton, SIGNAL(Clicked()), SLOT(ShowPreview()));
174  if (m_metadataButton)
175  connect(m_metadataButton, SIGNAL(Clicked()), SLOT(ShowMetadataOptions()));
176 
177  if (m_cancelButton)
178  connect(m_cancelButton, SIGNAL(Clicked()), SLOT(Close()));
179  connect(m_saveButton, SIGNAL(Clicked()), SLOT(Save()));
180 
181  if (m_schedInfoButton)
182  m_schedInfoButton->SetEnabled(!m_recordingRule->m_isTemplate);
183  if (m_previewButton)
184  m_previewButton->SetEnabled(!m_recordingRule->m_isTemplate);
185 
186  if (m_dupmethodList)
187  connect(m_dupmethodList, SIGNAL(itemSelected(MythUIButtonListItem *)),
188  SLOT(DupMethodChanged(MythUIButtonListItem *)));
189  if (m_filtersList)
190  connect(m_filtersList, SIGNAL(itemClicked(MythUIButtonListItem *)),
191  SLOT(FilterChanged(MythUIButtonListItem *)));
192  if (m_maxepSpin)
193  connect(m_maxepSpin, SIGNAL(itemSelected(MythUIButtonListItem *)),
194  SLOT(MaxEpisodesChanged(MythUIButtonListItem *)));
195  if (m_recgroupList)
196  connect(m_recgroupList, SIGNAL(LosingFocus()),
197  SLOT(PromptForRecGroup()));
198  if (m_transcodeCheck)
199  connect(m_transcodeCheck, SIGNAL(toggled(bool)),
200  SLOT(TranscodeChanged(bool)));
201 
202  BuildFocusList();
203 
204  if (!m_recordingRule->IsLoaded())
205  {
206  if (m_recInfo)
207  m_recordingRule->LoadByProgram(m_recInfo);
208  else if (m_recordingRule->m_recordID)
209  m_recordingRule->Load();
210 
211  if (!m_recordingRule->IsLoaded())
212  {
213  LOG(VB_GENERAL, LOG_ERR,
214  "ScheduleEditor::Create() - Failed to load recording rule");
215  return false;
216  }
217  }
218 
219  if (m_player)
220  m_player->StartEmbedding(QRect());
221 
222  return true;
223 }
224 
225 void ScheduleEditor::Close()
226 {
227  if (m_child)
228  m_child->Close();
229 
230  // don't fade the screen if we are returning to the player
231  if (m_player)
232  GetScreenStack()->PopScreen(this, false);
233  else
234  GetScreenStack()->PopScreen(this, true);
235 }
236 
237 void ScheduleEditor::Load()
238 {
239  SchedOptMixin::Load();
240  FilterOptMixin::Load();
241  StoreOptMixin::Load();
242  PostProcMixin::Load();
243 
244  if (!m_loaded)
245  {
246  // Copy this now, it will change briefly after the first item
247  // is inserted into the list by design of
248  // MythUIButtonList::itemSelected()
249  RecordingType type = m_recordingRule->m_type;
250 
251  // Rules List
252  if (m_recordingRule->m_isTemplate)
253  {
254  if (m_recordingRule->m_category
255  .compare("Default", Qt::CaseInsensitive) != 0)
256  {
257  new MythUIButtonListItem(m_rulesList,
258  tr("Delete this recording rule template"),
259  ENUM_TO_QVARIANT(kNotRecording));
260  }
261  new MythUIButtonListItem(m_rulesList,
262  toDescription(kTemplateRecord),
263  ENUM_TO_QVARIANT(kTemplateRecord));
264  }
265  else if (m_recordingRule->m_isOverride)
266  {
267  new MythUIButtonListItem(m_rulesList,
268  tr("Record this showing with normal options"),
269  ENUM_TO_QVARIANT(kNotRecording));
270  new MythUIButtonListItem(m_rulesList,
271  toDescription(kOverrideRecord),
272  ENUM_TO_QVARIANT(kOverrideRecord));
273  new MythUIButtonListItem(m_rulesList,
274  toDescription(kDontRecord),
275  ENUM_TO_QVARIANT(kDontRecord));
276  }
277  else
278  {
279  bool hasChannel = !m_recordingRule->m_station.isEmpty();
280  bool isManual = (m_recordingRule->m_searchType == kManualSearch);
281 
282  new MythUIButtonListItem(m_rulesList,
283  toDescription(kNotRecording),
284  ENUM_TO_QVARIANT(kNotRecording));
285  if (hasChannel)
286  {
287  new MythUIButtonListItem(m_rulesList,
288  toDescription(kSingleRecord),
289  ENUM_TO_QVARIANT(kSingleRecord));
290  }
291  if (!isManual)
292  {
293  new MythUIButtonListItem(m_rulesList,
294  toDescription(kOneRecord),
295  ENUM_TO_QVARIANT(kOneRecord));
296  }
297  if (!hasChannel || isManual)
298  {
299  new MythUIButtonListItem(m_rulesList,
300  toDescription(kWeeklyRecord),
301  ENUM_TO_QVARIANT(kWeeklyRecord));
302  }
303  if (!hasChannel || isManual)
304  {
305  new MythUIButtonListItem(m_rulesList,
306  toDescription(kDailyRecord),
307  ENUM_TO_QVARIANT(kDailyRecord));
308  }
309  if (!isManual)
310  {
311  new MythUIButtonListItem(m_rulesList,
312  toDescription(kAllRecord),
313  ENUM_TO_QVARIANT(kAllRecord));
314  }
315  }
316 
317  m_recordingRule->m_type = type;
318  }
319  m_rulesList->SetValueByData(ENUM_TO_QVARIANT(m_recordingRule->m_type));
320 
321  InfoMap progMap;
322 
323  m_recordingRule->ToMap(progMap);
324 
325  if (m_recInfo)
326  m_recInfo->ToMap(progMap);
327 
328  SetTextFromMap(progMap);
329 
330  m_loaded = true;
331 }
332 
333 void ScheduleEditor::LoadTemplate(const QString& name)
334 {
335  m_recordingRule->LoadTemplate(name);
336  Load();
337  emit templateLoaded();
338 }
339 
340 void ScheduleEditor::RuleChanged(MythUIButtonListItem *item)
341 {
342  if (!item)
343  return;
344 
345  m_recordingRule->m_type = static_cast<RecordingType>
346  (item->GetData().toInt());
347 
348  bool isScheduled = (m_recordingRule->m_type != kNotRecording &&
349  m_recordingRule->m_type != kDontRecord);
350 
351  if (m_schedOptButton)
352  m_schedOptButton->SetEnabled(isScheduled);
353  if (m_filtersButton)
354  m_filtersButton->SetEnabled(isScheduled);
355  if (m_storeOptButton)
356  m_storeOptButton->SetEnabled(isScheduled);
357  if (m_postProcButton)
358  m_postProcButton->SetEnabled(isScheduled);
359  if (m_metadataButton)
360  m_metadataButton->SetEnabled(isScheduled &&
361  !m_recordingRule->m_isTemplate);
362 
363  SchedOptMixin::RuleChanged();
364  FilterOptMixin::RuleChanged();
365  StoreOptMixin::RuleChanged();
366  PostProcMixin::RuleChanged();
367 }
368 
369 void ScheduleEditor::DupMethodChanged(MythUIButtonListItem *item)
370 {
371  SchedOptMixin::DupMethodChanged(item);
372 }
373 
374 void ScheduleEditor::FilterChanged(MythUIButtonListItem *item)
375 {
376  FilterOptMixin::ToggleSelected(item);
377 }
378 
379 void ScheduleEditor::MaxEpisodesChanged(MythUIButtonListItem *item)
380 {
381  StoreOptMixin::MaxEpisodesChanged(item);
382 }
383 
384 void ScheduleEditor::PromptForRecGroup(void)
385 {
386  StoreOptMixin::PromptForRecGroup();
387 }
388 
389 void ScheduleEditor::TranscodeChanged(bool enable)
390 {
391  PostProcMixin::TranscodeChanged(enable);
392 }
393 
394 void ScheduleEditor::Save()
395 {
396  if (m_child)
397  m_child->Close();
398 
399  if (m_recordingRule->m_type == kNotRecording)
400  {
401  int recid = m_recordingRule->m_recordID;
402  DeleteRule();
403  if (recid)
404  emit ruleDeleted(recid);
405  Close();
406  return;
407  }
408 
409  SchedOptMixin::Save();
410  FilterOptMixin::Save();
411  StoreOptMixin::Save();
412  PostProcMixin::Save();
413  m_recordingRule->Save(true);
414  emit ruleSaved(m_recordingRule->m_recordID);
415 
416  Close();
417 }
418 
419 void ScheduleEditor::DeleteRule()
420 {
421  m_recordingRule->Delete();
422 }
423 
424 void ScheduleEditor::ShowSchedOpt()
425 {
426  if (m_recordingRule->m_type == kNotRecording ||
427  m_recordingRule->m_type == kDontRecord)
428  return;
429 
430  if (m_child)
431  m_child->Close();
432 
433  SchedOptMixin::Save();
434 
435  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
436  auto *schedoptedit = new SchedOptEditor(mainStack, *this,
437  *m_recordingRule, m_recInfo);
438  if (!schedoptedit->Create())
439  {
440  delete schedoptedit;
441  return;
442  }
443 
444  m_view = kSchedOptView;
445  m_child = schedoptedit;
446  mainStack->AddScreen(schedoptedit);
447 }
448 
449 void ScheduleEditor::ShowStoreOpt()
450 {
451  if (m_recordingRule->m_type == kNotRecording ||
452  m_recordingRule->m_type == kDontRecord)
453  return;
454 
455  if (m_child)
456  m_child->Close();
457 
458  StoreOptMixin::Save();
459 
460  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
461  auto *storeoptedit = new StoreOptEditor(mainStack, *this,
462  *m_recordingRule, m_recInfo);
463  if (!storeoptedit->Create())
464  {
465  delete storeoptedit;
466  return;
467  }
468 
469  m_view = kStoreOptView;
470  m_child = storeoptedit;
471  mainStack->AddScreen(storeoptedit);
472 }
473 
474 void ScheduleEditor::ShowPostProc()
475 {
476  if (m_recordingRule->m_type == kNotRecording ||
477  m_recordingRule->m_type == kDontRecord)
478  return;
479 
480  if (m_child)
481  m_child->Close();
482 
483  PostProcMixin::Save();
484 
485  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
486  auto *ppedit = new PostProcEditor(mainStack, *this,
487  *m_recordingRule, m_recInfo);
488  if (!ppedit->Create())
489  {
490  delete ppedit;
491  return;
492  }
493 
494  m_view = kPostProcView;
495  m_child = ppedit;
496  mainStack->AddScreen(ppedit);
497 }
498 
499 void ScheduleEditor::ShowSchedInfo()
500 {
501  if (m_recordingRule->m_type == kTemplateRecord)
502  return;
503 
504  QString label = tr("Schedule Information");
505 
506  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
507  auto *menuPopup = new MythDialogBox(label, popupStack, "menuPopup");
508 
509  if (menuPopup->Create())
510  {
511  menuPopup->SetReturnEvent(this, "schedinfo");
512 
513  if (m_recInfo)
514  menuPopup->AddButton(tr("Program Details"));
515  menuPopup->AddButton(tr("Upcoming Episodes"));
516  menuPopup->AddButton(tr("Upcoming Recordings"));
517  if (m_recordingRule->m_type != kTemplateRecord)
518  menuPopup->AddButton(tr("Previously Recorded"));
519 
520  popupStack->AddScreen(menuPopup);
521  }
522  else
523  delete menuPopup;
524 }
525 
526 bool ScheduleEditor::keyPressEvent(QKeyEvent *event)
527 {
528  if (GetFocusWidget()->keyPressEvent(event))
529  return true;
530 
531  QStringList actions;
532  bool handled = GetMythMainWindow()->
533  TranslateKeyPress("TV Frontend", event, actions);
534 
535  for (int i = 0; i < actions.size() && !handled; i++)
536  {
537  QString action = actions[i];
538  handled = true;
539 
540  if (action == "MENU")
541  showMenu();
542  else if (action == "INFO")
543  ShowDetails();
544  else if (action == "GUIDE")
545  ShowGuide();
546  else if (action == "UPCOMING")
547  showUpcomingByTitle();
548  else if (action == "PREVVIEW")
549  ShowPreviousView();
550  else if (action == "NEXTVIEW")
551  ShowNextView();
552  else
553  handled = false;
554  }
555 
556  if (!handled && MythScreenType::keyPressEvent(event))
557  handled = true;
558 
559  return handled;
560 }
561 
562 void ScheduleEditor::customEvent(QEvent *event)
563 {
564  if (event->type() == DialogCompletionEvent::kEventType)
565  {
566  auto *dce = (DialogCompletionEvent*)(event);
567 
568  QString resultid = dce->GetId();
569  QString resulttext = dce->GetResultText();
570 
571  if (resultid == "menu")
572  {
573  if (resulttext == tr("Main Options"))
574  m_child->Close();
575  if (resulttext == tr("Schedule Options"))
576  ShowSchedOpt();
577  else if (resulttext == tr("Filter Options"))
578  ShowFilters();
579  else if (resulttext == tr("Storage Options"))
580  ShowStoreOpt();
581  else if (resulttext == tr("Post Processing"))
582  ShowPostProc();
583  else if (resulttext == tr("Metadata Options"))
584  ShowMetadataOptions();
585  else if (resulttext == tr("Use Template"))
586  showTemplateMenu();
587  else if (resulttext == tr("Schedule Info"))
588  ShowSchedInfo();
589  else if (resulttext == tr("Preview Changes"))
590  ShowPreview();
591  }
592  else if (resultid == "templatemenu")
593  {
594  LoadTemplate(resulttext);
595  }
596  else if (resultid == "schedinfo")
597  {
598  if (resulttext == tr("Program Details"))
599  ShowDetails();
600  else if (resulttext == tr("Upcoming Episodes"))
601  showUpcomingByTitle();
602  else if (resulttext == tr("Upcoming Recordings"))
603  showUpcomingByRule();
604  else if (resulttext == tr("Previously Recorded"))
605  ShowPrevious(m_recordingRule->m_recordID,
606  m_recordingRule->m_title);
607  }
608  else if (resultid == "newrecgroup")
609  {
610  int groupID = CreateRecordingGroup(resulttext);
611  StoreOptMixin::SetRecGroup(groupID, resulttext);
612  }
613  }
614 }
615 
616 void ScheduleEditor::showUpcomingByRule(void)
617 {
618  if (m_recordingRule->m_type == kTemplateRecord)
619  return;
620 
621  // No rule? Search by title
622  if (m_recordingRule->m_recordID <= 0)
623  {
624  showUpcomingByTitle();
625  return;
626  }
627 
628  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
629  auto *pl = new ProgLister(mainStack, plRecordid,
630  QString::number(m_recordingRule->m_recordID), "");
631 
632  if (pl->Create())
633  mainStack->AddScreen(pl);
634  else
635  delete pl;
636 }
637 
638 void ScheduleEditor::showUpcomingByTitle(void)
639 {
640  if (m_recordingRule->m_type == kTemplateRecord)
641  return;
642 
643  // Existing rule and search? Search by rule
644  if (m_recordingRule->m_recordID > 0 &&
645  m_recordingRule->m_searchType != kNoSearch)
646  showUpcomingByRule();
647 
648  QString title = m_recordingRule->m_title;
649 
650  if (m_recordingRule->m_searchType != kNoSearch)
651  title.remove(QRegExp(" \\(.*\\)$"));
652 
653  ShowUpcoming(title, m_recordingRule->m_seriesid);
654 }
655 
656 void ScheduleEditor::ShowPreview(void)
657 {
658  if (m_recordingRule->m_type == kTemplateRecord)
659  return;
660 
661  if (m_child)
662  {
663  m_child->Save();
664  if (m_view == kSchedOptView)
665  SchedOptMixin::Load();
666  else if (m_view == kStoreOptView)
667  StoreOptMixin::Load();
668  else if (m_view == kPostProcView)
669  PostProcMixin::Load();
670  }
671 
672  SchedOptMixin::Save();
673  FilterOptMixin::Save();
674  StoreOptMixin::Save();
675  PostProcMixin::Save();
676 
677  QString ttable = "record_tmp";
678  m_recordingRule->UseTempTable(true, ttable);
679 
680  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
681  auto *vsd = new ViewScheduleDiff(mainStack, ttable,
682  m_recordingRule->m_tempID,
683  m_recordingRule->m_title);
684  if (vsd->Create())
685  mainStack->AddScreen(vsd);
686  else
687  delete vsd;
688 
689  m_recordingRule->UseTempTable(false);
690 }
691 
692 void ScheduleEditor::ShowMetadataOptions(void)
693 {
694  if (m_recordingRule->m_type == kNotRecording ||
695  m_recordingRule->m_type == kDontRecord ||
696  m_recordingRule->m_type == kTemplateRecord)
697  return;
698 
699  if (m_child)
700  m_child->Close();
701 
702  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
703  auto *rad = new MetadataOptions(mainStack, *this,
704  *m_recordingRule, m_recInfo);
705  if (!rad->Create())
706  {
707  delete rad;
708  return;
709  }
710 
711  m_view = kMetadataView;
712  m_child = rad;
713  mainStack->AddScreen(rad);
714 }
715 
716 void ScheduleEditor::ShowFilters(void)
717 {
718  if (m_recordingRule->m_type == kNotRecording ||
719  m_recordingRule->m_type == kDontRecord)
720  return;
721 
722  if (m_child)
723  m_child->Close();
724 
725  FilterOptMixin::Save();
726 
727  MythScreenStack *mainStack = GetMythMainWindow()->GetMainStack();
728  auto *schedfilteredit = new SchedFilterEditor(mainStack, *this,
729  *m_recordingRule, m_recInfo);
730  if (!schedfilteredit->Create())
731  {
732  delete schedfilteredit;
733  return;
734  }
735 
736  m_view = kFilterView;
737  m_child = schedfilteredit;
738  mainStack->AddScreen(schedfilteredit);
739 }
740 
741 void ScheduleEditor::ShowPreviousView(void)
742 {
743  if (m_recordingRule->m_type == kNotRecording ||
744  m_recordingRule->m_type == kDontRecord)
745  return;
746 
747  if (m_view == kMainView && !m_recordingRule->m_isTemplate)
748  ShowMetadataOptions();
749  else if ((m_view == kMainView) || (m_view == kMetadataView))
750  ShowPostProc();
751  else if (m_view == kSchedOptView)
752  m_child->Close();
753  else if (m_view == kFilterView)
754  ShowSchedOpt();
755  else if (m_view == kStoreOptView)
756  ShowFilters();
757  else if (m_view == kPostProcView)
758  ShowStoreOpt();
759 }
760 
761 void ScheduleEditor::ShowNextView(void)
762 {
763  if (m_recordingRule->m_type == kNotRecording ||
764  m_recordingRule->m_type == kDontRecord)
765  return;
766 
767  if (m_view == kMainView)
768  ShowSchedOpt();
769  else if (m_view == kSchedOptView)
770  ShowFilters();
771  else if (m_view == kFilterView)
772  ShowStoreOpt();
773  else if (m_view == kStoreOptView)
774  ShowPostProc();
775  else if (m_view == kPostProcView && !m_recordingRule->m_isTemplate)
776  ShowMetadataOptions();
777  else if ((m_view == kPostProcView) || (m_view == kMetadataView))
778  m_child->Close();
779 }
780 
781 void ScheduleEditor::ChildClosing(void)
782 {
783  if (m_view == kSchedOptView)
784  SchedOptMixin::Load();
785  else if (m_view == kFilterView)
786  FilterOptMixin::Load();
787  else if (m_view == kStoreOptView)
788  StoreOptMixin::Load();
789  else if (m_view == kPostProcView)
790  PostProcMixin::Load();
791 
792  m_child = nullptr;
793  m_view = kMainView;
794 }
795 
796 void ScheduleEditor::showMenu(void)
797 {
798  QString label = tr("Options");
799  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
800  auto *menuPopup = new MythDialogBox(label, popupStack, "menuPopup");
801 
802  MythUIButtonListItem *item = m_rulesList->GetItemCurrent();
803  RecordingType type = static_cast<RecordingType>(item->GetData().toInt());
804  bool isScheduled = (type != kNotRecording && type != kDontRecord);
805 
806  if (menuPopup->Create())
807  {
808  menuPopup->SetReturnEvent(this, "menu");
809  if (m_view != kMainView)
810  menuPopup->AddButton(tr("Main Options"));
811  if (isScheduled && m_view != kSchedOptView)
812  menuPopup->AddButton(tr("Schedule Options"));
813  if (isScheduled && m_view != kFilterView)
814  menuPopup->AddButton(tr("Filter Options"));
815  if (isScheduled && m_view != kStoreOptView)
816  menuPopup->AddButton(tr("Storage Options"));
817  if (isScheduled && m_view != kPostProcView)
818  menuPopup->AddButton(tr("Post Processing"));
819  if (isScheduled && !m_recordingRule->m_isTemplate &&
820  m_view != kMetadataView)
821  menuPopup->AddButton(tr("Metadata Options"));
822  if (!m_recordingRule->m_isTemplate)
823  menuPopup->AddButton(tr("Schedule Info"));
824  if (!m_recordingRule->m_isTemplate)
825  menuPopup->AddButton(tr("Preview Changes"));
826  menuPopup->AddButton(tr("Use Template"));
827  popupStack->AddScreen(menuPopup);
828  }
829  else
830  {
831  delete menuPopup;
832  }
833 }
834 
835 void ScheduleEditor::showTemplateMenu(void)
836 {
837  QStringList templates = RecordingRule::GetTemplateNames();
838  if (templates.empty())
839  {
840  ShowOkPopup(tr("No templates available"));
841  return;
842  }
843 
844  QString label = tr("Template Options");
845  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
846  auto *menuPopup = new MythDialogBox(label, popupStack, "menuPopup");
847 
848  if (menuPopup->Create())
849  {
850  menuPopup->SetReturnEvent(this, "templatemenu");
851  while (!templates.empty())
852  {
853  QString name = templates.front();
854  if (name == "Default")
855  menuPopup->AddButton(tr("Default"));
856  else
857  menuPopup->AddButton(name);
858  templates.pop_front();
859  }
860  popupStack->AddScreen(menuPopup);
861  }
862  else
863  {
864  delete menuPopup;
865  }
866 }
867 
869 
874 SchedEditChild::SchedEditChild(MythScreenStack *parent, const QString &name,
875  ScheduleEditor &editor, RecordingRule &rule,
876  RecordingInfo *recInfo)
877  : MythScreenType(parent, name),
878  m_editor(&editor), m_recordingRule(&rule), m_recInfo(recInfo)
879 {
880 }
881 
882 bool SchedEditChild::keyPressEvent(QKeyEvent *event)
883 {
884  if (GetFocusWidget()->keyPressEvent(event))
885  return true;
886 
887  QStringList actions;
888  bool handled = GetMythMainWindow()->
889  TranslateKeyPress("TV Frontend", event, actions);
890 
891  for (int i = 0; i < actions.size() && !handled; i++)
892  {
893  QString action = actions[i];
894  handled = true;
895 
896  if (action == "MENU")
897  m_editor->showMenu();
898  else if (action == "INFO")
899  m_editor->ShowDetails();
900  else if (action == "UPCOMING")
901  m_editor->showUpcomingByTitle();
902  if (action == "ESCAPE")
903  Close();
904  else if (action == "PREVVIEW")
905  m_editor->ShowPreviousView();
906  else if (action == "NEXTVIEW")
907  m_editor->ShowNextView();
908  else
909  handled = false;
910  }
911 
912  if (!handled && MythScreenType::keyPressEvent(event))
913  handled = true;
914 
915  return handled;
916 }
917 
918 bool SchedEditChild::CreateEditChild(
919  const QString &xmlfile, const QString &winname, bool isTemplate)
920 {
921  if (!LoadWindowFromXML(xmlfile, winname, this))
922  return false;
923 
924  UIUtilW::Assign(this, m_backButton, "back");
925  UIUtilW::Assign(this, m_saveButton, "save");
926  UIUtilW::Assign(this, m_previewButton, "preview");
927 
928  connect(this, SIGNAL(Closing()), m_editor, SLOT(ChildClosing()));
929  connect(m_editor, SIGNAL(templateLoaded()), SLOT(Load()));
930 
931  if (m_backButton)
932  connect(m_backButton, SIGNAL(Clicked()), SLOT(Close()));
933  if (m_saveButton)
934  connect(m_saveButton, SIGNAL(Clicked()), m_editor, SLOT(Save()));
935  if (m_previewButton)
936  connect(m_previewButton, SIGNAL(Clicked()),
937  m_editor, SLOT(ShowPreview()));
938 
939  if (m_previewButton)
940  m_previewButton->SetEnabled(!isTemplate);
941 
942  return true;
943 }
944 
945 void SchedEditChild::SetTextFromMaps(void)
946 {
947  InfoMap progMap;
948 
949  m_recordingRule->ToMap(progMap);
950 
951  if (m_recInfo)
952  m_recInfo->ToMap(progMap);
953 
954  SetTextFromMap(progMap);
955 }
956 
957 void SchedEditChild::Close(void)
958 {
959  Save();
960  emit Closing();
961  MythScreenType::Close();
962 }
963 
965 
971 SchedOptEditor::SchedOptEditor(MythScreenStack *parent,
972  ScheduleEditor &editor,
973  RecordingRule &rule,
974  RecordingInfo *recInfo)
975  : SchedEditChild(parent, "ScheduleOptionsEditor", editor, rule, recInfo),
976  SchedOptMixin(*this, &rule, &editor)
977 {
978 }
979 
980 bool SchedOptEditor::Create()
981 {
982  if (!SchedEditChild::CreateEditChild(
983  "schedule-ui.xml", "scheduleoptionseditor",
984  m_recordingRule->m_isTemplate))
985  {
986  return false;
987  }
988 
989  bool err = false;
990 
991  SchedOptMixin::Create(&err);
992 
993  UIUtilW::Assign(this, m_filtersButton, "filters");
994 
995  if (err)
996  {
997  LOG(VB_GENERAL, LOG_ERR, "SchedOptEditor, theme is missing "
998  "required elements");
999  return false;
1000  }
1001 
1002  if (m_dupmethodList)
1003  connect(m_dupmethodList, SIGNAL(itemSelected(MythUIButtonListItem *)),
1004  SLOT(DupMethodChanged(MythUIButtonListItem *)));
1005 
1006  if (m_filtersButton)
1007  connect(m_filtersButton, SIGNAL(Clicked()),
1008  m_editor, SLOT(ShowFilters()));
1009 
1010  BuildFocusList();
1011 
1012  return true;
1013 }
1014 
1015 void SchedOptEditor::Load()
1016 {
1017  SchedOptMixin::Load();
1018  SetTextFromMaps();
1019 }
1020 
1021 void SchedOptEditor::Save()
1022 {
1023  SchedOptMixin::Save();
1024 }
1025 
1026 void SchedOptEditor::DupMethodChanged(MythUIButtonListItem *item)
1027 {
1028  SchedOptMixin::DupMethodChanged(item);
1029 }
1030 
1032 
1038 SchedFilterEditor::SchedFilterEditor(MythScreenStack *parent,
1039  ScheduleEditor &editor,
1040  RecordingRule &rule,
1041  RecordingInfo *recInfo)
1042  : SchedEditChild(parent, "ScheduleFilterEditor", editor, rule, recInfo),
1043  FilterOptMixin(*this, &rule, &editor)
1044 {
1045 }
1046 
1047 bool SchedFilterEditor::Create()
1048 {
1049  if (!SchedEditChild::CreateEditChild(
1050  "schedule-ui.xml", "schedulefiltereditor",
1051  m_recordingRule->m_isTemplate))
1052  {
1053  return false;
1054  }
1055 
1056  bool err = false;
1057 
1058  FilterOptMixin::Create(&err);
1059 
1060  if (err)
1061  {
1062  LOG(VB_GENERAL, LOG_ERR, "SchedFilterEditor, theme is missing "
1063  "required elements");
1064  return false;
1065  }
1066 
1067  connect(m_filtersList, SIGNAL(itemClicked(MythUIButtonListItem *)),
1068  SLOT(ToggleSelected(MythUIButtonListItem *)));
1069 
1070  BuildFocusList();
1071 
1072  return true;
1073 }
1074 
1075 void SchedFilterEditor::Load(void)
1076 {
1077  FilterOptMixin::Load();
1078  SetTextFromMaps();
1079 }
1080 
1081 void SchedFilterEditor::Save()
1082 {
1083  FilterOptMixin::Save();
1084 }
1085 
1086 void SchedFilterEditor::ToggleSelected(MythUIButtonListItem *item)
1087 {
1088  FilterOptMixin::ToggleSelected(item);
1089 }
1090 
1092 
1098 StoreOptEditor::StoreOptEditor(MythScreenStack *parent,
1099  ScheduleEditor &editor,
1100  RecordingRule &rule,
1101  RecordingInfo *recInfo)
1102  : SchedEditChild(parent, "StorageOptionsEditor", editor, rule, recInfo),
1103  StoreOptMixin(*this, &rule, &editor)
1104 {
1105 }
1106 
1107 bool StoreOptEditor::Create()
1108 {
1109  if (!SchedEditChild::CreateEditChild(
1110  "schedule-ui.xml", "storageoptionseditor",
1111  m_recordingRule->m_isTemplate))
1112  {
1113  return false;
1114  }
1115 
1116  bool err = false;
1117 
1118  StoreOptMixin::Create(&err);
1119 
1120  if (err)
1121  {
1122  LOG(VB_GENERAL, LOG_ERR, "StoreOptEditor, theme is missing "
1123  "required elements");
1124  return false;
1125  }
1126 
1127  if (m_maxepSpin)
1128  connect(m_maxepSpin, SIGNAL(itemSelected(MythUIButtonListItem *)),
1129  SLOT(MaxEpisodesChanged(MythUIButtonListItem *)));
1130  if (m_recgroupList)
1131  connect(m_recgroupList, SIGNAL(LosingFocus()),
1132  SLOT(PromptForRecGroup()));
1133 
1134  BuildFocusList();
1135 
1136  return true;
1137 }
1138 
1139 void StoreOptEditor::Load()
1140 {
1141  StoreOptMixin::Load();
1142  SetTextFromMaps();
1143 }
1144 
1145 void StoreOptEditor::MaxEpisodesChanged(MythUIButtonListItem *item)
1146 {
1147  StoreOptMixin::MaxEpisodesChanged(item);
1148 }
1149 
1150 void StoreOptEditor::PromptForRecGroup(void)
1151 {
1152  StoreOptMixin::PromptForRecGroup();
1153 }
1154 
1155 void StoreOptEditor::customEvent(QEvent *event)
1156 {
1157  if (event->type() == DialogCompletionEvent::kEventType)
1158  {
1159  auto *dce = (DialogCompletionEvent*)(event);
1160 
1161  QString resultid = dce->GetId();
1162  QString resulttext = dce->GetResultText();
1163 
1164  if (resultid == "newrecgroup")
1165  {
1166  int groupID = CreateRecordingGroup(resulttext);
1167  StoreOptMixin::SetRecGroup(groupID, resulttext);
1168  }
1169  }
1170 }
1171 
1172 void StoreOptEditor::Save()
1173 {
1174  StoreOptMixin::Save();
1175 }
1176 
1178 
1184 PostProcEditor::PostProcEditor(MythScreenStack *parent,
1185  ScheduleEditor &editor,
1186  RecordingRule &rule,
1187  RecordingInfo *recInfo)
1188  : SchedEditChild(parent, "PostProcOptionsEditor", editor, rule, recInfo),
1189  PostProcMixin(*this, &rule, &editor)
1190 {
1191 }
1192 
1193 bool PostProcEditor::Create()
1194 {
1195  if (!SchedEditChild::CreateEditChild(
1196  "schedule-ui.xml", "postproceditor",
1197  m_recordingRule->m_isTemplate))
1198  {
1199  return false;
1200  }
1201 
1202  bool err = false;
1203 
1204  PostProcMixin::Create(&err);
1205 
1206  if (err)
1207  {
1208  LOG(VB_GENERAL, LOG_ERR, "PostProcEditor, theme is missing "
1209  "required elements");
1210  return false;
1211  }
1212 
1213  if (m_transcodeCheck)
1214  connect(m_transcodeCheck, SIGNAL(toggled(bool)),
1215  SLOT(TranscodeChanged(bool)));
1216 
1217  BuildFocusList();
1218 
1219  return true;
1220 }
1221 
1222 void PostProcEditor::Load()
1223 {
1224  PostProcMixin::Load();
1225  SetTextFromMaps();
1226 }
1227 
1228 void PostProcEditor::TranscodeChanged(bool enable)
1229 {
1230  PostProcMixin::TranscodeChanged(enable);
1231 }
1232 
1233 void PostProcEditor::Save()
1234 {
1235  PostProcMixin::Save();
1236 }
1237 
1239 
1245 MetadataOptions::MetadataOptions(MythScreenStack *parent,
1246  ScheduleEditor &editor,
1247  RecordingRule &rule,
1248  RecordingInfo *recInfo)
1249  : SchedEditChild(parent, "MetadataOptions", editor, rule, recInfo)
1250 {
1251  m_popupStack = GetMythMainWindow()->GetStack("popup stack");
1252 
1253  m_metadataFactory = new MetadataFactory(this);
1254  m_imageLookup = new MetadataDownload(this);
1255  m_imageDownload = new MetadataImageDownload(this);
1256 
1257  m_artworkMap = GetArtwork(m_recordingRule->m_inetref,
1258  m_recordingRule->m_season);
1259 }
1260 
1261 MetadataOptions::~MetadataOptions(void)
1262 {
1263  if (m_imageLookup)
1264  {
1265  m_imageLookup->cancel();
1266  delete m_imageLookup;
1267  m_imageLookup = nullptr;
1268  }
1269 
1270  if (m_imageDownload)
1271  {
1272  m_imageDownload->cancel();
1273  delete m_imageDownload;
1274  m_imageDownload = nullptr;
1275  }
1276 }
1277 
1278 bool MetadataOptions::Create()
1279 {
1280  if (!SchedEditChild::CreateEditChild(
1281  "schedule-ui.xml", "metadataoptions",
1282  m_recordingRule->m_isTemplate))
1283  {
1284  return false;
1285  }
1286 
1287  bool err = false;
1288 
1289  UIUtilE::Assign(this, m_inetrefEdit, "inetref_edit", &err);
1290  UIUtilW::Assign(this, m_inetrefClear, "inetref_clear", &err);
1291  UIUtilE::Assign(this, m_seasonSpin, "season_spinbox", &err);
1292  UIUtilE::Assign(this, m_episodeSpin, "episode_spinbox", &err);
1293  UIUtilE::Assign(this, m_queryButton, "query_button", &err);
1294  UIUtilE::Assign(this, m_localFanartButton, "local_fanart_button", &err);
1295  UIUtilE::Assign(this, m_localCoverartButton, "local_coverart_button", &err);
1296  UIUtilE::Assign(this, m_localBannerButton, "local_banner_button", &err);
1297  UIUtilE::Assign(this, m_onlineFanartButton, "online_fanart_button", &err);
1298  UIUtilE::Assign(this, m_onlineCoverartButton, "online_coverart_button", &err);
1299  UIUtilE::Assign(this, m_onlineBannerButton, "online_banner_button", &err);
1300  UIUtilW::Assign(this, m_fanart, "fanart");
1301  UIUtilW::Assign(this, m_coverart, "coverart");
1302  UIUtilW::Assign(this, m_banner, "banner");
1303 
1304  if (err)
1305  {
1306  LOG(VB_GENERAL, LOG_ERR, "MetadataOptions, theme is missing "
1307  "required elements");
1308  return false;
1309  }
1310 
1311  connect(m_inetrefClear, SIGNAL(Clicked()),
1312  SLOT(ClearInetref()));
1313  connect(m_queryButton, SIGNAL(Clicked()),
1314  SLOT(PerformQuery()));
1315  connect(m_localFanartButton, SIGNAL(Clicked()),
1316  SLOT(SelectLocalFanart()));
1317  connect(m_localCoverartButton, SIGNAL(Clicked()),
1318  SLOT(SelectLocalCoverart()));
1319  connect(m_localBannerButton, SIGNAL(Clicked()),
1320  SLOT(SelectLocalBanner()));
1321  connect(m_onlineFanartButton, SIGNAL(Clicked()),
1322  SLOT(SelectOnlineFanart()));
1323  connect(m_onlineCoverartButton, SIGNAL(Clicked()),
1324  SLOT(SelectOnlineCoverart()));
1325  connect(m_onlineBannerButton, SIGNAL(Clicked()),
1326  SLOT(SelectOnlineBanner()));
1327 
1328  connect(m_seasonSpin, SIGNAL(itemSelected(MythUIButtonListItem*)),
1329  SLOT(ValuesChanged()));
1330 
1331  // InetRef
1332  m_inetrefEdit->SetText(m_recordingRule->m_inetref);
1333 
1334  // Season
1335  m_seasonSpin->SetRange(0,9999,1,5);
1336  m_seasonSpin->SetValue(m_recordingRule->m_season != 0 ? m_recordingRule->m_season : m_recInfo ? m_recInfo->GetSeason() : 0);
1337 
1338  // Episode
1339  m_episodeSpin->SetRange(0,9999,1,10);
1340  m_episodeSpin->SetValue(m_recordingRule->m_episode != 0 ? m_recordingRule->m_episode : m_recInfo ? m_recInfo->GetEpisode() : 0);
1341 
1342  if (m_coverart)
1343  {
1344  m_coverart->SetFilename(m_artworkMap.value(kArtworkCoverart).url);
1345  m_coverart->Load();
1346  }
1347 
1348  if (m_fanart)
1349  {
1350  m_fanart->SetFilename(m_artworkMap.value(kArtworkFanart).url);
1351  m_fanart->Load();
1352  }
1353 
1354  if (m_banner)
1355  {
1356  m_banner->SetFilename(m_artworkMap.value(kArtworkBanner).url);
1357  m_banner->Load();
1358  }
1359 
1360  BuildFocusList();
1361 
1362  return true;
1363 }
1364 
1365 void MetadataOptions::Load()
1366 {
1367  SetTextFromMaps();
1368 }
1369 
1370 void MetadataOptions::CreateBusyDialog(const QString& title)
1371 {
1372  if (m_busyPopup)
1373  return;
1374 
1375  const QString& message = title;
1376 
1377  m_busyPopup = new MythUIBusyDialog(message, m_popupStack,
1378  "metaoptsdialog");
1379 
1380  if (m_busyPopup->Create())
1381  m_popupStack->AddScreen(m_busyPopup);
1382 }
1383 
1384 void MetadataOptions::ClearInetref()
1385 {
1386  m_recordingRule->m_inetref.clear();
1387  m_inetrefEdit->SetText(m_recordingRule->m_inetref);
1388 }
1389 
1390 void MetadataOptions::PerformQuery()
1391 {
1392  CreateBusyDialog(tr("Trying to manually find this "
1393  "recording online..."));
1394 
1395  MetadataLookup *lookup = CreateLookup(kMetadataRecording);
1396 
1397  lookup->SetAutomatic(false);
1398  m_metadataFactory->Lookup(lookup);
1399 }
1400 
1401 void MetadataOptions::OnSearchListSelection(const RefCountHandler<MetadataLookup>& lookup)
1402 {
1403  QueryComplete(lookup);
1404 }
1405 
1406 void MetadataOptions::OnImageSearchListSelection(const ArtworkInfo& info,
1407  VideoArtworkType type)
1408 {
1409  QString msg = tr("Downloading selected artwork...");
1410  CreateBusyDialog(msg);
1411 
1412  auto *lookup = new MetadataLookup();
1413 
1414  lookup->SetType(kMetadataVideo);
1415  lookup->SetHost(gCoreContext->GetMasterHostName());
1416  lookup->SetAutomatic(true);
1417  lookup->SetData(QVariant::fromValue<VideoArtworkType>(type));
1418 
1419  ArtworkMap downloads;
1420  downloads.insert(type, info);
1421  lookup->SetDownloads(downloads);
1422  lookup->SetAllowOverwrites(true);
1423  lookup->SetTitle(m_recordingRule->m_title);
1424  lookup->SetSubtitle(m_recordingRule->m_subtitle);
1425  lookup->SetInetref(m_inetrefEdit->GetText());
1426  lookup->SetSeason(m_seasonSpin->GetIntValue());
1427  lookup->SetEpisode(m_episodeSpin->GetIntValue());
1428 
1429  m_imageDownload->addDownloads(lookup);
1430 }
1431 
1432 void MetadataOptions::SelectLocalFanart()
1433 {
1434  if (!CanSetArtwork())
1435  return;
1436 
1437  QString url = generate_file_url("Fanart",
1438  gCoreContext->GetMasterHostName(),
1439  "");
1440  FindImagePopup(url,"",*this, "fanart");
1441 }
1442 
1443 void MetadataOptions::SelectLocalCoverart()
1444 {
1445  if (!CanSetArtwork())
1446  return;
1447 
1448  QString url = generate_file_url("Coverart",
1449  gCoreContext->GetMasterHostName(),
1450  "");
1451  FindImagePopup(url,"",*this, "coverart");
1452 }
1453 
1454 void MetadataOptions::SelectLocalBanner()
1455 {
1456  if (!CanSetArtwork())
1457  return;
1458 
1459  QString url = generate_file_url("Banners",
1460  gCoreContext->GetMasterHostName(),
1461  "");
1462  FindImagePopup(url,"",*this, "banner");
1463 }
1464 
1465 void MetadataOptions::SelectOnlineFanart()
1466 {
1467  FindNetArt(kArtworkFanart);
1468 }
1469 
1470 void MetadataOptions::SelectOnlineCoverart()
1471 {
1472  FindNetArt(kArtworkCoverart);
1473 }
1474 
1475 void MetadataOptions::SelectOnlineBanner()
1476 {
1477  FindNetArt(kArtworkBanner);
1478 }
1479 
1480 void MetadataOptions::Save()
1481 {
1482  // Season
1483  if (m_seasonSpin)
1484  m_recordingRule->m_season = m_seasonSpin->GetIntValue();
1485 
1486  // Episode
1487  if (m_episodeSpin)
1488  m_recordingRule->m_episode = m_episodeSpin->GetIntValue();
1489 
1490  // InetRef
1491  if (m_inetrefEdit)
1492  m_recordingRule->m_inetref = m_inetrefEdit->GetText();
1493 }
1494 
1495 void MetadataOptions::QueryComplete(MetadataLookup *lookup)
1496 {
1497  if (!lookup)
1498  return;
1499 
1500  // InetRef
1501  m_inetrefEdit->SetText(lookup->GetInetref());
1502 
1503  // Season
1504  m_seasonSpin->SetValue(lookup->GetSeason());
1505 
1506  // Episode
1507  m_episodeSpin->SetValue(lookup->GetEpisode());
1508 
1509  InfoMap metadataMap;
1510  lookup->toMap(metadataMap);
1511  SetTextFromMap(metadataMap);
1512 }
1513 
1514 void MetadataOptions::FindImagePopup(const QString &prefix,
1515  const QString &prefixAlt,
1516  QObject &inst,
1517  const QString &returnEvent)
1518 {
1519  QString fp;
1520 
1521  if (prefix.startsWith("myth://"))
1522  fp = prefix;
1523  else
1524  fp = prefix.isEmpty() ? prefixAlt : prefix;
1525 
1526  MythScreenStack *popupStack =
1527  GetMythMainWindow()->GetStack("popup stack");
1528 
1529  auto *fb = new MythUIFileBrowser(popupStack, fp);
1530  fb->SetNameFilter(GetSupportedImageExtensionFilter());
1531  if (fb->Create())
1532  {
1533  fb->SetReturnEvent(&inst, returnEvent);
1534  popupStack->AddScreen(fb);
1535  }
1536  else
1537  delete fb;
1538 }
1539 
1540 QStringList MetadataOptions::GetSupportedImageExtensionFilter()
1541 {
1542  QStringList ret;
1543 
1544  QList<QByteArray> exts = QImageReader::supportedImageFormats();
1545  for (const auto & ext : qAsConst(exts))
1546  {
1547  ret.append(QString("*.").append(ext));
1548  }
1549 
1550  return ret;
1551 }
1552 
1553 bool MetadataOptions::CanSetArtwork()
1554 {
1555  if (m_inetrefEdit->GetText().isEmpty())
1556  {
1557  ShowOkPopup(tr("You must set a reference number "
1558  "on this rule to set artwork. For items "
1559  "without a metadata source, you can set "
1560  "any unique value."));
1561  return false;
1562  }
1563 
1564  return true;
1565 }
1566 
1567 MetadataLookup *MetadataOptions::CreateLookup(MetadataType mtype)
1568 {
1569  auto *lookup = new MetadataLookup();
1570  lookup->SetStep(kLookupSearch);
1571  lookup->SetType(mtype);
1572  LookupType type = GuessLookupType(m_inetrefEdit->GetText());
1573 
1574  if (type == kUnknownVideo)
1575  {
1576  if ((m_recInfo && m_recInfo->GetCategoryType() == ProgramInfo::kCategoryMovie) ||
1577  (m_seasonSpin->GetIntValue() == 0 &&
1578  m_episodeSpin->GetIntValue() == 0))
1579  {
1580  lookup->SetSubtype(kProbableMovie);
1581  }
1582  else
1583  {
1584  lookup->SetSubtype(kProbableTelevision);
1585  }
1586  }
1587  else
1588  {
1589  // we could determine the type from the inetref
1590  lookup->SetSubtype(type);
1591  }
1592  lookup->SetAllowGeneric(true);
1593  lookup->SetHandleImages(false);
1594  lookup->SetHost(gCoreContext->GetMasterHostName());
1595  lookup->SetTitle(m_recordingRule->m_title);
1596  lookup->SetSubtitle(m_recordingRule->m_subtitle);
1597  lookup->SetInetref(m_inetrefEdit->GetText());
1598  lookup->SetCollectionref(m_inetrefEdit->GetText());
1599  lookup->SetSeason(m_seasonSpin->GetIntValue());
1600  lookup->SetEpisode(m_episodeSpin->GetIntValue());
1601 
1602  return lookup;
1603 }
1604 
1605 void MetadataOptions::FindNetArt(VideoArtworkType type)
1606 {
1607  if (!CanSetArtwork())
1608  return;
1609 
1610  QString msg = tr("Searching for available artwork...");
1611  CreateBusyDialog(msg);
1612 
1613  MetadataLookup *lookup = CreateLookup(kMetadataVideo);
1614 
1615  lookup->SetAutomatic(true);
1616  lookup->SetData(QVariant::fromValue<VideoArtworkType>(type));
1617  m_imageLookup->addLookup(lookup);
1618 }
1619 
1620 void MetadataOptions::OnArtworkSearchDone(MetadataLookup *lookup)
1621 {
1622  if (!lookup)
1623  return;
1624 
1625  if (m_busyPopup)
1626  {
1627  m_busyPopup->Close();
1628  m_busyPopup = nullptr;
1629  }
1630 
1631  auto type = lookup->GetData().value<VideoArtworkType>();
1632  ArtworkList list = lookup->GetArtwork(type);
1633 
1634  if (list.isEmpty())
1635  {
1636  MythWarningNotification n(tr("No image found"), tr("Schedule Editor"));
1637  GetNotificationCenter()->Queue(n);
1638  return;
1639  }
1640 
1641  auto *resultsdialog = new ImageSearchResultsDialog(m_popupStack, list, type);
1642 
1643  connect(resultsdialog, SIGNAL(haveResult(ArtworkInfo, VideoArtworkType)),
1644  SLOT(OnImageSearchListSelection(ArtworkInfo, VideoArtworkType)));
1645 
1646  if (resultsdialog->Create())
1647  m_popupStack->AddScreen(resultsdialog);
1648 }
1649 
1650 void MetadataOptions::HandleDownloadedImages(MetadataLookup *lookup)
1651 {
1652  if (!lookup)
1653  return;
1654 
1655  DownloadMap map = lookup->GetDownloads();
1656 
1657  if (map.isEmpty())
1658  return;
1659 
1660  for (DownloadMap::const_iterator i = map.cbegin(); i != map.cend(); ++i)
1661  {
1662  VideoArtworkType type = i.key();
1663  const ArtworkInfo& info = i.value();
1664 
1665  if (type == kArtworkCoverart)
1666  m_artworkMap.replace(kArtworkCoverart, info);
1667  else if (type == kArtworkFanart)
1668  m_artworkMap.replace(kArtworkFanart, info);
1669  else if (type == kArtworkBanner)
1670  m_artworkMap.replace(kArtworkBanner, info);
1671  }
1672 
1673  SetArtwork(m_inetrefEdit->GetText(), m_seasonSpin->GetIntValue(),
1674  gCoreContext->GetMasterHostName(), m_artworkMap);
1675 
1676  ValuesChanged();
1677 }
1678 
1679 void MetadataOptions::ValuesChanged()
1680 {
1681  m_artworkMap = GetArtwork(m_inetrefEdit->GetText(),
1682  m_seasonSpin->GetIntValue());
1683 
1684  if (m_coverart)
1685  {
1686  m_coverart->SetFilename(m_artworkMap.value(kArtworkCoverart).url);
1687  m_coverart->Load();
1688  }
1689 
1690  if (m_fanart)
1691  {
1692  m_fanart->SetFilename(m_artworkMap.value(kArtworkFanart).url);
1693  m_fanart->Load();
1694  }
1695 
1696  if (m_banner)
1697  {
1698  m_banner->SetFilename(m_artworkMap.value(kArtworkBanner).url);
1699  m_banner->Load();
1700  }
1701 }
1702 
1703 void MetadataOptions::customEvent(QEvent *levent)
1704 {
1705  if (levent->type() == MetadataFactoryMultiResult::kEventType)
1706  {
1707  if (m_busyPopup)
1708  {
1709  m_busyPopup->Close();
1710  m_busyPopup = nullptr;
1711  }
1712 
1713  auto *mfmr = dynamic_cast<MetadataFactoryMultiResult*>(levent);
1714  if (!mfmr)
1715  return;
1716 
1717  MetadataLookupList list = mfmr->m_results;
1718 
1719  if (list.count() > 1)
1720  {
1721  int yearindex = -1;
1722 
1723  for (int p = 0; p != list.size(); ++p)
1724  {
1725  if (!m_recordingRule->m_seriesid.isEmpty() &&
1726  m_recordingRule->m_seriesid == (list[p])->GetTMSref())
1727  {
1728  MetadataLookup *lookup = list[p];
1729  QueryComplete(lookup);
1730  return;
1731  }
1732  if (m_recInfo &&
1733  m_recInfo->GetYearOfInitialRelease() != 0 &&
1734  (list[p])->GetYear() != 0 &&
1735  m_recInfo->GetYearOfInitialRelease() == (list[p])->GetYear())
1736  {
1737  if (yearindex > -1)
1738  {
1739  LOG(VB_GENERAL, LOG_INFO, "Multiple results matched on year. No definite "
1740  "match could be found based on year alone.");
1741  yearindex = -2;
1742  }
1743  else if (yearindex == -1)
1744  {
1745  LOG(VB_GENERAL, LOG_INFO, "Matched based on year. ");
1746  yearindex = p;
1747  }
1748  }
1749  }
1750 
1751  if (yearindex > -1)
1752  {
1753  MetadataLookup *lookup = list[yearindex];
1754  QueryComplete(lookup);
1755  return;
1756  }
1757 
1758  LOG(VB_GENERAL, LOG_INFO, "Falling through to selection dialog.");
1759  auto *resultsdialog = new MetadataResultsDialog(m_popupStack, list);
1760 
1761  connect(resultsdialog, SIGNAL(haveResult(RefCountHandler<MetadataLookup>)),
1762  SLOT(OnSearchListSelection(RefCountHandler<MetadataLookup>)),
1763  Qt::QueuedConnection);
1764 
1765  if (resultsdialog->Create())
1766  m_popupStack->AddScreen(resultsdialog);
1767  }
1768  }
1769  else if (levent->type() == MetadataFactorySingleResult::kEventType)
1770  {
1771  if (m_busyPopup)
1772  {
1773  m_busyPopup->Close();
1774  m_busyPopup = nullptr;
1775  }
1776 
1777  auto *mfsr = dynamic_cast<MetadataFactorySingleResult*>(levent);
1778  if (!mfsr)
1779  return;
1780 
1781  MetadataLookup *lookup = mfsr->m_result;
1782 
1783  if (!lookup)
1784  return;
1785 
1786  QueryComplete(lookup);
1787  }
1788  else if (levent->type() == MetadataFactoryNoResult::kEventType)
1789  {
1790  if (m_busyPopup)
1791  {
1792  m_busyPopup->Close();
1793  m_busyPopup = nullptr;
1794  }
1795 
1796  auto *mfnr = dynamic_cast<MetadataFactoryNoResult*>(levent);
1797  if (!mfnr)
1798  return;
1799 
1800  QString title = tr("No match found for this recording. You can "
1801  "try entering a TVDB/TMDB number, season, and "
1802  "episode manually.");
1803 
1804  auto *okPopup = new MythConfirmationDialog(m_popupStack, title, false);
1805 
1806  if (okPopup->Create())
1807  m_popupStack->AddScreen(okPopup);
1808  }
1809  else if (levent->type() == MetadataLookupEvent::kEventType)
1810  {
1811  if (m_busyPopup)
1812  {
1813  m_busyPopup->Close();
1814  m_busyPopup = nullptr;
1815  }
1816 
1817  auto *lue = (MetadataLookupEvent *)levent;
1818 
1819  MetadataLookupList lul = lue->m_lookupList;
1820 
1821  if (lul.isEmpty())
1822  return;
1823 
1824  if (lul.count() >= 1)
1825  {
1826  OnArtworkSearchDone(lul[0]);
1827  }
1828  }
1829  else if (levent->type() == MetadataLookupFailure::kEventType)
1830  {
1831  if (m_busyPopup)
1832  {
1833  m_busyPopup->Close();
1834  m_busyPopup = nullptr;
1835  }
1836 
1837  auto *luf = (MetadataLookupFailure *)levent;
1838 
1839  MetadataLookupList lul = luf->m_lookupList;
1840 
1841  if (!lul.empty())
1842  {
1843  QString title = tr("This number, season, and episode combination "
1844  "does not appear to be valid (or the site may "
1845  "be down). Check your information and try "
1846  "again.");
1847 
1848  auto *okPopup = new MythConfirmationDialog(m_popupStack, title, false);
1849 
1850  if (okPopup->Create())
1851  m_popupStack->AddScreen(okPopup);
1852  }
1853  }
1854  else if (levent->type() == ImageDLEvent::kEventType)
1855  {
1856  if (m_busyPopup)
1857  {
1858  m_busyPopup->Close();
1859  m_busyPopup = nullptr;
1860  }
1861 
1862  auto *ide = (ImageDLEvent *)levent;
1863 
1864  MetadataLookup *lookup = ide->m_item;
1865 
1866  if (!lookup)
1867  return;
1868 
1869  HandleDownloadedImages(lookup);
1870  }
1871  else if (levent->type() == ImageDLFailureEvent::kEventType)
1872  {
1873  if (m_busyPopup)
1874  {
1875  m_busyPopup->Close();
1876  m_busyPopup = nullptr;
1877  }
1878  MythErrorNotification n(tr("Failed to retrieve image(s)"),
1879  tr("Schedule Editor"),
1880  tr("Check logs"));
1881  GetNotificationCenter()->Queue(n);
1882  }
1883  else if (levent->type() == DialogCompletionEvent::kEventType)
1884  {
1885  auto *dce = (DialogCompletionEvent*)(levent);
1886 
1887  const QString resultid = dce->GetId();
1888  ArtworkInfo info;
1889  info.url = dce->GetResultText();
1890 
1891  if (resultid == "coverart")
1892  {
1893  m_artworkMap.replace(kArtworkCoverart, info);
1894  }
1895  else if (resultid == "fanart")
1896  {
1897  m_artworkMap.replace(kArtworkFanart, info);
1898  }
1899  else if (resultid == "banner")
1900  {
1901  m_artworkMap.replace(kArtworkBanner, info);
1902  }
1903 
1904  SetArtwork(m_inetrefEdit->GetText(), m_seasonSpin->GetIntValue(),
1905  gCoreContext->GetMasterHostName(), m_artworkMap);
1906 
1907  ValuesChanged();
1908  }
1909 
1910 }
1911 
1913 
1919 SchedOptMixin::SchedOptMixin(MythScreenType &screen, RecordingRule *rule,
1920  SchedOptMixin *other)
1921  : m_screen(&screen), m_rule(rule), m_other(other),
1922  m_haveRepeats(gCoreContext->GetBoolSetting("HaveRepeats", false))
1923 {
1924 }
1925 
1926 void SchedOptMixin::Create(bool *err)
1927 {
1928  if (!m_rule)
1929  return;
1930 
1931  if (m_other && !m_other->m_prioritySpin)
1932  UIUtilE::Assign(m_screen, m_prioritySpin, "priority", err);
1933  else
1934  UIUtilW::Assign(m_screen, m_prioritySpin, "priority");
1935 
1936  if (m_other && !m_other->m_startoffsetSpin)
1937  UIUtilE::Assign(m_screen, m_startoffsetSpin, "startoffset", err);
1938  else
1939  UIUtilW::Assign(m_screen, m_startoffsetSpin, "startoffset");
1940 
1941  if (m_other && !m_other->m_endoffsetSpin)
1942  UIUtilE::Assign(m_screen, m_endoffsetSpin, "endoffset", err);
1943  else
1944  UIUtilW::Assign(m_screen, m_endoffsetSpin, "endoffset");
1945 
1946  if (m_other && !m_other->m_dupmethodList)
1947  UIUtilE::Assign(m_screen, m_dupmethodList, "dupmethod", err);
1948  else
1949  UIUtilW::Assign(m_screen, m_dupmethodList, "dupmethod");
1950 
1951  if (m_other && !m_other->m_dupscopeList)
1952  UIUtilE::Assign(m_screen, m_dupscopeList, "dupscope", err);
1953  else
1954  UIUtilW::Assign(m_screen, m_dupscopeList, "dupscope");
1955 
1956  if (m_other && !m_other->m_inputList)
1957  UIUtilE::Assign(m_screen, m_inputList, "input", err);
1958  else
1959  UIUtilW::Assign(m_screen, m_inputList, "input");
1960 
1961  if (m_other && !m_other->m_ruleactiveCheck)
1962  UIUtilE::Assign(m_screen, m_ruleactiveCheck, "ruleactive", err);
1963  else
1964  UIUtilW::Assign(m_screen, m_ruleactiveCheck, "ruleactive");
1965 
1966  UIUtilW::Assign(m_screen, m_newrepeatList, "newrepeat");
1967 }
1968 
1969 void SchedOptMixin::Load(void)
1970 {
1971  if (!m_rule)
1972  return;
1973 
1974  // Priority
1975  if (m_prioritySpin)
1976  {
1977  if (!m_loaded)
1978  m_prioritySpin->SetRange(-99,99,1,5);
1979  m_prioritySpin->SetValue(m_rule->m_recPriority);
1980  }
1981 
1982  // Start Offset
1983  if (m_startoffsetSpin)
1984  {
1985  if (!m_loaded)
1986  m_startoffsetSpin->SetRange(480,-480,1,10);
1987  m_startoffsetSpin->SetValue(m_rule->m_startOffset);
1988  }
1989 
1990  // End Offset
1991  if (m_endoffsetSpin)
1992  {
1993  if (!m_loaded)
1994  m_endoffsetSpin->SetRange(-480,480,1,10);
1995  m_endoffsetSpin->SetValue(m_rule->m_endOffset);
1996  }
1997 
1998  // Duplicate Match Type
1999  if (m_dupmethodList)
2000  {
2001  if (!m_loaded)
2002  {
2003  RecordingDupMethodType dupMethod = m_rule->m_dupMethod;
2004 
2005  new MythUIButtonListItem(m_dupmethodList,
2006  toDescription(kDupCheckSubDesc),
2007  ENUM_TO_QVARIANT(kDupCheckSubDesc));
2008  new MythUIButtonListItem(m_dupmethodList,
2009  toDescription(kDupCheckSubThenDesc),
2010  ENUM_TO_QVARIANT(kDupCheckSubThenDesc));
2011  new MythUIButtonListItem(m_dupmethodList,
2012  toDescription(kDupCheckSub),
2013  ENUM_TO_QVARIANT(kDupCheckSub));
2014  new MythUIButtonListItem(m_dupmethodList,
2015  toDescription(kDupCheckDesc),
2016  ENUM_TO_QVARIANT(kDupCheckDesc));
2017  new MythUIButtonListItem(m_dupmethodList,
2018  toDescription(kDupCheckNone),
2019  ENUM_TO_QVARIANT(kDupCheckNone));
2020 
2021  m_rule->m_dupMethod = dupMethod;
2022  }
2023  m_dupmethodList->SetValueByData(ENUM_TO_QVARIANT(m_rule->m_dupMethod));
2024  }
2025 
2026  // Duplicate Matching Scope
2027  if (m_dupscopeList)
2028  {
2029  if (!m_loaded)
2030  {
2031  new MythUIButtonListItem(m_dupscopeList,
2032  toDescription(kDupsInAll),
2033  ENUM_TO_QVARIANT(kDupsInAll));
2034  new MythUIButtonListItem(m_dupscopeList,
2035  toDescription(kDupsInRecorded),
2036  ENUM_TO_QVARIANT(kDupsInRecorded));
2037  new MythUIButtonListItem(m_dupscopeList,
2038  toDescription(kDupsInOldRecorded),
2039  ENUM_TO_QVARIANT(kDupsInOldRecorded));
2040  if (m_haveRepeats && !m_newrepeatList &&
2041  (!m_other || !m_other->m_newrepeatList))
2042  {
2043  new MythUIButtonListItem(m_dupscopeList,
2044  toDescription(kDupsNewEpi),
2045  ENUM_TO_QVARIANT(kDupsNewEpi|kDupsInAll));
2046  }
2047  }
2048  m_dupscopeList->SetValueByData(ENUM_TO_QVARIANT(m_rule->m_dupIn));
2049  }
2050 
2051  // Preferred Input
2052  if (m_inputList)
2053  {
2054  if (!m_loaded)
2055  {
2056  new MythUIButtonListItem(m_inputList,
2057  QObject::tr("Use any available input"),
2058  QVariant::fromValue(0));
2059 
2060  vector<uint> inputids = CardUtil::GetSchedInputList();
2061  for (uint id : inputids)
2062  {
2063  new MythUIButtonListItem(m_inputList,
2064  QObject::tr("Prefer input %1")
2065  .arg(CardUtil::GetDisplayName(id)), id);
2066  }
2067  }
2068  m_inputList->SetValueByData(m_rule->m_prefInput);
2069  }
2070 
2071  // Active/Disabled
2072  if (m_ruleactiveCheck)
2073  {
2074  m_ruleactiveCheck->SetCheckState(!m_rule->m_isInactive);
2075  }
2076 
2077  // Record new and repeat
2078  if (m_newrepeatList)
2079  {
2080  if (!m_loaded)
2081  {
2082  new MythUIButtonListItem(m_newrepeatList,
2083  QObject::tr("Record new and repeat "
2084  "episodes"), ENUM_TO_QVARIANT(0));
2085  new MythUIButtonListItem(m_newrepeatList,
2086  QObject::tr("Record new episodes only"),
2087  ENUM_TO_QVARIANT(kDupsNewEpi));
2088  }
2089  m_newrepeatList->SetValueByData(ENUM_TO_QVARIANT
2090  (m_rule->m_dupIn & kDupsNewEpi));
2091  }
2092 
2093  m_loaded = true;
2094 
2095  RuleChanged();
2096 }
2097 
2098 void SchedOptMixin::Save(void)
2099 {
2100  if (!m_rule)
2101  return;
2102 
2103  if (m_prioritySpin)
2104  m_rule->m_recPriority = m_prioritySpin->GetIntValue();
2105  if (m_startoffsetSpin)
2106  m_rule->m_startOffset = m_startoffsetSpin->GetIntValue();
2107  if (m_endoffsetSpin)
2108  m_rule->m_endOffset = m_endoffsetSpin->GetIntValue();
2109  if (m_dupmethodList)
2110  m_rule->m_dupMethod = static_cast<RecordingDupMethodType>
2111  (m_dupmethodList->GetDataValue().toInt());
2112  if (m_dupscopeList)
2113  {
2114  int mask = ((m_other && m_other->m_newrepeatList) ||
2115  m_newrepeatList) ? kDupsInAll : ~0;
2116  int val = ((m_rule->m_dupIn & ~mask) |
2117  m_dupscopeList->GetDataValue().toInt());
2118  m_rule->m_dupIn = static_cast<RecordingDupInType>(val);
2119  }
2120  if (m_inputList)
2121  m_rule->m_prefInput = m_inputList->GetDataValue().toInt();
2122  if (m_ruleactiveCheck)
2123  m_rule->m_isInactive = !m_ruleactiveCheck->GetBooleanCheckState();
2124  if (m_newrepeatList)
2125  {
2126  int val = ((m_rule->m_dupIn & ~kDupsNewEpi) |
2127  m_newrepeatList->GetDataValue().toInt());
2128  m_rule->m_dupIn = static_cast<RecordingDupInType>(val);
2129  }
2130 }
2131 
2132 void SchedOptMixin::RuleChanged(void)
2133 {
2134  if (!m_rule)
2135  return;
2136 
2137  bool isScheduled = (m_rule->m_type != kNotRecording &&
2138  m_rule->m_type != kDontRecord);
2139  bool isSingle = (m_rule->m_type == kSingleRecord ||
2140  m_rule->m_type == kOverrideRecord);
2141  bool isManual = (m_rule->m_searchType == kManualSearch);
2142 
2143  if (m_prioritySpin)
2144  m_prioritySpin->SetEnabled(isScheduled);
2145  if (m_startoffsetSpin)
2146  m_startoffsetSpin->SetEnabled(isScheduled);
2147  if (m_endoffsetSpin)
2148  m_endoffsetSpin->SetEnabled(isScheduled);
2149  if (m_dupmethodList)
2150  {
2151  m_dupmethodList->SetEnabled(
2152  isScheduled && !isSingle &&
2153  (!isManual || m_rule->m_dupMethod != kDupCheckNone));
2154  }
2155  if (m_dupscopeList)
2156  m_dupscopeList->SetEnabled(isScheduled && !isSingle &&
2157  m_rule->m_dupMethod != kDupCheckNone);
2158  if (m_inputList)
2159  m_inputList->SetEnabled(isScheduled);
2160  if (m_ruleactiveCheck)
2161  m_ruleactiveCheck->SetEnabled(isScheduled);
2162  if (m_newrepeatList)
2163  m_newrepeatList->SetEnabled(isScheduled && !isSingle && m_haveRepeats);
2164 }
2165 
2166 void SchedOptMixin::DupMethodChanged(MythUIButtonListItem *item)
2167 {
2168  if (!item || !m_rule)
2169  return;
2170 
2171  m_rule->m_dupMethod = static_cast<RecordingDupMethodType>
2172  (item->GetData().toInt());
2173 
2174  if (m_dupscopeList)
2175  m_dupscopeList->SetEnabled(m_rule->m_dupMethod != kDupCheckNone);
2176 }
2177 
2179 
2185 void FilterOptMixin::Create(bool *err)
2186 {
2187  if (!m_rule)
2188  return;
2189 
2190  if (m_other && !m_other->m_filtersList)
2191  UIUtilE::Assign(m_screen, m_filtersList, "filters", err);
2192  else
2193  UIUtilW::Assign(m_screen, m_filtersList, "filters");
2194 
2195  UIUtilW::Assign(m_screen, m_activeFiltersList, "activefilters");
2196  if (m_activeFiltersList)
2197  m_activeFiltersList->SetCanTakeFocus(false);
2198 }
2199 
2200 void FilterOptMixin::Load(void)
2201 {
2202  if (!m_rule)
2203  return;
2204 
2205  if (!m_loaded)
2206  {
2207  MSqlQuery query(MSqlQuery::InitCon());
2208 
2209  query.prepare("SELECT filterid, description, newruledefault "
2210  "FROM recordfilter ORDER BY filterid");
2211 
2212  if (query.exec())
2213  {
2214  while (query.next())
2215  {
2216  m_descriptions << QObject::tr(query.value(1).toString()
2217  .toUtf8().constData());
2218  }
2219  }
2220  m_loaded = true;
2221  }
2222 
2223  if (m_activeFiltersList)
2224  m_activeFiltersList->Reset();
2225 
2226  MythUIButtonListItem *button = nullptr;
2227  QStringList::iterator Idesc;
2228  int idx = 0;
2229  bool not_empty = m_filtersList && !m_filtersList->IsEmpty();
2230  for (Idesc = m_descriptions.begin(), idx = 0;
2231  Idesc != m_descriptions.end(); ++Idesc, ++idx)
2232  {
2233  bool active = (m_rule->m_filter & (1 << idx)) != 0U;
2234  if (m_filtersList)
2235  {
2236  if (not_empty)
2237  button = m_filtersList->GetItemAt(idx);
2238  else
2239  button = new MythUIButtonListItem(m_filtersList, *Idesc, idx);
2240  button->setCheckable(true);
2241  button->setChecked(active ? MythUIButtonListItem::FullChecked
2242  : MythUIButtonListItem::NotChecked);
2243  }
2244  if (active && m_activeFiltersList)
2245  {
2246  /* Create a simple list of active filters the theme can
2247  use for informational purposes. */
2248  button = new MythUIButtonListItem(m_activeFiltersList,
2249  *Idesc, idx);
2250  button->setCheckable(false);
2251  }
2252  }
2253 
2254  if (m_activeFiltersList && m_activeFiltersList->IsEmpty())
2255  {
2256  button = new MythUIButtonListItem(m_activeFiltersList,
2257  QObject::tr("None"), idx);
2258  button->setCheckable(false);
2259  }
2260 
2261  RuleChanged();
2262 }
2263 
2264 void FilterOptMixin::Save()
2265 {
2266  if (!m_rule || !m_filtersList)
2267  return;
2268 
2269  // Iterate through button list, and build the mask
2270  uint32_t filter_mask = 0;
2271 
2272  int end = m_filtersList->GetCount();
2273  for (int idx = 0; idx < end; ++idx)
2274  {
2275  MythUIButtonListItem *button = m_filtersList->GetItemAt(idx);
2276  if (button != nullptr &&
2277  button->state() == MythUIButtonListItem::FullChecked)
2278  filter_mask |= (1 << button->GetData().value<uint32_t>());
2279  }
2280  m_rule->m_filter = filter_mask;
2281 }
2282 
2283 void FilterOptMixin::RuleChanged(void)
2284 {
2285  if (!m_rule)
2286  return;
2287 
2288  bool enabled = m_rule->m_type != kNotRecording &&
2289  m_rule->m_type != kDontRecord;
2290  if (m_filtersList)
2291  m_filtersList->SetEnabled(enabled);
2292  if (m_activeFiltersList)
2293  m_activeFiltersList->SetEnabled(enabled);
2294 }
2295 
2296 void FilterOptMixin::ToggleSelected(MythUIButtonListItem *item)
2297 {
2298  item->setChecked(item->state() == MythUIButtonListItem::FullChecked ?
2299  MythUIButtonListItem::NotChecked :
2300  MythUIButtonListItem::FullChecked);
2301 }
2302 
2303 
2305 
2311 void StoreOptMixin::Create(bool *err)
2312 {
2313  if (!m_rule)
2314  return;
2315 
2316  if (m_other && !m_other->m_recprofileList)
2317  UIUtilE::Assign(m_screen, m_recprofileList, "recprofile", err);
2318  else
2319  UIUtilW::Assign(m_screen, m_recprofileList, "recprofile");
2320 
2321  if (m_other && !m_other->m_recgroupList)
2322  UIUtilE::Assign(m_screen, m_recgroupList, "recgroup", err);
2323  else
2324  UIUtilW::Assign(m_screen, m_recgroupList, "recgroup");
2325 
2326  if (m_other && !m_other->m_storagegroupList)
2327  UIUtilE::Assign(m_screen, m_storagegroupList, "storagegroup", err);
2328  else
2329  UIUtilW::Assign(m_screen, m_storagegroupList, "storagegroup");
2330 
2331  if (m_other && !m_other->m_playgroupList)
2332  UIUtilE::Assign(m_screen, m_playgroupList, "playgroup", err);
2333  else
2334  UIUtilW::Assign(m_screen, m_playgroupList, "playgroup");
2335 
2336  if (m_other && !m_other->m_maxepSpin)
2337  UIUtilE::Assign(m_screen, m_maxepSpin, "maxepisodes", err);
2338  else
2339  UIUtilW::Assign(m_screen, m_maxepSpin, "maxepisodes");
2340 
2341  if (m_other && !m_other->m_maxbehaviourList)
2342  UIUtilE::Assign(m_screen, m_maxbehaviourList, "maxnewest", err);
2343  else
2344  UIUtilW::Assign(m_screen, m_maxbehaviourList, "maxnewest");
2345 
2346  if (m_other && !m_other->m_autoexpireCheck)
2347  UIUtilE::Assign(m_screen, m_autoexpireCheck, "autoexpire", err);
2348  else
2349  UIUtilW::Assign(m_screen, m_autoexpireCheck, "autoexpire");
2350 }
2351 
2352 void StoreOptMixin::Load(void)
2353 {
2354  if (!m_rule)
2355  return;
2356 
2357  QString label;
2358  QStringList groups;
2359  QStringList::Iterator it;
2360  MSqlQuery query(MSqlQuery::InitCon());
2361 
2362  // Recording Profile
2363  if (m_recprofileList)
2364  {
2365  if (!m_loaded)
2366  {
2367  label = QObject::tr("Record using the %1 profile");
2368 
2369  new MythUIButtonListItem(m_recprofileList,
2370  label.arg(QObject::tr("Default")),
2371  QVariant::fromValue(QString("Default")));
2372  // LiveTV profile - it's for LiveTV not scheduled recordings??
2373  new MythUIButtonListItem(m_recprofileList,
2374  label.arg(QObject::tr("LiveTV")),
2375  QVariant::fromValue(QString("LiveTV")));
2376  new MythUIButtonListItem(m_recprofileList,
2377  label.arg(QObject::tr("High Quality")),
2378  QVariant::fromValue(QString("High Quality")));
2379  new MythUIButtonListItem(m_recprofileList,
2380  label.arg(QObject::tr("Low Quality")),
2381  QVariant::fromValue(QString("Low Quality")));
2382  }
2383  m_recprofileList->SetValueByData(m_rule->m_recProfile);
2384  }
2385 
2386  // Recording Group
2387  if (m_recgroupList)
2388  {
2389  if (!m_loaded)
2390  {
2391  label = QObject::tr("Include in the \"%1\" recording group");
2392  new MythUIButtonListItem(m_recgroupList,
2393  QObject::tr("Create a new recording group"),
2394  QVariant::fromValue(QString("__NEW_GROUP__")));
2395 
2396  query.prepare("SELECT recgroupid, recgroup FROM recgroups "
2397  "WHERE recgroup <> 'Deleted' AND "
2398  " recgroup <> 'LiveTV' "
2399  "ORDER BY special DESC, recgroup ASC"); // Special groups first
2400  if (query.exec())
2401  {
2402  while (query.next())
2403  {
2404  int id = query.value(0).toInt();
2405  QString name = query.value(1).toString();
2406 
2407  if (name == "Default")
2408  name = QObject::tr("Default");
2409  new MythUIButtonListItem(m_recgroupList, label.arg(name),
2410  QVariant::fromValue(id));
2411  }
2412  }
2413 
2414  }
2415  m_recgroupList->SetValueByData(m_rule->m_recGroupID);
2416  }
2417 
2418  // Storage Group
2419  if (m_storagegroupList)
2420  {
2421  if (!m_loaded)
2422  {
2423  label = QObject::tr("Store in the \"%1\" storage group");
2424  new MythUIButtonListItem(m_storagegroupList,
2425  label.arg(QObject::tr("Default")),
2426  QVariant::fromValue(QString("Default")));
2427 
2428  groups = StorageGroup::getRecordingsGroups();
2429  for (it = groups.begin(); it != groups.end(); ++it)
2430  {
2431  if ((*it).compare("Default", Qt::CaseInsensitive) != 0)
2432  new MythUIButtonListItem(m_storagegroupList,
2433  label.arg(*it), QVariant::fromValue(*it));
2434  }
2435  }
2436  m_storagegroupList->SetValueByData(m_rule->m_storageGroup);
2437  }
2438 
2439  // Playback Group
2440  if (m_playgroupList)
2441  {
2442  if (!m_loaded)
2443  {
2444  label = QObject::tr("Use \"%1\" playback group settings");
2445  new MythUIButtonListItem(m_playgroupList,
2446  label.arg(QObject::tr("Default")),
2447  QVariant::fromValue(QString("Default")));
2448 
2449  groups = PlayGroup::GetNames();
2450  for (it = groups.begin(); it != groups.end(); ++it)
2451  {
2452  new MythUIButtonListItem(m_playgroupList, label.arg(*it),
2453  QVariant::fromValue(*it));
2454  }
2455  }
2456  m_playgroupList->SetValueByData(m_rule->m_playGroup);
2457  }
2458 
2459  // Max Episodes
2460  if (m_maxepSpin)
2461  {
2462  if (!m_loaded)
2463  {
2464  int maxEpisodes = m_rule->m_maxEpisodes;
2465  m_maxepSpin->SetRange(0,100,1,5);
2466  m_rule->m_maxEpisodes = maxEpisodes;
2467  }
2468  m_maxepSpin->SetValue(m_rule->m_maxEpisodes);
2469  }
2470 
2471  // Max Episode Behaviour
2472  if (m_maxbehaviourList)
2473  {
2474  if (!m_loaded)
2475  {
2476  new MythUIButtonListItem(m_maxbehaviourList,
2477  QObject::tr("Don't record if this would exceed the max "
2478  "episodes"), QVariant::fromValue(false));
2479  new MythUIButtonListItem(m_maxbehaviourList,
2480  QObject::tr("Delete oldest if this would exceed the max "
2481  "episodes"), QVariant::fromValue(true));
2482  }
2483  m_maxbehaviourList->SetValueByData(m_rule->m_maxNewest);
2484  }
2485 
2486  // Auto-Expire
2487  if (m_autoexpireCheck)
2488  {
2489  m_autoexpireCheck->SetCheckState(m_rule->m_autoExpire);
2490  }
2491 
2492  m_loaded = true;
2493 
2494  RuleChanged();
2495 }
2496 
2497 void StoreOptMixin::Save(void)
2498 {
2499  if (!m_rule)
2500  return;
2501 
2502  if (m_recprofileList)
2503  m_rule->m_recProfile = m_recprofileList->GetDataValue().toString();
2504 
2505  if (m_recgroupList)
2506  {
2507  // If the user selected 'Create a new regroup' but failed to enter a
2508  // name when prompted, restore the original value
2509  if (m_recgroupList->GetDataValue().toString() == "__NEW_GROUP__")
2510  m_recgroupList->SetValueByData(m_rule->m_recGroupID);
2511  m_rule->m_recGroupID = m_recgroupList->GetDataValue().toInt();
2512  }
2513 
2514  if (m_storagegroupList)
2515  m_rule->m_storageGroup = m_storagegroupList->GetDataValue().toString();
2516 
2517  if (m_playgroupList)
2518  m_rule->m_playGroup = m_playgroupList->GetDataValue().toString();
2519 
2520  if (m_maxepSpin)
2521  m_rule->m_maxEpisodes = m_maxepSpin->GetIntValue();
2522 
2523  if (m_maxbehaviourList)
2524  m_rule->m_maxNewest = m_maxbehaviourList->GetDataValue().toBool();
2525 
2526  if (m_autoexpireCheck)
2527  m_rule->m_autoExpire = m_autoexpireCheck->GetBooleanCheckState();
2528 }
2529 
2530 void StoreOptMixin::RuleChanged(void)
2531 {
2532  if (!m_rule)
2533  return;
2534 
2535  bool isScheduled = (m_rule->m_type != kNotRecording &&
2536  m_rule->m_type != kDontRecord);
2537  bool isSingle = (m_rule->m_type == kSingleRecord ||
2538  m_rule->m_type == kOverrideRecord);
2539 
2540  if (m_recprofileList)
2541  m_recprofileList->SetEnabled(isScheduled);
2542  if (m_recgroupList)
2543  m_recgroupList->SetEnabled(isScheduled);
2544  if (m_storagegroupList)
2545  m_storagegroupList->SetEnabled(isScheduled);
2546  if (m_playgroupList)
2547  m_playgroupList->SetEnabled(isScheduled);
2548  if (m_maxepSpin)
2549  m_maxepSpin->SetEnabled(isScheduled && !isSingle);
2550  if (m_maxbehaviourList)
2551  m_maxbehaviourList->SetEnabled(isScheduled && !isSingle &&
2552  m_rule->m_maxEpisodes != 0);
2553  if (m_autoexpireCheck)
2554  m_autoexpireCheck->SetEnabled(isScheduled);
2555 }
2556 
2557 void StoreOptMixin::MaxEpisodesChanged(MythUIButtonListItem *item)
2558 {
2559  if (!item || !m_rule)
2560  return;
2561 
2562  m_rule->m_maxEpisodes = item->GetData().toInt();
2563 
2564  if (m_maxbehaviourList)
2565  m_maxbehaviourList->SetEnabled(m_rule->m_maxEpisodes != 0);
2566 }
2567 
2568 void StoreOptMixin::PromptForRecGroup(void)
2569 {
2570  if (!m_rule)
2571  return;
2572 
2573  if (m_recgroupList->GetDataValue().toString() != "__NEW_GROUP__")
2574  return;
2575 
2576  MythScreenStack *popupStack = GetMythMainWindow()->GetStack("popup stack");
2577 
2578  QString label =
2579  QObject::tr("New Recording group name: ");
2580 
2581  auto *textDialog = new MythTextInputDialog(popupStack, label,
2582  static_cast<InputFilter>(FilterSymbols | FilterPunct));
2583 
2584  textDialog->SetReturnEvent(m_screen, "newrecgroup");
2585 
2586  if (textDialog->Create())
2587  popupStack->AddScreen(textDialog, false);
2588 }
2589 
2590 void StoreOptMixin::SetRecGroup(int recgroupID, QString recgroup)
2591 {
2592  if (!m_rule || recgroupID <= 0)
2593  return;
2594 
2595  if (m_recgroupList)
2596  {
2597  recgroup = recgroup.trimmed();
2598  if (recgroup.isEmpty())
2599  return;
2600 
2601  QString label = QObject::tr("Include in the \"%1\" recording group");
2602  auto *item = new MythUIButtonListItem(m_recgroupList, label.arg(recgroup),
2603  QVariant::fromValue(recgroup));
2604  m_recgroupList->SetItemCurrent(item);
2605 
2606  if (m_other && m_other->m_recgroupList)
2607  {
2608  item = new MythUIButtonListItem(m_other->m_recgroupList,
2609  label.arg(recgroup), QVariant::fromValue(recgroupID));
2610  m_other->m_recgroupList->SetItemCurrent(item);
2611  }
2612  }
2613 }
2614 
2615 int StoreOptMixin::CreateRecordingGroup(const QString& groupName)
2616 {
2617  int groupID = -1;
2618  MSqlQuery query(MSqlQuery::InitCon());
2619 
2620  query.prepare("INSERT INTO recgroups SET recgroup = :NAME, "
2621  "displayname = :DISPLAYNAME");
2622  query.bindValue(":NAME", groupName);
2623  query.bindValue(":DISPLAYNAME", groupName);
2624 
2625  if (query.exec())
2626  groupID = query.lastInsertId().toInt();
2627 
2628  if (groupID <= 0)
2629  LOG(VB_GENERAL, LOG_ERR, QString("Could not create recording group (%1). "
2630  "Does it already exist?").arg(groupName));
2631 
2632  return groupID;
2633 }
2634 
2636 
2642 void PostProcMixin::Create(bool *err)
2643 {
2644  if (!m_rule)
2645  return;
2646 
2647  if (m_other && !m_other->m_commflagCheck)
2648  UIUtilE::Assign(m_screen, m_commflagCheck, "autocommflag", err);
2649  else
2650  UIUtilW::Assign(m_screen, m_commflagCheck, "autocommflag");
2651 
2652  if (m_other && !m_other->m_transcodeCheck)
2653  UIUtilE::Assign(m_screen, m_transcodeCheck, "autotranscode", err);
2654  else
2655  UIUtilW::Assign(m_screen, m_transcodeCheck, "autotranscode");
2656 
2657  if (m_other && !m_other->m_transcodeprofileList)
2658  UIUtilE::Assign(m_screen, m_transcodeprofileList, "transcodeprofile", err);
2659  else
2660  UIUtilW::Assign(m_screen, m_transcodeprofileList, "transcodeprofile");
2661 
2662  if (m_other && !m_other->m_userjob1Check)
2663  UIUtilE::Assign(m_screen, m_userjob1Check, "userjob1", err);
2664  else
2665  UIUtilW::Assign(m_screen, m_userjob1Check, "userjob1");
2666 
2667  if (m_other && !m_other->m_userjob2Check)
2668  UIUtilE::Assign(m_screen, m_userjob2Check, "userjob2", err);
2669  else
2670  UIUtilW::Assign(m_screen, m_userjob2Check, "userjob2");
2671 
2672  if (m_other && !m_other->m_userjob3Check)
2673  UIUtilE::Assign(m_screen, m_userjob3Check, "userjob3", err);
2674  else
2675  UIUtilW::Assign(m_screen, m_userjob3Check, "userjob3");
2676 
2677  if (m_other && !m_other->m_userjob4Check)
2678  UIUtilE::Assign(m_screen, m_userjob4Check, "userjob4", err);
2679  else
2680  UIUtilW::Assign(m_screen, m_userjob4Check, "userjob4");
2681 
2682  UIUtilW::Assign(m_screen, m_metadataLookupCheck, "metadatalookup");
2683 }
2684 
2685 void PostProcMixin::Load(void)
2686 {
2687  if (!m_rule)
2688  return;
2689 
2690  // Auto-commflag
2691  if (m_commflagCheck)
2692  {
2693  m_commflagCheck->SetCheckState(m_rule->m_autoCommFlag);
2694  }
2695 
2696  // Auto-transcode
2697  if (m_transcodeCheck)
2698  {
2699  m_transcodeCheck->SetCheckState(m_rule->m_autoTranscode);
2700  }
2701 
2702  // Transcode Method
2703  if (m_transcodeprofileList)
2704  {
2705  if (!m_loaded)
2706  {
2707  QMap<int, QString> profiles = RecordingProfile::GetTranscodingProfiles();
2708  QMap<int, QString>::iterator it;
2709  for (it = profiles.begin(); it != profiles.end(); ++it)
2710  {
2711  new MythUIButtonListItem(m_transcodeprofileList, it.value(),
2712  QVariant::fromValue(it.key()));
2713  }
2714  }
2715  m_transcodeprofileList->SetValueByData(m_rule->m_transcoder);
2716  }
2717 
2718  // User Job #1
2719  if (m_userjob1Check)
2720  {
2721  if (!m_loaded)
2722  {
2723  MythUIText *userjob1Text = nullptr;
2724  UIUtilW::Assign(m_screen, userjob1Text, "userjob1text");
2725  if (userjob1Text)
2726  userjob1Text->SetText(QObject::tr("Run '%1'")
2727  .arg(gCoreContext->GetSetting("UserJobDesc1", "User Job 1")));
2728  }
2729  m_userjob1Check->SetCheckState(m_rule->m_autoUserJob1);
2730  }
2731 
2732  // User Job #2
2733  if (m_userjob2Check)
2734  {
2735  if (!m_loaded)
2736  {
2737  MythUIText *userjob2Text = nullptr;
2738  UIUtilW::Assign(m_screen, userjob2Text, "userjob2text");
2739  if (userjob2Text)
2740  userjob2Text->SetText(QObject::tr("Run '%1'")
2741  .arg(gCoreContext->GetSetting("UserJobDesc2", "User Job 2")));
2742  }
2743  m_userjob2Check->SetCheckState(m_rule->m_autoUserJob2);
2744  }
2745 
2746  // User Job #3
2747  if (m_userjob3Check)
2748  {
2749  if (!m_loaded)
2750  {
2751  MythUIText *userjob3Text = nullptr;
2752  UIUtilW::Assign(m_screen, userjob3Text, "userjob3text");
2753  if (userjob3Text)
2754  userjob3Text->SetText(QObject::tr("Run '%1'")
2755  .arg(gCoreContext->GetSetting("UserJobDesc3", "User Job 3")));
2756  }
2757  m_userjob3Check->SetCheckState(m_rule->m_autoUserJob3);
2758  }
2759 
2760  // User Job #4
2761  if (m_userjob4Check)
2762  {
2763  if (!m_loaded)
2764  {
2765  MythUIText *userjob4Text = nullptr;
2766  UIUtilW::Assign(m_screen, userjob4Text, "userjob4text");
2767  if (userjob4Text)
2768  userjob4Text->SetText(QObject::tr("Run '%1'")
2769  .arg(gCoreContext->GetSetting("UserJobDesc4", "User Job 4")));
2770  }
2771  m_userjob4Check->SetCheckState(m_rule->m_autoUserJob4);
2772  }
2773 
2774  // Auto Metadata Lookup
2775  if (m_metadataLookupCheck)
2776  {
2777  m_metadataLookupCheck->SetCheckState(m_rule->m_autoMetadataLookup);
2778  }
2779 
2780  m_loaded = true;
2781 
2782  RuleChanged();
2783 }
2784 
2785 void PostProcMixin::Save(void)
2786 {
2787  if (!m_rule)
2788  return;
2789 
2790  if (m_commflagCheck)
2791  m_rule->m_autoCommFlag = m_commflagCheck->GetBooleanCheckState();
2792  if (m_transcodeCheck)
2793  m_rule->m_autoTranscode = m_transcodeCheck->GetBooleanCheckState();
2794  if (m_transcodeprofileList)
2795  m_rule->m_transcoder = m_transcodeprofileList->GetDataValue().toInt();
2796  if (m_userjob1Check)
2797  m_rule->m_autoUserJob1 = m_userjob1Check->GetBooleanCheckState();
2798  if (m_userjob2Check)
2799  m_rule->m_autoUserJob2 = m_userjob2Check->GetBooleanCheckState();
2800  if (m_userjob3Check)
2801  m_rule->m_autoUserJob3 = m_userjob3Check->GetBooleanCheckState();
2802  if (m_userjob4Check)
2803  m_rule->m_autoUserJob4 = m_userjob4Check->GetBooleanCheckState();
2804  if (m_metadataLookupCheck)
2805  m_rule->m_autoMetadataLookup =
2806  m_metadataLookupCheck->GetBooleanCheckState();
2807 }
2808 
2809 void PostProcMixin::RuleChanged(void)
2810 {
2811  if (!m_rule)
2812  return;
2813 
2814  bool isScheduled = (m_rule->m_type != kNotRecording &&
2815  m_rule->m_type != kDontRecord);
2816 
2817  if (m_commflagCheck)
2818  m_commflagCheck->SetEnabled(isScheduled);
2819  if (m_transcodeCheck)
2820  m_transcodeCheck->SetEnabled(isScheduled);
2821  if (m_transcodeprofileList)
2822  m_transcodeprofileList->SetEnabled(isScheduled &&
2823  m_rule->m_autoTranscode);
2824  if (m_userjob1Check)
2825  m_userjob1Check->SetEnabled(isScheduled);
2826  if (m_userjob2Check)
2827  m_userjob2Check->SetEnabled(isScheduled);
2828  if (m_userjob3Check)
2829  m_userjob3Check->SetEnabled(isScheduled);
2830  if (m_userjob4Check)
2831  m_userjob4Check->SetEnabled(isScheduled);
2832  if (m_metadataLookupCheck)
2833  m_metadataLookupCheck->SetEnabled(isScheduled);
2834 }
2835 
2836 void PostProcMixin::TranscodeChanged(bool enable)
2837 {
2838  if (!m_rule)
2839  return;
2840 
2841  m_rule->m_autoTranscode = enable;
2842 
2843  if (m_transcodeprofileList)
2844  m_transcodeprofileList->SetEnabled(m_rule->m_autoTranscode);
2845 }
RecordingRule::m_isOverride
bool m_isOverride
Definition: recordingrule.h:153
MetadataFactory::Lookup
void Lookup(ProgramInfo *pginfo, bool automatic=true, bool getimages=true, bool allowgeneric=false)
Definition: metadatafactory.cpp:142
StorageGroup::getRecordingsGroups
static QStringList getRecordingsGroups(void)
Definition: storagegroup.cpp:790
MetadataOptions::~MetadataOptions
~MetadataOptions() override
Definition: scheduleeditor.cpp:1261
ScheduleEditor::m_view
int m_view
Definition: scheduleeditor.h:240
scheduleeditor.h
RecordingRule::LoadTemplate
bool LoadTemplate(const QString &category, const QString &categoryType="Default")
Definition: recordingrule.cpp:280
MythUIButtonList::GetItemAt
MythUIButtonListItem * GetItemAt(int pos) const
Definition: mythuibuttonlist.cpp:1676
RecordingRule::LoadByProgram
bool LoadByProgram(const ProgramInfo *proginfo)
Definition: recordingrule.cpp:175
FilterOptMixin::SetRule
void SetRule(RecordingRule *rule)
Definition: scheduleeditor.h:128
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:783
kDupCheckDesc
@ kDupCheckDesc
Definition: recordingtypes.h:62
mythuimetadataresults.h
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:126
MythMainWindow::GetMainStack
MythScreenStack * GetMainStack()
Definition: mythmainwindow.cpp:304
PostProcMixin::m_loaded
bool m_loaded
Definition: scheduleeditor.h:119
RecordingRule::m_autoTranscode
bool m_autoTranscode
Definition: recordingrule.h:133
generate_file_url
QString generate_file_url(const QString &storage_group, const QString &host, const QString &path)
Definition: videoutils.h:65
SchedEditChild::Save
virtual void Save(void)=0
ScheduleEditor::Load
void Load(void) override
Load data which will ultimately be displayed on-screen or used to determine what appears on-screen (S...
Definition: scheduleeditor.cpp:237
MetadataOptions::CanSetArtwork
bool CanSetArtwork(void)
Definition: scheduleeditor.cpp:1553
SchedOptEditor::Create
bool Create(void) override
Definition: scheduleeditor.cpp:980
VideoArtworkType
VideoArtworkType
Definition: metadataimagehelper.h:10
MetadataOptions::m_queryButton
MythUIButton * m_queryButton
Definition: scheduleeditor.h:419
MetadataOptions::OnImageSearchListSelection
void OnImageSearchListSelection(const ArtworkInfo &info, VideoArtworkType type)
Definition: scheduleeditor.cpp:1406
RecordingRule::m_playGroup
QString m_playGroup
Definition: recordingrule.h:123
PostProcMixin::m_screen
MythScreenType * m_screen
Definition: scheduleeditor.h:116
MetadataOptions::FindImagePopup
static void FindImagePopup(const QString &prefix, const QString &prefixAlt, QObject &inst, const QString &returnEvent)
Definition: scheduleeditor.cpp:1514
RecordingRule::m_seriesid
QString m_seriesid
Definition: recordingrule.h:86
MythUIButtonList::GetItemCurrent
MythUIButtonListItem * GetItemCurrent() const
Definition: mythuibuttonlist.cpp:1590
RefCountHandler
Definition: referencecounterlist.h:18
MythCoreContext::GetMasterHostName
QString GetMasterHostName(void)
Definition: mythcorecontext.cpp:825
SchedOptMixin::SetRule
void SetRule(RecordingRule *rule)
Definition: scheduleeditor.h:37
CardUtil::GetDisplayName
static QString GetDisplayName(uint inputid)
Definition: cardutil.cpp:1743
MythUIButtonList::SetValueByData
void SetValueByData(const QVariant &data)
Definition: mythuibuttonlist.cpp:1542
mythuitext.h
ScheduleEditor::Close
void Close(void) override
Definition: scheduleeditor.cpp:225
FilterOptMixin::Save
void Save(void)
Definition: scheduleeditor.cpp:2264
MetadataOptions::m_imageDownload
MetadataImageDownload * m_imageDownload
Definition: scheduleeditor.h:404
RecordingRule::m_autoCommFlag
bool m_autoCommFlag
Definition: recordingrule.h:132
RecordingRule::m_inetref
QString m_inetref
Definition: recordingrule.h:89
MetadataOptions::SelectOnlineFanart
void SelectOnlineFanart()
Definition: scheduleeditor.cpp:1465
MetadataImageDownload
Definition: metadataimagedownload.h:88
PostProcMixin::m_transcodeCheck
MythUICheckBox * m_transcodeCheck
Definition: scheduleeditor.h:107
ShowOkPopup
MythConfirmationDialog * ShowOkPopup(const QString &message, QObject *parent, const char *slot, bool showCancel)
Non-blocking version of MythPopupBox::showOkPopup()
Definition: mythdialogbox.cpp:551
SchedOptMixin::m_newrepeatList
MythUIButtonList * m_newrepeatList
Definition: scheduleeditor.h:51
kMetadataRecording
@ kMetadataRecording
Definition: metadatacommon.h:43
metadataimagehelper.h
MetadataOptions::CreateLookup
MetadataLookup * CreateLookup(MetadataType mtype)
Definition: scheduleeditor.cpp:1567
ScheduleEditor::customEvent
void customEvent(QEvent *event) override
Definition: scheduleeditor.cpp:562
RecordingRule::m_maxNewest
bool m_maxNewest
Definition: recordingrule.h:128
fs6
static QString fs6(QT_TRANSLATE_NOOP("SchedFilterEditor", "This episode"))
SchedOptEditor::DupMethodChanged
void DupMethodChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:1026
MetadataOptions::ClearInetref
void ClearInetref()
Definition: scheduleeditor.cpp:1384
MetadataType
MetadataType
Definition: metadatacommon.h:41
false
VERBOSE_PREAMBLE false
Definition: verbosedefs.h:85
RecordingRule::m_category
QString m_category
Definition: recordingrule.h:84
RecordingRule::Save
bool Save(bool sendSig=true)
Definition: recordingrule.cpp:390
MetadataOptions::customEvent
void customEvent(QEvent *event) override
Definition: scheduleeditor.cpp:1703
SchedEditChild::SetTextFromMaps
void SetTextFromMaps(void)
Definition: scheduleeditor.cpp:945
PostProcMixin::m_userjob3Check
MythUICheckBox * m_userjob3Check
Definition: scheduleeditor.h:111
SchedOptMixin::SchedOptMixin
SchedOptMixin(MythScreenType &screen, RecordingRule *rule, SchedOptMixin *other=nullptr)
Definition: scheduleeditor.cpp:1919
StoreOptEditor::MaxEpisodesChanged
void MaxEpisodesChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:1145
MetadataOptions::QueryComplete
void QueryComplete(MetadataLookup *lookup)
Definition: scheduleeditor.cpp:1495
MythScreenType::Close
virtual void Close()
Definition: mythscreentype.cpp:402
fs0
static QString fs0(QT_TRANSLATE_NOOP("SchedFilterEditor", "New episode"))
FilterOptMixin::m_activeFiltersList
MythUIButtonList * m_activeFiltersList
Definition: scheduleeditor.h:136
ScheduleEditor::Create
bool Create(void) override
Definition: scheduleeditor.cpp:127
StoreOptMixin::m_rule
RecordingRule * m_rule
Definition: scheduleeditor.h:88
MetadataResultsDialog
Definition: mythuimetadataresults.h:12
kDailyRecord
@ kDailyRecord
Definition: recordingtypes.h:23
kDupCheckSubThenDesc
@ kDupCheckSubThenDesc
Definition: recordingtypes.h:64
kMetadataVideo
@ kMetadataVideo
Definition: metadatacommon.h:42
PostProcMixin::m_metadataLookupCheck
MythUICheckBox * m_metadataLookupCheck
Definition: scheduleeditor.h:113
title
QString title
Definition: mythplugins/mytharchive/mytharchivehelper/main.cpp:639
ScheduleEditor::MaxEpisodesChanged
void MaxEpisodesChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:379
PostProcMixin::m_userjob2Check
MythUICheckBox * m_userjob2Check
Definition: scheduleeditor.h:110
MetadataOptions::m_metadataFactory
MetadataFactory * m_metadataFactory
Definition: scheduleeditor.h:400
MetadataImageDownload::cancel
void cancel()
Definition: metadataimagedownload.cpp:63
MetadataOptions::SelectLocalBanner
void SelectLocalBanner()
Definition: scheduleeditor.cpp:1454
ArtworkList
QList< ArtworkInfo > ArtworkList
Definition: metadataimagehelper.h:30
RecordingInfo
Holds information on a TV Program one might wish to record.
Definition: recordinginfo.h:35
SchedFilterEditor::Create
bool Create(void) override
Definition: scheduleeditor.cpp:1047
StoreOptEditor::customEvent
void customEvent(QEvent *event) override
Definition: scheduleeditor.cpp:1155
ScheduleEditor::Save
void Save(void)
Definition: scheduleeditor.cpp:394
ScheduleEditor::ScheduleEditor
ScheduleEditor(MythScreenStack *parent, RecordingInfo *recinfo, TV *player=nullptr)
Definition: scheduleeditor.cpp:87
MythUIImage::Load
bool Load(bool allowLoadInBackground=true, bool forceStat=false)
Load the image(s), wraps ImageLoader::LoadImage()
Definition: mythuiimage.cpp:968
kDupCheckSub
@ kDupCheckSub
Definition: recordingtypes.h:61
ScheduleEditor::~ScheduleEditor
~ScheduleEditor() override
Definition: scheduleeditor.cpp:115
MythUIBusyDialog::Create
bool Create(void) override
Definition: mythprogressdialog.cpp:32
DialogCompletionEvent::kEventType
static Type kEventType
Definition: mythdialogbox.h:57
ImageDLFailureEvent::kEventType
static Type kEventType
Definition: metadataimagedownload.h:67
kProbableTelevision
@ kProbableTelevision
Definition: metadatacommon.h:50
ScheduleEditor::DupMethodChanged
void DupMethodChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:369
SchedEditChild::SchedEditChild
SchedEditChild(MythScreenStack *parent, const QString &name, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:874
MSqlQuery::lastInsertId
QVariant lastInsertId()
Return the id of the last inserted row.
Definition: mythdbcon.cpp:888
MythEvent
This class is used as a container for messages.
Definition: mythevent.h:17
fs4
static QString fs4(QT_TRANSLATE_NOOP("SchedFilterEditor", "Commercial free"))
RecordingRule::m_title
QString m_title
Definition: recordingrule.h:79
MetadataOptions::m_inetrefClear
MythUIButton * m_inetrefClear
Definition: scheduleeditor.h:418
SchedOptEditor::m_filtersButton
MythUIButton * m_filtersButton
Definition: scheduleeditor.h:294
ScheduleEditor::showTemplateMenu
void showTemplateMenu(void)
Definition: scheduleeditor.cpp:835
MythUICheckBox::GetBooleanCheckState
bool GetBooleanCheckState(void) const
Definition: mythuicheckbox.cpp:103
SchedOptMixin::m_prioritySpin
MythUISpinBox * m_prioritySpin
Definition: scheduleeditor.h:44
mythdialogbox.h
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:198
MythScreenStack
Definition: mythscreenstack.h:16
RecordingProfile::GetTranscodingProfiles
static QMap< int, QString > GetTranscodingProfiles()
Definition: recordingprofile.cpp:1871
arg
arg(title).arg(filename).arg(doDelete))
MetadataOptions::m_episodeSpin
MythUISpinBox * m_episodeSpin
Definition: scheduleeditor.h:416
MythWarningNotification
Definition: mythnotification.h:373
ProgLister
Definition: proglist.h:32
GetArtwork
ArtworkMap GetArtwork(const QString &inetref, uint season, bool strict)
Definition: metadataimagehelper.cpp:23
MythUIButtonListItem::FullChecked
@ FullChecked
Definition: mythuibuttonlist.h:34
ScheduleEditor::ShowPreviousView
void ShowPreviousView(void)
Definition: scheduleeditor.cpp:741
SchedEditChild::m_recordingRule
RecordingRule * m_recordingRule
Definition: scheduleeditor.h:269
MythUIType::SetCanTakeFocus
void SetCanTakeFocus(bool set=true)
Set whether this widget can take focus.
Definition: mythuitype.cpp:343
StoreOptMixin::m_autoexpireCheck
MythUICheckBox * m_autoexpireCheck
Definition: scheduleeditor.h:84
RecordingRule
Internal representation of a recording rule, mirrors the record table.
Definition: recordingrule.h:33
RecordingDupMethodType
RecordingDupMethodType
Definition: recordingtypes.h:58
RecordingRule::m_endOffset
int m_endOffset
Definition: recordingrule.h:112
PostProcEditor::TranscodeChanged
void TranscodeChanged(bool enable)
Definition: scheduleeditor.cpp:1228
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:603
MetadataOptions::m_fanart
MythUIImage * m_fanart
Definition: scheduleeditor.h:409
StoreOptMixin::Create
void Create(bool *err)
Definition: scheduleeditor.cpp:2311
GuessLookupType
LookupType GuessLookupType(ProgramInfo *pginfo)
Definition: metadatafactory.cpp:653
ImageDLEvent
Definition: metadataimagedownload.h:19
MetadataDownload
Definition: metadatadownload.h:36
MetadataFactoryNoResult::kEventType
static Type kEventType
Definition: metadatafactory.h:65
ScheduleEditor::ShowPostProc
void ShowPostProc(void)
Definition: scheduleeditor.cpp:474
MetadataLookup::GetArtwork
ArtworkList GetArtwork(VideoArtworkType type) const
Definition: metadatacommon.cpp:327
ScheduleCommon::ShowGuide
virtual void ShowGuide(void) const
Show the program guide.
Definition: schedulecommon.cpp:132
PostProcMixin::m_userjob1Check
MythUICheckBox * m_userjob1Check
Definition: scheduleeditor.h:109
PostProcMixin::m_commflagCheck
MythUICheckBox * m_commflagCheck
Definition: scheduleeditor.h:106
LOG
#define LOG(_MASK_, _LEVEL_, _QSTRING_)
Definition: mythlogging.h:23
playgroup.h
PostProcEditor::Load
void Load(void) override
Definition: scheduleeditor.cpp:1222
MythScreenType
Screen in which all other widgets are contained and rendered.
Definition: mythscreentype.h:45
MetadataFactoryMultiResult::kEventType
static Type kEventType
Definition: metadatafactory.h:29
mythuistatetype.h
InputFilter
InputFilter
Definition: mythuitextedit.h:18
SchedOptMixin::m_rule
RecordingRule * m_rule
Definition: scheduleeditor.h:55
SchedEditChild
Definition: scheduleeditor.h:245
ScheduleEditor::kMainView
@ kMainView
Definition: scheduleeditor.h:232
SchedFilterEditor::ToggleSelected
static void ToggleSelected(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:1086
RecordingRule::IsLoaded
bool IsLoaded() const
Definition: recordingrule.h:57
ScheduleEditor::ruleSaved
void ruleSaved(int ruleId)
MythUITextEdit::GetText
QString GetText(void) const
Definition: mythuitextedit.h:47
MetadataOptions::m_coverart
MythUIImage * m_coverart
Definition: scheduleeditor.h:410
MetadataOptions::MetadataOptions
MetadataOptions(MythScreenStack *parent, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:1245
MetadataOptions::Load
void Load(void) override
Definition: scheduleeditor.cpp:1365
recordingtypes.h
RecordingRule::m_dupIn
RecordingDupInType m_dupIn
Definition: recordingrule.h:116
StoreOptMixin::m_recgroupList
MythUIButtonList * m_recgroupList
Definition: scheduleeditor.h:79
fs10
static QString fs10(QT_TRANSLATE_NOOP("SchedFilterEditor", "This channel"))
RecordingRule::m_isInactive
bool m_isInactive
Recording rule is enabled?
Definition: recordingrule.h:76
ScheduleEditor::DeleteRule
void DeleteRule(void)
Definition: scheduleeditor.cpp:419
ENUM_TO_QVARIANT
#define ENUM_TO_QVARIANT(a)
Definition: scheduleeditor.cpp:47
StoreOptMixin::m_playgroupList
MythUIButtonList * m_playgroupList
Definition: scheduleeditor.h:81
StoreOptMixin::m_maxbehaviourList
MythUIButtonList * m_maxbehaviourList
Definition: scheduleeditor.h:83
MetadataOptions::HandleDownloadedImages
void HandleDownloadedImages(MetadataLookup *lookup)
Definition: scheduleeditor.cpp:1650
RecordingRule::m_season
uint m_season
Definition: recordingrule.h:96
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
ScheduleEditor::m_rulesList
MythUIButtonList * m_rulesList
Definition: scheduleeditor.h:216
MythMainWindow::GetStack
MythScreenStack * GetStack(const QString &stackname)
Definition: mythmainwindow.cpp:309
mythuibuttonlist.h
hardwareprofile.distros.mythtv_data.data_mythtv.prefix
string prefix
Definition: data_mythtv.py:40
mythuiimage.h
MythUIButtonList::GetCount
int GetCount() const
Definition: mythuibuttonlist.cpp:1655
ScheduleCommon::ShowDetails
virtual void ShowDetails(void) const
Show the Program Details screen.
Definition: schedulecommon.cpp:33
ScheduleEditor::ChildClosing
void ChildClosing(void)
Definition: scheduleeditor.cpp:781
mythprogressdialog.h
kDupsInAll
@ kDupsInAll
Definition: recordingtypes.h:47
MetadataLookup::toMap
void toMap(InfoMap &map)
Definition: metadatacommon.cpp:344
ScheduleEditor::ShowStoreOpt
void ShowStoreOpt(void)
Definition: scheduleeditor.cpp:449
MetadataOptions::Save
void Save(void) override
Definition: scheduleeditor.cpp:1480
ScheduleEditor::ShowMetadataOptions
void ShowMetadataOptions(void)
Definition: scheduleeditor.cpp:692
MetadataFactoryNoResult
Definition: metadatafactory.h:51
kLookupSearch
@ kLookupSearch
Definition: metadatacommon.h:27
proglist.h
PostProcMixin
Mixin for post processing.
Definition: scheduleeditor.h:94
MythScreenType::GetFocusWidget
MythUIType * GetFocusWidget(void) const
Definition: mythscreentype.cpp:112
PostProcMixin::m_rule
RecordingRule * m_rule
Definition: scheduleeditor.h:117
programtypes.h
MetadataLookup
Definition: metadatacommon.h:87
PostProcEditor::PostProcEditor
PostProcEditor(MythScreenStack *parent, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:1184
InfoMap
QHash< QString, QString > InfoMap
Definition: mythtypes.h:15
MetadataOptions::m_banner
MythUIImage * m_banner
Definition: scheduleeditor.h:411
ProgramInfo::kCategoryMovie
@ kCategoryMovie
Definition: programinfo.h:75
ScheduleEditor::ShowSchedInfo
void ShowSchedInfo(void)
Definition: scheduleeditor.cpp:499
PlayGroup::GetNames
static QStringList GetNames(void)
Definition: playgroup.cpp:206
TV::StartEmbedding
bool StartEmbedding(const QRect &embedRect)
Definition: tv_play.cpp:8457
FilterOptMixin::m_other
FilterOptMixin * m_other
Definition: scheduleeditor.h:141
kDupsInRecorded
@ kDupsInRecorded
Definition: recordingtypes.h:45
MetadataOptions::PerformQuery
void PerformQuery()
Definition: scheduleeditor.cpp:1390
SchedEditChild::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: scheduleeditor.cpp:882
MetadataLookupFailure::kEventType
static Type kEventType
Definition: metadatadownload.h:32
mythuiutils.h
RecordingRule::Load
bool Load(bool asTemplate=false)
Load a single rule from the recorded table.
Definition: recordingrule.cpp:58
MythUIButtonListItem
Definition: mythuibuttonlist.h:28
RecordingRule::m_startOffset
int m_startOffset
Definition: recordingrule.h:111
MetadataOptions::CreateBusyDialog
void CreateBusyDialog(const QString &title)
Definition: scheduleeditor.cpp:1370
ProgramInfo::GetYearOfInitialRelease
uint GetYearOfInitialRelease(void) const
Definition: programinfo.h:421
SchedEditChild::m_recInfo
RecordingInfo * m_recInfo
Definition: scheduleeditor.h:270
RecordingDupInType
RecordingDupInType
Definition: recordingtypes.h:43
RecordingRule::GetTemplateNames
static QStringList GetTemplateNames(void)
Definition: recordingrule.cpp:832
MythUISpinBox::SetValue
void SetValue(int val) override
Definition: mythuispinbox.h:26
viewschedulediff.h
MythUITextEdit::SetText
void SetText(const QString &text, bool moveCursor=true)
Definition: mythuitextedit.cpp:216
SchedOptMixin::m_haveRepeats
bool m_haveRepeats
Definition: scheduleeditor.h:58
ScheduleCommon::ShowPrevious
virtual void ShowPrevious(void) const
Show the previous recordings for this recording rule.
Definition: schedulecommon.cpp:248
MetadataOptions::m_popupStack
MythScreenStack * m_popupStack
Definition: scheduleeditor.h:406
FilterOptMixin::m_loaded
bool m_loaded
Definition: scheduleeditor.h:142
MetadataLookup::GetDownloads
DownloadMap GetDownloads() const
Definition: metadatacommon.h:371
RecordingRule::m_isTemplate
bool m_isTemplate
Definition: recordingrule.h:157
MythUIButtonList::IsEmpty
bool IsEmpty() const
Definition: mythuibuttonlist.cpp:1671
FilterOptMixin::m_descriptions
QStringList m_descriptions
Definition: scheduleeditor.h:144
ScheduleEditor::ShowPreview
void ShowPreview(void)
Definition: scheduleeditor.cpp:656
SchedOptMixin::m_screen
MythScreenType * m_screen
Definition: scheduleeditor.h:54
MetadataOptions::m_onlineBannerButton
MythUIButton * m_onlineBannerButton
Definition: scheduleeditor.h:425
ScheduleEditor::m_schedOptButton
MythUIButton * m_schedOptButton
Definition: scheduleeditor.h:218
RecordingRule::m_episode
uint m_episode
Definition: recordingrule.h:97
ScheduleEditor::FilterChanged
static void FilterChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:374
MetadataOptions::SelectOnlineCoverart
void SelectOnlineCoverart()
Definition: scheduleeditor.cpp:1470
SchedOptMixin::Save
void Save(void)
Definition: scheduleeditor.cpp:2098
SchedEditChild::Closing
void Closing(void)
ScheduleEditor::kSchedOptView
@ kSchedOptView
Definition: scheduleeditor.h:233
ScheduleEditor::m_saveButton
MythUIButton * m_saveButton
Definition: scheduleeditor.h:213
MetadataLookup::GetEpisode
uint GetEpisode() const
Definition: metadatacommon.h:314
SchedOptMixin::m_startoffsetSpin
MythUISpinBox * m_startoffsetSpin
Definition: scheduleeditor.h:45
ScheduleEditor::ShowSchedOpt
void ShowSchedOpt(void)
Definition: scheduleeditor.cpp:424
SchedOptMixin::DupMethodChanged
void DupMethodChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:2166
MythUIButtonListItem::setCheckable
void setCheckable(bool flag)
Definition: mythuibuttonlist.cpp:3555
SchedFilterEditor
Select schedule filters.
Definition: scheduleeditor.h:298
RecordingRule::m_autoUserJob4
bool m_autoUserJob4
Definition: recordingrule.h:137
StoreOptMixin::CreateRecordingGroup
static int CreateRecordingGroup(const QString &groupName)
Definition: scheduleeditor.cpp:2615
MetadataOptions::m_onlineCoverartButton
MythUIButton * m_onlineCoverartButton
Definition: scheduleeditor.h:424
MetadataLookupFailure
Definition: metadatadownload.h:24
SchedEditChild::CreateEditChild
virtual bool CreateEditChild(const QString &xmlfile, const QString &winname, bool isTemplate)
Definition: scheduleeditor.cpp:918
ArtworkInfo
Definition: metadataimagehelper.h:22
PostProcMixin::RuleChanged
void RuleChanged(void)
Definition: scheduleeditor.cpp:2809
ImageSearchResultsDialog
Definition: mythuiimageresults.h:11
hardwareprofile.config.p
p
Definition: config.py:33
MetadataOptions::m_artworkMap
ArtworkMap m_artworkMap
Definition: scheduleeditor.h:427
kTemplateRecord
@ kTemplateRecord
Definition: recordingtypes.h:32
RefCountedList< MetadataLookup >
MetadataOptions::m_seasonSpin
MythUISpinBox * m_seasonSpin
Definition: scheduleeditor.h:415
MythDialogBox
Basic menu dialog, message and a list of options.
Definition: mythdialogbox.h:138
MetadataLookup::GetData
QVariant GetData() const
Definition: metadatacommon.h:287
SetArtwork
bool SetArtwork(const QString &inetref, uint season, const QString &host, const QString &coverart, const QString &fanart, const QString &banner)
Definition: metadataimagehelper.cpp:93
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:535
RecordingRule::m_autoUserJob2
bool m_autoUserJob2
Definition: recordingrule.h:135
ScheduleEditor::ruleDeleted
void ruleDeleted(int ruleId)
ScheduleEditor::kStoreOptView
@ kStoreOptView
Definition: scheduleeditor.h:235
MythUISpinBox::GetIntValue
int GetIntValue(void) const override
Definition: mythuispinbox.h:33
ScheduleEditor::m_schedInfoButton
MythUIButton * m_schedInfoButton
Definition: scheduleeditor.h:221
MetadataFactorySingleResult::kEventType
static Type kEventType
Definition: metadatafactory.h:47
MetadataOptions::m_localBannerButton
MythUIButton * m_localBannerButton
Definition: scheduleeditor.h:422
FilterPunct
@ FilterPunct
Definition: mythuitextedit.h:24
kDupsInOldRecorded
@ kDupsInOldRecorded
Definition: recordingtypes.h:46
StoreOptEditor::StoreOptEditor
StoreOptEditor(MythScreenStack *parent, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:1098
fs8
static QString fs8(QT_TRANSLATE_NOOP("SchedFilterEditor", "This time"))
ScheduleEditor::showMenu
void showMenu(void)
Definition: scheduleeditor.cpp:796
MythScreenType::BuildFocusList
void BuildFocusList(void)
Definition: mythscreentype.cpp:222
ScheduleEditor::m_previewButton
MythUIButton * m_previewButton
Definition: scheduleeditor.h:222
RecordingRule::m_autoExpire
bool m_autoExpire
Definition: recordingrule.h:127
FilterOptMixin::m_filtersList
MythUIButtonList * m_filtersList
Definition: scheduleeditor.h:135
StoreOptMixin::MaxEpisodesChanged
void MaxEpisodesChanged(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:2557
CardUtil::GetSchedInputList
static vector< uint > GetSchedInputList(void)
Definition: cardutil.cpp:2681
RecordingRule::m_recProfile
QString m_recProfile
Definition: recordingrule.h:121
PostProcEditor
Select post-processing options.
Definition: scheduleeditor.h:336
ScheduleEditor::m_metadataButton
MythUIButton * m_metadataButton
Definition: scheduleeditor.h:223
StoreOptMixin::Save
void Save(void)
Definition: scheduleeditor.cpp:2497
RecordingRule::m_tempID
int m_tempID
Definition: recordingrule.h:149
MythErrorNotification
Definition: mythnotification.h:362
StoreOptMixin::RuleChanged
void RuleChanged(void)
Definition: scheduleeditor.cpp:2530
mythtypes.h
kArtworkFanart
@ kArtworkFanart
Definition: metadataimagehelper.h:12
RecordingRule::m_searchType
RecSearchType m_searchType
Definition: recordingrule.h:114
FilterSymbols
@ FilterSymbols
Definition: mythuitextedit.h:23
MythUIComposite::SetTextFromMap
virtual void SetTextFromMap(const InfoMap &infoMap)
Definition: mythuicomposite.cpp:9
ScheduleCommon
Definition: schedulecommon.h:16
MetadataOptions::m_imageLookup
MetadataDownload * m_imageLookup
Definition: scheduleeditor.h:403
RecordingRule::m_type
RecordingType m_type
Definition: recordingrule.h:113
ScheduleEditor::m_player
TV * m_player
Definition: scheduleeditor.h:226
MetadataOptions::GetSupportedImageExtensionFilter
static QStringList GetSupportedImageExtensionFilter()
Definition: scheduleeditor.cpp:1540
ScheduleEditor::RunScheduleEditor
static void * RunScheduleEditor(ProgramInfo *proginfo, void *player=nullptr)
Callback.
Definition: scheduleeditor.cpp:66
RecordingRule::m_subtitle
QString m_subtitle
Definition: recordingrule.h:81
ScheduleEditor::m_loaded
bool m_loaded
Definition: scheduleeditor.h:228
MythUIButtonList::GetDataValue
QVariant GetDataValue() const
Definition: mythuibuttonlist.cpp:1619
RecordingRule::UseTempTable
void UseTempTable(bool usetemp, const QString &table="record_tmp")
Definition: recordingrule.cpp:674
ScheduleEditor::kMetadataView
@ kMetadataView
Definition: scheduleeditor.h:237
MetadataOptions::m_onlineFanartButton
MythUIButton * m_onlineFanartButton
Definition: scheduleeditor.h:423
PostProcMixin::TranscodeChanged
void TranscodeChanged(bool enable)
Definition: scheduleeditor.cpp:2836
ScheduleEditor::PromptForRecGroup
void PromptForRecGroup(void)
Definition: scheduleeditor.cpp:384
fs5
static QString fs5(QT_TRANSLATE_NOOP("SchedFilterEditor", "High definition"))
PostProcMixin::Save
void Save(void)
Definition: scheduleeditor.cpp:2785
storagegroup.h
MythUIBusyDialog
Definition: mythprogressdialog.h:37
MythUIType::SetEnabled
void SetEnabled(bool enable)
Definition: mythuitype.cpp:1108
fs9
static QString fs9(QT_TRANSLATE_NOOP("SchedFilterEditor", "This day and time"))
MetadataOptions::SelectOnlineBanner
void SelectOnlineBanner()
Definition: scheduleeditor.cpp:1475
MetadataDownload::addLookup
void addLookup(MetadataLookup *lookup)
addLookup: Add lookup to bottom of the queue MetadataDownload::m_lookupList takes ownership of the gi...
Definition: metadatadownload.cpp:35
mythuifilebrowser.h
kNoSearch
@ kNoSearch
Definition: recordingtypes.h:73
RecordingRule::m_filter
unsigned m_filter
Definition: recordingrule.h:117
SchedEditChild::Close
void Close(void) override
Definition: scheduleeditor.cpp:957
SchedEditChild::m_saveButton
MythUIButton * m_saveButton
Definition: scheduleeditor.h:273
SchedEditChild::Load
void Load(void) override=0
ScheduleEditor::templateLoaded
void templateLoaded(void)
MythUIButtonListItem::GetData
QVariant GetData()
Definition: mythuibuttonlist.cpp:3580
FilterOptMixin::Create
void Create(bool *err)
Definition: scheduleeditor.cpp:2185
PostProcMixin::Load
void Load(void)
Definition: scheduleeditor.cpp:2685
kManualSearch
@ kManualSearch
Definition: recordingtypes.h:78
MetadataOptions
Select artwork and inetref for recordings.
Definition: scheduleeditor.h:354
PostProcMixin::SetRule
void SetRule(RecordingRule *rule)
Definition: scheduleeditor.h:99
uint
unsigned int uint
Definition: compat.h:140
SchedEditChild::m_previewButton
MythUIButton * m_previewButton
Definition: scheduleeditor.h:274
FilterOptMixin::m_screen
MythScreenType * m_screen
Definition: scheduleeditor.h:139
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:57
ScheduleEditor::m_recInfo
RecordingInfo * m_recInfo
Definition: scheduleeditor.h:208
toDescription
QString toDescription(RecordingType rectype)
Converts "rectype" into a human readable description.
Definition: recordingtypes.cpp:50
ScheduleEditor::m_cancelButton
MythUIButton * m_cancelButton
Definition: scheduleeditor.h:214
MetadataFactoryMultiResult
Definition: metadatafactory.h:21
MythUIFileBrowser
Definition: mythuifilebrowser.h:81
StoreOptMixin::m_maxepSpin
MythUISpinBox * m_maxepSpin
Definition: scheduleeditor.h:82
MythScreenType::GetScreenStack
MythScreenStack * GetScreenStack() const
Definition: mythscreentype.cpp:233
RecordingRule::m_maxEpisodes
int m_maxEpisodes
Definition: recordingrule.h:126
kOneRecord
@ kOneRecord
Definition: recordingtypes.h:27
MetadataFactory
Definition: metadatafactory.h:86
UIUtilDisp::Assign
static bool Assign(ContainerType *container, UIType *&item, const QString &name, bool *err=nullptr)
Definition: mythuiutils.h:27
MetadataLookup::GetSeason
uint GetSeason() const
Definition: metadatacommon.h:313
SchedEditChild::m_backButton
MythUIButton * m_backButton
Definition: scheduleeditor.h:272
MetadataOptions::SelectLocalFanart
void SelectLocalFanart()
Definition: scheduleeditor.cpp:1432
StoreOptMixin
Mixin for storage options.
Definition: scheduleeditor.h:62
MetadataOptions::Create
bool Create(void) override
Definition: scheduleeditor.cpp:1278
SchedOptMixin::RuleChanged
void RuleChanged(void)
Definition: scheduleeditor.cpp:2132
StoreOptEditor::PromptForRecGroup
void PromptForRecGroup(void)
Definition: scheduleeditor.cpp:1150
kUnknownVideo
@ kUnknownVideo
Definition: metadatacommon.h:53
RecordingRule::m_recGroupID
uint m_recGroupID
Definition: recordingrule.h:124
SchedFilterEditor::SchedFilterEditor
SchedFilterEditor(MythScreenStack *parent, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:1038
fs11
static QString fs11(QT_TRANSLATE_NOOP("SchedFilterEditor", "No episodes"))
MetadataOptions::m_localCoverartButton
MythUIButton * m_localCoverartButton
Definition: scheduleeditor.h:421
ScheduleEditor::ShowNextView
void ShowNextView(void)
Definition: scheduleeditor.cpp:761
mythuispinbox.h
ScheduleEditor::m_storeOptButton
MythUIButton * m_storeOptButton
Definition: scheduleeditor.h:219
ViewScheduleDiff
Definition: viewschedulediff.h:25
mythuihelper.h
kWeeklyRecord
@ kWeeklyRecord
Definition: recordingtypes.h:26
ScheduleEditor::LoadTemplate
void LoadTemplate(const QString &name)
Definition: scheduleeditor.cpp:333
RecordingRule::m_storageGroup
QString m_storageGroup
Definition: recordingrule.h:122
fs1
static QString fs1(QT_TRANSLATE_NOOP("SchedFilterEditor", "Identifiable episode"))
StoreOptEditor::Load
void Load(void) override
Definition: scheduleeditor.cpp:1139
fs3
static QString fs3(QT_TRANSLATE_NOOP("SchedFilterEditor", "Prime time"))
ProgramInfo::GetEpisode
uint GetEpisode(void) const
Definition: programinfo.h:365
RecordingRule::m_transcoder
int m_transcoder
Definition: recordingrule.h:131
RecordingRule::m_autoUserJob1
bool m_autoUserJob1
Definition: recordingrule.h:134
MetadataFactorySingleResult
Definition: metadatafactory.h:33
StoreOptMixin::m_screen
MythScreenType * m_screen
Definition: scheduleeditor.h:87
ProgramInfo
Holds information on recordings and videos.
Definition: programinfo.h:68
RecordingRule::ToMap
void ToMap(InfoMap &infoMap) const
Definition: recordingrule.cpp:551
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
RecordingRule::m_recordID
int m_recordID
Unique Recording Rule ID.
Definition: recordingrule.h:72
MetadataLookupEvent::kEventType
static Type kEventType
Definition: metadatadownload.h:20
MetadataLookup::SetData
void SetData(QVariant data)
Definition: metadatacommon.h:241
MetadataOptions::SelectLocalCoverart
void SelectLocalCoverart()
Definition: scheduleeditor.cpp:1443
MythConfirmationDialog
Dialog asking for user confirmation.
Definition: mythdialogbox.h:222
ProgramInfo::GetSeason
uint GetSeason(void) const
Definition: programinfo.h:364
mythcorecontext.h
SchedOptMixin::m_loaded
bool m_loaded
Definition: scheduleeditor.h:57
StoreOptEditor::Save
void Save(void) override
Definition: scheduleeditor.cpp:1172
ScheduleEditor::keyPressEvent
bool keyPressEvent(QKeyEvent *event) override
Key event handler.
Definition: scheduleeditor.cpp:526
SchedOptMixin::m_other
SchedOptMixin * m_other
Definition: scheduleeditor.h:56
MetadataOptions::ValuesChanged
void ValuesChanged()
Definition: scheduleeditor.cpp:1679
MetadataLookup::SetAutomatic
void SetAutomatic(bool autom)
Definition: metadatacommon.h:245
MythUICheckBox::SetCheckState
void SetCheckState(MythUIStateType::StateType state)
Definition: mythuicheckbox.cpp:66
XMLParseBase::LoadWindowFromXML
static bool LoadWindowFromXML(const QString &xmlfile, const QString &windowname, MythUIType *parent)
Definition: xmlparsebase.cpp:692
cardutil.h
kOverrideRecord
@ kOverrideRecord
Definition: recordingtypes.h:28
FilterOptMixin::RuleChanged
void RuleChanged(void)
Definition: scheduleeditor.cpp:2283
RecordingRule::m_dupMethod
RecordingDupMethodType m_dupMethod
Definition: recordingrule.h:115
MetadataLookup::GetInetref
QString GetInetref() const
Definition: metadatacommon.h:355
fs2
static QString fs2(QT_TRANSLATE_NOOP("SchedFilterEditor", "First showing"))
SchedOptMixin::m_dupscopeList
MythUIButtonList * m_dupscopeList
Definition: scheduleeditor.h:48
MetadataOptions::OnSearchListSelection
void OnSearchListSelection(const RefCountHandler< MetadataLookup > &lookup)
Definition: scheduleeditor.cpp:1401
FilterOptMixin::Load
void Load(void)
Definition: scheduleeditor.cpp:2200
StoreOptMixin::Load
void Load(void)
Definition: scheduleeditor.cpp:2352
SchedOptMixin::Create
void Create(bool *err)
Definition: scheduleeditor.cpp:1926
kNotRecording
@ kNotRecording
Definition: recordingtypes.h:21
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:864
kDupCheckNone
@ kDupCheckNone
Definition: recordingtypes.h:60
SchedOptMixin::Load
void Load(void)
Definition: scheduleeditor.cpp:1969
DialogCompletionEvent
Event dispatched from MythUI modal dialogs to a listening class containing a result of some form.
Definition: mythdialogbox.h:42
StoreOptMixin::PromptForRecGroup
void PromptForRecGroup(void)
Definition: scheduleeditor.cpp:2568
kSingleRecord
@ kSingleRecord
Definition: recordingtypes.h:22
ScheduleEditor::ShowFilters
void ShowFilters(void)
Definition: scheduleeditor.cpp:716
SchedEditChild::m_editor
ScheduleEditor * m_editor
Definition: scheduleeditor.h:268
SchedOptMixin::m_ruleactiveCheck
MythUICheckBox * m_ruleactiveCheck
Definition: scheduleeditor.h:50
MythUIText::SetText
virtual void SetText(const QString &text)
Definition: mythuitext.cpp:134
MythUIButtonListItem::state
CheckState state() const
Definition: mythuibuttonlist.cpp:3534
LookupType
LookupType
Definition: metadatacommon.h:49
GetNotificationCenter
MythNotificationCenter * GetNotificationCenter(void)
Definition: mythmainwindow.cpp:127
MythScreenStack::PopScreen
virtual void PopScreen(MythScreenType *screen=nullptr, bool allowFade=true, bool deleteScreen=true)
Definition: mythscreenstack.cpp:83
ProgramInfo::ToMap
virtual void ToMap(InfoMap &progMap, bool showrerecord=false, uint star_range=10) const
Converts ProgramInfo into QString QHash containing each field in ProgramInfo converted into localized...
Definition: programinfo.cpp:1464
ScheduleCommon::ShowUpcoming
virtual void ShowUpcoming(void) const
Show the upcoming recordings for this title.
Definition: schedulecommon.cpp:73
PostProcMixin::m_userjob4Check
MythUICheckBox * m_userjob4Check
Definition: scheduleeditor.h:112
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
mythuiimageresults.h
SchedOptEditor::SchedOptEditor
SchedOptEditor(MythScreenStack *parent, ScheduleEditor &editor, RecordingRule &rule, RecordingInfo *recinfo)
Definition: scheduleeditor.cpp:971
GetMythMainWindow
MythMainWindow * GetMythMainWindow(void)
Definition: mythmainwindow.cpp:107
SchedOptMixin::m_dupmethodList
MythUIButtonList * m_dupmethodList
Definition: scheduleeditor.h:47
MythUIButtonList::SetItemCurrent
void SetItemCurrent(MythUIButtonListItem *item)
Definition: mythuibuttonlist.cpp:1557
build_compdb.action
action
Definition: build_compdb.py:9
PostProcMixin::m_other
PostProcMixin * m_other
Definition: scheduleeditor.h:118
kArtworkBanner
@ kArtworkBanner
Definition: metadataimagehelper.h:13
SchedOptEditor
Select schedule options.
Definition: scheduleeditor.h:278
PostProcEditor::Save
void Save(void) override
Definition: scheduleeditor.cpp:1233
SchedFilterEditor::Save
void Save(void) override
Definition: scheduleeditor.cpp:1081
SchedOptMixin
Mixin for schedule options.
Definition: scheduleeditor.h:33
mythuibutton.h
RecordingRule::Delete
bool Delete(bool sendSig=true)
Definition: recordingrule.cpp:508
plRecordid
@ plRecordid
Definition: proglist.h:26
SchedOptMixin::m_inputList
MythUIButtonList * m_inputList
Definition: scheduleeditor.h:49
StoreOptMixin::m_other
StoreOptMixin * m_other
Definition: scheduleeditor.h:89
DownloadMap
QMap< VideoArtworkType, ArtworkInfo > DownloadMap
Definition: metadatacommon.h:83
ArtworkMap
QMultiMap< VideoArtworkType, ArtworkInfo > ArtworkMap
Definition: metadataimagehelper.h:31
MetadataOptions::m_localFanartButton
MythUIButton * m_localFanartButton
Definition: scheduleeditor.h:420
kAllRecord
@ kAllRecord
Definition: recordingtypes.h:25
recordingprofile.h
StoreOptEditor
Select storage options.
Definition: scheduleeditor.h:316
StoreOptMixin::m_recprofileList
MythUIButtonList * m_recprofileList
Definition: scheduleeditor.h:78
MetadataOptions::FindNetArt
void FindNetArt(VideoArtworkType type)
Definition: scheduleeditor.cpp:1605
StoreOptMixin::SetRecGroup
void SetRecGroup(int recgroupID, QString recgroup)
Definition: scheduleeditor.cpp:2590
ScheduleEditor::showUpcomingByTitle
void showUpcomingByTitle(void)
Definition: scheduleeditor.cpp:638
kDupsNewEpi
@ kDupsNewEpi
Definition: recordingtypes.h:48
StoreOptMixin::SetRule
void SetRule(RecordingRule *rule)
Definition: scheduleeditor.h:67
RecordingRule::m_station
QString m_station
Definition: recordingrule.h:101
MythTextInputDialog
Dialog prompting the user to enter a text string.
Definition: mythdialogbox.h:264
MetadataOptions::m_busyPopup
MythUIBusyDialog * m_busyPopup
Definition: scheduleeditor.h:407
MetadataOptions::m_inetrefEdit
MythUITextEdit * m_inetrefEdit
Definition: scheduleeditor.h:413
ProgramInfo::GetRecordingRuleID
uint GetRecordingRuleID(void) const
Definition: programinfo.h:447
ScheduleEditor::m_filtersButton
MythUIButton * m_filtersButton
Definition: scheduleeditor.h:224
mythuicheckbox.h
MythUIImage::SetFilename
void SetFilename(const QString &filename)
Must be followed by a call to Load() to load the image.
Definition: mythuiimage.cpp:676
FilterOptMixin::ToggleSelected
static void ToggleSelected(MythUIButtonListItem *item)
Definition: scheduleeditor.cpp:2296
FilterOptMixin
Mixin for Filters.
Definition: scheduleeditor.h:123
MythUIType::LosingFocus
void LosingFocus()
ScheduleEditor::m_recordingRule
RecordingRule * m_recordingRule
Definition: scheduleeditor.h:209
PostProcMixin::m_transcodeprofileList
MythUIButtonList * m_transcodeprofileList
Definition: scheduleeditor.h:108
RecordingRule::m_recPriority
int m_recPriority
Definition: recordingrule.h:109
SchedOptEditor::Load
void Load(void) override
Definition: scheduleeditor.cpp:1015
StoreOptEditor::Create
bool Create(void) override
Definition: scheduleeditor.cpp:1107
StoreOptMixin::m_loaded
bool m_loaded
Definition: scheduleeditor.h:90
RecordingRule::m_autoUserJob3
bool m_autoUserJob3
Definition: recordingrule.h:136
SchedOptEditor::Save
void Save(void) override
Definition: scheduleeditor.cpp:1021
kProbableMovie
@ kProbableMovie
Definition: metadatacommon.h:52
SchedOptMixin::m_endoffsetSpin
MythUISpinBox * m_endoffsetSpin
Definition: scheduleeditor.h:46
mythmainwindow.h
MythUIButtonListItem::setChecked
void setChecked(CheckState state)
Definition: mythuibuttonlist.cpp:3544
ProgramInfo::GetCategoryType
CategoryType GetCategoryType(void) const
Definition: programinfo.h:436
fs7
static QString fs7(QT_TRANSLATE_NOOP("SchedFilterEditor", "This series"))
MythScreenStack::AddScreen
virtual void AddScreen(MythScreenType *screen, bool allowFade=true)
Definition: mythscreenstack.cpp:49
ScheduleEditor::m_postProcButton
MythUIButton * m_postProcButton
Definition: scheduleeditor.h:220
StoreOptMixin::m_storagegroupList
MythUIButtonList * m_storagegroupList
Definition: scheduleeditor.h:80
query
MSqlQuery query(MSqlQuery::InitCon())
ScheduleEditor
Construct a recording schedule.
Definition: scheduleeditor.h:150
MetadataLookupEvent
Definition: metadatadownload.h:12
kArtworkCoverart
@ kArtworkCoverart
Definition: metadataimagehelper.h:11
kDupCheckSubDesc
@ kDupCheckSubDesc
Definition: recordingtypes.h:63
ScheduleEditor::showUpcomingByRule
void showUpcomingByRule(void)
Definition: scheduleeditor.cpp:616
kDontRecord
@ kDontRecord
Definition: recordingtypes.h:29
PostProcEditor::Create
bool Create(void) override
Definition: scheduleeditor.cpp:1193
ScheduleEditor::m_child
SchedEditChild * m_child
Definition: scheduleeditor.h:241
videoutils.h
RecordingRule::m_autoMetadataLookup
bool m_autoMetadataLookup
Definition: recordingrule.h:138
FilterOptMixin::m_rule
RecordingRule * m_rule
Definition: scheduleeditor.h:140
RecordingRule::m_prefInput
int m_prefInput
Definition: recordingrule.h:110
ImageDLEvent::kEventType
static Type kEventType
Definition: metadataimagedownload.h:41
ScheduleEditor::kPostProcView
@ kPostProcView
Definition: scheduleeditor.h:236
MythCoreContext::GetSetting
QString GetSetting(const QString &key, const QString &defaultval="")
Definition: mythcorecontext.cpp:916
RecordingType
Definition: recordingprofile.cpp:1225
ArtworkInfo::url
QString url
Definition: metadataimagehelper.h:25
MythUIButtonListItem::NotChecked
@ NotChecked
Definition: mythuibuttonlist.h:32
MetadataOptions::OnArtworkSearchDone
void OnArtworkSearchDone(MetadataLookup *lookup)
Definition: scheduleeditor.cpp:1620
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:808
SchedFilterEditor::Load
void Load(void) override
Definition: scheduleeditor.cpp:1075
PostProcMixin::Create
void Create(bool *err)
Definition: scheduleeditor.cpp:2642
MetadataDownload::cancel
void cancel()
Definition: metadatadownload.cpp:61
tv_play.h
MetadataImageDownload::addDownloads
void addDownloads(MetadataLookup *lookup)
addLookup: Add lookup to bottom of the queue MetadataDownload::m_downloadList takes ownership of the ...
Definition: metadataimagedownload.cpp:53
MythNotificationCenter::Queue
bool Queue(const MythNotification &notification)
Queue a notification Queue() is thread-safe and can be called from anywhere.
Definition: mythnotificationcenter.cpp:1351
ScheduleEditor::TranscodeChanged
void TranscodeChanged(bool enable)
Definition: scheduleeditor.cpp:389
TV
Control TV playback.
Definition: tv_play.h:281
ScheduleEditor::kFilterView
@ kFilterView
Definition: scheduleeditor.h:234
Generated on Tue Sep 29 2020 04:15:38 for MythTV by doxygen 1.8.20