public virtual void PostNewItem(uint dwFlags, 
     IShellItem psiDestinationFolder, string pszNewName,
     string pszTemplateName, uint dwFileAttributes, 
     uint hrNew, IShellItem psiNewItem)
 {
     TraceAction("PostNewItem", psiNewItem, hrNew);
 }

        private static string GetParsingName(IShellItem shellItem)
        {
            if (shellItem == null)
                return null;

            string path = null;

            IntPtr pszPath = IntPtr.Zero;
            int hr = shellItem.GetDisplayName(Shell32.SIGDN.SIGDN_DESKTOPABSOLUTEPARSING, out pszPath);

            if (false ==
                    (hr == HRESULT.S_OK ||
                     hr == HRESULT.E_INVALIDARG))
                throw new COMException("GetParsingName", (int)hr);

            if (pszPath != IntPtr.Zero)
            {
                path = Marshal.PtrToStringAuto(pszPath);
                Marshal.FreeCoTaskMem(pszPath);
                pszPath = IntPtr.Zero;
            }

            return path;

        }

        private static void TraceAction(string action, IShellItem item, uint hresult)
        {

            //TraceAction(action, 
            //   item != null ?  Marshal.PtrToStringUni(item.GetDisplayName(WindowsAPI.SIGDN.NORMALDISPLAY)) : null, 
            //   hresult);
        }

 public virtual void PostCopyItem(
     uint dwFlags, IShellItem psiItem,
     IShellItem psiDestinationFolder, string pszNewName,
     uint hrCopy, IShellItem psiNewlyCreated)
 {
     TraceAction("PostCopyItem", psiNewlyCreated, hrCopy);
 }

 public void PostMoveItem(
     uint dwFlags, IShellItem psiItem, 
     IShellItem psiDestinationFolder,
     string pszNewName, uint hrMove, 
     IShellItem psiNewlyCreated)
 {
     TraceAction("PostMoveItem", psiNewlyCreated, hrMove);
 }

 private static IShellItem GetShellItemFromFolder(IShellItem shellItem, IShellFolder shellFolder)
 {
     if (shellItem == null && shellFolder == null)
         throw new ArgumentNullException("shellItem, shellFolder", "shellItem and shellFolder cannot both be null");
     if (shellItem != null)
         return shellItem;
     IdList pidl = SHGetIDListFromObject(shellFolder);
     return SHCreateItemFromIDList<IShellItem>(pidl);
 }

 internal ShellFolder(IShellItem shellItem, IShellFolder shellFolder, ShellItemKnownInfo knownInfo)
     : base(GetShellItemFromFolder(shellItem, shellFolder), knownInfo)
 {
     if (shellFolder == null)
     {
         shellFolder = (IShellFolder)shellItem.BindToHandler(null, ShellConsts.BHID_SFObject, typeof(IShellFolder).GUID);
     }
     NativeFolder = shellFolder;
 }

        internal static IntPtr PidlFromShellItem(IShellItem nativeShellItem)
        {
            IntPtr shellItem = Marshal.GetComInterfaceForObject(nativeShellItem, typeof(IShellItem));
            IntPtr pidl;

            int retCode = ShellNativeMethods.SHGetIDListFromObject(shellItem, out pidl);

            return (CoreErrorHelper.Succeeded(retCode) ? pidl : IntPtr.Zero);
        }

		public HResult GetItemAt(uint dwIndex, out IShellItem ppsi) {
			int index = (int)dwIndex;

			if (index < shellItemsList.Count) {
				ppsi = shellItemsList[index];
				return HResult.Ok;
			} else {
				ppsi = null;
				return HResult.Fail;
			}
		}

		public HResult GetParent(out IShellItem ppsi) {
			IntPtr pidl = Shell32.ILClone(Pidl);
			if (Shell32.ILRemoveLastID(pidl)) {
				ppsi = new ShellItemImpl(pidl, true);
				return HResult.S_OK;
			}
			else {
				ppsi = null;
				return HResult.MK_E_NOOBJECT;
			}
		}

        public HRESULT GetItemAt(uint dwIndex, out IShellItem ppsi)
        {
            int index = (int)dwIndex;

            if (index < shellItemsList.Count)
            {
                ppsi = shellItemsList[index];
                return HRESULT.S_OK;
            }
            else
            {
                ppsi = null;
                return HRESULT.E_FAIL;
            }
        }

		void IShellItemArray.GetItemAt(uint dwIndex, out IShellItem ppsi)
		{
			int index = (int)dwIndex;

			if (index < shellItemsList.Count)
			{
				ppsi = shellItemsList[index];
				//return HResult.S_OK;
			}
			else
			{
				ppsi = null;
				//return HResult.S_FALSE;
			}
		}

		public override void PostDeleteItem(TRANSFER_SOURCE_FLAGS dwFlags, IShellItem psiItem, uint hrDelete, IShellItem psiNewlyCreated) {
			//base.PostDeleteItem(dwFlags,psiItem,hrDelete,psiNewlyCreated);
			//if (hrDelete == 2555912) {
			//	var theNewItem = FileSystemListItem.InitializeWithIShellItem(this._View.LVHandle, psiItem);
			//  if (this._View.CurrentFolder.Equals(theNewItem.Parent)) {
			//    Shell32.SHChangeNotify(
			//      theNewItem.IsFolder ? Shell32.HChangeNotifyEventID.SHCNE_RMDIR : Shell32.HChangeNotifyEventID.SHCNE_DELETE,
			//      Shell32.HChangeNotifyFlags.SHCNF_IDLIST | Shell32.HChangeNotifyFlags.SHCNF_FLUSH, theNewItem.PIDL, IntPtr.Zero);
			//  }
			//  theNewItem.Dispose();
			//}
			//if (psiItem != null) {
			//  Marshal.FinalReleaseComObject(psiItem);
			//}

			//  if (psiNewlyCreated != null) {
			//    Marshal.FinalReleaseComObject(psiNewlyCreated);
			//  }
			//Shell32.SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
		}

		internal static string GetParsingName(IShellItem shellItem) {
			if (shellItem == null) { return null; }

			string path = null;

			IntPtr pszPath = IntPtr.Zero;
			HResult hr = shellItem.GetDisplayName(ShellNativeMethods.ShellItemDesignNameOptions.DesktopAbsoluteParsing, out pszPath);

			if (hr != HResult.Ok && hr != HResult.InvalidArguments) {
				throw new ShellException(LocalizedMessages.ShellHelperGetParsingNameFailed, hr);
			}

			if (pszPath != IntPtr.Zero) {
				path = Marshal.PtrToStringAuto(pszPath);
				Marshal.FreeCoTaskMem(pszPath);
				pszPath = IntPtr.Zero;
			}

			return path;

		}

		public override void PostCopyItem(TRANSFER_SOURCE_FLAGS dwFlags, IShellItem psiItem, IShellItem psiDestinationFolder, string pszNewName, uint hrCopy, IShellItem psiNewlyCreated) {
			//if (hrCopy == 0) {
			//     var destination = FileSystemListItem.InitializeWithIShellItem(this._View.LVHandle, psiDestinationFolder);
			//  if (destination.Equals(this._View.CurrentFolder)) {
			//    var theNewItem = FileSystemListItem.InitializeWithIShellItem(this._View.LVHandle, psiNewlyCreated);
			//    Shell32.SHChangeNotify(
			//      theNewItem.IsFolder ? Shell32.HChangeNotifyEventID.SHCNE_MKDIR : Shell32.HChangeNotifyEventID.SHCNE_CREATE,
			//      Shell32.HChangeNotifyFlags.SHCNF_IDLIST | Shell32.HChangeNotifyFlags.SHCNF_FLUSH, theNewItem.PIDL, IntPtr.Zero);
			//    this._View.LargeImageList.SupressThumbnailGeneration(false);
			//    Shell32.SHChangeNotify(Shell32.HChangeNotifyEventID.SHCNE_UPDATEITEM,
			//      Shell32.HChangeNotifyFlags.SHCNF_IDLIST | Shell32.HChangeNotifyFlags.SHCNF_FLUSH, theNewItem.PIDL, IntPtr.Zero);
			//    theNewItem.Dispose();
			//  }
			//     destination.Dispose();
			//}
			//if (psiItem != null) {
			//  Marshal.FinalReleaseComObject(psiItem);
			//}

			//if (psiNewlyCreated != null) {
			//  Marshal.FinalReleaseComObject(psiNewlyCreated);
			//}
			//Shell32.SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1);
		}

 public void OnOverwrite(IFileDialog pfd, IShellItem psi, out NativeMethods.RESPONSE pResponse)
 {
     pResponse = NativeMethods.RESPONSE.ACCEPT;
 }

 public void OnShareViolation(IFileDialog pfd, IShellItem psi, out NativeMethods.RESPONSE pResponse)
 {
     // Do nothing: we will ignore share violations, and don't register
     // for them, so this method should never be called
     pResponse = NativeMethods.RESPONSE.ACCEPT;
 }

 public HRESULT OnFolderChanging(IFileDialog pfd, IShellItem psiFolder)
 {
     return HRESULT.S_OK;
 }

 internal string GetFileNameFromShellItem(IShellItem item)
 {
     string filename;
     item.GetDisplayName(NativeMethods.SIGDN.DESKTOPABSOLUTEPARSING, out filename);
     return filename;
 }

 public static string GetPathFromShellItem(IShellItem item)
 {
     return item.GetDisplayName(SIGDN.DESKTOPABSOLUTEPARSING);
 }