remote.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "remote.h"
  22 #include "i18n.h"
  23
  24 Remote* Remote::instance = NULL;
  25
  26 Remote::Remote()
  27 {
  28   if (instance) return;
  29   instance = this;
  30   remoteType = OLDREMOTE;
  31   learnmode = NOLEARNMODE;
  32 }
  33
  34 Remote::~Remote()
  35 {
  36   instance = NULL;
  37 }
  38
  39 Remote* Remote::getInstance()
  40 {
  41   return instance;
  42 }
  43
  44 void Remote::setRemoteType(UCHAR newType)
  45 {
  46   if ((newType != OLDREMOTE) && (newType != NEWREMOTE)) return;
  47   remoteType = newType;
  48 }
  49
  50 void Remote::EnterLearningMode(UCHAR command)
  51 {
  52   learnmode = command; //Armed
  53 }
  54
  55 void Remote::ResetToDefault()
  56 {
  57   translist.clear();
  58   InitHWCListwithDefaults();
  59 }
  60
  61
  62 UCHAR Remote::TranslateHWCFixed(ULLONG code)
  63 {
  64   switch (code)
  65   {
  66     case DOWN:
  67       return DOWN;
  68     case UP:
  69       return UP;
  70     case LEFT:
  71       return LEFT;
  72     case RIGHT:
  73       return RIGHT;
  74     case DF_DOWN:
  75       return DOWN;
  76     case DF_UP:
  77       return UP;
  78     case DF_LEFT:
  79       return LEFT;
  80     case DF_RIGHT:
  81       return RIGHT;
  82     case MENU:
  83       return MENU;
  84     case BACK:
  85       return BACK;
  86     case OK:
  87       return OK;
  88     default:
  89       return NA_UNKNOWN;
  90   }
  91 }
  92
  93 const char*Remote::HardcodedTranslateStr(UCHAR command)
  94 {
  95   switch (command)
  96   {
  97     case DOWN:
  98       return tr("Down");
  99     case UP:
 100       return tr("Up");
 101     case LEFT:
 102       return tr("Left");
 103     case RIGHT:
 104       return tr("Right");
 105     case MENU:
 106       return tr("Menu");
 107     case BACK:
 108       return tr("Back");
 109     case OK:
 110       return tr("Ok");
 111     default:
 112       return NULL;
 113   }
 114 }
 115
 116 UCHAR Remote::TranslateHWCList(ULLONG code)
 117 {
 118   if (learnmode != NOLEARNMODE)
 119   {
 120     setHWCtoCommand(code, learnmode);
 121     learnmode = NOLEARNMODE;
 122     return NA_LEARN;
 123   }
 124   RemoteTranslationList::iterator it = translist.find(code);
 125   if (it == translist.end())
 126   {
 127     return NA_UNKNOWN;
 128   }
 129   else
 130   {
 131     return it->second;
 132   }
 133 }
 134
 135 UCHAR Remote::TranslateHWC(ULLONG code)
 136 {
 137   UCHAR ret = TranslateHWCFixed(code);
 138   if (ret == NA_UNKNOWN)
 139   {
 140     ret = TranslateHWCList(code);
 141   }
 142   else
 143   {
 144     learnmode = NOLEARNMODE;
 145   }
 146
 147   if (ret == NA_UNKNOWN)
 148   {
 149     return NA_UNKNOWN;
 150   }
 151   return ret;
 152 }
 153
 154 void Remote::setHWCtoCommand(ULLONG hcw, UCHAR command)
 155 {
 156   translist[hcw] = command;
 157 }
 158
 159 void Remote::unsetHWC(ULLONG hcw)
 160 {
 161   translist.erase(hcw);
 162 }
 163
 164 void Remote::LoadKeysConfig(char *cfg)
 165 {
 166   char *start = cfg;
 167   start = strchr(cfg,'H')+1;
 168   while ((start-1) != NULL)
 169   {
 170     ULONG ul1, ul2;
 171     ULONG uc;
 172     if (sscanf(start,"%lXI%lXK%lX",&ul1,&ul2,&uc) == 3)
 173     {
 174       translist[((ULLONG) ul1) | ((ULLONG)ul2) << 32]=(UCHAR)uc;
 175     }
 176     start = strchr(start, 'H')+1;
 177   }
 178 }
 179
 180 char *Remote::SaveKeysConfig()
 181 {
 182   int length=21*translist.size() +1;
 183   char *output=new char[length];
 184   char *current=output;
 185   RemoteTranslationList::const_iterator it;
 186   for (it = translist.begin(); it != translist.end(); it++)
 187   {
 188     current+=sprintf(current,"H%08lXI%08lXK%02X",
 189       (ULONG)it->first ,(ULONG) (it->first >> 32), it->second);
 190   }
 191   return output;
 192 }
 193
 194
 195 void Remote::InitHWCListwithDefaults()
 196 {
 197   translist[VOLUMEUP] = VOLUMEUP;
 198   translist[VOLUMEDOWN] = VOLUMEDOWN;
 199   translist[CHANNELUP] = CHANNELUP;
 200   translist[CHANNELDOWN] = CHANNELDOWN;
 201
 202   // Common buttons
 203   translist[ZERO] = ZERO;
 204   translist[ONE] = ONE;
 205   translist[TWO] = TWO;
 206   translist[THREE] = THREE;
 207   translist[FOUR] = FOUR;
 208   translist[FIVE] = FIVE;
 209   translist[SIX] = SIX;
 210   translist[SEVEN] = SEVEN;
 211   translist[EIGHT] = EIGHT;
 212   translist[NINE] = NINE;
 213   translist[POWER] = POWER;
 214   translist[GO] = GO;
 215   translist[RED] = RED;
 216   translist[GREEN] = GREEN;
 217   translist[YELLOW] = YELLOW;
 218   translist[BLUE] = BLUE;
 219
 220   translist[MUTE] = MUTE;
 221   translist[RADIO] = RADIO;
 222   translist[REVERSE] = REVERSE;
 223   translist[FORWARD] = FORWARD;
 224   translist[RECORD] = RECORD;
 225   translist[STOP] = STOP;
 226   translist[PAUSE] = PAUSE;
 227   translist[PLAY] = PLAY;
 228   translist[SKIPBACK] = SKIPBACK;
 229   translist[SKIPFORWARD] = SKIPFORWARD;
 230
 231   // Old remote only
 232   translist[FULL] = FULL;
 233
 234   // New remote only
 235   translist[TV] = TV;
 236   translist[VIDEOS] = VIDEOS;
 237   translist[MUSIC] = MUSIC;
 238   translist[PICTURES] = PICTURES;
 239   translist[GUIDE] = GUIDE;
 240   translist[PREVCHANNEL] = PREVCHANNEL;
 241   translist[STAR] = STAR;
 242   translist[HASH] = HASH;
 243 }
 244
 245 const char *Remote::CommandDesc(UCHAR number)
 246 {
 247   switch (number)
 248   {
 249     case VOLUMEUP:
 250       return tr("Volume Up");
 251
 252     case VOLUMEDOWN:
 253       return tr("Volume Down");
 254     case CHANNELUP:
 255       return tr("Channel up");
 256     case CHANNELDOWN:
 257       return tr("Channel down");
 258     case ZERO:
 259       return "0";
 260     case ONE:
 261       return "1";
 262     case TWO:
 263       return "2";
 264     case THREE:
 265       return "3";
 266     case FOUR:
 267       return "4";
 268     case FIVE:
 269       return "5";
 270     case SIX:
 271       return "6";
 272     case SEVEN:
 273       return "7";
 274     case EIGHT:
 275       return "8";
 276     case NINE:
 277       return "9";
 278     case POWER:
 279       return tr("Power");
 280     case GO:
 281       return tr("Go");
 282     case BACK:
 283       return tr("Back");
 284     case MENU:
 285       return tr("Menu");
 286     case RED:
 287       return tr("Red");
 288     case GREEN:
 289       return tr("Green");
 290     case YELLOW:
 291       return tr("Yellow");
 292     case BLUE:
 293       return tr("Blue");
 294     case MUTE:
 295       return tr("Mute");
 296     case RADIO:
 297       return tr("Radio");
 298     case REVERSE:
 299       return tr("Reverse");
 300     case PLAY:
 301       return tr("Play");
 302     case FORWARD:
 303       return tr("Forward");
 304     case RECORD:
 305       return tr("Record");
 306     case STOP:
 307       return tr("Stop");
 308     case PAUSE:
 309       return tr("Pause");
 310     case SKIPBACK:
 311       return tr("Skip back");
 312     case SKIPFORWARD:
 313       return tr("Skip forward");
 314     case OK:
 315       return tr("Ok");
 316     case FULL:
 317       return tr("Fullscreen");
 318     case TV:
 319       return tr("TV");
 320     case VIDEOS:
 321       return tr("Videos");
 322     case MUSIC:
 323       return tr("Music");
 324     case PICTURES:
 325       return tr("Pictures");
 326     case GUIDE:
 327       return tr("Guide");
 328     case UP:
 329       return tr("Up");
 330     case DOWN:
 331       return tr("Down");
 332     case LEFT:
 333       return tr("Left");
 334     case RIGHT:
 335       return tr("Right");
 336     case PREVCHANNEL:
 337       return tr("Previous Channel");
 338     case STAR:
 339       return tr("Star");
 340     case HASH:
 341       return tr("Hash");
 342
 343     default:
 344       return NULL;
 345   }
 346 }
 347
 348 char* Remote::HCWDesc(ULLONG hcw)
 349 {
 350   char *dest,*temp;
 351   temp=(char*)CommandDesc((UCHAR)hcw);
 352   if (temp != NULL)
 353   {
 354     dest=new char[strlen(temp)+1];
 355     strcpy(dest,temp);
 356   }
 357   else
 358   {
 359     dest=new char[20];
 360     sprintf(dest,"C:%lX",(ULONG)hcw);
 361   }
 362   return dest;
 363 }
 364
 365 char *Remote::CommandTranslateStr(UCHAR command)
 366 {
 367   char *desc;
 368   int length=5;//:+\t+0
 369   int keys=0; //max 10;
 370   char *commanddesc=(char*)CommandDesc(command);
 371   if (commanddesc != NULL)
 372   {
 373     length+=strlen(commanddesc);
 374   }
 375   char *preassigneddesc=(char*)HardcodedTranslateStr(command);
 376   if (preassigneddesc != NULL)
 377   {
 378     length+=strlen(preassigneddesc);
 379   }
 380
 381   char *keydesc[10];
 382   RemoteTranslationList::const_iterator it;
 383   for (it = translist.begin(); it != translist.end(); it++)
 384   {
 385     if (it->second == command)
 386     {
 387       keydesc[keys] = HCWDesc(it->first);
 388       length += strlen(keydesc[keys])+2;
 389       keys ++;
 390       if (keys == 10) break;
 391     }
 392   }
 393
 394   desc=new char [length];
 395   char *current=desc;
 396   if (commanddesc != NULL)
 397   {
 398     current+=sprintf(current,"%s:\t ",commanddesc);
 399   }
 400   else
 401   {
 402     current+=sprintf(current,":\t ");
 403   }
 404   if (preassigneddesc != NULL)
 405   {
 406     current+=sprintf(current,"%s\t",preassigneddesc);
 407   }
 408   else
 409   {
 410     current+=sprintf(current,"\t");
 411   }
 412   for (int i = 0;i < keys; i++)
 413   {
 414     current += sprintf(current,"%s, ",keydesc[i]);
 415     delete [] keydesc[i];
 416   }
 417   return desc;
 418 }