Merge mit P:\Projekte

PyDeskband/.gitignore

@@ -0,0 +1,17 @@
+# Python things
+dist/
+build/
+pydeskband.egg-info
+**.pyc
+
+# Built dlls in Python package
+pydeskband/dlls/
+
+# VS/MSVC things
+dll/PyDeskband/.vs/
+dll/PyDeskband/Debug/
+dll/PyDeskband/Release/
+dll/PyDeskband/x64/
+dll/PyDeskband/PyDeskband/Debug/
+dll/PyDeskband/PyDeskband/Release/
+dll/PyDeskband/PyDeskband/x64/

PyDeskband/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2020 Charles Machalow
+
+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.

PyDeskband/README.md

@@ -0,0 +1,26 @@
+# PyDeskband
+
+PyDeskband is a multi-part project with two interconnected pieces of code.
+
+## C++
+
+There is a C++ DLL that is loaded via regsvr32.exe (into Windows Explorer) to create and paint a Deskband on the Windows Taskbar.
+
+## Python
+
+The Python front-end contains a means to control the C++ backend to control what is painted onto the Deskband. After installing the dll, it's easy to manipulate the deskband:
+
+<img src="https://i.imgur.com/TJkWOhb.png">
+
+Note that the APIs are still being designed and subject to change.
+
+# What is a Deskband?
+
+A Deskband is an additonal toolbar placed on the right-hand-side of the Windows Taskbar. Interestingly, enough they are considered deprecated as of Windows 10, but as of this writing still work just fine. Here is some [documentation](https://docs.microsoft.com/en-us/previous-versions/windows/desktop/legacy/cc144099(v=vs.85)) that includes high-level information on Deskbands.
+
+## Any Other Deskband Examples?
+
+Another example of a deskband is [XMeters](https://entropy6.com/xmeters/)
+
+## License
+MIT License

PyDeskband/dll/PyDeskband/PyDeskband.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.30804.86
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PyDeskband", "PyDeskband\PyDeskband.vcxproj", "{F98F92CD-FEFD-4961-8193-F6881E6CE92E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Debug|x64.ActiveCfg = Debug|x64
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Debug|x64.Build.0 = Debug|x64
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Debug|x86.ActiveCfg = Debug|Win32
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Debug|x86.Build.0 = Debug|Win32
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Release|x64.ActiveCfg = Release|x64
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Release|x64.Build.0 = Release|x64
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Release|x86.ActiveCfg = Release|Win32
+		{F98F92CD-FEFD-4961-8193-F6881E6CE92E}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {26AC4DEA-72DA-447A-AE88-6F9641686CF5}
+	EndGlobalSection
+EndGlobal

PyDeskband/dll/PyDeskband/PyDeskband/ClassFactory.cpp

@@ -0,0 +1,86 @@
+#include "ClassFactory.h"
+#include "Deskband.h"
+
+extern long g_cDllRef;
+
+CClassFactory::CClassFactory()
+{
+    m_cRef = 1;
+    InterlockedIncrement(&g_cDllRef);
+}
+
+CClassFactory::~CClassFactory()
+{
+    InterlockedDecrement(&g_cDllRef);
+}
+
+//
+// IUnknown
+//
+STDMETHODIMP CClassFactory::QueryInterface(REFIID riid, void** ppv)
+{
+    HRESULT hr = S_OK;
+
+    if (IsEqualIID(IID_IUnknown, riid) || IsEqualIID(IID_IClassFactory, riid))
+    {
+        *ppv = static_cast<IUnknown*>(this);
+        AddRef();
+    }
+    else
+    {
+        hr = E_NOINTERFACE;
+        *ppv = NULL;
+    }
+
+    return hr;
+}
+
+STDMETHODIMP_(ULONG) CClassFactory::AddRef()
+{
+    return InterlockedIncrement(&m_cRef);
+}
+
+STDMETHODIMP_(ULONG) CClassFactory::Release()
+{
+    ULONG cRef = InterlockedDecrement(&m_cRef);
+    if (0 == cRef)
+    {
+        delete this;
+    }
+    return cRef;
+}
+
+//
+// IClassFactory
+//
+STDMETHODIMP CClassFactory::CreateInstance(IUnknown* pUnkOuter, REFIID riid, void** ppv)
+{
+    HRESULT hr = CLASS_E_NOAGGREGATION;
+
+    if (!pUnkOuter)
+    {
+        hr = E_OUTOFMEMORY;
+
+        CDeskBand* pDeskBand = new CDeskBand();
+        if (pDeskBand)
+        {
+            hr = pDeskBand->QueryInterface(riid, ppv);
+            pDeskBand->Release();
+        }
+    }
+
+    return hr;
+}
+
+STDMETHODIMP CClassFactory::LockServer(BOOL fLock)
+{
+    if (fLock)
+    {
+        InterlockedIncrement(&g_cDllRef);
+    }
+    else
+    {
+        InterlockedDecrement(&g_cDllRef);
+    }
+    return S_OK;
+}

PyDeskband/dll/PyDeskband/PyDeskband/ClassFactory.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <unknwn.h> // for IClassFactory
+#include <windows.h>
+
+class CClassFactory : public IClassFactory
+{
+public:
+    // IUnknown
+    STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
+    STDMETHODIMP_(ULONG) AddRef();
+    STDMETHODIMP_(ULONG) Release();
+
+    // IClassFactory
+    STDMETHODIMP CreateInstance(IUnknown* pUnkOuter, REFIID riid, void** ppv);
+    STDMETHODIMP LockServer(BOOL fLock);
+
+    CClassFactory();
+
+protected:
+    ~CClassFactory();
+
+private:
+    LONG m_cRef;
+};
+

PyDeskband/dll/PyDeskband/PyDeskband/ControlPipe.cpp

@@ -0,0 +1,453 @@
+#include "ControlPipe.h"
+#include "DeskBand.h"
+#include "Logger.h"
+
+#include <uxtheme.h>
+#include <exception>
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <codecvt>
+#include <locale>
+
+#define BUFFER_SIZE (1024 * 8)
+#define TRANSPORT_DELIM std::string(",")
+
+
+std::vector<std::string> split(std::string s, char delim)
+{
+    std::vector<std::string> ret;
+    std::stringstream wStringStream(s);
+    while (wStringStream.good())
+    {
+        std::string tmp;
+        std::getline(wStringStream, tmp, delim);
+        ret.push_back(tmp);
+    }
+    return ret;
+}
+
+std::wstring to_wstring(std::string str)
+{
+    using convert_t = std::codecvt_utf8<wchar_t>;
+    std::wstring_convert<convert_t, wchar_t> strconverter;
+    return strconverter.from_bytes(str);
+}
+
+ControlPipe::ControlPipe(CDeskBand* d)
+{
+    hPipe = CreateNamedPipe(TEXT("\\\\.\\pipe\\PyDeskbandControlPipe"),
+        PIPE_ACCESS_DUPLEX,
+        PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT,
+        1,
+        BUFFER_SIZE,
+        BUFFER_SIZE,
+        NMPWAIT_USE_DEFAULT_WAIT,
+        NULL);
+
+    deskband = d;
+    shouldStop = false;
+
+    this->asyncResponseThread = std::thread(&ControlPipe::asyncHandlingLoop, this);
+}
+
+ControlPipe::~ControlPipe()
+{
+    CloseHandle(hPipe);
+    hPipe = INVALID_HANDLE_VALUE;
+}
+
+DWORD ControlPipe::msgHandler(DWORD msg)
+{
+    if (msgToAction.find(msg) != msgToAction.end())
+    {
+        return system(msgToAction[msg].c_str());
+    }
+    return 0;
+}
+
+void ControlPipe::paintAllTextInfos()
+{
+    auto m_hwnd = deskband->m_hwnd;
+    PAINTSTRUCT ps;
+    HDC hdc = BeginPaint(m_hwnd, &ps);
+    RECT clientRectangle;
+    GetClientRect(m_hwnd, &clientRectangle);
+    HDC hdcPaint = NULL;
+    HPAINTBUFFER hBufferedPaint = BeginBufferedPaint(hdc, &clientRectangle, BPBF_TOPDOWNDIB, NULL, &hdcPaint);
+    DrawThemeParentBackground(m_hwnd, hdcPaint, &clientRectangle);
+
+    HTHEME hTheme = OpenThemeData(NULL, L"BUTTON");
+
+    for (auto& textInfo : textInfos)
+    {
+        log("Painting: " + textInfo.toString());
+
+        if (hdc)
+        {
+            if (deskband->m_fCompositionEnabled)
+            {
+                if (hTheme)
+                {
+
+                    SIZE textSize = getTextSize(textInfo.text);
+
+                    DTTOPTS dttOpts = { sizeof(dttOpts) };
+                    dttOpts.dwFlags = DTT_COMPOSITED | DTT_TEXTCOLOR | DTT_GLOWSIZE;
+                    dttOpts.crText = RGB(textInfo.red, textInfo.green, textInfo.blue);
+                    dttOpts.iGlowSize = 10;
+
+                    // textInfo.rect.left = (RECTWIDTH(clientRectangle) - textSize.cx) / 2;
+                    // textInfo.rect.top = (RECTHEIGHT(clientRectangle) - textSize.cy) / 2;
+                    textInfo.rect.right = textInfo.rect.left + textSize.cx;
+                    textInfo.rect.bottom = textInfo.rect.top + textSize.cy;
+
+                    auto w = to_wstring(textInfo.text);
+                    DrawThemeTextEx(hTheme, hdcPaint, 0, 0, w.c_str(), -1, 0, &textInfo.rect, &dttOpts);
+                }
+            }
+            else
+            {
+                abort();
+                /*
+                auto w = to_wstring(textInfo.text);
+
+                SetBkColor(hdc, RGB(textInfo.red, textInfo.green, textInfo.blue));
+                GetTextExtentPointA(hdc, textInfo.text.c_str(), (int)textInfo.text.size(), &size);
+                TextOutW(hdc,
+                    (RECTWIDTH(rc) - size.cx) / 2,
+                    (RECTHEIGHT(rc) - size.cy) / 2,
+                    w.c_str(),
+                    (int)w.size());
+                */
+            }
+        }
+    }
+
+    CloseThemeData(hTheme);
+    EndBufferedPaint(hBufferedPaint, TRUE);
+    EndPaint(m_hwnd, &ps);
+}
+
+void ControlPipe::asyncHandlingLoop()
+{
+    log("Starting loop");
+
+    char buffer[BUFFER_SIZE] = { 0 };
+    DWORD dwRead;
+
+    while (hPipe != INVALID_HANDLE_VALUE)
+    {
+        // will wait for a connection
+        if (ConnectNamedPipe(hPipe, NULL) != FALSE)
+        {
+            while (ReadFile(hPipe, buffer, sizeof(buffer) - 1, &dwRead, NULL) != FALSE)
+            {
+                /* add terminating zero */
+                buffer[dwRead] = '\0';
+                std::string sBuffer((char*)buffer);
+                log("Request: " + sBuffer);
+
+                std::string response = processRequest(sBuffer);
+                log("Response: " + response);
+
+                if (response.size())
+                {
+                    bool out = WriteFile(hPipe,
+                        response.data(),
+                        (DWORD)(response.size()),
+                        &dwRead,
+                        NULL);
+                }
+
+                if (shouldStop)
+                {
+                    log("Detected stop condition");
+                    CloseHandle(hPipe);
+                    hPipe = INVALID_HANDLE_VALUE;
+                    break;
+                }
+            }
+        }
+        DisconnectNamedPipe(hPipe);
+    }
+
+    log("Exited loop");
+}
+
+class TextInfoNullException : public std::exception
+{
+    using std::exception::exception;
+};
+
+TextInfo* verifyTextInfo(TextInfo* textInfo)
+{
+    if (textInfo == NULL)
+    { 
+        throw TextInfoNullException("TextInfo was NULL");
+    }
+    return textInfo;
+}
+
+std::string ControlPipe::processRequest(std::string message)
+{
+    // std::string ret = "BadCommand";
+    auto lineSplit = split(message, TRANSPORT_DELIM[0]);
+
+    // Do not use __textInfo directly... it may be NULL. Use GET_TEXT_INFO, which will throw if NULL.
+    auto __textInfo = getTextInfoTarget();
+    #define GET_TEXT_INFO() verifyTextInfo(__textInfo)
+
+    Response response;
+    
+    try
+    {
+        if (lineSplit.size())
+        {
+            if (lineSplit[0] == "GET")
+            {
+                if (lineSplit[1] == "WIDTH")
+                {
+                    RECT rc;
+                    GetClientRect(deskband->m_hwnd, &rc);
+                    response.addField(std::to_string(rc.right - rc.left));
+                }
+                else if (lineSplit[1] == "HEIGHT")
+                {
+                    RECT rc;
+                    GetClientRect(deskband->m_hwnd, &rc);
+                    response.addField(std::to_string(rc.bottom - rc.top));
+                }
+                else if (lineSplit[1] == "TEXTSIZE")
+                {
+                    auto size = getTextSize(lineSplit[2]);
+                    response.addField(std::to_string(size.cx));
+                    response.addField(std::to_string(size.cy));
+                }
+                else if (lineSplit[1] == "TEXTINFOCOUNT")
+                {
+                    response.addField(std::to_string(textInfos.size()));
+                }
+                else if (lineSplit[1] == "TEXTINFO_TARGET")
+                {
+                    if (textInfoTarget)
+                    {
+                        response.addField(std::to_string(*textInfoTarget));
+                    }
+                    else
+                    {
+                        response.addField("None");
+                    }
+                }
+                else if (lineSplit[1] == "RGB")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    response.addField(std::to_string(textInfo->red));
+                    response.addField(std::to_string(textInfo->green));
+                    response.addField(std::to_string(textInfo->blue));
+                }
+                else if (lineSplit[1] == "TEXT")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    response.addField(textInfo->text);
+                }
+                else if (lineSplit[1] == "XY")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    response.addField(std::to_string(textInfo->rect.left));
+                    response.addField(std::to_string(textInfo->rect.top));
+                }
+                else if (lineSplit[1] == "TRANSPORT_VERSION")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    response.addField("1");
+                }
+            }
+            else if (lineSplit[0] == "SET")
+            {
+                if (lineSplit[1] == "RGB")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    textInfo->red = std::stoi(lineSplit[2]);
+                    textInfo->green = std::stoi(lineSplit[3]);
+                    textInfo->blue = std::stoi(lineSplit[4]);
+                    response.setOk();
+                }
+                else if (lineSplit[1] == "TEXT")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+                    textInfo->text = std::string(lineSplit[2]);
+                    response.setOk();
+                }
+                else if (lineSplit[1] == "XY")
+                {
+                    auto textInfo = GET_TEXT_INFO();
+
+                    // xy from top left
+                    textInfo->rect.left = std::stol(lineSplit[2]);
+                    textInfo->rect.top = std::stol(lineSplit[3]);
+                    response.setOk();
+                }
+                else if (lineSplit[1] == "WIN_MSG")
+                {
+                    // set a (not already handled) Windows Message control to call something
+                    auto msg = std::stoi(lineSplit[2]);
+                    if (lineSplit.size() < 4)
+                    {
+                        if (msgToAction.find(msg) != msgToAction.end())
+                        {
+                            msgToAction.erase(msg);
+                            response.setOk();
+                        }
+                        else
+                        {
+                            response.setStatus("MSG_NOT_FOUND");
+                        }
+                    }
+                    else
+                    {
+                        auto sysCall = std::string(lineSplit[3]);
+                        msgToAction[msg] = sysCall;
+                        response.setOk();
+                    }
+                }
+                else if (lineSplit[1] == "TEXTINFO_TARGET")
+                {
+                    if (lineSplit.size() == 3)
+                    {
+                        textInfoTarget = (size_t)std::stoull(lineSplit[2]);
+                        log("Set textInfoTarget to: " + std::to_string(*textInfoTarget));
+                    }
+                    else
+                    {
+                        textInfoTarget.reset();
+                        log("Set textInfoTarget to: <reset>");
+                    }
+                    response.setOk();
+                }
+                else if (lineSplit[1] == "LOGGING_ENABLED")
+                {
+                    setLoggingEnabled((bool)std::stoi(lineSplit[2]));
+                    response.setOk();
+                }
+            }
+            else if (lineSplit[0] == "NEW_TEXTINFO")
+            {
+                textInfos.push_back(TextInfo());
+                response.setOk();
+            }
+            else if (lineSplit[0] == "PAINT")
+            {
+                InvalidateRect(deskband->m_hwnd, NULL, true);
+                response.setOk();
+            }
+            else if (lineSplit[0] == "CLEAR")
+            {
+                textInfos.clear();
+                InvalidateRect(deskband->m_hwnd, NULL, true);
+                response.setOk();
+            }
+            else if (lineSplit[0] == "STOP")
+            {
+                shouldStop = true;
+                response.setOk();
+            }
+            else if (lineSplit[0] == "SENDMESSAGE")
+            {
+                SendMessage(deskband->m_hwnd, std::stoi(lineSplit[1]), 0, 0);
+                response.setOk();
+            }
+        }
+    }
+    catch (TextInfoNullException)
+    {
+        response.setStatus("TextInfoTargetInvalid");
+    }
+
+    return response.toString();
+}
+
+SIZE ControlPipe::getTextSize(const std::string& text)
+{
+    HDC dc = GetDC(deskband->m_hwnd);
+    SIZE sz = { 0 };
+    GetTextExtentPoint32A(dc, text.c_str(), (int)text.size(), &sz);
+    ReleaseDC(deskband->m_hwnd, dc);
+    return sz;
+}
+
+TextInfo* ControlPipe::getTextInfoTarget()
+{
+    if (textInfos.size() == 0)
+    {
+        textInfos.push_back(TextInfo());
+    }
+
+    // get a ref to the last text info
+    auto textInfo = &textInfos[textInfos.size() - 1];
+
+    // swap that ref if textInfoTarget is set.
+    if (textInfoTarget)
+    {
+        if (*textInfoTarget < textInfos.size())
+        {
+            textInfo = &textInfos[*textInfoTarget];
+        }
+        else
+        {
+            log("Out of bounds text info target: " + std::to_string(*textInfoTarget));
+            textInfo = NULL;
+        }
+    }
+
+    return textInfo;
+}
+
+std::string TextInfo::toString()
+{
+    std::string retString = "";
+    retString += "TextInfo\n";
+    retString += "  Red:      " + std::to_string(red) + "\n";
+    retString += "  Green:    " + std::to_string(green) + "\n";
+    retString += "  Blue:     " + std::to_string(blue) + "\n";
+    retString += "  Rect:\n";
+    retString += "    Left:   " + std::to_string(rect.left) + "\n";
+    retString += "    Top:    " + std::to_string(rect.top) + "\n";
+    retString += "    Right:  " + std::to_string(rect.right) + "\n";
+    retString += "    Bottom: " + std::to_string(rect.bottom) + "\n";
+    retString += "  Text:     " + text + "\n";
+    return retString;
+}
+
+Response::Response()
+{
+    status = "BadCommand";
+}
+
+void Response::addField(std::string field)
+{
+    fields.push_back(field);
+    status = "OK";
+}
+
+void Response::setStatus(std::string status)
+{
+    this->status = status;
+}
+
+void Response::setOk()
+{
+    status = "OK";
+}
+
+std::string Response::toString()
+{
+    std::string ret = status + TRANSPORT_DELIM;
+    for (auto& field : fields)
+    {
+        ret += field + TRANSPORT_DELIM;
+    }
+
+    return ret + "\n";
+}

