Merge remote-tracking branch 'remotes/origin/feature/NewColorDefinition' into chore/aggregateBranches

PapeCoding · PapeCoding · commit fd9ae6047186 · 2025-03-30T19:20:45.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1,2 +1,3 @@
 /build
 /.cache
+/.vscode
diff --git a/.gitmodules b/.gitmodules
@@ -16,3 +16,6 @@
 [submodule "Thirdparty/nativefiledialog-extended"]
 	path = Thirdparty/nativefiledialog-extended
 	url = https://github.com/btzy/nativefiledialog-extended.git
+[submodule "Thirdparty/asio"]
+	path = Thirdparty/asio
+	url = https://github.com/chriskohlhoff/asio
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -60,7 +60,7 @@ add_subdirectory("Thirdparty/nativefiledialog-extended")
 
 IF (MSVC)
 	# Hide console window
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
+	#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:WINDOWS /ENTRY:mainCRTStartup")
 ENDIF()
 
 ADD_Executable(DasherUI
@@ -70,20 +70,29 @@ ADD_Executable(DasherUI
 	${PROJECT_SOURCE_DIR}/src/MainWindow.h
 	${PROJECT_SOURCE_DIR}/src/DasherUIScreen.cpp
 	${PROJECT_SOURCE_DIR}/src/DasherUIScreen.h
+	${PROJECT_SOURCE_DIR}/src/SocketInput.cpp
+	${PROJECT_SOURCE_DIR}/src/SocketInput.h
+	${PROJECT_SOURCE_DIR}/src/OSOutput.cpp
+	${PROJECT_SOURCE_DIR}/src/OSOutput.h
 	${PROJECT_SOURCE_DIR}/src/main.cpp
 )
 target_include_directories(DasherUI PUBLIC ${CMAKE_CURRENT_LIST_DIR}/Thirdparty/)
 add_dependencies(DasherUI imgui glfw DasherCore)
 target_link_libraries(DasherUI PRIVATE imgui glfw OpenGL::GL DasherCore nfd)
 
+###############################
+# Third Party Includes
+###############################
+target_include_directories(DasherUI PRIVATE ${PROJECT_SOURCE_DIR}/Thirdparty/asio/asio/include/)
+
 ###############################
 # Setting up deloyment
 ###############################
 
 # Copy Data files
 file(GLOB RESOURCE_FILES
   ${PROJECT_SOURCE_DIR}/DasherCore/Data/alphabets/alphabet*.xml
-  ${PROJECT_SOURCE_DIR}/DasherCore/Data/colours/colour*.xml
+  ${PROJECT_SOURCE_DIR}/DasherCore/Data/colors/color*.xml
   ${PROJECT_SOURCE_DIR}/DasherCore/Data/control/control*.xml
   ${PROJECT_SOURCE_DIR}/DasherCore/Data/training/training*.txt
 )
diff --git a/Thirdparty/asio b/Thirdparty/asio
@@ -0,0 +1 @@
+Subproject commit 6d7ab80041cb57d3dfe337ec58ee404c843a6833
diff --git a/src/DasherController.cpp b/src/DasherController.cpp
@@ -6,6 +6,8 @@ DasherController::DasherController(Dasher::CSettingsStore* pSettingsStore): CDas
 {
 	ScreenModule = std::make_shared<DasherUIScreen>();
 	CDashIntfScreenMsgs::ChangeScreen(ScreenModule.get());
+
+	OSOutputModule = std::make_unique<OSOutput>();
 }
 
 void DasherController::editOutput(const std::string& strText, Dasher::CDasherNode* pNode) {
@@ -15,35 +17,36 @@ void DasherController::editOutput(const std::string& strText, Dasher::CDasherNod
 	}
 	Buffer.append(strText);
 	Cursor += static_cast<unsigned int>(strText.length());
+	OSOutputModule->outputCharacter(strText);
 	CDasherInterfaceBase::editOutput(strText, pNode);
 }
 
 void DasherController::editDelete(const std::string& strText, Dasher::CDasherNode* pNode) {
 	if(0 == Buffer.compare(Buffer.length() - strText.length(), strText.length(), strText))
 	{
 		Buffer.erase(Buffer.length() - strText.length(), strText.length());
+		OSOutputModule->deleteCharacter();
 	}
 	CDasherInterfaceBase::editDelete(strText, pNode);
 }
 
-unsigned DasherController::ctrlMove(bool bForwards, Dasher::CControlManager::EditDistance dist)
+unsigned DasherController::ctrlMove(bool bForwards, Dasher::EditDistance dist)
 {
-	if (dist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {
+	if (dist == Dasher::EditDistance::EDIT_CHAR) {
 		if (bForwards) Cursor++;
 		else Cursor--;
 	}
 	return Cursor;
 }
 
-unsigned DasherController::ctrlDelete(bool bForwards, Dasher::CControlManager::EditDistance dist)
+unsigned DasherController::ctrlDelete(bool bForwards, Dasher::EditDistance dist)
 {
-	if(dist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {
+	if(dist == Dasher::EditDistance::EDIT_CHAR) {
 
 		Buffer.erase(Cursor - (bForwards ? 0 : 1), 1);
 	}
 	if(!bForwards) Cursor--;
 	return Cursor;
-
 }
 
 std::string DasherController::GetContext(unsigned iStart, unsigned iLength)
@@ -58,9 +61,9 @@ std::string DasherController::GetAllContext()
 	return CurrentBuffer;
 }
 
-std::string DasherController::GetTextAroundCursor(Dasher::CControlManager::EditDistance iDist) {
+std::string DasherController::GetTextAroundCursor(Dasher::EditDistance iDist) {
 	if (Buffer.length() > Cursor && Buffer.length() >= 2) {
-		if (iDist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {
+		if (iDist == Dasher::EditDistance::EDIT_CHAR) {
 			return Buffer.substr(Cursor - 1, 2);
 		}
 
@@ -87,8 +90,13 @@ void DasherController::CreateModules()
 {
 	CDashIntfScreenMsgs::CreateModules();
 
-	RegisterModule(ScreenModule.get());
-	SetDefaultInputDevice(ScreenModule.get());
+	GetModuleManager()->RegisterInputDeviceModule(ScreenModule.get());
+
+	SocketInputModule = std::make_shared<SocketInput>(m_pSettingsStore, this, m_pFramerate);
+	GetModuleManager()->RegisterInputDeviceModule(SocketInputModule.get());
+	SocketInputModule->startListen();
+
+	GetModuleManager()->SetDefaultInputDevice(SocketInputModule.get());
 }
 
 void DasherController::CopyToClipboard(const std::string& text)
diff --git a/src/DasherController.h b/src/DasherController.h
@@ -6,6 +6,9 @@
 #include "imgui_internal.h"
 #include <memory>
 
+#include "OSOutput.h"
+#include "SocketInput.h"
+
 
 class DasherController : public Dasher::CDashIntfScreenMsgs
 {
@@ -14,11 +17,11 @@ class DasherController : public Dasher::CDashIntfScreenMsgs
 
 	void editOutput(const std::string& strText, Dasher::CDasherNode* pNode) override;
 	void editDelete(const std::string& strText, Dasher::CDasherNode* pNode) override;
-	unsigned ctrlMove(bool bForwards, Dasher::CControlManager::EditDistance dist) override;
-	unsigned ctrlDelete(bool bForwards, Dasher::CControlManager::EditDistance dist) override;
+	unsigned ctrlMove(bool bForwards, Dasher::EditDistance dist) override;
+	unsigned ctrlDelete(bool bForwards, Dasher::EditDistance dist) override;
 	std::string GetContext(unsigned iStart, unsigned iLength) override;
 	std::string GetAllContext() override;
-	std::string GetTextAroundCursor(Dasher::CControlManager::EditDistance iDist) override;
+	std::string GetTextAroundCursor(Dasher::EditDistance iDist) override;
 	int GetAllContextLenght() override;
 
 	void Initialize();
@@ -44,4 +47,6 @@ class DasherController : public Dasher::CDashIntfScreenMsgs
 
 	//Modules
 	std::shared_ptr<DasherUIScreen> ScreenModule;
+	std::shared_ptr<SocketInput> SocketInputModule;
+	std::shared_ptr<OSOutput> OSOutputModule;
 };
diff --git a/src/DasherUIScreen.cpp b/src/DasherUIScreen.cpp
@@ -3,7 +3,7 @@
 #include "MainWindow.h"
 #include "imgui/imgui_internal.h"
 
-DasherUIScreen::DasherUIScreen(): Dasher::CDasherScreen(100,100), CScreenCoordInput(0, _("Mouse Input"))
+DasherUIScreen::DasherUIScreen(): Dasher::CDasherScreen(100,100), CScreenCoordInput(_("Mouse Input"))
 {
 	Font = MainWindow::LoadFonts(50.0f);
 }
@@ -14,52 +14,49 @@ std::pair<Dasher::screenint, Dasher::screenint> DasherUIScreen::TextSize(Label*
 	return {static_cast<Dasher::screenint>(Size.x), static_cast<Dasher::screenint>(Size.y)};
 }
 
-void DasherUIScreen::DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, int iColour)
+void DasherUIScreen::DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, const Dasher::ColorPalette::Color& Color)
 {
-	const Dasher::CColourIO::ColourInfo::PaletteColor Color = this->pColorScheme->Colors[iColour];
-	const ImVec4 ImColor = { static_cast<float>(Color.Red) / 255.0f, static_cast<float>(Color.Green) / 255.0f, static_cast<float>(Color.Blue) / 255.0f, 1.0f };
+	if(Color.isFullyTransparent()) return;
+	const ImVec4 ImColor = { static_cast<float>(Color.Red) / 255.0f, static_cast<float>(Color.Green) / 255.0f, static_cast<float>(Color.Blue) / 255.0f, static_cast<float>(Color.Alpha) / 255.0f };
 	const ImVec2 Pos = { static_cast<float>(x),static_cast<float>(y)};
 	ImGui::GetWindowDrawList()->AddText(Font, static_cast<float>(iFontSize), Pos + CanvasPos, ImGui::ColorConvertFloat4ToU32(ImColor), label->m_strText.c_str());
 }
 
-void DasherUIScreen::DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, int Colour, int iOutlineColour, int iThickness)
+void DasherUIScreen::DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& OutlineColor, int iThickness)
 {
-	const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[Colour];
-	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };
+	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };
 	const ImVec2 p1 = { static_cast<float>(x1), static_cast<float>(y1)};
 	const ImVec2 p2 = { static_cast<float>(x2), static_cast<float>(y2)};
 
-	ImGui::GetWindowDrawList()->AddRectFilled(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImFillColor));
+	if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddRectFilled(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImFillColor));
 
-	if(iThickness > 0)
+	if(iThickness > 0 && !OutlineColor.isFullyTransparent())
 	{
-		const Dasher::CColourIO::ColourInfo::PaletteColor OutlineColor = this->pColorScheme->Colors[iOutlineColour > 0 ? iOutlineColour : 3]; //Apparently Outline Color 3 is the default
-		const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, 1.0f };
+		const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };
 
 		ImGui::GetWindowDrawList()->AddRect(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImOutlineColor),0,0, static_cast<float>(iThickness));
 	}
 }
 
