pypresplash 1.0.0__tar.gz

pypresplash-1.0.0/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

pypresplash-1.0.0/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.15)
+project(PyPreSplash VERSION 1.0.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+find_package(Python3 COMPONENTS Interpreter Development.Module REQUIRED)
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+
+pybind11_add_module(pypresplash 
+    src/splash_screen.cpp
+    src/bridge.cpp
+)
+
+target_include_directories(pypresplash PRIVATE src/include)
+target_compile_definitions(pypresplash PRIVATE UNICODE _UNICODE)
+target_compile_definitions(pypresplash PRIVATE NOMINMAX)
+
+target_link_libraries(pypresplash PRIVATE gdiplus user32 gdi32)
+
+install(TARGETS pypresplash DESTINATION .)

pypresplash-1.0.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.2
+Name: pypresplash
+Version: 1.0.0
+Summary: A native Windows GDI+ splash screen module with smooth animations and transparency.
+Author-Email: Kartavya Shukla <novfensec@protonmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# PyPreSplash
+
+A lightning-fast, native Windows splash screen module for Python applications. 
+
+### Why does this exist?
+Python applications (especially those using heavy libraries or frameworks like PyQt/Kivy) take a few seconds to start up. Without a splash screen, users might click your app icon, see nothing happen for 4 seconds, assume it's broken, and click it three more times. 
+
+**PyPreSplash** pops up *instantly* using the native Windows API. It gives your users immediate visual feedback (a logo and a progress bar) while Python quietly finishes doing the heavy lifting in the background.
+
+## Features
+* **Zero Heavy Dependencies:** Uses native Win32/GDI+ APIs. No need to load Tkinter, PyQt, or Kivy just to show a loading screen.
+* **True Transparency:** Fully supports PNGs with transparent backgrounds. No ugly black boxes around your logo.
+* **Smooth 60FPS Animations:** The progress bar smoothly glides to its target using a C++ micro-loop, ensuring the window stays responsive.
+* **Minimalist UI:** The progress bar draws directly over your image edge-to-edge for a modern look.
+* **Dynamic Styling:** Change progress bar and text colors on the fly using standard Hex codes (e.g., `#0f62fe`).
+* **Custom Typography:** Use any system font (e.g., `"Segoe UI"`, `"Consolas"`) with hardware-accelerated ClearType rendering.
+
+## Installation
+
+This project is built using C++17, Pybind11, and `scikit-build-core`. 
+
+**Prerequisites:**
+* Windows 10 or 11
+* Python 3.8+
+* A C++ Compiler (Visual Studio / MSVC)
+
+### Install for Development
+To install the module directly into your current Python environment:
+```bash
+pip install .
+
+```
+
+### Build a Distributable Wheel
+
+To compile a `.whl` file that you can distribute to end-users (so they don't need a C++ compiler installed to use your app):
+
+```bash
+pip install build
+python -m build --wheel
+
+```
+
+The compiled wheel will be located in the `dist/` folder.
+
+## Quick Start
+
+Here is a complete example of how to mask a heavy application load.
+
+```python
+import time
+import pypresplash
+
+def main():
+    splash = pypresplash.SplashScreen()
+
+    splash.set_font("Segoe UI", 12) 
+
+    success = splash.show("presplash.png", 0, 600, 600, "contain")
+    
+    if not success:
+        print("Failed to load splash screen.")
+        return
+
+    stages = [
+        "Initializing core subsystems...",
+        "Loading graphics engine...",
+        "Mounting file system...",
+        "Connecting to services..."
+    ]
+
+    for i, stage_msg in enumerate(stages):
+        progress = int((i / len(stages)) * 100)
+
+        splash.set_progress(progress, stage_msg, "#0f62fe", "#FFFFFF")
+        time.sleep(0.8)
+
+    splash.set_progress(100, "Ready!", "#42be65", "#FFFFFF")
+    time.sleep(0.5)
+
+    splash.hide()
+    
+    print("Main application started.")
+
+if __name__ == "__main__":
+    main()
+
+```
+
+## API Reference
+
+### `SplashScreen()`
+
+Initializes the splash screen object and starts the GDI+ subsystem.
+
+### `.show(image_path, timeout_ms=0, width=0, height=0, scale_mode="stretch") -> bool`
+
+Creates and displays the splash screen window.
+
+* **`image_path`**: Path to your `.png`, `.jpg`, or `.bmp` file.
+* **`timeout_ms`**: Optional auto-close timer in milliseconds (0 keeps it open indefinitely).
+* **`width` / `height**`: Target window dimensions. If `0`, it defaults to the exact size of the image file.
+* **`scale_mode`**:
+* `"stretch"` (Default): Forces the image to exactly match the target width/height.
+* `"contain"`: Scales the image to fit entirely inside the width/height while maintaining aspect ratio. Unused space is transparent.
+* `"cover"`: Scales the image to fill the entire width/height, cropping edges if necessary.
+
+
+
+### `.set_progress(value, message="", hex_color="#00A8FF", text_color="#FFFFFF")`
+
+Smoothly animates the progress bar to a new value.
+
+* **`value`**: Integer between 0 and 100.
+* **`message`**: Status text displayed just above the loading bar.
+* **`hex_color`**: Hex string for the loading bar (e.g., `"#FF5733"`).
+* **`text_color`**: Hex string for the status text.
+
+### `.set_font(family, size=14)`
+
+Configures the text rendering engine. Must be called *before* `.set_progress`.
+
+* **`family`**: Name of an installed system font (e.g., `"Segoe UI"`, `"Consolas"`).
+* **`size`**: Font size in points. (Recommended: 10 to 13).
+
+### `.hide()`
+
+Destroys the window and safely releases GDI+ resources.
+
+### `.is_visible() -> bool`
+
+Returns `True` if the splash screen is currently active and rendered on screen.

pypresplash-1.0.0/README.md

@@ -0,0 +1,132 @@
+# PyPreSplash
+
+A lightning-fast, native Windows splash screen module for Python applications. 
+
+### Why does this exist?
+Python applications (especially those using heavy libraries or frameworks like PyQt/Kivy) take a few seconds to start up. Without a splash screen, users might click your app icon, see nothing happen for 4 seconds, assume it's broken, and click it three more times. 
+
+**PyPreSplash** pops up *instantly* using the native Windows API. It gives your users immediate visual feedback (a logo and a progress bar) while Python quietly finishes doing the heavy lifting in the background.
+
+## Features
+* **Zero Heavy Dependencies:** Uses native Win32/GDI+ APIs. No need to load Tkinter, PyQt, or Kivy just to show a loading screen.
+* **True Transparency:** Fully supports PNGs with transparent backgrounds. No ugly black boxes around your logo.
+* **Smooth 60FPS Animations:** The progress bar smoothly glides to its target using a C++ micro-loop, ensuring the window stays responsive.
+* **Minimalist UI:** The progress bar draws directly over your image edge-to-edge for a modern look.
+* **Dynamic Styling:** Change progress bar and text colors on the fly using standard Hex codes (e.g., `#0f62fe`).
+* **Custom Typography:** Use any system font (e.g., `"Segoe UI"`, `"Consolas"`) with hardware-accelerated ClearType rendering.
+
+## Installation
+
+This project is built using C++17, Pybind11, and `scikit-build-core`. 
+
+**Prerequisites:**
+* Windows 10 or 11
+* Python 3.8+
+* A C++ Compiler (Visual Studio / MSVC)
+
+### Install for Development
+To install the module directly into your current Python environment:
+```bash
+pip install .
+
+```
+
+### Build a Distributable Wheel
+
+To compile a `.whl` file that you can distribute to end-users (so they don't need a C++ compiler installed to use your app):
+
+```bash
+pip install build
+python -m build --wheel
+
+```
+
+The compiled wheel will be located in the `dist/` folder.
+
+## Quick Start
+
+Here is a complete example of how to mask a heavy application load.
+
+```python
+import time
+import pypresplash
+
+def main():
+    splash = pypresplash.SplashScreen()
+
+    splash.set_font("Segoe UI", 12) 
+
+    success = splash.show("presplash.png", 0, 600, 600, "contain")
+    
+    if not success:
+        print("Failed to load splash screen.")
+        return
+
+    stages = [
+        "Initializing core subsystems...",
+        "Loading graphics engine...",
+        "Mounting file system...",
+        "Connecting to services..."
+    ]
+
+    for i, stage_msg in enumerate(stages):
+        progress = int((i / len(stages)) * 100)
+
+        splash.set_progress(progress, stage_msg, "#0f62fe", "#FFFFFF")
+        time.sleep(0.8)
+
+    splash.set_progress(100, "Ready!", "#42be65", "#FFFFFF")
+    time.sleep(0.5)
+
+    splash.hide()
+    
+    print("Main application started.")
+
+if __name__ == "__main__":
+    main()
+
+```
+
+## API Reference
+
+### `SplashScreen()`
+
+Initializes the splash screen object and starts the GDI+ subsystem.
+
+### `.show(image_path, timeout_ms=0, width=0, height=0, scale_mode="stretch") -> bool`
+
+Creates and displays the splash screen window.
+
+* **`image_path`**: Path to your `.png`, `.jpg`, or `.bmp` file.
+* **`timeout_ms`**: Optional auto-close timer in milliseconds (0 keeps it open indefinitely).
+* **`width` / `height**`: Target window dimensions. If `0`, it defaults to the exact size of the image file.
+* **`scale_mode`**:
+* `"stretch"` (Default): Forces the image to exactly match the target width/height.
+* `"contain"`: Scales the image to fit entirely inside the width/height while maintaining aspect ratio. Unused space is transparent.
+* `"cover"`: Scales the image to fill the entire width/height, cropping edges if necessary.
+
+
+
+### `.set_progress(value, message="", hex_color="#00A8FF", text_color="#FFFFFF")`
+
+Smoothly animates the progress bar to a new value.
+
+* **`value`**: Integer between 0 and 100.
+* **`message`**: Status text displayed just above the loading bar.
+* **`hex_color`**: Hex string for the loading bar (e.g., `"#FF5733"`).
+* **`text_color`**: Hex string for the status text.
+
+### `.set_font(family, size=14)`
+
+Configures the text rendering engine. Must be called *before* `.set_progress`.
+
+* **`family`**: Name of an installed system font (e.g., `"Segoe UI"`, `"Consolas"`).
+* **`size`**: Font size in points. (Recommended: 10 to 13).
+
+### `.hide()`
+
+Destroys the window and safely releases GDI+ resources.
+
+### `.is_visible() -> bool`
+
+Returns `True` if the splash screen is currently active and rendered on screen.

pypresplash-1.0.0/examples/main.py

@@ -0,0 +1,42 @@
+import time
+import pypresplash
+
+
+def main():
+    splash = pypresplash.SplashScreen()
+    splash.set_font("Verdana", 12)
+
+    # use any image format that works
+    success = splash.show(
+        "presplash.png", 0, 600, 300, "cover"
+    )
+
+    if not success:
+        print("Failed to initialize splash screen.")
+        return
+
+    stages = [
+        "Initializing core subsystems...",
+        "Loading graphics engine...",
+        "Mounting file system...",
+        "Connecting to services...",
+        "Finalizing...",
+    ]
+
+    for i, stage_msg in enumerate(stages):
+        progress = int((i / len(stages)) * 100)
+
+        splash.set_progress(progress, stage_msg, "#0f62fe", "#000000")
+
+        time.sleep(0.8)
+
+    splash.set_progress(100, "Ready!", "#42be65", "#000000")
+    time.sleep(0.5)
+
+    splash.hide()
+
+    print("Main application started.")
+
+
+if __name__ == "__main__":
+    main()

pypresplash-1.0.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["scikit-build-core>=0.4.3", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "pypresplash"
+version = "1.0.0"
+description = "A native Windows GDI+ splash screen module with smooth animations and transparency."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [
+  { name = "Kartavya Shukla", email = "novfensec@protonmail.com" }
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+]
+dependencies = []
+
+[tool.scikit-build]
+cmake.build-type = "Release"

pypresplash-1.0.0/src/bridge.cpp

@@ -0,0 +1,32 @@
+#include <pybind11/pybind11.h>
+#include "splash_screen.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(pypresplash, m) {
+    m.doc() = "Native Windows GDI+ PreSplash Module";
+
+    py::class_<SplashScreen>(m, "SplashScreen")
+        .def(py::init<>())
+        .def("show", &SplashScreen::Show, 
+             py::arg("image_path"), 
+             py::arg("timeout_ms") = 0,
+             py::arg("width") = 0,
+             py::arg("height") = 0,
+             py::arg("scale_mode") = "stretch",
+             "Show the splash screen. scale_mode can be 'stretch', 'contain', or 'cover'.")
+        .def("hide", &SplashScreen::Hide,
+             "Hide and destroy the splash screen window.")
+        .def("set_progress", &SplashScreen::SetProgress,
+             py::arg("value"), 
+             py::arg("message") = L"",
+             py::arg("hex_color") = "#00A8FF",
+             py::arg("text_color") = "#FFFFFF", // NEW Argument
+             "Update the progress bar with a target value (0-100), message, bar hex color, and text hex color.")
+        .def("set_font", &SplashScreen::SetFont,
+             py::arg("family"), 
+             py::arg("size") = 14,
+             "Set the font family and size for the progress text.")
+        .def("is_visible", &SplashScreen::IsVisible,
+             "Check if the splash screen is currently active.");
+}

pypresplash-1.0.0/src/include/splash_screen.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <windows.h>
+#include <string>
+
+class SplashScreen
+{
+public:
+    SplashScreen();
+    ~SplashScreen();
+
+    bool Show(const std::wstring &imagePath, int timeoutMs = 0, int width = 0, int height = 0, const std::string &scaleMode = "stretch");
+    void Hide();
+
+    void SetProgress(int value, const std::wstring &message = L"", const std::string &hexColor = "#00A8FF", const std::string &textColor = "#FFFFFF");
+    void SetFont(const std::wstring &fontFamily, int fontSize);
+
+    bool IsVisible() const { return m_hWnd != nullptr; }
+
+private:
+    bool CreateWindowExW();
+    void CenterWindow();
+    bool LoadSplashImage(const std::wstring &imagePath, int targetWidth, int targetHeight, const std::string &scaleMode);
+    void Render();
+
+    static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+    HWND m_hWnd = nullptr;
+    HINSTANCE m_hInstance = nullptr;
+    HBITMAP m_hBitmap = nullptr;
+    ULONG_PTR m_gdiplusToken = 0;
+
+    int m_width = 0;
+    int m_height = 0;
+
+    float m_currentProgress = -1.0f;
+    int m_targetProgress = -1;
+    int m_progR = 0;
+    int m_progG = 168;
+    int m_progB = 255;
+
+    int m_textR = 255;
+    int m_textG = 255;
+    int m_textB = 255;
+    std::wstring m_progressMessage;
+    std::wstring m_fontFamily = L"Segoe UI";
+    int m_fontSize = 14;
+};

pypresplash-1.0.0/src/splash_screen.cpp

@@ -0,0 +1,337 @@
+#include "splash_screen.h"
+#include <gdiplus.h>
+#include <sstream>
+#include <algorithm>
+#include <stdexcept>
+
+#pragma comment(lib, "gdiplus.lib")
+#pragma comment(lib, "user32.lib")
+#pragma comment(lib, "gdi32.lib")
+
+using namespace Gdiplus;
+
+static SplashScreen *g_pSplash = nullptr;
+
+SplashScreen::SplashScreen()
+{
+    m_hInstance = GetModuleHandle(nullptr);
+    GdiplusStartupInput gdiplusStartupInput;
+    GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, nullptr);
+}
+
+SplashScreen::~SplashScreen()
+{
+    Hide();
+    if (m_hBitmap)
+    {
+        DeleteObject(m_hBitmap);
+        m_hBitmap = nullptr;
+    }
+    GdiplusShutdown(m_gdiplusToken);
+}
+
+bool SplashScreen::CreateWindowExW()
+{
+    WNDCLASS wc = {};
+    wc.lpfnWndProc = WndProc;
+    wc.hInstance = m_hInstance;
+    wc.lpszClassName = L"SplashScreenClass";
+    wc.hCursor = LoadCursor(nullptr, IDC_WAIT);
+
+    RegisterClass(&wc);
+
+    DWORD dwExStyle = WS_EX_LAYERED | WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
+    DWORD dwStyle = WS_POPUP;
+
+    m_hWnd = ::CreateWindowEx(
+        dwExStyle,
+        L"SplashScreenClass",
+        L"Splash",
+        dwStyle,
+        0, 0,
+        m_width, m_height,
+        nullptr, nullptr, m_hInstance, nullptr);
+
+    if (!m_hWnd)
+        return false;
+
+    // Optional: Keep rounded corners, or set to 0,0 for sharp corners
+    HRGN hRgn = CreateRoundRectRgn(0, 0, m_width, m_height, 0, 0);
+    SetWindowRgn(m_hWnd, hRgn, TRUE);
+
+    CenterWindow();
+    g_pSplash = this;
+    return true;
+}
+
+void SplashScreen::CenterWindow()
+{
+    RECT rcWork;
+    SystemParametersInfo(SPI_GETWORKAREA, 0, &rcWork, 0);
+
+    int screenWidth = rcWork.right - rcWork.left;
+    int screenHeight = rcWork.bottom - rcWork.top;
+
+    int x = (screenWidth - m_width) / 2 + rcWork.left;
+    int y = (screenHeight - m_height) / 2 + rcWork.top;
+
+    SetWindowPos(m_hWnd, HWND_TOPMOST, x, y, m_width, m_height, SWP_NOZORDER);
+}
+
+bool SplashScreen::LoadSplashImage(const std::wstring &imagePath, int targetWidth, int targetHeight, const std::string &scaleMode)
+{
+    if (m_hBitmap)
+    {
+        DeleteObject(m_hBitmap);
+        m_hBitmap = nullptr;
+    }
+
+    Gdiplus::Bitmap *pBitmap = new Gdiplus::Bitmap(imagePath.c_str());
+    if (pBitmap->GetLastStatus() != Gdiplus::Ok)
+    {
+        delete pBitmap;
+        return false;
+    }
+
+    if (targetWidth > 0 && targetHeight > 0)
+    {
+        m_width = targetWidth;
+        m_height = targetHeight;
+
+        Gdiplus::Bitmap *pScaled = new Gdiplus::Bitmap(m_width, m_height, PixelFormat32bppARGB);
+        Gdiplus::Graphics graphics(pScaled);
+        graphics.SetInterpolationMode(Gdiplus::InterpolationModeHighQualityBicubic);
+
+        float srcWidth = (float)pBitmap->GetWidth();
+        float srcHeight = (float)pBitmap->GetHeight();
+
+        float scaleX = (float)targetWidth / srcWidth;
+        float scaleY = (float)targetHeight / srcHeight;
+
+        float drawWidth = (float)targetWidth;
+        float drawHeight = (float)targetHeight;
+        float drawX = 0.0f;
+        float drawY = 0.0f;
+
+        if (scaleMode == "contain")
+        {
+            float scale = std::min(scaleX, scaleY);
+            drawWidth = srcWidth * scale;
+            drawHeight = srcHeight * scale;
+            drawX = (targetWidth - drawWidth) / 2.0f;
+            drawY = (targetHeight - drawHeight) / 2.0f;
+        }
+        else if (scaleMode == "cover")
+        {
+            float scale = std::max(scaleX, scaleY);
+            drawWidth = srcWidth * scale;
+            drawHeight = srcHeight * scale;
+            drawX = (targetWidth - drawWidth) / 2.0f;
+            drawY = (targetHeight - drawHeight) / 2.0f;
+        }
+
+        graphics.DrawImage(pBitmap, drawX, drawY, drawWidth, drawHeight);
+
+        pScaled->GetHBITMAP(Gdiplus::Color(0, 0, 0, 0), &m_hBitmap);
+        delete pScaled;
+    }
+    else
+    {
+        m_width = pBitmap->GetWidth();
+        m_height = pBitmap->GetHeight();
+        pBitmap->GetHBITMAP(Gdiplus::Color(0, 0, 0, 0), &m_hBitmap);
+    }
+
+    delete pBitmap;
+    return m_hBitmap != nullptr;
+}
+void SplashScreen::Render()
+{
+    if (!m_hWnd || !m_hBitmap)
+        return;
+
+    SIZE size = {m_width, m_height};
+    RECT rcWindow;
+    GetWindowRect(m_hWnd, &rcWindow);
+    POINT ptOrigin = {rcWindow.left, rcWindow.top};
+
+    HDC hdcScreen = GetDC(nullptr);
+    HDC hdcMem = CreateCompatibleDC(hdcScreen);
+
+    BITMAPINFO bmi = {0};
+    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    bmi.bmiHeader.biWidth = m_width;
+    bmi.bmiHeader.biHeight = -m_height;
+    bmi.bmiHeader.biPlanes = 1;
+    bmi.bmiHeader.biBitCount = 32;
+    bmi.bmiHeader.biCompression = BI_RGB;
+
+    void *pBits = nullptr;
+    HBITMAP hbmpMem = CreateDIBSection(hdcScreen, &bmi, DIB_RGB_COLORS, &pBits, nullptr, 0);
+    HBITMAP hbmpOld = (HBITMAP)SelectObject(hdcMem, hbmpMem);
+
+    // 1. Draw Background
+    HDC hdcImage = CreateCompatibleDC(hdcScreen);
+    HBITMAP hbmpOldImage = (HBITMAP)SelectObject(hdcImage, m_hBitmap);
+    BitBlt(hdcMem, 0, 0, m_width, m_height, hdcImage, 0, 0, SRCCOPY);
+    SelectObject(hdcImage, hbmpOldImage);
+    DeleteDC(hdcImage);
+
+    // 2. Draw UI using GDI+ (Fixes transparency bugs!)
+    if (m_targetProgress >= 0)
+    {
+        Gdiplus::Graphics graphics(hdcMem);
+        graphics.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
+        graphics.SetTextRenderingHint(Gdiplus::TextRenderingHintClearTypeGridFit);
+
+        int barHeight = 6;
+        int barX = 0;
+        int barY = m_height - barHeight;
+        int barWidth = m_width;
+
+
+        // Progress Bar
+        int filledWidth = (int)((barWidth * m_currentProgress) / 100.0f);
+        if (filledWidth > 0)
+        {
+            Gdiplus::SolidBrush progBrush(Gdiplus::Color(255, m_progR, m_progG, m_progB));
+            graphics.FillRectangle(&progBrush, barX, barY, filledWidth, barHeight);
+        }
+
+        // 3. Draw Text
+        if (!m_progressMessage.empty() || m_targetProgress >= 0)
+        {
+            std::wstring displayText = m_progressMessage;
+            if (m_targetProgress >= 0) {
+                displayText += L" - " + std::to_wstring((int)m_currentProgress) + L"%";
+            }
+            
+            Gdiplus::FontFamily fontFamily(m_fontFamily.c_str());
+            Gdiplus::Font font(&fontFamily, (Gdiplus::REAL)m_fontSize, Gdiplus::FontStyleRegular, Gdiplus::UnitPoint);
+            Gdiplus::StringFormat format;
+            format.SetAlignment(Gdiplus::StringAlignmentNear);
+            format.SetLineAlignment(Gdiplus::StringAlignmentFar);
+
+            int padding = 15;
+            Gdiplus::RectF textRect((Gdiplus::REAL)padding, (Gdiplus::REAL)(barY - 40), (Gdiplus::REAL)(m_width - padding * 2), 35.0f);
+            
+            // Just draw the pure colored text!
+            Gdiplus::SolidBrush textBrush(Gdiplus::Color(255, m_textR, m_textG, m_textB));
+            graphics.DrawString(displayText.c_str(), -1, &font, textRect, &format, &textBrush);
+        }
+    }
+
+    // 4. Update Window
+    BLENDFUNCTION blend = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
+    POINT ptZero = {0, 0};
+    UpdateLayeredWindow(m_hWnd, hdcScreen, &ptOrigin, &size,
+                        hdcMem, &ptZero, RGB(0, 0, 0), &blend, ULW_ALPHA);
+
+    SelectObject(hdcMem, hbmpOld);
+    DeleteObject(hbmpMem);
+    DeleteDC(hdcMem);
+    ReleaseDC(nullptr, hdcScreen);
+}
+
+void SplashScreen::SetProgress(int value, const std::wstring &message, const std::string &hexColor, const std::string &textColor)
+{
+    if (!IsVisible())
+        return;
+
+    m_targetProgress = value;
+    m_progressMessage = message;
+
+    // Helper to parse hex strings safely
+    auto parseHex = [](const std::string &hex, int &r, int &g, int &b)
+    {
+        std::string h = hex;
+        if (!h.empty() && h[0] == '#')
+            h = h.substr(1);
+        if (h.length() == 6)
+        {
+            try
+            {
+                r = std::stoi(h.substr(0, 2), nullptr, 16);
+                g = std::stoi(h.substr(2, 2), nullptr, 16);
+                b = std::stoi(h.substr(4, 2), nullptr, 16);
+            }
+            catch (...)
+            {
+            }
+        }
+    };
+
+    parseHex(hexColor, m_progR, m_progG, m_progB);
+    parseHex(textColor, m_textR, m_textG, m_textB);
+
+    if (m_currentProgress < 0.0f)
+    {
+        m_currentProgress = 0.0f;
+    }
+
+    while (m_currentProgress < (float)m_targetProgress)
+    {
+        m_currentProgress += ((float)m_targetProgress - m_currentProgress) * 0.15f;
+
+        if ((float)m_targetProgress - m_currentProgress < 0.5f)
+        {
+            m_currentProgress = (float)m_targetProgress;
+        }
+
+        Render();
+        Sleep(16);
+
+        MSG msg;
+        while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+        {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+    }
+}
+
+LRESULT CALLBACK SplashScreen::WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    switch (msg)
+    {
+    case WM_DESTROY:
+        PostQuitMessage(0);
+        return 0;
+    }
+    return DefWindowProc(hWnd, msg, wParam, lParam);
+}
+
+bool SplashScreen::Show(const std::wstring &imagePath, int timeoutMs, int width, int height, const std::string &scaleMode)
+{
+    if (!LoadSplashImage(imagePath, width, height, scaleMode))
+        return false;
+
+    if (!CreateWindowExW())
+        return false;
+
+    Render();
+    ShowWindow(m_hWnd, SW_SHOW);
+    UpdateWindow(m_hWnd);
+
+    if (timeoutMs > 0)
+    {
+        SetTimer(m_hWnd, 1, timeoutMs, nullptr);
+    }
+
+    return true;
+}
+
+void SplashScreen::Hide()
+{
+    if (m_hWnd && IsWindow(m_hWnd))
+    {
+        DestroyWindow(m_hWnd);
+        m_hWnd = nullptr;
+    }
+}
+
+void SplashScreen::SetFont(const std::wstring &fontFamily, int fontSize)
+{
+    m_fontFamily = fontFamily;
+    m_fontSize = fontSize;
+}