/*
 * menuitems.c: General purpose menu items
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: menuitems.c 1.23 2005/09/17 09:36:31 kls Exp $
 */

#include "menuitems.h"
#include <ctype.h>
#include "i18n.h"
#include "plugin.h"
#include "remote.h"
#include "skins.h"
#include "status.h"

#define SHIFTTIMEOUT 2

const char *FileNameChars = " abcdefghijklmnopqrstuvwxyz0123456789-.#~";

// --- cMenuEditItem ---------------------------------------------------------

cMenuEditItem::cMenuEditItem(const char *Name)
{
  name = strdup(Name);
  value = NULL;
}

cMenuEditItem::~cMenuEditItem()
{
  free(name);
  free(value);
}

void cMenuEditItem::SetValue(const char *Value, bool HasPre, bool HasSucc)
{
  free(value);
  value = strdup(Value);
  char *buffer = NULL;
  const char* fmt;
  if (HasPre)
    fmt = HasSucc ? "%s:\t<%s>" : "%s\t<%s";
  else
    fmt = HasSucc ? "%s\t%s>" : "%s\t%s";
  if (::Setup.ShowValidInput) asprintf(&buffer, fmt, name, value);
  else
    asprintf(&buffer, "%s:\t%s", name, value);
  SetText(buffer, false);
  cStatus::MsgOsdCurrentItem(buffer);
}

// --- cMenuEditIntItem ------------------------------------------------------

cMenuEditIntItem::cMenuEditIntItem(const char *Name, int *Value, int Min, int Max)
:cMenuEditItem(Name)
{
  value = Value;
  min = Min;
  max = Max;
  Set();
}

void cMenuEditIntItem::Set(void)
{
  char buf[16];
  snprintf(buf, sizeof(buf), "%d", *value);
  SetValue(buf, (*value > min), (*value < max));
}

eOSState cMenuEditIntItem::ProcessKey(eKeys Key)
{
  eOSState state = cMenuEditItem::ProcessKey(Key);

  if (state == osUnknown) {
     int newValue = *value;
     Key = NORMALKEY(Key);
     switch (Key) {
       case kNone: break;
       case k0 ... k9:
            if (fresh) {
               *value = 0;
               fresh = false;
               }
            newValue = *value * 10 + (Key - k0);
            break;
       case kLeft: // TODO might want to increase the delta if repeated quickly?
            newValue = *value - 1;
            fresh = true;
            break;
       case kRight:
            newValue = *value + 1;
            fresh = true;
            break;
       default:
            if (*value < min) { *value = min; Set(); }
            if (*value > max) { *value = max; Set(); }
            return state;
       }
     if ((!fresh || min <= newValue) && newValue <= max) {
        *value = newValue;
        Set();
        }
     state = osContinue;
     }
  return state;
}

// --- cMenuEditBoolItem -----------------------------------------------------

cMenuEditBoolItem::cMenuEditBoolItem(const char *Name, int *Value, const char *FalseString, const char *TrueString)
:cMenuEditIntItem(Name, Value, 0, 1)
{
  falseString = FalseString ? FalseString : tr("no");
  trueString = TrueString ? TrueString : tr("yes");
  Set();
}

void cMenuEditBoolItem::Set(void)
{
  char buf[16];
  snprintf(buf, sizeof(buf), "%s", *value ? trueString : falseString);
  SetValue(buf, *value, !*value);
}

// --- cMenuEditBitItem ------------------------------------------------------

cMenuEditBitItem::cMenuEditBitItem(const char *Name, int *Value, int Mask, const char *FalseString, const char *TrueString)
:cMenuEditBoolItem(Name, &bit, FalseString, TrueString)
{
  value = Value;
  bit = (*value & Mask) != 0;
  mask = Mask;
  Set();
}

void cMenuEditBitItem::Set(void)
{
  *value = bit ? *value | mask : *value & ~mask;
  cMenuEditBoolItem::Set();
}

// --- cMenuEditNumItem ------------------------------------------------------

cMenuEditNumItem::cMenuEditNumItem(const char *Name, char *Value, int Length, bool Blind)
:cMenuEditItem(Name)
{
  value = Value;
  length = Length;
  blind = Blind;
  Set();
}

