Converted to C++

Author: YakovAU

CMakeLists.txt

@@ -0,0 +1,76 @@
+cmake_minimum_required(VERSION 3.29)
+project(ProcessFlipper)
+
+# Enable the Resource Compiler language
+enable_language(RC)
+
+set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Find and setup ccache if available
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+  set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PROGRAM}")
+endif()
+
+# Check for LTO support
+include(CheckIPOSupported)
+check_ipo_supported(RESULT lto_supported OUTPUT error_message)
+
+# Set optimization flags for Release builds
+set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
+
+# Strip symbols in Release mode
+if(WIN32)
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+  set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
+  set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
+else()
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s")
+endif()
+
+# Default to Release build if not specified
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+add_executable(ProcessFlipper WIN32 main.cpp
+        process_manager.cpp
+        tray_icon.cpp
+        app.rc
+        # List header files for clarity / IDE support
+        tray_icon.h
+        hotkey_manager.h
+        process_manager.h
+        resource.h
+)
+
+# Enable LTO/IPO if supported
+if(lto_supported)
+  set_property(TARGET ProcessFlipper PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
+else()
+  message(WARNING "LTO is not supported: ${error_message}")
+endif()
+
+# Use precompiled headers for common headers
+target_precompile_headers(ProcessFlipper PRIVATE
+  <vector>
+  <string>
+  <windows.h>
+  <memory>
+  <unordered_map>
+)
+
+# Optimize for the current CPU architecture if not on Windows
+# (Windows builds typically need to be more portable, so architecture-specific optimizations are often avoided)
+if(NOT WIN32)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
+endif()
+
+# For Windows builds, specific optimizations
+if(WIN32)
+  # Use whole program optimization for MSVC
+  target_compile_options(ProcessFlipper PRIVATE $<$<CONFIG:Release>:/GL>)
+  # Use LTCG (Link Time Code Generation) for the linker
+  set_property(TARGET ProcessFlipper PROPERTY LINK_FLAGS_RELEASE "/LTCG")
+endif()

README.md

@@ -0,0 +1,3 @@
+#include "resource.h"
+
+IDI_APPICON ICON "icon.ico"

app.rc

@@ -0,0 +1,97 @@
+#pragma once
+#include <windows.h>
+#include <unordered_map>
+#include <functional>
+#include <iostream> // For logging
+
+class HotkeyManager {
+public:
+    HotkeyManager() : nextHotkeyId(1) {
+        std::cout << "HotkeyManager initialized." << std::endl;
+    }
+    
+    ~HotkeyManager() {
+        // Clean up all registered hotkeys
+        for (const auto& pair : hotkeyCallbacks) {
+            UnregisterHotKey(nullptr, pair.first);
+            std::cout << "Unregistered hotkey ID: " << pair.first << std::endl;
+        }
+        hotkeyCallbacks.clear();
+    }
+
+    int registerHotkey(const UINT modifiers, const UINT vk) {
+        const int currentIdAttempt = nextHotkeyId; // Use a temporary variable for logging before incrementing
+        if (RegisterHotKey(nullptr, currentIdAttempt, modifiers, vk)) {
+            nextHotkeyId++; // Increment only on success
+            std::cout << "Hotkey registered successfully: ID=" << currentIdAttempt
+                      << ", Modifiers=0x" << std::hex << modifiers
+                      << ", VK=0x" << std::hex << vk << std::dec << std::endl;
+            return currentIdAttempt;
+        }
+        DWORD errorCode = GetLastError();
+        std::cerr << "Failed to register hotkey: Modifiers=0x" << std::hex << modifiers
+                  << ", VK=0x" << std::hex << vk << std::dec
+                  << ". Error code: " << errorCode << std::endl;
+        return -1;
+    }
+
+    void setCallback(int id, const std::function<void()>& callback) {
+        if (id != -1) {
+            hotkeyCallbacks[id] = callback;
+            std::cout << "Callback set for hotkey ID: " << id << std::endl;
+        } else {
+            std::cerr << "Attempted to set callback for invalid hotkey ID (-1)." << std::endl;
+        }
+    }
+
+    // Processes a given MSG struct. Returns true if it was a hotkey message and handled, false otherwise.
+    bool processMessage(const MSG& msg) { // Go back to const reference but handle carefully
+        if (msg.message == WM_HOTKEY) {
+            // Extract only what we need - the ID
+            int hotkeyId = static_cast<int>(msg.wParam);
+            
+            std::cout << "HotkeyManager::processMessage - WM_HOTKEY received. ID: " << hotkeyId << std::endl;
+            
+            // Find the callback
+            auto it = hotkeyCallbacks.find(hotkeyId);
+            if (it != hotkeyCallbacks.end() && it->second) {
+                std::cout << "HotkeyManager::processMessage - Executing callback for hotkey ID: " << hotkeyId << std::endl;
+                
+                // Execute the callback directly - no need for a local copy
+                it->second();
+            } else {
+                std::cerr << "HotkeyManager::processMessage - No callback found for hotkey ID: " << hotkeyId << std::endl;
+            }
+            
+            return true; // Hotkey message was processed
+        }
+        
+        return false; // Not a hotkey message
+    }
+
+    /*
+    // The handleHotkeys method with PeekMessage is not suitable when GetMessage is used in the main loop
+    // as GetMessage will consume the WM_HOTKEY before PeekMessage in this function can see it.
+    // This function would be more appropriate if HotkeyManager ran its own message loop
+    // or if PeekMessage was used exclusively in the main loop.
+    void handleHotkeys() {
+        MSG msg;
+        while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
+            if (msg.message == WM_HOTKEY) {
+                int hotkeyId = static_cast<int>(msg.wParam);
+                std::cout << "WM_HOTKEY received. ID: " << hotkeyId << std::endl;
+                if (hotkeyCallbacks.count(hotkeyId) > 0) {
+                    std::cout << "Executing callback for hotkey ID: " << hotkeyId << std::endl;
+                    hotkeyCallbacks[hotkeyId]();
+                } else {
+                    std::cerr << "No callback found for hotkey ID: " << hotkeyId << std::endl;
+                }
+            }
+        }
+    }
+    */
+
+private:
+    int nextHotkeyId;
+    std::unordered_map<int, std::function<void()>> hotkeyCallbacks;
+};