Win32FileUtils.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
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.
 
Library: Base
File: Button
Included in API: False
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#ifdef _WIN32
#include <NDEVR/String.h>
#include <NDEVR/Translator.h>
#include <NDEVR/Thread.h>
#include <NDEVR/FileCachedData.h>
#include <NDEVR/RWLock.h>
#include <sherrors.h>
#include <Windows.h>
#include <Shlwapi.h>
#include "shobjidl_core.h"
#if NDEVR_SUPPORTS_MTP
    #include "libraries/MtpLite-master/MtpLite>
#endif
namespace NDEVR
{
    inline TranslatedString CreateCopyMoveException(DWORD error)
    {
        switch (error)
        {
        default: return _td("COPYENGINE_E_UNKNOWN", "Unknown Error Occurred while transferring file with code [error_code]").replace("[error_code]", String(cast<uint04>(error)));
        case COPYENGINE_E_USER_CANCELLED: return _td("COPYENGINE_E_USER_CANCELLED", "User cancelled job");
        case COPYENGINE_E_CANCELLED: return _td("COPYENGINE_E_CANCELLED", "Engine wants to cancel job");
        case COPYENGINE_E_REQUIRES_ELEVATION: return _td("COPYENGINE_E_REQUIRES_ELEVATION", "Need to elevate the process to complete the operation");
        case COPYENGINE_E_SAME_FILE: return _td("COPYENGINE_E_SAME_FILE", "Source and destination file are the same");
        case COPYENGINE_E_DIFF_DIR: return _td("COPYENGINE_E_DIFF_DIR", "Trying to rename a file into a different location, use move instead");
        case COPYENGINE_E_MANY_SRC_1_DEST: return _td("COPYENGINE_E_MANY_SRC_1_DEST", "One source specified, multiple destinations");
        case COPYENGINE_E_DEST_SUBTREE: return _td("COPYENGINE_E_DEST_SUBTREE", "The destination is a sub-tree of the source");
        case COPYENGINE_E_DEST_SAME_TREE: return _td("COPYENGINE_E_DEST_SAME_TREE", "The destination is the same folder as the source");
        case COPYENGINE_E_FLD_IS_FILE_DEST: return _td("COPYENGINE_E_FLD_IS_FILE_DEST", "Existing destination file with same name as folder");
        case COPYENGINE_E_FILE_IS_FLD_DEST: return _td("COPYENGINE_E_FILE_IS_FLD_DEST", "Existing destination folder with same name as file");
        case COPYENGINE_E_FILE_TOO_LARGE: return _td("COPYENGINE_E_FILE_TOO_LARGE", "File too large for destination file system");
        case COPYENGINE_E_REMOVABLE_FULL: return _td("COPYENGINE_E_REMOVABLE_FULL", "Removable Device is full");
        case COPYENGINE_E_DEST_IS_RO_CD: return _td("COPYENGINE_E_DEST_IS_RO_CD", "Destination is a Read-Only CDRom, possibly unformatted");
        case COPYENGINE_E_DEST_IS_RW_CD: return _td("COPYENGINE_E_DEST_IS_RW_CD", "Destination is a Read/Write CDRom, possibly unformatted");
        case COPYENGINE_E_DEST_IS_R_CD: return _td("COPYENGINE_E_DEST_IS_R_CD", "Destination is a Recordable (AudioL) CDRom, possibly unformatted");
        case COPYENGINE_E_DEST_IS_RO_DVD: return _td("COPYENGINE_E_DEST_IS_RO_DVD", "Destination is a Read-Only DVD, possibly unformatted");
        case COPYENGINE_E_DEST_IS_RW_DVD: return _td("COPYENGINE_E_DEST_IS_RW_DVD", "Destination is a Read/Wrote DVD, possibly unformatted");
        case COPYENGINE_E_DEST_IS_R_DVD: return _td("COPYENGINE_E_DEST_IS_R_DVD", "Destination is a Recordable (AudioL) DVD, possibly unformatted");
        case COPYENGINE_E_SRC_IS_RO_CD: return _td("COPYENGINE_E_SRC_IS_RO_CD", "Source is a Read-Only CDRom, possibly unformatted");
        case COPYENGINE_E_SRC_IS_RW_CD: return _td("COPYENGINE_E_SRC_IS_RW_CD", "Source is a Read/Write CDRom, possibly unformatted");
        case COPYENGINE_E_SRC_IS_R_CD: return _td("COPYENGINE_E_SRC_IS_R_CD", "Source is a Recordable (AudioL) CDRom, possibly unformatted");
        case COPYENGINE_E_SRC_IS_RO_DVD: return _td("COPYENGINE_E_SRC_IS_RO_DVD", "Source is a Read-Only DVD, possibly unformatted");
        case COPYENGINE_E_SRC_IS_RW_DVD: return _td("COPYENGINE_E_SRC_IS_RW_DVD", "Source is a Read/Wrote DVD, possibly unformatted");
        case COPYENGINE_E_SRC_IS_R_DVD: return _td("COPYENGINE_E_SRC_IS_R_DVD", "Source is a Recordable (AudioL) DVD, possibly unformatted");
 
        case COPYENGINE_E_INVALID_FILES_SRC: return _td("COPYENGINE_E_INVALID_FILES_SRC", "Invalid source path");
        case COPYENGINE_E_INVALID_FILES_DEST: return _td("COPYENGINE_E_INVALID_FILES_DEST", "Invalid destination path");
        case COPYENGINE_E_PATH_TOO_DEEP_SRC: return _td("COPYENGINE_E_PATH_TOO_DEEP_SRC", "Source Files within folders where the overall path is longer than MAX_PATH");
        case COPYENGINE_E_PATH_TOO_DEEP_DEST: return _td("COPYENGINE_E_PATH_TOO_DEEP_DEST", "Destination files would be within folders where the overall path is longer than MAX_PATH");
        case COPYENGINE_E_ROOT_DIR_SRC: return _td("COPYENGINE_E_ROOT_DIR_SRC", "Source is a root directory, cannot be moved or renamed");
        case COPYENGINE_E_ROOT_DIR_DEST: return _td("COPYENGINE_E_ROOT_DIR_DEST", "Destination is a root directory, cannot be renamed");
        case COPYENGINE_E_ACCESS_DENIED_SRC: return _td("COPYENGINE_E_ACCESS_DENIED_SRC", "Security problem on source");
        case COPYENGINE_E_ACCESS_DENIED_DEST: return _td("COPYENGINE_E_ACCESS_DENIED_DEST", "Security problem on destination");
        case COPYENGINE_E_PATH_NOT_FOUND_SRC: return _td("COPYENGINE_E_PATH_NOT_FOUND_SRC", "Source file does not exist, or is unavailable");
        case COPYENGINE_E_PATH_NOT_FOUND_DEST: return _td("COPYENGINE_E_PATH_NOT_FOUND_DEST", "Destination file does not exist, or is unavailable");
        case COPYENGINE_E_NET_DISCONNECT_SRC: return _td("COPYENGINE_E_NET_DISCONNECT_SRC", "Source file is on a disconnected network location");
        case COPYENGINE_E_NET_DISCONNECT_DEST: return _td("COPYENGINE_E_NET_DISCONNECT_DEST", "Destination file is on a disconnected network location");
        case COPYENGINE_E_SHARING_VIOLATION_SRC: return _td("COPYENGINE_E_SHARING_VIOLATION_SRC", "Sharing Violation on source");
        case COPYENGINE_E_SHARING_VIOLATION_DEST: return _td("COPYENGINE_E_SHARING_VIOLATION_DEST", "Sharing Violation on destination");
 
        case COPYENGINE_E_ALREADY_EXISTS_NORMAL: return _td("COPYENGINE_E_ALREADY_EXISTS_NORMAL", "Destination exists, cannot replace");
        case COPYENGINE_E_ALREADY_EXISTS_READONLY: return _td("COPYENGINE_E_ALREADY_EXISTS_READONLY", "Destination with read-only attribute exists, cannot replace");
        case COPYENGINE_E_ALREADY_EXISTS_SYSTEM: return _td("COPYENGINE_E_ALREADY_EXISTS_SYSTEM", "Destination with system attribute exists, cannot replace");
        case COPYENGINE_E_ALREADY_EXISTS_FOLDER: return _td("COPYENGINE_E_ALREADY_EXISTS_FOLDER", "Destination folder exists, cannot replace");
        case COPYENGINE_E_STREAM_LOSS: return _td("COPYENGINE_E_STREAM_LOSS", "Secondary Stream information would be lost");
        case COPYENGINE_E_EA_LOSS: return _td("COPYENGINE_E_EA_LOSS", "Extended Attributes would be lost");
        case COPYENGINE_E_PROPERTY_LOSS: return _td("COPYENGINE_E_PROPERTY_LOSS", "Property would be lost");
        case COPYENGINE_E_PROPERTIES_LOSS: return _td("COPYENGINE_E_PROPERTIES_LOSS", "Properties would be lost");
        case COPYENGINE_E_ENCRYPTION_LOSS: return _td("COPYENGINE_E_ENCRYPTION_LOSS", "Encryption would be lost");
        case COPYENGINE_E_DISK_FULL: return _td("COPYENGINE_E_DISK_FULL", "Windows is reporting that the destination disk or device is full.");
        case COPYENGINE_E_DISK_FULL_CLEAN: return _td("COPYENGINE_E_DISK_FULL_CLEAN", "Windows is reporting that the destination disk or device is full");
        case COPYENGINE_E_EA_NOT_SUPPORTED: return _td("COPYENGINE_E_EA_NOT_SUPPORTED", "Volume does not support Extended Attributes");
        case COPYENGINE_E_CANT_REACH_SOURCE: return _td("COPYENGINE_E_CANT_REACH_SOURCE", "Can't reach source folder");
 
 
        case COPYENGINE_E_RECYCLE_FORCE_NUKE: return _td("COPYENGINE_E_RECYCLE_FORCE_NUKE", "Recycling not available (usually turned offL)");
        case COPYENGINE_E_RECYCLE_SIZE_TOO_BIG:  return _td("COPYENGINE_E_RECYCLE_SIZE_TOO_BIG", "Item is too large for the recycle-bin");
        case COPYENGINE_E_RECYCLE_PATH_TOO_LONG: return _td("COPYENGINE_E_RECYCLE_PATH_TOO_LONG", "Folder is too deep to fit in the recycle-bin");
        case COPYENGINE_E_RECYCLE_BIN_NOT_FOUND: return _td("COPYENGINE_E_RECYCLE_BIN_NOT_FOUND", "Recycle bin could not be found or is unavailable");
        case COPYENGINE_E_NEWFILE_NAME_TOO_LONG: return _td("COPYENGINE_E_NEWFILE_NAME_TOO_LONG", "Name of the new file being created is too long");
        case COPYENGINE_E_NEWFOLDER_NAME_TOO_LONG: return _td("COPYENGINE_E_NEWFOLDER_NAME_TOO_LONG", "Name of the new folder being created is too long");
        case COPYENGINE_E_DIR_NOT_EMPTY: return _td("COPYENGINE_E_DIR_NOT_EMPTY", "The directory being processed is not empty");
        case COPYENGINE_E_FAT_MAX_IN_ROOT: return _td("COPYENGINE_E_FAT_MAX_IN_ROOT", "A Fat drive can only store and rename a limited number of items on the root.");
        case COPYENGINE_E_ACCESSDENIED_READONLY: return _td("COPYENGINE_E_ACCESSDENIED_READONLY", "The item cannot be modified because it is set to readonly.");
 
        case COPYENGINE_E_REDIRECTED_TO_WEBPAGE: return _td("COPYENGINE_E_REDIRECTED_TO_WEBPAGE", "The server redirected the download request to a web page.");
        case COPYENGINE_E_SERVER_BAD_FILE_TYPE: return _td("COPYENGINE_E_SERVER_BAD_FILE_TYPE", "The server returned data with an unexpected MIME type or extension.");
 
        case COPYENGINE_E_INTERNET_ITEM_UNAVAILABLE: return _td("COPYENGINE_E_INTERNET_ITEM_UNAVAILABLE", "The item is unavailable currently due to no internet connectivity");
 
        case COPYENGINE_E_CANNOT_MOVE_FROM_RECYCLE_BIN: return _td("COPYENGINE_E_CANNOT_MOVE_FROM_RECYCLE_BIN", "The item cannot be moved out of the recycle bin, can perform other operations like restored/delete");
 
        case COPYENGINE_E_CANNOT_MOVE_SHARED_FOLDER: return _td("COPYENGINE_E_CANNOT_MOVE_SHARED_FOLDER", "The item cannot be moved from a grouped folder to another shared folder");
 
        case COPYENGINE_E_INTERNET_ITEM_STORAGE_PROVIDER_ERROR: return _td("COPYENGINE_E_INTERNET_ITEM_STORAGE_PROVIDER_ERROR", "The item is unavailable currently due to storage provider being in error state");
        case COPYENGINE_E_INTERNET_ITEM_STORAGE_PROVIDER_PAUSED: return _td("COPYENGINE_E_INTERNET_ITEM_STORAGE_PROVIDER_PAUSED", "The item is unavailable currently due to storage provider being paused");
 
        case COPYENGINE_E_REQUIRES_EDP_CONSENT: return _td("COPYENGINE_E_REQUIRES_EDP_CONSENT", "The file can only be copied if the user consents to override the EDP block");
        case COPYENGINE_E_BLOCKED_BY_EDP_POLICY: return _td("COPYENGINE_E_BLOCKED_BY_EDP_POLICY", "The file cannot be copied per EDP policy");
        case COPYENGINE_E_REQUIRES_EDP_CONSENT_FOR_REMOVABLE_DRIVE: return _td("COPYENGINE_E_REQUIRES_EDP_CONSENT_FOR_REMOVABLE_DRIVE", "The file can be copied as personal if the user consents to override the EDP block");
        case COPYENGINE_E_BLOCKED_BY_EDP_FOR_REMOVABLE_DRIVE: return _td("COPYENGINE_E_BLOCKED_BY_EDP_FOR_REMOVABLE_DRIVE", "The file can only be copied as work protected per EDP policy");
        case COPYENGINE_E_RMS_REQUIRES_EDP_CONSENT_FOR_REMOVABLE_DRIVE: return _td("COPYENGINE_E_RMS_REQUIRES_EDP_CONSENT_FOR_REMOVABLE_DRIVE", "The file can be copied as personal if the user consents to override the EDP block");
        case COPYENGINE_E_RMS_BLOCKED_BY_EDP_FOR_REMOVABLE_DRIVE: return _td("COPYENGINE_E_RMS_BLOCKED_BY_EDP_FOR_REMOVABLE_DRIVE", "The file can only be copied as work protected per EDP policy");
        }
    }
    FILETIME Win32FileTime(const Time& time)
    {
        SYSTEMTIME stUTC;
        stUTC.wYear = time.year(false);
        stUTC.wMonth = time.month(false);
        stUTC.wDay = time.monthDay(false);
        stUTC.wHour = time.hour(false);
        stUTC.wMinute = time.minute(false);
        stUTC.wSecond = time.second(false);
        stUTC.wMilliseconds = cast<WORD>(time.millisecond());
        stUTC.wDayOfWeek = 0;
        FILETIME file_time;
        SystemTimeToFileTime(&stUTC, &file_time);
        return file_time;
    }
    Time Win32FileTime(FILETIME time)
    {
        SYSTEMTIME stUTC;
        BOOL success = FileTimeToSystemTime(&time, &stUTC);
 
        Time t = Constant<Time>::NaN;
        if (success == TRUE)
        {
            try
            {
                t.setYear(cast<uint02>(stUTC.wYear), false);
                t.setMonth(cast<uint01>(stUTC.wMonth), false);
                t.setMonthDay(cast<uint01>(stUTC.wDay), false);
                t.setHour(cast<uint01>(stUTC.wHour), false);
                t.setMinute(cast<uint01>(stUTC.wMinute), false);
                t.setSecond(cast<uint01>(stUTC.wSecond), false);
                t.setMillisecond(cast<uint02>(stUTC.wMilliseconds));
 
            }
            catch (Exception&)
            {
                return t;
            }
        }
        return t;
    }
    FileCachedData WIN32CreateCached(const WIN32_FILE_ATTRIBUTE_DATA& fad)
    {
        FileCachedData cache;
        cache.file_properties(FileProperty::e_file_cache_is_valid, true);
        if (fad.dwFileAttributes == INVALID_FILE_ATTRIBUTES)
        {
            cache.file_properties(FileProperty::e_file_exists, false); 
            cache.file_properties(FileProperty::e_file_is_hidden, false);
            cache.file_properties(FileProperty::e_file_is_directory, false);
            cache.file_size = Constant<uint08>::NaN;
        }
        else
        {
            LARGE_INTEGER size;
            size.HighPart = fad.nFileSizeHigh;
            size.LowPart = fad.nFileSizeLow;
            cache.file_size = cast<uint08>(size.QuadPart);
            cache.file_properties(FileProperty::e_file_exists, true);
            cache.file_properties(FileProperty::e_file_is_directory, fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
            cache.file_properties(FileProperty::e_file_is_hidden, fad.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
            cache.accessed_time = Win32FileTime(fad.ftLastAccessTime);
            cache.modified_time = Win32FileTime(fad.ftLastWriteTime);
            cache.created_time = Win32FileTime(fad.ftCreationTime);
            //lib_assert(cache.file_size != 0 || cache.file_properties[FileProperty::e_file_is_directory], "Unexpected 0 size");
        }
        return cache;
    }
    FileCachedData WIN32CreateCached(const WIN32_FIND_DATAW& fad)
    {
        FileCachedData cache;
        cache.file_properties(FileProperty::e_file_cache_is_valid, true);
        if (fad.dwFileAttributes == INVALID_FILE_ATTRIBUTES)
        {
            cache.file_properties(FileProperty::e_file_exists, false);
            cache.file_properties(FileProperty::e_file_is_hidden, false);
            cache.file_size = Constant<uint08>::NaN;
        }
        else
        {
            LARGE_INTEGER size;
            size.HighPart = fad.nFileSizeHigh;
            size.LowPart = fad.nFileSizeLow;
            cache.file_size = cast<uint08>(size.QuadPart);
            cache.file_properties(FileProperty::e_file_exists, true);
            cache.file_properties(FileProperty::e_file_is_directory, fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
            cache.file_properties(FileProperty::e_file_is_hidden, fad.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN);
            cache.accessed_time = Win32FileTime(fad.ftLastAccessTime);
            cache.modified_time = Win32FileTime(fad.ftLastWriteTime);
            cache.created_time = Win32FileTime(fad.ftCreationTime);
            //lib_assert(cache.file_size != 0 || cache.file_properties[FileProperty::e_file_is_directory], "Unexpected 0 size");
        }
        return cache;
    }
    FileCachedData WIN32CreateCached(const File& file)
    {
        if (!file.isDrive())
        {
            WIN32_FILE_ATTRIBUTE_DATA fad;
            if (!GetFileAttributesExW(file.getAs<std::wstring>().c_str(), GetFileExInfoStandard, &fad))
                return FileCachedData(); // error condition, could call GetLastError to find out more
            return WIN32CreateCached(fad);
        }
        else
        {
            FileCachedData cache;
            cache.file_properties(FileProperty::e_file_exists, true);
            cache.file_properties(FileProperty::e_file_is_directory, true);
            cache.file_properties(FileProperty::e_file_is_hidden, false);
            return cache;
        }
    }
    class NDEVRWIN32LogView final : public IOperationsProgressDialog, public IFileOperationProgressSink
    {
    public:
        ProgressInfo* m_log;
        bool show_progress;
        String m_action;
        DWORD id;
        NDEVRWIN32LogView(ProgressInfo* info)
            : m_log(info)
            , show_progress(false)
            , id(0)     
        {}
 
        HRESULT status() const
        {
            return S_OK;
        }
 
        virtual HRESULT STDMETHODCALLTYPE StartOperations(void) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE FinishOperations(HRESULT) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PreRenameItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PostRenameItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][in] */ __RPC__in_string LPCWSTR,
            /* [in] */ HRESULT,
            /* [in] */ __RPC__in_opt IShellItem*) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PreMoveItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PostMoveItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR,
            /* [in] */ HRESULT,
            /* [in] */ __RPC__in_opt IShellItem*)
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PreCopyItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PostCopyItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR,
            /* [in] */ HRESULT,
            /* [in] */ __RPC__in_opt IShellItem*) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PreDeleteItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PostDeleteItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [in] */ HRESULT,
            /* [in] */ __RPC__in_opt IShellItem*) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PreNewItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PostNewItem(
            /* [in] */ DWORD,
            /* [in] */ __RPC__in_opt IShellItem*,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR,
            /* [string][unique][in] */ __RPC__in_opt_string LPCWSTR,
            /* [in] */ DWORD,
            /* [in] */ HRESULT,
            /* [in] */ __RPC__in_opt IShellItem*) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE UpdateProgress(
            /* [in] */ UINT iWorkTotal,
            /* [in] */ UINT iWorkSoFar) override
        {
            if (m_log) m_log->setProgress(cast<fltp04>(iWorkSoFar) / cast<fltp04>(iWorkTotal));
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE ResetTimer(void) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE PauseTimer(void) override
        {
            return status();
        }
 
        virtual HRESULT STDMETHODCALLTYPE ResumeTimer(void) override
        {
            return status();
        }
        virtual HRESULT STDMETHODCALLTYPE StartProgressDialog(HWND, OPPROGDLGF flags) override
        {
            if (m_log) m_log->setProgress(0.0f);
            show_progress = (flags & PROGDLG_NOPROGRESSBAR) == 0;
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE StopProgressDialog(void) override
        {
            if (m_log) m_log->setProgress(1.0f);
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE SetOperation(SPACTION action) override
        {
            if (m_log == nullptr)
                return status();
            switch (action)
            {
            case SPACTION_NONE: break;
            case SPACTION_MOVING: m_log->addMessage(_t("Moving File Item")); break;
            case SPACTION_COPYING: m_log->addMessage(_t("Copying File Item")); break;
            case SPACTION_RECYCLING: m_log->addMessage(_t("Recyling File Item")); break;
            case SPACTION_APPLYINGATTRIBS: m_log->addMessage(_t("Appling Attributes")); break;
            case SPACTION_DOWNLOADING: m_log->addMessage(_t("Downloading")); break;
            case SPACTION_SEARCHING_INTERNET: m_log->addMessage(_t("Searching Web")); break;
            case SPACTION_CALCULATING: m_log->addMessage(_t("Calculating")); break;
            case SPACTION_UPLOADING: m_log->addMessage(_t("Uploading")); break;
            case SPACTION_SEARCHING_FILES: m_log->addMessage(_t("Searching File Items")); break;
            case SPACTION_DELETING: m_log->addMessage(_t("Deleting")); break;
            case SPACTION_RENAMING: m_log->addMessage(_t("Renaming File Item")); break;
            case SPACTION_FORMATTING: m_log->addMessage(_t("Formatting")); break;
            case SPACTION_COPY_MOVING: m_log->addMessage(_t("Copying File Item")); break;
            }
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE SetMode(PDMODE mode) override
        {
            switch (mode)
            {
            case PDM_DEFAULT:
            case PDM_RUN:
            case PDM_PREFLIGHT:
            case PDM_UNDOING:
            case PDM_ERRORSBLOCKING:
            case PDM_INDETERMINATE:
                break;
            }
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE UpdateProgress(
              ULONGLONG /*ullPointsCurrent*/, ULONGLONG /*ullPointsTotal*/
            , ULONGLONG ullSizeCurrent, ULONGLONG ullSizeTotal
            , ULONGLONG /*ullItemsCurrent*/, ULONGLONG /*ullItemsTotal*/) override
        {
            if (m_log) m_log->setProgress(cast<fltp04>(ullSizeCurrent) / cast<fltp04>(ullSizeTotal));
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE UpdateLocations(IShellItem*, IShellItem*, IShellItem*) override
        {
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE GetMilliseconds(ULONGLONG*, ULONGLONG*) override
        {
            return status();
        }
 
        HRESULT STDMETHODCALLTYPE GetOperationStatus(PDOPSTATUS* popstatus) override
        {
            if (m_log->cancelRequested())
                *popstatus = PDOPS_CANCELLED;
            else
                *popstatus = PDOPS_RUNNING;
            return status();
        }
        HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, _COM_Outptr_ void __RPC_FAR* __RPC_FAR* ppvObject) override
        {
            if (riid == IID_IUnknown || riid == IID_IFileOperationProgressSink || riid == IID_IOperationsProgressDialog) {
                *ppvObject = this;
 
                return S_OK;
            }
 
            *ppvObject = NULL;
 
            return E_NOINTERFACE;
        };
 
        ULONG STDMETHODCALLTYPE AddRef(void) override
        {
            return status();
        }
 
        ULONG STDMETHODCALLTYPE Release(void) override
        {
            return status();
        }
 
    };
    HRESULT NDEVRWIN32EnsureInitialized()
    {
#if NDEVR_SUPPORTS_THREADING
        unsigned thread_id = NDEVR::ThreadFunctions::CurrentThreadID();
        static NDEVR::Dictionary<unsigned, bool> Thread_Dictionary;
        NDEVR::WLock lock(&Thread_Dictionary);
        if (Thread_Dictionary.hasKey(thread_id) && Thread_Dictionary.get(thread_id))
            return 0;
        Thread_Dictionary.add(thread_id, false);
#endif
        HRESULT hr = S_OK;
        hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_SPEED_OVER_MEMORY);
        if (!SUCCEEDED(hr)) return hr;
#if NDEVR_SUPPORTS_THREADING
        Thread_Dictionary.set(thread_id, true);
#endif
        return hr;
    }
 
    HRESULT NDEVRWIN32CreateFileOperation(IFileOperation** pfo, NDEVRWIN32LogView* log)
    {
        HRESULT hr = NDEVRWIN32EnsureInitialized();
        if (!SUCCEEDED(hr)) return hr;
        hr = CoCreateInstance(CLSID_FileOperation, NULL, CLSCTX_ALL, IID_PPV_ARGS(pfo));
        if (!SUCCEEDED(hr)) return hr;
        if (log)
        {
            hr = (*pfo)->Advise(log, &log->id);
            if (!SUCCEEDED(hr)) { (*pfo)->Release(); return hr; }
        }
        hr = (*pfo)->SetOperationFlags(FOF_NO_UI | FOFX_EARLYFAILURE);
        if (!SUCCEEDED(hr))
            (*pfo)->Release();
        return hr;
    }
    HRESULT NDEVRWIN32CopyOrMoveItem(PCWSTR pszSrcItem, PCWSTR pszDest, PCWSTR pszNewName, bool is_copy, NDEVRWIN32LogView* log)
    {
        IFileOperation* pfo = NULL;
        HRESULT hr = NDEVRWIN32CreateFileOperation(&pfo, log);
        if (!SUCCEEDED(hr)) return hr;
 
        IShellItem* psiFrom = NULL;
        hr = SHCreateItemFromParsingName(pszSrcItem, NULL, IID_PPV_ARGS(&psiFrom));
        if (!SUCCEEDED(hr)) { pfo->Release(); return hr; }
 
        IShellItem* psiTo = NULL;
        if (NULL != pszDest)
            hr = SHCreateItemFromParsingName(pszDest, NULL, IID_PPV_ARGS(&psiTo));
        if (!SUCCEEDED(hr)) { psiFrom->Release(); pfo->Release(); return hr; }
        if (is_copy)
            hr = pfo->CopyItem(psiFrom, psiTo, pszNewName, NULL);
        else
            hr = pfo->MoveItem(psiFrom, psiTo, pszNewName, NULL);
        if (NULL != psiTo)
            psiTo->Release();
        if (NULL != psiFrom)
            psiFrom->Release();
        if (!SUCCEEDED(hr)) { pfo->Release(); return hr; }
 
        hr = pfo->PerformOperations();
        if (!SUCCEEDED(hr)) { pfo->Release(); return hr; }
        BOOL operations_aborted;
        hr = pfo->GetAnyOperationsAborted(&operations_aborted);
        pfo->Release();
        lib_assert(!operations_aborted, "file move/save aborted?");
        return hr;
    }
 
    HRESULT NDEVRWIN32DeleteItem(PCWSTR item_to_delete, NDEVRWIN32LogView* log)
    {
        //Create Operation
        IFileOperation* pfo = NULL;
        HRESULT hr = NDEVRWIN32CreateFileOperation(&pfo, log);
        if (!SUCCEEDED(hr)) return hr;
 
        IShellItem* psiDelete = NULL;
        hr = SHCreateItemFromParsingName(item_to_delete, NULL, IID_PPV_ARGS(&psiDelete));
        if (!SUCCEEDED(hr)) { pfo->Release(); return hr; }
 
        hr = pfo->DeleteItem(psiDelete, NULL);
        if (NULL != psiDelete)
            psiDelete->Release();
        if (!SUCCEEDED(hr)) { pfo->Release(); return hr; }
 
        hr = pfo->PerformOperations();
        pfo->Release();
        return hr;
    }
    bool dirExists(const wchar* const dir_name_in)
    {
        if (dir_name_in == nullptr)
            return false;
        DWORD ftyp = GetFileAttributesW(dir_name_in);
        if (ftyp == INVALID_FILE_ATTRIBUTES)
            return false;
        if (ftyp & FILE_ATTRIBUTE_DIRECTORY)
            return true;
        return false;
    }
    bool IsPathHidden(const wchar* const dir_name_in)
    {
        if (dir_name_in == nullptr)
            return false;
        DWORD ftyp = GetFileAttributesW(dir_name_in);
        if (ftyp == INVALID_FILE_ATTRIBUTES)
            return false;
        if (ftyp & FILE_ATTRIBUTE_HIDDEN)
            return true;
        return false;
    }
#if NDEVR_SUPPORTS_MTP
    IPortableDevice* getMTPDevice(const File& file)
    {
        IPortableDevice* device = nullptr;
        uint04 start = 0;// getMax(0U, file.pathID().indexOf('>') + 1);
        uint04 end = getMin(file.pathID().size(), file.pathID().indexOf('|'));
        String id = file.pathID().substr(start, end);
        HRESULT result = MTP::ChooseDevice(id.getAs<std::wstring>().c_str(), &device);
        return device;
    }
    bool MTPCreateFile(IPortableDevice* device, const File& file_to_create)
    {
        file_to_create.resolveMTPPath();
        File parent = file_to_create.getParentDirectory();
        if (parent.resolveMTPPath())
        {
            HRESULT result;
            if (file_to_create.isDirectory())
            {
                result = MTP::CreateFolderOnDevice(device
                    , parent.pathNameID().getAs<std::wstring>().c_str()
                    , file_to_create.getPath(File::e_file_name).getAs<std::wstring>().c_str());
            }
            else
            {
                lib_assert(false, "Not yet finished");
                /*result = MTP::Cre(device
                    , parent.pathNameID().getAs<std::wstring>().c_str()
                    , file_to_create.getPath(File::e_file_name).getAs<std::wstring>().c_str());*/
            }
            return SUCCEEDED(result);
        }
        return false;
    }
    Buffer<File> getMTPChildren(IPortableDevice* device, const File& dir)
    {
        Buffer<File> children;
        if (device == nullptr)
            return children;
        PWSTR values[1024];
        DWORD count = 1024;
        Buffer<String> path_ids = dir.pathID().splitString('|', false);
        std::wstring object_id;
        if (path_ids.size() == 0)
            return children;
        if (path_ids.size() == 1)
            object_id = WPD_DEVICE_OBJECT_ID;
        else
            object_id = path_ids.last().getAs<std::wstring>();
        HRESULT result = MTP::GetChildren(device, object_id.c_str(), &count, values);
        if (SUCCEEDED(result))
        {
            PWSTR file_name;
            for (uint04 i = 0; i < cast<uint04>(count); i++)
            {
                file_name = nullptr;
                result = MTP::GetProperty(device, values[i], WPD_OBJECT_NAME, &file_name);
                GUID guid;
                result = MTP::GetProperty(device, values[i], WPD_OBJECT_CONTENT_TYPE, &guid);
                if (guid == WPD_CONTENT_TYPE_FOLDER || guid == WPD_CONTENT_TYPE_FUNCTIONAL_OBJECT)
                {
                    children.add(File(
                        String(dir) + String(file_name) + File::PathSep
                        , dir.pathID() + String(values[i]) + File::IDSep));
                }
                else
                {
                    children.add(File(
                        String(dir) + String(file_name)
                        , dir.pathID() + String(values[i])));
                }
            }
        }
        return children;
    }
#endif
}
#endif