logoChat01.ai

#ifndef UNICODE #define UNICODE #endif #ifndef _UN...

創建於：2026年5月13日

使用 GPT-5.5 Thinking 回答 Chat01

問題

#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <shellapi.h>
#include <thread>
#include <atomic>
#include <vector>
#include <string>
#include <sstream>
#include <mutex>
#include <algorithm>
#include <cwchar>
#include <cstdint>

#pragma comment(lib, "Comctl32.lib")
#pragma comment(lib, "Shell32.lib")

// =====================================================
// Settings
// =====================================================
static constexpr int APP_W = 1020;
static constexpr int APP_H = 760;

static constexpr COLORREF CLR_BG = RGB(8, 8, 10);
static constexpr COLORREF CLR_PANEL = RGB(14, 14, 17);
static constexpr COLORREF CLR_PANEL_2 = RGB(21, 21, 25);
static constexpr COLORREF CLR_BORDER = RGB(120, 0, 15);
static constexpr COLORREF CLR_ACCENT = RGB(235, 25, 40);
static constexpr COLORREF CLR_ACCENT_2 = RGB(165, 15, 25);
static constexpr COLORREF CLR_TEXT = RGB(235, 235, 235);
static constexpr COLORREF CLR_MUTED = RGB(165, 165, 165);

static constexpr unsigned long long MAX_CPS = 10000042ULL;

// =====================================================
// Globals
// =====================================================
struct WindowItem {
HWND hwnd;
std::wstring title;
HICON icon;
};

enum class ClickMode {
Screen,
Windows
};

std::vector<WindowItem> g_windowList;
std::vector<HWND> g_selectedWindows;
std::mutex g_windowsMutex;

std::atomic<bool> g_clicking(false);
std::atomic<unsigned long long> g_cps(500);
std::atomic<bool> g_useVirtualMouse(false);
std::atomic<long> g_virtualX(0);
std::atomic<long> g_virtualY(0);
std::atomic<int> g_mode((int)ClickMode::Screen);

HWND g_mainHwnd = nullptr;

HFONT g_font = nullptr;
HFONT g_fontBold = nullptr;
HFONT g_fontTitle = nullptr;

HBRUSH g_brBg = nullptr;
HBRUSH g_brPanel = nullptr;
HBRUSH g_brEdit = nullptr;

HIMAGELIST g_imgList = nullptr;

// =====================================================
// UI
// =====================================================
HWND hBtnRefresh = nullptr;
HWND hBtnApplyWindows = nullptr;
HWND hStaticApplied = nullptr;
HWND hListView = nullptr;
HWND hEditCPS = nullptr;
HWND hBtnApplyCPS = nullptr;
HWND hStaticCPS = nullptr;
HWND hChkVirtual = nullptr;
HWND hLblVirtual = nullptr;
HWND hStaticHint = nullptr;

HWND hRadioScreen = nullptr;
HWND hRadioWindows = nullptr;

HWND hBtnMin = nullptr;
HWND hBtnMax = nullptr;
HWND hBtnClose = nullptr;

// =====================================================
// IDs
// =====================================================
enum {
ID_BTN_REFRESH = 101,
ID_LISTVIEW = 102,
ID_EDIT_CPS = 103,
ID_BTN_APPLY_CPS = 104,
ID_STATIC_CPS = 105,
ID_CHK_VIRTUAL = 106,
ID_BTN_APPLY_WINDOWS = 107,
ID_HOTKEY_F6 = 108,
ID_STATIC_APPLIED = 109,

text
ID_RADIO_SCREEN      = 120,
ID_RADIO_WINDOWS     = 121,

ID_BTN_MIN           = 201,
ID_BTN_MAX           = 202,
ID_BTN_CLOSE         = 203

};

// =====================================================
// Prototypes
// =====================================================
void RefreshWindowList();
void UpdateSelectedWindows();
void ClickLoop();
void SetVirtualMouseFromCursor();
void UpdateCpsText();
void UpdateAppliedText();
void UpdateModeUi();

static inline POINT GetVirtualPoint()
{
return POINT{ g_virtualX.load(), g_virtualY.load() };
}

// =====================================================
// GDI helpers
// =====================================================
void FillRound(HDC hdc, RECT rc, COLORREF fill, COLORREF border, int radius)
{
HBRUSH br = CreateSolidBrush(fill);
HPEN pen = CreatePen(PS_SOLID, 1, border);

text
HGDIOBJ oldBr = SelectObject(hdc, br);
HGDIOBJ oldPen = SelectObject(hdc, pen);

RoundRect(hdc, rc.left, rc.top, rc.right, rc.bottom, radius, radius);

SelectObject(hdc, oldBr);
SelectObject(hdc, oldPen);

DeleteObject(br);
DeleteObject(pen);

}

