c++ - 在拖拽文件还没有进入任何窗口时，怎样获取鼠标拖拽的文件信息？

Question

像豆包电脑那样，鼠标在桌面上拖动一个文件，刚开始拖动，还没进入任何窗口，豆包就能感知到，然后在屏幕右下角弹出提示，可以帮忙解读文件。这个是怎么实现的？

通过鼠标钩子判断是否在拖拽，如果在拖拽，就通过OleGetClipboard 函数从剪贴板获取文件信息，但是剪贴板里面没有文件相关的信息。代码如下：

#include <windows.h>
#include <shlobj.h>
#include <vector>
#include <string>
#include <iostream>
#include <chrono>
#include <thread>

HHOOK g_mouseHook;
bool g_isDragging = false;
POINT g_dragStartPos = { 0, 0 };
const int DRAG_THRESHOLD = 3; // 拖动阈值（像素）

void ExtractFileInfoFromDropClipboard();
void CheckOtherDataFormats(IDataObject* pDataObject);
void ExtractFileTypeInfo(const std::wstring& filePath);


LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
    if (nCode == HC_ACTION) {
        MSLLHOOKSTRUCT* pMouse = (MSLLHOOKSTRUCT*)lParam;

        if (wParam == WM_LBUTTONDOWN) {
            //std::cout << "Mouse Button Down at (" << pMouse->pt.x << ", " << pMouse->pt.y << ")\n";
            // 你可以在这里检测是否是拖拽开始的条件
            // 记录拖动起始位置
            g_dragStartPos = pMouse->pt;
            g_isDragging = false;
        }

        if (wParam == WM_MOUSEMOVE) {
            // 检测鼠标是否有拖拽操作
            if (GetAsyncKeyState(VK_LBUTTON) & 0x8000) {
                // 检查是否超过拖动阈值
                int deltaX = abs(pMouse->pt.x - g_dragStartPos.x);
                int deltaY = abs(pMouse->pt.y - g_dragStartPos.y);

                if (!g_isDragging && (deltaX > DRAG_THRESHOLD || deltaY > DRAG_THRESHOLD)) {
                    g_isDragging = true;
                    std::cout << "move begin..." << std::endl;

                    // 尝试从拖放剪贴板获取文件信息
                    ExtractFileInfoFromDropClipboard();

                }
            }
        }

        if (wParam == WM_LBUTTONUP)
        {
            if (g_isDragging) {
                std::cout << "move end" << std::endl;
                g_isDragging = false;
            }
        }
    }
    return CallNextHookEx(g_mouseHook, nCode, wParam, lParam);
}

// 从拖放剪贴板提取文件信息
void ExtractFileInfoFromDropClipboard() {
    HRESULT hr = OleInitialize(nullptr);
    if (FAILED(hr)) {
        std::cerr << "OleInitialize failed: " << hr << std::endl;
        return;
    }
    IDataObject* pDataObject = nullptr;
    // 获取拖放剪贴板数据
    hr = OleGetClipboard(&pDataObject);
    if (SUCCEEDED(hr) && pDataObject) {
        FORMATETC fmtetc = {
            CF_HDROP,
            NULL,
            DVASPECT_CONTENT,
            -1,
            TYMED_HGLOBAL
        };

        if (SUCCEEDED(pDataObject->QueryGetData(&fmtetc))) {
            STGMEDIUM stgmed;
            // 查询HDROP数据
            hr = pDataObject->GetData(&fmtetc, &stgmed);
            if (SUCCEEDED(hr)) {
                HDROP hDrop = static_cast<HDROP>(GlobalLock(stgmed.hGlobal));
                if (hDrop) {
                    // 获取文件数量
                    UINT fileCount = DragQueryFile(hDrop, 0xFFFFFFFF, nullptr, 0);
                    std::cout << "drag file count: " << fileCount << std::endl;

                    // 遍历所有文件
                    for (UINT i = 0; i < fileCount; i++) {
                        // 获取文件路径长度
                        UINT pathLength = DragQueryFile(hDrop, i, nullptr, 0);
                        if (pathLength > 0) {
                            std::vector<TCHAR> buffer(pathLength + 1);
                            DragQueryFile(hDrop, i, buffer.data(), pathLength + 1);

                            std::wstring filePath(buffer.data());
                            std::wcout << L"file " << (i + 1) << L": " << filePath << std::endl;

                            // 获取文件属性信息
                            ExtractFileTypeInfo(filePath);
                        }
                    }

                    GlobalUnlock(stgmed.hGlobal);
                }
                ReleaseStgMedium(&stgmed);
            }
        }
        else
        {
            std::wcout << L"CF_HDROP format not supported" << std::endl;
            // 尝试其他数据格式
            //CheckOtherDataFormats(pDataObject);
        }
        pDataObject->Release();
    }
    else {
        std::wcerr << L"can not get clipboard data" << std::endl;
    }
    OleUninitialize();
}

