Skip to content

Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic

64.0 KB
Raw Blame
// ui/dialogs.h - all modal dialogs (Proxy Servers, Proxy Checker,
// Proxy Rules, Log Filters, and their edit sub-dialogs, plus the new-profile prompt).
//
// Unity-build include: pulled into main.c after the globals, theme helpers, log store,
// filter helpers and the profile/engine helpers it calls. Not a standalone header.
#ifndef PB_UI_DIALOGS_H
#define PB_UI_DIALOGS_H

// Subclass a ListView to (a) dark-theme its header via custom draw - it stays light
// otherwise - and (b) the header's empty right-hand area gets filled dark too.
static LRESULT CALLBACK ListDarkSubProc(HWND h, UINT m, WPARAM w, LPARAM l, UINT_PTR id, DWORD_PTR ref)
{
    (void)id; (void)ref;
    if (m == WM_NOTIFY)
    {
        NMHDR* nh = (NMHDR*)l;
        if (nh->code == NM_CUSTOMDRAW && nh->hwndFrom == ListView_GetHeader(h))
        {
            NMCUSTOMDRAW* cd = (NMCUSTOMDRAW*)l;
            switch (cd->dwDrawStage)
            {
            case CDDS_PREPAINT:
                FillRect(cd->hdc, &cd->rc, g_brPanel);
                return CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT;
            case CDDS_ITEMPREPAINT:
            {
                wchar_t txt[64] = {0};
                HDITEMW hi; hi.mask = HDI_TEXT; hi.pszText = txt; hi.cchTextMax = 64;
                Header_GetItem(nh->hwndFrom, (int)cd->dwItemSpec, &hi);
                FillRect(cd->hdc, &cd->rc, g_brPanel);
                SetBkMode(cd->hdc, TRANSPARENT);
                SetTextColor(cd->hdc, C_TEXT);
                RECT tr = cd->rc; tr.left += 6; tr.right -= 4;
                DrawTextW(cd->hdc, txt, -1, &tr, DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
                RECT ln = { cd->rc.right - 1, cd->rc.top, cd->rc.right, cd->rc.bottom };
                FillRect(cd->hdc, &ln, g_brBg);   // subtle column divider
                return CDRF_SKIPDEFAULT;
            }
            case CDDS_POSTPAINT:
            {
                // Paint the empty area to the right of the last column dark; otherwise
                // it shows the default white header background (visible at the edge and
                // whenever the columns don't span the full width, e.g. after a drag).
                HWND hdr = nh->hwndFrom;
                int n = Header_GetItemCount(hdr);
                RECT last = {0, 0, 0, 0};
                if (n > 0) Header_GetItemRect(hdr, n - 1, &last);
                RECT hr; GetClientRect(hdr, &hr);
                if (hr.right > last.right)
                {
                    RECT fill = { last.right, hr.top, hr.right, hr.bottom };
                    FillRect(cd->hdc, &fill, g_brPanel);
                }
                return CDRF_DODEFAULT;
            }
            }
        }
    }
    return DefSubclassProc(h, m, w, l);
}

// Grow every column proportionally so the grid fills its full client width - no dead space
// on the right, and no single over-wide column. Idempotent: once the columns already span
// the width, re-calling it is a no-op (it never shrinks below the seeded widths).
#define PB_MAX_COLS 16
static void FillColumns(HWND lv, int count)
{
    if (count <= 0 || count > PB_MAX_COLS) return;
    RECT rc; GetClientRect(lv, &rc);
    int avail = rc.right - 4;                 // small margin to avoid a stray h-scrollbar
    if (avail <= 0) return;
    int w[PB_MAX_COLS]; int total = 0;
    for (int i = 0; i < count; i++) { w[i] = ListView_GetColumnWidth(lv, i); total += w[i]; }
    if (total <= 0 || avail <= total) return; // nothing to distribute (or would need to shrink)
    int extra = avail - total, given = 0;
    for (int i = 0; i < count; i++)
    {
        int add = (i == count - 1) ? (extra - given)      // last column soaks up the rounding
                                   : (int)((INT64)extra * w[i] / total);
        given += add;
        ListView_SetColumnWidth(lv, i, w[i] + add);
    }
}

// Dark-theme a report ListView: full-row select + double buffer (+ any extra ex-styles),
// dark colours, dark-drawn header. Columns/FillColumns are added by the caller.
static void DarkListView(HWND lv, DWORD extraExStyle)
{
    ListView_SetExtendedListViewStyle(lv, LVS_EX_FULLROWSELECT | LVS_EX_DOUBLEBUFFER | extraExStyle);
    SetWindowTheme(lv, L"DarkMode_Explorer", NULL);
    ListView_SetBkColor(lv, C_PANEL);
    ListView_SetTextBkColor(lv, C_PANEL);
    ListView_SetTextColor(lv, C_TEXT);
    SetWindowSubclass(lv, ListDarkSubProc, 3, 0);
}

// Proxy Servers
// A Proxifier-style list of proxy servers with Add.../Edit.../Remove; the actual
// address/port/protocol/auth fields live in the IDD_SERVER sub-dialog.

static void InitServerList(HWND lv)
{
    DarkListView(lv, 0);
    struct { int s; int w; } cols[] = { {S_COL_NAME, 130}, {S_COL_ADDR, 160}, {S_COL_PORTS, 60}, {S_COL_TYPE, 80} };
    LVCOLUMNW c; c.mask = LVCF_TEXT | LVCF_WIDTH;
    for (int i = 0; i < 4; i++) { c.pszText = (LPWSTR)T(cols[i].s); c.cx = cols[i].w; ListView_InsertColumn(lv, i, &c); }
    FillColumns(lv, 4);
}
static void RefreshServerList(HWND lv)
{
    ListView_DeleteAllItems(lv);
    for (int i = 0; i < g_profile.cfgCount; i++)
    {
        PBConfig* c = &g_profile.cfg[i];
        LVITEMW it; ZeroMemory(&it, sizeof(it));
        it.mask = LVIF_TEXT; it.iItem = i; it.pszText = c->name[0] ? c->name : c->host;
        ListView_InsertItem(lv, &it);
        ListView_SetItemText(lv, i, 1, c->host);
        ListView_SetItemText(lv, i, 2, c->port);
        ListView_SetItemText(lv, i, 3, c->type);
    }
}

// Edit sub-dialog. lParam is a PBConfig* seeded with current values (or zeroed for a new one);
// on OK it is written back and the dialog returns 1.
INT_PTR CALLBACK ServerEditDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
    {
        SetWindowLongPtrW(dlg, GWLP_USERDATA, (LONG_PTR)lp);
        PBConfig* c = (PBConfig*)lp;
        SetWindowTextW(dlg, T(S_DLG_SERVER));
        SetDlgItemTextW(dlg, IDC_SE_L_NAME,   T(S_L_NAME));
        SetDlgItemTextW(dlg, IDC_SE_G_SERVER, T(S_G_SERVER));
        SetDlgItemTextW(dlg, IDC_SE_G_AUTH,   T(S_G_AUTH));
        SetDlgItemTextW(dlg, IDC_SE_L_ADDR,   T(S_L_ADDR));
        SetDlgItemTextW(dlg, IDC_SE_L_PORT,   T(S_L_PORT));
        SetDlgItemTextW(dlg, IDC_SE_L_PROTO,  T(S_L_PROTO));
        SetDlgItemTextW(dlg, IDC_SE_AUTH,     T(S_CHK_ENABLE));
        SetDlgItemTextW(dlg, IDC_SE_SENDDOMAIN, T(S_CHK_SENDDOMAIN));
        SetDlgItemTextW(dlg, IDC_SE_L_USER,   T(S_L_USER));
        SetDlgItemTextW(dlg, IDC_SE_L_PASS,   T(S_L_PASS));
        SetDlgItemTextW(dlg, IDOK,            T(S_BTN_OK));
        SetDlgItemTextW(dlg, IDCANCEL,        T(S_BTN_CANCEL));
        HWND pr = GetDlgItem(dlg, IDC_SE_PROTO);
        SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)L"SOCKS5");
        SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)L"HTTP");
        SendMessageW(pr, CB_SETCURSEL, (_wcsicmp(c->type, L"HTTP") == 0) ? 1 : 0, 0);
        SetDlgItemTextW(dlg, IDC_SE_NAME, c->name);
        SetDlgItemTextW(dlg, IDC_SE_ADDR, c->host);
        if (c->port[0]) SetDlgItemTextW(dlg, IDC_SE_PORT, c->port); else SetDlgItemInt(dlg, IDC_SE_PORT, 1080, FALSE);
        SetDlgItemTextW(dlg, IDC_SE_USER, c->user);
        SetDlgItemTextW(dlg, IDC_SE_PASS, c->pass);
        CheckDlgButton(dlg, IDC_SE_SENDDOMAIN, c->sendDomain ? BST_CHECKED : BST_UNCHECKED);
        BOOL hasAuth = c->user[0] != 0;
        CheckDlgButton(dlg, IDC_SE_AUTH, hasAuth ? BST_CHECKED : BST_UNCHECKED);
        EnableWindow(GetDlgItem(dlg, IDC_SE_USER), hasAuth);
        EnableWindow(GetDlgItem(dlg, IDC_SE_PASS), hasAuth);
        InitDarkMode(dlg);
        return TRUE;
    }
    PB_DARK_CTLCOLORS;
    case WM_COMMAND:
        switch (LOWORD(wp))
        {
        case IDC_SE_AUTH:
        {
            BOOL on = IsDlgButtonChecked(dlg, IDC_SE_AUTH) == BST_CHECKED;
            EnableWindow(GetDlgItem(dlg, IDC_SE_USER), on);
            EnableWindow(GetDlgItem(dlg, IDC_SE_PASS), on);
            return TRUE;
        }
        case IDOK:
        {
            PBConfig* c = (PBConfig*)GetWindowLongPtrW(dlg, GWLP_USERDATA);
            int isHttp = (int)SendMessageW(GetDlgItem(dlg, IDC_SE_PROTO), CB_GETCURSEL, 0, 0) == 1;
            lstrcpynW(c->type, isHttp ? L"HTTP" : L"SOCKS5", 16);
            GetDlgItemTextW(dlg, IDC_SE_NAME, c->name, 128);
            GetDlgItemTextW(dlg, IDC_SE_ADDR, c->host, 128);
            c->sendDomain = (IsDlgButtonChecked(dlg, IDC_SE_SENDDOMAIN) == BST_CHECKED) ? 1 : 0;
            if (!c->name[0]) lstrcpynW(c->name, c->host[0] ? c->host : L"Proxy Server", 128);
            GetDlgItemTextW(dlg, IDC_SE_PORT, c->port, 16);
            if (IsDlgButtonChecked(dlg, IDC_SE_AUTH) == BST_CHECKED)
            {
                GetDlgItemTextW(dlg, IDC_SE_USER, c->user, 128);
                GetDlgItemTextW(dlg, IDC_SE_PASS, c->pass, 128);
            }
            else { c->user[0] = 0; c->pass[0] = 0; }
            if (!c->host[0]) { MessageBoxW(dlg, T(S_ERR_HOST), APP_TITLE, MB_OK | MB_ICONWARNING); return TRUE; }
            EndDialog(dlg, 1);
            return TRUE;
        }
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    }
    return FALSE;
}

