picView.cpp

#pragma comment(lib, "gdiplus.lib")  // 链接GDI+库
#include <shlobj.h>
#include "framework.h"
#include "picView.h"
#include "img_utils.h"  // 引入图片工具函数头文件
#include <commdlg.h>
#include <gdiplus.h>
#include <iostream>
#include <windows.h>
using namespace Gdiplus;


#ifndef MAX_LOADSTRING
#define MAX_LOADSTRING 100  // 与之前代码中使用的一致
#endif
// 全局变量:
HINSTANCE hInst;                                // 当前实例
WCHAR szTitle[MAX_LOADSTRING];                  // 标题栏文本
WCHAR szWindowClass[MAX_LOADSTRING];            // 主窗口类名

// 应用交互相关变量（非图片处理逻辑）
int g_currentIndex = 0;                         // 当前显示的图片索引
int g_scrollOffset = 0;                         // 滚动偏移量
int g_windowWidth = 800;                        // 窗口宽度
int g_windowHeight = 600;                       // 窗口高度
int g_totalHeight = 0;          // 已加载图片总高度（统一命名，避免歧义）
int g_scrollDelta = 100;          // 单次滚动的幅度（用于移动内容）
int g_imgnum = 10;              // 每次加载的图片数量
// 前向声明:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    NumSelectDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
void                OpenDirectoryDialog(HWND hWnd);  // 打开文件夹对话框
// GDI+初始化变量
ULONG_PTR g_gdiplusToken;

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPWSTR    lpCmdLine,
    _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    // 初始化GDI+
    GdiplusStartupInput gdiplusStartupInput;
    GdiplusStartup(&g_gdiplusToken, &gdiplusStartupInput, NULL);
    // 初始化全局字符串
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_PICVIEW, szWindowClass, MAX_LOADSTRING);
    // 输出到调试器输出窗口
    WCHAR debugMsg[512];
    swprintf_s(debugMsg, L"szTitle: %s\nszWindowClass: %s", szTitle, szWindowClass);
    OutputDebugStringW(debugMsg);
    // 注册窗口类
    MyRegisterClass(hInstance);
    // 执行应用程序初始化
    if (!InitInstance(hInstance, nCmdShow))
    {
        GdiplusShutdown(g_gdiplusToken);
        ReleaseAllImages();  // 调用工具函数释放图片资源
        return FALSE;
    }
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_PICVIEW));
    MSG msg;
    // 主消息循环
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    // 清理资源
    ReleaseAllImages();  // 调用工具函数释放所有图片
    GdiplusShutdown(g_gdiplusToken);
    return (int)msg.wParam;
}

//
//  函数: MyRegisterClass()
//  目标: 注册窗口类
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc = WndProc;
    wcex.cbClsExtra = 0;
    wcex.cbWndExtra = 0;
    wcex.hInstance = hInstance;
    wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_PICVIEW));
    wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_PICVIEW);
    wcex.lpszClassName = szWindowClass;
    wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    // 临时添加：打印注册的类名
    //WCHAR debugMsg[256];
    //swprintf_s(debugMsg, L"注册的类名：%s", szWindowClass);
    //MessageBoxW(NULL, debugMsg, L"调试-注册阶段", MB_OK);
    ATOM result = RegisterClassExW(&wcex);
    if (result == 0) {
        DWORD err = GetLastError();
        WCHAR errMsg[256];
        FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err, 0, errMsg, 256, NULL);
        MessageBoxW(NULL, errMsg, L"注册失败", MB_OK);
    }
    return result;
}

//
//   函数: InitInstance(HINSTANCE, int)
//   目标: 创建主窗口
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance;  // 存储实例句柄
    // 创建带垂直滚动条的窗口
    HWND hWnd = CreateWindowW(szWindowClass, szTitle,
        WS_OVERLAPPEDWINDOW | WS_VSCROLL,
        CW_USEDEFAULT, 0, 1024, 768,  // 初始窗口大小
        nullptr, nullptr, hInstance, nullptr);
    if (!hWnd)
    {
        // 打印错误信息（需要包含 <windows.h>，已在 framework.h 中包含）
        DWORD errorCode = GetLastError();  // 获取系统错误码
        WCHAR errorMsg[256];
        FormatMessageW(
            FORMAT_MESSAGE_FROM_SYSTEM,  // 从系统获取错误描述
            NULL,
            errorCode,
            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
            errorMsg,
            256,
            NULL
        );
        // 弹出错误对话框
        MessageBoxW(NULL, errorMsg, L"窗口创建失败", MB_ICONERROR);
        return FALSE;
    }
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
    return TRUE;
}

