hrynco/hrynco-kswitcher
1
0 Fork 0
Code Issues 2 Pull Requests Actions Packages Projects 1 Releases 93 Wiki Activity
Files
b5c803df875fba2f9e3e050a9963a72ecf2b6538
hrynco-kswitcher/src/files_main.cpp
T

4474 lines
184 KiB
C++
Raw Blame History

#include <windows.h>
#include <commctrl.h>
#include <windowsx.h>
#include <shellapi.h>
#include <shlobj.h>
#include <commdlg.h>
#include <algorithm>
#include <array>
#include <deque>
#include <filesystem>
#include <fstream>
#include <future>
#include <thread>
#include <iomanip>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <objbase.h>
#include "files_terminal.h"
#include "files_terminal_view.h"
#include "files_lan_ipc.h"
#include "lan_files.h"
#include "platform.h"
namespace
{
namespace fs = std::filesystem;
using ks::lan::FilesConnection;
using ks::lan::FilesPeer;
using ks::lan::Json;
using ks::lan::fileRequest;
using ks::lan::filePath;
using ks::lan::checkFileReply;
struct FileInfo { DWORD attributes; uint64_t size, modified; };
FileInfo fileInfo(const Json &row)
{
return {row.at("attributes"),row.at("size"),row.at("modified")};
}
std::optional<FileInfo> statFile(FilesConnection &host,const fs::path &path)
{
const auto reply=host.call(fileRequest("stat",path));
const auto error=reply.at("error").get<DWORD>();
if(error==ERROR_FILE_NOT_FOUND || error==ERROR_PATH_NOT_FOUND) return {};
checkFileReply(reply);
return fileInfo(reply);
}
using FileVisitor=std::function<bool(const fs::path &,const FileInfo &)>;
bool listFiles(FilesConnection &host,const fs::path &directory,const FileVisitor &visit)
{
auto page=host.call(fileRequest("list",directory));
for(;;)
{
checkFileReply(page);
for(const auto &row:page.at("entries"))
if(!visit(directory/filePath(row.at("name")),fileInfo(row))) return false;
if(!page.at("more").get<bool>()) return true;
page=host.call({{"action","listNext"}});
}
}
std::wstring fileError(const std::system_error &error)
{
wchar_t *message{};
const DWORD length=FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|
FORMAT_MESSAGE_IGNORE_INSERTS,nullptr,error.code().value(),0,reinterpret_cast<wchar_t*>(&message),0,nullptr);
std::wstring text=length?std::wstring(message,length):L"Windows error "+std::to_wstring(error.code().value());
LocalFree(message);
while(!text.empty() && (text.back()==L'\r' || text.back()==L'\n')) text.pop_back();
return text;
}
std::wstring formatSize(uint64_t bytes,size_t columns=0)
{
constexpr const wchar_t *units[]{L"B",L"KiB",L"MiB",L"GiB",L"TiB",L"PiB",L"EiB"};
constexpr const wchar_t *compact[]{L"",L"K",L"M",L"G",L"T",L"P",L"E"};
if(columns)
{
for(size_t unit=0;;++unit,bytes/=1024)
{
auto label=std::to_wstring(bytes)+compact[unit];
if(label.size()<=columns || unit==std::size(compact)-1) return label;
}
}
size_t unit=0;
double value=static_cast<double>(bytes);
while(value>=1024 && unit+1<std::size(units))
{
value/=1024;
++unit;
}
if(!unit) return std::to_wstring(bytes)+L" B";
std::wostringstream label;
label<<std::fixed<<std::setprecision(2)<<value<<L' '<<units[unit];
return label.str();
}
constexpr wchar_t folderPipePrefix[]=L"\\\\.\\pipe\\KSwitcher.Files.Folder.";
struct Handle
{
HANDLE value;
~Handle(){if(value && value!=INVALID_HANDLE_VALUE) CloseHandle(value);}
};
struct FolderEntryMetadata
{
DWORD attributes;
ULONGLONG size;
};
DWORD enableBackupPrivilege()
{
Handle token{};
if(!OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY,&token.value))
return GetLastError();
TOKEN_PRIVILEGES privileges{};
privileges.PrivilegeCount=1;
privileges.Privileges[0].Attributes=SE_PRIVILEGE_ENABLED;
if(!LookupPrivilegeValueW(nullptr,SE_BACKUP_NAME,&privileges.Privileges[0].Luid))
return GetLastError();
AdjustTokenPrivileges(token.value,FALSE,&privileges,0,nullptr,nullptr);
return GetLastError();
}
DWORD listElevatedFolder(const fs::path &directory, const std::wstring &pipeName)
{
if(!IsUserAnAdmin() || !directory.is_absolute() || !pipeName.starts_with(folderPipePrefix))
return ERROR_ACCESS_DENIED;
Handle pipe{CreateFileW(pipeName.c_str(),GENERIC_READ|GENERIC_WRITE,0,nullptr,OPEN_EXISTING,
SECURITY_SQOS_PRESENT|SECURITY_IDENTIFICATION,nullptr)};
if(pipe.value==INVALID_HANDLE_VALUE) return GetLastError();
// Keep the connection open until the parent verifies the helper's process ID.
char ready{};
DWORD received{};
if(!ReadFile(pipe.value,&ready,sizeof(ready),&received,nullptr)) return GetLastError();
if(received!=sizeof(ready) || ready!=1) return ERROR_INVALID_DATA;
if(const auto error=enableBackupPrivilege();error!=ERROR_SUCCESS)
return error;
Handle folder{CreateFileW(directory.c_str(),FILE_LIST_DIRECTORY,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,nullptr,OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,nullptr)};
if(folder.value==INVALID_HANDLE_VALUE) return GetLastError();
alignas(FILE_ID_BOTH_DIR_INFO) unsigned char buffer[16384];
while(GetFileInformationByHandleEx(folder.value,FileIdBothDirectoryInfo,buffer,sizeof(buffer)))
{
auto entry=reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(buffer);
for(;;)
{
std::wstring_view name(entry->FileName,entry->FileNameLength/sizeof(wchar_t));
if(name!=L"." && name!=L"..")
{
const FolderEntryMetadata metadata{entry->FileAttributes,
static_cast<ULONGLONG>(entry->EndOfFile.QuadPart)};
std::wstring row(sizeof(metadata)/sizeof(wchar_t),L'\0');
memcpy(row.data(),&metadata,sizeof(metadata));
row.append(name);
DWORD written{};
if(!WriteFile(pipe.value,row.data(),static_cast<DWORD>(row.size()*sizeof(wchar_t)),&written,nullptr))
return GetLastError();
}
if(!entry->NextEntryOffset) break;
entry=reinterpret_cast<const FILE_ID_BOTH_DIR_INFO*>(
reinterpret_cast<const unsigned char*>(entry)+entry->NextEntryOffset);
}
}
const auto error=GetLastError();
return error==ERROR_NO_MORE_FILES?ERROR_SUCCESS:error;
}
DWORD requestElevatedFolder(HWND owner,const fs::path &directory,
std::vector<fs::path> &folders,std::vector<fs::path> &files,
std::map<fs::path,FolderEntryMetadata> &metadata)
{
GUID id{};
wchar_t token[40]{}, executable[32768]{};
auto length=GetModuleFileNameW(nullptr,executable,static_cast<DWORD>(std::size(executable)));
if(!length || length>=std::size(executable) || FAILED(CoCreateGuid(&id)) ||
!StringFromGUID2(id,token,static_cast<int>(std::size(token)))) return ERROR_GEN_FAILURE;
auto name=std::wstring(folderPipePrefix)+token;
Handle pipe{CreateNamedPipeW(name.c_str(),PIPE_ACCESS_DUPLEX|FILE_FLAG_FIRST_PIPE_INSTANCE,
PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_NOWAIT|PIPE_REJECT_REMOTE_CLIENTS,1,0,4096,0,nullptr)};
if(pipe.value==INVALID_HANDLE_VALUE) return GetLastError();
auto parameters=L"--list-folder \""+(directory/L".").wstring()+L"\" \""+name+L"\"";
SHELLEXECUTEINFOW launch{};
launch.cbSize=sizeof(launch);
launch.fMask=SEE_MASK_NOCLOSEPROCESS|SEE_MASK_NOASYNC;
launch.hwnd=owner;
launch.lpVerb=L"runas";
launch.lpFile=executable;
launch.lpParameters=parameters.c_str();
launch.nShow=SW_HIDE;
if(!ShellExecuteExW(&launch)) return GetLastError();
Handle process{launch.hProcess};
bool connected=false;
bool finished=false;
auto deadline=GetTickCount64()+10000;
while(GetTickCount64()<deadline)
{
if(!connected)
{
connected=ConnectNamedPipe(pipe.value,nullptr) || GetLastError()==ERROR_PIPE_CONNECTED;
if(connected)
{
ULONG client{};
if(!GetNamedPipeClientProcessId(pipe.value,&client) || client!=GetProcessId(process.value))
return ERROR_ACCESS_DENIED;
const char ready=1;
DWORD written{};
if(!WriteFile(pipe.value,&ready,sizeof(ready),&written,nullptr)) return GetLastError();
if(written!=sizeof(ready)) return ERROR_WRITE_FAULT;
}
}
if(connected)
{
wchar_t row[512]{};
DWORD bytes{};
if(ReadFile(pipe.value,row,sizeof(row),&bytes,nullptr))
{
FolderEntryMetadata entry{};
if(bytes<=sizeof(entry) || bytes%sizeof(wchar_t)) return ERROR_INVALID_DATA;
memcpy(&entry,row,sizeof(entry));
const std::wstring_view name(row+sizeof(entry)/sizeof(wchar_t),(bytes-sizeof(entry))/sizeof(wchar_t));
if(name.find(L'\0')!=name.npos) return ERROR_INVALID_DATA;
const fs::path child(name);
if(child!=child.filename() || child==L"." || child==L"..") return ERROR_INVALID_DATA;
const auto path=directory/child;
(entry.attributes&FILE_ATTRIBUTE_DIRECTORY?folders:files).push_back(path);
metadata.emplace(path,entry);
continue;
}
}
if(finished)
{
DWORD result{};
if(!GetExitCodeProcess(process.value,&result)) return GetLastError();
return !connected && result==ERROR_SUCCESS ? ERROR_PIPE_NOT_CONNECTED : result;
}
finished=WaitForSingleObject(process.value,20)==WAIT_OBJECT_0;
}
return ERROR_TIMEOUT;
}
struct Panel
{
HWND path{}, list{}, heading{};
fs::path directory;
std::optional<FilesPeer> peer;
struct DirectoryWatch
{
HANDLE handle=INVALID_HANDLE_VALUE;
~DirectoryWatch() { reset(); }
void reset()
{
if(handle!=INVALID_HANDLE_VALUE) FindCloseChangeNotification(handle);
handle=INVALID_HANDLE_VALUE;
}
void start(const fs::path &path)
{
reset();
handle=FindFirstChangeNotificationW(path.c_str(),FALSE,
FILE_NOTIFY_CHANGE_FILE_NAME|FILE_NOTIFY_CHANGE_DIR_NAME|
FILE_NOTIFY_CHANGE_ATTRIBUTES|FILE_NOTIFY_CHANGE_SIZE|FILE_NOTIFY_CHANGE_LAST_WRITE);
}
} watch;
std::map<fs::path,uint64_t> timestamps;
std::vector<fs::path> rows;
std::vector<std::wstring> sizes;
std::vector<bool> dimmed;
std::vector<bool> marked;
std::set<fs::path> transferResults;
size_t fileExtensionLength{}, folderExtensionLength{};
bool wide{};
};
Panel panels[2];
FilesTerminal terminal;
std::ofstream terminalTrace;
unsigned terminalTraceLines{};
bool traceTerminalOutput{};
void traceTerminal(const char *event,int a=0,int b=0,int c=0,int d=0,int e=0)
{
if(!terminalTrace.is_open() || terminalTraceLines>=4096) return;
++terminalTraceLines;
terminalTrace<<GetTickCount64()<<' '<<event<<' '<<a<<' '<<b<<' '<<c<<' '<<d<<' '<<e<<std::endl;
}
FilesTerminalView terminalView;
COORD terminalSize{80,25};
bool terminalViewRequested{};
HWND terminalInput{},terminalOutput{},terminalPrompt{};
constexpr UINT_PTR terminalTimer=2;
constexpr UINT_PTR directoryWatchTimer=4;
bool terminalVisible{};
std::deque<int> terminalCommandPanels;
std::wstring terminalDirectory;
int terminalRows{};
struct CommandEntry { std::wstring date, command; };
std::vector<CommandEntry> terminalHistory;
size_t terminalHistoryIndex{};
constexpr UINT_PTR transferHighlightTimer=1;
unsigned transferHighlightPhase{};
HWND status{}, commands[6]{};
int active{}, split{};
bool dragging{};
bool rememberElevationApproval{};
HWND picker{}, pickerFrame{}, menuBar{};
HWND menuItems[5]{};
constexpr std::wstring_view menuAccessKeys=L"LFCOR";
std::vector<size_t> commandAccessPositions;
int menuIndex{};
bool commandPicker{};
constexpr int defaultSizeWidth=6, defaultFontPoints=110;
constexpr bool defaultWide=false, defaultAlignExtensions=true, defaultShowDetails=true, defaultAlignFolders=false;
constexpr DWORD defaultStatusFields=15;
int sizeWidth=defaultSizeWidth;
bool alignExtensions=defaultAlignExtensions, showDetails=defaultShowDetails;
bool alignFolders=defaultAlignFolders;
DWORD statusFields=defaultStatusFields;
std::vector<fs::path> drivePaths;
int driveHover=-1;
std::array<LONG,3> driveColumnStarts{};
HWND drivePeerService{};
bool drivePeerReplyReceived{};
std::wstring drivePeerLookupError;
std::vector<FilesPeer> drivePeers;
struct DriveQuery
{
FilesPeer peer;
std::future<Json> pending;
Json drives=Json::array();
std::wstring error;
};
struct DriveChoice { FilesPeer peer; fs::path path; };
std::vector<DriveQuery> driveQueries;
std::map<LRESULT,DriveChoice> remoteDriveRows;
constexpr UINT_PTR driveQueryTimer=3;
bool refreshDriveAddresses{};
ULONGLONG driveOpened{};
int drivePickerWidth{};
int pickerPanel{};
std::wstring panelSearchPrefix;
HWND panelSearchPopup{};
enum Color { PanelBlue, Text, Frame, Dialog, Selection, Footer, PanelCursor, ColorCount };
constexpr std::array<COLORREF,ColorCount> defaultColors{RGB(0,0,128), RGB(230,255,255), RGB(0,255,255),
RGB(0,128,128), RGB(0,0,0), RGB(0,128,128), RGB(0,128,128)};
auto colors=defaultColors;
constexpr auto schemeKey = L"Software\\KSwitcher\\Files";
constexpr auto placementPreference = L"WindowPlacement";
bool restorePlacement(HWND window)
{
WINDOWPLACEMENT placement{};
DWORD size=sizeof(placement);
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,placementPreference,RRF_RT_REG_BINARY,
nullptr,&placement,&size)!=ERROR_SUCCESS || size!=sizeof(placement) ||
placement.length!=sizeof(placement)) return false;
const auto &rect=placement.rcNormalPosition;
if(static_cast<long long>(rect.right)-rect.left<540 ||
static_cast<long long>(rect.bottom)-rect.top<220) return false;
if(!MonitorFromRect(&rect,MONITOR_DEFAULTTONULL)) return false;
placement.flags=0;
placement.showCmd=placement.showCmd==SW_SHOWMAXIMIZED?SW_SHOWMAXIMIZED:SW_SHOWNORMAL;
if(!SetWindowPlacement(window,&placement)) return false;
ShowWindow(window,static_cast<int>(placement.showCmd));
return true;
}
void savePlacement(HWND window)
{
WINDOWPLACEMENT placement{};
placement.length=sizeof(placement);
if(!GetWindowPlacement(window,&placement)) return;
const bool maximized=IsZoomed(window) ||
(IsIconic(window) && (placement.flags&WPF_RESTORETOMAXIMIZED));
placement.showCmd=maximized?SW_SHOWMAXIMIZED:SW_SHOWNORMAL;
placement.flags=0;
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,placementPreference,REG_BINARY,
&placement,sizeof(placement));
}
void chooseDrive(int index, bool fromMenu = false);
void openMenu(HWND window, int index);
void showFileDetails(const Panel &panel);
void editOptions(HWND owner);
void showFolderShortcuts(Panel &panel,int digit,bool all=false);
void layout(HWND window);
DWORD preference(const wchar_t *name, DWORD fallback)
{
DWORD value{}, size=sizeof(value);
return RegGetValueW(HKEY_CURRENT_USER,schemeKey,name,RRF_RT_REG_DWORD,nullptr,&value,&size)
== ERROR_SUCCESS ? value : fallback;
}
const UINT filesPreferencesChanged=RegisterWindowMessageW(L"KSwitcher.Files.PreferencesChanged");
void notifyFilesPreferences(HWND source)
{
SendNotifyMessageW(HWND_BROADCAST,filesPreferencesChanged,reinterpret_cast<WPARAM>(source),0);
}
void savePreference(const wchar_t *name, DWORD value)
{
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,name,REG_DWORD,&value,sizeof(value));
}
#include "files_styles.inl"
void setStatus(const std::wstring &message);
void refreshCommandHistory();
#include "files_command_history.inl"
constexpr const wchar_t *panelPathKeys[]{L"LeftPath",L"RightPath"};
constexpr const wchar_t *panelCursorKeys[]{L"LeftCursor",L"RightCursor"};
fs::path savedPanelPath(const wchar_t *key)
{
DWORD size{};
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,key,RRF_RT_REG_SZ,
nullptr,nullptr,&size)!=ERROR_SUCCESS || size<sizeof(wchar_t)) return {};
std::wstring path(size/sizeof(wchar_t),L'\0');
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,key,RRF_RT_REG_SZ,
nullptr,path.data(),&size)!=ERROR_SUCCESS) return {};
path.resize(wcslen(path.c_str()));
return path;
}
void setMode(int index, bool wide)
{
panels[index].wide=wide;
savePreference(index ? L"RightWide" : L"LeftWide",wide);
notifyFilesPreferences(GetParent(panels[index].list));
layout(GetParent(panels[index].list));
InvalidateRect(panels[index].list,nullptr,TRUE);
showFileDetails(panels[active]);
}
HFONT mono{};
LOGFONTW displayFont{};
int fontPoints=110;
int textHeight=20, cellWidth=9;
constexpr UINT refreshProgressLayout=WM_APP+1;
BOOL CALLBACK updateDialogFont(HWND window,LPARAM parameter)
{
const auto old=reinterpret_cast<HFONT>(parameter);
if(reinterpret_cast<HFONT>(SendMessageW(window,WM_GETFONT,0,0))==old)
SendMessageW(window,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
return TRUE;
}
HBRUSH blue{}, teal{}, terminalBackground{};
void layout(HWND window);
LOGFONTW defaultFilesFont()
{
LOGFONTW font{};
font.lfWeight=FW_NORMAL;
font.lfCharSet=DEFAULT_CHARSET;
font.lfQuality=CLEARTYPE_QUALITY;
wcscpy_s(font.lfFaceName,L"Consolas");
return font;
}
std::array<HFONT,4> fileStyleFonts{};
bool applyFont(HWND owner, LOGFONTW font, int points)
{
const auto dpi=GetDpiForWindow(owner);
font.lfHeight=-MulDiv(points,dpi,720);
font.lfWidth=0;
auto next=CreateFontIndirectW(&font);
if(!next) return false;
auto dc=GetDC(owner);
if(!dc){DeleteObject(next);return false;}
auto previous=SelectObject(dc,next);
TEXTMETRICW metrics{};
GetTextMetricsW(dc,&metrics);
SelectObject(dc,previous);
ReleaseDC(owner,dc);
textHeight=std::max(static_cast<LONG>(MulDiv(16,dpi,96)),metrics.tmHeight+MulDiv(6,dpi,96));
cellWidth=std::max(1L,metrics.tmAveCharWidth);
auto old=mono;
mono=next;
for(unsigned i=1;i<fileStyleFonts.size();++i)
{
if(fileStyleFonts[i]) DeleteObject(fileStyleFonts[i]);
auto decorated=font;
decorated.lfUnderline=(i&1)!=0;
decorated.lfStrikeOut=(i&2)!=0;
fileStyleFonts[i]=CreateFontIndirectW(&decorated);
}
displayFont=font;
fontPoints=points;
terminalView.setFont(displayFont,fontPoints);
for(auto &panel:panels)
{
if(panel.path) SendMessageW(panel.path,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
if(panel.list) SendMessageW(panel.list,LB_SETITEMHEIGHT,0,textHeight);
}
if(picker) SendMessageW(picker,LB_SETITEMHEIGHT,0,textHeight);
if(status) SendMessageW(status,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
for(const auto control:{terminalInput,terminalOutput,terminalPrompt})
if(control) SendMessageW(control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
if(old)
{
EnumThreadWindows(GetCurrentThreadId(),[](HWND window,LPARAM parameter)->BOOL
{
EnumChildWindows(window,updateDialogFont,parameter);
return TRUE;
},reinterpret_cast<LPARAM>(old));
DeleteObject(old);
}
return true;
}
bool chooseDisplayFont(HWND owner,LOGFONTW &font,int &points)
{
CHOOSEFONTW dialog{};
dialog.lStructSize=sizeof(dialog);
dialog.hwndOwner=owner;
dialog.lpLogFont=&font;
dialog.iPointSize=points;
dialog.Flags=CF_SCREENFONTS|CF_INITTOLOGFONTSTRUCT|CF_LIMITSIZE;
dialog.nSizeMin=8;
dialog.nSizeMax=24;
if(!ChooseFontW(&dialog)) return false;
points=dialog.iPointSize;
return true;
}
void refreshColors()
{
if (blue) DeleteObject(blue);
if (teal) DeleteObject(teal);
blue = CreateSolidBrush(colors[PanelBlue]);
teal = CreateSolidBrush(colors[Dialog]);
}
void loadColors()
{
for (DWORD i=0; i<ColorCount; ++i)
{
auto name = std::to_wstring(i);
DWORD value{}, size=sizeof(value);
if (RegGetValueW(HKEY_CURRENT_USER, schemeKey, name.c_str(), RRF_RT_REG_DWORD,
nullptr, &value, &size)==ERROR_SUCCESS && value<=0xffffff)
colors[i]=value;
}
refreshColors();
}
bool choosePanelColor(HWND owner,COLORREF &color,COLORREF *custom)
{
CHOOSECOLORW dialog{};
dialog.lStructSize=sizeof(dialog);
dialog.hwndOwner=owner;
dialog.rgbResult=color;
dialog.lpCustColors=custom;
dialog.Flags=CC_RGBINIT | CC_FULLOPEN;
if(!ChooseColorW(&dialog)) return false;
color=dialog.rgbResult;
return true;
}
void paintText(HDC dc, RECT rect, const wchar_t *text, COLORREF foreground, COLORREF background, bool right=false,HFONT font=nullptr)
{
SetTextColor(dc, foreground);
SetBkColor(dc, background);
SelectObject(dc, font?font:mono);
auto alignment=SetTextAlign(dc,right?TA_RIGHT:TA_LEFT);
ExtTextOutW(dc,right?rect.right-5:rect.left+5,rect.top+3,ETO_OPAQUE|ETO_CLIPPED,&rect,text,lstrlenW(text),nullptr);
SetTextAlign(dc,alignment);
}
void paintMenuLabel(HDC dc,RECT rect,const std::wstring &text,size_t access,COLORREF foreground,COLORREF background)
{
paintText(dc,rect,text.c_str(),foreground,background);
if(access>=text.size()) return;
SIZE prefix{};
GetTextExtentPoint32W(dc,text.c_str(),static_cast<int>(access),&prefix);
const auto mode=SetBkMode(dc,TRANSPARENT);
SetTextColor(dc,RGB(255,255,0));
ExtTextOutW(dc,rect.left+5+prefix.cx,rect.top+3,ETO_CLIPPED,&rect,text.c_str()+access,1,nullptr);
SetBkMode(dc,mode);
}
struct DialogFramePadding
{
DWORD outer,inner,rowText{};
bool operator==(const DialogFramePadding &) const=default;
};
// Delete at 96 DPI: outer line at x=8, inner line at x=10, content at x=25.
constexpr DialogFramePadding defaultDialogFramePadding{8,14};
constexpr DWORD maxDialogFramePadding=24;
constexpr DWORD maxDialogRowTextPadding=4;
constexpr wchar_t dialogFrameOuterKey[]=L"DialogFrameOuterPadding";
constexpr wchar_t dialogFrameInnerKey[]=L"DialogFrameInnerPadding";
constexpr wchar_t dialogRowTextKey[]=L"DialogRowTextPadding";
auto dialogFramePadding=defaultDialogFramePadding;
struct DialogFrameMetrics
{
int outer,gap,inner;
int innerLine() const {return outer+gap;}
int content() const {return innerLine()+1+inner;}
};
DialogFrameMetrics dialogFrameMetrics(UINT dpi,DialogFramePadding padding=dialogFramePadding)
{
return {MulDiv(padding.outer,dpi,96),std::max(2,MulDiv(2,dpi,96)),MulDiv(padding.inner,dpi,96)};
}
void paintDialogCaption(HDC dc,RECT row,const wchar_t *caption,HBRUSH surface,COLORREF ink,HFONT font)
{
const int saved=SaveDC(dc);
SelectObject(dc,font);
SIZE extent{};
GetTextExtentPoint32W(dc,caption,lstrlenW(caption),&extent);
TEXTMETRICW metrics{};
GetTextMetricsW(dc,&metrics);
const LONG width=std::min(row.right-row.left,extent.cx+2*metrics.tmAveCharWidth);
row.left+=(row.right-row.left-width)/2;
row.right=row.left+width;
FillRect(dc,&row,surface);
SetBkMode(dc,TRANSPARENT);
SetTextColor(dc,ink);
DrawTextW(dc,caption,-1,&row,DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS|DT_NOPREFIX);
if(saved) RestoreDC(dc,saved);
}
RECT paintDialogFrame(HDC dc,RECT bounds,DialogFrameMetrics metrics,HBRUSH surface,HBRUSH border)
{
FillRect(dc,&bounds,surface);
InflateRect(&bounds,-metrics.outer,-metrics.outer);
FrameRect(dc,&bounds,border);
InflateRect(&bounds,-metrics.gap,-metrics.gap);
FrameRect(dc,&bounds,border);
return bounds;
}
void paintDialogFrameCaptions(HDC dc,RECT client,RECT frame,const wchar_t *title,
HBRUSH surface,COLORREF ink,HFONT font,const wchar_t *hints=nullptr)
{
const auto previous=SelectObject(dc,font);
TEXTMETRICW text{};
GetTextMetricsW(dc,&text);
SelectObject(dc,previous);
const auto top=std::max(client.top,frame.top-text.tmHeight/2);
if(title) paintDialogCaption(dc,{frame.left,top,frame.right,top+text.tmHeight},title,surface,ink,font);
const auto bottom=std::min(client.bottom,frame.bottom+(text.tmHeight+1)/2);
if(hints) paintDialogCaption(dc,{frame.left,bottom-text.tmHeight,frame.right,bottom},hints,surface,ink,font);
}
int dialogListInset(DialogFrameMetrics metrics,int fontHeight)
{
return std::max(metrics.content(),metrics.innerLine()+(fontHeight+1)/2);
}
int dialogRowTextInset(int characterWidth,DialogFramePadding padding=dialogFramePadding)
{
return characterWidth*static_cast<int>(padding.rowText);
}
void paintDialogListRow(HDC dc,RECT bounds,std::wstring_view label,HFONT font,
COLORREF foreground,COLORREF background,int inset,UINT ellipsis=DT_PATH_ELLIPSIS)
{
const auto saved=SaveDC(dc);
SetBkColor(dc,background);
ExtTextOutW(dc,0,0,ETO_OPAQUE,&bounds,nullptr,0,nullptr);
SelectObject(dc,font);
SetTextColor(dc,foreground);
SetBkMode(dc,TRANSPARENT);
InflateRect(&bounds,-inset,0);
if(bounds.right>bounds.left)
DrawTextW(dc,label.data(),static_cast<int>(label.size()),&bounds,
DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX|ellipsis);
if(saved) RestoreDC(dc,saved);
}
void showMenu(bool show);
void hidePicker()
{
if (!picker || !IsWindowVisible(picker)) return;
KillTimer(GetParent(picker),driveQueryTimer);
driveQueries.clear();
ShowWindow(picker,SW_HIDE);
ShowWindow(pickerFrame,SW_HIDE);
InvalidateRect(GetParent(picker),nullptr,FALSE);
SetFocus(panels[commandPicker ? active : pickerPanel].list);
if (IsWindowVisible(menuBar)) showMenu(true);
}
void selectDrive();
void showMenu(bool show)
{
if (show) SetWindowPos(menuBar,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
for (auto item : menuItems)
{
if (show) SetWindowPos(item,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_SHOWWINDOW);
else ShowWindow(item,SW_HIDE);
if (show) InvalidateRect(item,nullptr,FALSE);
}
if (!show) ShowWindow(menuBar,SW_HIDE);
RedrawWindow(GetParent(menuBar),nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
}
LRESULT scrollList(HWND list, UINT message, WPARAM wp, LPARAM lp)
{
if (message == WM_MOUSEWHEEL)
{
int delta = GET_WHEEL_DELTA_WPARAM(wp);
int top = static_cast<int>(SendMessageW(list, LB_GETTOPINDEX, 0, 0));
int count = static_cast<int>(SendMessageW(list, LB_GETCOUNT, 0, 0));
RECT rect{};
GetClientRect(list, &rect);
int rowHeight = static_cast<int>(SendMessageW(list, LB_GETITEMHEIGHT, 0, 0));
int visible = std::max(1, static_cast<int>(rect.bottom) / std::max(1, rowHeight));
SendMessageW(list, LB_SETTOPINDEX,
std::clamp(top - (delta / WHEEL_DELTA) * 3, 0, std::max(0, count - visible)), 0);
return 0;
}
return DefSubclassProc(list, message, wp, lp);
}
void paintScrollPosition(HWND parent, HDC dc, HWND list, COLORREF background)
{
RECT track{};
GetWindowRect(list, &track);
MapWindowPoints(nullptr, parent, reinterpret_cast<POINT *>(&track), 2);
track.left = track.right;
track.right += 5;
SetDCBrushColor(dc, background);
FillRect(dc, &track, static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
int count = static_cast<int>(SendMessageW(list, LB_GETCOUNT, 0, 0));
int rowHeight = static_cast<int>(SendMessageW(list, LB_GETITEMHEIGHT, 0, 0));
int height = track.bottom - track.top;
int visible = std::max(1, height / std::max(1, rowHeight));
if (height <= 0 || count <= visible) return;
int thumb = std::min(height, std::max(5, MulDiv(height, visible, count)));
int top = static_cast<int>(SendMessageW(list, LB_GETTOPINDEX, 0, 0));
track.top += MulDiv(std::clamp(top, 0, count - visible), height - thumb, count - visible);
track.bottom = track.top + thumb;
SetDCBrushColor(dc, colors[Frame]);
FillRect(dc, &track, static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
}
void placePanelSearch(HWND window)
{
RECT panel{};
GetWindowRect(panels[active].list,&panel);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT *>(&panel),2);
const auto frame=dialogFrameMetrics(GetDpiForWindow(window));
const int width=std::min(static_cast<int>(panel.right-panel.left),24*cellWidth+2*frame.content());
const int height=textHeight+2*frame.content();
SetWindowPos(panelSearchPopup,HWND_TOP,(panel.left+panel.right-width)/2,
std::max(panel.top,panel.bottom+textHeight-height),width,height,SWP_NOACTIVATE);
}
void closePanelSearch()
{
panelSearchPrefix.clear();
if(IsWindowVisible(panelSearchPopup)) ShowWindow(panelSearchPopup,SW_HIDE);
}
void layout(HWND window)
{
RECT rect{};
GetClientRect(window, &rect);
int width = rect.right, height = rect.bottom;
const int inputTop=height-2*textHeight;
const int terminalBottom=std::max(4,inputTop);
const int detailsHeight=terminalVisible?0:textHeight+12;
const int terminalTop=terminalVisible?4:std::max(4,terminalBottom-
std::min(terminalRows,std::max(0,(terminalBottom-detailsHeight)/textHeight-4))*textHeight);
const int panelBottom=terminalTop-detailsHeight;
const bool showOutput=terminalTop<terminalBottom;
traceTerminal("layout",terminalRows,terminalTop,terminalBottom,showOutput,terminalVisible);
int middle = std::clamp(split ? split : width / 2, 120, std::max(120, width - 120));
auto place=[](HWND control, int x, int y, int width, int height)
{
if(control) SetWindowPos(control,nullptr,x,y,width,height,
SWP_NOZORDER|SWP_NOACTIVATE|SWP_NOCOPYBITS|SWP_NOREDRAW);
};
for (int i = 0; i < 2; ++i)
{
int x = i ? middle + 2 : 0;
int end = i ? width : middle - 2;
place(panels[i].path, x + 5, 4, std::max(0, end - x - 10), textHeight);
int headingHeight=panels[i].wide?textHeight:0;
place(panels[i].heading,x+5,textHeight+10,std::max(0,end-x-13),headingHeight);
ShowWindow(panels[i].heading,!terminalVisible && panels[i].wide?SW_SHOWNA:SW_HIDE);
place(panels[i].list, x + 5, textHeight+10+headingHeight, std::max(0, end - x - 13),
std::max(0, panelBottom-textHeight-10-headingHeight));
}
place(menuBar,0,0,width,textHeight+4);
const int menuEdges[]{0,7,15,27,38,46};
for(int i=0;i<5;++i)
place(menuItems[i],4+menuEdges[i]*cellWidth,0,(menuEdges[i+1]-menuEdges[i])*cellWidth,textHeight+4);
const int detailsLeft=active?middle+2:0;
const int detailsRight=active?width:middle-2;
place(status,detailsLeft+8,panelBottom+4,std::max(0,detailsRight-detailsLeft-16),textHeight);
const auto &current=panels[active];
const auto prompt=(current.peer?L"[Remote panel]":current.directory.wstring()+L">");
SetWindowTextW(terminalPrompt,prompt.c_str());
SIZE promptExtent{static_cast<LONG>(prompt.size())*cellWidth,0};
if(const auto dc=GetDC(window))
{
const auto previous=SelectObject(dc,mono);
GetTextExtentPoint32W(dc,prompt.c_str(),static_cast<int>(prompt.size()),&promptExtent);
SelectObject(dc,previous);
ReleaseDC(window,dc);
}
const int promptWidth=std::min(width/2,static_cast<int>(promptExtent.cx));
place(terminalPrompt,4,inputTop,promptWidth,textHeight);
place(terminalInput,4+promptWidth,inputTop,std::max(0,width-8-promptWidth),textHeight);
// Keep the WebView in place while the panels reveal more or less of it.
place(terminalOutput,4,4,std::max(0,width-8),terminalBottom-4);
if(showOutput)
{
const auto region=CreateRectRgn(0,terminalTop-4,std::max(0,width-8),terminalBottom-4);
if(region && !SetWindowRgn(terminalOutput,region,FALSE)) DeleteObject(region);
}
ShowWindow(terminalOutput,showOutput?SW_SHOWNA:SW_HIDE);
ShowWindow(status,terminalVisible?SW_HIDE:SW_SHOWNA);
terminalView.layout(terminalOutput,showOutput,terminalBottom-4);
for (int i = 0; i < static_cast<int>(std::size(commands)); ++i)
{
const int count=static_cast<int>(std::size(commands));
place(commands[i],i*width/count,height-textHeight,(i+1)*width/count-i*width/count,textHeight);
}
if(IsWindowVisible(panelSearchPopup)) placePanelSearch(window);
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ERASE|RDW_ALLCHILDREN);
}
void setStatus(const std::wstring &message) { SetWindowTextW(status, message.c_str()); }
void showTerminal(HWND owner,bool show)
{
terminalVisible=show;
for(const auto &panel:panels)
{
ShowWindow(panel.path,show?SW_HIDE:SW_SHOWNA);
ShowWindow(panel.list,show?SW_HIDE:SW_SHOWNA);
}
layout(owner);
SetFocus(terminalInput);
}
void open(Panel &panel,const fs::path &directory,bool offerElevation);
void activatePanel(int index)
{
const auto previous=active;
active=index;
showFileDetails(panels[index]);
if(previous==active) return;
for(const auto &panel:panels)
{
InvalidateRect(panel.path,nullptr,FALSE);
InvalidateRect(panel.list,nullptr,FALSE);
}
layout(GetParent(panels[index].list));
}
std::wstring terminalInputText()
{
std::wstring value(GetWindowTextLengthW(terminalInput)+1,L'\0');
value.resize(GetWindowTextW(terminalInput,value.data(),static_cast<int>(value.size())));
return value;
}
void copyTerminalInput(HWND owner)
{
const auto value=terminalInputText();
if(value.empty()) return;
try { ks::writeClipboard(owner,ks::textClip(value)); }
catch(const std::exception &) { setStatus(L"Could not copy the command line."); }
}
LRESULT currentPanelRow(const Panel &panel)
{
const auto row=SendMessageW(panel.list,LB_GETCURSEL,0,0);
return row>=0 && static_cast<size_t>(row)<panel.rows.size()?row:LB_ERR;
}
std::wstring powerShellPath(const fs::path &path)
{
std::wstring quoted=L"'";
for(const auto character:path.native())
{
// PowerShell recognizes typographic apostrophes as quote delimiters too.
if(character==L'\'' || character==L'\u2018' || character==L'\u2019') quoted+=character;
quoted+=character;
}
return quoted+L"'";
}
void insertCurrentPanelPath()
{
const auto &panel=panels[active];
const auto row=currentPanelRow(panel);
if(row==LB_ERR) return;
const auto &path=panel.rows[row].native();
std::wstring quoted;
if(path.find(L' ')!=std::wstring::npos)
{
quoted=L"\"";
for(const auto character:path)
{
if(character==L'`' || character==L'$' || character==L'"' ||
character==L'\u201c' || character==L'\u201d') quoted+=L'`';
quoted+=character;
}
quoted+=L'"';
}
SetFocus(terminalInput);
SendMessageW(terminalInput,EM_REPLACESEL,TRUE,
reinterpret_cast<LPARAM>(quoted.empty()?path.c_str():quoted.c_str()));
}
bool startTerminal(HWND owner)
{
if(terminal.alive()) return true;
if(!terminalViewRequested)
{
terminalViewRequested=terminalView.create(terminalOutput,[owner](const std::wstring &message)
{
if(message==L"ready")
{
terminalView.setFont(displayFont,fontPoints);
if(terminalTrace.is_open()) terminalView.enableTrace(traceTerminalOutput);
}
else if(traceTerminalOutput && terminalTrace.is_open() && message.starts_with(L"output:"))
terminalTrace<<"output "<<ks::utf8(message.substr(7))<<std::endl;
else if(terminalTrace.is_open() && message.starts_with(L"trace:"))
{
int phase{},height{},rows{},viewport{},base{},offset{};
if(swscanf_s(message.c_str()+6,L"%d,%d,%d,%d,%d,%d",
&phase,&height,&rows,&viewport,&base,&offset)==6 && phase>=0 && phase<=3)
{
const char *events[]{"web-before-fit","web-after-fit","web-anchor","web-scroll"};
traceTerminal(events[phase],height,rows,viewport,base,offset);
}
}
else if(message.starts_with(L"directory:"))
{
const auto directory=message.substr(10);
if(!terminalCommandPanels.empty())
{
const int panel=terminalCommandPanels.front();
terminalCommandPanels.pop_front();
std::error_code error;
if(panel>=0 && !panels[panel].peer && directory!=terminalDirectory &&
!directory.empty() && fs::is_directory(directory,error))
open(panels[panel],directory,false);
}
terminalDirectory=directory;
}
else if(message==L"focus-input")
{
if(GetForegroundWindow()==owner) SetFocus(terminalInput);
}
else if(message==L"insert-path") insertCurrentPanelPath();
else if(message==L"copy-command-line") SendMessageW(terminalInput,WM_COPY,0,0);
else if(message==L"toggle") showTerminal(owner,!terminalVisible);
else if(!terminalVisible && (message==L"grow" || message==L"shrink"))
{
terminalRows=std::max(0,terminalRows+(message==L"grow"?1:-1));
layout(owner);
}
else if(message.starts_with(L"size:"))
{
int columns{},rows{};
if(swscanf_s(message.c_str()+5,L"%d,%d",&columns,&rows)==2 &&
columns>=2 && columns<=32767 && rows>=2 && rows<=32767)
{
terminalSize={static_cast<SHORT>(columns),static_cast<SHORT>(rows)};
terminal.resize(terminalSize);
}
}
},[owner]
{
showTerminal(owner,false);
setStatus(L"Could not initialize the terminal view.");
});
if(!terminalViewRequested)
{
setStatus(L"WebView2 and the local terminal assets are required.");
return false;
}
}
if(panels[active].peer)
{
setStatus(L"Select a local panel to start the terminal.");
return false;
}
if(terminal.start(panels[active].directory.c_str(),terminalSize))
{
terminalCommandPanels={-1};
terminalDirectory.clear();
return true;
}
setStatus(L"Could not start PowerShell.");
return false;
}
void updateTerminalOutput()
{
if(!terminalView.initialized()) return;
const auto bytes=terminal.takeOutput();
if(!bytes.empty()) terminalView.send(bytes);
}
bool submitTerminalCommand(const Panel &panel,const std::wstring &value)
{
if(!startTerminal(GetParent(panel.list))) return false;
if(!terminal.write(value+L"\r"))
{
setStatus(L"Could not send PowerShell input.");
return false;
}
terminalCommandPanels.push_back(static_cast<int>(&panel-panels));
return true;
}
LRESULT CALLBACK terminalInputKeys(HWND input,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
if(message==WM_COPY || (message==WM_CHAR && wp==3))
{
copyTerminalInput(GetParent(input));
return 0;
}
if(message==WM_CHAR && wp==VK_TAB && !terminalVisible) return 0;
if(message==WM_CHAR && wp==VK_ESCAPE)
{
recallCommand(terminalHistory.size());
return 0;
}
if((message==WM_CHAR && wp==22) ||
(message==WM_KEYDOWN && wp==VK_INSERT && (GetKeyState(VK_SHIFT)&0x8000)))
{
SendMessageW(input,WM_PASTE,0,0);
return 0;
}
// The edit control receives Ctrl+Backspace as DEL.
if(message==WM_CHAR && wp==127)
{
DWORD first{},last{};
SendMessageW(input,EM_GETSEL,reinterpret_cast<WPARAM>(&first),reinterpret_cast<LPARAM>(&last));
if(first==last && first)
{
std::wstring text(GetWindowTextLengthW(input)+1,L'\0');
GetWindowTextW(input,text.data(),static_cast<int>(text.size()));
while(first && iswspace(text[first-1])) --first;
while(first && !iswspace(text[first-1])) --first;
SendMessageW(input,EM_SETSEL,first,last);
}
SendMessageW(input,EM_REPLACESEL,TRUE,reinterpret_cast<LPARAM>(L""));
return 0;
}
if(message==WM_CHAR && wp==VK_RETURN)
{
if(!terminalVisible && !GetWindowTextLengthW(input))
{
SendMessageW(panels[active].list,WM_KEYDOWN,VK_RETURN,lp);
return 0;
}
const auto value=terminalInputText();
if(!submitTerminalCommand(panels[active],value)) return 0;
if(value.find_first_not_of(L" \t\r\n")!=std::wstring::npos) rememberCommand(value);
terminalHistoryIndex=terminalHistory.size();
SetWindowTextW(input,L"");
return 0;
}
if(message==WM_KEYDOWN && !terminalVisible && wp==VK_TAB)
{
activatePanel(1-active);
return 0;
}
if(message==WM_KEYDOWN && !terminalVisible &&
((wp>=VK_F1 && wp<=VK_F12) || wp==VK_UP || wp==VK_DOWN || wp==VK_PRIOR || wp==VK_NEXT ||
(!GetWindowTextLengthW(input) &&
(wp==VK_HOME || wp==VK_END || wp==VK_LEFT || wp==VK_RIGHT || wp==VK_INSERT || wp==VK_DELETE))))
{
SendMessageW(panels[active].list,WM_KEYDOWN,wp,lp);
return 0;
}
if(message==WM_KEYDOWN && (wp==VK_UP || wp==VK_DOWN))
{
if(wp==VK_UP && terminalHistoryIndex) recallCommand(terminalHistoryIndex-1);
if(wp==VK_DOWN && terminalHistoryIndex<terminalHistory.size()) recallCommand(terminalHistoryIndex+1);
return 0;
}
return DefSubclassProc(input,message,wp,lp);
}
void showFileDetails(const Panel &panel)
{
auto row=SendMessageW(panel.list,LB_GETCURSEL,0,0);
if(!panel.wide || !showDetails || row<0 || static_cast<size_t>(row)>=panel.rows.size())
{
setStatus(L"");
return;
}
const auto &path=panel.rows[row];
WIN32_FILE_ATTRIBUTE_DATA data{};
SYSTEMTIME modified{};
wchar_t date[64]{};
bool haveTime=false;
if(panel.peer)
{
if(const auto found=panel.timestamps.find(path); found!=panel.timestamps.end())
{
data.ftLastWriteTime={static_cast<DWORD>(found->second),static_cast<DWORD>(found->second>>32)};
haveTime=true;
}
}
else haveTime=GetFileAttributesExW(path.c_str(),GetFileExInfoStandard,&data)!=FALSE;
if(haveTime && FileTimeToSystemTime(&data.ftLastWriteTime,&modified))
{
SYSTEMTIME local{};
if(SystemTimeToTzSpecificLocalTime(nullptr,&modified,&local))
swprintf_s(date,L" %04u-%02u-%02u %02u:%02u",unsigned(local.wYear),
unsigned(local.wMonth),unsigned(local.wDay),unsigned(local.wHour),unsigned(local.wMinute));
}
std::wstring details;
if(statusFields&1) details=path.filename().wstring();
if(statusFields&2)
{
const auto &size=panel.sizes[row];
details+=L" "+(size==L"Folder" || size==L"Up"?size:formatSize(std::stoull(size)));
}
std::wstring timestamp=date;
if((statusFields&4) && timestamp.size()>=12) details+=timestamp.substr(0,12);
if((statusFields&8) && timestamp.size()>=18) details+=timestamp.substr(12);
setStatus(details);
}
void openOn(Panel &panel,const fs::path &directory,bool offerElevation,std::optional<FilesPeer> peer)
{
const auto previousDirectory=(panel.peer?panel.peer->id:std::string{})==
(peer?peer->id:std::string{})?panel.directory:fs::path{};
const bool sameDirectory=previousDirectory==directory;
// Start watching before enumeration so changes during a scan trigger another refresh.
Panel::DirectoryWatch nextWatch;
if(!peer && (!sameDirectory || panel.watch.handle==INVALID_HANDLE_VALUE))
nextWatch.start(directory);
WIN32_FIND_DATAW data{};
const auto search=peer?INVALID_HANDLE_VALUE:FindFirstFileW((directory/L"*").c_str(),&data);
auto error=search==INVALID_HANDLE_VALUE ? GetLastError() : ERROR_SUCCESS;
std::vector<fs::path> folders, files;
std::map<fs::path,FolderEntryMetadata> metadata;
std::map<fs::path,uint64_t> timestamps;
if(peer)
{
try
{
FilesConnection host(&*peer);
listFiles(host,directory,[&](const fs::path &path,const FileInfo &info)
{
(info.attributes&FILE_ATTRIBUTE_DIRECTORY?folders:files).push_back(path);
metadata.emplace(path,FolderEntryMetadata{info.attributes,info.size});
timestamps.emplace(path,info.modified);
return true;
});
error=ERROR_SUCCESS;
}
catch(const std::system_error &e){setStatus(peer->name+L" — "+fileError(e));return;}
catch(const std::exception &){setStatus(L"Cannot open folder on "+peer->name);return;}
}
if (error!=ERROR_SUCCESS && error!=ERROR_FILE_NOT_FOUND)
{
const bool denied=error==ERROR_ACCESS_DENIED;
setStatus(denied ? L"Access denied: " + directory.wstring() :
L"Cannot open folder: " + directory.wstring());
if(offerElevation && denied && !IsUserAnAdmin())
{
auto owner=GetParent(panel.list);
auto path=directory.wstring();
const TASKDIALOG_BUTTON buttons[]{{IDYES,L"Continue as administrator"},{IDCANCEL,L"Skip"}};
TASKDIALOGCONFIG dialog{};
dialog.cbSize=sizeof(dialog);
dialog.hwndParent=owner;
dialog.dwFlags=TDF_ALLOW_DIALOG_CANCELLATION|TDF_POSITION_RELATIVE_TO_WINDOW;
dialog.pszWindowTitle=L"KSwitcher Files";
dialog.pszMainInstruction=L"Windows denied access to this folder";
dialog.pszContent=path.c_str();
dialog.pszVerificationText=L"Remember Continue for this session (Windows may still ask for UAC)";
dialog.cButtons=static_cast<UINT>(std::size(buttons));
dialog.pButtons=buttons;
dialog.nDefaultButton=IDCANCEL;
BOOL skip{};
int choice=IDYES;
if(!rememberElevationApproval && FAILED(TaskDialogIndirect(&dialog,&choice,nullptr,&skip)))
choice=MessageBoxW(owner,(path+L"\n\nTry opening as administrator?").c_str(),
L"KSwitcher Files",MB_YESNO|MB_DEFBUTTON2|MB_ICONQUESTION);
if(choice==IDYES)
{
const auto result=requestElevatedFolder(owner,directory,folders,files,metadata);
SetForegroundWindow(owner);
SetFocus(panel.list);
if(result!=ERROR_SUCCESS)
{
setStatus(result==ERROR_ACCESS_DENIED ? L"Windows denied access after elevation: "+path :
L"Could not read folder as administrator ("+std::to_wstring(result)+L"): "+path);
return;
}
rememberElevationApproval=rememberElevationApproval || skip!=FALSE;
error=ERROR_SUCCESS;
}
}
if(error) return;
}
if(search!=INVALID_HANDLE_VALUE)
{
do
{
const std::wstring_view name(data.cFileName);
if(name==L"." || name==L"..") continue;
const auto path=directory/name;
const auto size=(static_cast<ULONGLONG>(data.nFileSizeHigh)<<32)|data.nFileSizeLow;
(data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY?folders:files).push_back(path);
metadata.emplace(path,FolderEntryMetadata{data.dwFileAttributes,size});
} while(FindNextFileW(search,&data));
error=GetLastError();
FindClose(search);
}
std::sort(folders.begin(), folders.end());
std::sort(files.begin(), files.end());
std::set<fs::path> markedPaths;
fs::path previousSelection;
LRESULT previousRow=0, previousTop=0;
if(sameDirectory)
{
previousRow=SendMessageW(panel.list,LB_GETCURSEL,0,0);
previousTop=SendMessageW(panel.list,LB_GETTOPINDEX,0,0);
if(previousRow>=0 && static_cast<size_t>(previousRow)<panel.rows.size())
previousSelection=panel.rows[previousRow];
for(size_t i=0;i<panel.rows.size();++i)
if(panel.marked[i]) markedPaths.insert(panel.rows[i]);
}
panel.directory = directory;
panel.peer=std::move(peer);
if(!sameDirectory || nextWatch.handle!=INVALID_HANDLE_VALUE)
{
panel.watch.reset();
std::swap(panel.watch.handle,nextWatch.handle);
}
panel.timestamps=std::move(timestamps);
panel.rows.clear();
panel.sizes.clear();
panel.dimmed.clear();
panel.marked.clear();
panel.fileExtensionLength=panel.folderExtensionLength=0;
SendMessageW(panel.list, LB_RESETCONTENT, 0, 0);
auto add = [&](const fs::path &path, const std::wstring &label, bool folder)
{
if (SendMessageW(panel.list, LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(label.c_str())) >= 0)
{
panel.rows.push_back(path);
if(label!=L"..")
{
const auto extension=path.extension().native();
auto &longest=folder?panel.folderExtensionLength:panel.fileExtensionLength;
if(extension.size()>1) longest=std::max(longest,extension.size()-1);
}
panel.marked.push_back(label!=L".." && markedPaths.contains(path));
const auto entry=label==L".." ? FolderEntryMetadata{} : metadata.at(path);
panel.dimmed.push_back((entry.attributes&(FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN))!=0);
panel.sizes.push_back(folder ? (label==L".." ? L"Up" : L"Folder") :
std::to_wstring(entry.size));
}
};
if (directory.has_relative_path()) add(directory.parent_path(), L"..", true);
for (const auto &folder : folders) add(folder, L"[" + folder.filename().wstring() + L"]", true);
for (const auto &file : files) add(file, file.filename().wstring(), false);
const auto label=(panel.peer?panel.peer->name+L" · ":std::wstring{})+directory.native();
SetWindowTextW(panel.path,label.c_str());
if(&panel==&panels[active] && !sameDirectory)
layout(GetParent(panel.list));
auto selected=std::find(panel.rows.begin(),panel.rows.end(),previousSelection);
if(selected==panel.rows.end() && !panel.rows.empty())
selected=panel.rows.begin()+std::clamp<LRESULT>(previousRow,0,panel.rows.size()-1);
if(!previousDirectory.empty() && previousDirectory.parent_path()==directory)
{
const auto child=std::find(panel.rows.begin(),panel.rows.end(),previousDirectory);
if(child!=panel.rows.end()) selected=child;
}
if(selected!=panel.rows.end())
{
if(sameDirectory) SendMessageW(panel.list,LB_SETTOPINDEX,previousTop,0);
SendMessageW(panel.list,LB_SETCURSEL,selected-panel.rows.begin(),0);
}
InvalidateRect(panel.list,nullptr,FALSE);
if(error!=ERROR_SUCCESS && error!=ERROR_NO_MORE_FILES && error!=ERROR_FILE_NOT_FOUND)
setStatus(L"Some entries could not be read.");
else if(&panel==&panels[active]) showFileDetails(panel);
}
void open(Panel &panel,const fs::path &directory,bool offerElevation=false)
{
openOn(panel,directory,offerElevation,panel.peer);
}
void refreshChangedPanels()
{
for(auto &panel:panels)
{
const auto watch=panel.watch.handle;
if(watch==INVALID_HANDLE_VALUE || WaitForSingleObject(watch,0)!=WAIT_OBJECT_0) continue;
if(!FindNextChangeNotification(watch)) panel.watch.reset();
// Pass a copy because opening the folder rebuilds the panel.
const auto directory=panel.directory;
open(panel,directory);
}
}
void selectDrive()
{
auto row=SendMessageW(picker,LB_GETCURSEL,0,0);
if(!commandPicker && (row<0 || static_cast<size_t>(row)==drivePaths.size())) return;
const auto remote=remoteDriveRows.find(row);
if(commandPicker || row<static_cast<LRESULT>(drivePaths.size()) || remote!=remoteDriveRows.end())
{
hidePicker();
showMenu(false);
}
if(commandPicker)
{
if(row<0) return;
auto owner=GetParent(picker);
if(menuIndex==0 || menuIndex==4)
{
int index=menuIndex==4;
if(row==2) chooseDrive(index);
else setMode(index,row==1);
}
else if(menuIndex==2 && row==3) showFolderShortcuts(panels[active],-1);
else
{
const int command=menuIndex==1?113+static_cast<int>(row):110+static_cast<int>(row);
SendMessageW(owner,WM_COMMAND,MAKEWPARAM(command,BN_CLICKED),0);
}
return;
}
if(row>=0 && static_cast<size_t>(row)<drivePaths.size())
openOn(panels[pickerPanel],drivePaths[row],false,{});
else if(remote!=remoteDriveRows.end())
openOn(panels[pickerPanel],remote->second.path,false,remote->second.peer);
}
LRESULT CALLBACK pickerKeys(HWND window, UINT msg, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR)
{
if(!commandPicker && msg==WM_CHAR)
{
const auto key=towupper(static_cast<wchar_t>(wp));
LRESULT row=LB_ERR;
if(key>=L'A' && key<=L'Z')
{
const auto disk=std::find_if(drivePaths.begin(),drivePaths.end(),[key](const fs::path &path)
{ return path.native().front()==key; });
if(disk!=drivePaths.end()) row=disk-drivePaths.begin();
}
if(row!=LB_ERR)
{
SendMessageW(window,LB_SETCURSEL,row,0);
selectDrive();
return 0;
}
}
if(!commandPicker && (msg==WM_MOUSEMOVE || msg==WM_MOUSELEAVE))
{
int row=-1;
if(msg==WM_MOUSEMOVE)
{
TRACKMOUSEEVENT tracking{sizeof(tracking),TME_LEAVE,window,0};
TrackMouseEvent(&tracking);
const auto hit=SendMessageW(window,LB_ITEMFROMPOINT,0,lp);
if(!HIWORD(hit) && LOWORD(hit)<drivePaths.size()) row=LOWORD(hit);
}
if(driveHover!=row)
{
driveHover=row;
InvalidateRect(window,nullptr,FALSE);
}
}
if(msg==WM_KEYDOWN && wp==VK_ESCAPE)
{
hidePicker();
return 0;
}
if(msg==WM_KEYDOWN && wp==VK_RETURN){selectDrive();return 0;}
if(msg==WM_KEYDOWN && (wp==VK_LEFT || wp==VK_RIGHT) && IsWindowVisible(menuBar))
{
int next=(menuIndex+(wp==VK_LEFT?4:1))%5;
SendMessageW(GetParent(window),WM_COMMAND,MAKEWPARAM(130+next,BN_CLICKED),0);
return 0;
}
return scrollList(window,msg,wp,lp);
}
void queryDrivePeers()
{
drivePeers.clear();
drivePeerLookupError.clear();
drivePeerReplyReceived=false;
drivePeerService=FindWindowW(L"KSwitcher.Main",L"KSwitcher");
if(drivePeerService)
{
COPYDATASTRUCT request{FilesLanPeers,0,nullptr};
DWORD_PTR result{};
SetLastError(ERROR_SUCCESS);
const auto delivered=SendMessageTimeoutW(drivePeerService,WM_COPYDATA,
reinterpret_cast<WPARAM>(GetParent(picker)),reinterpret_cast<LPARAM>(&request),
SMTO_ABORTIFHUNG|SMTO_ERRORONEXIT,350,&result);
const auto error=GetLastError();
if(!delivered || result!=1 || !drivePeerReplyReceived)
{
drivePeers.clear();
if(delivered && result!=1)
drivePeerLookupError=L"KSwitcher rejected the peer request";
else if(delivered)
drivePeerLookupError=L"Invalid peer list from KSwitcher";
else if(error==ERROR_ACCESS_DENIED)
drivePeerLookupError=L"Access denied by Windows";
else if(error==ERROR_TIMEOUT)
drivePeerLookupError=L"KSwitcher did not respond in time";
else
drivePeerLookupError=L"Peer request failed (Windows code "+std::to_wstring(error)+L")";
ks::log(L"LAN Files peer lookup failed: delivered="+std::to_wstring(delivered!=0)+
L", reply="+std::to_wstring(result)+L", Windows error="+std::to_wstring(error));
}
}
else
{
drivePeerLookupError=L"KSwitcher is not running";
ks::log(L"LAN Files peer lookup failed: local KSwitcher window not found");
}
drivePeerService=nullptr;
}
void startDriveQuery(DriveQuery &query)
{
if(query.peer.address.empty()) return;
std::packaged_task<Json()> task([peer=query.peer]
{
FilesConnection host(&peer);
auto reply=host.call({{"action","drives"}});
checkFileReply(reply);
return reply.at("drives");
});
query.pending=task.get_future();
try {std::thread(std::move(task)).detach();}
catch(const std::system_error &e){query.pending={};query.error=fileError(e);}
}
std::array<std::wstring,3> driveLabels(wchar_t letter,UINT type,uint64_t total,uint64_t free)
{
const wchar_t *types[]{L"unknown",L"unavailable",L"removable",L"fixed",L"network",L"CD-ROM",L"RAM disk"};
return {std::wstring(1,letter)+L": "+types[type<std::size(types)?type:0],
total?formatSize(total):L"—",total?formatSize(free):L"—"};
}
void layoutDrivePicker(int selected,bool focus)
{
HWND owner=GetParent(picker);
RECT panel{};
GetWindowRect(panels[pickerPanel].list,&panel);
MapWindowPoints(nullptr,owner,reinterpret_cast<POINT*>(&panel),2);
const int panelWidth=panel.right-panel.left;
const auto frame=dialogFrameMetrics(GetDpiForWindow(owner));
const int inset=frame.content(),vertical=dialogListInset(frame,textHeight);
const int width=std::clamp(drivePickerWidth,90,std::max(90,panelWidth*4/5-2*inset));
const int height=std::min(std::max(1,(static_cast<int>(panel.bottom-panel.top)-2*vertical)/textHeight),
static_cast<int>(SendMessageW(picker,LB_GETCOUNT,0,0)))*textHeight;
const int x=panel.left+(panel.right-panel.left-width)/2;
const int y=panel.top+(panel.bottom-panel.top-height)/2;
constexpr UINT flags=SWP_SHOWWINDOW|SWP_NOACTIVATE|SWP_NOCOPYBITS;
auto layout=BeginDeferWindowPos(2);
if(layout) layout=DeferWindowPos(layout,pickerFrame,HWND_TOP,
x-inset,y-vertical,width+2*inset,height+2*vertical,flags);
if(layout) layout=DeferWindowPos(layout,picker,HWND_TOP,x,y,width,height,flags);
if(!layout || !EndDeferWindowPos(layout))
{
SetWindowPos(pickerFrame,HWND_TOP,x-inset,y-vertical,width+2*inset,height+2*vertical,flags);
SetWindowPos(picker,HWND_TOP,x,y,width,height,flags);
}
RedrawWindow(pickerFrame,nullptr,nullptr,RDW_INVALIDATE|RDW_UPDATENOW);
SendMessageW(picker,LB_SETCURSEL,selected,0);
if(focus) SetFocus(picker);
}
void showRemoteDrives(bool focus=false,int initialRow=0)
{
auto selection=SendMessageW(picker,LB_GETCURSEL,0,0);
std::optional<DriveChoice> previous;
if(auto row=remoteDriveRows.find(selection);row!=remoteDriveRows.end()) previous=row->second;
if(selection>static_cast<LRESULT>(drivePaths.size())) selection=-1;
if(focus) selection=initialRow;
const auto top=SendMessageW(picker,LB_GETTOPINDEX,0,0);
for(auto count=SendMessageW(picker,LB_GETCOUNT,0,0);count>static_cast<LRESULT>(drivePaths.size());--count)
SendMessageW(picker,LB_DELETESTRING,count-1,0);
remoteDriveRows.clear();
const auto add=[](const std::wstring &label)
{
drivePickerWidth=std::max(drivePickerWidth,static_cast<int>(label.size()+2)*cellWidth);
return SendMessageW(picker,LB_ADDSTRING,0,reinterpret_cast<LPARAM>(label.c_str()));
};
add(L"KSwitcher LAN");
if(!drivePeerLookupError.empty()) add(L" "+drivePeerLookupError);
else if(driveQueries.empty()) add(L" No paired computers");
for(const auto &query:driveQueries)
{
add(query.peer.name);
if(query.pending.valid()) add(L" Loading drives...");
else if(!query.error.empty()) add(L" "+query.error);
else if(query.peer.address.empty()) add(refreshDriveAddresses?L" Looking for PC...":L" Offline");
else if(query.drives.empty()) add(L" No drives");
for(const auto &entry:query.drives)
{
const auto root=filePath(entry.at("path"));
if(root.native().size()!=3 || root.native().front()<L'A' || root.native().front()>L'Z') continue;
const auto labels=driveLabels(root.native().front(),entry.at("type"),entry.at("total"),entry.at("free"));
const auto row=add(L" "+labels[0]+L" "+labels[1]+L" "+labels[2]);
if(row<0) continue;
remoteDriveRows.emplace(row,DriveChoice{query.peer,root});
if(previous && previous->peer.id==query.peer.id && previous->path==root) selection=row;
}
}
layoutDrivePicker(static_cast<int>(selection),focus);
InvalidateRect(picker,nullptr,FALSE);
if(!focus) SendMessageW(picker,LB_SETTOPINDEX,top,0);
}
void pollDriveQueries(HWND owner)
{
if(commandPicker || !IsWindowVisible(picker))
{
KillTimer(owner,driveQueryTimer);
driveQueries.clear();
return;
}
bool changed=false, pending=false;
if(refreshDriveAddresses && GetTickCount64()-driveOpened>=500)
{
refreshDriveAddresses=false;
queryDrivePeers();
for(const auto &peer:drivePeers)
if(std::none_of(driveQueries.begin(),driveQueries.end(),[&](const DriveQuery &query){return query.peer.id==peer.id;}))
{
auto &query=driveQueries.emplace_back();
query.peer=peer;
startDriveQuery(query);
}
for(auto &query:driveQueries)
if(query.peer.address.empty())
for(const auto &peer:drivePeers)
if(peer.id==query.peer.id && !peer.address.empty())
{
query.peer=peer;
startDriveQuery(query);
break;
}
changed=true;
}
for(auto &query:driveQueries)
{
if(!query.pending.valid()) continue;
if(query.pending.wait_for(std::chrono::seconds(0))!=std::future_status::ready)
{
pending=true;
continue;
}
try {query.drives=query.pending.get();}
catch(const std::system_error &e)
{
ks::log(L"LAN Files drive query failed: Windows error "+std::to_wstring(e.code().value()));
if(e.code()==std::error_code(WSAETIMEDOUT,std::system_category()))
query.error=L"Connection timed out";
else
query.error=query.peer.filesBrowse?fileError(e):L"Check build / TCP 45885";
}
catch(const std::exception &)
{
ks::log(L"LAN Files drive query failed: unexpected error");
query.error=query.peer.filesBrowse?L"Cannot reach TCP 45885":L"Check build / TCP 45885";
}
changed=true;
}
if(changed) showRemoteDrives();
if(!pending && !refreshDriveAddresses) KillTimer(owner,driveQueryTimer);
}
void chooseDrive(int index,bool fromMenu)
{
commandPicker=false;
if (!fromMenu) showMenu(false);
pickerPanel=index;
drivePaths.clear();
driveHover=-1;
SendMessageW(picker,LB_RESETCONTENT,0,0);
queryDrivePeers();
remoteDriveRows.clear();
driveQueries.clear();
for(const auto &peer:drivePeers)
{
auto &query=driveQueries.emplace_back();
query.peer=peer;
startDriveQuery(query);
}
refreshDriveAddresses=true;
driveOpened=GetTickCount64();
const DWORD disks=GetLogicalDrives();
int selected=0;
int textWidth=0;
auto dc=GetDC(picker);
auto oldFont=dc ? SelectObject(dc,mono) : nullptr;
std::vector<std::array<std::wstring,3>> driveColumns;
std::array<LONG,3> columnWidths{};
SIZE space{cellWidth,0};
if(dc) GetTextExtentPoint32W(dc,L" ",1,&space);
for(int letter=0;letter<26;++letter)
{
if(!(disks & (1UL<<letter))) continue;
wchar_t drive[]{static_cast<wchar_t>(L'A'+letter),L':',L'\\',0};
const auto type=GetDriveTypeW(drive);
ULARGE_INTEGER total{},free{};
if(type==DRIVE_FIXED || type==DRIVE_RAMDISK) GetDiskFreeSpaceExW(drive,nullptr,&total,&free);
driveColumns.push_back(driveLabels(drive[0],type,total.QuadPart,free.QuadPart));
for(size_t i=0;i<columnWidths.size();++i)
{
const auto &value=driveColumns.back()[i];
SIZE extent{static_cast<LONG>(value.size())*cellWidth,0};
if(dc) GetTextExtentPoint32W(dc,value.c_str(),static_cast<int>(value.size()),&extent);
columnWidths[i]=std::max(columnWidths[i],extent.cx);
}
if(fs::path(drive)==panels[index].directory.root_path()) selected=static_cast<int>(drivePaths.size());
drivePaths.emplace_back(drive);
}
LONG edge=0;
for(size_t i=0;i<driveColumnStarts.size();++i)
{
driveColumnStarts[i]=edge+space.cx;
edge=driveColumnStarts[i]+columnWidths[i]+space.cx+1;
}
if(!driveColumns.empty()) textWidth=edge-1;
for(const auto &values:driveColumns)
{
const auto label=values[0]+L"\t"+values[1]+L"\t"+values[2];
SendMessageW(picker,LB_ADDSTRING,0,reinterpret_cast<LPARAM>(label.c_str()));
}
if(dc)
{
if(oldFont) SelectObject(dc,oldFont);
ReleaseDC(picker,dc);
}
HWND owner=GetParent(picker);
drivePickerWidth=textWidth;
showRemoteDrives(true,selected);
SetTimer(owner,driveQueryTimer,100,nullptr);
if (fromMenu) showMenu(true);
RedrawWindow(owner,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN|RDW_UPDATENOW);
}
void openPanelFile(const Panel &panel, const fs::path &file, const wchar_t *verb, const wchar_t *failureMessage)
{
if(panel.peer)
{
setStatus(L"Copy the remote file to a local panel before opening it.");
return;
}
std::error_code error;
if (!fs::is_regular_file(file, error))
{
if(!verb) setStatus(failureMessage);
return;
}
const auto extension=file.extension().wstring();
const auto isExtension=[&](const wchar_t *expected)
{
return CompareStringOrdinal(extension.c_str(),-1,expected,-1,TRUE)==CSTR_EQUAL;
};
if(!verb && (isExtension(L".bat") || isExtension(L".cmd")))
{
const auto command=L"& "+powerShellPath(file);
if(submitTerminalCommand(panel,command) && terminalRows<5)
{
terminalRows=5;
layout(GetParent(panel.list));
}
return;
}
if(!verb && isExtension(L".exe")) verb=L"open";
if (reinterpret_cast<INT_PTR>(ShellExecuteW(GetParent(panel.list), verb, file.c_str(), nullptr,
panel.directory.c_str(), SW_SHOWNORMAL)) <= 32)
setStatus(failureMessage);
}
void enter(Panel &panel)
{
const auto row=currentPanelRow(panel);
if(row!=LB_ERR)
{
auto target = panel.rows[row];
if(panel.sizes[row]==L"Folder" || panel.sizes[row]==L"Up") open(panel,target,true);
else openPanelFile(panel, target, nullptr, L"Cannot open the selected file.");
}
}
enum class ConflictMode { ask, overwrite, skip, rename, append, newer };
struct CopyRequest
{
std::vector<fs::path> sources;
fs::path destination;
fs::path newName;
fs::path otherDirectory;
ConflictMode conflictMode{};
bool askReadOnly=true;
bool move{};
const FilesPeer *sourcePeer{}, *destinationPeer{}, *otherPeer{};
};
bool directoryExists(const FilesPeer *peer,const fs::path &path)
{
if(!peer)
{
std::error_code error;
return fs::is_directory(path,error);
}
FilesConnection host(peer);
const auto info=statFile(host,path);
return info && (info->attributes&FILE_ATTRIBUTE_DIRECTORY);
}
HBRUSH warningBrush{};
RECT previousOwnerBounds{};
#include "files_dialog_input.inl"
LRESULT CALLBACK dialogButtonEnter(HWND button,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR);
void installDialogButtonKeys(HWND dialog)
{
EnumChildWindows(dialog,[](HWND control,LPARAM)->BOOL
{
wchar_t name[16]{};
GetClassNameW(control,name,static_cast<int>(std::size(name)));
if(lstrcmpiW(name,L"Button")==0 && (GetWindowLongPtrW(control,GWL_STYLE)&WS_TABSTOP))
SetWindowSubclass(control,dialogButtonEnter,1,0);
return TRUE;
},0);
}
bool isDialogEdit(HWND control)
{
wchar_t name[16]{};
GetClassNameW(control,name,static_cast<int>(std::size(name)));
return lstrcmpiW(name,L"Edit")==0;
}
void centerDialogEditText(HWND field)
{
RECT edit{};
GetClientRect(field,&edit);
if(const auto dc=GetDC(field))
{
const auto oldFont=SelectObject(dc,mono);
TEXTMETRICW metrics{};
if(GetTextMetricsW(dc,&metrics))
edit.top=std::max(0L,(edit.bottom-metrics.tmHeight)/2);
SelectObject(dc,oldFont);
ReleaseDC(field,dc);
}
SendMessageW(field,EM_SETRECTNP,0,reinterpret_cast<LPARAM>(&edit));
}
LRESULT CALLBACK dialogEditLayout(HWND field,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
const auto result=DefSubclassProc(field,message,wp,lp);
if(message==WM_SIZE || message==WM_SETFONT) centerDialogEditText(field);
return result;
}
void prepareDialogEdit(HWND field)
{
SendMessageW(field,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
const auto margin=MulDiv(2,GetDpiForWindow(field),96);
SendMessageW(field,EM_SETMARGINS,EC_LEFTMARGIN|EC_RIGHTMARGIN,MAKELPARAM(margin,margin));
if(GetWindowLongPtrW(field,GWL_STYLE)&ES_MULTILINE)
{
SetWindowSubclass(field,dialogEditLayout,1,0);
centerDialogEditText(field);
}
}
void prepareCopyDialog(HWND dialog)
{
installDialogButtonKeys(dialog);
EnumChildWindows(dialog,[](HWND control,LPARAM)->BOOL
{
if(isDialogEdit(control)) prepareDialogEdit(control);
return TRUE;
},0);
const auto style=GetWindowLongPtrW(dialog,GWL_STYLE);
SetWindowLongPtrW(dialog,GWL_STYLE,style&~(WS_CAPTION|WS_SYSMENU|WS_THICKFRAME));
const auto extended=GetWindowLongPtrW(dialog,GWL_EXSTYLE);
SetWindowLongPtrW(dialog,GWL_EXSTYLE,extended&~WS_EX_DLGMODALFRAME);
SetWindowPos(dialog,nullptr,0,0,0,0,
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_FRAMECHANGED);
}
RECT dialogControlBounds(HWND dialog,int id)
{
RECT bounds{};
GetWindowRect(GetDlgItem(dialog,id),&bounds);
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&bounds),2);
return bounds;
}
void layoutDialogContent(HWND dialog,int firstControl)
{
const auto dpi=GetDpiForWindow(dialog);
const auto frame=dialogFrameMetrics(dpi);
const auto first=dialogControlBounds(dialog,firstControl);
const int dx=frame.content()-first.left;
const int dy=dialogListInset(frame,textHeight)+MulDiv(1,dpi,96)-first.top;
for(auto control=GetWindow(dialog,GW_CHILD);control;control=GetWindow(control,GW_HWNDNEXT))
{
RECT bounds{};
GetWindowRect(control,&bounds);
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&bounds),2);
SetWindowPos(control,nullptr,bounds.left+dx,bounds.top+dy,0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
}
RECT outer{};
GetWindowRect(dialog,&outer);
SetWindowPos(dialog,nullptr,0,0,outer.right-outer.left+2*dx,outer.bottom-outer.top+dy,
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
}
int dialogFooterInset(HWND dialog)
{
const auto dpi=GetDpiForWindow(dialog);
const auto metrics=dialogFrameMetrics(dpi);
return metrics.innerLine();
}
LONG dialogDividerY(HWND dialog,int id)
{
const auto bounds=dialogControlBounds(dialog,id);
if(id==214)
{
const auto combo=dialogControlBounds(dialog,213);
const auto validation=dialogControlBounds(dialog,328);
return bounds.bottom+std::max(0L,(combo.top-validation.bottom-1)/2);
}
if(id==213) return (dialogControlBounds(dialog,328).bottom+bounds.top-1)/2;
return bounds.top-4;
}
void centerDialogRow(HWND dialog,int upperDivider,int lowerDivider,std::initializer_list<int> controls)
{
RECT client{};
GetClientRect(dialog,&client);
const auto top=dialogDividerY(dialog,upperDivider)+1;
const auto bottom=lowerDivider?dialogDividerY(dialog,lowerDivider):client.bottom-dialogFooterInset(dialog);
for(const auto id:controls)
{
const auto bounds=dialogControlBounds(dialog,id);
SetWindowPos(GetDlgItem(dialog,id),nullptr,bounds.left,(top+bottom-(bounds.bottom-bounds.top))/2,
0,0,SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
}
}
void layoutDialogButtons(HWND dialog,int divider,std::initializer_list<int> controls)
{
RECT client{},window{};
GetClientRect(dialog,&client);
GetWindowRect(dialog,&window);
const auto dpi=GetDpiForWindow(dialog);
const auto frame=dialogFrameMetrics(dpi);
const auto extra=frame.inner-dialogFrameMetrics(dpi,defaultDialogFramePadding).inner;
LONG tallest{};
for(const auto id:controls)
{
const auto bounds=dialogControlBounds(dialog,id);
tallest=std::max(tallest,bounds.bottom-bounds.top);
}
const auto footerHeight=std::max(tallest+2,2*static_cast<LONG>(textHeight)+2*extra);
const auto height=dialogDividerY(dialog,divider)+1+footerHeight+dialogFooterInset(dialog);
const auto width=window.right-window.left;
const auto outerHeight=window.bottom-window.top+height-client.bottom;
RECT owner{};
const bool centered=GetWindowRect(GetWindow(dialog,GW_OWNER),&owner)!=FALSE;
SetWindowPos(dialog,nullptr,(owner.left+owner.right-width)/2,
(owner.top+owner.bottom-outerHeight)/2,width,outerHeight,
(centered?0:SWP_NOMOVE)|SWP_NOZORDER|SWP_NOACTIVATE);
centerDialogRow(dialog,divider,0,controls);
}
void paintDialogButton(const DRAWITEMSTRUCT &item,COLORREF surface,COLORREF foreground)
{
wchar_t label[32]{};
GetWindowTextW(item.hwndItem,label,static_cast<int>(std::size(label)));
const bool focused=(item.itemState&(ODS_FOCUS|ODS_SELECTED))!=0;
SetDCBrushColor(item.hDC,focused?colors[Dialog]:surface);
FillRect(item.hDC,&item.rcItem,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
SelectObject(item.hDC,mono);
SetBkMode(item.hDC,TRANSPARENT);
SetTextColor(item.hDC,focused?colors[Text]:foreground);
auto rect=item.rcItem;
const auto defaultButton=SendMessageW(GetParent(item.hwndItem),DM_GETDEFID,0,0);
const bool isDefault=HIWORD(defaultButton)==DC_HASDEFID && LOWORD(defaultButton)==item.CtlID;
const auto caption=(isDefault?L"{ ":L"[ ")+std::wstring(label)+(isDefault?L" }":L" ]");
DrawTextW(item.hDC,caption.c_str(),-1,&rect,DT_CENTER|DT_VCENTER|DT_SINGLELINE);
}
INT_PTR paintCopyDialog(HWND dialog, UINT message, WPARAM wp, LPARAM lp,
const wchar_t *caption, bool warning, std::initializer_list<int> dividers, bool useDialogPalette=false,
HWND scrollListControl=nullptr)
{
const auto foreground=useDialogPalette?colors[Text]:warning?RGB(255,255,255):RGB(0,0,0);
const auto surface=useDialogPalette?colors[Dialog]:warning?RGB(128,0,0):RGB(192,192,192);
const auto brush=useDialogPalette?teal:warning?warningBrush:static_cast<HBRUSH>(GetStockObject(LTGRAY_BRUSH));
if(message==WM_CTLCOLORDLG) return reinterpret_cast<INT_PTR>(brush);
if(message==WM_CTLCOLORSTATIC || message==WM_CTLCOLOREDIT || message==WM_CTLCOLORBTN)
{
const auto dc=reinterpret_cast<HDC>(wp);
const bool edit=message==WM_CTLCOLOREDIT ||
(message==WM_CTLCOLORSTATIC && isDialogEdit(reinterpret_cast<HWND>(lp)));
SetTextColor(dc,edit?colors[Text]:foreground);
SetBkColor(dc,edit?colors[Dialog]:surface);
return reinterpret_cast<INT_PTR>(edit?teal:brush);
}
if(message==WM_PAINT)
{
PAINTSTRUCT paint{};
const auto dc=BeginPaint(dialog,&paint);
RECT bounds{};
GetClientRect(dialog,&bounds);
const auto client=bounds;
const auto black=static_cast<HBRUSH>(GetStockObject(useDialogPalette?DC_BRUSH:warning?WHITE_BRUSH:BLACK_BRUSH));
if(useDialogPalette) SetDCBrushColor(dc,foreground);
bounds=paintDialogFrame(dc,client,dialogFrameMetrics(GetDpiForWindow(dialog)),brush,black);
for(const auto control:dividers)
{
const auto y=dialogDividerY(dialog,control);
RECT divider{bounds.left+1,y,bounds.right-1,y+1};
FillRect(dc,&divider,black);
}
paintDialogFrameCaptions(dc,client,bounds,caption,brush,foreground,mono);
if(scrollListControl) paintScrollPosition(dialog,dc,scrollListControl,surface);
EndPaint(dialog,&paint);
return TRUE;
}
if(message==WM_DRAWITEM)
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
paintDialogButton(item,surface,foreground);
return TRUE;
}
return FALSE;
}
LRESULT CALLBACK paintConflictCombo(HWND control,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
if(message!=WM_PAINT) return DefSubclassProc(control,message,wp,lp);
PAINTSTRUCT paint{};
const auto dc=BeginPaint(control,&paint);
RECT bounds{};
GetClientRect(control,&bounds);
wchar_t label[64]{};
const auto selected=SendMessageW(control,CB_GETCURSEL,0,0);
if(selected!=CB_ERR) SendMessageW(control,CB_GETLBTEXT,selected,reinterpret_cast<LPARAM>(label));
auto arrow=bounds;
arrow.left=std::max(bounds.left,bounds.right-2*static_cast<LONG>(cellWidth));
bounds.right=arrow.left;
SetDCBrushColor(dc,colors[Dialog]);
FillRect(dc,&bounds,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
FillRect(dc,&arrow,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
SelectObject(dc,mono);
SetBkMode(dc,TRANSPARENT);
SetTextColor(dc,colors[Text]);
bounds.left+=5;
DrawTextW(dc,label,-1,&bounds,DT_SINGLELINE|DT_VCENTER|DT_END_ELLIPSIS|DT_NOPREFIX);
DrawTextW(dc,L"↓",-1,&arrow,DT_SINGLELINE|DT_VCENTER|DT_CENTER);
if(GetFocus()==control) DrawFocusRect(dc,&bounds);
EndPaint(control,&paint);
return 0;
}
INT_PTR CALLBACK copyDialog(HWND dialog, UINT message, WPARAM wp, LPARAM lp)
{
constexpr int summary=210, pathField=211, conflicts=212;
if(message==WM_DRAWITEM && wp==214)
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
const auto request=reinterpret_cast<const CopyRequest*>(GetWindowLongPtrW(dialog,DWLP_USER));
const bool checked=request && request->askReadOnly;
paintText(item.hDC,item.rcItem,checked?L"[x] Also ask on read-only files":
L"[ ] Also ask on read-only files",RGB(0,0,0),RGB(192,192,192));
if(item.itemState&ODS_FOCUS) DrawFocusRect(item.hDC,&item.rcItem);
return TRUE;
}
if(message==WM_DRAWITEM && wp==213)
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
wchar_t label[64]{};
if(item.itemID!=UINT(-1))
SendMessageW(item.hwndItem,CB_GETLBTEXT,item.itemID,reinterpret_cast<LPARAM>(label));
const bool selected=(item.itemState&ODS_SELECTED)!=0 && (item.itemState&ODS_COMBOBOXEDIT)==0;
paintText(item.hDC,item.rcItem,label,colors[Text],colors[selected?Selection:Dialog]);
return TRUE;
}
if(message==WM_CTLCOLORLISTBOX)
{
const auto dc=reinterpret_cast<HDC>(wp);
SetTextColor(dc,colors[Text]);
SetBkColor(dc,colors[Dialog]);
return reinterpret_cast<INT_PTR>(teal);
}
const auto prompt=reinterpret_cast<const CopyRequest*>(GetWindowLongPtrW(dialog,DWLP_USER));
if(const auto painted=paintCopyDialog(dialog,message,wp,lp,
prompt && prompt->move?L" Rename/Move ":L" Copy ",false,{213,214}))
return painted;
if(message==WM_INITDIALOG)
{
auto &request=*reinterpret_cast<CopyRequest*>(lp);
prepareCopyDialog(dialog);
layoutDialogContent(dialog,summary);
SetWindowLongPtrW(dialog,DWLP_USER,lp);
for(const auto label:{L"Ask",L"Overwrite",L"Skip",L"Rename",L"Append",L"Only newer file(s)"})
if(!request.move || std::wstring_view(label)!=L"Append")
SendDlgItemMessageW(dialog,213,CB_ADDSTRING,0,reinterpret_cast<LPARAM>(label));
SendDlgItemMessageW(dialog,213,CB_SETCURSEL,0,0);
const std::wstring action=request.move?L"Rename or move ":L"Copy ";
const auto label=action+(request.sources.size()==1?request.sources.front().filename().wstring():
std::to_wstring(request.sources.size())+L" items")+L" to:";
SetDlgItemTextW(dialog,summary,label.c_str());
const bool single=request.sources.size()==1;
auto fieldText=single && !request.move?request.sources.front().filename():request.destination;
if(request.move && fieldText.has_filename()) fieldText/=L"";
SetDlgItemTextW(dialog,pathField,fieldText.c_str());
SendDlgItemMessageW(dialog,pathField,EM_SETREADONLY,!single && !request.move,0);
if(request.move) SetDlgItemTextW(dialog,IDOK,L"&Rename");
layoutDialogButtons(dialog,214,{IDOK,IDCANCEL});
SendDlgItemMessageW(dialog,328,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
SendDlgItemMessageW(dialog,summary,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
SendDlgItemMessageW(dialog,conflicts,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
for(const auto control:{213,214})
SendDlgItemMessageW(dialog,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
SendDlgItemMessageW(dialog,213,CB_SETITEMHEIGHT,0,textHeight);
SendDlgItemMessageW(dialog,213,CB_SETITEMHEIGHT,static_cast<WPARAM>(-1),textHeight+2);
RECT combo{}, caption{};
const auto captionControl=GetDlgItem(dialog,conflicts);
GetWindowRect(GetDlgItem(dialog,213),&combo);
GetWindowRect(captionControl,&caption);
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&combo),2);
MapWindowPoints(nullptr,dialog,reinterpret_cast<POINT*>(&caption),2);
SetWindowPos(captionControl,nullptr,caption.left,combo.top,
caption.right-caption.left,combo.bottom-combo.top,SWP_NOZORDER|SWP_NOACTIVATE);
SetWindowSubclass(GetDlgItem(dialog,213),paintConflictCombo,1,0);
SendMessageW(dialog,DM_SETDEFID,IDOK,0);
SendDlgItemMessageW(dialog,pathField,EM_SETSEL,0,-1);
return TRUE;
}
if(message==WM_CLOSE || (message==WM_COMMAND && LOWORD(wp)==IDCANCEL))
{
finishFilesDialog(dialog,IDCANCEL);
return TRUE;
}
if(message!=WM_COMMAND) return FALSE;
auto &request=*reinterpret_cast<CopyRequest*>(GetWindowLongPtrW(dialog,DWLP_USER));
if(LOWORD(wp)==214 && HIWORD(wp)==BN_CLICKED)
{
request.askReadOnly=!request.askReadOnly;
InvalidateRect(GetDlgItem(dialog,214),nullptr,FALSE);
return TRUE;
}
if(LOWORD(wp)==213)
{
InvalidateRect(GetDlgItem(dialog,213),nullptr,FALSE);
return FALSE;
}
if(LOWORD(wp)==pathField && HIWORD(wp)==EN_CHANGE)
{
SetDlgItemTextW(dialog,328,L"");
return TRUE;
}
if(LOWORD(wp)!=IDOK) return FALSE;
const auto showError=[&](const wchar_t *message)
{
SetDlgItemTextW(dialog,328,message);
SetFocus(GetDlgItem(dialog,pathField));
};
try
{
if(request.move)
{
const auto field=GetDlgItem(dialog,pathField);
std::wstring value(GetWindowTextLengthW(field)+1,L'\0');
value.resize(GetWindowTextW(field,value.data(),static_cast<int>(value.size())));
const fs::path entered(value);
const bool bareName=request.sources.size()==1 && entered==entered.filename() &&
entered!=L"." && entered!=L"..";
const auto initial=request.otherDirectory;
const bool usesOtherPanel=entered==initial || entered==initial/L"" ||
(request.otherPeer && entered.is_absolute());
const auto target=usesOtherPanel?entered:request.sources.front().parent_path()/entered;
const auto peer=usesOtherPanel?request.otherPeer:request.sourcePeer;
if(value.empty() || value.find_first_of(L"<>|?*")!=value.npos ||
(!directoryExists(peer,target) &&
(request.sources.size()!=1 || !target.has_filename() || !directoryExists(peer,target.parent_path()))))
{
showError(L"Enter an existing destination folder, or a new name for one item.");
return TRUE;
}
request.destinationPeer=peer;
request.newName.clear();
if(!bareName && directoryExists(peer,target))
{
request.destination=target.lexically_normal();
if(!request.destination.has_filename() && request.destination.has_relative_path())
request.destination=request.destination.parent_path();
}
else
{
request.destination=target.parent_path();
request.newName=target.filename();
}
}
else if(request.sources.size()==1)
{
const auto field=GetDlgItem(dialog,pathField);
std::wstring name(GetWindowTextLengthW(field)+1,L'\0');
name.resize(GetWindowTextW(field,name.data(),static_cast<int>(name.size())));
if(name.empty() || name.back()==L'.' || name.back()==L' ' ||
name.find_first_of(L"<>:\"/\\|?*")!=name.npos ||
std::any_of(name.begin(),name.end(),[](wchar_t ch){return ch<32;}))
{
showError(L"Enter a valid name for the copy.");
return TRUE;
}
if(CompareStringOrdinal(name.c_str(),-1,request.sources.front().filename().c_str(),-1,TRUE)!=CSTR_EQUAL)
request.newName=name;
else request.newName.clear();
}
const auto sourceDirectory=request.sources.front().parent_path();
const auto destination=request.move || request.newName.empty()?request.destination:sourceDirectory;
std::error_code error;
const auto peer=request.move || request.newName.empty()?request.destinationPeer:request.sourcePeer;
if(!directoryExists(peer,destination))
{
showError(L"The destination folder is unavailable.");
return TRUE;
}
const bool sameHost=(!peer && !request.sourcePeer) ||
(peer && request.sourcePeer && peer->id==request.sourcePeer->id);
const bool sameFolder=sameHost && (peer?
CompareStringOrdinal(destination.c_str(),-1,sourceDirectory.c_str(),-1,TRUE)==CSTR_EQUAL:
fs::equivalent(destination,sourceDirectory,error));
if(request.newName.empty() && sameFolder)
{
showError(L"Open a different folder in the other panel, or enter a new name for a single item.");
return TRUE;
}
const auto mode=SendDlgItemMessageW(dialog,213,CB_GETCURSEL,0,0);
if(mode!=CB_ERR) request.conflictMode=static_cast<ConflictMode>(
request.move && mode==static_cast<int>(ConflictMode::append)?static_cast<int>(ConflictMode::newer):mode);
finishFilesDialog(dialog,IDOK);
}
catch(const std::system_error &e)
{
showError(fileError(e).c_str());
}
catch(const std::exception &)
{
showError(L"The remote destination is unavailable.");
}
return TRUE;
}
struct CopyProgress
{
HWND window{};
bool canceled{};
bool closeOwner{};
bool move{};
int conflictChoice{};
ConflictMode conflictMode{};
bool askReadOnly=true;
uint64_t files{}, totalFiles{}, bytes{}, totalBytes{};
uint64_t skippedFiles{}, skippedBytes{};
const wchar_t *lastSkipReason=L"";
ULONGLONG lastPaint{};
fs::path from,to,renamedTarget;
};
bool copyInProgress{};
CopyProgress *activeCopy{};
struct OwnedWindowMove
{
HWND owner;
LONG dx,dy;
};
BOOL CALLBACK moveOwnedDialog(HWND window,LPARAM parameter)
{
const auto &move=*reinterpret_cast<const OwnedWindowMove*>(parameter);
if(window==move.owner || !IsWindowVisible(window) ||
GetAncestor(window,GA_ROOTOWNER)!=move.owner) return TRUE;
RECT bounds{};
if(GetWindowRect(window,&bounds))
SetWindowPos(window,nullptr,bounds.left+move.dx,bounds.top+move.dy,0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
return TRUE;
}
LRESULT CALLBACK paintCopyProgressBar(HWND bar,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
if(message!=WM_PAINT) return DefSubclassProc(bar,message,wp,lp);
PAINTSTRUCT paint{};
const auto dc=BeginPaint(bar,&paint);
RECT bounds{};
GetClientRect(bar,&bounds);
const auto percent=std::clamp(SendMessageW(bar,PBM_GETPOS,0,0),LRESULT{0},LRESULT{100});
auto filled=bounds;
filled.right=static_cast<LONG>(bounds.right*percent/100);
FillRect(dc,&bounds,static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH)));
FillRect(dc,&filled,static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
const auto label=std::to_wstring(percent)+L"%";
SelectObject(dc,mono);
SetBkMode(dc,TRANSPARENT);
constexpr auto flags=DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_NOPREFIX;
SetTextColor(dc,RGB(0,0,0));
auto labelBounds=bounds;
DrawTextW(dc,label.c_str(),-1,&labelBounds,flags);
const auto saved=SaveDC(dc);
if(saved)
{
IntersectClipRect(dc,filled.left,filled.top,filled.right,filled.bottom);
SetTextColor(dc,RGB(255,255,255));
labelBounds=bounds;
DrawTextW(dc,label.c_str(),-1,&labelBounds,flags);
RestoreDC(dc,saved);
}
EndPaint(bar,&paint);
return 0;
}
void updateCopyProgress(CopyProgress &progress,uint64_t current,uint64_t fileSize,bool force=false)
{
constexpr ULONGLONG refreshIntervalMs=200;
const auto now=GetTickCount64();
if(!force && now-progress.lastPaint<refreshIntervalMs) return;
progress.lastPaint=now;
if(!progress.from.empty())
{
SetDlgItemTextW(progress.window,220,(L"From: "+progress.from.wstring()).c_str());
SetDlgItemTextW(progress.window,221,(L"To: "+progress.to.wstring()).c_str());
for(const auto id:{220,221}) InvalidateRect(GetDlgItem(progress.window,id),nullptr,FALSE);
}
const auto percent=[](uint64_t done,uint64_t total)
{
return total?static_cast<int>(100.0*std::min(done,total)/total):0;
};
const auto updateBar=[&](int bar,int value)
{
const auto control=GetDlgItem(progress.window,bar);
SendMessageW(control,PBM_SETPOS,value,0);
InvalidateRect(control,nullptr,FALSE);
};
const auto bytes=progress.bytes+current;
updateBar(222,fileSize?percent(current,fileSize):0);
updateBar(226,progress.totalBytes?
percent(bytes+progress.skippedBytes,progress.totalBytes):
percent(progress.files+progress.skippedFiles,progress.totalFiles));
SetDlgItemTextW(progress.window,224,(L"Files: "+std::to_wstring(progress.files)+L" / "+
std::to_wstring(progress.totalFiles)+(progress.skippedFiles?
L" Skipped: "+std::to_wstring(progress.skippedFiles)+L" ("+progress.lastSkipReason+L")":L"")).c_str());
SetDlgItemTextW(progress.window,225,(L"Size: "+formatSize(bytes)+L" / "+
formatSize(progress.totalBytes)).c_str());
}
LRESULT CALLBACK dialogButtonEnter(HWND button,UINT message,WPARAM wp,LPARAM lp,UINT_PTR,DWORD_PTR)
{
if(message==WM_GETDLGCODE)
{
const auto key=reinterpret_cast<const MSG*>(lp);
if(key && key->message==WM_KEYDOWN && key->wParam==VK_RETURN)
return DefSubclassProc(button,message,wp,lp)|DLGC_WANTMESSAGE;
}
if(message==WM_KEYDOWN && wp==VK_RETURN)
{
SendMessageW(button,BM_CLICK,0,0);
return 0;
}
return DefSubclassProc(button,message,wp,lp);
}
INT_PTR CALLBACK cancelOperationDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
{
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Operation interrupted ",true,{236}))
return painted;
if(message==WM_INITDIALOG)
{
prepareCopyDialog(window);
layoutDialogContent(window,235);
SetDlgItemTextW(window,235,reinterpret_cast<const wchar_t*>(lp));
SendDlgItemMessageW(window,235,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
layoutDialogButtons(window,236,{IDYES,IDNO});
SendMessageW(window,DM_SETDEFID,IDNO,0);
SetFocus(GetDlgItem(window,IDNO));
return FALSE;
}
if(message==WM_CLOSE || (message==WM_COMMAND &&
(LOWORD(wp)==IDYES || LOWORD(wp)==IDNO || LOWORD(wp)==IDCANCEL)))
{
finishFilesDialog(window,message==WM_COMMAND && LOWORD(wp)==IDYES?IDYES:IDNO);
return TRUE;
}
return FALSE;
}
bool confirmOperationCancellation(HWND owner,const wchar_t *question)
{
const auto previous=warningBrush;
if(!previous) warningBrush=CreateSolidBrush(RGB(128,0,0));
const auto answer=runFilesDialog(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(105),owner,
cancelOperationDialog,reinterpret_cast<LPARAM>(question));
if(!previous)
{
DeleteObject(warningBrush);
warningBrush=nullptr;
}
return answer==IDYES;
}
INT_PTR CALLBACK copyProgressDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
{
if(message==WM_DRAWITEM && (wp==220 || wp==221))
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
std::wstring path(GetWindowTextLengthW(item.hwndItem)+1,L'\0');
GetWindowTextW(item.hwndItem,path.data(),static_cast<int>(path.size()));
auto bounds=item.rcItem;
FillRect(item.hDC,&bounds,static_cast<HBRUSH>(GetStockObject(LTGRAY_BRUSH)));
SelectObject(item.hDC,mono);
SetBkMode(item.hDC,TRANSPARENT);
SetTextColor(item.hDC,RGB(0,0,0));
constexpr auto flags=DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX;
const int prefix=wp==220?6:4;
if(GetWindowTextLengthW(item.hwndItem)>prefix && path[prefix-2]==L':')
{
SIZE width{};
GetTextExtentPoint32W(item.hDC,path.data(),prefix,&width);
DrawTextW(item.hDC,path.data(),prefix,&bounds,flags);
bounds.left+=width.cx;
DrawTextW(item.hDC,path.data()+prefix,-1,&bounds,flags|DT_PATH_ELLIPSIS|DT_END_ELLIPSIS);
}
else DrawTextW(item.hDC,path.data(),-1,&bounds,flags|DT_END_ELLIPSIS);
return TRUE;
}
const auto operation=reinterpret_cast<const CopyProgress*>(GetWindowLongPtrW(window,DWLP_USER));
if(const auto painted=paintCopyDialog(window,message,wp,lp,
operation && operation->move?L" Move ":L" Copy ",false,{228,229}))
return painted;
if(message==WM_DPICHANGED)
{
PostMessageW(window,refreshProgressLayout,0,0);
return FALSE;
}
if(message==WM_INITDIALOG || message==refreshProgressLayout)
{
if(message==WM_INITDIALOG)
{
prepareCopyDialog(window);
layoutDialogContent(window,220);
SetWindowLongPtrW(window,DWLP_USER,lp);
}
for(const auto control:{220,221,224,225})
{
SendDlgItemMessageW(window,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
const auto bounds=dialogControlBounds(window,control);
SetWindowPos(GetDlgItem(window,control),nullptr,0,0,bounds.right-bounds.left,textHeight,
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
}
for(const auto id:{222,226})
{
const auto bar=GetDlgItem(window,id);
const auto bounds=dialogControlBounds(window,id);
SetWindowPos(bar,nullptr,0,0,bounds.right-bounds.left,textHeight+8,
SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
SetWindowSubclass(bar,paintCopyProgressBar,1,0);
}
const auto moveRow=[&](int id,LONG top)
{
const auto bounds=dialogControlBounds(window,id);
SetWindowPos(GetDlgItem(window,id),nullptr,bounds.left,top,0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
};
const auto frame=dialogFrameMetrics(GetDpiForWindow(window));
const auto padding=std::max(0,frame.inner);
moveRow(221,std::max(dialogControlBounds(window,221).top,dialogControlBounds(window,220).bottom));
moveRow(222,std::max(dialogControlBounds(window,222).top,dialogControlBounds(window,221).bottom+4));
const auto firstBottom=dialogControlBounds(window,222).bottom;
moveRow(228,firstBottom+padding+4);
const auto offset=dialogDividerY(window,228)+1+padding-dialogControlBounds(window,224).top;
for(const auto id:{224,225,226})
moveRow(id,dialogControlBounds(window,id).top+offset);
moveRow(225,std::max(dialogControlBounds(window,225).top,dialogControlBounds(window,224).bottom));
moveRow(226,std::max(dialogControlBounds(window,226).top,dialogControlBounds(window,225).bottom+4));
const auto secondBottom=dialogControlBounds(window,226).bottom;
moveRow(229,secondBottom+padding+4);
layoutDialogButtons(window,229,{IDCANCEL});
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
return TRUE;
}
if(message==WM_NCHITTEST)
{
RECT bounds{};
GetWindowRect(window,&bounds);
if(GET_Y_LPARAM(lp)<bounds.top+18)
{
SetWindowLongPtrW(window,DWLP_MSGRESULT,HTCAPTION);
return TRUE;
}
}
if(message!=WM_CLOSE && (message!=WM_COMMAND || LOWORD(wp)!=IDCANCEL)) return FALSE;
auto &progress=*reinterpret_cast<CopyProgress*>(GetWindowLongPtrW(window,DWLP_USER));
if(!progress.canceled)
progress.canceled=confirmOperationCancellation(window,progress.move?
L"Do you really want to cancel moving?":L"Do you really want to cancel copying?");
return TRUE;
}
struct WarningPrompt
{
const wchar_t *message;
const wchar_t *details;
const wchar_t *accept;
const wchar_t *decline;
FileInfo incoming,existing;
bool remember{};
};
std::wstring conflictFileDetails(const FileInfo &file)
{
const FILETIME stamp{static_cast<DWORD>(file.modified),static_cast<DWORD>(file.modified>>32)};
SYSTEMTIME utc{},local{};
wchar_t date[32]=L"—";
if(file.modified && FileTimeToSystemTime(&stamp,&utc) && SystemTimeToTzSpecificLocalTime(nullptr,&utc,&local))
swprintf_s(date,L"%04u-%02u-%02u %02u:%02u:%02u",unsigned(local.wYear),
unsigned(local.wMonth),unsigned(local.wDay),unsigned(local.wHour),
unsigned(local.wMinute),unsigned(local.wSecond));
auto bytes=std::to_wstring(file.size);
for(auto position=bytes.size();position>3;)
{
position-=3;
bytes.insert(position,1,L'\u202F');
}
return bytes+L" B "+date;
}
LRESULT CALLBACK warningButtonKeys(HWND button,UINT message,WPARAM wp,LPARAM lp,
UINT_PTR,DWORD_PTR index)
{
if(message==WM_GETDLGCODE) return DefSubclassProc(button,message,wp,lp)|DLGC_WANTARROWS;
if(message==WM_KEYDOWN && (wp==VK_UP || wp==VK_DOWN))
{
if(index<3 && wp==VK_UP) SetFocus(GetDlgItem(GetParent(button),232));
if(index==3 && wp==VK_DOWN) SetFocus(GetDlgItem(GetParent(button),IDYES));
return 0;
}
if(message==WM_KEYDOWN && index<3 && (wp==VK_LEFT || wp==VK_RIGHT))
{
constexpr int buttons[]{IDYES,IDNO,IDCANCEL};
SetFocus(GetDlgItem(GetParent(button),buttons[(index+(wp==VK_LEFT?2:1))%3]));
return 0;
}
return DefSubclassProc(button,message,wp,lp);
}
INT_PTR CALLBACK warningDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
{
if(message==WM_DRAWITEM && wp==232)
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT*>(lp);
const auto warning=reinterpret_cast<const WarningPrompt*>(GetWindowLongPtrW(window,DWLP_USER));
auto bounds=item.rcItem;
FillRect(item.hDC,&bounds,warningBrush);
SelectObject(item.hDC,mono);
SetBkMode(item.hDC,TRANSPARENT);
SetTextColor(item.hDC,RGB(255,255,255));
bounds.left+=5;
DrawTextW(item.hDC,warning && warning->remember?L"[x] Remember choice":L"[ ] Remember choice",
-1,&bounds,DT_SINGLELINE|DT_VCENTER|DT_NOPREFIX);
if(item.itemState&ODS_FOCUS) DrawFocusRect(item.hDC,&item.rcItem);
return TRUE;
}
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Warning ",true,{233,333,234}))
return painted;
if(message==WM_INITDIALOG)
{
prepareCopyDialog(window);
layoutDialogContent(window,230);
SetWindowLongPtrW(window,DWLP_USER,lp);
const auto &warning=*reinterpret_cast<WarningPrompt*>(lp);
SetDlgItemTextW(window,230,warning.message);
SetDlgItemTextW(window,231,warning.details);
SetDlgItemTextW(window,330,conflictFileDetails(warning.incoming).c_str());
SetDlgItemTextW(window,332,conflictFileDetails(warning.existing).c_str());
SetDlgItemTextW(window,IDYES,warning.accept);
SetDlgItemTextW(window,IDNO,warning.decline);
for(const auto control:{230,231,232,329,330,331,332})
SendDlgItemMessageW(window,control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
centerDialogRow(window,333,234,{232});
layoutDialogButtons(window,234,{IDYES,IDNO,IDCANCEL});
SendMessageW(window,DM_SETDEFID,IDNO,0);
constexpr int buttons[]{IDYES,IDNO,IDCANCEL};
for(size_t i=0;i<std::size(buttons);++i)
SetWindowSubclass(GetDlgItem(window,buttons[i]),warningButtonKeys,1,i);
SetWindowSubclass(GetDlgItem(window,232),warningButtonKeys,1,std::size(buttons));
SetFocus(GetDlgItem(window,IDNO));
return FALSE;
}
if(message==WM_CLOSE)
{
finishFilesDialog(window,IDCANCEL);
return TRUE;
}
if(message==WM_COMMAND && LOWORD(wp)==232 && HIWORD(wp)==BN_CLICKED)
{
auto &warning=*reinterpret_cast<WarningPrompt*>(GetWindowLongPtrW(window,DWLP_USER));
warning.remember=!warning.remember;
InvalidateRect(GetDlgItem(window,232),nullptr,FALSE);
return TRUE;
}
if(message==WM_COMMAND && (LOWORD(wp)==IDYES || LOWORD(wp)==IDNO || LOWORD(wp)==IDCANCEL))
{
const auto choice=LOWORD(wp);
finishFilesDialog(window,choice);
return TRUE;
}
return FALSE;
}
bool pumpCopy(CopyProgress &progress)
{
MSG message{};
while(!progress.canceled && PeekMessageW(&message,nullptr,0,0,PM_REMOVE))
{
if(message.message==WM_QUIT)
{
PostQuitMessage(static_cast<int>(message.wParam));
progress.canceled=true;
break;
}
const auto owner=GetWindow(progress.window,GW_OWNER);
const bool inMainWindow=message.hwnd==owner || IsChild(owner,message.hwnd);
if(inMainWindow &&
((message.message>=WM_KEYFIRST && message.message<=WM_KEYLAST) ||
(message.message>=WM_MOUSEFIRST && message.message<=WM_MOUSELAST)))
{
if(filesMouseDown(message.message) || (message.message==WM_KEYDOWN && message.wParam==VK_ESCAPE))
SendMessageW(progress.window,WM_COMMAND,IDCANCEL,0);
else if(message.message==WM_SYSKEYDOWN && message.wParam==VK_F4)
SendMessageW(owner,WM_CLOSE,0,0);
continue;
}
const bool inProgressWindow=message.hwnd==progress.window || IsChild(progress.window,message.hwnd);
if(!inProgressWindow || !IsDialogMessageW(progress.window,&message))
{
TranslateMessage(&message);
DispatchMessageW(&message);
}
}
return !progress.canceled;
}
using FileEntries=std::vector<std::pair<fs::path,FileInfo>>;
FileEntries childrenOf(FilesConnection &host,const fs::path &path)
{
FileEntries children;
listFiles(host,path,[&](const fs::path &child,const FileInfo &info)
{
children.emplace_back(child,info);
return true;
});
return children;
}
bool countCopy(FilesConnection &host,const fs::path &path,CopyProgress &progress)
{
if(!pumpCopy(progress)) return false;
const auto info=statFile(host,path);
if(!info || (info->attributes&FILE_ATTRIBUTE_REPARSE_POINT))
throw std::system_error(info?ERROR_NOT_SUPPORTED:ERROR_FILE_NOT_FOUND,std::system_category());
if(!(info->attributes&FILE_ATTRIBUTE_DIRECTORY))
{
++progress.totalFiles;
progress.totalBytes+=info->size;
return true;
}
for(const auto &[child,entry]:childrenOf(host,path))
if(!countCopy(host,child,progress)) return false;
return true;
}
enum class CopyResult { complete, skipped, failed };
struct CopyEndpoints
{
FilesConnection &source, &target;
bool sameHost;
std::string sourceId;
};
void transferFile(const CopyEndpoints &hosts,const fs::path &from,const fs::path &to,
const FileInfo &info,bool replace,bool append,CopyProgress &progress)
{
const auto update=[&](uint64_t done,uint64_t total)
{
updateCopyProgress(progress,done,total);
return pumpCopy(progress);
};
if(hosts.sameHost)
{
auto request=fileRequest("copy",from);
request["target"]=ks::utf8(to.native());
request["replace"]=replace;
request["append"]=append;
request["size"]=info.size;
request["modified"]=info.modified;
checkFileReply(hosts.source.call(request,update));
return;
}
ks::lan::streamFile(hosts.source,hosts.target,hosts.sourceId,from,to,
info.size,info.modified,replace,append,update);
}
CopyResult copyItem(const CopyEndpoints &hosts,const fs::path &from,const fs::path &to,CopyProgress &progress,
bool topLevel=false,bool singleItem=false)
{
if(!pumpCopy(progress)) return CopyResult::failed;
const auto incoming=statFile(hosts.source,from);
if(!incoming || (incoming->attributes&FILE_ATTRIBUTE_REPARSE_POINT))
throw std::system_error(incoming?ERROR_NOT_SUPPORTED:ERROR_FILE_NOT_FOUND,std::system_category());
const auto moveOnHost=[&](const fs::path &target,bool replace)
{
if(!progress.move || !hosts.sameHost) return false;
auto request=fileRequest("move",from);
request["target"]=ks::utf8(target.native());
request["replace"]=replace;
const auto reply=hosts.source.call(request);
if(reply.at("error")==ERROR_NOT_SAME_DEVICE) return false;
checkFileReply(reply);
return true;
};
const auto existing=statFile(hosts.target,to);
if(incoming->attributes&FILE_ATTRIBUTE_DIRECTORY)
{
if(existing && (!(existing->attributes&FILE_ATTRIBUTE_DIRECTORY) ||
(existing->attributes&FILE_ATTRIBUTE_REPARSE_POINT)))
throw std::system_error(ERROR_ALREADY_EXISTS,std::system_category());
if(!existing && singleItem && moveOnHost(to,false))
{
progress.files=progress.totalFiles;
progress.bytes=progress.totalBytes;
return CopyResult::complete;
}
if(!existing) checkFileReply(hosts.target.call(fileRequest("mkdir",to)));
auto result=CopyResult::complete;
for(const auto &[child,entry]:childrenOf(hosts.source,from))
{
const auto outcome=copyItem(hosts,child,to/child.filename(),progress);
if(outcome==CopyResult::failed) return outcome;
if(outcome==CopyResult::skipped) result=outcome;
}
if(progress.move && result==CopyResult::complete)
checkFileReply(hosts.source.call(fileRequest("rmdir",from)));
return result;
}
progress.from=from;
progress.to=to;
const auto fileSize=incoming->size;
const auto transfer=[&](const fs::path &target,bool replace=false,bool append=false)
{
if(!moveOnHost(target,replace))
{
transferFile(hosts,from,target,*incoming,replace,append,progress);
if(progress.move)
{
auto remove=fileRequest("remove",from);
remove["size"]=incoming->size;
remove["modified"]=incoming->modified;
checkFileReply(hosts.source.call(remove));
}
}
progress.bytes+=fileSize;
++progress.files;
updateCopyProgress(progress,0,0);
return CopyResult::complete;
};
const auto skip=[&](const wchar_t *reason)
{
progress.skippedBytes+=fileSize;
++progress.skippedFiles;
progress.lastSkipReason=reason;
updateCopyProgress(progress,0,0);
return CopyResult::skipped;
};
updateCopyProgress(progress,0,fileSize);
if(!existing) return transfer(to);
if(existing->attributes&(FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_REPARSE_POINT))
throw std::system_error(ERROR_ALREADY_EXISTS,std::system_category());
const bool readOnly=(existing->attributes&FILE_ATTRIBUTE_READONLY)!=0;
auto mode=progress.conflictMode;
if(readOnly && progress.askReadOnly) mode=ConflictMode::ask;
if(mode==ConflictMode::skip) return skip(L"existing file");
if(mode==ConflictMode::newer && incoming->modified<=existing->modified)
return skip(L"source is not newer");
if(mode==ConflictMode::rename)
{
for(unsigned index=2;index<=10000;++index)
{
if(!pumpCopy(progress)) return CopyResult::failed;
const auto name=to.stem().wstring()+L" ("+std::to_wstring(index)+L")"+to.extension().wstring();
const auto candidate=to.parent_path()/name;
if(statFile(hosts.target,candidate)) continue;
const auto result=transfer(candidate);
if(topLevel) progress.renamedTarget=candidate;
return result;
}
throw std::system_error(ERROR_ALREADY_EXISTS,std::system_category());
}
const bool forceAsk=readOnly && progress.askReadOnly && progress.conflictMode!=ConflictMode::ask;
auto answer=mode==ConflictMode::ask?(forceAsk?0:static_cast<INT_PTR>(progress.conflictChoice)):IDYES;
if(!answer)
{
WarningPrompt warning{readOnly?L"Existing file is read-only":L"File already exists",
to.c_str(),L"&Overwrite",L"&Skip",*incoming,*existing};
warningBrush=CreateSolidBrush(RGB(128,0,0));
answer=runFilesDialog(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(104),progress.window,
warningDialog,reinterpret_cast<LPARAM>(&warning));
if(warning.remember && (answer==IDYES || answer==IDNO))
progress.conflictChoice=static_cast<int>(answer);
DeleteObject(warningBrush);
warningBrush=nullptr;
}
if(answer==IDNO) return skip(readOnly?L"read-only conflict":L"conflict choice");
if(answer!=IDYES)
{
progress.canceled=answer==IDCANCEL;
return CopyResult::failed;
}
return transfer(to,true,mode==ConflictMode::append);
}
void copySelection(HWND owner,Panel &source,Panel &destination,bool move)
{
if(copyInProgress)
{
setStatus(L"A copy is already in progress.");
return;
}
CopyRequest request{{},destination.directory};
request.move=move;
request.otherDirectory=destination.directory;
request.sourcePeer=source.peer?&*source.peer:nullptr;
request.otherPeer=request.destinationPeer=destination.peer?&*destination.peer:nullptr;
for(size_t i=0;i<source.rows.size();++i)
if(source.marked[i]) request.sources.push_back(source.rows[i]);
if(request.sources.empty())
{
const auto row=SendMessageW(source.list,LB_GETCURSEL,0,0);
if(row<0 || static_cast<size_t>(row)>=source.rows.size() || source.sizes[row]==L"Up") return;
request.sources.push_back(source.rows[row]);
}
const auto result=runFilesDialog(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(102),owner,copyDialog,
reinterpret_cast<LPARAM>(&request));
if(result==-1) setStatus(L"Could not open the Copy dialog.");
if(result!=IDOK) return;
const bool renamed=!request.newName.empty();
const auto targetDirectory=renamed && !move?request.sources.front().parent_path():request.destination;
const auto *targetPeer=renamed && !move?request.sourcePeer:request.destinationPeer;
const auto peerId=[](const FilesPeer *peer){return peer?peer->id:std::string{};};
const bool sameHost=peerId(request.sourcePeer)==peerId(targetPeer);
CopyProgress progress;
progress.move=move;
progress.conflictMode=request.conflictMode;
progress.askReadOnly=request.askReadOnly;
progress.window=CreateDialogParamW(GetModuleHandleW(nullptr),MAKEINTRESOURCEW(103),owner,
copyProgressDialog,reinterpret_cast<LPARAM>(&progress));
if(!progress.window)
{
setStatus(L"Could not open copy progress.");
return;
}
FilesDialogInput progressInput(progress.window);
copyInProgress=true;
activeCopy=&progress;
for(auto &panel:panels) EnableWindow(panel.list,FALSE);
for(const auto command:commands) EnableWindow(command,FALSE);
GetWindowRect(owner,&previousOwnerBounds);
ShowWindow(progress.window,SW_SHOW);
bool failed=false, skipped=false;
size_t copied=0;
std::set<fs::path> results;
std::wstring failure;
try
{
FilesConnection sourceHost(request.sourcePeer);
std::unique_ptr<FilesConnection> otherHost;
if(!sameHost) otherHost=std::make_unique<FilesConnection>(targetPeer);
const CopyEndpoints hosts{sourceHost,otherHost?*otherHost:sourceHost,sameHost,
request.sourcePeer?request.sourcePeer->id:"local"};
for(const auto &path:request.sources)
if(!countCopy(sourceHost,path,progress)) { failed=true; break; }
updateCopyProgress(progress,0,0,true);
for(const auto &path:request.sources)
{
if(failed) break;
const auto to=targetDirectory/(renamed?request.newName:path.filename());
if(sameHost)
{
const auto canonical=[&](const fs::path &name)
{
const auto reply=sourceHost.call(fileRequest("canonical",name));
checkFileReply(reply);
return filePath(reply.at("path"));
};
const auto canonicalSource=canonical(path);
const auto canonicalTarget=canonical(to);
for(auto ancestor=canonicalTarget;;ancestor=ancestor.parent_path())
{
if(CompareStringOrdinal(ancestor.c_str(),-1,canonicalSource.c_str(),-1,TRUE)==CSTR_EQUAL)
{
throw std::system_error(ERROR_INVALID_PARAMETER,std::system_category());
}
if(!ancestor.has_relative_path()) break;
}
}
if(failed) break;
progress.renamedTarget.clear();
const auto outcome=copyItem(hosts,path,to,progress,true,request.sources.size()==1);
if(outcome==CopyResult::failed) { failed=true; break; }
if(outcome==CopyResult::skipped) { skipped=true; continue; }
++copied;
results.insert(progress.renamedTarget.empty()?to:progress.renamedTarget);
const auto row=std::find(source.rows.begin(),source.rows.end(),path);
if(row!=source.rows.end()) source.marked[row-source.rows.begin()]=false;
InvalidateRect(source.list,nullptr,FALSE);
UpdateWindow(source.list);
}
}
catch(const std::system_error &e){failed=true;failure=fileError(e);}
catch(const std::exception &){failed=true;failure=L"File connection interrupted.";}
const auto targetId=peerId(targetPeer);
const bool restoreFocus=GetForegroundWindow()==progress.window;
updateCopyProgress(progress,0,0,true);
RedrawWindow(progress.window,nullptr,nullptr,RDW_UPDATENOW|RDW_ALLCHILDREN);
DestroyWindow(progress.window);
activeCopy=nullptr;
copyInProgress=false;
for(auto &panel:panels) EnableWindow(panel.list,TRUE);
for(const auto command:commands) EnableWindow(command,TRUE);
if(progress.closeOwner)
{
PostMessageW(owner,WM_CLOSE,0,0);
return;
}
if(move)
{
open(source,source.directory);
open(destination,destination.directory);
if(renamed && copied && sameHost)
{
const auto renamedPath=progress.renamedTarget.empty()?
targetDirectory/request.newName:progress.renamedTarget;
const auto row=std::find(source.rows.begin(),source.rows.end(),renamedPath);
if(row!=source.rows.end())
{
SendMessageW(source.list,LB_SETCURSEL,row-source.rows.begin(),0);
InvalidateRect(source.list,nullptr,FALSE);
showFileDetails(source);
}
}
}
else
{
auto &updated=renamed?source:destination;
if(updated.directory==targetDirectory)
open(updated,updated.directory);
}
if(!results.empty())
{
for(auto &panel:panels)
{
panel.transferResults.clear();
std::error_code error;
const bool hostMatches=peerId(panel.peer?&*panel.peer:nullptr)==targetId;
if(hostMatches && (panel.peer?CompareStringOrdinal(panel.directory.c_str(),-1,
targetDirectory.c_str(),-1,TRUE)==CSTR_EQUAL:fs::equivalent(panel.directory,targetDirectory,error)))
for(const auto &path:results) panel.transferResults.insert(panel.directory/path.filename());
InvalidateRect(panel.list,nullptr,FALSE);
}
transferHighlightPhase=0;
if(!SetTimer(owner,transferHighlightTimer,450,nullptr))
for(auto &panel:panels) panel.transferResults.clear();
}
if(restoreFocus)
{
SetForegroundWindow(owner);
SetFocus(panels[active].list);
}
if(failed && !progress.canceled && !failure.empty())
setStatus((move?L"Move failed — ":L"Copy failed — ")+failure);
else if(move)
{
if(progress.canceled) setStatus(L"Move canceled.");
else if(failed) setStatus(L"Could not complete the move.");
else if(skipped) setStatus(L"Move complete with skipped items.");
else setStatus(L"Move complete.");
}
else if(progress.canceled) setStatus(L"Copy canceled.");
else if(failed) setStatus(L"Could not complete the copy.");
else if(skipped) setStatus(L"Copy complete with skipped items.");
else setStatus(L"Copy complete.");
}
struct DeleteConfirmation
{
const wchar_t *message;
std::wstring entries;
int lines;
bool permanent;
bool folderPrompt;
bool readOnlyPrompt{};
};
INT_PTR CALLBACK deleteConfirmationDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
{
if(message==WM_INITDIALOG) SetWindowLongPtrW(window,DWLP_USER,lp);
const auto data=reinterpret_cast<const DeleteConfirmation*>(GetWindowLongPtrW(window,DWLP_USER));
if(!data) return FALSE;
if(const auto painted=paintCopyDialog(window,message,wp,lp,
data->readOnlyPrompt?L" Warning ":data->folderPrompt?L" Delete folder ":L" Delete ",
data->permanent,{243})) return painted;
if(message==WM_INITDIALOG)
{
prepareCopyDialog(window);
layoutDialogContent(window,240);
SetDlgItemTextW(window,240,data->message);
SetDlgItemTextW(window,241,data->entries.c_str());
if(data->permanent) SetDlgItemTextW(window,IDYES,L"&Delete");
for(const auto id:{240,241})
SendDlgItemMessageW(window,id,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
const auto entries=dialogControlBounds(window,241);
const auto question=dialogControlBounds(window,240);
const std::vector<int> buttons=data->readOnlyPrompt?
std::vector<int>{IDYES,244,IDNO,249,IDCANCEL}:data->folderPrompt?
std::vector<int>{IDYES,244,IDNO,IDCANCEL}:std::vector<int>{IDYES,IDCANCEL};
if(!data->readOnlyPrompt) ShowWindow(GetDlgItem(window,249),SW_HIDE);
if(!data->folderPrompt && !data->readOnlyPrompt)
for(const auto id:{244,IDNO}) ShowWindow(GetDlgItem(window,id),SW_HIDE);
LONG buttonWidth=cellWidth*static_cast<LONG>(buttons.size()-1);
for(const auto id:buttons)
{
const auto rect=dialogControlBounds(window,id);
buttonWidth+=rect.right-rect.left;
}
LONG contentWidth=buttonWidth;
if(const auto dc=GetDC(window))
{
const auto previous=SelectObject(dc,mono);
const auto measure=[&](const wchar_t *text)
{
RECT rect{};
DrawTextW(dc,text,-1,&rect,DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);
contentWidth=std::max(contentWidth,rect.right);
};
measure(data->message);
std::wistringstream names(data->entries);
for(std::wstring name;std::getline(names,name);)
{
if(!name.empty() && name.back()==L'\r') name.pop_back();
measure(name.c_str());
}
SelectObject(dc,previous);
ReleaseDC(window,dc);
}
MONITORINFO monitor{sizeof(monitor)};
if(GetMonitorInfoW(MonitorFromWindow(GetWindow(window,GW_OWNER),MONITOR_DEFAULTTONEAREST),&monitor))
contentWidth=std::min(contentWidth,std::max(buttonWidth,monitor.rcWork.right-monitor.rcWork.left-2*entries.left));
RECT outer{};
GetWindowRect(window,&outer);
const auto width=contentWidth+2*entries.left;
SetWindowPos(window,nullptr,0,0,width,outer.bottom-outer.top,SWP_NOMOVE|SWP_NOZORDER|SWP_NOACTIVATE);
for(const auto id:{240,241})
{
const auto control=GetDlgItem(window,id);
const bool centered=id==240 || data->lines==1;
SetWindowLongPtrW(control,GWL_STYLE,
(GetWindowLongPtrW(control,GWL_STYLE)&~SS_TYPEMASK)|(centered?SS_CENTER:SS_LEFT)|SS_NOPREFIX);
SetWindowPos(control,nullptr,entries.left,id==240?question.top:entries.top,
contentWidth,(id==240?1:data->lines)*textHeight,SWP_NOZORDER|SWP_NOACTIVATE);
}
SetWindowPos(GetDlgItem(window,243),nullptr,entries.left,entries.top+data->lines*textHeight+10,0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
auto x=(width-buttonWidth)/2;
for(const auto id:buttons)
{
const auto rect=dialogControlBounds(window,id);
SetWindowPos(GetDlgItem(window,id),nullptr,x,rect.top,0,0,
SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE);
x+=rect.right-rect.left+cellWidth;
}
if(data->readOnlyPrompt) layoutDialogButtons(window,243,{IDYES,244,IDNO,249,IDCANCEL});
else if(data->folderPrompt) layoutDialogButtons(window,243,{IDYES,244,IDNO,IDCANCEL});
else layoutDialogButtons(window,243,{IDYES,IDCANCEL});
SendMessageW(window,DM_SETDEFID,IDCANCEL,0);
SetFocus(GetDlgItem(window,IDCANCEL));
return FALSE;
}
if(message==WM_CLOSE || (message==WM_COMMAND && LOWORD(wp)==IDCANCEL))
{
finishFilesDialog(window,IDCANCEL);
return TRUE;
}
if(message==WM_COMMAND && (LOWORD(wp)==IDYES ||
((data->folderPrompt || data->readOnlyPrompt) && (LOWORD(wp)==244 || LOWORD(wp)==IDNO)) ||
(data->readOnlyPrompt && LOWORD(wp)==249)))
{
finishFilesDialog(window,LOWORD(wp));
return TRUE;
}
return FALSE;
}
INT_PTR CALLBACK deleteProgressDialog(HWND window,UINT message,WPARAM wp,LPARAM lp)
{
if(const auto painted=paintCopyDialog(window,message,wp,lp,L" Delete ",false,{248}))
return painted;
if(message==WM_INITDIALOG)
{
prepareCopyDialog(window);
layoutDialogContent(window,245);
SetWindowLongPtrW(window,DWLP_USER,lp);
for(const auto id:{245,246})
SendDlgItemMessageW(window,id,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
SetWindowSubclass(GetDlgItem(window,247),paintCopyProgressBar,1,0);
layoutDialogButtons(window,248,{IDCANCEL});
return TRUE;
}
if(message==WM_CLOSE || (message==WM_COMMAND && LOWORD(wp)==IDCANCEL))
{
auto &canceled=*reinterpret_cast<bool*>(GetWindowLongPtrW(window,DWLP_USER));
if(!canceled)
canceled=confirmOperationCancellation(window,L"Do you really want to cancel deletion?");
return TRUE;
}
return FALSE;
}
bool pumpDeletion(HWND window,bool &canceled)
{
MSG message{};
while(!canceled && PeekMessageW(&message,nullptr,0,0,PM_REMOVE))
{
if(message.message==WM_QUIT)
{
PostQuitMessage(static_cast<int>(message.wParam));
canceled=true;
break;
}
if(!filesDialogHandlesMessage(window,message))
{
TranslateMessage(&message);
DispatchMessageW(&message);
}
}
return !canceled;
}
void deleteSelection(HWND owner,Panel &panel,bool permanent)
{
if(copyInProgress) return;
std::vector<fs::path> paths;
for(size_t i=0;i<panel.rows.size();++i)
if(panel.marked[i] && panel.sizes[i]!=L"Up") paths.push_back(panel.rows[i]);
if(paths.empty())
{
const auto row=SendMessageW(panel.list,LB_GETCURSEL,0,0);
if(row<0 || static_cast<size_t>(row)>=panel.rows.size() || panel.sizes[row]==L"Up") return;
paths.push_back(panel.rows[row]);
}
const auto shown=std::min<size_t>(paths.size(),10);
std::wstring entries;
for(size_t i=0;i<shown;++i)
{
if(i) entries+=L"\r\n";
entries+=paths[i].filename().wstring();
}
if(shown<paths.size()) entries+=L"\r\n…and "+std::to_wstring(paths.size()-shown)+L" more";
const auto instance=GetModuleHandleW(nullptr);
warningBrush=CreateSolidBrush(RGB(128,0,0));
const wchar_t *message=permanent?L"Delete the selected items permanently?":
L"Move the selected items to the Recycle Bin?";
if(paths.size()==1)
{
DWORD attributes=INVALID_FILE_ATTRIBUTES;
try
{
FilesConnection host(panel.peer?&*panel.peer:nullptr);
if(const auto info=statFile(host,paths.front())) attributes=info->attributes;
}
catch(const std::system_error &e){setStatus(fileError(e));DeleteObject(warningBrush);warningBrush=nullptr;return;}
catch(const std::exception &){setStatus(L"File connection interrupted.");DeleteObject(warningBrush);warningBrush=nullptr;return;}
if(attributes!=INVALID_FILE_ATTRIBUTES)
message=attributes&FILE_ATTRIBUTE_DIRECTORY
? (permanent?L"Delete this folder permanently?":L"Move this folder to the Recycle Bin?")
: (permanent?L"Delete this file permanently?":L"Move this file to the Recycle Bin?");
}
DeleteConfirmation confirmation{message,entries,static_cast<int>(shown+(shown<paths.size())),
permanent,false};
if(runFilesDialog(instance,MAKEINTRESOURCEW(106),owner,deleteConfirmationDialog,
reinterpret_cast<LPARAM>(&confirmation))!=IDYES)
{
DeleteObject(warningBrush);
warningBrush=nullptr;
// The dialog owns focus until DialogBoxParamW returns. Restore the invoking list.
SetFocus(panel.list);
return;
}
bool canceled=false;
const auto window=CreateDialogParamW(instance,MAKEINTRESOURCEW(107),owner,deleteProgressDialog,
reinterpret_cast<LPARAM>(&canceled));
if(window)
{
GetWindowRect(owner,&previousOwnerBounds);
FilesDialogInput progressInput(window);
ShowWindow(window,SW_SHOW);
size_t done=0, skipped=0, failed=0, total=0;
bool all=false;
int readOnlyChoice=0;
std::vector<std::vector<fs::path>> groups;
std::wstring failure;
try
{
FilesConnection host(panel.peer?&*panel.peer:nullptr);
const auto collect=[&](auto &&self,const fs::path &path,std::vector<fs::path> &group)->void
{
for(const auto &[child,info]:childrenOf(host,path))
{
if(!pumpDeletion(window,canceled)) return;
group.push_back(child);
if((info.attributes&FILE_ATTRIBUTE_DIRECTORY) && !(info.attributes&FILE_ATTRIBUTE_REPARSE_POINT))
self(self,child,group);
}
};
for(const auto &path:paths)
{
if(!pumpDeletion(window,canceled)) break;
auto &group=groups.emplace_back(1,path);
if(permanent)
{
try
{
const auto info=statFile(host,path);
if(info && (info->attributes&FILE_ATTRIBUTE_DIRECTORY) &&
!(info->attributes&FILE_ATTRIBUTE_REPARSE_POINT)) collect(collect,path,group);
}
catch(const std::system_error &e)
{
failure=fileError(e);
++failed;
++total;
group.clear();
}
}
total+=group.size();
}
ULONGLONG lastPaint=0;
fs::path current;
const auto update=[&](const fs::path &path,bool force)
{
const auto now=GetTickCount64();
if(!force && now-lastPaint<200) return;
lastPaint=now;
SetDlgItemTextW(window,245,path.c_str());
const auto status=(permanent?L"Deleted: ":L"Moved: ")+std::to_wstring(done)+L" / "+std::to_wstring(total)+
L" Skipped: "+std::to_wstring(skipped)+L" Failed: "+std::to_wstring(failed);
SetDlgItemTextW(window,246,status.c_str());
const auto bar=GetDlgItem(window,247);
SendMessageW(bar,PBM_SETPOS,total?static_cast<int>(100.0*(done+skipped+failed)/total):0,0);
InvalidateRect(bar,nullptr,FALSE);
};
for(const auto &group:groups)
{
if(!pumpDeletion(window,canceled)) break;
if(group.empty()) continue;
if(group.size()>1 && !all)
{
DeleteConfirmation folder{L"The following folder will be deleted:",group.front().wstring(),1,true,true};
const auto answer=runFilesDialog(instance,MAKEINTRESOURCEW(106),window,deleteConfirmationDialog,
reinterpret_cast<LPARAM>(&folder));
if(answer==244) all=true;
else if(answer==IDNO)
{
skipped+=group.size();
update(group.front(),false);
continue;
}
else if(answer!=IDYES) { canceled=true; break; }
}
for(auto it=group.rbegin();it!=group.rend() && pumpDeletion(window,canceled);++it)
{
current=*it;
update(current,false);
bool readOnly=false;
try
{
const auto info=permanent?statFile(host,current):std::optional<FileInfo>{};
const auto attributes=info?info->attributes:INVALID_FILE_ATTRIBUTES;
if(attributes!=INVALID_FILE_ATTRIBUTES && (attributes&FILE_ATTRIBUTE_READONLY) &&
!(attributes&FILE_ATTRIBUTE_DIRECTORY))
{
auto answer=static_cast<INT_PTR>(readOnlyChoice);
if(!answer)
{
DeleteConfirmation warning{L"Delete this read-only file?",current.wstring(),1,true,false,true};
answer=runFilesDialog(instance,MAKEINTRESOURCEW(106),window,deleteConfirmationDialog,
reinterpret_cast<LPARAM>(&warning));
if(answer==244 || answer==249) readOnlyChoice=static_cast<int>(answer);
}
if(answer==IDNO || answer==249)
{
++skipped;
continue;
}
if(answer!=IDYES && answer!=244)
{
canceled=true;
break;
}
if(attributes&FILE_ATTRIBUTE_REPARSE_POINT)
throw std::system_error(ERROR_ACCESS_DENIED,std::system_category());
readOnly=true;
}
if(!permanent && !panel.peer)
{
if(!ks::lan::recycleFile(window,current))
throw std::system_error(ERROR_ACCESS_DENIED,std::system_category());
}
else
{
auto request=fileRequest(permanent?"remove":"recycle",current);
request["readOnly"]=readOnly;
checkFileReply(host.call(request));
}
++done;
}
catch(const std::system_error &e)
{
++failed;
failure=fileError(e);
if(e.code().value()>=10000) break;
}
}
}
update(current,true);
}
catch(const std::system_error &e){++failed;failure=fileError(e);}
catch(const std::exception &){++failed;failure=L"File connection interrupted.";}
RedrawWindow(window,nullptr,nullptr,RDW_UPDATENOW|RDW_ALLCHILDREN);
DestroyWindow(window);
for(auto &visible:panels)
if(!visible.directory.empty()) open(visible,visible.directory);
SetFocus(panel.list);
setStatus((canceled?L"Deletion canceled. ":L"Deletion finished. ")+
std::to_wstring(done)+(permanent?L" deleted, ":L" moved to Recycle Bin, ")+
std::to_wstring(skipped)+L" skipped, "+std::to_wstring(failed)+L" failed."+(failure.empty()?L"":L" "+failure));
}
else setStatus(L"Could not open deletion progress.");
DeleteObject(warningBrush);
warningBrush=nullptr;
}
void selectPanelEdge(Panel &panel,bool first)
{
activatePanel(static_cast<int>(&panel-panels));
const auto count=SendMessageW(panel.list,LB_GETCOUNT,0,0);
if(count<=0) return;
SendMessageW(panel.list,LB_SETCURSEL,first?0:count-1,0);
InvalidateRect(panel.list,nullptr,FALSE);
showFileDetails(panel);
}
LRESULT CALLBACK panelKeys(HWND window, UINT message, WPARAM wp, LPARAM lp, UINT_PTR, DWORD_PTR index)
{
if(message==WM_LBUTTONDOWN)
{
const auto count=SendMessageW(window,LB_GETCOUNT,0,0);
RECT last{};
if(count>0 && SendMessageW(window,LB_GETITEMRECT,count-1,reinterpret_cast<LPARAM>(&last))!=LB_ERR &&
GET_Y_LPARAM(lp)>=last.bottom)
{
selectPanelEdge(panels[index],false);
return 0;
}
}
const bool rangeKey=wp==VK_UP || wp==VK_DOWN || wp==VK_LEFT || wp==VK_RIGHT;
if(message==WM_KEYDOWN && (wp==VK_INSERT || (rangeKey && (GetKeyState(VK_SHIFT)&0x8000))))
{
auto &panel=panels[index];
const auto row=SendMessageW(window,LB_GETCURSEL,0,0);
if(row<0 || static_cast<size_t>(row)>=panel.marked.size()) return 0;
const auto last=static_cast<LRESULT>(panel.marked.size()-1);
auto target=row;
switch(wp)
{
case VK_UP: target=std::max<LRESULT>(0,row-1); break;
case VK_LEFT: target=0; break;
case VK_RIGHT: target=last; break;
default: target=std::min(last,row+1); break;
}
const bool mark=!panel.marked[row];
const bool toBoundary=wp==VK_LEFT || wp==VK_RIGHT;
const auto first=toBoundary ? std::min(row,target) : row;
const auto end=toBoundary ? std::max(row,target) : row;
for(auto i=first;i<=end;++i)
if(panel.sizes[i]!=L"Up") panel.marked[i]=mark;
SendMessageW(window,LB_SETCURSEL,target,0);
InvalidateRect(window,nullptr,FALSE);
showFileDetails(panel);
return 0;
}
if (message == WM_KEYDOWN && (wp == VK_LEFT || wp == VK_RIGHT))
return scrollList(window, message, wp == VK_LEFT ? VK_HOME : VK_END, lp);
if(message==WM_SETFOCUS) activatePanel(static_cast<int>(index));
if(message==WM_CHAR && wp>=32 && wp!=127)
{
SetFocus(terminalInput);
return SendMessageW(terminalInput,message,wp,lp);
}
if (message == WM_KEYDOWN)
{
if(wp==VK_TAB) { activatePanel(static_cast<int>(1-index)); SetFocus(terminalInput); return 0; }
if (wp == VK_RETURN) { enter(panels[index]); return 0; }
if (wp == VK_F2) { open(panels[index], panels[index].directory); return 0; }
if (wp == VK_F10) { SendMessageW(GetParent(window), WM_CLOSE, 0, 0); return 0; }
if (wp == VK_F3 || wp == VK_F4)
{
const auto &panel = panels[index];
const auto row=currentPanelRow(panel);
if(row==LB_ERR) return 0;
const bool edit = wp == VK_F4;
openPanelFile(panel, panel.rows[row], edit ? L"edit" : L"open",
edit ? L"No editor is registered for this file." : L"Cannot open the selected file.");
return 0;
}
if (wp == VK_F5 || wp == VK_F6)
{
copySelection(GetParent(window),panels[index],panels[1-index],wp==VK_F6);
return 0;
}
if(wp==VK_F8 || (wp==VK_DELETE && (GetKeyState(VK_SHIFT)&0x8000)))
{
deleteSelection(GetParent(window),panels[index],wp==VK_DELETE);
return 0;
}
}
auto result=scrollList(window, message, wp, lp);
if(message==WM_PAINT && panels[index].wide)
{
auto dc=GetDC(window);
if(dc)
{
RECT line{};
GetClientRect(window,&line);
line.left=std::max(0L,line.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
line.right=line.left+1;
SetDCBrushColor(dc,colors[Frame]);
FillRect(dc,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
ReleaseDC(window,dc);
}
}
return result;
}
#include "files_folder_shortcuts.inl"
#include "files_command_history_dialog.inl"
bool loadFilesPreferences(HWND window)
{
LOGFONTW font{};
DWORD bytes=sizeof(font);
if(RegGetValueW(HKEY_CURRENT_USER,schemeKey,L"DisplayFont",RRF_RT_REG_BINARY,nullptr,&font,&bytes)
!=ERROR_SUCCESS || bytes!=sizeof(font))
{
font=defaultFilesFont();
}
font.lfFaceName[LF_FACESIZE-1]=0;
if(!applyFont(window,font,static_cast<int>(std::clamp(preference(L"FontPoints",defaultFontPoints),80UL,240UL)))) return false;
loadColors();
dialogFramePadding={
std::min(preference(dialogFrameOuterKey,defaultDialogFramePadding.outer),maxDialogFramePadding),
std::min(preference(dialogFrameInnerKey,defaultDialogFramePadding.inner),maxDialogFramePadding),
std::min(preference(dialogRowTextKey,defaultDialogFramePadding.rowText),maxDialogRowTextPadding)};
loadFileStyles();
loadFolderShortcuts();
panels[0].wide=preference(L"LeftWide",defaultWide)!=0;
panels[1].wide=preference(L"RightWide",defaultWide)!=0;
sizeWidth=static_cast<int>(std::clamp(preference(L"SizeWidth",defaultSizeWidth),6UL,16UL));
alignExtensions=preference(L"AlignExtensions",defaultAlignExtensions)!=0;
showDetails=preference(L"ShowDetails",defaultShowDetails)!=0;
alignFolders=preference(L"AlignFolders",defaultAlignFolders)!=0;
statusFields=preference(L"StatusFields",defaultStatusFields)&15;
loadCommandHistoryKeys();
return true;
}
#include "files_options.inl"
void openMenu(HWND window, int index)
{
if(index==3)
{
hidePicker();
showMenu(false);
editOptions(window);
return;
}
menuIndex=index;
commandPicker=true;
SendMessageW(picker,LB_RESETCONTENT,0,0);
std::vector<std::wstring> rows;
if(index==0 || index==4)
{
const bool wide=panels[index==4].wide;
rows={wide?L" Brief":L"✓ Brief",
wide?L"✓ Wide":L" Wide",
index==0?L" Change drive\tAlt+F1":L" Change drive\tAlt+F2"};
}
else if(index==1) rows={L"Copy\tF5",L"Move\tF6",L"Exit\tF10"};
else if(index==2) rows={L"Refresh\tF2",L"View\tF3",L"Edit\tF4",L"Folder shortcuts"};
std::set<wchar_t> used;
commandAccessPositions.assign(rows.size(),std::wstring::npos);
const auto reserve=[&](size_t row,wchar_t key)
{
const auto &text=rows[row];
for(size_t pos=0;pos<text.size() && text[pos]!=L'\t';++pos)
if(towupper(text[pos])==key && used.insert(key).second)
{
commandAccessPositions[row]=pos;
return true;
}
return false;
};
if(index==0 || index==4) {reserve(0,L'B');reserve(1,L'W');reserve(2,L'C');}
if(index==1) {reserve(0,L'C');reserve(2,L'X');}
if(index==2) {reserve(1,L'V');reserve(2,L'E');}
for(size_t i=0;i<rows.size();++i)
{
const auto &text=rows[i];
if(commandAccessPositions[i]==std::wstring::npos)
for(const auto ch:text)
{
if(ch==L'\t') break;
const auto key=towupper(ch);
if(key>=L'A' && key<=L'Z' && reserve(i,static_cast<wchar_t>(key))) break;
}
SendMessageW(picker,LB_ADDSTRING,0,reinterpret_cast<LPARAM>(text.c_str()));
}
RECT anchor{}, client{};
GetWindowRect(menuItems[index],&anchor);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&anchor),2);
GetClientRect(window,&client);
const int inset=dialogFrameMetrics(GetDpiForWindow(window)).content();
const int width=std::max(1,std::min(static_cast<int>(client.right)-2*inset,26*cellWidth+16));
const int x=std::clamp(static_cast<int>(anchor.left)+inset,inset,
std::max(inset,static_cast<int>(client.right)-width-inset));
const int y=anchor.bottom+5;
const int height=static_cast<int>(rows.size())*static_cast<int>(SendMessageW(picker,LB_GETITEMHEIGHT,0,0));
SetWindowPos(pickerFrame,HWND_TOP,x-inset,y-inset,width+2*inset,height+2*inset,SWP_SHOWWINDOW);
SetWindowPos(picker,HWND_TOP,x,y,width,height,SWP_SHOWWINDOW);
SendMessageW(picker,LB_SETCURSEL,0,0);
SetFocus(picker);
showMenu(true);
}
void toggleFilesMenu()
{
const bool visible=IsWindowVisible(menuBar);
hidePicker();
if(!visible) menuIndex=active==0?0:4;
showMenu(!visible);
if(visible) SetFocus(panels[active].list);
}
bool handleFilesMenuKey(HWND window,UINT message,WPARAM key,LPARAM flags,bool modified)
{
const bool repeated=(flags & (1LL << 30))!=0;
if(message==WM_SYSKEYDOWN && key==VK_MENU)
{
return !modified;
}
if((message==WM_SYSKEYUP || message==WM_KEYUP) && key==VK_MENU)
return !modified;
if(message!=WM_KEYDOWN && message!=WM_SYSKEYDOWN) return false;
if(modified) return false;
if(message==WM_KEYDOWN && key==VK_F9)
{
if(!repeated) toggleFilesMenu();
return true;
}
if(IsWindowVisible(menuBar) && message==WM_SYSKEYDOWN &&
(flags & (1LL << 29)) && key>=L'A' && key<=L'Z')
{
const auto category=menuAccessKeys.find(static_cast<wchar_t>(key));
if(category!=menuAccessKeys.npos)
{
if(!repeated) openMenu(window,static_cast<int>(category));
return true;
}
}
return false;
}
void searchPanelByPrefix(HWND window,wchar_t character)
{
if(character==L'\b')
{
if(!panelSearchPrefix.empty()) panelSearchPrefix.pop_back();
}
else panelSearchPrefix+=character;
auto &panel=panels[active];
const auto length=static_cast<int>(panelSearchPrefix.size());
for(size_t row=0;length && row<panel.rows.size();++row)
{
if(panel.sizes[row]==L"Up") continue;
const auto name=panel.rows[row].filename().native();
if(name.size()<panelSearchPrefix.size() ||
CompareStringOrdinal(name.data(),length,panelSearchPrefix.data(),length,TRUE)!=CSTR_EQUAL)
continue;
SendMessageW(panel.list,LB_SETCURSEL,row,0);
InvalidateRect(panel.list,nullptr,FALSE);
showFileDetails(panel);
if(!IsWindowVisible(panelSearchPopup))
{
placePanelSearch(window);
ShowWindow(panelSearchPopup,SW_SHOWNA);
}
break;
}
if(IsWindowVisible(panelSearchPopup)) InvalidateRect(panelSearchPopup,nullptr,FALSE);
else panelSearchPrefix.clear();
}
bool handlePanelSearchKey(HWND window,MSG &message)
{
const bool searching=IsWindowVisible(panelSearchPopup);
if(message.message==WM_LBUTTONDOWN || message.message==WM_RBUTTONDOWN ||
message.message==WM_NCLBUTTONDOWN || message.message==WM_MOUSEWHEEL)
{
if(searching && message.hwnd!=panelSearchPopup) closePanelSearch();
return false;
}
const bool input=message.hwnd==terminalInput || message.hwnd==panels[0].list ||
message.hwnd==panels[1].list;
if(!input || terminalVisible || IsWindowVisible(menuBar) || IsWindowVisible(picker)) return false;
const bool modified=(GetKeyState(VK_CONTROL)&0x8000) || (GetKeyState(VK_LWIN)&0x8000) ||
(GetKeyState(VK_RWIN)&0x8000);
const bool alt=(message.lParam & (1LL<<29))!=0;
if((message.message==WM_SYSCHAR && alt) || (searching && message.message==WM_CHAR))
{
if(!modified && (message.wParam==L'\b' ||
(message.wParam>=32 && message.wParam!=127 && (!alt || message.wParam!=L' '))))
{
searchPanelByPrefix(window,static_cast<wchar_t>(message.wParam));
return true;
}
return false;
}
if(message.message!=WM_KEYDOWN && message.message!=WM_SYSKEYDOWN) return false;
if(!modified && message.wParam!=VK_SPACE && message.message==WM_SYSKEYDOWN && alt &&
(message.wParam==VK_BACK || MapVirtualKeyW(static_cast<UINT>(message.wParam),MAPVK_VK_TO_CHAR)))
{
TranslateMessage(&message);
return true;
}
if(!searching || message.wParam==VK_MENU || message.wParam==VK_SHIFT) return false;
if(!modified && !alt && (message.wParam==VK_BACK ||
MapVirtualKeyW(static_cast<UINT>(message.wParam),MAPVK_VK_TO_CHAR)) &&
message.wParam!=VK_RETURN && message.wParam!=VK_ESCAPE && message.wParam!=VK_TAB)
{
TranslateMessage(&message);
return true;
}
closePanelSearch();
if(message.wParam==VK_RETURN && !modified && !alt)
{
SendMessageW(panels[active].list,message.message,message.wParam,message.lParam);
return true;
}
return message.wParam==VK_ESCAPE && !modified && !alt;
}
void restoreCommandFocus()
{
if(GetFocus()!=terminalInput && !GetCapture() && !copyInProgress && !activeFilesDialog &&
!commandHistoryWindow && !IsWindowVisible(menuBar) && !IsWindowVisible(picker))
SetFocus(terminalInput);
}
LRESULT CALLBACK filesWindow(HWND window, UINT message, WPARAM wp, LPARAM lp)
{
if(message==filesPreferencesChanged)
{
if(reinterpret_cast<HWND>(wp)!=window)
{
loadFilesPreferences(window);
layout(window);
layoutOpenCommandHistory();
showFileDetails(panels[active]);
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
}
return 0;
}
switch (message)
{
case WM_SETFOCUS:
restoreCommandFocus();
return 0;
case WM_ACTIVATEAPP:
if(!wp) closePanelSearch();
break;
case WM_COPYDATA:
{
const auto *reply=reinterpret_cast<const COPYDATASTRUCT*>(lp);
if(!drivePeerService || reinterpret_cast<HWND>(wp)!=drivePeerService || !reply ||
reply->dwData!=FilesLanPeersReply || reply->cbData>FilesLanPeersLimit ||
(!reply->cbData || !reply->lpData)) return FALSE;
try
{
const auto *begin=static_cast<const char*>(reply->lpData);
const auto rows=Json::parse(begin,begin+reply->cbData);
if(!rows.is_array()) return FALSE;
for(const auto &row:rows)
drivePeers.push_back({row.at("id"),row.at("address"),ks::wide(row.at("name")),ks::lan::FilesPort,row.value("filesBrowse",false)});
}
catch(const std::exception &){drivePeers.clear();return FALSE;}
drivePeerReplyReceived=true;
return TRUE;
}
case WM_TIMER:
if(wp==driveQueryTimer) {pollDriveQueries(window);return 0;}
if(wp==terminalTimer) { updateTerminalOutput(); return 0; }
if(wp==directoryWatchTimer) { refreshChangedPanels(); return 0; }
if(wp!=transferHighlightTimer) break;
++transferHighlightPhase;
for(auto &panel:panels)
{
if(panel.transferResults.empty()) continue;
if(transferHighlightPhase==4) panel.transferResults.clear();
InvalidateRect(panel.list,nullptr,FALSE);
}
if(transferHighlightPhase==4) KillTimer(window,transferHighlightTimer);
return 0;
case WM_CREATE:
{
auto instance = GetModuleHandleW(nullptr);
if(!loadFilesPreferences(window)) return -1;
menuBar=CreateWindowW(L"BUTTON",L"",WS_CHILD|WS_CLIPSIBLINGS|BS_OWNERDRAW,
0,0,0,0,window,reinterpret_cast<HMENU>(120),instance,nullptr);
const wchar_t *menus[]{L"Left",L"Files",L"Commands",L"Options",L"Right"};
for(int i=0;i<5;++i)
{
menuItems[i]=CreateWindowW(L"BUTTON",menus[i],WS_CHILD|WS_CLIPSIBLINGS|BS_OWNERDRAW,
0,0,0,0,window,reinterpret_cast<HMENU>(130+static_cast<INT_PTR>(i)),instance,nullptr);
if(!menuItems[i]) return -1;
}
picker=CreateWindowExW(0,L"LISTBOX",L"Change drive",
WS_CHILD|WS_CLIPSIBLINGS|LBS_NOTIFY|LBS_OWNERDRAWFIXED|LBS_HASSTRINGS|LBS_NOINTEGRALHEIGHT,
0,0,0,0,window,reinterpret_cast<HMENU>(121),instance,nullptr);
pickerFrame=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_CLIPSIBLINGS|SS_OWNERDRAW,
0,0,0,0,window,reinterpret_cast<HMENU>(122),instance,nullptr);
SetWindowSubclass(picker,pickerKeys,1,0);
SendMessageW(picker,LB_SETITEMHEIGHT,0,textHeight);
status = CreateWindowW(L"STATIC", L"", WS_CHILD | WS_VISIBLE | SS_PATHELLIPSIS,
0, 0, 0, 0, window, reinterpret_cast<HMENU>(144), instance, nullptr);
panelSearchPopup=CreateWindowW(L"STATIC",L"Search",WS_CHILD|WS_CLIPSIBLINGS|SS_OWNERDRAW|SS_NOTIFY,
0,0,0,0,window,reinterpret_cast<HMENU>(148),instance,nullptr);
terminalInput=CreateWindowW(L"EDIT",L"",WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL,
0,0,0,0,window,nullptr,instance,nullptr);
terminalPrompt=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_VISIBLE|SS_PATHELLIPSIS,
0,0,0,0,window,nullptr,instance,nullptr);
terminalOutput=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_CLIPCHILDREN,
0,0,0,0,window,reinterpret_cast<HMENU>(145),instance,nullptr);
terminalBackground=CreateSolidBrush(RGB(24,24,24));
if(!terminalInput || !terminalOutput || !terminalPrompt || !terminalBackground) return -1;
for(const auto control:{terminalInput,terminalOutput,terminalPrompt})
SendMessageW(control,WM_SETFONT,reinterpret_cast<WPARAM>(mono),FALSE);
SendMessageW(terminalInput,EM_SETLIMITTEXT,2048,0);
SendMessageW(terminalInput,EM_SETMARGINS,EC_LEFTMARGIN|EC_RIGHTMARGIN,0);
SetWindowSubclass(terminalInput,terminalInputKeys,1,0);
SetTimer(window,terminalTimer,50,nullptr);
SetTimer(window,directoryWatchTimer,200,nullptr);
if (!mono || !blue || !teal || !menuBar || !picker || !pickerFrame || !status || !panelSearchPopup) return -1;
SendMessageW(status, WM_SETFONT, reinterpret_cast<WPARAM>(mono), FALSE);
const wchar_t *labels[]{L"F2 Refresh", L"F3 View", L"F4 Edit", L"F5 Copy", L"F6 Move", L"F10 Exit"};
for (int i = 0; i < static_cast<int>(std::size(commands)); ++i)
commands[i] = CreateWindowW(L"BUTTON", labels[i], WS_CHILD | WS_VISIBLE | BS_OWNERDRAW,
0, 0, 0, 0, window, reinterpret_cast<HMENU>(110 + static_cast<INT_PTR>(i)), instance, nullptr);
for (int i = 0; i < 2; ++i)
{
auto &panel = panels[i];
panel.path = CreateWindowW(L"STATIC", L"", WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | SS_OWNERDRAW,
0, 0, 0, 0, window, reinterpret_cast<HMENU>(142 + static_cast<INT_PTR>(i)), instance, nullptr);
panel.list = CreateWindowExW(0, L"LISTBOX", L"",
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS,
0, 0, 0, 0, window, reinterpret_cast<HMENU>(102 + static_cast<INT_PTR>(i)), instance, nullptr);
panel.heading=CreateWindowW(L"STATIC",L"",WS_CHILD|WS_CLIPSIBLINGS|SS_OWNERDRAW,
0,0,0,0,window,reinterpret_cast<HMENU>(140+static_cast<INT_PTR>(i)),instance,nullptr);
if (!panel.path || !panel.list || !panel.heading) return -1;
for (auto child : {panel.path, panel.list})
SendMessageW(child, WM_SETFONT, reinterpret_cast<WPARAM>(mono), FALSE);
SendMessageW(panel.list,LB_SETITEMHEIGHT,0,textHeight);
wchar_t system[MAX_PATH]{};
GetWindowsDirectoryW(system, MAX_PATH);
const auto saved=savedPanelPath(panelPathKeys[i]);
if(saved.is_absolute()) open(panel,saved);
if(!panel.directory.empty())
{
const auto cursor=savedPanelPath(panelCursorKeys[i]);
const auto row=std::find(panel.rows.begin(),panel.rows.end(),cursor);
if(row!=panel.rows.end()) SendMessageW(panel.list,LB_SETCURSEL,row-panel.rows.begin(),0);
}
if(panel.directory.empty()) open(panel,fs::path(system).root_path());
SetWindowSubclass(panel.list, panelKeys, 1, i);
}
SetFocus(panels[0].list);
return 0;
}
case WM_DPICHANGED:
{
hidePicker();
const auto &bounds=*reinterpret_cast<const RECT*>(lp);
applyFont(window,displayFont,fontPoints);
SetWindowPos(window,nullptr,bounds.left,bounds.top,bounds.right-bounds.left,
bounds.bottom-bounds.top,SWP_NOZORDER|SWP_NOACTIVATE);
layout(window);
if(activeCopy) PostMessageW(activeCopy->window,refreshProgressLayout,0,0);
RedrawWindow(window,nullptr,nullptr,RDW_INVALIDATE|RDW_ALLCHILDREN);
return 0;
}
case WM_MOVE:
layoutOpenCommandHistory(true);
if((copyInProgress || activeFilesDialog) && !IsIconic(window))
{
RECT bounds{};
if(GetWindowRect(window,&bounds))
{
const OwnedWindowMove move{window,bounds.left-previousOwnerBounds.left,
bounds.top-previousOwnerBounds.top};
previousOwnerBounds=bounds;
if(move.dx || move.dy)
EnumThreadWindows(GetCurrentThreadId(),moveOwnedDialog,reinterpret_cast<LPARAM>(&move));
}
}
return 0;
case WM_SIZE:
hidePicker();
layout(window);
layoutOpenCommandHistory();
return 0;
case WM_GETMINMAXINFO:
reinterpret_cast<MINMAXINFO *>(lp)->ptMinTrackSize = {540, 220};
return 0;
case WM_SETCURSOR:
case WM_LBUTTONDOWN:
{
POINT point{};
GetCursorPos(&point);
ScreenToClient(window, &point);
RECT rect{};
GetClientRect(window, &rect);
const int width = rect.right;
int middle = std::clamp(split ? split : width / 2, 120, std::max(120, width - 120));
if (point.y >= 0 && point.y < rect.bottom-2*textHeight-14 && abs(point.x - middle) <= 4)
{
SetCursor(LoadCursorW(nullptr, IDC_SIZEWE));
if (message == WM_LBUTTONDOWN) { dragging = true; SetCapture(window); }
return TRUE;
}
if(message==WM_LBUTTONDOWN && !terminalVisible)
{
for(auto &panel:panels)
{
RECT list{};
if(!GetWindowRect(panel.list,&list)) continue;
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&list),2);
if(point.x>=list.left && point.x<list.right && point.y>=0 && point.y<list.top)
{
selectPanelEdge(panel,true);
return 0;
}
}
}
break;
}
case WM_MOUSEMOVE:
if (dragging) { split = std::max(1, GET_X_LPARAM(lp)); layout(window); }
return 0;
case WM_LBUTTONUP:
if (dragging) ReleaseCapture();
return 0;
case WM_CAPTURECHANGED:
dragging = false;
return 0;
case WM_ERASEBKGND:
return 1;
case WM_PAINT:
{
PAINTSTRUCT paint{};
auto dc=BeginPaint(window,&paint);
FillRect(dc,&paint.rcPaint,blue);
auto border=CreateSolidBrush(colors[Frame]);
for(const auto &panel:panels)
{
if(terminalVisible) break;
RECT box{};
GetWindowRect(panel.list,&box);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&box),2);
const LONG columnX=std::max(box.left,box.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
box.right+=5;
InflateRect(&box,2,2);
box.left-=2;
RECT pathBounds{};
GetWindowRect(panel.path,&pathBounds);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&pathBounds),2);
box.top=pathBounds.top+(pathBounds.bottom-pathBounds.top)/2-2;
RECT details{};
GetWindowRect(status,&details);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&details),2);
const RECT divider{box.left+1,box.bottom-2,box.right-1,box.bottom-1};
box.bottom=std::max(box.bottom,details.bottom+6);
FrameRect(dc,&box,border);
paintScrollPosition(window,dc,panel.list,colors[PanelBlue]);
InflateRect(&box,-3,-3);
FrameRect(dc,&box,border);
FillRect(dc,&divider,border);
if(panel.wide)
{
RECT column{columnX,box.top+1,columnX+1,pathBounds.bottom+6};
FillRect(dc,&column,border);
}
}
DeleteObject(border);
EndPaint(window,&paint);
return 0;
}
case WM_CTLCOLOREDIT:
case WM_CTLCOLORSTATIC:
{
auto dc=reinterpret_cast<HDC>(wp);
if(reinterpret_cast<HWND>(lp)==terminalInput || reinterpret_cast<HWND>(lp)==terminalOutput ||
reinterpret_cast<HWND>(lp)==terminalPrompt)
{
SetTextColor(dc,RGB(232,232,232));
SetBkColor(dc,RGB(24,24,24));
return reinterpret_cast<LRESULT>(terminalBackground);
}
SetTextColor(dc,colors[Frame]);
SetBkColor(dc,colors[PanelBlue]);
return reinterpret_cast<LRESULT>(blue);
}
case WM_CTLCOLORLISTBOX:
return reinterpret_cast<LRESULT>(reinterpret_cast<HWND>(lp)==picker?teal:blue);
case WM_DRAWITEM:
{
const auto &item=*reinterpret_cast<const DRAWITEMSTRUCT *>(lp);
if(item.hwndItem==panelSearchPopup)
{
const auto frame=dialogFrameMetrics(GetDpiForWindow(window));
const auto surface=GetSysColorBrush(COLOR_BTNFACE);
const auto border=GetSysColorBrush(COLOR_BTNTEXT);
const auto ink=GetSysColor(COLOR_BTNTEXT);
const auto box=paintDialogFrame(item.hDC,item.rcItem,frame,surface,border);
paintDialogFrameCaptions(item.hDC,item.rcItem,box,L"Search",surface,ink,mono);
auto field=item.rcItem;
InflateRect(&field,-frame.content(),-frame.content());
const auto cells=static_cast<size_t>(std::max(0L,field.right-field.left-10)/std::max(1,cellWidth));
const auto start=panelSearchPrefix.size()>cells?panelSearchPrefix.size()-cells:0;
paintText(item.hDC,field,panelSearchPrefix.c_str()+start,RGB(0,0,0),RGB(0,128,128));
return TRUE;
}
if(item.CtlID==142 || item.CtlID==143)
{
auto bounds=item.rcItem;
FillRect(item.hDC,&bounds,blue);
const auto &panel=panels[item.CtlID-142];
const auto path=(panel.peer?panel.peer->name+L" · ":std::wstring{})+panel.directory.native();
const auto middle=bounds.top+(bounds.bottom-bounds.top)/2;
SetDCBrushColor(item.hDC,colors[Frame]);
const auto lineBrush=static_cast<HBRUSH>(GetStockObject(DC_BRUSH));
RECT upper{bounds.left,middle-2,bounds.right,middle-1};
RECT lower{bounds.left,middle+1,bounds.right,middle+2};
FillRect(item.hDC,&upper,lineBrush);
FillRect(item.hDC,&lower,lineBrush);
if(panels[item.CtlID-142].wide)
{
const auto index=item.CtlID-142;
RECT list{};
GetWindowRect(panels[index].list,&list);
MapWindowPoints(nullptr,item.hwndItem,reinterpret_cast<POINT*>(&list),2);
const auto x=std::max(list.left,list.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
RECT column{x,middle,x+1,bounds.bottom};
FillRect(item.hDC,&column,lineBrush);
}
if(path.empty()) return TRUE;
const int saved=SaveDC(item.hDC);
SelectObject(item.hDC,mono);
SIZE text{};
GetTextExtentPoint32W(item.hDC,path.c_str(),static_cast<int>(path.size()),&text);
const auto width=std::min(bounds.right-bounds.left,text.cx+2L*cellWidth);
bounds.left+=(bounds.right-bounds.left-width)/2;
bounds.right=bounds.left+width;
const bool highlighted=static_cast<int>(item.CtlID)-142==active;
FillRect(item.hDC,&bounds,highlighted?teal:blue);
const auto padding=std::min(static_cast<LONG>(cellWidth),width/4);
InflateRect(&bounds,-padding,0);
SetTextColor(item.hDC,colors[highlighted?Text:Frame]);
SetBkMode(item.hDC,TRANSPARENT);
DrawTextW(item.hDC,path.c_str(),-1,&bounds,
DT_CENTER|DT_VCENTER|DT_SINGLELINE|DT_PATH_ELLIPSIS|DT_NOPREFIX);
if(saved) RestoreDC(item.hDC,saved);
return TRUE;
}
if(item.CtlID==140 || item.CtlID==141)
{
auto name=item.rcItem, size=item.rcItem;
size.left=std::max(size.left,size.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
name.right=size.left;
paintText(item.hDC,name,L"Name",RGB(255,255,0),colors[PanelBlue]);
paintText(item.hDC,size,L"Size",RGB(255,255,0),colors[PanelBlue],true);
RECT line{size.left,size.top,size.left+1,size.bottom};
SetDCBrushColor(item.hDC,colors[Frame]);
FillRect(item.hDC,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
return TRUE;
}
if(item.hwndItem==pickerFrame)
{
auto border=CreateSolidBrush(commandPicker?colors[Frame]:RGB(255,255,255));
const auto box=paintDialogFrame(item.hDC,item.rcItem,
dialogFrameMetrics(GetDpiForWindow(window)),teal,border);
if(!commandPicker)
{
if(!drivePaths.empty())
{
RECT list{};
GetWindowRect(picker,&list);
MapWindowPoints(nullptr,pickerFrame,reinterpret_cast<POINT*>(&list),2);
for(size_t i=1;i<driveColumnStarts.size();++i)
{
const LONG x=list.left+driveColumnStarts[i]-driveColumnStarts[0]-1;
if(x<list.right)
{
const RECT line{x,box.top,x+1,list.top};
FillRect(item.hDC,&line,border);
}
}
}
paintDialogFrameCaptions(item.hDC,item.rcItem,box,L"Change drive",teal,colors[Text],mono);
}
DeleteObject(border);
return TRUE;
}
std::wstring text;
if(item.CtlType==ODT_LISTBOX && item.itemID!=UINT(-1))
{
auto length=SendMessageW(item.hwndItem,LB_GETTEXTLEN,item.itemID,0);
if(length>=0)
{
text.resize(length+1);
SendMessageW(item.hwndItem,LB_GETTEXT,item.itemID,reinterpret_cast<LPARAM>(text.data()));
}
}
if(item.CtlType==ODT_BUTTON)
{
wchar_t label[64]{};
GetWindowTextW(item.hwndItem,label,64);
text=label;
}
auto background=item.CtlType==ODT_BUTTON?Footer:item.hwndItem==picker?Dialog:PanelBlue;
auto foreground=colors[Text];
if(item.hwndItem==picker && !commandPicker && item.itemID==drivePaths.size())
{
auto row=item.rcItem;
FillRect(item.hDC,&row,teal);
const RECT line{row.left,row.top,row.right,row.top+1};
SetDCBrushColor(item.hDC,RGB(255,255,255));
FillRect(item.hDC,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
++row.top;
paintDialogCaption(item.hDC,row,L"KSwitcher LAN",teal,colors[Text],mono);
const RECT sectionLine{row.left,row.bottom-1,row.right,row.bottom};
FillRect(item.hDC,&sectionLine,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
return TRUE;
}
if(item.CtlID>=130 && item.CtlID<=134 && static_cast<int>(item.CtlID)-130==menuIndex)
background=Selection;
const bool panelRow=item.CtlID==102 || item.CtlID==103;
const bool activePanelRow=panelRow && item.hwndItem==panels[active].list;
if(panelRow)
{
const auto cursor=SendMessageW(item.hwndItem,LB_GETCURSEL,0,0);
if(activePanelRow && cursor!=LB_ERR &&
static_cast<UINT>(cursor)==item.itemID) background=PanelCursor;
}
else if(item.itemState&(ODS_SELECTED|ODS_FOCUS))
background=Selection;
COLORREF rowBackground=colors[background];
HFONT rowFont{};
if(panelRow)
{
const auto &panel=panels[item.CtlID-102];
if(item.itemID<panel.rows.size() && panel.sizes[item.itemID]!=L"Up")
{
const bool marked=panel.marked[item.itemID];
const bool transferred=transferHighlightPhase%2==0 && panel.transferResults.contains(panel.rows[item.itemID]);
const bool cursor=SendMessageW(panel.list,LB_GETCURSEL,0,0)==item.itemID;
const auto state=marked?FileRowState::Marked:!cursor?FileRowState::Normal:
activePanelRow?FileRowState::Focused:FileRowState::Unfocused;
const auto resolved=resolveFileStyle(panel.rows[item.itemID].extension().native(),
panel.sizes[item.itemID]!=L"Folder",panel.dimmed[item.itemID],
background==PanelCursor || marked || transferred,foreground,rowBackground,fileStyles,state,transferred);
foreground=resolved.foreground;
rowBackground=resolved.background;
rowFont=fileStyleFonts[resolved.decorations];
}
}
auto shortcut=text.find(L'\t');
if(item.hwndItem==picker && commandPicker && item.itemID<commandAccessPositions.size())
{
auto labelRect=item.rcItem, keyRect=item.rcItem;
SelectObject(item.hDC,mono);
SIZE extent{};
if(shortcut!=text.npos)
{
const auto key=text.c_str()+shortcut+1;
GetTextExtentPoint32W(item.hDC,key,lstrlenW(key),&extent);
keyRect.left=std::max(keyRect.left,keyRect.right-extent.cx-16);
labelRect.right=keyRect.left;
paintText(item.hDC,keyRect,key,colors[Text],colors[background],true);
}
paintMenuLabel(item.hDC,labelRect,text.substr(0,shortcut),commandAccessPositions[item.itemID],
colors[Text],colors[background]);
}
else if(item.hwndItem==picker && !commandPicker && item.itemID<drivePaths.size())
{
SelectObject(item.hDC,mono);
SetTextColor(item.hDC,foreground);
const auto normal=colors[Dialog];
const auto hover=RGB(3*GetRValue(normal)/4,3*GetGValue(normal)/4,
3*GetBValue(normal)/4);
SetBkColor(item.hDC,background==Dialog && static_cast<int>(item.itemID)==driveHover?
hover:colors[background]);
ExtTextOutW(item.hDC,0,0,ETO_OPAQUE,&item.rcItem,L"",0,nullptr);
SetBkMode(item.hDC,TRANSPARENT);
SetDCBrushColor(item.hDC,RGB(255,255,255));
const auto brush=static_cast<HBRUSH>(GetStockObject(DC_BRUSH));
size_t start=0;
for(size_t i=0;i<driveColumnStarts.size();++i)
{
const LONG x=item.rcItem.left+driveColumnStarts[i];
if(i)
{
const LONG divider=x-driveColumnStarts[0]-1;
if(divider<item.rcItem.right)
{
const RECT line{divider,item.rcItem.top,divider+1,item.rcItem.bottom};
FillRect(item.hDC,&line,brush);
}
}
const auto end=text.find(L'\t',start);
const auto length=end==text.npos?lstrlenW(text.c_str()+start):end-start;
SetTextColor(item.hDC,foreground);
ExtTextOutW(item.hDC,x,item.rcItem.top+3,ETO_CLIPPED,&item.rcItem,
text.c_str()+start,static_cast<UINT>(length),nullptr);
if(i==0 && length)
{
SetTextColor(item.hDC,RGB(255,255,0));
ExtTextOutW(item.hDC,x,item.rcItem.top+3,ETO_CLIPPED,&item.rcItem,text.c_str(),1,nullptr);
}
if(end==text.npos) break;
start=end+1;
}
SetBkMode(item.hDC,OPAQUE);
}
else if(item.hwndItem==picker && !commandPicker && item.itemID>drivePaths.size())
{
auto bounds=item.rcItem;
SelectObject(item.hDC,mono);
SetTextColor(item.hDC,foreground);
SetBkColor(item.hDC,colors[background]);
ExtTextOutW(item.hDC,bounds.left+driveColumnStarts[0],bounds.top+3,
ETO_OPAQUE|ETO_CLIPPED,&bounds,text.c_str(),lstrlenW(text.c_str()),nullptr);
}
else if(item.CtlID>=130 && item.CtlID<=134)
paintMenuLabel(item.hDC,item.rcItem,text,0,foreground,colors[background]);
else paintText(item.hDC,item.rcItem,text.c_str(),foreground,rowBackground,false,rowFont);
if(item.CtlID==102 || item.CtlID==103)
{
const auto &panel=panels[item.CtlID-102];
if(panel.wide && item.itemID<panel.sizes.size())
{
auto name=item.rcItem, size=item.rcItem;
size.left=std::max(size.left,size.right-(sizeWidth+2)*static_cast<LONG>(cellWidth));
name.right=size.left;
bool folder=panel.sizes[item.itemID]==L"Folder";
if(folder) text=panel.rows[item.itemID].filename().wstring();
const auto extensionLength=std::max(alignFolders?panel.folderExtensionLength:0,
alignExtensions?panel.fileExtensionLength:0);
if(panel.sizes[item.itemID]!=L"Up" && extensionLength && (folder?alignFolders:alignExtensions))
{
auto extension=panel.rows[item.itemID].extension().wstring();
if(extension.size()>1)
{
auto end=name;
const auto width=static_cast<LONG>(extensionLength)*cellWidth+5;
end.left=std::max(end.left+static_cast<LONG>(cellWidth),end.right-width);
end.left=std::min(end.left,end.right);
name.right=end.left;
paintText(item.hDC,end,extension.c_str()+1,foreground,rowBackground,true,rowFont);
text=panel.rows[item.itemID].stem().wstring();
}
}
paintText(item.hDC,name,text.c_str(),foreground,rowBackground,false,rowFont);
const auto &amount=panel.sizes[item.itemID];
auto visible=amount;
if(amount!=L"Folder" && amount!=L"Up")
visible=formatSize(std::stoull(amount),static_cast<size_t>(sizeWidth));
paintText(item.hDC,size,visible.c_str(),foreground,rowBackground,true);
RECT line{size.left,size.top,size.left+1,size.bottom};
SetDCBrushColor(item.hDC,colors[Frame]);
FillRect(item.hDC,&line,static_cast<HBRUSH>(GetStockObject(DC_BRUSH)));
}
}
if (item.CtlType==ODT_LISTBOX && item.hwndItem!=picker)
{
RECT track{};
GetWindowRect(item.hwndItem,&track);
MapWindowPoints(nullptr,window,reinterpret_cast<POINT*>(&track),2);
track.left=track.right;
track.right+=5;
InvalidateRect(window,&track,FALSE);
}
return TRUE;
}
case WM_COMMAND:
if(copyInProgress || commandHistoryWindow || activeFilesDialog) return 0;
if(LOWORD(wp)==121 && HIWORD(wp)==LBN_DBLCLK) selectDrive();
if(LOWORD(wp)>=130 && LOWORD(wp)<=134 && HIWORD(wp)==BN_CLICKED)
{
openMenu(window,LOWORD(wp)-130);
return 0;
}
if (LOWORD(wp) >= 110 && LOWORD(wp) <= 115 && HIWORD(wp) == BN_CLICKED)
{
const WPARAM keys[]{VK_F2, VK_F3, VK_F4, VK_F5, VK_F6, VK_F10};
SendMessageW(panels[active].list, WM_KEYDOWN, keys[LOWORD(wp) - 110], 0);
}
if (LOWORD(wp) >= 102 && LOWORD(wp) <= 103 && HIWORD(wp) == LBN_DBLCLK)
enter(panels[LOWORD(wp) - 102]);
if (LOWORD(wp) >= 102 && LOWORD(wp) <= 103 && HIWORD(wp) == LBN_SELCHANGE)
{
const auto &panel=panels[LOWORD(wp) - 102];
InvalidateRect(panel.list,nullptr,FALSE);
showFileDetails(panel);
}
return 0;
case WM_CLOSE:
if(activeFilesDialog && !activeCopy)
{
PostMessageW(activeFilesDialog,WM_CLOSE,0,0);
return 0;
}
if(activeCopy)
{
if(activeFilesDialog!=activeCopy->window)
{
setStatus(L"Resolve the copy prompt before closing.");
return 0;
}
SendMessageW(activeCopy->window,WM_COMMAND,IDCANCEL,0);
activeCopy->closeOwner=activeCopy->canceled;
return 0;
}
savePlacement(window);
for(int i=0;i<2;++i)
{
const auto &path=panels[i].directory.native();
if(!panels[i].peer && !path.empty())
RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,panelPathKeys[i],REG_SZ,path.c_str(),
static_cast<DWORD>((path.size()+1)*sizeof(wchar_t)));
const auto row=SendMessageW(panels[i].list,LB_GETCURSEL,0,0);
const auto cursor=row>=0 && static_cast<size_t>(row)<panels[i].rows.size() ?
panels[i].rows[row].native() : std::wstring{};
if(!panels[i].peer) RegSetKeyValueW(HKEY_CURRENT_USER,schemeKey,panelCursorKeys[i],REG_SZ,cursor.c_str(),
static_cast<DWORD>((cursor.size()+1)*sizeof(wchar_t)));
}
DestroyWindow(window);
return 0;
case WM_DESTROY:
KillTimer(window,terminalTimer);
KillTimer(window,directoryWatchTimer);
for(auto &panel:panels) panel.watch.reset();
terminalView.close();
terminal.close();
PostQuitMessage(0);
return 0;
}
return DefWindowProcW(window, message, wp, lp);
}
}
int WINAPI wWinMain(HINSTANCE instance, HINSTANCE, PWSTR, int show)
{
bool writeLog=true;
try
{
const auto settings=ks::dataDirectory()/L"settings.json";
if(std::filesystem::exists(settings))
writeLog=Json::parse(ks::readFile(settings,1024*1024)).value("writeLog",true);
}
catch(const std::exception &) {}
ks::setLogFilename(L"kswitcher-files.log");
ks::setLoggingEnabled(writeLog);
int count{};
if(auto args=CommandLineToArgvW(GetCommandLineW(),&count))
{
if(count==4 && std::wstring_view(args[1])==L"--list-folder")
{
auto result=listElevatedFolder(fs::path(args[2]).parent_path(),args[3]);
LocalFree(args);
return static_cast<int>(result);
}
for(int i=1;i<count;++i)
if(std::wstring_view(args[i])==L"--terminal-trace" ||
std::wstring_view(args[i])==L"--terminal-output-trace")
{
traceTerminalOutput=std::wstring_view(args[i])==L"--terminal-output-trace";
wchar_t temp[MAX_PATH]{};
const auto length=GetTempPathW(MAX_PATH,temp);
if(length && length<MAX_PATH)
terminalTrace.open(fs::path(temp)/(L"KSwitcher.Files.terminal-trace-"+
std::to_wstring(GetCurrentProcessId())+L".log"),std::ios::trunc);
traceTerminal("start");
}
LocalFree(args);
}
INITCOMMONCONTROLSEX controls{sizeof(controls), ICC_STANDARD_CLASSES|ICC_PROGRESS_CLASS|ICC_TREEVIEW_CLASSES|ICC_HOTKEY_CLASS};
InitCommonControlsEx(&controls);
loadCommandHistory();
WNDCLASSW type{};
type.hInstance = instance;
type.lpfnWndProc = filesWindow;
type.hIcon = LoadIconW(instance, MAKEINTRESOURCEW(1));
type.hCursor = LoadCursorW(nullptr, IDC_ARROW);
type.lpszClassName = L"KSwitcher.Files";
if (!RegisterClassW(&type)) return 1;
auto window = CreateWindowW(type.lpszClassName, L"KSwitcher Files — local prototype",
WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT, 900, 540, nullptr, nullptr, instance, nullptr);
if (!window) return 1;
if(!restorePlacement(window)) ShowWindow(window, show);
SetFocus(terminalInput);
const auto com=CoInitializeEx(nullptr,COINIT_APARTMENTTHREADED);
MSG message{};
for(;;)
{
if(GetForegroundWindow()==window) restoreCommandFocus();
if(GetMessageW(&message,nullptr,0,0)<=0) break;
if(message.hwnd==window && message.message>=WM_KEYFIRST && message.message<=WM_KEYLAST &&
GetFocus()==terminalInput)
message.hwnd=terminalInput;
if(commandHistoryWindow)
{
if(message.message==WM_KEYDOWN && (message.wParam==VK_RETURN || message.wParam==VK_ESCAPE) &&
(message.hwnd==commandHistoryWindow || IsChild(commandHistoryWindow,message.hwnd)))
{
SendMessageW(commandHistoryWindow,WM_COMMAND,message.wParam==VK_RETURN?IDOK:IDCANCEL,0);
continue;
}
if(IsDialogMessageW(commandHistoryWindow,&message)) continue;
const bool ownerClient=message.hwnd==window || IsChild(window,message.hwnd);
const bool clientInput=(message.message>=WM_KEYFIRST && message.message<=WM_KEYLAST) ||
(message.message>=WM_MOUSEFIRST && message.message<=WM_MOUSELAST) ||
message.message==WM_CONTEXTMENU;
if(ownerClient && clientInput) continue;
}
if(!copyInProgress && handlePanelSearchKey(window,message)) continue;
if(message.message==WM_KEYDOWN && (message.wParam==VK_UP || message.wParam==VK_DOWN) &&
(GetKeyState(VK_CONTROL)&0x8000) && !(GetKeyState(VK_MENU)&0x8000) &&
(message.hwnd==window || IsChild(window,message.hwnd)) && !terminalVisible && !copyInProgress)
{
RECT bounds{};
GetClientRect(window,&bounds);
const auto maximum=std::max(0,static_cast<int>(bounds.bottom)/textHeight-8);
const int rows=std::clamp(terminalRows+(message.wParam==VK_UP?1:-1),0,maximum);
traceTerminal(message.wParam==VK_UP?"key-grow":"key-shrink",terminalRows,rows);
if(rows && !startTerminal(window)) continue;
terminalRows=rows;
layout(window);
continue;
}
if(message.message==WM_KEYDOWN && message.wParam=='O' &&
(GetKeyState(VK_CONTROL)&0x8000) && !(GetKeyState(VK_MENU)&0x8000) &&
(message.hwnd==window || IsChild(window,message.hwnd)) &&
!copyInProgress)
{
if(terminalVisible || startTerminal(window)) showTerminal(window,!terminalVisible);
continue;
}
const bool panelFocused=message.hwnd==panels[0].list || message.hwnd==panels[1].list;
const bool mainInput=panelFocused || message.hwnd==terminalInput;
if(message.message==WM_KEYDOWN && mainInput && !terminalVisible &&
(GetKeyState(VK_CONTROL)&0x8000) && !(GetKeyState(VK_MENU)&0x8000) &&
!(GetKeyState(VK_LWIN)&0x8000) && !(GetKeyState(VK_RWIN)&0x8000) &&
message.wParam>='0' && message.wParam<='9' && !copyInProgress &&
(message.wParam!='8' || (GetKeyState(VK_SHIFT)&0x8000)))
{
if(!(message.lParam & (1LL<<30)))
{
hidePicker();
showMenu(false);
auto &panel=panels[active];
const auto digit=static_cast<int>(message.wParam-'0');
if(GetKeyState(VK_SHIFT)&0x8000) addFolderShortcut(panel,digit);
else showFolderShortcuts(panel,digit);
}
continue;
}
const bool filesMessage=message.hwnd==window || IsChild(window,message.hwnd);
if(filesMessage && !terminalVisible && !copyInProgress && !commandHistoryWindow &&
message.message==WM_KEYDOWN && message.wParam=='8' &&
(GetKeyState(VK_CONTROL)&0x8000) && !(GetKeyState(VK_MENU)&0x8000) &&
!(GetKeyState(VK_SHIFT)&0x8000) && !(GetKeyState(VK_LWIN)&0x8000) &&
!(GetKeyState(VK_RWIN)&0x8000))
{
if(!(message.lParam & (1LL<<30)))
{
hidePicker();
showMenu(false);
showFolderShortcuts(panels[active],-1,true);
}
continue;
}
if(mainInput &&
!copyInProgress && message.message==WM_KEYDOWN &&
!(GetKeyState(VK_MENU)&0x8000) &&
!(GetKeyState(VK_LWIN)&0x8000) && !(GetKeyState(VK_RWIN)&0x8000))
{
const bool ctrl=(GetKeyState(VK_CONTROL)&0x8000)!=0;
const bool shift=(GetKeyState(VK_SHIFT)&0x8000)!=0;
if(ctrl && !shift && (message.wParam=='F' || message.wParam=='C'))
{
if(!(message.lParam & (1LL<<30)))
{
if(message.wParam=='F') insertCurrentPanelPath();
else SendMessageW(terminalInput,WM_COPY,0,0);
}
continue;
}
if(panelFocused && ((message.wParam=='V' && ctrl && !shift) ||
(message.wParam==VK_INSERT && shift && !ctrl)))
{
SetFocus(terminalInput);
SendMessageW(terminalInput,WM_PASTE,0,0);
continue;
}
}
if(filesMessage && !copyInProgress && handleCommandHistoryKey(window,message)) continue;
const bool modified=(GetKeyState(VK_CONTROL)&0x8000) || (GetKeyState(VK_SHIFT)&0x8000) ||
(GetKeyState(VK_LWIN)&0x8000) || (GetKeyState(VK_RWIN)&0x8000);
if(filesMessage && !copyInProgress &&
handleFilesMenuKey(window,message.message,message.wParam,message.lParam,modified))
continue;
if((message.message==WM_LBUTTONDOWN || message.message==WM_RBUTTONDOWN ||
message.message==WM_NCLBUTTONDOWN) && message.hwnd!=menuBar && message.hwnd!=picker &&
std::find(std::begin(menuItems),std::end(menuItems),message.hwnd)==std::end(menuItems))
{
showMenu(false);
if(message.hwnd!=picker) hidePicker();
}
if((message.message==WM_CHAR || message.message==WM_SYSCHAR) && IsWindowVisible(menuBar))
{
const auto letter=towupper(static_cast<wchar_t>(message.wParam));
if(letter>=L'A' && letter<=L'Z')
{
if(!IsWindowVisible(picker))
{
const auto category=menuAccessKeys.find(static_cast<wchar_t>(letter));
if(category!=menuAccessKeys.npos) openMenu(window,static_cast<int>(category));
}
else if(commandPicker)
{
for(size_t row=0;row<commandAccessPositions.size();++row)
{
const auto pos=commandAccessPositions[row];
if(pos==std::wstring::npos) continue;
const auto length=SendMessageW(picker,LB_GETTEXTLEN,row,0);
if(length<=0 || pos>=static_cast<size_t>(length)) continue;
std::wstring label(static_cast<size_t>(length)+1,L'\0');
SendMessageW(picker,LB_GETTEXT,row,reinterpret_cast<LPARAM>(label.data()));
if(towupper(label[pos])==letter)
{
SendMessageW(picker,LB_SETCURSEL,row,0);
selectDrive();
break;
}
}
}
else
{
TranslateMessage(&message);
DispatchMessageW(&message);
}
continue;
}
}
if(message.message==WM_KEYDOWN && IsWindowVisible(menuBar) && !IsWindowVisible(picker))
{
if(message.wParam==VK_ESCAPE){showMenu(false);SetFocus(panels[active].list);continue;}
if(message.wParam==VK_LEFT || message.wParam==VK_RIGHT)
{
menuIndex=(menuIndex+(message.wParam==VK_LEFT?4:1))%5;
showMenu(true);
continue;
}
if(message.wParam==VK_RETURN || message.wParam==VK_DOWN)
{
SendMessageW(window,WM_COMMAND,MAKEWPARAM(130+menuIndex,BN_CLICKED),0);
continue;
}
}
if (message.message == WM_SYSKEYDOWN && message.wParam == VK_F10 &&
!(GetKeyState(VK_MENU) & 0x8000) && !(GetKeyState(VK_SHIFT) & 0x8000))
{
SendMessageW(window, WM_CLOSE, 0, 0);
continue;
}
if (message.message == WM_SYSKEYDOWN && (message.wParam == VK_F1 || message.wParam == VK_F2))
{
chooseDrive(static_cast<int>(message.wParam - VK_F1));
continue;
}
TranslateMessage(&message);
DispatchMessageW(&message);
}
for(auto font:fileStyleFonts) if(font) DeleteObject(font);
DeleteObject(mono);
DeleteObject(blue);
DeleteObject(teal);
DeleteObject(terminalBackground);
if(SUCCEEDED(com)) CoUninitialize();
return 0;
}
Reference in new issue View Git Blame Copy Permalink