// 检查其他数据格式
void CheckOtherDataFormats(IDataObject* pDataObject) {
    // 查询支持的数据格式
    IEnumFORMATETC* pEnumFormat = nullptr;
    HRESULT hr = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormat);

    if (SUCCEEDED(hr) && pEnumFormat) {
        FORMATETC fmtetc;
        ULONG fetched = 0;

        std::cout << "data format in clipboard:" << std::endl;

        while (pEnumFormat->Next(1, &fmtetc, &fetched) == S_OK && fetched == 1) {
            TCHAR formatName[256];
            if (GetClipboardFormatName(fmtetc.cfFormat, formatName, 256) > 0) {
                std::wcout << L"format1: " << formatName << L" (ID: " << fmtetc.cfFormat << L")" << std::endl;
            }
            else {
                // 标准格式
                std::string stdFormatName;
                switch (fmtetc.cfFormat) {
                case CF_TEXT: stdFormatName = "CF_TEXT"; break;
                case CF_UNICODETEXT: stdFormatName = "CF_UNICODETEXT"; break;
                case CF_BITMAP: stdFormatName = "CF_BITMAP"; break;
                case CF_DIB: stdFormatName = "CF_DIB"; break;
                case CF_HDROP: stdFormatName = "CF_HDROP"; break;
                case CF_LOCALE: stdFormatName = "CF_LOCALE"; break;
                case CF_OEMTEXT: stdFormatName = "CF_OEMTEXT"; break;
                default: stdFormatName = "unknown"; break;
                }
                std::cout << "format2: " << stdFormatName << " (ID: " << fmtetc.cfFormat << ")" << std::endl;
            }
        }

        pEnumFormat->Release();
    }
}

// 提取文件类型信息
void ExtractFileTypeInfo(const std::wstring& filePath) {
    // 获取文件属性
    DWORD attr = GetFileAttributes(filePath.c_str());
    if (attr != INVALID_FILE_ATTRIBUTES) {
        if (attr & FILE_ATTRIBUTE_DIRECTORY) {
            std::wcout << L"  type: directory" << std::endl;
        }
        else {
            std::wcout << L"  type: file" << std::endl;

            // 获取文件扩展名
            size_t dotPos = filePath.find_last_of(L'.');
            if (dotPos != std::wstring::npos) {
                std::wstring extension = filePath.substr(dotPos);
                std::wcout << L"  extension: " << extension << std::endl;
            }

            // 获取文件大小
            HANDLE hFile = CreateFile(filePath.c_str(), GENERIC_READ, FILE_SHARE_READ,
                nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
            if (hFile != INVALID_HANDLE_VALUE) {
                LARGE_INTEGER fileSize;
                if (GetFileSizeEx(hFile, &fileSize)) {
                    std::wcout << L"  size: " << fileSize.QuadPart << L" bytes" << std::endl;
                }
                CloseHandle(hFile);
            }
        }

        // 显示文件属性
        std::wcout << L"  properties: ";
        if (attr & FILE_ATTRIBUTE_READONLY) std::wcout << L"[read-only]";
        if (attr & FILE_ATTRIBUTE_HIDDEN) std::wcout << L"[hidden]";
        if (attr & FILE_ATTRIBUTE_SYSTEM) std::wcout << L"[system]";
        if (attr & FILE_ATTRIBUTE_ARCHIVE) std::wcout << L"[archive]";
        std::wcout << std::endl;
    }
}

void InstallMouseHook() {
    g_mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc, NULL, 0);
    if (g_mouseHook == NULL) {
        std::cerr << "Failed to install mouse hook!" << std::endl;
    }
}

int main() {
    InstallMouseHook();

    // 进入消息循环
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    // 卸载钩子
    UnhookWindowsHookEx(g_mouseHook);
    return 0;
}

Answer 1

要实现全局捕获文件拖拽操作并在未进入窗口时获取文件信息，关键在于正确处理Windows拖拽机制和剪贴板数据的获取时机。下面是基于你的代码的优化方案和实现原理：

解决方案

#include <windows.h>
#include <shlobj.h>
#include <thread>
#include <chrono>

// 全局变量
HHOOK g_mouseHook;
const int DRAG_THRESHOLD = 3; // 拖动阈值

