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

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

Shell编程

开发平台：

Visual C++

atlshellext.h：源码内容
  1. //
  2. // Written by Bjarke Viksoe (bjarke@viksoe.dk)
  3. // Copyright (c) 2001 Bjarke Viksoe.
  4. //
  5. // This code may be used in compiled form in any way you desire. This
  6. // file may be redistributed by any means PROVIDING it is 
  7. // not sold for profit without the authors written consent, and 
  8. // providing that this notice and the authors name is included. 
  9. //
  10. // This file is provided "as is" with no expressed or implied warranty.
  11. // The author accepts no liability if it causes any damage to you or your
  12. // computer whatsoever. It's free, so don't hassle me about it.
  13. //
  14. // Beware of bugs.
  16. #ifndef __ATLSHELLEXT_H__
  17. #define __ATLSHELLEXT_H__
  19. #pragma once
  21. #ifndef __ATLSHELLEXTBASE_H__
  22.    #error atlshellext.h requires atlshellbase.h to be included first
  23. #endif
  25. #include <atlwin.h>
  26. #include <prsht.h>
  27. #include "resource.h"
  30. //////////////////////////////////////////////////////////////////////////////
  31. // CPidl
  33. class CPidl
  34. {
  35. public:
  36.    LPITEMIDLIST m_pidl;
  38. public:
  39.    CPidl() : m_pidl(NULL)
  40.    {
  41.    }
  43.    virtual ~CPidl()
  44.    {
  45.       Delete();
  46.    }
  48.    BOOL IsEmpty()
  49.    {
  50.       return _IsEmpty(m_pidl);
  51.    }
  53.    operator LPITEMIDLIST() const
  54.    {
  55.       return m_pidl;
  56.    }
  58.    LPITEMIDLIST* operator&()
  59.    {
  60.       ATLASSERT(m_pidl==NULL);
  61.       return &m_pidl;
  62.    }
  64.    void Attach(LPITEMIDLIST pSrc)
  65.    {
  66.       Delete();
  67.       m_pidl = pSrc;
  68.    }
  70.    LPITEMIDLIST Detach()
  71.    {
  72.       LPITEMIDLIST pidl = m_pidl;
  73.       m_pidl = NULL;
  74.       return pidl;
  75.    }
  77.    DWORD GetByteSize() 
  78.    { 
  79.       return _GetByteSize(m_pidl);
  80.    }
  82.    UINT GetCount()
  83.    { 
  84.       return _GetCount(m_pidl);
  85.    }
  87.    LPCITEMIDLIST GetNextItem()
  88.    { 
  89.       return _GetNextItem(m_pidl);
  90.    }
  92.    LPCITEMIDLIST GetLastItem()
  93.    { 
  94.       return _GetLastItem(m_pidl);
  95.    }
  97.    LPITEMIDLIST CopyFirstItem()
  98.    { 
  99.       return _CopyFirstItem(m_pidl);
  100.    }
  101.   
  102.    LPITEMIDLIST Copy()
  103.    { 
  104.       return _Copy(m_pidl);
  105.    }
  107.    void Delete()
  108.    { 
  109.       _Delete(m_pidl);
  110.       m_pidl = NULL;
  111.    }
  113.    void Copy(LPCITEMIDLIST pidlSource) 
  114.    { 
  115.       Delete();
  116.       m_pidl = _Copy(pidlSource);
  117.    }  
  119.    void Concatenate(LPCITEMIDLIST pidl2)
  120.    {
  121.       if( (m_pidl==NULL) && (pidl2==NULL) ) return;
  122.       if( m_pidl==NULL ) {
  123.          m_pidl = _Copy(pidl2);
  124.          return;
  125.       }
  126.       if( pidl2==NULL ) return;
  128.       DWORD cb1, cb2;
  129.       cb1 = GetByteSize() - sizeof(ITEMIDLIST);
  130.       cb2 = _GetByteSize(pidl2);
  131.       LPITEMIDLIST pidlNew = (LPITEMIDLIST)_Module.m_Allocator.Alloc(cb1 + cb2);
  132.       if( pidlNew!=NULL ) {
  133.          ::CopyMemory( pidlNew, m_pidl, cb1 );
  134.          ::CopyMemory( ((LPBYTE)pidlNew) + cb1, pidl2, cb2 );
  135.       }
  136.       Attach(pidlNew);
  137.    }
  139.    void RemoveLast()
  140.    {
  141.       LPITEMIDLIST pidlLast = const_cast<LPITEMIDLIST>(_GetLastItem(m_pidl));
  142.       if( pidlLast!=NULL ) pidlLast->mkid.cb = 0;
  143.    }
  145.    inline static BOOL _IsEmpty(LPCITEMIDLIST pidl)
  146.    {
  147.       return pidl==NULL || pidl->mkid.cb==0;
  148.    }
  150.    static LPCITEMIDLIST _GetLastItem(LPCITEMIDLIST pidl) 
  151.    { 
  152.       // Get the PIDL of the last item in the list 
  153.       LPCITEMIDLIST pidlLast = NULL;  
  154.       if( pidl!=NULL ) {    
  155.          while( pidl->mkid.cb > 0 ) { 
  156.             pidlLast = pidl;
  157.             pidl = _GetNextItem(pidl);       
  158.          }      
  159.       }  
  160.       return pidlLast; 
  161.    } 
  163.    inline static LPITEMIDLIST _GetNextItem(LPCITEMIDLIST pidl) 
  164.    { 
  165.       return pidl==NULL ? NULL : (LPITEMIDLIST)(LPBYTE)(((LPBYTE)pidl) + pidl->mkid.cb);
  166.    }  
  168.    static UINT _GetCount(LPCITEMIDLIST pidlSource)
  169.    {
  170.       UINT cbTotal = 0; 
  171.       if( pidlSource!=NULL ) {    
  172.          while( pidlSource->mkid.cb > 0 ) {
  173.             cbTotal++;
  174.             pidlSource = _GetNextItem(pidlSource); 
  175.          }       
  176.       }  
  177.       return cbTotal; 
  178.    }
  180.    static DWORD _GetByteSize(LPCITEMIDLIST pidlSource)
  181.    { 
  182.       DWORD cbTotal = 0; 
  183.       if( pidlSource!=NULL ) {
  184.          while( pidlSource->mkid.cb > 0 ) {
  185.             cbTotal += pidlSource->mkid.cb;       
  186.             pidlSource = _GetNextItem(pidlSource);       
  187.          }       
  188.          // Add the size of the NULL terminating ITEMIDLIST    
  189.          cbTotal += sizeof(ITEMIDLIST);    
  190.       }  
  191.       return cbTotal; 
  192.    }
  194.    static void _Delete(LPITEMIDLIST pidlSource)
  195.    {
  196.       if( pidlSource==NULL ) return;
  197.       _Module.m_Allocator.Free( pidlSource ); 
  198.    }
  200.    static LPITEMIDLIST _Copy(LPCITEMIDLIST pidlSource) 
  201.    { 
  202.       LPITEMIDLIST pidlTarget = NULL; 
  203.       DWORD cbSource = 0;  
  204.       if( NULL==pidlSource ) return NULL;  
  205.       // Allocate the new pidl 
  206.       cbSource = _GetByteSize(pidlSource); 
  207.       pidlTarget = (LPITEMIDLIST)_Module.m_Allocator.Alloc(cbSource); 
  208.       if( pidlTarget==NULL ) return NULL;  // Copy the source to the target 
  209.       ::CopyMemory( pidlTarget, pidlSource, cbSource );
  210.       return pidlTarget; 
  211.    }
  213.    static LPITEMIDLIST _CopyFirstItem(LPCITEMIDLIST pidlSource) 
  214.    { 
  215.       LPITEMIDLIST pidlTarget = NULL; 
  216.       DWORD cbSource = 0;  
  217.       if( NULL==pidlSource ) return NULL;  
  218.       // Allocate the new pidl 
  219.       cbSource = pidlSource->mkid.cb + sizeof(ITEMIDLIST); 
  220.       pidlTarget = (LPITEMIDLIST)_Module.m_Allocator.Alloc(cbSource); 
  221.       if( pidlTarget==NULL ) return NULL;  // Copy the source to the target 
  222.       ::CopyMemory( pidlTarget, pidlSource, cbSource );
  223.       // Terminate the IDList 
  224.       *(WORD *)(((LPBYTE)pidlTarget)+pidlTarget->mkid.cb) = 0;  
  225.       return pidlTarget;
  226.    }
  228. };
  231. /////////////////////////////////////////////////////////////////////////////
  232. // CPidlList
  234. class CPidlList
  235. {
  236. public:
  237.    CPidlList()
  238.    {
  239.       m_pidls = NULL;
  240.       m_nCount = 0;
  241.       m_bOwner = false;
  242.    }
  243.    
  244.    CPidlList(HWND hwndList, DWORD dwListViewMask=LVNI_SELECTED)
  245.    {
  246.       ATLASSERT(::IsWindow(hwndList));
  248.       m_pidls = NULL;
  249.       m_nCount = 0;
  251.       UINT nCount = ( dwListViewMask==LVNI_SELECTED ? ListView_GetSelectedCount(hwndList) : ListView_GetItemCount(hwndList) );
  252.       if( nCount==0 ) return;
  254.       LPITEMIDLIST *pidls = (LPITEMIDLIST *)_Module.m_Allocator.Alloc(nCount * sizeof(LPITEMIDLIST));   
  255.       if( pidls==NULL ) return;
  256.    
  257.       int nItem = -1;
  258.       UINT i = 0;
  259.       while( (nItem = ListView_GetNextItem(hwndList, nItem, dwListViewMask))!=-1 )
  260.       {
  261.          LVITEM lvi = { 0 };
  262.          lvi.mask = LVIF_PARAM;
  263.          lvi.iItem = nItem;
  264.          ListView_GetItem(hwndList, &lvi);
  265.          pidls[i++] = (LPITEMIDLIST)lvi.lParam;
  266.       }
  268.       m_pidls = pidls;
  269.       m_nCount = i;
  270.       m_bOwner = false;
  271.    }
  272.    
  273.    virtual ~CPidlList()
  274.    {
  275.       Delete();
  276.    }
  278.    operator LPCITEMIDLIST *() const 
  279.    { 
  280.       return const_cast<LPCITEMIDLIST *>(m_pidls); 
  281.    }
  283.    UINT GetCount() const 
  284.    { 
  285.       return m_nCount; 
  286.    }
  288.    LPITEMIDLIST *Detach()
  289.    {
  290.       LPITEMIDLIST *pidls = m_pidls;
  291.       m_pidls = NULL;
  292.       m_nCount = 0;
  293.       m_bOwner = false;
  294.       return pidls;
  295.    }
  296.    
  297.    HRESULT Attach(LPITEMIDLIST *pidlSource, UINT nCount, BOOL bOwnItems=FALSE)
  298.    {
  299.       Delete();
  300.       m_pidls = pidlSource;
  301.       m_nCount = nCount;
  302.       m_bOwner = (bOwnItems==TRUE);
  303.       return S_OK;
  304.    }
  305.    
  306.    HRESULT Copy(LPCITEMIDLIST *pidlSource, UINT nCount, BOOL bOwnItems=FALSE)
  307.    {
  308.       ATLASSERT(pidlSource);
  309.       ATLASSERT(nCount>0);
  310.       if( (pidlSource==NULL) || (nCount==0) ) return E_INVALIDARG;
  311.       Delete();
  312.       m_pidls = (LPITEMIDLIST *)_Module.m_Allocator.Alloc(nCount * sizeof(LPITEMIDLIST));
  313.       if( m_pidls==NULL ) return E_OUTOFMEMORY;
  314.       m_nCount = nCount;
  315.       // If requested, we'll make a copy of each PIDL structure too, otherwise
  316.       // simply copy memory (weak reference).
  317.       if( bOwnItems ) {
  318.          for( UINT i=0; i<nCount; i++ ) m_pidls[i] = CPidl::_Copy(pidlSource[i]);
  319.          m_bOwner = true;
  320.       }
  321.       else {
  322.          ::CopyMemory(m_pidls, pidlSource, nCount * sizeof(LPITEMIDLIST));
  323.          m_bOwner = false;
  324.       }
  325.       return S_OK;
  326.    }
  327.    
  328.    void Delete()
  329.    {
  330.       if( m_pidls!=NULL ) {
  331.          if( m_bOwner ) for( UINT i=0; i<m_nCount; i++ ) _Module.m_Allocator.Free((LPVOID)m_pidls[i]);
  332.          _Module.m_Allocator.Free(m_pidls);
  333.          m_pidls = NULL;
  334.          m_nCount = 0;
  335.          m_bOwner = false;
  336.       }
  337.    }
  339.    HRESULT Filter(IShellFolder *pFolder, DWORD dwItemMask)
  340.    {
  341.       ATLASSERT(pFolder);
  342.       ATLASSERT(dwItemMask!=0);
  343.       ATLASSERT(!m_bOwner);
  344.       if( m_nCount==0 ) return S_OK;
  346.       LPITEMIDLIST *pidls = (LPITEMIDLIST *)_Module.m_Allocator.Alloc(m_nCount * sizeof(LPITEMIDLIST));
  347.       if( pidls==NULL ) return E_OUTOFMEMORY;
  349.       UINT nCount=0;
  350.       for( UINT i=0; i<m_nCount; i++ ) {
  351.          DWORD dwAttr = dwItemMask;
  352.          LPCITEMIDLIST pidl = m_pidls[i];
  353.          pFolder->GetAttributesOf(1, &pidl, &dwAttr);
  354.          if( (dwAttr & dwItemMask)==dwItemMask ) {
  355.             pidls[nCount] = m_pidls[i];
  356.             nCount++;
  357.          }
  358.       }
  359.       // We've recreated a new PIDL list.
  360.       // The allocated memory for the list may actually be too large, but
  361.       // it doesn't matter for the PIDL functions.
  362.       return Attach(pidls, nCount, FALSE);
  363.    }
  365.    LPITEMIDLIST *m_pidls;
  366.    UINT m_nCount;
  367.    bool m_bOwner;
  368. };
  371. #ifdef __ATLCOM_H__
  373. /////////////////////////////////////////////////////////////////////////////
  374. // CPidlEnum
  376. class ATL_NO_VTABLE CPidlEnum : 
  377.    public CComObjectRootEx<CComSingleThreadModel>,
  378.    public IEnumIDList
  379. {
  380. public:
  381.    HRESULT FinalConstruct()
  382.    {
  383.       m_iCount = 0;
  384.       m_iPos = 0;
  385.       return S_OK;
  386.    }
  388. DECLARE_NO_REGISTRY()
  389. DECLARE_NOT_AGGREGATABLE(CPidlEnum)
  390. DECLARE_PROTECT_FINAL_CONSTRUCT()
  392. BEGIN_COM_MAP(CPidlEnum)
  393.    COM_INTERFACE_ENTRY_IID(IID_IEnumIDList,IEnumIDList)
  394. END_COM_MAP()
  396. public:
  397.    HRESULT _Init(LPCITEMIDLIST pPidlArray, UINT nCount)
  398.    {      
  399.       m_pidl.Copy(pPidlArray);
  400.       m_iCount = nCount;
  401.       Reset();
  402.       return S_OK;
  403.    }
  405.    STDMETHOD(Next)(ULONG /*celt*/, LPITEMIDLIST *rgelt, ULONG *pceltFetched)
  406.    { 
  407.       ATLTRACE2(atlTraceCOM, 0, _T("IEnumIDList::Nextn"));
  408.       *rgelt = NULL; 
  409.       if( pceltFetched ) *pceltFetched = 0;
  411.       if( m_pidl.IsEmpty() ) return S_FALSE;
  413.       m_iPos++;
  414.       if( m_iPos > m_iCount ) return S_FALSE;
  416.       *rgelt = CPidl::_CopyFirstItem(m_pCur);
  417.       m_pCur = CPidl::_GetNextItem(m_pCur);
  418.       if( (*rgelt!=NULL)  && ((*rgelt)->mkid.cb!=0) ) { 
  419.           if( pceltFetched!=NULL ) *pceltFetched = 1; 
  420.           return S_OK; 
  421.       }
  423.       return E_OUTOFMEMORY; 
  424.    }   
  426.    STDMETHOD(Reset)(void)
  427.    { 
  428.       ATLTRACE2(atlTraceCOM, 0, _T("IEnumIDList::Resetn"));
  429.       m_iPos = 0;
  430.       m_pCur = m_pidl;
  431.       return S_OK; 
  432.    }
  434.    STDMETHOD(Skip)(ULONG /*celt*/)
  435.    {
  436.       ATLTRACENOTIMPL(_T("IEnumIDList::Skip"));
  437.    }
  439.    STDMETHOD(Clone)(IEnumIDList ** /*ppEnum*/)
  440.    {
  441.       ATLTRACENOTIMPL(_T("IEnumIDList::Clone"));
  442.    }
  444. public:
  445.    CPidl m_pidl;
  446.    LPCITEMIDLIST m_pCur;
  447.    UINT m_iCount; 
  448.    UINT m_iPos;
  449. };
  452. //////////////////////////////////////////////////////////////////////////////
  453. // IShellFolderImpl
  455. #define GET_SHGDN_FOR(dwFlags)         ((DWORD)dwFlags & (DWORD)0x0000FF00)
  456. #define GET_SHGDN_RELATION(dwFlags)    ((DWORD)dwFlags & (DWORD)0x000000FF)
  458. template <class T, typename DataStruct>
  459. class ATL_NO_VTABLE IShellFolderImpl : 
  460.    public IShellFolder,
  461.    public IPersistFolder,
  462.    public CPidl
  463. {
  464. public:
  466.    // IPersistFolder
  468.    STDMETHOD(GetClassID)(CLSID *pClassID)
  469.    {
  470.       ATLTRACE2(atlTraceCOM, 0, _T("IPersistFolder::GetClassIDn"));
  471.       ATLASSERT(pClassID);
  472.       if( pClassID==NULL ) return E_POINTER;
  473.       *pClassID = T::GetObjectCLSID();
  474.       return S_OK;
  475.    }
  476.   
  477.    STDMETHOD(Initialize)(LPCITEMIDLIST pList)
  478.    {
  479.       ATLTRACE2(atlTraceCOM, 0, _T("IPersistFolder::Initializen"));
  480.       ATLASSERT(pList);
  481.       if( pList==NULL ) return E_INVALIDARG;
  482.       Copy(pList);
  483.       return S_OK;
  484.    }
  486.    // IShellFolder
  488.    STDMETHOD(EnumObjects)(HWND, DWORD, LPENUMIDLIST *ppRetVal)
  489.    {
  490.       ATLTRACE2(atlTraceCOM, 0, _T("IShellFolder::EnumObjectsn"));
  491.       ATLASSERT(ppRetVal);
  492.       // Return empty collection
  493.       DataStruct v[1];
  494.       v[0].cb = 0;
  495.       HRESULT Hr;
  496.       CComObject<CPidlEnum> *pEnum;
  497.       Hr = CComObject<CPidlEnum>::CreateInstance(&pEnum);
  498.       if( FAILED(Hr) ) return Hr;
  499.       Hr = pEnum->_Init((LPITEMIDLIST)v, 1);
  500.       if( FAILED(Hr) ) return Hr;
  501.       Hr = pEnum->QueryInterface(IID_IEnumIDList,(LPVOID *)ppRetVal);
  502.       if( FAILED(Hr) ) return Hr;
  503.       return S_OK;
  504.    }
  506.    STDMETHOD(BindToObject)(LPCITEMIDLIST /*pidl*/, LPBC, REFIID /*riid*/, LPVOID *ppRetVal)
  507.    {
  508.       // Subfolders not implemented
  509.       *ppRetVal = NULL;
  510.       ATLTRACENOTIMPL(_T("IShellFolder::BindToObject"));
  511.    }
  513.    STDMETHOD(BindToStorage)(LPCITEMIDLIST, LPBC, REFIID, LPVOID *ppRetVal)
  514.    {
  515.       *ppRetVal = NULL;
  516.       ATLTRACENOTIMPL(_T("IShellFolder::BindToStorage"));
  517.    }
  519.    STDMETHOD(CreateViewObject)(HWND /*hwndOwner*/, REFIID riid, LPVOID *ppRetVal )
  520.    {
  521.       ATLTRACE2(atlTraceCOM, 0, _T("IShellFolder::CreateViewObjectn"));
  522.       ATLASSERT(::IsBadReadPtr(&riid,sizeof(IID))==FALSE);
  523.       if( riid != IID_IShellView ) return E_NOINTERFACE;
  524.       T *pT = static_cast<T*>(this);
  525.       return pT->_CreateShellFolderView(ppRetVal);
  526.    }
  528.    STDMETHOD(GetUIObjectOf)(HWND, UINT, LPCITEMIDLIST*, REFIID, LPUINT, LPVOID*)
  529.    {
  530.       ATLTRACE2(atlTraceCOM, 0, _T("IShellFolder::GetUIObjectOfn"));
  531.       return E_NOINTERFACE;
  532.    }
  534.    STDMETHOD(GetDisplayNameOf)(LPCITEMIDLIST, DWORD, LPSTRRET)
  535.    {
  536.       ATLTRACENOTIMPL(_T("IShellFolder::GetDisplayNameOf"));
  537.    }
  539.    STDMETHOD(GetAttributesOf)(UINT, LPCITEMIDLIST*, LPDWORD rgfInOut)
  540.    {
  541.       ATLTRACE2(atlTraceCOM, 0, _T("IShellFolder::GetAttributesOfn"));      
  542.       *rgfInOut = 0;
  543.       return S_OK;
  544.    }
  546.    STDMETHOD(ParseDisplayName)(HWND, LPBC, LPOLESTR, LPDWORD, LPITEMIDLIST*, LPDWORD /*ppRetVal*/)
  547.    {
  548.       ATLTRACENOTIMPL(_T("IShellFolder::ParseDisplayName"));
  549.    }
  551.    STDMETHOD(SetNameOf)(HWND, LPCITEMIDLIST, LPCOLESTR, DWORD, LPITEMIDLIST*)
  552.    {
  553.       ATLTRACENOTIMPL(_T("IShellFolder::SetNameOf"));
  554.    }
  556.    STDMETHOD(CompareIDs)(LPARAM, LPCITEMIDLIST, LPCITEMIDLIST)
  557.    {
  558.       ATLTRACENOTIMPL(_T("IShellFolder::CompareIDs"));
  559.    }
  561.    HRESULT _CreateShellFolderView(LPVOID *ppvObj)
  562.    {
  563.       ATLTRACENOTIMPL(_T("IShellFolder::_CreateShellFolderView"));
  564.    }
  566. };
  569. //////////////////////////////////////////////////////////////////////////////
  570. // IShellViewImpl
  572. template <class T>
  573. class ATL_NO_VTABLE IShellViewImpl : 
  574.    public IShellView2
  575. {
  576. public:
  577.    enum { IDC_LISTVIEW = 123 };
  579.    BEGIN_MSG_MAP(IShellViewImpl<T>)
  580.       MESSAGE_HANDLER(WM_CREATE, OnCreate)
  581.       MESSAGE_HANDLER(WM_SETFOCUS, OnSetFocus)
  582.       MESSAGE_HANDLER(WM_KILLFOCUS, OnKillFocus)
  583.       MESSAGE_HANDLER(WM_SIZE, OnSize)
  584.       MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
  585.       MESSAGE_HANDLER(WM_INITMENUPOPUP, OnInitMenu)
  586.       MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBackground)
  587.       NOTIFY_CODE_HANDLER(NM_SETFOCUS, OnNotifySetFocus)
  588.       NOTIFY_CODE_HANDLER(NM_KILLFOCUS, OnNotifyKillFocus)
  589.    END_MSG_MAP()
  591.    IShellViewImpl() :
  592.       m_pShellBrowser(NULL), m_uState(SVUIA_DEACTIVATE), m_hWnd(NULL), m_hwndList(NULL)
  593.    {
  594.       ZeroMemory(&m_ShellFlags,sizeof(m_ShellFlags));
  595.       m_dwListViewStyle = WS_TABSTOP | 
  596.                           WS_VISIBLE |
  597.                           WS_CHILD | 
  598.                           WS_BORDER | 
  599.                           LVS_REPORT | 
  600.                           LVS_NOSORTHEADER |
  601.                           LVS_SHAREIMAGELISTS;
  602.    }
  604. public:
  605.    const MSG *m_pCurrentMsg;
  606.    HWND m_hWnd;
  607.    HWND m_hwndList;
  608.    DWORD m_dwListViewStyle;
  609.    //
  610.    FOLDERSETTINGS m_FolderSettings;
  611.    SHELLFLAGSTATE m_ShellFlags;
  612.    LPSHELLBROWSER m_pShellBrowser;
  613.    UINT m_uState;
  615. public:
  616.    // IOleWindow
  617.    
  618.    STDMETHOD(GetWindow)(HWND *phWnd)
  619.    {
  620.       ATLTRACE2(atlTraceCOM, 0, _T("IOleWindow::GetWindown"));
  621.       ATLASSERT(phWnd);
  622.       ATLASSERT(::IsWindow(m_hWnd));
  623.       *phWnd = m_hWnd;
  624.       return S_OK;
  625.    }
  627.    STDMETHOD(ContextSensitiveHelp)(BOOL)
  628.    {
  629.       ATLTRACENOTIMPL(_T("IOleWindow::ContextSesitiveHelp"));
  630.    }
  632.    // IShellView
  634.    STDMETHOD(TranslateAccelerator)(LPMSG /*lpmsg*/)
  635.    {
  636.       return E_NOTIMPL;
  637.    }
  639.    STDMETHOD(Refresh)(void)
  640.    {
  641.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::Refreshn"));
  642.       ATLASSERT(::IsWindow(m_hwndList));
  643.       // Empty the list
  644.       ListView_DeleteAllItems(m_hwndList);
  645.       // Refill the list
  646.       T *pT = static_cast<T*>(this);
  647.       pT->_FillListView();
  648.       return S_OK;
  649.    }
  651.    STDMETHOD(AddPropertySheetPages)(
  652.       DWORD /*dwReserved*/,
  653.       LPFNADDPROPSHEETPAGE /*lpfn*/, 
  654.       LPARAM /*lParam*/)
  655.    {
  656.       ATLTRACENOTIMPL(_T("IShellView::AddPropertySheetPages"));
  657.    }
  659.    STDMETHOD(SelectItem)(LPCITEMIDLIST /*pidlItem*/, UINT /*uFlags*/)
  660.    {
  661.       ATLTRACENOTIMPL(_T("IShellView::SelectItem"));
  662.    }
  664.    STDMETHOD(GetItemObject)(UINT /*uItem*/, REFIID /*riid*/, LPVOID * ppRetVal)
  665.    {
  666.       ATLASSERT(ppRetVal);
  667.       ppRetVal;
  668.       ATLTRACENOTIMPL(_T("IShellView::GetItemObject"));
  669.    }
  671.    STDMETHOD(EnableModeless)(BOOL /*fEnable*/)
  672.    {
  673.       ATLTRACENOTIMPL(_T("IShellView::EnableModeless"));
  674.    }
  676.    STDMETHOD(GetCurrentInfo)(LPFOLDERSETTINGS lpFS)
  677.    {
  678.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::GetCurrentInfon"));
  679.       ATLASSERT(lpFS);
  680.       *lpFS = m_FolderSettings;
  681.       return S_OK;
  682.    }
  684.    STDMETHOD(UIActivate)(UINT uState)
  685.    {
  686.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::UIActivate (%d)n"), uState);
  687.       ATLASSERT(m_pShellBrowser);
  688.       // Only do this if we are active
  689.       if( m_uState==uState ) return S_OK;      
  690.       // _ViewActivate() handles merging of menus etc
  691.       T *pT = static_cast<T*>(this);
  692.       if( SVUIA_ACTIVATE_FOCUS==uState ) ::SetFocus(m_hwndList);
  693.       pT->_ViewActivate(uState);
  694.       if( uState != SVUIA_DEACTIVATE) {
  695.          // Update the status bar: set 'parts' and change text
  696.          LRESULT lResult;
  697.          int nPartArray[1] = { -1 };
  698.          m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETPARTS, 1, (LPARAM)nPartArray, &lResult);
  699.          // Set the statusbar text to the default description.
  700.          // The string resource IDS_DESCRIPTION must be defined!
  701.          TCHAR szName[128];
  702.          ::LoadString(_Module.GetResourceInstance(), IDS_DESCRIPTION, szName, sizeof(szName)/sizeof(TCHAR));
  703.          m_pShellBrowser->SendControlMsg(FCW_STATUS, SB_SETTEXT, 0, (LPARAM)szName, &lResult);
  704.       }
  705.       return S_OK;
  706.    }
  708.    STDMETHOD(CreateViewWindow)(
  709.       IShellView * /*lpPrevView*/,
  710.       LPCFOLDERSETTINGS pFS, 
  711.       IShellBrowser *pSB,
  712.       RECT *prcView, 
  713.       HWND *phWnd)
  714.    {
  715.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::CreateViewWindown"));
  716.       ATLASSERT(prcView);
  717.       ATLASSERT(pSB);
  718.       ATLASSERT(pFS);
  719.       ATLASSERT(phWnd);
  721.       // Register the ClassName.
  722.       // The ClassName comes from the string resource IDS_CLASSNAME!
  723.       TCHAR szClassName[64];
  724.       ::LoadString(_Module.GetResourceInstance(), IDS_CLASSNAME, szClassName, sizeof(szClassName)/sizeof(TCHAR));
  725.       WNDCLASS wc = { 0 };
  726.       *phWnd = NULL;
  727.       // If our window class has not been registered, then do so
  728.       if( !::GetClassInfo(_Module.GetModuleInstance(), szClassName, &wc) ) {
  729.          wc.style          = 0;
  730.          wc.lpfnWndProc    = (WNDPROC)WndProc;
  731.          wc.cbClsExtra     = 0;
  732.          wc.cbWndExtra     = 0;
  733.          wc.hInstance      = _Module.GetModuleInstance();
  734.          wc.hIcon          = NULL;
  735.          wc.hCursor        = ::LoadCursor(NULL, IDC_ARROW);
  736.          wc.hbrBackground  = (HBRUSH)(COLOR_WINDOW + 1);
  737.          wc.lpszMenuName   = NULL;
  738.          wc.lpszClassName  = szClassName; 
  739.          if( !::RegisterClass(&wc) ) return E_FAIL;
  740.       }
  742.       // Set up the member variables
  743.       m_pShellBrowser = pSB;
  744.       m_FolderSettings = *pFS;
  745.       m_ShellFlags.fWin95Classic = TRUE;
  746.       m_ShellFlags.fShowAllObjects = TRUE;
  747.       m_ShellFlags.fShowAttribCol = TRUE;
  749.       // Get our parent window
  750.       HWND hwndShell;
  751.       m_pShellBrowser->GetWindow(&hwndShell);
  752.       // Create host window
  753.       T *pT = static_cast<T*>(this);
  754.       *phWnd = ::CreateWindowEx(WS_EX_CONTROLPARENT,
  755.                                 szClassName,
  756.                                 NULL,
  757.                                 WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_TABSTOP,
  758.                                 prcView->left,
  759.                                 prcView->top,
  760.                                 prcView->right - prcView->left,
  761.                                 prcView->bottom - prcView->top,
  762.                                 hwndShell,
  763.                                 NULL,
  764.                                 _Module.GetModuleInstance(),
  765.                                 (LPVOID)pT);
  766.       if(!*phWnd) return E_FAIL;
  768.       pT->_MergeToolbar(SVUIA_ACTIVATE_FOCUS);
  770.       m_pShellBrowser->AddRef();
  771.       return S_OK;
  772.    }
  774.    STDMETHOD(DestroyViewWindow)(void)
  775.    {
  776.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::DestroyViewWindown"));
  777.       ATLASSERT(m_pShellBrowser);
  779.       // Make absolutely sure all our UI is cleaned up.
  780.       UIActivate(SVUIA_DEACTIVATE);
  782.       ::DestroyWindow(m_hWnd);
  784.       // Release the shell browser object
  785.       m_pShellBrowser->Release();
  786.       return S_OK;
  787.    }
  789.    STDMETHOD(SaveViewState)(void)
  790.    {
  791.       return S_OK;
  792.    }
  794.    // IShellView2
  796.    STDMETHOD(CreateViewWindow2)(LPSV2CVW2_PARAMS lpParams) 
  797.    {
  798.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::CreateViewWindow2n"));
  799.       return CreateViewWindow(lpParams->psvPrev, lpParams->pfs, lpParams->psbOwner, lpParams->prcView, &lpParams->hwndView);
  800.    }
  801.    
  802.    STDMETHOD(GetView)(SHELLVIEWID * /*pvid*/, ULONG /*uView*/) 
  803.    {
  804.       ATLTRACENOTIMPL(_T("IShellView2::GetView"));
  805.    }
  806.    
  807.    STDMETHOD(HandleRename)(LPCITEMIDLIST /*pidlNew*/) 
  808.    {
  809.       ATLTRACENOTIMPL(_T("IShellView2::HandleRename"));
  810.    }
  811.    
  812.    STDMETHOD(SelectAndPositionItem)(LPCITEMIDLIST /*pidlItem*/, UINT /*uFlags*/, POINT * /*point*/) 
  813.    {
  814.       ATLTRACENOTIMPL(_T("IShellView2::SelectAndPositionItem"));
  815.    }
  817.    // View handlers
  819.    LRESULT _ViewActivate(UINT uState)
  820.    {
  821.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::_ViewActivate %dn"), uState);
  822.       // Don't do anything if the state isn't really changing
  823.       if( m_uState==uState ) return S_OK;
  824.       T *pT = static_cast<T*>(this);
  825.       pT->_ViewDeactivate();
  826.       // Only do this if we are active
  827.       if( uState!=SVUIA_DEACTIVATE ) {
  828.          pT->_MergeMenus(uState);
  829.          pT->_UpdateToolbar();
  830.       }
  831.       m_uState = uState;
  832.       return 0;
  833.    }
  835.    LRESULT _ViewDeactivate(void)
  836.    {
  837.       ATLTRACE2(atlTraceCOM, 0, _T("IShellView::_ViewDeactivaten"));
  838.       //if( m_uState != SVUIA_DEACTIVATE ) {
  839.          T *pT = static_cast<T*>(this);
  840.          m_uState = SVUIA_DEACTIVATE;
  841.          pT->_MergeMenus(m_uState);
  842.          pT->_MergeToolbar(m_uState);
  843.       //}
  844.       return 0;
  845.    }
  847.    // Since ::SHGetSettings() is not implemented in all versions of the shell, get the 
  848.    // function address manually at run time. This allows the extension to run on all 
  849.    // platforms.
  850.    void _GetShellSettings(SHELLFLAGSTATE &sfs, DWORD dwMask)
  851.    {
  852.       typedef void (WINAPI *PFNSHGETSETTINGSPROC)(LPSHELLFLAGSTATE lpsfs, DWORD dwMask);
  853.       HINSTANCE hinstShell32;
  854.       hinstShell32 = ::LoadLibrary(TEXT("shell32.dll"));
  855.       if( hinstShell32!=NULL ){
  856.          PFNSHGETSETTINGSPROC pfnSHGetSettings = (PFNSHGETSETTINGSPROC) ::GetProcAddress(hinstShell32, "SHGetSettings");
  857.          if(pfnSHGetSettings) (*pfnSHGetSettings)(&sfs, dwMask);
  858.          ::FreeLibrary(hinstShell32);
  859.       }
  860.    }
  862.    // A helper function which will take care of some of
  863.    // the fancy new Win98 settings...
  864.    void _UpdateShellSettings(void)
  865.    {
  866.       // Update the m_ShellFlags state
  867.       _GetShellSettings(m_ShellFlags, 
  868.          SSF_DESKTOPHTML | 
  869.          SSF_NOCONFIRMRECYCLE | 
  870.          SSF_SHOWALLOBJECTS | 
  871.          SSF_SHOWATTRIBCOL | 
  872.          SSF_DOUBLECLICKINWEBVIEW | 
  873.          SSF_SHOWCOMPCOLOR |
  874.          SSF_WIN95CLASSIC);
  875.       
  876.       // Update the ListView control accordingly
  877.       DWORD dwExStyles = 0;
  878.       if( !m_ShellFlags.fWin95Classic && !m_ShellFlags.fDoubleClickInWebView ) {
  879.          dwExStyles |= LVS_EX_ONECLICKACTIVATE | 
  880.                        LVS_EX_TRACKSELECT | 
  881.                        LVS_EX_UNDERLINEHOT;
  882.       }
  883.       ListView_SetExtendedListViewStyle(m_hwndList, dwExStyles);
  884.    }
  886.    LRESULT DefWindowProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
  887.    {
  888. #ifdef STRICT
  889.       return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
  890. #else
  891.       return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
  892. #endif
  893.    }
  895.    static LRESULT CALLBACK WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
  896.    {
  897.       T *pT = (T*)::GetWindowLong(hWnd, GWL_USERDATA);
  898.       if(uMessage == WM_NCCREATE) {
  899.          LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
  900.          pT = (T*)(lpcs->lpCreateParams);
  901.          ::SetWindowLong(hWnd, GWL_USERDATA, (LONG)pT);
  902.          // Set the window handle
  903.          pT->m_hWnd = hWnd;
  904.          return 1;
  905.       }
  906.       ATLASSERT(pT);
  907.       MSG msg = { pT->m_hWnd, uMessage, wParam, lParam, 0, { 0, 0 } };
  908.       const MSG *pOldMsg = pT->m_pCurrentMsg;
  909.       pT->m_pCurrentMsg = &msg;
  910.       // pass to the message map to process
  911.       LRESULT lRes;
  912.       BOOL bRet = pT->ProcessWindowMessage(pT->m_hWnd, uMessage, wParam, lParam, lRes, 0);
  913.       // restore saved value for the current message
  914.       ATLASSERT(pT->m_pCurrentMsg == &msg);
  915.       pT->m_pCurrentMsg = pOldMsg;
  916.       if(!bRet) lRes = pT->DefWindowProc(uMessage, wParam, lParam);
  917.       return lRes;
  918.    }
  920.    // Message handlers
  922.    LRESULT OnSetFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  923.    {
  924.       ATLTRACE2(atlTraceWindowing, 0, _T("IShellView::OnSetFocusn"));
  925.       ::SetFocus(m_hwndList);
  926.       return 0;
  927.    }
  929.    LRESULT OnKillFocus(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  930.    {
  931.       ATLTRACE2(atlTraceWindowing, 0, _T("IShellView::OnKillFocusn"));
  932.       return 0;
  933.    }
  935.    LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  936.    {
  937.       T *pT = static_cast<T*>(this);
  938.       pT->_UpdateShellSettings();
  939.       return 0;
  940.    }
  942.    LRESULT OnNotifySetFocus(UINT /*CtlID*/, LPNMHDR /*lpnmh*/, BOOL &/*bHandled*/)
  943.    {
  944.       ATLTRACE2(atlTraceWindowing, 0, _T("IShellView::OnNotifySetFocusn"));
  945.       ATLASSERT(m_pShellBrowser);
  946.       // Tell the browser one of our windows has received the focus. This should always 
  947.       // be done before merging menus (_ViewActivate() merges the menus) if one of our 
  948.       // windows has the focus.
  949.       T *pT = static_cast<T*>(this);
  950.       m_pShellBrowser->OnViewWindowActive((IShellView *)pT);
  951.       pT->_ViewActivate(SVUIA_ACTIVATE_FOCUS);
  952.       return 0;
  953.    }
  955.    LRESULT OnNotifyKillFocus(UINT /*CtlID*/, LPNMHDR /*lpnmh*/, BOOL &/*bHandled*/)
  956.    {
  957.       ATLTRACE2(atlTraceWindowing, 0, _T("IShellView::OnNotifyKillFocusn"));
  958.       T *pT = static_cast<T*>(this);
  959.       pT->_ViewActivate(SVUIA_ACTIVATE_NOFOCUS);
  960.       return 0;
  961.    }
  963.    LRESULT OnInitMenu(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  964.    {
  965.       T *pT = static_cast<T*>(this);
  966.       pT->_UpdateMenu((HMENU)wParam);
  967.       return 0;
  968.    }
  970.    LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
  971.    {
  972.       // Resize the ListView to fit our window
  973.       if(m_hwndList) ::MoveWindow(m_hwndList, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
  974.       return 0;
  975.    }
  977.    LRESULT OnEraseBackground(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  978.    {
  979.       return 1; // avoid flicker
  980.    }
  982.    LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
  983.    {
  984.       // Create the ListView
  985.       T *pT = static_cast<T*>(this);
  986.       if( pT->_CreateListView() )
  987.          if( pT->_InitListView() )
  988.             pT->_FillListView();
  989.       return 0;
  990.    }
  992.    // Operations
  994.    typedef enum {
  995.       TBI_STD = 0,
  996.       TBI_VIEW,
  997.       TBI_LOCAL
  998.    } TOOLBARITEM;
  1000.    typedef struct
  1001.    {
  1002.       TOOLBARITEM nType;
  1003.       TBBUTTON tb;
  1004.    } NS_TOOLBUTTONINFO, *PNS_TOOLBUTTONINFO;
  1006.    BOOL _AppendToolbarItems(
  1007.       PNS_TOOLBUTTONINFO pButtons, 
  1008.       int nCount, 
  1009.       LPARAM lOffsetFile, 
  1010.       LPARAM lOffsetView, 
  1011.       LPARAM lOffsetCustom)
  1012.    {
  1013.       ATLASSERT(nCount>0);
  1014.       ATLASSERT(!::IsBadReadPtr(pButtons, nCount*sizeof(NS_TOOLBUTTONINFO)));
  1015.       ATLASSERT(m_pShellBrowser);
  1016.       LPTBBUTTON ptbb = (LPTBBUTTON)::GlobalAlloc(GPTR, sizeof(TBBUTTON)*nCount);
  1017.       if( ptbb==NULL ) return FALSE;
  1018.       for( int j=0; j<nCount; j++ ) {
  1019.          switch( pButtons[j].nType ) {
  1020.          case TBI_STD:
  1021.             (ptbb + j)->iBitmap = lOffsetFile + pButtons[j].tb.iBitmap;
  1022.             break;
  1023.          case TBI_VIEW:
  1024.             (ptbb + j)->iBitmap = lOffsetView + pButtons[j].tb.iBitmap;
  1025.             break;
  1026.          case TBI_LOCAL:
  1027.             (ptbb + j)->iBitmap = lOffsetCustom + pButtons[j].tb.iBitmap;
  1028.             break;
  1029.          }
  1030.          (ptbb + j)->idCommand = pButtons[j].tb.idCommand;
  1031.          (ptbb + j)->fsState = pButtons[j].tb.fsState;
  1032.          (ptbb + j)->fsStyle = pButtons[j].tb.fsStyle;
  1033.          (ptbb + j)->dwData = pButtons[j].tb.dwData;
  1034.          (ptbb + j)->iString = pButtons[j].tb.iString;
  1035.       }
  1036.       m_pShellBrowser->SetToolbarItems(ptbb, nCount, FCT_MERGE);
  1037.       ::GlobalFree((HGLOBAL)ptbb);
  1038.       return TRUE;
  1039.    }
  1041.    UINT _GetMenuPosFromID(HMENU hMenu, UINT ID) const
  1042.    {
  1043.       UINT nCount = ::GetMenuItemCount(hMenu);
  1044.       for( UINT i=0; i<nCount; i++ ) {
  1045.          if( ::GetMenuItemID(hMenu, i)==ID ) return i;
  1046.       }
  1047.       return (UINT)-1;
  1048.    }
  1050.    BOOL _AppendMenu(HMENU hMenu, HMENU hMenuSource, UINT nPosition)
  1051.    {
  1052.       ATLASSERT(::IsMenu(hMenu));
  1053.       ATLASSERT(::IsMenu(hMenuSource));
  1054.       // Get the HMENU of the popup
  1055.       if( hMenu==NULL ) return FALSE;
  1056.       if( hMenuSource==NULL ) return FALSE;
  1057.       // Make sure that we start with only one separator menu-item
  1058.       int iStartPos = 0;
  1059.       if( ::GetMenuState(hMenuSource, 0, MF_BYPOSITION) & MF_SEPARATOR ) {
  1060.          if( (nPosition==0) || 
  1061.              (::GetMenuState(hMenu, nPosition-1, MF_BYPOSITION) & MF_SEPARATOR) ) {
  1062.             iStartPos++;
  1063.          }
  1064.       }
  1065.       // Go...
  1066.       int nMenuItems = ::GetMenuItemCount(hMenuSource);
  1067.       for( int i=iStartPos; i<nMenuItems; i++ ) {
  1068.          // Get state information
  1069.          UINT state = ::GetMenuState(hMenuSource, i, MF_BYPOSITION);
  1070.          TCHAR szItemText[256];
  1071.          int nLen = ::GetMenuString(hMenuSource, i, szItemText, sizeof(szItemText)/sizeof(TCHAR), MF_BYPOSITION);
  1072.          // Is this a separator?
  1073.          if( state & MF_SEPARATOR ) {
  1074.             ::InsertMenu(hMenu, nPosition++, state | MF_STRING | MF_BYPOSITION, 0, _T(""));
  1075.          }
  1076.          else if( state & MF_POPUP ) {
  1077.             // Strip the HIBYTE because it contains a count of items
  1078.             state = LOBYTE(state) | MF_POPUP;
  1079.             // Then create the new submenu by using recursive call
  1080.             HMENU hSubMenu = ::CreateMenu();
  1081.             _AppendMenu(hSubMenu, ::GetSubMenu(hMenuSource, i), 0);
  1082.             ATLASSERT(::GetMenuItemCount(hSubMenu)>0);
  1083.             // Non-empty popup -- add it to the shared menu bar
  1084.             ::InsertMenu(hMenu, nPosition++, state | MF_BYPOSITION, (UINT)hSubMenu, szItemText);
  1085.          }
  1086.          else if( nLen>0 ) {
  1087.             // Only non-empty items should be added
  1088.             ATLASSERT(szItemText[0]!=_T(''));
  1089.             ATLASSERT(::GetMenuItemID(hMenuSource, i)>FCIDM_SHVIEWFIRST && ::GetMenuItemID(hMenuSource, i)<FCIDM_SHVIEWLAST);
  1090.             // Here the state does not contain a count in the HIBYTE
  1091.             ::InsertMenu(hMenu, nPosition++, state | MF_BYPOSITION, ::GetMenuItemID(hMenuSource, i), szItemText);
  1092.          }
  1093.       }
  1094.       return TRUE;
  1095.    }
  1097.    BOOL _IsExplorerMode() const
  1098.    {
  1099.       ATLASSERT(m_pShellBrowser);
  1100.       HWND hwndTree = NULL;
  1101.       return( SUCCEEDED(m_pShellBrowser->GetControlWindow(FCW_TREE, &hwndTree)) && hwndTree );
  1102.    }
  1104.    // Overridables
  1106.    BOOL _CreateListView(void)
  1107.    {
  1108.       // Initialize and create the actual List View control
  1109.       ATLASSERT((m_dwListViewStyle & (WS_VISIBLE|WS_CHILD))==(WS_VISIBLE|WS_CHILD));
  1110.       m_dwListViewStyle &= ~LVS_TYPEMASK;
  1111.       switch( m_FolderSettings.ViewMode ) {
  1112.       case FVM_ICON:
  1113.          m_dwListViewStyle |= LVS_ICON;
  1114.          break;
  1115.       case FVM_SMALLICON:
  1116.          m_dwListViewStyle |= LVS_SMALLICON;
  1117.          break;
  1118.       case FVM_LIST:
  1119.          m_dwListViewStyle |= LVS_LIST;
  1120.          break;
  1121.       case FVM_DETAILS:
  1122.          m_dwListViewStyle |= LVS_REPORT;
  1123.          break;
  1124.       }
  1125.       if( FWF_AUTOARRANGE & m_FolderSettings.fFlags ) m_dwListViewStyle |= LVS_AUTOARRANGE;
  1126. #if (_WIN32_IE >= 0x0500)
  1127.       if( FWF_SHOWSELALWAYS & m_FolderSettings.fFlags ) m_dwListViewStyle |= LVS_SHOWSELALWAYS;
  1128. #endif
  1129.       if( FWF_ALIGNLEFT & m_FolderSettings.fFlags ) m_dwListViewStyle |= LVS_ALIGNLEFT;
  1131.       // Go on,.. create ListView control
  1132.       m_hwndList = ::CreateWindowEx( FWF_NOCLIENTEDGE & m_FolderSettings.fFlags ? 0 : WS_EX_CLIENTEDGE,
  1133.                                      WC_LISTVIEW,
  1134.                                      NULL,
  1135.                                      m_dwListViewStyle,
  1136.                                      0,0,0,0,
  1137.                                      m_hWnd,
  1138.                                      (HMENU)IDC_LISTVIEW,
  1139.                                      _Module.GetModuleInstance(),
  1140.                                      NULL);
  1141.       if( m_hwndList==NULL ) return FALSE;
  1142.       T *pT = static_cast<T*>(this);
  1143.       pT->_UpdateShellSettings();
  1144.       return TRUE;
  1145.    }
  1146.    BOOL _InitListView(void) { return TRUE; };
  1147.    BOOL _FillListView(void) { return TRUE; };
  1148.    BOOL _MergeToolbar(UINT uState) { return TRUE; };
  1149.    BOOL _MergeMenus(UINT uState) { return TRUE; };
  1150.    BOOL _UpdateToolbar() { return TRUE; };
  1151.    BOOL _UpdateMenu(HMENU hMenu) { return TRUE; };
  1153. };
  1156. //////////////////////////////////////////////////////////////////////////////
  1157. // CShellPropertyPage
  1159. template <class T>
  1160. class ATL_NO_VTABLE CShellPropertyPage :
  1161.    public IShellPropSheetExt,
  1162.    public IShellExtInit,
  1163.    public CWindow
  1164. {
  1165. public:
  1166.    TCHAR m_szFileName[MAX_PATH];
  1167.    const MSG *m_pCurrentMsg;
  1169.    CShellPropertyPage()
  1170.    {
  1171.       m_szFileName[0]=_T('');
  1172.    }
  1174.    // IShellPropSheetExt
  1176.    STDMETHOD(AddPages)(LPFNADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
  1177.    {
  1178.       T* pT = static_cast<T*>(this);
  1179.       TCHAR szCaption[40];
  1180.       ::LoadString(_Module.GetResourceInstance(), T::IDS_TABCAPTION, szCaption, sizeof(szCaption)/sizeof(TCHAR));
  1181.       PROPSHEETPAGE psp = { 0 };
  1182.       psp.dwSize        = sizeof(psp);
  1183.       psp.dwFlags       = PSP_USETITLE | PSP_USECALLBACK;
  1184.       psp.hInstance     = _Module.GetResourceInstance();
  1185.       psp.pszTemplate   = MAKEINTRESOURCE(T::IDD);
  1186.       psp.hIcon         = 0;
  1187.       psp.pszTitle      = szCaption;
  1188.       psp.pfnDlgProc    = (DLGPROC)T::PageDlgProc;
  1189.       psp.pcRefParent   = NULL;
  1190.       psp.pfnCallback   = T::PropSheetPageProc;
  1191.       psp.lParam        = (LPARAM)pT;
  1193.       HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(&psp);            
  1194.       if( hPage==NULL ) return E_OUTOFMEMORY;
  1195.       if( pfnAddPage(hPage, lParam)==FALSE ) {
  1196.          ::DestroyPropertySheetPage(hPage);
  1197.          return E_FAIL;
  1198.       }
  1199.       pT->AddRef(); // This reference is release by the callback
  1201.       return MAKE_HRESULT(SEVERITY_SUCCESS, 0, T::ID_TAB_INDEX); // COMCTRL Ver 4.71 allows us to set the initial page index
  1202.    }
  1204.    STDMETHOD(ReplacePage)(UINT /*uPageID*/, LPFNADDPROPSHEETPAGE /*lpfnReplaceWith*/, LPARAM /*lParam*/) 
  1205.    {
  1206.       // The Shell doesn't call this for file class Property Sheets
  1207.       ATLTRACENOTIMPL(_T("IShellPropSheetExt::ReplacePage"));
  1208.    }
  1210.    // IShellExtInit
  1212.    STDMETHOD(Initialize)(LPCITEMIDLIST /*pidlFolder*/, IDataObject *lpDataObject, HKEY /*hkeyProgID*/) 
  1213.    {
  1214.       ATLASSERT(lpDataObject);
  1215.       STGMEDIUM medium;
  1216.       FORMATETC fe = {CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  1217.       if( SUCCEEDED(lpDataObject->GetData(&fe, &medium)) ) {
  1218.          // Get the file name from the CF_HDROP.
  1219.          UINT uCount = ::DragQueryFile((HDROP)medium.hGlobal, (UINT)-1, NULL, 0);
  1220.          if(uCount>0) ::DragQueryFile((HDROP)medium.hGlobal, 0, m_szFileName, sizeof(m_szFileName)/sizeof(TCHAR));
  1221.          ::ReleaseStgMedium(&medium);
  1222.       }
  1223.       return S_OK;
  1224.    }
  1226.    // Callbacks
  1228.    static UINT CALLBACK PropSheetPageProc(HWND /*hwnd*/, UINT uMsg, LPPROPSHEETPAGE ppsp)
  1229.    {
  1230.       switch( uMsg ) {
  1231.       case PSPCB_CREATE:
  1232.          return 1; // Allow dialog creation
  1233.       case PSPCB_RELEASE:
  1234.          T *pT = (T *)ppsp->lParam;
  1235.          ATLASSERT(pT);
  1236.          pT->Release();
  1237.          break;
  1238.       }
  1239.       return 0;
  1240.    }
  1242.    void SetModified(BOOL bChanged=TRUE)
  1243.    {
  1244.       ATLASSERT(::IsWindow(m_hWnd));
  1245.       ATLASSERT(GetParent()!=NULL);
  1246.       ::SendMessage(GetParent(), bChanged ? PSM_CHANGED : PSM_UNCHANGED, (WPARAM)m_hWnd, 0L);
  1247.    }
  1249.    static int CALLBACK PageDlgProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
  1250.    {    
  1251.       T *pT = (T *)::GetWindowLong(hWnd, GWL_USERDATA);
  1252.       LRESULT lRes = 0;
  1253.       if( uMessage==WM_INITDIALOG ) {
  1254.          pT = (T *)((LPPROPSHEETPAGE)lParam)->lParam;
  1255.          ::SetWindowLong(hWnd, GWL_USERDATA, (LONG)pT);
  1256.          // Set the window handle
  1257.          pT->m_hWnd = hWnd;
  1258.          lRes = 1;
  1259.       }
  1260.       if( pT==NULL ) {
  1261.          // The first message is WM_SETFONT, not WM_INITDIALOG...
  1262.          return FALSE;
  1263.       }
  1264.       MSG msg = { pT->m_hWnd, uMessage, wParam, lParam, 0, { 0, 0 } };
  1265.       const MSG *pOldMsg = pT->m_pCurrentMsg;
  1266.       pT->m_pCurrentMsg = &msg;
  1267.       // pass to the message map to process
  1268.       BOOL bRet = pT->ProcessWindowMessage(pT->m_hWnd, uMessage, wParam, lParam, lRes, 0);
  1269.       // restore saved value for the current message
  1270.       ATLASSERT(pT->m_pCurrentMsg == &msg);
  1271.       pT->m_pCurrentMsg = pOldMsg;
  1272.       // set result if message was handled
  1273.       if(bRet) {
  1274.          switch (uMessage) {
  1275.          case WM_COMPAREITEM:
  1276.          case WM_VKEYTOITEM:
  1277.          case WM_CHARTOITEM:
  1278.          case WM_INITDIALOG:
  1279.          case WM_QUERYDRAGICON:
  1280.          case WM_CTLCOLORMSGBOX:
  1281.          case WM_CTLCOLOREDIT:
  1282.          case WM_CTLCOLORLISTBOX:
  1283.          case WM_CTLCOLORBTN:
  1284.          case WM_CTLCOLORDLG:
  1285.          case WM_CTLCOLORSCROLLBAR:
  1286.          case WM_CTLCOLORSTATIC:
  1287.             return lRes;
  1288.          }
  1289.          ::SetWindowLong(pT->m_hWnd, DWL_MSGRESULT, lRes);
  1290.          return TRUE;
  1291.       }
  1292.       if( uMessage==WM_NCDESTROY ) {
  1293.          // clear out window handle
  1294.          pT->m_hWnd = NULL;
  1295.       }
  1296.       return FALSE;
  1297.    }
  1298. };
  1301. //////////////////////////////////////////////////////////////////////////////
  1302. // CExtractFileIcon
  1304. template< class T >
  1305. class ATL_NO_VTABLE CExtractFileIcon : 
  1306.    public CComObjectRootEx<CComSingleThreadModel>,
  1307.    public IExtractIcon
  1308. {
  1309. public:
  1311. DECLARE_NOT_AGGREGATABLE(CExtractFileIcon)
  1313. BEGIN_COM_MAP(CExtractFileIcon)
  1314.    COM_INTERFACE_ENTRY_IID(IID_IExtractIcon,IExtractIcon)
  1315. END_COM_MAP()
  1317. public:
  1318.    CPidl m_pidl;
  1320. public:
  1321.    void Init(LPCITEMIDLIST pidl)
  1322.    {
  1323.       m_pidl.Copy(pidl);
  1324.    }
  1326.    // IExtractIcon
  1328.    STDMETHOD(GetIconLocation)(UINT uFlags, 
  1329.                               LPTSTR /*szIconFile*/, 
  1330.                               UINT /*cchMax*/, 
  1331.                               LPINT piIndex, 
  1332.                               LPUINT puFlags)
  1333.    {
  1334.       ATLASSERT(piIndex);
  1335.       ATLASSERT(puFlags);
  1336.       if( m_pidl.IsEmpty() ) return E_FAIL;
  1337.       LPCITEMIDLIST pidlLast = CPidl::_GetLastItem(m_pidl);
  1338.       T *pData = (T *)pidlLast;
  1339.       if( pData!=NULL ) {
  1340.          switch( pData->type ) {
  1341.          case 0:
  1342.             *piIndex = 0;
  1343.             *puFlags = GIL_NOTFILENAME;
  1344.             break;
  1345.          case 1:
  1346.             *piIndex = 1;
  1347.             *puFlags = GIL_NOTFILENAME;
  1348.             break;
  1349.          default:
  1350.             *piIndex = 0;
  1351.             *puFlags = GIL_SIMULATEDOC;
  1352.             break;
  1353.          }
  1354.       }
  1355.       return S_OK;
  1356.    }
  1358.    STDMETHOD(Extract)(LPCTSTR pszFile, 
  1359.                       UINT nIconIndex, 
  1360.                       HICON *phiconLarge, 
  1361.                       HICON *phiconSmall, 
  1362.                       UINT nIconSize)
  1363.    {
  1364.       ATLASSERT(phiconLarge);
  1365.       ATLASSERT(phiconSmall);
  1366.       if( m_pidl.IsEmpty() ) return E_FAIL;
  1367.       LPCITEMIDLIST pidlLast = CPidl::_GetLastItem(m_pidl);
  1368.       T *pData = (T *)pidlLast;
  1369.       if( pData!=NULL ) {
  1370.          switch( pData->type ) {
  1371.          case 0:
  1372.             {
  1373.                *phiconLarge = ImageList_GetIcon(_Module.m_ImageLists.m_hImageListLarge, 0, ILD_TRANSPARENT);
  1374.                *phiconSmall = ImageList_GetIcon(_Module.m_ImageLists.m_hImageListSmall, 0, ILD_TRANSPARENT);
  1375.             }
  1376.             break;
  1377.          case 1:
  1378.             {
  1379.                *phiconLarge = ImageList_GetIcon(_Module.m_ImageLists.m_hImageListLarge, 1, ILD_TRANSPARENT);
  1380.                *phiconSmall = ImageList_GetIcon(_Module.m_ImageLists.m_hImageListSmall, 1, ILD_TRANSPARENT);
  1381.             }
  1382.             break;
  1383.          case 2:
  1384.             {
  1385.                TCHAR szPath[MAX_PATH];
  1386.                TCHAR szExt[MAX_PATH];
  1387.                _tcscpy( szPath, pData->ffd.cFileName );
  1388.                LPTSTR psz = _tcschr(szPath, _T('.'));
  1389.                szExt[0] = _T('');
  1390.                if( psz!=NULL ) _tcscpy(szExt, psz);
  1391.                SHFILEINFO sfi = { 0 };
  1392.                HIMAGELIST hImageListLarge = (HIMAGELIST) ::SHGetFileInfo(szExt, 
  1393.                                              FILE_ATTRIBUTE_NORMAL,
  1394.                                              &sfi, sizeof(sfi), 
  1395.                                              SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_SYSICONINDEX);
  1396.                if (hImageListLarge) *phiconLarge = ImageList_GetIcon(hImageListLarge, sfi.iIcon, ILD_TRANSPARENT);
  1397.                HIMAGELIST hImageListSmall = (HIMAGELIST) ::SHGetFileInfo(szExt, 
  1398.                                              FILE_ATTRIBUTE_NORMAL,
  1399.                                              &sfi, sizeof(sfi), 
  1400.                                              SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_SMALLICON|SHGFI_SYSICONINDEX);
  1401.                if (hImageListSmall) *phiconSmall = ImageList_GetIcon(hImageListSmall, sfi.iIcon, ILD_TRANSPARENT);
  1402.             }
  1403.             break;
  1404.          }
  1405.       }
  1406.       return S_OK;
  1407.    }
  1409. };
  1412. //////////////////////////////////////////////////////////////////////////////
  1413. // CContextMenuImpl
  1415. template <class T>
  1416. struct _ATL_CTXMENU_ENTRY
  1417. {
  1418.   UINT id;
  1419.   UINT desc;
  1420.   void (__stdcall T::*pfn)(); // method to invoke
  1421. };
  1423. #define BEGIN_CONTEXTMENU_MAP(theClass) 
  1424.    static const _ATL_CTXMENU_ENTRY<theClass>* _GetCtxMap()
  1425.    {
  1426.       typedef theClass _atl_event_classtype;
  1427.       static const _ATL_CTXMENU_ENTRY<_atl_event_classtype> _ctxmap[] = {
  1429. #define CONTEXTMENU_HANDLER(id, desc, func) 
  1430.     {id, desc, (void (__stdcall _atl_event_classtype::*)())func},
  1432. #define END_CONTEXTMENU_MAP() {0,0,NULL}}; return _ctxmap;}
  1435. template <class T>
  1436. class ATL_NO_VTABLE CShellContextMenu : 
  1437.    public IContextMenu,
  1438.    public IShellExtInit
  1439. {
  1440. public:
  1441.    CRegKey m_regClass;
  1442.    CSimpleArray<CComBSTR> m_arrFiles;
  1444. // IShellExtInit
  1445. public:
  1446.    STDMETHOD(Initialize)(LPCITEMIDLIST pidlFolder,
  1447.                          IDataObject *lpDataObj, 
  1448.                          HKEY hkeyProgID)
  1449.    {
  1450.       ATLTRACE(_T("CShellContextMenu::Initializen"));
  1451.       // Get file class
  1452.       m_regClass.Open(hkeyProgID,NULL);
  1453.       // Get files
  1454.       if( lpDataObj ) {
  1455.          CComPtr<IDataObject> spDataObj(lpDataObj);
  1456.          STGMEDIUM medium;
  1457.          FORMATETC fe = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  1458.          if( SUCCEEDED(spDataObj->GetData(&fe, &medium)) ) {
  1459.             // Get the filenames from the CF_HDROP.
  1460.             UINT uCount = ::DragQueryFile((HDROP)medium.hGlobal, (UINT)-1, NULL, 0);
  1461.             for( UINT i=0; i<uCount; i++ ) {
  1462.                TCHAR szFileName[MAX_PATH];    
  1463.                ::DragQueryFile((HDROP)medium.hGlobal, i, szFileName, sizeof(szFileName)/sizeof(TCHAR));
  1464.                m_arrFiles.Add(CComBSTR(szFileName));
  1465.             }
  1466.             ::ReleaseStgMedium(&medium);
  1467.          }
  1468.       }    
  1469.       return S_OK;
  1470.     }
  1472. // IContextMenu
  1473. public:
  1474.    STDMETHOD(QueryContextMenu)(HMENU hMenu,
  1475.                                UINT iIndexMenu,
  1476.                                UINT idCmdFirst,
  1477.                                UINT idCmdLast,
  1478.                                UINT uFlags)
  1479.    {
  1480.       ATLTRACE(_T("CShellContextMenu::QueryContextMenun"));
  1481.       const _ATL_CTXMENU_ENTRY<T>* pMap = T::_GetCtxMap();
  1482.       UINT i=0;
  1483.       while( pMap->pfn!=NULL ) {  
  1484.         if( pMap->id==0 ) {
  1485.           ::InsertMenu(hMenu, iIndexMenu++, MF_SEPARATOR | MF_STRING | MF_BYPOSITION, 0, _T(""));
  1486.         }
  1487.         else {
  1488.           TCHAR szText[128];
  1489.           ::LoadString(_Module.GetResourceInstance(), pMap->id, szText, sizeof(szText)/sizeof(TCHAR));
  1490.           ::InsertMenu(hMenu, iIndexMenu++, MF_STRING | MF_BYPOSITION, idCmdFirst + i, szText);
  1491.         }
  1492.         i++;
  1493.         pMap++;
  1494.       }
  1495.       T *pT = static_cast<T*>(this);
  1496.       pT->UpdateMenu(hMenu, idCmdFirst);
  1497.       return MAKE_HRESULT(SEVERITY_SUCCESS, 0, i + 1);
  1498.    }
  1500.    STDMETHOD(InvokeCommand)(LPCMINVOKECOMMANDINFO lpcmi)
  1501.    {
  1502.       ATLTRACE(_T("CShellContextMenu::InvokeCommandn"));
  1503.       if( HIWORD(lpcmi->lpVerb) ) return NOERROR; // The command is being sent via a verb
  1504.       UINT idxCmd = LOWORD(lpcmi->lpVerb);
  1505.       const _ATL_CTXMENU_ENTRY<T>* pMap = T::_GetCtxMap();
  1506.       UINT i=0;
  1507.       while( pMap->pfn!=NULL ) {
  1508.          if( i==idxCmd ) {
  1509.             T *pT = static_cast<T*>(this);
  1510.             CComStdCallThunk<T> thunk;
  1511.             thunk.Init(pMap->pfn, pT);
  1512.             VARIANT vRes;
  1513.             ::VariantInit(&vRes);
  1514.             return DispCallFunc(
  1515.                &thunk,
  1516.                0,
  1517.                CC_STDCALL,
  1518.                VT_EMPTY, // this is how DispCallFunc() represents void
  1519.                0,
  1520.                NULL,
  1521.                NULL,
  1522.                &vRes);
  1523.          }
  1524.          pMap++;
  1525.          i++;
  1526.       }
  1527.       return E_INVALIDARG;
  1528.    }
  1530.    STDMETHOD(GetCommandString)(UINT idCmd, UINT uFlags, LPUINT, LPSTR pszName, UINT cchMax)
  1531.    {
  1532.       ATLTRACE(_T("CContextMenu::GetCommandStringn"));
  1533.       switch( uFlags ) {
  1534.       case GCS_HELPTEXTA:
  1535.       case GCS_HELPTEXTW:
  1536.          {
  1537.             const _ATL_CTXMENU_ENTRY<T>* pMap = T::_GetCtxMap();
  1538.             UINT i=0;
  1539.             while( pMap->pfn!=NULL ) {
  1540.               if( i==idCmd ) {
  1541.                 if( uFlags==GCS_HELPTEXTA ) {
  1542.                    ::LoadStringA(_Module.GetResourceInstance(), pMap->desc, pszName, cchMax);
  1543.                 }
  1544.                 else {
  1545.                    // BUG: LoadStringW() is not supported on Win95
  1546.                    ::LoadStringW(_Module.GetResourceInstance(), pMap->desc, (LPWSTR)pszName, cchMax);
  1547.                 } 
  1548.                 return S_OK;
  1549.               }
  1550.               pMap++;
  1551.               i++;
  1552.             }
  1553.          }
  1554.          return E_FAIL;
  1555.       case GCS_VERBA:
  1556.       case GCS_VERBW:
  1557.          return E_FAIL;
  1558.       case GCS_VALIDATE:
  1559.          return NOERROR;
  1560.       default:
  1561.          return E_NOTIMPL;
  1562.       }
  1563.    }
  1565.    void UpdateMenu(HMENU hMenu, UINT iCmdFirst) { };
  1567. };
  1569. #endif // __ATLCOM_H__
  1572. //////////////////////////////////////////////////////////////////////////////
  1573. // ::SHGetPathFromIDList() wrapper
  1575. class CShellPidlPath
  1576. {
  1577. public:
  1578.    CShellPidlPath(LPCITEMIDLIST pidl)
  1579.    {
  1580.       ATLASSERT(pidl);     
  1581.       if( ::SHGetPathFromIDList(pidl, m_szPath)==FALSE ) m_szPath[0]=_T('');
  1582.    }
  1583.    operator LPCTSTR() const { return m_szPath; };
  1584.    TCHAR m_szPath[MAX_PATH];
  1585. };
  1588. //////////////////////////////////////////////////////////////////////////////
  1589. // Shell Helper Functions
  1591. inline LPITEMIDLIST ShellGetFileNamePidl(LPOLESTR pstrFileName)
  1592. {
  1593.    LPSHELLFOLDER pDesktopFolder;
  1594.    if( FAILED(::SHGetDesktopFolder(&pDesktopFolder)) ) return NULL;
  1595.    LPITEMIDLIST pidl;
  1596.    ULONG dwEaten;
  1597.    ULONG dwAttribs;
  1598.    if( FAILED( pDesktopFolder->ParseDisplayName(NULL, NULL, pstrFileName, &dwEaten, &pidl, &dwAttribs) ) ) {
  1599.       pidl = NULL;
  1600.    }
  1601.    pDesktopFolder->Release();
  1602.    return pidl; 
  1603. }
  1605. #endif // __ATLSHELLEXT_H__