void cMenuEditNumItem::Set(void)
{
  if (blind) {
     char buf[length + 1];
     int i;
     for (i = 0; i < length && value[i]; i++)
         buf[i] = '*';
     buf[i] = 0;
     SetValue(buf);
     }
  else
     SetValue(value);
}

eOSState cMenuEditNumItem::ProcessKey(eKeys Key)
{
  eOSState state = cMenuEditItem::ProcessKey(Key);

  if (state == osUnknown) {
     Key = NORMALKEY(Key);
     switch (Key) {
       case kLeft: {
            int l = strlen(value);
            if (l > 0)
               value[l - 1] = 0;
            }
            break;
       case k0 ... k9: {
            int l = strlen(value);
            if (l < length) {
               value[l] = Key - k0 + '0';
               value[l + 1] = 0;
               }
            }
            break;
       default: return state;
       }
     Set();
     state = osContinue;
     }
  return state;
}

// --- cMenuEditChrItem ------------------------------------------------------

cMenuEditChrItem::cMenuEditChrItem(const char *Name, char *Value, const char *Allowed)
:cMenuEditItem(Name)
{
  value = Value;
  allowed = strdup(Allowed);
  current = strchr(allowed, *Value);
  if (!current)
     current = allowed;
  Set();
}

cMenuEditChrItem::~cMenuEditChrItem()
{
  free(allowed);
}

void cMenuEditChrItem::Set(void)
{
  char buf[2];
  snprintf(buf, sizeof(buf), "%c", *value);
  SetValue(buf);
}

eOSState cMenuEditChrItem::ProcessKey(eKeys Key)
{
  eOSState state = cMenuEditItem::ProcessKey(Key);

  if (state == osUnknown) {
     if (NORMALKEY(Key) == kLeft) {
        if (current > allowed)
           current--;
        }
     else if (NORMALKEY(Key) == kRight) {
        if (*(current + 1))
           current++;
        }
     else
        return state;
     *value = *current;
     Set();
     state = osContinue;
     }
  return state;
}

// --- cMenuEditStrItem ------------------------------------------------------

cMenuEditStrItem::cMenuEditStrItem(const char *Name, char *Value, int Length, const char *Allowed)
:cMenuEditItem(Name)
{
  value = Value;
  length = Length;
  allowed = strdup(Allowed);
  pos = -1;
  insert = uppercase = false;
  newchar = true;
  ieCurChr = 0;
  lastKey = kNone;
  lastActivity = time(NULL);
  Set();
}

cMenuEditStrItem::~cMenuEditStrItem()
{
  free(allowed);
}

void cMenuEditStrItem::SetHelpKeys(void)
{
  if (pos >= 0)
     cSkinDisplay::Current()->SetButtons(tr("ABC/abc"), tr(insert ? "Overwrite" : "Insert"), tr("Delete"));
  else
     cSkinDisplay::Current()->SetButtons(NULL);
}

void cMenuEditStrItem::Set(void)
{
  char buf[1000];
  const char *fmt = insert && newchar ? "[]%c%s" : "[%c]%s";

  if (pos >= 0) {
     const cFont *font = cFont::GetFont(fontOsd);
     strncpy(buf, value, pos);
     snprintf(buf + pos, sizeof(buf) - pos - 2, fmt, *(value + pos), value + pos + 1);
     int width = cSkinDisplay::Current()->EditableWidth();
     if (font->Width(buf) <= width) {
        // the whole buffer fits on the screen
        SetValue(buf);
        return;
        }
     width -= font->Width('>'); // assuming '<' and '>' have the same with
     int w = 0;
     int i = 0;
     int l = strlen(buf);
     while (i < l && w <= width)
           w += font->Width(buf[i++]);
     if (i >= pos + 4) {
        // the cursor fits on the screen
        buf[i - 1] = '>';
        buf[i] = 0;
        SetValue(buf);
        return;
        }
     // the cursor doesn't fit on the screen
     w = 0;
     if (buf[i = pos + 3]) {
        buf[i] = '>';
        buf[i + 1] = 0;
        }
     else
        i--;
     while (i >= 0 && w <= width)
           w += font->Width(buf[i--]);
     buf[++i] = '<';
     SetValue(buf + i);
     }
  else
     SetValue(value);
}

