<file>icons/PierogiIcon.png</file>
<file>icons/red_pause.png</file>
<file>icons/delete_icon&48.png</file>
+ <file>icons/align_just_icon&32.png</file>
</qresource>
</RCC>
--- /dev/null
+#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();
+}
--- /dev/null
+#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
--- /dev/null
+<?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>
--- /dev/null
+#include "pirtabswidgetitem.h"
+
+PIRTabsWidgetItem::PIRTabsWidgetItem(
+ QString displayName,
+ PIRTabBarName internalName)
+ : QListWidgetItem(displayName),
+ tabBarName(internalName)
+{
+}
+
+
+PIRTabBarName PIRTabsWidgetItem::getTabBarName()
+{
+ return tabBarName;
+}
--- /dev/null
+#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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
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"
--- /dev/null
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
MCERemote1::MCERemote1(
unsigned int index)
: PIRKeysetMetaData(
- "Remote mode 1",
+ "Windows MCE Remote 1",
Microsoft_Make,
index)
{
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 2");
+ setKeysetName("Windows MCE Remote 2");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 3");
+ setKeysetName("Windows MCE Remote 3");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 4");
+ setKeysetName("Windows MCE Remote 4");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 5");
+ setKeysetName("Windows MCE Remote 5");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 6");
+ setKeysetName("Windows MCE Remote 6");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 7");
+ setKeysetName("Windows MCE Remote 7");
}
unsigned int index)
: MCERemote1(index)
{
- setKeysetName("Remote mode 8");
+ setKeysetName("Windows MCE Remote 8");
}
--- /dev/null
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
#include "panasonic.h"
#include "protocols/necprotocol.h"
#include "protocols/kaseikyoprotocol.h"
+#include "protocols/panasonicoldprotocol.h"
PanasonicCarAudio::PanasonicCarAudio(
Panasonic_Make,
index)
{
+ addControlledDevice(Panasonic_Make, "TX-32PD50", TV_Device);
}
}
+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(
}
+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(
}
+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(
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:
QObject *guiObject);
};
+class PanasonicVCR2: public PIRKeysetMetaData
+{
+public:
+ PanasonicVCR2(
+ unsigned int index);
+
+ virtual void populateProtocol(
+ QObject *guiObject);
+};
+
class PanasonicDVD1: public PIRKeysetMetaData
{
public:
QObject *guiObject);
};
+class PanasonicAudio3: public PIRKeysetMetaData
+{
+public:
+ PanasonicAudio3(
+ unsigned int index);
+
+ virtual void populateProtocol(
+ QObject *guiObject);
+};
+
class PanasonicAC1: public PIRKeysetMetaData
{
public:
--- /dev/null
+#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);
+}
--- /dev/null
+#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
}
+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(
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);
+}
};
+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:
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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
--- /dev/null
+#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);
+}
--- /dev/null
+#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
}
+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(
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);
}
QObject *guiObject);
};
+class ToshibaTV1i: public ToshibaTV1h
+{
+public:
+ ToshibaTV1i(
+ unsigned int index);
+
+ virtual void populateProtocol(
+ QObject *guiObject);
+};
+
class ToshibaVCR1: public PIRKeysetMetaData
{
public:
#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",
}
-void ZenithC32V37::populateProtocol(
+void ZenithTV1::populateProtocol(
QObject *guiObject)
{
if (threadableProtocol)
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);
+}
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(
#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"
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);
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);
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;
selectDeviceForm->show();
}
-void MainWindow::on_actionArrange_Button_Panels_triggered()
-{
- panelSelectionForm->show();
-}
-
void MainWindow::on_actionPreferences_triggered()
{
preferencesForm->show();
currentKeyset = kwi->getID();
QSettings settings("pietrzak.org", "Pierogi");
-// settings.setValue("currentKeyset", currentKeyset);
settings.setValue(
"currentKeysetMake",
settings.beginWriteArray("favorites");
settings.setArrayIndex(favSettingsSize);
-// settings.setValue("keysetID", currentKeyset);
settings.setValue(
"keysetMake",
kwi = dynamic_cast<PIRKeysetWidgetItem *>(qlw->item(index));
settings.setArrayIndex(index);
-// settings.setValue("keysetID", kwi->getID());
id = kwi->getID();
settings.setValue(
}
-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);
}
class QListWidget;
class QListWidgetItem;
+class QDialog;
+
class PIRSelectKeysetForm;
class PIRSelectDeviceForm;
-class PIRPanelSelectionForm;
class PIRPreferencesForm;
class PIRDocumentationForm;
class PIRAboutForm;
+
class PIRKeysetManager;
class PIRPanelManager;
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);
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,
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;
<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&48.png</normaloff>:/icons/arrow_left_icon&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&48.png</normaloff>:/icons/arrow_right_icon&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>
</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>
forms/pirmenuform.cpp \
forms/pirmediaform.cpp \
forms/pirfavoritesform.cpp \
- pirpanelselectionform.cpp \
pirpanelmanager.cpp \
protocols/nokia32protocol.cpp \
protocols/kathreinprotocol.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 \
forms/pirfavoritesform.h \
pirpanelnames.h \
pirpanelmanager.h \
- pirpanelselectionform.h \
protocols/nokia32protocol.h \
protocols/kathreinprotocol.h \
keysets/aoc.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 \
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)
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
<?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>
<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>
PCInput_Key,
CompositeInput_Key,
Composite2Input_Key,
+ SVideoInput_Key,
+ SVideo2Input_Key,
ComponentInput_Key,
Component2Input_Key,
HDMIInput_Key,
#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"
#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"
#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"
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));
setupKeyset(new FoxtelSTB1(++counter));
setupKeyset(new FoxtelSTB2(++counter));
+ setupKeyset(new GadmeiTuner1(++counter));
+
setupKeyset(new GeniusSpeakers1(++counter));
setupKeyset(new GoldStarTV1(++counter));
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));
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));
setupKeyset(new PioneerLaserDisc1(++counter));
setupKeyset(new PioneerDVD1(++counter));
+ setupKeyset(new ProviewDVD1(++counter));
+
setupKeyset(new QNAPPlayer1(++counter));
setupKeyset(new RaiteDVD1(++counter));
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));
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));
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));
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));
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();
}
+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,
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,
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";
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";
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";
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";
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";
Bush_Make,
Cambridge_Make,
Canon_Make,
+ Cisco_Make,
Compro_Make,
Daewoo_Make,
Dell_Make,
Epson_Make,
Fortec_Make,
Foxtel_Make,
+ Gadmei_Make,
Genius_Make,
GoldStar_Make,
Grundig_Make,
Kenwood_Make,
Lexuz_Make,
LG_Make,
+ Loewe_Make,
Logitech_Make,
Magnavox_Make,
Magnum_Make,
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,
Sky_Make,
Sony_Make,
Starsat_Make,
+ Strong_Make,
Technics_Make,
+ Technisat_Make,
+ Telefunken_Make,
Telenet_Make,
Thomson_Make,
Tivo_Make,
#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),
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] =
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;
}
}
-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();
}
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);
}
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);
}
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);
}
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();
}
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();
+}
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
~PIRPanelManager();
- void setupPanels(
- PIRPanelSelectionForm *psf);
+ void updateTabSet();
void enableButtons(
const PIRKeysetManager *keyset,
unsigned int currentID,
unsigned int defaultID);
- void managePanel(
- PIRPanelName name,
- int state);
-
void useMainPanel();
void useAltMainPanel();
// 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;
PIRPanelDisplayNameCollection shortPanelNames;
PIRPanelDisplayNameCollection longPanelNames;
- PIRActivePanelCollection activePanels;
// PIRReversePanelIndex reverseIndex;
+ PIRTabsCollection tabLists;
+ PIRPanelCollection panels;
bool altMainPanelFlag;
+ PIRTabBarName currentTabsName;
+
MainWindow *mainWindow;
};
enum PIRPanelName
{
Main_Panel,
+ Alt_Main_Panel,
Utility_Panel,
Keypad_Panel,
Menu_Panel,
};
+enum PIRTabBarName
+{
+ Universal_Tabs,
+ TV_Tabs,
+ VideoMedia_Tabs,
+ AC_Tabs,
+ Record_Tabs
+};
+
#endif // PIRPANELNAMES_H
+++ /dev/null
-#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);
-}
+++ /dev/null
-#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
+++ /dev/null
-<?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>
#include <QSettings>
-#include <iostream>
+//#include <iostream>
PIRPreferencesForm::PIRPreferencesForm(
QWidget *parent,
<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>
}
-void PIRSelectDeviceForm::on_searchStringLineEdit_textChanged(const QString &arg1)
+void PIRSelectDeviceForm::on_searchStringLineEdit_textChanged(
+ const QString &arg1)
{
filterListByString(arg1);
}
<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>
--- /dev/null
+#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;
+}
--- /dev/null
+#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
--- /dev/null
+#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;
+}
--- /dev/null
+#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
}
+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(
unsigned int addressData,
unsigned int commandData);
+ void addPanOldKey(
+ PIRKeyName key,
+ unsigned int addressData,
+ unsigned int commandData);
+
void addPioneerKey(
PIRKeyName key,
unsigned int firstAddress,
PIRRX51Hardware &device);
};
-#endif // NECPROTOCOL_H
+#endif // THOMSONPROTOCOL_H
+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.
projects / pierogi / commitdiff
