MythTV  master
backendsettings.cpp
Go to the documentation of this file.
1 #include <cstdio>
2 
3 #include "backendsettings.h"
4 #include "frequencies.h"
5 #include "mythcorecontext.h"
6 #include "channelsettings.h" // for ChannelTVFormat::GetFormats()
7 #include <unistd.h>
8 
9 #include <QNetworkInterface>
10 
11 
13 {
14  auto *gc = new TransMythUICheckBoxSetting();
15  gc->setLabel(QObject::tr("This server is the Master Backend"));
16  gc->setValue(false);
17  gc->setHelpText(QObject::tr(
18  "Enable this if this is the only backend or is the "
19  "master backend server. If enabled, all frontend and "
20  "non-master backend machines "
21  "will connect to this server. To change to a new master "
22  "backend, run setup on that server and select it as "
23  "master backend."));
24  return gc;
25 };
26 
28 {
29  auto *gc = new GlobalTextEditSetting("MasterServerName");
30  gc->setLabel(QObject::tr("Master Backend Name"));
31  gc->setValue("");
32  gc->setEnabled(true);
33  gc->setReadOnly(true);
34  gc->setHelpText(QObject::tr(
35  "Host name of Master Backend. This is set by selecting "
36  "\"This server is the Master Backend\" on that server."));
37  return gc;
38 };
39 
41 {
42  auto *gc = new HostCheckBoxSetting("AllowConnFromAll");
43  gc->setLabel(QObject::tr("Allow Connections from all Subnets"));
44  gc->setValue(false);
45  gc->setHelpText(QObject::tr(
46  "Allow this backend to receive connections from any IP "
47  "address on the internet. NOT recommended for most users. "
48  "Use this only if you have secure IPV4 and IPV6 " "firewalls."));
49  return gc;
50 };
51 
53 {
54  auto *gc = new HostComboBoxSetting("BackendServerIP");
55  gc->setLabel(QObject::tr("IPv4 address"));
56  QList<QHostAddress> list = QNetworkInterface::allAddresses();
57  QList<QHostAddress>::iterator it;
58  for (it = list.begin(); it != list.end(); ++it)
59  {
60  if ((*it).protocol() == QAbstractSocket::IPv4Protocol)
61  gc->addSelection((*it).toString(), (*it).toString());
62  }
63 
64  gc->setValue("127.0.0.1");
65  gc->setHelpText(QObject::tr("Enter the IP address of this machine. "
66  "Use an externally accessible address (ie, not "
67  "127.0.0.1) if you are going to be running a frontend "
68  "on a different machine than this one. Note, in IPv6 "
69  "setups, this is still required for certain extras "
70  "such as UPnP."));
71  return gc;
72 };
73 
75 {
76  auto *gc = new HostComboBoxSetting("BackendServerIP6");
77  gc->setLabel(QObject::tr("Listen on IPv6 address"));
78  QList<QHostAddress> list = QNetworkInterface::allAddresses();
79  QList<QHostAddress>::iterator it;
80  for (it = list.begin(); it != list.end(); ++it)
81  {
82  if ((*it).protocol() == QAbstractSocket::IPv6Protocol)
83  {
84  // If it is a link-local IPV6 address with scope,
85  // remove the scope.
86  it->setScopeId(QString());
87  gc->addSelection((*it).toString(), (*it).toString());
88  }
89  }
90 
91  if (list.isEmpty())
92  {
93  gc->setEnabled(false);
94  gc->setValue("");
95  }
96  else
97  {
98  if (list.contains(QHostAddress("::1")))
99  gc->setValue("::1");
100  }
101 
102  gc->setHelpText(QObject::tr("Enter the IPv6 address of this machine. "
103  "Use an externally accessible address (ie, not "
104  "::1) if you are going to be running a frontend "
105  "on a different machine than this one."));
106  return gc;
107 }
108 
110 {
111  auto *hc = new HostCheckBoxSetting("AllowLinkLocal");
112  hc->setLabel(QObject::tr("Listen on Link-Local addresses"));
113  hc->setValue(true);
114  hc->setHelpText(QObject::tr("Enable servers on this machine to listen on "
115  "link-local addresses. These are auto-configured "
116  "addresses and not accessible outside the local network. "
117  "This must be enabled for anything requiring Bonjour to "
118  "work."));
119  return hc;
120 };
121 
123 {
124  public:
127  explicit IpAddressSettings(/*Setting* trigger*/) :
128  HostCheckBoxSetting("ListenOnAllIps")
129  {
130  setLabel(BackendSettings::tr("Listen on All IP Addresses"));
131  setValue(true);
132  setHelpText(BackendSettings::tr("Allow this backend to receive "
133  "connections on any IP Address assigned to it. "
134  "Recommended for most users for ease and "
135  "reliability."));
136 
139  // show ip addresses if ListenOnAllIps is off
143  };
144 };
145 
146 
148 {
150 }
151 
153 {
154  auto *gc = new HostTextEditSetting("BackendServerPort");
155  gc->setLabel(QObject::tr("Port"));
156  gc->setValue("6543");
157  gc->setHelpText(QObject::tr("Unless you've got good reason, don't "
158  "change this."));
159  connect(gc, &StandardSetting::ChangeSaved,
161  return gc;
162 };
163 
165 {
166  auto *gc = new HostTextEditSetting("BackendStatusPort");
167  gc->setLabel(QObject::tr("Status port"));
168  gc->setValue("6544");
169  gc->setHelpText(QObject::tr("Port on which the server will listen for "
170  "HTTP requests, including backend status and MythXML "
171  "requests."));
172  return gc;
173 };
174 
176 {
177  auto *gc = new HostComboBoxSetting("BackendServerAddr", true);
178  gc->setLabel(QObject::tr("Primary IP address / DNS name"));
179  gc->setValue("127.0.0.1");
180  gc->setHelpText(QObject::tr("The Primary IP address of this backend "
181  "server. You can select an IP "
182  "address from the list or type a DNS name "
183  "or host name. Other systems will contact this "
184  "server using this address. "
185  "If you use a host name make sure it is assigned "
186  "an ip address other than 127.0.0.1 in the hosts "
187  "file."));
188  return gc;
189 };
190 
191 // Deprecated
193 {
194  auto *gc = new GlobalTextEditSetting("MasterServerIP");
195  gc->setLabel(QObject::tr("IP address"));
196  gc->setValue("127.0.0.1");
197  return gc;
198 };
199 
200 // Deprecated
202 {
203  auto *gc = new GlobalTextEditSetting("MasterServerPort");
204  gc->setLabel(QObject::tr("Port"));
205  gc->setValue("6543");
206  return gc;
207 };
208 
210 {
211  auto *gc = new HostTextEditSetting("SecurityPin");
212  gc->setLabel(QObject::tr("Security PIN (required)"));
213  gc->setValue("");
214  gc->setHelpText(QObject::tr("PIN code required for a frontend to connect "
215  "to the backend. Blank prevents all "
216  "connections; 0000 allows any client to "
217  "connect."));
218  return gc;
219 };
220 
222 {
223  auto *gc = new GlobalComboBoxSetting("TVFormat");
224  gc->setLabel(QObject::tr("TV format"));
225 
226  QStringList list = ChannelTVFormat::GetFormats();
227  for (const QString& item : qAsConst(list))
228  gc->addSelection(item);
229 
230  gc->setHelpText(QObject::tr("The TV standard to use for viewing TV."));
231  return gc;
232 };
233 
235 {
236  auto *gc = new GlobalComboBoxSetting("VbiFormat");
237  gc->setLabel(QObject::tr("VBI format"));
238  gc->addSelection("None");
239  gc->addSelection("PAL teletext");
240  gc->addSelection("NTSC closed caption");
241  gc->setHelpText(QObject::tr("The VBI (Vertical Blanking Interval) is "
242  "used to carry Teletext or Closed Captioning "
243  "data."));
244  return gc;
245 };
246 
248 {
249  auto *gc = new GlobalComboBoxSetting("FreqTable");
250  gc->setLabel(QObject::tr("Channel frequency table"));
251 
252  for (const auto &list : gChanLists)
253  gc->addSelection(list.name);
254 
255  gc->setHelpText(QObject::tr("Select the appropriate frequency table for "
256  "your system. If you have an antenna, use a \"-bcast\" "
257  "frequency."));
258  return gc;
259 };
260 
262 {
263  auto *gc = new GlobalCheckBoxSetting("SaveTranscoding");
264  gc->setLabel(QObject::tr("Save original files after transcoding (globally)"));
265  gc->setValue(false);
266  gc->setHelpText(QObject::tr("If enabled and the transcoder is active, the "
267  "original files will be renamed to .old once the "
268  "transcoding is complete."));
269  return gc;
270 };
271 
273 {
274  auto *hc = new HostCheckBoxSetting("TruncateDeletesSlowly");
275  hc->setLabel(QObject::tr("Delete files slowly"));
276  hc->setValue(false);
277  hc->setHelpText(QObject::tr("Some filesystems use a lot of resources when "
278  "deleting large files. If enabled, this option makes "
279  "MythTV delete files slowly on this backend to lessen the "
280  "impact."));
281  return hc;
282 };
283 
285 {
286  auto *gc = new GlobalCheckBoxSetting("DeletesFollowLinks");
287  gc->setLabel(QObject::tr("Follow symbolic links when deleting files"));
288  gc->setValue(false);
289  gc->setHelpText(QObject::tr("If enabled, MythTV will follow symlinks "
290  "when recordings and related files are deleted, instead "
291  "of deleting the symlink and leaving the actual file."));
292  return gc;
293 };
294 
296 {
297  auto *bs = new GlobalSpinBoxSetting(
298  "HDRingbufferSize", 25*188, 500*188, 25*188);
299  bs->setLabel(QObject::tr("HD ringbuffer size (kB)"));
300  bs->setHelpText(QObject::tr("The HD device ringbuffer allows the "
301  "backend to weather moments of stress. "
302  "The larger the ringbuffer (in kilobytes), the longer "
303  "the moments of stress can be. However, "
304  "setting the size too large can cause "
305  "swapping, which is detrimental."));
306  bs->setValue(50*188);
307  return bs;
308 }
309 
311 {
312  auto *gc = new GlobalComboBoxSetting("StorageScheduler");
313  gc->setLabel(QObject::tr("Storage Group disk scheduler"));
314  gc->addSelection(QObject::tr("Balanced free space"), "BalancedFreeSpace");
315  gc->addSelection(QObject::tr("Balanced percent free space"), "BalancedPercFreeSpace");
316  gc->addSelection(QObject::tr("Balanced disk I/O"), "BalancedDiskIO");
317  gc->addSelection(QObject::tr("Combination"), "Combination");
318  gc->setValue("BalancedFreeSpace");
319  gc->setHelpText(QObject::tr("This setting controls how the Storage Group "
320  "scheduling code will balance new recordings across "
321  "directories. 'Balanced Free Space' is the recommended "
322  "method for most users." ));
323  return gc;
324 };
325 
327 {
328  auto *gc = new GlobalCheckBoxSetting("DisableAutomaticBackup");
329  gc->setLabel(QObject::tr("Disable automatic database backup"));
330  gc->setValue(false);
331  gc->setHelpText(QObject::tr("If enabled, MythTV will not backup the "
332  "database before upgrades. You should "
333  "therefore have your own database backup "
334  "strategy in place."));
335  return gc;
336 };
337 
339 {
340  auto *hc = new HostCheckBoxSetting("DisableFirewireReset");
341  hc->setLabel(QObject::tr("Disable FireWire reset"));
342  hc->setHelpText(
343  QObject::tr(
344  "By default, MythTV resets the FireWire bus when a "
345  "FireWire recorder stops responding to commands. If "
346  "this causes problems, you can disable this behavior "
347  "here."));
348  hc->setValue(false);
349  return hc;
350 }
351 
353 {
354  auto *he = new HostTextEditSetting("MiscStatusScript");
355  he->setLabel(QObject::tr("Miscellaneous status application"));
356  he->setValue("");
357  he->setHelpText(QObject::tr("External application or script that outputs "
358  "extra information for inclusion in the "
359  "backend status page. See http://www.mythtv."
360  "org/wiki/Miscellaneous_Status_Information"));
361  return he;
362 }
363 
365 {
366  auto *gc = new GlobalSpinBoxSetting("EITTransportTimeout", 1, 15, 1);
367  gc->setLabel(QObject::tr("EIT transport timeout (mins)"));
368  gc->setValue(5);
369  QString helpText = QObject::tr(
370  "Maximum time to spend waiting (in minutes) for listings data "
371  "on one digital TV channel before checking for new listings data "
372  "on the next channel.");
373  gc->setHelpText(helpText);
374  return gc;
375 }
376 
378 {
379  auto *gc = new GlobalCheckBoxSetting("MasterBackendOverride");
380  gc->setLabel(QObject::tr("Master backend override"));
381  gc->setValue(true);
382  gc->setHelpText(QObject::tr("If enabled, the master backend will stream and"
383  " delete files if it finds them in a storage directory. "
384  "Useful if you are using a central storage location, like "
385  "a NFS share, and your slave backend isn't running."));
386  return gc;
387 };
388 
390 {
391  auto *gc = new GlobalSpinBoxSetting("EITCrawIdleStart", 30, 7200, 30);
392  gc->setLabel(QObject::tr("Backend idle before EIT crawl (secs)"));
393  gc->setValue(60);
394  QString help = QObject::tr(
395  "The minimum number of seconds after a recorder becomes idle "
396  "to wait before MythTV begins collecting EIT listings data.");
397  gc->setHelpText(help);
398  return gc;
399 }
400 
402 {
403  auto *gc = new GlobalSpinBoxSetting("WOLbackendReconnectWaitTime", 0, 1200, 5);
404  gc->setLabel(QObject::tr("Delay between wake attempts (secs)"));
405  gc->setValue(0);
406  gc->setHelpText(QObject::tr("Length of time the frontend waits between "
407  "tries to wake up the master backend. This should be the "
408  "time your master backend needs to startup. Set to 0 to "
409  "disable."));
410  return gc;
411 };
412 
414 {
415  auto *gc = new GlobalSpinBoxSetting("WOLbackendConnectRetry", 1, 60, 1);
416  gc->setLabel(QObject::tr("Wake attempts"));
417  gc->setHelpText(QObject::tr("Number of times the frontend will try to wake "
418  "up the master backend."));
419  gc->setValue(5);
420  return gc;
421 };
422 
424 {
425  auto *gc = new GlobalTextEditSetting("WOLbackendCommand");
426  gc->setLabel(QObject::tr("Wake command"));
427  gc->setValue("");
428  gc->setHelpText(QObject::tr("The command used to wake up your master "
429  "backend server (e.g. wakeonlan 00:00:00:00:00:00)."));
430  return gc;
431 };
432 
434 {
435  auto *gc = new HostTextEditSetting("SleepCommand");
436  gc->setLabel(QObject::tr("Sleep command"));
437  gc->setValue("");
438  gc->setHelpText(QObject::tr("The command used to put this slave to sleep. "
439  "If set, the master backend will use this command to put "
440  "this slave to sleep when it is not needed for recording."));
441  return gc;
442 };
443 
445 {
446  auto *gc = new HostTextEditSetting("WakeUpCommand");
447  gc->setLabel(QObject::tr("Wake command"));
448  gc->setValue("");
449  gc->setHelpText(QObject::tr("The command used to wake up this slave "
450  "from sleep. This setting is not used on the master "
451  "backend."));
452  return gc;
453 };
454 
456 {
457  auto *gc = new GlobalTextEditSetting("BackendStopCommand");
458  gc->setLabel(QObject::tr("Backend stop command"));
459  gc->setValue("killall mythbackend");
460  gc->setHelpText(QObject::tr("The command used to stop the backend"
461  " when running on the master backend server "
462  "(e.g. sudo /etc/init.d/mythtv-backend stop)"));
463  return gc;
464 };
465 
467 {
468  auto *gc = new GlobalTextEditSetting("BackendStartCommand");
469  gc->setLabel(QObject::tr("Backend start command"));
470  gc->setValue("mythbackend");
471  gc->setHelpText(QObject::tr("The command used to start the backend"
472  " when running on the master backend server "
473  "(e.g. sudo /etc/init.d/mythtv-backend start)."));
474  return gc;
475 };
476 
478 {
479  auto *gc = new GlobalSpinBoxSetting("idleTimeoutSecs", 0, 1200, 5);
480  gc->setLabel(QObject::tr("Idle shutdown timeout (secs)"));
481  gc->setValue(0);
482  gc->setHelpText(QObject::tr("The number of seconds the master backend "
483  "idles before it shuts down all other backends. Set to 0 to "
484  "disable automatic shutdown."));
485  return gc;
486 };
487 
489 {
490  auto *gc = new GlobalSpinBoxSetting("idleWaitForRecordingTime", 0, 300, 1);
491  gc->setLabel(QObject::tr("Maximum wait for recording (mins)"));
492  gc->setValue(15);
493  gc->setHelpText(QObject::tr("The number of minutes the master backend "
494  "waits for a recording. If the backend is idle but a "
495  "recording starts within this time period, it won't "
496  "shut down."));
497  return gc;
498 };
499 
501 {
502  auto *gc = new GlobalSpinBoxSetting("StartupSecsBeforeRecording", 0, 1200, 5);
503  gc->setLabel(QObject::tr("Startup before recording (secs)"));
504  gc->setValue(120);
505  gc->setHelpText(QObject::tr("The number of seconds the master backend "
506  "will be woken up before a recording starts."));
507  return gc;
508 };
509 
511 {
512  auto *gc = new GlobalTextEditSetting("WakeupTimeFormat");
513  gc->setLabel(QObject::tr("Wakeup time format"));
514  gc->setValue("hh:mm yyyy-MM-dd");
515  gc->setHelpText(QObject::tr("The format of the time string passed to the "
516  "'Command to set wakeup time' as $time. See "
517  "QT::QDateTime.toString() for details. Set to 'time_t' for "
518  "seconds since epoch."));
519  return gc;
520 };
521 
523 {
524  auto *gc = new GlobalTextEditSetting("SetWakeuptimeCommand");
525  gc->setLabel(QObject::tr("Command to set wakeup time"));
526  gc->setValue("");
527  gc->setHelpText(QObject::tr("The command used to set the wakeup time "
528  "(passed as $time) for the Master Backend"));
529  return gc;
530 };
531 
533 {
534  auto *gc = new GlobalTextEditSetting("ServerHaltCommand");
535  gc->setLabel(QObject::tr("Server halt command"));
536  gc->setValue("sudo /sbin/halt -p");
537  gc->setHelpText(QObject::tr("The command used to halt the backends."));
538  return gc;
539 };
540 
542 {
543  auto *gc = new GlobalTextEditSetting("preSDWUCheckCommand");
544  gc->setLabel(QObject::tr("Pre-shutdown-check command"));
545  gc->setValue("");
546  gc->setHelpText(QObject::tr("A command executed before the backend would "
547  "shutdown. The return value determines if "
548  "the backend can shutdown. 0 - yes, "
549  "1 - restart idling, "
550  "2 - reset the backend to wait for a frontend."));
551  return gc;
552 };
553 
555 {
556  auto *gc = new GlobalCheckBoxSetting("blockSDWUwithoutClient");
557  gc->setLabel(QObject::tr("Block shutdown before client connected"));
558  gc->setValue(true);
559  gc->setHelpText(QObject::tr("If enabled, the automatic shutdown routine will "
560  "be disabled until a client connects."));
561  return gc;
562 };
563 
565 {
566  auto *gc = new GlobalTextEditSetting("startupCommand");
567  gc->setLabel(QObject::tr("Startup command"));
568  gc->setValue("");
569  gc->setHelpText(QObject::tr("This command is executed right after starting "
570  "the BE. As a parameter '$status' is replaced by either "
571  "'auto' if the machine was started automatically or "
572  "'user' if a user switched it on."));
573  return gc;
574 };
575 
577 {
578  auto *gc = new HostSpinBoxSetting("JobQueueMaxSimultaneousJobs", 1, 10, 1);
579  gc->setLabel(QObject::tr("Maximum simultaneous jobs on this backend"));
580  gc->setHelpText(QObject::tr("The Job Queue will be limited to running "
581  "this many simultaneous jobs on this backend."));
582  gc->setValue(1);
583  return gc;
584 };
585 
587 {
588  auto *gc = new HostSpinBoxSetting("JobQueueCheckFrequency", 5, 300, 5);
589  gc->setLabel(QObject::tr("Job Queue check frequency (secs)"));
590  gc->setHelpText(QObject::tr("When looking for new jobs to process, the "
591  "Job Queue will wait this many seconds between checks."));
592  gc->setValue(60);
593  return gc;
594 };
595 
597 {
598  auto *gc = new HostComboBoxSetting("JobQueueCPU");
599  gc->setLabel(QObject::tr("CPU usage"));
600  gc->addSelection(QObject::tr("Low"), "0");
601  gc->addSelection(QObject::tr("Medium"), "1");
602  gc->addSelection(QObject::tr("High"), "2");
603  gc->setHelpText(QObject::tr("This setting controls approximately how "
604  "much CPU jobs in the queue may consume. "
605  "On 'High', all available CPU time may be used, "
606  "which could cause problems on slower systems." ));
607  return gc;
608 };
609 
611 {
612  auto *gc = new HostTimeBoxSetting("JobQueueWindowStart", "00:00");
613  gc->setLabel(QObject::tr("Job Queue start time"));
614  gc->setHelpText(QObject::tr("This setting controls the start of the "
615  "Job Queue time window, which determines when new jobs "
616  "will be started."));
617  return gc;
618 };
619 
621 {
622  auto *gc = new HostTimeBoxSetting("JobQueueWindowEnd", "23:59");
623  gc->setLabel(QObject::tr("Job Queue end time"));
624  gc->setHelpText(QObject::tr("This setting controls the end of the "
625  "Job Queue time window, which determines when new jobs "
626  "will be started."));
627  return gc;
628 };
629 
631 {
632  auto *gc = new GlobalCheckBoxSetting("JobsRunOnRecordHost");
633  gc->setLabel(QObject::tr("Run jobs only on original recording backend"));
634  gc->setValue(false);
635  gc->setHelpText(QObject::tr("If enabled, jobs in the queue will be required "
636  "to run on the backend that made the "
637  "original recording."));
638  return gc;
639 };
640 
642 {
643  auto *gc = new GlobalCheckBoxSetting("AutoTranscodeBeforeAutoCommflag");
644  gc->setLabel(QObject::tr("Run transcode jobs before auto commercial "
645  "detection"));
646  gc->setValue(false);
647  gc->setHelpText(QObject::tr("If enabled, and if both auto-transcode and "
648  "commercial detection are turned ON for a "
649  "recording, transcoding will run first; "
650  "otherwise, commercial detection runs first."));
651  return gc;
652 };
653 
655 {
656  auto *gc = new GlobalCheckBoxSetting("AutoCommflagWhileRecording");
657  gc->setLabel(QObject::tr("Start auto-commercial-detection jobs when the "
658  "recording starts"));
659  gc->setValue(false);
660  gc->setHelpText(QObject::tr("If enabled, and Auto Commercial Detection is "
661  "ON for a recording, the flagging job will be "
662  "started as soon as the recording starts. NOT "
663  "recommended on underpowered systems."));
664  return gc;
665 };
666 
668 {
669  auto *gc = new GlobalTextEditSetting(QString("UserJob%1").arg(job_num));
670  gc->setLabel(QObject::tr("User Job #%1 command").arg(job_num));
671  gc->setValue("");
672  gc->setHelpText(QObject::tr("The command to run whenever this User Job "
673  "number is scheduled."));
674  return gc;
675 };
676 
678 {
679  auto *gc = new GlobalTextEditSetting(QString("UserJobDesc%1")
680  .arg(job_num));
681  gc->setLabel(QObject::tr("User Job #%1 description").arg(job_num));
682  gc->setValue(QObject::tr("User Job #%1").arg(job_num));
683  gc->setHelpText(QObject::tr("The description for this User Job."));
684  return gc;
685 };
686 
688 {
689  auto *gc = new HostCheckBoxSetting("JobAllowMetadata");
690  gc->setLabel(QObject::tr("Allow metadata lookup jobs"));
691  gc->setValue(true);
692  gc->setHelpText(QObject::tr("If enabled, allow jobs of this type to "
693  "run on this backend."));
694  return gc;
695 };
696 
698 {
699  auto *gc = new HostCheckBoxSetting("JobAllowCommFlag");
700  gc->setLabel(QObject::tr("Allow commercial-detection jobs"));
701  gc->setValue(true);
702  gc->setHelpText(QObject::tr("If enabled, allow jobs of this type to "
703  "run on this backend."));
704  return gc;
705 };
706 
708 {
709  auto *gc = new HostCheckBoxSetting("JobAllowTranscode");
710  gc->setLabel(QObject::tr("Allow transcoding jobs"));
711  gc->setValue(true);
712  gc->setHelpText(QObject::tr("If enabled, allow jobs of this type to "
713  "run on this backend."));
714  return gc;
715 };
716 
718 {
719  auto *gc = new HostCheckBoxSetting("JobAllowPreview");
720  gc->setLabel(QObject::tr("Allow preview jobs"));
721  gc->setValue(true);
722  gc->setHelpText(QObject::tr("If enabled, allow jobs of this type to "
723  "run on this backend."));
724  return gc;
725 };
726 
728 {
729  auto *gc = new GlobalTextEditSetting("JobQueueTranscodeCommand");
730  gc->setLabel(QObject::tr("Transcoder command"));
731  gc->setValue("mythtranscode");
732  gc->setHelpText(QObject::tr("The program used to transcode recordings. "
733  "The default is 'mythtranscode' if this setting is empty."));
734  return gc;
735 };
736 
738 {
739  auto *gc = new GlobalTextEditSetting("JobQueueCommFlagCommand");
740  gc->setLabel(QObject::tr("Commercial-detection command"));
741  gc->setValue("mythcommflag");
742  gc->setHelpText(QObject::tr("The program used to detect commercials in a "
743  "recording. The default is 'mythcommflag' "
744  "if this setting is empty."));
745  return gc;
746 };
747 
749 {
750  QString dbStr = QString("JobAllowUserJob%1").arg(job_num);
751  QString desc = gCoreContext->GetSetting(QString("UserJobDesc%1").arg(job_num));
752  QString label = QObject::tr("Allow %1 jobs").arg(desc);
753 
754  auto *bc = new HostCheckBoxSetting(dbStr);
755  bc->setLabel(label);
756  bc->setValue(false);
757  // FIXME:
758  // It would be nice to disable inactive jobs,
759  // but enabling them currently requires a restart of mythtv-setup
760  // after entering the job command string. Will improve this logic later:
761  // if (QString(gCoreContext->GetSetting(QString("UserJob%1").arg(job_num)))
762  // .length() == 0)
763  // bc->setEnabled(false);
764  bc->setHelpText(QObject::tr("If enabled, allow jobs of this type to "
765  "run on this backend."));
766  return bc;
767 }
768 
769 #if 0
770 static GlobalCheckBoxSetting *UPNPShowRecordingUnderVideos()
771 {
772  GlobalCheckBoxSetting *gc = new GlobalCheckBoxSetting("UPnP/RecordingsUnderVideos");
773  gc->setLabel(QObject::tr("Include recordings in video list"));
774  gc->setValue(false);
775  gc->setHelpText(QObject::tr("If enabled, the master backend will include"
776  " the list of recorded shows in the list of videos. "
777  " This is mainly to accommodate UPnP players which do not"
778  " allow more than 1 video section." ));
779  return gc;
780 };
781 #endif
782 
784 {
785  auto *gc = new GlobalComboBoxSetting("UPnP/WMPSource");
786  gc->setLabel(QObject::tr("Video content to show a WMP client"));
787  gc->addSelection(QObject::tr("Recordings"),"0");
788  gc->addSelection(QObject::tr("Videos"),"1");
789  gc->setValue("0");
790  gc->setHelpText(QObject::tr("Which tree to show a Windows Media Player "
791  "client when it requests a list of videos."));
792  return gc;
793 };
794 
796 {
797  auto *bc = new GlobalCheckBoxSetting("MythFillEnabled");
798  bc->setLabel(QObject::tr("Automatically update program listings"));
799  bc->setValue(true);
800  bc->setHelpText(QObject::tr("If enabled, the guide data program "
801  "will be run automatically."));
802  return bc;
803 }
804 
806 {
807  auto *bs = new GlobalSpinBoxSetting("MythFillMinHour", 0, 23, 1);
808  bs->setLabel(QObject::tr("Guide data program execution start"));
809  bs->setValue(0);
810  bs->setHelpText(QObject::tr("This setting and the following one define a "
811  "time period when the guide data program is allowed "
812  "to run. For example, setting start to 11 and "
813  "end to 13 would mean that the program would only "
814  "run between 11:00 AM and 1:59 PM."));
815  return bs;
816 }
817 
819 {
820  auto *bs = new GlobalSpinBoxSetting("MythFillMaxHour", 0, 23, 1);
821  bs->setLabel(QObject::tr("Guide data program execution end"));
822  bs->setValue(23);
823  bs->setHelpText(QObject::tr("This setting and the preceding one define a "
824  "time period when the guide data program is allowed "
825  "to run. For example, setting start to 11 and "
826  "end to 13 would mean that the program would only "
827  "run between 11:00 AM and 1:59 PM."));
828  return bs;
829 }
830 
832 {
833  auto *bc = new GlobalCheckBoxSetting("MythFillGrabberSuggestsTime");
834  bc->setLabel(QObject::tr("Run guide data program at time suggested by the "
835  "grabber."));
836  bc->setValue(true);
837  bc->setHelpText(QObject::tr("If enabled, allow a guide data "
838  "provider to specify the next download time in order "
839  "to distribute load on their servers. Guide data program "
840  "execution start/end times are also ignored."));
841  return bc;
842 }
843 
845 {
846  auto *be = new GlobalTextEditSetting("MythFillDatabasePath");
847  be->setLabel(QObject::tr("Guide data program"));
848  be->setValue("mythfilldatabase");
849  be->setHelpText(QObject::tr(
850  "Use 'mythfilldatabase' or the name of a custom "
851  "script that will populate the program guide info "
852  "for all your video sources."));
853  return be;
854 }
855 
857 {
858  auto *be = new GlobalTextEditSetting("MythFillDatabaseArgs");
859  be->setLabel(QObject::tr("Guide data arguments"));
860  be->setValue("");
861  be->setHelpText(QObject::tr("Any arguments you want passed to the "
862  "guide data program."));
863  return be;
864 }
865 
867 {
868  public:
870  {
871  setLabel(QObject::tr("Program Schedule Downloading Options"));
872 
873  GlobalCheckBoxSetting* fillEnabled = MythFillEnabled();
874  addChild(fillEnabled);
875 
876  fillEnabled->addTargetedChild("1", MythFillDatabasePath());
877  fillEnabled->addTargetedChild("1", MythFillDatabaseArgs());
878  fillEnabled->addTargetedChild("1", MythFillMinHour());
879  fillEnabled->addTargetedChild("1", MythFillMaxHour());
880  fillEnabled->addTargetedChild("1", MythFillGrabberSuggestsTime());
881  }
882 };
883 
885 {
886  // These two are included for backward compatibility -
887  // used by python bindings. They could be removed later
890 
891  //++ Host Address Backend Setup ++
892  auto* server = new GroupSetting();
893  server->setLabel(tr("Host Address Backend Setup"));
895  server->addChild(m_localServerPort);
896  server->addChild(LocalStatusPort());
897  server->addChild(LocalSecurityPin());
898  server->addChild(AllowConnFromAll());
899  //+++ IP Addresses +++
901  server->addChild(m_ipAddressSettings);
905  static_cast<void (StandardSetting::*)(const QString&)>(&StandardSetting::valueChanged),
908  static_cast<void (StandardSetting::*)(const QString&)>(&StandardSetting::valueChanged),
911  server->addChild(m_backendServerAddr);
912  //++ Master Backend ++
916  server->addChild(m_isMasterBackend);
918  server->addChild(m_masterServerName);
919  addChild(server);
920 
921  //++ Locale Settings ++
922  auto* locale = new GroupSetting();
923  locale->setLabel(QObject::tr("Locale Settings"));
924  locale->addChild(TVFormat());
925  locale->addChild(VbiFormat());
926  locale->addChild(FreqTable());
927  addChild(locale);
928 
929  auto* group2 = new GroupSetting();
930  group2->setLabel(QObject::tr("Miscellaneous Settings"));
931 
932  auto* fm = new GroupSetting();
933  fm->setLabel(QObject::tr("File Management Settings"));
934  fm->addChild(MasterBackendOverride());
935  fm->addChild(DeletesFollowLinks());
936  fm->addChild(TruncateDeletes());
937  fm->addChild(HDRingbufferSize());
938  fm->addChild(StorageScheduler());
939  group2->addChild(fm);
940  auto* upnp = new GroupSetting();
941  upnp->setLabel(QObject::tr("UPnP Server Settings"));
942  //upnp->addChild(UPNPShowRecordingUnderVideos());
943  upnp->addChild(UPNPWmpSource());
944  group2->addChild(upnp);
945  group2->addChild(MiscStatusScript());
946  group2->addChild(DisableAutomaticBackup());
947  group2->addChild(DisableFirewireReset());
948  addChild(group2);
949 
950  auto* group2a1 = new GroupSetting();
951  group2a1->setLabel(QObject::tr("EIT Scanner Options"));
952  group2a1->addChild(EITTransportTimeout());
953  group2a1->addChild(EITCrawIdleStart());
954  addChild(group2a1);
955 
956  auto* group3 = new GroupSetting();
957  group3->setLabel(QObject::tr("Shutdown/Wakeup Options"));
958  group3->addChild(startupCommand());
959  group3->addChild(blockSDWUwithoutClient());
960  group3->addChild(idleTimeoutSecs());
961  group3->addChild(idleWaitForRecordingTime());
962  group3->addChild(StartupSecsBeforeRecording());
963  group3->addChild(WakeupTimeFormat());
964  group3->addChild(SetWakeuptimeCommand());
965  group3->addChild(ServerHaltCommand());
966  group3->addChild(preSDWUCheckCommand());
967  addChild(group3);
968 
969  auto* group4 = new GroupSetting();
970  group4->setLabel(QObject::tr("Backend Wakeup settings"));
971 
972  auto* backend = new GroupSetting();
973  backend->setLabel(QObject::tr("Master Backend"));
974  backend->addChild(WOLbackendReconnectWaitTime());
975  backend->addChild(WOLbackendConnectRetry());
976  backend->addChild(WOLbackendCommand());
977  group4->addChild(backend);
978 
979  auto* slaveBackend = new GroupSetting();
980  slaveBackend->setLabel(QObject::tr("Slave Backends"));
981  slaveBackend->addChild(SleepCommand());
982  slaveBackend->addChild(WakeUpCommand());
983  group4->addChild(slaveBackend);
984  addChild(group4);
985 
986  auto* backendControl = new GroupSetting();
987  backendControl->setLabel(QObject::tr("Backend Control"));
988  backendControl->addChild(BackendStopCommand());
989  backendControl->addChild(BackendStartCommand());
990  addChild(backendControl);
991 
992  auto* group5 = new GroupSetting();
993  group5->setLabel(QObject::tr("Job Queue (Backend-Specific)"));
994  group5->addChild(JobQueueMaxSimultaneousJobs());
995  group5->addChild(JobQueueCheckFrequency());
996  group5->addChild(JobQueueWindowStart());
997  group5->addChild(JobQueueWindowEnd());
998  group5->addChild(JobQueueCPU());
999  group5->addChild(JobAllowMetadata());
1000  group5->addChild(JobAllowCommFlag());
1001  group5->addChild(JobAllowTranscode());
1002  group5->addChild(JobAllowPreview());
1003  group5->addChild(JobAllowUserJob(1));
1004  group5->addChild(JobAllowUserJob(2));
1005  group5->addChild(JobAllowUserJob(3));
1006  group5->addChild(JobAllowUserJob(4));
1007  addChild(group5);
1008 
1009  auto* group6 = new GroupSetting();
1010  group6->setLabel(QObject::tr("Job Queue (Global)"));
1011  group6->addChild(JobsRunOnRecordHost());
1012  group6->addChild(AutoCommflagWhileRecording());
1013  group6->addChild(JobQueueCommFlagCommand());
1014  group6->addChild(JobQueueTranscodeCommand());
1015  group6->addChild(AutoTranscodeBeforeAutoCommflag());
1016  group6->addChild(SaveTranscoding());
1017  addChild(group6);
1018 
1019  auto* group7 = new GroupSetting();
1020  group7->setLabel(QObject::tr("Job Queue (Job Commands)"));
1021  group7->addChild(UserJobDesc(1));
1022  group7->addChild(UserJob(1));
1023  group7->addChild(UserJobDesc(2));
1024  group7->addChild(UserJob(2));
1025  group7->addChild(UserJobDesc(3));
1026  group7->addChild(UserJob(3));
1027  group7->addChild(UserJobDesc(4));
1028  group7->addChild(UserJob(4));
1029  addChild(group7);
1030 
1031  auto *mythfill = new MythFillSettings();
1032  addChild(mythfill);
1033 
1034 }
1035 
1037 {
1038  if (!m_isLoaded)
1039  return;
1040  bool ismasterchecked = m_isMasterBackend->boolValue();
1041  if (ismasterchecked)
1043  else
1045 }
1046 
1048 {
1049  if (!m_isLoaded)
1050  return;
1051  bool addrChanged = m_backendServerAddr->haveChanged();
1052  QString currentsetting = m_backendServerAddr->getValue();
1055  {
1056  QList<QHostAddress> list = QNetworkInterface::allAddresses();
1057  QList<QHostAddress>::iterator it;
1058  for (it = list.begin(); it != list.end(); ++it)
1059  {
1060  it->setScopeId(QString());
1061  m_backendServerAddr->addSelection((*it).toString(), (*it).toString());
1062  }
1063  }
1064  else
1065  {
1070  }
1071  // Remove the blank entry that is caused by clearSelections
1072  // TODO probably not needed anymore?
1073  // m_backendServerAddr->removeSelection(QString());
1074 
1075  QHostAddress addr;
1076  if (addr.setAddress(currentsetting))
1077  {
1078  // if prior setting is an ip address
1079  // it only if it is now in the list
1080  if (m_backendServerAddr->getValueIndex(currentsetting)
1081  > -1)
1082  m_backendServerAddr->setValue(currentsetting);
1083  else
1085  }
1086  else if (! currentsetting.isEmpty())
1087  {
1088  // if prior setting was not an ip address, it must
1089  // have been a dns name so add it back and select it.
1090  m_backendServerAddr->addSelection(currentsetting);
1091  m_backendServerAddr->setValue(currentsetting);
1092  }
1093  else
1095  m_backendServerAddr->setChanged(addrChanged);
1096 }
1097 
1098 
1100 {
1101  m_isLoaded=false;
1103 
1104  // These two are included for backward compatibility - only used by python
1105  // bindings. They should be removed later
1108 
1109  QString mastername = m_masterServerName->getValue();
1110  // new installation - default to master
1111  bool newInstall=false;
1112  if (mastername.isEmpty())
1113  {
1114  mastername = gCoreContext->GetHostName();
1115  newInstall=true;
1116  }
1117  bool ismaster = (mastername == gCoreContext->GetHostName());
1118  m_isMasterBackend->setValue(ismaster);
1119  m_priorMasterName = mastername;
1120  m_isLoaded=true;
1122  listenChanged();
1123  if (!newInstall)
1124  {
1126  m_isMasterBackend->setChanged(false);
1128  }
1129 }
1130 
1132 {
1133  // Setup deprecated backward compatibility settings
1135  {
1136  QString addr = m_backendServerAddr->getValue();
1137  QString ip = MythCoreContext::resolveAddress(addr);
1140  }
1141 
1142  // If listen on all is specified, set up values for the
1143  // specific IPV4 and IPV6 addresses for backward
1144  // compatibilty with other things that may use them
1146  {
1147  QString bea = m_backendServerAddr->getValue();
1148  // initialize them to localhost values
1151  QString ip4 = MythCoreContext::resolveAddress
1153  QString ip6 = MythCoreContext::resolveAddress
1155  // the setValue calls below only set the value if it is in the list.
1158  }
1159 
1161 
1162  // These two are included for backward compatibility - only used by python
1163  // bindings. They should be removed later
1166 }
1167 
1169 {
1170  delete m_masterServerIP;
1171  m_masterServerIP=nullptr;
1172  delete m_masterServerPort;
1173  m_masterServerPort=nullptr;
1174 }
SetWakeuptimeCommand
static GlobalTextEditSetting * SetWakeuptimeCommand()
Definition: backendsettings.cpp:522
HDRingbufferSize
static GlobalSpinBoxSetting * HDRingbufferSize()
Definition: backendsettings.cpp:295
MythFillSettings
Definition: backendsettings.cpp:866
MythUIComboBoxSetting::clearSelections
void clearSelections()
Definition: standardsettings.cpp:513
IpAddressSettings::m_localServerIP
HostComboBoxSetting * m_localServerIP
Definition: backendsettings.cpp:125
MasterServerIP
static GlobalTextEditSetting * MasterServerIP()
Definition: backendsettings.cpp:192
HostTimeBoxSetting
Definition: standardsettings.h:279
MythFillDatabasePath
static GlobalTextEditSetting * MythFillDatabasePath()
Definition: backendsettings.cpp:844
TransMythUICheckBoxSetting
Definition: standardsettings.h:411
StandardSetting::setValue
virtual void setValue(const QString &newValue)
Definition: standardsettings.cpp:169
EITTransportTimeout
static GlobalSpinBoxSetting * EITTransportTimeout()
Definition: backendsettings.cpp:364
SaveTranscoding
static GlobalCheckBoxSetting * SaveTranscoding()
Definition: backendsettings.cpp:261
JobAllowPreview
static HostCheckBoxSetting * JobAllowPreview()
Definition: backendsettings.cpp:717
MythFillMinHour
static GlobalSpinBoxSetting * MythFillMinHour()
Definition: backendsettings.cpp:805
WakeupTimeFormat
static GlobalTextEditSetting * WakeupTimeFormat()
Definition: backendsettings.cpp:510
VbiFormat
static GlobalComboBoxSetting * VbiFormat()
Definition: backendsettings.cpp:234
ServerHaltCommand
static GlobalTextEditSetting * ServerHaltCommand()
Definition: backendsettings.cpp:532
BackendSettings::m_isMasterBackend
TransMythUICheckBoxSetting * m_isMasterBackend
Definition: backendsettings.h:19
BackendSettings::m_masterServerName
GlobalTextEditSetting * m_masterServerName
Definition: backendsettings.h:22
JobQueueCommFlagCommand
static GlobalTextEditSetting * JobQueueCommFlagCommand()
Definition: backendsettings.cpp:737
IpAddressSettings::IpAddressSettings
IpAddressSettings()
Definition: backendsettings.cpp:127
BackendSettings::LocalServerPortChanged
static void LocalServerPortChanged(void)
Definition: backendsettings.cpp:147
WOLbackendReconnectWaitTime
static GlobalSpinBoxSetting * WOLbackendReconnectWaitTime()
Definition: backendsettings.cpp:401
HostTextEditSetting
Definition: standardsettings.h:168
LocalServerIP
static HostComboBoxSetting * LocalServerIP()
Definition: backendsettings.cpp:52
BackendSettings::Save
void Save(void) override
Definition: backendsettings.cpp:1131
frequencies.h
JobAllowCommFlag
static HostCheckBoxSetting * JobAllowCommFlag()
Definition: backendsettings.cpp:697
StartupSecsBeforeRecording
static GlobalSpinBoxSetting * StartupSecsBeforeRecording()
Definition: backendsettings.cpp:500
BackendSettings::masterBackendChanged
void masterBackendChanged(void)
Definition: backendsettings.cpp:1036
MasterServerName
static GlobalTextEditSetting * MasterServerName()
Definition: backendsettings.cpp:27
BackendSettings::LocalServerPort
HostTextEditSetting * LocalServerPort(void) const
Definition: backendsettings.cpp:152
JobAllowTranscode
static HostCheckBoxSetting * JobAllowTranscode()
Definition: backendsettings.cpp:707
preSDWUCheckCommand
static GlobalTextEditSetting * preSDWUCheckCommand()
Definition: backendsettings.cpp:541
BackendSettings::Load
void Load(void) override
Definition: backendsettings.cpp:1099
MythFillSettings::MythFillSettings
MythFillSettings()
Definition: backendsettings.cpp:869
JobQueueTranscodeCommand
static GlobalTextEditSetting * JobQueueTranscodeCommand()
Definition: backendsettings.cpp:727
UseLinkLocal
static HostCheckBoxSetting * UseLinkLocal()
Definition: backendsettings.cpp:109
MythFillEnabled
static GlobalCheckBoxSetting * MythFillEnabled()
Definition: backendsettings.cpp:795
StandardSetting::addTargetedChild
void addTargetedChild(const QString &value, StandardSetting *setting)
Definition: standardsettings.cpp:116
BackendStopCommand
static GlobalTextEditSetting * BackendStopCommand()
Definition: backendsettings.cpp:455
GroupSetting::GroupSetting
GroupSetting()=default
MasterBackendOverride
static GlobalCheckBoxSetting * MasterBackendOverride()
Definition: backendsettings.cpp:377
HostCheckBoxSetting
Definition: standardsettings.h:417
JobQueueMaxSimultaneousJobs
static HostSpinBoxSetting * JobQueueMaxSimultaneousJobs()
Definition: backendsettings.cpp:576
StandardSetting::haveChanged
bool haveChanged()
Return true if the setting have changed or any of its children.
Definition: standardsettings.cpp:185
LocalServerIP6
static HostComboBoxSetting * LocalServerIP6()
Definition: backendsettings.cpp:74
StorageScheduler
static GlobalComboBoxSetting * StorageScheduler()
Definition: backendsettings.cpp:310
MythFillGrabberSuggestsTime
static GlobalCheckBoxSetting * MythFillGrabberSuggestsTime()
Definition: backendsettings.cpp:831
BackendSettings::m_masterServerPort
GlobalTextEditSetting * m_masterServerPort
Definition: backendsettings.h:29
MythFillMaxHour
static GlobalSpinBoxSetting * MythFillMaxHour()
Definition: backendsettings.cpp:818
blockSDWUwithoutClient
static GlobalCheckBoxSetting * blockSDWUwithoutClient()
Definition: backendsettings.cpp:554
AllowConnFromAll
static HostCheckBoxSetting * AllowConnFromAll()
Definition: backendsettings.cpp:40
StandardSetting::setChanged
void setChanged(bool changed)
Definition: standardsettings.cpp:208
StandardSetting::addChild
virtual void addChild(StandardSetting *child)
Definition: standardsettings.cpp:70
idleTimeoutSecs
static GlobalSpinBoxSetting * idleTimeoutSecs()
Definition: backendsettings.cpp:477
TVFormat
static GlobalComboBoxSetting * TVFormat()
Definition: backendsettings.cpp:221
DisableFirewireReset
static HostCheckBoxSetting * DisableFirewireReset()
Definition: backendsettings.cpp:338
MasterServerPort
static GlobalTextEditSetting * MasterServerPort()
Definition: backendsettings.cpp:201
BackendSettings::m_localServerPort
HostTextEditSetting * m_localServerPort
Definition: backendsettings.h:20
WOLbackendCommand
static GlobalTextEditSetting * WOLbackendCommand()
Definition: backendsettings.cpp:423
JobAllowUserJob
static HostCheckBoxSetting * JobAllowUserJob(uint job_num)
Definition: backendsettings.cpp:748
BackendSettings::m_backendServerAddr
HostComboBoxSetting * m_backendServerAddr
Definition: backendsettings.h:21
JobsRunOnRecordHost
static GlobalCheckBoxSetting * JobsRunOnRecordHost()
Definition: backendsettings.cpp:630
StandardSetting::Load
virtual void Load(void)
Definition: standardsettings.cpp:213
MythUICheckBoxSetting::valueChanged
void valueChanged(bool)
LocalSecurityPin
static HostTextEditSetting * LocalSecurityPin()
Definition: backendsettings.cpp:209
BackendSettings::~BackendSettings
~BackendSettings() override
Definition: backendsettings.cpp:1168
StandardSetting::setHelpText
virtual void setHelpText(const QString &str)
Definition: standardsettings.h:37
FreqTable
static GlobalComboBoxSetting * FreqTable()
Definition: backendsettings.cpp:247
MythUIComboBoxSetting::getValueIndex
int getValueIndex(const QString &value) const
Definition: standardsettings.cpp:487
StandardSetting::Save
virtual void Save(void)
Definition: standardsettings.cpp:232
LocalStatusPort
static HostTextEditSetting * LocalStatusPort()
Definition: backendsettings.cpp:164
UserJobDesc
static GlobalTextEditSetting * UserJobDesc(uint job_num)
Definition: backendsettings.cpp:677
StandardSetting::getValue
virtual QString getValue(void) const
Definition: standardsettings.h:52
AutoTranscodeBeforeAutoCommflag
static GlobalCheckBoxSetting * AutoTranscodeBeforeAutoCommflag()
Definition: backendsettings.cpp:641
JobQueueWindowStart
static HostTimeBoxSetting * JobQueueWindowStart()
Definition: backendsettings.cpp:610
IpAddressSettings
Definition: backendsettings.cpp:122
uint
unsigned int uint
Definition: compat.h:144
gCoreContext
MythCoreContext * gCoreContext
This global variable contains the MythCoreContext instance for the app.
Definition: mythcorecontext.cpp:60
UserJob
static GlobalTextEditSetting * UserJob(uint job_num)
Definition: backendsettings.cpp:667
MythCoreContext::ResolveIPv6
@ ResolveIPv6
Definition: mythcorecontext.h:213
StandardSetting::setLabel
virtual void setLabel(QString str)
Definition: standardsettings.h:34
MythCoreContext::resolveAddress
static QString resolveAddress(const QString &host, ResolveType type=ResolveAny, bool keepscope=false)
if host is an IP address, it will be returned or resolved otherwise.
Definition: mythcorecontext.cpp:1216
BackendSettings::m_isLoaded
bool m_isLoaded
Definition: backendsettings.h:24
BackendSettings::BackendSettings
BackendSettings()
Definition: backendsettings.cpp:884
GlobalTextEditSetting
Definition: standardsettings.h:175
gChanLists
const CHANLISTS_vec gChanLists
Definition: frequencies.cpp:2215
StandardSetting::valueChanged
void valueChanged(const QString &newValue)
JobQueueCheckFrequency
static HostSpinBoxSetting * JobQueueCheckFrequency()
Definition: backendsettings.cpp:586
backendsettings.h
BackendStartCommand
static GlobalTextEditSetting * BackendStartCommand()
Definition: backendsettings.cpp:466
HostSpinBoxSetting
Definition: standardsettings.h:364
MythUIComboBoxSetting::addSelection
void addSelection(const QString &label, QString value=QString(), bool select=false)
Definition: standardsettings.cpp:498
BackendSettings::m_masterServerIP
GlobalTextEditSetting * m_masterServerIP
Definition: backendsettings.h:28
GlobalSpinBoxSetting
Definition: standardsettings.h:375
MythCoreContext::ResolveIPv4
@ ResolveIPv4
Definition: mythcorecontext.h:213
JobAllowMetadata
static HostCheckBoxSetting * JobAllowMetadata()
Definition: backendsettings.cpp:687
mythcorecontext.h
startupCommand
static GlobalTextEditSetting * startupCommand()
Definition: backendsettings.cpp:564
TruncateDeletes
static HostCheckBoxSetting * TruncateDeletes()
Definition: backendsettings.cpp:272
BackendSettings::m_priorMasterName
QString m_priorMasterName
Definition: backendsettings.h:25
UPNPWmpSource
static GlobalComboBoxSetting * UPNPWmpSource()
Definition: backendsettings.cpp:783
DeletesFollowLinks
static GlobalCheckBoxSetting * DeletesFollowLinks()
Definition: backendsettings.cpp:284
GlobalComboBoxSetting
Definition: standardsettings.h:265
DisableAutomaticBackup
static GlobalCheckBoxSetting * DisableAutomaticBackup()
Definition: backendsettings.cpp:326
MythFillDatabaseArgs
static GlobalTextEditSetting * MythFillDatabaseArgs()
Definition: backendsettings.cpp:856
JobQueueWindowEnd
static HostTimeBoxSetting * JobQueueWindowEnd()
Definition: backendsettings.cpp:620
MythCoreContext::ClearBackendServerPortCache
static void ClearBackendServerPortCache()
Definition: mythcorecontext.cpp:1095
channelsettings.h
HostComboBoxSetting
Definition: standardsettings.h:257
AutoCommflagWhileRecording
static GlobalCheckBoxSetting * AutoCommflagWhileRecording()
Definition: backendsettings.cpp:654
StandardSetting::ChangeSaved
void ChangeSaved()
build_compdb.help
help
Definition: build_compdb.py:10
StandardSetting
Definition: standardsettings.h:29
MythCoreContext::GetHostName
QString GetHostName(void)
Definition: mythcorecontext.cpp:862
WakeUpCommand
static HostTextEditSetting * WakeUpCommand()
Definition: backendsettings.cpp:444
BackendSettings::m_ipAddressSettings
IpAddressSettings * m_ipAddressSettings
Definition: backendsettings.h:23
MiscStatusScript
static HostTextEditSetting * MiscStatusScript()
Definition: backendsettings.cpp:352
GlobalCheckBoxSetting
Definition: standardsettings.h:424
BackendServerAddr
static HostComboBoxSetting * BackendServerAddr()
Definition: backendsettings.cpp:175
IpAddressSettings::m_localServerIP6
HostComboBoxSetting * m_localServerIP6
Definition: backendsettings.cpp:126
JobQueueCPU
static HostComboBoxSetting * JobQueueCPU()
Definition: backendsettings.cpp:596
ChannelTVFormat::GetFormats
static QStringList GetFormats(void)
Definition: channelsettings.cpp:152
IsMasterBackend
static TransMythUICheckBoxSetting * IsMasterBackend()
Definition: backendsettings.cpp:12
BackendSettings::listenChanged
void listenChanged(void)
Definition: backendsettings.cpp:1047
MythUICheckBoxSetting::setValue
void setValue(const QString &newValue) override
Definition: standardsettings.cpp:720
EITCrawIdleStart
static GlobalSpinBoxSetting * EITCrawIdleStart()
Definition: backendsettings.cpp:389
idleWaitForRecordingTime
static GlobalSpinBoxSetting * idleWaitForRecordingTime()
Definition: backendsettings.cpp:488
WOLbackendConnectRetry
static GlobalSpinBoxSetting * WOLbackendConnectRetry()
Definition: backendsettings.cpp:413
MythUIComboBoxSetting::setValue
void setValue(int value) override
Definition: standardsettings.cpp:478
GroupSetting
Definition: standardsettings.h:435
SleepCommand
static HostTextEditSetting * SleepCommand()
Definition: backendsettings.cpp:433
MythCoreContext::GetSetting
QString GetSetting(const QString &key, const QString &defaultval="")
Definition: mythcorecontext.cpp:922
MythUICheckBoxSetting::boolValue
bool boolValue()
Definition: standardsettings.h:403