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