PyDeskband/dll/PyDeskband/PyDeskband/ControlPipe.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <Windows.h>
+#include <thread>
+#include <string>
+#include <vector>
+#include <map>
+#include <optional>
+
+class CDeskBand;
+
+struct TextInfo
+{
+	TextInfo()
+	{
+		memset(this, 0, sizeof(TextInfo));
+	}
+
+	unsigned red;
+	unsigned green;
+	unsigned blue;
+
+	std::string text;
+	RECT rect;
+
+	std::string toString();
+};
+
+class Response
+{
+public:
+	Response();
+
+	void addField(std::string field);
+	void setStatus(std::string status);
+	void setOk();
+
+	std::string toString();
+private:
+	std::string status;
+	std::vector<std::string> fields;
+};
+
+class ControlPipe
+{
+public:
+	ControlPipe(CDeskBand* d);
+	~ControlPipe();
+
+	DWORD msgHandler(DWORD msg);
+
+	void paintAllTextInfos();
+
+private:
+
+	void asyncHandlingLoop();
+	std::string processRequest(std::string message);
+
+	HANDLE hPipe;
+	std::thread asyncResponseThread;
+	CDeskBand* deskband;
+
+	std::vector<TextInfo> textInfos;
+	std::map<DWORD, std::string> msgToAction;
+	bool shouldStop;
+
+	SIZE getTextSize(const std::string &text);
+	std::optional<size_t> textInfoTarget;
+
+	TextInfo* getTextInfoTarget();
+};
+#pragma once