-void DasherUIScreen::DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, int iFillColour, int iLineColour, int iLineWidth)
+void DasherUIScreen::DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& LineColor, int iLineWidth)
 {
-	const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[iFillColour];
-	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };
+	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };
 
-	ImGui::GetWindowDrawList()->AddCircleFilled(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor));
+	if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddCircleFilled(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor));
 
-	if (iLineWidth > 0)
+	if (iLineWidth > 0 && !LineColor.isFullyTransparent())
 	{
-		const Dasher::CColourIO::ColourInfo::PaletteColor OutlineColor = this->pColorScheme->Colors[iLineColour > 0 ? iLineColour : 3];
-		const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, 1.0f };
+		const ImVec4 ImOutlineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, static_cast<float>(LineColor.Alpha) / 255.0f };
 
-		ImGui::GetWindowDrawList()->AddCircle(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor),0, static_cast<float>(iLineWidth));
+		ImGui::GetWindowDrawList()->AddCircle(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImOutlineColor),0, static_cast<float>(iLineWidth));
 	}
 }
 
-void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, int Colour)
+void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, const Dasher::ColorPalette::Color& LineColor)
 {
-	const Dasher::CColourIO::ColourInfo::PaletteColor LineColor = this->pColorScheme->Colors[Colour];
-	const ImVec4 ImLineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, 1.0f };
+	if(LineColor.isFullyTransparent()) return;
+
+	const ImVec4 ImLineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, static_cast<float>(LineColor.Alpha) / 255.0f};
 
 	std::vector<ImVec2> points;
 
