Implemented 'skins' and 'themes'

1 files changed, 291 insertions, 376 deletions

diff --git a/osdbase.c b/osdbase.c
index 71794068..08aef965 100644
--- a/osdbase.c
+++ b/osdbase.c
@@ -4,495 +4,410 @@
  * See the main source file 'vdr.c' for copyright information and
  * how to reach the author.
  *
- * $Id: osdbase.c 1.12 2004/01/31 10:31:13 kls Exp $
+ * $Id: osdbase.c 1.13 2004/05/01 10:51:43 kls Exp $
  */
 
 #include "osdbase.h"
-#include <signal.h>
-#include <stdlib.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/unistd.h>
-#include "tools.h"
+#include <string.h>
+#include "device.h"
+#include "i18n.h"
+#include "remote.h"
+#include "status.h"
 
-// --- cPalette --------------------------------------------------------------
+// --- cOsdItem --------------------------------------------------------------
 
-cPalette::cPalette(int Bpp)
+cOsdItem::cOsdItem(eOSState State)
 {
-  maxColors = 1 << Bpp;
-  numColors = 0;
-  full = false;
+  text = NULL;
+  offset = -1;
+  state = State;
+  selectable = true;
+  fresh = true;
 }
 
-void cPalette::SetColor(int Index, eDvbColor Color)
+cOsdItem::cOsdItem(const char *Text, eOSState State)
 {
-  if (Index < maxColors) {
-     if (numColors < Index)
-        numColors = Index + 1;
-     used[Index] = true;
-     color[Index] = Color;
-     fetched[Index] = false;
-     }
+  text = NULL;
+  offset = -1;
+  state = State;
+  selectable = true;
+  fresh = true;
+  SetText(Text);
 }
 
-int cPalette::Index(eDvbColor Color)
+cOsdItem::~cOsdItem()
 {
-#if __BYTE_ORDER == __BIG_ENDIAN
-  Color = eDvbColor(((Color & 0xFF) << 24) | ((Color & 0xFF00) << 8) | ((Color & 0xFF0000) >> 8) | ((Color & 0xFF000000) >> 24));
-#endif
-  for (int i = 0; i < numColors; i++) {
-      if (color[i] == Color) {
-         used[i] = true;
-         return i;
-         }
-      }
-  if (!full) {
-     if (numColors < maxColors) {
-        color[numColors++] = Color;
-        used[numColors - 1] = true;
-        fetched[numColors - 1] = false;
-        return numColors - 1;
-        }
-     for (int i = maxColors; --i >= 0; ) {
-         if (!used[i]) {
-            color[i] = Color;
-            used[i] = true;
-            fetched[i] = false;
-            return i;
-            }
-         }
-     esyslog("ERROR: too many different colors used in palette");
-     full = true;
-     }
-  return 0;
+  free(text);
 }
 
-void cPalette::Reset(void)
+void cOsdItem::SetText(const char *Text, bool Copy)
 {
-  for (int i = 0; i < numColors; i++)
-      used[i] = fetched[i] = false;
-  full = false;
+  free(text);
+  text = Copy ? strdup(Text) : (char *)Text; // text assumes ownership!
 }
 
-const eDvbColor *cPalette::NewColors(int &FirstColor, int &LastColor)
+void cOsdItem::SetSelectable(bool Selectable)
 {
-  for (FirstColor = 0; FirstColor < numColors; FirstColor++) {
-      if (!fetched[FirstColor]) {
-         for (LastColor = FirstColor; LastColor < numColors && !fetched[LastColor]; LastColor++)
-             fetched[LastColor] = true;
-         LastColor--; // the loop ended one past the last one!
-         return &color[FirstColor];
-         }
-      }
-  return NULL;
+  selectable = Selectable;
 }
 
-const eDvbColor *cPalette::AllColors(int &NumColors)
+void cOsdItem::SetFresh(bool Fresh)
 {
-  NumColors = numColors;
-  return numColors ? color : NULL;
+  fresh = Fresh;
 }
 
