Enumdesk Clones

/************************************************
   THIS CODE AND INFORMATION IS PROVIDED 'AS IS' 
   WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED 
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO
   THE IMPLIED WARRANTIES OF MERCHANTABILITY 
   AND/OR FITNESS FOR A PARTICULAR PURPOSE.
   Author: Barretto VN  7/2002
*************************************************/


// FilesViewView.h : interface of the CFilesViewView class
//
/////////////////////////////////////////////////////////////////////////////

#if !defined(AFX_FILESVIEWVIEW_H__629DEDBF_4689_11D7_B1DC_83923F364322__INCLUDED_)
#define AFX_FILESVIEWVIEW_H__629DEDBF_4689_11D7_B1DC_83923F364322__INCLUDED_

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#include "ShellClass.h"

enum SubItems 
{
	SUBITEM_NAME, SUBITEM_TYPE, SUBITEM_SIZE, SUBITEM_MODIFIED
};

class CFilesViewView : public CWindowImpl<CFilesViewView, CListViewCtrl>
{
public:
	DECLARE_WND_SUPERCLASS(NULL, CListViewCtrl::GetWndClassName())

	int giRowCtr;

	BOOL PreTranslateMessage(MSG* pMsg)
	{
		pMsg;
		return FALSE;
	}

	BEGIN_MSG_MAP(CFilesViewView)
	END_MSG_MAP()


	void SetListViewColumns(HWND m_hWndList)
	{
	#define TOTAL_COLS 4
	LV_COLUMN   lvColumn; 
	int         i; 
	TCHAR       szString[TOTAL_COLS][20] = {"Name", "Type", "Size", "Modified"};  
	int         szColWidth[TOTAL_COLS] = {120, 80 , 60, 110};

		//empty the list 
		ListView_DeleteAllItems(m_hWndList);  //initialize the columns 
		lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM; 
		lvColumn.fmt = LVCFMT_LEFT; 

		for(i = 0; i < TOTAL_COLS; i++)    
		{    
			lvColumn.pszText = szString[i];    
			lvColumn.cx = szColWidth[i];
			ListView_InsertColumn(m_hWndList, i, &lvColumn);    
		}  
  
	}  

	BOOL InsertListViewItem(LPSHELLFOLDER lpsf, 
						    LPITEMIDLIST lpi,
						    LPITEMIDLIST lpifq,
							HWND m_hWndList)
	{

	char szBuff[MAX_PATH];
	LPMALLOC lpMalloc;
	LPTVITEMDATA* lptvid = NULL;
	LPITEMIDLIST pidl = NULL;	
	
		UINT uFlags;
		LV_ITEM lvi;
	
		CShellClass sc;

		lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;

		sc.GetName (lpsf, lpi, SHGDN_NORMAL, szBuff);

		lvi.iItem = giRowCtr++;
		lvi.iSubItem = 0 ; //COL_NAME;
		lvi.pszText =  LPSTR_TEXTCALLBACK; //szBuff; // LPSTR_TEXTCALLBACK;
	//	lvi.cchTextMax = MAX_PATH;
		uFlags = SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON;

	    SHGetMalloc(&lpMalloc);
		lptvid = (LPTVITEMDATA*) lpMalloc->Alloc ( sizeof (LPTVITEMDATA));
		pidl =  sc.Concatenate(lpMalloc, lpifq,lpi);

		lvi.iImage = sc.GetNormalIcon(pidl);  //I_IMAGECALLBACK;
		lptvid->lpsfParent = lpsf;
		lptvid->lpi = sc.CopyItemID(lpMalloc, lpi);
		lptvid->lpifq = pidl; //csc.CopyItemID(lpMalloc, pidl);
		lvi.lParam = (LPARAM)lptvid;
		ListView_InsertItem (m_hWndList, &lvi);
		lpMalloc->Release();

		return TRUE;
	}