// Proxy Checker
// A Proxifier-style multi-step check. The DLL streams log lines through a callback on a
// worker thread (it can block up to 10s on an unreachable proxy); each line is posted to
// the dialog which appends it to a read-only log - no blocking, no popup.
INT_PTR CALLBACK CheckerDlgProc(HWND, UINT, WPARAM, LPARAM);

static void CheckerLogCb(const char* line, void* user)
{
    HWND dlg = (HWND)user;
    int wn = MultiByteToWideChar(CP_ACP, 0, line, -1, NULL, 0);
    if (wn <= 0) return;
    wchar_t* w = (wchar_t*)malloc((size_t)wn * sizeof(wchar_t));
    if (!w) return;
    MultiByteToWideChar(CP_ACP, 0, line, -1, w, wn);
    PostMessageW(dlg, WM_APP_TESTLINE, 0, (LPARAM)w);   // dialog frees it
}
typedef struct { HWND dlg; UINT32 id; char host[256]; unsigned short port; } CheckerJob;
static DWORD WINAPI CheckerThread(LPVOID p)
{
    CheckerJob* j = (CheckerJob*)p;
    g_api.TestProxyConfigEx(j->id, j->host, j->port, CheckerLogCb, j->dlg);
    PostMessageW(j->dlg, WM_APP_TESTDONE, 0, 0);
    free(j);
    return 0;
}
static void CheckerStart(HWND dlg)
{
    CheckerJob* j = (CheckerJob*)calloc(1, sizeof(CheckerJob));
    if (!j) return;
    j->dlg = dlg;
    j->id  = (UINT32)(UINT_PTR)GetWindowLongPtrW(dlg, GWLP_USERDATA);
    wchar_t wh[256]; GetDlgItemTextW(dlg, IDC_CK_HOST, wh, 256);
    if (!wh[0]) lstrcpynW(wh, L"www.google.com", 256);
    WideCharToMultiByte(CP_ACP, 0, wh, -1, j->host, sizeof(j->host), NULL, NULL);
    UINT port = GetDlgItemInt(dlg, IDC_CK_PORT, NULL, FALSE);
    if (port == 0 || port > 65535) port = 80;
    j->port = (unsigned short)port;

    SetWindowTextW(GetDlgItem(dlg, IDC_CK_LOG), L"");
    EnableWindow(GetDlgItem(dlg, IDC_CK_RETEST), FALSE);
    HANDLE t = CreateThread(NULL, 0, CheckerThread, j, 0, NULL);
    if (t) CloseHandle(t);
    else { free(j); EnableWindow(GetDlgItem(dlg, IDC_CK_RETEST), TRUE); }
}

INT_PTR CALLBACK CheckerDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        SetWindowLongPtrW(dlg, GWLP_USERDATA, (LONG_PTR)lp);   // lParam = config nativeId
        SetWindowTextW(dlg, T(S_DLG_CHECKER));
        SetDlgItemTextW(dlg, IDC_CK_L_HOST, T(S_CK_HOST));
        SetDlgItemTextW(dlg, IDC_CK_L_PORT, T(S_L_PORT));
        SetDlgItemTextW(dlg, IDC_CK_RETEST, T(S_BTN_RETEST));
        SetDlgItemTextW(dlg, IDCANCEL, T(S_BTN_CLOSE));
        SetDlgItemTextW(dlg, IDC_CK_HOST, L"www.google.com");
        SetDlgItemInt(dlg, IDC_CK_PORT, 80, FALSE);
        SendDlgItemMessageW(dlg, IDC_CK_LOG, WM_SETFONT,
                            (WPARAM)(g_hMono ? g_hMono : (HFONT)GetStockObject(ANSI_FIXED_FONT)), TRUE);
        InitDarkMode(dlg);
        CheckerStart(dlg);
        return TRUE;
    PB_DARK_CTLCOLORS;
    case WM_APP_TESTLINE:
    {
        wchar_t* w = (wchar_t*)lp;
        if (w)
        {
            HWND e = GetDlgItem(dlg, IDC_CK_LOG);
            int len = GetWindowTextLengthW(e);
            SendMessageW(e, EM_SETSEL, len, len);
            SendMessageW(e, EM_REPLACESEL, FALSE, (LPARAM)w);
            SendMessageW(e, EM_REPLACESEL, FALSE, (LPARAM)L"\r\n");
            free(w);
        }
        return TRUE;
    }
    case WM_APP_TESTDONE:
        EnableWindow(GetDlgItem(dlg, IDC_CK_RETEST), TRUE);
        return TRUE;
    case WM_COMMAND:
        if (LOWORD(wp) == IDC_CK_RETEST) { CheckerStart(dlg); return TRUE; }
        if (LOWORD(wp) == IDCANCEL)      { EndDialog(dlg, 0); return TRUE; }
        return FALSE;
    }
    return FALSE;
}

INT_PTR CALLBACK ServersDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        SetWindowTextW(dlg, T(S_DLG_SERVERS));
        SetDlgItemTextW(dlg, IDC_SV_ADD,    T(S_BTN_ADDDOTS));
        SetDlgItemTextW(dlg, IDC_SV_EDIT,   T(S_BTN_EDITDOTS));
        SetDlgItemTextW(dlg, IDC_SV_REMOVE, T(S_BTN_REMOVE));
        SetDlgItemTextW(dlg, IDC_SV_CHECK,  T(S_BTN_CHECK));
        SetDlgItemTextW(dlg, IDCANCEL,      T(S_BTN_CLOSE));
        InitDarkMode(dlg);
        InitServerList(GetDlgItem(dlg, IDC_SV_LIST));
        RefreshServerList(GetDlgItem(dlg, IDC_SV_LIST));
        return TRUE;
    case WM_SIZE:
        FillColumns(GetDlgItem(dlg, IDC_SV_LIST), 4);
        return FALSE;
    PB_DARK_CTLCOLORS;
    case WM_NOTIFY:
    {
        LPNMHDR nh = (LPNMHDR)lp;
        if (nh->idFrom == IDC_SV_LIST && nh->code == NM_DBLCLK)
            PostMessageW(dlg, WM_COMMAND, IDC_SV_EDIT, 0);
        return TRUE;
    }
    case WM_COMMAND:
    {
        HWND lv = GetDlgItem(dlg, IDC_SV_LIST);
        switch (LOWORD(wp))
        {
        case IDC_SV_ADD:
        {
            if (g_profile.cfgCount >= PB_MAX_CFG) { MessageBoxW(dlg, L"Config limit reached.", APP_TITLE, MB_OK); return TRUE; }
            PBConfig c; ZeroMemory(&c, sizeof(c));
            lstrcpynW(c.name, L"Proxy Server", 128);
            c.sendDomain = 1;   // default: let the proxy resolve DNS
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_SERVER), dlg, ServerEditDlgProc, (LPARAM)&c) == 1)
            {
                char h[256], u[256], p[256]; W2Ux(c.host, h, sizeof(h)); W2Ux(c.user, u, sizeof(u)); W2Ux(c.pass, p, sizeof(p));
                UINT32 id = g_api.AddProxyConfig((_wcsicmp(c.type, L"HTTP") == 0) ? PB_PROXY_HTTP : PB_PROXY_SOCKS5,
                                                 h, (unsigned short)_wtoi(c.port), u, p, c.sendDomain ? TRUE : FALSE);
                if (id > 0) { c.nativeId = id; c.storedId = PB_AllocConfigId(&g_profile); g_profile.cfg[g_profile.cfgCount++] = c; SaveActive(); RefreshServerList(lv); }
                else MessageBoxW(dlg, T(S_ERR_ADDCFG), APP_TITLE, MB_OK | MB_ICONERROR);
            }
            return TRUE;
        }
        case IDC_SV_EDIT:
        {
            int sel = ListView_GetNextItem(lv, -1, LVNI_SELECTED);
            if (sel < 0 || sel >= g_profile.cfgCount) return TRUE;
            PBConfig c = g_profile.cfg[sel];
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_SERVER), dlg, ServerEditDlgProc, (LPARAM)&c) == 1)
            {
                g_profile.cfg[sel] = c;
                char h[256], u[256], p[256]; W2Ux(c.host, h, sizeof(h)); W2Ux(c.user, u, sizeof(u)); W2Ux(c.pass, p, sizeof(p));
                g_api.EditProxyConfig(c.nativeId, (_wcsicmp(c.type, L"HTTP") == 0) ? PB_PROXY_HTTP : PB_PROXY_SOCKS5,
                                      h, (unsigned short)_wtoi(c.port), u, p, c.sendDomain ? TRUE : FALSE);
                SaveActive(); RefreshServerList(lv);
                ListView_SetItemState(lv, sel, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
            }
            return TRUE;
        }
        case IDC_SV_CHECK:
        {
            int sel = ListView_GetNextItem(lv, -1, LVNI_SELECTED);
            if (sel < 0 || sel >= g_profile.cfgCount) return TRUE;
            DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_CHECKER), dlg, CheckerDlgProc,
                            (LPARAM)(UINT_PTR)g_profile.cfg[sel].nativeId);
            return TRUE;
        }
        case IDC_SV_REMOVE:
        {
            int sel = ListView_GetNextItem(lv, -1, LVNI_SELECTED);
            if (sel < 0 || sel >= g_profile.cfgCount) return TRUE;
            g_api.DeleteProxyConfig(g_profile.cfg[sel].nativeId);
            for (int i = sel; i < g_profile.cfgCount - 1; i++) g_profile.cfg[i] = g_profile.cfg[i + 1];
            g_profile.cfgCount--;
            SaveActive(); RefreshServerList(lv);
            return TRUE;
        }
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    }
    }
    return FALSE;
}

