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