From 28cb8747756c4270e5bb6cd8585685e7ed234aef Mon Sep 17 00:00:00 2001 From: eshe Date: Sun, 25 Jul 2010 22:15:36 +0100 Subject: [PATCH] Added theme scheduler, poi support and speed alarm features. --- jspeed.pro | 32 +++- src/buttonbox.cpp | 37 ++++ src/buttonbox.h | 38 ++++ src/buttonselector.cpp | 5 + src/buttonselector.h | 1 + src/fileselector.cpp | 139 +++++++++++++++ src/fileselector.h | 42 +++++ src/graphicsscene.h | 2 +- src/main.cpp | 24 +++ src/mainmenu.cpp | 29 ++- src/mainmenu.h | 6 + src/mainwindow.cpp | 6 + src/mediaplayer.cpp | 78 +++++++++ src/mediaplayer.h | 40 +++++ src/odometer.cpp | 5 + src/odometer.h | 1 + src/poialerts.cpp | 380 ++++++++++++++++++++++++++++++++++++++++ src/poialerts.h | 76 ++++++++ src/poiascreader.cpp | 86 +++++++++ src/poiascreader.h | 34 ++++ src/poireader.cpp | 86 +++++++++ src/poireader.h | 53 ++++++ src/poisettings.cpp | 143 +++++++++++++++ src/poisettings.h | 57 ++++++ src/resources.qrc | 1 + src/resources/sounds/beep.wav | Bin 0 -> 160776 bytes src/soundselector.cpp | 81 +++++++++ src/soundselector.h | 47 +++++ src/speedalarm.cpp | 118 +++++++++++++ src/speedalarm.h | 48 +++++ src/speedalarmsettings.cpp | 115 ++++++++++++ src/speedalarmsettings.h | 52 ++++++ src/themeloader.cpp | 27 ++- src/themeloader.h | 7 +- src/themepicker.cpp | 93 ++++++++++ src/themepicker.h | 43 +++++ src/themescheduler.cpp | 205 ++++++++++++++++++++++ src/themescheduler.h | 78 +++++++++ src/themeschedulersettings.cpp | 215 +++++++++++++++++++++++ src/themeschedulersettings.h | 62 +++++++ src/themeselector.cpp | 135 +++----------- src/themeselector.h | 13 +- src/unitselector.cpp | 8 +- 43 files changed, 2614 insertions(+), 134 deletions(-) create mode 100644 src/buttonbox.cpp create mode 100644 src/buttonbox.h create mode 100644 src/fileselector.cpp create mode 100644 src/fileselector.h create mode 100644 src/mediaplayer.cpp create mode 100644 src/mediaplayer.h create mode 100644 src/poialerts.cpp create mode 100644 src/poialerts.h create mode 100644 src/poiascreader.cpp create mode 100644 src/poiascreader.h create mode 100644 src/poireader.cpp create mode 100644 src/poireader.h create mode 100644 src/poisettings.cpp create mode 100644 src/poisettings.h create mode 100644 src/resources/sounds/beep.wav create mode 100644 src/soundselector.cpp create mode 100644 src/soundselector.h create mode 100644 src/speedalarm.cpp create mode 100644 src/speedalarm.h create mode 100644 src/speedalarmsettings.cpp create mode 100644 src/speedalarmsettings.h create mode 100644 src/themepicker.cpp create mode 100644 src/themepicker.h create mode 100644 src/themescheduler.cpp create mode 100644 src/themescheduler.h create mode 100644 src/themeschedulersettings.cpp create mode 100644 src/themeschedulersettings.h diff --git a/jspeed.pro b/jspeed.pro index f3014b6..ad563e1 100644 --- a/jspeed.pro +++ b/jspeed.pro @@ -1,6 +1,8 @@ QT += maemo5 xml TARGET = jspeed TEMPLATE = app +CONFIG += mobility +MOBILITY += multimedia SOURCES += src/main.cpp \ src/mainwindow.cpp \ src/mainwindowstack.cpp \ @@ -30,7 +32,20 @@ SOURCES += src/main.cpp \ src/effect.cpp \ src/blureffect.cpp \ src/opacityeffect.cpp \ - src/dropshadoweffect.cpp + src/dropshadoweffect.cpp \ + src/poialerts.cpp \ + src/poireader.cpp \ + src/poiascreader.cpp \ + src/poisettings.cpp \ + src/speedalarmsettings.cpp \ + src/speedalarm.cpp \ + src/fileselector.cpp \ + src/themescheduler.cpp \ + src/themeschedulersettings.cpp \ + src/themepicker.cpp \ + src/mediaplayer.cpp \ + src/soundselector.cpp \ + src/buttonbox.cpp HEADERS += src/mainwindow.h \ src/mainwindowstack.h \ src/location.h \ @@ -59,7 +74,20 @@ HEADERS += src/mainwindow.h \ src/effect.h \ src/blureffect.h \ src/opacityeffect.h \ - src/dropshadoweffect.h + src/dropshadoweffect.h \ + src/poialerts.h \ + src/poireader.h \ + src/poiascreader.h \ + src/poisettings.h \ + src/speedalarmsettings.h \ + src/speedalarm.h \ + src/fileselector.h \ + src/themescheduler.h \ + src/themeschedulersettings.h \ + src/themepicker.h \ + src/mediaplayer.h \ + src/soundselector.h \ + src/buttonbox.h RESOURCES = src/resources.qrc CONFIG += link_pkgconfig PKGCONFIG += liblocation libzip diff --git a/src/buttonbox.cpp b/src/buttonbox.cpp new file mode 100644 index 0000000..4636aae --- /dev/null +++ b/src/buttonbox.cpp @@ -0,0 +1,37 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include "buttonbox.h" + +ButtonBox::ButtonBox(QWidget* parent): QDialogButtonBox(parent) +{ + setCenterButtons(false); + setOrientation(Qt::Vertical); +} + +QPushButton* ButtonBox::addButton(QString const& text, + const QObject* receiver, + const char* member, + QDialogButtonBox::ButtonRole role) +{ + QPushButton* button = new QPushButton(text); + connect(button, SLOT(clicked(bool)), receiver, member); + QDialogButtonBox::addButton(button, role); + return button; +} diff --git a/src/buttonbox.h b/src/buttonbox.h new file mode 100644 index 0000000..6a3771c --- /dev/null +++ b/src/buttonbox.h @@ -0,0 +1,38 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef BUTTONBOX_H +#define BUTTONBOX_H + +#include +#include +#include + +class ButtonBox : public QDialogButtonBox +{ + Q_OBJECT + +public: + ButtonBox(QWidget* parent = 0); + QPushButton* addButton(QString const& text, + const QObject* receiver, + const char* member, + QDialogButtonBox::ButtonRole role = QDialogButtonBox::AcceptRole); +}; + +#endif diff --git a/src/buttonselector.cpp b/src/buttonselector.cpp index c1adde3..22fa6d4 100644 --- a/src/buttonselector.cpp +++ b/src/buttonselector.cpp @@ -142,6 +142,11 @@ bool ButtonSelector::removeItem(unsigned int index) return model_->removeRow(index); } +int ButtonSelector::size() const +{ + return model_->rowCount(); +} + void ButtonSelector::onSelected(QString const& text) { emit selected(currentIndex(), text, value()); diff --git a/src/buttonselector.h b/src/buttonselector.h index e36c159..6b92b24 100644 --- a/src/buttonselector.h +++ b/src/buttonselector.h @@ -39,6 +39,7 @@ public: int indexOfValue(QVariant const& value) const; bool selectByValue(QVariant const& value); int currentIndex() const; + int size() const; bool changeItem(unsigned int index, QString const& text); bool changeItem(unsigned int index, QString const& text, QVariant const& value); bool removeItem(unsigned int index); diff --git a/src/fileselector.cpp b/src/fileselector.cpp new file mode 100644 index 0000000..e7e9887 --- /dev/null +++ b/src/fileselector.cpp @@ -0,0 +1,139 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include "fileselector.h" + +FileSelector::FileSelector(QString const& text, QWidget* parent): ButtonSelector(text, parent) +{ +} + +bool FileSelector::loadFiles(QString const& dir, QString const& pattern) +{ + QDir directory(dir); + + if(directory.exists() && directory.isReadable()) + { + QStringList filters; + filters << pattern; + directory.setNameFilters(filters); + directory.setFilter(QDir::Files); + QStringList files = directory.entryList(); + + for(int i = 0; i < files.size(); i++) + { + addItem(files.at(i)); + } + + return true; + } + + return false; +} + +bool FileSelector::importFile(QString const& dir, + QString const& name, + QString const& pattern, + bool add, + QString* addedFile) +{ + QString filename = QFileDialog::getOpenFileName(this, tr("Open file"), + QDir::home().path(), + name + "(" + pattern + ")"); + + if(filename.isEmpty()) + { + return true; + } + + QString basename; + + int i = filename.lastIndexOf(QDir::separator()); + + if(i == -1) + { + basename = filename; + } + else + { + basename = filename.mid(i + 1); + } + + QString targetFile = dir + basename; + + QDir targetDir(dir); + + if(!targetDir.exists()) + { + if(!targetDir.mkpath(dir)) + { + return false; + } + } + + bool ok = true; + + if(QFile::exists(targetFile)) + { + ok = confirmCopy(basename); + + if(ok) + { + QFile::remove(targetFile); + } + } + + if(ok) + { + if(!QFile::copy(filename, targetFile)) + { + return false; + } + + if(addedFile) + { + *addedFile = basename; + } + + if(add) + { + addItem(basename); + selectByValue(basename); + } + + return true; + } + else + { + return false; + } +} + +bool FileSelector::confirmCopy(QString const& filename) +{ + QMessageBox::StandardButton result = QMessageBox::question(this, tr("File exists"), + tr("File %1 already exists in directory, overwrite?").arg(filename), + QMessageBox::Yes | QMessageBox::No); + + return (result == QMessageBox::Yes); +} + diff --git a/src/fileselector.h b/src/fileselector.h new file mode 100644 index 0000000..1a2ccb3 --- /dev/null +++ b/src/fileselector.h @@ -0,0 +1,42 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef FILESELECTOR_H +#define FILESELECTOR_H + +#include "buttonselector.h" + +class QString; + +class FileSelector : public ButtonSelector +{ + Q_OBJECT + +public: + FileSelector(QString const& text, QWidget* parent = 0); + bool loadFiles(QString const& dir, QString const& pattern); + bool importFile(QString const& dir, QString const& name, + QString const& pattern, bool add = true, + QString* addedFile = 0); + +private: + bool confirmCopy(QString const& filename); + +}; + +#endif diff --git a/src/graphicsscene.h b/src/graphicsscene.h index d5ac6d7..0a8733e 100644 --- a/src/graphicsscene.h +++ b/src/graphicsscene.h @@ -29,7 +29,7 @@ class GraphicsScene : public QGraphicsScene public: GraphicsScene(QRectF const& rect); - static int const CLICK_MARGIN = 45; + static int const CLICK_MARGIN = 48; signals: void clicked(); diff --git a/src/main.cpp b/src/main.cpp index cee1700..9838096 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -20,10 +20,34 @@ #include #include "mainwindow.h" +#include "poiascreader.h" +#include +#include "poialerts.h" + int main(int argc, char *argv[]) { QApplication app(argc, argv); + /* PoiAscReader reader("/home/maemo/workspace/jspeed/test.asc"); + + QList pois; + + if(reader.read(pois)) + { + qDebug() << "Kyl"; + + for(int i = 0; i < pois.size(); i++) + { + qDebug() << pois.at(i).latitude << pois.at(i).longitude << pois.at(i).name; + } + } + else + { + qDebug() << "Ei"; + }*/ + + //PoiAlerts::instance().startTest(); + MainWindow window; QObject::connect(&window, SIGNAL(quit()), &app, SLOT(quit())); diff --git a/src/mainmenu.cpp b/src/mainmenu.cpp index a10d69b..da6af01 100644 --- a/src/mainmenu.cpp +++ b/src/mainmenu.cpp @@ -25,9 +25,12 @@ #include "mainmenu.h" #include "themeselector.h" #include "unitselector.h" +#include "poisettings.h" +#include "speedalarmsettings.h" MainMenu::MainMenu(QWidget* parent): QDialog(parent), itemCount_(0), -currentRow_(0), themeSelector_(0), unitSelector_(0), aboutDialog_(0) +currentRow_(0), themeSelector_(0), unitSelector_(0), poiSettings_(0), +speedAlarmSettings_(0), aboutDialog_(0) { layout_ = new QVBoxLayout; setLayout(layout_); @@ -35,8 +38,10 @@ currentRow_(0), themeSelector_(0), unitSelector_(0), aboutDialog_(0) setWindowTitle(tr("Menu")); addAction(tr("Reset trip"), this, SIGNAL(resetTrip())); addAction(tr("Reset all"), this, SLOT(confirmReset())); - addAction(tr("Select theme"), this, SLOT(selectTheme())); + addAction(tr("Theme"), this, SLOT(selectTheme())); addAction(tr("Set unit"), this, SLOT(selectUnit())); + addAction(tr("Speed camera alerts"), this, SLOT(openPoiAlerts())); + addAction(tr("Speed alarm"), this, SLOT(openSpeedAlarm())); addAction(tr("Flip screen"), this, SIGNAL(flip())); addAction(tr("About"), this, SLOT(showAbout())); } @@ -52,6 +57,26 @@ void MainMenu::selectTheme() themeSelector_->show(); } +void MainMenu::openPoiAlerts() +{ + if(!poiSettings_) + { + poiSettings_ = new PoiSettings(this); + } + + poiSettings_->show(); +} + +void MainMenu::openSpeedAlarm() +{ + if(!speedAlarmSettings_) + { + speedAlarmSettings_ = new SpeedAlarmSettings(this); + } + + speedAlarmSettings_->show(); +} + void MainMenu::selectUnit() { if(!unitSelector_) diff --git a/src/mainmenu.h b/src/mainmenu.h index 44e8b0c..39dbb5d 100644 --- a/src/mainmenu.h +++ b/src/mainmenu.h @@ -25,6 +25,8 @@ class QVBoxLayout; class QHBoxLayout; class ThemeSelector; class UnitSelector; +class PoiSettings; +class SpeedAlarmSettings; class MainMenu : public QDialog { @@ -46,6 +48,8 @@ private slots: void selectUnit(); void showAbout(); void confirmReset(); + void openPoiAlerts(); + void openSpeedAlarm(); private: QVBoxLayout* layout_; @@ -53,6 +57,8 @@ private: QHBoxLayout* currentRow_; ThemeSelector* themeSelector_; UnitSelector* unitSelector_; + PoiSettings* poiSettings_; + SpeedAlarmSettings* speedAlarmSettings_; QDialog* aboutDialog_; }; diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp index 39b41b3..0d1294a 100644 --- a/src/mainwindow.cpp +++ b/src/mainwindow.cpp @@ -29,12 +29,16 @@ #include "mainmenu.h" #include "odometer.h" #include "widgetscreen.h" +#include "poialerts.h" +#include "speedalarm.h" MainWindow::MainWindow(): QMainWindow(0), menu_(0), themeLoader_(0), mainScreen_(0) { setWindowTitle(tr("jSpeed")); showFullScreen(); Odometer::instance().start(); + PoiAlerts::instance().start(); + SpeedAlarm::instance().start(); addScreens(); startBacklight(); } @@ -115,6 +119,8 @@ void MainWindow::openMenu() connect(menu_, SIGNAL(flip()), stack_, SLOT(flip())); connect(menu_, SIGNAL(themeChanged()), this, SLOT(loadTheme())); connect(menu_, SIGNAL(unitChanged()), &(Odometer::instance()), SLOT(updateUnit())); + connect(menu_, SIGNAL(poiSettingsChanged()), &(PoiAlerts::instance()), SLOT(loadConfig())); + connect(menu_, SIGNAL(speedAlarmSettingsChanged()), &(SpeedAlarm::instance()), SLOT(loadConfig())); } menu_->show(); diff --git a/src/mediaplayer.cpp b/src/mediaplayer.cpp new file mode 100644 index 0000000..3d09112 --- /dev/null +++ b/src/mediaplayer.cpp @@ -0,0 +1,78 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include "mediaplayer.h" +#include "settings.h" + +namespace +{ + QString const FORMATS[MediaPlayer::FORMAT_COUNT] = {"mp3", "aac", "wav"}; + QString const LOCAL_SOUND_DIR = ":/resources/sounds/"; +} + +QMediaPlayer MediaPlayer::player_; + +bool MediaPlayer::play(QString const& file) +{ + QMediaContent media(QUrl::fromLocalFile(file)); + + if(media.isNull()) + { + return false; + } + + player_.setMedia(media); + player_.play(); + return true; +} + +void MediaPlayer::getSupportedFormats(QList& formats) +{ + formats.clear(); + + for(int i = 0; i < FORMAT_COUNT; i++) + { + formats.push_back(FORMATS[i]); + } +} + +QString MediaPlayer::getFormatPattern() +{ + QString result = ""; + + for(int i = 0; i < FORMAT_COUNT; i++) + { + result += "*." + FORMATS[i] + " "; + } + + return result.trimmed(); +} + +QString MediaPlayer::getSoundDir() +{ + return Settings::getDir() + "sounds" + QDir::separator(); +} + +QString const& MediaPlayer::getLocalSoundDir() +{ + return LOCAL_SOUND_DIR; +} + diff --git a/src/mediaplayer.h b/src/mediaplayer.h new file mode 100644 index 0000000..abd3303 --- /dev/null +++ b/src/mediaplayer.h @@ -0,0 +1,40 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef MEDIAPLAYER_H +#define MEDIAPLAYER_H + +#include +#include +#include + +class MediaPlayer +{ +public: + enum Format {MP3, WAV, AAC, FORMAT_COUNT}; + static bool play(QString const& file); + static void getSupportedFormats(QList& formats); + static QString getFormatPattern(); + static QString getSoundDir(); + static QString const& getLocalSoundDir(); + +private: + static QMediaPlayer player_; +}; + +#endif diff --git a/src/odometer.cpp b/src/odometer.cpp index d68fb1f..4d81136 100644 --- a/src/odometer.cpp +++ b/src/odometer.cpp @@ -284,6 +284,11 @@ QString const& Odometer::getSpeedUnit() } } +double Odometer::getUnitMultiplier() +{ + return Location::getUnitMultiplier(); +} + void Odometer::updateUnit() { QString unit = Settings::instance().value("unit", "km").toString(); diff --git a/src/odometer.h b/src/odometer.h index c68fee3..83116bb 100644 --- a/src/odometer.h +++ b/src/odometer.h @@ -44,6 +44,7 @@ public: double getSignalStrength() const; static QString const& getUnit(); static QString const& getSpeedUnit(); + static double getUnitMultiplier(); signals: void dataUpdated(); diff --git a/src/poialerts.cpp b/src/poialerts.cpp new file mode 100644 index 0000000..dcc847e --- /dev/null +++ b/src/poialerts.cpp @@ -0,0 +1,380 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include "poialerts.h" +#include "odometer.h" +#include "settings.h" +#include "location.h" +#include "mediaplayer.h" + +namespace +{ + static double const EARTH_MEAN_RADIUS = 6371.0072; + static double const PI = 3.14159265; +} + +inline static double degToRad(double deg) +{ + return deg * PI / 180; +} + +inline static double radToDeg(double rad) +{ + return rad * 180 / PI; +} + +PoiAlerts::PoiAlerts(): QObject(0), enabled_(false), currentPoi_(0), loaded_(false) +{ +} + +PoiAlerts::~PoiAlerts() +{ + end(); +} + +PoiAlerts& PoiAlerts::instance() +{ + static PoiAlerts instance; + return instance; +} + +bool PoiAlerts::start() +{ + if(!loaded_) + { + if(!loadConfig()) + { + return false; + } + } + + if(enabled_) + { + connect(&(Odometer::instance()), SIGNAL(dataUpdated()), this, SLOT(onDataUpdated())); + } + + return true; +} + +void PoiAlerts::end() +{ + if(enabled_) + { + disconnect(&(Odometer::instance()), SIGNAL(dataUpdated()), this, SLOT(onDataUpdated())); + } + + pois_.clear(); + playedSounds_.clear(); + travelled_ = 0; + enabled_ = false; + currentPoi_ = 0; +} + +bool PoiAlerts::loadConfig() +{ + loaded_ = true; + + bool enabled = Settings::instance().value("alert_enabled", false).toBool(); + + if(!enabled) + { + end(); + enabled_ = false; + return true; + } + + distance_ = Settings::instance().value("alert_distance", 300).toBool(); + onlyOnRoute_ = Settings::instance().value("alert_only_on_route", true).toBool(); + + if(distance_ < 0) + { + distance_ = 0; + } + + QString filename = Settings::instance().value("alert_sound", "").toString(); + + if(filename.isEmpty()) + { + filename = "alert.wav"; + } + + QString soundDir = MediaPlayer::getSoundDir(); + QString localDir = MediaPlayer::getLocalSoundDir(); + + if(!filename.isEmpty() && QFile::exists(soundDir + filename)) + { + file_ = soundDir + filename; + } + else if(!filename.isEmpty() && QFile::exists(localDir + filename)) + { + file_ = localDir + filename; + } + else + { + enabled_ = false; + return false; + } + + if(!loadPois()) + { + enabled_ = false; + return false; + } + + if(!enabled_) + { + enabled_ = true; + start(); + } + + return true; +} + +bool PoiAlerts::loadPois() +{ + QString filename = Settings::instance().value("alert_poi_file", "").toString(); + + QString poiFile = getPoiDir() + filename; + + if(filename.isEmpty() || !QFile::exists(poiFile)) + { + error_ = "Poi file doesn't exist"; + return false; + } + + PoiReader* reader = PoiReader::getReader(poiFile); + + if(!reader) + { + error_ = "Unknown file format: " + poiFile; + return false; + } + + if(!reader->read(pois_)) + { + error_ = reader->error(); + return false; + } + + return true; +} + +double PoiAlerts::getCurrentDistance() const +{ + if(!currentPoi_) + { + return 0.0; + } + + return currentDistance_; +} + +QString PoiAlerts::getCurrentPoi() const +{ + if(currentPoi_) + { + return currentPoi_->name; + } + + return ""; +} + +bool PoiAlerts::poiInView() const +{ + return currentPoi_ != 0; +} + +QString const& PoiAlerts::error() const +{ + return error_; +} + +void PoiAlerts::onDataUpdated() +{ + qDebug() << "Data update"; + + static int i = 0; + i++; + + double travelled = Odometer::instance().getTotal(); + const Location::Fix* fix = &(Odometer::instance().getLatestFix()); + + if(fix->latitude < 0.01 || fix->longitude < 0.01 || fix->kmSpeed < 0.01) + { + return; + } + else + { + /*if(i < 5) + { + pois_[0].latitude = fix->latitude; + pois_[0].longitude = fix->longitude; + }*/ + } + + double distance; + double inRouteMargin = IN_ROUTE_MARGIN + (fix->eph / 1000.0); + + qDebug() << "Eph: " << fix->eph; + qDebug() << "In route margin: " << inRouteMargin; + + if(1 == 1 || abs(travelled - travelled_) > 0.03) + { + travelled_ = travelled; + + for(int i = 0; i < pois_.size(); i++) + { + if((distance = calculateDistance(pois_.at(i).latitude, pois_.at(i).longitude, + fix->latitude, fix->longitude)) <= distance_) + { + qDebug() << "Distance: " << distance; + + if(onlyOnRoute_) + { + double track = abs(calculateTrack(fix->latitude, fix->longitude, + pois_.at(i).latitude, pois_.at(i).longitude) - fix->track); + + if(track > 180) + { + track = 360.0 - track; + } + + qDebug() << "Real track: " << track; + qDebug() << "Epd: " << fix->epd; + + double trackLimit; + + if(distance < (inRouteMargin * 2.0)) + { + trackLimit = 60.0; + } + else + { + trackLimit = 90.0 - radToDeg(acos((inRouteMargin + (distance * 0.15)) / distance)); + } + + qDebug() << "Tracklimit: " << trackLimit; + + if(track < trackLimit) + { + currentPoi_ = &pois_[i]; + currentDistance_ = distance; + playSound(i); + } + else + { + currentPoi_ = 0; + } + + } + else + { + currentPoi_ = &pois_[i]; + currentDistance_ = distance; + playSound(i); + } + + break; + } + else + { + currentPoi_ = 0; + qDebug() << "Distance: " << distance; + } + } + } + + qDebug() << '\n'; +} + +void PoiAlerts::startTest() +{ + Odometer::instance().start(); + enabled_ = true; + distance_ = 100; + PoiReader::Poi poi; + poi.latitude = 0.0; + poi.longitude = 0.0; + poi.name = "Mokki"; + pois_.push_back(poi); + onlyOnRoute_ = true; + start(); +} + +double PoiAlerts::calculateDistance(double latitude1, double longitude1, + double latitude2, double longitude2) +{ + double dlat = degToRad(latitude1 - latitude2); + double dlon = degToRad(longitude1 - longitude2); + double y = sin(dlat / 2.0) * sin(dlat / 2.0) + + cos(degToRad(latitude2)) + * cos(degToRad(latitude1)) + * sin(dlon / 2.0) * sin(dlon / 2.0); + double x = 2 * atan2(sqrt(y), sqrt(1 - y)); + return x * EARTH_MEAN_RADIUS * 1000; +} + +double PoiAlerts::calculateTrack(double latitude1, double longitude1, + double latitude2, double longitude2) +{ + double dlon = degToRad(longitude2 - longitude1); + double lat1Rad = degToRad(latitude1); + double lat2Rad = degToRad(latitude2); + double y = sin(dlon) * cos(lat2Rad); + double x = cos(lat1Rad) * sin(lat2Rad) - sin(lat1Rad) * cos(lat2Rad) * cos(dlon); + double whole; + double fraction = modf(radToDeg(atan2(y, x)), &whole); + return (int(whole + 360) % 360) + fraction; +} + +void PoiAlerts::playSound(int poiIndex) +{ + qDebug() << "Almost play sound"; + + if(playedSounds_.indexOf(poiIndex) == -1) + { + playedSounds_.enqueue(poiIndex); + + qDebug() << "Play sound"; + MediaPlayer::play(file_); + + QTimer::singleShot(POI_ALERT_INTERVAL * 1000, this, SLOT(removePlayed())); + } + +} + +void PoiAlerts::removePlayed() +{ + if(!playedSounds_.isEmpty()) + { + int removed = playedSounds_.dequeue(); + qDebug() << "Removed: " << removed; + } +} + +QString PoiAlerts::getPoiDir() +{ + return Settings::getDir() + "pois" + QDir::separator(); +} + diff --git a/src/poialerts.h b/src/poialerts.h new file mode 100644 index 0000000..8adc163 --- /dev/null +++ b/src/poialerts.h @@ -0,0 +1,76 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef POIALERTS_H +#define POIALERTS_H + +#include +#include +#include +#include "poireader.h" + +class QString; + +class PoiAlerts : public QObject +{ + Q_OBJECT + +public: + static int const POI_ALERT_INTERVAL = 120; + static int const IN_ROUTE_MARGIN = 20; + static PoiAlerts& instance(); + static QString getPoiDir(); + ~PoiAlerts(); + bool start(); + void end(); + void startTest(); + double getCurrentDistance() const; + QString getCurrentPoi() const; + bool poiInView() const; + QString const& error() const; + +public slots: + bool loadConfig(); + +private slots: + void onDataUpdated(); + void removePlayed(); + +private: + PoiAlerts(); + bool loadPois(); + void playSound(int poiIndex); + static double calculateDistance(double latitude1, double longitude1, + double latitude2, double longitude2); + static double calculateTrack(double latitude1, double longitude1, + double latitude2, double longitude2); + QString file_; + bool onlyOnRoute_; + QList pois_; + QQueue playedSounds_; + bool enabled_; + int distance_; + double travelled_; + PoiReader::Poi* currentPoi_; + double currentDistance_; + bool loaded_; + QString error_; + +}; + +#endif diff --git a/src/poiascreader.cpp b/src/poiascreader.cpp new file mode 100644 index 0000000..0b44e7f --- /dev/null +++ b/src/poiascreader.cpp @@ -0,0 +1,86 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include "poiascreader.h" + +PoiAscReader::PoiAscReader(QString filename): PoiReader(), filename_(filename) +{ +} + +bool PoiAscReader::read(QList& pois) +{ + QFile file(filename_); + + if(!file.open(QIODevice::ReadOnly)) + { + setError("Unable to open file (check permissions)"); + return false; + } + + QString data = QString(file.readAll()); + static QRegExp matcher("([0-9]{1,3})\\.([0-9]+), ([0-9]{1,3})\\.([0-9]+), \"(.*)\""); + matcher.setMinimal(true); + + int pos = 0; + + while((pos = matcher.indexIn(data, pos)) != -1) + { + pos += matcher.matchedLength(); + + Poi poi; + + bool ok; + + QString latitude = matcher.cap(1) + "." + matcher.cap(2); + QString longitude = matcher.cap(3) + "." + matcher.cap(4); + + double doubleLatitude = latitude.toDouble(&ok); + + if(!ok) + { + continue; + } + + double doubleLongitude = longitude.toDouble(&ok); + + if(!ok) + { + continue; + } + + poi.latitude = doubleLatitude; + poi.longitude = doubleLongitude; + poi.name = matcher.cap(5); + + pois.push_back(poi); + + } + + if(pois.size() == 0) + { + setError("No valid poi data found from file"); + return false; + } + + return true; +} diff --git a/src/poiascreader.h b/src/poiascreader.h new file mode 100644 index 0000000..237cf5d --- /dev/null +++ b/src/poiascreader.h @@ -0,0 +1,34 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef POIASCREADER_H +#define POIASCREADER_H + +#include "poireader.h" + +class PoiAscReader : public PoiReader +{ +public: + PoiAscReader(QString filename); + virtual bool read(QList& pois); + +private: + QString filename_; +}; + +#endif diff --git a/src/poireader.cpp b/src/poireader.cpp new file mode 100644 index 0000000..3078ec6 --- /dev/null +++ b/src/poireader.cpp @@ -0,0 +1,86 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include "poireader.h" +#include "poiascreader.h" + +namespace +{ + QString const READER_FILETYPES[PoiReader::READER_COUNT] = {"asc"}; +} + +PoiReader::PoiReader() +{ +} + +PoiReader* PoiReader::getReader(QString const& filename) +{ + QString lower = filename.toLower(); + QString type; + Reader reader = READER_COUNT; + + for(int i = 0; i < READER_COUNT; i++) + { + if(lower.right(READER_FILETYPES[i].size()) == READER_FILETYPES[i]) + { + reader = static_cast(i); + break; + } + } + + switch(reader) + { + case ASCREADER: + return new PoiAscReader(filename); + break; + default: + return 0; + } +} + +void PoiReader::setError(QString const& error) +{ + error_ = error; +} + +QString const& PoiReader::error() +{ + return error_; +} + +QString PoiReader::getFormatPattern() +{ + QString data = ""; + + for(int i = 0; i < READER_COUNT; i++) + { + data += "*." + READER_FILETYPES[i] + " "; + } + + return data.trimmed(); +} + +void PoiReader::getSupportedFormats(QList& formats) +{ + formats.clear(); + + for(int i = 0; i < READER_COUNT; i++) + { + formats.push_back(READER_FILETYPES[i]); + } +} diff --git a/src/poireader.h b/src/poireader.h new file mode 100644 index 0000000..fced29e --- /dev/null +++ b/src/poireader.h @@ -0,0 +1,53 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef POIREADER_H +#define POIREADER_H + +#include +#include + +class PoiReader +{ +public: + + struct Poi + { + double latitude; + double longitude; + QString name; + }; + + enum Reader {ASCREADER, READER_COUNT}; + + static PoiReader* getReader(QString const& filename); + PoiReader(); + virtual bool read(QList& pois) = 0; + QString const& error(); + static QString getFormatPattern(); + static void getSupportedFormats(QList& formats); + +protected: + void setError(QString const& error); + +private: + QString error_; + +}; + +#endif diff --git a/src/poisettings.cpp b/src/poisettings.cpp new file mode 100644 index 0000000..09a4043 --- /dev/null +++ b/src/poisettings.cpp @@ -0,0 +1,143 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "poisettings.h" +#include "fileselector.h" +#include "poialerts.h" +#include "settings.h" +#include "mediaplayer.h" +#include "poireader.h" +#include "buttonbox.h" +#include "soundselector.h" + + +PoiSettings::PoiSettings(QWidget* parent): QDialog(parent) +{ + setWindowTitle(tr("Speed camera alerts")); + enabled_ = new QCheckBox(tr("Enabled")); + enabled_->setChecked(Settings::instance().value("alert_enabled", false).toBool()); + + QHBoxLayout* poiLayout = new QHBoxLayout; + poiFileSelector_ = new FileSelector(tr("Poi file (.asc)")); + QPushButton* importButton = new QPushButton(tr("Import")); + connect(importButton, SIGNAL(clicked(bool)), this, SLOT(importFile())); + poiLayout->addWidget(poiFileSelector_, Qt::AlignLeft); + poiLayout->addWidget(importButton); + + soundSelector_ = new SoundSelector; + + QLabel* distanceLabel = new QLabel(tr("Alert distance")); + distance_ = new QLineEdit; + distance_->setText(QString::number(Settings::instance().value("alert_distance", 300).toInt())); + distance_->setValidator(new QIntValidator(0, 5000, this)); + QHBoxLayout* distance = new QHBoxLayout; + distance->addWidget(distanceLabel); + distance->addWidget(distance_); + onlyOnRoute_ = new QCheckBox(tr("Alert only if poi is in route")); + onlyOnRoute_->setChecked(Settings::instance().value("alert_only_on_route", true).toBool()); + + ButtonBox* buttons = new ButtonBox; + buttons->addButton(tr("Save"), this, SLOT(saveSettings()), QDialogButtonBox::AcceptRole); + + QHBoxLayout* layout = new QHBoxLayout; + QVBoxLayout* left = new QVBoxLayout; + + left->addWidget(enabled_); + left->addLayout(poiLayout); + left->addWidget(soundSelector_); + left->addLayout(distance); + left->addWidget(onlyOnRoute_); + + layout->addLayout(left, Qt::AlignLeft); + layout->addWidget(buttons); + + setLayout(layout); +} + + +void PoiSettings::importFile() +{ + if(!poiFileSelector_->importFile(PoiAlerts::getPoiDir(), + "Poi files", + PoiReader::getFormatPattern(), + true)) + { + qDebug() << "Unable to import"; + } +} + +void PoiSettings::loadFiles() +{ + QDir poiDir(PoiAlerts::getPoiDir()); + + QString selectedSound = Settings::instance().value("alert_sound", "").toString(); + soundSelector_->setValue(selectedSound); + + poiFileSelector_->clear(); + QString selectedPoi = Settings::instance().value("alert_poi_file", "").toString(); + poiFileSelector_->loadFiles(PoiAlerts::getPoiDir(), PoiReader::getFormatPattern()); + poiFileSelector_->selectByValue(selectedPoi); + +} + +void PoiSettings::setVisible(bool visible) +{ + if(visible) + { + loadFiles(); + } + + QDialog::setVisible(visible); +} + +void PoiSettings::saveSettings() +{ + if(poiFileSelector_->currentIndex() < 0 && enabled_->isChecked()) + { + QMaemo5InformationBox::information(this, tr("No poi file selected")); + return; + } + + Settings::instance().setValue("alert_enabled", enabled_->isChecked()); + Settings::instance().setValue("alert_only_on_route", onlyOnRoute_->isChecked()); + Settings::instance().setValue("alert_distance", distance_->text().toInt()); + Settings::instance().setValue("alert_sound", soundSelector_->value()); + Settings::instance().setValue("alert_poi_file", poiFileSelector_->value()); + + hide(); + + if(!PoiAlerts::instance().loadConfig()) + { + QMaemo5InformationBox::information(0, tr("Unable to load poi file: %1.").arg(PoiAlerts::instance().error()), + QMaemo5InformationBox::NoTimeout); + } +} diff --git a/src/poisettings.h b/src/poisettings.h new file mode 100644 index 0000000..67cfc7f --- /dev/null +++ b/src/poisettings.h @@ -0,0 +1,57 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef POISETTINGS_H +#define POISETTINGS_H + +#include + +class QLineEdit; +class QCheckBox; +class SoundSelector; +class FileSelector; + +class PoiSettings : public QDialog +{ + Q_OBJECT + +public: + PoiSettings(QWidget* parent = 0); + +signals: + void saved(); + +protected: + virtual void setVisible(bool visible); + +private slots: + void saveSettings(); + void importFile(); + +private: + void loadFiles(); + void loadSounds(QString const& dir, QString const& selected); + QCheckBox* enabled_; + FileSelector* poiFileSelector_; + SoundSelector* soundSelector_; + QLineEdit* distance_; + QCheckBox* onlyOnRoute_; + +}; + +#endif diff --git a/src/resources.qrc b/src/resources.qrc index 24f58d4..a01fadf 100644 --- a/src/resources.qrc +++ b/src/resources.qrc @@ -12,6 +12,7 @@ resources/signal_2.png resources/signal_3.png resources/signal_4.png + resources/sounds/beep.wav resources/themes/default/theme.xml resources/themes/default/digital7.ttf resources/themes/default/background.png diff --git a/src/resources/sounds/beep.wav b/src/resources/sounds/beep.wav new file mode 100644 index 0000000000000000000000000000000000000000..678fbecbc73c1d591b46bbb071c373d829839e35 GIT binary patch literal 160776 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 V_FO5ZIHI}@`{1&y$uy$i|3BK`u>Jr5 literal 0 HcmV?d00001 diff --git a/src/soundselector.cpp b/src/soundselector.cpp new file mode 100644 index 0000000..1d80dbf --- /dev/null +++ b/src/soundselector.cpp @@ -0,0 +1,81 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include "soundselector.h" +#include "fileselector.h" +#include "mediaplayer.h" + +SoundSelector::SoundSelector(QWidget* parent): QWidget(parent) +{ + selector_ = new FileSelector(tr("Sound")); + QPushButton* playButton = new QPushButton(tr("Play")); + connect(playButton, SIGNAL(clicked(bool)), this, SLOT(playSound())); + QHBoxLayout* layout = new QHBoxLayout; + layout->addWidget(selector_, Qt::AlignLeft); + layout->addWidget(playButton); + setLayout(layout); +} + +void SoundSelector::playSound() +{ + QString sound = selector_->value().toString(); + + if(sound.isEmpty()) + { + return; + } + + QString soundDir = MediaPlayer::getSoundDir(); + QString localDir = MediaPlayer::getLocalSoundDir(); + + if(QFile::exists(soundDir + sound)) + { + MediaPlayer::play(soundDir + sound); + } + else if(QFile::exists(localDir + sound)) + { + MediaPlayer::play(localDir + sound); + } +} + +void SoundSelector::setVisible(bool visible) +{ + if(visible) + { + QString currentValue = selector_->value().toString(); + selector_->clear(); + QString pattern = MediaPlayer::getFormatPattern(); + selector_->loadFiles(MediaPlayer::getLocalSoundDir(), pattern); + selector_->loadFiles(MediaPlayer::getSoundDir(), pattern); + setValue(currentValue); + } + + QWidget::setVisible(visible); +} + +void SoundSelector::setValue(QString const& value) +{ + selector_->selectByValue(value); +} + +QString SoundSelector::value() const +{ + return selector_->value().toString(); +} diff --git a/src/soundselector.h b/src/soundselector.h new file mode 100644 index 0000000..c9247e9 --- /dev/null +++ b/src/soundselector.h @@ -0,0 +1,47 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef SOUNDSELECTOR_H +#define SOUNDSELECTOR_H + +#include + +class FileSelector; + +class SoundSelector : public QWidget +{ + Q_OBJECT + +public: + SoundSelector(QWidget* parent = 0); + +public slots: + void setValue(QString const& value); + QString value() const; + +protected: + virtual void setVisible(bool visible); + +private slots: + void playSound(); + +private: + FileSelector* selector_; +}; + +#endif diff --git a/src/speedalarm.cpp b/src/speedalarm.cpp new file mode 100644 index 0000000..b4908e7 --- /dev/null +++ b/src/speedalarm.cpp @@ -0,0 +1,118 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include "speedalarm.h" +#include "settings.h" +#include "odometer.h" +#include "poialerts.h" +#include "mediaplayer.h" + +SpeedAlarm::SpeedAlarm(): QObject(0), loaded_(false), enabled_(false), isOver_(false) +{ +} + +SpeedAlarm& SpeedAlarm::instance() +{ + static SpeedAlarm instance; + return instance; +} + +void SpeedAlarm::start() +{ + if(!loaded_) + { + loadConfig(); + } + + if(enabled_) + { + connect(&(Odometer::instance()), SIGNAL(dataUpdated()), this, SLOT(onDataUpdated())); + } + +} + +void SpeedAlarm::loadConfig() +{ + loaded_ = true; + + bool enabled = Settings::instance().value("alarm_enabled", false).toBool(); + + if(enabled) + { + enabled_ = true; + + QString sound = Settings::instance().value("alarm_sound", "").toString(); + + if(sound.isEmpty()) + { + enabled_ = false; + return; + } + + QString soundDir = MediaPlayer::getSoundDir(); + + if(QFile::exists(soundDir + sound)) + { + soundFile_ = soundDir + sound; + } + else if(QFile::exists(MediaPlayer::getLocalSoundDir() + sound)) + { + soundFile_ = MediaPlayer::getLocalSoundDir() + sound; + } + else + { + enabled_ = false; + return; + } + + threshold_ = Settings::instance().value("alarm_threshold", 0).toInt(); + + start(); + } + else + { + end(); + enabled_ = false; + } +} + +void SpeedAlarm::end() +{ + if(enabled_) + { + disconnect(&(Odometer::instance()), SIGNAL(dataUpdated()), this, SLOT(onDataUpdated())); + } +} + +void SpeedAlarm::onDataUpdated() +{ + if(Odometer::instance().getLatestFix().kmSpeed > threshold_) + { + if(!isOver_) + { + MediaPlayer::play(soundFile_); + isOver_ = true; + } + } + else + { + isOver_ = false; + } +} diff --git a/src/speedalarm.h b/src/speedalarm.h new file mode 100644 index 0000000..10e3581 --- /dev/null +++ b/src/speedalarm.h @@ -0,0 +1,48 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef SPEEDALARM_H +#define SPEEDALARM_H + +#include + +class SpeedAlarm : public QObject +{ + Q_OBJECT + +public: + static SpeedAlarm& instance(); + void start(); + void end(); + +public slots: + void loadConfig(); + +private slots: + void onDataUpdated(); + +private: + SpeedAlarm(); + bool loaded_; + QString soundFile_; + int threshold_; + bool enabled_; + bool isOver_; +}; + +#endif diff --git a/src/speedalarmsettings.cpp b/src/speedalarmsettings.cpp new file mode 100644 index 0000000..64e84c2 --- /dev/null +++ b/src/speedalarmsettings.cpp @@ -0,0 +1,115 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "speedalarmsettings.h" +#include "speedalarm.h" +#include "odometer.h" +#include "settings.h" +#include "fileselector.h" +#include "poialerts.h" +#include "mediaplayer.h" +#include "soundselector.h" +#include "buttonbox.h" + + +SpeedAlarmSettings::SpeedAlarmSettings(QWidget* parent): QDialog(parent) +{ + setWindowTitle(tr("Speed alarm")); + + speedLabel_ = new QLabel; + speed_ = new QLineEdit; + speed_->setValidator(new QIntValidator(0, 999, this)); + + QPushButton* current = new QPushButton(tr("Current")); + connect(current, SIGNAL(clicked(bool)), this, SLOT(loadCurrentSpeed())); + + QHBoxLayout* speedLayout = new QHBoxLayout; + speedLayout->addWidget(speedLabel_); + speedLayout->addWidget(speed_); + speedLayout->addWidget(current); + + soundSelector_ = new SoundSelector; + + enabled_ = new QCheckBox(tr("Enabled")); + enabled_->setChecked(Settings::instance().value("alarm_enabled", false).toBool()); + + ButtonBox* buttons = new ButtonBox; + buttons->addButton(tr("Save"), this, SLOT(saveSettings()), QDialogButtonBox::AcceptRole); + + QHBoxLayout* layout = new QHBoxLayout; + QVBoxLayout* left = new QVBoxLayout; + + left->addLayout(speedLayout); + left->addWidget(soundSelector_); + left->addWidget(enabled_); + layout->addLayout(left, Qt::AlignLeft); + layout->addWidget(buttons); + + setLayout(layout); +} + + +void SpeedAlarmSettings::loadData() +{ + speedLabel_->setText(tr("Speed threshold (%1)").arg(Odometer::getSpeedUnit())); + int speedValue = round(Settings::instance().value("alarm_threshold", 100).toDouble() * Odometer::getUnitMultiplier()); + speed_->setText(QString::number(static_cast(speedValue))); + + QString selected = Settings::instance().value("alarm_sound", "").toString(); + soundSelector_->setValue(selected); +} + +void SpeedAlarmSettings::loadCurrentSpeed() +{ + double speed = round(Odometer::instance().getLatestFix().speed); + speed_->setText(QString::number(static_cast(speed))); +} + +void SpeedAlarmSettings::saveSettings() +{ + double kmSpeed = speed_->text().toInt() / Odometer::getUnitMultiplier(); + + Settings::instance().setValue("alarm_threshold", kmSpeed); + Settings::instance().setValue("alarm_enabled", enabled_->isChecked()); + Settings::instance().setValue("alarm_sound", soundSelector_->value()); + + SpeedAlarm::instance().loadConfig(); + + hide(); +} + +void SpeedAlarmSettings::setVisible(bool visible) +{ + if(visible) + { + loadData(); + } + + QDialog::setVisible(visible); +} diff --git a/src/speedalarmsettings.h b/src/speedalarmsettings.h new file mode 100644 index 0000000..aa7d97e --- /dev/null +++ b/src/speedalarmsettings.h @@ -0,0 +1,52 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef SPEEDALARMSETTINGS_H +#define SPEEDALARMSETTINGS_H + +#include + +class QLineEdit; +class QLabel; +class QCheckBox; +class FileSelector; +class SoundSelector; + +class SpeedAlarmSettings : public QDialog +{ + Q_OBJECT + +public: + SpeedAlarmSettings(QWidget* parent = 0); + +protected: + virtual void setVisible(bool visible); + +private slots: + void saveSettings(); + void loadCurrentSpeed(); + +private: + void loadData(); + QLabel* speedLabel_; + QLineEdit* speed_; + SoundSelector* soundSelector_; + QCheckBox* enabled_; +}; + +#endif diff --git a/src/themeloader.cpp b/src/themeloader.cpp index b554088..768999b 100644 --- a/src/themeloader.cpp +++ b/src/themeloader.cpp @@ -33,6 +33,7 @@ #include "detailscreen.h" #include "settings.h" #include "widgetscreen.h" +#include "themescheduler.h" namespace { @@ -51,13 +52,25 @@ ThemeLoader::~ThemeLoader() bool ThemeLoader::load() { - QString theme = Settings::instance().value("theme", "default").toString(); + if(theme_.isEmpty()) + { + connect(&(ThemeScheduler::instance()), SIGNAL(themeChanged()), this, SLOT(load())); + } + + QString theme = ThemeScheduler::instance().currentTheme(); + + if(theme == theme_) + { + return true; + } + + theme_ = theme; QString themeDir = getThemeDir(); - if(QFile::exists(themeDir + theme + THEME_SUFFIX)) + if(QFile::exists(themeDir + theme_ + THEME_SUFFIX)) { - reader_ = new ZipReader(themeDir + theme + THEME_SUFFIX); + reader_ = new ZipReader(themeDir + theme_ + THEME_SUFFIX); if(read()) { @@ -71,17 +84,17 @@ bool ThemeLoader::load() } } - theme = "default"; - Settings::instance().setValue("theme", theme); + theme_ = ThemeScheduler::instance().getDefaultTheme(); + Settings::instance().setValue("theme", theme_); - if(QFile::exists(RESOURCE_DIR + theme)) + if(QFile::exists(RESOURCE_DIR + theme_)) { if(reader_) { delete reader_; } - reader_ = new FileReader(RESOURCE_DIR + theme); + reader_ = new FileReader(RESOURCE_DIR + theme_); return read(); } diff --git a/src/themeloader.h b/src/themeloader.h index bdf2ce2..f5797a2 100644 --- a/src/themeloader.h +++ b/src/themeloader.h @@ -28,17 +28,22 @@ class WidgetScreen; class ThemeLoader : public QObject { + Q_OBJECT + public: ThemeLoader(WidgetScreen* mainScreen, WidgetScreen* detailScreen, QObject* parent = 0); ~ThemeLoader(); - bool load(); QString const& error() const; static QString getThemeDir(); static QString const& getThemeSuffix(); +public slots: + bool load(); + private: bool read(); bool loadScreen(QString const& tag, QDomDocument const& doc, WidgetScreen* screen); + QString theme_; Reader* reader_; QString error_; WidgetScreen* mainScreen_; diff --git a/src/themepicker.cpp b/src/themepicker.cpp new file mode 100644 index 0000000..f7d3e44 --- /dev/null +++ b/src/themepicker.cpp @@ -0,0 +1,93 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include "themepicker.h" +#include "themescheduler.h" +#include "themeloader.h" +#include "settings.h" + +ThemePicker::ThemePicker(QString const& text, QWidget* parent): +FileSelector(text, parent) +{ +} + +void ThemePicker::setVisible(bool visible) +{ + if(visible) + { + loadThemes(); + } + + FileSelector::setVisible(visible); +} + +void ThemePicker::loadThemes() +{ + QString current = Settings::instance().value("theme", ThemeScheduler::getDefaultTheme()).toString(); + clear(); + addItem(tr("Default"), ThemeScheduler::getDefaultTheme()); + + QDir themeDir(ThemeLoader::getThemeDir()); + + if(!themeDir.exists() || !themeDir.isReadable()) + { + qDebug() << "Warning: theme dir (" + ThemeLoader::getThemeDir() + ") doesn't exist or is read protected"; + return; + } + + QStringList filters; + filters << "*" + ThemeLoader::getThemeSuffix(); + themeDir.setNameFilters(filters); + themeDir.setFilter(QDir::Files); + QStringList files = themeDir.entryList(); + + for(int i = 0; i < files.size(); i++) + { + QString name; + QString id; + getThemeDetails(files.at(i), name, id); + addItem(name, id); + + if(id == current) + { + setCurrentIndex(i + 1); + } + } +} + +bool ThemePicker::selectTheme(QString const& filename) +{ + QString name; + QString id; + getThemeDetails(filename, name, id); + return selectByValue(id); +} + +void ThemePicker::getThemeDetails(QString filename, + QString& name, + QString& id) +{ + static QRegExp cleaner(QRegExp::escape(ThemeLoader::getThemeSuffix()) + "$"); + filename = filename.replace(cleaner, ""); + + id = filename; + name = filename.at(0).toUpper() + filename.mid(1); +} diff --git a/src/themepicker.h b/src/themepicker.h new file mode 100644 index 0000000..5339faa --- /dev/null +++ b/src/themepicker.h @@ -0,0 +1,43 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef THEMEPICKER_H +#define THEMEPICKER_H + +#include "fileselector.h" + +class ThemePicker : public FileSelector +{ + Q_OBJECT + +public: + ThemePicker(QString const& text = tr("Theme"), QWidget* parent = 0); + bool selectTheme(QString const& name); + +public slots: + void loadThemes(); + +protected: + virtual void setVisible(bool visible); + +private: + void getThemeDetails(QString filename, QString& name, QString& id); + QString theme_; +}; + +#endif diff --git a/src/themescheduler.cpp b/src/themescheduler.cpp new file mode 100644 index 0000000..a09225f --- /dev/null +++ b/src/themescheduler.cpp @@ -0,0 +1,205 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include "themescheduler.h" +#include "settings.h" + +namespace +{ + QString const DEFAULT_THEME = "default"; +} + +ThemeScheduler::ThemeScheduler(): QObject(0), enabled_(false) +{ + loadConfig(); +} + +ThemeScheduler::~ThemeScheduler() +{ + store(); + clear(); +} + +ThemeScheduler& ThemeScheduler::instance() +{ + static ThemeScheduler instance; + return instance; +} + +void ThemeScheduler::addItem(QTime const& time, QString const& theme) +{ + removeItem(time); + ItemDetails* details = new ItemDetails; + details->time = time; + details->theme = theme; + + int msecs = QTime::currentTime().msecsTo(time); + + if(msecs < 0) + { + msecs += 86400000; + } + + details->timer.setSingleShot(true); + details->timer.start(msecs + 500); + connect(&details->timer, SIGNAL(timeout()), this, SLOT(emitThemeChanged())); + + for(int i = 0; i < items_.size(); i++) + { + if(items_.at(i)->time > time) + { + items_.insert(i, details); + return; + } + } + + items_.push_back(details); +} + +void ThemeScheduler::removeItem(QTime const& time) +{ + for(int i = 0; i < items_.size(); i++) + { + if(items_.at(i)->time == time) + { + delete items_.at(i); + items_.removeAt(i); + break; + } + } +} + +void ThemeScheduler::store() +{ + if(items_.isEmpty()) + { + Settings::instance().remove("theme_scheduler"); + return; + } + + QList list; + + for(int i = 0; i < items_.size(); i++) + { + QMap map; + map["time"] = items_.at(i)->time.toString(); + map["theme"] = items_.at(i)->theme; + list.push_back(map); + } + + Settings::instance().setValue("theme_scheduler", list); +} + +void ThemeScheduler::loadConfig() +{ + enabled_ = Settings::instance().value("theme_scheduler_enabled", false).toBool(); + + QList list = Settings::instance().value("theme_scheduler").toList(); + + for(int i = 0; i < list.size(); i++) + { + QMap map = list.at(i).toMap(); + QTime time = QTime::fromString(map["time"].toString()); + addItem(time, map["theme"].toString()); + } +} + +void ThemeScheduler::setEnabled(bool enabled) +{ + enabled_ = enabled; +} + +bool ThemeScheduler::isEnabled() const +{ + return enabled_; +} + +QString ThemeScheduler::currentTheme() const +{ + if(enabled_) + { + QTime time = QTime::currentTime(); + + for(int i = 0; i < items_.size(); i++) + { + if(items_.at(i)->time >= time) + { + int index = i - 1; + + if(index < 0) + { + index = items_.size() - 1; + } + + return items_.at(index)->theme; + } + } + + if(items_.size() > 0) + { + return items_.at(items_.size() - 1)->theme; + } + } + + QString theme = Settings::instance().value("theme", DEFAULT_THEME).toString(); + + if(theme.isEmpty()) + { + return DEFAULT_THEME; + } + + return theme; +} + +QString const& ThemeScheduler::getDefaultTheme() +{ + return DEFAULT_THEME; +} + +void ThemeScheduler::clear() +{ + for(int i = 0; i < items_.size(); i++) + { + delete items_.at(i); + } + + items_.clear(); +} + +void ThemeScheduler::getItems(QList& items) +{ + items.clear(); + + for(int i = 0; i < items_.size(); i++) + { + SchedulerItem item; + item.time = items_.at(i)->time; + item.theme = items_.at(i)->theme; + items.push_back(item); + } +} + +void ThemeScheduler::emitThemeChanged() +{ + if(enabled_) + { + emit themeChanged(); + } +} diff --git a/src/themescheduler.h b/src/themescheduler.h new file mode 100644 index 0000000..0501964 --- /dev/null +++ b/src/themescheduler.h @@ -0,0 +1,78 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef THEMESCHEDULER_H +#define THEMESCHEDULER_H + +#include +#include +#include +#include + +class QString; + +class ThemeScheduler : public QObject +{ + Q_OBJECT + +public: + + struct SchedulerItem + { + QTime time; + QString theme; + }; + + ~ThemeScheduler(); + static ThemeScheduler& instance(); + static QString const& getDefaultTheme(); + void addItem(QTime const& time, QString const& theme); + void removeItem(QTime const& time); + void setEnabled(bool enabled); + bool isEnabled() const; + QString currentTheme() const; + void clear(); + void getItems(QList& items); + +public slots: + void store(); + +signals: + void themeChanged(); + +private slots: + void emitThemeChanged(); + +private: + struct ItemDetails + { + QTime time; + QString theme; + QTimer timer; + }; + + ThemeScheduler(); + void loadConfig(); + void sort(); + bool enabled_; + QList items_; + + +}; + +#endif diff --git a/src/themeschedulersettings.cpp b/src/themeschedulersettings.cpp new file mode 100644 index 0000000..f736626 --- /dev/null +++ b/src/themeschedulersettings.cpp @@ -0,0 +1,215 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "themeschedulersettings.h" +#include "themescheduler.h" +#include "themepicker.h" +#include "buttonbox.h" + +namespace +{ + QString const TIME_FORMAT = "hh:mm"; +} + +ThemeSchedulerSettings::ThemeSchedulerSettings(QWidget* parent): +QDialog(parent), currentWidget_(0), addDialog_(0), itemList_(0) +{ + setWindowTitle(tr("Theme scheduler")); + + QHBoxLayout* layout = new QHBoxLayout; + layout_ = new QVBoxLayout; + + enabled_ = new QCheckBox(tr("Enabled")); + enabled_->setChecked(ThemeScheduler::instance().isEnabled()); + + QLabel* info = new QLabel(tr("Scheduled themes:")); + + layout_->addWidget(enabled_); + layout_->addWidget(info); + + loadItems(); + + ButtonBox* buttons = new ButtonBox; + buttons->addButton(tr("Save"), this, SLOT(saveSettings()), QDialogButtonBox::AcceptRole); + buttons->addButton(tr("Add new theme"), this, SLOT(openAddDialog()), QDialogButtonBox::ActionRole); + buttons->addButton(tr("Clear scheduler"), this, SLOT(clearScheduler()), QDialogButtonBox::ActionRole); + + layout->addLayout(layout_, Qt::AlignLeft); + layout->addWidget(buttons); + + setLayout(layout); + +} + +void ThemeSchedulerSettings::openAddDialog() +{ + if(!addDialog_) + { + addDialog_ = new QDialog(this); + addDialog_->setWindowTitle("Add scheduled theme"); + QHBoxLayout* layout = new QHBoxLayout; + QVBoxLayout* left = new QVBoxLayout; + timeButton_ = new QMaemo5ValueButton(tr("Start time")); + timeButton_->setValueLayout(QMaemo5ValueButton::ValueBesideText); + pickSelector_ = new QMaemo5TimePickSelector; + timeButton_->setPickSelector(pickSelector_); + themePicker_ = new ThemePicker(tr("Theme")); + + ButtonBox* buttons = new ButtonBox; + buttons->addButton(tr("Add"), this, SLOT(addScheduledTheme())); + + left->addWidget(timeButton_); + left->addWidget(themePicker_); + + layout->addLayout(left); + layout->addWidget(buttons); + + addDialog_->setLayout(layout); + + } + + pickSelector_->setCurrentTime(QTime::currentTime()); + addDialog_->show(); +} + +void ThemeSchedulerSettings::addScheduledTheme() +{ + QTime time = QTime::fromString(timeButton_->valueText(), TIME_FORMAT); + QString theme = themePicker_->value().toString(); + ThemeScheduler::instance().addItem(time, theme); + loadItems(); + addDialog_->hide(); +} + +void ThemeSchedulerSettings::clearScheduler() +{ + ThemeScheduler::instance().clear(); + loadItems(); +} + +void ThemeSchedulerSettings::loadItems() +{ + ThemeScheduler::instance().getItems(items_); + itemList_ = 0; + + if(currentWidget_) + { + layout_->removeWidget(currentWidget_); + delete currentWidget_; + currentWidget_ = 0; + } + + if(items_.isEmpty()) + { + QLabel* label = new QLabel(tr("There are currently no scheduled themes.")); + label->setWordWrap(true); + label->setAlignment(Qt::AlignLeft | Qt::AlignTop); + currentWidget_ = label; + layout_->addWidget(label); + } + else + { + itemList_ = new QListWidget; + itemList_->setContextMenuPolicy(Qt::CustomContextMenu); + connect(itemList_, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(showContextMenu(const QPoint&))); + + for(int i = 0; i < items_.size(); i++) + { + const QTime* endTime = 0; + + if(i < items_.size() - 1) + { + endTime = &(items_.at(i + 1).time); + } + else + { + endTime = &(items_.at(0).time); + } + + QString theme = items_.at(i).theme; + QString text = items_.at(i).time.toString(TIME_FORMAT) + " - " + + endTime->toString(TIME_FORMAT) + ": " + + theme.at(0).toUpper() + theme.mid(1); + QListWidgetItem* item = new QListWidgetItem(text); + item->setData(Qt::UserRole, items_.at(i).time.toString(TIME_FORMAT)); + itemList_->addItem(item); + } + + currentWidget_ = itemList_; + layout_->addWidget(itemList_); + } + + QApplication::processEvents(); + adjustSize(); + QApplication::processEvents(); + +} + +void ThemeSchedulerSettings::saveSettings() +{ + ThemeScheduler::instance().setEnabled(enabled_->isChecked()); + hide(); +} + +void ThemeSchedulerSettings::showContextMenu(QPoint const& point) +{ + if(!itemList_) + { + return; + } + + QMenu* menu = new QMenu(itemList_); + menu->addAction(tr("Remove"), this, SLOT(removeCurrent())); + connect(menu, SIGNAL(aboutToHide()), this, SLOT(removeSelection())); + menu->popup(itemList_->mapToGlobal(point)); +} + +void ThemeSchedulerSettings::removeCurrent() +{ + if(itemList_) + { + QListWidgetItem* item = itemList_->currentItem(); + + if(item) + { + ThemeScheduler::instance().removeItem(QTime::fromString(item->data(Qt::UserRole).toString(), TIME_FORMAT)); + loadItems(); + } + } +} + +void ThemeSchedulerSettings::removeSelection() +{ + if(itemList_) + { + itemList_->clearSelection(); + } +} diff --git a/src/themeschedulersettings.h b/src/themeschedulersettings.h new file mode 100644 index 0000000..c4a4fcd --- /dev/null +++ b/src/themeschedulersettings.h @@ -0,0 +1,62 @@ +/* + * This file is part of jSpeed. + * + * jSpeed is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * jSpeed is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with jSpeed. If not, see . + * + */ + +#ifndef THEMESCHEDULERSETTINGS_H +#define THEMESCHEDULERSETTINGS_H + +#include +#include "themescheduler.h" + +class QCheckBox; +class QScrollArea; +class QMaemo5ValueButton; +class QMaemo5TimePickSelector; +class QVBoxLayout; +class QListWidget; +class ThemePicker; + +class ThemeSchedulerSettings : public QDialog +{ + Q_OBJECT + +public: + ThemeSchedulerSettings(QWidget* parent = 0); + +private slots: + void openAddDialog(); + void addScheduledTheme(); + void clearScheduler(); + void saveSettings(); + void showContextMenu(QPoint const& point); + void removeCurrent(); + void removeSelection(); + +private: + void loadItems(); + QCheckBox* enabled_; + QVBoxLayout* layout_; + QWidget* currentWidget_; + QDialog* addDialog_; + QMaemo5TimePickSelector* pickSelector_; + QMaemo5ValueButton* timeButton_; + ThemePicker* themePicker_; + QList items_; + QListWidget* itemList_; +}; + +#endif diff --git a/src/themeselector.cpp b/src/themeselector.cpp index e66d925..9f377ac 100644 --- a/src/themeselector.cpp +++ b/src/themeselector.cpp @@ -27,31 +27,40 @@ #include #include #include "themeselector.h" -#include "buttonselector.h" +#include "themepicker.h" #include "themeloader.h" #include "settings.h" +#include "themeschedulersettings.h" -ThemeSelector::ThemeSelector(QWidget* parent): QDialog(parent) +ThemeSelector::ThemeSelector(QWidget* parent): QDialog(parent), themeScheduler_(0) { setWindowTitle(tr("Select theme")); QHBoxLayout* layout = new QHBoxLayout; - QHBoxLayout* left = new QHBoxLayout; + QVBoxLayout* left = new QVBoxLayout; + QHBoxLayout* first = new QHBoxLayout; QPushButton* saveButton = new QPushButton(tr("Save")); connect(saveButton, SIGNAL(clicked(bool)), this, SLOT(saveTheme())); QDialogButtonBox* buttons = new QDialogButtonBox; buttons->setCenterButtons(false); + buttons->setOrientation(Qt::Vertical); buttons->addButton(saveButton, QDialogButtonBox::AcceptRole); - selector_ = new ButtonSelector(tr("Theme"), this); + selector_ = new ThemePicker(tr("Theme"), this); theme_ = Settings::instance().value("theme", "default").toString(); QPushButton* loadButton = new QPushButton(tr("Import")); connect(loadButton, SIGNAL(clicked(bool)), this, SLOT(loadFromFile())); - left->addWidget(selector_, Qt::AlignLeft); - left->addWidget(loadButton); + QPushButton* scheduler = new QPushButton(tr("Theme scheduler")); + connect(scheduler, SIGNAL(clicked(bool)), this, SLOT(openScheduler())); + + first->addWidget(selector_, Qt::AlignLeft); + first->addWidget(loadButton); + + left->addLayout(first); + left->addWidget(scheduler); layout->addLayout(left, Qt::AlignLeft); layout->addWidget(buttons); @@ -78,115 +87,25 @@ void ThemeSelector::saveTheme() void ThemeSelector::loadFromFile() { - QString filename = QFileDialog::getOpenFileName(this, tr("Open file"), - QDir::home().path(), - tr("Theme files") + "(*" + ThemeLoader::getThemeSuffix() + ")"); - - if(filename.isEmpty()) - { - return; - } - - qDebug() << filename; - - QString basename; - int i = filename.lastIndexOf(QDir::separator()); - - if(i == -1) - { - basename = filename; - } - else - { - basename = filename.mid(i + 1); - } - - QString targetFile = ThemeLoader::getThemeDir() + basename; - - qDebug() << targetFile; - - bool ok = true; - - if(QFile::exists(targetFile)) - { - ok = confirmCopy(basename); - - if(ok) - { - QFile::remove(targetFile); - } - } - - if(ok) - { - QFile::copy(filename, targetFile); - QString name; - QString id; - getThemeDetails(basename, name, id); - theme_ = id; - loadThemes(); - } -} - -void ThemeSelector::loadThemes() -{ - selector_->clear(); - selector_->addItem(tr("Default"), "default"); - QDir themeDir(ThemeLoader::getThemeDir()); - - if(!themeDir.exists() || !themeDir.isReadable()) - { - qDebug() << "Warning: theme dir (" + ThemeLoader::getThemeDir() + ") doesn't exist or is read protected"; - return; - } + QString file; - QStringList filters; - filters << "*" + ThemeLoader::getThemeSuffix(); - themeDir.setNameFilters(filters); - themeDir.setFilter(QDir::Files); - QStringList files = themeDir.entryList(); - - for(int i = 0; i < files.size(); i++) + if(selector_->importFile(ThemeLoader::getThemeDir(), + "Theme files", + "*" + ThemeLoader::getThemeSuffix(), + false, + &file)) { - QString name; - QString id; - getThemeDetails(files.at(i), name, id); - selector_->addItem(name, id); - - if(id == theme_) - { - selector_->setCurrentIndex(i + 1); - } + selector_->loadThemes(); + selector_->selectTheme(file); } - -} - -void ThemeSelector::getThemeDetails(QString filename, - QString& name, - QString& id) -{ - static QRegExp cleaner(QRegExp::escape(ThemeLoader::getThemeSuffix()) + "$"); - filename = filename.replace(cleaner, ""); - - id = filename; - name = filename.at(0).toUpper() + filename.mid(1); -} - -bool ThemeSelector::confirmCopy(QString const& filename) -{ - QMessageBox::StandardButton result = QMessageBox::question(this, tr("File exists"), - tr("Theme file %1 already exists in theme directory, overwrite?").arg(filename), - QMessageBox::Yes | QMessageBox::No); - - return (result == QMessageBox::Yes); } -void ThemeSelector::setVisible(bool visible) +void ThemeSelector::openScheduler() { - if(visible) + if(!themeScheduler_) { - loadThemes(); + themeScheduler_ = new ThemeSchedulerSettings(this); } - QDialog::setVisible(visible); + themeScheduler_->show(); } diff --git a/src/themeselector.h b/src/themeselector.h index 7d29ac8..ec5f943 100644 --- a/src/themeselector.h +++ b/src/themeselector.h @@ -22,7 +22,8 @@ #include class QString; -class ButtonSelector; +class ThemePicker; +class ThemeSchedulerSettings; class ThemeSelector : public QDialog { @@ -37,16 +38,12 @@ signals: private slots: void saveTheme(); void loadFromFile(); - -protected: - virtual void setVisible(bool visible); + void openScheduler(); private: - void loadThemes(); - void getThemeDetails(QString filename, QString& name, QString& id); - bool confirmCopy(QString const& name); - ButtonSelector* selector_; + ThemePicker* selector_; QString theme_; + ThemeSchedulerSettings* themeScheduler_; }; diff --git a/src/unitselector.cpp b/src/unitselector.cpp index 90cadfa..61a0fb8 100644 --- a/src/unitselector.cpp +++ b/src/unitselector.cpp @@ -23,6 +23,7 @@ #include "unitselector.h" #include "buttonselector.h" #include "settings.h" +#include "buttonbox.h" UnitSelector::UnitSelector(QWidget* parent): QDialog(parent) { @@ -44,11 +45,8 @@ UnitSelector::UnitSelector(QWidget* parent): QDialog(parent) layout->addWidget(selector_, Qt::AlignLeft); - QPushButton* button = new QPushButton(tr("Save")); - connect(button, SIGNAL(clicked(bool)), this, SLOT(saveUnit())); - QDialogButtonBox* buttons = new QDialogButtonBox; - buttons->setCenterButtons(false); - buttons->addButton(button, QDialogButtonBox::AcceptRole); + ButtonBox* buttons = new ButtonBox; + buttons->addButton(tr("Save"), this, SLOT(saveUnit())); layout->addWidget(buttons); -- 1.7.9.5