@@ -71,10 +68,9 @@ void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, int Colour)
 	ImGui::GetWindowDrawList()->AddPolyline(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImLineColor), 0, static_cast<float>(iWidth));
 }
 
-void DasherUIScreen::Polygon(point* Points, int Number, int fillColour, int outlineColour, int lineWidth)
+void DasherUIScreen::Polygon(point* Points, int Number, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& outlineColor, int lineWidth)
 {
-	const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[fillColour];
-	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };
+	const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };
 
 	std::vector<ImVec2> points;
 
@@ -83,21 +79,16 @@ void DasherUIScreen::Polygon(point* Points, int Number, int fillColour, int outl
 		points.push_back(CanvasPos + ImVec2(static_cast<float>(Points[i].x), static_cast<float>(Points[i].y)));
 	}
 
-	ImGui::GetWindowDrawList()->AddConvexPolyFilled(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImFillColor));
+	if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddConvexPolyFilled(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImFillColor));
 
 	if(lineWidth > 0)
 	{
-		Polyline(Points, Number, lineWidth, outlineColour);
+		Polyline(Points, Number, lineWidth, outlineColor);
 	}
 }
 
 void DasherUIScreen::Display(){}
 
-void DasherUIScreen::SetColourScheme(const Dasher::CColourIO::ColourInfo* pColourScheme)
-{
-	this->pColorScheme = pColourScheme;
-}
-
 bool DasherUIScreen::IsPointVisible(Dasher::screenint, Dasher::screenint){
 	return true;
 }