	void    PopulateList(TV_ITEM tvi, HWND m_hWndList)
	{
	LPTVITEMDATA* lptvid = NULL;
	HTREEITEM hItem = NULL;
	HRESULT hr;
	LPENUMIDLIST lpe = NULL;	
	ULONG celtFetched;
	LPITEMIDLIST pidlItems = NULL;
	LPENUMIDLIST ppenum = NULL;
	IShellFolder *psfProgFiles = NULL;
	LPMALLOC m_pMalloc;

		hr = SHGetMalloc(&m_pMalloc);

		if(FAILED(hr))
			return;

		lptvid = (LPTVITEMDATA*) m_pMalloc->Alloc ( sizeof (LPTVITEMDATA));
		if (! lptvid)
		{
			return; // Error - could not allocate memory
		}

		lptvid = (LPTVITEMDATA*)tvi.lParam;
		if(lptvid == NULL)
			return;

		if(lptvid->bRoot)
			psfProgFiles = lptvid->lpsfParent;
		else
		{
			hr = lptvid->lpsfParent->BindToObject(lptvid->lpi, NULL, IID_IShellFolder, (LPVOID *) &psfProgFiles);
			if(FAILED(hr))
					return;
		}

		hr = psfProgFiles->EnumObjects(NULL,SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN , &ppenum);
		if(FAILED(hr))
			return;

		SetCursor(LoadCursor(NULL,IDC_WAIT));
	
		SendMessage(m_hWndList, WM_SETREDRAW, FALSE, 0L);

		ListView_DeleteAllItems(m_hWndList);
		giRowCtr = 0;

		while( hr = ppenum->Next(1,&pidlItems, &celtFetched) == S_OK && (celtFetched) == 1)
	    {

			ULONG uAttr = SFGAO_FOLDER;
			psfProgFiles->GetAttributesOf(1, (LPCITEMIDLIST *) &pidlItems, &uAttr);
			if(!(uAttr & SFGAO_FOLDER))
				InsertListViewItem(psfProgFiles , pidlItems , lptvid->lpifq, m_hWndList);
	    }

		m_pMalloc->Release();
		SetCursor(LoadCursor(NULL,IDC_ARROW));
		SendMessage(m_hWndList, WM_SETREDRAW, TRUE, 0L);
		::InvalidateRect(m_hWndList, NULL, TRUE);

	}

