Commit 36321f1f: - finally cleanup

- finally cleanup

36321f1f

Dimitar Tsenev

committed Oct 11, 2022

master

failed

Files

Details



	Shell1
	_Plugin Interfaces
	FileSystemListItem.cs
	IListItemEx.cs
	VirtualFilesystemItem.cs
	Custom ContextMenus Remove Soon
	FilterMenu_Strings.cs
	FileOperation
	AsyncUnbuffCopy.cs
	CollisionDialog.xaml
	CollisionDialog.xaml.cs
	CollisionItem.cs
	DeleteNotificationDialog.xaml
	DeleteNotificationDialog.xaml.cs
	FileOperation.xaml
	FileOperation.xaml.cs
	FileOperationDialog.xaml
	FileOperationDialog.xaml.cs
	IIFileOperation.cs
	Groups
	ListViewGroupEx.cs
	LVGROUP.cs
	Interop
	BHID.cs
	ComCtl32.cs
	ComReleaser.cs
	Constants.cs
	CredUI.cs
	DefaultIconSize.cs
	Enums.cs
	EnumUnknownClass.cs
	FileIcon.cs
	FileOperationFlags.cs
	Gdi32.cs
	Helpers.cs
	HResult.cs
	IColumnProvider.cs
	IconReference.cs
	IContextMenu.cs
	IDropSource.cs
	IEnumIDList.cs
	IExtractIcon.cs
	IFileDialog.cs
	IFileOperation.cs
	IFileOperationProgressSink.cs
	IFileSystemBindData.cs
	IListView.cs
	INativeShellLibrary.cs
	IOperationsProgressDialog.cs
	IQueryInfo.cs
	ISearch.cs
	IServiceProvider.cs
	IShellBrowser.cs
	IShellFolder.cs
	IShellItem.cs
	IShellItem2.cs
	IShellItemArray.cs
	IShellLibrary.cs
	IShellView.cs
	IThumbnail.cs
	IThumbnailCache.cs
	IVisualProperties.cs
	Kernel32.cs
	KnownFoldersCOM.cs
	NativePoint.cs
	NativeWindowListener.cs
	Ole32.cs
	PropertySystemNativeMethods.cs
	PropVariant.cs
	PropVariantNativeMethods.cs
	Shell32.cs
	ShellItemArray.cs
	ShellItemImpl.cs
	ShellLink.cs
	ShellNotifications.cs
	ShellThumbnail.cs
	ShlWapi.cs
	User32.cs
	UxTheme.cs
	Wallpaper.cs
	WIC.zip
	WindowsThumbnailProvider.cs
	KnownFolders
	DefinitionOptions.cs
	FileSystemKnownFolder.cs
	FolderCategory.cs
	FolderProperties.cs
	FoldersIdentifiers.cs
	FolderTypes.cs
	IKnownFolder.cs
	KnownFolderHelper.cs
	KnownFolders.cs
	KnownFolderSettings.cs
	NonFileSystemKnownFolder.cs
	RedirectionCapabilities.cs
	Properties
	Annotations.cs
	AssemblyInfo.cs
	Resources.Designer.cs
	Resources.resx
	Resources
	Back.bmp
	Forward.bmp
	NewFolder.bmp
	Up.bmp
	Views.bmp
	VirtualGroups
	IOwnerDataCallback.cs
	VirtualGrouping.cs
	WindowsSearch
	SearchCondition.cs
	SearchConditionFactory.cs
	ShellSearchFolder.cs
	x64
	SQLite.Interop.dll
	x86
	SQLite.Interop.dll
	.upgrade-assistant
	app.config
	AssociationItem.cs
	Collumns.cs
	Defaults.cs
	DragDropHelper.cs
	Extensions.cs
	FileFilterComboBox.cs
	FileNameComboBox.cs
	FilesystemTreeViewItem.cs
	FilterItem.cs
	FolderSelectDialog.cs
	FolderSettings.cs
	GlobalSuppressions.cs
	ImageListEx.cs
	JunctionPoint.cs
	LeftMarginMultiplierConverter.cs
	ListViewEditor.cs
	LVItemColor.cs
	NavigationLog.cs
	ObjectToSeparatorBooleanConverter.cs
	ObservableCollectionEx.cs
	QueueEx.cs
	Reflector.cs
	Settings.sqlite
	Shell.csproj
	Shell.ruleset
	ShellComboBox.cs
	ShellContextMenu.cs
	ShellItem.cs
	ShellItemEqualityComparer.cs
	ShellLibrary.cs
	ShellNotificationListener.cs
	ShellTreeView.xaml
	ShellTreeView.xaml.cs
	ShellTreeViewEx.cs
	ShellTreeViewEx.Designer.cs
	ShellViewControl.xaml
	ShellViewControl.xaml.cs
	ShellViewEx.cs
	ShellViewEx.Designer.cs
	ShellViewEx.resx
	SyncQueue.cs
	SysImageList.cs
	SystemImageList.cs
	ThreadSafeListWithLock.cs
	ToolTip.xaml
	ToolTip.xaml.cs
	TooltipDataTemplateSelector.cs
	TreeViewBase.cs
	TreeViewHelper.cs
	TreeViewItemBehaviour.cs
	Utilities.cs
	video_addorner_wide.png
	video_addorner.png
	WindowActivator.cs

FileSystemListItem.cs

-771

/Shell1/_Plugin Interfaces/FileSystemListItem.cs

View

Displayed content is truncated due to maximum viewable content limit.

using System.Runtime.CompilerServices;

using System.IO;

using BExplorer.Shell.Interop;

using System;

using System.Collections.Generic;

using System.Runtime.InteropServices;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Media.Imaging;

using ThumbnailGenerator;

using Size = System.Drawing.Size;

using System.Text;

using System.Linq;

using System.Windows.Interop;

