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>
Thu, 30 Aug 2012 20:26:53 +0000 (16:26 -0400)
committerJohn Pietrzak <john@pietrzak.org>
Thu, 30 Aug 2012 20:26:53 +0000 (16:26 -0400)
I'm back; the main change this time is a refreshed user interface,
back to using the real tabbed window interface.  Also, first pass
at keysets for Cisco, Gadmei, Loewe, Onkyo, Orion, Proview, Strong,
Technisat, and Telefunken, and new keysets for Panasonic, Sony,
Toshiba, and Zenith.

64 files changed:
PierogiResources.qrc
dialogs/pirtabschoicedialog.cpp [new file with mode: 0644]
dialogs/pirtabschoicedialog.h [new file with mode: 0644]
dialogs/pirtabschoicedialog.ui [new file with mode: 0644]
dialogs/pirtabswidgetitem.cpp [new file with mode: 0644]
dialogs/pirtabswidgetitem.h [new file with mode: 0644]
icons/align_just_icon&32.png [new file with mode: 0755]
keysets/cisco.cpp [new file with mode: 0644]
keysets/cisco.h [new file with mode: 0644]
keysets/fortec.cpp
keysets/gadmei.cpp [new file with mode: 0644]
keysets/gadmei.h [new file with mode: 0644]
keysets/loewe.cpp [new file with mode: 0644]
keysets/loewe.h [new file with mode: 0644]
keysets/mce.cpp
keysets/onkyo.cpp [new file with mode: 0644]
keysets/onkyo.h [new file with mode: 0644]
keysets/orion.cpp [new file with mode: 0644]
keysets/orion.h [new file with mode: 0644]
keysets/panasonic.cpp
keysets/panasonic.h
keysets/proview.cpp [new file with mode: 0644]
keysets/proview.h [new file with mode: 0644]
keysets/sony.cpp
keysets/sony.h
keysets/strong.cpp [new file with mode: 0644]
keysets/strong.h [new file with mode: 0644]
keysets/technisat.cpp [new file with mode: 0644]
keysets/technisat.h [new file with mode: 0644]
keysets/telefunken.cpp [new file with mode: 0644]
keysets/telefunken.h [new file with mode: 0644]
keysets/toshiba.cpp
keysets/toshiba.h
keysets/zenith.cpp
keysets/zenith.h
mainwindow.cpp
mainwindow.h
mainwindow.ui
pierogi.pro
pierogi.pro.user
pirkeynames.h
pirkeysetmanager.cpp
pirkeysetmetadata.cpp
pirkeysetmetadata.h
pirmakenames.cpp
pirmakenames.h
pirpanelmanager.cpp
pirpanelmanager.h
pirpanelnames.h
pirpanelselectionform.cpp [deleted file]
pirpanelselectionform.h [deleted file]
pirpanelselectionform.ui [deleted file]
pirpreferencesform.cpp
pirpreferencesform.ui
pirselectdeviceform.cpp
pirselectkeysetform.ui
protocols/paceprotocol.cpp [new file with mode: 0644]
protocols/paceprotocol.h [new file with mode: 0644]
protocols/panasonicoldprotocol.cpp [new file with mode: 0644]
protocols/panasonicoldprotocol.h [new file with mode: 0644]
protocols/pirprotocol.cpp
protocols/pirprotocol.h
protocols/thomsonprotocol.h
qtc_packaging/debian_fremantle/changelog

index a301d56..b5ac296 100644 (file)
@@ -34,5 +34,6 @@
         <file>icons/PierogiIcon.png</file>
         <file>icons/red_pause.png</file>
         <file>icons/delete_icon&amp;48.png</file>
+        <file>icons/align_just_icon&amp;32.png</file>
     </qresource>
 </RCC>