PyDeskband/dll/PyDeskband/PyDeskband/Deskband.cpp

@@ -0,0 +1,403 @@
+#include "DeskBand.h"
+#include "Logger.h"
+
+#include <windows.h>
+#include <uxtheme.h>
+#include <string>
+#include <thread>
+
+extern ULONG        g_cDllRef;
+extern HINSTANCE    g_hInst;
+
+extern CLSID CLSID_PyDeskBand;
+
+static const WCHAR g_szDeskBandSampleClass[] = L"PyDeskband";
+
+
+CDeskBand::CDeskBand() :
+    m_cRef(1), m_pSite(NULL), m_fHasFocus(FALSE), m_fIsDirty(FALSE), m_dwBandID(0), m_hwnd(NULL), m_hwndParent(NULL)
+{
+    m_controlPipe = std::make_unique<ControlPipe>(this);
+}
+
+CDeskBand::~CDeskBand()
+{
+    if (m_pSite)
+    {
+        m_pSite->Release();
+    }
+}
+
+//
+// IUnknown
+//
+STDMETHODIMP CDeskBand::QueryInterface(REFIID riid, void** ppv)
+{
+    HRESULT hr = S_OK;
+
+    if (IsEqualIID(IID_IUnknown, riid) ||
+        IsEqualIID(IID_IOleWindow, riid) ||
+        IsEqualIID(IID_IDockingWindow, riid) ||
+        IsEqualIID(IID_IDeskBand, riid) ||
+        IsEqualIID(IID_IDeskBand2, riid))
+    {
+        *ppv = static_cast<IOleWindow*>(this);
+    }
+    else if (IsEqualIID(IID_IPersist, riid) ||
+        IsEqualIID(IID_IPersistStream, riid))
+    {
+        *ppv = static_cast<IPersist*>(this);
+    }
+    else if (IsEqualIID(IID_IObjectWithSite, riid))
+    {
+        *ppv = static_cast<IObjectWithSite*>(this);
+    }
+    else if (IsEqualIID(IID_IInputObject, riid))
+    {
+        *ppv = static_cast<IInputObject*>(this);
+    }
+    else
+    {
+        hr = E_NOINTERFACE;
+        *ppv = NULL;
+    }
+
+    if (*ppv)
+    {
+        AddRef();
+    }
+
+    return hr;
+}
+
+STDMETHODIMP_(ULONG) CDeskBand::AddRef()
+{
+    return InterlockedIncrement(&m_cRef);
+}
+
+STDMETHODIMP_(ULONG) CDeskBand::Release()
+{
+    ULONG cRef = InterlockedDecrement(&m_cRef);
+    if (0 == cRef)
+    {
+        delete this;
+    }
+
+    return cRef;
+}
+
+//
+// IOleWindow
+//
+STDMETHODIMP CDeskBand::GetWindow(HWND* phwnd)
+{
+    *phwnd = m_hwnd;
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::ContextSensitiveHelp(BOOL)
+{
+    return E_NOTIMPL;
+}
+
+//
+// IDockingWindow
+//
+STDMETHODIMP CDeskBand::ShowDW(BOOL fShow)
+{
+    if (m_hwnd)
+    {
+        ShowWindow(m_hwnd, fShow ? SW_SHOW : SW_HIDE);
+    }
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::CloseDW(DWORD)
+{
+    if (m_hwnd)
+    {
+        ShowWindow(m_hwnd, SW_HIDE);
+        DestroyWindow(m_hwnd);
+        m_hwnd = NULL;
+    }
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::ResizeBorderDW(const RECT*, IUnknown*, BOOL)
+{
+    return E_NOTIMPL;
+}
+
+//
+// IDeskBand
+//
+STDMETHODIMP CDeskBand::GetBandInfo(DWORD dwBandID, DWORD, DESKBANDINFO* pdbi)
+{
+    HRESULT hr = E_INVALIDARG;
+
+    if (pdbi)
+    {
+        m_dwBandID = dwBandID;
+
+        if (pdbi->dwMask & DBIM_MINSIZE)
+        {
+            pdbi->ptMinSize.x = 100;
+            pdbi->ptMinSize.y = 10;
+        }
+
+        if (pdbi->dwMask & DBIM_MAXSIZE)
+        {
+            pdbi->ptMaxSize.y = -1;
+        }
+
+        if (pdbi->dwMask & DBIM_INTEGRAL)
+        {
+            pdbi->ptIntegral.y = 1;
+        }
+
+        if (pdbi->dwMask & DBIM_ACTUAL)
+        {
+            pdbi->ptActual.x = 200;
+            pdbi->ptActual.y = 30;
+        }
+
+        if (pdbi->dwMask & DBIM_TITLE)
+        {
+            // Don't show title by removing this flag.
+            pdbi->dwMask &= ~DBIM_TITLE;
+        }
+
+        if (pdbi->dwMask & DBIM_MODEFLAGS)
+        {
+            pdbi->dwModeFlags = DBIMF_NORMAL | DBIMF_VARIABLEHEIGHT;
+        }
+
+        if (pdbi->dwMask & DBIM_BKCOLOR)
+        {
+            // Use the default background color by removing this flag.
+            pdbi->dwMask &= ~DBIM_BKCOLOR;
+        }
+
+        hr = S_OK;
+    }
+
+    return hr;
+}
+
+//
+// IDeskBand2
+//
+STDMETHODIMP CDeskBand::CanRenderComposited(BOOL* pfCanRenderComposited)
+{
+    *pfCanRenderComposited = TRUE;
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::SetCompositionState(BOOL fCompositionEnabled)
+{
+    m_fCompositionEnabled = fCompositionEnabled;
+
+    InvalidateRect(m_hwnd, NULL, TRUE);
+    UpdateWindow(m_hwnd);
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::GetCompositionState(BOOL* pfCompositionEnabled)
+{
+    *pfCompositionEnabled = m_fCompositionEnabled;
+
+    return S_OK;
+}
+
+//
+// IPersist
+//
+STDMETHODIMP CDeskBand::GetClassID(CLSID* pclsid)
+{
+    *pclsid = CLSID_PyDeskBand;
+    return S_OK;
+}
+
+//
+// IPersistStream
+//
+STDMETHODIMP CDeskBand::IsDirty()
+{
+    return m_fIsDirty ? S_OK : S_FALSE;
+}
+
+STDMETHODIMP CDeskBand::Load(IStream* /*pStm*/)
+{
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::Save(IStream* /*pStm*/, BOOL fClearDirty)
+{
+    if (fClearDirty)
+    {
+        m_fIsDirty = FALSE;
+    }
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::GetSizeMax(ULARGE_INTEGER* /*pcbSize*/)
+{
+    return E_NOTIMPL;
+}
+
+//
+// IObjectWithSite
+//
+STDMETHODIMP CDeskBand::SetSite(IUnknown* pUnkSite)
+{
+    HRESULT hr = S_OK;
+
+    m_hwndParent = NULL;
+
+    if (m_pSite)
+    {
+        m_pSite->Release();
+    }
+
+    if (pUnkSite)
+    {
+        IOleWindow* pow;
+        hr = pUnkSite->QueryInterface(IID_IOleWindow, reinterpret_cast<void**>(&pow));
+        if (SUCCEEDED(hr))
+        {
+            hr = pow->GetWindow(&m_hwndParent);
+            if (SUCCEEDED(hr))
+            {
+                WNDCLASSW wc = { 0 };
+                wc.style = CS_HREDRAW | CS_VREDRAW;
+                wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+                wc.hInstance = g_hInst;
+                wc.lpfnWndProc = WndProc;
+                wc.lpszClassName = g_szDeskBandSampleClass;
+                wc.hbrBackground = NULL; // done to make it so the background is transparent //CreateSolidBrush(RGB(255, 255, 0));
+
+                RegisterClassW(&wc);
+
+                CreateWindowExW(0,
+                    g_szDeskBandSampleClass,
+                    NULL,
+                    WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+                    0,
+                    0,
+                    0,
+                    0,
+                    m_hwndParent,
+                    NULL,
+                    g_hInst,
+                    this);
+
+                if (!m_hwnd)
+                {
+                    hr = E_FAIL;
+                }
+            }
+
+            pow->Release();
+        }
+
+        hr = pUnkSite->QueryInterface(IID_IInputObjectSite, reinterpret_cast<void**>(&m_pSite));
+    }
+
+    return hr;
+}
+
+STDMETHODIMP CDeskBand::GetSite(REFIID riid, void** ppv)
+{
+    HRESULT hr = E_FAIL;
+
+    if (m_pSite)
+    {
+        hr = m_pSite->QueryInterface(riid, ppv);
+    }
+    else
+    {
+        *ppv = NULL;
+    }
+
+    return hr;
+}
+
+//
+// IInputObject
+//
+STDMETHODIMP CDeskBand::UIActivateIO(BOOL fActivate, MSG*)
+{
+    if (fActivate)
+    {
+        SetFocus(m_hwnd);
+    }
+
+    return S_OK;
+}
+
+STDMETHODIMP CDeskBand::HasFocusIO()
+{
+    return m_fHasFocus ? S_OK : S_FALSE;
+}
+
+STDMETHODIMP CDeskBand::TranslateAcceleratorIO(MSG*)
+{
+    return S_FALSE;
+};
+
+void CDeskBand::OnFocus(const BOOL fFocus)
+{
+    m_fHasFocus = fFocus;
+
+    if (m_pSite)
+    {
+        m_pSite->OnFocusChangeIS(static_cast<IOleWindow*>(this), m_fHasFocus);
+    }
+}
+
+LRESULT CALLBACK CDeskBand::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+    LRESULT lResult = 0;
+
+    CDeskBand* pDeskBand = reinterpret_cast<CDeskBand*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+
+    switch (uMsg)
+    {
+    case WM_CREATE:
+        pDeskBand = reinterpret_cast<CDeskBand*>(reinterpret_cast<CREATESTRUCT*>(lParam)->lpCreateParams);
+        pDeskBand->m_hwnd = hwnd;
+        SetWindowLongPtr(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(pDeskBand));
+        break;
+
+    case WM_SETFOCUS:
+        pDeskBand->OnFocus(TRUE);
+        break;
+
+    case WM_KILLFOCUS:
+        pDeskBand->OnFocus(FALSE);
+        break;
+
+    case WM_PAINT:
+    case WM_PRINTCLIENT:
+        log("WM_PAINT/WM_PRINTCLIENT");
+        pDeskBand->m_controlPipe->paintAllTextInfos();
+        break;
+    default:
+        if (pDeskBand)
+        {
+            lResult = pDeskBand->m_controlPipe->msgHandler(uMsg);
+        }
+    }
+
+    if (lResult == 0)
+    {
+        lResult = DefWindowProc(hwnd, uMsg, wParam, lParam);
+    }
+
+    return lResult;
+}

PyDeskband/dll/PyDeskband/PyDeskband/Deskband.h

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "ControlPipe.h"
+
+#include <windows.h>
+#include <shlobj.h> // for IDeskband2, IObjectWithSite, IPesistStream, and IInputObject
+#include <thread>
+#include <string>
+#include <memory>
+#include <mutex>
+#include <fstream>
+
+#define RECTWIDTH(x)   ((x).right - (x).left)
+#define RECTHEIGHT(x)  ((x).bottom - (x).top)
+
+class CDeskBand : public IDeskBand2,
+    public IPersistStream,
+    public IObjectWithSite,
+    public IInputObject
+{
+public:
+    // IUnknown
+    STDMETHODIMP QueryInterface(REFIID riid, void** ppv);
+    STDMETHODIMP_(ULONG) AddRef();
+    STDMETHODIMP_(ULONG) Release();
+
+    // IOleWindow
+    STDMETHODIMP GetWindow(HWND* phwnd);
+    STDMETHODIMP ContextSensitiveHelp(BOOL);
+
+    // IDockingWindow
+    STDMETHODIMP ShowDW(BOOL fShow);
+    STDMETHODIMP CloseDW(DWORD);
+    STDMETHODIMP ResizeBorderDW(const RECT*, IUnknown*, BOOL);
+
+    // IDeskBand (needed for all deskbands)
+    STDMETHODIMP GetBandInfo(DWORD dwBandID, DWORD, DESKBANDINFO* pdbi);
+
+    // IDeskBand2 (needed for glass deskband)
+    STDMETHODIMP CanRenderComposited(BOOL* pfCanRenderComposited);
+    STDMETHODIMP SetCompositionState(BOOL fCompositionEnabled);
+    STDMETHODIMP GetCompositionState(BOOL* pfCompositionEnabled);
+
+    // IPersist
+    STDMETHODIMP GetClassID(CLSID* pclsid);
+
+    // IPersistStream
+    STDMETHODIMP IsDirty();
+    STDMETHODIMP Load(IStream* pStm);
+    STDMETHODIMP Save(IStream* pStm, BOOL fClearDirty);
+    STDMETHODIMP GetSizeMax(ULARGE_INTEGER* pcbSize);
+
+    // IObjectWithSite
+    STDMETHODIMP SetSite(IUnknown* pUnkSite);
+    STDMETHODIMP GetSite(REFIID riid, void** ppv);
+
+    // IInputObject
+    STDMETHODIMP UIActivateIO(BOOL fActivate, MSG*);
+    STDMETHODIMP HasFocusIO();
+    STDMETHODIMP TranslateAcceleratorIO(MSG*);
+
+    CDeskBand();
+
+    HWND                m_hwnd;                 // main window of deskband
+    BOOL                m_fCompositionEnabled;  // whether glass is currently enabled in deskband
+
+protected:
+    ~CDeskBand();
+
+    static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+    void OnFocus(const BOOL fFocus);
+
+private:
+    LONG                m_cRef;                 // ref count of deskband
+    IInputObjectSite* m_pSite;                // parent site that contains deskband
+    BOOL                m_fHasFocus;            // whether deskband window currently has focus
+    BOOL                m_fIsDirty;             // whether deskband setting has changed
+    DWORD               m_dwBandID;             // ID of deskband
+    HWND                m_hwndParent;           // parent window of deskband
+    std::unique_ptr<ControlPipe> m_controlPipe;
+};
+

PyDeskband/dll/PyDeskband/PyDeskband/DllMain.cpp

@@ -0,0 +1,158 @@
+#include "ClassFactory.h" // for the class factory
+
+#include <windows.h>
+#include <strsafe.h> // for StringCchXXX functions
+#include <olectl.h> // for SELFREG_E_CLASS
+#include <shlobj.h> // for ICatRegister
+
+// {662A9E71-5B66-4C41-B4EE-306355846F44}
+CLSID CLSID_PyDeskBand = { 0x662A9E71, 0x5B66, 0x4C41, {0xB4, 0xEE, 0x30, 0x63, 0x55, 0x84, 0x6F, 0x44} };
+
+
+HINSTANCE   g_hInst = NULL;
+long        g_cDllRef = 0;
+
+STDAPI_(BOOL) DllMain(HINSTANCE hInstance, DWORD dwReason, void* lpvReserved)
+{
+    if (dwReason == DLL_PROCESS_ATTACH)
+    {
+        g_hInst = hInstance;
+        DisableThreadLibraryCalls(hInstance);
+    }
+    return TRUE;
+}
+
+STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void** ppv)
+{
+    HRESULT hr = CLASS_E_CLASSNOTAVAILABLE;
+
+    if (IsEqualCLSID(CLSID_PyDeskBand, rclsid))
+    {
+        hr = E_OUTOFMEMORY;
+
+        CClassFactory* pClassFactory = new CClassFactory();
+        if (pClassFactory)
+        {
+            hr = pClassFactory->QueryInterface(riid, ppv);
+            pClassFactory->Release();
+        }
+    }
+
+    return hr;
+}
+
+STDAPI DllCanUnloadNow()
+{
+    return g_cDllRef > 0 ? S_FALSE : S_OK;
+}
+
+HRESULT RegisterServer()
+{
+    WCHAR szCLSID[MAX_PATH];
+    StringFromGUID2(CLSID_PyDeskBand, szCLSID, ARRAYSIZE(szCLSID));
+
+    WCHAR szSubkey[MAX_PATH];
+    HKEY hKey;
+
+    HRESULT hr = StringCchPrintfW(szSubkey, ARRAYSIZE(szSubkey), L"CLSID\\%s", szCLSID);
+    if (SUCCEEDED(hr))
+    {
+        hr = E_FAIL;
+        if (ERROR_SUCCESS == RegCreateKeyExW(HKEY_CLASSES_ROOT,
+            szSubkey,
+            0,
+            NULL,
+            REG_OPTION_NON_VOLATILE,
+            KEY_WRITE,
+            NULL,
+            &hKey,
+            NULL))
+        {
+            WCHAR const szName[] = L"PyDeskband";
+            if (ERROR_SUCCESS == RegSetValueExW(hKey,
+                NULL,
+                0,
+                REG_SZ,
+                (LPBYTE)szName,
+                sizeof(szName)))
+            {
+                hr = S_OK;
+            }
+
+            RegCloseKey(hKey);
+        }
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        hr = StringCchPrintfW(szSubkey, ARRAYSIZE(szSubkey), L"CLSID\\%s\\InprocServer32", szCLSID);
+        if (SUCCEEDED(hr))
+        {
+            hr = HRESULT_FROM_WIN32(RegCreateKeyExW(HKEY_CLASSES_ROOT, szSubkey,
+                0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL));
+            if (SUCCEEDED(hr))
+            {
+                WCHAR szModule[MAX_PATH];
+                if (GetModuleFileNameW(g_hInst, szModule, ARRAYSIZE(szModule)))
+                {
+                    DWORD cch = lstrlen(szModule);
+                    hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, NULL, 0, REG_SZ, (LPBYTE)szModule, cch * sizeof(szModule[0])));
+                }
+
+                if (SUCCEEDED(hr))
+                {
+                    WCHAR const szModel[] = L"Apartment";
+                    hr = HRESULT_FROM_WIN32(RegSetValueExW(hKey, L"ThreadingModel", 0, REG_SZ, (LPBYTE)szModel, sizeof(szModel)));
+                }
+
+                RegCloseKey(hKey);
+            }
+        }
+    }
+
+    return hr;
+}
+
+HRESULT RegisterComCat()
+{
+    ICatRegister* pcr;
+    HRESULT hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pcr));
+    if (SUCCEEDED(hr))
+    {
+        CATID catid = CATID_DeskBand;
+        hr = pcr->RegisterClassImplCategories(CLSID_PyDeskBand, 1, &catid);
+        pcr->Release();
+    }
+    return hr;
+}
+
+STDAPI DllRegisterServer()
+{
+    // Register the deskband object.
+    HRESULT hr = RegisterServer();
+    if (SUCCEEDED(hr))
+    {
+        // Register the component category for the deskband object.
+        hr = RegisterComCat();
+    }
+
+    return SUCCEEDED(hr) ? S_OK : SELFREG_E_CLASS;
+}
+
+STDAPI DllUnregisterServer()
+{
+    WCHAR szCLSID[MAX_PATH];
+    StringFromGUID2(CLSID_PyDeskBand, szCLSID, ARRAYSIZE(szCLSID));
+
+    WCHAR szSubkey[MAX_PATH];
+    HRESULT hr = StringCchPrintfW(szSubkey, ARRAYSIZE(szSubkey), L"CLSID\\%s", szCLSID);
+    if (SUCCEEDED(hr))
+    {
+        if (ERROR_SUCCESS != RegDeleteTreeW(HKEY_CLASSES_ROOT, szSubkey))
+        {
+            hr = E_FAIL;
+        }
+    }
+
+    return SUCCEEDED(hr) ? S_OK : SELFREG_E_CLASS;
+}

PyDeskband/dll/PyDeskband/PyDeskband/Logger.cpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "Logger.h"
+
+#include <atomic>
+#include <filesystem>
+#include <fstream>
+#include <mutex>
+
+static std::mutex logMutex;
+static std::atomic<bool> loggingEnabled = false;
+
+void log(const std::string& s)
+{
+	if (loggingEnabled)
+	{
+		logMutex.lock();
+		auto logFilePath = (std::filesystem::temp_directory_path() / "pydeskband.log");
+		std::ofstream outfile;
+		outfile.open(logFilePath, std::ios_base::app);
+		outfile << s << std::endl;
+		logMutex.unlock();
+	}
+}
+
+void setLoggingEnabled(bool enabled)
+{
+	loggingEnabled = enabled;
+}

PyDeskband/dll/PyDeskband/PyDeskband/Logger.h

@@ -0,0 +1,6 @@
+#pragma once
+
+#include <string>
+
+void log(const std::string& s);
+void setLoggingEnabled(bool enabled);

PyDeskband/dll/PyDeskband/PyDeskband/PyDeskband.def

@@ -0,0 +1,5 @@
+EXPORTS
+    DllGetClassObject   PRIVATE
+    DllCanUnloadNow     PRIVATE
+    DllRegisterServer   PRIVATE
+    DllUnregisterServer PRIVATE

PyDeskband/dll/PyDeskband/PyDeskband/PyDeskband.vcxproj

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{f98f92cd-fefd-4961-8193-f6881e6ce92e}</ProjectGuid>
+    <RootNamespace>PyDeskband</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions); _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>uxtheme.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>PyDeskband.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions); _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>uxtheme.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>PyDeskband.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions); _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>uxtheme.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>PyDeskband.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions); _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>uxtheme.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <ModuleDefinitionFile>PyDeskband.def</ModuleDefinitionFile>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="ClassFactory.cpp" />
+    <ClCompile Include="ControlPipe.cpp" />
+    <ClCompile Include="Deskband.cpp" />
+    <ClCompile Include="DllMain.cpp" />
+    <ClCompile Include="Logger.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="ClassFactory.h" />
+    <ClInclude Include="ControlPipe.h" />
+    <ClInclude Include="Deskband.h" />
+    <ClInclude Include="Logger.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="PyDeskband.def" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

