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>
Tue, 21 Feb 2012 18:25:28 +0000 (13:25 -0500)
committerJohn Pietrzak <john@pietrzak.org>
Tue, 21 Feb 2012 18:25:28 +0000 (13:25 -0500)
Adding many new keysets this time.  The Panasonic "SA-AK25" LIRC file was added
as Panasonic Audio Keyset 2, and new keysets were created for Bush, Canon,
Epson, Humax, Technics, and United.

21 files changed:
keysets/bush.cpp [new file with mode: 0644]
keysets/bush.h [new file with mode: 0644]
keysets/canon.cpp [new file with mode: 0644]
keysets/canon.h [new file with mode: 0644]
keysets/epson.cpp [new file with mode: 0644]
keysets/epson.h [new file with mode: 0644]
keysets/humax.cpp [new file with mode: 0644]
keysets/humax.h [new file with mode: 0644]
keysets/panasonic.cpp
keysets/panasonic.h
keysets/technics.cpp [new file with mode: 0644]
keysets/technics.h [new file with mode: 0644]
keysets/united.cpp [new file with mode: 0644]
keysets/united.h [new file with mode: 0644]
pierogi.pro
pierogi.pro.user
pirkeysetmanager.cpp
pirmakenames.cpp
pirmakenames.h
qtc_packaging/debian_fremantle/changelog
qtc_packaging/debian_fremantle/control

