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