Added more features

Author: cx0onl

AnnotatorService.cpp

@@ -10,41 +10,58 @@ AnnotatorService::AnnotatorService(IUnoPluginController& controller, DataService
 
 void AnnotatorService::AnnotatorProcess(std::vector<IUnoAnnotatorItem>& items)
 {
+	auto selected = m_dataService.getSelectedMarker();
+
 	int y = 0;
-	for (const marker::marker_t& marker : m_markers)
+	for (const marker::marker_t& current : m_markers)
 	{
-		IUnoAnnotatorItem* item = new IUnoAnnotatorItem();
-		item->frequency = marker.frequency;
-		item->text = " " + marker.name;
+		items.push_back(*makeAnnotation(current, y++, selected.lid == current.lid));
+		y %= 6;
+	}
 
-		if (marker.type < 8) {
-			item->style = IUnoAnnotatorStyle::AnnotatorStyleFlag;
-			item->power = -40 - (y++ * 6);
-		}
-		else
-		{
+	if (selected.lid > 0 && !selected.show) {
+		items.push_back(*makeAnnotation(selected, y++, true));
+	}
+}
+
+IUnoAnnotatorItem* AnnotatorService::makeAnnotation(marker::marker_t marker, int y, bool selected)
+{
+	auto types = m_dataService.GetTypeSettings();
+
+	IUnoAnnotatorItem* item = new IUnoAnnotatorItem();
+	item->frequency = marker.frequency;
+	item->text = " " + marker.name;
+
+	if (marker.type < 8) {
+		if (selected) 
 			item->style = IUnoAnnotatorStyle::AnnotatorStyleMarkerAndLine;
-			item->lineToFreq = item->frequency;
-			item->power = -30;
-			item->lineToPower = -160;
-		}
-		
-		item->rgb = marker::type_colors[marker.type];
-		items.push_back(*item);
-		y %= 6;
+		else
+			item->style = IUnoAnnotatorStyle::AnnotatorStyleFlag;
+		item->power = -40 - (y++ * 6);
+	}
+	else
+	{
+		item->style = IUnoAnnotatorStyle::AnnotatorStyleMarkerAndLine;
+		item->lineToFreq = item->frequency;
+		item->power = -30;
+		item->lineToPower = -160;
 	}
+
+	item->rgb = types[marker.type].color;
+
+	return item;
 }
 
 void AnnotatorService::UpdateMarkers()
 {
-	std::vector<marker::marker_t> markers;
+	std::set<marker::marker_t> markers;
 	long offset = 10000000;
 
 	do {
 		markers.clear();
 		for (channel_t channel = 0; channel < m_controller.GetVRXCount(); channel++) {
 			auto channelMarkers = m_dataService.GetMarkers(m_controller.GetVfoFrequency(channel), offset, true);
-			markers.insert(markers.end(), channelMarkers.begin(), channelMarkers.end());
+			markers.insert(channelMarkers.begin(), channelMarkers.end());
 		}
 		offset -= (offset / 10);
 	} while (markers.size() > 64);

AnnotatorService.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <vector>
+#include <set>
 
 #include <iunoplugincontroller.h>
 #include <iunoannotator.h>
@@ -17,6 +17,8 @@ class AnnotatorService : public IUnoAnnotator
 private:
 	IUnoPluginController& m_controller;
 	DataService& m_dataService;
-	std::vector<marker::marker_t> m_markers;
+	std::set<marker::marker_t> m_markers;
+
+	IUnoAnnotatorItem* makeAnnotation(marker::marker_t marker, int y, bool selected = false);
 };
 

DataService.cpp

@@ -7,13 +7,12 @@
 #include <iomanip>
 
 
-inline bool operator<(const marker::marker_t& a, const marker::marker_t& b) {
-	return a.frequency != b.frequency || a.name != b.name;
-}
-
 DataService::DataService(IUnoPluginController& controller) :
 	m_controller(controller),
 	m_remoteAdapter(),
+	m_selectedMarker(),
+	m_typeSettings(),
+	m_vfoOffset(0),
 	m_oid(0)
 {
 	HMODULE hModule = GetModuleHandle(L"SDRunoPlugin_CloudMarkers");
@@ -106,6 +105,18 @@ void DataService::Init()
 
 	if (m_oid == 0)
 		m_oid = 1000; // 1000 = Anonymous
+
+	m_typeSettings[0].hex_color(getConfig("ColorUnknown"), 0xd94545);
+	m_typeSettings[1].hex_color(getConfig("ColorTimesignal"), 0xcccccc);
+	m_typeSettings[2].hex_color(getConfig("ColorMorse"), 0xb12eb3);
+	m_typeSettings[3].hex_color(getConfig("ColorDigimode"), 0xcfaa32);
+	m_typeSettings[4].hex_color(getConfig("ColorVoice"), 0x247fc9);
+	m_typeSettings[5].hex_color(getConfig("ColorBroadcast"), 0x2cb838);
+	m_typeSettings[6].hex_color(getConfig("ColorNoise"), 0x777777);
+	m_typeSettings[7].hex_color(getConfig("ColorNoise"), 0x777777);
+	m_typeSettings[8].hex_color(getConfig("ColorBandmarker"), 0xf0d52b);
+
+	m_vfoOffset = getConfigInt("VfoOffset", 10);
 }
 
 int DataService::GetMyOid()
@@ -434,19 +445,27 @@ int DataService::GetMarkerCount()
 	return count;
 }
 
