/**************************************************************************/
/* drop_target_windows.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "drop_target_windows.h"
#include "core/io/dir_access.h"
#include "core/math/random_pcg.h"
#include "core/os/time.h"
#include <fileapi.h>
// Helpers
static String create_temp_dir() {
Char16String buf;
int bufsize = GetTempPathW(0, nullptr) + 1;
buf.resize(bufsize);
if (GetTempPathW(bufsize, (LPWSTR)buf.ptrw()) == 0) {
return "";
}
String tmp_dir = String::utf16((const char16_t *)buf.ptr());
RandomPCG gen(Time::get_singleton()->get_ticks_usec());
const int attempts = 4;
for (int i = 0; i < attempts; ++i) {
uint32_t rnd = gen.rand();
String dirname = "godot_tmp_" + String::num_uint64(rnd);
String res_dir = tmp_dir.path_join(dirname);
Char16String res_dir16 = res_dir.utf16();
if (CreateDirectoryW((LPCWSTR)res_dir16.ptr(), nullptr)) {
return res_dir;
}
}
return "";
}
static bool remove_dir_recursive(const String &p_dir) {
Ref<DirAccess> dir_access = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
if (dir_access->change_dir(p_dir) != OK) {
return false;
}
return dir_access->erase_contents_recursive() == OK;
}
static bool stream2file(IStream *p_stream, FILEDESCRIPTORW *p_desc, const String &p_path) {
if (DirAccess::make_dir_recursive_absolute(p_path.get_base_dir()) != OK) {
return false;
}
Char16String path16 = p_path.utf16();
DWORD dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
if (p_desc->dwFlags & FD_ATTRIBUTES) {
dwFlagsAndAttributes = p_desc->dwFileAttributes;
}
HANDLE file = CreateFileW(
(LPCWSTR)path16.ptr(),
GENERIC_WRITE,
0,
nullptr,
CREATE_NEW,
dwFlagsAndAttributes,
nullptr);
if (!file) {
return false;
}
const int bufsize = 4096;
char buf[bufsize];
ULONG nread = 0;
DWORD nwritten = 0;
HRESULT read_result = S_OK;
bool result = true;
while (true) {
read_result = p_stream->Read(buf, bufsize, &nread);
if (read_result != S_OK && read_result != S_FALSE) {
result = false;
goto cleanup;
}
if (!nread) {
break;
}
while (nread > 0) {
if (!WriteFile(file, buf, nread, &nwritten, nullptr) || !nwritten) {
result = false;
goto cleanup;
}
nread -= nwritten;
}
}
cleanup:
CloseHandle(file);
return result;
}
// DropTargetWindows
bool DropTargetWindows::is_valid_filedescriptor() {
return cf_filedescriptor != 0 && cf_filecontents != 0;
}
HRESULT DropTargetWindows::handle_hdrop_format(Vector<String> *p_files, IDataObject *pDataObj) {
FORMATETC fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg;
HRESULT res = S_OK;
if (pDataObj->GetData(&fmt, &stg) != S_OK) {
return E_UNEXPECTED;
}
HDROP hDropInfo = (HDROP)GlobalLock(stg.hGlobal);
Char16String buf;
if (hDropInfo == nullptr) {
ReleaseStgMedium(&stg);
return E_UNEXPECTED;
}
int fcount = DragQueryFileW(hDropInfo, 0xFFFFFFFF, nullptr, 0);
for (int i = 0; i < fcount; i++) {
int buffsize = DragQueryFileW(hDropInfo, i, nullptr, 0);
buf.resize(buffsize + 1);
if (DragQueryFileW(hDropInfo, i, (LPWSTR)buf.ptrw(), buffsize + 1) == 0) {
res = E_UNEXPECTED;
goto cleanup;
}
String file = String::utf16((const char16_t *)buf.ptr());
p_files->push_back(file);
}
cleanup:
GlobalUnlock(stg.hGlobal);
ReleaseStgMedium(&stg);
return res;
}
HRESULT DropTargetWindows::handle_filedescriptor_format(Vector<String> *p_files, IDataObject *pDataObj) {
FORMATETC fmt = { cf_filedescriptor, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg;
HRESULT res = S_OK;
if (pDataObj->GetData(&fmt, &stg) != S_OK) {
return E_UNEXPECTED;
}
FILEGROUPDESCRIPTORW *filegroup_desc = (FILEGROUPDESCRIPTORW *)GlobalLock(stg.hGlobal);
if (!filegroup_desc) {
ReleaseStgMedium(&stg);
return E_UNEXPECTED;
}
tmp_path = create_temp_dir();
Ref<DirAccess> dir_access = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
PackedStringArray copied;
if (dir_access->change_dir(tmp_path) != OK) {
res = E_UNEXPECTED;
goto cleanup;
}
for (int i = 0; i < (int)filegroup_desc->cItems; ++i) {
res = save_as_file(tmp_path, filegroup_desc->fgd + i, pDataObj, i);
if (res != S_OK) {
res = E_UNEXPECTED;
goto cleanup;
}
}
copied = dir_access->get_files();
for (const String &file : copied) {
p_files->push_back(tmp_path.path_join(file));
}
copied = dir_access->get_directories();
for (const String &dir : copied) {
p_files->push_back(tmp_path.path_join(dir));
}
cleanup:
GlobalUnlock(filegroup_desc);
ReleaseStgMedium(&stg);
if (res != S_OK) {
remove_dir_recursive(tmp_path);
tmp_path.clear();
}
return res;
}
HRESULT DropTargetWindows::save_as_file(const String &p_out_dir, FILEDESCRIPTORW *p_file_desc, IDataObject *pDataObj, int p_file_idx) {
String relpath = String::utf16((const char16_t *)p_file_desc->cFileName);
String fullpath = p_out_dir.path_join(relpath);
if (p_file_desc->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
if (DirAccess::make_dir_recursive_absolute(fullpath) != OK) {
return E_UNEXPECTED;
}
return S_OK;
}
FORMATETC fmt = { cf_filecontents, nullptr, DVASPECT_CONTENT, p_file_idx, TYMED_ISTREAM };
STGMEDIUM stg;
HRESULT res = S_OK;
if (pDataObj->GetData(&fmt, &stg) != S_OK) {
return E_UNEXPECTED;
}
IStream *stream = stg.pstm;
if (stream == nullptr) {
res = E_UNEXPECTED;
goto cleanup;
}
if (!stream2file(stream, p_file_desc, fullpath)) {
res = E_UNEXPECTED;
goto cleanup;
}
cleanup:
ReleaseStgMedium(&stg);
return res;
}
DropTargetWindows::DropTargetWindows(DisplayServerWindows::WindowData *p_window_data) :
ref_count(1), window_data(p_window_data) {
cf_filedescriptor = RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW);
cf_filecontents = RegisterClipboardFormat(CFSTR_FILECONTENTS);
}
HRESULT STDMETHODCALLTYPE DropTargetWindows::QueryInterface(REFIID riid, void **ppvObject) {
if (riid == IID_IUnknown || riid == IID_IDropTarget) {
*ppvObject = static_cast<IDropTarget *>(this);
AddRef();
return S_OK;
}
*ppvObject = nullptr;
return E_NOINTERFACE;
}
ULONG STDMETHODCALLTYPE DropTargetWindows::AddRef() {
return InterlockedIncrement(&ref_count);
}
ULONG STDMETHODCALLTYPE DropTargetWindows::Release() {
ULONG count = InterlockedDecrement(&ref_count);
if (count == 0) {
memfree(this);
}
return count;
}
HRESULT STDMETHODCALLTYPE DropTargetWindows::DragEnter(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) {
(void)grfKeyState;
(void)pt;
FORMATETC hdrop_fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
FORMATETC filedesc_fmt = { cf_filedescriptor, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
if (!window_data->drop_files_callback.is_valid()) {
*pdwEffect = DROPEFFECT_NONE;
} else if (pDataObj->QueryGetData(&hdrop_fmt) == S_OK) {
*pdwEffect = DROPEFFECT_COPY;
} else if (is_valid_filedescriptor() && pDataObj->QueryGetData(&filedesc_fmt) == S_OK) {
*pdwEffect = DROPEFFECT_COPY;
} else {
*pdwEffect = DROPEFFECT_NONE;
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE DropTargetWindows::DragOver(DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) {
(void)grfKeyState;
(void)pt;
*pdwEffect = DROPEFFECT_COPY;
return S_OK;
}
HRESULT STDMETHODCALLTYPE DropTargetWindows::DragLeave() {
return S_OK;
}
HRESULT STDMETHODCALLTYPE DropTargetWindows::Drop(IDataObject *pDataObj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect) {
(void)grfKeyState;
(void)pt;
*pdwEffect = DROPEFFECT_NONE;
if (!window_data->drop_files_callback.is_valid()) {
return S_OK;
}
FORMATETC hdrop_fmt = { CF_HDROP, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
FORMATETC filedesc_fmt = { cf_filedescriptor, nullptr, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
Vector<String> files;
if (pDataObj->QueryGetData(&hdrop_fmt) == S_OK) {
HRESULT res = handle_hdrop_format(&files, pDataObj);
if (res != S_OK) {
return res;
}
} else if (pDataObj->QueryGetData(&filedesc_fmt) == S_OK && is_valid_filedescriptor()) {
HRESULT res = handle_filedescriptor_format(&files, pDataObj);
if (res != S_OK) {
return res;
}
} else {
return E_UNEXPECTED;
}
if (!files.size()) {
return S_OK;
}
Variant v_files = files;
const Variant *v_args[1] = { &v_files };
Variant ret;
Callable::CallError ce;
window_data->drop_files_callback.callp((const Variant **)&v_args, 1, ret, ce);
if (!tmp_path.is_empty()) {
remove_dir_recursive(tmp_path);
tmp_path.clear();
}
if (ce.error != Callable::CallError::CALL_OK) {
ERR_PRINT(vformat("Failed to execute drop files callback: %s.", Variant::get_callable_error_text(window_data->drop_files_callback, v_args, 1, ce)));
return E_UNEXPECTED;
}
*pdwEffect = DROPEFFECT_COPY;
return S_OK;
}
Codebase Browser
godot