Added a bunch of comments because its probably good practice.

Author: AustinATTS

src/app/main.cpp

@@ -1,11 +1,12 @@
-#ifdef _WIN32
+#ifdef _WIN32 // Will only build the Windows version for Windows devices.
 #include <windows.h>
 extern int RunWindowsApp ( );
 
+// Windows expects a WinMain as the application entry point so it doesn't attempt to run it through the terminal.
 int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) {
-    return RunWindowsApp();
+    return RunWindowsApp(); // Call the main start function from WinApp.cpp.
 }
-#else
+#else // For other operating systems just return 0 as they haven't been implemented yet.
 int main ( ) {
     return 0;
 }

src/core/Platform.cpp

@@ -1,34 +1,35 @@
 #ifdef _WIN32
+// Separate code for Windows devices.
 #include "Platform.h"
 #include "win/WinBackend.h"
 
 namespace Platform {
 
     void init ( ) {
-        WinBackend::init();
+        WinBackend::init(); // Start.
     }
 
     void shutdown ( ) {
-        WinBackend::shutdown();
+        WinBackend::shutdown(); // End.
     }
 
     void setTargetWindow (WindowHandle w) {
-        WinBackend::setTargetWindow(w);
+        WinBackend::setTargetWindow(w); // Assign target window.
     }
 
     void lockInput ( ) {
-        WinBackend::lockInput();
+        WinBackend::lockInput(); // Lock the keyboard to the targeted window.
     }
 
     void unlockInput ( ) {
-        WinBackend::unlockInput();
+        WinBackend::unlockInput(); // Unlock the keyboard.
     }
 
     bool processEvents ( ) {
-        return WinBackend::processEvents();
+        return WinBackend::processEvents(); // Process events.
     }
 
 }
 #else
-
+// Currently do nothing for non Windows devices.
 #endif

src/win/WinApp.cpp

@@ -6,39 +6,39 @@
 
 
 static const char * WINDOW_CLASS = "SplitLoafTray";
-static HINSTANCE g_hInstance = NULL;
+static HINSTANCE g_hInstance = NULL; // A handle to the current instance of the application.
 
 LRESULT CALLBACK WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
     switch (msg) {
 
         case TRAY_CALLBACK:
             if (lParam == WM_RBUTTONUP) {
-                ShowTrayMenu(hwnd);
+                ShowTrayMenu(hwnd); // Show a menu when right clicked.
             }
             break;
 
         case WM_COMMAND:
             switch (LOWORD(wParam)) {
             case CMD_SETTINGS:
-                    OpenSettingsWindow(g_hInstance, hwnd);
+                    OpenSettingsWindow(g_hInstance, hwnd); // Open settings window when that option is selected.
                     break;
 
             case CMD_EXIT:
-                    PostQuitMessage(0);
+                    PostQuitMessage(0); // Exit the program if the option is selected.
                     break;
             }
             break;
 
         case WM_DESTROY:
-            RemoveTrayIcon();
+            RemoveTrayIcon(); // Close the app and remove it from the System Tray.
             PostQuitMessage(0);
             return 0;
     }
 
     return DefWindowProc(hwnd, msg, wParam, lParam);
 }
 