PyDeskband/dll/PyDeskband/PyDeskband/PyDeskband.vcxproj.filters

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="DllMain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Logger.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ClassFactory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Deskband.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ControlPipe.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="Logger.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ClassFactory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Deskband.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ControlPipe.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="PyDeskband.def">
+      <Filter>Source Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>

PyDeskband/dll/PyDeskband/PyDeskband/PyDeskband.vcxproj.user

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>

PyDeskband/pydeskband/__init__.py

@@ -0,0 +1,3 @@
+from .pydeskband import ControlPipe
+
+__version__ = '0.0.1'

PyDeskband/pydeskband/pydeskband.py

@@ -0,0 +1,408 @@
+import contextlib
+import enum
+import os
+import pathlib
+import sys
+import time
+
+from dataclasses import dataclass
+from threading import Thread, Event
+from typing import Union, TypeVar
+
+@dataclass
+class Size:
+    ''' A Python-version of the SIZE struct in WinApi '''
+    x: int
+    y: int
+
+@dataclass
+class Color:
+    ''' Representation of an RGB color '''
+    red: int
+    green: int
+    blue: int
+
+class _LogTailer(Thread):
+    ''' A Thread that can follow/print new lines in the pydeskband log file (which is written by the DLL) '''
+    LOG_PATH = pathlib.Path(os.path.expandvars('%TEMP%/pydeskband.log'))
+    def __init__(self):
+        self.exit_event = Event()
+
+        if not _LogTailer.LOG_PATH.is_file():
+            raise FileNotFoundError("PyDeskband log was not found")
+
+        self.starting_offset = _LogTailer.LOG_PATH.stat().st_size
+
+        Thread.__init__(self, daemon=True)
+
+    def run(self):
+        ''' Ran in the other thread. Will effectively 'tail -f' the log file and print to stderr the new lines '''
+        try:
+            with open(_LogTailer.LOG_PATH, 'rb') as log_file:
+                log_file.seek(self.starting_offset)
+                while not self.exit_event.is_set():
+                    line = log_file.readline().rstrip().decode()
+                    if line:
+                        print(line, file=sys.stderr)
+                    time.sleep(.01)
+        except KeyboardInterrupt:
+            pass
+
+class ControlPipe:
+    ''' The mechanism for controlling PyDeskband.'''
+    def __init__(self):
+        ''' Note that this may raise if PyDeskband is not in use '''
+        try:
+            self.pipe = open('\\\\.\\pipe\\PyDeskbandControlPipe', 'r+b', buffering=0)
+        except FileNotFoundError as ex:
+            raise FileNotFoundError(f"The PyDeskbandControlPipe is not available. Is the deskband enabled?.. {str(ex)}")
+        self._log_tailer = None
+
+    def __enter__(self):
+        ''' For use as a contextmanager '''
+        return self
+
+    def __exit__(self, type, value, traceback):
+        ''' For use as a contextmanager... Closes the handle to the pipe '''
+        self.pipe.close()
+
+    def send_command(self, cmd:Union[list, tuple, str], check_ok:bool=True) -> list:
+        '''
+        The main entry point to go from Python to/from the C++ code. It is very unlikely that a regular user
+        would want to call this directly. If something is done incorrectly here, PyDeskband will likely crash...
+            and that will lead to Windows Explorer restarting.
+
+        Arguments:
+            cmd: Either a list of command keywords or a string of a full command
+            check_ok: If True, raise ValueError if C++ does not give back "OK" as the return status.
+                If set, will remove OK from the return list.
+
+        Returns:
+            A list of return fields.
+        '''
+        if isinstance(cmd, (list, tuple)):
+            cmd = ','.join([str(c) for c in cmd])
+
+        cmd = cmd.encode()
+
+        bytes_written = self.pipe.write(cmd)
+        if bytes_written != len(cmd):
+            raise RuntimeError(f"Unable to write all the bytes down the pipe. Wrote: {bytes_written} instead of {len(cmd)}")
+
+        response = self.pipe.readline().strip().decode().split(',')
+
+        if not response:
+            raise ValueError("Response was empty.")
+
+        if check_ok:
+            if response[0] != 'OK':
+                raise ValueError(f"Response was not OK. It was: {response[0]}")
+            response = response[1:]
+
+        return response
+
+    def get_width(self) -> int:
+        ''' Get the current width (in pixels) of the deskband '''
+        return int(self.send_command(['GET', 'WIDTH'])[0])
+
+    def get_height(self) -> int:
+        ''' Get the current height (in pixels) of the deskband '''
+        return int(self.send_command(['GET', 'HEIGHT'])[0])
+
+    def get_text_info_count(self) -> int:
+        ''' Get the count of TextInfos currently saved '''
+        return int(self.send_command(['GET', 'TEXTINFOCOUNT'])[0])
+
+    def add_new_text_info(self, text:str, x:int=0, y:int=0, red:int=255, green:int=255, blue:int=255) -> None:
+        ''' Creates a new TextInfo with the given text,x/y, and rgb text color '''
+        self.send_command('NEW_TEXTINFO')
+        self._set_color(red, green, blue)
+        self._set_coordinates(x, y)
+        self._set_text(text)
+        idx = (self.get_text_info_count() - 1)
+        return TextInfo(self, idx)
+
+    def get_text_size(self, text:str) -> Size:
+        ''' Gets a Size object corresponding with the x,y size this text would be (likely in pixels) '''
+        x, y = self.send_command([
+            'GET', 'TEXTSIZE', self._verify_input_text(text)
+        ])[:2]
+        return Size(int(x), int(y))
+
+    def paint(self) -> None:
+        ''' Requests that PyDeskband repaint all TextInfos now '''
+        self.send_command('PAINT')
+
+    def clear(self, reset_target_textinfo:bool=True) -> None:
+        '''
+        Clears all TextInfos and re-paints.
+
+        If reset_target_textinfo is set, will also reset the current TextInfo target.
+        '''
+        self.send_command('CLEAR')
+        self._set_textinfo_target()
+
+    def set_logging(self, enabled:bool, tail:bool=False) -> None:
+        '''
+        Enables/disables logging in the C++ module. Logging goes to %TEMP%/pydeskband.log.
+        If tail is True, will attempt to tail the output to stderr in Python.
+         '''
+        self.send_command([
+            'SET', 'LOGGING_ENABLED', 1 if enabled else 0
+        ])
+
+        def _stop_log_tailer():
+            if self._log_tailer:
+                self._log_tailer.exit_event.set()
+                self._log_tailer.join()
+                self._log_tailer = None
+
+        if tail:
+            _stop_log_tailer()
+            self._log_tailer = _LogTailer()
+            self._log_tailer.start()
+        else:
+            _stop_log_tailer()
+
+    def get_transport_version(self) -> int:
+        '''
+        Gets the current transport version from the DLL.
+        '''
+        return int(self.send_command([
+            'GET', 'TRANSPORT_VERSION'
+        ])[0])
+
+    def set_windows_message_handle_shell_cmd(self, msg_id:int, shell_cmd:str=None) -> None:
+        ''' Tell PyDeskband that if msg_id is sent to the form, run this shell command. If shell_cmd is None, clear existing handling of the msg_id. '''
+        if shell_cmd is not None:
+            return self.send_command([
+                'SET', 'WIN_MSG', msg_id, self._verify_input_text(shell_cmd)
+            ])
+        else:
+            return self.send_command([
+                'SET', 'WIN_MSG', msg_id
+            ])
+
+    def _send_message(self, msg:int) -> None:
+        ''' Likely only useful for debugging. Send a WM_... message with the given id to our hwnd.'''
+        self.send_command([
+            'SENDMESSAGE', str(msg)
+        ])
+
+    def _verify_input_text(self, text) -> str:
+        ''' Helper function. Verifies that the delimiter is not in the given text. Returns the text if not found. Otherwise raises. '''
+        if ',' in text:
+            raise ValueError(f"text cannot contain a ',' sign. Text: {text}")
+        return text
+
+    def _set_text(self, text:str) -> str:
+        ''' Call to SET TEXT in the DLL '''
+        return self.send_command([
+            'SET', 'TEXT', self._verify_input_text(text)
+        ])
+
+    def _set_color(self, red:int=255, green:int=255, blue:int=255) -> str:
+        ''' Call to SET RGB in the DLL '''
+        return self.send_command([
+            'SET', 'RGB', red, green, blue
+        ])
+
+    def _set_coordinates(self, x:int=0, y:int=0) -> str:
+        ''' Call to SET XY in the DLL '''
+        if x < 0:
+            raise ValueError(f"x cannot be less than 0. It was set to: {x}")
+        if y < 0:
+            raise ValueError(f"y cannot be less than 0. It was set to: {y}")
+
+        return self.send_command([
+            'SET', 'XY', x, y
+        ])
+
+    def _set_textinfo_target(self, idx:Union[int, None]=None) -> str:
+        ''' Call to SET TEXTINFO_TARGET in the DLL. Passing an index of None will lead to the last TextInfo being targeted '''
+        if idx is None:
+            return self.send_command(["SET", "TEXTINFO_TARGET"])
+        else:
+            return self.send_command(["SET", "TEXTINFO_TARGET", str(idx)])
+
+    def _get_text(self) -> str:
+        ''' Call to GET TEXT in the DLL '''
+        return self.send_command(["GET", "TEXT"])[0]
+
+    def _get_color(self) -> Color:
+        ''' Call to GET RGB in the DLL '''
+        r, g, b = self.send_command(["GET", "RGB"])[:3]
+        return Color(int(r), int(g), int(b))
+
+    def _get_coordinates(self) -> Size:
+        ''' Call to GET XY in the DLL '''
+        x, y = self.send_command(["GET", "XY"])[:2]
+        return Size(int(x), int(y))
+
+    def _get_textinfo_target(self) -> Union[int, None]:
+        ''' Call to GET TEXTINFO_TARGET in the DLL. A return of None, means that the current target is the last TextInfo.'''
+        # Cheap use of eval. It can be 'None' or an int.
+        return eval(self.send_command(["GET", "TEXTINFO_TARGET"])[0])
+
+    def _test(self, sleep_time:int=1):
+        ''' a test... :) '''
+        import psutil, time
+
+        def get_mbps_down():
+            last_timestamp = getattr(get_mbps_down, 'last_timestamp', time.time())
+            last_bytes = getattr(get_mbps_down, 'last_bytes', 0)
+
+            get_mbps_down.last_bytes = psutil.net_io_counters().bytes_recv
+
+            now = time.time()
+            mbps = (get_mbps_down.last_bytes - float(last_bytes)) / 125000.0 / max(.0000001, now - last_timestamp)
+            get_mbps_down.last_timestamp = now
+            return mbps
+
+        def get_mbps_up():
+            last_timestamp = getattr(get_mbps_up, 'last_timestamp', time.time())
+            last_bytes = getattr(get_mbps_up, 'last_bytes', 0)
+
+            get_mbps_up.last_bytes = psutil.net_io_counters().bytes_sent
+
+            now = time.time()
+            mbps = (get_mbps_up.last_bytes - float(last_bytes)) / 125000.0 /  max(.0000001, now - last_timestamp)
+            get_mbps_up.last_timestamp = now
+            return mbps
+
+        def get_cpu_used_percent():
+            return psutil.cpu_percent()
+
+        self.clear()
+
+        # Left click: Open task manager
+        self.set_windows_message_handle_shell_cmd(0x0201, r'start C:\Windows\System32\Taskmgr.exe')
+        cpuTextInfo = self.add_new_text_info('CPU:')
+        cpuValueTextInfo = self.add_new_text_info('0%')
+        netDownTextInfo = self.add_new_text_info('')
+        netDownTextInfo.justify_this_with_respect_to_that(cpuTextInfo, Justification.BELOW)
+
+        while True:
+            cpu = get_cpu_used_percent()
+            if cpu < 40:
+                cpuValueTextInfo.set_color(0, 250, 0)
+            elif cpu < 80:
+                cpuValueTextInfo.set_color(0, 250, 150)
+            elif cpu < 90:
+                cpuValueTextInfo.set_color(252, 148, 57)
+            else:
+                cpuValueTextInfo.set_color(250, 0, 0)
+
+            cpuValueTextInfo.set_text(f'{cpu:.02f}%')
+            cpuValueTextInfo.justify_this_with_respect_to_that(cpuTextInfo, Justification.RIGHT_OF)
+            netDownTextInfo.set_text(f'Net: {get_mbps_down():.02f}/{get_mbps_up():.02f} Mbps')
+            self.paint()
+            time.sleep(sleep_time)
+
+class Justification(enum.Enum):
+    LEFT_OF = 'Left of'
+    RIGHT_OF = 'Right of'
+    BELOW = 'Below'
+    ABOVE = 'Above'
+
+class TextInfo:
+    '''
+    Represents a reference to a TextInfo object in the DLL.
+
+    A TextInfo is a specific line/piece of text with a specific X/Y, RGB color, and text.
+    '''
+    def __init__(self, control_pipe:ControlPipe, idx:int):
+        self.controlPipe = control_pipe
+        self._idx = idx
+
+    @contextlib.contextmanager
+    def targeting_this_textinfo(self):
+        previous_target = self.controlPipe._get_textinfo_target()
+        self.controlPipe._set_textinfo_target(self._idx)
+        try:
+            yield
+        finally:
+            self.controlPipe._set_textinfo_target(previous_target)
+
+    def set_text(self, text:str) -> None:
+        ''' Sets the text of this TextInfo '''
+        with self.targeting_this_textinfo():
+            self.controlPipe._set_text(text)
+
+    def set_color(self, red:int=255, green:int=255, blue:int=255) -> None:
+        ''' Sets the color of this TextInfo '''
+        with self.targeting_this_textinfo():
+            self.controlPipe._set_color(red, green, blue)
+
+    def set_coordinates(self, x:int=0, y:int=0) -> None:
+        ''' Sets the X/Y coordinates of this TextInfo '''
+        with self.targeting_this_textinfo():
+            self.controlPipe._set_coordinates(x, y)
+
+    def get_text(self) -> str:
+        ''' Gets the text of this TextInfo '''
+        with self.targeting_this_textinfo():
+            return self.controlPipe._get_text()
+
+    def get_color(self) -> Color:
+        ''' Gets the color of this TextInfo '''
+        with self.targeting_this_textinfo():
+            return self.controlPipe._get_color()
+
+    def get_coordinates(self) -> Size:
+        ''' Gets the X/Y coordinates of this TextInfo '''
+        with self.targeting_this_textinfo():
+            return self.controlPipe._get_coordinates()
+
+    def get_text_size(self) -> Size:
+        ''' Gets the pixel size of the text within this TextInfo '''
+        text = self.get_text()
+        return self.controlPipe.get_text_size(text)
+
+    def justify_this_with_respect_to_that(self, that_text_info:TypeVar('TextInfo'), justify:Justification=Justification.RIGHT_OF, gap:Union[None, int]=None):
+        '''
+        Put this TextInfo to the <justify> of that TextInfo.
+
+        Gap is the distance in pixels between text_infos. If it is None, will be the size of a space (' ') character.
+
+        Only self (this) moves. that_text_info does not move.
+
+        Note that if a coordinate is calculated to be negative (in order to be in the correct spot) it will be set to 0.
+        '''
+        if gap is None:
+            gap = self.controlPipe.get_text_size(' ').x
+
+        that_coordinates = that_text_info.get_coordinates()
+        # that_text_info DOES NOT move. Only self (this) does.
+
+        # Right now things can wind up out of bounds in postive x and y directions.
+        #  We could fix that later if desired.
+
+        if justify == Justification.RIGHT_OF:
+            # THIS THAT
+            that_text_size = that_text_info.get_text_size()
+            new_x = that_coordinates.x + that_text_size.x + gap
+            self.set_coordinates(max(0, new_x), that_coordinates.y)
+        elif justify == Justification.LEFT_OF:
+            # THAT THIS
+            this_text_size = self.get_text_size()
+
+            new_x = that_coordinates.x - this_text_size.x - gap
+            self.set_coordinates(max(0, new_x), that_coordinates.y)
+        elif justify == Justification.BELOW:
+            # THIS
+            # THAT
+            that_text_size = that_text_info.get_text_size()
+            new_y = that_coordinates.y + that_text_size.y + gap
+
+            self.set_coordinates(that_coordinates.x, max(0, new_y))
+
+        elif justify == Justification.ABOVE:
+            # THAT
+            # THIS
+            this_text_size = self.get_text_size()
+            new_y = that_coordinates.y - this_text_size.y - gap
+
+            self.set_coordinates(that_coordinates.x, max(0, new_y))
+        else:
+            raise ValueError("justify must be defined in the Justification enum")

