From 6f6b1b9f2c785c16cea3c314bf87b73b7a084894 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 28 Apr 2015 02:01:44 +0200
Subject: [PATCH 01/27] Start work on making a port to Mac OS

---
 CMakeLists.txt                         | 2 +-
 src/rendering/renderablefieldlines.cpp | 2 +-
 src/util/spicemanager.cpp              | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 16f5700ee0..9f51b2688e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -92,7 +92,7 @@ include_directories(${GHOUL_ROOT_DIR}/ext/boost)
 find_package(SGCT REQUIRED)
 include_directories(${SGCT_INCLUDE_DIRECTORIES})
 set(DEPENDENT_LIBS ${DEPENDENT_LIBS} ${SGCT_LIBRARIES})
-if (UNIX)
+if (UNIX AND (NOT APPLE))
     set(DEPENDENT_LIBS ${DEPENDENT_LIBS} Xcursor Xinerama)
 endif ()
 
diff --git a/src/rendering/renderablefieldlines.cpp b/src/rendering/renderablefieldlines.cpp
index 24b6d465eb..4baa19bacb 100644
--- a/src/rendering/renderablefieldlines.cpp
+++ b/src/rendering/renderablefieldlines.cpp
@@ -306,7 +306,7 @@ void RenderableFieldlines::update(const UpdateData&) {
 
 void RenderableFieldlines::loadSeedPoints() {
 	_seedPoints.clear();
-	switch (_seedPointSource) {
+	switch (_seedPointSource.value()) {
 		case SeedPointSourceFile:
 			loadSeedPointsFromFile();
 			break;
diff --git a/src/util/spicemanager.cpp b/src/util/spicemanager.cpp
index 304cee4447..c49f28d19d 100644
--- a/src/util/spicemanager.cpp
+++ b/src/util/spicemanager.cpp
@@ -48,9 +48,9 @@ void SpiceManager::initialize() {
 	_manager->_lastAssignedKernel = 0;
 
 	// Set the SPICE library to not exit the program if an error occurs
-	erract_c("SET", 0, static_cast<char*>("REPORT"));
+	erract_c("SET", 0, const_cast<char*>("REPORT"));
 	// But we do not want SPICE to print the errors, we will fetch them ourselves
-	errprt_c("SET", 0, static_cast<char*>("NONE"));
+	errprt_c("SET", 0, const_cast<char*>("NONE"));
 }
 
 void SpiceManager::deinitialize() {
@@ -61,8 +61,8 @@ void SpiceManager::deinitialize() {
 	_manager = nullptr;
 
 	// Set values back to default
-	erract_c("SET", 0, static_cast<char*>("DEFAULT"));
-	errprt_c("SET", 0, static_cast<char*>("DEFAULT"));
+	erract_c("SET", 0, const_cast<char*>("DEFAULT"));
+	errprt_c("SET", 0, const_cast<char*>("DEFAULT"));
 }
 
 SpiceManager& SpiceManager::ref() {

From bbb62589063da1406f882e2c7da6fc0ce97ccc6c Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 28 Apr 2015 14:25:48 +0200
Subject: [PATCH 02/27] Update OpenSpace version

---
 include/openspace/version.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/openspace/version.h b/include/openspace/version.h
index 7f05ca7d21..f238d92af9 100644
--- a/include/openspace/version.h
+++ b/include/openspace/version.h
@@ -23,6 +23,6 @@
  ****************************************************************************************/
 
 #define OPENSPACE_VERSION_MAJOR 0
-#define OPENSPACE_VERSION_MINOR 0
-#define OPENSPACE_VERSION_REVISION 3
-#define OPENSPACE_VERSION_STRING "prerelease-3"
+#define OPENSPACE_VERSION_MINOR 1
+#define OPENSPACE_VERSION_REVISION 0
+#define OPENSPACE_VERSION_STRING "prerelease-4"

From 4f8c1e4a146cd7260c3b1911f45a558478ea06ed Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Sat, 2 May 2015 22:24:03 +0200
Subject: [PATCH 03/27] Added methods to Hongkang parser that publish the
 results More changes to the TImeline GUI

---
 gui/timelineview/common.h                  |  35 +++++
 gui/timelineview/mainwindow.cpp            | 115 ++++++++++++++-
 gui/timelineview/mainwindow.h              |   3 +
 gui/timelineview/timelinewidget.cpp        | 155 ++++++++++++++++++++-
 gui/timelineview/timelinewidget.h          |  24 ++++
 include/openspace/engine/openspaceengine.h |   1 +
 include/openspace/network/networkengine.h  |  37 ++++-
 include/openspace/util/hongkangparser.h    |   1 +
 src/engine/openspaceengine.cpp             |   7 +-
 src/main.cpp                               |   1 -
 src/network/networkengine.cpp              | 128 +++++++++++++++--
 src/util/hongkangparser.cpp                | 121 ++++++++++++++++
 12 files changed, 602 insertions(+), 26 deletions(-)
 create mode 100644 gui/timelineview/common.h

diff --git a/gui/timelineview/common.h b/gui/timelineview/common.h
new file mode 100644
index 0000000000..2588afda3a
--- /dev/null
+++ b/gui/timelineview/common.h
@@ -0,0 +1,35 @@
+/*****************************************************************************************
+ *                                                                                       *
+ * OpenSpace                                                                             *
+ *                                                                                       *
+ * Copyright (c) 2014-2015                                                               *
+ *                                                                                       *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this  *
+ * software and associated documentation files (the "Software"), to deal in the Software *
+ * without restriction, including without limitation the rights to use, copy, modify,    *
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to    *
+ * permit persons to whom the Software is furnished to do so, subject to the following   *
+ * conditions:                                                                           *
+ *                                                                                       *
+ * The above copyright notice and this permission notice shall be included in all copies *
+ * or substantial portions of the Software.                                              *
+ *                                                                                       *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   *
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A         *
+ * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT    *
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF  *
+ * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE  *
+ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
+ ****************************************************************************************/
+
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+struct Image {
+    double beginning;
+    double ending;
+    std::string target;
+    std::vector<std::string> instruments;
+};
+
+#endif // __COMMON_H__
diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index a6b2bb9b24..845a719e89 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -36,6 +36,28 @@
 #include <array>
 #include <cstdint>
 
+template <typename T>
+T readFromBuffer(char* buffer, size_t& currentReadLocation) {
+    union {
+        T value;
+        std::array<char, sizeof(T)> data;
+    } b;
+    std::memmove(b.data.data(), buffer + currentReadLocation, sizeof(T));
+    currentReadLocation += sizeof(T);
+    return b.value;
+}
+
+template <>
+std::string readFromBuffer(char* buffer, size_t& currentReadLocation) {
+    uint8_t size = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+
+    std::string result(buffer + currentReadLocation, buffer + currentReadLocation + size);
+    currentReadLocation += size;
+    return result;
+}
+
+
+
 MainWindow::MainWindow()
     : QWidget(nullptr)
     , _configurationWidget(nullptr)
@@ -82,24 +104,52 @@ void MainWindow::onConnect(QString host, QString port) {
     _socket = new QTcpSocket(this);
     connect(_socket, SIGNAL(readyRead()), SLOT(readTcpData()));
     _socket->connectToHost(host, port.toUInt());
+
+    _socket->write(QString("1\r\n").toLatin1());
 }
 
 
 void MainWindow::readTcpData() {
-    static const uint8_t MessageTypeStatus = 0;
+    static const uint16_t MessageTypeStatus = 0;
+    static const uint16_t MessageTypePlayBook = 2;
 
     QByteArray data = _socket->readAll();
 
+    //QString debug(data);
+    //qDebug() << debug;
+
     if (QString(data) == "Connected to SGCT!\r\n")
         return;
     if (QString(data) == "OK\r\n")
         return;
 
-    uint8_t messageType = data[0];
+    QByteArray messageTypeData = data.left(2);
+    union {
+        uint16_t value;
+        std::array<char, 2> data;
+    } messageType;
+    std::memcpy(messageType.data.data(), messageTypeData.data(), sizeof(uint16_t));
 
-    if (messageType == MessageTypeStatus)
-        handleStatusMessage(data.mid(1));
-        handleStatusMessage(data.right(data.length() - 1));
+    switch (messageType.value) {
+    case MessageTypeStatus:
+        handleStatusMessage(data.mid(2));
+        break;
+    case MessageTypePlayBook:
+    {
+        const char* payloadDebug = data.mid(2).data();
+
+        size_t beginning = 0;
+        uint32_t size = readFromBuffer<uint32_t>(data.mid(2).data(), beginning);
+
+        while (_socket->waitForReadyRead() && data.size() < size) {
+            data = data.append(_socket->readAll());
+        }
+        handlePlaybook(data.mid(2));
+        break;
+    }
+    default:
+        qDebug() << "Unknown message of type '" << messageType.value << "'";
+    }
 }
 
 void MainWindow::handleStatusMessage(QByteArray data) {
@@ -124,8 +174,63 @@ void MainWindow::handleStatusMessage(QByteArray data) {
         QString::fromStdString(std::string(timeString.begin(), timeString.end())),
         QString::number(delta.value)
     );
+    _timelineWidget->setCurrentTime(std::string(timeString.begin(), timeString.end()));
 }
 
+std::vector<std::string> instrumentsFromId(uint16_t instrumentId, std::map<uint16_t, std::string> instrumentMap) {
+    std::vector<std::string> results;
+    for (int i = 0; i < 16; ++i) {
+        uint16_t testValue = 1 << i;
+        if ((testValue & instrumentId) == 1)
+            results.push_back(instrumentMap[testValue]);
+    }
+    return results;
+}
+
+void MainWindow::handlePlaybook(QByteArray data) {
+    char* buffer = data.data();
+    size_t currentReadLocation = 0;
+
+    uint32_t totalData = readFromBuffer<uint32_t>(buffer, currentReadLocation);
+
+    uint8_t nTargets = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+    std::map<uint8_t, std::string> targetMap;
+    for (uint8_t i = 0; i < nTargets; ++i) {
+        uint8_t id = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+        std::string value = readFromBuffer<std::string>(buffer, currentReadLocation);
+        targetMap[id] = value;
+    }
+
+    uint8_t nInstruments = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+    std::map<uint16_t, std::string> instrumentMap;
+    for (uint8_t i = 0; i < nInstruments; ++i) {
+        uint8_t id = readFromBuffer<uint16_t>(buffer, currentReadLocation);
+        std::string value = readFromBuffer<std::string>(buffer, currentReadLocation);
+        instrumentMap[id] = value;
+    }
+
+    uint32_t nImages = readFromBuffer<uint32_t>(buffer, currentReadLocation);
+    std::vector<Image> images;
+    for (uint32_t i = 0; i < nImages; ++i) {
+        Image image;
+        image.beginning = readFromBuffer<double>(buffer, currentReadLocation);
+        image.ending = readFromBuffer<double>(buffer, currentReadLocation);
+
+        image.beginningString = readFromBuffer<std::string>(buffer, currentReadLocation);
+        image.endingString = readFromBuffer<std::string>(buffer, currentReadLocation);
+        
+        uint8_t targetId = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+        uint16_t instrumentId = readFromBuffer<uint16_t>(buffer, currentReadLocation);
+        image.target = targetMap[targetId];
+        image.instruments = instrumentsFromId(instrumentId, instrumentMap);
+        images.push_back(image);
+    }
+
+    _timelineWidget->setData(std::move(images), std::move(targetMap), std::move(instrumentMap));
+}
+
+
 void MainWindow::sendScript(QString script) {
     _socket->write(("0" + script + "\r\n").toLatin1());
 }
+
diff --git a/gui/timelineview/mainwindow.h b/gui/timelineview/mainwindow.h
index 9fdd10b1d3..cb9ada8a8b 100644
--- a/gui/timelineview/mainwindow.h
+++ b/gui/timelineview/mainwindow.h
@@ -28,6 +28,8 @@
 #include <QWidget>
 #include <QTcpSocket>
 
+#include "common.h"
+
 class ConfigurationWidget;
 class TimeControlWidget;
 class InformationWidget;
@@ -49,6 +51,7 @@ private slots:
 	//void sendCommandButton();
 	void readTcpData();
     void handleStatusMessage(QByteArray data);
+    void handlePlaybook(QByteArray data);
 
 private:
     ConfigurationWidget* _configurationWidget;
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index 7028482f30..5f064a0619 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -24,19 +24,166 @@
 
 #include "timelinewidget.h"
 
+#include <QDebug>
 #include <QPainter>
 #include <QPaintEvent>
 
+#include <set>
+
+namespace {
+    static const int LegendHeight = 105;
+    static const int TimeWidth = 150;
+
+    const QColor targetColors[] = {
+        QColor(251, 180, 174),
+        QColor(179, 205, 227),
+        QColor(204, 235, 197),
+        QColor(222, 203, 228),
+        QColor(254, 217, 166),
+        QColor(255, 255, 204)
+    };
+
+    const QColor instrumentColors[] = {
+        QColor(228, 26, 28),
+        QColor(55, 126, 184),
+        QColor(77, 175, 74),
+        QColor(152, 78, 163),
+        QColor(255, 127, 0),
+        QColor(255, 255, 51),
+        QColor(166, 86, 40),
+        QColor(247, 129, 191),
+        QColor(153, 153, 153),
+    };
+
+    const double etSpread = 100.0;
+}
+
 TimelineWidget::TimelineWidget(QWidget* parent)
     : QWidget(parent)
 {
-    setMinimumWidth(300);
-    setMinimumHeight(500);
+    setMinimumWidth(600);
+    setMinimumHeight(600);
 }
 
 void TimelineWidget::paintEvent(QPaintEvent* event) {
     QPainter painter(this);
 
-    painter.setBrush(QBrush(Qt::white));
-    painter.drawRect(contentsRect());
+    QRectF fullRect = contentsRect();
+    QRectF contentRect(0, 0, fullRect.width() - 1, fullRect.height() - LegendHeight);
+    QRectF legendRect(0, fullRect.bottom() - LegendHeight, fullRect.right(), fullRect.bottom());
+
+    painter.save();
+    drawContent(painter, contentRect);
+    painter.restore();
+
+    painter.save();
+    painter.translate(0, fullRect.height() - LegendHeight);
+    drawLegend(painter, QRectF(legendRect));
+    painter.restore();
 }
+
+void TimelineWidget::setData(std::vector<Image> images, std::map<uint8_t, std::string> targetMap, std::map<uint16_t, std::string> instrumentMap) {
+    _images = std::move(images);
+
+    std::sort(_images.begin(), _images.end(), [](const Image& a, const Image& b) { return a.beginning < b.beginning; });
+
+    _targetMap = std::move(targetMap);
+    _instrumentMap = std::move(instrumentMap);
+
+    _instruments.clear();
+    std::set<std::string> instruments;
+    for (auto p : _instrumentMap)
+        instruments.insert(p.second);
+    std::copy(instruments.begin(), instruments.end(), std::back_inserter(_instruments));
+
+    _targets.clear();
+    std::set<std::string> targets;
+    for (auto p : _targetMap)
+        targets.insert(p.second);
+    std::copy(targets.begin(), targets.end(), std::back_inserter(_targets));
+
+    repaint();
+}
+
+void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
+    QRectF timelineRect(0, 0, rect.width() - TimeWidth, rect.height());
+    QRectF dateRect(rect.width() - TimeWidth, 0, TimeWidth, rect.height());
+    
+    // Draw background
+    painter.setBrush(QBrush(Qt::white));  painter.drawRect(timelineRect);
+    painter.setBrush(QBrush(Qt::gray));   painter.drawRect(dateRect);
+
+    // Draw current time
+    painter.setBrush(QBrush(Qt::black));
+    painter.drawLine(QPointF(0, timelineRect.height() / 2), QPointF(timelineRect.width(), timelineRect.height() / 2));
+    painter.drawText(timelineRect.width(), timelineRect.height() / 2, QString::fromStdString(_currentTime.time));
+
+
+    const double lowerTime = _currentTime.et - etSpread;
+    const double upperTime = _currentTime.et + etSpread;
+
+    std::vector<Image>::const_iterator start = _images.end();
+    std::vector<Image>::const_iterator end = _images.end();
+    for (std::vector<Image>::const_iterator it = _images.begin(); it != _image.end(); ++it) {
+        if (it->beginning > lowerTime 
+    }
+
+    //std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [lowerTime](const Image& i) { return i.beginning < lowerTime; });
+    ////std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _iamges.end(), upperTime)
+
+
+
+}
+
+void TimelineWidget::drawLegend(QPainter& painter, QRectF rect) {
+    static const int HalfHeight = LegendHeight / 2;
+    static const int Padding = 5;
+    static const int BoxSize = 20;
+
+    // Draw Targets
+    int currentHorizontalPosition = Padding;
+    int currentVerticalPosition = Padding;
+    for (int i = 0; i < _targets.size(); ++i) {
+
+        const std::string& target = _targets[i];
+        
+        painter.setBrush(QBrush(targetColors[i]));
+        painter.drawRect(currentHorizontalPosition, currentVerticalPosition, BoxSize, BoxSize);
+        currentHorizontalPosition += BoxSize + Padding;
+
+        painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2, QString::fromStdString(target));
+        int textWidth = painter.boundingRect(QRect(), QString::fromStdString(target)).width();
+        currentHorizontalPosition += std::max(textWidth, 25) + Padding;
+    }
+
+    // Draw Instruments
+    currentHorizontalPosition = Padding;
+    currentVerticalPosition = Padding + BoxSize + Padding;
+    for (int i = 0; i < _instruments.size(); ++i) {
+        if (i == _instruments.size() / 3 || i == _instruments.size() * 2 / 3) {
+            currentVerticalPosition += BoxSize + Padding;
+            currentHorizontalPosition = Padding;
+        }
+
+        const std::string& instrument = _instruments[i];
+
+        //painter.setBrush(QBrush(instrumentColors[i]));
+        painter.setBrush(Qt::NoBrush);
+        painter.setPen(QPen(instrumentColors[i]));
+        painter.drawRect(currentHorizontalPosition, currentVerticalPosition, BoxSize, BoxSize);
+        currentHorizontalPosition += BoxSize + Padding;
+
+        painter.setPen(QPen(Qt::black));
+        painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2, QString::fromStdString(instrument));
+        int textWidth = painter.boundingRect(QRect(), QString::fromStdString(instrument)).width();
+        currentHorizontalPosition += std::max(textWidth, 25) + Padding;
+    }
+}
+
+void TimelineWidget::setCurrentTime(std::string currentTime, double et) {
+    _currentTime.time = std::move(currentTime);
+    _currentTime.et = std::move(et);
+    repaint();
+
+}
+
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index def40ffe6c..33c455b3eb 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -27,6 +27,12 @@
 
 #include <QWidget>
 
+#include "common.h"
+
+#include <stdint.h>
+#include <map>
+#include <vector>
+
 class QPaintEvent;
 
 class TimelineWidget : public QWidget {
@@ -34,9 +40,27 @@ Q_OBJECT
 public:
 	TimelineWidget(QWidget* parent);
 
+    void setData(std::vector<Image> images, std::map<uint8_t, std::string> targetMap, std::map<uint16_t, std::string> instrumentMap);
+    void setCurrentTime(std::string currentTime, double et);
+
 protected:
     void paintEvent(QPaintEvent* event);  
+    void drawContent(QPainter& painter, QRectF rect);
+    void drawLegend(QPainter& painter, QRectF rect);
 
+
+private:
+    std::vector<Image> _images;
+    std::map<uint8_t, std::string> _targetMap;
+    std::map<uint16_t, std::string> _instrumentMap;
+
+    std::vector<std::string> _targets;
+    std::vector<std::string> _instruments;
+
+    struct {
+        std::string time;
+        double et;
+    } _currentTime;
 };
 
 #endif // __TIMELINEWIDGET_H__
diff --git a/include/openspace/engine/openspaceengine.h b/include/openspace/engine/openspaceengine.h
index 2beeafa486..155a9f9e33 100644
--- a/include/openspace/engine/openspaceengine.h
+++ b/include/openspace/engine/openspaceengine.h
@@ -69,6 +69,7 @@ public:
     interaction::InteractionHandler* interactionHandler();
     RenderEngine* renderEngine();
 	scripting::ScriptEngine* scriptEngine();
+    NetworkEngine* networkEngine();
 	LuaConsole* console();
 
 	gui::GUI* gui();
diff --git a/include/openspace/network/networkengine.h b/include/openspace/network/networkengine.h
index 1d0c03481a..90558f9717 100644
--- a/include/openspace/network/networkengine.h
+++ b/include/openspace/network/networkengine.h
@@ -25,17 +25,50 @@
 #ifndef __NETWORKENGINE_H__
 #define __NETWORKENGINE_H__
 
+#include <cstdint>
+#include <map>
 #include <string>
+#include <vector>
 
 namespace openspace {
 
 class NetworkEngine {
 public:
-    NetworkEngine() = default;
+    typedef uint16_t MessageIdentifier;
 
+    NetworkEngine();
+
+    // Receiving messages
     bool handleMessage(const std::string& message);
 
-    void sendStatusMessage();
+    // Sending messages
+    void publishStatusMessage();
+    void publishIdentifierMappingMessage();
+    void publishMessage(MessageIdentifier identifier, std::vector<char> message);
+    void sendMessages();
+
+    // Initial Connection Messages
+    void setInitialConnectionMessage(MessageIdentifier identifier, std::vector<char> message);
+    void sendInitialInformation();
+
+    // Background
+    MessageIdentifier identifier(std::string name);
+private:
+    std::map<MessageIdentifier, std::string> _identifiers;
+    MessageIdentifier _lastAssignedIdentifier;
+
+    struct Message {
+        MessageIdentifier identifer;
+        std::vector<char> body;
+    };
+    std::vector<Message> _messagesToSend;
+
+    std::vector<Message> _initialConnectionMessages;
+
+
+
+    MessageIdentifier _statusMessageIdentifier;
+    MessageIdentifier _identifierMappingIdentifier;
 };
 
 } // namespace openspace
diff --git a/include/openspace/util/hongkangparser.h b/include/openspace/util/hongkangparser.h
index f6e08c6160..ca1eccf68d 100644
--- a/include/openspace/util/hongkangparser.h
+++ b/include/openspace/util/hongkangparser.h
@@ -65,6 +65,7 @@ namespace openspace {
 			                  std::string spacecraft, 
 							  std::vector<std::string> payload, 
 							  std::vector<std::string> potentialTargets);
+        void sendPlaybookInformation();
 
 		std::string _defaultCaptureImage;
 		double _metRef = 299180517;
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index 4e169dc328..7499cab4ec 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -703,7 +703,8 @@ void OpenSpaceEngine::encode() {
 		
 		_syncBuffer->write();
 	}
-    _networkEngine->sendStatusMessage();
+    _networkEngine->publishStatusMessage();
+    _networkEngine->sendMessages();
 }
 
 void OpenSpaceEngine::decode() {
@@ -733,4 +734,8 @@ void OpenSpaceEngine::disableBarrier() {
     sgct::SGCTWindow::setBarrier(false);
 }
 
+NetworkEngine* OpenSpaceEngine::networkEngine() {
+    return _networkEngine;
+}
+
 }  // namespace openspace
diff --git a/src/main.cpp b/src/main.cpp
index 86a3dfdf2a..d7a851db0f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -79,7 +79,6 @@ int main(int argc, char** argv) {
 	sgct::MessageHandler::instance()->setLogToCallback(true);
 	sgct::MessageHandler::instance()->setLogCallback(mainLogCallback);
 
-
 	LDEBUG("Creating SGCT Engine");
     _sgctEngine = new sgct::Engine(newArgc, newArgv);
 
diff --git a/src/network/networkengine.cpp b/src/network/networkengine.cpp
index 1b0c0a2599..c89ce924b3 100644
--- a/src/network/networkengine.cpp
+++ b/src/network/networkengine.cpp
@@ -27,27 +27,49 @@
 #include <openspace/util/time.h>
 #include <openspace/engine/openspaceengine.h>
 
+#include <array>
+
 #include "sgct.h"
 
 namespace {
     const std::string _loggerCat = "NetworkEngine";
 
-    const uint8_t MessageTypeStatus = 0;
+    const std::string StatusMessageIdentifierName = "StatusMessage";
+    const std::string MappingIdentifierIdentifierName = "IdentifierMapping";
+
+    const char MessageTypeLuaScript = '0';
+    const char MessageTypeExternalControlConnected = '1';
 }
 
 namespace openspace {
 
+NetworkEngine::NetworkEngine() 
+    : _lastAssignedIdentifier(-1) // -1 is okay as we assign one identifier in this ctor
+{
+    static_assert(
+        sizeof(MessageIdentifier) == 2,
+        "MessageIdentifier has to be 2 bytes or dependent applications will break"
+    );
+    _statusMessageIdentifier = identifier(StatusMessageIdentifierName);
+    _identifierMappingIdentifier = identifier(MappingIdentifierIdentifierName);
+}
+
 bool NetworkEngine::handleMessage(const std::string& message) {
     // The first byte determines the type of message
     const char type = message[0];
     switch (type) {
-    case '0':  // LuaScript
+    case MessageTypeLuaScript:  // LuaScript
     {
         std::string script = message.substr(1);
         //LINFO("Received Lua Script: '" << script << "'");
         OsEng.scriptEngine()->queueScript(script);
         return true;
     }
+    case MessageTypeExternalControlConnected:
+    {
+        sendInitialInformation();
+        return true;
+    }
     default:
         LERROR("Unknown type '" << type << "'");
         return false;
@@ -55,15 +77,14 @@ bool NetworkEngine::handleMessage(const std::string& message) {
 
 }
 
-void NetworkEngine::sendStatusMessage() {
+void NetworkEngine::publishStatusMessage() {
     if (!sgct::Engine::instance()->isExternalControlConnected())
         return;
-    // Protocols:
-    // 1 byte: type of message
+    // Protocol:
     // 8 bytes: time as a ET double
     // 24 bytes: time as a UTC string
     // 8 bytes: delta time as double
-    // Total: 41
+    // Total: 40
 
     uint16_t messageSize = 0;
     
@@ -71,27 +92,108 @@ void NetworkEngine::sendStatusMessage() {
     std::string timeString = Time::ref().currentTimeUTC();
     double delta = Time::ref().deltaTime();
 
-    messageSize += sizeof(uint8_t);
     messageSize += sizeof(time);
     messageSize += timeString.length();
     messageSize += sizeof(delta);
 
-    //LINFO(delta);
-
-    ghoul_assert(messageSize == 41, "Message size is not correct");
+    ghoul_assert(messageSize == 40, "Message size is not correct");
 
     unsigned int currentLocation = 0;
     std::vector<char> buffer(messageSize);
     
-    std::memcpy(buffer.data(), &MessageTypeStatus, sizeof(MessageTypeStatus));
-    currentLocation += sizeof(MessageTypeStatus);
     std::memmove(buffer.data() + currentLocation, &time, sizeof(time));
     currentLocation += sizeof(time);
     std::memmove(buffer.data() + currentLocation, timeString.c_str(), timeString.length());
     currentLocation += timeString.length();
     std::memmove(buffer.data() + currentLocation, &delta, sizeof(delta));
 
-    sgct::Engine::instance()->sendMessageToExternalControl(buffer.data(), messageSize);
+    publishMessage(_statusMessageIdentifier, std::move(buffer));
+}
+
+void NetworkEngine::publishIdentifierMappingMessage() {
+    size_t bufferSize = 0;
+    for (const std::pair<MessageIdentifier, std::string>& i : _identifiers) {
+        bufferSize += sizeof(MessageIdentifier);
+        bufferSize += i.second.size() + 1; // +1 for \0 terminating character
+    }
+
+    std::vector<char> buffer(bufferSize);
+    size_t currentWritingPosition = 0;
+    for (const std::pair<MessageIdentifier, std::string>& i : _identifiers) {
+        std::memcpy(buffer.data() + currentWritingPosition, &(i.first), sizeof(MessageIdentifier));
+        currentWritingPosition += sizeof(MessageIdentifier);
+        std::memcpy(buffer.data() + currentWritingPosition, i.second.data(), i.second.size());
+        currentWritingPosition += i.second.size();
+        buffer[currentWritingPosition] = '\0';
+        currentWritingPosition += 1;
+    }
+
+    publishMessage(_identifierMappingIdentifier, std::move(buffer));
+}
+
+
+NetworkEngine::MessageIdentifier NetworkEngine::identifier(std::string name) {
+#ifdef DEBUG
+    // Check if name has been assigned already
+    for (const std::pair<MessageIdentifier, std::string>& p : _identifiers) {
+        if (p.second == name) {
+            LERROR("Name '" << name << "' for identifier has been registered before");
+            return -1;
+        }
+    }
+#endif
+    _lastAssignedIdentifier++;
+
+    MessageIdentifier result = _lastAssignedIdentifier;
+
+    _identifiers[result] = std::move(name);
+    return result;
+}
+
+void NetworkEngine::publishMessage(MessageIdentifier identifier, std::vector<char> message) {
+    _messagesToSend.push_back({ std::move(identifier), std::move(message) });
+}
+
+void NetworkEngine::sendMessages() {
+    if (!sgct::Engine::instance()->isExternalControlConnected())
+        return;
+
+    for (Message& m : _messagesToSend) {
+        // Protocol:
+        // 2 bytes: type of message as uint16_t
+        // Rest of payload depending on the message type
+
+        union {
+            MessageIdentifier value;
+            std::array<char, 2> data;
+        } identifier;
+        identifier.value = m.identifer;
+
+        // Prepending the message identifier to the front
+        m.body.insert(m.body.begin(), identifier.data.begin(), identifier.data.end());
+        sgct::Engine::instance()->sendMessageToExternalControl(m.body.data(), m.body.size());
+    }
+
+    _messagesToSend.clear();
+}
+
+void NetworkEngine::sendInitialInformation() {
+    for (const Message& m : _initialConnectionMessages) {
+        union {
+            MessageIdentifier value;
+            std::array<char, 2> data;
+        } identifier;
+        identifier.value = m.identifer;
+
+        std::vector<char> payload = m.body;
+        payload.insert(payload.begin(), identifier.data.begin(), identifier.data.end());
+        sgct::Engine::instance()->sendMessageToExternalControl(payload.data(), payload.size());
+    }
+}
+
+void NetworkEngine::setInitialConnectionMessage(MessageIdentifier identifier, std::vector<char> message) {
+    // Add check if a MessageIdentifier already exists ---abock
+    _initialConnectionMessages.push_back({std::move(identifier), std::move(message)});
 }
 
 } // namespace openspace
diff --git a/src/util/hongkangparser.cpp b/src/util/hongkangparser.cpp
index 0628de37c3..55802a7249 100644
--- a/src/util/hongkangparser.cpp
+++ b/src/util/hongkangparser.cpp
@@ -28,6 +28,8 @@
 #include <ghoul/filesystem/directory.h>
 #include <openspace/util/time.h>
 #include <openspace/util/spicemanager.h>
+#include <openspace/engine/openspaceengine.h>
+#include <openspace/network/networkengine.h>
 #include <fstream>
 #include <iterator>
 #include <iomanip>
@@ -38,6 +40,8 @@
 namespace {
 	const std::string _loggerCat = "HongKangParser";
 	const std::string keyTranslation = "DataInputTranslation";
+
+    const std::string PlaybookIdentifierName = "Playbook";
 }
 
 namespace openspace {
@@ -207,6 +211,8 @@ void HongKangParser::create(){
 			}
 		}
 	}
+
+    sendPlaybookInformation();
 	
 	std::ofstream myfile;
 	myfile.open("HongKangOutput.txt");
@@ -333,4 +339,119 @@ std::vector<double> HongKangParser::getCaptureProgression(){
 	return _captureProgression; 
 };
 
+
+template <typename T>
+void writeToBuffer(std::vector<char>& buffer, size_t& currentWriteLocation, T value) {
+    if ((currentWriteLocation + sizeof(T)) > buffer.size())
+        buffer.resize(2 * buffer.size());
+
+    std::memmove(buffer.data() + currentWriteLocation, reinterpret_cast<const void*>(&value), sizeof(T));
+    currentWriteLocation += sizeof(T);
+}
+
+template <>
+
+void writeToBuffer<std::string>(std::vector<char>& buffer, size_t& currentWriteLocation, std::string value) {
+    if ((currentWriteLocation + sizeof(uint8_t) + value.size()) > buffer.size())
+        buffer.resize(2 * buffer.size());
+
+    uint8_t length = value.size();
+    std::memcpy(buffer.data() + currentWriteLocation, &length, sizeof(uint8_t));
+    currentWriteLocation += sizeof(uint8_t);
+
+    std::memmove(buffer.data() + currentWriteLocation, value.data(), length);
+    currentWriteLocation += length;
+}
+
+
+void HongKangParser::sendPlaybookInformation() {
+    static const NetworkEngine::MessageIdentifier PlaybookIdentifier = OsEng.networkEngine()->identifier(PlaybookIdentifierName);
+
+    std::vector<char> buffer(1024);
+    size_t currentWriteLocation = 0;
+
+    // Protocol:
+    // 4 bytes: Total number of bytes sent
+    // 1 byte : Number of Targets (i)
+    // i times: 1 byte (id), 1 byte (length j of name), j bytes (name)
+    // 1 byte : Number of Instruments (i)
+    // i times: 1 byte (id), 1 byte (length j of name), j bytes (name)
+    // 4 byte: Number (n) of images
+    // n times: 8 byte (beginning time), 8 byte (ending time), 1 byte (target id), 2 byte (instrument id)
+
+    std::map<std::string, uint8_t> targetMap;
+    uint8_t currentTargetId = 0;
+    for (auto target : _subsetMap) {
+        if (targetMap.find(target.first) == targetMap.end())
+            targetMap[target.first] = currentTargetId++;
+    }
+
+    std::map<std::string, uint16_t> instrumentMap;
+    uint16_t currentInstrumentId = 1;
+    for (auto target : _subsetMap) {
+        for (auto image : target.second._subset) {
+            for (auto instrument : image.activeInstruments) {
+                if (instrumentMap.find(instrument) == instrumentMap.end()) {
+                    instrumentMap[instrument] = currentInstrumentId;
+                    currentInstrumentId = currentInstrumentId  << 1;
+                }
+            }
+        }
+    }
+
+    writeToBuffer(buffer, currentWriteLocation, uint8_t(targetMap.size()));
+    for (const std::pair<std::string, uint8_t>& p : targetMap) {
+        writeToBuffer(buffer, currentWriteLocation, p.second);
+        writeToBuffer(buffer, currentWriteLocation, p.first);
+    }
+
+    writeToBuffer(buffer, currentWriteLocation, uint8_t(instrumentMap.size()));
+    for (const std::pair<std::string, uint16_t>& p : instrumentMap) {
+        writeToBuffer(buffer, currentWriteLocation, p.second);
+        writeToBuffer(buffer, currentWriteLocation, p.first);
+    }
+
+    uint32_t allImages = 0;
+    for (auto target : _subsetMap)
+        allImages += target.second._subset.size();
+    writeToBuffer(buffer, currentWriteLocation, allImages);
+
+    for (auto target : _subsetMap){
+        for (auto image : target.second._subset){
+            writeToBuffer(buffer, currentWriteLocation, image.startTime);
+            writeToBuffer(buffer, currentWriteLocation, image.stopTime);
+
+            std::string timeBegin;
+            std::string timeEnd;
+            SpiceManager::ref().getDateFromET(image.startTime, timeBegin);
+            SpiceManager::ref().getDateFromET(image.stopTime, timeEnd);
+
+            writeToBuffer(buffer, currentWriteLocation, timeBegin);
+            writeToBuffer(buffer, currentWriteLocation, timeEnd);
+
+            uint8_t targetId = targetMap[target.first];
+            writeToBuffer(buffer, currentWriteLocation, targetId);
+            uint16_t totalInstrumentId = 0;
+            for (auto instrument : image.activeInstruments) {
+                uint16_t thisInstrumentId = instrumentMap[instrument];
+                totalInstrumentId |= thisInstrumentId;
+            }
+            writeToBuffer(buffer, currentWriteLocation, totalInstrumentId);
+        }
+    }
+
+    union {
+        uint32_t value;
+        std::array<char, sizeof(uint32_t)> data;
+    } sizeBuffer;
+    sizeBuffer.value = currentWriteLocation;
+    buffer.insert(buffer.begin(), sizeBuffer.data.begin(), sizeBuffer.data.end());
+    currentWriteLocation += sizeof(uint32_t);
+
+    buffer.resize(currentWriteLocation);
+
+    //OsEng.networkEngine()->publishMessage(PlaybookIdentifier, buffer);
+    OsEng.networkEngine()->setInitialConnectionMessage(PlaybookIdentifier, buffer);
+}
+
 }
\ No newline at end of file

From 8b9165fbfbe76576c50ae59432a4781bb7a7896d Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Sat, 2 May 2015 22:24:27 +0200
Subject: [PATCH 04/27] Added missing files

---
 gui/timelineview/configurationwidget.cpp | 4 ----
 gui/timelineview/configurationwidget.h   | 3 ---
 2 files changed, 7 deletions(-)

diff --git a/gui/timelineview/configurationwidget.cpp b/gui/timelineview/configurationwidget.cpp
index 900a02d5c1..38b4526546 100644
--- a/gui/timelineview/configurationwidget.cpp
+++ b/gui/timelineview/configurationwidget.cpp
@@ -31,15 +31,11 @@ ConfigurationWidget::ConfigurationWidget(QWidget* parent)
     , _ipAddress(new QLineEdit("localhost"))
     , _port(new QLineEdit("20500"))
     , _connect(new QPushButton("Connect"))
-    , _playbook(new QLineEdit)
-    , _load(new QPushButton("Load"))
 {
     QGridLayout* layout = new QGridLayout;
     layout->addWidget(_ipAddress, 0, 0);
     layout->addWidget(_port, 0, 1);
     layout->addWidget(_connect, 0, 2);
-    layout->addWidget(_playbook, 1, 0, 1, 2);
-    layout->addWidget(_load, 1, 2);
 
     setLayout(layout);
 
diff --git a/gui/timelineview/configurationwidget.h b/gui/timelineview/configurationwidget.h
index dfc305005b..2c6291a13c 100644
--- a/gui/timelineview/configurationwidget.h
+++ b/gui/timelineview/configurationwidget.h
@@ -44,9 +44,6 @@ private:
     QLineEdit* _ipAddress;
     QLineEdit* _port;
     QPushButton* _connect;
-
-    QLineEdit* _playbook;
-    QPushButton* _load;
 };
 
 #endif // __CONFIGURATIONWIDGET_H__

From 9a76f3757374677bef122b532e21b33a12e675e2 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Sun, 3 May 2015 00:14:01 +0200
Subject: [PATCH 05/27] Fix crashes with focus node change when view and camera
 vectors were almost the same but not equal Fix crash when moving to time
 without any images

---
 src/interaction/interactionhandler.cpp |   7 +-
 src/rendering/renderengine.cpp         | 100 +++++++++++++------------
 src/util/imagesequencer2.cpp           |   6 +-
 3 files changed, 61 insertions(+), 52 deletions(-)

diff --git a/src/interaction/interactionhandler.cpp b/src/interaction/interactionhandler.cpp
index 9ac16253d6..6017ebb36e 100644
--- a/src/interaction/interactionhandler.cpp
+++ b/src/interaction/interactionhandler.cpp
@@ -556,7 +556,12 @@ void InteractionHandler::setFocusNode(SceneGraphNode* node) {
 	glm::vec3 cameraView = glm::normalize(_camera->viewDirection());
     //set new focus position
     _camera->setFocusPosition(node->worldPosition());
-    if (viewDir != cameraView) {
+    float dot = glm::dot(viewDir, cameraView);
+
+    //static const float Epsilon = 0.001f;
+    if (dot < 1.f && dot > -1.f) {
+    //if (glm::length(viewDir - cameraView) < 0.001) {
+    //if (viewDir != cameraView) {
 	    glm::vec3 rotAxis = glm::normalize(glm::cross(viewDir, cameraView));
 	    float angle = glm::angle(viewDir, cameraView);
 	    glm::quat q = glm::angleAxis(angle, rotAxis);
diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index ae5ce38a4f..f05d615695 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -629,70 +629,72 @@ namespace openspace {
 						std::pair<double, std::string> nextTarget = ImageSequencer2::ref().getNextTarget();
 						std::pair<double, std::string> currentTarget = ImageSequencer2::ref().getCurrentTarget();
 
-						int timeleft = nextTarget.first - currentTime;
+                        if (currentTarget.first > 0.0) {
 
-						int hour   = timeleft / 3600;
-						int second = timeleft % 3600;
-						int minute = second / 60;
-					        second = second % 60;
+                            int timeleft = nextTarget.first - currentTime;
 
-						std::string hh, mm, ss, coundtown;
+                            int hour = timeleft / 3600;
+                            int second = timeleft % 3600;
+                            int minute = second / 60;
+                            second = second % 60;
 
-						if (hour   < 10) hh.append("0");
-						if (minute < 10) mm.append("0");
-						if (second < 10) ss.append("0");
+                            std::string hh, mm, ss, coundtown;
 
-						hh.append(std::to_string(hour));
-						mm.append(std::to_string(minute));
-						ss.append(std::to_string(second));
+                            if (hour < 10) hh.append("0");
+                            if (minute < 10) mm.append("0");
+                            if (second < 10) ss.append("0");
+
+                            hh.append(std::to_string(hour));
+                            mm.append(std::to_string(minute));
+                            ss.append(std::to_string(second));
 
 
-						glm::vec4 b2(1.00, 0.51, 0.00, 1);
-						PrintColorText(i++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
+                            glm::vec4 b2(1.00, 0.51, 0.00, 1);
+                            PrintColorText(i++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
 
-						std::pair<double, std::vector<std::string>> incidentTargets = ImageSequencer2::ref().getIncidentTargetList(2);
-						std::string space;
-						glm::vec4 color;
-						int isize = incidentTargets.second.size(); 
-							for (int p = 0; p < isize; p++){
-								double t = (double)(p + 1) / (double)(isize+1);
-								t = (p > isize / 2) ? 1-t : t;
-								t += 0.3;
-								color = (p == isize / 2) ? glm::vec4(1.00, 0.51, 0.00, 1) : glm::vec4(t, t, t, 1);
-								PrintColorText(i, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
-							for (int k = 0; k < 10; k++){ space += " "; }
-						}
-						i++;
-					
-						std::vector<std::pair<std::string, bool>> instrVec = ImageSequencer2::ref().getActiveInstruments();
+                            std::pair<double, std::vector<std::string>> incidentTargets = ImageSequencer2::ref().getIncidentTargetList(2);
+                            std::string space;
+                            glm::vec4 color;
+                            int isize = incidentTargets.second.size();
+                            for (int p = 0; p < isize; p++){
+                                double t = (double)(p + 1) / (double)(isize + 1);
+                                t = (p > isize / 2) ? 1 - t : t;
+                                t += 0.3;
+                                color = (p == isize / 2) ? glm::vec4(1.00, 0.51, 0.00, 1) : glm::vec4(t, t, t, 1);
+                                PrintColorText(i, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
+                                for (int k = 0; k < 10; k++){ space += " "; }
+                            }
+                            i++;
 
-						glm::vec4 active(0.58, 1, 0.00, 1);
+                            std::vector<std::pair<std::string, bool>> instrVec = ImageSequencer2::ref().getActiveInstruments();
+
+                            glm::vec4 active(0.58, 1, 0.00, 1);
 
 
-						glm::vec4 firing(0.58-t, 1-t, 1-t, 1);
-						glm::vec4 notFiring(0.5, 0.5, 0.5, 1);
+                            glm::vec4 firing(0.58 - t, 1 - t, 1 - t, 1);
+                            glm::vec4 notFiring(0.5, 0.5, 0.5, 1);
 
 
-						double reduce = 0.01;
+                            double reduce = 0.01;
 
-						PrintColorText(i++, "Active Instruments : ", 10, active);
-						for (int k = 0; k < instrVec.size(); k++){
+                            PrintColorText(i++, "Active Instruments : ", 10, active);
+                            for (int k = 0; k < instrVec.size(); k++){
 
-							if (instrVec[k].second == false){
-								PrintColorText(i, "| |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								PrintColorText(i++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), instrVec[k].first.c_str());
-							}
-							else{
-								PrintColorText(i, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								if (instrVec[k].first == "NH_LORRI"){
-									PrintColorText(i, " + ", 10, firing);
-								}
-								PrintColorText(i, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								PrintColorText(i++, "    %5s", 10, active, instrVec[k].first.c_str());
+                                if (instrVec[k].second == false){
+                                    PrintColorText(i, "| |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+                                    PrintColorText(i++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), instrVec[k].first.c_str());
+                                }
+                                else{
+                                    PrintColorText(i, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+                                    if (instrVec[k].first == "NH_LORRI"){
+                                        PrintColorText(i, " + ", 10, firing);
+                                    }
+                                    PrintColorText(i, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+                                    PrintColorText(i++, "    %5s", 10, active, instrVec[k].first.c_str());
 
-							}
-						}
-						
+                                }
+                            }
+                        }
 					}
 					
 #undef PrintText
diff --git a/src/util/imagesequencer2.cpp b/src/util/imagesequencer2.cpp
index 573b648b4a..e5d66c7a5b 100644
--- a/src/util/imagesequencer2.cpp
+++ b/src/util/imagesequencer2.cpp
@@ -116,9 +116,11 @@ std::pair<double, std::string> ImageSequencer2::getCurrentTarget(){
 	findEqualToThis.first = _currentTime;
 	auto it = std::lower_bound(_targetTimes.begin(), _targetTimes.end(), findEqualToThis, compareTime);
 
-	if (it != _targetTimes.end()){
+	if (it != _targetTimes.end() && it != _targetTimes.begin()){
 		return *std::prev(it);
 	}
+    else
+        return std::make_pair(0.0, "No Target");
 }
 
 std::pair<double, std::vector<std::string>> ImageSequencer2::getIncidentTargetList(int range){
@@ -225,7 +227,7 @@ bool ImageSequencer2::getImagePaths(std::vector<std::pair<double, std::string>>&
 		auto curr = std::lower_bound(begin, end, findCurrent, compareTime);
 		auto prev = std::lower_bound(begin, end, findPrevious, compareTime);
 
-		if (curr != begin && curr != end  && prev != begin && prev != end){
+		if (curr != begin && curr != end  && prev != begin && prev != end && prev < curr){
 			std::transform(prev, curr, std::back_inserter(captureTimes),
 				[](const Image& i) {
 				return std::make_pair(i.startTime, i.path);

From d89760c9e96585441badd8e3d2fc929a8373c0c0 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Sun, 3 May 2015 00:14:17 +0200
Subject: [PATCH 06/27] More changes on TimelineView

---
 gui/timelineview/CMakeLists.txt               |  2 +-
 gui/timelineview/common.h                     |  2 +
 ...imecontrolwidget.cpp => controlwidget.cpp} | 58 ++++++++++++++++---
 .../{timecontrolwidget.h => controlwidget.h}  | 12 ++--
 gui/timelineview/mainwindow.cpp               |  6 +-
 gui/timelineview/mainwindow.h                 |  4 +-
 gui/timelineview/timelinewidget.cpp           |  6 +-
 7 files changed, 68 insertions(+), 22 deletions(-)
 rename gui/timelineview/{timecontrolwidget.cpp => controlwidget.cpp} (72%)
 rename gui/timelineview/{timecontrolwidget.h => controlwidget.h} (93%)

diff --git a/gui/timelineview/CMakeLists.txt b/gui/timelineview/CMakeLists.txt
index 86dd6b9a9c..da453d23bd 100644
--- a/gui/timelineview/CMakeLists.txt
+++ b/gui/timelineview/CMakeLists.txt
@@ -6,5 +6,5 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON)
 set(CMAKE_AUTOMOC ON)
 find_package(Qt5Widgets)
 find_package(Qt5Network)
-add_executable(TimelineView main.cpp mainwindow.cpp configurationwidget.cpp informationwidget.cpp timecontrolwidget.cpp timelinewidget.cpp)
+add_executable(TimelineView main.cpp mainwindow.cpp configurationwidget.cpp informationwidget.cpp controlwidget.cpp timelinewidget.cpp)
 target_link_libraries(TimelineView Qt5::Widgets Qt5::Network)
\ No newline at end of file
diff --git a/gui/timelineview/common.h b/gui/timelineview/common.h
index 2588afda3a..ddc0bad206 100644
--- a/gui/timelineview/common.h
+++ b/gui/timelineview/common.h
@@ -28,6 +28,8 @@
 struct Image {
     double beginning;
     double ending;
+    std::string beginningString;
+    std::string endingString;
     std::string target;
     std::vector<std::string> instruments;
 };
diff --git a/gui/timelineview/timecontrolwidget.cpp b/gui/timelineview/controlwidget.cpp
similarity index 72%
rename from gui/timelineview/timecontrolwidget.cpp
rename to gui/timelineview/controlwidget.cpp
index c2693c7aae..8074092a36 100644
--- a/gui/timelineview/timecontrolwidget.cpp
+++ b/gui/timelineview/controlwidget.cpp
@@ -22,7 +22,7 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#include "timecontrolwidget.h"
+#include "controlwidget.h"
 
 #include <QComboBox>
 #include <QGridLayout>
@@ -31,7 +31,25 @@
 #include <QPushButton>
 #include <QSlider>
 
-TimeControlWidget::TimeControlWidget(QWidget* parent)
+namespace {
+    struct ImportantDate {
+        QString date;
+        QString focus;
+        QString coordinateSystem;
+    };
+
+    const ImportantDate ImportantDates[] = {
+        { "2007-02-27T16:40:00.00", "JupiterProjection", "Jupiter" },
+        { "2015-07-14T10:50:00.00", "PlutoProjection", "Pluto" },
+        { "2015-07-14T11:22:00.00", "PlutoProjection", "Pluto" },
+        { "2015-07-14T11:36:40.00", "PlutoProjection", "Pluto" },
+        { "2015-07-14T11:48:43.00", "PlutoProjection", "Pluto" },
+        { "2015-07-14T12:04:35.00", "PlutoProjection", "Pluto" },
+        { "2015-07-14T15:02:46.00", "PlutoProjection", "Pluto" }
+    };
+}
+
+ControlWidget::ControlWidget(QWidget* parent)
     : QWidget(parent)
     , _currentTime(new QLabel("Current Time"))
     , _setTime(new QComboBox)
@@ -42,6 +60,16 @@ TimeControlWidget::TimeControlWidget(QWidget* parent)
     , _play(new QPushButton("|>"))
     , _forward(new QPushButton(">>"))
 {
+    for (const ImportantDate& d : ImportantDates)
+        _setTime->addItem(d.date);
+    QObject::connect(
+        _setTime,
+        SIGNAL(currentIndexChanged(int)),
+        this,
+        SLOT(onDateChange())
+    );
+
+
     _setDelta->setMinimum(-100);
     _setDelta->setMaximum(100);
     _setDelta->setValue(0);
@@ -99,33 +127,47 @@ TimeControlWidget::TimeControlWidget(QWidget* parent)
     setLayout(layout);
 }
 
-void TimeControlWidget::update(QString currentTime, QString currentDelta) {
+void ControlWidget::update(QString currentTime, QString currentDelta) {
     _currentTime->setText(currentTime);
     _currentDelta->setText(currentDelta);
 }
 
-void TimeControlWidget::onValueChange() {
+void ControlWidget::onValueChange() {
     QString script = "openspace.time.setDeltaTime(" + QString::number(_setDelta->value()) + ");";
     emit scriptActivity(script);
 }
 
-void TimeControlWidget::onRewindButton() {
+void ControlWidget::onRewindButton() {
     QString script = "openspace.time.setDeltaTime(-openspace.time.deltaTime());";
     emit scriptActivity(script);
 }
 
-void TimeControlWidget::onPauseButton() {
+void ControlWidget::onPauseButton() {
     QString script = "openspace.time.setPause(true);";
     emit scriptActivity(script);
 }
 
-void TimeControlWidget::onPlayButton() {
+void ControlWidget::onPlayButton() {
     QString script = "openspace.time.setPause(false);";
     emit scriptActivity(script);
 }
 
-void TimeControlWidget::onForwardButton() {
+void ControlWidget::onForwardButton() {
     QString script = "openspace.time.setDeltaTime(-openspace.time.deltaTime());";
     emit scriptActivity(script);
 
 }
+
+void ControlWidget::onDateChange() {
+    int index = _setTime->currentIndex();
+    QString date = ImportantDates[index].date;
+    QString focus = ImportantDates[index].focus;
+    QString coordinateSystem = ImportantDates[index].coordinateSystem;
+    //QString script =
+    //    "openspace.time.setTime('" + date + "');\
+    //     openspace.setOrigin('" + focus + "');\
+    //     openspace.changeCoordinateSystem('" + coordinateSystem + "');";
+    QString script =
+        "openspace.setOrigin('" + focus + "');";
+    emit scriptActivity(script);
+}
diff --git a/gui/timelineview/timecontrolwidget.h b/gui/timelineview/controlwidget.h
similarity index 93%
rename from gui/timelineview/timecontrolwidget.h
rename to gui/timelineview/controlwidget.h
index 8265184cf3..c60783d3fb 100644
--- a/gui/timelineview/timecontrolwidget.h
+++ b/gui/timelineview/controlwidget.h
@@ -22,8 +22,8 @@
  * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
  ****************************************************************************************/
 
-#ifndef __TIMECONTROLWIDGET_H__
-#define __TIMECONTROLWIDGET_H__
+#ifndef __CONTROLWIDGET_H__
+#define __CONTROLWIDGET_H__
 
 #include <QWidget>
 
@@ -32,10 +32,10 @@ class QLabel;
 class QPushButton;
 class QSlider;
 
-class TimeControlWidget : public QWidget {
+class ControlWidget : public QWidget {
 Q_OBJECT
 public:
-	TimeControlWidget(QWidget* parent);
+	ControlWidget(QWidget* parent);
 
     void update(QString currentTime, QString currentDelta);
 
@@ -44,11 +44,13 @@ signals:
 
 private slots:
     void onValueChange();
+    void onDateChange();
     void onRewindButton();
     void onPauseButton();
     void onPlayButton();
     void onForwardButton();
 
+
 private:
     QLabel* _currentTime;
     QComboBox* _setTime;
@@ -62,4 +64,4 @@ private:
     bool _stateNoNotification = false;
 };
 
-#endif // __TIMECONTROLWIDGET_H__
+#endif // __CONTROLWIDGET_H__
diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index 845a719e89..86e0a1517f 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -25,7 +25,7 @@
 #include "mainwindow.h"
 
 #include "configurationwidget.h"
-#include "timecontrolwidget.h"
+#include "controlwidget.h"
 #include "informationwidget.h"
 #include "timelinewidget.h"
 
@@ -69,7 +69,7 @@ MainWindow::MainWindow()
 	setWindowTitle("OpenSpace Timeline");
 
     _configurationWidget = new ConfigurationWidget(this);
-    _timeControlWidget = new TimeControlWidget(this);
+    _timeControlWidget = new ControlWidget(this);
     _informationWidget = new InformationWidget(this);
     _timelineWidget = new TimelineWidget(this);
 
@@ -174,7 +174,7 @@ void MainWindow::handleStatusMessage(QByteArray data) {
         QString::fromStdString(std::string(timeString.begin(), timeString.end())),
         QString::number(delta.value)
     );
-    _timelineWidget->setCurrentTime(std::string(timeString.begin(), timeString.end()));
+    _timelineWidget->setCurrentTime(std::string(timeString.begin(), timeString.end()), et.value);
 }
 
 std::vector<std::string> instrumentsFromId(uint16_t instrumentId, std::map<uint16_t, std::string> instrumentMap) {
diff --git a/gui/timelineview/mainwindow.h b/gui/timelineview/mainwindow.h
index cb9ada8a8b..cf30e8bfa2 100644
--- a/gui/timelineview/mainwindow.h
+++ b/gui/timelineview/mainwindow.h
@@ -31,7 +31,7 @@
 #include "common.h"
 
 class ConfigurationWidget;
-class TimeControlWidget;
+class ControlWidget;
 class InformationWidget;
 class TimelineWidget;
 
@@ -55,7 +55,7 @@ private slots:
 
 private:
     ConfigurationWidget* _configurationWidget;
-    TimeControlWidget* _timeControlWidget;
+    ControlWidget* _timeControlWidget;
     InformationWidget* _informationWidget;
     TimelineWidget* _timelineWidget;
     
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index 5f064a0619..30d2b018ec 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -124,9 +124,9 @@ void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
 
     std::vector<Image>::const_iterator start = _images.end();
     std::vector<Image>::const_iterator end = _images.end();
-    for (std::vector<Image>::const_iterator it = _images.begin(); it != _image.end(); ++it) {
-        if (it->beginning > lowerTime 
-    }
+    //for (std::vector<Image>::const_iterator it = _images.begin(); it != _images.end(); ++it) {
+    //    if (it->beginning > lowerTime 
+    //}
 
     //std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [lowerTime](const Image& i) { return i.beginning < lowerTime; });
     ////std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _iamges.end(), upperTime)

From 14270b316e370b16768b2717f7fbaf2e031ea780 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Sun, 3 May 2015 13:52:55 +0200
Subject: [PATCH 07/27] Bugfix fixing a crash with rendering Started rendering
 of image data

---
 gui/timelineview/controlwidget.cpp  | 10 +++----
 gui/timelineview/mainwindow.cpp     |  3 ++-
 gui/timelineview/timelinewidget.cpp | 41 ++++++++++++++++++++---------
 gui/timelineview/timelinewidget.h   |  2 +-
 4 files changed, 37 insertions(+), 19 deletions(-)

diff --git a/gui/timelineview/controlwidget.cpp b/gui/timelineview/controlwidget.cpp
index 8074092a36..d54f97ac3d 100644
--- a/gui/timelineview/controlwidget.cpp
+++ b/gui/timelineview/controlwidget.cpp
@@ -163,11 +163,11 @@ void ControlWidget::onDateChange() {
     QString date = ImportantDates[index].date;
     QString focus = ImportantDates[index].focus;
     QString coordinateSystem = ImportantDates[index].coordinateSystem;
-    //QString script =
-    //    "openspace.time.setTime('" + date + "');\
-    //     openspace.setOrigin('" + focus + "');\
-    //     openspace.changeCoordinateSystem('" + coordinateSystem + "');";
     QString script =
-        "openspace.setOrigin('" + focus + "');";
+        "openspace.time.setTime('" + date + "');\
+         openspace.setOrigin('" + focus + "');\
+         openspace.changeCoordinateSystem('" + coordinateSystem + "');";
+    //QString script =
+    //    "openspace.setOrigin('" + focus + "');";
     emit scriptActivity(script);
 }
diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index 86e0a1517f..503bcf1e6b 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -231,6 +231,7 @@ void MainWindow::handlePlaybook(QByteArray data) {
 
 
 void MainWindow::sendScript(QString script) {
-    _socket->write(("0" + script + "\r\n").toLatin1());
+    if (_socket)
+        _socket->write(("0" + script + "\r\n").toLatin1());
 }
 
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index 30d2b018ec..0fd032b40b 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -121,18 +121,10 @@ void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
 
     const double lowerTime = _currentTime.et - etSpread;
     const double upperTime = _currentTime.et + etSpread;
-
-    std::vector<Image>::const_iterator start = _images.end();
-    std::vector<Image>::const_iterator end = _images.end();
-    //for (std::vector<Image>::const_iterator it = _images.begin(); it != _images.end(); ++it) {
-    //    if (it->beginning > lowerTime 
-    //}
-
-    //std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [lowerTime](const Image& i) { return i.beginning < lowerTime; });
-    ////std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _iamges.end(), upperTime)
-
-
-
+    std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [](const Image& i, double time) { return i.beginning < time; });
+    std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _images.end(), upperTime, [](const Image& i, double time) { return i.ending < time; });
+    if (lower != _images.end() && upper != _images.end())
+        drawImages(painter, timelineRect, lower, upper, lowerTime, upperTime);
 }
 
 void TimelineWidget::drawLegend(QPainter& painter, QRectF rect) {
@@ -187,3 +179,28 @@ void TimelineWidget::setCurrentTime(std::string currentTime, double et) {
 
 }
 
+void TimelineWidget::drawImages(
+    QPainter& painter,
+    QRectF rect,
+    std::vector<Image>::const_iterator beginning,
+    std::vector<Image>::const_iterator ending,
+    double minimumTime, double maximumTime)
+{
+    int width = rect.width();
+
+    for (std::vector<Image>::const_iterator cur = beginning; cur != ending; ++cur) {
+        //double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+        //double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
+        double t = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+
+        int loc = rect.top() + rect.height() * t;
+
+        //int begin = rect.top() + rect.height() * tBeg;
+        //int end = rect.top() + rect.height() * tEnd;
+
+        //painter.drawRect(begin, 0, width, end);
+        painter.drawLine(QPointF(0, loc), QPointF(rect.width(), loc));
+        
+    }
+}
+
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index 33c455b3eb..8ed55e44af 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -47,7 +47,7 @@ protected:
     void paintEvent(QPaintEvent* event);  
     void drawContent(QPainter& painter, QRectF rect);
     void drawLegend(QPainter& painter, QRectF rect);
-
+    void drawImages(QPainter& painter, QRectF rect, std::vector<Image>::const_iterator beginning, std::vector<Image>::const_iterator ending, double minimumTime, double maximumTime);
 
 private:
     std::vector<Image> _images;

From 810480d5d859149357077c74dd3b9c09e6ae5cb5 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Mon, 4 May 2015 10:02:47 +0200
Subject: [PATCH 08/27] Enable focus node change Show instruments

---
 gui/timelineview/controlwidget.cpp  | 45 +++++++++++++++++++++++++++--
 gui/timelineview/controlwidget.h    |  4 +--
 gui/timelineview/timelinewidget.cpp | 27 ++++++++++++-----
 openspace-data                      |  2 +-
 4 files changed, 66 insertions(+), 12 deletions(-)

diff --git a/gui/timelineview/controlwidget.cpp b/gui/timelineview/controlwidget.cpp
index d54f97ac3d..964c34ce55 100644
--- a/gui/timelineview/controlwidget.cpp
+++ b/gui/timelineview/controlwidget.cpp
@@ -47,6 +47,20 @@ namespace {
         { "2015-07-14T12:04:35.00", "PlutoProjection", "Pluto" },
         { "2015-07-14T15:02:46.00", "PlutoProjection", "Pluto" }
     };
+
+    struct FocusNode {
+        QString guiName;
+        QString name;
+        QString coordinateSystem;
+    };
+    const FocusNode FocusNodes[] = {
+        { "Earth", "Earth", "Sun" },
+        { "Sun", "Sun", "Sun" },
+        { "Pluto", "PlutoProjection", "Pluto" },
+        { "Charon", "Charon", "Pluto" },
+        { "Jupiter", "JupiterProjection", "Jupiter" },
+        { "New Horizons", "NewHorizons", ""}
+    };
 }
 
 ControlWidget::ControlWidget(QWidget* parent)
@@ -59,6 +73,7 @@ ControlWidget::ControlWidget(QWidget* parent)
     , _pause(new QPushButton("||"))
     , _play(new QPushButton("|>"))
     , _forward(new QPushButton(">>"))
+    , _focusNode(new QComboBox)
 {
     for (const ImportantDate& d : ImportantDates)
         _setTime->addItem(d.date);
@@ -69,6 +84,14 @@ ControlWidget::ControlWidget(QWidget* parent)
         SLOT(onDateChange())
     );
 
+    for (const FocusNode& f : FocusNodes)
+        _focusNode->addItem(f.guiName);
+    QObject::connect(
+        _focusNode,
+        SIGNAL(currentIndexChanged(int)),
+        this,
+        SLOT(onFocusChange())
+    );
 
     _setDelta->setMinimum(-100);
     _setDelta->setMaximum(100);
@@ -124,6 +147,8 @@ ControlWidget::ControlWidget(QWidget* parent)
     controlContainer->setLayout(controlContainerLayout);
     layout->addWidget(controlContainer, 3, 0, 1, 2);
 
+    layout->addWidget(_focusNode, 4, 0, 1, 2);
+
     setLayout(layout);
 }
 
@@ -167,7 +192,23 @@ void ControlWidget::onDateChange() {
         "openspace.time.setTime('" + date + "');\
          openspace.setOrigin('" + focus + "');\
          openspace.changeCoordinateSystem('" + coordinateSystem + "');";
-    //QString script =
-    //    "openspace.setOrigin('" + focus + "');";
+    emit scriptActivity(script);
+}
+
+void ControlWidget::onFocusChange() {
+    int index = _focusNode->currentIndex();
+    QString name = FocusNodes[index].name;
+    QString coordinateSystem = FocusNodes[index].coordinateSystem;
+    if (coordinateSystem.isEmpty()) {
+        int date = _currentTime->text().left(4).toInt();
+        if (date < 2008)
+            coordinateSystem = "Jupiter";
+        else if (date < 2014)
+            coordinateSystem = "Sun";
+        else
+            coordinateSystem = "Pluto";
+
+    }
+    QString script = "openspace.setOrigin('" + name + "');openspace.changeCoordinateSystem('" + coordinateSystem + "');";
     emit scriptActivity(script);
 }
diff --git a/gui/timelineview/controlwidget.h b/gui/timelineview/controlwidget.h
index c60783d3fb..f4d78ae676 100644
--- a/gui/timelineview/controlwidget.h
+++ b/gui/timelineview/controlwidget.h
@@ -45,6 +45,7 @@ signals:
 private slots:
     void onValueChange();
     void onDateChange();
+    void onFocusChange();
     void onRewindButton();
     void onPauseButton();
     void onPlayButton();
@@ -60,8 +61,7 @@ private:
     QPushButton* _pause;
     QPushButton* _play;
     QPushButton* _forward;
-
-    bool _stateNoNotification = false;
+    QComboBox* _focusNode;
 };
 
 #endif // __CONTROLWIDGET_H__
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index 0fd032b40b..beda0e0490 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -188,19 +188,32 @@ void TimelineWidget::drawImages(
 {
     int width = rect.width();
 
-    for (std::vector<Image>::const_iterator cur = beginning; cur != ending; ++cur) {
+    for (std::vector<Image>::const_iterator cur = beginning; cur <= ending; ++cur) {
         //double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
         //double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
         double t = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
 
         int loc = rect.top() + rect.height() * t;
+        int height = 25;
 
-        //int begin = rect.top() + rect.height() * tBeg;
-        //int end = rect.top() + rect.height() * tEnd;
+        std::string target = cur->target;
+        auto it = std::find(_targets.begin(), _targets.end(), target);
+        int iTarget = std::distance(_targets.begin(), it);
+        QColor targetColor = targetColors[iTarget];
 
-        //painter.drawRect(begin, 0, width, end);
-        painter.drawLine(QPointF(0, loc), QPointF(rect.width(), loc));
-        
+        std::vector<std::string> instruments = cur->instruments;
+        std::vector<QColor> colors;
+        for (std::string instrument : instruments) {
+            auto it = std::find(_instruments.begin(), _instruments.end(), instrument);
+            int i = std::distance(_instruments.begin(), it);
+            colors.push_back(instrumentColors[i]);
+        }
+
+        painter.setBrush(QBrush(targetColor));
+        if (colors.empty()))
+            painter.setPen(QPen(Qt::black));
+        else
+            painter.setPen(QPen(colors[0]));
+        painter.drawRect(0, loc, rect.width(), height);
     }
 }
-
diff --git a/openspace-data b/openspace-data
index 6b34ef9849..16dbd84e5c 160000
--- a/openspace-data
+++ b/openspace-data
@@ -1 +1 @@
-Subproject commit 6b34ef9849d58fa33a40c571eee6432bde83e343
+Subproject commit 16dbd84e5c11116339d2071a49f4a473577a0dad

From 314ce645f6820693f6fdd7dd93f6ea1e3331f600 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Mon, 4 May 2015 11:55:53 +0200
Subject: [PATCH 09/27] Fix a bug where OpenSpace would crash when too many
 field of views are generated

---
 src/rendering/renderablefov.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rendering/renderablefov.cpp b/src/rendering/renderablefov.cpp
index 66233c48dd..64234ac171 100644
--- a/src/rendering/renderablefov.cpp
+++ b/src/rendering/renderablefov.cpp
@@ -104,7 +104,7 @@ namespace openspace{
 }
 
 void RenderableFov::allocateData(){ 
-	int points = 10;
+	int points = 20;
 	_stride[0] = points;
 	_isize[0]  = points;
 	_iarray1[0] = new int[_isize[0]];

From 5704c8dcf687b33de3cbc7b42e7838bf630f6203 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Mon, 4 May 2015 11:56:21 +0200
Subject: [PATCH 10/27] Show the target of an instrument in the timeline view

---
 gui/timelineview/mainwindow.cpp     |  1 +
 gui/timelineview/timelinewidget.cpp | 86 +++++++++++++++++------------
 gui/timelineview/timelinewidget.h   |  2 +-
 3 files changed, 52 insertions(+), 37 deletions(-)

diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index 503bcf1e6b..16342cf91f 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -142,6 +142,7 @@ void MainWindow::readTcpData() {
         uint32_t size = readFromBuffer<uint32_t>(data.mid(2).data(), beginning);
 
         while (_socket->waitForReadyRead() && data.size() < size) {
+        //while (data.size() < size) {
             data = data.append(_socket->readAll());
         }
         handlePlaybook(data.mid(2));
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index beda0e0490..aea1d27e05 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -32,16 +32,18 @@
 
 namespace {
     static const int LegendHeight = 105;
-    static const int TimeWidth = 150;
+    static const int TimeWidth = 200;
+    
+    static const int TextOffset = 5;
 
-    const QColor targetColors[] = {
-        QColor(251, 180, 174),
-        QColor(179, 205, 227),
-        QColor(204, 235, 197),
-        QColor(222, 203, 228),
-        QColor(254, 217, 166),
-        QColor(255, 255, 204)
-    };
+    //const QColor targetColors[] = {
+    //    QColor(251, 180, 174),
+    //    QColor(179, 205, 227),
+    //    QColor(204, 235, 197),
+    //    QColor(222, 203, 228),
+    //    QColor(254, 217, 166),
+    //    QColor(255, 255, 204)
+    //};
 
     const QColor instrumentColors[] = {
         QColor(228, 26, 28),
@@ -116,8 +118,7 @@ void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
     // Draw current time
     painter.setBrush(QBrush(Qt::black));
     painter.drawLine(QPointF(0, timelineRect.height() / 2), QPointF(timelineRect.width(), timelineRect.height() / 2));
-    painter.drawText(timelineRect.width(), timelineRect.height() / 2, QString::fromStdString(_currentTime.time));
-
+    painter.drawText(timelineRect.width(), timelineRect.height() / 2 + TextOffset, QString::fromStdString(_currentTime.time));
 
     const double lowerTime = _currentTime.et - etSpread;
     const double upperTime = _currentTime.et + etSpread;
@@ -135,18 +136,18 @@ void TimelineWidget::drawLegend(QPainter& painter, QRectF rect) {
     // Draw Targets
     int currentHorizontalPosition = Padding;
     int currentVerticalPosition = Padding;
-    for (int i = 0; i < _targets.size(); ++i) {
+    //for (int i = 0; i < _targets.size(); ++i) {
 
-        const std::string& target = _targets[i];
-        
-        painter.setBrush(QBrush(targetColors[i]));
-        painter.drawRect(currentHorizontalPosition, currentVerticalPosition, BoxSize, BoxSize);
-        currentHorizontalPosition += BoxSize + Padding;
+    //    const std::string& target = _targets[i];
+    //    
+    //    painter.setBrush(QBrush(targetColors[i]));
+    //    painter.drawRect(currentHorizontalPosition, currentVerticalPosition, BoxSize, BoxSize);
+    //    currentHorizontalPosition += BoxSize + Padding;
 
-        painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2, QString::fromStdString(target));
-        int textWidth = painter.boundingRect(QRect(), QString::fromStdString(target)).width();
-        currentHorizontalPosition += std::max(textWidth, 25) + Padding;
-    }
+    //    painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2 + TextOffset, QString::fromStdString(target));
+    //    int textWidth = painter.boundingRect(QRect(), QString::fromStdString(target)).width();
+    //    currentHorizontalPosition += std::max(textWidth, 25) + Padding;
+    //}
 
     // Draw Instruments
     currentHorizontalPosition = Padding;
@@ -160,13 +161,13 @@ void TimelineWidget::drawLegend(QPainter& painter, QRectF rect) {
         const std::string& instrument = _instruments[i];
 
         //painter.setBrush(QBrush(instrumentColors[i]));
-        painter.setBrush(Qt::NoBrush);
+        painter.setBrush(QBrush(instrumentColors[i]));
         painter.setPen(QPen(instrumentColors[i]));
         painter.drawRect(currentHorizontalPosition, currentVerticalPosition, BoxSize, BoxSize);
         currentHorizontalPosition += BoxSize + Padding;
 
         painter.setPen(QPen(Qt::black));
-        painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2, QString::fromStdString(instrument));
+        painter.drawText(currentHorizontalPosition, currentVerticalPosition + BoxSize / 2 + TextOffset, QString::fromStdString(instrument));
         int textWidth = painter.boundingRect(QRect(), QString::fromStdString(instrument)).width();
         currentHorizontalPosition += std::max(textWidth, 25) + Padding;
     }
@@ -181,25 +182,26 @@ void TimelineWidget::setCurrentTime(std::string currentTime, double et) {
 
 void TimelineWidget::drawImages(
     QPainter& painter,
-    QRectF rect,
+    QRectF timelineRect,
     std::vector<Image>::const_iterator beginning,
     std::vector<Image>::const_iterator ending,
     double minimumTime, double maximumTime)
 {
-    int width = rect.width();
+    int width = timelineRect.width();
 
     for (std::vector<Image>::const_iterator cur = beginning; cur <= ending; ++cur) {
-        //double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
-        //double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
-        double t = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+        double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+        double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
+        //double t = (cur->ending - minimumTime) / (maximumTime - minimumTime);
 
-        int loc = rect.top() + rect.height() * t;
-        int height = 25;
+        int loc = timelineRect.top() + timelineRect.height() * tBeg;
+        int height = (timelineRect.top() + timelineRect.height() * tEnd) - loc;
+        height = std::max(height, 5);
 
         std::string target = cur->target;
         auto it = std::find(_targets.begin(), _targets.end(), target);
         int iTarget = std::distance(_targets.begin(), it);
-        QColor targetColor = targetColors[iTarget];
+        //QColor targetColor = targetColors[iTarget];
 
         std::vector<std::string> instruments = cur->instruments;
         std::vector<QColor> colors;
@@ -209,11 +211,23 @@ void TimelineWidget::drawImages(
             colors.push_back(instrumentColors[i]);
         }
 
-        painter.setBrush(QBrush(targetColor));
-        if (colors.empty()))
-            painter.setPen(QPen(Qt::black));
+        //painter.setBrush(QBrush(targetColor));
+        if (colors.empty())
+            painter.setBrush(QBrush(Qt::black));
         else
-            painter.setPen(QPen(colors[0]));
-        painter.drawRect(0, loc, rect.width(), height);
+            painter.setBrush(QBrush(colors[0]));
+        painter.drawRect(0, loc, timelineRect.width(), height);
+
+        painter.setBrush(QBrush(Qt::black));
+        painter.setPen(QPen(Qt::black));
+        //QString firstLine = QString::fromStdString(cur->beginningString);
+        //QString secondLine = QString::fromStdString(cur->target);
+        QString line = QString::fromStdString(cur->beginningString) + QString("(") + QString::fromStdString(cur->target) + QString(")");
+
+        painter.drawText(timelineRect.width(), loc + height / 2 + TextOffset, line);
+
+        //painter.drawText(timelineRect.width(), loc + height / 2 - 1.5 * TextOffset, firstLine);
+        //painter.drawText(timelineRect.width(), loc + height / 2 + 1.5 * TextOffset, secondLine);
+
     }
 }
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index 8ed55e44af..e8dbd02b8b 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -47,7 +47,7 @@ protected:
     void paintEvent(QPaintEvent* event);  
     void drawContent(QPainter& painter, QRectF rect);
     void drawLegend(QPainter& painter, QRectF rect);
-    void drawImages(QPainter& painter, QRectF rect, std::vector<Image>::const_iterator beginning, std::vector<Image>::const_iterator ending, double minimumTime, double maximumTime);
+    void drawImages(QPainter& painter, QRectF timelineRect, std::vector<Image>::const_iterator beginning, std::vector<Image>::const_iterator ending, double minimumTime, double maximumTime);
 
 private:
     std::vector<Image> _images;

From 4451bbe920aab5a49cbf37e0b11546cf09671184 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Mon, 4 May 2015 17:29:18 +0200
Subject: [PATCH 11/27] More work on timeline application Only showing the
 images that are inside of the timeline Disabling all widgets when no
 connection is established

---
 gui/timelineview/configurationwidget.cpp |  6 +++++
 gui/timelineview/configurationwidget.h   |  3 +++
 gui/timelineview/controlwidget.cpp       |  8 +++++++
 gui/timelineview/controlwidget.h         |  4 +++-
 gui/timelineview/informationwidget.cpp   |  8 +++++++
 gui/timelineview/informationwidget.h     |  2 ++
 gui/timelineview/mainwindow.cpp          | 30 ++++++++++++++++++++----
 gui/timelineview/mainwindow.h            |  3 +++
 gui/timelineview/timelinewidget.cpp      | 20 +++++++++++++++-
 gui/timelineview/timelinewidget.h        |  2 ++
 10 files changed, 79 insertions(+), 7 deletions(-)

diff --git a/gui/timelineview/configurationwidget.cpp b/gui/timelineview/configurationwidget.cpp
index 38b4526546..8f2043fed5 100644
--- a/gui/timelineview/configurationwidget.cpp
+++ b/gui/timelineview/configurationwidget.cpp
@@ -46,3 +46,9 @@ ConfigurationWidget::ConfigurationWidget(QWidget* parent)
 void ConfigurationWidget::onConnectButton() {
     emit connect(_ipAddress->text(), _port->text());
 }
+
+void ConfigurationWidget::socketConnected() {
+}
+
+void ConfigurationWidget::socketDisconnected() {
+}
diff --git a/gui/timelineview/configurationwidget.h b/gui/timelineview/configurationwidget.h
index 2c6291a13c..ae6fd8b654 100644
--- a/gui/timelineview/configurationwidget.h
+++ b/gui/timelineview/configurationwidget.h
@@ -34,6 +34,9 @@ Q_OBJECT
 public:
 	ConfigurationWidget(QWidget* parent);
 
+    void socketConnected();
+    void socketDisconnected();
+
 signals:
     void connect(QString host, QString port);
 
diff --git a/gui/timelineview/controlwidget.cpp b/gui/timelineview/controlwidget.cpp
index 964c34ce55..1bd65f0c7c 100644
--- a/gui/timelineview/controlwidget.cpp
+++ b/gui/timelineview/controlwidget.cpp
@@ -212,3 +212,11 @@ void ControlWidget::onFocusChange() {
     QString script = "openspace.setOrigin('" + name + "');openspace.changeCoordinateSystem('" + coordinateSystem + "');";
     emit scriptActivity(script);
 }
+
+void ControlWidget::socketConnected() {
+    setDisabled(false);
+}
+
+void ControlWidget::socketDisconnected() {
+    setDisabled(true);
+}
diff --git a/gui/timelineview/controlwidget.h b/gui/timelineview/controlwidget.h
index f4d78ae676..970040cfb7 100644
--- a/gui/timelineview/controlwidget.h
+++ b/gui/timelineview/controlwidget.h
@@ -39,6 +39,9 @@ public:
 
     void update(QString currentTime, QString currentDelta);
 
+    void socketConnected();
+    void socketDisconnected();
+
 signals:
     void scriptActivity(QString script);
 
@@ -51,7 +54,6 @@ private slots:
     void onPlayButton();
     void onForwardButton();
 
-
 private:
     QLabel* _currentTime;
     QComboBox* _setTime;
diff --git a/gui/timelineview/informationwidget.cpp b/gui/timelineview/informationwidget.cpp
index f53147b510..0647f9fb32 100644
--- a/gui/timelineview/informationwidget.cpp
+++ b/gui/timelineview/informationwidget.cpp
@@ -31,3 +31,11 @@ InformationWidget::InformationWidget(QWidget* parent)
     : QTextEdit(parent)
 {
 }
+
+void InformationWidget::socketConnected() {
+    setDisabled(false);
+}
+
+void InformationWidget::socketDisconnected() {
+    setDisabled(true);
+}
diff --git a/gui/timelineview/informationwidget.h b/gui/timelineview/informationwidget.h
index b0f4df3aed..abf56897a9 100644
--- a/gui/timelineview/informationwidget.h
+++ b/gui/timelineview/informationwidget.h
@@ -31,6 +31,8 @@ class InformationWidget : public QTextEdit {
 Q_OBJECT
 public:
 	InformationWidget(QWidget* parent);
+    void socketConnected();
+    void socketDisconnected();
 };
 
 #endif // __INFORMATIONWIDGET_H__
diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index 16342cf91f..2de8575a57 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -90,8 +90,12 @@ MainWindow::MainWindow()
         this, SLOT(sendScript(QString))
     );
 
-
 	setLayout(layout);
+
+    _configurationWidget->socketDisconnected();
+    _timeControlWidget->socketDisconnected();
+    _informationWidget->socketDisconnected();
+    _timelineWidget->socketDisconnected();
 }
 
 MainWindow::~MainWindow() {
@@ -102,10 +106,11 @@ void MainWindow::onConnect(QString host, QString port) {
     delete _socket;
 
     _socket = new QTcpSocket(this);
-    connect(_socket, SIGNAL(readyRead()), SLOT(readTcpData()));
-    _socket->connectToHost(host, port.toUInt());
+    QObject::connect(_socket, SIGNAL(readyRead()), SLOT(readTcpData()));
+    QObject::connect(_socket, SIGNAL(connected()), SLOT(onSocketConnected()));
+    QObject::connect(_socket, SIGNAL(disconnected()), SLOT(onSocketDisconnected()));
 
-    _socket->write(QString("1\r\n").toLatin1());
+    _socket->connectToHost(host, port.toUInt());
 }
 
 
@@ -228,11 +233,26 @@ void MainWindow::handlePlaybook(QByteArray data) {
     }
 
     _timelineWidget->setData(std::move(images), std::move(targetMap), std::move(instrumentMap));
-}
 
+    _configurationWidget->socketConnected();
+    _timeControlWidget->socketConnected();
+    _informationWidget->socketConnected();
+    _timelineWidget->socketConnected();
+}
 
 void MainWindow::sendScript(QString script) {
     if (_socket)
         _socket->write(("0" + script + "\r\n").toLatin1());
 }
 
+void MainWindow::onSocketConnected() {
+    _socket->write(QString("1\r\n").toLatin1());
+}
+
+void MainWindow::onSocketDisconnected() {
+    _configurationWidget->socketDisconnected();
+    _timeControlWidget->socketDisconnected();
+    _informationWidget->socketDisconnected();
+    _timelineWidget->socketDisconnected();
+}
+
diff --git a/gui/timelineview/mainwindow.h b/gui/timelineview/mainwindow.h
index cf30e8bfa2..594e400583 100644
--- a/gui/timelineview/mainwindow.h
+++ b/gui/timelineview/mainwindow.h
@@ -47,6 +47,9 @@ public slots:
 private slots:
     void onConnect(QString host, QString port);
 
+    void onSocketConnected();
+    void onSocketDisconnected();
+
 	//void onConnectButton();
 	//void sendCommandButton();
 	void readTcpData();
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index aea1d27e05..cb6bbb2e6d 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -28,6 +28,7 @@
 #include <QPainter>
 #include <QPaintEvent>
 
+#include <iostream>
 #include <set>
 
 namespace {
@@ -189,9 +190,11 @@ void TimelineWidget::drawImages(
 {
     int width = timelineRect.width();
 
-    for (std::vector<Image>::const_iterator cur = beginning; cur <= ending; ++cur) {
+    for (std::vector<Image>::const_iterator cur = beginning; cur < ending; ++cur) {
         double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+        tBeg = std::max(tBeg, 0.0);
         double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
+        tEnd = std::min(tEnd, 1.0);
         //double t = (cur->ending - minimumTime) / (maximumTime - minimumTime);
 
         int loc = timelineRect.top() + timelineRect.height() * tBeg;
@@ -230,4 +233,19 @@ void TimelineWidget::drawImages(
         //painter.drawText(timelineRect.width(), loc + height / 2 + 1.5 * TextOffset, secondLine);
 
     }
+
+    painter.setPen(QPen(Qt::green));
+    int _tmp = timelineRect.top() + timelineRect.height() * 1.0;
+    painter.drawLine(QPointF(0, _tmp), QPointF(timelineRect.width(), _tmp));
+}
+
+void TimelineWidget::socketConnected() {
+    setDisabled(false);
+}
+
+void TimelineWidget::socketDisconnected() {
+    setDisabled(true);
+    _images.clear();
+    _instruments.clear();
+    _targets.clear();
 }
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index e8dbd02b8b..f658d4f3a3 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -42,6 +42,8 @@ public:
 
     void setData(std::vector<Image> images, std::map<uint8_t, std::string> targetMap, std::map<uint16_t, std::string> instrumentMap);
     void setCurrentTime(std::string currentTime, double et);
+    void socketConnected();
+    void socketDisconnected();
 
 protected:
     void paintEvent(QPaintEvent* event);  

From fde0d10199c57b7d7c2540ac40a1a96e6e45c959 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Mon, 4 May 2015 18:31:17 +0200
Subject: [PATCH 12/27] Fix error with instrument transmission over the network

---
 gui/timelineview/mainwindow.cpp     | 16 +++++--
 gui/timelineview/timelinewidget.cpp | 73 +++++++++++++++--------------
 gui/timelineview/timelinewidget.h   |  2 +-
 src/util/hongkangparser.cpp         |  6 ++-
 4 files changed, 56 insertions(+), 41 deletions(-)

diff --git a/gui/timelineview/mainwindow.cpp b/gui/timelineview/mainwindow.cpp
index 2de8575a57..3574f4dbfe 100644
--- a/gui/timelineview/mainwindow.cpp
+++ b/gui/timelineview/mainwindow.cpp
@@ -187,8 +187,12 @@ std::vector<std::string> instrumentsFromId(uint16_t instrumentId, std::map<uint1
     std::vector<std::string> results;
     for (int i = 0; i < 16; ++i) {
         uint16_t testValue = 1 << i;
-        if ((testValue & instrumentId) == 1)
-            results.push_back(instrumentMap[testValue]);
+        if ((testValue & instrumentId) != 0) {
+            std::string t = instrumentMap.at(testValue);
+            if (t.empty())
+                qDebug() << "Empty instrument";
+            results.push_back(t);
+        }
     }
     return results;
 }
@@ -200,18 +204,22 @@ void MainWindow::handlePlaybook(QByteArray data) {
     uint32_t totalData = readFromBuffer<uint32_t>(buffer, currentReadLocation);
 
     uint8_t nTargets = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+    qDebug() << "Targets: " << nTargets;
     std::map<uint8_t, std::string> targetMap;
     for (uint8_t i = 0; i < nTargets; ++i) {
         uint8_t id = readFromBuffer<uint8_t>(buffer, currentReadLocation);
         std::string value = readFromBuffer<std::string>(buffer, currentReadLocation);
+        qDebug() << QString::fromStdString(value);
         targetMap[id] = value;
     }
 
     uint8_t nInstruments = readFromBuffer<uint8_t>(buffer, currentReadLocation);
+    qDebug() << "Instruments: " << nInstruments;
     std::map<uint16_t, std::string> instrumentMap;
     for (uint8_t i = 0; i < nInstruments; ++i) {
-        uint8_t id = readFromBuffer<uint16_t>(buffer, currentReadLocation);
+        uint16_t id = readFromBuffer<uint16_t>(buffer, currentReadLocation);
         std::string value = readFromBuffer<std::string>(buffer, currentReadLocation);
+        qDebug() << QString::fromStdString(value);
         instrumentMap[id] = value;
     }
 
@@ -229,6 +237,8 @@ void MainWindow::handlePlaybook(QByteArray data) {
         uint16_t instrumentId = readFromBuffer<uint16_t>(buffer, currentReadLocation);
         image.target = targetMap[targetId];
         image.instruments = instrumentsFromId(instrumentId, instrumentMap);
+        if (image.instruments.empty())
+            qDebug() << "Instruments were empty";
         images.push_back(image);
     }
 
diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index cb6bbb2e6d..92360afb22 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -116,17 +116,21 @@ void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
     painter.setBrush(QBrush(Qt::white));  painter.drawRect(timelineRect);
     painter.setBrush(QBrush(Qt::gray));   painter.drawRect(dateRect);
 
-    // Draw current time
-    painter.setBrush(QBrush(Qt::black));
-    painter.drawLine(QPointF(0, timelineRect.height() / 2), QPointF(timelineRect.width(), timelineRect.height() / 2));
-    painter.drawText(timelineRect.width(), timelineRect.height() / 2 + TextOffset, QString::fromStdString(_currentTime.time));
-
     const double lowerTime = _currentTime.et - etSpread;
     const double upperTime = _currentTime.et + etSpread;
     std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [](const Image& i, double time) { return i.beginning < time; });
     std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _images.end(), upperTime, [](const Image& i, double time) { return i.ending < time; });
     if (lower != _images.end() && upper != _images.end())
-        drawImages(painter, timelineRect, lower, upper, lowerTime, upperTime);
+        drawImages(painter, timelineRect, std::vector<Image>(lower, upper), lowerTime, upperTime);
+        
+    //drawImages(painter, timelineRect, _images, lowerTime, upperTime);
+
+
+    // Draw current time
+    painter.setBrush(QBrush(Qt::black));
+    painter.setPen(QPen(Qt::black));
+    painter.drawLine(QPointF(0, timelineRect.height() / 2), QPointF(timelineRect.width(), timelineRect.height() / 2));
+    painter.drawText(timelineRect.width(), timelineRect.height() / 2 + TextOffset, QString::fromStdString(_currentTime.time));
 }
 
 void TimelineWidget::drawLegend(QPainter& painter, QRectF rect) {
@@ -184,59 +188,56 @@ void TimelineWidget::setCurrentTime(std::string currentTime, double et) {
 void TimelineWidget::drawImages(
     QPainter& painter,
     QRectF timelineRect,
-    std::vector<Image>::const_iterator beginning,
-    std::vector<Image>::const_iterator ending,
+    std::vector<Image> images,
     double minimumTime, double maximumTime)
 {
     int width = timelineRect.width();
 
-    for (std::vector<Image>::const_iterator cur = beginning; cur < ending; ++cur) {
-        double tBeg = (cur->beginning - minimumTime) / (maximumTime - minimumTime);
+    int nInstruments = 0;
+    std::set<std::string> instrumentSet;
+    for (const Image& i : images) {
+        for (std::string instrument : i.instruments)
+            instrumentSet.insert(instrument);
+    }
+    std::map<std::string, int> instruments;
+    for (std::set<std::string>::const_iterator it = instrumentSet.begin(); it != instrumentSet.end(); ++it)
+        instruments[*it] = std::distance(instrumentSet.begin(), it);
+
+    for (const Image& i : images) {
+        double tBeg = (i.beginning - minimumTime) / (maximumTime - minimumTime);
         tBeg = std::max(tBeg, 0.0);
-        double tEnd = (cur->ending - minimumTime) / (maximumTime - minimumTime);
+        double tEnd = (i.ending - minimumTime) / (maximumTime - minimumTime);
         tEnd = std::min(tEnd, 1.0);
-        //double t = (cur->ending - minimumTime) / (maximumTime - minimumTime);
 
         int loc = timelineRect.top() + timelineRect.height() * tBeg;
         int height = (timelineRect.top() + timelineRect.height() * tEnd) - loc;
         height = std::max(height, 5);
 
-        std::string target = cur->target;
+        std::string target = i.target;
         auto it = std::find(_targets.begin(), _targets.end(), target);
         int iTarget = std::distance(_targets.begin(), it);
-        //QColor targetColor = targetColors[iTarget];
 
-        std::vector<std::string> instruments = cur->instruments;
-        std::vector<QColor> colors;
-        for (std::string instrument : instruments) {
+        //std::vector<QColor> colors;
+        for (std::string instrument : i.instruments) {
             auto it = std::find(_instruments.begin(), _instruments.end(), instrument);
+            if (it == _instruments.end())
+                qDebug() << "Instrument not found";
             int i = std::distance(_instruments.begin(), it);
-            colors.push_back(instrumentColors[i]);
-        }
 
-        //painter.setBrush(QBrush(targetColor));
-        if (colors.empty())
-            painter.setBrush(QBrush(Qt::black));
-        else
-            painter.setBrush(QBrush(colors[0]));
-        painter.drawRect(0, loc, timelineRect.width(), height);
+            painter.setBrush(QBrush(instrumentColors[i]));
+
+            double width = timelineRect.width() / instruments.size();
+            double pos = instruments[instrument] * width;
+
+            painter.drawRect(pos, loc, width, height);
+        }
 
         painter.setBrush(QBrush(Qt::black));
         painter.setPen(QPen(Qt::black));
-        //QString firstLine = QString::fromStdString(cur->beginningString);
-        //QString secondLine = QString::fromStdString(cur->target);
-        QString line = QString::fromStdString(cur->beginningString) + QString("(") + QString::fromStdString(cur->target) + QString(")");
+        QString line = QString::fromStdString(i.beginningString) + QString(" (") + QString::fromStdString(i.target) + QString(")");
 
         painter.drawText(timelineRect.width(), loc + height / 2 + TextOffset, line);
-
-        //painter.drawText(timelineRect.width(), loc + height / 2 - 1.5 * TextOffset, firstLine);
-        //painter.drawText(timelineRect.width(), loc + height / 2 + 1.5 * TextOffset, secondLine);
-
     }
-
-    painter.setPen(QPen(Qt::green));
-    int _tmp = timelineRect.top() + timelineRect.height() * 1.0;
-    painter.drawLine(QPointF(0, _tmp), QPointF(timelineRect.width(), _tmp));
 }
 
 void TimelineWidget::socketConnected() {
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index f658d4f3a3..6dcb437c7a 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -49,7 +49,7 @@ protected:
     void paintEvent(QPaintEvent* event);  
     void drawContent(QPainter& painter, QRectF rect);
     void drawLegend(QPainter& painter, QRectF rect);
-    void drawImages(QPainter& painter, QRectF timelineRect, std::vector<Image>::const_iterator beginning, std::vector<Image>::const_iterator ending, double minimumTime, double maximumTime);
+    void drawImages(QPainter& painter, QRectF timelineRect, std::vector<Image> images, double minimumTime, double maximumTime);
 
 private:
     std::vector<Image> _images;
diff --git a/src/util/hongkangparser.cpp b/src/util/hongkangparser.cpp
index 55802a7249..ae19165dc8 100644
--- a/src/util/hongkangparser.cpp
+++ b/src/util/hongkangparser.cpp
@@ -393,7 +393,7 @@ void HongKangParser::sendPlaybookInformation() {
             for (auto instrument : image.activeInstruments) {
                 if (instrumentMap.find(instrument) == instrumentMap.end()) {
                     instrumentMap[instrument] = currentInstrumentId;
-                    currentInstrumentId = currentInstrumentId  << 1;
+                    currentInstrumentId = currentInstrumentId << 1;
                 }
             }
         }
@@ -432,6 +432,10 @@ void HongKangParser::sendPlaybookInformation() {
             uint8_t targetId = targetMap[target.first];
             writeToBuffer(buffer, currentWriteLocation, targetId);
             uint16_t totalInstrumentId = 0;
+            if (image.activeInstruments.empty()) {
+                LERROR("Image had no active instruments");
+            }
+
             for (auto instrument : image.activeInstruments) {
                 uint16_t thisInstrumentId = instrumentMap[instrument];
                 totalInstrumentId |= thisInstrumentId;

From 2f5114fe2dc16d9ffae0cfcbfd8eadc32191d949 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 10:58:10 +0200
Subject: [PATCH 13/27] More changes in timelinegui; show images even if start
 time and end time are outside the viewing frame

---
 gui/timelineview/timelinewidget.cpp | 36 ++++++++++++++++++-----------
 gui/timelineview/timelinewidget.h   |  2 +-
 2 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/gui/timelineview/timelinewidget.cpp b/gui/timelineview/timelinewidget.cpp
index 92360afb22..d8f2b0c3e6 100644
--- a/gui/timelineview/timelinewidget.cpp
+++ b/gui/timelineview/timelinewidget.cpp
@@ -118,12 +118,20 @@ void TimelineWidget::drawContent(QPainter& painter, QRectF rect) {
 
     const double lowerTime = _currentTime.et - etSpread;
     const double upperTime = _currentTime.et + etSpread;
-    std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [](const Image& i, double time) { return i.beginning < time; });
-    std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _images.end(), upperTime, [](const Image& i, double time) { return i.ending < time; });
-    if (lower != _images.end() && upper != _images.end())
-        drawImages(painter, timelineRect, std::vector<Image>(lower, upper), lowerTime, upperTime);
+
+    std::vector<Image*> images;
+    for (Image& i : _images) {
+        if (i.beginning <= upperTime && i.ending >= lowerTime)
+            images.push_back(&i);
+    }
+
+
+    //std::vector<Image>::const_iterator lower = std::lower_bound(_images.begin(), _images.end(), lowerTime, [](const Image& i, double time) { return i.beginning < time; });
+    //std::vector<Image>::const_iterator upper = std::lower_bound(_images.begin(), _images.end(), upperTime, [](const Image& i, double time) { return i.ending < time; });
+    //if (lower != _images.end() && upper != _images.end())
+    //    drawImages(painter, timelineRect, std::vector<Image>(lower, upper), lowerTime, upperTime);
         
-    //drawImages(painter, timelineRect, _images, lowerTime, upperTime);
+    drawImages(painter, timelineRect, images, lowerTime, upperTime);
 
 
     // Draw current time
@@ -188,37 +196,37 @@ void TimelineWidget::setCurrentTime(std::string currentTime, double et) {
 void TimelineWidget::drawImages(
     QPainter& painter,
     QRectF timelineRect,
-    std::vector<Image> images,
+    std::vector<Image*> images,
     double minimumTime, double maximumTime)
 {
     int width = timelineRect.width();
 
     int nInstruments = 0;
     std::set<std::string> instrumentSet;
-    for (const Image& i : images) {
-        for (std::string instrument : i.instruments)
+    for (Image* i : images) {
+        for (std::string instrument : i->instruments)
             instrumentSet.insert(instrument);
     }
     std::map<std::string, int> instruments;
     for (std::set<std::string>::const_iterator it = instrumentSet.begin(); it != instrumentSet.end(); ++it)
         instruments[*it] = std::distance(instrumentSet.begin(), it);
 
-    for (const Image& i : images) {
-        double tBeg = (i.beginning - minimumTime) / (maximumTime - minimumTime);
+    for (Image* i : images) {
+        double tBeg = (i->beginning - minimumTime) / (maximumTime - minimumTime);
         tBeg = std::max(tBeg, 0.0);
-        double tEnd = (i.ending - minimumTime) / (maximumTime - minimumTime);
+        double tEnd = (i->ending - minimumTime) / (maximumTime - minimumTime);
         tEnd = std::min(tEnd, 1.0);
 
         int loc = timelineRect.top() + timelineRect.height() * tBeg;
         int height = (timelineRect.top() + timelineRect.height() * tEnd) - loc;
         height = std::max(height, 5);
 
-        std::string target = i.target;
+        std::string target = i->target;
         auto it = std::find(_targets.begin(), _targets.end(), target);
         int iTarget = std::distance(_targets.begin(), it);
 
         //std::vector<QColor> colors;
-        for (std::string instrument : i.instruments) {
+        for (std::string instrument : i->instruments) {
             auto it = std::find(_instruments.begin(), _instruments.end(), instrument);
             if (it == _instruments.end())
                 qDebug() << "Instrument not found";
@@ -234,7 +242,7 @@ void TimelineWidget::drawImages(
 
         painter.setBrush(QBrush(Qt::black));
         painter.setPen(QPen(Qt::black));
-        QString line = QString::fromStdString(i.beginningString) + QString(" (") + QString::fromStdString(i.target) + QString(")");
+        QString line = QString::fromStdString(i->beginningString) + QString(" (") + QString::fromStdString(i->target) + QString(")");
 
         painter.drawText(timelineRect.width(), loc + height / 2 + TextOffset, line);
     }
diff --git a/gui/timelineview/timelinewidget.h b/gui/timelineview/timelinewidget.h
index 6dcb437c7a..86ec18779d 100644
--- a/gui/timelineview/timelinewidget.h
+++ b/gui/timelineview/timelinewidget.h
@@ -49,7 +49,7 @@ protected:
     void paintEvent(QPaintEvent* event);  
     void drawContent(QPainter& painter, QRectF rect);
     void drawLegend(QPainter& painter, QRectF rect);
-    void drawImages(QPainter& painter, QRectF timelineRect, std::vector<Image> images, double minimumTime, double maximumTime);
+    void drawImages(QPainter& painter, QRectF timelineRect, std::vector<Image*> images, double minimumTime, double maximumTime);
 
 private:
     std::vector<Image> _images;

From 5b1ab8b69260728984d12ef17bf03e9710476d62 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 14:10:37 +0200
Subject: [PATCH 14/27] Fix crash when changing coordinate system origin to
 Pluto

---
 src/rendering/renderengine.cpp | 70 +++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index 931abeecfb..2a8bd2a963 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -979,7 +979,7 @@ void RenderEngine::changeViewPoint(std::string origin) {
 
     SceneGraphNode* jupiterBarycenterNode = scene()->sceneGraphNode("JupiterBarycenter");
 
-	SceneGraphNode* newHorizonsGhostNode = scene()->sceneGraphNode("NewHorizonsGhost");
+	//SceneGraphNode* newHorizonsGhostNode = scene()->sceneGraphNode("NewHorizonsGhost");
 	//SceneGraphNode* dawnNode = scene()->sceneGraphNode("Dawn");
 	//SceneGraphNode* vestaNode = scene()->sceneGraphNode("Vesta");
 
@@ -998,7 +998,7 @@ void RenderEngine::changeViewPoint(std::string origin) {
 		
 		solarSystemBarycenterNode->setParent(plutoBarycenterNode);
 		newHorizonsNode->setParent(plutoBarycenterNode);
-		newHorizonsGhostNode->setParent(plutoBarycenterNode);
+		//newHorizonsGhostNode->setParent(plutoBarycenterNode);
 
 		//dawnNode->setParent(plutoBarycenterNode);
 		//vestaNode->setParent(plutoBarycenterNode);
@@ -1058,16 +1058,16 @@ void RenderEngine::changeViewPoint(std::string origin) {
 		//vestaNode->setEphemeris(new SpiceEphemeris(vestaDictionary));
 
 		
-		ghoul::Dictionary newHorizonsGhostDictionary =
-		{
-			{ std::string("Type"), std::string("Spice") },
-			{ std::string("Body"), std::string("NEW HORIZONS") },
-			{ std::string("EphmerisGhosting"), std::string("TRUE") },
-			{ std::string("Reference"), std::string("GALACTIC") },
-			{ std::string("Observer"), std::string("PLUTO BARYCENTER") },
-			{ std::string("Kernels"), ghoul::Dictionary() }
-		};
-		newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
+		//ghoul::Dictionary newHorizonsGhostDictionary =
+		//{
+		//	{ std::string("Type"), std::string("Spice") },
+		//	{ std::string("Body"), std::string("NEW HORIZONS") },
+		//	{ std::string("EphmerisGhosting"), std::string("TRUE") },
+		//	{ std::string("Reference"), std::string("GALACTIC") },
+		//	{ std::string("Observer"), std::string("PLUTO BARYCENTER") },
+		//	{ std::string("Kernels"), ghoul::Dictionary() }
+		//};
+		//newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
 		
         return;
     }
@@ -1077,7 +1077,7 @@ void RenderEngine::changeViewPoint(std::string origin) {
 		plutoBarycenterNode->setParent(solarSystemBarycenterNode);
 		jupiterBarycenterNode->setParent(solarSystemBarycenterNode);
 		newHorizonsNode->setParent(solarSystemBarycenterNode);
-		newHorizonsGhostNode->setParent(solarSystemBarycenterNode);
+		//newHorizonsGhostNode->setParent(solarSystemBarycenterNode);
 
 		//newHorizonsTrailNode->setParent(solarSystemBarycenterNode);
 		//dawnNode->setParent(solarSystemBarycenterNode);
@@ -1137,16 +1137,16 @@ void RenderEngine::changeViewPoint(std::string origin) {
 		//vestaNode->setEphemeris(new SpiceEphemeris(vestaDictionary));
 		
 		
-		ghoul::Dictionary newHorizonsGhostDictionary =
-		{
-			{ std::string("Type"), std::string("Spice") },
-			{ std::string("Body"), std::string("NEW HORIZONS") },
-			{ std::string("EphmerisGhosting"), std::string("TRUE") },
-			{ std::string("Reference"), std::string("GALACTIC") },
-			{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-			{ std::string("Kernels"), ghoul::Dictionary() }
-		};
-		newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
+		//ghoul::Dictionary newHorizonsGhostDictionary =
+		//{
+		//	{ std::string("Type"), std::string("Spice") },
+		//	{ std::string("Body"), std::string("NEW HORIZONS") },
+		//	{ std::string("EphmerisGhosting"), std::string("TRUE") },
+		//	{ std::string("Reference"), std::string("GALACTIC") },
+		//	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
+		//	{ std::string("Kernels"), ghoul::Dictionary() }
+		//};
+		//newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
 		
         return;
     }
@@ -1191,7 +1191,7 @@ void RenderEngine::changeViewPoint(std::string origin) {
 		solarSystemBarycenterNode->setEphemeris(new SpiceEphemeris(solarDictionary));
 		plutoBarycenterNode->setEphemeris(new SpiceEphemeris(plutoDictionary));
 		newHorizonsNode->setEphemeris(new SpiceEphemeris(newHorizonsDictionary));
-		newHorizonsGhostNode->setParent(jupiterBarycenterNode);
+		//newHorizonsGhostNode->setParent(jupiterBarycenterNode);
 		//newHorizonsTrailNode->setEphemeris(new SpiceEphemeris(newHorizonsDictionary));
 
 
@@ -1217,17 +1217,17 @@ void RenderEngine::changeViewPoint(std::string origin) {
 
 
 		
-		ghoul::Dictionary newHorizonsGhostDictionary =
-		{
-			{ std::string("Type"), std::string("Spice") },
-			{ std::string("Body"), std::string("NEW HORIZONS") },
-			{ std::string("EphmerisGhosting"), std::string("TRUE") },
-			{ std::string("Reference"), std::string("GALACTIC") },
-			{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-			{ std::string("Kernels"), ghoul::Dictionary() }
-		};
-		newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
-		newHorizonsGhostNode->setParent(jupiterBarycenterNode);
+		//ghoul::Dictionary newHorizonsGhostDictionary =
+		//{
+		//	{ std::string("Type"), std::string("Spice") },
+		//	{ std::string("Body"), std::string("NEW HORIZONS") },
+		//	{ std::string("EphmerisGhosting"), std::string("TRUE") },
+		//	{ std::string("Reference"), std::string("GALACTIC") },
+		//	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
+		//	{ std::string("Kernels"), ghoul::Dictionary() }
+		//};
+		//newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
+		//newHorizonsGhostNode->setParent(jupiterBarycenterNode);
 
 	
         return;

From 47af7a52707bd703b6fc20d80157bb60f85e1a3b Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 14:37:24 +0200
Subject: [PATCH 15/27] Disabling the GUI applications on default, added
 possibility to enable them with a switch Added additional check into the
 model loader to guard against empty models

---
 CMakeLists.txt                        | 6 +++++-
 src/rendering/model/modelgeometry.cpp | 5 +++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e3bbab74eb..8a02ab368c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -145,7 +145,11 @@ endif ()
 #########################################################################################
 
 add_subdirectory(src)
-add_subdirectory(gui)
+
+option(BUILD_GUI_APPLICATIONS "Build GUI Applications" OFF)
+if (BUILD_GUI_APPLICATIONS)
+    add_subdirectory(gui)
+endif ()
 
 #########################################################################################
 # File Fetch
diff --git a/src/rendering/model/modelgeometry.cpp b/src/rendering/model/modelgeometry.cpp
index a1e955988c..6905b0c9f1 100644
--- a/src/rendering/model/modelgeometry.cpp
+++ b/src/rendering/model/modelgeometry.cpp
@@ -206,6 +206,11 @@ bool ModelGeometry::loadCachedFile(const std::string& filename) {
 			fileStream.read(reinterpret_cast<char*>(&vSize), sizeof(int64_t));
 			fileStream.read(reinterpret_cast<char*>(&iSize), sizeof(int64_t));
 
+            if (vSize == 0 || iSize == 0) {
+                LERROR("Error opening file '" << filename << "' for loading cache file");
+                return false;
+            }
+
 			_vertices.resize(vSize);
 			_indices.resize(iSize);
 

From 4b9c5a9de6d0b3069dc09d05c77424b915fef714 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 14:40:47 +0200
Subject: [PATCH 16/27] Linux compile fix with ImageSequencer2

---
 include/openspace/util/imagesequencer2.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/openspace/util/imagesequencer2.h b/include/openspace/util/imagesequencer2.h
index f78674b9c1..184d121139 100644
--- a/include/openspace/util/imagesequencer2.h
+++ b/include/openspace/util/imagesequencer2.h
@@ -122,11 +122,11 @@ public:
 	 * makes the request. If an instance is not registered in the class then the singleton
 	 * returns false and no projections will occur. 
 	 */
-	bool ImageSequencer2::getImagePaths(std::vector<Image>& captures, 
+	bool getImagePaths(std::vector<Image>& captures, 
 		                                std::string projectee, 
 										std::string instrumentID);
 
-	bool ImageSequencer2::getImagePaths(std::vector<Image>& captures,
+	bool getImagePaths(std::vector<Image>& captures,
 		                                std::string projectee);
 
 	/*

From b79acb1501d5f36defa5bc465483d746c2a7aa08 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 15:45:00 +0200
Subject: [PATCH 17/27] Fixing variable names to fix linux compile error

---
 src/rendering/renderengine.cpp | 64 ++++++++++++++++++----------------
 1 file changed, 34 insertions(+), 30 deletions(-)

diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index 2a8bd2a963..e0339e503a 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -190,7 +190,7 @@ namespace openspace {
 
 			double t = luaL_checknumber(L, -1);
 			
-			OsEng.renderEngine()->startFading(1, t);
+			OsEng.renderEngine()->startFading(1, static_cast<float>(t));
 			return 0;
 		}
 		/**
@@ -205,7 +205,7 @@ namespace openspace {
 
 			double t = luaL_checknumber(L, -1);
 
-			OsEng.renderEngine()->startFading(-1, t);
+			OsEng.renderEngine()->startFading(-1, static_cast<float>(t));
 			return 0;
 		}
 
@@ -494,8 +494,8 @@ namespace openspace {
             }
 
 #if 1
-#define PrintText(i, format, ...) Freetype::print(font, 10.f, static_cast<float>(startY - font_size_mono * i * 2), format, __VA_ARGS__);
-#define PrintColorText(i, format, size, color, ...) Freetype::print(font, size, static_cast<float>(startY - font_size_mono * i * 2), color, format, __VA_ARGS__);
+#define PrintText(__i__, __format__, ...) Freetype::print(font, 10.f, static_cast<float>(startY - font_size_mono * __i__ * 2), __format__, __VA_ARGS__);
+#define PrintColorText(__i__, __format__, __size__, __color__, ...) Freetype::print(font, __size__, static_cast<float>(startY - font_size_mono * __i__ * 2), __color__, __format__, __VA_ARGS__);
 
             if (_onScreenInformation._node != -1) {
                 int thisId = sgct_core::ClusterManager::instance()->getThisNodeId();
@@ -536,13 +536,13 @@ namespace openspace {
 					// GUI PRINT 
 					// Using a macro to shorten line length and increase readability
 
-                    int i = 0;
+                    int line = 0;
 			
-					PrintText(i++, "Date: %s", Time::ref().currentTimeUTC().c_str());
+					PrintText(line++, "Date: %s", Time::ref().currentTimeUTC().c_str());
 				
-					PrintText(i++, "Avg. Frametime: %.5f", sgct::Engine::instance()->getAvgDt());
-					PrintText(i++, "Drawtime:       %.5f", sgct::Engine::instance()->getDrawTime());
-					PrintText(i++, "Frametime:      %.5f", sgct::Engine::instance()->getDt());
+					PrintText(line++, "Avg. Frametime: %.5f", sgct::Engine::instance()->getAvgDt());
+					PrintText(line++, "Drawtime:       %.5f", sgct::Engine::instance()->getDrawTime());
+					PrintText(line++, "Frametime:      %.5f", sgct::Engine::instance()->getDt());
 					/*
 					PrintText(i++, "Origin:         (% .5f, % .5f, % .5f, % .5f)", origin[0], origin[1], origin[2], origin[3]);
 					PrintText(i++, "Cam pos:        (% .5f, % .5f, % .5f, % .5f)", position[0], position[1], position[2], position[3]);
@@ -556,8 +556,11 @@ namespace openspace {
 						double t = 1.f - remaining / openspace::ImageSequencer2::ref().getIntervalLength();
 						std::string progress = "|";
 						int g = ((t)* 30) + 1;
-						for (int i = 0; i < g; i++)      progress.append("-"); progress.append(">");
-						for (int i = 0; i < 31 - g; i++) progress.append(" ");
+						for (int i = 0; i < g; i++)
+                            progress.append("-");
+                        progress.append(">");
+						for (int i = 0; i < 31 - g; i++)
+                            progress.append(" ");
 
 						std::string str = "";
 						openspace::SpiceManager::ref().getDateFromET(openspace::ImageSequencer2::ref().getNextCaptureTime(), str);
@@ -566,11 +569,11 @@ namespace openspace {
 						if (remaining > 0){
 							glm::vec4 g1(0, t, 0, 1);
 							glm::vec4 g2(1 - t);
-							PrintColorText(i++, "Next projection in:", 10, g1 + g2);
-							PrintColorText(i++, "%.0f sec %s %.1f %%", 10, g1 + g2, remaining, progress.c_str(), t * 100);
+							PrintColorText(line++, "Next projection in:", 10, g1 + g2);
+							PrintColorText(line++, "%.0f sec %s %.1f %%", 10, g1 + g2, remaining, progress.c_str(), t * 100);
 						}
 						glm::vec4 w(1);
-						PrintColorText(i++, "Ucoming capture : %s", 10, w, str.c_str());
+						PrintColorText(line++, "Ucoming capture : %s", 10, w, str.c_str());
 				
 						std::pair<double, std::string> nextTarget = ImageSequencer2::ref().getNextTarget();
    					    std::pair<double, std::string> currentTarget = ImageSequencer2::ref().getCurrentTarget();
@@ -595,39 +598,40 @@ namespace openspace {
 
 
 						    glm::vec4 b2(1.00, 0.51, 0.00, 1);
-						    PrintColorText(i++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
+						    PrintColorText(line++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
 						
 						    std::pair<double, std::vector<std::string>> incidentTargets = ImageSequencer2::ref().getIncidentTargetList(2);
 						    std::string space;
 						    glm::vec4 color;
 						    int isize = incidentTargets.second.size(); 
-							    for (int p = 0; p < isize; p++){
-								    double t = (double)(p + 1) / (double)(isize+1);
-								    t = (p > isize / 2) ? 1-t : t;
-								    t += 0.3;
-								    color = (p == isize / 2) ? glm::vec4(1.00, 0.51, 0.00, 1) : glm::vec4(t, t, t, 1);
-								    PrintColorText(i, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
-							    for (int k = 0; k < 10; k++){ space += " "; }
+                            for (int p = 0; p < isize; p++){
+                                double t = (double)(p + 1) / (double)(isize + 1);
+                                t = (p > isize / 2) ? 1 - t : t;
+                                t += 0.3;
+                                color = (p == isize / 2) ? glm::vec4(1.00, 0.51, 0.00, 1) : glm::vec4(t, t, t, 1);
+                                PrintColorText(line, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
+                                for (int k = 0; k < 10; k++)
+                                    space += " ";
 						    }
-						    i++;
+						    line++;
 					
 						    std::map<std::string, bool> activeMap = ImageSequencer2::ref().getActiveInstruments();
 						    glm::vec4 active(0.58, 1, 0.00, 1);
 						    glm::vec4 firing(0.58-t, 1-t, 1-t, 1);
 						    glm::vec4 notFiring(0.5, 0.5, 0.5, 1);
-						    PrintColorText(i++, "Active Instruments : ", 10, active);
+						    PrintColorText(line++, "Active Instruments : ", 10, active);
 						    for (auto t : activeMap){
 							    if (t.second == false){
-								    PrintColorText(i, "| |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								    PrintColorText(i++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), t.first.c_str());
+								    PrintColorText(line, "| |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+								    PrintColorText(line++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), t.first.c_str());
 							    }
 							    else{
-								    PrintColorText(i, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+								    PrintColorText(line, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
 								    if (t.first == "NH_LORRI"){
-									    PrintColorText(i, " + ", 10, firing);
+									    PrintColorText(line, " + ", 10, firing);
 								    }
-								    PrintColorText(i, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								    PrintColorText(i++, "    %5s", 10, active, t.first.c_str());
+								    PrintColorText(line, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
+								    PrintColorText(line++, "    %5s", 10, active, t.first.c_str());
 							    }
 						    }
                         }

From 335571879d5ae12e78036e51abc69ba5659dcaba Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 15:56:10 +0200
Subject: [PATCH 18/27] Fixing bug in linux with va_arg macros

---
 src/rendering/renderengine.cpp | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index e0339e503a..52b409a1ce 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -495,7 +495,8 @@ namespace openspace {
 
 #if 1
 #define PrintText(__i__, __format__, ...) Freetype::print(font, 10.f, static_cast<float>(startY - font_size_mono * __i__ * 2), __format__, __VA_ARGS__);
-#define PrintColorText(__i__, __format__, __size__, __color__, ...) Freetype::print(font, __size__, static_cast<float>(startY - font_size_mono * __i__ * 2), __color__, __format__, __VA_ARGS__);
+#define PrintColorTextArg(__i__, __format__, __size__, __color__, ...) Freetype::print(font, __size__, static_cast<float>(startY - font_size_mono * __i__ * 2), __color__, __format__, __VA_ARGS__);
+#define PrintColorText(__i__, __format__, __size__, __color__) Freetype::print(font, __size__, static_cast<float>(startY - font_size_mono * __i__ * 2), __color__, __format__);
 
             if (_onScreenInformation._node != -1) {
                 int thisId = sgct_core::ClusterManager::instance()->getThisNodeId();
@@ -570,10 +571,10 @@ namespace openspace {
 							glm::vec4 g1(0, t, 0, 1);
 							glm::vec4 g2(1 - t);
 							PrintColorText(line++, "Next projection in:", 10, g1 + g2);
-							PrintColorText(line++, "%.0f sec %s %.1f %%", 10, g1 + g2, remaining, progress.c_str(), t * 100);
+							PrintColorTextArg(line++, "%.0f sec %s %.1f %%", 10, g1 + g2, remaining, progress.c_str(), t * 100);
 						}
 						glm::vec4 w(1);
-						PrintColorText(line++, "Ucoming capture : %s", 10, w, str.c_str());
+						PrintColorTextArg(line++, "Ucoming capture : %s", 10, w, str.c_str());
 				
 						std::pair<double, std::string> nextTarget = ImageSequencer2::ref().getNextTarget();
    					    std::pair<double, std::string> currentTarget = ImageSequencer2::ref().getCurrentTarget();
@@ -598,7 +599,7 @@ namespace openspace {
 
 
 						    glm::vec4 b2(1.00, 0.51, 0.00, 1);
-						    PrintColorText(line++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
+						    PrintColorTextArg(line++, "Switching observation focus in : [%s:%s:%s]", 10, b2, hh.c_str(), mm.c_str(), ss.c_str());
 						
 						    std::pair<double, std::vector<std::string>> incidentTargets = ImageSequencer2::ref().getIncidentTargetList(2);
 						    std::string space;
@@ -609,7 +610,7 @@ namespace openspace {
                                 t = (p > isize / 2) ? 1 - t : t;
                                 t += 0.3;
                                 color = (p == isize / 2) ? glm::vec4(1.00, 0.51, 0.00, 1) : glm::vec4(t, t, t, 1);
-                                PrintColorText(line, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
+                                PrintColorTextArg(line, "%s%s", 10, color, space.c_str(), incidentTargets.second[p].c_str());
                                 for (int k = 0; k < 10; k++)
                                     space += " ";
 						    }
@@ -623,15 +624,15 @@ namespace openspace {
 						    for (auto t : activeMap){
 							    if (t.second == false){
 								    PrintColorText(line, "| |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								    PrintColorText(line++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), t.first.c_str());
+								    PrintColorTextArg(line++, "    %5s", 10, glm::vec4(0.3, 0.3, 0.3, 1), t.first.c_str());
 							    }
 							    else{
 								    PrintColorText(line, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
 								    if (t.first == "NH_LORRI"){
-									    PrintColorText(line, " + ", 10, firing);
+									    PrintColorTextArg(line, " + ", 10, firing);
 								    }
 								    PrintColorText(line, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
-								    PrintColorText(line++, "    %5s", 10, active, t.first.c_str());
+								    PrintColorTextArg(line++, "    %5s", 10, active, t.first.c_str());
 							    }
 						    }
                         }

From b458e6c0f9ae7255b2f6c72117ee093e34def091 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:12:24 +0200
Subject: [PATCH 19/27] Yet another linux fix

---
 src/rendering/renderengine.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index 52b409a1ce..f57d13486f 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -629,7 +629,7 @@ namespace openspace {
 							    else{
 								    PrintColorText(line, "|", 10, glm::vec4(0.3, 0.3, 0.3, 1));
 								    if (t.first == "NH_LORRI"){
-									    PrintColorTextArg(line, " + ", 10, firing);
+									    PrintColorText(line, " + ", 10, firing);
 								    }
 								    PrintColorText(line, "  |", 10, glm::vec4(0.3, 0.3, 0.3, 1));
 								    PrintColorTextArg(line++, "    %5s", 10, active, t.first.c_str());

From 0d11e6e2f8dc8838d0fd19d66ece1323572e2b39 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:23:41 +0200
Subject: [PATCH 20/27] Fixing issue with linux

---
 include/openspace/util/hongkangparser.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/openspace/util/hongkangparser.h b/include/openspace/util/hongkangparser.h
index ca1eccf68d..e29f2e4c4a 100644
--- a/include/openspace/util/hongkangparser.h
+++ b/include/openspace/util/hongkangparser.h
@@ -25,7 +25,7 @@
 
 #ifndef __HONGKANGPARSER_H__
 #define __HONGKANGPARSER_H__
-#include <openspace/util/ImageSequencer2.h>
+#include <openspace/util/imagesequencer2.h>
 #include <openspace/util/sequenceparser.h>
 
 #include <map>

From dfca3152930820ad62c5865b67f8f197eeb797bc Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:29:12 +0200
Subject: [PATCH 21/27] Fixing issue with linux

---
 src/util/labelparser.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util/labelparser.cpp b/src/util/labelparser.cpp
index 7ea41621d8..a6816e8584 100644
--- a/src/util/labelparser.cpp
+++ b/src/util/labelparser.cpp
@@ -22,7 +22,7 @@
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
 ****************************************************************************************/
 
-#include <openspace/util/ImageSequencer2.h>
+#include <openspace/util/imagesequencer2.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>

From e33c250bfc6a20537657346d183b8aa189f12668 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:33:48 +0200
Subject: [PATCH 22/27] Fixing issue with linux

---
 include/openspace/util/labelparser.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/include/openspace/util/labelparser.h b/include/openspace/util/labelparser.h
index cea2dce8aa..bfdf65ca7d 100644
--- a/include/openspace/util/labelparser.h
+++ b/include/openspace/util/labelparser.h
@@ -22,10 +22,9 @@
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
 ****************************************************************************************/
 
-
 #ifndef __LABELPARSER_H__
 #define __LABELPARSER_H__
-#include <openspace/util/ImageSequencer2.h>
+#include <openspace/util/imagesequencer2.h>
 #include <openspace/util/sequenceparser.h>
 
 #include <map>

From b35edde94a1adbe9bc81f1cc0a543b296bca8bf2 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:40:01 +0200
Subject: [PATCH 23/27] Fixing issue with linux

---
 src/util/hongkangparser.cpp | 2 +-
 src/util/labelparser.cpp    | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/util/hongkangparser.cpp b/src/util/hongkangparser.cpp
index 2f69f15adb..faac6a8e57 100644
--- a/src/util/hongkangparser.cpp
+++ b/src/util/hongkangparser.cpp
@@ -22,7 +22,7 @@
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
 ****************************************************************************************/
 
-#include <openspace/util/ImageSequencer2.h>
+#include <openspace/util/imagesequencer2.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>
diff --git a/src/util/labelparser.cpp b/src/util/labelparser.cpp
index a6816e8584..cf14549fc9 100644
--- a/src/util/labelparser.cpp
+++ b/src/util/labelparser.cpp
@@ -22,7 +22,6 @@
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                                         *
 ****************************************************************************************/
 
-#include <openspace/util/imagesequencer2.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>

From 23a39502154c5ac580fddde2aed1626fc06454c2 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:46:51 +0200
Subject: [PATCH 24/27] Fixing issue with linux

---
 src/util/imagesequencer2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util/imagesequencer2.cpp b/src/util/imagesequencer2.cpp
index d324f5ef29..65a562e5b5 100644
--- a/src/util/imagesequencer2.cpp
+++ b/src/util/imagesequencer2.cpp
@@ -23,7 +23,7 @@
 ****************************************************************************************/
 
 // open space includes
-#include <openspace/util/ImageSequencer2.h>
+#include <openspace/util/imagesequencer2.h>
 #include <ghoul/logging/logmanager.h>
 #include <ghoul/filesystem/filesystem.h>
 #include <ghoul/filesystem/directory.h>

From 02eaf6e7b9572b3fb232ef8ca253d5b70e26f27b Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 17:57:18 +0200
Subject: [PATCH 25/27] Replaced asserts with ghoul_asserts

---
 src/util/imagesequencer2.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/util/imagesequencer2.cpp b/src/util/imagesequencer2.cpp
index 65a562e5b5..446cd20bf0 100644
--- a/src/util/imagesequencer2.cpp
+++ b/src/util/imagesequencer2.cpp
@@ -282,11 +282,11 @@ void ImageSequencer2::runSequenceParser(SequenceParser* parser){
 	std::vector<double>                            in5 = parser->getCaptureProgression();
 	
 	// check for sanity
-	assert(in1.size() > 0, "Sequencer failed to load Translation"                  );
-	assert(in2.size() > 0, "Sequencer failed to load Image data"                   );
-	assert(in3.size() > 0, "Sequencer failed to load Instrument Switching schedule");
-	assert(in4.size() > 0, "Sequencer failed to load Target Switching schedule"    );
-	assert(in5.size() > 0, "Sequencer failed to load Capture progression"          );
+	ghoul_assert(in1.size() > 0, "Sequencer failed to load Translation"                  );
+	ghoul_assert(in2.size() > 0, "Sequencer failed to load Image data"                   );
+	ghoul_assert(in3.size() > 0, "Sequencer failed to load Instrument Switching schedule");
+	ghoul_assert(in4.size() > 0, "Sequencer failed to load Target Switching schedule"    );
+	ghoul_assert(in5.size() > 0, "Sequencer failed to load Capture progression"          );
 
 
 	// append data

From 33bc1733b6354b05356bebb6e8b9999b2f3bb030 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 19:41:31 +0200
Subject: [PATCH 26/27] Make time control in timeline view non-linear

---
 gui/timelineview/controlwidget.cpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/gui/timelineview/controlwidget.cpp b/gui/timelineview/controlwidget.cpp
index 1bd65f0c7c..ad53a9903e 100644
--- a/gui/timelineview/controlwidget.cpp
+++ b/gui/timelineview/controlwidget.cpp
@@ -40,6 +40,7 @@ namespace {
 
     const ImportantDate ImportantDates[] = {
         { "2007-02-27T16:40:00.00", "JupiterProjection", "Jupiter" },
+        { "2015-07-14T10:10:00.00", "PlutoProjection", "Pluto" },
         { "2015-07-14T10:50:00.00", "PlutoProjection", "Pluto" },
         { "2015-07-14T11:22:00.00", "PlutoProjection", "Pluto" },
         { "2015-07-14T11:36:40.00", "PlutoProjection", "Pluto" },
@@ -59,7 +60,10 @@ namespace {
         { "Pluto", "PlutoProjection", "Pluto" },
         { "Charon", "Charon", "Pluto" },
         { "Jupiter", "JupiterProjection", "Jupiter" },
-        { "New Horizons", "NewHorizons", ""}
+        { "New Horizons", "NewHorizons", "" },
+        { "Nix", "Nix", "Pluto" },
+        { "Kerberos", "Kerberos", "Pluto" },
+        { "Hydra", "Hydra", "Pluto" },
     };
 }
 
@@ -158,7 +162,20 @@ void ControlWidget::update(QString currentTime, QString currentDelta) {
 }
 
 void ControlWidget::onValueChange() {
-    QString script = "openspace.time.setDeltaTime(" + QString::number(_setDelta->value()) + ");";
+    float value = static_cast<float>(_setDelta->value());
+
+    int delta;
+    if (value < 0.f) {
+        value = -value;
+        float d = std::pow(2, value / 10);
+        delta = static_cast<int>(-d);
+    }
+    else {
+        float d = std::pow(2, value / 10);
+        delta = static_cast<int>(d);
+    }
+    
+    QString script = "openspace.time.setDeltaTime(" + QString::number(delta) + ");";
     emit scriptActivity(script);
 }
 

From 9150e52327017b540d5e00bfe6af36d8bc0820f9 Mon Sep 17 00:00:00 2001
From: Alexander Bock <alexander.bock@liu.se>
Date: Tue, 5 May 2015 19:43:54 +0200
Subject: [PATCH 27/27] Updated openspace-data

---
 openspace-data | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/openspace-data b/openspace-data
index 16dbd84e5c..739c807fed 160000
--- a/openspace-data
+++ b/openspace-data
@@ -1 +1 @@
-Subproject commit 16dbd84e5c11116339d2071a49f4a473577a0dad
+Subproject commit 739c807fedf857bd63222d52f34e8ef5a68fe413