vdr 2.7.7
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.32 2025/07/22 21:10:00 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:
1309 void Set(void);
1310 eOSState Edit(void);
1311 eOSState New(void);
1312 eOSState Delete(void);
1313 eOSState OnOff(void);
1314 eOSState Info(void);
1315 cTimer *GetTimer(void);
1316 void SetHelpKeys(void);
1317public:
1318 cMenuTimers(void);
1319 virtual ~cMenuTimers() override;
1320 virtual eOSState ProcessKey(eKeys Key) override;
1321 };
1322
1324:cOsdMenu(tr("Timers"), 2, CHNUMWIDTH, 10, 6, 6)
1325{
1327 helpKeys = -1;
1328 showAllTimers = true;
1329 cMenuEditTimer::AddedTimer(); // to clear any leftovers
1330 Set();
1331}
1332
1336
1338{
1339 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
1340 const cTimer *CurrentTimer = GetTimer();
1341 cMenuTimerItem *CurrentItem = NULL;
1342 Clear();
1343 {
1345 for (const cTimer *Timer = Timers->First(); Timer; Timer = Timers->Next(Timer)) {
1346 cMenuTimerItem *Item = new cMenuTimerItem(Timer);
1347 if (showAllTimers || Timer->HasFlags(tfActive)) {
1348 Add(Item);
1349 if (CurrentTimer && Timer->Id() == CurrentTimer->Id() && (!Timer->Remote() && !CurrentTimer->Remote() || Timer->Remote() && CurrentTimer->Remote() && strcmp(Timer->Remote(), CurrentTimer->Remote()) == 0))
1350 CurrentItem = Item;
1351 }
1352 }
1353 }
1354 Sort();
1355 SetCurrent(CurrentItem ? CurrentItem : First());
1356 SetHelpKeys();
1357 Display();
1358 timersStateKey.Remove();
1359 }
1360}
1361
1363{
1365 return item ? (cTimer *)item->Timer() : NULL;
1366}
1367
1369{
1370 int NewHelpKeys = 0;
1371 if (const cTimer *Timer = GetTimer()) {
1372 if (Timer->Event())
1373 NewHelpKeys = 2;
1374 else
1375 NewHelpKeys = 1;
1376 }
1377 if (NewHelpKeys != helpKeys) {
1378 helpKeys = NewHelpKeys;
1379 SetHelp(helpKeys > 0 ? tr("Button$On/Off") : NULL, tr("Button$New"), helpKeys > 0 ? tr("Button$Delete") : NULL, helpKeys == 2 ? tr("Button$Info") : NULL);
1380 }
1381}
1382
1384{
1385 if (HasSubMenu())
1386 return osContinue;
1387 cStateKey StateKey;
1388 cTimers *Timers = cTimers::GetTimersWrite(StateKey);
1389 cTimer *Timer = GetTimer();
1390 if (Timer) {
1391 Timer->OnOff();
1392 if (Timer->Remote()) {
1394 cStringList Response;
1395 if (!ExecSVDRPCommand(Timer->Remote(), cString::sprintf("MODT %d %s", Timer->Id(), *Timer->ToText(true)), &Response) || SVDRPCode(Response[0]) != 250)
1396 RemoteTimerError(Timer);
1397 }
1398 {
1400 Timer->SetEventFromSchedule(Schedules);
1401 }
1403 DisplayCurrent(true);
1404 if (Timer->FirstDay())
1405 isyslog("set first day of timer %s to %s", *Timer->ToDescr(), *Timer->PrintFirstDay());
1406 else
1407 isyslog("%sactivated timer %s", Timer->HasFlags(tfActive) ? "" : "de", *Timer->ToDescr());
1408 }
1409 StateKey.Remove(Timer != NULL);
1410 return osContinue;
1411}
1412
1414{
1415 if (HasSubMenu() || Count() == 0)
1416 return osContinue;
1417 return AddSubMenu(new cMenuEditTimer(GetTimer()));
1418}
1419
1421{
1422 if (HasSubMenu())
1423 return osContinue;
1424 cTimer *Timer = new cTimer;
1425 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
1426 Timer->SetRemote(Setup.SVDRPDefaultHost);
1427 return AddSubMenu(new cMenuEditTimer(Timer, true));
1428}
1429
1431{
1433 // Check if this timer is active:
1434 cTimer *Timer = GetTimer();
1435 if (Timer) {
1436 bool TimerRecording = Timer->Recording();
1437 timersStateKey.Remove(false); // must release lock while prompting!
1438 if (Interface->Confirm(tr("Delete timer?")) && (!TimerRecording || Interface->Confirm(tr("Timer still recording - really delete?")))) {
1440 Timer = GetTimer();
1441 if (Timer) {
1442 if (!Timer->Remote()) {
1443 Timer->Skip();
1444 cRecordControls::Process(Timers, time(NULL));
1445 }
1446 if (HandleRemoteModifications(NULL, Timer)) {
1447 if (Timer->Remote())
1449 Timers->Del(Timer);
1451 Display();
1452 }
1453 }
1454 }
1455 else
1456 return osContinue;
1457 }
1458 timersStateKey.Remove(Timer != NULL);
1459 return osContinue;
1460}
1461
1463{
1464 if (HasSubMenu() || Count() == 0)
1465 return osContinue;
1469 cTimer *Timer = GetTimer();
1470 if (Timer && Timer->Event())
1471 return AddSubMenu(new cMenuEvent(Timers, Channels, Timer->Event()));
1472 return osContinue;
1473}
1474
1476{
1477 if (!HasSubMenu())
1478 Set();
1479 eOSState state = cOsdMenu::ProcessKey(Key);
1480 bool oldShowAllTimers = showAllTimers;
1481 if (state == osUnknown) {
1482 switch (Key) {
1483 case k0: showAllTimers = !showAllTimers; break;
1484 case kOk: return Edit();
1485 case kRed: state = OnOff(); break; // must go through SetHelpKeys()!
1486 case kGreen: return New();
1487 case kYellow: state = Delete(); break;
1488 case kInfo:
1489 case kBlue: return Info();
1490 break;
1491 default: break;
1492 }
1493 }
1494 if (const cTimer *Timer = cMenuEditTimer::AddedTimer()) {
1495 // a newly created timer was confirmed with Ok and the proper item needs to be added:
1497 cMenuTimerItem *CurrentItem = new cMenuTimerItem(Timer);
1498 Add(CurrentItem, true);
1499 Sort();
1500 SetCurrent(CurrentItem);
1501 SetHelpKeys();
1502 Display();
1503 }
1504 if (showAllTimers != oldShowAllTimers) {
1505 timersStateKey.Reset();
1506 Set();
1507 }
1508 if (Key != kNone)
1509 SetHelpKeys();
1510 return state;
1511}
1512
1513// --- cMenuEvent ------------------------------------------------------------
1514
1515cMenuEvent::cMenuEvent(const cTimers *Timers, const cChannels *Channels, const cEvent *Event, bool CanSwitch, bool Buttons)
1516:cOsdMenu(tr("Event"))
1517{
1519 event = Event;
1520 if (event) {
1521 if (const cChannel *Channel = Channels->GetByChannelID(event->ChannelID(), true)) {
1522 SetTitle(Channel->Name());
1523 if (Buttons) {
1524 eTimerMatch TimerMatch = tmNone;
1525 Timers->GetMatch(event, &TimerMatch);
1526 SetHelp(TimerMatch == tmFull ? tr("Button$Timer") : tr("Button$Record"), NULL, NULL, CanSwitch ? tr("Button$Switch") : NULL);
1527 }
1528 }
1529 }
1530}
1531
1533{
1537 if (event->Description())
1538 cStatus::MsgOsdTextItem(event->Description());
1539}
1540
1542{
1543 switch (int(Key)) {
1544 case kUp|k_Repeat:
1545 case kUp:
1546 case kDown|k_Repeat:
1547 case kDown:
1548 case kLeft|k_Repeat:
1549 case kLeft:
1550 case kRight|k_Repeat:
1551 case kRight:
1552 DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight);
1553 cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft);
1554 return osContinue;
1555 case kInfo: return osBack;
1556 default: break;
1557 }
1558
1559 eOSState state = cOsdMenu::ProcessKey(Key);
1560
1561 if (state == osUnknown) {
1562 switch (Key) {
1563 case kGreen:
1564 case kYellow: return osContinue;
1565 case kOk: return osBack;
1566 default: break;
1567 }
1568 }
1569 return state;
1570}
1571
1572// --- cMenuScheduleItem -----------------------------------------------------
1573
1575public:
1576 enum eScheduleSortMode { ssmAllThis, ssmThisThis, ssmThisAll, ssmAllAll }; // "which event(s) on which channel(s)"
1577private:
1579public:
1586 cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel = NULL, bool WithDate = false);
1589 static eScheduleSortMode SortMode(void) { return sortMode; }
1590 virtual int Compare(const cListObject &ListObject) const override;
1591 bool Update(const cTimers *Timers, bool Force = false);
1592 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
1593 };
1594
1596
1597cMenuScheduleItem::cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel, bool WithDate)
1598{
1599 event = Event;
1600 channel = Channel;
1601 timer = NULL;
1602 withDate = WithDate;
1604 timerActive = false;
1605 Update(Timers, true);
1606}
1607
1608int cMenuScheduleItem::Compare(const cListObject &ListObject) const
1609{
1610 cMenuScheduleItem *p = (cMenuScheduleItem *)&ListObject;
1611 int r = -1;
1612 if (sortMode != ssmAllThis)
1613 r = strcoll(event->Title(), p->event->Title());
1614 if (sortMode == ssmAllThis || r == 0)
1615 r = event->StartTime() - p->event->StartTime();
1616 return r;
1617}
1618
1619static const char *TimerMatchChars = " tT iI";
1620
1621bool cMenuScheduleItem::Update(const cTimers *Timers, bool Force)
1622{
1625 eTimerMatch OldTimerMatch = timerMatch;
1626 bool OldTimerActive = timerActive;
1627 if (event->Schedule() && event->Schedule()->HasTimer())
1628 timer = Timers->GetMatch(event, &timerMatch);
1629 if (event->EndTime() < time(NULL) && !event->IsRunning() && (!timer || !timer->Recording()))
1631 timerActive = timer && timer->HasFlags(tfActive);
1632 if (Force || timerMatch != OldTimerMatch || timerActive != OldTimerActive) {
1633 cString buffer;
1634 char t = TimerMatchChars[timerMatch + (timerActive ? 0 : 3)];
1635 char v = event->Vps() && (event->Vps() - event->StartTime()) ? 'V' : ' ';
1636 char r = event->SeenWithin(30) && event->IsRunning() ? '*' : ' ';
1637 const char *csn = channel ? channel->ShortName(true) : NULL;
1638 cString eds = event->GetDateString();
1639 if (channel && withDate)
1640 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());
1641 else if (channel)
1642 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());
1643 else
1644 buffer = cString::sprintf("%.*s\t%s\t%c%c%c\t%s", Utf8SymChars(eds, 6), *eds, *event->GetTimeString(), t, v, r, event->Title());
1645 SetText(buffer);
1646 return true;
1647 }
1648 return false;
1649}
1650
1651void cMenuScheduleItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
1652{
1656 if (!DisplayMenu->SetItemEvent(event, Index, Current, Selectable, channel, withDate, timerMatch, timer))
1657 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
1658}
1659
1660// --- cMenuWhatsOn ----------------------------------------------------------
1661
1662class cMenuWhatsOn : public cOsdMenu {
1663private:
1664 bool now;
1668 eOSState Record(void);
1669 eOSState Switch(void);
1670 static int currentChannel;
1671 static const cEvent *scheduleEvent;
1672 bool Update(void);
1673 void SetHelpKeys(const cChannels *Channels);
1674public:
1675 cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr);
1676 static int CurrentChannel(void) { return currentChannel; }
1677 static void SetCurrentChannel(int ChannelNr) { currentChannel = ChannelNr; }
1678 static const cEvent *ScheduleEvent(void);
1679 virtual eOSState ProcessKey(eKeys Key) override;
1680 };
1681
1684
1685cMenuWhatsOn::cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr)
1686:cOsdMenu(Now ? tr("What's on now?") : tr("What's on next?"), CHNUMWIDTH, CHNAMWIDTH, 6, 4)
1687{
1689 now = Now;
1690 canSwitch = false;
1691 helpKeys = 0;
1692 for (const cChannel *Channel = Channels->First(); Channel; Channel = Channels->Next(Channel)) {
1693 if (!Channel->GroupSep()) {
1694 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1695 if (const cEvent *Event = Now ? Schedule->GetPresentEvent() : Schedule->GetFollowingEvent())
1696 Add(new cMenuScheduleItem(Timers, Event, Channel), Channel->Number() == CurrentChannelNr);
1697 }
1698 }
1699 }
1700 currentChannel = CurrentChannelNr;
1701 SetHelpKeys(Channels);
1702}
1703
1705{
1706 bool result = false;
1707 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
1708 for (cOsdItem *item = First(); item; item = Next(item)) {
1709 if (((cMenuScheduleItem *)item)->Update(Timers))
1710 result = true;
1711 }
1712 timersStateKey.Remove();
1713 }
1714 return result;
1715}
1716
1718{
1720 canSwitch = false;
1721 int NewHelpKeys = 0;
1722 if (item) {
1723 if (item->timerMatch == tmFull)
1724 NewHelpKeys |= 0x02; // "Timer"
1725 else
1726 NewHelpKeys |= 0x01; // "Record"
1727 if (now)
1728 NewHelpKeys |= 0x04; // "Next"
1729 else
1730 NewHelpKeys |= 0x08; // "Now"
1731 if (const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) {
1732 if (Channel->Number() != cDevice::CurrentChannel()) {
1733 NewHelpKeys |= 0x10; // "Switch"
1734 canSwitch = true;
1735 }
1736 }
1737 }
1738 if (NewHelpKeys != helpKeys) {
1739 const char *Red[] = { NULL, tr("Button$Record"), tr("Button$Timer") };
1740 SetHelp(Red[NewHelpKeys & 0x03], now ? tr("Button$Next") : tr("Button$Now"), tr("Button$Schedule"), canSwitch ? tr("Button$Switch") : NULL);
1741 helpKeys = NewHelpKeys;
1742 }
1743}
1744
1746{
1747 const cEvent *ei = scheduleEvent;
1748 scheduleEvent = NULL;
1749 return ei;
1750}
1751
1753{
1755 if (item) {
1757 const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true);
1758 if (Channel) {
1759 if (!cDevice::PrimaryDevice()->SwitchChannel(Channel, true))
1760 Channel = NULL;
1761 }
1762 if (Channel)
1763 return osEnd;
1764 }
1765 Skins.Message(mtError, tr("Can't switch channel!"));
1766 return osContinue;
1767}
1768
1770{
1771 if (cMenuScheduleItem *item = (cMenuScheduleItem *)Get(Current())) {
1775 Timers->SetExplicitModify();
1776 if (item->timerMatch == tmFull) {
1777 if (cTimer *Timer = Timers->GetMatch(item->event))
1778 return AddSubMenu(new cMenuEditTimer(Timer));
1779 }
1780 cTimer *Timer = new cTimer(item->event);
1781 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
1782 Timer->SetRemote(Setup.SVDRPDefaultHost);
1783 if (cTimer *t = Timers->GetTimer(Timer)) {
1784 delete Timer;
1785 Timer = t;
1786 return AddSubMenu(new cMenuEditTimer(Timer));
1787 }
1788 if (Timer->Matches(0, NEWTIMERLIMIT))
1789 return AddSubMenu(new cMenuEditTimer(Timer, true));
1790 Timers->Add(Timer);
1791 Timers->SetModified();
1792 if (!HandleRemoteModifications(Timer)) {
1793 // must add the timer before HandleRemoteModifications to get proper log messages with timer ids
1794 Timers->Del(Timer);
1795 }
1796 else if (Timer->Remote())
1797 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
1798 if (HasSubMenu())
1799 CloseSubMenu();
1800 }
1801 if (Update())
1802 Display();
1804 SetHelpKeys(Channels);
1805 return osContinue;
1806}
1807
1809{
1810 bool HadSubMenu = HasSubMenu();
1811 eOSState state = cOsdMenu::ProcessKey(Key);
1812
1813 if (state == osUnknown) {
1814 switch (int(Key)) {
1815 case kRecord:
1816 case kRed: return Record();
1817 case kYellow: state = osBack;
1818 // continue with kGreen
1819 case kGreen: {
1821 if (mi) {
1823 scheduleEvent = mi->event;
1824 currentChannel = mi->channel->Number();
1825 }
1826 }
1827 break;
1828 case kBlue: if (canSwitch)
1829 return Switch();
1830 break;
1831 case kChanUp|k_Repeat:
1832 case kChanUp:
1833 case kChanDn|k_Repeat:
1834 case kChanDn: if (!HasSubMenu()) {
1837 for (cOsdItem *item = First(); item; item = Next(item)) {
1838 if (((cMenuScheduleItem *)item)->channel->Number() == cDevice::CurrentChannel()) {
1839 DisplayCurrent(false);
1840 SetCurrent(item);
1841 DisplayCurrent(true);
1842 SetHelpKeys(Channels);
1843 break;
1844 }
1845 }
1846 }
1847 break;
1848 case kInfo:
1849 case kOk: if (Count()) {
1852 return AddSubMenu(new cMenuEvent(Timers, Channels, ((cMenuScheduleItem *)Get(Current()))->event, canSwitch, true));
1853 }
1854 break;
1855 default: break;
1856 }
1857 }
1858 else if (!HasSubMenu()) {
1859 if (HadSubMenu && Update())
1860 Display();
1861 if (Key != kNone) {
1863 SetHelpKeys(Channels);
1864 }
1865 }
1866 return state;
1867}
1868
1869// --- cMenuSchedule ---------------------------------------------------------
1870
1871class cMenuSchedule : public cOsdMenu {
1872private:
1876 bool now, next;
1879 void Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel = NULL, bool Force = false);
1880 eOSState Number(void);
1881 eOSState Record(void);
1882 eOSState Switch(void);
1883 bool PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1884 bool PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1885 bool PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1886 bool PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel);
1887 bool Update(void);
1888 void SetHelpKeys(void);
1889public:
1890 cMenuSchedule(void);
1891 virtual ~cMenuSchedule() override;
1892 virtual eOSState ProcessKey(eKeys Key) override;
1893 };
1894
1896:cOsdMenu(tr("Schedule"))
1897{
1899 scheduleState = -1;
1900 now = next = false;
1901 canSwitch = false;
1902 helpKeys = 0;
1907 Set(Timers, Channels, NULL, true);
1908}
1909
1911{
1912 cMenuWhatsOn::ScheduleEvent(); // makes sure any posted data is cleared
1913}
1914
1915void cMenuSchedule::Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel, bool Force)
1916{
1917 if (Force) {
1918 schedulesStateKey.Reset();
1919 scheduleState = -1;
1920 }
1922 cMenuScheduleItem *CurrentItem = (cMenuScheduleItem *)Get(Current());
1923 const cEvent *Event = NULL;
1924 if (!Channel) {
1925 if (CurrentItem) {
1926 Event = CurrentItem->event;
1927 Channel = Channels->GetByChannelID(Event->ChannelID(), true);
1928 }
1929 else
1930 Channel = Channels->GetByNumber(cDevice::CurrentChannel());
1931 }
1932 bool Refresh = false;
1933 switch (cMenuScheduleItem::SortMode()) {
1934 case cMenuScheduleItem::ssmAllThis: Refresh = PrepareScheduleAllThis(Timers, Schedules, Event, Channel); break;
1935 case cMenuScheduleItem::ssmThisThis: Refresh = PrepareScheduleThisThis(Timers, Schedules, Event, Channel); break;
1936 case cMenuScheduleItem::ssmThisAll: Refresh = Force && PrepareScheduleThisAll(Timers, Schedules, Event, Channel); break;
1937 case cMenuScheduleItem::ssmAllAll: Refresh = Force && PrepareScheduleAllAll(Timers, Schedules, Event, Channel); break;
1938 default: esyslog("ERROR: unknown SortMode %d (%s %d)", cMenuScheduleItem::SortMode(), __FUNCTION__, __LINE__);
1939 }
1940 if (Refresh) {
1941 CurrentItem = (cMenuScheduleItem *)Get(Current());
1942 Sort();
1943 SetCurrent(CurrentItem);
1944 SetHelpKeys();
1945 Display();
1946 }
1947 schedulesStateKey.Remove();
1948 }
1949}
1950
1951bool cMenuSchedule::PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1952{
1953 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1954 if (Schedule->Modified(scheduleState)) {
1955 Clear();
1956 SetCols(7, 6, 4);
1957 SetTitle(cString::sprintf(tr("Schedule - %s"), Channel->Name()));
1958 const cEvent *PresentEvent = Event ? Event : Schedule->GetPresentEvent();
1959 time_t now = time(NULL) - Setup.EPGLinger * 60;
1960 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
1961 if (ev->EndTime() > now || ev == PresentEvent)
1962 Add(new cMenuScheduleItem(Timers, ev), ev == PresentEvent);
1963 }
1964 return true;
1965 }
1966 }
1967 return false;
1968}
1969
1970bool cMenuSchedule::PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1971{
1972 if (Event) {
1973 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
1974 if (Schedule->Modified(scheduleState)) {
1975 Clear();
1976 SetCols(7, 6, 4);
1977 SetTitle(cString::sprintf(tr("This event - %s"), Channel->Name()));
1978 time_t now = time(NULL) - Setup.EPGLinger * 60;
1979 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
1980 if ((ev->EndTime() > now || ev == Event) && !strcmp(ev->Title(), Event->Title()))
1981 Add(new cMenuScheduleItem(Timers, ev), ev == Event);
1982 }
1983 return true;
1984 }
1985 }
1986 }
1987 return false;
1988}
1989
1990bool cMenuSchedule::PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
1991{
1992 Clear();
1993 SetCols(CHNUMWIDTH, CHNAMWIDTH, 7, 6, 4);
1994 SetTitle(tr("This event - all channels"));
1995 if (Event) {
1997 for (const cChannel *ch = Channels->First(); ch; ch = Channels->Next(ch)) {
1998 if (const cSchedule *Schedule = Schedules->GetSchedule(ch)) {
1999 time_t now = time(NULL) - Setup.EPGLinger * 60;
2000 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
2001 if ((ev->EndTime() > now || ev == Event) && !strcmp(ev->Title(), Event->Title()))
2002 Add(new cMenuScheduleItem(Timers, ev, ch, true), ev == Event && ch == Channel);
2003 }
2004 }
2005 }
2006 }
2007 return true;
2008}
2009
2010bool cMenuSchedule::PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
2011{
2012 Clear();
2013 SetCols(CHNUMWIDTH, CHNAMWIDTH, 7, 6, 4);
2014 SetTitle(tr("All events - all channels"));
2016 cStateKey StateKey;
2017 for (const cChannel *ch = Channels->First(); ch; ch = Channels->Next(ch)) {
2018 if (const cSchedule *Schedule = Schedules->GetSchedule(ch)) {
2019 time_t now = time(NULL) - Setup.EPGLinger * 60;
2020 for (const cEvent *ev = Schedule->Events()->First(); ev; ev = Schedule->Events()->Next(ev)) {
2021 if (ev->EndTime() > now || ev == Event)
2022 Add(new cMenuScheduleItem(Timers, ev, ch, true), ev == Event && ch == Channel);
2023 }
2024 }
2025 }
2026 return true;
2027}
2028
2030{
2031 bool result = false;
2032 if (const cTimers *Timers = cTimers::GetTimersRead(timersStateKey)) {
2033 for (cOsdItem *item = First(); item; item = Next(item)) {
2034 if (((cMenuScheduleItem *)item)->Update(Timers))
2035 result = true;
2036 }
2037 timersStateKey.Remove();
2038 }
2039 return result;
2040}
2041
2043{
2045 canSwitch = false;
2046 int NewHelpKeys = 0;
2047 if (item) {
2048 if (item->timerMatch == tmFull)
2049 NewHelpKeys |= 0x02; // "Timer"
2050 else
2051 NewHelpKeys |= 0x01; // "Record"
2053 if (const cChannel *Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) {
2054 if (Channel->Number() != cDevice::CurrentChannel()) {
2055 NewHelpKeys |= 0x10; // "Switch"
2056 canSwitch = true;
2057 }
2058 }
2059 }
2060 if (NewHelpKeys != helpKeys) {
2061 const char *Red[] = { NULL, tr("Button$Record"), tr("Button$Timer") };
2062 SetHelp(Red[NewHelpKeys & 0x03], tr("Button$Now"), tr("Button$Next"), canSwitch ? tr("Button$Switch") : NULL);
2063 helpKeys = NewHelpKeys;
2064 }
2065}
2066
2068{
2072 Set(Timers, Channels, NULL, true);
2073 return osContinue;
2074}
2075
2077{
2078 if (cMenuScheduleItem *item = (cMenuScheduleItem *)Get(Current())) {
2082 Timers->SetExplicitModify();
2083 if (item->timerMatch == tmFull) {
2084 if (cTimer *Timer = Timers->GetMatch(item->event))
2085 return AddSubMenu(new cMenuEditTimer(Timer));
2086 }
2087 cTimer *Timer = new cTimer(item->event);
2088 if (Setup.SVDRPPeering && *Setup.SVDRPDefaultHost)
2089 Timer->SetRemote(Setup.SVDRPDefaultHost);
2090 if (cTimer *t = Timers->GetTimer(Timer)) {
2091 delete Timer;
2092 Timer = t;
2093 return AddSubMenu(new cMenuEditTimer(Timer));
2094 }
2095 if (Timer->Matches(0, NEWTIMERLIMIT))
2096 return AddSubMenu(new cMenuEditTimer(Timer, true));
2097 Timers->Add(Timer);
2098 Timers->SetModified();
2099 if (!HandleRemoteModifications(Timer)) {
2100 // must add the timer before HandleRemoteModifications to get proper log messages with timer ids
2101 Timers->Del(Timer);
2102 }
2103 else if (Timer->Remote())
2104 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
2105 if (HasSubMenu())
2106 CloseSubMenu();
2107 }
2108 if (Update())
2109 Display();
2110 SetHelpKeys();
2111 return osContinue;
2112}
2113
2115{
2117 if (item) {
2119 const cChannel *Channel = NULL;
2120 if ((Channel = Channels->GetByChannelID(item->event->ChannelID(), true)) != NULL) {
2121 if (!Channels->SwitchTo(Channel->Number()))
2122 Channel = NULL;
2123 }
2124 if (Channel)
2125 return osEnd;
2126 }
2127 Skins.Message(mtError, tr("Can't switch channel!"));
2128 return osContinue;
2129}
2130
2132{
2133 if (!HasSubMenu()) {
2136 Set(Timers, Channels); // react on any changes to the schedules list
2137 }
2138 bool HadSubMenu = HasSubMenu();
2139 eOSState state = cOsdMenu::ProcessKey(Key);
2140
2141 if (state == osUnknown) {
2142 switch (int(Key)) {
2143 case k0: return Number();
2144 case kRecord:
2145 case kRed: return Record();
2146 case kGreen: {
2150 if (!now && !next) {
2151 int ChannelNr = 0;
2152 if (Count()) {
2153 if (const cChannel *Channel = Channels->GetByChannelID(((cMenuScheduleItem *)Get(Current()))->event->ChannelID(), true))
2154 ChannelNr = Channel->Number();
2155 }
2156 now = true;
2157 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, now, ChannelNr));
2158 }
2159 now = !now;
2160 next = !next;
2161 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, now, cMenuWhatsOn::CurrentChannel()));
2162 }
2163 case kYellow: {
2167 return AddSubMenu(new cMenuWhatsOn(Timers, Channels, Schedules, false, cMenuWhatsOn::CurrentChannel()));
2168 }
2169 case kBlue: if (canSwitch)
2170 return Switch();
2171 break;
2172 case kChanUp|k_Repeat:
2173 case kChanUp:
2174 case kChanDn|k_Repeat:
2175 case kChanDn: if (!HasSubMenu()) {
2178 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel()))
2179 Set(Timers, Channels, Channel, true);
2180 }
2181 break;
2182 case kInfo:
2183 case kOk: if (Count()) {
2187 return AddSubMenu(new cMenuEvent(Timers, Channels, ((cMenuScheduleItem *)Get(Current()))->event, canSwitch, true));
2188 }
2189 break;
2190 default: break;
2191 }
2192 }
2193 else if (!HasSubMenu()) {
2194 now = next = false;
2195 if (const cEvent *ei = cMenuWhatsOn::ScheduleEvent()) {
2198 if (const cChannel *Channel = Channels->GetByChannelID(ei->ChannelID(), true)) {
2200 Set(Timers, Channels, Channel, true);
2201 }
2202 }
2203 else if (HadSubMenu && Update())
2204 Display();
2205 if (Key != kNone)
2206 SetHelpKeys();
2207 }
2208 return state;
2209}
2210
2211// --- cMenuCommands ---------------------------------------------------------
2212
2215{
2217 result = NULL;
2218 SetHasHotkeys();
2220 parameters = Parameters;
2221 for (cNestedItem *Command = commands->First(); Command; Command = commands->Next(Command)) {
2222 const char *s = Command->Text();
2223 if (Command->SubItems())
2224 Add(new cOsdItem(hk(cString::sprintf("%s...", s))));
2225 else if (Parse(s))
2226 Add(new cOsdItem(hk(title)));
2227 }
2228}
2229
2231{
2232 free(result);
2233}
2234
2235bool cMenuCommands::Parse(const char *s)
2236{
2237 const char *p = strchr(s, ':');
2238 if (p) {
2239 int l = p - s;
2240 if (l > 0) {
2241 char t[l + 1];
2242 stripspace(strn0cpy(t, s, l + 1));
2243 l = strlen(t);
2244 if (l > 1 && t[l - 1] == '?') {
2245 t[l - 1] = 0;
2246 confirm = true;
2247 }
2248 else
2249 confirm = false;
2250 title = t;
2251 command = skipspace(p + 1);
2252 return true;
2253 }
2254 }
2255 return false;
2256}
2257
2259{
2260 cNestedItem *Command = commands->Get(Current());
2261 if (Command) {
2262 if (Command->SubItems())
2263 return AddSubMenu(new cMenuCommands(Title(), Command->SubItems(), parameters));
2264 if (Parse(Command->Text())) {
2265 if (!confirm || Interface->Confirm(cString::sprintf("%s?", *title))) {
2266 Skins.Message(mtStatus, cString::sprintf("%s...", *title));
2267 free(result);
2268 result = NULL;
2269 cString cmdbuf;
2270 if (!isempty(parameters))
2271 cmdbuf = cString::sprintf("%s %s", *command, *parameters);
2272 const char *cmd = *cmdbuf ? *cmdbuf : *command;
2273 dsyslog("executing command '%s'", cmd);
2274 cPipe p;
2275 if (p.Open(cmd, "r")) {
2276 int l = 0;
2277 int c;
2278 while ((c = fgetc(p)) != EOF) {
2279 if (l % 20 == 0) {
2280 if (char *NewBuffer = (char *)realloc(result, l + 21))
2281 result = NewBuffer;
2282 else {
2283 esyslog("ERROR: out of memory");
2284 break;
2285 }
2286 }
2287 result[l++] = char(c);
2288 }
2289 if (result)
2290 result[l] = 0;
2291 p.Close();
2292 }
2293 else
2294 esyslog("ERROR: can't open pipe for command '%s'", cmd);
2295 Skins.Message(mtStatus, NULL);
2296 if (result)
2297 return AddSubMenu(new cMenuText(title, result, fontFix));
2298 return osEnd;
2299 }
2300 }
2301 }
2302 return osContinue;
2303}
2304
2306{
2307 eOSState state = cOsdMenu::ProcessKey(Key);
2308
2309 if (state == osUnknown) {
2310 switch (Key) {
2311 case kRed:
2312 case kGreen:
2313 case kYellow:
2314 case kBlue: return osContinue;
2315 case kOk: return Execute();
2316 default: break;
2317 }
2318 }
2319 return state;
2320}
2321
2322// --- cMenuCam --------------------------------------------------------------
2323
2324static bool CamMenuIsOpen = false;
2325
2326class cMenuCam : public cOsdMenu {
2327private:
2331 char *input;
2334 void GenerateTitle(const char *s = NULL);
2335 void QueryCam(void);
2336 void AddMultiLineItem(const char *s);
2337 void Set(void);
2338 eOSState Select(void);
2339public:
2340 cMenuCam(cCamSlot *CamSlot);
2341 virtual ~cMenuCam() override;
2342 virtual eOSState ProcessKey(eKeys Key) override;
2343 };
2344
2346:cOsdMenu("", 1) // tab necessary for enquiry!
2347{
2349 camSlot = CamSlot;
2350 ciMenu = NULL;
2351 ciEnquiry = NULL;
2352 input = NULL;
2353 offset = 0;
2354 lastCamExchange = time(NULL);
2356 QueryCam();
2357 CamMenuIsOpen = true;
2358}
2359
2361{
2362 if (ciMenu)
2363 ciMenu->Abort();
2364 delete ciMenu;
2365 if (ciEnquiry)
2366 ciEnquiry->Abort();
2367 delete ciEnquiry;
2368 free(input);
2369 CamMenuIsOpen = false;
2370}
2371
2372void cMenuCam::GenerateTitle(const char *s)
2373{
2374 SetTitle(cString::sprintf("CAM %d - %s", camSlot->SlotNumber(), (s && *s) ? s : camSlot->GetCamName()));
2375}
2376
2378{
2379 delete ciMenu;
2380 ciMenu = NULL;
2381 delete ciEnquiry;
2382 ciEnquiry = NULL;
2383 if (camSlot->HasUserIO()) {
2384 ciMenu = camSlot->GetMenu();
2385 ciEnquiry = camSlot->GetEnquiry();
2386 }
2387 Set();
2388}
2389
2391{
2392 if (ciMenu) {
2393 Clear();
2394 free(input);
2395 input = NULL;
2396 dsyslog("CAM %d: Menu ------------------", camSlot->SlotNumber());
2397 offset = 0;
2398 SetHasHotkeys(ciMenu->Selectable());
2399 GenerateTitle(ciMenu->TitleText());
2400 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->TitleText());
2401 if (!isempty(ciMenu->SubTitleText())) {
2402 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->SubTitleText());
2403 AddMultiLineItem(ciMenu->SubTitleText());
2404 offset = Count();
2405 }
2406 for (int i = 0; i < ciMenu->NumEntries(); i++) {
2407 Add(new cOsdItem(hk(ciMenu->Entry(i)), osUnknown, ciMenu->Selectable()));
2408 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->Entry(i));
2409 }
2410 if (!isempty(ciMenu->BottomText())) {
2411 AddMultiLineItem(ciMenu->BottomText());
2412 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciMenu->BottomText());
2413 }
2415 }
2416 else if (ciEnquiry) {
2417 Clear();
2418 int Length = ciEnquiry->ExpectedLength();
2419 free(input);
2420 input = MALLOC(char, Length + 1);
2421 *input = 0;
2422 dsyslog("CAM %d: Enquiry ------------------", camSlot->SlotNumber());
2423 GenerateTitle();
2424 Add(new cOsdItem(ciEnquiry->Text(), osUnknown, false));
2425 dsyslog("CAM %d: '%s'", camSlot->SlotNumber(), ciEnquiry->Text());
2426 Add(new cOsdItem("", osUnknown, false));
2427 Add(new cMenuEditNumItem("", input, Length, ciEnquiry->Blind()));
2428 }
2429 Display();
2430}
2431
2433{
2434 while (s && *s) {
2435 const char *p = strchr(s, '\n');
2436 int l = p ? p - s : strlen(s);
2437 cOsdItem *item = new cOsdItem;
2438 item->SetSelectable(false);
2439 item->SetText(strndup(s, l), false);
2440 Add(item);
2441 s = p ? p + 1 : p;
2442 }
2443}
2444
2446{
2447 if (ciMenu) {
2448 if (ciMenu->Selectable()) {
2449 ciMenu->Select(Current() - offset);
2450 dsyslog("CAM %d: select %d", camSlot->SlotNumber(), Current() - offset);
2451 }
2452 else
2453 ciMenu->Cancel();
2454 }
2455 else if (ciEnquiry) {
2456 if (ciEnquiry->ExpectedLength() < 0xFF && int(strlen(input)) != ciEnquiry->ExpectedLength()) {
2457 char buffer[64];
2458 snprintf(buffer, sizeof(buffer), tr("Please enter %d digits!"), ciEnquiry->ExpectedLength());
2459 Skins.Message(mtError, buffer);
2460 return osContinue;
2461 }
2462 ciEnquiry->Reply(input);
2463 dsyslog("CAM %d: entered '%s'", camSlot->SlotNumber(), ciEnquiry->Blind() ? "****" : input);
2464 }
2465 QueryCam();
2466 return osContinue;
2467}
2468
2470{
2471 if (!camSlot->HasMMI())
2472 return osBack;
2473
2474 eOSState state = cOsdMenu::ProcessKey(Key);
2475
2476 if (ciMenu || ciEnquiry) {
2477 lastCamExchange = time(NULL);
2478 if (state == osUnknown) {
2479 switch (Key) {
2480 case kOk: return Select();
2481 default: break;
2482 }
2483 }
2484 else if (state == osBack) {
2485 if (ciMenu)
2486 ciMenu->Cancel();
2487 if (ciEnquiry)
2488 ciEnquiry->Cancel();
2489 QueryCam();
2490 return osContinue;
2491 }
2492 if (ciMenu && ciMenu->HasUpdate()) {
2493 QueryCam();
2494 return osContinue;
2495 }
2496 }
2497 else if (time(NULL) - lastCamExchange < CAMRESPONSETIMEOUT)
2498 QueryCam();
2499 else {
2500 Skins.Message(mtError, tr("CAM not responding!"));
2501 return osBack;
2502 }
2503 return state;
2504}
2505
2506// --- CamControl ------------------------------------------------------------
2507
2509{
2510 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
2511 if (CamSlot->HasUserIO())
2512 return new cMenuCam(CamSlot);
2513 }
2514 return NULL;
2515}
2516
2518{
2519 return CamMenuIsOpen;
2520}
2521
2522// --- cMenuPathEdit ---------------------------------------------------------
2523
2524#define osUserRecRenamed osUser1
2525#define osUserRecMoved osUser2
2526#define osUserRecRemoved osUser3
2527#define osUserRecEmpty osUser4
2528
2529class cMenuPathEdit : public cOsdMenu {
2530private:
2533 char folder[PATH_MAX];
2534 char name[NAME_MAX];
2537 eOSState SetFolder(void);
2538 eOSState Folder(void);
2539 eOSState ApplyChanges(void);
2540public:
2541 cMenuPathEdit(const char *Path);
2542 virtual eOSState ProcessKey(eKeys Key) override;
2543 };
2544
2546:cOsdMenu(tr("Edit path"), 12)
2547{
2549 path = Path;
2550 *folder = 0;
2551 *name = 0;
2552 const char *s = strrchr(path, FOLDERDELIMCHAR);
2553 if (s) {
2554 strn0cpy(folder, cString(path, s), sizeof(folder));
2555 s++;
2556 }
2557 else
2558 s = path;
2559 strn0cpy(name, s, sizeof(name));
2560 {
2562 pathIsInUse = Recordings->PathIsInUse(path);
2563 }
2564 oldFolder = folder;
2565 cOsdItem *p;
2566 Add(p = folderItem = new cMenuEditStrItem(tr("Folder"), folder, sizeof(folder)));
2568 Add(p = new cMenuEditStrItem(tr("Name"), name, sizeof(name)));
2570 if (*path) {
2571 int DirSize = 0;
2572 {
2574 for (const cRecording *Recording = Recordings->First(); Recording; Recording = Recordings->Next(Recording)) {
2575 if (Recording->IsInPath(path)) {
2576 int FileSizeMB = Recording->FileSizeMB();
2577 if (FileSizeMB > 0 )
2578 DirSize += FileSizeMB;
2579 }
2580 }
2581 }
2582 if (DirSize > 1023)
2583 Add(new cOsdItem(cString::sprintf("%s:\t%.2f GB", tr("Size"), DirSize / 1024.), osUnknown, false));
2584 else
2585 Add(new cOsdItem(cString::sprintf("%s:\t%d MB", tr("Size"), DirSize), osUnknown, false));
2586 }
2587 if (pathIsInUse) {
2588 Add(new cOsdItem("", osUnknown, false));
2589 Add(new cOsdItem(tr("This folder is currently in use - no changes are possible!"), osUnknown, false));
2590 }
2591 Display();
2592 if (!pathIsInUse)
2593 SetHelp(tr("Button$Folder"));
2594}
2595
2597{
2598 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu())) {
2599 strn0cpy(folder, mf->GetFolder(), sizeof(folder));
2601 Display();
2602 }
2603 return CloseSubMenu();
2604}
2605
2607{
2608 return AddSubMenu(new cMenuFolder(tr("Select folder"), &Folders, path));
2609}
2610
2612{
2613 if (!*name) {
2614 *name = ' '; // name must not be empty!
2615 name[1] = 0;
2616 }
2617 cString NewPath = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2619 if (strcmp(NewPath, path)) {
2620 int NumRecordings = 0;
2621 {
2623 NumRecordings = Recordings->GetNumRecordingsInPath(path);
2624 }
2625 if (NumRecordings > 1 && !Interface->Confirm(cString::sprintf(tr("Move entire folder containing %d recordings?"), NumRecordings)))
2626 return osContinue;
2627 bool Error = false;
2628 {
2630 Recordings->SetExplicitModify();
2631 Error = !Recordings->MoveRecordings(path, NewPath);
2632 if (!Error)
2633 Recordings->SetModified();
2634 }
2635 if (Error) {
2636 Skins.Message(mtError, tr("Error while moving folder!"));
2637 return osContinue;
2638 }
2639 if (strcmp(folder, oldFolder))
2640 return osUserRecMoved;
2641 return osUserRecRenamed;
2642 }
2643 return osBack;
2644}
2645
2647{
2648 eOSState state = cOsdMenu::ProcessKey(Key);
2649 if (state == osUnknown) {
2650 if (!pathIsInUse) {
2651 switch (Key) {
2652 case kRed: return Folder();
2653 case kOk: return ApplyChanges();
2654 default: break;
2655 }
2656 }
2657 else if (Key == kOk)
2658 return osBack;
2659 }
2660 else if (state == osEnd && HasSubMenu())
2661 state = SetFolder();
2662 return state;
2663}
2664
2665// --- cMenuRecordingEdit ----------------------------------------------------
2666
2668private:
2672 char folder[PATH_MAX];
2673 char name[NAME_MAX];
2678 const char *buttonFolder;
2679 const char *buttonAction;
2680 const char *buttonDelete;
2681 const char *actionCancel;
2682 const char *doCut;
2683 const char *doCopy;
2686 void Set(void);
2687 void SetHelpKeys(void);
2688 bool RefreshRecording(void);
2689 eOSState SetFolder(void);
2690 eOSState Folder(void);
2691 eOSState Action(void);
2692 eOSState RemoveName(void);
2693 eOSState Delete(void);
2694 eOSState ApplyChanges(void);
2695public:
2696 cMenuRecordingEdit(const cRecording *Recording);
2697 virtual eOSState ProcessKey(eKeys Key) override;
2698 };
2699
2701:cOsdMenu(tr("Edit recording"), 12)
2702{
2704 recording = Recording;
2705 originalFileName = recording->FileName();
2706 strn0cpy(folder, recording->Folder(), sizeof(folder));
2707 strn0cpy(name, recording->BaseName(), sizeof(name));
2708 priority = recording->Priority();
2709 lifetime = recording->Lifetime();
2710 folderItem = NULL;
2711 nameItem = NULL;
2712 buttonFolder = NULL;
2713 buttonAction = NULL;
2714 buttonDelete = NULL;
2715 actionCancel = NULL;
2716 doCut = NULL;
2717 doCopy = NULL;
2718 extraAction = false;
2720 Set();
2721}
2722
2724{
2725 int current = Current();
2726 Clear();
2727 recordingIsInUse = recording->IsInUse();
2728 cOsdItem *p;
2729 Add(p = folderItem = new cMenuEditStrItem(tr("Folder"), folder, sizeof(folder)));
2731 Add(p = nameItem = new cMenuEditStrItem(tr("Name"), name, sizeof(name)));
2733 Add(p = new cMenuEditIntItem(tr("Priority"), &priority, 0, MAXPRIORITY));
2735 Add(p = new cMenuEditIntItem(tr("Lifetime"), &lifetime, 0, MAXLIFETIME));
2737 if (recordingIsInUse) {
2738 Add(new cOsdItem("", osUnknown, false));
2739 Add(new cOsdItem(tr("This recording is currently in use - no changes are possible!"), osUnknown, false));
2740 }
2742 Display();
2743 SetHelpKeys();
2744}
2745
2747{
2748 buttonFolder = !recordingIsInUse ? tr("Button$Folder") : NULL;
2749 buttonAction = NULL;
2750 buttonDelete = NULL;
2751 actionCancel = NULL;
2752 doCut = NULL;
2753 doCopy = NULL;
2754 if ((recordingIsInUse & ruCut) != 0)
2755 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel cutting") : tr("Button$Stop cutting");
2756 else if ((recordingIsInUse & ruMove) != 0)
2757 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel moving") : tr("Button$Stop moving");
2758 else if ((recordingIsInUse & ruCopy) != 0)
2759 buttonAction = actionCancel = ((recordingIsInUse & ruPending) != 0) ? tr("Button$Cancel copying") : tr("Button$Stop copying");
2760 else if (extraAction) {
2761 cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording());
2762 buttonAction = doCopy = tr("Button$Copy");
2763 buttonDelete = (ResumeFile.Read() != -1) ? tr("Button$Delete resume") : NULL;
2764 }
2765 else if (recording->HasMarks()) {
2766 buttonAction = doCut = tr("Button$Cut");
2767 buttonDelete = tr("Button$Delete marks");
2768 }
2769 SetHelp(buttonFolder, buttonAction, buttonDelete, tr("Button$Toggle commands"));
2770}
2771
2773{
2775 if ((recording = Recordings->GetByName(originalFileName)) != NULL)
2776 Set();
2777 else {
2778 recordingsStateKey.Remove();
2779 Skins.Message(mtWarning, tr("Recording vanished!"));
2780 return false;
2781 }
2782 recordingsStateKey.Remove();
2783 }
2784 return true;
2785}
2786
2788{
2789 if (cMenuFolder *mf = dynamic_cast<cMenuFolder *>(SubMenu())) {
2790 strn0cpy(folder, mf->GetFolder(), sizeof(folder));
2792 Display();
2793 }
2794 return CloseSubMenu();
2795}
2796
2798{
2799 return AddSubMenu(new cMenuFolder(tr("Select folder"), &Folders, recording->Name()));
2800}
2801
2803{
2804 if (actionCancel)
2805 RecordingsHandler.Del(recording->FileName());
2806 else if (doCut) {
2807 if (access(cCutter::EditedFileName(recording->FileName()), F_OK) != 0 || Interface->Confirm(tr("Edited version already exists - overwrite?"))) {
2808 if (!EnoughFreeDiskSpaceForEdit(recording->FileName()))
2809 Skins.Message(mtError, tr("Not enough free disk space to start editing process!"));
2810 else if (!RecordingsHandler.Add(ruCut, recording->FileName()))
2811 Skins.Message(mtError, tr("Error while queueing recording for cutting!"));
2812 }
2813 }
2814 else if (doCopy) {
2815 if (!*name)
2816 *name = ' '; // name must not be empty!
2817 cString NewName = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2819 if (strcmp(NewName, recording->Name())) {
2820 cString FromName = cString(ExchangeChars(strdup(recording->Name()), true), true);
2821 cString ToName = cString(ExchangeChars(strdup(*NewName), true), true);
2822 cString FileName = cString(strreplace(strdup(recording->FileName()), *FromName, *ToName), true);
2823 if (access(*FileName, F_OK) != 0 || Interface->Confirm(tr("Edited version already exists - overwrite?"))) {
2824 if (MakeDirs(FileName, true) && !RecordingsHandler.Add(ruCopy, recording->FileName(), FileName))
2825 Skins.Message(mtError, tr("Error while queueing recording for copying!"));
2826 else {
2828 Recordings->AddByName(FileName);
2829 }
2830 }
2831 }
2832 }
2833 recordingIsInUse = recording->IsInUse();
2835 SetHelpKeys();
2836 return osContinue;
2837}
2838
2840{
2841 if (Get(Current()) == nameItem) {
2842 if (Interface->Confirm(tr("Rename recording to folder name?"))) {
2843 char *s = strrchr(folder, FOLDERDELIMCHAR);
2844 if (s)
2845 *s++ = 0;
2846 else
2847 s = folder;
2848 strn0cpy(name, s, sizeof(name));
2849 if (s == folder)
2850 *s = 0;
2851 Set();
2852 }
2853 }
2854 return osContinue;
2855}
2856
2858{
2859 if (extraAction) {
2860 if (buttonDelete && Interface->Confirm(tr("Delete resume for this recording?"))) {
2861 cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording());
2862 ResumeFile.Delete();
2863 SetHelpKeys();
2864 }
2865 }
2866 else {
2867 if (buttonDelete && Interface->Confirm(tr("Delete editing marks for this recording?"))) {
2869 SetHelpKeys();
2870 cMutexLock ControlMutexLock;
2871 if (cControl *Control = cControl::Control(ControlMutexLock, true)) {
2872 if (const cRecording *Recording = Control->GetRecording()) {
2873 if (strcmp(recording->FileName(), Recording->FileName()) == 0)
2874 Control->ClearEditingMarks();
2875 }
2876 }
2877 }
2878 else
2879 Skins.Message(mtError, tr("Error while deleting editing marks!"));
2880 }
2881 }
2882 return osContinue;
2883}
2884
2886{
2887 cStateKey StateKey;
2888 cRecordings *Recordings = cRecordings::GetRecordingsWrite(StateKey);
2889 cRecording *Recording = Recordings->GetByName(recording->FileName());
2890 if (!Recording) {
2891 StateKey.Remove(false);
2892 Skins.Message(mtWarning, tr("Recording vanished!"));
2893 return osBack;
2894 }
2895 bool Modified = false;
2896 if (priority != recording->Priority() || lifetime != recording->Lifetime()) {
2897 if (!Recording->ChangePriorityLifetime(priority, lifetime)) {
2898 StateKey.Remove(Modified);
2899 Skins.Message(mtError, tr("Error while changing priority/lifetime!"));
2900 return osContinue;
2901 }
2902 Modified = true;
2903 }
2904 if (!*name) {
2905 *name = ' '; // name must not be empty!
2906 name[1] = 0;
2907 }
2908 cString OldFolder = Recording->Folder();
2909 cString NewName = *folder ? cString::sprintf("%s%c%s", folder, FOLDERDELIMCHAR, name) : name;
2911 if (strcmp(NewName, Recording->Name())) {
2912 if (!Recording->ChangeName(NewName)) {
2913 StateKey.Remove(Modified);
2914 Skins.Message(mtError, tr("Error while changing folder/name!"));
2915 return osContinue;
2916 }
2917 Modified = true;
2918 }
2919 if (Modified) {
2920 eOSState state = osUserRecRenamed;
2921 if (strcmp(Recording->Folder(), OldFolder))
2922 state = osUserRecMoved;
2923 Recordings->TouchUpdate();
2924 StateKey.Remove(Modified);
2925 return state;
2926 }
2927 StateKey.Remove(Modified);
2928 return osBack;
2929}
2930
2932{
2933 if (!HasSubMenu()) {
2934 if (!RefreshRecording())
2935 return osBack; // the recording has vanished, so close this menu
2936 }
2937 eOSState state = cOsdMenu::ProcessKey(Key);
2938 if (state == osUnknown) {
2939 switch (Key) {
2940 case k0: return RemoveName();
2941 case kRed: return buttonFolder ? Folder() : osContinue;
2942 case kGreen: return buttonAction ? Action() : osContinue;
2943 case kYellow: return buttonDelete ? Delete() : osContinue;
2945 case kOk: return !recordingIsInUse ? ApplyChanges() : osBack;
2946 default: break;
2947 }
2948 }
2949 else if (state == osEnd && HasSubMenu())
2950 state = SetFolder();
2951 return state;
2952}
2953
2954// --- cMenuRecording --------------------------------------------------------
2955
2956class cMenuRecording : public cOsdMenu {
2957private:
2962 bool RefreshRecording(void);
2963public:
2964 cMenuRecording(const cRecording *Recording, bool WithButtons = false);
2965 virtual void Display(void) override;
2966 virtual eOSState ProcessKey(eKeys Key) override;
2967};
2968
2969cMenuRecording::cMenuRecording(const cRecording *Recording, bool WithButtons)
2970:cOsdMenu(tr("Recording info"))
2971{
2973 if (cRecordings::GetRecordingsRead(recordingsStateKey)) // initializes recordingsStateKey, so we don't call Display() unnecessarily
2974 recordingsStateKey.Remove();
2975 recording = Recording;
2976 originalFileName = recording->FileName();
2977 withButtons = WithButtons;
2978 if (withButtons)
2979 SetHelp(tr("Button$Play"), tr("Button$Rewind"), NULL, tr("Button$Edit"));
2980}
2981
2983{
2985 if ((recording = Recordings->GetByName(originalFileName)) != NULL)
2986 Display();
2987 else {
2988 recordingsStateKey.Remove();
2989 Skins.Message(mtWarning, tr("Recording vanished!"));
2990 return false;
2991 }
2992 recordingsStateKey.Remove();
2993 }
2994 return true;
2995}
2996
2998{
2999 if (HasSubMenu()) {
3000 SubMenu()->Display();
3001 return;
3002 }
3005 if (recording->Info()->Description())
3006 cStatus::MsgOsdTextItem(recording->Info()->Description());
3007}
3008
3010{
3011 if (HasSubMenu())
3012 return cOsdMenu::ProcessKey(Key);
3013 else if (!RefreshRecording())
3014 return osBack; // the recording has vanished, so close this menu
3015 switch (int(Key)) {
3016 case kUp|k_Repeat:
3017 case kUp:
3018 case kDown|k_Repeat:
3019 case kDown:
3020 case kLeft|k_Repeat:
3021 case kLeft:
3022 case kRight|k_Repeat:
3023 case kRight:
3024 DisplayMenu()->Scroll(NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft, NORMALKEY(Key) == kLeft || NORMALKEY(Key) == kRight);
3025 cStatus::MsgOsdTextItem(NULL, NORMALKEY(Key) == kUp || NORMALKEY(Key) == kLeft);
3026 return osContinue;
3027 case kInfo: return osBack;
3028 default: break;
3029 }
3030
3031 eOSState state = cOsdMenu::ProcessKey(Key);
3032
3033 if (state == osUnknown) {
3034 switch (Key) {
3035 case kRed: if (withButtons)
3036 Key = kOk; // will play the recording, even if recording commands are defined
3037 case kGreen: if (!withButtons)
3038 break;
3039 cRemote::Put(Key, true);
3040 // continue with osBack to close the info menu and process the key
3041 case kOk: return osBack;
3042 case kBlue: if (withButtons)
3044 break;
3045 default: break;
3046 }
3047 }
3048 return state;
3049}
3050
3051// --- cMenuRecordingItem ----------------------------------------------------
3052
3054private:
3057 char *name;
3059public:
3062 void IncrementCounter(bool New);
3063 const char *Name(void) const { return name; }
3064 int Level(void) const { return level; }
3065 const cRecording *Recording(void) const { return recording; }
3066 bool IsDirectory(void) const { return name != NULL; }
3068 virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override;
3069 };
3070
3072{
3074 level = Level;
3075 name = NULL;
3077 SetText(Recording->Title('\t', true, Level));
3078 if (*Text() == '\t') // this is a folder
3079 name = strdup(Text() + 2); // 'Text() + 2' to skip the two '\t'
3080 else { // this is an actual recording
3081 int Usage = Recording->IsInUse();
3082 if ((Usage & ruDst) != 0 && (Usage & (ruMove | ruCopy)) != 0)
3083 SetSelectable(false);
3084 }
3085}
3086
3091
3093{
3094 totalEntries++;
3095 if (New)
3096 newEntries++;
3098}
3099
3100void cMenuRecordingItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
3101{
3103 if (!DisplayMenu->SetItemRecording(recording, Index, Current, Selectable, level, totalEntries, newEntries))
3104 DisplayMenu->SetItem(Text(), Index, Current, Selectable);
3105}
3106
3107// --- cMenuRecordings -------------------------------------------------------
3108
3111
3112cMenuRecordings::cMenuRecordings(const char *Base, int Level, bool OpenSubMenus, const cRecordingFilter *Filter)
3113:cOsdMenu(Base ? Base : tr("Recordings"), 9, 6, 6)
3114{
3116 base = Base ? strdup(Base) : NULL;
3117 level = Setup.RecordingDirs ? Level : -1;
3118 filter = Filter;
3119 helpKeys = -1;
3120 Display(); // this keeps the higher level menus from showing up briefly when pressing 'Back' during replay
3121 Set();
3122 if (Current() < 0)
3123 SetCurrent(First());
3124 else if (OpenSubMenus && (cReplayControl::LastReplayed() || *path || *fileName)) {
3125 if (!*path || Level < strcountchr(path, FOLDERDELIMCHAR)) {
3126 if (Open(true))
3127 return;
3128 }
3129 }
3130 SetHelpKeys();
3131}
3132
3134{
3136 if (!ri->IsDirectory())
3137 SetRecording(ri->Recording()->FileName());
3138 }
3139 free(base);
3140}
3141
3143{
3145 int NewHelpKeys = 0;
3146 if (ri) {
3147 if (ri->IsDirectory())
3148 NewHelpKeys = 1;
3149 else
3150 NewHelpKeys = 2;
3151 }
3152 if (NewHelpKeys != helpKeys) {
3153 switch (NewHelpKeys) {
3154 case 0: SetHelp(NULL); break;
3155 case 1: SetHelp(tr("Button$Open"), NULL, NULL, tr("Button$Edit")); break;
3156 case 2: SetHelp(RecordingCommands.Count() ? tr("Commands") : tr("Button$Play"), tr("Button$Rewind"), tr("Button$Delete"), tr("Button$Info"));
3157 default: ;
3158 }
3159 helpKeys = NewHelpKeys;
3160 }
3161}
3162
3163void cMenuRecordings::Set(bool Refresh)
3164{
3166 recordingsStateKey.Remove();
3167 cRecordings *Recordings = cRecordings::GetRecordingsWrite(recordingsStateKey); // write access is necessary for sorting!
3168 const char *CurrentRecording = NULL;
3170 CurrentRecording = ri->Recording()->FileName();
3171 if (!CurrentRecording)
3172 CurrentRecording = *fileName ? *fileName : cReplayControl::LastReplayed();
3173 int current = Current();
3174 Clear();
3176 Recordings->Sort();
3177 cMenuRecordingItem *CurrentItem = NULL;
3178 cMenuRecordingItem *LastItem = NULL;
3179 for (const cRecording *Recording = Recordings->First(); Recording; Recording = Recordings->Next(Recording)) {
3180 if ((!filter || filter->Filter(Recording)) && (!base || (strstr(Recording->Name(), base) == Recording->Name() && Recording->Name()[strlen(base)] == FOLDERDELIMCHAR))) {
3181 cMenuRecordingItem *Item = new cMenuRecordingItem(Recording, level);
3182 cMenuRecordingItem *LastDir = NULL;
3183 if (Item->IsDirectory()) {
3184 // Sorting may ignore non-alphanumeric characters, so we need to explicitly handle directories in case they only differ in such characters:
3185 for (cMenuRecordingItem *p = LastItem; p; p = dynamic_cast<cMenuRecordingItem *>(p->Prev())) {
3186 if (p->Name() && strcmp(p->Name(), Item->Name()) == 0) {
3187 LastDir = p;
3188 break;
3189 }
3190 }
3191 }
3192 if (*Item->Text() && !LastDir) {
3193 Add(Item);
3194 LastItem = Item;
3195 if (Item->IsDirectory())
3196 LastDir = Item;
3197 }
3198 else
3199 delete Item;
3200 if (LastItem || LastDir) {
3201 if (*path) {
3202 if (strcmp(path, Recording->Folder()) == 0)
3203 CurrentItem = LastDir ? LastDir : LastItem;
3204 }
3205 else if (CurrentRecording && strcmp(CurrentRecording, Recording->FileName()) == 0)
3206 CurrentItem = LastDir ? LastDir : LastItem;
3207 }
3208 if (LastDir)
3209 LastDir->IncrementCounter(Recording->IsNew());
3210 }
3211 }
3212 SetCurrent(CurrentItem);
3213 if (Current() < 0)
3214 SetCurrent(Get(current)); // last resort, in case the recording was deleted
3216 recordingsStateKey.Remove(false); // sorting doesn't count as a real modification
3217 if (Refresh)
3218 Display();
3219 }
3220}
3221
3222void cMenuRecordings::SetRecording(const char *FileName)
3223{
3224 fileName = FileName;
3225}
3226
3228{
3230 if (base) {
3231 char *s = ExchangeChars(strdup(base), true);
3232 d = AddDirectory(d, s);
3233 free(s);
3234 }
3235 return d;
3236}
3237
3238bool cMenuRecordings::Open(bool OpenSubMenus)
3239{
3241 if (ri && ri->IsDirectory() && (!*path || strcountchr(path, FOLDERDELIMCHAR) > 0)) {
3242 const char *t = ri->Name();
3243 cString buffer;
3244 if (base) {
3245 buffer = cString::sprintf("%s%c%s", base, FOLDERDELIMCHAR, t);
3246 t = buffer;
3247 }
3248 AddSubMenu(new cMenuRecordings(t, level + 1, OpenSubMenus, filter));
3249 return true;
3250 }
3251 return false;
3252}
3253
3255{
3257 if (ri) {
3258 if (ri->IsDirectory())
3259 Open();
3260 else {
3262 return osReplay;
3263 }
3264 }
3265 return osContinue;
3266}
3267
3269{
3270 if (HasSubMenu() || Count() == 0)
3271 return osContinue;
3273 if (ri && !ri->IsDirectory()) {
3274 cDevice::PrimaryDevice()->StopReplay(); // must do this first to be able to rewind the currently replayed recording
3275 cResumeFile ResumeFile(ri->Recording()->FileName(), ri->Recording()->IsPesRecording());
3276 ResumeFile.Delete();
3277 return Play();
3278 }
3279 return osContinue;
3280}
3281
3282static bool TimerStillRecording(const char *FileName)
3283{
3285 // local timer
3286 if (Interface->Confirm(tr("Timer still recording - really delete?"))) {
3288 if (cTimer *Timer = rc->Timer()) {
3289 Timer->Skip();
3290 cRecordControls::Process(Timers, time(NULL));
3291 if (Timer->IsSingleEvent()) {
3292 Timers->Del(Timer);
3293 isyslog("deleted timer %s", *Timer->ToDescr());
3294 }
3295 }
3296 }
3297 else
3298 return true; // user didn't confirm deletion
3299 }
3300 else {
3301 // remote timer
3302 cString TimerId = GetRecordingTimerId(FileName);
3303 if (*TimerId) {
3304 int Id;
3305 char *RemoteBuf = NULL;
3306 cString Remote;
3307 if (2 == sscanf(TimerId, "%d@%m[^ \n]", &Id, &RemoteBuf) && Id != 0) {
3308 Remote = RemoteBuf;
3309 free(RemoteBuf);
3310 if (Interface->Confirm(tr("Timer still recording - really delete?"))) {
3312 if (cTimer *Timer = Timers->GetById(Id, Remote)) {
3313 cTimer OldTimer = *Timer;
3314 Timer->Skip();
3315 Timers->SetSyncStateKey(StateKeySVDRPRemoteTimersPoll);
3316 if (Timer->IsSingleEvent()) {
3317 if (HandleRemoteModifications(NULL, Timer))
3318 Timers->Del(Timer);
3319 else
3320 return true; // error while deleting remote timer
3321 }
3322 else if (!HandleRemoteModifications(Timer, &OldTimer))
3323 return true; // error while modifying remote timer
3324 }
3325 }
3326 else
3327 return true; // user didn't confirm deletion
3328 }
3329 }
3330 }
3331 return false;
3332}
3333
3335{
3336 if (HasSubMenu() || Count() == 0)
3337 return osContinue;
3339 if (ri && !ri->IsDirectory()) {
3340 if (Interface->Confirm(tr("Delete recording?"))) {
3342 return osContinue;
3343 cString FileName;
3344 {
3346 if (const cRecording *Recording = Recordings->GetByName(ri->Recording()->FileName())) {
3347 FileName = Recording->FileName();
3348 if (RecordingsHandler.GetUsage(FileName)) {
3349 if (!Interface->Confirm(tr("Recording is being edited - really delete?")))
3350 return osContinue;
3351 SetNeedsFastResponse(true); // makes sure the edited version is removed from the menu ASAP
3352 }
3353 }
3354 else
3355 return osContinue; // recording has already been deleted
3356 }
3357 RecordingsHandler.Del(FileName); // must do this w/o holding a lock, because the cleanup section in cDirCopier::Action() might request one!
3358 if (cReplayControl::NowReplaying() && strcmp(cReplayControl::NowReplaying(), FileName) == 0)
3361 Recordings->SetExplicitModify();
3362 cRecording *Recording = Recordings->GetByName(FileName);
3363 if (!Recording || Recording->Delete()) {
3365 Recordings->DelByName(FileName);
3367 SetHelpKeys();
3369 Recordings->SetModified();
3370 recordingsStateKey.Remove();
3371 Display();
3372 if (!Count())
3373 return osUserRecEmpty;
3374 return osUserRecRemoved;
3375 }
3376 else
3377 Skins.Message(mtError, tr("Error while deleting recording!"));
3378 recordingsStateKey.Remove();
3379 }
3380 }
3381 return osContinue;
3382}
3383
3385{
3386 if (HasSubMenu() || Count() == 0)
3387 return osContinue;
3389 if (ri->IsDirectory())
3390 return AddSubMenu(new cMenuPathEdit(cString(ri->Recording()->Name(), strchrn(ri->Recording()->Name(), FOLDERDELIMCHAR, ri->Level() + 1))));
3391 else
3392 return AddSubMenu(new cMenuRecording(ri->Recording(), true));
3393 }
3394 return osContinue;
3395}
3396
3398{
3399 if (HasSubMenu() || Count() == 0)
3400 return osContinue;
3402 if (ri && !ri->IsDirectory()) {
3403 cMenuCommands *menu;
3404 eOSState state = AddSubMenu(menu = new cMenuCommands(tr("Recording commands"), &RecordingCommands, cString::sprintf("\"%s\"", *strescape(ri->Recording()->FileName(), "\\\"$"))));
3405 if (Key != kNone)
3406 state = menu->ProcessKey(Key);
3407 return state;
3408 }
3409 return osContinue;
3410}
3411
3413{
3414 if (HasSubMenu())
3415 return osContinue;
3416 if (const cMenuRecordingItem *ri = (cMenuRecordingItem *)Get(Current()))
3417 SetRecording(ri->Recording()->FileName()); // makes sure the Recordings menu will reposition to the current recording
3419 recordingsStateKey.Reset();
3420 Set(true);
3421 return osContinue;
3422}
3423
3425{
3426 eOSState state = cOsdMenu::ProcessKey(Key);
3427
3428 if (state == osUnknown) {
3429 switch (Key) {
3430 case kPlayPause:
3431 case kPlay:
3432 case kOk: return Play();
3433 case kRed: return (helpKeys > 1 && RecordingCommands.Count()) ? Commands() : Play();
3434 case kGreen: return Rewind();
3435 case kYellow: return Delete();
3436 case kInfo:
3437 case kBlue: return Info();
3438 case k0: return Sort();
3439 case k1...k9: return Commands(Key);
3440 default: break;
3441 }
3442 }
3443 else if (state == osUserRecRenamed) {
3444 // a recording was renamed (within the same folder), so let's refresh the menu
3445 CloseSubMenu(false); // this is the cMenuRecordingEdit/cMenuPathEdit
3446 path = NULL;
3447 fileName = NULL;
3448 state = osContinue;
3449 }
3450 else if (state == osUserRecMoved) {
3451 // a recording was moved to a different folder, so let's delete the old item
3452 CloseSubMenu(false); // this is the cMenuRecordingEdit/cMenuPathEdit
3453 path = NULL;
3454 fileName = NULL;
3456 Set(); // the recording might have been moved into a new subfolder of this folder
3457 if (!Count())
3458 return osUserRecEmpty;
3459 Display();
3460 state = osUserRecRemoved;
3461 }
3462 else if (state == osUserRecRemoved) {
3463 // a recording was removed from a sub folder, so update the current item
3464 if (cOsdMenu *m = SubMenu()) {
3466 if (cMenuRecordingItem *riSub = (cMenuRecordingItem *)m->Get(m->Current()))
3467 ri->SetRecording(riSub->Recording());
3468 }
3469 }
3470 // no state change here, this report goes upstream!
3471 }
3472 else if (state == osUserRecEmpty) {
3473 // a subfolder became empty, so let's go back up
3474 CloseSubMenu(false); // this is the now empty submenu
3475 cOsdMenu::Del(Current()); // the menu entry of the now empty subfolder
3476 Set(); // in case a recording was moved into a new subfolder of this folder
3477 if (base && !Count()) // base: don't go up beyond the top level Recordings menu
3478 return state;
3479 Display();
3480 state = osContinue;
3481 }
3482 if (!HasSubMenu()) {
3483 Set(true);
3484 if (Key != kNone)
3485 SetHelpKeys();
3486 }
3487 return state;
3488}
3489
3490// --- cMenuSetupBase --------------------------------------------------------
3491
3493protected:
3495 virtual void Store(void) override;
3496public:
3497 cMenuSetupBase(void);
3498 };
3499
3504
3506{
3507 Setup = data;
3509 Setup.Save();
3510}
3511
3512// --- cMenuSetupOSD ---------------------------------------------------------
3513
3515private:
3516 const char *useSmallFontTexts[3];
3517 const char *recSortModeTexts[2];
3518 const char *recSortDirTexts[2];
3519 const char *keyColorTexts[4];
3524 const char **skinDescriptions;
3530 virtual void Set(void);
3531public:
3532 cMenuSetupOSD(void);
3533 virtual ~cMenuSetupOSD() override;
3534 virtual eOSState ProcessKey(eKeys Key) override;
3535 };
3536
3538{
3541 numSkins = Skins.Count();
3542 skinIndex = originalSkinIndex = Skins.Current()->Index();
3543 skinDescriptions = new const char*[numSkins];
3544 themes.Load(Skins.Current()->Name());
3545 themeIndex = originalThemeIndex = Skins.Current()->Theme() ? themes.GetThemeIndex(Skins.Current()->Theme()->Description()) : 0;
3549 fontOsdNames.Insert(strdup(DefaultFontOsd));
3550 fontSmlNames.Insert(strdup(DefaultFontSml));
3551 fontFixNames.Insert(strdup(DefaultFontFix));
3552 fontOsdIndex = max(0, fontOsdNames.Find(Setup.FontOsd));
3553 fontSmlIndex = max(0, fontSmlNames.Find(Setup.FontSml));
3554 fontFixIndex = max(0, fontFixNames.Find(Setup.FontFix));
3555 Set();
3556}
3557
3562
3564{
3565 int current = Current();
3566 for (cSkin *Skin = Skins.First(); Skin; Skin = Skins.Next(Skin))
3567 skinDescriptions[Skin->Index()] = Skin->Description();
3568 useSmallFontTexts[0] = tr("never");
3569 useSmallFontTexts[1] = tr("skin dependent");
3570 useSmallFontTexts[2] = tr("always");
3571 recSortModeTexts[0] = tr("by name");
3572 recSortModeTexts[1] = tr("by time");
3573 recSortDirTexts[0] = tr("ascending");
3574 recSortDirTexts[1] = tr("descending");
3575 keyColorTexts[0] = tr("Key$Red");
3576 keyColorTexts[1] = tr("Key$Green");
3577 keyColorTexts[2] = tr("Key$Yellow");
3578 keyColorTexts[3] = tr("Key$Blue");
3579 Clear();
3580 SetSection(tr("OSD"));
3581 Add(new cMenuEditStraItem(tr("Setup.OSD$Language"), &osdLanguageIndex, I18nNumLanguagesWithLocale(), &I18nLanguages()->At(0)));
3582 Add(new cMenuEditStraItem(tr("Setup.OSD$Skin"), &skinIndex, numSkins, skinDescriptions));
3583 if (themes.NumThemes())
3584 Add(new cMenuEditStraItem(tr("Setup.OSD$Theme"), &themeIndex, themes.NumThemes(), themes.Descriptions()));
3585 Add(new cMenuEditPrcItem( tr("Setup.OSD$Left (%)"), &data.OSDLeftP, 0.0, 0.5));
3586 Add(new cMenuEditPrcItem( tr("Setup.OSD$Top (%)"), &data.OSDTopP, 0.0, 0.5));
3587 Add(new cMenuEditPrcItem( tr("Setup.OSD$Width (%)"), &data.OSDWidthP, 0.5, 1.0));
3588 Add(new cMenuEditPrcItem( tr("Setup.OSD$Height (%)"), &data.OSDHeightP, 0.5, 1.0));
3589 Add(new cMenuEditIntItem( tr("Setup.OSD$Message time (s)"), &data.OSDMessageTime, 1, 60));
3590 Add(new cMenuEditStraItem(tr("Setup.OSD$Use small font"), &data.UseSmallFont, 3, useSmallFontTexts));
3591 Add(new cMenuEditBoolItem(tr("Setup.OSD$Anti-alias"), &data.AntiAlias));
3592 Add(new cMenuEditStraItem(tr("Setup.OSD$Default font"), &fontOsdIndex, fontOsdNames.Size(), &fontOsdNames[0]));
3593 Add(new cMenuEditStraItem(tr("Setup.OSD$Small font"), &fontSmlIndex, fontSmlNames.Size(), &fontSmlNames[0]));
3594 Add(new cMenuEditStraItem(tr("Setup.OSD$Fixed font"), &fontFixIndex, fontFixNames.Size(), &fontFixNames[0]));
3595 Add(new cMenuEditPrcItem( tr("Setup.OSD$Default font size (%)"), &data.FontOsdSizeP, 0.01, 0.1, 1));
3596 Add(new cMenuEditPrcItem( tr("Setup.OSD$Small font size (%)"), &data.FontSmlSizeP, 0.01, 0.1, 1));
3597 Add(new cMenuEditPrcItem( tr("Setup.OSD$Fixed font size (%)"), &data.FontFixSizeP, 0.01, 0.1, 1));
3598 Add(new cMenuEditBoolItem(tr("Setup.OSD$Channel info position"), &data.ChannelInfoPos, tr("bottom"), tr("top")));
3599 Add(new cMenuEditIntItem( tr("Setup.OSD$Channel info time (s)"), &data.ChannelInfoTime, 1, 60));
3600 Add(new cMenuEditBoolItem(tr("Setup.OSD$Info on channel switch"), &data.ShowInfoOnChSwitch));
3601 Add(new cMenuEditBoolItem(tr("Setup.OSD$Timeout requested channel info"), &data.TimeoutRequChInfo));
3602 Add(new cMenuEditBoolItem(tr("Setup.OSD$Scroll pages"), &data.MenuScrollPage));
3603 Add(new cMenuEditBoolItem(tr("Setup.OSD$Scroll wraps"), &data.MenuScrollWrap));
3604 Add(new cMenuEditBoolItem(tr("Setup.OSD$Menu key closes"), &data.MenuKeyCloses));
3605 Add(new cMenuEditBoolItem(tr("Setup.OSD$Recording directories"), &data.RecordingDirs));
3606 Add(new cMenuEditBoolItem(tr("Setup.OSD$Folders in timer menu"), &data.FoldersInTimerMenu));
3607 Add(new cMenuEditBoolItem(tr("Setup.OSD$Always sort folders first"), &data.AlwaysSortFoldersFirst));
3608 Add(new cMenuEditStraItem(tr("Setup.OSD$Default sort mode for recordings"), &data.DefaultSortModeRec, 2, recSortModeTexts));
3609 Add(new cMenuEditStraItem(tr("Setup.OSD$Sorting direction for recordings"), &data.RecSortingDirection, 2, recSortDirTexts));
3610 Add(new cMenuEditBoolItem(tr("Setup.OSD$Number keys for characters"), &data.NumberKeysForChars));
3611 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 0"), &data.ColorKey0, 4, keyColorTexts));
3612 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 1"), &data.ColorKey1, 4, keyColorTexts));
3613 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 2"), &data.ColorKey2, 4, keyColorTexts));
3614 Add(new cMenuEditStraItem(tr("Setup.OSD$Color key 3"), &data.ColorKey3, 4, keyColorTexts));
3616 Display();
3617}
3618
3620{
3621 bool ModifiedAppearance = false;
3622
3623 if (Key == kOk) {
3624 I18nSetLocale(data.OSDLanguage);
3626 cSkin *Skin = Skins.Get(skinIndex);
3627 if (Skin) {
3628 Utf8Strn0Cpy(data.OSDSkin, Skin->Name(), sizeof(data.OSDSkin));
3629 Skins.SetCurrent(Skin->Name());
3630 ModifiedAppearance = true;
3631 }
3632 }
3633 if (themes.NumThemes() && Skins.Current()->Theme()) {
3634 Skins.Current()->Theme()->Load(themes.FileName(themeIndex));
3635 Utf8Strn0Cpy(data.OSDTheme, themes.Name(themeIndex), sizeof(data.OSDTheme));
3636 ModifiedAppearance |= themeIndex != originalThemeIndex;
3637 }
3638 if (!(DoubleEqual(data.OSDLeftP, Setup.OSDLeftP) && DoubleEqual(data.OSDTopP, Setup.OSDTopP) && DoubleEqual(data.OSDWidthP, Setup.OSDWidthP) && DoubleEqual(data.OSDHeightP, Setup.OSDHeightP)))
3639 ModifiedAppearance = true;
3640 if (data.UseSmallFont != Setup.UseSmallFont || data.AntiAlias != Setup.AntiAlias)
3641 ModifiedAppearance = true;
3642 Utf8Strn0Cpy(data.FontOsd, fontOsdNames[fontOsdIndex], sizeof(data.FontOsd));
3643 Utf8Strn0Cpy(data.FontSml, fontSmlNames[fontSmlIndex], sizeof(data.FontSml));
3644 Utf8Strn0Cpy(data.FontFix, fontFixNames[fontFixIndex], sizeof(data.FontFix));
3645 if (strcmp(data.FontOsd, Setup.FontOsd) || !DoubleEqual(data.FontOsdSizeP, Setup.FontOsdSizeP))
3646 ModifiedAppearance = true;
3647 if (strcmp(data.FontSml, Setup.FontSml) || !DoubleEqual(data.FontSmlSizeP, Setup.FontSmlSizeP))
3648 ModifiedAppearance = true;
3649 if (strcmp(data.FontFix, Setup.FontFix) || !DoubleEqual(data.FontFixSizeP, Setup.FontFixSizeP))
3650 ModifiedAppearance = true;
3651 if (data.AlwaysSortFoldersFirst != Setup.AlwaysSortFoldersFirst || data.RecordingDirs != Setup.RecordingDirs || data.RecSortingDirection != Setup.RecSortingDirection) {
3653 Recordings->ClearSortNames();
3654 }
3655 }
3656
3657 int oldSkinIndex = skinIndex;
3658 int oldOsdLanguageIndex = osdLanguageIndex;
3660
3661 if (ModifiedAppearance)
3663
3664 if (osdLanguageIndex != oldOsdLanguageIndex || skinIndex != oldSkinIndex) {
3665 strn0cpy(data.OSDLanguage, I18nLocale(osdLanguageIndex), sizeof(data.OSDLanguage));
3666 int OriginalOSDLanguage = I18nCurrentLanguage();
3668
3669 cSkin *Skin = Skins.Get(skinIndex);
3670 if (Skin) {
3671 char *d = themes.NumThemes() ? strdup(themes.Descriptions()[themeIndex]) : NULL;
3672 themes.Load(Skin->Name());
3673 if (skinIndex != oldSkinIndex)
3674 themeIndex = d ? themes.GetThemeIndex(d) : 0;
3675 free(d);
3676 }
3677
3678 Set();
3679 I18nSetLanguage(OriginalOSDLanguage);
3680 }
3681 return state;
3682}
3683
3684// --- cMenuSetupEPG ---------------------------------------------------------
3685
3687private:
3690 void Setup(void);
3691public:
3692 cMenuSetupEPG(void);
3693 virtual eOSState ProcessKey(eKeys Key) override;
3694 };
3695
3697{
3699 for (numLanguages = 0; numLanguages < I18nLanguages()->Size() && data.EPGLanguages[numLanguages] >= 0; numLanguages++)
3700 ;
3702 SetSection(tr("EPG"));
3703 SetHelp(tr("Button$Scan"));
3704 Setup();
3705}
3706
3708{
3709 int current = Current();
3710
3711 Clear();
3712
3713 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG scan timeout (h)"), &data.EPGScanTimeout));
3714 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG scan max. channel number (0=all)"), &data.EPGScanMaxChannel));
3715 Add(new cMenuEditBoolItem(tr("Setup.EPG$EPG pause after scan"), &data.EPGPauseAfterScan));
3716 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG bugfix level"), &data.EPGBugfixLevel, 0, MAXEPGBUGFIXLEVEL));
3717 Add(new cMenuEditIntItem( tr("Setup.EPG$EPG linger time (min)"), &data.EPGLinger, 0));
3718 Add(new cMenuEditBoolItem(tr("Setup.EPG$Set system time"), &data.SetSystemTime));
3719 if (data.SetSystemTime)
3720 Add(new cMenuEditTranItem(tr("Setup.EPG$Use time from transponder"), &data.TimeTransponder, &data.TimeSource));
3721 // TRANSLATORS: note the plural!
3722 Add(new cMenuEditIntItem( tr("Setup.EPG$Preferred languages"), &numLanguages, 0, I18nLanguages()->Size()));
3723 for (int i = 0; i < numLanguages; i++)
3724 // TRANSLATORS: note the singular!
3725 Add(new cMenuEditStraItem(tr("Setup.EPG$Preferred language"), &data.EPGLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3726
3728 Display();
3729}
3730
3732{
3733 if (Key == kOk) {
3734 bool Modified = numLanguages != originalNumLanguages;
3735 if (!Modified) {
3736 for (int i = 0; i < numLanguages; i++) {
3737 if (data.EPGLanguages[i] != ::Setup.EPGLanguages[i]) {
3738 Modified = true;
3739 break;
3740 }
3741 }
3742 }
3743 if (Modified)
3745 }
3746
3747 int oldnumLanguages = numLanguages;
3748 int oldSetSystemTime = data.SetSystemTime;
3749
3751 if (Key != kNone) {
3752 if (numLanguages != oldnumLanguages || data.SetSystemTime != oldSetSystemTime) {
3753 for (int i = oldnumLanguages; i < numLanguages; i++) {
3754 data.EPGLanguages[i] = 0;
3755 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3756 int k;
3757 for (k = 0; k < oldnumLanguages; k++) {
3758 if (data.EPGLanguages[k] == l)
3759 break;
3760 }
3761 if (k >= oldnumLanguages) {
3762 data.EPGLanguages[i] = l;
3763 break;
3764 }
3765 }
3766 }
3767 data.EPGLanguages[numLanguages] = -1;
3768 Setup();
3769 }
3770 if (Key == kRed) {
3771 EITScanner.ForceScan();
3772 return osEnd;
3773 }
3774 }
3775 return state;
3776}
3777
3778// --- cMenuSetupDVB ---------------------------------------------------------
3779
3781private:
3786 void Setup(void);
3788 const char *updateChannelsTexts[6];
3791public:
3792 cMenuSetupDVB(void);
3793 virtual eOSState ProcessKey(eKeys Key) override;
3794 };
3795
3797{
3800 ;
3802 ;
3805 videoDisplayFormatTexts[0] = tr("pan&scan");
3806 videoDisplayFormatTexts[1] = tr("letterbox");
3807 videoDisplayFormatTexts[2] = tr("center cut out");
3808 updateChannelsTexts[0] = tr("no");
3809 updateChannelsTexts[1] = tr("names only");
3810 updateChannelsTexts[2] = tr("PIDs only");
3811 updateChannelsTexts[3] = tr("names and PIDs");
3812 updateChannelsTexts[4] = tr("add new channels");
3813 updateChannelsTexts[5] = tr("add new transponders");
3814 displaySubtitlesTexts[0] = tr("no");
3815 displaySubtitlesTexts[1] = tr("always");
3816 displaySubtitlesTexts[2] = tr("after rewind");
3817 standardComplianceTexts[0] = "DVB";
3818 standardComplianceTexts[1] = "ANSI/SCTE";
3819 standardComplianceTexts[2] = "NORDIG";
3820
3821 SetSection(tr("DVB"));
3822 SetHelp(NULL, tr("Button$Audio"), tr("Button$Subtitles"), NULL);
3823 Setup();
3824}
3825
3827{
3828 int current = Current();
3829
3830 Clear();
3831
3832 Add(new cMenuEditIntItem( tr("Setup.DVB$Primary DVB interface"), &data.PrimaryDVB, 1, cDevice::NumDevices()));
3833 Add(new cMenuEditStraItem(tr("Setup.DVB$Standard compliance"), &data.StandardCompliance, 3, standardComplianceTexts));
3834 Add(new cMenuEditBoolItem(tr("Setup.DVB$Video format"), &data.VideoFormat, "4:3", "16:9"));
3835 if (data.VideoFormat == 0)
3836 Add(new cMenuEditStraItem(tr("Setup.DVB$Video display format"), &data.VideoDisplayFormat, 3, videoDisplayFormatTexts));
3837 Add(new cMenuEditBoolItem(tr("Setup.DVB$Use Dolby Digital"), &data.UseDolbyDigital));
3838 Add(new cMenuEditStraItem(tr("Setup.DVB$Update channels"), &data.UpdateChannels, 6, updateChannelsTexts));
3839 Add(new cMenuEditIntItem( tr("Setup.DVB$Audio languages"), &numAudioLanguages, 0, I18nLanguages()->Size()));
3840 for (int i = 0; i < numAudioLanguages; i++)
3841 Add(new cMenuEditStraItem(tr("Setup.DVB$Audio language"), &data.AudioLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3842 Add(new cMenuEditStraItem(tr("Setup.DVB$Display subtitles"), &data.DisplaySubtitles, 3, displaySubtitlesTexts));
3843 if (data.DisplaySubtitles != SUBTITLES_NO) {
3844 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle languages"), &numSubtitleLanguages, 0, I18nLanguages()->Size()));
3845 for (int i = 0; i < numSubtitleLanguages; i++)
3846 Add(new cMenuEditStraItem(tr("Setup.DVB$Subtitle language"), &data.SubtitleLanguages[i], I18nLanguages()->Size(), &I18nLanguages()->At(0)));
3847 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle offset"), &data.SubtitleOffset, -100, 100));
3848 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle foreground transparency"), &data.SubtitleFgTransparency, 0, 9));
3849 Add(new cMenuEditIntItem( tr("Setup.DVB$Subtitle background transparency"), &data.SubtitleBgTransparency, 0, 10));
3850 }
3851
3853 Display();
3854}
3855
3857{
3858 int oldVideoDisplayFormat = ::Setup.VideoDisplayFormat;
3859 bool oldVideoFormat = ::Setup.VideoFormat;
3860 bool newVideoFormat = data.VideoFormat;
3861 int oldDisplaySubtitles = ::Setup.DisplaySubtitles;
3862 int newDisplaySubtitles = data.DisplaySubtitles;
3863 int oldnumAudioLanguages = numAudioLanguages;
3864 int oldnumSubtitleLanguages = numSubtitleLanguages;
3866
3867 if (Key != kNone) {
3868 switch (Key) {
3869 case kGreen: cRemote::Put(kAudio, true);
3870 state = osEnd;
3871 break;
3872 case kYellow: cRemote::Put(kSubtitles, true);
3873 state = osEnd;
3874 break;
3875 default: {
3876 bool DoSetup = data.VideoFormat != newVideoFormat;
3877 DoSetup |= data.DisplaySubtitles != newDisplaySubtitles;
3878 if (numAudioLanguages != oldnumAudioLanguages) {
3879 for (int i = oldnumAudioLanguages; i < numAudioLanguages; i++) {
3880 data.AudioLanguages[i] = 0;
3881 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3882 int k;
3883 for (k = 0; k < oldnumAudioLanguages; k++) {
3884 if (data.AudioLanguages[k] == l)
3885 break;
3886 }
3887 if (k >= oldnumAudioLanguages) {
3888 data.AudioLanguages[i] = l;
3889 break;
3890 }
3891 }
3892 }
3893 data.AudioLanguages[numAudioLanguages] = -1;
3894 DoSetup = true;
3895 }
3896 if (numSubtitleLanguages != oldnumSubtitleLanguages) {
3897 for (int i = oldnumSubtitleLanguages; i < numSubtitleLanguages; i++) {
3898 data.SubtitleLanguages[i] = 0;
3899 for (int l = 0; l < I18nLanguages()->Size(); l++) {
3900 int k;
3901 for (k = 0; k < oldnumSubtitleLanguages; k++) {
3902 if (data.SubtitleLanguages[k] == l)
3903 break;
3904 }
3905 if (k >= oldnumSubtitleLanguages) {
3906 data.SubtitleLanguages[i] = l;
3907 break;
3908 }
3909 }
3910 }
3911 data.SubtitleLanguages[numSubtitleLanguages] = -1;
3912 DoSetup = true;
3913 }
3914 if (DoSetup)
3915 Setup();
3916 }
3917 }
3918 }
3919 if (state == osBack && Key == kOk) {
3920 if (::Setup.VideoDisplayFormat != oldVideoDisplayFormat)
3922 if (::Setup.VideoFormat != oldVideoFormat)
3924 if (::Setup.DisplaySubtitles != oldDisplaySubtitles)
3927 }
3928 return state;
3929}
3930
3931// --- cMenuSetupLNB ---------------------------------------------------------
3932
3934private:
3936 void Setup(void);
3937public:
3938 cMenuSetupLNB(void);
3939 virtual eOSState ProcessKey(eKeys Key) override;
3940 };
3941
3944{
3946 satCableNumbers.FromString(data.DeviceBondings);
3947 SetSection(tr("LNB"));
3948 Setup();
3949}
3950
3952{
3953 int current = Current();
3954
3955 Clear();
3956
3957 Add(new cMenuEditBoolItem(tr("Setup.LNB$Use DiSEqC"), &data.DiSEqC));
3958 if (!data.DiSEqC) {
3959 Add(new cMenuEditIntItem( tr("Setup.LNB$SLOF (MHz)"), &data.LnbSLOF));
3960 Add(new cMenuEditIntItem( tr("Setup.LNB$Low LNB frequency (MHz)"), &data.LnbFrequLo));
3961 Add(new cMenuEditIntItem( tr("Setup.LNB$High LNB frequency (MHz)"), &data.LnbFrequHi));
3962 }
3963
3964 int NumSatDevices = 0;
3965 for (int i = 0; i < cDevice::NumDevices(); i++) {
3966 if (cDevice::GetDevice(i)->ProvidesSource(cSource::stSat))
3967 NumSatDevices++;
3968 }
3969 if (NumSatDevices > 1) {
3970 for (int i = 0; i < cDevice::NumDevices(); i++) {
3971 if (cDevice::GetDevice(i)->ProvidesSource(cSource::stSat))
3972 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")));
3973 else
3974 satCableNumbers.Array()[i] = 0;
3975 }
3976 }
3977
3978 Add(new cMenuEditBoolItem(tr("Setup.LNB$Use dish positioner"), &data.UsePositioner));
3979 if (data.UsePositioner) {
3980 Add(new cMenuEditIntxItem(tr("Setup.LNB$Site latitude (degrees)"), &data.SiteLat, -900, 900, 10, tr("South"), tr("North")));
3981 Add(new cMenuEditIntxItem(tr("Setup.LNB$Site longitude (degrees)"), &data.SiteLon, -1800, 1800, 10, tr("West"), tr("East")));
3982 Add(new cMenuEditIntxItem(tr("Setup.LNB$Max. positioner swing (degrees)"), &data.PositionerSwing, 0, 900, 10));
3983 Add(new cMenuEditIntxItem(tr("Setup.LNB$Positioner speed (degrees/s)"), &data.PositionerSpeed, 1, 1800, 10));
3984 }
3985
3987 Display();
3988}
3989
3991{
3992 int oldDiSEqC = data.DiSEqC;
3993 int oldUsePositioner = data.UsePositioner;
3994 bool DeviceBondingsChanged = false;
3995 if (Key == kOk) {
3996 cString NewDeviceBondings = satCableNumbers.ToString();
3997 DeviceBondingsChanged = strcmp(data.DeviceBondings, NewDeviceBondings) != 0;
3998 data.DeviceBondings = NewDeviceBondings;
3999 }
4001
4002 if (Key != kNone && (data.DiSEqC != oldDiSEqC || data.UsePositioner != oldUsePositioner))
4003 Setup();
4004 else if (DeviceBondingsChanged)
4005 cDvbDevice::BondDevices(data.DeviceBondings);
4006 return state;
4007}
4008
4009// --- cMenuSetupCAM ---------------------------------------------------------
4010
4012private:
4014public:
4016 cCamSlot *CamSlot(void) { return camSlot; }
4017 bool Changed(void);
4018 };
4019
4026
4028{
4029 cString AssignedDevice("");
4030 const char *Activating = "";
4031 const char *CamName = camSlot->GetCamName();
4032 if (!CamName) {
4033 switch (camSlot->ModuleStatus()) {
4034 case msReset: CamName = tr("CAM reset"); break;
4035 case msPresent: CamName = tr("CAM present"); break;
4036 case msReady: CamName = tr("CAM ready"); break;
4037 default: CamName = "-"; break;
4038 }
4039 }
4040 else if (camSlot->IsActivating())
4041 // TRANSLATORS: note the leading blank!
4042 Activating = tr(" (activating)");
4043 cVector<int> DeviceNumbers;
4044 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
4045 if (CamSlot == camSlot || CamSlot->MasterSlot() == camSlot)
4046 CamSlot->Devices(DeviceNumbers);
4047 }
4048 if (DeviceNumbers.Size() > 0) {
4049 AssignedDevice = cString::sprintf(" %s", tr("@ device"));
4050 DeviceNumbers.Sort(CompareInts);
4051 for (int i = 0; i < DeviceNumbers.Size(); i++)
4052 AssignedDevice = cString::sprintf("%s %d", *AssignedDevice, DeviceNumbers[i]);
4053 }
4054
4055 cString buffer = cString::sprintf(" %d %s%s%s", camSlot->SlotNumber(), CamName, *AssignedDevice, Activating);
4056 if (strcmp(buffer, Text()) != 0) {
4057 SetText(buffer);
4058 return true;
4059 }
4060 return false;
4061}
4062
4064private:
4066 const char *activationHelp;
4067 eOSState Menu(void);
4068 eOSState Reset(void);
4069 eOSState Activate(void);
4070 void SetHelpKeys(void);
4071public:
4072 cMenuSetupCAM(void);
4073 virtual eOSState ProcessKey(eKeys Key) override;
4074 };
4075
4077{
4079 activationHelp = NULL;
4081 SetSection(tr("CAM"));
4082 SetCols(15);
4083 SetHasHotkeys();
4084 for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) {
4085 if (CamSlot->IsMasterSlot()) // we only list master CAM slots
4086 Add(new cMenuSetupCAMItem(CamSlot));
4087 }
4088 SetHelpKeys();
4089}
4090
4092{
4093 if (HasSubMenu())
4094 return;
4096 const char *NewActivationHelp = "";
4097 if (item) {
4098 cCamSlot *CamSlot = item->CamSlot();
4099 if (CamSlot->IsActivating())
4100 NewActivationHelp = tr("Button$Cancel activation");
4101 else if (CamSlot->CanActivate())
4102 NewActivationHelp = tr("Button$Activate");
4103 }
4104 if (NewActivationHelp != activationHelp) {
4105 activationHelp = NewActivationHelp;
4106 SetHelp(tr("Button$Menu"), tr("Button$Reset"), activationHelp);
4107 }
4108}
4109
4111{
4113 if (item) {
4114 if (item->CamSlot()->EnterMenu()) {
4115 Skins.Message(mtStatus, tr("Opening CAM menu..."));
4116 time_t t0 = time(NULL);
4117 time_t t1 = t0;
4118 while (time(NULL) - t0 <= MAXWAITFORCAMMENU) {
4119 if (item->CamSlot()->HasUserIO())
4120 break;
4121 if (time(NULL) - t1 >= CAMMENURETRYTIMEOUT) {
4122 dsyslog("CAM %d: retrying to enter CAM menu...", item->CamSlot()->SlotNumber());
4123 item->CamSlot()->EnterMenu();
4124 t1 = time(NULL);
4125 }
4126 cCondWait::SleepMs(100);
4127 }
4128 Skins.Message(mtStatus, NULL);
4129 if (item->CamSlot()->HasUserIO())
4130 return AddSubMenu(new cMenuCam(item->CamSlot()));
4131 }
4132 Skins.Message(mtError, tr("Can't open CAM menu!"));
4133 }
4134 return osContinue;
4135}
4136
4138{
4140 if (item) {
4141 cCamSlot *CamSlot = item->CamSlot();
4142 if (CamSlot->IsActivating())
4143 CamSlot->CancelActivation();
4144 else if (CamSlot->CanActivate()) {
4145 if (CamSlot->Priority() < LIVEPRIORITY) { // don't interrupt recordings
4147 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel())) {
4148 for (int i = 0; i < cDevice::NumDevices(); i++) {
4149 if (cDevice *Device = cDevice::GetDevice(i)) {
4150 if (Device->ProvidesChannel(Channel)) {
4151 if (Device->Priority() < LIVEPRIORITY) { // don't interrupt recordings
4152 if (CamSlot->Assign(Device, true)) { // query
4153 cControl::Shutdown(); // must end transfer mode before assigning CAM, otherwise it might be unassigned again
4154 CamSlot = CamSlot->MtdSpawn();
4155 if (CamSlot->Assign(Device)) {
4156 if (Device->SwitchChannel(Channel, true)) {
4157 CamSlot->StartActivation();
4158 return osContinue;
4159 }
4160 }
4161 }
4162 }
4163 }
4164 }
4165 }
4166 }
4167 }
4168 Skins.Message(mtError, tr("Can't activate CAM!"));
4169 }
4170 }
4171 return osContinue;
4172}
4173
4175{
4177 if (item) {
4178 if (!item->CamSlot()->Device() || Interface->Confirm(tr("CAM is in use - really reset?"))) {
4179 if (!item->CamSlot()->Reset())
4180 Skins.Message(mtError, tr("Can't reset CAM!"));
4181 }
4182 }
4183 return osContinue;
4184}
4185
4187{
4189
4190 if (!HasSubMenu()) {
4191 switch (Key) {
4192 case kOk:
4193 case kRed: return Menu();
4194 case kGreen: state = Reset(); break;
4195 case kYellow: state = Activate(); break;
4196 default: break;
4197 }
4198 for (cMenuSetupCAMItem *ci = (cMenuSetupCAMItem *)First(); ci; ci = (cMenuSetupCAMItem *)ci->Next()) {
4199 if (ci->Changed())
4200 DisplayItem(ci);
4201 }
4202 SetHelpKeys();
4203 }
4205 state = osEnd;
4206 return state;
4207}
4208
4209// --- cMenuSetupRecord ------------------------------------------------------
4210
4212private:
4215 const char *delTimeshiftRecTexts[3];
4216public:
4217 cMenuSetupRecord(void);
4218 };
4219
4221{
4223 recordKeyHandlingTexts[0] = tr("no instant recording");
4224 recordKeyHandlingTexts[1] = tr("confirm instant recording");
4225 recordKeyHandlingTexts[2] = tr("record instantly");
4226 pauseKeyHandlingTexts[0] = tr("do not pause live video");
4227 pauseKeyHandlingTexts[1] = tr("confirm pause live video");
4228 pauseKeyHandlingTexts[2] = tr("pause live video");
4229 delTimeshiftRecTexts[0] = tr("no");
4230 delTimeshiftRecTexts[1] = tr("confirm");
4231 delTimeshiftRecTexts[2] = tr("yes");
4232 SetSection(tr("Recording"));
4233 Add(new cMenuEditIntItem( tr("Setup.Recording$Margin at start (min)"), &data.MarginStart));
4234 Add(new cMenuEditIntItem( tr("Setup.Recording$Margin at stop (min)"), &data.MarginStop));
4235 Add(new cMenuEditIntItem( tr("Setup.Recording$Default priority"), &data.DefaultPriority, 0, MAXPRIORITY));
4236 Add(new cMenuEditIntItem( tr("Setup.Recording$Default lifetime (d)"), &data.DefaultLifetime, 0, MAXLIFETIME));
4237 Add(new cMenuEditStraItem(tr("Setup.Recording$Record key handling"), &data.RecordKeyHandling, 3, recordKeyHandlingTexts));
4238 Add(new cMenuEditStraItem(tr("Setup.Recording$Pause key handling"), &data.PauseKeyHandling, 3, pauseKeyHandlingTexts));
4239 Add(new cMenuEditIntItem( tr("Setup.Recording$Pause priority"), &data.PausePriority, 0, MAXPRIORITY));
4240 Add(new cMenuEditIntItem( tr("Setup.Recording$Pause lifetime (d)"), &data.PauseLifetime, 0, MAXLIFETIME));
4241 Add(new cMenuEditBoolItem(tr("Setup.Recording$Use episode name"), &data.UseSubtitle));
4242 Add(new cMenuEditBoolItem(tr("Setup.Recording$Use VPS"), &data.UseVps));
4243 Add(new cMenuEditIntItem( tr("Setup.Recording$VPS margin (s)"), &data.VpsMargin, 0));
4244 Add(new cMenuEditBoolItem(tr("Setup.Recording$Mark instant recording"), &data.MarkInstantRecord));
4245 Add(new cMenuEditStrItem( tr("Setup.Recording$Name instant recording"), data.NameInstantRecord, sizeof(data.NameInstantRecord)));
4246 Add(new cMenuEditIntItem( tr("Setup.Recording$Instant rec. time (min)"), &data.InstantRecordTime, 0, MAXINSTANTRECTIME, tr("Setup.Recording$present event")));
4247 Add(new cMenuEditIntItem( tr("Setup.Recording$Max. video file size (MB)"), &data.MaxVideoFileSize, MINVIDEOFILESIZE, MAXVIDEOFILESIZETS));
4248 Add(new cMenuEditBoolItem(tr("Setup.Recording$Split edited files"), &data.SplitEditedFiles));
4249 Add(new cMenuEditStraItem(tr("Setup.Recording$Delete timeshift recording"),&data.DelTimeshiftRec, 3, delTimeshiftRecTexts));
4250}
4251
4252// --- cMenuSetupReplay ------------------------------------------------------
4253
4255protected:
4256 virtual void Store(void) override;
4257public:
4258 cMenuSetupReplay(void);
4259 };
4260
4262{
4264 SetSection(tr("Replay"));
4265 Add(new cMenuEditBoolItem(tr("Setup.Replay$Multi speed mode"), &data.MultiSpeedMode));
4266 Add(new cMenuEditBoolItem(tr("Setup.Replay$Show replay mode"), &data.ShowReplayMode));
4267 Add(new cMenuEditBoolItem(tr("Setup.Replay$Show remaining time"), &data.ShowRemainingTime));
4268 Add(new cMenuEditIntItem( tr("Setup.Replay$Progress display time (s)"), &data.ProgressDisplayTime, 0, 60));
4269 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay when setting mark"), &data.PauseOnMarkSet));
4270 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay when jumping to a mark"), &data.PauseOnMarkJump));
4271 Add(new cMenuEditBoolItem(tr("Setup.Replay$Skip edited parts"), &data.SkipEdited));
4272 Add(new cMenuEditBoolItem(tr("Setup.Replay$Pause replay at last mark"), &data.PauseAtLastMark));
4273 Add(new cMenuEditIntItem( tr("Setup.Replay$Initial duration for adaptive skipping (s)"), &data.AdaptiveSkipInitial, 10, 600));
4274 Add(new cMenuEditIntItem( tr("Setup.Replay$Reset timeout for adaptive skipping (s)"), &data.AdaptiveSkipTimeout, 0, 10));
4275 Add(new cMenuEditBoolItem(tr("Setup.Replay$Alternate behavior for adaptive skipping"), &data.AdaptiveSkipAlternate));
4276 Add(new cMenuEditBoolItem(tr("Setup.Replay$Use Prev/Next keys for adaptive skipping"), &data.AdaptiveSkipPrevNext));
4277 Add(new cMenuEditIntItem( tr("Setup.Replay$Skip distance with Green/Yellow keys (s)"), &data.SkipSeconds, 5, 600));
4278 Add(new cMenuEditIntItem( tr("Setup.Replay$Skip distance with Green/Yellow keys in repeat (s)"), &data.SkipSecondsRepeat, 5, 600));
4279 Add(new cMenuEditIntItem(tr("Setup.Replay$Resume ID"), &data.ResumeID, 0, 99));
4280}
4281
4283{
4284 if (Setup.ResumeID != data.ResumeID) {
4286 Recordings->ResetResume();
4287 }
4289}
4290
4291// --- cMenuSetupMisc --------------------------------------------------------
4292
4294private:
4298 void Set(void);
4299public:
4300 cMenuSetupMisc(void);
4301 virtual eOSState ProcessKey(eKeys Key) override;
4302 };
4303
4305{
4307 svdrpPeeringModeTexts[0] = tr("off");
4308 svdrpPeeringModeTexts[1] = tr("any hosts");
4309 svdrpPeeringModeTexts[2] = tr("only default host");
4313 SetSection(tr("Miscellaneous"));
4314 Set();
4315}
4316
4318{
4319 int current = Current();
4320 Clear();
4321 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Min. event timeout (min)"), &data.MinEventTimeout));
4322 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Min. user inactivity (min)"), &data.MinUserInactivity));
4323 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$SVDRP timeout (s)"), &data.SVDRPTimeout));
4324 Add(new cMenuEditStraItem(tr("Setup.Miscellaneous$SVDRP peering"), &data.SVDRPPeering, 3, svdrpPeeringModeTexts));
4325 if (data.SVDRPPeering) {
4326 Add(new cMenuEditStrItem( tr("Setup.Miscellaneous$SVDRP host name"), data.SVDRPHostName, sizeof(data.SVDRPHostName)));
4328 svdrpServerNames.Sort(true);
4329 svdrpServerNames.Insert(strdup(""));
4330 Add(new cMenuEditStrlItem(tr("Setup.Miscellaneous$SVDRP default host"), data.SVDRPDefaultHost, sizeof(data.SVDRPDefaultHost), &svdrpServerNames));
4331 }
4332 }
4333 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Zap timeout (s)"), &data.ZapTimeout));
4334 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Channel entry timeout (ms)"), &data.ChannelEntryTimeout, 0));
4335 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Remote control repeat delay (ms)"), &data.RcRepeatDelay, 0));
4336 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Remote control repeat delta (ms)"), &data.RcRepeatDelta, 0));
4337 Add(new cMenuEditChanItem(tr("Setup.Miscellaneous$Initial channel"), &data.InitialChannel, tr("Setup.Miscellaneous$as before")));
4338 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Initial volume"), &data.InitialVolume, -1, 255, tr("Setup.Miscellaneous$as before")));
4339 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Volume steps"), &data.VolumeSteps, 5, 255));
4340 Add(new cMenuEditIntItem( tr("Setup.Miscellaneous$Volume linearize"), &data.VolumeLinearize, -20, 20));
4341 Add(new cMenuEditBoolItem(tr("Setup.Miscellaneous$Channels wrap"), &data.ChannelsWrap));
4342 Add(new cMenuEditStraItem(tr("Setup.Miscellaneous$Show channel names with source"), &data.ShowChannelNamesWithSource, 3, showChannelNamesWithSourceTexts));
4343 Add(new cMenuEditBoolItem(tr("Setup.Miscellaneous$Emergency exit"), &data.EmergencyExit));
4345 Display();
4346}
4347
4349{
4350 bool OldSVDRPPeering = data.SVDRPPeering;
4351 bool ModifiedSVDRPSettings = false;
4352 bool ModifiedShowChannelNamesWithSource = false;
4353 if (Key == kOk) {
4354 ModifiedSVDRPSettings = data.SVDRPPeering != Setup.SVDRPPeering || strcmp(data.SVDRPHostName, Setup.SVDRPHostName);
4355 ModifiedShowChannelNamesWithSource = data.ShowChannelNamesWithSource != Setup.ShowChannelNamesWithSource;
4356 }
4358 if (ModifiedShowChannelNamesWithSource) {
4360 for (cChannel *Channel = Channels->First(); Channel; Channel = Channels->Next(Channel))
4361 Channel->UpdateNameSource();
4362 }
4363 if (data.SVDRPPeering != OldSVDRPPeering)
4364 Set();
4365 if (ModifiedSVDRPSettings) {
4367 {
4369 Timers->SetExplicitModify();
4370 if (Timers->StoreRemoteTimers(NULL, NULL))
4371 Timers->SetModified();
4372 }
4374 }
4375 return state;
4376}
4377
4378// --- cMenuSetupPluginItem --------------------------------------------------
4379
4381private:
4383public:
4384 cMenuSetupPluginItem(const char *Name, int Index);
4385 int PluginIndex(void) { return pluginIndex; }
4386 };
4387
4389:cOsdItem(Name)
4390{
4392}
4393
4394// --- cMenuSetupPlugins -----------------------------------------------------
4395
4397public:
4398 cMenuSetupPlugins(void);
4399 virtual eOSState ProcessKey(eKeys Key) override;
4400 };
4401
4403{
4405 SetSection(tr("Plugins"));
4406 SetHasHotkeys();
4407 for (int i = 0; ; i++) {
4409 if (p)
4410 Add(new cMenuSetupPluginItem(hk(cString::sprintf("%s (%s) - %s", p->Name(), p->Version(), p->Description())), i));
4411 else
4412 break;
4413 }
4414}
4415
4417{
4419
4420 if (Key == kOk) {
4421 if (state == osUnknown) {
4423 if (item) {
4425 if (p) {
4426 cMenuSetupPage *menu = p->SetupMenu();
4427 if (menu) {
4428 menu->SetPlugin(p);
4429 return AddSubMenu(menu);
4430 }
4431 Skins.Message(mtInfo, tr("This plugin has no setup parameters!"));
4432 }
4433 }
4434 }
4435 else if (state == osContinue) {
4436 Store();
4437 // Reinitialize OSD and skin, in case any plugin setup change has an influence on these:
4439 Display();
4440 }
4441 }
4442 return state;
4443}
4444
4445// --- cMenuSetup ------------------------------------------------------------
4446
4447class cMenuSetup : public cOsdMenu {
4448private:
4449 virtual void Set(void);
4450 eOSState Restart(void);
4451public:
4452 cMenuSetup(void);
4453 virtual eOSState ProcessKey(eKeys Key) override;
4454 };
4455
4457:cOsdMenu("")
4458{
4460 Set();
4461}
4462
4464{
4465 Clear();
4466 char buffer[64];
4467 snprintf(buffer, sizeof(buffer), "%s - VDR %s", tr("Setup"), VDRVERSION);
4468 SetTitle(buffer);
4469 SetHasHotkeys();
4470 Add(new cOsdItem(hk(tr("OSD")), osUser1));
4471 Add(new cOsdItem(hk(tr("EPG")), osUser2));
4472 Add(new cOsdItem(hk(tr("DVB")), osUser3));
4473 Add(new cOsdItem(hk(tr("LNB")), osUser4));
4474 Add(new cOsdItem(hk(tr("CAM")), osUser5));
4475 Add(new cOsdItem(hk(tr("Recording")), osUser6));
4476 Add(new cOsdItem(hk(tr("Replay")), osUser7));
4477 Add(new cOsdItem(hk(tr("Miscellaneous")), osUser8));
4479 Add(new cOsdItem(hk(tr("Plugins")), osUser9));
4480 Add(new cOsdItem(hk(tr("Restart")), osUser10));
4481}
4482
4484{
4485 if (Interface->Confirm(tr("Really restart?")) && ShutdownHandler.ConfirmRestart(true)) {
4486 ShutdownHandler.Exit(1);
4487 return osEnd;
4488 }
4489 return osContinue;
4490}
4491
4493{
4494 int osdLanguage = I18nCurrentLanguage();
4495 eOSState state = cOsdMenu::ProcessKey(Key);
4496
4497 switch (state) {
4498 case osUser1: return AddSubMenu(new cMenuSetupOSD);
4499 case osUser2: return AddSubMenu(new cMenuSetupEPG);
4500 case osUser3: return AddSubMenu(new cMenuSetupDVB);
4501 case osUser4: return AddSubMenu(new cMenuSetupLNB);
4502 case osUser5: return AddSubMenu(new cMenuSetupCAM);
4503 case osUser6: return AddSubMenu(new cMenuSetupRecord);
4504 case osUser7: return AddSubMenu(new cMenuSetupReplay);
4505 case osUser8: return AddSubMenu(new cMenuSetupMisc);
4506 case osUser9: return AddSubMenu(new cMenuSetupPlugins);
4507 case osUser10: return Restart();
4508 default: ;
4509 }
4510 if (I18nCurrentLanguage() != osdLanguage) {
4511 Set();
4512 if (!HasSubMenu())
4513 Display();
4514 }
4515 return state;
4516}
4517
4518// --- cMenuPluginItem -------------------------------------------------------
4519
4521private:
4523public:
4524 cMenuPluginItem(const char *Name, int Index);
4525 int PluginIndex(void) { return pluginIndex; }
4526 };
4527
4529:cOsdItem(Name, osPlugin)
4530{
4532}
4533
4534// --- cMenuMain -------------------------------------------------------------
4535
4536// TRANSLATORS: note the leading and trailing blanks!
4537#define STOP_RECORDING trNOOP(" Stop recording ")
4538
4540
4541cMenuMain::cMenuMain(eOSState State, bool OpenSubMenus)
4542:cOsdMenu("")
4543{
4545 replaying = false;
4546 stopReplayItem = NULL;
4547 cancelEditingItem = NULL;
4548 stopRecordingItem = NULL;
4550 Set();
4551
4552 // Initial submenus:
4553
4554 cOsdObject *menu = NULL;
4555 switch (State) {
4556 case osSchedule:
4557 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu))
4558 menu = new cMenuSchedule;
4559 break;
4560 case osChannels:
4561 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu))
4562 menu = new cMenuChannels;
4563 break;
4564 case osTimers:
4565 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu))
4566 menu = new cMenuTimers;
4567 break;
4568 case osRecordings:
4569 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu))
4570 menu = new cMenuRecordings(NULL, 0, OpenSubMenus);
4571 break;
4572 case osSetup: menu = new cMenuSetup; break;
4573 case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break;
4574 default: break;
4575 }
4576 if (menu)
4577 if (menu->IsMenu())
4578 AddSubMenu((cOsdMenu *) menu);
4579}
4580
4582{
4584 pluginOsdObject = NULL;
4585 return o;
4586}
4587
4589{
4590 Clear();
4591 SetTitle("VDR");
4592 SetHasHotkeys();
4593
4594 // Basic menu items:
4595
4596 Add(new cOsdItem(hk(tr("Schedule")), osSchedule));
4597 Add(new cOsdItem(hk(tr("Channels")), osChannels));
4598 Add(new cOsdItem(hk(tr("Timers")), osTimers));
4599 Add(new cOsdItem(hk(tr("Recordings")), osRecordings));
4600
4601 // Plugins:
4602
4603 for (int i = 0; ; i++) {
4605 if (p) {
4606 const char *item = p->MainMenuEntry();
4607 if (item)
4608 Add(new cMenuPluginItem(hk(item), i));
4609 }
4610 else
4611 break;
4612 }
4613
4614 // More basic menu items:
4615
4616 Add(new cOsdItem(hk(tr("Setup")), osSetup));
4617 if (Commands.Count())
4618 Add(new cOsdItem(hk(tr("Commands")), osCommands));
4619
4620 Update(true);
4621
4622 Display();
4623}
4624
4625bool cMenuMain::Update(bool Force)
4626{
4627 bool result = false;
4628
4629 bool NewReplaying = false;
4630 {
4631 cMutexLock ControlMutexLock;
4632 NewReplaying = cControl::Control(ControlMutexLock) != NULL;
4633 }
4634 if (Force || NewReplaying != replaying) {
4635 replaying = NewReplaying;
4636 // Replay control:
4637 if (replaying && !stopReplayItem)
4638 // TRANSLATORS: note the leading blank!
4639 Add(stopReplayItem = new cOsdItem(tr(" Stop replaying"), osStopReplay));
4640 else if (stopReplayItem && !replaying) {
4641 Del(stopReplayItem->Index());
4642 stopReplayItem = NULL;
4643 }
4644 // Color buttons:
4645 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"));
4646 result = true;
4647 }
4648
4649 // Editing control:
4650 bool EditingActive = RecordingsHandler.Active();
4651 if (EditingActive && !cancelEditingItem) {
4652 // TRANSLATORS: note the leading blank!
4653 Add(cancelEditingItem = new cOsdItem(tr(" Cancel editing"), osCancelEdit));
4654 result = true;
4655 }
4656 else if (cancelEditingItem && !EditingActive) {
4657 Del(cancelEditingItem->Index());
4658 cancelEditingItem = NULL;
4659 result = true;
4660 }
4661
4662 // Record control:
4664 while (stopRecordingItem) {
4666 Del(stopRecordingItem->Index());
4667 stopRecordingItem = it;
4668 }
4669 const char *s = NULL;
4670 while ((s = cRecordControls::GetInstantId(s)) != NULL) {
4671 cOsdItem *item = new cOsdItem(osStopRecord);
4672 item->SetText(cString::sprintf("%s%s", tr(STOP_RECORDING), s));
4673 Add(item);
4674 if (!stopRecordingItem)
4675 stopRecordingItem = item;
4676 }
4677 result = true;
4678 }
4679
4680 return result;
4681}
4682
4684{
4685 bool HadSubMenu = HasSubMenu();
4686 int osdLanguage = I18nCurrentLanguage();
4687 eOSState state = cOsdMenu::ProcessKey(Key);
4688 HadSubMenu |= HasSubMenu();
4689
4690 cOsdObject *menu = NULL;
4691 switch (state) {
4692 case osSchedule:
4693 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu))
4694 menu = new cMenuSchedule;
4695 else
4696 state = osContinue;
4697 break;
4698 case osChannels:
4699 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu))
4700 menu = new cMenuChannels;
4701 else
4702 state = osContinue;
4703 break;
4704 case osTimers:
4705 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu))
4706 menu = new cMenuTimers;
4707 else
4708 state = osContinue;
4709 break;
4710 case osRecordings:
4711 if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu))
4712 menu = new cMenuRecordings;
4713 else
4714 state = osContinue;
4715 break;
4716 case osSetup: menu = new cMenuSetup; break;
4717 case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break;
4718 case osStopRecord: if (Interface->Confirm(tr("Stop recording?"))) {
4719 if (cOsdItem *item = Get(Current())) {
4720 cRecordControls::Stop(item->Text() + strlen(tr(STOP_RECORDING)));
4721 return osEnd;
4722 }
4723 }
4724 break;
4725 case osCancelEdit: if (Interface->Confirm(tr("Cancel editing?"))) {
4726 RecordingsHandler.DelAll();
4727 return osEnd;
4728 }
4729 break;
4730 case osPlugin: {
4732 if (item) {
4734 if (p) {
4735 cOsdObject *menu = p->MainMenuAction();
4736 if (menu) {
4737 if (menu->IsMenu())
4738 return AddSubMenu((cOsdMenu *)menu);
4739 else {
4740 pluginOsdObject = menu;
4741 return osPlugin;
4742 }
4743 }
4744 }
4745 }
4746 state = osEnd;
4747 }
4748 break;
4749 default: switch (Key) {
4750 case kRecord:
4751 case kRed: if (!HadSubMenu)
4752 state = replaying || !Setup.RecordKeyHandling ? osContinue : osRecord;
4753 break;
4754 case kGreen: if (!HadSubMenu) {
4755 cRemote::Put(kAudio, true);
4756 state = osEnd;
4757 }
4758 break;
4759 case kYellow: if (!HadSubMenu)
4760 state = replaying || !Setup.PauseKeyHandling ? osContinue : osPause;
4761 break;
4762 case kBlue: if (!HadSubMenu)
4764 break;
4765 default: break;
4766 }
4767 }
4768 if (menu) {
4769 if (menu->IsMenu())
4770 return AddSubMenu((cOsdMenu *) menu);
4771 pluginOsdObject = menu;
4772 return osPlugin;
4773 }
4774 bool DoDisplay = Update();
4775 if (Key != kNone) {
4776 if (I18nCurrentLanguage() != osdLanguage) {
4777 Set();
4778 if (!HasSubMenu())
4779 DoDisplay = true;
4780 }
4781 }
4782 if (DoDisplay)
4783 Display();
4784 return state;
4785}
4786
4787// --- SetTrackDescriptions --------------------------------------------------
4788
4789void SetTrackDescriptions(int LiveChannel)
4790{
4792 const cComponents *Components = NULL;
4793 if (LiveChannel) {
4795 if (const cChannel *Channel = Channels->GetByNumber(LiveChannel)) {
4797 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
4798 const cEvent *Present = Schedule->GetPresentEvent();
4799 if (Present)
4800 Components = Present->Components();
4801 }
4802 }
4803 }
4804 else if (cReplayControl::NowReplaying()) {
4806 if (const cRecording *Recording = Recordings->GetByName(cReplayControl::NowReplaying()))
4807 Components = Recording->Info()->Components();
4808 }
4809 if (Components) {
4810 int indexAudio = 0;
4811 int indexDolby = 0;
4812 int indexSubtitle = 0;
4813 for (int i = 0; i < Components->NumComponents(); i++) {
4814 const tComponent *p = Components->Component(i);
4815 switch (p->stream) {
4816 case 2: if (p->type == 0x05)
4817 cDevice::PrimaryDevice()->SetAvailableTrack(ttDolby, indexDolby++, 0, LiveChannel ? NULL : p->language, p->description);
4818 else
4819 cDevice::PrimaryDevice()->SetAvailableTrack(ttAudio, indexAudio++, 0, LiveChannel ? NULL : p->language, p->description);
4820 break;
4821 case 3: cDevice::PrimaryDevice()->SetAvailableTrack(ttSubtitle, indexSubtitle++, 0, LiveChannel ? NULL : p->language, p->description);
4822 break;
4823 case 4: cDevice::PrimaryDevice()->SetAvailableTrack(ttDolby, indexDolby++, 0, LiveChannel ? NULL : p->language, p->description);
4824 break;
4825 default: ;
4826 }
4827 }
4828 }
4829}
4830
4831// --- cDisplayChannel -------------------------------------------------------
4832
4834
4835cDisplayChannel::cDisplayChannel(int Number, bool Switched)
4836:cOsdObject(true)
4837{
4838 currentDisplayChannel = this;
4839 group = -1;
4840 withInfo = !Switched || Setup.ShowInfoOnChSwitch;
4842 number = 0;
4843 timeout = Switched || Setup.TimeoutRequChInfo;
4844 cOsdProvider::OsdSizeChanged(osdState); // just to get the current state
4845 positioner = NULL;
4846 channel = NULL;
4847 {
4849 channel = Channels->GetByNumber(Number);
4850 lastPresent = lastFollowing = NULL;
4851 if (channel) {
4853 DisplayInfo();
4854 }
4855 }
4856 if (channel)
4857 displayChannel->Flush();
4858 lastTime.Set();
4859}
4860
4862:cOsdObject(true)
4863{
4864 currentDisplayChannel = this;
4865 group = -1;
4866 number = 0;
4867 timeout = true;
4868 lastPresent = lastFollowing = NULL;
4869 cOsdProvider::OsdSizeChanged(osdState); // just to get the current state
4870 lastTime.Set();
4871 withInfo = Setup.ShowInfoOnChSwitch;
4872 displayChannel = Skins.Current()->DisplayChannel(withInfo);
4873 positioner = NULL;
4874 channel = NULL;
4875 {
4877 channel = Channels->GetByNumber(cDevice::CurrentChannel());
4878 }
4879 ProcessKey(FirstKey);
4880}
4881
4888
4896
4898{
4899 if (withInfo && channel) {
4901 if (const cSchedule *Schedule = Schedules->GetSchedule(channel)) {
4902 const cEvent *Present = Schedule->GetPresentEvent();
4903 const cEvent *Following = Schedule->GetFollowingEvent();
4904 if (Present != lastPresent || Following != lastFollowing) {
4905 SetTrackDescriptions(channel->Number());
4906 displayChannel->SetEvents(Present, Following);
4907 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);
4908 lastPresent = Present;
4909 lastFollowing = Following;
4910 lastTime.Set();
4911 }
4912 }
4913 }
4914}
4915
4917{
4919 displayChannel->SetEvents(NULL, NULL);
4920}
4921
4922const cChannel *cDisplayChannel::NextAvailableChannel(const cChannel *Channel, int Direction)
4923{
4924 if (Direction) {
4925 cControl::Shutdown(); // prevents old channel from being shown too long if GetDevice() takes longer
4926 // and, if decrypted, this removes the now superfluous PIDs from the CAM, too
4928 while (Channel) {
4929 Channel = Direction > 0 ? Channels->Next(Channel) : Channels->Prev(Channel);
4930 if (!Channel && Setup.ChannelsWrap)
4931 Channel = Direction > 0 ? Channels->First() : Channels->Last();
4932 if (Channel && !Channel->GroupSep() && cDevice::GetDevice(Channel, LIVEPRIORITY, true, true))
4933 return Channel;
4934 }
4935 }
4936 return NULL;
4937}
4938
4940{
4942 delete displayChannel;
4943 displayChannel = Skins.Current()->DisplayChannel(withInfo);
4944 }
4945 const cChannel *NewChannel = NULL;
4946 if (Key != kNone)
4947 lastTime.Set();
4948 switch (int(Key)) {
4949 case k0:
4950 if (number == 0) {
4951 // keep the "Toggle channels" function working
4952 cRemote::Put(Key);
4953 return osEnd;
4954 }
4955 case k1 ... k9:
4956 group = -1;
4957 if (number >= 0) {
4959 number = Key - k0;
4960 else
4961 number = number * 10 + Key - k0;
4963 channel = Channels->GetByNumber(number);
4964 Refresh();
4965 withInfo = false;
4966 // Lets see if there can be any useful further input:
4967 int n = channel ? number * 10 : 0;
4968 int m = 10;
4969 const cChannel *ch = channel;
4970 while (ch && (ch = Channels->Next(ch)) != NULL) {
4971 if (!ch->GroupSep()) {
4972 if (n <= ch->Number() && ch->Number() < n + m) {
4973 n = 0;
4974 break;
4975 }
4976 if (ch->Number() > n) {
4977 n *= 10;
4978 m *= 10;
4979 }
4980 }
4981 }
4982 if (n > 0) {
4983 // This channel is the only one that fits the input, so let's take it right away:
4984 NewChannel = channel;
4985 withInfo = true;
4986 number = 0;
4987 Refresh();
4988 }
4989 }
4990 break;
4991 case kLeft|k_Repeat:
4992 case kLeft:
4993 case kRight|k_Repeat:
4994 case kRight:
4995 case kNext|k_Repeat:
4996 case kNext:
4997 case kPrev|k_Repeat:
4998 case kPrev: {
4999 withInfo = false;
5000 number = 0;
5002 if (group < 0) {
5003 if (const cChannel *Channel = Channels->GetByNumber(cDevice::CurrentChannel()))
5004 group = Channel->Index();
5005 }
5006 if (group >= 0) {
5007 int SaveGroup = group;
5008 if (NORMALKEY(Key) == kRight || NORMALKEY(Key) == kNext)
5009 group = Channels->GetNextGroup(group) ;
5010 else
5011 group = Channels->GetPrevGroup(group < 1 ? 1 : group);
5012 if (group < 0)
5013 group = SaveGroup;
5014 channel = Channels->Get(group);
5015 if (channel) {
5016 Refresh();
5017 if (!channel->GroupSep())
5018 group = -1;
5019 }
5020 }
5021 break;
5022 }
5023 case kUp|k_Repeat:
5024 case kUp:
5025 case kDown|k_Repeat:
5026 case kDown:
5027 case kChanUp|k_Repeat:
5028 case kChanUp:
5029 case kChanDn|k_Repeat:
5030 case kChanDn: {
5031 eKeys k = NORMALKEY(Key);
5032 if (const cChannel *Channel = NextAvailableChannel(channel, (k == kUp || k == kChanUp) ? 1 : -1))
5033 channel = Channel;
5034 else if (channel && channel->Number() != cDevice::CurrentChannel())
5035 Key = k; // immediately switches channel when hitting the beginning/end of the channel list with k_Repeat
5036 }
5037 // no break here
5038 case kUp|k_Release:
5039 case kDown|k_Release:
5040 case kChanUp|k_Release:
5041 case kChanDn|k_Release:
5042 case kNext|k_Release:
5043 case kPrev|k_Release:
5044 if (!(Key & k_Repeat) && channel && channel->Number() != cDevice::CurrentChannel())
5045 NewChannel = channel;
5046 withInfo = true;
5047 group = -1;
5048 number = 0;
5049 Refresh();
5050 break;
5051 case kNone:
5052 if (number && Setup.ChannelEntryTimeout && int(lastTime.Elapsed()) > Setup.ChannelEntryTimeout) {
5054 channel = Channels->GetByNumber(number);
5055 if (channel)
5056 NewChannel = channel;
5057 withInfo = true;
5058 number = 0;
5059 Refresh();
5060 lastTime.Set();
5061 }
5062 break;
5063 //TODO
5064 //XXX case kGreen: return osEventNow;
5065 //XXX case kYellow: return osEventNext;
5066 case kOk: {
5068 if (group >= 0) {
5069 channel = Channels->Get(Channels->GetNextNormal(group));
5070 if (channel)
5071 NewChannel = channel;
5072 withInfo = true;
5073 group = -1;
5074 Refresh();
5075 }
5076 else if (number > 0) {
5077 channel = Channels->GetByNumber(number);
5078 if (channel)
5079 NewChannel = channel;
5080 withInfo = true;
5081 number = 0;
5082 Refresh();
5083 }
5084 else {
5085 return osEnd;
5086 }
5087 }
5088 break;
5089 default:
5090 if ((Key & (k_Repeat | k_Release)) == 0) {
5091 cRemote::Put(Key);
5092 return osEnd;
5093 }
5094 };
5095 if (positioner || !timeout || lastTime.Elapsed() < (uint64_t)(Setup.ChannelInfoTime * 1000)) {
5096 {
5099 // makes sure a channel switch through the SVDRP CHAN command is displayed
5100 channel = Channels->GetByNumber(cDevice::CurrentChannel());
5101 Refresh();
5102 lastTime.Set();
5103 }
5104 DisplayInfo();
5105 if (NewChannel) {
5106 SetTrackDescriptions(NewChannel->Number()); // to make them immediately visible in the channel display
5107 Channels->SwitchTo(NewChannel->Number());
5108 SetTrackDescriptions(NewChannel->Number()); // switching the channel has cleared them
5109 channel = NewChannel;
5110 }
5111 const cPositioner *Positioner = cDevice::ActualDevice()->Positioner();
5112 bool PositionerMoving = Positioner && Positioner->IsMoving();
5113 SetNeedsFastResponse(PositionerMoving);
5114 if (!PositionerMoving) {
5115 if (positioner)
5116 lastTime.Set(); // to keep the channel display up a few seconds after the target position has been reached
5117 Positioner = NULL;
5118 }
5119 if (Positioner || positioner) // making sure we call SetPositioner(NULL) if there is a switch from "with" to "without" positioner
5120 displayChannel->SetPositioner(Positioner);
5121 positioner = Positioner;
5122 }
5123 displayChannel->Flush();
5124 return osContinue;
5125 }
5126 return osEnd;
5127}
5128
5129// --- cDisplayVolume --------------------------------------------------------
5130
5131#define VOLUMETIMEOUT 1000 //ms
5132#define MUTETIMEOUT 5000 //ms
5133
5135
5137:cOsdObject(true)
5138{
5139 currentDisplayVolume = this;
5141 displayVolume = Skins.Current()->DisplayVolume();
5142 Show();
5143}
5144
5150
5152{
5154}
5155
5162
5164{
5166 currentDisplayVolume->ProcessKey(Key);
5167}
5168
5170{
5171 switch (int(Key)) {
5172 case kVolUp|k_Repeat:
5173 case kVolUp:
5174 case kVolDn|k_Repeat:
5175 case kVolDn:
5176 Show();
5178 break;
5179 case kMute:
5180 if (cDevice::PrimaryDevice()->IsMute()) {
5181 Show();
5182 timeout.Set(MUTETIMEOUT);
5183 }
5184 else
5185 timeout.Set();
5186 break;
5187 case kNone: break;
5188 default: if ((Key & k_Release) == 0) {
5189 cRemote::Put(Key);
5190 return osEnd;
5191 }
5192 }
5193 return timeout.TimedOut() ? osEnd : osContinue;
5194}
5195
5196// --- cDisplayTracks --------------------------------------------------------
5197
5198#define TRACKTIMEOUT 5000 //ms
5199
5201
5203:cOsdObject(true)
5204{
5207 currentDisplayTracks = this;
5208 numTracks = track = 0;
5211 for (int i = ttAudioFirst; i <= ttDolbyLast; i++) {
5212 const tTrackId *TrackId = cDevice::PrimaryDevice()->GetTrack(eTrackType(i));
5213 if (TrackId && TrackId->id) {
5215 descriptions[numTracks] = strdup(*TrackId->description ? TrackId->description : *TrackId->language ? TrackId->language : *itoa(i));
5216 if (i == CurrentAudioTrack)
5217 track = numTracks;
5218 numTracks++;
5219 }
5220 }
5221 descriptions[numTracks] = NULL;
5222 timeout.Set(TRACKTIMEOUT);
5223 displayTracks = Skins.Current()->DisplayTracks(tr("Button$Audio"), numTracks, descriptions);
5224 Show();
5225}
5226
5228{
5229 delete displayTracks;
5230 currentDisplayTracks = NULL;
5231 for (int i = 0; i < numTracks; i++)
5232 free(descriptions[i]);
5234}
5235
5237{
5238 int ac = IS_AUDIO_TRACK(types[track]) ? audioChannel : -1;
5239 displayTracks->SetTrack(track, descriptions);
5240 displayTracks->SetAudioChannel(ac);
5241 displayTracks->Flush();
5244}
5245
5247{
5248 if (cDevice::PrimaryDevice()->NumAudioTracks() > 0) {
5250 new cDisplayTracks;
5251 return currentDisplayTracks;
5252 }
5253 Skins.Message(mtWarning, tr("No audio available!"));
5254 return NULL;
5255}
5256
5258{
5260 currentDisplayTracks->ProcessKey(Key);
5261}
5262
5264{
5265 int oldTrack = track;
5266 int oldAudioChannel = audioChannel;
5267 switch (int(Key)) {
5268 case kUp|k_Repeat:
5269 case kUp:
5270 case kDown|k_Repeat:
5271 case kDown:
5272 if (NORMALKEY(Key) == kUp && track > 0)
5273 track--;
5274 else if (NORMALKEY(Key) == kDown && track < numTracks - 1)
5275 track++;
5276 timeout.Set(TRACKTIMEOUT);
5277 break;
5278 case kLeft|k_Repeat:
5279 case kLeft:
5280 case kRight|k_Repeat:
5281 case kRight: if (IS_AUDIO_TRACK(types[track])) {
5282 static int ac[] = { 1, 0, 2 };
5284 if (NORMALKEY(Key) == kLeft && audioChannel > 0)
5285 audioChannel--;
5286 else if (NORMALKEY(Key) == kRight && audioChannel < 2)
5287 audioChannel++;
5289 timeout.Set(TRACKTIMEOUT);
5290 }
5291 break;
5292 case kAudio|k_Repeat:
5293 case kAudio:
5294 if (++track >= numTracks)
5295 track = 0;
5296 timeout.Set(TRACKTIMEOUT);
5297 break;
5298 case kOk:
5299 if (types[track] != cDevice::PrimaryDevice()->GetCurrentAudioTrack())
5300 oldTrack = -1; // make sure we explicitly switch to that track
5301 timeout.Set();
5302 break;
5303 case kNone: break;
5304 default: if ((Key & k_Release) == 0)
5305 return osEnd;
5306 }
5307 if (track != oldTrack || audioChannel != oldAudioChannel)
5308 Show();
5309 if (track != oldTrack) {
5311 Setup.CurrentDolby = IS_DOLBY_TRACK(types[track]);
5312 }
5313 if (audioChannel != oldAudioChannel)
5315 return timeout.TimedOut() ? osEnd : osContinue;
5316}
5317
5318// --- cDisplaySubtitleTracks ------------------------------------------------
5319
5321
5323:cOsdObject(true)
5324{
5326 currentDisplayTracks = this;
5327 numTracks = track = 0;
5329 descriptions[numTracks] = strdup(tr("No subtitles"));
5330 numTracks++;
5331 eTrackType CurrentSubtitleTrack = cDevice::PrimaryDevice()->GetCurrentSubtitleTrack();
5332 for (int i = ttSubtitleFirst; i <= ttSubtitleLast; i++) {
5333 const tTrackId *TrackId = cDevice::PrimaryDevice()->GetTrack(eTrackType(i));
5334 if (TrackId && TrackId->id) {
5336 descriptions[numTracks] = strdup(*TrackId->description ? TrackId->description : *TrackId->language ? TrackId->language : *itoa(i));
5337 if (i == CurrentSubtitleTrack)
5338 track = numTracks;
5339 numTracks++;
5340 }
5341 }
5342 descriptions[numTracks] = NULL;
5343 timeout.Set(TRACKTIMEOUT);
5344 displayTracks = Skins.Current()->DisplayTracks(tr("Button$Subtitles"), numTracks, descriptions);
5345 Show();
5346}
5347
5349{
5350 delete displayTracks;
5351 currentDisplayTracks = NULL;
5352 for (int i = 0; i < numTracks; i++)
5353 free(descriptions[i]);
5355}
5356
5363
5365{
5366 if (cDevice::PrimaryDevice()->NumSubtitleTracks() > 0) {
5369 return currentDisplayTracks;
5370 }
5371 Skins.Message(mtWarning, tr("No subtitles available!"));
5372 return NULL;
5373}
5374
5376{
5378 currentDisplayTracks->ProcessKey(Key);
5379}
5380
5382{
5383 int oldTrack = track;
5384 switch (int(Key)) {
5385 case kUp|k_Repeat:
5386 case kUp:
5387 case kDown|k_Repeat:
5388 case kDown:
5389 if (NORMALKEY(Key) == kUp && track > 0)
5390 track--;
5391 else if (NORMALKEY(Key) == kDown && track < numTracks - 1)
5392 track++;
5393 timeout.Set(TRACKTIMEOUT);
5394 break;
5395 case kSubtitles|k_Repeat:
5396 case kSubtitles:
5397 if (++track >= numTracks)
5398 track = 0;
5399 timeout.Set(TRACKTIMEOUT);
5400 break;
5401 case kOk:
5402 oldTrack = -1; // make sure we explicitly switch to that track
5403 timeout.Set();
5404 break;
5405 case kNone: break;
5406 default: if ((Key & k_Release) == 0)
5407 return osEnd;
5408 }
5409 if (track != oldTrack) {
5410 Show();
5412 if (track == ttNone && Setup.DisplaySubtitles == SUBTITLES_REWIND) {
5415 }
5416 }
5417 return timeout.TimedOut() ? osEnd : osContinue;
5418}
5419
5420// --- cRecordControl --------------------------------------------------------
5421
5423{
5424 const char *LastReplayed = cReplayControl::LastReplayed(); // must do this before locking schedules!
5425 // Whatever happens here, the timers will be modified in some way...
5426 Timers->SetModified();
5427 cStateKey ChannelsStateKey;
5428 // To create a new timer, we need to make shure there is
5429 // a lock on Channels prior to the Schedules locking below
5430 if (!Timer)
5431 cChannels::GetChannelsRead(ChannelsStateKey);
5432 // We're going to work with an event here, so we need to prevent
5433 // others from modifying any EPG data:
5434 cStateKey SchedulesStateKey;
5435 cSchedules::GetSchedulesRead(SchedulesStateKey);
5436
5437 event = NULL;
5438 fileName = NULL;
5439 recorder = NULL;
5440 device = Device;
5441 if (!device) device = cDevice::PrimaryDevice();//XXX
5442 timer = Timer;
5443 if (!timer) {
5444 timer = new cTimer(true, Pause);
5445 Timers->Add(timer);
5446 instantId = cString::sprintf(cDevice::NumDevices() > 1 ? "%s - %d" : "%s", timer->Channel()->Name(), device->DeviceNumber() + 1);
5447 ChannelsStateKey.Remove();
5448 }
5449 timer->SetPending(true);
5450 timer->SetRecording(true);
5451 event = timer->Event();
5452
5453 if (event || GetEvent())
5454 dsyslog("Title: '%s' Subtitle: '%s'", event->Title(), event->ShortText());
5455 cRecording Recording(timer, event);
5456 fileName = strdup(Recording.FileName());
5457
5458 // crude attempt to avoid duplicate recordings:
5460 isyslog("already recording: '%s'", fileName);
5461 if (Timer) {
5462 timer->SetPending(false);
5463 timer->SetRecording(false);
5464 timer->OnOff();
5465 }
5466 else {
5467 Timers->Del(timer);
5468 if (!LastReplayed) // an instant recording, maybe from cRecordControls::PauseLiveVideo()
5470 }
5471 timer = NULL;
5472 SchedulesStateKey.Remove();
5473 return;
5474 }
5475
5477 isyslog("record %s", fileName);
5478 if (MakeDirs(fileName, true)) {
5479 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!
5480 const cChannel *ch = timer->Channel();
5481 recorder = new cRecorder(fileName, ch, timer->Priority());
5482 if (device->AttachReceiver(recorder)) {
5483 cStatus::MsgRecording(device, Recording.Name(), Recording.FileName(), true);
5484 if (!Timer && !LastReplayed) // an instant recording, maybe from cRecordControls::PauseLiveVideo()
5486 SchedulesStateKey.Remove();
5488 SetRecordingTimerId(fileName, cString::sprintf("%d@%s", timer->Id(), Setup.SVDRPHostName));
5489 Recordings->AddByName(fileName);
5490 return;
5491 }
5492 else
5494 }
5495 else
5496 timer->SetDeferred(DEFERTIMER);
5497 if (!Timer) {
5498 Timers->Del(timer);
5499 timer = NULL;
5500 }
5501 SchedulesStateKey.Remove();
5502}
5503
5505{
5506 Stop();
5507 free(fileName);
5508}
5509
5510#define INSTANT_REC_EPG_LOOKAHEAD 300 // seconds to look into the EPG data for an instant recording
5511
5513{
5514 const cChannel *Channel = timer->Channel();
5515 time_t Time = timer->HasFlags(tfInstant) ? timer->StartTime() + INSTANT_REC_EPG_LOOKAHEAD : timer->StartTime() + (timer->StopTime() - timer->StartTime()) / 2;
5516 for (int seconds = 0; seconds <= MAXWAIT4EPGINFO; seconds++) {
5517 {
5519 if (const cSchedule *Schedule = Schedules->GetSchedule(Channel)) {
5520 event = Schedule->GetEventAround(Time);
5521 if (event) {
5522 if (seconds > 0)
5523 dsyslog("got EPG info after %d seconds", seconds);
5524 return true;
5525 }
5526 }
5527 }
5528 if (seconds == 0)
5529 dsyslog("waiting for EPG info...");
5530 cCondWait::SleepMs(1000);
5531 }
5532 dsyslog("no EPG info available");
5533 return false;
5534}
5535
5536void cRecordControl::Stop(bool ExecuteUserCommand)
5537{
5538 if (timer) {
5539 bool Finished = timer->HasFlags(tfActive) && !timer->Matches();
5540 if (recorder) {
5541 int Errors = recorder->Errors();
5542 isyslog("timer %s %s with %d error%s", *timer->ToDescr(), Finished ? "finished" : "stopped", Errors, Errors != 1 ? "s" : "");
5543 if (timer->HasFlags(tfAvoid) && Errors == 0 && Finished) {
5544 const char *p = strgetlast(timer->File(), FOLDERDELIMCHAR);
5545 DoneRecordingsPattern.Append(p);
5546 }
5547 }
5549 timer->SetRecording(false);
5550 timer = NULL;
5552 cStatus::MsgRecording(device, NULL, fileName, false);
5553 if (ExecuteUserCommand && Finished)
5555 }
5556}
5557
5559{
5560 if (!recorder || !recorder->IsAttached() || !timer || !timer->Matches(t)) {
5561 if (timer)
5562 timer->SetPending(false);
5563 return false;
5564 }
5565 return true;
5566}
5567
5568// --- cRecordControls -------------------------------------------------------
5569
5572
5573bool cRecordControls::Start(cTimers *Timers, cTimer *Timer, bool Pause)
5574{
5575 static time_t LastNoDiskSpaceMessage = 0;
5576 int FreeMB = 0;
5577 if (Timer) {
5578 AssertFreeDiskSpace(Timer->Priority(), !Timer->Pending());
5579 Timer->SetPending(true);
5580 }
5582 if (FreeMB < MINFREEDISK) {
5583 if (!Timer || time(NULL) - LastNoDiskSpaceMessage > NODISKSPACEDELTA) {
5584 isyslog("not enough disk space to start recording%s%s", Timer ? " timer " : "", Timer ? *Timer->ToDescr() : "");
5585 Skins.Message(mtWarning, tr("Not enough disk space to start recording!"));
5586 LastNoDiskSpaceMessage = time(NULL);
5587 }
5588 return false;
5589 }
5590 LastNoDiskSpaceMessage = 0;
5591
5592 ChangeState();
5593 cStateKey StateKey;
5594 const cChannels *Channels = cChannels::GetChannelsRead(StateKey);
5595 int ch = Timer ? Timer->Channel()->Number() : cDevice::CurrentChannel();
5596 if (const cChannel *Channel = Channels->GetByNumber(ch)) {
5597 int Priority = Timer ? Timer->Priority() : Pause ? Setup.PausePriority : Setup.DefaultPriority;
5598 cDevice *device = cDevice::GetDevice(Channel, Priority, false);
5599 if (device) {
5600 dsyslog("switching device %d to channel %d %s (%s)", device->DeviceNumber() + 1, Channel->Number(), *Channel->GetChannelID().ToString(), Channel->Name());
5601 if (!device->SwitchChannel(Channel, false)) {
5602 StateKey.Remove();
5603 ShutdownHandler.RequestEmergencyExit();
5604 return false;
5605 }
5606 StateKey.Remove();
5607 Channels = NULL;
5608 if (!Timer || Timer->Matches()) {
5609 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5610 if (!RecordControls[i]) {
5611 RecordControls[i] = new cRecordControl(device, Timers, Timer, Pause);
5612 return RecordControls[i]->Process(time(NULL));
5613 }
5614 }
5615 }
5616 }
5617 else if (!Timer || !Timer->Pending()) {
5618 isyslog("no free DVB device to record channel %d (%s)!", ch, Channel->Name());
5619 Skins.Message(mtError, tr("No free DVB device to record!"));
5620 }
5621 }
5622 else
5623 esyslog("ERROR: channel %d not defined!", ch);
5624 if (Channels)
5625 StateKey.Remove();
5626 return false;
5627}
5628
5630{
5632 return Start(Timers, NULL, Pause);
5633}
5634
5635void cRecordControls::Stop(const char *InstantId)
5636{
5638 ChangeState();
5639 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5640 if (RecordControls[i]) {
5641 const char *id = RecordControls[i]->InstantId();
5642 if (id && strcmp(id, InstantId) == 0) {
5643 cTimer *Timer = RecordControls[i]->Timer();
5644 RecordControls[i]->Stop();
5645 if (Timer) {
5646 Timers->Del(Timer);
5647 isyslog("deleted timer %s", *Timer->ToDescr());
5648 }
5649 break;
5650 }
5651 }
5652 }
5653}
5654
5656{
5657 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5658 if (RecordControls[i]) {
5659 if (RecordControls[i]->Timer() == Timer) {
5661 ChangeState();
5662 break;
5663 }
5664 }
5665 }
5666}
5667
5669{
5670 Skins.Message(mtStatus, tr("Pausing live video..."));
5671 cReplayControl::SetRecording(NULL); // make sure the new cRecordControl will set cReplayControl::LastReplayed()
5672 if (Start(true)) {
5673 cReplayControl *rc = new cReplayControl(true);
5674 cControl::Launch(rc);
5676 Skins.Message(mtStatus, NULL);
5677 return true;
5678 }
5679 Skins.Message(mtStatus, NULL);
5680 return false;
5681}
5682
5683const char *cRecordControls::GetInstantId(const char *LastInstantId)
5684{
5685 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5686 if (RecordControls[i]) {
5687 if (!LastInstantId && RecordControls[i]->InstantId())
5688 return RecordControls[i]->InstantId();
5689 if (LastInstantId && LastInstantId == RecordControls[i]->InstantId())
5690 LastInstantId = NULL;
5691 }
5692 }
5693 return NULL;
5694}
5695
5697{
5698 if (FileName) {
5699 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5700 if (RecordControls[i] && strcmp(RecordControls[i]->FileName(), FileName) == 0)
5701 return RecordControls[i];
5702 }
5703 }
5704 return NULL;
5705}
5706
5708{
5709 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5710 if (RecordControls[i] && RecordControls[i]->Timer() == Timer)
5711 return RecordControls[i];
5712 }
5713 return NULL;
5714}
5715
5716bool cRecordControls::Process(cTimers *Timers, time_t t)
5717{
5718 bool Result = false;
5719 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5720 if (RecordControls[i]) {
5721 if (!RecordControls[i]->Process(t)) {
5723 ChangeState();
5724 Result = true;
5725 }
5726 }
5727 }
5728 return Result;
5729}
5730
5732{
5733 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5734 if (RecordControls[i]) {
5735 if (RecordControls[i]->Timer() && RecordControls[i]->Timer()->Channel() == Channel) {
5736 if (RecordControls[i]->Device()->ProvidesTransponder(Channel)) { // avoids retune on devices that don't really access the transponder
5737 isyslog("stopping recording due to modification of channel %d (%s)", Channel->Number(), Channel->Name());
5738 RecordControls[i]->Stop();
5739 // This will restart the recording, maybe even from a different
5740 // device in case conditional access has changed.
5741 ChangeState();
5742 }
5743 }
5744 }
5745 }
5746}
5747
5749{
5750 for (int i = 0; i < MAXRECORDCONTROLS; i++) {
5751 if (RecordControls[i])
5752 return true;
5753 }
5754 return false;
5755}
5756
5758{
5759 for (int i = 0; i < MAXRECORDCONTROLS; i++)
5761 ChangeState();
5762}
5763
5765{
5766 int NewState = state;
5767 bool Result = State != NewState;
5768 State = state;
5769 return Result;
5770}
5771
5772// --- cAdaptiveSkipper ------------------------------------------------------
5773
5775{
5776 initialValue = NULL;
5777 currentValue = 0;
5778 framesPerSecond = 0;
5779 lastKey = kNone;
5780}
5781
5782void cAdaptiveSkipper::Initialize(int *InitialValue, double FramesPerSecond)
5783{
5784 initialValue = InitialValue;
5785 framesPerSecond = FramesPerSecond;
5786 currentValue = 0;
5787}
5788
5790{
5791 if (!initialValue)
5792 return 0;
5793 if (timeout.TimedOut()) {
5794 currentValue = int(round(*initialValue * framesPerSecond));
5795 lastKey = Key;
5796 }
5797 else if (Key != lastKey) {
5798 currentValue /= 2;
5799 if (Setup.AdaptiveSkipAlternate)
5800 lastKey = Key; // only halve the value when the direction is changed
5801 else
5802 lastKey = kNone; // once the direction has changed, every further call halves the value
5803 }
5804 timeout.Set(Setup.AdaptiveSkipTimeout * 1000);
5805 return max(currentValue, 1);
5806}
5807
5808// --- cReplayControl --------------------------------------------------------
5809
5813
5815:cDvbPlayerControl(fileName, PauseLive)
5816{
5818 currentReplayControl = this;
5819 displayReplay = NULL;
5820 marksModified = false;
5821 visible = modeOnly = shown = displayFrames = false;
5822 lastErrors = 0;
5823 lastCurrent = lastTotal = -1;
5824 lastPlay = lastForward = false;
5825 lastSpeed = -2; // an invalid value
5826 timeoutShow = 0;
5827 timeSearchActive = false;
5828 cRecording Recording(fileName);
5829 cStatus::MsgReplaying(this, Recording.Name(), Recording.FileName(), true);
5830 marks.Load(fileName, Recording.FramesPerSecond(), Recording.IsPesRecording());
5831 SetMarks(&marks);
5832 adaptiveSkipper.Initialize(&Setup.AdaptiveSkipInitial, Recording.FramesPerSecond());
5833 SetTrackDescriptions(false);
5834 if (Setup.ProgressDisplayTime)
5835 ShowTimed(Setup.ProgressDisplayTime);
5836}
5837
5845
5847{
5848 if (timeshiftTimer) {
5850 Timers->SetExplicitModify();
5851 Timers->Del(timeshiftTimer);
5852 Timers->SetModified();
5853 isyslog("deleted timer %s", *timeshiftTimer->ToDescr());
5854 timeshiftTimer = NULL;
5855 }
5856}
5857
5859{
5860 Hide();
5861 cStatus::MsgReplaying(this, NULL, fileName, false);
5862 if (Setup.DelTimeshiftRec && *fileName) {
5864 if (rc && rc->InstantId()) {
5865 if (Active()) {
5866 if (Setup.DelTimeshiftRec == 2 || Interface->Confirm(tr("Delete timeshift recording?"))) {
5867 // At this point somewhere up the call stack there may be a lock on the Channels, so we can't
5868 // lock the Timers here and have to delete this timer later:
5869 timeshiftTimer = rc->Timer();
5870 rc->Stop(false); // don't execute user command
5872 bool Error = false;
5873 {
5875 Recordings->SetExplicitModify();
5876 if (cRecording *Recording = Recordings->GetByName(fileName)) {
5877 if (Recording->Delete()) {
5878 Recordings->DelByName(fileName);
5880 Recordings->SetModified();
5881 }
5882 else
5883 Error = true;
5884 }
5885 }
5886 if (Error)
5887 Skins.Message(mtError, tr("Error while deleting recording!"));
5888 return;
5889 }
5890 }
5891 }
5892 }
5894 cMenuRecordings::SetRecording(NULL); // make sure opening the Recordings menu navigates to the last replayed recording
5895}
5896
5898{
5899 cStateKey StateKey;
5900 marks.Lock(StateKey);
5901 while (cMark *m = marks.First())
5902 marks.Del(m);
5903 StateKey.Remove();
5905}
5906
5907void cReplayControl::SetRecording(const char *FileName)
5908{
5909 fileName = FileName;
5910}
5911
5913{
5914 return currentReplayControl ? *fileName : NULL;
5915}
5916
5918{
5920 if (!Recordings->GetByName(fileName))
5921 fileName = NULL;
5922 return fileName;
5923}
5924
5925void cReplayControl::ClearLastReplayed(const char *FileName)
5926{
5927 if (*fileName && FileName && strcmp(fileName, FileName) == 0)
5928 fileName = NULL;
5929}
5930
5932{
5933 if (modeOnly)
5934 Hide();
5935 if (!visible) {
5936 shown = ShowProgress(true);
5937 timeoutShow = (shown && Seconds > 0) ? time(NULL) + Seconds : 0;
5938 }
5939 else if (timeoutShow && Seconds > 0)
5940 timeoutShow = time(NULL) + Seconds;
5941}
5942
5944{
5945 ShowTimed();
5946}
5947
5949{
5950 if (visible) {
5951 delete displayReplay;
5952 displayReplay = NULL;
5953 SetNeedsFastResponse(false);
5954 visible = false;
5955 modeOnly = false;
5956 lastPlay = lastForward = false;
5957 lastSpeed = -2; // an invalid value
5958 timeSearchActive = false;
5959 timeoutShow = 0;
5960 }
5961 if (marksModified) {
5962 marks.Save();
5963 marksModified = false;
5964 }
5965}
5966
5968{
5969 if (visible || Setup.ShowReplayMode && !cOsd::IsOpen()) {
5970 bool Play, Forward;
5971 int Speed;
5972 if (GetReplayMode(Play, Forward, Speed) && (!visible || Play != lastPlay || Forward != lastForward || Speed != lastSpeed)) {
5973 bool NormalPlay = (Play && Speed == -1);
5974
5975 if (!visible) {
5976 if (NormalPlay)
5977 return; // no need to do indicate ">" unless there was a different mode displayed before
5978 visible = modeOnly = true;
5979 displayReplay = Skins.Current()->DisplayReplay(modeOnly);
5980 }
5981
5982 if (modeOnly && !timeoutShow && NormalPlay)
5983 timeoutShow = time(NULL) + MODETIMEOUT;
5984 displayReplay->SetMode(Play, Forward, Speed);
5985 lastPlay = Play;
5987 lastSpeed = Speed;
5988 }
5989 }
5990}
5991
5993{
5994 int Current, Total;
5995 if (!(Initial || updateTimer.TimedOut()))
5996 return visible;
5997 if (GetFrameNumber(Current, Total) && Total > 0) {
5998 if (!visible) {
5999 displayReplay = Skins.Current()->DisplayReplay(modeOnly);
6000 displayReplay->SetMarks(&marks);
6001 displayReplay->SetErrors(GetErrors());
6003 visible = true;
6004 }
6005 if (Initial) {
6006 if (*fileName) {
6008 if (const cRecording *Recording = Recordings->GetByName(fileName))
6009 displayReplay->SetRecording(Recording);
6010 }
6011 lastCurrent = lastTotal = -1;
6012 }
6013 const cErrors *Errors = GetErrors();
6014 int NumErrors = Errors ? Errors->Size() : 0;
6015 if (Current != lastCurrent || Total != lastTotal || NumErrors != lastErrors) {
6016 if (Setup.ShowRemainingTime || Total != lastTotal) {
6017 int Index = Total;
6018 if (Setup.ShowRemainingTime)
6019 Index = Current - Index;
6020 displayReplay->SetTotal(IndexToHMSF(Index, false, FramesPerSecond()));
6021 }
6022 displayReplay->SetProgress(Current, Total);
6023 displayReplay->SetCurrent(IndexToHMSF(Current, displayFrames, FramesPerSecond()));
6024 displayReplay->SetErrors(Errors);
6025 displayReplay->Flush();
6026 lastCurrent = Current;
6027 lastTotal = Total;
6028 lastErrors = NumErrors;
6029 }
6030 ShowMode();
6032 return true;
6033 }
6034 return false;
6035}
6036
6038{
6039 char buf[64];
6040 // TRANSLATORS: note the trailing blank!
6041 strcpy(buf, tr("Jump: "));
6042 int len = strlen(buf);
6043 char h10 = '0' + (timeSearchTime >> 24);
6044 char h1 = '0' + ((timeSearchTime & 0x00FF0000) >> 16);
6045 char m10 = '0' + ((timeSearchTime & 0x0000FF00) >> 8);
6046 char m1 = '0' + (timeSearchTime & 0x000000FF);
6047 char ch10 = timeSearchPos > 3 ? h10 : '-';
6048 char ch1 = timeSearchPos > 2 ? h1 : '-';
6049 char cm10 = timeSearchPos > 1 ? m10 : '-';
6050 char cm1 = timeSearchPos > 0 ? m1 : '-';
6051 sprintf(buf + len, "%c%c:%c%c", ch10, ch1, cm10, cm1);
6052 displayReplay->SetJump(buf);
6053}
6054
6056{
6057#define STAY_SECONDS_OFF_END 10
6058 int Seconds = (timeSearchTime >> 24) * 36000 + ((timeSearchTime & 0x00FF0000) >> 16) * 3600 + ((timeSearchTime & 0x0000FF00) >> 8) * 600 + (timeSearchTime & 0x000000FF) * 60;
6059 int Current = int(round(lastCurrent / FramesPerSecond()));
6060 int Total = int(round(lastTotal / FramesPerSecond()));
6061 switch (Key) {
6062 case k0 ... k9:
6063 if (timeSearchPos < 4) {
6064 timeSearchTime <<= 8;
6065 timeSearchTime |= Key - k0;
6066 timeSearchPos++;
6068 }
6069 break;
6070 case kFastRew:
6071 case kLeft:
6072 case kFastFwd:
6073 case kRight: {
6074 int dir = ((Key == kRight || Key == kFastFwd) ? 1 : -1);
6075 if (dir > 0)
6076 Seconds = min(Total - Current - STAY_SECONDS_OFF_END, Seconds);
6077 SkipSeconds(Seconds * dir);
6078 timeSearchActive = false;
6079 }
6080 break;
6081 case kPlayPause:
6082 case kPlay:
6083 case kUp:
6084 case kPause:
6085 case kDown:
6086 case kOk:
6087 if (timeSearchPos > 0) {
6088 Seconds = min(Total - STAY_SECONDS_OFF_END, Seconds);
6089 bool Still = Key == kDown || Key == kPause || Key == kOk;
6090 Goto(SecondsToFrames(Seconds, FramesPerSecond()), Still);
6091 }
6092 timeSearchActive = false;
6093 break;
6094 default:
6095 if (!(Key & k_Flags)) // ignore repeat/release keys
6096 timeSearchActive = false;
6097 break;
6098 }
6099
6100 if (!timeSearchActive) {
6101 if (timeSearchHide)
6102 Hide();
6103 else
6104 displayReplay->SetJump(NULL);
6105 ShowMode();
6106 }
6107}
6108
6110{
6112 timeSearchHide = false;
6113 if (modeOnly)
6114 Hide();
6115 if (!visible) {
6116 Show();
6117 if (visible)
6118 timeSearchHide = true;
6119 else
6120 return;
6121 }
6122 timeoutShow = 0;
6124 timeSearchActive = true;
6125}
6126
6128{
6129 int Current, Total;
6130 if (GetIndex(Current, Total, true)) {
6131 lastCurrent = -1; // triggers redisplay
6132 cStateKey StateKey;
6133 marks.Lock(StateKey);
6134 if (cMark *m = marks.Get(Current))
6135 marks.Del(m);
6136 else {
6137 marks.Add(Current);
6138 bool Play, Forward;
6139 int Speed;
6140 if (Setup.PauseOnMarkSet || GetReplayMode(Play, Forward, Speed) && !Play) {
6141 Goto(Current, true);
6142 displayFrames = true;
6143 }
6144 }
6145 StateKey.Remove();
6146 ShowTimed(2);
6147 marksModified = true;
6149 }
6150}
6151
6153{
6154 int Current, Total;
6155 if (GetIndex(Current, Total)) {
6156 if (marks.Count()) {
6157 if (cMark *m = Forward ? marks.GetNext(Current) : marks.GetPrev(Current)) {
6158 if (!Setup.PauseOnMarkJump) {
6159 bool Playing, Fwd;
6160 int Speed;
6161 if (GetReplayMode(Playing, Fwd, Speed) && Playing && Forward && m->Position() < Total - SecondsToFrames(3, FramesPerSecond())) {
6162 Goto(m->Position());
6163 return;
6164 }
6165 }
6166 Goto(m->Position(), true);
6167 displayFrames = true;
6168 return;
6169 }
6170 }
6171 // There are either no marks at all, or we already were at the first or last one,
6172 // so jump to the very beginning or end:
6173 Goto(Forward ? Total : 0, true);
6174 }
6175}
6176
6177void cReplayControl::MarkMove(int Frames, bool MarkRequired)
6178{
6179 int Current, Total;
6180 if (GetIndex(Current, Total)) {
6181 bool Play, Forward;
6182 int Speed;
6183 GetReplayMode(Play, Forward, Speed);
6184 cMark *m = marks.Get(Current);
6185 if (!Play && m) {
6186 displayFrames = true;
6187 cMark *m2;
6188 if (Frames > 0) {
6189 // Handle marks at the same offset:
6190 while ((m2 = marks.Next(m)) != NULL && m2->Position() == m->Position())
6191 m = m2;
6192 // Don't skip the next mark:
6193 if ((m2 = marks.Next(m)) != NULL)
6194 Frames = min(Frames, m2->Position() - m->Position() - 1);
6195 }
6196 else {
6197 // Handle marks at the same offset:
6198 while ((m2 = marks.Prev(m)) != NULL && m2->Position() == m->Position())
6199 m = m2;
6200 // Don't skip the next mark:
6201 if ((m2 = marks.Prev(m)) != NULL)
6202 Frames = -min(-Frames, m->Position() - m2->Position() - 1);
6203 }
6204 int p = SkipFrames(Frames);
6205 m->SetPosition(p);
6206 Goto(m->Position(), true);
6207 marksModified = true;
6209 }
6210 else if (!MarkRequired)
6211 Goto(SkipFrames(Frames), !Play);
6212 }
6213}
6214
6216{
6217 const cErrors *Errors = GetErrors();
6218 int NumErrors = Errors ? Errors->Size() : 0;
6219 if (NumErrors > 0) {
6220 int Current, Total;
6221 if (GetIndex(Current, Total)) {
6222 if (Forward) {
6223 int Offset = 0;
6224 for (int i = 0; i < NumErrors; i++) {
6225 int Position = Errors->At(i);
6226 if (Position > Current + Offset) {
6227 int NextIFrame = SkipFrames(Position - Current) + Offset; // this takes us to the I-frame at or right after Position
6228 if (NextIFrame > Position) {
6229 if (SkipFrames(Offset + 1) == NextIFrame) { // means Current is the I-frame right before Position
6230 Offset = NextIFrame - Current;
6231 continue;
6232 }
6233 }
6234 Goto(Position, true); // this takes us to the I-frame at or right before Position
6235 return;
6236 }
6237 }
6238 if (Current < Total)
6239 Goto(Total, true);
6240 }
6241 else {
6242 for (int i = NumErrors - 1; i >= 0; i--) {
6243 if (Errors->At(i) < Current) {
6244 int Position = Errors->At(i);
6245 Goto(Position, true); // this takes us to the I-frame at or right before Position
6246 return;
6247 }
6248 }
6249 if (Current > 0)
6250 Goto(0, true);
6251 }
6252 }
6253 }
6254}
6255
6257{
6258 if (*fileName) {
6259 Hide();
6260 if (!RecordingsHandler.GetUsage(fileName)) {
6261 if (!marks.Count())
6262 Skins.Message(mtError, tr("No editing marks defined!"));
6263 else if (!marks.GetNumSequences())
6264 Skins.Message(mtError, tr("No editing sequences defined!"));
6265 else if (access(cCutter::EditedFileName(fileName), F_OK) == 0 && !Interface->Confirm(tr("Edited version already exists - overwrite?")))
6266 ;
6268 Skins.Message(mtError, tr("Not enough free disk space to start editing process!"));
6269 else if (!RecordingsHandler.Add(ruCut, fileName))
6270 Skins.Message(mtError, tr("Can't start editing process!"));
6271 else
6272 Skins.Message(mtInfo, tr("Editing process started"));
6273 }
6274 else
6275 Skins.Message(mtError, tr("Editing process already active!"));
6276 ShowMode();
6277 }
6278}
6279
6281{
6282 int Current, Total;
6283 if (GetIndex(Current, Total)) {
6284 cMark *m = marks.Get(Current);
6285 if (!m)
6286 m = marks.GetNext(Current);
6287 if (m) {
6288 if ((m->Index() & 0x01) != 0 && !Setup.SkipEdited) // when skipping edited parts we also need to jump to end marks
6289 m = marks.Next(m);
6290 if (m)
6292 }
6293 }
6294}
6295
6297{
6299 if (const cRecording *Recording = Recordings->GetByName(cReplayControl::LastReplayed()))
6300 return new cMenuRecording(Recording, false);
6301 return NULL;
6302}
6303
6305{
6307 if (const cRecording *Recording = Recordings->GetByName(LastReplayed()))
6308 return Recording;
6309 return NULL;
6310}
6311
6313{
6314 if (!Active())
6315 return osEnd;
6316 if (Key == kNone && !marksModified)
6317 marks.Update();
6318 if (visible) {
6319 if (timeoutShow && time(NULL) > timeoutShow) {
6320 Hide();
6321 ShowMode();
6322 timeoutShow = 0;
6323 }
6324 else if (modeOnly)
6325 ShowMode();
6326 else
6328 }
6329 bool DisplayedFrames = displayFrames;
6330 displayFrames = false;
6331 if (timeSearchActive && Key != kNone) {
6332 TimeSearchProcess(Key);
6333 return osContinue;
6334 }
6335 if (Key == kPlayPause) {
6336 bool Play, Forward;
6337 int Speed;
6338 GetReplayMode(Play, Forward, Speed);
6339 if (Speed >= 0)
6340 Key = Play ? kPlay : kPause;
6341 else
6342 Key = Play ? kPause : kPlay;
6343 }
6344 bool DoShowMode = true;
6345 switch (int(Key)) {
6346 // Positioning:
6347 case kPlay:
6348 case kUp: Play(); break;
6349 case kPause:
6350 case kDown: Pause(); break;
6351 case kFastRew|k_Release:
6352 case kLeft|k_Release:
6353 if (Setup.MultiSpeedMode) break;
6354 case kFastRew:
6355 case kLeft: Backward(); break;
6356 case kFastFwd|k_Release:
6357 case kRight|k_Release:
6358 if (Setup.MultiSpeedMode) break;
6359 case kFastFwd:
6360 case kRight: Forward(); break;
6361 case kRed: TimeSearch(); break;
6362 case kGreen|k_Repeat:
6363 SkipSeconds(-Setup.SkipSecondsRepeat); break;
6364 case kGreen: SkipSeconds(-Setup.SkipSeconds); break;
6365 case kYellow|k_Repeat:
6366 SkipSeconds(Setup.SkipSecondsRepeat); break;
6367 case kYellow: SkipSeconds(Setup.SkipSeconds); break;
6368 case kStop:
6369 case kBlue: Stop();
6370 return osEnd;
6371 default: {
6372 DoShowMode = false;
6373 switch (int(Key)) {
6374 // Editing:
6375 case kMarkToggle: MarkToggle(); break;
6376 case kPrev|k_Repeat:
6377 case kPrev: if (Setup.AdaptiveSkipPrevNext) {
6378 MarkMove(-adaptiveSkipper.GetValue(RAWKEY(Key)), false);
6379 break;
6380 }
6381 // fall through...
6383 case kMarkJumpBack: MarkJump(false); break;
6384 case kNext|k_Repeat:
6385 case kNext: if (Setup.AdaptiveSkipPrevNext) {
6386 MarkMove(+adaptiveSkipper.GetValue(RAWKEY(Key)), false);
6387 break;
6388 }
6389 // fall through...
6391 case kMarkJumpForward: MarkJump(true); break;
6393 case kMarkMoveBack: MarkMove(-1, true); break;
6395 case kMarkMoveForward: MarkMove(+1, true); break;
6397 case kMarkSkipBack: MarkMove(-adaptiveSkipper.GetValue(RAWKEY(Key)), false); break;
6399 case kMarkSkipForward: MarkMove(+adaptiveSkipper.GetValue(RAWKEY(Key)), false); break;
6400 case kChanUp|k_Repeat:
6401 case kChanUp: ErrorJump(true); break;
6402 case kChanDn|k_Repeat:
6403 case kChanDn: ErrorJump(false); break;
6404 case kEditCut: EditCut(); break;
6405 case kEditTest: EditTest(); break;
6406 default: {
6407 displayFrames = DisplayedFrames;
6408 switch (Key) {
6409 // Menu control:
6410 case kOk: if (visible && !modeOnly) {
6411 Hide();
6412 DoShowMode = true;
6413 }
6414 else
6415 Show();
6416 break;
6417 case kBack: Stop();
6418 return osRecordings;
6419 default: return osUnknown;
6420 }
6421 }
6422 }
6423 }
6424 }
6425 if (DoShowMode)
6426 ShowMode();
6427 return osContinue;
6428}
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:5774
eKeys lastKey
Definition menu.h:285
void Initialize(int *InitialValue, double FramesPerSecond)
Definition menu.c:5782
int * initialValue
Definition menu.h:282
int currentValue
Definition menu.h:283
int GetValue(eKeys Key)
Definition menu.c:5789
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:4889
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:4882
void Refresh(void)
Definition menu.c:4916
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4939
const cPositioner * positioner
Definition menu.h:131
static cDisplayChannel * currentDisplayChannel
Definition menu.h:135
void DisplayInfo(void)
Definition menu.c:4897
cDisplayChannel(int Number, bool Switched)
Definition menu.c:4835
const cChannel * NextAvailableChannel(const cChannel *Channel, int Direction)
Definition menu.c:4922
virtual void Show(void) override
Definition menu.c:5357
cSkinDisplayTracks * displayTracks
Definition menu.h:182
cDisplaySubtitleTracks(void)
Definition menu.c:5322
static void Process(eKeys Key)
Definition menu.c:5375
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:5364
virtual ~cDisplaySubtitleTracks() override
Definition menu.c:5348
eOSState ProcessKey(eKeys Key)
Definition menu.c:5381
char * descriptions[ttMaxTrackTypes+1]
Definition menu.h:167
static cDisplayTracks * Create(void)
Definition menu.c:5246
cDisplayTracks(void)
Definition menu.c:5202
cTimeMs timeout
Definition menu.h:165
eOSState ProcessKey(eKeys Key)
Definition menu.c:5263
static cDisplayTracks * currentDisplayTracks
Definition menu.h:169
virtual void Show(void) override
Definition menu.c:5236
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:5257
virtual ~cDisplayTracks() override
Definition menu.c:5227
eTrackType types[ttMaxTrackTypes]
Definition menu.h:166
static cDisplayVolume * Create(void)
Definition menu.c:5156
cSkinDisplayVolume * displayVolume
Definition menu.h:150
virtual void Show(void) override
Definition menu.c:5151
eOSState ProcessKey(eKeys Key)
Definition menu.c:5169
cTimeMs timeout
Definition menu.h:151
static void Process(eKeys Key)
Definition menu.c:5163
cDisplayVolume(void)
Definition menu.c:5136
static cDisplayVolume * currentDisplayVolume
Definition menu.h:152
virtual ~cDisplayVolume() override
Definition menu.c:5145
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:1010
bool GetIndex(int &Current, int &Total, bool SnapToIFrame=false)
Definition dvbplayer.c:1072
const cErrors * GetErrors(void)
Definition dvbplayer.c:1065
void SkipSeconds(int Seconds)
Definition dvbplayer.c:1052
cDvbPlayerControl(const char *FileName, bool PauseLive=false)
Definition dvbplayer.c:998
bool GetReplayMode(bool &Play, bool &Forward, int &Speed)
Definition dvbplayer.c:1090
void Pause(void)
Definition dvbplayer.c:1028
int SkipFrames(int Frames)
Definition dvbplayer.c:1058
void Goto(int Index, bool Still=false)
Definition dvbplayer.c:1095
void Stop(void)
Definition dvbplayer.c:1021
void Forward(void)
Definition dvbplayer.c:1040
bool Active(void)
Definition dvbplayer.c:1016
bool GetFrameNumber(int &Current, int &Total)
Definition dvbplayer.c:1081
void Play(void)
Definition dvbplayer.c:1034
void Backward(void)
Definition dvbplayer.c:1046
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:2265
virtual void Move(int From, int To)
Definition tools.c:2225
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:2274
void SetModified(void)
Unconditionally marks this list as modified.
Definition tools.c:2279
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:2177
void Sort(void)
Definition tools.c:2301
cListObject(const cListObject &ListObject)
Definition tools.h:534
cListObject * Prev(void) const
Definition tools.h:546
int Index(void) const
Definition tools.c:2097
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:2328
void Set(void)
Definition menu.c:2390
eOSState Select(void)
Definition menu.c:2445
char * input
Definition menu.c:2331
void AddMultiLineItem(const char *s)
Definition menu.c:2432
void GenerateTitle(const char *s=NULL)
Definition menu.c:2372
void QueryCam(void)
Definition menu.c:2377
virtual ~cMenuCam() override
Definition menu.c:2360
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2469
cMenuCam(cCamSlot *CamSlot)
Definition menu.c:2345
time_t lastCamExchange
Definition menu.c:2333
cCiEnquiry * ciEnquiry
Definition menu.c:2330
cCiMenu * ciMenu
Definition menu.c:2329
int offset
Definition menu.c:2332
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:2258
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2305
cList< cNestedItem > * commands
Definition menu.h:59
virtual ~cMenuCommands() override
Definition menu.c:2230
bool confirm
Definition menu.h:63
cMenuCommands(const char *Title, cList< cNestedItem > *Commands, const char *Parameters=NULL)
Definition menu.c:2213
cString title
Definition menu.h:61
cString command
Definition menu.h:62
bool Parse(const char *s)
Definition menu.c:2235
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:1541
const cEvent * event
Definition menu.h:99
virtual void Display(void) override
Definition menu.c:1532
cMenuEvent(const cTimers *Timers, const cChannels *Channels, const cEvent *Event, bool CanSwitch=false, bool Buttons=false)
Definition menu.c:1515
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:4588
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:4683
bool Update(bool Force=false)
Definition menu.c:4625
cMenuMain(eOSState State=osUnknown, bool OpenSubMenus=false)
Definition menu.c:4541
static cOsdObject * pluginOsdObject
Definition menu.h:113
static cOsdObject * PluginOsdObject(void)
Definition menu.c:4581
eOSState ApplyChanges(void)
Definition menu.c:2611
int pathIsInUse
Definition menu.c:2536
cString oldFolder
Definition menu.c:2532
eOSState Folder(void)
Definition menu.c:2606
cMenuEditStrItem * folderItem
Definition menu.c:2535
eOSState SetFolder(void)
Definition menu.c:2596
cString path
Definition menu.c:2531
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2646
cMenuPathEdit(const char *Path)
Definition menu.c:2545
char name[NAME_MAX]
Definition menu.c:2534
char folder[PATH_MAX]
Definition menu.c:2533
cMenuPluginItem(const char *Name, int Index)
Definition menu.c:4528
int PluginIndex(void)
Definition menu.c:4525
int pluginIndex
Definition menu.c:4522
bool RefreshRecording(void)
Definition menu.c:2772
cMenuEditStrItem * nameItem
Definition menu.c:2677
const char * actionCancel
Definition menu.c:2681
cString originalFileName
Definition menu.c:2670
eOSState ApplyChanges(void)
Definition menu.c:2885
const char * doCopy
Definition menu.c:2683
eOSState Action(void)
Definition menu.c:2802
cMenuEditStrItem * folderItem
Definition menu.c:2676
eOSState SetFolder(void)
Definition menu.c:2787
void Set(void)
Definition menu.c:2723
char name[NAME_MAX]
Definition menu.c:2673
const char * buttonAction
Definition menu.c:2679
cStateKey recordingsStateKey
Definition menu.c:2671
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2931
const char * doCut
Definition menu.c:2682
eOSState RemoveName(void)
Definition menu.c:2839
void SetHelpKeys(void)
Definition menu.c:2746
eOSState Delete(void)
Definition menu.c:2857
const char * buttonDelete
Definition menu.c:2680
cMenuRecordingEdit(const cRecording *Recording)
Definition menu.c:2700
const char * buttonFolder
Definition menu.c:2678
const cRecording * recording
Definition menu.c:2669
eOSState Folder(void)
Definition menu.c:2797
char folder[PATH_MAX]
Definition menu.c:2672
const cRecording * recording
Definition menu.c:3055
int Level(void) const
Definition menu.c:3064
const cRecording * Recording(void) const
Definition menu.c:3065
const char * Name(void) const
Definition menu.c:3063
void IncrementCounter(bool New)
Definition menu.c:3092
bool IsDirectory(void) const
Definition menu.c:3066
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:3100
void SetRecording(const cRecording *Recording)
Definition menu.c:3067
cMenuRecordingItem(const cRecording *Recording, int Level)
Definition menu.c:3071
const cRecording * recording
Definition menu.c:2958
bool withButtons
Definition menu.c:2961
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3009
bool RefreshRecording(void)
Definition menu.c:2982
cString originalFileName
Definition menu.c:2959
cStateKey recordingsStateKey
Definition menu.c:2960
virtual void Display(void) override
Definition menu.c:2997
cMenuRecording(const cRecording *Recording, bool WithButtons=false)
Definition menu.c:2969
static cString path
Definition menu.h:217
void Set(bool Refresh=false)
Definition menu.c:3163
bool Open(bool OpenSubMenus=false)
Definition menu.c:3238
eOSState Sort(void)
Definition menu.c:3412
static void SetRecording(const char *FileName)
Definition menu.c:3222
eOSState Info(void)
Definition menu.c:3384
eOSState Play(void)
Definition menu.c:3254
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:3268
cStateKey recordingsStateKey
Definition menu.h:214
cMenuRecordings(const char *Base=NULL, int Level=0, bool OpenSubMenus=false, const cRecordingFilter *Filter=NULL)
Definition menu.c:3112
eOSState Commands(eKeys Key=kNone)
Definition menu.c:3397
cString DirectoryName(void)
Definition menu.c:3227
void SetHelpKeys(void)
Definition menu.c:3142
eOSState Delete(void)
Definition menu.c:3334
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3424
static void SetSortMode(eScheduleSortMode SortMode)
Definition menu.c:1587
const cChannel * channel
Definition menu.c:1581
cMenuScheduleItem(const cTimers *Timers, const cEvent *Event, const cChannel *Channel=NULL, bool WithDate=false)
Definition menu.c:1597
const cTimer * timer
Definition menu.c:1582
const cEvent * event
Definition menu.c:1580
static void IncSortMode(void)
Definition menu.c:1588
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:1608
bool Update(const cTimers *Timers, bool Force=false)
Definition menu.c:1621
static eScheduleSortMode sortMode
Definition menu.c:1578
static eScheduleSortMode SortMode(void)
Definition menu.c:1589
eTimerMatch timerMatch
Definition menu.c:1584
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable) override
Definition menu.c:1651
virtual ~cMenuSchedule() override
Definition menu.c:1910
bool PrepareScheduleAllAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:2010
bool canSwitch
Definition menu.c:1877
bool PrepareScheduleAllThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1951
void SetHelpKeys(void)
Definition menu.c:2042
int helpKeys
Definition menu.c:1878
cStateKey timersStateKey
Definition menu.c:1873
bool next
Definition menu.c:1876
void Set(const cTimers *Timers, const cChannels *Channels, const cChannel *Channel=NULL, bool Force=false)
Definition menu.c:1915
bool Update(void)
Definition menu.c:2029
eOSState Record(void)
Definition menu.c:2076
cMenuSchedule(void)
Definition menu.c:1895
cStateKey schedulesStateKey
Definition menu.c:1874
eOSState Number(void)
Definition menu.c:2067
int scheduleState
Definition menu.c:1875
eOSState Switch(void)
Definition menu.c:2114
bool PrepareScheduleThisThis(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1970
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:2131
bool PrepareScheduleThisAll(const cTimers *Timers, const cSchedules *Schedules, const cEvent *Event, const cChannel *Channel)
Definition menu.c:1990
cMenuSetupBase(void)
Definition menu.c:3500
cSetup data
Definition menu.c:3494
virtual void Store(void) override
Definition menu.c:3505
cMenuSetupCAMItem(cCamSlot *CamSlot)
Definition menu.c:4020
bool Changed(void)
Definition menu.c:4027
cCamSlot * camSlot
Definition menu.c:4013
cCamSlot * CamSlot(void)
Definition menu.c:4016
void SetHelpKeys(void)
Definition menu.c:4091
cMenuSetupCAM(void)
Definition menu.c:4076
eOSState Menu(void)
Definition menu.c:4110
eOSState Reset(void)
Definition menu.c:4174
eOSState Activate(void)
Definition menu.c:4137
const char * activationHelp
Definition menu.c:4066
int currentChannel
Definition menu.c:4065
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4186
const char * updateChannelsTexts[6]
Definition menu.c:3788
int numAudioLanguages
Definition menu.c:3783
cMenuSetupDVB(void)
Definition menu.c:3796
int originalNumSubtitleLanguages
Definition menu.c:3784
void Setup(void)
Definition menu.c:3826
int numSubtitleLanguages
Definition menu.c:3785
const char * standardComplianceTexts[3]
Definition menu.c:3790
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3856
int originalNumAudioLanguages
Definition menu.c:3782
const char * videoDisplayFormatTexts[3]
Definition menu.c:3787
const char * displaySubtitlesTexts[3]
Definition menu.c:3789
int originalNumLanguages
Definition menu.c:3688
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3731
int numLanguages
Definition menu.c:3689
void Setup(void)
Definition menu.c:3707
cMenuSetupEPG(void)
Definition menu.c:3696
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3990
cSatCableNumbers satCableNumbers
Definition menu.c:3935
cMenuSetupLNB(void)
Definition menu.c:3942
void Setup(void)
Definition menu.c:3951
void Set(void)
Definition menu.c:4317
cMenuSetupMisc(void)
Definition menu.c:4304
const char * svdrpPeeringModeTexts[3]
Definition menu.c:4295
cStringList svdrpServerNames
Definition menu.c:4297
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4348
const char * showChannelNamesWithSourceTexts[3]
Definition menu.c:4296
virtual void Set(void)
Definition menu.c:3563
cStringList fontSmlNames
Definition menu.c:3528
cStringList fontOsdNames
Definition menu.c:3528
const char * recSortDirTexts[2]
Definition menu.c:3518
const char * useSmallFontTexts[3]
Definition menu.c:3516
int numSkins
Definition menu.c:3521
cStringList fontFixNames
Definition menu.c:3528
const char * recSortModeTexts[2]
Definition menu.c:3517
int fontOsdIndex
Definition menu.c:3529
const char * keyColorTexts[4]
Definition menu.c:3519
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:3619
int skinIndex
Definition menu.c:3523
int originalSkinIndex
Definition menu.c:3522
int originalThemeIndex
Definition menu.c:3526
int fontFixIndex
Definition menu.c:3529
const char ** skinDescriptions
Definition menu.c:3524
cThemes themes
Definition menu.c:3525
int themeIndex
Definition menu.c:3527
virtual ~cMenuSetupOSD() override
Definition menu.c:3558
int fontSmlIndex
Definition menu.c:3529
cMenuSetupOSD(void)
Definition menu.c:3537
int osdLanguageIndex
Definition menu.c:3520
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:4388
int PluginIndex(void)
Definition menu.c:4385
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4416
cMenuSetupPlugins(void)
Definition menu.c:4402
const char * pauseKeyHandlingTexts[3]
Definition menu.c:4214
const char * recordKeyHandlingTexts[3]
Definition menu.c:4213
cMenuSetupRecord(void)
Definition menu.c:4220
const char * delTimeshiftRecTexts[3]
Definition menu.c:4215
virtual void Store(void) override
Definition menu.c:4282
cMenuSetupReplay(void)
Definition menu.c:4261
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:4492
virtual void Set(void)
Definition menu.c:4463
cMenuSetup(void)
Definition menu.c:4456
eOSState Restart(void)
Definition menu.c:4483
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:1420
cMenuTimers(void)
Definition menu.c:1323
void Set(void)
Definition menu.c:1337
void SetHelpKeys(void)
Definition menu.c:1368
eOSState Info(void)
Definition menu.c:1462
eOSState Edit(void)
Definition menu.c:1413
cTimer * GetTimer(void)
Definition menu.c:1362
cStateKey timersStateKey
Definition menu.c:1306
bool showAllTimers
Definition menu.c:1308
eOSState Delete(void)
Definition menu.c:1430
int helpKeys
Definition menu.c:1307
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1475
eOSState OnOff(void)
Definition menu.c:1383
virtual ~cMenuTimers() override
Definition menu.c:1333
void SetHelpKeys(const cChannels *Channels)
Definition menu.c:1717
static const cEvent * scheduleEvent
Definition menu.c:1671
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:1808
static const cEvent * ScheduleEvent(void)
Definition menu.c:1745
eOSState Record(void)
Definition menu.c:1769
cMenuWhatsOn(const cTimers *Timers, const cChannels *Channels, const cSchedules *Schedules, bool Now, int CurrentChannelNr)
Definition menu.c:1685
static void SetCurrentChannel(int ChannelNr)
Definition menu.c:1677
cStateKey timersStateKey
Definition menu.c:1667
static int CurrentChannel(void)
Definition menu.c:1676
eOSState Switch(void)
Definition menu.c:1752
bool canSwitch
Definition menu.c:1665
bool Update(void)
Definition menu.c:1704
static int currentChannel
Definition menu.c:1670
bool now
Definition menu.c:1664
int helpKeys
Definition menu.c:1666
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:5504
const char * InstantId(void)
Definition menu.h:252
void Stop(bool ExecuteUserCommand=true)
Definition menu.c:5536
cDevice * device
Definition menu.h:239
cTimer * timer
Definition menu.h:240
bool GetEvent(void)
Definition menu.c:5512
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:5422
cDevice * Device(void)
Definition menu.h:250
const cEvent * event
Definition menu.h:242
bool Process(time_t t)
Definition menu.c:5558
cString instantId
Definition menu.h:243
static bool StateChanged(int &State)
Definition menu.c:5764
static const char * GetInstantId(const char *LastInstantId)
Definition menu.c:5683
static void ChannelDataModified(const cChannel *Channel)
Definition menu.c:5731
static bool Process(cTimers *Timers, time_t t)
Definition menu.c:5716
static bool PauseLiveVideo(void)
Definition menu.c:5668
static void Shutdown(void)
Definition menu.c:5757
static bool Start(cTimers *Timers, cTimer *Timer, bool Pause=false)
Definition menu.c:5573
static cRecordControl * RecordControls[]
Definition menu.h:5570
static bool Active(void)
Definition menu.c:5748
static void Stop(const char *InstantId)
Definition menu.c:5635
static cRecordControl * GetRecordControl(const char *FileName)
Definition menu.c:5696
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:5907
static const char * LastReplayed(void)
Definition menu.c:5917
void MarkToggle(void)
Definition menu.c:6127
virtual void Show(void) override
Definition menu.c:5943
static cString fileName
Definition menu.h:314
void TimeSearchDisplay(void)
Definition menu.c:6037
static void ClearLastReplayed(const char *FileName)
Definition menu.c:5925
int lastTotal
Definition menu.h:302
virtual eOSState ProcessKey(eKeys Key) override
Definition menu.c:6312
void MarkMove(int Frames, bool MarkRequired)
Definition menu.c:6177
static cReplayControl * currentReplayControl
Definition menu.h:313
bool timeSearchHide
Definition menu.h:307
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:6304
void TimeSearchProcess(eKeys Key)
Definition menu.c:6055
void MarkJump(bool Forward)
Definition menu.c:6152
cMarks marks
Definition menu.h:298
void EditCut(void)
Definition menu.c:6256
int timeSearchTime
Definition menu.h:308
cSkinDisplayReplay * displayReplay
Definition menu.h:296
void Stop(void)
Definition menu.c:5858
void ShowTimed(int Seconds=0)
Definition menu.c:5931
static cTimer * timeshiftTimer
Definition menu.h:295
bool lastForward
Definition menu.h:303
virtual cOsdObject * GetInfo(void) override
Returns an OSD object that displays information about the currently played programme.
Definition menu.c:6296
bool displayFrames
Definition menu.h:300
bool shown
Definition menu.h:300
virtual void Hide(void) override
Definition menu.c:5948
time_t timeoutShow
Definition menu.h:305
void EditTest(void)
Definition menu.c:6280
bool timeSearchActive
Definition menu.h:307
bool ShowProgress(bool Initial)
Definition menu.c:5992
static void DelTimeshiftTimer(void)
Definition menu.c:5846
bool marksModified
Definition menu.h:299
int lastSpeed
Definition menu.h:304
cAdaptiveSkipper adaptiveSkipper
Definition menu.h:297
bool lastPlay
Definition menu.h:303
int timeSearchPos
Definition menu.h:308
virtual void ClearEditingMarks(void) override
Clears any editing marks this player might be showing.
Definition menu.c:5897
int lastErrors
Definition menu.h:301
virtual ~cReplayControl() override
Definition menu.c:5838
void ShowMode(void)
Definition menu.c:5967
void ErrorJump(bool Forward)
Definition menu.c:6215
cTimeMs updateTimer
Definition menu.h:306
void TimeSearch(void)
Definition menu.c:6109
bool visible
Definition menu.h:300
bool modeOnly
Definition menu.h:300
static const char * NowReplaying(void)
Definition menu.c:5912
cReplayControl(bool PauseLive=false)
Definition menu.c:5814
int lastCurrent
Definition menu.h:302
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:1632
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:1148
cString PrintFirstDay(void) const
Definition timers.c:436
void SetPending(bool Pending)
Definition timers.c:1060
time_t FirstDay(void) const
Definition timers.h:79
bool Recording(void) const
Definition timers.h:66
void SetRemote(const char *Remote)
Definition timers.c:1108
const cEvent * Event(void) const
Definition timers.h:87
void Skip(void)
Definition timers.c:1140
const cChannel * Channel(void) const
Definition timers.h:70
bool Pending(void) const
Definition timers.h:67
cString ToDescr(void) const
Definition timers.c:333
bool SetEventFromSchedule(const cSchedules *Schedules)
Definition timers.c:981
int Priority(void) const
Definition timers.h:75
bool Matches(void) const
Definition timers.h:109
bool HasFlags(uint Flags) const
Definition timers.c:1135
const char * Remote(void) const
Definition timers.h:81
int Id(void) const
Definition timers.h:65
cString ToText(bool UseChannelID=false) const
Definition timers.c:323
void Add(cTimer *Timer, cTimer *After=NULL)
Definition timers.c:1305
static cTimers * GetTimersWrite(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of timers for write access.
Definition timers.c:1300
void Del(cTimer *Timer, bool DeleteObject=true)
Definition timers.c:1319
static const cTimers * GetTimersRead(cStateKey &StateKey, int TimeoutMs=0)
Gets the list of timers for read access.
Definition timers.c:1295
const cTimer * GetMatch(time_t t) const
Definition timers.c:1221
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:1619
static const char * TimerFileMacrosForPattern[]
Definition menu.c:998
#define NEWTIMERLIMIT
Definition menu.c:38
#define osUserRecRenamed
Definition menu.c:2524
#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:2527
cOsdObject * CamControl(void)
Definition menu.c:2508
bool CamMenuActive(void)
Definition menu.c:2517
#define STAY_SECONDS_OFF_END
#define osUserRecMoved
Definition menu.c:2525
#define MUTETIMEOUT
Definition menu.c:5132
void SetTrackDescriptions(int LiveChannel)
Definition menu.c:4789
#define MODETIMEOUT
Definition menu.c:37
#define TRACKTIMEOUT
Definition menu.c:5198
static bool CamMenuIsOpen
Definition menu.c:2324
#define CHANNELNUMBERTIMEOUT
Definition menu.c:352
static const char * TimerFileMacros[]
Definition menu.c:1008
#define INSTANT_REC_EPG_LOOKAHEAD
Definition menu.c:5510
#define FOLDERDELIMCHARSUBST
Definition menu.c:823
#define CHNAMWIDTH
Definition menu.c:54
#define CHNUMWIDTH
Definition menu.c:53
#define osUserRecRemoved
Definition menu.c:2526
#define MAXWAITFORCAMMENU
Definition menu.c:45
#define VOLUMETIMEOUT
Definition menu.c:5131
#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:3282
static bool HandleRemoteModifications(cTimer *NewTimer, cTimer *OldTimer=NULL)
Definition menu.c:1138
#define MAXWAIT4EPGINFO
Definition menu.c:36
#define STOP_RECORDING
Definition menu.c:4537
void SetTrackDescriptions(int LiveChannel)
Definition menu.c:4789
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:3517
cString IndexToHMSF(int Index, bool WithFrame, double FramesPerSecond)
Definition recording.c:3412
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:3469
int SecondsToFrames(int Seconds, double FramesPerSecond)
Definition recording.c:3439
eRecordingsSortMode RecordingsSortMode
Definition recording.c:3462
bool EnoughFreeDiskSpaceForEdit(const char *FileName)
Definition recording.c:3549
char * ExchangeChars(char *s, bool ToFileSystem)
Definition recording.c:697
void IncRecordingsSortMode(const char *Directory)
Definition recording.c:3488
cDoneRecordings DoneRecordingsPattern
Definition recording.c:3319
cRecordingsHandler RecordingsHandler
Definition recording.c:2123
void SetRecordingTimerId(const char *Directory, const char *TimerId)
Definition recording.c:3499
@ 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:2907
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:2916
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:2925
void StartSVDRPHandler(void)
Definition svdrp.c:2891
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:1509
#define LOCK_TIMERS_READ
Definition timers.h:275
#define LOCK_TIMERS_WRITE
Definition timers.h:276
@ 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