-int RunWindowsApp ( ) {
+int RunWindowsApp ( ) { // Create the application.
     g_hInstance = GetModuleHandle(NULL);
 
     WNDCLASS wc = {};
@@ -49,9 +49,9 @@ int RunWindowsApp ( ) {
 
     HWND hwnd = CreateWindowEx(0, WINDOW_CLASS, "Split Loaf",0, 0, 0, 0, 0,NULL, NULL, g_hInstance, NULL);
 
-    InitTrayIcon(hwnd);
+    InitTrayIcon(hwnd); // Create the System Tray icon.
 
-    Platform::init();
+    Platform::init(); // Start the main program.
 
     MSG msg {};
     while (true) {
@@ -60,7 +60,7 @@ int RunWindowsApp ( ) {
             DispatchMessage(& msg);
 
             if (msg.message == WM_QUIT) {
-                Platform::shutdown();
+                Platform::shutdown(); // Exit app if quit.
                 return 0;
             }
         }

src/win/WinBackend.cpp

@@ -4,10 +4,10 @@
 #include "WinTray.h"
 #include "core/Platform.h"
 
+// IDs for handling the button events.
 #define TRAY_CALLBACK (WM_USER + 1)
-
 #define CMD_SETTINGS 1001
-#define CMD_EXIT     1002
+#define CMD_EXIT 1002
 
 
 static HHOOK keyboardHook = NULL;
@@ -16,49 +16,50 @@ static bool locked = false;
 static bool targetHasFocus = false;
 
 HHOOK & WinHooks_GetKeyboardHook ( ) {
-    return keyboardHook;
+    return keyboardHook; // Gives the keyboard hook.
 }
 HWND & WinHooks_GetTargetWindow ( ) {
-    return targetWindow;
+    return targetWindow; // Gives the target window.
 }
 bool & WinHooks_GetLockedFlag ( ) {
-    return locked;
+    return locked; // Gives the current state of locked.
 }
 bool & WinHooks_GetTargetFocusFlag ( ) {
-    return targetHasFocus;
+    return targetHasFocus; // Gives the state of the target window.
 }
 
-void WinBackend::init ( ) {
+void WinBackend::init ( ) { // Sets up the keyboard hook.
     keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,LowLevelKeyboardProc,GetModuleHandle(NULL),0);
 }
 
-void WinBackend::shutdown ( ) {
+void WinBackend::shutdown ( ) { // Removes the hook when closed.
     UnhookWindowsHookEx(keyboardHook);
 }
 
 void WinBackend::setTargetWindow (WindowHandle w) {
-    targetWindow = (HWND)w;
+    targetWindow = (HWND)w; // Sets the target window.
 }
 
 void WinBackend::lockInput ( ) {
-    locked = true;
+    locked = true; // Sets the locked value.
 }
 
 void WinBackend::unlockInput ( ) {
-    locked = false;
+    locked = false; // Unlock the keyboard.
     targetHasFocus = false;
 }
 
 void WinBackend::sendVirtualKey (uint32_t vk) {
+    // Send a key down signal to the target window.
+    // Key up isn't important so can be left to be handled by Windows to allow modifier keys to be used.
     INPUT in = {0};
 
     in.type = INPUT_KEYBOARD;
     in.ki.wVk = vk;
 
-
     SendInput(1, & in, sizeof(INPUT));
 }
 
-bool WinBackend::processEvents ( ) {
+bool WinBackend::processEvents ( ) { // Handle processes.
     return true;
 }

src/win/WinHooks.cpp

@@ -6,41 +6,43 @@
 #include <string>
 #include <algorithm>
 
-std::string ToLower (const std::string & s) {
+std::string ToLower (const std::string & s) { // Set the string to lowercase.
     std::string out = s;
     std::transform(out.begin(), out.end(), out.begin(), ::tolower);
     return out;
 }
 
-std::string ToUpper (const std::string & s) {
+std::string ToUpper (const std::string & s) { // Set the string to uppercase.
     std::string out = s;
     std::transform(out.begin(), out.end(), out.begin(), ::toupper);
     return out;
 }
 
-std::string GetWindowTitle (HWND hwnd) {
+std::string GetWindowTitle (HWND hwnd) { // Get the name of the target window.
     char buffer[256];
     GetWindowTextA(hwnd, buffer, sizeof(buffer));
     return std::string(buffer);
 }
 
-void Tray_SetIdle ( ) {
+void Tray_SetIdle ( ) { // Set the tooltip for the System Tray to indicate state of the program as idle.
     UpdateTrayTooltip("Split Loaf - Idle");
 }
 
 void Tray_SetTargeted (const std::string & windowName) {
-    UpdateTrayTooltip("Split Loaf - " + ToLower(windowName));
+    UpdateTrayTooltip("Split Loaf - " + ToLower(windowName)); // When a window is targeted it shows the app name in lowercase.
 }
 
 void Tray_SetLocked (const std::string & windowName) {
-    UpdateTrayTooltip("Split Loaf - " + ToUpper(windowName));
+    UpdateTrayTooltip("Split Loaf - " + ToUpper(windowName)); // When the keyboard is locked, the name of the window is shown in capitals.
 }
 
 LRESULT CALLBACK LowLevelKeyboardProc (int nCode, WPARAM wParam, LPARAM lParam) {
     if (nCode != HC_ACTION) {
+        // If no action go to next.
         return CallNextHookEx(NULL, nCode, wParam, lParam);
     }
 
+    // Get the current values of the program state.
     auto & targetWindow = WinHooks_GetTargetWindow();
     auto & locked = WinHooks_GetLockedFlag();
     auto & targetHasFocus = WinHooks_GetTargetFocusFlag();
@@ -51,26 +53,32 @@ LRESULT CALLBACK LowLevelKeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
         return CallNextHookEx(NULL, nCode, wParam, lParam);
     }
 
-    if (wParam == WM_KEYDOWN) {
+    if (wParam == WM_KEYDOWN) { // For key press downs.
         if (kbd -> vkCode == VK_F8) {
+            // If F8 is pressed set the target window to the current one.
             POINT p;
             GetCursorPos(& p);
             targetWindow = WindowFromPoint(p);
             if (targetWindow) {
+                // If there is a suitable target window, update the tooltip and title.
                 std::string title = GetWindowTitle(targetWindow);
                 Tray_SetTargeted(title);
             } else {
+                // If not a suitable target, set it to idle.
                 Tray_SetIdle();
             }
             return 1;
         }
 
         if (kbd -> vkCode == VK_F6) {
+            // If F6 is pressed, lock the keyboard to the target window.
             locked = (targetWindow != NULL);
             if (locked) {
+                // If valid, update tooltip and name.
                 std::string title = GetWindowTitle(targetWindow);
                 Tray_SetLocked(title);
 
+                // Set the target window to be the main active window.
                 SetForegroundWindow(targetWindow);
                 Sleep(1);
                 targetHasFocus = 1;
@@ -79,33 +87,37 @@ LRESULT CALLBACK LowLevelKeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
         }
 
         if (kbd -> vkCode == VK_F7) {
+            // If F7 is pressed unlock the keyboard.
             locked = false;
             targetHasFocus = false;
             if (targetWindow) {
+                // If valid update the name and tooltip.
                 std::string title = GetWindowTitle(targetWindow);
                 Tray_SetTargeted(title);
             } else {
+                // If no valid window, set idle.
                 Tray_SetIdle();
             }
             return 1;
         }
     }
 
     if (locked && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN)) {
-        if (targetWindow) {
+        // For key presses down while locked.
+        if (targetWindow) { // If there is a target window.
             HWND fg = GetForegroundWindow();
 
-            if (fg != targetWindow) {
-                SetForegroundWindow(targetWindow);
-                Sleep(1);
-                targetHasFocus = 1;
+            if (fg != targetWindow) { // If the target window is not the active one.
+                SetForegroundWindow(targetWindow); // Make it active.
+                Sleep(1); // Sleep so it can be processed.
+                targetHasFocus = 1; // Say its been made active.
             }
 
-            WinBackend::sendVirtualKey(kbd -> vkCode);
+            WinBackend::sendVirtualKey(kbd -> vkCode); // Redirect the keyboard presses.
             return 1;
         }
     }
 
-    return CallNextHookEx (NULL, nCode, wParam, lParam);
+    return CallNextHookEx (NULL, nCode, wParam, lParam); // Move to the next.
 }