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

   1 #include "panasonic.h"
   2 #include "protocols/necprotocol.h"
   3 #include "protocols/kaseikyoprotocol.h"
   4 #include "protocols/panasonicoldprotocol.h"
   5
   6
   7 PanasonicCarAudio::PanasonicCarAudio(
   8   unsigned int index)
   9   : PIRKeysetMetaData(
  10       "Car Audio Keyset",
  11       Panasonic_Make,
  12       index)
  13 {
  14 }
  15
  16
  17 void PanasonicCarAudio::populateProtocol(
  18   QObject *guiObject)
  19 {
  20   if (threadableProtocol)
  21   {
  22     // If the pointer is not null, the keyset must already be populated.
  23     return;
  24   }
  25
  26   threadableProtocol = new NECProtocol(guiObject, index, true, false);
  27
  28 //  setPreData(0x8156, 16);
  29   setPreData(0x6A81, 16);
  30
  31   addKey("Power", Power_Key, 0x12, 8);
  32   addKey("ATT", Unmapped_Key, 0x14, 8);
  33   addKey("Vol_Down", VolumeDown_Key, 0x19, 8);
  34   addKey("Mode", SoundMode_Key, 0x1A, 8);
  35   addKey("PRG", Program_Key, 0x1C, 8);
  36   addKey("Vol_Up", VolumeUp_Key, 0x1D, 8);
  37   addKey("Tune/Track_Down", ChannelDown_Key, 0x1E, 8);
  38   addKey("Tune/Track_Up", ChannelUp_Key, 0x1F, 8);
  39 }
  40
  41
  42 PanasonicSat1::PanasonicSat1(
  43   unsigned int index)
  44   : PIRKeysetMetaData(
  45       "Satellite Keyset 1",
  46       Panasonic_Make,
  47       index)
  48 {
  49 }
  50
  51
  52 void PanasonicSat1::populateProtocol(
  53   QObject *guiObject)
  54 {
  55   if (threadableProtocol)
  56   {
  57     // If the pointer is not null, the keyset must already be populated.
  58     return;
  59   }
  60
  61   threadableProtocol = new KaseikyoProtocol(guiObject, index);
  62
  63 //  setPreData(0x40040140, 32);
  64   setPreData(0x2002, 16);
  65
  66   addKaseikyoKey("PROG", Program_Key, 0x028, 0x8A);
  67   addKaseikyoKey("1", One_Key, 0x028, 0xA0);
  68   addKaseikyoKey("2", Two_Key, 0x028, 0xA1);
  69   addKaseikyoKey("3", Three_Key, 0x028, 0xA2);
  70   addKaseikyoKey("4", Four_Key, 0x028, 0xA3);
  71   addKaseikyoKey("5", Five_Key, 0x028, 0xA4);
  72   addKaseikyoKey("6", Six_Key, 0x028, 0xA5);
  73   addKaseikyoKey("7", Seven_Key, 0x028, 0xA6);
  74   addKaseikyoKey("8", Eight_Key, 0x028, 0xA7);
  75   addKaseikyoKey("9", Nine_Key, 0x028, 0xA8);
  76   addKaseikyoKey("0", Zero_Key, 0x028, 0xA9);
  77   addKaseikyoKey("CH-", ChannelDown_Key, 0x028, 0xB6);
  78   addKaseikyoKey("CH+", ChannelUp_Key, 0x028, 0xB7);
  79   addKaseikyoKey("ALT_AUD", Audio_Key, 0x028, 0xB8);
  80   addKaseikyoKey("INFO", Info_Key, 0x028, 0xB9);
  81   addKaseikyoKey("TV/DSS", Input_Key, 0x028, 0xBC);
  82   addKaseikyoKey("POWER", Power_Key, 0x028, 0xBD);
  83   addKaseikyoKey("REC", Record_Key, 0x028, 0xC2);
  84   addKaseikyoKey("ACTION", Select_Key, 0x028, 0xC3);
  85   addKaseikyoKey("MENU", Menu_Key, 0x028, 0xC4);
  86   addKaseikyoKey("GUIDE", Guide_Key, 0x028, 0xC5);
  87   addKaseikyoKey("EXIT", Exit_Key, 0x028, 0xC6);
  88   addKaseikyoKey("UP", Up_Key, 0x028, 0xCA);
  89   addKaseikyoKey("DOWN", Down_Key, 0x028, 0xCB);
  90   addKaseikyoKey("LEFT", Left_Key, 0x028, 0xCD);
  91   addKaseikyoKey("RIGHT", Right_Key, 0x028, 0xCE);
  92   addKaseikyoKey("FAV", Favorites_Key, 0x028, 0xD0);
  93   addKaseikyoKey("R_TUNE", PrevChannel_Key, 0x028, 0xD1);
  94   addKaseikyoKey("GUIDE", Guide_Key, 0x028, 0xD3);
  95   addKaseikyoKey("LOGO_TUNE", Unmapped_Key, 0x028, 0xD5);
  96   addKaseikyoKey("TXT", Teletext_Key, 0x028, 0xDE);
  97   addKaseikyoKey("STTL", Unmapped_Key, 0x028, 0xDF);
  98
  99   addKaseikyoKey("RED", Red_Key, 0x028, 0xEC);
 100   addKaseikyoKey("GREEN", Green_Key, 0x028, 0xED);
 101   addKaseikyoKey("BLUE", Blue_Key, 0x028, 0xEE);
 102   addKaseikyoKey("YELLOW", Yellow_Key, 0x028, 0xEF);
 103 }
 104
 105
 106 PanasonicSat1a::PanasonicSat1a(
 107   unsigned int index)
 108   : PanasonicSat1(index)
 109 {
 110   setKeysetName("Satellite Keyset 1a");
 111 }
 112
 113
 114 void PanasonicSat1a::populateProtocol(
 115   QObject *guiObject)
 116 {
 117   if (threadableProtocol)
 118   {
 119     // If the pointer is not null, the keyset must already be populated.
 120     return;
 121   }
 122
 123   PanasonicSat1::populateProtocol(guiObject);
 124
 125   addKaseikyoKey("EXIT", Exit_Key, 0x028, 0xCF);
 126   addKaseikyoKey("CH+", ChannelUp_Key, 0x028, 0xB2);
 127   addKaseikyoKey("CH-", ChannelDown_Key, 0x028, 0xB3);
 128 }
 129
 130
 131 PanasonicTV1::PanasonicTV1(
 132   unsigned int index)
 133   : PIRKeysetMetaData(
 134       "TV Keyset 1",
 135       Panasonic_Make,
 136       index)
 137 {
 138   addControlledDevice(Panasonic_Make, "TX-32PD50", TV_Device);
 139 }
 140
 141
 142 void PanasonicTV1::populateProtocol(
 143   QObject *guiObject)
 144 {
 145   if (threadableProtocol)
 146   {
 147     // If the pointer is not null, the keyset must already be populated.
 148     return;
 149   }
 150
 151   threadableProtocol = new KaseikyoProtocol(guiObject, index);
 152
 153 //  setPreData(0x400401, 24);
 154   setPreData(0x2002, 16);
 155
 156   addKaseikyoKey("TV/AV", Input_Key, 0x008, 0x05);
 157   addKaseikyoKey("PICTURE", PictureMode_Key, 0x008, 0x06);
 158   addKaseikyoKey("SOUND", SoundMode_Key, 0x008, 0x07);
 159   addKaseikyoKey("N", Unmapped_Key, 0x008, 0x0C);
 160   addKaseikyoKey("S", Unmapped_Key, 0x008, 0x0E);
 161   addKaseikyoKey("TIMER", Sleep_Key, 0x008, 0x0F); // "Sleep"
 162   addKaseikyoKey("1", One_Key, 0x008, 0x10);
 163   addKaseikyoKey("2", Two_Key, 0x008, 0x11);
 164   addKaseikyoKey("3", Three_Key, 0x008, 0x12);
 165   addKaseikyoKey("4", Four_Key, 0x008, 0x13);
 166   addKaseikyoKey("5", Five_Key, 0x008, 0x14);
 167   addKaseikyoKey("6", Six_Key, 0x008, 0x15);
 168   addKaseikyoKey("7", Seven_Key, 0x008, 0x16);
 169   addKaseikyoKey("8", Eight_Key, 0x008, 0x17);
 170   addKaseikyoKey("9", Nine_Key, 0x008, 0x18);
 171   addKaseikyoKey("0", Zero_Key, 0x008, 0x19);
 172   addKaseikyoKey("VOLUME_UP", VolumeUp_Key, 0x008, 0x20);
 173   addKaseikyoKey("VOLUME_DOWN", VolumeDown_Key, 0x008, 0x21);
 174   addKaseikyoKey("Bass Up", BassUp_Key, 0x008, 0x22);
 175   addKaseikyoKey("Bass Down", BassDown_Key, 0x008, 23);
 176   addKaseikyoKey("Treble Up", TrebleUp_Key, 0x008, 0x24);
 177   addKaseikyoKey("Treble Down", TrebleDown_Key, 0x008, 0x25);
 178   addKaseikyoKey("Balance Left", BalanceLeft_Key, 0x008, 0x26);
 179   addKaseikyoKey("Balance Right", BalanceRight_Key, 0x008, 0x27);
 180   addKaseikyoKey("SURROUND", Surround_Key, 0x008, 0x31);
 181   addKaseikyoKey("MUTE", Mute_Key, 0x008, 0x32);
 182   addKaseikyoKey("SAP", Audio_Key, 0x008, 0x33); // "Stereo/Mono/Bilingual"
 183   addKaseikyoKey("PROG_UP", ChannelUp_Key, 0x008, 0x34);
 184   addKaseikyoKey("PROG_DOWN", ChannelDown_Key, 0x008, 0x35);
 185   addKaseikyoKey("R-TUNE", Unmapped_Key, 0x008, 0x37);
 186   addKaseikyoKey("RECALL", PrevChannel_Key, 0x008, 0x39);
 187   addKaseikyoKey("C", Clear_Key, 0x008, 0x3A);
 188   addKaseikyoKey("-/--", DoubleDigit_Key, 0x008, 0x3B); // Also Dash_Key?
 189   addKaseikyoKey("POWER", Power_Key, 0x008, 0x3D);
 190   addKaseikyoKey("On", PowerOn_Key, 0x008, 0x3E);
 191   addKaseikyoKey("Off", PowerOff_Key, 0x008, 0x3F);
 192   addKaseikyoKey("Color Up", ColorUp_Key, 0x008, 0x40);
 193   addKaseikyoKey("Color Down", ColorDown_Key, 0x008, 0x41);
 194   addKaseikyoKey("Contrast Up", ContrastUp_Key, 0x008, 0x42);
 195   addKaseikyoKey("Contrast Down", ContrastDown_Key, 0x008, 0x43);
 196   addKaseikyoKey("Brightness Up", BrightnessUp_Key, 0x008, 0x44);
 197   addKaseikyoKey("Brightness Down", BrightnessDown_Key, 0x008, 0x45);
 198   addKaseikyoKey("select", Select_Key, 0x008, 0x49); // "OK"
 199   addKaseikyoKey("UP", Up_Key, 0x008, 0x4A);
 200   addKaseikyoKey("DOWN", Down_Key, 0x008, 0x4B);
 201   addKaseikyoKey("LEFT", Left_Key, 0x008, 0x4E);
 202   addKaseikyoKey("RIGHT", Right_Key, 0x008, 0x4F);
 203   addKaseikyoKey("P_MENU", Unmapped_Key, 0x008, 0x50);
 204   addKaseikyoKey("S_MENU", Unmapped_Key, 0x008, 0x51);
 205 //  addKaseikyoKey("ACTION", Enter_Key, 0x008, 0x52); // Might be wrong
 206   addKaseikyoKey("setup", Menu_Key, 0x008, 0x52); // "ACTION"
 207   addKaseikyoKey("pip swap", PIPSwap_Key, 0x008, 0x5E);
 208   addKaseikyoKey("pip move", PIPMove_Key, 0x008, 0x67);
 209   addKaseikyoKey("RED", Red_Key, 0x008, 0x70);
 210   addKaseikyoKey("GREEN", Green_Key, 0x008, 0x71);
 211   addKaseikyoKey("YELLOW", Yellow_Key, 0x008, 0x72);
 212   addKaseikyoKey("BLUE", Blue_Key, 0x008, 0x73);
 213   addKaseikyoKey("MOOD_LIGHT", Unmapped_Key, 0x008, 0xA1);
 214   addKaseikyoKey("HELP", Unmapped_Key, 0x008, 0xAC);
 215   addKaseikyoKey("GAME", Unmapped_Key, 0x008, 0xBB);
 216   addKaseikyoKey("Exit", Unmapped_Key, 0x008, 0xD3);
 217   addKaseikyoKey("Return", Unmapped_Key, 0x008, 0xD4); // "R"
 218   addKaseikyoKey("STR", Unmapped_Key, 0x008,0xD5);
 219   addKaseikyoKey("MULTIWINDOW", Unmapped_Key, 0x008, 0xE6); // "multi pip"
 220   addKaseikyoKey("FM/TV", Unmapped_Key, 0x008, 0xEE);
 221   addKaseikyoKey("System reset", Unmapped_Key, 0x008, 0xFF);
 222
 223   addKaseikyoKey("Mix", TeletextAndTV_Key, 0x018, 0x01);
 224   addKaseikyoKey("TV/TEXT", Teletext_Key, 0x018, 0x03);
 225   addKaseikyoKey("Display_Cancel", Unmapped_Key, 0x018, 0x04);
 226   addKaseikyoKey("FP (Favorite Page)", Unmapped_Key, 0x018, 0x05);
 227   addKaseikyoKey("INDEX", TeletextIndex_Key, 0x018, 0x08);
 228   addKaseikyoKey("HOLD", TeletextHold_Key, 0x018, 0x09);
 229   addKaseikyoKey("List Store", TeletextStore_Key, 0x018, 0x0A);
 230   addKaseikyoKey("TIMETEXT", TeletextTime_Key, 0x018, 0x0B);
 231   addKaseikyoKey("FTB (Full/Top/Bottom)", TeletextSize_Key, 0x018, 0x0C);
 232   addKaseikyoKey("REVEAL", TeletextReveal_Key, 0x018, 0x1C);
 233   addKaseikyoKey("List/F.Text", Unmapped_Key, 0x018, 0x1D);
 234   addKaseikyoKey("Text Reset", Unmapped_Key, 0x018, 0x1E);
 235
 236   addKaseikyoKey("TV", Unmapped_Key, 0x028, 0x30);
 237   addKaseikyoKey("PROG", Program_Key, 0x028, 0x8A);
 238   addKaseikyoKey("MENU", Menu_Key, 0x028, 0xC4);
 239   addKaseikyoKey("GUIDE", Guide_Key, 0x028, 0xC5);
 240   addKaseikyoKey("EXIT", Exit_Key, 0x028, 0xC6);
 241
 242   addKaseikyoKey("ASPECT", AspectRatio_Key, 0x048, 0xDE);
 243   addKaseikyoKey("picture position/size", PIPSize_Key, 0x048, 0xE5);
 244
 245   addKaseikyoKey("Guide", Unmapped_Key, 0x098, 0x87);
 246   addKaseikyoKey("DIRECTREC", Record_Key, 0x098, 0x89);
 247   addKaseikyoKey("Exit", Unmapped_Key, 0x098, 0x9A);
 248   addKaseikyoKey("Option", Unmapped_Key, 0x098, 0xA7);
 249   addKaseikyoKey("SDCard", Unmapped_Key, 0x098, 0xAB);
 250   addKaseikyoKey("Favorite", Unmapped_Key, 0x098, 0xAE);
 251   addKaseikyoKey("Link", Unmapped_Key, 0x098, 0xB1);
 252   addKaseikyoKey("prog-", Unmapped_Key, 0x098, 0xD0);
 253
 254   // Some media keys, possibly a combo DVD-TV?
 255 //  addKaseikyoKey("STOP", Stop_Key, 0x00B, 0x00);
 256 //  addKaseikyoKey("PLAY", Play_Key, 0x00B, 0x0A);
 257 //  addKaseikyoKey("FORWARD", FastForward_Key, 0x00B, 0x4A);
 258 //  addKaseikyoKey("REWIND", Rewind_Key, 0x00B, 0x49);
 259 }
 260
 261
 262 PanasonicTV1a::PanasonicTV1a(
 263   unsigned int index)
 264   : PanasonicTV1(index)
 265 {
 266   setKeysetName("TV Keyset 1a");
 267 }
 268
 269
 270 void PanasonicTV1a::populateProtocol(
 271   QObject *guiObject)
 272 {
 273   if (threadableProtocol)
 274   {
 275     // If the pointer is not null, the keyset must already be populated.
 276     return;
 277   }
 278
 279   PanasonicTV1::populateProtocol(guiObject);
 280
 281   // Overwrite some of the keys:
 282   addKaseikyoKey("OK", Select_Key, 0x008, 0x49);
 283   addKaseikyoKey("MENU", Menu_Key, 0x008, 0x06);
 284 }
 285
 286
 287 PanasonicTV1b::PanasonicTV1b(
 288   unsigned int index)
 289   : PanasonicTV1(index)
 290 {
 291   setKeysetName("TV Keyset 1b");
 292
 293   addControlledDevice(Panasonic_Make, "Viera TX-32LZD80", TV_Device);
 294   addControlledDevice(Panasonic_Make, "Viera 42PZ700U", TV_Device);
 295   addControlledDevice(Panasonic_Make, "Viera 42PZ8ES", TV_Device);
 296   addControlledDevice(Panasonic_Make, "Quintrix TX-25MK1C", TV_Device);
 297 }
 298
 299
 300 void PanasonicTV1b::populateProtocol(
 301   QObject *guiObject)
 302 {
 303   if (threadableProtocol)
 304   {
 305     // If the pointer is not null, the keyset must already be populated.
 306     return;
 307   }
 308
 309   PanasonicTV1::populateProtocol(guiObject);
 310
 311   addKaseikyoKey("Info", Info_Key, 0x008, 0x39); // "OSD"
 312   addKaseikyoKey("OK", Select_Key, 0x008, 0x49);
 313   addKaseikyoKey("Menu", Menu_Key, 0x008, 0x52);
 314 //  addKaseikyoKey("Exit", Exit_Key, 0x008, 0xD3);
 315
 316   addKaseikyoKey("Guide", Guide_Key, 0x098, 0x87);
 317   addKaseikyoKey("Exit", Exit_Key, 0x098, 0x9A);
 318 }
 319
 320
 321 PanasonicTV2::PanasonicTV2(
 322   unsigned int index)
 323   : PIRKeysetMetaData(
 324       "TV Keyset 2",
 325       Panasonic_Make,
 326       index)
 327 {
 328 }
 329
 330
 331 void PanasonicTV2::populateProtocol(
 332   QObject *guiObject)
 333 {
 334   if (threadableProtocol)
 335   {
 336     // Keyset already populated.
 337     return;
 338   }
 339
 340   threadableProtocol = new PanasonicOldProtocol(guiObject, index);
 341
 342   addPanOldKey("Mute", Mute_Key, 0x00, 0x00);
 343   addPanOldKey("R-Tune", Unmapped_Key, 0x00, 0x0A);
 344   addPanOldKey("Sleep", Sleep_Key, 0x00, 0x0B);
 345   addPanOldKey("TV/Video", Input_Key, 0x00, 0x0D);
 346   addPanOldKey("Recall", PrevChannel_Key, 0x00, 0x0F);
 347
 348   addPanOldKey("ONE", One_Key, 0x00, 0x10);
 349   addPanOldKey("TWO", Two_Key, 0x00, 0x11);
 350   addPanOldKey("THREE", Three_Key, 0x00, 0x12);
 351   addPanOldKey("FOUR", Four_Key, 0x00, 0x13);
 352   addPanOldKey("FIVE", Five_Key, 0x00, 0x14);
 353   addPanOldKey("SIX", Six_Key, 0x00, 0x15);
 354   addPanOldKey("SEVEN", Seven_Key, 0x00, 0x16);
 355   addPanOldKey("EIGHT", Eight_Key, 0x00, 0x17);
 356   addPanOldKey("NINE", Nine_Key, 0x00, 0x18);
 357   addPanOldKey("ZERO", Zero_Key, 0x00, 0x19);
 358
 359   addPanOldKey("POWER", Power_Key, 0x00, 0x20);
 360   addPanOldKey("CHANNEL_UP", ChannelUp_Key, 0x00, 0x22); // "NEXT"
 361   addPanOldKey("CHANNEL_DOWN", ChannelDown_Key, 0x00, 0x23); // "PREV"
 362   addPanOldKey("VOLUME_UP", VolumeUp_Key, 0x00, 0x24);
 363   addPanOldKey("VOLUME_DOWN", VolumeDown_Key, 0x00, 0x25);
 364 }
 365
 366
 367 PanasonicTV2a::PanasonicTV2a(
 368   unsigned int index)
 369   : PanasonicTV2(index)
 370 {
 371   setKeysetName("TV Keyset 2a");
 372 }
 373
 374
 375 void PanasonicTV2a::populateProtocol(
 376   QObject *guiObject)
 377 {
 378   if (threadableProtocol)
 379   {
 380     // Keyset already populated.
 381     return;
 382   }
 383
 384   PanasonicTV2::populateProtocol(guiObject);
 385
 386   addPanOldKey("BAL_LEFT", BalanceLeft_Key, 0x00, 0x24);
 387   addPanOldKey("BAL_RIGHT", BalanceRight_Key, 0x00, 0x25);
 388   addPanOldKey("VOL_UP", VolumeUp_Key, 0x00, 0x01);
 389   addPanOldKey("VOL_DOWN", VolumeDown_Key, 0x00, 0x0D);
 390   addPanOldKey("BWD", Rewind_Key, 0x00, 0x3B);
 391   addPanOldKey("FWD", FastForward_Key, 0x00, 0x3C);
 392   addPanOldKey("STOP", Stop_Key, 0x00, 0x1B);
 393   addPanOldKey("PAUSE", Pause_Key, 0x00, 0x2A);
 394   addPanOldKey("PLAYLIST_CLEAR", Unmapped_Key, 0x00, 0x1A);
 395   addPanOldKey("PLAYLIST_ADD", Unmapped_Key, 0x00, 0x36);
 396   addPanOldKey("PLAY", Play_Key, 0x00, 0x3A);
 397   addPanOldKey("MUTE", Mute_Key, 0x00, 0x0B);
 398   addPanOldKey("QUIT", Unmapped_Key, 0x00, 0x20);
 399 }
 400
 401
 402 PanasonicVCR1::PanasonicVCR1(
 403   unsigned int index)
 404   : PIRKeysetMetaData(
 405       "VCR Keyset 1",
 406       Panasonic_Make,
 407       index)
 408 {
 409 }
 410
 411
 412 void PanasonicVCR1::populateProtocol(
 413   QObject *guiObject)
 414 {
 415   if (threadableProtocol)
 416   {
 417     // If the pointer is not null, the keyset must already be populated.
 418     return;
 419   }
 420
 421   threadableProtocol = new KaseikyoProtocol(guiObject, index);
 422
 423 //  setPreData(0x400409, 24);
 424   setPreData(0x2002, 16);
 425
 426   addKaseikyoKey("STOP", Stop_Key, 0x009, 0x00);
 427   addKaseikyoKey("REWIND", Rewind_Key, 0x009, 0x02);
 428   addKaseikyoKey("FORWARD", FastForward_Key, 0x009, 0x03);
 429   addKaseikyoKey("PAUSE", Pause_Key, 0x009, 0x06);
 430   addKaseikyoKey("REC", Record_Key, 0x009, 0x08);
 431   addKaseikyoKey("PLAY", Play_Key, 0x009, 0x0A);
 432   addKaseikyoKey("STILL", StepForward_Key, 0x009, 0x0C);  // also "ADV"
 433   addKaseikyoKey("SLOW", Slow_Key, 0x009, 0x0F);
 434   addKaseikyoKey("1", One_Key, 0x009, 0x10);
 435   addKaseikyoKey("2", Two_Key, 0x009, 0x11);
 436   addKaseikyoKey("3", Three_Key, 0x009, 0x12);
 437   addKaseikyoKey("4", Four_Key, 0x009, 0x13);
 438   addKaseikyoKey("5", Five_Key, 0x009, 0x14);
 439   addKaseikyoKey("6", Six_Key, 0x009, 0x15);
 440   addKaseikyoKey("7", Seven_Key, 0x009, 0x16);
 441   addKaseikyoKey("8", Eight_Key, 0x009, 0x17);
 442   addKaseikyoKey("9", Nine_Key, 0x009, 0x18);
 443   addKaseikyoKey("0", Zero_Key, 0x009, 0x19);
 444   addKaseikyoKey("AUDIO", Audio_Key, 0x009, 0x33);
 445   addKaseikyoKey("PROGRAMME^", ChannelUp_Key, 0x009, 0x34);
 446   addKaseikyoKey("PROGRAMMEv", ChannelDown_Key, 0x009, 0x35);
 447   addKaseikyoKey("TV-SAT", Input_Key, 0x009, 0x36);
 448   addKaseikyoKey("INFO", Info_Key, 0x009, 0x39);
 449   addKaseikyoKey("-/--", DoubleDigit_Key, 0x009, 0x3B);
 450   addKaseikyoKey("POWER", Power_Key, 0x009, 0x3D);
 451   addKaseikyoKey("INDEX", IndexSearch_Key, 0x009, 0x40);
 452   addKaseikyoKey("time_search", Unmapped_Key, 0x009, 0x44);
 453   addKaseikyoKey("INDEXL", Previous_Key, 0x009, 0x49);
 454   addKaseikyoKey("INDEXR", Next_Key, 0x009, 0x4A);
 455   addKaseikyoKey("mem_rep", Unmapped_Key, 0x009, 0x53);
 456   addKaseikyoKey("COUNTER_RESET", Unmapped_Key, 0x009, 0x54);
 457   addKaseikyoKey("TAPE_REMAIN", Unmapped_Key, 0x009, 0x55);
 458   addKaseikyoKey("CLOCK/COUNTER", Clock_Key, 0x009, 0x56);
 459   addKaseikyoKey("+", Unmapped_Key, 0x009, 0x8E);
 460   addKaseikyoKey("-", Unmapped_Key, 0x009, 0x8F);
 461   addKaseikyoKey("monitor", Unmapped_Key, 0x009, 0x91);
 462   addKaseikyoKey("TRACKING_AUTO", AutoTracking_Key, 0x009, 0xB0);
 463   addKaseikyoKey("TRACKING_PLUS", TrackingPlus_Key, 0x009, 0xB1);
 464   addKaseikyoKey("TRACKING_MINUS", TrackingMinus_Key, 0x009, 0xB2);
 465   addKaseikyoKey("TIMERREC", RecordTimed_Key, 0x009, 0xB4);
 466   addKaseikyoKey("AV", Unmapped_Key, 0x009, 0xC0);
 467   addKaseikyoKey("DIRECT_TV_REC", Unmapped_Key, 0x009, 0xC2);
 468   addKaseikyoKey("mesecam", Unmapped_Key, 0x009, 0xC9);
 469   addKaseikyoKey("100", PlusOneHundred_Key, 0x009, 0xE5);
 470   addKaseikyoKey("sap/hi-fi", Unmapped_Key, 0x009, 0xE6);
 471   addKaseikyoKey("repeat", Repeat_Key, 0x009, 0xF0);
 472   addKaseikyoKey("memory", Program_Key, 0x009, 0xF1);
 473   addKaseikyoKey("sleep", Sleep_Key, 0x009, 0xF2);
 474   addKaseikyoKey("rew2", Unmapped_Key, 0x009, 0xF3);
 475   addKaseikyoKey("zerostop", Unmapped_Key, 0x009, 0xF5);
 476   addKaseikyoKey("REPLAY", Replay_Key, 0x009, 0xF7);
 477   addKaseikyoKey("cm-zero", Unmapped_Key, 0x009, 0xF8);
 478
 479   addKaseikyoKey("PROG/CHECK", Program_Key, 0x019, 0x01);
 480   addKaseikyoKey("rotate", Unmapped_Key, 0x019, 0x02);
 481   addKaseikyoKey("rotatedown", Unmapped_Key, 0x019, 0x03);
 482   addKaseikyoKey("set", Unmapped_Key, 0x019, 0x04);
 483   addKaseikyoKey("clear", Unmapped_Key, 0x019, 0x05);
 484   addKaseikyoKey("VPS/PDC", RecordPDC_Key, 0x019, 0x06);
 485   addKaseikyoKey("OffTimer", Sleep_Key, 0x019, 0x08);
 486   addKaseikyoKey("CANCEL", Clear_Key, 0x019, 0x09);
 487   addKaseikyoKey("SPEED", VHSSpeed_Key, 0x019, 0x0A);
 488   addKaseikyoKey("ADD/DELETE", Unmapped_Key, 0x019, 0x31);
 489   addKaseikyoKey("RADIO_TUNE", Unmapped_Key, 0x019, 0x38);
 490   addKaseikyoKey("MENU", Menu_Key, 0x019, 0x56);
 491   addKaseikyoKey("OK", Select_Key, 0x019, 0x58);
 492   addKaseikyoKey("SHOWVIEW", Unmapped_Key, 0x019, 0x5D); // vhsplus+, etc.
 493   addKaseikyoKey("DISPLAY", Unmapped_Key, 0x019, 0x5F);
 494   addKaseikyoKey("EXIT", Exit_Key, 0x019, 0x66);
 495   addKaseikyoKey("CHECK+", Unmapped_Key, 0x019, 0x90);
 496   addKaseikyoKey("CHECK-", Unmapped_Key, 0x019, 0x91);
 497   addKaseikyoKey("DATE+", Unmapped_Key, 0x019, 0x92);
 498   addKaseikyoKey("DATE-", Unmapped_Key, 0x019, 0x93);
 499   addKaseikyoKey("ON+", Unmapped_Key, 0x019, 0x94);
 500   addKaseikyoKey("ON-", Unmapped_Key, 0x019, 0x95);
 501   addKaseikyoKey("OFF+", Unmapped_Key, 0x019, 0x96);
 502   addKaseikyoKey("OFF-", Unmapped_Key, 0x019, 0x97);
 503   addKaseikyoKey("SEARCH", Unmapped_Key, 0x019, 0x9D);
 504   addKaseikyoKey("TAPE", Unmapped_Key, 0x019, 0xE0);
 505
 506   addKaseikyoKey("STILL_ALBUM", Unmapped_Key, 0x059, 0x23);
 507   addKaseikyoKey("PROG_PLAY", Unmapped_Key, 0x059, 0x3A);
 508   addKaseikyoKey("I-Timer", Unmapped_Key, 0x059, 0x3F);
 509   addKaseikyoKey("TV/TEXT", Unmapped_Key, 0x059, 0x57);
 510   addKaseikyoKey("ExtLink", Unmapped_Key, 0x059, 0x5B);
 511
 512 // These are fishy:
 513 //  addKaseikyoKey("RESET_STORE", Unmapped_Key, 0x019, 0x58);
 514 }
 515
 516
 517 PanasonicVCR1a::PanasonicVCR1a(
 518   unsigned int index)
 519   : PanasonicVCR1(index)
 520 {
 521   setKeysetName("VCR Keyset 1a");
 522 }
 523
 524
 525 void PanasonicVCR1a::populateProtocol(
 526   QObject *guiObject)
 527 {
 528   if (threadableProtocol)
 529   {
 530     // If the pointer is not null, the keyset must already be populated.
 531     return;
 532   }
 533
 534   PanasonicVCR1::populateProtocol(guiObject);
 535
 536   addKaseikyoKey("OSD", Info_Key, 0x009, 0x57);
 537   addKaseikyoKey("AV", Input_Key, 0x009, 0xC0);
 538   addKaseikyoKey("DISPLAY", Unmapped_Key, 0x019, 0x5F);
 539 }
 540
 541
 542 PanasonicVCR1b::PanasonicVCR1b(
 543   unsigned int index)
 544   : PanasonicVCR1(index)
 545 {
 546   setKeysetName("VCR Keyset 1b");
 547 }
 548
 549
 550 void PanasonicVCR1b::populateProtocol(
 551   QObject *guiObject)
 552 {
 553   if (threadableProtocol)
 554   {
 555     // If the pointer is not null, the keyset must already be populated.
 556     return;
 557   }
 558
 559   PanasonicVCR1::populateProtocol(guiObject);
 560
 561   addKaseikyoKey("repeat", Repeat_Key, 0x009, 0xF9);
 562   addKaseikyoKey("prog", Program_Key, 0x009, 0xFF);
 563   addKaseikyoKey("clear", Clear_Key, 0x019, 0x0A);
 564 }
 565
 566
 567 PanasonicVCR1c::PanasonicVCR1c(
 568   unsigned int index)
 569   : PanasonicVCR1(index)
 570 {
 571   setKeysetName("VCR Keyset 1c");
 572 }
 573
 574
 575 void PanasonicVCR1c::populateProtocol(
 576   QObject *guiObject)
 577 {
 578   if (threadableProtocol)
 579   {
 580     // If the pointer is not null, the keyset must already be populated.
 581     return;
 582   }
 583
 584   PanasonicVCR1::populateProtocol(guiObject);
 585
 586   addKaseikyoKey("rotate", Up_Key, 0x019, 0x02);
 587   addKaseikyoKey("rotatedown", Down_Key, 0x019, 0x03);
 588   addKaseikyoKey("set", Select_Key, 0x019, 0x04);
 589   addKaseikyoKey("clear", Exit_Key, 0x019, 0x05);
 590 }
 591
 592
 593 PanasonicVCR2::PanasonicVCR2(
 594   unsigned int index)
 595   : PIRKeysetMetaData(
 596       "VCR Keyset 2",
 597       Panasonic_Make,
 598       index)
 599 {
 600 }
 601
 602
 603 void PanasonicVCR2::populateProtocol(
 604   QObject *guiObject)
 605 {
 606   if (threadableProtocol)
 607   {
 608     // Keyset already populated.
 609     return;
 610   }
 611
 612   threadableProtocol = new PanasonicOldProtocol(guiObject, index);
 613
 614   addPanOldKey("STOP", Stop_Key, 0x02, 0x00);
 615   addPanOldKey("REW", Rewind_Key, 0x02, 0x02);
 616   addPanOldKey("FF", FastForward_Key, 0x02, 0x03);
 617   addPanOldKey("PAUSE", Pause_Key, 0x02, 0x06);
 618   addPanOldKey("REC", Record_Key, 0x02, 0x08);
 619   addPanOldKey("PLAY", Play_Key, 0x02, 0x0A);
 620   addPanOldKey("REV_PLAY", Unmapped_Key, 0x02, 0x0B);
 621   addPanOldKey("F.ADV", StepForward_Key, 0x02, 0x0C);
 622   addPanOldKey("x2", PlayX2_Key, 0x02, 0x0E);
 623   addPanOldKey("SLOW", Slow_Key, 0x02, 0x0F);
 624   addPanOldKey("1", One_Key, 0x02, 0x10);
 625   addPanOldKey("2", Two_Key, 0x02, 0x11);
 626   addPanOldKey("3", Three_Key, 0x02, 0x12);
 627   addPanOldKey("4", Four_Key, 0x02, 0x13);
 628   addPanOldKey("5", Five_Key, 0x02, 0x14);
 629   addPanOldKey("6", Six_Key, 0x02, 0x15);
 630   addPanOldKey("7", Seven_Key, 0x02, 0x16);
 631   addPanOldKey("8", Eight_Key, 0x02, 0x17);
 632   addPanOldKey("9", Nine_Key, 0x02, 0x18);
 633   addPanOldKey("0", Zero_Key, 0x02, 0x19);
 634   addPanOldKey("POWER", Power_Key, 0x02, 0x20); // "vtr"
 635   addPanOldKey("VOL+", VolumeUp_Key, 0x02, 0x22);
 636   addPanOldKey("VOL-", VolumeDown_Key, 0x02, 0x23);
 637   addPanOldKey("-/--", DoubleDigit_Key, 0x02, 0x24);
 638   addPanOldKey("VTR/TV", Input_Key, 0x02, 0x2A);
 639   addPanOldKey("slow+", SlowPlus_Key, 0x02, 0x2E);
 640   addPanOldKey("slow-", SlowMinus_Key, 0x02, 0x2F);
 641   addPanOldKey("MEMORY_SEARCH", Memory_Key, 0x02, 0x32);
 642   addPanOldKey("RESET_INDEX", Reset_Key, 0x02, 0x33);
 643   addPanOldKey("INTRO_SCAN", Unmapped_Key, 0x02, 0x34);
 644   addPanOldKey("timer_rec", RecordTimed_Key, 0x02, 0x36);
 645   addPanOldKey("AUDIO-SELECT", Audio_Key, 0x02, 0x3D);
 646
 647   addPanOldKey("VPS", RecordPDC_Key, 0x03, 0x06);
 648   addPanOldKey("prog", Program_Key, 0x03, 0x2C);
 649   addPanOldKey("next", Next_Key, 0x03, 0x3A);
 650
 651   addPanOldKey("FSTORE", Unmapped_Key, 0x19, 0x10);
 652   addPanOldKey("STROBE", Unmapped_Key, 0x19, 0x11);
 653   addPanOldKey("CLEAR", Unmapped_Key, 0x19, 0x12);
 654   addPanOldKey("GEFFECT", Unmapped_Key, 0x19, 0x17);
 655   addPanOldKey("MINUS", ChannelDown_Key, 0x19, 0x19); //?
 656   addPanOldKey("PLUS", ChannelUp_Key, 0x19, 0x24); //?
 657 }
 658
 659
 660 PanasonicDVD1::PanasonicDVD1(
 661   unsigned int index)
 662   : PIRKeysetMetaData(
 663       "DVD Keyset 1",
 664       Panasonic_Make,
 665       index)
 666 {
 667 }
 668
 669
 670 void PanasonicDVD1::populateProtocol(
 671   QObject *guiObject)
 672 {
 673   if (threadableProtocol)
 674   {
 675     // If the pointer is not null, the keyset must already be populated.
 676     return;
 677   }
 678
 679   threadableProtocol = new KaseikyoProtocol(guiObject, index);
 680
 681 //  setPreData(0x40040D00, 32);
 682   setPreData(0x2002, 16);
 683
 684   addKaseikyoKey("STOP", Stop_Key, 0x00B, 0x00);
 685   addKaseikyoKey("OPEN/CLOSE", Eject_Key, 0x00B, 0x01);
 686 //  addKaseikyoKey("TV-SAT", Input_Key, 0x00B, 0x01);
 687   addKaseikyoKey("REW", Rewind_Key, 0x00B, 0x04);
 688   addKaseikyoKey("FF", FastForward_Key, 0x00B, 0x05);
 689   addKaseikyoKey("PAUSE", Pause_Key, 0x00B, 0x06);
 690   addKaseikyoKey("CH_DOWN", ChannelDown_Key, 0x00B, 0x07);
 691   addKaseikyoKey("rec", Record_Key, 0x00B, 0x08);
 692   addKaseikyoKey("PLAY", Play_Key, 0x00B, 0x0A);
 693   addKaseikyoKey("CH_UP", ChannelUp_Key, 0x00B, 0x0F);
 694   addKaseikyoKey("1", One_Key, 0x00B, 0x10);
 695   addKaseikyoKey("2", Two_Key, 0x00B, 0x11);
 696   addKaseikyoKey("3", Three_Key, 0x00B, 0x12);
 697   addKaseikyoKey("4", Four_Key, 0x00B, 0x13);
 698   addKaseikyoKey("5", Five_Key, 0x00B, 0x14);
 699   addKaseikyoKey("6", Six_Key, 0x00B, 0x15);
 700   addKaseikyoKey("7", Seven_Key, 0x00B, 0x16);
 701   addKaseikyoKey("8", Eight_Key, 0x00B, 0x17);
 702   addKaseikyoKey("9", Nine_Key, 0x00B, 0x18);
 703   addKaseikyoKey("0", Zero_Key, 0x00B, 0x19);
 704   addKaseikyoKey("extlink", Unmapped_Key, 0x00B, 0x23);
 705   addKaseikyoKey("AUDIO", Audio_Key, 0x00B, 0x33);
 706   addKaseikyoKey("POWER", Power_Key, 0x00B, 0x3D);
 707   addKaseikyoKey("erase", Unmapped_Key, 0x00B, 0x44); // "DELETE"
 708   addKaseikyoKey("POSITION_MEMORY", Unmapped_Key, 0x00B, 0x46);
 709   addKaseikyoKey("A-B_REPEAT", RepeatAB_Key, 0x00B, 0x48);
 710   addKaseikyoKey("PREV", Previous_Key, 0x00B, 0x49);
 711   addKaseikyoKey("NEXT", Next_Key, 0x00B, 0x04A);
 712   addKaseikyoKey("timeslip", Unmapped_Key, 0x00B, 0x4B);
 713   addKaseikyoKey("manualskip", Unmapped_Key, 0x00B, 0x4C);
 714   addKaseikyoKey("RANDOM", Random_Key, 0x00B, 0x4D);
 715   addKaseikyoKey("recmode", Unmapped_Key, 0x00B, 0x51);
 716   addKaseikyoKey("functions", Unmapped_Key, 0x00B, 0x57);
 717   addKaseikyoKey("createchapter", Unmapped_Key, 0x00B, 0x58);
 718   addKaseikyoKey("status", Unmapped_Key, 0x00B, 0x5F);
 719   addKaseikyoKey("VOLUMEDOWN", VolumeDown_Key, 0x00B, 0x62);
 720   addKaseikyoKey("VOLUMEUP", VolumeUp_Key, 0x00B, 0x63);
 721   addKaseikyoKey("i", Unmapped_Key, 0x00B, 0x66);
 722   addKaseikyoKey("timer", Timer_Key, 0x00B, 0x78);
 723   addKaseikyoKey("progcheck", Unmapped_Key, 0x00B, 0x7C);
 724   addKaseikyoKey("showview", Unmapped_Key, 0x00B, 0x7F);
 725   addKaseikyoKey("MENU", Menu_Key, 0x00B, 0x80);
 726   addKaseikyoKey("RETURN", Exit_Key, 0x00B, 0x81);
 727   addKaseikyoKey("ACTION", Select_Key, 0x00B, 0x82);
 728   addKaseikyoKey("CANCEL", Clear_Key, 0x00B, 0x83);
 729   addKaseikyoKey("UP", Up_Key, 0x00B, 0x85);
 730   addKaseikyoKey("DOWN", Down_Key, 0x00B, 0x86);
 731   addKaseikyoKey("LEFT", Left_Key, 0x00B, 0x87);
 732   addKaseikyoKey("RIGHT", Right_Key, 0x00B, 0x88);
 733   addKaseikyoKey("+10", DoubleDigit_Key, 0x00B, 0x89);
 734 //  addKaseikyoKey("inputselect", Input_Key, 0x00B, 0x89); // odd!
 735   addKaseikyoKey("PROGRAM", Program_Key, 0x00B, 0x8A);
 736   addKaseikyoKey("QUICK_REPLAY", Replay_Key, 0x00B, 0x8B);
 737   addKaseikyoKey("REPEAT", Repeat_Key, 0x00B, 0x8C);
 738   addKaseikyoKey("PLAY_MODE", Unmapped_Key, 0x00B, 0x8D);
 739   addKaseikyoKey("ANGLE", Angle_Key, 0x00B, 0x90);
 740   addKaseikyoKey("SUBTITLE", Captions_Key, 0x00B, 0x91);
 741   addKaseikyoKey("INFO", Info_Key, 0x00B, 0x92);
 742   addKaseikyoKey("SETUP", Unmapped_Key, 0x00B, 0x94);
 743 //  addKaseikyoKey("R-TUNE", PrevChannel_Key, 0x00B, 0x9B);
 744   addKaseikyoKey("TOP_MENU", DiscTitle_Key, 0x00B, 0x9B);
 745   addKaseikyoKey("A.SRD", Unmapped_Key, 0x00B, 0x9E);
 746   addKaseikyoKey("FL_SELECT", Unmapped_Key, 0x00B, 0xB6);
 747   addKaseikyoKey("DISC", Unmapped_Key, 0x00B, 0xB7);
 748   addKaseikyoKey("SEQUENTIAL", Unmapped_Key, 0x00B, 0xBF);
 749   addKaseikyoKey("CINEMA", Unmapped_Key, 0x00B, 0xC0);
 750   addKaseikyoKey("ZOOM", Zoom_Key, 0x00B, 0xC1);
 751   addKaseikyoKey("frec", Unmapped_Key, 0x00B, 0xC7);
 752   addKaseikyoKey("BASS", EnhancedBass_Key, 0x00B, 0xD4);
 753   addKaseikyoKey("D.ENH", Unmapped_Key, 0x00B, 0xD5);
 754   addKaseikyoKey("ONETOUCH_MEMORY", Unmapped_Key, 0x00B, 0xD6);
 755   addKaseikyoKey("GROUP", Unmapped_Key, 0x00B, 0xE0);
 756   addKaseikyoKey("SLEEP", Sleep_Key, 0x00B, 0xEB);
 757 }
 758
 759
 760 PanasonicDVD1a::PanasonicDVD1a(
 761   unsigned int index)
 762   : PanasonicDVD1(index)
 763 {
 764   setKeysetName("DVD Keyset 1a");
 765 }
 766
 767
 768 void PanasonicDVD1a::populateProtocol(
 769   QObject *guiObject)
 770 {
 771   if (threadableProtocol)
 772   {
 773     // If the pointer is not null, the keyset must already be populated.
 774     return;
 775   }
 776
 777   PanasonicDVD1::populateProtocol(guiObject);
 778
 779   addKaseikyoKey("channel2up", ChannelUp_Key, 0x00B, 0x34);
 780   addKaseikyoKey("channel2down", ChannelDown_Key, 0x00B, 0x35);
 781   addKaseikyoKey("INPUT_SELECT", Input_Key, 0x00B, 0x50);
 782 }
 783
 784
 785 PanasonicAudio1::PanasonicAudio1(
 786   unsigned int index)
 787   : PIRKeysetMetaData(
 788       "Audio Keyset 1",
 789       Panasonic_Make,
 790       index)
 791 {
 792   addControlledDevice(Panasonic_Make, "RX-DS25", Audio_Device);
 793   addControlledDevice(Panasonic_Make, "RX-e300", Audio_Device);
 794 }
 795
 796
 797 void PanasonicAudio1::populateProtocol(
 798   QObject *guiObject)
 799 {
 800   if (threadableProtocol)
 801   {
 802     // If the pointer is not null, the keyset must already be populated.
 803     return;
 804   }
 805
 806   threadableProtocol = new KaseikyoProtocol(guiObject, index);
 807
 808 //  setPreData(0x40040543, 32);
 809   setPreData(0x2002, 16);
 810
 811   addKaseikyoKey("INTRO", Unmapped_Key, 0xC2A, 0x46); // odd
 812
 813   addKaseikyoKey("stop-clear", Stop_Key, 0xC2A, 0x80);
 814   addKaseikyoKey("repeat", Repeat_Key, 0xC2A, 0x81);
 815   addKaseikyoKey("random", Random_Key, 0xC2A, 0x82);
 816   addKaseikyoKey("eject", Eject_Key, 0xC2A, 0x8E);
 817   addKaseikyoKey("prev", Rewind_Key, 0xC2A, 0x84); // "CD_<<"
 818   addKaseikyoKey("next", FastForward_Key, 0xC2A, 0x85); // "CD_>>"
 819   addKaseikyoKey("CD_PAUSE", Pause_Key, 0xC2A, 0x86);
 820   addKaseikyoKey("play-pause", Play_Key, 0xC2A, 0x87);
 821   addKaseikyoKey("program", Program_Key, 0xC2A, 0x8B); // "MEMORY"
 822   addKaseikyoKey("cancel", Clear_Key, 0xC2A, 0x8D);
 823   addKaseikyoKey("display", Info_Key, 0xC2A, 0x8F);
 824
 825   addKaseikyoKey("1", One_Key, 0xC2A, 0x90);
 826   addKaseikyoKey("2", Two_Key, 0xC2A, 0x91);
 827   addKaseikyoKey("3", Three_Key, 0xC2A, 0x92);
 828   addKaseikyoKey("4", Four_Key, 0xC2A, 0x93);
 829   addKaseikyoKey("5", Five_Key, 0xC2A, 0x94);
 830   addKaseikyoKey("6", Six_Key, 0xC2A, 0x95);
 831   addKaseikyoKey("7", Seven_Key, 0xC2A, 0x96);
 832   addKaseikyoKey("8", Eight_Key, 0xC2A, 0x97);
 833   addKaseikyoKey("9", Nine_Key, 0xC2A, 0x98);
 834   addKaseikyoKey("10/0", Zero_Key, 0xC2A, 0x99);
 835   addKaseikyoKey("+10", DoubleDigit_Key, 0xC2A, 0x9F);
 836
 837   addKaseikyoKey("tape_stop", Unmapped_Key, 0xC2A, 0xA0);
 838   addKaseikyoKey("rew", Unmapped_Key, 0xC2A, 0xA2); // "TAPE_<<"
 839   addKaseikyoKey("ff", Unmapped_Key, 0xC2A, 0xA3); // "TAPE_>>"
 840   addKaseikyoKey("tape_record", Record_Key, 0xC2A, 0xA4);
 841   addKaseikyoKey("TAPE_PLAY_REWIND", Unmapped_Key, 0xC2A, 0xA5);
 842   addKaseikyoKey("tape_play", Unmapped_Key, 0xC2A, 0xA6); // "TAPE_PLAY_FORWARD"
 843   addKaseikyoKey("tape", TapeInput_Key, 0xC2A, 0xAC);
 844   addKaseikyoKey("TAPE_DECK", Unmapped_Key, 0xC2A, 0xAD);
 845   addKaseikyoKey("rev_mode", Unmapped_Key, 0xC2A, 0xAE); // "TAPE_REV_MODE"
 846   addKaseikyoKey("counter_reset", Reset_Key, 0xC2A, 0xAF);
 847
 848   addKaseikyoKey("vol+", VolumeUp_Key, 0xC2A, 0xB0);
 849   addKaseikyoKey("vol-", VolumeDown_Key, 0xC2A, 0xB1);
 850   addKaseikyoKey("cd", CDInput_Key, 0xC2A, 0xB6);
 851   addKaseikyoKey("tuner-band", TunerInput_Key, 0xC2A, 0xB8);
 852   addKaseikyoKey("sleep", Sleep_Key, 0xC2A, 0xBC);
 853   addKaseikyoKey("power", Power_Key, 0xC2A, 0xBF);
 854
 855   addKaseikyoKey("TRACK>>", Unmapped_Key, 0xC2A, 0xD0);
 856   addKaseikyoKey("TRACK<<", Unmapped_Key, 0xC2A, 0xD1);
 857   addKaseikyoKey("xbs", Unmapped_Key, 0xC2A, 0xD6);
 858   addKaseikyoKey("preset_eq", Unmapped_Key, 0xC2A, 0xD9);
 859   addKaseikyoKey("virtualizer", Unmapped_Key, 0xC2A, 0xDA); // "S.VIRT"
 860
 861   addKaseikyoKey("fm-mode", FMMode_Key, 0xC2A, 0xE4); // "st-mono"
 862   addKaseikyoKey("TUNER_PRESET_TUNE_UP", NextPreset_Key, 0xC2A, 0xE7);
 863   addKaseikyoKey("TUNER_PRESET_TUNE_UP", Next_Key, 0xC2A, 0xE7);
 864   addKaseikyoKey("TUNER_PRESET_TUNE_DOWN", PrevPreset_Key, 0xC2A, 0xE8);
 865   addKaseikyoKey("TUNER_PRESET_TUNE_DOWN", Previous_Key, 0xC2A, 0xE8);
 866   addKaseikyoKey("tuning+", ChannelUp_Key, 0xC2A, 0xE9);
 867   addKaseikyoKey("tuning-", ChannelDown_Key, 0xC2A, 0xEA);
 868   addKaseikyoKey("AUTOSCAN", Scan_Key, 0xC2A, 0xEC);
 869   addKaseikyoKey("bp", Unmapped_Key, 0xC2A, 0xEF); // "TUNER_BP", beat-proof?
 870
 871   addKaseikyoKey("panelopen", Unmapped_Key, 0xC2A, 0xF4);  // "TOP_PANEL_OPEN"
 872   addKaseikyoKey("panelclose", Unmapped_Key, 0xC2A, 0xF5); // "TOP_PANEL_CLOSE"
 873 }
 874
 875
 876 PanasonicAudio2::PanasonicAudio2(
 877   unsigned int index)
 878   : PIRKeysetMetaData(
 879       "Audio Keyset 2",
 880       Panasonic_Make,
 881       index)
 882 {
 883 }
 884
 885
 886 void PanasonicAudio2::populateProtocol(
 887   QObject *guiObject)
 888 {
 889   if (threadableProtocol)
 890   {
 891     // Keyset already populated.
 892     return;
 893   }
 894
 895   threadableProtocol = new KaseikyoProtocol(guiObject, index);
 896
 897   setPreData(0x2002, 16);
 898
 899   addKaseikyoKey("Volume_Up", VolumeUp_Key, 0x00A, 0x20);
 900   addKaseikyoKey("Volume_Down", VolumeDown_Key, 0x00A, 0x21);
 901   addKaseikyoKey("Mute", Mute_Key, 0x00A, 0x32);
 902   addKaseikyoKey("INPUT:AUX", AuxInput_Key, 0x00A, 0x9A);
 903   addKaseikyoKey("Super_Woofer", Unmapped_Key, 0x00A, 0xC2);
 904
 905   addKaseikyoKey("tuner", TunerInput_Key, 0x04A, 0xA4);
 906
 907   addKaseikyoKey("tape", TapeInput_Key, 0x08A, 0x96);
 908   addKaseikyoKey("INPUT: TAPE Play", Unmapped_Key, 0x08A, 0x9E);
 909
 910   addKaseikyoKey("repeat", Repeat_Key, 0x0AA, 0x47);
 911   addKaseikyoKey("random", Random_Key, 0x0AA, 0x4D);
 912   addKaseikyoKey("program", Program_Key, 0x0AA, 0x8A);
 913   addKaseikyoKey("cd", CDInput_Key, 0x00A, 0x94);
 914   addKaseikyoKey("aux", AuxInput_Key, 0x00A, 0x9A);
 915   addKaseikyoKey("cancel", Clear_Key, 0x0AA, 0xA3);
 916   addKaseikyoKey("Disc", NextDisc_Key, 0x0AA, 0xA4);
 917
 918   addKaseikyoKey("Eq", Unmapped_Key, 0x10A, 0x83); // "Preset EQ"
 919
 920   addKaseikyoKey("S.Sound EQ", Unmapped_Key, 0x12A, 0xC5);
 921
 922   addKaseikyoKey("Stop", Stop_Key, 0x1CA, 0x00);
 923   addKaseikyoKey("Play_Reverse", Unmapped_Key, 0x1CA, 0x06);
 924   addKaseikyoKey("Play/Pause", Play_Key, 0x1CA, 0x0A);
 925   addKaseikyoKey("Play/Pause", Pause_Key, 0x1CA, 0x0A);
 926   addKaseikyoKey("1", One_Key, 0x1CA, 0x10);
 927   addKaseikyoKey("2", Two_Key, 0x1CA, 0x11);
 928   addKaseikyoKey("3", Three_Key, 0x1CA, 0x12);
 929   addKaseikyoKey("4", Four_Key, 0x1CA, 0x13);
 930   addKaseikyoKey("5", Five_Key, 0x1CA, 0x14);
 931   addKaseikyoKey("6", Six_Key, 0x1CA, 0x15);
 932   addKaseikyoKey("7", Seven_Key, 0x1CA, 0x16);
 933   addKaseikyoKey("8", Eight_Key, 0x1CA, 0x17);
 934   addKaseikyoKey("9", Nine_Key, 0x1CA, 0x18);
 935   addKaseikyoKey("0", Zero_Key, 0x1CA, 0x19);
 936   addKaseikyoKey("Power", Power_Key, 0x1CA, 0x3D);
 937   addKaseikyoKey("discrete on", PowerOn_Key, 0x1CA, 0x3E);
 938   addKaseikyoKey("discrete off", PowerOff_Key, 0x1CA, 0x3F);
 939   addKaseikyoKey("Back", Previous_Key, 0x1CA, 0x49);
 940   addKaseikyoKey("Forward", Next_Key, 0x1CA, 0x4A);
 941   addKaseikyoKey("Display", Info_Key, 0x1CA, 0x55);
 942   addKaseikyoKey(">10", DoubleDigit_Key, 0x1CA, 0x84);
 943   addKaseikyoKey("clock/timer", Timer_Key, 0x1CA, 0x95);
 944   addKaseikyoKey("Sleep", Sleep_Key, 0x1CA, 0x96);
 945   addKaseikyoKey("Dimmer", Unmapped_Key, 0x1CA, 0x97);
 946   addKaseikyoKey("play/record timer", Unmapped_Key, 0x1CA, 0x9B);
 947   addKaseikyoKey("play mode", Mode_Key, 0x1CA, 0xBB);
 948 }
 949
 950
 951 PanasonicAudio2a::PanasonicAudio2a(
 952   unsigned int index)
 953   : PanasonicAudio2(index)
 954 {
 955   setKeysetName("Audio Keyset 2a");
 956 }
 957
 958
 959 void PanasonicAudio2a::populateProtocol(
 960   QObject *guiObject)
 961 {
 962   if (threadableProtocol)
 963   {
 964     // Keyset already populated.
 965     return;
 966   }
 967
 968   PanasonicAudio2::populateProtocol(guiObject);
 969
 970   addKaseikyoKey("INPUT: CD play/pause", CDInput_Key, 0x0AA, 0x0A);
 971   addKaseikyoKey("INPUT: CD play/pause", Play_Key, 0x0AA, 0x0A);
 972   addKaseikyoKey("INPUT: CD play/pause", Pause_Key, 0x0AA, 0x0A);
 973 }
 974
 975
 976 PanasonicAudio3::PanasonicAudio3(
 977   unsigned int index)
 978   : PIRKeysetMetaData(
 979       "Audio Keyset 3",
 980       Panasonic_Make,
 981       index)
 982 {
 983 }
 984
 985
 986 void PanasonicAudio3::populateProtocol(
 987   QObject *guiObject)
 988 {
 989   if (threadableProtocol)
 990   {
 991     // Keyset already populated.
 992     return;
 993   }
 994
 995   threadableProtocol = new PanasonicOldProtocol(guiObject, index);
 996
 997   addPanOldKey("audio_power", Power_Key, 0x09, 0x20);
 998   addPanOldKey("audio_phono", PhonoInput_Key, 0x09, 0x0C);
 999   addPanOldKey("vol-", VolumeDown_Key, 0x09, 0x25);
1000   addPanOldKey("vol+", VolumeUp_Key, 0x09, 0x24);
1001   addPanOldKey("audio_video", Input_Key, 0x09, 0x2E);
1002   addPanOldKey("audio_tape", TapeInput_Key, 0x09, 0x0A);
1003   addPanOldKey("tuner-", ChannelDown_Key, 0x09, 0x23);
1004   addPanOldKey("tuner+", ChannelUp_Key, 0x09, 0x22);
1005   addPanOldKey("cd_skip-", Previous_Key, 0x0C, 0x02);
1006   addPanOldKey("cd_skip+", Next_Key, 0x0C, 0x03);
1007   addPanOldKey("cd_stop", Stop_Key, 0x0C, 0x00);
1008   addPanOldKey("cd_play", Play_Key, 0x0C, 0x0A);
1009   addPanOldKey("vcr_power", Unmapped_Key, 0x02, 0x20);
1010   addPanOldKey("vcr_stop", Unmapped_Key, 0x02, 0x00);
1011   addPanOldKey("vcr_ch-", Unmapped_Key, 0x02, 0x23);
1012   addPanOldKey("vcr_ch+", Unmapped_Key, 0x02, 0x22);
1013   addPanOldKey("tv_vcr", Unmapped_Key, 0x02, 0x2A);
1014   addPanOldKey("vcr_pause", Unmapped_Key, 0x02, 0x06);
1015   addPanOldKey("vcr_rec", Unmapped_Key, 0x02, 0x08);
1016   addPanOldKey("tv_power", Unmapped_Key, 0x00, 0x20);
1017   addPanOldKey("vcr_play", Unmapped_Key, 0x02, 0x0A);
1018   addPanOldKey("vcr_rew", Unmapped_Key, 0x02, 0x02);
1019   addPanOldKey("vcr_ff", Unmapped_Key, 0x02, 0x03);
1020   addPanOldKey("tv_video", Unmapped_Key, 0x00, 0x0D);
1021   addPanOldKey("tv_ant", Unmapped_Key, 0x00, 0x2A);
1022   addPanOldKey("tv_ch-", Unmapped_Key, 0x00, 0x23);
1023   addPanOldKey("tv_ch+", Unmapped_Key, 0x00, 0x22);
1024 }
1025
1026
1027 PanasonicAC1::PanasonicAC1(
1028   unsigned int index)
1029   : PIRKeysetMetaData(
1030       "Air Conditioner 1",
1031       Panasonic_Make,
1032       index)
1033 {
1034 }
1035
1036
1037 void PanasonicAC1::populateProtocol(
1038   QObject *guiObject)
1039 {
1040   if (threadableProtocol)
1041   {
1042     // If the pointer is not null, the keyset must already be populated.
1043     return;
1044   }
1045
1046   threadableProtocol = new NECProtocol(guiObject, index, true, true);
1047
1048   setPreData(0x6681, 16);
1049
1050   addKey("Operation", Power_Key, 0x81, 8);
1051   addKey("Economy", EnergySave_Key, 0x82, 8);
1052   addKey("Air Swing", Oscillate_Key, 0x83, 8);
1053   addKey("Temp Up", TempUp_Key, 0x85, 8);
1054   addKey("Temp Down", TempDown_Key, 0x8A, 8);
1055   addKey("Fan Speed", FanFaster_Key, 0x99, 8);
1056   addKey("Mode", Mode_Key, 0x9B, 8);
1057   addKey("Timer", Timer_Key, 0x9F, 8);
1058 }