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

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