PyDeskband/pydeskband/registrar.py

@@ -0,0 +1,92 @@
+import argparse
+import os
+import ctypes
+import pathlib
+import subprocess
+
+class RegistrarActionRequiresAdmin(PermissionError):
+    ''' Used to denote that this action requires admin permissions '''
+    pass
+
+class Registrar:
+    ''' A collection of methods relating to registering and unregistering PyDeskband via regsvr32.exe '''
+    @classmethod
+    def is_64_bit(cls) -> bool:
+        return '64' in subprocess.check_output([
+            'wmic', 'os', 'get', 'osarchitecture'
+        ]).decode()
+
+    @classmethod
+    def is_admin(cls) -> bool:
+        ''' Asks Windows if we are running as admin '''
+        return bool(ctypes.windll.shell32.IsUserAnAdmin())
+
+    @classmethod
+    def get_dll_path(cls) -> pathlib.Path:
+        ''' Returns the path to the PyDeskband dll for the OS architecture '''
+        arch = '64' if cls.is_64_bit() else '86'
+        dll_path = (pathlib.Path(__file__).parent / f"dlls/PyDeskband_x{arch}.dll").resolve()
+        if not dll_path.is_file():
+            raise FileNotFoundError(f"dll_path: {dll_path} is missing")
+        return dll_path
+
+    @classmethod
+    def get_regsvr32_path(cls) -> pathlib.Path:
+        ''' Returns the path to regsvr32.exe '''
+        path = pathlib.Path(os.path.expandvars(r'%systemroot%\System32\regsvr32.exe'))
+        if not path.is_file():
+            raise FileNotFoundError(f"regsvr32.exe {path} is missing")
+        return path
+
+    @classmethod
+    def register(cls) -> int:
+        '''
+        Attempts to register the PyDeskband DLL with the OS. Will return the exit code from that attempt. 0 typically means success.
+        Requires admin privledges to run.
+
+        Funny enough, on register, you may need to view right click and view the Toolbars list twice before the option PyDeskband option comes up.
+            (This is even if you restart Windows Explorer). This is a known Windows behavior and not a bug with PyDeskband.
+        '''
+        if not cls.is_admin():
+            raise RegistrarActionRequiresAdmin("Registering pyDeskband requires admin permissions!")
+
+        return subprocess.call([cls.get_regsvr32_path(), cls.get_dll_path(), '/s'])
+
+    @classmethod
+    def unregister(cls) -> int:
+        '''
+        Attempts to unregister the PyDeskband DLL with the OS. Will return the exit code from that attempt. 0 typically means success.
+        Requires admin privledges to run.
+        '''
+        if not cls.is_admin():
+            raise RegistrarActionRequiresAdmin("Unregistering pyDeskband requires admin permissions!")
+
+        return subprocess.call([cls.get_regsvr32_path(), '/u', cls.get_dll_path(), '/s'])
+
+    @classmethod
+    def restart_windows_explorer(cls) -> None:
+        '''
+        Uses the knowledge of us being on Windows to use a subprocess to restart Windows Explorer.
+
+        Technically a Windows Explorer restart is not necessary though on an unregister, it will force the dll to be unloaded.
+        '''
+        subprocess.call('taskkill /F /IM explorer.exe && start explorer', shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="CLI to register/unregister PyDeskband with the registry")
+    action = parser.add_mutually_exclusive_group()
+    action.add_argument('-r', '--register', help='Registers the PyDeskband DLL with the OS.', action='store_true')
+    action.add_argument('-u', '--unregister', help='Unregisters the PyDeskband DLL with the OS. Unless -x/--no-restart-explorer is given, Windows Explorer will restart after success.', action='store_true')
+    parser.add_argument('-x', '--no-restart-explorer', help='If given, do not restart Windows Explorer after registering or unregistering.', action='store_true')
+    args = parser.parse_args()
+
+    ret_code = None
+    if args.register:
+        ret_code = Registrar.register()
+    elif args.unregister:
+        ret_code = Registrar.unregister()
+
+    if ret_code is not None:
+        if ret_code == 0 and not args.no_restart_explorer:
+            Registrar.restart_windows_explorer()
+        exit(ret_code)