// Proxification Rules
// List of rules with check-box enable/disable, Add.../Clone/Edit.../Remove, Move Up / Move Down ordering and a
// search box. The rule fields live in the IDD_RULE sub-dialog.

static BOOL g_rulesRefreshing = FALSE;   // guards the checkbox-change notification during refill

// Search. The list shows only the rules that contain EVERY word typed in the search box (case-insensitive) in
// their name, applications, hosts, ports, protocol, action or proxy. g_rlMap[row] is the index in g_profile.rule
// of the rule shown at that list row: every action works on rule indexes, never on row numbers, so Edit, Clone,
// Remove and the enable check boxes are correct while the list is filtered.
#define RL_MAX_WORDS 8
#define RL_WORD_LEN  64
static int     g_rlMap[PB_MAX_RULE];
static int     g_rlMapN = 0;
static wchar_t g_rlWord[RL_MAX_WORDS][RL_WORD_LEN];
static int     g_rlWordN = 0;

// The text shown in the "Proxy" column (also searched).
static void RuleProxyLabel(const PBRule* r, wchar_t* cfg, int cch)
{
    if (_wcsicmp(r->action, L"PROXY") == 0)
    {
        const PBConfig* c = NULL;
        for (int k = 0; k < g_profile.cfgCount; k++)
            if (g_profile.cfg[k].storedId == r->cfgStoredId) { c = &g_profile.cfg[k]; break; }
        if (c) _snwprintf_s(cfg, cch, _TRUNCATE, L"%s  %s  %s:%s", c->name[0] ? c->name : c->type, c->type, c->host, c->port);
        else   _snwprintf_s(cfg, cch, _TRUNCATE, L"#%u (missing)", r->cfgStoredId);
        cfg[cch - 1] = 0;
    }
    else lstrcpynW(cfg, L"\x2014", cch);   // em dash for Direct/Block
}

static void RulesSetFilterText(const wchar_t* text)
{
    g_rlWordN = 0;
    const wchar_t* p = text ? text : L"";
    while (*p && g_rlWordN < RL_MAX_WORDS)
    {
        while (*p && *p <= L' ') p++;
        if (!*p) break;
        int n = 0;
        while (*p && *p > L' ') { if (n < RL_WORD_LEN - 1) g_rlWord[g_rlWordN][n++] = *p; p++; }
        g_rlWord[g_rlWordN][n] = 0;
        g_rlWordN++;
    }
}

static BOOL RuleMatchesFilter(const PBRule* r)
{
    if (g_rlWordN == 0) return TRUE;
    wchar_t label[200]; RuleProxyLabel(r, label, 200);
    const wchar_t* name = r->name[0] ? r->name : L"ProxyBridge Rule";
    size_t cap = wcslen(name) + wcslen(r->proc) + wcslen(r->hosts) + wcslen(r->ports) + wcslen(r->proto) + wcslen(r->action) + wcslen(label) + 16;
    wchar_t* hay = (wchar_t*)malloc(cap * sizeof(wchar_t));
    if (!hay) return TRUE;                                  // out of memory: show the rule rather than hide it
    _snwprintf_s(hay, cap, _TRUNCATE, L"%s\n%s\n%s\n%s\n%s\n%s\n%s", name, r->proc, r->hosts, r->ports, r->proto, r->action, label);
    BOOL ok = TRUE;
    for (int i = 0; i < g_rlWordN && ok; i++) ok = ContainsCI(hay, g_rlWord[i]);
    free(hay);
    return ok;
}