void DrawTitleLogo(HDC hdc)
{
HPEN redPen = CreatePen(PS_SOLID, 3, CLR_ACCENT);
HGDIOBJ oldPen = SelectObject(hdc, redPen);
HGDIOBJ oldBr = SelectObject(hdc, GetStockObject(NULL_BRUSH));

text
Ellipse(hdc, 28, 24, 64, 60);
Ellipse(hdc, 38, 34, 54, 50);

MoveToEx(hdc, 46, 42, nullptr);
LineTo(hdc, 70, 66);

SelectObject(hdc, oldBr);
SelectObject(hdc, oldPen);
DeleteObject(redPen);

SetBkMode(hdc, TRANSPARENT);

HFONT oldFont = (HFONT)SelectObject(hdc, g_fontTitle);

SetTextColor(hdc, CLR_ACCENT);
TextOutW(hdc, 84, 27, L"Red", 3);

SetTextColor(hdc, CLR_TEXT);
TextOutW(hdc, 130, 27, L"Clicker", 7);

SelectObject(hdc, oldFont);

}

void DrawWindowChrome(HDC hdc)
{
RECT full{ 0, 0, APP_W, APP_H };
HBRUSH bg = CreateSolidBrush(CLR_BG);
FillRect(hdc, &full, bg);
DeleteObject(bg);

text
RECT outer{ 0, 0, APP_W, APP_H };
FillRound(hdc, outer, CLR_BG, CLR_BORDER, 18);

RECT topLine{ 0, 74, APP_W, 75 };
HBRUSH brLine = CreateSolidBrush(RGB(40, 20, 23));
FillRect(hdc, &topLine, brLine);
DeleteObject(brLine);

DrawTitleLogo(hdc);

RECT modePanel{ 28, 90, 988, 164 };
FillRound(hdc, modePanel, CLR_PANEL, RGB(45, 45, 50), 8);

RECT appliedPanel{ 28, 180, 988, 230 };
FillRound(hdc, appliedPanel, CLR_PANEL, RGB(45, 45, 50), 8);

RECT listPanel{ 28, 244, 988, 588 };
FillRound(hdc, listPanel, CLR_BG, CLR_BORDER, 8);

SetBkMode(hdc, TRANSPARENT);
HFONT oldFont = (HFONT)SelectObject(hdc, g_fontBold);

SetTextColor(hdc, CLR_ACCENT);
TextOutW(hdc, 50, 260, L"Window list", 11);

SelectObject(hdc, oldFont);

}