	void setDisplayInfo(LV_DISPINFO *lpdi)
	{
	LPMALLOC m_pMalloc;
	HRESULT hr;
	LPTVITEMDATA* pData = NULL;
	char refTime[20];
	WIN32_FIND_DATA fd;
	SYSTEMTIME st;
	STRRET srName;

	//	LPITEMIDLIST pidl = (LPITEMIDLIST)lpdi->item.lParam;
		lpdi->item.mask |= LVIF_DI_SETITEM;	// dont ask us again
	//	LPMYPIDLDATA pData = m_pPidlMgr->GetDataPointer(pidl);
	//	if(!pData)
	//		return;

	    hr = SHGetMalloc(&m_pMalloc);

		if(FAILED(hr))
			return;

		CShellClass sc; 

		pData = (LPTVITEMDATA*) m_pMalloc->Alloc ( sizeof (LPTVITEMDATA));
		if (! pData)
		{
			return; // Error - could not allocate memory
		}

		pData = (LPTVITEMDATA*)lpdi->item.lParam;
		if(pData == NULL)
			return;

		if(lpdi->item.iSubItem)	// Subitem information being requested
		{
			//is the text being requested?
			if(lpdi->item.mask & LVIF_TEXT)
			{
				switch (lpdi->item.iSubItem)
				{
				case SUBITEM_MODIFIED:
					{
						hr = SHGetDataFromIDList(pData->lpsfParent , pData->lpi, SHGDFIL_FINDDATA , (WIN32_FIND_DATA*)&fd , sizeof(fd));
						if(FAILED(hr))
							break;
	
						FileTimeToSystemTime( &fd.ftLastWriteTime, &st );
						wsprintf(refTime, "%02u-%02u-%04u" , st.wMonth, st.wDay, st.wYear ); 
						lstrcpy(lpdi->item.pszText, refTime);
					}
					break;
				case SUBITEM_SIZE:
					{
						hr = SHGetDataFromIDList(pData->lpsfParent , pData->lpi, SHGDFIL_FINDDATA , (WIN32_FIND_DATA*)&fd , sizeof(fd));
						if(FAILED(hr))
							break ;
	
						if(fd.nFileSizeLow)
						{
							char sNumBuff[30];
							if(fd.nFileSizeLow != 0)
								ltoa((long)fd.nFileSizeLow,sNumBuff,10);
							else
								strcpy(sNumBuff,"");
		
							lstrcpy(lpdi->item.pszText, sNumBuff);
	
						}
					}			
					break;
				case SUBITEM_TYPE:
		    		GetTypeOf(pData->lpifq, &srName);
					lstrcpy(lpdi->item.pszText, srName.cStr);
        			break;

				}
			}
		}
		else	// The item information is being requested
		{
			if(lpdi->item.mask & LVIF_TEXT)
			{

				char szBuff[MAX_PATH];
				sc.GetName(pData->lpsfParent, pData->lpi, SHGDN_NORMAL , szBuff);
				lpdi->item.pszText = (LPSTR)szBuff; 
				lpdi->item.cchTextMax = lstrlen(szBuff);
	//			lpdi->item.iImage = GetIcon(pData->lpifq, FALSE);
			}
		
			if ((lpdi->item.mask & LVIF_IMAGE) == LVIF_IMAGE)
			{
	
	//			if (m_fsFolderSettings.ViewMode != FVM_ICON)
	//				lpdi->item.iImage = GetIcon(pData->lpi, FALSE);
	//			else
	//				lpdi->item.iImage = GetIcon(pData->lpi, TRUE);
			}
		}

		m_pMalloc->Release();

	}

	void GetTypeOf(LPITEMIDLIST pit, LPSTRRET lpName)
	{
	SHFILEINFO sfi;

	    lpName->uType = STRRET_CSTR;
		lpName->cStr[0] = '\0';
		if (SHGetFileInfo((LPTSTR)pit, 
			            0, 
						&sfi, 
						sizeof(sfi),
	    SHGFI_USEFILEATTRIBUTES | SHGFI_TYPENAME | SHGFI_PIDL))
		{
			lstrcpy(lpName->cStr, sfi.szTypeName);
	    }
	}


	void UpdateViewStyle(UINT uiStyle, HWND hWndListView, HWND hWndMain)
	{
		DWORD dwStyle = ::GetWindowLong(hWndListView, GWL_STYLE);
		dwStyle &= ~LVS_TYPEMASK;

//		CheckMenuItem (::GetMenu (hWndMain), ID_VIEW_LARGEICONS , uiStyle == ID_VIEW_LARGEICONS ? MF_CHECKED : MF_UNCHECKED);
//		CheckMenuItem (::GetMenu (hWndMain), ID_VIEW_SMALLICONS , uiStyle == ID_VIEW_SMALLICONS ? MF_CHECKED : MF_UNCHECKED);
//		CheckMenuItem (::GetMenu (hWndMain), ID_VIEW_LIST       , uiStyle == ID_VIEW_LIST       ? MF_CHECKED : MF_UNCHECKED);
//		CheckMenuItem (::GetMenu (hWndMain), ID_VIEW_DETAILS     , uiStyle == ID_VIEW_DETAILS    ? MF_CHECKED : MF_UNCHECKED);

		switch (uiStyle)
		{
		case ID_VIEW_LARGEICONS:
			dwStyle |= LVS_ICON;
			break;
		case ID_VIEW_SMALLICONS:
			dwStyle |= LVS_SMALLICON;
			break;
		case ID_VIEW_LIST:
			dwStyle |= LVS_LIST;
			break;
		case ID_VIEW_DETAILS:
			dwStyle |= LVS_REPORT;
			break;
		}
		::SetWindowLong(hWndListView, GWL_STYLE, dwStyle);
	}