static int RowOfRuleIndex(int idx)
{
    for (int i = 0; i < g_rlMapN; i++) if (g_rlMap[i] == idx) return i;
    return -1;
}
static int SelectedRuleIndex(HWND lv)
{
    int row = ListView_GetNextItem(lv, -1, LVNI_SELECTED);
    return (row >= 0 && row < g_rlMapN) ? g_rlMap[row] : -1;
}
static void SelectRuleIndex(HWND lv, int idx)
{
    int row = RowOfRuleIndex(idx);
    if (row < 0) return;
    ListView_SetItemState(lv, row, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
    ListView_EnsureVisible(lv, row, FALSE);
}

static void InitRulesList(HWND lv)
{
    // Checkboxes give the enable/disable toggle in the first column.
    DarkListView(lv, LVS_EX_CHECKBOXES);
    struct { int s; int w; } cols[] = {
        {S_COL_ON, 36}, {S_COL_NAME, 130}, {S_COL_APPS, 160}, {S_COL_HOSTS, 200}, {S_COL_PORTS, 60},
        {S_COL_PROTO, 55}, {S_COL_ACTION, 65}, {S_COL_CFG, 190}
    };
    LVCOLUMNW c; c.mask = LVCF_TEXT | LVCF_WIDTH;
    for (int i = 0; i < 8; i++) { c.pszText = (LPWSTR)T(cols[i].s); c.cx = cols[i].w; ListView_InsertColumn(lv, i, &c); }
    SetWindowSubclass(lv, ListDarkSubProc, 3, 0);
    FillColumns(lv, 8);
}

// "n of m rules" while a search is active; reordering is only offered on the full list.
static void RulesUpdateChrome(HWND dlg)
{
    BOOL filtered = g_rlWordN > 0;
    wchar_t txt[160]; txt[0] = 0;
    if (filtered) _snwprintf_s(txt, ARRAYSIZE(txt), _TRUNCATE, T(S_RULES_COUNT), g_rlMapN, g_profile.ruleCount);
    SetDlgItemTextW(dlg, IDC_RL_COUNT, txt);
    EnableWindow(GetDlgItem(dlg, IDC_RL_UP),    !filtered);
    EnableWindow(GetDlgItem(dlg, IDC_RL_DOWN),  !filtered);
    EnableWindow(GetDlgItem(dlg, IDC_RL_CLEAR), filtered);
}

static void RefreshRulesList(HWND lv)
{
    g_rulesRefreshing = TRUE;
    ListView_DeleteAllItems(lv);
    g_rlMapN = 0;
    for (int i = 0; i < g_profile.ruleCount && g_rlMapN < PB_MAX_RULE; i++)
        if (RuleMatchesFilter(&g_profile.rule[i])) g_rlMap[g_rlMapN++] = i;
    for (int row = 0; row < g_rlMapN; row++)
    {
        const PBRule* r = &g_profile.rule[g_rlMap[row]];
        LVITEMW it; ZeroMemory(&it, sizeof(it));
        it.mask = LVIF_TEXT; it.iItem = row; it.pszText = (LPWSTR)L"";
        ListView_InsertItem(lv, &it);
        ListView_SetItemText(lv, row, 1, r->name[0] ? (LPWSTR)r->name : (LPWSTR)L"ProxyBridge Rule");
        ListView_SetItemText(lv, row, 2, (LPWSTR)r->proc);
        ListView_SetItemText(lv, row, 3, (LPWSTR)r->hosts);
        ListView_SetItemText(lv, row, 4, (LPWSTR)r->ports);
        ListView_SetItemText(lv, row, 5, (LPWSTR)r->proto);
        ListView_SetItemText(lv, row, 6, (LPWSTR)r->action);
        wchar_t cfg[200]; RuleProxyLabel(r, cfg, 200);
        ListView_SetItemText(lv, row, 7, cfg);
        ListView_SetCheckState(lv, row, r->enabled ? TRUE : FALSE);
    }
    g_rulesRefreshing = FALSE;
    RulesUpdateChrome(GetParent(lv));
}

// Re-reads the search box and refilters, keeping the selected rule selected when it is still shown.
static void RulesApplyFilterFromBox(HWND dlg)
{
    HWND lv = GetDlgItem(dlg, IDC_RL_LIST);
    wchar_t text[256];
    GetDlgItemTextW(dlg, IDC_RL_SEARCH, text, ARRAYSIZE(text));
    int keep = SelectedRuleIndex(lv);
    RulesSetFilterText(text);
    RefreshRulesList(lv);
    SelectRuleIndex(lv, keep);
}

static void RulesFocusSearch(HWND dlg, wchar_t typed)
{
    HWND e = GetDlgItem(dlg, IDC_RL_SEARCH);
    SetFocus(e);
    if (typed)
    {
        wchar_t s[2] = { typed, 0 };
        SendMessageW(e, EM_SETSEL, (WPARAM)-1, (LPARAM)-1);          // type-to-search: append at the end
        SendMessageW(e, EM_REPLACESEL, TRUE, (LPARAM)s);
    }
    else SendMessageW(e, EM_SETSEL, 0, (LPARAM)-1);                  // Ctrl+F: select the old text
}

static void RulesFocusList(HWND dlg)
{
    HWND lv = GetDlgItem(dlg, IDC_RL_LIST);
    if (g_rlMapN <= 0) return;
    if (ListView_GetNextItem(lv, -1, LVNI_SELECTED) < 0)
        ListView_SetItemState(lv, 0, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
    SetFocus(lv);
}

// Search box keys: Enter / Down go to the list, Esc clears the text (and only closes the dialog when empty).
static LRESULT CALLBACK RuleSearchProc(HWND h, UINT m, WPARAM w, LPARAM l, UINT_PTR id, DWORD_PTR ref)
{
    (void)ref;
    HWND dlg = GetParent(h);
    switch (m)
    {
    case WM_GETDLGCODE:
    {
        LRESULT r = DefSubclassProc(h, m, w, l);
        const MSG* ms = (const MSG*)l;
        if (ms && ms->message == WM_KEYDOWN)
        {
            if (ms->wParam == VK_RETURN || ms->wParam == VK_DOWN) r |= DLGC_WANTMESSAGE;
            else if (ms->wParam == VK_ESCAPE && GetWindowTextLengthW(h) > 0) r |= DLGC_WANTMESSAGE;
        }
        return r;
    }
    case WM_KEYDOWN:
        if (w == VK_RETURN || w == VK_DOWN) { RulesFocusList(dlg); return 0; }
        if (w == VK_ESCAPE && GetWindowTextLengthW(h) > 0) { SetWindowTextW(h, L""); return 0; }   // EN_CHANGE refilters
        if (w == 'F' && GetKeyState(VK_CONTROL) < 0) { SendMessageW(h, EM_SETSEL, 0, (LPARAM)-1); return 0; }
        break;
    case WM_CHAR:
        if (w == VK_RETURN || w == VK_ESCAPE) return 0;               // no beep
        break;
    case WM_NCDESTROY:
        RemoveWindowSubclass(h, RuleSearchProc, id);
        break;
    }
    return DefSubclassProc(h, m, w, l);
}

// List keys: Ctrl+F jumps to the search box, any printable character starts a search (type-to-search),
// Esc clears an active search.
static LRESULT CALLBACK RuleListProc(HWND h, UINT m, WPARAM w, LPARAM l, UINT_PTR id, DWORD_PTR ref)
{
    (void)ref;
    HWND dlg = GetParent(h);
    switch (m)
    {
    case WM_GETDLGCODE:
    {
        LRESULT r = DefSubclassProc(h, m, w, l);
        const MSG* ms = (const MSG*)l;
        if (ms && ms->message == WM_KEYDOWN && ms->wParam == VK_ESCAPE && g_rlWordN > 0) r |= DLGC_WANTMESSAGE;
        return r;
    }
    case WM_KEYDOWN:
        if (w == 'F' && GetKeyState(VK_CONTROL) < 0) { RulesFocusSearch(dlg, 0); return 0; }
        if (w == VK_ESCAPE && g_rlWordN > 0) { SetDlgItemTextW(dlg, IDC_RL_SEARCH, L""); return 0; }
        break;
    case WM_CHAR:
        // Space is left to the list (it toggles the check box of the selected rule).
        if (w > L' ' && w != 0x7F && GetKeyState(VK_CONTROL) >= 0) { RulesFocusSearch(dlg, (wchar_t)w); return 0; }
        break;
    case WM_NCDESTROY:
        RemoveWindowSubclass(h, RuleListProc, id);
        break;
    }
    return DefSubclassProc(h, m, w, l);
}

// ---- Applications list: adding programs from Browse / Running ----
// Rules match programs by NAME (or by full path), never by PID: everything added here is a file name or a path.
typedef struct { wchar_t** v; int n; } AppList;

static void AppListAdd(AppList* l, const wchar_t* s)
{
    for (int i = 0; i < l->n; i++) if (!_wcsicmp(l->v[i], s)) return;          // no duplicates
    wchar_t* c = _wcsdup(s);
    wchar_t** nv = c ? (wchar_t**)realloc(l->v, ((size_t)l->n + 1) * sizeof(wchar_t*)) : NULL;
    if (!nv) { free(c); return; }
    l->v = nv; l->v[l->n++] = c;
}
static void AppListFree(AppList* l) { for (int i = 0; i < l->n; i++) free(l->v[i]); free(l->v); l->v = NULL; l->n = 0; }

// Does the ';' / ',' separated list already contain `name` (case-insensitive; blanks and surrounding quotes ignored)?
static BOOL AppListContains(const wchar_t* list, const wchar_t* name)
{
    size_t nl = wcslen(name);
    const wchar_t* p = list;
    while (*p)
    {
        while (*p == L';' || *p == L',' || *p == L' ' || *p == L'\t') p++;
        const wchar_t* s = p; while (*p && *p != L';' && *p != L',') p++;
        const wchar_t* e = p; while (e > s && (e[-1] == L' ' || e[-1] == L'\t')) e--;
        if (e - s >= 2 && *s == L'"' && e[-1] == L'"') { s++; e--; }
        if ((size_t)(e - s) == nl && _wcsnicmp(s, name, nl) == 0) return TRUE;
    }
    return FALSE;
}

// Appends names to the Applications box ("a.exe; b.exe"). A name already in the list is skipped, and a name that is
// empty, contains a list separator (';' ',' or a quote), or would not fit in PB_APPS_MAX is skipped as a whole - never
// cut in the middle. Returns how many were added; *skipped counts the ones that could not be (list full / unusable name).
static int AppendApps(HWND dlg, const wchar_t* const* names, int n, int* skipped, int* duplicates)
{
    int added = 0, bad = 0, dup = 0;
    HWND e = GetDlgItem(dlg, IDC_RE_APPS);
    wchar_t out[PB_APPS_MAX];
    GetWindowTextW(e, out, PB_APPS_MAX);
    if (out[0] == L'*' && out[1] == 0) out[0] = 0;                              // "any program" gives way to the first real entry
    for (int i = 0; i < n; i++)
    {
        const wchar_t* nm = names[i];
        size_t len = out[0] ? wcslen(out) : 0, nl = nm ? wcslen(nm) : 0;
        if (!nm || nl == 0 || wcspbrk(nm, L";,\"")) { bad++; continue; }
        if (AppListContains(out, nm)) { dup++; continue; }
        const wchar_t* sep = len == 0 ? L"" : (out[len - 1] == L';') ? L" " : L"; ";
        if (len + wcslen(sep) + nl >= PB_APPS_MAX) { bad++; continue; }
        _snwprintf_s(out + len, PB_APPS_MAX - len, _TRUNCATE, L"%s%s", sep, nm);
        added++;
    }
    if (added) SetWindowTextW(e, out);
    if (skipped) *skipped = bad;
    if (duplicates) *duplicates = dup;
    return added;
}

// AppendApps + the "list is full" message (kept apart so tests can call AppendApps without a message box)
static void ApplyApps(HWND dlg, const AppList* l)
{
    int bad = 0;
    AppendApps(dlg, (const wchar_t* const*)l->v, l->n, &bad, NULL);
    if (bad > 0)
    {
        wchar_t m[256]; _snwprintf_s(m, ARRAYSIZE(m), _TRUNCATE, T(S_PP_FULL), PB_APPS_MAX - 1, bad);
        MessageBoxW(dlg, m, APP_TITLE, MB_OK | MB_ICONWARNING);
    }
}

// Browse: the modern Windows file dialog. Unlike the old GetOpenFileName multi-select it accepts files from DIFFERENT
// folders (for example the results of a search), and has no fixed buffer to overflow. Adds the file NAMES.
static BOOL BrowseExecutables(HWND owner, AppList* out)
{
    BOOL got = FALSE;
    HRESULT co = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    IFileOpenDialog* fd = NULL;
    if (SUCCEEDED(CoCreateInstance(&CLSID_FileOpenDialog, NULL, CLSCTX_INPROC_SERVER, &IID_IFileOpenDialog, (void**)&fd)))
    {
        DWORD opt = 0; IFileOpenDialog_GetOptions(fd, &opt);
        IFileOpenDialog_SetOptions(fd, opt | FOS_ALLOWMULTISELECT | FOS_FORCEFILESYSTEM | FOS_FILEMUSTEXIST | FOS_PATHMUSTEXIST);
        COMDLG_FILTERSPEC spec[2] = { { L"Executables", L"*.exe" }, { L"All Files", L"*.*" } };
        IFileOpenDialog_SetFileTypes(fd, 2, spec);
        IFileOpenDialog_SetFileTypeIndex(fd, 1);
        IFileOpenDialog_SetTitle(fd, L"Select Process Executable(s)");
        if (SUCCEEDED(IFileOpenDialog_Show(fd, owner)))
        {
            IShellItemArray* arr = NULL;
            if (SUCCEEDED(IFileOpenDialog_GetResults(fd, &arr)))
            {
                DWORD cnt = 0; IShellItemArray_GetCount(arr, &cnt);
                for (DWORD i = 0; i < cnt; i++)
                {
                    IShellItem* it = NULL;
                    if (FAILED(IShellItemArray_GetItemAt(arr, i, &it))) continue;
                    PWSTR path = NULL;
                    if (SUCCEEDED(IShellItem_GetDisplayName(it, SIGDN_FILESYSPATH, &path)) && path)
                    {
                        const wchar_t* base = path;
                        for (const wchar_t* q = path; *q; q++) if (*q == L'\\' || *q == L'/') base = q + 1;
                        if (*base) { AppListAdd(out, base); got = TRUE; }
                        CoTaskMemFree(path);
                    }
                    IShellItem_Release(it);
                }
                IShellItemArray_Release(arr);
            }
        }
        IFileOpenDialog_Release(fd);
    }
    if (SUCCEEDED(co)) CoUninitialize();
    return got;
}

// ---- Running-programs picker ----
// One row per running PROGRAM (same executable path; or same name when the path cannot be read). The PID shown is
// the lowest one of that program and is for reference only - nothing here ever writes a PID into a rule.
typedef struct { wchar_t name[260]; wchar_t path[MAX_PATH]; DWORD pid; int instances; } PPRow;

static int PPCompare(const void* a, const void* b)
{
    const PPRow* x = (const PPRow*)a; const PPRow* y = (const PPRow*)b;
    int c = _wcsicmp(x->name, y->name);
    return c ? c : _wcsicmp(x->path, y->path);
}

static int PPEnumerateReal(PPRow** out)
{
    *out = NULL;
    HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snap == INVALID_HANDLE_VALUE) return 0;
    int cap = 256, n = 0;
    PPRow* rows = (PPRow*)calloc((size_t)cap, sizeof(PPRow));
    if (!rows) { CloseHandle(snap); return 0; }
    PROCESSENTRY32W pe; pe.dwSize = sizeof(pe);
    for (BOOL ok = Process32FirstW(snap, &pe); ok; ok = Process32NextW(snap, &pe))
    {
        if (pe.th32ProcessID == 0 || pe.th32ProcessID == 4) continue;           // Idle and System are not programs
        wchar_t path[MAX_PATH]; path[0] = 0;
        HANDLE h = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pe.th32ProcessID);
        if (h) { DWORD len = MAX_PATH; if (!QueryFullProcessImageNameW(h, 0, path, &len)) path[0] = 0; CloseHandle(h); }
        int found = -1;
        for (int i = 0; i < n && found < 0; i++)
            if (path[0] ? (rows[i].path[0] && !_wcsicmp(rows[i].path, path)) : (!rows[i].path[0] && !_wcsicmp(rows[i].name, pe.szExeFile))) found = i;
        if (found >= 0) { rows[found].instances++; if (pe.th32ProcessID < rows[found].pid) rows[found].pid = pe.th32ProcessID; continue; }
        if (n == cap)
        {
            PPRow* g = (PPRow*)realloc(rows, (size_t)cap * 2 * sizeof(PPRow));
            if (!g) break;
            rows = g; cap *= 2;
        }
        PPRow* r = &rows[n++]; ZeroMemory(r, sizeof(*r));
        lstrcpynW(r->name, pe.szExeFile, 260); lstrcpynW(r->path, path, MAX_PATH); r->pid = pe.th32ProcessID; r->instances = 1;
    }
    CloseHandle(snap);
    qsort(rows, (size_t)n, sizeof(PPRow), PPCompare);
    *out = rows;
    return n;
}
static int (*g_ppEnumerate)(PPRow**) = PPEnumerateReal;       // replaced by a fake list in the tests