// =====================================================
// Owner-draw buttons
// =====================================================
void DrawOwnerButton(const DRAWITEMSTRUCT* dis)
{
HDC hdc = dis->hDC;
RECT rc = dis->rcItem;
UINT id = dis->CtlID;

text
bool pressed = (dis->itemState & ODS_SELECTED) != 0;
bool hot = (dis->itemState & ODS_HOTLIGHT) != 0;

COLORREF fill = CLR_PANEL_2;
COLORREF border = RGB(55, 55, 60);
COLORREF text = CLR_TEXT;

if (id == ID_BTN_APPLY_WINDOWS || id == ID_BTN_APPLY_CPS) {
    fill = pressed ? CLR_ACCENT_2 : CLR_ACCENT;
    border = RGB(255, 60, 75);
    text = RGB(255, 255, 255);
}

if (id == ID_BTN_CLOSE) {
    fill = pressed ? RGB(130, 15, 25) : CLR_BG;
    border = CLR_BG;
    text = CLR_TEXT;
}

if (id == ID_BTN_MIN || id == ID_BTN_MAX) {
    fill = CLR_BG;
    border = CLR_BG;
    text = CLR_TEXT;
}

if (hot && id != ID_BTN_APPLY_WINDOWS && id != ID_BTN_APPLY_CPS) {
    fill = RGB(26, 26, 31);
}

FillRound(hdc, rc, fill, border, 9);

wchar_t textBuf[128]{};
GetWindowTextW(dis->hwndItem, textBuf, 128);

SetBkMode(hdc, TRANSPARENT);
SetTextColor(hdc, text);

HFONT oldFont = (HFONT)SelectObject(hdc, g_fontBold);
DrawTextW(hdc, textBuf, -1, &rc, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
SelectObject(hdc, oldFont);

}

// =====================================================
// Window icons
// =====================================================
HICON GetWindowSmallIcon(HWND hwnd)
{
HICON icon = (HICON)SendMessageW(hwnd, WM_GETICON, ICON_SMALL2, 0);
if (!icon)
icon = (HICON)SendMessageW(hwnd, WM_GETICON, ICON_SMALL, 0);
if (!icon)
icon = (HICON)SendMessageW(hwnd, WM_GETICON, ICON_BIG, 0);

text
if (!icon) {
    LONG_PTR clsIcon = GetClassLongPtrW(hwnd, GCLP_HICONSM);
    if (clsIcon)
        icon = (HICON)clsIcon;
}

if (!icon) {
    LONG_PTR clsIcon = GetClassLongPtrW(hwnd, GCLP_HICON);
    if (clsIcon)
        icon = (HICON)clsIcon;
}

if (!icon)
    icon = LoadIconW(nullptr, IDI_APPLICATION);

return icon;

}

// =====================================================
// Window enum
// =====================================================
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM)
{
if (!IsWindowVisible(hwnd))
return TRUE;

text
if (hwnd == g_mainHwnd)
    return TRUE;

wchar_t title[512]{};
GetWindowTextW(hwnd, title, 512);

if (wcslen(title) == 0)
    return TRUE;

LONG_PTR exStyle = GetWindowLongPtrW(hwnd, GWL_EXSTYLE);
if (exStyle & WS_EX_TOOLWINDOW)
    return TRUE;

g_windowList.push_back(WindowItem{ hwnd, title, GetWindowSmallIcon(hwnd) });
return TRUE;

}

void RefreshWindowList()
{
g_windowList.clear();
EnumWindows(EnumWindowsProc, 0);

text
std::sort(g_windowList.begin(), g_windowList.end(),
    [](const WindowItem& a, const WindowItem& b) {
        return a.title < b.title;
    });

ListView_DeleteAllItems(hListView);

if (g_imgList) {
    ImageList_Destroy(g_imgList);
    g_imgList = nullptr;
}

g_imgList = ImageList_Create(16, 16, ILC_COLOR32 | ILC_MASK, 16, 16);
ListView_SetImageList(hListView, g_imgList, LVSIL_SMALL);

LVCOLUMNW col{};
col.mask = LVCF_TEXT | LVCF_WIDTH;
col.pszText = const_cast<LPWSTR>(L"Windows");
col.cx = 850;

if (Header_GetItemCount(ListView_GetHeader(hListView)) == 0)
    ListView_InsertColumn(hListView, 0, &col);
else
    ListView_SetColumn(hListView, 0, &col);

for (int i = 0; i < (int)g_windowList.size(); ++i) {
    int img = ImageList_AddIcon(g_imgList, g_windowList[i].icon);

    LVITEMW item{};
    item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
    item.iItem = i;
    item.iSubItem = 0;
    item.pszText = const_cast<LPWSTR>(g_windowList[i].title.c_str());
    item.lParam = reinterpret_cast<LPARAM>(g_windowList[i].hwnd);
    item.iImage = img;
    ListView_InsertItem(hListView, &item);
}

{
    std::lock_guard<std::mutex> lock(g_windowsMutex);
    g_selectedWindows.clear();
}

UpdateAppliedText();

}

void UpdateAppliedText()
{
size_t count = 0;

text
{
    std::lock_guard<std::mutex> lock(g_windowsMutex);
    count = g_selectedWindows.size();
}

std::wstringstream ss;
ss << L"Applied windows: " << count;
SetWindowTextW(hStaticApplied, ss.str().c_str());

}

void UpdateSelectedWindows()
{
std::vector<HWND> picked;

text
int count = ListView_GetItemCount(hListView);

for (int i = 0; i < count; ++i) {
    UINT state = ListView_GetItemState(hListView, i, LVIS_STATEIMAGEMASK);

    if (state == INDEXTOSTATEIMAGEMASK(2)) {
        LVITEMW item{};
        item.mask = LVIF_PARAM;
        item.iItem = i;

        if (ListView_GetItem(hListView, &item)) {
            HWND hwnd = reinterpret_cast<HWND>(item.lParam);
            if (IsWindow(hwnd))
                picked.push_back(hwnd);
        }
    }
}

{
    std::lock_guard<std::mutex> lock(g_windowsMutex);
    g_selectedWindows = picked;
}

UpdateAppliedText();

}