diff --git a/keysets/bush.cpp b/keysets/bush.cpp
new file mode 100644 (file)
index 0000000..5d7f03c
--- /dev/null
@@ -0,0 +1,183 @@
+#include "bush.h"
+#include "protocols/rc5protocol.h"
+
+
+BushTV1::BushTV1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 1",
+      Bush_Make,
+      index)
+{
+}
+
+
+void BushTV1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index);
+
+  addKey("menu-off", Exit_Key, 0x0013, 13);
+  addKey("zoom", Zoom_Key, 0x003E, 13);
+
+  addKey("0", Zero_Key, 0x1000, 13);
+  addKey("1", One_Key, 0x1001, 13);
+  addKey("2", Two_Key, 0x1002, 13);
+  addKey("3", Three_Key, 0x1003, 13);
+  addKey("4", Four_Key, 0x1004, 13);
+  addKey("5", Five_Key, 0x1005, 13);
+  addKey("6", Six_Key, 0x1006, 13);
+  addKey("7", Seven_Key, 0x1007, 13);
+  addKey("8", Eight_Key, 0x1008, 13);
+  addKey("9", Nine_Key, 0x1009, 13);
+  addKey("off", Power_Key, 0x100C, 13);
+  addKey("mute", Mute_Key, 0x100D, 13);
+  addKey("norm", Unmapped_Key, 0x100E, 13);
+  addKey("osd", Info_Key, 0x100F, 13);
+  addKey("vol+", VolumeUp_Key, 0x1010, 13);
+  addKey("vol-", VolumeDown_Key, 0x1011, 13);
+  addKey("chan+", ChannelUp_Key, 0x1020, 13);
+  addKey("chan-", ChannelDown_Key, 0x1021, 13);
+  addKey("last", PrevChannel_Key, 0x1024, 13);
+  addKey("clockon", Sleep_Key, 0x102A, 13);
+  addKey("yellow", Yellow_Key, 0x1032, 13);
+  addKey("blue", Blue_Key, 0x1034, 13);
+  addKey("white", Unmapped_Key, 0x1035, 13);
+  addKey("green", Green_Key, 0x1036, 13);
+  addKey("red", Red_Key, 0x1037, 13);
+  addKey("av", AuxInput_Key, 0x1038, 13);
+  addKey("menu", Menu_Key, 0x103B, 13);
+  addKey("text", Teletext_Key, 0x103C, 13);
+  addKey("tv", Input_Key, 0x103F, 13);
+}
+
+
+BushTV2::BushTV2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 2",
+      Bush_Make,
+      index)
+{
+}
+
+
+void BushTV2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // If the pointer is not null, the keyset must already be populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index);
+
+  addKey("SMART_CONTROL_PICTURE", PictureMode_Key, 0x1002, 13);
+  addKey("MIX", TeletextAndTV_Key, 0x1004, 13);
+  addKey("P100", Unmapped_Key, 0x1006, 13); // Plus 100?
+  addKey("DOUB", TeletextSize_Key, 0x1007, 13);
+  addKey("SUB", Unmapped_Key, 0x100A, 13);
+  addKey("SMART_CONTROL_SOUND", SoundMode_Key, 0x100B, 13);
+  addKey("HOLD", TeletextHold_Key, 0x100C, 13);
+  addKey("REV", TeletextReveal_Key, 0x100E, 13);
+  addKey("UPDATE", Unmapped_Key, 0x100F, 13);
+
+  addKey("0", Zero_Key, 0x1010, 13);
+  addKey("1", One_Key, 0x1011, 13);
+  addKey("2", Two_Key, 0x1012, 13);
+  addKey("3", Three_Key, 0x1013, 13);
+  addKey("4", Four_Key, 0x1014, 13);
+  addKey("5", Five_Key, 0x1015, 13);
+  addKey("6", Six_Key, 0x1016, 13);
+  addKey("7", Seven_Key, 0x1017, 13);
+  addKey("8", Eight_Key, 0x1018, 13);
+  addKey("9", Nine_Key, 0x1019, 13);
+  addKey("-/--", DoubleDigit_Key, 0x101A, 13);
+  addKey("PR_DOWN", ChannelDown_Key, 0x101B, 13);
+  addKey("PR_DOWN", Down_Key, 0x101B, 13);
+  addKey("PR_UP", ChannelUp_Key, 0x101C, 13);
+  addKey("PR_UP", Up_Key, 0x101C, 13);
+
+  addKey("POWER", Power_Key, 0x1020, 13);
+  addKey("PP", Unmapped_Key, 0x1021, 13);
+  addKey("16:9", AspectRatio_Key, 0x1023, 13);
+  addKey("VOL_UP", VolumeUp_Key, 0x1024, 13);
+  addKey("VOL_UP", Right_Key, 0x1024, 13);
+  addKey("VOL_LOW", VolumeDown_Key, 0x1025, 13);
+  addKey("VOL_LOW", Left_Key, 0x1025, 13);
+  addKey("RED", Red_Key, 0x1026, 13);
+  addKey("SWAP", PrevChannel_Key, 0x1027, 13);
+  addKey("OK", Select_Key, 0x1028, 13);
+  addKey("MENU", Menu_Key, 0x1029, 13);
+  addKey("AV", Input_Key, 0x102A, 13);
+  addKey("MUTE", Mute_Key, 0x102B, 13);
+  addKey("GREEN", Green_Key, 0x102C, 13);
+  addKey("YELLOW", Yellow_Key, 0x102E, 13);
+  addKey("I", Info_Key, 0x102F, 13); // "PURPLE", might be wrong
+
+  addKey("TXT", Teletext_Key, 0x1031, 13);
+  addKey("BLUE", Blue_Key, 0x1033, 13);
+}
+
+
+BushSTB1::BushSTB1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "STB Keyset 1",
+      Bush_Make,
+      index)
+{
+}
+
+
+void BushSTB1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index);
+
+  addKey("power", Power_Key, 0x120C, 13);
+  addKey("mute", Mute_Key, 0x120D, 13);
+  addKey("tvdtv", Input_Key, 0x120E, 13);
+  addKey("menu", Menu_Key, 0x1235, 13);
+  addKey("up", Up_Key, 0x1212, 13);
+  addKey("left", Left_Key, 0x1215, 13);
+  addKey("select", Select_Key, 0x1214, 13);
+  addKey("right", Right_Key, 0x1216, 13);
+  addKey("down", Down_Key, 0x1213, 13);
+  addKey("num1", One_Key, 0x1201, 13);
+  addKey("num2", Two_Key, 0x1202, 13);
+  addKey("num3", Three_Key, 0x1203, 13);
+  addKey("num4", Four_Key, 0x1204, 13);
+  addKey("num5", Five_Key, 0x1205, 13);
+  addKey("num6", Six_Key, 0x1206, 13);
+  addKey("num7", Seven_Key, 0x1207, 13);
+  addKey("num8", Eight_Key, 0x1208, 13);
+  addKey("num9", Nine_Key, 0x1209, 13);
+  addKey("num0", Zero_Key, 0x1200, 13);
+  addKey("guide", Guide_Key, 0x1222, 13);
+  addKey("volup", VolumeUp_Key, 0x1210, 13);
+  addKey("progup", ChannelUp_Key, 0x1220, 13);
+  addKey("voldwn", VolumeDown_Key, 0x1211, 13);
+  addKey("progdwn", ChannelDown_Key, 0x1221, 13);
+  addKey("red", Red_Key, 0x1237, 13);
+  addKey("green", Green_Key, 0x1236, 13);
+  addKey("yellow", Yellow_Key, 0x1232, 13);
+  addKey("blue", Blue_Key, 0x1234, 13);
+  addKey("wide", AspectRatio_Key, 0x121E, 13);
+  addKey("info", Info_Key, 0x123F, 13);
+  addKey("exit", Exit_Key, 0x120A, 13);
+  addKey("text", Teletext_Key, 0x123C, 13);
+}
diff --git a/keysets/bush.h b/keysets/bush.h
new file mode 100644 (file)
index 0000000..f48f0d7
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef BUSH_H
+#define BUSH_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class BushTV1: public PIRKeysetMetaData
+{
+public:
+  BushTV1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class BushTV2: public PIRKeysetMetaData
+{
+public:
+  BushTV2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class BushSTB1: public PIRKeysetMetaData
+{
+public:
+  BushSTB1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // BUSH_H
diff --git a/keysets/canon.cpp b/keysets/canon.cpp
new file mode 100644 (file)
index 0000000..498e91d
--- /dev/null
@@ -0,0 +1,138 @@
+#include "canon.h"
+#include "protocols/lircprotocol.h"
+#include "protocols/necprotocol.h"
+
+
+CanonDSLR1::CanonDSLR1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "RC 1/5/6 Keyset",
+      Canon_Make,
+      index)
+{
+}
+
+
+void CanonDSLR1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  LIRCProtocol *lp = new LIRCProtocol(
+    guiObject, index,
+    550, 5250,
+    550, 7143,
+    100000, true);
+
+  threadableProtocol = lp;
+  lp->setTrailerPulse(550);
+
+  addKey("S", VolumeDown_Key, 0x1, 1); // Open shutter immediately (?)
+  addKey("2S", VolumeUp_Key, 0x0, 1); // Two second delay (?)
+}
+
+
+CanonCamcorder1::CanonCamcorder1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Camcorder Keyset 1",
+      Canon_Make,
+      index)
+{
+}
+
+
+void CanonCamcorder1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x7685, 16);
+
+  addKey("ff", FastForward_Key, 0x00, 8);
+  addKey("play", Play_Key, 0x01, 8);
+  addKey("rew", Rewind_Key, 0x02, 8);
+  addKey("startstop", Unmapped_Key, 0x03, 8); // "remote_set"  ?
+  addKey("pause", Pause_Key, 0x04, 8);
+  addKey("slow", Slow_Key, 0x05, 8);
+  addKey("TAPE-RETURN", Unmapped_Key, 0x06, 8); // "tr"
+  addKey("rec", Record_Key, 0x07, 8);
+  addKey("COUNTER-RESET", Clear_Key, 0x0D, 8); // "cr"
+  addKey("title", Unmapped_Key, 0x0E, 8);
+  addKey("date", Unmapped_Key, 0x0F, 8);
+
+  addKey("fadv", StepForward_Key, 0x10, 8); //"+", "next_frame"
+  addKey("self_timer", Sleep_Key, 0x12, 8);
+  addKey("stop", Stop_Key, 0x17, 8);
+  addKey("display", Info_Key, 0x1B, 8); // "tv_screen"
+  addKey("t", Unmapped_Key, 0x1C, 8); // "ZOOM-T"
+  addKey("w", Unmapped_Key, 0x1D, 8); // "ZOOM-W"
+
+  addKey("up", Up_Key, 0x20, 8);
+  addKey("down", Down_Key, 0x21, 8);
+  addKey("set", Select_Key, 0x24, 8);
+  addKey("menu", Menu_Key, 0x25, 8);
+  addKey("on/off", Power_Key, 0x27, 8); // might be wrong
+  addKey("d.effects", Unmapped_Key, 0x28, 8);
+  addKey("CARD+", Unmapped_Key, 0x2A, 8);
+  addKey("CARD-", Unmapped_Key, 0x2B, 8);
+  addKey("SLIDE-SHOW", Unmapped_Key, 0x2C, 8);
+
+  addKey("PHOTO", Unmapped_Key, 0x30, 8);
+  addKey("data_code", Unmapped_Key, 0x31, 8);
+  addKey("zero_set_memory", Unmapped_Key, 0x32, 8);
+  addKey("audio_dub.", Unmapped_Key, 0x33, 8);
+  addKey("search_select", Memory_Key, 0x34, 8);
+  addKey("fwd", Next_Key, 0x35, 8); // "search_select_forward"
+  addKey("bwd", Previous_Key, 0x36, 8); // "search_select_rewind"
+  addKey("audio_monitor", Audio_Key, 0x39, 8);
+  addKey("st-2", Unmapped_Key, 0x3A, 8);
+  addKey("st-1", Unmapped_Key, 0x3B, 8);
+  addKey("-", StepBack_Key, 0x50, 8); // "prev_frame"
+  addKey("x2", Unmapped_Key, 0x55, 8);
+  addKey("AV-INSERT", Unmapped_Key, 0x5B, 8);
+}
+
+
+CanonPowershot1::CanonPowershot1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Powershot Keyset 1",
+      Canon_Make,
+      index)
+{
+}
+
+
+void CanonPowershot1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0xB1CA, 16);
+
+  addKey("Snap", Select_Key, 0x1F, 8);
+  addKey("ZoomIn", Up_Key, 0x42, 8);
+  addKey("ZoomOut", Down_Key, 0x43, 8);
+  addKey("Right", Right_Key, 0x40, 8);
+  addKey("Left", Left_Key, 0x41, 8);
+  addKey("Multi", Menu_Key, 0x44, 8);
+  addKey("Magnify", Guide_Key, 0x46, 8);
+  addKey("Display", DiscMenu_Key, 0x47, 8);
+}
diff --git a/keysets/canon.h b/keysets/canon.h
new file mode 100644 (file)
index 0000000..50d608c
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef CANON_H
+#define CANON_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class CanonDSLR1: public PIRKeysetMetaData
+{
+public:
+  CanonDSLR1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class CanonCamcorder1: public PIRKeysetMetaData
+{
+public:
+  CanonCamcorder1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class CanonPowershot1: public PIRKeysetMetaData
+{
+public:
+  CanonPowershot1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // CANON_H
diff --git a/keysets/epson.cpp b/keysets/epson.cpp
new file mode 100644 (file)
index 0000000..6e8b9a0
--- /dev/null
@@ -0,0 +1,100 @@
+#include "epson.h"
+#include "protocols/necprotocol.h"
+
+
+EpsonProjector1::EpsonProjector1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Projector Keyset 1",
+      Epson_Make,
+      index)
+{
+}
+
+
+void EpsonProjector1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x5583, 16);
+
+  addKey("esc", Exit_Key, 0x84, 8);
+  addKey("enter", Select_Key, 0x85, 8);
+  addKey("pageup", PageUp_Key, 0x86, 8);
+  addKey("pagedown", PageDown_Key, 0x87, 8);
+  addKey("zoom+", ChannelUp_Key, 0x88, 8);
+  addKey("zoom-", ChannelDown_Key, 0x89, 8);
+  addKey("3", Three_Key, 0x8A, 8);
+  addKey("0", Zero_Key, 0x8C, 8);
+  addKey("6", Six_Key, 0x8F, 8);
+
+  addKey("power", Power_Key, 0x90, 8);
+  addKey("9", Nine_Key, 0x92, 8);
+  addKey("8", Eight_Key, 0x93, 8);
+  addKey("4", Four_Key, 0x94, 8);
+  addKey("5", Five_Key, 0x95, 8);
+  addKey("2", Two_Key, 0x96, 8);
+  addKey("1", One_Key, 0x97, 8);
+  addKey("vol+", VolumeUp_Key, 0x98, 8);
+  addKey("vol-", VolumeDown_Key, 0x99, 8);
+  addKey("menu", Menu_Key, 0x9A, 8);
+  addKey("7", Seven_Key, 0x9B, 8);
+  addKey("?", Guide_Key, 0x9F, 8);
+
+  addKey("up", Up_Key, 0xB0, 8);
+  addKey("right", Right_Key, 0xB1, 8);
+  addKey("down", Down_Key, 0xB2, 8);
+  addKey("left", Left_Key, 0xB3, 8);
+}
+
+
+// I'm not making this one a subset, it's just too different:
+EpsonProjector2::EpsonProjector2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Projector Keyset 2",
+      Epson_Make,
+      index)
+{
+}
+
+
+void EpsonProjector2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x5583, 16);
+
+  addKey("ASPECT", AspectRatio_Key, 0x8A, 8);
+  addKey("ESC", Exit_Key, 0x84, 8);
+  addKey("SELECT", Select_Key, 0x85, 8);
+  addKey("MEMORY", Memory_Key, 0x8B, 8);
+  addKey("COLOR-MODE", PictureMode_Key, 0x8F, 8);
+
+  addKey("POWER", Power_Key, 0x90, 8);
+  addKey("PAUSE", Pause_Key, 0x92, 8);
+  addKey("MUTE", Mute_Key, 0x93, 8);
+  addKey("MENU", Menu_Key, 0x9A, 8);
+  addKey("VIDEO", Unmapped_Key, 0x9C, 8);
+  addKey("INPUT-A-B", Unmapped_Key, 0x9D, 8);
+  addKey("AUTO", Info_Key, 0x9E, 8); // bit of a hack
+
+  addKey("UP", Up_Key, 0xB0, 8);
+  addKey("RIGHT", Right_Key, 0xB1, 8);
+  addKey("DOWN", Down_Key, 0xB2, 8);
+  addKey("LEFT", Left_Key, 0xB3, 8);
+}
diff --git a/keysets/epson.h b/keysets/epson.h
new file mode 100644 (file)
index 0000000..7bd2ec4
--- /dev/null
@@ -0,0 +1,28 @@
+#ifndef EPSON_H
+#define EPSON_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class EpsonProjector1: public PIRKeysetMetaData
+{
+public:
+  EpsonProjector1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class EpsonProjector2: public PIRKeysetMetaData
+{
+public:
+  EpsonProjector2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // EPSON_H
diff --git a/keysets/humax.cpp b/keysets/humax.cpp
new file mode 100644 (file)
index 0000000..5553e4f
--- /dev/null
@@ -0,0 +1,213 @@
+#include "humax.h"
+#include "protocols/necprotocol.h"
+
+
+HumaxReceiver1::HumaxReceiver1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "STB Keyset 1",
+      Humax_Make,
+      index)
+{
+}
+
+
+void HumaxReceiver1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x1000, 16);
+
+  addKey("power", Power_Key, 0x00, 8);
+  addKey("tvsat", Input_Key, 0x02, 8); // "SOURCE"
+  addKey("1", One_Key, 0x03, 8);
+  addKey("2", Two_Key, 0x04, 8);
+  addKey("3", Three_Key, 0x05, 8);
+  addKey("4", Four_Key, 0x06, 8);
+  addKey("5", Five_Key, 0x07, 8);
+  addKey("6", Six_Key, 0x08, 8);
+  addKey("7", Seven_Key, 0x09, 8);
+  addKey("8", Eight_Key, 0x0A, 8);
+  addKey("9", Nine_Key, 0x0B, 8);
+  addKey("0", Zero_Key, 0x0C, 8);
+  addKey("tone", TunerInput_Key, 0x0D, 8); // "ton" "TV/RADIO"
+  addKey("menu", Menu_Key, 0x0E, 8);
+  addKey("p-", ChannelDown_Key, 0x0F, 8);
+
+  addKey("p+", ChannelUp_Key, 0x10, 8);
+  addKey("up", Up_Key, 0x11, 8);
+  addKey("left", Left_Key, 0x12, 8);
+  addKey("ok", Select_Key, 0x13, 8);
+  addKey("right", Right_Key, 0x14, 8);
+  addKey("down", Down_Key, 0x15, 8);
+  addKey("exit", Exit_Key, 0x16, 8); // "gray"
+  addKey("?", Unmapped_Key, 0x17, 8);
+  addKey("mute", Mute_Key, 0x18, 8);
+  addKey("time", Unmapped_Key, 0x19, 8); // "white"
+  addKey("yellow", Yellow_Key, 0x1A, 8);
+  addKey("epg", Guide_Key, 0x1B, 8);
+  addKey("red", Red_Key, 0x1C, 8);
+  addKey("green", Green_Key, 0x1D, 8);
+  addKey("blue", Blue_Key, 0x1E, 8);
+  addKey("vol+", VolumeUp_Key, 0x1F, 8);
+
+  addKey("vol-", VolumeDown_Key, 0x40, 8);
+  addKey("rcl", PrevChannel_Key, 0x41, 8); // might be wrong
+  addKey("INFO", Info_Key, 0x43, 8);
+  addKey("LIST", HDDInput_Key, 0x4D, 8);
+
+  addKey("PLAY", Play_Key, 0x60, 8);
+  addKey("REC", Record_Key, 0x61, 8);
+  addKey("PAUSE", Pause_Key, 0x62, 8);
+  addKey("STOP", Stop_Key, 0x63, 8);
+  addKey("FFWD", FastForward_Key, 0x64, 8);
+  addKey("REW", Rewind_Key, 0x65, 8);
+}
+
+
+// Ugly!  Humax has two different keysets using the same device code. :(
+HumaxReceiver2::HumaxReceiver2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "STB Keyset 2",
+      Humax_Make,
+      index)
+{
+}
+
+
+void HumaxReceiver2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x1000, 16);
+
+  addKey("power", Power_Key, 0x00, 8);
+  addKey("tv", Input_Key, 0x02, 8);
+  addKey("radio", TunerInput_Key, 0x03, 8);
+  addKey("1", One_Key, 0x04, 8);
+  addKey("2", Two_Key, 0x05, 8);
+  addKey("3", Three_Key, 0x06, 8);
+  addKey("display", Info_Key, 0x07, 8);
+  addKey("4", Four_Key, 0x08, 8);
+  addKey("5", Five_Key, 0x09, 8);
+  addKey("6", Six_Key, 0x0A, 8);
+  addKey("audio", Audio_Key, 0x0B, 8);
+  addKey("7", Seven_Key, 0x0C, 8);
+  addKey("8", Eight_Key, 0x0D, 8);
+  addKey("9", Nine_Key, 0x0E, 8);
+  addKey("mute", Mute_Key, 0x0F, 8);
+
+  addKey("uhf", Unmapped_Key, 0x10, 8);
+  addKey("0", Zero_Key, 0x11, 8);
+  addKey("teletext", Teletext_Key, 0x12, 8);
+  addKey("ok", Select_Key, 0x13, 8);
+  addKey("reserved", Unmapped_Key, 0x14, 8);
+  addKey("down", Down_Key, 0x15, 8);
+  addKey("gray", Unmapped_Key, 0x16, 8);
+  addKey("ch+", ChannelUp_Key, 0x17, 8);
+  addKey("menu", Menu_Key, 0x18, 8);
+  addKey("up", Up_Key, 0x19, 8);
+  addKey("epg", Guide_Key, 0x1A, 8);
+  addKey("ch-", ChannelDown_Key, 0x1B, 8);
+  addKey("left", Left_Key, 0x1C, 8);
+  addKey("ok", Select_Key, 0x1D, 8);
+  addKey("right", Right_Key, 0x1E, 8);
+  addKey("v+", VolumeUp_Key, 0x1F, 8);
+
+  addKey("v-", VolumeDown_Key, 0x40, 8);
+  addKey("down", Down_Key, 0x41, 8);
+}
+
+
+HumaxReceiver3::HumaxReceiver3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "STB Keyset 3",
+      Humax_Make,
+      index)
+{
+}
+
+
+void HumaxReceiver3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x1702, 16);
+
+  addKey("power", Power_Key, 0x00, 8);
+  addKey("source", Input_Key, 0x02, 8);
+  addKey("1", One_Key, 0x03, 8);
+  addKey("2", Two_Key, 0x04, 8);
+  addKey("3", Three_Key, 0x05, 8);
+  addKey("4", Four_Key, 0x06, 8);
+  addKey("5", Five_Key, 0x07, 8);
+  addKey("6", Six_Key, 0x08, 8);
+  addKey("7", Seven_Key, 0x09, 8);
+  addKey("8", Eight_Key, 0x0A, 8);
+  addKey("9", Nine_Key, 0x0B, 8);
+  addKey("0", Zero_Key, 0x0C, 8);
+  addKey("tv/radio", TunerInput_Key, 0x0D, 8);
+  addKey("menu", Menu_Key, 0x0E, 8);
+
+  addKey("up", Up_Key, 0x11, 8);
+  addKey("left", Left_Key, 0x12, 8);
+  addKey("ok", Select_Key, 0x13, 8);
+  addKey("right", Right_Key, 0x14, 8);
+  addKey("down", Down_Key, 0x15, 8);
+  addKey("back", Exit_Key, 0x16, 8);
+  addKey("mute", Mute_Key, 0x18, 8);
+  addKey("yellow", Yellow_Key, 0x1A, 8);
+  addKey("epg", Guide_Key, 0x1B, 8);
+  addKey("red", Red_Key, 0x1C, 8);
+  addKey("green", Green_Key, 0x1D, 8);
+  addKey("blue", Blue_Key, 0x1E, 8);
+  addKey("vol+", VolumeUp_Key, 0x1F, 8);
+
+  addKey("vol-", VolumeDown_Key, 0x40, 8);
+  addKey("last", PrevChannel_Key, 0x41, 8);
+  addKey("info", Info_Key, 0x43, 8);
+  addKey("pip", PIP_Key, 0x46, 8);
+  addKey("movepip", PIPMove_Key, 0x48, 8);
+  addKey("swappip", PIPSwap_Key, 0x47, 8);
+  addKey("p+", ChannelUp_Key, 0x49, 8);
+  addKey("p-", ChannelDown_Key, 0x4A, 8);
+  addKey("list", HDDInput_Key, 0x4D, 8);
+  addKey("sleep", Sleep_Key, 0x4E, 8);
+  addKey("directory", Unmapped_Key, 0x4F, 8);
+
+  addKey("play", Play_Key, 0x60, 8);
+  addKey("slow", Slow_Key, 0x62, 8);
+  addKey("rec", Record_Key, 0x61, 8);
+  addKey("stop", Stop_Key, 0x63, 8);
+  addKey("ffwd", FastForward_Key, 0x64, 8);
+  addKey("rewind", Rewind_Key, 0x65, 8);
+  addKey("instreplay", Replay_Key, 0x66, 8);
+  addKey("goto", Unmapped_Key, 0x67, 8);
+  addKey("pause", Pause_Key, 0x68, 8);
+  addKey("pipch", PIPChannelUp_Key, 0x69, 8);
+  addKey("setbookmark", Unmapped_Key, 0x6A, 8);
+  addKey("listbookmarks", Unmapped_Key, 0x6B, 8);
+}
diff --git a/keysets/humax.h b/keysets/humax.h
new file mode 100644 (file)
index 0000000..865107f
--- /dev/null
@@ -0,0 +1,40 @@
+#ifndef HUMAX_H
+#define HUMAX_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class HumaxReceiver1: public PIRKeysetMetaData
+{
+public:
+  HumaxReceiver1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+
+class HumaxReceiver2: public PIRKeysetMetaData
+{
+public:
+  HumaxReceiver2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+
+class HumaxReceiver3: public PIRKeysetMetaData
+{
+public:
+  HumaxReceiver3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // HUMAX_H
index fcf3d29..5ca58b0 100644 (file)
@@ -723,6 +723,65 @@ void PanasonicAudio1::populateProtocol(
 }
 
 
+PanasonicAudio2::PanasonicAudio2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 2",
+      Panasonic_Make,
+      index)
+{
+}
+
+
+void PanasonicAudio2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x2002, 16);
+
+  addKaseikyoKey("Play/Pause", Play_Key, 0x1CA, 0x0A);
+  addKaseikyoKey("Play/Pause", Pause_Key, 0x1CA, 0x0A);
+  addKaseikyoKey("Stop", Stop_Key, 0x1CA, 0x0A);
+  addKaseikyoKey("Play_Reverse", Unmapped_Key, 0x1CA, 0x06);
+  addKaseikyoKey("Back", Previous_Key, 0x1CA, 0x49);
+  addKaseikyoKey("Forward", Next_Key, 0x1CA, 0x4A);
+  addKaseikyoKey("Mute", Mute_Key, 0x00A, 0x32);
+  addKaseikyoKey("Volume_Down", VolumeDown_Key, 0x00A, 0x21);
+  addKaseikyoKey("Volume_Up", VolumeUp_Key, 0x00A, 0x20);
+  addKaseikyoKey("Power", Power_Key, 0x1CA, 0x3D);
+  addKaseikyoKey("Sleep", Sleep_Key, 0x1CA, 0x96);
+  addKaseikyoKey("Eq", Unmapped_Key, 0x10A, 0x83);
+  addKaseikyoKey("Super_Woofer", Unmapped_Key, 0x00A, 0xC2);
+  addKaseikyoKey("1", One_Key, 0x1CA, 0x10);
+  addKaseikyoKey("2", Two_Key, 0x1CA, 0x11);
+  addKaseikyoKey("3", Three_Key, 0x1CA, 0x12);
+  addKaseikyoKey("Disc", NextDisc_Key, 0x0AA, 0xA4);
+  addKaseikyoKey("4", Four_Key, 0x1CA, 0x13);
+  addKaseikyoKey("5", Five_Key, 0x1CA, 0x14);
+  addKaseikyoKey("6", Six_Key, 0x1CA, 0x15);
+  addKaseikyoKey(">10", DoubleDigit_Key, 0x1CA, 0x84);
+  addKaseikyoKey("7", Seven_Key, 0x1CA, 0x16);
+  addKaseikyoKey("8", Eight_Key, 0x1CA, 0x17);
+  addKaseikyoKey("9", Nine_Key, 0x1CA, 0x18);
+  addKaseikyoKey("0", Zero_Key, 0x1CA, 0x19);
+  addKaseikyoKey("program", Program_Key, 0x0AA, 0x8A);
+  addKaseikyoKey("cancel", Clear_Key, 0x0AA, 0xA3);
+  addKaseikyoKey("repeat", Repeat_Key, 0x0AA, 0x47);
+  addKaseikyoKey("random", Random_Key, 0x0AA, 0x4D);
+  addKaseikyoKey("aux", AuxInput_Key, 0x00A, 0x9A);
+  addKaseikyoKey("tape", TapeInput_Key, 0x08A, 0x96);
+  addKaseikyoKey("cd", CDInput_Key, 0x00A, 0x94);
+  addKaseikyoKey("tuner", TunerInput_Key, 0x04A, 0xA4);
+}
+
+
 PanasonicAC1::PanasonicAC1(
   unsigned int index)
   : PIRKeysetMetaData(
index 1933a6a..0c16d9f 100644 (file)
@@ -135,10 +135,10 @@ public:
     QObject *guiObject);
 };
 