typedef struct { AppList* result; PPRow* rows; int n; int* shown; int shownN; } PPState;

static void PPRefill(HWND dlg, PPState* st)
{
    HWND lv = GetDlgItem(dlg, IDC_PP_LIST);
    wchar_t q[256]; GetDlgItemTextW(dlg, IDC_PP_SEARCH, q, ARRAYSIZE(q));
    wchar_t words[8][64]; int nw = 0;                           // every word must appear in the name or the path
    for (const wchar_t* p = q; *p && nw < 8; )
    {
        while (*p && *p <= L' ') p++;
        if (!*p) break;
        int k = 0; while (*p && *p > L' ') { if (k < 63) words[nw][k++] = *p; p++; }
        words[nw++][k] = 0;
    }
    SendMessageW(lv, WM_SETREDRAW, FALSE, 0);
    ListView_DeleteAllItems(lv);
    st->shownN = 0;
    for (int i = 0; i < st->n; i++)
    {
        const PPRow* r = &st->rows[i];
        BOOL ok = TRUE;
        for (int w = 0; w < nw && ok; w++) ok = ContainsCI(r->name, words[w]) || ContainsCI(r->path, words[w]);
        if (!ok) continue;
        int row = st->shownN++;
        st->shown[row] = i;
        LVITEMW it; ZeroMemory(&it, sizeof(it)); it.mask = LVIF_TEXT; it.iItem = row; it.pszText = (LPWSTR)r->name;
        ListView_InsertItem(lv, &it);
        wchar_t pid[48];
        if (r->instances > 1) _snwprintf_s(pid, ARRAYSIZE(pid), _TRUNCATE, L"%lu  (+%d)", r->pid, r->instances - 1);
        else                  _snwprintf_s(pid, ARRAYSIZE(pid), _TRUNCATE, L"%lu", r->pid);
        ListView_SetItemText(lv, row, 1, pid);
        ListView_SetItemText(lv, row, 2, r->path[0] ? (LPWSTR)r->path : (LPWSTR)L"\x2014");
    }
    SendMessageW(lv, WM_SETREDRAW, TRUE, 0);
    EnableWindow(GetDlgItem(dlg, IDOK), ListView_GetSelectedCount(lv) > 0);
    wchar_t status[200]; _snwprintf_s(status, ARRAYSIZE(status), _TRUNCATE, T(S_PP_STATUS), st->n);
    SetDlgItemTextW(dlg, IDC_PP_STATUS, status);
}

static void PPReload(HWND dlg, PPState* st)
{
    free(st->rows); free(st->shown);
    st->rows = NULL; st->shown = NULL; st->n = 0; st->shownN = 0;
    st->n = g_ppEnumerate(&st->rows);
    if (st->n < 0 || !st->rows) st->n = 0;
    st->shown = (int*)calloc((size_t)(st->n > 0 ? st->n : 1), sizeof(int));
    if (!st->shown) { free(st->rows); st->rows = NULL; st->n = 0; st->shown = (int*)calloc(1, sizeof(int)); }
    PPRefill(dlg, st);
}

// Only ever a name, or a path when "full path" is ticked and the path is usable in the list ("," ";" and quotes are not).
static const wchar_t* PPChoose(const PPRow* r, BOOL fullPath)
{
    if (fullPath && r->path[0] && !wcspbrk(r->path, L";,\"")) return r->path;
    return r->name;
}

INT_PTR CALLBACK ProcPickDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    PPState* st = (PPState*)GetWindowLongPtrW(dlg, GWLP_USERDATA);
    switch (msg)
    {
    case WM_INITDIALOG:
    {
        st = (PPState*)calloc(1, sizeof(PPState));
        st->result = (AppList*)lp;
        SetWindowLongPtrW(dlg, GWLP_USERDATA, (LONG_PTR)st);
        SetWindowTextW(dlg, T(S_DLG_PROCPICK));
        SetDlgItemTextW(dlg, IDC_PP_REFRESH,  T(S_PP_REFRESH));
        SetDlgItemTextW(dlg, IDC_PP_FULLPATH, T(S_PP_FULLPATH));
        SetDlgItemTextW(dlg, IDC_PP_NOTE,     T(S_PP_NOTE));
        SetDlgItemTextW(dlg, IDOK,            T(S_BTN_ADD));
        SetDlgItemTextW(dlg, IDCANCEL,        T(S_BTN_CANCEL));
        SendDlgItemMessageW(dlg, IDC_PP_SEARCH, EM_LIMITTEXT, 255, 0);
        SendDlgItemMessageW(dlg, IDC_PP_SEARCH, EM_SETCUEBANNER, TRUE, (LPARAM)T(S_PP_SEARCH));
        InitDarkMode(dlg);
        HWND lv = GetDlgItem(dlg, IDC_PP_LIST);
        DarkListView(lv, 0);
        struct { int s; int w; } cols[] = { {S_PP_COL_NAME, 150}, {S_PP_COL_PID, 80}, {S_PP_COL_PATH, 380} };
        LVCOLUMNW c; c.mask = LVCF_TEXT | LVCF_WIDTH;
        for (int i = 0; i < 3; i++) { c.pszText = (LPWSTR)T(cols[i].s); c.cx = cols[i].w; ListView_InsertColumn(lv, i, &c); }
        PPReload(dlg, st);
        return TRUE;
    }
    PB_DARK_CTLCOLORS;
    case WM_NOTIFY:
    {
        LPNMHDR nh = (LPNMHDR)lp;
        if (nh->idFrom == IDC_PP_LIST && nh->code == LVN_ITEMCHANGED)
            EnableWindow(GetDlgItem(dlg, IDOK), ListView_GetSelectedCount(GetDlgItem(dlg, IDC_PP_LIST)) > 0);
        else if (nh->idFrom == IDC_PP_LIST && nh->code == NM_DBLCLK && ListView_GetSelectedCount(GetDlgItem(dlg, IDC_PP_LIST)) > 0)
            PostMessageW(dlg, WM_COMMAND, IDOK, 0);
        return TRUE;
    }
    case WM_COMMAND:
        switch (LOWORD(wp))
        {
        case IDC_PP_SEARCH:  if (HIWORD(wp) == EN_CHANGE && st) PPRefill(dlg, st); return TRUE;
        case IDC_PP_REFRESH: if (st) PPReload(dlg, st); return TRUE;
        case IDOK:
        {
            HWND lv = GetDlgItem(dlg, IDC_PP_LIST);
            BOOL full = IsDlgButtonChecked(dlg, IDC_PP_FULLPATH) == BST_CHECKED;
            for (int row = ListView_GetNextItem(lv, -1, LVNI_SELECTED); row >= 0 && st; row = ListView_GetNextItem(lv, row, LVNI_SELECTED))
                if (row < st->shownN) AppListAdd(st->result, PPChoose(&st->rows[st->shown[row]], full));
            EndDialog(dlg, (st && st->result->n > 0) ? 1 : 0);
            return TRUE;
        }
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    case WM_DESTROY:
        if (st) { free(st->rows); free(st->shown); free(st); SetWindowLongPtrW(dlg, GWLP_USERDATA, 0); }
        return FALSE;
    }
    return FALSE;
}


// Edit sub-dialog. lParam is a PBRule* seeded with current values; on OK it is written back
// (name/proc/hosts/ports/domains/proto/action/cfgStoredId/enabled) and the dialog returns 1.
// "Also proxy localhost traffic" only means something for a PROXY rule (DIRECT / BLOCK never
// send traffic to a proxy), so show it only while the Action list has a proxy selected.
// Action list: 0 = Direct, 1 = Block, 2.. = one entry per proxy server.
static void RuleSyncLocalhostVisibility(HWND dlg)
{
    int asel = (int)SendMessageW(GetDlgItem(dlg, IDC_RE_ACTION), CB_GETCURSEL, 0, 0);
    int show = (asel >= 2) ? SW_SHOW : SW_HIDE;
    ShowWindow(GetDlgItem(dlg, IDC_RE_LOCALHOST), show);
    ShowWindow(GetDlgItem(dlg, IDC_RE_EX_LOCAL),  show);
}