-void DataService::SyncMarkers()
+void DataService::SyncMarkers(std::function<void(bool download, int progress) > progressHandler)
 {
 	auto syncinfo = GetLastSync();
 	int lastCommit = std::stoi(syncinfo.commit);
 
 	std::string commit = syncinfo.commit;
-	std::string count = syncinfo.count;
+	std::string count = "0";
 	std::string time = sync::currentDateTime();
 
-	auto syncresult = m_remoteAdapter.Get(lastCommit, m_oid);
+	auto syncresult = m_remoteAdapter.Get(lastCommit, m_oid, [&](uint64_t c, uint64_t t) {
+		progressHandler(true, c * 100 / t);
+		return true;
+	});
+
+	progressHandler(true, 100);
 
 	if (syncresult.commit > lastCommit && syncresult.items.size() > 0)
 	{
+		int t = syncresult.items.size();
+		int c = 0;
+
 		commit = std::to_string(syncresult.commit);
 		count = std::to_string(syncresult.items.size());
 
@@ -460,9 +479,13 @@ void DataService::SyncMarkers()
 
 			if (item.action == "UPDATE")
 				updateSyncedMarker(item.marker);
+
+			progressHandler(false, ++c * 100 / t);
 		}
 	}
 
+	progressHandler(false, 100);
+
 	sqlite3_stmt* statement;
 	int rc = sqlite3_prepare(m_database, "INSERT OR REPLACE INTO config (key, value1, value2, value3) VALUES ('LAST_SYNC', ?, ?, ?);", -1, &statement, 0);
 	if (rc == SQLITE_OK)
@@ -476,4 +499,90 @@ void DataService::SyncMarkers()
 	}
 
 	m_dataChangedCallback();
+}
+
+void DataService::setSelectedMarker(marker::marker_t marker)
+{
+	m_selectedMarker = marker;
+}
+marker::marker_t DataService::getSelectedMarker()
+{
+	return m_selectedMarker;
+}
+
+std::string DataService::getConfig(std::string key)
+{
+	std::string value;
+	m_controller.GetConfigurationKey("CloudMarker." + key, value);
+	return value;
+}
+
+void DataService::setConfig(std::string key, std::string value)
+{
+	m_controller.SetConfigurationKey("CloudMarker." + key, value);
+}
+
+int DataService::getConfigInt(std::string key, int defaultValue)
+{
+	try {
+		return std::stoi(getConfig(key));
+	}
+	catch(...)
+	{
+		return defaultValue;
+	}
+}
+void DataService::setConfigInt(std::string key, int value)
+{
+	setConfig(key, std::to_string(value));
+}
+
+settings::types_t DataService::GetTypeSettings()
+{
+	return m_typeSettings;
+}
+
+void DataService::SetTypeSettings(settings::types_t types)
+{
+	m_typeSettings = types;
+
+	setConfig("ColorUnknown", m_typeSettings[0].hex_color());
+	setConfig("ColorTimesignal", m_typeSettings[1].hex_color());
+	setConfig("ColorMorse", m_typeSettings[2].hex_color());
+	setConfig("ColorDigimode", m_typeSettings[3].hex_color());
+	setConfig("ColorVoice", m_typeSettings[4].hex_color());
+	setConfig("ColorBroadcast", m_typeSettings[5].hex_color());
+	setConfig("ColorNoise", m_typeSettings[6].hex_color());
+	setConfig("ColorBandmarker", m_typeSettings[8].hex_color());
+
+	m_dataChangedCallback();
+}
+
+void DataService::SaveWindowPos(channel_t channel, nana::point point)
+{
+	setConfigInt("Window" + std::to_string(channel) + "PosX", point.x);
+	setConfigInt("Window" + std::to_string(channel) + "PosY", point.y);
+}
+
+nana::point DataService::LoadWindowPos(channel_t channel)
+{
+	int x = getConfigInt("Window" + std::to_string(channel) + "PosX", -1);
+	int y = getConfigInt("Window" + std::to_string(channel) + "PosY", -1);
+	return nana::point(x, y);
+}
+
+int DataService::GetVfoOffset() {
+	return m_vfoOffset;
+}
+
+void DataService::SetVfoOffset(int offset) {
+	if (offset >= 10 && offset <= 500) {
+		m_vfoOffset = offset;
+		setConfigInt("VfoOffset", offset);
+		m_dataChangedCallback();
+	}
+}
+
+bool DataService::UpdateAvailable() {
+	return version::version != m_remoteAdapter.GetNewestVersion();
 }

