inputwin.cc

   1 /*
   2     Copyright 2004-2020 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, see <https://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "vompreswin.h"
  21 #include "i18n.h"
  22 #include "log.h"
  23 #include "inputwin.h"
  24
  25 #define W_G_HCW(type,code) ( (((ULLONG)(type))<<32) | code)
  26
  27 #define W_HCW_VK 1 /* virtual key */
  28 #define W_HCW_AP 2 /* App command */
  29 #define W_HCW_RI 3 /* remote control */
  30 #define W_HCW_CH 4 /* char */
  31
  32 const char* InputWin::myModName = "InputWin";
  33
  34 InputWin::InputWin()
  35 {
  36 }
  37
  38 InputWin::~InputWin()
  39 {
  40 }
  41
  42 bool InputWin::init()
  43 {
  44   if (initted) return false;
  45   initted = true;
  46   event = CreateEvent(NULL, /*FALSE*/TRUE, FALSE, NULL);
  47   return true;
  48 }
  49
  50 void InputWin::shutdown()
  51 {
  52   if (!initted) return;
  53   Log::getInstance()->log("InputWin", Log::DEBUG, "Shutdown called");
  54   CloseHandle(event);
  55   initted = false;
  56 }
  57
  58 /*
  59 UCHAR RemoteWin::getButtonPress(int waitType)
  60 {
  61   / * how = 0 - block
  62      how = 1 - start new wait
  63      how = 2 - continue wait
  64      how = 3 - no wait
  65   * /
  66   DWORD wait;
  67
  68
  69   if (hascurevent) {
  70           UCHAR temp=curevent;
  71       hascurevent=false;
  72
  73           return temp;
  74   }
  75   if (waitType==3) {
  76           return NA_NONE;
  77   }
  78   if (waitType==0) {
  79           wait=INFINITE;
  80   } else { //We do not distingish between 2 and 3
  81           wait=1000;
  82
  83   }
  84   WaitForSingleObject(event,wait);
  85   ResetEvent(event);
  86   if (!hascurevent) {
  87           if (signal) {
  88                   signal=false;
  89                   return NA_SIGNAL; //Since we have no signals on windows, we simulate this
  90           } else {
  91                   return NA_NONE;
  92           }
  93   }
  94   UCHAR temp2=curevent;
  95   hascurevent=false;
  96   return temp2;
  97
  98 }
  99 */
 100
 101 UCHAR InputWin::TranslateHWCFixed(HWC_TYPE code)
 102 {
 103   switch (code)
 104   {
 105     case W_G_HCW(W_HCW_VK,VK_DOWN):
 106       return DOWN;
 107     case W_G_HCW(W_HCW_VK,VK_UP):
 108       return UP;
 109     case W_G_HCW(W_HCW_VK,VK_LEFT):
 110       return LEFT;
 111     case W_G_HCW(W_HCW_VK,VK_RIGHT):
 112       return RIGHT;
 113     case W_G_HCW(W_HCW_CH,'m'):
 114       return MENU;
 115     case W_G_HCW(W_HCW_VK,VK_BACK):
 116       return BACK;
 117     case W_G_HCW(W_HCW_VK,VK_RETURN):
 118     case W_G_HCW(W_HCW_VK,VK_SPACE):
 119       return OK;
 120     /* Menu IDs, no sense to make it user selectable */
 121     case W_G_HCW(W_HCW_AP,APPCOMMAND_BROWSER_BACKWARD):
 122             return BACK;
 123           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_CHANNEL_DOWN):
 124                   return CHANNELDOWN;
 125           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_CHANNEL_UP):
 126                   return CHANNELUP;
 127           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_FAST_FORWARD):
 128                   return FORWARD;
 129           case W_G_HCW(W_HCW_AP,APPCOMMAND_VOLUME_MUTE):
 130                   return MUTE;
 131           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_PAUSE):
 132                   return PAUSE;
 133           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_PLAY):
 134                   return PLAY;
 135           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_RECORD):
 136                   return RECORD;
 137           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_PREVIOUSTRACK):
 138                   return SKIPBACK;
 139           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_REWIND):
 140                   return REVERSE;
 141           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_NEXTTRACK):
 142                   return SKIPFORWARD;
 143           case W_G_HCW(W_HCW_AP,APPCOMMAND_MEDIA_STOP):
 144                   return STOP;
 145           case W_G_HCW(W_HCW_AP,APPCOMMAND_VOLUME_DOWN):
 146                   return VOLUMEDOWN;
 147           case W_G_HCW(W_HCW_AP,APPCOMMAND_VOLUME_UP):
 148                   return VOLUMEUP;
 149           case W_G_HCW(W_HCW_AP,VOMP_YELLOW):
 150                   return YELLOW;
 151           case W_G_HCW(W_HCW_AP,VOMP_BLUE):
 152                   return BLUE;
 153           case W_G_HCW(W_HCW_AP,VOMP_RED):
 154                   return RED;
 155           case W_G_HCW(W_HCW_AP,VOMP_GREEN):
 156                   return GREEN;
 157           case W_G_HCW(W_HCW_AP,VOMP_ENTER):
 158                   return OK;
 159           case W_G_HCW(W_HCW_AP,VOMP_CANCEL):
 160                   return BACK;
 161           case W_G_HCW(W_HCW_AP,VOMP_UP):
 162                   return UP;
 163           case W_G_HCW(W_HCW_AP,VOMP_DOWN):
 164                   return DOWN;
 165           case W_G_HCW(W_HCW_AP,VOMP_LEFT):
 166                   return LEFT;
 167           case W_G_HCW(W_HCW_AP,VOMP_RIGHT):
 168                   return RIGHT;
 169     case POWER:
 170         return POWER;
 171     default:
 172         return NA_UNKNOWN;
 173     }
 174 }
 175
 176 const char* InputWin::getHardCodedHardwareKeyNameForVompKey(UCHAR vompKey)
 177 {
 178     switch (vompKey)
 179     {
 180     case DOWN:
 181         return tr("Down");
 182     case UP:
 183         return tr("Up");
 184     case LEFT:
 185         return tr("Left");
 186     case RIGHT:
 187         return tr("Right");
 188     case MENU:
 189         return tr("M");
 190     case BACK:
 191         return tr("Backspace, Back");
 192     case OK:
 193         return tr("Return, Space");
 194     case CHANNELDOWN:
 195         return tr("Insrt, C+Insrt, Pg down");
 196     case CHANNELUP:
 197         return tr("+, C++, Pg up");
 198     case VOLUMEUP:
 199         return "F10";
 200     case VOLUMEDOWN:
 201         return "F9";
 202     case POWER:
 203         return "Esc, A+F4";
 204     case MUTE:
 205         return "F8";
 206     case REVERSE:
 207         return"S+C+B";
 208     case FORWARD:
 209         return "S+C+F";
 210     case SKIPBACK:
 211         return "C+B";
 212     case SKIPFORWARD:
 213         return "C+F";
 214     case PLAY:
 215         return "S+P";
 216     case STOP:
 217         return "C+S";
 218     case PAUSE:
 219         return "C+P";
 220     default:
 221         return NULL;
 222     }
 223 }
 224
 225 void InputWin::InitHWCListwithDefaults()
 226 {
 227     //Processing VK_Messages
 228     translist[W_G_HCW(W_HCW_CH,'9')] = NINE;
 229     translist[W_G_HCW(W_HCW_CH,'8')] = EIGHT;
 230     translist[W_G_HCW(W_HCW_CH,'7')] = SEVEN;
 231     translist[W_G_HCW(W_HCW_CH,'6')] = SIX;
 232     translist[W_G_HCW(W_HCW_CH,'5')] = FIVE;
 233     translist[W_G_HCW(W_HCW_CH,'4')] = FOUR;
 234     translist[W_G_HCW(W_HCW_CH,'3')] = THREE;
 235     translist[W_G_HCW(W_HCW_CH,'2')] = TWO;
 236     translist[W_G_HCW(W_HCW_CH,'1')] = ONE;
 237     translist[W_G_HCW(W_HCW_CH,'0')] = ZERO;
 238     translist[W_G_HCW(W_HCW_CH,'*')] = STAR;
 239     translist[W_G_HCW(W_HCW_CH,'#')] = HASH;
 240     translist[W_G_HCW(W_HCW_CH,'j')] = GO; //j for JUMP TO instead of go to
 241     translist[W_G_HCW(W_HCW_CH,'r')] = RED;
 242     translist[W_G_HCW(W_HCW_CH,'g')] = GREEN;
 243     translist[W_G_HCW(W_HCW_CH,'y')] = YELLOW;
 244     translist[W_G_HCW(W_HCW_CH,'b')] = BLUE;
 245     //Processing RI Messages
 246     translist[W_G_HCW(W_HCW_RI,0x35c)] = GREEN;
 247     translist[W_G_HCW(W_HCW_RI,0x35b)] = RED;
 248     translist[W_G_HCW(W_HCW_RI,0x35d)] = YELLOW;
 249     translist[W_G_HCW(W_HCW_RI,0x35e)] = BLUE;
 250     translist[W_G_HCW(W_HCW_RI,0x30d)] = MENU; //MCE Button, used for Menu
 251     translist[W_G_HCW(W_HCW_RI,0x348)] = RECORD; //Record Television
 252     translist[W_G_HCW(W_HCW_RI,0x325)] = PLAY; //Playback Televison
 253     translist[W_G_HCW(W_HCW_RI,0x324)] = PLAY; //Playback DVD
 254     translist[W_G_HCW(W_HCW_RI,0x209)] = OK; //Properties
 255     translist[W_G_HCW(W_HCW_RI,0x35a)] = OK; //Teletext?
 256 }
 257
 258 std::string InputWin::getHardwareKeyName(HWC_TYPE hardwareKey)
 259 {
 260     //Determine type
 261     ULONG type = hardwareKey >> 32;
 262     char rt[10];
 263
 264     switch(type)
 265     {
 266       case W_HCW_VK:
 267           {
 268         ULONG vk = (ULONG)hardwareKey;
 269         ULONG scancode = MapVirtualKey(vk,0);
 270         GetKeyNameText(scancode << 16, rt, 10);
 271                 break;
 272       }
 273       case W_HCW_CH:
 274           {
 275         ULONG ch = (ULONG)hardwareKey;
 276         ULONG scancode = OemKeyScan(ch);
 277         GetKeyNameText(scancode << 16, rt, 10);
 278                 break;
 279           }
 280       case W_HCW_RI:
 281           {
 282         ULONG ri = (ULONG)hardwareKey;
 283         sprintf(rt, "R: %X", ri);
 284                 break;
 285           }
 286     }
 287
 288         std::string retval = rt;
 289         return retval;
 290 }
 291
 292 int InputWin::ReceiveButtonVK(UINT button)
 293 {
 294 /*      UCHAR pb=NA_NONE;
 295         //should we use a translation table ? No APPCOMMAND iS DWORD!
 296         switch (button) { //Processing VK_Messages
 297         case VK_DOWN:
 298                 pb=DOWN; break;
 299         case VK_RETURN:
 300         case VK_SPACE:
 301                 pb=OK;break;
 302         case VK_LEFT:
 303                 pb=LEFT;break;
 304         case '9':
 305         case VK_NUMPAD9:
 306                 pb=NINE;break;
 307         case '8':
 308         case VK_NUMPAD8:
 309                 pb=EIGHT;break;
 310         case '7':
 311         case VK_NUMPAD7:
 312                 pb=SEVEN;break;
 313         case '6':
 314         case VK_NUMPAD6:
 315                 pb=SIX;break;
 316         case '5':
 317         case VK_NUMPAD5:
 318                 pb=FIVE;break;
 319         case '4':
 320         case VK_NUMPAD4:
 321                 pb=FOUR;break;
 322         case '3':
 323         case VK_NUMPAD3:
 324                 pb=THREE;break;
 325         case '2':
 326         case VK_NUMPAD2:
 327                 pb=TWO;break;
 328         case '1':
 329         case VK_NUMPAD1:
 330                 pb=ONE;break;
 331         case '0':
 332         case VK_NUMPAD0:
 333                 pb=ZERO;break;
 334         case VK_RIGHT:
 335                 pb=RIGHT;break;
 336         case VK_UP:
 337                 pb=UP;break;
 338         case VK_MULTIPLY:
 339                 pb=STAR;break;
 340         case 'J'://j for JUMP TO instead of go to
 341                 pb=GO;break;
 342         //case VK_ESCAPE:
 343         //      pb=POWER;break;
 344         case VK_BACK:
 345                 pb=BACK;break;
 346         case 'M':
 347                 pb=MENU;break;
 348         case 'R':
 349                 pb=RED;break;
 350         case 'G':
 351                 pb=GREEN;break;
 352         case 'Y':
 353                 pb=YELLOW;break;
 354         case 'B':
 355                 pb=BLUE; break;
 356
 357
 358         }; //All other commands are process via APPCOMMAND_MESSAGES
 359         if (pb==NA_NONE) return 0;*/
 360
 361   UCHAR pb = TranslateHWC(W_G_HCW(W_HCW_VK,button));
 362   if (pb==NA_UNKNOWN || pb==NA_NONE) return 0;
 363   sendInputKey(pb);
 364   return 1;
 365
 366   /*
 367   curevent=pb;
 368     hascurevent=true;
 369         //PulseEvent(event);
 370         SetEvent(event);
 371         return 1;  */
 372 }
 373
 374 int InputWin::ReceiveButtonCH(UINT button)
 375 {
 376   UCHAR pb = TranslateHWC(W_G_HCW(W_HCW_CH,button));
 377   if (pb==NA_UNKNOWN || pb==NA_NONE) return 0;
 378   sendInputKey(pb);
 379   return 1;
 380
 381
 382   /*
 383   curevent=pb;
 384     hascurevent=true;
 385         //PulseEvent(event);
 386         SetEvent(event);
 387         return 1; */
 388 }
 389
 390 int InputWin::ReceiveButtonAP(UINT button)
 391 {
 392 /*      UCHAR pb=NA_NONE;
 393         //should we use a translation table ? No APPCOMMAND iS DWORD!
 394         switch (button) { //Processing VK_Messages
 395         case APPCOMMAND_BROWSER_BACKWARD:
 396                 pb=BACK;break;
 397         case APPCOMMAND_MEDIA_CHANNEL_DOWN:
 398                 pb=CHANNELDOWN;break;
 399         case APPCOMMAND_MEDIA_CHANNEL_UP:
 400                 pb=CHANNELUP;break;
 401         case APPCOMMAND_MEDIA_FAST_FORWARD:
 402                 pb=FORWARD;break;
 403         case APPCOMMAND_VOLUME_MUTE:
 404                 pb=MUTE;break;
 405         case APPCOMMAND_MEDIA_PAUSE:
 406                 pb=PAUSE;break;
 407         case APPCOMMAND_MEDIA_PLAY:
 408                 pb=PLAY;break;
 409         case APPCOMMAND_MEDIA_RECORD:
 410                 pb=RECORD;break;
 411         case APPCOMMAND_MEDIA_PREVIOUSTRACK:
 412                 pb=SKIPBACK;break;
 413         case APPCOMMAND_MEDIA_REWIND:
 414                 pb=REVERSE;break;
 415         case APPCOMMAND_MEDIA_NEXTTRACK:
 416                 pb=SKIPFORWARD;break;
 417         case APPCOMMAND_MEDIA_STOP:
 418                 pb=STOP;break;
 419         case APPCOMMAND_VOLUME_DOWN:
 420                 pb=VOLUMEDOWN;break;
 421         case APPCOMMAND_VOLUME_UP:
 422                 pb=VOLUMEUP;break;
 423         case VOMP_YELLOW:
 424                 pb=YELLOW; break;
 425         case VOMP_BLUE:
 426                 pb=BLUE;break;
 427         case VOMP_RED:
 428                 pb=RED;break;
 429         case VOMP_GREEN:
 430                 pb=GREEN;break;
 431         case VOMP_ENTER:
 432                 pb=OK;break;
 433         case VOMP_CANCEL:
 434                 pb=BACK;break;
 435         case VOMP_UP:
 436                 pb=UP;break;
 437         case VOMP_DOWN:
 438                 pb=DOWN;break;
 439         case VOMP_LEFT:
 440                 pb=LEFT;break;
 441         case VOMP_RIGHT:
 442                 pb=RIGHT;break;
 443         };*/
 444
 445         //if (pb==NA_NONE) return 0;
 446
 447
 448   UCHAR pb = TranslateHWC(W_G_HCW(W_HCW_AP,button));
 449   if (pb==NA_UNKNOWN || pb==NA_NONE) return 0;
 450   sendInputKey(pb);
 451   return 1;
 452
 453   /*
 454   curevent=pb;
 455     hascurevent=true;
 456         //PulseEvent(event);
 457         SetEvent(event);
 458         return 1; */
 459 }
 460
 461 int InputWin::ReceiveButtonRI(UINT button)
 462 {
 463         //UCHAR pb=NA_NONE;
 464         //Raw Input
 465         /* Note Codes above 0x29c are not listed in the specs on usb.org
 466            therefore they are used by try, they might be device dependent
 467            thus please supply codes of your remote control */
 468 /*      switch (button) { //Processing VK_Messages
 469         case 0x35c: //Green
 470                 pb=GREEN;break;
 471         case 0x35b: //Red
 472                 pb=RED;break;
 473         case 0x35d: //Yellow
 474                 pb=YELLOW;break;
 475         case 0x35e: //Blue
 476                 pb=BLUE;break;
 477         case 0x30d: //MCE Button, used for Menu
 478                 pb=MENU;break;
 479         case 0x348: //Record Television
 480                 pb=RECORD;break;
 481         case 0x28d: //Attach File Mmh, how should we assign this
 482                 pb=NA_NONE;break;
 483         case 0x325: //Playback Televison
 484                 pb=PLAY;break;
 485         case 0x324: //Playback DVD
 486                 pb=PLAY;break;
 487         case 0x209: //Properties
 488         case 0x35a: //Teletext?
 489                 pb=OK;break;
 490
 491
 492         };
 493         if (pb==NA_NONE) return 0;*/
 494
 495   UCHAR pb = TranslateHWC(W_G_HCW(W_HCW_RI,button));
 496   if (pb==NA_UNKNOWN || pb==NA_NONE) return 0;
 497   sendInputKey(pb);
 498   return 1;
 499
 500   /*
 501   curevent=pb;
 502     hascurevent=true;
 503         //PulseEvent(event);
 504         SetEvent(event);
 505         return 1; */
 506 }
 507
 508 /*
 509 void InputWin::Signal()
 510 {
 511         signal = true;
 512         //PulseEvent(event);
 513         SetEvent(event);
 514 }
 515 */