vdr 2.7.6
menu.c
Go to the documentation of this file.
1/*
2 * menu.c: The actual menu implementations
3 *
4 * See the main source file 'vdr.c' for copyright information and
5 * how to reach the author.
6 *
7 * $Id: menu.c 5.29 2025/06/20 14:02:57 kls Exp $
8 */
9
10#include "menu.h"
11#include <ctype.h>
12#include <limits.h>
13#include <math.h>
14#include <stdio.h>
15#include <stdlib.h>
16#include <string.h>
17#include "channels.h"
18#include "config.h"
19#include "cutter.h"
20#include "eitscan.h"
21#include "i18n.h"
22#include "interface.h"
23#include "plugin.h"
24#include "recording.h"
25#include "remote.h"
26#include "shutdown.h"
27#include "sourceparams.h"
28#include "sources.h"
29#include "status.h"
30#include "svdrp.h"
31#include "themes.h"
32#include "timers.h"
33#include "transfer.h"
34#include "videodir.h"
35
36#define MAXWAIT4EPGINFO 3 // seconds
37#define MODETIMEOUT 3 // seconds
38#define NEWTIMERLIMIT 120 // seconds until the start time of a new timer created from the Schedule menu,
39 // within which it will go directly into the "Edit timer" menu to allow
40 // further parameter settings
41#define DEFERTIMER 60 // seconds by which a timer is deferred in case of problems
42
43#define MAXRECORDCONTROLS (MAXDEVICES * MAXRECEIVERS)
44#define MAXINSTANTRECTIME (24 * 60 - 1) // 23:59 hours
45#define MAXWAITFORCAMMENU 10 // seconds to wait for the CAM menu to open
46#define CAMMENURETRYTIMEOUT 3 // seconds after which opening the CAM menu is retried
47#define CAMRESPONSETIMEOUT 5 // seconds to wait for a response from a CAM
48#define PROGRESSTIMEOUT 100 // milliseconds to wait before updating the replay progress display
49#define MINFREEDISK 300 // minimum free disk space (in MB) required to start recording
50#define NODISKSPACEDELTA 300 // seconds between "Not enough disk space to start recording!" messages
51#define MAXCHNAMWIDTH 16 // maximum number of characters of channels' short names shown in schedules menus
52
53#define CHNUMWIDTH (numdigits(cChannels::MaxNumber()) + 1)
54#define CHNAMWIDTH (min(MAXCHNAMWIDTH, cChannels::MaxShortChannelNameLength() + 1))
55
56// --- cMenuEditCaItem -------------------------------------------------------
57
59protected:
60 virtual void Set(void) override;
61public:
62 cMenuEditCaItem(const char *Name, int *Value);
64 };
65
66cMenuEditCaItem::cMenuEditCaItem(const char *Name, int *Value)
67:cMenuEditIntItem(Name, Value, 0)
68{
69 Set();
70}
71
73{
74 if (*value == CA_FTA)
75 SetValue(tr("Free To Air"));
76 else if (*value >= CA_ENCRYPTED_MIN)
77 SetValue(tr("encrypted"));
78 else
80}
81
83{
85
86 if (state == osUnknown) {
87 if (NORMALKEY(Key) == kLeft && *value >= CA_ENCRYPTED_MIN)
88 *value = CA_FTA;
89 else
91 Set();
93 }
94 return state;
95}
96
97// --- cMenuEditSrcItem ------------------------------------------------------
98
100private:
102protected:
103 virtual void Set(void) override;
104public:
105 cMenuEditSrcItem(const char *Name, int *Value);
107 };
108
109cMenuEditSrcItem::cMenuEditSrcItem(const char *Name, int *Value)
110:cMenuEditIntItem(Name, Value, 0)
111{
112 source = Sources.Get(*Value);
113 Set();
114}
115
117{
118 if (source)
119 SetValue(cString::sprintf("%s - %s", *cSource::ToString(source->Code()), source->Description()));
120 else
122}
123
125{
127
128 if (state == osUnknown) {
129 bool IsRepeat = Key & k_Repeat;
130 Key = NORMALKEY(Key);
131 if (Key == kLeft) { // TODO might want to increase the delta if repeated quickly?
132 if (source) {
133 if (source->Prev())
134 source = (cSource *)source->Prev();
135 else if (!IsRepeat)
136 source = Sources.Last();
137 *value = source->Code();
138 }
139 }
140 else if (Key == kRight) {
141 if (source) {
142 if (source->Next())
143 source = (cSource *)source->Next();
144 else if (!IsRepeat)
145 source = Sources.First();
146 }
147 else
148 source = Sources.First();
149 if (source)
150 *value = source->Code();
151 }
152 else
153 return state; // we don't call cMenuEditIntItem::ProcessKey(Key) here since we don't accept numerical input
154 Set();
156 }
157 return state;
158}
159
160// --- cMenuEditChannel ------------------------------------------------------
161
163private:
168 char name[256];
169 void Setup(void);
170public:
171 cMenuEditChannel(cStateKey *ChannelsStateKey, cChannel *Channel, bool New = false);
172 cChannel *Channel(void) { return channel; }
173 virtual eOSState ProcessKey(eKeys Key) override;
174 };
175
177:cOsdMenu(tr("Edit channel"), 16)
178{
180 channelsStateKey = ChannelsStateKey;
182 sourceParam = NULL;
183 *name = 0;
184 if (channel) {
185 data = *channel;
186 strn0cpy(name, data.name, sizeof(name));
187 if (New) {
188 channel = NULL;
189 // clear non-editable members:
190 data.nid = 0;
191 data.tid = 0;
192 data.rid = 0;
193 *data.shortName = 0;
194 *data.provider = 0;
195 *data.portalName = 0;
196 }
197 }
198 Setup();
199}
200
202{
203 int current = Current();
204
205 Clear();
206
207 // Parameters for all types of sources:
208 Add(new cMenuEditStrItem( tr("Name"), name, sizeof(name)));
209 Add(new cMenuEditSrcItem( tr("Source"), &data.source));
210 Add(new cMenuEditIntItem( tr("Frequency"), &data.frequency));
211 Add(new cMenuEditIntItem( tr("Vpid"), &data.vpid, 0, 0x1FFF));
212 Add(new cMenuEditIntItem( tr("Ppid"), &data.ppid, 0, 0x1FFF));
213 Add(new cMenuEditIntItem( tr("Apid1"), &data.apids[0], 0, 0x1FFF));
214 Add(new cMenuEditIntItem( tr("Apid2"), &data.apids[1], 0, 0x1FFF));
215 Add(new cMenuEditIntItem( tr("Dpid1"), &data.dpids[0], 0, 0x1FFF));
216 Add(new cMenuEditIntItem( tr("Dpid2"), &data.dpids[1], 0, 0x1FFF));
217 Add(new cMenuEditIntItem( tr("Spid1"), &data.spids[0], 0, 0x1FFF));
218 Add(new cMenuEditIntItem( tr("Spid2"), &data.spids[1], 0, 0x1FFF));
219 Add(new cMenuEditIntItem( tr("Tpid"), &data.tpid, 0, 0x1FFF));
220 Add(new cMenuEditCaItem( tr("CA"), &data.caids[0]));
221 Add(new cMenuEditIntItem( tr("Sid"), &data.sid, 1, 0xFFFF));
222 Add(new cMenuEditIntItem( tr("Nid"), &data.nid, 0));
223 Add(new cMenuEditIntItem( tr("Tid"), &data.tid, 0));
224 /* XXX not yet used
225 Add(new cMenuEditIntItem( tr("Rid"), &data.rid, 0));
226 XXX*/
227 // Parameters for specific types of sources:
229 if (sourceParam) {
230 sourceParam->SetData(&data);
231 cOsdItem *Item;
232 while ((Item = sourceParam->GetOsdItem()) != NULL)
233 Add(Item);
234 }
235
237 Display();
238}
239
241{
242 int oldSource = data.source;
243 eOSState state = cOsdMenu::ProcessKey(Key);
244
245 if (state == osUnknown) {
246 if (Key == kOk) {
248 bool Modified = false;
249 if (sourceParam)
250 sourceParam->GetData(&data);
251 if (Channels->HasUniqueChannelID(&data, channel)) {
252 data.name = strcpyrealloc(data.name, name);
253 if (channel) {
254 *channel = data;
255 isyslog("edited channel %d %s", channel->Number(), *channel->ToText());
256 state = osBack;
257 }
258 else {
259 channel = new cChannel;
260 *channel = data;
261 Channels->Add(channel);
262 Channels->ReNumber();
263 isyslog("added channel %d %s", channel->Number(), *channel->ToText());
264 state = osUser1;
265 }
266 Channels->SetModifiedByUser();
267 Modified = true;
268 }
269 else {
270 Skins.Message(mtError, tr("Channel settings are not unique!"));
271 state = osContinue;
272 }
273 channelsStateKey->Remove(Modified);
274 }
275 }
276 if (Key != kNone && (data.source & cSource::st_Mask) != (oldSource & cSource::st_Mask)) {
278 if (sourceParam)
279 sourceParam->GetData(&data);
280 Setup();
281 }
282 return state;
283}
284
285// --- cMenuChannelItem ------------------------------------------------------
286
288public:
290private:
293public:
297 static eChannelSortMode SortMode(void) { return sortMode; }
298 virtual int Compare(const cListObject &ListObject) const override;
299 virtual void Set(void) override;
300 const cChannel *Channel(void) { return channel; }
301 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
302 };
303
305
307{
309 if (channel->GroupSep())
310 SetSelectable(false);
311 Set();
312}
313
314int cMenuChannelItem::Compare(const cListObject &ListObject) const
315{
316 cMenuChannelItem *p = (cMenuChannelItem *)&ListObject;
317 int r = -1;
318 if (sortMode == csmProvider)
319 r = strcoll(channel->Provider(), p->channel->Provider());
320 if (sortMode == csmName || r == 0)
321 r = strcoll(channel->Name(), p->channel->Name());
322 if (sortMode == csmNumber || r == 0)
323 r = channel->Number() - p->channel->Number();
324 return r;
325}
326
328{
329 cString buffer;
330 if (!channel->GroupSep()) {
331 const char *X = *channel->Caids() >= CA_ENCRYPTED_MIN ? "X" : "";
332 const char *R = !channel->Vpid() && (*channel->Apids() || *channel->Dpids()) ? "R" : "";
333 if (sortMode == csmProvider)
334 buffer = cString::sprintf("%d\t%s%s\t%s - %s", channel->Number(), X, R, channel->Provider(), channel->Name());
335 else
336 buffer = cString::sprintf("%d\t%s%s\t%s", channel->Number(), X, R, channel->Name());
337 }
338 else
339 buffer = cString::sprintf("\t\t%s", channel->Name());
340 SetText(buffer);
341}
342
343void cMenuChannelItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
344{
346 if (!DisplayMenu->SetItemChannel(channel, Index, Current, Selectable, sortMode == csmProvider))
347 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
348}
349
350// --- cMenuChannels ---------------------------------------------------------
351
352#define CHANNELNUMBERTIMEOUT 1000 //ms
353
354class cMenuChannels : public cOsdMenu {
355private:
359 void Set(bool Force = false);
360 cChannel *GetChannel(int Index);
361 void Propagate(cChannels *Channels);
362protected:
363 eOSState Number(eKeys Key);
364 eOSState Switch(void);
365 eOSState Edit(void);
366 eOSState New(void);
367 eOSState Delete(void);
368 virtual void Move(int From, int To) override;
369public:
370 cMenuChannels(void);
372 virtual eOSState ProcessKey(eKeys Key) override;
373 };
374
376:cOsdMenu(tr("Channels"), CHNUMWIDTH, 3)
377{
379 number = 0;
380 Set();
381}
382
386
387void cMenuChannels::Set(bool Force)
388{
389 if (Force)
390 channelsStateKey.Reset();
392 const cChannel *CurrentChannel = GetChannel(Current());
393 if (!CurrentChannel)
394 CurrentChannel = Channels->GetByNumber(cDevice::CurrentChannel());
395 cMenuChannelItem *CurrentItem = NULL;
396 Clear();
397 for (const cChannel *Channel = Channels->First(); Channel; Channel = Channels->Next(Channel)) {
398 if (!Channel->GroupSep() || cMenuChannelItem::SortMode() == cMenuChannelItem::csmNumber && *Channel->Name()) {
399 cMenuChannelItem *Item = new cMenuChannelItem(Channel);
400 Add(Item);
401 if (Channel == CurrentChannel)
402 CurrentItem = Item;
403 }
404 }
407 msmNumber);
409 Sort();
410 SetCurrent(CurrentItem);
411 SetHelp(tr("Button$Edit"), tr("Button$New"), tr("Button$Delete"), tr("Button$Mark"));
412 Display();
413 channelsStateKey.Remove();
414 }
415}
416
418{
420 return p ? (cChannel *)p->Channel() : NULL;
421}
422
424{
425 Channels->ReNumber();
426 for (cMenuChannelItem *ci = (cMenuChannelItem *)First(); ci; ci = (cMenuChannelItem *)ci->Next())
427 ci->Set();
428 Display();
429 Channels->SetModifiedByUser();
430}
431
433{
434 if (HasSubMenu())
435 return osContinue;
436 if (numberTimer.TimedOut())
437 number = 0;
438 if (!number && Key == k0) {
440 Set(true);
441 }
442 else {
444 number = number * 10 + Key - k0;
445 for (cMenuChannelItem *ci = (cMenuChannelItem *)First(); ci; ci = (cMenuChannelItem *)ci->Next()) {
446 if (!ci->Channel()->GroupSep() && ci->Channel()->Number() == number) {
447 DisplayCurrent(false);
448 SetCurrent(ci);
449 DisplayCurrent(true);
450 break;
451 }
452 }
454 }
455 return osContinue;
456}
457
459{
460 if (HasSubMenu())
461 return osContinue;
463 cChannel *ch = GetChannel(Current());
464 if (ch)
466 return osEnd;
467}
468
470{
471 if (HasSubMenu() || Count() == 0)
472 return osContinue;
474 cChannel *ch = GetChannel(Current());
475 if (ch)
477 return osContinue;
478}
479
487
489{
490 if (!HasSubMenu() && Count() > 0) {
491 LOCK_TIMERS_READ; // must lock timers before channels!
493 int Index = Current();
494 cChannel *Channel = GetChannel(Current());
495 if (!Channels->Contains(Channel)) {
496 channelsStateKey.Remove(false);
497 channelsStateKey.Reset(); // makes sure the menu is refreshed
498 return osContinue;
499 }
500 bool Deleted = false;
501 int CurrentChannelNr = cDevice::CurrentChannel();
502 cChannel *CurrentChannel = Channels->GetByNumber(CurrentChannelNr);
503 int DeletedChannel = Channel->Number();
504 // Check if there is a timer using this channel:
505 if (Timers->UsesChannel(Channel)) {
506 channelsStateKey.Remove(false);
507 Skins.Message(mtError, tr("Channel is being used by a timer!"));
508 return osContinue;
509 }
510 if (Interface->Confirm(tr("Delete channel?"))) {
511 if (CurrentChannel && Channel == CurrentChannel) {
512 int n = Channels->GetNextNormal(CurrentChannel->Index());
513 if (n < 0)
514 n = Channels->GetPrevNormal(CurrentChannel->Index());
515 CurrentChannel = Channels->Get(n);
516 CurrentChannelNr = 0; // triggers channel switch below
517 }
518 Channels->Del(Channel);
519 cOsdMenu::Del(Index);
520 Propagate(Channels);
521 isyslog("channel %d deleted", DeletedChannel);
522 Deleted = true;
523 if (CurrentChannel && CurrentChannel->Number() != CurrentChannelNr) {
524 if (!cDevice::PrimaryDevice()->Replaying() || cDevice::PrimaryDevice()->Transferring())
525 Channels->SwitchTo(CurrentChannel->Number());
526 else
527 cDevice::SetCurrentChannel(CurrentChannel->Number());
528 }
529 }
530 channelsStateKey.Remove(Deleted);
531 }
532 return osContinue;
533}
534
535void cMenuChannels::Move(int From, int To)
536{
538 int CurrentChannelNr = cDevice::CurrentChannel();
539 cChannel *CurrentChannel = Channels->GetByNumber(CurrentChannelNr);
540 cChannel *FromChannel = GetChannel(From);
541 cChannel *ToChannel = GetChannel(To);
542 if (FromChannel && ToChannel) {
543 int FromNumber = FromChannel->Number();
544 int ToNumber = ToChannel->Number();
545 if (Channels->MoveNeedsDecrement(FromChannel, ToChannel)) {
546 ToChannel = Channels->Prev(ToChannel); // cListBase::Move() doesn't know about the channel list's numbered groups!
547 To--;
548 }
549 Channels->Move(FromChannel, ToChannel);
550 cOsdMenu::Move(From, To);
551 SetCurrent(Get(To));
552 Propagate(Channels);
553 isyslog("channel %d moved to %d", FromNumber, ToNumber);
554 if (CurrentChannel && CurrentChannel->Number() != CurrentChannelNr) {
555 if (!cDevice::PrimaryDevice()->Replaying() || cDevice::PrimaryDevice()->Transferring())
556 Channels->SwitchTo(CurrentChannel->Number());
557 else
558 cDevice::SetCurrentChannel(CurrentChannel->Number());
559 }
560 }
561 channelsStateKey.Remove();
562 }
563}
564
566{
567 if (!HasSubMenu())
568 Set(); // react on any changes to the channels list
569 eOSState state = cOsdMenu::ProcessKey(Key);
570
571 switch (state) {
572 case osUser1: {
573 if (cMenuEditChannel *MenuEditChannel = dynamic_cast<cMenuEditChannel *>(SubMenu())) {
574 if (cChannel *Channel = MenuEditChannel->Channel()) {
576 Add(new cMenuChannelItem(Channel), true);
577 return CloseSubMenu();
578 }
579 }
580 }
581 break;
582 default:
583 if (state == osUnknown) {
584 switch (int(Key)) {
585 case k0 ... k9:
586 return Number(Key);
587 case kOk: return Switch();
588 case kRed: return Edit();
589 case kGreen: return New();
590 case kYellow: return Delete();
591 case kBlue: if (!HasSubMenu())
592 Mark();
593 break;
594 case kChanUp|k_Repeat:
595 case kChanUp:
596 case kChanDn|k_Repeat:
597 case kChanDn: {
599 int CurrentChannelNr = cDevice::CurrentChannel();
600 for (cMenuChannelItem *ci = (cMenuChannelItem *)First(); ci; ci = (cMenuChannelItem *)ci->Next()) {
601 if (!ci->Channel()->GroupSep() && ci->Channel()->Number() == CurrentChannelNr) {
602 SetCurrent(ci);
603 Display();
604 break;
605 }
606 }
607 }
608 default: break;
609 }
610 }
611 }
612 return state;
613}
614
615// --- cMenuText -------------------------------------------------------------
616
617cMenuText::cMenuText(const char *Title, const char *Text, eDvbFont Font)
619{
621 text = NULL;
622 font = Font;
623 SetText(Text);
624}
625
627{
628 free(text);
629}
630
631void cMenuText::SetText(const char *Text)
632{
633 free(text);
634 text = Text ? strdup(Text) : NULL;
635}
636
638{
640 DisplayMenu()->SetText(text, font == fontFix); //XXX define control character in text to choose the font???
641 if (text)
643}
644
646{
647 switch (int(Key)) {
648 case kUp|k_Repeat:
649 case kUp:
650 case kDown|k_Repeat:
651 case kDown:
652 case kLeft|k_Repeat:
653 case kLeft:
654 case kRight|k_Repeat:
655 case kRight:
656 DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight);
657 cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft);
658 return osContinue;
659 default: break;
660 }
661
662 eOSState state = cOsdMenu::ProcessKey(Key);
663
664 if (state == osUnknown) {
665 switch (Key) {
666 case kOk: return osBack;
667 default: state = osContinue;
668 }
669 }
670 return state;
671}
672
673// --- cMenuFolderItem -------------------------------------------------------
674
675class cMenuFolderItem : public cOsdItem {
676private:
678public:
679 virtual void Set(void) override;
681 cNestedItem *Folder(void) { return folder; }
682 };
683
690
692{
693 if (folder->SubItems() && folder->SubItems()->Count())
694 SetText(cString::sprintf("%s...", folder->Text()));
695 else
696 SetText(folder->Text());
697}
698
699// --- cMenuEditFolder -------------------------------------------------------
700
701class cMenuEditFolder : public cOsdMenu {
702private:
705 char name[PATH_MAX];
706 eOSState Confirm(void);
707public:
708 cMenuEditFolder(const char *Dir, cList<cNestedItem> *List, cNestedItem *Folder = NULL);
709 cString GetFolder(void);
710 virtual eOSState ProcessKey(eKeys Key) override;
711 };
712
714:cOsdMenu(Folder ? tr("Edit folder") : tr("New folder"), 12)
715{
717 list = List;
718 folder = Folder;
719 if (folder)
720 strn0cpy(name, folder->Text(), sizeof(name));
721 else {
722 *name = 0;
723 cRemote::Put(kRight, true); // go right into string editing mode
724 }
725 if (!isempty(Dir)) {
726 cOsdItem *DirItem = new cOsdItem(Dir);
727 DirItem->SetSelectable(false);
728 Add(DirItem);
729 }
730 Add(new cMenuEditStrItem( tr("Name"), name, sizeof(name)));
731}
732
734{
735 return folder ? folder->Text() : "";
736}
737
739{
740 if (!folder || strcmp(folder->Text(), name) != 0) {
741 // each name may occur only once in a folder list
742 for (cNestedItem *Folder = list->First(); Folder; Folder = list->Next(Folder)) {
743 if (strcmp(Folder->Text(), name) == 0) {
744 Skins.Message(mtError, tr("Folder name already exists!"));
745 return osContinue;
746 }
747 }
748 char *p = strpbrk(name, "\\{}#~"); // FOLDERDELIMCHAR
749 if (p) {
750 Skins.Message(mtError, cString::sprintf(tr("Folder name must not contain '%c'!"), *p));
751 return osContinue;
752 }
753 }
754 if (folder)
755 folder->SetText(name);
756 else
757 list->Add(folder = new cNestedItem(name));
758 return osEnd;
759}
760
762{
763 eOSState state = cOsdMenu::ProcessKey(Key);
764
765 if (state == osUnknown) {
766 switch (Key) {
767 case kOk: return Confirm();
768 case kRed:
769 case kGreen:
770 case kYellow:
771 case kBlue: return osContinue;
772 default: break;
773 }
774 }
775 return state;
776}
777
778// --- cMenuFolder -----------------------------------------------------------
779
780cMenuFolder::cMenuFolder(const char *Title, cNestedItemList *NestedItemList, const char *Path)
782{
784 list = nestedItemList = NestedItemList;
785 firstFolder = NULL;
786 editing = false;
787 helpKeys = -1;
788 Set();
789 DescendPath(Path);
790 Display();
791 SetHelpKeys();
792}
793
794cMenuFolder::cMenuFolder(const char *Title, cList<cNestedItem> *List, cNestedItemList *NestedItemList, const char *Dir, const char *Path)
796{
798 list = List;
799 nestedItemList = NestedItemList;
800 dir = Dir;
801 firstFolder = NULL;
802 editing = false;
803 helpKeys = -1;
804 Set();
805 DescendPath(Path);
806 Display();
807 SetHelpKeys();
808}
809
811{
812 if (HasSubMenu())
813 return;
814 int NewHelpKeys = 0;
815 if (firstFolder)
816 NewHelpKeys = 1;
817 if (NewHelpKeys != helpKeys) {
818 helpKeys = NewHelpKeys;
819 SetHelp(NewHelpKeys > 0 ? tr("Button$Open") : NULL, tr("Button$New"), firstFolder ? tr("Button$Delete") : NULL, firstFolder ? tr("Button$Edit") : NULL);
820 }
821}
822
823#define FOLDERDELIMCHARSUBST 0x01
824static void AddRecordingFolders(const cRecordings *Recordings, cList<cNestedItem> *List, char *Path)
825{
826 if (Path) {
827 char *p = strchr(Path, FOLDERDELIMCHARSUBST);
828 if (p)
829 *p++ = 0;
830 cNestedItem *Folder;
831 for (Folder = List->First(); Folder; Folder = List->Next(Folder)) {
832 if (strcmp(Path, Folder->Text()) == 0)
833 break;
834 }
835 if (!Folder)
836 List->Add(Folder = new cNestedItem(Path));
837 if (p) {
838 Folder->SetSubItems(true);
839 AddRecordingFolders(Recordings, Folder->SubItems(), p);
840 }
841 }
842 else {
843 cStringList Dirs;
844 for (const cRecording *Recording = Recordings->First(); Recording; Recording = Recordings->Next(Recording)) {
845 cString Folder = Recording->Folder();
846 strreplace((char *)*Folder, FOLDERDELIMCHAR, FOLDERDELIMCHARSUBST); // makes sure parent folders come before subfolders
847 if (Dirs.Find(Folder) < 0)
848 Dirs.Append(strdup(Folder));
849 }
850 Dirs.Sort();
851 for (int i = 0; i < Dirs.Size(); i++) {
852 if (char *s = Dirs[i])
853 AddRecordingFolders(Recordings, &Folders, s);
854 }
855 }
856}
857
858void cMenuFolder::Set(const char *CurrentFolder)
859{
860 static cStateKey RecordingsStateKey;
861 if (list == &Folders) {
862 if (const cRecordings *Recordings = cRecordings::GetRecordingsRead(RecordingsStateKey)) {
863 AddRecordingFolders(Recordings, &Folders, NULL);
864 RecordingsStateKey.Remove();
865 }
866 }
867 firstFolder = NULL;
868 Clear();
869 if (!isempty(dir)) {
870 cOsdItem *DirItem = new cOsdItem(dir);
871 DirItem->SetSelectable(false);
872 Add(DirItem);
873 }
874 list->Sort();
875 for (cNestedItem *Folder = list->First(); Folder; Folder = list->Next(Folder)) {
876 cOsdItem *FolderItem = new cMenuFolderItem(Folder);
877 Add(FolderItem, CurrentFolder ? strcmp(Folder->Text(), CurrentFolder) == 0 : false);
878 if (!firstFolder)
879 firstFolder = FolderItem;
880 }
881}
882
883void cMenuFolder::DescendPath(const char *Path)
884{
885 if (Path) {
886 const char *p = strchr(Path, FOLDERDELIMCHAR);
887 if (p) {
888 for (cMenuFolderItem *Folder = (cMenuFolderItem *)firstFolder; Folder; Folder = (cMenuFolderItem *)Next(Folder)) {
889 if (strncmp(Folder->Folder()->Text(), Path, p - Path) == 0) {
890 SetCurrent(Folder);
891 if (Folder->Folder()->SubItems() && strchr(p + 1, FOLDERDELIMCHAR))
892 AddSubMenu(new cMenuFolder(Title(), Folder->Folder()->SubItems(), nestedItemList, !isempty(dir) ? *cString::sprintf("%s%c%s", *dir, FOLDERDELIMCHAR, Folder->Folder()->Text()) : Folder->Folder()->Text(), p + 1));
893 break;
894 }
895 }
896 }
897 }
898}
899
901{
902 if (firstFolder) {
904 if (Folder) {
905 if (Open) {
906 Folder->Folder()->SetSubItems(true);
907 return AddSubMenu(new cMenuFolder(Title(), Folder->Folder()->SubItems(), nestedItemList, !isempty(dir) ? *cString::sprintf("%s%c%s", *dir, FOLDERDELIMCHAR, Folder->Folder()->Text()) : Folder->Folder()->Text()));
908 }
909 else
910 return osEnd;
911 }
912 }
913 return osContinue;
914}
915
917{
918 editing = true;
919 return AddSubMenu(new cMenuEditFolder(dir, list));
920}
921
923{
924 if (!HasSubMenu() && firstFolder) {
926 if (Folder && Interface->Confirm(Folder->Folder()->SubItems() ? tr("Delete folder and all sub folders?") : tr("Delete folder?"))) {
927 list->Del(Folder->Folder());
928 Del(Folder->Index());
929 firstFolder = Get(isempty(dir) ? 0 : 1);
930 Display();
931 SetHelpKeys();
932 nestedItemList->Save();
933 }
934 }
935 return osContinue;
936}
937
939{
940 if (!HasSubMenu() && firstFolder) {
942 if (Folder) {
943 editing = true;
944 return AddSubMenu(new cMenuEditFolder(dir, list, Folder->Folder()));
945 }
946 }
947 return osContinue;
948}
949
951{
952 if (cMenuEditFolder *mef = dynamic_cast<cMenuEditFolder *>(SubMenu())) {
953 Set(mef->GetFolder());
954 SetHelpKeys();
955 Display();
956 nestedItemList->Save();
957 }
958 return CloseSubMenu();
959}
960
962{
963 if (firstFolder) {
965 if (Folder) {
966 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu()))
967 return cString::sprintf("%s%c%s", Folder->Folder()->Text(), FOLDERDELIMCHAR, *mf->GetFolder());
968 return Folder->Folder()->Text();
969 }
970 }
971 return "";
972}
973
975{
976 if (!HasSubMenu())
977 editing = false;
978 eOSState state = cOsdMenu::ProcessKey(Key);
979
980 if (state == osUnknown) {
981 switch (Key) {
982 case kOk: return Select(false);
983 case kRed: return Select(true);
984 case kGreen: return New();
985 case kYellow: return Delete();
986 case kBlue: return Edit();
987 default: state = osContinue;
988 }
989 }
990 else if (state == osEnd && HasSubMenu() && editing)
991 state = SetFolder();
992 SetHelpKeys();
993 return state;
994}
995
996// --- cMenuEditTimer --------------------------------------------------------
997
998static const char *TimerFileMacrosForPattern[] = {
1004 "",
1005 NULL
1006 };
1007
1008static const char *TimerFileMacros[] = {
1011 "",
1012 NULL
1013 };
1014
1016
1018:cOsdMenu(tr("Edit timer"), 12)
1019{
1021 addedTimer = NULL;
1022 pattern = NULL;
1023 file = NULL;
1024 day = firstday = NULL;
1025 timer = Timer;
1026 addIfConfirmed = New;
1027 if (timer) {
1028 data = *timer;
1029 if (New)
1030 data.SetFlags(tfActive);
1031 channel = data.Channel()->Number();
1032 Add(new cMenuEditBitItem( tr("Active"), &data.flags, tfActive));
1033 Add(new cMenuEditChanItem(tr("Channel"), &channel));
1034 Add(day = new cMenuEditDateItem(tr("Day"), &data.day, &data.weekdays));
1035 Add(new cMenuEditTimeItem(tr("Start"), &data.start));
1036 Add(new cMenuEditTimeItem(tr("Stop"), &data.stop));
1037 Add(new cMenuEditBitItem( tr("VPS"), &data.flags, tfVps));
1038 Add(new cMenuEditIntItem( tr("Priority"), &data.priority, 0, MAXPRIORITY));
1039 Add(new cMenuEditIntItem( tr("Lifetime"), &data.lifetime, 0, MAXLIFETIME));
1040 Add(file = new cMenuEditStrItem( tr("File"), data.file, sizeof(data.file)));
1042 SetPatternItem(true);
1043 if (data.remote)
1044 strn0cpy(remote, data.remote, sizeof(remote));
1045 else
1046 *remote = 0;
1048 svdrpServerNames.Sort(true);
1049 svdrpServerNames.Insert(strdup(""));
1050 Add(new cMenuEditStrlItem(tr("Record on"), remote, sizeof(remote), &svdrpServerNames));
1051 }
1052 }
1053 SetHelpKeys();
1054}
1055
1057{
1058 if (timer && addIfConfirmed)
1059 delete timer; // apparently it wasn't confirmed
1060}
1061
1063{
1064 const cTimer *Timer = addedTimer;
1065 addedTimer = NULL;
1066 return Timer;
1067}
1068
1070{
1071 SetHelp(tr("Button$Folder"), data.weekdays ? tr("Button$Single") : tr("Button$Repeating"), *data.pattern ? tr("Button$Regular") : tr("Button$Pattern"));
1072}
1073
1075{
1076 if (!firstday && !data.IsSingleEvent()) {
1077 Add(firstday = new cMenuEditDateItem(tr("First day"), &data.day));
1078 Display();
1079 }
1080 else if (firstday && data.IsSingleEvent()) {
1081 Del(firstday->Index());
1082 firstday = NULL;
1083 Display();
1084 }
1085}
1086
1088{
1089 if (Initial && !*data.pattern) {
1090 file->SetMacros(TimerFileMacros);
1091 return;
1092 }
1093 if (!pattern) {
1094 if (data.HasFlags(tfRecording)) {
1095 Skins.Message(mtWarning, tr("Timer is recording!"));
1096 return;
1097 }
1098 if (!*data.pattern) {
1099 char *p = strgetlast(data.file, FOLDERDELIMCHAR);
1100 strn0cpy(data.pattern, p, sizeof(data.pattern));
1101 }
1102 Ins(pattern = new cMenuEditStrItem( tr("Pattern"), data.pattern, sizeof(data.pattern)), true, file);
1103 pattern->SetKeepSpace();
1104 file->SetMacros(TimerFileMacrosForPattern);
1105 Display();
1106 }
1107 else {
1108 Del(pattern->Index());
1109 pattern = NULL;
1110 *data.pattern = 0;
1111 file->SetMacros(TimerFileMacros);
1112 Display();
1113 }
1114 SetHelpKeys();
1115}
1116
1118{
1119 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu())) {
1120 cString Folder = mf->GetFolder();
1121 char *p = strgetlast(data.file, FOLDERDELIMCHAR);
1122 if (!isempty(*Folder))
1123 strn0cpy(data.file, cString::sprintf("%s%c%s", *Folder, FOLDERDELIMCHAR, p), sizeof(data.file));
1124 else if (p != data.file)
1125 memmove(data.file, p, strlen(p) + 1);
1127 Display();
1128 }
1129 return CloseSubMenu();
1130}
1131
1132static bool RemoteTimerError(const cTimer *Timer)
1133{
1134 Skins.Message(mtError, cString::sprintf("%s %d@%s!", tr("Error while accessing remote timer"), Timer->Id(), Timer->Remote()));
1135 return false; // convenience return code
1136}
1137
1138static bool HandleRemoteModifications(cTimer *NewTimer, cTimer *OldTimer = NULL)
1139{
1140 cString ErrorMessage;
1141 if (!HandleRemoteTimerModifications(NewTimer, OldTimer, &ErrorMessage)) {
1142 Skins.QueueMessage(mtError, ErrorMessage);
1143 return false;
1144 }
1145 return true;
1146}
1147
1149{
1150 eOSState state = cOsdMenu::ProcessKey(Key);
1151
1152 if (state == osUnknown) {
1153 switch (Key) {
1154 case kOk: if (timer) {
1156 if (!addIfConfirmed && !Timers->Contains(timer)) {
1157 if (cTimer *t = Timers->GetById(timer->Id(), timer->Remote()))
1158 timer = t;
1159 else {
1160 Skins.Message(mtWarning, tr("Timer has been deleted!"));
1161 break;
1162 }
1163 }
1165 if (const cChannel *Channel = Channels->GetByNumber(channel))
1166 data.channel = Channel;
1167 else {
1168 Skins.Message(mtError, tr("*** Invalid Channel ***"));
1169 break;
1170 }
1171 if (!*data.file)
1172 strcpy(data.file, data.Channel()->ShortName(true));
1173 data.SetRemote(*remote ? remote : NULL);
1174 if (addIfConfirmed) {
1175 *timer = data;
1176 Timers->Add(timer);
1177 addedTimer = timer;
1179 // must add the timer before HandleRemoteModifications to get proper log messages with timer ids
1180 Timers->Del(timer, false);
1181 addedTimer = NULL;
1182 return osContinue;
1183 }
1184 }
1185 else {
1187 return osContinue;
1188 if (timer->Local() && timer->Recording() && data.Remote())
1190 if (timer->Remote() && data.Remote())
1191 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
1192 if (data.Local() && !timer->IsPatternTimer() && data.IsPatternTimer())
1193 data.SetEvent(NULL);
1194 *timer = data;
1195 }
1196 timer->TriggerRespawn();
1198 timer->SetEventFromSchedule(Schedules);
1199 timer->Matches();
1200 addIfConfirmed = false;
1201 }
1202 return osBack;
1203 case kRed: return AddSubMenu(new cMenuFolder(tr("Select folder"), &Folders, data.file));
1204 case kGreen: if (day) {
1205 day->ToggleRepeating();
1206 SetCurrent(day);
1208 SetHelpKeys();
1209 Display();
1210 }
1211 return osContinue;
1212 case kYellow: SetPatternItem();
1213 return osContinue;
1214 case kBlue: return osContinue;
1215 default: break;
1216 }
1217 }
1218 else if (state == osEnd && HasSubMenu())
1219 state = SetFolder();
1220 if (Key != kNone)
1222 return state;
1223}
1224
1225// --- cMenuTimerItem --------------------------------------------------------
1226
1227class cMenuTimerItem : public cOsdItem {
1228private:
1230public:
1231 cMenuTimerItem(const cTimer *Timer);
1232 virtual int Compare(const cListObject &ListObject) const override;
1233 virtual void Set(void) override;
1234 const cTimer *Timer(void) { return timer; }
1235 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
1236 };
1237
1239{
1240 timer = Timer;
1241 Set();
1242}
1243
1244int cMenuTimerItem::Compare(const cListObject &ListObject) const
1245{
1246 return timer->Compare(*((cMenuTimerItem *)&ListObject)->timer);
1247}
1248
1250{
1251 cString day, name("");
1252 if (timer->WeekDays())
1253 day = timer->PrintDay(0, timer->WeekDays(), false);
1254 else if (timer->Day() - time(NULL) < 28 * SECSINDAY) {
1255 day = itoa(timer->GetMDay(timer->Day()));
1256 name = WeekDayName(timer->Day());
1257 }
1258 else {
1259 struct tm tm_r;
1260 time_t Day = timer->Day();
1261 localtime_r(&Day, &tm_r);
1262 char buffer[16];
1263 strftime(buffer, sizeof(buffer), "%Y%m%d", &tm_r);
1264 day = buffer;
1265 }
1266 const char *File = timer->Pattern();
1267 if (!*File) {
1269 if (timer->HasFlags(tfSpawned) && timer->Event() && timer->Event()->Title())
1270 File = timer->Event()->Title();
1271 else {
1272 File = Setup.FoldersInTimerMenu ? NULL : strrchr(timer->File(), FOLDERDELIMCHAR);
1273 if (File && strcmp(File + 1, TIMERMACRO_TITLE) && strcmp(File + 1, TIMERMACRO_EPISODE))
1274 File++;
1275 else
1276 File = timer->File();
1277 }
1278 }
1279 SetText(cString::sprintf("%c\t%d\t%s%s%s\t%02d:%02d\t%02d:%02d\t%s%s%s%s",
1280 !(timer->HasFlags(tfActive)) ? ' ' : timer->FirstDay() ? '!' : timer->Recording() ? '#' : '>',
1281 timer->Channel()->Number(),
1282 *name,
1283 *name && **name ? " " : "",
1284 *day,
1285 timer->Start() / 100,
1286 timer->Start() % 100,
1287 timer->Stop() / 100,
1288 timer->Stop() % 100,
1289 timer->Remote() ? *cString::sprintf("@%s: ", timer->Remote()) : "",
1290 timer->IsPatternTimer() ? "{" : "",
1291 File,
1292 timer->IsPatternTimer() ? "}" : ""));
1293}
1294
1295void cMenuTimerItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
1296{
1298 if (!DisplayMenu->SetItemTimer(timer, Index, Current, Selectable))
1299 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
1300}
1301
1302// --- cMenuTimers -----------------------------------------------------------
1303
1304class cMenuTimers : public cOsdMenu {
1305private:
1308 void Set(void);
1309 eOSState Edit(void);
1310 eOSState New(void);
1311 eOSState Delete(void);
1312 eOSState OnOff(void);
1313 eOSState Info(void);
1314 cTimer *GetTimer(void);
1315 void SetHelpKeys(void);
1316public:
1317 cMenuTimers(void);
1318 virtual ~cMenuTimers() override;
1319 virtual eOSState ProcessKey(eKeys Key) override;
1320 };
1321
1323:cOsdMenu(tr("Timers"), 2, CHNUMWIDTH, 10, 6, 6)
1324{
1326 helpKeys = -1;
1327 cMenuEditTimer::AddedTimer(); // to clear any leftovers
1328 Set();
1329}
1330
1334
1336{
1337 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
1338 const cTimer *CurrentTimer = GetTimer();
1339 cMenuTimerItem *CurrentItem = NULL;
1340 Clear();
1341 {
1343 for (const cTimer *Timer = Timers->First(); Timer; Timer = Timers->Next(Timer)) {
1344 cMenuTimerItem *Item = new cMenuTimerItem(Timer);
1345 Add(Item);
1346 if (CurrentTimer && Timer->Id() == CurrentTimer->Id() && (!Timer->Remote() && !CurrentTimer->Remote() || Timer->Remote() && CurrentTimer->Remote() && strcmp(Timer->Remote(), CurrentTimer->Remote()) == 0))
1347 CurrentItem = Item;
1348 }
1349 }
1350 Sort();
1351 SetCurrent(CurrentItem ? CurrentItem : First());
1352 SetHelpKeys();
1353 Display();
1354 timersStateKey.Remove();
1355 }
1356}
1357
1359{
1361 return item ? (cTimer *)item->Timer() : NULL;
1362}
1363
1365{
1366 int NewHelpKeys = 0;
1367 if (const cTimer *Timer = GetTimer()) {
1368 if (Timer->Event())
1369 NewHelpKeys = 2;
1370 else
1371 NewHelpKeys = 1;
1372 }
1373 if (NewHelpKeys != helpKeys) {
1374 helpKeys = NewHelpKeys;
1375 SetHelp(helpKeys > 0 ? tr("Button$On/Off") : NULL, tr("Button$New"), helpKeys > 0 ? tr("Button$Delete") : NULL, helpKeys == 2 ? tr("Button$Info") : NULL);
1376 }
1377}
1378
1380{
1381 if (HasSubMenu())
1382 return osContinue;
1383 cStateKey StateKey;
1384 cTimers *Timers = cTimers::GetTimersWrite(StateKey);
1385 cTimer *Timer = GetTimer();
1386 if (Timer) {
1387 Timer->OnOff();
1388 if (Timer->Remote()) {
1390 cStringList Response;
1391 if (!ExecSVDRPCommand(Timer->Remote(), cString::sprintf("MODT %d %s", Timer->Id(), *Timer->ToText(true)), &Response) || SVDRPCode(Response[0]) != 250)
1392 RemoteTimerError(Timer);
1393 }
1394 {
1396 Timer->SetEventFromSchedule(Schedules);
1397 }
1399 DisplayCurrent(true);
1400 if (Timer->FirstDay())
1401 isyslog("set first day of timer %s to %s", *Timer->ToDescr(), *Timer->PrintFirstDay());
1402 else
1403 isyslog("%sactivated timer %s", Timer->HasFlags(tfActive) ? "" : "de", *Timer->ToDescr());
1404 }
1405 StateKey.Remove(Timer != NULL);
1406 return osContinue;
1407}
1408
1410{
1411 if (HasSubMenu() || Count() == 0)
1412 return osContinue;
1413 return AddSubMenu(new cMenuEditTimer(GetTimer()));
1414}
1415
1417{
1418 if (HasSubMenu())
1419 return osContinue;
1420 cTimer *Timer = new cTimer;
1421 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
1422 Timer->SetRemote(Setup.SVDRPDefaultHost);
1423 return AddSubMenu(new cMenuEditTimer(Timer, true));
1424}
1425
1427{
1429 // Check if this timer is active:
1430 cTimer *Timer = GetTimer();
1431 if (Timer) {
1432 bool TimerRecording = Timer->Recording();
1433 timersStateKey.Remove(false); // must release lock while prompting!
1434 if (Interface->Confirm(tr("Delete timer?")) && (!TimerRecording || Interface->Confirm(tr("Timer still recording - really delete?")))) {
1436 Timer = GetTimer();
1437 if (Timer) {
1438 if (!Timer->Remote()) {
1439 Timer->Skip();
1440 cRecordControls::Process(Timers, time(NULL));
1441 }
1442 if (HandleRemoteModifications(NULL, Timer)) {
1443 if (Timer->Remote())
1445 Timers->Del(Timer);
1447 Display();
1448 }
1449 }
1450 }
1451 else
1452 return osContinue;
1453 }
1454 timersStateKey.Remove(Timer != NULL);
1455 return osContinue;
1456}
1457
1459{
1460 if (HasSubMenu() || Count() == 0)
1461 return osContinue;
1465 cTimer *Timer = GetTimer();
1466 if (Timer && Timer->Event())
1467 return AddSubMenu(new cMenuEvent(Timers, Channels, Timer->Event()));
1468 return osContinue;
1469}
1470
1472{
1473 if (!HasSubMenu())
1474 Set();
1475 eOSState state = cOsdMenu::ProcessKey(Key);
1476 if (state == osUnknown) {
1477 switch (Key) {
1478 case kOk: return Edit();
1479 case kRed: state = OnOff(); break; // must go through SetHelpKeys()!
1480 case kGreen: return New();
1481 case kYellow: state = Delete(); break;
1482 case kInfo:
1483 case kBlue: return Info();
1484 break;
1485 default: break;
1486 }
1487 }
1488 if (const cTimer *Timer = cMenuEditTimer::AddedTimer()) {
1489 // a newly created timer was confirmed with Ok and the proper item needs to be added:
1491 cMenuTimerItem *CurrentItem = new cMenuTimerItem(Timer);
1492 Add(CurrentItem, true);
1493 Sort();
1494 SetCurrent(CurrentItem);
1495 SetHelpKeys();
1496 Display();
1497 }
1498 if (Key != kNone)
1499 SetHelpKeys();
1500 return state;
1501}
1502
1503// --- cMenuEvent ------------------------------------------------------------
1504
1505cMenuEvent::cMenuEvent(const cTimers *Timers, const cChannels *Channels, const cEvent *Event, bool CanSwitch, bool Buttons)
1506:cOsdMenu(tr("Event"))
1507{
1509 event = Event;
1510 if (event) {
1511 if (const cChannel *Channel = Channels->GetByChannelID(event->ChannelID(), true)) {
1512 SetTitle(Channel->Name());
1513 if (Buttons) {
1514 eTimerMatch TimerMatch = tmNone;
1515 Timers->GetMatch(event, &TimerMatch);
1516 SetHelp(TimerMatch == tmFull ? tr("Button$Timer") : tr("Button$Record"), NULL, NULL, CanSwitch ? tr("Button$Switch") : NULL);
1517 }
1518 }
1519 }
1520}
1521
1523{
1527 if (event->Description())
1528 cStatus::MsgOsdTextItem(event->Description());
1529}
1530
1532{
1533 switch (int(Key)) {
1534 case kUp|k_Repeat:
1535 case kUp:
1536 case kDown|k_Repeat:
1537 case kDown:
1538 case kLeft|k_Repeat:
1539 case kLeft:
1540 case kRight|k_Repeat:
1541 case kRight:
1542 DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight);
1543 cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft);
1544 return osContinue;
1545 case kInfo: return osBack;
1546 default: break;
1547 }
1548
1549 eOSState state = cOsdMenu::ProcessKey(Key);
1550
1551 if (state == osUnknown) {
1552 switch (Key) {
1553 case kGreen:
1554 case kYellow: return osContinue;
1555 case kOk: return osBack;
1556 default: break;
1557 }
1558 }
1559 return state;
1560}
1561
1562// --- cMenuScheduleItem -----------------------------------------------------
1563
1565public:
1566 enum eScheduleSortMode { ssmAllThis, ssmThisThis, ssmThisAll, ssmAllAll }; // "which event(s) on which channel(s)"
1567private:
1569public:
1576 cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel = NULL, bool WithDate = false);
1579 static eScheduleSortMode SortMode(void) { return sortMode; }
1580 virtual int Compare(const cListObject &ListObject) const override;
1581 bool Update(const cTimers *Timers, bool Force = false);
1582 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
1583 };
1584
1586
1587cMenuScheduleItem::cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel, bool WithDate)
1588{
1589 event = Event;
1590 channel = Channel;
1591 timer = NULL;
1592 withDate = WithDate;
1594 timerActive = false;
1595 Update(Timers, true);
1596}
1597
1598int cMenuScheduleItem::Compare(const cListObject &ListObject) const
1599{
1600 cMenuScheduleItem *p = (cMenuScheduleItem *)&ListObject;
1601 int r = -1;
1602 if (sortMode != ssmAllThis)
1603 r = strcoll(event->Title(), p->event->Title());
1604 if (sortMode == ssmAllThis || r == 0)
1605 r = event->StartTime() - p->event->StartTime();
1606 return r;
1607}
1608
1609static const char *TimerMatchChars = " tT iI";
1610
1611bool cMenuScheduleItem::Update(const cTimers *Timers, bool Force)
1612{
1615 eTimerMatch OldTimerMatch = timerMatch;
1616 bool OldTimerActive = timerActive;
1617 if (event->Schedule() && event->Schedule()->HasTimer())
1618 timer = Timers->GetMatch(event, &timerMatch);
1619 if (event->EndTime() < time(NULL) && !event->IsRunning() && (!timer || !timer->Recording()))
1621 timerActive = timer && timer->HasFlags(tfActive);
1622 if (Force || timerMatch != OldTimerMatch || timerActive != OldTimerActive) {
1623 cString buffer;
1624 char t = TimerMatchChars[timerMatch + (timerActive ? 0 : 3)];
1625 char v = event->Vps() && (event->Vps() - event->StartTime()) ? 'V' : ' ';
1626 char r = event->SeenWithin(30) && event->IsRunning() ? '*' : ' ';
1627 const char *csn = channel ? channel->ShortName(true) : NULL;
1628 cString eds = event->GetDateString();
1629 if (channel && withDate)
1630 buffer = cString::sprintf("%d\t%.*s\t%.*s\t%s\t%c%c%c\t%s", channel->Number(), Utf8SymChars(csn, 999), csn, Utf8SymChars(eds, 6), *eds, *event->GetTimeString(), t, v, r, event->Title());
1631 else if (channel)
1632 buffer = cString::sprintf("%d\t%.*s\t%s\t%c%c%c\t%s", channel->Number(), Utf8SymChars(csn, 999), csn, *event->GetTimeString(), t, v, r, event->Title());
1633 else
1634 buffer = cString::sprintf("%.*s\t%s\t%c%c%c\t%s", Utf8SymChars(eds, 6), *eds, *event->GetTimeString(), t, v, r, event->Title());
1635 SetText(buffer);
1636 return true;
1637 }
1638 return false;
1639}
1640
1641void cMenuScheduleItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
1642{
1646 if (!DisplayMenu->SetItemEvent(event, Index, Current, Selectable, channel, withDate, timerMatch, timer))
1647 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
1648}
1649
1650// --- cMenuWhatsOn ----------------------------------------------------------
1651
1652class cMenuWhatsOn : public cOsdMenu {
1653private:
1654 bool now;
1658 eOSState Record(void);
1659 eOSState Switch(void);
1660 static int currentChannel;
1661 static const cEvent *scheduleEvent;
1662 bool Update(void);
1663 void SetHelpKeys(const cChannels *Channels);
1664public:
1665 cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr);
1666 static int CurrentChannel(void) { return currentChannel; }
1667 static void SetCurrentChannel(int ChannelNr) { currentChannel = ChannelNr; }
1668 static const cEvent *ScheduleEvent(void);
1669 virtual eOSState ProcessKey(eKeys Key) override;
1670 };
1671
1674
1675cMenuWhatsOn::cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr)
1676:cOsdMenu(Now ? tr("What's on now?") : tr("What's on next?"), CHNUMWIDTH, CHNAMWIDTH, 6, 4)
1677{
1679 now = Now;
1680 canSwitch = false;
1681 helpKeys = 0;
1682 for (const cChannel *Channel = Channels->First(); Channel; Channel = Channels->Next(Channel)) {
1683 if (!Channel->GroupSep()) {
1684 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1685 if (const cEvent *Event = Now ? Schedule->GetPresentEvent() : Schedule->GetFollowingEvent())
1686 Add(new cMenuScheduleItem(Timers, Event, Channel), Channel->Number() == CurrentChannelNr);
1687 }
1688 }
1689 }
1690 currentChannel = CurrentChannelNr;
1691 SetHelpKeys(Channels);
1692}
1693
1695{
1696 bool result = false;
1697 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
1698 for (cOsdItem *item = First(); item; item = Next(item)) {
1699 if (((cMenuScheduleItem *)item)->Update(Timers))
1700 result = true;
1701 }
1702 timersStateKey.Remove();
1703 }
1704 return result;
1705}
1706
1708{
1710 canSwitch = false;
1711 int NewHelpKeys = 0;
1712 if (item) {
1713 if (item->timerMatch == tmFull)
1714 NewHelpKeys |= 0x02; // "Timer"
1715 else
1716 NewHelpKeys |= 0x01; // "Record"
1717 if (now)
1718 NewHelpKeys |= 0x04; // "Next"
1719 else
1720 NewHelpKeys |= 0x08; // "Now"
1721 if (const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) {
1722 if (Channel->Number() != cDevice::CurrentChannel()) {
1723 NewHelpKeys |= 0x10; // "Switch"
1724 canSwitch = true;
1725 }
1726 }
1727 }
1728 if (NewHelpKeys != helpKeys) {
1729 const char *Red[] = { NULL, tr("Button$Record"), tr("Button$Timer") };
1730 SetHelp(Red[NewHelpKeys & 0x03], now ? tr("Button$Next") : tr("Button$Now"), tr("Button$Schedule"), canSwitch ? tr("Button$Switch") : NULL);
1731 helpKeys = NewHelpKeys;
1732 }
1733}
1734
1736{
1737 const cEvent *ei = scheduleEvent;
1738 scheduleEvent = NULL;
1739 return ei;
1740}
1741
1743{
1745 if (item) {
1747 const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true);
1748 if (Channel) {
1749 if (!cDevice::PrimaryDevice()->SwitchChannel(Channel, true))
1750 Channel = NULL;
1751 }
1752 if (Channel)
1753 return osEnd;
1754 }
1755 Skins.Message(mtError, tr("Can't switch channel!"));
1756 return osContinue;
1757}
1758
1760{
1761 if (cMenuScheduleItem *item = (cMenuScheduleItem *)Get(Current())) {
1765 Timers->SetExplicitModify();
1766 if (item->timerMatch == tmFull) {
1767 if (cTimer *Timer = Timers->GetMatch(item->event))
1768 return AddSubMenu(new cMenuEditTimer(Timer));
1769 }
1770 cTimer *Timer = new cTimer(item->event);
1771 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
1772 Timer->SetRemote(Setup.SVDRPDefaultHost);
1773 if (cTimer *t = Timers->GetTimer(Timer)) {
1774 delete Timer;
1775 Timer = t;
1776 return AddSubMenu(new cMenuEditTimer(Timer));
1777 }
1778 if (Timer->Matches(0, false, NEWTIMERLIMIT))
1779 return AddSubMenu(new cMenuEditTimer(Timer, true));
1780 Timers->Add(Timer);
1781 Timers->SetModified();
1782 if (!HandleRemoteModifications(Timer)) {
1783 // must add the timer before HandleRemoteModifications to get proper log messages with timer ids
1784 Timers->Del(Timer);
1785 }
1786 else if (Timer->Remote())
1787 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
1788 if (HasSubMenu())
1789 CloseSubMenu();
1790 }
1791 if (Update())
1792 Display();
1794 SetHelpKeys(Channels);
1795 return osContinue;
1796}
1797
1799{
1800 bool HadSubMenu = HasSubMenu();
1801 eOSState state = cOsdMenu::ProcessKey(Key);
1802
1803 if (state == osUnknown) {
1804 switch (int(Key)) {
1805 case kRecord:
1806 case kRed: return Record();
1807 case kYellow: state = osBack;
1808 // continue with kGreen
1809 case kGreen: {
1811 if (mi) {
1813 scheduleEvent = mi->event;
1814 currentChannel = mi->channel->Number();
1815 }
1816 }
1817 break;
1818 case kBlue: if (canSwitch)
1819 return Switch();
1820 break;
1821 case kChanUp|k_Repeat:
1822 case kChanUp:
1823 case kChanDn|k_Repeat:
1824 case kChanDn: if (!HasSubMenu()) {
1827 for (cOsdItem *item = First(); item; item = Next(item)) {
1828 if (((cMenuScheduleItem *)item)->channel->Number() == cDevice::CurrentChannel()) {
1829 DisplayCurrent(false);
1830 SetCurrent(item);
1831 DisplayCurrent(true);
1832 SetHelpKeys(Channels);
1833 break;
1834 }
1835 }
1836 }
1837 break;
1838 case kInfo:
1839 case kOk: if (Count()) {
1842 return AddSubMenu(new cMenuEvent(Timers, Channels, ((cMenuScheduleItem *)Get(Current()))->event, canSwitch, true));
1843 }
1844 break;
1845 default: break;
1846 }
1847 }
1848 else if (!HasSubMenu()) {
1849 if (HadSubMenu && Update())
1850 Display();
1851 if (Key != kNone) {
1853 SetHelpKeys(Channels);
1854 }
1855 }
1856 return state;
1857}
1858
1859// --- cMenuSchedule ---------------------------------------------------------
1860
1861class cMenuSchedule : public cOsdMenu {
1862private:
1866 bool now, next;
1869 void Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel = NULL, bool Force = false);
1870 eOSState Number(void);
1871 eOSState Record(void);
1872 eOSState Switch(void);
1873 bool PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1874 bool PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1875 bool PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1876 bool PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1877 bool Update(void);
1878 void SetHelpKeys(void);
1879public:
1880 cMenuSchedule(void);
1881 virtual ~cMenuSchedule() override;
1882 virtual eOSState ProcessKey(eKeys Key) override;
1883 };
1884
1886:cOsdMenu(tr("Schedule"))
1887{
1889 scheduleState = -1;
1890 now = next = false;
1891 canSwitch = false;
1892 helpKeys = 0;
1897 Set(Timers, Channels, NULL, true);
1898}
1899
1901{
1902 cMenuWhatsOn::ScheduleEvent(); // makes sure any posted data is cleared
1903}
1904
1905void cMenuSchedule::Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel, bool Force)
1906{
1907 if (Force) {
1908 schedulesStateKey.Reset();
1909 scheduleState = -1;
1910 }
1912 cMenuScheduleItem *CurrentItem = (cMenuScheduleItem *)Get(Current());
1913 const cEvent *Event = NULL;
1914 if (!Channel) {
1915 if (CurrentItem) {
1916 Event = CurrentItem->event;
1917 Channel = Channels->GetByChannelID(Event->ChannelID(), true);
1918 }
1919 else
1920 Channel = Channels->GetByNumber(cDevice::CurrentChannel());
1921 }
1922 bool Refresh = false;
1923 switch (cMenuScheduleItem::SortMode()) {
1924 case cMenuScheduleItem::ssmAllThis: Refresh = PrepareScheduleAllThis(Timers, Schedules, Event, Channel); break;
1925 case cMenuScheduleItem::ssmThisThis: Refresh = PrepareScheduleThisThis(Timers, Schedules, Event, Channel); break;
1926 case cMenuScheduleItem::ssmThisAll: Refresh = Force && PrepareScheduleThisAll(Timers, Schedules, Event, Channel); break;
1927 case cMenuScheduleItem::ssmAllAll: Refresh = Force && PrepareScheduleAllAll(Timers, Schedules, Event, Channel); break;
1928 default: esyslog("ERROR: unknown SortMode %d (%s %d)", cMenuScheduleItem::SortMode(), __FUNCTION__, __LINE__);
1929 }
1930 if (Refresh) {
1931 CurrentItem = (cMenuScheduleItem *)Get(Current());
1932 Sort();
1933 SetCurrent(CurrentItem);
1934 SetHelpKeys();
1935 Display();
1936 }
1937 schedulesStateKey.Remove();
1938 }
1939}
1940
1941bool cMenuSchedule::PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1942{
1943 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1944 if (Schedule->Modified(scheduleState)) {
1945 Clear();
1946 SetCols(7, 6, 4);
1947 SetTitle(cString::sprintf(tr("Schedule - %s"), Channel->Name()));
1948 const cEvent *PresentEvent = Event ? Event : Schedule->GetPresentEvent();
1949 time_t now = time(NULL) - Setup.EPGLinger * 60;
1950 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
1951 if (ev->EndTime() > now || ev == PresentEvent)
1952 Add(new cMenuScheduleItem(Timers, ev), ev == PresentEvent);
1953 }
1954 return true;
1955 }
1956 }
1957 return false;
1958}
1959
1960bool cMenuSchedule::PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1961{
1962 if (Event) {
1963 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1964 if (Schedule->Modified(scheduleState)) {
1965 Clear();
1966 SetCols(7, 6, 4);
1967 SetTitle(cString::sprintf(tr("This event - %s"), Channel->Name()));
1968 time_t now = time(NULL) - Setup.EPGLinger * 60;
1969 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
1970 if ((ev->EndTime() > now || ev == Event) && !strcmp(ev->Title(), Event->Title()))
1971 Add(new cMenuScheduleItem(Timers, ev), ev == Event);
1972 }
1973 return true;
1974 }
1975 }
1976 }
1977 return false;
1978}
1979
1980bool cMenuSchedule::PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1981{
1982 Clear();
1983 SetCols(CHNUMWIDTH, CHNAMWIDTH, 7, 6, 4);
1984 SetTitle(tr("This event - all channels"));
1985 if (Event) {
1987 for (const cChannel *ch = Channels->First(); ch; ch = Channels->Next(ch)) {
1988 if (const cSchedule *Schedule = Schedules->GetSchedule(ch)) {
1989 time_t now = time(NULL) - Setup.EPGLinger * 60;
1990 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
1991 if ((ev->EndTime() > now || ev == Event) && !strcmp(ev->Title(), Event->Title()))
1992 Add(new cMenuScheduleItem(Timers, ev, ch, true), ev == Event && ch == Channel);
1993 }
1994 }
1995 }
1996 }
1997 return true;
1998}
1999
2000bool cMenuSchedule::PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
2001{
2002 Clear();
2003 SetCols(CHNUMWIDTH, CHNAMWIDTH, 7, 6, 4);
2004 SetTitle(tr("All events - all channels"));
2006 cStateKey StateKey;
2007 for (const cChannel *ch = Channels->First(); ch; ch = Channels->Next(ch)) {
2008 if (const cSchedule *Schedule = Schedules->GetSchedule(ch)) {
2009 time_t now = time(NULL) - Setup.EPGLinger * 60;
2010 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
2011 if (ev->EndTime() > now || ev == Event)
2012 Add(new cMenuScheduleItem(Timers, ev, ch, true), ev == Event && ch == Channel);
2013 }
2014 }
2015 }
2016 return true;
2017}
2018
2020{
2021 bool result = false;
2022 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
2023 for (cOsdItem *item = First(); item; item = Next(item)) {
2024 if (((cMenuScheduleItem *)item)->Update(Timers))
2025 result = true;
2026 }
2027 timersStateKey.Remove();
2028 }
2029 return result;
2030}
2031
2033{
2035 canSwitch = false;
2036 int NewHelpKeys = 0;
2037 if (item) {
2038 if (item->timerMatch == tmFull)
2039 NewHelpKeys |= 0x02; // "Timer"
2040 else
2041 NewHelpKeys |= 0x01; // "Record"
2043 if (const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) {
2044 if (Channel->Number() != cDevice::CurrentChannel()) {
2045 NewHelpKeys |= 0x10; // "Switch"
2046 canSwitch = true;
2047 }
2048 }
2049 }
2050 if (NewHelpKeys != helpKeys) {
2051 const char *Red[] = { NULL, tr("Button$Record"), tr("Button$Timer") };
2052 SetHelp(Red[NewHelpKeys & 0x03], tr("Button$Now"), tr("Button$Next"), canSwitch ? tr("Button$Switch") : NULL);
2053 helpKeys = NewHelpKeys;
2054 }
2055}
2056
2058{
2062 Set(Timers, Channels, NULL, true);
2063 return osContinue;
2064}
2065
2067{
2068 if (cMenuScheduleItem *item = (cMenuScheduleItem *)Get(Current())) {
2072 Timers->SetExplicitModify();
2073 if (item->timerMatch == tmFull) {
2074 if (cTimer *Timer = Timers->GetMatch(item->event))
2075 return AddSubMenu(new cMenuEditTimer(Timer));
2076 }
2077 cTimer *Timer = new cTimer(item->event);
2078 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
2079 Timer->SetRemote(Setup.SVDRPDefaultHost);
2080 if (cTimer *t = Timers->GetTimer(Timer)) {
2081 delete Timer;
2082 Timer = t;
2083 return AddSubMenu(new cMenuEditTimer(Timer));
2084 }
2085 if (Timer->Matches(0, false, NEWTIMERLIMIT))
2086 return AddSubMenu(new cMenuEditTimer(Timer, true));
2087 Timers->Add(Timer);
2088 Timers->SetModified();
2089 if (!HandleRemoteModifications(Timer)) {
2090 // must add the timer before HandleRemoteModifications to get proper log messages with timer ids
2091 Timers->Del(Timer);
2092 }
2093 else if (Timer->Remote())
2094 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
2095 if (HasSubMenu())
2096 CloseSubMenu();
2097 }
2098 if (Update())
2099 Display();
2100 SetHelpKeys();
2101 return osContinue;
2102}
2103
2105{
2107 if (item) {
2109 const cChannel *Channel = NULL;
2110 if ((Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) != NULL) {
2111 if (!Channels->SwitchTo(Channel->Number()))
2112 Channel = NULL;
2113 }
2114 if (Channel)
2115 return osEnd;
2116 }
2117 Skins.Message(mtError, tr("Can't switch channel!"));
2118 return osContinue;
2119}
2120
2122{
2123 if (!HasSubMenu()) {
2126 Set(Timers, Channels); // react on any changes to the schedules list
2127 }
2128 bool HadSubMenu = HasSubMenu();
2129 eOSState state = cOsdMenu::ProcessKey(Key);
2130
2131 if (state == osUnknown) {
2132 switch (int(Key)) {
2133 case k0: return Number();
2134 case kRecord:
2135 case kRed: return Record();
2136 case kGreen: {
2140 if (!now && !next) {
2141 int ChannelNr = 0;
2142 if (Count()) {
2143 if (const cChannel *Channel = Channels->GetByChannelID(((cMenuScheduleItem *)Get(Current()))->event->ChannelID(), true))
2144 ChannelNr = Channel->Number();
2145 }
2146 now = true;
2147 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, now, ChannelNr));
2148 }
2149 now = !now;
2150 next = !next;
2151 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, now, cMenuWhatsOn::CurrentChannel()));
2152 }
2153 case kYellow: {
2157 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, false, cMenuWhatsOn::CurrentChannel()));
2158 }
2159 case kBlue: if (canSwitch)
2160 return Switch();
2161 break;
2162 case kChanUp|k_Repeat:
2163 case kChanUp:
2164 case kChanDn|k_Repeat:
2165 case kChanDn: if (!HasSubMenu()) {
2168 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel()))
2169 Set(Timers, Channels, Channel, true);
2170 }
2171 break;
2172 case kInfo:
2173 case kOk: if (Count()) {
2177 return AddSubMenu(new cMenuEvent(Timers, Channels, ((cMenuScheduleItem *)Get(Current()))->event, canSwitch, true));
2178 }
2179 break;
2180 default: break;
2181 }
2182 }
2183 else if (!HasSubMenu()) {
2184 now = next = false;
2185 if (const cEvent *ei = cMenuWhatsOn::ScheduleEvent()) {
2188 if (const cChannel *Channel = Channels->GetByChannelID(ei->ChannelID(), true)) {
2190 Set(Timers, Channels, Channel, true);
2191 }
2192 }
2193 else if (HadSubMenu && Update())
2194 Display();
2195 if (Key != kNone)
2196 SetHelpKeys();
2197 }
2198 return state;
2199}
2200
2201// --- cMenuCommands ---------------------------------------------------------
2202
2205{
2207 result = NULL;
2208 SetHasHotkeys();
2210 parameters = Parameters;
2211 for (cNestedItem *Command = commands->First(); Command; Command = commands->Next(Command)) {
2212 const char *s = Command->Text();
2213 if (Command->SubItems())
2214 Add(new cOsdItem(hk(cString::sprintf("%s...", s))));
2215 else if (Parse(s))
2216 Add(new cOsdItem(hk(title)));
2217 }
2218}
2219
2221{
2222 free(result);
2223}
2224
2225bool cMenuCommands::Parse(const char *s)
2226{
2227 const char *p = strchr(s, ':');
2228 if (p) {
2229 int l = p - s;
2230 if (l > 0) {
2231 char t[l + 1];
2232 stripspace(strn0cpy(t, s, l + 1));
2233 l = strlen(t);
2234 if (l > 1 && t[l - 1] == '?') {
2235 t[l - 1] = 0;
2236 confirm = true;
2237 }
2238 else
2239 confirm = false;
2240 title = t;
2241 command = skipspace(p + 1);
2242 return true;
2243 }
2244 }
2245 return false;
2246}
2247
2249{
2250 cNestedItem *Command = commands->Get(Current());
2251 if (Command) {
2252 if (Command->SubItems())
2253 return AddSubMenu(new cMenuCommands(Title(), Command->SubItems(), parameters));
2254 if (Parse(Command->Text())) {
2255 if (!confirm || Interface->Confirm(cString::sprintf("%s?", *title))) {
2256 Skins.Message(mtStatus, cString::sprintf("%s...", *title));
2257 free(result);
2258 result = NULL;
2259 cString cmdbuf;
2260 if (!isempty(parameters))
2261 cmdbuf = cString::sprintf("%s %s", *command, *parameters);
2262 const char *cmd = *cmdbuf ? *cmdbuf : *command;
2263 dsyslog("executing command '%s'", cmd);
2264 cPipe p;
2265 if (p.Open(cmd, "r")) {
2266 int l = 0;
2267 int c;
2268 while ((c = fgetc(p)) != EOF) {
2269 if (l % 20 == 0) {
2270 if (char *NewBuffer = (char *)realloc(result, l + 21))
2271 result = NewBuffer;
2272 else {
2273 esyslog("ERROR: out of memory");
2274 break;
2275 }
2276 }
2277 result[l++] = char(c);
2278 }
2279 if (result)
2280 result[l] = 0;
2281 p.Close();
2282 }
2283 else
2284 esyslog("ERROR: can't open pipe for command '%s'", cmd);
2285 Skins.Message(mtStatus, NULL);
2286 if (result)
2287 return AddSubMenu(new cMenuText(title, result, fontFix));
2288 return osEnd;
2289 }
2290 }
2291 }
2292 return osContinue;
2293}
2294
2296{
2297 eOSState state = cOsdMenu::ProcessKey(Key);
2298
2299 if (state == osUnknown) {
2300 switch (Key) {
2301 case kRed:
2302 case kGreen:
2303 case kYellow:
2304 case kBlue: return osContinue;
2305 case kOk: return Execute();
2306 default: break;
2307 }
2308 }
2309 return state;
2310}
2311
2312// --- cMenuCam --------------------------------------------------------------
2313
2314static bool CamMenuIsOpen = false;
2315
2316class cMenuCam : public cOsdMenu {
2317private:
2321 char *input;
2324 void GenerateTitle(const char *s = NULL);
2325 void QueryCam(void);
2326 void AddMultiLineItem(const char *s);
2327 void Set(void);
2328 eOSState Select(void);
2329public:
2330 cMenuCam(cCamSlot *CamSlot);
2331 virtual ~cMenuCam() override;
2332 virtual eOSState ProcessKey(eKeys Key) override;
2333 };
2334
2336:cOsdMenu("", 1) // tab necessary for enquiry!
2337{
2339 camSlot = CamSlot;
2340 ciMenu = NULL;
2341 ciEnquiry = NULL;
2342 input = NULL;
2343 offset = 0;
2344 lastCamExchange = time(NULL);
2346 QueryCam();
2347 CamMenuIsOpen = true;
2348}
2349
2351{
2352 if (ciMenu)
2353 ciMenu->Abort();
2354 delete ciMenu;
2355 if (ciEnquiry)
2356 ciEnquiry->Abort();
2357 delete ciEnquiry;
2358 free(input);
2359 CamMenuIsOpen = false;
2360}
2361
2362void cMenuCam::GenerateTitle(const char *s)
2363{
2364 SetTitle(cString::sprintf("CAM %d - %s", camSlot->SlotNumber(), (s && *s) ? s : camSlot->GetCamName()));
2365}
2366
2368{
2369 delete ciMenu;
2370 ciMenu = NULL;
2371 delete ciEnquiry;
2372 ciEnquiry = NULL;
2373 if (camSlot->HasUserIO()) {
2374 ciMenu = camSlot->GetMenu();
2375 ciEnquiry = camSlot->GetEnquiry();
2376 }
2377 Set();
2378}
2379
2381{
2382 if (ciMenu) {
2383 Clear();
2384 free(input);
2385 input = NULL;
2386 dsyslog("CAM %d: Menu ------------------", camSlot->SlotNumber());
2387 offset = 0;
2388 SetHasHotkeys(ciMenu->Selectable());
2389 GenerateTitle(ciMenu->TitleText());
2390 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->TitleText());
2391 if (!isempty(ciMenu->SubTitleText())) {
2392 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->SubTitleText());
2393 AddMultiLineItem(ciMenu->SubTitleText());
2394 offset = Count();
2395 }
2396 for (int i = 0; i < ciMenu->NumEntries(); i++) {
2397 Add(new cOsdItem(hk(ciMenu->Entry(i)), osUnknown, ciMenu->Selectable()));
2398 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->Entry(i));
2399 }
2400 if (!isempty(ciMenu->BottomText())) {
2401 AddMultiLineItem(ciMenu->BottomText());
2402 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->BottomText());
2403 }
2405 }
2406 else if (ciEnquiry) {
2407 Clear();
2408 int Length = ciEnquiry->ExpectedLength();
2409 free(input);
2410 input = MALLOC(char, Length + 1);
2411 *input = 0;
2412 dsyslog("CAM %d: Enquiry ------------------", camSlot->SlotNumber());
2413 GenerateTitle();
2414 Add(new cOsdItem(ciEnquiry->Text(), osUnknown, false));
2415 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciEnquiry->Text());
2416 Add(new cOsdItem("", osUnknown, false));
2417 Add(new cMenuEditNumItem("", input, Length, ciEnquiry->Blind()));
2418 }
2419 Display();
2420}
2421
2423{
2424 while (s && *s) {
2425 const char *p = strchr(s, '\n');
2426 int l = p ? p - s : strlen(s);
2427 cOsdItem *item = new cOsdItem;
2428 item->SetSelectable(false);
2429 item->SetText(strndup(s, l), false);
2430 Add(item);
2431 s = p ? p + 1 : p;
2432 }
2433}
2434
2436{
2437 if (ciMenu) {
2438 if (ciMenu->Selectable()) {
2439 ciMenu->Select(Current() - offset);
2440 dsyslog("CAM %d: select %d", camSlot->SlotNumber(), Current() - offset);
2441 }
2442 else
2443 ciMenu->Cancel();
2444 }
2445 else if (ciEnquiry) {
2446 if (ciEnquiry->ExpectedLength() < 0xFF && int(strlen(input)) != ciEnquiry->ExpectedLength()) {
2447 char buffer[64];
2448 snprintf(buffer, sizeof(buffer), tr("Please enter %d digits!"), ciEnquiry->ExpectedLength());
2449 Skins.Message(mtError, buffer);
2450 return osContinue;
2451 }
2452 ciEnquiry->Reply(input);
2453 dsyslog("CAM %d: entered '%s'", camSlot->SlotNumber(), ciEnquiry->Blind() ? "****" : input);
2454 }
2455 QueryCam();
2456 return osContinue;
2457}
2458
2460{
2461 if (!camSlot->HasMMI())
2462 return osBack;
2463
2464 eOSState state = cOsdMenu::ProcessKey(Key);
2465
2466 if (ciMenu || ciEnquiry) {
2467 lastCamExchange = time(NULL);
2468 if (state == osUnknown) {
2469 switch (Key) {
2470 case kOk: return Select();
2471 default: break;
2472 }
2473 }
2474 else if (state == osBack) {
2475 if (ciMenu)
2476 ciMenu->Cancel();
2477 if (ciEnquiry)
2478 ciEnquiry->Cancel();
2479 QueryCam();
2480 return osContinue;
2481 }
2482 if (ciMenu && ciMenu->HasUpdate()) {
2483 QueryCam();
2484 return osContinue;
2485 }
2486 }
2487 else if (time(NULL) - lastCamExchange < CAMRESPONSETIMEOUT)
2488 QueryCam();
2489 else {
2490 Skins.Message(mtError, tr("CAM not responding!"));
2491 return osBack;
2492 }
2493 return state;
2494}
2495
2496// --- CamControl ------------------------------------------------------------
2497
2499{
2500 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
2501 if (CamSlot->HasUserIO())
2502 return new cMenuCam(CamSlot);
2503 }
2504 return NULL;
2505}
2506
2508{
2509 return CamMenuIsOpen;
2510}
2511
2512// --- cMenuPathEdit ---------------------------------------------------------
2513
2514#define osUserRecRenamed osUser1
2515#define osUserRecMoved osUser2
2516#define osUserRecRemoved osUser3
2517#define osUserRecEmpty osUser4
2518
2519class cMenuPathEdit : public cOsdMenu {
2520private:
2523 char folder[PATH_MAX];
2524 char name[NAME_MAX];
2527 eOSState SetFolder(void);
2528 eOSState Folder(void);
2529 eOSState ApplyChanges(void);
2530public:
2531 cMenuPathEdit(const char *Path);
2532 virtual eOSState ProcessKey(eKeys Key) override;
2533 };
2534
2536:cOsdMenu(tr("Edit path"), 12)
2537{
2539 path = Path;
2540 *folder = 0;
2541 *name = 0;
2542 const char *s = strrchr(path, FOLDERDELIMCHAR);
2543 if (s) {
2544 strn0cpy(folder, cString(path, s), sizeof(folder));
2545 s++;
2546 }
2547 else
2548 s = path;
2549 strn0cpy(name, s, sizeof(name));
2550 {
2552 pathIsInUse = Recordings->PathIsInUse(path);
2553 }
2554 oldFolder = folder;
2555 cOsdItem *p;
2556 Add(p = folderItem = new cMenuEditStrItem(tr("Folder"), folder, sizeof(folder)));
2558 Add(p = new cMenuEditStrItem(tr("Name"), name, sizeof(name)));
2560 if (*path) {
2561 int DirSize = 0;
2562 {
2564 for (const cRecording *Recording = Recordings->First(); Recording; Recording = Recordings->Next(Recording)) {
2565 if (Recording->IsInPath(path)) {
2566 int FileSizeMB = Recording->FileSizeMB();
2567 if (FileSizeMB > 0 )
2568 DirSize += FileSizeMB;
2569 }
2570 }
2571 }
2572 if (DirSize > 1023)
2573 Add(new cOsdItem(cString::sprintf("%s:\t%.2f GB", tr("Size"), DirSize / 1024.), osUnknown, false));
2574 else
2575 Add(new cOsdItem(cString::sprintf("%s:\t%d MB", tr("Size"), DirSize), osUnknown, false));
2576 }
2577 if (pathIsInUse) {
2578 Add(new cOsdItem("", osUnknown, false));
2579 Add(new cOsdItem(tr("This folder is currently in use - no changes are possible!"), osUnknown, false));
2580 }
2581 Display();
2582 if (!pathIsInUse)
2583 SetHelp(tr("Button$Folder"));
2584}
2585
2587{
2588 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu())) {
2589 strn0cpy(folder, mf->GetFolder(), sizeof(folder));
2591 Display();
2592 }
2593 return CloseSubMenu();
2594}
2595
2597{
2598 return AddSubMenu(new cMenuFolder(tr("Select folder"), &Folders, path));
2599}
2600
2602{
2603 if (!*name) {
2604 *name = ' '; // name must not be empty!
2605 name[1] = 0;
2606 }
2607 cString NewPath = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2609 if (strcmp(NewPath, path)) {
2610 int NumRecordings = 0;
2611 {
2613 NumRecordings = Recordings->GetNumRecordingsInPath(path);
2614 }
2615 if (NumRecordings > 1 && !Interface->Confirm(cString::sprintf(tr("Move entire folder containing %d recordings?"), NumRecordings)))
2616 return osContinue;
2617 bool Error = false;
2618 {
2620 Recordings->SetExplicitModify();
2621 Error = !Recordings->MoveRecordings(path, NewPath);
2622 if (!Error)
2623 Recordings->SetModified();
2624 }
2625 if (Error) {
2626 Skins.Message(mtError, tr("Error while moving folder!"));
2627 return osContinue;
2628 }
2629 if (strcmp(folder, oldFolder))
2630 return osUserRecMoved;
2631 return osUserRecRenamed;
2632 }
2633 return osBack;
2634}
2635
2637{
2638 eOSState state = cOsdMenu::ProcessKey(Key);
2639 if (state == osUnknown) {
2640 if (!pathIsInUse) {
2641 switch (Key) {
2642 case kRed: return Folder();
2643 case kOk: return ApplyChanges();
2644 default: break;
2645 }
2646 }
2647 else if (Key == kOk)
2648 return osBack;
2649 }
2650 else if (state == osEnd && HasSubMenu())
2651 state = SetFolder();
2652 return state;
2653}
2654
2655// --- cMenuRecordingEdit ----------------------------------------------------
2656
2658private:
2662 char folder[PATH_MAX];
2663 char name[NAME_MAX];
2668 const char *buttonFolder;
2669 const char *buttonAction;
2670 const char *buttonDelete;
2671 const char *actionCancel;
2672 const char *doCut;
2673 const char *doCopy;
2676 void Set(void);
2677 void SetHelpKeys(void);
2678 bool RefreshRecording(void);
2679 eOSState SetFolder(void);
2680 eOSState Folder(void);
2681 eOSState Action(void);
2682 eOSState RemoveName(void);
2683 eOSState Delete(void);
2684 eOSState ApplyChanges(void);
2685public:
2686 cMenuRecordingEdit(const cRecording *Recording);
2687 virtual eOSState ProcessKey(eKeys Key) override;
2688 };
2689
2691:cOsdMenu(tr("Edit recording"), 12)
2692{
2694 recording = Recording;
2695 originalFileName = recording->FileName();
2696 strn0cpy(folder, recording->Folder(), sizeof(folder));
2697 strn0cpy(name, recording->BaseName(), sizeof(name));
2698 priority = recording->Priority();
2699 lifetime = recording->Lifetime();
2700 folderItem = NULL;
2701 nameItem = NULL;
2702 buttonFolder = NULL;
2703 buttonAction = NULL;
2704 buttonDelete = NULL;
2705 actionCancel = NULL;
2706 doCut = NULL;
2707 doCopy = NULL;
2708 extraAction = false;
2710 Set();
2711}
2712
2714{
2715 int current = Current();
2716 Clear();
2717 recordingIsInUse = recording->IsInUse();
2718 cOsdItem *p;
2719 Add(p = folderItem = new cMenuEditStrItem(tr("Folder"), folder, sizeof(folder)));
2721 Add(p = nameItem = new cMenuEditStrItem(tr("Name"), name, sizeof(name)));
2723 Add(p = new cMenuEditIntItem(tr("Priority"), &priority, 0, MAXPRIORITY));
2725 Add(p = new cMenuEditIntItem(tr("Lifetime"), &lifetime, 0, MAXLIFETIME));
2727 if (recordingIsInUse) {
2728 Add(new cOsdItem("", osUnknown, false));
2729 Add(new cOsdItem(tr("This recording is currently in use - no changes are possible!"), osUnknown, false));
2730 }
2732 Display();
2733 SetHelpKeys();
2734}
2735
2737{
2738 buttonFolder = !recordingIsInUse ? tr("Button$Folder") : NULL;
2739 buttonAction = NULL;
2740 buttonDelete = NULL;
2741 actionCancel = NULL;
2742 doCut = NULL;
2743 doCopy = NULL;
2744 if ((recordingIsInUse & ruCut) != 0)
2745 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel cutting") : tr("Button$Stop cutting");
2746 else if ((recordingIsInUse & ruMove) != 0)
2747 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel moving") : tr("Button$Stop moving");
2748 else if ((recordingIsInUse & ruCopy) != 0)
2749 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel copying") : tr("Button$Stop copying");
2750 else if (extraAction) {
2751 cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording());
2752 buttonAction = doCopy = tr("Button$Copy");
2753 buttonDelete = (ResumeFile.Read() != -1) ? tr("Button$Delete resume") : NULL;
2754 }
2755 else if (recording->HasMarks()) {
2756 buttonAction = doCut = tr("Button$Cut");
2757 buttonDelete = tr("Button$Delete marks");
2758 }
2759 SetHelp(buttonFolder, buttonAction, buttonDelete, tr("Button$Toggle commands"));
2760}
2761
2763{
2765 if ((recording = Recordings->GetByName(originalFileName)) != NULL)
2766 Set();
2767 else {
2768 recordingsStateKey.Remove();
2769 Skins.Message(mtWarning, tr("Recording vanished!"));
2770 return false;
2771 }
2772 recordingsStateKey.Remove();
2773 }
2774 return true;
2775}
2776
2778{
2779 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu())) {
2780 strn0cpy(folder, mf->GetFolder(), sizeof(folder));
2782 Display();
2783 }
2784 return CloseSubMenu();
2785}
2786
2788{
2789 return AddSubMenu(new cMenuFolder(tr("Select folder"), &Folders, recording->Name()));
2790}
2791
2793{
2794 if (actionCancel)
2795 RecordingsHandler.Del(recording->FileName());
2796 else if (doCut) {
2797 if (access(cCutter::EditedFileName(recording->FileName()), F_OK) != 0 || Interface->Confirm(tr("Edited version already exists - overwrite?"))) {
2798 if (!EnoughFreeDiskSpaceForEdit(recording->FileName()))
2799 Skins.Message(mtError, tr("Not enough free disk space to start editing process!"));
2800 else if (!RecordingsHandler.Add(ruCut, recording->FileName()))
2801 Skins.Message(mtError, tr("Error while queueing recording for cutting!"));
2802 }
2803 }
2804 else if (doCopy) {
2805 if (!*name)
2806 *name = ' '; // name must not be empty!
2807 cString NewName = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2809 if (strcmp(NewName, recording->Name())) {
2810 cString FromName = cString(ExchangeChars(strdup(recording->Name()), true), true);
2811 cString ToName = cString(ExchangeChars(strdup(*NewName), true), true);
2812 cString FileName = cString(strreplace(strdup(recording->FileName()), *FromName, *ToName), true);
2813 if (access(*FileName, F_OK) != 0 || Interface->Confirm(tr("Edited version already exists - overwrite?"))) {
2814 if (MakeDirs(FileName, true) && !RecordingsHandler.Add(ruCopy, recording->FileName(), FileName))
2815 Skins.Message(mtError, tr("Error while queueing recording for copying!"));
2816 else {
2818 Recordings->AddByName(FileName);
2819 }
2820 }
2821 }
2822 }
2823 recordingIsInUse = recording->IsInUse();
2825 SetHelpKeys();
2826 return osContinue;
2827}
2828
2830{
2831 if (Get(Current()) == nameItem) {
2832 if (Interface->Confirm(tr("Rename recording to folder name?"))) {
2833 char *s = strrchr(folder, FOLDERDELIMCHAR);
2834 if (s)
2835 *s++ = 0;
2836 else
2837 s = folder;
2838 strn0cpy(name, s, sizeof(name));
2839 if (s == folder)
2840 *s = 0;
2841 Set();
2842 }
2843 }
2844 return osContinue;
2845}
2846
2848{
2849 if (extraAction) {
2850 if (buttonDelete && Interface->Confirm(tr("Delete resume for this recording?"))) {
2851 cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording());
2852 ResumeFile.Delete();
2853 SetHelpKeys();
2854 }
2855 }
2856 else {
2857 if (buttonDelete && Interface->Confirm(tr("Delete editing marks for this recording?"))) {
2859 SetHelpKeys();
2860 cMutexLock ControlMutexLock;
2861 if (cControl *Control = cControl::Control(ControlMutexLock, true)) {
2862 if (const cRecording *Recording = Control->GetRecording()) {
2863 if (strcmp(recording->FileName(), Recording->FileName()) == 0)
2864 Control->ClearEditingMarks();
2865 }
2866 }
2867 }
2868 else
2869 Skins.Message(mtError, tr("Error while deleting editing marks!"));
2870 }
2871 }
2872 return osContinue;
2873}
2874
2876{
2877 cStateKey StateKey;
2878 cRecordings *Recordings = cRecordings::GetRecordingsWrite(StateKey);
2879 cRecording *Recording = Recordings->GetByName(recording->FileName());
2880 if (!Recording) {
2881 StateKey.Remove(false);
2882 Skins.Message(mtWarning, tr("Recording vanished!"));
2883 return osBack;
2884 }
2885 bool Modified = false;
2886 if (priority != recording->Priority() || lifetime != recording->Lifetime()) {
2887 if (!Recording->ChangePriorityLifetime(priority, lifetime)) {
2888 StateKey.Remove(Modified);
2889 Skins.Message(mtError, tr("Error while changing priority/lifetime!"));
2890 return osContinue;
2891 }
2892 Modified = true;
2893 }
2894 if (!*name) {
2895 *name = ' '; // name must not be empty!
2896 name[1] = 0;
2897 }
2898 cString OldFolder = Recording->Folder();
2899 cString NewName = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2901 if (strcmp(NewName, Recording->Name())) {
2902 if (!Recording->ChangeName(NewName)) {
2903 StateKey.Remove(Modified);
2904 Skins.Message(mtError, tr("Error while changing folder/name!"));
2905 return osContinue;
2906 }
2907 Modified = true;
2908 }
2909 if (Modified) {
2910 eOSState state = osUserRecRenamed;
2911 if (strcmp(Recording->Folder(), OldFolder))
2912 state = osUserRecMoved;
2913 Recordings->TouchUpdate();
2914 StateKey.Remove(Modified);
2915 return state;
2916 }
2917 StateKey.Remove(Modified);
2918 return osBack;
2919}
2920
2922{
2923 if (!HasSubMenu()) {
2924 if (!RefreshRecording())
2925 return osBack; // the recording has vanished, so close this menu
2926 }
2927 eOSState state = cOsdMenu::ProcessKey(Key);
2928 if (state == osUnknown) {
2929 switch (Key) {
2930 case k0: return RemoveName();
2931 case kRed: return buttonFolder ? Folder() : osContinue;
2932 case kGreen: return buttonAction ? Action() : osContinue;
2933 case kYellow: return buttonDelete ? Delete() : osContinue;
2935 case kOk: return !recordingIsInUse ? ApplyChanges() : osBack;
2936 default: break;
2937 }
2938 }
2939 else if (state == osEnd && HasSubMenu())
2940 state = SetFolder();
2941 return state;
2942}
2943
2944// --- cMenuRecording --------------------------------------------------------
2945
2946class cMenuRecording : public cOsdMenu {
2947private:
2952 bool RefreshRecording(void);
2953public:
2954 cMenuRecording(const cRecording *Recording, bool WithButtons = false);
2955 virtual void Display(void) override;
2956 virtual eOSState ProcessKey(eKeys Key) override;
2957};
2958
2959cMenuRecording::cMenuRecording(const cRecording *Recording, bool WithButtons)
2960:cOsdMenu(tr("Recording info"))
2961{
2963 if (cRecordings::GetRecordingsRead(recordingsStateKey)) // initializes recordingsStateKey, so we don't call Display() unnecessarily
2964 recordingsStateKey.Remove();
2965 recording = Recording;
2966 originalFileName = recording->FileName();
2967 withButtons = WithButtons;
2968 if (withButtons)
2969 SetHelp(tr("Button$Play"), tr("Button$Rewind"), NULL, tr("Button$Edit"));
2970}
2971
2973{
2975 if ((recording = Recordings->GetByName(originalFileName)) != NULL)
2976 Display();
2977 else {
2978 recordingsStateKey.Remove();
2979 Skins.Message(mtWarning, tr("Recording vanished!"));
2980 return false;
2981 }
2982 recordingsStateKey.Remove();
2983 }
2984 return true;
2985}
2986
2988{
2989 if (HasSubMenu()) {
2990 SubMenu()->Display();
2991 return;
2992 }
2995 if (recording->Info()->Description())
2996 cStatus::MsgOsdTextItem(recording->Info()->Description());
2997}
2998
3000{
3001 if (HasSubMenu())
3002 return cOsdMenu::ProcessKey(Key);
3003 else if (!RefreshRecording())
3004 return osBack; // the recording has vanished, so close this menu
3005 switch (int(Key)) {
3006 case kUp|k_Repeat:
3007 case kUp:
3008 case kDown|k_Repeat:
3009 case kDown:
3010 case kLeft|k_Repeat:
3011 case kLeft:
3012 case kRight|k_Repeat:
3013 case kRight:
3014 DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight);
3015 cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft);
3016 return osContinue;
3017 case kInfo: return osBack;
3018 default: break;
3019 }
3020
3021 eOSState state = cOsdMenu::ProcessKey(Key);
3022
3023 if (state == osUnknown) {
3024 switch (Key) {
3025 case kRed: if (withButtons)
3026 Key = kOk; // will play the recording, even if recording commands are defined
3027 case kGreen: if (!withButtons)
3028 break;
3029 cRemote::Put(Key, true);
3030 // continue with osBack to close the info menu and process the key
3031 case kOk: return osBack;
3032 case kBlue: if (withButtons)
3034 break;
3035 default: break;
3036 }
3037 }
3038 return state;
3039}
3040
3041// --- cMenuRecordingItem ----------------------------------------------------
3042
3044private:
3047 char *name;
3049public:
3052 void IncrementCounter(bool New);
3053 const char *Name(void) const { return name; }
3054 int Level(void) const { return level; }
3055 const cRecording *Recording(void) const { return recording; }
3056 bool IsDirectory(void) const { return name != NULL; }
3058 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
3059 };
3060
3062{
3064 level = Level;
3065 name = NULL;
3067 SetText(Recording->Title('\t', true, Level));
3068 if (*Text() == '\t') // this is a folder
3069 name = strdup(Text() + 2); // 'Text() + 2' to skip the two '\t'
3070 else { // this is an actual recording
3071 int Usage = Recording->IsInUse();
3072 if ((Usage & ruDst) != 0 && (Usage & (ruMove | ruCopy)) != 0)
3073 SetSelectable(false);
3074 }
3075}
3076
3081
3083{
3084 totalEntries++;
3085 if (New)
3086 newEntries++;
3088}
3089
3090void cMenuRecordingItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
3091{
3093 if (!DisplayMenu->SetItemRecording(recording, Index, Current, Selectable, level, totalEntries, newEntries))
3094 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
3095}
3096
3097// --- cMenuRecordings -------------------------------------------------------
3098
3101
3102cMenuRecordings::cMenuRecordings(const char *Base, int Level, bool OpenSubMenus, const cRecordingFilter *Filter)
3103:cOsdMenu(Base ? Base : tr("Recordings"), 9, 6, 6)
3104{
3106 base = Base ? strdup(Base) : NULL;
3107 level = Setup.RecordingDirs ? Level : -1;
3108 filter = Filter;
3109 helpKeys = -1;
3110 Display(); // this keeps the higher level menus from showing up briefly when pressing 'Back' during replay
3111 Set();
3112 if (Current() < 0)
3113 SetCurrent(First());
3114 else if (OpenSubMenus && (cReplayControl::LastReplayed() || *path || *fileName)) {
3115 if (!*path || Level < strcountchr(path, FOLDERDELIMCHAR)) {
3116 if (Open(true))
3117 return;
3118 }
3119 }
3120 SetHelpKeys();
3121}
3122
3124{
3126 if (!ri->IsDirectory())
3127 SetRecording(ri->Recording()->FileName());
3128 }
3129 free(base);
3130}
3131
3133{
3135 int NewHelpKeys = 0;
3136 if (ri) {
3137 if (ri->IsDirectory())
3138 NewHelpKeys = 1;
3139 else
3140 NewHelpKeys = 2;
3141 }
3142 if (NewHelpKeys != helpKeys) {
3143 switch (NewHelpKeys) {
3144 case 0: SetHelp(NULL); break;
3145 case 1: SetHelp(tr("Button$Open"), NULL, NULL, tr("Button$Edit")); break;
3146 case 2: SetHelp(RecordingCommands.Count() ? tr("Commands") : tr("Button$Play"), tr("Button$Rewind"), tr("Button$Delete"), tr("Button$Info"));
3147 default: ;
3148 }
3149 helpKeys = NewHelpKeys;
3150 }
3151}
3152
3153void cMenuRecordings::Set(bool Refresh)
3154{
3156 recordingsStateKey.Remove();
3157 cRecordings *Recordings = cRecordings::GetRecordingsWrite(recordingsStateKey); // write access is necessary for sorting!
3158 const char *CurrentRecording = NULL;
3160 CurrentRecording = ri->Recording()->FileName();
3161 if (!CurrentRecording)
3162 CurrentRecording = *fileName ? *fileName : cReplayControl::LastReplayed();
3163 int current = Current();
3164 Clear();
3166 Recordings->Sort();
3167 cMenuRecordingItem *CurrentItem = NULL;
3168 cMenuRecordingItem *LastItem = NULL;
3169 for (const cRecording *Recording = Recordings->First(); Recording; Recording = Recordings->Next(Recording)) {
3170 if ((!filter || filter->Filter(Recording)) && (!base || (strstr(Recording->Name(), base) == Recording->Name() && Recording->Name()[strlen(base)] == FOLDERDELIMCHAR))) {
3171 cMenuRecordingItem *Item = new cMenuRecordingItem(Recording, level);
3172 cMenuRecordingItem *LastDir = NULL;
3173 if (Item->IsDirectory()) {
3174 // Sorting may ignore non-alphanumeric characters, so we need to explicitly handle directories in case they only differ in such characters:
3175 for (cMenuRecordingItem *p = LastItem; p; p = dynamic_cast<cMenuRecordingItem *>(p->Prev())) {
3176 if (p->Name() && strcmp(p->Name(), Item->Name()) == 0) {
3177 LastDir = p;
3178 break;
3179 }
3180 }
3181 }
3182 if (*Item->Text() && !LastDir) {
3183 Add(Item);
3184 LastItem = Item;
3185 if (Item->IsDirectory())
3186 LastDir = Item;
3187 }
3188 else
3189 delete Item;
3190 if (LastItem || LastDir) {
3191 if (*path) {
3192 if (strcmp(path, Recording->Folder()) == 0)
3193 CurrentItem = LastDir ? LastDir : LastItem;
3194 }
3195 else if (CurrentRecording && strcmp(CurrentRecording, Recording->FileName()) == 0)
3196 CurrentItem = LastDir ? LastDir : LastItem;
3197 }
3198 if (LastDir)
3199 LastDir->IncrementCounter(Recording->IsNew());
3200 }
3201 }
3202 SetCurrent(CurrentItem);
3203 if (Current() < 0)
3204 SetCurrent(Get(current)); // last resort, in case the recording was deleted
3206 recordingsStateKey.Remove(false); // sorting doesn't count as a real modification
3207 if (Refresh)
3208 Display();
3209 }
3210}
3211
3212void cMenuRecordings::SetRecording(const char *FileName)
3213{
3214 fileName = FileName;
3215}
3216
3218{
3220 if (base) {
3221 char *s = ExchangeChars(strdup(base), true);
3222 d = AddDirectory(d, s);
3223 free(s);
3224 }
3225 return d;
3226}
3227
3228bool cMenuRecordings::Open(bool OpenSubMenus)
3229{
3231 if (ri && ri->IsDirectory() && (!*path || strcountchr(path, FOLDERDELIMCHAR) > 0)) {
3232 const char *t = ri->Name();
3233 cString buffer;
3234 if (base) {
3235 buffer = cString::sprintf("%s%c%s", base, FOLDERDELIMCHAR, t);
3236 t = buffer;
3237 }
3238 AddSubMenu(new cMenuRecordings(t, level + 1, OpenSubMenus, filter));
3239 return true;
3240 }
3241 return false;
3242}
3243
3245{
3247 if (ri) {
3248 if (ri->IsDirectory())
3249 Open();
3250 else {
3252 return osReplay;
3253 }
3254 }
3255 return osContinue;
3256}
3257
3259{
3260 if (HasSubMenu() || Count() == 0)
3261 return osContinue;
3263 if (ri && !ri->IsDirectory()) {
3264 cDevice::PrimaryDevice()->StopReplay(); // must do this first to be able to rewind the currently replayed recording
3265 cResumeFile ResumeFile(ri->Recording()->FileName(), ri->Recording()->IsPesRecording());
3266 ResumeFile.Delete();
3267 return Play();
3268 }
3269 return osContinue;
3270}
3271
3272static bool TimerStillRecording(const char *FileName)
3273{
3275 // local timer
3276 if (Interface->Confirm(tr("Timer still recording - really delete?"))) {
3278 if (cTimer *Timer = rc->Timer()) {
3279 Timer->Skip();
3280 cRecordControls::Process(Timers, time(NULL));
3281 if (Timer->IsSingleEvent()) {
3282 Timers->Del(Timer);
3283 isyslog("deleted timer %s", *Timer->ToDescr());
3284 }
3285 }
3286 }
3287 else
3288 return true; // user didn't confirm deletion
3289 }
3290 else {
3291 // remote timer
3292 cString TimerId = GetRecordingTimerId(FileName);
3293 if (*TimerId) {
3294 int Id;
3295 char *RemoteBuf = NULL;
3296 cString Remote;
3297 if (2 == sscanf(TimerId, "%d@%m[^ \n]", &Id, &RemoteBuf) && Id != 0) {
3298 Remote = RemoteBuf;
3299 free(RemoteBuf);
3300 if (Interface->Confirm(tr("Timer still recording - really delete?"))) {
3302 if (cTimer *Timer = Timers->GetById(Id, Remote)) {
3303 cTimer OldTimer = *Timer;
3304 Timer->Skip();
3305 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
3306 if (Timer->IsSingleEvent()) {
3307 if (HandleRemoteModifications(NULL, Timer))
3308 Timers->Del(Timer);
3309 else
3310 return true; // error while deleting remote timer
3311 }
3312 else if (!HandleRemoteModifications(Timer, &OldTimer))
3313 return true; // error while modifying remote timer
3314 }
3315 }
3316 else
3317 return true; // user didn't confirm deletion
3318 }
3319 }
3320 }
3321 return false;
3322}
3323
3325{
3326 if (HasSubMenu() || Count() == 0)
3327 return osContinue;
3329 if (ri && !ri->IsDirectory()) {
3330 if (Interface->Confirm(tr("Delete recording?"))) {
3332 return osContinue;
3333 cString FileName;
3334 {
3336 if (const cRecording *Recording = Recordings->GetByName(ri->Recording()->FileName())) {
3337 FileName = Recording->FileName();
3338 if (RecordingsHandler.GetUsage(FileName)) {
3339 if (!Interface->Confirm(tr("Recording is being edited - really delete?")))
3340 return osContinue;
3341 SetNeedsFastResponse(true); // makes sure the edited version is removed from the menu ASAP
3342 }
3343 }
3344 else
3345 return osContinue; // recording has already been deleted
3346 }
3347 RecordingsHandler.Del(FileName); // must do this w/o holding a lock, because the cleanup section in cDirCopier::Action() might request one!
3348 if (cReplayControl::NowReplaying() && strcmp(cReplayControl::NowReplaying(), FileName) == 0)
3351 Recordings->SetExplicitModify();
3352 cRecording *Recording = Recordings->GetByName(FileName);
3353 if (!Recording || Recording->Delete()) {
3355 Recordings->DelByName(FileName);
3357 SetHelpKeys();
3359 Recordings->SetModified();
3360 recordingsStateKey.Remove();
3361 Display();
3362 if (!Count())
3363 return osUserRecEmpty;
3364 return osUserRecRemoved;
3365 }
3366 else
3367 Skins.Message(mtError, tr("Error while deleting recording!"));
3368 recordingsStateKey.Remove();
3369 }
3370 }
3371 return osContinue;
3372}
3373
3375{
3376 if (HasSubMenu() || Count() == 0)
3377 return osContinue;
3379 if (ri->IsDirectory())
3380 return AddSubMenu(new cMenuPathEdit(cString(ri->Recording()->Name(), strchrn(ri->Recording()->Name(), FOLDERDELIMCHAR, ri->Level() + 1))));
3381 else
3382 return AddSubMenu(new cMenuRecording(ri->Recording(), true));
3383 }
3384 return osContinue;
3385}
3386
3388{
3389 if (HasSubMenu() || Count() == 0)
3390 return osContinue;
3392 if (ri && !ri->IsDirectory()) {
3393 cMenuCommands *menu;
3394 eOSState state = AddSubMenu(menu = new cMenuCommands(tr("Recording commands"), &RecordingCommands, cString::sprintf("\"%s\"", *strescape(ri->Recording()->FileName(), "\\\"$"))));
3395 if (Key != kNone)
3396 state = menu->ProcessKey(Key);
3397 return state;
3398 }
3399 return osContinue;
3400}
3401
3403{
3404 if (HasSubMenu())
3405 return osContinue;
3406 if (const cMenuRecordingItem *ri = (cMenuRecordingItem *)Get(Current()))
3407 SetRecording(ri->Recording()->FileName()); // makes sure the Recordings menu will reposition to the current recording
3409 recordingsStateKey.Reset();
3410 Set(true);
3411 return osContinue;
3412}
3413
3415{
3416 eOSState state = cOsdMenu::ProcessKey(Key);
3417
3418 if (state == osUnknown) {
3419 switch (Key) {
3420 case kPlayPause:
3421 case kPlay:
3422 case kOk: return Play();
3423 case kRed: return (helpKeys > 1 && RecordingCommands.Count()) ? Commands() : Play();
3424 case kGreen: return Rewind();
3425 case kYellow: return Delete();
3426 case kInfo:
3427 case kBlue: return Info();
3428 case k0: return Sort();
3429 case k1...k9: return Commands(Key);
3430 default: break;
3431 }
3432 }
3433 else if (state == osUserRecRenamed) {
3434 // a recording was renamed (within the same folder), so let's refresh the menu
3435 CloseSubMenu(false); // this is the cMenuRecordingEdit/cMenuPathEdit
3436 path = NULL;
3437 fileName = NULL;
3438 state = osContinue;
3439 }
3440 else if (state == osUserRecMoved) {
3441 // a recording was moved to a different folder, so let's delete the old item
3442 CloseSubMenu(false); // this is the cMenuRecordingEdit/cMenuPathEdit
3443 path = NULL;
3444 fileName = NULL;
3446 Set(); // the recording might have been moved into a new subfolder of this folder
3447 if (!Count())
3448 return osUserRecEmpty;
3449 Display();
3450 state = osUserRecRemoved;
3451 }
3452 else if (state == osUserRecRemoved) {
3453 // a recording was removed from a sub folder, so update the current item
3454 if (cOsdMenu *m = SubMenu()) {
3456 if (cMenuRecordingItem *riSub = (cMenuRecordingItem *)m->Get(m->Current()))
3457 ri->SetRecording(riSub->Recording());
3458 }
3459 }
3460 // no state change here, this report goes upstream!
3461 }
3462 else if (state == osUserRecEmpty) {
3463 // a subfolder became empty, so let's go back up
3464 CloseSubMenu(false); // this is the now empty submenu
3465 cOsdMenu::Del(Current()); // the menu entry of the now empty subfolder
3466 Set(); // in case a recording was moved into a new subfolder of this folder
3467 if (base && !Count()) // base: don't go up beyond the top level Recordings menu
3468 return state;
3469 Display();
3470 state = osContinue;
3471 }
3472 if (!HasSubMenu()) {
3473 Set(true);
3474 if (Key != kNone)
3475 SetHelpKeys();
3476 }
3477 return state;
3478}
3479
3480// --- cMenuSetupBase --------------------------------------------------------
3481
3483protected:
3485 virtual void Store(void) override;
3486public:
3487 cMenuSetupBase(void);
3488 };
3489
3494
3496{
3497 Setup = data;
3499 Setup.Save();
3500}
3501
3502// --- cMenuSetupOSD ---------------------------------------------------------
3503
3505private:
3506 const char *useSmallFontTexts[3];
3507 const char *recSortModeTexts[2];
3508 const char *recSortDirTexts[2];
3509 const char *keyColorTexts[4];
3514 const char **skinDescriptions;
3520 virtual void Set(void);
3521public:
3522 cMenuSetupOSD(void);
3523 virtual ~cMenuSetupOSD() override;
3524 virtual eOSState ProcessKey(eKeys Key) override;
3525 };
3526
3528{
3531 numSkins = Skins.Count();
3532 skinIndex = originalSkinIndex = Skins.Current()->Index();
3533 skinDescriptions = new const char*[numSkins];
3534 themes.Load(Skins.Current()->Name());
3535 themeIndex = originalThemeIndex = Skins.Current()->Theme() ? themes.GetThemeIndex(Skins.Current()->Theme()->Description()) : 0;
3539 fontOsdNames.Insert(strdup(DefaultFontOsd));
3540 fontSmlNames.Insert(strdup(DefaultFontSml));
3541 fontFixNames.Insert(strdup(DefaultFontFix));
3542 fontOsdIndex = max(0, fontOsdNames.Find(Setup.FontOsd));
3543 fontSmlIndex = max(0, fontSmlNames.Find(Setup.FontSml));
3544 fontFixIndex = max(0, fontFixNames.Find(Setup.FontFix));
3545 Set();
3546}
3547
3552
3554{
3555 int current = Current();
3556 for (cSkin *Skin = Skins.First(); Skin; Skin = Skins.Next(Skin))
3557 skinDescriptions[Skin->Index()] = Skin->Description();
3558 useSmallFontTexts[0] = tr("never");
3559 useSmallFontTexts[1] = tr("skin dependent");
3560 useSmallFontTexts[2] = tr("always");
3561 recSortModeTexts[0] = tr("by name");
3562 recSortModeTexts[1] = tr("by time");
3563 recSortDirTexts[0] = tr("ascending");
3564 recSortDirTexts[1] = tr("descending");
3565 keyColorTexts[0] = tr("Key$Red");
3566 keyColorTexts[1] = tr("Key$Green");
3567 keyColorTexts[2] = tr("Key$Yellow");
3568 keyColorTexts[3] = tr("Key$Blue");
3569 Clear();
3570 SetSection(tr("OSD"));
3571 Add(new cMenuEditStraItem(tr("Setup.OSD$Language"), &osdLanguageIndex, I18nNumLanguagesWithLocale(), &I18nLanguages()->At(0)));
3572 Add(new cMenuEditStraItem(tr("Setup.OSD$Skin"), &skinIndex, numSkins, skinDescriptions));
3573 if (themes.NumThemes())
3574 Add(new cMenuEditStraItem(tr("Setup.OSD$Theme"), &themeIndex, themes.NumThemes(), themes.Descriptions()));
3575 Add(new cMenuEditPrcItem( tr("Setup.OSD$Left (%)"), &data.OSDLeftP, 0.0, 0.5));
3576 Add(new cMenuEditPrcItem( tr("Setup.OSD$Top (%)"), &data.OSDTopP, 0.0, 0.5));
3577 Add(new cMenuEditPrcItem( tr("Setup.OSD$Width (%)"), &data.OSDWidthP, 0.5, 1.0));
3578 Add(new cMenuEditPrcItem( tr("Setup.OSD$Height (%)"), &data.OSDHeightP, 0.5, 1.0));
3579 Add(new cMenuEditIntItem( tr("Setup.OSD$Message time (s)"), &data.OSDMessageTime, 1, 60));
3580 Add(new cMenuEditStraItem(tr("Setup.OSD$Use small font"), &data.UseSmallFont, 3, useSmallFontTexts));
3581 Add(new cMenuEditBoolItem(tr("Setup.OSD$Anti-alias"), &data.AntiAlias));
3582 Add(new cMenuEditStraItem(tr("Setup.OSD$Default font"), &fontOsdIndex, fontOsdNames.Size(), &fontOsdNames[0]));
3583 Add(new cMenuEditStraItem(tr("Setup.OSD$Small font"), &fontSmlIndex, fontSmlNames.Size(), &fontSmlNames[0]));
3584 Add(new cMenuEditStraItem(tr("Setup.OSD$Fixed font"), &fontFixIndex, fontFixNames.Size(), &fontFixNames[0]));
3585 Add(new cMenuEditPrcItem( tr("Setup.OSD$Default font size (%)"), &data.FontOsdSizeP, 0.01, 0.1, 1));
3586 Add(new cMenuEditPrcItem( tr("Setup.OSD$Small font size (%)"), &data.FontSmlSizeP, 0.01, 0.1, 1));
3587 Add(new cMenuEditPrcItem( tr("Setup.OSD$Fixed font size (%)"), &data.FontFixSizeP, 0.01, 0.1, 1));
3588 Add(new cMenuEditBoolItem(tr("Setup.OSD$Channel info position"), &data.ChannelInfoPos, tr("bottom"), tr("top")));
3589 Add(new cMenuEditIntItem( tr("Setup.OSD$Channel info time (s)"), &data.ChannelInfoTime, 1, 60));
3590 Add(new cMenuEditBoolItem(tr("Setup.OSD$Info on channel switch"), &data.ShowInfoOnChSwitch));
3591 Add(new cMenuEditBoolItem(tr("Setup.OSD$Timeout requested channel info"), &data.TimeoutRequChInfo));
3592 Add(new cMenuEditBoolItem(tr("Setup.OSD$Scroll pages"), &data.MenuScrollPage));
3593 Add(new cMenuEditBoolItem(tr("Setup.OSD$Scroll wraps"), &data.MenuScrollWrap));
3594 Add(new cMenuEditBoolItem(tr("Setup.OSD$Menu key closes"), &data.MenuKeyCloses));
3595 Add(new cMenuEditBoolItem(tr("Setup.OSD$Recording directories"), &data.RecordingDirs));
3596 Add(new cMenuEditBoolItem(tr("Setup.OSD$Folders in timer menu"), &data.FoldersInTimerMenu));
3597 Add(new cMenuEditBoolItem(tr("Setup.OSD$Always sort folders first"), &data.AlwaysSortFoldersFirst));
3598 Add(new cMenuEditStraItem(tr("Setup.OSD$Default sort mode for recordings"), &data.DefaultSortModeRec, 2, recSortModeTexts));
3599 Add(new cMenuEditStraItem(tr("Setup.OSD$Sorting direction for recordings"), &data.RecSortingDirection, 2, recSortDirTexts));
3600 Add(new cMenuEditBoolItem(tr("Setup.OSD$Number keys for characters"), &data.NumberKeysForChars));
3601 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 0"), &data.ColorKey0, 4, keyColorTexts));
3602 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 1"), &data.ColorKey1, 4, keyColorTexts));
3603 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 2"), &data.ColorKey2, 4, keyColorTexts));
3604 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 3"), &data.ColorKey3, 4, keyColorTexts));
3606 Display();
3607}
3608
3610{
3611 bool ModifiedAppearance = false;
3612
3613 if (Key == kOk) {
3614 I18nSetLocale(data.OSDLanguage);
3616 cSkin *Skin = Skins.Get(skinIndex);
3617 if (Skin) {
3618 Utf8Strn0Cpy(data.OSDSkin, Skin->Name(), sizeof(data.OSDSkin));
3619 Skins.SetCurrent(Skin->Name());
3620 ModifiedAppearance = true;
3621 }
3622 }
3623 if (themes.NumThemes() && Skins.Current()->Theme()) {
3624 Skins.Current()->Theme()->Load(themes.FileName(themeIndex));
3625 Utf8Strn0Cpy(data.OSDTheme, themes.Name(themeIndex), sizeof(data.OSDTheme));
3626 ModifiedAppearance |= themeIndex != originalThemeIndex;
3627 }
3628 if (!(DoubleEqual(data.OSDLeftP, Setup.OSDLeftP) && DoubleEqual(data.OSDTopP, Setup.OSDTopP) && DoubleEqual(data.OSDWidthP, Setup.OSDWidthP) && DoubleEqual(data.OSDHeightP, Setup.OSDHeightP)))
3629 ModifiedAppearance = true;
3630 if (data.UseSmallFont != Setup.UseSmallFont || data.AntiAlias != Setup.AntiAlias)
3631 ModifiedAppearance = true;
3632 Utf8Strn0Cpy(data.FontOsd, fontOsdNames[fontOsdIndex], sizeof(data.FontOsd));
3633 Utf8Strn0Cpy(data.FontSml, fontSmlNames[fontSmlIndex], sizeof(data.FontSml));
3634 Utf8Strn0Cpy(data.FontFix, fontFixNames[fontFixIndex], sizeof(data.FontFix));
3635 if (strcmp(data.FontOsd, Setup.FontOsd) || !DoubleEqual(data.FontOsdSizeP, Setup.FontOsdSizeP))
3636 ModifiedAppearance = true;
3637 if (strcmp(data.FontSml, Setup.FontSml) || !DoubleEqual(data.FontSmlSizeP, Setup.FontSmlSizeP))
3638 ModifiedAppearance = true;
3639 if (strcmp(data.FontFix, Setup.FontFix) || !DoubleEqual(data.FontFixSizeP, Setup.FontFixSizeP))
3640 ModifiedAppearance = true;
3641 if (data.AlwaysSortFoldersFirst != Setup.AlwaysSortFoldersFirst || data.RecordingDirs != Setup.RecordingDirs || data.RecSortingDirection != Setup.RecSortingDirection) {
3643 Recordings->ClearSortNames();
3644 }
3645 }
3646
3647 int oldSkinIndex = skinIndex;
3648 int oldOsdLanguageIndex = osdLanguageIndex;
3650
3651 if (ModifiedAppearance)
3653
3654 if (osdLanguageIndex != oldOsdLanguageIndex || skinIndex != oldSkinIndex) {
3655 strn0cpy(data.OSDLanguage, I18nLocale(osdLanguageIndex), sizeof(data.OSDLanguage));
3656 int OriginalOSDLanguage = I18nCurrentLanguage();
3658
3659 cSkin *Skin = Skins.Get(skinIndex);
3660 if (Skin) {
3661 char *d = themes.NumThemes() ? strdup(themes.Descriptions()[themeIndex]) : NULL;
3662 themes.Load(Skin->Name());
3663 if (skinIndex != oldSkinIndex)
3664 themeIndex = d ? themes.GetThemeIndex(d) : 0;
3665 free(d);
3666 }
3667
3668 Set();
3669 I18nSetLanguage(OriginalOSDLanguage);
3670 }
3671 return state;
3672}
3673
3674// --- cMenuSetupEPG ---------------------------------------------------------
3675
3677private:
3680 void Setup(void);
3681public:
3682 cMenuSetupEPG(void);
3683 virtual eOSState ProcessKey(eKeys Key) override;
3684 };
3685
3687{
3689 for (numLanguages = 0; numLanguages < I18nLanguages()->Size() && data.EPGLanguages[numLanguages] >= 0; numLanguages++)
3690 ;
3692 SetSection(tr("EPG"));
3693 SetHelp(tr("Button$Scan"));
3694 Setup();
3695}
3696
3698{
3699 int current = Current();
3700
3701 Clear();
3702
3703 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG scan timeout (h)"), &data.EPGScanTimeout));
3704 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG scan max. channel number (0=all)"), &data.EPGScanMaxChannel));
3705 Add(new cMenuEditBoolItem(tr("Setup.EPG$EPG pause after scan"), &data.EPGPauseAfterScan));
3706 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG bugfix level"), &data.EPGBugfixLevel, 0, MAXEPGBUGFIXLEVEL));
3707 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG linger time (min)"), &data.EPGLinger, 0));
3708 Add(new cMenuEditBoolItem(tr("Setup.EPG$Set system time"), &data.SetSystemTime));
3709 if (data.SetSystemTime)
3710 Add(new cMenuEditTranItem(tr("Setup.EPG$Use time from transponder"), &data.TimeTransponder, &data.TimeSource));
3711 // TRANSLATORS: note the plural!
3712 Add(new cMenuEditIntItem( tr("Setup.EPG$Preferred languages"), &numLanguages, 0, I18nLanguages()->Size()));
3713 for (int i = 0; i < numLanguages; i++)
3714 // TRANSLATORS: note the singular!
3715 Add(new cMenuEditStraItem(tr("Setup.EPG$Preferred language"), &data.EPGLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3716
3718 Display();
3719}
3720
3722{
3723 if (Key == kOk) {
3724 bool Modified = numLanguages != originalNumLanguages;
3725 if (!Modified) {
3726 for (int i = 0; i < numLanguages; i++) {
3727 if (data.EPGLanguages[i] != ::Setup.EPGLanguages[i]) {
3728 Modified = true;
3729 break;
3730 }
3731 }
3732 }
3733 if (Modified)
3735 }
3736
3737 int oldnumLanguages = numLanguages;
3738 int oldSetSystemTime = data.SetSystemTime;
3739
3741 if (Key != kNone) {
3742 if (numLanguages != oldnumLanguages || data.SetSystemTime != oldSetSystemTime) {
3743 for (int i = oldnumLanguages; i < numLanguages; i++) {
3744 data.EPGLanguages[i] = 0;
3745 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3746 int k;
3747 for (k = 0; k < oldnumLanguages; k++) {
3748 if (data.EPGLanguages[k] == l)
3749 break;
3750 }
3751 if (k >= oldnumLanguages) {
3752 data.EPGLanguages[i] = l;
3753 break;
3754 }
3755 }
3756 }
3757 data.EPGLanguages[numLanguages] = -1;
3758 Setup();
3759 }
3760 if (Key == kRed) {
3761 EITScanner.ForceScan();
3762 return osEnd;
3763 }
3764 }
3765 return state;
3766}
3767
3768// --- cMenuSetupDVB ---------------------------------------------------------
3769
3771private:
3776 void Setup(void);
3778 const char *updateChannelsTexts[6];
3781public:
3782 cMenuSetupDVB(void);
3783 virtual eOSState ProcessKey(eKeys Key) override;
3784 };
3785
3787{
3790 ;
3792 ;
3795 videoDisplayFormatTexts[0] = tr("pan&scan");
3796 videoDisplayFormatTexts[1] = tr("letterbox");
3797 videoDisplayFormatTexts[2] = tr("center cut out");
3798 updateChannelsTexts[0] = tr("no");
3799 updateChannelsTexts[1] = tr("names only");
3800 updateChannelsTexts[2] = tr("PIDs only");
3801 updateChannelsTexts[3] = tr("names and PIDs");
3802 updateChannelsTexts[4] = tr("add new channels");
3803 updateChannelsTexts[5] = tr("add new transponders");
3804 displaySubtitlesTexts[0] = tr("no");
3805 displaySubtitlesTexts[1] = tr("always");
3806 displaySubtitlesTexts[2] = tr("after rewind");
3807 standardComplianceTexts[0] = "DVB";
3808 standardComplianceTexts[1] = "ANSI/SCTE";
3809 standardComplianceTexts[2] = "NORDIG";
3810
3811 SetSection(tr("DVB"));
3812 SetHelp(NULL, tr("Button$Audio"), tr("Button$Subtitles"), NULL);
3813 Setup();
3814}
3815
3817{
3818 int current = Current();
3819
3820 Clear();
3821
3822 Add(new cMenuEditIntItem( tr("Setup.DVB$Primary DVB interface"), &data.PrimaryDVB, 1, cDevice::NumDevices()));
3823 Add(new cMenuEditStraItem(tr("Setup.DVB$Standard compliance"), &data.StandardCompliance, 3, standardComplianceTexts));
3824 Add(new cMenuEditBoolItem(tr("Setup.DVB$Video format"), &data.VideoFormat, "4:3", "16:9"));
3825 if (data.VideoFormat == 0)
3826 Add(new cMenuEditStraItem(tr("Setup.DVB$Video display format"), &data.VideoDisplayFormat, 3, videoDisplayFormatTexts));
3827 Add(new cMenuEditBoolItem(tr("Setup.DVB$Use Dolby Digital"), &data.UseDolbyDigital));
3828 Add(new cMenuEditStraItem(tr("Setup.DVB$Update channels"), &data.UpdateChannels, 6, updateChannelsTexts));
3829 Add(new cMenuEditIntItem( tr("Setup.DVB$Audio languages"), &numAudioLanguages, 0, I18nLanguages()->Size()));
3830 for (int i = 0; i < numAudioLanguages; i++)
3831 Add(new cMenuEditStraItem(tr("Setup.DVB$Audio language"), &data.AudioLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3832 Add(new cMenuEditStraItem(tr("Setup.DVB$Display subtitles"), &data.DisplaySubtitles, 3, displaySubtitlesTexts));
3833 if (data.DisplaySubtitles != SUBTITLES_NO) {
3834 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle languages"), &numSubtitleLanguages, 0, I18nLanguages()->Size()));
3835 for (int i = 0; i < numSubtitleLanguages; i++)
3836 Add(new cMenuEditStraItem(tr("Setup.DVB$Subtitle language"), &data.SubtitleLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3837 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle offset"), &data.SubtitleOffset, -100, 100));
3838 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle foreground transparency"), &data.SubtitleFgTransparency, 0, 9));
3839 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle background transparency"), &data.SubtitleBgTransparency, 0, 10));
3840 }
3841
3843 Display();
3844}
3845
3847{
3848 int oldVideoDisplayFormat = ::Setup.VideoDisplayFormat;
3849 bool oldVideoFormat = ::Setup.VideoFormat;
3850 bool newVideoFormat = data.VideoFormat;
3851 int oldDisplaySubtitles = ::Setup.DisplaySubtitles;
3852 int newDisplaySubtitles = data.DisplaySubtitles;
3853 int oldnumAudioLanguages = numAudioLanguages;
3854 int oldnumSubtitleLanguages = numSubtitleLanguages;
3856
3857 if (Key != kNone) {
3858 switch (Key) {
3859 case kGreen: cRemote::Put(kAudio, true);
3860 state = osEnd;
3861 break;
3862 case kYellow: cRemote::Put(kSubtitles, true);
3863 state = osEnd;
3864 break;
3865 default: {
3866 bool DoSetup = data.VideoFormat != newVideoFormat;
3867 DoSetup |= data.DisplaySubtitles != newDisplaySubtitles;
3868 if (numAudioLanguages != oldnumAudioLanguages) {
3869 for (int i = oldnumAudioLanguages; i < numAudioLanguages; i++) {
3870 data.AudioLanguages[i] = 0;
3871 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3872 int k;
3873 for (k = 0; k < oldnumAudioLanguages; k++) {
3874 if (data.AudioLanguages[k] == l)
3875 break;
3876 }
3877 if (k >= oldnumAudioLanguages) {
3878 data.AudioLanguages[i] = l;
3879 break;
3880 }
3881 }
3882 }
3883 data.AudioLanguages[numAudioLanguages] = -1;
3884 DoSetup = true;
3885 }
3886 if (numSubtitleLanguages != oldnumSubtitleLanguages) {
3887 for (int i = oldnumSubtitleLanguages; i < numSubtitleLanguages; i++) {
3888 data.SubtitleLanguages[i] = 0;
3889 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3890 int k;
3891 for (k = 0; k < oldnumSubtitleLanguages; k++) {
3892 if (data.SubtitleLanguages[k] == l)
3893 break;
3894 }
3895 if (k >= oldnumSubtitleLanguages) {
3896 data.SubtitleLanguages[i] = l;
3897 break;
3898 }
3899 }
3900 }
3901 data.SubtitleLanguages[numSubtitleLanguages] = -1;
3902 DoSetup = true;
3903 }
3904 if (DoSetup)
3905 Setup();
3906 }
3907 }
3908 }
3909 if (state == osBack && Key == kOk) {
3910 if (::Setup.VideoDisplayFormat != oldVideoDisplayFormat)
3912 if (::Setup.VideoFormat != oldVideoFormat)
3914 if (::Setup.DisplaySubtitles != oldDisplaySubtitles)
3917 }
3918 return state;
3919}
3920
3921// --- cMenuSetupLNB ---------------------------------------------------------
3922
3924private:
3926 void Setup(void);
3927public:
3928 cMenuSetupLNB(void);
3929 virtual eOSState ProcessKey(eKeys Key) override;
3930 };
3931
3934{
3936 satCableNumbers.FromString(data.DeviceBondings);
3937 SetSection(tr("LNB"));
3938 Setup();
3939}
3940
3942{
3943 int current = Current();
3944
3945 Clear();
3946
3947 Add(new cMenuEditBoolItem(tr("Setup.LNB$Use DiSEqC"), &data.DiSEqC));
3948 if (!data.DiSEqC) {
3949 Add(new cMenuEditIntItem( tr("Setup.LNB$SLOF (MHz)"), &data.LnbSLOF));
3950 Add(new cMenuEditIntItem( tr("Setup.LNB$Low LNB frequency (MHz)"), &data.LnbFrequLo));
3951 Add(new cMenuEditIntItem( tr("Setup.LNB$High LNB frequency (MHz)"), &data.LnbFrequHi));
3952 }
3953
3954 int NumSatDevices = 0;
3955 for (int i = 0; i < cDevice::NumDevices(); i++) {
3956 if (cDevice::GetDevice(i)->ProvidesSource(cSource::stSat))
3957 NumSatDevices++;
3958 }
3959 if (NumSatDevices > 1) {
3960 for (int i = 0; i < cDevice::NumDevices(); i++) {
3961 if (cDevice::GetDevice(i)->ProvidesSource(cSource::stSat))
3962 Add(new cMenuEditIntItem(cString::sprintf(tr("Setup.LNB$Device %d connected to sat cable"), i + 1), &satCableNumbers.Array()[i], 0, NumSatDevices, tr("Setup.LNB$own")));
3963 else
3964 satCableNumbers.Array()[i] = 0;
3965 }
3966 }
3967
3968 Add(new cMenuEditBoolItem(tr("Setup.LNB$Use dish positioner"), &data.UsePositioner));
3969 if (data.UsePositioner) {
3970 Add(new cMenuEditIntxItem(tr("Setup.LNB$Site latitude (degrees)"), &data.SiteLat, -900, 900, 10, tr("South"), tr("North")));
3971 Add(new cMenuEditIntxItem(tr("Setup.LNB$Site longitude (degrees)"), &data.SiteLon, -1800, 1800, 10, tr("West"), tr("East")));
3972 Add(new cMenuEditIntxItem(tr("Setup.LNB$Max. positioner swing (degrees)"), &data.PositionerSwing, 0, 900, 10));
3973 Add(new cMenuEditIntxItem(tr("Setup.LNB$Positioner speed (degrees/s)"), &data.PositionerSpeed, 1, 1800, 10));
3974 }
3975
3977 Display();
3978}
3979
3981{
3982 int oldDiSEqC = data.DiSEqC;
3983 int oldUsePositioner = data.UsePositioner;
3984 bool DeviceBondingsChanged = false;
3985 if (Key == kOk) {
3986 cString NewDeviceBondings = satCableNumbers.ToString();
3987 DeviceBondingsChanged = strcmp(data.DeviceBondings, NewDeviceBondings) != 0;
3988 data.DeviceBondings = NewDeviceBondings;
3989 }
3991
3992 if (Key != kNone && (data.DiSEqC != oldDiSEqC || data.UsePositioner != oldUsePositioner))
3993 Setup();
3994 else if (DeviceBondingsChanged)
3995 cDvbDevice::BondDevices(data.DeviceBondings);
3996 return state;
3997}
3998
3999// --- cMenuSetupCAM ---------------------------------------------------------
4000
4002private:
4004public:
4006 cCamSlot *CamSlot(void) { return camSlot; }
4007 bool Changed(void);
4008 };
4009
4016
4018{
4019 cString AssignedDevice("");
4020 const char *Activating = "";
4021 const char *CamName = camSlot->GetCamName();
4022 if (!CamName) {
4023 switch (camSlot->ModuleStatus()) {
4024 case msReset: CamName = tr("CAM reset"); break;
4025 case msPresent: CamName = tr("CAM present"); break;
4026 case msReady: CamName = tr("CAM ready"); break;
4027 default: CamName = "-"; break;
4028 }
4029 }
4030 else if (camSlot->IsActivating())
4031 // TRANSLATORS: note the leading blank!
4032 Activating = tr(" (activating)");
4033 cVector<int> DeviceNumbers;
4034 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
4035 if (CamSlot == camSlot || CamSlot->MasterSlot() == camSlot)
4036 CamSlot->Devices(DeviceNumbers);
4037 }
4038 if (DeviceNumbers.Size() > 0) {
4039 AssignedDevice = cString::sprintf(" %s", tr("@ device"));
4040 DeviceNumbers.Sort(CompareInts);
4041 for (int i = 0; i < DeviceNumbers.Size(); i++)
4042 AssignedDevice = cString::sprintf("%s %d", *AssignedDevice, DeviceNumbers[i]);
4043 }
4044
4045 cString buffer = cString::sprintf(" %d %s%s%s", camSlot->SlotNumber(), CamName, *AssignedDevice, Activating);
4046 if (strcmp(buffer, Text()) != 0) {
4047 SetText(buffer);
4048 return true;
4049 }
4050 return false;
4051}
4052
4054private:
4056 const char *activationHelp;
4057 eOSState Menu(void);
4058 eOSState Reset(void);
4059 eOSState Activate(void);
4060 void SetHelpKeys(void);
4061public:
4062 cMenuSetupCAM(void);
4063 virtual eOSState ProcessKey(eKeys Key) override;
4064 };
4065
4067{
4069 activationHelp = NULL;
4071 SetSection(tr("CAM"));
4072 SetCols(15);
4073 SetHasHotkeys();
4074 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
4075 if (CamSlot->IsMasterSlot()) // we only list master CAM slots
4076 Add(new cMenuSetupCAMItem(CamSlot));
4077 }
4078 SetHelpKeys();
4079}
4080
4082{
4083 if (HasSubMenu())
4084 return;
4086 const char *NewActivationHelp = "";
4087 if (item) {
4088 cCamSlot *CamSlot = item->CamSlot();
4089 if (CamSlot->IsActivating())
4090 NewActivationHelp = tr("Button$Cancel activation");
4091 else if (CamSlot->CanActivate())
4092 NewActivationHelp = tr("Button$Activate");
4093 }
4094 if (NewActivationHelp != activationHelp) {
4095 activationHelp = NewActivationHelp;
4096 SetHelp(tr("Button$Menu"), tr("Button$Reset"), activationHelp);
4097 }
4098}
4099
4101{
4103 if (item) {
4104 if (item->CamSlot()->EnterMenu()) {
4105 Skins.Message(mtStatus, tr("Opening CAM menu..."));
4106 time_t t0 = time(NULL);
4107 time_t t1 = t0;
4108 while (time(NULL) - t0 <= MAXWAITFORCAMMENU) {
4109 if (item->CamSlot()->HasUserIO())
4110 break;
4111 if (time(NULL) - t1 >= CAMMENURETRYTIMEOUT) {
4112 dsyslog("CAM %d: retrying to enter CAM menu...", item->CamSlot()->SlotNumber());
4113 item->CamSlot()->EnterMenu();
4114 t1 = time(NULL);
4115 }
4116 cCondWait::SleepMs(100);
4117 }
4118 Skins.Message(mtStatus, NULL);
4119 if (item->CamSlot()->HasUserIO())
4120 return AddSubMenu(new cMenuCam(item->CamSlot()));
4121 }
4122 Skins.Message(mtError, tr("Can't open CAM menu!"));
4123 }
4124 return osContinue;
4125}
4126
4128{
4130 if (item) {
4131 cCamSlot *CamSlot = item->CamSlot();
4132 if (CamSlot->IsActivating())
4133 CamSlot->CancelActivation();
4134 else if (CamSlot->CanActivate()) {
4135 if (CamSlot->Priority() < LIVEPRIORITY) { // don't interrupt recordings
4137 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel())) {
4138 for (int i = 0; i < cDevice::NumDevices(); i++) {
4139 if (cDevice *Device = cDevice::GetDevice(i)) {
4140 if (Device->ProvidesChannel(Channel)) {
4141 if (Device->Priority() < LIVEPRIORITY) { // don't interrupt recordings
4142 if (CamSlot->Assign(Device, true)) { // query
4143 cControl::Shutdown(); // must end transfer mode before assigning CAM, otherwise it might be unassigned again
4144 CamSlot = CamSlot->MtdSpawn();
4145 if (CamSlot->Assign(Device)) {
4146 if (Device->SwitchChannel(Channel, true)) {
4147 CamSlot->StartActivation();
4148 return osContinue;
4149 }
4150 }
4151 }
4152 }
4153 }
4154 }
4155 }
4156 }
4157 }
4158 Skins.Message(mtError, tr("Can't activate CAM!"));
4159 }
4160 }
4161 return osContinue;
4162}
4163
4165{
4167 if (item) {
4168 if (!item->CamSlot()->Device() || Interface->Confirm(tr("CAM is in use - really reset?"))) {
4169 if (!item->CamSlot()->Reset())
4170 Skins.Message(mtError, tr("Can't reset CAM!"));
4171 }
4172 }
4173 return osContinue;
4174}
4175
4177{
4179
4180 if (!HasSubMenu()) {
4181 switch (Key) {
4182 case kOk:
4183 case kRed: return Menu();
4184 case kGreen: state = Reset(); break;
4185 case kYellow: state = Activate(); break;
4186 default: break;
4187 }
4188 for (cMenuSetupCAMItem *ci = (cMenuSetupCAMItem *)First(); ci; ci = (cMenuSetupCAMItem *)ci->Next()) {
4189 if (ci->Changed())
4190 DisplayItem(ci);
4191 }
4192 SetHelpKeys();
4193 }
4195 state = osEnd;
4196 return state;
4197}
4198
4199// --- cMenuSetupRecord ------------------------------------------------------
4200
4202private:
4205 const char *delTimeshiftRecTexts[3];
4206public:
4207 cMenuSetupRecord(void);
4208 };
4209
4211{
4213 recordKeyHandlingTexts[0] = tr("no instant recording");
4214 recordKeyHandlingTexts[1] = tr("confirm instant recording");
4215 recordKeyHandlingTexts[2] = tr("record instantly");
4216 pauseKeyHandlingTexts[0] = tr("do not pause live video");
4217 pauseKeyHandlingTexts[1] = tr("confirm pause live video");
4218 pauseKeyHandlingTexts[2] = tr("pause live video");
4219 delTimeshiftRecTexts[0] = tr("no");
4220 delTimeshiftRecTexts[1] = tr("confirm");
4221 delTimeshiftRecTexts[2] = tr("yes");
4222 SetSection(tr("Recording"));
4223 Add(new cMenuEditIntItem( tr("Setup.Recording$Margin at start (min)"), &data.MarginStart));
4224 Add(new cMenuEditIntItem( tr("Setup.Recording$Margin at stop (min)"), &data.MarginStop));
4225 Add(new cMenuEditIntItem( tr("Setup.Recording$Default priority"), &data.DefaultPriority, 0, MAXPRIORITY));
4226 Add(new cMenuEditIntItem( tr("Setup.Recording$Default lifetime (d)"), &data.DefaultLifetime, 0, MAXLIFETIME));
4227 Add(new cMenuEditStraItem(tr("Setup.Recording$Record key handling"), &data.RecordKeyHandling, 3, recordKeyHandlingTexts));
4228 Add(new cMenuEditStraItem(tr("Setup.Recording$Pause key handling"), &data.PauseKeyHandling, 3, pauseKeyHandlingTexts));
4229 Add(new cMenuEditIntItem( tr("Setup.Recording$Pause priority"), &data.PausePriority, 0, MAXPRIORITY));
4230 Add(new cMenuEditIntItem( tr("Setup.Recording$Pause lifetime (d)"), &data.PauseLifetime, 0, MAXLIFETIME));
4231 Add(new cMenuEditBoolItem(tr("Setup.Recording$Use episode name"), &data.UseSubtitle));
4232 Add(new cMenuEditBoolItem(tr("Setup.Recording$Use VPS"), &data.UseVps));
4233 Add(new cMenuEditIntItem( tr("Setup.Recording$VPS margin (s)"), &data.VpsMargin, 0));
4234 Add(new cMenuEditBoolItem(tr("Setup.Recording$Mark instant recording"), &data.MarkInstantRecord));
4235 Add(new cMenuEditStrItem( tr("Setup.Recording$Name instant recording"), data.NameInstantRecord, sizeof(data.NameInstantRecord)));
4236 Add(new cMenuEditIntItem( tr("Setup.Recording$Instant rec. time (min)"), &data.InstantRecordTime, 0, MAXINSTANTRECTIME, tr("Setup.Recording$present event")));
4237 Add(new cMenuEditIntItem( tr("Setup.Recording$Max. video file size (MB)"), &data.MaxVideoFileSize, MINVIDEOFILESIZE, MAXVIDEOFILESIZETS));
4238 Add(new cMenuEditBoolItem(tr("Setup.Recording$Split edited files"), &data.SplitEditedFiles));
4239 Add(new cMenuEditStraItem(tr("Setup.Recording$Delete timeshift recording"),&data.DelTimeshiftRec, 3, delTimeshiftRecTexts));
4240}
4241
4242// --- cMenuSetupReplay ------------------------------------------------------
4243
4245protected:
4246 virtual void Store(void) override;
4247public:
4248 cMenuSetupReplay(void);
4249 };
4250
4252{
4254 SetSection(tr("Replay"));
4255 Add(new cMenuEditBoolItem(tr("Setup.Replay$Multi speed mode"), &data.MultiSpeedMode));
4256 Add(new cMenuEditBoolItem(tr("Setup.Replay$Show replay mode"), &data.ShowReplayMode));
4257 Add(new cMenuEditBoolItem(tr("Setup.Replay$Show remaining time"), &data.ShowRemainingTime));
4258 Add(new cMenuEditIntItem( tr("Setup.Replay$Progress display time (s)"), &data.ProgressDisplayTime, 0, 60));
4259 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay when setting mark"), &data.PauseOnMarkSet));
4260 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay when jumping to a mark"), &data.PauseOnMarkJump));
4261 Add(new cMenuEditBoolItem(tr("Setup.Replay$Skip edited parts"), &data.SkipEdited));
4262 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay at last mark"), &data.PauseAtLastMark));
4263 Add(new cMenuEditIntItem( tr("Setup.Replay$Initial duration for adaptive skipping (s)"), &data.AdaptiveSkipInitial, 10, 600));
4264 Add(new cMenuEditIntItem( tr("Setup.Replay$Reset timeout for adaptive skipping (s)"), &data.AdaptiveSkipTimeout, 0, 10));
4265 Add(new cMenuEditBoolItem(tr("Setup.Replay$Alternate behavior for adaptive skipping"), &data.AdaptiveSkipAlternate));
4266 Add(new cMenuEditBoolItem(tr("Setup.Replay$Use Prev/Next keys for adaptive skipping"), &data.AdaptiveSkipPrevNext));
4267 Add(new cMenuEditIntItem( tr("Setup.Replay$Skip distance with Green/Yellow keys (s)"), &data.SkipSeconds, 5, 600));
4268 Add(new cMenuEditIntItem( tr("Setup.Replay$Skip distance with Green/Yellow keys in repeat (s)"), &data.SkipSecondsRepeat, 5, 600));
4269 Add(new cMenuEditIntItem(tr("Setup.Replay$Resume ID"), &data.ResumeID, 0, 99));
4270}
4271
4273{
4274 if (Setup.ResumeID != data.ResumeID) {
4276 Recordings->ResetResume();
4277 }
4279}
4280
4281// --- cMenuSetupMisc --------------------------------------------------------
4282
4284private:
4288 void Set(void);
4289public:
4290 cMenuSetupMisc(void);
4291 virtual eOSState ProcessKey(eKeys Key) override;
4292 };
4293
4295{
4297 svdrpPeeringModeTexts[0] = tr("off");
4298 svdrpPeeringModeTexts[1] = tr("any hosts");
4299 svdrpPeeringModeTexts[2] = tr("only default host");
4303 SetSection(tr("Miscellaneous"));
4304 Set();
4305}
4306
4308{
4309 int current = Current();
4310 Clear();
4311 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Min. event timeout (min)"), &data.MinEventTimeout));
4312 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Min. user inactivity (min)"), &data.MinUserInactivity));
4313 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$SVDRP timeout (s)"), &data.SVDRPTimeout));
4314 Add(new cMenuEditStraItem(tr("Setup.Miscellaneous$SVDRP peering"), &data.SVDRPPeering, 3, svdrpPeeringModeTexts));
4315 if (data.SVDRPPeering) {
4316 Add(new cMenuEditStrItem( tr("Setup.Miscellaneous$SVDRP host name"), data.SVDRPHostName, sizeof(data.SVDRPHostName)));
4318 svdrpServerNames.Sort(true);
4319 svdrpServerNames.Insert(strdup(""));
4320 Add(new cMenuEditStrlItem(tr("Setup.Miscellaneous$SVDRP default host"), data.SVDRPDefaultHost, sizeof(data.SVDRPDefaultHost), &svdrpServerNames));
4321 }
4322 }
4323 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Zap timeout (s)"), &data.ZapTimeout));
4324 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Channel entry timeout (ms)"), &data.ChannelEntryTimeout, 0));
4325 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Remote control repeat delay (ms)"), &data.RcRepeatDelay, 0));
4326 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Remote control repeat delta (ms)"), &data.RcRepeatDelta, 0));
4327 Add(new cMenuEditChanItem(tr("Setup.Miscellaneous$Initial channel"), &data.InitialChannel, tr("Setup.Miscellaneous$as before")));
4328 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Initial volume"), &data.InitialVolume, -1, 255, tr("Setup.Miscellaneous$as before")));
4329 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Volume steps"), &data.VolumeSteps, 5, 255));
4330 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Volume linearize"), &data.VolumeLinearize, -20, 20));
4331 Add(new cMenuEditBoolItem(tr("Setup.Miscellaneous$Channels wrap"), &data.ChannelsWrap));
4332 Add(new cMenuEditStraItem(tr("Setup.Miscellaneous$Show channel names with source"), &data.ShowChannelNamesWithSource, 3, showChannelNamesWithSourceTexts));
4333 Add(new cMenuEditBoolItem(tr("Setup.Miscellaneous$Emergency exit"), &data.EmergencyExit));
4335 Display();
4336}
4337
4339{
4340 bool OldSVDRPPeering = data.SVDRPPeering;
4341 bool ModifiedSVDRPSettings = false;
4342 bool ModifiedShowChannelNamesWithSource = false;
4343 if (Key == kOk) {
4344 ModifiedSVDRPSettings = data.SVDRPPeering != Setup.SVDRPPeering || strcmp(data.SVDRPHostName, Setup.SVDRPHostName);
4345 ModifiedShowChannelNamesWithSource = data.ShowChannelNamesWithSource != Setup.ShowChannelNamesWithSource;
4346 }
4348 if (ModifiedShowChannelNamesWithSource) {
4350 for (cChannel *Channel = Channels->First(); Channel; Channel = Channels->Next(Channel))
4351 Channel->UpdateNameSource();
4352 }
4353 if (data.SVDRPPeering != OldSVDRPPeering)
4354 Set();
4355 if (ModifiedSVDRPSettings) {
4357 {
4359 Timers->SetExplicitModify();
4360 if (Timers->StoreRemoteTimers(NULL, NULL))
4361 Timers->SetModified();
4362 }
4364 }
4365 return state;
4366}
4367
4368// --- cMenuSetupPluginItem --------------------------------------------------
4369
4371private:
4373public:
4374 cMenuSetupPluginItem(const char *Name, int Index);
4375 int PluginIndex(void) { return pluginIndex; }
4376 };
4377
4379:cOsdItem(Name)
4380{
4382}
4383
4384// --- cMenuSetupPlugins -----------------------------------------------------
4385
4387public:
4388 cMenuSetupPlugins(void);
4389 virtual eOSState ProcessKey(eKeys Key) override;
4390 };
4391
4393{
4395 SetSection(tr("Plugins"));
4396 SetHasHotkeys();
4397 for (int i = 0; ; i++) {
4399 if (p)
4400 Add(new cMenuSetupPluginItem(hk(cString::sprintf("%s (%s) - %s", p->Name(), p->Version(), p->Description())), i));
4401 else
4402 break;
4403 }
4404}
4405
4407{
4409
4410 if (Key == kOk) {
4411 if (state == osUnknown) {
4413 if (item) {
4415 if (p) {
4416 cMenuSetupPage *menu = p->SetupMenu();
4417 if (menu) {
4418 menu->SetPlugin(p);
4419 return AddSubMenu(menu);
4420 }
4421 Skins.Message(mtInfo, tr("This plugin has no setup parameters!"));
4422 }
4423 }
4424 }
4425 else if (state == osContinue) {
4426 Store();
4427 // Reinitialize OSD and skin, in case any plugin setup change has an influence on these:
4429 Display();
4430 }
4431 }
4432 return state;
4433}
4434
4435// --- cMenuSetup ------------------------------------------------------------
4436
4437class cMenuSetup : public cOsdMenu {
4438private:
4439 virtual void Set(void);
4440 eOSState Restart(void);
4441public:
4442 cMenuSetup(void);
4443 virtual eOSState ProcessKey(eKeys Key) override;
4444 };
4445
4447:cOsdMenu("")
4448{
4450 Set();
4451}
4452
4454{
4455 Clear();
4456 char buffer[64];
4457 snprintf(buffer, sizeof(buffer), "%s - VDR %s", tr("Setup"), VDRVERSION);
4458 SetTitle(buffer);
4459 SetHasHotkeys();
4460 Add(new cOsdItem(hk(tr("OSD")), osUser1));
4461 Add(new cOsdItem(hk(tr("EPG")), osUser2));
4462 Add(new cOsdItem(hk(tr("DVB")), osUser3));
4463 Add(new cOsdItem(hk(tr("LNB")), osUser4));
4464 Add(new cOsdItem(hk(tr("CAM")), osUser5));
4465 Add(new cOsdItem(hk(tr("Recording")), osUser6));
4466 Add(new cOsdItem(hk(tr("Replay")), osUser7));
4467 Add(new cOsdItem(hk(tr("Miscellaneous")), osUser8));
4469 Add(new cOsdItem(hk(tr("Plugins")), osUser9));
4470 Add(new cOsdItem(hk(tr("Restart")), osUser10));
4471}
4472
4474{
4475 if (Interface->Confirm(tr("Really restart?")) && ShutdownHandler.ConfirmRestart(true)) {
4476 ShutdownHandler.Exit(1);
4477 return osEnd;
4478 }
4479 return osContinue;
4480}
4481
4483{
4484 int osdLanguage = I18nCurrentLanguage();
4485 eOSState state = cOsdMenu::ProcessKey(Key);
4486
4487 switch (state) {
4488 case osUser1: return AddSubMenu(new cMenuSetupOSD);
4489 case osUser2: return AddSubMenu(new cMenuSetupEPG);
4490 case osUser3: return AddSubMenu(new cMenuSetupDVB);
4491 case osUser4: return AddSubMenu(new cMenuSetupLNB);
4492 case osUser5: return AddSubMenu(new cMenuSetupCAM);
4493 case osUser6: return AddSubMenu(new cMenuSetupRecord);
4494 case osUser7: return AddSubMenu(new cMenuSetupReplay);
4495 case osUser8: return AddSubMenu(new cMenuSetupMisc);
4496 case osUser9: return AddSubMenu(new cMenuSetupPlugins);
4497 case osUser10: return Restart();
4498 default: ;
4499 }
4500 if (I18nCurrentLanguage() != osdLanguage) {
4501 Set();
4502 if (!HasSubMenu())
4503 Display();
4504 }
4505 return state;
4506}
4507
4508// --- cMenuPluginItem -------------------------------------------------------
4509
4511private:
4513public:
4514 cMenuPluginItem(const char *Name, int Index);
4515 int PluginIndex(void) { return pluginIndex; }
4516 };
4517
4519:cOsdItem(Name, osPlugin)
4520{
4522}
4523
4524// --- cMenuMain -------------------------------------------------------------
4525
4526// TRANSLATORS: note the leading and trailing blanks!
4527#define STOP_RECORDING trNOOP(" Stop recording ")
4528
4530
4531cMenuMain::cMenuMain(eOSState State, bool OpenSubMenus)
4532:cOsdMenu("")
4533{
4535 replaying = false;
4536 stopReplayItem = NULL;
4537 cancelEditingItem = NULL;
4538 stopRecordingItem = NULL;
4540 Set();
4541
4542 // Initial submenus:
4543
4544 cOsdObject *menu = NULL;
4545 switch (State) {
4546 case osSchedule:
4547 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu))
4548 menu = new cMenuSchedule;
4549 break;
4550 case osChannels:
4551 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu))
4552 menu = new cMenuChannels;
4553 break;
4554 case osTimers:
4555 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu))
4556 menu = new cMenuTimers;
4557 break;
4558 case osRecordings:
4559 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu))
4560 menu = new cMenuRecordings(NULL, 0, OpenSubMenus);
4561 break;
4562 case osSetup: menu = new cMenuSetup; break;
4563 case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break;
4564 default: break;
4565 }
4566 if (menu)
4567 if (menu->IsMenu())
4568 AddSubMenu((cOsdMenu *) menu);
4569}
4570
4572{
4574 pluginOsdObject = NULL;
4575 return o;
4576}
4577
4579{
4580 Clear();
4581 SetTitle("VDR");
4582 SetHasHotkeys();
4583
4584 // Basic menu items:
4585
4586 Add(new cOsdItem(hk(tr("Schedule")), osSchedule));
4587 Add(new cOsdItem(hk(tr("Channels")), osChannels));
4588 Add(new cOsdItem(hk(tr("Timers")), osTimers));
4589 Add(new cOsdItem(hk(tr("Recordings")), osRecordings));
4590
4591 // Plugins:
4592
4593 for (int i = 0; ; i++) {
4595 if (p) {
4596 const char *item = p->MainMenuEntry();
4597 if (item)
4598 Add(new cMenuPluginItem(hk(item), i));
4599 }
4600 else
4601 break;
4602 }
4603
4604 // More basic menu items:
4605
4606 Add(new cOsdItem(hk(tr("Setup")), osSetup));
4607 if (Commands.Count())
4608 Add(new cOsdItem(hk(tr("Commands")), osCommands));
4609
4610 Update(true);
4611
4612 Display();
4613}
4614
4615bool cMenuMain::Update(bool Force)
4616{
4617 bool result = false;
4618
4619 bool NewReplaying = false;
4620 {
4621 cMutexLock ControlMutexLock;
4622 NewReplaying = cControl::Control(ControlMutexLock) != NULL;
4623 }
4624 if (Force || NewReplaying != replaying) {
4625 replaying = NewReplaying;
4626 // Replay control:
4627 if (replaying && !stopReplayItem)
4628 // TRANSLATORS: note the leading blank!
4629 Add(stopReplayItem = new cOsdItem(tr(" Stop replaying"), osStopReplay));
4630 else if (stopReplayItem && !replaying) {
4631 Del(stopReplayItem->Index());
4632 stopReplayItem = NULL;
4633 }
4634 // Color buttons:
4635 SetHelp(!replaying && Setup.RecordKeyHandling ? tr("Button$Record") : NULL, tr("Button$Audio"), replaying || !Setup.PauseKeyHandling ? NULL : tr("Button$Pause"), replaying ? tr("Button$Stop") : cReplayControl::LastReplayed() ? tr("Button$Resume") : tr("Button$Play"));
4636 result = true;
4637 }
4638
4639 // Editing control:
4640 bool EditingActive = RecordingsHandler.Active();
4641 if (EditingActive && !cancelEditingItem) {
4642 // TRANSLATORS: note the leading blank!
4643 Add(cancelEditingItem = new cOsdItem(tr(" Cancel editing"), osCancelEdit));
4644 result = true;
4645 }
4646 else if (cancelEditingItem && !EditingActive) {
4647 Del(cancelEditingItem->Index());
4648 cancelEditingItem = NULL;
4649 result = true;
4650 }
4651
4652 // Record control:
4654 while (stopRecordingItem) {
4656 Del(stopRecordingItem->Index());
4657 stopRecordingItem = it;
4658 }
4659 const char *s = NULL;
4660 while ((s = cRecordControls::GetInstantId(s)) != NULL) {
4661 cOsdItem *item = new cOsdItem(osStopRecord);
4662 item->SetText(cString::sprintf("%s%s", tr(STOP_RECORDING), s));
4663 Add(item);
4664 if (!stopRecordingItem)
4665 stopRecordingItem = item;
4666 }
4667 result = true;
4668 }
4669
4670 return result;
4671}
4672
4674{
4675 bool HadSubMenu = HasSubMenu();
4676 int osdLanguage = I18nCurrentLanguage();
4677 eOSState state = cOsdMenu::ProcessKey(Key);
4678 HadSubMenu |= HasSubMenu();
4679
4680 cOsdObject *menu = NULL;
4681 switch (state) {
4682 case osSchedule:
4683 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu))
4684 menu = new cMenuSchedule;
4685 else
4686 state = osContinue;
4687 break;
4688 case osChannels:
4689 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu))
4690 menu = new cMenuChannels;
4691 else
4692 state = osContinue;
4693 break;
4694 case osTimers:
4695 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu))
4696 menu = new cMenuTimers;
4697 else
4698 state = osContinue;
4699 break;
4700 case osRecordings:
4701 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu))
4702 menu = new cMenuRecordings;
4703 else
4704 state = osContinue;
4705 break;
4706 case osSetup: menu = new cMenuSetup; break;
4707 case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break;
4708 case osStopRecord: if (Interface->Confirm(tr("Stop recording?"))) {
4709 if (cOsdItem *item = Get(Current())) {
4710 cRecordControls::Stop(item->Text() + strlen(tr(STOP_RECORDING)));
4711 return osEnd;
4712 }
4713 }
4714 break;
4715 case osCancelEdit: if (Interface->Confirm(tr("Cancel editing?"))) {
4716 RecordingsHandler.DelAll();
4717 return osEnd;
4718 }
4719 break;
4720 case osPlugin: {
4722 if (item) {
4724 if (p) {
4725 cOsdObject *menu = p->MainMenuAction();
4726 if (menu) {
4727 if (menu->IsMenu())
4728 return AddSubMenu((cOsdMenu *)menu);
4729 else {
4730 pluginOsdObject = menu;
4731 return osPlugin;
4732 }
4733 }
4734 }
4735 }
4736 state = osEnd;
4737 }
4738 break;
4739 default: switch (Key) {
4740 case kRecord:
4741 case kRed: if (!HadSubMenu)
4742 state = replaying || !Setup.RecordKeyHandling ? osContinue : osRecord;
4743 break;
4744 case kGreen: if (!HadSubMenu) {
4745 cRemote::Put(kAudio, true);
4746 state = osEnd;
4747 }
4748 break;
4749 case kYellow: if (!HadSubMenu)
4750 state = replaying || !Setup.PauseKeyHandling ? osContinue : osPause;
4751 break;
4752 case kBlue: if (!HadSubMenu)
4754 break;
4755 default: break;
4756 }
4757 }
4758 if (menu) {
4759 if (menu->IsMenu())
4760 return AddSubMenu((cOsdMenu *) menu);
4761 pluginOsdObject = menu;
4762 return osPlugin;
4763 }
4764 bool DoDisplay = Update();
4765 if (Key != kNone) {
4766 if (I18nCurrentLanguage() != osdLanguage) {
4767 Set();
4768 if (!HasSubMenu())
4769 DoDisplay = true;
4770 }
4771 }
4772 if (DoDisplay)
4773 Display();
4774 return state;
4775}
4776
4777// --- SetTrackDescriptions --------------------------------------------------
4778
4779void SetTrackDescriptions(int LiveChannel)
4780{
4782 const cComponents *Components = NULL;
4783 if (LiveChannel) {
4785 if (const cChannel *Channel = Channels->GetByNumber(LiveChannel)) {
4787 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
4788 const cEvent *Present = Schedule->GetPresentEvent();
4789 if (Present)
4790 Components = Present->Components();
4791 }
4792 }
4793 }
4794 else if (cReplayControl::NowReplaying()) {
4796 if (const cRecording *Recording = Recordings->GetByName(cReplayControl::NowReplaying()))
4797 Components = Recording->Info()->Components();
4798 }
4799 if (Components) {
4800 int indexAudio = 0;
4801 int indexDolby = 0;
4802 int indexSubtitle = 0;
4803 for (int i = 0; i < Components->NumComponents(); i++) {
4804 const tComponent *p = Components->Component(i);
4805 switch (p->stream) {
4806 case 2: if (p->type == 0x05)
4807 cDevice::PrimaryDevice()->SetAvailableTrack(ttDolby, indexDolby++, 0, LiveChannel ? NULL : p->language, p->description);
4808 else
4809 cDevice::PrimaryDevice()->SetAvailableTrack(ttAudio, indexAudio++, 0, LiveChannel ? NULL : p->language, p->description);
4810 break;
4811 case 3: cDevice::PrimaryDevice()->SetAvailableTrack(ttSubtitle, indexSubtitle++, 0, LiveChannel ? NULL : p->language, p->description);
4812 break;
4813 case 4: cDevice::PrimaryDevice()->SetAvailableTrack(ttDolby, indexDolby++, 0, LiveChannel ? NULL : p->language, p->description);
4814 break;
4815 default: ;
4816 }
4817 }
4818 }
4819}
4820
4821// --- cDisplayChannel -------------------------------------------------------
4822
4824
4825cDisplayChannel::cDisplayChannel(int Number, bool Switched)
4826:cOsdObject(true)
4827{
4828 currentDisplayChannel = this;
4829 group = -1;
4830 withInfo = !Switched || Setup.ShowInfoOnChSwitch;
4832 number = 0;
4833 timeout = Switched || Setup.TimeoutRequChInfo;
4834 cOsdProvider::OsdSizeChanged(osdState); // just to get the current state
4835 positioner = NULL;
4836 channel = NULL;
4837 {
4839 channel = Channels->GetByNumber(Number);
4840 lastPresent = lastFollowing = NULL;
4841 if (channel) {
4843 DisplayInfo();
4844 }
4845 }
4846 if (channel)
4847 displayChannel->Flush();
4848 lastTime.Set();
4849}
4850
4852:cOsdObject(true)
4853{
4854 currentDisplayChannel = this;
4855 group = -1;
4856 number = 0;
4857 timeout = true;
4858 lastPresent = lastFollowing = NULL;
4859 cOsdProvider::OsdSizeChanged(osdState); // just to get the current state
4860 lastTime.Set();
4861 withInfo = Setup.ShowInfoOnChSwitch;
4862 displayChannel = Skins.Current()->DisplayChannel(withInfo);
4863 positioner = NULL;
4864 channel = NULL;
4865 {
4867 channel = Channels->GetByNumber(cDevice::CurrentChannel());
4868 }
4869 ProcessKey(FirstKey);
4870}
4871
4878
4886
4888{
4889 if (withInfo && channel) {
4891 if (const cSchedule *Schedule = Schedules->GetSchedule(channel)) {
4892 const cEvent *Present = Schedule->GetPresentEvent();
4893 const cEvent *Following = Schedule->GetFollowingEvent();
4894 if (Present != lastPresent || Following != lastFollowing) {
4895 SetTrackDescriptions(channel->Number());
4896 displayChannel->SetEvents(Present, Following);
4897 cStatus::MsgOsdProgramme(Present ? Present->StartTime() : 0, Present ? Present->Title() : NULL, Present ? Present->ShortText() : NULL, Following ? Following->StartTime() : 0, Following ? Following->Title() : NULL, Following ? Following->ShortText() : NULL);
4898 lastPresent = Present;
4899 lastFollowing = Following;
4900 lastTime.Set();
4901 }
4902 }
4903 }
4904}
4905
4907{
4909 displayChannel->SetEvents(NULL, NULL);
4910}
4911
4912const cChannel *cDisplayChannel::NextAvailableChannel(const cChannel *Channel, int Direction)
4913{
4914 if (Direction) {
4915 cControl::Shutdown(); // prevents old channel from being shown too long if GetDevice() takes longer
4916 // and, if decrypted, this removes the now superfluous PIDs from the CAM, too
4918 while (Channel) {
4919 Channel = Direction > 0 ? Channels->Next(Channel) : Channels->Prev(Channel);
4920 if (!Channel && Setup.ChannelsWrap)
4921 Channel = Direction > 0 ? Channels->First() : Channels->Last();
4922 if (Channel && !Channel->GroupSep() && cDevice::GetDevice(Channel, LIVEPRIORITY, true, true))
4923 return Channel;
4924 }
4925 }
4926 return NULL;
4927}
4928
4930{
4932 delete displayChannel;
4933 displayChannel = Skins.Current()->DisplayChannel(withInfo);
4934 }
4935 const cChannel *NewChannel = NULL;
4936 if (Key != kNone)
4937 lastTime.Set();
4938 switch (int(Key)) {
4939 case k0:
4940 if (number == 0) {
4941 // keep the "Toggle channels" function working
4942 cRemote::Put(Key);
4943 return osEnd;
4944 }
4945 case k1 ... k9:
4946 group = -1;
4947 if (number >= 0) {
4949 number = Key - k0;
4950 else
4951 number = number * 10 + Key - k0;
4953 channel = Channels->GetByNumber(number);
4954 Refresh();
4955 withInfo = false;
4956 // Lets see if there can be any useful further input:
4957 int n = channel ? number * 10 : 0;
4958 int m = 10;
4959 const cChannel *ch = channel;
4960 while (ch && (ch = Channels->Next(ch)) != NULL) {
4961 if (!ch->GroupSep()) {
4962 if (n <= ch->Number() && ch->Number() < n + m) {
4963 n = 0;
4964 break;
4965 }
4966 if (ch->Number() > n) {
4967 n *= 10;
4968 m *= 10;
4969 }
4970 }
4971 }
4972 if (n > 0) {
4973 // This channel is the only one that fits the input, so let's take it right away:
4974 NewChannel = channel;
4975 withInfo = true;
4976 number = 0;
4977 Refresh();
4978 }
4979 }
4980 break;
4981 case kLeft|k_Repeat:
4982 case kLeft:
4983 case kRight|k_Repeat:
4984 case kRight:
4985 case kNext|k_Repeat:
4986 case kNext:
4987 case kPrev|k_Repeat:
4988 case kPrev: {
4989 withInfo = false;
4990 number = 0;
4992 if (group < 0) {
4993 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel()))
4994 group = Channel->Index();
4995 }
4996 if (group >= 0) {
4997 int SaveGroup = group;
4998 if (NORMALKEY(Key) == kRight || NORMALKEY(Key) == kNext)
4999 group = Channels->GetNextGroup(group) ;
5000 else
5001 group = Channels->GetPrevGroup(group < 1 ? 1 : group);
5002 if (group < 0)
5003 group = SaveGroup;
5004 channel = Channels->Get(group);
5005 if (channel) {
5006 Refresh();
5007 if (!channel->GroupSep())
5008 group = -1;
5009 }
5010 }
5011 break;
5012 }
5013 case kUp|k_Repeat:
5014 case kUp:
5015 case kDown|k_Repeat:
5016 case kDown:
5017 case kChanUp|k_Repeat:
5018 case kChanUp:
5019 case kChanDn|k_Repeat:
5020 case kChanDn: {
5021 eKeys k = NORMALKEY(Key);
5022 if (const cChannel *Channel = NextAvailableChannel(channel, (k == kUp || k == kChanUp) ? 1 : -1))
5023 channel = Channel;
5024 else if (channel && channel->Number() != cDevice::CurrentChannel())
5025 Key = k; // immediately switches channel when hitting the beginning/end of the channel list with k_Repeat
5026 }
5027 // no break here
5028 case kUp|k_Release:
5029 case kDown|k_Release:
5030 case kChanUp|k_Release:
5031 case kChanDn|k_Release:
5032 case kNext|k_Release:
5033 case kPrev|k_Release:
5034 if (!(Key & k_Repeat) && channel && channel->Number() != cDevice::CurrentChannel())
5035 NewChannel = channel;
5036 withInfo = true;
5037 group = -1;
5038 number = 0;
5039 Refresh();
5040 break;
5041 case kNone:
5042 if (number && Setup.ChannelEntryTimeout && int(lastTime.Elapsed()) > Setup.ChannelEntryTimeout) {
5044 channel = Channels->GetByNumber(number);
5045 if (channel)
5046 NewChannel = channel;
5047 withInfo = true;
5048 number = 0;
5049 Refresh();
5050 lastTime.Set();
5051 }
5052 break;
5053 //TODO
5054 //XXX case kGreen: return osEventNow;
5055 //XXX case kYellow: return osEventNext;
5056 case kOk: {
5058 if (group >= 0) {
5059 channel = Channels->Get(Channels->GetNextNormal(group));
5060 if (channel)
5061 NewChannel = channel;
5062 withInfo = true;
5063 group = -1;
5064 Refresh();
5065 }
5066 else if (number > 0) {
5067 channel = Channels->GetByNumber(number);
5068 if (channel)
5069 NewChannel = channel;
5070 withInfo = true;
5071 number = 0;
5072 Refresh();
5073 }
5074 else {
5075 return osEnd;
5076 }
5077 }
5078 break;
5079 default:
5080 if ((Key & (k_Repeat | k_Release)) == 0) {
5081 cRemote::Put(Key);
5082 return osEnd;
5083 }
5084 };
5085 if (positioner || !timeout || lastTime.Elapsed() < (uint64_t)(Setup.ChannelInfoTime * 1000)) {
5086 {
5089 // makes sure a channel switch through the SVDRP CHAN command is displayed
5090 channel = Channels->GetByNumber(cDevice::CurrentChannel());
5091 Refresh();
5092 lastTime.Set();
5093 }
5094 DisplayInfo();
5095 if (NewChannel) {
5096 SetTrackDescriptions(NewChannel->Number()); // to make them immediately visible in the channel display
5097 Channels->SwitchTo(NewChannel->Number());
5098 SetTrackDescriptions(NewChannel->Number()); // switching the channel has cleared them
5099 channel = NewChannel;
5100 }
5101 const cPositioner *Positioner = cDevice::ActualDevice()->Positioner();
5102 bool PositionerMoving = Positioner && Positioner->IsMoving();
5103 SetNeedsFastResponse(PositionerMoving);
5104 if (!PositionerMoving) {
5105 if (positioner)
5106 lastTime.Set(); // to keep the channel display up a few seconds after the target position has been reached
5107 Positioner = NULL;
5108 }
5109 if (Positioner || positioner) // making sure we call SetPositioner(NULL) if there is a switch from "with" to "without" positioner
5110 displayChannel->SetPositioner(Positioner);
5111 positioner = Positioner;
5112 }
5113 displayChannel->Flush();
5114 return osContinue;
5115 }
5116 return osEnd;
5117}
5118
5119// --- cDisplayVolume --------------------------------------------------------
5120
5121#define VOLUMETIMEOUT 1000 //ms
5122#define MUTETIMEOUT 5000 //ms
5123
5125
5127:cOsdObject(true)
5128{
5129 currentDisplayVolume = this;
5131 displayVolume = Skins.Current()->DisplayVolume();
5132 Show();
5133}
5134
5140
5142{
5144}
5145
5152
5154{
5156 currentDisplayVolume->ProcessKey(Key);
5157}
5158
5160{
5161 switch (int(Key)) {
5162 case kVolUp|k_Repeat:
5163 case kVolUp:
5164 case kVolDn|k_Repeat:
5165 case kVolDn:
5166 Show();
5168 break;
5169 case kMute:
5170 if (cDevice::PrimaryDevice()->IsMute()) {
5171 Show();
5172 timeout.Set(MUTETIMEOUT);
5173 }
5174 else
5175 timeout.Set();
5176 break;
5177 case kNone: break;
5178 default: if ((Key & k_Release) == 0) {
5179 cRemote::Put(Key);
5180 return osEnd;
5181 }
5182 }
5183 return timeout.TimedOut() ? osEnd : osContinue;
5184}
5185
5186// --- cDisplayTracks --------------------------------------------------------
5187
5188#define TRACKTIMEOUT 5000 //ms
5189
5191
5193:cOsdObject(true)
5194{
5197 currentDisplayTracks = this;
5198 numTracks = track = 0;
5201 for (int i = ttAudioFirst; i <= ttDolbyLast; i++) {
5202 const tTrackId *TrackId = cDevice::PrimaryDevice()->GetTrack(eTrackType(i));
5203 if (TrackId && TrackId->id) {
5205 descriptions[numTracks] = strdup(*TrackId->description ? TrackId->description : *TrackId->language ? TrackId->language : *itoa(i));
5206 if (i == CurrentAudioTrack)
5207 track = numTracks;
5208 numTracks++;
5209 }
5210 }
5211 descriptions[numTracks] = NULL;
5212 timeout.Set(TRACKTIMEOUT);
5213 displayTracks = Skins.Current()->DisplayTracks(tr("Button$Audio"), numTracks, descriptions);
5214 Show();
5215}
5216
5218{
5219 delete displayTracks;
5220 currentDisplayTracks = NULL;
5221 for (int i = 0; i < numTracks; i++)
5222 free(descriptions[i]);
5224}
5225
5227{
5228 int ac = IS_AUDIO_TRACK(types[track]) ? audioChannel : -1;
5229 displayTracks->SetTrack(track, descriptions);
5230 displayTracks->SetAudioChannel(ac);
5231 displayTracks->Flush();
5234}
5235
5237{
5238 if (cDevice::PrimaryDevice()->NumAudioTracks() > 0) {
5240 new cDisplayTracks;
5241 return currentDisplayTracks;
5242 }
5243 Skins.Message(mtWarning, tr("No audio available!"));
5244 return NULL;
5245}
5246
5248{
5250 currentDisplayTracks->ProcessKey(Key);
5251}
5252
5254{
5255 int oldTrack = track;
5256 int oldAudioChannel = audioChannel;
5257 switch (int(Key)) {
5258 case kUp|k_Repeat:
5259 case kUp:
5260 case kDown|k_Repeat:
5261 case kDown:
5262 if (NORMALKEY(Key) == kUp && track > 0)
5263 track--;
5264 else if (NORMALKEY(Key) == kDown && track < numTracks - 1)
5265 track++;
5266 timeout.Set(TRACKTIMEOUT);
5267 break;
5268 case kLeft|k_Repeat:
5269 case kLeft:
5270 case kRight|k_Repeat:
5271 case kRight: if (IS_AUDIO_TRACK(types[track])) {
5272 static int ac[] = { 1, 0, 2 };
5274 if (NORMALKEY(Key) == kLeft && audioChannel > 0)
5275 audioChannel--;
5276 else if (NORMALKEY(Key) == kRight && audioChannel < 2)
5277 audioChannel++;
5279 timeout.Set(TRACKTIMEOUT);
5280 }
5281 break;
5282 case kAudio|k_Repeat:
5283 case kAudio:
5284 if (++track >= numTracks)
5285 track = 0;
5286 timeout.Set(TRACKTIMEOUT);
5287 break;
5288 case kOk:
5289 if (types[track] != cDevice::PrimaryDevice()->GetCurrentAudioTrack())
5290 oldTrack = -1; // make sure we explicitly switch to that track
5291 timeout.Set();
5292 break;
5293 case kNone: break;
5294 default: if ((Key & k_Release) == 0)
5295 return osEnd;
5296 }
5297 if (track != oldTrack || audioChannel != oldAudioChannel)
5298 Show();
5299 if (track != oldTrack) {
5301 Setup.CurrentDolby = IS_DOLBY_TRACK(types[track]);
5302 }
5303 if (audioChannel != oldAudioChannel)
5305 return timeout.TimedOut() ? osEnd : osContinue;
5306}
5307
5308// --- cDisplaySubtitleTracks ------------------------------------------------
5309
5311
5313:cOsdObject(true)
5314{
5316 currentDisplayTracks = this;
5317 numTracks = track = 0;
5319 descriptions[numTracks] = strdup(tr("No subtitles"));
5320 numTracks++;
5321 eTrackType CurrentSubtitleTrack = cDevice::PrimaryDevice()->GetCurrentSubtitleTrack();
5322 for (int i = ttSubtitleFirst; i <= ttSubtitleLast; i++) {
5323 const tTrackId *TrackId = cDevice::PrimaryDevice()->GetTrack(eTrackType(i));
5324 if (TrackId && TrackId->id) {
5326 descriptions[numTracks] = strdup(*TrackId->description ? TrackId->description : *TrackId->language ? TrackId->language : *itoa(i));
5327 if (i == CurrentSubtitleTrack)
5328 track = numTracks;
5329 numTracks++;
5330 }
5331 }
5332 descriptions[numTracks] = NULL;
5333 timeout.Set(TRACKTIMEOUT);
5334 displayTracks = Skins.Current()->DisplayTracks(tr("Button$Subtitles"), numTracks, descriptions);
5335 Show();
5336}
5337
5339{
5340 delete displayTracks;
5341 currentDisplayTracks = NULL;
5342 for (int i = 0; i < numTracks; i++)
5343 free(descriptions[i]);
5345}
5346
5353
5355{
5356 if (cDevice::PrimaryDevice()->NumSubtitleTracks() > 0) {
5359 return currentDisplayTracks;
5360 }
5361 Skins.Message(mtWarning, tr("No subtitles available!"));
5362 return NULL;
5363}
5364
5366{
5368 currentDisplayTracks->ProcessKey(Key);
5369}
5370
5372{
5373 int oldTrack = track;
5374 switch (int(Key)) {
5375 case kUp|k_Repeat:
5376 case kUp:
5377 case kDown|k_Repeat:
5378 case kDown:
5379 if (NORMALKEY(Key) == kUp && track > 0)
5380 track--;
5381 else if (NORMALKEY(Key) == kDown && track < numTracks - 1)
5382 track++;
5383 timeout.Set(TRACKTIMEOUT);
5384 break;
5385 case kSubtitles|k_Repeat:
5386 case kSubtitles:
5387 if (++track >= numTracks)
5388 track = 0;
5389 timeout.Set(TRACKTIMEOUT);
5390 break;
5391 case kOk:
5392 oldTrack = -1; // make sure we explicitly switch to that track
5393 timeout.Set();
5394 break;
5395 case kNone: break;
5396 default: if ((Key & k_Release) == 0)
5397 return osEnd;
5398 }
5399 if (track != oldTrack) {
5400 Show();
5402 if (track == ttNone && Setup.DisplaySubtitles == SUBTITLES_REWIND) {
5405 }
5406 }
5407 return timeout.TimedOut() ? osEnd : osContinue;
5408}
5409
5410// --- cRecordControl --------------------------------------------------------
5411
5413{
5414 const char *LastReplayed = cReplayControl::LastReplayed(); // must do this before locking schedules!
5415 // Whatever happens here, the timers will be modified in some way...
5416 Timers->SetModified();
5417 cStateKey ChannelsStateKey;
5418 // To create a new timer, we need to make shure there is
5419 // a lock on Channels prior to the Schedules locking below
5420 if (!Timer)
5421 cChannels::GetChannelsRead(ChannelsStateKey);
5422 // We're going to work with an event here, so we need to prevent
5423 // others from modifying any EPG data:
5424 cStateKey SchedulesStateKey;
5425 cSchedules::GetSchedulesRead(SchedulesStateKey);
5426
5427 event = NULL;
5428 fileName = NULL;
5429 recorder = NULL;
5430 device = Device;
5431 if (!device) device = cDevice::PrimaryDevice();//XXX
5432 timer = Timer;
5433 if (!timer) {
5434 timer = new cTimer(true, Pause);
5435 Timers->Add(timer);
5436 instantId = cString::sprintf(cDevice::NumDevices() > 1 ? "%s - %d" : "%s", timer->Channel()->Name(), device->DeviceNumber() + 1);
5437 ChannelsStateKey.Remove();
5438 }
5439 timer->SetPending(true);
5440 timer->SetRecording(true);
5441 event = timer->Event();
5442
5443 if (event || GetEvent())
5444 dsyslog("Title: '%s' Subtitle: '%s'", event->Title(), event->ShortText());
5445 cRecording Recording(timer, event);
5446 fileName = strdup(Recording.FileName());
5447
5448 // crude attempt to avoid duplicate recordings:
5450 isyslog("already recording: '%s'", fileName);
5451 if (Timer) {
5452 timer->SetPending(false);
5453 timer->SetRecording(false);
5454 timer->OnOff();
5455 }
5456 else {
5457 Timers->Del(timer);
5458 if (!LastReplayed) // an instant recording, maybe from cRecordControls::PauseLiveVideo()
5460 }
5461 timer = NULL;
5462 SchedulesStateKey.Remove();
5463 return;
5464 }
5465
5467 isyslog("record %s", fileName);
5468 if (MakeDirs(fileName, true)) {
5469 Recording.WriteInfo(); // we write this *before* attaching the recorder to the device, to make sure the info file is present when the recorder needs to update the fps value!
5470 const cChannel *ch = timer->Channel();
5471 recorder = new cRecorder(fileName, ch, timer->Priority());
5472 if (device->AttachReceiver(recorder)) {
5473 cStatus::MsgRecording(device, Recording.Name(), Recording.FileName(), true);
5474 if (!Timer && !LastReplayed) // an instant recording, maybe from cRecordControls::PauseLiveVideo()
5476 SchedulesStateKey.Remove();
5478 SetRecordingTimerId(fileName, cString::sprintf("%d@%s", timer->Id(), Setup.SVDRPHostName));
5479 Recordings->AddByName(fileName);
5480 return;
5481 }
5482 else
5484 }
5485 else
5486 timer->SetDeferred(DEFERTIMER);
5487 if (!Timer) {
5488 Timers->Del(timer);
5489 timer = NULL;
5490 }
5491 SchedulesStateKey.Remove();
5492}
5493
5495{
5496 Stop();
5497 free(fileName);
5498}
5499
5500#define INSTANT_REC_EPG_LOOKAHEAD 300 // seconds to look into the EPG data for an instant recording
5501
5503{
5504 const cChannel *Channel = timer->Channel();
5505 time_t Time = timer->HasFlags(tfInstant) ? timer->StartTime() + INSTANT_REC_EPG_LOOKAHEAD : timer->StartTime() + (timer->StopTime() - timer->StartTime()) / 2;
5506 for (int seconds = 0; seconds <= MAXWAIT4EPGINFO; seconds++) {
5507 {
5509 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
5510 event = Schedule->GetEventAround(Time);
5511 if (event) {
5512 if (seconds > 0)
5513 dsyslog("got EPG info after %d seconds", seconds);
5514 return true;
5515 }
5516 }
5517 }
5518 if (seconds == 0)
5519 dsyslog("waiting for EPG info...");
5520 cCondWait::SleepMs(1000);
5521 }
5522 dsyslog("no EPG info available");
5523 return false;
5524}
5525
5526void cRecordControl::Stop(bool ExecuteUserCommand)
5527{
5528 if (timer) {
5529 bool Finished = timer->HasFlags(tfActive) && !timer->Matches();
5530 if (recorder) {
5531 int Errors = recorder->Errors();
5532 isyslog("timer %s %s with %d error%s", *timer->ToDescr(), Finished ? "finished" : "stopped", Errors, Errors != 1 ? "s" : "");
5533 if (timer->HasFlags(tfAvoid) && Errors == 0 && Finished) {
5534 const char *p = strgetlast(timer->File(), FOLDERDELIMCHAR);
5535 DoneRecordingsPattern.Append(p);
5536 }
5537 }
5539 timer->SetRecording(false);
5540 timer = NULL;
5542 cStatus::MsgRecording(device, NULL, fileName, false);
5543 if (ExecuteUserCommand && Finished)
5545 }
5546}
5547
5549{
5550 if (!recorder || !recorder->IsAttached() || !timer || !timer->Matches(t)) {
5551 if (timer)
5552 timer->SetPending(false);
5553 return false;
5554 }
5555 return true;
5556}
5557
5558// --- cRecordControls -------------------------------------------------------
5559
5562
5563bool cRecordControls::Start(cTimers *Timers, cTimer *Timer, bool Pause)
5564{
5565 static time_t LastNoDiskSpaceMessage = 0;
5566 int FreeMB = 0;
5567 if (Timer) {
5568 AssertFreeDiskSpace(Timer->Priority(), !Timer->Pending());
5569 Timer->SetPending(true);
5570 }
5572 if (FreeMB < MINFREEDISK) {
5573 if (!Timer || time(NULL) - LastNoDiskSpaceMessage > NODISKSPACEDELTA) {
5574 isyslog("not enough disk space to start recording%s%s", Timer ? " timer " : "", Timer ? *Timer->ToDescr() : "");
5575 Skins.Message(mtWarning, tr("Not enough disk space to start recording!"));
5576 LastNoDiskSpaceMessage = time(NULL);
5577 }
5578 return false;
5579 }
5580 LastNoDiskSpaceMessage = 0;
5581
5582 ChangeState();
5583 cStateKey StateKey;
5584 const cChannels *Channels = cChannels::GetChannelsRead(StateKey);
5585 int ch = Timer ? Timer->Channel()->Number() : cDevice::CurrentChannel();
5586 if (const cChannel *Channel = Channels->GetByNumber(ch)) {
5587 int Priority = Timer ? Timer->Priority() : Pause ? Setup.PausePriority : Setup.DefaultPriority;
5588 cDevice *device = cDevice::GetDevice(Channel, Priority, false);
5589 if (device) {
5590 dsyslog("switching device %d to channel %d %s (%s)", device->DeviceNumber() + 1, Channel->Number(), *Channel->GetChannelID().ToString(), Channel->Name());
5591 if (!device->SwitchChannel(Channel, false)) {
5592 StateKey.Remove();
5593 ShutdownHandler.RequestEmergencyExit();
5594 return false;
5595 }
5596 StateKey.Remove();
5597 Channels = NULL;
5598 if (!Timer || Timer->Matches()) {
5599 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5600 if (!RecordControls[i]) {
5601 RecordControls[i] = new cRecordControl(device, Timers, Timer, Pause);
5602 return RecordControls[i]->Process(time(NULL));
5603 }
5604 }
5605 }
5606 }
5607 else if (!Timer || !Timer->Pending()) {
5608 isyslog("no free DVB device to record channel %d (%s)!", ch, Channel->Name());
5609 Skins.Message(mtError, tr("No free DVB device to record!"));
5610 }
5611 }
5612 else
5613 esyslog("ERROR: channel %d not defined!", ch);
5614 if (Channels)
5615 StateKey.Remove();
5616 return false;
5617}
5618
5620{
5622 return Start(Timers, NULL, Pause);
5623}
5624
5625void cRecordControls::Stop(const char *InstantId)
5626{
5628 ChangeState();
5629 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5630 if (RecordControls[i]) {
5631 const char *id = RecordControls[i]->InstantId();
5632 if (id && strcmp(id, InstantId) == 0) {
5633 cTimer *Timer = RecordControls[i]->Timer();
5634 RecordControls[i]->Stop();
5635 if (Timer) {
5636 Timers->Del(Timer);
5637 isyslog("deleted timer %s", *Timer->ToDescr());
5638 }
5639 break;
5640 }
5641 }
5642 }
5643}
5644
5646{
5647 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5648 if (RecordControls[i]) {
5649 if (RecordControls[i]->Timer() == Timer) {
5651 ChangeState();
5652 break;
5653 }
5654 }
5655 }
5656}
5657
5659{
5660 Skins.Message(mtStatus, tr("Pausing live video..."));
5661 cReplayControl::SetRecording(NULL); // make sure the new cRecordControl will set cReplayControl::LastReplayed()
5662 if (Start(true)) {
5663 cReplayControl *rc = new cReplayControl(true);
5664 cControl::Launch(rc);
5666 Skins.Message(mtStatus, NULL);
5667 return true;
5668 }
5669 Skins.Message(mtStatus, NULL);
5670 return false;
5671}
5672
5673const char *cRecordControls::GetInstantId(const char *LastInstantId)
5674{
5675 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5676 if (RecordControls[i]) {
5677 if (!LastInstantId && RecordControls[i]->InstantId())
5678 return RecordControls[i]->InstantId();
5679 if (LastInstantId && LastInstantId == RecordControls[i]->InstantId())
5680 LastInstantId = NULL;
5681 }
5682 }
5683 return NULL;
5684}
5685
5687{
5688 if (FileName) {
5689 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5690 if (RecordControls[i] && strcmp(RecordControls[i]->FileName(), FileName) == 0)
5691 return RecordControls[i];
5692 }
5693 }
5694 return NULL;
5695}
5696
5698{
5699 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5700 if (RecordControls[i] && RecordControls[i]->Timer() == Timer)
5701 return RecordControls[i];
5702 }
5703 return NULL;
5704}
5705
5706bool cRecordControls::Process(cTimers *Timers, time_t t)
5707{
5708 bool Result = false;
5709 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5710 if (RecordControls[i]) {
5711 if (!RecordControls[i]->Process(t)) {
5713 ChangeState();
5714 Result = true;
5715 }
5716 }
5717 }
5718 return Result;
5719}
5720
5722{
5723 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5724 if (RecordControls[i]) {
5725 if (RecordControls[i]->Timer() && RecordControls[i]->Timer()->Channel() == Channel) {
5726 if (RecordControls[i]->Device()->ProvidesTransponder(Channel)) { // avoids retune on devices that don't really access the transponder
5727 isyslog("stopping recording due to modification of channel %d (%s)", Channel->Number(), Channel->Name());
5728 RecordControls[i]->Stop();
5729 // This will restart the recording, maybe even from a different
5730 // device in case conditional access has changed.
5731 ChangeState();
5732 }
5733 }
5734 }
5735 }
5736}
5737
5739{
5740 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5741 if (RecordControls[i])
5742 return true;
5743 }
5744 return false;
5745}
5746
5748{
5749 for (int i = 0; i < MAXRECORDCONTROLS; i++)
5751 ChangeState();
5752}
5753
5755{
5756 int NewState = state;
5757 bool Result = State != NewState;
5758 State = state;
5759 return Result;
5760}
5761
5762// --- cAdaptiveSkipper ------------------------------------------------------
5763
5765{
5766 initialValue = NULL;
5767 currentValue = 0;
5768 framesPerSecond = 0;
5769 lastKey = kNone;
5770}
5771
5772void cAdaptiveSkipper::Initialize(int *InitialValue, double FramesPerSecond)
5773{
5774 initialValue = InitialValue;
5775 framesPerSecond = FramesPerSecond;
5776 currentValue = 0;
5777}
5778
5780{
5781 if (!initialValue)
5782 return 0;
5783 if (timeout.TimedOut()) {
5784 currentValue = int(round(*initialValue * framesPerSecond));
5785 lastKey = Key;
5786 }
5787 else if (Key != lastKey) {
5788 currentValue /= 2;
5789 if (Setup.AdaptiveSkipAlternate)
5790 lastKey = Key; // only halve the value when the direction is changed
5791 else
5792 lastKey = kNone; // once the direction has changed, every further call halves the value
5793 }
5794 timeout.Set(Setup.AdaptiveSkipTimeout * 1000);
5795 return max(currentValue, 1);
5796}
5797
5798// --- cReplayControl --------------------------------------------------------
5799
5802
5804:cDvbPlayerControl(fileName, PauseLive)
5805{
5807 currentReplayControl = this;
5808 displayReplay = NULL;
5809 marksModified = false;
5810 visible = modeOnly = shown = displayFrames = false;
5811 lastErrors = 0;
5812 lastCurrent = lastTotal = -1;
5813 lastPlay = lastForward = false;
5814 lastSpeed = -2; // an invalid value
5815 timeoutShow = 0;
5816 timeSearchActive = false;
5817 cRecording Recording(fileName);
5818 cStatus::MsgReplaying(this, Recording.Name(), Recording.FileName(), true);
5819 marks.Load(fileName, Recording.FramesPerSecond(), Recording.IsPesRecording());
5820 SetMarks(&marks);
5821 adaptiveSkipper.Initialize(&Setup.AdaptiveSkipInitial, Recording.FramesPerSecond());
5822 SetTrackDescriptions(false);
5823 if (Setup.ProgressDisplayTime)
5824 ShowTimed(Setup.ProgressDisplayTime);
5825}
5826
5834
5836{
5837 Hide();
5838 cStatus::MsgReplaying(this, NULL, fileName, false);
5839 if (Setup.DelTimeshiftRec && *fileName) {
5841 if (rc && rc->InstantId()) {
5842 if (Active()) {
5843 if (Setup.DelTimeshiftRec == 2 || Interface->Confirm(tr("Delete timeshift recording?"))) {
5844 {
5846 Timers->SetExplicitModify();
5847 cTimer *Timer = rc->Timer();
5848 rc->Stop(false); // don't execute user command
5849 if (Timer) {
5850 Timers->Del(Timer);
5851 Timers->SetModified();
5852 isyslog("deleted timer %s", *Timer->ToDescr());
5853 }
5854 }
5856 bool Error = false;
5857 {
5859 Recordings->SetExplicitModify();
5860 if (cRecording *Recording = Recordings->GetByName(fileName)) {
5861 if (Recording->Delete()) {
5862 Recordings->DelByName(fileName);
5864 Recordings->SetModified();
5865 }
5866 else
5867 Error = true;
5868 }
5869 }
5870 if (Error)
5871 Skins.Message(mtError, tr("Error while deleting recording!"));
5872 return;
5873 }
5874 }
5875 }
5876 }
5878 cMenuRecordings::SetRecording(NULL); // make sure opening the Recordings menu navigates to the last replayed recording
5879}
5880
5882{
5883 cStateKey StateKey;
5884 marks.Lock(StateKey);
5885 while (cMark *m = marks.First())
5886 marks.Del(m);
5887 StateKey.Remove();
5889}
5890
5891void cReplayControl::SetRecording(const char *FileName)
5892{
5893 fileName = FileName;
5894}
5895
5897{
5898 return currentReplayControl ? *fileName : NULL;
5899}
5900
5902{
5904 if (!Recordings->GetByName(fileName))
5905 fileName = NULL;
5906 return fileName;
5907}
5908
5909void cReplayControl::ClearLastReplayed(const char *FileName)
5910{
5911 if (*fileName && FileName && strcmp(fileName, FileName) == 0)
5912 fileName = NULL;
5913}
5914
5916{
5917 if (modeOnly)
5918 Hide();
5919 if (!visible) {
5920 shown = ShowProgress(true);
5921 timeoutShow = (shown && Seconds > 0) ? time(NULL) + Seconds : 0;
5922 }
5923 else if (timeoutShow && Seconds > 0)
5924 timeoutShow = time(NULL) + Seconds;
5925}
5926
5928{
5929 ShowTimed();
5930}
5931
5933{
5934 if (visible) {
5935 delete displayReplay;
5936 displayReplay = NULL;
5937 SetNeedsFastResponse(false);
5938 visible = false;
5939 modeOnly = false;
5940 lastPlay = lastForward = false;
5941 lastSpeed = -2; // an invalid value
5942 timeSearchActive = false;
5943 timeoutShow = 0;
5944 }
5945 if (marksModified) {
5946 marks.Save();
5947 marksModified = false;
5948 }
5949}
5950
5952{
5953 if (visible || Setup.ShowReplayMode && !cOsd::IsOpen()) {
5954 bool Play, Forward;
5955 int Speed;
5956 if (GetReplayMode(Play, Forward, Speed) && (!visible || Play != lastPlay || Forward != lastForward || Speed != lastSpeed)) {
5957 bool NormalPlay = (Play && Speed == -1);
5958
5959 if (!visible) {
5960 if (NormalPlay)
5961 return; // no need to do indicate ">" unless there was a different mode displayed before
5962 visible = modeOnly = true;
5963 displayReplay = Skins.Current()->DisplayReplay(modeOnly);
5964 }
5965
5966 if (modeOnly && !timeoutShow && NormalPlay)
5967 timeoutShow = time(NULL) + MODETIMEOUT;
5968 displayReplay->SetMode(Play, Forward, Speed);
5969 lastPlay = Play;
5971 lastSpeed = Speed;
5972 }
5973 }
5974}
5975
5977{
5978 int Current, Total;
5979 if (!(Initial || updateTimer.TimedOut()))
5980 return visible;
5981 if (GetFrameNumber(Current, Total) && Total > 0) {
5982 if (!visible) {
5983 displayReplay = Skins.Current()->DisplayReplay(modeOnly);
5984 displayReplay->SetMarks(&marks);
5985 displayReplay->SetErrors(GetErrors());
5987 visible = true;
5988 }
5989 if (Initial) {
5990 if (*fileName) {
5992 if (const cRecording *Recording = Recordings->GetByName(fileName))
5993 displayReplay->SetRecording(Recording);
5994 }
5995 lastCurrent = lastTotal = -1;
5996 }
5997 const cErrors *Errors = GetErrors();
5998 int NumErrors = Errors ? Errors->Size() : 0;
5999 if (Current != lastCurrent || Total != lastTotal || NumErrors != lastErrors) {
6000 if (Setup.ShowRemainingTime || Total != lastTotal) {
6001 int Index = Total;
6002 if (Setup.ShowRemainingTime)
6003 Index = Current - Index;
6004 displayReplay->SetTotal(IndexToHMSF(Index, false, FramesPerSecond()));
6005 }
6006 displayReplay->SetProgress(Current, Total);
6007 displayReplay->SetCurrent(IndexToHMSF(Current, displayFrames, FramesPerSecond()));
6008 displayReplay->SetErrors(Errors);
6009 displayReplay->Flush();
6010 lastCurrent = Current;
6011 lastTotal = Total;
6012 lastErrors = NumErrors;
6013 }
6014 ShowMode();
6016 return true;
6017 }
6018 return false;
6019}
6020
6022{
6023 char buf[64];
6024 // TRANSLATORS: note the trailing blank!
6025 strcpy(buf, tr("Jump: "));
6026 int len = strlen(buf);
6027 char h10 = '0' + (timeSearchTime >> 24);
6028 char h1 = '0' + ((timeSearchTime & 0x00FF0000) >> 16);
6029 char m10 = '0' + ((timeSearchTime & 0x0000FF00) >> 8);
6030 char m1 = '0' + (timeSearchTime & 0x000000FF);
6031 char ch10 = timeSearchPos > 3 ? h10 : '-';
6032 char ch1 = timeSearchPos > 2 ? h1 : '-';
6033 char cm10 = timeSearchPos > 1 ? m10 : '-';
6034 char cm1 = timeSearchPos > 0 ? m1 : '-';
6035 sprintf(buf + len, "%c%c:%c%c", ch10, ch1, cm10, cm1);
6036 displayReplay->SetJump(buf);
6037}
6038
6040{
6041#define STAY_SECONDS_OFF_END 10
6042 int Seconds = (timeSearchTime >> 24) * 36000 + ((timeSearchTime & 0x00FF0000) >> 16) * 3600 + ((timeSearchTime & 0x0000FF00) >> 8) * 600 + (timeSearchTime & 0x000000FF) * 60;
6043 int Current = int(round(lastCurrent / FramesPerSecond()));
6044 int Total = int(round(lastTotal / FramesPerSecond()));
6045 switch (Key) {
6046 case k0 ... k9:
6047 if (timeSearchPos < 4) {
6048 timeSearchTime <<= 8;
6049 timeSearchTime |= Key - k0;
6050 timeSearchPos++;
6052 }
6053 break;
6054 case kFastRew:
6055 case kLeft:
6056 case kFastFwd:
6057 case kRight: {
6058 int dir = ((Key == kRight || Key == kFastFwd) ? 1 : -1);
6059 if (dir > 0)
6060 Seconds = min(Total - Current - STAY_SECONDS_OFF_END, Seconds);
6061 SkipSeconds(Seconds * dir);
6062 timeSearchActive = false;
6063 }
6064 break;
6065 case kPlayPause:
6066 case kPlay:
6067 case kUp:
6068 case kPause:
6069 case kDown:
6070 case kOk:
6071 if (timeSearchPos > 0) {
6072 Seconds = min(Total - STAY_SECONDS_OFF_END, Seconds);
6073 bool Still = Key == kDown || Key == kPause || Key == kOk;
6074 Goto(SecondsToFrames(Seconds, FramesPerSecond()), Still);
6075 }
6076 timeSearchActive = false;
6077 break;
6078 default:
6079 if (!(Key & k_Flags)) // ignore repeat/release keys
6080 timeSearchActive = false;
6081 break;
6082 }
6083
6084 if (!timeSearchActive) {
6085 if (timeSearchHide)
6086 Hide();
6087 else
6088 displayReplay->SetJump(NULL);
6089 ShowMode();
6090 }
6091}
6092
6094{
6096 timeSearchHide = false;
6097 if (modeOnly)
6098 Hide();
6099 if (!visible) {
6100 Show();
6101 if (visible)
6102 timeSearchHide = true;
6103 else
6104 return;
6105 }
6106 timeoutShow = 0;
6108 timeSearchActive = true;
6109}
6110
6112{
6113 int Current, Total;
6114 if (GetIndex(Current, Total, true)) {
6115 lastCurrent = -1; // triggers redisplay
6116 cStateKey StateKey;
6117 marks.Lock(StateKey);
6118 if (cMark *m = marks.Get(Current))
6119 marks.Del(m);
6120 else {
6121 marks.Add(Current);
6122 bool Play, Forward;
6123 int Speed;
6124 if (Setup.PauseOnMarkSet || GetReplayMode(Play, Forward, Speed) && !Play) {
6125 Goto(Current, true);
6126 displayFrames = true;
6127 }
6128 }
6129 StateKey.Remove();
6130 ShowTimed(2);
6131 marksModified = true;
6133 }
6134}
6135
6137{
6138 int Current, Total;
6139 if (GetIndex(Current, Total)) {
6140 if (marks.Count()) {
6141 if (cMark *m = Forward ? marks.GetNext(Current) : marks.GetPrev(Current)) {
6142 if (!Setup.PauseOnMarkJump) {
6143 bool Playing, Fwd;
6144 int Speed;
6145 if (GetReplayMode(Playing, Fwd, Speed) && Playing && Forward && m->Position() < Total - SecondsToFrames(3, FramesPerSecond())) {
6146 Goto(m->Position());
6147 return;
6148 }
6149 }
6150 Goto(m->Position(), true);
6151 displayFrames = true;
6152 return;
6153 }
6154 }
6155 // There are either no marks at all, or we already were at the first or last one,
6156 // so jump to the very beginning or end:
6157 Goto(Forward ? Total : 0, true);
6158 }
6159}
6160
6161void cReplayControl::MarkMove(int Frames, bool MarkRequired)
6162{
6163 int Current, Total;
6164 if (GetIndex(Current, Total)) {
6165 bool Play, Forward;
6166 int Speed;
6167 GetReplayMode(Play, Forward, Speed);
6168 cMark *m = marks.Get(Current);
6169 if (!Play && m) {
6170 displayFrames = true;
6171 cMark *m2;
6172 if (Frames > 0) {
6173 // Handle marks at the same offset:
6174 while ((m2 = marks.Next(m)) != NULL && m2->Position() == m->Position())
6175 m = m2;
6176 // Don't skip the next mark:
6177 if ((m2 = marks.Next(m)) != NULL)
6178 Frames = min(Frames, m2->Position() - m->Position() - 1);
6179 }
6180 else {
6181 // Handle marks at the same offset:
6182 while ((m2 = marks.Prev(m)) != NULL && m2->Position() == m->Position())
6183 m = m2;
6184 // Don't skip the next mark:
6185 if ((m2 = marks.Prev(m)) != NULL)
6186 Frames = -min(-Frames, m->Position() - m2->Position() - 1);
6187 }
6188 int p = SkipFrames(Frames);
6189 m->SetPosition(p);
6190 Goto(m->Position(), true);
6191 marksModified = true;
6193 }
6194 else if (!MarkRequired)
6195 Goto(SkipFrames(Frames), !Play);
6196 }
6197}
6198
6200{
6201 const cErrors *Errors = GetErrors();
6202 int NumErrors = Errors ? Errors->Size() : 0;
6203 if (NumErrors > 0) {
6204 int Current, Total;
6205 if (GetIndex(Current, Total)) {
6206 if (Forward) {
6207 int Offset = 0;
6208 for (int i = 0; i < NumErrors; i++) {
6209 int Position = Errors->At(i);
6210 if (Position > Current + Offset) {
6211 int NextIFrame = SkipFrames(Position - Current) + Offset; // this takes us to the I-frame at or right after Position
6212 if (NextIFrame > Position) {
6213 if (SkipFrames(Offset + 1) == NextIFrame) { // means Current is the I-frame right before Position
6214 Offset = NextIFrame - Current;
6215 continue;
6216 }
6217 }
6218 Goto(Position, true); // this takes us to the I-frame at or right before Position
6219 return;
6220 }
6221 }
6222 if (Current < Total)
6223 Goto(Total, true);
6224 }
6225 else {
6226 for (int i = NumErrors - 1; i >= 0; i--) {
6227 if (Errors->At(i) < Current) {
6228 int Position = Errors->At(i);
6229 Goto(Position, true); // this takes us to the I-frame at or right before Position
6230 return;
6231 }
6232 }
6233 if (Current > 0)
6234 Goto(0, true);
6235 }
6236 }
6237 }
6238}
6239
6241{
6242 if (*fileName) {
6243 Hide();
6244 if (!RecordingsHandler.GetUsage(fileName)) {
6245 if (!marks.Count())
6246 Skins.Message(mtError, tr("No editing marks defined!"));
6247 else if (!marks.GetNumSequences())
6248 Skins.Message(mtError, tr("No editing sequences defined!"));
6249 else if (access(cCutter::EditedFileName(fileName), F_OK) == 0 && !Interface->Confirm(tr("Edited version already exists - overwrite?")))
6250 ;
6252 Skins.Message(mtError, tr("Not enough free disk space to start editing process!"));
6253 else if (!RecordingsHandler.Add(ruCut, fileName))
6254 Skins.Message(mtError, tr("Can't start editing process!"));
6255 else
6256 Skins.Message(mtInfo, tr("Editing process started"));
6257 }
6258 else
6259 Skins.Message(mtError, tr("Editing process already active!"));
6260 ShowMode();
6261 }
6262}
6263
6265{
6266 int Current, Total;
6267 if (GetIndex(Current, Total)) {
6268 cMark *m = marks.Get(Current);
6269 if (!m)
6270 m = marks.GetNext(Current);
6271 if (m) {
6272 if ((m->Index() & 0x01) != 0 && !Setup.SkipEdited) // when skipping edited parts we also need to jump to end marks
6273 m = marks.Next(m);
6274 if (m)
6276 }
6277 }
6278}
6279
6281{
6283 if (const cRecording *Recording = Recordings->GetByName(cReplayControl::LastReplayed()))
6284 return new cMenuRecording(Recording, false);
6285 return NULL;
6286}
6287
6289{
6291 if (const cRecording *Recording = Recordings->GetByName(LastReplayed()))
6292 return Recording;
6293 return NULL;
6294}
6295
6297{
6298 if (!Active())
6299 return osEnd;
6300 if (Key == kNone && !marksModified)
6301 marks.Update();
6302 if (visible) {
6303 if (timeoutShow && time(NULL) > timeoutShow) {
6304 Hide();
6305 ShowMode();
6306 timeoutShow = 0;
6307 }
6308 else if (modeOnly)
6309 ShowMode();
6310 else
6312 }
6313 bool DisplayedFrames = displayFrames;
6314 displayFrames = false;
6315 if (timeSearchActive && Key != kNone) {
6316 TimeSearchProcess(Key);
6317 return osContinue;
6318 }
6319 if (Key == kPlayPause) {
6320 bool Play, Forward;
6321 int Speed;
6322 GetReplayMode(Play, Forward, Speed);
6323 if (Speed >= 0)
6324 Key = Play ? kPlay : kPause;
6325 else
6326 Key = Play ? kPause : kPlay;
6327 }
6328 bool DoShowMode = true;
6329 switch (int(Key)) {
6330 // Positioning:
6331 case kPlay:
6332 case kUp: Play(); break;
6333 case kPause:
6334 case kDown: Pause(); break;
6335 case kFastRew|k_Release:
6336 case kLeft|k_Release:
6337 if (Setup.MultiSpeedMode) break;
6338 case kFastRew:
6339 case kLeft: Backward(); break;
6340 case kFastFwd|k_Release:
6341 case kRight|k_Release:
6342 if (Setup.MultiSpeedMode) break;
6343 case kFastFwd:
6344 case kRight: Forward(); break;
6345 case kRed: TimeSearch(); break;
6346 case kGreen|k_Repeat:
6347 SkipSeconds(-Setup.SkipSecondsRepeat); break;
6348 case kGreen: SkipSeconds(-Setup.SkipSeconds); break;
6349 case kYellow|k_Repeat:
6350 SkipSeconds(Setup.SkipSecondsRepeat); break;
6351 case kYellow: SkipSeconds(Setup.SkipSeconds); break;
6352 case kStop:
6353 case kBlue: Stop();
6354 return osEnd;
6355 default: {
6356 DoShowMode = false;
6357 switch (int(Key)) {
6358 // Editing:
6359 case kMarkToggle: MarkToggle(); break;
6360 case kPrev|k_Repeat:
6361 case kPrev: if (Setup.AdaptiveSkipPrevNext) {
6362 MarkMove(-adaptiveSkipper.GetValue(RAWKEY(Key)), false);
6363 break;
6364 }
6365 // fall through...
6367 case kMarkJumpBack: MarkJump(false); break;
6368 case kNext|k_Repeat:
6369 case kNext: if (Setup.AdaptiveSkipPrevNext) {
6370 MarkMove(+adaptiveSkipper.GetValue(RAWKEY(Key)), false);
6371 break;
6372 }
6373 // fall through...
6375 case kMarkJumpForward: MarkJump(true); break;
6377 case kMarkMoveBack: MarkMove(-1, true); break;
6379 case kMarkMoveForward: MarkMove(+1, true); break;
6381 case kMarkSkipBack: MarkMove(-adaptiveSkipper.GetValue(RAWKEY(Key)), false); break;
6383 case kMarkSkipForward: MarkMove(+adaptiveSkipper.GetValue(RAWKEY(Key)), false); break;
6384 case kChanUp|k_Repeat:
6385 case kChanUp: ErrorJump(true); break;
6386 case kChanDn|k_Repeat:
6387 case kChanDn: ErrorJump(false); break;
6388 case kEditCut: EditCut(); break;
6389 case kEditTest: EditTest(); break;
6390 default: {
6391 displayFrames = DisplayedFrames;
6392 switch (Key) {
6393 // Menu control:
6394 case kOk: if (visible && !modeOnly) {
6395 Hide();
6396 DoShowMode = true;
6397 }
6398 else
6399 Show();
6400 break;
6401 case kBack: Stop();
6402 return osRecordings;
6403 default: return osUnknown;
6404 }
6405 }
6406 }
6407 }
6408 }
6409 if (DoShowMode)
6410 ShowMode();
6411 return osContinue;
6412}
cString ChannelString(const cChannel *Channel, int Number)
Definition channels.c:1140
#define CA_ENCRYPTED_MIN
Definition channels.h:44
#define CA_FTA
Definition channels.h:39
#define LOCK_CHANNELS_READ
Definition channels.h:270
#define LOCK_CHANNELS_WRITE
Definition channels.h:271
cCamSlots CamSlots
Definition ci.c:2838
@ msReady
Definition ci.h:170
@ msPresent
Definition ci.h:170
@ msReset
Definition ci.h:170
double framesPerSecond
Definition menu.h:284
cTimeMs timeout
Definition menu.h:286
cAdaptiveSkipper(void)
Definition menu.c:5764
eKeys lastKey
Definition menu.h:285
void Initialize(int *InitialValue, double FramesPerSecond)
Definition menu.c:5772
int * initialValue
Definition menu.h:282
int currentValue
Definition menu.h:283
int GetValue(eKeys Key)
Definition menu.c:5779
Definition ci.h:232
int Priority(void)
Returns the priority of the device this slot is currently assigned to, or IDLEPRIORITY if it is not a...
Definition ci.c:2656
virtual bool EnterMenu(void)
Requests the CAM in this slot to start its menu.
Definition ci.c:2468
virtual bool HasUserIO(void)
Returns true if there is a pending user interaction, which shall be retrieved via GetMenu() or GetEnq...
Definition ci.c:2462
virtual bool Assign(cDevice *Device, bool Query=false)
Assigns this CAM slot to the given Device, if this is possible.
Definition ci.c:2221
cDevice * Device(void)
Returns the device this CAM slot is currently assigned to.
Definition ci.h:332
virtual bool Reset(void)
Resets the CAM in this slot.
Definition ci.c:2375
virtual void StartActivation(void)
Puts the CAM in this slot into a mode where an inserted smart card can be activated.
Definition ci.c:2398
virtual bool IsActivating(void)
Returns true if this CAM slot is currently activating a smart card.
Definition ci.c:2424
virtual bool CanActivate(void)
Returns true if there is a CAM in this slot that can be put into activation mode.
Definition ci.c:2393
cCamSlot * MtdSpawn(void)
If this CAM slot can do MTD ("Multi Transponder Decryption"), a call to this function returns a cMtdC...
Definition ci.c:2213
int SlotNumber(void)
Returns the number of this CAM slot within the whole system.
Definition ci.h:344
virtual void CancelActivation(void)
Cancels a previously started activation (if any).
Definition ci.c:2413
int Number(void) const
Definition channels.h:179
const char * Name(void) const
Definition channels.c:121
bool GroupSep(void) const
Definition channels.h:181
const char * Provider(void) const
Definition channels.h:147
static cChannels * GetChannelsWrite(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of channels for write access.
Definition channels.c:861
bool HasUniqueChannelID(const cChannel *NewChannel, const cChannel *OldChannel=NULL) const
Definition channels.c:1053
static int MaxNumber(void)
Definition channels.h:249
int GetPrevNormal(int Idx) const
Get previous normal channel (not group)
Definition channels.c:930
static const cChannels * GetChannelsRead(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of channels for read access.
Definition channels.c:856
void ReNumber(void)
Recalculate 'number' based on channel type.
Definition channels.c:938
const cChannel * GetByNumber(int Number, int SkipGap=0) const
Definition channels.c:983
void SetModifiedByUser(void)
Definition channels.c:1093
const cChannel * GetByChannelID(tChannelID ChannelID, bool TryWithoutRid=false, bool TryWithoutPolarization=false) const
Definition channels.c:1011
bool SwitchTo(int Number) const
Definition channels.c:1063
void Del(cChannel *Channel)
Delete the given Channel from the list.
Definition channels.c:975
int GetNextNormal(int Idx) const
Get next normal channel (not group)
Definition channels.c:922
Definition ci.h:119
tComponent * Component(int Index) const
Definition epg.h:64
int NumComponents(void) const
Definition epg.h:61
static void SleepMs(int TimeoutMs)
Creates a cCondWait object and uses it to sleep for TimeoutMs milliseconds, immediately giving up the...
Definition thread.c:73
static cControl * Control(cMutexLock &MutexLock, bool Hidden=false)
Returns the current replay control (if any) in case it is currently visible.
Definition player.c:73
double FramesPerSecond(void) const
Definition player.h:114
static void Shutdown(void)
Definition player.c:99
static void Attach(void)
Definition player.c:86
static void Launch(cControl *Control)
Definition player.c:79
static cString EditedFileName(const char *FileName)
Returns the full path name of the edited version of the recording with the given FileName.
Definition cutter.c:696
void SetKeepTracks(bool KeepTracks)
Controls whether the current audio and subtitle track settings shall be kept as they currently are,...
Definition device.h:613
bool SetCurrentSubtitleTrack(eTrackType Type, bool Manual=false)
Sets the current subtitle track to the given Type.
Definition device.c:1186
virtual const cPositioner * Positioner(void) const
Returns a pointer to the positioner (if any) this device has used to move the satellite dish to the r...
Definition device.c:780
static cDevice * ActualDevice(void)
Returns the actual receiving device in case of Transfer Mode, or the primary device otherwise.
Definition device.c:222
static cDevice * PrimaryDevice(void)
Returns the primary device.
Definition device.h:148
eTrackType GetCurrentSubtitleTrack(void) const
Definition device.h:597
static cDevice * GetDevice(int Index)
Gets the device with the given Index.
Definition device.c:230
eTrackType GetCurrentAudioTrack(void) const
Definition device.h:593
bool SwitchChannel(const cChannel *Channel, bool LiveView)
Switches the device to the given Channel, initiating transfer mode if necessary.
Definition device.c:825
int DeviceNumber(void) const
Returns the number of this device (0 ... numDevices - 1).
Definition device.c:167
static int CurrentChannel(void)
Returns the number of the current channel on the primary device.
Definition device.h:371
void StopReplay(void)
Stops the current replay session (if any).
Definition device.c:1434
int GetAudioChannel(void)
Gets the current audio channel, which is stereo (0), mono left (1) or mono right (2).
Definition device.c:1064
void EnsureAudioTrack(bool Force=false)
Makes sure an audio track is selected that is actually available.
Definition device.c:1227
const tTrackId * GetTrack(eTrackType Type)
Returns a pointer to the given track id, or NULL if Type is not less than ttMaxTrackTypes.
Definition device.c:1143
static void SetCurrentChannel(int ChannelNumber)
Sets the number of the current channel on the primary device, without actually switching to it.
Definition device.h:373
void SetAudioChannel(int AudioChannel)
Sets the audio channel to stereo (0), mono left (1) or mono right (2).
Definition device.c:1070
static int NumDevices(void)
Returns the total number of devices.
Definition device.h:129
virtual void SetVideoDisplayFormat(eVideoDisplayFormat VideoDisplayFormat)
Sets the video display format to the given one (only useful if this device has an MPEG decoder).
Definition device.c:506
virtual void SetVideoFormat(bool VideoFormat16_9)
Sets the output video format to either 16:9 or 4:3 (only useful if this device has an MPEG decoder).
Definition device.c:529
void ClrAvailableTracks(bool DescriptionsOnly=false, bool IdsOnly=false)
Clears the list of currently available tracks.
Definition device.c:1091
void EnsureSubtitleTrack(void)
Makes sure one of the preferred language subtitle tracks is selected.
Definition device.c:1260
static int CurrentVolume(void)
Definition device.h:648
bool SetAvailableTrack(eTrackType Type, int Index, uint16_t Id, const char *Language=NULL, const char *Description=NULL)
Sets the track of the given Type and Index to the given values.
Definition device.c:1114
bool SetCurrentAudioTrack(eTrackType Type)
Sets the current audio track to the given Type.
Definition device.c:1168
cTimeMs lastTime
Definition menu.h:127
const cChannel * channel
Definition menu.h:132
const cEvent * lastPresent
Definition menu.h:133
void DisplayChannel(void)
Definition menu.c:4879
const cEvent * lastFollowing
Definition menu.h:134
bool timeout
Definition menu.h:129
cSkinDisplayChannel * displayChannel
Definition menu.h:124
bool withInfo
Definition menu.h:126
virtual ~cDisplayChannel() override
Definition menu.c:4872
void Refresh(void)
Definition menu.c:4906
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4929
const cPositioner * positioner
Definition menu.h:131
static cDisplayChannel * currentDisplayChannel
Definition menu.h:135
void DisplayInfo(void)
Definition menu.c:4887
cDisplayChannel(int Number, bool Switched)
Definition menu.c:4825
const cChannel * NextAvailableChannel(const cChannel *Channel, int Direction)
Definition menu.c:4912
virtual void Show(void) override
Definition menu.c:5347
cSkinDisplayTracks * displayTracks
Definition menu.h:182
cDisplaySubtitleTracks(void)
Definition menu.c:5312
static void Process(eKeys Key)
Definition menu.c:5365
char * descriptions[ttMaxTrackTypes+1]
Definition menu.h:185
eTrackType types[ttMaxTrackTypes]
Definition menu.h:184
static cDisplaySubtitleTracks * currentDisplayTracks
Definition menu.h:187
static cDisplaySubtitleTracks * Create(void)
Definition menu.c:5354
virtual ~cDisplaySubtitleTracks() override
Definition menu.c:5338
eOSState ProcessKey(eKeys Key)
Definition menu.c:5371
char * descriptions[ttMaxTrackTypes+1]
Definition menu.h:167
static cDisplayTracks * Create(void)
Definition menu.c:5236
cDisplayTracks(void)
Definition menu.c:5192
cTimeMs timeout
Definition menu.h:165
eOSState ProcessKey(eKeys Key)
Definition menu.c:5253
static cDisplayTracks * currentDisplayTracks
Definition menu.h:169
virtual void Show(void) override
Definition menu.c:5226
cSkinDisplayTracks * displayTracks
Definition menu.h:164
int numTracks
Definition menu.h:168
int audioChannel
Definition menu.h:168
static void Process(eKeys Key)
Definition menu.c:5247
virtual ~cDisplayTracks() override
Definition menu.c:5217
eTrackType types[ttMaxTrackTypes]
Definition menu.h:166
static cDisplayVolume * Create(void)
Definition menu.c:5146
cSkinDisplayVolume * displayVolume
Definition menu.h:150
virtual void Show(void) override
Definition menu.c:5141
eOSState ProcessKey(eKeys Key)
Definition menu.c:5159
cTimeMs timeout
Definition menu.h:151
static void Process(eKeys Key)
Definition menu.c:5153
cDisplayVolume(void)
Definition menu.c:5126
static cDisplayVolume * currentDisplayVolume
Definition menu.h:152
virtual ~cDisplayVolume() override
Definition menu.c:5135
static bool BondDevices(const char *Bondings)
Bonds the devices as defined in the given Bondings string.
Definition dvbdevice.c:2042
void SetMarks(const cMarks *Marks)
Definition dvbplayer.c:1009
bool GetIndex(int &Current, int &Total, bool SnapToIFrame=false)
Definition dvbplayer.c:1071
const cErrors * GetErrors(void)
Definition dvbplayer.c:1064
void SkipSeconds(int Seconds)
Definition dvbplayer.c:1051
cDvbPlayerControl(const char *FileName, bool PauseLive=false)
Definition dvbplayer.c:997
bool GetReplayMode(bool &Play, bool &Forward, int &Speed)
Definition dvbplayer.c:1089
void Pause(void)
Definition dvbplayer.c:1027
int SkipFrames(int Frames)
Definition dvbplayer.c:1057
void Goto(int Index, bool Still=false)
Definition dvbplayer.c:1094
void Stop(void)
Definition dvbplayer.c:1020
void Forward(void)
Definition dvbplayer.c:1039
bool Active(void)
Definition dvbplayer.c:1015
bool GetFrameNumber(int &Current, int &Total)
Definition dvbplayer.c:1080
void Play(void)
Definition dvbplayer.c:1033
void Backward(void)
Definition dvbplayer.c:1045
static void SetupChanged(void)
Definition epg.h:73
const char * ShortText(void) const
Definition epg.h:106
const cComponents * Components(void) const
Definition epg.h:108
time_t StartTime(void) const
Definition epg.h:111
tChannelID ChannelID(void) const
Definition epg.c:154
const char * Title(void) const
Definition epg.h:105
static bool GetAvailableFontNames(cStringList *FontNames, bool Monospaced=false)
Queries the font configuration for a list of available font names, which is returned in FontNames.
Definition font.c:440
bool Contains(const cListObject *Object) const
If a pointer to an object contained in this list has been obtained while holding a lock,...
Definition tools.c:2263
virtual void Move(int From, int To)
Definition tools.c:2223
void SetExplicitModify(void)
If you have obtained a write lock on this list, and you don't want it to be automatically marked as m...
Definition tools.c:2272
void SetModified(void)
Unconditionally marks this list as modified.
Definition tools.c:2277
void SetSyncStateKey(cStateKey &StateKey)
When making changes to this list (while holding a write lock) that shall not affect some other code t...
Definition tools.h:599
int Count(void) const
Definition tools.h:627
void Add(cListObject *Object, cListObject *After=NULL)
Definition tools.c:2175
void Sort(void)
Definition tools.c:2299
cListObject(const cListObject &ListObject)
Definition tools.h:534
cListObject * Prev(void) const
Definition tools.h:546
int Index(void) const
Definition tools.c:2095
cListObject * Next(void) const
Definition tools.h:547
Definition tools.h:631
const cOsdItem * First(void) const
Definition tools.h:643
cList(const char *NeedsLocking=NULL)
Definition tools.h:633
const T * Next(const T *Object) const
< Returns the element immediately before Object in this list, or NULL if Object is the first element ...
Definition tools.h:650
const cOsdItem * Get(int Index) const
Definition tools.h:640
void SetPosition(int Position)
Definition recording.h:391
int Position(void) const
Definition recording.h:389
static bool DeleteMarksFile(const cRecording *Recording)
Definition recording.c:2305
cCamSlot * camSlot
Definition menu.c:2318
void Set(void)
Definition menu.c:2380
eOSState Select(void)
Definition menu.c:2435
char * input
Definition menu.c:2321
void AddMultiLineItem(const char *s)
Definition menu.c:2422
void GenerateTitle(const char *s=NULL)
Definition menu.c:2362
void QueryCam(void)
Definition menu.c:2367
virtual ~cMenuCam() override
Definition menu.c:2350
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2459
cMenuCam(cCamSlot *CamSlot)
Definition menu.c:2335
time_t lastCamExchange
Definition menu.c:2323
cCiEnquiry * ciEnquiry
Definition menu.c:2320
cCiMenu * ciMenu
Definition menu.c:2319
int offset
Definition menu.c:2322
static eChannelSortMode sortMode
Definition menu.c:291
cMenuChannelItem(const cChannel *Channel)
Definition menu.c:306
const cChannel * Channel(void)
Definition menu.c:300
virtual int Compare(const cListObject &ListObject) const override
Must return 0 if this object is equal to ListObject, a positive value if it is "greater",...
Definition menu.c:314
static void SetSortMode(eChannelSortMode SortMode)
Definition menu.c:295
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:343
virtual void Set(void) override
Definition menu.c:327
static eChannelSortMode SortMode(void)
Definition menu.c:297
const cChannel * channel
Definition menu.c:292
static void IncSortMode(void)
Definition menu.c:296
cStateKey channelsStateKey
Definition menu.c:356
eOSState Number(eKeys Key)
Definition menu.c:432
cChannel * GetChannel(int Index)
Definition menu.c:417
void Set(bool Force=false)
Definition menu.c:387
int number
Definition menu.c:357
eOSState Delete(void)
Definition menu.c:488
void Propagate(cChannels *Channels)
Definition menu.c:423
eOSState New(void)
Definition menu.c:480
cMenuChannels(void)
Definition menu.c:375
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:565
virtual void Move(int From, int To) override
Definition menu.c:535
cTimeMs numberTimer
Definition menu.c:358
eOSState Edit(void)
Definition menu.c:469
~cMenuChannels()
Definition menu.c:383
eOSState Switch(void)
Definition menu.c:458
eOSState Execute(void)
Definition menu.c:2248
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2295
cList< cNestedItem > * commands
Definition menu.h:59
virtual ~cMenuCommands() override
Definition menu.c:2220
bool confirm
Definition menu.h:63
cMenuCommands(const char *Title, cList< cNestedItem > *Commands, const char *Parameters=NULL)
Definition menu.c:2203
cString title
Definition menu.h:61
cString command
Definition menu.h:62
bool Parse(const char *s)
Definition menu.c:2225
char * result
Definition menu.h:64
cString parameters
Definition menu.h:60
cMenuEditCaItem(const char *Name, int *Value)
Definition menu.c:66
eOSState ProcessKey(eKeys Key)
Definition menu.c:82
virtual void Set(void) override
Definition menu.c:72
cStateKey * channelsStateKey
Definition menu.c:164
cChannel data
Definition menu.c:166
void Setup(void)
Definition menu.c:201
cChannel * channel
Definition menu.c:165
cSourceParam * sourceParam
Definition menu.c:167
char name[256]
Definition menu.c:168
cChannel * Channel(void)
Definition menu.c:172
cMenuEditChannel(cStateKey *ChannelsStateKey, cChannel *Channel, bool New=false)
Definition menu.c:176
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:240
cNestedItem * folder
Definition menu.c:704
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:761
cMenuEditFolder(const char *Dir, cList< cNestedItem > *List, cNestedItem *Folder=NULL)
Definition menu.c:713
char name[PATH_MAX]
Definition menu.c:705
eOSState Confirm(void)
Definition menu.c:738
cString GetFolder(void)
Definition menu.c:733
cList< cNestedItem > * list
Definition menu.c:703
cMenuEditIntItem(const char *Name, int *Value, int Min=0, int Max=INT_MAX, const char *MinString=NULL, const char *MaxString=NULL)
Definition menuitems.c:66
virtual void Set(void) override
Definition menuitems.c:81
virtual eOSState ProcessKey(eKeys Key) override
Definition menuitems.c:94
void SetValue(const char *Value)
Definition menuitems.c:37
eOSState ProcessKey(eKeys Key)
Definition menu.c:124
cMenuEditSrcItem(const char *Name, int *Value)
Definition menu.c:109
const cSource * source
Definition menu.c:101
virtual void Set(void) override
Definition menu.c:116
bool addIfConfirmed
Definition menu.h:79
eOSState SetFolder(void)
Definition menu.c:1117
cMenuEditDateItem * firstday
Definition menu.h:85
static const cTimer * addedTimer
Definition menu.h:75
int channel
Definition menu.h:78
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1148
cTimer data
Definition menu.h:77
void SetHelpKeys(void)
Definition menu.c:1069
cMenuEditStrItem * file
Definition menu.h:83
virtual ~cMenuEditTimer() override
Definition menu.c:1056
cMenuEditStrItem * pattern
Definition menu.h:82
cMenuEditDateItem * day
Definition menu.h:84
static const cTimer * AddedTimer(void)
Definition menu.c:1062
cTimer * timer
Definition menu.h:76
cMenuEditTimer(cTimer *Timer, bool New=false)
Definition menu.c:1017
void SetFirstDayItem(void)
Definition menu.c:1074
char remote[HOST_NAME_MAX]
Definition menu.h:81
cStringList svdrpServerNames
Definition menu.h:80
void SetPatternItem(bool Initial=false)
Definition menu.c:1087
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1531
const cEvent * event
Definition menu.h:99
virtual void Display(void) override
Definition menu.c:1522
cMenuEvent(const cTimers *Timers, const cChannels *Channels, const cEvent *Event, bool CanSwitch=false, bool Buttons=false)
Definition menu.c:1505
cMenuFolderItem(cNestedItem *Folder)
Definition menu.c:684
cNestedItem * Folder(void)
Definition menu.c:681
cNestedItem * folder
Definition menu.c:677
virtual void Set(void) override
Definition menu.c:691
cMenuFolder(const char *Title, cList< cNestedItem > *List, cNestedItemList *NestedItemList, const char *Dir, const char *Path=NULL)
Definition menu.c:794
eOSState Delete(void)
Definition menu.c:922
int helpKeys
Definition menu.h:41
eOSState New(void)
Definition menu.c:916
cNestedItemList * nestedItemList
Definition menu.h:36
cList< cNestedItem > * list
Definition menu.h:37
eOSState SetFolder(void)
Definition menu.c:950
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:974
cString dir
Definition menu.h:38
void Set(const char *CurrentFolder=NULL)
Definition menu.c:858
void DescendPath(const char *Path)
Definition menu.c:883
cOsdItem * firstFolder
Definition menu.h:39
eOSState Edit(void)
Definition menu.c:938
eOSState Select(bool Open)
Definition menu.c:900
bool editing
Definition menu.h:40
cString GetFolder(void)
Definition menu.c:961
void SetHelpKeys(void)
Definition menu.c:810
cOsdItem * cancelEditingItem
Definition menu.h:110
cOsdItem * stopRecordingItem
Definition menu.h:111
void Set(void)
Definition menu.c:4578
int recordControlsState
Definition menu.h:112
bool replaying
Definition menu.h:108
cOsdItem * stopReplayItem
Definition menu.h:109
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4673
bool Update(bool Force=false)
Definition menu.c:4615
cMenuMain(eOSState State=osUnknown, bool OpenSubMenus=false)
Definition menu.c:4531
static cOsdObject * pluginOsdObject
Definition menu.h:113
static cOsdObject * PluginOsdObject(void)
Definition menu.c:4571
eOSState ApplyChanges(void)
Definition menu.c:2601
int pathIsInUse
Definition menu.c:2526
cString oldFolder
Definition menu.c:2522
eOSState Folder(void)
Definition menu.c:2596
cMenuEditStrItem * folderItem
Definition menu.c:2525
eOSState SetFolder(void)
Definition menu.c:2586
cString path
Definition menu.c:2521
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2636
cMenuPathEdit(const char *Path)
Definition menu.c:2535
char name[NAME_MAX]
Definition menu.c:2524
char folder[PATH_MAX]
Definition menu.c:2523
cMenuPluginItem(const char *Name, int Index)
Definition menu.c:4518
int PluginIndex(void)
Definition menu.c:4515
int pluginIndex
Definition menu.c:4512
bool RefreshRecording(void)
Definition menu.c:2762
cMenuEditStrItem * nameItem
Definition menu.c:2667
const char * actionCancel
Definition menu.c:2671
cString originalFileName
Definition menu.c:2660
eOSState ApplyChanges(void)
Definition menu.c:2875
const char * doCopy
Definition menu.c:2673
eOSState Action(void)
Definition menu.c:2792
cMenuEditStrItem * folderItem
Definition menu.c:2666
eOSState SetFolder(void)
Definition menu.c:2777
void Set(void)
Definition menu.c:2713
char name[NAME_MAX]
Definition menu.c:2663
const char * buttonAction
Definition menu.c:2669
cStateKey recordingsStateKey
Definition menu.c:2661
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2921
const char * doCut
Definition menu.c:2672
eOSState RemoveName(void)
Definition menu.c:2829
void SetHelpKeys(void)
Definition menu.c:2736
eOSState Delete(void)
Definition menu.c:2847
const char * buttonDelete
Definition menu.c:2670
cMenuRecordingEdit(const cRecording *Recording)
Definition menu.c:2690
const char * buttonFolder
Definition menu.c:2668
const cRecording * recording
Definition menu.c:2659
eOSState Folder(void)
Definition menu.c:2787
char folder[PATH_MAX]
Definition menu.c:2662
const cRecording * recording
Definition menu.c:3045
int Level(void) const
Definition menu.c:3054
const cRecording * Recording(void) const
Definition menu.c:3055
const char * Name(void) const
Definition menu.c:3053
void IncrementCounter(bool New)
Definition menu.c:3082
bool IsDirectory(void) const
Definition menu.c:3056
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:3090
void SetRecording(const cRecording *Recording)
Definition menu.c:3057
cMenuRecordingItem(const cRecording *Recording, int Level)
Definition menu.c:3061
const cRecording * recording
Definition menu.c:2948
bool withButtons
Definition menu.c:2951
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2999
bool RefreshRecording(void)
Definition menu.c:2972
cString originalFileName
Definition menu.c:2949
cStateKey recordingsStateKey
Definition menu.c:2950
virtual void Display(void) override
Definition menu.c:2987
cMenuRecording(const cRecording *Recording, bool WithButtons=false)
Definition menu.c:2959
static cString path
Definition menu.h:217
void Set(bool Refresh=false)
Definition menu.c:3153
bool Open(bool OpenSubMenus=false)
Definition menu.c:3228
eOSState Sort(void)
Definition menu.c:3402
static void SetRecording(const char *FileName)
Definition menu.c:3212
eOSState Info(void)
Definition menu.c:3374
eOSState Play(void)
Definition menu.c:3244
const cRecordingFilter * filter
Definition menu.h:216
static cString fileName
Definition menu.h:218
char * base
Definition menu.h:212
eOSState Rewind(void)
Definition menu.c:3258
cStateKey recordingsStateKey
Definition menu.h:214
cMenuRecordings(const char *Base=NULL, int Level=0, bool OpenSubMenus=false, const cRecordingFilter *Filter=NULL)
Definition menu.c:3102
eOSState Commands(eKeys Key=kNone)
Definition menu.c:3387
cString DirectoryName(void)
Definition menu.c:3217
void SetHelpKeys(void)
Definition menu.c:3132
eOSState Delete(void)
Definition menu.c:3324
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3414
static void SetSortMode(eScheduleSortMode SortMode)
Definition menu.c:1577
const cChannel * channel
Definition menu.c:1571
cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel=NULL, bool WithDate=false)
Definition menu.c:1587
const cTimer * timer
Definition menu.c:1572
const cEvent * event
Definition menu.c:1570
static void IncSortMode(void)
Definition menu.c:1578
virtual int Compare(const cListObject &ListObject) const override
Must return 0 if this object is equal to ListObject, a positive value if it is "greater",...
Definition menu.c:1598
bool Update(const cTimers *Timers, bool Force=false)
Definition menu.c:1611
static eScheduleSortMode sortMode
Definition menu.c:1568
static eScheduleSortMode SortMode(void)
Definition menu.c:1579
eTimerMatch timerMatch
Definition menu.c:1574
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:1641
virtual ~cMenuSchedule() override
Definition menu.c:1900
bool PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:2000
bool canSwitch
Definition menu.c:1867
bool PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1941
void SetHelpKeys(void)
Definition menu.c:2032
int helpKeys
Definition menu.c:1868
cStateKey timersStateKey
Definition menu.c:1863
bool next
Definition menu.c:1866
void Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel=NULL, bool Force=false)
Definition menu.c:1905
bool Update(void)
Definition menu.c:2019
eOSState Record(void)
Definition menu.c:2066
cMenuSchedule(void)
Definition menu.c:1885
cStateKey schedulesStateKey
Definition menu.c:1864
eOSState Number(void)
Definition menu.c:2057
int scheduleState
Definition menu.c:1865
eOSState Switch(void)
Definition menu.c:2104
bool PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1960
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2121
bool PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1980
cMenuSetupBase(void)
Definition menu.c:3490
cSetup data
Definition menu.c:3484
virtual void Store(void) override
Definition menu.c:3495
cMenuSetupCAMItem(cCamSlot *CamSlot)
Definition menu.c:4010
bool Changed(void)
Definition menu.c:4017
cCamSlot * camSlot
Definition menu.c:4003
cCamSlot * CamSlot(void)
Definition menu.c:4006
void SetHelpKeys(void)
Definition menu.c:4081
cMenuSetupCAM(void)
Definition menu.c:4066
eOSState Menu(void)
Definition menu.c:4100
eOSState Reset(void)
Definition menu.c:4164
eOSState Activate(void)
Definition menu.c:4127
const char * activationHelp
Definition menu.c:4056
int currentChannel
Definition menu.c:4055
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4176
const char * updateChannelsTexts[6]
Definition menu.c:3778
int numAudioLanguages
Definition menu.c:3773
cMenuSetupDVB(void)
Definition menu.c:3786
int originalNumSubtitleLanguages
Definition menu.c:3774
void Setup(void)
Definition menu.c:3816
int numSubtitleLanguages
Definition menu.c:3775
const char * standardComplianceTexts[3]
Definition menu.c:3780
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3846
int originalNumAudioLanguages
Definition menu.c:3772
const char * videoDisplayFormatTexts[3]
Definition menu.c:3777
const char * displaySubtitlesTexts[3]
Definition menu.c:3779
int originalNumLanguages
Definition menu.c:3678
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3721
int numLanguages
Definition menu.c:3679
void Setup(void)
Definition menu.c:3697
cMenuSetupEPG(void)
Definition menu.c:3686
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3980
cSatCableNumbers satCableNumbers
Definition menu.c:3925
cMenuSetupLNB(void)
Definition menu.c:3932
void Setup(void)
Definition menu.c:3941
void Set(void)
Definition menu.c:4307
cMenuSetupMisc(void)
Definition menu.c:4294
const char * svdrpPeeringModeTexts[3]
Definition menu.c:4285
cStringList svdrpServerNames
Definition menu.c:4287
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4338
const char * showChannelNamesWithSourceTexts[3]
Definition menu.c:4286
virtual void Set(void)
Definition menu.c:3553
cStringList fontSmlNames
Definition menu.c:3518
cStringList fontOsdNames
Definition menu.c:3518
const char * recSortDirTexts[2]
Definition menu.c:3508
const char * useSmallFontTexts[3]
Definition menu.c:3506
int numSkins
Definition menu.c:3511
cStringList fontFixNames
Definition menu.c:3518
const char * recSortModeTexts[2]
Definition menu.c:3507
int fontOsdIndex
Definition menu.c:3519
const char * keyColorTexts[4]
Definition menu.c:3509
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3609
int skinIndex
Definition menu.c:3513
int originalSkinIndex
Definition menu.c:3512
int originalThemeIndex
Definition menu.c:3516
int fontFixIndex
Definition menu.c:3519
const char ** skinDescriptions
Definition menu.c:3514
cThemes themes
Definition menu.c:3515
int themeIndex
Definition menu.c:3517
virtual ~cMenuSetupOSD() override
Definition menu.c:3548
int fontSmlIndex
Definition menu.c:3519
cMenuSetupOSD(void)
Definition menu.c:3527
int osdLanguageIndex
Definition menu.c:3510
virtual eOSState ProcessKey(eKeys Key) override
Definition menuitems.c:1241
cMenuSetupPage(void)
Definition menuitems.c:1229
void SetSection(const char *Section)
Definition menuitems.c:1236
void SetPlugin(cPlugin *Plugin)
Definition menuitems.c:1256
cMenuSetupPluginItem(const char *Name, int Index)
Definition menu.c:4378
int PluginIndex(void)
Definition menu.c:4375
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4406
cMenuSetupPlugins(void)
Definition menu.c:4392
const char * pauseKeyHandlingTexts[3]
Definition menu.c:4204
const char * recordKeyHandlingTexts[3]
Definition menu.c:4203
cMenuSetupRecord(void)
Definition menu.c:4210
const char * delTimeshiftRecTexts[3]
Definition menu.c:4205
virtual void Store(void) override
Definition menu.c:4272
cMenuSetupReplay(void)
Definition menu.c:4251
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4482
virtual void Set(void)
Definition menu.c:4453
cMenuSetup(void)
Definition menu.c:4446
eOSState Restart(void)
Definition menu.c:4473
eDvbFont font
Definition menu.h:25
void SetText(const char *Text)
Definition menu.c:631
cMenuText(const char *Title, const char *Text, eDvbFont Font=fontOsd)
Definition menu.c:617
virtual void Display(void) override
Definition menu.c:637
char * text
Definition menu.h:24
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:645
virtual ~cMenuText() override
Definition menu.c:626
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:1295
virtual void Set(void) override
Definition menu.c:1249
virtual int Compare(const cListObject &ListObject) const override
Must return 0 if this object is equal to ListObject, a positive value if it is "greater",...
Definition menu.c:1244
cMenuTimerItem(const cTimer *Timer)
Definition menu.c:1238
const cTimer * timer
Definition menu.c:1229
const cTimer * Timer(void)
Definition menu.c:1234
eOSState New(void)
Definition menu.c:1416
cMenuTimers(void)
Definition menu.c:1322
void Set(void)
Definition menu.c:1335
void SetHelpKeys(void)
Definition menu.c:1364
eOSState Info(void)
Definition menu.c:1458
eOSState Edit(void)
Definition menu.c:1409
cTimer * GetTimer(void)
Definition menu.c:1358
cStateKey timersStateKey
Definition menu.c:1306
eOSState Delete(void)
Definition menu.c:1426
int helpKeys
Definition menu.c:1307
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1471
eOSState OnOff(void)
Definition menu.c:1379
virtual ~cMenuTimers() override
Definition menu.c:1331
void SetHelpKeys(const cChannels *Channels)
Definition menu.c:1707
static const cEvent * scheduleEvent
Definition menu.c:1661
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1798
static const cEvent * ScheduleEvent(void)
Definition menu.c:1735
eOSState Record(void)
Definition menu.c:1759
cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr)
Definition menu.c:1675
static void SetCurrentChannel(int ChannelNr)
Definition menu.c:1667
cStateKey timersStateKey
Definition menu.c:1657
static int CurrentChannel(void)
Definition menu.c:1666
eOSState Switch(void)
Definition menu.c:1742
bool canSwitch
Definition menu.c:1655
bool Update(void)
Definition menu.c:1694
static int currentChannel
Definition menu.c:1660
bool now
Definition menu.c:1654
int helpKeys
Definition menu.c:1656
void SetSubItems(bool On)
Definition config.c:162
cList< cNestedItem > * SubItems(void)
Definition config.h:213
const char * Text(void) const
Definition config.h:212
const char * Text(void) const
Definition osdbase.h:63
void SetSelectable(bool Selectable)
Definition osdbase.c:48
virtual eOSState ProcessKey(eKeys Key)
Definition osdbase.c:63
eOSState state
Definition osdbase.h:51
bool Selectable(void) const
Definition osdbase.h:59
void SetText(const char *Text, bool Copy=true)
Definition osdbase.c:42
cOsdItem(eOSState State=osUnknown)
Definition osdbase.c:20
void Ins(cOsdItem *Item, bool Current=false, cOsdItem *Before=NULL)
Definition osdbase.c:234
virtual eOSState ProcessKey(eKeys Key) override
Definition osdbase.c:573
eOSState CloseSubMenu(bool ReDisplay=true)
Definition osdbase.c:561
void SetTitle(const char *Title)
Definition osdbase.c:187
void DisplayCurrent(bool Current)
Definition osdbase.c:326
int Current(void) const
Definition osdbase.h:143
const char * hk(const char *s)
Definition osdbase.c:149
void Mark(void)
Definition osdbase.c:525
cOsdMenu * SubMenu(void)
Definition osdbase.h:132
void DisplayItem(cOsdItem *Item)
Definition osdbase.c:348
eOSState AddSubMenu(cOsdMenu *SubMenu)
Definition osdbase.c:551
void Add(cOsdItem *Item, bool Current=false, cOsdItem *After=NULL)
Definition osdbase.c:227
void SetHasHotkeys(bool HasHotkeys=true)
Definition osdbase.c:173
void SetCols(int c0, int c1=0, int c2=0, int c3=0, int c4=0)
Definition osdbase.c:164
void SetCurrent(cOsdItem *Item)
Definition osdbase.c:311
cOsdMenu(const char *Title, int c0=0, int c1=0, int c2=0, int c3=0, int c4=0)
Definition osdbase.c:83
void SetMenuCategory(eMenuCategory MenuCategory)
Definition osdbase.c:125
void RefreshCurrent(void)
Definition osdbase.c:319
void SetHelp(const char *Red, const char *Green=NULL, const char *Yellow=NULL, const char *Blue=NULL)
Definition osdbase.c:203
cSkinDisplayMenu * DisplayMenu(void)
Definition osdbase.h:112
virtual void Display(void)
Definition osdbase.c:248
bool HasSubMenu(void)
Definition osdbase.h:131
virtual void Del(int Index)
Definition osdbase.c:213
const char * Title(void)
Definition osdbase.h:117
virtual void Clear(void)
Definition osdbase.c:362
void SetMenuSortMode(eMenuSortMode MenuSortMode)
Definition osdbase.c:130
int current
Definition osdbase.h:94
void SetNeedsFastResponse(bool NeedsFastResponse)
Definition osdbase.h:75
cOsdObject(bool FastResponse=false)
Definition osdbase.h:77
bool IsMenu(void) const
Definition osdbase.h:80
static bool OsdSizeChanged(int &State)
Checks if the OSD size has changed and a currently displayed OSD needs to be redrawn.
Definition osd.c:2337
static void UpdateOsdSize(bool Force=false)
Inquires the actual size of the video display and adjusts the OSD and font sizes accordingly.
Definition osd.c:2310
static int IsOpen(void)
Returns true if there is currently a level 0 OSD open.
Definition osd.h:837
int Close(void)
Definition thread.c:1003
bool Open(const char *Command, const char *Mode)
Definition thread.c:949
static bool HasPlugins(void)
Definition plugin.c:465
static cPlugin * CallFirstService(const char *Id, void *Data=NULL)
Definition plugin.c:488
static cPlugin * GetPlugin(int Index)
Definition plugin.c:470
virtual cMenuSetupPage * SetupMenu(void)
Definition plugin.c:101
virtual const char * Version(void)=0
const char * Name(void)
Definition plugin.h:36
virtual const char * MainMenuEntry(void)
Definition plugin.c:91
virtual cOsdObject * MainMenuAction(void)
Definition plugin.c:96
virtual const char * Description(void)=0
A steerable satellite dish generally points to the south on the northern hemisphere,...
Definition positioner.h:31
virtual bool IsMoving(void) const
Returns true if the dish is currently moving as a result of a call to GotoPosition() or GotoAngle().
Definition positioner.c:127
virtual ~cRecordControl()
Definition menu.c:5494
const char * InstantId(void)
Definition menu.h:252
void Stop(bool ExecuteUserCommand=true)
Definition menu.c:5526
cDevice * device
Definition menu.h:239
cTimer * timer
Definition menu.h:240
bool GetEvent(void)
Definition menu.c:5502
char * fileName
Definition menu.h:244
cTimer * Timer(void)
Definition menu.h:254
cRecorder * recorder
Definition menu.h:241
cRecordControl(cDevice *Device, cTimers *Timers, cTimer *Timer=NULL, bool Pause=false)
Definition menu.c:5412
cDevice * Device(void)
Definition menu.h:250
const cEvent * event
Definition menu.h:242
bool Process(time_t t)
Definition menu.c:5548
cString instantId
Definition menu.h:243
static bool StateChanged(int &State)
Definition menu.c:5754
static const char * GetInstantId(const char *LastInstantId)
Definition menu.c:5673
static void ChannelDataModified(const cChannel *Channel)
Definition menu.c:5721
static bool Process(cTimers *Timers, time_t t)
Definition menu.c:5706
static bool PauseLiveVideo(void)
Definition menu.c:5658
static void Shutdown(void)
Definition menu.c:5747
static bool Start(cTimers *Timers, cTimer *Timer, bool Pause=false)
Definition menu.c:5563
static cRecordControl * RecordControls[]
Definition menu.h:5560
static bool Active(void)
Definition menu.c:5738
static void Stop(const char *InstantId)
Definition menu.c:5625
static cRecordControl * GetRecordControl(const char *FileName)
Definition menu.c:5686
static int state
Definition menu.h:260
static void ChangeState(void)
Definition menu.h:276
static void InvokeCommand(const char *State, const char *RecordingFileName, const char *SourceFileName=NULL)
Definition recording.c:2512
bool ChangePriorityLifetime(int NewPriority, int NewLifetime)
Changes the priority and lifetime of this recording to the given values.
Definition recording.c:1317
bool WriteInfo(const char *OtherFileName=NULL)
Writes in info file of this recording.
Definition recording.c:1289
bool ChangeName(const char *NewName)
Changes the name of this recording to the given value.
Definition recording.c:1340
bool Delete(void)
Changes the file name so that it will no longer be visible in the "Recordings" menu Returns false in ...
Definition recording.c:1368
cString Folder(void) const
Returns the name of the folder this recording is stored in (without the video directory).
Definition recording.c:1146
const char * Name(void) const
Returns the full name of the recording (without the video directory).
Definition recording.h:164
const char * FileName(void) const
Returns the full path name to the recording directory, including the video directory and the actual '...
Definition recording.c:1158
double FramesPerSecond(void) const
Definition recording.h:175
bool IsPesRecording(void) const
Definition recording.h:196
static const cRecordings * GetRecordingsRead(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of recordings for read access.
Definition recording.h:262
static cRecordings * GetRecordingsWrite(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of recordings for write access.
Definition recording.h:265
static void TouchUpdate(void)
Touches the '.update' file in the video directory, so that other instances of VDR that access the sam...
Definition recording.c:1644
void DelByName(const char *FileName)
Definition recording.c:1709
const cRecording * GetByName(const char *FileName) const
Definition recording.c:1681
bool Put(uint64_t Code, bool Repeat=false, bool Release=false)
Definition remote.c:124
static void TriggerLastActivity(void)
Simulates user activity, for instance to keep the current menu open even if no remote control key has...
Definition remote.c:204
static void SetRecording(const char *FileName)
Definition menu.c:5891
static const char * LastReplayed(void)
Definition menu.c:5901
void MarkToggle(void)
Definition menu.c:6111
virtual void Show(void) override
Definition menu.c:5927
static cString fileName
Definition menu.h:313
void TimeSearchDisplay(void)
Definition menu.c:6021
static void ClearLastReplayed(const char *FileName)
Definition menu.c:5909
int lastTotal
Definition menu.h:301
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:6296
void MarkMove(int Frames, bool MarkRequired)
Definition menu.c:6161
static cReplayControl * currentReplayControl
Definition menu.h:312
bool timeSearchHide
Definition menu.h:306
virtual const cRecording * GetRecording(void) override
Returns the cRecording that is currently being replayed, or NULL if this player is not playing a cRec...
Definition menu.c:6288
void TimeSearchProcess(eKeys Key)
Definition menu.c:6039
void MarkJump(bool Forward)
Definition menu.c:6136
cMarks marks
Definition menu.h:297
void EditCut(void)
Definition menu.c:6240
int timeSearchTime
Definition menu.h:307
cSkinDisplayReplay * displayReplay
Definition menu.h:295
void Stop(void)
Definition menu.c:5835
void ShowTimed(int Seconds=0)
Definition menu.c:5915
bool lastForward
Definition menu.h:302
virtual cOsdObject * GetInfo(void) override
Returns an OSD object that displays information about the currently played programme.
Definition menu.c:6280
bool displayFrames
Definition menu.h:299
bool shown
Definition menu.h:299
virtual void Hide(void) override
Definition menu.c:5932
time_t timeoutShow
Definition menu.h:304
void EditTest(void)
Definition menu.c:6264
bool timeSearchActive
Definition menu.h:306
bool ShowProgress(bool Initial)
Definition menu.c:5976
bool marksModified
Definition menu.h:298
int lastSpeed
Definition menu.h:303
cAdaptiveSkipper adaptiveSkipper
Definition menu.h:296
bool lastPlay
Definition menu.h:302
int timeSearchPos
Definition menu.h:307
virtual void ClearEditingMarks(void) override
Clears any editing marks this player might be showing.
Definition menu.c:5881
int lastErrors
Definition menu.h:300
virtual ~cReplayControl() override
Definition menu.c:5827
void ShowMode(void)
Definition menu.c:5951
void ErrorJump(bool Forward)
Definition menu.c:6199
cTimeMs updateTimer
Definition menu.h:305
void TimeSearch(void)
Definition menu.c:6093
bool visible
Definition menu.h:299
bool modeOnly
Definition menu.h:299
static const char * NowReplaying(void)
Definition menu.c:5896
cReplayControl(bool PauseLive=false)
Definition menu.c:5803
int lastCurrent
Definition menu.h:301
int Read(void)
Definition recording.c:260
void Delete(void)
Definition recording.c:343
const cSchedule * GetSchedule(tChannelID ChannelID) const
Definition epg.c:1381
static const cSchedules * GetSchedulesRead(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of schedules for read access.
Definition epg.c:1276
static void ResetVersions(void)
Definition epg.c:1307
virtual void SetRecording(const cRecording *Recording)=0
Sets the Recording that shall be displayed, using the entire central area of the menu.
virtual bool SetItemRecording(const cRecording *Recording, int Index, bool Current, bool Selectable, int Level, int Total, int New)
Sets the item at the given Index to Recording.
Definition skins.h:267
virtual void Scroll(bool Up, bool Page)
If this menu contains a text area that can be scrolled, this function will be called to actually scro...
Definition skins.c:107
virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable)=0
Sets the item at the given Index to Text.
virtual void SetEvent(const cEvent *Event)=0
Sets the Event that shall be displayed, using the entire central area of the menu.
virtual bool SetItemEvent(const cEvent *Event, int Index, bool Current, bool Selectable, const cChannel *Channel, bool WithDate, eTimerMatch TimerMatch, bool TimerActive)
Sets the item at the given Index to Event.
Definition skins.h:236
virtual bool SetItemChannel(const cChannel *Channel, int Index, bool Current, bool Selectable, bool WithProvider)
Sets the item at the given Index to Channel.
Definition skins.h:258
virtual bool SetItemTimer(const cTimer *Timer, int Index, bool Current, bool Selectable)
Sets the item at the given Index to Timer.
Definition skins.h:251
virtual void SetText(const char *Text, bool FixedFont)=0
Sets the Text that shall be displayed, using the entire central area of the menu.
Definition skins.h:402
const char * Name(void)
Definition skins.h:421
static cString ToString(int Code)
Definition sources.c:52
@ st_Mask
Definition sources.h:23
@ stSat
Definition sources.h:21
void Remove(bool IncState=true)
Removes this key from the lock it was previously used with.
Definition thread.c:869
static void MsgMarksModified(const cMarks *Marks)
Definition status.c:63
static void MsgOsdChannel(const char *Text)
Definition status.c:135
static void MsgSetAudioChannel(int AudioChannel)
Definition status.c:81
static void MsgOsdProgramme(time_t PresentTime, const char *PresentTitle, const char *PresentSubtitle, time_t FollowingTime, const char *FollowingTitle, const char *FollowingSubtitle)
Definition status.c:141
static void MsgReplaying(const cControl *Control, const char *Name, const char *FileName, bool On)
Definition status.c:57
static void MsgRecording(const cDevice *Device, const char *Name, const char *FileName, bool On)
Definition status.c:51
static void MsgOsdClear(void)
Definition status.c:93
static void MsgSetAudioTrack(int Index, const char *const *Tracks)
Definition status.c:75
static void MsgOsdTextItem(const char *Text, bool Scroll=false)
Definition status.c:129
static void MsgSetSubtitleTrack(int Index, const char *const *Tracks)
Definition status.c:87
void Sort(bool IgnoreCase=false)
Definition tools.h:843
int Find(const char *s) const
Definition tools.c:1630
cString & CompactChars(char c)
Compact any sequence of characters 'c' to a single character, and strip all of them from the beginnin...
Definition tools.c:1189
static cString sprintf(const char *fmt,...) __attribute__((format(printf
Definition tools.c:1195
void OnOff(void)
Definition timers.c:1087
cString PrintFirstDay(void) const
Definition timers.c:436
void SetPending(bool Pending)
Definition timers.c:1000
time_t FirstDay(void) const
Definition timers.h:78
bool Recording(void) const
Definition timers.h:65
void SetRemote(const char *Remote)
Definition timers.c:1048
const cEvent * Event(void) const
Definition timers.h:86
void Skip(void)
Definition timers.c:1080
const cChannel * Channel(void) const
Definition timers.h:69
bool Pending(void) const
Definition timers.h:66
cString ToDescr(void) const
Definition timers.c:333
bool SetEventFromSchedule(const cSchedules *Schedules)
Definition timers.c:922
int Priority(void) const
Definition timers.h:74
bool HasFlags(uint Flags) const
Definition timers.c:1075
const char * Remote(void) const
Definition timers.h:80
int Id(void) const
Definition timers.h:64
bool Matches(time_t t=0, bool Directly=false, int Margin=0) const
Definition timers.c:573
cString ToText(bool UseChannelID=false) const
Definition timers.c:323
void Add(cTimer *Timer, cTimer *After=NULL)
Definition timers.c:1244
static cTimers * GetTimersWrite(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of timers for write access.
Definition timers.c:1239
void Del(cTimer *Timer, bool DeleteObject=true)
Definition timers.c:1258
static const cTimers * GetTimersRead(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of timers for read access.
Definition timers.c:1234
const cTimer * GetMatch(time_t t) const
Definition timers.c:1160
int Size(void) const
Definition tools.h:754
void Sort(__compar_fn_t Compare)
Definition tools.h:811
virtual void Append(T Data)
Definition tools.h:774
T & At(int Index) const
Definition tools.h:731
static const char * Name(void)
Definition videodir.c:60
static int VideoDiskSpace(int *FreeMB=NULL, int *UsedMB=NULL)
Definition videodir.c:152
static void ForceCheck(void)
To avoid unnecessary load, the video disk usage is only actually checked every DISKSPACECHEK seconds.
Definition videodir.h:101
cNestedItemList Commands
Definition config.c:275
cSetup Setup
Definition config.c:372
cNestedItemList Folders
Definition config.c:274
cNestedItemList RecordingCommands
Definition config.c:276
#define SUBTITLES_NO
Definition config.h:85
#define TIMERMACRO_MATCH
Definition config.h:56
#define TIMERMACRO_AFTER
Definition config.h:57
#define MAXLIFETIME
Definition config.h:50
#define MAXPRIORITY
Definition config.h:45
#define VDRVERSION
Definition config.h:25
#define TIMERMACRO_BEFORE
Definition config.h:55
#define TIMERMACRO_EPISODE
Definition config.h:54
#define SUBTITLES_REWIND
Definition config.h:87
#define TIMERMACRO_TITLE
Definition config.h:53
#define LIVEPRIORITY
Definition config.h:47
#define MAXVOLUME
Definition device.h:32
eVideoDisplayFormat
Definition device.h:58
#define MAXDEVICES
Definition device.h:29
#define IS_AUDIO_TRACK(t)
Definition device.h:76
eTrackType
Definition device.h:63
@ ttSubtitle
Definition device.h:70
@ ttDolbyLast
Definition device.h:69
@ ttDolby
Definition device.h:67
@ ttAudioFirst
Definition device.h:65
@ ttSubtitleLast
Definition device.h:72
@ ttSubtitleFirst
Definition device.h:71
@ ttAudio
Definition device.h:64
@ ttNone
Definition device.h:63
#define IS_DOLBY_TRACK(t)
Definition device.h:77
cEITScanner EITScanner
Definition eitscan.c:104
#define LOCK_SCHEDULES_READ
Definition epg.h:228
#define MAXEPGBUGFIXLEVEL
Definition epg.h:21
const char * DefaultFontOsd
Definition font.c:24
const char * DefaultFontSml
Definition font.c:25
const char * DefaultFontFix
Definition font.c:26
eDvbFont
Definition font.h:21
@ fontFix
Definition font.h:23
const char * I18nLocale(int Language)
Returns the locale code of the given Language (which is an index as returned by I18nCurrentLanguage()...
Definition i18n.c:266
const cStringList * I18nLanguages(void)
Returns the list of available languages.
Definition i18n.c:249
int I18nNumLanguagesWithLocale(void)
Returns the number of entries in the list returned by I18nLanguages() that actually have a locale.
Definition i18n.c:244
int I18nCurrentLanguage(void)
Returns the index of the current language.
Definition i18n.c:231
void I18nSetLocale(const char *Locale)
Sets the current locale to Locale.
Definition i18n.c:217
void I18nSetLanguage(int Language)
Sets the current language index to Language.
Definition i18n.c:236
#define tr(s)
Definition i18n.h:85
cInterface * Interface
Definition interface.c:20
#define kMarkMoveForward
Definition keys.h:71
#define kMarkSkipForward
Definition keys.h:69
#define kMarkJumpBack
Definition keys.h:72
#define kEditCut
Definition keys.h:74
#define kMarkToggle
Definition keys.h:67
#define kMarkJumpForward
Definition keys.h:73
#define RAWKEY(k)
Definition keys.h:77
#define kEditTest
Definition keys.h:75
#define kMarkSkipBack
Definition keys.h:68
#define kMarkMoveBack
Definition keys.h:70
#define NORMALKEY(k)
Definition keys.h:79
eKeys
Definition keys.h:16
@ kRecord
Definition keys.h:34
@ kPlayPause
Definition keys.h:30
@ kRight
Definition keys.h:23
@ k_Flags
Definition keys.h:63
@ kPause
Definition keys.h:32
@ k9
Definition keys.h:28
@ kRed
Definition keys.h:24
@ kUp
Definition keys.h:17
@ kChanUp
Definition keys.h:40
@ kNone
Definition keys.h:55
@ kPlay
Definition keys.h:31
@ kFastFwd
Definition keys.h:35
@ k_Release
Definition keys.h:62
@ kDown
Definition keys.h:18
@ kGreen
Definition keys.h:25
@ k1
Definition keys.h:28
@ kStop
Definition keys.h:33
@ kSubtitles
Definition keys.h:47
@ kLeft
Definition keys.h:22
@ kBlue
Definition keys.h:27
@ kAudio
Definition keys.h:46
@ kMute
Definition keys.h:45
@ kPrev
Definition keys.h:38
@ k0
Definition keys.h:28
@ kYellow
Definition keys.h:26
@ kBack
Definition keys.h:21
@ k_Repeat
Definition keys.h:61
@ kFastRew
Definition keys.h:36
@ kChanDn
Definition keys.h:41
@ kVolDn
Definition keys.h:44
@ kNext
Definition keys.h:37
@ kOk
Definition keys.h:20
@ kVolUp
Definition keys.h:43
@ kInfo
Definition keys.h:29
static const char * TimerMatchChars
Definition menu.c:1609
static const char * TimerFileMacrosForPattern[]
Definition menu.c:998
#define NEWTIMERLIMIT
Definition menu.c:38
#define osUserRecRenamed
Definition menu.c:2514
#define MAXINSTANTRECTIME
Definition menu.c:44
#define NODISKSPACEDELTA
Definition menu.c:50
#define CAMRESPONSETIMEOUT
Definition menu.c:47
#define MAXRECORDCONTROLS
Definition menu.c:43
static bool RemoteTimerError(const cTimer *Timer)
Definition menu.c:1132
static void AddRecordingFolders(const cRecordings *Recordings, cList< cNestedItem > *List, char *Path)
Definition menu.c:824
#define CAMMENURETRYTIMEOUT
Definition menu.c:46
#define osUserRecEmpty
Definition menu.c:2517
cOsdObject * CamControl(void)
Definition menu.c:2498
bool CamMenuActive(void)
Definition menu.c:2507
#define STAY_SECONDS_OFF_END
#define osUserRecMoved
Definition menu.c:2515
#define MUTETIMEOUT
Definition menu.c:5122
void SetTrackDescriptions(int LiveChannel)
Definition menu.c:4779
#define MODETIMEOUT
Definition menu.c:37
#define TRACKTIMEOUT
Definition menu.c:5188
static bool CamMenuIsOpen
Definition menu.c:2314
#define CHANNELNUMBERTIMEOUT
Definition menu.c:352
static const char * TimerFileMacros[]
Definition menu.c:1008
#define INSTANT_REC_EPG_LOOKAHEAD
Definition menu.c:5500
#define FOLDERDELIMCHARSUBST
Definition menu.c:823
#define CHNAMWIDTH
Definition menu.c:54
#define CHNUMWIDTH
Definition menu.c:53
#define osUserRecRemoved
Definition menu.c:2516
#define MAXWAITFORCAMMENU
Definition menu.c:45
#define VOLUMETIMEOUT
Definition menu.c:5121
#define DEFERTIMER
Definition menu.c:41
#define PROGRESSTIMEOUT
Definition menu.c:48
#define MINFREEDISK
Definition menu.c:49
static bool TimerStillRecording(const char *FileName)
Definition menu.c:3272
static bool HandleRemoteModifications(cTimer *NewTimer, cTimer *OldTimer=NULL)
Definition menu.c:1138
#define MAXWAIT4EPGINFO
Definition menu.c:36
#define STOP_RECORDING
Definition menu.c:4527
void SetTrackDescriptions(int LiveChannel)
Definition menu.c:4779
eOSState
Definition osdbase.h:18
@ osUser5
Definition osdbase.h:40
@ osRecordings
Definition osdbase.h:23
@ osCancelEdit
Definition osdbase.h:32
@ osPause
Definition osdbase.h:27
@ osPlugin
Definition osdbase.h:24
@ osChannels
Definition osdbase.h:21
@ osStopReplay
Definition osdbase.h:31
@ osUser1
Definition osdbase.h:36
@ osUser8
Definition osdbase.h:43
@ osUser10
Definition osdbase.h:45
@ osRecord
Definition osdbase.h:28
@ osEnd
Definition osdbase.h:34
@ osSetup
Definition osdbase.h:25
@ osUser4
Definition osdbase.h:39
@ osStopRecord
Definition osdbase.h:30
@ osContinue
Definition osdbase.h:19
@ osUser6
Definition osdbase.h:41
@ osTimers
Definition osdbase.h:22
@ osReplay
Definition osdbase.h:29
@ osUser3
Definition osdbase.h:38
@ osUser2
Definition osdbase.h:37
@ osUnknown
Definition osdbase.h:18
@ osUser9
Definition osdbase.h:44
@ osSchedule
Definition osdbase.h:20
@ osCommands
Definition osdbase.h:26
@ osBack
Definition osdbase.h:33
@ osUser7
Definition osdbase.h:42
cString GetRecordingTimerId(const char *Directory)
Definition recording.c:3505
cString IndexToHMSF(int Index, bool WithFrame, double FramesPerSecond)
Definition recording.c:3400
void AssertFreeDiskSpace(int Priority, bool Force)
The special Priority value -1 means that we shall get rid of any deleted recordings faster than norma...
Definition recording.c:152
void GetRecordingsSortMode(const char *Directory)
Definition recording.c:3457
int SecondsToFrames(int Seconds, double FramesPerSecond)
Definition recording.c:3427
eRecordingsSortMode RecordingsSortMode
Definition recording.c:3450
bool EnoughFreeDiskSpaceForEdit(const char *FileName)
Definition recording.c:3537
char * ExchangeChars(char *s, bool ToFileSystem)
Definition recording.c:697
void IncRecordingsSortMode(const char *Directory)
Definition recording.c:3476
cDoneRecordings DoneRecordingsPattern
Definition recording.c:3307
cRecordingsHandler RecordingsHandler
Definition recording.c:2123
void SetRecordingTimerId(const char *Directory, const char *TimerId)
Definition recording.c:3487
@ ruCut
Definition recording.h:34
@ ruCopy
Definition recording.h:36
@ ruDst
Definition recording.h:39
@ ruNone
Definition recording.h:30
@ ruMove
Definition recording.h:35
@ ruPending
Definition recording.h:41
#define RUC_BEFORERECORDING
Definition recording.h:454
@ rsmName
Definition recording.h:587
#define RUC_AFTERRECORDING
Definition recording.h:456
#define LOCK_RECORDINGS_READ
Definition recording.h:329
#define MAXVIDEOFILESIZETS
Definition recording.h:481
#define FOLDERDELIMCHAR
Definition recording.h:22
#define LOCK_RECORDINGS_WRITE
Definition recording.h:330
#define MINVIDEOFILESIZE
Definition recording.h:483
cShutdownHandler ShutdownHandler
Definition shutdown.c:27
static const cCursesFont Font
Definition skincurses.c:31
cSkins Skins
Definition skins.c:253
@ mcSetupMisc
Definition skins.h:128
@ mcSetupOsd
Definition skins.h:121
@ mcSetupLnb
Definition skins.h:124
@ mcMain
Definition skins.h:107
@ mcSetup
Definition skins.h:120
@ mcChannel
Definition skins.h:111
@ mcRecordingInfo
Definition skins.h:116
@ mcSetupDvb
Definition skins.h:123
@ mcSetupRecord
Definition skins.h:126
@ mcCam
Definition skins.h:134
@ mcSetupReplay
Definition skins.h:127
@ mcChannelEdit
Definition skins.h:112
@ mcCommand
Definition skins.h:130
@ mcEvent
Definition skins.h:131
@ mcSetupCam
Definition skins.h:125
@ mcSchedule
Definition skins.h:108
@ mcText
Definition skins.h:132
@ mcRecording
Definition skins.h:115
@ mcRecordingEdit
Definition skins.h:117
@ mcTimerEdit
Definition skins.h:114
@ mcScheduleNow
Definition skins.h:109
@ mcSetupPlugins
Definition skins.h:129
@ mcFolder
Definition skins.h:133
@ mcSetupEpg
Definition skins.h:122
@ mcTimer
Definition skins.h:113
@ mcScheduleNext
Definition skins.h:110
@ mtWarning
Definition skins.h:37
@ mtInfo
Definition skins.h:37
@ mtError
Definition skins.h:37
@ mtStatus
Definition skins.h:37
@ msmProvider
Definition skins.h:142
@ msmTime
Definition skins.h:141
@ msmName
Definition skins.h:140
@ msmNumber
Definition skins.h:139
cSourceParams SourceParams
cSources Sources
Definition sources.c:114
Definition runvdr.c:107
char language[MAXLANGCODE2]
Definition epg.h:47
uchar stream
Definition epg.h:45
uchar type
Definition epg.h:46
char * description
Definition epg.h:48
char language[MAXLANGCODE2]
Definition device.h:82
char description[32]
Definition device.h:83
uint16_t id
Definition device.h:81
void StopSVDRPHandler(void)
Definition svdrp.c:2888
bool GetSVDRPServerNames(cStringList *ServerNames)
Gets a list of all available VDRs this VDR is connected to via SVDRP, and stores it in the given Serv...
Definition svdrp.c:2897
bool ExecSVDRPCommand(const char *ServerName, const char *Command, cStringList *Response)
Sends the given SVDRP Command string to the remote VDR identified by ServerName and collects all of t...
Definition svdrp.c:2906
void StartSVDRPHandler(void)
Definition svdrp.c:2872
int SVDRPCode(const char *s)
Returns the value of the three digit reply code of the given SVDRP response string.
Definition svdrp.h:47
cStateKey StateKeySVDRPRemoteTimersPoll
Controls whether a change to the local list of timers needs to result in sending a POLL to the remote...
bool HandleRemoteTimerModifications(cTimer *NewTimer, cTimer *OldTimer, cString *Msg)
Performs any operations necessary to synchronize changes to a timer between peer VDR machines.
Definition timers.c:1448
#define LOCK_TIMERS_READ
Definition timers.h:246
#define LOCK_TIMERS_WRITE
Definition timers.h:247
@ tfAvoid
Definition timers.h:24
@ tfInstant
Definition timers.h:20
@ tfActive
Definition timers.h:19
@ tfVps
Definition timers.h:21
@ tfRecording
Definition timers.h:22
@ tfSpawned
Definition timers.h:23
eTimerMatch
Definition timers.h:27
@ tmFull
Definition timers.h:27
@ tmNone
Definition timers.h:27
char * strcpyrealloc(char *dest, const char *src)
Definition tools.c:114
const char * strgetlast(const char *s, char c)
Definition tools.c:221
char * Utf8Strn0Cpy(char *Dest, const char *Src, int n)
Copies at most n character bytes from Src to Dest, making sure that the resulting copy ends with a co...
Definition tools.c:915
bool isempty(const char *s)
Definition tools.c:357
char * strreplace(char *s, char c1, char c2)
Definition tools.c:142
cString strescape(const char *s, const char *chars)
Definition tools.c:280
int strcountchr(const char *s, char c)
returns the number of occurrences of 'c' in 's'.
Definition tools.c:199
bool MakeDirs(const char *FileName, bool IsDirectory)
Definition tools.c:507
cString WeekDayName(int WeekDay)
Converts the given WeekDay (0=Sunday, 1=Monday, ...) to a three letter day name.
Definition tools.c:1218
char * stripspace(char *s)
Definition tools.c:227
int Utf8SymChars(const char *s, int Symbols)
Returns the number of character bytes at the beginning of the given string that form at most the give...
Definition tools.c:890
char * strn0cpy(char *dest, const char *src, size_t n)
Definition tools.c:131
cString itoa(int n)
Definition tools.c:450
const char * strchrn(const char *s, char c, size_t n)
returns a pointer to the n'th occurrence (counting from 1) of c in s, or NULL if no such character wa...
Definition tools.c:186
cString AddDirectory(const char *DirName, const char *FileName)
Definition tools.c:410
#define SECSINDAY
Definition tools.h:42
#define dsyslog(a...)
Definition tools.h:37
int CompareInts(const void *a, const void *b)
Definition tools.h:817
#define MALLOC(type, size)
Definition tools.h:47
char * skipspace(const char *s)
Definition tools.h:244
void DELETENULL(T *&p)
Definition tools.h:49
bool DoubleEqual(double a, double b)
Definition tools.h:97
T min(T a, T b)
Definition tools.h:63
T max(T a, T b)
Definition tools.h:64
#define esyslog(a...)
Definition tools.h:35
#define isyslog(a...)
Definition tools.h:36