PyDeskband/setup.py

@@ -0,0 +1,114 @@
+from setuptools import setup
+from setuptools.command.build_py import build_py
+
+import glob
+import os
+import pathlib
+import shutil
+import subprocess
+import sys
+
+if os.name != 'nt':
+    raise EnvironmentError(f"This is only supported on Windows... not for: {os.name}")
+
+THIS_FOLDER = os.path.abspath(os.path.dirname(__file__))
+
+def getVersion() -> str:
+    with open(os.path.join(THIS_FOLDER, 'pydeskband', '__init__.py'), 'r') as f:
+        text = f.read()
+
+    for line in text.splitlines():
+        if line.startswith('__version__'):
+            version = line.split('=', 1)[1].replace('\'', '').replace('"', '')
+            return version.strip()
+
+    raise EnvironmentError("Unable to find __version__!")
+
+def get_msbuild() -> str:
+    ''' globs to find VS 2019's instance of MSBuild.exe '''
+    matches = glob.glob(r'C:\Program Files*\Microsoft Visual Studio\2019\*\MSBuild\*\Bin\MSBuild.exe')
+    if matches:
+        print(f"MSBuild: {matches[0]}")
+        return pathlib.Path(matches[0])
+
+    raise EnvironmentError("Could not find MSBuild for VS 2019!")
+
+def get_sln() -> pathlib.Path:
+    sln = pathlib.Path(THIS_FOLDER) / "dll/PyDeskband/PyDeskband.sln"
+    if not sln.is_file():
+        raise FileNotFoundError(f"Could not find sln file: {sln}")
+
+    return sln
+
+def run_msbuild(configuration, platform) -> pathlib.Path:
+    ''' Runs MSBuild for the given configuration/platform. Returns the path to the built dll '''
+
+    if configuration not in ('Debug', 'Release'):
+        raise ValueError("configuration should be Debug or Release")
+    if platform not in ('x64', 'x86'):
+        raise ValueError("platform should be x64 or x86")
+
+    if subprocess.check_call([
+        get_msbuild(),
+        get_sln(),
+        f'/p:Configuration={configuration}',
+        f'/p:Platform={platform}',
+    ]) == 0:
+        arch_folder = 'x64' if platform == 'x64' else ''
+        output = pathlib.Path(THIS_FOLDER) / f"dll/PyDeskband/{arch_folder}/{configuration}/PyDeskband.dll"
+        if not output.is_file():
+            raise FileNotFoundError("MSBuild was successful, though we couldn't find the output dll.")
+        return output
+
+class BuildPyCommand(build_py):
+    """Custom build command. That will build dlls using MSBuild"""
+    def build_and_copy_dlls(self):
+        '''
+        Build x64 and x86 versions of the dll. Then copies them to pydeskband/dlls within the Python package
+        '''
+        x64_dll = run_msbuild('Release', 'x64')
+        x86_dll = run_msbuild('Release', 'x86')
+
+        dll_dir = pathlib.Path(THIS_FOLDER) / "pydeskband/dlls"
+        if not dll_dir.is_dir():
+            dll_dir.mkdir()
+
+        # copy dlls to dll dir
+        shutil.copy(x64_dll, dll_dir / "PyDeskband_x64.dll")
+        shutil.copy(x86_dll, dll_dir / "PyDeskband_x86.dll")
+
+        print("DLLs have been copied!")
+
+    def run(self):
+        '''
+        Called to perform the build_py step
+        '''
+        self.build_and_copy_dlls()
+        build_py.run(self)
+
+setup(
+    name='pydeskband',
+    author='csm10495',
+    author_email='csm10495@gmail.com',
+    url='http://github.com/csm10495/pydeskband',
+    version=getVersion(),
+    packages=['pydeskband'],
+    license='MIT License',
+    python_requires='>=3.7',
+    long_description=open(os.path.join(os.path.dirname(__file__), 'README.md')).read(),
+    long_description_content_type="text/markdown",
+    classifiers=[
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+        'Operating System :: Microsoft :: Windows',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+    ],
+    package_data={
+        "pydeskband": ["dlls/*.dll"],
+    },
+    cmdclass={
+        'build_py': BuildPyCommand
+    },
+    install_requires=[],
+)

