Initial commit

32 files changed, 4653 insertions, 0 deletions

diff --git a/src/ChatPage.cc b/src/ChatPage.cc
new file mode 100644
index 00000000..a17e8c65
--- /dev/null
+++ b/src/ChatPage.cc
@@ -0,0 +1,277 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ui_ChatPage.h"
+
+#include <QDebug>
+#include <QLabel>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSettings>
+#include <QWidget>
+
+#include "ChatPage.h"
+#include "Sync.h"
+#include "UserInfoWidget.h"
+
+ChatPage::ChatPage(QWidget *parent)
+    : QWidget(parent)
+    , ui(new Ui::ChatPage)
+    , sync_interval_(2000)
+{
+	ui->setupUi(this);
+	matrix_client_ = new MatrixClient("matrix.org", parent);
+	content_downloader_ = new QNetworkAccessManager(parent);
+
+	room_list_ = new RoomList(this);
+
+	top_bar_ = new TopRoomBar(this);
+	ui->topBarLayout->addWidget(top_bar_);
+
+	view_manager_ = new HistoryViewManager(this);
+	ui->mainContentLayout->addWidget(view_manager_);
+
+	text_input_ = new TextInputWidget(this);
+	ui->contentLayout->addWidget(text_input_);
+
+	user_info_widget_ = new UserInfoWidget(ui->sideBarTopWidget);
+
+	connect(room_list_,
+		SIGNAL(roomChanged(const RoomInfo &)),
+		this,
+		SLOT(changeTopRoomInfo(const RoomInfo &)));
+
+	connect(room_list_,
+		SIGNAL(roomChanged(const RoomInfo &)),
+		view_manager_,
+		SLOT(setHistoryView(const RoomInfo &)));
+
+	connect(room_list_,
+		SIGNAL(fetchRoomAvatar(const QString &, const QUrl &)),
+		this,
+		SLOT(fetchRoomAvatar(const QString &, const QUrl &)));
+
+	connect(text_input_,
+		SIGNAL(sendTextMessage(const QString &)),
+		this,
+		SLOT(sendTextMessage(const QString &)));
+
+	ui->sideBarTopUserInfoLayout->addWidget(user_info_widget_);
+	ui->sideBarMainLayout->addWidget(room_list_);
+
+	connect(matrix_client_,
+		SIGNAL(initialSyncCompleted(SyncResponse)),
+		this,
+		SLOT(initialSyncCompleted(SyncResponse)));
+	connect(matrix_client_,
+		SIGNAL(syncCompleted(SyncResponse)),
+		this,
+		SLOT(syncCompleted(SyncResponse)));
+	connect(matrix_client_,
+		SIGNAL(getOwnProfileResponse(QUrl, QString)),
+		this,
+		SLOT(updateOwnProfileInfo(QUrl, QString)));
+	connect(matrix_client_,
+		SIGNAL(messageSent(QString, int)),
+		this,
+		SLOT(messageSent(QString, int)));
+}
+
+void ChatPage::messageSent(QString event_id, int txn_id)
+{
+	Q_UNUSED(event_id);
+
+	QSettings settings;
+	settings.setValue("client/transaction_id", txn_id + 1);
+}
+
+void ChatPage::sendTextMessage(const QString &msg)
+{
+	auto room = current_room_;
+	matrix_client_->sendTextMessage(current_room_.id(), msg);
+}
+
+void ChatPage::bootstrap(QString userid, QString homeserver, QString token)
+{
+	Q_UNUSED(userid);
+
+	matrix_client_->setServer(homeserver);
+	matrix_client_->setAccessToken(token);
+
+	matrix_client_->getOwnProfile();
+	matrix_client_->initialSync();
+}
+
+void ChatPage::startSync()
+{
+	matrix_client_->sync();
+}
+
+void ChatPage::setOwnAvatar(QByteArray img)
+{
+	if (img.size() == 0)
+		return;
+
+	QPixmap pixmap;
+	pixmap.loadFromData(img);
+	user_info_widget_->setAvatar(pixmap.toImage());
+}
+
+void ChatPage::syncCompleted(SyncResponse response)
+{
+	matrix_client_->setNextBatchToken(response.nextBatch());
+
+	/* room_list_->sync(response.rooms()); */
+	view_manager_->sync(response.rooms());
+}
+
+void ChatPage::initialSyncCompleted(SyncResponse response)
+{
+	if (!response.nextBatch().isEmpty())
+		matrix_client_->setNextBatchToken(response.nextBatch());
+
+	view_manager_->initialize(response.rooms());
+	room_list_->setInitialRooms(response.rooms());
+
+	sync_timer_ = new QTimer(this);
+	connect(sync_timer_, SIGNAL(timeout()), this, SLOT(startSync()));
+	sync_timer_->start(sync_interval_);
+}
+
+// TODO: This function should be part of the matrix client for generic media retrieval.
+void ChatPage::fetchRoomAvatar(const QString &roomid, const QUrl &avatar_url)
+{
+	// TODO: move this into a Utils function
+	QList<QString> url_parts = avatar_url.toString().split("mxc://");
+
+	if (url_parts.size() != 2) {
+		qDebug() << "Invalid format for room avatar " << avatar_url.toString();
+		return;
+	}
+
+	QString media_params = url_parts[1];
+	QString media_url = QString("%1/_matrix/media/r0/download/%2")
+				    .arg(matrix_client_->getHomeServer(), media_params);
+
+	QNetworkRequest avatar_request(media_url);
+	QNetworkReply *reply = content_downloader_->get(avatar_request);
+	reply->setProperty("media_params", media_params);
+
+	connect(reply, &QNetworkReply::finished, [this, media_params, roomid, reply]() {
+		reply->deleteLater();
+
+		auto media = reply->property("media_params").toString();
+
+		if (media != media_params)
+			return;
+
+		int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+		if (status == 0) {
+			qDebug() << reply->errorString();
+			return;
+		}
+
+		if (status >= 400) {
+			qWarning() << "Request " << reply->request().url() << " returned " << status;
+			return;
+		}
+
+		auto img = reply->readAll();
+
+		if (img.size() == 0)
+			return;
+
+		QPixmap pixmap;
+		pixmap.loadFromData(img);
+		room_avatars_.insert(roomid, pixmap);
+
+		this->room_list_->updateRoomAvatar(roomid, pixmap.toImage());
+
+		if (current_room_.id() == roomid) {
+			QIcon icon(pixmap);
+			this->top_bar_->updateRoomAvatar(icon);
+		}
+	});
+}
+
+void ChatPage::updateOwnProfileInfo(QUrl avatar_url, QString display_name)
+{
+	QSettings settings;
+	auto userid = settings.value("auth/user_id").toString();
+
+	user_info_widget_->setUserId(userid);
+	user_info_widget_->setDisplayName(display_name);
+
+	// TODO: move this into a Utils function
+	QList<QString> url_parts = avatar_url.toString().split("mxc://");
+
+	if (url_parts.size() != 2) {
+		qDebug() << "Invalid format for media " << avatar_url.toString();
+		return;
+	}
+
+	QString media_params = url_parts[1];
+	QString media_url = QString("%1/_matrix/media/r0/download/%2")
+				    .arg(matrix_client_->getHomeServer(), media_params);
+
+	QNetworkRequest avatar_request(media_url);
+	QNetworkReply *reply = content_downloader_->get(avatar_request);
+	reply->setProperty("media_params", media_params);
+
+	connect(reply, &QNetworkReply::finished, [this, media_params, reply]() {
+		reply->deleteLater();
+
+		auto media = reply->property("media_params").toString();
+
+		if (media != media_params)
+			return;
+
+		int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+		if (status == 0) {
+			qDebug() << reply->errorString();
+			return;
+		}
+
+		if (status >= 400) {
+			qWarning() << "Request " << reply->request().url() << " returned " << status;
+			return;
+		}
+
+		setOwnAvatar(reply->readAll());
+	});
+}
+
+void ChatPage::changeTopRoomInfo(const RoomInfo &info)
+{
+	top_bar_->updateRoomName(info.name());
+	top_bar_->updateRoomTopic(info.topic());
+
+	if (room_avatars_.contains(info.id())) {
+		QIcon icon(room_avatars_.value(info.id()));
+		top_bar_->updateRoomAvatar(icon);
+	}
+
+	current_room_ = info;
+}
+
+ChatPage::~ChatPage()
+{
+	sync_timer_->stop();
+	delete ui;
+}
diff --git a/src/Deserializable.cc b/src/Deserializable.cc
new file mode 100644
index 00000000..967f5ef4
--- /dev/null
+++ b/src/Deserializable.cc
@@ -0,0 +1,31 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+
+#include "Deserializable.h"
+
+DeserializationException::DeserializationException(const std::string &msg) : msg_(msg)
+{
+}
+
+const char *DeserializationException::what() const throw()
+{
+	return msg_.c_str();
+}
diff --git a/src/HistoryView.cc b/src/HistoryView.cc
new file mode 100644
index 00000000..0949d17c
--- /dev/null
+++ b/src/HistoryView.cc
@@ -0,0 +1,145 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <random>
+
+#include <QDebug>
+#include <QScrollBar>
+#include <QtWidgets/QLabel>
+#include <QtWidgets/QSpacerItem>
+
+#include "HistoryView.h"
+#include "HistoryViewItem.h"
+
+const QList<QString> HistoryView::COLORS({"#FFF46E",
+					  "#A58BFF",
+					  "#50C9BA",
+					  "#9EE6CF",
+					  "#FFDD67",
+					  "#2980B9",
+					  "#FC993C",
+					  "#2772DB",
+					  "#CB8589",
+					  "#DDE8B9",
+					  "#55A44E",
+					  "#A9EEE6",
+					  "#53B759",
+					  "#9E3997",
+					  "#5D89D5",
+					  "#BB86B7",
+					  "#50a0cf",
+					  "#3C989F",
+					  "#5A4592",
+					  "#235e5b",
+					  "#d58247",
+					  "#e0a729",
+					  "#a2b636",
+					  "#4BBE2E"});
+
+HistoryView::HistoryView(QList<Event> events, QWidget *parent)
+    : QWidget(parent)
+{
+	init();
+	addEvents(events);
+}
+
+HistoryView::HistoryView(QWidget *parent)
+    : QWidget(parent)
+{
+	init();
+}
+
+void HistoryView::sliderRangeChanged(int min, int max)
+{
+	Q_UNUSED(min);
+	scroll_area_->verticalScrollBar()->setValue(max);
+}
+
+QString HistoryView::chooseRandomColor()
+{
+	std::random_device random_device;
+	std::mt19937 engine{random_device()};
+	std::uniform_int_distribution<int> dist(0, HistoryView::COLORS.size() - 1);
+
+	return HistoryView::COLORS[dist(engine)];
+}
+
+void HistoryView::addEvents(const QList<Event> &events)
+{
+	for (int i = 0; i < events.size(); i++) {
+		auto event = events[i];
+
+		if (event.type() == "m.room.message") {
+			auto msg_type = event.content().value("msgtype").toString();
+
+			if (msg_type == "m.text" || msg_type == "m.notice") {
+				auto with_sender = last_sender_ != event.sender();
+				auto color = nick_colors_.value(event.sender());
+
+				if (color.isEmpty()) {
+					color = chooseRandomColor();
+					nick_colors_.insert(event.sender(), color);
+				}
+
+				addHistoryItem(event, color, with_sender);
+				last_sender_ = event.sender();
+			} else {
+				qDebug() << "Ignoring message" << msg_type;
+			}
+		}
+	}
+}
+
+void HistoryView::init()
+{
+	top_layout_ = new QVBoxLayout(this);
+	top_layout_->setSpacing(0);
+	top_layout_->setMargin(0);
+
+	scroll_area_ = new QScrollArea(this);
+	scroll_area_->setWidgetResizable(true);
+
+	scroll_widget_ = new QWidget();
+
+	scroll_layout_ = new QVBoxLayout();
+	scroll_layout_->addStretch(1);
+	scroll_layout_->setSpacing(0);
+
+	scroll_widget_->setLayout(scroll_layout_);
+
+	scroll_area_->setWidget(scroll_widget_);
+
+	top_layout_->addWidget(scroll_area_);
+
+	setLayout(top_layout_);
+
+	connect(scroll_area_->verticalScrollBar(),
+		SIGNAL(rangeChanged(int, int)),
+		this,
+		SLOT(sliderRangeChanged(int, int)));
+}
+
+void HistoryView::addHistoryItem(Event event, QString color, bool with_sender)
+{
+	// TODO: Probably create another function instead of passing the flag.
+	HistoryViewItem *item = new HistoryViewItem(event, with_sender, color, scroll_widget_);
+	scroll_layout_->addWidget(item);
+}
+
+HistoryView::~HistoryView()
+{
+}
diff --git a/src/HistoryViewItem.cc b/src/HistoryViewItem.cc
new file mode 100644
index 00000000..04c42f45
--- /dev/null
+++ b/src/HistoryViewItem.cc
@@ -0,0 +1,80 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDateTime>
+#include <QDebug>
+
+#include "HistoryViewItem.h"
+
+HistoryViewItem::HistoryViewItem(Event event, bool with_sender, QString color, QWidget *parent)
+    : QWidget(parent)
+{
+	QString sender = "";
+
+	if (with_sender)
+		sender = event.sender().split(":")[0].split("@")[1];
+
+	auto body = event.content().value("body").toString();
+
+	auto timestamp = QDateTime::fromMSecsSinceEpoch(event.timestamp());
+	auto local_time = timestamp.toString("HH:mm");
+
+	time_label_ = new QLabel(this);
+	time_label_->setWordWrap(true);
+	QString msg(
+		"<html>"
+		"<head/>"
+		"<body>"
+		"   <span style=\"font-size: 7pt; color: #5d6565;\">"
+		"   %1"
+		"   </span>"
+		"</body>"
+		"</html>");
+	time_label_->setText(msg.arg(local_time));
+	time_label_->setStyleSheet("margin-left: 7px; margin-right: 7px; margin-top: 0;");
+	time_label_->setAlignment(Qt::AlignTop);
+
+	content_label_ = new QLabel(this);
+	content_label_->setWordWrap(true);
+	content_label_->setAlignment(Qt::AlignTop);
+	content_label_->setStyleSheet("margin: 0;");
+	QString content(
+		"<html>"
+		"<head/>"
+		"<body>"
+		"   <span style=\"font-size: 10pt; font-weight: 600; color: %1\">"
+		"   %2"
+		"   </span>"
+		"   <span style=\"font-size: 10pt;\">"
+		"   %3"
+		"   </span>"
+		"</body>"
+		"</html>");
+	content_label_->setText(content.arg(color).arg(sender).arg(body));
+
+	top_layout_ = new QHBoxLayout();
+	top_layout_->setMargin(0);
+
+	top_layout_->addWidget(time_label_);
+	top_layout_->addWidget(content_label_, 1);
+
+	setLayout(top_layout_);
+}
+
+HistoryViewItem::~HistoryViewItem()
+{
+}
diff --git a/src/HistoryViewManager.cc b/src/HistoryViewManager.cc
new file mode 100644
index 00000000..c7292747
--- /dev/null
+++ b/src/HistoryViewManager.cc
@@ -0,0 +1,83 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QStackedWidget>
+#include <QWidget>
+
+#include "HistoryView.h"
+#include "HistoryViewManager.h"
+
+HistoryViewManager::HistoryViewManager(QWidget *parent)
+    : QStackedWidget(parent)
+{
+	setStyleSheet(
+		"QWidget {background: #171919; color: #ebebeb;}"
+		"QScrollBar:vertical { background-color: #171919; width: 10px; border-radius: 20px; margin: 0px 2px 0 2px; }"
+		"QScrollBar::handle:vertical { border-radius : 50px; background-color : #1c3133; }"
+		"QScrollBar::add-line:vertical { border: none; background: none; }"
+		"QScrollBar::sub-line:vertical { border: none; background: none; }");
+}
+
+HistoryViewManager::~HistoryViewManager()
+{
+}
+
+void HistoryViewManager::initialize(const Rooms &rooms)
+{
+	for (auto it = rooms.join().constBegin(); it != rooms.join().constEnd(); it++) {
+		auto roomid = it.key();
+		auto events = it.value().timeline().events();
+
+		// Create a history view with the room events.
+		HistoryView *view = new HistoryView(events);
+		views_.insert(it.key(), view);
+
+		// Add the view in the widget stack.
+		addWidget(view);
+	}
+}
+
+void HistoryViewManager::sync(const Rooms &rooms)
+{
+	for (auto it = rooms.join().constBegin(); it != rooms.join().constEnd(); it++) {
+		auto roomid = it.key();
+
+		if (!views_.contains(roomid)) {
+			qDebug() << "Ignoring event from unknown room";
+			continue;
+		}
+
+		auto view = views_.value(roomid);
+		auto events = it.value().timeline().events();
+
+		view->addEvents(events);
+	}
+}
+
+void HistoryViewManager::setHistoryView(const RoomInfo &info)
+{
+	if (!views_.contains(info.id())) {
+		qDebug() << "Room List id is not present in view manager";
+		qDebug() << info.name();
+		return;
+	}
+
+	auto widget = views_.value(info.id());
+
+	setCurrentWidget(widget);
+}
diff --git a/src/InputValidator.cc b/src/InputValidator.cc
new file mode 100644
index 00000000..3713c501
--- /dev/null
+++ b/src/InputValidator.cc
@@ -0,0 +1,31 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "InputValidator.h"
+
+// FIXME: Maybe change the regex to match the real Matrix ID format and not email.
+InputValidator::InputValidator(QObject *parent)
+    : matrix_id_("[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,6}")
+    , matrix_localpart_("[A-za-z0-9._%+-]{3,}")
+    , matrix_password_(".{8,}")
+    , server_domain_("(?!\\-)(?:[a-zA-Z\\d\\-]{0,62}[a-zA-Z\\d]\\.){1,126}(?!\\d+)[a-zA-Z\\d]{1,63}")
+{
+	id_ = new QRegExpValidator(matrix_id_, parent);
+	localpart_ = new QRegExpValidator(matrix_localpart_, parent);
+	password_ = new QRegExpValidator(matrix_password_, parent);
+	domain_ = new QRegExpValidator(server_domain_, parent);
+}
diff --git a/src/Login.cc b/src/Login.cc
new file mode 100644
index 00000000..f3b8e2f4
--- /dev/null
+++ b/src/Login.cc
@@ -0,0 +1,89 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+
+#include "Deserializable.h"
+#include "Login.h"
+
+LoginRequest::LoginRequest()
+{
+}
+
+LoginRequest::LoginRequest(QString username, QString password)
+    : user_(username)
+    , password_(password)
+{
+}
+
+QByteArray LoginRequest::serialize()
+{
+	QJsonObject body{
+		{"type", "m.login.password"},
+		{"user", user_},
+		{"password", password_}};
+
+	return QJsonDocument(body).toJson(QJsonDocument::Compact);
+}
+
+void LoginRequest::setPassword(QString password)
+{
+	password_ = password;
+}
+
+void LoginRequest::setUser(QString username)
+{
+	user_ = username;
+}
+
+QString LoginResponse::getAccessToken()
+{
+	return access_token_;
+}
+
+QString LoginResponse::getHomeServer()
+{
+	return home_server_;
+}
+
+QString LoginResponse::getUserId()
+{
+	return user_id_;
+}
+
+void LoginResponse::deserialize(QJsonDocument data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Login response is not a JSON object");
+
+	QJsonObject object = data.object();
+
+	if (object.value("access_token") == QJsonValue::Undefined)
+		throw DeserializationException("Login: missing access_token param");
+
+	if (object.value("home_server") == QJsonValue::Undefined)
+		throw DeserializationException("Login: missing home_server param");
+
+	if (object.value("user_id") == QJsonValue::Undefined)
+		throw DeserializationException("Login: missing user_id param");
+
+	access_token_ = object.value("access_token").toString();
+	home_server_ = object.value("home_server").toString();
+	user_id_ = object.value("user_id").toString();
+}
diff --git a/src/LoginPage.cc b/src/LoginPage.cc
new file mode 100644
index 00000000..68927c33
--- /dev/null
+++ b/src/LoginPage.cc
@@ -0,0 +1,147 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+
+#include "LoginPage.h"
+
+LoginPage::LoginPage(QWidget *parent)
+    : QWidget(parent)
+    , matrix_id_validator_(new InputValidator(parent))
+{
+	top_layout_ = new QVBoxLayout();
+
+	back_layout_ = new QHBoxLayout();
+	back_layout_->setSpacing(0);
+	back_layout_->setContentsMargins(5, 5, -1, -1);
+
+	back_button_ = new FlatButton(this);
+	back_button_->setMinimumSize(QSize(30, 30));
+	back_button_->setCursor(QCursor(Qt::PointingHandCursor));
+
+	QIcon icon;
+	icon.addFile(":/icons/icons/left-angle.png", QSize(), QIcon::Normal, QIcon::Off);
+
+	back_button_->setIcon(icon);
+	back_button_->setIconSize(QSize(24, 24));
+
+	back_layout_->addWidget(back_button_, 0, Qt::AlignLeft | Qt::AlignVCenter);
+	back_layout_->addStretch(1);
+
+	logo_layout_ = new QHBoxLayout();
+	logo_layout_->setContentsMargins(0, 20, 0, 20);
+	logo_ = new QLabel(this);
+	logo_->setText("nheko");
+	logo_->setStyleSheet("font-size: 22pt; font-weight: 400;");
+	logo_layout_->addWidget(logo_, 0, Qt::AlignHCenter);
+
+	form_wrapper_ = new QHBoxLayout();
+	form_widget_ = new QWidget();
+	form_widget_->setMinimumSize(QSize(350, 200));
+
+	form_layout_ = new QVBoxLayout();
+	form_layout_->setSpacing(20);
+	form_layout_->setContentsMargins(0, 00, 0, 30);
+	form_widget_->setLayout(form_layout_);
+
+	form_wrapper_->addStretch(1);
+	form_wrapper_->addWidget(form_widget_);
+	form_wrapper_->addStretch(1);
+
+	username_input_ = new TextField();
+	username_input_->setLabel("Username");
+	username_input_->setInkColor("#577275");
+	username_input_->setBackgroundColor("#f9f9f9");
+
+	password_input_ = new TextField();
+	password_input_->setLabel("Password");
+	password_input_->setInkColor("#577275");
+	password_input_->setBackgroundColor("#f9f9f9");
+	password_input_->setEchoMode(QLineEdit::Password);
+
+	form_layout_->addWidget(username_input_, Qt::AlignHCenter, 0);
+	form_layout_->addWidget(password_input_, Qt::AlignHCenter, 0);
+
+	button_layout_ = new QHBoxLayout();
+	button_layout_->setSpacing(0);
+	button_layout_->setContentsMargins(0, 0, 0, 50);
+
+	login_button_ = new RaisedButton("LOGIN", this);
+	login_button_->setBackgroundColor(QColor("#171919"));
+	login_button_->setForegroundColor(QColor("#ebebeb"));
+	login_button_->setMinimumSize(350, 65);
+	login_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	login_button_->setFontSize(17);
+	login_button_->setCornerRadius(3);
+
+	button_layout_->addStretch(1);
+	button_layout_->addWidget(login_button_);
+	button_layout_->addStretch(1);
+
+	error_label_ = new QLabel(this);
+	error_label_->setStyleSheet("color: #E22826; font-size: 11pt;");
+
+	top_layout_->addLayout(back_layout_);
+	top_layout_->addStretch(1);
+	top_layout_->addLayout(logo_layout_);
+	top_layout_->addLayout(form_wrapper_);
+	top_layout_->addStretch(1);
+	top_layout_->addLayout(button_layout_);
+	top_layout_->addWidget(error_label_, 0, Qt::AlignHCenter);
+	top_layout_->addStretch(1);
+
+	connect(back_button_, SIGNAL(clicked()), this, SLOT(onBackButtonClicked()));
+	connect(login_button_, SIGNAL(clicked()), this, SLOT(onLoginButtonClicked()));
+	connect(username_input_, SIGNAL(returnPressed()), login_button_, SLOT(click()));
+	connect(password_input_, SIGNAL(returnPressed()), login_button_, SLOT(click()));
+
+	username_input_->setValidator(matrix_id_validator_->id_);
+
+	setLayout(top_layout_);
+}
+
+void LoginPage::loginError(QString error)
+{
+	qWarning() << "Error Message: " << error;
+	error_label_->setText(error);
+}
+
+void LoginPage::onLoginButtonClicked()
+{
+	error_label_->setText("");
+
+	if (!username_input_->hasAcceptableInput()) {
+		loginError("Invalid Matrix ID");
+	} else if (password_input_->text().isEmpty()) {
+		loginError("Empty password");
+	} else {
+		QString user = username_input_->text().split("@").at(0);
+		QString home_server = username_input_->text().split("@").at(1);
+		QString password = password_input_->text();
+
+		emit userLogin(user, password, home_server);
+	}
+}
+
+void LoginPage::onBackButtonClicked()
+{
+	emit backButtonClicked();
+}
+
+LoginPage::~LoginPage()
+{
+}
diff --git a/src/MainWindow.cc b/src/MainWindow.cc
new file mode 100644
index 00000000..82976f23
--- /dev/null
+++ b/src/MainWindow.cc
@@ -0,0 +1,134 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "MainWindow.h"
+#include "ui_MainWindow.h"
+
+#include <QLayout>
+#include <QNetworkReply>
+#include <QSettings>
+
+MainWindow::MainWindow(QWidget *parent)
+    : QMainWindow(parent)
+    , ui_(new Ui::MainWindow)
+    , welcome_page_(new WelcomePage(parent))
+    , login_page_(new LoginPage(parent))
+    , register_page_(new RegisterPage(parent))
+    , chat_page_(new ChatPage(parent))
+    , matrix_client_(new MatrixClient("matrix.org", parent))
+{
+	ui_->setupUi(this);
+
+	// Initialize sliding widget manager.
+	sliding_stack_ = new SlidingStackWidget(this);
+	sliding_stack_->addWidget(welcome_page_);
+	sliding_stack_->addWidget(login_page_);
+	sliding_stack_->addWidget(register_page_);
+	sliding_stack_->addWidget(chat_page_);
+
+	setCentralWidget(sliding_stack_);
+
+	connect(welcome_page_, SIGNAL(userLogin()), this, SLOT(showLoginPage()));
+	connect(welcome_page_, SIGNAL(userRegister()), this, SLOT(showRegisterPage()));
+
+	connect(login_page_, SIGNAL(backButtonClicked()), this, SLOT(showWelcomePage()));
+	connect(login_page_,
+		SIGNAL(userLogin(const QString &, const QString &, const QString &)),
+		this,
+		SLOT(matrixLogin(const QString &, const QString &, const QString &)));
+
+	connect(register_page_, SIGNAL(backButtonClicked()), this, SLOT(showWelcomePage()));
+	connect(register_page_,
+		SIGNAL(registerUser(const QString &, const QString &, const QString &)),
+		this,
+		SLOT(matrixRegister(const QString &, const QString &, const QString &)));
+
+	connect(matrix_client_, SIGNAL(loginError(QString)), login_page_, SLOT(loginError(QString)));
+	connect(matrix_client_,
+		SIGNAL(loginSuccess(QString, QString, QString)),
+		this,
+		SLOT(showChatPage(QString, QString, QString)));
+}
+
+void MainWindow::matrixLogin(const QString &username, const QString &password, const QString &home_server)
+{
+	qDebug() << "About to login into Matrix";
+	qDebug() << "Userame: " << username;
+
+	matrix_client_->setServer(home_server);
+	matrix_client_->login(username, password);
+}
+
+void MainWindow::showChatPage(QString userid, QString homeserver, QString token)
+{
+	QSettings settings;
+	settings.setValue("auth/access_token", token);
+	settings.setValue("auth/home_server", homeserver);
+	settings.setValue("auth/user_id", userid);
+
+	int index = sliding_stack_->getWidgetIndex(chat_page_);
+	sliding_stack_->slideInIndex(index, SlidingStackWidget::AnimationDirection::LEFT_TO_RIGHT);
+
+	chat_page_->bootstrap(userid, homeserver, token);
+}
+
+void MainWindow::matrixRegister(const QString &username, const QString &password, const QString &server)
+{
+	qDebug() << "About to register to Matrix";
+	qDebug() << "Username: " << username << " Password: " << password << " Server: " << server;
+}
+
+void MainWindow::showWelcomePage()
+{
+	int index = sliding_stack_->getWidgetIndex(welcome_page_);
+
+	if (sliding_stack_->currentIndex() == sliding_stack_->getWidgetIndex(login_page_))
+		sliding_stack_->slideInIndex(index, SlidingStackWidget::AnimationDirection::RIGHT_TO_LEFT);
+	else
+		sliding_stack_->slideInIndex(index, SlidingStackWidget::AnimationDirection::LEFT_TO_RIGHT);
+}
+
+void MainWindow::showLoginPage()
+{
+	QSettings settings;
+
+	if (settings.contains("auth/access_token") &&
+	    settings.contains("auth/home_server") &&
+	    settings.contains("auth/user_id")) {
+		QString token = settings.value("auth/access_token").toString();
+		QString home_server = settings.value("auth/home_server").toString();
+		QString user_id = settings.value("auth/user_id").toString();
+
+		showChatPage(user_id, home_server, token);
+
+		return;
+	}
+
+	int index = sliding_stack_->getWidgetIndex(login_page_);
+	sliding_stack_->slideInIndex(index, SlidingStackWidget::AnimationDirection::LEFT_TO_RIGHT);
+}
+
+void MainWindow::showRegisterPage()
+{
+	int index = sliding_stack_->getWidgetIndex(register_page_);
+	sliding_stack_->slideInIndex(index, SlidingStackWidget::AnimationDirection::RIGHT_TO_LEFT);
+}
+
+MainWindow::~MainWindow()
+{
+	delete ui_;
+}
diff --git a/src/MatrixClient.cc b/src/MatrixClient.cc
new file mode 100644
index 00000000..5510b6d9
--- /dev/null
+++ b/src/MatrixClient.cc
@@ -0,0 +1,365 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QSettings>
+#include <QUrl>
+#include <QUrlQuery>
+
+#include "Login.h"
+#include "MatrixClient.h"
+#include "Profile.h"
+
+MatrixClient::MatrixClient(QString server, QObject *parent)
+    : QNetworkAccessManager(parent)
+{
+	server_ = "https://" + server;
+	api_url_ = "/_matrix/client/r0";
+	token_ = "";
+
+	QSettings settings;
+	txn_id_ = settings.value("client/transaction_id", 1).toInt();
+
+	// FIXME: Other QNetworkAccessManagers use the finish handler.
+	connect(this, SIGNAL(finished(QNetworkReply *)), this, SLOT(onResponse(QNetworkReply *)));
+}
+
+MatrixClient::~MatrixClient()
+{
+}
+
+void MatrixClient::onVersionsResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	qDebug() << "Handling the versions response";
+
+	auto data = reply->readAll();
+	auto json = QJsonDocument::fromJson(data);
+
+	qDebug() << json;
+}
+
+void MatrixClient::onLoginResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	int status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+	if (status_code == 403) {
+		emit loginError("Wrong username or password");
+		return;
+	}
+
+	if (status_code == 404) {
+		emit loginError("Login endpoint was not found on the server");
+		return;
+	}
+
+	if (status_code != 200) {
+		qDebug() << "Login response: status code " << status_code;
+
+		if (status_code >= 400) {
+			qWarning() << "Login error: " << reply->errorString();
+			emit loginError("An unknown error occured. Please try again.");
+			return;
+		}
+	}
+
+	auto data = reply->readAll();
+	auto json = QJsonDocument::fromJson(data);
+
+	LoginResponse response;
+
+	try {
+		response.deserialize(json);
+		emit loginSuccess(response.getUserId(),
+				  response.getHomeServer(),
+				  response.getAccessToken());
+	} catch (DeserializationException &e) {
+		qWarning() << "Malformed JSON response" << e.what();
+		emit loginError("Malformed response. Possibly not a Matrix server");
+	}
+}
+
+void MatrixClient::onRegisterResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	qDebug() << "Handling the register response";
+}
+
+void MatrixClient::onGetOwnProfileResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+	if (status >= 400) {
+		qWarning() << reply->errorString();
+		return;
+	}
+
+	auto data = reply->readAll();
+	auto json = QJsonDocument::fromJson(data);
+
+	ProfileResponse response;
+
+	try {
+		response.deserialize(json);
+		emit getOwnProfileResponse(response.getAvatarUrl(), response.getDisplayName());
+	} catch (DeserializationException &e) {
+		qWarning() << "Profile malformed response" << e.what();
+	}
+}
+
+void MatrixClient::onInitialSyncResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+	if (status == 0 || status >= 400) {
+		qWarning() << reply->errorString();
+		return;
+	}
+
+	auto data = reply->readAll();
+
+	if (data.isEmpty())
+		return;
+
+	auto json = QJsonDocument::fromJson(data);
+
+	SyncResponse response;
+
+	try {
+		response.deserialize(json);
+		emit initialSyncCompleted(response);
+	} catch (DeserializationException &e) {
+		qWarning() << "Sync malformed response" << e.what();
+	}
+}
+
+void MatrixClient::onSyncResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+	if (status == 0 || status >= 400) {
+		qWarning() << reply->errorString();
+		return;
+	}
+
+	auto data = reply->readAll();
+
+	if (data.isEmpty())
+		return;
+
+	auto json = QJsonDocument::fromJson(data);
+
+	SyncResponse response;
+
+	try {
+		response.deserialize(json);
+		emit syncCompleted(response);
+	} catch (DeserializationException &e) {
+		qWarning() << "Sync malformed response" << e.what();
+	}
+}
+
+void MatrixClient::onSendTextMessageResponse(QNetworkReply *reply)
+{
+	reply->deleteLater();
+
+	int status = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
+
+	if (status == 0 || status >= 400) {
+		qWarning() << reply->errorString();
+		return;
+	}
+
+	auto data = reply->readAll();
+
+	if (data.isEmpty())
+		return;
+
+	auto json = QJsonDocument::fromJson(data);
+
+	if (!json.isObject()) {
+		qDebug() << "Send message response is not a JSON object";
+		return;
+	}
+
+	auto object = json.object();
+
+	if (!object.contains("event_id")) {
+		qDebug() << "SendTextMessage: missnig event_id from response";
+		return;
+	}
+
+	emit messageSent(object.value("event_id").toString(),
+			 reply->property("txn_id").toInt());
+
+	incrementTransactionId();
+}
+
+void MatrixClient::onResponse(QNetworkReply *reply)
+{
+	switch (reply->property("endpoint").toInt()) {
+	case Endpoint::Versions:
+		onVersionsResponse(reply);
+		break;
+	case Endpoint::Login:
+		onLoginResponse(reply);
+		break;
+	case Endpoint::Register:
+		onRegisterResponse(reply);
+	case Endpoint::GetOwnProfile:
+		onGetOwnProfileResponse(reply);
+	case Endpoint::InitialSync:
+		onInitialSyncResponse(reply);
+	case Endpoint::Sync:
+		onSyncResponse(reply);
+	case Endpoint::SendTextMessage:
+		onSendTextMessageResponse(reply);
+	default:
+		break;
+	}
+}
+
+void MatrixClient::login(const QString &username, const QString &password)
+{
+	QUrl endpoint(server_);
+	endpoint.setPath(api_url_ + "/login");
+
+	QNetworkRequest request(endpoint);
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+	LoginRequest body(username, password);
+
+	QNetworkReply *reply = post(request, body.serialize());
+	reply->setProperty("endpoint", Endpoint::Login);
+}
+
+void MatrixClient::sync()
+{
+	QJsonObject filter{{"room",
+			    QJsonObject{{"ephemeral", QJsonObject{{"limit", 0}}}}},
+			   {"presence", QJsonObject{{"limit", 0}}}};
+
+	QUrlQuery query;
+	query.addQueryItem("set_presence", "online");
+	query.addQueryItem("filter", QJsonDocument(filter).toJson(QJsonDocument::Compact));
+	query.addQueryItem("access_token", token_);
+
+	if (next_batch_.isEmpty()) {
+		qDebug() << "Sync requires a valid next_batch token. Initial sync should be performed.";
+		return;
+	}
+
+	query.addQueryItem("since", next_batch_);
+
+	QUrl endpoint(server_);
+	endpoint.setPath(api_url_ + "/sync");
+	endpoint.setQuery(query);
+
+	QNetworkRequest request(QString(endpoint.toEncoded()));
+
+	QNetworkReply *reply = get(request);
+	reply->setProperty("endpoint", Endpoint::Sync);
+}
+
+void MatrixClient::sendTextMessage(QString roomid, QString msg)
+{
+	QUrlQuery query;
+	query.addQueryItem("access_token", token_);
+
+	QUrl endpoint(server_);
+	endpoint.setPath(api_url_ + QString("/rooms/%1/send/m.room.message/%2").arg(roomid).arg(txn_id_));
+	endpoint.setQuery(query);
+
+	QJsonObject body{
+		{"msgtype", "m.text"},
+		{"body", msg}};
+
+	QNetworkRequest request(QString(endpoint.toEncoded()));
+	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+
+	QNetworkReply *reply = put(request, QJsonDocument(body).toJson(QJsonDocument::Compact));
+
+	reply->setProperty("endpoint", Endpoint::SendTextMessage);
+	reply->setProperty("txn_id", txn_id_);
+}
+
+void MatrixClient::initialSync()
+{
+	QJsonObject filter{{"room",
+			    QJsonObject{{"timeline", QJsonObject{{"limit", 70}}},
+					{"ephemeral", QJsonObject{{"limit", 0}}}}},
+			   {"presence", QJsonObject{{"limit", 0}}}};
+
+	QUrlQuery query;
+	query.addQueryItem("full_state", "true");
+	query.addQueryItem("set_presence", "online");
+	query.addQueryItem("filter", QJsonDocument(filter).toJson(QJsonDocument::Compact));
+	query.addQueryItem("access_token", token_);
+
+	QUrl endpoint(server_);
+	endpoint.setPath(api_url_ + "/sync");
+	endpoint.setQuery(query);
+
+	QNetworkRequest request(QString(endpoint.toEncoded()));
+
+	QNetworkReply *reply = get(request);
+	reply->setProperty("endpoint", Endpoint::InitialSync);
+}
+
+void MatrixClient::versions()
+{
+	QUrl endpoint(server_);
+	endpoint.setPath("/_matrix/client/versions");
+
+	QNetworkRequest request(endpoint);
+
+	QNetworkReply *reply = get(request);
+	reply->setProperty("endpoint", Endpoint::Versions);
+}
+
+void MatrixClient::getOwnProfile()
+{
+	// FIXME: Remove settings from the matrix client. The class should store the user's matrix ID.
+	QSettings settings;
+	auto userid = settings.value("auth/user_id", "").toString();
+
+	QUrlQuery query;
+	query.addQueryItem("access_token", token_);
+
+	QUrl endpoint(server_);
+	endpoint.setPath(api_url_ + "/profile/" + userid);
+	endpoint.setQuery(query);
+
+	QNetworkRequest request(QString(endpoint.toEncoded()));
+
+	QNetworkReply *reply = get(request);
+	reply->setProperty("endpoint", Endpoint::GetOwnProfile);
+}
diff --git a/src/Profile.cc b/src/Profile.cc
new file mode 100644
index 00000000..aa556370
--- /dev/null
+++ b/src/Profile.cc
@@ -0,0 +1,50 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QJsonObject>
+#include <QJsonValue>
+#include <QUrl>
+
+#include "Deserializable.h"
+#include "Profile.h"
+
+QUrl ProfileResponse::getAvatarUrl()
+{
+	return avatar_url_;
+}
+
+QString ProfileResponse::getDisplayName()
+{
+	return display_name_;
+}
+
+void ProfileResponse::deserialize(QJsonDocument data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Profile response is not a JSON object");
+
+	QJsonObject object = data.object();
+
+	if (object.value("avatar_url") == QJsonValue::Undefined)
+		throw DeserializationException("Profile: missing avatar_url param");
+
+	if (object.value("displayname") == QJsonValue::Undefined)
+		throw DeserializationException("Profile: missing displayname param");
+
+	avatar_url_ = QUrl(object.value("avatar_url").toString());
+	display_name_ = object.value("displayname").toString();
+}
diff --git a/src/RegisterPage.cc b/src/RegisterPage.cc
new file mode 100644
index 00000000..fcb43b86
--- /dev/null
+++ b/src/RegisterPage.cc
@@ -0,0 +1,166 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QToolTip>
+
+#include "RegisterPage.h"
+
+RegisterPage::RegisterPage(QWidget *parent)
+    : QWidget(parent)
+    , validator_(new InputValidator(parent))
+{
+	top_layout_ = new QVBoxLayout();
+
+	back_layout_ = new QHBoxLayout();
+	back_layout_->setSpacing(0);
+	back_layout_->setContentsMargins(5, 5, -1, -1);
+
+	back_button_ = new FlatButton(this);
+	back_button_->setMinimumSize(QSize(30, 30));
+	back_button_->setCursor(QCursor(Qt::PointingHandCursor));
+
+	QIcon icon;
+	icon.addFile(":/icons/icons/left-angle.png", QSize(), QIcon::Normal, QIcon::Off);
+
+	back_button_->setIcon(icon);
+	back_button_->setIconSize(QSize(24, 24));
+
+	back_layout_->addWidget(back_button_, 0, Qt::AlignLeft | Qt::AlignVCenter);
+	back_layout_->addStretch(1);
+
+	logo_layout_ = new QHBoxLayout();
+	logo_layout_->setContentsMargins(0, 20, 0, 20);
+	logo_ = new QLabel(this);
+	logo_->setText("nheko");
+	logo_->setStyleSheet("font-size: 22pt; font-weight: 400;");
+	logo_layout_->addWidget(logo_, 0, Qt::AlignHCenter);
+
+	form_wrapper_ = new QHBoxLayout();
+	form_widget_ = new QWidget();
+	form_widget_->setMinimumSize(QSize(350, 300));
+
+	form_layout_ = new QVBoxLayout();
+	form_layout_->setSpacing(20);
+	form_layout_->setContentsMargins(0, 00, 0, 60);
+	form_widget_->setLayout(form_layout_);
+
+	form_wrapper_->addStretch(1);
+	form_wrapper_->addWidget(form_widget_);
+	form_wrapper_->addStretch(1);
+
+	username_input_ = new TextField();
+	username_input_->setLabel("Username");
+	username_input_->setInkColor("#577275");
+	username_input_->setBackgroundColor("#f9f9f9");
+
+	password_input_ = new TextField();
+	password_input_->setLabel("Password");
+	password_input_->setInkColor("#577275");
+	password_input_->setBackgroundColor("#f9f9f9");
+	password_input_->setEchoMode(QLineEdit::Password);
+
+	password_confirmation_ = new TextField();
+	password_confirmation_->setLabel("Password confirmation");
+	password_confirmation_->setInkColor("#577275");
+	password_confirmation_->setBackgroundColor("#f9f9f9");
+	password_confirmation_->setEchoMode(QLineEdit::Password);
+
+	server_input_ = new TextField();
+	server_input_->setLabel("Home Server");
+	server_input_->setInkColor("#577275");
+	server_input_->setBackgroundColor("#f9f9f9");
+
+	form_layout_->addWidget(username_input_, Qt::AlignHCenter, 0);
+	form_layout_->addWidget(password_input_, Qt::AlignHCenter, 0);
+	form_layout_->addWidget(password_confirmation_, Qt::AlignHCenter, 0);
+	form_layout_->addWidget(server_input_, Qt::AlignHCenter, 0);
+
+	button_layout_ = new QHBoxLayout();
+	button_layout_->setSpacing(0);
+	button_layout_->setContentsMargins(0, 0, 0, 50);
+
+	register_button_ = new RaisedButton("REGISTER", this);
+	register_button_->setBackgroundColor(QColor("#171919"));
+	register_button_->setForegroundColor(QColor("#ebebeb"));
+	register_button_->setMinimumSize(350, 65);
+	register_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	register_button_->setFontSize(17);
+	register_button_->setCornerRadius(3);
+
+	button_layout_->addStretch(1);
+	button_layout_->addWidget(register_button_);
+	button_layout_->addStretch(1);
+
+	top_layout_->addLayout(back_layout_);
+	top_layout_->addStretch(1);
+	top_layout_->addLayout(logo_layout_);
+	top_layout_->addLayout(form_wrapper_);
+	top_layout_->addStretch(2);
+	top_layout_->addLayout(button_layout_);
+	top_layout_->addStretch(1);
+
+	connect(back_button_, SIGNAL(clicked()), this, SLOT(onBackButtonClicked()));
+	connect(register_button_, SIGNAL(clicked()), this, SLOT(onRegisterButtonClicked()));
+
+	connect(username_input_, SIGNAL(returnPressed()), register_button_, SLOT(click()));
+	connect(password_input_, SIGNAL(returnPressed()), register_button_, SLOT(click()));
+	connect(password_confirmation_, SIGNAL(returnPressed()), register_button_, SLOT(click()));
+	connect(server_input_, SIGNAL(returnPressed()), register_button_, SLOT(click()));
+
+	username_input_->setValidator(validator_->localpart_);
+	password_input_->setValidator(validator_->password_);
+	server_input_->setValidator(validator_->domain_);
+
+	setLayout(top_layout_);
+}
+
+void RegisterPage::onBackButtonClicked()
+{
+	emit backButtonClicked();
+}
+
+void RegisterPage::onRegisterButtonClicked()
+{
+	if (!username_input_->hasAcceptableInput()) {
+		QString text("Invalid username");
+		QPoint point = username_input_->mapToGlobal(username_input_->rect().topRight());
+		QToolTip::showText(point, text);
+	} else if (!password_input_->hasAcceptableInput()) {
+		QString text("Password is not long enough");
+		QPoint point = password_input_->mapToGlobal(password_input_->rect().topRight());
+		QToolTip::showText(point, text);
+	} else if (password_input_->text() != password_confirmation_->text()) {
+		QString text("Passwords don't match");
+		QPoint point = password_confirmation_->mapToGlobal(password_confirmation_->rect().topRight());
+		QToolTip::showText(point, text);
+	} else if (!server_input_->hasAcceptableInput()) {
+		QString text("Invalid server name");
+		QPoint point = server_input_->mapToGlobal(server_input_->rect().topRight());
+		QToolTip::showText(point, text);
+	} else {
+		QString username = username_input_->text();
+		QString password = password_input_->text();
+		QString server = server_input_->text();
+
+		emit registerUser(username, password, server);
+	}
+}
+
+RegisterPage::~RegisterPage()
+{
+}
diff --git a/src/RoomInfo.cc b/src/RoomInfo.cc
new file mode 100644
index 00000000..f8a7c56a
--- /dev/null
+++ b/src/RoomInfo.cc
@@ -0,0 +1,71 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "RoomInfo.h"
+
+RoomInfo::RoomInfo()
+    : name_("")
+    , topic_("")
+{
+}
+
+RoomInfo::RoomInfo(QString name, QString topic, QUrl avatar_url)
+    : name_(name)
+    , topic_(topic)
+    , avatar_url_(avatar_url)
+{
+}
+
+QString RoomInfo::id() const
+{
+	return id_;
+}
+
+QString RoomInfo::name() const
+{
+	return name_;
+}
+
+QString RoomInfo::topic() const
+{
+	return topic_;
+}
+
+QUrl RoomInfo::avatarUrl() const
+{
+	return avatar_url_;
+}
+
+void RoomInfo::setAvatarUrl(const QUrl &url)
+{
+	avatar_url_ = url;
+}
+
+void RoomInfo::setId(const QString &id)
+{
+	id_ = id;
+}
+
+void RoomInfo::setName(const QString &name)
+{
+	name_ = name;
+}
+
+void RoomInfo::setTopic(const QString &topic)
+{
+	topic_ = topic;
+}
diff --git a/src/RoomInfoListItem.cc b/src/RoomInfoListItem.cc
new file mode 100644
index 00000000..dedae3fd
--- /dev/null
+++ b/src/RoomInfoListItem.cc
@@ -0,0 +1,138 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+
+#include "Ripple.h"
+#include "RoomInfo.h"
+#include "RoomInfoListItem.h"
+
+RoomInfoListItem::RoomInfoListItem(RoomInfo info, QWidget *parent)
+    : QWidget(parent)
+    , info_(info)
+    , is_pressed_(false)
+    , max_height_(65)
+{
+	normal_style_ =
+		"QWidget { background-color: #5d6565; color: #ebebeb;"
+		"border-bottom: 1px solid #171919;}"
+		"QLabel { border: none; }";
+
+	pressed_style_ =
+		"QWidget { background-color: #577275; color: #ebebeb;"
+		"border-bottom: 1px solid #171919;}"
+		"QLabel { border: none; }";
+
+	setStyleSheet(normal_style_);
+	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+	setAutoFillBackground(true);
+
+	setMinimumSize(parent->width(), max_height_);
+
+	topLayout_ = new QHBoxLayout(this);
+	topLayout_->setSpacing(0);
+	topLayout_->setMargin(0);
+
+	avatarWidget_ = new QWidget(this);
+	avatarWidget_->setMaximumSize(max_height_, max_height_);
+	textWidget_ = new QWidget(this);
+
+	avatarLayout_ = new QVBoxLayout(avatarWidget_);
+	avatarLayout_->setSpacing(0);
+	avatarLayout_->setContentsMargins(0, 5, 0, 5);
+
+	textLayout_ = new QVBoxLayout(textWidget_);
+	textLayout_->setSpacing(0);
+	textLayout_->setContentsMargins(0, 5, 0, 5);
+
+	roomAvatar_ = new Avatar(avatarWidget_);
+	roomAvatar_->setLetter(QChar(info_.name()[0]));
+	avatarLayout_->addWidget(roomAvatar_);
+
+	roomName_ = new QLabel(textWidget_);
+	roomName_->setText(info_.name());
+	roomName_->setMaximumSize(230, max_height_ / 2);
+	roomName_->setStyleSheet("font-weight: 500; font-size: 11.5pt");
+	roomName_->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
+
+	roomTopic_ = new QLabel(textWidget_);
+	roomTopic_->setText(info_.topic());
+	roomTopic_->setMaximumSize(230, max_height_ / 2);
+	roomTopic_->setStyleSheet("color: #c9c9c9; font-size: 10pt");
+	roomTopic_->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
+
+	textLayout_->addWidget(roomName_);
+	textLayout_->addWidget(roomTopic_);
+
+	topLayout_->addWidget(avatarWidget_);
+	topLayout_->addWidget(textWidget_);
+
+	setElidedText(roomName_, info_.name(), 220);
+	setElidedText(roomTopic_, info_.topic(), 220);
+
+	QPainterPath path;
+	path.addRoundedRect(rect(), 0, 0);
+
+	ripple_overlay_ = new RippleOverlay(this);
+	ripple_overlay_->setClipPath(path);
+	ripple_overlay_->setClipping(true);
+
+	setLayout(topLayout_);
+}
+
+void RoomInfoListItem::setPressedState(bool state)
+{
+	if (!is_pressed_ && state) {
+		is_pressed_ = state;
+		setStyleSheet(pressed_style_);
+	} else if (is_pressed_ && !state) {
+		is_pressed_ = state;
+		setStyleSheet(normal_style_);
+	}
+}
+
+void RoomInfoListItem::mousePressEvent(QMouseEvent *event)
+{
+	emit clicked(info_);
+
+	setPressedState(true);
+
+	// Ripple on mouse position by default.
+	QPoint pos = event->pos();
+	qreal radiusEndValue = static_cast<qreal>(width()) / 2;
+
+	Ripple *ripple = new Ripple(pos);
+
+	ripple->setRadiusEndValue(radiusEndValue);
+	ripple->setOpacityStartValue(0.35);
+	ripple->setColor(QColor("#171919"));
+	ripple->radiusAnimation()->setDuration(300);
+	ripple->opacityAnimation()->setDuration(500);
+
+	ripple_overlay_->addRipple(ripple);
+}
+
+void RoomInfoListItem::setElidedText(QLabel *label, QString text, int width)
+{
+	QFontMetrics metrics(label->font());
+	QString elidedText = metrics.elidedText(text, Qt::ElideRight, width);
+	label->setText(elidedText);
+}
+
+RoomInfoListItem::~RoomInfoListItem()
+{
+}
diff --git a/src/RoomList.cc b/src/RoomList.cc
new file mode 100644
index 00000000..1e147a48
--- /dev/null
+++ b/src/RoomList.cc
@@ -0,0 +1,119 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ui_RoomList.h"
+
+#include <QDebug>
+#include <QJsonArray>
+#include <QLabel>
+
+#include "RoomInfoListItem.h"
+#include "RoomList.h"
+#include "Sync.h"
+
+RoomList::RoomList(QWidget *parent)
+    : QWidget(parent)
+    , ui(new Ui::RoomList)
+{
+	ui->setupUi(this);
+}
+
+RoomList::~RoomList()
+{
+	delete ui;
+}
+
+RoomInfo RoomList::extractRoomInfo(const State &room_state)
+{
+	RoomInfo info;
+
+	auto events = room_state.events();
+
+	for (int i = 0; i < events.count(); i++) {
+		if (events[i].type() == "m.room.name") {
+			info.setName(events[i].content().value("name").toString());
+		} else if (events[i].type() == "m.room.topic") {
+			info.setTopic(events[i].content().value("topic").toString());
+		} else if (events[i].type() == "m.room.avatar") {
+			info.setAvatarUrl(QUrl(events[i].content().value("url").toString()));
+		} else if (events[i].type() == "m.room.canonical_alias") {
+			if (info.name().isEmpty())
+				info.setName(events[i].content().value("alias").toString());
+		}
+	}
+
+	return info;
+}
+
+void RoomList::setInitialRooms(const Rooms &rooms)
+{
+	available_rooms_.clear();
+
+	for (auto it = rooms.join().constBegin(); it != rooms.join().constEnd(); it++) {
+		RoomInfo info = RoomList::extractRoomInfo(it.value().state());
+		info.setId(it.key());
+
+		if (info.name().isEmpty())
+			continue;
+
+		if (!info.avatarUrl().isEmpty())
+			emit fetchRoomAvatar(info.id(), info.avatarUrl());
+
+		RoomInfoListItem *room_item = new RoomInfoListItem(info, ui->scrollArea);
+		connect(room_item,
+			SIGNAL(clicked(const RoomInfo &)),
+			this,
+			SLOT(highlightSelectedRoom(const RoomInfo &)));
+
+		available_rooms_.insert(it.key(), room_item);
+
+		ui->scrollVerticalLayout->addWidget(room_item);
+	}
+
+	// TODO: Move this into its own function.
+	auto first_room = available_rooms_.first();
+	first_room->setPressedState(true);
+	emit roomChanged(first_room->info());
+
+	ui->scrollVerticalLayout->addStretch(1);
+}
+
+void RoomList::highlightSelectedRoom(const RoomInfo &info)
+{
+	emit roomChanged(info);
+
+	for (auto it = available_rooms_.constBegin(); it != available_rooms_.constEnd(); it++) {
+		if (it.key() != info.id())
+			it.value()->setPressedState(false);
+	}
+}
+
+void RoomList::updateRoomAvatar(const QString &roomid, const QImage &avatar_image)
+{
+	if (!available_rooms_.contains(roomid)) {
+		qDebug() << "Avatar update on non existent room" << roomid;
+		return;
+	}
+
+	auto list_item = available_rooms_.value(roomid);
+	list_item->setAvatar(avatar_image);
+}
+
+void RoomList::appendRoom(QString name)
+{
+	Q_UNUSED(name);
+}
diff --git a/src/SlidingStackWidget.cc b/src/SlidingStackWidget.cc
new file mode 100644
index 00000000..c4d2f7cf
--- /dev/null
+++ b/src/SlidingStackWidget.cc
@@ -0,0 +1,151 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SlidingStackWidget.h"
+
+SlidingStackWidget::SlidingStackWidget(QWidget *parent)
+    : QStackedWidget(parent)
+{
+	window_ = parent;
+
+	if (parent == Q_NULLPTR) {
+		qDebug() << "Using nullptr for parent";
+		window_ = this;
+	}
+
+	current_position_ = QPoint(0, 0);
+	speed_ = 400;
+	now_ = 0;
+	next_ = 0;
+	active_ = false;
+	animation_type_ = QEasingCurve::InOutCirc;
+}
+
+SlidingStackWidget::~SlidingStackWidget()
+{
+}
+
+void SlidingStackWidget::slideInNext()
+{
+	int now = currentIndex();
+
+	if (now < count() - 1)
+		slideInIndex(now + 1);
+}
+
+void SlidingStackWidget::slideInPrevious()
+{
+	int now = currentIndex();
+
+	if (now > 0)
+		slideInIndex(now - 1);
+}
+
+void SlidingStackWidget::slideInIndex(int index, AnimationDirection direction)
+{
+	// Take into consideration possible index overflow/undeflow.
+	if (index > count() - 1) {
+		direction = AnimationDirection::RIGHT_TO_LEFT;
+		index = index % count();
+	} else if (index < 0) {
+		direction = AnimationDirection::LEFT_TO_RIGHT;
+		index = (index + count()) % count();
+	}
+
+	slideInWidget(widget(index), direction);
+}
+
+void SlidingStackWidget::slideInWidget(QWidget *next_widget, AnimationDirection direction)
+{
+	// If an animation is currenlty executing we should wait for it to finish before
+	// another transition can start.
+	if (active_)
+		return;
+
+	active_ = true;
+
+	int now = currentIndex();
+	int next = indexOf(next_widget);
+
+	if (now == next) {
+		active_ = false;
+		return;
+	}
+
+	int offset_x = frameRect().width();
+
+	next_widget->setGeometry(0, 0, offset_x, 0);
+
+	if (direction == AnimationDirection::LEFT_TO_RIGHT) {
+		offset_x = -offset_x;
+	}
+
+	QPoint pnext = next_widget->pos();
+	QPoint pnow = widget(now)->pos();
+	current_position_ = pnow;
+
+	// Reposition the next widget outside of the display area.
+	next_widget->move(pnext.x() - offset_x, pnext.y());
+
+	// Make the widget visible.
+	next_widget->show();
+	next_widget->raise();
+
+	// Animate both the next and now widget.
+	QPropertyAnimation *animation_now = new QPropertyAnimation(widget(now), "pos");
+
+	animation_now->setDuration(speed_);
+	animation_now->setEasingCurve(animation_type_);
+	animation_now->setStartValue(QPoint(pnow.x(), pnow.y()));
+	animation_now->setEndValue(QPoint(pnow.x() + offset_x, pnow.y()));
+
+	QPropertyAnimation *animation_next = new QPropertyAnimation(next_widget, "pos");
+
+	animation_next->setDuration(speed_);
+	animation_next->setEasingCurve(animation_type_);
+	animation_next->setStartValue(QPoint(pnext.x() - offset_x, pnext.y()));
+	animation_next->setEndValue(QPoint(pnext.x(), pnext.y()));
+
+	QParallelAnimationGroup *animation_group = new QParallelAnimationGroup;
+
+	animation_group->addAnimation(animation_now);
+	animation_group->addAnimation(animation_next);
+
+	connect(animation_group, SIGNAL(finished()), this, SLOT(onAnimationFinished()));
+
+	next_ = next;
+	now_ = now;
+	animation_group->start();
+}
+
+void SlidingStackWidget::onAnimationFinished()
+{
+	setCurrentIndex(next_);
+
+	// The old widget is no longer necessary so we can hide it and
+	// move it back to its original position.
+	widget(now_)->hide();
+	widget(now_)->move(current_position_);
+
+	active_ = false;
+	emit animationFinished();
+}
+
+int SlidingStackWidget::getWidgetIndex(QWidget *widget)
+{
+	return indexOf(widget);
+}
diff --git a/src/Sync.cc b/src/Sync.cc
new file mode 100644
index 00000000..3ba6d220
--- /dev/null
+++ b/src/Sync.cc
@@ -0,0 +1,290 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QJsonValue>
+
+#include "Deserializable.h"
+#include "Sync.h"
+
+QString SyncResponse::nextBatch() const
+{
+	return next_batch_;
+}
+
+void SyncResponse::deserialize(QJsonDocument data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Sync response is not a JSON object");
+
+	QJsonObject object = data.object();
+
+	if (object.value("next_batch") == QJsonValue::Undefined)
+		throw DeserializationException("Sync: missing next_batch parameter");
+
+	if (object.value("rooms") == QJsonValue::Undefined)
+		throw DeserializationException("Sync: missing rooms parameter");
+
+	rooms_.deserialize(object.value("rooms"));
+	next_batch_ = object.value("next_batch").toString();
+}
+
+Rooms SyncResponse::rooms() const
+{
+	return rooms_;
+}
+
+QMap<QString, JoinedRoom> Rooms::join() const
+{
+	return join_;
+}
+
+void Rooms::deserialize(QJsonValue data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Rooms value is not a JSON object");
+
+	QJsonObject object = data.toObject();
+
+	if (!object.contains("join"))
+		throw DeserializationException("rooms/join is missing");
+
+	if (!object.contains("invite"))
+		throw DeserializationException("rooms/invite is missing");
+
+	if (!object.contains("leave"))
+		throw DeserializationException("rooms/leave is missing");
+
+	if (!object.value("join").isObject())
+		throw DeserializationException("rooms/join must be a JSON object");
+
+	if (!object.value("invite").isObject())
+		throw DeserializationException("rooms/invite must be a JSON object");
+
+	if (!object.value("leave").isObject())
+		throw DeserializationException("rooms/leave must be a JSON object");
+
+	auto join = object.value("join").toObject();
+
+	for (auto it = join.constBegin(); it != join.constEnd(); it++) {
+		JoinedRoom tmp_room;
+
+		try {
+			tmp_room.deserialize(it.value());
+			join_.insert(it.key(), tmp_room);
+		} catch (DeserializationException &e) {
+			qWarning() << e.what();
+			qWarning() << "Skipping malformed object for room" << it.key();
+		}
+	}
+}
+
+State JoinedRoom::state() const
+{
+	return state_;
+}
+
+Timeline JoinedRoom::timeline() const
+{
+	return timeline_;
+}
+
+void JoinedRoom::deserialize(QJsonValue data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("JoinedRoom is not a JSON object");
+
+	QJsonObject object = data.toObject();
+
+	if (!object.contains("state"))
+		throw DeserializationException("join/state is missing");
+
+	if (!object.contains("timeline"))
+		throw DeserializationException("join/timeline is missing");
+
+	if (!object.contains("account_data"))
+		throw DeserializationException("join/account_data is missing");
+
+	if (!object.contains("unread_notifications"))
+		throw DeserializationException("join/unread_notifications is missing");
+
+	if (!object.value("state").isObject())
+		throw DeserializationException("join/state should be an object");
+
+	QJsonObject state = object.value("state").toObject();
+
+	if (!state.contains("events"))
+		throw DeserializationException("join/state/events is missing");
+
+	state_.deserialize(state.value("events"));
+	timeline_.deserialize(object.value("timeline"));
+}
+
+QJsonObject Event::content() const
+{
+	return content_;
+}
+
+QJsonObject Event::unsigned_content() const
+{
+	return unsigned_;
+}
+
+QString Event::sender() const
+{
+	return sender_;
+}
+
+QString Event::state_key() const
+{
+	return state_key_;
+}
+
+QString Event::type() const
+{
+	return type_;
+}
+
+QString Event::eventId() const
+{
+	return event_id_;
+}
+
+uint64_t Event::timestamp() const
+{
+	return origin_server_ts_;
+}
+
+void Event::deserialize(QJsonValue data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Event is not a JSON object");
+
+	QJsonObject object = data.toObject();
+
+	if (!object.contains("content"))
+		throw DeserializationException("event/content is missing");
+
+	if (!object.contains("unsigned"))
+		throw DeserializationException("event/content is missing");
+
+	if (!object.contains("sender"))
+		throw DeserializationException("event/sender is missing");
+
+	if (!object.contains("event_id"))
+		throw DeserializationException("event/event_id is missing");
+
+	// TODO: Make this optional
+	/* if (!object.contains("state_key")) */
+	/* 	throw DeserializationException("event/state_key is missing"); */
+
+	if (!object.contains("type"))
+		throw DeserializationException("event/type is missing");
+
+	if (!object.contains("origin_server_ts"))
+		throw DeserializationException("event/origin_server_ts is missing");
+
+	content_ = object.value("content").toObject();
+	unsigned_ = object.value("unsigned").toObject();
+
+	sender_ = object.value("sender").toString();
+	state_key_ = object.value("state_key").toString();
+	type_ = object.value("type").toString();
+	event_id_ = object.value("event_id").toString();
+
+	origin_server_ts_ = object.value("origin_server_ts").toDouble();
+}
+
+QList<Event> State::events() const
+{
+	return events_;
+}
+
+void State::deserialize(QJsonValue data) throw(DeserializationException)
+{
+	if (!data.isArray())
+		throw DeserializationException("State is not a JSON array");
+
+	QJsonArray event_array = data.toArray();
+
+	for (int i = 0; i < event_array.count(); i++) {
+		Event event;
+
+		try {
+			event.deserialize(event_array.at(i));
+			events_.push_back(event);
+		} catch (DeserializationException &e) {
+			qWarning() << e.what();
+			qWarning() << "Skipping malformed state event";
+		}
+	}
+}
+
+QList<Event> Timeline::events() const
+{
+	return events_;
+}
+
+QString Timeline::previousBatch() const
+{
+	return prev_batch_;
+}
+
+bool Timeline::limited() const
+{
+	return limited_;
+}
+
+void Timeline::deserialize(QJsonValue data) throw(DeserializationException)
+{
+	if (!data.isObject())
+		throw DeserializationException("Timeline is not a JSON object");
+
+	auto object = data.toObject();
+
+	if (!object.contains("events"))
+		throw DeserializationException("timeline/events is missing");
+
+	if (!object.contains("prev_batch"))
+		throw DeserializationException("timeline/prev_batch is missing");
+
+	if (!object.contains("limited"))
+		throw DeserializationException("timeline/limited is missing");
+
+	prev_batch_ = object.value("prev_batch").toString();
+	limited_ = object.value("limited").toBool();
+
+	if (!object.value("events").isArray())
+		throw DeserializationException("timeline/events is not a JSON array");
+
+	auto timeline_events = object.value("events").toArray();
+
+	for (int i = 0; i < timeline_events.count(); i++) {
+		Event event;
+
+		try {
+			event.deserialize(timeline_events.at(i));
+			events_.push_back(event);
+		} catch (DeserializationException &e) {
+			qWarning() << e.what();
+			qWarning() << "Skipping malformed timeline event";
+		}
+	}
+}
diff --git a/src/TextInputWidget.cc b/src/TextInputWidget.cc
new file mode 100644
index 00000000..ec92e77d
--- /dev/null
+++ b/src/TextInputWidget.cc
@@ -0,0 +1,91 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QDebug>
+#include <QPainter>
+#include <QStyleOption>
+
+#include "TextInputWidget.h"
+
+TextInputWidget::TextInputWidget(QWidget *parent)
+    : QWidget(parent)
+{
+	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+	setCursor(Qt::ArrowCursor);
+	setStyleSheet("background-color: #171919; height: 45px;");
+
+	top_layout_ = new QHBoxLayout();
+	top_layout_->setSpacing(6);
+	top_layout_->setContentsMargins(6, 0, 0, 0);
+
+	send_file_button_ = new FlatButton(this);
+	send_file_button_->setCursor(Qt::PointingHandCursor);
+
+	QIcon send_file_icon;
+	send_file_icon.addFile(":/icons/icons/clip-dark.png", QSize(), QIcon::Normal, QIcon::Off);
+	send_file_button_->setForegroundColor(QColor("#577275"));
+	send_file_button_->setIcon(send_file_icon);
+	send_file_button_->setIconSize(QSize(24, 24));
+
+	input_ = new QLineEdit(this);
+	input_->setPlaceholderText("Write a message...");
+	input_->setStyleSheet("color: #ebebeb; font-size: 10pt; border-radius: 0; padding: 2px; margin-bottom: 4px;");
+
+	send_message_button_ = new FlatButton(this);
+	send_message_button_->setCursor(Qt::PointingHandCursor);
+	send_message_button_->setForegroundColor(QColor("#577275"));
+
+	QIcon send_message_icon;
+	send_message_icon.addFile(":/icons/icons/share-dark.png", QSize(), QIcon::Normal, QIcon::Off);
+	send_message_button_->setIcon(send_message_icon);
+	send_message_button_->setIconSize(QSize(24, 24));
+
+	top_layout_->addWidget(send_file_button_);
+	top_layout_->addWidget(input_);
+	top_layout_->addWidget(send_message_button_);
+
+	setLayout(top_layout_);
+
+	connect(send_message_button_, SIGNAL(clicked()), this, SLOT(onSendButtonClicked()));
+	connect(input_, SIGNAL(returnPressed()), send_message_button_, SIGNAL(clicked()));
+}
+
+void TextInputWidget::onSendButtonClicked()
+{
+	auto msg_text = input_->text();
+
+	if (msg_text.isEmpty())
+		return;
+
+	emit sendTextMessage(msg_text);
+	input_->clear();
+}
+
+void TextInputWidget::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event);
+
+	QStyleOption option;
+	option.initFrom(this);
+
+	QPainter painter(this);
+	style()->drawPrimitive(QStyle::PE_Widget, &option, &painter, this);
+}
+
+TextInputWidget::~TextInputWidget()
+{
+}
diff --git a/src/TopRoomBar.cc b/src/TopRoomBar.cc
new file mode 100644
index 00000000..7e390bdf
--- /dev/null
+++ b/src/TopRoomBar.cc
@@ -0,0 +1,93 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QStyleOption>
+
+#include "TopRoomBar.h"
+
+TopRoomBar::TopRoomBar(QWidget *parent)
+    : QWidget(parent)
+{
+	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+	setMinimumSize(QSize(0, 70));
+	setStyleSheet("background-color: #171919; color: #ebebeb;");
+
+	top_layout_ = new QHBoxLayout();
+	top_layout_->setSpacing(10);
+	top_layout_->setContentsMargins(10, 10, 0, 10);
+
+	avatar_ = new Avatar(this);
+	avatar_->setLetter(QChar('?'));
+	avatar_->setBackgroundColor(QColor("#ebebeb"));
+	avatar_->setSize(45);
+
+	text_layout_ = new QVBoxLayout();
+	text_layout_->setSpacing(0);
+	text_layout_->setContentsMargins(0, 0, 0, 0);
+
+	name_label_ = new QLabel(this);
+	name_label_->setStyleSheet("font-size: 11pt;");
+
+	topic_label_ = new QLabel(this);
+	topic_label_->setStyleSheet("font-size: 10pt; color: #6c7278;");
+
+	text_layout_->addWidget(name_label_);
+	text_layout_->addWidget(topic_label_);
+
+	settings_button_ = new FlatButton(this);
+	settings_button_->setForegroundColor(QColor("#ebebeb"));
+	settings_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	settings_button_->setStyleSheet("width: 30px; height: 30px;");
+
+	QIcon settings_icon;
+	settings_icon.addFile(":/icons/icons/cog.png", QSize(), QIcon::Normal, QIcon::Off);
+	settings_button_->setIcon(settings_icon);
+	settings_button_->setIconSize(QSize(16, 16));
+
+	search_button_ = new FlatButton(this);
+	search_button_->setForegroundColor(QColor("#ebebeb"));
+	search_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	search_button_->setStyleSheet("width: 30px; height: 30px;");
+
+	QIcon search_icon;
+	search_icon.addFile(":/icons/icons/search.png", QSize(), QIcon::Normal, QIcon::Off);
+	search_button_->setIcon(search_icon);
+	search_button_->setIconSize(QSize(16, 16));
+
+	top_layout_->addWidget(avatar_);
+	top_layout_->addLayout(text_layout_);
+	top_layout_->addStretch(1);
+	top_layout_->addWidget(search_button_);
+	top_layout_->addWidget(settings_button_);
+
+	setLayout(top_layout_);
+}
+
+void TopRoomBar::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event);
+
+	QStyleOption option;
+	option.initFrom(this);
+
+	QPainter painter(this);
+	style()->drawPrimitive(QStyle::PE_Widget, &option, &painter, this);
+}
+
+TopRoomBar::~TopRoomBar()
+{
+}
diff --git a/src/UserInfoWidget.cc b/src/UserInfoWidget.cc
new file mode 100644
index 00000000..a617d212
--- /dev/null
+++ b/src/UserInfoWidget.cc
@@ -0,0 +1,104 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UserInfoWidget.h"
+#include "FlatButton.h"
+
+UserInfoWidget::UserInfoWidget(QWidget *parent)
+    : QWidget(parent)
+    , display_name_("User")
+    , userid_("@user:homeserver.org")
+{
+	QSizePolicy sizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
+
+	setSizePolicy(sizePolicy);
+	setMinimumSize(QSize(0, 65));
+
+	topLayout_ = new QHBoxLayout(this);
+	topLayout_->setSpacing(0);
+	topLayout_->setContentsMargins(5, 5, 5, 5);
+
+	avatarLayout_ = new QHBoxLayout();
+	textLayout_ = new QVBoxLayout();
+
+	userAvatar_ = new Avatar(this);
+	userAvatar_->setLetter(QChar('?'));
+	userAvatar_->setSize(50);
+	userAvatar_->setMaximumSize(QSize(55, 55));
+
+	displayNameLabel_ = new QLabel(this);
+	displayNameLabel_->setStyleSheet(
+		"padding: 0 9px;"
+		"color: #ebebeb;"
+		"font-size: 11pt;"
+		"margin-bottom: -10px;");
+	displayNameLabel_->setAlignment(Qt::AlignLeading | Qt::AlignLeft | Qt::AlignTop);
+
+	userIdLabel_ = new QLabel(this);
+	userIdLabel_->setStyleSheet(
+		"padding: 0 8px 8px 8px;"
+		"color: #5D6565;"
+		"font-size: 10pt;");
+	userIdLabel_->setAlignment(Qt::AlignLeading | Qt::AlignLeft | Qt::AlignVCenter);
+
+	avatarLayout_->addWidget(userAvatar_);
+	textLayout_->addWidget(displayNameLabel_);
+	textLayout_->addWidget(userIdLabel_);
+
+	topLayout_->addLayout(avatarLayout_);
+	topLayout_->addLayout(textLayout_);
+	topLayout_->addStretch(1);
+
+	buttonLayout_ = new QHBoxLayout();
+
+	settingsButton_ = new FlatButton(this);
+	settingsButton_->setForegroundColor(QColor("#ebebeb"));
+	settingsButton_->setCursor(QCursor(Qt::PointingHandCursor));
+	settingsButton_->setStyleSheet("width: 30px; height: 30px;");
+
+	QIcon icon;
+	icon.addFile(":/icons/icons/user-shape.png", QSize(), QIcon::Normal, QIcon::Off);
+
+	settingsButton_->setIcon(icon);
+	settingsButton_->setIconSize(QSize(16, 16));
+
+	buttonLayout_->addWidget(settingsButton_);
+
+	topLayout_->addLayout(buttonLayout_);
+}
+
+UserInfoWidget::~UserInfoWidget()
+{
+}
+
+void UserInfoWidget::setAvatar(const QImage &img)
+{
+	avatar_image_ = img;
+	userAvatar_->setImage(img);
+}
+
+void UserInfoWidget::setDisplayName(const QString &name)
+{
+	display_name_ = name;
+	displayNameLabel_->setText(name);
+}
+
+void UserInfoWidget::setUserId(const QString &userid)
+{
+	userid_ = userid;
+	userIdLabel_->setText(userid);
+}
diff --git a/src/WelcomePage.cc b/src/WelcomePage.cc
new file mode 100644
index 00000000..2220fad7
--- /dev/null
+++ b/src/WelcomePage.cc
@@ -0,0 +1,103 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QLayout>
+
+#include "WelcomePage.h"
+
+WelcomePage::WelcomePage(QWidget *parent)
+    : QWidget(parent)
+{
+	setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+
+	top_layout_ = new QVBoxLayout(this);
+	top_layout_->setSpacing(0);
+	top_layout_->setMargin(0);
+
+	intro_banner_ = new QLabel(this);
+	intro_banner_->setStyleSheet("background-color: #1c3133;");
+	intro_banner_->setAlignment(Qt::AlignCenter);
+
+	intro_text_ = new QLabel(this);
+	intro_text_->setText(QApplication::translate("WelcomePage",
+						     "<html>"
+						     "<head/>"
+						     "<body>"
+						     "    <p align=\"center\"><span style=\" font-size:28pt;\"> nheko </span></p>"
+						     "    <p align=\"center\" style=\"margin: 0; line-height: 2pt\">"
+						     "      <span style=\" font-size:12pt; color:#6d7387;\"> "
+						     "		A desktop client for Matrix, the open protocol for decentralized communication."
+						     "	    </span>"
+						     "    </p>\n"
+						     "    <p align=\"center\" style=\"margin: 1pt; line-height: 2pt;\">"
+						     "        <span style=\" font-size:12pt; color:#6d7387;\">Enjoy your stay!</span>"
+						     "    </p>"
+						     "</body>"
+						     "</html>",
+						     Q_NULLPTR));
+
+	top_layout_->addWidget(intro_banner_);
+	top_layout_->addWidget(intro_text_, 0, Qt::AlignCenter);
+
+	button_layout_ = new QHBoxLayout();
+	button_layout_->setSpacing(0);
+	button_layout_->setContentsMargins(0, 20, 0, 80);
+
+	register_button_ = new RaisedButton("REGISTER", this);
+	register_button_->setBackgroundColor(QColor("#171919"));
+	register_button_->setForegroundColor(QColor("#ebebeb"));
+	register_button_->setMinimumSize(240, 60);
+	register_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	register_button_->setFontSize(14);
+	register_button_->setCornerRadius(3);
+
+	login_button_ = new RaisedButton("LOGIN", this);
+	login_button_->setBackgroundColor(QColor("#171919"));
+	login_button_->setForegroundColor(QColor("#ebebeb"));
+	login_button_->setMinimumSize(240, 60);
+	login_button_->setCursor(QCursor(Qt::PointingHandCursor));
+	login_button_->setFontSize(14);
+	login_button_->setCornerRadius(3);
+
+	button_spacer_ = new QSpacerItem(20, 20, QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);
+
+	button_layout_->addStretch(1);
+	button_layout_->addWidget(register_button_);
+	button_layout_->addItem(button_spacer_);
+	button_layout_->addWidget(login_button_);
+	button_layout_->addStretch(1);
+
+	top_layout_->addLayout(button_layout_);
+
+	connect(register_button_, SIGNAL(clicked()), this, SLOT(onRegisterButtonClicked()));
+	connect(login_button_, SIGNAL(clicked()), this, SLOT(onLoginButtonClicked()));
+}
+
+void WelcomePage::onLoginButtonClicked()
+{
+	emit userLogin();
+}
+
+void WelcomePage::onRegisterButtonClicked()
+{
+	emit userRegister();
+}
+
+WelcomePage::~WelcomePage()
+{
+}
diff --git a/src/main.cc b/src/main.cc
new file mode 100644
index 00000000..9ef7ffd7
--- /dev/null
+++ b/src/main.cc
@@ -0,0 +1,48 @@
+/*
+ * nheko Copyright (C) 2017  Konstantinos Sideris <siderisk@auth.gr>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QApplication>
+#include <QFontDatabase>
+
+#include "MainWindow.h"
+
+int main(int argc, char *argv[])
+{
+	QCoreApplication::setApplicationName("nheko");
+	QCoreApplication::setApplicationVersion("Ωμέγa");
+	QCoreApplication::setOrganizationName("Nheko");
+
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-Light.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-Regular.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-Italic.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-Bold.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-BoldItalic.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-Semibold.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-SemiboldItalic.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-ExtraBold.ttf");
+	QFontDatabase::addApplicationFont(":/fonts/OpenSans-ExtraBoldItalic.ttf");
+
+	QApplication app(argc, argv);
+
+	QFont font("Open Sans");
+	app.setFont(font);
+
+	MainWindow w;
+	w.show();
+
+	return app.exec();
+}
diff --git a/src/ui/Avatar.cc b/src/ui/Avatar.cc
new file mode 100644
index 00000000..4245c168
--- /dev/null
+++ b/src/ui/Avatar.cc
@@ -0,0 +1,143 @@
+#include <QIcon>
+#include <QPainter>
+#include <QWidget>
+
+#include "Avatar.h"
+
+Avatar::Avatar(QWidget *parent)
+    : QWidget(parent)
+{
+	size_ = ui::AvatarSize;
+	type_ = ui::AvatarType::Letter;
+	letter_ = QChar('A');
+
+	QFont _font(font());
+	_font.setPointSizeF(ui::FontSize);
+	setFont(_font);
+
+	QSizePolicy policy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
+	setSizePolicy(policy);
+}
+
+Avatar::~Avatar()
+{
+}
+
+QColor Avatar::textColor() const
+{
+	if (!text_color_.isValid())
+		return QColor("black");
+
+	return text_color_;
+}
+
+QColor Avatar::backgroundColor() const
+{
+	if (!text_color_.isValid())
+		return QColor("white");
+
+	return background_color_;
+}
+
+int Avatar::size() const
+{
+	return size_;
+}
+
+QSize Avatar::sizeHint() const
+{
+	return QSize(size_ + 2, size_ + 2);
+}
+
+void Avatar::setTextColor(const QColor &color)
+{
+	text_color_ = color;
+}
+
+void Avatar::setBackgroundColor(const QColor &color)
+{
+	background_color_ = color;
+}
+
+void Avatar::setSize(int size)
+{
+	size_ = size;
+
+	if (!image_.isNull()) {
+		pixmap_ = QPixmap::fromImage(
+			image_.scaled(size_, size_, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+	}
+
+	QFont _font(font());
+	_font.setPointSizeF(size_ * (ui::FontSize) / 40);
+
+	setFont(_font);
+	update();
+}
+
+void Avatar::setLetter(const QChar &letter)
+{
+	letter_ = letter;
+	type_ = ui::AvatarType::Letter;
+	update();
+}
+
+void Avatar::setImage(const QImage &image)
+{
+	image_ = image;
+	type_ = ui::AvatarType::Image;
+	pixmap_ = QPixmap::fromImage(
+		image_.scaled(size_, size_, Qt::KeepAspectRatio, Qt::SmoothTransformation));
+	update();
+}
+
+void Avatar::setIcon(const QIcon &icon)
+{
+	icon_ = icon;
+	type_ = ui::AvatarType::Icon;
+	update();
+}
+
+void Avatar::paintEvent(QPaintEvent *)
+{
+	QPainter painter(this);
+	painter.setRenderHint(QPainter::Antialiasing);
+
+	QRect r = rect();
+	const int hs = size_ / 2;
+
+	if (type_ != ui::AvatarType::Image) {
+		QBrush brush;
+		brush.setStyle(Qt::SolidPattern);
+		brush.setColor(backgroundColor());
+
+		painter.setPen(Qt::NoPen);
+		painter.setBrush(brush);
+		painter.drawEllipse(r.center(), hs, hs);
+	}
+
+	switch (type_) {
+	case ui::AvatarType::Icon: {
+		icon_.paint(&painter,
+			    QRect((width() - hs) / 2, (height() - hs) / 2, hs, hs),
+			    Qt::AlignCenter,
+			    QIcon::Normal);
+		break;
+	}
+	case ui::AvatarType::Image: {
+		QPainterPath ppath;
+		ppath.addEllipse(width() / 2 - hs, height() / 2 - hs, size_, size_);
+		painter.setClipPath(ppath);
+		painter.drawPixmap(QRect(width() / 2 - hs, height() / 2 - hs, size_, size_), pixmap_);
+		break;
+	}
+	case ui::AvatarType::Letter: {
+		painter.setPen(textColor());
+		painter.setBrush(Qt::NoBrush);
+		painter.drawText(r.translated(0, -1), Qt::AlignCenter, letter_);
+		break;
+	}
+	default:
+		break;
+	}
+}
diff --git a/src/ui/Badge.cc b/src/ui/Badge.cc
new file mode 100644
index 00000000..05531f6c
--- /dev/null
+++ b/src/ui/Badge.cc
@@ -0,0 +1,186 @@
+#include <QPainter>
+
+#include "Badge.h"
+
+Badge::Badge(QWidget *parent)
+    : OverlayWidget(parent)
+{
+	init();
+}
+
+Badge::Badge(const QIcon &icon, QWidget *parent)
+    : OverlayWidget(parent)
+{
+	init();
+	setIcon(icon);
+}
+
+Badge::Badge(const QString &text, QWidget *parent)
+    : OverlayWidget(parent)
+{
+	init();
+	setText(text);
+}
+
+Badge::~Badge()
+{
+}
+
+void Badge::init()
+{
+	x_ = 0;
+	y_ = 0;
+	padding_ = 10;
+
+	setAttribute(Qt::WA_TransparentForMouseEvents);
+
+	QFont _font(font());
+	_font.setPointSizeF(10);
+	_font.setStyleName("Bold");
+
+	setFont(_font);
+	setText("");
+}
+
+QString Badge::text() const
+{
+	return text_;
+}
+
+QIcon Badge::icon() const
+{
+	return icon_;
+}
+
+QSize Badge::sizeHint() const
+{
+	const int d = getDiameter();
+	return QSize(d + 4, d + 4);
+}
+
+qreal Badge::relativeYPosition() const
+{
+	return y_;
+}
+
+qreal Badge::relativeXPosition() const
+{
+	return x_;
+}
+
+QPointF Badge::relativePosition() const
+{
+	return QPointF(x_, y_);
+}
+
+QColor Badge::backgroundColor() const
+{
+	if (!background_color_.isValid())
+		return QColor("black");
+
+	return background_color_;
+}
+
+QColor Badge::textColor() const
+{
+	if (!text_color_.isValid())
+		return QColor("white");
+
+	return text_color_;
+}
+
+void Badge::setTextColor(const QColor &color)
+{
+	text_color_ = color;
+}
+
+void Badge::setBackgroundColor(const QColor &color)
+{
+	background_color_ = color;
+}
+
+void Badge::setRelativePosition(const QPointF &pos)
+{
+	setRelativePosition(pos.x(), pos.y());
+}
+
+void Badge::setRelativePosition(qreal x, qreal y)
+{
+	x_ = x;
+	y_ = y;
+	update();
+}
+
+void Badge::setRelativeXPosition(qreal x)
+{
+	x_ = x;
+	update();
+}
+
+void Badge::setRelativeYPosition(qreal y)
+{
+	y_ = y;
+	update();
+}
+
+void Badge::setIcon(const QIcon &icon)
+{
+	icon_ = icon;
+	update();
+}
+
+void Badge::setText(const QString &text)
+{
+	text_ = text;
+
+	if (!icon_.isNull())
+		icon_ = QIcon();
+
+	size_ = fontMetrics().size(Qt::TextShowMnemonic, text);
+
+	update();
+}
+
+void Badge::paintEvent(QPaintEvent *)
+{
+	QPainter painter(this);
+	painter.setRenderHint(QPainter::Antialiasing);
+	painter.translate(x_, y_);
+
+	QBrush brush;
+	brush.setStyle(Qt::SolidPattern);
+	brush.setColor(isEnabled() ? backgroundColor() : QColor("#cccccc"));
+
+	painter.setBrush(brush);
+	painter.setPen(Qt::NoPen);
+
+	const int d = getDiameter();
+
+	QRectF r(0, 0, d, d);
+	r.translate(QPointF((width() - d), (height() - d)) / 2);
+
+	if (icon_.isNull()) {
+		painter.drawEllipse(r);
+		painter.setPen(textColor());
+		painter.setBrush(Qt::NoBrush);
+		painter.drawText(r.translated(0, -0.5), Qt::AlignCenter, text_);
+	} else {
+		painter.drawEllipse(r);
+		QRectF q(0, 0, 16, 16);
+		q.moveCenter(r.center());
+		QPixmap pixmap = icon().pixmap(16, 16);
+		QPainter icon(&pixmap);
+		icon.setCompositionMode(QPainter::CompositionMode_SourceIn);
+		icon.fillRect(pixmap.rect(), textColor());
+		painter.drawPixmap(q.toRect(), pixmap);
+	}
+}
+
+int Badge::getDiameter() const
+{
+	if (icon_.isNull()) {
+		return qMax(size_.width(), size_.height()) + padding_;
+	}
+	// FIXME: Move this to Theme.h as the default
+	return 24;
+}
diff --git a/src/ui/FlatButton.cc b/src/ui/FlatButton.cc
new file mode 100644
index 00000000..97711de5
--- /dev/null
+++ b/src/ui/FlatButton.cc
@@ -0,0 +1,761 @@
+
+#include <QBitmap>
+#include <QEventTransition>
+#include <QFontDatabase>
+#include <QIcon>
+#include <QMouseEvent>
+#include <QPainter>
+#include <QPainterPath>
+#include <QResizeEvent>
+#include <QSequentialAnimationGroup>
+#include <QSignalTransition>
+
+#include "FlatButton.h"
+#include "Ripple.h"
+#include "RippleOverlay.h"
+#include "ThemeManager.h"
+
+void FlatButton::init()
+{
+	ripple_overlay_ = new RippleOverlay(this);
+	state_machine_ = new FlatButtonStateMachine(this);
+	role_ = ui::Default;
+	ripple_style_ = ui::PositionedRipple;
+	icon_placement_ = ui::LeftIcon;
+	overlay_style_ = ui::GrayOverlay;
+	bg_mode_ = Qt::TransparentMode;
+	fixed_ripple_radius_ = 64;
+	corner_radius_ = 3;
+	base_opacity_ = 0.13;
+	font_size_ = 10;  // 10.5;
+	use_fixed_ripple_radius_ = false;
+	halo_visible_ = false;
+
+	setStyle(&ThemeManager::instance());
+	setAttribute(Qt::WA_Hover);
+	setMouseTracking(true);
+
+	QPainterPath path;
+	path.addRoundedRect(rect(), corner_radius_, corner_radius_);
+
+	ripple_overlay_->setClipPath(path);
+	ripple_overlay_->setClipping(true);
+
+	state_machine_->setupProperties();
+	state_machine_->startAnimations();
+}
+
+FlatButton::FlatButton(QWidget *parent, ui::ButtonPreset preset)
+    : QPushButton(parent)
+{
+	init();
+	applyPreset(preset);
+}
+
+FlatButton::FlatButton(const QString &text, QWidget *parent, ui::ButtonPreset preset)
+    : QPushButton(text, parent)
+{
+	init();
+	applyPreset(preset);
+}
+
+FlatButton::FlatButton(const QString &text, ui::Role role, QWidget *parent, ui::ButtonPreset preset)
+    : QPushButton(text, parent)
+{
+	init();
+	applyPreset(preset);
+	setRole(role);
+}
+
+FlatButton::~FlatButton()
+{
+}
+
+void FlatButton::applyPreset(ui::ButtonPreset preset)
+{
+	switch (preset) {
+	case ui::FlatPreset:
+		setOverlayStyle(ui::NoOverlay);
+		break;
+	case ui::CheckablePreset:
+		setOverlayStyle(ui::NoOverlay);
+		setCheckable(true);
+		setHaloVisible(false);
+		break;
+	default:
+		break;
+	}
+}
+
+void FlatButton::setRole(ui::Role role)
+{
+	role_ = role;
+	state_machine_->setupProperties();
+}
+
+ui::Role FlatButton::role() const
+{
+	return role_;
+}
+
+void FlatButton::setForegroundColor(const QColor &color)
+{
+	foreground_color_ = color;
+}
+
+QColor FlatButton::foregroundColor() const
+{
+	if (!foreground_color_.isValid()) {
+		if (bg_mode_ == Qt::OpaqueMode) {
+			return ThemeManager::instance().themeColor("BrightWhite");
+		}
+
+		switch (role_) {
+		case ui::Primary:
+			return ThemeManager::instance().themeColor("Blue");
+		case ui::Secondary:
+			return ThemeManager::instance().themeColor("Gray");
+		case ui::Default:
+		default:
+			return ThemeManager::instance().themeColor("Black");
+		}
+	}
+
+	return foreground_color_;
+}
+
+void FlatButton::setBackgroundColor(const QColor &color)
+{
+	background_color_ = color;
+}
+
+QColor FlatButton::backgroundColor() const
+{
+	if (!background_color_.isValid()) {
+		switch (role_) {
+		case ui::Primary:
+			return ThemeManager::instance().themeColor("Blue");
+		case ui::Secondary:
+			return ThemeManager::instance().themeColor("Gray");
+		case ui::Default:
+		default:
+			return ThemeManager::instance().themeColor("Black");
+		}
+	}
+
+	return background_color_;
+}
+
+void FlatButton::setOverlayColor(const QColor &color)
+{
+	overlay_color_ = color;
+	setOverlayStyle(ui::TintedOverlay);
+}
+
+QColor FlatButton::overlayColor() const
+{
+	if (!overlay_color_.isValid()) {
+		return foregroundColor();
+	}
+
+	return overlay_color_;
+}
+
+void FlatButton::setDisabledForegroundColor(const QColor &color)
+{
+	disabled_color_ = color;
+}
+
+QColor FlatButton::disabledForegroundColor() const
+{
+	if (!disabled_color_.isValid()) {
+		return ThemeManager::instance().themeColor("FadedWhite");
+	}
+
+	return disabled_color_;
+}
+
+void FlatButton::setDisabledBackgroundColor(const QColor &color)
+{
+	disabled_background_color_ = color;
+}
+
+QColor FlatButton::disabledBackgroundColor() const
+{
+	if (!disabled_background_color_.isValid()) {
+		return ThemeManager::instance().themeColor("FadedWhite");
+	}
+
+	return disabled_background_color_;
+}
+
+void FlatButton::setFontSize(qreal size)
+{
+	font_size_ = size;
+
+	QFont f(font());
+	f.setPointSizeF(size);
+	setFont(f);
+
+	update();
+}
+
+qreal FlatButton::fontSize() const
+{
+	return font_size_;
+}
+
+void FlatButton::setHaloVisible(bool visible)
+{
+	halo_visible_ = visible;
+	update();
+}
+
+bool FlatButton::isHaloVisible() const
+{
+	return halo_visible_;
+}
+
+void FlatButton::setOverlayStyle(ui::OverlayStyle style)
+{
+	overlay_style_ = style;
+	update();
+}
+
+ui::OverlayStyle FlatButton::overlayStyle() const
+{
+	return overlay_style_;
+}
+
+void FlatButton::setRippleStyle(ui::RippleStyle style)
+{
+	ripple_style_ = style;
+}
+
+ui::RippleStyle FlatButton::rippleStyle() const
+{
+	return ripple_style_;
+}
+
+void FlatButton::setIconPlacement(ui::ButtonIconPlacement placement)
+{
+	icon_placement_ = placement;
+	update();
+}
+
+ui::ButtonIconPlacement FlatButton::iconPlacement() const
+{
+	return icon_placement_;
+}
+
+void FlatButton::setCornerRadius(qreal radius)
+{
+	corner_radius_ = radius;
+	updateClipPath();
+	update();
+}
+
+qreal FlatButton::cornerRadius() const
+{
+	return corner_radius_;
+}
+
+void FlatButton::setBackgroundMode(Qt::BGMode mode)
+{
+	bg_mode_ = mode;
+	state_machine_->setupProperties();
+}
+
+Qt::BGMode FlatButton::backgroundMode() const
+{
+	return bg_mode_;
+}
+
+void FlatButton::setBaseOpacity(qreal opacity)
+{
+	base_opacity_ = opacity;
+	state_machine_->setupProperties();
+}
+
+qreal FlatButton::baseOpacity() const
+{
+	return base_opacity_;
+}
+
+void FlatButton::setCheckable(bool value)
+{
+	state_machine_->updateCheckedStatus();
+	state_machine_->setCheckedOverlayProgress(0);
+
+	QPushButton::setCheckable(value);
+}
+
+void FlatButton::setHasFixedRippleRadius(bool value)
+{
+	use_fixed_ripple_radius_ = value;
+}
+
+bool FlatButton::hasFixedRippleRadius() const
+{
+	return use_fixed_ripple_radius_;
+}
+
+void FlatButton::setFixedRippleRadius(qreal radius)
+{
+	fixed_ripple_radius_ = radius;
+	setHasFixedRippleRadius(true);
+}
+
+QSize FlatButton::sizeHint() const
+{
+	ensurePolished();
+
+	QSize label(fontMetrics().size(Qt::TextSingleLine, text()));
+
+	int w = 20 + label.width();
+	int h = label.height();
+
+	if (!icon().isNull()) {
+		w += iconSize().width() + FlatButton::IconPadding;
+		h = qMax(h, iconSize().height());
+	}
+
+	return QSize(w, 20 + h);
+}
+
+void FlatButton::checkStateSet()
+{
+	state_machine_->updateCheckedStatus();
+	QPushButton::checkStateSet();
+}
+
+void FlatButton::mousePressEvent(QMouseEvent *event)
+{
+	if (ui::NoRipple != ripple_style_) {
+		QPoint pos;
+		qreal radiusEndValue;
+
+		if (ui::CenteredRipple == ripple_style_) {
+			pos = rect().center();
+		} else {
+			pos = event->pos();
+		}
+
+		if (use_fixed_ripple_radius_) {
+			radiusEndValue = fixed_ripple_radius_;
+		} else {
+			radiusEndValue = static_cast<qreal>(width()) / 2;
+		}
+
+		Ripple *ripple = new Ripple(pos);
+
+		ripple->setRadiusEndValue(radiusEndValue);
+		ripple->setOpacityStartValue(0.35);
+		ripple->setColor(foregroundColor());
+		ripple->radiusAnimation()->setDuration(600);
+		ripple->opacityAnimation()->setDuration(1300);
+
+		ripple_overlay_->addRipple(ripple);
+	}
+
+	QPushButton::mousePressEvent(event);
+}
+
+void FlatButton::mouseReleaseEvent(QMouseEvent *event)
+{
+	QPushButton::mouseReleaseEvent(event);
+	state_machine_->updateCheckedStatus();
+}
+
+void FlatButton::resizeEvent(QResizeEvent *event)
+{
+	QPushButton::resizeEvent(event);
+	updateClipPath();
+}
+
+void FlatButton::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event)
+
+	QPainter painter(this);
+	painter.setRenderHint(QPainter::Antialiasing);
+
+	const qreal cr = corner_radius_;
+
+	if (cr > 0) {
+		QPainterPath path;
+		path.addRoundedRect(rect(), cr, cr);
+
+		painter.setClipPath(path);
+		painter.setClipping(true);
+	}
+
+	paintBackground(&painter);
+	paintHalo(&painter);
+
+	painter.setOpacity(1);
+	painter.setClipping(false);
+
+	paintForeground(&painter);
+}
+
+void FlatButton::paintBackground(QPainter *painter)
+{
+	const qreal overlayOpacity = state_machine_->overlayOpacity();
+	const qreal checkedProgress = state_machine_->checkedOverlayProgress();
+
+	if (Qt::OpaqueMode == bg_mode_) {
+		QBrush brush;
+		brush.setStyle(Qt::SolidPattern);
+
+		if (isEnabled()) {
+			brush.setColor(backgroundColor());
+		} else {
+			brush.setColor(disabledBackgroundColor());
+		}
+
+		painter->setOpacity(1);
+		painter->setBrush(brush);
+		painter->setPen(Qt::NoPen);
+		painter->drawRect(rect());
+	}
+
+	QBrush brush;
+	brush.setStyle(Qt::SolidPattern);
+	painter->setPen(Qt::NoPen);
+
+	if (!isEnabled()) {
+		return;
+	}
+
+	if ((ui::NoOverlay != overlay_style_) && (overlayOpacity > 0)) {
+		if (ui::TintedOverlay == overlay_style_) {
+			brush.setColor(overlayColor());
+		} else {
+			brush.setColor(Qt::gray);
+		}
+
+		painter->setOpacity(overlayOpacity);
+		painter->setBrush(brush);
+		painter->drawRect(rect());
+	}
+
+	if (isCheckable() && checkedProgress > 0) {
+		const qreal q = Qt::TransparentMode == bg_mode_ ? 0.45 : 0.7;
+		brush.setColor(foregroundColor());
+		painter->setOpacity(q * checkedProgress);
+		painter->setBrush(brush);
+		QRect r(rect());
+		r.setHeight(static_cast<qreal>(r.height()) * checkedProgress);
+		painter->drawRect(r);
+	}
+}
+
+void FlatButton::paintHalo(QPainter *painter)
+{
+	if (!halo_visible_)
+		return;
+
+	const qreal opacity = state_machine_->haloOpacity();
+	const qreal s = state_machine_->haloScaleFactor() * state_machine_->haloSize();
+	const qreal radius = static_cast<qreal>(width()) * s;
+
+	if (isEnabled() && opacity > 0) {
+		QBrush brush;
+		brush.setStyle(Qt::SolidPattern);
+		brush.setColor(foregroundColor());
+		painter->setOpacity(opacity);
+		painter->setBrush(brush);
+		painter->setPen(Qt::NoPen);
+		const QPointF center = rect().center();
+		painter->drawEllipse(center, radius, radius);
+	}
+}
+
+#define COLOR_INTERPOLATE(CH) (1 - progress) * source.CH() + progress *dest.CH()
+
+void FlatButton::paintForeground(QPainter *painter)
+{
+	if (isEnabled()) {
+		painter->setPen(foregroundColor());
+		const qreal progress = state_machine_->checkedOverlayProgress();
+
+		if (isCheckable() && progress > 0) {
+			QColor source = foregroundColor();
+			QColor dest = Qt::TransparentMode == bg_mode_ ? Qt::white
+								      : backgroundColor();
+			if (qFuzzyCompare(1, progress)) {
+				painter->setPen(dest);
+			} else {
+				painter->setPen(QColor(COLOR_INTERPOLATE(red),
+						       COLOR_INTERPOLATE(green),
+						       COLOR_INTERPOLATE(blue),
+						       COLOR_INTERPOLATE(alpha)));
+			}
+		}
+	} else {
+		painter->setPen(disabledForegroundColor());
+	}
+
+	if (icon().isNull()) {
+		painter->drawText(rect(), Qt::AlignCenter, text());
+		return;
+	}
+
+	QSize textSize(fontMetrics().size(Qt::TextSingleLine, text()));
+	QSize base(size() - textSize);
+
+	const int iw = iconSize().width() + IconPadding;
+	QPoint pos((base.width() - iw) / 2, 0);
+
+	QRect textGeometry(pos + QPoint(0, base.height() / 2), textSize);
+	QRect iconGeometry(pos + QPoint(0, (height() - iconSize().height()) / 2), iconSize());
+
+	if (ui::LeftIcon == icon_placement_) {
+		textGeometry.translate(iw, 0);
+	} else {
+		iconGeometry.translate(textSize.width() + IconPadding, 0);
+	}
+
+	painter->drawText(textGeometry, Qt::AlignCenter, text());
+
+	QPixmap pixmap = icon().pixmap(iconSize());
+	QPainter icon(&pixmap);
+	icon.setCompositionMode(QPainter::CompositionMode_SourceIn);
+	icon.fillRect(pixmap.rect(), painter->pen().color());
+	painter->drawPixmap(iconGeometry, pixmap);
+}
+
+void FlatButton::updateClipPath()
+{
+	const qreal radius = corner_radius_;
+
+	QPainterPath path;
+	path.addRoundedRect(rect(), radius, radius);
+	ripple_overlay_->setClipPath(path);
+}
+
+FlatButtonStateMachine::FlatButtonStateMachine(FlatButton *parent)
+    : QStateMachine(parent)
+    , button_(parent)
+    , top_level_state_(new QState(QState::ParallelStates))
+    , config_state_(new QState(top_level_state_))
+    , checkable_state_(new QState(top_level_state_))
+    , checked_state_(new QState(checkable_state_))
+    , unchecked_state_(new QState(checkable_state_))
+    , neutral_state_(new QState(config_state_))
+    , neutral_focused_state_(new QState(config_state_))
+    , hovered_state_(new QState(config_state_))
+    , hovered_focused_state_(new QState(config_state_))
+    , pressed_state_(new QState(config_state_))
+    , halo_animation_(new QSequentialAnimationGroup(this))
+    , overlay_opacity_(0)
+    , checked_overlay_progress_(parent->isChecked() ? 1 : 0)
+    , halo_opacity_(0)
+    , halo_size_(0.8)
+    , halo_scale_factor_(1)
+    , was_checked_(false)
+{
+	Q_ASSERT(parent);
+
+	parent->installEventFilter(this);
+
+	config_state_->setInitialState(neutral_state_);
+	addState(top_level_state_);
+	setInitialState(top_level_state_);
+
+	checkable_state_->setInitialState(parent->isChecked() ? checked_state_
+							      : unchecked_state_);
+	QSignalTransition *transition;
+	QPropertyAnimation *animation;
+
+	transition = new QSignalTransition(this, SIGNAL(buttonChecked()));
+	transition->setTargetState(checked_state_);
+	unchecked_state_->addTransition(transition);
+
+	animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
+	animation->setDuration(200);
+	transition->addAnimation(animation);
+
+	transition = new QSignalTransition(this, SIGNAL(buttonUnchecked()));
+	transition->setTargetState(unchecked_state_);
+	checked_state_->addTransition(transition);
+
+	animation = new QPropertyAnimation(this, "checkedOverlayProgress", this);
+	animation->setDuration(200);
+	transition->addAnimation(animation);
+
+	addTransition(button_, QEvent::FocusIn, neutral_state_, neutral_focused_state_);
+	addTransition(button_, QEvent::FocusOut, neutral_focused_state_, neutral_state_);
+	addTransition(button_, QEvent::Enter, neutral_state_, hovered_state_);
+	addTransition(button_, QEvent::Leave, hovered_state_, neutral_state_);
+	addTransition(button_, QEvent::Enter, neutral_focused_state_, hovered_focused_state_);
+	addTransition(button_, QEvent::Leave, hovered_focused_state_, neutral_focused_state_);
+	addTransition(button_, QEvent::FocusIn, hovered_state_, hovered_focused_state_);
+	addTransition(button_, QEvent::FocusOut, hovered_focused_state_, hovered_state_);
+	addTransition(this, SIGNAL(buttonPressed()), hovered_state_, pressed_state_);
+	addTransition(button_, QEvent::Leave, pressed_state_, neutral_focused_state_);
+	addTransition(button_, QEvent::FocusOut, pressed_state_, hovered_state_);
+
+	neutral_state_->assignProperty(this, "haloSize", 0);
+	neutral_focused_state_->assignProperty(this, "haloSize", 0.7);
+	hovered_state_->assignProperty(this, "haloSize", 0);
+	pressed_state_->assignProperty(this, "haloSize", 4);
+	hovered_focused_state_->assignProperty(this, "haloSize", 0.7);
+
+	QPropertyAnimation *grow = new QPropertyAnimation(this);
+	QPropertyAnimation *shrink = new QPropertyAnimation(this);
+
+	grow->setTargetObject(this);
+	grow->setPropertyName("haloScaleFactor");
+	grow->setStartValue(0.56);
+	grow->setEndValue(0.63);
+	grow->setEasingCurve(QEasingCurve::InOutSine);
+	grow->setDuration(840);
+
+	shrink->setTargetObject(this);
+	shrink->setPropertyName("haloScaleFactor");
+	shrink->setStartValue(0.63);
+	shrink->setEndValue(0.56);
+	shrink->setEasingCurve(QEasingCurve::InOutSine);
+	shrink->setDuration(840);
+
+	halo_animation_->addAnimation(grow);
+	halo_animation_->addAnimation(shrink);
+	halo_animation_->setLoopCount(-1);
+}
+
+FlatButtonStateMachine::~FlatButtonStateMachine()
+{
+}
+
+void FlatButtonStateMachine::setOverlayOpacity(qreal opacity)
+{
+	overlay_opacity_ = opacity;
+	button_->update();
+}
+
+void FlatButtonStateMachine::setCheckedOverlayProgress(qreal opacity)
+{
+	checked_overlay_progress_ = opacity;
+	button_->update();
+}
+
+void FlatButtonStateMachine::setHaloOpacity(qreal opacity)
+{
+	halo_opacity_ = opacity;
+	button_->update();
+}
+
+void FlatButtonStateMachine::setHaloSize(qreal size)
+{
+	halo_size_ = size;
+	button_->update();
+}
+
+void FlatButtonStateMachine::setHaloScaleFactor(qreal factor)
+{
+	halo_scale_factor_ = factor;
+	button_->update();
+}
+
+void FlatButtonStateMachine::startAnimations()
+{
+	halo_animation_->start();
+	start();
+}
+
+void FlatButtonStateMachine::setupProperties()
+{
+	QColor overlayColor;
+
+	if (Qt::TransparentMode == button_->backgroundMode()) {
+		overlayColor = button_->backgroundColor();
+	} else {
+		overlayColor = button_->foregroundColor();
+	}
+
+	const qreal baseOpacity = button_->baseOpacity();
+
+	neutral_state_->assignProperty(this, "overlayOpacity", 0);
+	neutral_state_->assignProperty(this, "haloOpacity", 0);
+	neutral_focused_state_->assignProperty(this, "overlayOpacity", 0);
+	neutral_focused_state_->assignProperty(this, "haloOpacity", baseOpacity);
+	hovered_state_->assignProperty(this, "overlayOpacity", baseOpacity);
+	hovered_state_->assignProperty(this, "haloOpacity", 0);
+	hovered_focused_state_->assignProperty(this, "overlayOpacity", baseOpacity);
+	hovered_focused_state_->assignProperty(this, "haloOpacity", baseOpacity);
+	pressed_state_->assignProperty(this, "overlayOpacity", baseOpacity);
+	pressed_state_->assignProperty(this, "haloOpacity", 0);
+	checked_state_->assignProperty(this, "checkedOverlayProgress", 1);
+	unchecked_state_->assignProperty(this, "checkedOverlayProgress", 0);
+
+	button_->update();
+}
+
+void FlatButtonStateMachine::updateCheckedStatus()
+{
+	const bool checked = button_->isChecked();
+	if (was_checked_ != checked) {
+		was_checked_ = checked;
+		if (checked) {
+			emit buttonChecked();
+		} else {
+			emit buttonUnchecked();
+		}
+	}
+}
+
+bool FlatButtonStateMachine::eventFilter(QObject *watched,
+					 QEvent *event)
+{
+	if (QEvent::FocusIn == event->type()) {
+		QFocusEvent *focusEvent = static_cast<QFocusEvent *>(event);
+		if (focusEvent && Qt::MouseFocusReason == focusEvent->reason()) {
+			emit buttonPressed();
+			return true;
+		}
+	}
+
+	return QStateMachine::eventFilter(watched, event);
+}
+
+void FlatButtonStateMachine::addTransition(QObject *object,
+					   const char *signal,
+					   QState *fromState,
+					   QState *toState)
+{
+	addTransition(new QSignalTransition(object, signal), fromState, toState);
+}
+
+void FlatButtonStateMachine::addTransition(QObject *object,
+					   QEvent::Type eventType,
+					   QState *fromState,
+					   QState *toState)
+{
+	addTransition(new QEventTransition(object, eventType), fromState, toState);
+}
+
+void FlatButtonStateMachine::addTransition(QAbstractTransition *transition,
+					   QState *fromState,
+					   QState *toState)
+{
+	transition->setTargetState(toState);
+
+	QPropertyAnimation *animation;
+
+	animation = new QPropertyAnimation(this, "overlayOpacity", this);
+	animation->setDuration(150);
+	transition->addAnimation(animation);
+
+	animation = new QPropertyAnimation(this, "haloOpacity", this);
+	animation->setDuration(170);
+	transition->addAnimation(animation);
+
+	animation = new QPropertyAnimation(this, "haloSize", this);
+	animation->setDuration(350);
+	animation->setEasingCurve(QEasingCurve::OutCubic);
+	transition->addAnimation(animation);
+
+	fromState->addTransition(transition);
+}
diff --git a/src/ui/OverlayWidget.cc b/src/ui/OverlayWidget.cc
new file mode 100644
index 00000000..b4dfb918
--- /dev/null
+++ b/src/ui/OverlayWidget.cc
@@ -0,0 +1,59 @@
+#include "OverlayWidget.h"
+#include <QEvent>
+
+OverlayWidget::OverlayWidget(QWidget *parent)
+    : QWidget(parent)
+{
+	if (parent)
+		parent->installEventFilter(this);
+}
+
+OverlayWidget::~OverlayWidget()
+{
+}
+
+bool OverlayWidget::event(QEvent *event)
+{
+	if (!parent())
+		return QWidget::event(event);
+
+	switch (event->type()) {
+	case QEvent::ParentChange: {
+		parent()->installEventFilter(this);
+		setGeometry(overlayGeometry());
+		break;
+	}
+	case QEvent::ParentAboutToChange: {
+		parent()->removeEventFilter(this);
+		break;
+	}
+	default:
+		break;
+	}
+
+	return QWidget::event(event);
+}
+
+bool OverlayWidget::eventFilter(QObject *obj, QEvent *event)
+{
+	switch (event->type()) {
+	case QEvent::Move:
+	case QEvent::Resize:
+		setGeometry(overlayGeometry());
+		break;
+	default:
+		break;
+	}
+
+	return QWidget::eventFilter(obj, event);
+}
+
+QRect OverlayWidget::overlayGeometry() const
+{
+	QWidget *widget = parentWidget();
+
+	if (!widget)
+		return QRect();
+
+	return widget->rect();
+}
diff --git a/src/ui/RaisedButton.cc b/src/ui/RaisedButton.cc
new file mode 100644
index 00000000..74f549c4
--- /dev/null
+++ b/src/ui/RaisedButton.cc
@@ -0,0 +1,92 @@
+#include <QEventTransition>
+#include <QGraphicsDropShadowEffect>
+#include <QPropertyAnimation>
+#include <QState>
+#include <QStateMachine>
+
+#include "RaisedButton.h"
+
+void RaisedButton::init()
+{
+	shadow_state_machine_ = new QStateMachine(this);
+	normal_state_ = new QState;
+	pressed_state_ = new QState;
+	effect_ = new QGraphicsDropShadowEffect;
+
+	effect_->setBlurRadius(7);
+	effect_->setOffset(QPointF(0, 2));
+	effect_->setColor(QColor(0, 0, 0, 75));
+
+	setBackgroundMode(Qt::OpaqueMode);
+	setMinimumHeight(42);
+	setGraphicsEffect(effect_);
+	setBaseOpacity(0.3);
+
+	shadow_state_machine_->addState(normal_state_);
+	shadow_state_machine_->addState(pressed_state_);
+
+	normal_state_->assignProperty(effect_, "offset", QPointF(0, 2));
+	normal_state_->assignProperty(effect_, "blurRadius", 7);
+
+	pressed_state_->assignProperty(effect_, "offset", QPointF(0, 5));
+	pressed_state_->assignProperty(effect_, "blurRadius", 29);
+
+	QAbstractTransition *transition;
+
+	transition = new QEventTransition(this, QEvent::MouseButtonPress);
+	transition->setTargetState(pressed_state_);
+	normal_state_->addTransition(transition);
+
+	transition = new QEventTransition(this, QEvent::MouseButtonDblClick);
+	transition->setTargetState(pressed_state_);
+	normal_state_->addTransition(transition);
+
+	transition = new QEventTransition(this, QEvent::MouseButtonRelease);
+	transition->setTargetState(normal_state_);
+	pressed_state_->addTransition(transition);
+
+	QPropertyAnimation *animation;
+
+	animation = new QPropertyAnimation(effect_, "offset", this);
+	animation->setDuration(100);
+	shadow_state_machine_->addDefaultAnimation(animation);
+
+	animation = new QPropertyAnimation(effect_, "blurRadius", this);
+	animation->setDuration(100);
+	shadow_state_machine_->addDefaultAnimation(animation);
+
+	shadow_state_machine_->setInitialState(normal_state_);
+	shadow_state_machine_->start();
+}
+
+RaisedButton::RaisedButton(QWidget *parent)
+    : FlatButton(parent)
+{
+	init();
+}
+
+RaisedButton::RaisedButton(const QString &text, QWidget *parent)
+    : FlatButton(parent)
+{
+	init();
+	setText(text);
+}
+
+RaisedButton::~RaisedButton()
+{
+}
+
+bool RaisedButton::event(QEvent *event)
+{
+	if (QEvent::EnabledChange == event->type()) {
+		if (isEnabled()) {
+			shadow_state_machine_->start();
+			effect_->setEnabled(true);
+		} else {
+			shadow_state_machine_->stop();
+			effect_->setEnabled(false);
+		}
+	}
+
+	return FlatButton::event(event);
+}
diff --git a/src/ui/Ripple.cc b/src/ui/Ripple.cc
new file mode 100644
index 00000000..107bfd7f
--- /dev/null
+++ b/src/ui/Ripple.cc
@@ -0,0 +1,106 @@
+#include "Ripple.h"
+#include "RippleOverlay.h"
+
+Ripple::Ripple(const QPoint &center, QObject *parent)
+    : QParallelAnimationGroup(parent)
+    , overlay_(0)
+    , radius_anim_(animate("radius"))
+    , opacity_anim_(animate("opacity"))
+    , radius_(0)
+    , opacity_(0)
+    , center_(center)
+{
+	init();
+}
+
+Ripple::Ripple(const QPoint &center, RippleOverlay *overlay, QObject *parent)
+    : QParallelAnimationGroup(parent)
+    , overlay_(overlay)
+    , radius_anim_(animate("radius"))
+    , opacity_anim_(animate("opacity"))
+    , radius_(0)
+    , opacity_(0)
+    , center_(center)
+{
+	init();
+}
+
+Ripple::~Ripple()
+{
+}
+
+void Ripple::setRadius(qreal radius)
+{
+	Q_ASSERT(overlay_);
+
+	if (radius_ == radius)
+		return;
+
+	radius_ = radius;
+	overlay_->update();
+}
+
+void Ripple::setOpacity(qreal opacity)
+{
+	Q_ASSERT(overlay_);
+
+	if (opacity_ == opacity)
+		return;
+
+	opacity_ = opacity;
+	overlay_->update();
+}
+
+void Ripple::setColor(const QColor &color)
+{
+	if (brush_.color() == color)
+		return;
+
+	brush_.setColor(color);
+
+	if (overlay_)
+		overlay_->update();
+}
+
+void Ripple::setBrush(const QBrush &brush)
+{
+	brush_ = brush;
+
+	if (overlay_)
+		overlay_->update();
+}
+
+void Ripple::destroy()
+{
+	Q_ASSERT(overlay_);
+
+	overlay_->removeRipple(this);
+}
+
+QPropertyAnimation *Ripple::animate(const QByteArray &property,
+				    const QEasingCurve &easing,
+				    int duration)
+{
+	QPropertyAnimation *animation = new QPropertyAnimation;
+	animation->setTargetObject(this);
+	animation->setPropertyName(property);
+	animation->setEasingCurve(easing);
+	animation->setDuration(duration);
+
+	addAnimation(animation);
+
+	return animation;
+}
+
+void Ripple::init()
+{
+	setOpacityStartValue(0.5);
+	setOpacityEndValue(0);
+	setRadiusStartValue(0);
+	setRadiusEndValue(300);
+
+	brush_.setColor(Qt::black);
+	brush_.setStyle(Qt::SolidPattern);
+
+	connect(this, SIGNAL(finished()), this, SLOT(destroy()));
+}
diff --git a/src/ui/RippleOverlay.cc b/src/ui/RippleOverlay.cc
new file mode 100644
index 00000000..add030d9
--- /dev/null
+++ b/src/ui/RippleOverlay.cc
@@ -0,0 +1,61 @@
+#include <QPainter>
+
+#include "Ripple.h"
+#include "RippleOverlay.h"
+
+RippleOverlay::RippleOverlay(QWidget *parent)
+    : OverlayWidget(parent)
+    , use_clip_(false)
+{
+	setAttribute(Qt::WA_TransparentForMouseEvents);
+	setAttribute(Qt::WA_NoSystemBackground);
+}
+
+RippleOverlay::~RippleOverlay()
+{
+}
+
+void RippleOverlay::addRipple(Ripple *ripple)
+{
+	ripple->setOverlay(this);
+	ripples_.push_back(ripple);
+	ripple->start();
+}
+
+void RippleOverlay::addRipple(const QPoint &position, qreal radius)
+{
+	Ripple *ripple = new Ripple(position);
+	ripple->setRadiusEndValue(radius);
+	addRipple(ripple);
+}
+
+void RippleOverlay::removeRipple(Ripple *ripple)
+{
+	if (ripples_.removeOne(ripple))
+		delete ripple;
+}
+
+void RippleOverlay::paintEvent(QPaintEvent *event)
+{
+	Q_UNUSED(event)
+
+	QPainter painter(this);
+	painter.setRenderHint(QPainter::Antialiasing);
+	painter.setPen(Qt::NoPen);
+
+	if (use_clip_)
+		painter.setClipPath(clip_path_);
+
+	for (auto it = ripples_.constBegin(); it != ripples_.constEnd(); it++)
+		paintRipple(&painter, *it);
+}
+
+void RippleOverlay::paintRipple(QPainter *painter, Ripple *ripple)
+{
+	const qreal radius = ripple->radius();
+	const QPointF center = ripple->center();
+
+	painter->setOpacity(ripple->opacity());
+	painter->setBrush(ripple->brush());
+	painter->drawEllipse(center, radius, radius);
+}
diff --git a/src/ui/TextField.cc b/src/ui/TextField.cc
new file mode 100644
index 00000000..3b701549
--- /dev/null
+++ b/src/ui/TextField.cc
@@ -0,0 +1,346 @@
+#include "TextField.h"
+
+#include <QApplication>
+#include <QEventTransition>
+#include <QFontDatabase>
+#include <QPaintEvent>
+#include <QPainter>
+#include <QPropertyAnimation>
+
+TextField::TextField(QWidget *parent)
+    : QLineEdit(parent)
+{
+	state_machine_ = new TextFieldStateMachine(this);
+	label_ = 0;
+	label_font_size_ = 9.5;
+	show_label_ = false;
+	background_color_ = QColor("white");
+
+	setFrame(false);
+	setAttribute(Qt::WA_Hover);
+	setMouseTracking(true);
+	setTextMargins(0, 2, 0, 4);
+
+	QFontDatabase db;
+	QFont font(db.font("Open Sans", "Regular", 11));
+	setFont(font);
+
+	state_machine_->start();
+	QCoreApplication::processEvents();
+}
+
+TextField::~TextField()
+{
+}
+
+void TextField::setBackgroundColor(const QColor &color)
+{
+	background_color_ = color;
+}
+
+QColor TextField::backgroundColor() const
+{
+	return background_color_;
+}
+
+void TextField::setShowLabel(bool value)
+{
+	if (show_label_ == value) {
+		return;
+	}
+
+	show_label_ = value;
+
+	if (!label_ && value) {
+		label_ = new TextFieldLabel(this);
+		state_machine_->setLabel(label_);
+	}
+
+	if (value) {
+		setContentsMargins(0, 23, 0, 0);
+	} else {
+		setContentsMargins(0, 0, 0, 0);
+	}
+}
+
+bool TextField::hasLabel() const
+{
+	return show_label_;
+}
+
+void TextField::setLabelFontSize(qreal size)
+{
+	label_font_size_ = size;
+
+	if (label_) {
+		QFont font(label_->font());
+		font.setPointSizeF(size);
+		label_->setFont(font);
+		label_->update();
+	}
+}
+
+qreal TextField::labelFontSize() const
+{
+	return label_font_size_;
+}
+
+void TextField::setLabel(const QString &label)
+{
+	label_text_ = label;
+	setShowLabel(true);
+	label_->update();
+}
+
+QString TextField::label() const
+{
+	return label_text_;
+}
+
+void TextField::setTextColor(const QColor &color)
+{
+	text_color_ = color;
+	setStyleSheet(QString("QLineEdit { color: %1; }").arg(color.name()));
+}
+
+QColor TextField::textColor() const
+{
+	if (!text_color_.isValid()) {
+		return QColor("black");
+	}
+
+	return text_color_;
+}
+
+void TextField::setLabelColor(const QColor &color)
+{
+	label_color_ = color;
+}
+
+QColor TextField::labelColor() const
+{
+	if (!label_color_.isValid()) {
+		return QColor("#abb");  // TODO: Move this into Theme.h
+	}
+
+	return label_color_;
+}
+
+void TextField::setInkColor(const QColor &color)
+{
+	ink_color_ = color;
+}
+
+QColor TextField::inkColor() const
+{
+	if (!ink_color_.isValid()) {
+		return QColor("black");
+	}
+
+	return ink_color_;
+}
+
+void TextField::setUnderlineColor(const QColor &color)
+{
+	underline_color_ = color;
+}
+
+QColor TextField::underlineColor() const
+{
+	if (!underline_color_.isValid()) {
+		return QColor("black");
+	}
+
+	return underline_color_;
+}
+
+bool TextField::event(QEvent *event)
+{
+	switch (event->type()) {
+	case QEvent::Resize:
+	case QEvent::Move: {
+		if (label_)
+			label_->setGeometry(rect());
+		break;
+	}
+	default:
+		break;
+	}
+
+	return QLineEdit::event(event);
+}
+
+void TextField::paintEvent(QPaintEvent *event)
+{
+	QLineEdit::paintEvent(event);
+
+	QPainter painter(this);
+
+	if (text().isEmpty()) {
+		painter.setOpacity(1 - state_machine_->progress());
+		//painter.fillRect(rect(), parentWidget()->palette().color(backgroundRole()));
+		painter.fillRect(rect(), backgroundColor());
+	}
+
+	const int y = height() - 1;
+	const int wd = width() - 5;
+
+	QPen pen;
+	pen.setWidth(1);
+	pen.setColor(underlineColor());
+	painter.setPen(pen);
+	painter.setOpacity(1);
+	painter.drawLine(2.5, y, wd, y);
+
+	QBrush brush;
+	brush.setStyle(Qt::SolidPattern);
+	brush.setColor(inkColor());
+
+	const qreal progress = state_machine_->progress();
+
+	if (progress > 0) {
+		painter.setPen(Qt::NoPen);
+		painter.setBrush(brush);
+		const int w = (1 - progress) * static_cast<qreal>(wd / 2);
+		painter.drawRect(w + 2.5, height() - 2, wd - 2 * w, 2);
+	}
+}
+
+TextFieldStateMachine::TextFieldStateMachine(TextField *parent)
+    : QStateMachine(parent), text_field_(parent)
+{
+	normal_state_ = new QState;
+	focused_state_ = new QState;
+
+	label_ = 0;
+	offset_anim_ = 0;
+	color_anim_ = 0;
+	progress_ = 0.0;
+
+	addState(normal_state_);
+	addState(focused_state_);
+
+	setInitialState(normal_state_);
+
+	QEventTransition *transition;
+	QPropertyAnimation *animation;
+
+	transition = new QEventTransition(parent, QEvent::FocusIn);
+	transition->setTargetState(focused_state_);
+	normal_state_->addTransition(transition);
+
+	animation = new QPropertyAnimation(this, "progress", this);
+	animation->setEasingCurve(QEasingCurve::InCubic);
+	animation->setDuration(310);
+	transition->addAnimation(animation);
+
+	transition = new QEventTransition(parent, QEvent::FocusOut);
+	transition->setTargetState(normal_state_);
+	focused_state_->addTransition(transition);
+
+	animation = new QPropertyAnimation(this, "progress", this);
+	animation->setEasingCurve(QEasingCurve::OutCubic);
+	animation->setDuration(310);
+	transition->addAnimation(animation);
+
+	normal_state_->assignProperty(this, "progress", 0);
+	focused_state_->assignProperty(this, "progress", 1);
+
+	setupProperties();
+
+	connect(text_field_, SIGNAL(textChanged(QString)), this, SLOT(setupProperties()));
+}
+
+TextFieldStateMachine::~TextFieldStateMachine()
+{
+}
+
+void TextFieldStateMachine::setLabel(TextFieldLabel *label)
+{
+	if (label_) {
+		delete label_;
+	}
+
+	if (offset_anim_) {
+		removeDefaultAnimation(offset_anim_);
+		delete offset_anim_;
+	}
+
+	if (color_anim_) {
+		removeDefaultAnimation(color_anim_);
+		delete color_anim_;
+	}
+
+	label_ = label;
+
+	if (label_) {
+		offset_anim_ = new QPropertyAnimation(label_, "offset", this);
+		offset_anim_->setDuration(210);
+		offset_anim_->setEasingCurve(QEasingCurve::OutCubic);
+		addDefaultAnimation(offset_anim_);
+
+		color_anim_ = new QPropertyAnimation(label_, "color", this);
+		color_anim_->setDuration(210);
+		addDefaultAnimation(color_anim_);
+	}
+
+	setupProperties();
+}
+
+void TextFieldStateMachine::setupProperties()
+{
+	if (label_) {
+		const int m = text_field_->textMargins().top();
+
+		if (text_field_->text().isEmpty()) {
+			normal_state_->assignProperty(label_, "offset", QPointF(0, 26));
+		} else {
+			normal_state_->assignProperty(label_, "offset", QPointF(0, 0 - m));
+		}
+
+		focused_state_->assignProperty(label_, "offset", QPointF(0, 0 - m));
+		focused_state_->assignProperty(label_, "color", text_field_->inkColor());
+		normal_state_->assignProperty(label_, "color", text_field_->labelColor());
+
+		if (0 != label_->offset().y() && !text_field_->text().isEmpty()) {
+			label_->setOffset(QPointF(0, 0 - m));
+		} else if (!text_field_->hasFocus() && label_->offset().y() <= 0 && text_field_->text().isEmpty()) {
+			label_->setOffset(QPointF(0, 26));
+		}
+	}
+
+	text_field_->update();
+}
+
+TextFieldLabel::TextFieldLabel(TextField *parent)
+    : QWidget(parent), text_field_(parent)
+{
+	x_ = 0;
+	y_ = 26;
+	scale_ = 1;
+	color_ = parent->labelColor();
+
+	QFontDatabase db;
+	QFont font(db.font("Open Sans", "Medium", parent->labelFontSize()));
+	font.setLetterSpacing(QFont::PercentageSpacing, 102);
+	setFont(font);
+}
+
+TextFieldLabel::~TextFieldLabel()
+{
+}
+
+void TextFieldLabel::paintEvent(QPaintEvent *)
+{
+	if (!text_field_->hasLabel())
+		return;
+
+	QPainter painter(this);
+	painter.setRenderHint(QPainter::Antialiasing);
+	painter.scale(scale_, scale_);
+	painter.setPen(color_);
+	painter.setOpacity(1);
+
+	QPointF pos(2 + x_, height() - 36 + y_);
+	painter.drawText(pos.x(), pos.y(), text_field_->label());
+}
diff --git a/src/ui/Theme.cc b/src/ui/Theme.cc
new file mode 100644
index 00000000..4c5c19de
--- /dev/null
+++ b/src/ui/Theme.cc
@@ -0,0 +1,73 @@
+#include <QDebug>
+
+#include "Theme.h"
+
+Theme::Theme(QObject *parent)
+    : QObject(parent)
+{
+	setColor("Black", ui::Color::Black);
+
+	setColor("BrightWhite", ui::Color::BrightWhite);
+	setColor("FadedWhite", ui::Color::FadedWhite);
+	setColor("MediumWhite", ui::Color::MediumWhite);
+
+	setColor("BrightGreen", ui::Color::BrightGreen);
+	setColor("DarkGreen", ui::Color::DarkGreen);
+	setColor("LightGreen", ui::Color::LightGreen);
+
+	setColor("Gray", ui::Color::Gray);
+	setColor("Red", ui::Color::Red);
+	setColor("Blue", ui::Color::Blue);
+
+	setColor("Transparent", ui::Color::Transparent);
+}
+
+Theme::~Theme()
+{
+}
+
+QColor Theme::rgba(int r, int g, int b, qreal a) const
+{
+	QColor color(r, g, b);
+	color.setAlphaF(a);
+
+	return color;
+}
+
+QColor Theme::getColor(const QString &key) const
+{
+	if (!colors_.contains(key)) {
+		qWarning() << "Color with key" << key << "could not be found";
+		return QColor();
+	}
+
+	return colors_.value(key);
+}
+
+void Theme::setColor(const QString &key, const QColor &color)
+{
+	colors_.insert(key, color);
+}
+
+void Theme::setColor(const QString &key, ui::Color &color)
+{
+	static const QColor palette[] = {
+		QColor("#171919"),
+
+		QColor("#EBEBEB"),
+		QColor("#C9C9C9"),
+		QColor("#929292"),
+
+		QColor("#1C3133"),
+		QColor("#577275"),
+		QColor("#46A451"),
+
+		QColor("#5D6565"),
+		QColor("#E22826"),
+		QColor("#81B3A9"),
+
+		rgba(0, 0, 0, 0),
+	};
+
+	colors_.insert(key, palette[color]);
+}
diff --git a/src/ui/ThemeManager.cc b/src/ui/ThemeManager.cc
new file mode 100644
index 00000000..3c8a16ab
--- /dev/null
+++ b/src/ui/ThemeManager.cc
@@ -0,0 +1,20 @@
+#include <QFontDatabase>
+
+#include "ThemeManager.h"
+
+ThemeManager::ThemeManager()
+{
+	setTheme(new Theme);
+}
+
+void ThemeManager::setTheme(Theme *theme)
+{
+	theme_ = theme;
+	theme_->setParent(this);
+}
+
+QColor ThemeManager::themeColor(const QString &key) const
+{
+	Q_ASSERT(theme_);
+	return theme_->getColor(key);
+}