// 修改后的拖拽检测函数
LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam) {
    static POINT dragStart{};
    static bool isDragging = false;
    
    if (nCode == HC_ACTION) {
        auto* ms = reinterpret_cast<MSLLHOOKSTRUCT*>(lParam);
        
        switch (wParam) {
        case WM_LBUTTONDOWN:
            dragStart = ms->pt;  // 记录起点
            isDragging = false;
            break;
            
        case WM_MOUSEMOVE:
            if (GetAsyncKeyState(VK_LBUTTON) & 0x8000 && !isDragging) {
                int dx = abs(ms->pt.x - dragStart.x);
                int dy = abs(ms->pt.y - dragStart.y);
                
                // 超过阈值视为拖拽
                if (dx > DRAG_THRESHOLD || dy > DRAG_THRESHOLD) {
                    isDragging = true;
                    
                    // 关键：开启独立线程处理剪贴板（避免阻塞钩子）
                    std::thread([] {
                        // 等待拖拽数据准备（重要！）
                        std::this_thread::sleep_for(std::chrono::milliseconds(50));
                        ExtractFileInfo();
                    }).detach();
                }
            }
            break;
            
        case WM_LBUTTONUP:
            isDragging = false;
            break;
        }
    }
    return CallNextHookEx(g_mouseHook, nCode, wParam, lParam);
}

// 优化的文件信息获取函数
void ExtractFileInfo() {
    OleInitialize(nullptr);  // 初始化OLE

    IDataObject* pDataObj = nullptr;
    if (SUCCEEDED(OleGetClipboard(&pDataObj)) && pDataObj) {
        FORMATETC fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
        STGMEDIUM stg;
        
        if (SUCCEEDED(pDataObj->GetData(&fmt, &stg))) {
            HDROP hDrop = static_cast<HDROP>(GlobalLock(stg.hGlobal));
            if (hDrop) {
                UINT count = DragQueryFile(hDrop, 0xFFFFFFFF, nullptr, 0);
                for (UINT i = 0; i < count; i++) {
                    wchar_t path[MAX_PATH]{};
                    DragQueryFile(hDrop, i, path, MAX_PATH);
                    // 在这里处理文件路径（示例：输出到调试窗口）
                    OutputDebugStringW(path);
                }
                GlobalUnlock(stg.hGlobal);
            }
            ReleaseStgMedium(&stg);
        }
        pDataObj->Release();
    }
    OleUninitialize();  // 清理OLE
}

关键实现原理

1. 拖拽开始检测
   使用低级鼠标钩子(WH_MOUSE_LL)检测：

   • WM_LBUTTONDOWN 记录起点
   • WM_MOUSEMOVE+VK_LBUTTON 检测拖拽阈值

2. 剪贴板获取时机

   • 使用 std::this_thread::sleep_for(50ms) 延迟确保资源管理器已将文件数据放入拖拽剪贴板
   • 必须在独立线程中处理避免阻塞钩子消息流

3. 拖拽剪贴板特性

   sequenceDiagram
     资源管理器->>系统剪贴板： 开始拖拽时填充CF_HDROP
     系统剪贴板->>应用： 通过OleGetClipboard()获取

   • 只包含 CF_HDROP 格式（无常规文件路径数据）
   • 使用 DragQueryFile 解析文件路径

4. OLE初始化要求

   • 必须调用 OleInitialize() 初始化COM
   • 每次调用都要配对的 OleUninitialize()

常见问题解决

1. 剪贴板返回空数据？

   • 增加延迟时间（50ms → 100ms）
   • 检查程序是否为32/64位匹配

2. 多文件拖拽处理

   UINT fileCount = DragQueryFile(hDrop, 0xFFFFFFFF, NULL, 0);
   for(UINT i = 0; i < fileCount; i++) {
       // 逐个处理文件
   }

3. 资源管理器外拖拽支持

   • 需额外处理 CFSTR_SHELLIDLIST 格式：

     CLIPFORMAT cfShellID = RegisterClipboardFormat(CFSTR_SHELLIDLIST);
     FORMATETC fmt = { cfShellID, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };

部署注意事项

1. 安装钩子：

   g_mouseHook = SetWindowsHookEx(WH_MOUSE_LL, MouseProc, NULL, 0);

2. 消息循环保持：

   MSG msg;
   while (GetMessage(&msg, NULL, 0, 0)) {
       TranslateMessage(&msg);
       DispatchMessage(&msg);
   }

提示：完整编译需链接 Ole32.lib 和 Shell32.lib。通过检测到拖拽后显示悬浮窗即可实现类似豆包的效果。