-void cPalette::Take(const cPalette &Palette, tIndexes *Indexes)
+eOSState cOsdItem::ProcessKey(eKeys Key)
 {
-  for (int i = 0; i < Palette.numColors; i++) {
-      if (Palette.used[i]) {
-         int n = Index(Palette.color[i]);
-         if (Indexes)
-            (*Indexes)[i] = n;
-         }
-      }
+  return Key == kOk ? state : osUnknown;
 }
 
-// --- cBitmap ---------------------------------------------------------------
+// --- cOsdMenu --------------------------------------------------------------
 
-cBitmap::cBitmap(int Width, int Height, int Bpp, bool ClearWithBackground)
-:cPalette(Bpp)
-{
-  width = Width;
-  height = Height;
-  clearWithBackground = ClearWithBackground;
-  bitmap = NULL;
-  fontType = fontOsd;
-  font = NULL;
-  if (width > 0 && height > 0) {
-     bitmap = MALLOC(u_char, width * height);
-     if (bitmap) {
-        Clean();
-        memset(bitmap, 0x00, width * height);
-        SetFont(fontOsd);
-        }
-     else
-        esyslog("ERROR: can't allocate bitmap!");
-     }
-  else
-     esyslog("ERROR: illegal bitmap parameters (%d, %d)!", width, height);
-}
+cSkinDisplayMenu *cOsdMenu::displayMenu = NULL;
+int cOsdMenu::displayMenuCount = 0;
+int cOsdMenu::displayMenuItems = 0;//XXX dynamic???
 
