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[SKIPBACK] = SKIPBACK;
 228   translist[SKIPFORWARD] = SKIPFORWARD;
 229
 230   // Old remote only
 231   translist[FULL] = FULL;
 232
 233   // New remote only
 234   translist[TV] = TV;
 235   translist[VIDEOS] = VIDEOS;
 236   translist[MUSIC] = MUSIC;
 237   translist[PICTURES] = PICTURES;
 238   translist[GUIDE] = GUIDE;
 239   translist[PREVCHANNEL] = PREVCHANNEL;
 240   translist[STAR] = STAR;
 241   translist[HASH] = HASH;
 242 }
 243
 244 const char *Remote::CommandDesc(UCHAR number)
 245 {
 246   switch (number)
 247   {
 248     case VOLUMEUP:
 249       return tr("Volume Up");
 250
 251     case VOLUMEDOWN:
 252       return tr("Volume Down");
 253     case CHANNELUP:
 254       return tr("Channel up");
 255     case CHANNELDOWN:
 256       return tr("Channel down");
 257     case ZERO:
 258       return "0";
 259     case ONE:
 260       return "1";
 261     case TWO:
 262       return "2";
 263     case THREE:
 264       return "3";
 265     case FOUR:
 266       return "4";
 267     case FIVE:
 268       return "5";
 269     case SIX:
 270       return "6";
 271     case SEVEN:
 272       return "7";
 273     case EIGHT:
 274       return "8";
 275     case NINE:
 276       return "9";
 277     case POWER:
 278       return tr("Power");
 279     case GO:
 280       return tr("Go");
 281     case BACK:
 282       return tr("Back");
 283     case MENU:
 284       return tr("Menu");
 285     case RED:
 286       return tr("Red");
 287     case GREEN:
 288       return tr("Green");
 289     case YELLOW:
 290       return tr("Yellow");
 291     case BLUE:
 292       return tr("Blue");
 293     case MUTE:
 294       return tr("Mute");
 295     case RADIO:
 296       return tr("Radio");
 297     case REVERSE:
 298       return tr("Reverse");
 299     case PLAY:
 300       return tr("Play");
 301     case FORWARD:
 302       return tr("Forward");
 303     case RECORD:
 304       return tr("Record");
 305     case STOP:
 306       return tr("Stop");
 307     case PAUSE:
 308       return tr("Pause");
 309     case SKIPBACK:
 310       return tr("Skip back");
 311     case SKIPFORWARD:
 312       return tr("Skip forward");
 313     case OK:
 314       return tr("Ok");
 315     case FULL:
 316       return tr("Fullscreen");
 317     case TV:
 318       return tr("TV");
 319     case VIDEOS:
 320       return tr("Videos");
 321     case MUSIC:
 322       return tr("Music");
 323     case PICTURES:
 324       return tr("Pictures");
 325     case GUIDE:
 326       return tr("Guide");
 327     case UP:
 328       return tr("Up");
 329     case DOWN:
 330       return tr("Down");
 331     case LEFT:
 332       return tr("Left");
 333     case RIGHT:
 334       return tr("Right");
 335     case PREVCHANNEL:
 336       return tr("Previous Channel");
 337     case STAR:
 338       return tr("Star");
 339     case HASH:
 340       return tr("Hash");
 341
 342     default:
 343       return NULL;
 344   }
 345 }
 346
 347 char* Remote::HCWDesc(ULLONG hcw)
 348 {
 349   char *dest,*temp;
 350   temp=(char*)CommandDesc((UCHAR)hcw);
 351   if (temp != NULL)
 352   {
 353     dest=new char[strlen(temp)+1];
 354     strcpy(dest,temp);
 355   }
 356   else
 357   {
 358     dest=new char[20];
 359     sprintf(dest,"C:%lX",(ULONG)hcw);
 360   }
 361   return dest;
 362 }
 363
 364 char *Remote::CommandTranslateStr(UCHAR command)
 365 {
 366   char *desc;
 367   int length=5;//:+\t+0
 368   int keys=0; //max 10;
 369   char *commanddesc=(char*)CommandDesc(command);
 370   if (commanddesc != NULL)
 371   {
 372     length+=strlen(commanddesc);
 373   }
 374   char *preassigneddesc=(char*)HardcodedTranslateStr(command);
 375   if (preassigneddesc != NULL)
 376   {
 377     length+=strlen(preassigneddesc);
 378   }
 379
 380   char *keydesc[10];
 381   RemoteTranslationList::const_iterator it;
 382   for (it = translist.begin(); it != translist.end(); it++)
 383   {
 384     if (it->second == command)
 385     {
 386       keydesc[keys] = HCWDesc(it->first);
 387       length += strlen(keydesc[keys])+2;
 388       keys ++;
 389       if (keys == 10) break;
 390     }
 391   }
 392
 393   desc=new char [length];
 394   char *current=desc;
 395   if (commanddesc != NULL)
 396   {
 397     current+=sprintf(current,"%s:\t ",commanddesc);
 398   }
 399   else
 400   {
 401     current+=sprintf(current,":\t ");
 402   }
 403   if (preassigneddesc != NULL)
 404   {
 405     current+=sprintf(current,"%s\t",preassigneddesc);
 406   }
 407   else
 408   {
 409     current+=sprintf(current,"\t");
 410   }
 411   for (int i = 0;i < keys; i++)
 412   {
 413     current += sprintf(current,"%s, ",keydesc[i]);
 414     delete [] keydesc[i];
 415   }
 416   return desc;
 417 }