NetSpeed.cpp

// ============================================================================
//  NetSpeed.cpp — 全局网速浮窗 (下行 + 可选上行), 带设置窗口, 方便自定义
//
//  功能:
//    · 置顶半透明浮窗, 大字显示全局下行速度, 附带上行/峰值/累计
//    · 左键按住拖动; 双击或托盘图标打开设置; 右键菜单
//    · 设置窗口: 刷新间隔 / 显示单位 / 主题(深/浅) / 高亮色 / 字号 /
//      位置 / 不透明度 / 显示上行 / 鼠标穿透 / 开机自启 / 记忆位置
//    · 所有设置即时生效并保存到程序同目录 NetSpeed.ini (可手动编辑)
//
//  原理: GetIfTable2 读取所有网卡(跳过回环)的 64 位累计字节计数
//        InOctets/OutOctets, 采样差值/时间 即全局上下行速度。无需管理员权限。
//
//  构建 (MinGW-w64 g++):
//    g++ -O2 -std=c++17 -municode -mwindows -static -finput-charset=UTF-8
//        -o NetSpeed.exe NetSpeed.cpp -luser32 -lgdi32 -ladvapi32 -lcomctl32 -lshell32 -liphlpapi
//
//  依赖: 无。静态链接, 只需 Windows 10/11 自带系统库。
// ============================================================================

#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <windows.h>
#include <commctrl.h>
#include <netioapi.h>
#include <shellapi.h>

#include <cmath>
#include <cstdio>
#include <cwchar>
#include <string>

// ============================================================================
//  配置
// ============================================================================
struct Settings {
    int  intervalMs = 1000;   // 500 / 1000 / 2000 / 3000
    int  unitMode   = 0;      // 0=自动 1=B/s 2=KB/s 3=MB/s 4=GB/s
    int  theme      = 0;      // 0=深色 1=浅色
    int  accent     = 0;      // 高亮色索引
    int  fontSize   = 1;      // 0=小 1=中 2=大
    int  corner     = 0;      // 0=右下 1=左下 2=右上 3=左上
    int  opacityPct = 85;     // 30..100
    bool showUp     = true;
    bool clickThrough = false;
    bool autoStart  = false;
    bool rememberPos = true;
    int  posX = -1, posY = -1; // 记忆的拖动位置
};
static Settings g_cfg;

static const COLORREF kAccents[] = {
    RGB(255, 150, 60),  // 橙
    RGB(90,  170, 255), // 蓝
    RGB(80,  210, 130), // 绿
    RGB(255, 110, 180), // 粉
    RGB(240, 205, 60),  // 黄
    RGB(80,  210, 220), // 青
};
static COLORREF accentColor() { return kAccents[g_cfg.accent % 6]; }

struct Palette { COLORREF bg, border, dim, norm, bright; };
static Palette palette() {
    if (g_cfg.theme == 1)
        return { RGB(247, 248, 250), RGB(152, 158, 172), RGB(98, 104, 116), RGB(45, 50, 60), RGB(20, 24, 32) };
    return { RGB(26, 28, 33), RGB(60, 66, 78), RGB(116, 122, 134), RGB(206, 211, 221), RGB(240, 242, 246) };
}

// ============================================================================
//  ini (程序同目录 NetSpeed.ini)
// ============================================================================
static std::wstring exeDir() {
    wchar_t buf[1024];
    DWORD n = GetModuleFileNameW(nullptr, buf, 1024);
    std::wstring p(buf, n);
    size_t pos = p.find_last_of(L"\\/");
    return pos == std::wstring::npos ? L"." : p.substr(0, pos);
}
static std::wstring iniPath() { return exeDir() + L"\\NetSpeed.ini"; }

static void saveIni() {
    const wchar_t* S = L"net";
    wchar_t tmp[64];
    auto wi = [&](const wchar_t* k, int v) {
        swprintf(tmp, 64, L"%d", v);
        WritePrivateProfileStringW(S, k, tmp, iniPath().c_str());
    };
    wi(L"interval", g_cfg.intervalMs);
    wi(L"unit",     g_cfg.unitMode);
    wi(L"theme",    g_cfg.theme);
    wi(L"accent",   g_cfg.accent);
    wi(L"font",     g_cfg.fontSize);
    wi(L"corner",   g_cfg.corner);
    wi(L"opacity",  g_cfg.opacityPct);
    wi(L"showup",   g_cfg.showUp ? 1 : 0);
    wi(L"through",  g_cfg.clickThrough ? 1 : 0);
    wi(L"autostart", g_cfg.autoStart ? 1 : 0);
    wi(L"remember", g_cfg.rememberPos ? 1 : 0);
    wi(L"posx",     g_cfg.posX);
    wi(L"posy",     g_cfg.posY);
}

