From: John Pietrzak Date: Thu, 6 Sep 2012 20:44:26 +0000 (-0400) Subject: Search for Power Button Panel X-Git-Url: https://vcs.maemo.org/git/?p=pierogi;a=commitdiff_plain;h=a755f0efc0ba10848d26e1aed7f9933ccdcbb59e Search for Power Button Panel Finally, a "search for power button" panel has been added to Pierogi. Probably still needs some tweaking. Also, a new Camera Shutter panel for DSLR camera remotes. First pass at keysets for Deutsche Telekom, Emtec, Goodmans, Nikon, Olympus, and Pentax; Canon keyset updated to use new camera panel. --- diff --git a/dialogs/pireditkeysetdialog.cpp b/dialogs/pireditkeysetdialog.cpp index c0662c3..c9b2f7b 100644 --- a/dialogs/pireditkeysetdialog.cpp +++ b/dialogs/pireditkeysetdialog.cpp @@ -52,6 +52,10 @@ void PIREditKeysetDialog::setupDialog( { ui->nicknameLineEdit->setText(kwi->getNickname()); } + else + { + ui->nicknameLineEdit->clear(); + } keysetItem = kwi; } @@ -121,9 +125,6 @@ void PIREditKeysetDialog::enactChanges() mainWindow->addToFavorites(keysetItem); } } - - // Finally, clean up the dialog box for the next user: - ui->nicknameLineEdit->clear(); } diff --git a/dialogs/pirtabschoicedialog.cpp b/dialogs/pirtabschoicedialog.cpp index 21d4662..d184dc3 100644 --- a/dialogs/pirtabschoicedialog.cpp +++ b/dialogs/pirtabschoicedialog.cpp @@ -31,7 +31,13 @@ PIRTabsChoiceDialog::PIRTabsChoiceDialog( new PIRTabsWidgetItem("Air Conditioner Panels", AC_Tabs)); ui->tabsChoiceListWidget->addItem( + new PIRTabsWidgetItem("Camera Panels", Camera_Tabs)); + + ui->tabsChoiceListWidget->addItem( new PIRTabsWidgetItem("Roomba Panels", Roomba_Tabs)); + + ui->tabsChoiceListWidget->addItem( + new PIRTabsWidgetItem("Keyset Search Panels", PowerSearch_Tabs)); } diff --git a/forms/pircameraform.cpp b/forms/pircameraform.cpp new file mode 100644 index 0000000..fbda637 --- /dev/null +++ b/forms/pircameraform.cpp @@ -0,0 +1,60 @@ +#include "pircameraform.h" +#include "ui_pircameraform.h" + +#include "mainwindow.h" +#include "pirkeysetmanager.h" + +/* +PIRCameraForm::PIRCameraForm(QWidget *parent) : + QWidget(parent), + ui(new Ui::PIRCameraForm) +{ + ui->setupUi(this); +} +*/ + + +PIRCameraForm::PIRCameraForm( + MainWindow *mw) + : QWidget(0), + ui(new Ui::PIRCameraForm), + mainWindow(mw) +{ + ui->setupUi(this); +} + + +PIRCameraForm::~PIRCameraForm() +{ + delete ui; +} + + +void PIRCameraForm::enableButtons( + const PIRKeysetManager *km, + unsigned int id) +{ + emit openShutterEnabled(km->hasKey(id, OpenShutter_Key)); + emit delayedOpenShutterEnabled(km->hasKey(id, DelayedOpenShutter_Key)); +} + + +void PIRCameraForm::on_delayedShutterButton_pressed() +{ + mainWindow->startRepeating(DelayedOpenShutter_Key); +} + +void PIRCameraForm::on_delayedShutterButton_released() +{ + mainWindow->stopRepeating(); +} + +void PIRCameraForm::on_openShutterButton_pressed() +{ + mainWindow->startRepeating(OpenShutter_Key); +} + +void PIRCameraForm::on_openShutterButton_released() +{ + mainWindow->stopRepeating(); +} diff --git a/forms/pircameraform.h b/forms/pircameraform.h new file mode 100644 index 0000000..0ff46c2 --- /dev/null +++ b/forms/pircameraform.h @@ -0,0 +1,45 @@ +#ifndef PIRCAMERAFORM_H +#define PIRCAMERAFORM_H + +#include + +class MainWindow; +class PIRKeysetManager; + +namespace Ui { +class PIRCameraForm; +} + +class PIRCameraForm : public QWidget +{ + Q_OBJECT + +public: +// explicit PIRCameraForm(QWidget *parent = 0); + + PIRCameraForm( + MainWindow *mw); + + ~PIRCameraForm(); + + void enableButtons( + const PIRKeysetManager *keyset, + unsigned int id); + +signals: + void openShutterEnabled(bool); + void delayedOpenShutterEnabled(bool); + +private slots: + void on_delayedShutterButton_pressed(); + void on_delayedShutterButton_released(); + void on_openShutterButton_pressed(); + void on_openShutterButton_released(); + +private: + Ui::PIRCameraForm *ui; + + MainWindow *mainWindow; +}; + +#endif // PIRCAMERAFORM_H diff --git a/forms/pircameraform.ui b/forms/pircameraform.ui new file mode 100644 index 0000000..f2d3d73 --- /dev/null +++ b/forms/pircameraform.ui @@ -0,0 +1,87 @@ + + + PIRCameraForm + + + + 0 + 0 + 800 + 480 + + + + Form + + + + 8 + + + + + + 0 + 0 + + + + Open Shutter After Delay + + + + + + + + 0 + 0 + + + + Open Shutter + + + + + + + + + PIRCameraForm + openShutterEnabled(bool) + openShutterButton + setEnabled(bool) + + + 399 + 239 + + + 399 + 361 + + + + + PIRCameraForm + delayedOpenShutterEnabled(bool) + delayedShutterButton + setEnabled(bool) + + + 399 + 239 + + + 399 + 122 + + + + + + openShutterEnabled(bool) + delayedOpenShutterEnabled(bool) + + diff --git a/forms/pirmacroform.ui b/forms/pirmacroform.ui index 9b5d68a..1644c0c 100644 --- a/forms/pirmacroform.ui +++ b/forms/pirmacroform.ui @@ -13,119 +13,158 @@ Macro Processor - - + + + 8 + + - - - Continuously Cycle Macros - - - - - + - + - Cycle Delay in Seconds: + Macro Pack: - - - 5 - - - 60 - - - 5 - - + - - - - 0 - 0 - - + - Prev Macro - - - - :/icons/br_up_icon&48.png:/icons/br_up_icon&48.png + New Macro Pack - - - 48 - 48 - + + + + + + Edit / Delete Macro Pack - - - - 0 - 0 - + + + Macro Editing Commands + + + 8 + + + + + + + Macro: + + + + + + + + + + + + + 0 + 0 + + + + Prev Macro + + + + :/icons/br_up_icon&48.png:/icons/br_up_icon&48.png + + + + 48 + 48 + + + + + + + + + 0 + 0 + + + + Next Macro + + + + :/icons/br_down_icon&48.png:/icons/br_down_icon&48.png + + + + 48 + 48 + + + + + + + + New Macro + + + + + + + Edit / Delete Macro + + + + + + + + + + + + - Next Macro + Command List - - - :/icons/br_down_icon&48.png:/icons/br_down_icon&48.png + + Qt::AlignCenter - - - 48 - 48 - + + + + + + + + + New Command - - - - - - true - - - - - 0 - 0 - 529 - 420 - - - - - 0 + + + + Edit / Delete Command - - - - - - - - - - - New Macro - - + + + diff --git a/forms/pirpowersearchform.cpp b/forms/pirpowersearchform.cpp new file mode 100644 index 0000000..25cc444 --- /dev/null +++ b/forms/pirpowersearchform.cpp @@ -0,0 +1,166 @@ +#include "pirpowersearchform.h" +#include "ui_pirpowersearchform.h" + +#include "mainwindow.h" +#include "pirkeysetmanager.h" + +#include +#include + +// Debugging includes: +#include + +// Check if a command is running: +extern bool commandInFlight; +extern QMutex commandIFMutex; + +/* +PIRPowerSearchForm::PIRPowerSearchForm(QWidget *parent) : + QWidget(parent), + ui(new Ui::PIRPowerSearchForm) +{ + ui->setupUi(this); +} +*/ + + +PIRPowerSearchForm::PIRPowerSearchForm( + MainWindow *mw) + : QWidget(0), + ui(new Ui::PIRPowerSearchForm), + mainWindow(mw), + advanceTimer(0) +{ + ui->setupUi(this); +} + + +PIRPowerSearchForm::~PIRPowerSearchForm() +{ + delete ui; + if (advanceTimer) delete advanceTimer; +} + +void PIRPowerSearchForm::setKeysetName( + QString name) +{ + ui->keysetNameLabel->setText(name); +} + +void PIRPowerSearchForm::on_stepBackwardButton_pressed() +{ + if (mainWindow->selectPrevKeyset()) + { + mainWindow->startRepeating(Power_Key); + } +} + +void PIRPowerSearchForm::on_stepBackwardButton_released() +{ + mainWindow->stopRepeating(); +} + +void PIRPowerSearchForm::on_stepForwardKey_pressed() +{ + if (mainWindow->selectNextKeyset()) + { + mainWindow->startRepeating(Power_Key); + } +} + +void PIRPowerSearchForm::on_stepForwardKey_released() +{ + mainWindow->stopRepeating(); +} + +void PIRPowerSearchForm::on_fastBackwardButton_pressed() +{ + if (!mainWindow->selectPrevKeyset()) + { + return; + } + + mainWindow->startRepeating(Power_Key); + + advanceTimer = new QTimer(); + connect(advanceTimer, SIGNAL(timeout()), this, SLOT(gotoPrevKeyset())); + advanceTimer->start(100); +} + +void PIRPowerSearchForm::on_fastBackwardButton_released() +{ + delete advanceTimer; + advanceTimer = 0; + mainWindow->stopRepeating(); +} + +void PIRPowerSearchForm::on_fastForwardButton_pressed() +{ + if (!mainWindow->selectNextKeyset()) + { + return; + } + + mainWindow->startRepeating(Power_Key); + + advanceTimer = new QTimer(); + connect(advanceTimer, SIGNAL(timeout()), this, SLOT(gotoNextKeyset())); + advanceTimer->start(50); +} + + +void PIRPowerSearchForm::on_fastForwardButton_released() +{ + delete advanceTimer; + advanceTimer = 0; + mainWindow->stopRepeating(); +} + + +void PIRPowerSearchForm::gotoPrevKeyset() +{ + if (checkMutex()) + { + mainWindow->stopRepeating(); + } + else + { + if (mainWindow->selectPrevKeyset()) + { + mainWindow->startRepeating(Power_Key); + } + else + { + delete advanceTimer; + advanceTimer = 0; + } + } +} + + +void PIRPowerSearchForm::gotoNextKeyset() +{ + if (checkMutex()) + { + mainWindow->stopRepeating(); + } + else + { + if (mainWindow->selectNextKeyset()) + { + mainWindow->startRepeating(Power_Key); + } + else + { + delete advanceTimer; + advanceTimer = 0; + } + } +} + + +bool PIRPowerSearchForm::checkMutex() +{ + QMutexLocker locker(&commandIFMutex); + return commandInFlight; +} diff --git a/forms/pirpowersearchform.h b/forms/pirpowersearchform.h new file mode 100644 index 0000000..91554e2 --- /dev/null +++ b/forms/pirpowersearchform.h @@ -0,0 +1,53 @@ +#ifndef PIRPOWERSEARCHFORM_H +#define PIRPOWERSEARCHFORM_H + +#include +#include + +class MainWindow; +class PIRKeysetManager; +class QTimer; + +namespace Ui { +class PIRPowerSearchForm; +} + +class PIRPowerSearchForm : public QWidget +{ + Q_OBJECT + +public: +// explicit PIRPowerSearchForm(QWidget *parent = 0); + + PIRPowerSearchForm( + MainWindow *mw); + + ~PIRPowerSearchForm(); + + void setKeysetName( + QString name); + +private slots: + void on_stepBackwardButton_pressed(); + void on_stepBackwardButton_released(); + void on_stepForwardKey_pressed(); + void on_stepForwardKey_released(); + void on_fastBackwardButton_pressed(); + void on_fastBackwardButton_released(); + void on_fastForwardButton_pressed(); + void on_fastForwardButton_released(); + + void gotoPrevKeyset(); + void gotoNextKeyset(); + +private: + bool checkMutex(); + + Ui::PIRPowerSearchForm *ui; + + MainWindow *mainWindow; + + QTimer *advanceTimer; +}; + +#endif // PIRPOWERSEARCHFORM_H diff --git a/forms/pirpowersearchform.ui b/forms/pirpowersearchform.ui new file mode 100644 index 0000000..c722ccd --- /dev/null +++ b/forms/pirpowersearchform.ui @@ -0,0 +1,211 @@ + + + PIRPowerSearchForm + + + + 0 + 0 + 800 + 480 + + + + Form + + + + + + + + + + + :/icons/on-off_icon&48.png + + + Qt::AlignCenter + + + + + + + Power Button Search + + + Qt::AlignCenter + + + + + + + + + + :/icons/on-off_icon&48.png + + + Qt::AlignCenter + + + + + + + + + + + + 0 + 0 + + + + Current Keyset: + + + + + + + At start of list + + + + + + + + + + 0 + 0 + + + + Previous Keyset + + + + :/icons/playback_prev_icon&48.png:/icons/playback_prev_icon&48.png + + + + 48 + 48 + + + + + + + + + 0 + 0 + + + + Next Keyset + + + + :/icons/playback_next_icon&48.png:/icons/playback_next_icon&48.png + + + + 48 + 48 + + + + + + + + + 0 + 0 + + + + Fast Backward + + + + :/icons/playback_rew_icon&48.png:/icons/playback_rew_icon&48.png + + + + 48 + 48 + + + + + + + + + 0 + 0 + + + + Fast Forward + + + + :/icons/playback_ff_icon&48.png:/icons/playback_ff_icon&48.png + + + + 48 + 48 + + + + + + + + Qt::Vertical + + + QSizePolicy::Preferred + + + + 20 + 20 + + + + + + + + Qt::Vertical + + + QSizePolicy::Preferred + + + + 20 + 20 + + + + + + + + + + + diff --git a/forms/pirstatefulacform.cpp b/forms/pirstatefulacform.cpp new file mode 100644 index 0000000..f53f021 --- /dev/null +++ b/forms/pirstatefulacform.cpp @@ -0,0 +1,14 @@ +#include "pirstatefulacform.h" +#include "ui_pirstatefulacform.h" + +PIRStatefulACForm::PIRStatefulACForm(QWidget *parent) : + QWidget(parent), + ui(new Ui::PIRStatefulACForm) +{ + ui->setupUi(this); +} + +PIRStatefulACForm::~PIRStatefulACForm() +{ + delete ui; +} diff --git a/forms/pirstatefulacform.h b/forms/pirstatefulacform.h new file mode 100644 index 0000000..e289401 --- /dev/null +++ b/forms/pirstatefulacform.h @@ -0,0 +1,22 @@ +#ifndef PIRSTATEFULACFORM_H +#define PIRSTATEFULACFORM_H + +#include + +namespace Ui { +class PIRStatefulACForm; +} + +class PIRStatefulACForm : public QWidget +{ + Q_OBJECT + +public: + explicit PIRStatefulACForm(QWidget *parent = 0); + ~PIRStatefulACForm(); + +private: + Ui::PIRStatefulACForm *ui; +}; + +#endif // PIRSTATEFULACFORM_H diff --git a/forms/pirstatefulacform.ui b/forms/pirstatefulacform.ui new file mode 100644 index 0000000..162ad6a --- /dev/null +++ b/forms/pirstatefulacform.ui @@ -0,0 +1,49 @@ + + + PIRStatefulACForm + + + + 0 + 0 + 800 + 480 + + + + Form + + + + + 70 + 50 + 111 + 26 + + + + + + + 230 + 50 + 111 + 26 + + + + + + + 440 + 50 + 111 + 26 + + + + + + + diff --git a/keysets/canon.cpp b/keysets/canon.cpp index 498e91d..d9def26 100644 --- a/keysets/canon.cpp +++ b/keysets/canon.cpp @@ -30,9 +30,10 @@ void CanonDSLR1::populateProtocol( threadableProtocol = lp; lp->setTrailerPulse(550); + lp->setCarrierFrequency(32000); // hope this is right - addKey("S", VolumeDown_Key, 0x1, 1); // Open shutter immediately (?) - addKey("2S", VolumeUp_Key, 0x0, 1); // Two second delay (?) + addKey("S", OpenShutter_Key, 0x1, 1); // Open shutter immediately (?) + addKey("2S", DelayedOpenShutter_Key, 0x0, 1); // Two second delay (?) } diff --git a/keysets/deutschetelekom.cpp b/keysets/deutschetelekom.cpp new file mode 100644 index 0000000..3d2574a --- /dev/null +++ b/keysets/deutschetelekom.cpp @@ -0,0 +1,71 @@ +#include "deutschetelekom.h" +#include "protocols/tcdprotocol.h" + +DeutscheTelekomSTB1::DeutscheTelekomSTB1( + unsigned int index) + : PIRKeysetMetaData( + "TV Receiver Keyset 1", + DeutscheTelekom_Make, + index) +{ + addControlledDevice(DeutscheTelekom_Make, "MR100", Other_Device); +} + + +void DeutscheTelekomSTB1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new TDCProtocol(guiObject, index, 0x06, 0x0A); + + addKey("1", One_Key, 0x02, 7); + addKey("2", Two_Key, 0x05, 7); + addKey("3", Three_Key, 0x06, 7); + addKey("4", Four_Key, 0x09, 7); + addKey("5", Five_Key, 0x0A, 7); + addKey("6", Six_Key, 0x0D, 7); + addKey("7", Seven_Key, 0x0E, 7); + addKey("8", Eight_Key, 0x11, 7); + addKey("9", Nine_Key, 0x12, 7); + addKey("0", Zero_Key, 0x15, 7); + addKey("power", Power_Key, 0x16, 7); + addKey("up arrow", Up_Key, 0x19, 7); + addKey("down arrow", Down_Key, 0x1A, 7); + addKey("left arrow", Left_Key, 0x1D, 7); + addKey("select", Select_Key, 0x1E, 7); + addKey("right arrow", Right_Key, 0x21, 7); + addKey("clear", Clear_Key, 0x22, 7); + addKey("vol up", VolumeUp_Key, 0x26, 7); + addKey("channel up", ChannelUp_Key, 0x29, 7); + addKey("vol down", VolumeDown_Key, 0x2A, 7); + addKey("channel down", ChannelDown_Key, 0x2D, 7); + addKey("display", Info_Key, 0x2E, 7); + addKey("last (prev ch)", PrevChannel_Key, 0x31, 7); + addKey("recording", Unmapped_Key, 0x32, 7); // what is this? + addKey("stop", Stop_Key, 0x35, 7); + addKey("play", Play_Key, 0x36, 7); + addKey("pause", Pause_Key, 0x36, 7); + addKey("record", Record_Key, 0x39, 7); + addKey("return", Unmapped_Key, 0x3A, 7); + addKey("exit", Exit_Key, 0x3D, 7); + addKey("program guide", Guide_Key, 0x3E, 7); + addKey("videoondemand", Unmapped_Key, 0x41, 7); + addKey("skip-", Previous_Key, 0x42, 7); + addKey("rewind", Rewind_Key, 0x45, 7); + addKey("fast fwd", FastForward_Key, 0x46, 7); + addKey("skip+", Next_Key, 0x49, 7); + addKey("red", Red_Key, 0x4A, 7); + addKey("green", Green_Key, 0x4D, 7); + addKey("yellow", Yellow_Key, 0x4E, 7); + addKey("blue", Blue_Key, 0x51, 7); + addKey("mute", Mute_Key, 0x52, 7); + addKey("teletext", Teletext_Key, 0x55, 7); + addKey("options", Unmapped_Key, 0x56, 7); + addKey("radio", TunerInput_Key, 0x59, 7); + addKey("menu", Menu_Key, 0x5A, 7); +} diff --git a/keysets/deutschetelekom.h b/keysets/deutschetelekom.h new file mode 100644 index 0000000..535a896 --- /dev/null +++ b/keysets/deutschetelekom.h @@ -0,0 +1,18 @@ +#ifndef DEUTSCHETELEKOM_H +#define DEUTSCHETELEKOM_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class DeutscheTelekomSTB1: public PIRKeysetMetaData +{ +public: + DeutscheTelekomSTB1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // DEUTSCHETELEKOM_H diff --git a/keysets/digitalstream.cpp b/keysets/digitalstream.cpp index 51e0705..4ffce58 100644 --- a/keysets/digitalstream.cpp +++ b/keysets/digitalstream.cpp @@ -9,6 +9,7 @@ DigitalStreamReceiver::DigitalStreamReceiver( DigitalStream_Make, index) { + addControlledDevice(DigitalStream_Make, "DTX9900", Other_Device); } diff --git a/keysets/emtec.cpp b/keysets/emtec.cpp new file mode 100644 index 0000000..3b04b19 --- /dev/null +++ b/keysets/emtec.cpp @@ -0,0 +1,130 @@ +#include "emtec.h" +#include "protocols/necprotocol.h" + +EmtecSTB1::EmtecSTB1( + unsigned int index) + : PIRKeysetMetaData( + "Movie Cube Keyset 1", + Emtec_Make, + index) +{ + addControlledDevice(Emtec_Make, "Movie Cube N200", Other_Device); +} + + +void EmtecSTB1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, true, true); + + setPreData(0x9F00, 16); + + addKey("Power", Power_Key, 0x57, 8); + addKey("Mute", Mute_Key, 0x5B, 8); + addKey("TV_Sys", Unmapped_Key, 0x01, 8); + addKey("Up", Up_Key, 0x43, 8); + addKey("Down", Down_Key, 0x0A, 8); + addKey("Left", Left_Key, 0x06, 8); + addKey("Right", Right_Key, 0x0E, 8); + addKey("Enter", Select_Key, 0x02, 8); + addKey("Rewind", Rewind_Key, 0x07, 8); + addKey("previous", Previous_Key, 0x0F, 8); + addKey("Vol-", VolumeDown_Key, 0x53, 8); + addKey("FastForward", FastForward_Key, 0x03, 8); + addKey("Next", Next_Key, 0x0B, 8); + addKey("Play", Play_Key, 0x54, 8); + addKey("Stop", Stop_Key, 0x13, 8); + addKey("Home", Guide_Key, 0x47, 8); + addKey("Return", Exit_Key, 0x4F, 8); + addKey("Search", Unmapped_Key, 0x30, 8); + addKey("Eject", Eject_Key, 0x31, 8); + addKey("option", Info_Key, 0x16, 8); +} + + +EmtecSTB2::EmtecSTB2( + unsigned int index) + : PIRKeysetMetaData( + "Movie Cube Keyset 2", + Emtec_Make, + index) +{ + addControlledDevice(Emtec_Make, "MovieCube R700", Other_Device); + addControlledDevice(Emtec_Make, "MovieCube Q800", Other_Device); +} + + +void EmtecSTB2::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, true, true); + + setPreData(0x9F00, 16); + + addKey("7", Seven_Key, 0x00, 8); + addKey("timeshift", Unmapped_Key, 0x01, 8); + addKey("select", Select_Key, 0x02, 8); + addKey("fast fwd", FastForward_Key, 0x03, 8); + addKey("4", Four_Key, 0x04, 8); + addKey("1", One_Key, 0x05, 8); + addKey("left arrow", Left_Key, 0x06, 8); + addKey("rewind", Rewind_Key, 0x07, 8); + addKey("5", Five_Key, 0x08, 8); + addKey("2", Two_Key, 0x09, 8); + addKey("down arrow", Down_Key, 0x0A, 8); + addKey("skip", Next_Key, 0x0B, 8); // "next" + addKey("9", Nine_Key, 0x0C, 8); + addKey("goto", Unmapped_Key, 0x0D, 8); + addKey("right arrow", Right_Key, 0x0E, 8); + addKey("replay", Previous_Key, 0x0F, 8); // "prev" + addKey("8", Eight_Key, 0x10, 8); + addKey("0", Zero_Key, 0x11, 8); + addKey("stop", Stop_Key, 0x13, 8); + addKey("6", Six_Key, 0x14, 8); + addKey("3", Three_Key, 0x15, 8); + addKey("display", Info_Key, 0x16, 8); + addKey("vol up", VolumeUp_Key, 0x17, 8); + addKey("setup", Unmapped_Key, 0x1A, 8); + addKey("zoom", Zoom_Key, 0x1B, 8); + addKey("green", Green_Key, 0x1D, 8); + addKey("yellow", Yellow_Key, 0x1E, 8); + addKey("blue", Blue_Key, 0x1F, 8); + addKey("audio", Audio_Key, 0x40, 8); + addKey("input next", Unmapped_Key, 0x41, 8); + addKey("f1", Unmapped_Key, 0x42, 8); + addKey("red", Red_Key, 0x42, 8); + addKey("up arrow", Up_Key, 0x43, 8); + addKey("repeat", Repeat_Key, 0x44, 8); + addKey("subtitle", Captions_Key, 0x45, 8); + addKey("repeat ab", RepeatAB_Key, 0x46, 8); + addKey("program guide", Guide_Key, 0x47, 8); + addKey("com skip", Advance_Key, 0x48, 8); + addKey("replay", Replay_Key, 0x49, 8); + addKey("record list", Unmapped_Key, 0x4A, 8); + addKey("slow", Slow_Key, 0x4C, 8); + addKey("pause", Pause_Key, 0x4D, 8); + addKey("timer", Timer_Key, 0x4E, 8); + addKey("return", Exit_Key, 0x4F, 8); + addKey("play", Play_Key, 0x50, 8); + addKey("record", Record_Key, 0x52, 8); + addKey("vol down", VolumeDown_Key, 0x54, 8); + addKey("browser", Unmapped_Key, 0x55, 8); + addKey("tv system", Unmapped_Key, 0x56, 8); + addKey("power", Power_Key, 0x57, 8); + addKey("copy", Unmapped_Key, 0x58, 8); + addKey("music", Unmapped_Key, 0x59, 8); + addKey("menu", Menu_Key, 0x5A, 8); + addKey("mute", Mute_Key, 0x5B, 8); +} diff --git a/keysets/emtec.h b/keysets/emtec.h new file mode 100644 index 0000000..227d0df --- /dev/null +++ b/keysets/emtec.h @@ -0,0 +1,28 @@ +#ifndef EMTEC_H +#define EMTEC_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class EmtecSTB1: public PIRKeysetMetaData +{ +public: + EmtecSTB1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +class EmtecSTB2: public PIRKeysetMetaData +{ +public: + EmtecSTB2( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // EMTEC_H diff --git a/keysets/goodmans.cpp b/keysets/goodmans.cpp new file mode 100644 index 0000000..e5416b0 --- /dev/null +++ b/keysets/goodmans.cpp @@ -0,0 +1,253 @@ +#include "goodmans.h" +#include "protocols/rc5protocol.h" +#include "protocols/necprotocol.h" + +GoodmansSTB1::GoodmansSTB1( + unsigned int index) + : PIRKeysetMetaData( + "TV Set Top Box Keyset 1", + Goodmans_Make, + index) +{ +} + + +void GoodmansSTB1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("Power", Power_Key, 0x120C, 13); + addKey("TV/DTV", Input_Key, 0x120E, 13); + addKey("MUTE", Mute_Key, 0x120D, 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("WIDE", AspectRatio_Key, 0x121E, 13); + addKey("0", Zero_Key, 0x1200, 13); + addKey("GUIDE", Guide_Key, 0x1222, 13); + addKey("P-", ChannelDown_Key, 0x1221, 13); + addKey("P+", ChannelUp_Key, 0x1220, 13); + addKey("V-", VolumeDown_Key, 0x1211, 13); + addKey("V+", VolumeUp_Key, 0x1210, 13); + addKey("i", Info_Key, 0x123F, 13); // is this right? + addKey("MENU", Menu_Key, 0x1235, 13); + addKey("RED", Red_Key, 0x1237, 13); + addKey("UP", Up_Key, 0x1212, 13); + addKey("BLUE", Blue_Key, 0x1234, 13); + addKey("LEFT", Left_Key, 0x1215, 13); + addKey("SELECT", Select_Key, 0x1214, 13); + addKey("RIGHT", Right_Key, 0x1216, 13); + addKey("GREEN", Green_Key, 0x1236, 13); + addKey("DOWN", Down_Key, 0x1213, 13); + addKey("YELLOW", Yellow_Key, 0x1232, 13); + addKey("EXIT", Exit_Key, 0x120A, 13); + addKey("TEXT", Teletext_Key, 0x123C, 13); + addKey("SUBTITLE", Captions_Key, 0x1226, 13); +} + + +GoodmansVCR1::GoodmansVCR1( + unsigned int index) + : PIRKeysetMetaData( + "VCR Keyset 1", + Goodmans_Make, + index) +{ +} + + +void GoodmansVCR1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, true, false); + + setPreData(0x7B80, 16); + + addKey("VCR_ON", Power_Key, 0x13, 8); + addKey("EJECT", Eject_Key, 0x4E, 8); + addKey("TIMER_REC", RecordTimed_Key, 0x0D, 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("-/--", DoubleDigit_Key, 0x0F, 8); + addKey("TV/VCR", Input_Key, 0x12, 8); + addKey("CHANNEL+", ChannelUp_Key, 0x0A, 8); + addKey("CHANNEL-", ChannelDown_Key, 0x0B, 8); + addKey("SPEED_SP/LP", VHSSpeed_Key, 0x1E, 8); + addKey("CALL", Call_Key, 0x5F, 8); + addKey("REC/QTR", Record_Key, 0x15, 8); + addKey("PAUSE", Pause_Key, 0x1A, 8); + addKey("Play/Slow/Up", Play_Key, 0x16, 8); + addKey("Play/Slow/Up", Slow_Key, 0x16, 8); + addKey("Play/Slow/Up", Up_Key, 0x16, 8); + addKey("Stop/Down", Stop_Key, 0x17, 8); + addKey("Stop/Down", Down_Key, 0x17, 8); + addKey("Rew/Left", Rewind_Key, 0x19, 8); + addKey("Rew/Left", Left_Key, 0x19, 8); + addKey("FF/Right", FastForward_Key, 0x18, 8); + addKey("FF/Right", FastForward_Key, 0x18, 8); + addKey("VIDEO_PLUS+_PROGRAM", Unmapped_Key, 0x1D, 8); // obsolete + addKey("ENTER", Select_Key, 0x45, 8); + addKey("MENU", Menu_Key, 0x50, 8); + addKey("CANCEL", Exit_Key, 0x4A, 8); + addKey("INDEX", IndexSearch_Key, 0x14, 8); + addKey("ATR", AutoTracking_Key, 0x52, 8); + addKey("CLOCK/COUNTER", Unmapped_Key, 0x51, 8); + addKey("COUNTER_MEMORY", Unmapped_Key, 0x4B, 8); + addKey("COUNTER_RESET", Reset_Key, 0x4C, 8); + addKey("AUDIO_SELECT", Audio_Key, 0x0E, 8); +} + + +GoodmansDVD1::GoodmansDVD1( + unsigned int index) + : PIRKeysetMetaData( + "DVD Keyset 1", + Goodmans_Make, + index) +{ +} + + +void GoodmansDVD1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, false, true); + + setPreData(0x00, 8); + + addKey("PLAY", Play_Key, 0x47, 8); + addKey("STOP", Stop_Key, 0x04, 8); + addKey("PAUSE", Pause_Key, 0x05, 8); + addKey("FFWD", FastForward_Key, 0x4B, 8); + addKey("REV", Rewind_Key, 0x4A, 8); + addKey("REVPLAY", Unmapped_Key, 0x08, 8); + addKey("SLOW", Slow_Key, 0x09, 8); + addKey("SKIP_F", Next_Key, 0x4F, 8); + addKey("SKIP_R", Previous_Key, 0x4E, 8); + addKey("PAL_NTSC", Unmapped_Key, 0x0C, 8); + addKey("CLEAR", Clear_Key, 0x0D, 8); + addKey("RETURN", Exit_Key, 0x53, 8); + addKey("ZOOM", Zoom_Key, 0x10, 8); + addKey("TITLE", DiscTitle_Key, 0x11, 8); + addKey("SELECT", Select_Key, 0x57, 8); + addKey("DOWN", Down_Key, 0x14, 8); + addKey("MENU", DiscMenu_Key, 0x15, 8); + addKey("LEFT", Left_Key, 0x19, 8); + addKey("RIGHT", Right_Key, 0x5B, 8); + addKey("ENTER", Enter_Key, 0x18, 8); + addKey("UP", Up_Key, 0x1C, 8); + addKey("DISPLAY", Info_Key, 0x5F, 8); + addKey("SETUP", Menu_Key, 0x1D, 8); + addKey("GOTO", Unmapped_Key, 0x5D, 8); + addKey("PROG", Program_Key, 0x5C, 8); + addKey("0", Zero_Key, 0x1E, 8); + addKey("SUB_TITLE", Captions_Key, 0x1F, 8); + addKey("9", Nine_Key, 0x55, 8); + addKey("8", Eight_Key, 0x54, 8); + addKey("7", Seven_Key, 0x16, 8); + addKey("6", Six_Key, 0x49, 8); + addKey("5", Five_Key, 0x48, 8); + addKey("4", Four_Key, 0x0A, 8); + addKey("3", Three_Key, 0x51, 8); + addKey("2", Two_Key, 0x50, 8); + addKey("1", One_Key, 0x12, 8); + addKey("SUB_TITLE1", Unmapped_Key, 0x17, 8); + addKey("AUDIO", Audio_Key, 0x0B, 8); + addKey("L_R", Unmapped_Key, 0x13, 8); + addKey("REPEAT", Repeat_Key, 0x1A, 8); + addKey("A_B", RepeatAB_Key, 0x58, 8); + addKey("EJECT", Eject_Key, 0x59, 8); + addKey("ANGLE", Angle_Key, 0x1B, 8); +} + + +GoodmansAudio1::GoodmansAudio1( + unsigned int index) + : PIRKeysetMetaData( + "Audio Keyset 1", + Goodmans_Make, + index) +{ + addControlledDevice(Goodmans_Make, "MD-305", Audio_Device); +} + + +void GoodmansAudio1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, true, true); + + setPreData(0x6C87, 16); + + addKey("power", Power_Key, 0x0A, 8); + addKey("tape", TapeInput_Key, 0x4B, 8); + addKey("cd", CDInput_Key, 0x48, 8); + addKey("tuner", TunerInput_Key, 0x4A, 8); + addKey("aux", AuxInput_Key, 0x4D, 8); + addKey("play", Play_Key, 0x12, 8); + addKey("random", Random_Key, 0x13, 8); + addKey("stop", Stop_Key, 0x11, 8); + addKey("rew", Rewind_Key, 0x15, 8); + addKey("repeat", Repeat_Key, 0x16, 8); + addKey("ffwd", FastForward_Key, 0x14, 8); + addKey("space", Unmapped_Key, 0x17, 8); + addKey("display", Info_Key, 0x1A, 8); + addKey("mute", Mute_Key, 0x1D, 8); + addKey("vol-", VolumeDown_Key, 0x1F, 8); + addKey("vol+", VolumeUp_Key, 0x1E, 8); + addKey("tun+", ChannelUp_Key, 0x94, 8); + addKey("tun-", ChannelDown_Key, 0x95, 8); + addKey("mode", FMMode_Key, 0x4F, 8); // might be wrong + addKey("band", FM_Key, 0x43, 8); + addKey("program", Program_Key, 0x19, 8); + addKey("intro", Unmapped_Key, 0x18, 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); +} diff --git a/keysets/goodmans.h b/keysets/goodmans.h new file mode 100644 index 0000000..7664073 --- /dev/null +++ b/keysets/goodmans.h @@ -0,0 +1,48 @@ +#ifndef GOODMANS_H +#define GOODMANS_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class GoodmansSTB1: public PIRKeysetMetaData +{ +public: + GoodmansSTB1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +class GoodmansVCR1: public PIRKeysetMetaData +{ +public: + GoodmansVCR1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +class GoodmansDVD1: public PIRKeysetMetaData +{ +public: + GoodmansDVD1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +class GoodmansAudio1: public PIRKeysetMetaData +{ +public: + GoodmansAudio1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // GOODMANS_H diff --git a/keysets/nikon.cpp b/keysets/nikon.cpp new file mode 100644 index 0000000..2f257c6 --- /dev/null +++ b/keysets/nikon.cpp @@ -0,0 +1,36 @@ +#include "nikon.h" +#include "protocols/lircprotocol.h" + + +NikonDSLR1::NikonDSLR1( + unsigned int index) + : PIRKeysetMetaData( + "ML-L3 Remote Keyset", + Nikon_Make, + index) +{ + addControlledDevice(Nikon_Make, "D70s DSLR Camera", Other_Device); +} + + +void NikonDSLR1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + LIRCProtocol *lp = new LIRCProtocol( + guiObject, index, + 500, 1500, + 500, 3500, + 100000, true); + + threadableProtocol = lp; + lp->setHeaderPair(2100, 27800); + lp->setTrailerPulse(500); + + addKey("shutter", OpenShutter_Key, 0x1, 2); +} diff --git a/keysets/nikon.h b/keysets/nikon.h new file mode 100644 index 0000000..d11e3d1 --- /dev/null +++ b/keysets/nikon.h @@ -0,0 +1,18 @@ +#ifndef NIKON_H +#define NIKON_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class NikonDSLR1: public PIRKeysetMetaData +{ +public: + NikonDSLR1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // NIKON_H diff --git a/keysets/olympus.cpp b/keysets/olympus.cpp new file mode 100644 index 0000000..1716f54 --- /dev/null +++ b/keysets/olympus.cpp @@ -0,0 +1,29 @@ +#include "olympus.h" +#include "protocols/necprotocol.h" + +OlympusCamera1::OlympusCamera1( + unsigned int index) + : PIRKeysetMetaData( + "RM-2 Remote Keyset", + Olympus_Make, + index) +{ + addControlledDevice(Olympus_Make, "410 Digital", Other_Device); +} + + +void OlympusCamera1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new NECProtocol(guiObject, index, true, true); + + setPreData(0x3B86, 16); + + addKey("CAPTURE", OpenShutter_Key, 0x01, 8); +} diff --git a/keysets/olympus.h b/keysets/olympus.h new file mode 100644 index 0000000..35b3d8d --- /dev/null +++ b/keysets/olympus.h @@ -0,0 +1,18 @@ +#ifndef OLYMPUS_H +#define OLYMPUS_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class OlympusCamera1: public PIRKeysetMetaData +{ +public: + OlympusCamera1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // OLYMPUS_H diff --git a/keysets/pentax.cpp b/keysets/pentax.cpp new file mode 100644 index 0000000..889dc62 --- /dev/null +++ b/keysets/pentax.cpp @@ -0,0 +1,26 @@ +#include "pentax.h" +#include "protocols/rc5protocol.h" + +PentaxCamera1::PentaxCamera1( + unsigned int index) + : PIRKeysetMetaData( + "RC-F Remote Keyset", + Pentax_Make, + index) +{ +} + + +void PentaxCamera1::populateProtocol( + QObject *guiObject) +{ + if (threadableProtocol) + { + // Keyset already populated. + return; + } + + threadableProtocol = new RC5Protocol(guiObject, index); + + addKey("CAPTURE", OpenShutter_Key, 0x100C, 13); +} diff --git a/keysets/pentax.h b/keysets/pentax.h new file mode 100644 index 0000000..b8fab5e --- /dev/null +++ b/keysets/pentax.h @@ -0,0 +1,18 @@ +#ifndef PENTAX_H +#define PENTAX_H + +#include "pirkeysetmetadata.h" + +class QObject; + +class PentaxCamera1: public PIRKeysetMetaData +{ +public: + PentaxCamera1( + unsigned int index); + + virtual void populateProtocol( + QObject *guiObject); +}; + +#endif // PENTAX_H diff --git a/keysets/samsung.cpp b/keysets/samsung.cpp index da23518..56fb273 100644 --- a/keysets/samsung.cpp +++ b/keysets/samsung.cpp @@ -914,17 +914,46 @@ void SamsungAC2::populateProtocol( threadableProtocol = new ACProtocol(guiObject, index); - addKey("Power Off", PowerOff_Subkey, 0xC, 4); - addKey("Power On", PowerOn_Subkey, 0x0, 4); - - addKey("Cool Mode - Normal", CoolModeNormal_Subkey, 0x7, 3); - addKey("Cool Mode - Turbo", CoolModeTurbo_Subkey, 0x1, 3); - addKey("Cool Mode - Far", CoolModeFar_Subkey, 0x2, 3); - - addKey("Deflector L/R Off", DeflectorLROff_Subkey, 0x0, 1); - addKey("Deflector L/R On", DeflectorLROn_Subkey, 0x1, 1); - addKey("Deflector U/D Off", DeflectorUDOff_Subkey, 0x0, 1); - addKey("Deflector U/D On", DeflectorUDOn_Subkey, 0x1, 1); + addKey("Power Off", PowerOff_Subkey, 0x0, 4); + addKey("Power On", PowerOn_Subkey, 0xC, 4); + + addKey("Cool Mode - Normal", CoolModeNormal_Subkey, 0x0, 3); + addKey("Cool Mode - Turbo", CoolModeTurbo_Subkey, 0x3, 3); + addKey("Cool Mode - Far", CoolModeFar_Subkey, 0x6, 3); + + addKey("Deflector L/R Off", DeflectorLROff_Subkey, 0x1, 1); + addKey("Deflector L/R On", DeflectorLROn_Subkey, 0x0, 1); + addKey("Deflector U/D Off", DeflectorUDOff_Subkey, 0x1, 1); + addKey("Deflector U/D On", DeflectorUDOn_Subkey, 0x0, 1); + + // Sixteen temperature settings; make this a straight-up variable? + // It may be that only 18-30 are supported. +// addKey("Temperature 16", Temp16_Subkey, 0x0, 8); +// addKey("Temperature 17", Temp16_Subkey, 0x1, 8); + addKey("Temperature 18", Temp16_Subkey, 0x2, 8); + addKey("Temperature 19", Temp16_Subkey, 0x3, 8); + addKey("Temperature 20", Temp16_Subkey, 0x4, 8); + addKey("Temperature 21", Temp16_Subkey, 0x5, 8); + addKey("Temperature 22", Temp16_Subkey, 0x6, 8); + addKey("Temperature 23", Temp16_Subkey, 0x7, 8); + addKey("Temperature 24", Temp16_Subkey, 0x8, 8); + addKey("Temperature 25", Temp16_Subkey, 0x9, 8); + addKey("Temperature 26", Temp16_Subkey, 0xA, 8); + addKey("Temperature 27", Temp16_Subkey, 0xB, 8); + addKey("Temperature 28", Temp16_Subkey, 0xC, 8); + addKey("Temperature 29", Temp16_Subkey, 0xD, 8); + addKey("Temperature 30", Temp16_Subkey, 0xE, 8); +// addKey("Temperature 31", Temp31_Subkey, 0xF, 8); + + addKey("Fan - Auto", FanSpeedAuto_Subkey, 0x0, 3); + addKey("Fan - Low", FanSpeedLow_Subkey, 0x2, 3); + addKey("Fan - Medium", FanSpeedMed_Subkey, 0x4, 3); + addKey("Fan - High", FanSpeedHigh_Subkey, 0x6, 3); + + addKey("Mode - auto", ModeAuto_Subkey, 0x0, 4); + addKey("Mode - cool", ModeCool_Subkey, 0x1, 4); + addKey("Mode - DeHumidify", ModeDehumidify_Subkey, 0x2, 4); + addKey("Mode - fan", ModeFan_Subkey, 0x03, 4); } */ diff --git a/mainwindow.cpp b/mainwindow.cpp index d55e661..32d99aa 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -285,6 +285,12 @@ QString MainWindow::getCurrentName() } +QString MainWindow::getCurrentFullName() +{ + return selectKeysetForm->getKeysetName(); +} + + void MainWindow::receivedExternalWarning( const char *warning) { @@ -349,6 +355,9 @@ void MainWindow::keysetSelectionChanged( // We're already on that keyset, so nothing to do: return; } + + // Clean up and remove the current keyset: + myKeysets->clearKeyset(currentKeyset); currentKeyset = kwi->getID(); @@ -586,3 +595,15 @@ void MainWindow::setupTabs( { myPanels->setupTabs(name); } + + +bool MainWindow::selectNextKeyset() +{ + return selectKeysetForm->selectNextKeyset(); +} + + +bool MainWindow::selectPrevKeyset() +{ + return selectKeysetForm->selectPrevKeyset(); +} diff --git a/mainwindow.h b/mainwindow.h index ba00799..2eadcde 100644 --- a/mainwindow.h +++ b/mainwindow.h @@ -69,6 +69,7 @@ public: QString getCurrentMake(); QString getCurrentName(); + QString getCurrentFullName(); unsigned int getCurrentKeyset() { @@ -84,6 +85,9 @@ public: QString label); void setupTabs(PIRTabBarName name); + bool selectNextKeyset(); + bool selectPrevKeyset(); + signals: void buttonPressed( unsigned int keysetID, diff --git a/pierogi.pro b/pierogi.pro index 4fb68bf..16dd093 100644 --- a/pierogi.pro +++ b/pierogi.pro @@ -204,7 +204,17 @@ SOURCES += main.cpp mainwindow.cpp \ keysets/lifetec.cpp \ keysets/irobot.cpp \ protocols/irobotprotocol.cpp \ - forms/pirroombaform.cpp + forms/pirroombaform.cpp \ + forms/pirstatefulacform.cpp \ + forms/pircameraform.cpp \ + keysets/nikon.cpp \ + keysets/olympus.cpp \ + keysets/pentax.cpp \ + forms/pirpowersearchform.cpp \ + keysets/deutschetelekom.cpp \ + keysets/goodmans.cpp \ + keysets/emtec.cpp \ + protocols/tdcprotocol.cpp HEADERS += mainwindow.h \ pirkeynames.h \ pirmakenames.h \ @@ -384,7 +394,17 @@ HEADERS += mainwindow.h \ keysets/lifetec.h \ keysets/irobot.h \ protocols/irobotprotocol.h \ - forms/pirroombaform.h + forms/pirroombaform.h \ + forms/pirstatefulacform.h \ + forms/pircameraform.h \ + keysets/nikon.h \ + keysets/olympus.h \ + keysets/pentax.h \ + forms/pirpowersearchform.h \ + keysets/deutschetelekom.h \ + keysets/goodmans.h \ + keysets/emtec.h \ + protocols/tdcprotocol.h FORMS += mainwindow.ui \ pirdocumentationform.ui \ piraboutform.ui \ @@ -412,7 +432,10 @@ FORMS += mainwindow.ui \ forms/pirvideodiscform.ui \ forms/piraudiodeviceform.ui \ dialogs/pirfavoritesdialog.ui \ - forms/pirroombaform.ui + forms/pirroombaform.ui \ + forms/pirstatefulacform.ui \ + forms/pircameraform.ui \ + forms/pirpowersearchform.ui # Please do not modify the following two lines. Required for deployment. include(deployment.pri) diff --git a/pierogi.pro.user b/pierogi.pro.user index 7a9000d..5123665 100644 --- a/pierogi.pro.user +++ b/pierogi.pro.user @@ -1,6 +1,6 @@ - + ProjectExplorer.Project.ActiveTarget @@ -78,8 +78,8 @@ dpkg-buildpackage -sa -S -uc -us /Users/john/QtSDK/Maemo/4.6.2/bin/mad - true - /Users/john/Develop/n900/pierogi-1.1.6 + false + /Users/john/Develop/n900/pierogi-1.1.7 Custom Process Step ProjectExplorer.ProcessStep @@ -185,6 +185,7 @@ /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_1_4_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_0_0_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_5_1_armel.deb + /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_1_7_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_1_3_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_1_1_5_armel.deb /Users/john/Develop/n900/pierogi-build-maemo-Qt_for_Fremantle_PR1_3_Devices__Qt_SDK__Release/pierogi_0_6_1_armel.deb @@ -237,6 +238,7 @@ 192.168.0.15 192.168.0.15 192.168.0.15 + 192.168.0.15 localhost 192.168.0.15 192.168.0.15 @@ -288,11 +290,13 @@ + 2012-01-19T22:18:07 2012-02-29T10:48:05 2012-02-06T17:22:16 + 2012-09-06T16:32:59 2012-03-08T23:20:27 2012-09-02T20:43:12 2012-02-12T23:10:44 @@ -307,7 +311,7 @@ 2012-01-17T13:21:05 2012-01-23T09:47:37 2012-02-03T10:04:34 - 2012-09-03T17:43:57 + 2012-09-03T18:20:27 2012-03-04T19:56:48 2012-01-01T15:35:35 2012-03-12T20:02:57 diff --git a/pirkeynames.h b/pirkeynames.h index 16abe63..308cda1 100644 --- a/pirkeynames.h +++ b/pirkeynames.h @@ -227,6 +227,10 @@ enum PIRKeyName{ RobotMax_Key, RobotClean_Key, + // Camera controls: + OpenShutter_Key, + DelayedOpenShutter_Key, + // Other keys: Captions_Key, Info_Key, diff --git a/pirkeysetmanager.cpp b/pirkeysetmanager.cpp index 817594c..4d9eaf6 100644 --- a/pirkeysetmanager.cpp +++ b/pirkeysetmanager.cpp @@ -27,6 +27,7 @@ #include "keysets/daewoo.h" #include "keysets/dell.h" #include "keysets/denon.h" +#include "keysets/deutschetelekom.h" #include "keysets/digitalstream.h" #include "keysets/directv.h" #include "keysets/dish.h" @@ -36,12 +37,14 @@ #include "keysets/ei.h" #include "keysets/elgato.h" #include "keysets/emerson.h" +#include "keysets/emtec.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/goodmans.h" #include "keysets/grundig.h" #include "keysets/haier.h" #include "keysets/harmankardon.h" @@ -69,12 +72,15 @@ #include "keysets/mitsubishi.h" #include "keysets/motorola.h" #include "keysets/nad.h" +#include "keysets/nikon.h" #include "keysets/nokia.h" #include "keysets/octagon.h" +#include "keysets/olympus.h" #include "keysets/onida.h" #include "keysets/onkyo.h" #include "keysets/orion.h" #include "keysets/panasonic.h" +#include "keysets/pentax.h" #include "keysets/philco.h" #include "keysets/philips.h" #include "keysets/pinnacle.h" @@ -238,6 +244,8 @@ PIRKeysetManager::PIRKeysetManager() setupKeyset(new DellRemote1(++counter)); + setupKeyset(new DeutscheTelekomSTB1(++counter)); + setupKeyset(new DigitalStreamReceiver(++counter)); setupKeyset(new DirectvReceiver1(++counter)); @@ -285,6 +293,9 @@ PIRKeysetManager::PIRKeysetManager() setupKeyset(new EmersonTV1(++counter)); setupKeyset(new EmersonDVD1(++counter)); + setupKeyset(new EmtecSTB1(++counter)); + setupKeyset(new EmtecSTB2(++counter)); + setupKeyset(new EpsonProjector1(++counter)); setupKeyset(new EpsonProjector2(++counter)); @@ -306,6 +317,11 @@ PIRKeysetManager::PIRKeysetManager() setupKeyset(new GoldStarVCR1c(++counter)); setupKeyset(new GoldStarCD1(++counter)); + setupKeyset(new GoodmansSTB1(++counter)); + setupKeyset(new GoodmansVCR1(++counter)); + setupKeyset(new GoodmansDVD1(++counter)); + setupKeyset(new GoodmansAudio1(++counter)); + setupKeyset(new GrundigSat1(++counter)); setupKeyset(new GrundigSat2(++counter)); setupKeyset(new GrundigSat3(++counter)); @@ -466,12 +482,16 @@ PIRKeysetManager::PIRKeysetManager() setupKeyset(new NADCD2(++counter)); setupKeyset(new NADTape1(++counter)); + setupKeyset(new NikonDSLR1(++counter)); + setupKeyset(new NokiaGenericVCR(++counter)); setupKeyset(new OctagonSat1(++counter)); setupKeyset(new OctagonSat1a(++counter)); setupKeyset(new OctagonSat2(++counter)); + setupKeyset(new OlympusCamera1(++counter)); + setupKeyset(new OnidaTV1(++counter)); setupKeyset(new OnidaDVD1(++counter)); @@ -508,6 +528,8 @@ PIRKeysetManager::PIRKeysetManager() setupKeyset(new PanasonicAudio2a(++counter)); setupKeyset(new PanasonicAC1(++counter)); + setupKeyset(new PentaxCamera1(++counter)); + setupKeyset(new PhilcoTV(++counter)); setupKeyset(new PhilipsTV1(++counter)); @@ -910,6 +932,20 @@ void PIRKeysetManager::populateKeyset( } +void PIRKeysetManager::clearKeyset( + unsigned int keysetID) +{ + PIRKeysetCollection::iterator i = keysetsInfo.find(keysetID); + + if (i == keysetsInfo.end()) + { + return; // should throw error or something + } + + i->second->clearProtocol(); +} + + void PIRKeysetManager::setupKeyset( PIRKeysetMetaData *keyset) { diff --git a/pirkeysetmanager.h b/pirkeysetmanager.h index 98f5ab7..4b6527c 100644 --- a/pirkeysetmanager.h +++ b/pirkeysetmanager.h @@ -65,6 +65,9 @@ public: QObject *guiObject, unsigned int keysetID); + void clearKeyset( + unsigned int keysetID); + void populateFavorites( PIRFavoritesDialog *favoritesDialog, PIRSelectKeysetForm *keysetForm); diff --git a/pirkeysetmetadata.cpp b/pirkeysetmetadata.cpp index 71b2c33..dd1574f 100644 --- a/pirkeysetmetadata.cpp +++ b/pirkeysetmetadata.cpp @@ -292,3 +292,13 @@ void PIRKeysetMetaData::setKeysetName( { keysetName = n; } + + +void PIRKeysetMetaData::clearProtocol() +{ + if (threadableProtocol) + { + delete threadableProtocol; + threadableProtocol = 0; + } +} diff --git a/pirkeysetmetadata.h b/pirkeysetmetadata.h index e8a2b28..401174a 100644 --- a/pirkeysetmetadata.h +++ b/pirkeysetmetadata.h @@ -39,6 +39,8 @@ public: virtual void populateProtocol( QObject *guiObject) = 0; + void clearProtocol(); + void moveToThread( QThread *thread); diff --git a/pirmakenames.cpp b/pirmakenames.cpp index 1fa1dec..5f3ba5c 100644 --- a/pirmakenames.cpp +++ b/pirmakenames.cpp @@ -25,6 +25,7 @@ PIRMakeMgr::PIRMakeMgr() makes[Daewoo_Make] = "Daewoo"; makes[Dell_Make] = "Dell"; makes[Denon_Make] = "Denon"; + makes[DeutscheTelekom_Make] = "Deutsche Telekom"; makes[DigitalStream_Make] = "Digital Stream"; makes[Directv_Make] = "DirecTV"; makes[Dish_Make] = "Dish"; @@ -34,12 +35,14 @@ PIRMakeMgr::PIRMakeMgr() makes[Ei_Make] = "Ei"; makes[Elgato_Make] = "Elgato"; makes[Emerson_Make] = "Emerson"; + makes[Emtec_Make] = "Emtec"; 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[Goodmans_Make] = "Goodmans"; makes[Grundig_Make] = "Grundig"; makes[Haier_Make] = "Haier"; makes[HarmanKardon_Make] = "Harman/Kardon"; @@ -67,12 +70,15 @@ PIRMakeMgr::PIRMakeMgr() makes[Mitsubishi_Make] = "Mitsubishi"; makes[Motorola_Make] = "Motorola"; makes[NAD_Make] = "NAD"; + makes[Nikon_Make] = "Nikon"; makes[Nokia_Make] = "Nokia"; makes[Octagon_Make] = "Octagon"; + makes[Olympus_Make] = "Olympus"; makes[Onida_Make] = "Onida"; makes[Onkyo_Make] = "Onkyo"; makes[Orion_Make] = "Orion"; makes[Panasonic_Make] = "Panasonic"; + makes[Pentax_Make] = "Pentax"; makes[Philco_Make] = "Philco"; makes[Philips_Make] = "Philips"; makes[Pinnacle_Make] = "Pinnacle Systems"; diff --git a/pirmakenames.h b/pirmakenames.h index 3df98e1..821f67e 100644 --- a/pirmakenames.h +++ b/pirmakenames.h @@ -26,6 +26,7 @@ enum PIRMakeName{ Daewoo_Make, Dell_Make, Denon_Make, + DeutscheTelekom_Make, DigitalStream_Make, Directv_Make, Dish_Make, @@ -35,12 +36,14 @@ enum PIRMakeName{ Ei_Make, Elgato_Make, Emerson_Make, + Emtec_Make, Epson_Make, Fortec_Make, Foxtel_Make, Gadmei_Make, Genius_Make, GoldStar_Make, + Goodmans_Make, Grundig_Make, Haier_Make, HarmanKardon_Make, @@ -68,12 +71,15 @@ enum PIRMakeName{ Mitsubishi_Make, Motorola_Make, NAD_Make, + Nikon_Make, Nokia_Make, Octagon_Make, + Olympus_Make, Onida_Make, Onkyo_Make, Orion_Make, Panasonic_Make, + Pentax_Make, Philco_Make, Philips_Make, Pinnacle_Make, diff --git a/pirpanelmanager.cpp b/pirpanelmanager.cpp index 0511bfc..c8c64b2 100644 --- a/pirpanelmanager.cpp +++ b/pirpanelmanager.cpp @@ -13,7 +13,9 @@ #include "forms/piradjustform.h" #include "forms/pirairconditionerform.h" #include "forms/piraudiodeviceform.h" +#include "forms/pircameraform.h" #include "forms/pirroombaform.h" +#include "forms/pirpowersearchform.h" #include "mainwindow.h" @@ -40,7 +42,9 @@ PIRPanelManager::PIRPanelManager( adjustForm(0), acForm(0), audioDeviceForm(0), + cameraForm(0), roombaForm(0), + powerSearchForm(0), altMainPanelFlag(false), currentTabsName(Universal_Tabs), mainWindow(mw) @@ -88,9 +92,15 @@ PIRPanelManager::PIRPanelManager( shortPanelNames[Audio_Panel] = "Audio"; longPanelNames[Audio_Panel] = "Audio Device Panel - various audio related buttons"; + shortPanelNames[Camera_Panel] = "Camera"; + longPanelNames[Camera_Panel] = + "Camera Panel - simple shutter controls"; shortPanelNames[Roomba_Panel] = "Roomba"; longPanelNames[Roomba_Panel] = "Roomba Panel - robotic vacuum cleaner controls"; + shortPanelNames[PowerSearch_Panel] = "Keyset Search"; + longPanelNames[PowerSearch_Panel] = + "Keyset Search Panel - execute power button in each keyset"; mainForm = new PIRMainForm(mainWindow); panels[Main_Panel] = mainForm; @@ -131,9 +141,15 @@ PIRPanelManager::PIRPanelManager( audioDeviceForm = new PIRAudioDeviceForm(mainWindow); panels[Audio_Panel] = audioDeviceForm; + cameraForm = new PIRCameraForm(mainWindow); + panels[Camera_Panel] = cameraForm; + roombaForm = new PIRRoombaForm(mainWindow); panels[Roomba_Panel] = roombaForm; + powerSearchForm = new PIRPowerSearchForm(mainWindow); + panels[PowerSearch_Panel] = powerSearchForm; + // Set up the panel collections: PIRPanelNameList pset; @@ -184,10 +200,20 @@ PIRPanelManager::PIRPanelManager( pset.push_back(Keypad_Panel); tabLists[Record_Tabs] = pset; + // The camera control collection: + pset.clear(); + pset.push_back(Camera_Panel); + tabLists[Camera_Tabs] = pset; + // The Roomba collection: pset.clear(); pset.push_back(Roomba_Panel); tabLists[Roomba_Tabs] = pset; + + // The Power Search collection: + pset.clear(); + pset.push_back(PowerSearch_Panel); + tabLists[PowerSearch_Tabs] = pset; } @@ -265,7 +291,11 @@ void PIRPanelManager::commonEnableButtons( adjustForm->enableButtons(keyset, id); acForm->enableButtons(keyset, id); audioDeviceForm->enableButtons(keyset, id); + cameraForm->enableButtons(keyset, id); roombaForm->enableButtons(keyset, id); + + // Also, set the label in the power search form: + powerSearchForm->setKeysetName(mainWindow->getCurrentFullName()); } diff --git a/pirpanelmanager.h b/pirpanelmanager.h index c2cb046..73b4a5d 100644 --- a/pirpanelmanager.h +++ b/pirpanelmanager.h @@ -16,7 +16,9 @@ class PIRInputForm; class PIRAdjustForm; class PIRAirConditionerForm; class PIRAudioDeviceForm; +class PIRCameraForm; class PIRRoombaForm; +class PIRPowerSearchForm; class PIRKeysetWidgetItem; class PIRKeysetManager; @@ -84,7 +86,9 @@ private: PIRAdjustForm *adjustForm; PIRAirConditionerForm *acForm; PIRAudioDeviceForm *audioDeviceForm; + PIRCameraForm *cameraForm; PIRRoombaForm *roombaForm; + PIRPowerSearchForm *powerSearchForm; PIRPanelDisplayNameCollection shortPanelNames; PIRPanelDisplayNameCollection longPanelNames; diff --git a/pirpanelnames.h b/pirpanelnames.h index 967913c..ff65131 100644 --- a/pirpanelnames.h +++ b/pirpanelnames.h @@ -16,7 +16,9 @@ enum PIRPanelName Adjust_Panel, AC_Panel, Audio_Panel, + Camera_Panel, Roomba_Panel, + PowerSearch_Panel, Last_Panel_Marker // Used when traversing this enumeration. }; @@ -31,7 +33,9 @@ enum PIRTabBarName Audio_Tabs, AC_Tabs, Record_Tabs, - Roomba_Tabs + Camera_Tabs, + Roomba_Tabs, + PowerSearch_Tabs }; #endif // PIRPANELNAMES_H diff --git a/pirselectdeviceform.cpp b/pirselectdeviceform.cpp index 6639c79..5520be1 100644 --- a/pirselectdeviceform.cpp +++ b/pirselectdeviceform.cpp @@ -16,6 +16,10 @@ PIRSelectDeviceForm::PIRSelectDeviceForm( { ui->setupUi(this); + // Make sure the user can only select one device at a time: + ui->deviceListWidget->setSelectionMode( + QAbstractItemView::SingleSelection); + // Don't want to start with the line editor visible: ui->searchStringLineEdit->hide(); ui->searchStringLineEdit->lower(); diff --git a/pirselectkeysetform.cpp b/pirselectkeysetform.cpp index 8d6f403..e191da9 100644 --- a/pirselectkeysetform.cpp +++ b/pirselectkeysetform.cpp @@ -25,6 +25,10 @@ PIRSelectKeysetForm::PIRSelectKeysetForm( { ui->setupUi(this); + // Make sure the user can only select one keyset at a time: + ui->keysetListWidget->setSelectionMode( + QAbstractItemView::SingleSelection); + // Don't want to start with the line editor visible: ui->searchStringLineEdit->hide(); ui->searchStringLineEdit->lower(); @@ -96,6 +100,63 @@ QListWidget *PIRSelectKeysetForm::getKeysetListWidget() } +bool PIRSelectKeysetForm::selectNextKeyset() +{ + int currentRow = ui->keysetListWidget->currentRow(); + + // If we're at the end of the list, give up: + if (currentRow >= (ui->keysetListWidget->count() -1)) + { + return false; + } + + ui->keysetListWidget->setCurrentRow( + currentRow + 1, + QItemSelectionModel::ClearAndSelect); + + mainWindow->keysetSelectionChanged( + ui->keysetListWidget->currentItem()); + + return true; +} + + +bool PIRSelectKeysetForm::selectPrevKeyset() +{ + int currentRow = ui->keysetListWidget->currentRow(); + + // If we're at the beginning of the list, give up: + if (currentRow <= 0) + { + return false; + } + + ui->keysetListWidget->setCurrentRow( + currentRow - 1, + QItemSelectionModel::ClearAndSelect); + + mainWindow->keysetSelectionChanged( + ui->keysetListWidget->currentItem()); + + return true; +} + + +QString PIRSelectKeysetForm::getKeysetName() +{ + QListWidgetItem *item = ui->keysetListWidget->currentItem(); + + if (item) + { + return item->text(); + } + else + { + return ""; + } +} + + void PIRSelectKeysetForm::keyPressEvent( QKeyEvent *event) { diff --git a/pirselectkeysetform.h b/pirselectkeysetform.h index 58609f0..5b94b02 100644 --- a/pirselectkeysetform.h +++ b/pirselectkeysetform.h @@ -42,6 +42,11 @@ public: // This is a bit of a hack, but not sure how to create a connection otherwise. QListWidget *getKeysetListWidget(); + bool selectNextKeyset(); + bool selectPrevKeyset(); + + QString getKeysetName(); + protected: void keyPressEvent( QKeyEvent *event); diff --git a/pirselectkeysetform.ui b/pirselectkeysetform.ui index 7b07973..fffdacb 100644 --- a/pirselectkeysetform.ui +++ b/pirselectkeysetform.ui @@ -17,6 +17,9 @@ Select Keyset + + 8 + diff --git a/protocols/aiwaprotocol.cpp b/protocols/aiwaprotocol.cpp index c4dcf6d..1a7f60e 100644 --- a/protocols/aiwaprotocol.cpp +++ b/protocols/aiwaprotocol.cpp @@ -55,8 +55,11 @@ void AiwaProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -88,23 +91,26 @@ void AiwaProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/boseprotocol.cpp b/protocols/boseprotocol.cpp index 63e1658..72dfe16 100644 --- a/protocols/boseprotocol.cpp +++ b/protocols/boseprotocol.cpp @@ -49,8 +49,11 @@ void BoseProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -74,23 +77,26 @@ void BoseProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/daewooprotocol.cpp b/protocols/daewooprotocol.cpp index 24c71ff..9c02a87 100644 --- a/protocols/daewooprotocol.cpp +++ b/protocols/daewooprotocol.cpp @@ -56,8 +56,11 @@ void DaewooProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -81,23 +84,26 @@ void DaewooProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/directvprotocol.cpp b/protocols/directvprotocol.cpp index f14496f..88bcf1d 100644 --- a/protocols/directvprotocol.cpp +++ b/protocols/directvprotocol.cpp @@ -79,8 +79,11 @@ void DirectvProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -118,23 +121,26 @@ void DirectvProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/dishprotocol.cpp b/protocols/dishprotocol.cpp index d192031..91b992c 100644 --- a/protocols/dishprotocol.cpp +++ b/protocols/dishprotocol.cpp @@ -56,8 +56,11 @@ void DishProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -89,23 +92,26 @@ void DishProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/giprotocol.cpp b/protocols/giprotocol.cpp index feac5e1..f4fd620 100644 --- a/protocols/giprotocol.cpp +++ b/protocols/giprotocol.cpp @@ -52,8 +52,11 @@ void GIProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -85,23 +88,26 @@ void GIProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/irobotprotocol.cpp b/protocols/irobotprotocol.cpp index c2ac7ab..244b045 100644 --- a/protocols/irobotprotocol.cpp +++ b/protocols/irobotprotocol.cpp @@ -51,8 +51,11 @@ void IRobotProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -82,23 +85,26 @@ void IRobotProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/jvcprotocol.cpp b/protocols/jvcprotocol.cpp index d94de00..74f5b65 100644 --- a/protocols/jvcprotocol.cpp +++ b/protocols/jvcprotocol.cpp @@ -52,8 +52,11 @@ void JVCProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -86,23 +89,26 @@ void JVCProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/kaseikyoprotocol.cpp b/protocols/kaseikyoprotocol.cpp index 1fe73bb..f1437ca 100644 --- a/protocols/kaseikyoprotocol.cpp +++ b/protocols/kaseikyoprotocol.cpp @@ -52,8 +52,11 @@ void KaseikyoProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -77,23 +80,26 @@ void KaseikyoProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/kathreinprotocol.cpp b/protocols/kathreinprotocol.cpp index 1d29779..35208f3 100644 --- a/protocols/kathreinprotocol.cpp +++ b/protocols/kathreinprotocol.cpp @@ -51,8 +51,11 @@ void KathreinProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -83,23 +86,26 @@ void KathreinProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/lircprotocol.cpp b/protocols/lircprotocol.cpp index 1d08726..549c323 100644 --- a/protocols/lircprotocol.cpp +++ b/protocols/lircprotocol.cpp @@ -90,8 +90,11 @@ void LIRCProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -128,23 +131,26 @@ void LIRCProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/mceprotocol.cpp b/protocols/mceprotocol.cpp index 9096c7e..b6d91b7 100644 --- a/protocols/mceprotocol.cpp +++ b/protocols/mceprotocol.cpp @@ -58,8 +58,11 @@ void MCEProtocol::startSendingCommand( // Sanity check: if (i == keycodes.end()) { - std::string s = "Tried to send a non-existent command.\n"; - throw PIRException(s); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); @@ -141,21 +144,24 @@ void MCEProtocol::startSendingCommand( if (checkRepeatFlag()) { // Yes, we can now quit repeating: + break; +/* ++keypressCount; QMutexLocker ciflocker(&commandIFMutex); commandInFlight = false; return; +*/ } } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/necprotocol.cpp b/protocols/necprotocol.cpp index 9aaffbd..e2d5961 100644 --- a/protocols/necprotocol.cpp +++ b/protocols/necprotocol.cpp @@ -64,8 +64,11 @@ void NECProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -98,23 +101,26 @@ void NECProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/necxprotocol.cpp b/protocols/necxprotocol.cpp index 1ca40e4..7989c6e 100644 --- a/protocols/necxprotocol.cpp +++ b/protocols/necxprotocol.cpp @@ -57,8 +57,11 @@ void NECXProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -91,23 +94,26 @@ void NECXProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/nokia32protocol.cpp b/protocols/nokia32protocol.cpp index 63c36ad..98b1aaf 100644 --- a/protocols/nokia32protocol.cpp +++ b/protocols/nokia32protocol.cpp @@ -60,8 +60,11 @@ void Nokia32Protocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -85,25 +88,28 @@ void Nokia32Protocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* + ++keypressCount; QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; - ++keypressCount; return; +*/ } } ++repeatCount; } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; - ++keypressCount; } diff --git a/protocols/paceprotocol.cpp b/protocols/paceprotocol.cpp index 3129917..03a4f30 100644 --- a/protocols/paceprotocol.cpp +++ b/protocols/paceprotocol.cpp @@ -52,8 +52,11 @@ void PaceProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -77,25 +80,28 @@ void PaceProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* ++keypressCount; QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/panasonicoldprotocol.cpp b/protocols/panasonicoldprotocol.cpp index 17d037b..108acd6 100644 --- a/protocols/panasonicoldprotocol.cpp +++ b/protocols/panasonicoldprotocol.cpp @@ -49,8 +49,11 @@ void PanasonicOldProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -74,23 +77,26 @@ void PanasonicOldProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/pioneerprotocol.cpp b/protocols/pioneerprotocol.cpp index d2cb312..b6b74f6 100644 --- a/protocols/pioneerprotocol.cpp +++ b/protocols/pioneerprotocol.cpp @@ -55,8 +55,11 @@ void PioneerProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -91,23 +94,26 @@ void PioneerProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/pirprotocol.cpp b/protocols/pirprotocol.cpp index 4a78eac..2203b4d 100644 --- a/protocols/pirprotocol.cpp +++ b/protocols/pirprotocol.cpp @@ -12,9 +12,9 @@ extern bool stopRepeatingFlag; extern QMutex stopRepeatingMutex; -// Total of all running commands -extern bool commandInFlight; -extern QMutex commandIFMutex; +// Check if a command is running: +//extern bool commandInFlight; +//extern QMutex commandIFMutex; // From what I understand (mostly from reading LIRC config files), NEC // protocol based remotes mostly use a frequency of 38000 units and a diff --git a/protocols/protonprotocol.cpp b/protocols/protonprotocol.cpp index c1f956b..2f4a2a8 100644 --- a/protocols/protonprotocol.cpp +++ b/protocols/protonprotocol.cpp @@ -51,8 +51,11 @@ void ProtonProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -76,23 +79,26 @@ void ProtonProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/rc5protocol.cpp b/protocols/rc5protocol.cpp index 36322a1..deffdd7 100644 --- a/protocols/rc5protocol.cpp +++ b/protocols/rc5protocol.cpp @@ -52,8 +52,11 @@ void RC5Protocol::startSendingCommand( // Sanity check, make sure command exists first: if (i == keycodes.end()) { - std::string s = "Tried to send a non-existent command.\n"; - throw PIRException(s); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // Construct the object that communicates with the device driver: @@ -104,24 +107,27 @@ void RC5Protocol::startSendingCommand( // Have we been told to stop yet? if (checkRepeatFlag()) { + break; +/* // Ok, then we can quit now: ++keypressCount; QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } ++repeatCount; } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } @@ -162,7 +168,7 @@ int RC5Protocol::pushControlBits( // Simply push the rest of the bits: while (i != preData.end()) { - pushBit(*i, rx51device); + duration += pushBit(*i, rx51device); ++i; } @@ -226,7 +232,7 @@ int RC5Protocol::pushNonStandardRC5( // Simply push the rest of the bits: while (i != pkb.firstCode.end()) { - pushBit(*i, rx51device); + duration += pushBit(*i, rx51device); ++i; } diff --git a/protocols/rc6protocol.cpp b/protocols/rc6protocol.cpp index bdbccfe..0c901c0 100644 --- a/protocols/rc6protocol.cpp +++ b/protocols/rc6protocol.cpp @@ -46,8 +46,11 @@ void RC6Protocol::startSendingCommand( // Sanity check: if (i == keycodes.end()) { - std::string s = "Tried to send a non-existent command.\n"; - throw PIRException(s); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); @@ -138,22 +141,25 @@ void RC6Protocol::startSendingCommand( // Have we been told to stop yet? if (checkRepeatFlag()) { + break; +/* // Yes, we can now quit repeating: ++keypressCount; QMutexLocker ciflocker(&commandIFMutex); commandInFlight = false; return; +*/ } } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/rc6skyprotocol.cpp b/protocols/rc6skyprotocol.cpp index 9b376af..739b109 100644 --- a/protocols/rc6skyprotocol.cpp +++ b/protocols/rc6skyprotocol.cpp @@ -54,8 +54,11 @@ void RC6SkyProtocol::startSendingCommand( // Sanity check: if (i == keycodes.end()) { - std::string s = "Tried to send a non-existent command.\n"; - throw PIRException(s); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); @@ -125,21 +128,24 @@ void RC6SkyProtocol::startSendingCommand( if (checkRepeatFlag()) { // Yes, we can now quit repeating: + break; +/* ++keypressCount; QMutexLocker ciflocker(&commandIFMutex); commandInFlight = false; return; +*/ } } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/rcaprotocol.cpp b/protocols/rcaprotocol.cpp index bd96c7c..32b8337 100644 --- a/protocols/rcaprotocol.cpp +++ b/protocols/rcaprotocol.cpp @@ -62,8 +62,11 @@ void RCAProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -87,23 +90,26 @@ void RCAProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/sharpprotocol.cpp b/protocols/sharpprotocol.cpp index 20eddf3..52ace57 100644 --- a/protocols/sharpprotocol.cpp +++ b/protocols/sharpprotocol.cpp @@ -58,8 +58,11 @@ void SharpProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -92,23 +95,26 @@ void SharpProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/sircprotocol.cpp b/protocols/sircprotocol.cpp index e16fdd7..a58e4cc 100644 --- a/protocols/sircprotocol.cpp +++ b/protocols/sircprotocol.cpp @@ -52,8 +52,11 @@ void SIRCProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -78,23 +81,26 @@ void SIRCProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/tdcprotocol.cpp b/protocols/tdcprotocol.cpp new file mode 100644 index 0000000..1707137 --- /dev/null +++ b/protocols/tdcprotocol.cpp @@ -0,0 +1,213 @@ +#include "tdcprotocol.h" + +#include "pirrx51hardware.h" + +#include "pirexception.h" + +#include +extern bool commandInFlight; +extern QMutex commandIFMutex; + + +// There are apparently two forms of TDC protocol; I'm just focussing on one +// for now. As with the Philips protocols, this one is "shift encoded". +// The unit biphase pulse length is 315 usec; each command contains 18 bits, +// and is followed by an 89000 usec space. The entire pulse train is +// re-sent when repeating. The carrier frequency is 38 kHz (the Pierogi +// default value). + +// I'm going to count both the "device" and "subdevice" bits as pre-data. +// (Both are 5 bits in length.) This may need to be changed... + +TDCProtocol::TDCProtocol( + QObject *guiObject, + unsigned int index, + unsigned int deviceBits, + unsigned int subdeviceBits) + : PIRProtocol(guiObject, index, 89000, false), + biphaseUnit(315), + buffer(0) +{ + // Bit of a hack to get the device and subdevice data in: + setPreData(deviceBits, 5); + setPostData(subdeviceBits, 5); +} + + +void TDCProtocol::startSendingCommand( + unsigned int threadableID, + PIRKeyName command) +{ + // Catch any exceptions here before they go up any further: + try + { + // Check that this command is meant for us: + if (threadableID != id) return; + + clearRepeatFlag(); + + KeycodeCollection::const_iterator i = keycodes.find(command); + + // Sanity check: + if (i == keycodes.end()) + { + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); + } + + // Construct the object that communicates with the device driver: + PIRRX51Hardware rx51device(carrierFrequency, dutyCycle); + + int repeatCount = 0; + int commandDuration = 0; + while (repeatCount < MAX_REPEAT_COUNT) + { + // Construct the actual command string. + // The string always starts with a constant "1" bit: + commandDuration += pushBit(true, rx51device); + + // Next, the device bits: + commandDuration += pushBits(preData, rx51device); + + // Then, the subdevice bits: + commandDuration += pushBits(postData, rx51device); + + // Finally, the command bits: + commandDuration += pushBits((*i).second.firstCode, rx51device); + + // Clear out the buffer, if needed: + if (buffer) + { + rx51device.addSingle(buffer); + commandDuration += buffer; + + buffer = 0; + bufferContainsSpace = false; + bufferContainsPulse = false; + } + + // Send the command: + rx51device.sendCommandToDevice(); + + // Sleep for the required amount of time. + sleepUntilRepeat(commandDuration); + + // Check whether we've been told to stop: + if (checkRepeatFlag()) + { + // We shall stop: + break; +/* + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +*/ + } + + ++repeatCount; + } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + } + catch (PIRException e) + { + emit commandFailed(e.getError().c_str()); + } +} + + +int TDCProtocol::pushBits( + const CommandSequence &bits, + PIRRX51Hardware &rx51device) +{ + int duration = 0; + + CommandSequence::const_iterator i = bits.begin(); + + while (i != bits.end()) + { + duration += pushBit(*i, rx51device); + ++i; + } + + return duration; +} + + +int TDCProtocol::pushBit( + bool bitValue, + PIRRX51Hardware &device) +{ + unsigned int duration = 0; + // TDC encodes a "0" by using a space followed by a pulse, + // and a "1" by using a pulse followed by a space. + + if (bitValue) + { + // We've got a "1". First add a pulse, then a space. + if (bufferContainsPulse) + { + // Merge our pulse with the previous one, and send them to the device: + device.addSingle(buffer + biphaseUnit); + duration += (buffer + biphaseUnit); + buffer = 0; + bufferContainsPulse = false; + } + else + { + if (bufferContainsSpace) + { + // Flush out the buffer: + device.addSingle(buffer); + duration += buffer; + buffer = 0; + bufferContainsSpace = false; + } + + // Add a pulse: + device.addSingle(biphaseUnit); + duration += biphaseUnit; + } + + // Put a space into the buffer to wait: + buffer = biphaseUnit; + bufferContainsSpace = true; + } + else + { + // We've got a "0". First add a space, then a pulse. + if (bufferContainsSpace) + { + // Merge our space with the previous space, and send them to + // the device. + device.addSingle(buffer + biphaseUnit); + duration += (buffer + biphaseUnit); + buffer = 0; + bufferContainsSpace = false; + } + else + { + if (bufferContainsPulse) + { + // Flush the buffer: + device.addSingle(buffer); + duration += buffer; + buffer = 0; + bufferContainsPulse = false; + } + // Add a space: + device.addSingle(biphaseUnit); + duration += biphaseUnit; + } + + // Put a pulse into the buffer to wait. + buffer = biphaseUnit; + bufferContainsPulse = true; + } + + return duration; +} diff --git a/protocols/tdcprotocol.h b/protocols/tdcprotocol.h new file mode 100644 index 0000000..28c0d7b --- /dev/null +++ b/protocols/tdcprotocol.h @@ -0,0 +1,38 @@ +#ifndef TDCPROTOCOL_H +#define TDCPROTOCOL_H + +#include "pirprotocol.h" + +class PIRRX51Hardware; + +class TDCProtocol: public PIRProtocol +{ +public: + TDCProtocol( + QObject *guiObject, + unsigned int index, + unsigned int deviceBits, + unsigned int subdeviceBits); + +public slots: + void startSendingCommand( + unsigned int threadableID, + PIRKeyName command); + + +private: + int pushBits( + const CommandSequence &bits, + PIRRX51Hardware &device); + + int pushBit( + bool bitValue, + PIRRX51Hardware &device); + + unsigned int biphaseUnit; + unsigned int buffer; + bool bufferContainsSpace; + bool bufferContainsPulse; +}; + +#endif // TDCPROTOCOL_H diff --git a/protocols/thomsonprotocol.cpp b/protocols/thomsonprotocol.cpp index b53075f..23a4da8 100644 --- a/protocols/thomsonprotocol.cpp +++ b/protocols/thomsonprotocol.cpp @@ -51,8 +51,11 @@ void ThomsonProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -76,25 +79,28 @@ void ThomsonProtocol::startSendingCommand( // Check whether we've been asked to stop: if (checkRepeatFlag()) { + break; +/* ++keypressCount; QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + ++keypressCount; + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - ++keypressCount; - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/protocols/xmpprotocol.cpp b/protocols/xmpprotocol.cpp index 096eb54..ce8ae9c 100644 --- a/protocols/xmpprotocol.cpp +++ b/protocols/xmpprotocol.cpp @@ -66,8 +66,11 @@ void XMPProtocol::startSendingCommand( // 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); + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; + return; +// std::string s = "Tried to send a non-existent command.\n"; +// throw PIRException(s); } // construct the device: @@ -106,23 +109,26 @@ void XMPProtocol::startSendingCommand( sleepUntilRepeat(commandDuration); } + break; +/* QMutexLocker cifLocker(&commandIFMutex); commandInFlight = false; return; +*/ } } ++repeatCount; } + + QMutexLocker cifLocker(&commandIFMutex); + commandInFlight = false; } catch (PIRException e) { // inform the gui: emit commandFailed(e.getError().c_str()); } - - QMutexLocker cifLocker(&commandIFMutex); - commandInFlight = false; } diff --git a/qtc_packaging/debian_fremantle/changelog b/qtc_packaging/debian_fremantle/changelog index 2b948ab..bf70424 100644 --- a/qtc_packaging/debian_fremantle/changelog +++ b/qtc_packaging/debian_fremantle/changelog @@ -1,3 +1,17 @@ +pierogi (1.1.8) unstable; urgency=low + * A first attempt at the long-asked-for "search for power button" function. Getting this in required more work on the memory management side of Pierogi, so beware of possible new subtle bugs... + * A new Camera Shutter panel has been added, for remote controls used with DSLR cameras. + * First pass at keysets for Deutsche Telekom, Emtec, Goodmans, Nikon, Olympus,and Pentax. + * Updated Canon keyset to use the new camera panel. + + -- John Pietrzak Thu, 06 Sep 2012 16:35:00 -0400 + +pierogi (1.1.7) unstable; urgency=low + * A quick update to add a "show only favorites" button to the Select Keyset window. Hopefully this will make managing favorites easier. Also, renamed a variety of phrases to make them less misleading. + * Added a keyset and a panel for the iRobot Roomba vacuum cleaner. + + -- John Pietrzak Mon, 03 Sep 2012 18:28:23 -0400 + pierogi (1.1.6) unstable; urgency=low * A big change this time: the move to support true per-keyset editable config data. All favorites data has been moved into the keyset configs, and nicknames have been added. The favorites are now accessed with a pop-up menu. * A new "audio" panel has been added. diff --git a/qtc_packaging/debian_fremantle/control b/qtc_packaging/debian_fremantle/control index 01f6427..383b9cf 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: New Favorites, Nicknames - With the move to per-keyset editable data, the entire favorites system is revamped, and keyset nicknames have been added. A new "audio" panel has also been created. And, a first pass made at keysets for ADB (I-Can), Anitech, Blaupunkt, Lifetec, Medion, Sylvania, Triax, and Viewsonic. +XB-Maemo-Upgrade-Description: Added search for power button panel + The long-wished-for "search for power button" panel has been added to Pierogi. (It may still require a bit of tweaking.) Also in this release, a new Camera Shutter panel for DSLR camera remote controls. First pass at keysets for Deutsche Telekom, Emtec, Goodmans, Nikon, Olympus, and Pentax; and, Canon keyset updated to use new camera panel. 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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