]> git.vomp.tv Git - vompclient-marten.git/blob - remotelinux.cc
Motion Compensation, all implemented, all buggy
[vompclient-marten.git] / remotelinux.cc
1 /*
2     Copyright 2004-2005 Chris Tallon; 2012 Marten Richter
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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "remotelinux.h"
22 #include "i18n.h"
23 #include <linux/input.h>
24 #include <sys/types.h>
25
26
27 #include <errno.h>
28
29 #include <sys/stat.h>
30 #include <fcntl.h>
31
32
33
34
35 #define W_G_HCW(type,code) ( (((ULLONG)(type))<<32) | code)
36
37 #define W_HCW_KC 1 /* key code as defined by kernel for keyboard and remotes through /dev/input */
38 #define W_HCW_CEC 2 /* HDMI_CEC */
39 #define W_HCW_LIRC 3 /* remote control LIRC*/
40
41
42 RemoteLinux::RemoteLinux()
43 {
44   initted = 0;
45   curevent=0;
46   hascurevent=false;
47   signal=false;
48   tv.tv_sec = 0;
49   tv.tv_usec = 0;
50
51 }
52
53 RemoteLinux::~RemoteLinux()
54 {
55         for (unsigned int i=0; i<devices.size();i++) {
56                 close(devices[i]);
57         }
58 }
59
60 #define test_bit(input,b)  ((1 << ((b) % 8))&(input)[b / 8] )
61
62
63 int RemoteLinux::init(char* devName)
64 {
65   if (initted) return 0;
66   initted = 1;
67
68   InitKeymap();
69
70   for (int eventid=0;eventid<100;eventid++){
71           char buffer[1024];
72           sprintf(buffer,"/dev/input/event%d",eventid);
73
74
75           struct stat test_buf;
76           if (stat(buffer,&test_buf)==0) {
77                   Log::getInstance()->log("Remote", Log::NOTICE, "Probe /dev/input/event%d",eventid);
78                   // file exists
79                   unsigned long ev_type=0;
80                   int new_fd=open(buffer,O_RDONLY);
81                   if (new_fd<0) {
82                           Log::getInstance()->log("Remote", Log::NOTICE, "Can not open /dev/input/event%d",eventid);
83                           continue;
84                   }
85                   if (ioctl(new_fd, EVIOCGBIT(0, EV_MAX), &ev_type) < 0) {
86                           Log::getInstance()->log("Remote", Log::NOTICE, "Ioctl failed /dev/input/event%d %d",eventid,errno);
87                       close(new_fd);
88                   }
89                   //Now test if it generates keyboard presses
90                   if (test_bit((char*)&ev_type , EV_KEY)) {
91                           Log::getInstance()->log("Remote", Log::NOTICE, "Add /dev/input/event%d to List",eventid);
92                           devices.push_back(new_fd);
93                   } else {
94                           close(new_fd);
95                   }
96
97
98
99
100           }
101
102   }
103
104
105
106
107   return 1;
108 }
109
110 int RemoteLinux::shutdown()
111 {
112   if (!initted) return 0;
113
114   initted = 0;
115   return 1;
116 }
117
118 UCHAR RemoteLinux::getButtonPress(int waitType)
119 {
120           /* how = 0 - block
121              how = 1 - start new wait
122              how = 2 - continue wait
123              how = 3 - no wait
124           */
125
126
127           struct timeval* passToSelect = NULL;
128           int retval;
129           fd_set readfds;
130
131           if (waitType == 0)
132           {
133             passToSelect = NULL;
134           }
135           else if (waitType == 1)
136           {
137             tv.tv_sec = 1;
138             tv.tv_usec = 000000;
139             passToSelect = &tv;
140           }
141           else if (waitType == 2)
142           {
143             if ((tv.tv_sec == 0) && (tv.tv_usec == 0))  // protection in case timer = 0
144             {
145               tv.tv_sec = 1;
146               tv.tv_usec = 000000;
147             }
148             passToSelect = &tv;
149           }
150           else if (waitType == 3)
151           {
152             tv.tv_sec = 0;
153             tv.tv_usec = 0;
154             passToSelect = &tv;
155           }
156           FD_ZERO(&readfds);
157
158           int maxfd=0;
159           for (int i=0; i<devices.size();i++) {
160                   int cur_fd=devices[i];
161                   maxfd=max(cur_fd,maxfd);
162                   FD_SET(cur_fd, &readfds);
163           }
164
165
166
167           retval = select(maxfd + 1, &readfds, NULL, NULL, &tv);
168           // 0 = nothing happened
169           // 1 = data arrived (actually num of descriptors that changed)
170           // other value = signal or error
171           if (retval == 0) return NA_NONE;
172           if (retval == -1) return NA_SIGNAL;
173
174
175           for (int i=0; i<devices.size();i++) {
176                           int cur_fd=devices[i];
177                           if (FD_ISSET(cur_fd, &readfds)) {
178                                 struct input_event ev;
179                                 int count = read(cur_fd, &ev, sizeof(ev));
180                                 if (count==sizeof(ev)) {
181                                         if (ev.type==EV_KEY && ev.value==1) {
182                                                 return (UCHAR) TranslateHWC(W_G_HCW(W_HCW_KC,ev.code));
183                                         }
184                                 }
185
186                           }
187
188           }
189
190           return NA_UNKNOWN;
191   
192 }
193
194 void RemoteLinux::clearBuffer()
195 {
196           while(getButtonPress(3) != NA_NONE);
197 }
198
199 UCHAR RemoteLinux::TranslateHWCFixed(ULLONG code)
200 {
201     switch (code) 
202     {
203     case W_G_HCW(W_HCW_KC,KEY_DOWN):
204         return DOWN;
205     case W_G_HCW(W_HCW_KC,KEY_UP):
206         return UP;
207     case W_G_HCW(W_HCW_KC,KEY_LEFT):
208         return LEFT;
209     case W_G_HCW(W_HCW_KC,KEY_RIGHT):
210         return RIGHT;
211     case W_G_HCW(W_HCW_KC,KEY_M):
212         return MENU;
213     case W_G_HCW(W_HCW_KC,KEY_BACKSPACE):
214         return BACK;
215     case W_G_HCW(W_HCW_KC,KEY_ENTER):
216     case W_G_HCW(W_HCW_KC,KEY_SPACE):
217     case W_G_HCW(W_HCW_KC,KEY_OK):
218         return OK;
219     case POWER:
220         return POWER;
221     default:
222         return NA_UNKNOWN;
223     };
224 }
225
226 const char*RemoteLinux::HardcodedTranslateStr(UCHAR command)
227 {
228     switch (command) 
229     {
230     case DOWN:
231         return tr("Down");
232     case UP:
233         return tr("Up");
234     case LEFT:
235         return tr("Left");
236     case RIGHT:
237         return tr("Right");
238     case MENU:
239         return tr("M");
240     case BACK:
241         return tr("Backspace, Back");
242     case OK:
243         return tr("Return, Space");
244     default:
245         return NULL;
246     };
247     
248 }
249
250
251 void RemoteLinux::InitHWCListwithDefaults()
252 {
253     //Processing VK_Messages
254     translist[W_G_HCW(W_HCW_KC,KEY_9)] = NINE;
255     translist[W_G_HCW(W_HCW_KC,KEY_8)] = EIGHT;
256     translist[W_G_HCW(W_HCW_KC,KEY_7)] = SEVEN;
257     translist[W_G_HCW(W_HCW_KC,KEY_6)] = SIX;
258     translist[W_G_HCW(W_HCW_KC,KEY_5)] = FIVE;
259     translist[W_G_HCW(W_HCW_KC,KEY_4)] = FOUR;
260     translist[W_G_HCW(W_HCW_KC,KEY_3)] = THREE;
261     translist[W_G_HCW(W_HCW_KC,KEY_2)] = TWO;
262     translist[W_G_HCW(W_HCW_KC,KEY_1)] = ONE;
263     translist[W_G_HCW(W_HCW_KC,KEY_0)] = ZERO;
264     translist[W_G_HCW(W_HCW_KC,KEY_KPDOT)] = STAR;
265    // translist[W_G_HCW(W_HCW_KC,KEY_#)] = HASH;
266
267     translist[W_G_HCW(W_HCW_KC,KEY_KP9)] = NINE;
268     translist[W_G_HCW(W_HCW_KC,KEY_KP8)] = EIGHT;
269     translist[W_G_HCW(W_HCW_KC,KEY_KP7)] = SEVEN;
270     translist[W_G_HCW(W_HCW_KC,KEY_KP6)] = SIX;
271     translist[W_G_HCW(W_HCW_KC,KEY_KP5)] = FIVE;
272     translist[W_G_HCW(W_HCW_KC,KEY_KP4)] = FOUR;
273     translist[W_G_HCW(W_HCW_KC,KEY_KP3)] = THREE;
274     translist[W_G_HCW(W_HCW_KC,KEY_KP2)] = TWO;
275     translist[W_G_HCW(W_HCW_KC,KEY_KP1)] = ONE;
276     translist[W_G_HCW(W_HCW_KC,KEY_KP0)] = ZERO;
277
278     translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_9)] = NINE;
279         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_8)] = EIGHT;
280         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_7)] = SEVEN;
281         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_6)] = SIX;
282         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_5)] = FIVE;
283         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_4)] = FOUR;
284         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_3)] = THREE;
285         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_2)] = TWO;
286         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_1)] = ONE;
287         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_0)] = ZERO;
288         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_STAR)] = STAR;
289         translist[W_G_HCW(W_HCW_KC,KEY_NUMERIC_POUND)] = HASH;
290
291
292     translist[W_G_HCW(W_HCW_KC,KEY_J)] = GO; //j for JUMP TO instead of go to
293     translist[W_G_HCW(W_HCW_KC,KEY_R)] = RED;
294     translist[W_G_HCW(W_HCW_KC,KEY_G)] = GREEN;
295     translist[W_G_HCW(W_HCW_KC,KEY_Y)] = YELLOW;
296     translist[W_G_HCW(W_HCW_KC,KEY_B)] = BLUE;
297     //Processing Remote Style Messages
298     translist[W_G_HCW(W_HCW_KC,KEY_GREEN)] = GREEN;
299     translist[W_G_HCW(W_HCW_KC,KEY_RED)] = RED;
300     translist[W_G_HCW(W_HCW_KC,KEY_YELLOW)] = YELLOW;
301     translist[W_G_HCW(W_HCW_KC,KEY_BLUE)] = BLUE;
302     translist[W_G_HCW(W_HCW_KC,KEY_MENU)] = MENU;
303
304     translist[W_G_HCW(W_HCW_KC,KEY_RECORD)] = RECORD;
305     translist[W_G_HCW(W_HCW_KC,KEY_PLAY)] = PLAY; //Playback Televison
306     translist[W_G_HCW(W_HCW_KC,KEY_PAUSE)] = PAUSE;
307     translist[W_G_HCW(W_HCW_KC,KEY_STOP)] = STOP;
308     translist[W_G_HCW(W_HCW_KC,KEY_PLAYPAUSE)] = PLAYPAUSE;
309     translist[W_G_HCW(W_HCW_KC,KEY_P)] = PLAYPAUSE;
310     translist[W_G_HCW(W_HCW_KC,KEY_NEXT)] = SKIPFORWARD;
311     translist[W_G_HCW(W_HCW_KC,KEY_PREVIOUS)] = SKIPBACK;
312     translist[W_G_HCW(W_HCW_KC,KEY_FORWARD)] = FORWARD;
313     translist[W_G_HCW(W_HCW_KC,KEY_BACK)] = REVERSE;
314     translist[W_G_HCW(W_HCW_KC,KEY_MUTE)] = MUTE;
315     translist[W_G_HCW(W_HCW_KC,KEY_F9)] = VOLUMEUP;
316     translist[W_G_HCW(W_HCW_KC,KEY_F10)] = VOLUMEDOWN;
317     translist[W_G_HCW(W_HCW_KC,KEY_VOLUMEUP)] = VOLUMEUP;
318     translist[W_G_HCW(W_HCW_KC,KEY_VOLUMEDOWN)] = VOLUMEDOWN;
319     translist[W_G_HCW(W_HCW_KC,KEY_CHANNELUP)] = CHANNELUP;
320     translist[W_G_HCW(W_HCW_KC,KEY_CHANNELDOWN)] = CHANNELDOWN;
321     translist[W_G_HCW(W_HCW_KC,KEY_PAGEUP)] = CHANNELUP;
322     translist[W_G_HCW(W_HCW_KC,KEY_PAGEDOWN)] = CHANNELDOWN;
323
324
325 }
326
327 #define NAMETRICK(pre, code) linux_keymap[pre ## code]=  #code
328 //extracte from linux/input.h
329
330 static const char * linux_keymap[KEY_MAX+1];
331
332 void RemoteLinux::InitKeymap()
333 {
334         for (int i=0;i<KEY_MAX+1;i++) {
335                 linux_keymap[i]=NULL;
336         }
337         NAMETRICK(KEY_,RESERVED);
338         NAMETRICK(KEY_,ESC);
339         NAMETRICK(KEY_,1);
340         NAMETRICK(KEY_,2);
341         NAMETRICK(KEY_,3);
342         NAMETRICK(KEY_,4);
343         NAMETRICK(KEY_,5);
344         NAMETRICK(KEY_,6);
345         NAMETRICK(KEY_,7);
346         NAMETRICK(KEY_,8);
347         NAMETRICK(KEY_,9);
348         NAMETRICK(KEY_,0);
349         NAMETRICK(KEY_,MINUS);
350         NAMETRICK(KEY_,EQUAL);
351         NAMETRICK(KEY_,BACKSPACE);
352         NAMETRICK(KEY_,TAB);
353         NAMETRICK(KEY_,Q);
354         NAMETRICK(KEY_,W);
355         NAMETRICK(KEY_,E);
356         NAMETRICK(KEY_,R);
357         NAMETRICK(KEY_,T);
358         NAMETRICK(KEY_,Y);
359         NAMETRICK(KEY_,U);
360         NAMETRICK(KEY_,I);
361         NAMETRICK(KEY_,O);
362         NAMETRICK(KEY_,P);
363         NAMETRICK(KEY_,LEFTBRACE);
364         NAMETRICK(KEY_,RIGHTBRACE);
365         NAMETRICK(KEY_,ENTER);
366         NAMETRICK(KEY_,LEFTCTRL);
367         NAMETRICK(KEY_,A);
368         NAMETRICK(KEY_,S);
369         NAMETRICK(KEY_,D);
370         NAMETRICK(KEY_,F);
371         NAMETRICK(KEY_,G);
372         NAMETRICK(KEY_,H);
373         NAMETRICK(KEY_,J);
374         NAMETRICK(KEY_,K);
375         NAMETRICK(KEY_,L);
376         NAMETRICK(KEY_,SEMICOLON);
377         NAMETRICK(KEY_,APOSTROPHE);
378         NAMETRICK(KEY_,GRAVE);
379         NAMETRICK(KEY_,LEFTSHIFT);
380         NAMETRICK(KEY_,BACKSLASH);
381         NAMETRICK(KEY_,Z);
382         NAMETRICK(KEY_,X);
383         NAMETRICK(KEY_,C);
384         NAMETRICK(KEY_,V);
385         NAMETRICK(KEY_,B);
386         NAMETRICK(KEY_,N);
387         NAMETRICK(KEY_,M);
388         NAMETRICK(KEY_,COMMA);
389         NAMETRICK(KEY_,DOT);
390         NAMETRICK(KEY_,SLASH);
391         NAMETRICK(KEY_,RIGHTSHIFT);
392         NAMETRICK(KEY_,KPASTERISK);
393         NAMETRICK(KEY_,LEFTALT);
394         NAMETRICK(KEY_,SPACE);
395         NAMETRICK(KEY_,CAPSLOCK);
396         NAMETRICK(KEY_,F1);
397         NAMETRICK(KEY_,F2);
398         NAMETRICK(KEY_,F3);
399         NAMETRICK(KEY_,F4);
400         NAMETRICK(KEY_,F5);
401         NAMETRICK(KEY_,F6);
402         NAMETRICK(KEY_,F7);
403         NAMETRICK(KEY_,F8);
404         NAMETRICK(KEY_,F9);
405         NAMETRICK(KEY_,F10);
406         NAMETRICK(KEY_,NUMLOCK);
407         NAMETRICK(KEY_,SCROLLLOCK);
408         NAMETRICK(KEY_,KP7);
409         NAMETRICK(KEY_,KP8);
410         NAMETRICK(KEY_,KP9);
411         NAMETRICK(KEY_,KPMINUS);
412         NAMETRICK(KEY_,KP4);
413         NAMETRICK(KEY_,KP5);
414         NAMETRICK(KEY_,KP6);
415         NAMETRICK(KEY_,KPPLUS);
416         NAMETRICK(KEY_,KP1);
417         NAMETRICK(KEY_,KP2);
418         NAMETRICK(KEY_,KP3);
419         NAMETRICK(KEY_,KP0);
420         NAMETRICK(KEY_,KPDOT);
421         NAMETRICK(KEY_,F11);
422         NAMETRICK(KEY_,F12);
423         NAMETRICK(KEY_,KPENTER);
424         NAMETRICK(KEY_,RIGHTCTRL);
425         NAMETRICK(KEY_,KPSLASH);
426         NAMETRICK(KEY_,SYSRQ);
427         NAMETRICK(KEY_,RIGHTALT);
428         NAMETRICK(KEY_,LINEFEED);
429         NAMETRICK(KEY_,HOME);
430         NAMETRICK(KEY_,UP);
431         NAMETRICK(KEY_,PAGEUP);
432         NAMETRICK(KEY_,LEFT);
433         NAMETRICK(KEY_,RIGHT);
434         NAMETRICK(KEY_,END);
435         NAMETRICK(KEY_,DOWN);
436         NAMETRICK(KEY_,PAGEDOWN);
437         NAMETRICK(KEY_,INSERT);
438         NAMETRICK(KEY_,DELETE);
439         NAMETRICK(KEY_,MACRO);
440         NAMETRICK(KEY_,MUTE);
441         NAMETRICK(KEY_,VOLUMEDOWN);
442         NAMETRICK(KEY_,VOLUMEUP);
443         NAMETRICK(KEY_,POWER);
444         NAMETRICK(KEY_,KPEQUAL);
445         NAMETRICK(KEY_,KPPLUSMINUS);
446         NAMETRICK(KEY_,PLAY);
447         NAMETRICK(KEY_,PAUSE);
448         NAMETRICK(KEY_,SCALE);
449         NAMETRICK(KEY_,KPCOMMA);
450         NAMETRICK(KEY_,YEN);
451         NAMETRICK(KEY_,LEFTMETA);
452         NAMETRICK(KEY_,RIGHTMETA);
453         NAMETRICK(KEY_,COMPOSE);
454         NAMETRICK(KEY_,STOP);
455         NAMETRICK(KEY_,AGAIN);
456         NAMETRICK(KEY_,PROPS);
457         NAMETRICK(KEY_,UNDO);
458         NAMETRICK(KEY_,FRONT);
459         NAMETRICK(KEY_,COPY);
460         NAMETRICK(KEY_,OPEN);
461         NAMETRICK(KEY_,PASTE);
462         NAMETRICK(KEY_,FIND);
463         NAMETRICK(KEY_,CUT);
464         NAMETRICK(KEY_,HELP);
465         NAMETRICK(KEY_,MENU);
466         NAMETRICK(KEY_,CALC);
467         NAMETRICK(KEY_,SETUP);
468         NAMETRICK(KEY_,SLEEP);
469         NAMETRICK(KEY_,WAKEUP);
470         NAMETRICK(KEY_,FILE);
471         NAMETRICK(KEY_,SENDFILE);
472         NAMETRICK(KEY_,DELETEFILE);
473         NAMETRICK(KEY_,XFER);
474         NAMETRICK(KEY_,PROG1);
475         NAMETRICK(KEY_,PROG2);
476         NAMETRICK(KEY_,WWW);
477         NAMETRICK(KEY_,MSDOS);
478         NAMETRICK(KEY_,COFFEE);
479         NAMETRICK(KEY_,DIRECTION);
480         NAMETRICK(KEY_,CYCLEWINDOWS);
481         NAMETRICK(KEY_,MAIL);
482         NAMETRICK(KEY_,BOOKMARKS);
483         NAMETRICK(KEY_,COMPUTER);
484         NAMETRICK(KEY_,BACK);
485         NAMETRICK(KEY_,FORWARD);
486         NAMETRICK(KEY_,CLOSECD);
487         NAMETRICK(KEY_,EJECTCD);
488         NAMETRICK(KEY_,EJECTCLOSECD);
489         NAMETRICK(KEY_,NEXTSONG);
490         NAMETRICK(KEY_,PLAYPAUSE);
491         NAMETRICK(KEY_,PREVIOUSSONG);
492         NAMETRICK(KEY_,STOPCD);
493         NAMETRICK(KEY_,RECORD);
494         NAMETRICK(KEY_,REWIND);
495         NAMETRICK(KEY_,PHONE);
496         NAMETRICK(KEY_,ISO);
497         NAMETRICK(KEY_,CONFIG);
498         NAMETRICK(KEY_,HOMEPAGE);
499         NAMETRICK(KEY_,REFRESH);
500         NAMETRICK(KEY_,EXIT);
501         NAMETRICK(KEY_,MOVE);
502         NAMETRICK(KEY_,EDIT);
503         NAMETRICK(KEY_,SCROLLUP);
504         NAMETRICK(KEY_,SCROLLDOWN);
505         NAMETRICK(KEY_,KPLEFTPAREN);
506         NAMETRICK(KEY_,KPRIGHTPAREN);
507         NAMETRICK(KEY_,NEW);
508         NAMETRICK(KEY_,REDO);
509         NAMETRICK(KEY_,OK);
510         NAMETRICK(KEY_,SELECT);
511         NAMETRICK(KEY_,GOTO);
512         NAMETRICK(KEY_,CLEAR);
513         NAMETRICK(KEY_,POWER2);
514         NAMETRICK(KEY_,OPTION);
515         NAMETRICK(KEY_,INFO);
516         NAMETRICK(KEY_,TIME);
517         NAMETRICK(KEY_,VENDOR);
518         NAMETRICK(KEY_,ARCHIVE);
519         NAMETRICK(KEY_,PROGRAM);
520         NAMETRICK(KEY_,CHANNEL);
521         NAMETRICK(KEY_,FAVORITES);
522         NAMETRICK(KEY_,EPG);
523         NAMETRICK(KEY_,PVR);
524         NAMETRICK(KEY_,MHP);
525         NAMETRICK(KEY_,LANGUAGE);
526         NAMETRICK(KEY_,TITLE);
527         NAMETRICK(KEY_,SUBTITLE);
528         NAMETRICK(KEY_,ANGLE);
529         NAMETRICK(KEY_,ZOOM);
530         NAMETRICK(KEY_,MODE);
531         NAMETRICK(KEY_,KEYBOARD);
532         NAMETRICK(KEY_,SCREEN);
533         NAMETRICK(KEY_,RED);
534         NAMETRICK(KEY_,GREEN);
535         NAMETRICK(KEY_,YELLOW);
536         NAMETRICK(KEY_,BLUE);
537         NAMETRICK(KEY_,CHANNELUP);
538         NAMETRICK(KEY_,CHANNELDOWN);
539         NAMETRICK(KEY_,FIRST);
540         NAMETRICK(KEY_,LAST);
541         NAMETRICK(KEY_,AB);
542         NAMETRICK(KEY_,NEXT);
543         NAMETRICK(KEY_,RESTART);
544         NAMETRICK(KEY_,SLOW);
545         NAMETRICK(KEY_,SHUFFLE);
546         NAMETRICK(KEY_,BREAK);
547         NAMETRICK(KEY_,PREVIOUS);
548         NAMETRICK(KEY_,DIGITS);
549         NAMETRICK(KEY_,TEEN);
550         NAMETRICK(KEY_,TWEN);
551         NAMETRICK(KEY_,VIDEOPHONE);
552         NAMETRICK(KEY_,GAMES);
553         NAMETRICK(KEY_,ZOOMIN);
554         NAMETRICK(KEY_,ZOOMOUT);
555         NAMETRICK(KEY_,ZOOMRESET);
556         NAMETRICK(KEY_,DOLLAR);
557         NAMETRICK(KEY_,EURO);
558         NAMETRICK(KEY_,FRAMEBACK);
559         NAMETRICK(KEY_,FRAMEFORWARD);
560         NAMETRICK(KEY_,CONTEXT_MENU);
561         NAMETRICK(KEY_,MEDIA_REPEAT);
562         NAMETRICK(KEY_,NUMERIC_0);
563         NAMETRICK(KEY_,NUMERIC_1);
564         NAMETRICK(KEY_,NUMERIC_2);
565         NAMETRICK(KEY_,NUMERIC_3);
566         NAMETRICK(KEY_,NUMERIC_4);
567         NAMETRICK(KEY_,NUMERIC_5);
568         NAMETRICK(KEY_,NUMERIC_6);
569         NAMETRICK(KEY_,NUMERIC_7);
570         NAMETRICK(KEY_,NUMERIC_8);
571         NAMETRICK(KEY_,NUMERIC_9);
572         NAMETRICK(KEY_,NUMERIC_STAR);
573         NAMETRICK(KEY_,NUMERIC_POUND);
574
575
576
577 }
578
579
580
581 char* RemoteLinux::HCWDesc(unsigned long long hcw)
582 {
583     //Determine type
584     unsigned int type =  hcw >> 32;
585     char *rt=NULL;
586     switch(type)
587     {
588     case W_HCW_KC:{
589         unsigned int vk=(ULONG)hcw;
590         rt=new char[10];
591         const char *desc=linux_keymap[vk];
592         if (desc) {
593                 strncpy(rt,desc,9);
594         } else {
595                 sprintf(rt,"0x%x",vk);
596         }
597                   }break;
598                   //TODO
599   /*  case W_HCW_CEC:{
600         ULONG ch=(ULONG)hcw;
601         ULONG scancode=OemKeyScan(ch);
602   
603         rt=new char[10];
604         GetKeyNameText(scancode << 16,rt,10); 
605                   }break;
606     case W_HCW_LIRC:{
607         ULONG ri=(ULONG)hcw;
608         rt=new char[10];
609         sprintf(rt,"R: %X",ri);
610                   }break;*/
611
612     };
613     return rt;
614 }
615
616
617
618
619
620
621
622 /*
623 void RemoteLinux::Signal() {
624         signal=true;
625         //PulseEvent(event);
626         SetEvent(event);
627 }
628
629 void RemoteLinux::SendPower()
630 {
631
632         curevent=POWER;
633     hascurevent=true;
634         SetEvent(event);
635 }*/
636