@@ -119,7 +110,7 @@ bool DasherUIScreen::SetCanvasSize(const ImVec2 position, const ImVec2 size)
 bool DasherUIScreen::GetScreenCoords(Dasher::screenint& iX, Dasher::screenint& iY, Dasher::CDasherView* pView)
 {
 	const ImVec2 MousePos = ImGui::GetMousePos();
-	if (MousePos.x < 0 || MousePos.y < 0) return false;
+	if(!ImGui::IsMousePosValid(&MousePos)) return false;
 	iX = static_cast<Dasher::screenint>(MousePos.x - CanvasPos.x);
 	iY = static_cast<Dasher::screenint>(MousePos.y - CanvasPos.y);
 	return true;
diff --git a/src/DasherUIScreen.h b/src/DasherUIScreen.h
@@ -11,23 +11,19 @@ class DasherUIScreen : public Dasher::CDasherScreen, public Dasher::CScreenCoord
 	DasherUIScreen();
 
 	std::pair<Dasher::screenint, Dasher::screenint> TextSize(Label* label, unsigned iFontSize) override;
-	void DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, int iColour) override;
-	void DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, int Colour, int iOutlineColour, int iThickness) override;
-	void DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, int iFillColour, int iLineColour, int iLineWidth) override;
-	void Polyline(point* Points, int Number, int iWidth, int Colour) override;
-	void Polygon(point* Points, int Number, int fillColour, int outlineColour, int lineWidth) override;
+	void DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, const Dasher::ColorPalette::Color& Colour) override;
+	void DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, const Dasher::ColorPalette::Color& Colour, const Dasher::ColorPalette::Color& OutlineColour, int iThickness) override;
+	void DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, const Dasher::ColorPalette::Color& iFillColour, const Dasher::ColorPalette::Color& LineColour, int iLineWidth) override;
+	void Polyline(point* Points, int Number, int iWidth, const Dasher::ColorPalette::Color& Colour) override;
+	void Polygon(point* Points, int Number, const Dasher::ColorPalette::Color& fillColour, const Dasher::ColorPalette::Color& outlineColour, int lineWidth) override;
 	void Display() override;
-	void SetColourScheme(const Dasher::CColourIO::ColourInfo* pColourScheme) override;
 	bool IsPointVisible(Dasher::screenint x, Dasher::screenint y) override;
-
-	bool MultiSizeFonts() override { return true; }
-	
+		
 	bool SetCanvasSize(ImVec2 CanvasPos, ImVec2 CanvasSize);
 
 	bool GetScreenCoords(Dasher::screenint& iX, Dasher::screenint& iY, Dasher::CDasherView* pView) override;
 
 private:
-	const Dasher::CColourIO::ColourInfo* pColorScheme;
 	ImVec2 CanvasPos;
 	ImVec2 CanvasSize;
 
diff --git a/src/MainWindow.cpp b/src/MainWindow.cpp
@@ -8,7 +8,7 @@
 
 MainWindow::MainWindow()
 {
-	ImGui::SetCurrentFont(LoadFonts(14.0f));
+	ImGui::SetCurrentFont(LoadFonts(22.0f));
 
 	Settings = std::make_unique<Dasher::XmlSettingsStore>("Settings.xml", this);
 	Settings->Load();
@@ -18,7 +18,6 @@ MainWindow::MainWindow()
 	Controller->Initialize();
 
 	Controller->GetPermittedValues(Dasher::SP_ALPHABET_ID, Alphabets);
-
 }
 
 #define FORWARD_KEY(ImGui_Key, DasherKey) { \