// =====================================================
// CPS
// =====================================================
void UpdateCpsText()
{
std::wstringstream ss;
ss << L"CPS: " << g_cps.load();
SetWindowTextW(hStaticCPS, ss.str().c_str());
}

void ApplyCpsFromEdit()
{
wchar_t buf[64]{};
GetWindowTextW(hEditCPS, buf, 64);

text
unsigned long long value = _wcstoui64(buf, nullptr, 10);

if (value < 1)
    value = 1;

if (value > MAX_CPS)
    value = MAX_CPS;

g_cps.store(value);

std::wstringstream ss;
ss << value;
SetWindowTextW(hEditCPS, ss.str().c_str());

UpdateCpsText();

}

// =====================================================
// Clicks
// =====================================================
void SendGlobalClickBatch(unsigned long long clicks)
{
const unsigned long long MAX_BATCH = 4096;

text
while (clicks > 0) {
    unsigned long long batch64 = std::min(clicks, MAX_BATCH);
    int batch = (int)batch64;

    std::vector<INPUT> inputs(batch * 2);

    for (int i = 0; i < batch; ++i) {
        inputs[i * 2].type = INPUT_MOUSE;
        inputs[i * 2].mi.dwFlags = MOUSEEVENTF_LEFTDOWN;

        inputs[i * 2 + 1].type = INPUT_MOUSE;
        inputs[i * 2 + 1].mi.dwFlags = MOUSEEVENTF_LEFTUP;
    }

    SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT));
    clicks -= batch64;
}

}

void SendVirtualClickBatch(POINT p, unsigned long long clicks)
{
const unsigned long long MAX_BATCH = 4096;

text
int screenW = GetSystemMetrics(SM_CXSCREEN);
int screenH = GetSystemMetrics(SM_CYSCREEN);

if (screenW <= 1 || screenH <= 1)
    return;

LONG xAbs = (LONG)((double)p.x * 65535.0 / (screenW - 1));
LONG yAbs = (LONG)((double)p.y * 65535.0 / (screenH - 1));

while (clicks > 0) {
    unsigned long long batch64 = std::min(clicks, MAX_BATCH);
    int batch = (int)batch64;

    std::vector<INPUT> inputs(1 + batch * 2);

    inputs[0].type = INPUT_MOUSE;
    inputs[0].mi.dwFlags = MOUSEEVENTF_MOVE | MOUSEEVENTF_ABSOLUTE;
    inputs[0].mi.dx = xAbs;
    inputs[0].mi.dy = yAbs;

    for (int i = 0; i < batch; ++i) {
        inputs[1 + i * 2].type = INPUT_MOUSE;
        inputs[1 + i * 2].mi.dwFlags = MOUSEEVENTF_LEFTDOWN;

        inputs[1 + i * 2 + 1].type = INPUT_MOUSE;
        inputs[1 + i * 2 + 1].mi.dwFlags = MOUSEEVENTF_LEFTUP;
    }

    SendInput((UINT)inputs.size(), inputs.data(), sizeof(INPUT));
    clicks -= batch64;
}

}

LPARAM MakeMouseLParam(POINT clientPoint)
{
return MAKELPARAM((SHORT)clientPoint.x, (SHORT)clientPoint.y);
}

void PostWindowClick(HWND hwnd, POINT screenPoint)
{
if (!IsWindow(hwnd))
return;

text
POINT clientPoint = screenPoint;
ScreenToClient(hwnd, &clientPoint);

LPARAM lp = MakeMouseLParam(clientPoint);

PostMessageW(hwnd, WM_MOUSEMOVE, 0, lp);
PostMessageW(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, lp);
PostMessageW(hwnd, WM_LBUTTONUP, 0, lp);

}

void DoClickBurst(unsigned long long amount)
{
if (amount == 0)
return;

text
ClickMode mode = (ClickMode)g_mode.load();
bool virtualMode = g_useVirtualMouse.load();

POINT realPos{};
GetCursorPos(&realPos);

POINT virtualPos = GetVirtualPoint();
POINT effectivePos = virtualMode ? virtualPos : realPos;

if (mode == ClickMode::Screen) {
    if (virtualMode)
        SendVirtualClickBatch(effectivePos, amount);
    else
        SendGlobalClickBatch(amount);

    return;
}

std::vector<HWND> targets;

{
    std::lock_guard<std::mutex> lock(g_windowsMutex);
    targets = g_selectedWindows;
}

if (targets.empty())
    return;

for (unsigned long long i = 0; i < amount; ++i) {
    for (HWND hwnd : targets) {
        PostWindowClick(hwnd, effectivePos);
    }
}

}