static void loadIni() {
    const wchar_t* S = L"net";
    const wchar_t* p = iniPath().c_str();
    auto rd = [&](const wchar_t* k, int def) { return (int)GetPrivateProfileIntW(S, k, def, p); };
    g_cfg.intervalMs   = rd(L"interval", 1000);
    g_cfg.unitMode     = rd(L"unit", 0);
    g_cfg.theme        = rd(L"theme", 0);
    g_cfg.accent       = rd(L"accent", 0);
    g_cfg.fontSize     = rd(L"font", 1);
    g_cfg.corner       = rd(L"corner", 0);
    g_cfg.opacityPct   = rd(L"opacity", 85);
    g_cfg.showUp       = rd(L"showup", 1) != 0;
    g_cfg.clickThrough = rd(L"through", 0) != 0;
    g_cfg.autoStart    = rd(L"autostart", 0) != 0;
    g_cfg.rememberPos  = rd(L"remember", 1) != 0;
    g_cfg.posX         = rd(L"posx", -1);
    g_cfg.posY         = rd(L"posy", -1);
    if (g_cfg.intervalMs < 300)  g_cfg.intervalMs = 500;
    if (g_cfg.opacityPct < 30)   g_cfg.opacityPct = 30;
    if (g_cfg.opacityPct > 100)  g_cfg.opacityPct = 100;
    // 首次运行: 生成一份默认配置, 方便手动编辑
    if (GetFileAttributesW(iniPath().c_str()) == INVALID_FILE_ATTRIBUTES) saveIni();
}

// 开机自启 (HKCU Run, 无需管理员)
static bool regAutoStart() {
    HKEY k;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
                      0, KEY_QUERY_VALUE, &k) != ERROR_SUCCESS) return false;
    wchar_t buf[1024]; DWORD sz = sizeof(buf), type = 0;
    LONG rc = RegQueryValueExW(k, L"GlobalNetSpeed", nullptr, &type, (LPBYTE)buf, &sz);
    RegCloseKey(k);
    return rc == ERROR_SUCCESS;
}
static void setAutoStart(bool on) {
    HKEY k;
    if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
                      0, KEY_SET_VALUE, &k) != ERROR_SUCCESS) return;
    if (on) {
        wchar_t path[1024];
        GetModuleFileNameW(nullptr, path, 1024);
        RegSetValueExW(k, L"GlobalNetSpeed", 0, REG_SZ, (const BYTE*)path,
                       (DWORD)((wcslen(path) + 1) * sizeof(wchar_t)));
    } else {
        RegDeleteValueW(k, L"GlobalNetSpeed");
    }
    RegCloseKey(k);
}

// ============================================================================
//  网络采样 (GetIfTable2, 64 位计数器)
// ============================================================================
static const ULONG IF_OPER_STATUS_UP = 1;   // IfOperStatusUp
static const ULONG IF_TYPE_LOOPBACK  = 24;  // IF_TYPE_SOFTWARE_LOOPBACK

struct NetMon {
    bool havePrev = false, haveEma = false;
    ULONGLONG prevIn = 0, prevOut = 0, prevTime = 0;
    double downBps = 0, upBps = 0, peakBps = 0, cumBytes = 0;
    LARGE_INTEGER freq{};
    NetMon() { QueryPerformanceFrequency(&freq); }

    void poll() {
        ULONGLONG in = 0, out = 0;
        PMIB_IF_TABLE2 t = nullptr;
        if (GetIfTable2(&t) == NO_ERROR) {
            for (DWORD i = 0; i < t->NumEntries; i++) {
                const MIB_IF_ROW2& r = t->Table[i];
                if (r.OperStatus == IF_OPER_STATUS_UP && r.Type != IF_TYPE_LOOPBACK) {
                    in += r.InOctets;
                    out += r.OutOctets;
                }
            }
            FreeMibTable(t);
        }
        LARGE_INTEGER now;
        QueryPerformanceCounter(&now);
        if (havePrev) {
            double dt = (double)(now.QuadPart - prevTime) / (double)freq.QuadPart;
            if (dt < 0.1) return;
            if (dt > 5.0) {                     // 睡眠/长暂停: 重设基线
                prevIn = in; prevOut = out; prevTime = now.QuadPart;
                return;
            }
            double dd = in >= prevIn ? (double)(in - prevIn) : 0.0;
            double du = out >= prevOut ? (double)(out - prevOut) : 0.0;
            double a = 1.0 - exp(-dt / 1.2);    // 指数平滑 (~1.2s)
            double id = dd / dt, iu = du / dt;
            if (!haveEma) { downBps = id; upBps = iu; haveEma = true; }
            else { downBps = downBps * (1 - a) + id * a;
                   upBps   = upBps   * (1 - a) + iu * a; }
            cumBytes += dd;
            if (downBps > peakBps) peakBps = downBps;
        }
        prevIn = in; prevOut = out; prevTime = now.QuadPart;
        havePrev = true;
    }
};
static NetMon g_mon;