-class PanasonicAudio1a: public PanasonicAudio1
+class PanasonicAudio2: public PIRKeysetMetaData
 {
 public:
-  PanasonicAudio1a(
+  PanasonicAudio2(
     unsigned int index);
 
   virtual void populateProtocol(
diff --git a/keysets/technics.cpp b/keysets/technics.cpp
new file mode 100644 (file)
index 0000000..1b12d09
--- /dev/null
@@ -0,0 +1,377 @@
+#include "technics.h"
+#include "protocols/kaseikyoprotocol.h"
+
+
+TechnicsAudio1::TechnicsAudio1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio (CD) Keyset 1",
+      Technics_Make,
+      index)
+{
+}
+
+
+void TechnicsAudio1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x2002, 16);
+
+  addKaseikyoKey("stop", Stop_Key, 0x0AA, 0x00);
+  addKaseikyoKey("open/close", Eject_Key, 0x0AA, 0x01);
+  addKaseikyoKey("search_bwd", Rewind_Key, 0x0AA, 0x02); // "Rewind"
+  addKaseikyoKey("search_fwd", FastForward_Key, 0x0AA, 0x03); // "FastForward"
+  addKaseikyoKey("pause", Pause_Key, 0x0AA, 0x06);
+  addKaseikyoKey("play", Play_Key, 0x0AA, 0x0A);
+
+  addKaseikyoKey("1", One_Key, 0x0AA, 0x10);
+  addKaseikyoKey("2", Two_Key, 0x0AA, 0x11);
+  addKaseikyoKey("3", Three_Key, 0x0AA, 0x12);
+  addKaseikyoKey("4", Four_Key, 0x0AA, 0x13);
+  addKaseikyoKey("5", Five_Key, 0x0AA, 0x14);
+  addKaseikyoKey("6", Six_Key, 0x0AA, 0x15);
+  addKaseikyoKey("7", Seven_Key, 0x0AA, 0x16);
+  addKaseikyoKey("8", Eight_Key, 0x0AA, 0x17);
+  addKaseikyoKey("9", Nine_Key, 0x0AA, 0x18);
+  addKaseikyoKey("0", Zero_Key, 0x0AA, 0x19);
+
+  addKaseikyoKey("level+", VolumeUp_Key, 0x0AA, 0x20); // "VOL_UP"
+  addKaseikyoKey("level-", VolumeDown_Key, 0x0AA, 0x21); // "VOL_DOWN"
+
+  addKaseikyoKey("POWER", Power_Key, 0x0AA, 0x3D);
+
+  addKaseikyoKey("M.SCAN", Scan_Key, 0x0AA, 0x46);
+  addKaseikyoKey("repeat", Repeat_Key, 0x0AA, 0x47);
+  addKaseikyoKey("a-b_repeat", RepeatAB_Key, 0x0AA, 0x48);
+  addKaseikyoKey("skip_bwd", Previous_Key, 0x0AA, 0x49); // "PrevTrack"
+  addKaseikyoKey("skip_fwd", Next_Key, 0x0AA, 0x4A); // "NextTrack"
+  addKaseikyoKey("random", Random_Key, 0x0AA, 0x4D);
+  addKaseikyoKey("side_a-b", Unmapped_Key, 0x0AA, 0x53);
+  addKaseikyoKey("tape_length", Unmapped_Key, 0x0AA, 0x54);
+  addKaseikyoKey("time_mode", Unmapped_Key, 0x0AA, 0x55);
+
+  addKaseikyoKey("peak_search", Unmapped_Key, 0x0AA, 0x70);
+  addKaseikyoKey("auto_cue", Unmapped_Key, 0x0AA, 0x74);
+
+  addKaseikyoKey("clear", Clear_Key, 0x0AA, 0x80);
+  addKaseikyoKey("recall", Unmapped_Key, 0x0AA, 0x81); // prev channel?
+  addKaseikyoKey("+10", DoubleDigit_Key, 0x0AA, 0x84);
+  addKaseikyoKey("10", Unmapped_Key, 0x0AA, 0x85);
+  addKaseikyoKey("program", Program_Key, 0x0AA, 0x8A);
+  addKaseikyoKey("auto_cue", Unmapped_Key, 0x0AA, 0x8B);
+  addKaseikyoKey("Peak_Search", Unmapped_Key, 0x0AA, 0x8F);
+
+  addKaseikyoKey("Time_Fade", Unmapped_Key, 0x0AA, 0x94);
+
+  addKaseikyoKey("disc", NextDisc_Key, 0x0AA, 0xA4);
+  addKaseikyoKey("Tape_Length", Unmapped_Key, 0x0AA, 0xAB);
+  addKaseikyoKey("Side_A/B", Unmapped_Key, 0x0AA, 0xAC);
+
+  addKaseikyoKey("on-winamp", PowerOn_Key, 0x0AA, 0xEB); // might be wrong
+  addKaseikyoKey("spiral", Unmapped_Key, 0x0AA, 0xED);
+  addKaseikyoKey("off-winamp", PowerOff_Key, 0xAA, 0x01); // Might be wrong
+}
+
+
+TechnicsAudio1a::TechnicsAudio1a(
+  unsigned int index)
+  : TechnicsAudio1(index)
+{
+  setKeysetName("Audio Keyset 1a");
+}
+
+
+void TechnicsAudio1a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TechnicsAudio1::populateProtocol(guiObject);
+
+  addKaseikyoKey("generalvol+", VolumeUp_Key, 0x0AA, 0x46);
+  addKaseikyoKey("winampvol+", Unmapped_Key, 0x0AA, 0x47);
+  addKaseikyoKey("winampvol-", Unmapped_Key, 0x0AA, 0x55);
+  addKaseikyoKey("generalvol-", VolumeDown_Key, 0x0AA, 0x81);
+}
+
+
+TechnicsAudio2::TechnicsAudio2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 2",
+      Technics_Make,
+      index)
+{
+}
+
+
+void TechnicsAudio2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x1001, 16);
+
+  addKaseikyoKey("VOL-UP", VolumeUp_Key, 0x005, 0x20);
+  addKaseikyoKey("VOL-DOWN", VolumeDown_Key, 0x005, 0x21);
+  addKaseikyoKey("BALANCE-L", BalanceLeft_Key, 0x005, 0x26);
+  addKaseikyoKey("BALANCE-R", BalanceRight_Key, 0x005, 0x27);
+  addKaseikyoKey("MUTING", Mute_Key, 0x005, 0x32);
+  addKaseikyoKey("CD", CDInput_Key, 0x005, 0x94);
+
+  addKaseikyoKey("AUTO/MONO", FMMode_Key, 0x045, 0x33);
+  addKaseikyoKey("TUNER/BAND", TunerBand_Key, 0x045, 0xA4);
+
+  addKaseikyoKey("DECKSTOP", Unmapped_Key, 0x085, 0x00);
+  addKaseikyoKey("DECK<<", Unmapped_Key, 0x085, 0x02);
+  addKaseikyoKey("DECK>>", Unmapped_Key, 0x085, 0x03);
+  addKaseikyoKey("REC_PAUSE", Unmapped_Key, 0x085, 0x08);
+  addKaseikyoKey("DECK<", Unmapped_Key, 0x085, 0x0B);
+  addKaseikyoKey("DECK>", Unmapped_Key, 0x085, 0x0A);
+  addKaseikyoKey("DECK1/2", Unmapped_Key, 0x085, 0x95);
+
+  addKaseikyoKey("CDSTOP", Stop_Key, 0x0A5, 0x00);
+  addKaseikyoKey("CD||", Pause_Key, 0x0A5, 0x06);
+  addKaseikyoKey("CD->", Play_Key, 0x0A5, 0x0A);
+  addKaseikyoKey("CD|<<", Previous_Key, 0x0A5, 0x49);
+  addKaseikyoKey("CD>>|", Next_Key, 0x0A5, 0x4A);
+  addKaseikyoKey("PROGRAM", Program_Key, 0x0A5, 0x8A);
+  addKaseikyoKey("CANCEL", Clear_Key, 0x0A5, 0xA3);
+
+  addKaseikyoKey("EQSPACE", Unmapped_Key, 0x105, 0x83);
+  addKaseikyoKey("FLAT", Unmapped_Key, 0x105, 0x8F);
+
+  addKaseikyoKey("1", One_Key, 0x1C5, 0x10);
+  addKaseikyoKey("2", Two_Key, 0x1C5, 0x11);
+  addKaseikyoKey("3", Three_Key, 0x1C5, 0x12);
+  addKaseikyoKey("4", Four_Key, 0x1C5, 0x13);
+  addKaseikyoKey("5", Five_Key, 0x1C5, 0x14);
+  addKaseikyoKey("6", Six_Key, 0x1C5, 0x15);
+  addKaseikyoKey("7", Seven_Key, 0x1C5, 0x16);
+  addKaseikyoKey("8", Eight_Key, 0x1C5, 0x17);
+  addKaseikyoKey("9", Nine_Key, 0x1C5, 0x18);
+  addKaseikyoKey("0", Zero_Key, 0x1C5, 0x19);
+  addKaseikyoKey(">10", DoubleDigit_Key, 0x1C5, 0x84);
+  addKaseikyoKey("SLEEP", Sleep_Key, 0x1C5, 0x96);
+  addKaseikyoKey("POWER", Power_Key, 0x1C5, 0x3D);
+}
+
+
+TechnicsAudio3::TechnicsAudio3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 3",
+      Technics_Make,
+      index)
+{
+}
+
+
+void TechnicsAudio3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x2002, 16);
+
+  addKaseikyoKey("vol_up", VolumeUp_Key, 0x00A, 0x20);
+  addKaseikyoKey("vol_down", VolumeDown_Key, 0x00A, 0x21);
+  addKaseikyoKey("balance_left", BalanceLeft_Key, 0x00A, 0x26);
+  addKaseikyoKey("balance_right", BalanceRight_Key, 0x00A, 0x27);
+  addKaseikyoKey("SURROUND-UP", RearVolumeUp_Key, 0x00A, 0x2C);
+  addKaseikyoKey("SURROUND-DOWN", RearVolumeDown_Key, 0x00A, 0x2D);
+  addKaseikyoKey("muting", Mute_Key, 0x00A, 0x32);
+  addKaseikyoKey("VCR/VDP", VCRInput_Key, 0x00A, 0x86);
+  addKaseikyoKey("phono", PhonoInput_Key, 0x00A, 0x90);
+  addKaseikyoKey("Amp.Tuner", TunerInput_Key, 0x00A, 0x92);
+  addKaseikyoKey("cd", CDInput_Key, 0x00A, 0x94);
+  addKaseikyoKey("tape", TapeInput_Key, 0x00A, 0x96);
+  addKaseikyoKey("TAPE2", Unmapped_Key, 0x00A, 0x97);
+  addKaseikyoKey("ext", Unmapped_Key, 0x00A, 0x99); // "DCC"
+  addKaseikyoKey("AUX", AuxInput_Key, 0x00A, 0x9A);
+  addKaseikyoKey("vdp", Unmapped_Key, 0x00A, 0xA2); // separate keyset?
+  addKaseikyoKey("PRO-LOGIC", Unmapped_Key, 0x00A, 0xB4);
+  addKaseikyoKey("chselect", Unmapped_Key, 0x00A, 0xBB);
+  addKaseikyoKey("delay_time", Unmapped_Key, 0x00A, 0xC8);
+  addKaseikyoKey("CENTER-UP", CenterVolumeUp_Key, 0x00A, 0xCE);
+  addKaseikyoKey("CENTER-DOWN", CenterVolumeDown_Key, 0x00A, 0xCF);
+  addKaseikyoKey("TEST", Unmapped_Key, 0x00A, 0xF6);
+
+  addKaseikyoKey("auto/mono", FMMode_Key, 0x04A, 0x33);
+  addKaseikyoKey("Tuner.Preset.up", ChannelUp_Key, 0x04A, 0x34);
+  addKaseikyoKey("Tuner.Preset.down", ChannelDown_Key, 0x04A, 0x35);
+  addKaseikyoKey("tuner/band", TunerBand_Key, 0x04A, 0xA4);
+
+  addKaseikyoKey("tape_stop", Unmapped_Key, 0x08A, 0x00);
+  addKaseikyoKey("tape_open/close", Unmapped_Key, 0x08A, 0x01);
+  addKaseikyoKey("tape_rew", Unmapped_Key, 0x08A, 0x02);
+  addKaseikyoKey("tape_fwd", Unmapped_Key, 0x08A, 0x03);
+  addKaseikyoKey("rec_pause", Unmapped_Key, 0x08A, 0x08);
+  addKaseikyoKey("tape_play_fwd", Unmapped_Key, 0x08A, 0x0A);
+  addKaseikyoKey("tape_play_back", Unmapped_Key, 0x08A, 0x0B);
+  addKaseikyoKey("tape", Unmapped_Key, 0x08A, 0x95); // what is this?
+
+  addKaseikyoKey("cd_stop", Stop_Key, 0x0AA, 0x00);
+  addKaseikyoKey("cd_open/close", Eject_Key, 0x0AA, 0x01);
+  addKaseikyoKey("cd_pause", Pause_Key, 0x0AA, 0x06);
+  addKaseikyoKey("cd_play", Play_Key, 0x0AA, 0x0A);
+  addKaseikyoKey("program", Program_Key, 0x0AA, 0x2A);
+  addKaseikyoKey("repeat", Repeat_Key, 0x0AA, 0x47);
+  addKaseikyoKey("cd_back", Previous_Key, 0x0AA, 0x49);
+  addKaseikyoKey("cd_fwd", Next_Key, 0x0AA, 0x4A);
+  addKaseikyoKey("disc", NextDisc_Key, 0x0AA, 0xA4);
+  addKaseikyoKey("cancel", Clear_Key, 0x0AA, 0xA5);
+
+  addKaseikyoKey("3dai", Unmapped_Key, 0x10A, 0x31);
+  addKaseikyoKey("eq", Unmapped_Key, 0x10A, 0x83);
+  addKaseikyoKey("EQ-SPACE", Unmapped_Key, 0x10A, 0x8F);
+
+  addKaseikyoKey("supersurround", Unmapped_Key, 0x12A, 0xC0);
+  addKaseikyoKey("simulatedsurround", Unmapped_Key, 0x12A, 0xEC);
+
+  addKaseikyoKey("1", One_Key, 0x1CA, 0x10);
+  addKaseikyoKey("2", Two_Key, 0x1CA, 0x11);
+  addKaseikyoKey("3", Three_Key, 0x1CA, 0x12);
+  addKaseikyoKey("4", Four_Key, 0x1CA, 0x13);
+  addKaseikyoKey("5", Five_Key, 0x1CA, 0x14);
+  addKaseikyoKey("6", Six_Key, 0x1CA, 0x15);
+  addKaseikyoKey("7", Seven_Key, 0x1CA, 0x16);
+  addKaseikyoKey("8", Eight_Key, 0x1CA, 0x17);
+  addKaseikyoKey("9", Nine_Key, 0x1CA, 0x18);
+  addKaseikyoKey("0", Zero_Key, 0x1CA, 0x19);
+  addKaseikyoKey("power", Power_Key, 0x1CA, 0x3D);
+  addKaseikyoKey(">10", DoubleDigit_Key, 0x1CA, 0x84);
+  addKaseikyoKey("sleep", Sleep_Key, 0x1CA, 0x96);
+  addKaseikyoKey("aveffect", Unmapped_Key, 0x1CA, 0xE0);
+  addKaseikyoKey("down", Down_Key, 0x1CA, 0xF2);
+  addKaseikyoKey("up", Up_Key, 0x1CA, 0xF3);
+  addKaseikyoKey("right", Right_Key, 0x1CA, 0xFC);
+  addKaseikyoKey("left", Left_Key, 0x1CA, 0xFD);
+}
+
+
+TechnicsAudio3a::TechnicsAudio3a(
+  unsigned int index)
+  : TechnicsAudio3(index)
+{
+  setKeysetName("Audio Keyset 3a");
+}
+
+
+void TechnicsAudio3a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TechnicsAudio3::populateProtocol(guiObject);
+
+  addKaseikyoKey("tape", Unmapped_Key, 0x01A, 0x95);
+
+  addKaseikyoKey("stop", Stop_Key, 0x1CA, 0x00);
+  addKaseikyoKey("pauze", Pause_Key, 0x1CA, 0x06);
+  addKaseikyoKey("play", Play_Key, 0x1CA, 0x0A);
+  addKaseikyoKey("vorige", Previous_Key, 0x1CA, 0x49);
+  addKaseikyoKey("volgende", Next_Key, 0x1CA, 0x4A);
+}
+
+
+TechnicsDVD1::TechnicsDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Technics_Make,
+      index)
+{
+}
+
+
+void TechnicsDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x2002, 16);
+
+  addKaseikyoKey("tv/av", Unmapped_Key, 0x008, 0x05);
+  addKaseikyoKey("tvvol+", Unmapped_Key, 0x008, 0x20);
+  addKaseikyoKey("tvvol-", Unmapped_Key, 0x008, 0x21);
+
+  addKaseikyoKey("vol+", VolumeUp_Key, 0x00A, 0x20);
+  addKaseikyoKey("vol-", VolumeDown_Key, 0x00A, 0x21);
+  addKaseikyoKey("muting", Mute_Key, 0x00A, 0x32);
+  addKaseikyoKey("dvd", DVDInput_Key, 0x00A, 0xA3);
+  addKaseikyoKey("surround", Surround_Key, 0x00A, 0xB2);
+
+  addKaseikyoKey("stop", Stop_Key, 0x00B, 0x00);
+  addKaseikyoKey("play", Play_Key, 0x00B, 0x0A);
+
+  addKaseikyoKey("1", One_Key, 0x00B, 0x10);
+  addKaseikyoKey("2", Two_Key, 0x00B, 0x11);
+  addKaseikyoKey("3", Three_Key, 0x00B, 0x12);
+  addKaseikyoKey("4", Four_Key, 0x00B, 0x13);
+  addKaseikyoKey("5", Five_Key, 0x00B, 0x14);
+  addKaseikyoKey("6", Six_Key, 0x00B, 0x15);
+  addKaseikyoKey("7", Seven_Key, 0x00B, 0x16);
+  addKaseikyoKey("8", Eight_Key, 0x00B, 0x17);
+  addKaseikyoKey("9", Nine_Key, 0x00B, 0x18);
+  addKaseikyoKey("0", Zero_Key, 0x00B, 0x19);
+
+  addKaseikyoKey("power", Power_Key, 0x00B, 0x3D);
+
+  addKaseikyoKey("rewind", Rewind_Key, 0x00B, 0x49);  // previous?
+  addKaseikyoKey("forward", FastForward_Key, 0x00B, 0x4A); // Next?
+
+  addKaseikyoKey("menu", DiscMenu_Key, 0x00B, 0x80);
+  addKaseikyoKey("select", Select_Key, 0x00B, 0x82);
+  addKaseikyoKey("up", Up_Key, 0x00B, 0x85);
+  addKaseikyoKey("down", Down_Key, 0x00B, 0x86);
+  addKaseikyoKey("left", Left_Key, 0x00B, 0x87);
+  addKaseikyoKey("right", Right_Key, 0x00B, 0x88);
+  addKaseikyoKey("10", DoubleDigit_Key, 0x00B, 0x89);
+
+  addKaseikyoKey("display", Info_Key, 0x00B, 0x92);
+  addKaseikyoKey("title", DiscTitle_Key, 0x00B, 0x9B);
+
+  addKaseikyoKey("disc/deck", Unmapped_Key, 0x08A, 0x95);
+  addKaseikyoKey("processor", Unmapped_Key, 0x12A, 0x3D);
+  addKaseikyoKey("stereo", Unmapped_Key, 0x14A, 0x30);
+  addKaseikyoKey("+", Unmapped_Key, 0x14A, 0xBC);
+  addKaseikyoKey("-", Unmapped_Key, 0x14A, 0xBD);
+  addKaseikyoKey("level", Unmapped_Key, 0x14A, 0xBE);
+  addKaseikyoKey("delay", Unmapped_Key, 0x14A, 0xBF);
+  addKaseikyoKey("test", Unmapped_Key, 0x14A, 0xF6);
+}
diff --git a/keysets/technics.h b/keysets/technics.h
new file mode 100644 (file)
index 0000000..34f75b1
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef TECHNICS_H
+#define TECHNICS_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class TechnicsAudio1: public PIRKeysetMetaData
+{
+public:
+  TechnicsAudio1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnicsAudio1a: public TechnicsAudio1
+{
+public:
+  TechnicsAudio1a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnicsAudio2: public PIRKeysetMetaData
+{
+public:
+  TechnicsAudio2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnicsAudio3: public PIRKeysetMetaData
+{
+public:
+  TechnicsAudio3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnicsAudio3a: public TechnicsAudio3
+{
+public:
+  TechnicsAudio3a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnicsDVD1: public PIRKeysetMetaData
+{
+public:
+  TechnicsDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // TECHNICS_H
diff --git a/keysets/united.cpp b/keysets/united.cpp
new file mode 100644 (file)
index 0000000..af7caa8
--- /dev/null
@@ -0,0 +1,152 @@
+#include "united.h"
+#include "protocols/necprotocol.h"
+
+
+UnitedDVD1::UnitedDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      United_Make,
+      index)
+{
+}
+
+
+void UnitedDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated:
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x00, 8);
+
+  addKey("next", Next_Key, 0x06, 8);
+  addKey("prev", Previous_Key, 0x0A, 8);
+  addKey("stop", Stop_Key, 0x0B, 8);
+  addKey("ffwd", FastForward_Key, 0x0E, 8);
+  addKey("enterplay", Select_Key, 0x0F, 8);
+
+  addKey("frev", Rewind_Key, 0x12, 8);
+  addKey("playpause", Play_Key, 0x13, 8);
+  addKey("playpause", Pause_Key, 0x13, 8);
+  addKey("right", Right_Key, 0x14, 8);
+  addKey("intro", Unmapped_Key, 0x15, 8);
+  addKey("power", Power_Key, 0x16, 8);
+  addKey("3", Three_Key, 0x17, 8);
+  addKey("setup", Menu_Key, 0x18, 8);
+  addKey("down", Down_Key, 0x19, 8);
+  addKey("vmode", Unmapped_Key, 0x1A, 8);
+  addKey("2", Two_Key, 0x1B, 8);
+  addKey("left", Left_Key, 0x1C, 8);
+  addKey("clear", Clear_Key, 0x1D, 8);
+  addKey("openclose", Eject_Key, 0x1E, 8);
+  addKey("1", One_Key, 0x1F, 8);
+
+  addKey("vol+", VolumeUp_Key, 0x44, 8);
+  addKey("menu", DiscMenu_Key, 0x45, 8);
+  addKey("a-brpt", RepeatAB_Key, 0x46, 8);
+  addKey("audio", Audio_Key, 0x47, 8);
+  addKey("vol-", VolumeDown_Key, 0x48, 8);
+  addKey("title", DiscTitle_Key, 0x49, 8);
+  addKey("repeat", Repeat_Key, 0x4A, 8);
+  addKey("angle", Angle_Key, 0x4B, 8);
+  addKey("sfwd", StepForward_Key, 0x4C, 8);
+  addKey("subtitle", Captions_Key, 0x4D, 8);
+  addKey("pal_ntsc", Unmapped_Key, 0x4E, 8);
+  addKey("dsp", Unmapped_Key, 0x4F, 8);
+
+  addKey("srev", StepBack_Key, 0x50, 8);
+  addKey("prog", Program_Key, 0x51, 8);
+  addKey("zoom", Zoom_Key, 0x52, 8);
+  addKey("mute", Mute_Key, 0x53, 8);
+  addKey("6", Six_Key, 0x54, 8);
+  addKey("9", Nine_Key, 0x55, 8);
+  addKey("search", Unmapped_Key, 0x56, 8);
+  addKey("equ", Unmapped_Key, 0x57, 8);
+  addKey("5", Five_Key, 0x58, 8);
+  addKey("8", Eight_Key, 0x59, 8);
+  addKey("10+", DoubleDigit_Key, 0x5A, 8);
+  addKey("up", Up_Key, 0x5B, 8);
+  addKey("4", Four_Key, 0x5C, 8);
+  addKey("7", Seven_Key, 0x5D, 8);
+  addKey("0", Zero_Key, 0x5E, 8);
+  addKey("osd", Info_Key, 0x5F, 8);
+}
+
+
+UnitedDVBT1::UnitedDVBT1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVBT Keyset 1",
+      United_Make,
+      index)
+{
+}
+
+
+void UnitedDVBT1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated:
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x04, 8);
+
+  addKey("power", Power_Key, 0x1A, 8);
+  addKey("0", Zero_Key, 0x47, 8);
+  addKey("1", One_Key, 0x13, 8);
+  addKey("2", Two_Key, 0x10, 8);
+  addKey("3", Three_Key, 0x11, 8);
+  addKey("4", Four_Key, 0x0F, 8);
+  addKey("5", Five_Key, 0x0C, 8);
+  addKey("6", Six_Key, 0x0D, 8);
+  addKey("7", Seven_Key, 0x0B, 8);
+  addKey("8", Eight_Key, 0x09, 8);
+  addKey("9", Nine_Key, 0x08, 8);
+  addKey("vol up", VolumeUp_Key, 0x45, 8);
+  addKey("vol down", VolumeDown_Key, 0x19, 8);
+  addKey("mute", Mute_Key, 0x0E, 8);
+  addKey("channel up", ChannelUp_Key, 0x05, 8);
+  addKey("channel down", ChannelDown_Key, 0x59, 8);
+  addKey("last (prev ch)", PrevChannel_Key, 0x42, 8);
+  addKey("exit", Exit_Key, 0x0A, 8);
+  addKey("menu", Menu_Key, 0x1F, 8);
+  addKey("program guide", Guide_Key, 0x53, 8);
+  addKey("display", Info_Key, 0x1E, 8);
+  addKey("up arrow", Up_Key, 0x44, 8);
+  addKey("down arrow", Down_Key, 0x1D, 8);
+  addKey("left arrow", Left_Key, 0x1C, 8);
+  addKey("right arrow", Right_Key, 0x48, 8);
+  addKey("select", Select_Key, 0x5C, 8);
+  addKey("play", Play_Key, 0x5D, 8);
+  addKey("pause", Pause_Key, 0x4C, 8);
+  addKey("rewind", Rewind_Key, 0x50, 8);
+  addKey("fast fwd", FastForward_Key, 0x40, 8);
+  addKey("stop", Stop_Key, 0x51, 8);
+  addKey("media", Unmapped_Key, 0x00, 8);
+  addKey("red", Red_Key, 0x58, 8);
+  addKey("green", Green_Key, 0x12, 8);
+  addKey("yellow", Yellow_Key, 0x54, 8);
+  addKey("blue", Blue_Key, 0x02, 8);
+  addKey("skip+", Next_Key, 0x43, 8);
+  addKey("skip-", Previous_Key, 0x4D, 8);
+  addKey("page+", PageDown_Key, 0x04, 8);
+  addKey("page-", PageUp_Key, 0x1B, 8);
+  addKey("list", Unmapped_Key, 0x4F, 8);
+  addKey("fav", Favorites_Key, 0x06, 8);
+  addKey("aspect", AspectRatio_Key, 0x49, 8);
+  addKey("language", Audio_Key, 0x52, 8);
+  addKey("subtitle", Captions_Key, 0x14, 8);
+  addKey("teletext", Teletext_Key, 0x07, 8);
+}
+
diff --git a/keysets/united.h b/keysets/united.h
new file mode 100644 (file)
index 0000000..ebcb7a4
--- /dev/null
@@ -0,0 +1,28 @@
+#ifndef UNITED_H
+#define UNITED_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class UnitedDVD1: public PIRKeysetMetaData
+{
+public:
+  UnitedDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class UnitedDVBT1: public PIRKeysetMetaData
+{
+public:
+  UnitedDVBT1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // UNITED_H
index fc7a7d8..2abae1c 100644 (file)
@@ -123,7 +123,13 @@ SOURCES += main.cpp mainwindow.cpp \
     keysets/vizio.cpp \
     keysets/hp.cpp \
     keysets/motorola.cpp \
-    protocols/giprotocol.cpp
+    protocols/giprotocol.cpp \
+    keysets/bush.cpp \
+    keysets/canon.cpp \
+    keysets/epson.cpp \
+    keysets/humax.cpp \
+    keysets/technics.cpp \
+    keysets/united.cpp
 HEADERS += mainwindow.h \
     pirkeynames.h \
     pirmakenames.h \
@@ -221,7 +227,13 @@ HEADERS += mainwindow.h \
     keysets/vizio.h \
     keysets/hp.h \
     keysets/motorola.h \
-    protocols/giprotocol.h
+    protocols/giprotocol.h \
+    keysets/bush.h \
+    keysets/canon.h \
+    keysets/epson.h \
+    keysets/humax.h \
+    keysets/technics.h \
+    keysets/united.h
 FORMS += mainwindow.ui \
     pirdocumentationform.ui \
     piraboutform.ui \
index bb677ef..8a7fd72 100644 (file)
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.1, 2012-02-19T19:32:05. -->
+<!-- Written by Qt Creator 2.4.1, 2012-02-21T13:13:50. -->
 <qtcreator>
  <data>
   <variable>ProjectExplorer.Project.ActiveTarget</variable>
index d0c95ec..0b54b33 100644 (file)
@@ -10,7 +10,9 @@
 #include "keysets/apple.h"
 #include "keysets/beko.h"
 #include "keysets/bose.h"
+#include "keysets/bush.h"
 #include "keysets/cambridge.h"
+#include "keysets/canon.h"
 #include "keysets/daewoo.h"
 #include "keysets/denon.h"
 #include "keysets/digitalstream.h"
 #include "keysets/sharp.h"
 #include "keysets/sky.h"
 #include "keysets/sony.h"
+#include "keysets/technics.h"
 #include "keysets/tivo.h"
 #include "keysets/topfield.h"
 #include "keysets/toshiba.h"
+#include "keysets/united.h"
 #include "keysets/vestel.h"
 #include "keysets/virgin.h"
 #include "keysets/vizio.h"
@@ -117,12 +121,20 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new BoseRadio3(counter++));
   setupKeyset(new BoseHomeTheater1(counter++));
 
+  setupKeyset(new BushTV1(counter++));
+  setupKeyset(new BushTV2(counter++));
+  setupKeyset(new BushSTB1(counter++));
+
   setupKeyset(new CambridgeCD1(counter++));
   setupKeyset(new CambridgeAudio1(counter++));
   setupKeyset(new CambridgeAudio2(counter++));
   setupKeyset(new CambridgeAudio3(counter++));
   setupKeyset(new CambridgeDVD1(counter++));
 
+  setupKeyset(new CanonDSLR1(counter++));
+  setupKeyset(new CanonCamcorder1(counter++));
+  setupKeyset(new CanonPowershot1(counter++));
+
   setupKeyset(new DaewooTV1(counter++));
   setupKeyset(new DaewooTV2(counter++));
   setupKeyset(new DaewooTV3(counter++));
@@ -325,6 +337,7 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new PanasonicDVD1(counter++));
   setupKeyset(new PanasonicDVD1a(counter++));
   setupKeyset(new PanasonicAudio1(counter++));