DataService.h

@@ -25,12 +25,29 @@ class DataService
 
 	void SaveMarker(marker::marker_t marker, const bool share);
 	void DeleteMarker(marker::marker_t marker);
-	void SyncMarkers();
+	void SyncMarkers(std::function<void(bool download, int progress)> progressHandler);
 	sync::syncinfo_t GetLastSync();
 	int GetMarkerCount();
 
+	void setSelectedMarker(marker::marker_t marker);
+	marker::marker_t getSelectedMarker();	
+
+	settings::types_t GetTypeSettings();
+	void SetTypeSettings(settings::types_t types);
+
+	void SaveWindowPos(channel_t channel, nana::point point);
+	nana::point LoadWindowPos(channel_t channel);
+
+	int GetVfoOffset();
+	void SetVfoOffset(int offset);
+
+	bool UpdateAvailable();
+
 private:
 	int m_oid;
+	int m_vfoOffset;
+	marker::marker_t m_selectedMarker;
+	settings::types_t m_typeSettings;
 	std::function<void()> m_dataChangedCallback;
 	sqlite3* m_database;
 
@@ -44,5 +61,10 @@ class DataService
 
 	void insertSyncedMarker(const marker::marker_t marker);
 	void updateSyncedMarker(const marker::marker_t marker);
+
+	std::string getConfig(std::string key);
+	void setConfig(std::string key, std::string value);
+	int getConfigInt(std::string key, int defaultValue = 0);
+	void setConfigInt(std::string key, int value);
 };
 

Plugin.cpp

@@ -12,6 +12,8 @@ Plugin::Plugin(IUnoPluginController& controller) :
 	m_dataService.Init();
 
 	m_annotatorService.UpdateMarkers();
+	
+	m_windowManager.RegisterCallback(std::bind(&Plugin::CloseCallback, this));
 	m_windowManager.UpdateVrxCount();
 
 	m_controller.RegisterAnnotator(&m_annotatorService);
@@ -40,6 +42,10 @@ void Plugin::HandleEvent(const UnoEvent& event)
 	}
 }
 
+void Plugin::CloseCallback()
+{
+	m_controller.RequestUnload(this);
+}
 
 void Plugin::DataChangedCallback()
 {

Plugin.h

@@ -17,6 +17,7 @@ class Plugin : public IUnoPlugin
 	const char* GetPluginName() const { return "CloudMarkers"; }
 	void HandleEvent(const UnoEvent& event);
 	void DataChangedCallback();
+	void CloseCallback();
 
 private:
 	AnnotatorService m_annotatorService;

RemoteAdapter.cpp

@@ -121,15 +121,28 @@ bool RemoteAdapter::Vote(const marker::marker_t marker, const int oid)
 	}
 }
 
-sync::syncresult_t RemoteAdapter::Get(int afterCommit, int oid)
+std::string RemoteAdapter::GetNewestVersion() {
+	std::string remoteUrl = std::string("/version.txt");
+
+	httplib::Client remoteClient(remote::server, 80);
+	httplib::Result result = remoteClient.Get(remoteUrl.c_str());
+	if (result.error() == httplib::Error::Success) {
+		if (result->status == 200 && !result->body.empty())
+			return result->body;
+	}
+
+	return "ERR";
+}
+
+sync::syncresult_t RemoteAdapter::Get(int afterCommit, int oid, std::function<bool(uint64_t current, uint64_t total)> progress)
 {
 	std::string remoteUrl = std::string("/get.php")
 		.append("?token=").append(remote::token)
 		.append("&oid=").append(std::to_string(oid))
 		.append("&commit=").append(std::to_string(afterCommit));
 
 	httplib::Client remoteClient(remote::server, 80);
-	httplib::Result result = remoteClient.Get(remoteUrl.c_str());
+	httplib::Result result = remoteClient.Get(remoteUrl.c_str(), progress);
 
 	if (result.error() == httplib::Error::Success) {
 		if (result->status == 200) {

RemoteAdapter.h

@@ -11,7 +11,9 @@ class RemoteAdapter
 	bool Delete(marker::marker_t marker, int oid);
 	bool Vote(const marker::marker_t marker, int oid);
 
-	sync::syncresult_t Get(int afterCommit, int oid);
+	std::string GetNewestVersion();
+
+	sync::syncresult_t Get(int afterCommit, int oid, std::function<bool(uint64_t current, uint64_t total)> progress);
 
 private:
 	std::string markerToJson(marker::marker_t marker);