Commit 2872c477: - work on try to speed up the stuff

MainWindow.xaml.cs

+1

/BExplorer/BetterExplorer/MainWindow.xaml.cs

View

#region On Navigated

void ShellListView_Navigated(object sender, NavigatedEventArgs e) {

//return;

this._ProgressTimer.Stop();

this.btnCancelNavigation.Visibility = Visibility.Collapsed;

this.btnGoNavigation.Visibility = Visibility.Visible;

FileSystemListItem.cs

-97+391

/Shell/_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.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 {

#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._Item.ComInterface;

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; set; }

public string DisplayName {

get {

return this.GetDisplayName(SIGDN.NORMALDISPLAY);

}

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

public bool IsNeedRefreshing { get; set; }

private IExtractIconPWFlags _IconType = IExtractIconPWFlags.GIL_PERCLASS;

public IExtractIconPWFlags IconType {

get { return this.IsParentSearchFolder ? IExtractIconPWFlags.GIL_PERINSTANCE : this._Item.GetIconType(); }

get { return this.IsParentSearchFolder ? IExtractIconPWFlags.GIL_PERINSTANCE : this.GetIconType(); }

set { this._IconType = value; }

}

public IntPtr ILPidl => this._Item.ILPidl;

public IExtractIconPWFlags GetIconType() {

if (this.Extension == ".exe" || this.Extension == ".com" || this.Extension == ".bat" || this.Extension == ".msi")

return IExtractIconPWFlags.GIL_PERINSTANCE;

public IntPtr PIDL { get; set; }

if (this.Parent == null)

return 0;

public IntPtr AbsolutePidl => this._Item.AbsolutePidl;

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) };

//pidls[0] = Shell32.ILFindLastID(this.Pidl);

ishellfolder.GetUIObjectOf(

IntPtr.Zero,

1,

pidls,

ref guid,

res,

out result

);

if (result == IntPtr.Zero) {

pidls = null;

//Marshal.ReleaseComObject(ishellfolder);

return IExtractIconPWFlags.GIL_PERCLASS;

}

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

str = new StringBuilder(512);

int index = -1;

IExtractIconPWFlags flags;

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

pidls = null;

//Marshal.ReleaseComObject(ishellfolder);

//Marshal.ReleaseComObject(iextract);

ishellfolder = null;

iextract = null;

str = null;

return flags;

} catch (Exception) {

//if (ishellfolder != null)

//Marshal.ReleaseComObject(ishellfolder);

//if (iextract != null)

// Marshal.ReleaseComObject(iextract);

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 {

uint attr;

IntPtr pidl;

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

return pidl;

}

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

public int ShieldedIconIndex { get; set; }

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

public bool IsIconLoaded { get; set; }

public string ParsingName { get; set; }

public string ParsingName {

get {

return this.GetDisplayName(SIGDN.DESKTOPABSOLUTEPARSING);

}

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

public string Extension { get; set; }

public string Extension {

get {

return Path.GetExtension(this.ParsingName);

}

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

public string FileSystemPath { get; set; }

public string FileSystemPath {

get {

return this.GetDisplayName(SIGDN.FILESYSPATH);

}

/// <summary>

/// Returns true if folder can be browsed

/// </summary>

public bool IsBrowsable => this._Item.IsBrowsable;

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

[System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]

private bool COM_Attribute_Check(SFGAO Check) {

var comObject = this.ComInterface;

SFGAO sfgao;

comObject.GetAttributes(Check, out sfgao);

Marshal.FinalReleaseComObject(comObject);

return (sfgao & Check) != 0;

}

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

public bool IsFolder { get; set; }

public bool 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 bool HasSubFolders => this._Item.HasSubFolders;

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

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

public bool IsHidden { get; set; }

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

public bool IsFileSystem { get; set; }

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

public bool IsNetworkPath { get; set; }

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

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

public bool IsDrive { get; set; }

public bool IsDrive {

get {

try {

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

} catch {

return false;

}

public bool IsShared { get; set; }

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

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

public bool IsParentSearchFolder { get; set; }

public IShellFolder IFolder { get; set; }

private void Initialize_Helper(ShellItem folder, IntPtr lvHandle, int index) {

this.DisplayName = folder.DisplayName;

this.ParsingName = folder.ParsingName;

this.ItemIndex = index;

this.PIDL = folder.Pidl;

//this.IFolder = folder.GetIShellFolder();

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

this.ParentPIDL = IntPtr.Zero;

this.EnumPIDL = folder;

//this.ComInterface = Shell32.SHCreateItemFromIDList(this.EnumPIDL, typeof(IShellItem).GUID);

this.ParentHandle = lvHandle;

this.IsFileSystem = folder.IsFileSystem;

this.IsNetworkPath = folder.IsNetworkPath;

this.Extension = folder.Extension;

this.IsDrive = folder.IsDrive;

this.IsHidden = folder.IsHidden;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

this.IsShared = folder.IsShared;

//this.IconType = folder.IconType;

this.IsFolder = folder.IsFolder;

this.IsSearchFolder = folder.IsSearchFolder;

this._Item = folder;

//this._IconType = folder.GetIconType();

}

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

var folder = new ShellItem(parent, pidl);

this.DisplayName = folder.DisplayName;

this.ParsingName = folder.ParsingName;

this.ItemIndex = index;

this.PIDL = folder.Pidl;

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

this.ParentPIDL = parent;

this.EnumPIDL = pidl;

//this.ComInterface = Shell32.SHCreateItemWithParent(this.ParentPIDL, null, this.EnumPIDL, typeof(IShellItem).GUID);

this.ParentHandle = lvHandle;

this.IsFileSystem = folder.IsFileSystem;

this.IsNetworkPath = folder.IsNetworkPath;

this.Extension = folder.Extension;

this.IsDrive = folder.IsDrive;

this.IsHidden = folder.IsHidden;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

this.IsShared = folder.IsShared;

//this.IconType = folder.IconType;

this.IsFolder = folder.IsFolder;

this.IsSearchFolder = folder.IsSearchFolder;

this._Item = folder;

//this._IconType = folder.GetIconType();

}

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

Initialize_Helper(new ShellItem(pidl), lvHandle, index);

Initialize_Helper(pidl, lvHandle, index);

}

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

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

Initialize_Helper2(parent, pidl, lvHandle, index);

}

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

Initialize_Helper(item, lvHandle, index);

Initialize_Helper(item.Pidl, lvHandle, index);

this.searchFolder = item;

}

public void Initialize(IntPtr lvHandle, string path, int index) {

var item = new ShellItem(path);

this.DisplayName = item.DisplayName;

this.ParsingName = item.ParsingName;

this.ItemIndex = index;

this.ParentPIDL = IntPtr.Zero;

this.EnumPIDL = Shell32.SHGetIDListFromObject(Shell32.SHCreateItemFromParsingName(path, IntPtr.Zero, typeof(IShellItem).GUID));

this.ParentHandle = lvHandle;

this.IsFileSystem = item.IsFileSystem;

this.IsNetworkPath = item.IsNetworkPath;

this.Extension = item.Extension;

this.IsDrive = item.IsDrive;

this.IsHidden = item.IsHidden;

this.OverlayIconIndex = -1;

this.ShieldedIconIndex = -1;

this.PIDL = item.Pidl;

//this.IFolder = item.GetIShellFolder();

//this.HasSubFolders = item.HasSubFolders;

this.IsShared = item.IsShared;

//this.IconType = item.IconType;

this.IsFolder = item.IsFolder;

this.IsSearchFolder = item.IsSearchFolder;

this._Item = item;

this._IconType = item.GetIconType();

//item.Dispose();

} //TODO: Find out why this does nothing with the ShellViewItem that it creates

while (enumId.Next(1, out pidl, out count) == HResult.S_OK) {

var fsi = new FileSystemListItem();

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

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

fsiList.Add(fsi);

Shell32.ILFree(pidl);

//if (this.IsSearchFolder)

public Size IconSize { get; set; }

public IEnumerable<IntPtr> GetItemsForCount(Boolean isEnumHidden) {

IShellFolder folder = this.GetIShellFolder();

if (folder == null)

yield return IntPtr.Zero;

HResult navRes;

SHCONTF flags = SHCONTF.FOLDERS | SHCONTF.FASTITEMS |

SHCONTF.NONFOLDERS | SHCONTF.ENABLE_ASYNC | SHCONTF.INIT_ON_FIRST_NEXT;

if (isEnumHidden) {

flags = SHCONTF.FOLDERS | SHCONTF.INCLUDEHIDDEN | SHCONTF.INCLUDESUPERHIDDEN | SHCONTF.FASTITEMS |

SHCONTF.NONFOLDERS | SHCONTF.ENABLE_ASYNC | SHCONTF.INIT_ON_FIRST_NEXT;

}

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

this.NavigationStatus = navRes;

uint count;

IntPtr pidl;

if (enumId == null) {

yield break;

}

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

var i = 0;

//var parentItem = new ShellItem(this._Item.Pidl); //this._Item;//this.IsSearchFolder ? this._Item : new ShellItem(this.ParsingName.ToShellParsingName());

while (result == HResult.S_OK) {

yield return pidl;

Shell32.ILFree(pidl);

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

}

if (result != HResult.S_FALSE) {

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

}

//parentItem.Dispose();

yield break;

}

public IEnumerator<IListItemEx> GetEnumerator() {

IShellFolder folder = this.GetIShellFolder();

if (folder == null) yield return null;

if (folder == null)

yield return null;

HResult navRes;

IEnumIDList enumId = ShellItem.GetIEnumIDList(folder, SHCONTF.FOLDERS | SHCONTF.INCLUDEHIDDEN | SHCONTF.INCLUDESUPERHIDDEN | SHCONTF.FASTITEMS |

SHCONTF.NONFOLDERS | SHCONTF.ENABLE_ASYNC | SHCONTF.INIT_ON_FIRST_NEXT, out navRes);

while (result == HResult.S_OK) {

var fsi = new FileSystemListItem();

try {

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

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

} catch {

continue;

}

fsi.IsParentSearchFolder = this.IsSearchFolder;

yield return fsi;

Shell32.ILFree(pidl);

//Shell32.ILFree(pidl);

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

}

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

//public PropVariant GetPropertyValue(PROPERTYKEY pkey, Type type) => this._Item.GetPropertyValue(pkey, type);

public PropVariant GetPropertyValue(PROPERTYKEY pkey, Type type) => this._Item.GetPropertyValue(pkey);

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);

return pvar;

}

public System.Drawing.Bitmap Thumbnail(int size, ShellThumbnailFormatOption format, ShellThumbnailRetrievalOption source) =>

this._Item.GetShellThumbnail(size, format, source);

this._Item?.GetShellThumbnail(size, format, source);

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

//if (this.IsSearchFolder)

// this._Item.ComInterface = this.searchFolder.m_SearchComInterface;

//if (this._Item == null)

// return null;

//this._Item.Thumbnail.CurrentSize = new System.Windows.Size(size, size);

//this._Item.Thumbnail.RetrievalOption = source;

//this._Item.Thumbnail.FormatOption = format;

//return this._Item.Thumbnail.BitmapSource;

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

this._Item.Thumbnail.CurrentSize = new System.Windows.Size(size, size);

this._Item.Thumbnail.RetrievalOption = source;

this._Item.Thumbnail.FormatOption = format;

return this._Item.Thumbnail.BitmapSource;

// return a System.Media.Imaging.BitmapSource

// Use interop to create a BitmapSource from hBitmap.

if (hBitmap != IntPtr.Zero) {

BitmapSource returnValue = Imaging.CreateBitmapSourceFromHBitmap(

hBitmap,

IntPtr.Zero,

System.Windows.Int32Rect.Empty,

BitmapSizeOptions.FromEmptyOptions()).Clone();

// delete HBitmap to avoid memory leaks

Gdi32.DeleteObject(hBitmap);

return returnValue;

}

return null;

}

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

public bool IsSearchFolder { get; set; }

public bool IsSearchFolder {

get {

try {

return (!ParsingName.StartsWith("::") && !IsFileSystem && !ParsingName.StartsWith(@"\\") && !ParsingName.Contains(":\\")) || ParsingName.EndsWith(".search-ms");

} catch {

return false;

}

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

public IListItemEx Parent {

get {

if (this.IsSearchFolder || this._Item.Parent == null) return null;

IShellItem item;

var comObject = this.ComInterface;

HResult result = comObject.GetParent(out item);

Marshal.ReleaseComObject(comObject);

if (result == HResult.S_OK) {

var parent = new FileSystemListItem();

parent.Initialize(this.ParentHandle, this._Item.Parent.Pidl, 0);

parent.Initialize(this.ParentHandle, Shell32.SHGetIDListFromObject(item), 0);

return parent;

} else if (result == HResult.MK_E_NOOBJECT) {

return null;

} else {

Marshal.ThrowExceptionForHR((int)result);

return null;

}

public IShellFolder GetIShellFolder() => this._Item.GetIShellFolder();

public IShellFolder GetIShellFolder() {

IntPtr res;

try {

var comObject = this.ComInterface;

comObject.BindToHandler(IntPtr.Zero, BHID.SFObject, typeof(IShellFolder).GUID, out res); //HResult result =

var iShellFolder = (IShellFolder)Marshal.GetTypedObjectForIUnknown(res, typeof(IShellFolder));

Marshal.ReleaseComObject(comObject);

return iShellFolder;

} catch {

return null;

}

public bool IsLink => this._Item.IsLink;

IListItemEx.cs

-14+21

/Shell/_Plugin Interfaces/IListItemEx.cs

View

public interface IListItemEx : IEnumerable<IListItemEx>, IDisposable, 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; }

IListItemEx Parent { get; }

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

String DisplayName { get; set; }

String DisplayName { get; }

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

String Extension { get; set; }

String Extension { get; }

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

String FileSystemPath { get; set; }

String FileSystemPath { get; }

Int32 ItemIndex { get; set; }

IntPtr ILPidl { get; }

IntPtr PIDL { get; set; }

IntPtr PIDL { get; }

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

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

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

Boolean IsIconLoaded { get; set; }

Boolean IsFileSystem { get; set; }

Boolean IsFileSystem { get; }

Boolean IsNetworkPath { get; set; }

Boolean IsNetworkPath { get; }

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

Boolean IsDrive { get; set; }

Boolean IsDrive { get; }

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

Boolean IsSearchFolder { get; set; }

Boolean IsSearchFolder { get; }

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

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

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

BitmapSource BitmapSource { get; }

String ParsingName { get; set; }

String ParsingName { get; }

Boolean IsBrowsable { get; }

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

Boolean IsFolder { get; set; }

Boolean IsFolder { get; }

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

Boolean HasSubFolders { get; }

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

Boolean IsHidden { get; set; }

Boolean IsHidden { get; }

Boolean IsLink { get; }

Boolean IsShared { get; set; }

Boolean IsShared { get; }

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

Boolean IsParentSearchFolder { get; set; }

void Initialize(IntPtr lvHandle, IntPtr pidl);

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

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

IListItemEx Clone(Boolean isHardCloning = false);

/// <param name="isEnumHidden">Should we include the hidden items?</param>

/// <returns></returns>

IListItemEx[] GetSubItems(Boolean isEnumHidden);

IEnumerable<IntPtr> GetItemsForCount(Boolean isEnumHidden);

IShellFolder GetIShellFolder();

HResult NavigationStatus { get; set; }

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

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

Boolean RefreshThumb(int iconSize, out WTS_CACHEFLAGS flags);

Extensions.cs

-1+57

/Shell/Extensions.cs

View

return false;

}

else {

return checkedItem?.Parent?.Equals(currentFolder) == true;

return checkedItem?.Parent?.ParsingName == currentFolder.ParsingName;

}

public static IOrderedEnumerable<IListItemEx> SetSortCollumn(this IEnumerable<IListItemEx> items, ShellView view, Boolean isReorder, Collumns column, SortOrder order, Boolean reverseOrder = true) {

if (column == null) {

column = view.Collumns.FirstOrDefault();

}

try {

IOrderedEnumerable<IListItemEx> result = null;

var itemsArray = items;

//var selectedItems = this.SelectedItems.ToArray();

if (column.ID == view.LastSortedColumnId && reverseOrder) {

// Reverse the current sort direction for this column.

view.LastSortOrder = view.LastSortOrder == SortOrder.Ascending ? SortOrder.Descending : SortOrder.Ascending;

} else {

// Set the column number that is to be sorted; default to ascending.

view.LastSortedColumnId = column.ID;

view.LastSortOrder = order;

}

if (isReorder) {

var itemsQuery = itemsArray.Where(w => view.ShowHidden || !w.IsHidden).OrderByDescending(o => o.IsFolder);

if (column.CollumnType != typeof(String)) {

if (order == SortOrder.Ascending) {

result = itemsQuery.ThenBy(o => o.GetPropertyValue(column.pkey, typeof(String)).Value ?? "1");

} else {

result = itemsQuery.ThenByDescending(o => o.GetPropertyValue(column.pkey, typeof(String)).Value ?? "1");

}

} else {

if (order == SortOrder.Ascending) {

result = itemsQuery.ThenBy(o => o.GetPropertyValue(column.pkey, typeof(String)).Value == null ? "1" : o.GetPropertyValue(column.pkey, typeof(String)).Value.ToString(), NaturalStringComparer.Default);

} else {

result = itemsQuery.ThenByDescending(o => o.GetPropertyValue(column.pkey, typeof(String)).Value == null ? "1" : o.GetPropertyValue(column.pkey, typeof(String)).Value.ToString(),

NaturalStringComparer.Default);

}

var i = 0;

}

var colIndexReal = view.Collumns.IndexOf(view.Collumns.FirstOrDefault(w => w.ID == view.LastSortedColumnId));

if (colIndexReal > -1) {

User32.SendMessage(view.LVHandle, MSG.LVM_SETSELECTEDCOLUMN, colIndexReal, 0);

view.SetSortIcon(colIndexReal, order);

} else {

User32.SendMessage(view.LVHandle, MSG.LVM_SETSELECTEDCOLUMN, -1, 0);

}

//if (!this.IsRenameInProgress) {

// this.SelectItems(selectedItems);

//}

return result;

} catch {

return null;

}

ImageListEx.cs

-7+7

/Shell/ImageListEx.cs

View

else

this._Large.DrawIcon(hdc, this._SharedIconIndex, new Point(iconBounds.Right - 30, iconBounds.Bottom - 32));

}

var badge = this.GetBadgeForPath(sho.ParsingName);

IListItemEx badge = this.GetBadgeForPath(sho.ParsingName);

if (badge != null) {

var badgeIco = badge.GetHBitmap(this._CurrentSize, false);

Gdi32.ConvertPixelByPixel(badgeIco, out width, out height);

this._Small.DrawIcon(hdc, this._SharedIconIndex, new Point(iconBounds.Right - 9, iconBounds.Bottom - 16));

}

var badge = this.GetBadgeForPath(sho.ParsingName);

IListItemEx badge = this.GetBadgeForPath(sho.ParsingName);

if (badge != null) {

var badgeIco = badge.GetHBitmap(16, false);

Gdi32.ConvertPixelByPixel(badgeIco, out width, out height);

Int32 overlayIndex = 0;

this._Small.GetIconIndexWithOverlay(sho.PIDL, out overlayIndex);

shoTemp.OverlayIconIndex = overlayIndex;

if (sho.IsFolder && sho.IsShared) shoTemp.IsShared = true;

//if (sho.IsFolder && sho.IsShared) shoTemp.IsShared = true;

if (overlayIndex > 0) {

if (!this._RedrawQueue.Contains(index))

this._RedrawQueue.Enqueue(index);

var sho = this._ShellViewEx.Items[index];

if (!sho.IsIconLoaded) {

try {

var temp = FileSystemListItem.ToFileSystemItem(sho.ParentHandle, sho.ParsingName.ToShellParsingName());

var icon = temp.GetHBitmap(this._CurrentSize, false, true);

//var temp = FileSystemListItem.ToFileSystemItem(sho.ParentHandle, sho.ParsingName.ToShellParsingName());

var icon = sho.GetHBitmap(this._CurrentSize, false, true);

var shieldOverlay = 0;

if (sho.ShieldedIconIndex == -1) {

if ((temp.GetShield() & IExtractIconPWFlags.GIL_SHIELD) != 0) shieldOverlay = this._ShieldIconIndex;

if ((sho.GetShield() & IExtractIconPWFlags.GIL_SHIELD) != 0) shieldOverlay = this._ShieldIconIndex;

sho.ShieldedIconIndex = shieldOverlay;

}

private void _RedrawingThreadRun() {

while (true) {

ResetEvent?.WaitOne();

Application.DoEvents();

//Application.DoEvents();

var index = this._RedrawQueue.Dequeue();

if (User32.SendMessage(this._ShellViewEx.LVHandle, Interop.MSG.LVM_ISITEMVISIBLE, index, 0) == IntPtr.Zero) continue;

this._ShellViewEx.RedrawItem(index);

ShellItem.cs

+2

/Shell/ShellItem.cs

View

}

public static IEnumIDList GetIEnumIDList(IShellFolder folder, SHCONTF flags, out HResult navResult) {

navResult = HResult.S_OK;

if (folder == null) return null;

IEnumIDList result;

var res = folder.EnumObjects(IsCareForMessageHandle ? MessageHandle : IntPtr.Zero, flags, out result);

navResult = res;

ShellTreeViewEx.cs

/Shell/ShellTreeViewEx.cs

View

ShellViewEx.cs

/Shell/ShellViewEx.cs

View



	BExplorer/BetterExplorer
	MainWindow.xaml.cs
	Shell
	_Plugin Interfaces
	FileSystemListItem.cs
	IListItemEx.cs
	Extensions.cs
	ImageListEx.cs
	ShellItem.cs
	ShellTreeViewEx.cs
	ShellViewEx.cs