diff --git a/src/OSOutput.cpp b/src/OSOutput.cpp
@@ -0,0 +1,61 @@
+#include "OSOutput.h"
+
+#include <string>
+
+#ifdef _WIN32
+#include <codecvt>
+
+#define WIN32_LEAN_AND_MEAN      // Exclude rarely-used stuff from Windows headers
+#include <windows.h>
+#include <stringapiset.h>
+#include <WinUser.h>
+#undef WIN32_LEAN_AND_MEAN
+#endif
+
+OSOutput::OSOutput(){}
+
+OSOutput::~OSOutput(){}
+
+void OSOutput::deleteCharacter()
+{
+#ifdef _WIN32
+    INPUT fakekey[2];
+    fakekey[0].type = fakekey[1].type = INPUT_KEYBOARD;
+    fakekey[0].ki.wVk = fakekey[1].ki.wVk = VK_BACK;
+    fakekey[0].ki.time = fakekey[1].ki.time = 0;
+    fakekey[1].ki.dwFlags = KEYEVENTF_KEYUP;
+
+    SendInput(2, fakekey, sizeof(INPUT));
+#endif
+}
+
+void OSOutput::outputCharacter(const std::string &sText)
+{
+#ifdef _WIN32
+    INPUT fakekey[2];
+    if(sText[0] == '\r' && sText[1] == '\n') {
+        // Newline, so we want to fake an enter
+        fakekey[0].type = fakekey[1].type = INPUT_KEYBOARD;
+        fakekey[0].ki.wVk = fakekey[1].ki.wVk = VK_RETURN;
+        fakekey[0].ki.time = fakekey[1].ki.time = 0;
+        fakekey[1].ki.dwFlags = KEYEVENTF_KEYUP;
+        SendInput(2, fakekey, sizeof(INPUT));
+    }
+    else {
+        int wchars_num = MultiByteToWideChar( CP_UTF8 , 0 , sText.c_str() , -1, nullptr , 0 );
+        wchar_t* wstr = new wchar_t[wchars_num];
+        MultiByteToWideChar( CP_UTF8 , 0 , sText.c_str() , -1, wstr , wchars_num );
+
+        for(int i = 0; i < wchars_num; ++i) {
+            fakekey[0].type = INPUT_KEYBOARD;
+            fakekey[0].ki.dwFlags = KEYEVENTF_UNICODE;
+            fakekey[0].ki.wVk = 0;
+            fakekey[0].ki.time = NULL;
+            fakekey[0].ki.wScan = wstr[i];
+            SendInput(1, fakekey, sizeof(INPUT));
+        }
+
+        delete[] wstr;
+    }
+#endif
+}
diff --git a/src/OSOutput.h b/src/OSOutput.h
diff --git a/src/SocketInput.cpp b/src/SocketInput.cpp
diff --git a/src/SocketInput.h b/src/SocketInput.h

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,3 @@`
`1`	`1`	`/build`
`2`	`2`	`/.cache`
	`3`	`+/.vscode`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@ DasherController::DasherController(Dasher::CSettingsStore* pSettingsStore): CDas`
`6`	`6`	`{`
`7`	`7`	`ScreenModule = std::make_shared<DasherUIScreen>();`
`8`	`8`	`CDashIntfScreenMsgs::ChangeScreen(ScreenModule.get());`
	`9`	`+`
	`10`	`+ OSOutputModule = std::make_unique<OSOutput>();`
`9`	`11`	`}`
`10`	`12`
`11`	`13`	`void DasherController::editOutput(const std::string& strText, Dasher::CDasherNode* pNode) {`
`@@ -15,35 +17,36 @@ void DasherController::editOutput(const std::string& strText, Dasher::CDasherNod`
`15`	`17`	`}`
`16`	`18`	`Buffer.append(strText);`
`17`	`19`	`Cursor += static_cast<unsigned int>(strText.length());`
	`20`	`+ OSOutputModule->outputCharacter(strText);`
`18`	`21`	`CDasherInterfaceBase::editOutput(strText, pNode);`
`19`	`22`	`}`
`20`	`23`
`21`	`24`	`void DasherController::editDelete(const std::string& strText, Dasher::CDasherNode* pNode) {`
`22`	`25`	`if(0 == Buffer.compare(Buffer.length() - strText.length(), strText.length(), strText))`
`23`	`26`	`{`
`24`	`27`	`Buffer.erase(Buffer.length() - strText.length(), strText.length());`
	`28`	`+ OSOutputModule->deleteCharacter();`
`25`	`29`	`}`
`26`	`30`	`CDasherInterfaceBase::editDelete(strText, pNode);`
`27`	`31`	`}`
`28`	`32`
`29`		`-unsigned DasherController::ctrlMove(bool bForwards, Dasher::CControlManager::EditDistance dist)`
	`33`	`+unsigned DasherController::ctrlMove(bool bForwards, Dasher::EditDistance dist)`
`30`	`34`	`{`
`31`		`- if (dist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {`
	`35`	`+ if (dist == Dasher::EditDistance::EDIT_CHAR) {`
`32`	`36`	`if (bForwards) Cursor++;`
`33`	`37`	`else Cursor--;`
`34`	`38`	`}`
`35`	`39`	`return Cursor;`
`36`	`40`	`}`
`37`	`41`
`38`		`-unsigned DasherController::ctrlDelete(bool bForwards, Dasher::CControlManager::EditDistance dist)`
	`42`	`+unsigned DasherController::ctrlDelete(bool bForwards, Dasher::EditDistance dist)`
