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