namespace
{
QString const FONT = "Tahoma";
- QString const BACKGROUND = ":/resources/themes/default/background.png";
+ QString const DEFAULT_BACKGROUND_COLOR = "#000";
+ QString const DEFAULT_COLOR = "#fff";
int const FONT_SIZE = 20;
int const START_HEIGHT = 80;
int const ITEM_WIDTH = 130;
+
}
-DetailScreen::DetailScreen(QWidget* parent): GraphicsScreen(parent)
+DetailScreen::DetailScreen(QWidget* parent): ThemeScreen(parent)
{
QString unit = Odometer::getUnit();
QString speedUnit = Odometer::getSpeedUnit();
- QGraphicsPixmapItem* background = new QGraphicsPixmapItem(QPixmap(BACKGROUND));
- getScene()->addItem(background);
+ getScene()->setBackgroundBrush(QBrush(QColor(DEFAULT_BACKGROUND_COLOR)));
tripLabel_ = createItem(tr("Trip"));
trip_ = createItem(roundDouble(Odometer::instance().getTrip()));
strength_ = new QGraphicsPixmapItem;
currentStrength_ = getStrength();
strength_->setPixmap(QPixmap(":/resources/signal_" + QString::number(currentStrength_) + ".png"));
+ strength_->setZValue(999);
getScene()->addItem(strength_);
connect(&(Odometer::instance()), SIGNAL(timeUpdated()), this, SLOT(updateTime()));
void DetailScreen::update()
{
+ ThemeScreen::update();
+
speed_->setPlainText(roundDouble(Odometer::instance().getLatestFix().speed));
trip_->setPlainText(roundDouble(Odometer::instance().getTrip()));
total_->setPlainText(roundDouble(Odometer::instance().getTotal()));
void DetailScreen::reArrange()
{
- GraphicsScreen::reArrange();
+ ThemeScreen::reArrange();
int width = getScene()->width();
int height = getScene()->height();
QFont font(FONT, FONT_SIZE);
font.setBold(true);
item->setFont(font);
- item->setDefaultTextColor(QColor("#fff"));
+ item->setDefaultTextColor(QColor(DEFAULT_COLOR));
+ item->setZValue(999);
getScene()->addItem(item);
return item;
}
QGraphicsLineItem* DetailScreen::createLine()
{
QGraphicsLineItem* item = new QGraphicsLineItem;
- QPen pen(QColor("#ddd"));
- pen.setWidth(1);
- item->setPen(pen);
+ QColor pColor(DEFAULT_COLOR);
+ QPen p(pColor);
+ p.setWidth(1);
+ item->setPen(p);
+ item->setZValue(999);
getScene()->addItem(item);
return item;
}
double strength = round(Odometer::instance().getSignalStrength() / 25.0);
return static_cast<int>(strength);
}
+
+void DetailScreen::setColor(QString const& color)
+{
+ QColor c(color);
+
+ tripLabel_->setDefaultTextColor(c);
+ trip_->setDefaultTextColor(c);
+ tripUnit_->setDefaultTextColor(c);
+ totalLabel_->setDefaultTextColor(c);
+ total_->setDefaultTextColor(c);
+ totalUnit_->setDefaultTextColor(c);
+ speedLabel_->setDefaultTextColor(c);
+ speed_->setDefaultTextColor(c);
+ speedUnit_->setDefaultTextColor(c);
+ avgSpeedLabel_->setDefaultTextColor(c);
+ avgSpeed_->setDefaultTextColor(c);
+ avgSpeedUnit_->setDefaultTextColor(c);
+ maxSpeedLabel_->setDefaultTextColor(c);
+ maxSpeed_->setDefaultTextColor(c);
+ maxSpeedUnit_->setDefaultTextColor(c);
+ tripTimeLabel_->setDefaultTextColor(c);
+ tripTime_->setDefaultTextColor(c);
+ totalTimeLabel_->setDefaultTextColor(c);
+ totalTime_->setDefaultTextColor(c);
+
+ QPen p(c);
+ p.setWidth(1);
+
+ line1_->setPen(p);
+ line2_->setPen(p);
+}
#ifndef DETAILSCREEN_H
#define DETAILSCREEN_H
-#include "graphicsscreen.h"
+#include "themescreen.h"
class QString;
class QGraphicsTextItem;
class QGraphicsLineItem;
class QGraphicsPixmapItem;
-class DetailScreen : public GraphicsScreen
+class DetailScreen : public ThemeScreen
{
Q_OBJECT
public:
DetailScreen(QWidget* parent = 0);
+ void setColor(QString const& color);
public slots:
virtual void update();
{
screen_->flip();
}
+
+DetailScreen* DetailWidget::getScreen() const
+{
+ return screen_;
+}
public:
DetailWidget(QWidget* parent = 0);
+ DetailScreen* getScreen() const;
public slots:
virtual void update();
class QString;
class QByteArray;
class QFont;
+class QGraphicsItem;
class GraphicsScene;
class Reader;
virtual bool setAttribute(QString const& name, QString const& value) = 0;
virtual void addToScene(GraphicsScene* scene) = 0;
virtual void update() = 0;
+ virtual QGraphicsItem* getElement() const = 0;
QString const& getError() const;
protected:
namespace
{
- int const PADDING = 8;
+ int const PADDING = 6;
}
GraphicsScreen::GraphicsScreen(QWidget* parent): QGraphicsView(parent),
return true;
}
+
+QGraphicsItem* ImageElement::getElement() const
+{
+ return element_;
+}
class QString;
class QGraphicsPixmapItem;
+class QGraphicsItem;
class Reader;
class GraphicsScene;
virtual bool setAttribute(QString const& name, QString const& value);
virtual void addToScene(GraphicsScene* scene);
virtual void update();
+ virtual QGraphicsItem* getElement() const;
private:
bool loadImage(QString const& name);
{
if(!hasFix())
{
- qDebug() << "No fix";
return 0.0;
}
#include "mainwindowstack.h"
#include "theme.h"
#include "detailwidget.h"
+#include "detailscreen.h"
#include "mainmenu.h"
#include "odometer.h"
connect(stack_, SIGNAL(settingsPressed()), this, SLOT(openMenu()));
connect(stack_, SIGNAL(closePressed()), this, SIGNAL(quit()));
- theme_ = new Theme;
+ DetailWidget* details = new DetailWidget(this);
+
+ theme_ = new Theme(details->getScreen());
if(!loadTheme())
{
}
stack_->addScreen(theme_);
- stack_->addScreen(new DetailWidget(this));
+ stack_->addScreen(details);
connect(QApplication::desktop(), SIGNAL(resized(int)), stack_, SLOT(reArrange()));
{
setAttribute(Qt::WA_Maemo5PortraitOrientation, true);
}
+ else
+ {
+ setAttribute(Qt::WA_Maemo5LandscapeOrientation, true);
+ }
return true;
}
QString const MILE_UNIT = "mi";
QString const KM_SPEEDUNIT = "km/h";
QString const MILE_SPEEDUNIT = "mph";
+ static const int FIX_TIMEOUT = 4000;
double const DEFAULT_SPEED_TRESHOLD = 8.0;
double const MIN_SPEED_TRESHOLD = 0.8;
double const SPEED_IGNORE_LEVEL = 0.01;
signalTimer_->setInterval(1000);
connect(signalTimer_, SIGNAL(timeout()), this, SIGNAL(timeUpdated()));
updateUnit();
+ timeoutTimer_ = new QTimer(this);
+ timeoutTimer_->setSingleShot(true);
+ connect(timeoutTimer_, SIGNAL(timeout()), this, SLOT(fixTimeout()));
+
}
Odometer::~Odometer()
int elapsed = fixTimer_->elapsed();
fixTimer_->restart();
+ timeoutTimer_->start(FIX_TIMEOUT);
if(fix.kmSpeed > SPEED_IGNORE_LEVEL)
{
}
}
- if(fix.kmSpeed > treshold && elapsed > 200 && elapsed < 8000)
+ if(fix.kmSpeed > treshold && elapsed > 200 && elapsed < FIX_TIMEOUT)
{
double km = fix.kmSpeed * (static_cast<double>(elapsed) / (1000 * 3600));
trip_ += km;
}
else
{
- if(latestFix_.kmSpeed > SPEED_IGNORE_LEVEL)
- {
- latestFix_ = fix;
- latestFix_.speed = 0.0;
- latestFix_.kmSpeed = 0.0;
- emit dataUpdated();
- }
+ fixTimeout();
+ }
+}
- endTiming();
+void Odometer::fixTimeout()
+{
+ if(latestFix_.kmSpeed > SPEED_IGNORE_LEVEL)
+ {
+ latestFix_ = Location::Fix();
+ emit dataUpdated();
}
+
+ endTiming();
}
double Odometer::getTrip() const
static QString const& getUnit();
static QString const& getSpeedUnit();
-public slots:
- void update(Location::Fix const& fix);
- void updateUnit();
-
signals:
void dataUpdated();
void timeUpdated();
void unitChanged();
public slots:
+ void update(Location::Fix const& fix);
+ void updateUnit();
void resetTrip();
void resetTotal();
void resetAll();
void store();
+private slots:
+ void fixTimeout();
+
private:
Q_DISABLE_COPY(Odometer);
Odometer();
bool emitUpdate_;
Location* location_;
QTimer* signalTimer_;
+ QTimer* timeoutTimer_;
};
#endif
return true;
}
+
+QGraphicsItem* Pointer::getElement() const
+{
+ return element_;
+}
+
class QGraphicsPixmapItem;
class QTimeLine;
+class QGraphicsItem;
class GraphicsScene;
class Reader;
virtual bool setAttribute(QString const& name, QString const& value);
virtual void addToScene(GraphicsScene* scene);
virtual void update();
+ virtual QGraphicsItem* getElement() const;
private slots:
void setFrame(int frame);
void Rectangle::update()
{
}
+
+QGraphicsItem* Rectangle::getElement() const
+{
+ return element_;
+}
class QString;
class QGraphicsRectItem;
+class QGraphicsItem;
class Reader;
class GraphicsScene;
virtual bool setAttribute(QString const& name, QString const& value);
virtual void addToScene(GraphicsScene* scene);
virtual void update();
+ virtual QGraphicsItem* getElement() const;
private:
QGraphicsRectItem* element_;
-<theme>
+<theme>
+<detailscreen color="#fff">
+ <image>
+ <xpos>0</xpos>
+ <ypos>0</ypos>
+ <src>background.png</src>
+ </image>
+</detailscreen>
<orientation name="landscape">
<image>
<xpos>0</xpos>
#include <QtCore/QString>
#include <QtCore/QDebug>
+#include <QtCore/QTime>
#include <QtGui/QGraphicsScene>
#include <QtGui/QGraphicsTextItem>
#include "textelement.h"
const QString FIELDS[TextElement::FIELD_COUNT] = {"TRIP", "TOTAL", "SPEED",
"MAXSPEED", "AVGSPEED",
- "UNIT", "SPEEDUNIT"};
+ "UNIT", "SPEEDUNIT", "TIME"};
}
TextElement::TextElement(Reader* reader): GraphicsElement(reader),
case SPEEDUNIT:
replaceValue(value, f, o->getSpeedUnit());
break;
+ case TIME:
+ replaceValue(value, f, QTime::currentTime().toString("hh:mm"));
+ break;
default:
qDebug() << "Unknown field: " << f;
}
return result;
}
+
+
+QGraphicsItem* TextElement::getElement() const
+{
+ return element_;
+}
#include "graphicselement.h"
-class Reader;
class QString;
-class GraphicsScene;
+class QGraphicsItem;
class QGraphicsTextItem;
+class Reader;
+class GraphicsScene;
class TextElement : public GraphicsElement
{
public:
enum Attribute {XPOS, YPOS, DATA, FORMAT, WIDTH, ALIGN, COLOR, SIZE, FONT, ATTRIBUTE_COUNT};
- enum Field {TRIP, TOTAL, SPEED, MAXSPEED, AVGSPEED, UNIT, SPEEDUNIT, FIELD_COUNT};
+ enum Field {TRIP, TOTAL, SPEED, MAXSPEED, AVGSPEED, UNIT, SPEEDUNIT, TIME, FIELD_COUNT};
TextElement(Reader* reader);
virtual bool setAttribute(QString const& name, QString const& value);
virtual void addToScene(GraphicsScene* scene);
virtual void update();
+ virtual QGraphicsItem* getElement() const;
private:
void updateHtml(QString const& data);
#include "zipreader.h"
#include "filereader.h"
#include "themescreen.h"
+#include "detailscreen.h"
#include "settings.h"
namespace
QString const THEME_SUFFIX = ".jspeed";
}
-Theme::Theme(QWidget* parent): WidgetScreen(parent),
+Theme::Theme(DetailScreen* detailScreen, QWidget* parent): WidgetScreen(parent),
portraitId_(-1), landscapeId_(-1), reader_(0),
-portrait_(0), landscape_(0), portraitMode_(false)
+portrait_(0), landscape_(0), detailScreen_(detailScreen), portraitMode_(false)
{
}
if(read())
{
- qDebug() << "Ladattiin " << theme;
return true;
}
else
return false;
}
+ QDomNodeList detailConfigs = doc.elementsByTagName("detailscreen");
+
+ if(detailConfigs.size() > 1)
+ {
+ error_ = "Multiple <detailscreen> tags specified";
+ return false;
+ }
+
+ if(detailConfigs.size() == 1)
+ {
+ detailScreen_->removeElements();
+
+ QDomNode color = detailConfigs.at(0).attributes().namedItem("color");
+
+ if(!color.isNull())
+ {
+ detailScreen_->setColor(color.toAttr().value());
+ }
+
+ detailScreen_->load(detailConfigs.at(0), reader_);
+ }
+
QDomNodeList orientations = doc.elementsByTagName("orientation");
if(orientations.isEmpty())
portraitId_ = addWidget(portrait_);
connectSignals(portrait_);
}
+
+ if(landscape_ && portrait_)
+ {
+ QRect rect = QApplication::desktop()->screenGeometry();
+
+ if(rect.height() > rect.width())
+ {
+ setCurrentIndex(portraitId_);
+ portraitMode_ = true;
+ }
+ else
+ {
+ setCurrentIndex(landscapeId_);
+ portraitMode_ = false;
+ }
+ }
}
else
{
bool Theme::portraitEnabled() const
{
- return portraitId_ != -1;
+ return portrait_ != 0;
}
bool Theme::landscapeEnabled() const
{
- return landscapeId_ != -1;
+ return landscape_ != 0;
}
void Theme::reArrange()
class QString;
class Reader;
class ThemeScreen;
+class DetailScreen;
class Theme : public WidgetScreen
{
Q_OBJECT
public:
- Theme(QWidget* parent = 0);
+ Theme(DetailScreen* detailScreen, QWidget* parent = 0);
~Theme();
bool load();
bool portraitEnabled() const;
QString error_;
ThemeScreen* portrait_;
ThemeScreen* landscape_;
+ DetailScreen* detailScreen_;
bool portraitMode_;
};
*/
#include <QtGui/QWidget>
+#include <QtGui/QGraphicsItem>
#include <QtCore/QString>
#include <QtCore/QDebug>
#include <QtXml/QDomNode>
#include "themescreen.h"
#include "graphicselement.h"
#include "reader.h"
+#include "graphicsscene.h"
ThemeScreen::ThemeScreen(QWidget* parent): GraphicsScreen(parent)
{
return true;
}
+void ThemeScreen::removeElements()
+{
+ for(int i = 0; i < elements_.size(); i++)
+ {
+ QGraphicsItem* item = elements_.at(i)->getElement();
+
+ if(item)
+ {
+ getScene()->removeItem(item);
+ delete item;
+ }
+
+ delete elements_.at(i);
+ }
+
+ elements_.clear();
+}
+
void ThemeScreen::update()
{
for(int i = 0; i < elements_.size(); i++)
ThemeScreen(QWidget* parent = 0);
bool load(QDomNode const& data, Reader* reader);
virtual void update();
+ void removeElements();
private:
QList<GraphicsElement*> elements_;