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