You've already forked FileManager
mirror of
https://github.com/Team-Resurgent/FileManager.git
synced 2026-04-30 10:38:50 -07:00
HoRnEyDvL
b07c4be9cb
Fixed keyboard highlight spacing Fixed button sensitivity while in context menus. Fixed scroll sensitivity when navigating files and folders. Fixed go to root. If already in a folder will take you to the root of the drive, If root of drive will take you to drive list.
1332 lines
46 KiB
C++
1332 lines
46 KiB
C++
//------------------------------------------------------------------------------
|
||
// OG Xbox File Browser (Original Xbox XDK) — VS2003 friendly
|
||
// Dual-pane GUI with auto layout, context menu, basic file ops, and rename OSD
|
||
//------------------------------------------------------------------------------
|
||
|
||
#include "stdafx.h" // Remove if you disabled PCH
|
||
#include <xtl.h>
|
||
#include <wchar.h>
|
||
#include <vector>
|
||
#include <algorithm>
|
||
#include <stdarg.h>
|
||
|
||
#include "XBApp.h"
|
||
#include "XBFont.h"
|
||
#include "XBInput.h"
|
||
|
||
extern "C" {
|
||
typedef struct _STRING { USHORT Length; USHORT MaximumLength; PCHAR Buffer; } STRING, *PSTRING;
|
||
LONG __stdcall IoCreateSymbolicLink(PSTRING SymbolicLinkName, PSTRING DeviceName);
|
||
LONG __stdcall IoDeleteSymbolicLink(PSTRING SymbolicLinkName);
|
||
}
|
||
//#pragma comment(lib, "xboxkrnl.lib")
|
||
|
||
#ifndef INVALID_FILE_ATTRIBUTES
|
||
#define INVALID_FILE_ATTRIBUTES 0xFFFFFFFF
|
||
#endif
|
||
|
||
// --- Simple on-screen keyboard layout (fixed grid, VS2003-safe) ---
|
||
static const char s_kb_r0[] = "ABCDEFGHIJKL"; // 12
|
||
static const char s_kb_r1[] = "MNOPQRSTUVWX"; // 12
|
||
static const char s_kb_r2[] = "YZ0123456789"; // 12
|
||
static const char s_kb_r3[] = "-_.()[]{}+&"; // 12 (punctuation row)
|
||
static const int s_kb_cols[5] = {12,12,12,12,5}; // last row: Back, Space, Aa, OK, Cancel
|
||
|
||
// small helpers (avoid <algorithm> max macro surprises in VS2003)
|
||
static inline FLOAT MaxF(FLOAT a, FLOAT b){ return (a>b)?a:b; }
|
||
static inline int MaxI(int a, int b){ return (a>b)?a:b; }
|
||
static inline FLOAT Snap(FLOAT v){ return (FLOAT)((int)(v + 0.5f)); } // integer pixel snap
|
||
|
||
static const char* kRoots[] = { "C:\\", "D:\\", "E:\\", "F:\\", "G:\\", "X:\\", "Y:\\", "Z:\\" };
|
||
static const int kNumRoots = sizeof(kRoots)/sizeof(kRoots[0]);
|
||
static int g_presentIdx[16];
|
||
static int g_presentCount = 0;
|
||
|
||
// -------------------- text / size / path helpers --------------------
|
||
static inline void DrawAnsi(CXBFont& font, FLOAT x, FLOAT y, DWORD color, const char* text){
|
||
WCHAR wbuf[512]; MultiByteToWideChar(CP_ACP,0,text,-1,wbuf,512); font.DrawText(x,y,color,wbuf,0,0.0f);
|
||
}
|
||
static inline void FormatSize(ULONGLONG sz, char* out, size_t cap){
|
||
const char* unit="B"; double v=(double)sz;
|
||
if(sz>=(1ULL<<30)){ v/=(double)(1ULL<<30); unit="GB"; }
|
||
else if(sz>=(1ULL<<20)){ v/=(double)(1ULL<<20); unit="MB"; }
|
||
else if(sz>=(1ULL<<10)){ v/=(double)(1ULL<<10); unit="KB"; }
|
||
_snprintf(out,(int)cap,(unit[0]=='B')?"%.0f %s":"%.1f %s",v,unit); out[cap-1]=0;
|
||
}
|
||
static inline void GetDriveFreeTotal(const char* anyPathInDrive, ULONGLONG& freeBytes, ULONGLONG& totalBytes){
|
||
freeBytes=0; totalBytes=0; char root[8]; _snprintf(root,sizeof(root),"%c:\\",anyPathInDrive[0]); root[sizeof(root)-1]=0;
|
||
ULARGE_INTEGER a,t,f; a.QuadPart=0; t.QuadPart=0; f.QuadPart=0;
|
||
if(GetDiskFreeSpaceExA(root,&a,&t,&f)){ freeBytes=f.QuadPart; totalBytes=t.QuadPart; }
|
||
}
|
||
static inline void BuildString(STRING& s,const char* z){ USHORT L=(USHORT)strlen(z); s.Length=L; s.MaximumLength=L+1; s.Buffer=(PCHAR)z; }
|
||
static inline void MakeDosString(char* out,size_t cap,const char* letter){ _snprintf(out,(int)cap,"\\??\\%s",letter); out[cap-1]=0; }
|
||
static inline void JoinPath(char* dst,size_t cap,const char* base,const char* name){
|
||
size_t bl=strlen(base);
|
||
if(bl&&base[bl-1]=='\\') _snprintf(dst,(int)cap,"%s%s",base,name);
|
||
else _snprintf(dst,(int)cap,"%s\\%s",base,name);
|
||
dst[cap-1]=0;
|
||
}
|
||
static inline void EnsureTrailingSlash(char* s,size_t cap){ size_t n=strlen(s); if(n&&s[n-1]!='\\'&&n+1<cap){ s[n]='\\'; s[n+1]=0; } }
|
||
static inline void ParentPath(char* path){
|
||
size_t n=strlen(path);
|
||
if (n <= 3) { path[0]=0; return; }
|
||
while (n && path[n-1]=='\\') { path[--n]=0; }
|
||
char* p = strrchr(path,'\\');
|
||
if (!p) { path[0]=0; return; }
|
||
if (p == path+2) *(p+1)=0; else *p=0;
|
||
}
|
||
static inline int ci_cmp(const char* a,const char* b){ return _stricmp(a,b); }
|
||
|
||
// -------------------- letter mapping --------------------
|
||
static BOOL MapLetterToDevice(const char* letter,const char* devicePath){
|
||
char dosBuf[16]={0}; MakeDosString(dosBuf,sizeof(dosBuf),letter);
|
||
STRING sDos; BuildString(sDos,dosBuf); IoDeleteSymbolicLink(&sDos);
|
||
STRING sDev; BuildString(sDev,devicePath);
|
||
if(IoCreateSymbolicLink(&sDos,&sDev)!=0) return FALSE; // STATUS_SUCCESS==0
|
||
char root[8]={0}; _snprintf(root,sizeof(root),"%s\\",letter);
|
||
if(GetFileAttributesA(root)==INVALID_FILE_ATTRIBUTES){ IoDeleteSymbolicLink(&sDos); return FALSE; }
|
||
return TRUE;
|
||
}
|
||
static void MapStandardDrives_Io(){
|
||
MapLetterToDevice("D:","\\Device\\Cdrom0");
|
||
MapLetterToDevice("C:","\\Device\\Harddisk0\\Partition2");
|
||
MapLetterToDevice("E:","\\Device\\Harddisk0\\Partition1");
|
||
MapLetterToDevice("X:","\\Device\\Harddisk0\\Partition3");
|
||
MapLetterToDevice("Y:","\\Device\\Harddisk0\\Partition4");
|
||
MapLetterToDevice("Z:","\\Device\\Harddisk0\\Partition5");
|
||
MapLetterToDevice("F:","\\Device\\Harddisk0\\Partition6");
|
||
MapLetterToDevice("G:","\\Device\\Harddisk0\\Partition7");
|
||
}
|
||
|
||
// -------------------- listing --------------------
|
||
struct Item { char name[256]; bool isDir; ULONGLONG size; bool isUpEntry; };
|
||
|
||
static void BuildDriveItems(std::vector<Item>& out){
|
||
out.clear(); for(int j=0;j<g_presentCount;++j){ int i=g_presentIdx[j]; Item it; ZeroMemory(&it,sizeof(it));
|
||
strncpy(it.name,kRoots[i],255); it.name[255]=0; it.isDir=true; it.size=0; it.isUpEntry=false; out.push_back(it); }
|
||
}
|
||
static void RescanDrives(){ g_presentCount=0; for(int i=0;i<kNumRoots && g_presentCount<(int)(sizeof(g_presentIdx)/sizeof(g_presentIdx[0])); ++i){ DWORD a=GetFileAttributesA(kRoots[i]); if(a!=INVALID_FILE_ATTRIBUTES) g_presentIdx[g_presentCount++]=i; } }
|
||
static bool ItemLess(const Item& a,const Item& b){ if(a.isDir!=b.isDir) return a.isDir>b.isDir; return ci_cmp(a.name,b.name)<0; }
|
||
static bool ListDirectory(const char* path,std::vector<Item>& out){
|
||
out.clear();
|
||
if(strlen(path)>3){ Item up; ZeroMemory(&up,sizeof(up)); strncpy(up.name,"..",3); up.isDir=true; up.size=0; up.isUpEntry=true; out.push_back(up); }
|
||
char base[512]; _snprintf(base,sizeof(base),"%s",path); base[sizeof(base)-1]=0; EnsureTrailingSlash(base,sizeof(base));
|
||
char mask[512]; _snprintf(mask,sizeof(mask),"%s*",base); mask[sizeof(mask)-1]=0;
|
||
WIN32_FIND_DATAA fd; ZeroMemory(&fd,sizeof(fd)); HANDLE h=FindFirstFileA(mask,&fd); if(h==INVALID_HANDLE_VALUE) return false;
|
||
do{ const char* n=fd.cFileName; if(!strcmp(n,".")||!strcmp(n,"..")) continue; Item it; ZeroMemory(&it,sizeof(it));
|
||
strncpy(it.name,n,255); it.name[255]=0; it.isDir=(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)!=0;
|
||
it.size=(((ULONGLONG)fd.nFileSizeHigh)<<32)|fd.nFileSizeLow; it.isUpEntry=false; out.push_back(it);
|
||
}while(FindNextFileA(h,&fd)); FindClose(h);
|
||
size_t start=(strlen(path)>3)?1:0; if(out.size()>start+1) std::sort(out.begin()+(int)start,out.end(),ItemLess);
|
||
return true;
|
||
}
|
||
|
||
static bool IsDriveRoot(const char* p){
|
||
return p && strlen(p)==3 && p[1]==':' && p[2]=='\\';
|
||
}
|
||
|
||
// -------------------- App (dual-pane + menu) --------------------
|
||
class FileBrowserApp : public CXBApplication {
|
||
public:
|
||
// pane state
|
||
struct Pane {
|
||
std::vector<Item> items;
|
||
char curPath[512];
|
||
int mode; // 0=drives, 1=dir
|
||
int sel;
|
||
int scroll;
|
||
Pane(){ curPath[0]=0; mode=0; sel=0; scroll=0; }
|
||
};
|
||
|
||
CXBFont m_font;
|
||
int m_visible; // rows
|
||
unsigned char m_prevA, m_prevB, m_prevX, m_prevY;
|
||
DWORD m_prevButtons; // last frame's digital buttons
|
||
unsigned char m_prevWhite, m_prevBlack; // last frame's white/black
|
||
Pane m_pane[2];
|
||
int m_active; // 0=left, 1=right
|
||
bool m_navUDHeld; // up/down currently held?
|
||
int m_navUDDir; // -1 up, +1 down
|
||
DWORD m_navUDNext; // next time (ms) another step is allowed
|
||
|
||
// TL vertex for filled rects
|
||
struct TLVERT { float x,y,z,rhw; D3DCOLOR color; };
|
||
enum { FVF_TLVERT = D3DFVF_XYZRHW | D3DFVF_DIFFUSE };
|
||
|
||
// Layout (left pane base + right pane offset) — computed at runtime
|
||
static FLOAT kListX_L, kListY, kListW, kLineH;
|
||
static FLOAT kHdrX_L, kHdrY, kHdrW, kHdrH;
|
||
static FLOAT kGutterW, kPaddingX, kScrollBarW;
|
||
static FLOAT kPaneGap; // space between panes
|
||
|
||
// --- Context menu/state ---
|
||
enum Action {
|
||
ACT_OPEN, ACT_COPY, ACT_MOVE, ACT_DELETE, ACT_RENAME,
|
||
ACT_MKDIR, ACT_CALCSIZE, ACT_GOROOT, ACT_SWITCHMEDIA
|
||
};
|
||
struct MenuItem { const char* label; Action act; bool enabled; };
|
||
|
||
bool m_menuOpen;
|
||
int m_menuSel;
|
||
MenuItem m_menu[9];
|
||
int m_menuCount;
|
||
|
||
enum { MODE_BROWSE, MODE_MENU, MODE_RENAME } m_mode;
|
||
|
||
// footer status
|
||
char m_status[256];
|
||
DWORD m_statusUntilMs;
|
||
|
||
// --- Rename UI state ---
|
||
bool m_renActive;
|
||
char m_renParent[512];
|
||
char m_renOld[256];
|
||
char m_renBuf[256];
|
||
int m_renCursor; // insertion cursor in m_renBuf
|
||
int m_renSelRow; // keyboard selection
|
||
int m_renSelCol;
|
||
bool m_kbLower; // case mode
|
||
|
||
FileBrowserApp(){
|
||
m_visible=13; m_prevA=0; m_prevB=0; m_prevX=0; m_prevY=0; m_active=0;
|
||
m_prevButtons = 0;
|
||
m_prevWhite = m_prevBlack = 0;
|
||
m_navUDHeld = false;
|
||
m_navUDDir = 0;
|
||
m_navUDNext = 0;
|
||
ZeroMemory(&m_d3dpp,sizeof(m_d3dpp));
|
||
m_d3dpp.BackBufferWidth=1280; m_d3dpp.BackBufferHeight=720;
|
||
m_d3dpp.BackBufferFormat=D3DFMT_X8R8G8B8; m_d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
|
||
m_d3dpp.FullScreen_RefreshRateInHz=60; m_d3dpp.EnableAutoDepthStencil=TRUE; m_d3dpp.AutoDepthStencilFormat=D3DFMT_D24S8;
|
||
m_d3dpp.Flags = D3DPRESENTFLAG_PROGRESSIVE | D3DPRESENTFLAG_WIDESCREEN;
|
||
|
||
m_menuOpen=false; m_menuSel=0; m_menuCount=0; m_mode=MODE_BROWSE;
|
||
m_status[0]=0; m_statusUntilMs=0;
|
||
|
||
m_renActive=false; m_renParent[0]=0; m_renOld[0]=0; m_renBuf[0]=0;
|
||
m_renCursor=0; m_renSelRow=0; m_renSelCol=0; m_kbLower=false;
|
||
}
|
||
|
||
// --- draw prims
|
||
void DrawRect(float x,float y,float w,float h,D3DCOLOR c){
|
||
TLVERT v[4]; v[0].x=x; v[0].y=y; v[1].x=x+w; v[1].y=y; v[2].x=x; v[2].y=y+h; v[3].x=x+w; v[3].y=y+h;
|
||
for(int i=0;i<4;i++){ v[i].z=0.0f; v[i].rhw=1.0f; v[i].color=c; }
|
||
m_pd3dDevice->SetTexture(0,NULL);
|
||
m_pd3dDevice->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
|
||
m_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_DISABLE);
|
||
m_pd3dDevice->SetVertexShader(FVF_TLVERT);
|
||
m_pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,v,sizeof(TLVERT));
|
||
}
|
||
void DrawHLine(float x,float y,float w,D3DCOLOR c){ DrawRect(x,y,w,1.0f,c); }
|
||
void DrawVLine(float x,float y,float h,D3DCOLOR c){ DrawRect(x,y,1.0f,h,c); }
|
||
|
||
// --- layout helpers/columns
|
||
static FLOAT NameColX(FLOAT baseX){ return baseX + kGutterW + kPaddingX; }
|
||
static FLOAT HdrX (FLOAT baseX){ return baseX - 15.0f; }
|
||
|
||
// --- text measurement + right-align
|
||
FLOAT MeasureTextW(const char* s){
|
||
WCHAR wbuf[256];
|
||
MultiByteToWideChar(CP_ACP, 0, s, -1, wbuf, 256);
|
||
FLOAT w=0.0f, h=0.0f;
|
||
m_font.GetTextExtent(wbuf, &w, &h);
|
||
return w;
|
||
}
|
||
// Returns both width & height for centering
|
||
void MeasureTextWH(const char* s, FLOAT& outW, FLOAT& outH){
|
||
WCHAR wbuf[256];
|
||
MultiByteToWideChar(CP_ACP, 0, s, -1, wbuf, 256);
|
||
m_font.GetTextExtent(wbuf, &outW, &outH);
|
||
}
|
||
|
||
void DrawRightAligned(const char* s, FLOAT rightX, FLOAT y, DWORD color){
|
||
FLOAT w = MeasureTextW(s);
|
||
DrawAnsi(m_font, rightX - w, y, color, s);
|
||
}
|
||
|
||
// --- size column measurement (dynamic per pane)
|
||
FLOAT ComputeSizeColW(const Pane& p){
|
||
FLOAT maxW = MeasureTextW("Size");
|
||
int limit = (int)p.items.size(); if(limit>200) limit=200;
|
||
char buf[64];
|
||
for(int i=0;i<limit;++i){
|
||
const Item& it = p.items[i];
|
||
if(!it.isDir && !it.isUpEntry){
|
||
FormatSize(it.size, buf, sizeof(buf));
|
||
FLOAT w = MeasureTextW(buf); if(w>maxW) maxW=w;
|
||
}
|
||
}
|
||
maxW += 16.0f; // padding
|
||
const FLOAT minW = MaxF(90.0f, kLineH * 4.0f);
|
||
const FLOAT maxWClamp = kListW * 0.40f;
|
||
if(maxW < minW) maxW = minW;
|
||
if(maxW > maxWClamp) maxW = maxWClamp;
|
||
return maxW;
|
||
}
|
||
|
||
// --- status
|
||
void SetStatus(const char* fmt, ...){
|
||
va_list ap; va_start(ap, fmt);
|
||
_vsnprintf(m_status, sizeof(m_status), fmt, ap);
|
||
va_end(ap);
|
||
m_status[sizeof(m_status)-1]=0;
|
||
m_statusUntilMs = GetTickCount() + 3000; // 3s
|
||
}
|
||
void SetStatusLastErr(const char* prefix){
|
||
DWORD e = GetLastError();
|
||
char msg[64]; _snprintf(msg, sizeof(msg), "%s (err=%lu)", prefix, (unsigned long)e);
|
||
msg[sizeof(msg)-1]=0;
|
||
SetStatus("%s", msg);
|
||
}
|
||
|
||
// Return true if we can create & delete a temp file in 'dir'
|
||
bool CanWriteHereA(const char* dir){
|
||
char test[512];
|
||
JoinPath(test, sizeof(test), dir, ".__xwtest$__");
|
||
test[sizeof(test)-1]=0;
|
||
HANDLE h = CreateFileA(test, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY, NULL);
|
||
if (h == INVALID_HANDLE_VALUE) return false;
|
||
CloseHandle(h);
|
||
DeleteFileA(test);
|
||
return true;
|
||
}
|
||
|
||
// normalize dir for things like "E:" -> "E:\"
|
||
void NormalizeDirA(char* s){
|
||
size_t n = strlen(s);
|
||
if (n==2 && s[1]==':'){ s[2]='\\'; s[3]=0; return; }
|
||
EnsureTrailingSlash(s, 512);
|
||
}
|
||
|
||
// FATX-ish name rules: disallow control chars and obvious bad ones
|
||
bool IsBadFatxChar(char c){
|
||
if ((unsigned char)c < 32) return true;
|
||
const char* bad = "\\/:*?\"<>|+,;=[]";
|
||
return (strchr(bad, c) != NULL);
|
||
}
|
||
void SanitizeFatxNameInPlace(char* s){
|
||
for (char* p=s; *p; ++p) if (IsBadFatxChar(*p)) *p = '_';
|
||
int n = (int)strlen(s);
|
||
while (n>0 && (s[n-1]==' ' || s[n-1]=='.')) s[--n]=0;
|
||
if (n > 42) { s[42]=0; n=42; }
|
||
if (n==0 || (strcmp(s,".")==0) || (strcmp(s,"..")==0)) strcpy(s, "NewName");
|
||
}
|
||
|
||
// pick char at (row,col) for rows 0-3 of keyboard (respects case)
|
||
char KbCharAt(int row, int col){
|
||
char ch = 0;
|
||
if (row==0) ch = s_kb_r0[col];
|
||
else if (row==1) ch = s_kb_r1[col];
|
||
else if (row==2) ch = s_kb_r2[col];
|
||
else if (row==3) ch = s_kb_r3[col];
|
||
if (m_kbLower && (ch>='A' && ch<='Z')) ch = (char)(ch + ('a' - 'A'));
|
||
return ch;
|
||
}
|
||
|
||
void RefreshPane(Pane& p){
|
||
if (p.mode==1){
|
||
int prevSel = p.sel;
|
||
int prevScroll= p.scroll;
|
||
|
||
ListDirectory(p.curPath, p.items);
|
||
|
||
if (prevSel >= (int)p.items.size()) prevSel = (int)p.items.size()-1;
|
||
if (prevSel < 0) prevSel = 0;
|
||
p.sel = prevSel;
|
||
|
||
int maxScroll = MaxI(0, (int)p.items.size() - m_visible);
|
||
if (prevScroll > maxScroll) prevScroll = maxScroll;
|
||
if (prevScroll < 0) prevScroll = 0;
|
||
p.scroll = prevScroll;
|
||
} else {
|
||
// drives list
|
||
BuildDriveItems(p.items);
|
||
if (p.sel >= (int)p.items.size()) p.sel = (int)p.items.size()-1;
|
||
if (p.sel < 0) p.sel = 0;
|
||
p.scroll = 0;
|
||
}
|
||
}
|
||
|
||
bool ResolveDestDir(char* outDst, size_t cap){
|
||
Pane& dst = m_pane[1 - m_active];
|
||
outDst[0] = 0;
|
||
|
||
if (dst.mode == 1) {
|
||
_snprintf(outDst, (int)cap, "%s", dst.curPath);
|
||
outDst[cap-1]=0;
|
||
NormalizeDirA(outDst);
|
||
return true;
|
||
}
|
||
if (!dst.items.empty()){
|
||
const Item& di = dst.items[dst.sel];
|
||
if (di.isDir && !di.isUpEntry){
|
||
_snprintf(outDst, (int)cap, "%s", di.name); // e.g. "E:\"
|
||
outDst[cap-1]=0;
|
||
NormalizeDirA(outDst);
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// --- file ops helpers
|
||
bool EnsureDirA(const char* path){
|
||
DWORD a = GetFileAttributesA(path);
|
||
if (a != INVALID_FILE_ATTRIBUTES && (a & FILE_ATTRIBUTE_DIRECTORY)) return true;
|
||
return CreateDirectoryA(path, NULL) ? true : false;
|
||
}
|
||
bool CopyFileSimpleA(const char* s, const char* d){ return CopyFileA(s, d, FALSE) ? true : false; }
|
||
bool DeleteRecursiveA(const char* path){
|
||
DWORD a = GetFileAttributesA(path);
|
||
if (a == INVALID_FILE_ATTRIBUTES) return false;
|
||
if (a & FILE_ATTRIBUTE_DIRECTORY){
|
||
char mask[512]; JoinPath(mask, sizeof(mask), path, "*");
|
||
WIN32_FIND_DATAA fd; HANDLE h=FindFirstFileA(mask,&fd);
|
||
if (h != INVALID_HANDLE_VALUE){
|
||
do{
|
||
if (!strcmp(fd.cFileName,".") || !strcmp(fd.cFileName,"..")) continue;
|
||
char sub[512]; JoinPath(sub, sizeof(sub), path, fd.cFileName);
|
||
DeleteRecursiveA(sub);
|
||
}while(FindNextFileA(h,&fd));
|
||
FindClose(h);
|
||
}
|
||
return RemoveDirectoryA(path) ? true : false;
|
||
}else{
|
||
return DeleteFileA(path) ? true : false;
|
||
}
|
||
}
|
||
bool CopyRecursiveA(const char* srcPath, const char* dstDir){
|
||
DWORD a = GetFileAttributesA(srcPath);
|
||
if (a == INVALID_FILE_ATTRIBUTES) return false;
|
||
|
||
const char* base = strrchr(srcPath, '\\');
|
||
base = base ? base+1 : srcPath;
|
||
|
||
char dstPath[512]; JoinPath(dstPath, sizeof(dstPath), dstDir, base);
|
||
|
||
if (a & FILE_ATTRIBUTE_DIRECTORY){
|
||
if (!EnsureDirA(dstPath)) return false;
|
||
char mask[512]; JoinPath(mask, sizeof(mask), srcPath, "*");
|
||
WIN32_FIND_DATAA fd; HANDLE h=FindFirstFileA(mask, &fd);
|
||
if (h != INVALID_HANDLE_VALUE){
|
||
do{
|
||
if (!strcmp(fd.cFileName,".") || !strcmp(fd.cFileName,"..")) continue;
|
||
char subSrc[512]; JoinPath(subSrc, sizeof(subSrc), srcPath, fd.cFileName);
|
||
CopyRecursiveA(subSrc, dstPath);
|
||
}while(FindNextFileA(h,&fd));
|
||
FindClose(h);
|
||
}
|
||
return true;
|
||
}else{
|
||
return CopyFileSimpleA(srcPath, dstPath);
|
||
}
|
||
}
|
||
ULONGLONG DirSizeRecursiveA(const char* path){
|
||
ULONGLONG sum = 0;
|
||
DWORD a = GetFileAttributesA(path);
|
||
if (a == INVALID_FILE_ATTRIBUTES) return 0;
|
||
|
||
if (a & FILE_ATTRIBUTE_DIRECTORY){
|
||
char mask[512]; JoinPath(mask, sizeof(mask), path, "*");
|
||
WIN32_FIND_DATAA fd; HANDLE h = FindFirstFileA(mask, &fd);
|
||
if (h != INVALID_HANDLE_VALUE){
|
||
do{
|
||
if (!strcmp(fd.cFileName,".") || !strcmp(fd.cFileName,"..")) continue;
|
||
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY){
|
||
char sub[512]; JoinPath(sub, sizeof(sub), path, fd.cFileName);
|
||
sum += DirSizeRecursiveA(sub);
|
||
} else {
|
||
sum += (((ULONGLONG)fd.nFileSizeHigh)<<32) | fd.nFileSizeLow;
|
||
}
|
||
} while (FindNextFileA(h, &fd));
|
||
FindClose(h);
|
||
}
|
||
} else {
|
||
WIN32_FILE_ATTRIBUTE_DATA fad;
|
||
if (GetFileAttributesExA(path, GetFileExInfoStandard, &fad)){
|
||
sum += (((ULONGLONG)fad.nFileSizeHigh)<<32) | fad.nFileSizeLow;
|
||
}
|
||
}
|
||
return sum;
|
||
}
|
||
|
||
void AddMenuItem(const char* label, Action act, bool enabled){
|
||
m_menu[m_menuCount].label = label;
|
||
m_menu[m_menuCount].act = act;
|
||
m_menu[m_menuCount].enabled = enabled;
|
||
++m_menuCount;
|
||
}
|
||
|
||
bool DirExistsA(const char* path){
|
||
DWORD a = GetFileAttributesA(path);
|
||
return (a != INVALID_FILE_ATTRIBUTES) && (a & FILE_ATTRIBUTE_DIRECTORY);
|
||
}
|
||
|
||
void SelectItemInPane(Pane& p, const char* name){
|
||
if (!name || p.items.empty()) return;
|
||
for (int i=0;i<(int)p.items.size();++i){
|
||
if (_stricmp(p.items[i].name, name) == 0){
|
||
p.sel = i;
|
||
if (p.sel < p.scroll) p.scroll = p.sel;
|
||
if (p.sel >= p.scroll + m_visible) p.scroll = p.sel - (m_visible - 1);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
// --- context menu
|
||
void BuildContextMenu(){
|
||
Pane& p = m_pane[m_active];
|
||
bool inDir = (p.mode == 1);
|
||
bool hasSel = !p.items.empty();
|
||
|
||
m_menuCount = 0;
|
||
|
||
if (inDir) AddMenuItem("Open", ACT_OPEN, hasSel);
|
||
AddMenuItem("Copy", ACT_COPY, hasSel);
|
||
AddMenuItem("Move", ACT_MOVE, hasSel);
|
||
AddMenuItem("Delete", ACT_DELETE, hasSel);
|
||
AddMenuItem("Rename", ACT_RENAME, hasSel);
|
||
AddMenuItem("Make new folder", ACT_MKDIR, inDir);
|
||
AddMenuItem("Calculate size", ACT_CALCSIZE, hasSel);
|
||
AddMenuItem("Go to root", ACT_GOROOT, inDir);
|
||
AddMenuItem("Switch pane", ACT_SWITCHMEDIA,true);
|
||
|
||
if (m_menuSel >= m_menuCount) m_menuSel = m_menuCount-1;
|
||
if (m_menuSel < 0) m_menuSel = 0;
|
||
}
|
||
void OpenMenu(){ BuildContextMenu(); m_menuOpen=true; m_mode=MODE_MENU; }
|
||
|
||
// >>> CHANGED: only switch to BROWSE if we were actually in MENU
|
||
void CloseMenu(){
|
||
m_menuOpen = false;
|
||
if (m_mode == MODE_MENU)
|
||
m_mode = MODE_BROWSE;
|
||
}
|
||
|
||
// --- Rename UI lifecycle
|
||
void BeginRename(const char* parentDir, const char* oldName){
|
||
// ensure any context menu is hidden, but do NOT stomp the new mode
|
||
m_menuOpen = false;
|
||
|
||
m_renActive = true;
|
||
_snprintf(m_renParent, sizeof(m_renParent), "%s", parentDir);
|
||
m_renParent[sizeof(m_renParent)-1]=0;
|
||
_snprintf(m_renOld, sizeof(m_renOld), "%s", oldName);
|
||
m_renOld[sizeof(m_renOld)-1]=0;
|
||
_snprintf(m_renBuf, sizeof(m_renBuf), "%s", oldName);
|
||
m_renBuf[sizeof(m_renBuf)-1]=0;
|
||
m_renCursor = (int)strlen(m_renBuf);
|
||
m_renSelRow = 0; m_renSelCol = 0;
|
||
m_mode = MODE_RENAME;
|
||
}
|
||
void CancelRename(){
|
||
m_renActive = false;
|
||
m_mode = MODE_BROWSE;
|
||
}
|
||
void AcceptRename(){
|
||
SanitizeFatxNameInPlace(m_renBuf);
|
||
if (_stricmp(m_renBuf, m_renOld)==0){ SetStatus("No change"); CancelRename(); return; }
|
||
|
||
char oldPath[512]; JoinPath(oldPath, sizeof(oldPath), m_renParent, m_renOld);
|
||
char newPath[512]; JoinPath(newPath, sizeof(newPath), m_renParent, m_renBuf);
|
||
|
||
if (MoveFileA(oldPath, newPath)){
|
||
SetStatus("Renamed to %s", m_renBuf);
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
Pane& ap = m_pane[m_active];
|
||
if (ap.mode==1 && _stricmp(ap.curPath, m_renParent)==0){
|
||
SelectItemInPane(ap, m_renBuf);
|
||
}
|
||
}else{
|
||
SetStatusLastErr("Rename failed");
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
}
|
||
CancelRename();
|
||
}
|
||
|
||
void OnPad_Rename(const XBGAMEPAD& pad)
|
||
{
|
||
const DWORD btn = pad.wButtons;
|
||
|
||
// Edge-detected digital buttons + allow quick analog nudge
|
||
bool up = ((btn & XINPUT_GAMEPAD_DPAD_UP) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_UP)) || (pad.sThumbLY > 16000);
|
||
bool down = ((btn & XINPUT_GAMEPAD_DPAD_DOWN) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_DOWN)) || (pad.sThumbLY < -16000);
|
||
bool left = ((btn & XINPUT_GAMEPAD_DPAD_LEFT) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_LEFT)) || (pad.sThumbLX < -16000);
|
||
bool right = ((btn & XINPUT_GAMEPAD_DPAD_RIGHT) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_RIGHT)) || (pad.sThumbLX > 16000);
|
||
|
||
if (up) { if (m_renSelRow > 0) m_renSelRow--; Sleep(120); }
|
||
if (down) { if (m_renSelRow < 4) m_renSelRow++; Sleep(120); }
|
||
|
||
int cols = s_kb_cols[m_renSelRow];
|
||
if (m_renSelCol >= cols) m_renSelCol = cols - 1;
|
||
|
||
if (left) { if (m_renSelCol > 0) m_renSelCol--; Sleep(120); }
|
||
if (right) { if (m_renSelCol < cols - 1) m_renSelCol++; Sleep(120); }
|
||
|
||
// Edge-detect face buttons
|
||
unsigned char a = pad.bAnalogButtons[XINPUT_GAMEPAD_A];
|
||
unsigned char b = pad.bAnalogButtons[XINPUT_GAMEPAD_B];
|
||
unsigned char y = pad.bAnalogButtons[XINPUT_GAMEPAD_Y];
|
||
unsigned char w = pad.bAnalogButtons[XINPUT_GAMEPAD_WHITE];
|
||
unsigned char k = pad.bAnalogButtons[XINPUT_GAMEPAD_BLACK];
|
||
|
||
bool aTrig = (a > 30 && m_prevA <= 30);
|
||
bool bTrig = (b > 30 && m_prevB <= 30);
|
||
bool yTrig = (y > 30 && m_prevY <= 30);
|
||
bool startTrig = ((btn & XINPUT_GAMEPAD_START) && !(m_prevButtons & XINPUT_GAMEPAD_START));
|
||
|
||
// Toggle case with Y
|
||
if (yTrig){ m_kbLower = !m_kbLower; Sleep(120); }
|
||
|
||
if (aTrig){
|
||
if (m_renSelRow <= 3){
|
||
// Insert selected char at cursor
|
||
int len = (int)strlen(m_renBuf);
|
||
const int cap = (int)sizeof(m_renBuf) - 1;
|
||
if (len < cap){
|
||
char ch = KbCharAt(m_renSelRow, m_renSelCol);
|
||
for (int i=len; i>=m_renCursor; --i) m_renBuf[i+1] = m_renBuf[i];
|
||
m_renBuf[m_renCursor++] = ch;
|
||
}
|
||
}else{
|
||
// Bottom-row actions: 0=Backspace 1=Space 2=Aa 3=OK 4=Cancel
|
||
if (m_renSelCol == 0){ // Backspace
|
||
if (m_renCursor > 0){
|
||
int len = (int)strlen(m_renBuf);
|
||
for (int i=m_renCursor-1; i<=len; ++i) m_renBuf[i] = m_renBuf[i+1];
|
||
m_renCursor--;
|
||
}
|
||
}else if (m_renSelCol == 1){ // Space
|
||
int len = (int)strlen(m_renBuf);
|
||
const int cap = (int)sizeof(m_renBuf) - 1;
|
||
if (len < cap){
|
||
for (int i=len; i>=m_renCursor; --i) m_renBuf[i+1] = m_renBuf[i];
|
||
m_renBuf[m_renCursor++] = ' ';
|
||
}
|
||
}else if (m_renSelCol == 2){ // Aa toggle
|
||
m_kbLower = !m_kbLower;
|
||
}else if (m_renSelCol == 3){ // OK
|
||
AcceptRename();
|
||
m_prevA=a; m_prevB=b; m_prevY=y; m_prevButtons=btn; m_prevWhite=w; m_prevBlack=k;
|
||
return;
|
||
}else if (m_renSelCol == 4){ // Cancel
|
||
CancelRename();
|
||
m_prevA=a; m_prevB=b; m_prevY=y; m_prevButtons=btn; m_prevWhite=w; m_prevBlack=k;
|
||
return;
|
||
}
|
||
}
|
||
Sleep(140);
|
||
}
|
||
|
||
if (startTrig){
|
||
AcceptRename();
|
||
m_prevA=a; m_prevB=b; m_prevY=y; m_prevButtons=btn; m_prevWhite=w; m_prevBlack=k;
|
||
return;
|
||
}
|
||
if (bTrig){
|
||
CancelRename();
|
||
m_prevA=a; m_prevB=b; m_prevY=y; m_prevButtons=btn; m_prevWhite=w; m_prevBlack=k;
|
||
return;
|
||
}
|
||
|
||
// Move caret with White/Black (edge-detected)
|
||
bool wTrig = (w > 30 && m_prevWhite <= 30);
|
||
bool kTrig = (k > 30 && m_prevBlack <= 30);
|
||
|
||
if (wTrig){ if (m_renCursor > 0) m_renCursor--; }
|
||
if (kTrig){ int len=(int)strlen(m_renBuf); if (m_renCursor < len) m_renCursor++; }
|
||
|
||
// Clamp caret
|
||
{
|
||
int len=(int)strlen(m_renBuf);
|
||
if (m_renCursor < 0) m_renCursor = 0;
|
||
if (m_renCursor > len) m_renCursor = len;
|
||
}
|
||
|
||
// Save previous for edge detection next frame
|
||
m_prevA = a;
|
||
m_prevB = b;
|
||
m_prevY = y;
|
||
m_prevButtons = btn;
|
||
m_prevWhite = w;
|
||
m_prevBlack = k;
|
||
}
|
||
|
||
void OnPad_Menu(const XBGAMEPAD& pad)
|
||
{
|
||
const DWORD btn = pad.wButtons;
|
||
|
||
// Edge-detected dpad (like keyboard) + allow quick analog nudge
|
||
bool up = ((btn & XINPUT_GAMEPAD_DPAD_UP) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_UP)) || (pad.sThumbLY > 16000);
|
||
bool down = ((btn & XINPUT_GAMEPAD_DPAD_DOWN) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_DOWN)) || (pad.sThumbLY < -16000);
|
||
|
||
if (up) { if (m_menuSel > 0) --m_menuSel; }
|
||
if (down) { if (m_menuSel < m_menuCount-1) ++m_menuSel; }
|
||
|
||
// Edge-detect face buttons
|
||
unsigned char a = pad.bAnalogButtons[XINPUT_GAMEPAD_A];
|
||
unsigned char b = pad.bAnalogButtons[XINPUT_GAMEPAD_B];
|
||
unsigned char x = pad.bAnalogButtons[XINPUT_GAMEPAD_X];
|
||
|
||
bool aTrig = (a > 30 && m_prevA <= 30);
|
||
bool bTrig = (b > 30 && m_prevB <= 30);
|
||
bool xTrig = (x > 30 && m_prevX <= 30);
|
||
|
||
if (aTrig) {
|
||
const MenuItem& mi = m_menu[m_menuSel];
|
||
if (mi.enabled) ExecuteAction(mi.act); // may close menu / change mode
|
||
} else if (bTrig || xTrig) {
|
||
CloseMenu();
|
||
}
|
||
|
||
// Save previous states for next frame
|
||
m_prevButtons = btn;
|
||
m_prevA = a; m_prevB = b; m_prevX = x;
|
||
m_prevWhite = pad.bAnalogButtons[XINPUT_GAMEPAD_WHITE];
|
||
m_prevBlack = pad.bAnalogButtons[XINPUT_GAMEPAD_BLACK];
|
||
}
|
||
|
||
void DrawRename(){
|
||
if (!m_renActive) return;
|
||
|
||
D3DVIEWPORT8 vp; m_pd3dDevice->GetViewport(&vp);
|
||
const FLOAT panelW = MaxF(520.0f, vp.Width * 0.55f);
|
||
const FLOAT panelH = MaxF(280.0f, vp.Height*0.45f);
|
||
const FLOAT x = Snap((vp.Width - panelW)*0.5f);
|
||
const FLOAT y = Snap((vp.Height - panelH)*0.5f);
|
||
|
||
DrawRect(x-8, y-8, panelW+16, panelH+16, 0xA0101010);
|
||
DrawRect(x, y, panelW, panelH, 0xE0222222);
|
||
|
||
DrawAnsi(m_font, x+12, y+8, 0xFFFFFFFF, "Rename");
|
||
DrawHLine(x, y+28, panelW, 0x60FFFFFF);
|
||
|
||
char hdr[640];
|
||
_snprintf(hdr, sizeof(hdr), "In: %s", m_renParent); hdr[sizeof(hdr)-1]=0;
|
||
DrawAnsi(m_font, x+12, y+34, 0xFFCCCCCC, hdr);
|
||
|
||
const FLOAT boxY = Snap(y + 60.0f);
|
||
const FLOAT boxH = 30.0f;
|
||
DrawRect(x+12, boxY, panelW-24, boxH, 0xFF0E0E0E);
|
||
|
||
// text
|
||
DrawAnsi(m_font, x+18, boxY+4, 0xFFFFFF00, m_renBuf);
|
||
|
||
// caret at cursor
|
||
char tmp = m_renBuf[m_renCursor];
|
||
m_renBuf[m_renCursor] = 0;
|
||
FLOAT caretX = Snap(x+18 + MeasureTextW(m_renBuf));
|
||
m_renBuf[m_renCursor] = tmp;
|
||
DrawRect(caretX, boxY+4, 2.0f, boxH-8.0f, 0x90FFFF00);
|
||
|
||
// keyboard grid (integer-snap to avoid drift)
|
||
const FLOAT padX = 12.0f;
|
||
const FLOAT contentW = panelW - 2.0f*padX;
|
||
const FLOAT cellH = kLineH + 6.0f;
|
||
const FLOAT gridTop = Snap(boxY + boxH + 16.0f);
|
||
|
||
// visual gaps between keys
|
||
const FLOAT gapX = 6.0f; // horizontal gap between keys
|
||
const FLOAT gapY = 4.0f; // vertical gap
|
||
|
||
const FLOAT colW12 = contentW / 12.0f;
|
||
|
||
for (int row=0; row<5; ++row){
|
||
int cols = s_kb_cols[row];
|
||
FLOAT rowY = Snap(gridTop + row*(cellH + gapY));
|
||
|
||
for (int col=0; col<cols; ++col){
|
||
// raw cell edges
|
||
FLOAT x0, x1;
|
||
if (row < 4){
|
||
x0 = Snap(x + padX + col * colW12);
|
||
x1 = Snap(x + padX + (col + 1) * colW12);
|
||
}else{
|
||
FLOAT colW = contentW / (FLOAT)cols;
|
||
x0 = Snap(x + padX + col * colW);
|
||
x1 = Snap(x + padX + (col + 1) * colW);
|
||
}
|
||
|
||
// make highlight symmetric: half gap left + half right
|
||
const FLOAT drawX = x0 + gapX * 0.5f;
|
||
const FLOAT drawW = (x1 - x0) - gapX;
|
||
const bool sel = (row==m_renSelRow && col==m_renSelCol);
|
||
|
||
DrawRect(drawX, rowY, drawW, cellH, sel ? 0x60FFFF00 : 0x30202020);
|
||
|
||
// label text (centered)
|
||
if (row < 4){
|
||
char s[2]; s[0] = KbCharAt(row, col); s[1] = 0;
|
||
FLOAT tw, th; MeasureTextWH(s, tw, th);
|
||
const FLOAT tx = Snap(drawX + (drawW - tw) * 0.5f);
|
||
const FLOAT ty = Snap(rowY + (cellH - th) * 0.5f);
|
||
DrawAnsi(m_font, tx, ty, 0xFFE0E0E0, s);
|
||
}else{
|
||
const char* cap =
|
||
(col==0) ? "Backspace" :
|
||
(col==1) ? "Space" :
|
||
(col==2) ? "Aa" :
|
||
(col==3) ? "OK" : "Cancel";
|
||
FLOAT tw, th; MeasureTextWH(cap, tw, th);
|
||
const FLOAT tx = Snap(drawX + (drawW - tw) * 0.5f);
|
||
const FLOAT ty = Snap(rowY + (cellH - th) * 0.5f);
|
||
DrawAnsi(m_font, tx, ty, 0xFFE0E0E0, cap);
|
||
}
|
||
}
|
||
}
|
||
|
||
DrawAnsi(m_font, x+12, y+panelH-20, 0xFFBBBBBB,
|
||
"A: Select B: Cancel Start: OK Y/Aa: Case White/Black: Move cursor");
|
||
}
|
||
|
||
void ExecuteAction(Action act){
|
||
Pane& src = m_pane[m_active];
|
||
Pane& dst = m_pane[1 - m_active];
|
||
|
||
const Item* sel = NULL;
|
||
if (!src.items.empty()) sel = &src.items[src.sel];
|
||
|
||
char srcFull[512]="";
|
||
if (sel && src.mode==1 && !sel->isUpEntry) JoinPath(srcFull, sizeof(srcFull), src.curPath, sel->name);
|
||
|
||
switch (act){
|
||
case ACT_OPEN:
|
||
if (sel){
|
||
if (sel->isUpEntry) { UpOne(src); }
|
||
else if (sel->isDir) { EnterSelection(src); }
|
||
}
|
||
CloseMenu(); break;
|
||
|
||
case ACT_COPY:
|
||
{
|
||
if (!sel || sel->isUpEntry) { SetStatus("Nothing to copy"); CloseMenu(); break; }
|
||
|
||
char dstDir[512];
|
||
if (!ResolveDestDir(dstDir, sizeof(dstDir))) {
|
||
SetStatus("Pick a destination (open a folder or select a drive)");
|
||
CloseMenu(); break;
|
||
}
|
||
if ((dstDir[0]=='D' || dstDir[0]=='d') && dstDir[1]==':') {
|
||
SetStatus("Cannot copy to D:\\ (read-only)");
|
||
CloseMenu(); break;
|
||
}
|
||
|
||
NormalizeDirA(dstDir);
|
||
if (!CanWriteHereA(dstDir)){
|
||
SetStatusLastErr("Dest not writable");
|
||
CloseMenu(); break;
|
||
}
|
||
|
||
if (CopyRecursiveA(srcFull, dstDir)) {
|
||
Pane& dstp = m_pane[1 - m_active];
|
||
if (dstp.mode==1 && _stricmp(dstp.curPath, dstDir)==0) ListDirectory(dstp.curPath, dstp.items);
|
||
SetStatus("Copied to %s", dstDir);
|
||
} else {
|
||
SetStatusLastErr("Copy failed");
|
||
}
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
CloseMenu();
|
||
break;
|
||
}
|
||
|
||
case ACT_MOVE:
|
||
{
|
||
if (!sel || sel->isUpEntry) { SetStatus("Nothing to move"); CloseMenu(); break; }
|
||
|
||
char dstDir[512];
|
||
if (!ResolveDestDir(dstDir, sizeof(dstDir))) {
|
||
SetStatus("Pick a destination (open a folder or select a drive)");
|
||
CloseMenu(); break;
|
||
}
|
||
if ((dstDir[0]=='D' || dstDir[0]=='d') && dstDir[1]==':') {
|
||
SetStatus("Cannot move to D:\\ (read-only)");
|
||
CloseMenu(); break;
|
||
}
|
||
|
||
NormalizeDirA(dstDir);
|
||
if (!CanWriteHereA(dstDir)){
|
||
SetStatusLastErr("Dest not writable");
|
||
CloseMenu(); break;
|
||
}
|
||
|
||
if (CopyRecursiveA(srcFull, dstDir)) {
|
||
if (!DeleteRecursiveA(srcFull)) {
|
||
SetStatusLastErr("Move: delete source failed");
|
||
} else {
|
||
Pane& srcp = m_pane[m_active];
|
||
Pane& dstp = m_pane[1 - m_active];
|
||
if (dstp.mode==1 && _stricmp(dstp.curPath, dstDir)==0) ListDirectory(dstp.curPath, dstp.items);
|
||
if (srcp.mode==1) { ListDirectory(srcp.curPath, srcp.items); if (srcp.sel >= (int)srcp.items.size()) srcp.sel = (int)srcp.items.size()-1; }
|
||
SetStatus("Moved to %s", dstDir);
|
||
}
|
||
} else {
|
||
SetStatusLastErr("Move: copy failed");
|
||
}
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
CloseMenu();
|
||
break;
|
||
}
|
||
|
||
case ACT_DELETE:
|
||
if (sel){
|
||
if (DeleteRecursiveA(srcFull)){
|
||
ListDirectory(src.curPath, src.items);
|
||
if (src.sel >= (int)src.items.size()) src.sel = (int)src.items.size()-1;
|
||
SetStatus("Deleted");
|
||
} else SetStatus("Delete failed");
|
||
}
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
CloseMenu(); break;
|
||
|
||
case ACT_RENAME:
|
||
{
|
||
if (sel && src.mode==1 && !sel->isUpEntry){
|
||
BeginRename(src.curPath, sel->name); // BeginRename will hide menu & set MODE_RENAME
|
||
CloseMenu(); // safe (won't change mode unless we were in MENU)
|
||
} else {
|
||
SetStatus("Open a folder and select an item");
|
||
CloseMenu();
|
||
}
|
||
break;
|
||
}
|
||
|
||
case ACT_MKDIR:
|
||
{
|
||
char baseDir[512] = {0};
|
||
|
||
if (src.mode == 1) {
|
||
_snprintf(baseDir, sizeof(baseDir), "%s", src.curPath);
|
||
} else if (!src.items.empty()) {
|
||
const Item& di = src.items[src.sel];
|
||
if (di.isDir && !di.isUpEntry) {
|
||
_snprintf(baseDir, sizeof(baseDir), "%s", di.name); // e.g. "E:\"
|
||
}
|
||
}
|
||
baseDir[sizeof(baseDir)-1] = 0;
|
||
if (!baseDir[0]) { SetStatus("Open a folder or select a drive first"); CloseMenu(); break; }
|
||
|
||
if ((baseDir[0]=='D' || baseDir[0]=='d') && baseDir[1]==':') {
|
||
SetStatus("Cannot create on D:\\ (read-only)"); CloseMenu(); break;
|
||
}
|
||
|
||
NormalizeDirA(baseDir);
|
||
if (!CanWriteHereA(baseDir)) { SetStatusLastErr("Dest not writable"); CloseMenu(); break; }
|
||
|
||
char nameBuf[64];
|
||
char target[512];
|
||
int idx = 0;
|
||
for (;;){
|
||
if (idx == 0) _snprintf(nameBuf, sizeof(nameBuf), "NewFolder");
|
||
else _snprintf(nameBuf, sizeof(nameBuf), "NewFolder%d", idx);
|
||
nameBuf[sizeof(nameBuf)-1]=0;
|
||
|
||
JoinPath(target, sizeof(target), baseDir, nameBuf);
|
||
|
||
if (!DirExistsA(target)) {
|
||
if (CreateDirectoryA(target, NULL)) {
|
||
SetStatus("Created %s", nameBuf);
|
||
} else {
|
||
SetStatusLastErr("Create folder failed");
|
||
}
|
||
break;
|
||
}
|
||
if (++idx > 999){ SetStatus("Create folder failed (names exhausted)"); break; }
|
||
}
|
||
|
||
RefreshPane(m_pane[0]); RefreshPane(m_pane[1]);
|
||
|
||
if (src.mode == 1 && _stricmp(src.curPath, baseDir) == 0) {
|
||
SelectItemInPane(src, nameBuf);
|
||
}
|
||
|
||
CloseMenu();
|
||
break;
|
||
}
|
||
|
||
case ACT_CALCSIZE:
|
||
if (sel){
|
||
ULONGLONG bytes = DirSizeRecursiveA(srcFull);
|
||
char tmp[64]; FormatSize(bytes, tmp, sizeof(tmp));
|
||
SetStatus("%s", tmp);
|
||
}
|
||
CloseMenu(); break;
|
||
|
||
case ACT_GOROOT:
|
||
{
|
||
if (src.mode == 1){
|
||
if (!IsDriveRoot(src.curPath)){
|
||
// go to current drive’s root
|
||
char root[4] = { src.curPath[0], ':', '\\', 0 };
|
||
strncpy(src.curPath, root, sizeof(src.curPath)-1);
|
||
src.curPath[3] = 0;
|
||
src.sel = 0; src.scroll = 0;
|
||
ListDirectory(src.curPath, src.items);
|
||
} else {
|
||
// already at root -> show all drives
|
||
src.mode = 0; src.curPath[0] = 0; src.sel = 0; src.scroll = 0;
|
||
BuildDriveItems(src.items);
|
||
}
|
||
} else {
|
||
// if we were on the drives list already, just ensure it’s built
|
||
BuildDriveItems(src.items);
|
||
}
|
||
CloseMenu();
|
||
break;
|
||
}
|
||
|
||
case ACT_SWITCHMEDIA:
|
||
m_active = 1 - m_active; CloseMenu(); break;
|
||
}
|
||
}
|
||
|
||
void DrawMenu(){
|
||
if (!m_menuOpen) return;
|
||
|
||
const FLOAT menuW = 340.0f;
|
||
const FLOAT rowH = kLineH + 6.0f;
|
||
const FLOAT menuH = 12.0f + m_menuCount*rowH + 12.0f;
|
||
|
||
const FLOAT paneX = (m_active==0) ? kListX_L : (kListX_L + kListW + kPaneGap);
|
||
const FLOAT x = paneX + (kListW - menuW)*0.5f;
|
||
const FLOAT y = kListY + 20.0f;
|
||
|
||
// backdrop
|
||
DrawRect(x-6.0f, y-6.0f, menuW+12.0f, menuH+12.0f, 0xA0101010);
|
||
DrawRect(x, y, menuW, menuH, 0xE0222222);
|
||
|
||
// title
|
||
DrawAnsi(m_font, x+10.0f, y+6.0f, 0xFFFFFFFF, "Select action");
|
||
DrawHLine(x, y+26.0f, menuW, 0x60FFFFFF);
|
||
|
||
// items
|
||
FLOAT iy = y + 30.0f;
|
||
for (int i=0;i<m_menuCount;++i){
|
||
bool sel = (i == m_menuSel);
|
||
D3DCOLOR row = sel ? 0x60FFFF00 : 0x20202020;
|
||
DrawRect(x+6.0f, iy-2.0f, menuW-12.0f, rowH, row);
|
||
|
||
const MenuItem& mi = m_menu[i];
|
||
DWORD col = mi.enabled? (sel?0xFF202020:0xFFE0E0E0) : 0xFF7A7A7A;
|
||
DrawAnsi(m_font, x+16.0f, iy, col, mi.label);
|
||
iy += rowH;
|
||
}
|
||
}
|
||
|
||
HRESULT Initialize(){
|
||
if (FAILED(m_font.Create("D:\\Media\\Font.xpr", 0))) {
|
||
m_font.Create("D:\\Media\\CourierNew.xpr", 0);
|
||
}
|
||
XBInput_CreateGamepads(); MapStandardDrives_Io(); RescanDrives();
|
||
BuildDriveItems(m_pane[0].items); BuildDriveItems(m_pane[1].items);
|
||
|
||
// compute resolution-aware layout from viewport
|
||
D3DVIEWPORT8 vp; m_pd3dDevice->GetViewport(&vp);
|
||
|
||
const FLOAT sideMargin = MaxF(24.0f, vp.Width * 0.04f);
|
||
const FLOAT gap = MaxF(24.0f, vp.Width * 0.035f);
|
||
|
||
kPaneGap = gap;
|
||
kListX_L = sideMargin;
|
||
|
||
const FLOAT totalUsable = (FLOAT)vp.Width - (sideMargin * 2.0f) - gap;
|
||
kListW = MaxF(260.0f, (totalUsable / 2.0f) - 10.0f);
|
||
|
||
kHdrW = kListW + 30.0f;
|
||
kHdrY = MaxF(12.0f, vp.Height * 0.03f);
|
||
kHdrH = MaxF(22.0f, vp.Height * 0.04f);
|
||
kListY = MaxF(60.0f, kHdrY + kHdrH + 34.0f); // room under "Name/Size"
|
||
|
||
kLineH = MaxF(22.0f, vp.Height * 0.036f);
|
||
|
||
// compute rows by viewport (leave footer space)
|
||
FLOAT bottomY = (FLOAT)vp.Height - MaxF(48.0f, vp.Height * 0.09f);
|
||
FLOAT usableH = bottomY - kListY; if (usableH < 0) usableH = 0;
|
||
m_visible = (int)(usableH / kLineH); if (m_visible < 6) m_visible=6; if (m_visible>30) m_visible=30;
|
||
|
||
return S_OK;
|
||
}
|
||
|
||
void EnsureListing(Pane& p){
|
||
if (p.mode==0) BuildDriveItems(p.items);
|
||
else ListDirectory(p.curPath, p.items);
|
||
|
||
if (p.sel >= (int)p.items.size()) p.sel = (int)p.items.size()-1;
|
||
if (p.sel < 0) p.sel = 0;
|
||
|
||
if (p.scroll > p.sel) p.scroll = p.sel;
|
||
int maxScroll = MaxI(0, (int)p.items.size() - m_visible);
|
||
if (p.scroll > maxScroll) p.scroll = maxScroll;
|
||
}
|
||
|
||
void EnterSelection(Pane& p){
|
||
if (p.items.empty()) return;
|
||
const Item& it = p.items[p.sel];
|
||
if (p.mode==0){ // into drive
|
||
strncpy(p.curPath,it.name,sizeof(p.curPath)-1); p.curPath[sizeof(p.curPath)-1]=0;
|
||
p.mode=1; p.sel=0; p.scroll=0; ListDirectory(p.curPath,p.items); return;
|
||
}
|
||
if (it.isUpEntry){
|
||
if (strlen(p.curPath)<=3){ p.mode=0; p.sel=0; p.scroll=0; BuildDriveItems(p.items); p.curPath[0]=0; }
|
||
else { ParentPath(p.curPath); p.sel=0; p.scroll=0; ListDirectory(p.curPath,p.items); }
|
||
return;
|
||
}
|
||
if (it.isDir){
|
||
char next[512]; JoinPath(next,sizeof(next),p.curPath,it.name);
|
||
strncpy(p.curPath,next,sizeof(p.curPath)-1); p.curPath[sizeof(p.curPath)-1]=0;
|
||
p.sel=0; p.scroll=0; ListDirectory(p.curPath,p.items); return;
|
||
}
|
||
// files: no-op in this build
|
||
}
|
||
|
||
void UpOne(Pane& p){
|
||
if (p.mode==0) return;
|
||
if (strlen(p.curPath)<=3){ p.mode=0; p.sel=0; p.scroll=0; BuildDriveItems(p.items); p.curPath[0]=0; return; }
|
||
ParentPath(p.curPath); p.sel=0; p.scroll=0; ListDirectory(p.curPath,p.items);
|
||
}
|
||
|
||
void OnPad(const XBGAMEPAD& pad){
|
||
// Rename modal takes over
|
||
if (m_mode == MODE_RENAME){ OnPad_Rename(pad); return; }
|
||
|
||
// Context menu modal
|
||
if (m_mode == MODE_MENU){ OnPad_Menu(pad); return; }
|
||
|
||
// Browse mode
|
||
OnPad_Browse(pad);
|
||
}
|
||
|
||
|
||
|
||
void OnPad_Browse(const XBGAMEPAD& pad)
|
||
{
|
||
const DWORD btn = pad.wButtons;
|
||
Pane& p = m_pane[m_active];
|
||
|
||
// -------- NAVIGATION (auto-repeat with initial delay) --------
|
||
const DWORD now = GetTickCount();
|
||
const int kDead = 16000; // analog deadzone
|
||
const DWORD kInit = 230; // ms before first repeat
|
||
const DWORD kRep = 120; // ms between repeats
|
||
|
||
int ud = 0;
|
||
if ((btn & XINPUT_GAMEPAD_DPAD_UP) || pad.sThumbLY > kDead) ud = -1;
|
||
if ((btn & XINPUT_GAMEPAD_DPAD_DOWN) || pad.sThumbLY < -kDead) ud = +1;
|
||
|
||
if (ud == 0){
|
||
m_navUDHeld = false;
|
||
m_navUDDir = 0;
|
||
}else{
|
||
if (!m_navUDHeld || m_navUDDir != ud){
|
||
// first step immediately
|
||
if (ud < 0){
|
||
if (p.sel > 0){ --p.sel; if (p.sel < p.scroll) p.scroll = p.sel; }
|
||
}else{
|
||
int maxSel = (int)p.items.size() - 1;
|
||
if (p.sel < maxSel){ ++p.sel; if (p.sel >= p.scroll + m_visible) p.scroll = p.sel - (m_visible - 1); }
|
||
}
|
||
m_navUDHeld = true;
|
||
m_navUDDir = ud;
|
||
m_navUDNext = now + kInit;
|
||
}else if (now >= m_navUDNext){
|
||
// held long enough -> repeat
|
||
if (ud < 0){
|
||
if (p.sel > 0){ --p.sel; if (p.sel < p.scroll) p.scroll = p.sel; }
|
||
}else{
|
||
int maxSel = (int)p.items.size() - 1;
|
||
if (p.sel < maxSel){ ++p.sel; if (p.sel >= p.scroll + m_visible) p.scroll = p.sel - (m_visible - 1); }
|
||
}
|
||
m_navUDNext = now + kRep;
|
||
}
|
||
}
|
||
// Pane switch (edge-detected, no repeat)
|
||
bool leftTrig = (btn & XINPUT_GAMEPAD_DPAD_LEFT) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_LEFT);
|
||
bool rightTrig = (btn & XINPUT_GAMEPAD_DPAD_RIGHT) && !(m_prevButtons & XINPUT_GAMEPAD_DPAD_RIGHT);
|
||
if (leftTrig) m_active = 0;
|
||
if (rightTrig) m_active = 1;
|
||
|
||
// -------- Other buttons (edge-detected) --------
|
||
unsigned char a = pad.bAnalogButtons[XINPUT_GAMEPAD_A];
|
||
unsigned char b = pad.bAnalogButtons[XINPUT_GAMEPAD_B];
|
||
unsigned char x = pad.bAnalogButtons[XINPUT_GAMEPAD_X];
|
||
unsigned char w = pad.bAnalogButtons[XINPUT_GAMEPAD_WHITE]; // page down
|
||
unsigned char k = pad.bAnalogButtons[XINPUT_GAMEPAD_BLACK]; // page up
|
||
|
||
bool aTrig = (a > 30 && m_prevA <= 30);
|
||
bool bTrig = (b > 30 && m_prevB <= 30);
|
||
bool xTrig = (x > 30 && m_prevX <= 30);
|
||
bool wTrig = (w > 30 && m_prevWhite <= 30);
|
||
bool kTrig = (k > 30 && m_prevBlack <= 30);
|
||
bool startTrig = ((btn & XINPUT_GAMEPAD_START) && !(m_prevButtons & XINPUT_GAMEPAD_START));
|
||
|
||
if (xTrig) { OpenMenu(); goto store_prev; } // open once
|
||
|
||
if (aTrig) EnterSelection(p);
|
||
if (bTrig) UpOne(p);
|
||
|
||
if (kTrig){ // BLACK: page up
|
||
p.sel -= m_visible; if (p.sel < 0) p.sel = 0;
|
||
if (p.sel < p.scroll) p.scroll = p.sel;
|
||
}
|
||
if (wTrig){ // WHITE: page down
|
||
int maxSel = (int)p.items.size()-1;
|
||
p.sel += m_visible; if (p.sel > maxSel) p.sel = maxSel;
|
||
if (p.sel >= p.scroll + m_visible) p.scroll = p.sel - (m_visible - 1);
|
||
}
|
||
|
||
if (startTrig){
|
||
MapStandardDrives_Io(); RescanDrives();
|
||
EnsureListing(m_pane[0]); EnsureListing(m_pane[1]);
|
||
}
|
||
|
||
store_prev:
|
||
// remember states for edge detection next frame
|
||
m_prevButtons = btn;
|
||
m_prevA = a; m_prevB = b; m_prevX = x;
|
||
m_prevWhite = w; m_prevBlack = k;
|
||
}
|
||
|
||
|
||
|
||
HRESULT Render(){
|
||
m_pd3dDevice->Clear(0,NULL,D3DCLEAR_TARGET,0x20202020,1.0f,0);
|
||
m_pd3dDevice->BeginScene();
|
||
m_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
|
||
m_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
|
||
m_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
|
||
|
||
// left + right panes
|
||
DrawPane(kListX_L, m_pane[0], m_active==0);
|
||
DrawPane(kListX_L + kListW + kPaneGap, m_pane[1], m_active==1);
|
||
|
||
// footer
|
||
D3DVIEWPORT8 vp2; m_pd3dDevice->GetViewport(&vp2);
|
||
const FLOAT footerY = (FLOAT)vp2.Height - MaxF(48.0f, vp2.Height * 0.09f);
|
||
DrawRect(HdrX(kListX_L), footerY, kHdrW*2 + kPaneGap + 30.0f, 28.0f, 0x802A2A2A);
|
||
if (m_pane[m_active].mode==0){
|
||
DrawAnsi(m_font, HdrX(kListX_L)+5.0f, footerY+4.0f, 0xFFCCCCCC,
|
||
"D-Pad: Move | Left/Right: Switch pane | A: Enter | X: Menu | Start: Map+Rescan | Black/White: Page");
|
||
} else {
|
||
ULONGLONG fb=0, tb=0; GetDriveFreeTotal(m_pane[m_active].curPath, fb, tb);
|
||
char fstr[64], tstr[64], bar[420];
|
||
FormatSize(fb, fstr, sizeof(fstr)); FormatSize(tb, tstr, sizeof(tstr));
|
||
_snprintf(bar,sizeof(bar),
|
||
"Active: %s | B: Up | Free: %s / Total: %s | Left/Right: Switch pane | X: Menu | Black/White: Page",
|
||
m_active==0?"Left":"Right", fstr, tstr);
|
||
bar[sizeof(bar)-1]=0;
|
||
DrawAnsi(m_font, HdrX(kListX_L)+5.0f, footerY+4.0f, 0xFFCCCCCC, bar);
|
||
}
|
||
|
||
// transient status (over footer, if any)
|
||
DWORD now = GetTickCount();
|
||
if (now < m_statusUntilMs && m_status[0]){
|
||
DrawAnsi(m_font, HdrX(kListX_L)+5.0f, footerY-18.0f, 0xFFBBDDEE, m_status);
|
||
}
|
||
|
||
// modal menu
|
||
DrawMenu();
|
||
|
||
// rename overlay (modal)
|
||
DrawRename();
|
||
|
||
m_pd3dDevice->EndScene(); m_pd3dDevice->Present(NULL,NULL,NULL,NULL);
|
||
return S_OK;
|
||
}
|
||
|
||
// input pump
|
||
HRESULT FrameMove(){
|
||
XBInput_GetInput();
|
||
OnPad(g_Gamepads[0]);
|
||
return S_OK;
|
||
}
|
||
|
||
// pane draw (placed after other methods for readability)
|
||
void DrawPane(FLOAT baseX, Pane& p, bool active){
|
||
// header
|
||
FLOAT hx = HdrX(baseX);
|
||
DrawRect(hx, kHdrY, kHdrW, kHdrH, active ? 0xFF3A3A3A : 0x802A2A2A);
|
||
if (p.mode==0) DrawAnsi(m_font, hx+5.0f, kHdrY+6.0f, 0xFFFFFFFF, "Detected Drives");
|
||
else { char hdr[600]; _snprintf(hdr,sizeof(hdr),"%s", p.curPath); hdr[sizeof(hdr)-1]=0; DrawAnsi(m_font, hx+5.0f, kHdrY+6.0f, 0xFFFFFFFF, hdr); }
|
||
|
||
// compute Size column width/X for this pane
|
||
const FLOAT sizeColW = ComputeSizeColW(p);
|
||
const FLOAT sizeColX = baseX + kListW - (kScrollBarW + kPaddingX + sizeColW);
|
||
const FLOAT sizeRight = sizeColX + sizeColW;
|
||
|
||
// column header
|
||
DrawRect(baseX-10.0f, kHdrY+kHdrH+6.0f, kListW+20.0f, 22.0f, 0x60333333);
|
||
DrawAnsi(m_font, NameColX(baseX), kHdrY+kHdrH+10.0f, 0xFFDDDDDD, "Name");
|
||
DrawRightAligned("Size", sizeRight, kHdrY+kHdrH+10.0f, 0xFFDDDDDD);
|
||
DrawHLine(baseX-10.0f, kHdrY+kHdrH+28.0f, kListW+20.0f, 0x80444444);
|
||
DrawVLine(sizeColX - 8.0f, kHdrY+kHdrH+7.0f, 22.0f, 0x40444444);
|
||
|
||
// list bg
|
||
DrawRect(baseX-10.0f, kListY-6.0f, kListW+20.0f, kLineH*m_visible+12.0f, 0x30101010);
|
||
|
||
// stripes + selection
|
||
int end=p.scroll+m_visible; if(end>(int)p.items.size()) end=(int)p.items.size();
|
||
int rowIndex=0;
|
||
for(int i=p.scroll;i<end;++i,++rowIndex){
|
||
D3DCOLOR stripe=(rowIndex&1)?0x201E1E1E:0x10000000;
|
||
DrawRect(baseX, kListY + rowIndex*kLineH - 2.0f, kListW-8.0f, kLineH, stripe);
|
||
}
|
||
if(!p.items.empty() && p.sel>=p.scroll && p.sel<end){
|
||
int selRow=p.sel-p.scroll;
|
||
DrawRect(baseX, kListY + selRow*kLineH - 2.0f, kListW-8.0f, kLineH, active?0x60FFFF00:0x30FFFF00);
|
||
}
|
||
|
||
// rows
|
||
FLOAT y=kListY;
|
||
for(int i=p.scroll, r=0; i<end; ++i,++r){
|
||
const Item& it=p.items[i];
|
||
DWORD nameCol=(i==p.sel)?0xFFFFFF00:0xFFE0E0E0;
|
||
DWORD sizeCol=(i==p.sel)?0xFFFFFF00:0xFFB0B0B0;
|
||
D3DCOLOR ico = it.isUpEntry ? 0xFFAAAAAA : (it.isDir ? 0xFF5EA4FF : 0xFF89D07E);
|
||
DrawRect(baseX+2.0f, y+6.0f, kGutterW-8.0f, kLineH-12.0f, ico);
|
||
const char* glyph = it.isUpEntry ? ".." : (it.isDir?"+":"-");
|
||
DrawAnsi(m_font, baseX+4.0f, y+4.0f, 0xFFFFFFFF, glyph);
|
||
|
||
char nameBuf[300]; _snprintf(nameBuf,sizeof(nameBuf),"%s",it.name); nameBuf[sizeof(nameBuf)-1]=0;
|
||
DrawAnsi(m_font, NameColX(baseX), y, nameCol, nameBuf);
|
||
|
||
char sz[64]=""; if(!it.isDir && !it.isUpEntry){ FormatSize(it.size, sz, sizeof(sz)); }
|
||
DrawRightAligned(sz, sizeRight, y, sizeCol);
|
||
|
||
y += kLineH;
|
||
}
|
||
|
||
// scrollbar
|
||
if((int)p.items.size()>m_visible){
|
||
FLOAT trackX = baseX + kListW - kScrollBarW - 4.0f;
|
||
FLOAT trackY = kListY - 2.0f;
|
||
FLOAT trackH = m_visible * kLineH;
|
||
DrawRect(trackX, trackY, kScrollBarW, trackH, 0x40282828);
|
||
int total=(int)p.items.size();
|
||
FLOAT thumbH=(FLOAT)m_visible/(FLOAT)total*trackH; if(thumbH<10.0f) thumbH=10.0f;
|
||
FLOAT maxScroll=(FLOAT)(total-m_visible);
|
||
FLOAT t=(maxScroll>0.0f)?((FLOAT)p.scroll/maxScroll):0.0f;
|
||
FLOAT thumbY=trackY + t*(trackH-thumbH);
|
||
DrawRect(trackX, thumbY, kScrollBarW, thumbH, 0x80C0C0C0);
|
||
}
|
||
}
|
||
};
|
||
|
||
// ---- static layout defs (defaults; overwritten in Initialize) ----
|
||
FLOAT FileBrowserApp::kListX_L = 50.0f;
|
||
FLOAT FileBrowserApp::kListY = 100.0f;
|
||
FLOAT FileBrowserApp::kListW = 540.0f;
|
||
FLOAT FileBrowserApp::kLineH = 26.0f;
|
||
|
||
FLOAT FileBrowserApp::kHdrX_L = 35.0f;
|
||
FLOAT FileBrowserApp::kHdrY = 22.0f;
|
||
FLOAT FileBrowserApp::kHdrW = 570.0f;
|
||
FLOAT FileBrowserApp::kHdrH = 28.0f;
|
||
|
||
FLOAT FileBrowserApp::kGutterW = 18.0f;
|
||
FLOAT FileBrowserApp::kPaddingX = 6.0f;
|
||
FLOAT FileBrowserApp::kScrollBarW = 3.0f;
|
||
FLOAT FileBrowserApp::kPaneGap = 60.0f;
|
||
|
||
// OG XDK prefers main() entry
|
||
int __cdecl main(){ FileBrowserApp app; app.Create(); return app.Run(); }
|