+  setupKeyset(new PanasonicAudio2(counter++));
   setupKeyset(new PanasonicAC1(counter++));
 
   setupKeyset(new PhilcoTV(counter++));
@@ -467,6 +480,13 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new SonyVCR1b(counter++));
   setupKeyset(new SonyReceiver1(counter++));
 
+  setupKeyset(new TechnicsAudio1(counter++));
+  setupKeyset(new TechnicsAudio1a(counter++));
+  setupKeyset(new TechnicsAudio2(counter++));
+  setupKeyset(new TechnicsAudio3(counter++));
+  setupKeyset(new TechnicsAudio3a(counter++));
+  setupKeyset(new TechnicsDVD1(counter++));
+
   setupKeyset(new Tivo1(counter++));
   setupKeyset(new Tivo1a(counter++));
   setupKeyset(new Tivo1b(counter++));
@@ -493,6 +513,9 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new ToshibaDisc1c(counter++));
   setupKeyset(new ToshibaDisc1d(counter++));
 
+  setupKeyset(new UnitedDVD1(counter++));
+  setupKeyset(new UnitedDVBT1(counter++));
+
   setupKeyset(new VestelTV1(counter++));
   setupKeyset(new VestelTV2(counter++));
 
index 5496b67..6a1353a 100644 (file)
@@ -11,7 +11,9 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Apple_Make] = "Apple";
   makes[Beko_Make] = "Beko";
   makes[Bose_Make] = "Bose";