namespace BExplorer.Shell._Plugin_Interfaces {

using System.Drawing;

using System.Windows.Media;

/// <summary>

/// A representation of items on a standard physical/local file system

/// </summary>

public class FileSystemListItem : IListItemEx {

#region Private Members

/// <summary>The real item that is a wrapper for</summary>

private ShellItem _Item { get; set; }

#endregion Private Members

#region IListItemEx Members

public IntPtr ParentPIDL { get; set; }

public IntPtr EnumPIDL { get; set; }

/// <summary>The COM interface for this item</summary>

public IShellItem ComInterface => this.ParentPIDL == IntPtr.Zero

? Shell32.SHCreateItemFromIDList(this.EnumPIDL, typeof(IShellItem).GUID)

: Shell32.SHCreateItemWithParent(this.ParentPIDL, null, this.EnumPIDL, typeof(IShellItem).GUID);

/// <summary>The text that represents the display name</summary>

public String DisplayName {

get { return this.GetDisplayName(SIGDN.NORMALDISPLAY); }

}

/// <summary>Does the current item need to be refreshed in the ShellListView</summary>

public Boolean IsNeedRefreshing { get; set; }

/// <summary>Assigned values but never used</summary>

public Boolean IsInvalid { get; set; }

public Boolean IsProcessed { get; set; }

/// <summary>Changes how the item gets loaded</summary>

public Boolean IsOnlyLowQuality { get; set; }

public Boolean IsThumbnailLoaded { get; set; }

public Boolean IsInitialised { get; set; }

public Int32 OverlayIconIndex { get; set; }

private IExtractIconPWFlags _IconType = IExtractIconPWFlags.GIL_PERCLASS;

public IExtractIconPWFlags IconType {

get { return this.GetIconType(); }

set { this._IconType = value; }

}

public IExtractIconPWFlags GetIconType() {

if (this.IsFolder) {

IExtractIcon iextract = null;

IShellFolder ishellfolder = null;

StringBuilder str = null;

IntPtr result;

try {

var guid = new Guid("000214fa-0000-0000-c000-000000000046");

UInt32 res = 0;

ishellfolder = this.Parent.GetIShellFolder();

var pidls = new IntPtr[1] { Shell32.ILFindLastID(this.PIDL) };

ishellfolder.GetUIObjectOf(IntPtr.Zero, 1, pidls, ref guid, res, out result);

if (result == IntPtr.Zero) {

pidls = null;

return IExtractIconPWFlags.GIL_PERCLASS;

}

iextract = (IExtractIcon)Marshal.GetTypedObjectForIUnknown(result, typeof(IExtractIcon));

str = new StringBuilder(512);

var index = -1;

IExtractIconPWFlags flags;

iextract.GetIconLocation(IExtractIconUFlags.GIL_ASYNC, str, 512, out index, out flags);

Marshal.ReleaseComObject(ishellfolder);

Marshal.ReleaseComObject(iextract);

return flags;

} catch (Exception) {

return 0;

}

} else {

var value = this.GetPropertyValue(SystemProperties.PerceivedType, typeof(PerceivedType))?.Value;

if (value != null) {

var perceivedType = (PerceivedType)value;

if (perceivedType == PerceivedType.Application) {

return IExtractIconPWFlags.GIL_PERINSTANCE;

} else {

return IExtractIconPWFlags.GIL_PERCLASS;

}

return IExtractIconPWFlags.GIL_PERCLASS;

//if (this.Extension.ToLowerInvariant() == ".exe" || this.Extension.ToLowerInvariant() == ".com" || this.Extension.ToLowerInvariant() == ".bat" || this.Extension.ToLowerInvariant() == ".msi" || this.Extension.ToLowerInvariant() == ".jar") {

// return IExtractIconPWFlags.GIL_PERINSTANCE;

//}

////return IExtractIconPWFlags.GIL_PERCLASS;

//if (this.Parent == null) {

// return 0;

//}

////if (this.IsFolder) {

// IExtractIcon iextract = null;

// IShellFolder ishellfolder = null;

// StringBuilder str = null;

// IntPtr result;

// try {

// var guid = new Guid("000214fa-0000-0000-c000-000000000046");

// uint res = 0;

// ishellfolder = this.Parent.GetIShellFolder();

// var pidls = new IntPtr[1] { Shell32.ILFindLastID(this.PIDL) };

// ishellfolder.GetUIObjectOf(IntPtr.Zero, 1, pidls, ref guid, res, out result);

// if (result == IntPtr.Zero) {

// pidls = null;

// return IExtractIconPWFlags.GIL_PERCLASS;

// }

// iextract = (IExtractIcon)Marshal.GetTypedObjectForIUnknown(result, typeof(IExtractIcon));

// str = new StringBuilder(512);

// var index = -1;

// IExtractIconPWFlags flags;

// iextract.GetIconLocation(IExtractIconUFlags.GIL_ASYNC, str, 512, out index, out flags);

// return flags;

// } catch (Exception) {

// return 0;

// }

////} else {

//// return IExtractIconPWFlags.GIL_PERCLASS;

////}

}

public IntPtr ILPidl => Shell32.ILFindLastID(this.PIDL);

public IntPtr PIDL {

get {

var comObject = this.ComInterface;

var result = comObject == null ? IntPtr.Zero : Shell32.SHGetIDListFromObject(comObject);

Marshal.FinalReleaseComObject(comObject);

return result;

}

public IntPtr AbsolutePidl {

get {

UInt32 attr;

IntPtr pidl;

Shell32.SHParseDisplayName(this.ParsingName, IntPtr.Zero, out pidl, 0, out attr);

return pidl;

}

/// <summary>Index of the ShieldedIcon</summary>

public Int32 ShieldedIconIndex { get; set; }

/// <summary>Is this item's icon loaded yet?</summary>

public Boolean IsIconLoaded { get; set; }

public String ParsingName {

get { return this.GetDisplayName(SIGDN.DESKTOPABSOLUTEPARSING); }

}

/// <summary>The file system extension for this item</summary>

public String Extension => Path.GetExtension(this.ParsingName);

/// <summary>The file system path</summary>

public String FileSystemPath => this.GetDisplayName(SIGDN.FILESYSPATH);

/// <summary>

/// Returns true if folder can be browsed

/// </summary>

public Boolean IsBrowsable => this.COM_Attribute_Check(SFGAO.BROWSABLE);

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private Boolean COM_Attribute_Check(SFGAO Check) {

var comObject = this.ComInterface;

SFGAO sfgao;

comObject.GetAttributes(Check, out sfgao);

Marshal.FinalReleaseComObject(comObject);

this.Dispose();

return (sfgao & Check) != 0;

}

/// <summary>Gets a value indicating whether this is a folder </summary>

public Boolean IsFolder {

get {

var comObject = this.ComInterface;

SFGAO sfgao;

comObject.GetAttributes(SFGAO.FOLDER, out sfgao);

SFGAO sfgao2;

comObject.GetAttributes(SFGAO.STREAM, out sfgao2);

Marshal.FinalReleaseComObject(comObject);

return sfgao != 0 && sfgao2 == 0;

}

/// <summary>Does this have folders?</summary>

public Boolean HasSubFolders => this.COM_Attribute_Check(SFGAO.HASSUBFOLDER);

/// <summary>Is this item normally hidden?</summary>

public Boolean IsHidden => this.COM_Attribute_Check(SFGAO.HIDDEN);

public Boolean IsFileSystem => this.COM_Attribute_Check(SFGAO.FILESYSTEM);

public Boolean IsNetworkPath => Shell32.PathIsNetworkPath(this.ParsingName);

/// <summary>Is current item represent a system drive?</summary>

public Boolean IsDrive {

get {

try {

return Directory.GetLogicalDrives().Contains(this.ParsingName) && Kernel32.GetDriveType(this.ParsingName) != DriveType.Network;

} catch {

return false;

}

public Boolean IsShared => this.COM_Attribute_Check(SFGAO.SHARE);

public Boolean IsSlow => this.COM_Attribute_Check(SFGAO.ISSLOW);

/// <summary>Is the parent a search folder?</summary>

public Boolean IsParentSearchFolder { get; set; }

public Int32 GroupIndex { get; set; }

public Int32 RCWThread { get; set; }

public IShellFolder IFolder { get; set; }

private void Initialize_Helper(IntPtr folder, IntPtr lvHandle, Int32 index) {

this.ParentPIDL = IntPtr.Zero;

this.EnumPIDL = folder;

//this.ParentHandle = lvHandle;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

}

private void Initialize_Helper2(IntPtr parent, IntPtr pidl, IntPtr lvHandle, Int32 index) {

this.ParentPIDL = parent;

this.EnumPIDL = pidl;

//this.ParentHandle = lvHandle;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

}

public void Initialize(IntPtr lvHandle, IntPtr pidl, Int32 index) {

this.Initialize_Helper(pidl, lvHandle, index);

}

public void InitializeWithParent(IntPtr parent, IntPtr lvHandle, IntPtr pidl, Int32 index) {

this.Initialize_Helper2(parent, pidl, lvHandle, index);

}

public void InitializeWithShellItem(ShellSearchFolder item, IntPtr lvHandle, Int32 index) {

this.Initialize_Helper(item.Pidl, lvHandle, index);

this.searchFolder = item;

}

public ShellSearchFolder searchFolder { get; set; }

public Dictionary<PROPERTYKEY, Object> ColumnValues { get; set; }

public Int32 ItemIndex { get; set; }

public IntPtr ParentHandle { get; set; }

public static IListItemEx InitializeWithIShellItem(IntPtr lvHandle, IShellItem item) {

var fsItem = new FileSystemListItem();

fsItem.Initialize(lvHandle, Shell32.SHGetIDListFromObject(item), 0);

return fsItem;

}

public void Initialize(IntPtr lvHandle, String path, Int32 index) {

var shellItem = Shell32.SHCreateItemFromParsingName(path, IntPtr.Zero, typeof(IShellItem).GUID);

this.ParentPIDL = IntPtr.Zero;

this.EnumPIDL = Shell32.SHGetIDListFromObject(shellItem);

Marshal.ReleaseComObject(shellItem);

//this.ParentHandle = lvHandle;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

}

public void Initialize(IntPtr lvHandle, String path) {

throw new NotImplementedException();

}

public void Initialize(IntPtr lvHandle, IntPtr pidl) {

throw new NotImplementedException();

}

public FileSystemListItem() {

this.GroupIndex = -1;

this.ItemIndex = -1;

this.IconIndex = -1;

this.ColumnValues = new Dictionary<PROPERTYKEY, Object>();

}

public HResult NavigationStatus { get; set; }

public Size IconSize { get; set; }

public IEnumerable<IntPtr> GetItemsForCount(Boolean isEnumHidden) {

var folder = this.GetIShellFolder();

if (folder == null) {

yield return IntPtr.Zero;

}

HResult navRes;

var flags = SHCONTF.FOLDERS | SHCONTF.FASTITEMS | SHCONTF.NONFOLDERS | SHCONTF.ENABLE_ASYNC | SHCONTF.INIT_ON_FIRST_NEXT;

if (isEnumHidden) {

}

var enumId = ShellItem.GetIEnumIDList(folder, flags, out navRes);

this.NavigationStatus = navRes;

UInt32 count;

IntPtr pidl;

if (enumId == null) {

yield break;

}

var result = enumId.Next(1, out pidl, out count);

while (result == HResult.S_OK) {

yield return pidl;

Shell32.ILFree(pidl);

result = enumId.Next(1, out pidl, out count);

}

if (folder != null) {

Marshal.ReleaseComObject(folder);

}

if (result != HResult.S_FALSE) {

//Marshal.ThrowExceptionForHR((int)result);

}

yield break;

}

public IEnumerable<IListItemEx> GetContents(Boolean isEnumHidden, Boolean isFlatList = false) {

var folder = this.GetIShellFolder();

if (folder == null) {

yield return null;

}

HResult navRes;

var flags = SHCONTF.FOLDERS | SHCONTF.NONFOLDERS | SHCONTF.CHECKING_FOR_CHILDREN | SHCONTF.ENABLE_ASYNC;

if (isEnumHidden) {

}

//if (isFlatList) {

// flags = SHCONTF.NONFOLDERS | SHCONTF.CHECKING_FOR_CHILDREN | SHCONTF.ENABLE_ASYNC | SHCONTF.SFLATLIST | SHCONTF.NAVIGATION_ENUM;

//}

var enumId = ShellItem.GetIEnumIDList(folder, flags, out navRes);

this.NavigationStatus = navRes;

UInt32 count;

IntPtr pidl;

if (enumId == null) {

yield break;

}

var result = enumId.Next(1, out pidl, out count);

var i = 0;

while (result == HResult.S_OK) {

//var sb = new StringBuilder(512);

//Shell32.SHGetPathFromIDList(pidl, sb);

//var ext = Path.GetExtension(sb.ToString());

var fsi = new FileSystemListItem();

try {

fsi.InitializeWithParent(this.PIDL, this.ParentHandle, pidl, i++);

} catch {

continue;

}

if (fsi.IsFolder && isFlatList) {

foreach (var child in fsi.GetContents(true, true)) {

yield return child;

}

fsi.IsParentSearchFolder = this.IsSearchFolder;

fsi.Dispose();

yield return fsi;

//Shell32.ILFree(pidl);

result = enumId.Next(1, out pidl, out count);

}

if (folder != null) {

Marshal.ReleaseComObject(folder);

}

if (result != HResult.S_FALSE) {

//Marshal.ThrowExceptionForHR((int)result);

}

//parentItem.Dispose();

yield break;

}

public IEnumerator<IListItemEx> GetEnumerator() {

var folder = this.GetIShellFolder();

if (folder == null) {

yield return null;

}

HResult navRes;

var enumId = ShellItem.GetIEnumIDList(folder, flags, out navRes);

this.NavigationStatus = navRes;

UInt32 count;

IntPtr pidl;

if (enumId == null) {

yield break;

}

var result = enumId.Next(1, out pidl, out count);

var i = 0;

while (result == HResult.S_OK) {

var fsi = new FileSystemListItem();

try {

fsi.InitializeWithParent(this.PIDL, this.ParentHandle, pidl, i++);

} catch {

continue;

}

fsi.IsParentSearchFolder = this.IsSearchFolder;

fsi.Dispose();

yield return fsi;

result = enumId.Next(1, out pidl, out count);

}

if (folder != null) {

Marshal.ReleaseComObject(folder);

}

if (result != HResult.S_FALSE) {

//Marshal.ThrowExceptionForHR((int)result);

}

yield break;

}

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() => this.GetEnumerator();

public PropVariant GetPropertyValue(PROPERTYKEY pkey, Type type) {

var pvar = new PropVariant();

var comObject = this.ComInterface;

var isi2 = (IShellItem2)comObject;

if (isi2 == null) {

return PropVariant.FromObject(null);

}

isi2.GetProperty(ref pkey, pvar);

Marshal.ReleaseComObject(comObject);

this.Dispose();

return pvar;

}

public System.Drawing.Bitmap Thumbnail(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source) => this._Item?.GetShellThumbnail(size, format, source);

public BitmapSource ThumbnailBitmapSource => this.ThumbnailSource(16, ShellThumbnailFormatOption.IconOnly, ShellThumbnailRetrievalOption.Default);

public BitmapSource ThumbnailSource(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source) {

var hBitmap = this.GetHBitmap(size, format == ShellThumbnailFormatOption.ThumbnailOnly, source == ShellThumbnailRetrievalOption.Default, format == ShellThumbnailFormatOption.Default);

// return a System.Media.Imaging.BitmapSource

// Use interop to create a BitmapSource from hBitmap.

if (hBitmap == IntPtr.Zero) {

return null;

}

var returnValue = Imaging.CreateBitmapSourceFromHBitmap(hBitmap, IntPtr.Zero, System.Windows.Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions()).Clone();

//returnValue.Freeze();

// delete HBitmap to avoid memory leaks

Gdi32.DeleteObject(hBitmap);

this.Dispose();

return returnValue;

}

IListItemEx.cs

-177

/Shell1/_Plugin Interfaces/IListItemEx.cs

View

using System;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Windows.Media.Imaging;

using BExplorer.Shell.Interop;

using Size = System.Drawing.Size;

namespace BExplorer.Shell._Plugin_Interfaces {

public interface IListItemEx : IEnumerable<IListItemEx>, IEquatable<IListItemEx>, IEqualityComparer<IListItemEx> {

IntPtr ParentPIDL { get; set; }

IntPtr EnumPIDL { get; set; }

IExtractIconPWFlags GetIconType();

/// <summary>The COM interface for this item</summary>

IShellItem ComInterface { get; }

/// <summary>The logical parent for this item</summary>

IListItemEx Parent { get; }

/// <summary>The text that represents the display name</summary>

String DisplayName { get; }

/// <summary>The file system extension for this item</summary>

String Extension { get; }

/// <summary>The file system path</summary>

String FileSystemPath { get; }

Int32 ItemIndex { get; set; }

/// <summary>I think we can remove this and just use this.Parent.PIDL. This property's role is confusing because of how its used</summary>

IntPtr ParentHandle { get; set; }

/// <summary>Does the current item need to be refreshed in the ShellListView</summary>

Boolean IsNeedRefreshing { get; set; }

/// <summary>Assigned values but never used</summary>

Boolean IsInvalid { get; set; }

Boolean IsProcessed { get; set; }

/// <summary>Changes how the item gets loaded</summary>

Boolean IsOnlyLowQuality { get; set; }

Boolean IsThumbnailLoaded { get; set; }

/// <summary>Set but never used</summary>

Boolean IsInitialised { get; set; } //TODO: Use this property or delete it

/// <summary>The Index of the Icon (Double Check)</summary>

Int32 OverlayIconIndex { get; set; }

Int32 GroupIndex { get; set; }

/// <summary>Set but never used</summary>

Int32 IconIndex { get; set; } //TODO: Use this property or delete it

Size IconSize { get; set; }

IExtractIconPWFlags IconType { get; set; }

IntPtr ILPidl { get; }

IntPtr PIDL { get; }

/// <summary>Not Used</summary>

IShellFolder IFolder { get; set; } //TODO: Use this property or delete it

/// <summary>Index of the ShieldedIcon</summary>

Int32 ShieldedIconIndex { get; set; }

/// <summary>Is this item's icon loaded yet?</summary>

Boolean IsIconLoaded { get; set; }

Boolean IsFileSystem { get; }

Boolean IsNetworkPath { get; }

/// <summary>Is current item represent a system drive?</summary>

Boolean IsDrive { get; }

/// <summary>Is the current item a search folder?</summary>

Boolean IsSearchFolder { get; }

/// <summary>Implemented but never used</summary>

Bitmap Thumbnail(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source);

/// <summary>Gets the item's BitmapSource</summary>

BitmapSource ThumbnailSource(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source);

/// <summary>Implemented but never used</summary>

BitmapSource BitmapSource { get; }

String ParsingName { get; }

Boolean IsBrowsable { get; }

/// <summary>Is this a folder?</summary>

Boolean IsFolder { get; }

/// <summary>Does this have folders?</summary>

Boolean HasSubFolders { get; }

/// <summary>Is this item normally hidden?</summary>

Boolean IsHidden { get; }

Boolean IsLink { get; }

Boolean IsShared { get; }

Boolean IsSlow { get; }

/// <summary>We should remove this and use this.Parent.IsSearchFolder</summary>

Boolean IsParentSearchFolder { get; set; }

void Initialize(IntPtr lvHandle, String path);

void Initialize(IntPtr lvHandle, String path, Int32 index);

void Initialize(IntPtr lvHandle, IntPtr pidl, int index);

void Initialize(IntPtr lvHandle, IntPtr pidl);

void InitializeWithParent(IntPtr parent, IntPtr lvHandle, IntPtr pidl, int index);

IListItemEx Clone(Boolean isHardCloning = false);

PropVariant GetPropertyValue(PROPERTYKEY pkey, Type type);

Dictionary<PROPERTYKEY, Object> ColumnValues { get; set; }

IEnumerable<IntPtr> GetItemsForCount(Boolean isEnumHidden);

IEnumerable<IListItemEx> GetContents(Boolean isEnumHidden, Boolean isFlatList = false);

IShellFolder GetIShellFolder();

String ToolTipText { get; }

IntPtr AbsolutePidl { get; }

/// <summary>Returns drive information</summary>

DriveInfo GetDriveInfo();

Boolean IsRCWSet { get; set; }

Int32 RCWThread { get; set; }

HResult ExtractAndDrawThumbnail(IntPtr hdc, uint iconSize, out WTS_CACHEFLAGS flags, User32.RECT iconBounds, out bool retrieved, bool isHidden, bool isRefresh = false); //TODO: Use or Delete

HResult NavigationStatus { get; set; }

IntPtr GetHBitmap(int iconSize, bool isThumbnail, bool isForce = false, bool isBoth = false);

Boolean RefreshThumb(int iconSize, out WTS_CACHEFLAGS flags);

String GetDisplayName(SIGDN type);

IExtractIconPWFlags GetShield();

int GetSystemImageListIndex(IntPtr pidl, ShellIconType type, ShellIconFlags flags);

int GetUniqueID();

int[] cColumns { get; set; }

void Dispose();

}

VirtualFilesystemItem.cs

-257

/Shell1/_Plugin Interfaces/VirtualFilesystemItem.cs

View

using System;

using System.Collections;

using System.Collections.Generic;

using System.Drawing;

using System.IO;

using System.Runtime.InteropServices;

using System.Runtime.InteropServices.ComTypes;

using System.Windows.Media.Imaging;

using BExplorer.Shell.Interop;

namespace BExplorer.Shell._Plugin_Interfaces {

public class VirtualFilesystemItem : IListItemEx, IFileSystemBindData, IDisposable {

protected WIN32_FIND_DATA _fd;

//private VirtualFilesystemItem(ref WIN32_FIND_DATA pfd) { _fd = pfd; }

public VirtualFilesystemItem(String path, System.IO.FileAttributes attributes) {

this._fd = new WIN32_FIND_DATA() {

dwFileAttributes = (uint)attributes

};

this.CreateSimplePidl(path);

}

public void GetFileData([MarshalAs(UnmanagedType.Struct), Out] out WIN32_FIND_DATA pdf) {

pdf = _fd;

}

public void SetFileData([In, MarshalAs(UnmanagedType.Struct)] ref WIN32_FIND_DATA pfd) {

_fd = pfd;

}

void CreateBindCtx(out IBindCtx pbc) {

System.Runtime.InteropServices.ComTypes.BIND_OPTS bo = new System.Runtime.InteropServices.ComTypes.BIND_OPTS() {

cbStruct = Marshal.SizeOf(typeof(System.Runtime.InteropServices.ComTypes.BIND_OPTS)),

dwTickCountDeadline = 0,

grfFlags = 0,

grfMode = Shell32.STGM_CREATE

};

try {

Ole32.CreateBindCtx(0, out pbc);

pbc.SetBindOptions(ref bo);

pbc.RegisterObjectParam(Shell32.STR_FILE_SYS_BIND_DATA, this);

} catch {

pbc = null;

throw;

}

void CreateSimplePidl(string path) {

IBindCtx pbc;

IntPtr ppidl = IntPtr.Zero;

uint sfgao;

this.CreateBindCtx(out pbc);

Shell32.SHParseDisplayName(path, pbc, out ppidl, 0, out sfgao);

this.EnumPIDL = ppidl;

}

public IShellFolder GetParent(ref IntPtr pidl) {

Guid iid = typeof(IShellFolder).GUID;

IShellFolder ppv;

Shell32.SHBindToParent(this.EnumPIDL, ref iid, out ppv, out pidl);

return ppv;

}

bool _disposed = false;

public IntPtr ParentPIDL { get; set; }

public IntPtr EnumPIDL { get; set; }

public IExtractIconPWFlags GetIconType() {

throw new NotImplementedException();

}

public IShellItem ComInterface {

get {

object item = null;

Guid iid = typeof(IShellItem).GUID;

Shell32.SHCreateItemFromIDList(this.EnumPIDL, ref iid, out item);

return (IShellItem)item;

}

public IListItemEx Parent {

get {

Guid iid = typeof(IShellFolder).GUID;

IntPtr pidl = IntPtr.Zero;

IShellFolder ppv;

Shell32.SHBindToParent(this.EnumPIDL, ref iid, out ppv, out pidl);

this.ParentPIDL = pidl;

var parent = new FileSystemListItem();

parent.Initialize(IntPtr.Zero, pidl);

return parent;

}

public String DisplayName { get; }

public String Extension { get; }

public String FileSystemPath { get; }

public Int32 ItemIndex { get; set; }

public IntPtr ParentHandle { get; set; }

public Boolean IsNeedRefreshing { get; set; }

public Boolean IsInvalid { get; set; }

public Boolean IsProcessed { get; set; }

public Boolean IsOnlyLowQuality { get; set; }

public Boolean IsThumbnailLoaded { get; set; }

public Boolean IsInitialised { get; set; }

public Int32 OverlayIconIndex { get; set; }

public Int32 GroupIndex { get; set; }

public Int32 IconIndex { get; set; }

public System.Drawing.Size IconSize { get; set; }

public IExtractIconPWFlags IconType { get; set; }

public IntPtr ILPidl { get; }

public IntPtr PIDL { get; }

public IShellFolder IFolder { get; set; }

public Int32 ShieldedIconIndex { get; set; }

public Boolean IsIconLoaded { get; set; }

public Boolean IsFileSystem { get; }

public Boolean IsNetworkPath { get; }

public Boolean IsDrive { get; }

public Boolean IsSearchFolder { get; }

public Bitmap Thumbnail(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source) {

throw new NotImplementedException();

}

public BitmapSource ThumbnailSource(Int32 size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source) {

throw new NotImplementedException();

}

public BitmapSource BitmapSource { get; }

public String ParsingName { get; }

public Boolean IsBrowsable { get; }

public Boolean IsFolder { get; }

public Boolean HasSubFolders { get; }

public Boolean IsHidden { get; }

public Boolean IsLink { get; }

public Boolean IsShared { get; }

public Boolean IsSlow { get; }

public Boolean IsParentSearchFolder { get; set; }

public void Initialize(IntPtr lvHandle, String path) {

throw new NotImplementedException();

}

public void Initialize(IntPtr lvHandle, String path, Int32 index) {

throw new NotImplementedException();

}

public void Initialize(IntPtr lvHandle, IntPtr pidl, Int32 index) {

throw new NotImplementedException();

}

public void Initialize(IntPtr lvHandle, IntPtr pidl) {

throw new NotImplementedException();

}

public void InitializeWithParent(IntPtr parent, IntPtr lvHandle, IntPtr pidl, Int32 index) {

throw new NotImplementedException();

}

public IListItemEx Clone(Boolean isHardCloning = false) {

throw new NotImplementedException();

}

public PropVariant GetPropertyValue(PROPERTYKEY pkey, Type type) {

throw new NotImplementedException();

}

public Dictionary<PROPERTYKEY, Object> ColumnValues { get; set; }

public IEnumerable<IntPtr> GetItemsForCount(Boolean isEnumHidden) {

throw new NotImplementedException();

}

public IEnumerable<IListItemEx> GetContents(Boolean isEnumHidden, Boolean isFlatList = false) {

throw new NotImplementedException();

}

public IShellFolder GetIShellFolder() {

throw new NotImplementedException();

}

public String ToolTipText { get; }

public IntPtr AbsolutePidl { get; }

public DriveInfo GetDriveInfo() {

throw new NotImplementedException();

}

public Boolean IsRCWSet { get; set; }

public Int32 RCWThread { get; set; }

public HResult ExtractAndDrawThumbnail(IntPtr hdc, UInt32 iconSize, out WTS_CACHEFLAGS flags, User32.RECT iconBounds,

out Boolean retrieved, Boolean isHidden, Boolean isRefresh = false) {

throw new NotImplementedException();

}

public HResult NavigationStatus { get; set; }

public IntPtr GetHBitmap(Int32 iconSize, Boolean isThumbnail, Boolean isForce = false, Boolean isBoth = false) {

throw new NotImplementedException();

}

public Boolean RefreshThumb(Int32 iconSize, out WTS_CACHEFLAGS flags) {

throw new NotImplementedException();

}

public String GetDisplayName(SIGDN type) {

throw new NotImplementedException();

}

public IExtractIconPWFlags GetShield() {

throw new NotImplementedException();

}

public Int32 GetSystemImageListIndex(IntPtr pidl, ShellIconType type, ShellIconFlags flags) {

throw new NotImplementedException();

}

public Int32 GetUniqueID() {

throw new NotImplementedException();

}

public Int32[] cColumns { get; set; }

public void Dispose() {

if (!_disposed) {

if (this.EnumPIDL != IntPtr.Zero) {

try {

Marshal.FreeCoTaskMem(this.EnumPIDL);

} catch { } finally {

this.EnumPIDL = IntPtr.Zero;

}

GC.SuppressFinalize(this);

}

_disposed = true;

}

public IEnumerator<IListItemEx> GetEnumerator() {

throw new NotImplementedException();

}

public Boolean Equals(IListItemEx other) {

throw new NotImplementedException();

}

~VirtualFilesystemItem() { Dispose(); }

IEnumerator IEnumerable.GetEnumerator() {

return this.GetEnumerator();

}

public Boolean Equals(IListItemEx x, IListItemEx y) {

throw new NotImplementedException();

}

public Int32 GetHashCode(IListItemEx obj) {

throw new NotImplementedException();

}

FilterMenu_Strings.cs

-70

/Shell1/Custom ContextMenus Remove Soon/FilterMenu_Strings.cs

View

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows;

using System.Windows.Controls;

namespace BExplorer.Shell {

public class FilterMenu_Strings : ContextMenu {

/// <summary>

/// Represents the changing of a CheckBox's check state

/// </summary>

/// <param name="sender">The sender.</param>

/// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>

/// <param name="IsChecked">if set to <c>true</c> [is checked].</param>

public delegate void CheckChanged(object sender, RoutedEventArgs e, bool IsChecked);

/// <summary>Occurs when a CheckBox's check has been changed</summary>

public event CheckChanged OnCheckChanged;

public void SetItems(params string[] Items) {

SetItems(Items.ToList());

}

/// <summary>

/// Sets the items.

/// </summary>

/// <param name="Items">The items you want to use.</param>

public void SetItems(IEnumerable<string> Items) {

this.Items.Clear();

foreach (var Item in Items) {

//this.Height += 25;

var CheckBox = new CheckBox();

CheckBox.Content = Item;

CheckBox.Checked += CheckBox_Checked;

CheckBox.Unchecked += CheckBox_Unchecked;

this.Items.Add(CheckBox);

}

/// <summary>

/// Gets the [Content] of the checked CheckBoxes.

/// </summary>

/// <returns></returns>

public List<string> CheckedItems() {

return this.Items.OfType<CheckBox>().Where(x => x.IsChecked.Value).Select(x => x.Content.ToString()).ToList();

}

public void Activate(Control Container) {

Container.ContextMenu = this;

Container.ContextMenu.IsEnabled = true;

Container.ContextMenu.PlacementTarget = Container;

Container.ContextMenu.Placement = System.Windows.Controls.Primitives.PlacementMode.Bottom;

Container.ContextMenu.IsOpen = true;

}

void CheckBox_Unchecked(object sender, RoutedEventArgs e) {

if (OnCheckChanged != null) OnCheckChanged(sender, e, false);

}

void CheckBox_Checked(object sender, System.Windows.RoutedEventArgs e) {

if (OnCheckChanged != null) OnCheckChanged(sender, e, true);

}

AsyncUnbuffCopy.cs

-375

/Shell1/FileOperation/AsyncUnbuffCopy.cs

View

// AsyncUnbuffCopy.cs

// Authors:

// Wesley D. Brown <wes@planetarydb.com>

// Permission is hereby granted, free of charge, to any person obtaining

// a copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to

// permit persons to whom the Software is furnished to do so, subject to

// the following conditions:

// The above copyright notice and this permission notice shall be

// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

using System;

using System.IO;

using System.Runtime.CompilerServices;

using System.Security.Cryptography;

using System.Text;

using System.Threading;

namespace BExplorer.Shell {

public class CopyEventArgs {

public String InFileName { get; set; }

public String OutFileName { get; set; }

public long BytesTransferred { get; set; }

public long TotalBytes { get; set; }

}

public class AsyncUnbuffCopy {

public event EventHandler<CopyEventArgs> OnProgress;

//file names

private static string _inputfile;

private static string _outputfile;

//checksum holders

private static string _infilechecksum;

private static string _outfilechecksum;

//show write progress

private static bool _reportprogress;

//cursor position

private static int _origRow;

private static int _origCol;

//number of chunks to copy

private static int _numchunks;

//track read state and read failed state

private static bool _readfailed;

//syncronization object

private static readonly object Locker1 = new object();

//buffer size

public static int CopyBufferSize;

private static long _infilesize;

//buffer read

public static byte[] Buffer1;

private static int _bytesRead1;

//buffer overlap

public static byte[] Buffer2;

private static bool _buffer2Dirty;

private static int _bytesRead2;

//buffer write

public static byte[] Buffer3;

//total bytes read

private static long _totalbytesread;

private static long _totalbyteswritten;

//filestreams

private static FileStream _infile;

private static FileStream _outfile;

//secret sauce for unbuffered IO

const FileOptions FileFlagNoBuffering = (FileOptions)0x20000000;

private static void AsyncReadFile() {

//open input file

try {

_infile = new FileStream(_inputfile, FileMode.Open, FileAccess.Read, FileShare.Read, CopyBufferSize, FileFlagNoBuffering);

} catch {

throw;

}

//if we have data read it

while (_totalbytesread < _infilesize) {

_bytesRead1 = _infile.Read(Buffer1, 0, CopyBufferSize);

Monitor.Enter(Locker1);

try {

while (_buffer2Dirty) Monitor.Wait(Locker1);

Buffer.BlockCopy(Buffer1, 0, Buffer2, 0, _bytesRead1);

_buffer2Dirty = true;

_bytesRead2 = _bytesRead1;

_totalbytesread = _totalbytesread + _bytesRead1;

Monitor.PulseAll(Locker1);

} catch {

_readfailed = true;

throw;

} finally { Monitor.Exit(Locker1); }

}

//clean up open handle

_infile.Close();

_infile.Dispose();

}

private void AsyncWriteFile() {

//open output file set length to prevent growth and file fragmentation and close it.

//We do this to prevent file fragmentation and make the write as fast as possible.

try {

_outfile = new FileStream(_outputfile, FileMode.Create, FileAccess.Write, FileShare.None, 8, FileOptions.WriteThrough);

//set file size to minimum of one buffer to cut down on fragmentation

_outfile.SetLength(_infilesize > CopyBufferSize ? _infilesize : CopyBufferSize);

_outfile.Close();

_outfile.Dispose();

} catch {

throw;

}

//open file for write unbuffered

try {

_outfile = new FileStream(_outputfile, FileMode.Open, FileAccess.Write, FileShare.None, 8, FileOptions.WriteThrough | FileFlagNoBuffering);

} catch {

throw;

}

var pctinc = 0.0;

var progress = pctinc;

//progress stuff

if (_reportprogress) {

pctinc = 100.00 / _numchunks;

}

while ((_totalbyteswritten < _infilesize) && !_readfailed) {

lock (Locker1) {

while (!_buffer2Dirty) Monitor.Wait(Locker1);

Buffer.BlockCopy(Buffer2, 0, Buffer3, 0, _bytesRead2);

_buffer2Dirty = false;

_totalbyteswritten = _totalbyteswritten + CopyBufferSize;

Monitor.PulseAll(Locker1);

//fancy dan in place percent update on each write.

if (this.OnProgress != null) {

this.OnProgress.Invoke(this, new CopyEventArgs() {

InFileName = _inputfile,

OutFileName = _outputfile,

BytesTransferred = _totalbyteswritten,

TotalBytes = _infilesize

});

}

if (_reportprogress) {

Console.SetCursorPosition(_origCol, _origRow);

if (progress < 101 - pctinc) {

progress = progress + pctinc;

Console.Write("%{0}", Math.Round(progress, 0));

}

try {

_outfile.Write(Buffer3, 0, CopyBufferSize);

} catch {

throw;

}

//close the file handle that was using unbuffered and write through

_outfile.Close();

_outfile.Dispose();

try {

_outfile = new FileStream(_outputfile, FileMode.Open, FileAccess.Write, FileShare.None, 8,

FileOptions.WriteThrough);

_outfile.SetLength(_infilesize);

_outfile.Close();

_outfile.Dispose();

} catch {

throw;

}

public int AsyncCopyFileUnbuffered(string inputfile, string outputfile, bool overwrite,bool movefile, bool checksum, int buffersize, bool reportprogress) {

//report write progress

_reportprogress = reportprogress;

//set file name globals

_inputfile = inputfile;

_outputfile = outputfile;

//setup single buffer size, remember this will be x3.

CopyBufferSize = buffersize * 1024 * 1024;

//buffer read

Buffer1 = new byte[CopyBufferSize];

//buffer overlap

Buffer2 = new byte[CopyBufferSize];

//buffer write

Buffer3 = new byte[CopyBufferSize];

//clear all flags and handles

_totalbytesread = 0;

_totalbyteswritten = 0;

_bytesRead1 = 0;

_buffer2Dirty = false;

//if the overwrite flag is set to false check to see if the file is there.

if (File.Exists(outputfile) && !overwrite) {

Console.WriteLine("Destination File Exists!");

return 0;

}

//create the directory if it doesn't exist

if (!Directory.Exists(outputfile)) {

try {

// ReSharper disable AssignNullToNotNullAttribute

Directory.CreateDirectory(Path.GetDirectoryName(outputfile));

// ReSharper restore AssignNullToNotNullAttribute

} catch (Exception e) {

Console.WriteLine("Create Directory Failed.");

Console.WriteLine(e.Message);

throw;

}

//get input file size for later use

var inputFileInfo = new FileInfo(_inputfile);

_infilesize = inputFileInfo.Length;

//get number of buffer sized chunks used to correctly display percent complete.

_numchunks = (int)((_infilesize / CopyBufferSize) <= 0 ? (_infilesize / CopyBufferSize) : 1);

Console.WriteLine("File Copy Started");

//create read thread and start it.

var readfile = new Thread(AsyncReadFile) { Name = "ReadThread", IsBackground = true };

readfile.Start();

//create write thread and start it.

var writefile = new Thread(AsyncWriteFile) { Name = "WriteThread", IsBackground = true };

writefile.Start();

if (_reportprogress) {

//set fancy curor position

_origRow = Console.CursorTop;

_origCol = Console.CursorLeft;

}

//wait for threads to finish

readfile.Join();

writefile.Join();

//leave a blank line for the progress indicator

if (_reportprogress)

Console.WriteLine();

Console.WriteLine("File Copy Done");

if (checksum) {

Console.WriteLine("Checksum Source File Started");

//create checksum read file thread and start it.

var checksumreadfile = new Thread(GetMD5HashFromInputFile) {

Name = "checksumreadfile",

IsBackground = true

};

checksumreadfile.Start();

Console.WriteLine("Checksum Destination File Started");

//create checksum write file thread and start it.

var checksumwritefile = new Thread(GetMD5HashFromOutputFile) {

Name = "checksumwritefile",

IsBackground = true

};

checksumwritefile.Start();

//hang out until the checksums are done.

checksumreadfile.Join();

checksumwritefile.Join();

if (_infilechecksum.Equals(_outfilechecksum)) {

Console.WriteLine("Checksum Verified");

} else {

Console.WriteLine("Checksum Failed");

Console.WriteLine("Input File Checksum : {0}", _infilechecksum);

Console.WriteLine("Output File Checksum: {0}", _outfilechecksum);

}

if (movefile && File.Exists(inputfile) && File.Exists(outputfile))

try {

File.Delete(inputfile);

} catch (IOException ioex) {

Console.WriteLine("File in use or locked");

Console.WriteLine(ioex.Message);

} catch (Exception ex) {

Console.WriteLine("File Failed to Delete");

Console.WriteLine(ex.Message);

}

return 1;

}

//hash input file

public void GetMD5HashFromInputFile() {

var fs = new FileStream(_inputfile, FileMode.Open, FileAccess.Read, FileShare.None, CopyBufferSize);

MD5 md5 = new MD5CryptoServiceProvider();

byte[] retVal = md5.ComputeHash(fs);

fs.Close();

var sb = new StringBuilder();

for (var i = 0; i < retVal.Length; i++) {

sb.Append(retVal[i].ToString("x2"));

}

_infilechecksum = sb.ToString();

}

//hash output file

public void GetMD5HashFromOutputFile() {

var fs = new FileStream(_outputfile, FileMode.Open, FileAccess.Read, FileShare.None, CopyBufferSize);

MD5 md5 = new MD5CryptoServiceProvider();

byte[] retVal = md5.ComputeHash(fs);

fs.Close();

var sb = new StringBuilder();

for (var i = 0; i < retVal.Length; i++) {

sb.Append(retVal[i].ToString("x2"));

}

_outfilechecksum = sb.ToString();

}

CollisionDialog.xaml

/Shell1/FileOperation/CollisionDialog.xaml

View

CollisionDialog.xaml.cs

/Shell1/FileOperation/CollisionDialog.xaml.cs

View

CollisionItem.cs

/Shell1/FileOperation/CollisionItem.cs

View

DeleteNotificationDialog.xaml

/Shell1/FileOperation/DeleteNotificationDialog.xaml

View

DeleteNotificationDialog.xaml.cs

/Shell1/FileOperation/DeleteNotificationDialog.xaml.cs

View

FileOperation.xaml

/Shell1/FileOperation/FileOperation.xaml

View

FileOperation.xaml.cs

/Shell1/FileOperation/FileOperation.xaml.cs

View

FileOperationDialog.xaml

/Shell1/FileOperation/FileOperationDialog.xaml

View

FileOperationDialog.xaml.cs

/Shell1/FileOperation/FileOperationDialog.xaml.cs

View

IIFileOperation.cs

/Shell1/FileOperation/IIFileOperation.cs

View

ListViewGroupEx.cs

/Shell1/Groups/ListViewGroupEx.cs

View

LVGROUP.cs

/Shell1/Groups/LVGROUP.cs

View

BHID.cs

/Shell1/Interop/BHID.cs

View

ComCtl32.cs

/Shell1/Interop/ComCtl32.cs

View

ComReleaser.cs

/Shell1/Interop/ComReleaser.cs

View

Constants.cs

/Shell1/Interop/Constants.cs

View

CredUI.cs

/Shell1/Interop/CredUI.cs

View

DefaultIconSize.cs

/Shell1/Interop/DefaultIconSize.cs

View

Enums.cs

/Shell1/Interop/Enums.cs

View

EnumUnknownClass.cs

/Shell1/Interop/EnumUnknownClass.cs

View

FileIcon.cs

/Shell1/Interop/FileIcon.cs

View

FileOperationFlags.cs

/Shell1/Interop/FileOperationFlags.cs

View

Gdi32.cs

/Shell1/Interop/Gdi32.cs

View

Helpers.cs

/Shell1/Interop/Helpers.cs

View

HResult.cs

/Shell1/Interop/HResult.cs

View

IColumnProvider.cs

/Shell1/Interop/IColumnProvider.cs

View

IconReference.cs

/Shell1/Interop/IconReference.cs

View

IContextMenu.cs

/Shell1/Interop/IContextMenu.cs

View

IDropSource.cs

/Shell1/Interop/IDropSource.cs

View

IEnumIDList.cs

/Shell1/Interop/IEnumIDList.cs

View

IExtractIcon.cs

/Shell1/Interop/IExtractIcon.cs

View

IFileDialog.cs

/Shell1/Interop/IFileDialog.cs

View

IFileOperation.cs

/Shell1/Interop/IFileOperation.cs

View

IFileOperationProgressSink.cs

/Shell1/Interop/IFileOperationProgressSink.cs

View

IFileSystemBindData.cs

/Shell1/Interop/IFileSystemBindData.cs

View

IListView.cs

/Shell1/Interop/IListView.cs

View

INativeShellLibrary.cs

/Shell1/Interop/INativeShellLibrary.cs

View

IOperationsProgressDialog.cs

/Shell1/Interop/IOperationsProgressDialog.cs

View

IQueryInfo.cs

/Shell1/Interop/IQueryInfo.cs

View

ISearch.cs

/Shell1/Interop/ISearch.cs

View

IServiceProvider.cs

/Shell1/Interop/IServiceProvider.cs

View

IShellBrowser.cs

/Shell1/Interop/IShellBrowser.cs

View

IShellFolder.cs

/Shell1/Interop/IShellFolder.cs

View

IShellItem.cs

/Shell1/Interop/IShellItem.cs

View

IShellItem2.cs

/Shell1/Interop/IShellItem2.cs

View

IShellItemArray.cs

/Shell1/Interop/IShellItemArray.cs

View

IShellLibrary.cs

/Shell1/Interop/IShellLibrary.cs

View

IShellView.cs

/Shell1/Interop/IShellView.cs

View

IThumbnail.cs

/Shell1/Interop/IThumbnail.cs

View

IThumbnailCache.cs

/Shell1/Interop/IThumbnailCache.cs

View

IVisualProperties.cs

/Shell1/Interop/IVisualProperties.cs

View

Kernel32.cs

/Shell1/Interop/Kernel32.cs

View

KnownFoldersCOM.cs

/Shell1/Interop/KnownFoldersCOM.cs

View

NativePoint.cs

/Shell1/Interop/NativePoint.cs

View

NativeWindowListener.cs

/Shell1/Interop/NativeWindowListener.cs

View

Ole32.cs

/Shell1/Interop/Ole32.cs

View

PropertySystemNativeMethods.cs

/Shell1/Interop/PropertySystemNativeMethods.cs

View

PropVariant.cs

/Shell1/Interop/PropVariant.cs

View

PropVariantNativeMethods.cs

/Shell1/Interop/PropVariantNativeMethods.cs

View

Shell32.cs

/Shell1/Interop/Shell32.cs

View

ShellItemArray.cs

/Shell1/Interop/ShellItemArray.cs

View

ShellItemImpl.cs

/Shell1/Interop/ShellItemImpl.cs

View

ShellLink.cs

/Shell1/Interop/ShellLink.cs

View

ShellNotifications.cs

/Shell1/Interop/ShellNotifications.cs

View

ShellThumbnail.cs

/Shell1/Interop/ShellThumbnail.cs

View

ShlWapi.cs

/Shell1/Interop/ShlWapi.cs

View

User32.cs

/Shell1/Interop/User32.cs

View

UxTheme.cs

/Shell1/Interop/UxTheme.cs

View

Wallpaper.cs

/Shell1/Interop/Wallpaper.cs

View

WIC.zip

/Shell1/Interop/WIC.zip

View

WindowsThumbnailProvider.cs

/Shell1/Interop/WindowsThumbnailProvider.cs

View

DefinitionOptions.cs

/Shell1/KnownFolders/DefinitionOptions.cs

View

FileSystemKnownFolder.cs

/Shell1/KnownFolders/FileSystemKnownFolder.cs

View

FolderCategory.cs

/Shell1/KnownFolders/FolderCategory.cs

View

FolderProperties.cs

/Shell1/KnownFolders/FolderProperties.cs

View

FoldersIdentifiers.cs

/Shell1/KnownFolders/FoldersIdentifiers.cs

View

FolderTypes.cs

/Shell1/KnownFolders/FolderTypes.cs

View

IKnownFolder.cs

/Shell1/KnownFolders/IKnownFolder.cs

View

KnownFolderHelper.cs

/Shell1/KnownFolders/KnownFolderHelper.cs

View

KnownFolders.cs

/Shell1/KnownFolders/KnownFolders.cs

View

KnownFolderSettings.cs

/Shell1/KnownFolders/KnownFolderSettings.cs

View

NonFileSystemKnownFolder.cs

/Shell1/KnownFolders/NonFileSystemKnownFolder.cs

View

RedirectionCapabilities.cs

/Shell1/KnownFolders/RedirectionCapabilities.cs

View

Annotations.cs

/Shell1/Properties/Annotations.cs

View

AssemblyInfo.cs

/Shell1/Properties/AssemblyInfo.cs

View

Resources.Designer.cs

/Shell1/Properties/Resources.Designer.cs

View

Resources.resx

/Shell1/Properties/Resources.resx

View

Back.bmp

/Shell1/Resources/Back.bmp

View

Forward.bmp

/Shell1/Resources/Forward.bmp

View

NewFolder.bmp

/Shell1/Resources/NewFolder.bmp

View

Up.bmp

/Shell1/Resources/Up.bmp

View

Views.bmp

/Shell1/Resources/Views.bmp

View

IOwnerDataCallback.cs

/Shell1/VirtualGroups/IOwnerDataCallback.cs

View

VirtualGrouping.cs

/Shell1/VirtualGroups/VirtualGrouping.cs

View

SearchCondition.cs

/Shell1/WindowsSearch/SearchCondition.cs

View

SearchConditionFactory.cs

/Shell1/WindowsSearch/SearchConditionFactory.cs

View

ShellSearchFolder.cs

/Shell1/WindowsSearch/ShellSearchFolder.cs

View

SQLite.Interop.dll

/Shell1/x64/SQLite.Interop.dll

View

SQLite.Interop.dll

/Shell1/x86/SQLite.Interop.dll

View

.upgrade-assistant

/Shell1/.upgrade-assistant

View

app.config

/Shell1/app.config

View

AssociationItem.cs

/Shell1/AssociationItem.cs

View

Collumns.cs

/Shell1/Collumns.cs

View

Defaults.cs

/Shell1/Defaults.cs

View

DragDropHelper.cs

/Shell1/DragDropHelper.cs

View

Extensions.cs

/Shell1/Extensions.cs

View

FileFilterComboBox.cs

/Shell1/FileFilterComboBox.cs

View

FileNameComboBox.cs

/Shell1/FileNameComboBox.cs

View

FilesystemTreeViewItem.cs

/Shell1/FilesystemTreeViewItem.cs

View

FilterItem.cs

/Shell1/FilterItem.cs

View

FolderSelectDialog.cs

/Shell1/FolderSelectDialog.cs

View

FolderSettings.cs

/Shell1/FolderSettings.cs

View

GlobalSuppressions.cs

/Shell1/GlobalSuppressions.cs

View

ImageListEx.cs

/Shell1/ImageListEx.cs

View

JunctionPoint.cs

/Shell1/JunctionPoint.cs

View

LeftMarginMultiplierConverter.cs

/Shell1/LeftMarginMultiplierConverter.cs

View

ListViewEditor.cs

/Shell1/ListViewEditor.cs

View

LVItemColor.cs

/Shell1/LVItemColor.cs

View

NavigationLog.cs

/Shell1/NavigationLog.cs

View

ObjectToSeparatorBooleanConverter.cs

/Shell1/ObjectToSeparatorBooleanConverter.cs

View

ObservableCollectionEx.cs

/Shell1/ObservableCollectionEx.cs

View

QueueEx.cs

/Shell1/QueueEx.cs

View

Reflector.cs

/Shell1/Reflector.cs

View

Settings.sqlite

/Shell1/Settings.sqlite

View

Shell.csproj

/Shell1/Shell.csproj

View

Shell.ruleset

/Shell1/Shell.ruleset

View

ShellComboBox.cs

/Shell1/ShellComboBox.cs

View

ShellContextMenu.cs

/Shell1/ShellContextMenu.cs

View

ShellItem.cs

/Shell1/ShellItem.cs

View

ShellItemEqualityComparer.cs

/Shell1/ShellItemEqualityComparer.cs

View

ShellLibrary.cs

/Shell1/ShellLibrary.cs

View

ShellNotificationListener.cs

/Shell1/ShellNotificationListener.cs

View

ShellTreeView.xaml

/Shell1/ShellTreeView.xaml

View

ShellTreeView.xaml.cs

/Shell1/ShellTreeView.xaml.cs

View

ShellTreeViewEx.cs

/Shell1/ShellTreeViewEx.cs

View

ShellTreeViewEx.Designer.cs

/Shell1/ShellTreeViewEx.Designer.cs

View

ShellViewControl.xaml

/Shell1/ShellViewControl.xaml

View

ShellViewControl.xaml.cs

/Shell1/ShellViewControl.xaml.cs

View

ShellViewEx.cs

/Shell1/ShellViewEx.cs

View

ShellViewEx.Designer.cs

/Shell1/ShellViewEx.Designer.cs

View

ShellViewEx.resx

/Shell1/ShellViewEx.resx

View

SyncQueue.cs

/Shell1/SyncQueue.cs

View

SysImageList.cs

/Shell1/SysImageList.cs

View

SystemImageList.cs

/Shell1/SystemImageList.cs

View

ThreadSafeListWithLock.cs

/Shell1/ThreadSafeListWithLock.cs

View

ToolTip.xaml

/Shell1/ToolTip.xaml

View

ToolTip.xaml.cs

/Shell1/ToolTip.xaml.cs

View

TooltipDataTemplateSelector.cs

/Shell1/TooltipDataTemplateSelector.cs

View

TreeViewBase.cs

/Shell1/TreeViewBase.cs

View

TreeViewHelper.cs

/Shell1/TreeViewHelper.cs

View

TreeViewItemBehaviour.cs

/Shell1/TreeViewItemBehaviour.cs

View

Utilities.cs

/Shell1/Utilities.cs

View

video_addorner_wide.png

/Shell1/video_addorner_wide.png

View

video_addorner.png

/Shell1/video_addorner.png

View

WindowActivator.cs

/Shell1/WindowActivator.cs

View