void ClickLoop()
{
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

text
LARGE_INTEGER freq{};
LARGE_INTEGER last{};
LARGE_INTEGER now{};

QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&last);

long double accumulator = 0.0L;
int idleSpins = 0;

while (g_clicking.load(std::memory_order_relaxed)) {
    QueryPerformanceCounter(&now);

    long double elapsed = (long double)(now.QuadPart - last.QuadPart) / (long double)freq.QuadPart;
    last = now;

    unsigned long long localCps = g_cps.load(std::memory_order_relaxed);
    if (localCps < 1)
        localCps = 1;

    accumulator += elapsed * (long double)localCps;

    unsigned long long due = (unsigned long long)accumulator;

    if (due > 0) {
        ClickMode mode = (ClickMode)g_mode.load();

        unsigned long long maxBurst = (mode == ClickMode::Screen) ? 65536ULL : 4096ULL;

        if (due > maxBurst)
            due = maxBurst;

        accumulator -= (long double)due;
        DoClickBurst(due);
        idleSpins = 0;
    } else {
        if (++idleSpins < 200) {
            YieldProcessor();
        } else {
            Sleep(0);
            idleSpins = 0;
        }
    }
}

}

void ToggleClicking()
{
bool now = !g_clicking.load();

text
g_clicking.store(now);

if (now) {
    std::thread(ClickLoop).detach();
    SetWindowTextW(hStaticHint, L"F6: stop");
} else {
    SetWindowTextW(hStaticHint, L"F6: start / stop");
}

}

// =====================================================
// Virtual mouse
// =====================================================
void SetVirtualMouseFromCursor()
{
POINT p{};
GetCursorPos(&p);

text
g_virtualX.store(p.x);
g_virtualY.store(p.y);

}

// =====================================================
// Mode
// =====================================================
void UpdateModeUi()
{
ClickMode mode = (ClickMode)g_mode.load();

text
bool screen = mode == ClickMode::Screen;

ShowWindow(hBtnRefresh, screen ? SW_HIDE : SW_SHOW);
ShowWindow(hBtnApplyWindows, screen ? SW_HIDE : SW_SHOW);
ShowWindow(hStaticApplied, screen ? SW_HIDE : SW_SHOW);
ShowWindow(hListView, screen ? SW_HIDE : SW_SHOW);

InvalidateRect(g_mainHwnd, nullptr, TRUE);

}