char cMenuEditStrItem::Inc(char c, bool Up)
{
  const char *p = strchr(allowed, c);
  if (!p)
     p = allowed;
  if (Up) {
     if (!*++p)
        p = allowed;
     }
  else if (--p < allowed)
     p = allowed + strlen(allowed) - 1;
  return *p;
}

eOSState cMenuEditStrItem::ProcessKey(eKeys Key)
{
  const char c1[] = "-.#%~,/_@:1";
  const char c2[] = "abcäåá2";
  const char c3[] = "defé3";
  const char c4[] = "ghi4";
  const char c5[] = "jkl5";
  const char c6[] = "mnoöñó6";
  const char c7[] = "pqrsß7";
  const char c8[] = "tuvüú8";
  const char c9[] = "wxyz9";
  const char c0[] = " 0";

  switch (Key) {
    case kRed:   // Switch between upper- and lowercase characters
                 if (pos >= 0) {
                    if (!insert || !newchar) {
                       uppercase = !uppercase;
                       value[pos] = uppercase ? toupper(value[pos]) : tolower(value[pos]);
                       }
                    }
                 else
                    return osUnknown;
                 lastKey = Key;
                 break;
    case kGreen: // Toggle insert/overwrite modes
                 if (pos >= 0) {
                    insert = !insert;
                    newchar = true;
                    SetHelpKeys();
                    }
                 else
                    return osUnknown;
                 lastKey = Key;
                 break;
    case kYellow|k_Repeat:
    case kYellow: // Remove the character at current position; in insert mode it is the character to the right of cursor
                 if (pos >= 0) {
                    if (strlen(value) > 1) {
                       if (!insert || pos < int(strlen(value)) - 1)
                          memmove(value + pos, value + pos + 1, strlen(value) - pos);
                       // reduce position, if we removed the last character
                       if (pos == int(strlen(value)))
                          pos--;
                       }
                    else if (strlen(value) == 1)
                       value[0] = ' '; // This is the last character in the string, replace it with a blank
                    if (isalpha(value[pos]))
                       uppercase = isupper(value[pos]);
                    newchar = true;
                    }
                 else
                    return osUnknown;
                 break;
    case kBlue|k_Repeat:
    case kBlue:  // consume the key only if in edit-mode
                 if (pos >= 0)
                    ;
                 else
                    return osUnknown;
                 lastKey = Key;
                 break;
    case kLeft|k_Repeat:
    case kLeft:  if (pos > 0) {
                    if (!insert || newchar)
                       pos--;
                    newchar = true;
                    }
                 if (!insert && isalpha(value[pos]))
                    uppercase = isupper(value[pos]);
                 lastKey = Key;
                 break;
    case kRight|k_Repeat:
    case kRight: if (pos < length - 2 && pos < int(strlen(value)) ) {
                    if (++pos >= int(strlen(value))) {
                       if (pos >= 2 && value[pos - 1] == ' ' && value[pos - 2] == ' ')
                          pos--; // allow only two blanks at the end
                       else {
                          value[pos] = ' ';
                          value[pos + 1] = 0;
                          }
                       }
                    }
                 newchar = true;
                 if (!insert && isalpha(value[pos]))
                    uppercase = isupper(value[pos]);
                 if (pos == 0)
                    SetHelpKeys();
                 lastKey = Key;
                 break;
    case kUp|k_Repeat:
    case kUp:
    case kDown|k_Repeat:
    case kDown:  if (pos >= 0) {
                    if (insert && newchar) {
                       // create a new character in insert mode
                       if (int(strlen(value)) < length - 1) {
                          memmove(value + pos + 1, value + pos, strlen(value) - pos + 1);
                          value[pos] = ' ';
                          }
                       }
                    if (uppercase)
                       value[pos] = toupper(Inc(tolower(value[pos]), NORMALKEY(Key) == kUp));
                    else
                       value[pos] =         Inc(        value[pos],  NORMALKEY(Key) == kUp);
                    newchar = false;
                    }
                 else
                    return cMenuEditItem::ProcessKey(Key);
                 lastKey = Key;
                 break;
    case k0|k_Repeat ... k9|k_Repeat:
    case k0 ... k9: if ((Key != lastKey) || ((Key == lastKey) && (time(NULL) - lastActivity > SHIFTTIMEOUT)) ) {
                    ieCurChr = 0;
                    if (!newchar) {
                       // kRight
                       if (pos < length - 2 && pos < int(strlen(value)) ) {
                          if (++pos >= int(strlen(value))) {
                             if (pos >= 2 && value[pos - 1] == ' ' && value[pos - 2] == ' ')
                                pos--; // allow only two blanks at the end
                             else {
                                value[pos] = ' ';
                                value[pos + 1] = 0;
                                }
                             }
                          }
                       newchar = true;
                       if (!insert && isalpha(value[pos]))
                          uppercase = isupper(value[pos]);
                       }
                    }
                 // kUp/kDown
                 if (pos >= 0) {
                    if (insert && newchar) {
                       // create a new character in insert mode
                       if (int(strlen(value)) < length - 1) {
                          memmove(value + pos + 1, value + pos, strlen(value) - pos + 1);
                          value[pos] = ' ';
                          }
                       }
                    }
                 else
                    return cMenuEditItem::ProcessKey(Key);
                 switch (Key) {
                    case k1:
                         if (uppercase)
                            value[pos] = toupper(c1[ieCurChr]);
                         else
                            value[pos] =         c1[ieCurChr];
                         if (c1[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k2:
                         if (uppercase)
                            value[pos] = toupper(c2[ieCurChr]);
                         else
                            value[pos] =         c2[ieCurChr];
                         if (c2[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k3:
                         if (uppercase)
                            value[pos] = toupper(c3[ieCurChr]);
                         else
                            value[pos] =         c3[ieCurChr];
                         if (c3[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k4:
                         if (uppercase)
                            value[pos] = toupper(c4[ieCurChr]);
                         else
                            value[pos] =         c4[ieCurChr];
                         if (c4[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k5:
                         if (uppercase)
                            value[pos] = toupper(c5[ieCurChr]);
                         else
                            value[pos] =         c5[ieCurChr];
                         if (c5[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k6:
                         if (uppercase)
                            value[pos] = toupper(c6[ieCurChr]);
                         else
                            value[pos] =         c6[ieCurChr];
                         if (c6[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k7:
                         if (uppercase)
                            value[pos] = toupper(c7[ieCurChr]);
                         else
                            value[pos] =         c7[ieCurChr];
                         if (c7[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k8:
                         if (uppercase)
                            value[pos] = toupper(c8[ieCurChr]);
                         else
                            value[pos] =         c8[ieCurChr];
                         if (c8[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k9:
                         if (uppercase)
                            value[pos] = toupper(c9[ieCurChr]);
                         else
                            value[pos] =         c9[ieCurChr];
                         if (c9[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    case k0:
                         if (uppercase)
                            value[pos] = toupper(c0[ieCurChr]);
                         else
                            value[pos] =         c0[ieCurChr];
                         if (c0[ieCurChr+1] == 0)
                            ieCurChr = 0;
                         else
                            ieCurChr++;
                         break;
                    default:
                         break;
                    }
                 lastKey = Key;
                 newchar = false;
                 lastActivity = time(NULL);
                 break;
    case kOk:    if (pos >= 0) {
                    pos = -1;
                    lastKey = Key;
                    newchar = true;
                    stripspace(value);
                    SetHelpKeys();
                    break;
                    }
                 // run into default
    default:     if (pos >= 0 && BASICKEY(Key) == kKbd) {
                    int c = KEYKBD(Key);
                    if (c <= 0xFF) {
                       const char *p = strchr(allowed, tolower(c));
                       if (p) {
                          int l = strlen(value);
                          if (insert && l < length - 1)
                             memmove(value + pos + 1, value + pos, l - pos + 1);
                          value[pos] = c;
                          if (pos < length - 2)
                             pos++;
                          if (pos >= l) {
                             value[pos] = ' ';
                             value[pos + 1] = 0;
                             }
                          }
                       else {
                          switch (c) {
                            case 0x7F: // backspace
                                       if (pos > 0) {
                                          pos--;
                                          return ProcessKey(kYellow);
                                          }
                                       break;
                            }
                          }
                       }
                    else {
                       switch (c) {
                         case kfHome: pos = 0; break;
                         case kfEnd:  pos = strlen(value) - 1; break;
                         case kfIns:  return ProcessKey(kGreen);
                         case kfDel:  return ProcessKey(kYellow);
                         }
                       }
                    }
                 else
                    return cMenuEditItem::ProcessKey(Key);
    }
  Set();
  return osContinue;
}

 
// --- cMenuEditRecPathItem --------------------------------------------------

cMenuEditRecPathItem::cMenuEditRecPathItem(const char* Name, char* Path,
   int Length): cMenuEditStrItem(Name, Path, Length, tr(FileNameChars))
{
  SetBase(Path);
}

cMenuEditRecPathItem::~cMenuEditRecPathItem()
{
}

void cMenuEditRecPathItem::SetBase(const char* Path)
{
  if (!Path)
      base[0] = 0;
  strn0cpy(base, Path, sizeof(base));
  char* p = strrchr(base, '~');
  if (p)
     p[0] = 0; 
  else
     base[0] = 0;
}

void cMenuEditRecPathItem::FindNextLevel()
{
  char item[MaxFileName];

  for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording))
  {
     char* p;
     strn0cpy(item, recording->Name(), sizeof(item));
     stripspace(value);
     if (!strlen(value))
        p = strchr(item, '~');
     else {
        if (strstr(item, value) != item)
           continue;
        if (item[strlen(value)] != '~')
           continue;
        p = strchr(item + strlen(value) + 1, '~');
        }
     if (!p)
        continue;
     p[0] = 0;
     strn0cpy(base, value, length);
     strn0cpy(value, item, length);
     return;
     }
}

void cMenuEditRecPathItem::Find(bool Next)
{
  char item[MaxFileName];
  char lastItem[MaxFileName] = "";

  for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording))
  {
     const char* recName = recording->Name();
     if (strlen(base) && strstr(recName, base) != recName)
        continue;
     if (strlen(base) && recName[strlen(base)] != '~')
        continue;
     strn0cpy(item, recName, sizeof(item));
     char* p = strchr(item + strlen(base) + 1, '~');
     if (!p)
        continue;
     p[0] = 0;

     esyslog("item: %s (%s)", item, lastItem);
     if (!Next && (strcmp(item, value) == 0)) {
        if (strlen(lastItem))
           strn0cpy(value, lastItem, length);
        return;
        }
     if (strcmp(lastItem, item) != 0) {
        if(Next && strlen(lastItem) && strcmp(lastItem, value) == 0) {
           strn0cpy(value, item, length);
           return;
           }
        strn0cpy(lastItem, item, sizeof(lastItem));
        }
     }
}

void cMenuEditRecPathItem::SetHelpKeys(void)
{
  cSkinDisplay::Current()->SetButtons(tr("Rename$Up"), tr("Rename$Down"), tr("Rename$Previous"), tr("Rename$Next"));
}

eOSState cMenuEditRecPathItem::ProcessKey(eKeys Key)
{
  switch (Key) {
    case kLeft:
    case kRed:    // one level up
                  if (pos<0)
                     return cMenuEditItem::ProcessKey(Key);
                  strn0cpy(value, base, length);
                  SetBase(base);
                  pos = strlen(base);
                  if (pos)
                     pos++;
                  if (!strlen(value))
                     strn0cpy(value, " ", length);
                  break;
    case kRight:
    case kGreen:  // one level down
                  if (pos>=0)
                     FindNextLevel();
                  if (!strlen(value))
                     strn0cpy(value, " ", length);
                  pos = strlen(base);
                  if (pos)
                     pos++;
                  SetHelpKeys();
                  break;
    case kUp|k_Repeat:
    case kUp:
    case kYellow|k_Repeat:
    case kYellow: // previous directory in list
                  if (pos<0)
                     return cMenuEditItem::ProcessKey(Key);
                  Find(false);
                  pos = strlen(base);
                  if (pos)
                     pos++;
                  break;
    case kDown|k_Repeat:
    case kDown:
    case kBlue|k_Repeat:
    case kBlue:   // next directory in list
                  if (pos<0)
                     return cMenuEditItem::ProcessKey(Key);
                  Find(true);
                  pos = strlen(base);
                  if (pos)
                     pos++;
                  break;
    case kOk:     // done
                  if (pos<0)
                     return cMenuEditItem::ProcessKey(Key);
                  stripspace(value);
                  cSkinDisplay::Current()->SetButtons(NULL);
                  pos = -1;
                  break;
    default:
                  return cMenuEditItem::ProcessKey(Key);
    }
  Set();
  return osContinue;
}

// --- cMenuEditStraItem -----------------------------------------------------

cMenuEditStraItem::cMenuEditStraItem(const char *Name, int *Value, int NumStrings, const char * const *Strings)
:cMenuEditIntItem(Name, Value, 0, NumStrings - 1)
{
  strings = Strings;
  Set();
}

void cMenuEditStraItem::Set(void)
{
  SetValue(strings[*value], (*value > min), (*value < max));
}

// --- cMenuEditChanItem -----------------------------------------------------

cMenuEditChanItem::cMenuEditChanItem(const char *Name, int *Value)
:cMenuEditIntItem(Name, Value, 1, Channels.MaxNumber())
{
  Set();
}

void cMenuEditChanItem::Set(void)
{
  char buf[255];
  cChannel *channel = Channels.GetByNumber(*value);
  snprintf(buf, sizeof(buf), "%d %s", *value, channel ? channel->Name() : "");
  SetValue(buf, (*value > 1), (*value < Channels.MaxNumber()));
}

eOSState cMenuEditChanItem::ProcessKey(eKeys Key)
{
  int delta = 1;

  switch (Key) {
    case kLeft|k_Repeat:
    case kLeft:  delta = -1;
    case kRight|k_Repeat:
    case kRight:
                 {
                   cChannel *channel = Channels.GetByNumber(*value + delta, delta);
                   if (channel) {
                      *value = channel->Number();
                      Set();
                      }
                 }
                 break;
    default: return cMenuEditIntItem::ProcessKey(Key);
    }
  return osContinue;
}

// --- cMenuEditPrefChanItem -----------------------------------------------------

cMenuEditPrefChanItem::cMenuEditPrefChanItem(const char *Name, int *Value)
:cMenuEditIntItem(Name, Value, 0, Channels.MaxNumber())
{
  Set();
}


void cMenuEditPrefChanItem::Set(void)
{
  char buf[255];
  if (*value > 0) { // We have a preferred Channel
    cChannel *channel = Channels.GetByNumber(*value);
    snprintf(buf, sizeof(buf), "%d %s", *value, channel ? channel->Name() : "");
    SetValue(buf);
  } else { // Normal behavior, use last channel
    strncpy(buf, tr("Channel used last"), sizeof(buf));
    SetValue(buf);
  }
}

eOSState cMenuEditPrefChanItem::ProcessKey(eKeys Key)
{
  int delta = 1;
  char buf[255];

  switch (Key) {
    case kLeft|k_Repeat:
    case kLeft:  delta = -1;
    case kRight|k_Repeat:
    case kRight:
                 {
                   if (*value + delta < 1) {
                     strncpy(buf, tr("Channel used last"), sizeof(buf));
                     *value = 0;
                     SetValue(buf);
                   } else {
                     cChannel *channel = Channels.GetByNumber(*value + delta, delta);
                     if (channel) {
                        *value = channel->Number();
                        Set();
                        }
                   }
                 }
                 break;
    default : return cMenuEditIntItem::ProcessKey(Key);
    }
  return osContinue;
}

// --- cMenuEditPrefVolItem -----------------------------------------------------

cMenuEditPrefVolItem::cMenuEditPrefVolItem(const char *Name, int *Value)
:cMenuEditIntItem(Name, Value, 0, 256)
{
  Set();
}


void cMenuEditPrefVolItem::Set(void)
{
  char buf[255];
  if (*value < 256 ) { // We have a preferred Volume
    snprintf(buf, sizeof(buf), "%d", *value);
    SetValue(buf);
  } else { // Normal behavior, use last Volume
    strncpy(buf, tr("Volume used last"), sizeof(buf));
    SetValue(buf);
  }
}

eOSState cMenuEditPrefVolItem::ProcessKey(eKeys Key)
{
  int delta = 1;
  char buf[255];

  switch (Key) {
    case kLeft|k_Repeat:
    case kLeft:  delta = -1;
    case kRight|k_Repeat:
    case kRight:
                 {
                   if (*value + delta > 255) {
                     strncpy(buf, tr("Volume used last"), sizeof(buf));
                     *value = 256;
                     SetValue(buf);
                   } else {
                     cChannel *channel = Channels.GetByNumber(*value + delta, delta);
                     if (channel) {
                        *value = channel->Number();
                        Set();
                        }
                   }
                 }
                 break;
    default : return cMenuEditIntItem::ProcessKey(Key);
    }
  return osContinue;
}


// --- cMenuEditTranItem -----------------------------------------------------

cMenuEditTranItem::cMenuEditTranItem(const char *Name, int *Value, int *Source)
:cMenuEditChanItem(Name, Value)
{
  number = 0;
  source = Source;
  transponder = *Value;
  cChannel *channel = Channels.First();
  while (channel) {
        if (!channel->GroupSep() && *source == channel->Source() && ISTRANSPONDER(channel->Transponder(), *Value)) {
           number = channel->Number();
           break;
           }
        channel = (cChannel *)channel->Next();
        }
  *Value = number;
  Set();
  *Value = transponder;
}

eOSState cMenuEditTranItem::ProcessKey(eKeys Key)
{
  *value = number;
  eOSState state = cMenuEditChanItem::ProcessKey(Key);
  number = *value;
  cChannel *channel = Channels.GetByNumber(*value);
  if (channel) {
     *source = channel->Source();
     transponder = channel->Transponder();
     }
  *value = transponder;
  return state;
}

// --- cMenuEditDateItem -----------------------------------------------------

static int ParseWeekDays(const char *s)
{
  time_t day;
  int weekdays;
  return cTimer::ParseDay(s, day, weekdays) ? weekdays : 0;
}

int cMenuEditDateItem::days[] = { ParseWeekDays("M------"),
                                  ParseWeekDays("-T-----"),
                                  ParseWeekDays("--W----"),
                                  ParseWeekDays("---T---"),
                                  ParseWeekDays("----F--"),
                                  ParseWeekDays("-----S-"),
                                  ParseWeekDays("------S"),
                                  ParseWeekDays("MTWTF--"),
                                  ParseWeekDays("MTWTFS-"),
                                  ParseWeekDays("MTWTFSS"),
                                  ParseWeekDays("-----SS"),
                                  0 };

cMenuEditDateItem::cMenuEditDateItem(const char *Name, time_t *Value, int *WeekDays)
:cMenuEditItem(Name)
{
  value = Value;
  weekdays = WeekDays;
  oldvalue = 0;
  dayindex = 0;
  Set();
}

void cMenuEditDateItem::Set(void)
{
#define DATEBUFFERSIZE 32
  char buf[DATEBUFFERSIZE];
  if (weekdays && *weekdays) {
     SetValue(cTimer::PrintDay(0, *weekdays));
     return;
     }
  else if (*value) {
     struct tm tm_r;
     localtime_r(value, &tm_r);
     strftime(buf, DATEBUFFERSIZE, "%Y-%m-%d ", &tm_r);
     strcat(buf, WeekDayName(tm_r.tm_wday));
     }
  else
     *buf = 0;
  SetValue(buf);
}

eOSState cMenuEditDateItem::ProcessKey(eKeys Key)
{
  eOSState state = cMenuEditItem::ProcessKey(Key);

  if (state == osUnknown) {
     time_t now = time(NULL);
     if (NORMALKEY(Key) == kLeft) { // TODO might want to increase the delta if repeated quickly?
        if (!weekdays || !*weekdays) {
           // Decrement single day:
           time_t v = *value;
           v -= SECSINDAY;
           if (v < now) {
              if (now <= v + SECSINDAY) { // switched from tomorrow to today
                 if (!weekdays)
                    v = 0;
                 }
              else if (weekdays) { // switched from today to yesterday, so enter weekdays mode
                 v = 0;
                 dayindex = sizeof(days) / sizeof(int) - 2;
                 *weekdays = days[dayindex];
                 }
              else // don't go before today
                 v = *value;
              }
           *value = v;
           }
        else {
           // Decrement weekday index:
           if (dayindex > 0)
              *weekdays = days[--dayindex];
           }
        }
     else if (NORMALKEY(Key) == kRight) {
        if (!weekdays || !*weekdays) {
           // Increment single day:
           if (!*value)
              *value = cTimer::SetTime(now, 0);
           *value += SECSINDAY;
           }
        else {
           // Increment weekday index:
           *weekdays = days[++dayindex];
           if (!*weekdays) { // was last weekday entry, so switch to today
              *value = cTimer::SetTime(now, 0);
              dayindex = 0;
              }
           }
        }
     else if (weekdays) {
        if (Key == k0) {
           // Toggle between weekdays and single day:
           if (*weekdays) {
              *value = cTimer::SetTime(oldvalue ? oldvalue : now, 0);
              oldvalue = 0;
              *weekdays = 0;
              }
           else {
              *weekdays = days[cTimer::GetWDay(*value)];
              oldvalue = *value;
              *value = 0;
              }
           }
        else if (k1 <= Key && Key <= k7) {
           // Toggle individual weekdays:
           if (*weekdays) {
              int v = *weekdays ^ (1 << (Key - k1));
              if (v != 0)
                 *weekdays = v; // can't let this become all 0
              }
           }
        else
           return state;
        }
     else
        return state;
     Set();
     state = osContinue;
     }
  return state;
}

// --- cMenuEditTimeItem -----------------------------------------------------

cMenuEditTimeItem::cMenuEditTimeItem(const char *Name, int *Value)
:cMenuEditItem(Name)
{
  value = Value;
  hh = *value / 100;
  mm = *value % 100;
  pos = 0;
  Set();
}

void cMenuEditTimeItem::Set(void)
{
  char buf[10];
  switch (pos) {
    case 1:  snprintf(buf, sizeof(buf), "%01d-:--", hh / 10); break;
    case 2:  snprintf(buf, sizeof(buf), "%02d:--", hh); break;
    case 3:  snprintf(buf, sizeof(buf), "%02d:%01d-", hh, mm / 10); break;
    default: snprintf(buf, sizeof(buf), "%02d:%02d", hh, mm);
    }
  SetValue(buf);
}

eOSState cMenuEditTimeItem::ProcessKey(eKeys Key)
{
  eOSState state = cMenuEditItem::ProcessKey(Key);

  if (state == osUnknown) {
     if (k0 <= Key && Key <= k9) {
        if (fresh || pos > 3) {
           pos = 0;
           fresh = false;
           }
        int n = Key - k0;
        switch (pos) {
          case 0: if (n <= 2) {
                     hh = n * 10;
                     mm = 0;
                     pos++;
                     }
                  break;
          case 1: if (hh + n <= 23) {
                     hh += n;
                     pos++;
                     }
                  break;
          case 2: if (n <= 5) {
                     mm += n * 10;
                     pos++;
                     }
                  break;
          case 3: if (mm + n <= 59) {
                     mm += n;
                     pos++;
                     }
                  break;
          }
        }
     else if (NORMALKEY(Key) == kLeft) { // TODO might want to increase the delta if repeated quickly?
        if (--mm < 0) {
           mm = 59;
           if (--hh < 0)
              hh = 23;
           }
        fresh = true;
        }
     else if (NORMALKEY(Key) == kRight) {
        if (++mm > 59) {
           mm = 0;
           if (++hh > 23)
              hh = 0;
           }
        fresh = true;
        }
     else
        return state;
     *value = hh * 100 + mm;
     Set();
     state = osContinue;
     }
  return state;
}

// --- cMenuSetupPage --------------------------------------------------------

cMenuSetupPage::cMenuSetupPage(void)
:cOsdMenu("", 33)
{
  plugin = NULL;
}

void cMenuSetupPage::SetSection(const char *Section)
{
  char buf[40];
  snprintf(buf, sizeof(buf), "%s - %s", tr("Setup"), Section);
  SetTitle(buf);
}

eOSState cMenuSetupPage::ProcessKey(eKeys Key)
{
  eOSState state = cOsdMenu::ProcessKey(Key);

  if (state == osUnknown) {
     switch (Key) {
       case kOk: Store();
                 state = osBack;
                 break;
       default: break;
       }
     }
  return state;
}

void cMenuSetupPage::SetPlugin(cPlugin *Plugin)
{
  plugin = Plugin;
  char buf[40];
  snprintf(buf, sizeof(buf), "%s '%s'", tr("Plugin"), plugin->Name());
  SetSection(buf);
}

void cMenuSetupPage::SetupStore(const char *Name, const char *Value)
{
  if (plugin)
     plugin->SetupStore(Name, Value);
}

void cMenuSetupPage::SetupStore(const char *Name, int Value)
{
  if (plugin)
     plugin->SetupStore(Name, Value);
}
