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