michael-treadgold/win-dictate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
dd25b2f58b0d390c4df3636b03419701bca11b94
win-dictate/src/main.cpp
T

1870 lines
76 KiB
C++
Raw Blame History

#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <objbase.h>
#include <windowsx.h>
#include <commctrl.h>
#include <shellapi.h>
#include <dwmapi.h>
#include <gdiplus.h>
#include <uxtheme.h>
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "dwmapi.lib")
#pragma comment(lib, "gdiplus.lib")
#pragma comment(lib, "uxtheme.lib")
using namespace Gdiplus;
#include <string>
#include <vector>
#include <cstring>
#include <cmath>
#include <thread>
#include <mutex>
#include <atomic>
#include <SDL.h>
#include "transcriber.h"
#include "text_util.h"
#include "whisper.h"
#include "settings.h"
#include "logging.h"
#include "timing.h"
#include "stats.h"
#include "history.h"
#include "downloader.h"
#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE
#define DWMWA_USE_IMMERSIVE_DARK_MODE 20
#endif
#ifndef DWMWA_BORDER_COLOR
#define DWMWA_BORDER_COLOR 34
#endif
#ifndef DWMWA_CAPTION_COLOR
#define DWMWA_CAPTION_COLOR 35
#endif
#ifndef DWMWA_TEXT_COLOR
#define DWMWA_TEXT_COLOR 36
#endif
#ifndef DWMWA_WINDOW_CORNER_PREFERENCE
#define DWMWA_WINDOW_CORNER_PREFERENCE 33
#endif
#ifndef DWMWCP_ROUND
#define DWMWCP_ROUND 2
#endif
#ifndef DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
#define DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2 ((DPI_AWARENESS_CONTEXT)-4)
#endif
#define WM_TRAYICON (WM_USER + 1)
#define WM_APP_RESULT (WM_USER + 2)
#define WM_APP_SHOW (WM_USER + 3)
#define WM_APP_SELECT (WM_USER + 5)
#define WM_APP_PROGRESS (WM_USER + 6)
#define ID_TRAY_APP_ICON 1001
#define ID_TRAY_EXIT 1002
#define ID_TRAY_SHOW 1003
#define ID_TRAY_AUTOPASTE 1016
#define ID_TRAY_TOPMOST 1017
#define ID_TRAY_AUTOHIDE 1018
#define ID_BTN_RECORD 1004
#define ID_BTN_CLEAR 1005
#define ID_EDIT_TEXT 1006
#define ID_COMBO_AUDIO 1007
#define ID_STATIC_STATUS 1009
#define ID_BTN_COPY 1011
#define ID_BTN_PASTE 1012
#define ID_BTN_PIN 1013
#define ID_STATIC_PLACEHOLDER 1014
#define ID_COMBO_MODEL 1015
#define ID_SEL_AUDIO 1007
#define ID_SEL_MODEL 1015
#define ID_TIMER_UPDATE 2
#define HK_TOGGLE 1
#define HK_HIDE 2
#define IDI_ICON1 101
#define CR_BG RGB(0x0E,0x10,0x14)
#define CR_SURFACE RGB(0x16,0x19,0x20)
#define CR_TEXT RGB(0xEC,0xEE,0xF2)
static const Color T_BG (255, 0x0E, 0x10, 0x14);
static const Color T_CARD (255, 0x16, 0x19, 0x20);
static const Color T_CARD_HI (255, 0x1E, 0x22, 0x2B);
static const Color T_CARD_LO (255, 0x12, 0x15, 0x1B);
static const Color T_TEXT (255, 0xEC, 0xEE, 0xF2);
static const Color T_DIM (255, 0x8A, 0x90, 0x9C);
static const Color T_FAINT (255, 0x5A, 0x60, 0x6C);
static const Color T_ACCENT (255, 0x6E, 0x8B, 0xFF);
static const Color T_ACCENT_HI(255, 0x83, 0x9C, 0xFF);
static const Color T_DANGER (255, 0xFF, 0x5C, 0x5C);
static const Color T_GOOD (255, 0x46, 0xD3, 0x9A);
static const Color T_TOPLIGHT (26, 0xFF, 0xFF, 0xFF);
static const Color C_BG = T_BG;
static const Color C_SURFACE = T_CARD;
static const Color C_SURFACEHI= T_CARD_HI;
static const Color C_BORDER = Color(255,0x26,0x2B,0x36);
static const Color C_TEXT = T_TEXT;
static const Color C_TEXTDIM = T_DIM;
static const Color C_ACCENT = T_ACCENT;
static const Color C_ACCENTHI = T_ACCENT_HI;
static const Color C_DANGER = T_DANGER;
static const Color C_GOOD = T_GOOD;
HINSTANCE hInst;
HWND hMainWnd;
NOTIFYICONDATA nid;
Transcriber g_tx;
WhisperConfig g_config;
HWND g_prevForeground = nullptr;
bool g_autoPaste = true;
bool g_pinned = true;
bool g_autoHide = false;
HANDLE g_hMutex = nullptr;
ULONG_PTR g_gdipToken = 0;
std::atomic<bool> g_modelLoaded{false};
std::atomic<bool> g_modelOk{false};
std::atomic<int> g_recordingSecs{0};
std::atomic<int> g_progress{0};
DWORD g_busyStart = 0;
float g_energy = 0.0f;
bool g_cancelRequested = false;
TimingModel g_timing;
ProgressEstimator g_est;
double g_lastAudioLen = 0.0;
DWORD g_lastTick = 0;
float g_progressFrac = 0.0f;
float g_progressRemain = 0.0f;
float g_dpiScale = 1.0f;
std::wstring g_statusOverride;
DWORD g_statusOverrideUntil = 0;
AppSettings g_set;
UsageStats g_stats;
bool g_editDirty = false;
DWORD g_insStart = 0, g_insEnd = 0;
REAL g_statsTopY = 0;
std::vector<HistoryEntry> g_history;
std::wstring g_lastLoadedText;
#define ID_SEL_HISTORY 1019
enum class View { Main, Settings };
View g_view = View::Main;
std::string g_pendingModelPath;
int g_setScroll = 0, g_setScrollMax = 0;
RectF g_sBack, g_sSave, g_sCancel;
RECT g_sContent = {0,0,0,0};
struct CatRowRect { RectF row, btn; };
int g_setHot = -1;
Downloader g_dl;
enum class DlState { NotInstalled, Downloading, Installed };
struct CatState { DlState state = DlState::NotInstalled; int pct = 0; };
static const float kMaxRecordSeconds = 600.0f;
void PersistNow() {
g_set.pinned = g_pinned;
g_set.autoPaste = g_autoPaste;
g_set.autoHide = g_autoHide;
g_set.captureId = g_config.capture_id;
{
std::string path = g_config.model_path;
g_set.modelFile = std::wstring(path.begin(), path.end());
}
RECT r; if (GetWindowRect(hMainWnd, &r)) {
g_set.winX = r.left; g_set.winY = r.top;
g_set.winW = r.right - r.left; g_set.winH = r.bottom - r.top;
}
SaveSettings(g_set);
}
RECT g_vuRect = {0,0,0,0};
RECT g_panelRect = {0,0,0,0};
HFONT g_fUI = nullptr, g_fUISemi = nullptr, g_fSmall = nullptr, g_fText = nullptr;
HBRUSH g_brBg = nullptr, g_brSurface = nullptr;
Gdiplus::Font* g_gpUI = nullptr;
Gdiplus::Font* g_gpUISemi = nullptr;
Gdiplus::Font* g_gpSmall = nullptr;
Gdiplus::Font* g_gpText = nullptr;
Gdiplus::Font* g_gpIcon = nullptr;
struct ModelInfo {
const wchar_t* display;
const char* fileName;
const wchar_t* sizeLabel;
const wchar_t* hint;
};
static const ModelInfo kCatalog[] = {
{ L"tiny.en", "ggml-tiny.en.bin", L"~75 MB", L"fastest" },
{ L"tiny.en-q8_0", "ggml-tiny.en-q8_0.bin", L"~42 MB", L"fastest, smaller file" },
{ L"base.en-q5_1", "ggml-base.en-q5_1.bin", L"~59 MB", L"good balance" },
{ L"base.en", "ggml-base.en.bin", L"~142 MB", L"more accurate" },
{ L"small.en-q5_1", "ggml-small.en-q5_1.bin", L"~182 MB", L"accurate — slow on this CPU" },
{ L"small.en", "ggml-small.en.bin", L"~466 MB", L"most accurate — slowest" },
};
static const int kCatalogCount = (int)std::size(kCatalog);
CatRowRect g_catRect[kCatalogCount];
CatState g_cat[kCatalogCount];
std::vector<std::string> g_modelComboPaths;
std::vector<std::wstring> g_audioItems; int g_audioSel = 0;
std::vector<std::wstring> g_modelItems; int g_modelSel = 0;
bool g_initializing = true;
struct PopupState { std::vector<std::wstring> items; int sel; int hot; HWND owner; int ctrlId; };
static PopupState g_pop;
enum class WK { RecordHero, Pin, SettingsCog, Copy, Paste, Clear, SelAudio, History, Transcript };
struct Widget {
WK kind;
RectF r;
bool hover = false;
bool pressed = false;
float anim = 0.0f;
};
static Widget g_w[ (int)WK::Transcript + 1 ];
static int g_hot = -1;
static int g_active = -1;
static DWORD g_lastFrame = 0;
static bool g_animating = false;
static bool AnyAnimating() {
if (g_animating) return true;
if (g_tx.is_recording() || g_tx.is_busy()) return true;
for (auto& w : g_w) {
float target = g_active == (&w - g_w) ? 1.0f : (w.hover ? 0.6f : 0.0f);
if (std::fabs(w.anim - target) > 0.002f) return true;
}
return false;
}
static void StepAnimations(float dt) {
for (auto& w : g_w) {
float target = (g_active == (&w - g_w)) ? 1.0f : (w.hover ? 0.6f : 0.0f);
w.anim += (target - w.anim) * std::min(1.0f, dt * 12.0f);
}
}
static void EnsureAnimating(HWND h) {
if (!g_animating) {
g_animating = true;
g_lastFrame = GetTickCount();
SetTimer(h, 3, 16, nullptr); // 16ms animation timer
}
}
static void StopAnimating(HWND h) {
KillTimer(h, 3);
g_animating = false;
}
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK PopupProc(HWND, UINT, WPARAM, LPARAM);
void ShowContextMenu(HWND, POINT);
void RefreshAudioDevices(HWND);
void RefreshModelList(HWND);
void SetStatus(HWND, const wchar_t*);
void UpdatePlaceholder(HWND);
void LayoutControls(HWND, int, int);
void LayoutWidgets(int W, int H);
void PaintSurface(HWND hwnd);
int HitTest(POINT p);
void OnClick(HWND hwnd, WK kind);
void DrawHero(Graphics& g, const Widget& w);
void DrawGhost(Graphics& g, const Widget& w, const wchar_t* label, bool active);
void DrawPinSurface(Graphics& g, const Widget& w);
void DrawIconChip(Graphics& g, const Widget& w, const wchar_t* glyph, const wchar_t* fallback, bool active);
void DrawSelectSurface(Graphics& g, const Widget& w, const std::wstring& text);
void DrawStatusStrip(Graphics& g, const RectF& strip);
void DrawCard(Graphics& g, const Rect& cardRect);
void DrawVU(Graphics&, const RECT&, float);
void DrawProgress(Graphics&, const RECT&, float);
void ShowSelectPopup(HWND owner, int ctrlId, const std::vector<std::wstring>& items, int sel, const RectF& anchor);
void SwitchView(HWND hwnd, View v);
void LayoutSettings(int W, int H);
void PaintSettings(Graphics& g, HWND hwnd, int W, int H);
int SettingsHitTest(POINT p);
void OnSettingsClick(HWND hwnd, POINT p);
void ApplySettings(HWND hwnd);
std::string exe_dir();
std::wstring to_w(const std::string&);
std::wstring GetEditText(HWND hwnd);
bool SetClipboardTextUtf8(HWND, const std::string&);
void send_ctrl_v();
void PasteIntoWindow(HWND);
bool DetectGPUAvailability();
std::string SelectOptimalModel(bool);
std::vector<std::wstring> BuildStatsLines();
static HFONT MakeFont(int px, int weight, float scale = 1.0f) {
return CreateFontW(-(int)(px * scale + 0.5f), 0, 0, 0, weight, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, L"Segoe UI Variable Display");
}
static void RebuildGdipFonts();
static void RecreateFonts(float scale) {
if (g_fUI) DeleteObject(g_fUI);
if (g_fUISemi) DeleteObject(g_fUISemi);
if (g_fSmall) DeleteObject(g_fSmall);
if (g_fText) DeleteObject(g_fText);
g_fUI = MakeFont(15, FW_NORMAL, scale);
g_fUISemi = MakeFont(15, FW_SEMIBOLD, scale);
g_fSmall = MakeFont(12, FW_NORMAL, scale);
g_fText = MakeFont(16, FW_NORMAL, scale);
if (!g_fUI) g_fUI = MakeFont(15, FW_NORMAL, scale);
RebuildGdipFonts();
}
static Gdiplus::Font* GdipFontFromHFont(HFONT hf) {
HDC sdc = GetDC(nullptr);
Gdiplus::Font* f = new Gdiplus::Font(sdc, hf);
ReleaseDC(nullptr, sdc);
if (f->GetLastStatus() != Ok) { delete f; return nullptr; }
return f;
}
static void RebuildGdipFonts() {
delete g_gpUI; delete g_gpUISemi; delete g_gpSmall; delete g_gpText; delete g_gpIcon;
g_gpUI = GdipFontFromHFont(g_fUI);
g_gpUISemi = GdipFontFromHFont(g_fUISemi);
g_gpSmall = GdipFontFromHFont(g_fSmall);
g_gpText = GdipFontFromHFont(g_fText);
g_gpIcon = new Gdiplus::Font(L"Segoe MDL2 Assets", 15.0f * g_dpiScale, FontStyleRegular, UnitPixel);
if (g_gpIcon->GetLastStatus() != Ok) { delete g_gpIcon; g_gpIcon = nullptr; }
if (!g_gpUI) g_gpUI = new Gdiplus::Font(L"Segoe UI", 15.0f * g_dpiScale, FontStyleRegular, UnitPixel);
if (!g_gpUISemi) g_gpUISemi = new Gdiplus::Font(L"Segoe UI", 15.0f * g_dpiScale, FontStyleBold, UnitPixel);
if (!g_gpSmall) g_gpSmall = new Gdiplus::Font(L"Segoe UI", 12.0f * g_dpiScale, FontStyleRegular, UnitPixel);
if (!g_gpText) g_gpText = new Gdiplus::Font(L"Segoe UI", 16.0f * g_dpiScale, FontStyleRegular, UnitPixel);
}
static void RoundPath(GraphicsPath& p, const Rect& r, int rad) {
int d = rad * 2;
p.AddArc(r.X, r.Y, d, d, 180, 90);
p.AddArc(r.GetRight() - d, r.Y, d, d, 270, 90);
p.AddArc(r.GetRight() - d, r.GetBottom() - d, d, d, 0, 90);
p.AddArc(r.X, r.GetBottom() - d, d, d, 90, 90);
p.CloseFigure();
}
static void FillRound(Graphics& g, const Color& c, const Rect& r, int rad) {
GraphicsPath p; RoundPath(p, r, rad); SolidBrush b(c); g.FillPath(&b, &p);
}
static void StrokeRound(Graphics& g, const Color& c, const Rect& r, int rad, REAL w = 1.0f) {
GraphicsPath p; RoundPath(p, r, rad); Pen pen(c, w); g.DrawPath(&pen, &p);
}
static void DrawTextC(Graphics& g, const wchar_t* s, const Font& f, const Color& c,
const RectF& box, StringAlignment h, StringAlignment v) {
StringFormat sf; sf.SetAlignment(h); sf.SetLineAlignment(v);
sf.SetTrimming(StringTrimmingEllipsisCharacter);
SolidBrush b(c); g.DrawString(s, -1, &f, box, &sf, &b);
}
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR, int nCmdShow) {
hInst = hInstance;
g_hMutex = CreateMutexW(nullptr, TRUE, L"WhisperDictation_SingleInstance");
if (GetLastError() == ERROR_ALREADY_EXISTS) {
HWND existing = FindWindowW(L"WhisperDictationClass", nullptr);
if (existing) PostMessage(existing, WM_APP_SHOW, 0, 0);
CloseHandle(g_hMutex);
return 0;
}
GdiplusStartupInput gdipIn;
if (GdiplusStartup(&g_gdipToken, &gdipIn, nullptr) != Ok) return 1;
SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
INITCOMMONCONTROLSEX icex;
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = ICC_WIN95_CLASSES | ICC_STANDARD_CLASSES;
InitCommonControlsEx(&icex);
g_fUI = MakeFont(15, FW_NORMAL, g_dpiScale);
g_fUISemi = MakeFont(15, FW_SEMIBOLD, g_dpiScale);
g_fSmall = MakeFont(12, FW_NORMAL, g_dpiScale);
g_fText = MakeFont(16, FW_NORMAL, g_dpiScale);
if (!g_fUI) g_fUI = MakeFont(15, FW_NORMAL, g_dpiScale);
g_brBg = CreateSolidBrush(CR_BG);
g_brSurface = CreateSolidBrush(CR_SURFACE);
WNDCLASSEX wc = {0};
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
wc.hbrBackground = g_brBg;
wc.lpszClassName = L"WhisperDictationClass";
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
RegisterClassEx(&wc);
LoadSettings(g_set);
g_pinned = g_set.pinned;
g_autoPaste = g_set.autoPaste;
g_autoHide = g_set.autoHide;
hMainWnd = CreateWindowExW(
g_pinned ? WS_EX_TOPMOST : 0,
L"WhisperDictationClass", L"Dictation",
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN,
g_set.winX, g_set.winY, g_set.winW, g_set.winH,
nullptr, nullptr, hInstance, nullptr);
if (!hMainWnd) return FALSE;
g_dpiScale = GetDpiForWindow(hMainWnd) / 96.0f;
if (g_dpiScale <= 0.0f) g_dpiScale = 1.0f;
RecreateFonts(g_dpiScale);
BOOL dark = TRUE;
DwmSetWindowAttribute(hMainWnd, DWMWA_USE_IMMERSIVE_DARK_MODE, &dark, sizeof(dark));
COLORREF cap = CR_BG, bord = RGB(0x5A,0x60,0x6C), txt = CR_TEXT;
DwmSetWindowAttribute(hMainWnd, DWMWA_CAPTION_COLOR, &cap, sizeof(cap));
DwmSetWindowAttribute(hMainWnd, DWMWA_BORDER_COLOR, &bord, sizeof(bord));
DwmSetWindowAttribute(hMainWnd, DWMWA_TEXT_COLOR, &txt, sizeof(txt));
int corner = DWMWCP_ROUND;
DwmSetWindowAttribute(hMainWnd, DWMWA_WINDOW_CORNER_PREFERENCE, &corner, sizeof(corner));
{
HWND hBtnRecord = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_BTN_RECORD, hInst, nullptr);
SetWindowTheme(hBtnRecord, L"", L"");
HWND hPin = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_BTN_PIN, hInst, nullptr);
SetWindowTheme(hPin, L"", L"");
CreateWindow(L"STATIC", L"Ready",
WS_CHILD | WS_VISIBLE | SS_LEFT,
0, 0, 0, 0, hMainWnd, (HMENU)ID_STATIC_STATUS, hInst, nullptr);
HWND hEdit = CreateWindowExW(0, L"EDIT", L"",
WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE | ES_AUTOVSCROLL,
0, 0, 0, 0, hMainWnd, (HMENU)ID_EDIT_TEXT, hInst, nullptr);
SetWindowTheme(hEdit, L"DarkMode_Explorer", nullptr);
SendMessage(hEdit, WM_SETFONT, (WPARAM)g_fText, TRUE);
int editMargin = (int)(10 * g_dpiScale);
SendMessage(hEdit, EM_SETMARGINS, EC_LEFTMARGIN | EC_RIGHTMARGIN, MAKELONG(editMargin, editMargin));
CreateWindowW(L"STATIC", L"Your transcription will appear here\u2026",
WS_CHILD | WS_VISIBLE | SS_LEFT,
0, 0, 0, 0, hMainWnd, (HMENU)ID_STATIC_PLACEHOLDER, hInst, nullptr);
HWND hSelAudio = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_SEL_AUDIO, hInst, nullptr);
SetWindowTheme(hSelAudio, L"", L"");
HWND hSelModel = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_SEL_MODEL, hInst, nullptr);
SetWindowTheme(hSelModel, L"", L"");
HWND hCopy = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_BTN_COPY, hInst, nullptr);
SetWindowTheme(hCopy, L"", L"");
HWND hPaste = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_BTN_PASTE, hInst, nullptr);
SetWindowTheme(hPaste, L"", L"");
HWND hClear = CreateWindow(L"BUTTON", L"",
WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_OWNERDRAW,
0, 0, 0, 0, hMainWnd, (HMENU)ID_BTN_CLEAR, hInst, nullptr);
SetWindowTheme(hClear, L"", L"");
}
ShowWindow(GetDlgItem(hMainWnd, ID_BTN_RECORD), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_BTN_PIN), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_STATIC_STATUS), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_STATIC_PLACEHOLDER), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_SEL_AUDIO), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_SEL_MODEL), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_BTN_COPY), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_BTN_PASTE), SW_HIDE);
ShowWindow(GetDlgItem(hMainWnd, ID_BTN_CLEAR), SW_HIDE);
SendMessageW(hMainWnd, WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEFOCUS), 0);
SDL_Init(SDL_INIT_AUDIO);
RefreshAudioDevices(hMainWnd);
RefreshModelList(hMainWnd);
CreateDirectoryA((exe_dir() + "\\models").c_str(), nullptr);
{
WIN32_FIND_DATAA fd;
HANDLE h = FindFirstFileA((exe_dir() + "\\models\\*.part").c_str(), &fd);
if (h != INVALID_HANDLE_VALUE) {
do { DeleteFileA((exe_dir() + "\\models\\" + fd.cFileName).c_str()); } while (FindNextFileA(h, &fd));
FindClose(h);
}
}
bool has_gpu = DetectGPUAvailability();
std::string model = SelectOptimalModel(has_gpu);
if (!g_set.modelFile.empty()) {
std::string mf;
{
int len = WideCharToMultiByte(CP_UTF8, 0, g_set.modelFile.c_str(), -1, nullptr, 0, nullptr, nullptr);
if (len > 0) { mf.resize(len - 1); WideCharToMultiByte(CP_UTF8, 0, g_set.modelFile.c_str(), -1, &mf[0], len, nullptr, nullptr); }
}
if (GetFileAttributesA(mf.c_str()) != INVALID_FILE_ATTRIBUTES) {
g_config.model_path = mf;
for (int i = 0; i < (int)g_modelComboPaths.size(); ++i) {
std::string p = exe_dir() + "\\" + g_modelComboPaths[i];
if (p == mf) { g_modelSel = i; break; }
}
}
}
if (g_config.model_path.empty()) {
if (!g_modelComboPaths.empty())
g_config.model_path = exe_dir() + "\\" + g_modelComboPaths[0];
else
g_config.model_path = exe_dir() + "\\" + model;
}
g_config.n_threads = 0;
g_config.capture_id = g_set.captureId;
SeedDefaults(g_timing, g_config.model_path);
LoadTiming(g_timing, g_config.model_path);
LoadStats(g_stats);
g_history = LoadHistoryIndex();
{
char log[256];
snprintf(log, sizeof(log), "Startup model=%s threads=%d capture_id=%d",
g_config.model_path.c_str(), g_config.n_threads, g_config.capture_id);
LogLine(log);
}
nid.cbSize = sizeof(NOTIFYICONDATA);
nid.hWnd = hMainWnd;
nid.uID = ID_TRAY_APP_ICON;
nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
nid.uCallbackMessage = WM_TRAYICON;
nid.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
wcscpy_s(nid.szTip, L"Dictation");
Shell_NotifyIcon(NIM_ADD, &nid);
bool hkOk1 = RegisterHotKey(hMainWnd, HK_TOGGLE, g_set.hkMods, g_set.hkVk) != FALSE;
bool hkOk2 = RegisterHotKey(hMainWnd, HK_HIDE, MOD_CONTROL | MOD_SHIFT, 'H') != FALSE;
if (!hkOk1) SetStatus(hMainWnd, L"Hotkey in use \u2014 edit win-dictation.ini");
g_tx.set_result_callback([](const std::string& t) {
PostMessage(hMainWnd, WM_APP_RESULT, (WPARAM)new std::string(t), 0);
});
g_tx.set_progress_callback([](int p) {
PostMessage(hMainWnd, WM_APP_PROGRESS, (WPARAM)p, 0);
});
std::thread([] {
bool ok = g_tx.preload(g_config);
g_modelOk = ok;
g_modelLoaded = true;
LogLine(ok ? "Model loaded successfully" : "Model load FAILED");
}).detach();
SetTimer(hMainWnd, ID_TIMER_UPDATE, 50, nullptr);
SetStatus(hMainWnd, L"Loading model\u2026");
ShowWindow(hMainWnd, nCmdShow);
{
RECT rc; GetClientRect(hMainWnd, &rc);
LayoutControls(hMainWnd, rc.right, rc.bottom);
LayoutWidgets(rc.right, rc.bottom);
}
InvalidateRect(hMainWnd, nullptr, FALSE);
g_initializing = false;
MSG msg;
while (GetMessage(&msg, nullptr, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
KillTimer(hMainWnd, ID_TIMER_UPDATE);
UnregisterHotKey(hMainWnd, HK_TOGGLE);
UnregisterHotKey(hMainWnd, HK_HIDE);
g_tx.cancel();
g_dl.requestCancel();
g_dl.join();
Shell_NotifyIcon(NIM_DELETE, &nid);
SDL_Quit();
ReleaseMutex(g_hMutex);
CloseHandle(g_hMutex);
delete g_gpUI; delete g_gpUISemi; delete g_gpSmall; delete g_gpText; delete g_gpIcon;
g_gpUI = g_gpUISemi = g_gpSmall = g_gpText = g_gpIcon = nullptr;
GdiplusShutdown(g_gdipToken);
DeleteObject(g_fUI); DeleteObject(g_fUISemi);
DeleteObject(g_fSmall); DeleteObject(g_fText);
DeleteObject(g_brBg); DeleteObject(g_brSurface);
return (int)msg.wParam;
}
void DrawVU(Graphics& g, const RECT& r, float level) {
const int N = 14, gap = 3;
int w = r.right - r.left;
if (w <= 0) return;
int segW = (w - gap * (N - 1)) / N;
if (segW < 1) return;
int h = r.bottom - r.top;
int lit = (int)(level * N + 0.5f);
for (int i = 0; i < N; ++i) {
int x = r.left + i * (segW + gap);
Rect seg(x, r.top, segW, h);
FillRound(g, (i < lit) ? C_GOOD : C_SURFACEHI, seg, 2);
}
}
void DrawProgress(Graphics& g, const RECT& r, float frac) {
Rect track(r.left, r.top, r.right - r.left, r.bottom - r.top);
FillRound(g, C_SURFACEHI, track, 4);
frac = frac < 0.0f ? 0.0f : (frac > 1.0f ? 1.0f : frac);
int fullW = r.right - r.left;
int w = (int)(fullW * frac);
if (w > 0) { Rect fill(r.left, r.top, w, r.bottom - r.top); FillRound(g, C_ACCENT, fill, 4); }
if (frac >= 0.949f && frac < 1.0f) {
double ph = (GetTickCount() % 1100) / 1100.0;
BYTE a = (BYTE)(70 + 150 * (0.5 + 0.5 * sin(ph * 6.2831853)));
Rect tail(r.left + w, r.top, fullW - w, r.bottom - r.top);
FillRound(g, Color(a, 0x6E, 0x8B, 0xFF), tail, 4);
}
}
LRESULT CALLBACK PopupProc(HWND h, UINT m, WPARAM w, LPARAM l) {
switch (m) {
case WM_MOUSEMOVE: {
int row = GET_Y_LPARAM(l) / 30;
if (row != g_pop.hot) { g_pop.hot = row; InvalidateRect(h, nullptr, FALSE); }
TRACKMOUSEEVENT t{ sizeof(t), TME_LEAVE, h, 0 }; TrackMouseEvent(&t);
return 0;
}
case WM_MOUSELEAVE: g_pop.hot = -1; InvalidateRect(h, nullptr, FALSE); return 0;
case WM_LBUTTONUP: {
int row = GET_Y_LPARAM(l) / 30;
if (row >= 0 && row < (int)g_pop.items.size())
PostMessageW(g_pop.owner, WM_APP_SELECT, (WPARAM)g_pop.ctrlId, (LPARAM)row);
DestroyWindow(h); return 0;
}
case WM_KILLFOCUS: DestroyWindow(h); return 0;
case WM_ERASEBKGND: return 1;
case WM_PAINT: {
PAINTSTRUCT ps; HDC hdc = BeginPaint(h, &ps);
RECT rc; GetClientRect(h, &rc);
HDC mem = CreateCompatibleDC(hdc);
HBITMAP bmp = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);
HBITMAP old = (HBITMAP)SelectObject(mem, bmp);
{
Graphics g(mem); g.SetSmoothingMode(SmoothingModeAntiAlias);
Rect all(0, 0, rc.right, rc.bottom);
FillRound(g, T_CARD, all, 10); StrokeRound(g, T_FAINT, all, 10, 1.0f);
Font f(mem, g_fUI);
for (int i = 0; i < (int)g_pop.items.size(); ++i) {
Rect row(3, i * 30 + 3, rc.right - 6, 28);
if (i == g_pop.hot) FillRound(g, T_CARD_HI, row, 7);
RectF tb((REAL)row.X + 9, (REAL)row.Y, (REAL)row.Width - 12, (REAL)row.Height);
DrawTextC(g, g_pop.items[i].c_str(), f, (i == g_pop.sel) ? T_ACCENT : T_TEXT,
tb, StringAlignmentNear, StringAlignmentCenter);
}
}
BitBlt(hdc, 0, 0, rc.right, rc.bottom, mem, 0, 0, SRCCOPY);
SelectObject(mem, old); DeleteObject(bmp); DeleteDC(mem);
EndPaint(h, &ps); return 0;
}
}
return DefWindowProc(h, m, w, l);
}
void ShowSelectPopup(HWND owner, int ctrlId, const std::vector<std::wstring>& items, int sel, const RectF& anchor) {
static bool reg = false;
if (!reg) {
WNDCLASSEXW wc{ sizeof(wc) };
wc.lpfnWndProc = PopupProc;
wc.hInstance = hInst;
wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
wc.hbrBackground = CreateSolidBrush(CR_SURFACE);
wc.lpszClassName = L"DictPopup";
RegisterClassExW(&wc);
reg = true;
}
g_pop = { items, sel, -1, owner, ctrlId };
POINT tl{ (LONG)anchor.X, (LONG)(anchor.Y + anchor.Height) };
ClientToScreen(owner, &tl);
int h = (int)items.size() * 30 + 6, wdt = (int)anchor.Width;
HWND p = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_TOPMOST, L"DictPopup", L"",
WS_POPUP, tl.x, tl.y + 2, wdt, h, owner, nullptr, hInst, nullptr);
int corner = DWMWCP_ROUND; DwmSetWindowAttribute(p, DWMWA_WINDOW_CORNER_PREFERENCE, &corner, sizeof(corner));
ShowWindow(p, SW_SHOWNA); SetFocus(p);
}
void LayoutControls(HWND h, int W, int H) {
float s = g_dpiScale;
const int M = (int)(16 * s), row = (int)(36 * s), gap = (int)(10 * s);
int x = M, y = M, innerW = W - 2 * M;
int pinW = (int)(78 * s), recW = innerW - pinW - gap;
MoveWindow(GetDlgItem(h, ID_BTN_RECORD), x, y, recW, row, TRUE);
MoveWindow(GetDlgItem(h, ID_BTN_PIN), x + recW + gap, y, pinW, row, TRUE);
y += row + gap;
int vuH = (int)(8 * s);
g_vuRect = { x, y, x + innerW, y + vuH };
y += vuH + gap;
MoveWindow(GetDlgItem(h, ID_STATIC_STATUS), x, y, innerW, (int)(18 * s), TRUE);
y += (int)(18 * s) + gap;
int bottom = (row + gap) * 2;
int panelTop = y;
int textH = H - y - M - bottom;
if (textH < (int)(70 * s)) textH = (int)(70 * s);
int editPad = (int)(10 * s);
MoveWindow(GetDlgItem(h, ID_EDIT_TEXT), x + editPad, panelTop + editPad, innerW - 2 * editPad, textH - 2 * editPad, TRUE);
MoveWindow(GetDlgItem(h, ID_STATIC_PLACEHOLDER), x + (int)(16 * s), panelTop + (int)(16 * s), innerW - (int)(32 * s), (int)(22 * s), TRUE);
y += textH + gap;
int halfW = (innerW - gap) / 2;
MoveWindow(GetDlgItem(h, ID_SEL_AUDIO), x, y, halfW, row, TRUE);
MoveWindow(GetDlgItem(h, ID_SEL_MODEL), x + halfW + gap, y, halfW, row, TRUE);
y += row + gap;
int thirdW = (innerW - gap * 2) / 3;
MoveWindow(GetDlgItem(h, ID_BTN_COPY), x, y, thirdW, row, TRUE);
MoveWindow(GetDlgItem(h, ID_BTN_PASTE), x + thirdW + gap, y, thirdW, row, TRUE);
MoveWindow(GetDlgItem(h, ID_BTN_CLEAR), x + (thirdW + gap) * 2, y, thirdW, row, TRUE);
g_panelRect = { x, panelTop, x + innerW, panelTop + textH };
InvalidateRect(h, nullptr, FALSE);
}
void LayoutWidgets(int W, int H) {
for (int i = 0; i < (int)std::size(g_w); ++i)
g_w[i].kind = (WK)i;
for (auto& w : g_w) w.r = RectF(0, 0, 0, 0);
float s = g_dpiScale;
const REAL M = 16 * s, row = 36 * s, gap = 10 * s;
REAL x = M, y = M, innerW = W - 2 * M;
REAL iconW = 44 * s;
REAL recW = innerW - 2 * (iconW + gap);
g_w[(int)WK::RecordHero].r = RectF(x, y, recW, row);
g_w[(int)WK::Pin].r = RectF(x + recW + gap, y, iconW, row);
g_w[(int)WK::SettingsCog].r = RectF(x + recW + gap + iconW + gap, y, iconW, row);
y += row + gap;
REAL vuH = 8 * s;
g_vuRect = { (int)x, (int)y, (int)(x + innerW), (int)(y + vuH) };
y += vuH + gap;
REAL statusH = 18 * s;
y += statusH + gap; // status strip space (drawn by PaintSurface)
int bottom = (int)((row + gap) * 2);
REAL panelTop = y;
int textH = H - (int)y - (int)M - bottom;
if (textH < (int)(70 * s)) textH = (int)(70 * s);
int editPad = (int)(10 * s);
MoveWindow(GetDlgItem(hMainWnd, ID_EDIT_TEXT), (int)(x + editPad), (int)(panelTop + editPad),
(int)(innerW - 2 * editPad), textH - 2 * editPad, TRUE);
g_w[(int)WK::Transcript].r = RectF(x + editPad, panelTop + editPad, innerW - 2 * editPad, (REAL)(textH - 2 * editPad));
y += textH + gap;
REAL halfW = (innerW - gap) / 2;
g_w[(int)WK::SelAudio].r = RectF(x, y, halfW, row);
g_w[(int)WK::History].r = RectF(x + halfW + gap, y, halfW, row);
y += row + gap;
REAL thirdW = (innerW - gap * 2) / 3;
g_w[(int)WK::Copy].r = RectF(x, y, thirdW, row);
g_w[(int)WK::Paste].r = RectF(x + thirdW + gap, y, thirdW, row);
g_w[(int)WK::Clear].r = RectF(x + (thirdW + gap) * 2, y, thirdW, row);
g_panelRect = { (int)x, (int)panelTop, (int)(x + innerW), (int)(panelTop + textH) };
}
void DrawCard(Graphics& g, const Rect& cardRect) {
FillRound(g, T_CARD, cardRect, (int)(16 * g_dpiScale));
int r = (int)(16 * g_dpiScale);
int d = r * 2;
if (d < 1) return;
GraphicsPath p;
p.AddArc(cardRect.X, cardRect.Y, d, d, 180, 90);
p.AddArc(cardRect.GetRight() - d, cardRect.Y, d, d, 270, 90);
p.AddArc(cardRect.GetRight() - d, cardRect.GetBottom() - d, d, d, 0, 90);
p.AddArc(cardRect.X, cardRect.GetBottom() - d, d, d, 90, 90);
p.CloseFigure();
Pen topLight(T_TOPLIGHT, 1.0f);
g.DrawPath(&topLight, &p);
}
void DrawHero(Graphics& g, const Widget& w) {
Rect rc((int)w.r.X, (int)w.r.Y, (int)w.r.Width, (int)w.r.Height);
bool rec = g_tx.is_recording();
bool hover = w.hover;
bool pressed = w.pressed;
Color fill = rec ? T_DANGER : (hover ? T_ACCENT_HI : T_ACCENT);
if (rec) {
double ph = (GetTickCount() % 1400) / 1400.0;
int add = (int)(18 * (0.5 + 0.5 * sin(ph * 6.2831853)));
fill = Color(255, (BYTE)std::min(255, 0xFF), (BYTE)std::min(255, 0x5C + add), (BYTE)std::min(255, 0x5C + add));
}
if (pressed) fill = Color(255, (BYTE)(fill.GetR() * 0.85f),
(BYTE)(fill.GetG() * 0.85f),
(BYTE)(fill.GetB() * 0.85f));
Rect pill = rc; pill.Inflate(-1, -1);
FillRound(g, fill, pill, pill.Height / 2);
int cx = pill.X + (int)(22 * g_dpiScale), cy = pill.Y + pill.Height / 2;
SolidBrush white(Color(255, 255, 255, 255));
if (rec) { Rect sq(cx - 7, cy - 7, 14, 14); FillRound(g, Color(255, 255, 255, 255), sq, 3); }
else { g.FillEllipse(&white, cx - 7, cy - 7, 14, 14); }
RectF tb((REAL)(pill.X + (int)(36 * g_dpiScale)), (REAL)pill.Y, (REAL)(pill.Width - (int)(44 * g_dpiScale)), (REAL)pill.Height);
DrawTextC(g, rec ? L"Stop" : L"Record", *g_gpUISemi, Color(255, 255, 255, 255),
tb, StringAlignmentNear, StringAlignmentCenter);
}
void DrawGhost(Graphics& g, const Widget& w, const wchar_t* label, bool active) {
Rect rc((int)w.r.X, (int)w.r.Y, (int)w.r.Width, (int)w.r.Height);
Rect chip = rc; chip.Inflate(-1, -1);
float a = w.anim;
if (a > 0.001f) {
BYTE bgAlpha = (BYTE)(std::min(255, (int)(255 * a)));
Color bg(T_CARD_HI.GetA(), T_CARD_HI.GetR(), T_CARD_HI.GetG(), T_CARD_HI.GetB());
if (w.pressed) bg = Color(bgAlpha, T_CARD_LO.GetR(), T_CARD_LO.GetG(), T_CARD_LO.GetB());
else bg = Color(bgAlpha, T_CARD_HI.GetR(), T_CARD_HI.GetG(), T_CARD_HI.GetB());
FillRound(g, bg, chip, (int)(10 * g_dpiScale));
}
BYTE tr = (BYTE)(T_DIM.GetR() + (T_TEXT.GetR() - T_DIM.GetR()) * a);
BYTE tg = (BYTE)(T_DIM.GetG() + (T_TEXT.GetG() - T_DIM.GetG()) * a);
BYTE tb = (BYTE)(T_DIM.GetB() + (T_TEXT.GetB() - T_DIM.GetB()) * a);
Color tc(255, tr, tg, tb);
if (active && a < 0.01f) tc = T_ACCENT;
RectF textBox((REAL)chip.X, (REAL)chip.Y, (REAL)chip.Width, (REAL)chip.Height);
DrawTextC(g, label, *g_gpUI, tc, textBox, StringAlignmentCenter, StringAlignmentCenter);
}
void DrawPinSurface(Graphics& g, const Widget& w) {
Rect rc((int)w.r.X, (int)w.r.Y, (int)w.r.Width, (int)w.r.Height);
Rect chip = rc; chip.Inflate(-1, -1);
float a = w.anim;
if (a > 0.001f) {
BYTE bgAlpha = (BYTE)(std::min(255, (int)(255 * a)));
Color bg = w.pressed ? Color(bgAlpha, T_CARD_LO.GetR(), T_CARD_LO.GetG(), T_CARD_LO.GetB())
: Color(bgAlpha, T_CARD_HI.GetR(), T_CARD_HI.GetG(), T_CARD_HI.GetB());
FillRound(g, bg, chip, (int)(10 * g_dpiScale));
}
Color tc = g_pinned ? T_ACCENT : (a > 0.01f ? T_TEXT : T_FAINT);
RectF tb((REAL)chip.X, (REAL)chip.Y, (REAL)chip.Width, (REAL)chip.Height);
DrawTextC(g, g_pinned ? L"Pinned" : L"Pin", *g_gpUI, tc, tb, StringAlignmentCenter, StringAlignmentCenter);
}
void DrawIconChip(Graphics& g, const Widget& w, const wchar_t* glyph,
const wchar_t* fallback, bool active) {
Rect chip((int)w.r.X, (int)w.r.Y, (int)w.r.Width, (int)w.r.Height);
chip.Inflate(-1, -1);
float a = w.anim;
if (a > 0.001f) {
BYTE al = (BYTE)std::min(255, (int)(255 * a));
FillRound(g, Color(al, T_CARD_HI.GetR(), T_CARD_HI.GetG(), T_CARD_HI.GetB()),
chip, (int)(10 * g_dpiScale));
}
Color tc = active ? T_ACCENT : (a > 0.01f ? T_TEXT : T_FAINT);
RectF tb((REAL)chip.X, (REAL)chip.Y, (REAL)chip.Width, (REAL)chip.Height);
if (g_gpIcon) DrawTextC(g, glyph, *g_gpIcon, tc, tb, StringAlignmentCenter, StringAlignmentCenter);
else DrawTextC(g, fallback, *g_gpUI, tc, tb, StringAlignmentCenter, StringAlignmentCenter);
}
void DrawSelectSurface(Graphics& g, const Widget& w, const std::wstring& text) {
Rect rc((int)w.r.X, (int)w.r.Y, (int)w.r.Width, (int)w.r.Height);
Rect field = rc; field.Inflate(-1, -1);
float a = w.anim;
if (a > 0.001f) {
BYTE bgAlpha = (BYTE)(std::min(255, (int)(255 * a)));
FillRound(g, Color(bgAlpha, T_CARD_HI.GetR(), T_CARD_HI.GetG(), T_CARD_HI.GetB()),
field, (int)(9 * g_dpiScale));
} else {
FillRound(g, T_CARD, field, (int)(9 * g_dpiScale));
}
Pen border(T_FAINT, 1.0f);
Rect brd = field; brd.Inflate(-1, -1);
StrokeRound(g, T_FAINT, brd, (int)(9 * g_dpiScale), 1.0f);
RectF tb((REAL)field.X + (10 * g_dpiScale), (REAL)field.Y,
(REAL)(field.Width - 28 * g_dpiScale), (REAL)field.Height);
DrawTextC(g, text.c_str(), *g_gpUI, T_TEXT, tb, StringAlignmentNear, StringAlignmentCenter);
int cx = field.X + field.Width - (int)(16 * g_dpiScale), cy = field.Y + field.Height / 2;
Pen pen(T_DIM, 1.6f);
g.DrawLine(&pen, cx - 4, cy - 2, cx, cy + 2);
g.DrawLine(&pen, cx, cy + 2, cx + 4, cy - 2);
}
void DrawStatusStrip(Graphics& g, const RectF& strip) {
RECT r = { (int)strip.X, (int)strip.Y, (int)(strip.X + strip.Width), (int)(strip.Y + strip.Height) };
if (g_tx.is_busy()) {
DrawProgress(g, r, g_progressFrac);
} else if (g_tx.is_recording()) {
DrawVU(g, r, g_energy);
}
}
void PaintSurface(HWND hwnd) {
PAINTSTRUCT ps; HDC hdc = BeginPaint(hwnd, &ps);
RECT rcCli; GetClientRect(hwnd, &rcCli);
int W = rcCli.right - rcCli.left, H = rcCli.bottom - rcCli.top;
if (W <= 0 || H <= 0) { EndPaint(hwnd, &ps); return; }
HDC mem = CreateCompatibleDC(hdc);
HBITMAP bmp = CreateCompatibleBitmap(hdc, W, H);
HBITMAP old = (HBITMAP)SelectObject(mem, bmp);
{
Graphics g(mem);
g.SetSmoothingMode(SmoothingModeAntiAlias);
g.SetTextRenderingHint(TextRenderingHintClearTypeGridFit);
SolidBrush bg(T_BG); g.FillRectangle(&bg, 0, 0, W, H);
if (g_view == View::Settings) { PaintSettings(g, hwnd, W, H); }
else {
Rect panel(g_panelRect.left, g_panelRect.top,
g_panelRect.right - g_panelRect.left,
g_panelRect.bottom - g_panelRect.top);
DrawCard(g, panel);
for (auto& w : g_w) {
switch (w.kind) {
case WK::RecordHero: DrawHero(g, w); break;
case WK::Copy: DrawGhost(g, w, L"Copy", false); break;
case WK::Paste: DrawGhost(g, w, L"Paste", false); break;
case WK::Clear: DrawGhost(g, w, L"Clear", false); break;
case WK::Pin: DrawIconChip(g, w, L"\uE718", L"P", g_pinned); break;
case WK::SettingsCog: DrawIconChip(g, w, L"\uE713", L"\u2699", false); break;
case WK::History: DrawSelectSurface(g, w, L"History"); break;
case WK::SelAudio: DrawSelectSurface(g, w, g_audioItems.empty() ? L"No devices" : g_audioItems[g_audioSel]); break;
case WK::Transcript: break;
}
}
RECT vr = g_vuRect;
RectF stripRect((REAL)vr.left, (REAL)vr.top, (REAL)(vr.right - vr.left), (REAL)(vr.bottom - vr.top));
DrawStatusStrip(g, stripRect);
wchar_t statusBuf[256];
if (g_tx.is_recording()) {
int secs = g_recordingSecs.load();
swprintf_s(statusBuf, L"Recording %d:%02d", secs / 60, secs % 60);
} else if (g_tx.is_busy()) {
int pct = (int)(g_progressFrac*100.0f + 0.5f);
float total = g_tx.audio_seconds();
int mm = (int)total / 60;
int ss = (int)total % 60;
int rem = (int)(g_progressRemain + 0.5f);
if (g_progressFrac >= 0.949f)
swprintf_s(statusBuf, L"Transcribing %d:%02d \u2022 95%% \u2022 finishing\u2026", mm, ss);
else
swprintf_s(statusBuf, L"Transcribing %d:%02d \u2022 %d%% \u2022 %ds left", mm, ss, pct, rem);
} else if (g_modelLoaded.load()) {
if (!g_statusOverride.empty() && GetTickCount() < g_statusOverrideUntil) {
wcscpy_s(statusBuf, g_statusOverride.c_str());
} else if (!g_modelOk.load()) {
swprintf_s(statusBuf, L"Model not found \u2014 check models folder");
} else {
swprintf_s(statusBuf, L"Ready \u2022 %d threads", g_tx.threads());
}
} else {
swprintf_s(statusBuf, L"Loading model\u2026");
}
REAL vy = g_vuRect.top + g_vuRect.bottom - g_vuRect.top + (REAL)(10 * g_dpiScale);
RectF statusBox((REAL)g_vuRect.left, vy,
(REAL)(g_vuRect.right - g_vuRect.left), (REAL)(18 * g_dpiScale));
DrawTextC(g, statusBuf, *g_gpSmall, T_DIM, statusBox, StringAlignmentNear, StringAlignmentNear);
bool empty = GetWindowTextLengthW(GetDlgItem(hwnd, ID_EDIT_TEXT)) == 0;
if (empty && !g_tx.is_busy()) {
RectF placeholderBox(g_w[(int)WK::Transcript].r.X + (6 * g_dpiScale),
g_w[(int)WK::Transcript].r.Y + (6 * g_dpiScale),
g_w[(int)WK::Transcript].r.Width,
(REAL)(22 * g_dpiScale));
DrawTextC(g, L"Your transcription will appear here\u2026", *g_gpText, T_DIM,
placeholderBox, StringAlignmentNear, StringAlignmentNear);
}
} // else (view == Main)
}
BitBlt(hdc, 0, 0, W, H, mem, 0, 0, SRCCOPY);
SelectObject(mem, old); DeleteObject(bmp); DeleteDC(mem);
EndPaint(hwnd, &ps);
}
int HitTest(POINT p) {
for (int i = 0; i < (int)std::size(g_w); ++i)
if (g_w[i].kind != WK::Transcript && g_w[i].r.Contains((REAL)p.x, (REAL)p.y)) return i;
return -1;
}
void OnClick(HWND hWnd, WK kind) {
if (!g_modelLoaded.load() && kind != WK::RecordHero && kind != WK::Clear
&& kind != WK::Copy && kind != WK::Paste && kind != WK::Pin
&& kind != WK::History && kind != WK::SettingsCog && kind != WK::SelAudio) return;
switch (kind) {
case WK::RecordHero:
PostMessage(hWnd, WM_HOTKEY, HK_TOGGLE, 0);
break;
case WK::Copy: {
int len = GetWindowTextLengthW(GetDlgItem(hWnd, ID_EDIT_TEXT));
if (len > 0) {
std::vector<wchar_t> buf(len + 1);
GetDlgItemTextW(hWnd, ID_EDIT_TEXT, buf.data(), (int)buf.size());
std::wstring w(buf.data());
int u8len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, nullptr, 0, nullptr, nullptr);
std::string u8(u8len ? u8len - 1 : 0, '\0');
if (u8len) WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, &u8[0], u8len, nullptr, nullptr);
SetClipboardTextUtf8(hWnd, u8);
SetStatus(hWnd, L"Copied");
}
break;
}
case WK::Paste:
if (g_prevForeground) {
HWND target = g_prevForeground;
ShowWindow(hWnd, SW_HIDE);
Sleep(60);
PasteIntoWindow(target);
}
break;
case WK::Clear: {
std::wstring cur = GetEditText(hWnd);
if (!cur.empty() && cur != g_lastLoadedText)
ArchiveSession(cur);
g_history = LoadHistoryIndex();
g_lastLoadedText.clear();
g_editDirty = false;
SetDlgItemText(hWnd, ID_EDIT_TEXT, L"");
UpdatePlaceholder(hWnd);
SetStatus(hWnd, L"Saved to history");
break;
}
case WK::Pin:
g_pinned = !g_pinned;
SetWindowPos(hWnd, g_pinned ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
InvalidateRect(hWnd, nullptr, FALSE);
PersistNow();
break;
case WK::SelAudio:
ShowSelectPopup(hWnd, ID_SEL_AUDIO, g_audioItems, g_audioSel, g_w[(int)WK::SelAudio].r);
break;
case WK::History: {
wchar_t dbg[64];
swprintf_s(dbg, L"History: %d entries", (int)g_history.size());
SetStatus(hWnd, dbg);
std::vector<std::wstring> items;
for (auto& e : g_history) items.push_back(e.label);
if (items.empty()) items.push_back(L"No history yet");
ShowSelectPopup(hWnd, ID_SEL_HISTORY, items, -1, g_w[(int)WK::History].r);
break;
}
case WK::SettingsCog: SwitchView(hWnd, View::Settings); break;
default: break;
}
}
void RefreshCatalogStates() {
std::string dir = exe_dir();
for (int i = 0; i < kCatalogCount; ++i) {
if (g_dl.active.load() && g_dl.itemIndex == i) { g_cat[i].state = DlState::Downloading; continue; }
std::string full = dir + "\\models\\" + kCatalog[i].fileName;
g_cat[i].state = (GetFileAttributesA(full.c_str()) != INVALID_FILE_ATTRIBUTES)
? DlState::Installed : DlState::NotInstalled;
g_cat[i].pct = 0;
}
}
void SwitchView(HWND hwnd, View v) {
g_view = v;
ShowWindow(GetDlgItem(hwnd, ID_EDIT_TEXT), v == View::Main ? SW_SHOW : SW_HIDE);
if (v == View::Settings) {
g_pendingModelPath = g_config.model_path;
g_setScroll = 0;
RefreshCatalogStates();
}
RECT rc; GetClientRect(hwnd, &rc);
LayoutWidgets(rc.right, rc.bottom);
if (v == View::Settings) LayoutSettings(rc.right, rc.bottom);
g_setHot = -1;
InvalidateRect(hwnd, nullptr, FALSE);
}
void LayoutSettings(int W, int H) {
float s = g_dpiScale;
const REAL M = 16 * s, row = 36 * s, gap = 10 * s;
g_sBack = RectF(M, M, 90 * s, row);
g_sSave = RectF(M, H - M - row, (W - 2*M - gap) / 2, row);
g_sCancel = RectF(M + (W - 2*M - gap)/2 + gap, H - M - row, (W - 2*M - gap)/2, row);
g_sContent = { (int)M, (int)(M + row + gap), (int)(W - M), (int)(H - M - row - gap) };
REAL cy = (REAL)g_sContent.top - g_setScroll;
REAL cw = (REAL)(g_sContent.right - g_sContent.left);
cy += 22 * s;
for (int i = 0; i < kCatalogCount; ++i) {
g_catRect[i].row = RectF(M, cy, cw, 34 * s);
REAL bw = 112 * s;
g_catRect[i].btn = RectF(M + cw - bw, cy + 3 * s, bw, 28 * s);
cy += 40 * s;
}
cy += 26 * s;
REAL statsTop = cy;
cy += (REAL)BuildStatsLines().size() * 20 * s;
g_statsTopY = statsTop;
int contentH = (int)(cy + g_setScroll) - g_sContent.top + (int)(8 * s);
int viewH = g_sContent.bottom - g_sContent.top;
g_setScrollMax = std::max(0, contentH - viewH);
if (g_setScroll > g_setScrollMax) g_setScroll = g_setScrollMax;
}
void DrawCatalogButton(Graphics& g, int i, bool installed) {
const RectF& b = g_catRect[i].btn;
Rect br((int)b.X, (int)b.Y, (int)b.Width, (int)b.Height);
bool hov = (g_setHot == 100 + i);
wchar_t label[32]; Color tc = T_DIM;
switch (g_cat[i].state) {
case DlState::Installed:
wcscpy_s(label, L"Installed"); tc = T_GOOD; break;
case DlState::Downloading:
swprintf_s(label, 32, L"%d%% \u2715", g_cat[i].pct); tc = T_ACCENT; break;
default:
wcscpy_s(label, L"Download"); tc = hov ? T_TEXT : T_DIM; break;
}
if (hov && g_cat[i].state != DlState::Installed)
FillRound(g, T_CARD_HI, br, (int)(8 * g_dpiScale));
DrawTextC(g, label, *g_gpSmall, tc, b, StringAlignmentCenter, StringAlignmentCenter);
}
void OnCatalogButton(HWND hwnd, int i) {
switch (g_cat[i].state) {
case DlState::Installed: {
std::string full = exe_dir() + "\\models\\" + kCatalog[i].fileName;
g_pendingModelPath = full;
break;
}
case DlState::Downloading:
g_dl.requestCancel();
break;
default: {
if (g_dl.active.load()) { SetStatus(hwnd, L"One download at a time"); return; }
std::wstring url = L"https://huggingface.co/ggerganov/whisper.cpp/resolve/main/"
+ to_w(kCatalog[i].fileName);
std::wstring dest = to_w(exe_dir()) + L"\\models\\" + to_w(kCatalog[i].fileName);
g_cat[i].state = DlState::Downloading; g_cat[i].pct = 0;
g_dl.start(hwnd, i, url, dest);
break;
}
}
InvalidateRect(hwnd, nullptr, FALSE);
}
void PaintSettings(Graphics& g, HWND hwnd, int W, int H) {
float s = g_dpiScale;
bool hb = (g_setHot == 200);
if (hb) FillRound(g, T_CARD_HI, Rect((int)g_sBack.X,(int)g_sBack.Y,(int)g_sBack.Width,(int)g_sBack.Height), (int)(10*s));
DrawTextC(g, L"\u2190 Back", *g_gpUI, hb ? T_TEXT : T_DIM, g_sBack, StringAlignmentCenter, StringAlignmentCenter);
RectF title((REAL)g_sContent.left, g_sBack.Y, (REAL)(g_sContent.right - g_sContent.left), g_sBack.Height);
DrawTextC(g, L"Settings", *g_gpUISemi, T_TEXT, title, StringAlignmentCenter, StringAlignmentCenter);
g.SetClip(Rect(g_sContent.left, g_sContent.top,
g_sContent.right - g_sContent.left, g_sContent.bottom - g_sContent.top));
RectF cap(g_catRect[0].row.X, g_catRect[0].row.Y - 20*s, 300*s, 18*s);
DrawTextC(g, L"MODEL", *g_gpSmall, T_FAINT, cap, StringAlignmentNear, StringAlignmentNear);
std::string dir = exe_dir();
for (int i = 0; i < kCatalogCount; ++i) {
const RectF& r = g_catRect[i].row;
std::string rel = std::string("models\\") + kCatalog[i].fileName;
bool installed = GetFileAttributesA((dir + "\\" + rel).c_str()) != INVALID_FILE_ATTRIBUTES;
bool selected = (g_pendingModelPath == dir + "\\" + rel);
if (g_setHot == i && installed)
FillRound(g, T_CARD_HI, Rect((int)r.X,(int)r.Y,(int)r.Width,(int)r.Height), (int)(9*s));
int rx = (int)(r.X + 12*s), ry = (int)(r.Y + r.Height/2);
Pen ring(installed ? T_DIM : T_FAINT, 1.4f);
g.DrawEllipse(&ring, rx-6, ry-6, 12, 12);
if (selected) { SolidBrush dot(T_ACCENT); g.FillEllipse(&dot, rx-3, ry-3, 6, 6); }
RectF nameBox(r.X + 30*s, r.Y, 150*s, r.Height);
DrawTextC(g, kCatalog[i].display, *g_gpUI, installed ? T_TEXT : T_DIM,
nameBox, StringAlignmentNear, StringAlignmentCenter);
wchar_t meta[96]; swprintf_s(meta, L"%s \u00b7 %s", kCatalog[i].sizeLabel, kCatalog[i].hint);
RectF metaBox(r.X + 30*s + 150*s, r.Y, r.Width - 30*s - 150*s - 120*s, r.Height);
DrawTextC(g, meta, *g_gpSmall, T_FAINT, metaBox, StringAlignmentNear, StringAlignmentCenter);
DrawCatalogButton(g, i, installed);
}
RectF scap(g_catRect[0].row.X, g_statsTopY - 20*s, 300*s, 18*s);
DrawTextC(g, L"STATISTICS", *g_gpSmall, T_FAINT, scap, StringAlignmentNear, StringAlignmentNear);
auto lines = BuildStatsLines();
for (size_t i = 0; i < lines.size(); ++i) {
RectF lr(g_catRect[0].row.X, g_statsTopY + (REAL)i * 20*s, (REAL)(g_sContent.right - g_sContent.left), 18*s);
DrawTextC(g, lines[i].c_str(), *g_gpUI, T_DIM, lr, StringAlignmentNear, StringAlignmentNear);
}
g.ResetClip();
Rect sv((int)g_sSave.X,(int)g_sSave.Y,(int)g_sSave.Width,(int)g_sSave.Height);
FillRound(g, g_setHot == 201 ? T_ACCENT_HI : T_ACCENT, sv, (int)(10*s));
DrawTextC(g, L"Save", *g_gpUISemi, Color(255,255,255,255), g_sSave, StringAlignmentCenter, StringAlignmentCenter);
if (g_setHot == 202)
FillRound(g, T_CARD_HI, Rect((int)g_sCancel.X,(int)g_sCancel.Y,(int)g_sCancel.Width,(int)g_sCancel.Height), (int)(10*s));
DrawTextC(g, L"Cancel", *g_gpUI, g_setHot == 202 ? T_TEXT : T_DIM, g_sCancel, StringAlignmentCenter, StringAlignmentCenter);
}
static bool PtIn(const RectF& r, POINT p) { return r.Contains((REAL)p.x, (REAL)p.y); }
int SettingsHitTest(POINT p) {
if (PtIn(g_sBack, p)) return 200;
if (PtIn(g_sSave, p)) return 201;
if (PtIn(g_sCancel, p)) return 202;
if (!PtInRect(&g_sContent, p)) return -1;
for (int i = 0; i < kCatalogCount; ++i) {
if (PtIn(g_catRect[i].btn, p)) return 100 + i;
if (PtIn(g_catRect[i].row, p)) return i;
}
return -1;
}
void OnSettingsClick(HWND hwnd, POINT p) {
int hit = SettingsHitTest(p);
if (hit == 200 || hit == 202) { SwitchView(hwnd, View::Main); return; }
if (hit == 201) { ApplySettings(hwnd); return; }
if (hit >= 100 && hit < 100 + kCatalogCount) { OnCatalogButton(hwnd, hit - 100); return; }
if (hit >= 0 && hit < kCatalogCount) {
std::string full = exe_dir() + "\\models\\" + kCatalog[hit].fileName;
if (GetFileAttributesA(full.c_str()) != INVALID_FILE_ATTRIBUTES) {
g_pendingModelPath = full;
InvalidateRect(hwnd, nullptr, FALSE);
}
}
}
void ApplySettings(HWND hwnd) {
if (!g_pendingModelPath.empty() && g_pendingModelPath != g_config.model_path) {
g_config.model_path = g_pendingModelPath;
SeedDefaults(g_timing, g_config.model_path);
LoadTiming(g_timing, g_config.model_path);
g_modelLoaded = false; g_modelOk = false;
std::thread([] {
bool ok = g_tx.reload(g_config);
g_modelOk = ok; g_modelLoaded = true;
}).detach();
PersistNow();
SetStatus(hwnd, L"Settings saved \u2014 loading model\u2026");
}
SwitchView(hwnd, View::Main);
}
void UpdatePlaceholder(HWND hwnd) {
bool empty = GetWindowTextLengthW(GetDlgItem(hwnd, ID_EDIT_TEXT)) == 0;
ShowWindow(GetDlgItem(hwnd, ID_STATIC_PLACEHOLDER), empty ? SW_SHOW : SW_HIDE);
}
void RefreshAudioDevices(HWND hwnd) {
g_audioItems.clear();
std::vector<std::string> devices = Transcriber::get_audio_devices();
for (const auto& device : devices) {
int len = MultiByteToWideChar(CP_UTF8, 0, device.c_str(), -1, nullptr, 0);
if (len > 0) {
std::vector<wchar_t> wbuf(len);
MultiByteToWideChar(CP_UTF8, 0, device.c_str(), -1, wbuf.data(), len);
g_audioItems.push_back(wbuf.data());
}
}
if (g_audioItems.empty())
g_audioItems.push_back(L"No devices");
g_audioSel = 0;
g_config.capture_id = 0;
InvalidateRect(GetDlgItem(hwnd, ID_SEL_AUDIO), nullptr, FALSE);
}
void RefreshModelList(HWND hwnd) {
g_modelItems.clear();
g_modelComboPaths.clear();
std::string dir = exe_dir();
for (int i = 0; i < kCatalogCount; ++i) {
std::string rel = std::string("models\\") + kCatalog[i].fileName;
if (GetFileAttributesA((dir + "\\" + rel).c_str()) != INVALID_FILE_ATTRIBUTES) {
g_modelItems.push_back(kCatalog[i].display);
g_modelComboPaths.push_back(rel);
}
}
g_modelSel = 0;
InvalidateRect(GetDlgItem(hwnd, ID_SEL_MODEL), nullptr, FALSE);
}
void SetStatus(HWND hwnd, const wchar_t* text) {
g_statusOverride = text;
g_statusOverrideUntil = GetTickCount() + 2500;
InvalidateRect(hwnd, nullptr, FALSE);
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
switch (message) {
case WM_CTLCOLORSTATIC:
{
HDC hdc = (HDC)wParam;
if (GetDlgCtrlID((HWND)lParam) == ID_STATIC_PLACEHOLDER) {
SetTextColor(hdc, RGB(0x9A, 0xA0, 0xAB));
SetBkColor(hdc, CR_SURFACE);
return (LRESULT)g_brSurface;
}
SetTextColor(hdc, CR_TEXT);
SetBkColor(hdc, CR_BG);
return (LRESULT)g_brBg;
}
case WM_CTLCOLOREDIT:
{
HDC hdc = (HDC)wParam;
SetTextColor(hdc, CR_TEXT);
SetBkColor(hdc, CR_SURFACE);
return (LRESULT)g_brSurface;
}
case WM_ERASEBKGND:
return 1;
case WM_PAINT:
PaintSurface(hWnd);
return 0;
case WM_MOUSEMOVE: {
if (g_view == View::Settings) {
POINT p{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
int hot = SettingsHitTest(p);
if (hot != g_setHot) { g_setHot = hot; InvalidateRect(hWnd, nullptr, FALSE); }
TRACKMOUSEEVENT t{ sizeof(t), TME_LEAVE, hWnd, 0 }; TrackMouseEvent(&t);
return 0;
}
POINT p{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
int hot = HitTest(p);
if (hot != g_hot) {
if (g_hot >= 0) g_w[g_hot].hover = false;
g_hot = hot;
if (g_hot >= 0) g_w[g_hot].hover = true;
TRACKMOUSEEVENT t{ sizeof(t), TME_LEAVE, hWnd, 0 }; TrackMouseEvent(&t);
EnsureAnimating(hWnd);
}
return 0;
}
case WM_MOUSELEAVE:
if (g_hot >= 0) { g_w[g_hot].hover = false; g_hot = -1; EnsureAnimating(hWnd); }
return 0;
case WM_LBUTTONDOWN:
if (g_view == View::Settings) return 0;
g_active = g_hot;
if (g_active >= 0) { g_w[g_active].pressed = true; SetCapture(hWnd); EnsureAnimating(hWnd); }
return 0;
case WM_LBUTTONUP: {
if (g_view == View::Settings) {
POINT p{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
OnSettingsClick(hWnd, p);
return 0;
}
ReleaseCapture();
POINT p{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
if (g_active >= 0 && HitTest(p) == g_active) OnClick(hWnd, g_w[g_active].kind);
if (g_active >= 0) g_w[g_active].pressed = false;
g_active = -1; EnsureAnimating(hWnd);
return 0;
}
case WM_MOUSEWHEEL:
if (g_view == View::Settings) {
g_setScroll -= GET_WHEEL_DELTA_WPARAM(wParam) / 2;
g_setScroll = std::max(0, std::min(g_setScroll, g_setScrollMax));
RECT rc; GetClientRect(hWnd, &rc);
LayoutSettings(rc.right, rc.bottom);
InvalidateRect(hWnd, nullptr, FALSE);
}
return 0;
case WM_DPICHANGED: {
g_dpiScale = LOWORD(wParam) / 96.0f;
if (g_dpiScale <= 0.0f) g_dpiScale = 1.0f;
RecreateFonts(g_dpiScale);
RECT* sug = (RECT*)lParam;
SetWindowPos(hWnd, nullptr, sug->left, sug->top,
sug->right - sug->left, sug->bottom - sug->top,
SWP_NOZORDER | SWP_NOACTIVATE);
HWND hEdit = GetDlgItem(hWnd, ID_EDIT_TEXT);
if (hEdit) SendMessage(hEdit, WM_SETFONT, (WPARAM)g_fText, TRUE);
LayoutControls(hWnd, sug->right - sug->left, sug->bottom - sug->top);
LayoutWidgets(sug->right - sug->left, sug->bottom - sug->top);
if (g_view == View::Settings) LayoutSettings(sug->right - sug->left, sug->bottom - sug->top);
InvalidateRect(hWnd, nullptr, TRUE);
return 0;
}
case WM_SIZE:
LayoutControls(hWnd, LOWORD(lParam), HIWORD(lParam));
LayoutWidgets(LOWORD(lParam), HIWORD(lParam));
if (g_view == View::Settings) LayoutSettings(LOWORD(lParam), HIWORD(lParam));
return 0;
case WM_EXITSIZEMOVE:
PersistNow();
return 0;
case WM_GETMINMAXINFO:
((MINMAXINFO*)lParam)->ptMinTrackSize.x = (LONG)(340 * g_dpiScale);
((MINMAXINFO*)lParam)->ptMinTrackSize.y = (LONG)(280 * g_dpiScale);
return 0;
case WM_TIMER:
if (wParam == 3) {
DWORD now = GetTickCount();
float dt = (now - g_lastFrame) / 1000.0f; g_lastFrame = now;
if (dt <= 0.0f) dt = 0.016f;
StepAnimations(dt);
if (!AnyAnimating()) {
StopAnimating(hWnd);
}
InvalidateRect(hWnd, nullptr, FALSE);
}
if (wParam == ID_TIMER_UPDATE) {
if (g_tx.is_recording()) {
g_energy = g_tx.get_audio_energy();
InvalidateRect(hWnd, nullptr, FALSE);
static DWORD lastTick = 0;
DWORD now = GetTickCount();
if (now - lastTick >= 1000) {
g_recordingSecs.store(g_recordingSecs.load() + 1);
lastTick = now;
}
if (g_tx.recorded_seconds() >= kMaxRecordSeconds) {
g_lastAudioLen = g_tx.recorded_seconds();
g_busyStart = GetTickCount();
g_lastTick = g_busyStart;
g_progress = 0;
g_cancelRequested = false;
g_est.begin(g_timing.predict(g_lastAudioLen));
g_tx.stop_and_transcribe();
SetStatus(hWnd, L"Max length reached \u2014 transcribing\u2026");
}
} else {
g_energy = 0.0f;
if (g_tx.is_busy()) {
DWORD now = GetTickCount();
float dt = (now - g_lastTick) / 1000.0f; g_lastTick = now;
if (dt <= 0.0f) dt = 0.05f;
g_est.tick(dt, g_progressFrac, g_progressRemain);
InvalidateRect(hWnd, nullptr, FALSE);
}
}
}
break;
case WM_HOTKEY:
if (wParam == HK_TOGGLE) {
if (g_tx.is_busy()) {
g_tx.request_cancel();
g_cancelRequested = true;
g_est.reset_busy();
g_progressFrac = 0.0f;
g_progressRemain = 0.0f;
SetStatus(hWnd, L"Cancelling\u2026");
break;
}
if (!g_tx.is_recording()) {
if (g_view == View::Settings) SwitchView(hWnd, View::Main);
if (!g_modelLoaded.load()) { SetStatus(hWnd, L"Loading model\u2026"); break; }
if (!g_modelOk.load()) {
std::wstring m = L"Model not found:\n" + to_w(g_config.model_path)
+ L"\n\nPut the .bin there and restart.";
MessageBoxW(hWnd, m.c_str(), L"Dictation", MB_OK | MB_ICONWARNING);
break;
}
g_prevForeground = GetForegroundWindow();
ShowWindow(hWnd, SW_SHOWNA);
g_recordingSecs = 0;
{
DWORD s = 0, e = 0;
SendMessageW(GetDlgItem(hWnd, ID_EDIT_TEXT), EM_GETSEL, (WPARAM)&s, (LPARAM)&e);
g_insStart = s; g_insEnd = e;
}
if (g_tx.start_recording()) {
SetStatus(hWnd, L"Recording\u2026");
} else {
SetStatus(hWnd, L"Microphone error");
}
} else {
g_lastAudioLen = g_tx.recorded_seconds();
g_busyStart = GetTickCount();
g_lastTick = g_busyStart;
g_progress = 0;
g_cancelRequested = false;
g_est.begin(g_timing.predict(g_lastAudioLen));
g_tx.stop_and_transcribe();
SetStatus(hWnd, L"Transcribing\u2026");
}
} else if (wParam == HK_HIDE) {
if (g_tx.is_recording()) g_tx.cancel();
ShowWindow(hWnd, SW_HIDE);
}
break;
case WM_APP_SHOW:
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
break;
case WM_APP_RESULT:
{
float frac, remain; g_est.finish(frac, remain);
g_progressFrac = 1.0f; g_progressRemain = 0.0f;
double actual = (GetTickCount() - g_busyStart) / 1000.0;
if (g_lastAudioLen > 0.5 && actual > 0.2 && !g_cancelRequested) {
g_timing.add_sample(g_lastAudioLen, actual);
SaveTiming(g_timing, g_config.model_path);
}
std::string* res = (std::string*)wParam;
if (res && !res->empty()) {
RecordUsage(g_stats, g_lastAudioLen, actual, to_w(*res));
char log[128];
float secs = g_tx.audio_seconds();
snprintf(log, sizeof(log), "Transcribed %.1fs %d chars", secs, (int)res->size());
LogLine(log);
HWND hEdit = GetDlgItem(hWnd, ID_EDIT_TEXT);
std::wstring full = GetEditText(hWnd);
DWORD s = std::min<DWORD>(g_insStart, (DWORD)full.size());
DWORD e = std::min<DWORD>(g_insEnd, (DWORD)full.size());
std::wstring add = to_w(*res);
bool needLead = (s > 0) && !iswspace(full[s - 1]);
bool needTrail = (e < full.size()) && !iswspace(full[e]);
std::wstring ins = (needLead ? L" " : L"") + add + (needTrail ? L" " : L"");
SendMessageW(hEdit, EM_SETSEL, s, e);
SendMessageW(hEdit, EM_REPLACESEL, TRUE, (LPARAM)ins.c_str());
SendMessageW(hEdit, EM_SCROLLCARET, 0, 0);
UpdatePlaceholder(hWnd);
g_lastLoadedText = GetEditText(hWnd);
SetClipboardTextUtf8(hWnd, *res);
bool pasted = false;
if (g_autoPaste && g_prevForeground &&
g_prevForeground != hWnd && IsWindow(g_prevForeground)) {
PasteIntoWindow(g_prevForeground);
pasted = true;
}
if (pasted && g_autoHide) {
ShowWindow(hWnd, SW_HIDE);
}
SetStatus(hWnd, pasted ? L"Pasted" : L"Copied");
} else {
SetStatus(hWnd, g_cancelRequested ? L"Cancelled" : L"No speech detected");
}
delete res;
}
break;
case WM_APP_PROGRESS: {
double t_now = (GetTickCount() - g_busyStart) / 1000.0;
g_est.on_whisper(t_now, (int)wParam);
InvalidateRect(hWnd, &g_vuRect, FALSE);
return 0;
}
case WM_APP_DLPROGRESS: {
int idx = (int)wParam, code = (int)lParam;
if (idx >= 0 && idx < kCatalogCount) {
if (code >= 0 && code <= 100) {
g_cat[idx].state = DlState::Downloading; g_cat[idx].pct = code;
} else {
g_dl.join(); g_dl.active = false;
if (code == 101) {
RefreshModelList(hWnd);
SetStatus(hWnd, L"Model downloaded");
} else {
SetStatus(hWnd, code == -2 ? L"Download cancelled" : L"Download failed");
}
RefreshCatalogStates();
}
}
InvalidateRect(hWnd, nullptr, FALSE);
return 0;
}
case WM_APP_SELECT: {
int ctrlId = (int)wParam, idx = (int)lParam;
if (ctrlId == ID_SEL_AUDIO) {
g_audioSel = idx;
g_config.capture_id = idx;
InvalidateRect(GetDlgItem(hWnd, ID_SEL_AUDIO), nullptr, FALSE);
PersistNow();
} else if (ctrlId == ID_SEL_MODEL && idx >= 0 && idx < (int)g_modelComboPaths.size()) {
g_modelSel = idx;
g_config.model_path = exe_dir() + "\\" + g_modelComboPaths[idx];
SeedDefaults(g_timing, g_config.model_path);
LoadTiming(g_timing, g_config.model_path);
g_modelLoaded = false; g_modelOk = false;
SetStatus(hWnd, L"Loading model\u2026");
std::thread([] {
bool ok = g_tx.reload(g_config);
g_modelOk = ok; g_modelLoaded = true;
}).detach();
InvalidateRect(GetDlgItem(hWnd, ID_SEL_MODEL), nullptr, FALSE);
PersistNow();
} else if (ctrlId == ID_SEL_HISTORY && idx >= 0 && idx < (int)g_history.size()) {
std::wstring cur = GetEditText(hWnd);
if (!cur.empty() && cur != g_lastLoadedText)
ArchiveSession(cur);
std::wstring text = ReadFileUtf8(g_history[idx].path);
SetWindowTextW(GetDlgItem(hWnd, ID_EDIT_TEXT), text.c_str());
g_lastLoadedText = text;
g_editDirty = false;
g_history = LoadHistoryIndex();
UpdatePlaceholder(hWnd);
SetStatus(hWnd, L"Loaded from history");
}
return 0;
}
case WM_COMMAND:
if (LOWORD(wParam) == ID_EDIT_TEXT && HIWORD(wParam) == EN_CHANGE) {
g_editDirty = true;
break;
}
switch (LOWORD(wParam)) {
case ID_TRAY_EXIT:
DestroyWindow(hWnd);
break;
case ID_TRAY_SHOW:
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
break;
case ID_TRAY_AUTOPASTE:
g_autoPaste = !g_autoPaste;
PersistNow();
break;
case ID_TRAY_TOPMOST:
g_pinned = !g_pinned;
SetWindowPos(hWnd, g_pinned ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
InvalidateRect(GetDlgItem(hWnd, ID_BTN_PIN), nullptr, FALSE);
PersistNow();
break;
case ID_TRAY_AUTOHIDE:
g_autoHide = !g_autoHide;
PersistNow();
break;
case ID_BTN_RECORD:
PostMessage(hWnd, WM_HOTKEY, HK_TOGGLE, 0);
break;
case ID_BTN_CLEAR: {
std::wstring cur = GetEditText(hWnd);
if (!cur.empty() && cur != g_lastLoadedText)
ArchiveSession(cur);
g_history = LoadHistoryIndex();
g_lastLoadedText.clear();
g_editDirty = false;
SetDlgItemText(hWnd, ID_EDIT_TEXT, L"");
UpdatePlaceholder(hWnd);
SetStatus(hWnd, L"Saved to history");
break;
}
case ID_BTN_PIN:
g_pinned = !g_pinned;
SetWindowPos(hWnd, g_pinned ? HWND_TOPMOST : HWND_NOTOPMOST,
0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
InvalidateRect(GetDlgItem(hWnd, ID_BTN_PIN), nullptr, FALSE);
PersistNow();
break;
case ID_BTN_COPY:
{
int len = GetWindowTextLengthW(GetDlgItem(hWnd, ID_EDIT_TEXT));
if (len > 0) {
std::vector<wchar_t> buf(len + 1);
GetDlgItemTextW(hWnd, ID_EDIT_TEXT, buf.data(), (int)buf.size());
std::wstring w(buf.data());
int u8len = WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, nullptr, 0, nullptr, nullptr);
std::string u8(u8len ? u8len - 1 : 0, '\0');
if (u8len) WideCharToMultiByte(CP_UTF8, 0, w.c_str(), -1, &u8[0], u8len, nullptr, nullptr);
SetClipboardTextUtf8(hWnd, u8);
SetStatus(hWnd, L"Copied");
}
}
break;
case ID_BTN_PASTE:
if (g_prevForeground) {
HWND target = g_prevForeground;
ShowWindow(hWnd, SW_HIDE);
Sleep(60);
PasteIntoWindow(target);
}
break;
case ID_SEL_AUDIO:
ShowSelectPopup(hWnd, ID_SEL_AUDIO, g_audioItems, g_audioSel, g_w[(int)WK::SelAudio].r);
break;
}
break;
case WM_TRAYICON:
if (lParam == WM_RBUTTONUP) {
POINT pt; GetCursorPos(&pt);
ShowContextMenu(hWnd, pt);
} else if (lParam == WM_LBUTTONDBLCLK) {
ShowWindow(hWnd, SW_SHOW);
SetForegroundWindow(hWnd);
}
break;
case WM_CLOSE:
ShowWindow(hWnd, SW_HIDE);
return 0;
case WM_DESTROY: {
std::wstring cur = GetEditText(hWnd);
if (!cur.empty() && cur != g_lastLoadedText) ArchiveSession(cur);
PersistNow();
PostQuitMessage(0);
break;
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
void ShowContextMenu(HWND hwnd, POINT pt) {
HMENU hMenu = CreatePopupMenu();
InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, ID_TRAY_SHOW, L"Show Window");
InsertMenu(hMenu, 1, MF_BYPOSITION | MF_SEPARATOR, 0, nullptr);
InsertMenu(hMenu, 2, MF_BYPOSITION | MF_STRING | (g_autoPaste ? MF_CHECKED : 0), ID_TRAY_AUTOPASTE, L"Auto-paste");
InsertMenu(hMenu, 3, MF_BYPOSITION | MF_STRING | (g_pinned ? MF_CHECKED : 0), ID_TRAY_TOPMOST, L"Always on top");
InsertMenu(hMenu, 4, MF_BYPOSITION | MF_STRING | (g_autoHide ? MF_CHECKED : 0), ID_TRAY_AUTOHIDE, L"Auto-hide");
InsertMenu(hMenu, 5, MF_BYPOSITION | MF_SEPARATOR, 0, nullptr);
InsertMenu(hMenu, 6, MF_BYPOSITION | MF_STRING, ID_TRAY_EXIT, L"Exit");
SetForegroundWindow(hwnd);
TrackPopupMenu(hMenu, TPM_BOTTOMALIGN | TPM_LEFTALIGN, pt.x, pt.y, 0, hwnd, nullptr);
DestroyMenu(hMenu);
}
std::string exe_dir() {
char buf[MAX_PATH];
GetModuleFileNameA(nullptr, buf, MAX_PATH);
std::string p(buf);
return p.substr(0, p.find_last_of("\\/"));
}
std::wstring to_w(const std::string& s) {
if (s.empty()) return L"";
int n = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, nullptr, 0);
std::wstring w(n ? n - 1 : 0, L'\0');
if (n) MultiByteToWideChar(CP_UTF8, 0, s.c_str(), -1, &w[0], n);
return w;
}
std::wstring GetEditText(HWND hwnd) {
HWND e = GetDlgItem(hwnd, ID_EDIT_TEXT);
int len = GetWindowTextLengthW(e);
std::wstring s;
if (len > 0) { s.resize(len + 1); int got = GetWindowTextW(e, &s[0], len + 1); s.resize(got); }
return s;
}
std::vector<std::wstring> BuildStatsLines() {
std::vector<std::wstring> out;
wchar_t b[160];
swprintf_s(b, L"Dictated %s of audio across %d clips",
FormatHMS(g_stats.totalAudioSec).c_str(), (int)g_stats.totalClips);
out.push_back(b);
double mins = g_stats.totalAudioSec / 60.0;
swprintf_s(b, L"Words %d (%d wpm speaking)",
(int)g_stats.totalWords, mins > 0.05 ? (int)(g_stats.totalWords / mins + 0.5) : 0);
out.push_back(b);
swprintf_s(b, L"Processing %s total (%.1fx real-time on this machine)",
FormatHMS(g_stats.totalProcSec).c_str(),
g_stats.totalProcSec > 0.5 ? g_stats.totalAudioSec / g_stats.totalProcSec : 0.0);
out.push_back(b);
swprintf_s(b, L"Longest clip %s", FormatHMS(g_stats.longestClipSec).c_str());
out.push_back(b);
double typingSec = (g_stats.totalWords / 40.0) * 60.0;
double savedSec = typingSec - g_stats.totalAudioSec;
if (savedSec > 60)
{ swprintf_s(b, L"Time saved ~%s vs typing at 40 wpm", FormatHMS(savedSec).c_str()); out.push_back(b); }
return out;
}
bool SetClipboardTextUtf8(HWND owner, const std::string& utf8) {
std::wstring w = to_w(utf8);
if (!OpenClipboard(owner)) return false;
EmptyClipboard();
size_t bytes = (w.size() + 1) * sizeof(wchar_t);
HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, bytes);
if (h) {
void* p = GlobalLock(h);
memcpy(p, w.c_str(), bytes);
GlobalUnlock(h);
SetClipboardData(CF_UNICODETEXT, h);
}
CloseClipboard();
return h != nullptr;
}
void send_ctrl_v() {
INPUT in[4] = {};
in[0].type = INPUT_KEYBOARD; in[0].ki.wVk = VK_CONTROL;
in[1].type = INPUT_KEYBOARD; in[1].ki.wVk = 'V';
in[2].type = INPUT_KEYBOARD; in[2].ki.wVk = 'V'; in[2].ki.dwFlags = KEYEVENTF_KEYUP;
in[3].type = INPUT_KEYBOARD; in[3].ki.wVk = VK_CONTROL; in[3].ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(4, in, sizeof(INPUT));
}
void PasteIntoWindow(HWND target) {
if (!target || !IsWindow(target)) return;
DWORD me = GetCurrentThreadId();
DWORD other = GetWindowThreadProcessId(target, nullptr);
AttachThreadInput(me, other, TRUE);
SetForegroundWindow(target);
SetFocus(target);
AttachThreadInput(me, other, FALSE);
Sleep(40);
send_ctrl_v();
}
bool DetectGPUAvailability() {
const char* info = whisper_print_system_info();
if (!info) return false;
return (strstr(info, "CUDA") != nullptr ||
strstr(info, "Metal") != nullptr ||
strstr(info, "HIP") != nullptr ||
strstr(info, "Vulkan") != nullptr);
}
std::string SelectOptimalModel(bool has_gpu) {
std::string dir = exe_dir();
if (has_gpu) {
if (GetFileAttributesA((dir + "\\models\\ggml-base.en.bin").c_str()) != INVALID_FILE_ATTRIBUTES)
return "models\\ggml-base.en.bin";
if (GetFileAttributesA((dir + "\\models\\ggml-tiny.en.bin").c_str()) != INVALID_FILE_ATTRIBUTES)
return "models\\ggml-tiny.en.bin";
} else {
if (GetFileAttributesA((dir + "\\models\\ggml-tiny.en.bin").c_str()) != INVALID_FILE_ATTRIBUTES)
return "models\\ggml-tiny.en.bin";
if (GetFileAttributesA((dir + "\\models\\ggml-base.en.bin").c_str()) != INVALID_FILE_ATTRIBUTES)
return "models\\ggml-base.en.bin";
}
return "models\\ggml-base.en.bin";
}
Reference in New Issue View Git Blame Copy Permalink