`39`	`43`	`{`
`40`		`- if(dist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {`
	`44`	`+ if(dist == Dasher::EditDistance::EDIT_CHAR) {`
`41`	`45`
`42`	`46`	`Buffer.erase(Cursor - (bForwards ? 0 : 1), 1);`
`43`	`47`	`}`
`44`	`48`	`if(!bForwards) Cursor--;`
`45`	`49`	`return Cursor;`
`46`		`-`
`47`	`50`	`}`
`48`	`51`
`49`	`52`	`std::string DasherController::GetContext(unsigned iStart, unsigned iLength)`
`@@ -58,9 +61,9 @@ std::string DasherController::GetAllContext()`
`58`	`61`	`return CurrentBuffer;`
`59`	`62`	`}`
`60`	`63`
`61`		`-std::string DasherController::GetTextAroundCursor(Dasher::CControlManager::EditDistance iDist) {`
	`64`	`+std::string DasherController::GetTextAroundCursor(Dasher::EditDistance iDist) {`
`62`	`65`	`if (Buffer.length() > Cursor && Buffer.length() >= 2) {`
`63`		`- if (iDist == Dasher::CControlManager::EditDistance::EDIT_CHAR) {`
	`66`	`+ if (iDist == Dasher::EditDistance::EDIT_CHAR) {`
`64`	`67`	`return Buffer.substr(Cursor - 1, 2);`
`65`	`68`	`}`
`66`	`69`
`@@ -87,8 +90,13 @@ void DasherController::CreateModules()`
`87`	`90`	`{`
`88`	`91`	`CDashIntfScreenMsgs::CreateModules();`
`89`	`92`
`90`		`- RegisterModule(ScreenModule.get());`
`91`		`- SetDefaultInputDevice(ScreenModule.get());`
	`93`	`+ GetModuleManager()->RegisterInputDeviceModule(ScreenModule.get());`
	`94`	`+`
	`95`	`+ SocketInputModule = std::make_shared<SocketInput>(m_pSettingsStore, this, m_pFramerate);`
	`96`	`+ GetModuleManager()->RegisterInputDeviceModule(SocketInputModule.get());`
	`97`	`+ SocketInputModule->startListen();`
	`98`	`+`
	`99`	`+ GetModuleManager()->SetDefaultInputDevice(SocketInputModule.get());`
`92`	`100`	`}`
`93`	`101`
`94`	`102`	`void DasherController::CopyToClipboard(const std::string& text)`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`#include "MainWindow.h"`
`4`	`4`	`#include "imgui/imgui_internal.h"`
`5`	`5`
`6`		`-DasherUIScreen::DasherUIScreen(): Dasher::CDasherScreen(100,100), CScreenCoordInput(0, _("Mouse Input"))`
	`6`	`+DasherUIScreen::DasherUIScreen(): Dasher::CDasherScreen(100,100), CScreenCoordInput(_("Mouse Input"))`
`7`	`7`	`{`
`8`	`8`	`Font = MainWindow::LoadFonts(50.0f);`
`9`	`9`	`}`
`@@ -14,52 +14,49 @@ std::pair<Dasher::screenint, Dasher::screenint> DasherUIScreen::TextSize(Label*`
`14`	`14`	`return {static_cast<Dasher::screenint>(Size.x), static_cast<Dasher::screenint>(Size.y)};`
`15`	`15`	`}`
`16`	`16`
`17`		`-void DasherUIScreen::DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, int iColour)`
	`17`	`+void DasherUIScreen::DrawString(Label* label, Dasher::screenint x, Dasher::screenint y, unsigned iFontSize, const Dasher::ColorPalette::Color& Color)`
`18`	`18`	`{`
`19`		`- const Dasher::CColourIO::ColourInfo::PaletteColor Color = this->pColorScheme->Colors[iColour];`
`20`		`- const ImVec4 ImColor = { static_cast<float>(Color.Red) / 255.0f, static_cast<float>(Color.Green) / 255.0f, static_cast<float>(Color.Blue) / 255.0f, 1.0f };`
	`19`	`+ if(Color.isFullyTransparent()) return;`
	`20`	`+ const ImVec4 ImColor = { static_cast<float>(Color.Red) / 255.0f, static_cast<float>(Color.Green) / 255.0f, static_cast<float>(Color.Blue) / 255.0f, static_cast<float>(Color.Alpha) / 255.0f };`