// =====================================================
// Main window
// =====================================================
LRESULT CALLBACK MainProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_CREATE:
{
g_brBg = CreateSolidBrush(CLR_BG);
g_brPanel = CreateSolidBrush(CLR_PANEL);
g_brEdit = CreateSolidBrush(CLR_PANEL_2);

text
    g_font = CreateFontW(
        20, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
        CLEARTYPE_QUALITY, DEFAULT_PITCH, L"Segoe UI Variable Display"
    );

    g_fontBold = CreateFontW(
        20, 0, 0, 0, FW_SEMIBOLD, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
        CLEARTYPE_QUALITY, DEFAULT_PITCH, L"Segoe UI Variable Display"
    );

    g_fontTitle = CreateFontW(
        27, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE,
        DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
        CLEARTYPE_QUALITY, DEFAULT_PITCH, L"Segoe UI Variable Display"
    );

    hBtnMin = CreateWindowW(
        L"BUTTON", L"—",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        APP_W - 198, 22, 54, 38,
        hwnd, (HMENU)ID_BTN_MIN, GetModuleHandleW(nullptr), nullptr
    );

    hBtnMax = CreateWindowW(
        L"BUTTON", L"□",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        APP_W - 134, 22, 54, 38,
        hwnd, (HMENU)ID_BTN_MAX, GetModuleHandleW(nullptr), nullptr
    );

    hBtnClose = CreateWindowW(
        L"BUTTON", L"×",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        APP_W - 70, 22, 54, 38,
        hwnd, (HMENU)ID_BTN_CLOSE, GetModuleHandleW(nullptr), nullptr
    );

    hRadioScreen = CreateWindowW(
        L"BUTTON", L"Screen",
        WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON | WS_GROUP,
        50, 112, 140, 30,
        hwnd, (HMENU)ID_RADIO_SCREEN, GetModuleHandleW(nullptr), nullptr
    );

    hRadioWindows = CreateWindowW(
        L"BUTTON", L"Windows",
        WS_CHILD | WS_VISIBLE | BS_AUTORADIOBUTTON,
        210, 112, 160, 30,
        hwnd, (HMENU)ID_RADIO_WINDOWS, GetModuleHandleW(nullptr), nullptr
    );

    SendMessageW(hRadioScreen, BM_SETCHECK, BST_CHECKED, 0);

    hBtnRefresh = CreateWindowW(
        L"BUTTON", L"Refresh window list",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        400, 100, 270, 54,
        hwnd, (HMENU)ID_BTN_REFRESH, GetModuleHandleW(nullptr), nullptr
    );

    hBtnApplyWindows = CreateWindowW(
        L"BUTTON", L"Apply windows",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        690, 100, 270, 54,
        hwnd, (HMENU)ID_BTN_APPLY_WINDOWS, GetModuleHandleW(nullptr), nullptr
    );

    hStaticApplied = CreateWindowW(
        L"STATIC", L"Applied windows: 0",
        WS_CHILD | WS_VISIBLE,
        50, 194, 420, 28,
        hwnd, (HMENU)ID_STATIC_APPLIED, GetModuleHandleW(nullptr), nullptr
    );

    hListView = CreateWindowW(
        WC_LISTVIEWW,
        nullptr,
        WS_CHILD | WS_VISIBLE | LVS_REPORT | LVS_SINGLESEL |
        LVS_SHOWSELALWAYS | LVS_NOCOLUMNHEADER,
        52, 292, 910, 276,
        hwnd, (HMENU)ID_LISTVIEW, GetModuleHandleW(nullptr), nullptr
    );

    ListView_SetExtendedListViewStyle(
        hListView,
        LVS_EX_FULLROWSELECT | LVS_EX_CHECKBOXES | LVS_EX_DOUBLEBUFFER
    );

    ListView_SetBkColor(hListView, CLR_PANEL);
    ListView_SetTextBkColor(hListView, CLR_PANEL);
    ListView_SetTextColor(hListView, CLR_TEXT);

    hEditCPS = CreateWindowW(
        L"EDIT", L"500",
        WS_CHILD | WS_VISIBLE | WS_BORDER | ES_NUMBER,
        28, 616, 180, 54,
        hwnd, (HMENU)ID_EDIT_CPS, GetModuleHandleW(nullptr), nullptr
    );

    hBtnApplyCPS = CreateWindowW(
        L"BUTTON", L"Apply CPS",
        WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
        230, 616, 255, 54,
        hwnd, (HMENU)ID_BTN_APPLY_CPS, GetModuleHandleW(nullptr), nullptr
    );

    hStaticCPS = CreateWindowW(
        L"STATIC", L"CPS: 500",
        WS_CHILD | WS_VISIBLE,
        510, 630, 280, 32,
        hwnd, (HMENU)ID_STATIC_CPS, GetModuleHandleW(nullptr), nullptr
    );

    hChkVirtual = CreateWindowW(
        L"BUTTON", L"",
        WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
        28, 694, 22, 22,
        hwnd, (HMENU)ID_CHK_VIRTUAL, GetModuleHandleW(nullptr), nullptr
    );

    hLblVirtual = CreateWindowW(
        L"STATIC", L"Virtual mouse",
        WS_CHILD | WS_VISIBLE,
        58, 694, 220, 30,
        hwnd, nullptr, GetModuleHandleW(nullptr), nullptr
    );

    hStaticHint = CreateWindowW(
        L"STATIC", L"F6: start / stop",
        WS_CHILD | WS_VISIBLE,
        320, 696, 500, 28,
        hwnd, nullptr, GetModuleHandleW(nullptr), nullptr
    );

    HWND controls[] = {
        hBtnMin, hBtnMax, hBtnClose,
        hRadioScreen, hRadioWindows,
        hBtnRefresh, hBtnApplyWindows, hStaticApplied,
        hListView, hEditCPS, hBtnApplyCPS, hStaticCPS,
        hChkVirtual, hLblVirtual, hStaticHint
    };

    for (HWND c : controls)
        SendMessageW(c, WM_SETFONT, (WPARAM)g_font, TRUE);

    SendMessageW(hStaticApplied, WM_SETFONT, (WPARAM)g_fontBold, TRUE);
    SendMessageW(hStaticCPS, WM_SETFONT, (WPARAM)g_fontBold, TRUE);

    RefreshWindowList();

    RegisterHotKey(hwnd, ID_HOTKEY_F6, 0, VK_F6);

    POINT center{
        GetSystemMetrics(SM_CXSCREEN) / 2,
        GetSystemMetrics(SM_CYSCREEN) / 2
    };

    g_virtualX.store(center.x);
    g_virtualY.store(center.y);

    UpdateModeUi();

    return 0;
}

