vdr  2.4.0
osdbase.c
Go to the documentation of this file.
1 /*
2  * osdbase.c: Basic interface to the On Screen Display
3  *
4  * See the main source file 'vdr.c' for copyright information and
5  * how to reach the author.
6  *
7  * $Id: osdbase.c 4.5 2018/03/24 11:47:45 kls Exp $
8  */
9 
10 #include "osdbase.h"
11 #include <string.h>
12 #include "device.h"
13 #include "i18n.h"
14 #include "menuitems.h"
15 #include "remote.h"
16 #include "status.h"
17 
18 // --- cOsdItem --------------------------------------------------------------
19 
21 {
22  text = NULL;
23  state = State;
24  selectable = true;
25  fresh = true;
26 }
27 
28 cOsdItem::cOsdItem(const char *Text, eOSState State, bool Selectable)
29 {
30  text = NULL;
31  state = State;
33  fresh = true;
34  SetText(Text);
35 }
36 
38 {
39  free(text);
40 }
41 
42 void cOsdItem::SetText(const char *Text, bool Copy)
43 {
44  free(text);
45  text = Copy ? strdup(Text ? Text : "") : (char *)Text; // text assumes ownership!
46 }
47 
48 void cOsdItem::SetSelectable(bool Selectable)
49 {
51 }
52 
53 void cOsdItem::SetFresh(bool Fresh)
54 {
55  fresh = Fresh;
56 }
57 
58 void cOsdItem::SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
59 {
60  DisplayMenu->SetItem(Text(), Index, Current, Selectable);
61 }
62 
64 {
65  return Key == kOk ? state : osUnknown;
66 }
67 
68 // --- cOsdObject ------------------------------------------------------------
69 
70 void cOsdObject::Show(void)
71 {
72  if (isMenu)
73  ((cOsdMenu *)this)->Display();
74 }
75 
76 // --- cOsdMenu --------------------------------------------------------------
77 
80 int cOsdMenu::osdState = 0;
81 
82 cOsdMenu::cOsdMenu(const char *Title, int c0, int c1, int c2, int c3, int c4)
83 {
84  isMenu = true;
85  digit = 0;
86  key_nr = -1;
87  hasHotkeys = false;
88  displayMenuItems = 0;
89  title = NULL;
93  SetTitle(Title);
94  SetCols(c0, c1, c2, c3, c4);
95  first = 0;
96  lastOffset = -1;
97  current = marked = -1;
98  subMenu = NULL;
99  helpRed = helpGreen = helpYellow = helpBlue = NULL;
100  helpDisplayed = false;
101  status = NULL;
102  if (!displayMenuCount++) {
103  cOsdProvider::OsdSizeChanged(osdState); // to get the current state
104  SetDisplayMenu();
105  }
106 }
107 
109 {
110  free(title);
111  delete subMenu;
112  free(status);
113  displayMenu->Clear();
115  if (!--displayMenuCount)
117 }
118 
120 {
121  menuCategory = MenuCategory;
122 }
123 
125 {
126  menuSortMode = MenuSortMode;
127 }
128 
130 {
131  if (displayMenu) {
132  displayMenu->Clear();
133  delete displayMenu;
134  }
136 }
137 
138 const char *cOsdMenu::hk(const char *s)
139 {
140  static cString buffer;
141  if (s && hasHotkeys) {
142  if (digit == 0 && '1' <= *s && *s <= '9' && *(s + 1) == ' ')
143  digit = -1; // prevents automatic hotkeys - input already has them
144  if (digit >= 0) {
145  digit++;
146  buffer = cString::sprintf(" %2d%s %s", digit, (digit > 9) ? "" : " ", s);
147  s = buffer;
148  }
149  }
150  return s;
151 }
152 
153 void cOsdMenu::SetCols(int c0, int c1, int c2, int c3, int c4)
154 {
155  cols[0] = c0;
156  cols[1] = c1;
157  cols[2] = c2;
158  cols[3] = c3;
159  cols[4] = c4;
160 }
161 
162 void cOsdMenu::SetHasHotkeys(bool HasHotkeys)
163 {
164  hasHotkeys = HasHotkeys;
165  digit = 0;
166 }
167 
168 void cOsdMenu::SetStatus(const char *s)
169 {
170  free(status);
171  status = s ? strdup(s) : NULL;
173 }
174 
175 void cOsdMenu::SetTitle(const char *Title)
176 {
177  free(title);
178  title = strdup(Title);
179 }
180 
181 void cOsdMenu::DisplayHelp(bool Force)
182 {
183  if (!helpDisplayed || Force) {
186  helpDisplayed = true;
187  }
188 }
189 
190 void cOsdMenu::SetHelp(const char *Red, const char *Green, const char *Yellow, const char *Blue)
191 {
192  // strings are NOT copied - must be constants!!!
193  helpRed = Red;
194  helpGreen = Green;
195  helpYellow = Yellow;
196  helpBlue = Blue;
197  DisplayHelp(true);
198 }
199 
200 void cOsdMenu::Del(int Index)
201 {
202  cList<cOsdItem>::Del(Get(Index));
203  int count = Count();
204  while (current < count && !SelectableItem(current))
205  current++;
206  if (current == count) {
207  while (current > 0 && !SelectableItem(current))
208  current--;
209  }
210  if (Index == first && first > 0)
211  first--;
212 }
213 
214 void cOsdMenu::Add(cOsdItem *Item, bool Current, cOsdItem *After)
215 {
216  cList<cOsdItem>::Add(Item, After);
217  if (Current)
218  current = Item->Index();
219 }
220 
221 void cOsdMenu::Ins(cOsdItem *Item, bool Current, cOsdItem *Before)
222 {
223  cList<cOsdItem>::Ins(Item, Before);
224  if (Current)
225  current = Item->Index();
226 }
227 
229 {
230  if (subMenu) {
231  subMenu->Display();
232  return;
233  }
235  SetDisplayMenu();
237  displayMenu->Clear();
244  displayMenu->SetTabs(cols[0], cols[1], cols[2], cols[3], cols[4]);//XXX
247  DisplayHelp(true);
248  int count = Count();
249  if (count > 0) {
250  int ni = 0;
251  for (cOsdItem *item = First(); item; item = Next(item)) {
252  cStatus::MsgOsdItem(item->Text(), ni++);
253  if (current < 0 && item->Selectable())
254  current = item->Index();
255  }
256  if (current < 0)
257  current = 0; // just for safety - there HAS to be a current item!
258  first = max(0, min(first, max(0, count - displayMenuItems))); // in case the menu size has changed
259  if (current - first >= displayMenuItems || current < first) {
261  if (first + displayMenuItems > count)
263  if (first < 0)
264  first = 0;
265  }
266  int i = first;
267  int n = 0;
268  for (cOsdItem *item = Get(first); item; item = Next(item)) {
269  bool CurrentSelectable = (i == current) && item->Selectable();
270  item->SetMenuItem(displayMenu, i - first, CurrentSelectable, item->Selectable());
271  if (CurrentSelectable)
272  cStatus::MsgOsdCurrentItem(item->Text());
273  if (++n == displayMenuItems)
274  break;
275  i++;
276  }
277  }
279  if (!isempty(status))
281 }
282 
284 {
285  current = Item ? Item->Index() : -1;
286  if (current >= 0 && lastOffset >= 0)
287  first = max(0, current - lastOffset);
288  lastOffset = -1;
289 }
290 
292 {
293  cOsdItem *item = Get(current);
294  if (item)
295  item->Set();
296 }
297 
298 void cOsdMenu::DisplayCurrent(bool Current)
299 {
300  cOsdItem *item = Get(current);
301  if (item) {
302  item->SetMenuItem(displayMenu, current - first, Current && item->Selectable(), item->Selectable());
303  if (Current && item->Selectable())
305  if (!Current)
306  item->SetFresh(true); // leaving the current item resets 'fresh'
307  if (cMenuEditItem *MenuEditItem = dynamic_cast<cMenuEditItem *>(item)) {
308  if (!MenuEditItem->DisplayHelp(Current))
309  DisplayHelp();
310  else
311  helpDisplayed = false;
312  }
313  }
314 }
315 
317 {
318  if (Item) {
319  int Index = Item->Index();
320  int Offset = Index - first;
321  if (Offset >= 0 && Offset < first + displayMenuItems) {
322  bool Current = Index == current;
323  Item->SetMenuItem(displayMenu, Offset, Current && Item->Selectable(), Item->Selectable());
324  if (Current && Item->Selectable())
326  }
327  }
328 }
329 
330 void cOsdMenu::Clear(void)
331 {
332  if (marked >= 0)
333  SetStatus(NULL);
334  if (current >= 0)
335  lastOffset = (current > first) ? current - first : 0;
336  first = 0;
337  current = marked = -1;
339 }
340 
342 {
343  cOsdItem *item = Get(idx);
344  return item && item->Selectable();
345 }
346 
348 {
349  int tmpCurrent = current;
350  int lastOnScreen = first + displayMenuItems - 1;
351  int last = Count() - 1;
352  if (last < 0)
353  return;
354  while (--tmpCurrent != current) {
355  if (tmpCurrent < 0) {
356  if (first > 0) {
357  // make non-selectable items at the beginning visible:
358  first = 0;
359  Display();
360  return;
361  }
362  if (Setup.MenuScrollWrap)
363  tmpCurrent = last + 1;
364  else
365  return;
366  }
367  else if (SelectableItem(tmpCurrent))
368  break;
369  }
370  if (first <= tmpCurrent && tmpCurrent <= lastOnScreen)
371  DisplayCurrent(false);
372  current = tmpCurrent;
373  if (current < first) {
375  Display();
376  }
377  else if (current > lastOnScreen) {
378  first = max(0, current - displayMenuItems + 1);
379  Display();
380  }
381  else
382  DisplayCurrent(true);
383 }
384 
386 {
387  int tmpCurrent = current;
388  int lastOnScreen = first + displayMenuItems - 1;
389  int last = Count() - 1;
390  if (last < 0)
391  return;
392  while (++tmpCurrent != current) {
393  if (tmpCurrent > last) {
394  if (first < last - displayMenuItems) {
395  // make non-selectable items at the end visible:
396  first = last - displayMenuItems + 1;
397  Display();
398  return;
399  }
400  if (Setup.MenuScrollWrap)
401  tmpCurrent = -1;
402  else
403  return;
404  }
405  else if (SelectableItem(tmpCurrent))
406  break;
407  }
408  if (first <= tmpCurrent && tmpCurrent <= lastOnScreen)
409  DisplayCurrent(false);
410  current = tmpCurrent;
411  if (current > lastOnScreen) {
413  if (first + displayMenuItems > last)
414  first = max(0, last - displayMenuItems + 1);
415  Display();
416  }
417  else if (current < first) {
418  first = current;
419  Display();
420  }
421  else
422  DisplayCurrent(true);
423 }
424 
426 {
427  int oldCurrent = current;
428  int oldFirst = first;
431  int last = Count() - 1;
432  if (current < 0)
433  current = 0;
434  if (first < 0)
435  first = 0;
436  int tmpCurrent = current;
437  while (!SelectableItem(tmpCurrent) && --tmpCurrent >= 0)
438  ;
439  if (tmpCurrent < 0) {
440  tmpCurrent = current;
441  while (++tmpCurrent <= last && !SelectableItem(tmpCurrent))
442  ;
443  }
444  current = tmpCurrent <= last ? tmpCurrent : -1;
445  if (current >= 0) {
446  if (current < first)
447  first = current;
448  else if (current - first >= displayMenuItems)
450  }
451  if (current != oldCurrent || first != oldFirst) {
452  Display();
453  DisplayCurrent(true);
454  }
455  else if (Setup.MenuScrollWrap)
456  CursorUp();
457 }
458 
460 {
461  int oldCurrent = current;
462  int oldFirst = first;
465  int last = Count() - 1;
466  if (current > last)
467  current = last;
468  if (first + displayMenuItems > last)
469  first = max(0, last - displayMenuItems + 1);
470  int tmpCurrent = current;
471  while (!SelectableItem(tmpCurrent) && ++tmpCurrent <= last)
472  ;
473  if (tmpCurrent > last) {
474  tmpCurrent = current;
475  while (--tmpCurrent >= 0 && !SelectableItem(tmpCurrent))
476  ;
477  }
478  current = tmpCurrent > 0 ? tmpCurrent : -1;
479  if (current >= 0) {
480  if (current < first)
481  first = current;
482  else if (current - first >= displayMenuItems)
484  }
485  if (current != oldCurrent || first != oldFirst) {
486  Display();
487  DisplayCurrent(true);
488  }
489  else if (Setup.MenuScrollWrap)
490  CursorDown();
491 }
492 
493 void cOsdMenu::Mark(void)
494 {
495  if (Count() && marked < 0) {
496  marked = current;
497  SetStatus(tr("Up/Dn for new location - OK to move"));
498  }
499 }
500 
501 #define MENUKEY_TIMEOUT 1500
502 
504 {
505  bool match = false;
506  bool highlight = false;
507  int item_nr;
508  int i;
509 
510  if (Key == kNone) {
511  if (lastActivity.TimedOut())
512  Key = kOk;
513  else
514  return osContinue;
515  }
516  else
518  for (cOsdItem *item = Last(); item; item = Prev(item)) {
519  const char *s = item->Text();
520  i = 0;
521  item_nr = 0;
522  if (s && (s = skipspace(s))[0] != '\0' && '0' <= s[i] && s[i] <= '9') {
523  do {
524  item_nr = item_nr * 10 + (s[i] - '0');
525  }
526  while ( !((s[++i] == '\t')||(s[i] == ' ')) && (s[i] != '\0') && ('0' <= s[i]) && (s[i] <= '9'));
527  if ((Key == kOk) && (item_nr == key_nr)) {
528  current = item->Index();
529  RefreshCurrent();
530  Display();
531  cRemote::Put(kOk, true);
532  key_nr = -1;
533  break;
534  }
535  else if (Key != kOk) {
536  if (!highlight && (item_nr == (Key - k0))) {
537  highlight = true;
538  current = item->Index();
539  }
540  if (!match && (key_nr == -1) && ((item_nr / 10) == (Key - k0))) {
541  match = true;
542  key_nr = (Key - k0);
543  }
544  else if (((key_nr == -1) && (item_nr == (Key - k0))) || (!match && (key_nr >= 0) && (item_nr == (10 * key_nr + Key - k0)))) {
545  current = item->Index();
546  cRemote::Put(kOk, true);
547  key_nr = -1;
548  break;
549  }
550  }
551  }
552  }
553  if ((!match) && (Key != kNone))
554  key_nr = -1;
555  return osContinue;
556 }
557 
559 {
560  delete subMenu;
561  subMenu = SubMenu;
562  subMenu->Display();
563  return osContinue; // convenience return value
564 }
565 
567 {
568  delete subMenu;
569  subMenu = NULL;
570  if (ReDisplay) {
571  RefreshCurrent();
572  Display();
573  }
574  return osContinue; // convenience return value
575 }
576 
578 {
579  if (subMenu) {
580  eOSState state = subMenu->ProcessKey(Key);
581  if (state == osBack)
582  return CloseSubMenu();
583  return state;
584  }
585 
586  cOsdItem *item = Get(current);
587  if (marked < 0 && item) {
588  eOSState state = item->ProcessKey(Key);
589  if (state != osUnknown) {
590  DisplayCurrent(true);
591  return state;
592  }
593  }
594  switch (int(Key)) {
595  case kNone:
596  case k0...k9: return hasHotkeys ? HotKey(Key) : osUnknown;
597  case kUp|k_Repeat:
598  case kUp: if (menuOrientation == moHorizontal) PageUp(); else CursorUp(); break;
599  case kDown|k_Repeat:
600  case kDown: if (menuOrientation == moHorizontal) PageDown(); else CursorDown(); break;
601  case kLeft|k_Repeat:
602  case kLeft: if (menuOrientation == moHorizontal) CursorUp(); else PageUp(); break;
603  case kRight|k_Repeat:
604  case kRight: if (menuOrientation == moHorizontal) CursorDown(); else PageDown(); break;
605  case kBack: return osBack;
606  case kOk: if (marked >= 0) {
607  SetStatus(NULL);
608  if (marked != current)
609  Move(marked, current);
610  marked = -1;
611  break;
612  }
613  // else run into default
614  default: if (marked < 0)
615  return osUnknown;
616  }
617  return osContinue;
618 }
virtual ~cOsdMenu()
Definition: osdbase.c:108
void SetStatus(const char *s)
Definition: osdbase.c:168
void DisplayItem(cOsdItem *Item)
Definition: osdbase.c:316
static void MsgOsdCurrentItem(const char *Text)
Definition: status.c:116
virtual void Del(int Index)
Definition: osdbase.c:200
const cOsdItem * Get(int Index) const
Returns the list element at the given Index, or NULL if no such element exists.
Definition: tools.h:603
bool isempty(const char *s)
Definition: tools.c:331
const char * helpGreen
Definition: osdbase.h:99
int lastOffset
Definition: osdbase.h:94
void Set(int Ms=0)
Definition: tools.c:774
const char * helpBlue
Definition: osdbase.h:99
int key_nr
Definition: osdbase.h:104
Definition: keys.h:23
void Add(cOsdItem *Item, bool Current=false, cOsdItem *After=NULL)
Definition: osdbase.c:214
cOsdItem(eOSState State=osUnknown)
Definition: osdbase.c:20
void Add(cListObject *Object, cListObject *After=NULL)
Definition: tools.c:2152
eMenuCategory menuCategory
Definition: osdbase.h:95
bool hasHotkeys
Definition: osdbase.h:103
cOsdMenu * subMenu
Definition: osdbase.h:98
static cString sprintf(const char *fmt,...) __attribute__((format(printf
Definition: tools.c:1127
Definition: keys.h:17
virtual void SetMessage(eMessageType Type, const char *Text)=0
Sets a one line message Text, with the given Type.
Definition: keys.h:61
int displayMenuItems
Definition: osdbase.h:90
cOsdMenu * SubMenu(void)
Definition: osdbase.h:129
virtual void Clear(void)
Definition: osdbase.c:330
virtual void SetScrollbar(int Total, int Offset)
Sets the Total number of items in the currently displayed list, and the Offset of the first item that...
Definition: skins.c:133
int Index(void) const
Definition: tools.c:2072
eOSState HotKey(eKeys Key)
Definition: osdbase.c:503
void RefreshCurrent(void)
Definition: osdbase.c:291
const char * Title(void)
Definition: osdbase.h:114
T max(T a, T b)
Definition: tools.h:60
bool selectable
Definition: osdbase.h:52
void PageUp(void)
Definition: osdbase.c:425
virtual cSkinDisplayMenu * DisplayMenu(void)=0
Creates and returns a new object for displaying a menu.
bool fresh
Definition: osdbase.h:54
void SetFresh(bool Fresh)
Definition: osdbase.c:53
void SetDisplayMenu(void)
Definition: osdbase.c:129
eMenuCategory MenuCategory(void) const
Returns the menu category, set by a previous call to SetMenuCategory().
Definition: skins.h:183
T min(T a, T b)
Definition: tools.h:59
static bool OsdSizeChanged(int &State)
Checks if the OSD size has changed and a currently displayed OSD needs to be redrawn.
Definition: osd.c:2064
#define MENUKEY_TIMEOUT
Definition: osdbase.c:501
static void MsgOsdHelpKeys(const char *Red, const char *Green, const char *Yellow, const char *Blue)
Definition: status.c:104
virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable)=0
Sets the item at the given Index to Text.
cTimeMs lastActivity
Definition: osdbase.h:105
virtual void Clear(void)
Definition: tools.c:2229
Definition: keys.h:55
int marked
Definition: osdbase.h:93
static cSkinDisplayMenu * displayMenu
Definition: osdbase.h:87
char * status
Definition: osdbase.h:101
eOSState
Definition: osdbase.h:18
virtual void SetTabs(int Tab1, int Tab2=0, int Tab3=0, int Tab4=0, int Tab5=0)
Sets the tab columns to the given values, which are the number of characters in each column.
Definition: skins.c:95
void SetHasHotkeys(bool HasHotkeys=true)
Definition: osdbase.c:162
virtual eOSState ProcessKey(eKeys Key)
Definition: osdbase.c:577
void PageDown(void)
Definition: osdbase.c:459
void Ins(cOsdItem *Item, bool Current=false, cOsdItem *Before=NULL)
Definition: osdbase.c:221
void SetCols(int c0, int c1=0, int c2=0, int c3=0, int c4=0)
Definition: osdbase.c:153
virtual void SetMenuSortMode(eMenuSortMode MenuSortMode)
Sets the mode by which the items in this menu are sorted.
Definition: skins.h:196
void SetMenuCategory(eMenuCategory MenuCategory)
Definition: osdbase.c:119
static void MsgOsdTitle(const char *Title)
Definition: status.c:92
void CursorDown(void)
Definition: osdbase.c:385
char * title
Definition: osdbase.h:91
cOsdMenu(const char *Title, int c0=0, int c1=0, int c2=0, int c3=0, int c4=0)
Definition: osdbase.c:82
void SetText(const char *Text, bool Copy=true)
Definition: osdbase.c:42
void SetSelectable(bool Selectable)
Definition: osdbase.c:48
Definition: keys.h:18
const char * helpYellow
Definition: osdbase.h:99
void Ins(cListObject *Object, cListObject *Before=NULL)
Definition: tools.c:2168
virtual ~cOsdItem()
Definition: osdbase.c:37
virtual void Display(void)
Definition: osdbase.c:228
cSetup Setup
Definition: config.c:372
bool Put(uint64_t Code, bool Repeat=false, bool Release=false)
Definition: remote.c:124
Definition: keys.h:20
void Mark(void)
Definition: osdbase.c:493
int digit
Definition: osdbase.h:102
const cOsdItem * Last(void) const
Returns the last element in this list, or NULL if the list is empty.
Definition: tools.h:608
static int displayMenuCount
Definition: osdbase.h:88
int current
Definition: osdbase.h:93
eMenuSortMode menuSortMode
Definition: osdbase.h:96
const cOsdItem * Prev(const cOsdItem *Object) const
Definition: tools.h:610
Definition: skins.h:37
virtual eOSState ProcessKey(eKeys Key)
Definition: osdbase.c:63
virtual void Show(void)
Definition: osdbase.c:70
const cOsdItem * First(void) const
Returns the first element in this list, or NULL if the list is empty.
Definition: tools.h:606
void DisplayHelp(bool Force=false)
Definition: osdbase.c:181
int first
Definition: osdbase.h:93
Definition: keys.h:21
void SetCurrent(cOsdItem *Item)
Definition: osdbase.c:283
void DisplayCurrent(bool Current)
Definition: osdbase.c:298
void SetMenuSortMode(eMenuSortMode MenuSortMode)
Definition: osdbase.c:124
eOSState CloseSubMenu(bool ReDisplay=true)
Definition: osdbase.c:566
void Del(cListObject *Object, bool DeleteObject=true)
Definition: tools.c:2184
eMenuCategory
Definition: skins.h:104
static void MsgOsdClear(void)
Definition: status.c:86
bool isMenu
Definition: osdbase.h:72
virtual void SetMenuCategory(eMenuCategory MenuCategory)
Sets the current menu category.
Definition: skins.c:90
const char * hk(const char *s)
Definition: osdbase.c:138
bool Selectable(void) const
Definition: osdbase.h:59
#define tr(s)
Definition: i18n.h:85
virtual void Move(int From, int To)
Definition: tools.c:2200
void DELETENULL(T *&p)
Definition: tools.h:49
char * skipspace(const char *s)
Definition: tools.h:209
void SetHelp(const char *Red, const char *Green=NULL, const char *Yellow=NULL, const char *Blue=NULL)
Definition: osdbase.c:190
bool SelectableItem(int idx)
Definition: osdbase.c:341
static int osdState
Definition: osdbase.h:89
int count
Definition: tools.h:530
virtual int MaxItems(void)=0
Returns the maximum number of items the menu can display.
char * text
Definition: osdbase.h:50
virtual void SetTitle(const char *Title)=0
Sets the title of this menu to Title.
void CursorUp(void)
Definition: osdbase.c:347
eMenuOrientation menuOrientation
Definition: osdbase.h:97
Definition: keys.h:28
int MenuScrollWrap
Definition: config.h:266
virtual void Set(void)
Definition: osdbase.h:64
bool helpDisplayed
Definition: osdbase.h:100
int MenuScrollPage
Definition: config.h:265
Definition: osdbase.h:33
eOSState state
Definition: osdbase.h:51
virtual void Clear(void)=0
Clears the entire central area of the menu.
const char * helpRed
Definition: osdbase.h:99
void SetTitle(const char *Title)
Definition: osdbase.c:175
cSkin * Current(void)
Returns a pointer to the current skin.
Definition: skins.h:468
eOSState AddSubMenu(cOsdMenu *SubMenu)
Definition: osdbase.c:558
int Current(void) const
Definition: osdbase.h:140
static void MsgOsdItem(const char *Text, int Index)
Definition: status.c:110
virtual void SetMenuItem(cSkinDisplayMenu *DisplayMenu, int Index, bool Current, bool Selectable)
Definition: osdbase.c:58
int Count(void) const
Definition: tools.h:590
int cols[cSkinDisplayMenu::MaxTabs]
Definition: osdbase.h:92
eKeys
Definition: keys.h:16
virtual void SetButtons(const char *Red, const char *Green=NULL, const char *Yellow=NULL, const char *Blue=NULL)=0
Sets the color buttons to the given strings.
virtual eMenuOrientation MenuOrientation(void)
Asks the skin for the orientation of the displayed menu.
Definition: skins.h:200
Definition: tools.h:176
const char * Text(void) const
Definition: osdbase.h:63
eMenuSortMode
Definition: skins.h:137
Definition: keys.h:22
cSkins Skins
Definition: skins.c:219
bool TimedOut(void) const
Definition: tools.c:779
const cOsdItem * Next(const cOsdItem *Object) const
< Returns the element immediately before Object in this list, or NULL if Object is the first element ...
Definition: tools.h:613