excel/convert.py

@@ -1,3 +1,4 @@
+import zipfile
 import openpyxl
 import xlrd
 import csv
@@ -5,7 +6,9 @@ import plac
 from pathlib import Path
 
 
-def convert_folder(folder: str):
+def convert_folder(folder=None):
+    if folder is None:
+        folder = str(Path(__file__).parent)
     for xls_file in Path(folder).absolute().glob('*.xls'):
         convert_old(xls_file)
     for xls_file in Path(folder).absolute().glob('*.xlsx'):
@@ -19,7 +22,7 @@ def localize_floats(el):
 def convert_old(xls_file: Path):
     print('\n' + str(xls_file))
     try:
-        workbook = xlrd.open_workbook(xls_file)
+        workbook = xlrd.open_workbook(xls_file, ignore_workbook_corruption=True)
     except xlrd.XLRDError as e:
         print(e)
         return
@@ -45,7 +48,11 @@ def convert_old(xls_file: Path):
 
 def convert(xls_file: Path):
     print('\n' + str(xls_file))
-    workbook = openpyxl.load_workbook(xls_file)
+    try:
+        workbook = openpyxl.load_workbook(xls_file)
+    except zipfile.BadZipFile as e:
+        print(e)
+        return
 
     # first sheet as master without suffix
     csv_file = f'{xls_file.parent}/{xls_file.stem}.csv'