// 打开文件夹选择对话框
void OpenDirectoryDialog(HWND hWnd)
{
    TCHAR szPath[MAX_PATH] = { 0 };
    BROWSEINFOW bi = { 0 };
    bi.hwndOwner = hWnd;
    bi.lpszTitle = L"选择图片文件夹";
    bi.ulFlags = BIF_RETURNONLYFSDIRS;  // 只允许选择目录
    // 显示目录选择对话框
    LPITEMIDLIST pidl = SHBrowseForFolderW(&bi);
    if (pidl != 0)
    {
        // 获取选择的目录路径
        if (SHGetPathFromIDListW(pidl, szPath))
        {
            LoadImagePaths(szPath);  // 调用工具函数加载图片路径
            // 重置浏览状态
            g_currentIndex = 0;
            g_scrollOffset = 0;
            loadImages(g_currentIndex, g_imgnum);
            InvalidateRect(hWnd, NULL, TRUE);  // 触发重绘
        }
        CoTaskMemFree(pidl);  // 释放资源
    }
}


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        // 分析菜单选择:
        switch (wmId)
        {
            case IDM_IMGNUM:
            {
                // 显示自定义对话框：传递g_imgnum的地址给对话框
                INT_PTR dlgResult = DialogBoxParamW(
                    GetModuleHandleW(NULL),  // 当前程序模块句柄
                    NULL,                    // 无需资源模板（动态创建控件）
                    hWnd,                    // 父窗口句柄（主窗口）
                    NumSelectDlgProc,         // 对话框回调函数
                    (LPARAM)&g_imgnum         // 传递全局变量地址（供对话框修改）
                );
                // 对话框关闭后，根据结果提示
                if (dlgResult == IDOK)
                {
                    // 提示设置成功
                    wchar_t msg[64];
                    swprintf_s(msg, L"图片数量已设置为：%d", g_imgnum);
                    MessageBoxW(hWnd, msg, L"设置成功", MB_OK | MB_ICONINFORMATION);
                    g_scrollOffset = 0;
                    loadImages(g_currentIndex, g_imgnum);
                    InvalidateRect(hWnd, NULL, TRUE);
                }
                break;
            }
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            case IDM_OPEN:  // 打开文件夹命令
                OpenDirectoryDialog(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_SIZE:
    {
        // 窗口大小改变时更新
        g_windowWidth = LOWORD(lParam);
        g_windowHeight = HIWORD(lParam);
        InvalidateRect(hWnd, NULL, TRUE);  // 重绘窗口
        break;
    }
    case WM_VSCROLL:
    {
        int scrollType = LOWORD(wParam);
        int newOffset = g_scrollOffset;
        int scrollDelta = 0;  // 重置滚动增量
        // 1. 根据滚动类型计算新偏移量和滚动增量
        switch (scrollType)
        {
        case SB_LINEUP:       // 上滚一行（50像素）
            scrollDelta = -g_scrollDelta;  // 内容向上移动，增量为负
            newOffset = max(0, newOffset + scrollDelta);
            break;
        case SB_LINEDOWN:     // 下滚一行（50像素）
            scrollDelta = g_scrollDelta;   // 内容向下移动，增量为正
            newOffset = min(g_totalHeight - g_windowHeight, newOffset + scrollDelta);
            break;
        case SB_PAGEUP:       // 上滚半页
            scrollDelta = -(g_windowHeight / 2);
            newOffset = max(0, newOffset + scrollDelta);
            break;
        case SB_PAGEDOWN:     // 下滚半页
            scrollDelta = g_windowHeight / 2;
            newOffset = min(g_totalHeight - g_windowHeight, newOffset + scrollDelta);
            break;
        case SB_THUMBPOSITION:// 拖动滑块（直接定位到目标位置）
            newOffset = HIWORD(wParam);
            scrollDelta = newOffset - g_scrollOffset;  // 计算增量（滑块拖动距离）
            break;
        }
        // 2. 偏移量变化时，移动内容并更新
        if (newOffset != g_scrollOffset)
        {
            g_scrollOffset = newOffset;
            // 关键：移动现有内容，避免全量重绘
            ScrollWindowEx(
                hWnd,                // 窗口句柄
                0,                   // 水平滚动量（0 = 仅垂直滚动）
                -scrollDelta,      // 垂直滚动量（负号表示内容移动方向与偏移一致）
                NULL,                // 滚动整个客户区
                NULL,
                NULL,
                NULL,
                SW_ERASE | SW_INVALIDATE  // 擦除背景并标记新区域为无效（需重绘）
            );
            // 同步滚动条位置
            SCROLLINFO si = { 0 };
            si.cbSize = sizeof(SCROLLINFO);
            si.fMask = SIF_POS;
            si.nPos = g_scrollOffset;
            SetScrollInfo(hWnd, SB_VERT, &si, TRUE);
        }
        return 0;  // 已处理，无需默认消息
    }
    break;
    case WM_MOUSEWHEEL:
    {
        int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
        int newOffset = g_scrollOffset;
        int scrollDelta = 0;
        // 1. 根据滚轮方向计算滚动增量和新偏移
        if (zDelta > 0)  // 滚轮向上（内容上移）
        {
            scrollDelta = -g_scrollDelta;  // 每次滚动50像素
            newOffset = max(0, newOffset + scrollDelta);
        }
        else  // 滚轮向下（内容下移）
        {
            scrollDelta = g_scrollDelta;
            newOffset = min(g_totalHeight - g_windowHeight, newOffset + scrollDelta);
        }
        // 2. 偏移量变化时，移动内容并更新
        if (newOffset != g_scrollOffset)
        {
            g_scrollOffset = newOffset;
            // 移动现有内容，仅重绘新暴露区域
            ScrollWindowEx(
                hWnd,
                0,
                -scrollDelta,
                NULL,
                NULL,
                NULL,
                NULL,
                SW_ERASE | SW_INVALIDATE
            );
            // 同步滚动条位置
            SCROLLINFO si = { 0 };
            si.cbSize = sizeof(SCROLLINFO);
            si.fMask = SIF_POS;
            si.nPos = g_scrollOffset;
            SetScrollInfo(hWnd, SB_VERT, &si, TRUE);
        }
        else if (newOffset == g_totalHeight - g_windowHeight)
        {
            g_currentIndex = g_currentIndex + g_imgnum;
            g_scrollOffset = 0;
            loadImages(g_currentIndex, g_imgnum);
            InvalidateRect(hWnd, NULL, TRUE);
        }
        else if (newOffset == 0)
        {
            g_currentIndex = g_currentIndex - g_imgnum;
            g_scrollOffset = 0;
            loadImages(g_currentIndex, g_imgnum);
            InvalidateRect(hWnd, NULL, TRUE);
        }
        return 0;
    }
    break;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);  // ps.rcPaint = 需要重绘的区域（仅新暴露部分）
        // 1. 绘制背景（仅绘制无效区域，避免全窗口擦除导致白屏）
        FillRect(hdc, &ps.rcPaint, (HBRUSH)(COLOR_WINDOW + 1));
        if (g_imagePaths.empty())
        {
            // 无图片时，仅在无效区域显示提示
            const wchar_t* msg = L"请通过文件菜单选择包含图片的文件夹";
            DrawTextW(hdc, msg, -1, &ps.rcPaint, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        }
        else
        {
            // 2. 重新计算图片总高度（确保与最新加载状态同步）
            g_totalHeight = 0;
            for (int i = 0; i < (int)g_imagePaths.size(); i++)
            {
                if (g_imageBitmaps[i] != nullptr)
                {
                    g_totalHeight += GetScaledImageHeight(i, g_windowWidth);
                }
            }
            // 3. 更新滚动条范围（确保滑块最大位置正确）
            SCROLLINFO si = { 0 };
            si.cbSize = sizeof(SCROLLINFO);
            si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
            si.nMin = 0;
            si.nMax = g_totalHeight;       // 滚动条最大值 = 图片总高度
            si.nPage = g_windowHeight;     // 滑块大小 = 窗口高度（可视区域）
            si.nPos = g_scrollOffset;      // 当前偏移量
            SetScrollInfo(hWnd, SB_VERT, &si, TRUE);
            // 4. 仅绘制无效区域内的图片（避免重复绘制）
            Graphics graphics(hdc);
            int currentY = -g_scrollOffset;  // 图片当前Y坐标（受偏移影响）
            for (int i = 0; i < (int)g_imagePaths.size(); i++)
            {
                if (g_imageBitmaps[i] == nullptr)
                    continue;  // 跳过未加载的图片
                int imgHeight = GetScaledImageHeight(i, g_windowWidth);
                // 定义当前图片的矩形区域（屏幕坐标）
                RECT imgRect = { 0, currentY, g_windowWidth, currentY + imgHeight };
                // 只绘制与无效区域（ps.rcPaint）重叠的图片
                if (IntersectRect(&imgRect, &imgRect, &ps.rcPaint))
                {
                    graphics.DrawImage(
                        g_imageBitmaps[i],
                        0, currentY,       // 图片左上角坐标
                        g_windowWidth,     // 缩放后宽度
                        imgHeight          // 缩放后高度
                    );
                }
                currentY += imgHeight;  // 移动到下一张图片的Y坐标
            }
        }
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}

// “关于”框的消息处理程序。
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;

    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

// 对话框回调函数：创建控件并处理用户交互
INT_PTR CALLBACK NumSelectDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    static int* pTargetNum;  // 指向全局变量g_imgnum的指针（用于传递值）
    switch (uMsg)
    {
        // 1. 对话框初始化：创建控件+设置初始值
    case WM_INITDIALOG:
    {
        // 接收传递的全局变量地址（从DialogBoxParamW传入）
        pTargetNum = (int*)lParam;
        // ① 创建提示标签（静态文本）
        CreateWindowExW(
            0,
            L"STATIC",                  // 控件类名（静态文本）
            L"请输入图片数量（1-100）：", // 显示文本
            WS_VISIBLE | WS_CHILD | SS_CENTERIMAGE,  // 可见+子控件+居中
            20, 20, 200, 25,            // 位置(x,y)和大小(width,height)
            hDlg,                       // 父窗口（对话框）
            (HMENU)1001,                // 控件ID（自定义）
            GetModuleHandleW(NULL),     // 当前模块句柄
            NULL
        );
        // ② 创建数字输入框（仅允许输入数字）
        CreateWindowExW(
            0,
            L"EDIT",                    // 控件类名（编辑框）
            L"",                        // 初始为空，后续设置
            WS_VISIBLE | WS_CHILD | WS_BORDER | ES_NUMBER | ES_CENTER,  // 数字输入+居中
            20, 60, 200, 30,            // 位置和大小
            hDlg,
            (HMENU)1002,                // 控件ID
            GetModuleHandleW(NULL),
            NULL
        );
        // ③ 创建“确定”按钮
        CreateWindowExW(
            0,
            L"BUTTON",                  // 控件类名（按钮）
            L"确定",
            WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,  // 默认按钮样式
            20, 110, 80, 30,
            hDlg,
            (HMENU)IDOK,                // 系统预设ID（确定）
            GetModuleHandleW(NULL),
            NULL
        );
        // ④ 创建“取消”按钮
        CreateWindowExW(
            0,
            L"BUTTON",
            L"取消",
            WS_VISIBLE | WS_CHILD,
            140, 110, 80, 30,
            hDlg,
            (HMENU)IDCANCEL,            // 系统预设ID（取消）
            GetModuleHandleW(NULL),
            NULL
        );
        // 设置输入框的初始值（显示当前g_imgnum）
        wchar_t buf[32];
        swprintf_s(buf, L"%d", *pTargetNum);
        SetDlgItemTextW(hDlg, 1002, buf);
        // 调整对话框大小（根据控件位置）
        SetWindowPos(hDlg, NULL, 0, 0, 240, 160, SWP_NOMOVE | SWP_NOZORDER);
        return TRUE;
    }
    // 2. 处理按钮点击（确定/取消）
    case WM_COMMAND:
    {
        switch (LOWORD(wParam))
        {
            // 点击“确定”
        case IDOK:
        {
            // 获取输入框的内容
            wchar_t inputBuf[32];
            GetDlgItemTextW(hDlg, 1002, inputBuf, sizeof(inputBuf) / sizeof(wchar_t));
            // 转换为整数并验证范围
            int newNum = _wtoi(inputBuf);
            if (newNum >= 1 && newNum <= 100)
            {
                *pTargetNum = newNum;  // 更新全局变量
                EndDialog(hDlg, IDOK); // 关闭对话框（返回成功）
            }
            else
            {
                // 输入无效，提示错误
                MessageBoxW(hDlg, L"请输入1-100之间的有效数字！", L"输入错误", MB_OK | MB_ICONWARNING);
            }
            return TRUE;
        }
        // 点击“取消”
        case IDCANCEL:
        {
            EndDialog(hDlg, IDCANCEL); // 关闭对话框（返回取消）
            return TRUE;
        }
        }
        break;
    }
    // 3. 对话框关闭
    case WM_CLOSE:
    {
        EndDialog(hDlg, IDCANCEL);
        return TRUE;
    }
    }
    return FALSE;
}