+  makes[Bush_Make] = "Bush";
   makes[Cambridge_Make] = "Cambridge Audio";
+  makes[Canon_Make] = "Canon";
   makes[Daewoo_Make] = "Daewoo";
   makes[Denon_Make] = "Denon";
   makes[DigitalStream_Make] = "Digital Stream";
@@ -56,9 +58,11 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Sharp_Make] = "Sharp";
   makes[Sky_Make] = "Sky";
   makes[Sony_Make] = "Sony";
+  makes[Technics_Make] = "Technics";
   makes[Tivo_Make] = "TiVo";
   makes[Topfield_Make] = "Topfield";
   makes[Toshiba_Make] = "Toshiba";
+  makes[United_Make] = "United";
   makes[Vestel_Make] = "Vestel";
   makes[Virgin_Make] = "Virgin Media";
   makes[Vizio_Make] = "Vizio";
index 917e67c..3867174 100644 (file)
@@ -12,7 +12,9 @@ enum PIRMakeName{
   Apple_Make,
   Beko_Make,
   Bose_Make,
+  Bush_Make,
   Cambridge_Make,
+  Canon_Make,
   Daewoo_Make,
   Denon_Make,
   DigitalStream_Make,
@@ -57,9 +59,11 @@ enum PIRMakeName{
   Sharp_Make,
   Sky_Make,
   Sony_Make,
+  Technics_Make,
   Tivo_Make,
   Topfield_Make,
   Toshiba_Make,
+  United_Make,
   Vestel_Make,
   Virgin_Make,
   Vizio_Make,
index d25c206..40745fc 100644 (file)
@@ -1,3 +1,9 @@
+pierogi (0.6.9) unstable; urgency=low
+  * Added Panasonic "SA-AK25" as Audio Keyset 2
+  * Made a first pass at keysets for Bush, Canon, Epson, Humax, Technics, and United
+
+ -- John Pietrzak <jpietrzak8@gmail.com>  Tue, 21 Feb 2012 11:36:15 -0500
+
 pierogi (0.6.8) unstable; urgency=low
   * Finally, some work to improve memory management, although much remains to be done.
   * Fixed a subtle bug in the Sky protocol.
index 882dd6d..b3db3dd 100644 (file)
@@ -11,8 +11,8 @@ Architecture: armel
 Depends: ${shlibs:Depends}, ${misc:Depends}
 Description: Universal Infrared (IR) Remote Control for N900
  Pierogi is a Universal Infrared Remote Control app for the Nokia N900.  It is independent from the LIRC server, and stores all configuration info internally.
-XB-Maemo-Upgrade-Description: Memory management improved
- A large update this time, revamping the way keysets are allocated.  Also, a fix for the Sky/Sky+ keysets, and a first pass at keysets for HP and Motorola.
+XB-Maemo-Upgrade-Description: More keysets
+ Added the Panasonic "SA-AK25" in as Audio Keyset 2, and made a first pass at keysets for Bush, Canon, Epson, Humax, Technics, and United.
 XSBC-Bugtracker: https://garage.maemo.org/tracker/?func=add&group_id=2286&atid=7641
 XB-Maemo-Display-Name: Pierogi
 XB-Maemo-Icon-26: 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

Terms of Use    Privacy Policy    Contribution Guidelines    Feedback

Powered By GForge Collaborative Development Environment