Log In
New Account
  
Home My Page Project Cloud Code Snippets Project Openings Pierogi
Summary Forums Tracker Lists Tasks Docs News SCM Files
authorJohn Pietrzak <john@pietrzak.org>
Mon, 23 Jan 2012 14:59:52 +0000 (09:59 -0500)
committerJohn Pietrzak <john@pietrzak.org>
Mon, 23 Jan 2012 14:59:52 +0000 (09:59 -0500)
I'm still trying to get install to do what I want, but it still either
doesn't remove pierogi.sudoers when it should, or does remove it when it
shouldn't.  For now, I'll have to ask users to clean up that file manually
on uninstall. :(  In other news, some cleanup work on the keysets, along
with a few new keysets (Denon, Hitachi, Pinnacle).

50 files changed:
doc/documentation.html
keysets/apple.cpp
keysets/denon.cpp [new file with mode: 0644]
keysets/denon.h [new file with mode: 0644]
keysets/ei.cpp
keysets/goldstar.cpp
keysets/hauppauge.cpp
keysets/hauppauge.h
keysets/hitachi.cpp [new file with mode: 0644]
keysets/hitachi.h [new file with mode: 0644]
keysets/jvc.cpp
keysets/lg.cpp
keysets/mitsubishi.cpp
keysets/nokia.cpp
keysets/panasonic.cpp
keysets/pinnacle.cpp [new file with mode: 0644]
keysets/pinnacle.h [new file with mode: 0644]
keysets/raite.cpp
keysets/rca.cpp
keysets/sagem.cpp
keysets/samsung.cpp
keysets/sanyo.cpp
keysets/sanyo.h
keysets/sharp.cpp
keysets/sony.cpp
keysets/toshiba.cpp
keysets/westinghouse.cpp
keysets/yamaha.cpp
keysets/zenith.cpp
necprotocol.cpp
necprotocol.h
pierogi.pro
pierogi.pro.user
pirdevicetypenames.cpp
pirdevicetypenames.h
pirkeynames.h
pirkeysetmanager.cpp
pirkeysetmetadata.cpp
pirkeysetmetadata.h
pirmakenames.cpp
pirmakenames.h
pirprotocol.cpp
pirprotocol.h
pirselectkeysetform.ui
qtc_packaging/debian_fremantle/changelog
qtc_packaging/debian_fremantle/postrm [deleted file]
qtc_packaging/debian_fremantle/postrm.needsfixing [new file with mode: 0644]
rc5protocol.cpp
rc5protocol.h
www/index.html

index b23e657..0bdf9f2 100644 (file)
@@ -88,9 +88,9 @@ targeted towards entering other useful menus when available.</p>
 <h3>Media Tab</h3>
 
 <p>Many of the most important playback commands are represented on this tab.
-Play, pause, and stop are the most common ones, along with "Reverse" (often
-called "Rewind") and Fast Forward.  A variety of other less common navigation
-controls are included, along with the "eject" command.</p>
+"Play", "Pause", and "Stop" are the most common ones, along with "Reverse"
+(often called rewind) and "Fast Forward".  A variety of other less common
+navigation controls are included, along with the "Eject" command.</p>
 
 <h3>Misc Tab</h3>
 
index 143de54..c7aa9c2 100644 (file)
@@ -14,24 +14,10 @@ AppleWhiteRemote::AppleWhiteRemote(
   addControlledDevice(Apple_Make, "Mac Mini", Computer_Device);
 
   // Set up the threadable object:
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    574, 547,   // zero pulse, zero space
-    574, 1668,  // one pulse, one space
-    37600,      // gap
-    false);     // gap is not constant length
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(567);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x77e1, 16);
-  np->setPostData(0xc5, 8);
-
-  // Finally, add the keys:
+  setPreData(0x77e1, 16);
+  setPostData(0xc5, 8);
 
 // Menu oriented:
   addKey("menu", Menu_Key, 0x40, 8);