INT_PTR CALLBACK RuleEditDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
    {
        SetWindowLongPtrW(dlg, GWLP_USERDATA, (LONG_PTR)lp);
        PBRule* r = (PBRule*)lp;
        SetWindowTextW(dlg, T(S_DLG_RULE));
        SetDlgItemTextW(dlg, IDC_RE_L_NAME,   T(S_L_NAME));
        SetDlgItemTextW(dlg, IDC_RE_ENABLED,  T(S_CHK_ENABLED));
        SetDlgItemTextW(dlg, IDC_RE_L_APPS,   T(S_L_APPS));
        SetDlgItemTextW(dlg, IDC_RE_L_HOSTS,  T(S_L_HOSTS));
        SetDlgItemTextW(dlg, IDC_RE_L_PORTS,  T(S_L_PORTS));
        SetDlgItemTextW(dlg, IDC_RE_L_PROTO,  T(S_L_PROTO));
        SetDlgItemTextW(dlg, IDC_RE_L_ACTION, T(S_L_ACTION));
        SetDlgItemTextW(dlg, IDC_RE_BROWSE,   T(S_BTN_BROWSE));
        SetDlgItemTextW(dlg, IDC_RE_RUNNING,  T(S_BTN_RUNNING));
        SetDlgItemTextW(dlg, IDC_RE_EX_APPS,    T(S_EX_APPS));
        SetDlgItemTextW(dlg, IDC_RE_EX_HOSTS,   T(S_EX_HOSTS));
        SetDlgItemTextW(dlg, IDC_RE_EX_PORTS,   T(S_EX_PORTS));
        SetDlgItemTextW(dlg, IDC_RE_UDPNOTE,    T(S_UDP_NOTE));
        SetDlgItemTextW(dlg, IDC_RE_LOCALHOST,  T(S_CHK_LOCALHOST));
        SetDlgItemTextW(dlg, IDC_RE_EX_LOCAL,   T(S_EX_LOCALHOST));
        SetDlgItemTextW(dlg, IDOK,            T(S_BTN_OK));
        SetDlgItemTextW(dlg, IDCANCEL,        T(S_BTN_CANCEL));
        HWND pr = GetDlgItem(dlg, IDC_RE_PROTO);
        SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)L"TCP");
        SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)L"UDP");
        SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)L"BOTH");
        // Action combo: Direct, Block, then one entry per configured proxy (item data = storedId).
        HWND ac = GetDlgItem(dlg, IDC_RE_ACTION);
        SendMessageW(ac, CB_SETITEMDATA, SendMessageW(ac, CB_ADDSTRING, 0, (LPARAM)L"Direct"), 0);
        SendMessageW(ac, CB_SETITEMDATA, SendMessageW(ac, CB_ADDSTRING, 0, (LPARAM)L"Block"),  0);
        for (int i = 0; i < g_profile.cfgCount; i++)
        {
            PBConfig* c = &g_profile.cfg[i];
            wchar_t label[320];
            _snwprintf_s(label, 320, _TRUNCATE, L"%s  %s  %s:%s", c->name[0] ? c->name : c->type, c->type, c->host, c->port);
            label[319] = 0;
            LRESULT idx = SendMessageW(ac, CB_ADDSTRING, 0, (LPARAM)label);
            SendMessageW(ac, CB_SETITEMDATA, idx, c->storedId);
        }
        SendMessageW(ac, CB_SETDROPPEDWIDTH, 360, 0);
        // Seed fields from the rule.
        SetDlgItemTextW(dlg, IDC_RE_NAME,    r->name[0]    ? r->name    : L"ProxyBridge Rule");
        SendDlgItemMessageW(dlg, IDC_RE_APPS, EM_LIMITTEXT, PB_APPS_MAX - 1, 0);
        SetDlgItemTextW(dlg, IDC_RE_APPS,    r->proc[0]    ? r->proc    : L"*");
        SetDlgItemTextW(dlg, IDC_RE_PORTS,   r->ports[0]   ? r->ports   : L"*");
        {
            // multiline editor: one entry per line (the line breaks are display-only, removed again on save)
            HWND he = GetDlgItem(dlg, IDC_RE_HOSTS);
            SendMessageW(he, EM_LIMITTEXT, PB_HOSTS_MAX * 3, 0);
            size_t fcap = wcslen(r->hosts) * 3 + 4;
            wchar_t* fmt = (wchar_t*)malloc(fcap * sizeof(wchar_t));
            if (fmt) { PB_ListFormat(r->hosts[0] ? r->hosts : L"*", fmt, fcap); SetWindowTextW(he, fmt); free(fmt); }
            else SetWindowTextW(he, L"*");
        }
        SendMessageW(pr, CB_SETCURSEL, ProtoIdx(r->proto[0] ? r->proto : L"BOTH"), 0);
        int target = 0;
        if (!_wcsicmp(r->action, L"BLOCK")) target = 1;
        else if (!_wcsicmp(r->action, L"DIRECT")) target = 0;
        else if (!_wcsicmp(r->action, L"PROXY"))
        {
            int n = (int)SendMessageW(ac, CB_GETCOUNT, 0, 0);
            for (int k = 2; k < n; k++)
                if ((UINT32)SendMessageW(ac, CB_GETITEMDATA, k, 0) == r->cfgStoredId) { target = k; break; }
        }
        SendMessageW(ac, CB_SETCURSEL, target, 0);
        CheckDlgButton(dlg, IDC_RE_ENABLED, r->enabled ? BST_CHECKED : BST_UNCHECKED);
        CheckDlgButton(dlg, IDC_RE_LOCALHOST, r->localhost ? BST_CHECKED : BST_UNCHECKED);
        RuleSyncLocalhostVisibility(dlg);
        InitDarkMode(dlg);
        return TRUE;
    }
    case WM_CTLCOLORDLG:
    case WM_CTLCOLOREDIT:
    case WM_CTLCOLORLISTBOX:
    case WM_CTLCOLORBTN:
        return DlgCtlColor(wp);
    case WM_CTLCOLORSTATIC:
    {
        HDC dc = (HDC)wp;
        int id = GetDlgCtrlID((HWND)lp);
        SetBkColor(dc, C_BG);
        if (id == IDC_RE_UDPNOTE) SetTextColor(dc, C_WARN);
        else if (id == IDC_RE_EX_APPS || id == IDC_RE_EX_HOSTS ||
                 id == IDC_RE_EX_PORTS || id == IDC_RE_EX_LOCAL) SetTextColor(dc, C_DIM);
        else SetTextColor(dc, C_TEXT);
        return (INT_PTR)g_brBg;
    }
    case WM_COMMAND:
        switch (LOWORD(wp))
        {
        case IDC_RE_ACTION:
            if (HIWORD(wp) == CBN_SELCHANGE) RuleSyncLocalhostVisibility(dlg);
            return TRUE;
        case IDC_RE_BROWSE:
        {
            AppList l = { 0 };                                 // file names only; files from different folders are fine
            if (BrowseExecutables(dlg, &l)) ApplyApps(dlg, &l);
            AppListFree(&l);
            return TRUE;
        }
        case IDC_RE_RUNNING:
        {
            AppList l = { 0 };                                 // program names (never PIDs) from the running programs
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_PROCPICK), dlg, ProcPickDlgProc, (LPARAM)&l) == 1) ApplyApps(dlg, &l);
            AppListFree(&l);
            return TRUE;
        }
        case IDOK:
        {
            PBRule* r = (PBRule*)GetWindowLongPtrW(dlg, GWLP_USERDATA);
            GetDlgItemTextW(dlg, IDC_RE_NAME,    r->name,    128);
            if (!r->name[0]) lstrcpynW(r->name, L"ProxyBridge Rule", 128);
            GetDlgItemTextW(dlg, IDC_RE_APPS,    r->proc,    PB_APPS_MAX);
            GetDlgItemTextW(dlg, IDC_RE_PORTS,   r->ports,   128);
            {
                // read the whole text (line breaks included), clean it up, and refuse - not cut - a list that is too long
                HWND he = GetDlgItem(dlg, IDC_RE_HOSTS);
                int hn = GetWindowTextLengthW(he);
                wchar_t* htxt = (wchar_t*)malloc(((size_t)hn + 1) * sizeof(wchar_t));
                if (!htxt) { MessageBoxW(dlg, L"Out of memory.", APP_TITLE, MB_OK | MB_ICONERROR); return TRUE; }
                GetWindowTextW(he, htxt, hn + 1);
                PB_ListNormalize(htxt);
                if (wcslen(htxt) >= PB_HOSTS_MAX)
                {
                    wchar_t m[96]; _snwprintf_s(m, ARRAYSIZE(m), _TRUNCATE, L"Target Hosts is too long (maximum %d characters).", PB_HOSTS_MAX - 1);
                    MessageBoxW(dlg, m, APP_TITLE, MB_OK | MB_ICONWARNING);
                    free(htxt);
                    return TRUE;
                }
                lstrcpynW(r->hosts, htxt, PB_HOSTS_MAX);
                free(htxt);
            }
            if (!r->proc[0])    lstrcpynW(r->proc,    L"*", 256);
            if (!r->hosts[0])   lstrcpynW(r->hosts,   L"*", PB_HOSTS_MAX);
            if (!r->ports[0])   lstrcpynW(r->ports,   L"*", 128);
            lstrcpynW(r->proto, ProtoName((int)SendMessageW(GetDlgItem(dlg, IDC_RE_PROTO), CB_GETCURSEL, 0, 0)), 8);
            HWND ac = GetDlgItem(dlg, IDC_RE_ACTION);
            int asel = (int)SendMessageW(ac, CB_GETCURSEL, 0, 0);
            if (asel == 0)      { lstrcpynW(r->action, L"DIRECT", 16); r->cfgStoredId = 0; }
            else if (asel == 1) { lstrcpynW(r->action, L"BLOCK",  16); r->cfgStoredId = 0; }
            else                { lstrcpynW(r->action, L"PROXY",  16);
                                  r->cfgStoredId = (UINT32)SendMessageW(ac, CB_GETITEMDATA, asel, 0); }
            r->enabled = (IsDlgButtonChecked(dlg, IDC_RE_ENABLED) == BST_CHECKED) ? 1 : 0;
            r->localhost = (asel >= 2 && IsDlgButtonChecked(dlg, IDC_RE_LOCALHOST) == BST_CHECKED) ? 1 : 0;   // only for PROXY rules
            EndDialog(dlg, 1);
            return TRUE;
        }
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    }
    return FALSE;
}

static void SwapRules(HWND lv, int a, int b)
{
    if (a < 0 || b < 0 || a >= g_profile.ruleCount || b >= g_profile.ruleCount) return;
    PBRule t = g_profile.rule[a]; g_profile.rule[a] = g_profile.rule[b]; g_profile.rule[b] = t;
    // Reorder inside the engine without recreating rules - the rule keeps its native id.
    // MoveRuleToPosition takes a 1-based position; the moved rule now sits at array index b.
    if (g_profile.rule[b].nativeId)
        g_api.MoveRuleToPosition(g_profile.rule[b].nativeId, (UINT32)(b + 1));
    SaveActive();
    RefreshRulesList(lv);
    SelectRuleIndex(lv, b);
}