case WM_ERASEBKGND:
    return 1;

case WM_PAINT:
{
    PAINTSTRUCT ps{};
    HDC hdc = BeginPaint(hwnd, &ps);
    DrawWindowChrome(hdc);
    EndPaint(hwnd, &ps);
    return 0;
}

case WM_NCHITTEST:
{
    POINT p{ GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
    ScreenToClient(hwnd, &p);

    if (p.y >= 0 && p.y <= 75) {
        if (p.x >= APP_W - 220)
            return HTCLIENT;

        return HTCAPTION;
    }

    return HTCLIENT;
}

case WM_CTLCOLORSTATIC:
{
    HDC hdc = (HDC)wParam;
    SetBkMode(hdc, TRANSPARENT);

    HWND ctl = (HWND)lParam;

    if (ctl == hStaticApplied || ctl == hStaticCPS)
        SetTextColor(hdc, CLR_TEXT);
    else
        SetTextColor(hdc, CLR_MUTED);

    return (LRESULT)g_brBg;
}

case WM_CTLCOLORBTN:
{
    HDC hdc = (HDC)wParam;
    SetBkMode(hdc, TRANSPARENT);
    SetTextColor(hdc, CLR_TEXT);
    return (LRESULT)g_brBg;
}

case WM_CTLCOLOREDIT:
{
    HDC hdc = (HDC)wParam;
    SetBkColor(hdc, CLR_PANEL_2);
    SetTextColor(hdc, CLR_TEXT);
    return (LRESULT)g_brEdit;
}

case WM_DRAWITEM:
{
    DrawOwnerButton((DRAWITEMSTRUCT*)lParam);
    return TRUE;
}

case WM_NOTIFY:
{
    LPNMHDR hdr = (LPNMHDR)lParam;

    if (hdr->idFrom == ID_LISTVIEW && hdr->code == NM_CUSTOMDRAW) {
        LPNMLVCUSTOMDRAW cd = (LPNMLVCUSTOMDRAW)lParam;

        if (cd->nmcd.dwDrawStage == CDDS_PREPAINT) {
            SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, CDRF_NOTIFYITEMDRAW);
            return TRUE;
        }

        if (cd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT) {
            cd->clrText = CLR_TEXT;
            cd->clrTextBk = CLR_PANEL;
            SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, CDRF_DODEFAULT);
            return TRUE;
        }
    }

    return 0;
}

case WM_HOTKEY:
{
    if (wParam == ID_HOTKEY_F6)
        ToggleClicking();

    return 0;
}

case WM_COMMAND:
{
    switch (LOWORD(wParam)) {
    case ID_BTN_REFRESH:
        RefreshWindowList();
        break;

    case ID_BTN_APPLY_WINDOWS:
        UpdateSelectedWindows();
        break;

    case ID_BTN_APPLY_CPS:
        ApplyCpsFromEdit();
        break;

    case ID_RADIO_SCREEN:
        g_mode.store((int)ClickMode::Screen);
        UpdateModeUi();
        break;

    case ID_RADIO_WINDOWS:
        g_mode.store((int)ClickMode::Windows);
        UpdateModeUi();
        break;

    case ID_CHK_VIRTUAL:
    {
        LRESULT state = SendMessageW(hChkVirtual, BM_GETCHECK, 0, 0);
        bool enabled = state == BST_CHECKED;

        g_useVirtualMouse.store(enabled);

        if (enabled)
            SetVirtualMouseFromCursor();

        break;
    }

    case ID_BTN_MIN:
        ShowWindow(hwnd, SW_MINIMIZE);
        break;

    case ID_BTN_MAX:
        if (IsZoomed(hwnd))
            ShowWindow(hwnd, SW_RESTORE);
        else
            ShowWindow(hwnd, SW_MAXIMIZE);
        break;

    case ID_BTN_CLOSE:
        DestroyWindow(hwnd);
        break;
    }

    return 0;
}

