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

   1 #include "sony.h"
   2 #include "protocols/sircprotocol.h"
   3 #include "protocols/aiwaprotocol.h"
   4
   5
   6 SonyTV1::SonyTV1(
   7   unsigned int index)
   8   : PIRKeysetMetaData(
   9       "TV Keyset 1",
  10       Sony_Make,
  11       index)
  12 {
  13   addControlledDevice(Sony_Make, "KV-M1420D", TV_Device);
  14   addControlledDevice(Sony_Make, "KV-20FV10", TV_Device);
  15   addControlledDevice(Sony_Make, "KV-2167MT", TV_Device);
  16   addControlledDevice(Sony_Make, "KV-2184MT", TV_Device);
  17   addControlledDevice(Sony_Make, "KV-27FX210", TV_Device);
  18   addControlledDevice(Sony_Make, "KV-32FS210", TV_Device);
  19   addControlledDevice(Sony_Make, "KV-36FS210", TV_Device);
  20   addControlledDevice(Sony_Make, "KV-36FS13", TV_Device);
  21   addControlledDevice(Sony_Make, "KDL-23B4030", TV_Device);
  22   addControlledDevice(Sony_Make, "KDL-40EX403", TV_Device);
  23   addControlledDevice(Sony_Make, "KDL-40EX520", TV_Device);
  24   addControlledDevice(Sony_Make, "KDL-40X2000", TV_Device);
  25   addControlledDevice(Sony_Make, "KDL-52X2000", TV_Device);
  26   addControlledDevice(Sony_Make, "KDL-46X2000", TV_Device);
  27   addControlledDevice(Sony_Make, "KP-46WT520", TV_Device);
  28 }
  29
  30
  31 void SonyTV1::populateProtocol(
  32   QObject *guiObject)
  33 {
  34   if (threadableProtocol)
  35   {
  36     // If the pointer is not null, the keyset must already be populated.
  37     return;
  38   }
  39
  40   threadableProtocol = new SIRCProtocol(guiObject, index);
  41
  42   addSIRC12Key("1", One_Key, 0x01, 0x00);
  43   addSIRC12Key("2", Two_Key, 0x01, 0x01);
  44   addSIRC12Key("3", Three_Key, 0x01, 0x02);
  45   addSIRC12Key("4", Four_Key, 0x01, 0x03);
  46   addSIRC12Key("5", Five_Key, 0x01, 0x04);
  47   addSIRC12Key("6", Six_Key, 0x01, 0x05);
  48   addSIRC12Key("7", Seven_Key, 0x01, 0x06);
  49   addSIRC12Key("8", Eight_Key, 0x01, 0x07);
  50   addSIRC12Key("9", Nine_Key, 0x01, 0x08);
  51   addSIRC12Key("0", Zero_Key, 0x01, 0x09);
  52   addSIRC12Key("enter", Enter_Key, 0x01, 0x0B);
  53   addSIRC12Key("1-", Unmapped_Key, 0x01, 0x0C);
  54   addSIRC12Key("2-", Unmapped_Key, 0x01, 0x0D);
  55   addSIRC12Key("C", Clear_Key, 0x01, 0x0E); // "C00"
  56   addSIRC12Key("CHANNEL/PAGE+", ChannelUp_Key, 0x01, 0x10);
  57   addSIRC12Key("CHANNEL/PAGE-", ChannelDown_Key, 0x01, 0x11);
  58   addSIRC12Key("VOLUME+", VolumeUp_Key, 0x01, 0x12);
  59   addSIRC12Key("VOLUME-", VolumeDown_Key, 0x01, 0x13);
  60   addSIRC12Key("MUTE", Mute_Key, 0x01, 0x14);
  61   addSIRC12Key("POWER", Power_Key, 0x01, 0x15);
  62   addSIRC12Key("normalise", Reset_Key, 0x01, 0x16); // "reset"
  63   addSIRC12Key("a/b", Audio_Key, 0x01, 0x17); // "mts", "sap", "language"
  64   addSIRC12Key("picture_up", ContrastUp_Key, 0x01, 0x18); // "Contrast Up"
  65   addSIRC12Key("picture_down", ContrastDown_Key, 0x1, 0x19); // "Contrast Down"
  66   addSIRC12Key("-/--", DoubleDigit_Key, 0x01, 0x1D);
  67   addSIRC12Key("tv/video", Input_Key, 0x01, 0x25);
  68   addSIRC12Key("bucket", Unmapped_Key, 0x01, 0x28);
  69   addSIRC12Key("stereo", Surround_Key, 0x01, 0x29);
  70   addSIRC12Key("ANT", AntennaInput_Key, 0x01, 0x2A);
  71   addSIRC12Key("time", Clock_Key, 0x01, 0x2B);
  72   addSIRC12Key("timer/block", Timer_Key, 0x01, 0x30);
  73   addSIRC12Key("right", Right_Key, 0x01, 0x33);
  74   addSIRC12Key("left", Left_Key, 0x01, 0x34);
  75   addSIRC12Key("sleep", Sleep_Key, 0x01, 0x36);
  76   addSIRC12Key("TV-RETURN", Unmapped_Key, 0x01, 0x38); // "analog"
  77   addSIRC12Key("?/INFO", Info_Key, 0x01, 0x3A); // Teletext Index
  78   addSIRC12Key("prev_ch", PrevChannel_Key, 0x01, 0x3B); // "jump"
  79   addSIRC12Key("off/repeat", Repeat_Key, 0x01, 0x3C);
  80   addSIRC12Key("TELETXT", Teletext_Key, 0x01, 0x3F);
  81   addSIRC12Key("favourite", Unmapped_Key, 0x01, 0x4A); // separate keyset?
  82   addSIRC12Key("cable", CableInput_Key, 0x01, 0x4E);
  83   addSIRC12Key("Sat", SatInput_Key, 0x01, 0x51);
  84   addSIRC12Key("pip_ch+", PIPChannelUp_Key, 0x01, 0x58);
  85   addSIRC12Key("pip_ch-", PIPChannelDown_Key, 0x01, 0x59);
  86   addSIRC12Key("piptv_video", PIPSource_Key, 0x01, 0x5A);
  87   addSIRC12Key("PIP", PIP_Key, 0x01, 0x5B);
  88   addSIRC12Key("pipfreeze", PIPPause_Key, 0x01, 0x5C);
  89   addSIRC12Key("PIP_POSITION", PIPMove_Key, 0x01, 0x5E);
  90   addSIRC12Key("PIP_SWAP", PIPSwap_Key, 0x01, 0x5F);
  91   addSIRC12Key("MENU", Menu_Key, 0x01, 0x60);
  92   addSIRC12Key("Settup_V", Unmapped_Key, 0x01, 0x61); // alternate pic mode
  93   addSIRC12Key("Settup_A", Unmapped_Key, 0x01, 0x62); // alternate sound mode
  94   addSIRC12Key("EXIT", Exit_Key, 0x01, 0x63);
  95   addSIRC12Key("picturemode", PictureMode_Key, 0x01, 0x64);
  96   addSIRC12Key("OK", Select_Key, 0x01, 0x65); // "return", "select", "enter"
  97   addSIRC12Key("output", Unmapped_Key, 0x01, 0x66);
  98   addSIRC12Key("PIP_SOURCE", Unmapped_Key, 0x01, 0x67); // separate keyset?
  99   addSIRC12Key("asterisk", Unmapped_Key, 0x01, 0x68); // "TV System"
 100   addSIRC12Key("auto_program", Unmapped_Key, 0x01, 0x6B);
 101   addSIRC12Key("setup", Program_Key, 0x01, 0x6C);
 102   addSIRC12Key("tune_down", Unmapped_Key, 0x01, 0x6F); // "search -"
 103   addSIRC12Key("tune_up", Unmapped_Key, 0x01, 0x6E); // "search +"
 104   addSIRC12Key("up", Up_Key, 0x01, 0x74);
 105   addSIRC12Key("down", Down_Key, 0x01, 0x75);
 106   addSIRC12Key("diamond", Unmapped_Key, 0x01, 0x78); // "add"
 107   addSIRC12Key("erase", Unmapped_Key, 0x01, 0x79);
 108   addSIRC12Key("select", Unmapped_Key, 0x01, 0x7C); // PictureMode_Key?
 109
 110   addSIRC12Key("vt_inf", TeletextIndex_Key, 0x03, 0x48); // "Teletext Home"
 111   addSIRC12Key("expand", TeletextSize_Key, 0x03, 0x49);
 112   addSIRC12Key("Teletext Hold", TeletextHold_Key, 0x03, 0x4A); // "shrink"
 113   addSIRC12Key("subtitles", Unmapped_Key, 0x03, 0x4B); // Teletext subtitles
 114   addSIRC12Key("LEFT/-/RED", Red_Key, 0x03, 0x4C);
 115   addSIRC12Key("UP/GREEN", Green_Key, 0x03, 0x4D);
 116   addSIRC12Key("RIGHT/+/YELLOW", Yellow_Key, 0x03, 0x4E);
 117   addSIRC12Key("DOWN/BLUE", Blue_Key, 0x03, 0x4F);
 118
 119   addSIRC15Key("SYNC_MENU", Unmapped_Key, 0x1A, 0x58);
 120   addSIRC15Key("SCENE", Unmapped_Key, 0x1A, 0x78);
 121   addSIRC15Key("INTERNET_VIDEO", Unmapped_Key, 0x1A, 0x79);
 122   addSIRC15Key("I-MANUAL", Unmapped_Key, 0x1A, 0x7B);
 123
 124   addSIRC15Key("DIGITAL_ANALOG", Unmapped_Key, 0x77, 0x0D);
 125   addSIRC15Key("DIGITAL", Unmapped_Key, 0x77, 0x52);
 126   addSIRC15Key("theatre", Unmapped_Key, 0x77, 0x60); // "Home Theater"
 127   addSIRC15Key("FAVORITES", Favorites_Key, 0x77, 0x76);
 128
 129   addSIRC15Key("STOP", Stop_Key, 0x97, 0x18);
 130   addSIRC15Key("PAUSE", Pause_Key, 0x97, 0x19);
 131   addSIRC15Key("PLAY", Play_Key, 0x97, 0x1A);
 132   addSIRC15Key("FBACKWARD", Rewind_Key, 0x97, 0x1B);
 133   addSIRC15Key("FFORWARD", FastForward_Key, 0x97, 0x1C);
 134   addSIRC15Key("DOT", Unmapped_Key, 0x97, 0x1D);
 135   addSIRC15Key("RETURN", Unmapped_Key, 0x97, 0x23); // exit?
 136   addSIRC15Key("TOOLS", Unmapped_Key, 0x97, 0x36); // "OPTIONS"
 137   addSIRC15Key("PREVIOUS", Previous_Key, 0x97, 0x3C);
 138   addSIRC15Key("NEXT", Next_Key, 0x97, 0x3D);
 139   addSIRC15Key("REPLAY", Replay_Key, 0x97, 0x79);
 140   addSIRC15Key("ADVANCE", Advance_Key, 0x97, 0x78);
 141   addSIRC15Key("SOUND", Unmapped_Key, 0x97, 0x7B);
 142
 143   addSIRC15Key("Surround_Mode", Unmapped_Key, 0xA4, 0x1F); // "Music"
 144   addSIRC15Key("16:9", AspectRatio_Key, 0xA4, 0x3D); // "WIDE"
 145   addSIRC15Key("EPG", Guide_Key, 0xA4, 0x5B);
 146   addSIRC15Key("PIP_Audio", Unmapped_Key, 0xA4, 0x7C);
 147 }
 148
 149
 150 SonyTV1a::SonyTV1a(
 151   unsigned int index)
 152   : SonyTV1(index)
 153 {
 154   setKeysetName("TV Keyset 1a");
 155
 156   addControlledDevice(Sony_Make, "KDW-25", TV_Device);
 157 }
 158
 159
 160 void SonyTV1a::populateProtocol(
 161   QObject *guiObject)
 162 {
 163   if (threadableProtocol)
 164   {
 165     // If the pointer is not null, the keyset must already be populated.
 166     return;
 167   }
 168
 169   SonyTV1::populateProtocol(guiObject);
 170
 171   addSIRC12Key("LEFT/-/RED", Left_Key, 0x03, 0x4C);
 172   addSIRC12Key("UP/GREEN", Up_Key, 0x03, 0x4D);
 173   addSIRC12Key("RIGHT/+/YELLOW", Right_Key, 0x03, 0x4E);
 174   addSIRC12Key("DOWN/BLUE", Down_Key, 0x03, 0x4F);
 175 }
 176
 177
 178 SonyTV1b::SonyTV1b(
 179   unsigned int index)
 180   : SonyTV1a(index)
 181 {
 182   setKeysetName("TV Keyset 1b");
 183 }
 184
 185
 186 void SonyTV1b::populateProtocol(
 187   QObject *guiObject)
 188 {
 189   if (threadableProtocol)
 190   {
 191     // If the pointer is not null, the keyset must already be populated.
 192     return;
 193   }
 194
 195   SonyTV1a::populateProtocol(guiObject);
 196
 197   addSIRC12Key("clear", Unmapped_Key, 0x01, 0x34); // "Clock Clear"
 198   addSIRC12Key("level_plus", Unmapped_Key, 0x01, 0x74);
 199   addSIRC12Key("level_minus", Unmapped_Key, 0x01, 0x75);
 200   addSIRC12Key("am/pm", Unmapped_Key, 0x01, 0x33);
 201 }
 202
 203
 204 // Not sure about these codes:
 205 SonyTV1c::SonyTV1c(
 206   unsigned int index)
 207   : SonyTV1(index)
 208 {
 209   setKeysetName("TV Keyset 1c");
 210 }
 211
 212
 213 void SonyTV1c::populateProtocol(
 214   QObject *guiObject)
 215 {
 216   if (threadableProtocol)
 217   {
 218     // If the pointer is not null, the keyset must already be populated.
 219     return;
 220   }
 221
 222   SonyTV1::populateProtocol(guiObject);
 223
 224   addSIRC12Key(">>", FastForward_Key, 0x01, 0x58);
 225   addSIRC12Key("<<", Rewind_Key, 0x01, 0x59);
 226   addSIRC12Key("rec", Record_Key, 0x01, 0x5A);
 227   addSIRC12Key("pause", Pause_Key, 0x01, 0x5C);
 228   addSIRC12Key("stop", Stop_Key, 0x01, 0x5E);
 229   addSIRC12Key("play", Play_Key, 0x01, 0x5F);
 230
 231   addSIRC15Key("BLUE", Blue_Key, 0x97, 0x24);
 232   addSIRC15Key("RED", Red_Key, 0x97, 0x25);
 233   addSIRC15Key("GREEN", Green_Key, 0x97, 0x26);
 234   addSIRC15Key("YELLOW", Yellow_Key, 0x97, 0x27);
 235   addSIRC15Key("SUBTITLES", Captions_Key, 0x97, 0x28);
 236 }
 237
 238
 239 SonyTV2::SonyTV2(
 240   unsigned int index)
 241   : PIRKeysetMetaData(
 242       "TV Keyset 2",
 243       Sony_Make,
 244       index)
 245 {
 246 }
 247
 248
 249 void SonyTV2::populateProtocol(
 250   QObject *guiObject)
 251 {
 252   if (threadableProtocol)
 253   {
 254     // Keyset already populated.
 255     return;
 256   }
 257
 258   threadableProtocol = new AiwaProtocol(guiObject, index);
 259
 260   setPreData(0x0119, 13);
 261
 262   addKey("0", Zero_Key, 0x00, 8);
 263   addKey("1", One_Key, 0x01, 8);
 264   addKey("2", Two_Key, 0x02, 8);
 265   addKey("3", Three_Key, 0x03, 8);
 266   addKey("4", Four_Key, 0x04, 8);
 267   addKey("5", Five_Key, 0x05, 8);
 268   addKey("6", Six_Key, 0x06, 8);
 269   addKey("7", Seven_Key, 0x07, 8);
 270   addKey("8", Eight_Key, 0x08, 8);
 271   addKey("9", Nine_Key, 0x09, 8);
 272   addKey("sleep", Sleep_Key, 0x0A, 8);
 273   addKey("tv/av", Input_Key, 0x0E, 8);
 274   addKey("back", PrevChannel_Key, 0x0F, 8);
 275
 276   addKey("display", Info_Key, 0x10, 8);
 277   addKey("cc", Captions_Key, 0x11, 8);
 278   addKey("input 1", Unmapped_Key, 0x12, 8);
 279   addKey("pip on/off", PIP_Key, 0x13, 8);
 280   addKey("pip move", PIPMove_Key, 0x14, 8);
 281   addKey("mute", Mute_Key, 0x15, 8);
 282   addKey("pip swap", PIPSwap_Key, 0x16, 8);
 283   addKey("menu", Menu_Key, 0x17, 8);
 284   addKey("ch-", ChannelDown_Key, 0x1A, 8);
 285   addKey("ch-", Down_Key, 0x1A, 8);
 286   addKey("ch+", ChannelUp_Key, 0x1B, 8);
 287   addKey("ch+", Up_Key, 0x1B, 8);
 288   addKey("power", Power_Key, 0x1C, 8);
 289   addKey("freeze", PIPPause_Key, 0x1D, 8);
 290   addKey("vol-", VolumeDown_Key, 0x1E, 8);
 291   addKey("vol-", Left_Key, 0x1E, 8);
 292   addKey("vol+", VolumeUp_Key, 0x1F, 8);
 293   addKey("vol+", Right_Key, 0x1F, 8);
 294 }
 295
 296
 297 // These controls don't quite match other SIRC data.  (some do, some don't)
 298 // This all taken from LIRC "AMPIR" config file.
 299 SonyAmp1::SonyAmp1(
 300   unsigned int index)
 301   : PIRKeysetMetaData(
 302       "Amp Keyset 1",
 303       Sony_Make,
 304       index)
 305 {
 306 }
 307
 308
 309 void SonyAmp1::populateProtocol(
 310   QObject *guiObject)
 311 {
 312   if (threadableProtocol)
 313   {
 314     // If the pointer is not null, the keyset must already be populated.
 315     return;
 316   }
 317
 318   threadableProtocol = new SIRCProtocol(guiObject, index);
 319
 320   addSIRC12Key("1", One_Key, 0x0C, 0x00);
 321   addSIRC12Key("2", Two_Key, 0x0C, 0x01);
 322   addSIRC12Key("3", Three_Key, 0x0C, 0x02);
 323   addSIRC12Key("4", Four_Key, 0x0C, 0x03);
 324   addSIRC12Key("5", Five_Key, 0x0C, 0x04);
 325   addSIRC12Key("6", Six_Key, 0x0C, 0x05);
 326   addSIRC12Key("7", Seven_Key, 0x0C, 0x06);
 327   addSIRC12Key("8", Eight_Key, 0x0C, 0x07);
 328   addSIRC12Key("9", Nine_Key, 0x0C, 0x08);
 329   addSIRC12Key("0", Zero_Key, 0x0C, 0x09);
 330   addSIRC12Key("ENTER", Enter_Key, 0x0C, 0x0B);
 331   addSIRC12Key("DIGITAL", Unmapped_Key, 0x0C, 0x0C);
 332   addSIRC12Key("VIDEO3", Unmapped_Key, 0x0C, 0x0A);
 333   addSIRC12Key("VIDEO4", Unmapped_Key, 0x0C, 0x0B);
 334   addSIRC12Key("VOL+", VolumeUp_Key, 0x0C, 0x12);
 335   addSIRC12Key("VOL-", VolumeDown_Key, 0x0C, 0x13);
 336   addSIRC12Key("MUTE", Mute_Key, 0x0C, 0x14);
 337   addSIRC12Key("POWER", Power_Key, 0x0C, 0x15);
 338   addSIRC12Key("LD", LDInput_Key, 0x0C, 0x19);
 339   addSIRC12Key("TV", CableInput_Key, 0x0C, 0x18);
 340   addSIRC12Key("VIDEO2", Unmapped_Key, 0x0C, 0x1E);
 341   addSIRC12Key("PHONO", PhonoInput_Key, 0x0C, 0x20);
 342   addSIRC12Key("TUNER", TunerInput_Key, 0x0C, 0x21);
 343   addSIRC12Key("VIDEO1", Unmapped_Key, 0x0C, 0x22);
 344   addSIRC12Key("TAPE", TapeInput_Key, 0x0C, 0x23);
 345   addSIRC12Key("CD", CDInput_Key, 0x0C, 0x25);
 346   addSIRC12Key("DAT", Unmapped_Key, 0x0C, 0x46);
 347   addSIRC12Key("SLEEP", Sleep_Key, 0x0C, 0x60);
 348   addSIRC12Key("MD", MDInput_Key, 0x0C, 0x69);
 349   addSIRC12Key("TV2", Unmapped_Key, 0x0C, 0x6A);
 350   addSIRC12Key("5.1CH", Unmapped_Key, 0x0C, 0x72);
 351   addSIRC12Key("DVD", DVDInput_Key, 0x0C, 0x7D);
 352 }
 353
 354
 355 // These taken from LIRC config file "RM-AV2100T".
 356 SonyAmp2::SonyAmp2(
 357   unsigned int index)
 358   : PIRKeysetMetaData(
 359       "Amp Keyset 2",
 360       Sony_Make,
 361       index)
 362 {
 363 }
 364
 365
 366 void SonyAmp2::populateProtocol(
 367   QObject *guiObject)
 368 {
 369   if (threadableProtocol)
 370   {
 371     // If the pointer is not null, the keyset must already be populated.
 372     return;
 373   }
 374
 375   threadableProtocol = new SIRCProtocol(guiObject, index);
 376
 377   addSIRC12Key("up", Up_Key, 0x0C, 0x78);
 378   addSIRC12Key("down", Down_Key, 0x0C, 0x79);
 379   addSIRC12Key("left", Left_Key, 0x0C, 0x7A);
 380   addSIRC12Key("right", Right_Key, 0x0C, 0x7B);
 381
 382   addSIRC12Key("program_+", ChannelUp_Key, 0x0D, 0x10);
 383   addSIRC12Key("program_-", ChannelDown_Key, 0x0D, 0x11);
 384   addSIRC12Key("shift", Unmapped_Key, 0x0D, 0x55);
 385
 386   addSIRC12Key("1", One_Key, 0x10, 0x00);
 387   addSIRC12Key("2", Two_Key, 0x10, 0x01);
 388   addSIRC12Key("3", Three_Key, 0x10, 0x02);
 389   addSIRC12Key("4", Four_Key, 0x10, 0x03);
 390   addSIRC12Key("5", Five_Key, 0x10, 0x04);
 391   addSIRC12Key("6", Six_Key, 0x10, 0x05);
 392   addSIRC12Key("7", Seven_Key, 0x10, 0x06);
 393   addSIRC12Key("8", Eight_Key, 0x10, 0x07);
 394   addSIRC12Key("9", Nine_Key, 0x10, 0x08);
 395   addSIRC12Key("0", Zero_Key, 0x10, 0x09);
 396   addSIRC12Key("enter", Enter_Key, 0x10, 0x0C);
 397   addSIRC12Key("vol_+", VolumeUp_Key, 0x10, 0x12);
 398   addSIRC12Key("vol_-", VolumeDown_Key, 0x10, 0x13);
 399   addSIRC12Key("mute", Mute_Key, 0x10, 0x14);
 400   addSIRC12Key("power", Power_Key, 0x10, 0x15);
 401   addSIRC12Key("aux/vdp", AuxInput_Key, 0x10, 0x1D);
 402   addSIRC12Key("video2", Unmapped_Key, 0x10, 0x1E);
 403   addSIRC12Key("phono", PhonoInput_Key, 0x10, 0x20);
 404   addSIRC12Key("tuner", TunerInput_Key, 0x10, 0x21);
 405   addSIRC12Key("video1", Unmapped_Key, 0x10, 0x22);
 406   addSIRC12Key("tape", TapeInput_Key, 0x10, 0x23);
 407   addSIRC12Key("cd", CDInput_Key, 0x10, 0x25);
 408   addSIRC12Key("power_on", PowerOn_Key, 0x10, 0x2E);
 409   addSIRC12Key("video3", Unmapped_Key, 0x10, 0x42);
 410   addSIRC12Key("tv", CableInput_Key, 0x10, 0x6A);
 411   addSIRC12Key("dvd", DVDInput_Key, 0x10, 0x7D);
 412
 413   addSIRC15Key("md/dat", MDInput_Key, 0x10, 0x69);
 414 }
 415
 416
 417 SonyAudio1::SonyAudio1(
 418   unsigned int index)
 419   : PIRKeysetMetaData(
 420       "Audio Keyset 1",
 421       Sony_Make,
 422       index)
 423 {
 424 }
 425
 426
 427 void SonyAudio1::populateProtocol(
 428   QObject *guiObject)
 429 {
 430   if (threadableProtocol)
 431   {
 432     // If the pointer is not null, the keyset must already be populated.
 433     return;
 434   }
 435
 436   threadableProtocol = new SIRCProtocol(guiObject, index);
 437
 438   addSIRC12Key("tv_video", Input_Key, 0x01, 0x25);
 439
 440   addSIRC12Key("DSG", Unmapped_Key, 0x0C, 0x31);
 441
 442   addSIRC12Key("MEMORY", Program_Key, 0x0D, 0x0E);
 443   addSIRC12Key("TUNER-BAND", TunerInput_Key, 0x0D, 0x0F);
 444   addSIRC12Key("TUNING_MODE", Unmapped_Key, 0x0D, 0x17);
 445   addSIRC12Key("STEREO-MONO", FMMode_Key, 0x0D, 0x21);
 446
 447   addSIRC12Key("DIR_MODE", Unmapped_Key, 0x0E, 0x14);
 448   addSIRC12Key("REC", Record_Key, 0x0E, 0x1E);
 449   addSIRC12Key("TAPE", TapeInput_Key, 0x0E, 0x34);
 450
 451   addSIRC12Key("tuner", ChannelUp_Key, 0x10, 0x0F); // "Tune Up"
 452   addSIRC12Key("VOL+", VolumeUp_Key, 0x10, 0x12);
 453   addSIRC12Key("VOL-", VolumeDown_Key, 0x10, 0x13);
 454   addSIRC12Key("ON-OFF", Power_Key, 0x10, 0x15);
 455   addSIRC12Key("effect_on_off", Unmapped_Key, 0x10, 0x1F);
 456   addSIRC12Key("cd", CDInput_Key, 0x10, 0x25);
 457   addSIRC12Key("DISPLAY", Info_Key, 0x10, 0x4B);
 458   addSIRC12Key("dimmer", Unmapped_Key, 0x10, 0x4D);
 459   addSIRC12Key("karaoke_mpx", Unmapped_Key, 0x10, 0x5F);
 460   addSIRC12Key("SLEEP", Sleep_Key, 0x10, 0x60);
 461   addSIRC12Key("TIMER_SELECT", Unmapped_Key, 0x10, 0x62); // "clock_select"
 462   addSIRC12Key("TIMER_SET", Timer_Key, 0x10, 0x65);
 463   addSIRC12Key("md", Unmapped_Key, 0x10, 0x69);
 464   addSIRC12Key("game", Unmapped_Key, 0x10, 0x7C);
 465
 466   addSIRC12Key("CD_REPEAT", Repeat_Key, 0x11, 0x2C);
 467   addSIRC12Key("CD", Unmapped_Key, 0x11, 0x32);
 468   addSIRC12Key("PLAY_MODE", Unmapped_Key, 0x11, 0x6C);
 469
 470   addSIRC15Key("cinema_effect", Unmapped_Key, 0x90, 0x08);
 471   addSIRC15Key("game_mixing", Unmapped_Key, 0x90, 0x33);
 472   addSIRC15Key("spectrum", Unmapped_Key, 0x90, 0x34);
 473   addSIRC15Key("p_file", Unmapped_Key, 0x90, 0x39);
 474   addSIRC15Key("surround_speaker_mode", Surround_Key, 0x90, 0x5F);
 475   addSIRC15Key("music_eq", Unmapped_Key, 0x90, 0x60);
 476   addSIRC15Key("movie_eq", Unmapped_Key, 0x90, 0x61);
 477   addSIRC15Key("game_eq", Unmapped_Key, 0x90, 0x62);
 478
 479   addSIRC20Key("return", Exit_Key, 0x31, 0x1A, 0x0E);
 480   addSIRC20Key("prev_r", Unmapped_Key, 0x31, 0x1A, 0x36);
 481   addSIRC20Key("next_r", Unmapped_Key, 0x31, 0x1A, 0x37);
 482   addSIRC20Key("special_menu", Menu_Key, 0x31, 0x1A, 0x53);
 483   addSIRC20Key("on_screen", Unmapped_Key, 0x31, 0x1A, 0x55);
 484   addSIRC20Key("sharp", Unmapped_Key, 0x31, 0x1A, 0x6B);
 485   addSIRC20Key("flat", Unmapped_Key, 0x31, 0x1A, 0x6C);
 486   addSIRC20Key("album-", Unmapped_Key, 0x31, 0x1A, 0x6E);
 487   addSIRC20Key("album+", Unmapped_Key, 0x31, 0x1A, 0x6F);
 488
 489   addSIRC20Key("1", One_Key, 0x39, 0x1A, 0x00);
 490   addSIRC20Key("2", Two_Key, 0x39, 0x1A, 0x01);
 491   addSIRC20Key("3", Three_Key, 0x39, 0x1A, 0x02);
 492   addSIRC20Key("4", Four_Key, 0x39, 0x1A, 0x03);
 493   addSIRC20Key("5", Five_Key, 0x39, 0x1A, 0x04);
 494   addSIRC20Key("6", Six_Key, 0x39, 0x1A, 0x05);
 495   addSIRC20Key("7", Seven_Key, 0x39, 0x1A, 0x06);
 496   addSIRC20Key("8", Eight_Key, 0x39, 0x1A, 0x07);
 497   addSIRC20Key("9", Nine_Key, 0x39, 0x1A, 0x08);
 498   addSIRC20Key("0", Zero_Key, 0x39, 0x1A, 0x09);
 499   addSIRC20Key("KEY_ENTER", Enter_Key, 0x39, 0x1A, 0x0C);
 500   addSIRC20Key("gt_10", DoubleDigit_Key, 0x39, 0x1A, 0x0D);
 501   addSIRC20Key("clear", Clear_Key, 0x39, 0x1A, 0x0F);
 502   addSIRC20Key("repeat", Repeat_Key, 0x39, 0x1A, 0x2C);
 503   addSIRC20Key("KEY_PREV_SONG", Previous_Key, 0x39, 0x1A, 0x30);
 504   addSIRC20Key("KEY_NEXT_SONG", Next_Key, 0x39, 0x1A, 0x31);
 505   addSIRC20Key("KEY_PREV", Rewind_Key, 0x39, 0x1A, 0x33); // "Rewind"
 506   addSIRC20Key("KEY_NEXT", FastForward_Key, 0x39, 0x1A, 0x34); // "Fast Forward"
 507   addSIRC20Key("KEY_STOP", Stop_Key, 0x39, 0x1A, 0x38);
 508   addSIRC20Key("KEY_PAUSE", Pause_Key, 0x39, 0x1A, 0x39);
 509   addSIRC20Key("d_skip", NextDisc_Key, 0x39, 0x1A, 0x3E);
 510   addSIRC20Key("up", Up_Key, 0x39, 0x1A, 0x78);
 511   addSIRC20Key("down", Down_Key, 0x39, 0x1A, 0x79);
 512   addSIRC20Key("left", Left_Key, 0x39, 0x1A, 0x7A);
 513   addSIRC20Key("right", Right_Key, 0x39, 0x1A, 0x7B);
 514   addSIRC20Key("Select", Select_Key, 0x39, 0x1A, 0x7C);
 515 }
 516
 517
 518 SonyAudio1a::SonyAudio1a(
 519   unsigned int index)
 520   : SonyAudio1(index)
 521 {
 522   setKeysetName("Audio Keyset 1a");
 523 }
 524
 525
 526 void SonyAudio1a::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   SonyAudio1::populateProtocol(guiObject);
 536
 537   addSIRC12Key("tape", TapeInput_Key, 0x10, 0x23);
 538
 539 //  addSIRC20Key("select", Select_Key, 0x39, 0x1A, 0x32); // Doesn't make sense
 540   addSIRC20Key("play", Play_Key, 0x39, 0x1A, 0x32);
 541   addSIRC20Key("play_mode", Unmapped_Key, 0x39, 0x1A, 0x26);
 542   addSIRC20Key("enter", Select_Key, 0x39, 0x1A, 0x7C);
 543 }
 544
 545
 546 SonyDAT1::SonyDAT1(
 547   unsigned int index)
 548   : PIRKeysetMetaData(
 549       "DAT Keyset 1",
 550       Sony_Make,
 551       index)
 552 {
 553 }
 554
 555
 556 void SonyDAT1::populateProtocol(
 557   QObject *guiObject)
 558 {
 559   if (threadableProtocol)
 560   {
 561     // If the pointer is not null, the keyset must already be populated.
 562     return;
 563   }
 564
 565   threadableProtocol = new SIRCProtocol(guiObject, index);
 566
 567   setPostData(0x07, 5);
 568
 569   addSIRC12Key("1", One_Key, 0x1C, 0x00);
 570   addSIRC12Key("2", Two_Key, 0x1C, 0x01);
 571   addSIRC12Key("3", Three_Key, 0x1C, 0x02);
 572   addSIRC12Key("4", Four_Key, 0x1C, 0x03);
 573   addSIRC12Key("5", Five_Key, 0x1C, 0x04);
 574   addSIRC12Key("6", Six_Key, 0x1C, 0x05);
 575   addSIRC12Key("7", Seven_Key, 0x1C, 0x06);
 576   addSIRC12Key("8", Eight_Key, 0x1C, 0x07);
 577   addSIRC12Key("9", Nine_Key, 0x1C, 0x08);
 578   addSIRC12Key("0", Zero_Key, 0x1C, 0x14);
 579   addSIRC12Key("PLAY", Play_Key, 0x1C, 0x3A);
 580   addSIRC12Key("PAUSE", Pause_Key, 0x1C, 0x39);
 581   addSIRC12Key("STOP", Stop_Key, 0x1C, 0x38);
 582   addSIRC12Key("<<", Rewind_Key, 0x1C, 0x3B);
 583   addSIRC12Key(">>", FastForward_Key, 0x1C, 0x3C);
 584   addSIRC12Key("|<<", Previous_Key, 0x1C, 0x68);
 585   addSIRC12Key(">>|", Next_Key, 0x1C, 0x69);
 586   addSIRC12Key("RECORD", Record_Key, 0x1C, 0x3E);
 587   addSIRC12Key("Open/Close", Eject_Key, 0x1C, 0x20);
 588
 589   // The following commands are dubious:
 590   addSIRC12Key("VOL+", VolumeUp_Key, 0x1C, 0x12);
 591   addSIRC12Key("VOL-", VolumeDown_Key, 0x1C, 0x13);
 592   addSIRC12Key("POWER_ON", PowerOn_Key, 0x1C, 0x2E);
 593   addSIRC12Key("POWER_OFF", PowerOff_Key, 0x1C, 0x2F);
 594   addSIRC12Key("MUTE", Mute_Key, 0x1C, 0x14); // Makes no sense...
 595   addSIRC12Key("POWER", Power_Key, 0x1C, 0x15);
 596   addSIRC12Key("ENTER", Enter_Key, 0x1C, 0x0B);
 597 }
 598
 599
 600 SonyDVD1::SonyDVD1(
 601   unsigned int index)
 602   : PIRKeysetMetaData(
 603       "DVD Keyset 1",
 604       Sony_Make,
 605       index)
 606 {
 607   addControlledDevice(Sony_Make, "DVP-CX985V", DVD_Device);
 608   addControlledDevice(Sony_Make, "DVP-NS608P", DVD_Device);
 609 }
 610
 611
 612 void SonyDVD1::populateProtocol(
 613   QObject *guiObject)
 614 {
 615   if (threadableProtocol)
 616   {
 617     // If the pointer is not null, the keyset must already be populated.
 618     return;
 619   }
 620
 621   threadableProtocol = new SIRCProtocol(guiObject, index);
 622
 623   addSIRC20Key("1", One_Key, 0x49, 0x1A, 0x00);
 624   addSIRC20Key("2", Two_Key, 0x49, 0x1A, 0x01);
 625   addSIRC20Key("3", Three_Key, 0x49, 0x1A, 0x02);
 626   addSIRC20Key("4", Four_Key, 0x49, 0x1A, 0x03);
 627   addSIRC20Key("5", Five_Key, 0x49, 0x1A, 0x04);
 628   addSIRC20Key("6", Six_Key, 0x49, 0x1A, 0x05);
 629   addSIRC20Key("7", Seven_Key, 0x49, 0x1A, 0x06);
 630   addSIRC20Key("8", Eight_Key, 0x49, 0x1A, 0x07);
 631   addSIRC20Key("9", Nine_Key, 0x49, 0x1A, 0x08);
 632   addSIRC20Key("0", Zero_Key, 0x49, 0x1A, 0x09);
 633   addSIRC20Key("select", Select_Key, 0x49, 0x1A, 0x0B); //"Enter"
 634   addSIRC20Key("Disc Explorer", Unmapped_Key, 0x49, 0x1A, 0x0C);
 635   addSIRC20Key("Ent", Enter_Key, 0x49, 0x1A, 0x0D); // "Set"
 636   addSIRC20Key("return", Exit_Key, 0x49, 0x1A, 0x0E);
 637   addSIRC20Key("CLEAR", Clear_Key, 0x49, 0x1A, 0x0F);
 638   addSIRC20Key("-/--", DoubleDigit_Key, 0x49, 0x1A, 0x0F);
 639
 640   addSIRC20Key("Input", Input_Key, 0x49, 0x1A, 0x12);
 641   addSIRC20Key("prog+", ChannelUp_Key, 0x49, 0x1A, 0x13);
 642   addSIRC20Key("prog-", ChannelDown_Key, 0x49, 0x1A, 0x14);
 643   addSIRC20Key("power", Power_Key, 0x49, 0x1A, 0x15);
 644   addSIRC20Key("open/close", Eject_Key, 0x49, 0x1A, 0x16);
 645   addSIRC20Key("rec", Record_Key, 0x49, 0x1A, 0x19);
 646   addSIRC20Key("top_menu", DiscTitle_Key, 0x49, 0x1A, 0x1A); // "Title"
 647   addSIRC20Key("dvd_menu", DiscMenu_Key, 0x49, 0x1A, 0x1B);
 648   addSIRC20Key("program", Program_Key, 0x49, 0x1A, 0x1F);
 649   addSIRC20Key("step/search -", StepBack_Key, 0x49, 0x1A, 0x20);
 650   addSIRC20Key("step/search +", StepForward_Key, 0x49, 0x1A, 0x21);
 651   addSIRC20Key("scan/slow -", SlowMinus_Key, 0x49, 0x1A, 0x22);
 652   addSIRC20Key("scan/slow +", SlowPlus_Key, 0x49, 0x1A, 0x23);
 653   addSIRC20Key("INDEX-", Unmapped_Key, 0x49, 0x1A, 0x26);
 654   addSIRC20Key("INDEX+", Unmapped_Key, 0x49, 0x1A, 0x27);
 655   addSIRC20Key("TIME", Unmapped_Key, 0x49, 0x1A, 0x28);
 656   addSIRC20Key("JOG_STOP", Unmapped_Key, 0x49, 0x1A, 0x29); // "Pause"
 657   addSIRC20Key("a-b", RepeatAB_Key, 0x49, 0x1A, 0x2A);
 658   addSIRC20Key("repeat", Repeat_Key, 0x49, 0x1A, 0x2C);
 659   addSIRC20Key("POWER_ON", PowerOn_Key, 0x49, 0x1A, 0x2E);
 660   addSIRC20Key("POWER_OFF", PowerOff_Key, 0x49, 0x1A, 0x2F);
 661
 662   addSIRC20Key("prev", Previous_Key, 0x49, 0x1A, 0x30);
 663   addSIRC20Key("next", Next_Key, 0x49, 0x1A, 0x31);
 664   addSIRC20Key("play", Play_Key, 0x49, 0x1A, 0x32);
 665   addSIRC20Key("rew", Rewind_Key, 0x49, 0x1A, 0x33);
 666   addSIRC20Key("ffwd", FastForward_Key, 0x49, 0x1A, 0x34);
 667   addSIRC20Key("shuffle", Random_Key, 0x49, 0x1A, 0x35);
 668   addSIRC20Key("X2_BACK", Unmapped_Key, 0x49, 0x1A, 0x36);
 669   addSIRC20Key("X2_FORWARD", Unmapped_Key, 0x49, 0x1A, 0x37);
 670   addSIRC20Key("stop", Stop_Key, 0x49, 0x1A, 0x38);
 671   addSIRC20Key("pause", Pause_Key, 0x49, 0x1A, 0x39);
 672   addSIRC20Key("STEP_BACK", Unmapped_Key, 0x49, 0x1A, 0x3A); // "Jog Rev"
 673   addSIRC20Key("STEP_FORWARD", Unmapped_Key, 0x49, 0x1A, 0x3B); // "Jog Fwd"
 674   addSIRC20Key("RecStop", RecordStop_Key, 0x49, 0x1A, 0x3D);
 675   addSIRC20Key("RecPause", RecordPause_Key, 0x49, 0x1A, 0x3E);
 676
 677   addSIRC20Key("DNR", NoiseReduction_Key, 0x49, 0x1A, 0x48);
 678   addSIRC20Key("SEARCH_MODE", Unmapped_Key, 0x49, 0x1A, 0x4B);
 679   addSIRC20Key("Picture_Navi", Unmapped_Key, 0x49, 0x1A, 0x50);
 680   addSIRC20Key("TV_DVD", Unmapped_Key, 0x49, 0x1A, 0x51);
 681   addSIRC20Key("menu", Menu_Key, 0x49, 0x1A, 0x53); // "setup"
 682   addSIRC20Key("Display", Info_Key, 0x49, 0x1A, 0x54);
 683   addSIRC20Key("surround", Surround_Key, 0x49, 0x1A, 0x5A);
 684   addSIRC20Key("PICTUREMODE", PictureMode_Key, 0x49, 0x1A, 0x5B);
 685   addSIRC20Key("Replay", Replay_Key, 0x49, 0x1A, 0x5C);
 686   addSIRC20Key("SA-CD_MULTI/2CH", Unmapped_Key, 0x49, 0x1A, 0x5E);
 687   addSIRC20Key("SA-CD/CD", Unmapped_Key, 0x49, 0x1A, 0x5F);
 688
 689   addSIRC20Key("SLOW_BACK", SlowMinus_Key, 0x49, 0x1A, 0x60);
 690   addSIRC20Key("SLOW_FORWARD", SlowPlus_Key, 0x49, 0x1A, 0x61);
 691   addSIRC20Key("SUBTITLE_ON_OFF", Captions_Key, 0x49, 0x1A, 0x62);
 692   addSIRC20Key("Subtitle Change", Unmapped_Key, 0x49, 0x1A, 0x63);
 693   addSIRC20Key("Language", Audio_Key, 0x49, 0x1A, 0x64); // "Audio"
 694   addSIRC20Key("ANGLE_CHANGE", Angle_Key, 0x49, 0x1A, 0x65); // "Angle"
 695   addSIRC20Key("up", Up_Key, 0x49, 0x1A, 0x79);
 696   addSIRC20Key("down", Down_Key, 0x49, 0x1A, 0x7A);
 697   addSIRC20Key("left", Left_Key, 0x49, 0x1A, 0x7B);
 698   addSIRC20Key("right", Right_Key, 0x49, 0x1A, 0x7C);
 699
 700   addSIRC20Key("Advance", Advance_Key, 0x62, 0x1A, 0x14);
 701   addSIRC20Key("Guide", Guide_Key, 0x62, 0x1A, 0x16);
 702   addSIRC20Key("Options", Unmapped_Key, 0x62, 0x1A, 0x17); // "Tools"
 703   addSIRC20Key("Dot", Unmapped_Key, 0x62, 0x1A, 0x1D);
 704   addSIRC20Key("file", Unmapped_Key, 0x62, 0x1A, 0x20);
 705   addSIRC20Key("sort", Unmapped_Key, 0x62, 0x1A, 0x21);
 706   addSIRC20Key("edit", Unmapped_Key, 0x62, 0x1A, 0x22);
 707   addSIRC20Key("ALBUM-MINUS", Unmapped_Key, 0x62, 0x1A, 0x29);
 708   addSIRC20Key("ALBUM-PLUS", Unmapped_Key, 0x62, 0x1A, 0x2A);
 709   addSIRC20Key("F1", Unmapped_Key, 0x62, 0x1A, 0x2E); // "HDD"
 710   addSIRC20Key("F2", Unmapped_Key, 0x62, 0x1A, 0x2F); // "DVD"
 711   addSIRC20Key("picture memory", Unmapped_Key, 0x62, 0x1A, 0x3C);
 712   addSIRC20Key("disc skip -", PrevDisc_Key, 0x62, 0x1A, 0x3D);
 713   addSIRC20Key("DiscSkip", NextDisc_Key, 0x62, 0x1A, 0x3E); // "disc skip +"
 714   addSIRC20Key("folder", Unmapped_Key, 0x62, 0x1A, 0x40);
 715   addSIRC20Key("Favorites", Favorites_Key, 0x62, 0x1A, 0x5E);
 716   addSIRC20Key("Purple", Blue_Key, 0x62, 0x1A, 0x66);
 717   addSIRC20Key("Red", Red_Key, 0x62, 0x1A, 0x67);
 718   addSIRC20Key("Green", Green_Key, 0x62, 0x1A, 0x68);
 719   addSIRC20Key("Yellow", Yellow_Key, 0x62, 0x1A, 0x69);
 720   addSIRC20Key("ZOOM", Zoom_Key, 0x62, 0x1A, 0x79);
 721 }
 722
 723
 724 SonyDVD1a::SonyDVD1a(
 725   unsigned int index)
 726   : SonyDVD1(index)
 727 {
 728   setKeysetName("DVD Keyset 1a");
 729 }
 730
 731
 732 void SonyDVD1a::populateProtocol(
 733   QObject *guiObject)
 734 {
 735   if (threadableProtocol)
 736   {
 737     // If the pointer is not null, the keyset must already be populated.
 738     return;
 739   }
 740
 741   SonyDVD1::populateProtocol(guiObject);
 742
 743   addSIRC20Key("STEP_BACK", StepBack_Key, 0x49, 0x1A, 0x20);
 744   addSIRC20Key("STEP_FORWARD", StepForward_Key, 0x49, 0x1A, 0x21);
 745   addSIRC20Key("SLOW_BACK", SlowMinus_Key, 0x49, 0x1A, 0x22);
 746   addSIRC20Key("SLOW_FORWARD", SlowPlus_Key, 0x49, 0x1A, 0x23);
 747 }
 748
 749
 750 SonyDVD1b::SonyDVD1b(
 751   unsigned int index)
 752   : SonyDVD1(index)
 753 {
 754   setKeysetName("DVD Keyset 1b");
 755 }
 756
 757
 758 void SonyDVD1b::populateProtocol(
 759   QObject *guiObject)
 760 {
 761   if (threadableProtocol)
 762   {
 763     // If the pointer is not null, the keyset must already be populated.
 764     return;
 765   }
 766
 767   SonyDVD1::populateProtocol(guiObject);
 768
 769   addSIRC20Key("SLOW-", SlowMinus_Key, 0x49, 0x1A, 0x72);
 770   addSIRC20Key("SLOW+", SlowPlus_Key, 0x49, 0x1A, 0x73);
 771 }
 772
 773
 774 SonyDVD1c::SonyDVD1c(
 775   unsigned int index)
 776   : SonyDVD1(index)
 777 {
 778   setKeysetName("DVD Keyset 1c");
 779 }
 780
 781
 782 void SonyDVD1c::populateProtocol(
 783   QObject *guiObject)
 784 {
 785   if (threadableProtocol)
 786   {
 787     // If the pointer is not null, the keyset must already be populated.
 788     return;
 789   }
 790
 791   SonyDVD1::populateProtocol(guiObject);
 792
 793   addSIRC20Key("up", Up_Key, 0x49, 0x1A, 0x39);
 794   addSIRC20Key("down", Down_Key, 0x49, 0x1A, 0x38);
 795   addSIRC20Key("left", Left_Key, 0x49, 0x1A, 0x33);
 796   addSIRC20Key("right", Right_Key, 0x49, 0x1A, 0x34);
 797   addSIRC20Key("ok", Select_Key, 0x49, 0x1A, 0x32);
 798   addSIRC20Key("enter", Enter_Key, 0x49, 0x1A, 0x0B);
 799 }
 800
 801
 802 SonyDVD2::SonyDVD2(
 803   unsigned int index)
 804   : PIRKeysetMetaData(
 805       "DVD Keyset 2",
 806       Sony_Make,
 807       index)
 808 {
 809   addControlledDevice(Sony_Make, "RDR-GX360", DVD_Device);
 810 }
 811
 812
 813 void SonyDVD2::populateProtocol(
 814   QObject *guiObject)
 815 {
 816   if (threadableProtocol)
 817   {
 818     // Keyset already populated.
 819     return;
 820   }
 821
 822   threadableProtocol = new SIRCProtocol(guiObject, index);
 823
 824   addSIRC20Key("Title List", Unmapped_Key, 0x0B, 0x1A, 0x10);
 825   addSIRC20Key("Original playlist", Unmapped_Key, 0x0B, 0x1A, 0x11);
 826   addSIRC20Key("Thumbnail", Unmapped_Key, 0x0B, 0x1A, 0x12);
 827   addSIRC20Key("Chapter Mark", Unmapped_Key, 0x0B, 0x1A, 0x13);
 828   addSIRC20Key("Instant Advance", Advance_Key, 0x0B, 0x1A, 0x14);
 829   addSIRC20Key("Tools", Unmapped_Key, 0x0B, 0x1A, 0x17);
 830   addSIRC20Key("Cursor Mode", Unmapped_Key, 0x0B, 0x1A, 0x18);
 831   addSIRC20Key("Zoom -", Unmapped_Key, 0x0B, 0x1A, 0x19);
 832   addSIRC20Key("Mark Erase", Unmapped_Key, 0x0B, 0x1A, 0x1A);
 833   addSIRC20Key("Timer", Timer_Key, 0x0B, 0x1A, 0x1C);
 834   addSIRC20Key("Timer List", Unmapped_Key, 0x0B, 0x1A, 0x37);
 835   addSIRC20Key("Synchro Rec", Unmapped_Key, 0x0B, 0x1A, 0x77);
 836   addSIRC20Key("Zoom", Zoom_Key, 0x0B, 0x1A, 0x79); // "Zoom +"
 837
 838   addSIRC20Key("1", One_Key, 0xFA, 0x1A, 0x00);
 839   addSIRC20Key("2", Two_Key, 0xFA, 0x1A, 0x01);
 840   addSIRC20Key("3", Three_Key, 0xFA, 0x1A, 0x02);
 841   addSIRC20Key("4", Four_Key, 0xFA, 0x1A, 0x03);
 842   addSIRC20Key("5", Five_Key, 0xFA, 0x1A, 0x04);
 843   addSIRC20Key("6", Six_Key, 0xFA, 0x1A, 0x05);
 844   addSIRC20Key("7", Seven_Key, 0xFA, 0x1A, 0x06);
 845   addSIRC20Key("8", Eight_Key, 0xFA, 0x1A, 0x07);
 846   addSIRC20Key("9", Nine_Key, 0xFA, 0x1A, 0x08);
 847   addSIRC20Key("0", Zero_Key, 0xFA, 0x1A, 0x09);
 848   addSIRC20Key("Select", Select_Key, 0xFA, 0x1A, 0x0B);
 849   addSIRC20Key("Set", Unmapped_Key, 0xFA, 0x1A, 0x0D);
 850   addSIRC20Key("Return", Exit_Key, 0xFA, 0x1A, 0x0E);
 851   addSIRC20Key("Clear", Clear_Key, 0xFA, 0x1A, 0x0F);
 852   addSIRC20Key("Input Select", Input_Key, 0xFA, 0x1A, 0x12);
 853   addSIRC20Key("Channel +", ChannelUp_Key, 0xFA, 0x1A, 0x13);
 854   addSIRC20Key("Channel -", ChannelDown_Key, 0xFA, 0x1A, 0x14);
 855   addSIRC20Key("Power", Power_Key, 0xFA, 0x1A, 0x15);
 856   addSIRC20Key("Eject", Eject_Key, 0xFA, 0x1A, 0x16);
 857   addSIRC20Key("Record", Record_Key, 0xFA, 0x1A, 0x19);
 858   addSIRC20Key("Top Menu", DiscTitle_Key, 0xFA, 0x1A, 0x1A);
 859   addSIRC20Key("menu", DiscMenu_Key, 0xFA, 0x1A, 0x1B);
 860   addSIRC20Key("Rec Mode", Unmapped_Key, 0xFA, 0x1A, 0x1E);
 861   addSIRC20Key("Step Reverse", StepBack_Key, 0xFA, 0x1A, 0x20);
 862   addSIRC20Key("Step Fwd", StepForward_Key, 0xFA, 0x1A, 0x21);
 863   addSIRC20Key("Slow Forward", SlowPlus_Key, 0xFA, 0x1A, 0x23);
 864   addSIRC20Key("Time/Text", Unmapped_Key, 0xFA, 0x1A, 0x28);
 865   addSIRC20Key("Power On", PowerOn_Key, 0xFA, 0x1A, 0x2E);
 866   addSIRC20Key("Power Off", PowerOff_Key, 0xFA, 0x1A, 0x2F);
 867   addSIRC20Key("Track - (prev)", Previous_Key, 0xFA, 0x1A, 0x30);
 868   addSIRC20Key("Track + (next)", Next_Key, 0xFA, 0x1A, 0x31);
 869   addSIRC20Key("Play", Play_Key, 0xFA, 0x1A, 0x32);
 870   addSIRC20Key("rewind", Rewind_Key, 0xFA, 0x1A, 0x33);
 871   addSIRC20Key("Fast Forward", FastForward_Key, 0xFA, 0x1A, 0x34);
 872   addSIRC20Key("stop", Stop_Key, 0xFA, 0x1A, 0x38);
 873   addSIRC20Key("Pause", Pause_Key, 0xFA, 0x1A, 0x39);
 874   addSIRC20Key("Record Stop", RecordStop_Key, 0xFA, 0x1A, 0x3D);
 875   addSIRC20Key("Record Pause", RecordPause_Key, 0xFA, 0x1A, 0x3E);
 876   addSIRC20Key("System Menu", Menu_Key, 0xFA, 0x1A, 0x53);
 877   addSIRC20Key("Display", Info_Key, 0xFA, 0x1A, 0x54);
 878   addSIRC20Key("Surround", Surround_Key, 0xFA, 0x1A, 0x5A);
 879   addSIRC20Key("Instant Replay", Replay_Key, 0xFA, 0x1A, 0x5C);
 880   addSIRC20Key("Subtitle", Captions_Key, 0xFA, 0x1A, 0x63);
 881   addSIRC20Key("Audio", Audio_Key, 0xFA, 0x1A, 0x64);
 882   addSIRC20Key("angle", Angle_Key, 0xFA, 0x1A, 0x65);
 883   addSIRC20Key("Up", Up_Key, 0xFA, 0x1A, 0x79);
 884   addSIRC20Key("Down", Down_Key, 0xFA, 0x1A, 0x7A);
 885   addSIRC20Key("Left", Left_Key, 0xFA, 0x1A, 0x7B);
 886   addSIRC20Key("Right", Right_Key, 0xFA, 0x1A, 0x7C);
 887 }
 888
 889
 890 SonyDVD2a::SonyDVD2a(
 891   unsigned int index)
 892   : SonyDVD2(index)
 893 {
 894   setKeysetName("DVD Keyset 2a");
 895
 896   addControlledDevice(Sony_Make, "RDR-GX257", DVD_Device);
 897 }
 898
 899
 900 void SonyDVD2a::populateProtocol(
 901   QObject *guiObject)
 902 {
 903   if (threadableProtocol)
 904   {
 905     // Keyset already populated.
 906     return;
 907   }
 908
 909   SonyDVD2::populateProtocol(guiObject);
 910
 911   addSIRC20Key("top menu / title List", DiscTitle_Key, 0x0B, 0x1A, 0x10);
 912   addSIRC20Key("marker", Unmapped_Key, 0x0B, 0x1A, 0x34);
 913   addSIRC20Key("search", Unmapped_Key, 0x0B, 0x1A, 0x35);
 914
 915   addSIRC20Key("discrete off", PowerOff_Key, 0xFA, 0x1A, 0x29);
 916   addSIRC20Key("play mode", Unmapped_Key, 0xFA, 0x1A, 0x31);
 917 }
 918
 919
 920 SonyVCR1::SonyVCR1(
 921   unsigned int index)
 922   : PIRKeysetMetaData(
 923       "VCR Keyset 1",
 924       Sony_Make,
 925       index)
 926 {
 927 }
 928
 929
 930 void SonyVCR1::populateProtocol(
 931   QObject *guiObject)
 932 {
 933   if (threadableProtocol)
 934   {
 935     // If the pointer is not null, the keyset must already be populated.
 936     return;
 937   }
 938
 939   threadableProtocol = new SIRCProtocol(guiObject, index);
 940
 941   addSIRC12Key("VOL_UP", VolumeUp_Key, 0x01, 0x12);
 942   addSIRC12Key("VOL_DOWN", VolumeDown_Key, 0x01, 0x13);
 943
 944   addSIRC12Key("red", Red_Key, 0x03, 0x4C);
 945   addSIRC12Key("green", Green_Key, 0x03, 0x4D);
 946   addSIRC12Key("Yellow", Yellow_Key, 0x03, 0x4E);
 947   addSIRC12Key("blue", Blue_Key, 0x03, 0x4F);
 948
 949   addSIRC12Key("1", One_Key, 0x0B, 0x00);
 950   addSIRC12Key("2", Two_Key, 0x0B, 0x01);
 951   addSIRC12Key("3", Three_Key, 0x0B, 0x02);
 952   addSIRC12Key("4", Four_Key, 0x0B, 0x03);
 953   addSIRC12Key("5", Five_Key, 0x0B, 0x04);
 954   addSIRC12Key("6", Six_Key, 0x0B, 0x05);
 955   addSIRC12Key("7", Seven_Key, 0x0B, 0x06);
 956   addSIRC12Key("8", Eight_Key, 0x0B, 0x07);
 957   addSIRC12Key("9", Nine_Key, 0x0B, 0x08);
 958   addSIRC12Key("0", Zero_Key, 0x0B, 0x09);
 959 //  addSIRC12Key("jump", PrevChannel_Key, 0x0B, 0x0A); // might be wrong
 960   addSIRC12Key("-/--", DoubleDigit_Key, 0x0B, 0x0A);
 961   addSIRC12Key("ENT", Enter_Key, 0x0B, 0x0B); // "Enter"
 962
 963   addSIRC12Key("prog-next", ChannelUp_Key, 0x0B, 0x10);
 964   addSIRC12Key("prog-prev", ChannelDown_Key, 0x0B, 0x11);
 965   addSIRC12Key("pwon", Power_Key, 0x0B, 0x15);
 966   addSIRC12Key("stop", Stop_Key, 0x0B, 0x18);
 967   addSIRC12Key("pause", Pause_Key, 0x0B, 0x19);
 968   addSIRC12Key("play", Play_Key, 0x0B, 0x1A);
 969   addSIRC12Key("<<", Rewind_Key, 0x0B, 0x1B);
 970   addSIRC12Key(">>", FastForward_Key, 0x0B, 0x1C);
 971   addSIRC12Key("rec", Record_Key, 0x0B, 0x1D);
 972   addSIRC12Key("ant/sw", AntennaInput_Key, 0x0B, 0x2A);  // "tv/vcr"
 973   addSIRC12Key("power_on", PowerOn_Key, 0x0B, 0x2E);
 974   addSIRC12Key("Power Off", PowerOff_Key, 0x0B, 0x2F);
 975   addSIRC12Key("menu", Menu_Key, 0x0B, 0x4D);
 976   addSIRC12Key("input", Input_Key, 0x0B, 0x4F);
 977   addSIRC12Key("display", Info_Key, 0x0B, 0x5A);
 978
 979   // Odd cursor keys, overlap with media controls:
 980   addSIRC12Key("down", Down_Key, 0x0B, 0x18);
 981   addSIRC12Key("up", Up_Key, 0x0B, 0x19);
 982   addSIRC12Key("ok", Select_Key, 0x0B, 0x1A);
 983   addSIRC12Key("left", Left_Key, 0x0B, 0x1B);
 984   addSIRC12Key("right", Right_Key, 0x0B, 0x1C);
 985 }
 986
 987
 988 SonyVCR1a::SonyVCR1a(
 989   unsigned int index)
 990   : SonyVCR1(index)
 991 {
 992   setKeysetName("VCR Keyset 1a");
 993 }
 994
 995
 996 void SonyVCR1a::populateProtocol(
 997   QObject *guiObject)
 998 {
 999   if (threadableProtocol)
1000   {
1001     // If the pointer is not null, the keyset must already be populated.
1002     return;
1003   }
1004
1005   SonyVCR1::populateProtocol(guiObject);
1006
1007   // These are the expected cursor keys:
1008   addSIRC12Key("up", Up_Key, 0x0B, 0x42);
1009   addSIRC12Key("down", Down_Key, 0x0B, 0x43);
1010   addSIRC12Key("left", Left_Key, 0x0B, 0x62);
1011   addSIRC12Key("right", Right_Key, 0x0B, 0x61);
1012   addSIRC12Key("execute", Select_Key, 0x0B, 0x51); //"OK"
1013
1014 //  addKey("SLEEP", Sleep_Key, 0x0B, 0x4F); // odd
1015 }
1016
1017
1018 // Extra codes off of hifi-remote website:
1019 SonyVCR1b::SonyVCR1b(
1020   unsigned int index)
1021   : SonyVCR1a(index)
1022 {
1023   setKeysetName("VCR Keyset 1b");
1024 }
1025
1026
1027 void SonyVCR1b::populateProtocol(
1028   QObject *guiObject)
1029 {
1030   if (threadableProtocol)
1031   {
1032     // If the pointer is not null, the keyset must already be populated.
1033     return;
1034   }
1035
1036   SonyVCR1a::populateProtocol(guiObject);
1037
1038   addSIRC12Key("Volume Up", VolumeUp_Key, 0x0B, 0x12);
1039   addSIRC12Key("Volume Down", VolumeDown_Key, 0x0B, 0x13);
1040   addSIRC12Key("Eject", Eject_Key, 0x0B, 0x16);
1041   addSIRC12Key("Record Pause", RecordPause_Key, 0x0B, 0x1E);
1042   addSIRC12Key("Record Mute", RecordMute_Key, 0x0B, 0x1F);
1043   addSIRC12Key("Auto Tracking", AutoTracking_Key, 0x0B, 0x27);
1044   addSIRC12Key("Frame Reverse", StepBack_Key, 0x0B, 0x30);
1045   addSIRC12Key("Frame Advance", StepForward_Key, 0x0B, 0x31);
1046   addSIRC12Key("Mute", Mute_Key, 0x0B, 0x35);
1047   addSIRC12Key("Sleep", Sleep_Key, 0x0B, 0x36);
1048   addSIRC12Key("Slow +", SlowPlus_Key, 0x0B, 0x3D);
1049   addSIRC12Key("Slow -", SlowMinus_Key, 0x0B, 0x3E);
1050   addSIRC12Key("Tracking Up", TrackingPlus_Key, 0x0B, 0x44);
1051   addSIRC12Key("Tracking Down", TrackingMinus_Key, 0x0B, 0x45);
1052   addSIRC12Key("SP/EP", VHSSpeed_Key, 0x0B, 0x58);
1053 }
1054
1055
1056 SonyReceiver1::SonyReceiver1(
1057   unsigned int index)
1058   : PIRKeysetMetaData(
1059       "Receiver Keyset 1",
1060       Sony_Make,
1061       index)
1062 {
1063 }
1064
1065
1066 void SonyReceiver1::populateProtocol(
1067   QObject *guiObject)
1068 {
1069   if (threadableProtocol)
1070   {
1071     // If the pointer is not null, the keyset must already be populated.
1072     return;
1073   }
1074
1075   threadableProtocol = new SIRCProtocol(guiObject, index);
1076
1077   addSIRC15Key("1", One_Key, 0x30, 0x00);
1078   addSIRC15Key("2", Two_Key, 0x30, 0x01);
1079   addSIRC15Key("3", Three_Key, 0x30, 0x02);
1080   addSIRC15Key("4", Four_Key, 0x30, 0x03);
1081   addSIRC15Key("5", Five_Key, 0x30, 0x04);
1082   addSIRC15Key("6", Six_Key, 0x30, 0x05);
1083   addSIRC15Key("7", Seven_Key, 0x30, 0x06);
1084   addSIRC15Key("8", Eight_Key, 0x30, 0x07);
1085   addSIRC15Key("9", Nine_Key, 0x30, 0x08);
1086   addSIRC15Key("0", Zero_Key, 0x30, 0x09);
1087   addSIRC15Key("SELECT", Select_Key, 0x30, 0x0C);
1088   addSIRC15Key("VOLUME_UP", VolumeUp_Key, 0x30, 0x12);
1089   addSIRC15Key("VOLUME_DOWN", VolumeDown_Key, 0x30, 0x13);
1090   addSIRC15Key("MUTING", Mute_Key, 0x30, 0x14);
1091   addSIRC15Key("POWER", Power_Key, 0x30, 0x15);
1092   addSIRC15Key("VIDEO2", Unmapped_Key, 0x30, 0x1E);
1093   addSIRC15Key("TUNER", TunerInput_Key, 0x30, 0x21);
1094   addSIRC15Key("VIDEO1", Unmapped_Key, 0x30, 0x22);
1095   addSIRC15Key("SA_CD", Unmapped_Key, 0x30, 0x25);
1096   addSIRC15Key("VIDEO3", Unmapped_Key, 0x30, 0x42);
1097   addSIRC15Key("DISPLAY", Info_Key, 0x30, 0x4B);
1098   addSIRC15Key("SLEEP", Sleep_Key, 0x30, 0x60);
1099   addSIRC15Key("TV", Unmapped_Key, 0x30, 0x6A);
1100   addSIRC15Key("DVD", DVDInput_Key, 0x30, 0x7D);
1101
1102   addSIRC15Key("SAT", SatInput_Key, 0xB0, 0x03);
1103   addSIRC15Key("2CH", Unmapped_Key, 0xB0, 0x09);
1104   addSIRC15Key("AFD", Unmapped_Key, 0xB0, 0x0A);
1105   addSIRC15Key("MOVIE", Unmapped_Key, 0xB0, 0x0B);
1106   addSIRC15Key("DVD_MENU", DiscMenu_Key, 0xB0, 0x2D); // Not sure about this
1107   addSIRC15Key("MUSIC", Unmapped_Key, 0xB0, 0x49);
1108   addSIRC15Key("AMP_MENU", Menu_Key, 0xB0, 0x77);
1109   addSIRC15Key("UP", Up_Key, 0xB0, 0x78);
1110   addSIRC15Key("DOWN", Down_Key, 0xB0, 0x79);
1111   addSIRC15Key("LEFT", Left_Key, 0xB0, 0x7A);
1112   addSIRC15Key("RIGHT", Right_Key, 0xB0, 0x7B);
1113 }
1114
1115
1116 SonyCD1::SonyCD1(
1117   unsigned int index)
1118   : PIRKeysetMetaData(
1119       "CD Keyset 1",
1120       Sony_Make,
1121       index)
1122 {
1123 }
1124
1125
1126 void SonyCD1::populateProtocol(
1127   QObject *guiObject)
1128 {
1129   if (threadableProtocol)
1130   {
1131     // Keyset already populated.
1132     return;
1133   }
1134
1135   threadableProtocol = new SIRCProtocol(guiObject, index);
1136
1137   addSIRC12Key("1", One_Key, 0x11, 0x00);
1138   addSIRC12Key("2", Two_Key, 0x11, 0x01);
1139   addSIRC12Key("3", Three_Key, 0x11, 0x02);
1140   addSIRC12Key("4", Four_Key, 0x11, 0x03);
1141   addSIRC12Key("5", Five_Key, 0x11, 0x04);
1142   addSIRC12Key("6", Six_Key, 0x11, 0x05);
1143   addSIRC12Key("7", Seven_Key, 0x11, 0x06);
1144   addSIRC12Key("8", Eight_Key, 0x11, 0x07);
1145   addSIRC12Key("9", Nine_Key, 0x11, 0x08);
1146   addSIRC12Key("ENTER", Enter_Key, 0x11, 0x0B);
1147   addSIRC12Key("check", Unmapped_Key, 0x11, 0x0D);
1148   addSIRC12Key("clear", Clear_Key, 0x11, 0x0F);
1149
1150   addSIRC12Key("vol+", VolumeUp_Key, 0x11, 0x12);
1151   addSIRC12Key("vol-", VolumeDown_Key, 0x11, 0x13);
1152   addSIRC12Key("mute", Mute_Key, 0x11, 0x14);
1153   addSIRC12Key("power", Power_Key, 0x11, 0x15);
1154   addSIRC12Key("eject", Eject_Key, 0x11, 0x16);
1155   addSIRC12Key("C.INDEX", Unmapped_Key, 0x11, 0x18);
1156   addSIRC12Key("FILE", Memory_Key, 0x11, 0x19);
1157   addSIRC12Key("BANK", Call_Key, 0x11, 0x1A); // "file recall"
1158   addSIRC12Key("continue", Unmapped_Key, 0x11, 0x1D);
1159   addSIRC12Key("single", Unmapped_Key, 0x11, 0x1E);
1160   addSIRC12Key("pgm", Program_Key, 0x11, 0x1F);
1161
1162   addSIRC12Key("10", Zero_Key, 0x11, 0x20); // "0"
1163   addSIRC12Key(">10", DoubleDigit_Key, 0x11, 0x27);
1164   addSIRC12Key("DISPLAY", Info_Key, 0x11, 0x28); // "time"
1165   addSIRC12Key("a-b", RepeatAB_Key, 0x11, 0x2A);
1166   addSIRC12Key("repeat", Repeat_Key, 0x11, 0x2C);
1167   addSIRC12Key("POWER_ON", PowerOn_Key, 0x11, 0x2E);
1168   addSIRC12Key("POWER_OFF", PowerOff_Key, 0x11, 0x2F);
1169
1170   addSIRC12Key("|<<", Previous_Key, 0x11, 0x30);
1171   addSIRC12Key(">>|", Next_Key, 0x11, 0x31);
1172   addSIRC12Key("play", Play_Key, 0x11, 0x32);
1173   addSIRC12Key("<<", Rewind_Key, 0x11, 0x33);
1174   addSIRC12Key(">>", FastForward_Key, 0x11, 0x34);
1175   addSIRC12Key("shuffle", Random_Key, 0x11, 0x35);
1176   addSIRC12Key("cd_ind_dec", Unmapped_Key, 0x11, 0x36);
1177   addSIRC12Key("cd_ind_inc", Unmapped_Key, 0x11, 0x37);
1178   addSIRC12Key("stop", Stop_Key, 0x11, 0x38);
1179   addSIRC12Key("PAUSE", Pause_Key, 0x11, 0x39);
1180   addSIRC12Key("SLOW--", SlowMinus_Key, 0x11, 0x3A);
1181   addSIRC12Key("SLOW++", SlowPlus_Key, 0x11, 0x3B);
1182   addSIRC12Key("musicscan", Unmapped_Key, 0x11, 0x3C); // "intro"
1183   addSIRC12Key("prevDisc", PrevDisc_Key, 0x11, 0x3D);
1184   addSIRC12Key("disc_skip", NextDisc_Key, 0x11, 0x3E);
1185
1186   addSIRC12Key("disc_1", Unmapped_Key, 0x11, 0x40);
1187   addSIRC12Key("disc_2", Unmapped_Key, 0x11, 0x41);
1188   addSIRC12Key("disc_3", Unmapped_Key, 0x11, 0x42);
1189   addSIRC12Key("disc_4", Unmapped_Key, 0x11, 0x43);
1190   addSIRC12Key("disc_5", Unmapped_Key, 0x11, 0x44);
1191   addSIRC12Key("DISC", Unmapped_Key, 0x11, 0x4A);
1192   addSIRC12Key("AUTO_SPACE", Unmapped_Key, 0x11, 0x4E);
1193
1194   addSIRC12Key("fader", Unmapped_Key, 0x11, 0x5F); // "mute"
1195
1196   addSIRC12Key("LEVEL_FILE", Unmapped_Key, 0x11, 0x68);
1197 }
1198
1199
1200 SonyCD1a::SonyCD1a(
1201   unsigned int index)
1202   : SonyCD1(index)
1203 {
1204   setKeysetName("CD Keyset 1a");
1205 }
1206
1207
1208 void SonyCD1a::populateProtocol(
1209   QObject *guiObject)
1210 {
1211   if (threadableProtocol)
1212   {
1213     // Keyset already populated.
1214     return;
1215   }
1216
1217   SonyCD1::populateProtocol(guiObject);
1218
1219   addSIRC12Key("a-b", RepeatAB_Key, 0x11, 0x2D);
1220 }
1221
1222
1223 SonyCD1b::SonyCD1b(
1224   unsigned int index)
1225   : SonyCD1(index)
1226 {
1227   setKeysetName("CD Keyset 1b");
1228 }
1229
1230
1231 void SonyCD1b::populateProtocol(
1232   QObject *guiObject)
1233 {
1234   if (threadableProtocol)
1235   {
1236     // Keyset already populated.
1237     return;
1238   }
1239
1240   SonyCD1::populateProtocol(guiObject);
1241
1242   addSIRC12Key("display", Info_Key, 0x11, 0x56);
1243 }
1244
1245
1246 SonyProjector1::SonyProjector1(
1247   unsigned int index)
1248   : PIRKeysetMetaData(
1249       "Projector Keyset 1",
1250       Sony_Make,
1251       index)
1252 {
1253   addControlledDevice(Sony_Make, "RM-1271", Other_Device);
1254   addControlledDevice(Sony_Make, "VPL-SC50", Other_Device);
1255   addControlledDevice(Sony_Make, "VPL-HS10", Other_Device);
1256   addControlledDevice(Sony_Make, "VPL-HS20", Other_Device);
1257   addControlledDevice(Sony_Make, "VH11HT", Other_Device);
1258 }
1259
1260
1261 void SonyProjector1::populateProtocol(
1262   QObject *guiObject)
1263 {
1264   if (threadableProtocol)
1265   {
1266     // Keyset already populated.
1267     return;
1268   }
1269
1270   threadableProtocol = new SIRCProtocol(guiObject, index);
1271
1272   addSIRC15Key("Switcher 1", Unmapped_Key, 0x54, 0x0A);
1273   addSIRC15Key("Switcher 2", Unmapped_Key, 0x54, 0x0B);
1274   addSIRC15Key("Switcher 3", Unmapped_Key, 0x54, 0x0C);
1275   addSIRC15Key("Switcher 4", Unmapped_Key, 0x54, 0x0D);
1276   addSIRC15Key("Switcher 5", Unmapped_Key, 0x54, 0x0E);
1277   addSIRC15Key("Switcher 6", Unmapped_Key, 0x54, 0x0F);
1278   addSIRC15Key("Switcher 7", Unmapped_Key, 0x54, 0x10);
1279   addSIRC15Key("Switcher 8", Unmapped_Key, 0x54, 0x11);
1280   addSIRC15Key("vol up", VolumeUp_Key, 0x54, 0x12);
1281   addSIRC15Key("vol down", VolumeDown_Key, 0x54, 0x13);
1282   addSIRC15Key("mute", Mute_Key, 0x54, 0x14);
1283   addSIRC15Key("power", Power_Key, 0x54, 0x15);
1284   addSIRC15Key("Contrast+", ContrastUp_Key, 0x54, 0x18);
1285   addSIRC15Key("Contrast-", ContrastDown_Key, 0x54, 0x19);
1286   addSIRC15Key("Color+", ColorUp_Key, 0x54, 0x1A);
1287   addSIRC15Key("Color-", ColorDown_Key, 0x54, 0x1B);
1288   addSIRC15Key("Brightness+", BrightnessUp_Key, 0x54, 0x1E);
1289   addSIRC15Key("Brightness-", BrightnessDown_Key, 0x54, 0x1F);
1290   addSIRC15Key("Hue+", Unmapped_Key, 0x54, 0x20);
1291   addSIRC15Key("Hue-", Unmapped_Key, 0x54, 0x21);
1292   addSIRC15Key("Sharpness+", Unmapped_Key, 0x54, 0x22);
1293   addSIRC15Key("Sharpness-", Unmapped_Key, 0x54, 0x23);
1294   addSIRC15Key("Pic Mute", Unmapped_Key, 0x54, 0x24);
1295   addSIRC15Key("Status ON", Unmapped_Key, 0x54, 0x25);
1296   addSIRC15Key("Status OFF", Unmapped_Key, 0x54, 0x26);
1297   addSIRC15Key("Secam", Unmapped_Key, 0x54, 0x27);
1298   addSIRC15Key("Clear Blue", Unmapped_Key, 0x54, 0x28);
1299   addSIRC15Key("menu", Menu_Key, 0x54, 0x29);
1300   addSIRC15Key("video 1 input", CompositeInput_Key, 0x54, 0x2A);
1301   addSIRC15Key("Input A", AuxInput_Key, 0x54, 0x2B);
1302   addSIRC15Key("video 2 input", Composite2Input_Key, 0x54, 0x2C);
1303   addSIRC15Key("power on", PowerOn_Key, 0x54, 0x2E);
1304   addSIRC15Key("power off", PowerOff_Key, 0x54, 0x2F);
1305   addSIRC15Key("Position +", Unmapped_Key, 0x54, 0x31);
1306   addSIRC15Key("Position -", Unmapped_Key, 0x54, 0x32);
1307   addSIRC15Key("right arrow", Right_Key, 0x54, 0x33);
1308   addSIRC15Key("left arrow", Left_Key, 0x54, 0x34);
1309   addSIRC15Key("up arrow", Up_Key, 0x54, 0x35);
1310   addSIRC15Key("down arrow", Down_Key, 0x54, 0x36);
1311   addSIRC15Key("Adjust Red", Unmapped_Key, 0x54, 0x41);
1312   addSIRC15Key("Adjust Green", Unmapped_Key, 0x54, 0x42);
1313   addSIRC15Key("Adjust Blue", Unmapped_Key, 0x54, 0x43);
1314   addSIRC15Key("Cutoff Red", Unmapped_Key, 0x54, 0x44);
1315   addSIRC15Key("Cutoff Green", Unmapped_Key, 0x54, 0x45);
1316   addSIRC15Key("Cutoff Blue", Unmapped_Key, 0x54, 0x46);
1317   addSIRC15Key("H Size", Unmapped_Key, 0x54, 0x47);
1318   addSIRC15Key("Shift", Unmapped_Key, 0x54, 0x48);
1319   addSIRC15Key("Center Red", Unmapped_Key, 0x54, 0x49);
1320   addSIRC15Key("Center Green", Unmapped_Key, 0x54, 0x4A);
1321   addSIRC15Key("Center Blue", Unmapped_Key, 0x54, 0x4B);
1322   addSIRC15Key("Size", Unmapped_Key, 0x54, 0x4C);
1323   addSIRC15Key("Linearity", Unmapped_Key, 0x54, 0x4D);
1324   addSIRC15Key("Skew", Unmapped_Key, 0x54, 0x4E);
1325   addSIRC15Key("Bow", Unmapped_Key, 0x54, 0x4F);
1326   addSIRC15Key("Keystone", Unmapped_Key, 0x54, 0x50);
1327   addSIRC15Key("Pin Cushion", Unmapped_Key, 0x54, 0x51);
1328   addSIRC15Key("Gain", Unmapped_Key, 0x54, 0x52);
1329   addSIRC15Key("Bias", Unmapped_Key, 0x54, 0x53);
1330   addSIRC15Key("Zone", Unmapped_Key, 0x54, 0x56);
1331   addSIRC15Key("tv/vcr", Input_Key, 0x54, 0x57);
1332   addSIRC15Key("Blanking", Unmapped_Key, 0x54, 0x58);
1333   addSIRC15Key("select", Select_Key, 0x54, 0x5A);
1334   addSIRC15Key("Enter", Unmapped_Key, 0x54, 0x5E);
1335   addSIRC15Key("Svideo 1", SVideoInput_Key, 0x54, 0x5F);
1336   addSIRC15Key("Index Second / 0 (All)", Unmapped_Key, 0x54, 0x60);
1337   addSIRC15Key("Index 1", Unmapped_Key, 0x54, 0x61);
1338   addSIRC15Key("Index 2", Unmapped_Key, 0x54, 0x62);
1339   addSIRC15Key("Index 3", Unmapped_Key, 0x54, 0x63);
1340   addSIRC15Key("Index 4", Unmapped_Key, 0x54, 0x64);
1341   addSIRC15Key("Index 5", Unmapped_Key, 0x54, 0x65);
1342   addSIRC15Key("Index 6", Unmapped_Key, 0x54, 0x66);
1343   addSIRC15Key("Index 7", Unmapped_Key, 0x54, 0x67);
1344   addSIRC15Key("Index 8", Unmapped_Key, 0x54, 0x68);
1345   addSIRC15Key("Index 9", Unmapped_Key, 0x54, 0x69);
1346   addSIRC15Key("Svideo 2", SVideo2Input_Key, 0x54, 0x6F);
1347   addSIRC15Key("Component Input", ComponentInput_Key, 0x54, 0x70);
1348   addSIRC15Key("Focus+", Unmapped_Key, 0x54, 0x74);
1349   addSIRC15Key("Focus-", Unmapped_Key, 0x54, 0x75);
1350   addSIRC15Key("Zoom+", Unmapped_Key, 0x54, 0x77);
1351   addSIRC15Key("Zoom-", Unmapped_Key, 0x54, 0x78);
1352   addSIRC15Key("reset", Reset_Key, 0x54, 0x7B);
1353   addSIRC15Key("Right and Left Arrows", Unmapped_Key, 0x54, 0x7C);
1354   addSIRC15Key("Normal", Unmapped_Key, 0x54, 0x7D);
1355   addSIRC15Key("Test", Unmapped_Key, 0x54, 0x7E);
1356
1357   addSIRC20Key("ms slide", Unmapped_Key, 0x2A, 0x1A, 0x3C);
1358   addSIRC20Key("side shot +", Unmapped_Key, 0x2A, 0x1A, 0x3E); //"Keystone+"
1359   addSIRC20Key("side shot -", Unmapped_Key, 0x2A, 0x1A, 0x3F); //"Keystone-"
1360   addSIRC20Key("dynamic", One_Key, 0x2A, 0x1A, 0x51);
1361   addSIRC20Key("standard", Two_Key, 0x2A, 0x1A, 0x52);
1362   addSIRC20Key("cinema", Three_Key, 0x2A, 0x1A, 0x53);
1363   addSIRC20Key("user 1", Four_Key, 0x2A, 0x1A, 0x54);
1364   addSIRC20Key("user 2", Five_Key, 0x2A, 0x1A, 0x55);
1365   addSIRC20Key("user 3", Six_Key, 0x2A, 0x1A, 0x56);
1366   addSIRC20Key("apa", Unmapped_Key, 0x2A, 0x1A, 0x60);
1367   addSIRC20Key("wide mode", AspectRatio_Key, 0x2A, 0x1A, 0x6E);
1368   addSIRC20Key("lens", Unmapped_Key, 0x2A, 0x1A, 0x78);
1369 }
1370
1371
1372 SonyProjector1a::SonyProjector1a(
1373   unsigned int index)
1374   : SonyProjector1(index)
1375 {
1376   setKeysetName("Projector Keyset 1a");
1377
1378   addControlledDevice(Sony_Make, "VPL-VH11HT", Other_Device);
1379 }
1380
1381
1382 void SonyProjector1a::populateProtocol(
1383   QObject *guiObject)
1384 {
1385   if (threadableProtocol)
1386   {
1387     // Keyset already populated.
1388     return;
1389   }
1390
1391   SonyProjector1::populateProtocol(guiObject);
1392
1393   addSIRC15Key("input toggle", Input_Key, 0x54, 0x2C);
1394   addSIRC15Key("shift-left", Unmapped_Key, 0x54, 0x2F);
1395 }