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