// ============================================================================
//  格式化
// ============================================================================
static std::wstring fmtVal(double v, const wchar_t* unit) {
    wchar_t buf[48];
    if (v >= 99.5)      swprintf(buf, 48, L"%.0f %ls", v, unit);
    else if (v >= 9.95) swprintf(buf, 48, L"%.1f %ls", v, unit);
    else                swprintf(buf, 48, L"%.2f %ls", v, unit);
    return buf;
}
static std::wstring fmtRate(double bps, int mode) {
    if (mode == 0) {
        if (bps < 1.0)                  return L"0 B/s";
        if (bps >= 1073741824.0) return fmtVal(bps / 1073741824.0, L"GB/s");
        if (bps >= 1048576.0)    return fmtVal(bps / 1048576.0,   L"MB/s");
        if (bps >= 1024.0)       return fmtVal(bps / 1024.0,      L"KB/s");
        return fmtVal(bps, L"B/s");
    }
    static const double scale[]  = { 1.0, 1024.0, 1048576.0, 1073741824.0 };
    static const wchar_t* name[] = { L"B/s", L"KB/s", L"MB/s", L"GB/s" };
    return fmtVal(bps / scale[mode - 1], name[mode - 1]);
}
static std::wstring fmtBytes(double v) {
    if (v >= 1073741824.0) return fmtVal(v / 1073741824.0, L"GB");
    if (v >= 1048576.0)    return fmtVal(v / 1048576.0,    L"MB");
    if (v >= 1024.0)       return fmtVal(v / 1024.0,       L"KB");
    wchar_t buf[32];
    swprintf(buf, 32, L"%.0f B", v);
    return buf;
}

// ============================================================================
//  全局窗口/状态
// ============================================================================
static HWND   g_hFloat = nullptr, g_hSettings = nullptr;
static HFONT  g_fTitle = nullptr, g_fSpeed = nullptr, g_fSub = nullptr;
static HFONT  g_fDlg = nullptr;
static bool   g_active = false;
static bool   g_dragging = false;
static POINT  g_dragStart{}, g_winStart{};
static std::wstring g_s1, g_s2, g_s3;   // 三行显示文本

static UINT getDpiFor(HWND hwnd) {
    typedef UINT (WINAPI *FnDpi)(HWND);
    static FnDpi fn = (FnDpi)GetProcAddress(GetModuleHandleW(L"user32.dll"), "GetDpiForWindow");
    if (fn) { UINT d = fn(hwnd); if (d) return d; }
    HDC dc = GetDC(hwnd);
    UINT d = GetDeviceCaps(dc, LOGPIXELSY);
    ReleaseDC(hwnd, dc);
    return d ? d : 96;
}
static int sc(int v, UINT dpi) { return MulDiv(v, dpi, 96); }
static int ptPx(int pt, UINT dpi) { return -MulDiv(pt, dpi, 72); }

