/*************************************************************************
* SHGetFileInfoA [SHELL32.@]
*
* Note:
* MSVBVM60.__vbaNew2 expects this function to return a value in range
* 1 .. 0x7fff when the function succeeds and flags does not contain
* SHGFI_EXETYPE or SHGFI_SYSICONINDEX (see bug 7701)
*/
DWORD_PTR WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes,
SHFILEINFOA *psfi, UINT sizeofpsfi,
UINT flags )
{
INT len;
LPWSTR temppath = NULL;
LPCWSTR pathW;
DWORD_PTR ret;
SHFILEINFOW temppsfi;
if (flags & SHGFI_PIDL)
{
/* path contains a pidl */
pathW = (LPCWSTR)path;
}
else
{
len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
temppath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, path, -1, temppath, len);
pathW = temppath;
}
if (psfi && (flags & SHGFI_ATTR_SPECIFIED))
temppsfi.dwAttributes=psfi->dwAttributes;
if (psfi == NULL)
ret = SHGetFileInfoW(pathW, dwFileAttributes, NULL, sizeof(temppsfi), flags);
else
ret = SHGetFileInfoW(pathW, dwFileAttributes, &temppsfi, sizeof(temppsfi), flags);
if (psfi)
{
if(flags & SHGFI_ICON)
psfi->hIcon=temppsfi.hIcon;
if(flags & (SHGFI_SYSICONINDEX|SHGFI_ICON|SHGFI_ICONLOCATION))
psfi->iIcon=temppsfi.iIcon;
if(flags & SHGFI_ATTRIBUTES)
psfi->dwAttributes=temppsfi.dwAttributes;
if(flags & (SHGFI_DISPLAYNAME|SHGFI_ICONLOCATION))
{
WideCharToMultiByte(CP_ACP, 0, temppsfi.szDisplayName, -1,
psfi->szDisplayName, sizeof(psfi->szDisplayName), NULL, NULL);
}
if(flags & SHGFI_TYPENAME)
{
WideCharToMultiByte(CP_ACP, 0, temppsfi.szTypeName, -1,
psfi->szTypeName, sizeof(psfi->szTypeName), NULL, NULL);
}
}
HeapFree(GetProcessHeap(), 0, temppath);
return ret;
}
//idExtName为扩展名ID
//pFilePath为带斜线目录名
//filePathLen为带斜线目录名长度
//pFileName文件名
//fileLen文件名长度
int CExtArray::SetIconIndex(int idExtName,PWCHAR pFilePath,int filePathLen,PWCHAR pFileName,int fileLen)
{
assert(idExtName>=s_dwOmitExt && "已经初始化实时调用的不能再传递进来");
SHFILEINFOW sfi;
//现将filePath扩展为文件名
int j=filePathLen;
for(int i=0;i<fileLen;++i)
{
pFilePath[j++]=pFileName[i];
}
pFilePath[j]=L'\0';
SHGetFileInfoW(pFilePath,
FILE_ATTRIBUTE_NORMAL,
&sfi,
sizeof(sfi),
SHGFI_SMALLICON
| SHGFI_SYSICONINDEX
| SHGFI_USEFILEATTRIBUTES
) ;
pFilePath[filePathLen]=L'\0';//还原filePath
m_piIcon[idExtName]=sfi.iIcon;
return sfi.iIcon;
}
void draw_file_icon(HDC hdc, int x, int y, LPCWSTR filename)
{
SHFILEINFOW sfi;
HIMAGELIST hlist = (HIMAGELIST) SHGetFileInfoW( filename, 0, &sfi, sizeof(SHFILEINFO), SHGFI_USEFILEATTRIBUTES | SHGFI_SYSICONINDEX | SHGFI_SMALLICON );
if(hlist)
ImageList_Draw(hlist, sfi.iIcon, hdc, x, y, ILD_TRANSPARENT);
}
CFileDlg::CFileDlg(CWnd* pParent /*=NULL*/)
: CDialog(CFileDlg::IDD, pParent)
{
HRESULT hresut=CoInitialize(NULL);
SHFILEINFO sfi;
SHGetFileInfo
(
L"\\\\", //随便传递两个字节
FILE_ATTRIBUTE_NORMAL,
&sfi,
sizeof(SHFILEINFO),
SHGFI_ICON | SHGFI_USEFILEATTRIBUTES | SHGFI_PIDL
);
m_hIcon = sfi.hIcon;
WCHAR Temp[100] = {0};
HIMAGELIST hImageList;
// 加载系统图标列表
hImageList = (HIMAGELIST)SHGetFileInfoW
(
Temp,
FILE_ATTRIBUTE_NORMAL,
&sfi,
sizeof(SHFILEINFO),
SHGFI_LARGEICON | SHGFI_SYSICONINDEX | SHGFI_PIDL
);
m_pImageList_Large.Attach(hImageList);
// 加载系统图标列表
hImageList = (HIMAGELIST)SHGetFileInfoW
(
Temp,
FILE_ATTRIBUTE_NORMAL,
&sfi,
sizeof(SHFILEINFO),
SHGFI_SMALLICON | SHGFI_SYSICONINDEX | SHGFI_PIDL
);
m_pImageList_Small.Attach(hImageList);
m_wParent = pParent;
}
BOOL
CFileDefExt::InitFileType(HWND hwndDlg)
{
TRACE("path %s\n", debugstr_w(m_wszPath));
HWND hDlgCtrl = GetDlgItem(hwndDlg, 14005);
if (hDlgCtrl == NULL)
return FALSE;
/* Get file information */
SHFILEINFO fi;
if (!SHGetFileInfoW(m_wszPath, 0, &fi, sizeof(fi), SHGFI_TYPENAME|SHGFI_ICON))
{
ERR("SHGetFileInfoW failed for %ls (%lu)\n", m_wszPath, GetLastError());
fi.szTypeName[0] = L'\0';
fi.hIcon = NULL;
}
LPCWSTR pwszExt = PathFindExtensionW(m_wszPath);
if (pwszExt[0])
{
WCHAR wszBuf[256];
if (!fi.szTypeName[0])
{
/* The file type is unknown, so default to string "FileExtension File" */
size_t cchRemaining = 0;
LPWSTR pwszEnd = NULL;
StringCchPrintfExW(wszBuf, _countof(wszBuf), &pwszEnd, &cchRemaining, 0, L"%s ", pwszExt + 1);
SendMessageW(hDlgCtrl, WM_GETTEXT, (WPARAM)cchRemaining, (LPARAM)pwszEnd);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
else
{
/* Update file type */
StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s (%s)", fi.szTypeName, pwszExt);
SendMessageW(hDlgCtrl, WM_SETTEXT, (WPARAM)NULL, (LPARAM)wszBuf);
}
}
/* Update file icon */
if (fi.hIcon)
SendDlgItemMessageW(hwndDlg, 14000, STM_SETICON, (WPARAM)fi.hIcon, 0);
else
ERR("No icon %ls\n", m_wszPath);
return TRUE;
}
BOOL CDirTreeCtrl::AttachImgList()
{
SHFILEINFO shFinfo;
HIMAGELIST hImgList = NULL;
if ( GetImageList( TVSIL_NORMAL ) ) m_imgList.Detach();
hImgList = (HIMAGELIST)SHGetFileInfoW( _T("C:\\"),
0, &shFinfo, sizeof( shFinfo ),
SHGFI_SYSICONINDEX | SHGFI_SMALLICON );
if ( !hImgList ) {
m_strError = _T("无法得到系统图标文件!");
return FALSE;
}
m_imgList.m_hImageList = hImgList;
SetImageList( &m_imgList, TVSIL_NORMAL );
return TRUE;
}
inline std::wstring search_path(const std::wstring &filename,
std::wstring path = L"")
{
if (path.empty())
{
path = ::_wgetenv(L"PATH");
if (path.empty())
BOOST_PROCESS_THROW(std::runtime_error(
"Environment variable PATH not found"));
}
typedef boost::tokenizer<boost::char_separator<wchar_t>,
std::wstring::const_iterator, std::wstring> tokenizer;
boost::char_separator<wchar_t> sep(L";");
tokenizer tok(path, sep);
for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it)
{
boost::filesystem::path p = *it;
p /= filename;
boost::array<std::wstring, 4> extensions =
{ L"", L".exe", L".com", L".bat" };
for (boost::array<std::wstring, 4>::iterator it2 = extensions.begin();
it2 != extensions.end(); ++it2)
{
boost::filesystem::path p2 = p;
p2 += *it2;
boost::system::error_code ec;
bool file = boost::filesystem::is_regular_file(p2, ec);
if (!ec && file &&
SHGetFileInfoW(p2.c_str(), 0, 0, 0, SHGFI_EXETYPE))
{
return p2.wstring();
}
}
}
return L"";
}
virtual BOOL on_draw (HELEMENT he, UINT draw_type, HDC hdc, const RECT& rc )
{
if( draw_type != DRAW_CONTENT )
return FALSE; /*do default draw*/
dom::element el = he;
const wchar_t* filename = el.get_attribute("filename");
if( !filename )
return FALSE; // no such attribute at all.
// 先画图标
SHFILEINFOW sfi;
HIMAGELIST hlist = (HIMAGELIST) SHGetFileInfoW( filename,
0, &sfi, sizeof(SHFILEINFO),
/*SHGFI_USEFILEATTRIBUTES |*/ SHGFI_SYSICONINDEX | SHGFI_SMALLICON );
if(!hlist)
return FALSE;
int szx = 16;
int szy = 16;
ImageList_GetIconSize(hlist, &szx, &szy);
int x = rc.left - 19; // 水平居左 // + (rc.right - rc.left - szx) / 2;
int y = rc.top + (rc.bottom - rc.top - szy) / 2; // 垂直居中
//draw_file_icon(hdc, x, y, filename);
ImageList_Draw(hlist, sfi.iIcon, hdc, x, y, ILD_TRANSPARENT);
// 输出文字
UINT pta = GetTextAlign(hdc);
SetTextAlign(hdc, TA_LEFT | TA_TOP |TA_NOUPDATECP);
DrawTextW(hdc, (is_fullpath(el) && (wcslen(filename) > 1)) ? filename : el.text(),
-1,const_cast<RECT*>(&rc),
DT_SINGLELINE | DT_LEFT | DT_VCENTER | DT_PATH_ELLIPSIS | DT_NOPREFIX);
SetTextAlign(hdc, pta);
return TRUE; /*skip default draw as we did it already*/
}
static int GetIcon(LPCITEMIDLIST lpi, UINT uFlags)
{
SHFILEINFOW sfi;
SHGetFileInfoW((LPCWSTR)lpi, 0 ,&sfi, sizeof(SHFILEINFOW), uFlags);
return sfi.iIcon;
}
HRESULT WINAPI CFontsFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
{
WCHAR buffer[MAX_PATH] = {0};
HRESULT hr = E_FAIL;
PIDLFontStruct * pfont;
HANDLE hFile;
LARGE_INTEGER FileSize;
SHFILEINFOW fi;
TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, psd);
if (iColumn >= FontsSHELLVIEWCOLUMNS)
return E_FAIL;
psd->fmt = FontsSFHeader[iColumn].fmt;
psd->cxChar = FontsSFHeader[iColumn].cxChar;
if (pidl == NULL)
{
psd->str.uType = STRRET_WSTR;
if (LoadStringW(shell32_hInstance, FontsSFHeader[iColumn].colnameid, buffer, MAX_PATH))
hr = SHStrDupW(buffer, &psd->str.pOleStr);
return hr;
}
if (iColumn == COLUMN_NAME)
{
psd->str.uType = STRRET_WSTR;
return GetDisplayNameOf(pidl, SHGDN_NORMAL, &psd->str);
}
psd->str.uType = STRRET_CSTR;
psd->str.cStr[0] = '\0';
switch(iColumn)
{
case COLUMN_TYPE:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
if (SHGetFileInfoW(pfont->szName + pfont->offsFile, 0, &fi, sizeof(fi), SHGFI_TYPENAME))
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(fi.szTypeName) + 1) * sizeof(WCHAR));
if (!psd->str.pOleStr)
return E_OUTOFMEMORY;
wcscpy(psd->str.pOleStr, fi.szTypeName);
psd->str.uType = STRRET_WSTR;
return S_OK;
}
}
break;
case COLUMN_SIZE:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
hFile = CreateFileW(pfont->szName + pfont->offsFile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
if (GetFileSizeEx(hFile, &FileSize))
{
if (StrFormatByteSizeW(FileSize.QuadPart, buffer, sizeof(buffer) / sizeof(WCHAR)))
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc(wcslen(buffer) + 1);
if (!psd->str.pOleStr)
{
CloseHandle(hFile);
return E_OUTOFMEMORY;
}
wcscpy(psd->str.pOleStr, buffer);
psd->str.uType = STRRET_WSTR;
CloseHandle(hFile);
return S_OK;
}
}
CloseHandle(hFile);
}
}
break;
case COLUMN_FILENAME:
pfont = _ILGetFontStruct(pidl);
if (pfont)
{
psd->str.pOleStr = (LPWSTR)CoTaskMemAlloc((wcslen(pfont->szName + pfont->offsFile) + 1) * sizeof(WCHAR));
if (psd->str.pOleStr)
{
psd->str.uType = STRRET_WSTR;
wcscpy(psd->str.pOleStr, pfont->szName + pfont->offsFile);
return S_OK;
}
else
return E_OUTOFMEMORY;
}
break;
}
return E_FAIL;
}
static INT_PTR CALLBACK TemplateDlg(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static HWND hTreeCtrl;
static HWND hOkBtn;
static HWND hEditBtn;
static HWND hInsertBtn;
static HWND hRemoveMarkerBtn;
static int LDX, LDY, BDX;
static LPARAM param;
if(WM_INITDIALOG == uMsg)
{
RECT rcWR, rcCR;
POINT pt;
EDITINFO ei;
param = lParam;
GetClientRect(hWndDlg,&rcWR);
hTreeCtrl = GetDlgItem(hWndDlg,IDC_TREE);
hOkBtn = GetDlgItem(hWndDlg,IDOK);
hEditBtn = GetDlgItem(hWndDlg,IDC_EDIT);
hInsertBtn = GetDlgItem(hWndDlg,IDC_INSERT);
hRemoveMarkerBtn = GetDlgItem(hWndDlg, IDC_REMMARKER);
GetWindowRect(hTreeCtrl,&rcCR);
pt.x = rcCR.right; pt.y = rcCR.bottom;
ScreenToClient(hWndDlg,&pt);
LDX = rcWR.right - pt.x;
LDY = rcWR.bottom - pt.y;
GetWindowRect(hOkBtn,&rcCR);
pt.x=rcCR.left; pt.y=0;
ScreenToClient(hWndDlg,&pt);
BDX = rcWR.right - pt.x;
{
TVINSERTSTRUCTW tvi;
HTREEITEM hEmpty;
WCHAR szRoot[MAX_PATH];
SHFILEINFOW sfi;
HIMAGELIST hList
= (HIMAGELIST)SHGetFileInfoW(g_szAkelPath,0,&sfi,sizeof(sfi),SHGFI_SYSICONINDEX|SHGFI_SMALLICON);
TreeView_SetImageList(hTreeCtrl,hList,TVSIL_NORMAL);
lstrcpyW(szRoot,g_szAkelPath);
lstrcatW(szRoot,TEMPLATES_PATH);
FillTreeCtrl(hTreeCtrl,szRoot,TVI_ROOT);
TreeView_SortChildren(hTreeCtrl,TVI_ROOT,FALSE);
tvi.hParent = TVI_ROOT;
tvi.hInsertAfter = TVI_FIRST;
tvi.item.pszText = L"<Empty>";
tvi.item.lParam = TVNT_EMPTY;
tvi.item.iImage = tvi.item.iSelectedImage = 3;
tvi.item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
hEmpty = TreeView_InsertItem(hTreeCtrl,&tvi);
if(TreeView_GetCount(hTreeCtrl)>0)
{
TreeView_SelectItem(hTreeCtrl,hEmpty);
EnableWindow(hOkBtn,TRUE);
}
else
{
EnableWindow(hOkBtn,FALSE);
}
}
if(!(lParam&DCP_ALLOWEDIT))
{
DestroyWindow(hEditBtn);
hEditBtn = NULL;
}
if(SendMessageW(g_hMainWnd,AKD_GETEDITINFO,(WPARAM)NULL,(LPARAM)&ei))
{
if(!IsWindow(ei.hWndEdit) || (!(lParam&DCP_ALLOWINSERT)))
{
DestroyWindow(hInsertBtn);
hInsertBtn = NULL;
}
}
SendMessageW(hRemoveMarkerBtn, BM_SETCHECK,g_bRemoveMarker?BST_CHECKED:BST_UNCHECKED,0);
PostMessageW(hWndDlg,WM_COMMAND,MAKEWPARAM(IDC_TREE,LBN_SELCHANGE),0);
RestorePosition(hWndDlg);
#ifndef NO_SMALL_ICON
SendMessageW(hWndDlg, WM_SETICON,(WPARAM)ICON_SMALL,(LPARAM)g_hMainIcon);
#endif
SendMessageW(hWndDlg, WM_SETICON,(WPARAM)ICON_BIG,(LPARAM)g_hMainIcon);
return TRUE;
}
else if(WM_COMMAND == uMsg)
{
if(((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDC_EDIT) || (LOWORD(wParam) == IDC_INSERT)) && (HIWORD(wParam) == BN_CLICKED))
{
HTREEITEM hItem = TreeView_GetSelection(hTreeCtrl);
TVITEM item;
INT_PTR len = 0;
if(!hItem) return TRUE;
item.hItem = hItem;
item.lParam = 0;
item.mask = TVIF_PARAM;
if(!TreeView_GetItem(hTreeCtrl,&item)) return TRUE;
if(item.lParam==TVNT_DIR) return TRUE;
lstrcpyW(g_szTemplate,g_szAkelPath);
lstrcatW(g_szTemplate,TEMPLATES_PATH);
lstrcatW(g_szTemplate,L"\\");
g_bRemoveMarker = (SendMessageW(hRemoveMarkerBtn, BM_GETCHECK, 0, 0)==BST_CHECKED)?TRUE:FALSE;
UpdateSettings(TSF_REMOVEMARKER,FALSE);
len = lstrlenW(g_szTemplate);
if(RebuildPath(hTreeCtrl, hItem, g_szTemplate+len))
{
if(lstrlenW(g_szTemplate) == len)
{
//! Opening empty template
g_szTemplate[0] = 0;
}
EndDialog(hWndDlg,LOWORD(wParam));
}
else
{
g_szTemplate[0]=0;
}
return TRUE;
}
else if((LOWORD(wParam)==IDCANCEL) && (HIWORD(wParam) == BN_CLICKED))
{
EndDialog(hWndDlg,IDCANCEL);
return TRUE;
}
}
else if(WM_NOTIFY == uMsg)
{
if(IDC_TREE == wParam)
{
if(((LPNMHDR)lParam)->code == TVN_SELCHANGED)
{
LPNMTREEVIEWW ptv = (LPNMTREEVIEWW)lParam;
if(ptv->itemNew.hItem && (ptv->itemNew.mask&TVIF_PARAM))
{
if(hOkBtn)
{
EnableWindow(hOkBtn, (ptv->itemNew.lParam != TVNT_DIR));
}
if(hEditBtn)
{
EnableWindow(hEditBtn, ptv->itemNew.lParam == TVNT_FILE);
}
if(hInsertBtn)
{
EnableWindow(hInsertBtn, ptv->itemNew.lParam == TVNT_FILE);
}
}
return TRUE;
}
else if(((LPNMHDR)lParam)->code == NM_DBLCLK)
{
DWORD pos = GetMessagePos();
TVHITTESTINFO thi;
HTREEITEM hit=0;
thi.pt.x = GET_X_LPARAM(pos);
thi.pt.y = GET_Y_LPARAM(pos);
ScreenToClient(hTreeCtrl,&thi.pt);
thi.hItem =0;
thi.flags =0;
hit = TreeView_HitTest(hTreeCtrl,&thi);
if(thi.hItem)
{
TVITEM item;
item.hItem = thi.hItem;
item.mask = TVIF_PARAM;
TreeView_GetItem(hTreeCtrl,&item);
if(hOkBtn)
{
EnableWindow(hOkBtn, item.lParam != TVNT_DIR);
}
if(hEditBtn)
{
EnableWindow(hEditBtn, item.lParam == TVNT_FILE);
}
if(hInsertBtn)
{
EnableWindow(hInsertBtn, item.lParam != TVNT_DIR);
}
if(item.lParam != TVNT_DIR)
PostMessageW(hWndDlg,WM_COMMAND,MAKEWPARAM(IDOK,BN_CLICKED),0);
}
return TRUE;
}
}
}
else if(WM_CLOSE == uMsg)
{
PostMessageW(hWndDlg,WM_COMMAND,MAKEWPARAM(IDCANCEL,BN_CLICKED),0);
return TRUE;
}
else if(WM_DESTROY == uMsg)
{
SavePosition(hWndDlg);
}
else if(WM_SIZE == uMsg)
{
RECT rcWindow, rcNew; POINT pt;
GetClientRect(hWndDlg,&rcWindow);
GetWindowRect(hTreeCtrl,&rcNew);
pt.x = rcNew.left; pt.y = rcNew.top;
ScreenToClient(hWndDlg,&pt);
MoveWindow(hTreeCtrl,pt.x,pt.y,rcWindow.right-LDX-pt.x, rcWindow.bottom-LDY-pt.y,TRUE);
MoveButton(hWndDlg,hOkBtn,rcWindow, BDX);
MoveButton(hWndDlg,GetDlgItem(hWndDlg,IDCANCEL),rcWindow, BDX);
MoveButton(hWndDlg,hEditBtn,rcWindow, BDX);
MoveButton(hWndDlg,hInsertBtn,rcWindow, BDX);
MoveButton(hWndDlg,hRemoveMarkerBtn,rcWindow,BDX);
InvalidateRect(hWndDlg,NULL,TRUE);
}
else if(WM_PAINT == uMsg)
{
RECT rc;
PAINTSTRUCT ps;
HDC dc = BeginPaint(hWndDlg, &ps);
if(dc)
{
GetClientRect(hWndDlg, &rc);
rc.left = rc.right - GetSystemMetrics(SM_CXVSCROLL);
rc.top = rc.bottom - GetSystemMetrics(SM_CYVSCROLL);
DrawFrameControl(dc, &rc, DFC_SCROLL, DFCS_SCROLLSIZEGRIP);
EndPaint(hWndDlg, &ps);
}
}
return FALSE;
}
static void CALLCONV FillTreeCtrl(HWND hTreeCtrl, LPCWSTR szPath, HTREEITEM hRoot)
{
SIZE_T i, nPathLen = lstrlenW(szPath);
WIN32_FIND_DATAW fd;
HANDLE hFind;
LPWSTR szMask = PLUGIN_ALLOC(MAX_PATH*sizeof(WCHAR));
if(!szMask) return;
lstrcpyW(szMask,szPath);
lstrcatW(szMask,L"\\");
lstrcatW(szMask,TEMPLATES_MASK);
hFind = FindFirstFileW(szMask,&fd);
if(hFind != INVALID_HANDLE_VALUE)
{
LPWSTR szItem = PLUGIN_ALLOC(MAX_PATH*sizeof(szItem));
LPCWSTR p = szPath;
UINT_PTR tail = 0;
SHFILEINFOW sfi,sfis;
while(*p){ szItem[tail] = *p++;tail++;};
szItem[tail]=L'\\';tail++;
do
{
if(fd.cFileName[0] != L'.')
{
i=0;
while(fd.cFileName[i]) {szItem[tail+i]=fd.cFileName[i];i++;}
szItem[tail+i]=0;
SHGetFileInfoW(szItem,0,&sfi,sizeof(sfi),SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_OPENICON);
SHGetFileInfoW(szItem,0,&sfis,sizeof(sfis),SHGFI_SYSICONINDEX|SHGFI_SMALLICON|SHGFI_OPENICON);
if(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
TVINSERTSTRUCTW tvi;
HTREEITEM hNode=NULL;
WCHAR szChild[MAX_PATH],szLabel[MAX_PATH];
p = fd.cFileName;
tvi.hParent = hRoot;
tvi.hInsertAfter = TVI_LAST;
szLabel[0]=L'[';
i=0;
while(*p) {szLabel[1+i]=*p++;i++;}
szLabel[1+i]=L']';
szLabel[1+i+1]=0;
tvi.item.pszText = szLabel;
tvi.item.cchTextMax = MAX_PATH;
tvi.item.lParam = TVNT_DIR;
tvi.item.iImage = sfi.iIcon;
tvi.item.iSelectedImage = sfis.iIcon;
tvi.item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
hNode = TreeView_InsertItem(hTreeCtrl,&tvi);
//! Что-бы не "оптимизировало" в вызов memcpy пришлось установить опцию
//! компилятора "Inline Function Expansion" в /Ob1
//! На значение по-умолчанию "Default" в Win32 всё нормально, в x64 - вылазит memcpy
xmemcpy(szChild,szPath,nPathLen*sizeof(WCHAR));
i = nPathLen;
szChild[i]=L'\\'; i++;
p = fd.cFileName;
while(*p) {szChild[i]=*p++;i++;}
szChild[i]=0;
FillTreeCtrl(hTreeCtrl,szChild,hNode);
TreeView_SortChildren(hTreeCtrl,hNode,FALSE);
TreeView_Expand(hTreeCtrl,hNode,TVE_EXPAND);
}
else
{
TVINSERTSTRUCTW tvi;
tvi.hParent = hRoot;
tvi.hInsertAfter = TVI_LAST;
tvi.item.pszText = fd.cFileName;
tvi.item.cchTextMax = MAX_PATH;
tvi.item.lParam = TVNT_FILE;
tvi.item.iImage = sfi.iIcon;
tvi.item.iSelectedImage = sfis.iIcon;
tvi.item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
TreeView_InsertItem(hTreeCtrl,&tvi);
}
}
}
while(FindNextFileW(hFind, &fd));
FindClose(hFind);
PLUGIN_FREE(szItem);
}
PLUGIN_FREE(szMask);
}
EXPORT DWORD_PTR WINAPI SHGetFileInfoWStub(LPCWSTR pszPath, DWORD dwFileAttributes, SHFILEINFOW *psfi, UINT cbFileInfo, UINT uFlags)
{return SHGetFileInfoW(pszPath, dwFileAttributes, psfi, cbFileInfo, uFlags);}
CNewMenu::SHELLNEW_ITEM *CNewMenu::LoadItem(LPCWSTR pwszExt)
{
HKEY hKey;
WCHAR wszBuf[MAX_PATH];
BYTE *pData = NULL;
DWORD cbData;
StringCbPrintfW(wszBuf, sizeof(wszBuf), L"%s\\ShellNew", pwszExt);
TRACE("LoadItem Keyname %s Name %s\n", debugstr_w(pwszExt), debugstr_w(wszBuf));
if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszBuf, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
{
TRACE("Failed to open key\n");
return NULL;
}
/* Find first valid value */
struct
{
LPCWSTR pszName;
SHELLNEW_TYPE Type;
BOOL bNeedData;
BOOL bStr;
} Types[] = {
{L"FileName", SHELLNEW_TYPE_FILENAME, TRUE, TRUE},
{L"Command", SHELLNEW_TYPE_COMMAND, TRUE, TRUE},
{L"Data", SHELLNEW_TYPE_DATA, TRUE, FALSE},
{L"NullFile", SHELLNEW_TYPE_NULLFILE, FALSE},
{NULL}
};
UINT i;
for (i = 0; Types[i].pszName; ++i)
{
/* Note: We are using ANSI function because strings can be treated as data */
cbData = 0;
DWORD dwFlags = Types[i].bStr ? RRF_RT_REG_SZ : RRF_RT_ANY;
DWORD dwType;
if (RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, NULL, NULL, &cbData) == ERROR_SUCCESS)
{
if (Types[i].bNeedData && cbData > 0)
{
pData = (BYTE*)malloc(cbData);
RegGetValueW(hKey, NULL, Types[i].pszName, dwFlags, &dwType, pData, &cbData);
if (!Types[i].bStr && (dwType == REG_SZ || dwType == REG_EXPAND_SZ))
{
PBYTE pData2 = (PBYTE)malloc(cbData);
cbData = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pData, -1, (LPSTR)pData2, cbData, NULL, NULL);
free(pData);
pData = pData2;
}
}
break;
}
}
RegCloseKey(hKey);
/* Was any key found? */
if (!Types[i].pszName)
return NULL;
SHFILEINFO fi;
if (!SHGetFileInfoW(pwszExt, FILE_ATTRIBUTE_NORMAL, &fi, sizeof(fi), SHGFI_USEFILEATTRIBUTES|SHGFI_TYPENAME|SHGFI_ICON|SHGFI_SMALLICON))
return NULL;
/* Create new item */
SHELLNEW_ITEM *pNewItem = static_cast<SHELLNEW_ITEM *>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SHELLNEW_ITEM)));
if (!pNewItem)
{
free(pData);
return NULL;
}
TRACE("new item %ls\n", fi.szTypeName);
pNewItem->Type = Types[i].Type;
pNewItem->pData = pData;
pNewItem->cbData = pData ? cbData : 0;
pNewItem->pwszExt = _wcsdup(pwszExt);
pNewItem->pwszDesc = _wcsdup(fi.szTypeName);
if (fi.hIcon)
pNewItem->hIcon = fi.hIcon;
return pNewItem;
}
// 初始化文件树和列表
void HsLoadFileTreeList(CFileDlg *cFleDlg)
{
WCHAR* pDrive = NULL;
HTREEITEM hRoot; // 树的根节点的句柄
HTREEITEM hDriverItem; // 可表示任一磁盘节点的句柄
HTREEITEM hFolderItem; // 可表示任一目录节点的句柄
HIMAGELIST hImageListLarge = NULL;
HIMAGELIST hImageListSmall = NULL;
Shell_GetImageLists(&hImageListLarge, &hImageListSmall);
ListView_SetImageList(cFleDlg->m_fileList.m_hWnd, hImageListLarge, LVSIL_NORMAL);
ListView_SetImageList(cFleDlg->m_fileList.m_hWnd, hImageListSmall, LVSIL_SMALL);
HsInitDriveList(&cFleDlg->m_fileList);
cFleDlg->m_fileList.DeleteAllItems();
cFleDlg->m_dirTree.DeleteAllItems();
LPITEMIDLIST ppidl = {0};
SHGetSpecialFolderLocation(NULL,CSIDL_DRIVES,&ppidl);
//SHGetPathFromIDList(ppidl,TempPath);
SHFILEINFO sfi;
SHGetFileInfoW
(
(LPCWSTR)ppidl,
0,
&sfi,
sizeof(SHFILEINFO),
SHGFI_SYSICONINDEX | SHGFI_PIDL
);
hRoot = cFleDlg->m_dirTree.InsertItem(_T("计算机"),sfi.iIcon,sfi.iIcon,0,0);
GetLogicalDriveStrings(sizeof(DriveString), DriveString);
pDrive = DriveString;
CString DriveName;
WCHAR FileSystem[MAX_PATH];
unsigned __int64 HDAmount = 0;
unsigned __int64 HDFreeSpace = 0;
unsigned long AmntMB = 0; // 总大小
unsigned long FreeMB = 0; // 剩余空间
cFleDlg->m_dirTree.Expand(hRoot,TVE_EXPAND);
for (int i = 0; *pDrive != '\0'; i++, pDrive += lstrlen(pDrive) + 1)
{
// 得到磁盘相关信息
memset(FileSystem, 0, sizeof(FileSystem));
// 得到文件系统信息及大小
GetVolumeInformation(pDrive, NULL, 0, NULL, NULL, NULL, FileSystem, MAX_PATH);
int nFileSystemLen = lstrlen(FileSystem) + 1;
if (GetDiskFreeSpaceEx(pDrive, (PULARGE_INTEGER)&HDFreeSpace, (PULARGE_INTEGER)&HDAmount, NULL))
{
AmntMB = (ULONG)(HDAmount / 1024 / 1024);
FreeMB = (ULONG)(HDFreeSpace / 1024 / 1024);
}
else
{
AmntMB = 0;
FreeMB = 0;
}
//获得磁盘类别
SHFILEINFO sfi;
SHGetFileInfo(pDrive, FILE_ATTRIBUTE_NORMAL, &sfi,sizeof(SHFILEINFO), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);
DriveName = sfi.szTypeName;
DriveName += L" (";
DriveName += pDrive;
DriveName.Delete(DriveName.GetLength()-1);
DriveName += L")";
int icon = GetIconIndex(pDrive,GetFileAttributes(pDrive));
int nItem = cFleDlg->m_fileList.InsertItem(i, DriveName, icon); //插入列表框
cFleDlg->m_fileList.SetItemData(nItem, (DWORD_PTR)pDrive);
hDriverItem = cFleDlg->m_dirTree.InsertItem(DriveName,icon,icon,hRoot,0); //插入树形列表
cFleDlg->m_dirTree.SetItemData(hDriverItem, (DWORD_PTR)pDrive);
cFleDlg->m_dirTree.Expand(hRoot,TVE_EXPAND);
cFleDlg->m_fileList.SetItemText(nItem, 1, sfi.szTypeName); //插入磁盘类别
CString str;
str.Format(L"%10.1f GB", (float)AmntMB / 1024);
cFleDlg->m_fileList.SetItemText(nItem, 2, str);
str.Format(L"%10.1f GB", (float)FreeMB / 1024);
cFleDlg->m_fileList.SetItemText(nItem, 3, str);
}
// 重置本地当前路径
cFleDlg->m_filePath.ResetContent();
cFleDlg->m_filePath.SetWindowTextW(L"计算机");
}
/**
\note This implementation cannot be used because the extension is omitted
when the exploer hides the extension of registered file types.
\todo Support the case where the exploer hides the extension of registered file types.
*/
std::string toActualPathName(const std::string& path)
{
int codepage = _getmbcp();
size_t length = ::MultiByteToWideChar(codepage, 0, path.c_str(), path.size(), NULL, 0);
if(length >= 0){
wchar_t wpath[MAX_PATH];
::MultiByteToWideChar(codepage, 0, path.c_str(), path.size(), wpath, MAX_PATH);
// The following code was based on the code posted at
// http://stackoverflow.com/questions/74451/getting-actual-file-name-with-proper-casing-on-windowsis
// Thank you.
const wchar_t kSeparator = L'\\';
size_t i = 0;
std::wstring result;
// for network paths (\\server\share\RestOfPath), getting the display
// name mangles it into unusable form (e.g. "\\server\share" turns
// into "share on server (server)"). So detect this case and just skip
// up to two path components
if( length >= 2 && wpath[0] == kSeparator && wpath[1] == kSeparator ) {
int skippedCount = 0;
i = 2; // start after '\\'
while( i < length && skippedCount < 2 ) {
if( wpath[i] == kSeparator ){
++skippedCount;
}
++i;
}
result.append( wpath, i );
}
// for drive names, just add it uppercased
else if( length >= 2 && wpath[1] == L':' ) {
result += towupper(wpath[0]);
result += L':';
if( length >= 3 && wpath[2] == kSeparator ){
result += kSeparator;
i = 3; // start after drive, colon and separator
} else {
i = 2; // start after drive and colon
}
}
size_t lastComponentStart = i;
bool addSeparator = false;
while( i < length ) {
// skip until path separator
while( i < length && wpath[i] != kSeparator ) {
++i;
}
if( addSeparator ) {
result += kSeparator;
}
// if we found path separator, get real filename of this
// last path name component
bool foundSeparator = (i < length);
wpath[i] = 0;
SHFILEINFOW info;
// nuke the path separator so that we get real name of current path component
info.szDisplayName[0] = 0;
if( SHGetFileInfoW( wpath, 0, &info, sizeof(info), SHGFI_DISPLAYNAME ) ) {
result += info.szDisplayName;
} else {
// most likely file does not exist.
// So just append original path name component.
result.append( wpath + lastComponentStart, i - lastComponentStart );
}
// restore path separator that we might have nuked before
if( foundSeparator ){
wpath[i] = kSeparator;
}
++i;
lastComponentStart = i;
addSeparator = true;
}
length = ::WideCharToMultiByte(codepage, 0, &result[0], result.size(), NULL, 0, NULL, NULL);
if(length >= 0){
std::vector<char> converted(length + 1);
::WideCharToMultiByte(codepage, 0, &result[0], result.size(), &converted[0], length + 1, NULL, NULL);
return std::string(&converted[0], length);
}
}
return path; // failed
}
