MythTV  master
channelsettings.cpp
Go to the documentation of this file.
1 // C/C++ headers
2 #include <utility>
3 
4 // Qt headers
5 #include <QCoreApplication>
6 #include <QFile>
7 #include <QWidget>
8 
9 // MythTV headers
10 #include "libmythbase/mythdirs.h"
11 #include "libmythbase/programinfo.h" // for COMM_DETECT*, GetPreferredSkipTypeCombinations()
12 
13 #include "cardutil.h"
14 #include "channelsettings.h"
15 #include "channelutil.h"
16 #include "mpeg/mpegtables.h"
17 
18 
20 {
21  QString fieldTag = (":WHERE" + m_id.getField().toUpper());
22  QString query(m_id.getField() + " = " + fieldTag);
23 
24  bindings.insert(fieldTag, m_id.getValue());
25 
26  return query;
27 }
28 
30 {
31  QString fieldTag = (":SET" + m_id.getField().toUpper());
32  QString nameTag = (":SET" + GetColumnName().toUpper());
33 
34  QString query(m_id.getField() + " = " + fieldTag + ", " +
35  GetColumnName() + " = " + nameTag);
36 
37  bindings.insert(fieldTag, m_id.getValue());
38  bindings.insert(nameTag, m_user->GetDBValue());
39 
40  return query;
41 }
42 
44 {
45  QString fieldTag = (":WHERE" + m_id.getField().toUpper());
46  QString query(m_id.getField() + " = " + fieldTag);
47 
48  bindings.insert(fieldTag, m_id.getValue());
49 
50  return query;
51 }
52 
54 {
55  QString fieldTag = (":SET" + m_id.getField().toUpper());
56  QString nameTag = (":SET" + GetColumnName().toUpper());
57 
58  QString query(m_id.getField() + " = " + fieldTag + ", " +
59  GetColumnName() + " = " + nameTag);
60 
61  bindings.insert(fieldTag, m_id.getValue());
62  bindings.insert(nameTag, m_user->GetDBValue());
63 
64  return query;
65 }
66 
67 /*****************************************************************************
68  Channel Options - Common
69  *****************************************************************************/
70 
72 {
73  public:
74  explicit Name(const ChannelID &id) :
75  MythUITextEditSetting(new ChannelDBStorage(this, id, "name"))
76  {
77  setLabel(QCoreApplication::translate("(Common)", "Channel Name"));
78  }
79 };
80 
82 {
83  public:
84  explicit Channum(const ChannelID &id) :
85  MythUITextEditSetting(new ChannelDBStorage(this, id, "channum"))
86  {
87  setLabel(QCoreApplication::translate("(Common)", "Channel Number"));
88  setHelpText(QCoreApplication::translate("(Common)",
89  "This is the number by which the channel is known to MythTV."));
90  }
91 };
92 
94 {
95  public:
96  Source(const ChannelID &id, uint _default_sourceid) :
97  MythUIComboBoxSetting(new ChannelDBStorage(this, id, "sourceid")),
98  m_defaultSourceId(_default_sourceid)
99  {
100  setLabel(QCoreApplication::translate("(Common)", "Video Source"));
101  setHelpText(QCoreApplication::translate("(Common)",
102  "It is NOT a good idea to change this value as it only changes "
103  "the sourceid in table channel but not in dtv_multiplex. "
104  "The sourceid in dtv_multiplex cannot and should not be changed."));
105  }
106 
107  void Load(void) override // StandardSetting
108  {
109  fillSelections();
111 
112  if ((m_defaultSourceId != 0U) && (getValue().toUInt() == 0U))
113  {
115  if (which)
116  setValue(which);
117  }
118  }
119 
120  void fillSelections(void)
121  {
122  addSelection(QCoreApplication::translate("(ChannelSettings)",
123  "[Not Selected]"), "0");
124 
125  MSqlQuery query(MSqlQuery::InitCon());
126  query.prepare("SELECT name, sourceid "
127  "FROM videosource "
128  "ORDER BY sourceid");
129 
130  if (!query.exec() || !query.isActive())
131  {
132  MythDB::DBError("Source::fillSelections", query);
133  }
134  else
135  {
136  for (uint i = 1; query.next(); i++)
137  {
138  m_sourceIdToIndex[query.value(1).toUInt()] = i;
139  addSelection(query.value(0).toString(),
140  query.value(1).toString());
141  }
142  }
143 
144  m_sourceIdToIndex[0] = 0; // Not selected entry.
145  }
146 
147  private:
149  QMap<uint,uint> m_sourceIdToIndex;
150 };
151 
153 {
154  public:
155  explicit Callsign(const ChannelID &id) :
156  MythUITextEditSetting(new ChannelDBStorage(this, id, "callsign"))
157  {
158  setLabel(QCoreApplication::translate("(Common)", "Callsign"));
159  }
160 };
161 
163  MythUIComboBoxSetting(new ChannelDBStorage(this, id, "tvformat"))
164 {
165  setLabel(QCoreApplication::translate("(ChannelSettings)", "TV Format"));
166  setHelpText(QCoreApplication::translate("(ChannelSettings)",
167  "If this channel uses a format other than TV Format in the General "
168  "Backend Setup screen, set it here."));
169 
170  addSelection(QCoreApplication::translate("(Common)", "Default"), "Default");
171 
172  QStringList list = GetFormats();
173  for (const QString& format : std::as_const(list))
174  addSelection(format);
175 }
176 
178 {
179  QStringList list;
180 
181  list.push_back("NTSC");
182  list.push_back("NTSC-JP");
183  list.push_back("PAL");
184  list.push_back("PAL-60");
185  list.push_back("PAL-BG");
186  list.push_back("PAL-DK");
187  list.push_back("PAL-D");
188  list.push_back("PAL-I");
189  list.push_back("PAL-M");
190  list.push_back("PAL-N");
191  list.push_back("PAL-NC");
192  list.push_back("SECAM");
193  list.push_back("SECAM-D");
194  list.push_back("SECAM-DK");
195 
196  return list;
197 }
198 
200 {
201  public:
202  explicit TimeOffset(const ChannelID &id) :
203  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "tmoffset"),
204  -1440, 1440, 1)
205  {
206  setLabel(QCoreApplication::translate("(ChannelSettings)",
207  "DataDirect Time Offset"));
208 
209  setHelpText(QCoreApplication::translate("(ChannelSettings)",
210  "Offset (in minutes) to apply to the program guide data during "
211  "import. This can be used when the listings for a particular "
212  "channel are in a different time zone."));
213  }
214 };
215 
217 {
218  public:
219  explicit Priority(const ChannelID &id) :
220  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "recpriority"),
221  -99, 99, 1)
222  {
223  setLabel(QCoreApplication::translate("(ChannelSettings)", "Priority"));
224 
225  setHelpText(QCoreApplication::translate("(ChannelSettings)",
226  "Number of priority points to be added to any recording on this "
227  "channel during scheduling. Use a positive number as the priority "
228  "if you want this to be a preferred channel, a negative one to "
229  "depreciate this channel."));
230  }
231 };
232 
234 {
235  public:
236  explicit Icon(const ChannelID &id) :
237  MythUITextEditSetting(new ChannelDBStorage(this, id, "icon"))
238  {
239  setLabel(QCoreApplication::translate("(ChannelSettings)", "Icon"));
240 
241  setHelpText(QCoreApplication::translate("(ChannelSettings)",
242  "Image file to use as the icon for this channel on various MythTV "
243  "displays."));
244  }
245 };
246 
248 {
249  public:
250  explicit VideoFilters(const ChannelID &id) :
251  MythUITextEditSetting(new ChannelDBStorage(this, id, "videofilters"))
252  {
253  setLabel(QCoreApplication::translate("(ChannelSettings)",
254  "Video filters"));
255 
256  setHelpText(QCoreApplication::translate("(ChannelSettings)",
257  "Filters to be used when recording from this channel. Not used "
258  "with hardware encoding cards."));
259 
260  }
261 };
262 
263 
265 {
266  public:
267  explicit OutputFilters(const ChannelID &id) :
268  MythUITextEditSetting(new ChannelDBStorage(this, id, "outputfilters"))
269  {
270  setLabel(QCoreApplication::translate("(ChannelSettings)",
271  "Playback filters"));
272 
273  setHelpText(QCoreApplication::translate("(ChannelSettings)",
274  "Filters to be used when recordings from this channel are viewed. "
275  "Start with a plus to append to the global playback filters."));
276  }
277 };
278 
280 {
281  public:
282  XmltvID(const ChannelID &id, QString _sourceName) :
283  MythUIComboBoxSetting(new ChannelDBStorage(this, id, "xmltvid"), true),
284  m_sourceName(std::move(_sourceName))
285  {
286  setLabel(QCoreApplication::translate("(Common)", "XMLTV ID"));
287 
288  setHelpText(QCoreApplication::translate("(ChannelSettings)",
289  "ID used by listing services to get an exact correspondence "
290  "between a channel in your line-up and a channel in their "
291  "database. Normally this is set automatically when "
292  "'mythfilldatabase' is run."));
293  }
294 
295  void Load(void) override // StandardSetting
296  {
297  fillSelections();
299  }
300 
301  void fillSelections(void)
302  {
303  clearSelections();
304 
305  QString xmltvFile = GetConfDir() + '/' + m_sourceName + ".xmltv";
306 
307  if (QFile::exists(xmltvFile))
308  {
309  QFile file(xmltvFile);
310  if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
311  return;
312 
313  QStringList idList;
314 
315  while (!file.atEnd())
316  {
317  QByteArray line = file.readLine();
318 
319  if (line.startsWith("channel="))
320  {
321  QString id = line.mid(8, -1).trimmed();
322  idList.append(id);
323  }
324  }
325 
326  idList.sort();
327 
328  for (const QString& idName : std::as_const(idList))
329  addSelection(idName, idName);
330  }
331  }
332 
333  private:
334  QString m_sourceName;
335 };
336 
338 {
339  public:
340  explicit ServiceID(const ChannelID &id)
341  : MythUISpinBoxSetting(new ChannelDBStorage(this, id, "serviceid"),
342  -1, UINT16_MAX, 1, 1, "NULL")
343  {
344  setLabel(QCoreApplication::translate("(ChannelSettings)", "Service ID"));
345 
346  setHelpText(QCoreApplication::translate("(ChannelSettings)",
347  "Service ID (Program Number) of desired channel within the transport stream. "
348  "If there is only one channel, then setting this to anything will still find it."));
349  }
350 
351  void Load(void) override // StandardSetting
352  {
354 
355  if (getValue().isNull())
356  setValue("-1");
357  }
358 
359  QString getValue(void) const override // StandardSetting
360  {
361  if (StandardSetting::getValue().toInt() == -1)
362  return {};
363  return StandardSetting::getValue();
364  }
365 };
366 
367 // Transport ID in Channel Options
369 {
370  public:
372  {
373  setLabel(QObject::tr("Transport ID"));
374  setHelpText(
375  QObject::tr("The transport stream ID (tid) can be used to identify "
376  "the transport of this channel in the Transport Editor."));
377  }
378 };
379 
380 // Frequency in Channel Options
382 {
383  public:
385  {
386  setLabel(QObject::tr("Frequency"));
387  setHelpText(
388  QObject::tr("Frequency of the transport of this channel in Hz for "
389  "DVB-T/T2/C or in kHz plus polarization H or V for DVB-S/S2."));
390  }
391 };
392 
394 {
395  public:
396  explicit CommMethod(const ChannelID &id) :
397  MythUIComboBoxSetting(new ChannelDBStorage(this, id, "commmethod"))
398  {
399  setLabel(QCoreApplication::translate("(ChannelSettings)",
400  "Commercial Detection Method"));
401 
402  setHelpText(QCoreApplication::translate("(ChannelSettings)",
403  "Changes the method of commercial detection used for recordings on "
404  "this channel or skips detection by marking the channel as "
405  "Commercial Free."));
406 
407  std::deque<int> tmp = GetPreferredSkipTypeCombinations();
408  tmp.push_front(COMM_DETECT_UNINIT);
409  tmp.push_back(COMM_DETECT_COMMFREE);
410 
411  for (int pref : tmp)
412  addSelection(SkipTypeToString(pref), QString::number(pref));
413  }
414 };
415 
417 {
418  public:
419  explicit Visible(const ChannelID &id) :
420  MythUIComboBoxSetting(new ChannelDBStorage(this, id, "visible"))
421  {
423 
424  setLabel(QCoreApplication::translate("(ChannelSettings)", "Visible"));
425 
426  setHelpText(QCoreApplication::translate("(ChannelSettings)",
427  "If set to Always Visible or Visible, the channel will be visible in the "
428  "EPG. Set to Always Visible or Never Visible to prevent MythTV and other "
429  "utilities from automatically managing the value for this "
430  "channel."));
431 
432  addSelection(QCoreApplication::translate("(Common)", "Always Visible"),
433  QString::number(kChannelAlwaysVisible));
434  addSelection(QCoreApplication::translate("(Common)", "Visible"),
435  QString::number(kChannelVisible));
436  addSelection(QCoreApplication::translate("(Common)", "Not Visible"),
437  QString::number(kChannelNotVisible));
438  addSelection(QCoreApplication::translate("(Common)", "Never Visible"),
439  QString::number(kChannelNeverVisible));
440  }
441 };
442 
444 {
445  public:
446  explicit OnAirGuide(const ChannelID &id) :
447  MythUICheckBoxSetting(new ChannelDBStorage(this, id, "useonairguide"))
448  {
449  setLabel(QCoreApplication::translate("(ChannelSettings)",
450  "Use on air guide"));
451 
452  setHelpText(QCoreApplication::translate("(ChannelSettings)",
453  "If enabled, guide information for this channel will be updated "
454  "using 'Over-the-Air' program listings."));
455  }
456 };
457 
458 /*****************************************************************************
459  Channel Options - IPTV
460  *****************************************************************************/
462 {
463  public:
464  explicit ChannelURL(const ChannelID &id) :
465  MythUITextEditSetting(new IPTVChannelDBStorage(this, id, "url"))
466  {
467  setLabel(QCoreApplication::translate("(ChannelSettings)", "URL"));
468  setHelpText(QCoreApplication::translate("(ChannelSettings)",
469  "URL for streaming of this channel. Used by the IPTV "
470  "capture card and obtained with an \"M3U Import\" or "
471  "with a \"HDHomeRun Channel Import\" loading of an XML file."));
472  }
473 };
474 
475 /*****************************************************************************
476  Channel Options - Video 4 Linux
477  *****************************************************************************/
478 
480 {
481  public:
482  explicit Freqid(const ChannelID &id) :
483  MythUITextEditSetting(new ChannelDBStorage(this, id, "freqid"))
484  {
485  setLabel(QCoreApplication::translate("(ChannelSettings)",
486  "Freq/Channel"));
487  setHelpText(QCoreApplication::translate("(ChannelSettings)",
488  "N.B. This setting is only used for analog channels. "
489  "Depending on the tuner type, specify either the exact "
490  "frequency (in kHz) or a valid channel "
491  "number that will be understood by your tuners."));
492  }
493 };
494 
496 {
497  public:
498  explicit Finetune(const ChannelID& id)
499  : MythUISpinBoxSetting(new ChannelDBStorage(this, id, "finetune"),
500  -300, 300, 1)
501  {
502  setLabel(QCoreApplication::translate("(ChannelSettings)",
503  "Finetune (kHz)"));
504 
505  setHelpText(QCoreApplication::translate("(ChannelSettings)",
506  "Value to be added to your desired frequency (in kHz) for "
507  "'fine tuning'."));
508 
509  setValue("0");
510  }
511 };
512 
514 {
515  public:
516  explicit Contrast(const ChannelID &id) :
517  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "contrast"),
518  0, 65535, 655)
519  {
520  setLabel(QCoreApplication::translate("(Common)", "Contrast"));
521  }
522 };
523 
525 {
526  public:
527  explicit Brightness(const ChannelID &id) :
528  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "brightness"),
529  0, 65535, 655)
530  {
531  setLabel(QCoreApplication::translate("(Common)", "Brightness"));
532  }
533 };
534 
536 {
537  public:
538  explicit Colour(const ChannelID &id) :
539  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "colour"),
540  0, 65535, 655)
541  {
542  setLabel(QCoreApplication::translate("(Common)", "Color"));
543  }
544 };
545 
546 class Hue : public MythUISpinBoxSetting
547 {
548  public:
549  explicit Hue(const ChannelID &id) :
550  MythUISpinBoxSetting(new ChannelDBStorage(this, id, "hue"),
551  0, 65535, 655)
552  {
553  setLabel(QCoreApplication::translate("(Common)", "Hue"));
554  }
555 };
556 
558  uint default_sourceid, bool add_freqid)
559 {
560  setLabel(QCoreApplication::translate("(ChannelSettings)",
561  "Channel Options - Common"));
562  addChild(new Name(id));
563 
564  auto *source = new Source(id, default_sourceid);
565 
566  auto *channum = new Channum(id);
567  addChild(channum);
568  if (add_freqid)
569  {
570  m_freqId = new Freqid(id);
572  }
573  else
574  m_freqId = nullptr;
575  addChild(new Callsign(id));
576 
577 
578 
579  addChild(new Visible(id));
580  addChild(new ServiceID(id));
581 
584 
585  addChild(source);
586  addChild(new ChannelTVFormat(id));
587  addChild(new Priority(id));
588 
589  addChild(m_onAirGuide = new OnAirGuide(id));
590  addChild(m_xmltvID = new XmltvID(id, source->getValueLabel()));
591  addChild(new TimeOffset(id));
592 
593  addChild(new CommMethod(id));
594  addChild(new Icon(id));
595 
598  connect(source, qOverload<const QString&>(&StandardSetting::valueChanged),
600 
601  // Transport stream ID and frequency from dtv_multiplex
602  MSqlQuery query(MSqlQuery::InitCon());
603  query.prepare(
604  "SELECT transportid, frequency, polarity, mod_sys FROM dtv_multiplex "
605  "JOIN channel ON channel.mplexid = dtv_multiplex.mplexid "
606  "WHERE channel.chanid = :CHANID");
607 
608  query.bindValue(":CHANID", id.getValue().toUInt());
609 
610  if (!query.exec() || !query.isActive())
611  {
612  MythDB::DBError("ChannelOptionsCommon::ChannelOptionsCommon", query);
613  }
614  else if (query.next())
615  {
616  QString frequency = query.value(1).toString();
617  DTVModulationSystem modSys;
618  modSys.Parse(query.value(3).toString());
621  {
622  QString polarization = query.value(2).toString().toUpper();
623  frequency.append(polarization);
624  }
625  m_transportId->setValue(query.value(0).toString());
626  m_frequency->setValue(frequency);
627  }
628 };
629 
630 void ChannelOptionsCommon::onAirGuideChanged([[maybe_unused]] bool fValue)
631 {
632 }
633 
634 void ChannelOptionsCommon::sourceChanged(const QString& sourceid)
635 {
636  bool supports_eit = true;
637  bool uses_eit_only = false;
638 
639  MSqlQuery query(MSqlQuery::InitCon());
640  query.prepare("SELECT cardtype "
641  "FROM capturecard, videosource "
642  "WHERE capturecard.sourceid = videosource.sourceid AND "
643  " videosource.sourceid = :SOURCEID");
644  query.bindValue(":SOURCEID", sourceid);
645 
646  if (!query.exec() || !query.isActive())
647  MythDB::DBError("sourceChanged -- supports eit", query);
648  else
649  {
650  supports_eit = (query.size() == 0);
651  while (query.next())
652  {
653  supports_eit |= CardUtil::IsEITCapable(
654  query.value(0).toString().toUpper());
655  }
656 
657  query.prepare("SELECT xmltvgrabber "
658  "FROM videosource "
659  "WHERE sourceid = :SOURCEID");
660  query.bindValue(":SOURCEID", sourceid);
661 
662  if (!query.exec() || !query.isActive())
663  MythDB::DBError("sourceChanged -- eit only", query);
664  else
665  {
666  uses_eit_only = (query.size() != 0);
667  while (query.next())
668  {
669  uses_eit_only &= (query.value(0).toString() == "eitonly");
670  }
671  }
672  }
673 
674  m_onAirGuide->setEnabled(supports_eit);
675  m_xmltvID->setEnabled(!uses_eit_only);
676  m_xmltvID->Load();
677 }
678 
680 {
681  setLabel(QCoreApplication::translate("(ChannelSettings)",
682  "Channel Options - Filters"));
683 
684  addChild(new VideoFilters(id));
685  addChild(new OutputFilters(id));
686 }
687 
689 {
690  setLabel(QCoreApplication::translate("(ChannelSettings)",
691  "Channel Options - IPTV"));
692 
693  addChild(new Name(id));
694  addChild(new Channum(id));
695  addChild(new ChannelURL(id));
696 }
697 
699 {
700  setLabel(QCoreApplication::translate("(ChannelSettings)",
701  "Channel Options - Video4Linux"));
702 
703  addChild(new Freqid(id));
704  addChild(new Finetune(id));
705  addChild(new Contrast(id));
706  addChild(new Brightness(id));
707  addChild(new Colour(id));
708  addChild(new Hue(id));
709 };
710 
711 /*****************************************************************************
712  Channel Options - Video 4 Linux
713  *****************************************************************************/
714 
716  m_cid(id)
717 {
718  setLabel(QCoreApplication::translate("(ChannelSettings)",
719  "Channel Options - Raw Transport Stream"));
720 
721  const uint mx = kMaxPIDs;
722  m_pids.resize(mx);
723  m_sids.resize(mx);
724  m_pcrs.resize(mx);
725 
726  for (uint i = 0; i < mx; i++)
727  {
728  addChild((m_pids[i] = new TransTextEditSetting()));
729  m_pids[i]->setLabel("PID");
731  m_sids[i]->setLabel(" StreamID");
732  for (uint j = 0x101; j <= 0x1ff; j++)
733  {
734  QString desc = StreamID::GetDescription(j&0xff);
735  if (!desc.isEmpty())
736  {
737  m_sids[i]->addSelection(
738  QString("%1 (0x%2)")
739  .arg(desc).arg(j&0xff,2,16,QLatin1Char('0')),
740  QString::number(j), false);
741  }
742  }
743  for (uint j = 0x101; j <= 0x1ff; j++)
744  {
745  QString desc = StreamID::GetDescription(j&0xff);
746  if (desc.isEmpty())
747  {
748  m_sids[i]->addSelection(
749  QString("0x%1").arg(j&0xff,2,16,QLatin1Char('0')),
750  QString::number(j), false);
751  }
752  }
753 /* we don't allow tables right now, PAT & PMT generated on the fly
754  for (uint j = 0; j <= 0xff; j++)
755  {
756  QString desc = TableID::GetDescription(j);
757  if (!desc.isEmpty())
758  {
759  m_sids[i]->addSelection(
760  QString("%1 (0x%2)").arg(j,0,16,QLatin1Char('0')),
761  QString::number(j),
762  false);
763  }
764  }
765 */
767  m_pcrs[i]->setLabel(" Is PCR");
768  }
769 };
770 
772 {
773  uint chanid = m_cid.getValue().toUInt();
774 
775  pid_cache_t pid_cache;
776  if (!ChannelUtil::GetCachedPids(chanid, pid_cache))
777  return;
778 
779  auto it = pid_cache.begin();
780  for (uint i = 0; i < kMaxPIDs && it != pid_cache.end(); )
781  {
782  if (!(it->IsPermanent()))
783  {
784  ++it;
785  continue;
786  }
787 
788  m_pids[i]->setValue(QString("0x%1")
789  .arg(it->GetPID(),2,16,QLatin1Char('0')));
790  m_sids[i]->setValue(QString::number(it->GetComposite()&0x1ff));
791  m_pcrs[i]->setValue(it->IsPCRPID());
792 
793  ++it;
794  ++i;
795  }
796 }
797 
799 {
800  uint chanid = m_cid.getValue().toUInt();
801 
802  pid_cache_t pid_cache;
803  for (uint i = 0; i < kMaxPIDs; i++)
804  {
805  bool ok = false;
806  uint pid = m_pids[i]->getValue().toUInt(&ok, 0);
807  if (!ok || (m_sids[i]->getValue().toUInt() == 0U))
808  continue;
809 
810  pid_cache.emplace_back(
811  pid, m_sids[i]->getValue().toUInt() | 0x10000 |
812  (m_pcrs[i]->getValue().toUInt() ? 0x200 : 0x0));
813  }
814 
815  ChannelUtil::SaveCachedPids(chanid, pid_cache, true /* delete_all */);
816 }
817 
818 /* vim: set expandtab tabstop=4 shiftwidth=4: */
XmltvID
Definition: channelsettings.cpp:279
MSqlBindings
QMap< QString, QVariant > MSqlBindings
typedef for a map of string -> string bindings for generic queries.
Definition: mythdbcon.h:100
Source
static QString Source(const QNetworkRequest &request)
Definition: netstream.cpp:134
MSqlQuery::isActive
bool isActive(void) const
Definition: mythdbcon.h:215
ChannelOptionsCommon::m_xmltvID
XmltvID * m_xmltvID
Definition: channelsettings.h:139
CommMethod
Definition: channelsettings.cpp:393
MSqlQuery::next
bool next(void)
Wrap QSqlQuery::next() so we can display the query results.
Definition: mythdbcon.cpp:813
MSqlQuery
QSqlQuery wrapper that fetches a DB connection from the connection pool.
Definition: mythdbcon.h:127
Name::Name
Name(const ChannelID &id)
Definition: channelsettings.cpp:76
MythUIComboBoxSetting::clearSelections
void clearSelections()
Definition: standardsettings.cpp:514
ChannelOptionsRawTS::ChannelOptionsRawTS
ChannelOptionsRawTS(const ChannelID &id)
Definition: channelsettings.cpp:715
Visible::Visible
Visible(const ChannelID &id)
Definition: channelsettings.cpp:419
Frequency_CO
Definition: channelsettings.cpp:381
MSqlQuery::size
int size(void) const
Definition: mythdbcon.h:214
TransMythUICheckBoxSetting
Definition: standardsettings.h:411
OutputFilters
Definition: channelsettings.cpp:264
ChannelOptionsCommon::onAirGuideChanged
static void onAirGuideChanged(bool fValue)
Definition: channelsettings.cpp:630
StandardSetting::setValue
virtual void setValue(const QString &newValue)
Definition: standardsettings.cpp:170
Brightness
Definition: channelsettings.cpp:524
DTVModulationSystem::kModulationSystem_DVBS2
@ kModulationSystem_DVBS2
Definition: dtvconfparserhelpers.h:662
ChannelOptionsRawTS::m_pids
std::vector< TransTextEditSetting * > m_pids
Definition: channelsettings.h:175
ChannelOptionsCommon::sourceChanged
void sourceChanged(const QString &sourceid)
Definition: channelsettings.cpp:634
DBStorage::m_user
StorageUser * m_user
Definition: mythstorage.h:50
ChannelID::getField
const QString & getField(void) const
Definition: channelsettings.h:86
Hue
Definition: channelsettings.cpp:546
TransMythUIComboBoxSetting
Definition: standardsettings.h:272
kChannelNeverVisible
@ kChannelNeverVisible
Definition: channelinfo.h:25
MythUITextEditSetting::MythUITextEditSetting
MythUITextEditSetting(Storage *_storage=nullptr)
Definition: standardsettings.h:157
TransTextEditSetting
Definition: standardsettings.h:161
XmltvID::fillSelections
void fillSelections(void)
Definition: channelsettings.cpp:301
OnAirGuide
Definition: channelsettings.cpp:443
ChannelOptionsCommon::ChannelOptionsCommon
ChannelOptionsCommon(const ChannelID &id, uint default_sourceid, bool add_freqid)
Definition: channelsettings.cpp:557
MSqlQuery::value
QVariant value(int i) const
Definition: mythdbcon.h:204
ChannelOptionsIPTV::ChannelOptionsIPTV
ChannelOptionsIPTV(const ChannelID &id)
Definition: channelsettings.cpp:688
Colour
Definition: channelsettings.cpp:535
Source::Load
void Load(void) override
Definition: channelsettings.cpp:107
DBStorage::GetColumnName
QString GetColumnName(void) const
Definition: mythstorage.h:47
MSqlQuery::exec
bool exec(void)
Wrap QSqlQuery::exec() so we can display SQL.
Definition: mythdbcon.cpp:619
x0
static int x0
Definition: mythsocket.cpp:49
ChannelUtil::GetCachedPids
static bool GetCachedPids(uint chanid, pid_cache_t &pid_cache)
Returns cached MPEG PIDs when given a Channel ID.
Definition: channelutil.cpp:858
SkipTypeToString
QString SkipTypeToString(int flags)
Definition: programtypes.cpp:91
StorageUser::GetDBValue
virtual QString GetDBValue(void) const =0
build_compdb.file
file
Definition: build_compdb.py:55
mythdirs.h
kChannelAlwaysVisible
@ kChannelAlwaysVisible
Definition: channelinfo.h:22
Callsign
Definition: channelsettings.cpp:152
Contrast::Contrast
Contrast(const ChannelID &id)
Definition: channelsettings.cpp:516
ChannelDBStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: channelsettings.cpp:19
Visible
Definition: channelsettings.cpp:416
true
VERBOSE_PREAMBLE Most true
Definition: verbosedefs.h:95
ChannelOptionsCommon::m_frequency
Frequency_CO * m_frequency
Definition: channelsettings.h:142
tmp
static guint32 * tmp
Definition: goom_core.cpp:26
Source::Source
Source(const ChannelID &id, uint _default_sourceid)
Definition: channelsettings.cpp:96
ServiceID::getValue
QString getValue(void) const override
Definition: channelsettings.cpp:359
TimeOffset::TimeOffset
TimeOffset(const ChannelID &id)
Definition: channelsettings.cpp:202
ChannelID
Definition: channelsettings.h:20
StreamID::GetDescription
static QString GetDescription(uint stream_id)
Definition: mpegtables.cpp:1033
StandardSetting::addChild
virtual void addChild(StandardSetting *child)
Definition: standardsettings.cpp:71
ServiceID
Definition: channelsettings.cpp:337
Source::fillSelections
void fillSelections(void)
Definition: channelsettings.cpp:120
programinfo.h
COMM_DETECT_COMMFREE
@ COMM_DETECT_COMMFREE
Definition: programtypes.h:129
ChannelDBStorage::m_id
const ChannelID & m_id
Definition: channelsettings.h:104
GetConfDir
QString GetConfDir(void)
Definition: mythdirs.cpp:256
ChannelOptionsFilters::ChannelOptionsFilters
ChannelOptionsFilters(const ChannelID &id)
Definition: channelsettings.cpp:679
MythUIComboBoxSetting
Definition: standardsettings.h:218
Source
Definition: channelsettings.cpp:93
VideoFilters::VideoFilters
VideoFilters(const ChannelID &id)
Definition: channelsettings.cpp:250
Brightness::Brightness
Brightness(const ChannelID &id)
Definition: channelsettings.cpp:527
MSqlQuery::InitCon
static MSqlQueryInfo InitCon(ConnectionReuse _reuse=kNormalConnection)
Only use this in combination with MSqlQuery constructor.
Definition: mythdbcon.cpp:551
pid_cache_t
std::vector< pid_cache_item_t > pid_cache_t
Definition: channelutil.h:43
MythDB::DBError
static void DBError(const QString &where, const MSqlQuery &query)
Definition: mythdb.cpp:226
XmltvID::XmltvID
XmltvID(const ChannelID &id, QString _sourceName)
Definition: channelsettings.cpp:282
StandardSetting::Load
virtual void Load(void)
Definition: standardsettings.cpp:214
MythUICheckBoxSetting::valueChanged
void valueChanged(bool)
Icon::Icon
Icon(const ChannelID &id)
Definition: channelsettings.cpp:236
Colour::Colour
Colour(const ChannelID &id)
Definition: channelsettings.cpp:538
Callsign::Callsign
Callsign(const ChannelID &id)
Definition: channelsettings.cpp:155
StandardSetting::setHelpText
virtual void setHelpText(const QString &str)
Definition: standardsettings.h:37
Freqid
Definition: channelsettings.cpp:479
OutputFilters::OutputFilters
OutputFilters(const ChannelID &id)
Definition: channelsettings.cpp:267
Finetune::Finetune
Finetune(const ChannelID &id)
Definition: channelsettings.cpp:498
mpegtables.h
StandardSetting::getValue
virtual QString getValue(void) const
Definition: standardsettings.h:52
VideoFilters
Definition: channelsettings.cpp:247
ChannelTVFormat
Definition: channelsettings.h:182
Contrast
Definition: channelsettings.cpp:513
uint
unsigned int uint
Definition: compat.h:81
ChannelOptionsCommon::m_transportId
TransportID_CO * m_transportId
Definition: channelsettings.h:141
ChannelURL
Definition: channelsettings.cpp:461
Channum::Channum
Channum(const ChannelID &id)
Definition: channelsettings.cpp:84
IPTVChannelDBStorage::GetWhereClause
QString GetWhereClause(MSqlBindings &bindings) const override
Definition: channelsettings.cpp:43
StandardSetting::setLabel
virtual void setLabel(QString str)
Definition: standardsettings.h:34
ChannelOptionsRawTS::Load
void Load(void) override
Definition: channelsettings.cpp:771
channelutil.h
IPTVChannelDBStorage::m_id
const ChannelID & m_id
Definition: channelsettings.h:116
XmltvID::Load
void Load(void) override
Definition: channelsettings.cpp:295
TimeOffset
Definition: channelsettings.cpp:199
COMM_DETECT_UNINIT
@ COMM_DETECT_UNINIT
Definition: programtypes.h:130
ChannelOptionsRawTS::kMaxPIDs
static const uint kMaxPIDs
Definition: channelsettings.h:179
StandardSetting::valueChanged
void valueChanged(const QString &newValue)
StandardSetting::setEnabled
virtual void setEnabled(bool enabled)
Definition: standardsettings.cpp:48
Channum
Definition: channelsettings.cpp:81
MythUIComboBoxSetting::addSelection
void addSelection(const QString &label, QString value=QString(), bool select=false)
Definition: standardsettings.cpp:499
TransportID_CO
Definition: channelsettings.cpp:368
Hue::Hue
Hue(const ChannelID &id)
Definition: channelsettings.cpp:549
Source::m_sourceIdToIndex
QMap< uint, uint > m_sourceIdToIndex
Definition: channelsettings.cpp:149
ChannelOptionsCommon::m_onAirGuide
OnAirGuide * m_onAirGuide
Definition: channelsettings.h:138
MythUITextEditSetting
Definition: standardsettings.h:146
kChannelVisible
@ kChannelVisible
Definition: channelinfo.h:23
DTVModulationSystem
Definition: dtvconfparserhelpers.h:644
ChannelDBStorage
Definition: channelsettings.h:95
cardutil.h
Name
Definition: channelsettings.cpp:71
IPTVChannelDBStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: channelsettings.cpp:53
MSqlQuery::bindValue
void bindValue(const QString &placeholder, const QVariant &val)
Add a single binding.
Definition: mythdbcon.cpp:889
std
Definition: mythchrono.h:23
channelsettings.h
OnAirGuide::OnAirGuide
OnAirGuide(const ChannelID &id)
Definition: channelsettings.cpp:446
Brightness
static constexpr uint8_t Brightness
Definition: synaesthesia.h:18
CommMethod::CommMethod
CommMethod(const ChannelID &id)
Definition: channelsettings.cpp:396
MythUISpinBoxSetting
Definition: standardsettings.h:328
ChannelOptionsRawTS::m_sids
std::vector< TransMythUIComboBoxSetting * > m_sids
Definition: channelsettings.h:176
CardUtil::IsEITCapable
static bool IsEITCapable(const QString &rawtype)
Definition: cardutil.h:170
ChannelOptionsRawTS::m_pcrs
std::vector< TransMythUICheckBoxSetting * > m_pcrs
Definition: channelsettings.h:177
Icon
Definition: channelsettings.cpp:233
ServiceID::ServiceID
ServiceID(const ChannelID &id)
Definition: channelsettings.cpp:340
IPTVChannelDBStorage
Definition: channelsettings.h:107
Source::m_defaultSourceId
uint m_defaultSourceId
Definition: channelsettings.cpp:148
ChannelUtil::SaveCachedPids
static bool SaveCachedPids(uint chanid, const pid_cache_t &_pid_cache, bool delete_all=false)
Saves PIDs for PSIP tables to database.
Definition: channelutil.cpp:891
MythUICheckBoxSetting
Definition: standardsettings.h:390
Finetune
Definition: channelsettings.cpp:495
ChannelOptionsV4L::ChannelOptionsV4L
ChannelOptionsV4L(const ChannelID &id)
Definition: channelsettings.cpp:698
Frequency_CO::Frequency_CO
Frequency_CO(void)
Definition: channelsettings.cpp:384
ChannelURL::ChannelURL
ChannelURL(const ChannelID &id)
Definition: channelsettings.cpp:466
ChannelOptionsCommon::m_freqId
Freqid * m_freqId
Definition: channelsettings.h:140
GetPreferredSkipTypeCombinations
std::deque< int > GetPreferredSkipTypeCombinations(void)
Definition: programtypes.cpp:129
Priority::Priority
Priority(const ChannelID &id)
Definition: channelsettings.cpp:219
ChannelTVFormat::GetFormats
static QStringList GetFormats(void)
Definition: channelsettings.cpp:177
TransportID_CO::TransportID_CO
TransportID_CO(void)
Definition: channelsettings.cpp:371
ChannelTVFormat::ChannelTVFormat
ChannelTVFormat(const ChannelID &id)
Definition: channelsettings.cpp:162
ChannelOptionsRawTS::Save
void Save(void) override
Definition: channelsettings.cpp:798
Freqid::Freqid
Freqid(const ChannelID &id)
Definition: channelsettings.cpp:484
XmltvID::m_sourceName
QString m_sourceName
Definition: channelsettings.cpp:334
ChannelOptionsRawTS::m_cid
const ChannelID & m_cid
Definition: channelsettings.h:173
DTVModulationSystem::kModulationSystem_DVBS
@ kModulationSystem_DVBS
Definition: dtvconfparserhelpers.h:661
Priority
Definition: channelsettings.cpp:216
MythUIComboBoxSetting::setValue
void setValue(int value) override
Definition: standardsettings.cpp:479
ChannelDBStorage::GetSetClause
QString GetSetClause(MSqlBindings &bindings) const override
Definition: channelsettings.cpp:29
GroupSetting
Definition: standardsettings.h:435
kChannelNotVisible
@ kChannelNotVisible
Definition: channelinfo.h:24
ServiceID::Load
void Load(void) override
Definition: channelsettings.cpp:351
MSqlQuery::prepare
bool prepare(const QString &query)
QSqlQuery::prepare() is not thread safe in Qt <= 3.3.2.
Definition: mythdbcon.cpp:838
DTVModulationSystem::Parse
bool Parse(const QString &_value)
Definition: dtvconfparserhelpers.h:716