	BOOL ShowStdMenu(LVITEM lvi , BOOL bShowMenu, HINSTANCE appInstance, HWND hWndListView)
	{
	HRESULT hr;
	HMENU hMenuPopup;
	IContextMenu   *icm;
	LPMALLOC m_pMalloc;
	LPTVITEMDATA* lptvid = NULL;
	UINT  id;
	static POINT pt;
	CMINVOKECOMMANDINFO  ici;

		if(!lvi.lParam)
		{
			// Click on an empty area of Listview
			ShowPopupStyleMenu(appInstance, hWndListView);		
			return TRUE;
		}

		hr = SHGetMalloc(&m_pMalloc);

		if(FAILED(hr))
			return FALSE;

	    lptvid = (LPTVITEMDATA*) m_pMalloc->Alloc (sizeof (LPTVITEMDATA));
		if (! lptvid)
			goto Done;


		lptvid = (LPTVITEMDATA*)lvi.lParam;
		if(lptvid == NULL)
			goto Done;

		hr = lptvid->lpsfParent->GetUIObjectOf(
			                       hWndListView, 
				                   1, 
					               (LPCITEMIDLIST*)&lptvid->lpi,
						           IID_IContextMenu, 
							       NULL, 
								   (LPVOID*)&icm);

	    hMenuPopup = CreatePopupMenu();
		if(!hMenuPopup)
			goto Done;
	
		hr = icm->QueryContextMenu(hMenuPopup, 0, 1, 0x7fff, CMF_NORMAL | CMF_EXPLORE);
	    if(FAILED(hr))
			goto Done;

	    GetCursorPos(&pt);

		if(bShowMenu)
			id = TrackPopupMenu(hMenuPopup, 
		              TPM_LEFTALIGN | TPM_RETURNCMD | TPM_RIGHTBUTTON, 
			          pt.x, pt.y,0,
				      hWndListView,NULL);
		else
			// User Double-clicked on menu item, 
			// so we don't show the menu
			// and execute the command
			id = hr;


		if(!id)
			goto Done;


		ici.cbSize = sizeof(CMINVOKECOMMANDINFO);
	    ici.fMask = 0;
		ici.hwnd = hWndListView;
	    ici.lpVerb = (LPCSTR)(INT_PTR)(id - 1);
		ici.lpParameters = NULL;
		ici.lpDirectory = NULL;
	    ici.nShow = SW_SHOWNORMAL;
	    ici.dwHotKey = 0;
		ici.hIcon = NULL;
	    hr = icm->InvokeCommand(&ici);

	Done:
	m_pMalloc->Release();
	return TRUE;

	}

	BOOL GetSelectedItem(LPNMHDR lpnmh , LV_ITEM* lvItem, HWND hWndListView)
	{
		LPNMLISTVIEW   lpnmlv = (LPNMLISTVIEW)lpnmh;
	    lvItem->mask = LVIF_PARAM;
		lvItem->iItem = lpnmlv->iItem;
		if(ListView_GetItem(hWndListView, lvItem))
			return TRUE;
		else
			return FALSE;
	}

	BOOL ShowPopupStyleMenu(HINSTANCE appInstance, HWND hWndListView)
	{
	static POINT point;
	HMENU m_hMenu;
	UINT id;
	HMENU hMenuTrackPopup;

		GetCursorPos(&point);
		m_hMenu = LoadMenu( appInstance, MAKEINTRESOURCE(IDR_VIEW_POPUP));
		hMenuTrackPopup = GetSubMenu (m_hMenu, 0);
		id = TrackPopupMenu(hMenuTrackPopup, 
		          TPM_LEFTALIGN | TPM_RETURNCMD | TPM_RIGHTBUTTON, 
		          point.x, point.y,0,
			      hWndListView, NULL);

		UpdateViewStyle(id, hWndListView, NULL);
		DestroyMenu(m_hMenu);

		return TRUE;
	}



};


/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_FILESVIEWVIEW_H__629DEDBF_4689_11D7_B1DC_83923F364322__INCLUDED_)