diff --git a/dialogs/pirtabschoicedialog.cpp b/dialogs/pirtabschoicedialog.cpp
new file mode 100644 (file)
index 0000000..41a84f6
--- /dev/null
@@ -0,0 +1,47 @@
+#include "pirtabschoicedialog.h"
+#include "ui_pirtabschoicedialog.h"
+
+#include "pirtabswidgetitem.h"
+#include "mainwindow.h"
+
+PIRTabsChoiceDialog::PIRTabsChoiceDialog(
+  MainWindow *mw)
+  : QDialog(0),
+    ui(new Ui::PIRTabsChoiceDialog),
+    mainWindow(mw)
+{
+  ui->setupUi(this);
+
+  ui->tabsChoiceListWidget->addItem(
+    new PIRTabsWidgetItem("Universal Panels", Universal_Tabs));
+
+  ui->tabsChoiceListWidget->addItem(
+    new PIRTabsWidgetItem("Television Panels", TV_Tabs));
+
+  ui->tabsChoiceListWidget->addItem(
+    new PIRTabsWidgetItem("Video Media Panels", VideoMedia_Tabs));
+
+  ui->tabsChoiceListWidget->addItem(
+    new PIRTabsWidgetItem("Recording Panels", Record_Tabs));
+
+  ui->tabsChoiceListWidget->addItem(
+    new PIRTabsWidgetItem("Air Conditioner Panels", AC_Tabs));
+}
+
+
+PIRTabsChoiceDialog::~PIRTabsChoiceDialog()
+{
+  delete ui;
+}
+
+
+void PIRTabsChoiceDialog::on_tabsChoiceListWidget_itemClicked(
+  QListWidgetItem *item)
+{
+  PIRTabsWidgetItem *twi = dynamic_cast<PIRTabsWidgetItem *> (item);
+
+  mainWindow->setupTabs(twi->getTabBarName());
+
+  // Exit from the dialog:
+  accept();
+}
diff --git a/dialogs/pirtabschoicedialog.h b/dialogs/pirtabschoicedialog.h
new file mode 100644 (file)
index 0000000..9c210ed
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef PIRTABSCHOICEDIALOG_H
+#define PIRTABSCHOICEDIALOG_H
+
+#include <QDialog>
+
+class QListWidgetItem;
+class MainWindow;
+
+namespace Ui {
+class PIRTabsChoiceDialog;
+}
+
+class PIRTabsChoiceDialog : public QDialog
+{
+  Q_OBJECT
+  
+public:
+//  explicit PIRTabsChoiceDialog(QWidget *parent = 0);
+  PIRTabsChoiceDialog(MainWindow *mw);
+  ~PIRTabsChoiceDialog();
+  
+private slots:
+  void on_tabsChoiceListWidget_itemClicked(QListWidgetItem *item);
+
+private:
+  Ui::PIRTabsChoiceDialog *ui;
+
+  MainWindow *mainWindow;
+};
+
+#endif // PIRTABSCHOICEDIALOG_H
diff --git a/dialogs/pirtabschoicedialog.ui b/dialogs/pirtabschoicedialog.ui
new file mode 100644 (file)
index 0000000..8200c15
--- /dev/null
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>PIRTabsChoiceDialog</class>
+ <widget class="QDialog" name="PIRTabsChoiceDialog">
+  <property name="windowModality">
+   <enum>Qt::NonModal</enum>
+  </property>
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>480</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Choose Panels</string>
+  </property>
+  <property name="modal">
+   <bool>true</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <property name="margin">
+    <number>8</number>
+   </property>
+   <item>
+    <widget class="QListWidget" name="tabsChoiceListWidget"/>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/dialogs/pirtabswidgetitem.cpp b/dialogs/pirtabswidgetitem.cpp
new file mode 100644 (file)
index 0000000..b78850e
--- /dev/null
@@ -0,0 +1,15 @@
+#include "pirtabswidgetitem.h"
+
+PIRTabsWidgetItem::PIRTabsWidgetItem(
+  QString displayName,
+  PIRTabBarName internalName)
+  : QListWidgetItem(displayName),
+    tabBarName(internalName)
+{
+}
+
+
+PIRTabBarName PIRTabsWidgetItem::getTabBarName()
+{
+  return tabBarName;
+}
diff --git a/dialogs/pirtabswidgetitem.h b/dialogs/pirtabswidgetitem.h
new file mode 100644 (file)
index 0000000..7099c25
--- /dev/null
@@ -0,0 +1,21 @@
+#ifndef PIRTABSWIDGETITEM_H
+#define PIRTABSWIDGETITEM_H
+
+#include <QListWidgetItem>
+
+#include "pirpanelnames.h"
+
+class PIRTabsWidgetItem: public QListWidgetItem
+{
+public:
+  PIRTabsWidgetItem(
+    QString displayName,
+    PIRTabBarName internalName);
+
+  PIRTabBarName getTabBarName();
+
+private:
+  PIRTabBarName tabBarName;
+};
+
+#endif // PIRTABSWIDGETITEM_H
diff --git a/icons/align_just_icon&32.png b/icons/align_just_icon&32.png
new file mode 100755 (executable)
index 0000000..13e4290
Binary files /dev/null and b/icons/align_just_icon&32.png differ
diff --git a/keysets/cisco.cpp b/keysets/cisco.cpp
new file mode 100644 (file)
index 0000000..3d7e817
--- /dev/null
@@ -0,0 +1,233 @@
+#include "cisco.h"
+#include "protocols/necprotocol.h"
+#include "protocols/panasonicoldprotocol.h"
+#include "protocols/nokia32protocol.h"
+
+CiscoSTB1::CiscoSTB1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Set-Top Box Keyset 1",
+      Cisco_Make,
+      index)
+{
+  addControlledDevice(Cisco_Make, "8485DVB", Other_Device);
+}
+
+void CiscoSTB1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0xFD01, 16);
+
+  addKey("vol up", VolumeUp_Key, 0x80, 8);
+  addKey("vol down", VolumeDown_Key, 0x81, 8);
+  addKey("record", Record_Key, 0x83, 8);
+  addKey("green", Green_Key, 0x84, 8);
+  addKey("channel up", ChannelUp_Key, 0x85, 8);
+  addKey("channel down", ChannelDown_Key, 0x86, 8);
+  addKey("0", Zero_Key, 0x87, 8);
+  addKey("exit", Exit_Key, 0x88, 8);
+  addKey("red", Red_Key, 0x89, 8);
+  addKey("7", Seven_Key, 0x8A, 8);
+  addKey("8", Eight_Key, 0x8B, 8);
+  addKey("last (prev ch)", PrevChannel_Key, 0x8C, 8);
+  addKey("pagedn", PageDown_Key, 0x8C, 8);
+  addKey("replay", Replay_Key, 0x8D, 8);
+  addKey("4", Four_Key, 0x8E, 8);
+  addKey("5", Five_Key, 0x8F, 8);
+  addKey("play", Play_Key, 0x91, 8);
+  addKey("1", One_Key, 0x92, 8);
+  addKey("2", Two_Key, 0x93, 8);
+  addKey("hd", HDMIInput_Key, 0x95, 8); // Might be wrong
+  addKey("blue", Blue_Key, 0x96, 8);
+  addKey("stop", Stop_Key, 0x97, 8);
+  addKey("radio", TunerInput_Key, 0x98, 8);
+  addKey("left arrow", Left_Key, 0x99, 8);
+  addKey("mute", Mute_Key, 0x9C, 8);
+  addKey("right arrow", Right_Key, 0xC1, 8);
+  addKey("pause", Pause_Key, 0xC3, 8);
+  addKey("9", Nine_Key, 0xC4, 8);
+  addKey("program guide", Guide_Key, 0xC5, 8);
+  addKey("6", Six_Key, 0xC8, 8);
+  addKey("up arrow", Up_Key, 0xCA, 8);
+  addKey("3", Three_Key, 0xCC, 8);
+  addKey("rewind", Rewind_Key, 0xCD, 8);
+  addKey("select", Select_Key, 0xCE, 8);
+  addKey("menu", Menu_Key, 0xCF, 8);
+  addKey("fast fwd", FastForward_Key, 0xD0, 8);
+  addKey("down arrow", Down_Key, 0xD2, 8);
+  addKey("vod", Unmapped_Key, 0xD6, 8);
+  addKey("yellow", Yellow_Key, 0xD9, 8);
+  addKey("tv", Input_Key, 0xDA, 8); // Probably too obscure
+  addKey("tv", AntennaInput_Key, 0xDA, 8);
+  addKey("power", Power_Key, 0xDC, 8);
+  addKey("pageup", PageUp_Key, 0xDD, 8);
+  addKey("favourite", Favorites_Key, 0xDD, 8);
+}
+
+
+CiscoSTB2::CiscoSTB2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Set-Top Box Keyset 2",
+      Cisco_Make,
+      index)
+{
+}
+
+
+void CiscoSTB2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PanasonicOldProtocol(guiObject, index);
+
+  addPanOldKey("DirectionUp", Up_Key, 0x1B, 0x02);
+  addPanOldKey("DirectionLeft", Left_Key, 0x1B, 0x03);
+  addPanOldKey("DirectionRight", Right_Key, 0x1B, 0x04);
+  addPanOldKey("Pause", Pause_Key, 0x1B, 0x05);
+  addPanOldKey("Guide", Guide_Key, 0x1B, 0x06);
+  addPanOldKey("PowerToggle", Power_Key, 0x1B, 0x07);
+  addPanOldKey("Info", Info_Key, 0x1B, 0x08);
+  addPanOldKey("DirectionDown", Down_Key, 0x1B, 0x0B);
+  addPanOldKey("Select/Ok", Select_Key, 0x1B, 0x0C);
+  addPanOldKey("VideoSource", Input_Key, 0x1B, 0x0D);
+  addPanOldKey("ChannelPrev", PrevChannel_Key, 0x1B, 0x0E);
+  addPanOldKey("*", Unmapped_Key, 0x1B, 0x0F);
+  addPanOldKey("1", One_Key, 0x1B, 0x10);
+  addPanOldKey("2", Two_Key, 0x1B, 0x11);
+  addPanOldKey("3", Three_Key, 0x1B, 0x12);
+  addPanOldKey("4", Four_Key, 0x1B, 0x13);
+  addPanOldKey("5", Five_Key, 0x1B, 0x14);
+  addPanOldKey("6", Six_Key, 0x1B, 0x15);
+  addPanOldKey("7", Seven_Key, 0x1B, 0x16);
+  addPanOldKey("8", Eight_Key, 0x1B, 0x17);
+  addPanOldKey("9", Nine_Key, 0x1B, 0x18);
+  addPanOldKey("0", Nine_Key, 0x1B, 0x19);
+  addPanOldKey("Live", LiveTV_Key, 0x1B, 0x1A);
+  addPanOldKey("SkipForward", Advance_Key, 0x1B, 0x1B);
+  addPanOldKey("ChannelUp", ChannelUp_Key, 0x1B, 0x1D);
+  addPanOldKey("ChannelDown", ChannelDown_Key, 0x1B, 0x1E);
+  addPanOldKey("Favorite", Favorites_Key, 0x1B, 0x1F);
+  addPanOldKey("VolumeUp", VolumeUp_Key, 0x1B, 0x20);
+  addPanOldKey("VolumeDown", VolumeDown_Key, 0x1B, 0x21);
+  addPanOldKey("Mute", Mute_Key, 0x1B, 0x22);
+  addPanOldKey("List", Unmapped_Key, 0x1B, 0x26);
+  addPanOldKey("Replay", Replay_Key, 0x1B, 0x27); // "SkipBack"
+  addPanOldKey("FastForward", FastForward_Key, 0x1B, 0x28);
+  addPanOldKey("Rewind", Rewind_Key, 0x1B, 0x29);
+  addPanOldKey("Exit", Exit_Key, 0x1B, 0x2C);
+  addPanOldKey("M1", Unmapped_Key, 0x1B, 0x2D);
+  addPanOldKey("PIPChannelup", PIPChannelUp_Key, 0x1B, 0x2E);
+  addPanOldKey("Yellow A Triangle", Yellow_Key, 0x1B, 0x2F);
+  addPanOldKey("Blue B Square", Blue_Key, 0x1B, 0x30);
+  addPanOldKey("Red C Circle", Red_Key, 0x1B, 0x31);
+  addPanOldKey("Play", Play_Key, 0x1B, 0x33);
+  addPanOldKey("Stop", Stop_Key, 0x1B, 0x34);
+  addPanOldKey("Record", Record_Key, 0x1B, 0x35);
+  addPanOldKey("PageUp", PageUp_Key, 0x1B, 0x36);
+  addPanOldKey("PageDown", PageDown_Key, 0x1B, 0x37);
+  addPanOldKey("Settings", Unmapped_Key, 0x1B, 0x39);
+  addPanOldKey("#/Aspect", AspectRatio_Key, 0x1B, 0x3A);
+  addPanOldKey("PIPtoggle", PIP_Key, 0x1B, 0x3B);
+  addPanOldKey("PIPSwap", PIPSwap_Key, 0x1B, 0x3C);
+  addPanOldKey("PIPmove", PIPMove_Key, 0x1B, 0x3D);
+  addPanOldKey("Menu", Menu_Key, 0x1B, 0x3E);
+  addPanOldKey("PIPchanneldown", PIPChannelDown_Key, 0x1B, 0x3F);
+
+  addPanOldKey("Search", Unmapped_Key, 0x1C, 0x17);
+  addPanOldKey("900", Unmapped_Key, 0x1C, 0x18);
+
+  addPanOldKey("+", Unmapped_Key, 0x1F, 0x07);
+  addPanOldKey("DayUp/SkipForward", Unmapped_Key, 0x1F, 0x0F);
+  addPanOldKey("DayDown/SkipBackward", Unmapped_Key, 0x1F, 0x10);
+  addPanOldKey("OnDemand", Unmapped_Key, 0x1F, 0x1E);
+  addPanOldKey("Shift/Mode", Unmapped_Key, 0x1F, 0x1F);
+  addPanOldKey("M2", Unmapped_Key, 0x1F, 0x39); // "M1(alt)"
+  addPanOldKey("Person", Unmapped_Key, 0x1F, 0x3B);
+  addPanOldKey("Green D Diamond", Green_Key, 0x1F, 0x3D);
+}
+
+
+CiscoSTB3::CiscoSTB3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Set-Top Box Keyset 3",
+      Cisco_Make,
+      index)
+{
+}
+
+
+void CiscoSTB3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new Nokia32Protocol(guiObject, index);
+
+  setPreData(0x2480, 16);
+  setPostData(0x26, 7);
+
+  addKey("0", Zero_Key, 0x00, 8);
+  addKey("1", One_Key, 0x01, 8);
+  addKey("2", Two_Key, 0x02, 8);
+  addKey("3", Three_Key, 0x03, 8);
+  addKey("4", Four_Key, 0x04, 8);
+  addKey("5", Five_Key, 0x05, 8);
+  addKey("6", Six_Key, 0x06, 8);
+  addKey("7", Seven_Key, 0x07, 8);
+  addKey("8", Eight_Key, 0x08, 8);
+  addKey("9", Nine_Key, 0x09, 8);
+  addKey("jump", Unmapped_Key, 0x0A, 8);
+  addKey("power", Power_Key, 0x0C, 8);
+  addKey("info", Info_Key, 0x0F, 8);
+  addKey("vol up", VolumeUp_Key, 0x10, 8);
+  addKey("vol down", VolumeDown_Key, 0x11, 8);
+  addKey("channel up", ChannelUp_Key, 0x20, 8);
+  addKey("channel down", ChannelDown_Key, 0x21, 8);
+  addKey("fast fwd", FastForward_Key, 0x28, 8);
+  addKey("last (prev ch)", PrevChannel_Key, 0x29, 8);
+  addKey("rewind", Rewind_Key, 0x29, 8);
+  addKey("play", Play_Key, 0x2C, 8);
+  addKey("pause", Pause_Key, 0x30, 8);
+  addKey("stop", Stop_Key, 0x31, 8);
+  addKey("record", Record_Key, 0x37, 8);
+  addKey("a", Unmapped_Key, 0x38, 8);
+  addKey("b", Unmapped_Key, 0x39, 8);
+  addKey("multiscreen", PIP_Key, 0x3B, 8); // might be wrong
+  addKey("search", Unmapped_Key, 0x40, 8);
+  addKey("replay", Replay_Key, 0x4D, 8);
+  addKey("menu", Menu_Key, 0x54, 8);
+  addKey("exit", Exit_Key, 0x55, 8);
+  addKey("up arrow", Up_Key, 0x58, 8);
+  addKey("down arrow", Down_Key, 0x59, 8);
+  addKey("left arrow", Left_Key, 0x5A, 8);
+  addKey("right arrow", Right_Key, 0x5B, 8);
+  addKey("select", Select_Key, 0x5C, 8);
+  addKey("c", Unmapped_Key, 0x86, 8);
+  addKey("advance", Advance_Key, 0x9C, 8);
+  addKey("clear", Clear_Key, 0x9E, 8);
+  addKey("program guide", Guide_Key, 0xCC, 8);
+  addKey("interact", Unmapped_Key, 0xDA, 8);
+  addKey("tvvideo", Input_Key, 0xE8, 8);
+  addKey("recording", Record_Key, 0xF1, 8);
+  addKey("livetv", LiveTV_Key, 0xF2, 8);
+  addKey("phone", Unmapped_Key, 0xF9, 8);
+}
diff --git a/keysets/cisco.h b/keysets/cisco.h
new file mode 100644 (file)
index 0000000..6571b2b
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef CISCO_H
+#define CISCO_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class CiscoSTB1: public PIRKeysetMetaData
+{
+public:
+  CiscoSTB1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class CiscoSTB2: public PIRKeysetMetaData
+{
+public:
+  CiscoSTB2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class CiscoSTB3: public PIRKeysetMetaData
+{
+public:
+  CiscoSTB3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // CISCO_H
index f082cfe..8ffbb61 100644 (file)
@@ -82,7 +82,7 @@ void FortecReceiver2::populateProtocol(
 
   threadableProtocol = new NECProtocol(guiObject, index, true, true);
 
-  setPreData(0xFD01, 8);
+  setPreData(0xFD01, 16);
 
   addKey("channel up", ChannelUp_Key, 0x00, 8); // "up arrow"
   addKey("channel up", Up_Key, 0x00, 8); // "up arrow"
diff --git a/keysets/gadmei.cpp b/keysets/gadmei.cpp
new file mode 100644 (file)
index 0000000..d3c78f0
--- /dev/null
@@ -0,0 +1,63 @@
+#include "gadmei.h"
+#include "protocols/necprotocol.h"
+
+
+GadmeiTuner1::GadmeiTuner1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Tuner Keyset 1",
+      Gadmei_Make,
+      index)
+{
+}
+
+
+void GadmeiTuner1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0xBD02, 16);
+
+  addKey("1", One_Key, 0x00, 8);
+  addKey("2", Two_Key, 0x01, 8);
+  addKey("3", Three_Key, 0x02, 8);
+  addKey("4", Four_Key, 0x03, 8);
+  addKey("5", Five_Key, 0x04, 8);
+  addKey("6", Six_Key, 0x05, 8);
+  addKey("7", Seven_Key, 0x06, 8);
+  addKey("8", Eight_Key, 0x07, 8);
+  addKey("9", Nine_Key, 0x08, 8);
+  addKey("0", Zero_Key, 0x09, 8);
+  addKey("-/--", DoubleDigit_Key, 0x0A, 8);
+  addKey("display", Info_Key, 0x0B, 8);
+  addKey("mute", Mute_Key, 0x0C, 8);
+  addKey("speaker", Unmapped_Key, 0x0D, 8);
+  addKey("calander", Unmapped_Key, 0x0E, 8);
+  addKey("game", Unmapped_Key, 0x0F, 8);
+  addKey("vol up", VolumeUp_Key, 0x10, 8);
+  addKey("vol down", VolumeDown_Key, 0x11, 8);
+  addKey("channel up", ChannelUp_Key, 0x12, 8);
+  addKey("channel down", ChannelDown_Key, 0x13, 8);
+  addKey("power", Power_Key, 0x14, 8);
+  addKey("menu", Menu_Key, 0x15, 8);
+  addKey("AV", Input_Key, 0x17, 8);
+  addKey("timer", Sleep_Key, 0x18, 8);
+  addKey("mode", Mode_Key, 0x1A, 8);
+  addKey("recall", Unmapped_Key, 0x1C, 8);
+  addKey("FM", TunerInput_Key, 0x1E, 8);
+  addKey("NICAM", Unmapped_Key, 0x1F, 8);
+  addKey("+", Unmapped_Key, 0x40, 8);
+  addKey("PIP", PIP_Key, 0x41, 8);
+  addKey("-", Unmapped_Key, 0x42, 8);
+  addKey("still", PIPPause_Key, 0x45, 8);
+  addKey("view", Unmapped_Key, 0x46, 8);
+  addKey("OSD", Unmapped_Key, 0x49, 8);
+  addKey("resolution", AspectRatio_Key, 0x4A, 8);
+}
diff --git a/keysets/gadmei.h b/keysets/gadmei.h
new file mode 100644 (file)
index 0000000..c24a8ee
--- /dev/null
@@ -0,0 +1,18 @@
+#ifndef GADMEI_H
+#define GADMEI_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class GadmeiTuner1: public PIRKeysetMetaData
+{
+public:
+  GadmeiTuner1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // GADMEI_H
diff --git a/keysets/loewe.cpp b/keysets/loewe.cpp
new file mode 100644 (file)
index 0000000..22e3129
--- /dev/null
@@ -0,0 +1,176 @@
+#include "loewe.h"
+#include "protocols/rc5protocol.h"
+#include "protocols/necprotocol.h"
+#include "protocols/rc6protocol.h"
+
+LoeweTV1::LoeweTV1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 1",
+      Loewe_Make,
+      index)
+{
+}
+
+
+void LoeweTV1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index, 0x40);
+
+  addKey("Up", Up_Key, 0x20, 6);
+  addKey("Up", ChannelUp_Key, 0x20, 6);
+  addKey("Down", Down_Key, 0x21, 6);
+  addKey("Down", ChannelDown_Key, 0x21, 6);
+  addKey("Left", Left_Key, 0x11, 6);
+  addKey("Right", Right_Key, 0x10, 6);
+  addKey("Ok", Select_Key, 0x26, 6);
+  addKey("Red", Red_Key, 0x1B, 6);
+  addKey("Green", Green_Key, 0x1A, 6);
+  addKey("Yellow", Yellow_Key, 0x2B, 6);
+  addKey("Blue", Blue_Key, 0x28, 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("0", Zero_Key, 0x00, 6);
+  addKey("T", Unmapped_Key, 0x3C, 6);
+  addKey("M", Unmapped_Key, 0x0B, 6);
+  addKey("E", Unmapped_Key, 0x3F, 6);
+  addKey("I", Unmapped_Key, 0x27, 6);
+  addKey("Power", Power_Key, 0x0C, 6);
+  addKey("Mute", Mute_Key, 0x0D, 6);
+  addKey("Video", PictureMode_Key, 0x23, 6);
+  addKey("Audio", SoundMode_Key, 0x35, 6);
+  addKey("PiP", PIP_Key, 0x0A, 6);
+  addKey("V=", Unmapped_Key, 0x31, 6);
+  addKey("Timer", Sleep_Key, 0x0F, 6);
+}
+
+
+LoeweVCR1::LoeweVCR1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "VCR Keyset 1",
+      Loewe_Make,
+      index)
+{
+  addControlledDevice(Loewe_Make, "ViewVision 3600H", VCR_Device);
+  addControlledDevice(Loewe_Make, "ViewVision 8500H", VCR_Device);
+}
+
+
+void LoeweVCR1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x6E, 8);
+
+  addKey("POWER", Power_Key, 0x14, 8);
+  addKey("SHOW", Unmapped_Key, 0x47, 8);
+  addKey("1", One_Key, 0x05, 8);
+  addKey("2", Two_Key, 0x06, 8);
+  addKey("3", Three_Key, 0x07, 8);
+  addKey("4", Four_Key, 0x0C, 8);
+  addKey("5", Five_Key, 0x0D, 8);
+  addKey("6", Six_Key, 0x0E, 8);
+  addKey("7", Seven_Key, 0x0F, 8);
+  addKey("8", Eight_Key, 0x1C, 8);
+  addKey("9", Nine_Key, 0x1D, 8);
+  addKey("0", Zero_Key, 0x04, 8);
+  addKey("AV", CompositeInput_Key, 0x56, 8); // need to fix this
+  addKey("MENU", Menu_Key, 0x16, 8);
+  addKey("UP", Up_Key, 0x18, 8);
+  addKey("UP", ChannelUp_Key, 0x18, 8);
+  addKey("DOWN", Down_Key, 0x19, 8);
+  addKey("DOWN", ChannelDown_Key, 0x19, 8);
+  addKey("RIGHT", Right_Key, 0x90, 8);
+  addKey("LEFT", Left_Key, 0x83, 8);
+  addKey("OK", Select_Key, 0x8E, 8);
+  addKey("STILL", Pause_Key, 0x0B, 8);
+  addKey("REC", Record_Key, 0x09, 8);
+  addKey("STOP", Stop_Key, 0x01, 8);
+  addKey("REW", Rewind_Key, 0x02, 8);
+  addKey("PLAY", Play_Key, 0x08, 8);
+  addKey("FF", FastForward_Key, 0x03, 8);
+  addKey("A/T", AutoTracking_Key, 0x5F, 8);
+  addKey("TV", Input_Key, 0x15, 8);
+  addKey("LP", VHSSpeed_Key, 0x48, 8);
+  addKey("REST", Clock_Key, 0x4C, 8);
+  addKey("VISS", Unmapped_Key, 0x41, 8);
+  addKey("MARK", Unmapped_Key, 0x50, 8);
+  addKey("ERASE", Unmapped_Key, 0x42, 8);
+  addKey("0000", Reset_Key, 0x4D, 8);
+}
+
+
+LoeweDVD1::LoeweDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Loewe_Make,
+      index)
+{
+}
+
+
+void LoeweDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC6Protocol(guiObject, index, 0x04);
+
+  addKey("Up", Up_Key, 0x58, 8);
+  addKey("Down", Down_Key, 0x59, 8);
+  addKey("Left", Left_Key, 0x5A, 8);
+  addKey("Right", Right_Key, 0x5B, 8);
+  addKey("Ok", Select_Key, 0x5C, 8);
+  addKey("Red", Red_Key, 0x21, 8);
+  addKey("Green", Green_Key, 0x31, 8);
+  addKey("Yellow", Yellow_Key, 0x2C, 8);
+  addKey("Blue", Blue_Key, 0x20, 8);
+  addKey("T", Unmapped_Key, 0x30, 8);
+  addKey("M", Unmapped_Key, 0xD1, 8);
+  addKey("E", Unmapped_Key, 0x83, 8);
+  addKey("I", Unmapped_Key, 0x22, 8);
+  addKey("1", One_Key, 0x01, 8);
+  addKey("2", Two_Key, 0x02, 8);
+  addKey("3", Three_Key, 0x03, 8);
+  addKey("4", Four_Key, 0x04, 8);
+  addKey("5", Five_Key, 0x05, 8);
+  addKey("6", Six_Key, 0x06, 8);
+  addKey("7", Seven_Key, 0x07, 8);
+  addKey("8", Eight_Key, 0x08, 8);
+  addKey("9", Nine_Key, 0x09, 8);
+  addKey("0", Zero_Key, 0x00, 8);
+  addKey("Power", Power_Key, 0x0C, 8);
+  addKey("Video", PictureMode_Key, 0x4B, 8);
+  addKey("Audio", SoundMode_Key, 0x4E, 8);
+  addKey("Mute", Mute_Key, 0x0F, 8);
+  addKey("Timer", Sleep_Key, 0xC8, 8);
+  addKey("V=", Unmapped_Key, 0x1D, 8);
+  addKey("PiP", PIP_Key, 0x85, 8);
+}
diff --git a/keysets/loewe.h b/keysets/loewe.h
new file mode 100644 (file)
index 0000000..0a7d688
--- /dev/null
@@ -0,0 +1,38 @@
+#ifndef LOEWE_H
+#define LOEWE_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class LoeweTV1: public PIRKeysetMetaData
+{
+public:
+  LoeweTV1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class LoeweVCR1: public PIRKeysetMetaData
+{
+public:
+  LoeweVCR1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class LoeweDVD1: public PIRKeysetMetaData
+{
+public:
+  LoeweDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // LOEWE_H
index 27ccf08..1740a02 100644 (file)
@@ -4,7 +4,7 @@
 MCERemote1::MCERemote1(
   unsigned int index)
   : PIRKeysetMetaData(
-      "Remote mode 1",
+      "Windows MCE Remote 1",
       Microsoft_Make,
       index)
 {
@@ -104,7 +104,7 @@ MCERemote1a::MCERemote1a(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 2");
+  setKeysetName("Windows MCE Remote 2");
 }
 
 
@@ -127,7 +127,7 @@ MCERemote1b::MCERemote1b(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 3");
+  setKeysetName("Windows MCE Remote 3");
 }
 
 
@@ -150,7 +150,7 @@ MCERemote1c::MCERemote1c(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 4");
+  setKeysetName("Windows MCE Remote 4");
 }
 
 
@@ -173,7 +173,7 @@ MCERemote1d::MCERemote1d(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 5");
+  setKeysetName("Windows MCE Remote 5");
 }
 
 
@@ -196,7 +196,7 @@ MCERemote1e::MCERemote1e(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 6");
+  setKeysetName("Windows MCE Remote 6");
 }
 
 
@@ -219,7 +219,7 @@ MCERemote1f::MCERemote1f(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 7");
+  setKeysetName("Windows MCE Remote 7");
 }
 
 
@@ -242,7 +242,7 @@ MCERemote1g::MCERemote1g(
   unsigned int index)
   : MCERemote1(index)
 {
-  setKeysetName("Remote mode 8");
+  setKeysetName("Windows MCE Remote 8");
 }
 
 
diff --git a/keysets/onkyo.cpp b/keysets/onkyo.cpp
new file mode 100644 (file)
index 0000000..59b3f14
--- /dev/null
@@ -0,0 +1,507 @@
+#include "onkyo.h"
+#include "protocols/necprotocol.h"
+#include "protocols/kaseikyoprotocol.h"
+
+
+OnkyoAudio1::OnkyoAudio1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 1",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoAudio1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0xD2, 8);
+
+  addKey("PLAY", Play_Key, 0x49, 8);
+  addKey("STOP", Stop_Key, 0x4A, 8);
+  addKey("PAUSE", Pause_Key, 0x4B, 8);
+  addKey("5", Five_Key, 0x4C, 8);
+  addKey("6", Six_Key, 0x4D, 8);
+  addKey("7", Seven_Key, 0x4E, 8);
+  addKey("8", Eight_Key, 0x4F, 8);
+
+  addKey("9", Nine_Key, 0x50, 8);
+  addKey("0", Zero_Key, 0x51, 8);
+  addKey("MEMORY", Memory_Key, 0x52, 8);
+  addKey("CLEAR", Clear_Key, 0x53, 8);
+  addKey("REPEAT", Repeat_Key, 0x54, 8);
+  addKey("INDEX", Unmapped_Key, 0x55, 8);
+  addKey("DISPLAY", Info_Key, 0x56, 8); // "REMAIN"
+  addKey("A-B", RepeatAB_Key, 0x57, 8);
+  addKey("1", One_Key, 0x58, 8);
+  addKey("2", Two_Key, 0x59, 8);
+  addKey("3", Three_Key, 0x5A, 8);
+  addKey("4", Four_Key, 0x5B, 8);
+  addKey("PREV", Previous_Key, 0x5C, 8);
+  addKey("NEXT", Next_Key, 0x5D, 8);
+  addKey("REW", Rewind_Key, 0x5E, 8);
+  addKey("FFW", FastForward_Key, 0x5F, 8);
+}
+
+
+OnkyoAudio2::OnkyoAudio2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 2",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoAudio2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x0DD2, 16);
+
+  addKey("Autospace", Unmapped_Key, 0x1B, 8);
+  addKey("Pause-Record", Pause_Key, 0x18, 8);
+  addKey("Rewind", Rewind_Key, 0x1A, 8);
+  addKey("FastFwd", FastForward_Key, 0x19, 8);
+  addKey("PlayReverse", Unmapped_Key, 0x16, 8);
+  addKey("PlayForward", Play_Key, 0x15, 8);
+  addKey("SkipForward", Next_Key, 0x1D, 8);
+  addKey("Stop", Stop_Key, 0x13, 8);
+  addKey("Reset", Reset_Key, 0x5D, 8);
+}
+
+
+OnkyoAudio2a::OnkyoAudio2a(
+  unsigned int index)
+  : OnkyoAudio2(index)
+{
+  setKeysetName("Audio Keyset 2a");
+}
+
+
+void OnkyoAudio2a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  OnkyoAudio2::populateProtocol(guiObject);
+
+  addKey("TAPE_FWD", FastForward_Key, 0x80, 8);
+  addKey("TAPE_REW", Rewind_Key, 0x81, 8);
+  addKey("TAPE_VOLUME_UP", VolumeUp_Key, 0x82, 8);
+  addKey("TAPE_VOLUME_DOWN", VolumeDown_Key, 0x83, 8);
+  addKey("TAPE_REPEAT", Repeat_Key, 0x86, 8);
+  addKey("TAPE_A_B", RepeatAB_Key, 0x87, 8);
+  addKey("TAPE_CLEAR", Clear_Key, 0x88, 8);
+  addKey("TAPE_MEMORY", Memory_Key, 0x89, 8);
+  addKey("TAPE_EJECT", Eject_Key, 0x8B, 8);
+  addKey("TAPE_TRACK_8", Eight_Key, 0x8C, 8);
+  addKey("TAPE_TRACK_9", Nine_Key, 0x8D, 8);
+  addKey("TAPE_TRACK_0", Zero_Key, 0x8E, 8);
+  addKey("TAPE_TRACK_PLUS_10", DoubleDigit_Key, 0x8F, 8);
+
+  addKey("TAPE_TRACK_1", One_Key, 0x90, 8);
+  addKey("TAPE_TRACK_2", Two_Key, 0x91, 8);
+  addKey("TAPE_TRACK_3", Three_Key, 0x92, 8);
+  addKey("TAPE_TRACK_4", Four_Key, 0x93, 8);
+  addKey("TAPE_TRACK_5", Five_Key, 0x98, 8);
+  addKey("TAPE_TRACK_6", Six_Key, 0x99, 8);
+  addKey("TAPE_TRACK_7", Seven_Key, 0x9A, 8);
+  addKey("TAPE_PLAY", Play_Key, 0x9B, 8);
+  addKey("TAPE_STOP", Stop_Key, 0x9C, 8);
+  addKey("TAPE_NEXT_TRACK", Next_Key, 0x9D, 8);
+  addKey("TAPE_PREV_TRACK", Previous_Key, 0x9E, 8);
+  addKey("TAPE_PAUSE", Pause_Key, 0x9F, 8);
+
+  addKey("TAPE_SHUFFLE", Random_Key, 0xC6, 8);
+  addKey("TAPE_AUTO_SPACE", Unmapped_Key, 0xCC, 8);
+
+  addKey("TAPE_PEAK_SEARCH", Unmapped_Key, 0xDD, 8);
+}
+
+
+OnkyoAudio3::OnkyoAudio3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 3",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoAudio3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x6DD2, 16);
+
+  addKey("tuner_:_preset_>", NextPreset_Key, 0x00, 8);
+  addKey("tuner_:_preset_>", ChannelUp_Key, 0x00, 8);
+  addKey("tuner_:_preset_<", PrevPreset_Key, 0x01, 8);
+  addKey("tuner_:_preset_<", ChannelDown_Key, 0x01, 8);
+  addKey("volume_up", VolumeUp_Key, 0x02, 8);
+  addKey("volume_down", VolumeDown_Key, 0x03, 8);
+  addKey("power", Power_Key, 0x04, 8);
+  addKey("audio_muting", Mute_Key, 0x05, 8);
+  addKey("input_selector_:_aux", AuxInput_Key, 0x06, 8);
+  addKey("input_selector_:_tape_2", Unmapped_Key, 0x07, 8);
+  addKey("input_selector_:_tape_1", TapeInput_Key, 0x08, 8);
+  addKey("input_selector_:_cd", CDInput_Key, 0x09, 8);
+  addKey("input_selector_:_phono", PhonoInput_Key, 0x0A, 8);
+  addKey("input_selector_:_tuner", TunerInput_Key, 0x0B, 8);
+  addKey("input_selector_:_video_2", Unmapped_Key, 0x0D, 8);
+  addKey("input_selector_:_video_1", Unmapped_Key, 0x0E, 8);
+  addKey("v1", Unmapped_Key, 0x0F, 8); // another video?
+
+  addKey("deck_B_:#", Unmapped_Key, 0x13, 8);
+  addKey("deck_B_:>", Unmapped_Key, 0x15, 8);
+  addKey("deck_B_:<", Unmapped_Key, 0x16, 8);
+  addKey("deck_B_:O/||", Unmapped_Key, 0x18, 8);
+  addKey("deck_B_:>>", Unmapped_Key, 0x19, 8);
+  addKey("deck_B_:<<", Unmapped_Key, 0x1A, 8);
+  addKey("cd_:>", Play_Key, 0x1B, 8);
+  addKey("cd_:#", Stop_Key, 0x1C, 8);
+  addKey("cd_:>>", FastForward_Key, 0x1D, 8);
+  addKey("cd_:<<", Rewind_Key, 0x1E, 8);
+  addKey("cd_:||", Pause_Key, 0x1F, 8);
+
+  addKey("REAR_LEVEL-UP", RearVolumeUp_Key, 0x42, 8);
+  addKey("REAR_LEVEL-DOWN", RearVolumeDown_Key, 0x43, 8);
+  addKey("source_direct", Unmapped_Key, 0x44, 8); // "INPUT_SEL_DIRECT"
+  addKey("FM", Unmapped_Key, 0x46, 8);
+  addKey("AM", Unmapped_Key, 0x47, 8);
+  addKey("tuner_:_class", Unmapped_Key, 0x4A, 8); // set a preset?
+  addKey("SURROUND_FUNCTION-MODE", Surround_Key, 0x4C, 8); // "surrmode"
+  addKey("stop", Unmapped_Key, 0x4D, 8); // "deck_A_:#"
+  addKey("play", Unmapped_Key, 0x4E, 8); // "deck_A_:>"
+  addKey("deck_A_:<", Unmapped_Key, 0x4F, 8);
+
+  addKey("deck_A_:O/||", Unmapped_Key, 0x50, 8);
+  addKey("ffw", Unmapped_Key, 0x51, 8); // "deck_A_:>>"
+  addKey("rew", Unmapped_Key, 0x52, 8); // "deck_A_:<<"
+  addKey("SURROUND_FUNCTION-DELAY_TIME", Unmapped_Key, 0x53, 8);
+  addKey("speakers_A", Unmapped_Key, 0x59, 8); // "SPEAKERS_MAIN"
+  addKey("speakers_B", Unmapped_Key, 0x5A, 8); // "SPEAKERS_REMOTE"
+  addKey("CD-eject", Eject_Key, 0x5C, 8);
+  addKey("SLEEP", Sleep_Key, 0x5D, 8);
+
+  addKey("CENTER_LEVEL-UP", CenterVolumeUp_Key, 0x80, 8);
+  addKey("CENTER_LEVEL-DOWN", CenterVolumeDown_Key, 0x81, 8);
+  addKey("up", Up_Key, 0x82, 8);
+  addKey("down", Down_Key, 0x83, 8);
+  addKey("left", Left_Key, 0x84, 8);
+  addKey("right", Right_Key, 0x85, 8);
+
+  addKey("chapter_back", Unmapped_Key, 0x93, 8);
+  addKey("chapter_forward", Unmapped_Key, 0x94, 8);
+  addKey("enter", Select_Key, 0x97, 8);
+  addKey("SURROUND_FUNCTION-TEST", Unmapped_Key, 0x9A, 8);
+  addKey("actrl", Unmapped_Key, 0x9B, 8);
+  addKey("v4", Unmapped_Key, 0x9F, 8); // yet another video input
+
+  addKey("SIMUL_SOURCE_VOL-UP", Unmapped_Key, 0xC2, 8);
+  addKey("SIMUL_SOURCE_VOL-DOWN", Unmapped_Key, 0xC3, 8);
+  addKey("SIMUL_SOURCE", Unmapped_Key, 0xCC, 8);
+}
+
+
+OnkyoAudio4::OnkyoAudio4(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 4",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoAudio4::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x2CD2, 16);
+
+  addKey("CD_FWD", FastForward_Key, 0x00, 8);
+  addKey("CD_REW", Rewind_Key, 0x01, 8);
+  addKey("CD_VOLUME_UP", VolumeUp_Key, 0x02, 8);
+  addKey("CD_VOLUME_DOWN", VolumeDown_Key, 0x03, 8);
+  addKey("NEXT_SELECTION", Unmapped_Key, 0x05, 8);
+  addKey("CD_REPEAT", Repeat_Key, 0x06, 8);
+  addKey("CD_A_B", RepeatAB_Key, 0x07, 8);
+  addKey("CD_CLEAR", Clear_Key, 0x08, 8);
+  addKey("CD_MEMORY", Memory_Key, 0x09, 8);
+  addKey("CD_ELAPSED", Info_Key, 0x0A, 8); // "DISPLAY"
+  addKey("CD_EJECT", Eject_Key, 0x0B, 8);
+  addKey("CD_TRACK_8", Eight_Key, 0x0C, 8);
+  addKey("CD_TRACK_9", Nine_Key, 0x0D, 8);
+  addKey("CD_TRACK_0", Zero_Key, 0x0E, 8);
+  addKey("CD_TRACK_PLUS_10", DoubleDigit_Key, 0x0F, 8);
+
+  addKey("CD_TRACK_1", One_Key, 0x10, 8);
+  addKey("CD_TRACK_2", Two_Key, 0x11, 8);
+  addKey("CD_TRACK_3", Three_Key, 0x12, 8);
+  addKey("CD_TRACK_4", Four_Key, 0x13, 8);
+  addKey("CD_TRACK_5", Five_Key, 0x18, 8);
+  addKey("CD_TRACK_6", Six_Key, 0x19, 8);
+  addKey("CD_TRACK_7", Seven_Key, 0x1A, 8);
+  addKey("CD_PLAY", Play_Key, 0x1B, 8);
+  addKey("CD_STOP", Stop_Key, 0x1C, 8);
+  addKey("CD_NEXT_TRACK", Next_Key, 0x1D, 8);
+  addKey("CD_PREV_TRACK", Previous_Key, 0x1E, 8);
+  addKey("CD_PAUSE", Pause_Key, 0x1F, 8);
+
+  addKey("EDIT_NEXT", Unmapped_Key, 0x42, 8);
+  addKey("EDIT_PREVIOUS", Unmapped_Key, 0x43, 8);
+  addKey("INDEX", Unmapped_Key, 0x44, 8);
+  addKey("CD_SHUFFLE", Random_Key, 0x46, 8);
+  addKey("CD_AUTO_SPACE", Unmapped_Key, 0x4C, 8);
+  addKey("CD_TIME_EDIT", Unmapped_Key, 0x4D, 8);
+
+  addKey("CD_PEAK_SEARCH", Unmapped_Key, 0x5D, 8);
+  addKey("CD_FADE", Unmapped_Key, 0x5E, 8);
+}
+
+
+OnkyoAudio5::OnkyoAudio5(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 5",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoAudio5::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated
+    return;
+  }
+
+  threadableProtocol = new KaseikyoProtocol(guiObject, index);
+
+  setPreData(0x2002, 16);
+
+  addKaseikyoKey("Stop", Stop_Key, 0x0AA, 0x00);
+  addKaseikyoKey("Play/Pause", Play_Key, 0x0AA, 0x0A);
+  addKaseikyoKey("Play/Pause", Pause_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("Output+", VolumeUp_Key, 0x0AA, 0x20);
+  addKaseikyoKey("Output-", VolumeDown_Key, 0x0AA, 0x21);
+
+  addKaseikyoKey("M.Scan", Unmapped_Key, 0x0AA, 0x46);
+  addKaseikyoKey("RepeatAll", Repeat_Key, 0x0AA, 0x47);
+  addKaseikyoKey("RepeatA-B", RepeatAB_Key, 0x0AA, 0x48);
+  addKaseikyoKey("Skip/Search_Back", Rewind_Key, 0x0AA, 0x49);
+  addKaseikyoKey("Skip/Search_Forward", FastForward_Key, 0x0AA, 0x4A);
+
+  addKaseikyoKey("Clear", Clear_Key, 0x0AA, 0x80);
+  addKaseikyoKey("Recall", Unmapped_Key, 0x0AA, 0x81);
+  addKaseikyoKey(">10", DoubleDigit_Key, 0x0AA, 0x84);
+  addKaseikyoKey("10", Unmapped_Key, 0x0AA, 0x85);
+  addKaseikyoKey("Memory", Memory_Key, 0x0AA, 0x8A);
+}
+
+
+OnkyoDVD1::OnkyoDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x6CD2, 16);
+
+  addKey("mdfastforward", Unmapped_Key, 0x00, 8);
+  addKey("mdrewind", Unmapped_Key, 0x01, 8);
+  addKey("MULTI-CH-INPUT", Unmapped_Key, 0x04, 8);
+  addKey("md/tape", TapeInput_Key, 0x09, 8);
+  addKey("mdplay", Unmapped_Key, 0x0A, 8);
+  addKey("mdstop", Unmapped_Key, 0x0B, 8);
+  addKey("mdnexttrack", Unmapped_Key, 0x0C, 8);
+  addKey("mdprevtrack", Unmapped_Key, 0x0D, 8);
+  addKey("mdpause", Unmapped_Key, 0x0E, 8);
+
+  addKey("CH-LEVEL+", VolumeUp_Key, 0x42, 8); // "level+"
+  addKey("CH-LEVEL-", VolumeDown_Key, 0x43, 8); // "level-"
+  addKey("CH-SEL", Unmapped_Key, 0x44, 8);
+  addKey("standby", Power_Key, 0x47, 8);
+  addKey("stereo", Surround_Key, 0x4C, 8);
+
+  addKey("setup", Menu_Key, 0x53, 8);
+//  addKey("return", Exit_Key, 0x54, 8); // child class?
+  addKey("display", Info_Key, 0x55, 8);
+
+  addKey("DVD", DVDInput_Key, 0x8C, 8);
+  addKey("DVD_PLAY", Play_Key, 0x8D, 8);
+  addKey("DVD_STOP", Stop_Key, 0x8E, 8);
+  addKey("DVD_CHAPTER+", Next_Key, 0x8F, 8);
+  addKey("DVD_CHAPTER-", Previous_Key, 0x90, 8);
+  addKey("DVD_FF", FastForward_Key, 0x91, 8);
+  addKey("DVD_REW", Rewind_Key, 0x92, 8);
+  addKey("dvdpause", Pause_Key, 0x93, 8);
+  addKey("setup", Menu_Key, 0x97, 8);
+  addKey("topmenu", DiscTitle_Key, 0x98, 8);
+  addKey("menu", DiscMenu_Key, 0x99, 8);
+  addKey("up", Up_Key, 0x9A, 8);
+  addKey("down", Down_Key, 0x9B, 8);
+  addKey("left", Left_Key, 0x9C, 8);
+  addKey("right", Right_Key, 0x9D, 8);
+  addKey("enter", Select_Key, 0x9E, 8);
+  addKey("return", Exit_Key, 0x9F, 8);
+
+  addKey("latenight", Unmapped_Key, 0xD7, 8);
+  addKey("open", Eject_Key, 0xD8, 8);
+  addKey("audio", Audio_Key, 0xD9, 8);
+  addKey("spsetup", Unmapped_Key, 0xDB, 8);
+  addKey("swmode", Unmapped_Key, 0xDE, 8);
+  addKey("distance", Unmapped_Key, 0xDF, 8);
+}
+
+
+OnkyoDVD2::OnkyoDVD2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 2",
+      Onkyo_Make,
+      index)
+{
+}
+
+
+void OnkyoDVD2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x2BD2, 16);
+
+  addKey("Power", Power_Key, 0x04, 8);
+  addKey("OpenClose", Eject_Key, 0x05, 8);
+  addKey("Display", Info_Key, 0x06, 8);
+  addKey("Angle", Angle_Key, 0x07, 8);
+  addKey("Enter", Select_Key, 0x08, 8);
+  addKey("Return", Exit_Key, 0x09, 8);
+  addKey("Random", Random_Key, 0x0A, 8);
+  addKey("SlowForward", StepForward_Key, 0x0B, 8);
+  addKey("FastForward", FastForward_Key, 0x0C, 8);
+  addKey("FastReverse", Rewind_Key, 0x0D, 8);
+  addKey("1", One_Key, 0x0E, 8);
+  addKey("2", Two_Key, 0x0F, 8);
+
+  addKey("3", Three_Key, 0x10, 8);
+  addKey("4", Four_Key, 0x11, 8);
+  addKey("5", Five_Key, 0x12, 8);
+  addKey("6", Six_Key, 0x13, 8);
+  addKey("7", Seven_Key, 0x14, 8);
+  addKey("8", Eight_Key, 0x15, 8);
+  addKey("9", Nine_Key, 0x16, 8);
+  addKey("0", Zero_Key, 0x17, 8);
+  addKey("+10", DoubleDigit_Key, 0x18, 8);
+  addKey("Search", Unmapped_Key, 0x19, 8);
+  addKey("Play", Play_Key, 0x1B, 8);
+  addKey("Stop", Stop_Key, 0x1C, 8);
+  addKey("Next", Next_Key, 0x1D, 8);
+  addKey("Previous", Previous_Key, 0x1E, 8);
+  addKey("Pause", Pause_Key, 0x1F, 8);
+
+  addKey("Repeat", Repeat_Key, 0x44, 8);
+  addKey("A-B", RepeatAB_Key, 0x45, 8);
+  addKey("Dimmer", Unmapped_Key, 0x46, 8);
+  addKey("Zoom", Zoom_Key, 0x48, 8);
+  addKey("Memory", Memory_Key, 0x4A, 8);
+  addKey("Clear", Clear_Key, 0x4B, 8);
+  addKey("Setup", Menu_Key, 0x4D, 8);
+  addKey("TopMenu", DiscTitle_Key, 0x4E, 8);
+  addKey("Menu", DiscMenu_Key, 0x4F, 8);
+
+  addKey("Up", Up_Key, 0x50, 8);
+  addKey("Down", Down_Key, 0x51, 8);
+  addKey("Left", Left_Key, 0x52, 8);
+  addKey("Right", Right_Key, 0x53, 8);
+  addKey("Subtitle", Unmapped_Key, 0x54, 8);
+  addKey("Audio", Audio_Key, 0x55, 8);
+  addKey("SubtitleOnOff", Captions_Key, 0x56, 8);
+
+  addKey("SlowReverse", StepBack_Key, 0x8F, 8);
+  addKey("NextSelection", Unmapped_Key, 0x90, 8);
+  addKey("CDPlay", CDInput_Key, 0xD2, 8);
+  addKey("Disc+", NextDisc_Key, 0xD3, 8);
+  addKey("Disc-", PrevDisc_Key, 0xD4, 8);
+  addKey("Disc1", Unmapped_Key, 0xD5, 8);
+  addKey("Disc2", Unmapped_Key, 0xD6, 8);
+  addKey("Disc3", Unmapped_Key, 0xD7, 8);
+  addKey("Disc4", Unmapped_Key, 0xD8, 8);
+  addKey("Disc5", Unmapped_Key, 0xD9, 8);
+  addKey("Disc6", Unmapped_Key, 0xDA, 8);
+}
diff --git a/keysets/onkyo.h b/keysets/onkyo.h
new file mode 100644 (file)
index 0000000..c340799
--- /dev/null
@@ -0,0 +1,88 @@
+#ifndef ONKYO_H
+#define ONKYO_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class OnkyoAudio1: public PIRKeysetMetaData
+{
+public:
+  OnkyoAudio1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoAudio2: public PIRKeysetMetaData
+{
+public:
+  OnkyoAudio2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoAudio2a: public OnkyoAudio2
+{
+public:
+  OnkyoAudio2a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoAudio3: public PIRKeysetMetaData
+{
+public:
+  OnkyoAudio3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoAudio4: public PIRKeysetMetaData
+{
+public:
+  OnkyoAudio4(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoAudio5: public PIRKeysetMetaData
+{
+public:
+  OnkyoAudio5(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoDVD1: public PIRKeysetMetaData
+{
+public:
+  OnkyoDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OnkyoDVD2: public PIRKeysetMetaData
+{
+public:
+  OnkyoDVD2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // ONKYO_H
diff --git a/keysets/orion.cpp b/keysets/orion.cpp
new file mode 100644 (file)
index 0000000..3fea824
--- /dev/null
@@ -0,0 +1,367 @@
+#include "orion.h"
+#include "protocols/necprotocol.h"
+
+OrionTV1::OrionTV1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 1",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionTV1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, false);
+
+  setPreData(0x00, 8);
+
+  addKey("Power", Power_Key, 0x00, 8);
+  addKey("Vol-", VolumeDown_Key, 0x01, 8);
+  addKey("OK", Select_Key, 0x02, 8);
+  addKey("9", Nine_Key, 0x03, 8);
+  addKey("Lang", Unmapped_Key, 0x04, 8);
+  addKey("ChannelUp", ChannelUp_Key, 0x05, 8);
+  addKey("Vol+", VolumeUp_Key, 0x06, 8);
+  addKey("8", Eight_Key, 0x07, 8);
+  addKey("Search", Unmapped_Key, 0x08, 8);
+  addKey("Exit", Exit_Key, 0x09, 8);
+  addKey("ChannelDown", ChannelDown_Key, 0x0A, 8);
+  addKey("7", Seven_Key, 0x0B, 8);
+  addKey("Memory", Memory_Key, 0x0C, 8);
+  addKey("Mute", Mute_Key, 0x0E, 8);
+  addKey("TV/Radio", TunerInput_Key, 0x0F, 8);
+  addKey("FavoriteOnOff", Favorites_Key, 0x10, 8);
+  addKey("Menu", Menu_Key, 0x11, 8);
+  addKey("Audio", Audio_Key, 0x12, 8);
+  addKey("6", Six_Key, 0x13, 8);
+  addKey("GuideUp", Up_Key, 0x14, 8);
+  addKey("Info", Info_Key, 0x15, 8);
+  addKey("1", One_Key, 0x16, 8);
+  addKey("5", Five_Key, 0x17, 8);
+  addKey("GuideDown", Down_Key, 0x18, 8);
+  addKey("Teletext", Teletext_Key, 0x19, 8);
+  addKey("2", Two_Key, 0x1A, 8);
+  addKey("4", Four_Key, 0x1B, 8);
+  addKey("Guide", Guide_Key, 0x1C, 8);
+  addKey("PRList", Unmapped_Key, 0x1D, 8);
+  addKey("3", Three_Key, 0x1E, 8);
+  addKey("Pause", Pause_Key, 0x1F, 8);
+  addKey("Sleep", Sleep_Key, 0x40, 8);
+  addKey("0", Zero_Key, 0x44, 8);
+  addKey("P/N", Unmapped_Key, 0x48, 8);
+  addKey("Spiral", Unmapped_Key, 0x4C, 8);
+  addKey("TV/AV", Input_Key, 0x50, 8);
+  addKey("-", Left_Key, 0x54, 8); // bit of a hack
+  addKey("+", Right_Key, 0x58, 8); // also here
+  addKey("Mode", Mode_Key, 0x5C, 8);
+}
+
+
+OrionTV2::OrionTV2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 2",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionTV2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x0586, 16);
+
+  addKey("1", One_Key, 0x00, 8);
+  addKey("2", Two_Key, 0x01, 8);
+  addKey("3", Three_Key, 0x02, 8);
+  addKey("4", Four_Key, 0x03, 8);
+  addKey("5", Five_Key, 0x04, 8);
+  addKey("6", Six_Key, 0x05, 8);
+  addKey("7", Seven_Key, 0x06, 8);
+  addKey("8", Eight_Key, 0x07, 8);
+  addKey("9", Nine_Key, 0x08, 8);
+  addKey("0", Zero_Key, 0x09, 8);
+  addKey("channel up", ChannelUp_Key, 0x0A, 8);
+  addKey("channel down", ChannelDown_Key, 0x0B, 8);
+  addKey("vol up", VolumeUp_Key, 0x0C, 8);
+  addKey("vol down", VolumeDown_Key, 0x0D, 8);
+  addKey("mute", Mute_Key, 0x0E, 8);
+  addKey("power", Power_Key, 0x0F, 8);
+  addKey("prev", PrevChannel_Key, 0x10, 8);
+  addKey("input", Input_Key, 0x12, 8);
+  addKey("sleep", Sleep_Key, 0x13, 8);
+  addKey("menu", Menu_Key, 0x14, 8);
+  addKey("menu item+", Right_Key, 0x15, 8); // hack
+  addKey("menu item-", Left_Key, 0x16, 8); // also hack
+  addKey("info", Info_Key, 0x17, 8);
+  addKey("menu enter", Select_Key, 0x18, 8);
+  addKey("reset", Reset_Key, 0x19, 8);
+  addKey("caption", Captions_Key, 0x1C, 8);
+  addKey("caption channel", Unmapped_Key, 0x1D, 8);
+  addKey("secret menu", Unmapped_Key, 0x1E, 8);
+}
+
+
+OrionTV3::OrionTV3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 3",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionTV3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x0571, 16);
+
+  addKey("0", Zero_Key, 0x40, 8);
+  addKey("1", One_Key, 0x41, 8);
+  addKey("2", Two_Key, 0x42, 8);
+  addKey("3", Three_Key, 0x43, 8);
+  addKey("4", Four_Key, 0x44, 8);
+  addKey("5", Five_Key, 0x45, 8);
+  addKey("6", Six_Key, 0x46, 8);
+  addKey("7", Seven_Key, 0x47, 8);
+  addKey("8", Eight_Key, 0x48, 8);
+  addKey("9", Nine_Key, 0x49, 8);
+  addKey("Power", Power_Key, 0x4A, 8);
+  addKey("Info", Info_Key, 0x4C, 8);
+  addKey("Exit", Exit_Key, 0x4D, 8);
+  addKey("Audio", Audio_Key, 0x4E, 8);
+  addKey("Reveal", Unmapped_Key, 0x4F, 8); // teletext?
+  addKey("Sub", Captions_Key, 0x50, 8);
+  addKey("Hold", TeletextHold_Key, 0x51, 8);
+  addKey("MenuA", Unmapped_Key, 0x53, 8); // what is this?
+  addKey("Up", Up_Key, 0x56, 8);
+  addKey("Down", Down_Key, 0x57, 8);
+  addKey("Left", Left_Key, 0x58, 8);
+  addKey("Right", Right_Key, 0x59, 8);
+  addKey("OK", Select_Key, 0x5A, 8);
+  addKey("SubPage", TeletextSelect_Key, 0x5C, 8);
+  addKey("Yellow", Yellow_Key, 0x61, 8);
+  addKey("Blue", Blue_Key, 0x64, 8);
+  addKey("Red", Red_Key, 0x65, 8);
+  addKey("Enlarge", Unmapped_Key, 0x66, 8); // more txt I guess
+  addKey("Green", Green_Key, 0x68, 8);
+  addKey("TV/DVD", DVDInput_Key, 0x69, 8);
+  addKey("Mute", Mute_Key, 0x6A, 8);
+  addKey("sleep", Sleep_Key, 0x6B, 8);
+  addKey("16/9", AspectRatio_Key, 0x6C, 8);
+  addKey("Ch+", ChannelUp_Key, 0x6D, 8);
+  addKey("Ch-", ChannelDown_Key, 0x6E, 8);
+  addKey("Text", Teletext_Key, 0x71, 8);
+  addKey("Input", Input_Key, 0x73, 8);
+  addKey("PP", PrevChannel_Key, 0x7C, 8);
+  addKey("TV/DBTV", AntennaInput_Key, 0xB0, 8); // fix
+  addKey("Guide", Guide_Key, 0xB1, 8);
+  addKey("Menu", Menu_Key, 0xB2, 8);
+  addKey("TV/Radio", TunerInput_Key, 0xB3, 8);
+  addKey("Vol+", VolumeUp_Key, 0xC5, 8);
+  addKey("Vol-", VolumeDown_Key, 0xC6, 8);
+}
+
+
+OrionVCR1::OrionVCR1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "VCR Keyset 1",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionVCR1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x7B80, 16);
+
+  addKey("CH0", Zero_Key, 0x00, 8);
+  addKey("CH1", One_Key, 0x01, 8);
+  addKey("CH2", Two_Key, 0x02, 8);
+  addKey("CH3", Three_Key, 0x03, 8);
+  addKey("CH4", Four_Key, 0x04, 8);
+  addKey("CH5", Five_Key, 0x05, 8);
+  addKey("CH6", Six_Key, 0x06, 8);
+  addKey("CH7", Seven_Key, 0x07, 8);
+  addKey("CH8", Eight_Key, 0x08, 8);
+  addKey("CH9", Nine_Key, 0x09, 8);
+  addKey("CHUP", Up_Key, 0x0A, 8);
+  addKey("CHDN", Down_Key, 0x0B, 8);
+  addKey("TIMER_REC", Timer_Key, 0x0D, 8);
+  addKey("AUDIOSELECT", Audio_Key, 0x0E, 8);
+  addKey("CH10+", DoubleDigit_Key, 0x0F, 8);
+
+  addKey("TVVCR", Input_Key, 0x12, 8);
+  addKey("POWER", Power_Key, 0x13, 8);
+  addKey("INDEX", Unmapped_Key, 0x14, 8);
+  addKey("RECOTR", Record_Key, 0x15, 8);
+  addKey("PLAY", Play_Key, 0x16, 8);
+  addKey("STOP", Stop_Key, 0x17, 8);
+  addKey("FFWD", FastForward_Key, 0x18, 8);
+  addKey("REW", Rewind_Key, 0x19, 8);
+  addKey("PAUSESTILL", Pause_Key, 0x1A, 8);
+  addKey("CLOCKSET", Unmapped_Key, 0x1C, 8);
+  addKey("SHOWVIEW", Unmapped_Key, 0x1D, 8);
+  addKey("SPEEDSPLP", VHSSpeed_Key, 0x1E, 8);
+
+  addKey("PRESET", Unmapped_Key, 0x40, 8);
+  addKey("SET+", Unmapped_Key, 0x41, 8);
+  addKey("SET-", Unmapped_Key, 0x42, 8);
+  addKey("FINETUNEUP", TrackingPlus_Key, 0x43, 8);
+  addKey("FINETUNEDN", TrackingMinus_Key, 0x44, 8);
+  addKey("ENTER", Enter_Key, 0x45, 8);
+  addKey("AFT", Unmapped_Key, 0x46, 8);
+  addKey("PROGRAM", Program_Key, 0x48, 8);
+  addKey("CANCEL", Clear_Key, 0x4A, 8);
+  addKey("MEMORY", Memory_Key, 0x4B, 8);
+  addKey("RESET", Reset_Key, 0x4C, 8);
+  addKey("EJECT", Eject_Key, 0x4E, 8);
+  addKey("AUDIODUBBING", Unmapped_Key, 0x4F, 8);
+
+  addKey("MENU", Menu_Key, 0x50, 8);
+  addKey("CLOCKCOUNTER", Clock_Key, 0x51, 8);
+  addKey("ATR", AutoTracking_Key, 0x52, 8);
+  addKey("CALL", Call_Key, 0x5F, 8);
+}
+
+
+OrionVCR2::OrionVCR2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "VCR Keyset 2",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionVCR2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x7E80, 16);
+
+  addKey("repeat", Repeat_Key, 0x0A, 8);
+  addKey("power", Power_Key, 0x0B, 8);
+  addKey("play", Play_Key, 0x0C, 8);
+  addKey("stop", Stop_Key, 0x0D, 8);
+  addKey("ffwd", FastForward_Key, 0x0E, 8);
+  addKey("rew", Rewind_Key, 0x0F, 8);
+  addKey("still", Pause_Key, 0x10, 8);
+}
+
+
+OrionDVD1::OrionDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Orion_Make,
+      index)
+{
+}
+
+
+void OrionDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, false);
+
+  setPreData(0x0571, 16);
+
+  addKey("0", Zero_Key, 0x40, 8);
+  addKey("1", One_Key, 0x41, 8);
+  addKey("2", Two_Key, 0x42, 8);
+  addKey("3", Three_Key, 0x43, 8);
+  addKey("4", Four_Key, 0x44, 8);
+  addKey("5", Five_Key, 0x45, 8);
+  addKey("6", Six_Key, 0x46, 8);
+  addKey("7", Seven_Key, 0x47, 8);
+  addKey("8", Eight_Key, 0x48, 8);
+  addKey("9", Nine_Key, 0x49, 8);
+  addKey("Power", Power_Key, 0x4A, 8);
+  addKey("Info", Info_Key, 0x4C, 8);
+  addKey("Exit", Exit_Key, 0x4D, 8);
+  addKey("Audio", Audio_Key, 0x4E, 8);
+  addKey("Angle", Angle_Key, 0x4F, 8);
+  addKey("Sub", Captions_Key, 0x50, 8);
+  addKey("Slow-", SlowMinus_Key, 0x51, 8);
+  addKey("TopMenu", DiscTitle_Key, 0x52, 8);
+  addKey("Return", Exit_Key, 0x54, 8);
+  addKey("DVDMenu", DiscMenu_Key, 0x55, 8);
+  addKey("Up", Up_Key, 0x56, 8);
+  addKey("Down", Down_Key, 0x57, 8);
+  addKey("Left", Left_Key, 0x58, 8);
+  addKey("Right", Right_Key, 0x59, 8);
+  addKey("OK", Select_Key, 0x5A, 8);
+  addKey("PlayMode", Mode_Key, 0x5B, 8);
+  addKey("Mark", Unmapped_Key, 0x5C, 8);
+  addKey("Jump", Unmapped_Key, 0x5D, 8);
+  addKey("A-B", RepeatAB_Key, 0x5E, 8);
+  addKey("Zoom", Zoom_Key, 0x5F, 8);
+  addKey("Play", Play_Key, 0x60, 8);
+  addKey("Stop", Stop_Key, 0x61, 8);
+  addKey("FFW", FastForward_Key, 0x62, 8);
+  addKey("Rew", Rewind_Key, 0x63, 8);
+  addKey("Skip+", Next_Key, 0x64, 8);
+  addKey("Skip-", Previous_Key, 0x65, 8);
+  addKey("Slow+", SlowPlus_Key, 0x66, 8);
+  addKey("Pause", Pause_Key, 0x68, 8);
+  addKey("TV/DVD", DVDInput_Key, 0x69, 8);
+  addKey("Mute", Mute_Key, 0x6A, 8);
+  addKey("Sleep", Sleep_Key, 0x6B, 8);
+  addKey("16/9", AspectRatio_Key, 0x6C, 8);
+  addKey("Vol+", VolumeUp_Key, 0xC5, 8);
+  addKey("Vol-", VolumeDown_Key, 0xC6, 8);
+  addKey("Eject", Eject_Key, 0xCD, 8);
+}
diff --git a/keysets/orion.h b/keysets/orion.h
new file mode 100644 (file)
index 0000000..e7218da
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef ORION_H
+#define ORION_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class OrionTV1: public PIRKeysetMetaData
+{
+public:
+  OrionTV1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OrionTV2: public PIRKeysetMetaData
+{
+public:
+  OrionTV2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OrionTV3: public PIRKeysetMetaData
+{
+public:
+  OrionTV3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OrionVCR1: public PIRKeysetMetaData
+{
+public:
+  OrionVCR1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OrionVCR2: public PIRKeysetMetaData
+{
+public:
+  OrionVCR2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class OrionDVD1: public PIRKeysetMetaData
+{
+public:
+  OrionDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // ORION_H
index 1b8ea71..cee2505 100644 (file)
@@ -1,6 +1,7 @@
 #include "panasonic.h"
 #include "protocols/necprotocol.h"
 #include "protocols/kaseikyoprotocol.h"
+#include "protocols/panasonicoldprotocol.h"
 
 
 PanasonicCarAudio::PanasonicCarAudio(
@@ -134,6 +135,7 @@ PanasonicTV1::PanasonicTV1(
       Panasonic_Make,
       index)
 {
+  addControlledDevice(Panasonic_Make, "TX-32PD50", TV_Device);
 }
 
 
@@ -316,6 +318,87 @@ void PanasonicTV1b::populateProtocol(
 }
 
 
+PanasonicTV2::PanasonicTV2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 2",
+      Panasonic_Make,
+      index)
+{
+}
+
+
+void PanasonicTV2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PanasonicOldProtocol(guiObject, index);
+
+  addPanOldKey("Mute", Mute_Key, 0x00, 0x00);
+  addPanOldKey("R-Tune", Unmapped_Key, 0x00, 0x0A);
+  addPanOldKey("Sleep", Sleep_Key, 0x00, 0x0B);
+  addPanOldKey("TV/Video", Input_Key, 0x00, 0x0D);
+  addPanOldKey("Recall", PrevChannel_Key, 0x00, 0x0F);
+
+  addPanOldKey("ONE", One_Key, 0x00, 0x10);
+  addPanOldKey("TWO", Two_Key, 0x00, 0x11);
+  addPanOldKey("THREE", Three_Key, 0x00, 0x12);
+  addPanOldKey("FOUR", Four_Key, 0x00, 0x13);
+  addPanOldKey("FIVE", Five_Key, 0x00, 0x14);
+  addPanOldKey("SIX", Six_Key, 0x00, 0x15);
+  addPanOldKey("SEVEN", Seven_Key, 0x00, 0x16);
+  addPanOldKey("EIGHT", Eight_Key, 0x00, 0x17);
+  addPanOldKey("NINE", Nine_Key, 0x00, 0x18);
+  addPanOldKey("ZERO", Zero_Key, 0x00, 0x19);
+
+  addPanOldKey("POWER", Power_Key, 0x00, 0x20);
+  addPanOldKey("CHANNEL_UP", ChannelUp_Key, 0x00, 0x22); // "NEXT"
+  addPanOldKey("CHANNEL_DOWN", ChannelDown_Key, 0x00, 0x23); // "PREV"
+  addPanOldKey("VOLUME_UP", VolumeUp_Key, 0x00, 0x24);
+  addPanOldKey("VOLUME_DOWN", VolumeDown_Key, 0x00, 0x25);
+}
+
+
+PanasonicTV2a::PanasonicTV2a(
+  unsigned int index)
+  : PanasonicTV2(index)
+{
+  setKeysetName("TV Keyset 2a");
+}
+
+
+void PanasonicTV2a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  PanasonicTV2::populateProtocol(guiObject);
+
+  addPanOldKey("BAL_LEFT", BalanceLeft_Key, 0x00, 0x24);
+  addPanOldKey("BAL_RIGHT", BalanceRight_Key, 0x00, 0x25);
+  addPanOldKey("VOL_UP", VolumeUp_Key, 0x00, 0x01);
+  addPanOldKey("VOL_DOWN", VolumeDown_Key, 0x00, 0x0D);
+  addPanOldKey("BWD", Rewind_Key, 0x00, 0x3B);
+  addPanOldKey("FWD", FastForward_Key, 0x00, 0x3C);
+  addPanOldKey("STOP", Stop_Key, 0x00, 0x1B);
+  addPanOldKey("PAUSE", Pause_Key, 0x00, 0x2A);
+  addPanOldKey("PLAYLIST_CLEAR", Unmapped_Key, 0x00, 0x1A);
+  addPanOldKey("PLAYLIST_ADD", Unmapped_Key, 0x00, 0x36);
+  addPanOldKey("PLAY", Play_Key, 0x00, 0x3A);
+  addPanOldKey("MUTE", Mute_Key, 0x00, 0x0B);
+  addPanOldKey("QUIT", Unmapped_Key, 0x00, 0x20);
+}
+
+
 PanasonicVCR1::PanasonicVCR1(
   unsigned int index)
   : PIRKeysetMetaData(
@@ -507,6 +590,73 @@ void PanasonicVCR1c::populateProtocol(
 }
 
 
+PanasonicVCR2::PanasonicVCR2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "VCR Keyset 2",
+      Panasonic_Make,
+      index)
+{
+}
+
+
+void PanasonicVCR2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PanasonicOldProtocol(guiObject, index);
+
+  addPanOldKey("STOP", Stop_Key, 0x02, 0x00);
+  addPanOldKey("REW", Rewind_Key, 0x02, 0x02);
+  addPanOldKey("FF", FastForward_Key, 0x02, 0x03);
+  addPanOldKey("PAUSE", Pause_Key, 0x02, 0x06);
+  addPanOldKey("REC", Record_Key, 0x02, 0x08);
+  addPanOldKey("PLAY", Play_Key, 0x02, 0x0A);
+  addPanOldKey("REV_PLAY", Unmapped_Key, 0x02, 0x0B);
+  addPanOldKey("F.ADV", StepForward_Key, 0x02, 0x0C);
+  addPanOldKey("x2", Unmapped_Key, 0x02, 0x0E);
+  addPanOldKey("SLOW", Slow_Key, 0x02, 0x0F);
+  addPanOldKey("1", One_Key, 0x02, 0x10);
+  addPanOldKey("2", Two_Key, 0x02, 0x11);
+  addPanOldKey("3", Three_Key, 0x02, 0x12);
+  addPanOldKey("4", Four_Key, 0x02, 0x13);
+  addPanOldKey("5", Five_Key, 0x02, 0x14);
+  addPanOldKey("6", Six_Key, 0x02, 0x15);
+  addPanOldKey("7", Seven_Key, 0x02, 0x16);
+  addPanOldKey("8", Eight_Key, 0x02, 0x17);
+  addPanOldKey("9", Nine_Key, 0x02, 0x18);
+  addPanOldKey("0", Zero_Key, 0x02, 0x19);
+  addPanOldKey("POWER", Power_Key, 0x02, 0x20); // "vtr"
+  addPanOldKey("VOL+", VolumeUp_Key, 0x02, 0x22);
+  addPanOldKey("VOL-", VolumeDown_Key, 0x02, 0x23);
+  addPanOldKey("-/--", DoubleDigit_Key, 0x02, 0x24);
+  addPanOldKey("VTR/TV", Input_Key, 0x02, 0x2A);
+  addPanOldKey("slow+", SlowPlus_Key, 0x02, 0x2E);
+  addPanOldKey("slow-", SlowMinus_Key, 0x02, 0x2F);
+  addPanOldKey("MEMORY_SEARCH", Memory_Key, 0x02, 0x32);
+  addPanOldKey("RESET_INDEX", Reset_Key, 0x02, 0x33);
+  addPanOldKey("INTRO_SCAN", Unmapped_Key, 0x02, 0x34);
+  addPanOldKey("timer_rec", Timer_Key, 0x02, 0x36);
+  addPanOldKey("AUDIO-SELECT", Audio_Key, 0x02, 0x3D);
+
+  addPanOldKey("VPS", VHSSpeed_Key, 0x03, 0x06); // Might be wrong
+  addPanOldKey("prog", Program_Key, 0x03, 0x2C);
+  addPanOldKey("next", Next_Key, 0x03, 0x3A);
+
+  addPanOldKey("FSTORE", Unmapped_Key, 0x19, 0x10);
+  addPanOldKey("STROBE", Unmapped_Key, 0x19, 0x11);
+  addPanOldKey("CLEAR", Unmapped_Key, 0x19, 0x12);
+  addPanOldKey("GEFFECT", Unmapped_Key, 0x19, 0x17);
+  addPanOldKey("MINUS", ChannelDown_Key, 0x19, 0x19); //?
+  addPanOldKey("PLUS", ChannelUp_Key, 0x19, 0x24); //?
+}
+
+
 PanasonicDVD1::PanasonicDVD1(
   unsigned int index)
   : PIRKeysetMetaData(
@@ -823,6 +973,57 @@ void PanasonicAudio2a::populateProtocol(
 }
 
 
+PanasonicAudio3::PanasonicAudio3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Audio Keyset 3",
+      Panasonic_Make,
+      index)
+{
+}
+
+
+void PanasonicAudio3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PanasonicOldProtocol(guiObject, index);
+
+  addPanOldKey("audio_power", Power_Key, 0x09, 0x20);
+  addPanOldKey("audio_phono", PhonoInput_Key, 0x09, 0x0C);
+  addPanOldKey("vol-", VolumeDown_Key, 0x09, 0x25);
+  addPanOldKey("vol+", VolumeUp_Key, 0x09, 0x24);
+  addPanOldKey("audio_video", Input_Key, 0x09, 0x2E);
+  addPanOldKey("audio_tape", TapeInput_Key, 0x09, 0x0A);
+  addPanOldKey("tuner-", ChannelDown_Key, 0x09, 0x23);
+  addPanOldKey("tuner+", ChannelUp_Key, 0x09, 0x22);
+  addPanOldKey("cd_skip-", Previous_Key, 0x0C, 0x02);
+  addPanOldKey("cd_skip+", Next_Key, 0x0C, 0x03);
+  addPanOldKey("cd_stop", Stop_Key, 0x0C, 0x00);
+  addPanOldKey("cd_play", Play_Key, 0x0C, 0x0A);
+  addPanOldKey("vcr_power", Unmapped_Key, 0x02, 0x20);
+  addPanOldKey("vcr_stop", Unmapped_Key, 0x02, 0x00);
+  addPanOldKey("vcr_ch-", Unmapped_Key, 0x02, 0x23);
+  addPanOldKey("vcr_ch+", Unmapped_Key, 0x02, 0x22);
+  addPanOldKey("tv_vcr", Unmapped_Key, 0x02, 0x2A);
+  addPanOldKey("vcr_pause", Unmapped_Key, 0x02, 0x06);
+  addPanOldKey("vcr_rec", Unmapped_Key, 0x02, 0x08);
+  addPanOldKey("tv_power", Unmapped_Key, 0x00, 0x20);
+  addPanOldKey("vcr_play", Unmapped_Key, 0x02, 0x0A);
+  addPanOldKey("vcr_rew", Unmapped_Key, 0x02, 0x02);
+  addPanOldKey("vcr_ff", Unmapped_Key, 0x02, 0x03);
+  addPanOldKey("tv_video", Unmapped_Key, 0x00, 0x0D);
+  addPanOldKey("tv_ant", Unmapped_Key, 0x00, 0x2A);
+  addPanOldKey("tv_ch-", Unmapped_Key, 0x00, 0x23);
+  addPanOldKey("tv_ch+", Unmapped_Key, 0x00, 0x22);
+}
+
+
 PanasonicAC1::PanasonicAC1(
   unsigned int index)
   : PIRKeysetMetaData(
index 2cbb472..6c643bb 100644 (file)
@@ -65,6 +65,26 @@ public:
     QObject *guiObject);
 };
 
+class PanasonicTV2: public PIRKeysetMetaData
+{
+public:
+  PanasonicTV2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class PanasonicTV2a: public PanasonicTV2
+{
+public:
+  PanasonicTV2a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
 class PanasonicVCR1: public PIRKeysetMetaData
 {
 public:
@@ -105,6 +125,16 @@ public:
     QObject *guiObject);
 };
 
+class PanasonicVCR2: public PIRKeysetMetaData
+{
+public:
+  PanasonicVCR2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
 class PanasonicDVD1: public PIRKeysetMetaData
 {
 public:
@@ -155,6 +185,16 @@ public:
     QObject *guiObject);
 };
 
+class PanasonicAudio3: public PIRKeysetMetaData
+{
+public:
+  PanasonicAudio3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
 class PanasonicAC1: public PIRKeysetMetaData
 {
 public:
diff --git a/keysets/proview.cpp b/keysets/proview.cpp
new file mode 100644 (file)
index 0000000..5f34234
--- /dev/null
@@ -0,0 +1,62 @@
+#include "proview.h"
+#include "protocols/necprotocol.h"
+
+ProviewDVD1::ProviewDVD1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Proview_Make,
+      index)
+{
+  addControlledDevice(Proview_Make, "DVP816", DVD_Device);
+}
+
+
+void ProviewDVD1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x00, 8);
+
+  addKey("0", Zero_Key, 0x19, 8);
+  addKey("1", One_Key, 0x0C, 8);
+  addKey("2", Two_Key, 0x0D, 8);
+  addKey("3", Three_Key, 0x0E, 8);
+  addKey("4", Four_Key, 0x10, 8);
+  addKey("5", Five_Key, 0x11, 8);
+  addKey("6", Six_Key, 0x12, 8);
+  addKey("7", Seven_Key, 0x14, 8);
+  addKey("8", Eight_Key, 0x15, 8);
+  addKey("9", Nine_Key, 0x16, 8);
+  addKey("vol up", VolumeUp_Key, 0x50, 8);
+  addKey("vol down", VolumeDown_Key, 0x51, 8);
+  addKey("mute", Mute_Key, 0x00, 8);
+  addKey("power", Power_Key, 0x03, 8);
+  addKey("menu", Menu_Key, 0x5E, 8);
+  addKey("program/guide", Guide_Key, 0x54, 8);
+  addKey("exit", Exit_Key, 0x56, 8);
+  addKey("up arrow", Up_Key, 0x5D, 8);
+  addKey("down arrow", Down_Key, 0x55, 8);
+  addKey("left arrow", Left_Key, 0x58, 8);
+  addKey("right arrow", Right_Key, 0x5A, 8);
+  addKey("enter", Enter_Key, 0x59, 8);
+  addKey("ok", Select_Key, 0x59, 8);
+  addKey("play", Play_Key, 0x59, 8);
+  addKey("pause", Pause_Key, 0x1E, 8);
+  addKey("rewind", Rewind_Key, 0x48, 8);
+  addKey("fast fwd", FastForward_Key, 0x44, 8);
+  addKey("stop", Stop_Key, 0x1D, 8);
+  addKey("record", Record_Key, 0x07, 8);
+  addKey("f.fwd/next track", Next_Key, 0x49, 8);
+  addKey("f.fwd/prev track", Previous_Key, 0x45, 8);
+  addKey("+100", PlusOneHundred_Key, 0x18, 8);
+  addKey("slow", Slow_Key, 0x4D, 8);
+  addKey("advance", Advance_Key, 0x07, 8);
+}
diff --git a/keysets/proview.h b/keysets/proview.h
new file mode 100644 (file)
index 0000000..a7d5be4
--- /dev/null
@@ -0,0 +1,18 @@
+#ifndef PROVIEW_H
+#define PROVIEW_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class ProviewDVD1: public PIRKeysetMetaData
+{
+public:
+  ProviewDVD1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // PROVIEW_H
index f05f44b..78f6581 100644 (file)
@@ -740,6 +740,124 @@ void SonyDVD1c::populateProtocol(
 }
 
 
+SonyDVD2::SonyDVD2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "DVD Keyset 1",
+      Sony_Make,
+      index)
+{
+  addControlledDevice(Sony_Make, "RDR-GX360", DVD_Device);
+}
+
+
+void SonyDVD2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new SIRCProtocol(guiObject, index);
+
+  addSIRC20Key("Title List", Unmapped_Key, 0x0B, 0x1A, 0x10);
+  addSIRC20Key("Original playlist", Unmapped_Key, 0x0B, 0x1A, 0x11);
+  addSIRC20Key("Thumbnail", Unmapped_Key, 0x0B, 0x1A, 0x12);
+  addSIRC20Key("Chapter Mark", Unmapped_Key, 0x0B, 0x1A, 0x13);
+  addSIRC20Key("Instant Advance", Advance_Key, 0x0B, 0x1A, 0x14);
+  addSIRC20Key("Tools", Unmapped_Key, 0x0B, 0x1A, 0x17);
+  addSIRC20Key("Cursor Mode", Unmapped_Key, 0x0B, 0x1A, 0x18);
+  addSIRC20Key("Zoom -", Unmapped_Key, 0x0B, 0x1A, 0x19);
+  addSIRC20Key("Mark Erase", Unmapped_Key, 0x0B, 0x1A, 0x1A);
+  addSIRC20Key("Timer", Timer_Key, 0x0B, 0x1A, 0x1C);
+  addSIRC20Key("Timer List", Unmapped_Key, 0x0B, 0x1A, 0x37);
+  addSIRC20Key("Synchro Rec", Unmapped_Key, 0x0B, 0x1A, 0x77);
+  addSIRC20Key("Zoom", Zoom_Key, 0x0B, 0x1A, 0x79); // "Zoom +"
+
+  addSIRC20Key("1", One_Key, 0xFA, 0x1A, 0x00);
+  addSIRC20Key("2", Two_Key, 0xFA, 0x1A, 0x01);
+  addSIRC20Key("3", Three_Key, 0xFA, 0x1A, 0x02);
+  addSIRC20Key("4", Four_Key, 0xFA, 0x1A, 0x03);
+  addSIRC20Key("5", Five_Key, 0xFA, 0x1A, 0x04);
+  addSIRC20Key("6", Six_Key, 0xFA, 0x1A, 0x05);
+  addSIRC20Key("7", Seven_Key, 0xFA, 0x1A, 0x06);
+  addSIRC20Key("8", Eight_Key, 0xFA, 0x1A, 0x07);
+  addSIRC20Key("9", Nine_Key, 0xFA, 0x1A, 0x08);
+  addSIRC20Key("0", Zero_Key, 0xFA, 0x1A, 0x09);
+  addSIRC20Key("Select", Select_Key, 0xFA, 0x1A, 0x0B);
+  addSIRC20Key("Set", Unmapped_Key, 0xFA, 0x1A, 0x0D);
+  addSIRC20Key("Return", Exit_Key, 0xFA, 0x1A, 0x0E);
+  addSIRC20Key("Clear", Clear_Key, 0xFA, 0x1A, 0x0F);
+  addSIRC20Key("Input Select", Input_Key, 0xFA, 0x1A, 0x12);
+  addSIRC20Key("Channel +", ChannelUp_Key, 0xFA, 0x1A, 0x13);
+  addSIRC20Key("Channel -", ChannelDown_Key, 0xFA, 0x1A, 0x14);
+  addSIRC20Key("Power", Power_Key, 0xFA, 0x1A, 0x15);
+  addSIRC20Key("Eject", Eject_Key, 0xFA, 0x1A, 0x16);
+  addSIRC20Key("Record", Record_Key, 0xFA, 0x1A, 0x19);
+  addSIRC20Key("Top Menu", DiscTitle_Key, 0xFA, 0x1A, 0x1A);
+  addSIRC20Key("menu", DiscMenu_Key, 0xFA, 0x1A, 0x1B);
+  addSIRC20Key("Rec Mode", Unmapped_Key, 0xFA, 0x1A, 0x1E);
+  addSIRC20Key("Step Reverse", StepBack_Key, 0xFA, 0x1A, 0x20);
+  addSIRC20Key("Step Fwd", StepForward_Key, 0xFA, 0x1A, 0x21);
+  addSIRC20Key("Slow Forward", SlowPlus_Key, 0xFA, 0x1A, 0x23);
+  addSIRC20Key("Time/Text", Unmapped_Key, 0xFA, 0x1A, 0x28);
+  addSIRC20Key("Power On", PowerOn_Key, 0xFA, 0x1A, 0x2E);
+  addSIRC20Key("Power Off", PowerOff_Key, 0xFA, 0x1A, 0x2F);
+  addSIRC20Key("Track - (prev)", Previous_Key, 0xFA, 0x1A, 0x30);
+  addSIRC20Key("Track + (next)", Next_Key, 0xFA, 0x1A, 0x31);
+  addSIRC20Key("Play", Play_Key, 0xFA, 0x1A, 0x32);
+  addSIRC20Key("rewind", Rewind_Key, 0xFA, 0x1A, 0x33);
+  addSIRC20Key("Fast Forward", FastForward_Key, 0xFA, 0x1A, 0x34);
+  addSIRC20Key("stop", Stop_Key, 0xFA, 0x1A, 0x38);
+  addSIRC20Key("Pause", Pause_Key, 0xFA, 0x1A, 0x39);
+  addSIRC20Key("Record Stop", RecordStop_Key, 0xFA, 0x1A, 0x3D);
+  addSIRC20Key("Record Pause", RecordPause_Key, 0xFA, 0x1A, 0x3E);
+  addSIRC20Key("System Menu", Menu_Key, 0xFA, 0x1A, 0x53);
+  addSIRC20Key("Display", Info_Key, 0xFA, 0x1A, 0x54);
+  addSIRC20Key("Surround", Surround_Key, 0xFA, 0x1A, 0x5A);
+  addSIRC20Key("Instant Replay", Replay_Key, 0xFA, 0x1A, 0x5C);
+  addSIRC20Key("Subtitle", Captions_Key, 0xFA, 0x1A, 0x63);
+  addSIRC20Key("Audio", Audio_Key, 0xFA, 0x1A, 0x64);
+  addSIRC20Key("angle", Angle_Key, 0xFA, 0x1A, 0x65);
+  addSIRC20Key("Up", Up_Key, 0xFA, 0x1A, 0x79);
+  addSIRC20Key("Down", Down_Key, 0xFA, 0x1A, 0x7A);
+  addSIRC20Key("Left", Left_Key, 0xFA, 0x1A, 0x7B);
+  addSIRC20Key("Right", Right_Key, 0xFA, 0x1A, 0x7C);
+}
+
+
+SonyDVD2a::SonyDVD2a(
+  unsigned int index)
+  : SonyDVD2(index)
+{
+  setKeysetName("DVD Keyset 2a");
+
+  addControlledDevice(Sony_Make, "RDR-GX257", DVD_Device);
+}
+
+
+void SonyDVD2a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  SonyDVD2::populateProtocol(guiObject);
+
+  addSIRC20Key("top menu / title List", DiscTitle_Key, 0x0B, 0x1A, 0x10);
+  addSIRC20Key("marker", Unmapped_Key, 0x0B, 0x1A, 0x34);
+  addSIRC20Key("search", Unmapped_Key, 0x0B, 0x1A, 0x35);
+
+  addSIRC20Key("discrete off", PowerOff_Key, 0xFA, 0x1A, 0x29);
+  addSIRC20Key("play mode", Unmapped_Key, 0xFA, 0x1A, 0x31);
+}
+
+
 SonyVCR1::SonyVCR1(
   unsigned int index)
   : PIRKeysetMetaData(
@@ -1064,3 +1182,155 @@ void SonyCD1b::populateProtocol(
 
   addSIRC12Key("display", Info_Key, 0x11, 0x56);
 }
+
+
+SonyProjector1::SonyProjector1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Projector Keyset 1",
+      Sony_Make,
+      index)
+{
+  addControlledDevice(Sony_Make, "RM-1271", Other_Device);
+  addControlledDevice(Sony_Make, "VPL-SC50", Other_Device);
+  addControlledDevice(Sony_Make, "VPL-HS10", Other_Device);
+  addControlledDevice(Sony_Make, "VPL-HS20", Other_Device);
+  addControlledDevice(Sony_Make, "VH11HT", Other_Device);
+}
+
+
+void SonyProjector1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new SIRCProtocol(guiObject, index);
+
+  addSIRC15Key("Switcher 1", Unmapped_Key, 0x54, 0x0A);
+  addSIRC15Key("Switcher 2", Unmapped_Key, 0x54, 0x0B);
+  addSIRC15Key("Switcher 3", Unmapped_Key, 0x54, 0x0C);
+  addSIRC15Key("Switcher 4", Unmapped_Key, 0x54, 0x0D);
+  addSIRC15Key("Switcher 5", Unmapped_Key, 0x54, 0x0E);
+  addSIRC15Key("Switcher 6", Unmapped_Key, 0x54, 0x0F);
+  addSIRC15Key("Switcher 7", Unmapped_Key, 0x54, 0x10);
+  addSIRC15Key("Switcher 8", Unmapped_Key, 0x54, 0x11);
+  addSIRC15Key("vol up", VolumeUp_Key, 0x54, 0x12);
+  addSIRC15Key("vol down", VolumeDown_Key, 0x54, 0x13);
+  addSIRC15Key("mute", Mute_Key, 0x54, 0x14);
+  addSIRC15Key("power", Power_Key, 0x54, 0x15);
+  addSIRC15Key("Contrast+", ContrastUp_Key, 0x54, 0x18);
+  addSIRC15Key("Contrast-", ContrastDown_Key, 0x54, 0x19);
+  addSIRC15Key("Color+", ColorUp_Key, 0x54, 0x1A);
+  addSIRC15Key("Color-", ColorDown_Key, 0x54, 0x1B);
+  addSIRC15Key("Brightness+", BrightnessUp_Key, 0x54, 0x1E);
+  addSIRC15Key("Brightness-", BrightnessDown_Key, 0x54, 0x1F);
+  addSIRC15Key("Hue+", Unmapped_Key, 0x54, 0x20);
+  addSIRC15Key("Hue-", Unmapped_Key, 0x54, 0x21);
+  addSIRC15Key("Sharpness+", Unmapped_Key, 0x54, 0x22);
+  addSIRC15Key("Sharpness-", Unmapped_Key, 0x54, 0x23);
+  addSIRC15Key("Pic Mute", Unmapped_Key, 0x54, 0x24);
+  addSIRC15Key("Status ON", Unmapped_Key, 0x54, 0x25);
+  addSIRC15Key("Status OFF", Unmapped_Key, 0x54, 0x26);
+  addSIRC15Key("Secam", Unmapped_Key, 0x54, 0x27);
+  addSIRC15Key("Clear Blue", Unmapped_Key, 0x54, 0x28);
+  addSIRC15Key("menu", Menu_Key, 0x54, 0x29);
+  addSIRC15Key("video 1 input", CompositeInput_Key, 0x54, 0x2A);
+  addSIRC15Key("Input A", AuxInput_Key, 0x54, 0x2B);
+  addSIRC15Key("video 2 input", Composite2Input_Key, 0x54, 0x2C);
+  addSIRC15Key("power on", PowerOn_Key, 0x54, 0x2E);
+  addSIRC15Key("power off", PowerOff_Key, 0x54, 0x2F);
+  addSIRC15Key("Position +", Unmapped_Key, 0x54, 0x31);
+  addSIRC15Key("Position -", Unmapped_Key, 0x54, 0x32);
+  addSIRC15Key("right arrow", Right_Key, 0x54, 0x33);
+  addSIRC15Key("left arrow", Left_Key, 0x54, 0x34);
+  addSIRC15Key("up arrow", Up_Key, 0x54, 0x35);
+  addSIRC15Key("down arrow", Down_Key, 0x54, 0x36);
+  addSIRC15Key("Adjust Red", Unmapped_Key, 0x54, 0x41);
+  addSIRC15Key("Adjust Green", Unmapped_Key, 0x54, 0x42);
+  addSIRC15Key("Adjust Blue", Unmapped_Key, 0x54, 0x43);
+  addSIRC15Key("Cutoff Red", Unmapped_Key, 0x54, 0x44);
+  addSIRC15Key("Cutoff Green", Unmapped_Key, 0x54, 0x45);
+  addSIRC15Key("Cutoff Blue", Unmapped_Key, 0x54, 0x46);
+  addSIRC15Key("H Size", Unmapped_Key, 0x54, 0x47);
+  addSIRC15Key("Shift", Unmapped_Key, 0x54, 0x48);
+  addSIRC15Key("Center Red", Unmapped_Key, 0x54, 0x49);
+  addSIRC15Key("Center Green", Unmapped_Key, 0x54, 0x4A);
+  addSIRC15Key("Center Blue", Unmapped_Key, 0x54, 0x4B);
+  addSIRC15Key("Size", Unmapped_Key, 0x54, 0x4C);
+  addSIRC15Key("Linearity", Unmapped_Key, 0x54, 0x4D);
+  addSIRC15Key("Skew", Unmapped_Key, 0x54, 0x4E);
+  addSIRC15Key("Bow", Unmapped_Key, 0x54, 0x4F);
+  addSIRC15Key("Keystone", Unmapped_Key, 0x54, 0x50);
+  addSIRC15Key("Pin Cushion", Unmapped_Key, 0x54, 0x51);
+  addSIRC15Key("Gain", Unmapped_Key, 0x54, 0x52);
+  addSIRC15Key("Bias", Unmapped_Key, 0x54, 0x53);
+  addSIRC15Key("Zone", Unmapped_Key, 0x54, 0x56);
+  addSIRC15Key("tv/vcr", Input_Key, 0x54, 0x57);
+  addSIRC15Key("Blanking", Unmapped_Key, 0x54, 0x58);
+  addSIRC15Key("select", Select_Key, 0x54, 0x5A);
+  addSIRC15Key("Enter", Unmapped_Key, 0x54, 0x5E);
+  addSIRC15Key("Svideo 1", SVideoInput_Key, 0x54, 0x5F);
+  addSIRC15Key("Index Second / 0 (All)", Unmapped_Key, 0x54, 0x60);
+  addSIRC15Key("Index 1", Unmapped_Key, 0x54, 0x61);
+  addSIRC15Key("Index 2", Unmapped_Key, 0x54, 0x62);
+  addSIRC15Key("Index 3", Unmapped_Key, 0x54, 0x63);
+  addSIRC15Key("Index 4", Unmapped_Key, 0x54, 0x64);
+  addSIRC15Key("Index 5", Unmapped_Key, 0x54, 0x65);
+  addSIRC15Key("Index 6", Unmapped_Key, 0x54, 0x66);
+  addSIRC15Key("Index 7", Unmapped_Key, 0x54, 0x67);
+  addSIRC15Key("Index 8", Unmapped_Key, 0x54, 0x68);
+  addSIRC15Key("Index 9", Unmapped_Key, 0x54, 0x69);
+  addSIRC15Key("Svideo 2", SVideo2Input_Key, 0x54, 0x6F);
+  addSIRC15Key("Component Input", ComponentInput_Key, 0x54, 0x70);
+  addSIRC15Key("Focus+", Unmapped_Key, 0x54, 0x74);
+  addSIRC15Key("Focus-", Unmapped_Key, 0x54, 0x75);
+  addSIRC15Key("Zoom+", Unmapped_Key, 0x54, 0x77);
+  addSIRC15Key("Zoom-", Unmapped_Key, 0x54, 0x78);
+  addSIRC15Key("reset", Reset_Key, 0x54, 0x7B);
+  addSIRC15Key("Right and Left Arrows", Unmapped_Key, 0x54, 0x7C);
+  addSIRC15Key("Normal", Unmapped_Key, 0x54, 0x7D);
+  addSIRC15Key("Test", Unmapped_Key, 0x54, 0x7E);
+
+  addSIRC20Key("ms slide", Unmapped_Key, 0x2A, 0x1A, 0x3C);
+  addSIRC20Key("side shot +", Unmapped_Key, 0x2A, 0x1A, 0x3E); //"Keystone+"
+  addSIRC20Key("side shot -", Unmapped_Key, 0x2A, 0x1A, 0x3F); //"Keystone-"
+  addSIRC20Key("dynamic", One_Key, 0x2A, 0x1A, 0x51);
+  addSIRC20Key("standard", Two_Key, 0x2A, 0x1A, 0x52);
+  addSIRC20Key("cinema", Three_Key, 0x2A, 0x1A, 0x53);
+  addSIRC20Key("user 1", Four_Key, 0x2A, 0x1A, 0x54);
+  addSIRC20Key("user 2", Five_Key, 0x2A, 0x1A, 0x55);
+  addSIRC20Key("user 3", Six_Key, 0x2A, 0x1A, 0x56);
+  addSIRC20Key("apa", Unmapped_Key, 0x2A, 0x1A, 0x60);
+  addSIRC20Key("wide mode", AspectRatio_Key, 0x2A, 0x1A, 0x6E);
+  addSIRC20Key("lens", Unmapped_Key, 0x2A, 0x1A, 0x78);
+}
+
+
+SonyProjector1a::SonyProjector1a(
+  unsigned int index)
+  : SonyProjector1(index)
+{
+  setKeysetName("Projector Keyset 1a");
+
+  addControlledDevice(Sony_Make, "VPL-VH11HT", Other_Device);
+}
+
+
+void SonyProjector1a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  SonyProjector1::populateProtocol(guiObject);
+
+  addSIRC15Key("input toggle", Input_Key, 0x54, 0x2C);
+  addSIRC15Key("shift-left", Unmapped_Key, 0x54, 0x2F);
+}
index 3ceb575..c971392 100644 (file)
@@ -148,6 +148,28 @@ public:
 };
 
 
