vcs.maemo.org Git - pierogi/blob - keysets/grundig.cpp

   1 #include "grundig.h"
   2 #include "protocols/rc5protocol.h"
   3 #include "protocols/necxprotocol.h"
   4 #include "protocols/necprotocol.h"
   5 #include "protocols/protonprotocol.h"
   6
   7 // This one is iffy, might be another brand:
   8 GrundigSat1::GrundigSat1(
   9   unsigned int index)
  10   : PIRKeysetMetaData(
  11       "Satellite Keyset 1",
  12       Grundig_Make,
  13       index)
  14 {
  15 }
  16
  17
  18 void GrundigSat1::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("Mute", Mute_Key, 0x0286, 13);
  30   addKey("Guide", Guide_Key, 0x028F, 13);
  31   addKey("Up", Up_Key, 0x0290, 13);
  32   addKey("Down", Down_Key, 0x0291, 13);
  33   addKey("Serv", Unmapped_Key, 0x0292, 13);
  34   addKey("Exit", Exit_Key, 0x0293, 13);
  35   addKey("Left", Left_Key, 0x0295, 13);
  36   addKey("Right", Right_Key, 0x0296, 13);
  37   addKey("OK", Select_Key, 0x0297, 13);
  38   addKey("Prefer", Unmapped_Key, 0x02A1, 13);
  39   addKey("Perso", Unmapped_Key, 0x02AA, 13);
  40   addKey("A", Unmapped_Key, 0x02AB, 13);
  41   addKey("B", Unmapped_Key, 0x02AC, 13);
  42   addKey("C", Unmapped_Key, 0x02AD, 13);
  43   addKey("D", Unmapped_Key, 0x02AE, 13);
  44   addKey("E", Unmapped_Key, 0x02AF, 13);
  45
  46   addKey("1", One_Key, 0x1281, 13);
  47   addKey("2", Two_Key, 0x1282, 13);
  48   addKey("3", Three_Key, 0x1283, 13);
  49   addKey("4", Four_Key, 0x1284, 13);
  50   addKey("5", Five_Key, 0x1285, 13);
  51   addKey("6", Six_Key, 0x1286, 13);
  52   addKey("7", Seven_Key, 0x1287, 13);
  53   addKey("8", Eight_Key, 0x1288, 13);
  54   addKey("9", Nine_Key, 0x1289, 13);
  55   addKey("0", Zero_Key, 0x1280, 13);
  56   addKey("Standby", Power_Key, 0x128C, 13);
  57   addKey("Info", Info_Key, 0x128F, 13);
  58   addKey("TV/Sat", Input_Key, 0x12A8, 13);
  59   addKey("Plus", Unmapped_Key, 0x12AF, 13);
  60 }
  61
  62
  63 GrundigSat2::GrundigSat2(
  64   unsigned int index)
  65   : PIRKeysetMetaData(
  66       "Satellite Keyset 2",
  67       Grundig_Make,
  68       index)
  69 {
  70   addControlledDevice(Grundig_Make, "STR 7100", Sat_Device);
  71 }
  72
  73
  74 void GrundigSat2::populateProtocol(
  75   QObject *guiObject)
  76 {
  77   if (threadableProtocol)
  78   {
  79     // If the pointer is not null, the keyset must already be populated.
  80     return;
  81   }
  82
  83   threadableProtocol = new RC5Protocol(guiObject, index);
  84
  85   addKey("POWER", Power_Key, 0x017B, 13);
  86   addKey("Audio", Audio_Key, 0x00D3, 13);
  87   addKey(">|", StepForward_Key, 0x008B, 13);
  88   addKey("|<", StepBack_Key, 0x00BB, 13);
  89   addKey("1", One_Key, 0x00EB, 13);
  90   addKey("2", Two_Key, 0x016B, 13);
  91   addKey("3", Three_Key, 0x006B, 13);
  92   addKey("4", Four_Key, 0x01AB, 13);
  93   addKey("5", Five_Key, 0x00AB, 13);
  94   addKey("6", Six_Key, 0x012B, 13);
  95   addKey("7", Seven_Key, 0x002B, 13);
  96   addKey("8", Eight_Key, 0x01CB, 13);
  97   addKey("9", Nine_Key, 0x00CB, 13);
  98   addKey("0", Zero_Key, 0x01EB, 13);
  99   addKey("i", Info_Key, 0x0093, 13);  // "OSD"
 100   addKey("MUTE", Mute_Key, 0x00FB, 13);
 101   addKey("P+", ChannelUp_Key, 0x0153, 13);
 102   addKey("P-", ChannelDown_Key, 0x0053, 13);
 103   addKey("-", VolumeDown_Key, 0x00DB, 13);
 104   addKey("+", VolumeUp_Key, 0x01DB, 13);
 105   addKey("OK", Select_Key, 0x01FB, 13);
 106   addKey("AUX", AuxInput_Key, 0x003B, 13); // "DiscMenu"
 107   addKey("TXT", Teletext_Key, 0x01E3, 13);
 108   addKey("RED", Red_Key, 0x0143, 13);
 109   addKey("GREEN", Green_Key, 0x0103, 13);
 110   addKey("YELLOW", Yellow_Key, 0x0043, 13);
 111   addKey("BLUE", Blue_Key, 0x0113, 13);
 112   addKey("COL-", ColorDown_Key, 0x009B, 13);
 113   addKey("COL+", ColorUp_Key, 0x019B, 13);
 114   addKey("BRIGHT-", BrightnessDown_Key, 0x005B, 13);
 115   addKey("BRIGHT+", BrightnessUp_Key, 0x015B, 13);
 116   addKey("TV-G", Unmapped_Key, 0x01BB, 13);
 117 }
 118
 119
 120 GrundigSat3::GrundigSat3(
 121   unsigned int index)
 122   : PIRKeysetMetaData(
 123       "Satellite Keyset 3",
 124       Grundig_Make,
 125       index)
 126 {
 127 }
 128
 129
 130 void GrundigSat3::populateProtocol(
 131   QObject *guiObject)
 132 {
 133   if (threadableProtocol)
 134   {
 135     // Keyset already populated.
 136     return;
 137   }
 138
 139   threadableProtocol = new NECProtocol(guiObject, index, false, true);
 140
 141   setPreData(0x80, 8);
 142
 143   addKey("menu", Menu_Key, 0x12, 8);
 144   addKey("Ch-", ChannelDown_Key, 0x16, 8);
 145   addKey("3", Three_Key, 0x40, 8);
 146   addKey("2", Two_Key, 0x41, 8);
 147   addKey("1", One_Key, 0x42, 8);
 148   addKey("6", Six_Key, 0x44, 8);
 149   addKey("5", Five_Key, 0x45, 8);
 150   addKey("4", Four_Key, 0x46, 8);
 151   addKey("0", Zero_Key, 0x47, 8);
 152   addKey("9", Nine_Key, 0x48, 8);
 153   addKey("8", Eight_Key, 0x49, 8);
 154   addKey("7", Seven_Key, 0x4A, 8);
 155   addKey("mute", Mute_Key, 0x4C, 8);
 156   addKey("up", Up_Key, 0x4E, 8);
 157   addKey("sub", Captions_Key, 0x73, 8);
 158   addKey("OK", Select_Key, 0x75, 8);
 159   addKey("Yellow", Yellow_Key, 0x78, 8);
 160   addKey("text", Teletext_Key, 0x7B, 8);
 161   addKey("Vol-", VolumeDown_Key, 0x7D, 8);
 162   addKey("exit", Exit_Key, 0x7E, 8);
 163   addKey("AD", Unmapped_Key, 0x7F, 8);
 164   addKey("power", Power_Key, 0xB2, 8);
 165   addKey("TV/DTV", TunerInput_Key, 0xB7, 8);
 166   addKey("Guide", Guide_Key, 0xB8, 8);
 167   addKey("Info", Info_Key, 0xB9, 8);
 168   addKey("Green", Green_Key, 0xBA, 8);
 169   addKey("Red", Red_Key, 0xBB, 8);
 170   addKey("down", Down_Key, 0xBE, 8);
 171   addKey("right", Right_Key, 0xC4, 8);
 172   addKey("left", Left_Key, 0xC8, 8);
 173   addKey("Blue", Blue_Key, 0xCC, 8);
 174   addKey("wide", AspectRatio_Key, 0xCF, 8);
 175   addKey("back", PrevChannel_Key, 0xD2, 8);
 176   addKey("Vol+", VolumeUp_Key, 0xD4, 8);
 177   addKey("Ch List", Unmapped_Key, 0xD5, 8);
 178   addKey("Ch+", ChannelUp_Key, 0xD6, 8);
 179   addKey("Swap", Unmapped_Key, 0xD8, 8);
 180 }
 181
 182
 183 GrundigAmp1::GrundigAmp1(
 184   unsigned int index)
 185   : PIRKeysetMetaData(
 186       "Amp Keyset 1",
 187       Grundig_Make,
 188       index)
 189 {
 190   addControlledDevice(Grundig_Make, "FineArts Amplifier V1", Audio_Device);
 191 }
 192
 193
 194 void GrundigAmp1::populateProtocol(
 195   QObject *guiObject)
 196 {
 197   if (threadableProtocol)
 198   {
 199     // If the pointer is not null, the keyset must already be populated.
 200     return;
 201   }
 202
 203   threadableProtocol = new RC5Protocol(guiObject, index);
 204
 205   addKey("number_10", Zero_Key, 0x1C00, 13);
 206   addKey("number_1", One_Key, 0x1C01, 13);
 207   addKey("number_2", Two_Key, 0x1C02, 13);
 208   addKey("number_3", Three_Key, 0x1C03, 13);
 209   addKey("number_4", Four_Key, 0x1C04, 13);
 210   addKey("number_5", Five_Key, 0x1C05, 13);
 211   addKey("number_6", Six_Key, 0x1C06, 13);
 212   addKey("number_7", Seven_Key, 0x1C07, 13);
 213   addKey("number_8", Eight_Key, 0x1C08, 13);
 214   addKey("number_9", Nine_Key, 0x1C09, 13);
 215   addKey("mute", Mute_Key, 0x1C0D, 13);
 216   addKey("volume_+", VolumeUp_Key, 0x1C10, 13);
 217   addKey("volume_-", VolumeDown_Key, 0x1C11, 13);
 218   addKey("standby", Power_Key, 0x1C3D, 13);
 219
 220   addKey("tuner_up", ChannelUp_Key, 0x1C60, 13);
 221   addKey("tuner_down", ChannelDown_Key, 0x1C61, 13);
 222   addKey("tuner", TunerInput_Key, 0x1C7F, 13);
 223
 224   addKey("tape_play_back", Unmapped_Key, 0x1CAF, 13);
 225   addKey("tape_pause", Unmapped_Key, 0x1CB0, 13);
 226   addKey("tape_fastrewind", Unmapped_Key, 0x1CB2, 13);
 227   addKey("tape_fastforward", Unmapped_Key, 0x1CB4, 13);
 228   addKey("tape_play_forward", Unmapped_Key, 0x1CB5, 13);
 229   addKey("tape_stop", Unmapped_Key, 0x1CB6, 13);
 230   addKey("tape_record", Unmapped_Key, 0x1CB7, 13);
 231   addKey("tape", TapeInput_Key, 0x1CBF, 13);
 232
 233   addKey("cd_fastforward", FastForward_Key, 0x1D20, 13);
 234   addKey("cd_fastrewind", Rewind_Key, 0x1D21, 13);
 235   addKey("cd_pause", Pause_Key, 0x1D30, 13);
 236   addKey("cd_play", Play_Key, 0x1D35, 13);
 237   addKey("cd_stop", Stop_Key, 0x1D36, 13);
 238   addKey("cd", CDInput_Key, 0x1D3F, 13);
 239
 240   addKey("phono", PhonoInput_Key, 0x1D7F, 13);
 241   addKey("dsr_up", Unmapped_Key, 0x1DA0, 13);
 242   addKey("dsr_down", Unmapped_Key, 0x1DA1, 13);
 243   addKey("dsr_aux", AuxInput_Key, 0x1DBF, 13);
 244
 245   addKey("dcc_play_back", Unmapped_Key, 0x1DEF, 13);
 246   addKey("dcc_pause", Unmapped_Key, 0x1DF0, 13);
 247   addKey("dcc_fastrewind", Unmapped_Key, 0x1DF2, 13);
 248   addKey("dcc_fastforward", Unmapped_Key, 0x1DF4, 13);
 249   addKey("dcc_play_forward", Unmapped_Key, 0x1DF5, 13);
 250   addKey("dcc_stop", Unmapped_Key, 0x1DF6, 13);
 251   addKey("dcc_record", Unmapped_Key, 0x1DF7, 13);
 252   addKey("dcc", Unmapped_Key, 0x1DFF, 13);
 253 }
 254
 255
 256 GrundigAudio1::GrundigAudio1(
 257   unsigned int index)
 258   : PIRKeysetMetaData(
 259       "Audio(CD) Keyset 1",
 260       Grundig_Make,
 261       index)
 262 {
 263   addControlledDevice(Grundig_Make, "CD 8400", Audio_Device);
 264 }
 265
 266
 267 void GrundigAudio1::populateProtocol(
 268   QObject *guiObject)
 269 {
 270   if (threadableProtocol)
 271   {
 272     // If the pointer is not null, the keyset must already be populated.
 273     return;
 274   }
 275
 276   threadableProtocol = new RC5Protocol(guiObject, index);
 277
 278   addKey("0", Zero_Key, 0x1D00, 13);
 279   addKey("1", One_Key, 0x1D01, 13);
 280   addKey("2", Two_Key, 0x1D02, 13);
 281   addKey("3", Three_Key, 0x1D03, 13);
 282   addKey("4", Four_Key, 0x1D04, 13);
 283   addKey("5", Five_Key, 0x1D05, 13);
 284   addKey("6", Six_Key, 0x1D06, 13);
 285   addKey("7", Seven_Key, 0x1D07, 13);
 286   addKey("8", Eight_Key, 0x1D08, 13);
 287   addKey("9", Nine_Key, 0x1D09, 13);
 288   addKey("10+", DoubleDigit_Key, 0x1D0A, 13); // hack
 289   addKey("20+", PlusOneHundred_Key, 0x1D0B, 13); // also hack
 290
 291   addKey("repeat", Repeat_Key, 0x1D1D, 13);
 292
 293   addKey("track+", Next_Key, 0x1D20, 13);
 294   addKey("track-", Previous_Key, 0x1D21, 13);
 295   addKey("index+", Unmapped_Key, 0x1D22, 13);
 296   addKey("index-", Unmapped_Key, 0x1D23, 13);
 297   addKey("store", Memory_Key, 0x1D29, 13);
 298   addKey("scan", Scan_Key, 0x1D2B, 13);
 299
 300   addKey("pause", Pause_Key, 0x1D30, 13);
 301   addKey("skip-", Replay_Key, 0x1D32, 13);
 302   addKey("skip+", Advance_Key, 0x1D34, 13);
 303   addKey("play", Play_Key, 0x1D35, 13);
 304   addKey("stop", Stop_Key, 0x1D36, 13);
 305 }
 306
 307
 308 GrundigAudio2::GrundigAudio2(
 309   unsigned int index)
 310   : PIRKeysetMetaData(
 311       "Audio Keyset 2",
 312       Grundig_Make,
 313       index)
 314 {
 315   addControlledDevice(Grundig_Make, "CDM 700", Audio_Device);
 316   addControlledDevice(Grundig_Make, "UMS-9V", Audio_Device);
 317 }
 318
 319
 320 void GrundigAudio2::populateProtocol(
 321   QObject *guiObject)
 322 {
 323   if (threadableProtocol)
 324   {
 325     // If the pointer is not null, the keyset must already be populated.
 326     return;
 327   }
 328
 329   threadableProtocol = new NECXProtocol(guiObject, index, true);
 330
 331   setPreData(0xA2A2, 16);
 332
 333   addKey("1", One_Key, 0x01, 8);
 334   addKey("5", Five_Key, 0x02, 8);
 335   addKey("9", Nine_Key, 0x03, 8);
 336   addKey("tuning_down", ChannelDown_Key, 0x04, 8);
 337   addKey("display", Info_Key, 0x05, 8); // "MODE_remain
 338   addKey("on/off", Power_Key, 0x06, 8);
 339   addKey("tuner", TunerInput_Key, 0x07, 8);
 340   addKey("2", Two_Key, 0x09, 8);
 341   addKey("6", Six_Key, 0x0A, 8);
 342   addKey("0", Zero_Key, 0x0B, 8);
 343   addKey("tuning_up", ChannelUp_Key, 0x0C, 8);
 344   addKey("random", Random_Key, 0x0D, 8);
 345   addKey("band", FM_Key, 0x0E, 8);  // This is a hack
 346   addKey("band", AM_Key, 0x0E, 8);  // This too
 347   addKey("cd", CDInput_Key, 0x0F, 8);
 348
 349   addKey("3", Three_Key, 0x11, 8);
 350   addKey("7", Seven_Key, 0x12, 8);
 351   addKey("play/pause", Play_Key, 0x13, 8);
 352   addKey("play/pause", Pause_Key, 0x13, 8);
 353   addKey("time_program", Program_Key, 0x14, 8); // "MEMORY_clock"
 354   addKey("intro", Unmapped_Key, 0x15, 8);
 355   addKey("SLEEP", Sleep_Key, 0x17, 8);
 356   addKey("4", Four_Key, 0x19, 8);
 357   addKey("8", Eight_Key, 0x1A, 8);
 358   addKey("stop", Stop_Key, 0x1B, 8);
 359   addKey("repeat/scan", Repeat_Key, 0x1C, 8);
 360   addKey("repeat/scan", Scan_Key, 0x1C, 8);
 361   addKey("BASS", EnhancedBass_Key, 0x1D, 8);
 362   addKey("tape", TapeInput_Key, 0x1E, 8);
 363   addKey("TIMER", Timer_Key, 0x1F, 8);
 364
 365   addKey("volume_up", VolumeUp_Key, 0x20, 8);
 366   addKey("volume_down", VolumeDown_Key, 0x60, 8);
 367   addKey("mute", Mute_Key, 0xA0, 8);
 368   addKey("+10", DoubleDigit_Key, 0xE0, 8);
 369 }
 370
 371
 372 GrundigVCR1::GrundigVCR1(
 373   unsigned int index)
 374   : PIRKeysetMetaData(
 375       "VCR Keyset 1",
 376       Grundig_Make,
 377       index)
 378 {
 379   addControlledDevice(Grundig_Make, "GV 437", VCR_Device);
 380 }
 381
 382
 383 void GrundigVCR1::populateProtocol(
 384   QObject *guiObject)
 385 {
 386   if (threadableProtocol)
 387   {
 388     // If the pointer is not null, the keyset must already be populated.
 389     return;
 390   }
 391
 392   threadableProtocol = new RC5Protocol(guiObject, index);
 393
 394   addKey("SYSTEM", Menu_Key, 0x014A, 13);
 395   addKey("OK", Select_Key, 0x0157, 13);
 396   addKey("next", Next_Key, 0x0170, 13);
 397   addKey("previous", Previous_Key, 0x0171, 13);
 398   addKey("MONITOR", Unmapped_Key, 0x017A, 13);
 399   addKey("tuner", TunerInput_Key, 0x017D, 13);
 400   addKey("cass", Eject_Key, 0x017E, 13); // might be wrong
 401
 402   addKey("0", Zero_Key, 0x1140, 13);
 403   addKey("1", One_Key, 0x1141, 13);
 404   addKey("2", Two_Key, 0x1142, 13);
 405   addKey("3", Three_Key, 0x1143, 13);
 406   addKey("4", Four_Key, 0x1144, 13);
 407   addKey("5", Five_Key, 0x1145, 13);
 408   addKey("6", Six_Key, 0x1146, 13);
 409   addKey("7", Seven_Key, 0x1147, 13);
 410   addKey("8", Eight_Key, 0x1148, 13);
 411   addKey("9", Nine_Key, 0x1149, 13);
 412   addKey("SELECT", Enter_Key, 0x114B, 13); // "selvps"
 413   addKey("standby", Power_Key, 0x114C, 13); // "OFF"
 414   addKey("tracking", AutoTracking_Key, 0x114E, 13);
 415
 416   addKey("TIMER", Timer_Key, 0x115D, 13);
 417
 418   // Just guessing at what + and - mean here:
 419   addKey("+", ChannelUp_Key, 0x1160, 13);
 420   addKey("-", ChannelDown_Key, 0x1161, 13);
 421   addKey("REW", Rewind_Key, 0x1165, 13);
 422   addKey("FF", FastForward_Key, 0x1166, 13);
 423
 424   addKey("CLEAR", Clear_Key, 0x1171, 13);
 425   addKey("PLAY", Play_Key, 0x1175, 13);
 426   addKey("pausestop", Pause_Key, 0x1176, 13); // "STOP"
 427   addKey("pausestop", Stop_Key, 0x1176, 13); // "STOP"
 428   addKey("RECORD", Record_Key, 0x1177, 13);
 429   addKey("SP/LP", VHSSpeed_Key, 0x117A, 13);
 430 }
 431
 432
 433 GrundigVCR1a::GrundigVCR1a(
 434   unsigned int index)
 435   : GrundigVCR1(index)
 436 {
 437   setKeysetName("VCR Keyset 1a");
 438 }
 439
 440
 441 void GrundigVCR1a::populateProtocol(
 442   QObject *guiObject)
 443 {
 444   if (threadableProtocol)
 445   {
 446     // If the pointer is not null, the keyset must already be populated.
 447     return;
 448   }
 449
 450   GrundigVCR1::populateProtocol(guiObject);
 451
 452   addKey("INDEX", IndexSearch_Key, 0x0170, 13);
 453   addKey("PAUSE", Pause_Key, 0x1169, 13);
 454 }
 455
 456
 457 GrundigTV1::GrundigTV1(
 458   unsigned int index)
 459   : PIRKeysetMetaData(
 460       "TV Keyset 1",
 461       Grundig_Make,
 462       index)
 463 {
 464   addControlledDevice(Grundig_Make, "ST 55-908", TV_Device);
 465 }
 466
 467
 468 void GrundigTV1::populateProtocol(
 469   QObject *guiObject)
 470 {
 471   if (threadableProtocol)
 472   {
 473     // If the pointer is not null, the keyset must already be populated.
 474     return;
 475   }
 476
 477   threadableProtocol = new RC5Protocol(guiObject, index);
 478
 479   addKey("leer", Unmapped_Key, 0x0000, 13);
 480   addKey("POWER", Power_Key, 0x017F, 13);
 481   addKey("1", One_Key, 0x00EF, 13);
 482   addKey("2", Two_Key, 0x016F, 13);
 483   addKey("3", Three_Key, 0x006F, 13);
 484   addKey("4", Four_Key, 0x01AF, 13);
 485   addKey("5", Five_Key, 0x00AF, 13);
 486   addKey("6", Six_Key, 0x012F, 13);
 487   addKey("7", Seven_Key, 0x002F, 13);
 488   addKey("8", Eight_Key, 0x1CF, 13);
 489   addKey("9", Nine_Key, 0x00CF, 13);
 490   addKey("0", Zero_Key, 0x01EF, 13);
 491   addKey("AUX2", Unmapped_Key, 0x014F, 13);
 492   addKey("BR+", BrightnessUp_Key, 0x015F, 13);
 493   addKey("BR-", BrightnessDown_Key, 0x005F, 13);
 494   addKey("COLOR+", ColorUp_Key, 0x019F, 13);
 495   addKey("COLOR-", ColorDown_Key, 0x009F, 13);
 496   addKey("AUX", AuxInput_Key, 0x003F, 13);
 497   addKey("I", Info_Key, 0x0097, 13); // "Info"
 498   addKey("TXT", Teletext_Key, 0x01E7, 13);
 499   addKey("P+", ChannelUp_Key, 0x0157, 13);
 500   addKey("P+", Up_Key, 0x0157, 13);
 501   addKey("VOL-", VolumeDown_Key, 0x00DF, 13);
 502   addKey("VOL-", Left_Key, 0x00DF, 13);
 503   addKey("OK", Select_Key, 0x01FF, 13);
 504   addKey("VOL+", VolumeUp_Key, 0x01DF, 13);
 505   addKey("VOL+", Right_Key, 0x01DF, 13);
 506   addKey("P-", ChannelDown_Key, 0x0057, 13);
 507   addKey("P-", Down_Key, 0x0057, 13);
 508   addKey("MUTE", Mute_Key, 0x00FF, 13);
 509   addKey("BLUE", Blue_Key, 0x0117, 13);
 510   addKey("YELLOW", Yellow_Key, 0x0047, 13);
 511   addKey("GREEN", Green_Key, 0x0107, 13);
 512   addKey("RED", Red_Key, 0x0147, 13);
 513 }
 514
 515
 516 GrundigTV2::GrundigTV2(
 517   unsigned int index)
 518   : PIRKeysetMetaData(
 519       "TV Keyset 2",
 520       Grundig_Make,
 521       index)
 522 {
 523 }
 524
 525
 526 void GrundigTV2::populateProtocol(
 527   QObject *guiObject)
 528 {
 529   if (threadableProtocol)
 530   {
 531     // If the pointer is not null, the keyset must already be populated.
 532     return;
 533   }
 534
 535   threadableProtocol = new RC5Protocol(guiObject, index);
 536
 537   addKey("P+", ChannelUp_Key, 0x0010, 13);
 538   addKey("P+", Up_Key, 0x0010, 13);
 539   addKey("P-", ChannelDown_Key, 0x0011, 13);
 540   addKey("P-", Down_Key, 0x0011, 13);
 541   addKey("info", Info_Key, 0x0012, 13);
 542   addKey("<-", VolumeDown_Key, 0x0015, 13);
 543   addKey("<-", Left_Key, 0x0015, 13);
 544   addKey("+>", VolumeUp_Key, 0x0016, 13);
 545   addKey("+>", Right_Key, 0x0016, 13);
 546   addKey("OK", Select_Key, 0x0017, 13);
 547
 548   addKey("NEXT", Next_Key, 0x0170, 13);
 549   addKey("PREV", Previous_Key, 0x0171, 13);
 550
 551   addKey("0AV", Zero_Key, 0x1000, 13); // also AV?
 552   addKey("1", One_Key, 0x1001, 13);
 553   addKey("2", Two_Key, 0x1002, 13);
 554   addKey("3", Three_Key, 0x1003, 13);
 555   addKey("4", Four_Key, 0x1004, 13);
 556   addKey("5", Five_Key, 0x1005, 13);
 557   addKey("6", Six_Key, 0x1006, 13);
 558   addKey("7", Seven_Key, 0x1007, 13);
 559   addKey("8", Eight_Key, 0x1008, 13);
 560   addKey("9", Nine_Key, 0x1009, 13);
 561   addKey("power", Power_Key, 0x100C, 13);
 562   addKey("mute", Mute_Key, 0x100D, 13);
 563
 564   addKey("br+", BrightnessUp_Key, 0x1012, 13);
 565   addKey("br-", BrightnessDown_Key, 0x1013, 13);
 566   addKey("col+", ColorUp_Key, 0x1014, 13);
 567   addKey("col-", ColorDown_Key, 0x1015, 13);
 568
 569   addKey("PC/CL", Unmapped_Key, 0x1031, 13);
 570
 571   addKey("TXT", Teletext_Key, 0x115D, 13);
 572   addKey("<<", Rewind_Key, 0x1165, 13);
 573   addKey(">>", FastForward_Key, 0x1166, 13);
 574   addKey("||", Pause_Key, 0x1169, 13);
 575   addKey(">", Play_Key, 0x1175, 13);
 576   addKey("stop", Stop_Key, 0x1176, 13);
 577   addKey("REC", Record_Key, 0x1177, 13);
 578 }
 579
 580
 581 GrundigTV3::GrundigTV3(
 582   unsigned int index)
 583   : PIRKeysetMetaData(
 584       "TV/VDR Keyset 3",
 585       Grundig_Make,
 586       index)
 587 {
 588 }
 589
 590
 591 void GrundigTV3::populateProtocol(
 592   QObject *guiObject)
 593 {
 594   if (threadableProtocol)
 595   {
 596     // If the pointer is not null, the keyset must already be populated.
 597     return;
 598   }
 599
 600   threadableProtocol = new RC5Protocol(guiObject, index);
 601
 602   addKey("USR4", Unmapped_Key, 0x0205, 13);
 603   addKey("INFO", Info_Key, 0x0206, 13);
 604   addKey("BACK", Exit_Key, 0x020F, 13);
 605   addKey("UP", Up_Key, 0x0210, 13);
 606   addKey("DOWN", Down_Key, 0x0211, 13);
 607   addKey("LEFT", Left_Key, 0x0215, 13);
 608   addKey("RIGHT", Right_Key, 0x0216, 13);
 609   addKey("OK", Select_Key, 0x0217, 13);
 610
 611   addKey("RED", Red_Key, 0x022B, 13);
 612   addKey("GREEN", Green_Key, 0x022C, 13);
 613   addKey("YEL", Yellow_Key, 0x022D, 13);
 614   addKey("BLU", Blue_Key, 0x022E, 13);
 615   addKey("USR2", Unmapped_Key, 0x0235, 13);
 616   addKey("USR1", Unmapped_Key, 0x023E, 13);
 617
 618   addKey("0", Zero_Key, 0x1200, 13);
 619   addKey("1", One_Key, 0x1201, 13);
 620   addKey("2", Two_Key, 0x1202, 13);
 621   addKey("3", Three_Key, 0x1203, 13);
 622   addKey("4", Four_Key, 0x1204, 13);
 623   addKey("5", Five_Key, 0x1205, 13);
 624   addKey("6", Six_Key, 0x1206, 13);
 625   addKey("7", Seven_Key, 0x1207, 13);
 626   addKey("8", Eight_Key, 0x1208, 13);
 627   addKey("9", Nine_Key, 0x1209, 13);
 628
 629   addKey("MUTE", Mute_Key, 0x120D, 13);
 630   addKey("REC", Record_Key, 0x120E, 13);
 631   addKey("VOL+", VolumeUp_Key, 0x1210, 13);
 632   addKey("VOL-", VolumeDown_Key, 0x1211, 13);
 633   addKey("NEXT", Next_Key, 0x121E, 13);
 634   addKey("PREV", Previous_Key, 0x121F, 13);
 635   addKey("CHANNEL+", ChannelUp_Key, 0x1220, 13);
 636   addKey("CHANNEL-", ChannelDown_Key, 0x1221, 13);
 637   addKey("CEC", Unmapped_Key, 0x1222, 13);
 638   addKey("USR3", Unmapped_Key, 0x1223, 13);
 639   addKey("REW", Rewind_Key, 0x122C, 13);
 640   addKey("FF", FastForward_Key, 0x122E, 13);
 641
 642   addKey("PAUSE", Pause_Key, 0x1230, 13);
 643   addKey("PLAY", Play_Key, 0x1235, 13);
 644   addKey("STOP", Stop_Key, 0x1236, 13);
 645   addKey("MENU", Menu_Key, 0x123C, 13);
 646 }
 647
 648
 649 GrundigTV4::GrundigTV4(
 650   unsigned int index)
 651   : PIRKeysetMetaData(
 652       "TV Keyset 4",
 653       Grundig_Make,
 654       index)
 655 {
 656 }
 657
 658
 659 void GrundigTV4::populateProtocol(
 660   QObject *guiObject)
 661 {
 662   if (threadableProtocol)
 663   {
 664     // Keyset already populated.
 665     return;
 666   }
 667
 668   threadableProtocol = new ProtonProtocol(guiObject, index);
 669
 670   setPreData(0x1B, 8);
 671
 672   addKey("vol-", VolumeDown_Key, 0x00, 8);
 673   addKey("vol+", VolumeUp_Key, 0x04, 8);
 674   addKey("exp", Unmapped_Key, 0x05, 8);
 675   addKey("tune", Unmapped_Key, 0x07, 8);
 676   addKey("mute", Mute_Key, 0x08, 8);
 677   addKey("text/mix", TeletextMix_Key, 0x09, 8);
 678   addKey("hold", TeletextHold_Key, 0x0A, 8);
 679   addKey("menu", Menu_Key, 0x0C, 8);
 680   addKey("0", Zero_Key, 0x0D, 8);
 681   addKey("tv", Input_Key, 0x0E, 8); // not sure
 682   addKey("7", Seven_Key, 0x10, 8);
 683   addKey("8", Eight_Key, 0x11, 8);
 684   addKey("9", Nine_Key, 0x12, 8);
 685   addKey("ch-", ChannelDown_Key, 0x13, 8);
 686   addKey("4", Four_Key, 0x14, 8);
 687   addKey("5", Five_Key, 0x15, 8);
 688   addKey("6", Six_Key, 0x16, 8);
 689   addKey("ch+", ChannelUp_Key, 0x17, 8);
 690   addKey("1", One_Key, 0x18, 8);
 691   addKey("2", Two_Key, 0x19, 8);
 692   addKey("3", Three_Key, 0x1A, 8);
 693   addKey("info", Info_Key, 0x1C, 8);
 694   addKey("store", Unmapped_Key, 0x1D, 8);
 695   addKey("power", Power_Key, 0x1F, 8);
 696 }
 697
 698
 699 GrundigDVD1::GrundigDVD1(
 700   unsigned int index)
 701   : PIRKeysetMetaData(
 702       "DVD Keyset 1",
 703       Grundig_Make,
 704       index)
 705 {
 706   addControlledDevice(Grundig_Make, "GDV 130", DVD_Device);
 707 }
 708
 709
 710 void GrundigDVD1::populateProtocol(
 711   QObject *guiObject)
 712 {
 713   if (threadableProtocol)
 714   {
 715     // If the pointer is not null, the keyset must already be populated.
 716     return;
 717   }
 718
 719   threadableProtocol = new NECProtocol(guiObject, index, false, true);
 720
 721   setPreData(0x10, 8);
 722
 723   addKey("POWER", Power_Key, 0x00, 8);
 724   addKey("FF_SF", FastForward_Key, 0x01, 8);
 725   addKey("OPEN_CLOSE", Eject_Key, 0x02, 8);
 726   addKey("ARROW_LEFT", Left_Key, 0x03, 8);
 727   addKey("STEP", StepForward_Key, 0x04, 8);
 728   addKey("PREV", Previous_Key, 0x05, 8);
 729   addKey("DISPLAY", Info_Key, 0x06, 8);
 730   addKey("NEXT", Next_Key, 0x07, 8);
 731   addKey("1", One_Key, 0x08, 8);
 732   addKey("2", Two_Key, 0x09, 8);
 733   addKey("3", Three_Key, 0x0A, 8);
 734   addKey("ARROW_UP", Up_Key, 0x0B, 8);
 735   addKey("FR_SR", Rewind_Key, 0x0C, 8);
 736   addKey("SETUP", Menu_Key, 0x0D, 8);
 737   addKey("TITLE", DiscTitle_Key, 0x0E, 8);
 738   addKey("MENU", DiscMenu_Key, 0x0F, 8);
 739
 740   addKey("4", Four_Key, 0x10, 8);
 741   addKey("5", Five_Key, 0x11, 8);
 742   addKey("6", Six_Key, 0x12, 8);
 743   addKey("SELECT", Select_Key, 0x13, 8);
 744   addKey("DIGEST", Unmapped_Key, 0x14, 8);
 745   addKey("ANGLE", Angle_Key, 0x15, 8);
 746   addKey("SUBTITLE", Captions_Key, 0x16, 8);
 747   addKey("AUDIO", Audio_Key, 0x17, 8);
 748   addKey("7", Seven_Key, 0x18, 8);
 749   addKey("8", Eight_Key, 0x19, 8);
 750   addKey("9", Nine_Key, 0x1A, 8);
 751   addKey("ARROW_RIGHT", Right_Key, 0x1B, 8);
 752   addKey("PROGRAM", Program_Key, 0x1C, 8);
 753   addKey("VOLUME_UP", VolumeUp_Key, 0x1D, 8);
 754   addKey("ZOOM", Zoom_Key, 0x1E, 8);
 755   addKey("3D_SOUND", Surround_Key, 0x1F, 8);
 756
 757   addKey("CLEAR", Clear_Key, 0x40, 8);
 758   addKey("0", Zero_Key, 0x41, 8);
 759   addKey("PCB", Unmapped_Key, 0x42, 8);
 760   addKey("ARROW_DOWN", Down_Key, 0x43, 8);
 761   addKey("SHUFFLE", Random_Key, 0x44, 8);
 762   addKey("VOLUME_DOWN", VolumeDown_Key, 0x45, 8);
 763   addKey("REPEAT", Repeat_Key, 0x46, 8);
 764   addKey("A-B", RepeatAB_Key, 0x47, 8);
 765   addKey("STOP/RETURN", Stop_Key, 0x48, 8);
 766   addKey("STOP/RETURN", Exit_Key, 0x48, 8);
 767   addKey("PLAY/PAUSE", Play_Key, 0x49, 8);
 768   addKey("PLAY/PAUSE", Pause_Key, 0x49, 8);
 769   addKey("MARKER", Unmapped_Key, 0x4A, 8);
 770 }