`21`	`21`	`const ImVec2 Pos = { static_cast<float>(x),static_cast<float>(y)};`
`22`	`22`	`ImGui::GetWindowDrawList()->AddText(Font, static_cast<float>(iFontSize), Pos + CanvasPos, ImGui::ColorConvertFloat4ToU32(ImColor), label->m_strText.c_str());`
`23`	`23`	`}`
`24`	`24`
`25`		`-void DasherUIScreen::DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, int Colour, int iOutlineColour, int iThickness)`
	`25`	`+void DasherUIScreen::DrawRectangle(Dasher::screenint x1, Dasher::screenint y1, Dasher::screenint x2, Dasher::screenint y2, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& OutlineColor, int iThickness)`
`26`	`26`	`{`
`27`		`- const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[Colour];`
`28`		`- const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };`
	`27`	`+ const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };`
`29`	`28`	`const ImVec2 p1 = { static_cast<float>(x1), static_cast<float>(y1)};`
`30`	`29`	`const ImVec2 p2 = { static_cast<float>(x2), static_cast<float>(y2)};`
`31`	`30`
`32`		`- ImGui::GetWindowDrawList()->AddRectFilled(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImFillColor));`
	`31`	`+ if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddRectFilled(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImFillColor));`
`33`	`32`
`34`		`- if(iThickness > 0)`
	`33`	`+ if(iThickness > 0 && !OutlineColor.isFullyTransparent())`
`35`	`34`	`{`
`36`		`- const Dasher::CColourIO::ColourInfo::PaletteColor OutlineColor = this->pColorScheme->Colors[iOutlineColour > 0 ? iOutlineColour : 3]; //Apparently Outline Color 3 is the default`
`37`		`- const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, 1.0f };`
	`35`	`+ const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };`
`38`	`36`
`39`	`37`	`ImGui::GetWindowDrawList()->AddRect(CanvasPos + p1, CanvasPos + p2, ImGui::ColorConvertFloat4ToU32(ImOutlineColor),0,0, static_cast<float>(iThickness));`
`40`	`38`	`}`
`41`	`39`	`}`
`42`	`40`
`43`		`-void DasherUIScreen::DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, int iFillColour, int iLineColour, int iLineWidth)`
	`41`	`+void DasherUIScreen::DrawCircle(Dasher::screenint iCX, Dasher::screenint iCY, Dasher::screenint iR, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& LineColor, int iLineWidth)`
`44`	`42`	`{`
`45`		`- const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[iFillColour];`
`46`		`- const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };`
	`43`	`+ const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };`
`47`	`44`
`48`		`- ImGui::GetWindowDrawList()->AddCircleFilled(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor));`
	`45`	`+ if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddCircleFilled(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor));`
`49`	`46`
`50`		`- if (iLineWidth > 0)`
	`47`	`+ if (iLineWidth > 0 && !LineColor.isFullyTransparent())`
`51`	`48`	`{`
`52`		`- const Dasher::CColourIO::ColourInfo::PaletteColor OutlineColor = this->pColorScheme->Colors[iLineColour > 0 ? iLineColour : 3];`
`53`		`- const ImVec4 ImOutlineColor = { static_cast<float>(OutlineColor.Red) / 255.0f, static_cast<float>(OutlineColor.Green) / 255.0f, static_cast<float>(OutlineColor.Blue) / 255.0f, 1.0f };`
	`49`	`+ const ImVec4 ImOutlineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, static_cast<float>(LineColor.Alpha) / 255.0f };`
`54`	`50`
`55`		`- ImGui::GetWindowDrawList()->AddCircle(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImFillColor),0, static_cast<float>(iLineWidth));`
	`51`	`+ ImGui::GetWindowDrawList()->AddCircle(CanvasPos + ImVec2(static_cast<float>(iCX), static_cast<float>(iCY)), static_cast<float>(iR), ImGui::ColorConvertFloat4ToU32(ImOutlineColor),0, static_cast<float>(iLineWidth));`
`56`	`52`	`}`
`57`	`53`	`}`
`58`	`54`
`59`		`-void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, int Colour)`
	`55`	`+void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, const Dasher::ColorPalette::Color& LineColor)`
`60`	`56`	`{`
`61`		`- const Dasher::CColourIO::ColourInfo::PaletteColor LineColor = this->pColorScheme->Colors[Colour];`
`62`		`- const ImVec4 ImLineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, 1.0f };`
	`57`	`+ if(LineColor.isFullyTransparent()) return;`
	`58`	`+`
	`59`	`+ const ImVec4 ImLineColor = { static_cast<float>(LineColor.Red) / 255.0f, static_cast<float>(LineColor.Green) / 255.0f, static_cast<float>(LineColor.Blue) / 255.0f, static_cast<float>(LineColor.Alpha) / 255.0f};`