+class SonyDVD2: public PIRKeysetMetaData
+{
+public:
+  SonyDVD2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+
+class SonyDVD2a: public SonyDVD2
+{
+public:
+  SonyDVD2a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+
 class SonyVCR1: public PIRKeysetMetaData
 {
 public:
@@ -222,4 +244,24 @@ public:
     QObject *guiObject);
 };
 
+class SonyProjector1: public PIRKeysetMetaData
+{
+public:
+  SonyProjector1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class SonyProjector1a: public SonyProjector1
+{
+public:
+  SonyProjector1a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
 #endif // SONY_H
diff --git a/keysets/strong.cpp b/keysets/strong.cpp
new file mode 100644 (file)
index 0000000..0a36c88
--- /dev/null
@@ -0,0 +1,266 @@
+#include "strong.h"
+#include "protocols/necprotocol.h"
+
+StrongSat1::StrongSat1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Sat Receiver Keyset 1",
+      Strong_Make,
+      index)
+{
+  addControlledDevice(Strong_Make, "ZapBox", Sat_Device);
+}
+
+
+void StrongSat1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x7780, 16);
+
+  addKey("POWER", Power_Key, 0x16, 8);
+  addKey("MODE", Mode_Key, 0x11, 8);
+  addKey("MUTE", Mute_Key, 0x1C, 8);
+  addKey("TV/SAT", Input_Key, 0x1A, 8);
+  addKey("EPG", Guide_Key, 0x0E, 8);
+  addKey("TV/RADIO", TunerInput_Key, 0x1E, 8);
+  addKey("PAGE-", ChannelDown_Key, 0x0C, 8);
+  addKey("INFO", Info_Key, 0x1B, 8);
+  addKey("PAGE+", ChannelUp_Key, 0x14, 8);
+  addKey("EXIT", Exit_Key, 0x0F, 8);
+  addKey("MENU", Menu_Key, 0x07, 8);
+  addKey("vol up", VolumeUp_Key, 0x10, 8); // might be down instead
+  addKey("vol down", VolumeDown_Key, 0x19, 8); // might be up instead
+  addKey("UP", Up_Key, 0x12, 8);
+  addKey("DOWN", Down_Key, 0x13, 8);
+  addKey("LEFT", Left_Key, 0x15, 8);
+  addKey("RIGHT", Right_Key, 0x17, 8);
+  addKey("OK", Select_Key, 0x0B, 8);
+  addKey("enter", Enter_Key, 0x0B, 8);
+  addKey("1", One_Key, 0x00, 8);
+  addKey("2", Two_Key, 0x01, 8);
+  addKey("3", Three_Key, 0x02, 8);
+  addKey("4", Four_Key, 0x04, 8);
+  addKey("5", Five_Key, 0x05, 8);
+  addKey("6", Six_Key, 0x06, 8);
+  addKey("7", Seven_Key, 0x08, 8);
+  addKey("8", Eight_Key, 0x09, 8);
+  addKey("9", Nine_Key, 0x0A, 8);
+  addKey("0", Zero_Key, 0x0D, 8);
+  addKey("HELP", Unmapped_Key, 0x03, 8); // Might be info key
+  addKey("RED", Red_Key, 0x40, 8);
+  addKey("GREEN", Green_Key, 0x1D, 8);
+  addKey("YELLOW", Yellow_Key, 0x1F, 8);
+  addKey("BLUE", Blue_Key, 0x41, 8);
+}
+
+
+StrongSat2::StrongSat2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Sat Receiver Keyset 2",
+      Strong_Make,
+      index)
+{
+  addControlledDevice(Strong_Make, "SRT-4620", Sat_Device);
+}
+
+
+void StrongSat2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x01, 8);
+
+  addKey("power", Power_Key, 0x00, 8);
+  addKey("1", One_Key, 0x01, 8);
+  addKey("2", Two_Key, 0x02, 8);
+  addKey("mute", Mute_Key, 0x03, 8);
+  addKey("4", Four_Key, 0x04, 8);
+  addKey("5", Five_Key, 0x05, 8);
+  addKey("3", Three_Key, 0x06, 8);
+  addKey("6", Six_Key, 0x07, 8);
+  addKey("7", Seven_Key, 0x08, 8);
+  addKey("8", Eight_Key, 0x0A, 8);
+  addKey("9", Nine_Key, 0x0B, 8);
+  addKey("tv/Radio", TunerInput_Key, 0x0C, 8);
+  addKey("0", Zero_Key, 0x0E, 8);
+  addKey("TV/Sat", Input_Key, 0x0F, 8);
+  addKey("menu", Menu_Key, 0x10, 8);
+  addKey("exit", Exit_Key, 0x11, 8);
+  addKey("select", Select_Key, 0x12, 8);
+  addKey("channel", Unmapped_Key, 0x13, 8); // Not sure
+  addKey("vol down", VolumeDown_Key, 0x14, 8);
+  addKey("left arrow", Left_Key, 0x14, 8);
+  addKey("channel up", ChannelUp_Key, 0x15, 8);
+  addKey("up arrow", Up_Key, 0x15, 8);
+  addKey("channel down", ChannelDown_Key, 0x16, 8);
+  addKey("down arrow", Down_Key, 0x16, 8);
+  addKey("vol up", VolumeUp_Key, 0x17, 8);
+  addKey("right arrow", Right_Key, 0x17, 8);
+  addKey("program guide", Guide_Key, 0x18, 8);
+  addKey("display", Info_Key, 0x19, 8);
+  addKey("audio", Audio_Key, 0x1A, 8);
+  addKey("white", Unmapped_Key, 0x41, 8);
+  addKey("orange", Unmapped_Key, 0x42, 8);
+  addKey("red", Red_Key, 0x44, 8);
+  addKey("green", Green_Key, 0x45, 8);
+  addKey("yellow", Yellow_Key, 0x46, 8);
+  addKey("blue", Blue_Key, 0x47, 8);
+}
+
+
+StrongSat3::StrongSat3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Sat Receiver Keyset 3",
+      Strong_Make,
+      index)
+{
+  addControlledDevice(Strong_Make, "SRT-6410", Sat_Device);
+}
+
+
+void StrongSat3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, true, true);
+
+  setPreData(0x0202, 16);
+
+  addKey("0", Zero_Key, 0x00, 8);
+  addKey("1", One_Key, 0x01, 8);
+  addKey("2", Two_Key, 0x02, 8);
+  addKey("3", Three_Key, 0x03, 8);
+  addKey("4", Four_Key, 0x04, 8);
+  addKey("5", Five_Key, 0x05, 8);
+  addKey("6", Six_Key, 0x06, 8);
+  addKey("7", Seven_Key, 0x07, 8);
+  addKey("8", Eight_Key, 0x08, 8);
+  addKey("9", Nine_Key, 0x09, 8);
+  addKey("power", Power_Key, 0x0A, 8);
+  addKey("up arrow", Up_Key, 0x0B, 8);
+  addKey("ZOOM", Zoom_Key, 0x0C, 8);
+  addKey("select", Select_Key, 0x0D, 8);
+  addKey("down arrow", Down_Key, 0x0E, 8);
+  addKey("right arrow", Right_Key, 0x10, 8);
+  addKey("left arrow", Left_Key, 0x11, 8);
+  addKey("AV", Input_Key, 0x12, 8);
+  addKey("red", Red_Key, 0x14, 8);
+  addKey("channel up", Up_Key, 0x15, 8);
+  addKey("menu", Menu_Key, 0x16, 8);
+  addKey("green", Green_Key, 0x17, 8);
+  addKey("channel down", Down_Key, 0x18, 8);
+  addKey("mute", Mute_Key, 0x19, 8);
+  addKey("LIST", Unmapped_Key, 0x1A, 8);
+  addKey("program guide", Guide_Key, 0x1B, 8);
+  addKey("AUDIO", Audio_Key, 0x1C, 8);
+  addKey("yellow", Yellow_Key, 0x1D, 8);
+  addKey("exit", Exit_Key, 0x1F, 8);
+  addKey("MOSAIC", PIP_Key, 0x40, 8);
+  addKey("vol up", VolumeUp_Key, 0x41, 8);
+  addKey("vol down", VolumeDown_Key, 0x42, 8);
+  addKey("blue", Blue_Key, 0x43, 8);
+  addKey("INFO", Info_Key, 0x44, 8);
+  addKey("TV/R", TunerInput_Key, 0x45, 8);
+}
+
+
+StrongSat4::StrongSat4(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Sat Receiver Keyset 4",
+      Strong_Make,
+      index)
+{
+  addControlledDevice(Strong_Make, "SRT-5430", Sat_Device);
+}
+
+
+void StrongSat4::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x00, 8);
+
+  addKey("Mute", Mute_Key, 0x00, 8);
+  addKey("Language", Audio_Key, 0x01, 8);
+  addKey("exit", Exit_Key, 0x03, 8);
+  addKey("Play", Play_Key, 0x04, 8);
+  addKey("num_3", Three_Key, 0x05, 8);
+  addKey("Select", Select_Key, 0x06, 8);
+  addKey("Guide", Guide_Key, 0x07, 8);
+  addKey("Stop", Stop_Key, 0x08, 8);
+  addKey("num_2", Two_Key, 0x09, 8);
+  addKey("Pause", Pause_Key, 0x0A, 8);
+  addKey("Aspect", AspectRatio_Key, 0x0B, 8);
+  addKey("Power", Power_Key, 0x0C, 8);
+  addKey("num_1", One_Key, 0x0D, 8);
+  addKey("Menu", Menu_Key, 0x0F, 8);
+  addKey("ffwd", FastForward_Key, 0x10, 8);
+  addKey("Page+", PageUp_Key, 0x14, 8);
+  addKey("Page-", PageDown_Key, 0x18, 8);
+  addKey("Skip+", Next_Key, 0x1C, 8);
+  addKey("VOL+", VolumeUp_Key, 0x40, 8);
+  addKey("right_arrow", Right_Key, 0x40, 8);
+  addKey("Info", Info_Key, 0x41, 8);
+  addKey("Media", Unmapped_Key, 0x42, 8);
+  addKey("TV/Radio", TunerInput_Key, 0x43, 8);
+  addKey("CH+", ChannelUp_Key, 0x44, 8);
+  addKey("up_arrow", Up_Key, 0x44, 8);
+  addKey("Last_ch", PrevChannel_Key, 0x45, 8);
+  addKey("num_9", Nine_Key, 0x46, 8);
+  addKey("num_6", Six_Key, 0x47, 8);
+  addKey("CH-", ChannelDown_Key, 0x48, 8);
+  addKey("down_arrow", Down_Key, 0x48, 8);
+  addKey("num_0", Zero_Key, 0x49, 8);
+  addKey("num_8", Eight_Key, 0x4A, 8);
+  addKey("num_5", Five_Key, 0x4B, 8);
+  addKey("VOL-", VolumeDown_Key, 0x4C, 8);
+  addKey("left_arrow", Left_Key, 0x4C, 8);
+  addKey("Fav", Favorites_Key, 0x4D, 8);
+  addKey("num_7", Seven_Key, 0x4E, 8);
+  addKey("num_4", Four_Key, 0x4F, 8);
+  addKey("V.Mode", PictureMode_Key, 0x50, 8);
+  addKey("Goto", Unmapped_Key, 0x51, 8);
+  addKey("Red", Red_Key, 0x52, 8);
+  addKey("Zoom", Zoom_Key, 0x54, 8);
+  addKey("Repeat", Repeat_Key, 0x55, 8);
+  addKey("Green", Green_Key, 0x56, 8);
+  addKey("rewind", Rewind_Key, 0x57, 8);
+  addKey("Subtitle", Captions_Key, 0x58, 8);
+  addKey("TimeShift", Unmapped_Key, 0x59, 8);
+  addKey("Yellow", Yellow_Key, 0x5A, 8);
+  addKey("Skip-", Previous_Key, 0x5B, 8);
+  addKey("List", Unmapped_Key, 0x5C, 8);
+  addKey("Scan", Unmapped_Key, 0x5D, 8);
+  addKey("Blue", Blue_Key, 0x5E, 8);
+  addKey("Record", Record_Key, 0x5F, 8);
+}
diff --git a/keysets/strong.h b/keysets/strong.h
new file mode 100644 (file)
index 0000000..b3d172b
--- /dev/null
@@ -0,0 +1,48 @@
+#ifndef STRONG_H
+#define STRONG_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class StrongSat1: public PIRKeysetMetaData
+{
+public:
+  StrongSat1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class StrongSat2: public PIRKeysetMetaData
+{
+public:
+  StrongSat2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class StrongSat3: public PIRKeysetMetaData
+{
+public:
+  StrongSat3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class StrongSat4: public PIRKeysetMetaData
+{
+public:
+  StrongSat4(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // STRONG_H
diff --git a/keysets/technisat.cpp b/keysets/technisat.cpp
new file mode 100644 (file)
index 0000000..b84d2fc
--- /dev/null
@@ -0,0 +1,287 @@
+#include "technisat.h"
+#include "protocols/paceprotocol.h"
+#include "protocols/rc5protocol.h"
+
+
+TechnisatSTB1::TechnisatSTB1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Satellite Receiver 1",
+      Technisat_Make,
+      index)
+{
+  addControlledDevice(Technisat_Make, "ST 3004 S", Other_Device);
+}
+
+
+void TechnisatSTB1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PaceProtocol(guiObject, index);
+
+  setPreData(0x4, 3);
+
+  addKey("POWER", Power_Key, 0x01, 6);
+  addKey("TV/R", TunerInput_Key, 0x02, 6); // "radio"
+  addKey("dek", Unmapped_Key, 0x04, 6);
+  addKey("tab", Unmapped_Key, 0x05, 6);
+  addKey("MUTE", Mute_Key, 0x06, 6);
+  addKey("CH_UP", ChannelUp_Key, 0x07, 6);
+  addKey("CH_DOWN", ChannelDown_Key, 0x08, 6);
+  addKey("sat", SatInput_Key, 0x09, 6);
+  addKey("lnb", Unmapped_Key, 0x0E, 6);
+  addKey("0", Zero_Key, 0x0F, 6);
+
+  addKey("1", One_Key, 0x10, 6);
+  addKey("2", Two_Key, 0x11, 6);
+  addKey("3", Three_Key, 0x12, 6);
+  addKey("4", Four_Key, 0x13, 6);
+  addKey("5", Five_Key, 0x14, 6);
+  addKey("6", Six_Key, 0x15, 6);
+  addKey("7", Seven_Key, 0x16, 6);
+  addKey("8", Eight_Key, 0x17, 6);
+  addKey("9", Nine_Key, 0x18, 6);
+  addKey("deem", Unmapped_Key, 0x1E, 6);
+
+  addKey("delete", Unmapped_Key, 0x21, 6);
+  addKey("A/B", Audio_Key, 0x24, 6);
+  addKey("save", Unmapped_Key, 0x26, 6);
+  addKey("BACK", Exit_Key, 0x27, 6);
+  addKey("audio_plus", Unmapped_Key, 0x28, 6);
+  addKey("audio_minus", Unmapped_Key, 0x29, 6);
+  addKey("MENU", Menu_Key, 0x2B, 6);
+  addKey("video_plus", Unmapped_Key, 0x2C, 6);
+  addKey("video_minus", Unmapped_Key, 0x2D, 6);
+  addKey("VOL_UP", VolumeUp_Key, 0x2E, 6);
+  addKey("VOL_DOWN", VolumeDown_Key, 0x2F, 6);
+
+  addKey("ARROW_UP", Up_Key, 0x32, 6);
+  addKey("ARROW_DOWN", Down_Key, 0x33, 6);
+  addKey("ARROW_LEFT", Left_Key, 0x34, 6);
+  addKey("ARROW_RIGHT", Right_Key, 0x35, 6);
+  addKey("OK", Select_Key, 0x36, 6);
+  addKey("LIST", Unmapped_Key, 0x37, 6);
+}
+
+
+TechnisatSTB1a::TechnisatSTB1a(
+  unsigned int index)
+  : TechnisatSTB1(index)
+{
+  setKeysetName("Satellite Receiver 1a");
+
+  addControlledDevice(Technisat_Make, "ST 3002 S", Other_Device);
+}
+
+
+void TechnisatSTB1a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TechnisatSTB1::populateProtocol(guiObject);
+
+  setPreData(0x1, 3);
+}
+
+
+TechnisatSTB2::TechnisatSTB2(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Satellite Receiver 2",
+      Technisat_Make,
+      index)
+{
+  addControlledDevice(Technisat_Make, "TechniBox CAM1", Other_Device);
+}
+
+
+void TechnisatSTB2::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index);
+
+  addKey("TV/SAT", SatInput_Key, 0x0200, 13);
+  addKey("INFO", Info_Key, 0x020F, 13);
+  addKey("MENU", Menu_Key, 0x0212, 13);
+  addKey("TV/RADIO", TunerInput_Key, 0x0213, 13);
+  addKey("OK", Select_Key, 0x0217, 13);
+
+  addKey("RED", Red_Key, 0x022B, 13);
+  addKey("GREEN", Green_Key, 0x022C, 13);
+  addKey("YELLOW", Yellow_Key, 0x022D, 13);
+  addKey("BLUE", Blue_Key, 0x022E, 13);
+
+  addKey("0", Zero_Key, 0x1200, 13);
+  addKey("1", One_Key, 0x1201, 13);
+  addKey("2", Two_Key, 0x1202, 13);
+  addKey("3", Three_Key, 0x1203, 13);
+  addKey("4", Four_Key, 0x1204, 13);
+  addKey("5", Five_Key, 0x1205, 13);
+  addKey("6", Six_Key, 0x1206, 13);
+  addKey("7", Seven_Key, 0x1207, 13);
+  addKey("8", Eight_Key, 0x1208, 13);
+  addKey("9", Nine_Key, 0x1209, 13);
+  addKey("-/--", DoubleDigit_Key, 0x120A, 13); // "OPTION"
+  addKey("POWER", Power_Key, 0x120C, 13);
+  addKey("MUTE", Mute_Key, 0x120D, 13);
+
+  addKey("RIGHT", Right_Key, 0x1210, 13);
+  addKey("RIGHT", VolumeUp_Key, 0x1210, 13);
+  addKey("LEFT", Left_Key, 0x1211, 13);
+  addKey("LEFT", VolumeDown_Key, 0x1211, 13);
+  addKey("UP", Up_Key, 0x1220, 13);
+  addKey("UP", ChannelUp_Key, 0x1220, 13);
+  addKey("DOWN", Down_Key, 0x1221, 13);
+  addKey("DOWN", ChannelDown_Key, 0x1221, 13);
+  addKey("BACK", Exit_Key, 0x1222, 13);
+  addKey("A/B", Audio_Key, 0x1223, 13);
+  addKey("STOP", Unmapped_Key, 0x1229, 13);
+  addKey("EPG", Guide_Key, 0x122F, 13); // "SFI"
+  addKey("EXT", Input_Key, 0x1238, 13);
+  addKey("VT", Teletext_Key, 0x123C, 13); // "TXT"
+}
+
+
+TechnisatSTB2a::TechnisatSTB2a(
+  unsigned int index)
+  : TechnisatSTB2(index)
+{
+  setKeysetName("Satellite Receiver 2a");
+}
+
+
+void TechnisatSTB2a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TechnisatSTB2::populateProtocol(guiObject);
+
+  addKey("UP", Up_Key, 0x0210, 13);
+  addKey("LEFT", Left_Key, 0x0215, 13);
+  addKey("RIGHT", Right_Key, 0x0216, 13);
+  addKey("DOWN", Down_Key, 0x0211, 13);
+}
+
+
+TechnisatSTB3::TechnisatSTB3(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Satellite Receiver (and PCTV) 3",
+      Technisat_Make,
+      index)
+{
+  addControlledDevice(Technisat_Make, "SkyStar 2 TV", Other_Device);
+  addControlledDevice(Technisat_Make, "SkyStar 2.6D", Other_Device);
+}
+
+
+void TechnisatSTB3::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new RC5Protocol(guiObject, index);
+
+  addKey("INFO", Info_Key, 0x028F, 13);
+  addKey("MENU", Menu_Key, 0x0292, 13);
+  addKey("TV/RADIO", TunerInput_Key, 0x0293, 13);
+  addKey("OK", Select_Key, 0x0297, 13);
+  addKey("RED", Red_Key, 0x02AB, 13);
+  addKey("REWIND", Rewind_Key, 0x02AB, 13);
+  addKey("GREEN", Green_Key, 0x02AC, 13);
+  addKey("STOP", Stop_Key, 0x02AC, 13);
+  addKey("YELLOW", Yellow_Key, 0x02AD, 13);
+  addKey("PLAY", Play_Key, 0x02AD, 13);
+  addKey("PAUSE", Pause_Key, 0x02AD, 13);
+  addKey("BLUE", Blue_Key, 0x02AE, 13);
+  addKey("FASTFORWARD", FastForward_Key, 0x02AE, 13);
+  addKey("CHECK", Unmapped_Key, 0x02B6, 13);
+  addKey("KEY_QUESTION", Unmapped_Key, 0x02BD, 13);
+  addKey("ZOOM", Zoom_Key, 0x02BE, 13);
+
+  addKey("0", Zero_Key, 0x1280, 13);
+  addKey("1", One_Key, 0x1281, 13);
+  addKey("2", Two_Key, 0x1282, 13);
+  addKey("3", Three_Key, 0x1283, 13);
+  addKey("4", Four_Key, 0x1284, 13);
+  addKey("5", Five_Key, 0x1285, 13);
+  addKey("6", Six_Key, 0x1286, 13);
+  addKey("7", Seven_Key, 0x1287, 13);
+  addKey("8", Eight_Key, 0x1288, 13);
+  addKey("9", Nine_Key, 0x1289, 13);
+  addKey("-/--", DoubleDigit_Key, 0x128A, 13); // "OPTION"
+  addKey("POWER", Power_Key, 0x128C, 13);
+  addKey("MUTE", Mute_Key, 0x128D, 13);
+  addKey("HILFE", Unmapped_Key, 0x128F, 13);
+
+  addKey("RIGHT", Right_Key, 0x1290, 13);
+  addKey("V+", VolumeUp_Key, 0x1290, 13);
+  addKey("LEFT", Left_Key, 0x1291, 13);
+  addKey("V-", VolumeDown_Key, 0x1291, 13);
+  addKey("UP", Up_Key, 0x12A0, 13);
+  addKey("P+", ChannelUp_Key, 0x12A0, 13);
+  addKey("DOWN", Down_Key, 0x12A1, 13);
+  addKey("P-", ChannelDown_Key, 0x12A1, 13);
+  addKey("BACK", Exit_Key, 0x12A2, 13);
+  addKey("A/B", Audio_Key, 0x12A3, 13);
+  addKey("Time", Unmapped_Key, 0x12A6, 13);
+  addKey("STOP", Unmapped_Key, 0x12A9, 13); // "Still"
+  addKey("EPG", Guide_Key, 0x12AF, 13); //"SFI"
+  addKey("RECORD", Record_Key, 0x12B7, 13);
+  addKey("EXT", Input_Key, 0x12B8, 13);
+  addKey("TXT", Teletext_Key, 0x12BC, 13);
+}
+
+
+TechnisatSTB3a::TechnisatSTB3a(
+  unsigned int index)
+  : TechnisatSTB3(index)
+{
+  setKeysetName("Satellite Receiver (and PCTV) 3a");
+
+  addControlledDevice(Technisat_Make, "Technisat Digit HD4 CX", Other_Device);
+}
+
+
+void TechnisatSTB3a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TechnisatSTB3::populateProtocol(guiObject);
+
+  addKey("UP", Up_Key, 0x0290, 13);
+  addKey("DOWN", Down_Key, 0x0291, 13);
+  addKey("LEFT", Left_Key, 0x0295, 13);
+  addKey("RIGHT", Right_Key, 0x0296, 13);
+}
diff --git a/keysets/technisat.h b/keysets/technisat.h
new file mode 100644 (file)
index 0000000..343d10c
--- /dev/null
@@ -0,0 +1,68 @@
+#ifndef TECHNISAT_H
+#define TECHNISAT_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class TechnisatSTB1: public PIRKeysetMetaData
+{
+public:
+  TechnisatSTB1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnisatSTB1a: public TechnisatSTB1
+{
+public:
+  TechnisatSTB1a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnisatSTB2: public PIRKeysetMetaData
+{
+public:
+  TechnisatSTB2(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnisatSTB2a: public TechnisatSTB2
+{
+public:
+  TechnisatSTB2a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnisatSTB3: public PIRKeysetMetaData
+{
+public:
+  TechnisatSTB3(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TechnisatSTB3a: public TechnisatSTB3
+{
+public:
+  TechnisatSTB3a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // TECHNISAT_H
diff --git a/keysets/telefunken.cpp b/keysets/telefunken.cpp
new file mode 100644 (file)
index 0000000..ada8362
--- /dev/null
@@ -0,0 +1,101 @@
+#include "telefunken.h"
+#include "protocols/paceprotocol.h"
+
+
+TelefunkenTV1::TelefunkenTV1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "TV Keyset 1",
+      Telefunken_Make,
+      index)
+{
+}
+
+
+void TelefunkenTV1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new PaceProtocol(guiObject, index);
+
+  setPreData(0x7, 3);
+
+  addKey("KEY_1", One_Key, 0x00, 6);
+  addKey("KEY_4", Four_Key, 0x01, 6);
+  addKey("KEY_7", Seven_Key, 0x02, 6);
+  addKey("COLOR+", ColorUp_Key, 0x03, 6);
+  addKey("COLOR-", ColorDown_Key, 0x04, 6);
+  addKey("MUTE", Mute_Key, 0x05, 6);
+  addKey("CHANNEL", Info_Key, 0x06, 6);
+  addKey("KEY_2", Two_Key, 0x08, 6);
+  addKey("KEY_5", Five_Key, 0x09, 6);
+  addKey("KEY_8", Eight_Key, 0x0A, 6);
+  addKey("BRIGHTNESS+", BrightnessUp_Key, 0x0B, 6);
+  addKey("BRIGHTNESS-", BrightnessDown_Key, 0x0C, 6);
+  addKey("KEY_0", Zero_Key, 0x0E, 6);
+
+  addKey("KEY_3", Three_Key, 0x10, 6);
+  addKey("KEY_6", Six_Key, 0x11, 6);
+  addKey("KEY_9", Nine_Key, 0x12, 6);
+  addKey("BLUE/VT", Blue_Key, 0x15, 6);
+  addKey("VTX", Unmapped_Key, 0x15, 6); // what is this?
+  addKey("AV", Input_Key, 0x18, 6);
+  addKey("KEY_POWER", Power_Key, 0x1D, 6);
+  addKey("STD_VALUES", Unmapped_Key, 0x1E, 6); // "VIOLET/NORM", "TOP"
+  addKey("KEY_CHANNELUP", ChannelUp_Key, 0x1F, 6);
+
+  addKey("KEY_CHANNELDOWN", ChannelDown_Key, 0x20, 6);
+  addKey("BASS", BassUp_Key, 0x21, 6);
+  addKey("SIZE", Unmapped_Key, 0x22, 6); // txt
+  addKey("CONTRAST", ContrastUp_Key, 0x23, 6);
+  addKey("<-o->", Unmapped_Key, 0x24, 6); // txt
+  addKey("BALANCE", BalanceLeft_Key, 0x25, 6);
+  addKey("HIDDEN", Unmapped_Key, 0x28, 6); //txt
+  addKey("VOL_UP", VolumeUp_Key, 0x29, 6);
+  addKey("VOL_DOWN", VolumeDown_Key, 0x2A, 6);
+  addKey("MIX", Unmapped_Key, 0x2B, 6); //txt
+
+  addKey("INDEX", Unmapped_Key, 0x34, 6); //txt
+  addKey("STOP", Unmapped_Key, 0x35, 6); //txt
+  addKey("CLOCK", Unmapped_Key, 0x36, 6); //txt
+  addKey("YELLOW/PR", Yellow_Key, 0x38, 6);
+  addKey("PROGRAM", Program_Key, 0x38, 6);
+  addKey("RED/TONE", Red_Key, 0x39, 6);
+  addKey("AUDIO", SoundMode_Key, 0x39, 6);
+  addKey("GREEN/PICTURE", Green_Key, 0x3B, 6);
+  addKey("VIDEO", PictureMode_Key, 0x3B, 6);
+  addKey("FORMAT+", Unmapped_Key, 0x3C, 6);
+  addKey("FORMAT-", Unmapped_Key, 0x3D, 6);
+  addKey("VIDEOTEXT", Teletext_Key, 0x3E, 6);
+}
+
+
+TelefunkenTV1a::TelefunkenTV1a(
+  unsigned int index)
+  : TelefunkenTV1(index)
+{
+  setKeysetName("TV Keyset 1a");
+}
+
+
+void TelefunkenTV1a::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  TelefunkenTV1::populateProtocol(guiObject);
+
+  addKey("VOLUME+", VolumeUp_Key, 0x1B, 6);
+  addKey("VOLUME-", VolumeDown_Key, 0x1C, 6);
+  addKey("+", Right_Key, 0x29, 6);
+  addKey("-", Left_Key, 0x2A, 6);
+}
diff --git a/keysets/telefunken.h b/keysets/telefunken.h
new file mode 100644 (file)
index 0000000..5877483
--- /dev/null
@@ -0,0 +1,28 @@
+#ifndef TELEFUNKEN_H
+#define TELEFUNKEN_H
+
+#include "pirkeysetmetadata.h"
+
+class QObject;
+
+class TelefunkenTV1: public PIRKeysetMetaData
+{
+public:
+  TelefunkenTV1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class TelefunkenTV1a: public TelefunkenTV1
+{
+public:
+  TelefunkenTV1a(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+#endif // TELEFUNKEN_H
index ba2edcb..93f370c 100644 (file)
@@ -314,6 +314,33 @@ void ToshibaTV1h::populateProtocol(
 }
 
 
+ToshibaTV1i::ToshibaTV1i(
+  unsigned int index)
+  : ToshibaTV1h(index)
+{
+  setKeysetName("TV Keyset 1i");
+
+  addControlledDevice(Toshiba_Make, "MW-27H62", TV_Device);
+}
+
+
+void ToshibaTV1i::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  ToshibaTV1h::populateProtocol(guiObject);
+
+  addKey("Menu", Menu_Key, 0x0E, 8);
+  addKey("DvdMenu", DiscMenu_Key, 0x19, 8);
+  addKey("ChapterNext", Next_Key, 0x57, 8);
+}
+
+
 ToshibaVCR1::ToshibaVCR1(
   unsigned int index)
   : PIRKeysetMetaData(
@@ -359,10 +386,24 @@ void ToshibaVCR1::populateProtocol(
   addKey("rew", Rewind_Key, 0x19, 8);
   addKey("ch+", ChannelUp_Key, 0x1B, 8);
   addKey("ch-", ChannelDown_Key, 0x1F, 8);
+  addKey("InputDVD", DVDInput_Key, 0x20, 8);
+  addKey("DirectionRight", Right_Key, 0x4D, 8);
+  addKey("Select/Ok", Select_Key, 0x4E, 8);
+  addKey("DirectionLeft", Left_Key, 0x51, 8);
+  addKey("Audio", Audio_Key, 0x53, 8);
+  addKey("Program", Program_Key, 0x5C, 8);
+  addKey("SP/SLP", VHSSpeed_Key, 0x5D, 8);
   addKey("input", Input_Key, 0x5F, 8);
+  addKey("DirectionUp", Up_Key, 0x80, 8);
+  addKey("DirectionDown", Down_Key, 0x81, 8);
   addKey("recall", PrevChannel_Key, 0x83, 8);
+  addKey("Subtitle", Captions_Key, 0x87, 8);
+  addKey("Angle", Angle_Key, 0x96, 8);
+  addKey("Greater100", PlusOneHundred_Key, 0x9B, 8);
   addKey("skip", Next_Key, 0x9E, 8);
   addKey("previous", Previous_Key, 0x9F, 8);
+  addKey("TopMenu", DiscTitle_Key, 0xDF, 8);
+  addKey("Cancel", Clear_Key, 0xEF, 8);
   addKey("eject", Eject_Key, 0xF5, 8);
 }
 
index 1dc7572..6116d60 100644 (file)
@@ -95,6 +95,16 @@ public:
     QObject *guiObject);
 };
 
+class ToshibaTV1i: public ToshibaTV1h
+{
+public:
+  ToshibaTV1i(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
 class ToshibaVCR1: public PIRKeysetMetaData
 {
 public:
index 537e9dd..3d11f9f 100644 (file)
@@ -1,8 +1,8 @@
 #include "zenith.h"
 #include "protocols/necprotocol.h"
 
-// Based solely on LIRC Zenith_C32V37 config file
-ZenithC32V37::ZenithC32V37(
+// Based on LIRC Zenith_C32V37 config file
+ZenithTV1::ZenithTV1(
   unsigned int index)
   : PIRKeysetMetaData(
       "TV Keyset 1",
@@ -13,7 +13,7 @@ ZenithC32V37::ZenithC32V37(
 }
 
 
-void ZenithC32V37::populateProtocol(
+void ZenithTV1::populateProtocol(
   QObject *guiObject)
 {
   if (threadableProtocol)
@@ -69,3 +69,70 @@ void ZenithC32V37::populateProtocol(
   addKey("comp/dvi", Unmapped_Key, 0x98, 8);
   addKey("info", Info_Key, 0xAA, 8);
 }
+
+
+ZenithConverterBox1::ZenithConverterBox1(
+  unsigned int index)
+  : PIRKeysetMetaData(
+      "Digital Converter Box 1",
+      Zenith_Make,
+      index)
+{
+  addControlledDevice(Zenith_Make, "AKB36157102", Other_Device);
+}
+
+
+void ZenithConverterBox1::populateProtocol(
+  QObject *guiObject)
+{
+  if (threadableProtocol)
+  {
+    // Keyset already populated.
+    return;
+  }
+
+  threadableProtocol = new NECProtocol(guiObject, index, false, true);
+
+  setPreData(0x10, 8);
+
+  addKey("CHUP", ChannelUp_Key, 0x00, 8);
+  addKey("CHDOWN", ChannelDown_Key, 0x01, 8);
+  addKey("VOLUP", VolumeUp_Key, 0x02, 8);
+  addKey("VOLDOWN", VolumeDown_Key, 0x03, 8);
+  addKey("UP", Up_Key, 0x04, 8);
+  addKey("DOWN", Down_Key, 0x05, 8);
+  addKey("RIGHT", Right_Key, 0x06, 8);
+  addKey("LEFT", Left_Key, 0x07, 8);
+  addKey("POWER", Power_Key, 0x08, 8);
+  addKey("MUTE", Mute_Key, 0x09, 8);
+  addKey("SAP", Audio_Key, 0x0A, 8);
+  addKey("SLEEP", Sleep_Key, 0x0E, 8);
+  addKey("0", Zero_Key, 0x10, 8);
+  addKey("1", One_Key, 0x11, 8);
+  addKey("2", Two_Key, 0x12, 8);
+  addKey("3", Three_Key, 0x13, 8);
+  addKey("4", Four_Key, 0x14, 8);
+  addKey("5", Five_Key, 0x15, 8);
+  addKey("6", Six_Key, 0x16, 8);
+  addKey("7", Seven_Key, 0x17, 8);
+  addKey("8", Eight_Key, 0x18, 8);
+  addKey("9", Nine_Key, 0x19, 8);
+  addKey("RECALL", PrevChannel_Key, 0x1A, 8);
+  addKey("FAV", Favorites_Key, 0x1E, 8);
+  addKey("CCD", Captions_Key, 0x39, 8);
+  addKey("MENU", Menu_Key, 0x43, 8);
+  addKey("OK", Select_Key, 0x44, 8);
+  addKey("-", Dash_Key, 0x4C, 8);
+  addKey("EXIT", Exit_Key, 0x5B, 8);
+  addKey("ZOOM", Zoom_Key, 0x79, 8);
+  addKey("SIGNAL", Unmapped_Key, 0x96, 8);
+  addKey("GUIDE", Guide_Key, 0xA9, 8);
+  addKey("DISPLAY", Info_Key, 0xAA, 8);
+  addKey("CHUP2", Unmapped_Key, 0x20, 8);
+  addKey("CHDOWN2", Unmapped_Key, 0x21, 8);
+  addKey("OK2", Unmapped_Key, 0x78, 8);
+  addKey("MENU2", Unmapped_Key, 0x7E, 8);
+  addKey("POWER_OFF", PowerOff_Key, 0x5C, 8);
+  addKey("FACTORY_MENU", Unmapped_Key, 0xEA, 8);
+  addKey("FACTORY_RESET", Unmapped_Key, 0xEB, 8);
+}
index 491c0e5..3134621 100644 (file)
@@ -5,10 +5,20 @@
 
 class QObject;
 
-class ZenithC32V37: public PIRKeysetMetaData
+class ZenithTV1: public PIRKeysetMetaData
 {
 public:
-  ZenithC32V37(
+  ZenithTV1(
+    unsigned int index);
+
+  virtual void populateProtocol(
+    QObject *guiObject);
+};
+
+class ZenithConverterBox1: public PIRKeysetMetaData
+{
+public:
+  ZenithConverterBox1(
     unsigned int index);
 
   virtual void populateProtocol(
index d7e9921..78744b4 100644 (file)
@@ -4,17 +4,22 @@
 #include <QtCore/QCoreApplication>
 #include <QMutex>
 #include <QtGui/QMessageBox>
-//#include <QtGui>
+#include <QPushButton>
+#include <QDialog>
+#include <QDialogButtonBox>
+#include <QScrollArea>
 #include <QSettings>
 
 #include "pirkeysetmetadata.h"
+
 #include "pirkeysetwidgetitem.h"
 #include "pirselectkeysetform.h"
 #include "pirselectdeviceform.h"
-#include "pirpanelselectionform.h"
 #include "pirpreferencesform.h"
 #include "pirdocumentationform.h"
 #include "piraboutform.h"
+#include "dialogs/pirtabschoicedialog.h"
+
 #include "pirkeysetmanager.h"
 #include "pirpanelmanager.h"
 
@@ -41,10 +46,11 @@ MainWindow::MainWindow(QWidget *parent)
     ui(new Ui::MainWindow),
     selectKeysetForm(0),
     selectDeviceForm(0),
-    panelSelectionForm(0),
     preferencesForm(0),
     documentationForm(0),
     aboutForm(0),
+    myKeysets(0),
+    myPanels(0),
     currentKeyset(1) // Zero is not a valid keyset any more
 {
   ui->setupUi(this);
@@ -56,10 +62,13 @@ MainWindow::MainWindow(QWidget *parent)
   myKeysets = new PIRKeysetManager();
   myPanels = new PIRPanelManager(this);
 
-  // Construct the forms:
-  panelSelectionForm = new PIRPanelSelectionForm(this);
-  myPanels->setupPanels(panelSelectionForm);
+  // Display the panels:
+  myPanels->updateTabSet();
 
+  // Add the corner button:
+  insertCornerButton();
+
+  // Construct the rest of the forms:
   selectKeysetForm = new PIRSelectKeysetForm(this);
   myKeysets->populateSelectionWidget(selectKeysetForm);
 
@@ -166,7 +175,7 @@ MainWindow::~MainWindow()
   delete myKeysets;
   if (selectKeysetForm) delete selectKeysetForm;
   if (selectDeviceForm) delete selectDeviceForm;
-  if (panelSelectionForm) delete panelSelectionForm;
+//  if (panelSelectionForm) delete panelSelectionForm;
   if (documentationForm) delete documentationForm;
   if (aboutForm) delete aboutForm;
   delete ui;
@@ -299,11 +308,6 @@ void MainWindow::on_actionSelect_Device_By_Name_triggered()
   selectDeviceForm->show();
 }
 
-void MainWindow::on_actionArrange_Button_Panels_triggered()
-{
-  panelSelectionForm->show();
-}
-
 void MainWindow::on_actionPreferences_triggered()
 {
   preferencesForm->show();
@@ -350,7 +354,6 @@ void MainWindow::keysetSelectionChanged(
   currentKeyset = kwi->getID();
 
   QSettings settings("pietrzak.org", "Pierogi");
-//  settings.setValue("currentKeyset", currentKeyset);
 
   settings.setValue(
     "currentKeysetMake",
@@ -410,7 +413,6 @@ void MainWindow::addCurrentKeyset(
 
   settings.beginWriteArray("favorites");
   settings.setArrayIndex(favSettingsSize);
-//  settings.setValue("keysetID", currentKeyset);
 
   settings.setValue(
     "keysetMake",
@@ -453,7 +455,6 @@ void MainWindow::removeFavoriteKeyset(
     kwi = dynamic_cast<PIRKeysetWidgetItem *>(qlw->item(index));
 
     settings.setArrayIndex(index);
-//    settings.setValue("keysetID", kwi->getID());
     id = kwi->getID();
 
     settings.setValue(
@@ -544,83 +545,55 @@ void MainWindow::selectNextFavKeyset()
 }
 
 
-void MainWindow::selectPanel(
-  int index)
+void MainWindow::insertCornerButton()
 {
-  ui->selectPanelComboBox->setCurrentIndex(index);
-}
+  // Set up the dialog box:
+  PIRTabsChoiceDialog *tcd = new PIRTabsChoiceDialog(this);
 
+  // Next, set up the corner button itself:
+  QPushButton *button =
+    new QPushButton(QIcon(":/icons/align_just_icon&32.png"), "");
 
-void MainWindow::managePanel(
-  PIRPanelName name,
-  int state)
-{
-  myPanels->managePanel(name, state);
-}
+  button->setFlat(true);
 
+  connect(
+    button,
+    SIGNAL(clicked()),
+    tcd,
+    SLOT(exec()),
+    Qt::QueuedConnection);
 
-void MainWindow::insertPanel(
-  int index,
-  QWidget *panel,
-  const QString &displayName)
-{
-  ui->selectPanelComboBox->insertItem(index, displayName);
-  ui->stackedButtonsWidget->insertWidget(index, panel);
+  ui->mainTabWidget->setCornerWidget(button);
 }
 
 
-void MainWindow::removePanel(
-  int index,
-  QWidget *panel)
+void MainWindow::disableUpdates()
 {
-  ui->stackedButtonsWidget->removeWidget(panel);
-  ui->selectPanelComboBox->removeItem(index);
+  ui->mainTabWidget->setUpdatesEnabled(false);
 }
 
 
-void MainWindow::on_prevPanelButton_clicked()
+void MainWindow::enableUpdates()
 {
-  int count = ui->selectPanelComboBox->count();
-
-  // No need to do anything if there are less than two panels available:
-  if (count < 2) return;
-
-  int index = ui->selectPanelComboBox->currentIndex();
-  if (index == 0)
-  {
-    index = count - 1;
-  }
-  else
-  {
-    --index;
-  }
-
-  ui->selectPanelComboBox->setCurrentIndex(index);
+  ui->mainTabWidget->setUpdatesEnabled(true);
 }
 
 
-void MainWindow::on_nextPanelButton_clicked()
+void MainWindow::clearTabs()
 {
-  int count = ui->selectPanelComboBox->count();
+  ui->mainTabWidget->clear();
+}
 
-  // No need to do anything if there are less than two panels available:
-  if (count < 2) return;
 
-  int index = ui->selectPanelComboBox->currentIndex();
-  if (index == count - 1)
-  {
-    index = 0;
-  }
-  else
-  {
-    ++index;
-  }
-
-  ui->selectPanelComboBox->setCurrentIndex(index);
+void MainWindow::addTab(
+  QWidget *page,
+  QString label)
+{
+  ui->mainTabWidget->addTab(page, label);
 }
 
-
-void MainWindow::on_selectPanelComboBox_currentIndexChanged(int index)
+void MainWindow::setupTabs(
+  PIRTabBarName name)
 {
-  ui->stackedButtonsWidget->setCurrentIndex(index);
+  myPanels->setupTabs(name);
 }
index 2be48d2..7b321ff 100644 (file)
@@ -9,12 +9,14 @@
 
 class QListWidget;
 class QListWidgetItem;
+class QDialog;
+
 class PIRSelectKeysetForm;
 class PIRSelectDeviceForm;
-class PIRPanelSelectionForm;
 class PIRPreferencesForm;
 class PIRDocumentationForm;
 class PIRAboutForm;
+
 class PIRKeysetManager;
 class PIRPanelManager;
 
@@ -50,22 +52,6 @@ public:
 
   void stopRepeating();
 
-  void selectPanel(
-    int index);
-
-  void managePanel(
-    PIRPanelName name,
-    int state);
-
-  void insertPanel(
-    int index,
-    QWidget *panel,
-    const QString &displayName);
-
-  void removePanel(
-    int index,
-    QWidget *panel);
-
   // Favorites panel actions:
   void addCurrentKeyset(
     QListWidget *qlw);
@@ -87,6 +73,15 @@ public:
     return currentKeyset;
   }
 
+  void insertCornerButton();
+  void disableUpdates();
+  void enableUpdates();
+  void clearTabs();
+  void addTab(
+    QWidget *page,
+    QString label);
+  void setupTabs(PIRTabBarName name);
+
 signals:
   void buttonPressed(
     unsigned int keysetID,
@@ -107,27 +102,20 @@ public slots:
 private slots:
   void on_actionSelectKeyset_triggered();
   void on_actionSelect_Device_By_Name_triggered();
-  void on_actionArrange_Button_Panels_triggered();
   void on_actionPreferences_triggered();
   void on_actionAbout_triggered();
   void on_actionDocumentation_triggered();
 
-  void on_prevPanelButton_clicked();
-  void on_nextPanelButton_clicked();
-  void on_selectPanelComboBox_currentIndexChanged(int index);
-
   // Internal actions:
   void finalCleanup();
 
 private:
   void populateFavorites();
-//  void setupTabs();
 
   Ui::MainWindow *ui;
 
   PIRSelectKeysetForm *selectKeysetForm;
   PIRSelectDeviceForm *selectDeviceForm;
-  PIRPanelSelectionForm *panelSelectionForm;
   PIRPreferencesForm *preferencesForm;
   PIRDocumentationForm *documentationForm;
   PIRAboutForm *aboutForm;
index 52c12c6..19e19c5 100644 (file)
      <number>8</number>
     </property>
     <item row="0" column="0">
-     <widget class="QPushButton" name="prevPanelButton">
-      <property name="icon">
-       <iconset resource="PierogiResources.qrc">
-        <normaloff>:/icons/arrow_left_icon&amp;48.png</normaloff>:/icons/arrow_left_icon&amp;48.png</iconset>
-      </property>
-      <property name="iconSize">
-       <size>
-        <width>36</width>
-        <height>36</height>
-       </size>
-      </property>
-     </widget>
-    </item>
-    <item row="0" column="1">
-     <widget class="QComboBox" name="selectPanelComboBox">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-     </widget>
-    </item>
-    <item row="0" column="2">
-     <widget class="QPushButton" name="nextPanelButton">
-      <property name="text">
-       <string/>
-      </property>
-      <property name="icon">
-       <iconset resource="PierogiResources.qrc">
-        <normaloff>:/icons/arrow_right_icon&amp;48.png</normaloff>:/icons/arrow_right_icon&amp;48.png</iconset>
-      </property>
-      <property name="iconSize">
-       <size>
-        <width>36</width>
-        <height>36</height>
-       </size>
-      </property>
-     </widget>
-    </item>
-    <item row="1" column="0" colspan="3">
-     <widget class="QStackedWidget" name="stackedButtonsWidget">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-     </widget>
+     <widget class="QTabWidget" name="mainTabWidget"/>
     </item>
    </layout>
   </widget>
@@ -98,7 +50,6 @@
     </property>
     <addaction name="actionSelectKeyset"/>
     <addaction name="actionSelect_Device_By_Name"/>
-    <addaction name="actionArrange_Button_Panels"/>
     <addaction name="actionPreferences"/>
     <addaction name="actionDocumentation"/>
     <addaction name="actionAbout"/>
     <string>Select Keyset by Device</string>
    </property>
   </action>
-  <action name="actionArrange_Button_Panels">
-   <property name="text">
-    <string>Manage Panels</string>
-   </property>
-  </action>
   <action name="actionPreferences">
    <property name="text">
     <string>Preferences</string>
   </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
- <resources>
-  <include location="PierogiResources.qrc"/>
- </resources>
+ <resources/>
  <connections/>
  <slots>
   <signal>zeroEnabled(bool)</signal>
index b7b0bcd..5f13397 100644 (file)
@@ -146,7 +146,6 @@ SOURCES += main.cpp mainwindow.cpp \
     forms/pirmenuform.cpp \
     forms/pirmediaform.cpp \
     forms/pirfavoritesform.cpp \
-    pirpanelselectionform.cpp \
     pirpanelmanager.cpp \
     protocols/nokia32protocol.cpp \
     protocols/kathreinprotocol.cpp \
@@ -177,7 +176,20 @@ SOURCES += main.cpp mainwindow.cpp \
     forms/pirmacroform.cpp \
     dialogs/pirtextentrydialog.cpp \
     keysets/lexuz.cpp \
-    protocols/protonprotocol.cpp
+    protocols/protonprotocol.cpp \
+    keysets/gadmei.cpp \
+    keysets/onkyo.cpp \
+    protocols/panasonicoldprotocol.cpp \
+    keysets/orion.cpp \
+    keysets/cisco.cpp \
+    keysets/loewe.cpp \
+    keysets/telefunken.cpp \
+    protocols/paceprotocol.cpp \
+    dialogs/pirtabschoicedialog.cpp \
+    dialogs/pirtabswidgetitem.cpp \
+    keysets/technisat.cpp \
+    keysets/strong.cpp \
+    keysets/proview.cpp
 HEADERS += mainwindow.h \
     pirkeynames.h \
     pirmakenames.h \
@@ -300,7 +312,6 @@ HEADERS += mainwindow.h \
     forms/pirfavoritesform.h \
     pirpanelnames.h \
     pirpanelmanager.h \
-    pirpanelselectionform.h \
     protocols/nokia32protocol.h \
     protocols/kathreinprotocol.h \
     keysets/aoc.h \
@@ -330,7 +341,20 @@ HEADERS += mainwindow.h \
     forms/pirmacroform.h \
     dialogs/pirtextentrydialog.h \
     keysets/lexuz.h \
-    protocols/protonprotocol.h
+    protocols/protonprotocol.h \
+    keysets/gadmei.h \
+    keysets/onkyo.h \
+    protocols/panasonicoldprotocol.h \
+    keysets/orion.h \
+    keysets/cisco.h \
+    keysets/loewe.h \
+    keysets/telefunken.h \
+    protocols/paceprotocol.h \
+    dialogs/pirtabschoicedialog.h \
+    dialogs/pirtabswidgetitem.h \
+    keysets/technisat.h \
+    keysets/strong.h \
+    keysets/proview.h
 FORMS += mainwindow.ui \
     pirdocumentationform.ui \
     piraboutform.ui \
@@ -348,12 +372,12 @@ FORMS += mainwindow.ui \
     forms/pirmenuform.ui \
     forms/pirmediaform.ui \
     forms/pirfavoritesform.ui \
-    pirpanelselectionform.ui \
     forms/pirrecordform.ui \
     forms/piraltmainform.ui \
     pirpreferencesform.ui \
     forms/pirmacroform.ui \
-    dialogs/pirtextentrydialog.ui
+    dialogs/pirtextentrydialog.ui \
+    dialogs/pirtabschoicedialog.ui
 
 # Please do not modify the following two lines. Required for deployment.
 include(deployment.pri)
@@ -421,7 +445,8 @@ OTHER_FILES += \
     www/InputTab.png \
     qtc_packaging/debian_fremantle/postrm \
     icons/red_pause.png \
-    icons/delete_icon&48.png
+    icons/delete_icon&48.png \
+    icons/align_just_icon&32.png
 
 RESOURCES += \
     PierogiResources.qrc
index c2fbf4d..48b33d1 100644 (file)
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE QtCreatorProject>
-<!-- Written by Qt Creator 2.4.1, 2012-03-12T19:55:23. -->
+<!-- Written by Qt Creator 2.4.1, 2012-08-30T16:14:55. -->
 <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-1.1.3</value>
+      <value type="QString" key="ProjectExplorer.ProcessStep.WorkingDirectory">/Users/john/Develop/n900/pierogi-1.1.4</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">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_0_0_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_5_1_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_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_1_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_6_1_armel.deb</value>
        <value type="QString">/Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_5_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_6_7_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>
        <value type="QString">192.168.0.15</value>
        <value type="QString">192.168.0.15</value>
        <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-19T22:18:07</value>
        <value type="QDateTime">2012-02-29T10:48:05</value>
        <value type="QDateTime">2012-02-06T17:22:16</value>
        <value type="QDateTime">2012-03-08T23:20:27</value>
+       <value type="QDateTime">2012-08-30T16:08:14</value>
        <value type="QDateTime">2012-02-12T23:10:44</value>
        <value type="QDateTime">2012-02-09T18:12:21</value>
        <value type="QDateTime">2012-02-19T10:29:22</value>
        <value type="QDateTime">2012-02-03T10:04:34</value>
        <value type="QDateTime">2012-03-04T19:56:48</value>
        <value type="QDateTime">2012-01-01T15:35:35</value>
-       <value type="QDateTime">2012-03-12T18:26:07</value>
+       <value type="QDateTime">2012-03-12T20:02:57</value>
        <value type="QDateTime">2012-02-11T18:03:15</value>
        <value type="QDateTime">2012-02-08T20:29:28</value>
        <value type="QDateTime">2012-02-16T22:03:28</value>
index a58404d..27a9222 100644 (file)
@@ -163,6 +163,8 @@ enum PIRKeyName{
   PCInput_Key,
   CompositeInput_Key,
   Composite2Input_Key,
+  SVideoInput_Key,
+  SVideo2Input_Key,
   ComponentInput_Key,
   Component2Input_Key,
   HDMIInput_Key,
index 403318b..0be5987 100644 (file)
@@ -16,6 +16,7 @@
 #include "keysets/bush.h"
 #include "keysets/cambridge.h"
 #include "keysets/canon.h"
+#include "keysets/cisco.h"
 #include "keysets/compro.h"
 #include "keysets/daewoo.h"
 #include "keysets/dell.h"
@@ -32,6 +33,7 @@
 #include "keysets/epson.h"
 #include "keysets/fortec.h"
 #include "keysets/foxtel.h"
+#include "keysets/gadmei.h"
 #include "keysets/genius.h"
 #include "keysets/goldstar.h"
 #include "keysets/grundig.h"
@@ -50,6 +52,7 @@
 #include "keysets/kenwood.h"
 #include "keysets/lexuz.h"
 #include "keysets/lg.h"
+#include "keysets/loewe.h"
 #include "keysets/logitech.h"
 #include "keysets/magnavox.h"
 #include "keysets/magnum.h"
 #include "keysets/nokia.h"
 #include "keysets/octagon.h"
 #include "keysets/onida.h"
+#include "keysets/onkyo.h"
+#include "keysets/orion.h"
 #include "keysets/panasonic.h"
 #include "keysets/philco.h"
 #include "keysets/philips.h"
 #include "keysets/pinnacle.h"
 #include "keysets/pioneer.h"
+#include "keysets/proview.h"
 #include "keysets/qnap.h"
 #include "keysets/raite.h"
 #include "keysets/rca.h"
 #include "keysets/sky.h"
 #include "keysets/sony.h"
 #include "keysets/starsat.h"
+#include "keysets/strong.h"
 #include "keysets/technics.h"
+#include "keysets/technisat.h"
+#include "keysets/telefunken.h"
 #include "keysets/telenet.h"
 #include "keysets/thomson.h"
 #include "keysets/tivo.h"
@@ -165,6 +174,10 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new CanonCamcorder1(++counter));
   setupKeyset(new CanonPowershot1(++counter));
 
+  setupKeyset(new CiscoSTB1(++counter));
+  setupKeyset(new CiscoSTB2(++counter));
+  setupKeyset(new CiscoSTB3(++counter));
+
   setupKeyset(new ComproTVCard1(++counter));
 
   setupKeyset(new DaewooTV1(++counter));
@@ -256,6 +269,8 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new FoxtelSTB1(++counter));
   setupKeyset(new FoxtelSTB2(++counter));
 
+  setupKeyset(new GadmeiTuner1(++counter));
+
   setupKeyset(new GeniusSpeakers1(++counter));
 
   setupKeyset(new GoldStarTV1(++counter));
@@ -373,6 +388,10 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new LGVCR1b(++counter));
   setupKeyset(new LGAC1(++counter));
 
+  setupKeyset(new LoeweTV1(++counter));
+  setupKeyset(new LoeweVCR1(++counter));
+  setupKeyset(new LoeweDVD1(++counter));
+
   setupKeyset(new LogitechSpeakers(++counter));
   setupKeyset(new LogitechSqueezebox(++counter));
 
@@ -419,6 +438,22 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new OnidaTV1(++counter));
   setupKeyset(new OnidaDVD1(++counter));
 
+  setupKeyset(new OnkyoAudio1(++counter));
+  setupKeyset(new OnkyoAudio2(++counter));
+  setupKeyset(new OnkyoAudio2a(++counter));
+  setupKeyset(new OnkyoAudio3(++counter));
+  setupKeyset(new OnkyoAudio4(++counter));
+  setupKeyset(new OnkyoAudio5(++counter));
+  setupKeyset(new OnkyoDVD1(++counter));
+  setupKeyset(new OnkyoDVD2(++counter));
+
+  setupKeyset(new OrionTV1(++counter));
+  setupKeyset(new OrionTV2(++counter));
+  setupKeyset(new OrionTV3(++counter));
+  setupKeyset(new OrionVCR1(++counter));
+  setupKeyset(new OrionVCR2(++counter));
+  setupKeyset(new OrionDVD1(++counter));
+
   setupKeyset(new PanasonicCarAudio(++counter));
   setupKeyset(new PanasonicSat1(++counter));
   setupKeyset(new PanasonicSat1a(++counter));
@@ -490,6 +525,8 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new PioneerLaserDisc1(++counter));
   setupKeyset(new PioneerDVD1(++counter));
 
+  setupKeyset(new ProviewDVD1(++counter));
+
   setupKeyset(new QNAPPlayer1(++counter));
 
   setupKeyset(new RaiteDVD1(++counter));
@@ -573,6 +610,8 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new SonyDVD1a(++counter));
   setupKeyset(new SonyDVD1b(++counter));
   setupKeyset(new SonyDVD1c(++counter));
+  setupKeyset(new SonyDVD2(++counter));
+  setupKeyset(new SonyDVD2a(++counter));
   setupKeyset(new SonyVCR1(++counter));
   setupKeyset(new SonyVCR1a(++counter));
   setupKeyset(new SonyVCR1b(++counter));
@@ -580,9 +619,16 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new SonyCD1(++counter));
   setupKeyset(new SonyCD1a(++counter));
   setupKeyset(new SonyCD1b(++counter));
+  setupKeyset(new SonyProjector1(++counter));
+  setupKeyset(new SonyProjector1a(++counter));
 
   setupKeyset(new StarsatSat1(++counter));
 
+  setupKeyset(new StrongSat1(++counter));
+  setupKeyset(new StrongSat2(++counter));
+  setupKeyset(new StrongSat3(++counter));
+  setupKeyset(new StrongSat4(++counter));
+
   setupKeyset(new TechnicsAudio1(++counter));
   setupKeyset(new TechnicsAudio1a(++counter));
   setupKeyset(new TechnicsAudio2(++counter));
@@ -590,6 +636,16 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new TechnicsAudio3a(++counter));
   setupKeyset(new TechnicsDVD1(++counter));
 
+  setupKeyset(new TechnisatSTB1(++counter));
+  setupKeyset(new TechnisatSTB1a(++counter));
+  setupKeyset(new TechnisatSTB2(++counter));
+  setupKeyset(new TechnisatSTB2a(++counter));
+  setupKeyset(new TechnisatSTB3(++counter));
+  setupKeyset(new TechnisatSTB3a(++counter));
+
+  setupKeyset(new TelefunkenTV1(++counter));
+  setupKeyset(new TelefunkenTV1a(++counter));
+
   setupKeyset(new TelenetSTB1(++counter));
 
   setupKeyset(new ThomsonConverter1(++counter));
@@ -618,6 +674,7 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new ToshibaTV1f(++counter));
   setupKeyset(new ToshibaTV1g(++counter));
   setupKeyset(new ToshibaTV1h(++counter));
+  setupKeyset(new ToshibaTV1i(++counter));
   setupKeyset(new ToshibaVCR1(++counter));
   setupKeyset(new ToshibaVCR1a(++counter));
   setupKeyset(new ToshibaDisc1(++counter));
@@ -670,7 +727,8 @@ PIRKeysetManager::PIRKeysetManager()
   setupKeyset(new YamahaTV1(++counter));
   setupKeyset(new YamahaKaraoke1(++counter));
 
-  setupKeyset(new ZenithC32V37(++counter));
+  setupKeyset(new ZenithTV1(++counter));
+  setupKeyset(new ZenithConverterBox1(++counter));
 
   // Start the thread running:
   commandThread.start();
index 6db70bf..05d6011 100644 (file)
@@ -181,6 +181,20 @@ void PIRKeysetMetaData::addNECKey(
 }
 
 
+void PIRKeysetMetaData::addPanOldKey(
+  const char *name,
+  PIRKeyName key,
+  unsigned int addressData,
+  unsigned int commandData)
+{
+  if (key != Unmapped_Key)
+  {
+    keys[key] = name;
+    threadableProtocol->addPanOldKey(key, addressData, commandData);
+  }
+}
+
+
 void PIRKeysetMetaData::addPioneerKey(
   const char *name,
   PIRKeyName key,
index 2426bed..e8a2b28 100644 (file)
@@ -93,6 +93,12 @@ protected:
     unsigned int addressData,
     unsigned int commandData);
 
+  void addPanOldKey(
+    const char *name,
+    PIRKeyName key,
+    unsigned int addressData,
+    unsigned int commandData);
+
   void addPioneerKey(
     const char *name,
     PIRKeyName key,
index 93fecd0..ad947de 100644 (file)
@@ -17,6 +17,7 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Bush_Make] = "Bush";
   makes[Cambridge_Make] = "Cambridge Audio";
   makes[Canon_Make] = "Canon";
+  makes[Cisco_Make] = "Cisco";
   makes[Compro_Make] = "Compro";
   makes[Daewoo_Make] = "Daewoo";
   makes[Dell_Make] = "Dell";
@@ -33,6 +34,7 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Epson_Make] = "Epson";
   makes[Fortec_Make] = "Fortec Star";
   makes[Foxtel_Make] = "Foxtel";
+  makes[Gadmei_Make] = "Gadmei";
   makes[Genius_Make] = "Genius";
   makes[GoldStar_Make] = "GoldStar";
   makes[Grundig_Make] = "Grundig";
@@ -51,6 +53,7 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Kenwood_Make] = "Kenwood";
   makes[Lexuz_Make] = "Lexuz";
   makes[LG_Make] = "LG";
+  makes[Loewe_Make] = "Loewe";
   makes[Logitech_Make] = "Logitech";
   makes[Magnavox_Make] = "Magnavox";
   makes[Magnum_Make] = "Magnum";
@@ -61,11 +64,14 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Nokia_Make] = "Nokia";
   makes[Octagon_Make] = "Octagon";
   makes[Onida_Make] = "Onida";
+  makes[Onkyo_Make] = "Onkyo";
+  makes[Orion_Make] = "Orion";
   makes[Panasonic_Make] = "Panasonic";
   makes[Philco_Make] = "Philco";
   makes[Philips_Make] = "Philips";
   makes[Pinnacle_Make] = "Pinnacle Systems";
   makes[Pioneer_Make] = "Pioneer";
+  makes[Proview_Make] = "Proview";
   makes[QNAP_Make] = "QNAP";
   makes[Raite_Make] = "Raite";
   makes[RCA_Make] = "RCA";
@@ -78,7 +84,10 @@ PIRMakeMgr::PIRMakeMgr()
   makes[Sky_Make] = "Sky";
   makes[Sony_Make] = "Sony";
   makes[Starsat_Make] = "Starsat";
+  makes[Strong_Make] = "Strong";
   makes[Technics_Make] = "Technics";
+  makes[Technisat_Make] = "Technisat";
+  makes[Telefunken_Make] = "Telefunken";
   makes[Telenet_Make] = "Telenet";
   makes[Thomson_Make] = "Thomson";
   makes[Tivo_Make] = "TiVo";
index 0a4011b..25074f8 100644 (file)
@@ -18,6 +18,7 @@ enum PIRMakeName{
   Bush_Make,
   Cambridge_Make,
   Canon_Make,
+  Cisco_Make,
   Compro_Make,
   Daewoo_Make,
   Dell_Make,
@@ -34,6 +35,7 @@ enum PIRMakeName{
   Epson_Make,
   Fortec_Make,
   Foxtel_Make,
+  Gadmei_Make,
   Genius_Make,
   GoldStar_Make,
   Grundig_Make,
@@ -52,6 +54,7 @@ enum PIRMakeName{
   Kenwood_Make,
   Lexuz_Make,
   LG_Make,
+  Loewe_Make,
   Logitech_Make,
   Magnavox_Make,
   Magnum_Make,
@@ -62,11 +65,14 @@ enum PIRMakeName{
   Nokia_Make,
   Octagon_Make,
   Onida_Make,
+  Onkyo_Make,
+  Orion_Make,
   Panasonic_Make,
   Philco_Make,
   Philips_Make,
   Pinnacle_Make,
   Pioneer_Make,
+  Proview_Make,
   QNAP_Make,
   Raite_Make,
   RCA_Make,
@@ -79,7 +85,10 @@ enum PIRMakeName{
   Sky_Make,
   Sony_Make,
   Starsat_Make,
+  Strong_Make,
   Technics_Make,
+  Technisat_Make,
+  Telefunken_Make,
   Telenet_Make,
   Thomson_Make,
   Tivo_Make,
index ff947d0..11e6094 100644 (file)
@@ -1,7 +1,5 @@
 #include "pirpanelmanager.h"
 
-#include "pirpanelselectionform.h"
-
 #include "forms/pirmainform.h"
 #include "forms/piraltmainform.h"
 #include "forms/pirutilityform.h"
 #include "mainwindow.h"
 
 #include <QSettings>
+#include <QDialogButtonBox>
+#include <QPushButton>
 
 // Debugging:
 //#include <QMaemo5InformationBox>
-#include <iostream>
+//#include <iostream>
 
-PIRPanelManager::PIRPanelManager(MainWindow *mw)
-  : mainForm(0),
+PIRPanelManager::PIRPanelManager(
+  MainWindow *mw):
+    mainForm(0),
     altMainForm(0),
     utilityForm(0),
     keypadForm(0),
@@ -39,8 +40,15 @@ PIRPanelManager::PIRPanelManager(MainWindow *mw)
     acForm(0),
     favoritesForm(0),
     altMainPanelFlag(false),
+    currentTabsName(Universal_Tabs),
     mainWindow(mw)
 {
+  QSettings settings("pietrzak.org", "Pierogi");
+  if (settings.contains("currentTabsName"))
+  {
+    currentTabsName = PIRTabBarName(settings.value("currentTabsName").toInt());
+  }
+
   // Set up the panel names:
   shortPanelNames[Main_Panel] = "Main";
   longPanelNames[Main_Panel] =
@@ -79,18 +87,89 @@ PIRPanelManager::PIRPanelManager(MainWindow *mw)
   longPanelNames[Favorites_Panel] =
     "Favorites Panel - memorized keysets";
 
-  activePanels[Main_Panel] = false;
-  activePanels[Utility_Panel]= false;
-  activePanels[Keypad_Panel]= false;
-  activePanels[Menu_Panel]= false;
-  activePanels[Media_Panel]= false;
-  activePanels[Media2_Panel]= false;
-  activePanels[Record_Panel]= false;
-  activePanels[TV_Panel]= false;
-  activePanels[Input_Panel]= false;
-  activePanels[Adjust_Panel]= false;
-  activePanels[AC_Panel]= false;
-  activePanels[Favorites_Panel]= false;
+  mainForm = new PIRMainForm(mainWindow);
+  panels[Main_Panel] = mainForm;
+
+  altMainForm = new PIRAltMainForm(mainWindow);
+  panels[Alt_Main_Panel] = altMainForm;
+
+  utilityForm = new PIRUtilityForm(mainWindow);
+  panels[Utility_Panel] = utilityForm;
+
+  keypadForm = new PIRKeypadForm(mainWindow);
+  panels[Keypad_Panel] = keypadForm;
+
+  menuForm = new PIRMenuForm(mainWindow);
+  panels[Menu_Panel] = menuForm;
+
+  mediaForm = new PIRMediaForm(mainWindow);
+  panels[Media_Panel] = mediaForm;
+
+  media2Form = new PIRMedia2Form(mainWindow);
+  panels[Media2_Panel] = media2Form;
+
+  recordForm = new PIRRecordForm(mainWindow);
+  panels[Record_Panel] = recordForm;
+
+  tvForm = new PIRTVForm(mainWindow);
+  panels[TV_Panel] = tvForm;
+
+  inputForm = new PIRInputForm(mainWindow);
+  panels[Input_Panel] = inputForm;
+
+  adjustForm = new PIRAdjustForm(mainWindow);
+  panels[Adjust_Panel] = adjustForm;
+
+  acForm = new PIRAirConditionerForm(mainWindow);
+  panels[AC_Panel] = acForm;
+
+  favoritesForm = new PIRFavoritesForm(mainWindow);
+  panels[Favorites_Panel] = favoritesForm;
+
+  // Set up the panel collections:
+  PIRPanelNameList pset;
+
+  // The universal collection:
+  pset.push_back(Main_Panel);
+  pset.push_back(Utility_Panel);
+  pset.push_back(Keypad_Panel);
+  pset.push_back(Menu_Panel);
+  pset.push_back(Media_Panel);
+  pset.push_back(Favorites_Panel);
+  tabLists[Universal_Tabs] = pset;
+
+  // The TV collection:
+  pset.clear();
+  pset.push_back(Main_Panel);
+  pset.push_back(Keypad_Panel);
+  pset.push_back(Menu_Panel);
+  pset.push_back(TV_Panel);
+  pset.push_back(Adjust_Panel);
+  pset.push_back(Favorites_Panel);
+  tabLists[TV_Tabs] = pset;
+
+  // The video media collection:
+  pset.clear();
+  pset.push_back(Main_Panel);
+  pset.push_back(Menu_Panel);
+  pset.push_back(Media_Panel);
+  pset.push_back(Media2_Panel);
+  pset.push_back(Input_Panel);
+  pset.push_back(Favorites_Panel);
+  tabLists[VideoMedia_Tabs] = pset;
+
+  // The air conditioner collection:
+  pset.clear();
+  pset.push_back(AC_Panel);
+  pset.push_back(Favorites_Panel);
+  tabLists[AC_Tabs] = pset;
+
+  // The recording collection:
+  pset.clear();
+  pset.push_back(Record_Panel);
+  pset.push_back(Keypad_Panel);
+  pset.push_back(Favorites_Panel);
+  tabLists[Record_Tabs] = pset;
 }
 
 
@@ -104,109 +183,31 @@ PIRPanelManager::~PIRPanelManager()
 }
 
 
-void PIRPanelManager::setupPanels(
-  PIRPanelSelectionForm *psf)
+void PIRPanelManager::updateTabSet()
 {
   QSettings settings("pietrzak.org", "Pierogi");
+  settings.setValue("currentTabsName", currentTabsName);
 
-  settings.beginGroup("Panels");
-
-  // Do the panel settings exist? (We'll check for "Main_Panel".)
-  if (!settings.contains(shortPanelNames[Main_Panel]))
-  {
-    // A default set of panels:
-    psf->setCheckBox(Main_Panel, true);
-    psf->setCheckBox(Utility_Panel, true);
-    psf->setCheckBox(Keypad_Panel, true);
-    psf->setCheckBox(Menu_Panel, true);
-    psf->setCheckBox(Media_Panel, true);
-    psf->setCheckBox(Favorites_Panel, true);
-  }
-  else
-  {
-    psf->setCheckBox(
-      Main_Panel,
-      settings.value(shortPanelNames[Main_Panel]).toBool());
-
-    if (settings.contains(shortPanelNames[Utility_Panel]))
-    {
-      psf->setCheckBox(
-        Utility_Panel,
-        settings.value(shortPanelNames[Utility_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[Keypad_Panel]))
-    {
-      psf->setCheckBox(
-        Keypad_Panel,
-        settings.value(shortPanelNames[Keypad_Panel]).toBool());
-    }
+  mainWindow->disableUpdates();
+  mainWindow->clearTabs();
 
-    if (settings.contains(shortPanelNames[Menu_Panel]))
-    {
-      psf->setCheckBox(
-        Menu_Panel,
-        settings.value(shortPanelNames[Menu_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[Media_Panel]))
-    {
-      psf->setCheckBox(
-        Media_Panel,
-        settings.value(shortPanelNames[Media_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[Media2_Panel]))
-    {
-      psf->setCheckBox(
-        Media2_Panel,
-        settings.value(shortPanelNames[Media2_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[Record_Panel]))
-    {
-      psf->setCheckBox(
-        Record_Panel,
-        settings.value(shortPanelNames[Record_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[TV_Panel]))
-    {
-      psf->setCheckBox(
-        TV_Panel,
-        settings.value(shortPanelNames[TV_Panel]).toBool());
-    }
-
-    if (settings.contains(shortPanelNames[Input_Panel]))
-    {
-      psf->setCheckBox(
-        Input_Panel,
-        settings.value(shortPanelNames[Input_Panel]).toBool());
-    }
+  PIRPanelNameList::const_iterator i = tabLists[currentTabsName].begin();
 
-    if (settings.contains(shortPanelNames[Adjust_Panel]))
+  while (i != tabLists[currentTabsName].end())
+  {
+    if ((*i == Main_Panel) && altMainPanelFlag)
     {
-      psf->setCheckBox(
-        Adjust_Panel,
-        settings.value(shortPanelNames[Adjust_Panel]).toBool());
+      mainWindow->addTab(altMainForm, shortPanelNames[Main_Panel]);
     }
-
-    if (settings.contains(shortPanelNames[AC_Panel]))
+    else
     {
-      psf->setCheckBox(
-        AC_Panel,
-        settings.value(shortPanelNames[AC_Panel]).toBool());
+      mainWindow->addTab(panels[*i], shortPanelNames[*i]);
     }
 
-    if (settings.contains(shortPanelNames[Favorites_Panel]))
-    {
-      psf->setCheckBox(
-        Favorites_Panel,
-        settings.value(shortPanelNames[Favorites_Panel]).toBool());
-    }
+    ++i;
   }
 
-  settings.endGroup();
+  mainWindow->enableUpdates();
 }
 
 
@@ -214,15 +215,8 @@ void PIRPanelManager::enableButtons(
   const PIRKeysetManager *keyset,
   unsigned int id)
 {
-  if (altMainPanelFlag)
-  {
-    if (altMainForm) altMainForm->enableButtons(keyset, id);
-  }
-  else
-  {
-    if (mainForm) mainForm->enableButtons(keyset, id);
-  }
-
+  mainForm->enableButtons(keyset, id);
+  altMainForm->enableButtons(keyset, id);
   commonEnableButtons(keyset, id);
 }
 
@@ -232,15 +226,8 @@ void PIRPanelManager::enableButtons(
   unsigned int currentID,
   unsigned int defaultID)
 {
-  if (altMainPanelFlag)
-  {
-    if (altMainForm) altMainForm->enableButtons(keyset, currentID, defaultID);
-  }
-  else
-  {
-    if (mainForm) mainForm->enableButtons(keyset, currentID, defaultID);
-  }
-
+  mainForm->enableButtons(keyset, currentID, defaultID);
+  altMainForm->enableButtons(keyset, currentID, defaultID);
   commonEnableButtons(keyset, currentID);
 }
 
@@ -249,65 +236,16 @@ void PIRPanelManager::commonEnableButtons(
   const PIRKeysetManager *keyset,
   unsigned int id)
 {
-  if (utilityForm) utilityForm->enableButtons(keyset, id);
-  if (keypadForm) keypadForm->enableButtons(keyset, id);
-  if (menuForm) menuForm->enableButtons(keyset, id);
-  if (mediaForm) mediaForm->enableButtons(keyset, id);
-  if (media2Form) media2Form->enableButtons(keyset, id);
-  if (recordForm) recordForm->enableButtons(keyset, id);
-  if (tvForm) tvForm->enableButtons(keyset, id);
-  if (inputForm) inputForm->enableButtons(keyset, id);
-  if (adjustForm) adjustForm->enableButtons(keyset, id);
-  if (acForm) acForm->enableButtons(keyset, id);
-}
-
-
-void PIRPanelManager::managePanel(
-  PIRPanelName name,
-  int state)
-{
-  int currentPanel = 0;
-  int displayCount = 0;
-
-//  PIRPanelList::iterator i = panelList.begin();
-  while (currentPanel < Last_Panel_Marker)
-  {
-    if (currentPanel == name)
-    {
-      break;
-    }
-    else if (activePanels[PIRPanelName(currentPanel)])
-    {
-      ++displayCount;
-    }
-
-    ++currentPanel;
-  }
-
-  if (currentPanel == Last_Panel_Marker)
-  {
-    // should throw an error message here!!!
-    return;
-  }
-
-  QSettings settings("pietrzak.org", "Pierogi");
-
-  settings.beginGroup("Panels");
-
-  if (state == Qt::Unchecked && activePanels[PIRPanelName(currentPanel)])
-  {
-    hidePanel(name, displayCount);
-    activePanels[PIRPanelName(currentPanel)] = false;
-    settings.setValue(shortPanelNames[PIRPanelName(currentPanel)], false);
-  }
-  else if (state == Qt::Checked && !activePanels[PIRPanelName(currentPanel)])
-  {
-    showPanel(name, displayCount);
-    activePanels[PIRPanelName(currentPanel)] = true;
-    settings.setValue(shortPanelNames[PIRPanelName(currentPanel)], true);
-  }
-
-  settings.endGroup();
+  utilityForm->enableButtons(keyset, id);
+  keypadForm->enableButtons(keyset, id);
+  menuForm->enableButtons(keyset, id);
+  mediaForm->enableButtons(keyset, id);
+  media2Form->enableButtons(keyset, id);
+  recordForm->enableButtons(keyset, id);
+  tvForm->enableButtons(keyset, id);
+  inputForm->enableButtons(keyset, id);
+  adjustForm->enableButtons(keyset, id);
+  acForm->enableButtons(keyset, id);
 }
 
 
@@ -321,20 +259,7 @@ void PIRPanelManager::useMainPanel()
 
   altMainPanelFlag = false;
 
-  // Is the main panel currently active?
-  if (activePanels[Main_Panel])
-  {
-    mainWindow->removePanel(0, altMainForm);
-    if (!mainForm)
-    {
-      mainForm = new PIRMainForm(mainWindow);
-    }
-
-    mainWindow->insertPanel(0, mainForm, longPanelNames[Main_Panel]);
-    mainWindow->selectPanel(0);
-  }
-
-  mainWindow->enableButtons();
+  updateTabSet();
 }
 
 
@@ -348,324 +273,85 @@ void PIRPanelManager::useAltMainPanel()
 
   altMainPanelFlag = true;
 
-  // Is the main panel currently active?
-  if (activePanels[Main_Panel])
-  {
-    mainWindow->removePanel(0, mainForm);
-    if (!altMainForm)
-    {
-      altMainForm = new PIRAltMainForm(mainWindow);
-    }
+  updateTabSet();
+}
 
-    mainWindow->insertPanel(0, altMainForm, longPanelNames[Main_Panel]);
-    mainWindow->selectPanel(0);
-  }
 
-  mainWindow->enableButtons();
+void PIRPanelManager::selectPrevFavKeyset()
+{
+  favoritesForm->selectPrevFavKeyset();
 }
 
 
-void PIRPanelManager::hidePanel(
-  PIRPanelName name,
-  int index)
+void PIRPanelManager::selectNextFavKeyset()
 {
-  switch (name)
-  {
-    case Main_Panel:
-      if (altMainPanelFlag)
-      {
-        if (altMainForm) mainWindow->removePanel(index, altMainForm);
-      }
-      else
-      {
-        if (mainForm) mainWindow->removePanel(index, mainForm);
-      }
-      break;
-
-    case Utility_Panel:
-      if (utilityForm) mainWindow->removePanel(index, utilityForm);
-      break;
-
-    case Keypad_Panel:
-      if (keypadForm) mainWindow->removePanel(index, keypadForm);
-      break;
-
-    case Menu_Panel:
-      if (menuForm) mainWindow->removePanel(index, menuForm);
-      break;
-
-    case Media_Panel:
-      if (mediaForm) mainWindow->removePanel(index, mediaForm);
-      break;
-
-    case Media2_Panel:
-      if (media2Form) mainWindow->removePanel(index, media2Form);
-      break;
-
-    case Record_Panel:
-      if (recordForm) mainWindow->removePanel(index, recordForm);
-      break;
-
-    case TV_Panel:
-      if (tvForm) mainWindow->removePanel(index, tvForm);
-      break;
-
-    case Input_Panel:
-      if (inputForm) mainWindow->removePanel(index, inputForm);
-      break;
-
-    case Adjust_Panel:
-      if (adjustForm) mainWindow->removePanel(index, adjustForm);
-      break;
-
-    case AC_Panel:
-      if (acForm) mainWindow->removePanel(index, acForm);
-      break;
-
-    case Favorites_Panel:
-      if (favoritesForm) mainWindow->removePanel(index, favoritesForm);
-      break;
-
-    default:
-      return; 
-      break;
-  }
+  favoritesForm->selectNextFavKeyset();
+}
+
+
+void PIRPanelManager::addFavoritesItem(
+  PIRKeysetWidgetItem *item)
+{
+  favoritesForm->addItem(item);
 }
 
 
-void PIRPanelManager::showPanel(
-  PIRPanelName name,
-  int index)
+QListWidget *PIRPanelManager::getFavoritesListWidget()
 {
-  switch (name)
-  {
-    case Main_Panel:
-      if (altMainPanelFlag)
-      {
-        if (!altMainForm)
-        {
-          altMainForm = new PIRAltMainForm(mainWindow);
-          mainWindow->enableButtons();
-        }
-
-        mainWindow->insertPanel(
-          index,
-          altMainForm,
-          longPanelNames[Main_Panel]);
-      }
-      else
-      {
-        if (!mainForm)
-        {
-          mainForm = new PIRMainForm(mainWindow);
-          mainWindow->enableButtons();
-        }
-
-        mainWindow->insertPanel(
-          index,
-          mainForm,
-          longPanelNames[Main_Panel]);
-      }
-
-      break;
-
-    case Utility_Panel:
-      if (!utilityForm)
-      {
-        utilityForm = new PIRUtilityForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        utilityForm,
-        longPanelNames[Utility_Panel]);
-
-      break;
-
-    case Keypad_Panel:
-      if (!keypadForm)
-      {
-        keypadForm = new PIRKeypadForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        keypadForm,
-        longPanelNames[Keypad_Panel]);
-
-      break;
-
-    case Menu_Panel:
-      if (!menuForm)
-      {
-        menuForm = new PIRMenuForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        menuForm,
-        longPanelNames[Menu_Panel]);
-
-      break;
-
-    case Media_Panel:
-      if (!mediaForm)
-      {
-        mediaForm = new PIRMediaForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        mediaForm,
-        longPanelNames[Media_Panel]);
-
-      break;
-
-    case Media2_Panel:
-      if (!media2Form)
-      {
-        media2Form = new PIRMedia2Form(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        media2Form,
-        longPanelNames[Media2_Panel]);
-
-      break;
-
-    case Record_Panel:
-      if (!recordForm)
-      {
-        recordForm = new PIRRecordForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        recordForm,
-        longPanelNames[Record_Panel]);
-
-      break;
-
-    case TV_Panel:
-      if (!tvForm)
-      {
-        tvForm = new PIRTVForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        tvForm,
-        longPanelNames[TV_Panel]);
-
-      break;
-
-    case Input_Panel:
-      if (!inputForm)
-      {
-        inputForm = new PIRInputForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        inputForm,
-        longPanelNames[Input_Panel]);
-
-      break;
-
-    case Adjust_Panel:
-      if (!adjustForm)
-      {
-        adjustForm = new PIRAdjustForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        adjustForm,
-        longPanelNames[Adjust_Panel]);
-
-      break;
-
-    case AC_Panel:
-      if (!acForm)
-      {
-        acForm = new PIRAirConditionerForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        acForm,
-        longPanelNames[AC_Panel]);
-
-      break;
-
-    case Favorites_Panel:
-      if (!favoritesForm)
-      {
-        favoritesForm = new PIRFavoritesForm(mainWindow);
-        mainWindow->enableButtons();
-      }
-
-      mainWindow->insertPanel(
-        index,
-        favoritesForm,
-        longPanelNames[Favorites_Panel]);
-
-      break;
-
-    default:
-      break;
-  }
+  return favoritesForm->getFavoritesListWidget();
 }
 
 
-void PIRPanelManager::selectPrevFavKeyset()
+void PIRPanelManager::setupUniversalTabs()
 {
-  // If the favorites form doesn't exist, no need to continue:
-  if (!favoritesForm) return;
+  if (currentTabsName == Universal_Tabs) return;
 
-  favoritesForm->selectPrevFavKeyset();
+  currentTabsName = Universal_Tabs;
+  updateTabSet();
 }
 
 
-void PIRPanelManager::selectNextFavKeyset()
+void PIRPanelManager::setupTVTabs()
 {
-  // If the favorites form doesn't exist, no need to continue:
-  if (!favoritesForm) return;
+  if (currentTabsName == TV_Tabs) return;
 
-  favoritesForm->selectNextFavKeyset();
+  currentTabsName = TV_Tabs;
+  updateTabSet();
 }
 
 
-void PIRPanelManager::addFavoritesItem(
-  PIRKeysetWidgetItem *item)
+void PIRPanelManager::setupVideoTabs()
 {
-  if (!favoritesForm)
-  {
-    favoritesForm = new PIRFavoritesForm(mainWindow);
-  }
+  if (currentTabsName == VideoMedia_Tabs) return;
 
-  favoritesForm->addItem(item);
+  currentTabsName = VideoMedia_Tabs;
+  updateTabSet();
 }
 
 
-QListWidget *PIRPanelManager::getFavoritesListWidget()
+void PIRPanelManager::setupACTabs()
 {
-  if (!favoritesForm)
-  {
-    favoritesForm = new PIRFavoritesForm(mainWindow);
-  }
+  if (currentTabsName == AC_Tabs) return;
 
-  return favoritesForm->getFavoritesListWidget();
+  currentTabsName = AC_Tabs;
+  updateTabSet();
 }
 
+
+void PIRPanelManager::setupRecordTabs()
+{
+  if (currentTabsName == Record_Tabs) return;
+
+  currentTabsName = Record_Tabs;
+  updateTabSet();
+}
+
+
+void PIRPanelManager::setupTabs(
+  PIRTabBarName name)
+{
+  if (currentTabsName == name) return;
+
+  currentTabsName = name;
+  updateTabSet();
+}
index c06c7f2..c7d842d 100644 (file)
@@ -18,15 +18,20 @@ class PIRAirConditionerForm;
 class PIRFavoritesForm;
 
 class PIRKeysetWidgetItem;
-class PIRPanelSelectionForm;
 class PIRKeysetManager;
 class QListWidget;
 class MainWindow;
 
+#include <list>
 #include <map>
 #include <QString>
+#include <QWidget>
+
+typedef std::list<PIRPanelName> PIRPanelNameList;
+typedef std::map<PIRTabBarName, PIRPanelNameList> PIRTabsCollection;
+
+typedef std::map<PIRPanelName, QWidget *> PIRPanelCollection;
 typedef std::map<PIRPanelName, const char *> PIRPanelDisplayNameCollection;
-typedef std::map<PIRPanelName, bool> PIRActivePanelCollection;
 typedef std::map<QString, PIRPanelName> PIRReversePanelIndex;
 
 class PIRPanelManager
@@ -37,8 +42,7 @@ public:
 
   ~PIRPanelManager();
 
-  void setupPanels(
-    PIRPanelSelectionForm *psf);
+  void updateTabSet();
 
   void enableButtons(
     const PIRKeysetManager *keyset,
@@ -49,10 +53,6 @@ public:
     unsigned int currentID,
     unsigned int defaultID);
 
-  void managePanel(
-    PIRPanelName name,
-    int state);
-
   void useMainPanel();
   void useAltMainPanel();
 
@@ -65,19 +65,18 @@ public:
   // This is a hack:
   QListWidget *getFavoritesListWidget();
 
+  void setupUniversalTabs();
+  void setupTVTabs();
+  void setupVideoTabs();
+  void setupACTabs();
+  void setupRecordTabs();
+  void setupTabs(PIRTabBarName name);
+
 private:
   void commonEnableButtons(
     const PIRKeysetManager *keyset,
     unsigned int id);
 
-  void hidePanel(
-    PIRPanelName name,
-    int index);
-
-  void showPanel(
-    PIRPanelName name,
-    int index);
-  
   PIRMainForm *mainForm;
   PIRAltMainForm *altMainForm;
   PIRUtilityForm *utilityForm;
@@ -94,11 +93,14 @@ private:
 
   PIRPanelDisplayNameCollection shortPanelNames;
   PIRPanelDisplayNameCollection longPanelNames;
-  PIRActivePanelCollection activePanels;
 //  PIRReversePanelIndex reverseIndex;
+  PIRTabsCollection tabLists;
+  PIRPanelCollection panels;
 
   bool altMainPanelFlag;
 
+  PIRTabBarName currentTabsName;
+
   MainWindow *mainWindow;
 };
 
index 9f38c62..44d48dc 100644 (file)
@@ -4,6 +4,7 @@
 enum PIRPanelName
 {
   Main_Panel,
+  Alt_Main_Panel,
   Utility_Panel,
   Keypad_Panel,
   Menu_Panel,
@@ -19,4 +20,13 @@ enum PIRPanelName
 };
 
 
+enum PIRTabBarName
+{
+  Universal_Tabs,
+  TV_Tabs,
+  VideoMedia_Tabs,
+  AC_Tabs,
+  Record_Tabs
+};
+
 #endif // PIRPANELNAMES_H
diff --git a/pirpanelselectionform.cpp b/pirpanelselectionform.cpp
deleted file mode 100644 (file)
index 6a6db1d..0000000
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "pirpanelselectionform.h"
-#include "ui_pirpanelselectionform.h"
-
-#include "mainwindow.h"
-
-PIRPanelSelectionForm::PIRPanelSelectionForm(QWidget *parent) :
-  QWidget(parent),
-  ui(new Ui::PIRPanelSelectionForm)
-{
-  ui->setupUi(this);
-
-  mainWindow = dynamic_cast<MainWindow *>(parent);
-
-  setAttribute(Qt::WA_Maemo5StackedWindow);
-  setWindowFlags(windowFlags() | Qt::Window);
-}
-
-PIRPanelSelectionForm::~PIRPanelSelectionForm()
-{
-  delete ui;
-}
-
-void PIRPanelSelectionForm::setCheckBox(
-  PIRPanelName name,
-  bool setting)
-{
-  switch (name)
-  {
-  case Main_Panel:
-    ui->mainCheckBox->setChecked(setting);
-    break;
-
-  case Utility_Panel:
-    ui->utilityCheckBox->setChecked(setting);
-    break;
-
-  case Keypad_Panel:
-    ui->keypadCheckBox->setChecked(setting);
-    break;
-
-  case Menu_Panel:
-    ui->menuCheckBox->setChecked(setting);
-    break;
-
-  case Media_Panel:
-    ui->mediaCheckBox->setChecked(setting);
-    break;
-
-  case Media2_Panel:
-    ui->media2CheckBox->setChecked(setting);
-    break;
-
-  case Record_Panel:
-    ui->recordCheckBox->setChecked(setting);
-    break;
-
-  case TV_Panel:
-    ui->tvCheckBox->setChecked(setting);
-    break;
-
-  case Input_Panel:
-    ui->inputCheckBox->setChecked(setting);
-    break;
-
-  case Adjust_Panel:
-    ui->adjustCheckBox->setChecked(setting);
-    break;
-
-  case AC_Panel:
-    ui->acCheckBox->setChecked(setting);
-    break;
-
-  case Favorites_Panel:
-    ui->favoritesCheckBox->setChecked(setting);
-    break;
-
-  default:
-    break;
-  }
-}
-
-void PIRPanelSelectionForm::on_mainCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Main_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_utilityCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Utility_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_keypadCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Keypad_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_menuCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Menu_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_mediaCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Media_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_media2CheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Media2_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_recordCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Record_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_tvCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(TV_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_inputCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Input_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_adjustCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Adjust_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_acCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(AC_Panel, arg1);
-}
-
-void PIRPanelSelectionForm::on_favoritesCheckBox_stateChanged(int arg1)
-{
-  mainWindow->managePanel(Favorites_Panel, arg1);
-}
diff --git a/pirpanelselectionform.h b/pirpanelselectionform.h
deleted file mode 100644 (file)
index 81c37a3..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef PIRPANELSELECTIONFORM_H
-#define PIRPANELSELECTIONFORM_H
-
-#include <QWidget>
-#include "pirpanelnames.h"
-
-class MainWindow;
-
-namespace Ui {
-class PIRPanelSelectionForm;
-}
-
-class PIRPanelSelectionForm : public QWidget
-{
-  Q_OBJECT
-  
-public:
-  explicit PIRPanelSelectionForm(QWidget *parent = 0);
-//  PIRPanelSelectionForm(MainWindow *mw);
-  ~PIRPanelSelectionForm();
-
-  void setCheckBox(
-    PIRPanelName name,
-    bool setting);
-  
-private slots:
-  void on_mainCheckBox_stateChanged(int arg1);
-  void on_utilityCheckBox_stateChanged(int arg1);
-  void on_keypadCheckBox_stateChanged(int arg1);
-  void on_menuCheckBox_stateChanged(int arg1);
-  void on_mediaCheckBox_stateChanged(int arg1);
-  void on_media2CheckBox_stateChanged(int arg1);
-  void on_recordCheckBox_stateChanged(int arg1);
-  void on_tvCheckBox_stateChanged(int arg1);
-  void on_inputCheckBox_stateChanged(int arg1);
-  void on_adjustCheckBox_stateChanged(int arg1);
-  void on_acCheckBox_stateChanged(int arg1);
-  void on_favoritesCheckBox_stateChanged(int arg1);
-
-private:
-  Ui::PIRPanelSelectionForm *ui;
-
-  MainWindow *mainWindow;
-};
-
-#endif // PIRPANELSELECTIONFORM_H
diff --git a/pirpanelselectionform.ui b/pirpanelselectionform.ui
deleted file mode 100644 (file)
index 86690aa..0000000
+++ /dev/null
@@ -1,130 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>PIRPanelSelectionForm</class>
- <widget class="QWidget" name="PIRPanelSelectionForm">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>800</width>
-    <height>480</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Select Panels</string>
-  </property>
-  <layout class="QGridLayout" name="gridLayout">
-   <property name="margin">
-    <number>8</number>
-   </property>
-   <item row="0" column="0">
-    <widget class="QScrollArea" name="scrollArea">
-     <property name="widgetResizable">
-      <bool>true</bool>
-     </property>
-     <widget class="QWidget" name="scrollAreaWidgetContents">
-      <property name="geometry">
-       <rect>
-        <x>0</x>
-        <y>0</y>
-        <width>782</width>
-        <height>462</height>
-       </rect>
-      </property>
-      <layout class="QVBoxLayout" name="verticalLayout_2">
-       <item>
-        <widget class="QCheckBox" name="mainCheckBox">
-         <property name="text">
-          <string>Main Panel - power, volume, and channel controls</string>
-         </property>
-         <property name="checked">
-          <bool>false</bool>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="utilityCheckBox">
-         <property name="text">
-          <string>Utility Panel - commonly used controls</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="keypadCheckBox">
-         <property name="text">
-          <string>Keypad Panel - numeric value entry</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="menuCheckBox">
-         <property name="text">
-          <string>Menu Panel - enter, exit, and navigate menus</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="mediaCheckBox">
-         <property name="text">
-          <string>Media Panel - control over recorded data</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="media2CheckBox">
-         <property name="text">
-          <string>Media2 Panel - additional media controls</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="recordCheckBox">
-         <property name="text">
-          <string>Program/Record Panel - control over memory and storage</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="tvCheckBox">
-         <property name="text">
-          <string>TV Panel - Teletext and Picture-in-Picture</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="inputCheckBox">
-         <property name="text">
-          <string>Input Panel - manage data sources</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="adjustCheckBox">
-         <property name="text">
-          <string>Adjust Panel - modify audio and video</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="acCheckBox">
-         <property name="text">
-          <string>A/C Panel - air conditioner controls</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QCheckBox" name="favoritesCheckBox">
-         <property name="text">
-          <string>Favorites Panel - memorized keysets</string>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>
index 36544bc..029fa78 100644 (file)
@@ -6,7 +6,7 @@
 
 #include <QSettings>
 
-#include <iostream>
+//#include <iostream>
 
 PIRPreferencesForm::PIRPreferencesForm(
   QWidget *parent,
index 1038063..b149e70 100644 (file)
@@ -97,7 +97,7 @@
           <item row="2" column="0" colspan="2">
            <widget class="QCheckBox" name="useDefaultCheckBox">
             <property name="enabled">
-             <bool>false</bool>
+             <bool>true</bool>
             </property>
             <property name="text">
              <string>Always use default keyset for volume controls</string>
index 021cc07..6639c79 100644 (file)
@@ -94,7 +94,8 @@ void PIRSelectDeviceForm::keyPressEvent(
 }
 
 
-void PIRSelectDeviceForm::on_searchStringLineEdit_textChanged(const QString &arg1)
+void PIRSelectDeviceForm::on_searchStringLineEdit_textChanged(
+  const QString &arg1)
 {
   filterListByString(arg1);
 }
index d901de2..62fe3bc 100644 (file)
   <property name="windowTitle">
    <string>Select Keyset</string>
   </property>
-  <layout class="QGridLayout" name="gridLayout">
+  <layout class="QVBoxLayout" name="verticalLayout">
    <property name="margin">
     <number>8</number>
    </property>
-   <item row="1" column="0" colspan="2">
-    <widget class="QListWidget" name="keysetListWidget">
-     <property name="focusPolicy">
-      <enum>Qt::NoFocus</enum>
-     </property>
-    </widget>
-   </item>
-   <item row="0" column="0">
-    <layout class="QHBoxLayout" name="makeHorizontalLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
      <item>
       <widget class="QLabel" name="makeLabel">
        <property name="sizePolicy">
-        <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+        <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
          <horstretch>0</horstretch>
          <verstretch>0</verstretch>
         </sizepolicy>
      </item>
     </layout>
    </item>
-   <item row="2" column="0">
-    <layout class="QHBoxLayout" name="horizontalLayout">
+   <item>
+    <widget class="QListWidget" name="keysetListWidget">
+     <property name="focusPolicy">
+      <enum>Qt::NoFocus</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
      <item>
       <widget class="QLineEdit" name="searchStringLineEdit"/>
      </item>
diff --git a/protocols/paceprotocol.cpp b/protocols/paceprotocol.cpp
new file mode 100644 (file)
index 0000000..3129917
--- /dev/null
@@ -0,0 +1,139 @@
+#include "paceprotocol.h"
+
+#include "pirrx51hardware.h"
+
+#include "pirexception.h"
+
+// Some global communications stuff:
+#include <QMutex>
+extern bool commandInFlight;
+extern QMutex commandIFMutex;
+
+// The Pace protocol is fairly simple.  (Not sure I've got good data, though)
+// A "zero" is encoded with a 630 usec pulse, 7*630 (4410) usec space.
+// A "one" is encoded with a 630 usec pulse, 11*630 (6930) usec space.
+// Different opinions exist on what is the header; I'm going to go with
+//   a 630 usec pulse, 6930 usec space one.  Hope it works.
+// Commands end with a trailing 630 usec pulse.
+// Full pulse train is re-sent when repeating.
+// Each command runs for 120000 usec.
+// The carrier frequency is 38 kHz.
+
+PaceProtocol::PaceProtocol(
+  QObject *guiObject,
+  unsigned int index)
+  : SpaceProtocol(
+      guiObject, index,
+      630, 4410,
+      630, 6930,
+      630, 6930,
+      500,
+      120000, true),
+    keypressCount(0)
+{
+}
+
+
+void PaceProtocol::startSendingCommand(
+  unsigned int threadableID,
+  PIRKeyName command)
+{
+  // Exceptions here are problematic; I'll try to weed them out by putting the
+  // whole thing in a try/catch block:
+  try
+  {
+    // First, check if we are meant to be the recipient of this command:
+    if (threadableID != id) return;
+
+    clearRepeatFlag();
+
+    KeycodeCollection::const_iterator i = keycodes.find(command);
+
+    // Do we even have this key defined?
+    if (i == keycodes.end())
+    {
+      std::string s = "Tried to send a non-existent command.\n";
+      throw PIRException(s);
+    }
+
+    // construct the device:
+    PIRRX51Hardware rx51device(carrierFrequency, dutyCycle);
+
+    int repeatCount = 0;
+    int commandDuration = 0;
+    while (repeatCount < MAX_REPEAT_COUNT)
+    {
+      commandDuration = generateStandardCommand((*i).second, rx51device);
+
+      // Now, tell the device to send the whole command:
+      rx51device.sendCommandToDevice();
+
+      // sleep until the next repetition of command:
+      sleepUntilRepeat(commandDuration);
+
+      // Check whether we've reached the minimum required number of repetitons:
+      if (repeatCount >= minimumRepetitions)
+      {
+        // Check whether we've been asked to stop:
+        if (checkRepeatFlag())
+        {
+          ++keypressCount;
+          QMutexLocker cifLocker(&commandIFMutex);
+          commandInFlight = false;
+          return;
+        }
+      }
+
+      ++repeatCount;
+    }
+  }
+  catch (PIRException e)
+  {
+    // inform the gui:
+    emit commandFailed(e.getError().c_str());
+  }
+
+  ++keypressCount;
+  QMutexLocker cifLocker(&commandIFMutex);
+  commandInFlight = false;
+}
+
+
+// Pace seems to be going with a header pulse/space, a toggle bit, and nine
+// more bits of data.  Information is sketchy, however.  I'll be going with
+// three bits of pre-data (address?), and six bits of command...
+
+int PaceProtocol::generateStandardCommand(
+  const PIRKeyBits &pkb,
+  PIRRX51Hardware &rx51device)
+{
+  int duration = 0;
+
+  // First, the "header" pulse:
+  rx51device.addPair(headerPulse, headerSpace);
+  duration += (headerPulse + headerSpace);
+
+  // Next, the toggle bit:
+  if (keypressCount % 2)
+  {
+    rx51device.addPair(onePulse, oneSpace);
+    duration += (onePulse + oneSpace);
+  }
+  else
+  {
+    rx51device.addPair(zeroPulse, zeroSpace);
+    duration += (zeroPulse + zeroSpace);
+  }
+
+  // Next, three bits of pre-data:
+  duration += pushBits(preData, rx51device);
+
+  // Next, six bits of data:
+  duration += pushBits(pkb.firstCode, rx51device);
+
+  // Finally add the "trail":
+  rx51device.addSingle(trailerPulse);
+  duration += trailerPulse;
+
+  return duration;
+}
diff --git a/protocols/paceprotocol.h b/protocols/paceprotocol.h
new file mode 100644 (file)
index 0000000..2fb0f94
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef PACEPROTOCOL_H
+#define PACEPROTOCOL_H
+
+#include "spaceprotocol.h"
+
+class PIRRX51Hardware;
+
+// The "Pace" protocol seems to be a very simple space-encoded protocol
+// with little more than the command code and a toggle bit.
+
+class PaceProtocol: public SpaceProtocol
+{
+public:
+  PaceProtocol(
+    QObject *guiObject,
+    unsigned int index);
+
+public slots:
+  void startSendingCommand(
+    unsigned int threadableID,
+    PIRKeyName command);
+
+private:
+  unsigned int keypressCount;
+
+  int generateStandardCommand(
+    const PIRKeyBits &bits,
+    PIRRX51Hardware &device);
+};
+
+#endif // PACEPROTOCOL_H
diff --git a/protocols/panasonicoldprotocol.cpp b/protocols/panasonicoldprotocol.cpp
new file mode 100644 (file)
index 0000000..17d037b
--- /dev/null
@@ -0,0 +1,127 @@
+#include "panasonicoldprotocol.h"
+
+#include "pirrx51hardware.h"
+
+#include "pirexception.h"
+
+#include <QMutex>
+extern bool commandInFlight;
+extern QMutex commandIFMutex;
+
+// The "Panasonic Old" protocol appears to have the following features:
+// A "zero" is encoded with an 833 usec pulse, 833 usec space.
+// A "one" is encoded with an 833 usec pulse, and 3*833 (2499) usec space.
+// The header is a 3332 usec pulse, 3332 usec space.
+// Commands end with a trailing 833 usec pulse.
+// When repeating, the entire command is re-sent.
+// Each command runs for approximately 105000 usec (need to check this)
+// The carrier frequency might be 57.6 kHz.
+
+PanasonicOldProtocol::PanasonicOldProtocol(
+  QObject *guiObject,
+  unsigned int index)
+  : SpaceProtocol(
+      guiObject, index,
+      833, 833,
+      833, 2499,
+      3332, 3332,
+      833,
+      105000, true)
+{
+}
+
+
+void PanasonicOldProtocol::startSendingCommand(
+  unsigned int threadableID,
+  PIRKeyName command)
+{
+  // Exceptions here are problematic; I'll try to weed them out by putting the
+  // whole thing in a try/catch block:
+  try
+  {
+    // First, check if we are meant to be the recipient of this command:
+    if (threadableID != id) return;
+
+    clearRepeatFlag();
+
+    KeycodeCollection::const_iterator i = keycodes.find(command);
+
+    // Do we even have this key defined?
+    if (i == keycodes.end())
+    {
+      std::string s = "Tried to send a non-existent command.\n";
+      throw PIRException(s);
+    }
+
+    // construct the device:
+    PIRRX51Hardware rx51device(carrierFrequency, dutyCycle);
+
+    int repeatCount = 0;
+    int commandDuration = 0;
+    while (repeatCount < MAX_REPEAT_COUNT)
+    {
+      commandDuration = generateStandardCommand((*i).second, rx51device);
+
+      // Now, tell the device to send the whole command:
+      rx51device.sendCommandToDevice();
+
+      // sleep until the next repetition of command:
+      sleepUntilRepeat(commandDuration);
+
+      // Check whether we've reached the minimum required number of repetitons:
+      if (repeatCount >= minimumRepetitions)
+      {
+        // Check whether we've been asked to stop:
+        if (checkRepeatFlag())
+        {
+          QMutexLocker cifLocker(&commandIFMutex);
+          commandInFlight = false;
+          return;
+        }
+      }
+
+      ++repeatCount;
+    }
+  }
+  catch (PIRException e)
+  {
+    // inform the gui:
+    emit commandFailed(e.getError().c_str());
+  }
+
+  QMutexLocker cifLocker(&commandIFMutex);
+  commandInFlight = false;
+}
+
+
+int PanasonicOldProtocol::generateStandardCommand(
+  const PIRKeyBits &pkb,
+  PIRRX51Hardware &rx51device)
+{
+  int duration = 0;
+
+  // First, the header pulse:
+  rx51device.addPair(headerPulse, headerSpace);
+  duration += (headerPulse + headerSpace);
+
+  // Supposedly, this protocol uses 5 bits of address and 6 bits of command,
+  // but it looks like the address can be variable.  So, I'm going to treat
+  // them as more-or-less two separate sets of command data.
+  //
+  // It is laid out as follows:
+  // 1) the five bits of "address" data
+  // 2) the six bits of command data
+  // 3) repeat of the five bits of address data, inverted
+  // 4) repeat of the six bits of command data, inverted
+
+  duration += pushReverseBits(pkb.firstCode, rx51device);
+  duration += pushReverseBits(pkb.secondCode, rx51device);
+  duration += pushInvertedReverseBits(pkb.firstCode, rx51device);
+  duration += pushInvertedReverseBits(pkb.secondCode, rx51device);
+
+  // Add the trailer pulse:
+  rx51device.addSingle(trailerPulse);
+  duration += trailerPulse;
+
+  return duration;
+}
diff --git a/protocols/panasonicoldprotocol.h b/protocols/panasonicoldprotocol.h
new file mode 100644 (file)
index 0000000..bd48713
--- /dev/null
@@ -0,0 +1,31 @@
+#ifndef PANASONICOLDPROTOCOL_H
+#define PANASONICOLDPROTOCOL_H
+
+#include "spaceprotocol.h"
+
+class PIRRX51Hardware;
+
+//
+// This is apparently a very old Panasonic protocol, but still in use by a
+// few manufacturers.
+//
+
+class PanasonicOldProtocol: public SpaceProtocol
+{
+public:
+  PanasonicOldProtocol(
+    QObject *guiObject,
+    unsigned int index);
+
+public slots:
+  void startSendingCommand(
+    unsigned int threadableID,
+    PIRKeyName command);
+
+private:
+  int generateStandardCommand(
+    const PIRKeyBits &bits,
+    PIRRX51Hardware &device);
+};
+
+#endif // PANASONICOLDPROTOCOL_H
index 7e6d794..4a78eac 100644 (file)
@@ -185,6 +185,32 @@ void PIRProtocol::addNECKey(
 }
 
 
+void PIRProtocol::addPanOldKey(
+  PIRKeyName key,
+  unsigned int addressData,
+  unsigned int commandData)
+{
+  PIRKeyBits *pkb = 0;
+  KeycodeCollection::iterator i = keycodes.find(key);
+  if (i != keycodes.end())
+  {
+    pkb = &(i->second);
+    pkb->firstCode.clear();
+    pkb->secondCode.clear();
+    pkb->thirdCode.clear();
+    pkb->fourthCode.clear();
+  }
+  else
+  {
+    pkb = &(keycodes[key]);
+  }
+
+  // The "Old Panasonic" commands have 5 bits address, 6 bits command:
+  appendToBitSeq(pkb->firstCode, addressData, 5);
+  appendToBitSeq(pkb->secondCode, commandData, 6);
+}
+
+
 // Most Pioneer keys use the NEC key format, but some are pairs of
 // NEC keys sent together:
 void PIRProtocol::addPioneerKey(
index e5b32c9..fc77f8c 100644 (file)
@@ -77,6 +77,11 @@ public:
     unsigned int addressData,
     unsigned int commandData);
 
+  void addPanOldKey(
+    PIRKeyName key,
+    unsigned int addressData,
+    unsigned int commandData);
+
   void addPioneerKey(
     PIRKeyName key,
     unsigned int firstAddress,
index 4c11595..3efa564 100644 (file)
@@ -31,4 +31,4 @@ private:
     PIRRX51Hardware &device);
 };
 
-#endif // NECPROTOCOL_H
+#endif // THOMSONPROTOCOL_H
index 63b6109..f8a8656 100644 (file)
@@ -1,3 +1,15 @@
+pierogi (1.1.6) unstable; urgency=low
+  * Hey, I'm back!  The big change in this update is a move back to real tabbed windows.  I've finally figured out how to quickly customize the tab bar.
+  * First pass at keysets for Cisco, Loewe, Orion, Proview, Strong, Technisat, and Telefunken.
+  * New keysets added for Panasonic, Sony, Toshiba, and Zenith.
+
+ -- John Pietrzak <jpietrzak8@gmail.com>  Thu, 30 Aug 2012 16:16:21 -0400
+
+pierogi (1.1.5) unstable; urgency=low
+  * First pass at keysets for Gadmei, Onkyo.
+
+ -- John Pietrzak <jpietrzak8@gmail.com>  Thu, 15 Mar 2012 15:11:11 -0400
+
 pierogi (1.1.4) unstable; urgency=low
   * Finally added the ability to search the keyset and device lists using the keyboard.
   * Added a "default keyset" to the preferences page; so far, the only thing you can do with the default is use it for the volume control keys.

Terms of Use    Privacy Policy    Contribution Guidelines    Feedback

Powered By GForge Collaborative Development Environment