-cBitmap::~cBitmap()
+cOsdMenu::cOsdMenu(const char *Title, int c0, int c1, int c2, int c3, int c4)
 {
-  free(bitmap);
-}
-
-eDvbFont cBitmap::SetFont(eDvbFont Font)
-{
-  eDvbFont oldFont = fontType;
-  if (fontType != Font || !font) {
-     font = cFont::GetFont(Font);
-     fontType = Font;
+  isMenu = true;
+  digit = 0;
+  hasHotkeys = false;
+  title = NULL;
+  SetTitle(Title);
+  cols[0] = c0;
+  cols[1] = c1;
+  cols[2] = c2;
+  cols[3] = c3;
+  cols[4] = c4;
+  first = 0;
+  current = marked = -1;
+  subMenu = NULL;
+  helpRed = helpGreen = helpYellow = helpBlue = NULL;
+  status = NULL;
+  if (!displayMenuCount++) {
+     displayMenu = Skins.Current()->DisplayMenu();
+     displayMenuItems = displayMenu->MaxItems();
      }
-  return oldFont;
 }
 
-bool cBitmap::Dirty(int &x1, int &y1, int &x2, int &y2)
+cOsdMenu::~cOsdMenu()
 {
-  if (dirtyX2 >= 0) {
-     //XXX Workaround: apparently the bitmap sent to the driver always has to be a multiple
-     //XXX of 8 bits wide, and (dx * dy) also has to be a multiple of 8.
-     //TODO Fix driver (should be able to handle any size bitmaps!)
-     while ((dirtyX1 > 0 || dirtyX2 < width - 1) && ((dirtyX2 - dirtyX1) & 7) != 7) {
-           if (dirtyX2 < width - 1)
-              dirtyX2++;
-           else if (dirtyX1 > 0)
-              dirtyX1--;
-           }
-     //XXX "... / 2" <==> Bpp???
-     while ((dirtyY1 > 0 || dirtyY2 < height - 1) && (((dirtyX2 - dirtyX1 + 1) * (dirtyY2 - dirtyY1 + 1) / 2) & 7) != 0) {
-           if (dirtyY2 < height - 1)
-              dirtyY2++;
-           else if (dirtyY1 > 0)
-              dirtyY1--;
-           }
-     while ((dirtyX1 > 0 || dirtyX2 < width - 1) && (((dirtyX2 - dirtyX1 + 1) * (dirtyY2 - dirtyY1 + 1) / 2) & 7) != 0) {
-           if (dirtyX2 < width - 1)
-              dirtyX2++;
-           else if (dirtyX1 > 0)
-              dirtyX1--;
-           }
-     x1 = dirtyX1;
-     y1 = dirtyY1;
-     x2 = dirtyX2;
-     y2 = dirtyY2;
-     return true;
-     }
-  return false;
-}
-
-void cBitmap::Clean(void)
-{
-  dirtyX1 = width;
-  dirtyY1 = height;
-  dirtyX2 = -1;
-  dirtyY2 = -1;
+  free(title);
+  delete subMenu;
+  free(status);
+  displayMenu->Clear();
+  cStatus::MsgOsdClear();
+  if (!--displayMenuCount)
+     DELETENULL(displayMenu);
 }
 
-void cBitmap::SetIndex(int x, int y, u_char Index)
+const char *cOsdMenu::hk(const char *s)
 {
-  if (bitmap) {
-     if (0 <= x && x < width && 0 <= y && y < height) {
-        if (bitmap[width * y + x] != Index) {
-           bitmap[width * y + x] = Index;
-           if (dirtyX1 > x)  dirtyX1 = x;
-           if (dirtyY1 > y)  dirtyY1 = y;
-           if (dirtyX2 < x)  dirtyX2 = x;
-           if (dirtyY2 < y)  dirtyY2 = y;
-           }
+  static char buffer[64];
+  if (s && hasHotkeys) {
+     if (digit == 0 && '1' <= *s && *s <= '9' && *(s + 1) == ' ')
+        digit = -1; // prevents automatic hotkeys - input already has them
+     if (digit >= 0) {
+        digit++;
+        snprintf(buffer, sizeof(buffer), " %c %s", (digit < 10) ? '0' + digit : ' ' , s);
+        s = buffer;
         }
      }
+  return s;
 }
 
-void cBitmap::SetPixel(int x, int y, eDvbColor Color)
+void cOsdMenu::SetHasHotkeys(void)
 {
-  SetIndex(x, y, Index(Color));
+  hasHotkeys = true;
+  digit = 0;
 }
 
-void cBitmap::SetBitmap(int x, int y, const cBitmap &Bitmap)
+void cOsdMenu::SetStatus(const char *s)
 {
-  if (bitmap && Bitmap.bitmap) {
-     tIndexes Indexes;
-     Take(Bitmap, &Indexes);
-     for (int ix = 0; ix < Bitmap.width; ix++) {
-         for (int iy = 0; iy < Bitmap.height; iy++)
-             SetIndex(x + ix, y + iy, Indexes[int(Bitmap.bitmap[Bitmap.width * iy + ix])]);
-         }
-     }
+  free(status);
+  status = s ? strdup(s) : NULL;
+  displayMenu->SetMessage(mtStatus, s);
 }
 
-int cBitmap::Width(unsigned char c)
+void cOsdMenu::SetTitle(const char *Title)
 {
-  return font ? font->Width(c) : -1;
+  free(title);
+  title = strdup(Title);
 }
 
-int cBitmap::Width(const char *s)
+void cOsdMenu::SetHelp(const char *Red, const char *Green, const char *Yellow, const char *Blue)
 {
-  return font ? font->Width(s) : -1;
+  // strings are NOT copied - must be constants!!!
+  helpRed    = Red;
+  helpGreen  = Green;
+  helpYellow = Yellow;
+  helpBlue   = Blue;
+  displayMenu->SetButtons(helpRed, helpGreen, helpYellow, helpBlue);
+  cStatus::MsgOsdHelpKeys(helpRed, helpGreen, helpYellow, helpBlue);
 }
 
-void cBitmap::Text(int x, int y, const char *s, eDvbColor ColorFg, eDvbColor ColorBg)
+void cOsdMenu::Del(int Index)
 {
-  if (bitmap) {
-     u_char fg = Index(ColorFg);
-     u_char bg = Index(ColorBg);
-     int h = font->Height(s);
-     while (s && *s) {
-           const cFont::tCharData *CharData = font->CharData(*s++);
-           if (int(x + CharData->width) > width)
-              break;
-           for (int row = 0; row < h; row++) {
-               cFont::tPixelData PixelData = CharData->lines[row];
-               for (int col = CharData->width; col-- > 0; ) {
-                   SetIndex(x + col, y + row, (PixelData & 1) ? fg : bg);
-                   PixelData >>= 1;
-                   }
-               }
-           x += CharData->width;
-           }
-     }
+  cList<cOsdItem>::Del(Get(Index));
+  if (current == Count())
+     current--;
+  if (Index == first && first > 0)
+     first--;
 }
 
-void cBitmap::Fill(int x1, int y1, int x2, int y2, eDvbColor Color)
-{
-  if (bitmap) {
-     u_char c = Index(Color);
-     for (int y = y1; y <= y2; y++)
-         for (int x = x1; x <= x2; x++)
-             SetIndex(x, y, c);
-     }
-}
-
-void cBitmap::Clear(void)
-{
-  Reset();
-  if (clearWithBackground)
-     Fill(0, 0, width - 1, height - 1, clrBackground);
-}
-
-const u_char *cBitmap::Data(int x, int y)
-{
-  return &bitmap[y * width + x];
-}
-
-// --- cWindow ---------------------------------------------------------------
-
-cWindow::cWindow(int Handle, int x, int y, int w, int h, int Bpp, bool ClearWithBackground, bool Tiled)
-:cBitmap(w, h, Bpp, ClearWithBackground)
+void cOsdMenu::Add(cOsdItem *Item, bool Current, cOsdItem *After)
 {
-  handle = Handle;
-  x0 = x;
-  y0 = y;
-  bpp = Bpp;
-  tiled = Tiled;
-  shown = false;
+  cList<cOsdItem>::Add(Item, After);
+  if (Current)
+     current = Item->Index();
 }
 
-bool cWindow::Contains(int x, int y)
+void cOsdMenu::Ins(cOsdItem *Item, bool Current, cOsdItem *Before)
 {
-  x -= x0;
-  y -= y0;
-  return x >= 0 && y >= 0 && x < width && y < height;
+  cList<cOsdItem>::Ins(Item, Before);
+  if (Current)
+     current = Item->Index();
 }
 
-void cWindow::Relocate(int x, int y)
+void cOsdMenu::Display(void)
 {
-  x0 = x;
-  y0 = y;
+  if (subMenu) {
+     subMenu->Display();
+     return;
+     }
+  displayMenu->Clear();
+  cStatus::MsgOsdClear();
+  displayMenu->SetTabs(cols[0], cols[1], cols[2], cols[3], cols[4]);//XXX
+  displayMenu->SetTitle(title);
+  cStatus::MsgOsdTitle(title);
+  displayMenu->SetButtons(helpRed, helpGreen, helpYellow, helpBlue);
+  cStatus::MsgOsdHelpKeys(helpRed, helpGreen, helpYellow, helpBlue);
+  int count = Count();
+  if (count > 0) {
+     int ni = 0;
+     for (cOsdItem *item = First(); item; item = Next(item))
+         cStatus::MsgOsdItem(item->Text(), ni++);
+     if (current < 0)
+        current = 0; // just for safety - there HAS to be a current item!
+     if (current - first >= displayMenuItems || current < first) {
+        first = current - displayMenuItems / 2;
+        if (first + displayMenuItems > count)
+           first = count - displayMenuItems;
+        if (first < 0)
+           first = 0;
+        }
+     int i = first;
+     int n = 0;
+     for (cOsdItem *item = Get(first); item; item = Next(item)) {
+         displayMenu->SetItem(item->Text(), i - first, i == current, item->Selectable());
+         if (i == current)
+            cStatus::MsgOsdCurrentItem(item->Text());
+         if (++n == displayMenuItems)
+            break;
+         i++;
+         }
+     }
+  if (!isempty(status))
+     displayMenu->SetMessage(mtStatus, status);
 }
 
-void cWindow::Fill(int x1, int y1, int x2, int y2, eDvbColor Color)
+void cOsdMenu::SetCurrent(cOsdItem *Item)
 {
-  if (tiled) {
-     x1 -= x0;
-     y1 -= y0;
-     x2 -= x0;
-     y2 -= y0;
-     }
-  cBitmap::Fill(x1, y1, x2, y2, Color);
+  current = Item ? Item->Index() : -1;
 }
 
-void cWindow::SetBitmap(int x, int y, const cBitmap &Bitmap)
+void cOsdMenu::RefreshCurrent(void)
 {
-  if (tiled) {
-     x -= x0;
-     y -= y0;
-     }
-  cBitmap::SetBitmap(x, y, Bitmap);
+  cOsdItem *item = Get(current);
+  if (item)
+     item->Set();
 }
 
-void cWindow::Text(int x, int y, const char *s, eDvbColor ColorFg, eDvbColor ColorBg)
+void cOsdMenu::DisplayCurrent(bool Current)
 {
-  if (tiled) {
-     x -= x0;
-     y -= y0;
+  cOsdItem *item = Get(current);
+  if (item) {
+     displayMenu->SetItem(item->Text(), current - first, Current, item->Selectable());
+     if (Current)
+        cStatus::MsgOsdCurrentItem(item->Text());
+     if (!Current)
+        item->SetFresh(true); // leaving the current item resets 'fresh'
      }
-  cBitmap::Text(x, y, s, ColorFg, ColorBg);
 }
 
-const u_char *cWindow::Data(int x, int y)
+void cOsdMenu::Clear(void)
 {
-  return cBitmap::Data(x, y);
+  first = 0;
+  current = marked = -1;
+  cList<cOsdItem>::Clear();
 }
 
-// --- cOsdBase --------------------------------------------------------------
-
-cOsdBase::cOsdBase(int x, int y)
+bool cOsdMenu::SelectableItem(int idx)
 {
-  numWindows = 0;
-  x0 = x;
-  y0 = y;
+  cOsdItem *item = Get(idx);
+  return item && item->Selectable();
 }
 
-cOsdBase::~cOsdBase()
+void cOsdMenu::CursorUp(void)
 {
-  for (int i = 0; i < numWindows; i++)
-      delete window[i];
+  if (current > 0) {
+     int tmpCurrent = current;
+     while (--tmpCurrent >= 0 && !SelectableItem(tmpCurrent));
+     if (tmpCurrent < 0)
+        return;
+     if (tmpCurrent >= first)
+        DisplayCurrent(false);
+     current = tmpCurrent;
+     if (current < first) {
+        first = first > displayMenuItems - 1 ? first - (displayMenuItems - 1) : 0;
+        if (Setup.MenuScrollPage)
+           current = !SelectableItem(first) ? first + 1 : first;
+        Display();
+        }
+     else
+        DisplayCurrent(true);
+     }
 }
 
-tWindowHandle cOsdBase::Create(int x, int y, int w, int h, int Bpp, bool ClearWithBackground, bool Tiled)
-{
-  if (numWindows < MAXNUMWINDOWS) {
-     if (x >= 0 && y >= 0 && w > 0 && h > 0 && (Bpp == 1 || Bpp == 2 || Bpp == 4 || Bpp == 8)) {
-        if ((w & 0x03) != 0) {
-           w += 4 - (w & 0x03);
-           dsyslog("OSD window width must be a multiple of 4 - increasing to %d", w);
+void cOsdMenu::CursorDown(void)
+{
+  int last = Count() - 1;
+  int lastOnScreen = first + displayMenuItems - 1;
+
+  if (current < last) {
+     int tmpCurrent = current;
+     while (++tmpCurrent <= last && !SelectableItem(tmpCurrent));
+     if (tmpCurrent > last)
+        return;
+     if (tmpCurrent <= lastOnScreen)
+        DisplayCurrent(false);
+     current = tmpCurrent;
+     if (current > lastOnScreen) {
+        first += displayMenuItems - 1;
+        lastOnScreen = first + displayMenuItems - 1;
+        if (lastOnScreen > last) {
+           first = last - (displayMenuItems - 1);
+           lastOnScreen = last;
            }
-        cWindow *win = new cWindow(numWindows, x, y, w, h, Bpp, ClearWithBackground, Tiled);
-        if (OpenWindow(win)) {
-           window[win->Handle()] = win;
-           numWindows++;
-           return win->Handle();
-           }
-        else
-           delete win;
+        if (Setup.MenuScrollPage)
+           current = !SelectableItem(lastOnScreen) ? lastOnScreen - 1 : lastOnScreen;
+        Display();
         }
      else
-        esyslog("ERROR: illegal OSD parameters");
+        DisplayCurrent(true);
      }
-  else
-     esyslog("ERROR: too many OSD windows");
-  return -1;
 }
 
-void cOsdBase::AddColor(eDvbColor Color, tWindowHandle Window)
+void cOsdMenu::PageUp(void)
 {
-  cWindow *w = GetWindow(Window);
-  if (w) {
-     w->Index(Color);
-     w->Reset();
+  current -= displayMenuItems;
+  first -= displayMenuItems;
+  if (first < 0)
+     first = current = 0;
+  if (!SelectableItem(current)) {
+     current -= (current > 0) ? 1 : -1;
+     first = min(first, current - 1);
      }
+  Display();
+  DisplayCurrent(true);
 }
 
-cWindow *cOsdBase::GetWindow(int x, int y)
-{
-  for (int i = 0; i < numWindows; i++) {
-      if (window[i]->Tiled() && window[i]->Contains(x, y))
-         return window[i];
-      }
-  return NULL;
-}
-
-cWindow *cOsdBase::GetWindow(tWindowHandle Window)
-{
-  if (0 <= Window && Window < numWindows)
-     return window[Window];
-  if (Window == LAST_CREATED_WINDOW && numWindows > 0)
-     return window[numWindows - 1];
-  return NULL;
-}
-
-void cOsdBase::Flush(void)
-{
-  for (int i = 0; i < numWindows; i++) {
-      CommitWindow(window[i]);
-      window[i]->Clean();
-      }
-  // Showing the windows in a separate loop to avoid seeing them come up one after another
-  for (int i = 0; i < numWindows; i++) {
-      if (!window[i]->Shown())
-         ShowWindow(window[i]);
-      }
-}
-
-void cOsdBase::Clear(tWindowHandle Window)
+void cOsdMenu::PageDown(void) 
 {
-  if (Window == ALL_TILED_WINDOWS || Window == ALL_WINDOWS) {
-     for (int i = 0; i < numWindows; i++)
-         if (Window == ALL_WINDOWS || window[i]->Tiled())
-            window[i]->Clear();
+  current += displayMenuItems;
+  first += displayMenuItems;
+  int count = Count();
+  if (current > count - 1) {
+     current = count - 1;
+     first = max(0, count - displayMenuItems);
      }
-  else {
-     cWindow *w = GetWindow(Window);
-     if (w)
-        w->Clear();
+  if (!SelectableItem(current)) {
+     current += (current < count - 1) ? 1 : -1;
+     first = max(first, current - displayMenuItems);
      }
+  Display();
+  DisplayCurrent(true);
 }
 
-void cOsdBase::Fill(int x1, int y1, int x2, int y2, eDvbColor Color, tWindowHandle Window)
-{
-  cWindow *w = (Window == ALL_TILED_WINDOWS) ? GetWindow(x1, y1) : GetWindow(Window);
-  if (w)
-     w->Fill(x1, y1, x2, y2, Color);
-}
-
-void cOsdBase::SetBitmap(int x, int y, const cBitmap &Bitmap, tWindowHandle Window)
+void cOsdMenu::Mark(void)
 {
-  cWindow *w = (Window == ALL_TILED_WINDOWS) ? GetWindow(x, y) : GetWindow(Window);
-  if (w)
-     w->SetBitmap(x, y, Bitmap);
+  if (Count() && marked < 0) {
+     marked = current;
+     SetStatus(tr("Up/Dn for new location - OK to move"));
+     }
 }
 
-int cOsdBase::Width(unsigned char c)
+eOSState cOsdMenu::HotKey(eKeys Key)
 {
-  return numWindows ? window[0]->Width(c) : 0;
+  for (cOsdItem *item = First(); item; item = Next(item)) {
+      const char *s = item->Text();
+      if (s && (s = skipspace(s)) != NULL) {
+         if (*s == Key - k1 + '1') {
+            current = item->Index();
+            cRemote::Put(kOk, true);
+            break;
+            }
+         }
+      }
+  return osContinue;
 }
 
-int cOsdBase::Width(const char *s)
+eOSState cOsdMenu::AddSubMenu(cOsdMenu *SubMenu)
 {
-  return numWindows ? window[0]->Width(s) : 0;
+  delete subMenu;
+  subMenu = SubMenu;
+  subMenu->Display();
+  return osContinue; // convenience return value
 }
 
-eDvbFont cOsdBase::SetFont(eDvbFont Font)
+eOSState cOsdMenu::CloseSubMenu()
 {
-  eDvbFont oldFont = Font;
-  for (int i = 0; i < numWindows; i++)
-      oldFont = window[i]->SetFont(Font);
-  return oldFont;
+  delete subMenu;
+  subMenu = NULL;
+  RefreshCurrent();
+  Display();
+  return osContinue; // convenience return value
 }
 
-void cOsdBase::Text(int x, int y, const char *s, eDvbColor ColorFg, eDvbColor ColorBg, tWindowHandle Window)
+eOSState cOsdMenu::ProcessKey(eKeys Key)
 {
-  cWindow *w = (Window == ALL_TILED_WINDOWS) ? GetWindow(x, y) : GetWindow(Window);
-  if (w)
-     w->Text(x, y, s, ColorFg, ColorBg);
-}
+  if (subMenu) {
+     eOSState state = subMenu->ProcessKey(Key);
+     if (state == osBack)
+        return CloseSubMenu();
+     return state;
+     }
 
-void cOsdBase::Relocate(tWindowHandle Window, int x, int y, int NewWidth, int NewHeight)
-{
-  cWindow *w = GetWindow(Window);
-  if (w) {
-     if (NewWidth > 0 && NewHeight > 0) {
-        if ((NewWidth & 0x03) != 0) {
-           NewWidth += 4 - (NewWidth & 0x03);
-           dsyslog("OSD window width must be a multiple of 4 - increasing to %d", NewWidth);
-           }
-        CloseWindow(w);
-        cWindow *NewWindow = new cWindow(w->Handle(), x, y, NewWidth, NewHeight, w->Bpp(), w->ClearWithBackground(), w->Tiled());
-        window[w->Handle()] = NewWindow;
-        delete w;
-        OpenWindow(NewWindow);
-        }
-     else {
-        MoveWindow(w, x, y);
-        w->Relocate(x, y);
+  cOsdItem *item = Get(current);
+  if (marked < 0 && item) {
+     eOSState state = item->ProcessKey(Key);
+     if (state != osUnknown) {
+        DisplayCurrent(true);
+        return state;
         }
      }
+  switch (Key) {
+    case k1...k9: return hasHotkeys ? HotKey(Key) : osUnknown;
+    case kUp|k_Repeat:
+    case kUp:   CursorUp();   break;
+    case kDown|k_Repeat:
+    case kDown: CursorDown(); break;
+    case kLeft|k_Repeat:
+    case kLeft: PageUp(); break;
+    case kRight|k_Repeat:
+    case kRight: PageDown(); break;
+    case kBack: return osBack;
+    case kOk:   if (marked >= 0) {
+                   SetStatus(NULL);
+                   if (marked != current)
+                      Move(marked, current);
+                   marked = -1;
+                   break;
+                   }
+                // else run into default
+    default: if (marked < 0)
+                return osUnknown;
+    }
+  return osContinue;
 }
 
-void cOsdBase::Hide(tWindowHandle Window)
-{
-  HideWindow(GetWindow(Window), true);
-}
-
-void cOsdBase::Show(tWindowHandle Window)
-{
-  HideWindow(GetWindow(Window), false);
-}