static HFONT makeFont(int pt, int weight, UINT dpi) {
    return CreateFontW(ptPx(pt, dpi), 0, 0, 0, weight, 0, 0, 0, DEFAULT_CHARSET, 0, 0,
                       CLEARTYPE_QUALITY, 0, L"Microsoft YaHei UI");
}
static void rebuildFloatFonts() {
    if (g_fTitle) { DeleteObject(g_fTitle); g_fTitle = nullptr; }
    if (g_fSpeed) { DeleteObject(g_fSpeed); g_fSpeed = nullptr; }
    if (g_fSub)   { DeleteObject(g_fSub);   g_fSub = nullptr; }
    if (!g_hFloat) return;
    UINT dpi = getDpiFor(g_hFloat);
    int t = 9, s = 18, u = 9;          // 中
    if (g_cfg.fontSize == 0) { t = 8;  s = 15; u = 8; }   // 小
    if (g_cfg.fontSize == 2) { t = 11; s = 21; u = 12; }  // 大
    g_fTitle = makeFont(t, FW_NORMAL, dpi);
    g_fSpeed = makeFont(s, FW_BOLD, dpi);
    g_fSub   = makeFont(u, FW_NORMAL, dpi);
}
static void applyOpacity() {
    if (g_hFloat) SetLayeredWindowAttributes(g_hFloat, 0, (BYTE)(g_cfg.opacityPct * 255 / 100), LWA_ALPHA);
}
static void applyClickThrough() {
    if (!g_hFloat) return;
    LONG ex = GetWindowLongW(g_hFloat, GWL_EXSTYLE);
    if (g_cfg.clickThrough) ex |= WS_EX_TRANSPARENT; else ex &= ~WS_EX_TRANSPARENT;
    SetWindowLongW(g_hFloat, GWL_EXSTYLE, ex);
}
static void placeFloat() {
    RECT wa;
    SystemParametersInfoW(SPI_GETWORKAREA, 0, &wa, 0);
    RECT rc; GetWindowRect(g_hFloat, &rc);
    int w = rc.right - rc.left, h = rc.bottom - rc.top;
    int pad = sc(14, getDpiFor(g_hFloat));
    int x, y;
    if (g_cfg.rememberPos && g_cfg.posX >= 0 && g_cfg.posY >= 0) {
        x = g_cfg.posX; y = g_cfg.posY;
    } else {
        switch (g_cfg.corner) {
        case 1:  x = wa.left + pad;       y = wa.bottom - h - pad; break;
        case 2:  x = wa.right - w - pad;  y = wa.top + pad;        break;
        case 3:  x = wa.left + pad;       y = wa.top + pad;        break;
        default: x = wa.right - w - pad;  y = wa.bottom - h - pad; break;
        }
    }
    if (x < wa.left - w + 80)  x = wa.left;
    if (y < wa.top)            y = wa.top;
    if (x > wa.right - 80)     x = wa.right - w;
    if (y > wa.bottom - 60)    y = wa.bottom - h;
    SetWindowPos(g_hFloat, nullptr, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
}

// 采样 + 组文本 + 自适应宽度
static void refreshFloat() {
    g_mon.poll();
    UINT dpi = getDpiFor(g_hFloat);

    g_s1 = g_cfg.clickThrough ? L"全局网速  [鼠标穿透]" : L"全局网速";
    g_active = g_mon.downBps > 512.0;
    g_s2 = L"\u2193 " + fmtRate(g_mon.downBps, g_cfg.unitMode);
    if (g_cfg.showUp)
        g_s3 = L"\u2191 " + fmtRate(g_mon.upBps, g_cfg.unitMode) +
               L"  ·  峰值 " + fmtRate(g_mon.peakBps, g_cfg.unitMode);
    else
        g_s3 = L"累计 " + fmtBytes(g_mon.cumBytes) +
               L"  ·  峰值 " + fmtRate(g_mon.peakBps, g_cfg.unitMode);

    // 自动宽度 = 最长文本 + 边距
    HDC dc = GetDC(g_hFloat);
    int pad = sc(14, dpi);
    auto tw = [&](HFONT f, const std::wstring& s) {
        HGDIOBJ o = SelectObject(dc, f);
        SIZE sz{};
        GetTextExtentPoint32W(dc, s.c_str(), (int)s.size(), &sz);
        SelectObject(dc, o);
        return sz.cx;
    };
    int wmax = tw(g_fSpeed, g_s2);
    int w1 = tw(g_fTitle, g_s1), w3 = tw(g_fSub, g_s3);
    if (w1 > wmax) wmax = w1;
    if (w3 > wmax) wmax = w3;
    int width = wmax + pad * 2;
    if (width < sc(160, dpi)) width = sc(160, dpi);
    if (width > sc(640, dpi)) width = sc(640, dpi);
    ReleaseDC(g_hFloat, dc);

    RECT rc; GetWindowRect(g_hFloat, &rc);
    int curW = rc.right - rc.left;
    if (!g_dragging && width != curW) {
        bool keepRight = (g_cfg.corner == 0 || g_cfg.corner == 2)
                         && !(g_cfg.rememberPos && g_cfg.posX >= 0);
        int x = keepRight ? rc.right - width : rc.left;
        SetWindowPos(g_hFloat, nullptr, x, rc.top, width, rc.bottom - rc.top,
                     SWP_NOZORDER | SWP_NOACTIVATE);
    }
    InvalidateRect(g_hFloat, nullptr, FALSE);
}

// ============================================================================
//  托盘 + 菜单
// ============================================================================
static void showSettings();
static void toggleThroughAndSave();

static void trayMenu() {
    POINT pt; GetCursorPos(&pt);
    // 临时去掉 NOACTIVATE, 保证菜单正常
    LONG ex0 = GetWindowLongW(g_hFloat, GWL_EXSTYLE);
    SetWindowLongW(g_hFloat, GWL_EXSTYLE, ex0 & ~WS_EX_NOACTIVATE);
    SetForegroundWindow(g_hFloat);
    HMENU m = CreatePopupMenu();
    AppendMenuW(m, MF_STRING, 10, L"设置…");
    AppendMenuW(m, MF_STRING | (g_cfg.clickThrough ? MF_CHECKED : 0), 11, L"鼠标穿透");
    AppendMenuW(m, MF_SEPARATOR, 0, nullptr);
    AppendMenuW(m, MF_STRING, 12, L"退出");
    int id = TrackPopupMenu(m, TPM_RIGHTBUTTON | TPM_RETURNCMD, pt.x, pt.y, 0, g_hFloat, nullptr);
    DestroyMenu(m);
    SetWindowLongW(g_hFloat, GWL_EXSTYLE, ex0);
    if (id == 10) showSettings();
    else if (id == 11) toggleThroughAndSave();
    else if (id == 12) DestroyWindow(g_hFloat);
}

static void addTrayIcon() {
    NOTIFYICONDATAW n{};
    n.cbSize = sizeof(n);
    n.hWnd = g_hFloat;
    n.uID = 1;
    n.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
    n.uCallbackMessage = WM_APP + 1;
    n.hIcon = LoadIconW((HINSTANCE)GetWindowLongPtrW(g_hFloat, GWLP_HINSTANCE), MAKEINTRESOURCEW(1));
    wcscpy(n.szTip, L"全局网速浮窗");
    Shell_NotifyIconW(NIM_ADD, &n);
}
static void removeTrayIcon() {
    NOTIFYICONDATAW n{};
    n.cbSize = sizeof(n);
    n.hWnd = g_hFloat;
    n.uID = 1;
    Shell_NotifyIconW(NIM_DELETE, &n);
}

static LRESULT CALLBACK floatProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    switch (msg) {
    case WM_CREATE:
        g_hFloat = hwnd;
        rebuildFloatFonts();
        addTrayIcon();
        return 0;
    case WM_TIMER:
        refreshFloat();
        return 0;
    case WM_ERASEBKGND:
        return 1;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC dc = BeginPaint(hwnd, &ps);
        RECT rc; GetClientRect(hwnd, &rc);
        Palette p = palette();
        HBRUSH bg = CreateSolidBrush(p.bg);
        FillRect(dc, &rc, bg);
        DeleteObject(bg);
        HPEN pen = CreatePen(PS_SOLID, 1, p.border);
        HGDIOBJ op = SelectObject(dc, pen);
        HGDIOBJ ob = SelectObject(dc, GetStockObject(NULL_BRUSH));
        Rectangle(dc, 0, 0, rc.right, rc.bottom);
        SelectObject(dc, op); SelectObject(dc, ob);
        DeleteObject(pen);
        SetBkMode(dc, TRANSPARENT);
        UINT dpi = getDpiFor(hwnd);
        float k = g_cfg.fontSize == 0 ? 0.88f : g_cfg.fontSize == 2 ? 1.2f : 1.0f;
        int t1 = (int)(sc(7, dpi) * k),  h1 = (int)(sc(17, dpi) * k);
        int t2 = (int)(sc(25, dpi) * k), h2 = (int)(sc(31, dpi) * k);
        int t3 = (int)(sc(58, dpi) * k), h3 = (int)(sc(17, dpi) * k);
        int pad = (int)(sc(11, dpi) * k);

        SetTextColor(dc, p.dim);
        SelectObject(dc, g_fTitle);
        RECT r1 = { pad, t1, rc.right - sc(5, dpi), t1 + h1 };
        DrawTextW(dc, g_s1.c_str(), -1, &r1, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_END_ELLIPSIS);

        SetTextColor(dc, g_active ? accentColor() : p.norm);
        SelectObject(dc, g_fSpeed);
        RECT r2 = { pad, t2, rc.right - sc(5, dpi), t2 + h2 };
        DrawTextW(dc, g_s2.c_str(), -1, &r2, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_END_ELLIPSIS);

        SetTextColor(dc, p.dim);
        SelectObject(dc, g_fSub);
        RECT r3 = { pad, t3, rc.right - sc(5, dpi), t3 + h3 };
        DrawTextW(dc, g_s3.c_str(), -1, &r3, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_END_ELLIPSIS);

        EndPaint(hwnd, &ps);
        return 0;
    }
    case WM_LBUTTONDOWN: {
        if (g_cfg.clickThrough) return 0;
        SetCapture(hwnd);
        g_dragging = false;
        GetCursorPos(&g_dragStart);
        RECT rc; GetWindowRect(hwnd, &rc);
        g_winStart.x = rc.left; g_winStart.y = rc.top;
        return 0;
    }
    case WM_MOUSEMOVE: {
        if ((wp & MK_LBUTTON) && GetCapture() == hwnd) {
            POINT c; GetCursorPos(&c);
            int dx = c.x - g_dragStart.x, dy = c.y - g_dragStart.y;
            if (!g_dragging && (dx > 3 || dx < -3 || dy > 3 || dy < -3)) g_dragging = true;
            if (g_dragging)
                SetWindowPos(hwnd, nullptr, g_winStart.x + dx, g_winStart.y + dy, 0, 0,
                             SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
        }
        return 0;
    }
    case WM_LBUTTONUP:
        if (GetCapture() == hwnd) {
            ReleaseCapture();
            if (g_dragging) {
                g_dragging = false;
                RECT rc; GetWindowRect(hwnd, &rc);
                g_cfg.posX = rc.left; g_cfg.posY = rc.top;
                if (g_cfg.rememberPos) saveIni();
            }
        }
        return 0;
    case WM_LBUTTONDBLCLK:
        if (!g_cfg.clickThrough) showSettings();
        return 0;
    case WM_RBUTTONUP:
        if (!g_cfg.clickThrough) trayMenu();
        return 0;
    case WM_APP + 1:
        if (lp == WM_LBUTTONDBLCLK) showSettings();
        else if (lp == WM_RBUTTONUP) trayMenu();
        return 0;
    case WM_DESTROY:
        removeTrayIcon();
        if (g_hSettings) DestroyWindow(g_hSettings);
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcW(hwnd, msg, wp, lp);
}

// ============================================================================
//  设置窗口
// ============================================================================
enum {
    IDC_INTERVAL = 3001, IDC_UNIT, IDC_THEME, IDC_ACCENT, IDC_FONT, IDC_CORNER,
    IDC_OPACITY, IDC_OPACITY_VAL,
    IDC_SHOWUP, IDC_THROUGH2, IDC_AUTOSTART, IDC_REMEMBER,
    IDC_BTN_CLOSE, IDC_HINT,
};

static HFONT dlgFont() {
    if (!g_fDlg) {
        HDC dc = GetDC(nullptr);
        UINT dpi = GetDeviceCaps(dc, LOGPIXELSY);
        ReleaseDC(nullptr, dc);
        g_fDlg = makeFont(9, FW_NORMAL, dpi ? dpi : 96);
    }
    return g_fDlg;
}

static void applyControls(HWND dlg) {
    auto cur = [&](int id) { return (int)SendMessageW(GetDlgItem(dlg, id), CB_GETCURSEL, 0, 0); };
    auto chk = [&](int id) { return SendMessageW(GetDlgItem(dlg, id), BM_GETCHECK, 0, 0) == BST_CHECKED; };
    static const int ivs[] = { 500, 1000, 2000, 3000 };
    int iv = cur(IDC_INTERVAL); if (iv >= 0 && iv < 4) g_cfg.intervalMs = ivs[iv];
    int un = cur(IDC_UNIT);     if (un >= 0) g_cfg.unitMode = un;
    int th = cur(IDC_THEME);    if (th >= 0) g_cfg.theme = th;
    int ac = cur(IDC_ACCENT);   if (ac >= 0) g_cfg.accent = ac;
    int fo = cur(IDC_FONT);     if (fo >= 0) g_cfg.fontSize = fo;
    int co = cur(IDC_CORNER);   if (co >= 0) { g_cfg.corner = co; g_cfg.posX = g_cfg.posY = -1; }
    g_cfg.showUp       = chk(IDC_SHOWUP);
    g_cfg.clickThrough = chk(IDC_THROUGH2);
    g_cfg.autoStart    = chk(IDC_AUTOSTART);
    g_cfg.rememberPos  = chk(IDC_REMEMBER);
    saveIni();
    setAutoStart(g_cfg.autoStart);
    applyClickThrough();
    SetTimer(g_hFloat, 1, g_cfg.intervalMs, nullptr);
    rebuildFloatFonts();
    applyOpacity();
    placeFloat();
    refreshFloat();
}

static void openSettings() {
    if (g_hSettings && IsWindow(g_hSettings)) {
        ShowWindow(g_hSettings, SW_SHOW);
        SetForegroundWindow(g_hSettings);
        return;
    }
    HINSTANCE hi = (HINSTANCE)GetWindowLongPtrW(g_hFloat, GWLP_HINSTANCE);
    HDC dc = GetDC(nullptr);
    UINT dpi = GetDeviceCaps(dc, LOGPIXELSY);
    ReleaseDC(nullptr, dc);
    if (!dpi) dpi = 96;

    int lx = sc(16, dpi), cx = sc(150, dpi), cw = sc(188, dpi);
    int clW = sc(356, dpi);
    int rowH = sc(30, dpi), ctrlH = sc(23, dpi);

    int y = sc(12, dpi);
    int rows = 11;                      // 6 行下拉 + 1 滑杆 + 4 复选
    int bottomY = y + rows * rowH;      // 提示与按钮所在行
    int clH = bottomY + ctrlH + sc(14, dpi);

    RECT wr = { 0, 0, clW, clH };
    AdjustWindowRectEx(&wr, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU, FALSE, 0);

    g_hSettings = CreateWindowExW(0, L"NetSpeedSettingsWnd", L"全局网速浮窗 · 设置",
        WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU,
        CW_USEDEFAULT, CW_USEDEFAULT, wr.right - wr.left, wr.bottom - wr.top,
        g_hFloat, nullptr, hi, nullptr);
    if (!g_hSettings) return;
    HFONT f = dlgFont();

    auto label = [&](const wchar_t* t, int yy) {
        HWND h = CreateWindowExW(0, L"STATIC", t, WS_CHILD | WS_VISIBLE | SS_LEFT | SS_CENTERIMAGE,
                                 lx, yy, cx - lx - sc(6, dpi), ctrlH, g_hSettings, nullptr, hi, nullptr);
        SendMessageW(h, WM_SETFONT, (WPARAM)f, TRUE);
    };
    auto combo = [&](int id, const wchar_t* items[], int n, int sel, int yy) {
        HWND h = CreateWindowExW(0, L"COMBOBOX", L"", WS_CHILD | WS_VISIBLE | CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP,
                                 cx, yy, cw, sc(160, dpi), g_hSettings, (HMENU)(INT_PTR)id, hi, nullptr);
        SendMessageW(h, WM_SETFONT, (WPARAM)f, TRUE);
        for (int i = 0; i < n; i++) SendMessageW(h, CB_ADDSTRING, 0, (LPARAM)items[i]);
        SendMessageW(h, CB_SETCURSEL, sel, 0);
    };

    static const wchar_t* iv[] = { L"0.5 秒", L"1 秒", L"2 秒", L"3 秒" };
    static const wchar_t* un[] = { L"自动", L"B/s", L"KB/s", L"MB/s", L"GB/s" };
    static const wchar_t* th[] = { L"深色", L"浅色" };
    static const wchar_t* ac[] = { L"橙色", L"蓝色", L"绿色", L"粉色", L"黄色", L"青色" };
    static const wchar_t* fo[] = { L"小", L"中", L"大" };
    static const wchar_t* co[] = { L"右下", L"左下", L"右上", L"左上" };
    auto ivSel = [](int ms) { return ms <= 500 ? 0 : ms <= 1000 ? 1 : ms <= 2000 ? 2 : 3; };

    label(L"刷新间隔", y);      combo(IDC_INTERVAL, iv, 4, ivSel(g_cfg.intervalMs), y); y += rowH;
    label(L"显示单位", y);      combo(IDC_UNIT, un, 5, g_cfg.unitMode, y);             y += rowH;
    label(L"主题", y);          combo(IDC_THEME, th, 2, g_cfg.theme, y);               y += rowH;
    label(L"高亮色", y);        combo(IDC_ACCENT, ac, 6, g_cfg.accent, y);             y += rowH;
    label(L"字号", y);          combo(IDC_FONT, fo, 3, g_cfg.fontSize, y);             y += rowH;
    label(L"位置", y);          combo(IDC_CORNER, co, 4, g_cfg.corner, y);             y += rowH;

    label(L"不透明度", y);
    {
        HWND tb = CreateWindowExW(0, TRACKBAR_CLASSW, L"",
            WS_CHILD | WS_VISIBLE | WS_TABSTOP | TBS_HORZ | TBS_AUTOTICKS,
            cx, y, cw - sc(56, dpi), ctrlH, g_hSettings, (HMENU)(INT_PTR)IDC_OPACITY, hi, nullptr);
        SendMessageW(tb, WM_SETFONT, (WPARAM)f, TRUE);
        SendMessageW(tb, TBM_SETRANGE, TRUE, MAKELONG(30, 100));
        SendMessageW(tb, TBM_SETPOS, TRUE, g_cfg.opacityPct);
        HWND v = CreateWindowExW(0, L"STATIC", L"", WS_CHILD | WS_VISIBLE | SS_RIGHT,
                                 cx + cw - sc(48, dpi), y, sc(48, dpi), ctrlH,
                                 g_hSettings, (HMENU)(INT_PTR)IDC_OPACITY_VAL, hi, nullptr);
        SendMessageW(v, WM_SETFONT, (WPARAM)f, TRUE);
        wchar_t t[16]; swprintf(t, 16, L"%d%%", g_cfg.opacityPct);
        SetWindowTextW(v, t);
    }
    y += rowH;

    auto chk = [&](int id, const wchar_t* t, bool on, int yy) {
        HWND h = CreateWindowExW(0, L"BUTTON", t, WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX | WS_TABSTOP,
                                 lx, yy, clW - lx * 2, ctrlH, g_hSettings, (HMENU)(INT_PTR)id, hi, nullptr);
        SendMessageW(h, WM_SETFONT, (WPARAM)f, TRUE);
        SendMessageW(h, BM_SETCHECK, on ? BST_CHECKED : BST_UNCHECKED, 0);
    };
    chk(IDC_SHOWUP,    L"显示上行速度", g_cfg.showUp, y); y += rowH;
    chk(IDC_THROUGH2,  L"鼠标穿透（开启后点不到浮窗，从托盘恢复）", g_cfg.clickThrough, y); y += rowH;
    chk(IDC_AUTOSTART, L"开机自动启动", g_cfg.autoStart, y); y += rowH;
    chk(IDC_REMEMBER,  L"记住拖动位置（关闭则按上方“位置”摆放）", g_cfg.rememberPos, y); y += rowH;

    HWND btn = CreateWindowExW(0, L"BUTTON", L"完成",
        WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON | WS_TABSTOP,
        clW - sc(96, dpi) - lx, bottomY, sc(96, dpi), ctrlH,
        g_hSettings, (HMENU)(INT_PTR)IDC_BTN_CLOSE, hi, nullptr);
    SendMessageW(btn, WM_SETFONT, (WPARAM)f, TRUE);
    HWND hint = CreateWindowExW(0, L"STATIC", L"修改即时生效 · 自动保存到 NetSpeed.ini",
                                WS_CHILD | WS_VISIBLE | SS_LEFT | SS_CENTERIMAGE,
                                lx, bottomY, clW - sc(96, dpi) - lx * 2 - sc(8, dpi), ctrlH,
                                g_hSettings, (HMENU)(INT_PTR)IDC_HINT, hi, nullptr);
    SendMessageW(hint, WM_SETFONT, (WPARAM)f, TRUE);

    // 放在浮窗附近
    RECT fr; GetWindowRect(g_hFloat, &fr);
    RECT wa; SystemParametersInfoW(SPI_GETWORKAREA, 0, &wa, 0);
    int ww = wr.right - wr.left, wh = wr.bottom - wr.top;
    int sx = fr.left + (fr.right - fr.left) / 2 - ww / 2;
    int sy = fr.bottom + sc(6, dpi);
    if (sx < wa.left) sx = wa.left;
    if (sx + ww > wa.right) sx = wa.right - ww;
    if (sy + wh > wa.bottom) sy = fr.top - wh - sc(6, dpi);
    if (sy < wa.top) sy = wa.top;
    SetWindowPos(g_hSettings, nullptr, sx, sy, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
    ShowWindow(g_hSettings, SW_SHOW);
}

static void toggleThroughAndSave() {
    g_cfg.clickThrough = !g_cfg.clickThrough;
    applyClickThrough();
    saveIni();
    if (g_hSettings) {
        HWND ck = GetDlgItem(g_hSettings, IDC_THROUGH2);
        if (ck) SendMessageW(ck, BM_SETCHECK, g_cfg.clickThrough ? BST_CHECKED : BST_UNCHECKED, 0);
    }
    refreshFloat();
}

static void showSettings() { openSettings(); }

static LRESULT CALLBACK settingsProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    switch (msg) {
    case WM_COMMAND:
        if (LOWORD(wp) == IDC_BTN_CLOSE) { DestroyWindow(hwnd); return 0; }
        if (HIWORD(wp) == CBN_SELCHANGE || HIWORD(wp) == BN_CLICKED)
            applyControls(hwnd);
        return 0;
    case WM_HSCROLL:
        if ((HWND)lp == GetDlgItem(hwnd, IDC_OPACITY)) {
            g_cfg.opacityPct = (int)SendMessageW((HWND)lp, TBM_GETPOS, 0, 0);
            HWND v = GetDlgItem(hwnd, IDC_OPACITY_VAL);
            wchar_t t[16]; swprintf(t, 16, L"%d%%", g_cfg.opacityPct);
            SetWindowTextW(v, t);
            applyOpacity();
            saveIni();
        }
        return 0;
    case WM_CLOSE:
        DestroyWindow(hwnd);
        return 0;
    case WM_DESTROY:
        g_hSettings = nullptr;
        return 0;
    }
    return DefWindowProcW(hwnd, msg, wp, lp);
}

// ============================================================================
//  入口
// ============================================================================
int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, PWSTR, int) {
    CreateMutexW(nullptr, TRUE, L"Local\\GlobalNetSpeedFloat");
    if (GetLastError() == ERROR_ALREADY_EXISTS) return 0;

    typedef BOOL (WINAPI *FnDpiAware)(void*);
    FnDpiAware f1 = (FnDpiAware)GetProcAddress(GetModuleHandleW(L"user32.dll"), "SetProcessDpiAwarenessContext");
    if (f1) f1((void*)(intptr_t)-4);
    else {
        typedef HRESULT (WINAPI *FnDpiAware2)(int);
        FnDpiAware2 f2 = (FnDpiAware2)GetProcAddress(LoadLibraryW(L"shcore.dll"), "SetProcessDpiAwareness");
        if (f2) f2(2);
    }

    INITCOMMONCONTROLSEX icc{ sizeof(icc), ICC_BAR_CLASSES };
    InitCommonControlsEx(&icc);

    loadIni();
    g_cfg.autoStart = regAutoStart();

    WNDCLASSEXW wc = { sizeof(wc) };
    wc.lpfnWndProc = floatProc;
    wc.hInstance = hInst;
    wc.hIcon = LoadIconW(hInst, MAKEINTRESOURCEW(1));
    wc.hIconSm = wc.hIcon;
    wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    wc.lpszClassName = L"NetSpeedFloatWnd";
    RegisterClassExW(&wc);
    WNDCLASSEXW wc2 = wc;
    wc2.lpfnWndProc = settingsProc;
    wc2.lpszClassName = L"NetSpeedSettingsWnd";
    RegisterClassExW(&wc2);

    g_hFloat = CreateWindowExW(
        WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE | WS_EX_LAYERED,
        L"NetSpeedFloatWnd", L"全局网速", WS_POPUP,
        0, 0, 200, 84, nullptr, nullptr, hInst, nullptr);
    if (!g_hFloat) return 1;

    applyOpacity();
    applyClickThrough();
    refreshFloat();          // 采样 + 自适应宽度
    placeFloat();            // 按设置摆放
    refreshFloat();          // 宽度变化后再校正一次文本尺寸引起的右缘位置
    SetTimer(g_hFloat, 1, g_cfg.intervalMs, nullptr);
    ShowWindow(g_hFloat, SW_SHOWNOACTIVATE);

    MSG msg;
    while (GetMessageW(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
    return 0;
}