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