gcstruct/gcstruct.py

@@ -421,9 +421,12 @@ class GCStruct():
         df_source['Ebene79'] = np.where(df_source['GuV'], '', df_source['Ebene80'])
         df_source['Ebene80'] = ''
         df_source['Susa'] = df_source['Konto_Gruppe'].str.slice(stop=1)
+        df_source['Konto_KST'] = ''
+        df_source['GuV_Bilanz'] = df_source['Konto_Art']
 
-        from_label = ['Konto_neu', 'Konto_Nr_Händler', 'Konto_Art']
-        to_label = ['Konto', 'Acct_Nr', 'GuV_Bilanz']
+
+        from_label = ['Konto_neu', 'Konto_Nr_Händler']
+        to_label = ['Konto', 'Acct_Nr']
 
         df_source = df_source.rename(columns=dict(zip(from_label, to_label)))
         
@@ -489,13 +492,14 @@ def gcstruct_uebersetzung():
 
     struct = GCStruct(str(base_dir.joinpath('GCStruct_Aufbereitung')))
     struct.skr51_translate(import_dir.glob('Kontenrahmen_kombiniert*.csv'))
-    print('Kontenrahmen_uebersetzt.csv erstellt.\n')
+    print('Kontenrahmen_uebersetzt.csv erstellt.')
     # copyfile('c:/Projekte/Python/Gcstruct/Kontenrahmen_kombiniert.csv', base_dir + 'GCStruct_Modell/Export/Kontenrahmen_kombiniert.csv')
+
     struct2 = GCStruct(str(base_dir.joinpath('GCStruct_Modell')))
     struct2.skr51_translate2(str(base_dir.joinpath('GCStruct_Aufbereitung/Export/Kontenrahmen_uebersetzt.csv')))
-    print('SKR51_Uebersetzung.csv erstellt.\n')
+    print('SKR51_Uebersetzung.csv erstellt.')
     struct2.skr51_vars()
-    print('SKR51_Struktur.csv erstellt.\n')
+    print('SKR51_Struktur.csv erstellt.')
 
 
 def dresen():

gcstruct/gcstruct.spec

@@ -5,11 +5,12 @@ block_cipher = None
 
 
 a = Analysis(['gcstruct.py'],
-             pathex=['/home/robert/projekte/python/gcstruct'],
+             pathex=['P:\\Python_Projekte\\Python\\gcstruct'],
              binaries=[],
              datas=[],
              hiddenimports=[],
              hookspath=[],
+             hooksconfig={},
              runtime_hooks=[],
              excludes=[],
              win_no_prefer_redirects=False,
@@ -18,21 +19,22 @@ a = Analysis(['gcstruct.py'],
              noarchive=False)
 pyz = PYZ(a.pure, a.zipped_data,
              cipher=block_cipher)
+
 exe = EXE(pyz,
           a.scripts,
+          a.binaries,
+          a.zipfiles,
+          a.datas,  
           [],
-          exclude_binaries=True,
           name='gcstruct',
           debug=False,
           bootloader_ignore_signals=False,
           strip=False,
           upx=True,
-          console=True )
-coll = COLLECT(exe,
-               a.binaries,
-               a.zipfiles,
-               a.datas,
-               strip=False,
-               upx=True,
-               upx_exclude=[],
-               name='gcstruct')
+          upx_exclude=[],
+          runtime_tmpdir=None,
+          console=True,
+          disable_windowed_traceback=False,
+          target_arch=None,
+          codesign_identity=None,
+          entitlements_file=None )

gcstruct/gcstruct_uebersetzung.spec

@@ -4,7 +4,7 @@
 block_cipher = None
 
 
-a = Analysis(['gcstruct.py'],
+a = Analysis(['gcstruct_uebersetzung.py'],
              pathex=['P:\\Python_Projekte\\Python\\gcstruct'],
              binaries=[],
              datas=[],
@@ -37,4 +37,4 @@ exe = EXE(pyz,
           disable_windowed_traceback=False,
           target_arch=None,
           codesign_identity=None,
-          entitlements_file=None )
+          entitlements_file=None , icon='P:\\Python_Projekte\\Python\\gcstruct\\cube.ico')

process_monitor.py

@@ -0,0 +1,87 @@
+import psutil
+from datetime import datetime
+import pandas as pd
+import time
+import os
+
+
+def get_size(bytes):
+    """Returns size of bytes in a nice format"""
+    for unit in ['', 'K', 'M', 'G', 'T', 'P']:
+        if bytes < 1024:
+            return f"{bytes:.2f}{unit}B"
+        bytes /= 1024
+
+
+def get_processes_info(name_filter):
+    processes = []
+    for process in psutil.process_iter():
+        with process.oneshot():
+            pid = process.pid
+            if pid == 0:
+                continue
+            name = process.name().lower()
+            if name not in name_filter:
+                continue
+            try:
+                create_time = datetime.fromtimestamp(process.create_time())
+            except OSError:
+                create_time = datetime.fromtimestamp(psutil.boot_time())
+            try:
+                cores = len(process.cpu_affinity())
+            except psutil.AccessDenied:
+                cores = 0
+            cpu_usage = process.cpu_percent()
+            status = process.status()
+            try:
+                nice = int(process.nice())
+            except psutil.AccessDenied:
+                nice = 0
+            try:
+                memory_usage = process.memory_full_info().uss
+            except psutil.AccessDenied:
+                memory_usage = 0
+            io_counters = process.io_counters()
+            read_bytes = io_counters.read_bytes
+            write_bytes = io_counters.write_bytes
+            n_threads = process.num_threads()
+            try:
+                username = process.username()
+            except psutil.AccessDenied:
+                username = "N/A"
+
+        processes.append({
+            'pid': pid, 'name': name, 'create_time': create_time,
+            'cores': cores, 'cpu_usage': cpu_usage, 'status': status, 'nice': nice,
+            'memory_usage': memory_usage, 'read_bytes': read_bytes, 'write_bytes': write_bytes,
+            'n_threads': n_threads, 'username': username,
+        })
+
+    return processes
+
+
+def construct_dataframe(processes):
+    df = pd.DataFrame(processes)
+    df.set_index('pid', inplace=True)
+    df.sort_values(sort_by, inplace=True)
+    # pretty printing bytes
+    df['memory_usage'] = df['memory_usage'].apply(get_size)
+    df['write_bytes'] = df['write_bytes'].apply(get_size)
+    df['read_bytes'] = df['read_bytes'].apply(get_size)
+    # convert to proper date format
+    df['create_time'] = df['create_time'].apply(datetime.strftime, args=("%Y-%m-%d %H:%M:%S",))
+    # reorder and define used columns
+    df = df[columns]
+    return df
+
+
+if __name__ == "__main__":
+    sort_by = "memory_usage"
+    columns = ["name", "cpu_usage", "memory_usage", "read_bytes", "write_bytes", "status", "create_time", "nice", "n_threads", "cores", "username"]
+    name_filter = ["pwrplay.exe", "httpd.exe", "impadmin.exe", "trnsfrmr.exe"]
+    while True:
+        processes = get_processes_info(name_filter)
+        df = construct_dataframe(processes)
+        os.system("cls") if "nt" in os.name else os.system("clear")
+        print(df.to_string())
+        time.sleep(10)