开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > Shell编程 > 查看源码
View.cpp
资源名称：adfview_src.zip　[点击查看]
上传用户：hy_wanghao
上传日期：2007-01-08
资源大小：279k
文件大小：36k
源码类别：

Shell编程

开发平台：

Visual C++

View.cpp：源码内容
  1. // View.cpp : Implementation of CView
  3. #include "stdafx.h"
  5. #include "View.h"
  6. #include "Misc.h"
  7. #include "DropSource.h"
  8. #include "DataObject.h"
  9. #include "PropDlg.h"
  12. /////////////////////////////////////////////////////////////////////////////
  13. // CView
  15. HRESULT CView::FinalConstruct()
  16. {
  17.    ATLTRACE(_T("CView::FinalConstructn"));
  18.    // Win95 requires us to call ::OleInitialize() on the View because we use
  19.    // ::OleSetClipboard() and ::DoDragDrop() ???
  20.    // But we've already called it! The 2nd call is ignored on other platforms.
  21.    ::OleInitialize(NULL);
  22.    // Reset variables
  23.    m_pFolder = NULL;
  24.    m_hAccels = ::LoadAccelerators(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_ACCELERATOR));
  25.    m_hMenu = NULL;
  26.    m_bInEdit = false;
  27.    m_bShowDeletedFiles = false;
  28.    m_dwListViewStyle = WS_TABSTOP | 
  29.                        WS_VISIBLE |
  30.                        WS_CHILD | 
  31.                        WS_BORDER | 
  32.                        LVS_REPORT |
  33.                        LVS_AUTOARRANGE |
  34.                        LVS_EDITLABELS |
  35.                        LVS_SHOWSELALWAYS |
  36.                        LVS_SHAREIMAGELISTS;
  37.    return S_OK;
  38. }
  40. void CView::FinalRelease()
  41. {
  42.    ATLASSERT(m_pFolder);
  43.    m_pFolder->Release();
  44.    ::OleUninitialize();
  45. }
  48. /////////////////////////////////////////////////////////////////////////////
  49. // IShellView
  51. STDMETHODIMP CView::CreateViewWindow(
  52.    IShellView *lpPrevView,
  53.    LPCFOLDERSETTINGS lpFS, 
  54.    IShellBrowser *pSB,
  55.    RECT *prcView, 
  56.    HWND *phWnd)
  57. {
  58.    ATLTRACE("CView::CreateViewWindown");
  59.    ATLASSERT(m_pFolder);
  60.    HRESULT Hr;
  61.    HR( IShellViewImpl<CView>::CreateViewWindow(lpPrevView, lpFS, pSB, prcView, phWnd) );
  62.    // Register view as drop target
  63.    LPDROPTARGET pDropTarget = NULL;
  64.    HR( m_pFolder->CreateViewObject(m_hWnd, IID_IDropTarget, (LPVOID *)&pDropTarget) );
  65.    HR( ::RegisterDragDrop(m_hwndList, pDropTarget) );
  66.    return S_OK;
  67. }
  69. STDMETHODIMP CView::DestroyViewWindow(void)
  70. {
  71.    ATLTRACE("CView::DestroyViewWindown");
  72.    ATLASSERT(::IsWindow(m_hwndList));
  73.    ::RevokeDragDrop(m_hwndList);
  74.    return IShellViewImpl<CView>::DestroyViewWindow();
  75. }
  77. STDMETHODIMP CView::GetItemObject(UINT uItem, REFIID riid, LPVOID *ppRetVal)
  78. {
  79.    ATLTRACE(_T("CView::GetItemObject %s (%d)n"), DbgGetIID(riid), uItem);
  80.    VALIDATE_OUT_POINTER(ppRetVal);
  81.    switch( uItem ) {
  82.    case SVGIO_BACKGROUND:
  83.       {
  84.          HRESULT Hr;
  85.          Hr = m_pFolder->CreateViewObject(NULL, riid, ppRetVal);
  86.          if( FAILED(Hr) ) Hr = m_pFolder->QueryInterface(riid, ppRetVal);
  87.          return Hr;
  88.       }
  89.    case SVGIO_SELECTION:
  90.       {
  91.          CPidlList pidls(m_hwndList);
  92.          return m_pFolder->GetUIObjectOf(m_hWnd, pidls.GetCount(), pidls, riid, NULL, ppRetVal);
  93.       }
  94.    case SVGIO_ALLVIEW:
  95.       {
  96.          CPidlList pidls(m_hwndList, LVNI_ALL);
  97.          return m_pFolder->GetUIObjectOf(m_hWnd, pidls.GetCount(), pidls, riid, NULL, ppRetVal);
  98.       }
  99.    default:
  100.       ATLASSERT(false);
  101.       return E_NOINTERFACE;
  102.    }
  103. }
  105. STDMETHODIMP CView::TranslateAccelerator(LPMSG pmsg)
  106. {
  107.    ATLASSERT(pmsg);
  108.    if( m_bInEdit ) {
  109.       if( (pmsg->message >= WM_KEYFIRST) && (pmsg->message <= WM_KEYLAST) ) {
  110.          ::TranslateMessage(pmsg);
  111.          ::DispatchMessage(pmsg);
  112.          return S_OK;
  113.       }
  114.    }
  115.    else {
  116.       if( ::TranslateAccelerator(m_hWnd, m_hAccels, pmsg) ) return S_OK;
  117.    }
  118.    return S_FALSE;
  119. }
  122. /////////////////////////////////////////////////////////////////////////////
  123. // Implementation
  125. HRESULT CView::_Init(CFolder *pFolder)
  126. {
  127.    ATLTRACE("CView::_Initn");
  128.    ATLASSERT(pFolder);
  129.    m_pFolder = pFolder;
  130.    m_pFolder->AddRef();
  131.    return S_OK;
  132. }
  134. // Sort List View item callback function.
  135. int CALLBACK CView::_ListViewSortFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  136. {
  137.    LPCPIDLDATA pData1 = (LPCPIDLDATA)CPidl::_GetLastItem((LPCITEMIDLIST)lParam1);
  138.    LPCPIDLDATA pData2 = (LPCPIDLDATA)CPidl::_GetLastItem((LPCITEMIDLIST)lParam2);
  139.    return CFolder::_CompareItems((short)lParamSort, pData1, pData2);
  140. }
  142. // Setup ListView control
  143. // Adds column headers and clears all items.
  144. BOOL CView::_InitListView()
  145. {
  146.    ATLTRACE("CView::_InitListViewn");
  148.    // Empty the list
  149.    ListView_DeleteAllItems(m_hwndList);
  151.    // Initialize the columns
  152.    LV_COLUMN lvColumn;
  153.    CResString<64> str;
  155.    lvColumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  156.    lvColumn.fmt = LVCFMT_LEFT;
  157.    lvColumn.pszText = str; // We reuse same buffer for all columns
  159.    str.LoadString(IDS_COL_NAME);
  160.    lvColumn.cx = 210;
  161.    ListView_InsertColumn(m_hwndList, COL_NAME, &lvColumn);
  163.    str.LoadString(IDS_COL_SIZE);
  164.    lvColumn.cx = 70;
  165.    lvColumn.fmt = LVCFMT_RIGHT;
  166.    ListView_InsertColumn(m_hwndList, COL_SIZE, &lvColumn);
  168.    str.LoadString(IDS_COL_TYPE);
  169.    lvColumn.cx = 80;
  170.    lvColumn.fmt = LVCFMT_LEFT;
  171.    ListView_InsertColumn(m_hwndList, COL_TYPE, &lvColumn);
  173.    str.LoadString(IDS_COL_MODIFIED);
  174.    lvColumn.cx = 130;
  175.    ListView_InsertColumn(m_hwndList, COL_TIME, &lvColumn);
  177.    if( m_ShellFlags.fShowAttribCol ) {
  178.       str.LoadString(IDS_COL_ATTR);
  179.       lvColumn.cx = 60;
  180.       lvColumn.fmt = LVCFMT_RIGHT;
  181.       ListView_InsertColumn(m_hwndList, COL_ATTRIBS, &lvColumn);
  182.    }
  184.    ListView_SetImageList(m_hwndList, _Module.m_ImageLists.m_hImageListLarge, LVSIL_NORMAL);
  185.    ListView_SetImageList(m_hwndList, _Module.m_ImageLists.m_hImageListSmall, LVSIL_SMALL);
  187.    return TRUE;
  188. }
  190. BOOL CView::_FillListView()
  191. {
  192.    ATLTRACE(_T("CView::_FillListViewn"));
  194.    DWORD dwFlags = SHCONTF_NONFOLDERS | SHCONTF_FOLDERS;
  195.    if( m_bShowDeletedFiles ) dwFlags |= SHCONTF_INCLUDEDELETED;
  197.    LPENUMIDLIST pEnumIDList;
  198.    if (SUCCEEDED(m_pFolder->EnumObjects(m_hWnd, dwFlags, &pEnumIDList) ) ) {
  199.       // Turn the listview's redrawing off
  200.       ::SendMessage(m_hwndList, WM_SETREDRAW, FALSE, 0L);
  201.       
  202.       DWORD dwFetched = 0;
  203.       LPITEMIDLIST pidl = NULL;
  204.       int iItem = 0;
  205.       while( (S_OK == pEnumIDList->Next(1, &pidl, &dwFetched)) && (dwFetched!=0) ) {
  206.          LPCPIDLDATA pData = pidl_cast(pidl);
  207.          LV_ITEM lvi = { 0 };
  208.          lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
  209.          lvi.pszText = LPSTR_TEXTCALLBACK;
  210.          lvi.iImage = I_IMAGECALLBACK;
  211.          lvi.iItem = iItem++;
  212.          lvi.state = 0;
  213.          if( pData->dwEntryFlags & EF_DELETED ) lvi.state |= LVIS_CUT;
  214.          lvi.stateMask = (UINT)-1;
  215.          lvi.lParam = (LPARAM)CPidl::_Copy(pidl);
  216.          ListView_InsertItem(m_hwndList, &lvi);
  217.       }
  218.       pEnumIDList->Release();
  220.       ListView_SortItems(m_hwndList, _ListViewSortFunc, 0);
  222.       // Turn the listview's redrawing back on and force it to draw
  223.       ::SendMessage(m_hwndList, WM_SETREDRAW, TRUE, 0L);
  224.       ::InvalidateRect(m_hwndList, NULL, TRUE);
  225.       ::UpdateWindow(m_hwndList);
  226.    }
  228.    return TRUE;
  229. }
  231. // Merge the toolbar
  232. BOOL CView::_MergeToolbar(UINT uState)
  233. {
  234.    ATLTRACE(_T("CView::_MergeToolbarn"));
  235.    ATLASSERT(m_pShellBrowser);
  237.    static NS_TOOLBUTTONINFO ToolBarItems[] =
  238.    {
  239.       TBI_STD, { STD_CUT,        ID_EDIT_CUT,        0, TBSTYLE_BUTTON, 0, 0 },
  240.       TBI_STD, { STD_COPY,       ID_EDIT_COPY,       0, TBSTYLE_BUTTON, 0, 0 },
  241.       TBI_STD, { STD_PASTE,      ID_EDIT_PASTE,      0, TBSTYLE_BUTTON, 0, 0 },
  242.       TBI_STD, { 0,              0,                  0, TBSTYLE_SEP,    0, 0 },
  243.       TBI_STD, { STD_DELETE,     ID_EDIT_DELETE,     0, TBSTYLE_BUTTON, 0, 0 },
  244.       TBI_STD, { STD_PROPERTIES, ID_EDIT_PROPERTIES, 0, TBSTYLE_BUTTON, 0, 0 },
  245.    };
  247.    // Don't unmerge toolbar; Shell will do it.
  248.    if( uState==SVUIA_DEACTIVATE ) return TRUE;
  250.    HRESULT Hr;
  251.    LRESULT lOffsetFile = 0;
  252.    LRESULT lOffsetView = 0;
  253.    LRESULT lOffsetCustom = 0;
  255.    Hr = m_pShellBrowser->SetToolbarItems(NULL, 0, FCT_MERGE);
  257.    // Add the toolbar bitmaps (use standard COMCTRL bitmaps)
  258.    TBADDBITMAP tbab;
  259.    tbab.hInst = HINST_COMMCTRL;
  260.    tbab.nID = IDB_STD_SMALL_COLOR;
  261.    Hr = m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ADDBITMAP, 0, (LPARAM)&tbab, &lOffsetFile);
  262.    tbab.hInst = HINST_COMMCTRL;
  263.    tbab.nID = IDB_VIEW_SMALL_COLOR;
  264.    Hr = m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ADDBITMAP, 0, (LPARAM)&tbab, &lOffsetView);
  266.    // Add the buttons
  267.    BOOL res = _AppendToolbarItems(ToolBarItems, lengthof(ToolBarItems), 
  268.                                   lOffsetFile,lOffsetView,lOffsetCustom);
  269.    if( !res ) return FALSE;
  271.    _UpdateToolbar();
  272.    return TRUE;
  273. }
  275. // Updates the toolbar.
  276. BOOL CView::_UpdateToolbar()
  277. {   
  278.    ATLTRACE(_T("CView::_UpdateToolbarn"));
  279.    ATLASSERT(m_pShellBrowser);
  280.    ATLASSERT(::IsWindow(m_hwndList));
  281.    LPARAM lResult;
  282.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  284.    m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, ID_EDIT_COPY, MAKELPARAM(nCount!=0, 0), &lResult);
  285.    m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, ID_EDIT_CUT, MAKELPARAM(nCount!=0, 0), &lResult);
  286.    m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, ID_EDIT_PROPERTIES, MAKELPARAM(nCount==1, 0), &lResult);
  287.    m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, ID_EDIT_DELETE, MAKELPARAM(nCount!=0, 0), &lResult);
  289.    BOOL bClipboardCopy = _HasClipDataReady();
  290.    m_pShellBrowser->SendControlMsg(FCW_TOOLBAR, TB_ENABLEBUTTON, ID_EDIT_PASTE, MAKELPARAM(bClipboardCopy, 0), &lResult);
  292.    return TRUE;
  293. }
  295. // Merge our own menus into the Shell.
  296. // The 'uState' argument is called with SVUIA_DEACTIVATE
  297. // when the menus should be destroyed rather than created.
  298. BOOL CView::_MergeMenus(UINT uState)
  299. {
  300.    ATLTRACE(_T("CView::_MergeMenus (%d)n"), uState);
  301.    ATLASSERT(m_pShellBrowser);
  302.    typedef enum {
  303.       MENU_INDEX_FILE = 0,
  304.       MENU_INDEX_EDIT = 1,
  305.       MENU_INDEX_VIEW = 2,
  306.       MENU_INDEX_HELP = 3,
  307.    } MENUINDEX;
  309.    if( uState!=SVUIA_DEACTIVATE ) {
  310.       // Create the menu
  311.       // Some undocumented behaviour allows us to tell when the
  312.       // menu is merge when browsing solely in the folder tree or
  313.       // when to merge the view menu. There's a difference because
  314.       // the Explorer adds the "Delete", "Rename" etc items when
  315.       // you browse in the folder tree.
  316.       // We must look at the "uState": SVUIA_ACTIVATE_FOCUS means
  317.       // the view menu should be merged, SVUIA_ACTIVATE_NOFOCUS
  318.       // is the folder tree menu.
  319.       ATLASSERT(m_hMenu==NULL); // Don't merge twice without unmerge
  320.       if( m_hMenu!=NULL ) return FALSE;
  321.       // Load the menu we build the Shell menu from.
  322.       HMENU hSharedMenu = ::LoadMenu(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDR_MENU));
  323.       ATLASSERT(hSharedMenu);
  324.       // Merge the menus
  325.       m_hMenu = ::CreateMenu();
  326.       ATLASSERT(m_hMenu);
  327.       if( m_hMenu==NULL ) return FALSE;
  328.       OLEMENUGROUPWIDTHS omw = {0, 0, 0, 0, 0, 0};
  329.       m_pShellBrowser->InsertMenusSB(m_hMenu, &omw);
  331.       // Add top level sub-menus...
  332.       MENUITEMINFO mii = { 0 };
  333.       mii.cbSize = sizeof(mii);
  334.       mii.fMask = MIIM_SUBMENU;     
  335.       // Merge our items into the File menu
  336.       if( uState==SVUIA_ACTIVATE_FOCUS ) { 
  337.          if( ::GetMenuItemInfo(m_hMenu, FCIDM_MENU_FILE, FALSE, &mii)) {
  338.             HMENU hMenuPopup = ::GetSubMenu(hSharedMenu, MENU_INDEX_FILE);
  339.             _AppendMenu(mii.hSubMenu, hMenuPopup, 0);
  340.          }
  341.       }
  342.       // Merge our items into the Edit menu
  343.       if( uState==SVUIA_ACTIVATE_FOCUS ) {
  344.          if( ::GetMenuItemInfo(m_hMenu, FCIDM_MENU_EDIT, FALSE, &mii)) {
  345.             // Merge our menu
  346.             HMENU hMenuPopup = ::GetSubMenu(hSharedMenu, MENU_INDEX_EDIT);
  347.             _AppendMenu(mii.hSubMenu, hMenuPopup, 0);
  348.          }
  349.       }
  350.       // Merge our items into the View menu
  351.       if( ::GetMenuItemInfo(m_hMenu, FCIDM_MENU_VIEW, FALSE, &mii)) {
  352.          // Find the position of the Seperator
  353.          UINT nPos = _GetMenuPosFromID(mii.hSubMenu, FCIDM_MENU_VIEW_SEP_OPTIONS);
  354.          // and merge...
  355.          HMENU hMenuPopup = ::GetSubMenu(hSharedMenu, MENU_INDEX_VIEW);
  356.          _AppendMenu(mii.hSubMenu, hMenuPopup, nPos+1);
  357.       }
  358.       // Merge our items into the Help menu
  359.       if( ::GetMenuItemInfo(m_hMenu, FCIDM_MENU_HELP, FALSE, &mii)) {
  360.          // Merge our menu
  361.          HMENU hMenuPopup = ::GetSubMenu(hSharedMenu, MENU_INDEX_HELP);
  362.          _AppendMenu(mii.hSubMenu, hMenuPopup, 0);
  363.       }
  364.       m_pShellBrowser->SetMenuSB(m_hMenu, NULL, m_hWnd);
  365.       ::DestroyMenu(hSharedMenu);
  366.    }
  367.    else {
  368.       // Dismantle menu
  369.       m_pShellBrowser->SetMenuSB(NULL, NULL, NULL);
  370.       if( m_hMenu!=NULL ) {
  371.          ATLASSERT(::IsMenu(m_hMenu));
  372.          m_pShellBrowser->RemoveMenusSB(m_hMenu);
  373.          ::DestroyMenu(m_hMenu);
  374.          m_hMenu = NULL;
  375.       }
  376.    }
  377.    return TRUE;
  378. }
  380. // Updates the menu.
  381. // This function is usually called when the user opens one of the
  382. // Shell menus. The HMENU argument is the handled to the opened menu.
  383. BOOL CView::_UpdateMenu(HMENU hMenu)
  384. {
  385.    ATLTRACE(_T("CView::_UpdateMenun"));
  386.    if( !::IsMenu(hMenu) ) return FALSE; // Gets called with our own File sub-menu popups?
  388.    // Deselect some menuitems if there are too many/few ListView items selected
  389.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  390.    ::EnableMenuItem(hMenu, ID_FILE_OPEN, nCount==1 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  391.    ::EnableMenuItem(hMenu, ID_FILE_RENAME, nCount==1 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  392.    ::EnableMenuItem(hMenu, ID_EDIT_PROPERTIES, nCount<=1 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  393.    ::EnableMenuItem(hMenu, ID_EDIT_COPY, nCount!=0 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  394.    ::EnableMenuItem(hMenu, ID_EDIT_CUT, nCount!=0 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  395.    ::EnableMenuItem(hMenu, ID_EDIT_DELETE, nCount!=0 ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  397.    ::CheckMenuItem(hMenu, ID_VIEW_DELETEDFILES, m_bShowDeletedFiles ? MF_CHECKED | MF_BYCOMMAND : MF_UNCHECKED | MF_BYCOMMAND);
  399.    // Check the "View" menu
  400.    UINT idMenu = ID_VIEW_REPORT;
  401.    switch( m_FolderSettings.ViewMode ) {
  402.    case FVM_ICON:
  403.       idMenu = ID_VIEW_LARGEICONS;
  404.       break;
  405.    case FVM_SMALLICON:
  406.       idMenu = ID_VIEW_SMALLICONS;
  407.       break;
  408.    case FVM_LIST:
  409.       idMenu = ID_VIEW_LIST;
  410.       break;
  411.    case FVM_DETAILS:
  412.       idMenu = ID_VIEW_REPORT;
  413.       break;
  414.    }
  415.    ATLASSERT(ID_VIEW_LARGEICONS<ID_VIEW_REPORT);
  416.    ::CheckMenuRadioItem(hMenu, ID_VIEW_LARGEICONS, ID_VIEW_REPORT, idMenu, MF_BYCOMMAND);
  418.    BOOL bClipboardCopy = _HasClipDataReady();
  419.    ::EnableMenuItem(hMenu, ID_EDIT_PASTE, bClipboardCopy ? MF_ENABLED | MF_BYCOMMAND : MF_GRAYED | MF_BYCOMMAND);
  421.    return TRUE;
  422. }
  424. // Check that data exists on the clipboard for paste
  425. BOOL CView::_HasClipDataReady()
  426. {
  427.    BOOL bClipboardCopy = FALSE;
  428.    CComPtr<IDataObject> spDataObject;
  429.    if( SUCCEEDED( ::OleGetClipboard(&spDataObject) ) ) {
  430.       if( !bClipboardCopy ) {
  431.          FORMATETC fe = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  432.          if( SUCCEEDED( spDataObject->QueryGetData(&fe) ) ) {
  433.             bClipboardCopy = TRUE;
  434.          }
  435.       }
  436.       if( !bClipboardCopy ) {
  437.          FORMATETC fe = { _Module.m_CFSTR_FILEDESCRIPTOR, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  438.          if( SUCCEEDED( spDataObject->QueryGetData(&fe) ) ) {
  439.             bClipboardCopy = TRUE;
  440.          }
  441.       }
  442.       if( bClipboardCopy ) {
  443.          if( m_pFolder->_IsDroppedPathSame(spDataObject) ) bClipboardCopy = FALSE; 
  444.       }
  445.    }
  446.    return bClipboardCopy;
  447. }
  449. // This method handles both "Copy/Cut" menu-items and drag'n'drop
  450. // operations. In both cases we need to create an IDataObject object
  451. // and pass it to Windows.
  452. HRESULT CView::_DoCopyOperation(bool bDragDrop, bool bCut)
  453. {
  454.    ATLTRACE(_T("CView::_DoCopyOperationn"));
  455.    
  456.    // Get list from selected ListView items
  457.    CPidlList pidls(m_hwndList);
  458.    pidls.Filter(m_pFolder, bCut ? SFGAO_CANMOVE : SFGAO_CANCOPY);
  459.    if( pidls.GetCount()==0 ) return E_FAIL;
  461.    // Update the ListView to reflect the possible CUT operation.
  462.    // Remove all previous CUT items.
  463.    if( !bDragDrop ) ListView_SetItemState(m_hwndList, -1, 0, LVIS_CUT);
  464.    if( bCut ) {
  465.       // Now mark all selected items as CUT
  466.       int nItem = -1;
  467.       while( (nItem = ListView_GetNextItem(m_hwndList, nItem, LVNI_SELECTED)) != -1 ) {
  468.          ListView_SetItemState(m_hwndList, nItem, LVIS_CUT, LVIS_CUT);
  469.       }
  470.    }
  472.    // Create a IDataObject and let the system handle operation...
  473.    HRESULT Hr;
  474.    CComPtr<IDataObject> spDataObject;
  475.    Hr = m_pFolder->GetUIObjectOf(m_hWnd, 
  476.                                  pidls.GetCount(), 
  477.                                  pidls,
  478.                                  IID_IDataObject, 
  479.                                  NULL, 
  480.                                  (LPVOID*)&spDataObject);
  481.    if( SUCCEEDED(Hr) && (spDataObject!=NULL) ) {
  482.       if( bCut ) {
  483.          // If we're doing 'cut' in copy/cut/paste, we need
  484.          // to notify the IDataObject about our intention
  485.          DataObj_SetDWORD(spDataObject, _Module.m_CFSTR_PREFERREDDROPEFFECT, DROPEFFECT_MOVE);
  486.       }
  487.       if( bDragDrop ) {
  488.          // If we're dragging then call Window's DoDragDrop()
  489.          // method with a freshly created IDropSource object
  490.          CComObject<CDropSource> *pDropSource;
  491.          HR( CComObject<CDropSource>::CreateInstance(&pDropSource) );
  492.          pDropSource->AddRef();
  493.          DWORD dwEffect = 0;
  494.          Hr = ::DoDragDrop(spDataObject, 
  495.                            pDropSource, 
  496.                            DROPEFFECT_COPY | DROPEFFECT_MOVE, 
  497.                            &dwEffect);
  498.          // If the drag drop turned out to be a move operation, we should
  499.          // delete the files
  500.          if( (Hr==DRAGDROP_S_DROP) && (dwEffect & DROPEFFECT_MOVE) ) {
  501.             CPidlList pidls(m_hwndList);
  502.             m_pFolder->_DeleteFiles(pidls, pidls.GetCount());
  503.             ::OleSetClipboard(NULL);
  504.             Refresh();
  505.          }
  506.          pDropSource->Release();
  507.       }
  508.       else {
  509.          // In case of regular copy/cut/paste operatons, we
  510.          // simply need to put the IDataObject on the clipboard.
  511.          // The auto-ptr will release our reference on function
  512.          // exit.
  513.          ::OleSetClipboard(spDataObject);
  514.       }
  515.    }
  516.    _UpdateToolbar();
  518.    return S_OK;
  519. }
  522. /////////////////////////////////////////////////////////////////////////////
  523. // Message Handlers
  525. LRESULT CView::OnNotifyDispInfo(UINT /*CtlID*/, LPNMHDR lpnmh, BOOL& /*bHandled*/)
  526. {
  527.    USES_CONVERSION;
  528.    LV_DISPINFO *lpdi = (LV_DISPINFO *)lpnmh;
  529.    LPITEMIDLIST pidl = (LPITEMIDLIST)lpdi->item.lParam;
  530.    ATLASSERT(pidl);
  531.    lpdi->item.mask |= LVIF_DI_SETITEM;   // dont ask us again
  533.    if( lpdi->item.iSubItem>0 ) {  
  534.       // Sub-item information being requested.
  535.       // Is the text being requested?
  536.       if(lpdi->item.mask & LVIF_TEXT) {
  537.          
  538.          TCHAR szTemp[MAX_PATH];
  539.          LPCPIDLDATA pData = pidl_cast(pidl);
  540.          switch( lpdi->item.iSubItem ) {
  541.          case COL_SIZE:
  542.             if( pData->type==PT_FILE ) {
  543.                WCHAR szwTemp[32];
  544.                if( pData->dwEntryFlags & EF_DELETED ) {
  545.                   szwTemp[0] = L'';
  546.                }
  547.                else {
  548.                   LONGLONG longlong = pData->dwSize;
  549.                   ::StrFormatByteSizeW(longlong, szwTemp, lengthof(szwTemp));
  550.                }
  551.                _tcsncpy(lpdi->item.pszText, W2CT(szwTemp), lpdi->item.cchTextMax);
  552.             }
  553.             break;
  554.          case COL_TYPE:
  555.             _tcsncpy(lpdi->item.pszText, pData->szType, lpdi->item.cchTextMax);
  556.             break;
  557.          case COL_TIME:
  558.             {
  559.               TCHAR szDate[32];
  560.               TCHAR szTime[32];
  561.               ::GetDateFormat( LOCALE_USER_DEFAULT, DATE_SHORTDATE, &pData->ftTime, NULL, szDate, lengthof(szDate) );
  562.               ::GetTimeFormat( LOCALE_USER_DEFAULT, 0, &pData->ftTime, NULL, szTime, lengthof(szTime) );
  563.               ::wsprintf(szTemp, _T("%s %s"), szDate, szTime);
  564.               _tcsncpy(lpdi->item.pszText, szTemp, lpdi->item.cchTextMax);
  565.             };
  566.             break;
  567.          case COL_ATTRIBS:
  568.             {
  569.                // Construct attribute string
  570.                CAdfFile::ConvertAccess(pData->dwAccess, szTemp);
  571.                _tcsncpy(lpdi->item.pszText, szTemp, lpdi->item.cchTextMax);
  572.             };
  573.             break;
  574.          }
  575.       }
  576.    }
  577.    else {  
  578.       // The main item information is being requested
  579.       if( lpdi->item.mask & LVIF_TEXT ) {
  580.          STRRET str;
  581.          if(SUCCEEDED(m_pFolder->GetDisplayNameOf(pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &str))) {
  582.             switch( str.uType ) {
  583.             case STRRET_WSTR:
  584.                _tcsncpy(lpdi->item.pszText, OLE2CT(str.pOleStr), lpdi->item.cchTextMax);               
  585.                _Module.m_Allocator.Free(str.pOleStr); // Delete the string
  586.                break;
  587.             case STRRET_CSTR:
  588.                _tcsncpy(lpdi->item.pszText, A2CT(str.cStr), lpdi->item.cchTextMax);
  589.                break;
  590.             default:
  591.                ATLASSERT(false);
  592.             }
  593.          }
  594.       }
  595.       if( lpdi->item.mask & LVIF_IMAGE ) {
  596.          IExtractIcon *pEI;
  597.          if( SUCCEEDED(m_pFolder->GetUIObjectOf(m_hWnd, 
  598.                                                 1, 
  599.                                                 (LPCITEMIDLIST *)&pidl, 
  600.                                                 IID_IExtractIcon, 
  601.                                                 NULL, 
  602.                                                 (LPVOID*)&pEI)) ) 
  603.          {
  604.             // GetIconLoaction will give us the index into our image list
  605.             UINT uFlags;
  606.             pEI->GetIconLocation(GIL_FORSHELL, NULL, 0, &lpdi->item.iImage, &uFlags);
  607.             ATLASSERT(uFlags & GIL_NOTFILENAME);
  608.             pEI->Release();
  609.          }
  610.       }
  611.    }
  613.    return 0;
  614. }
  616. LRESULT CView::OnHeaderClick(UINT /*CtlID*/, LPNMHDR lpnmh, BOOL& /*bHandled*/)
  617. {
  618.    ATLTRACE(_T("CView::OnHeaderClickn"));
  619.    NMHEADER *pnmh = (NMHEADER *)lpnmh; 
  620.    // Handle left-click only 
  621.    if( pnmh->iButton==0 ) { 
  622.       // Sort the list by the column that was clicked 
  623.       ListView_SortItems(m_hwndList, _ListViewSortFunc, pnmh->iItem);
  624.    } 
  625.    return 0;
  626. }
  628. LRESULT CView::OnDeleteItem(UINT /*CtlID*/, LPNMHDR lpnmh, BOOL& /*bHandled*/)
  629. {
  630.    // Delete the pidl because we made a copy of it
  631.    NM_LISTVIEW *lpnmlv = (NM_LISTVIEW *)lpnmh;
  632.    CPidl::_Delete((LPITEMIDLIST)lpnmlv->lParam);
  633.    return 0;
  634. }
  636. // Bring up Context Menu.
  637. LRESULT CView::OnContextMenu(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
  638. {
  639.    ATLTRACE(_T("CView::OnContextMenun"));
  641.    CPidl pidl;
  642.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  643.    if( nCount==0 ) {
  644.       // Nothing selected? Use the View menu then (see code below).
  645.    }
  646.    else {
  647.       // We don't support merging of menus when more than one item
  648.       // is selected, so the menu for the first item is shown.
  649.       CPidlList pidls(m_hwndList);
  650.       pidl.Copy(pidls[0]);
  651.    }
  653.    UINT resMenu = 0;
  654.    if( pidl.IsEmpty() ) {
  655.       resMenu = IDM_POPUP_VIEW;
  656.    }
  657.    else {
  658.       LPCPIDLDATA pData = pidl_cast((LPCITEMIDLIST)pidl);
  659.       if( pData->dwEntryFlags & EF_DELETED ) {
  660.          resMenu = IDM_POPUP_DELETED;
  661.       }
  662.       else {
  663.          switch( pData->type ) {
  664.          case PT_FOLDER:
  665.             resMenu = IDM_POPUP_FOLDER;
  666.             break;
  667.          case PT_FILE:
  668.             resMenu = IDM_POPUP_FILE;
  669.             break;
  670.          default:
  671.             ATLASSERT(""=="Invalid menu type");
  672.          }
  673.       }
  674.    }
  676.    // Prepare menu
  677.    POINT pt = { LOWORD(lParam), HIWORD(lParam) };
  678.    if( lParam==-1 ) {
  679.       // Windows sends -1 as lParam when using SHIFT+F10 to activate context menu
  680.       RECT rc;
  681.       ListView_GetItemRect(m_hwndList, ListView_GetNextItem(m_hwndList, -1, LVNI_SELECTED), &rc, LVIR_ICON);
  682.       pt.x = rc.left + ((rc.right-rc.left)/2);
  683.       pt.y = rc.top + ((rc.bottom-rc.top)/2);
  684.       ::ClientToScreen(m_hwndList, &pt);
  685.    }
  686.    HMENU hMenu = ::LoadMenu(_Module.GetResourceInstance(), MAKEINTRESOURCE(resMenu));
  687.    ATLASSERT(::IsMenu(hMenu));
  688.    HMENU hSubMenu = ::GetSubMenu(hMenu,0);
  689.    // Let generic menu-updater handle popup too...
  690.    _UpdateMenu(hSubMenu);
  691.    // Show popup menu
  692.    ::SetMenuDefaultItem(hSubMenu, ID_FILE_OPEN, FALSE);
  693.    ::SetForegroundWindow(m_hWnd);
  694.    ::TrackPopupMenu(hSubMenu,
  695.                     TPM_LEFTALIGN|TPM_LEFTBUTTON,
  696.                     pt.x, pt.y,
  697.                     0,
  698.                     m_hWnd,
  699.                     NULL);
  700.    ::DestroyMenu(hMenu);
  701.    // Reset statusbar
  702.    OnItemChanged(0,NULL,bHandled);
  703.    return 0;
  704. }
  706. LRESULT CView::OnItemActivated(UINT /*CtlID*/, LPNMHDR /*lpnmh*/, BOOL& bHandled)
  707. {
  708.    ATLTRACE(_T("CView::OnItemActivatedn"));
  709.    return OnFileOpen(0,0,0,bHandled);
  710. }
  712. LRESULT CView::OnLabelEditBegin(UINT /*CtlID*/, LPNMHDR lpnmh, BOOL& /*bHandled*/)
  713. {
  714.    ATLTRACE(_T("CView::OnLabelEditBeginn"));
  715.    NMLVDISPINFO *lpdi = (NMLVDISPINFO*)lpnmh;
  716.    DWORD dwAttr = SFGAO_CANRENAME;
  717.    m_pFolder->GetAttributesOf(1, (LPCITEMIDLIST*)&lpdi->item.lParam, &dwAttr);
  718.    if( (dwAttr & SFGAO_CANRENAME)==0 ) return TRUE;
  719.    m_bInEdit = true;
  720.    return FALSE; // Allow edit!
  721. }
  723. LRESULT CView::OnLabelEditEnd(UINT /*CtlID*/, LPNMHDR lpnmh, BOOL& /*bHandled*/)
  724. {
  725.    ATLTRACE(_T("CView::OnLabelEditEndn"));
  726.    NMLVDISPINFO *lpdi = (NMLVDISPINFO*)lpnmh;
  727.    m_bInEdit = false;
  729.    if( lpdi->item.pszText==NULL ) return FALSE; // User cancelled editing
  731.    LVITEM lvItem = { 0 };
  732.    lvItem.mask = LVIF_PARAM;
  733.    lvItem.iItem = lpdi->item.iItem;
  734.    ListView_GetItem(m_hwndList, &lvItem);
  735.    LPITEMIDLIST pidlOldItem = (LPITEMIDLIST)lvItem.lParam;
  737.    // The IShellFolder handles the actual rename...
  738.    USES_CONVERSION;
  739.    LPCWSTR pwstr = T2CW(lpdi->item.pszText);
  740.    LPITEMIDLIST pidlNewItem = NULL;
  741.    HRESULT Hr = m_pFolder->SetNameOf(NULL, pidlOldItem, pwstr, 0, &pidlNewItem);
  742.    if( FAILED(Hr) || (pidlNewItem==NULL) ) {
  743.       ::MessageBeep(MB_ICONEXCLAMATION);
  744.       return FALSE;
  745.    }
  747.    // Set the new PIDL structure
  748.    lvItem.mask = LVIF_PARAM;
  749.    lvItem.lParam = (LPARAM)pidlNewItem;
  750.    ListView_SetItem(m_hwndList, &lvItem);
  752.    CPidl::_Delete(pidlOldItem);
  754.    return TRUE; // Accept rename
  755. }
  757. LRESULT CView::OnBeginDrag(UINT /*CtlID*/, LPNMHDR /*lpnmh*/, BOOL& /*bHandled*/)
  758. {
  759.    ATLTRACE(_T("CView::OnBeginDragn"));
  760.    _DoCopyOperation(true, false);
  761.    return TRUE;
  762. }
  764. LRESULT CView::OnItemChanged(UINT /*CtlID*/, LPNMHDR /*lpnmh*/, BOOL& /*bHandled*/)
  765. {
  766.    ATLTRACE(_T("CView::OnItemChangedn"));
  767.    ATLASSERT(m_pShellBrowser);
  769.    // Set the status bar text
  770.    TCHAR szText[64] = { 0 };
  771.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  772.    if( nCount>0 ) {
  773.       // Show "x object(s) selected" message
  774.       CResString<64> sFormat(IDS_OBJECTSELECTED);
  775.       ::wsprintf(szText, sFormat, nCount);
  776.    }
  777.    USES_CONVERSION;
  778.    m_pShellBrowser->SetStatusTextSB(T2CW(szText));
  780.    _UpdateToolbar();
  781.    return TRUE;
  782. }
  784. LRESULT CView::OnMenuSelect(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
  785. {
  786.    ATLTRACE(_T("CView::OnMenuSelectn"));
  787.    ATLASSERT(m_pShellBrowser);
  789.    WORD wFlags = HIWORD(wParam);
  790.    if( wFlags==0xFFFF && lParam==NULL ) {
  791.       bHandled = FALSE;
  792.       return 1; // Menu closing!
  793.    }
  794.    CResString<80> sText(LOWORD(wParam));
  795.    if( _tcslen(sText)==0 ) {
  796.       bHandled = FALSE;
  797.       return 1; // No text. Not processed!
  798.    }
  799.    LRESULT lResult;
  800.    m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, (255 | SBT_NOBORDERS), (LPARAM)(LPCTSTR)sText, &lResult);
  801.    return 0;
  802. }
  805. /////////////////////////////////////////////////////////////////////////////
  806. // Message Command Handlers
  808. LRESULT CView::OnNewFolder(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  809. {
  810.    // Create a new folder right away
  811.    CResString<MAXNAMELEN> sName(IDS_NEWFOLDER);
  812.    DWORD dwFileOpFlags = CFolder::FILEOP_UNIQUENAME;
  813.    if( FAILED( m_pFolder->_CreateFolder(sName, &dwFileOpFlags) ) ) return 0;
  815.    Refresh();
  817.    // Get new PIDL structure
  818.    LVFINDINFO fi = { 0 };
  819.    fi.flags = LVFI_STRING;
  820.    fi.psz = sName;
  821.    int iItem = ListView_FindItem(m_hwndList, -1, &fi);
  822.    ATLASSERT(iItem!=-1);
  823.    LVITEM lvItem = { 0 };
  824.    lvItem.mask = LVIF_PARAM;
  825.    lvItem.iItem = iItem;
  826.    ListView_GetItem(m_hwndList, &lvItem);
  828.    // Notify Shell so it can create the folder in the Explorer tree
  829.    CPidl pidl;
  830.    pidl.Copy(m_pFolder->m_pidl);
  831.    pidl.Concatenate(m_pFolder->m_pidlPath);
  832.    pidl.Concatenate((LPCITEMIDLIST)lvItem.lParam);
  833.    ::SHChangeNotify(SHCNE_MKDIR, SHCNF_IDLIST | SHCNF_FLUSH, pidl, NULL);
  835.    // Put ListView item in edit mode...
  836.    ::SetFocus(m_hwndList);
  837.    ListView_EditLabel(m_hwndList, iItem);
  839.    return 0;
  840. }
  842. LRESULT CView::OnFileOpen(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  843. {
  844.    ATLASSERT(m_pShellBrowser);
  846.    CPidlList pidls(m_hwndList);
  847.    pidls.Filter(m_pFolder, SFGAO_BROWSABLE);
  848.    if( pidls.GetCount()==0 ) return 0;
  850.    CPidl pidl;
  851.    pidl.Copy( m_pFolder->m_pidl );
  852.    pidl.Concatenate( m_pFolder->m_pidlPath );
  853.    pidl.Concatenate( pidls[0] );
  854.    m_pShellBrowser->BrowseObject(pidl, SBSP_DEFBROWSER | SBSP_ABSOLUTE);
  855.    return 0;
  856. }
  858. LRESULT CView::OnFileRename(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  859. {
  860.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  861.    if( nCount!=1 ) return 0;
  862.    // Put the ListView into edit mode
  863.    ::SetFocus(m_hwndList);
  864.    int nItem;
  865.    if( (nItem = ListView_GetNextItem(m_hwndList, -1, LVNI_SELECTED)) != -1 ) {
  866.       ListView_EditLabel(m_hwndList, nItem);
  867.    }
  868.    return 0;
  869. }
  871. LRESULT CView::OnFileUndelete(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  872. {
  873.    CPidlList pidls(m_hwndList);
  874.    pidls.Filter(m_pFolder, SFGAO_GHOSTED);
  875.    if( pidls.GetCount()==0 ) return 0;
  876.    m_pFolder->_UnDeleteFiles(pidls, pidls.GetCount());
  877.    Refresh();
  878.    return 0;
  879. }
  881. LRESULT CView::OnGoUp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  882. {
  883.    ATLASSERT(m_pShellBrowser);
  884.    m_pShellBrowser->BrowseObject(NULL, SBSP_SAMEBROWSER | SBSP_PARENT);
  885.    return 0;
  886. }
  888. LRESULT CView::OnViewDeletedFiles(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  889. {
  890.    m_bShowDeletedFiles = !m_bShowDeletedFiles;
  891.    Refresh();
  892.    return 0;
  893. }
  895. LRESULT CView::OnViewChange(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  896. {
  897.    int dwListStyle = LVS_REPORT;
  898.    int dwViewMode = FVM_DETAILS;
  899.    switch( wID ) {
  900.    case ID_VIEW_REPORT:
  901.       dwListStyle = LVS_REPORT;
  902.       dwViewMode = FVM_DETAILS;
  903.       break;
  904.    case ID_VIEW_LARGEICONS:
  905.       dwListStyle = LVS_ICON;
  906.       dwViewMode = FVM_ICON;
  907.       break;
  908.    case ID_VIEW_SMALLICONS:
  909.       dwListStyle = LVS_SMALLICON;
  910.       dwViewMode = FVM_SMALLICON;
  911.       break;
  912.    case ID_VIEW_LIST:
  913.       dwListStyle = LVS_LIST;
  914.       dwViewMode = FVM_LIST;
  915.       break;
  916.    }
  917.    // Change the FolderSettings and change ListView control
  918.    m_FolderSettings.ViewMode = dwViewMode;
  919.    DWORD dwStyle = ::GetWindowLong(m_hwndList, GWL_STYLE);
  920.    dwStyle &= ~LVS_TYPEMASK;
  921.    dwStyle |= dwListStyle;
  922.    ::SetWindowLong(m_hwndList, GWL_STYLE, dwStyle);
  923.    // Need to update toolbar as well
  924.    _UpdateToolbar();
  926.    return 0;
  927. }
  929. LRESULT CView::OnShowHelp(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  930. {
  931.    TCHAR szFileName[MAX_PATH];
  932.    ::GetModuleFileName(_Module.GetModuleInstance(), szFileName, lengthof(szFileName));
  933.    ::PathRemoveExtension(szFileName);
  934.    ::PathAddExtension(szFileName, _T(".hlp"));
  935.    ::WinHelp(m_hWnd, szFileName, HELP_CONTENTS, 0);
  936.    return 0;
  937. }
  939. LRESULT CView::OnRefresh(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  940. {
  941.    Refresh();
  942.    return 0;
  943. }
  945. LRESULT CView::OnFileProperties(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  946. {
  947.    UINT nCount = ListView_GetSelectedCount(m_hwndList);
  948.    if( nCount==0 ) {
  949.       // Show the View's Properties
  950.       if( m_pFolder->m_pidlPath.IsEmpty() ) {
  951.          // Show properties for root!
  952.          // We basically bring up the standard Property Pages for the ADF file.
  953.          SHELLEXECUTEINFO sei = { 0 };
  954.          sei.cbSize = sizeof(sei);
  955.          sei.hwnd = m_hWnd;
  956.          sei.fMask = SEE_MASK_IDLIST | SEE_MASK_INVOKEIDLIST;
  957.          sei.lpIDList = m_pFolder->m_pidl;
  958.          sei.lpVerb = _T("properties");
  959.          sei.nShow = SW_SHOWNORMAL;
  960.          ::ShellExecuteEx(&sei);
  961.       }
  962.       else {
  963.          // Show properties for active folder
  964.          CPropertiesDlg dlg;
  965.          if( SUCCEEDED(dlg._Init(m_pFolder, NULL)) ) {
  966.             if( dlg.DoModal()==IDOK ) {
  967.                Refresh();
  968.             }
  969.          }
  970.       }
  971.    }
  972.    else {
  973.       CPidlList pidls(m_hwndList);
  974.       pidls.Filter(m_pFolder, SFGAO_HASPROPSHEET);
  975.       if( pidls.GetCount()==0 ) return 0;
  977.       // Show the Folder/File Properties
  978.       switch( PidlGetType(pidls[0]) ) {
  979.       case PT_FOLDER:
  980.       case PT_FILE:
  981.          {
  982.             CPropertiesDlg dlg;
  983.             if( SUCCEEDED( dlg._Init(m_pFolder, pidls[0])) ) {;
  984.                if( dlg.DoModal()==IDOK ) {
  985.                   Refresh();
  986.                }
  987.             }
  988.          }
  989.          break;
  990.       default:
  991.          ATLASSERT(""=="Invalid property page request");
  992.       }
  993.    }
  994.    return 0;
  995. }
  997. LRESULT CView::OnFileDelete(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  998. {
  999.    ATLASSERT(m_pFolder);
  1001.    CPidlList pidls(m_hwndList);
  1002.    pidls.Filter(m_pFolder, SFGAO_CANDELETE);
  1003.    if( pidls.GetCount()==0 ) return 0;
  1005.    // Complex task of putting up a confirmation dialog...
  1006.    if( m_ShellFlags.fNoConfirmRecycle==0 ) {
  1007.       DWORD dwFlags = 0;
  1008.       if( m_pFolder->_ConfirmDelete(pidls, pidls.GetCount(), &dwFlags)==IDNO ) return 0;
  1009.    }
  1010.    m_pFolder->_DeleteFiles(pidls, pidls.GetCount());
  1012.    Refresh();
  1013.    ::SetFocus(m_hwndList);
  1015.    return 0;
  1016. }
  1018. LRESULT CView::OnCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1019. {
  1020.    _DoCopyOperation(false,false);
  1021.    return 0;
  1022. }
  1024. LRESULT CView::OnCut(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1025. {
  1026.    _DoCopyOperation(false,true);
  1027.    return 0;
  1028. }
  1030. LRESULT CView::OnPaste(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1031. {
  1032.    CComPtr<IDataObject> spDataObject;    
  1033.    if( SUCCEEDED( ::OleGetClipboard(&spDataObject) ) ) {     
  1034.       
  1035.       // We attempt to do an "non-optimized move".
  1036.       // The formal communication when doing the paste, is to let the
  1037.       // IDataObject know about the success of the paste operation.
  1038.       // MSDN explains the procedures...
  1039.       FORMATETC fe = { _Module.m_CFSTR_PREFERREDDROPEFFECT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  1040.       STGMEDIUM med;
  1041.       HRESULT HrHadData = spDataObject->GetData(&fe, &med);
  1042.       if( SUCCEEDED(HrHadData) ) {
  1043.          fe.cfFormat = _Module.m_CFSTR_PERFORMEDDROPEFFECT;
  1044.          spDataObject->SetData(&fe,&med,FALSE);
  1045.       }
  1047.       // Handle drop
  1048.       HRESULT Hr;
  1049.       Hr = m_pFolder->_DoDrop(spDataObject, DROPEFFECT_COPY);
  1051.       // Tell the IDataObject if we succeeded
  1052.       if( Hr==S_OK ) {
  1053.          // We ask the IDataObject to delete the items (if we're moving files)
  1054.          if( SUCCEEDED(HrHadData) ) {
  1055.             fe.cfFormat = _Module.m_CFSTR_PASTESUCCEEDED;
  1056.             spDataObject->SetData(&fe,&med,FALSE);
  1057.          }
  1058.       }
  1059.       else if( Hr==S_FALSE ) {
  1060.          // Do something! Anything!
  1061.       }
  1062.       else {         
  1063.          ::MessageBeep(MB_ICONEXCLAMATION);
  1064.       }
  1066.       if( SUCCEEDED(HrHadData) ) ::ReleaseStgMedium(&med);
  1067.       Refresh();
  1068.    }
  1069.    return 0;
  1070. }
  1072. LRESULT CView::OnSelectAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1073. {
  1074.    ::SetFocus(m_hwndList);
  1075.    ListView_SetItemState(m_hwndList, -1, LVIS_SELECTED, LVIS_SELECTED);
  1076.    return 0;
  1077. }
  1079. LRESULT CView::OnInvertSelection(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
  1080. {
  1081.    ::SetFocus(m_hwndList);
  1082.    int nItem = -1;
  1083.    while( (nItem = ListView_GetNextItem(m_hwndList, nItem, LVNI_ALL)) != -1 ) {
  1084.       UINT state = ListView_GetItemState(m_hwndList, nItem, LVIS_SELECTED);
  1085.       ListView_SetItemState(m_hwndList, nItem, (state ^ LVIS_SELECTED), LVIS_SELECTED);
  1086.    }
  1087.    return 0;
  1088. }