INT_PTR CALLBACK RulesDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        SetWindowTextW(dlg, T(S_DLG_RULES));
        SetDlgItemTextW(dlg, IDC_RL_ADD,    T(S_BTN_ADDDOTS));
        SetDlgItemTextW(dlg, IDC_RL_CLONE,  T(S_BTN_CLONE));
        SetDlgItemTextW(dlg, IDC_RL_EDIT,   T(S_BTN_EDITDOTS));
        SetDlgItemTextW(dlg, IDC_RL_REMOVE, T(S_BTN_REMOVE));
        SetDlgItemTextW(dlg, IDC_RL_UP,     T(S_BTN_UP));
        SetDlgItemTextW(dlg, IDC_RL_DOWN,   T(S_BTN_DOWN));
        SetDlgItemTextW(dlg, IDC_RL_HINT,   T(S_RULES_HINT));
        SetDlgItemTextW(dlg, IDCANCEL,      T(S_BTN_CLOSE));
        SetDlgItemTextW(dlg, IDC_RL_CLEAR,  L"\x2715");             // multiplication X
        InitDarkMode(dlg);
        InitRulesList(GetDlgItem(dlg, IDC_RL_LIST));
        g_rlWordN = 0; g_rlMapN = 0;                                  // always open with the full list
        SendDlgItemMessageW(dlg, IDC_RL_SEARCH, EM_LIMITTEXT, 255, 0);
        SendDlgItemMessageW(dlg, IDC_RL_SEARCH, EM_SETCUEBANNER, TRUE, (LPARAM)T(S_RULES_SEARCH));
        SetWindowSubclass(GetDlgItem(dlg, IDC_RL_SEARCH), RuleSearchProc, 4, 0);
        SetWindowSubclass(GetDlgItem(dlg, IDC_RL_LIST),   RuleListProc,   5, 0);
        RefreshRulesList(GetDlgItem(dlg, IDC_RL_LIST));
        return TRUE;
    case WM_SIZE:
        FillColumns(GetDlgItem(dlg, IDC_RL_LIST), 8);
        return FALSE;
    PB_DARK_CTLCOLORS;
    case WM_NOTIFY:
    {
        LPNMHDR nh = (LPNMHDR)lp;
        HWND lv = GetDlgItem(dlg, IDC_RL_LIST);
        if (nh->idFrom == IDC_RL_LIST && nh->code == NM_DBLCLK)
        {
            PostMessageW(dlg, WM_COMMAND, IDC_RL_EDIT, 0);
        }
        else if (nh->idFrom == IDC_RL_LIST && nh->code == LVN_ITEMCHANGED && !g_rulesRefreshing)
        {
            NMLISTVIEW* nlv = (NMLISTVIEW*)lp;
            if ((nlv->uChanged & LVIF_STATE) && (nlv->uNewState & LVIS_STATEIMAGEMASK) &&
                nlv->iItem >= 0 && nlv->iItem < g_rlMapN)
            {
                int ri = g_rlMap[nlv->iItem];                         // row -> rule index
                BOOL checked = ListView_GetCheckState(lv, nlv->iItem);
                PBRule* r = &g_profile.rule[ri];
                if ((BOOL)r->enabled != checked)
                {
                    r->enabled = checked ? 1 : 0;
                    if (r->enabled) g_api.EnableRule(r->nativeId); else g_api.DisableRule(r->nativeId);
                    SaveActive();
                }
            }
        }
        return TRUE;
    }
    case WM_COMMAND:
    {
        HWND lv = GetDlgItem(dlg, IDC_RL_LIST);
        int sel = SelectedRuleIndex(lv);                              // index in g_profile.rule, not a row number
        switch (LOWORD(wp))
        {
        case IDC_RL_SEARCH:
            if (HIWORD(wp) == EN_CHANGE) RulesApplyFilterFromBox(dlg);
            return TRUE;
        case IDC_RL_CLEAR:
            SetDlgItemTextW(dlg, IDC_RL_SEARCH, L"");                 // EN_CHANGE refilters
            SetFocus(GetDlgItem(dlg, IDC_RL_SEARCH));
            return TRUE;
        case IDC_RL_ADD:
        {
            if (g_profile.ruleCount >= PB_MAX_RULE) { MessageBoxW(dlg, L"Rule limit reached.", APP_TITLE, MB_OK); return TRUE; }
            PBRule r; ZeroMemory(&r, sizeof(r));
            lstrcpynW(r.name, L"ProxyBridge Rule", 128);
            lstrcpynW(r.proc, L"*", 256); lstrcpynW(r.hosts, L"*", PB_HOSTS_MAX);
            lstrcpynW(r.ports, L"*", 128);
            lstrcpynW(r.proto, L"BOTH", 8); lstrcpynW(r.action, L"DIRECT", 16); r.enabled = 1;
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_RULE), dlg, RuleEditDlgProc, (LPARAM)&r) == 1)
            {
                UINT32 id = EngineAddRule(&r);          // appended at the end of the engine list
                if (id)
                {
                    r.nativeId = id; g_profile.rule[g_profile.ruleCount++] = r; SaveActive();
                    // a new rule that the active search hides would look like it was lost: show everything instead
                    if (g_rlWordN > 0 && !RuleMatchesFilter(&r)) SetDlgItemTextW(dlg, IDC_RL_SEARCH, L"");
                    RefreshRulesList(lv);
                    SelectRuleIndex(lv, g_profile.ruleCount - 1);
                }
                else MessageBoxW(dlg, T(S_ERR_ADDRULE), APP_TITLE, MB_OK | MB_ICONERROR);
            }
            return TRUE;
        }
        case IDC_RL_CLONE:
        {
            if (sel < 0 || sel >= g_profile.ruleCount) return TRUE;
            if (g_profile.ruleCount >= PB_MAX_RULE) { MessageBoxW(dlg, L"Rule limit reached.", APP_TITLE, MB_OK); return TRUE; }
            PBRule r = g_profile.rule[sel]; r.nativeId = 0;
            UINT32 id = EngineAddRule(&r);              // new engine rule (its own id), added at the end
            if (!id) { MessageBoxW(dlg, T(S_ERR_ADDRULE), APP_TITLE, MB_OK | MB_ICONERROR); return TRUE; }
            r.nativeId = id;
            for (int i = g_profile.ruleCount; i > sel + 1; i--) g_profile.rule[i] = g_profile.rule[i - 1];
            g_profile.rule[sel + 1] = r; g_profile.ruleCount++;
            g_api.MoveRuleToPosition(id, (UINT32)(sel + 2));   // slot it right after the source
            SaveActive(); RefreshRulesList(lv);
            SelectRuleIndex(lv, sel + 1);
            return TRUE;
        }
        case IDC_RL_EDIT:
        {
            if (sel < 0 || sel >= g_profile.ruleCount) return TRUE;
            PBRule r = g_profile.rule[sel];            // keeps nativeId - edited in place
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_RULE), dlg, RuleEditDlgProc, (LPARAM)&r) == 1)
            {
                g_profile.rule[sel] = r;
                EngineEditRule(&r);
                SaveActive(); RefreshRulesList(lv);
                SelectRuleIndex(lv, sel);              // stays unselected if the edit made it stop matching the search
            }
            return TRUE;
        }
        case IDC_RL_REMOVE:
        {
            if (sel < 0 || sel >= g_profile.ruleCount) return TRUE;
            if (g_profile.rule[sel].nativeId) g_api.DeleteRule(g_profile.rule[sel].nativeId);
            for (int i = sel; i < g_profile.ruleCount - 1; i++) g_profile.rule[i] = g_profile.rule[i + 1];
            g_profile.ruleCount--;
            SaveActive(); RefreshRulesList(lv);
            return TRUE;
        }
        case IDC_RL_UP:   if (g_rlWordN == 0 && sel > 0) SwapRules(lv, sel, sel - 1); return TRUE;
        case IDC_RL_DOWN: if (g_rlWordN == 0 && sel >= 0 && sel < g_profile.ruleCount - 1) SwapRules(lv, sel, sel + 1); return TRUE;
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    }
    }
    return FALSE;
}

// Log Filters
INT_PTR CALLBACK FilterEditDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    static const wchar_t* kProto[]  = { L"All", L"TCP", L"UDP" };
    static const wchar_t* kAction[] = { L"All", L"Direct", L"Proxy", L"Blocked" };
    switch (msg)
    {
    case WM_INITDIALOG:
    {
        SetWindowLongPtrW(dlg, GWLP_USERDATA, (LONG_PTR)lp);
        PBFilter* f = (PBFilter*)lp;
        SetWindowTextW(dlg, T(S_DLG_FILTER));
        SetDlgItemTextW(dlg, IDC_FE_L_MODE,   T(S_L_MODE));
        SetDlgItemTextW(dlg, IDC_FE_L_PROC,   T(S_L_PROC));
        SetDlgItemTextW(dlg, IDC_FE_L_IP,     T(S_L_IP));
        SetDlgItemTextW(dlg, IDC_FE_L_PORT,   T(S_L_PORT));
        SetDlgItemTextW(dlg, IDC_FE_L_PROTO,  T(S_L_PROTO));
        SetDlgItemTextW(dlg, IDC_FE_L_ACTION, T(S_L_ACTION));
        SetDlgItemTextW(dlg, IDOK, T(S_BTN_OK)); SetDlgItemTextW(dlg, IDCANCEL, T(S_BTN_CANCEL));
        HWND mode = GetDlgItem(dlg, IDC_FE_MODE), pr = GetDlgItem(dlg, IDC_FE_PROTO), ac = GetDlgItem(dlg, IDC_FE_ACTION);
        SendMessageW(mode, CB_ADDSTRING, 0, (LPARAM)L"Include");
        SendMessageW(mode, CB_ADDSTRING, 0, (LPARAM)L"Exclude");
        for (int i = 0; i < 3; i++) SendMessageW(pr, CB_ADDSTRING, 0, (LPARAM)kProto[i]);
        for (int i = 0; i < 4; i++) SendMessageW(ac, CB_ADDSTRING, 0, (LPARAM)kAction[i]);
        SendMessageW(mode, CB_SETCURSEL, (_wcsicmp(f->mode, L"Exclude") == 0) ? 1 : 0, 0);
        SetDlgItemTextW(dlg, IDC_FE_PROC, f->proc);
        SetDlgItemTextW(dlg, IDC_FE_IP,   f->ip);
        SetDlgItemTextW(dlg, IDC_FE_PORT, f->port);
        int pi = 0; if (!_wcsicmp(f->proto, L"TCP")) pi = 1; else if (!_wcsicmp(f->proto, L"UDP")) pi = 2;
        int ai = 0; if (!_wcsicmp(f->action, L"Direct")) ai = 1; else if (!_wcsicmp(f->action, L"Proxy")) ai = 2; else if (!_wcsicmp(f->action, L"Blocked")) ai = 3;
        SendMessageW(pr, CB_SETCURSEL, pi, 0);
        SendMessageW(ac, CB_SETCURSEL, ai, 0);
        InitDarkMode(dlg);
        return TRUE;
    }
    PB_DARK_CTLCOLORS;
    case WM_COMMAND:
        switch (LOWORD(wp))
        {
        case IDOK:
        {
            PBFilter* f = (PBFilter*)GetWindowLongPtrW(dlg, GWLP_USERDATA);
            int m = (int)SendMessageW(GetDlgItem(dlg, IDC_FE_MODE), CB_GETCURSEL, 0, 0);
            lstrcpynW(f->mode, m == 1 ? L"Exclude" : L"Include", 16);
            GetDlgItemTextW(dlg, IDC_FE_PROC, f->proc, 256);
            GetDlgItemTextW(dlg, IDC_FE_IP,   f->ip,   64);
            GetDlgItemTextW(dlg, IDC_FE_PORT, f->port, 16);
            int pi = (int)SendMessageW(GetDlgItem(dlg, IDC_FE_PROTO),  CB_GETCURSEL, 0, 0); if (pi < 0) pi = 0;
            int ai = (int)SendMessageW(GetDlgItem(dlg, IDC_FE_ACTION), CB_GETCURSEL, 0, 0); if (ai < 0) ai = 0;
            lstrcpynW(f->proto,  kProto[pi],  8);
            lstrcpynW(f->action, kAction[ai], 16);
            EndDialog(dlg, 1);
            return TRUE;
        }
        case IDCANCEL: EndDialog(dlg, 0); return TRUE;
        }
        return FALSE;
    }
    return FALSE;
}

