able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/pstore/shview.cpp

1413 lines
27 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Implements IShellView.
--*/
#include <windows.h>
#include <windowsx.h>
#include <objbase.h>
#include <shlobj.h>
#include <docobj.h>
#include <shellapi.h>
#include "pstore.h"
#include "shfolder.h"
#include "shview.h"
#include "guid.h"
#include "resource.h"
#include "tools.h"
#include "utility.h"
#include "enumid.h"
#include "listu.h"
extern HINSTANCE g_hInst;
extern LONG g_DllRefCount;
BOOL
AddListItem(
HWND hWnd,
DWORD dwType,
PST_KEY KeyType,
LPCWSTR szName,
LPITEMIDLIST pidl
);
#define TOOLBAR_ID (L"TBar")
#define INITIAL_COLUMN_POS 100
MYTOOLINFO g_Buttons[] =
{
IDM_MESSAGE1, 0, IDS_TB_MESSAGE1, IDS_MI_MESSAGE1, TBSTATE_ENABLED, TBSTYLE_BUTTON,
IDM_MESSAGE2, 0, IDS_TB_MESSAGE2, IDS_MI_MESSAGE2, TBSTATE_ENABLED, TBSTYLE_BUTTON,
-1, 0, 0, 0, 0,
};
CShellView::CShellView(
CShellFolder *pFolder,
LPCITEMIDLIST pidl
)
{
m_hMenu = NULL;
ZeroMemory(&m_MenuWidths, sizeof(m_MenuWidths));
m_nColumn1 = INITIAL_COLUMN_POS;
m_nColumn2 = INITIAL_COLUMN_POS;
m_pSFParent = pFolder;
if(m_pSFParent)
m_pSFParent->AddRef();
m_pidl = (LPITEMIDLIST)pidl;
m_uState = SVUIA_DEACTIVATE;
m_ObjRefCount = 1;
InterlockedIncrement(&g_DllRefCount);
}
CShellView::~CShellView()
{
if(m_pSFParent)
m_pSFParent->Release();
InterlockedDecrement(&g_DllRefCount);
}
STDMETHODIMP
CShellView::QueryInterface(
REFIID riid,
LPVOID *ppReturn
)
/*++
IUnknown::QueryInterface
--*/
{
*ppReturn = NULL;
if(IsEqualIID(riid, IID_IUnknown))
*ppReturn = (IUnknown*)(IShellView*)this;
else if(IsEqualIID(riid, IID_IOleWindow))
*ppReturn = (IOleWindow*)this;
else if(IsEqualIID(riid, IID_IShellView))
*ppReturn = (CShellView*)this;
else if(IsEqualIID(riid, IID_IOleCommandTarget))
*ppReturn = (IOleCommandTarget*)this;
if(*ppReturn == NULL)
return E_NOINTERFACE;
(*(LPUNKNOWN*)ppReturn)->AddRef();
return S_OK;
}
STDMETHODIMP_(DWORD)
CShellView::AddRef()
/*++
IUnknown::AddRef
--*/
{
return InterlockedIncrement(&m_ObjRefCount);
}
STDMETHODIMP_(DWORD)
CShellView::Release()
/*++
IUnknown::Release
--*/
{
LONG lDecremented = InterlockedDecrement(&m_ObjRefCount);
if(lDecremented == 0)
delete this;
return lDecremented;
}
STDMETHODIMP
CShellView::GetWindow(
HWND *phWnd
)
/*++
IOleWindow::GetWindow
--*/
{
*phWnd = m_hWnd;
return S_OK;
}
STDMETHODIMP
CShellView::ContextSensitiveHelp(
BOOL fEnterMode
)
/*++
Inherited from IOleWindow::ContextSensitiveHelp.
--*/
{
return E_NOTIMPL;
}
STDMETHODIMP
CShellView::QueryStatus(
const GUID *pguidCmdGroup,
ULONG cCmds,
OLECMD prgCmds[],
OLECMDTEXT *pCmdText
)
/*++
IOleCommandTarget::QueryStatus
--*/
{
ULONG i;
//
// only process the commands for our command group
//
if(pguidCmdGroup && (*pguidCmdGroup != CLSID_CmdGrp))
return OLECMDERR_E_UNKNOWNGROUP;
//
// make sure prgCmds is not NULL
//
if(prgCmds == NULL)
return E_POINTER;
//
// run through all of the commands and supply the correct information
//
for(i = 0; i < cCmds;i++)
{
switch(prgCmds[i].cmdID)
{
case IDM_MESSAGE1:
prgCmds[i].cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case IDM_MESSAGE2:
prgCmds[i].cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
}
}
return S_OK;
}
STDMETHODIMP
CShellView::Exec(
const GUID *pguidCmdGroup,
DWORD nCmdID,
DWORD nCmdExecOpt,
VARIANTARG *pvaIn,
VARIANTARG *pvaOut
)
/*++
IOleCommandTarget::Exec
--*/
{
//
// only process the commands for our command group
//
if(pguidCmdGroup && (*pguidCmdGroup == CLSID_CmdGrp))
{
OnCommand(nCmdID, 0, NULL);
return S_OK;
}
return OLECMDERR_E_UNKNOWNGROUP;
}
STDMETHODIMP
CShellView::TranslateAccelerator(
LPMSG pMsg
)
/*++
Same as the IOleInPlaceFrame::TranslateAccelerator, but will be
never called because we don't support EXEs (i.e., the explorer has
the message loop). This member function is defined here for possible
future enhancement.
--*/
{
return E_NOTIMPL;
}
STDMETHODIMP
CShellView::EnableModeless(
BOOL fEnable
)
/*++
Same as the IOleInPlaceFrame::EnableModeless.
--*/
{
return E_NOTIMPL;
}
STDMETHODIMP
CShellView::UIActivate(
UINT uState
)
/*++
IShellView::UIActivate
--*/
{
//
// don't do anything if the state isn't really changing
//
if(m_uState == uState)
return S_OK;
//
// Always do this because we will cause problems if we are going from
// SVUIA_ACTIVATE_FOCUS to SVUIA_ACTIVATE_NOFOCUS or vice versa.
//
m_uState = SVUIA_DEACTIVATE;
m_pShellBrowser->SetMenuSB(NULL, NULL, NULL);
if(m_hMenu) {
DestroyMenu(m_hMenu);
m_hMenu = NULL;
}
//
// only do this if we are active
//
if(uState != SVUIA_DEACTIVATE) {
m_uState = uState;
//
// update the Explorer's menu
//
if(m_hMenu == NULL)
m_hMenu = CreateMenu();
if(m_hMenu) {
MENUITEMINFO mii;
TCHAR szText[MAX_PATH];
m_pShellBrowser->InsertMenusSB(m_hMenu, &m_MenuWidths);
//
// get the menu item's text
//
LoadString(g_hInst, IDS_MI_REGISTRY, szText, sizeof(szText));
//
// build our menu
//
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_SUBMENU | MIIM_TYPE | MIIM_STATE;
mii.fType = MFT_STRING;
mii.fState = MFS_ENABLED;
mii.dwTypeData = szText;
mii.hSubMenu = BuildMenu();
//
// insert our menu
//
InsertMenuItem(m_hMenu, FCIDM_MENU_HELP, FALSE, &mii);
m_pShellBrowser->SetMenuSB(m_hMenu, NULL, m_hWnd);
}
//
// TODO: update the status bar
//
/*
TCHAR szName[MAX_PATH];
LoadString(g_hInst, IDS_PSTORE_TITLE, szName, sizeof(szName));
m_pSFParent->GetPidlFullText(m_pidl, szName + lstrlen(szName), sizeof(szName) - lstrlen(szName));
LRESULT lResult;
int nPartArray[1] = {-1};
//set the number of parts
m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, 1, (LPARAM)nPartArray, &lResult);
//set the text for the parts
m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 0, (LPARAM)szName, &lResult);
*/
}
return S_OK;
}
HMENU
CShellView::BuildMenu(
void
)
{
HMENU hSubMenu = CreatePopupMenu();
if(hSubMenu == NULL)
return NULL;
TCHAR szText[MAX_PATH];
MENUITEMINFO mii;
int nButtons, i;
//
// get the number of items in our global array
//
for(nButtons = 0; g_Buttons[nButtons].idCommand != -1; nButtons++) {
;
}
//
// add the menu items
//
for(i = 0; i < nButtons; i++) {
LoadString(g_hInst, g_Buttons[i].idMenuString, szText, sizeof(szText));
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
if(TBSTYLE_SEP != g_Buttons[i].bStyle) {
mii.fType = MFT_STRING;
mii.fState = MFS_ENABLED;
mii.dwTypeData = szText;
mii.wID = g_Buttons[i].idCommand;
} else {
mii.fType = MFT_SEPARATOR;
}
//
// tack this item onto the end of the menu
//
InsertMenuItem(hSubMenu, (UINT)-1, TRUE, &mii);
}
//
// add a couple more that aren't in the button array
//
LoadString(g_hInst, IDS_MI_VIEW_ISTB, szText, sizeof(szText));
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
mii.fType = MFT_STRING;
mii.fState = MFS_ENABLED;
mii.dwTypeData = szText;
mii.wID = IDM_VIEW_ISTB;
//
// tack this item onto the end of the menu
//
InsertMenuItem(hSubMenu, (UINT)-1, TRUE, &mii);
LoadString(g_hInst, IDS_MI_VIEW_IETB, szText, sizeof(szText));
ZeroMemory(&mii, sizeof(mii));
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
mii.fType = MFT_STRING;
mii.fState = MFS_ENABLED;
mii.dwTypeData = szText;
mii.wID = IDM_VIEW_IETB;
//
// tack this item onto the end of the menu
//
InsertMenuItem(hSubMenu, (UINT)-1, TRUE, &mii);
return hSubMenu;
}
STDMETHODIMP
CShellView::Refresh(
void
)
/*++
IShellView::Refresh
--*/
{
//
// empty the list
//
ListView_DeleteAllItems(m_hwndList);
//
// refill the list
//
FillList();
return S_OK;
}
STDMETHODIMP
CShellView::CreateViewWindow(
LPSHELLVIEW pPrevView,
LPCFOLDERSETTINGS lpfs,
LPSHELLBROWSER psb,
LPRECT prcView,
HWND *phWnd
)
/*++
CreateViewWindow creates a view window. This can be either the right pane
of the Explorer or the client window of a folder window.
--*/
{
WNDCLASS wc;
*phWnd = NULL;
//
// if our window class has not been registered, then do so
//
if(!GetClassInfo(g_hInst, NS_CLASS_NAME, &wc)) {
ZeroMemory(&wc, sizeof(wc));
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = g_hInst;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = NS_CLASS_NAME;
if(!RegisterClass(&wc))
return E_FAIL;
}
//
// set up the member variables
//
m_pShellBrowser = psb;
m_FolderSettings.ViewMode = lpfs->ViewMode;
m_FolderSettings.fFlags = lpfs->fFlags;
//
// get our parent window
//
m_pShellBrowser->GetWindow(&m_hwndParent);
GetSettings();
*phWnd = CreateWindowEx( 0,
NS_CLASS_NAME,
NULL,
WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
prcView->left,
prcView->top,
prcView->right - prcView->left,
prcView->bottom - prcView->top,
m_hwndParent,
NULL,
g_hInst,
(LPVOID)this);
if(*phWnd == NULL)
return E_FAIL;
//
// addref the IShellBrowser interface to allow communication with Explorer
//
m_pShellBrowser->AddRef();
return S_OK;
}
STDMETHODIMP
CShellView::DestroyViewWindow(
void
)
/*++
The Explorer calls this method when a folder window or the Explorer
is being closed.
--*/
{
if(m_hMenu)
DestroyMenu(m_hMenu);
DestroyWindow(m_hWnd);
//
// release the shell browser object
//
m_pShellBrowser->Release();
return S_OK;
}
STDMETHODIMP
CShellView::GetCurrentInfo(
LPFOLDERSETTINGS lpfs
)
/*++
The Explorer uses GetCurrentInfo to query the view for standard settings.
--*/
{
// TODO, check proper approach.
*lpfs = m_FolderSettings;
// lpfs->ViewMode = m_FolderSettings.ViewMode;
// lpfs->fFlags = m_FolderSettings.fFlags;
return NOERROR;
}
STDMETHODIMP
CShellView::AddPropertySheetPages(
DWORD dwReserved,
LPFNADDPROPSHEETPAGE lpfn,
LPARAM lParam
)
/*++
The Explorer calls this method when it is opening the View.Options...
property sheet. Views can add pages by creating them and calling the
callback function with the page handles.
--*/
{
OutputDebugStringA("IShellView::AddPropertySheetPages\n");
return E_NOTIMPL;
}
STDMETHODIMP
CShellView::SaveViewState(
void
)
/*++
IShellView::SaveViewState
--*/
{
SaveSettings();
return S_OK;
}
STDMETHODIMP
CShellView::SelectItem(
LPCITEMIDLIST pidlItem,
UINT uFlags
)
/*++
IShellView::SelectItem
--*/
{
return E_NOTIMPL;
}
STDMETHODIMP
CShellView::GetItemObject(
UINT uItem,
REFIID riid,
LPVOID *ppvOut
)
/*++
Used by the common dialogs to get the selected items from the view.
--*/
{
return E_NOTIMPL;
}
LRESULT
CALLBACK
CShellView::WndProc(
HWND hWnd,
UINT uMessage,
WPARAM wParam,
LPARAM lParam
)
{
CShellView *pThis = (CShellView*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
switch (uMessage)
{
case WM_NCCREATE:
{
LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
pThis = (CShellView*)(lpcs->lpCreateParams);
SetWindowLongPtr(hWnd, GWLP_USERDATA, (LPARAM)pThis);
//set the window handle
pThis->m_hWnd = hWnd;
break;
}
case WM_SIZE:
return pThis->OnSize(LOWORD(lParam), HIWORD(lParam));
case WM_CREATE:
return pThis->OnCreate();
case WM_SETFOCUS:
return pThis->OnSetFocus();
case WM_ACTIVATE:
return pThis->OnActivate(wParam, lParam);
case WM_COMMAND:
return pThis->OnCommand( GET_WM_COMMAND_ID(wParam, lParam),
GET_WM_COMMAND_CMD(wParam, lParam),
GET_WM_COMMAND_HWND(wParam, lParam));
case WM_INITMENUPOPUP:
return pThis->UpdateMenu((HMENU)wParam);
case WM_NOTIFY:
return pThis->OnNotify((UINT)wParam, (LPNMHDR)lParam);
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
LRESULT
CShellView::OnSetFocus(
void
)
{
//
// tell the browser we got the focus
//
m_pShellBrowser->OnViewWindowActive(this);
return 0;
}
LRESULT
CShellView::OnActivate(
WPARAM wParam,
LPARAM lParam
)
{
//
// tell the browser we got the focus
//
if(wParam)
m_pShellBrowser->OnViewWindowActive(this);
return 0;
}
LRESULT
CShellView::OnCommand(
DWORD dwCmdID,
DWORD dwCmd,
HWND hwndCmd
)
{
switch(dwCmdID)
{
case IDM_MESSAGE1:
MessageBox(m_hWnd, TEXT("Message 1 was selected"), TEXT("Notice"), MB_OK | MB_ICONEXCLAMATION);
break;
case IDM_MESSAGE2:
MessageBox(m_hWnd, TEXT("Message 2 was selected"), TEXT("Notice"), MB_OK | MB_ICONEXCLAMATION);
break;
case IDM_VIEW_ISTB:
m_bShowISTB = ! m_bShowISTB;
UpdateToolbar();
break;
case IDM_VIEW_IETB:
m_bShowIETB = ! m_bShowIETB;
UpdateToolbar();
break;
}
return 0;
}
HRESULT
CShellView::SaveSettings(
void
)
/*++
Called by IShellView::SaveViewState to store the relevant setting data
to the browser stream.
--*/
{
HRESULT hr;
LPSTREAM pStream;
hr = m_pShellBrowser->GetViewStateStream(STGM_WRITE, &pStream);
if(SUCCEEDED(hr))
{
ULONG uWritten;
pStream->Write(&m_bShowISTB, sizeof(m_bShowISTB), &uWritten);
pStream->Write(&m_bShowIETB, sizeof(m_bShowIETB), &uWritten);
pStream->Write(&m_nColumn1, sizeof(m_nColumn1), &uWritten);
pStream->Write(&m_nColumn2, sizeof(m_nColumn2), &uWritten);
pStream->Release();
}
return hr;
}
HRESULT
CShellView::GetSettings(
void
)
{
HRESULT hr;
LPSTREAM pStream;
hr = m_pShellBrowser->GetViewStateStream(STGM_READ, &pStream);
if(SUCCEEDED(hr)) {
ULONG uRead;
if(S_OK != pStream->Read(&m_bShowISTB, sizeof(m_bShowISTB), &uRead))
m_bShowISTB = FALSE;
if(S_OK != pStream->Read(&m_bShowIETB, sizeof(m_bShowIETB), &uRead))
m_bShowIETB = FALSE;
if(S_OK != pStream->Read(&m_nColumn1, sizeof(m_nColumn1), &uRead))
m_nColumn1 = INITIAL_COLUMN_POS;
if(S_OK != pStream->Read(&m_nColumn2, sizeof(m_nColumn2), &uRead))
m_nColumn2 = INITIAL_COLUMN_POS;
pStream->Release();
}
return hr;
}
LRESULT
CShellView::UpdateMenu(
HMENU hMenu
)
{
return 0;
}
void
CShellView::UpdateToolbar()
{
// nothing to update yet
}
LRESULT
CShellView::OnNotify(
UINT CtlID,
LPNMHDR pNotify
)
{
LPNM_LISTVIEW pNotifyLV = (LPNM_LISTVIEW)pNotify;
LV_DISPINFO *pNotifyDI = (LV_DISPINFO *)pNotify;
LPTBNOTIFY pNotifyTB = (LPTBNOTIFY)pNotify;
LPTOOLTIPTEXT pNotifyTT = (LPTOOLTIPTEXT)pNotify;
switch(pNotify->code)
{
//
// HDN_BEGINTRACK
// HDN_DIVIDERDBLCLICK
// HDN_ENDTRACK
// HDN_ITEMCHANGED
// HDN_ITEMCHANGING
// HDN_ITEMCLICK
// HDN_ITEMDBLCLICK
// HDN_TRACK
//
case HDN_ENDTRACK:
{
m_nColumn1 = ListView_GetColumnWidth(m_hwndList, 0);
m_nColumn2 = ListView_GetColumnWidth(m_hwndList, 1);
break;
}
//
// LVN_BEGINDRAG
// LVN_BEGINLABELEDIT
// LVN_BEGINRDRAG
// LVN_COLUMNCLICK
// LVN_DELETEALLITEMS
// LVN_DELETEITEM
// LVN_ENDLABELEDIT
// LVN_GETDISPINFO
// LVN_INSERTITEM
// LVN_ITEMCHANGED
// LVN_ITEMCHANGING
// LVN_KEYDOWN
// LVN_SETDISPINFO
//
case LVN_DELETEITEM:
{
LPITEMIDLIST pidl = (LPITEMIDLIST)(pNotifyLV->lParam);
//
// free the memory for the pidl associated with this item.
//
if(pidl != NULL)
FreePidl(pidl);
break;
}
// NM_CLICK
// NM_DBLCLK
// NM_KILLFOCUS
// NM_LISTVIEW
// NM_OUTOFMEMORY
// NM_RCLICK
// NM_RDBLCLK
// NM_RETURN
// NM_SETFOCUS
// NM_TREEVIEW
// NM_UPDOWN
//
case NM_RETURN:
case NM_DBLCLK:
{
UINT wFlags = SBSP_RELATIVE | SBSP_DEFMODE;
int iItem = -1;
//
// if we are in explorer mode, start out in DEFBROWSER mode,
// otherwise, start in NEWBROWSER mode.
//
HWND hwnd = NULL;
m_pShellBrowser->GetControlWindow(FCW_TREE, &hwnd);
if(hwnd != NULL) {
wFlags |= SBSP_DEFBROWSER;
} else {
wFlags |= SBSP_NEWBROWSER;
}
//
// loop through all the selected items.
// TODO: if more than two are selected, we only get to view
// two.
//
do {
LV_ITEM item;
iItem = ListView_GetNextItem(m_hwndList, iItem, LVNI_SELECTED | LVNI_ALL);
ZeroMemory(&item, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = iItem;
if(!ListView_GetItem(m_hwndList, &item))
break;
LPCITEMIDLIST pidl = (LPCITEMIDLIST)(item.lParam);
if(pidl != NULL) {
//
// don't browse into items.
//
if(GetLastPidlType(pidl) > PIDL_TYPE_SUBTYPE)
break;
m_pShellBrowser->BrowseObject(pidl, wFlags);
}
//
// if multiple items selected, bring up a new browser
//
wFlags &= ~SBSP_DEFBROWSER;
wFlags |= SBSP_NEWBROWSER;
} while (iItem != -1);
}
//
// TBN_BEGINADJUST
// TBN_BEGINDRAG
// TBN_CUSTHELP
// TBN_ENDADJUST
// TBN_ENDDRAG
// TBN_GETBUTTONINFO
// TBN_QUERYDELETE
// TBN_QUERYINSERT
// TBN_RESET
// TBN_TOOLBARCHANGE
//
case TBN_BEGINDRAG:
default:
return 0;
}
return 0;
}
LRESULT
CShellView::OnSize(
WORD wWidth,
WORD wHeight
)
{
//
// resize the ListView to fit our window
//
if(m_hwndList)
MoveWindow(m_hwndList, 0, 0, wWidth, wHeight, TRUE);
return 0;
}
LRESULT
CShellView::OnCreate(
void
)
{
//
// create the ListView
//
if(CreateList())
{
if(InitList())
{
FillList();
}
}
return 0;
}
BOOL
CShellView::CreateList(
void
)
{
DWORD dwStyle;
//
// fetch the prior listview style and use
// that as the new listview style.
//
switch (m_FolderSettings.ViewMode) {
case FVM_ICON:
dwStyle = LVS_ICON;
break;
case FVM_SMALLICON:
dwStyle = LVS_SMALLICON;
break;
case FVM_LIST:
dwStyle = LVS_LIST;
break;
case FVM_DETAILS:
dwStyle = LVS_REPORT;
break;
default:
dwStyle = LVS_ICON;
break;
}
m_hwndList = CreateWindowEx(
WS_EX_CLIENTEDGE,
WC_LISTVIEW,
NULL,
WS_TABSTOP |
WS_VISIBLE |
WS_CHILD |
WS_BORDER |
LVS_SORTASCENDING |
dwStyle |
LVS_NOSORTHEADER |
0,
0,
0,
0,
0,
m_hWnd,
(HMENU)ID_LISTVIEW,
g_hInst,
NULL
);
return (BOOL)(NULL != m_hwndList);
}
BOOL
CShellView::InitList(
void
)
{
LV_COLUMN lvColumn;
HIMAGELIST himlSmall;
HIMAGELIST himlLarge;
RECT rc;
TCHAR szString[MAX_PATH];
//
// empty the list
//
ListView_DeleteAllItems(m_hwndList);
//
// initialize the columns
//
lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
lvColumn.fmt = LVCFMT_LEFT;
lvColumn.pszText = szString;
lvColumn.cx = m_nColumn1;
LoadString(g_hInst, IDS_COLUMN1, szString, sizeof(szString));
ListView_InsertColumn(m_hwndList, 0, &lvColumn);
GetClientRect(m_hWnd, &rc);
lvColumn.cx = m_nColumn2;
LoadString(g_hInst, IDS_COLUMN2, szString, sizeof(szString));
ListView_InsertColumn(m_hwndList, 1, &lvColumn);
int cxSmall;
int cySmall;
int cxLarge;
int cyLarge;
SHFILEINFO sfi;
HIMAGELIST himl;
//
// get large and small icon size info from shell
//
himl = (HIMAGELIST)SHGetFileInfo(
NULL,
0,
&sfi,
sizeof(sfi),
SHGFI_LARGEICON | SHGFI_SYSICONINDEX
);
if(!ImageList_GetIconSize(himl, &cxLarge, &cyLarge)) {
cxLarge = GetSystemMetrics(SM_CXICON);
cyLarge = GetSystemMetrics(SM_CYICON);
}
himl = (HIMAGELIST)SHGetFileInfo(
NULL,
0,
&sfi,
sizeof(sfi),
SHGFI_SMALLICON | SHGFI_SYSICONINDEX
);
if(!ImageList_GetIconSize(himl, &cxSmall, &cySmall)) {
cxSmall = GetSystemMetrics(SM_CXSMICON);
cySmall = GetSystemMetrics(SM_CYSMICON);
}
//
// Create the full-sized and small icon image lists.
//
himlLarge = ImageList_Create(
cxLarge,
cyLarge,
ILC_COLORDDB | ILC_MASK,
4, // initial image count
0
);
himlSmall = ImageList_Create(
cxSmall,
cySmall,
ILC_COLORDDB | ILC_MASK,
4, // initial image count
0
);
//
// Add icons to each image list.
// TODO cache icons
//
HICON hIconSmall;
HICON hIconLarge;
// icon 0: Provider icon
hIconSmall = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_PROVIDER), IMAGE_ICON, cxSmall, cySmall, LR_DEFAULTCOLOR | LR_SHARED);
hIconLarge = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_PROVIDER), IMAGE_ICON, cxLarge, cyLarge, LR_DEFAULTCOLOR | LR_SHARED);
ImageList_AddIcon(himlSmall, hIconSmall);
ImageList_AddIcon(himlLarge, hIconLarge);
// icon 1: type icon
hIconSmall = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_FOLDER), IMAGE_ICON, cxSmall, cySmall, LR_DEFAULTCOLOR | LR_SHARED);
hIconLarge = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_FOLDER), IMAGE_ICON, cxLarge, cyLarge, LR_DEFAULTCOLOR | LR_SHARED);
ImageList_AddIcon(himlSmall, hIconSmall);
ImageList_AddIcon(himlLarge, hIconLarge);
// icon 2: item icon
hIconSmall = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_ITEM), IMAGE_ICON, cxSmall, cySmall, LR_DEFAULTCOLOR | LR_SHARED);
hIconLarge = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_ITEM), IMAGE_ICON, cxLarge, cyLarge, LR_DEFAULTCOLOR | LR_SHARED);
ImageList_AddIcon(himlSmall, hIconSmall);
ImageList_AddIcon(himlLarge, hIconLarge);
// icon 3: global type
hIconSmall = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_GLOBAL), IMAGE_ICON, cxSmall, cySmall, LR_DEFAULTCOLOR | LR_SHARED);
hIconLarge = (HICON)LoadImage(g_hInst, MAKEINTRESOURCE(IDI_GLOBAL), IMAGE_ICON, cxLarge, cyLarge, LR_DEFAULTCOLOR | LR_SHARED);
ImageList_AddIcon(himlSmall, hIconSmall);
ImageList_AddIcon(himlLarge, hIconLarge);
//
// Assign the image lists to the list view control.
//
ListView_SetImageList(m_hwndList, himlLarge, LVSIL_NORMAL);
ListView_SetImageList(m_hwndList, himlSmall, LVSIL_SMALL);
return TRUE;
}
BOOL
CShellView::FillList(
void
)
{
LPENUMIDLIST pEnumIDList;
ULONG ulFetched;
LPITEMIDLIST pidl = NULL;
pEnumIDList = new CEnumIDList(m_pidl, TRUE);
if(pEnumIDList == NULL)
return FALSE;
//
// enumerate the sub folders or items, based on the parent m_pidl.
// note that storage is allocated for the pidlNew, which is a copy
// of the current path + pidl - that storage is later freed during
// the processing of LVN_DELETEITEM
//
while( NOERROR == pEnumIDList->Next(1, &pidl, &ulFetched) ) {
LPCWSTR szText = GetPidlText(pidl);
PST_KEY KeyType = GetPidlKeyType(pidl);
DWORD dwPidlType = GetPidlType(pidl);
//
// make a fully qualified (absolute) pidl
//
// LPITEMIDLIST pidlNew = CopyCatPidl(m_pidl, pidl);
//
// free pidl associated with Next enumeration
//
// FreePidl(pidl);
//
// add item with absolute pidl to listview
//
AddListItem(m_hwndList, dwPidlType, KeyType, szText, pidl);
}
pEnumIDList->Release();
return TRUE;
}
BOOL
AddListItem(
HWND hWnd,
DWORD dwType,
PST_KEY KeyType,
LPCWSTR szName,
LPITEMIDLIST pidl
)
/*++
This function is a temporary hack to support image list add/set data.
This will be replaced by an Unicode interface that operates on WinNT and
Win95 in the near future.
--*/
{
LVITEM lvItem;
int nIndex;
DWORD dwIconIndex;
//
// determine which icon to use.
// when PST_KEY is not PST_KEY_LOCAL_MACHINE, use a different folder
// icon at the type and subtype level.
//
switch(dwType) {
case PIDL_TYPE_PROVIDER:
dwIconIndex = 0;
break;
case PIDL_TYPE_TYPE:
case PIDL_TYPE_SUBTYPE:
if(KeyType == PST_KEY_CURRENT_USER)
dwIconIndex = 1;
else
dwIconIndex = 3; // global (shared) icon
break;
case PIDL_TYPE_ITEM:
dwIconIndex = 2;
break;
default:
dwIconIndex = 0;
}
ZeroMemory(&lvItem, sizeof(lvItem));
lvItem.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
lvItem.iItem = 0;
lvItem.lParam = (LPARAM)pidl;
lvItem.pszText = (LPTSTR)szName;
lvItem.iImage = dwIconIndex; // image index
nIndex = ListView_InsertItemU(hWnd, &lvItem);
// ListView_SetItemTextU(hWnd, nIndex, 1, (LPWSTR)szValue);
return TRUE;
}
Reference in a new issue Copy permalink