git.maemo.org Git - pierogi/blob - keysets/philips.cpp

   1 #include "philips.h"
   2 #include "protocols/rc5protocol.h"
   3 #include "protocols/rc6protocol.h"
   4 #include "protocols/necprotocol.h"
   5
   6 PhilipsTV1::PhilipsTV1(
   7   unsigned int index)
   8   : PIRKeysetMetaData(
   9       "TV Keyset 1",
  10       Philips_Make,
  11       index)
  12 {
  13   addControlledDevice(Philips_Make, "HV92", TV_Device);
  14   addControlledDevice(Philips_Make, "15PF4121", TV_Device);
  15 }
  16
  17
  18 void PhilipsTV1::populateProtocol(
  19   QObject *guiObject)
  20 {
  21   if (threadableProtocol)
  22   {
  23     // If the pointer is not null, the keyset must already be populated.
  24     return;
  25   }
  26
  27   threadableProtocol = new RC5Protocol(guiObject, index);
  28
  29   addKey("UP", Up_Key, 0x0010, 13);
  30   addKey("DOWN", Down_Key, 0x0011, 13);
  31   addKey("MENU", Menu_Key, 0x0012, 13);
  32   addKey("exit", Exit_Key, 0x0013, 13);
  33   addKey("LEFT", Left_Key, 0x0015, 13);
  34   addKey("RIGHT", Right_Key, 0x0016, 13);
  35 //  addKey("TELETEXT", Teletext_Key, 0x0017, 13);
  36   addKey("PICTURE_SETTINGS", PictureMode_Key, 0x002B, 13);
  37   addKey("SOUND_SETTINGS", SoundMode_Key, 0x002C, 13);
  38   addKey("GAME", Unmapped_Key, 0x002E, 13);
  39   addKey("fav", Favorites_Key, 0x0039, 13);
  40   addKey("SCREEN_WIDTH", AspectRatio_Key, 0x003E, 13); // "format"
  41   addKey("RED", Red_Key, 0x00C8, 13);
  42   addKey("YELLOW", Yellow_Key, 0x00F1, 13); // "radio"
  43   addKey(".", Unmapped_Key, 0x00F8, 13);
  44   addKey("Cinema", Unmapped_Key, 0x00F9, 13);
  45   addKey("GREEN", Green_Key, 0x00FB, 13);
  46
  47   addKey("0", Zero_Key, 0x1000, 13);
  48   addKey("1", One_Key, 0x1001, 13);
  49   addKey("2", Two_Key, 0x1002, 13);
  50   addKey("3", Three_Key, 0x1003, 13);
  51   addKey("4", Four_Key, 0x1004, 13);
  52   addKey("5", Five_Key, 0x1005, 13);
  53   addKey("6", Six_Key, 0x1006, 13);
  54   addKey("7", Seven_Key, 0x1007, 13);
  55   addKey("8", Eight_Key, 0x1008, 13);
  56   addKey("9", Nine_Key, 0x1009, 13);
  57   addKey("1-", DoubleDigit_Key, 0x100A, 13); // -/--
  58   addKey("100", PlusOneHundred_Key, 0x100A, 13);
  59   addKey("TV-Dash", Dash_Key, 0x100A, 13);
  60   addKey("CP", Unmapped_Key, 0x100B, 13); // "C/P"
  61   addKey("ON/OFF", Power_Key, 0x100C, 13);
  62   addKey("MUTE", Mute_Key, 0x100D, 13);
  63   addKey("pp", PrevChannel_Key, 0x100E, 13); // "GREEN"
  64   addKey("INFO", Info_Key, 0x100F, 13); // "+", "OSD"
  65
  66   addKey("VOL+", VolumeUp_Key, 0x1010, 13);
  67   addKey("VOL-", VolumeDown_Key, 0x1011, 13);
  68   addKey("BRIGHTNESS_UP", BrightnessUp_Key, 0x1012, 13);
  69   addKey("BRIGHTNESS_DOWN", BrightnessDown_Key, 0x1013, 13);
  70   addKey("CONTRAST_UP", ContrastUp_Key, 0x1014, 13);
  71   addKey("CONTRAST_DOWN", ContrastDown_Key, 0x1015, 13);
  72   addKey("BASS_UP", BassUp_Key, 0x1016, 13);
  73   addKey("BASS_DOWN", BassDown_Key, 0x1017, 13);
  74   addKey("TREBLE_UP", TrebleUp_Key, 0x1018, 13);
  75   addKey("TREBLE_DOWN", TrebleDown_Key, 0x1019, 13);
  76   addKey("BALANCE_RIGHT", BalanceRight_Key, 0x101A, 13);
  77   addKey("BALANCE_LEFT", BalanceLeft_Key, 0x101B, 13);
  78   addKey("TT_OUT", Unmapped_Key, 0x101D, 13);
  79   addKey("TT_PLAY", TeletextReveal_Key, 0x101E, 13);
  80
  81   addKey("P+", ChannelUp_Key, 0x1020, 13);
  82   addKey("P-", ChannelDown_Key, 0x1021, 13);
  83   addKey("SURF", Unmapped_Key, 0x1022, 13);
  84   addKey("I/II", Audio_Key, 0x1023, 13); // "TEXT_REVEAL", "Stereo"
  85   addKey("EXPAND", Surround_Key, 0x1024, 13); // "STEREO", "spatial"
  86   addKey("TIMER", Sleep_Key, 0x1026, 13); // "POWER-OFF", "sleep"
  87   addKey("PLAY", Play_Key, 0x1028, 13);
  88 //  addKey("CENTER", Unmapped_Key, 0x1029, 13); // "TEXT_STOP_SEQUENCE", etc.
  89   addKey("TT_STOP", TeletextHold_Key, 0x1029, 13);
  90   addKey("TEXT_CLOCK", TeletextTime_Key, 0x102A, 13); // "time", "TT_TIME"
  91   addKey("TEXT_ENLARGE", TeletextSize_Key, 0x102B, 13); // "Reduce_Teletext"
  92   addKey("TT_INFO", Unmapped_Key, 0x102C, 13); // "TELETEXT_ADDINFO"
  93   addKey("TT_X", TeletextOff_Key, 0x102D, 13); // "TELETEXT_OFF"
  94   addKey("TT_MIX", Unmapped_Key, 0x102E, 13);
  95   addKey("BACK", Unmapped_Key, 0x102F, 13);
  96
  97   addKey("vcr_rewind", Rewind_Key, 0x1032, 13);
  98   addKey("REVERSE", Unmapped_Key, 0x1033, 13);
  99   addKey("vcr_fastforward", FastForward_Key, 0x1034, 13);
 100   addKey("FORWARD", Unmapped_Key, 0x1035, 13);
 101   addKey("STOP", Stop_Key, 0x1036, 13);
 102   addKey("RECORD", Record_Key, 0x1037, 13);
 103   addKey("AV", Input_Key, 0x1038, 13); // "EXT", "SOURCE"
 104   addKey("TELETEXT", Teletext_Key, 0x103C, 13);
 105   addKey("TEXT_TV", TeletextAndTV_Key, 0x103C, 13); // "TELETEXT"
 106 //  addKey("TT_TV", TeletextAndTV_Key, 0x103F, 13);
 107
 108   addKey("MY_AUDIO", Unmapped_Key, 0x10D2, 13);
 109   addKey("PAY-TV_UP", Unmapped_Key, 0x10DC, 13);
 110   addKey("PAY-TV_DOWN", Unmapped_Key, 0x10DD, 13);
 111   addKey("RADIO_UP", Unmapped_Key, 0x10DE, 13);
 112   addKey("RADIO_DOWN", Unmapped_Key, 0x10DF, 13);
 113   addKey("ambilight_power", Unmapped_Key, 0x10E3, 13);
 114   addKey("ambilight_mode", Unmapped_Key, 0x10E4, 13);
 115   addKey("BLUE", Blue_Key, 0x10F9, 13);
 116
 117   // The media keys are not well described!  -- config file 5373
 118   addKey("FAST_BACK", Unmapped_Key, 0x116F, 13);
 119   addKey("PLAY_3", Unmapped_Key, 0x1168, 13);
 120   addKey("FAST_FORWARD", Unmapped_Key, 0x1175, 13);
 121   addKey("DOWN", Unmapped_Key, 0x1176, 13);
 122   addKey("SKIP", Unmapped_Key, 0x1177, 13);
 123 }
 124
 125
 126 PhilipsTV1a::PhilipsTV1a(
 127   unsigned int index)
 128   : PhilipsTV1(index)
 129 {
 130   setKeysetName("TV Keyset 1a");
 131
 132   addControlledDevice(Philips_Make, "17PT1563", TV_Device);
 133 }
 134
 135
 136 void PhilipsTV1a::populateProtocol(
 137   QObject *guiObject)
 138 {
 139   if (threadableProtocol)
 140   {
 141     // If the pointer is not null, the keyset must already be populated.
 142     return;
 143   }
 144
 145   PhilipsTV1::populateProtocol(guiObject);
 146
 147   addKey("TIMER", Sleep_Key, 0x002D, 13);
 148 }
 149
 150
 151 PhilipsTV1b::PhilipsTV1b(
 152   unsigned int index)
 153   : PhilipsTV1(index)
 154 {
 155   setKeysetName("TV Keyset 1b");
 156
 157   addControlledDevice(Philips_Make, "29PT5507", TV_Device);
 158 }
 159
 160
 161 void PhilipsTV1b::populateProtocol(
 162   QObject *guiObject)
 163 {
 164   if (threadableProtocol)
 165   {
 166     // If the pointer is not null, the keyset must already be populated.
 167     return;
 168   }
 169
 170   PhilipsTV1::populateProtocol(guiObject);
 171
 172   addKey("radio", Unmapped_Key, 0x00F1, 13);
 173   addKey("sound", Unmapped_Key, 0x1014, 13);
 174   addKey("screen", Unmapped_Key, 0x1015, 13);
 175   addKey("rec", Record_Key, 0x002B, 13);
 176   addKey("rewind", Rewind_Key, 0x002C, 13);
 177   addKey("stop", Stop_Key, 0x002D, 13);
 178   addKey("play", Play_Key, 0x002E, 13);
 179 }
 180
 181
 182 PhilipsTV1c::PhilipsTV1c(
 183   unsigned int index)
 184   : PhilipsTV1(index)
 185 {
 186   setKeysetName("TV Keyset 1c");
 187 }
 188
 189
 190 void PhilipsTV1c::populateProtocol(
 191   QObject *guiObject)
 192 {
 193   if (threadableProtocol)
 194   {
 195     // If the pointer is not null, the keyset must already be populated.
 196     return;
 197   }
 198
 199   PhilipsTV1::populateProtocol(guiObject);
 200
 201   addKey("spatial", Surround_Key, 0x1024, 13);
 202   addKey("stereo", Audio_Key, 0x1023, 13);
 203   addKey("dbb", Unmapped_Key, 0x1016, 13); // dynamic bass boost?
 204 }
 205
 206
 207 PhilipsTV1d::PhilipsTV1d(
 208   unsigned int index)
 209   : PhilipsTV1(index)
 210 {
 211   setKeysetName("TV Keyset 1d");
 212
 213   addControlledDevice(Philips_Make, "47PFL7603D", TV_Device);
 214   addControlledDevice(Philips_Make, "14PT1562/00", TV_Device);
 215   addControlledDevice(Philips_Make, "32PW9528/12", TV_Device);
 216 }
 217
 218
 219 void PhilipsTV1d::populateProtocol(
 220   QObject *guiObject)
 221 {
 222   if (threadableProtocol)
 223   {
 224     // If the pointer is not null, the keyset must already be populated.
 225     return;
 226   }
 227
 228   PhilipsTV1::populateProtocol(guiObject);
 229
 230   addKey("NOTE_BUTTON", Unmapped_Key, 0x1014, 13); // "Tune"
 231   addKey("RADIO_BUTTON", Unmapped_Key, 0x00F1, 13);
 232   addKey("RED", Red_Key, 0x002B, 13);
 233   addKey("GREEN", Green_Key, 0x002C, 13);
 234   addKey("YELLOW", Yellow_Key, 0x002D, 13);
 235   addKey("BLUE", Blue_Key, 0x002E, 13);
 236   addKey("prev", PrevChannel_Key, 0x1022, 13);
 237   addKey("red-", Unmapped_Key, 0x000E, 13); // "CURSOR -"
 238   addKey("blue+", Unmapped_Key, 0x000D, 13); // "CURSOR +"
 239   addKey("pip", PIP_Key, 0x0018, 13);
 240   addKey("pip_move", PIPMove_Key, 0x0019, 13);
 241   addKey("pip_source", PIPSource_Key, 0x001F, 13);
 242   addKey("pip_still", PIPPause_Key, 0x0025, 13);
 243   addKey("pip_switch", PIPSwap_Key, 0x001A, 13);
 244   addKey("pip_prog+", PIPChannelUp_Key, 0x0026, 13);
 245   addKey("pip_prog-", PIPChannelDown_Key, 0x0027, 13);
 246   addKey("tvtxt_index", TeletextIndex_Key, 0x002F, 13);
 247 }
 248
 249
 250 PhilipsTV1e::PhilipsTV1e(
 251   unsigned int index)
 252   : PhilipsTV1(index)
 253 {
 254   setKeysetName("TV Keyset 1e");
 255
 256   addControlledDevice(Philips_Make, "28PT4455", TV_Device);
 257   addControlledDevice(Philips_Make, "21PT2265", TV_Device);
 258 }
 259
 260
 261 void PhilipsTV1e::populateProtocol(
 262   QObject *guiObject)
 263 {
 264   if (threadableProtocol)
 265   {
 266     // If the pointer is not null, the keyset must already be populated.
 267     return;
 268   }
 269
 270   PhilipsTV1::populateProtocol(guiObject);
 271
 272   addKey("smart_audio", SoundMode_Key, 0x10CB, 13);
 273   addKey("smart_video", PictureMode_Key, 0x10CA, 13);
 274   addKey("teletext/ok", Select_Key, 0x103C, 13);
 275   addKey("red", Red_Key, 0x002B, 13);
 276   addKey("green", Green_Key, 0x002C, 13);
 277   addKey("yellow", Yellow_Key, 0x002D, 13);
 278   addKey("blue", Blue_Key, 0x002E, 13);
 279   addKey("teletext_menu", Unmapped_Key, 0x002F, 13);
 280 }
 281
 282
 283 PhilipsTV1f::PhilipsTV1f(
 284   unsigned int index)
 285   : PhilipsTV1(index)
 286 {
 287   setKeysetName("TV Keyset 1f");
 288
 289   addControlledDevice(Philips_Make, "25PT5302", TV_Device);
 290 }
 291
 292
 293 void PhilipsTV1f::populateProtocol(
 294   QObject *guiObject)
 295 {
 296   if (threadableProtocol)
 297   {
 298     // If the pointer is not null, the keyset must already be populated.
 299     return;
 300   }
 301
 302   PhilipsTV1::populateProtocol(guiObject);
 303
 304   addKey("SETUP", Menu_Key, 0x003A, 13);
 305   addKey("VOL-", VolumeDown_Key, 0x0011, 13);
 306   addKey("VOL+", VolumeUp_Key, 0x0010, 13);
 307   addKey("P<P", PrevChannel_Key, 0x1022, 13); // Might be wrong
 308   addKey("RED", Red_Key, 0x002B, 13);
 309   addKey("GREEN", Green_Key, 0x002C, 13);
 310   addKey("YELLOW", Yellow_Key, 0x002D, 13);
 311   addKey("BLUE", Blue_Key, 0x002E, 13);
 312   addKey("GRAY", Unmapped_Key, 0x002F, 13);
 313   addKey("SMARTVIDEO", PictureMode_Key, 0x10CA, 13);
 314   addKey("SMARTAUDIO", SoundMode_Key, 0x10CB, 13);
 315   addKey("+", Unmapped_Key, 0x0032, 13);
 316   addKey("-", Unmapped_Key, 0x0033, 13);
 317 }
 318
 319
 320 PhilipsTV2::PhilipsTV2(
 321   unsigned int index)
 322   : PIRKeysetMetaData(
 323       "TV Keyset 2",
 324       Philips_Make,
 325       index)
 326 {
 327   addControlledDevice(Philips_Make, "28PW8506/12R", TV_Device);
 328   addControlledDevice(Philips_Make, "26PFL5604H", TV_Device);
 329   addControlledDevice(Philips_Make, "32PFL5403D", TV_Device);
 330 }
 331
 332
 333 void PhilipsTV2::populateProtocol(
 334   QObject *guiObject)
 335 {
 336   if (threadableProtocol)
 337   {
 338     // If the pointer is not null, the keyset must already be populated.
 339     return;
 340   }
 341
 342   threadableProtocol = new RC6Protocol(guiObject, index, 0x00);
 343
 344   addKey("0", Zero_Key, 0x00, 8);
 345   addKey("1", One_Key, 0x01, 8);
 346   addKey("2", Two_Key, 0x02, 8);
 347   addKey("3", Three_Key, 0x03, 8);
 348   addKey("4", Four_Key, 0x04, 8);
 349   addKey("5", Five_Key, 0x05, 8);
 350   addKey("6", Six_Key, 0x06, 8);
 351   addKey("7", Seven_Key, 0x07, 8);
 352   addKey("8", Eight_Key, 0x08, 8);
 353   addKey("9", Nine_Key, 0x09, 8);
 354   addKey("Previous_channel", PrevChannel_Key, 0x0A, 8); // "PP", "AB"
 355   addKey("Power", Power_Key, 0x0C, 8);
 356   addKey("Mute", Mute_Key, 0x0D, 8);
 357   addKey("INFO", Info_Key, 0x0F, 8); // "i+"
 358
 359   addKey("Vol+", VolumeUp_Key, 0x10, 8);
 360   addKey("Vol-", VolumeDown_Key, 0x11, 8);
 361
 362   addKey("P+", ChannelUp_Key, 0x20, 8);
 363   addKey("P-", ChannelDown_Key, 0x21, 8);
 364   addKey(">>", FastForward_Key, 0x28, 8);
 365   addKey("<<", Rewind_Key, 0x2B, 8);
 366   addKey("Play", Play_Key, 0x2C, 8);
 367
 368   addKey("Stop", Stop_Key, 0x31, 8); // "MHEG_Cancel"
 369   addKey("Record", Record_Key, 0x37, 8);
 370   addKey("SOURCE", Input_Key, 0x38, 8); // "inputselect", "external"
 371   addKey("TELETEXT", Teletext_Key, 0x3C, 8);
 372
 373   addKey("OPTIONS", Unmapped_Key, 0x40, 8);
 374   addKey("InstallMenu", Unmapped_Key, 0x45, 8);
 375   addKey("SUBTITLE", Captions_Key, 0x4B, 8);
 376   addKey("1st/2nd_language", Audio_Key, 0x4E, 8); // "monostereo"
 377
 378   addKey("Home", Menu_Key, 0x54, 8); // "Menu"
 379   addKey("up", Up_Key, 0x58, 8);
 380   addKey("down", Down_Key, 0x59, 8);
 381   addKey("left", Left_Key, 0x5A, 8);
 382   addKey("right", Right_Key, 0x5B, 8);
 383   addKey("OK", Select_Key, 0x5C, 8);
 384   addKey("Dual_Screen", PIP_Key, 0x5D, 8); // "splitdisplay"
 385
 386   addKey("freeze", Pause_Key, 0x67, 8); // "pause"
 387   addKey("red", Red_Key, 0x6D, 8);
 388   addKey("green", Green_Key, 0x6E, 8);
 389   addKey("yellow", Yellow_Key, 0x6F, 8);
 390   addKey("blue", Blue_Key, 0x70, 8);
 391   addKey("SurroundSound", Surround_Key, 0x71, 8);  // "soundselect"
 392   addKey("Time", Sleep_Key, 0x7F, 8); // "clock", "timer_programming"
 393
 394   addKey("ActiveControl", Unmapped_Key, 0x96, 8);
 395   addKey("TV", Unmapped_Key, 0x9F, 8);
 396
 397   addKey("Guide", Guide_Key, 0xCC, 8); // "nextview", "EPG"
 398
 399   addKey("zoom", Zoom_Key, 0xE7, 8);
 400   addKey("PICTURE", PictureMode_Key, 0xF3, 8); // "smartdisplay"
 401   addKey("SOUND", SoundMode_Key, 0xF4, 8); // "smartsound"
 402   addKey("FORMAT", AspectRatio_Key, 0xF5, 8); // "Picture_Format", "displaymode"
 403 }
 404
 405
 406 PhilipsTV2a::PhilipsTV2a(
 407   unsigned int index)
 408   : PhilipsTV2(index)
 409 {
 410   setKeysetName("TV Keyset 2a");
 411
 412   addControlledDevice(Philips_Make, "29PT8607/12", TV_Device);
 413 }
 414
 415
 416 void PhilipsTV2a::populateProtocol(
 417   QObject *guiObject)
 418 {
 419   if (threadableProtocol)
 420   {
 421     // If the pointer is not null, the keyset must already be populated.
 422     return;
 423   }
 424
 425   PhilipsTV2::populateProtocol(guiObject);
 426
 427   addKey("tv-display", Info_Key, 0x3C, 8);
 428   addKey("tv-teletext_submode_(J:12)", Unmapped_Key, 0x5D, 8);
 429   addKey("tv-recording", Record_Key, 0x6D, 8);
 430   addKey("tv-speed-", Unmapped_Key, 0x6E, 8);
 431   addKey("tv-stop", Stop_Key, 0x6F, 8);
 432   addKey("tv-play", Play_Key, 0x70, 8);
 433   addKey("tv-speed+", Unmapped_Key, 0x71, 8);
 434   addKey("tv-solarization", Unmapped_Key, 0xCC, 8);
 435 }
 436
 437
 438 PhilipsTV2b::PhilipsTV2b(
 439   unsigned int index)
 440   : PhilipsTV2(index)
 441 {
 442   setKeysetName("TV Keyset 2b");
 443
 444   addControlledDevice(Philips_Make, "32PFL7532D", TV_Device);
 445 }
 446
 447
 448 void PhilipsTV2b::populateProtocol(
 449   QObject *guiObject)
 450 {
 451   if (threadableProtocol)
 452   {
 453     // If the pointer is not null, the keyset must already be populated.
 454     return;
 455   }
 456
 457   PhilipsTV2::populateProtocol(guiObject);
 458
 459   addKey("KEY_PLAY", Play_Key, 0xC1, 8);
 460   addKey("KEY_FAVORITES", Favorites_Key, 0xD2, 8);
 461 }
 462
 463
 464 PhilipsTV3::PhilipsTV3(
 465   unsigned int index)
 466   : PIRKeysetMetaData(
 467       "TV (settop-box) keyset 3",
 468       Philips_Make,
 469       index)
 470 {
 471   addControlledDevice(Philips_Make, "DTX6372", TV_Device);
 472 }
 473
 474
 475 void PhilipsTV3::populateProtocol(
 476   QObject *guiObject)
 477 {
 478   if (threadableProtocol)
 479   {
 480     // If the pointer is not null, the keyset must already be populated.
 481     return;
 482   }
 483
 484   threadableProtocol = new RC6Protocol(guiObject, index, 0x28);
 485
 486   addKey("0", Zero_Key, 0x00, 8);
 487   addKey("1", One_Key, 0x01, 8);
 488   addKey("2", Two_Key, 0x02, 8);
 489   addKey("3", Three_Key, 0x03, 8);
 490   addKey("4", Four_Key, 0x04, 8);
 491   addKey("5", Five_Key, 0x05, 8);
 492   addKey("6", Six_Key, 0x06, 8);
 493   addKey("7", Seven_Key, 0x07, 8);
 494   addKey("8", Eight_Key, 0x08, 8);
 495   addKey("9", Nine_Key, 0x09, 8);
 496
 497   addKey("power", Power_Key, 0x0C, 8);
 498   addKey("mute", Mute_Key, 0x0D, 8);
 499   addKey("info", Info_Key, 0x0F, 8);
 500
 501   addKey("vol+", VolumeUp_Key, 0x10, 8);
 502   addKey("vol-", VolumeDown_Key, 0x11, 8);
 503
 504   addKey("p+", ChannelUp_Key, 0x20, 8);
 505   addKey("p-", ChannelDown_Key, 0x21, 8);
 506
 507   addKey("text", Teletext_Key, 0x3C, 8);
 508
 509   addKey("tv/dtv", Input_Key, 0x43, 8);
 510   addKey("subtitle", Captions_Key, 0x4B, 8);
 511   addKey("menu", Menu_Key, 0x54, 8);
 512   addKey("up", Up_Key, 0x58, 8);
 513   addKey("down", Down_Key, 0x59, 8);
 514   addKey("left", Left_Key, 0x5A, 8);
 515   addKey("right", Right_Key, 0x5B, 8);
 516   addKey("select", Select_Key, 0x5C, 8);
 517
 518   addKey("red", Red_Key, 0x6D, 8);
 519   addKey("green", Green_Key, 0x6E, 8);
 520   addKey("yellow", Yellow_Key, 0x6F, 8);
 521   addKey("blue", Blue_Key, 0x70, 8);
 522   addKey("exit", Exit_Key, 0x83, 8);
 523
 524   addKey("guide", Guide_Key, 0xCC, 8);
 525   addKey("wide", AspectRatio_Key, 0xD8, 8);
 526 }
 527
 528
 529 PhilipsDVD1::PhilipsDVD1(
 530   unsigned int index)
 531   : PIRKeysetMetaData(
 532       "DVD Keyset 1",
 533       Philips_Make,
 534       index)
 535 {
 536   addControlledDevice(Philips_Make, "DVD712", DVD_Device);
 537   addControlledDevice(Philips_Make, "DVD722", DVD_Device);
 538   addControlledDevice(Philips_Make, "DVD-724", DVD_Device);
 539   addControlledDevice(Philips_Make, "DVP 3005", DVD_Device);
 540 }
 541
 542
 543 void PhilipsDVD1::populateProtocol(
 544   QObject *guiObject)
 545 {
 546   if (threadableProtocol)
 547   {
 548     // If the pointer is not null, the keyset must already be populated.
 549     return;
 550   }
 551
 552   threadableProtocol = new RC6Protocol(guiObject, index, 0x04);
 553
 554   addKey("0", Zero_Key, 0x00, 8);
 555   addKey("1", One_Key, 0x01, 8);
 556   addKey("2", Two_Key, 0x02, 8);
 557   addKey("3", Three_Key, 0x03, 8);
 558   addKey("4", Four_Key, 0x04, 8);
 559   addKey("5", Five_Key, 0x05, 8);
 560   addKey("6", Six_Key, 0x06, 8);
 561   addKey("7", Seven_Key, 0x07, 8);
 562   addKey("8", Eight_Key, 0x08, 8);
 563   addKey("9", Nine_Key, 0x09, 8);
 564   addKey("Standby", Power_Key, 0x0C, 8);
 565   addKey("Mute", Mute_Key, 0x0D, 8);
 566   addKey("Display", Info_Key, 0x0F, 8);
 567
 568   addKey("dim", Unmapped_Key, 0x13, 8);
 569   addKey("Shuffle", Random_Key, 0x1C, 8);
 570   addKey("Repeat", Repeat_Key, 0x1D, 8);
 571
 572   addKey("Skip_Right", Next_Key, 0x20, 8); // "next"
 573   addKey("Skip_Left", Previous_Key, 0x21, 8); // "prev"
 574   addKey("Forward", FastForward_Key, 0x28, 8);
 575   addKey("Rewind", Rewind_Key, 0x29, 8);
 576   addKey("Scan", Scan_Key, 0x2A, 8);
 577   addKey("Play", Play_Key, 0x2C, 8);
 578
 579   addKey("Still", Pause_Key, 0x30, 8); // "pause"
 580   addKey("Stop", Stop_Key, 0x31, 8);
 581   addKey("Repeat_AB", RepeatAB_Key, 0x3B, 8);
 582
 583   addKey("open-close", Eject_Key, 0x42, 8);
 584   addKey("Subtitle", Captions_Key, 0x4B, 8);
 585   addKey("Audio", Audio_Key, 0x4E, 8);
 586
 587   addKey("sound-mode", SoundMode_Key, 0x50, 8);
 588   addKey("Menu", DiscMenu_Key, 0x54, 8);
 589   addKey("Up", Up_Key, 0x58, 8);
 590   addKey("Down", Down_Key, 0x59, 8);
 591   addKey("Left", Left_Key, 0x5A, 8);
 592   addKey("Right", Right_Key, 0x5B, 8);
 593   addKey("OK", Select_Key, 0x5C, 8);
 594
 595   addKey("Title", DiscTitle_Key, 0x71, 8);
 596   addKey("System_Menu", Menu_Key, 0x82, 8); // "setup"
 597   addKey("Return", Exit_Key, 0x83, 8);
 598   addKey("Angle", Angle_Key, 0x85, 8);
 599   addKey("Preview", Unmapped_Key, 0xB5, 8);
 600   addKey("T-C", Unmapped_Key, 0xC8, 8);
 601   addKey("Secret", Unmapped_Key, 0xEB, 8);
 602   addKey("Zoom", Zoom_Key, 0xF7, 8);
 603   addKey("fts", Unmapped_Key, 0xFB, 8);
 604 }
 605
 606
 607 PhilipsDVD1a::PhilipsDVD1a(
 608   unsigned int index)
 609   : PhilipsDVD1(index)
 610 {
 611   setKeysetName("DVD Keyset 1a");
 612
 613   addControlledDevice(Philips_Make, "DVP-5982", DVD_Device);
 614 }
 615
 616
 617 void PhilipsDVD1a::populateProtocol(
 618   QObject *guiObject)
 619 {
 620   if (threadableProtocol)
 621   {
 622     // If the pointer is not null, the keyset must already be populated.
 623     return;
 624   }
 625
 626   PhilipsDVD1::populateProtocol(guiObject);
 627
 628   addKey("Play_Pause", Pause_Key, 0x2C, 8);
 629   addKey("USB", Unmapped_Key, 0x7E, 8);
 630   addKey("Power", Power_Key, 0xC7, 8);
 631 }
 632
 633
 634 PhilipsDVD1b::PhilipsDVD1b(
 635   unsigned int index)
 636   : PhilipsDVD1(index)
 637 {
 638   setKeysetName("DVD Keyset 1b");
 639
 640   addControlledDevice(Philips_Make, "DVP-642", DVD_Device);
 641 }
 642
 643
 644 void PhilipsDVD1b::populateProtocol(
 645   QObject *guiObject)
 646 {
 647   if (threadableProtocol)
 648   {
 649     // If the pointer is not null, the keyset must already be populated.
 650     return;
 651   }
 652
 653   PhilipsDVD1::populateProtocol(guiObject);
 654
 655   addKey("Forward", FastForward_Key, 0x20, 8);
 656   addKey("Reverse", Rewind_Key, 0x21, 8);
 657   addKey("Title", DiscTitle_Key, 0x83, 8);
 658 }
 659
 660
 661 PhilipsDVD1c::PhilipsDVD1c(
 662   unsigned int index)
 663   : PhilipsDVD1(index)
 664 {
 665   setKeysetName("DVD Keyset 1c");
 666
 667   addControlledDevice(Philips_Make, "HTS3544", DVD_Device);
 668   addControlledDevice(Philips_Make, "DVP5982", DVD_Device);
 669   addControlledDevice(Philips_Make, "DVP5160", DVD_Device);
 670 }
 671
 672
 673 void PhilipsDVD1c::populateProtocol(
 674   QObject *guiObject)
 675 {
 676   if (threadableProtocol)
 677   {
 678     // If the pointer is not null, the keyset must already be populated.
 679     return;
 680   }
 681
 682   PhilipsDVD1::populateProtocol(guiObject);
 683
 684   addKey("play-pause", Pause_Key, 0x2C, 8);
 685   addKey("disc-usb", Unmapped_Key, 0x3F, 8);
 686   addKey("USB", Unmapped_Key, 0x7E, 8);
 687   addKey("title", DiscTitle_Key, 0x83, 8);
 688   addKey("power", Power_Key, 0xC7, 8);
 689   addKey("menu", DiscMenu_Key, 0xD1, 8);
 690   addKey("program", Program_Key, 0xFB, 8);
 691 }
 692
 693
 694 PhilipsDVD1d::PhilipsDVD1d(
 695   unsigned int index)
 696   : PhilipsDVD1(index)
 697 {
 698   setKeysetName("DVD Keyset 1d");
 699
 700   addControlledDevice(Philips_Make, "DVD 963SA", DVD_Device);
 701 }
 702
 703
 704 void PhilipsDVD1d::populateProtocol(
 705   QObject *guiObject)
 706 {
 707   if (threadableProtocol)
 708   {
 709     // If the pointer is not null, the keyset must already be populated.
 710     return;
 711   }
 712
 713   PhilipsDVD1::populateProtocol(guiObject);
 714
 715   addKey("ff-right", FastForward_Key, 0x20, 8);
 716   addKey("ff-left", Rewind_Key, 0x21, 8);
 717   addKey("display", Info_Key, 0x48, 8);
 718 }
 719
 720
 721 PhilipsDVD2::PhilipsDVD2(
 722   unsigned int index)
 723   : PIRKeysetMetaData(
 724       "DVD/BD Keyset 2",
 725       Philips_Make,
 726       index)
 727 {
 728 }
 729
 730
 731 void PhilipsDVD2::populateProtocol(
 732   QObject *guiObject)
 733 {
 734   if (threadableProtocol)
 735   {
 736     // If the pointer is not null, the keyset must already be populated.
 737     return;
 738   }
 739
 740   threadableProtocol = new RC6Protocol(guiObject, index, 0x46);
 741
 742   addKey("0", Zero_Key, 0x00, 8);
 743   addKey("1", One_Key, 0x01, 8);
 744   addKey("2", Two_Key, 0x02, 8);
 745   addKey("3", Three_Key, 0x03, 8);
 746   addKey("4", Four_Key, 0x04, 8);
 747   addKey("5", Five_Key, 0x05, 8);
 748   addKey("6", Six_Key, 0x06, 8);
 749   addKey("7", Seven_Key, 0x07, 8);
 750   addKey("8", Eight_Key, 0x08, 8);
 751   addKey("9", Nine_Key, 0x09, 8);
 752   addKey("info", Info_Key, 0x0F, 8);
 753
 754   addKey("repeat", Repeat_Key, 0x1D, 8);
 755
 756   addKey("next", Next_Key, 0x20, 8);
 757   addKey("prev", Previous_Key, 0x21, 8);
 758   addKey("fwd", FastForward_Key, 0x28, 8);
 759   addKey("bwd", Rewind_Key, 0x29, 8);
 760   addKey("play", Play_Key, 0x2C, 8);
 761   addKey("pause", Pause_Key, 0x30, 8);
 762   addKey("stop", Stop_Key, 0x31, 8);
 763
 764   addKey("eject", Eject_Key, 0x42, 8);
 765   addKey("subtitle", Captions_Key, 0x4B, 8);
 766   addKey("audio", Audio_Key, 0x4E, 8);
 767
 768   addKey("up", Up_Key, 0x58, 8);
 769   addKey("down", Down_Key, 0x59, 8);
 770   addKey("left", Left_Key, 0x5A, 8);
 771   addKey("right", Right_Key, 0x5B, 8);
 772   addKey("ok", Select_Key, 0x5C, 8);
 773   addKey("bonus", Unmapped_Key, 0x5D, 8);
 774
 775   addKey("red", Red_Key, 0x6D, 8);
 776   addKey("green", Green_Key, 0x6E, 8);
 777   addKey("yellow", Yellow_Key, 0x6F, 8);
 778   addKey("blue", Blue_Key, 0x70, 8);
 779
 780   addKey("back", Exit_Key, 0x83, 8);
 781   addKey("home", Menu_Key, 0x92, 8);
 782   addKey("menu", DiscMenu_Key, 0x9A, 8);
 783   addKey("topmenu", DiscTitle_Key, 0x9C, 8);
 784   addKey("hdmi", HDMIInput_Key, 0xC6, 8);
 785   addKey("power", Power_Key, 0xC7, 8);
 786   addKey("options", Unmapped_Key, 0xC9, 8);
 787 }
 788
 789
 790 PhilipsDVD3::PhilipsDVD3(
 791   unsigned int index)
 792   : PIRKeysetMetaData(
 793       "DVD Keyset 3",
 794       Philips_Make,
 795       index)
 796 {
 797   addControlledDevice(Philips_Make, "DVDR3570H", DVD_Device);
 798 }
 799
 800
 801 void PhilipsDVD3::populateProtocol(
 802   QObject *guiObject)
 803 {
 804   if (threadableProtocol)
 805   {
 806     // If the pointer is not null, the keyset must already be populated.
 807     return;
 808   }
 809
 810   threadableProtocol = new RC6Protocol(guiObject, index, 0x32);
 811
 812   addKey("0", Zero_Key, 0x00, 8);
 813   addKey("1", One_Key, 0x01, 8);
 814   addKey("2", Two_Key, 0x02, 8);
 815   addKey("3", Three_Key, 0x03, 8);
 816   addKey("4", Four_Key, 0x04, 8);
 817   addKey("5", Five_Key, 0x05, 8);
 818   addKey("6", Six_Key, 0x06, 8);
 819   addKey("7", Seven_Key, 0x07, 8);
 820   addKey("8", Eight_Key, 0x08, 8);
 821   addKey("9", Nine_Key, 0x09, 8);
 822   addKey("Power", Power_Key, 0x0C, 8);
 823   addKey("Info", Info_Key, 0x0F, 8);
 824
 825   addKey("Ch-", ChannelDown_Key, 0x10, 8);
 826   addKey("Ch+", ChannelUp_Key, 0x11, 8);
 827   addKey("shuffle", Random_Key, 0x1C, 8);
 828   addKey("repeat", Repeat_Key, 0x1D, 8);
 829
 830   addKey("Next", Next_Key, 0x20, 8);
 831   addKey("Prev", Previous_Key, 0x21, 8);
 832   addKey("Ffw", FastForward_Key, 0x28, 8);
 833   addKey("Rew", Rewind_Key, 0x29, 8);
 834   addKey("Play", Play_Key, 0x2C, 8);
 835   addKey("Play", Pause_Key, 0x2C, 8);
 836   addKey("Stop", Stop_Key, 0x31, 8);
 837   addKey("Rec", Record_Key, 0x37, 8);
 838
 839   addKey("Scart", ScartInput_Key, 0x43, 8);
 840   addKey("Subtitle", Captions_Key, 0x4B, 8);
 841   addKey("Audio", Audio_Key, 0x4E, 8);
 842
 843   addKey("Up", Up_Key, 0x58, 8);
 844   addKey("Down", Down_Key, 0x59, 8);
 845   addKey("Left", Left_Key, 0x5A, 8);
 846   addKey("Right", Right_Key, 0x5B, 8);
 847   addKey("OK", Select_Key, 0x5C, 8);
 848   addKey("inputnext", Input_Key, 0x5E, 8);
 849
 850   addKey("Last_ch", PrevChannel_Key, 0x6A, 8);
 851   addKey("Red", Red_Key, 0x6D, 8);
 852   addKey("Green", Green_Key, 0x6E, 8);
 853   addKey("Yellow", Yellow_Key, 0x6F, 8);
 854   addKey("Blue", Blue_Key, 0x70, 8);
 855   addKey("USB", Unmapped_Key, 0x7E, 8);
 856
 857   addKey("Options", Unmapped_Key, 0x82, 8);
 858   addKey("Back", Exit_Key, 0x83, 8); // "Exit"
 859   addKey("angle", Angle_Key, 0x85, 8);
 860   addKey("inoputtuner", TunerInput_Key, 0x8A, 8);
 861
 862   addKey("HDDList", Unmapped_Key, 0x90, 8);
 863   addKey("Home", Menu_Key, 0x92, 8);
 864
 865   addKey("TVGuide", Guide_Key, 0xC2, 8);
 866   addKey("Cam", Unmapped_Key, 0xC3, 8);
 867   addKey("t/c", Unmapped_Key, 0xC8, 8); // title/chapter
 868   addKey("Select", Unmapped_Key, 0xC9, 8); // "menuselect"
 869
 870   addKey("Disc", DiscMenu_Key, 0xD1, 8);
 871   addKey("zoom", Zoom_Key, 0xD3, 8);
 872   addKey("LiveTV", LiveTV_Key, 0xEE, 8);
 873   addKey("Edit", Unmapped_Key, 0xF1, 8);
 874   addKey("timer", Timer_Key, 0xFE, 8);
 875 }
 876
 877
 878 PhilipsDVD3a::PhilipsDVD3a(
 879   unsigned int index)
 880   : PhilipsDVD3(index)
 881 {
 882   setKeysetName("DVD Keyset 3a");
 883
 884   addControlledDevice(Philips_Make, "DVDR-3455H", DVD_Device);
 885 }
 886
 887
 888 void PhilipsDVD3a::populateProtocol(
 889   QObject *guiObject)
 890 {
 891   if (threadableProtocol)
 892   {
 893     // If the pointer is not null, the keyset must already be populated.
 894     return;
 895   }
 896
 897   PhilipsDVD3::populateProtocol(guiObject);
 898
 899   addKey("CH+", ChannelUp_Key, 0x1E, 8);
 900   addKey("CH-", ChannelDown_Key, 0x1F, 8);
 901   addKey("Menu", Menu_Key, 0x54, 8);
 902   addKey("InputDVD", Unmapped_Key, 0x90, 8);
 903   addKey("InputHDD", Unmapped_Key, 0x92, 8);
 904   addKey("inputusb", USBInput_Key, 0xC3, 8);
 905   addKey("Audio", Audio_Key, 0xD2, 8);
 906   addKey("Record", Record_Key, 0xF3, 8);
 907 }
 908
 909
 910 PhilipsDVD4::PhilipsDVD4(
 911   unsigned int index)
 912   : PIRKeysetMetaData(
 913       "DVD Keyset 4",
 914       Philips_Make,
 915       index)
 916 {
 917   addControlledDevice(Philips_Make, "DVDR 1000", DVD_Device);
 918 }
 919
 920
 921 void PhilipsDVD4::populateProtocol(
 922   QObject *guiObject)
 923 {
 924   if (threadableProtocol)
 925   {
 926     // If the pointer is not null, the keyset must already be populated.
 927     return;
 928   }
 929
 930   threadableProtocol = new RC6Protocol(guiObject, index, 0x30);
 931
 932   addKey("0", Zero_Key, 0x00, 8);
 933   addKey("1", One_Key, 0x01, 8);
 934   addKey("2", Two_Key, 0x02, 8);
 935   addKey("3", Three_Key, 0x03, 8);
 936   addKey("4", Four_Key, 0x04, 8);
 937   addKey("5", Five_Key, 0x05, 8);
 938   addKey("6", Six_Key, 0x06, 8);
 939   addKey("7", Seven_Key, 0x07, 8);
 940   addKey("8", Eight_Key, 0x08, 8);
 941   addKey("9", Nine_Key, 0x09, 8);
 942
 943   addKey("Power", Power_Key, 0x0C, 8);
 944   addKey("SYSTEM", Info_Key, 0x0F, 8);
 945
 946   addKey("DIM", Unmapped_Key, 0x13, 8);
 947   addKey("REPEAT", Repeat_Key, 0x1D, 8);
 948   addKey("PROGPLUS", ChannelUp_Key, 0x1E, 8);
 949   addKey("PROGMINUS", ChannelDown_Key, 0x1F, 8);
 950
 951   addKey("NEXT", Next_Key, 0x20, 8);
 952   addKey("PREVIOUS", Previous_Key, 0x21, 8);
 953   addKey("SLOW", Slow_Key, 0x22, 8);
 954   addKey("FORWARD", FastForward_Key, 0x28, 8);
 955   addKey("REWIND", Rewind_Key, 0x29, 8);
 956   addKey("SCAN", Scan_Key, 0x2A, 8);
 957   addKey("PLAY", Play_Key, 0x2C, 8);
 958   addKey("PAUSE", Pause_Key, 0x30, 8);
 959   addKey("STOP", Stop_Key, 0x31, 8);
 960   addKey("RECORD", Record_Key, 0x37, 8);
 961   addKey("REPEATAB", RepeatAB_Key, 0x3B, 8);
 962
 963   addKey("CLEAR", Clear_Key, 0x41, 8);
 964   addKey("TVDVD", Input_Key, 0x43, 8);
 965   addKey("SUBTITLE", Captions_Key, 0x4B, 8);
 966   addKey("AUDIO", Audio_Key, 0x4E, 8);
 967
 968   addKey("DISC", Unmapped_Key, 0x54, 8);
 969   addKey("UP", Up_Key, 0x58, 8);
 970   addKey("DOWN", Down_Key, 0x59, 8);
 971   addKey("LEFT", Left_Key, 0x5A, 8);
 972   addKey("RIGHT", Right_Key, 0x5B, 8);
 973
 974   addKey("ANGLE", Angle_Key, 0x85, 8);
 975
 976   addKey("TC", Unmapped_Key, 0xC8, 8);
 977   addKey("EDIT", Unmapped_Key, 0xCF, 8);
 978
 979   addKey("TUNER", TunerInput_Key, 0xEE, 8);
 980
 981   addKey("ZOOM", Zoom_Key, 0xF7, 8);
 982   addKey("SELECT", Select_Key, 0xFA, 8);
 983   addKey("TIMER", Timer_Key, 0xFE, 8);
 984 }
 985
 986
 987 PhilipsVCR1::PhilipsVCR1(
 988   unsigned int index)
 989   : PIRKeysetMetaData(
 990       "VCR Keyset 1",
 991       Philips_Make,
 992       index)
 993 {
 994 }
 995
 996
 997 void PhilipsVCR1::populateProtocol(
 998   QObject *guiObject)
 999 {
1000   if (threadableProtocol)
1001   {
1002     // If the pointer is not null, the keyset must already be populated.
1003     return;
1004   }
1005
1006   threadableProtocol = new RC5Protocol(guiObject, index);
1007
1008   addKey("Standby", Power_Key, 0x114C, 13);
1009   addKey("External", Input_Key, 0x1178, 13);
1010   addKey("Forward", FastForward_Key, 0x1174, 13);
1011   addKey("Record", Record_Key, 0x1177, 13);
1012   addKey("Rewind", Rewind_Key, 0x1172, 13);
1013   addKey("Stop", Stop_Key, 0x1176, 13);
1014   addKey("Play", Play_Key, 0x1175, 13);
1015   addKey("Timer", Timer_Key, 0x115D, 13);
1016   addKey("OSD", Info_Key, 0x114F, 13);
1017   addKey("Menu", Menu_Key, 0x0152, 13);
1018   addKey("OK", Select_Key, 0x0157, 13);
1019   addKey("Left", Left_Key, 0x0155, 13);
1020   addKey("Right", Right_Key, 0x0156, 13);
1021   addKey("Up", Up_Key, 0x0150, 13);
1022   addKey("Down", Down_Key, 0x0151, 13);
1023   addKey("Program+", ChannelUp_Key, 0x1160, 13);
1024   addKey("Program-", ChannelDown_Key, 0x1161, 13);
1025   addKey("Audio", Audio_Key, 0x1163, 13);
1026   addKey("Still", Pause_Key, 0x1169, 13); // "PAUSE"
1027   addKey("1", One_Key, 0x1141, 13);
1028   addKey("2", Two_Key, 0x1142, 13);
1029   addKey("3", Three_Key, 0x1143, 13);
1030   addKey("4", Four_Key, 0x1144, 13);
1031   addKey("5", Five_Key, 0x1145, 13);
1032   addKey("6", Six_Key, 0x1146, 13);
1033   addKey("7", Seven_Key, 0x1147, 13);
1034   addKey("8", Eight_Key, 0x1148, 13);
1035   addKey("9", Nine_Key, 0x1149, 13);
1036   addKey("0", Zero_Key, 0x1140, 13);
1037   addKey("-/--", DoubleDigit_Key, 0x114A, 13);
1038   addKey("100", PlusOneHundred_Key, 0x114A, 13);
1039   addKey("VCR-Dash", Dash_Key, 0x114A, 13);
1040   addKey("Index", IndexSearch_Key, 0x0170, 13);
1041   addKey("reset", Reset_Key, 0x1171, 13); // "clear"
1042   addKey("play<", Unmapped_Key, 0x116F, 13);
1043   addKey("x>", PlayX2_Key, 0x116A, 13); // "X2_PLAY"
1044   addKey("speed", VHSSpeed_Key, 0x117A, 13); // "SP/LP"
1045   addKey("Childlock", Unmapped_Key, 0x017F, 13);
1046   addKey("System", Unmapped_Key, 0x094A, 13);
1047   addKey("vol_dn", VolumeDown_Key, 0x1011, 13);
1048   addKey("vol_up", VolumeUp_Key, 0x1010, 13);
1049   addKey("F_ADV", StepForward_Key, 0x016B, 13);
1050   addKey("G_CODE", Unmapped_Key, 0x0145, 13);
1051   addKey("GO_TO", Unmapped_Key, 0x1173, 13);
1052   addKey("SLOW", Slow_Key, 0x1168, 13);
1053   addKey("memory", Program_Key, 0x117B, 13);
1054   addKey("VCR_TV", Unmapped_Key, 0x117E, 13);
1055   addKey("track_up", TrackingPlus_Key, 0x014D, 13);
1056   addKey("track_down", TrackingMinus_Key, 0x14E, 13);
1057 }
1058
1059
1060 PhilipsVCR1a::PhilipsVCR1a(
1061   unsigned int index)
1062   : PhilipsVCR1(index)
1063 {
1064   setKeysetName("VCR Keyset 1a");
1065
1066   addControlledDevice(Philips_Make, "VP27/55", VCR_Device);
1067 }
1068
1069
1070 void PhilipsVCR1a::populateProtocol(
1071   QObject *guiObject)
1072 {
1073   if (threadableProtocol)
1074   {
1075     // If the pointer is not null, the keyset must already be populated.
1076     return;
1077   }
1078
1079   PhilipsVCR1::populateProtocol(guiObject);
1080
1081   addKey("menu", Menu_Key, 0x115D, 13);
1082   addKey("eject", Eject_Key, 0x116D, 13);
1083   addKey("sleep_wake", Sleep_Key, 0x1026, 13);
1084   addKey("alt_ch", PrevChannel_Key, 0x1022, 13);
1085   addKey("chan_prev", ChannelDown_Key, 0x1020, 13);
1086   addKey("chan_next", ChannelUp_Key, 0x1021, 13);
1087   addKey("mute", Mute_Key, 0x100D, 13);
1088   addKey("TV-POWER", Unmapped_Key, 0x100C, 13);
1089 }
1090
1091
1092 PhilipsVCR1b::PhilipsVCR1b(
1093   unsigned int index)
1094   : PhilipsVCR1(index)
1095 {
1096   setKeysetName("VCR Keyset 1b");
1097 }
1098
1099
1100 void PhilipsVCR1b::populateProtocol(
1101   QObject *guiObject)
1102 {
1103   if (threadableProtocol)
1104   {
1105     // If the pointer is not null, the keyset must already be populated.
1106     return;
1107   }
1108
1109   PhilipsVCR1::populateProtocol(guiObject);
1110
1111   addKey("Cassette_Eject", Eject_Key, 0x017E, 13);
1112   addKey("Select", Select_Key, 0x114B, 13);
1113   addKey("Rewind", Rewind_Key, 0x1165, 13);
1114   addKey("Forward", FastForward_Key, 0x1166, 13);
1115   addKey("Previous", Previous_Key, 0x0171, 13);
1116   addKey("Next", Next_Key, 0x0170, 13);
1117   addKey("Monitor", Unmapped_Key, 0x017A, 13);
1118   addKey("Tuner", TunerInput_Key, 0x017D, 13);
1119   addKey("Tracking", AutoTracking_Key, 0x114E, 13);
1120 }
1121
1122
1123 PhilipsVCR1c::PhilipsVCR1c(
1124   unsigned int index)
1125   : PhilipsVCR1(index)
1126 {
1127   setKeysetName("VCR Keyset 1c");
1128 }
1129
1130
1131 void PhilipsVCR1c::populateProtocol(
1132   QObject *guiObject)
1133 {
1134   if (threadableProtocol)
1135   {
1136     // If the pointer is not null, the keyset must already be populated.
1137     return;
1138   }
1139
1140   PhilipsVCR1::populateProtocol(guiObject);
1141
1142   addKey("TIMER_REVIEW", Unmapped_Key, 0x0168, 13);
1143   addKey("DATE_UP", Unmapped_Key, 0x125C, 13);
1144   addKey("DATE_DOWN", Unmapped_Key, 0x125D, 13);
1145   addKey("PROG_UP", Unmapped_Key, 0x1260, 13);
1146   addKey("PROG_DOWN", Unmapped_Key, 0x1261, 13);
1147   addKey("START_UP", Unmapped_Key, 0x125E, 13);
1148   addKey("START_DOWN", Unmapped_Key, 0x125F, 13);
1149   addKey("END_UP", Unmapped_Key, 0x1263, 13);
1150   addKey("END_DOWN", Unmapped_Key, 0x1264, 13);
1151   addKey("Tracking", AutoTracking_Key, 0x114E, 13);
1152   addKey("FF", FastForward_Key, 0x1166, 13);
1153   addKey("Previous", Previous_Key, 0x0171, 13);
1154   addKey("Next", Next_Key, 0x0170, 13);
1155   addKey("SET_CLOCK", Unmapped_Key, 0x1164, 13);
1156   addKey("VPS", RecordPDC_Key, 0x114B, 13);
1157   addKey("Cassette", Eject_Key, 0x017E, 13);
1158   addKey("DECODER", Unmapped_Key, 0x0169, 13);
1159   addKey("Tuner", TunerInput_Key, 0x017D, 13);
1160   addKey("Monitor", Unmapped_Key, 0x017A, 13);
1161   addKey("SYSTEM", Unmapped_Key, 0x014A, 13);
1162   addKey("REC_MODE", Unmapped_Key, 0x115E, 13);
1163   addKey("SHOWVIEW", Unmapped_Key, 0x0145, 13); // vhsplus+, etc.
1164   addKey("DW", Unmapped_Key, 0x0144, 13); // "D/W"
1165   addKey("SPEED-", SlowMinus_Key, 0x1165, 13);
1166   addKey("SPEED+", SlowPlus_Key, 0x1166, 13);
1167 }
1168
1169
1170 PhilipsSat1::PhilipsSat1(
1171   unsigned int index)
1172   : PIRKeysetMetaData(
1173       "Sat Keyset 1",
1174       Philips_Make,
1175       index)
1176 {
1177 }
1178
1179
1180 void PhilipsSat1::populateProtocol(
1181   QObject *guiObject)
1182 {
1183   if (threadableProtocol)
1184   {
1185     // If the pointer is not null, the keyset must already be populated.
1186     return;
1187   }
1188
1189   threadableProtocol = new RC5Protocol(guiObject, index);
1190
1191   addKey("Standby", Power_Key, 0x120C, 13);
1192   addKey("External", Unmapped_Key, 0x1238, 13);
1193   addKey("Menu", Menu_Key, 0x0212, 13); // "blue_on"
1194   addKey("blue_off", Exit_Key, 0x0213, 13);
1195   addKey("OK", Select_Key, 0x0217, 13); // "blue_ok"
1196   addKey("Left", Left_Key, 0x0215, 13);
1197   addKey("Right", Right_Key, 0x0216, 13);
1198   addKey("Up", Up_Key, 0x0210, 13);
1199   addKey("Down", Down_Key, 0x0211, 13);
1200   addKey("Program+", ChannelUp_Key, 0x1220, 13);
1201   addKey("Program-", ChannelDown_Key, 0x1221, 13);
1202   addKey("Audio", Audio_Key, 0x1223, 13); // I-II
1203   addKey("1", One_Key, 0x1201, 13);
1204   addKey("2", Two_Key, 0x1202, 13);
1205   addKey("3", Three_Key, 0x1203, 13);
1206   addKey("4", Four_Key, 0x1204, 13);
1207   addKey("5", Five_Key, 0x1205, 13);
1208   addKey("6", Six_Key, 0x1206, 13);
1209   addKey("7", Seven_Key, 0x1207, 13);
1210   addKey("8", Eight_Key, 0x1208, 13);
1211   addKey("9", Nine_Key, 0x1209, 13);
1212   addKey("0", Zero_Key, 0x1200, 13);
1213   addKey("OSD", Info_Key, 0x120F, 13);
1214   addKey("Program<", PrevChannel_Key, 0x1222, 13); // "P<P"
1215   addKey("A/B", Unmapped_Key, 0x122C, 13);
1216   addKey("Music_notes", Unmapped_Key, 0x0205, 13);
1217   addKey("TV_ON", Unmapped_Key, 0x1001, 13);
1218   addKey("TV_OFF", Unmapped_Key, 0x100C, 13);
1219   addKey("Vol_+", VolumeUp_Key, 0x1010, 13);
1220   addKey("Vol_-", VolumeDown_Key, 0x1011, 13);
1221   addKey("Mute", Mute_Key, 0x0206, 13);
1222   addKey("Screensize", AspectRatio_Key, 0x003E, 13);
1223   addKey("TV/SAT", Input_Key, 0x1228, 13);
1224   addKey("Play", Play_Key, 0x1175, 13);
1225   addKey("Stop", Stop_Key, 0x1176, 13);
1226   addKey("ffw", FastForward_Key, 0x1174, 13);
1227   addKey("fbw", Rewind_Key, 0x1172, 13);
1228   addKey("TV_MUTE", Unmapped_Key, 0x100D, 13);
1229   addKey("TV_P-", Unmapped_Key, 0x1021, 13);
1230   addKey("TV_P+", Unmapped_Key, 0x1020, 13);
1231   addKey("Install", Unmapped_Key, 0x023A, 13);
1232   addKey("Clock", Clock_Key, 0x122A, 13);
1233   addKey("Clock_dotted", Unmapped_Key, 0x1226, 13);
1234 }
1235
1236
1237 PhilipsSat2::PhilipsSat2(
1238   unsigned int index)
1239   : PIRKeysetMetaData(
1240       "Sat Keyset 2",
1241       Philips_Make,
1242       index)
1243 {
1244   addControlledDevice(Philips_Make, "DSX-5500", Sat_Device);
1245 }
1246
1247
1248 void PhilipsSat2::populateProtocol(
1249   QObject *guiObject)
1250 {
1251   if (threadableProtocol)
1252   {
1253     // If the pointer is not null, the keyset must already be populated.
1254     return;
1255   }
1256
1257   threadableProtocol = new RC6Protocol(guiObject, index, 0x27);
1258
1259   addKey("0", Zero_Key, 0x00, 8);
1260   addKey("1", One_Key, 0x01, 8);
1261   addKey("2", Two_Key, 0x02, 8);
1262   addKey("3", Three_Key, 0x03, 8);
1263   addKey("4", Four_Key, 0x04, 8);
1264   addKey("5", Five_Key, 0x05, 8);
1265   addKey("6", Six_Key, 0x06, 8);
1266   addKey("7", Seven_Key, 0x07, 8);
1267   addKey("8", Eight_Key, 0x08, 8);
1268   addKey("9", Nine_Key, 0x09, 8);
1269   addKey("power", Power_Key, 0x0C, 8);
1270   addKey("ch+", ChannelUp_Key, 0x20, 8);
1271   addKey("ch-", ChannelDown_Key, 0x21, 8);
1272   addKey("source", Input_Key, 0x43, 8);
1273   addKey("menu", Menu_Key, 0x54, 8);
1274   addKey("exit", Exit_Key, 0x55, 8);
1275   addKey("up", Up_Key, 0x58, 8);
1276   addKey("down", Down_Key, 0x59, 8);
1277   addKey("left", Left_Key, 0x5A, 8);
1278   addKey("right", Right_Key, 0x5B, 8);
1279   addKey("OK", Select_Key, 0x5C, 8);
1280   addKey("red", Red_Key, 0x6D, 8);
1281   addKey("green", Green_Key, 0x6E, 8);
1282   addKey("yellow", Yellow_Key, 0x6F, 8);
1283   addKey("blue", Blue_Key, 0x70, 8);
1284   addKey("white", Unmapped_Key, 0x71, 8);
1285   addKey("back", PrevChannel_Key, 0x83, 8); // Might be wrong
1286   addKey("pause", Pause_Key, 0x84, 8);
1287   addKey("brackets", Unmapped_Key, 0xAF, 8);
1288   addKey("info", Info_Key, 0xCB, 8);
1289   addKey("guide", Guide_Key, 0xCC, 8);
1290   addKey("surf", Unmapped_Key, 0xCD, 8);
1291   addKey("i", Unmapped_Key, 0xFD, 8);
1292 }
1293
1294
1295 PhilipsSat2a::PhilipsSat2a(
1296   unsigned int index)
1297   : PhilipsSat2(index)
1298 {
1299   setKeysetName("Sat Keyset 2a");
1300
1301   addControlledDevice(Philips_Make, "DSX 6010/62A", Sat_Device);
1302 }
1303
1304
1305 void PhilipsSat2a::populateProtocol(
1306   QObject *guiObject)
1307 {
1308   if (threadableProtocol)
1309   {
1310     // If the pointer is not null, the keyset must already be populated.
1311     return;
1312   }
1313
1314   PhilipsSat2::populateProtocol(guiObject);
1315
1316   addKey("ch+", ChannelUp_Key, 0x58, 8);
1317   addKey("ch-", ChannelDown_Key, 0x59, 8);
1318   addKey("language", Audio_Key, 0x49, 8);
1319   addKey("txt", Captions_Key, 0x4B, 8);
1320   addKey("favorites", Favorites_Key, 0x84, 8);
1321   addKey("themes", Unmapped_Key, 0xCD, 8);
1322   addKey("opts", Unmapped_Key, 0xBD, 8);
1323   addKey("pp", PrevChannel_Key, 0x0A, 8);
1324   addKey("page+", PageUp_Key, 0xCE, 8);
1325   addKey("page-", PageDown_Key, 0xCF, 8);
1326 }
1327
1328
1329 PhilipsSat3::PhilipsSat3(
1330   unsigned int index)
1331   : PIRKeysetMetaData(
1332       "Sat Keyset 3",
1333       Philips_Make,
1334       index)
1335 {
1336   addControlledDevice(Philips_Make, "DST5816/33", Sat_Device);
1337 }
1338
1339
1340 void PhilipsSat3::populateProtocol(
1341   QObject *guiObject)
1342 {
1343   if (threadableProtocol)
1344   {
1345     // If the pointer is not null, the keyset must already be populated.
1346     return;
1347   }
1348
1349   threadableProtocol = new RC5Protocol(guiObject, index);
1350
1351   addKey("SOUNDOFF", Mute_Key, 0x0286, 13); // "mute"
1352   addKey("EPG", Guide_Key, 0x028F, 13); // "prog"
1353   addKey("UP", Up_Key, 0x0290, 13);
1354   addKey("DOWN", Down_Key, 0x0291, 13);
1355   addKey("SERV", Unmapped_Key, 0x0292, 13);
1356   addKey("BACK", Unmapped_Key, 0x0293, 13); // "av"
1357   addKey("LEFT", Left_Key, 0x0295, 13);
1358   addKey("RIGHT", Right_Key, 0x0296, 13);
1359   addKey("OK", Select_Key, 0x0297, 13);
1360   addKey("FRONT", Unmapped_Key, 0x02A1, 13); // "twoje"
1361   addKey("MENU", Menu_Key, 0x02AA, 13); // "perso"
1362   addKey("A", Unmapped_Key, 0x02AB, 13);
1363   addKey("B", Unmapped_Key, 0x02AC, 13);
1364   addKey("C", Unmapped_Key, 0x02AD, 13);
1365   addKey("D", Unmapped_Key, 0x02AE, 13);
1366   addKey("E", Unmapped_Key, 0x02AF, 13);
1367
1368   addKey("0", Zero_Key, 0x1280, 13);
1369   addKey("1", One_Key, 0x1281, 13);
1370   addKey("2", Two_Key, 0x1282, 13);
1371   addKey("3", Three_Key, 0x1283, 13);
1372   addKey("4", Four_Key, 0x1284, 13);
1373   addKey("5", Five_Key, 0x1285, 13);
1374   addKey("6", Six_Key, 0x1286, 13);
1375   addKey("7", Seven_Key, 0x1287, 13);
1376   addKey("8", Eight_Key, 0x1288, 13);
1377   addKey("9", Nine_Key, 0x1289, 13);
1378   addKey("STANDBY", Power_Key, 0x128C, 13);
1379   addKey("INFO", Info_Key, 0x128F, 13); // "pilot"
1380   addKey("TV/SAT", Input_Key, 0x12A8, 13);
1381   addKey("+", Unmapped_Key, 0x12AF, 13);
1382 }
1383
1384
1385 PhilipsAudio1::PhilipsAudio1(
1386   unsigned int index)
1387   : PIRKeysetMetaData(
1388       "Audio Keyset 1",
1389       Philips_Make,
1390       index)
1391 {
1392   addControlledDevice(Philips_Make, "FW 530C", Audio_Device);
1393   addControlledDevice(Philips_Make, "FW-P78", Audio_Device);
1394   addControlledDevice(Philips_Make, "FWP73P", Audio_Device);
1395   addControlledDevice(Philips_Make, "FWP78C", Audio_Device);
1396   addControlledDevice(Philips_Make, "PVD0384", Audio_Device);
1397   addControlledDevice(Philips_Make, "AZ2407", Audio_Device);
1398   addControlledDevice(Philips_Make, "MZ7", Audio_Device);
1399   addControlledDevice(Philips_Make, "AS680C", Audio_Device);
1400 }
1401
1402
1403 void PhilipsAudio1::populateProtocol(
1404   QObject *guiObject)
1405 {
1406   if (threadableProtocol)
1407   {
1408     // If the pointer is not null, the keyset must already be populated.
1409     return;
1410   }
1411
1412   threadableProtocol = new RC5Protocol(guiObject, index);
1413
1414   addKey("Dynamic Bass Boost", EnhancedBass_Key, 0x0406, 13); // "dbb"
1415   addKey("Digital Sound Control", Unmapped_Key, 0x040F, 13); // "dsc"
1416   addKey("mute", Mute_Key, 0x140D, 13);
1417   addKey("Vol+", VolumeUp_Key, 0x1410, 13);
1418   addKey("Vol-", VolumeDown_Key, 0x1411, 13);
1419   addKey("tuner_power", Power_Key, 0x144C, 13);
1420   addKey("tuner_ff", ChannelUp_Key, 0x145E, 13); // "tuningR"
1421   addKey("tuner_rew", ChannelDown_Key, 0x145F, 13); // "tuningL"
1422   addKey("tuner_next", Next_Key, 0x1460, 13); // "presetUp"
1423   addKey("tuner_previous", Previous_Key, 0x1461, 13); // "presetDown"
1424   addKey("tuner_program", Program_Key, 0x047A, 13); // Create Preset
1425   addKey("tuner", TunerInput_Key, 0x147F, 13);
1426   addKey("tape_power", Unmapped_Key, 0x148C, 13);
1427   addKey("tape_next", Unmapped_Key, 0x14A0, 13);
1428   addKey("tape_previous", Unmapped_Key, 0x14A1, 13);
1429   addKey("tape_pause", Unmapped_Key, 0x14B0, 13);
1430   addKey("tape_rew", Unmapped_Key, 0x14B2, 13);
1431   addKey("tape_ff", Unmapped_Key, 0x14B3, 13);
1432   addKey("tape_play", Unmapped_Key, 0x14B5, 13);
1433   addKey("tape_stop", Unmapped_Key, 0x14B6, 13);
1434   addKey("tape", Unmapped_Key, 0x14BF, 13); // "tape1-2"
1435   addKey("cd_power", Unmapped_Key, 0x150C, 13);
1436   addKey("cd_shuffle", Random_Key, 0x151C, 13);
1437   addKey("cd_repeat", Repeat_Key, 0x151D, 13);
1438   addKey("cd_next", Unmapped_Key, 0x1520, 13);
1439   addKey("cd_previous", Unmapped_Key, 0x1521, 13);
1440   addKey("cd_program", Unmapped_Key, 0x1524, 13);
1441   addKey("cd_pause", Pause_Key, 0x1530, 13);
1442   addKey("cd_rew", Rewind_Key, 0x1532, 13);
1443   addKey("cd_ff", FastForward_Key, 0x1534, 13);
1444   addKey("cd_play", Play_Key, 0x1535, 13);
1445   addKey("cd_stop", Stop_Key, 0x1536, 13);
1446   addKey("cd_1", One_Key, 0x1537, 13);
1447   addKey("cd_2", Two_Key, 0x1538, 13);
1448   addKey("cd_3", Three_Key, 0x1539, 13);
1449   addKey("cd", CDInput_Key, 0x153F, 13);
1450   addKey("aux_power", Unmapped_Key, 0x154C, 13); // "power", "standby"
1451   addKey("aux", AuxInput_Key, 0x157F, 13);
1452   addKey("DPL", Unmapped_Key, 0x1425, 13);
1453   addKey("SleepTimer", Sleep_Key, 0x1426, 13);
1454   addKey("Rear+", RearVolumeUp_Key, 0x0401, 13);
1455   addKey("Rear-", RearVolumeDown_Key, 0x0402, 13);
1456   addKey("TestTone", Unmapped_Key, 0x0418, 13);
1457   addKey("Center+", CenterVolumeUp_Key, 0x0426, 13);
1458   addKey("Center-", CenterVolumeDown_Key, 0x0427, 13);
1459   addKey("incredible_surround", Surround_Key, 0x0400, 13); // "inc_s"
1460   addKey("osm", Unmapped_Key, 0x042C, 13);
1461   addKey("vec", Unmapped_Key, 0x042B, 13);
1462   addKey("TIME", Info_Key, 0x150B, 13); // "CD_DISPLAY"
1463   addKey("SCAN", Scan_Key, 0x152B, 13);
1464   addKey("OPEN/CLOSE", Eject_Key, 0x152D, 13);
1465   addKey("Side", Unmapped_Key, 0x14AF, 13);  // "TAPE_SIDE"
1466   addKey("TIMER", Timer_Key, 0x142A, 13);
1467   addKey("FLAT", Unmapped_Key, 0x1434, 13);
1468   addKey("LOUDNESS", Unmapped_Key, 0x1432, 13);
1469   addKey("BASS_UP", BassUp_Key, 0x1416, 13);
1470   addKey("BASS_DOWN", BassDown_Key, 0x1417, 13);
1471   addKey("TREBLE_UP", TrebleUp_Key, 0x1418, 13);
1472   addKey("TREBLE_DOWN", TrebleDown_Key, 0x1419, 13);
1473   addKey("BALANCE_RIGHT", BalanceRight_Key, 0x141A, 13); // "BalR"
1474   addKey("BALANCE_LEFT", BalanceLeft_Key, 0x141B, 13); // "BalL"
1475   addKey("TUNER_DISPLAY", Unmapped_Key, 0x144F, 13);
1476   addKey("CDR", Unmapped_Key, 0x16BF, 13);
1477   addKey("CDR_POWER", Unmapped_Key, 0x100C, 13);
1478   addKey("CDR_REPEAT", Unmapped_Key, 0x169D, 13);
1479   addKey("CDR_SHUFFLE", Unmapped_Key, 0x169C, 13);
1480   addKey("CDR_PROGRAM", Unmapped_Key, 0x16A4, 13);
1481   addKey("CDR_DISPLAY", Unmapped_Key, 0x168B, 13);
1482   addKey("CDR_PAUSE", Unmapped_Key, 0x16B0, 13);
1483   addKey("CDR_PLAY", Unmapped_Key, 0x16B5, 13);
1484   addKey("CDR_NEXT", Unmapped_Key, 0x16A0, 13);
1485   addKey("CDR_PREV", Unmapped_Key, 0x16A1, 13);
1486   addKey("CDR_STOP", Unmapped_Key, 0x16B6, 13);
1487   addKey("CDR_FWD", Unmapped_Key, 0x16B4, 13);
1488   addKey("CDR_BWD", Unmapped_Key, 0x16B2, 13);
1489 }
1490
1491
1492 PhilipsAudio1a::PhilipsAudio1a(
1493   unsigned int index)
1494   : PhilipsAudio1(index)
1495 {
1496   setKeysetName("Audio Keyset 1a");
1497
1498   addControlledDevice(Philips_Make, "C 380", Audio_Device);
1499 }
1500
1501
1502 void PhilipsAudio1a::populateProtocol(
1503   QObject *guiObject)
1504 {
1505   if (threadableProtocol)
1506   {
1507     // If the pointer is not null, the keyset must already be populated.
1508     return;
1509   }
1510
1511   PhilipsAudio1::populateProtocol(guiObject);
1512
1513   addKey("VOL-", VolumeDown_Key, 0x1511, 13);
1514   addKey("VOL+", VolumeUp_Key, 0x1510, 13);
1515 }
1516
1517
1518 PhilipsAudio1b::PhilipsAudio1b(
1519   unsigned int index)
1520   : PhilipsAudio1(index)
1521 {
1522   setKeysetName("Audio Keyset 1b");
1523
1524   addControlledDevice(Philips_Make, "FW 362", Audio_Device);
1525 }
1526
1527
1528 void PhilipsAudio1b::populateProtocol(
1529   QObject *guiObject)
1530 {
1531   if (threadableProtocol)
1532   {
1533     // If the pointer is not null, the keyset must already be populated.
1534     return;
1535   }
1536
1537   PhilipsAudio1::populateProtocol(guiObject);
1538
1539   addKey("tv_power", Unmapped_Key, 0x100C, 13);
1540   addKey("tv_vcr", VCRInput_Key, 0x103F, 13);
1541   addKey("tape1", TapeInput_Key, 0x14AC, 13);
1542   addKey("tape2", Unmapped_Key, 0x14AE, 13);
1543   addKey("play", Play_Key, 0x1175, 13);
1544   addKey("pause", Pause_Key, 0x1170, 13);
1545   addKey("stop", Stop_Key, 0x1176, 13);
1546   addKey("skip_forw", Next_Key, 0x1020, 13);
1547   addKey("skip_back", Previous_Key, 0x1021, 13);
1548   addKey("forw", FastForward_Key, 0x1010, 13);
1549   addKey("back", Rewind_Key, 0x1011, 13);
1550   addKey("disc_up", NextDisc_Key, 0x151E, 13);
1551 }
1552
1553
1554 PhilipsAudio2::PhilipsAudio2(
1555   unsigned int index)
1556   : PIRKeysetMetaData(
1557       "Audio Keyset 2",
1558       Philips_Make,
1559       index)
1560 {
1561   addControlledDevice(Philips_Make, "FW2104", Audio_Device);
1562 }
1563
1564
1565 void PhilipsAudio2::populateProtocol(
1566   QObject *guiObject)
1567 {
1568   if (threadableProtocol)
1569   {
1570     // If the pointer is not null, the keyset must already be populated.
1571     return;
1572   }
1573
1574   threadableProtocol = new NECProtocol(guiObject, index, true, false);
1575
1576 //  setPreData(0x61CA, 16);
1577   setPreData(0x5386, 16);
1578
1579   addKey("POWER", Power_Key, 0x01, 8);
1580   addKey("TAPE", TapeInput_Key, 0x02, 8);
1581   addKey("CD", CDInput_Key, 0x03, 8);
1582   addKey("TUNER", TunerInput_Key, 0x04, 8);
1583   addKey("MUTE", Mute_Key, 0x06, 8);
1584   addKey("VOL_UP", VolumeUp_Key, 0x07, 8);
1585   addKey("VOL_DOWN", VolumeDown_Key, 0x08, 8);
1586   addKey("TUN_UP", ChannelUp_Key, 0x09, 8);
1587   addKey("TUN_DOWN", ChannelDown_Key, 0x0A, 8);
1588   addKey("SNOOZE", Unmapped_Key, 0x0B, 8);
1589   addKey("SLEEP", Sleep_Key, 0x0C, 8);
1590   addKey("TIMER", Timer_Key, 0x0D, 8);
1591   addKey("AUX", AuxInput_Key, 0x05, 8);
1592   addKey("REP_A_B", RepeatAB_Key, 0x13, 8);
1593   addKey("MEMORY", Program_Key, 0x14, 8);
1594   addKey("CANCEL", Clear_Key, 0x15, 8);
1595   addKey("0", Zero_Key, 0x16, 8);
1596   addKey("1", One_Key, 0x17, 8);
1597   addKey("2", Two_Key, 0x18, 8);
1598   addKey("3", Three_Key, 0x19, 8);
1599   addKey("4", Four_Key, 0x1A, 8);
1600   addKey("5", Five_Key, 0x1B, 8);
1601   addKey("6", Six_Key, 0x1C, 8);
1602   addKey("7", Seven_Key, 0x1D, 8);
1603   addKey("8", Eight_Key, 0x1E, 8);
1604   addKey("9", Nine_Key, 0x1F, 8);
1605   addKey("EJECT", Eject_Key, 0x40, 8);
1606   addKey("CD_PLAY", Play_Key, 0x41, 8);
1607   addKey("CD_STOP", Stop_Key, 0x42, 8);
1608   addKey("CD_FW", FastForward_Key, 0x43, 8);
1609   addKey("CD_REW", Rewind_Key, 0x44, 8);
1610   addKey("TIME", Unmapped_Key, 0x45, 8);
1611   addKey("REP_ALL_PRG", Repeat_Key, 0x46, 8);
1612   addKey("INTRO", Unmapped_Key, 0x47, 8);
1613   addKey("EDIT", Unmapped_Key, 0x48, 8);
1614   addKey("WARP", Unmapped_Key, 0x49, 8);
1615   addKey("SPACE", Unmapped_Key, 0x4A, 8);
1616   addKey("CHAIN", Unmapped_Key, 0x4B, 8);
1617   addKey("TAPE1_REW", Unmapped_Key, 0x5B, 8);
1618   addKey("TAPE1_BACKPLAY", Unmapped_Key, 0x59, 8);
1619   addKey("TAPE1_STOP", Unmapped_Key, 0x5C, 8);
1620   addKey("TAPE1_PLAY", Unmapped_Key, 0x58, 8);
1621   addKey("TAPE1_FW", Unmapped_Key, 0x5A, 8);
1622   addKey("TAPE2_REW", Unmapped_Key, 0x54, 8);
1623   addKey("TAPE2_BACKPLAY", Unmapped_Key, 0x52, 8);
1624   addKey("TAPE2_STOP", Unmapped_Key, 0x55, 8);
1625   addKey("TAPE2_PLAY", Unmapped_Key, 0x51, 8);
1626   addKey("TAPE2_FW", Unmapped_Key, 0x50, 8);
1627 //  addKey("PAUSE_RECORD", RecordPause_Key, 0x50, 8);
1628 }
1629
1630
1631 // This CD control is different enough from Audio1 that I figured I should
1632 // give it an entirely new keyset:
1633 PhilipsAudio3::PhilipsAudio3(
1634   unsigned int index)
1635   : PIRKeysetMetaData(
1636       "Audio Keyset 3",
1637       Philips_Make,
1638       index)
1639 {
1640   addControlledDevice(Philips_Make, "CD723", Audio_Device);
1641 }
1642
1643
1644 void PhilipsAudio3::populateProtocol(
1645   QObject *guiObject)
1646 {
1647   if (threadableProtocol)
1648   {
1649     // If the pointer is not null, the keyset must already be populated.
1650     return;
1651   }
1652
1653   threadableProtocol = new RC5Protocol(guiObject, index);
1654
1655   addKey("fade", Unmapped_Key, 0x0538, 13);
1656   addKey("0", Zero_Key, 0x1500, 13);
1657   addKey("1", One_Key, 0x1501, 13);
1658   addKey("2", Two_Key, 0x1502, 13);
1659   addKey("3", Three_Key, 0x1503, 13);
1660   addKey("4", Four_Key, 0x1504, 13);
1661   addKey("5", Five_Key, 0x1505, 13);
1662   addKey("6", Six_Key, 0x1506, 13);
1663   addKey("7", Seven_Key, 0x1507, 13);
1664   addKey("8", Eight_Key, 0x1508, 13);
1665   addKey("9", Nine_Key, 0x1509, 13);
1666   addKey("time", Unmapped_Key, 0x150B, 13);
1667   addKey("standby", Power_Key, 0x150C, 13);
1668   addKey("volume+", VolumeUp_Key, 0x1510, 13);
1669   addKey("volume-", VolumeDown_Key, 0x1511, 13);
1670   addKey("shuffle", Random_Key, 0x151C, 13);
1671   addKey("repeat", Repeat_Key, 0x151D, 13);
1672   addKey("next", Next_Key, 0x1520, 13);
1673   addKey("previous", Previous_Key, 0x1521, 13);
1674   addKey("program", Program_Key, 0x1524, 13);
1675   addKey("highlight", Unmapped_Key, 0x152B, 13); // "SCAN", "INDEX"
1676   addKey("pause", Pause_Key, 0x1530, 13);
1677   addKey("rewind", Rewind_Key, 0x1532, 13);
1678   addKey("wind", FastForward_Key, 0x1534, 13);
1679   addKey("play", Play_Key, 0x1535, 13);
1680   addKey("stop", Stop_Key, 0x1536, 13);
1681   addKey("OPEN/CLOSE", Eject_Key, 0x152D, 13);
1682   addKey("DISC", Unmapped_Key, 0x151E, 13);
1683 }
1684
1685
1686 PhilipsAudio4::PhilipsAudio4(
1687   unsigned int index)
1688   : PIRKeysetMetaData(
1689       "Audio Keyset 4",
1690       Philips_Make,
1691       index)
1692 {
1693 }
1694
1695
1696 void PhilipsAudio4::populateProtocol(
1697   QObject *guiObject)
1698 {
1699   if (threadableProtocol)
1700   {
1701     // If the pointer is not null, the keyset must already be populated.
1702     return;
1703   }
1704
1705   threadableProtocol = new RC5Protocol(guiObject, index);
1706
1707   addKey("EJECT", Eject_Key, 0x16AD, 13);
1708   addKey("INPUT", Input_Key, 0x16B8, 13);
1709   addKey("DISPLAY", Info_Key, 0x168B, 13);
1710   addKey("REPEAT", Repeat_Key, 0x169D, 13);
1711   addKey("1", One_Key, 0x1681, 13);
1712   addKey("2", Two_Key, 0x1682, 13);
1713   addKey("3", Three_Key, 0x1683, 13);
1714   addKey("4", Four_Key, 0x1684, 13);
1715   addKey("5", Five_Key, 0x1685, 13);
1716   addKey("6", Six_Key, 0x1686, 13);
1717   addKey("7", Seven_Key, 0x1687, 13);
1718   addKey("8", Eight_Key, 0x1688, 13);
1719   addKey("9", Nine_Key, 0x1689, 13);
1720   addKey("0", Zero_Key, 0x1680, 13);
1721   addKey("PAUSE", Pause_Key, 0x16B0, 13);
1722   addKey("STOP", Stop_Key, 0x16B6, 13);
1723   addKey("PREV", Previous_Key, 0x16A1, 13);
1724   addKey("PLAY", Play_Key, 0x16B5, 13);
1725   addKey("NEXT", Next_Key, 0x16A0, 13);
1726   addKey("REW", Rewind_Key, 0x16B2, 13);
1727   addKey("FAST", Unmapped_Key, 0x16AF, 13);
1728   addKey("FORW", FastForward_Key, 0x16B4, 13);
1729   addKey("TRACK_INCR", Unmapped_Key, 0x06B2, 13);
1730   addKey("PROGRAM", Program_Key, 0x16A4, 13);
1731   addKey("FINE_TUNE", Unmapped_Key, 0x06B4, 13);
1732   addKey("CD_SYNC", Unmapped_Key, 0x16A8, 13);
1733   addKey("REC", Record_Key, 0x16B7, 13);
1734 }