diff --git a/keysets/denon.cpp b/keysets/denon.cpp
new file mode 100644 (file)
index 0000000..e59402f
--- /dev/null
@@ -0,0 +1,1058 @@
+#include "denon.h"
+#include "necprotocol.h"
+
+// This whole set of Denon keysets is a mess.  Need to clean it up!!!
+
+DenonDVD1::DenonDVD1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "DVD-1930", DVD_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    349, 647,
+    349, 1689,
+    65002, true); // 43802 between?
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(349);
+
+//  np->setCarrierFrequency(26500); //?
+
+  addKey("POWER_ON", Unmapped_Key, 0x0A34, 15);
+  addKey("POWER_OFF", Unmapped_Key, 0x300C, 15);
+  addKey("MODE", Unmapped_Key, 0x08E4, 15);
+  addKey("OPEN_CLOSE", Eject_Key, 0x0824, 15);
+  addKey("A_B_REPEAT", Unmapped_Key, 0x0974, 15);
+  addKey("REPEAT", Unmapped_Key, 0x08A4, 15);
+  addKey("RANDOM", Unmapped_Key, 0x0954, 15);
+  addKey("ZOOM", Unmapped_Key, 0x13E4, 15);
+  addKey("CLEAR", Clear_Key, 0x0B14, 15);
+  addKey("1", One_Key, 0x0904, 15);
+  addKey("2", Two_Key, 0x0B04, 15);
+  addKey("3", Three_Key, 0x0884, 15);
+  addKey("4", Four_Key, 0x0A84, 15);
+  addKey("5", Five_Key, 0x0984, 15);
+  addKey("6", Six_Key, 0x0B84, 15);
+  addKey("7", Seven_Key, 0x0844, 15);
+  addKey("8", Eight_Key, 0x0A44, 15);
+  addKey("9", Nine_Key, 0x0944, 15);
+  addKey("0", Zero_Key, 0x0A04, 15);
+  addKey("10+", DoubleDigit_Key, 0x08C4, 15);
+  addKey("ANGLE", Unmapped_Key, 0x0BC4, 15);
+  addKey("SUBTITLE", Captions_Key, 0x0AC4, 15);
+  addKey("AUDIO", Language_Key, 0x09C4, 15);
+  addKey("DISPLAY", Info_Key, 0x0B94, 15);
+  addKey("MENU", DiscMenu_Key, 0x0A24, 15);
+  addKey("TOP_MENU", DiscTitle_Key, 0x0AF4, 15);
+  addKey("UP", Up_Key, 0x08D4, 15);
+  addKey("DOWN", Down_Key, 0x0AD4, 15);
+  addKey("LEFT", Left_Key, 0x0BD4, 15);
+  addKey("RIGHT", Right_Key, 0x09D4, 15);
+  addKey("ENTER", Select_Key, 0x0B74, 15);
+  addKey("RETURN", Exit_Key, 0x0924, 15);
+  addKey("SETUP", Menu_Key, 0x08F4, 15);
+  addKey("SEARCH_MODE", Unmapped_Key, 0x11E4, 15);
+  addKey("SKIP_DOWN", Next_Key, 0x0A64, 15);
+  addKey("SKIP_UP", Previous_Key, 0x0864, 15);
+  addKey("FAST_REVERSE", Rewind_Key, 0x0B64, 15);
+  addKey("STOP", Stop_Key, 0x0A14, 15);
+  addKey("PLAY", Play_Key, 0x0814, 15);
+  addKey("FAST_FORWARD", FastForward_Key, 0x0964, 15);
+  addKey("PAUSE", Pause_Key, 0x0AE4, 15);
+  addKey("GROUP", Unmapped_Key, 0x33FC, 15);
+  addKey("SACD_SETUP", Unmapped_Key, 0x09F8, 15);
+  addKey("PAGE+", Unmapped_Key, 0x31FC, 15);
+  addKey("PAGE-", Unmapped_Key, 0x32FC, 15);
+}
+
+
+DenonDVD2::DenonDVD2(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 2",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "DVD-2500", DVD_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    400, 500,
+    400, 1400,
+    43000, false);
+
+  threadableProtocol = np;
+
+  np->setHeaderPair(3500, 1800);
+  np->setTrailerPulse(400);
+
+  setPreData(0x40040D00, 32);
+
+  addKey("Power", Power_Key, 0xBCB1, 16);
+  addKey("Open/Close", Eject_Key, 0x808D, 16);
+  addKey("Stop", Stop_Key, 0x000D, 16);
+  addKey("Pause", Pause_Key, 0x606D, 16);
+  addKey("Play", Play_Key, 0x505D, 16);
+  addKey("SkipBack", Previous_Key, 0x929F, 16);
+  addKey("SkipFwd", Next_Key, 0x525F, 16);
+  addKey("Rev", Rewind_Key, 0x202D, 16);
+  addKey("Fwd", FastForward_Key, 0xA0AD, 16);
+  addKey("Title", DiscTitle_Key, 0xD9D4, 16);
+  addKey("Menu", DiscMenu_Key, 0x010C, 16);
+  addKey("Display", Info_Key, 0x4944, 16);
+  addKey("Return", Exit_Key, 0x818C, 16);
+  addKey("Up", Up_Key, 0xA1AC, 16);
+  addKey("Down", Down_Key, 0x616C, 16);
+  addKey("Right", Right_Key, 0x111C, 16);
+  addKey("Left", Left_Key, 0xE1EC, 16);
+  addKey("Select", Select_Key, 0x414C, 16);
+  addKey("Subtitle", Captions_Key, 0x8984, 16);
+  addKey("Audio", Language_Key, 0xCCC1, 16);
+  addKey("Angle", Unmapped_Key, 0x0904, 16);
+  addKey("Marker", Unmapped_Key, 0x717C, 16);
+  addKey("PlayMode", Unmapped_Key, 0xB1BC, 16);
+  addKey("RepeatMode", Unmapped_Key, 0x313C, 16);
+  addKey("A-B_Repeat", Unmapped_Key, 0x121F, 16);
+  addKey("Setup", Menu_Key, 0x2924, 16);
+  addKey("Clear", Clear_Key, 0xC1CC, 16);
+  addKey("VSS", Unmapped_Key, 0x7974, 16);
+  addKey("1", One_Key, 0x0805, 16);
+  addKey("2", Two_Key, 0x8885, 16);
+  addKey("3", Three_Key, 0x4845, 16);
+  addKey("4", Four_Key, 0xC8C5, 16);
+  addKey("5", Five_Key, 0x2825, 16);
+  addKey("6", Six_Key, 0xA8A5, 16);
+  addKey("7", Seven_Key, 0x6865, 16);
+  addKey("8", Eight_Key, 0xE8E5, 16);
+  addKey("9", Nine_Key, 0x1815, 16);
+  addKey("0", Zero_Key, 0x9895, 16);
+  addKey(">=10", DoubleDigit_Key, 0x919C, 16);
+}
+
+
+DenonDVD3::DenonDVD3(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 3 (odd)",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "dvd-1000", DVD_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    275, 776,
+    275, 1829,
+    67389, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(275);
+
+//  np->setCarrierFrequency(32000);
+
+  addKey("power", Power_Key, 0x09CB, 15);
+  addKey("1", One_Key, 0x0AFB, 15);
+  addKey("2", Two_Key, 0x0B04, 15);
+  addKey("3", Three_Key, 0x0884, 15);
+  addKey("4", Four_Key, 0x097B, 15);
+  addKey("5", Five_Key, 0x0A7B, 15);
+  addKey("6", Six_Key, 0x0B84, 15);
+  addKey("7", Seven_Key, 0x0844, 15);
+  addKey("8", Eight_Key, 0x0A44, 15);
+  addKey("9", Nine_Key, 0x0ABB, 15);
+  addKey("0", Zero_Key, 0x09FB, 15);
+  addKey("10", Unmapped_Key, 0x0B3B, 15);
+  addKey("clear", Clear_Key, 0x08EB, 15);
+  addKey("skip-", Previous_Key, 0x099B, 15);
+  addKey("skip+", Next_Key, 0x0B9B, 15);
+  addKey("slow-", Unmapped_Key, 0x089B, 15);
+  addKey("slow+", Unmapped_Key, 0x0A9B, 15);
+  addKey("stop", Stop_Key, 0x09EB, 15);
+  addKey("pause", Pause_Key, 0x091B, 15);
+  addKey("play", Play_Key, 0x0814, 15);
+  addKey("title", DiscTitle_Key, 0x090B, 15);
+  addKey("menu", DiscMenu_Key, 0x09DB, 15);
+  addKey("return", Exit_Key, 0x0ADB, 15);
+  addKey("display", Info_Key, 0x086B, 15);
+  addKey("select", Select_Key, 0x088B, 15);
+  addKey("arrow-up", Up_Key, 0x0B2B, 15);
+  addKey("arrow-down", Down_Key, 0x092B, 15);
+  addKey("arrow-left", Left_Key, 0x082B, 15);
+  addKey("arrow-right", Right_Key, 0x0A2B, 15);
+  addKey("subtitle", Captions_Key, 0x093B, 15);
+  addKey("audio", Language_Key, 0x0A3B, 15);
+  addKey("angle", Unmapped_Key, 0x083B, 15);
+  addKey("setup", Menu_Key, 0x0B0B, 15);
+  addKey("repeat", Repeat_Key, 0x0B5B, 15);
+  addKey("repeat-ab", Unmapped_Key, 0x0A8B, 15);
+  addKey("random", Random_Key, 0x0AAB, 15);
+  addKey("call", Unmapped_Key, 0x0A0B, 15);
+  addKey("program", Program_Key, 0x0AEB, 15);
+  addKey("open-close", Eject_Key, 0x0BDB, 15);
+  addKey("ntsc-pal", Unmapped_Key, 0x084B, 15);
+}
+
+
+DenonReceiver1::DenonReceiver1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Receiver Keyset 1",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "avr-1708", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    400, 700,
+    400, 1700,
+    67000, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(400);
+
+  addKey("On", Unmapped_Key, 0x221C, 15);
+  addKey("Off", Unmapped_Key, 0x211C, 15);
+  addKey("DVD_HDP", Unmapped_Key, 0x231C, 15); // "SRC_DVD"
+  addKey("TV_CBL", Unmapped_Key, 0x224C, 15);
+  addKey("VCR", Unmapped_Key, 0x22CC, 15);
+  addKey("Play", Play_Key, 0x10E8, 15);
+  addKey("Stop", Stop_Key, 0x11E8, 15);
+  addKey("Skip_Favorite", Favorites_Key, 0x13A8, 15);
+  addKey("Pause", Pause_Key, 0x1328, 15);
+  addKey("Volume_up", VolumeUp_Key, 0x223C, 15);
+  addKey("Volume_down", VolumeDown_Key, 0x213C, 15);
+  addKey("Rewind", Rewind_Key, 0x1368, 15);
+  addKey("Forward", FastForward_Key, 0x1168, 15);
+  addKey("Setup", Menu_Key, 0x206C, 15);
+  addKey("Mute", Mute_Key, 0x203C, 15);
+  addKey("Night_Audio", Unmapped_Key, 0x1064, 15);
+  addKey("Display", Info_Key, 0x23EC, 15); // "onscreen"
+  addKey("Enter", Select_Key, 0x201C, 15);
+  addKey("Left", Left_Key, 0x1BF8, 15);
+  addKey("Up", Up_Key, 0x1B14, 15);
+  addKey("Right", Right_Key, 0x22EC, 15);
+  addKey("Down", Down_Key, 0x1894, 15);
+  addKey("Return", Exit_Key, 0x21EC, 15);
+  addKey("Dimmer", Unmapped_Key, 0x1BEC, 15);
+}
+
+
+DenonReceiver1a::DenonReceiver1a(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonReceiver1(guiObject, index)
+{
+  setKeysetName("Receiver Keyset 1a");
+
+  addControlledDevice(Denon_Make, "AVR-1610", Audio_Device);
+
+  // This keyset may need work, see denon/RC-1120
+  addKey("SRC_TV", Unmapped_Key, 0x21B3, 15);
+  addKey("SRC_TUNNER", Unmapped_Key, 0x228C, 15);
+  addKey("SRC_VAUX", Unmapped_Key, 0x20CC, 15);
+  addKey("SRC_HDP", Unmapped_Key, 0x214C, 15);
+  addKey("SRC_DVR", Unmapped_Key, 0x2233, 15);
+  addKey("SRC_VCR", Unmapped_Key, 0x2133, 15);
+  addKey("SRC_SATCBL", Unmapped_Key, 0x204C, 15);
+  addKey("BTN_VSEL", Unmapped_Key, 0x2393, 15);
+  addKey("BTN_INPUT_MODE", Unmapped_Key, 0x19B4, 15);
+  addKey("BTN_MULTEQ", Unmapped_Key, 0x111B, 15);
+  addKey("BTN_HDMI_CONTROL", Unmapped_Key, 0x182B, 15);
+  addKey("BTN_UP", Up_Key, 0x18EB, 15);
+  addKey("BTN_DOWN", Down_Key, 0x1894, 15);
+  addKey("BTN_SKIP", Unmapped_Key, 0x18CC, 15);
+  addKey("BTN_STOP", Stop_Key, 0x1BAC, 15);
+  addKey("BTN_PAUSE", Pause_Key, 0x1ACC, 15);
+  addKey("BTN_PLAY", Play_Key, 0x186C, 15);
+  addKey("FAST_REVERSE", Rewind_Key, 0x1A93, 15);
+  addKey("FAST_FORWARD", FastForward_Key, 0x1A6C, 15);
+  addKey("BTN_PREV", Previous_Key, 0x1AAC, 15);
+  addKey("BTN_NEXT", Next_Key, 0x19AC, 15);
+  addKey("BTN_STD", Unmapped_Key, 0x2363, 15);
+  addKey("PAGE_DN", Unmapped_Key, 0x1813, 15);
+  addKey("PAGE_UP", Unmapped_Key, 0x21EC, 15);
+  addKey("BTN_STD_CINEMA", Unmapped_Key, 0x115B, 15);
+  addKey("BTN_STD_MUSIC", Unmapped_Key, 0x125B, 15);
+  addKey("BTN_SIMU", Unmapped_Key, 0x219C, 15);
+}
+
+
+DenonReceiver1b::DenonReceiver1b(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonReceiver1(guiObject, index)
+{
+  setKeysetName("Receiver Keyset 1b");
+
+  addControlledDevice(Denon_Make, "avr-3300", Audio_Device);
+
+  addKey("vol+", VolumeUp_Key, 0x21C3, 15);
+  addKey("channel+", ChannelUp_Key, 0x19AC, 15);
+  addKey("channel-", ChannelDown_Key, 0x1AAC, 15);
+  addKey("setup", Menu_Key, 0x1814, 15);
+  addKey("params", Unmapped_Key, 0x1A14, 15);
+  addKey("input-mode", Unmapped_Key, 0x19B4, 15);
+  addKey("analog", Unmapped_Key, 0x20EC, 15);
+  addKey("ext.in", Unmapped_Key, 0x1AB4, 15);
+  addKey("output", Unmapped_Key, 0x1A94, 15);
+  addKey("multi", Unmapped_Key, 0x236C, 15);
+}
+
+
+DenonReceiver1c::DenonReceiver1c(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonReceiver1(guiObject, index)
+{
+  setKeysetName("Receiver Keyset 1c");
+
+  addControlledDevice(Denon_Make, "AVR-1602", Audio_Device);
+  addControlledDevice(Denon_Make, "AVR-1802", Audio_Device);
+  addControlledDevice(Denon_Make, "AVR-1803", Audio_Device);
+
+  addKey("ONE", One_Key, 0x230C, 15);
+  addKey("TWO", Two_Key, 0x208C, 15);
+  addKey("THREE", Three_Key, 0x231C, 15);
+  addKey("FOUR", Four_Key, 0x20CC, 15);
+  addKey("FIVE", Five_Key, 0x22CC, 15);
+  addKey("SIX", Six_Key, 0x21CC, 15);
+  addKey("SEVEN", Seven_Key, 0x224C, 15);
+  addKey("EIGHT", Eight_Key, 0x19B4, 15);
+  addKey("NINE", Nine_Key, 0x212C, 15);
+  addKey("ZERO", Zero_Key, 0x228C, 15);
+  addKey("RCVR_SURROUND_MODE", Unmapped_Key, 0x219C, 15);
+  addKey("RCVR_CHANNEL+", ChannelUp_Key, 0x19AC, 15);
+  addKey("RCVR_CHANNEL-", ChannelDown_Key, 0x1AAC, 15);
+  addKey("VIDEO_SELECT", Unmapped_Key, 0x206C, 15);
+  addKey("CD_DISC_SKIP", Unmapped_Key, 0x0B58, 15);
+  addKey("CD_PLAY", Unmapped_Key, 0x08E8, 15);
+  addKey("CD_PAUSE", Unmapped_Key, 0x0AE8, 15);
+  addKey("CD_NEXT", Unmapped_Key, 0x0868, 15);
+  addKey("CD_PREV", Unmapped_Key, 0x0A68, 15);
+  addKey("CD_STOP", Unmapped_Key, 0x09E8, 15);
+  addKey("CD_REW", Unmapped_Key, 0x0B68, 15);
+  addKey("CD_FFW", Unmapped_Key, 0x0968, 15);
+  addKey("SYSTEM", Menu_Key, 0x1814, 15);
+  addKey("RCVR_SURROUND", Surround_Key, 0x1A14, 15);
+//  addKey("RCVR_CH_SELECT", Select_Key, 0x201C, 15);
+  addKey("RCVR_T_TONE", Unmapped_Key, 0x215C, 15);
+  addKey("RCVR_STATUS", Info_Key, 0x21EC, 15);
+}
+
+
+DenonReceiver2::DenonReceiver2(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Receiver Keyset 2",
+      Denon_Make,
+      index)
+{
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    315, 740,
+    315, 1812,
+    45920, false);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(315);
+
+  addKey("amp_power", Power_Key, 0x67D7, 15);
+  addKey("amp_vol-down", VolumeDown_Key, 0x6737, 15);
+  addKey("amp_vol-up", VolumeUp_Key, 0x6537, 15);
+  addKey("amp_tape", Unmapped_Key, 0x6517, 15);
+  addKey("amp_aux/video", Unmapped_Key, 0x6497, 15);
+  addKey("amp_tuner", Unmapped_Key, 0x6597, 15);
+  addKey("amp_cd", Unmapped_Key, 0x6697, 15);
+  addKey("amp_phono", Unmapped_Key, 0x6797, 15);
+  addKey("tun_1", Unmapped_Key, 0x66F7, 15);
+  addKey("tun_2", Unmapped_Key, 0x64F7, 15);
+  addKey("tun_3", Unmapped_Key, 0x6777, 15);
+  addKey("tun_4", Unmapped_Key, 0x6577, 15);
+  addKey("tun_5", Unmapped_Key, 0x6677, 15);
+  addKey("tun_6", Unmapped_Key, 0x6477, 15);
+  addKey("tun_7", Unmapped_Key, 0x67B7, 15);
+  addKey("tun_8", Unmapped_Key, 0x65B7, 15);
+  addKey("tun_shift", Unmapped_Key, 0x66B7, 15);
+  addKey("cd_pause", Pause_Key, 0x76E8, 15);
+  addKey("cd_stop", Stop_Key, 0x7617, 15);
+  addKey("cd_play", Play_Key, 0x7717, 15);
+  addKey("cd_rew", Rewind_Key, 0x7497, 15);
+  addKey("cd_ff", FastForward_Key, 0x7697, 15);
+  addKey("cd_prev", Previous_Key, 0x7597, 15);
+  addKey("cd_next", Next_Key, 0x7797, 15);
+  addKey("CD_RANDOM", Random_Key, 0x76A7, 15);
+  addKey("CD_REPEAT", Repeat_Key, 0x7757, 15);
+  addKey("CD_SKIP", Unmapped_Key, 0x74A7, 15);
+  addKey("tape_pause", Unmapped_Key, 0x6D17, 15);
+  addKey("tape_stop", Unmapped_Key, 0x6E17, 15);
+  addKey("tape_playrev", Unmapped_Key, 0x6C57, 15);
+  addKey("tape_play", Unmapped_Key, 0x6F17, 15);
+  addKey("tape_rec", Unmapped_Key, 0x6C17, 15);
+  addKey("tape_a/b", Unmapped_Key, 0x6CD7, 15);
+  addKey("tape_rew", Unmapped_Key, 0x6C97, 15);
+  addKey("tape_ff", Unmapped_Key, 0x6E97, 15);
+}
+
+
+DenonReceiver2a::DenonReceiver2a(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonReceiver2(guiObject, index)
+{
+  setKeysetName("Receiver Keyset 2a");
+
+  addControlledDevice(Denon_Make, "PMA-425R", Audio_Device);
+
+  addKey("AMP_TAPE2", Unmapped_Key, 0x5E9B, 15);
+  addKey("AMP_TAPE1", Unmapped_Key, 0x5D9B, 15);
+  addKey("AMP_AUX", Unmapped_Key, 0x5F7B, 15);
+  addKey("AMP_TUNER", Unmapped_Key, 0x5CE3, 15);
+  addKey("AMP_CD", Unmapped_Key, 0x5EFB, 15);
+  addKey("AMP_PHONO", Unmapped_Key, 0x5DFB, 15);
+  addKey("AMP_VOL_UP", VolumeUp_Key, 0x5D3B, 15);
+  addKey("AMP_VOL_DOWN", VolumeDown_Key, 0x5F3B, 15);
+  addKey("AMP_POWER", Power_Key, 0x5FDB, 15);
+  addKey("AMP_MUTE", Mute_Key, 0x5CBB, 15);
+  addKey("TUN_CH_UP", ChannelUp_Key, 0x6653, 15);
+  addKey("TUN_CH_DOWN", ChannelDown_Key, 0x6553, 15);
+}
+
+
+DenonReceiver3::DenonReceiver3(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Receiver Keyset 3",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "PMA-480R", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    400, 600,
+    400, 1700,
+    67400, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(400);
+
+  addKey("TUNER", Unmapped_Key, 0x1AEC, 15);
+  addKey("DECK", Unmapped_Key, 0x12B8, 15);
+  addKey("CD", Unmapped_Key, 0x0B38, 15);
+  addKey("CD_PLAY", Play_Key, 0x08E8, 15);
+  addKey("CD_PAUSE", Pause_Key, 0x0AE8, 15);
+  addKey("CD_STOP", Stop_Key, 0x09E8, 15);
+  addKey("CD_REW", Rewind_Key, 0x0B68, 15);
+  addKey("CD_FF", FastForward_Key, 0x0968, 15);
+  addKey("CD_BACK", Previous_Key, 0x0A68, 15);
+  addKey("CD_NEXT", Next_Key, 0x0868, 15);
+  addKey("DISC1", Unmapped_Key, 0x0898, 15);
+  addKey("DISC2", Unmapped_Key, 0x0A98, 15);
+  addKey("DISC3", Unmapped_Key, 0x0998, 15);
+  addKey("DISC4", Unmapped_Key, 0x0B98, 15);
+  addKey("DISC5", Unmapped_Key, 0x0858, 15);
+  addKey("DISC6", Unmapped_Key, 0x0A58, 15);
+  addKey("REPEAT", Repeat_Key, 0x08A8, 15);
+  addKey("TAPE_A/B", Unmapped_Key, 0x1328, 15);
+  addKey("TAPE_PAUSE", Unmapped_Key, 0x12E8, 15);
+  addKey("TAPE_STOP", Unmapped_Key, 0x11E8, 15);
+  addKey("TAPE_REC", Unmapped_Key, 0x13E8, 15);
+  addKey("TAPE_REW", Unmapped_Key, 0x1368, 15);
+  addKey("TAPE_FF", Unmapped_Key, 0x1168, 15);
+  addKey("TAPE_PLAY_REV", Unmapped_Key, 0x13A8, 15);
+  addKey("TAPE_PLAY", Unmapped_Key, 0x10E8, 15);
+  addKey("TUNER_UP", ChannelUp_Key, 0x1AAC, 15);
+  addKey("TUNER_DOWN", ChannelDown_Key, 0x19AC, 15);
+  addKey("AMP_POWER", Power_Key, 0x2024, 15);
+  addKey("AMP_CD", Unmapped_Key, 0x2104, 15);
+  addKey("AMP_PHONO", Unmapped_Key, 0x2204, 15);
+  addKey("AMP_AUX", Unmapped_Key, 0x2084, 15);
+  addKey("AMP_TUNER", Unmapped_Key, 0x2304, 15);
+  addKey("AMP_TAPE-2", Unmapped_Key, 0x2164, 15);
+  addKey("AMP_TAPE-1", Unmapped_Key, 0x2264, 15);
+  addKey("AMP_MUTING", Mute_Key, 0x20BB, 15);
+  addKey("AMP_VOL_UP", VolumeUp_Key, 0x22C4, 15);
+  addKey("AMP_VOL_DOWN", VolumeDown_Key, 0x20C4, 15);
+}
+
+
+DenonReceiver3a::DenonReceiver3a(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonReceiver3(guiObject, index)
+{
+  setKeysetName("Receiver Keyset 3a");
+
+  addControlledDevice(Denon_Make, "DRA-385RD", Audio_Device);
+
+  addKey("random", Random_Key, 0x0958, 15);
+  addKey("repeat", Repeat_Key, 0x0B57, 15);
+  addKey("disksk", Unmapped_Key, 0x0B58, 15);
+  addKey("panel", Info_Key, 0x19F8, 15);
+  addKey("tape_mon", Unmapped_Key, 0x18E8, 15);
+  addKey("tape2", Unmapped_Key, 0x19E8, 15);
+  addKey("tape1", Unmapped_Key, 0x1AE8, 15);
+  addKey("video", Unmapped_Key, 0x1B28, 15);
+  addKey("tuner", Unmapped_Key, 0x1A68, 15);
+  addKey("cd", Unmapped_Key, 0x1968, 15);
+  addKey("phono", Unmapped_Key, 0x1868, 15);
+  addKey("preset+", Unmapped_Key, 0x1A37, 15);
+  addKey("preset-", Unmapped_Key, 0x1BC8, 15);
+  addKey("volup", VolumeUp_Key, 0x1937, 15);
+  addKey("voldwn", VolumeDown_Key, 0x18C8, 15);
+}
+
+
+DenonReceiver4::DenonReceiver4(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Receiver Keyset 4",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "AVR-600 RD", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    561, 489,
+    561, 1543,
+    67329, true);
+
+  threadableProtocol = np;
+
+  np->setTrailerPulse(561);
+
+  addKey("POWER", Power_Key, 0xA20C, 16);
+  addKey("UP", Up_Key, 0x99AC, 16);
+  addKey("DOWN", Down_Key, 0x9AAC, 16);
+  addKey("TUNER", Unmapped_Key, 0xA28C, 16);
+  addKey("CD", Unmapped_Key, 0xA08C, 16);
+  addKey("PHONO", Unmapped_Key, 0xA30C, 16);
+  addKey("VCR", Unmapped_Key, 0xA2CC, 16);
+  addKey("TV", Unmapped_Key, 0xA14C, 16);
+  addKey("TAPE", Unmapped_Key, 0xA12C, 16);
+  addKey("STEREO", Unmapped_Key, 0xA39C, 16);
+  addKey("MODE", Unmapped_Key, 0xA19C, 16);
+  addKey("TESTTONE", Unmapped_Key, 0xA15C, 16);
+  addKey("DELAY", Unmapped_Key, 0xA25C, 16);
+  addKey("MUTE", Mute_Key, 0xA03C, 16);
+  addKey("PANEL", Info_Key, 0xA1EC, 16);
+  addKey("CENTER_UP", Unmapped_Key, 0xA2BC, 16);
+  addKey("CENTER_DOWN", Unmapped_Key, 0xA1BC, 16);
+  addKey("REAR_UP", Unmapped_Key, 0xA33C, 16);
+  addKey("REAR_DOWN", Unmapped_Key, 0xA0BC, 16);
+  addKey("VOL_UP", VolumeUp_Key, 0xA23C, 16);
+  addKey("VOL_DOWN", VolumeDown_Key, 0xA13C, 16);
+}
+
+
+DenonReceiver5::DenonReceiver5(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Receiver Keyset 5",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "AVR-700RD", Audio_Device);
+  addControlledDevice(Denon_Make, "RC-841", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    336, 715,
+    336, 1769,
+    67376, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(337);
+
+  addKey("Power", Power_Key, 0x220C, 15);
+  addKey("CD_Disc_Skip_Plus", Unmapped_Key, 0x0B58, 15);
+  addKey("CD_Stop", Stop_Key, 0x09E8, 15);
+  addKey("CD_Play", Play_Key, 0x08E8, 15);
+  addKey("CD_Prev", Previous_Key, 0x0A68, 15);
+  addKey("CD_Pause", Pause_Key, 0x0AE8, 15);
+  addKey("CD_Next", Next_Key, 0x0868, 15);
+  addKey("Preset_Up", Unmapped_Key, 0x19AC, 15);
+  addKey("Preset_Down", Unmapped_Key, 0x1AAC, 15);
+  addKey("Shift", Unmapped_Key, 0x1ACC, 15);
+  addKey("Tuner", Unmapped_Key, 0x228C, 15);
+  addKey("CD", Unmapped_Key, 0x208C, 15);
+  addKey("Phono", Unmapped_Key, 0x230C, 15);
+  addKey("VCR", Unmapped_Key, 0x22CC, 15);
+  addKey("DVD_TV", Unmapped_Key, 0x214C, 15);
+  addKey("NoName1", Unmapped_Key, 0x20CC, 15);
+  addKey("DAT_Tape", Unmapped_Key, 0x212C, 15);
+  addKey("Stereo", Unmapped_Key, 0x239C, 15);
+  addKey("Mode", Unmapped_Key, 0x219C, 15);
+  addKey("Test_Tone", Unmapped_Key, 0x215C, 15);
+  addKey("Delay", Unmapped_Key, 0x225C, 15);
+  addKey("CenterVolumeUp", Unmapped_Key, 0x22BC, 15);
+  addKey("CenterVolumeDown", Unmapped_Key, 0x21BC, 15);
+  addKey("RearVolumeUp", Unmapped_Key, 0x233C, 15);
+  addKey("RearVolumeDown", Unmapped_Key, 0x20BC, 15);
+  addKey("Muting", Mute_Key, 0x203C, 15);
+  addKey("NoName2", Unmapped_Key, 0x23EC, 15);
+  addKey("Panel", Info_Key, 0x21EC, 15);
+  addKey("MasterVolumeUp", VolumeUp_Key, 0x223C, 15);
+  addKey("MasterVolumeDown", VolumeDown_Key, 0x213C, 15);
+  addKey("Deck_PlayLeft", Unmapped_Key, 0x13A8, 15);
+  addKey("Deck_Stop", Unmapped_Key, 0x11E8, 15);
+  addKey("Deck_PlayRight", Unmapped_Key, 0x10E8, 15);
+  addKey("Deck_Rewind", Unmapped_Key, 0x1368, 15);
+  addKey("Deck_A_B", Unmapped_Key, 0x1328, 15);
+  addKey("Deck_FastForward", Unmapped_Key, 0x1168, 15);
+}
+
+
+DenonAudio1::DenonAudio1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 1",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "HiFi 110", Audio_Device);
+  addControlledDevice(Denon_Make, "DRM-550", Audio_Device);
+  addControlledDevice(Denon_Make, "DCD-335", Audio_Device);
+  addControlledDevice(Denon_Make, "DRA-275RD", Audio_Device);
+  addControlledDevice(Denon_Make, "UD-M30", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    300, 750,
+    300, 1800,
+    67500, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(300);
+
+  addKey("KEY_POWER", Power_Key, 0x1828, 15); // "aus"
+  addKey("KEY_SLEEP", Sleep_Key, 0x1938, 15);
+  addKey("KEY_FN", Unmapped_Key, 0x1BE8, 15); // "func"
+  addKey("KEY_STOP", Stop_Key, 0x09E8, 15); // "CD_STOP"
+  addKey("KEY_PLAY", Play_Key, 0x08E8, 15); // "cdplay"
+  addKey("KEY_PAUSE", Pause_Key, 0x0AE8, 15); // "cdpause"
+  addKey("KEY_REWIND", Rewind_Key, 0x0B68, 15); // "cdfrew"
+  addKey("KEY_FORWARD", FastForward_Key, 0x0968, 15); // "cdffwd"
+  addKey("KEY_PREVIOUS", Previous_Key, 0x0A68, 15); // "cdrew", "cdprevtrack"
+  addKey("KEY_NEXT", Next_Key, 0x0868, 15); // "cdfwd", "cdnexttrack"
+  addKey("KEY_1", One_Key, 0x0908, 15);
+  addKey("KEY_2", Two_Key, 0x0B08, 15);
+  addKey("KEY_3", Three_Key, 0x0888, 15);
+  addKey("KEY_4", Four_Key, 0x0A88, 15);
+  addKey("KEY_5", Five_Key, 0x0988, 15);
+  addKey("KEY_6", Six_Key, 0x0B88, 15);
+  addKey("KEY_7", Seven_Key, 0x0BB7, 15);
+  addKey("KEY_8", Eight_Key, 0x0A48, 15);
+  addKey("KEY_9", Nine_Key, 0x0948, 15);
+  addKey("10", Zero_Key, 0x0B48, 15);
+  addKey("+10", DoubleDigit_Key, 0x08C8, 15);
+  addKey("DIRECT", Unmapped_Key, 0x0BA8, 15); // "direct"
+  addKey("KEY_PROGRAM", Program_Key, 0x0AC8, 15);
+  addKey("KEY_CANCEL", Clear_Key, 0x0A28, 15); // "cancel", "CD_CANCEL"
+  addKey("TUNER BAND", Unmapped_Key, 0x1BAC, 15);
+  addKey("TUNER KEY_DOWN", ChannelDown_Key, 0x196C, 15);
+  addKey("TUNER KEY_UP", ChannelUp_Key, 0x1A6C, 15);
+  addKey("CT", Unmapped_Key, 0x1B2C, 15); // "TUNER_CT"
+  addKey("RDS", Unmapped_Key, 0x192C, 15); // "TUNER_RDS"
+  addKey("PRESET DOWN", Down_Key, 0x1BC8, 15); // "dwn"
+  addKey("PRESET UP", Up_Key, 0x19C8, 15); // "up"
+  addKey("TAPE REW", Unmapped_Key, 0x13A8, 15); // "TAPE_PLAY_REV"
+  addKey("TAPE FWD", Unmapped_Key, 0x10E8, 15); // "TAPE_PLAY_FORW"
+  addKey("TAPE FAST REW", Unmapped_Key, 0x1368, 15); // "TAPE_REW"
+  addKey("TAPE FAST FWD", Unmapped_Key, 0x1168, 15); // "TAPE_FORW"
+  addKey("TAPE STOP", Unmapped_Key, 0x11E8, 15);
+  addKey("TAPE 2 REW", Unmapped_Key, 0x1398, 15);
+  addKey("TAPE 2 FWD", Unmapped_Key, 0x10D8, 15);
+  addKey("TAPE 2 FAST REW", Unmapped_Key, 0x1358, 15);
+  addKey("TAPE 2 FAST FWD", Unmapped_Key, 0x1158, 15);
+  addKey("TAPE 2 STOP", Unmapped_Key, 0x11D8, 15);
+  addKey("KEY_RECORD", Record_Key, 0x13D8, 15);
+  addKey("SDB", Unmapped_Key, 0x095C, 15);
+  addKey("KEY_VOLUMEDOWN", VolumeDown_Key, 0x18C8, 15);
+  addKey("KEY_VOLUMEUP", VolumeUp_Key, 0x1AC8, 15);
+  addKey("cdskip", Unmapped_Key, 0x0B58, 15);
+  addKey("tuner", Unmapped_Key, 0x1A68, 15);
+  addKey("repeat", Repeat_Key, 0x08A8, 15); // "CD_REPEAT"
+  addKey("random", Random_Key, 0x0958, 15); // "CD_RANDOM"
+  addKey("programm", Program_Key, 0x0AC8, 15);
+  addKey("edit", Unmapped_Key, 0x0838, 15); // "CD_EDIT"
+  addKey("time", Unmapped_Key, 0x0B28, 15); // "CD_TIME"
+  addKey("reset", Reset_Key, 0x10A8, 15);
+  addKey("remain", Unmapped_Key, 0x10B8, 15);
+  addKey("tapesize", Unmapped_Key, 0x1018, 15);
+  addKey("revmode", Unmapped_Key, 0x1118, 15);
+  addKey("memo", Unmapped_Key, 0x1A2C, 15);
+  addKey("pty", Unmapped_Key, 0x18AC, 15); // "TUNER_PTY"
+  addKey("panel", Info_Key, 0x19EC, 15);
+  addKey("eon", Unmapped_Key, 0x1BBC, 15);
+  addKey("auto_space", Unmapped_Key, 0x0A18, 15);
+  addKey("auto_edit", Unmapped_Key, 0x0B18, 15);
+  addKey("open_close", Eject_Key, 0x0828, 15);
+  addKey("fader", Unmapped_Key, 0x09B8, 15);
+  addKey("pitch-", Unmapped_Key, 0x0878, 15);
+  addKey("pitch+", Unmapped_Key, 0x0BB8, 15);
+  addKey("peak", Unmapped_Key, 0x0BD8, 15);
+  addKey("TAPE_AB", Unmapped_Key, 0x1328, 15);
+  addKey("TAPE_PAUSE", Unmapped_Key, 0x12E8, 15);
+  addKey("RCVR_PANEL", Info_Key, 0x19F8, 15);
+  addKey("RCVR_TAPE_MON", Unmapped_Key, 0x18E8, 15);
+  addKey("RCVR_TAPE2", Unmapped_Key, 0x19E8, 15);
+  addKey("RCVR_TAPE1", Unmapped_Key, 0x1AE8, 15);
+  addKey("RCVR_VIDEO", Unmapped_Key, 0x1B28, 15);
+  addKey("RCVR_TUNER", Unmapped_Key, 0x1A68, 15);
+  addKey("RCVR_CD", Unmapped_Key, 0x1A97, 15);
+  addKey("RCVR_PHONO", Unmapped_Key, 0x1868, 15);
+}
+
+
+DenonAudio1a::DenonAudio1a(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonAudio1(guiObject, index)
+{
+  setKeysetName("Audio Keyset 1a");
+
+  addControlledDevice(Denon_Make, "UCD-F07", Audio_Device);
+  addControlledDevice(Denon_Make, "UDR-F07", Audio_Device);
+  addControlledDevice(Denon_Make, "UDRA-F07", Audio_Device);
+
+  addKey("rec", Record_Key, 0x13E8, 15);
+  addKey("side_a/b", Unmapped_Key, 0x0B28, 15);
+  addKey("cdstop", Stop_Key, 0x0A17, 15);
+}
+
+
+DenonAudio1b::DenonAudio1b(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonAudio1(guiObject, index)
+{
+  setKeysetName("Audio Keyset 1b");
+
+  addControlledDevice(Denon_Make, "DCD-1015", Audio_Device);
+  addControlledDevice(Denon_Make, "DCD-655", Audio_Device);
+
+  addKey("vol_down", VolumeDown_Key, 0x0BC8, 15);
+  addKey("vol_up", VolumeUp_Key, 0x09C8, 15);
+  addKey("display", Info_Key, 0x0AB8, 15);
+}
+
+
+DenonAudio1c::DenonAudio1c(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonAudio1b(guiObject, index)
+{
+  setKeysetName("Audio Keyset 1c (odd)");
+
+  addControlledDevice(Denon_Make, "DCM-260", Audio_Device);
+
+  addKey("RANDOM", Random_Key, 0x0AA7, 15);
+  addKey("2", Two_Key, 0x08F7, 15);
+  addKey("DISC_SELECT", Unmapped_Key, 0x0918, 15);
+//  addKey("DISC_SKIP+", Unmapped_Key, 0x0B58, 15); // already in parent...
+  addKey("DISC_SKIP-", Unmapped_Key, 0x0A27, 15); // not in parent
+  addKey("|<<", Previous_Key, 0x0997, 15);
+}
+
+
+DenonAudio1d::DenonAudio1d(
+  QObject *guiObject,
+  unsigned int index)
+  : DenonAudio1(guiObject, index)
+{
+  setKeysetName("Audio Keyset 1d");
+
+  addControlledDevice(Denon_Make, "UDRA-M7", Audio_Device);
+  addControlledDevice(Denon_Make, "UPA-F88", Audio_Device);
+  addControlledDevice(Denon_Make, "UCD-F88", Audio_Device);
+  addControlledDevice(Denon_Make, "UDR-F88", Audio_Device);
+  addControlledDevice(Denon_Make, "UTU-F88", Audio_Device);
+  addControlledDevice(Denon_Make, "RC-846", Audio_Device);
+
+  addKey("TAPE_REC", Record_Key, 0x13E8, 15);
+  addKey("MD_PLAY", Unmapped_Key, 0x311C, 15);
+  addKey("MD_STOP", Unmapped_Key, 0x321C, 15);
+  addKey("MD_REC", Unmapped_Key, 0x329C, 15);
+  addKey("MD_SEARCH_NEXT", Unmapped_Key, 0x325C, 15);
+  addKey("MD_SEARCH_PREVIOUS", Unmapped_Key, 0x315C, 15);
+}
+
+
+DenonAudio2::DenonAudio2(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 2",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "D-C30", Audio_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0xDA25, 16);
+
+  addKey("Power", Power_Key, 0x00FF, 16);
+  addKey("Tuner_Band", Unmapped_Key, 0xE01F, 16);
+  addKey("EQ_Pattern", Unmapped_Key, 0x8877, 16);
+  addKey("Open/Close", Eject_Key, 0x18E7, 16);
+  addKey("1", One_Key, 0xB24D, 16);
+  addKey("2", Two_Key, 0x728D, 16);
+  addKey("3", Three_Key, 0xF20D, 16);
+  addKey("4", Four_Key, 0x0AF5, 16);
+  addKey("5", Five_Key, 0x8A75, 16);
+  addKey("6", Six_Key, 0x4AB5, 16);
+  addKey("7", Seven_Key, 0xCA35, 16);
+  addKey("8", Eight_Key, 0x2AD5, 16);
+  addKey("9", Nine_Key, 0xAA55, 16);
+  addKey("10", Unmapped_Key, 0x6A95, 16);
+  addKey("0/11", Zero_Key, 0xDA25, 16);
+  addKey("10+/12", DoubleDigit_Key, 0xEA15, 16);
+  addKey("Record_Pause", Unmapped_Key, 0xF807, 16);
+  addKey("Play_Backward", Unmapped_Key, 0x4B87, 16);
+  addKey("Stop", Unmapped_Key, 0xB847, 16);
+  addKey("Play_Forward", Unmapped_Key, 0x9867, 16);
+  addKey("A.Edit", Unmapped_Key, 0x20DF, 16);
+  addKey("Fast_Rewind", Unmapped_Key, 0x38C7, 16);
+  addKey("Fast_Forward", Unmapped_Key, 0xD827, 16);
+  addKey("Tape_1/2", Unmapped_Key, 0x906F, 16);
+  addKey("Remain", Unmapped_Key, 0xC03F, 16);
+  addKey("Random", Random_Key, 0x5AA5, 16);
+  addKey("Prog", Program_Key, 0x6897, 16);
+  addKey("Disc", Unmapped_Key, 0x7A85, 16);
+  addKey("Skip_Backward", Previous_Key, 0xA857, 16);
+  addKey("Skip_Forward", Next_Key, 0x28D7, 16);
+  addKey("CD_Stop", Stop_Key, 0xC837, 16);
+  addKey("CD_Play", Play_Key, 0x48B7, 16);
+  addKey("P.Mode", Unmapped_Key, 0xD02F, 16);
+  addKey("Repeat", Repeat_Key, 0xE817, 16);
+  addKey("Volume_Down", VolumeDown_Key, 0x40BF, 16);
+  addKey("Volume_Up", VolumeUp_Key, 0x807F, 16);
+}
+
+
+DenonAudio3::DenonAudio3(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 3",
+      Denon_Make,
+      index)
+{
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    336, 717,
+    336, 1773,
+    67458, true);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(336);
+
+  addKey("open_close", Eject_Key, 0x8828, 15);
+  addKey("call", Unmapped_Key, 0x8928, 15);
+  addKey("prog", Program_Key, 0x8B08, 15);
+  addKey("direct", Unmapped_Key, 0x8BA8, 15);
+  addKey("1", One_Key, 0x8908, 15);
+  addKey("2", Two_Key, 0x8B08, 15);
+  addKey("3", Three_Key, 0x8888, 15);
+  addKey("4", Four_Key, 0x8A88, 15);
+  addKey("5", Five_Key, 0x8988, 15);
+  addKey("6", Six_Key, 0x8B88, 15);
+  addKey("7", Seven_Key, 0x8848, 15);
+  addKey("8", Eight_Key, 0x8A48, 15);
+  addKey("9", Nine_Key, 0x8948, 15);
+  addKey("10", Zero_Key, 0x8B48, 15);
+  addKey("+10", DoubleDigit_Key, 0x88C8, 15);
+  addKey("play", Play_Key, 0x88E8, 15);
+  addKey("vol_up", VolumeUp_Key, 0x89C8, 15);
+  addKey("vol_down", VolumeDown_Key, 0x8BC8, 15);
+  addKey("pause", Pause_Key, 0x8AE8, 15);
+  addKey("stop", Stop_Key, 0x89E8, 15);
+  addKey("a_space", Unmapped_Key, 0x8A18, 15);
+  addKey("all", Unmapped_Key, 0x88A8, 15);
+  addKey("a-b", Unmapped_Key, 0x8AA8, 15);
+  addKey("rewind", Rewind_Key, 0x8B68, 15);
+  addKey("wind", FastForward_Key, 0x8968, 15);
+  addKey("prev", Previous_Key, 0x8A68, 15);
+  addKey("next", Next_Key, 0x8868, 15);
+}
+
+
+DenonAudio4::DenonAudio4(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 4",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "DMD-800", Audio_Device);
+
+  NECProtocol *np = new NECProtocol(
+    guiObject,
+    index,
+    275, 775,
+    275, 1900,
+    43000, false);
+
+  threadableProtocol = np;
+
+  np->setElevenBitToggle(true);
+
+  np->setTrailerPulse(275);
+
+  addKey("EJECT", Eject_Key, 0x319C, 15);
+  addKey("POWER", Power_Key, 0x301C, 15);
+  addKey("PLAY", Play_Key, 0x311C, 15);
+  addKey("PAUSE", Pause_Key, 0x331C, 15);
+  addKey("STOP", Stop_Key, 0x321C, 15);
+  addKey("REC", Record_Key, 0x329C, 15);
+  addKey("1", One_Key, 0x320C, 15);
+  addKey("2", Two_Key, 0x310C, 15);
+  addKey("3", Three_Key, 0x330C, 15);
+  addKey("4", Four_Key, 0x308C, 15);
+  addKey("5", Five_Key, 0x328C, 15);
+  addKey("6", Six_Key, 0x318C, 15);
+  addKey("7", Seven_Key, 0x338C, 15);
+  addKey("8", Eight_Key, 0x304C, 15);
+  addKey("9", Nine_Key, 0x324C, 15);
+  addKey("10", Zero_Key, 0x314C, 15);
+  addKey("+10", DoubleDigit_Key, 0x305C, 15);
+  addKey("CALL", Unmapped_Key, 0x31BC, 15);
+  addKey("PREV_TRACK", Previous_Key, 0x315C, 15);
+  addKey("NEXT_TRACK", Next_Key, 0x325C, 15);
+  addKey("BACK", Replay_Key, 0x30DC, 15);
+  addKey("FORWARD", Advance_Key, 0x335C, 15);
+  addKey("CLEAR", Clear_Key, 0x33EC, 15);
+  addKey("PROG", Program_Key, 0x303C, 15);
+  addKey("REPEAT", Repeat_Key, 0x323C, 15);
+  addKey("RANDOM", Random_Key, 0x333C, 15);
+  addKey("EDIT", Unmapped_Key, 0x33DC, 15);
+  addKey("ENTER", Select_Key, 0x31EC, 15);
+  addKey("TIME", Unmapped_Key, 0x30BC, 15);
+  addKey("CHAR", Unmapped_Key, 0x32EC, 15);
+  addKey("TITLE", Unmapped_Key, 0x32BC, 15);
+}
+
+
+DenonAudio5::DenonAudio5(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 5",
+      Denon_Make,
+      index)
+{
+  addControlledDevice(Denon_Make, "D-G1MD", Audio_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x4040, 16);
+
+  addKey("fm/am", Unmapped_Key, 0x00FF, 16);
+  addKey("tape", Unmapped_Key, 0x10EF, 16);
+  addKey("cd", Unmapped_Key, 0x08F7, 16);
+  addKey("md", Unmapped_Key, 0x02FD, 16);
+  addKey("aux", Unmapped_Key, 0x18E7, 16);
+  addKey("rds", Unmapped_Key, 0x807F, 16);
+  addKey("pty", Unmapped_Key, 0x906F, 16);
+  addKey("ct", Unmapped_Key, 0x8877, 16);
+  addKey("rt", Unmapped_Key, 0x9867, 16);
+  addKey("fmmode", Unmapped_Key, 0x827D, 16);
+  addKey("1", One_Key, 0x40BF, 16);
+  addKey("2", Two_Key, 0x50AF, 16);
+  addKey("3", Three_Key, 0x48B7, 16);
+  addKey("4", Four_Key, 0x58A7, 16);
+  addKey("5", Five_Key, 0x42BD, 16);
+  addKey("6", Six_Key, 0xC03F, 16);
+  addKey("7", Seven_Key, 0xD02F, 16);
+  addKey("8", Eight_Key, 0xC837, 16);
+  addKey("9", Nine_Key, 0xD827, 16);
+  addKey("0", Zero_Key, 0xC23D, 16);
+  addKey("+10", DoubleDigit_Key, 0x20DF, 16);
+  addKey("+100", PlusOneHundred_Key, 0x30CF, 16);
+  addKey("clock", Unmapped_Key, 0x28D7, 16);
+  addKey("timer", Unmapped_Key, 0x38C7, 16);
+  addKey("sleep", Sleep_Key, 0x22DD, 16);
+  addKey("set", Unmapped_Key, 0xA25D, 16);
+  addKey("mdrec", Unmapped_Key, 0xA05F, 16);
+  addKey("pickrec", Unmapped_Key, 0xB04F, 16);
+  addKey("checkspace", Unmapped_Key, 0xA857, 16);
+  addKey("clear", Clear_Key, 0xB847, 16);
+  addKey("enter", Enter_Key, 0x629D, 16);
+  addKey("recmute", Unmapped_Key, 0x609F, 16);
+  addKey("revmode", Unmapped_Key, 0x708F, 16);
+  addKey("dolby", Unmapped_Key, 0x6897, 16);
+  addKey("5modesrs", Surround_Key, 0xE21D, 16);
+  addKey("edit", Unmapped_Key, 0xE01F, 16);
+  addKey("editcancel", Unmapped_Key, 0xF00F, 16);
+  addKey("titleinput", Unmapped_Key, 0x7887, 16);
+  addKey("titlesearch", Unmapped_Key, 0x12ED, 16);
+  addKey("edit", Unmapped_Key, 0xE01F, 16);
+  addKey("repeat", Repeat_Key, 0x52AD, 16);
+  addKey("random", Random_Key, 0xD22D, 16);
+  addKey("prog", Program_Key, 0xE817, 16);
+  addKey("vol-", VolumeDown_Key, 0xF807, 16);
+  addKey("vol+", VolumeUp_Key, 0x926D, 16);
+  addKey("power", Power_Key, 0x32CD, 16);
+  addKey("mute", Mute_Key, 0xF20D, 16);
+  addKey("bass", Unmapped_Key, 0x0AF5, 16);
+  addKey("eqmode", Unmapped_Key, 0x728D, 16);
+  addKey("timedisp", Info_Key, 0xB24D, 16);
+  addKey("forward", FastForward_Key, 0x8A75, 16);
+  addKey("prev", Previous_Key, 0x4AB5, 16);
+  addKey("stop", Stop_Key, 0xEA15, 16);
+  addKey("next", Next_Key, 0xCA35, 16);
+  addKey("backward", Rewind_Key, 0x6A95, 16);
+}
diff --git a/keysets/denon.h b/keysets/denon.h
new file mode 100644 (file)
index 0000000..6b76d9a
--- /dev/null
@@ -0,0 +1,183 @@
+#ifndef DENON_H
+#define DENON_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class DenonDVD1: public PIRKeysetMetaData
+{
+public:
+  DenonDVD1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonDVD2: public PIRKeysetMetaData
+{
+public:
+  DenonDVD2(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonDVD3: public PIRKeysetMetaData
+{
+public:
+  DenonDVD3(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver1: public PIRKeysetMetaData
+{
+public:
+  DenonReceiver1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver1a: public DenonReceiver1
+{
+public:
+  DenonReceiver1a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver1b: public DenonReceiver1
+{
+public:
+  DenonReceiver1b(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver1c: public DenonReceiver1
+{
+public:
+  DenonReceiver1c(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver2: public PIRKeysetMetaData
+{
+public:
+  DenonReceiver2(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver2a: public DenonReceiver2
+{
+public:
+  DenonReceiver2a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver3: public PIRKeysetMetaData
+{
+public:
+  DenonReceiver3(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver3a: public DenonReceiver3
+{
+public:
+  DenonReceiver3a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver4: public PIRKeysetMetaData
+{
+public:
+  DenonReceiver4(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonReceiver5: public PIRKeysetMetaData
+{
+public:
+  DenonReceiver5(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio1: public PIRKeysetMetaData
+{
+public:
+  DenonAudio1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio1a: public DenonAudio1
+{
+public:
+  DenonAudio1a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio1b: public DenonAudio1
+{
+public:
+  DenonAudio1b(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio1c: public DenonAudio1b
+{
+public:
+  DenonAudio1c(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio1d: public DenonAudio1
+{
+public:
+  DenonAudio1d(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio2: public PIRKeysetMetaData
+{
+public:
+  DenonAudio2(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio3: public PIRKeysetMetaData
+{
+public:
+  DenonAudio3(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio4: public PIRKeysetMetaData
+{
+public:
+  DenonAudio4(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class DenonAudio5: public PIRKeysetMetaData
+{
+public:
+  DenonAudio5(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+#endif // DENON_H
index 7314628..29685a2 100644 (file)
@@ -21,14 +21,14 @@ EiKeyset::EiKeyset(
     index,
     931, 836,
     969,
-    113205, 2);
+    113205, true);
 
   threadableProtocol = rp;
 
-  rp->setPreData(0x10, 5);
-
   rp->setToggleBit(2);
 
+  setPreData(0x10, 5);
+
   addKey("i", Unmapped_Key, 0x35, 8);
   addKey("a", Unmapped_Key, 0x37, 8);
   addKey("b", Unmapped_Key, 0x36, 8);
index 32e7323..b3d344a 100644 (file)
@@ -12,20 +12,9 @@ GoldStarTV1::GoldStarTV1(
 {
   addControlledDevice(GoldStar_Make, "105-210A", TV_Device);
 
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    10800, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x20DF, 16);
+  setPreData(0x20DF, 16);
 
   addKey("power", Power_Key, 0x10EF, 16);
   addKey("mute", Mute_Key, 0x906F, 16);
@@ -46,7 +35,6 @@ GoldStarTV1::GoldStarTV1(
   addKey("volup", VolumeUp_Key, 0x40BF, 16);
   addKey("voldown", VolumeDown_Key, 0xC03F, 16);
   addKey("ok", Select_Key, 0x22DD, 16);
-//  addKey("ok", Enter_Key, 0x22DD, 16);
   addKey("prup", Up_Key, 0x00FF, 16);
   addKey("voldown", Left_Key, 0xC03F, 16);
   addKey("volup", Right_Key, 0x40BF, 16);
@@ -77,7 +65,7 @@ GoldStarTV2::GoldStarTV2(
 
   threadableProtocol = rp;
 
-  rp->setPreData(0x40, 7);
+  setPreData(0x40, 7);
 
   rp->setToggleBit(2);
 
@@ -133,20 +121,9 @@ GoldStarVCR1::GoldStarVCR1(
   addControlledDevice(GoldStar_Make, "GSE-Q204P", VCR_Device);
   addControlledDevice(GoldStar_Make, "QUISY 500", VCR_Device);
 
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    108000, true);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0x7689, 16);
+  setPreData(0x7689, 16);
 
   addKey("power", Power_Key, 0x28D7, 16);
   addKey("eject", Eject_Key, 0x00FF, 16);
@@ -269,8 +246,8 @@ GoldStarCD1::GoldStarCD1(
   np->setRepeatPair(600, 1600);
   np->setRepeatNeedsHeader(true);
 
-  np->setPreData(0x0808, 16);
-  np->setPostData(0x1, 1);
+  setPreData(0x0808, 16);
+  setPostData(0x1, 1);
 
   addKey("power", Power_Key, 0x3C43, 15);
   addKey("mute", Mute_Key, 0x7C03, 15);
index b451f38..92f076d 100644 (file)
 #include "hauppauge.h"
 #include "rc5protocol.h"
 
-HauppaugeGeneric::HauppaugeGeneric(
+HauppaugePCTV1::HauppaugePCTV1(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "Generic Remote",
+      "PCTV Keyset 1",
       Hauppauge_Make,
       index)
 {
+  addControlledDevice(Hauppauge_Make, "PVR 350", Computer_Device);
+
   RC5Protocol *rp = new RC5Protocol(
     guiObject,
     index,
-    950, 820,     // biphase pulse
-    1000,         // lead pulse
+    900, 900,     // biphase pulse
+    900,         // lead pulse
     114000, true); // constant-length gap
 
   threadableProtocol = rp;
 
-  rp->setPreData(0x17, 5);
-
   rp->setToggleBit(2);
 
-  addKey("Power", Power_Key, 0xBD, 8);
-  addKey("Go", Unmapped_Key, 0xBB, 8);
-  addKey("TV", Unmapped_Key, 0x9C, 8);
-  addKey("Videos", Unmapped_Key, 0x98, 8);
-  addKey("Music", Unmapped_Key, 0x99, 8);
-  addKey("Pictures", Unmapped_Key, 0x9A, 8);
-  addKey("Guide", Unmapped_Key, 0x9B, 8);
-  addKey("Radio", Unmapped_Key, 0x8C, 8);
-  addKey("Up", Up_Key, 0x94, 8);
-  addKey("Down", Down_Key, 0x95, 8);
-  addKey("Left", Left_Key, 0x96, 8);
-  addKey("Right", Right_Key, 0x97, 8);
-  addKey("Ok", Enter_Key, 0xA5, 8);
-  addKey("Ok", Select_Key, 0xA5, 8);
-  addKey("Back/Exit", Exit_Key, 0x9F, 8);
-  addKey("Menu/i", Menu_Key, 0x8D, 8);
-  addKey("Vol+", VolumeUp_Key, 0x90, 8);
-  addKey("Vol-", VolumeDown_Key, 0x91, 8);
-  addKey("Prev.Ch", PrevChannel_Key, 0x92, 8);
-  addKey("Mute", Mute_Key, 0x8F, 8);
-  addKey("Ch+", ChannelUp_Key, 0xA0, 8);
-  addKey("Ch-", ChannelDown_Key, 0xA1, 8);
-  addKey("Record", Record_Key, 0xB7, 8);
-  addKey("Stop", Stop_Key, 0xB6, 8);
-  addKey("Rewind", Rewind_Key, 0xB2, 8);
-  addKey("Play", Play_Key, 0xB5, 8);
-  addKey("Forward", FastForward_Key, 0xB4, 8);
-  addKey("Replay/SkipBackward", Replay_Key, 0xA4, 8);
-  addKey("Pause", Pause_Key, 0xB0, 8);
-  addKey("SkipForward", Advance_Key, 0x9E, 8);
-  addKey("1", One_Key, 0x81, 8);
-  addKey("2", Two_Key, 0x82, 8);
-  addKey("3", Three_Key, 0x83, 8);
-  addKey("4", Four_Key, 0x84, 8);
-  addKey("5", Five_Key, 0x85, 8);
-  addKey("6", Six_Key, 0x86, 8);
-  addKey("7", Seven_Key, 0x87, 8);
-  addKey("8", Eight_Key, 0x88, 8);
-  addKey("9", Nine_Key, 0x89, 8);
-  addKey("0", Zero_Key, 0x80, 8);
-  addKey("Asterix", Unmapped_Key, 0x8A, 8);
-  addKey("sub/cc", Captions_Key, 0x8E, 8);
-  addKey("Red", Red_Key, 0x8B, 8);
-  addKey("Green", Green_Key, 0xAE, 8);
-  addKey("Yellow", Yellow_Key, 0xB8, 8);
-  addKey("Blue", Blue_Key, 0xA9, 8);
+  setPreData(0x5E, 7);
+
+  addKey("Power", Power_Key, 0x3D, 6);
+  addKey("Go", Unmapped_Key, 0x3B, 6);
+  addKey("TV", Unmapped_Key, 0x1C, 6);
+  addKey("Videos", Unmapped_Key, 0x18, 6);
+  addKey("Music", Unmapped_Key, 0x19, 6);
+  addKey("Pictures", Unmapped_Key, 0x1A, 6);
+  addKey("Guide", Unmapped_Key, 0x1B, 6);
+  addKey("Radio", Unmapped_Key, 0x0C, 6);
+  addKey("Up", Up_Key, 0x14, 6);
+  addKey("Down", Down_Key, 0x15, 6);
+  addKey("Left", Left_Key, 0x16, 6);
+  addKey("Right", Right_Key, 0x17, 6);
+  addKey("Ok", Select_Key, 0x25, 6);
+  addKey("Back/Exit", Exit_Key, 0x1F, 6);
+  addKey("Menu/i", Menu_Key, 0x0D, 6);
+  addKey("Vol+", VolumeUp_Key, 0x10, 6);
+  addKey("Vol-", VolumeDown_Key, 0x11, 6);
+  addKey("Prev.Ch", PrevChannel_Key, 0x12, 6);
+  addKey("Mute", Mute_Key, 0x0F, 6);
+  addKey("Ch+", ChannelUp_Key, 0x20, 6);
+  addKey("Ch-", ChannelDown_Key, 0x21, 6);
+  addKey("Record", Record_Key, 0x37, 6);
+  addKey("Stop", Stop_Key, 0x36, 6);
+  addKey("Rewind", Rewind_Key, 0x32, 6);
+  addKey("Play", Play_Key, 0x35, 6);
+  addKey("Forward", FastForward_Key, 0x34, 6);
+  addKey("Replay/SkipBackward", Replay_Key, 0x24, 6);
+  addKey("Pause", Pause_Key, 0x30, 6);
+  addKey("SkipForward", Advance_Key, 0x1E, 6);
+  addKey("0", Zero_Key, 0x00, 6);
+  addKey("1", One_Key, 0x01, 6);
+  addKey("2", Two_Key, 0x02, 6);
+  addKey("3", Three_Key, 0x03, 6);
+  addKey("4", Four_Key, 0x04, 6);
+  addKey("5", Five_Key, 0x05, 6);
+  addKey("6", Six_Key, 0x06, 6);
+  addKey("7", Seven_Key, 0x07, 6);
+  addKey("8", Eight_Key, 0x08, 6);
+  addKey("9", Nine_Key, 0x09, 6);
+  addKey("Asterix", Unmapped_Key, 0x0A, 6);
+  addKey("sub/cc", Captions_Key, 0x0E, 6); // "Recordings"
+  addKey("Red", Red_Key, 0x0B, 6);
+  addKey("Green", Green_Key, 0x2E, 6);
+  addKey("Yellow", Yellow_Key, 0x38, 6);
+  addKey("Blue", Blue_Key, 0x29, 6);
+}
+
+
+HauppaugePCTV1a::HauppaugePCTV1a(
+  QObject *guiObject,
+  unsigned int index)
+  : HauppaugePCTV1(guiObject, index)
+{
+  setKeysetName("PCTV Keyset 1a");
+
+  addControlledDevice(Hauppauge_Make, "WinTV-HVR-950Q", Computer_Device);
+
+  setPreData(0x5D, 7);
+}
+
+
+HauppaugePCTV1b::HauppaugePCTV1b(
+  QObject *guiObject,
+  unsigned int index)
+  : HauppaugePCTV1(guiObject, index)
+{
+  setKeysetName("PCTV Keyset 1b");
+
+  addControlledDevice(Hauppauge_Make, "MVP", Computer_Device);
+
+  setPreData(0x43, 7);
+
+  addKey("KEY_FN_1", Unmapped_Key, 0x0C, 6);
+  addKey("KEY_FN_2", Unmapped_Key, 0x3C, 6);
+}
+
+
+HauppaugePCTV1c::HauppaugePCTV1c(
+  QObject *guiObject,
+  unsigned int index)
+  : HauppaugePCTV1(guiObject, index)
+{
+  setKeysetName("PCTV Keyset 1c");
+
+  addControlledDevice(Hauppauge_Make, "PVR 250", Computer_Device);
+//  addControlledDevice(Hauppauge_Make, "PVR 350", Computer_Device);
+
+  setPreData(0x5F, 7);
+
+  addKey("blank", Unmapped_Key, 0x0C, 6);
+  addKey("full", Unmapped_Key, 0x3C, 6);
 }
 
 
 // Based on LIRC Sony_RM-V302-DVD010 config file
-HauppaugeTV1::HauppaugeTV1(
+HauppaugePCTV2::HauppaugePCTV2(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "TV Keyset 1",
+      "PCTV Keyset 2",
       Hauppauge_Make,
       index)
 {
-  addControlledDevice(Hauppauge_Make, "PVR-250", TV_Device);
+  addControlledDevice(Hauppauge_Make, "PVR-250", Computer_Device);
 
   RC5Protocol *rp = new RC5Protocol(
     guiObject,
     index,
-    889, 889,
-    889,
-    113792, true);
+    900, 900,
+    900,
+    114000, true);
 
   threadableProtocol = rp;
 
@@ -127,3 +174,32 @@ HauppaugeTV1::HauppaugeTV1(
   addKey("STOP", Stop_Key, 0x1520, 13);
 }
 
+
+/*
+// Translation of DSR-0095 config file
+HauppaugePCTV3::HauppaugePCTV3(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "PCTV Keyset 3",
+      Hauppauge_Make,
+      index)
+{
+  RC5Protocol *rp = new RC5Protocol(
+    guiObject,
+    index,
+    900, 900,
+    900,
+    114000, true);
+
+  threadableProtocol = rp;
+
+  rp->setToggleBit(2);
+
+  rp->setPreData(0x17, 5);
+
+  addKey("home", Unmapped_Key, 0x7B, 8);
+  addKey("choice", Unmapped_Key, 0x5B, 8);
+  addKey("stop", Stop_Key, 0x77, 8);
+}
+*/
index 9d9295c..d53509b 100644 (file)
@@ -2,22 +2,44 @@
 #define HAUPPAUGE_H
 
 #include "pirkeysetmetadata.h"
-
 #include <QObject>
 
-class HauppaugeGeneric: public PIRKeysetMetaData
+class HauppaugePCTV1: public PIRKeysetMetaData
+{
+public:
+  HauppaugePCTV1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HauppaugePCTV1a: public HauppaugePCTV1
+{
+public:
+  HauppaugePCTV1a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HauppaugePCTV1b: public HauppaugePCTV1
 {
 public:
-  HauppaugeGeneric(
+  HauppaugePCTV1b(
     QObject *guiObject,
     unsigned int index);
 };
 
+class HauppaugePCTV1c: public HauppaugePCTV1
+{
+public:
+  HauppaugePCTV1c(
+    QObject *guiObject,
+    unsigned int index);
+};
 
-class HauppaugeTV1: public PIRKeysetMetaData
+class HauppaugePCTV2: public PIRKeysetMetaData
 {
 public:
-  HauppaugeTV1(
+  HauppaugePCTV2(
     QObject *guiObject,
     unsigned int index);
 };
diff --git a/keysets/hitachi.cpp b/keysets/hitachi.cpp
new file mode 100644 (file)
index 0000000..bfbf2ef
--- /dev/null
@@ -0,0 +1,343 @@
+#include "hitachi.h"
+#include "necprotocol.h"
+
+HitachiTV1::HitachiTV1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 1",
+      Hitachi_Make,
+      index)
+{
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x0AF5, 16);
+
+  addKey("1", One_Key, 0xB04F, 16);
+  addKey("2", Two_Key, 0x708F, 16);
+  addKey("3", Three_Key, 0xF00F, 16);
+  addKey("4", Four_Key, 0x38C7, 16);
+  addKey("5", Five_Key, 0xB847, 16);
+  addKey("6", Six_Key, 0x7887, 16);
+  addKey("7", Seven_Key, 0xF807, 16);
+  addKey("8", Eight_Key, 0x20DF, 16);
+  addKey("9", Nine_Key, 0xA05F, 16);
+  addKey("0", Zero_Key, 0x30CF, 16);
+  addKey("ch_down", ChannelDown_Key, 0x18E7, 16);
+  addKey("ch_up", ChannelUp_Key, 0x9867, 16);
+  addKey("recall", PrevChannel_Key, 0x08F7, 16);
+  addKey("tv/video", Input_Key, 0x906F, 16); // "AV"
+  addKey("power", Power_Key, 0xE817, 16);
+  addKey("vol_up", VolumeUp_Key, 0x48B7, 16);
+  addKey("vol_down", VolumeDown_Key, 0xA857, 16);
+  addKey("timer", Sleep_Key, 0x8877, 16);
+  addKey("return", Exit_Key, 0x22DD, 16);
+  addKey("mute", Mute_Key, 0xD02F, 16);
+  addKey("krasn", Unmapped_Key, 0xDA25, 16);
+  addKey("zelen", Unmapped_Key, 0x7A85, 16);
+  addKey("Reveal", Unmapped_Key, 0xBA45, 16); // "jolt"
+  addKey("zelen", Unmapped_Key, 0x3AC5, 16);
+  addKey("OK", Select_Key, 0xC23D, 16);
+  addKey("FWD", FastForward_Key, 0xF609, 16);
+  addKey("REV", Rewind_Key, 0xB649, 16);
+  addKey("PLAY", Play_Key, 0xD629, 16);
+  addKey("STOP", Stop_Key, 0x36C9, 16);
+  addKey("HELP", Info_Key, 0x58A7, 16);
+  addKey("CH", Unmapped_Key, 0xC837, 16);
+  addKey("MENU", Menu_Key, 0x02FD, 16);
+  addKey("PSCAN100HZ", Unmapped_Key, 0xB24D, 16);
+  addKey("X", Unmapped_Key, 0x2AD5, 16);
+  addKey("3D-SOUND", Surround_Key, 0xD827, 16);
+  addKey("UP", Up_Key, 0x0EF1, 16);
+  addKey("DOWN", Down_Key, 0x8E71, 16);
+  addKey("CH_I/II", Unmapped_Key, 0x10EF, 16);
+  addKey("TV/TEXT", Unmapped_Key, 0x6699, 16);
+  addKey("SOUND", SoundMode_Key, 0xF20D, 16);
+  addKey("Picture", PictureMode_Key, 0xE619, 16);
+  addKey("Red", Red_Key, 0x32CD, 16);
+  addKey("SUB", Unmapped_Key, 0xA25D, 16);
+  addKey("U.N.L", Unmapped_Key, 0x629D, 16);
+  addKey("HOLD", Unmapped_Key, 0xE21D, 16);
+  addKey("Cancel", Clear_Key, 0x16E9, 16);
+  addKey("Store", Unmapped_Key, 0x28D7, 16);
+  addKey("Language", Language_Key, 0x609F, 16);
+}
+
+
+HitachiTV1a::HitachiTV1a(
+  QObject *guiObject,
+  unsigned int index)
+  : HitachiTV1(guiObject, index)
+{
+  setKeysetName("TV Keyset 1a");
+
+  addKey("menu", Menu_Key, 0xCA35, 16);
+}
+
+HitachiTV1b::HitachiTV1b(
+  QObject *guiObject,
+  unsigned int index)
+  : HitachiTV1a(guiObject, index)
+{
+  setKeysetName("TV Keyset 1b");
+
+  addKey("Sound+", VolumeUp_Key, 0x4EB1, 16);
+  addKey("Sound-", VolumeDown_Key, 0xCE31, 16);
+  addKey("Timer", Sleep_Key, 0xD629, 16);
+}
+
+
+HitachiTV1c::HitachiTV1c(
+  QObject *guiObject,
+  unsigned int index)
+  : HitachiTV1(guiObject, index)
+{
+  setKeysetName("TV Keyset 1c");
+
+  addControlledDevice(Hitachi_Make, "57F510", TV_Device);
+
+  addKey("LastChannel", PrevChannel_Key, 0x50AF, 16);
+  addKey("Info", Info_Key, 0x08F7, 16);
+  addKey("Input1", Unmapped_Key, 0x847B, 16);
+  addKey("Input2", Unmapped_Key, 0x44BB, 16);
+  addKey("Input3", Unmapped_Key, 0xC43B, 16);
+  addKey("Input4", Unmapped_Key, 0x24DB, 16);
+  addKey("ChannelUp", Unmapped_Key, 0x14EB, 16); // these four are odd
+  addKey("ChannelDown", Unmapped_Key, 0x946B, 16); // duplicate?
+  addKey("VolumeDown", Unmapped_Key, 0x54AB, 16); // maybe pip?
+  addKey("VolumeUp", Unmapped_Key, 0xD42B, 16); // doesn't make sense
+  addKey("SELECT", Select_Key, 0x748B, 16);
+  addKey("CC", Captions_Key, 0xEC13, 16);
+  addKey("FavouriteChannel", Favorites_Key, 0x1CE3, 16);
+  addKey("1080i/540p", Unmapped_Key, 0x3CC3, 16);
+  addKey("Input5", Unmapped_Key, 0xBC43, 16);
+  addKey("PowerON", Unmapped_Key, 0x7C83, 16);
+  addKey("PowerOFF", Unmapped_Key, 0xFC03, 16);
+  addKey("Menu", Menu_Key, 0xCA35, 16);
+  addKey("PIP", PIP_Key, 0x1AE5, 16);
+  addKey("Day/Night", Unmapped_Key, 0x7A85, 16);
+  addKey("Freeze/Pause", Unmapped_Key, 0x8679, 16);
+  addKey("EXIT", Exit_Key, 0x26D9, 16);
+  addKey("16:9", Unmapped_Key, 0xA659, 16);
+  addKey("16:9Zoom", Unmapped_Key, 0x6699, 16);
+  addKey("4:3Standard", Unmapped_Key, 0xE619, 16);
+  addKey("4:3Expanded", Unmapped_Key, 0x16E9, 16);
+  addKey("4:3Zoom1", Unmapped_Key, 0x9669, 16);
+  addKey("4:3Zoom2", Unmapped_Key, 0x56A9, 16);
+  addKey("540p", Unmapped_Key, 0xD629, 16);
+  addKey("1080i", Unmapped_Key, 0x36C9, 16);
+  addKey("Aspect", AspectRatio_Key, 0xF609, 16);
+  addKey("ArrowRight", Right_Key, 0x4EB1, 16);
+  addKey("ArrowLeft", Left_Key, 0xCE31, 16);
+  addKey("DayMode", Unmapped_Key, 0x2ED1, 16);
+  addKey("NightMode", Unmapped_Key, 0xAE51, 16);
+  addKey("AntennaA", Unmapped_Key, 0x6E91, 16);
+  addKey("AntennaB", Unmapped_Key, 0xEE11, 16);
+  addKey("CC", Unmapped_Key, 0x1EE1, 16); // Another CC key?
+  addKey("Guide", Guide_Key, 0xAC53, 16);
+  // Many more codes available in LIRC's hitachi/CLU4341UG2 config file
+}
+
+
+HitachiProjector::HitachiProjector(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Projector Keyset",
+      Hitachi_Make,
+      index)
+{
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0xE1A2, 16);
+
+  addKey("Power", Power_Key, 0xE817, 16);
+  addKey("PageUp", Unmapped_Key, 0x0BF4, 16);
+  addKey("PageDown", Unmapped_Key, 0x8B74, 16);
+  addKey("Home", Unmapped_Key, 0xAB54, 16);
+  addKey("End", Unmapped_Key, 0x6B94, 16);
+  addKey("Enter", Select_Key, 0x847B, 16);
+  addKey("Left", Left_Key, 0x748B, 16);
+  addKey("Right", Right_Key, 0x54AB, 16);
+  addKey("Up", Up_Key, 0x14EB, 16);
+  addKey("Down", Down_Key, 0x34CB, 16);
+  addKey("Menu", Menu_Key, 0x04FB, 16);
+  addKey("Reset", Reset_Key, 0x44BB, 16);
+  addKey("Esc", Unmapped_Key, 0x2BD4, 16);
+  addKey("Position", Unmapped_Key, 0x0CF3, 16);
+  addKey("Freeze", Unmapped_Key, 0x2DD2, 16);
+  addKey("Keystone", Unmapped_Key, 0x6D92, 16);
+  addKey("Search", Unmapped_Key, 0x58A7, 16);
+  addKey("RGB", PictureMode_Key, 0x18E7, 16);
+  addKey("Video", Unmapped_Key, 0x9867, 16);
+  addKey("Aspect", AspectRatio_Key, 0x5EA1, 16);
+  addKey("MagnifyOn", Unmapped_Key, 0x0DF2, 16);
+  addKey("MagnifyOff", Unmapped_Key, 0xCD32, 16);
+  addKey("Volume", Unmapped_Key, 0xCA35, 16);
+  addKey("Mute", Mute_Key, 0x4AB5, 16);
+  addKey("Auto", Unmapped_Key, 0x24DB, 16);
+  addKey("Blank", Unmapped_Key, 0x827D, 16);
+}
+
+
+HitachiDVD1::HitachiDVD1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Hitachi_Make,
+      index)
+{
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x01C4, 16);
+
+  addKey("Power", Power_Key, 0x50AF, 16);
+  addKey("Surround", Surround_Key, 0xBA45, 16);
+  addKey("SearchMode", Unmapped_Key, 0x7C83, 16);
+  addKey("OpenClose", Eject_Key, 0x906F, 16);
+  addKey("ABRepeat", Unmapped_Key, 0x04FB, 16);
+  addKey("1", One_Key, 0xB04F, 16);
+  addKey("2", Two_Key, 0x708F, 16);
+  addKey("3", Three_Key, 0xF00F, 16);
+  addKey("4", Four_Key, 0x38C7, 16);
+  addKey("5", Five_Key, 0xB847, 16);
+  addKey("6", Six_Key, 0x7887, 16);
+  addKey("7", Seven_Key, 0xF807, 16);
+  addKey("8", Eight_Key, 0x20DF, 16);
+  addKey("9", Nine_Key, 0xA05F, 16);
+  addKey("0", Zero_Key, 0x30CF, 16);
+  addKey("Repeat", Unmapped_Key, 0x00FF, 16);
+  addKey("Mode", Unmapped_Key, 0xB44B, 16);
+  addKey("Zoom", Unmapped_Key, 0xDC23, 16);
+  addKey("Clear", Clear_Key, 0x9867, 16);
+  addKey("+10", DoubleDigit_Key, 0x08F7, 16);
+  addKey("Angle", Unmapped_Key, 0x54AB, 16);
+  addKey("Subtitle", Captions_Key, 0xD42B, 16);
+  addKey("Audio", Language_Key, 0x34CB, 16);
+  addKey("Display", Info_Key, 0xD02F, 16);
+  addKey("Menu", DiscMenu_Key, 0xE01F, 16);
+  addKey("TopMenu", DiscTitle_Key, 0x609F, 16);
+  addKey("Up", Up_Key, 0x44BB, 16);
+  addKey("Left", Left_Key, 0x24DB, 16);
+  addKey("Enter", Select_Key, 0x649B, 16);
+  addKey("Right", Right_Key, 0xA45B, 16);
+  addKey("Down", Down_Key, 0xC43B, 16);
+  addKey("Return", Exit_Key, 0xE41B, 16);
+  addKey("Setup", Menu_Key, 0x10EF, 16);
+  addKey("DiscNav", Guide_Key, 0x4CB3, 16);
+  addKey("Prev", Previous_Key, 0xC03F, 16);
+  addKey("Next", Next_Key, 0x40BF, 16);
+  addKey("Stop", Stop_Key, 0xD827, 16);
+  addKey("Play", Play_Key, 0x28D7, 16);
+  addKey("Rew", Rewind_Key, 0x48B7, 16);
+  addKey("Pause", Pause_Key, 0x58A7, 16);
+  addKey("FF", FastForward_Key, 0x8877, 16);
+}
+
+
+HitachiAudio1::HitachiAudio1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 1",
+      Hitachi_Make,
+      index)
+{
+  addControlledDevice(Hitachi_Make, "FX-7", Audio_Device);
+  addControlledDevice(Hitachi_Make, "FX-77", Audio_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0xDA25, 16);
+
+  addKey("1", One_Key, 0xB24D, 16);
+  addKey("2", Two_Key, 0x728D, 16);
+  addKey("3", Three_Key, 0xF20D, 16);
+  addKey("4", Four_Key, 0x0AF5, 16);
+  addKey("5", Five_Key, 0x8A75, 16);
+  addKey("6", Six_Key, 0x4AB5, 16);
+  addKey("7", Seven_Key, 0xCA35, 16);
+  addKey("8", Eight_Key, 0x2AD5, 16);
+  addKey("9", Nine_Key, 0xAA55, 16);
+  addKey("10", Unmapped_Key, 0x6A95, 16);
+  addKey("0/11", Zero_Key, 0xDA25, 16);
+  addKey("10+/12", DoubleDigit_Key, 0xEA15, 16);
+  addKey("CD_SKIP_BACK", Previous_Key, 0xA857, 16);
+  addKey("CD_SKIP_FWD", Next_Key, 0x28D7, 16);
+  addKey("CD_STOP", Stop_Key, 0xC837, 16);
+  addKey("CD_PLAY/PAUSE", Play_Key, 0x48B7, 16);
+  addKey("CD_PLAY/PAUSE", Pause_Key, 0x48B7, 16);
+  addKey("CD_PROG", Program_Key, 0x6897, 16);
+  addKey("CASSETTE_PLAY_BACK", Unmapped_Key, 0x58A7, 16);
+  addKey("CASSETTE_STOP", Unmapped_Key, 0xB847, 16);
+  addKey("CASSETTE_PLAY_FORWARD", Unmapped_Key, 0x9867, 16);
+  addKey("CASSETTE_REC", Record_Key, 0xF807, 16);
+  addKey("CASSETTE_TAPE_1/2", Unmapped_Key, 0x906F, 16);
+  addKey("CASSETTE_REW", Unmapped_Key, 0x38C7, 16);
+  addKey("CASSETTE_FFW", Unmapped_Key, 0xD827, 16);
+  addKey("VOLUME_DOWN", VolumeDown_Key, 0x40BF, 16);
+  addKey("VOLUME_UP", VolumeUp_Key, 0x807F, 16);
+  addKey("TUNER_BAND", Input_Key, 0xE01F, 16);
+  addKey("POWER", Power_Key, 0x00FF, 16);
+}
+
+
+HitachiVCR1::HitachiVCR1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "VCR Keyset 1",
+      Hitachi_Make,
+      index)
+{
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x06F9, 16);
+
+  addKey("Power", Power_Key, 0xE817, 16);
+  addKey("Eject", Eject_Key, 0x9C63, 16);
+  addKey("VCR/TV", Input_Key, 0x6897, 16);
+  addKey("P+", ChannelUp_Key, 0x9867, 16);
+  addKey("P-", ChannelDown_Key, 0x18E7, 16);
+  addKey("Play", Play_Key, 0x28D7, 16);
+  addKey("FF", FastForward_Key, 0x906F, 16);
+  addKey("Rew", Rewind_Key, 0x50AF, 16);
+  addKey("Stop", Stop_Key, 0xD02F, 16);
+  addKey("Pause", Pause_Key, 0x58A7, 16);
+  addKey("Step", StepForward_Key, 0x08F7, 16);
+  addKey("SpinRight", Right_Key, 0xFE01, 16);
+  addKey("SpinLeft", Left_Key, 0x7E81, 16);
+  addKey("Enter", Select_Key, 0x22DD, 16);
+  addKey("TransAux", Unmapped_Key, 0x2CD3, 16); // "AVX"
+  addKey("1", One_Key, 0xB04F, 16);
+  addKey("2", Two_Key, 0x708F, 16);
+  addKey("3", Three_Key, 0xF00F, 16);
+  addKey("4", Four_Key, 0x38C7, 16);
+  addKey("5", Five_Key, 0xB847, 16);
+  addKey("6", Six_Key, 0x7887, 16);
+  addKey("7", Seven_Key, 0xF807, 16);
+  addKey("8", Eight_Key, 0x20DF, 16);
+  addKey("9", Nine_Key, 0xA05F, 16);
+  addKey("0", Zero_Key, 0x30CF, 16);
+  addKey("Menu", Menu_Key, 0x02FD, 16);
+  addKey("Disp", Info_Key, 0x42BD, 16);
+  addKey("Index", Unmapped_Key, 0xA25D, 16);
+  addKey("SP/LP", VHSSpeed_Key, 0x0CF3, 16);
+  addKey("Count/Clock", Unmapped_Key, 0x629D, 16);
+  addKey("CLEAR", Reset_Key, 0x827D, 16); // "reset", "0000"
+  addKey("Slow", Unmapped_Key, 0x8877, 16);
+  addKey("CH1/2", Unmapped_Key, 0xA857, 16); // "CHANNEL"
+  addKey("A.DUB", Unmapped_Key, 0x34CB, 16);
+  addKey("V.DUB", Unmapped_Key, 0x5CA3, 16);
+  addKey("Tracking+", TrackingPlus_Key, 0x00FF, 16);
+  addKey("Tracking-", TrackingMinus_Key, 0x807F, 16);
+  addKey("100/ENT", PlusOneHundred_Key, 0x609F, 16);
+  addKey("-", Unmapped_Key, 0xC03F, 16);
+  addKey("+", Unmapped_Key, 0x40BF, 16);
+  addKey("GO-TO", Unmapped_Key, 0x619E, 16);
+  addKey("FRAME+", Unmapped_Key, 0xBE41, 16); // This is for jog/shuttle!
+  addKey("FRAME-", Unmapped_Key, 0x7E81, 16); // I'll get the other j/s later
+  // For more Jog/Shuttle see LIRC hitachi/VT-RM783E
+  addKey("tracking_auto", AutoTracking_Key, 0x7C83, 16);
+}
diff --git a/keysets/hitachi.h b/keysets/hitachi.h
new file mode 100644 (file)
index 0000000..0011f12
--- /dev/null
@@ -0,0 +1,71 @@
+#ifndef HITACHI_H
+#define HITACHI_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class HitachiTV1: public PIRKeysetMetaData
+{
+public:
+  HitachiTV1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiTV1a: public HitachiTV1
+{
+public:
+  HitachiTV1a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiTV1b: public HitachiTV1a
+{
+public:
+  HitachiTV1b(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiTV1c: public HitachiTV1
+{
+public:
+  HitachiTV1c(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiProjector: public PIRKeysetMetaData
+{
+public:
+  HitachiProjector(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiDVD1: public PIRKeysetMetaData
+{
+public:
+  HitachiDVD1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiAudio1: public PIRKeysetMetaData
+{
+public:
+  HitachiAudio1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class HitachiVCR1: public PIRKeysetMetaData
+{
+public:
+  HitachiVCR1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+#endif // HITACHI_H
index 79f1433..034c948 100644 (file)
@@ -88,14 +88,14 @@ JVCSat2::JVCSat2(
   np->setHeaderPair(525, 6045);
   np->setTrailerPulse(450);
 
-  np->setPostData(0x000, 10);
-
 //  np->setMinimumRepetitions(6);
   np->setFullHeadlessRepeat(true);
 
   np->setCarrierFrequency(56000);
   np->setDutyCycle(32);
 
+  setPostData(0x000, 10);
+
   addKey("info", Info_Key, 0x0, 6);
   addKey("power_on", Unmapped_Key, 0x1, 6);
   addKey("power", Power_Key, 0x2, 6);
@@ -153,7 +153,7 @@ JVCVCR1::JVCVCR1(
 
   np->setTrailerPulse(600);
 
-  np->setPreData(0xC2, 8);
+  setPreData(0xC2, 8);
 
   addKey("power", Power_Key, 0xD0, 8);
   addKey("play", Play_Key, 0x30, 8);
@@ -254,8 +254,7 @@ JVCVCR1b::JVCVCR1b(
 {
   setKeysetName("VCR (alt) keyset 1b");
 
-  NECProtocol *np = dynamic_cast<NECProtocol *>(threadableProtocol);
-  np->setPreData(0xCA, 8);
+  setPreData(0xCA, 8);
 }
 
 
@@ -294,7 +293,7 @@ JVCVCR2::JVCVCR2(
   np->setTrailerPulse(600);
   np->setFullHeadlessRepeat(true);
 
-  np->setPreData(0xC2, 8);
+  setPreData(0xC2, 8);
 
   addKey("power", Power_Key, 0xD0, 8);
   addKey("play", Play_Key, 0x30, 8);
@@ -391,8 +390,7 @@ JVCVCR2b::JVCVCR2b(
 {
   setKeysetName("VCR (alt) keyset 2b");
 
-  NECProtocol *np = dynamic_cast<NECProtocol *>(threadableProtocol);
-  np->setPreData(0xCA, 8);
+  setPreData(0xCA, 8);
 }
 
 
@@ -426,7 +424,7 @@ JVCTV1::JVCTV1(
 
   np->setTrailerPulse(600);
 
-  np->setPreData(0xC0, 8);
+  setPreData(0xC0, 8);
 
   addKey("Power", Power_Key, 0xE8, 8);
   addKey("Vol+", VolumeUp_Key, 0x78, 8);
@@ -570,7 +568,7 @@ JVCTV2::JVCTV2(
   np->setTrailerPulse(600);
   np->setFullHeadlessRepeat(true);
 
-  np->setPreData(0xC0, 8);
+  setPreData(0xC0, 8);
 
   addKey("Power", Power_Key, 0xE8, 8);
   addKey("Vol+", VolumeUp_Key, 0x78, 8);
@@ -708,7 +706,7 @@ JVCDAT1::JVCDAT1(
 
   np->setFullHeadlessRepeat(true);
 
-  np->setPreData(0xC9, 8);
+  setPreData(0xC9, 8);
 
   addKey("1", One_Key, 0x84, 8);
   addKey("2", Two_Key, 0x44, 8);
@@ -763,7 +761,7 @@ JVCCarDeck1::JVCCarDeck1(
 
   np->setFullHeadlessRepeat(true);
 
-  np->setPreData(0xF1, 8);
+  setPreData(0xF1, 8);
 
   addKey("Power", Power_Key, 0x71, 8); // "Att"
   addKey("Sound", Mute_Key, 0xB1, 8); // "SCM"
@@ -949,7 +947,7 @@ JVCPortableAudio2::JVCPortableAudio2(
 
   np->setFullHeadlessRepeat(true);
 
-  np->setPreData(0xF9, 8);
+  setPreData(0xF9, 8);
 
   addKey("stop", Stop_Key, 0x8E, 8); // "CD_STOP" "stop_clear"
   addKey("stop", Clear_Key, 0x8E, 8); // "CD_STOP" "stop_clear"
index e7495fc..b6cc8cc 100644 (file)
@@ -11,22 +11,9 @@ LGTV1::LGTV1(
       LG_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    107753, true);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x20DF, 16);
-
-//  np->setMinimumRepetitions(2);
+  setPreData(0x20DF, 16);
 
   addKey("power", Power_Key, 0x10EF, 16);
   addKey("input", Input_Key, 0xD02F, 16);
@@ -170,10 +157,10 @@ LGTV2::LGTV2(
 
   threadableProtocol = rp;
 
-  rp->setPreData(0x10, 5);
-
   rp->setToggleBit(2);
 
+  setPreData(0x10, 5);
+
   addKey("POWER", Power_Key, 0x0C, 8);
   addKey("DRP", Unmapped_Key, 0x14, 8);
   addKey("TVAV", Unmapped_Key, 0x38, 8);
@@ -271,7 +258,7 @@ LGDisc1::LGDisc1(
   np->setRepeatPair(531, 1710);
   np->setRepeatNeedsHeader(true);
 
-  np->setPreData(0x3434, 16);
+  setPreData(0x3434, 16);
 
 //  np->setMinimumRepetitions(1);
 
@@ -360,7 +347,7 @@ LGDisc2::LGDisc2(
   np->setRepeatPair(600, 550);
   np->setRepeatNeedsHeader(true);
 
-  np->setPreData(0xB4B4, 16);
+  setPreData(0xB4B4, 16);
 
 //  np->setMinimumRepetitions(3);
 
@@ -441,20 +428,9 @@ LGVCR1::LGVCR1(
       LG_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 550,
-    600, 1650,
-    107753, true);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0x7689, 16);
+  setPreData(0x7689, 16);
 
   addKey("power", Power_Key, 0x28D7, 16);
   addKey("rew", Rewind_Key, 0x40BF, 16);
index f3a38e5..a808ba9 100644 (file)
@@ -20,10 +20,10 @@ MitsubishiTV1::MitsubishiTV1(
 
   np->setTrailerPulse(300);
 
-  np->setPreData(0xE2, 8);
-
 //  np->setMinimumRepetitions(1);
 
+  setPreData(0xE2, 8);
+
   addKey("POWER", Power_Key, 0x40, 8);
   addKey("0", Zero_Key, 0x90, 8);
   addKey("1", One_Key, 0x00, 8);
@@ -124,10 +124,10 @@ MitsubishiVCR1::MitsubishiVCR1(
 
   np->setTrailerPulse(300);
 
-  np->setPreData(0xEA, 8);
-
 //  np->setMinimumRepetitions(1);
 
+  setPreData(0xEA, 8);
+
   addKey("POWER", Power_Key, 0x40, 8);
   addKey("CH-", ChannelDown_Key, 0x48, 8);
   addKey("CH+", ChannelUp_Key, 0x50, 8);
index 92d1735..83aa5c9 100644 (file)
@@ -22,7 +22,7 @@ NokiaGenericVCR::NokiaGenericVCR(
 
 //  np->setMinimumRepetitions(3);
 
-  np->setPreData(0x6, 3);
+  setPreData(0x6, 3);
 
   addKey("Power", Power_Key, 0x1A2, 12);
   addKey("1", One_Key, 0x202, 12);
index 7075ee6..ab0da88 100644 (file)
@@ -21,12 +21,12 @@ PanasonicAmp::PanasonicAmp(
   np->setHeaderPair(4000, 1600);
   np->setTrailerPulse(400);
 
-  np->setPreData(0x80080A86, 32);
-
 //  np->setMinimumRepetitions(4);
 
   np->setCarrierFrequency(36000);
 
+  setPreData(0x80080A86, 32);
+
   addKey("POWER", Power_Key, 0xFDBB, 16);
   addKey("VOL+", VolumeUp_Key, 0x0D4B, 16);
   addKey("VOL-", VolumeDown_Key, 0x4DCB, 16);
@@ -55,7 +55,7 @@ PanasonicCarAudio::PanasonicCarAudio(
   np->setHeaderPair(9148, 4424);
   np->setTrailerPulse(667);
 
-  np->setPreData(0x8156, 16);
+  setPreData(0x8156, 16);
 
   addKey("Power", Power_Key, 0x48B7, 16);
   addKey("PRG", Unmapped_Key, 0x38C7, 16);
@@ -88,7 +88,7 @@ PanasonicSat1::PanasonicSat1(
   np->setHeaderPair(3565, 1700);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x40040140, 32);
+  setPreData(0x40040140, 32);
 
   addKey("POWER", Power_Key, 0xBDFC, 16);
   addKey("CH+", ChannelUp_Key, 0xEDAC, 16);
@@ -164,10 +164,10 @@ PanasonicTV1::PanasonicTV1(
   np->setHeaderPair(3500, 1700);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x400401, 24);
-
 //  np->setMinRepeat(1);
 
+  setPreData(0x400401, 24);
+
   addKey("POWER", Power_Key, 0x00BCBD, 24);
   addKey("MUTE", Mute_Key, 0x004C4D, 24);
   addKey("PICTURE", Unmapped_Key, 0x006061, 24);
@@ -295,7 +295,7 @@ PanasonicVCR1::PanasonicVCR1(
   np->setHeaderPair(3600, 1650);
   np->setTrailerPulse(550);
 
-  np->setPreData(0x400409, 24);
+  setPreData(0x400409, 24);
 
   addKey("POWER", Power_Key, 0x00BCB5, 24);
   addKey("PROGRAMME^", ChannelUp_Key, 0x002C25, 24);
@@ -448,7 +448,7 @@ PanasonicDVD1::PanasonicDVD1(
   np->setHeaderPair(3500, 1650);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x40040D00, 32);
+  setPreData(0x40040D00, 32);
 
   addKey("POWER", Power_Key, 0xBCB1, 16);
   addKey("PLAY", Play_Key, 0x505D, 16);
@@ -567,10 +567,10 @@ PanasonicAudio1::PanasonicAudio1(
   np->setHeaderPair(4000, 1600);
   np->setTrailerPulse(400);
 
-  np->setPreData(0x40040543, 32);
-
 //  np->setMinimumRepetitions(1);
 
+  setPreData(0x40040543, 32);
+
   addKey("power", Power_Key, 0xFDBB, 16);
   addKey("tape", Unmapped_Key, 0x3573, 16);
   addKey("1", One_Key, 0x094F, 16);
diff --git a/keysets/pinnacle.cpp b/keysets/pinnacle.cpp
new file mode 100644 (file)
index 0000000..c8bd921
--- /dev/null
@@ -0,0 +1,172 @@
+#include "pinnacle.h"
+#include "rc5protocol.h"
+
+PinnaclePCTV1::PinnaclePCTV1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "PCTV Keyset 1",
+      Pinnacle_Make,
+      index)
+{
+  addControlledDevice(Pinnacle_Make, "800i", Computer_Device);
+
+  RC5Protocol *rp = new RC5Protocol(
+    guiObject,
+    index,
+    900, 900,
+    900,
+    114000, true);
+
+  threadableProtocol = rp;
+
+  rp->setToggleBit(2);
+
+  setPreData(0x11, 5);
+
+  addKey("key_mute", Mute_Key, 0xC0, 8);
+  addKey("key_menu", Menu_Key, 0xC1, 8);
+  addKey("key_power", Power_Key, 0xF9, 8);
+  addKey("key_volumeup", VolumeUp_Key, 0xC3, 8);
+  addKey("key_volumedown", VolumeDown_Key, 0xC9, 8);
+  addKey("key_channelup", ChannelUp_Key, 0xC6, 8);
+  addKey("key_channeldown", ChannelDown_Key, 0xCC, 8);
+  addKey("btn_1", One_Key, 0xCF, 8);
+  addKey("btn_2", Two_Key, 0xD5, 8);
+  addKey("btn_3", Three_Key, 0xD0, 8);
+  addKey("btn_4", Four_Key, 0xD8, 8);
+  addKey("btn_5", Five_Key, 0xDB, 8);
+  addKey("btn_6", Six_Key, 0xDE, 8);
+  addKey("btn_7", Seven_Key, 0xD1, 8);
+  addKey("btn_8", Eight_Key, 0xE1, 8);
+  addKey("btn_9", Nine_Key, 0xD2, 8);
+  addKey("btn_0", Zero_Key, 0xE7, 8);
+  addKey("key_screen", Unmapped_Key, 0xE4, 8);
+  addKey("key_t", Unmapped_Key, 0xEA, 8);
+  addKey("key_rewind", Rewind_Key, 0xED, 8);
+  addKey("key_playpause", Play_Key, 0xF0, 8);
+  addKey("key_playpause", Pause_Key, 0xF0, 8);
+  addKey("key_fastforward", FastForward_Key, 0xF3, 8);
+  addKey("key_record", Record_Key, 0xF6, 8);
+  addKey("key_stop", Stop_Key, 0xFC, 8);
+  addKey("key_question", Unmapped_Key, 0xFF, 8);
+}
+
+
+PinnaclePCTV2::PinnaclePCTV2(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "PCTV Keyset 2",
+      Pinnacle_Make,
+      index)
+{
+  addControlledDevice(Pinnacle_Make, "USB Stick", Computer_Device);
+
+  RC5Protocol *rp = new RC5Protocol(
+    guiObject,
+    index,
+    900, 900,
+    900,
+    114000, true);
+
+  threadableProtocol = rp;
+
+  rp->setToggleBit(2);
+
+  setPreData(0x11, 5);
+
+  addKey("play-pause", Play_Key, 0xC6, 8);
+  addKey("play-pause", Pause_Key, 0xC6, 8);
+  addKey("stop", Stop_Key, 0xC5, 8);
+  addKey("exit", Exit_Key, 0xC3, 8);
+  addKey("screen", Unmapped_Key, 0xC2, 8);
+  addKey("rew", Rewind_Key, 0xC4, 8);
+  addKey("ff", FastForward_Key, 0xC7, 8);
+  addKey("mute", Mute_Key, 0xC0, 8);
+  addKey("volup", VolumeUp_Key, 0xCB, 8);
+  addKey("voldown", VolumeDown_Key, 0xCF, 8);
+  addKey("ask", Unmapped_Key, 0xD4, 8);
+  addKey("m", Unmapped_Key, 0xD6, 8);
+  addKey("chup", ChannelUp_Key, 0xD3, 8);
+  addKey("chdown", ChannelDown_Key, 0xD7, 8);
+  addKey("rec", Record_Key, 0xC1, 8);
+  addKey("1", One_Key, 0xC8, 8);
+  addKey("2", Two_Key, 0xC9, 8);
+  addKey("3", Three_Key, 0xCA, 8);
+  addKey("4", Four_Key, 0xCC, 8);
+  addKey("5", Five_Key, 0xCD, 8);
+  addKey("6", Six_Key, 0xCE, 8);
+  addKey("7", Seven_Key, 0xD0, 8);
+  addKey("8", Eight_Key, 0xD1, 8);
+  addKey("9", Nine_Key, 0xD2, 8);
+  addKey("0", Zero_Key, 0xD5, 8);
+}
+
+
+PinnaclePCTV3::PinnaclePCTV3(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "PCTV Keyset 3",
+      Pinnacle_Make,
+      index)
+{
+  addControlledDevice(Pinnacle_Make, "110i", Computer_Device);
+
+  RC5Protocol *rp = new RC5Protocol(
+    guiObject,
+    index,
+    900, 900,
+    900,
+    114000, true);
+
+  threadableProtocol = rp;
+
+  rp->setToggleBit(2);
+
+  setPreData(0x11, 5);
+
+  addKey("MUTE", Mute_Key, 0xC1, 8);
+  addKey("POWER", Power_Key, 0xF9, 8);
+  addKey("CTVERECSETREMIRADKY", Unmapped_Key, 0xE5, 8);
+  addKey("TV", Unmapped_Key, 0xE6, 8);
+  addKey("EPG", Guide_Key, 0xE7, 8);
+  addKey("A_RED", Red_Key, 0xC3, 8);
+  addKey("B_GREEN", Green_Key, 0xC4, 8);
+  addKey("C_YELLOW", Yellow_Key, 0xC5, 8);
+  addKey("OTAZNIK_BLUE", Blue_Key, 0xC6, 8);
+  addKey("VOL_PLUS", VolumeUp_Key, 0xE8, 8);
+  addKey("VOL_MINUS", VolumeDown_Key, 0xE9, 8);
+  addKey("PINNACLE", Unmapped_Key, 0xF3, 8);
+  addKey("CH_PLUS", ChannelUp_Key, 0xC8, 8);
+  addKey("CH_MINUS", ChannelDown_Key, 0xC9, 8);
+  addKey("UP", Up_Key, 0xCA, 8);
+  addKey("LEFT", Left_Key, 0xCC, 8);
+  addKey("OK", Select_Key, 0xF6, 8);
+  addKey("RIGHT", Right_Key, 0xCD, 8);
+  addKey("DOWN", Down_Key, 0xCB, 8);
+  addKey("BACK", Exit_Key, 0xF0, 8);
+  addKey("JUMP", PrevChannel_Key, 0xEA, 8);
+  addKey("CTVERECVECTVERCI", Unmapped_Key, 0xC2, 8);
+  addKey("PAUSE", Pause_Key, 0xE1, 8);
+  addKey("RED_IN_THE_MIDDLE", Record_Key, 0xFF, 8);
+  addKey("PREV", Rewind_Key, 0xE0, 8);
+  addKey("PLAY", Play_Key, 0xEB, 8);
+  addKey("FFORWARD", FastForward_Key, 0xE2, 8);
+  addKey("BEGINNING", Previous_Key, 0xE3, 8);
+  addKey("STOP", Stop_Key, 0xFC, 8);
+  addKey("END", Next_Key, 0xE4, 8);
+  addKey("1", One_Key, 0xCE, 8);
+  addKey("2", Two_Key, 0xCF, 8);
+  addKey("3", Three_Key, 0xD1, 8);
+  addKey("4", Four_Key, 0xD2, 8);
+  addKey("5", Five_Key, 0xD4, 8);
+  addKey("6", Six_Key, 0xD5, 8);
+  addKey("7", Seven_Key, 0xD7, 8);
+  addKey("8", Eight_Key, 0xD8, 8);
+  addKey("9", Nine_Key, 0xDA, 8);
+  addKey("0", Zero_Key, 0xDD, 8);
+  addKey("CAPS_NUM", Unmapped_Key, 0xDB, 8);
+  addKey("DEL", Unmapped_Key, 0xDE, 8);
+}
diff --git a/keysets/pinnacle.h b/keysets/pinnacle.h
new file mode 100644 (file)
index 0000000..4fcb8e6
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef PINNACLE_H
+#define PINNACLE_H
+
+#include "pirkeysetmetadata.h"
+#include <QObject>
+
+class PinnaclePCTV1: public PIRKeysetMetaData
+{
+public:
+  PinnaclePCTV1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class PinnaclePCTV2: public PIRKeysetMetaData
+{
+public:
+  PinnaclePCTV2(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class PinnaclePCTV3: public PIRKeysetMetaData
+{
+public:
+  PinnaclePCTV3(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+#endif // PINNACLE_H
index 3e50bf8..2f7fdff 100644 (file)
@@ -9,20 +9,9 @@ RaiteDVD1::RaiteDVD1(
       Raite_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    107823, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x04FB, 16);
+  setPreData(0x04FB, 16);
 
   addKey("mute", Mute_Key, 0xC03F, 16);
   addKey("1", One_Key, 0xC837, 16);
index fef8bb4..9d6189d 100644 (file)
@@ -21,10 +21,10 @@ RCATV1::RCATV1(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0xF, 4);
-
 //  np->setMinimumRepetitions(1);
 
+  setPreData(0xF, 4);
+
   addKey("vol-left", VolumeDown_Key, 0x2E0D1, 20);
   addKey("vol-right", VolumeUp_Key, 0x2F0D0, 20);
   addKey("mute", Mute_Key, 0x3F0C0, 20);
@@ -108,7 +108,7 @@ RCATV2::RCATV2(
   np->setHeaderPair(17355, 3978);
   np->setTrailerPulse(897);
 
-  np->setPreData(0xF, 4);
+  setPreData(0xF, 4);
 
   addKey("off", Unmapped_Key, 0x3B0C4, 20);
   addKey("on", Unmapped_Key, 0x3A0C5, 20);
@@ -157,7 +157,7 @@ RCAAux1::RCAAux1(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x4, 4);
+  setPreData(0x4, 4);
 
   addKey("aux1_power", Power_Key, 0x2ABD5, 20);
   addKey("skip", Advance_Key, 0x53BAC, 20);
@@ -219,7 +219,7 @@ RCAAux2::RCAAux2(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0xC, 4);
+  setPreData(0xC, 4);
 
   addKey("aux-on-off", Power_Key, 0x3B3C4, 20);
   addKey("aux-mute", Mute_Key, 0x3F3C0, 20);
@@ -297,10 +297,10 @@ RCAVCR1::RCAVCR1(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0xE, 4);
-
 //  np->setMinimumRepetitions(1);
 
+  setPreData(0xE, 4);
+
   addKey("vcr1-on-off", Power_Key, 0x2A1D5, 20);
   addKey("vcr1-who", Unmapped_Key, 0x6119E, 20);
   addKey("vcr1-ch+", ChannelUp_Key, 0x2D1D2, 20);
@@ -363,7 +363,7 @@ RCAVCR2::RCAVCR2(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0xD, 4);
+  setPreData(0xD, 4);
 
   addKey("vcr2-on-off", Power_Key, 0x2A2D5, 20);
   addKey("vcr2-who", Unmapped_Key, 0x6129E, 20);
@@ -423,7 +423,7 @@ RCADVD1::RCADVD1(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x5, 4);
+  setPreData(0x5, 4);
 
   addKey("dvd-on-off", Power_Key, 0x2AAD5, 20);
   addKey("dvd-who", Unmapped_Key, 0x61A9E, 20);
@@ -500,7 +500,7 @@ RCASat1::RCASat1(
   np->setHeaderPair(4000, 4000);
   np->setTrailerPulse(500);
 
-  np->setPreData(0x7, 4);
+  setPreData(0x7, 4);
 
   addKey("on-off", Power_Key, 0x2A8D5, 20);
   addKey("who", Unmapped_Key, 0x6189E, 20); // "cc", "-"
@@ -565,14 +565,14 @@ RCASat2::RCASat2(
   np->setHeaderPair(525, 6045);
   np->setTrailerPulse(450);
 
-  np->setPostData(0x000, 10);
-
 //  np->setMinimumRepetitions(6);
   np->setFullHeadlessRepeat(true);
 
   np->setCarrierFrequency(56000);
   np->setDutyCycle(32);
 
+  setPostData(0x000, 10);
+
   addKey("info", Info_Key, 0x0, 6);
   addKey("power_on", Unmapped_Key, 0x1, 6);
   addKey("power", Power_Key, 0x2, 6);
index 1ffe6e1..87d1db8 100644 (file)
@@ -9,22 +9,9 @@ SagemTVBox1::SagemTVBox1(
       Sagem_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    108000, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-//  np->setMinimumRepetitions(1);
-
-  np->setPreData(0xE17A, 16);
+  setPreData(0xE17A, 16);
 
   addKey("Power", Power_Key, 0x48B7, 16);
   addKey("P+", ChannelUp_Key, 0x08F7, 16);
index 5400d72..e4f26e0 100644 (file)
@@ -12,6 +12,7 @@ SamsungTV1::SamsungTV1(
 {
   addControlledDevice(Samsung_Make, "SyncMaster 192MP", TV_Device);
   addControlledDevice(Samsung_Make, "LN32C530F1FXZA", TV_Device);
+  addControlledDevice(Samsung_Make, "UE46B6000VPXZG", TV_Device); // ?
 
   NECProtocol *np = new NECProtocol(
     guiObject,
@@ -25,7 +26,7 @@ SamsungTV1::SamsungTV1(
   np->setHeaderPair(4500, 4500);
   np->setTrailerPulse(600);
 
-  np->setPreData(0xE0E0, 16);
+  setPreData(0xE0E0, 16);
 
   addKey("Power", Power_Key, 0x40BF, 16);
   addKey("Channel Up", ChannelUp_Key, 0x48B7, 16);
@@ -279,7 +280,7 @@ SamsungVCR1::SamsungVCR1(
   np->setHeaderPair(4500, 4500);
   np->setTrailerPulse(600);
 
-  np->setPreData(0xA0A0, 16);
+  setPreData(0xA0A0, 16);
 
   addKey("Power", Power_Key, 0x40BF, 16);
   addKey("Eject", Eject_Key, 0x04FB, 16);
@@ -496,7 +497,7 @@ SamsungDVD1::SamsungDVD1(
   np->setTrailerPulse(600);
   np->setRepeatPair(9000, 4500);
 
-  np->setPreData(0x198133F, 26);
+  setPreData(0x198133F, 26);
 
   addKey("power", Power_Key, 0x8976, 16);
   addKey("open_close", Eject_Key, 0x31CE, 16);
@@ -599,7 +600,7 @@ SamsungDVD2::SamsungDVD2(
   np->setHeaderPair(4500, 4500);
   np->setTrailerPulse(600);
 
-  np->setPreData(0xC2CA, 16);
+  setPreData(0xC2CA, 16);
 
   addKey("1", One_Key, 0x827D, 16);
   addKey("2", Two_Key, 0x42BD, 16);
@@ -678,7 +679,7 @@ SamsungAC1::SamsungAC1(
   np->setHeaderPair(4500, 4500);
   np->setTrailerPulse(600);
 
-  np->setPreData(0x804, 12);
+  setPreData(0x804, 12);
 
 //  np->setMinimumRepetitions(1);
 
index 8875b67..bd70260 100644 (file)
@@ -6,29 +6,17 @@ SanyoVCR1::SanyoVCR1(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "VCR Keyset 1",
+      "VCR(/DVD) Keyset 1",
       Sanyo_Make,
       index)
 {
   addControlledDevice(Sanyo_Make, "DVW-5000", VCR_Device);
   addControlledDevice(Sanyo_Make, "DVW-5000", DVD_Device);
 
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    627, 500,  // values for zero
-    627, 1626, // values for one
-    108754, true); // constant-length gap
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
+  setPreData(0x8C73, 16);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(626);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x8C73, 16);
-
-  // Add keys:
   addKey("Power", Power_Key, 0xDA25, 16);
   addKey("1", One_Key, 0x20DF, 16);
   addKey("2", Two_Key, 0xA05F, 16);
@@ -77,6 +65,67 @@ SanyoVCR1::SanyoVCR1(
 }
 
 
+SanyoDVD1::SanyoDVD1(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Sanyo_Make,
+      index)
+{
+  addControlledDevice(Sanyo_Make, "DVD-SL25", DVD_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x3C23, 16);
+
+  addKey("On", Power_Key, 0x00FF, 16);
+  addKey("LastMemo", Unmapped_Key, 0xF40B, 16);
+  addKey("PictureMode", PictureMode_Key, 0x5CA3, 16);
+  addKey("OpenClose", Eject_Key, 0x807F, 16);
+  addKey("ProgramRandom", Random_Key, 0x9C63, 16);
+  addKey("Repeat", Repeat_Key, 0xAC53, 16);
+  addKey("ABRepeat", Unmapped_Key, 0x6C93, 16);
+  addKey("OnScreen", Unmapped_Key, 0xC03F, 16);
+  addKey("Zoom", Unmapped_Key, 0xDC23, 16);
+  addKey("Angle", Unmapped_Key, 0x10EF, 16);
+  addKey("AngleReplay", Unmapped_Key, 0x906F, 16);
+  addKey("SubtitleChange", Unmapped_Key, 0xA05F, 16);
+  addKey("Setup", Menu_Key, 0x40BF, 16);
+  addKey("Menu", DiscMenu_Key, 0xE01F, 16);
+  addKey("SubtitleOnOff", Captions_Key, 0x52AD, 16);
+  addKey("Audio", Language_Key, 0x50AF, 16);
+  addKey("Up", Up_Key, 0xD02F, 16);
+  addKey("Down", Down_Key, 0x30CF, 16);
+  addKey("Left", Left_Key, 0xB04F, 16);
+  addKey("Right", Right_Key, 0x708F, 16);
+  addKey("Enter", Select_Key, 0xF00F, 16);
+  addKey("TopMenu", DiscTitle_Key, 0x609F, 16);
+  addKey("Return", Exit_Key, 0x08F7, 16);
+  addKey("RevSlow", StepBack_Key, 0x34CB, 16);
+  addKey("FwdSlow", StepForward_Key, 0x946B, 16);
+  addKey("PauseStep", Pause_Key, 0x04FB, 16);
+  addKey("Stop", Stop_Key, 0x7887, 16);
+  addKey("Play", Play_Key, 0xF807, 16);
+  addKey("Prev", Previous_Key, 0x44BB, 16);
+  addKey("Next", Next_Key, 0x847B, 16);
+  addKey("Rev", Rewind_Key, 0x649B, 16);
+  addKey("Fwd", FastForward_Key, 0xC43B, 16);
+  addKey("1", One_Key, 0x8877, 16);
+  addKey("2", Two_Key, 0x48B7, 16);
+  addKey("3", Three_Key, 0xC837, 16);
+  addKey("4", Four_Key, 0x28D7, 16);
+  addKey("5", Five_Key, 0xA857, 16);
+  addKey("6", Six_Key, 0x6897, 16);
+  addKey("7", Seven_Key, 0xE817, 16);
+  addKey("8", Eight_Key, 0x18E7, 16);
+  addKey("9", Nine_Key, 0x9867, 16);
+  addKey("0", Zero_Key, 0x58A7, 16);
+  addKey("Clear", Clear_Key, 0x38C7, 16);
+  addKey("SearchMode", Unmapped_Key, 0x1CE3, 16);
+}
+
+
 SanyoTV1::SanyoTV1(
   QObject *guiObject,
   unsigned int index)
@@ -85,117 +134,169 @@ SanyoTV1::SanyoTV1(
       Sanyo_Make,
       index)
 {
-  addControlledDevice(Sanyo_Make, "DP32746", TV_Device);
-
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 1600,  // zero
-    600, 500,   // one
-    40000, false);  // gap, not constant length
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0xE31C, 16);
-
-  addKey("Power", Power_Key, 0xB748, 16);
-//  addKey("audio_mode", Language_Key, 0xC738, 16);  // might be wrong
-  addKey("1", One_Key, 0x7F80, 16);
-  addKey("2", Two_Key, 0xBF40, 16);
-  addKey("3", Three_Key, 0x3FC0, 16);
-  addKey("4", Four_Key, 0xDF20, 16);
-  addKey("5", Five_Key, 0x5FA0, 16);
-  addKey("6", Six_Key, 0x9F60, 16);
-  addKey("7", Seven_Key, 0x1FE0, 16);
-  addKey("8", Eight_Key, 0xEF10, 16);
-  addKey("9", Nine_Key, 0x6F90, 16);
-  addKey("0", Zero_Key, 0xFF00, 16);
-  addKey("Channel Up", ChannelUp_Key, 0xAF50, 16);
-  addKey("Channel Down", ChannelDown_Key, 0x2FD0, 16);
-  addKey("Volume Up", VolumeUp_Key, 0x8F70, 16);
-  addKey("Volume Down", VolumeDown_Key, 0x0FF0, 16);
-  addKey("Mute", Mute_Key, 0xE718, 16);
-  addKey("Display", Info_Key, 0xCF30, 16);
-  addKey("Menu", Menu_Key, 0x17E8, 16);
-//  addKey("Enter", Enter_Key, 0xA758, 16);
-  addKey("Enter", Select_Key, 0xA758, 16);
-  addKey("Closed Captions", Captions_Key, 0x7788, 16);
-  addKey("Video Mode", Input_Key, 0x37C8, 16);
-  addKey("Sleep", Sleep_Key, 0x4FB0, 16);
-  addKey("Recall", PrevChannel_Key, 0x6798, 16);
-  addKey("PIP", PIP_Key, 0x25DA, 16);
-  addKey("Swap", PIPSwap_Key, 0x45BA, 16);
-  addKey("Red", Red_Key, 0x6D92, 16);
-  addKey("Green", Green_Key, 0xAD52, 16);
-  addKey("Yellow", Yellow_Key, 0x2DD2, 16);
-  addKey("Blue", Blue_Key, 0xCD32, 16);
-  addKey("Reset", Reset_Key, 0xC738, 16);
-  addKey("Menu +", Up_Key, 0x8778, 16); // menu +
-  addKey("Menu -", Down_Key, 0x07F8, 16); // menu - 
-//  addKey("image", AspectRatio_Key, 0x7788, 16);
-  addKey("Digicon", Guide_Key, 0x47B8, 16);
+  addControlledDevice(Sanyo_Make, "CTP-6791P", TV_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x1CE3, 16);
+
+  addKey("Power", Power_Key, 0x48B7, 16);
+  addKey("audio_mode", SoundMode_Key, 0x38C7, 16); // "auto"
+  addKey("video_mode", PictureMode_Key, 0xC837, 16);
+  addKey("1", One_Key, 0x807F, 16);
+  addKey("2", Two_Key, 0x40BF, 16);
+  addKey("3", Three_Key, 0xC03F, 16);
+  addKey("4", Four_Key, 0x20DF, 16);
+  addKey("5", Five_Key, 0xA05F, 16);
+  addKey("6", Six_Key, 0x609F, 16);
+  addKey("7", Seven_Key, 0xE01F, 16);
+  addKey("8", Eight_Key, 0x10EF, 16);
+  addKey("9", Nine_Key, 0x906F, 16);
+  addKey("0", Zero_Key, 0x00FF, 16);
+  addKey("Channel Up", ChannelUp_Key, 0x50AF, 16);
+  addKey("Channel Down", ChannelDown_Key, 0xD02F, 16);
+  addKey("Volume Up", VolumeUp_Key, 0x708F, 16);
+  addKey("Volume Down", VolumeDown_Key, 0xF00F, 16);
+  addKey("Mute", Mute_Key, 0x18E7, 16);
+  addKey("Display", Info_Key, 0x30CF, 16);
+  addKey("image", AspectRatio_Key, 0x8877, 16);
+  addKey("Menu", Menu_Key, 0xE817, 16); // "setup"
+  addKey("Enter", Select_Key, 0x58A7, 16); // "F/OK"
+  addKey("Sleep", Sleep_Key, 0xB04F, 16);
+  addKey("Recall", PrevChannel_Key, 0x9867, 16);
+  addKey("PIP", PIP_Key, 0xDA25, 16);
+  addKey("Swap", PIPSwap_Key, 0xBA45, 16);
+  addKey("Red", Red_Key, 0x926D, 16);
+  addKey("Green", Green_Key, 0x52AD, 16);
+  addKey("Yellow", Yellow_Key, 0xD22D, 16);
+  addKey("Blue", Blue_Key, 0x32CD, 16);
+  addKey("Menu +", Up_Key, 0x7887, 16);
+  addKey("Menu -", Down_Key, 0xF807, 16);
+  addKey("Digicon", Guide_Key, 0xB847, 16);
+  addKey("TV", Input_Key, 0x28D7, 16); // tv/video
+}
+
+
+SanyoTV1a::SanyoTV1a(
+  QObject *guiObject,
+  unsigned int index)
+  : SanyoTV1(guiObject, index)
+{
+  setKeysetName("TV Keyset 1a");
+
+  addControlledDevice(Sanyo_Make, "28LN4-C", TV_Device);
+  addControlledDevice(Sanyo_Make, "28CN7F", TV_Device);
+  addControlledDevice(Sanyo_Make, "C21EF44", TV_Device);
+  addControlledDevice(Sanyo_Make, "C25EG64", TV_Device);
+  addControlledDevice(Sanyo_Make, "C28EH64", TV_Device);
+//  addControlledDevice(Sanyo_Make, "CED3011PV", TV_Device);
+//  addControlledDevice(Sanyo_Make, "CEM6011PV", TV_Device);
+//  addControlledDevice(Sanyo_Make, "DP32746", TV_Device);
+
+  addKey("POWER", Power_Key, 0x38C7, 16);
+  addKey("WIDE", AspectRatio_Key, 0xC23D, 16);
+  addKey("-/--", DoubleDigit_Key, 0x50AF, 16);
+  addKey("CS", Unmapped_Key, 0xD02F, 16); // 2-
+  addKey("OSD", Info_Key, 0x18E7, 16); // "SYMBOL_1
+  addKey("NORMAL", Unmapped_Key, 0x8877, 16); // "SYMBOL_2"
+  addKey("MUTE", Mute_Key, 0xA857, 16);
+  addKey("P--P", Unmapped_Key, 0xB847, 16); // "ALTERNATE"
+  addKey("MENU", Menu_Key, 0x8A75, 16);
+  addKey("P+", ChannelUp_Key, 0x30CF, 16);
+  addKey("UP", Up_Key, 0x30CF, 16);
+  addKey("P-", ChannelDown_Key, 0xB04F, 16);
+  addKey("DOWN", Down_Key, 0xB04F, 16);
+  addKey("VOL-", VolumeDown_Key, 0xE817, 16);
+  addKey("LEFT", Left_Key, 0xE817, 16);
+  addKey("VOL+", VolumeUp_Key, 0x6897, 16);
+  addKey("RIGHT", Right_Key, 0x6897, 16);
+  addKey("CLOCK", Sleep_Key, 0x9867, 16); // "SLEEP/ON-TIMER/TEXT_CANCEL"
+  addKey("EXPAND", Unmapped_Key, 0x6A95, 16); // "SYMBOL_4" teletext
+  addKey("SHRINK", Unmapped_Key, 0x728D, 16); // "SYMBOL_5" teletext
+  addKey("TXT/TV", Unmapped_Key, 0x629D, 16); // teletext
+  addKey("A-B", Language_Key, 0x02FD, 16); //?
+}
+
+
+SanyoTV1b::SanyoTV1b(
+  QObject *guiObject,
+  unsigned int index)
+  : SanyoTV1(guiObject, index)
+{
+  setKeysetName("TV Keyset 1b");
+
+  addKey("Reset", Reset_Key, 0x38C7, 16);
+  addKey("Closed Captions", Captions_Key, 0x8877, 16);
 }
 
 
-SanyoTV2::SanyoTV2(
+SanyoTV1c::SanyoTV1c(
+  QObject *guiObject,
+  unsigned int index)
+  : SanyoTV1(guiObject, index)
+{
+  setKeysetName("TV Keyset 1c");
+
+  addKey("tv/vid", Input_Key, 0xC837, 16);
+}
+
+
+SanyoTV1d::SanyoTV1d(
+  QObject *guiObject,
+  unsigned int index)
+  : SanyoTV1a(guiObject, index)
+{
+  setKeysetName("TV Keyset 1d");
+
+  addKey("prg_scan", Scan_Key, 0x08F7, 16);
+  addKey("tuning_<", ChannelDown_Key, 0xC837, 16);
+  addKey("tuning_>", ChannelUp_Key, 0x48B7, 16);
+  addKey("colour_<", Unmapped_Key, 0xD827, 16);
+  addKey("colour_>", Unmapped_Key, 0x58A7, 16);
+  addKey("bright_<", Unmapped_Key, 0xF807, 16);
+  addKey("bright_>", Unmapped_Key, 0x7887, 16);
+  addKey("contrast_<", Unmapped_Key, 0xF00F, 16);
+  addKey("contrast_>", Unmapped_Key, 0x708F, 16);
+  addKey("clear_screen", Unmapped_Key, 0x18E7, 16);
+}
+
+
+SanyoProjector::SanyoProjector(
   QObject *guiObject,
   unsigned int index)
   : PIRKeysetMetaData(
-      "TV Keyset 2",
+      "Projector Keyset 1",
       Sanyo_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 1600,
-    600, 500,
-    40000, false);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0xE31C, 16);
-
-  addKey("POWER", Power_Key, 0xC738, 16);
-  addKey("TV", Unmapped_Key, 0xD728, 16);
-  addKey("WIDE", AspectRatio_Key, 0x3DC2, 16);
-  addKey("1", One_Key, 0x7F80, 16);
-  addKey("2", Two_Key, 0xBF40, 16);
-  addKey("3", Three_Key, 0x3FC0, 16);
-  addKey("4", Four_Key, 0xDF20, 16);
-  addKey("5", Five_Key, 0x5FA0, 16);
-  addKey("6", Six_Key, 0x9F60, 16);
-  addKey("7", Seven_Key, 0x1FE0, 16);
-  addKey("8", Eight_Key, 0xEF10, 16);
-  addKey("9", Nine_Key, 0x6F90, 16);
-  addKey("0", Zero_Key, 0xFF00, 16);
-  addKey("-/--", DoubleDigit_Key, 0xAF50, 16);
-  addKey("CS", Unmapped_Key, 0x2FD0, 16);
-  addKey("SYMBOL_1", Unmapped_Key, 0xE718, 16);
-  addKey("SYMBOL_2", Unmapped_Key, 0x7788, 16);
-  addKey("MUTE", Mute_Key, 0x57A8, 16);
-  addKey("P--P", Unmapped_Key, 0x47B8, 16);
-  addKey("F/OK", Unmapped_Key, 0xA758, 16);
-  addKey("MENU", Menu_Key, 0x758A, 16);
-  addKey("VOL-", VolumeDown_Key, 0x17E8, 16);
-  addKey("VOL+", VolumeUp_Key, 0x9768, 16);
-  addKey("P+", ChannelUp_Key, 0xCF30, 16);
-  addKey("P-", ChannelDown_Key, 0x4FB0, 16);
-  addKey("RED", Red_Key, 0x6D92, 16);
-  addKey("GREEN", Green_Key, 0xAD52, 16);
-  addKey("YELLOW", Yellow_Key, 0x2DD2, 16);
-  addKey("BLUE", Blue_Key, 0xCD32, 16);
-  addKey("SYMBOL_3", Unmapped_Key, 0x6798, 16);
-  addKey("SYMBOL_4", Unmapped_Key, 0x956A, 16);
-  addKey("SYMBOL_5", Unmapped_Key, 0x8D72, 16);
-  addKey("TXT/TV", Unmapped_Key, 0x9D62, 16);
-  addKey("A-B", Language_Key, 0xFD02, 16);
+  addControlledDevice(Sanyo_Make, "PLV-Z1", Other_Device);
+
+  threadableProtocol = new NECProtocol(guiObject, index);
+
+  setPreData(0x0C, 8);
+
+  addKey("ONOFF0", Power_Key, 0xF300FF, 24);
+  addKey("ONOFF1", Unmapped_Key, 0x73FF00, 24);
+  addKey("AUTO_PC_ADJ", Unmapped_Key, 0xF3916E, 24);
+  addKey("MENU", Menu_Key, 0xF338C7, 24);
+  addKey("SCREEN", Unmapped_Key, 0xF341BE, 24);
+  addKey("INPUT", Input_Key, 0xF3A05F, 24);
+  addKey("IMAGE", Unmapped_Key, 0xF330CF, 24);
+  addKey("AUTO", Unmapped_Key, 0xF3FC03, 24);
+  addKey("COMPOSITE", Unmapped_Key, 0xF3BC43, 24);
+  addKey("S-VIDEO", Unmapped_Key, 0xF37C83, 24);
+  addKey("COMPONENT", Unmapped_Key, 0xF3C13E, 24);
+  addKey("NOSHOW", Unmapped_Key, 0xF3D12E, 24);
+  addKey("KEYSTONE_UP", Unmapped_Key, 0xF3718E, 24);
+  addKey("KEYSTONE_DOWN", Unmapped_Key, 0xF3F10E, 24);
+  addKey("IMAGE_1", One_Key, 0xF30AF5, 24);
+  addKey("IMAGE_2", Two_Key, 0xF38A75, 24);
+  addKey("IMAGE_3", Three_Key, 0xF36A95, 24);
+  addKey("IMAGE_4", Four_Key, 0xF3EA15, 24);
+  addKey("SELECT", Select_Key, 0xF3F00F, 24);
+  addKey("LEFT", Left_Key, 0xF37887, 24);
+  addKey("RIGHT", Right_Key, 0xF3B847, 24);
+  addKey("UP", Up_Key, 0xF331CE, 24);
+  addKey("DOWN", Down_Key, 0xF3B14E, 24);
 }
+
index c04360e..45bece9 100644 (file)
@@ -13,6 +13,14 @@ public:
     unsigned int index);
 };
 
+class SanyoDVD1: public PIRKeysetMetaData
+{
+public:
+  SanyoDVD1(
+    QObject *guiObject,
+    unsigned int index);
+};
+
 class SanyoTV1: public PIRKeysetMetaData
 {
 public:
@@ -21,10 +29,42 @@ public:
     unsigned int index);
 };
 
-class SanyoTV2: public PIRKeysetMetaData
+class SanyoTV1a: public SanyoTV1
+{
+public:
+  SanyoTV1a(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class SanyoTV1b: public SanyoTV1
+{
+public:
+  SanyoTV1b(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class SanyoTV1c: public SanyoTV1
+{
+public:
+  SanyoTV1c(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class SanyoTV1d: public SanyoTV1a
+{
+public:
+  SanyoTV1d(
+    QObject *guiObject,
+    unsigned int index);
+};
+
+class SanyoProjector: public PIRKeysetMetaData
 {
 public:
-  SanyoTV2(
+  SanyoProjector(
     QObject *guiObject,
     unsigned int index);
 };
index 186ce8e..f2fbe4f 100644 (file)
@@ -19,6 +19,8 @@ SharpTV1::SharpTV1(
 
   threadableProtocol = np;
 
+  np->setElevenBitToggle(true);
+
   np->setTrailerPulse(350);
 
 //  np->setMinimumRepetitions(1);
@@ -225,6 +227,8 @@ SharpVCR1::SharpVCR1(
 
   threadableProtocol = np;
 
+  np->setElevenBitToggle(true);
+
   np->setTrailerPulse(400);
 
 //  np->setMinimumRepetitions(1);
@@ -317,6 +321,8 @@ SharpReceiver1::SharpReceiver1(
 
   threadableProtocol = np;
 
+  np->setElevenBitToggle(true);
+
   np->setTrailerPulse(350);
 
 //  np->setMinimumRepetitions(9);
index 55bb700..8d103a2 100644 (file)
@@ -308,10 +308,10 @@ SonyAmp1::SonyAmp1(
 
   np->setHeaderPair(2400, 600);
 
-  np->setPostData(0xC, 6);
-
 //  np->setMinimumRepetitions(2);
 
+  setPostData(0xC, 6);
+
   addKey("VIDEO1", Unmapped_Key, 0x22, 7);
   addKey("VIDEO2", Unmapped_Key, 0x3C, 7);
   addKey("VIDEO3", Unmapped_Key, 0x21, 7);
@@ -533,7 +533,7 @@ SonyCD2::SonyCD2(
 
   np->setHeaderPair(2412, 588);
 
-  np->setPostData(0x7, 4);
+  setPostData(0x7, 4);
 
   addKey("PLAY", Play_Key, 0x59, 7);
   addKey("STOP", Stop_Key, 0x71, 7);
@@ -604,10 +604,10 @@ SonyCD3::SonyCD3(
   np->setHeaderPair(2400, 600);
   np->setTrailerPulse(1200);
 
-  np->setPostData(0x08, 5);
-
 //  np->setMinimumRepetitions(2);
 
+  setPostData(0x08, 5);
+
   addKey("|<<", Previous_Key, 0x03, 6);
   addKey(">>|", Next_Key, 0x23, 6);
   addKey("<<", Rewind_Key, 0x33, 6);
@@ -657,12 +657,12 @@ SonyDAT1::SonyDAT1(
 
   np->setHeaderPair(2400, 600);
 
-  np->setPostData(0x07, 5);
-
 //  np->setMinimumRepetitions(2);
 
   np->setCarrierFrequency(40000);
 
+  setPostData(0x07, 5);
+
   addKey("1", One_Key, 0x00, 7);
   addKey("2", Two_Key, 0x40, 7);
   addKey("3", Three_Key, 0x20, 7);
index 52ca8f2..f57f00d 100644 (file)
@@ -10,20 +10,9 @@ ToshibaTV1::ToshibaTV1(
       Toshiba_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 539,
-    600, 1672,
-    108000, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x02FD, 16);
+  setPreData(0x02FD, 16);
 
   addKey("POWER", Power_Key, 0x48B7, 16);
   addKey("1", One_Key, 0x807F, 16);
@@ -189,20 +178,9 @@ ToshibaVCR1::ToshibaVCR1(
       Toshiba_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 525,
-    600, 1650,
-    108000, true);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x22DD, 16);
+  setPreData(0x22DD, 16);
 
   addKey("power", Power_Key, 0x48B7, 16);
   addKey("1", One_Key, 0x807F, 16);
@@ -254,20 +232,9 @@ ToshibaDisc1::ToshibaDisc1(
       Toshiba_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 539,
-    600, 1672,
-    108000, true);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0xA25D, 16);
+  setPreData(0xA25D, 16);
 
   addKey("power", Power_Key, 0x48B7, 16);
   addKey("1", One_Key, 0x807F, 16);
index a90080e..a992949 100644 (file)
@@ -21,7 +21,7 @@ WestinghouseTV1::WestinghouseTV1(
   np->setHeaderPair(9000, 4500);
   np->setTrailerPulse(600);
 
-  np->setPreData(0x807F, 16);
+  setPreData(0x807F, 16);
 
   addKey("KEY_1", One_Key, 0x8877, 16);
   addKey("KEY_2", Two_Key, 0x48B7, 16);
index 2837354..f5193c4 100644 (file)
@@ -10,21 +10,9 @@ YamahaDVD1::YamahaDVD1(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    107782, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-
-//  np->setMinimumRepetitions(3);
-
-  np->setPreData(0x3EC1, 16);
+  setPreData(0x3EC1, 16);
 
   addKey("title", DiscTitle_Key, 0x8D72, 16);
   addKey("menu", DiscMenu_Key, 0x4DB2, 16);
@@ -88,20 +76,9 @@ YamahaAudio1::YamahaAudio1(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    107823, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x9E61, 16);
+  setPreData(0x9E61, 16);
 
   addKey("SYNCHRO", Unmapped_Key, 0x1AE5, 16); // "DIRECT_OUT"
   addKey("DIMMER", Unmapped_Key, 0x7887, 16); // "MODE"
@@ -179,22 +156,9 @@ YamahaAudio2::YamahaAudio2(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    107500, true);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-//  np->setMinimumRepetitions(1);
-
-  np->setPreData(0x5EA1, 16);
+  setPreData(0x5EA1, 16);
 
   addKey("Power", Power_Key, 0xF807, 16); // "STANDBY"
   addKey("mute", Mute_Key, 0x38C7, 16); // "-20DB"
@@ -342,20 +306,9 @@ YamahaAudio3::YamahaAudio3(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    38500, false);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0xFE01, 16);
+  setPreData(0xFE01, 16);
 
   addKey("PLAY", Play_Key, 0x00FF, 16);
   addKey("STOP", Stop_Key, 0xC03F, 16);
@@ -400,20 +353,9 @@ YamahaAudio4::YamahaAudio4(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    50000, false);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x857A, 16);
+  setPreData(0x857A, 16);
 
   addKey("CD_PLAY", Play_Key, 0xF708, 16);
   addKey("CD_PAUSE/STOP", Pause_Key, 0xF609, 16);
@@ -459,19 +401,9 @@ YamahaAudio5::YamahaAudio5(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    40000, false);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0xA25D, 16);
+  setPreData(0xA25D, 16);
 
   addKey("Power", Power_Key, 0x48B7, 16);
   addKey("Rewind", Rewind_Key, 0x9867, 16);
@@ -514,20 +446,9 @@ YamahaAudio6::YamahaAudio6(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    40000, false);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x8B74, 16);
+  setPreData(0x8B74, 16);
 
   addKey("A/B/C/D/E", Unmapped_Key, 0xB04F, 16);
   addKey("1", One_Key, 0x708F, 16);
@@ -549,20 +470,9 @@ YamahaAudio7::YamahaAudio7(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    40000, false);
-
-  threadableProtocol = np;
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x1EE1, 16);
+  setPreData(0x1EE1, 16);
 
   addKey("1", One_Key, 0x8877, 16);
   addKey("2", Two_Key, 0x48B7, 16);
@@ -620,20 +530,9 @@ YamahaTV1::YamahaTV1(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    41609, false);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0x20DF, 16);
+  setPreData(0x20DF, 16);
 
   addKey("1", One_Key, 0x8877, 16);
   addKey("2", Two_Key, 0x48B7, 16);
@@ -662,20 +561,9 @@ YamahaKaraoke1::YamahaKaraoke1(
       Yamaha_Make,
       index)
 {
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    600, 500,
-    600, 1600,
-    40000, false);
-
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(600);
-  np->setRepeatPair(9000, 2250);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  np->setPreData(0xDE21, 16);
+  setPreData(0xDE21, 16);
 
   addKey("POWER", Power_Key, 0x01FE, 16);
   addKey("VOL+", VolumeUp_Key, 0x41BE, 16);
index 1c94bc1..db3b7d0 100644 (file)
@@ -12,20 +12,9 @@ ZenithC32V37::ZenithC32V37(
 {
   addControlledDevice(Zenith_Make, "C32V37", TV_Device);
 
-  NECProtocol *np = new NECProtocol(
-    guiObject,
-    index,
-    581, 528,
-    581, 1663,
-    106773, true);
+  threadableProtocol = new NECProtocol(guiObject, index);
 
-  threadableProtocol = np;
-
-  np->setHeaderPair(9000, 4500);
-  np->setTrailerPulse(581);
-  np->setRepeatPair(9000, 2250);
-
-  np->setPreData(0x20DF, 16);
+  setPreData(0x20DF, 16);
 
   addKey("power", Power_Key, 0x10EF, 16);
   addKey("tv/video", Input_Key, 0xD02F, 16);
index 4454ad0..6468e12 100644 (file)
@@ -9,6 +9,38 @@
 extern bool commandInFlight;
 extern QMutex commandIFMutex;
 
+// The official NEC protocol, as I understand it, has the following attributes:
+// A "zero" is encoded with a 560 usec pulse, 560 usec space.
+// A "one" is encoded with a 560 usec pulse, and 3*560 (1680) usec space.
+// The header is a 9000 usec pulse, 4500 usec space.
+// Commands end with a trailing 560 usec pulse.
+// A repeat block is a 9000 usec pulse, 2250 usec space, then trailing pulse.
+// Each command runs for 110000 usec before another can be executed.
+
+// For standard NEC, use this constructor:
+NECProtocol::NECProtocol(
+  QObject *guiObject,
+  unsigned int index)
+  : PIRProtocol(guiObject, index, 110000, true),
+    zeroPulse(560),
+    zeroSpace(560),
+    onePulse(560),
+    oneSpace(1680),
+    headerPulse(9000),
+    headerSpace(4500),
+    hasHeaderPair(true),
+    trailerPulse(560),
+    hasTrailerPulse(true),
+    repeatPulse(9000),
+    repeatSpace(2250),
+    hasRepeatPair(true),
+    repeatNeedsHeader(false),
+    fullHeadlessRepeat(false),
+    elevenBitToggle(false)
+{
+}
+
+// For non-standard NEC, use this constructor:
 NECProtocol::NECProtocol(
   QObject *guiObject,
   unsigned int index,
@@ -23,11 +55,12 @@ NECProtocol::NECProtocol(
     zeroSpace(zSpace),
     onePulse(oPulse),
     oneSpace(oSpace),
-    hasTrailerPulse(false),
     hasHeaderPair(false),
+    hasTrailerPulse(false),
     hasRepeatPair(false),
     repeatNeedsHeader(false),
-    fullHeadlessRepeat(false)
+    fullHeadlessRepeat(false),
+    elevenBitToggle(false)
 {
 }
 
@@ -68,18 +101,10 @@ void NECProtocol::setFullHeadlessRepeat(
   fullHeadlessRepeat = flag;
 }
 
-void NECProtocol::setPreData(
-  unsigned long data,
-  unsigned int bits)
-{
-  appendToBitSeq(preData, data, bits);
-}
-
-void NECProtocol::setPostData(
-  unsigned long data,
-  unsigned int bits)
+void NECProtocol::setElevenBitToggle(
+  bool flag)
 {
-  appendToBitSeq(postData, data, bits);
+  elevenBitToggle = flag;
 }
 
 void NECProtocol::startSendingCommand(
@@ -129,6 +154,10 @@ void NECProtocol::startSendingCommand(
       {
         commandDuration = generateHeadlessCommand((*i).second, rx51device);
       }
+      else if (elevenBitToggle && (repeatCount % 2))
+      {
+        commandDuration = generateToggledCommand((*i).second, rx51device);
+      }
       else
       {
         commandDuration = generateStandardCommand((*i).second, rx51device);
@@ -257,6 +286,67 @@ int NECProtocol::generateRepeatCommand(
 }
 
 
+// NOTE!  The following is a special command to toggle the last eleven bits
+// of the fifteen-bit commands used by Denon, Sharp, and a few others.  It
+// assumes the command sequence will contain all fifteen bits.  If this
+// is not the case, it will work incorrectly!
+int NECProtocol::generateToggledCommand(
+  const CommandSequence &bits,
+  PIRRX51Hardware &rx51device)
+{
+  int duration = 0;
+
+  CommandSequence::const_iterator i = bits.begin();
+
+  int bitcount = 0;
+  // First 4 bits:
+  while ((bitcount < 4) && (i != bits.end()))
+  {
+    if (*i)
+    {
+      // Send pulse for "one":
+      rx51device.addPair(onePulse, oneSpace);
+      duration += (onePulse + oneSpace);
+    }
+    else
+    {
+      // Send pulse for "zero":
+      rx51device.addPair(zeroPulse, zeroSpace);
+      duration += (zeroPulse + zeroSpace);
+    }
+    ++i;
+    ++bitcount;
+  }
+
+  // Now, invert the last eleven bits:
+  while (i != bits.end())
+  {
+    if (*i)
+    {
+      // Send pulse for "zero":
+      rx51device.addPair(zeroPulse, zeroSpace);
+      duration += (zeroPulse + zeroSpace);
+    }
+    else
+    {
+      // Send pulse for "one":
+      rx51device.addPair(onePulse, oneSpace);
+      duration += (onePulse + oneSpace);
+    }
+    ++i;
+  }
+
+  // Add trail on end:
+  if (hasTrailerPulse)
+  {
+    rx51device.addSingle(trailerPulse);
+    duration += trailerPulse;
+  }
+
+  return duration;
+}
+
+
 int NECProtocol::pushBits(
   const CommandSequence &bits,
   PIRRX51Hardware &rx51device)
index da5e5ff..9de409d 100644 (file)
@@ -23,6 +23,13 @@ public:
   // command and the start of the next, and others specify each command be
   // started at a precise interval (so the spacing between the end of one
   // and the start of another may vary).
+
+  // Constructor for standard NEC:
+  NECProtocol(
+    QObject *guiObject,
+    unsigned int index);
+
+  // Constructor for non-standard NEC:
   NECProtocol(
     QObject *guiObject,
     unsigned int index,
@@ -44,20 +51,15 @@ public:
     unsigned int pulse,
     unsigned int space);
 
-  void setPreData(
-    unsigned long data,
-    unsigned int bits);
-
-  void setPostData(
-    unsigned long data,
-    unsigned int bits);
-
   void setRepeatNeedsHeader(
     bool flag);
 
   void setFullHeadlessRepeat(
     bool flag);
 
+  void setElevenBitToggle(
+    bool flag);
+
 public slots:
   void startSendingCommand(
     unsigned int threadableID,
@@ -70,6 +72,11 @@ private:
   unsigned int onePulse;
   unsigned int oneSpace;
 
+  // Some administrative data that most NEC Protocol remotes have:
+  unsigned int headerPulse;
+  unsigned int headerSpace;
+  bool hasHeaderPair;
+
   // A tailing on-request, not followed by a specific off time:
   unsigned int trailerPulse;
   bool hasTrailerPulse;
@@ -77,21 +84,13 @@ private:
   // Each remote key has a unique command sequence:
 //  KeyCommandMap commands;
 
-  // Some administrative data that most NEC Protocol remotes have:
-  unsigned int headerPulse;
-  unsigned int headerSpace;
-  bool hasHeaderPair;
-
-  // More administrative data wrapped around the actual command:
-  CommandSequence preData;
-  CommandSequence postData;
-
   // A pulse that means "repeat the last command":
   unsigned int repeatPulse;
   unsigned int repeatSpace;
   bool hasRepeatPair;
   bool repeatNeedsHeader; // Put the header ahead of the repeat pulse
   bool fullHeadlessRepeat; // Repeat full command but without header
+  bool elevenBitToggle; // A few remotes toggle the last eleven bits on repeat
 
   int generateStandardCommand(
     const CommandSequence &bits,
@@ -104,6 +103,10 @@ private:
   int generateRepeatCommand(
     PIRRX51Hardware &device);
 
+  int generateToggledCommand(
+    const CommandSequence &bits,
+    PIRRX51Hardware &device);
+
   int pushBits(
     const CommandSequence &bits,
     PIRRX51Hardware &device);
index 618640e..317764c 100644 (file)
@@ -61,7 +61,10 @@ SOURCES += main.cpp mainwindow.cpp \
     pirdevicetypenames.cpp \
     keysets/raite.cpp \
     keysets/sagem.cpp \
-    keysets/yamaha.cpp
+    keysets/yamaha.cpp \
+    keysets/hitachi.cpp \
+    keysets/denon.cpp \
+    keysets/pinnacle.cpp
 HEADERS += mainwindow.h \
     pirkeynames.h \
     necprotocol.h \
@@ -97,7 +100,10 @@ HEADERS += mainwindow.h \
     pirdevicetypenames.h \
     keysets/raite.h \
     keysets/sagem.h \
-    keysets/yamaha.h
+    keysets/yamaha.h \
+    keysets/hitachi.h \
+    keysets/denon.h \
+    keysets/pinnacle.h
 FORMS += mainwindow.ui \
     pirdocumentationform.ui \
     piraboutform.ui \
@@ -164,7 +170,7 @@ OTHER_FILES += \
     www/PierogiIcon.png \
     www/SelectKeysetWindow.png \
     www/UtilityTab.png \
-    qtc_packaging/debian_fremantle/postrm
+    qtc_packaging/debian_fremantle/postrm.needsfixing
 
 RESOURCES += \
     PierogiResources.qrc
index 9c01f9e..1f6fb5a 100644 (file)
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.0, 2012-01-19T19:30:41. -->
+<!-- Written by Qt Creator 2.4.0, 2012-01-23T09:52:06. -->
 <qtcreator>
  <data>
   <variable>ProjectExplorer.Project.ActiveTarget</variable>
@@ -79,7 +79,7 @@
       <value type="QString" key="ProjectExplorer.ProcessStep.Arguments">dpkg-buildpackage -sa -S -uc -us</value>
       <value type="QString" key="ProjectExplorer.ProcessStep.Command">/Users/john/QtSDK/Maemo/4.6.2/bin/mad</value>
       <value type="bool" key="ProjectExplorer.ProcessStep.Enabled">false</value>
-      <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.4</value>
+      <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-0.1.5</value>
       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Custom Process Step</value>
       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.ProcessStep</value>
       <value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
       <value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">MaemoMountAndInstallDeployStep</value>
       <valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedFiles">
+       <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_5_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_4_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_3_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_2_armel.deb</value>
        <value type="QString">192.168.0.15</value>
        <value type="QString">192.168.0.15</value>
        <value type="QString">192.168.0.15</value>
+       <value type="QString">192.168.0.15</value>
        <value type="QString">localhost</value>
       </valuelist>
       <valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedRemotePaths">
        <value type="QString"></value>
        <value type="QString"></value>
        <value type="QString"></value>
+       <value type="QString"></value>
       </valuelist>
       <valuelist type="QVariantList" key="Qt4ProjectManager.MaemoRunConfiguration.LastDeployedTimes">
-       <value type="QDateTime">2012-01-18T19:44:56</value>
+       <value type="QDateTime">2012-01-23T09:47:37</value>
+       <value type="QDateTime">2012-01-19T22:18:07</value>
        <value type="QDateTime">2012-01-17T13:21:05</value>
        <value type="QDateTime">2012-01-17T12:19:28</value>
        <value type="QDateTime">2012-01-17T00:15:23</value>
index 6451f6f..32d8cf0 100644 (file)
@@ -8,6 +8,7 @@ PIRDeviceTypeMgr::PIRDeviceTypeMgr()
   devices[DVD_Device] = "DVD";
   devices[Audio_Device] = "Audio";
   devices[Computer_Device] = "Computer";
+  devices[Other_Device] = "Other";
 }
 
 const char *PIRDeviceTypeMgr::getDeviceString(
index b9aa0ff..1606841 100644 (file)
@@ -12,7 +12,8 @@ enum PIRDeviceTypeName {
   VCR_Device,
   DVD_Device,
   Audio_Device,
-  Computer_Device
+  Computer_Device,
+  Other_Device
 };
 
 typedef std::set<PIRDeviceTypeName> PIRDeviceTypeCollection;
index ba806e1..2d4aeec 100644 (file)
@@ -49,6 +49,8 @@ enum PIRKeyName{
   Advance_Key,
   Replay_Key,
   Eject_Key,
+  Random_Key,
+  Repeat_Key,
   // Menu control:
   Menu_Key,
   Up_Key,
index a7a837c..29eefd5 100644 (file)
@@ -1,14 +1,17 @@
 #include "pirkeysetmanager.h"
 #include "pirkeysetmetadata.h"
 #include "keysets/apple.h"
+#include "keysets/denon.h"
 #include "keysets/ei.h"
 #include "keysets/goldstar.h"
 #include "keysets/hauppauge.h"
+#include "keysets/hitachi.h"
 #include "keysets/jvc.h"
 #include "keysets/lg.h"
 #include "keysets/mitsubishi.h"
 #include "keysets/nokia.h"
 #include "keysets/panasonic.h"
+#include "keysets/pinnacle.h"
 #include "keysets/raite.h"
 #include "keysets/rca.h"
 #include "keysets/sagem.h"
 #include "keysets/westinghouse.h"
 #include "keysets/yamaha.h"
 #include "keysets/zenith.h"
-//#include "protocol.h"
 #include "pirmakenames.h"
 
 #include "pirexception.h"
 
 #include <QObject>
-//#include <QMetaType>
 
 // I'll be handling the threading of the keyset commands in this object:
 #include <QMutex>
@@ -48,6 +49,29 @@ PIRKeysetManager::PIRKeysetManager(
   // Create the keysets.  Ugly!  This needs to be worked on!
   populateKeyset(new AppleWhiteRemote(guiObject, counter++));
 
+  populateKeyset(new DenonDVD1(guiObject, counter++));
+  populateKeyset(new DenonDVD2(guiObject, counter++));
+  populateKeyset(new DenonDVD3(guiObject, counter++));
+  populateKeyset(new DenonReceiver1(guiObject, counter++));
+  populateKeyset(new DenonReceiver1a(guiObject, counter++));
+  populateKeyset(new DenonReceiver1b(guiObject, counter++));
+  populateKeyset(new DenonReceiver1c(guiObject, counter++));
+  populateKeyset(new DenonReceiver2(guiObject, counter++));
+  populateKeyset(new DenonReceiver2a(guiObject, counter++));
+  populateKeyset(new DenonReceiver3(guiObject, counter++));
+  populateKeyset(new DenonReceiver3a(guiObject, counter++));
+  populateKeyset(new DenonReceiver4(guiObject, counter++));
+  populateKeyset(new DenonReceiver5(guiObject, counter++));
+  populateKeyset(new DenonAudio1(guiObject, counter++));
+  populateKeyset(new DenonAudio1a(guiObject, counter++));
+  populateKeyset(new DenonAudio1b(guiObject, counter++));
+  populateKeyset(new DenonAudio1c(guiObject, counter++));
+  populateKeyset(new DenonAudio1d(guiObject, counter++));
+  populateKeyset(new DenonAudio2(guiObject, counter++));
+  populateKeyset(new DenonAudio3(guiObject, counter++));
+  populateKeyset(new DenonAudio4(guiObject, counter++));
+  populateKeyset(new DenonAudio5(guiObject, counter++));
+
   populateKeyset(new EiKeyset(guiObject, counter++));
 
   populateKeyset(new GoldStarTV1(guiObject, counter++));
@@ -59,8 +83,11 @@ PIRKeysetManager::PIRKeysetManager(
   populateKeyset(new GoldStarVCR1d(guiObject, counter++));
   populateKeyset(new GoldStarCD1(guiObject, counter++));
 
-  populateKeyset(new HauppaugeGeneric(guiObject, counter++));
-  populateKeyset(new HauppaugeTV1(guiObject, counter++));
+  populateKeyset(new HauppaugePCTV1(guiObject, counter++));
+  populateKeyset(new HauppaugePCTV1a(guiObject, counter++));
+  populateKeyset(new HauppaugePCTV1b(guiObject, counter++));
+  populateKeyset(new HauppaugePCTV1c(guiObject, counter++));
+  populateKeyset(new HauppaugePCTV2(guiObject, counter++));
 
   populateKeyset(new JVCSat1(guiObject, counter++));
   populateKeyset(new JVCSat2(guiObject, counter++));
@@ -127,6 +154,10 @@ PIRKeysetManager::PIRKeysetManager(
   populateKeyset(new PanasonicAudio1(guiObject, counter++));
   populateKeyset(new PanasonicAudio1a(guiObject, counter++));
 
+  populateKeyset(new PinnaclePCTV1(guiObject, counter++));
+  populateKeyset(new PinnaclePCTV2(guiObject, counter++));
+  populateKeyset(new PinnaclePCTV3(guiObject, counter++));
+
   populateKeyset(new RaiteDVD1(guiObject, counter++));
 
   populateKeyset(new RCATV1(guiObject, counter++));
@@ -166,9 +197,14 @@ PIRKeysetManager::PIRKeysetManager(
   populateKeyset(new SamsungDVD2(guiObject, counter++));
   populateKeyset(new SamsungAC1(guiObject, counter++));
 
-  populateKeyset(new SanyoTV1(guiObject, counter++));
-  populateKeyset(new SanyoTV2(guiObject, counter++));
   populateKeyset(new SanyoVCR1(guiObject, counter++));
+  populateKeyset(new SanyoDVD1(guiObject, counter++));
+  populateKeyset(new SanyoTV1(guiObject, counter++));
+  populateKeyset(new SanyoTV1a(guiObject, counter++));
+  populateKeyset(new SanyoTV1b(guiObject, counter++));
+  populateKeyset(new SanyoTV1c(guiObject, counter++));
+  populateKeyset(new SanyoTV1d(guiObject, counter++));
+  populateKeyset(new SanyoProjector(guiObject, counter++));
 
   populateKeyset(new SharpTV1(guiObject, counter++));
   populateKeyset(new SharpTV1a(guiObject, counter++));
index cb8847c..32c46bb 100644 (file)
@@ -71,6 +71,22 @@ void PIRKeysetMetaData::addKey(
 }
 
 
+void PIRKeysetMetaData::setPreData(
+  unsigned long data,
+  unsigned int bits)
+{
+  threadableProtocol->setPreData(data, bits);
+}
+
+
+void PIRKeysetMetaData::setPostData(
+  unsigned long data,
+  unsigned int bits)
+{
+  threadableProtocol->setPostData(data, bits);
+}
+
+
 PIRMakeName PIRKeysetMetaData::getMake()
 {
   return make;
index bed34bb..7bdf2e9 100644 (file)
@@ -69,6 +69,14 @@ protected:
     unsigned long data,
     unsigned int bits);
 
+  void setPreData(
+    unsigned long data,
+    unsigned int bits);
+
+  void setPostData(
+    unsigned long data,
+    unsigned int bits);
+
   KeyCollection keys;
 
   DeviceCollection controlledDevices;
index cae6aa2..777151f 100644 (file)
@@ -4,15 +4,18 @@ PIRMakeMgr::PIRMakeMgr()
 {
   makes[Any_Make] = "Any";
   makes[Apple_Make] = "Apple";
+  makes[Denon_Make] = "Denon";
   makes[Ei_Make] = "Ei";
   makes[GoldStar_Make] = "GoldStar";
   makes[Hauppauge_Make] = "Hauppauge";
+  makes[Hitachi_Make] = "Hitachi";
   makes[JVC_Make] = "JVC";
   makes[LG_Make] = "LG";
   makes[Mitsubishi_Make] = "Mitsubishi";
   makes[Nokia_Make] = "Nokia";
-  makes[Philips_Make] = "Philips";
   makes[Panasonic_Make] = "Panasonic";
+  makes[Philips_Make] = "Philips";
+  makes[Pinnacle_Make] = "Pinnacle Systems";
   makes[Raite_Make] = "Raite";
   makes[RCA_Make] = "RCA";
   makes[Sagem_Make] = "Sagem";
index 814a544..a99054b 100644 (file)
@@ -8,15 +8,18 @@
 enum PIRMakeName{
   Any_Make,
   Apple_Make,
+  Denon_Make,
   Ei_Make,
   GoldStar_Make,
   Hauppauge_Make,
+  Hitachi_Make,
   JVC_Make,
   LG_Make,
   Mitsubishi_Make,
   Nokia_Make,
   Panasonic_Make,
   Philips_Make,
+  Pinnacle_Make,
   Raite_Make,
   RCA_Make,
   Sagem_Make,
index d67f18d..60a7286 100644 (file)
@@ -56,6 +56,13 @@ void PIRProtocol::addKey(
   unsigned long command,
   unsigned int bits)
 {
+  // First, if key already exists, clear it out:
+  KeycodeCollection::iterator i = keycodes.find(key);
+  if (i != keycodes.end())
+  {
+    i->second.clear();
+  }
+
   appendToBitSeq(keycodes[key], command, bits);
 }
 
@@ -81,6 +88,34 @@ void PIRProtocol::setMinimumRepetitions(
 }
 
 
+void PIRProtocol::setPreData(
+  unsigned long data,
+  unsigned int bits)
+{
+  // If the container is not empty, first clear it out:
+  if (!preData.empty())
+  {
+    preData.clear();
+  }
+
+  appendToBitSeq(preData, data, bits);
+}
+
+
+void PIRProtocol::setPostData(
+  unsigned long data,
+  unsigned int bits)
+{
+  // If the container is not empty, first clear it out:
+  if (!postData.empty())
+  {
+    postData.clear();
+  }
+
+  appendToBitSeq(postData, data, bits);
+}
+
+
 bool PIRProtocol::isCommandSupported(
   PIRKeyName command)
 {
index a594aad..b78c523 100644 (file)
@@ -51,6 +51,14 @@ public:
   void setMinimumRepetitions(
     unsigned int minrep);
 
+  void setPreData(
+    unsigned long data,
+    unsigned int bits);
+
+  void setPostData(
+    unsigned long data,
+    unsigned int bits);
+
 public slots:
   virtual void startSendingCommand(
     unsigned int threadableID,
@@ -91,7 +99,12 @@ protected:
   bool isConstantLength;
   int gap;
 
+  // More administrative data wrapped around the actual command:
+  CommandSequence preData;
+  CommandSequence postData;
+
   // Some remotes require a minimum number of repetitions:
+  // Note: thinking about removing this -- don't know if it is needed
   int minimumRepetitions;
 
   unsigned int id;
index 09b271d..1b78469 100644 (file)
@@ -28,7 +28,7 @@
         </sizepolicy>
        </property>
        <property name="text">
-        <string>Make</string>
+        <string>Make:</string>
        </property>
       </widget>
      </item>
index 7c827fa..bd6ba46 100644 (file)
@@ -1,3 +1,13 @@
+pierogi (0.1.6) unstable; urgency=low
+  * Still having installation problems!  For now, I'm just giving up on the postrm script; for now, users will have to live with the extra file when uninstalling.
+
+ -- John Pietrzak <jpietrzak8@gmail.com>  Mon, 23 Jan 2012 09:50:25 -0500
+
+pierogi (0.1.5) unstable; urgency=low
+  * Fixed a design flaw allowing user to queue up unlimited number of commands.
+
+ -- John Pietrzak <jpietrzak8@gmail.com>  Fri, 20 Jan 2012 00:00:29 -0500
+
 pierogi (0.1.4) unstable; urgency=low
   * I think uninstall is working now.  So, Initial Release time!
 
diff --git a/qtc_packaging/debian_fremantle/postrm b/qtc_packaging/debian_fremantle/postrm
deleted file mode 100644 (file)
index 3653f7a..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh
-
-rm -f /etc/sudoers.d/pierogi.sudoers
-
-update-sudoers
-
-exit 0
diff --git a/qtc_packaging/debian_fremantle/postrm.needsfixing b/qtc_packaging/debian_fremantle/postrm.needsfixing
new file mode 100644 (file)
index 0000000..3653f7a
--- /dev/null
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+rm -f /etc/sudoers.d/pierogi.sudoers
+
+update-sudoers
+
+exit 0
index 98d8ebb..3df1687 100644 (file)
@@ -34,14 +34,6 @@ void RC5Protocol::setHeaderPair(
 }
 
 
-void RC5Protocol::setPreData(
-  unsigned long data,
-  unsigned int bits)
-{
-  appendToBitSeq(preData, data, bits);
-}
-
-
 void RC5Protocol::setToggleBit(
   unsigned int bit)
 {
index 181b12a..dacea76 100644 (file)
@@ -5,9 +5,8 @@
 #include "pirrx51hardware.h"
 
 //
-// The RC5 protocol is apparently quite a bit older than the NEC protocol, but
-// not as widespread.  Still, it continues to be in use, as I've seen
-// by my Elgato "Eye TV" remote control.
+// The RC5 protocol is not as widespread as the NEC protocol, but still
+// somewhat popular.  Philips, the inventor, uses it extensively.
 //
 
 class RC5Protocol: public PIRProtocol
@@ -26,10 +25,6 @@ public:
     unsigned int pulse,
     unsigned int space);
 
-  void setPreData(
-    unsigned long data,
-    unsigned int bits);
-
   void setToggleBit(
     unsigned int bit);
 
@@ -48,11 +43,6 @@ protected:
   unsigned int headerSpace;
   bool hasHeaderPair;
 
-  CommandSequence preData;
-//  CommandSequence postData;
-
-//  int trail;
-
   // The original RC-5 specification marks a single bit as a "toggle bit",
   // which should be inverted on each separate keypress.  This was originally
   // the third bit, but apparently some remotes invert a different bit.
index 353a99c..084efcf 100644 (file)
@@ -120,9 +120,9 @@ targeted towards entering other useful menus when available.</p>
 <img src="MediaTab.png">
 
 <p>Many of the most important playback commands are represented on this tab.
-Play, pause, and stop are the most common ones, along with "Reverse" (often
-called "Rewind") and Fast Forward.  A variety of other less common navigation
-controls are included, along with the "eject" command.</p>
+"Play", "Pause", and "Stop" are the most common ones, along with "Reverse"
+(often called rewind) and "Fast Forward".  A variety of other less common
+navigation controls are included, along with the "Eject" command.</p>
 
 <h3>Misc Tab</h3>
 

Terms of Use    Privacy Policy    Contribution Guidelines    Feedback

Powered By GForge Collaborative Development Environment