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