case WM_DESTROY:
{
    g_clicking.store(false);

    UnregisterHotKey(hwnd, ID_HOTKEY_F6);

    if (g_imgList) ImageList_Destroy(g_imgList);

    if (g_font) DeleteObject(g_font);
    if (g_fontBold) DeleteObject(g_fontBold);
    if (g_fontTitle) DeleteObject(g_fontTitle);

    if (g_brBg) DeleteObject(g_brBg);
    if (g_brPanel) DeleteObject(g_brPanel);
    if (g_brEdit) DeleteObject(g_brEdit);

    PostQuitMessage(0);
    return 0;
}
}

return DefWindowProcW(hwnd, msg, wParam, lParam);

}

// =====================================================
// Entry point
// =====================================================
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int nCmdShow)
{
SetProcessDPIAware();

text
INITCOMMONCONTROLSEX icex{};
icex.dwSize = sizeof(icex);
icex.dwICC = ICC_LISTVIEW_CLASSES | ICC_STANDARD_CLASSES;
InitCommonControlsEx(&icex);

WNDCLASSW wc{};
wc.lpfnWndProc = MainProc;
wc.hInstance = hInstance;
wc.lpszClassName = L"RedClickerMainWindow";
wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

if (!RegisterClassW(&wc)) {
    MessageBoxW(nullptr, L"Failed to register window class.", L"Error", MB_OK | MB_ICONERROR);
    return 0;
}

int x = (GetSystemMetrics(SM_CXSCREEN) - APP_W) / 2;
int y = (GetSystemMetrics(SM_CYSCREEN) - APP_H) / 2;

g_mainHwnd = CreateWindowExW(
    WS_EX_APPWINDOW,
    L"RedClickerMainWindow",
    L"Red Clicker",
    WS_POPUP | WS_MINIMIZEBOX,
    x, y, APP_W, APP_H,
    nullptr,
    nullptr,
    hInstance,
    nullptr
);

if (!g_mainHwnd) {
    MessageBoxW(nullptr, L"Failed to create window.", L"Error", MB_OK | MB_ICONERROR);
    return 0;
}

HRGN rgn = CreateRoundRectRgn(0, 0, APP_W + 1, APP_H + 1, 18, 18);
SetWindowRgn(g_mainHwnd, rgn, TRUE);

ShowWindow(g_mainHwnd, nCmdShow);
UpdateWindow(g_mainHwnd);

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

return 0;

}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
return wWinMain(hInstance, hPrevInstance, GetCommandLineW(), nCmdShow);
}

в этом коде есть несколько проблем тебе надо их исправить

  1. в меню текст выглядит плохо надо большие красивые буквы
  2. надо всё на руском кроме названия RedClicer
  3. надо чтобы где щас windows надо название 'окна' а где scren надо экран + изначально будет 1 это окно а 2 экран
  4. когда вкладка экран надо чтобы виндоас лист и всё отстольное небыло а кпс и тд был смещён в верх
  5. когда я ставлю 3к кпс он сделал 8 к кпс надо чуть точность поднять но чтобы он спокойно мог выдавать до 30к взависимости от пк ограничение не меняй и изначальное значение кпс должно быть 42 а не 500

итог скинь готовый код с всеми изменениями

思考

Checking for potential issues in the code

I see a few possible issues, such as ensuring proper handling of std::memory_order_relaxed, and the need to include <algorithm>. There's also the struggle with transparency on custom panels where the background brush may not behave as expected. I’ll need to double-check how control backgrounds are handled under transparency and if they might cause unexpected results.

Improving static control background handling

It seems like SetBkMode(TRANSPARENT) usually leaves the text background unfilled, but static control backgrounds can end up black. I think returning g_brPanel for all statics on the panel might be a better option. For controls like checkboxes, maybe they should also use g_brPanel instead of g_brBg. Should I proceed with updating the code for this?

Thought for 2m 52s

回答

Готово: скачать исправленный RedClicer_fixed.cpp

Что изменил:

  • интерфейс перевёл на русский, кроме названия RedClicer;
  • сделал красивые крупные вкладки: 1 Окна и 2 Экран;
  • по умолчанию открывается режим Окна;
  • в режиме Экран список окон, кнопки обновления/применения и счётчик выбранных окон скрываются, а КПС-блок поднимается вверх;
  • стартовое КПС теперь 42;
  • ограничение MAX_CPS не менял;
  • цикл кликов сделал ровнее: до ~30к КПС он работает маленькими пачками, чтобы 3000 КПС не улетали в 8000 на тестерах;
  • добавил Winmm.lib и timeBeginPeriod(1) для более стабильного тайминга.

Сохраняй файл как UTF-8 или компилируй с /utf-8, потому что в коде есть русский текст.

分享這個問答