static void InitFilterList(HWND lv)
{
    DarkListView(lv, 0);
    struct { int s; int w; } cols[] = {
        {S_COL_MODE, 70}, {S_COL_PROC, 150}, {S_COL_IP, 110}, {S_COL_PORTS, 70}, {S_COL_PROTO, 70}, {S_COL_ACTION, 90}
    };
    LVCOLUMNW c; c.mask = LVCF_TEXT | LVCF_WIDTH;
    for (int i = 0; i < 6; i++) { c.pszText = (LPWSTR)T(cols[i].s); c.cx = cols[i].w; ListView_InsertColumn(lv, i, &c); }
    SetWindowSubclass(lv, ListDarkSubProc, 3, 0);
    FillColumns(lv, 6);
}
static void RefreshFilterList(HWND lv)
{
    ListView_DeleteAllItems(lv);
    for (int i = 0; i < g_profile.filterCount; i++)
    {
        PBFilter* f = &g_profile.filter[i];
        LVITEMW it; ZeroMemory(&it, sizeof(it));
        it.mask = LVIF_TEXT; it.iItem = i; it.pszText = f->mode[0] ? f->mode : (LPWSTR)L"Include";
        ListView_InsertItem(lv, &it);
        ListView_SetItemText(lv, i, 1, f->proc[0]   ? f->proc   : (LPWSTR)L"*");
        ListView_SetItemText(lv, i, 2, f->ip[0]     ? f->ip     : (LPWSTR)L"*");
        ListView_SetItemText(lv, i, 3, f->port[0]   ? f->port   : (LPWSTR)L"*");
        ListView_SetItemText(lv, i, 4, f->proto[0]  ? f->proto  : (LPWSTR)L"All");
        ListView_SetItemText(lv, i, 5, f->action[0] ? f->action : (LPWSTR)L"All");
    }
}
INT_PTR CALLBACK FiltersDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        SetWindowTextW(dlg, T(S_DLG_FILTERS));
        SetDlgItemTextW(dlg, IDC_FL_DESC,   T(S_FL_DESC));
        SetDlgItemTextW(dlg, IDC_FL_ADD,    T(S_BTN_ADDDOTS));
        SetDlgItemTextW(dlg, IDC_FL_EDIT,   T(S_BTN_EDITDOTS));
        SetDlgItemTextW(dlg, IDC_FL_REMOVE, T(S_BTN_REMOVE));
        SetDlgItemTextW(dlg, IDCANCEL,      T(S_BTN_CLOSE));
        InitDarkMode(dlg);
        InitFilterList(GetDlgItem(dlg, IDC_FL_LIST));
        RefreshFilterList(GetDlgItem(dlg, IDC_FL_LIST));
        return TRUE;
    PB_DARK_CTLCOLORS;
    case WM_NOTIFY:
    {
        LPNMHDR nh = (LPNMHDR)lp;
        if (nh->idFrom == IDC_FL_LIST && nh->code == NM_DBLCLK) PostMessageW(dlg, WM_COMMAND, IDC_FL_EDIT, 0);
        return TRUE;
    }
    case WM_COMMAND:
    {
        HWND lv = GetDlgItem(dlg, IDC_FL_LIST);
        int sel = ListView_GetNextItem(lv, -1, LVNI_SELECTED);
        switch (LOWORD(wp))
        {
        case IDC_FL_ADD:
        {
            if (g_profile.filterCount >= PB_MAX_FILTER) { MessageBoxW(dlg, L"Filter limit reached.", APP_TITLE, MB_OK); return TRUE; }
            PBFilter f; ZeroMemory(&f, sizeof(f));
            lstrcpynW(f.mode, L"Include", 16); lstrcpynW(f.proto, L"All", 8); lstrcpynW(f.action, L"All", 16);
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_FILTER), dlg, FilterEditDlgProc, (LPARAM)&f) == 1)
            { g_profile.filter[g_profile.filterCount++] = f; RefreshFilterList(lv); }
            return TRUE;
        }
        case IDC_FL_EDIT:
        {
            if (sel < 0 || sel >= g_profile.filterCount) return TRUE;
            PBFilter f = g_profile.filter[sel];
            if (DialogBoxParamW(g_hInst, MAKEINTRESOURCEW(IDD_FILTER), dlg, FilterEditDlgProc, (LPARAM)&f) == 1)
            { g_profile.filter[sel] = f; RefreshFilterList(lv);
              ListView_SetItemState(lv, sel, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED); }
            return TRUE;
        }
        case IDC_FL_REMOVE:
            if (sel < 0 || sel >= g_profile.filterCount) return TRUE;
            for (int i = sel; i < g_profile.filterCount - 1; i++) g_profile.filter[i] = g_profile.filter[i + 1];
            g_profile.filterCount--;
            RefreshFilterList(lv);
            return TRUE;
        case IDCANCEL: EndDialog(dlg, 1); return TRUE;   // nonzero => caller re-applies + saves
        }
        return FALSE;
    }
    }
    return FALSE;
}

// Name input dialog
INT_PTR CALLBACK NameDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    (void)lp;
    switch (msg)
    {
    case WM_INITDIALOG:
        g_nameResult[0] = 0;
        SetWindowTextW(dlg, T(S_DLG_NEWPROFILE));
        SetDlgItemTextW(dlg, IDC_NAME_PROMPT, T(S_L_PROFNAME));
        SetDlgItemTextW(dlg, IDOK, T(S_BTN_OK));
        SetDlgItemTextW(dlg, IDCANCEL, T(S_BTN_CANCEL));
        InitDarkMode(dlg);
        SetFocus(GetDlgItem(dlg, IDC_NAME_EDIT));
        return FALSE;
    PB_DARK_CTLCOLORS;
    case WM_COMMAND:
        if (LOWORD(wp) == IDOK) { GetDlgItemTextW(dlg, IDC_NAME_EDIT, g_nameResult, PB_NAME_MAX); EndDialog(dlg, 1); return TRUE; }
        if (LOWORD(wp) == IDCANCEL) { g_nameResult[0] = 0; EndDialog(dlg, 0); return TRUE; }
        return FALSE;
    }
    return FALSE;
}

// About dialog
static void AboutCenterLink(HWND dlg, int id)
{
    HWND h = GetDlgItem(dlg, id);
    SIZE sz = {0};
    SendMessageW(h, LM_GETIDEALSIZE, 0, (LPARAM)&sz);
    RECT cr; GetClientRect(dlg, &cr);
    RECT wr; GetWindowRect(h, &wr);
    POINT p = { wr.left, wr.top }; ScreenToClient(dlg, &p);
    MoveWindow(h, (cr.right - sz.cx) / 2, p.y, sz.cx, sz.cy, TRUE);
}
INT_PTR CALLBACK AboutDlgProc(HWND dlg, UINT msg, WPARAM wp, LPARAM lp)
{
    static HFONT s_titleFont = NULL;
    switch (msg)
    {
    case WM_INITDIALOG:
        SetWindowTextW(dlg, T(S_ABOUT_TITLE));
        SetDlgItemTextW(dlg, IDC_AB_TITLE,   APP_TITLE);
        SetDlgItemTextW(dlg, IDC_AB_VER,     T(S_AB_VERSION));
        SetDlgItemTextW(dlg, IDC_AB_DESC,    T(S_AB_DESC));
        SetDlgItemTextW(dlg, IDC_AB_AUTHOR,  T(S_AB_AUTHOR));
        SetDlgItemTextW(dlg, IDC_AB_WEB,     T(S_AB_WEB));
        SetDlgItemTextW(dlg, IDC_AB_GITHUB,  T(S_AB_GITHUB));
        SetDlgItemTextW(dlg, IDC_AB_LICENSE, T(S_AB_LICENSE));
        SetDlgItemTextW(dlg, IDCANCEL,       T(S_BTN_CLOSE));
        if (!s_titleFont)
            s_titleFont = CreateFontW(-34, 0, 0, 0, FW_BOLD, 0, 0, 0, DEFAULT_CHARSET,
                                      OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
                                      DEFAULT_PITCH | FF_DONTCARE, L"Segoe UI");
        SendDlgItemMessageW(dlg, IDC_AB_TITLE, WM_SETFONT, (WPARAM)s_titleFont, TRUE);
        InitDarkMode(dlg);
        AboutCenterLink(dlg, IDC_AB_WEB);
        AboutCenterLink(dlg, IDC_AB_GITHUB);
        return TRUE;
    case WM_CTLCOLORDLG:
    case WM_CTLCOLORBTN:
    case WM_CTLCOLORSTATIC:
    {
        HDC dc = (HDC)wp;
        int id = GetDlgCtrlID((HWND)lp);
        SetBkColor(dc, C_BG);
        SetTextColor(dc, id == IDC_AB_TITLE ? C_ACCENT : (id == IDC_AB_DESC || id == 0 ? C_TEXT : C_DIM));
        return (INT_PTR)g_brBg;
    }
    case WM_NOTIFY:
    {
        LPNMHDR nh = (LPNMHDR)lp;
        if ((nh->code == NM_CLICK || nh->code == NM_RETURN) &&
            (nh->idFrom == IDC_AB_WEB || nh->idFrom == IDC_AB_GITHUB))
        {
            PNMLINK link = (PNMLINK)lp;
            ShellExecuteW(dlg, L"open", link->item.szUrl, NULL, NULL, SW_SHOWNORMAL);
        }
        return TRUE;
    }
    case WM_COMMAND:
        if (LOWORD(wp) == IDCANCEL || LOWORD(wp) == IDOK) { EndDialog(dlg, 0); return TRUE; }
        return FALSE;
    }
    return FALSE;
}

#endif // PB_UI_DIALOGS_H