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