`63`	`60`
`64`	`61`	`std::vector<ImVec2> points;`
`65`	`62`
`@@ -71,10 +68,9 @@ void DasherUIScreen::Polyline(point* Points, int Number, int iWidth, int Colour)`
`71`	`68`	`ImGui::GetWindowDrawList()->AddPolyline(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImLineColor), 0, static_cast<float>(iWidth));`
`72`	`69`	`}`
`73`	`70`
`74`		`-void DasherUIScreen::Polygon(point* Points, int Number, int fillColour, int outlineColour, int lineWidth)`
	`71`	`+void DasherUIScreen::Polygon(point* Points, int Number, const Dasher::ColorPalette::Color& FillColor, const Dasher::ColorPalette::Color& outlineColor, int lineWidth)`
`75`	`72`	`{`
`76`		`- const Dasher::CColourIO::ColourInfo::PaletteColor FillColor = this->pColorScheme->Colors[fillColour];`
`77`		`- const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, 1.0f };`
	`73`	`+ const ImVec4 ImFillColor = { static_cast<float>(FillColor.Red) / 255.0f, static_cast<float>(FillColor.Green) / 255.0f, static_cast<float>(FillColor.Blue) / 255.0f, static_cast<float>(FillColor.Alpha) / 255.0f };`
`78`	`74`
`79`	`75`	`std::vector<ImVec2> points;`
`80`	`76`
`@@ -83,21 +79,16 @@ void DasherUIScreen::Polygon(point* Points, int Number, int fillColour, int outl`
`83`	`79`	`points.push_back(CanvasPos + ImVec2(static_cast<float>(Points[i].x), static_cast<float>(Points[i].y)));`
`84`	`80`	`}`
`85`	`81`
`86`		`- ImGui::GetWindowDrawList()->AddConvexPolyFilled(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImFillColor));`
	`82`	`+ if(!FillColor.isFullyTransparent()) ImGui::GetWindowDrawList()->AddConvexPolyFilled(points.data(), Number, ImGui::ColorConvertFloat4ToU32(ImFillColor));`
`87`	`83`
`88`	`84`	`if(lineWidth > 0)`
`89`	`85`	`{`
`90`		`- Polyline(Points, Number, lineWidth, outlineColour);`
	`86`	`+ Polyline(Points, Number, lineWidth, outlineColor);`
`91`	`87`	`}`
`92`	`88`	`}`
`93`	`89`
`94`	`90`	`void DasherUIScreen::Display(){}`
`95`	`91`
`96`		`-void DasherUIScreen::SetColourScheme(const Dasher::CColourIO::ColourInfo* pColourScheme)`
`97`		`-{`
`98`		`- this->pColorScheme = pColourScheme;`
`99`		`-}`
`100`		`-`
`101`	`92`	`bool DasherUIScreen::IsPointVisible(Dasher::screenint, Dasher::screenint){`
`102`	`93`	`return true;`
`103`	`94`	`}`
`@@ -119,7 +110,7 @@ bool DasherUIScreen::SetCanvasSize(const ImVec2 position, const ImVec2 size)`
`119`	`110`	`bool DasherUIScreen::GetScreenCoords(Dasher::screenint& iX, Dasher::screenint& iY, Dasher::CDasherView* pView)`
`120`	`111`	`{`
`121`	`112`	`const ImVec2 MousePos = ImGui::GetMousePos();`
`122`		`- if (MousePos.x < 0 \|\| MousePos.y < 0) return false;`
	`113`	`+ if(!ImGui::IsMousePosValid(&MousePos)) return false;`
`123`	`114`	`iX = static_cast<Dasher::screenint>(MousePos.x - CanvasPos.x);`
`124`	`115`	`iY = static_cast<Dasher::screenint>(MousePos.y - CanvasPos.y);`
`125`	`116`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`
`9`	`9`	`MainWindow::MainWindow()`
`10`	`10`	`{`
`11`		`- ImGui::SetCurrentFont(LoadFonts(14.0f));`
	`11`	`+ ImGui::SetCurrentFont(LoadFonts(22.0f));`
`12`	`12`
`13`	`13`	`Settings = std::make_unique<Dasher::XmlSettingsStore>("Settings.xml", this);`
`14`	`14`	`Settings->Load();`
`@@ -18,7 +18,6 @@ MainWindow::MainWindow()`
`18`	`18`	`Controller->Initialize();`
`19`	`19`
`20`	`20`	`Controller->GetPermittedValues(Dasher::SP_ALPHABET_ID, Alphabets);`
`21`		`-`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`#define FORWARD_KEY(ImGui_Key, DasherKey) { \`