Commit 292fb149: Clean up and fixed part of Undo Closing Tabs

AsyncContext.cs

-33+15

/BEHelper/AsyncContext.cs

View

using System;

using System.Collections.Generic;

using System.Linq;

using System.Threading;

namespace BEHelper

{

public class AsyncContext : IAsyncContext

{

namespace BEHelper {

public class AsyncContext : IAsyncContext {

private readonly SynchronizationContext _asynchronizationContext;

///

/// Constructor - Save the context of the creator/current thread

///

public AsyncContext()

{

_asynchronizationContext = SynchronizationContext.Current;

}

/// <summary>Get the context of the creator thread</summary>

public SynchronizationContext AsynchronizationContext { get { return _asynchronizationContext; } }

///

/// Get the context of the creator thread

///

public SynchronizationContext AsynchronizationContext

{

get { return _asynchronizationContext; }

}

/// <summary>Test if the current executing thread is the creator thread</summary>

public bool IsAsyncCreatorThread { get { return SynchronizationContext.Current == AsynchronizationContext; } }

///

/// Test if the current executing thread is the creator thread

///

public bool IsAsyncCreatorThread

{

get { return SynchronizationContext.Current == AsynchronizationContext; }

/// <summary>Constructor - Save the context of the creator/current thread</summary>

public AsyncContext() {

_asynchronizationContext = SynchronizationContext.Current;

}

///

/// <summary>

/// Post a call to the specified method on the creator thread

///

/// Method that is to be called

/// Method parameter/state

public void AsyncPost(SendOrPostCallback callback, object state)

{

/// </summary>

/// <param name="callback">Method that is to be called</param>

/// <param name="state">Method parameter/state</param>

public void AsyncPost(SendOrPostCallback callback, object state) {

if (IsAsyncCreatorThread)

callback(state); // Call the method directly

else

AsyncObservableCollection.cs

-13+6

/BEHelper/AsyncObservableCollection.cs

View

using System.Linq;

using System.Threading;

namespace BEHelper

{

public class AsyncObservableCollection<T> : ObservableCollection<T>, IAsyncContext

{

namespace BEHelper {

public class AsyncObservableCollection<T> : ObservableCollection<T>, IAsyncContext {

private readonly AsyncContext _asyncContext = new AsyncContext();

#region IAsyncContext Members

#endregion

public AsyncObservableCollection() { }

public AsyncObservableCollection(IEnumerable<T> list) : base(list) { }

public AsyncObservableCollection(List<T> list) : base(list) { }

protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)

{

protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) {

AsyncPost(RaiseCollectionChanged, e);

}

private void RaiseCollectionChanged(object param)

{

private void RaiseCollectionChanged(object param) {

base.OnCollectionChanged((NotifyCollectionChangedEventArgs)param);

}

protected override void OnPropertyChanged(PropertyChangedEventArgs e)

{

protected override void OnPropertyChanged(PropertyChangedEventArgs e) {

AsyncPost(RaisePropertyChanged, e);

}

private void RaisePropertyChanged(object param)

{

private void RaisePropertyChanged(object param) {

base.OnPropertyChanged((PropertyChangedEventArgs)param);

}

IAsyncContext.cs

-4+2

/BEHelper/IAsyncContext.cs

View

using System.Linq;

using System.Threading;

namespace BEHelper

{

public interface IAsyncContext

{

namespace BEHelper {

public interface IAsyncContext {

/// <summary>

/// Get the context of the creator thread

/// </summary>

NoFlickerWindowsFormsHost.cs

-8+4

/BEHelper/NoFlickerWindowsFormsHost.cs

View

using System.Windows;

using System.Windows.Forms.Integration;

namespace BEHelper

{

public class NoFlickerWindowsFormsHost : WindowsFormsHost

{

namespace BEHelper {

public class NoFlickerWindowsFormsHost : WindowsFormsHost {

const uint SWP_NOZORDER = 0x0004;

const uint SWP_NOACTIVATE = 0x0010;

const uint SWP_ASYNCWINDOWPOS = 0x4000;

extern static bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

protected override void OnWindowPositionChanged(Rect rcBoundingBox)

{

if (Handle != IntPtr.Zero)

{

protected override void OnWindowPositionChanged(Rect rcBoundingBox) {

if (Handle != IntPtr.Zero) {

SetWindowPos(Handle,

IntPtr.Zero,

(int)rcBoundingBox.X,

TransPicBox.cs

-53+33

/BEHelper/TransPicBox.cs

View

using System;

using System.Collections.Generic;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace BEHelper

{

public class TransPicBox : Control

{

public TransPicBox()

{

namespace BEHelper {

public class TransPicBox : Control {

public Bitmap Image { get; set; }

#region Constructors

public TransPicBox() {

this.DoubleBuffered = true;

this.SetStyle(ControlStyles.UserPaint |

ControlStyles.AllPaintingInWmPaint |

ControlStyles.ResizeRedraw |

ControlStyles.ContainerControl |

ControlStyles.OptimizedDoubleBuffer |

ControlStyles.SupportsTransparentBackColor

, true);

ControlStyles.SupportsTransparentBackColor,

true);

}

public TransPicBox(string text)

: base(text)

{

public TransPicBox(string text)

: base(text) {

}

public TransPicBox(string text, int left, int top, int width, int height)

: base(text, left, top, width, height)

{

public TransPicBox(string text, int left, int top, int width, int height)

: base(text, left, top, width, height) {

}

public TransPicBox(Control parent, string text)

: base(parent, text)

{

public TransPicBox(Control parent, string text)

: base(parent, text) {

}

public TransPicBox(Control parent, string text, int left, int top, int width, int height)

: base(parent, text, left, top, width, height)

{

public TransPicBox(Control parent, string text, int left, int top, int width, int height)

: base(parent, text, left, top, width, height) {

}

#endregion

private static Bitmap resizeImage(Bitmap imgToResize, Size size)

{

int sourceWidth = imgToResize.Width;

int sourceHeight = imgToResize.Height;

float nPercent = 0;

float nPercentW = 0;

float nPercentH = 0;

private static Bitmap resizeImage(Bitmap imgToResize, Size size) {

float nPercent = 0, nPercentW = 0, nPercentH = 0;

int sourceWidth = imgToResize.Width, sourceHeight = imgToResize.Height;

nPercentW = ((float)size.Width / (float)sourceWidth);

nPercentH = ((float)size.Height / (float)sourceHeight);

if (nPercentH < nPercentW)

nPercent = nPercentH;

else

nPercent = nPercentW;

nPercent = nPercentH < nPercentW ? nPercentH : nPercentW;

int destWidth = (int)(sourceWidth * nPercent);

int destHeight = (int)(sourceHeight * nPercent);

return b;

}

public Bitmap Image { get; set; }

protected override CreateParams CreateParams

{

get

{

protected override CreateParams CreateParams {

get {

CreateParams cp = base.CreateParams;

cp.ExStyle |= 0x02000000;

return cp;

}

protected override void OnResize(EventArgs e)

{

protected override void OnResize(EventArgs e) {

this.Update();

base.OnResize(e);

}

protected override void OnSizeChanged(EventArgs e)

{

protected override void OnSizeChanged(EventArgs e) {

this.Update();

base.OnSizeChanged(e);

}

protected override void OnPaint(PaintEventArgs e)

{

if (this.Image != null)

{

protected override void OnPaint(PaintEventArgs e) {

if (this.Image != null) {

var res = resizeImage(this.Image, this.ClientSize);

e.Graphics.FillRectangle(SystemBrushes.Window, this.ClientRectangle);

e.Graphics.DrawImage(res, (this.Size.Width - res.Width) / 2, (this.Size.Height - res.Height) / 2);

}

protected override void OnPaintBackground(PaintEventArgs e)

{

protected override void OnPaintBackground(PaintEventArgs e) {

}

NtfsUsnJournal.cs

+1022

/BExplorer/BetterExplorer/__Obsolete/MFTScanning/NtfsUsnJournal.cs

View

Displayed content is truncated due to maximum viewable content limit.

// NtfsUsnJournal.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.ComponentModel;

using System.Runtime.InteropServices;

using Microsoft.Win32.SafeHandles;

namespace BetterExplorer {

[Obsolete("Never used", true)]

public class NtfsUsnJournal : IDisposable {

#region enum(s)

public enum UsnJournalReturnCode {

INVALID_HANDLE_VALUE = -1,

USN_JOURNAL_SUCCESS = 0,

ERROR_INVALID_FUNCTION = 1,

ERROR_FILE_NOT_FOUND = 2,

ERROR_PATH_NOT_FOUND = 3,

ERROR_TOO_MANY_OPEN_FILES = 4,

ERROR_ACCESS_DENIED = 5,

ERROR_INVALID_HANDLE = 6,

ERROR_INVALID_DATA = 13,

ERROR_HANDLE_EOF = 38,

ERROR_NOT_SUPPORTED = 50,

ERROR_INVALID_PARAMETER = 87,

ERROR_JOURNAL_DELETE_IN_PROGRESS = 1178,

USN_JOURNAL_NOT_ACTIVE = 1179,

ERROR_JOURNAL_ENTRY_DELETED = 1181,

ERROR_INVALID_USER_BUFFER = 1784,

USN_JOURNAL_INVALID = 17001,

VOLUME_NOT_NTFS = 17003,

INVALID_FILE_REFERENCE_NUMBER = 17004,

USN_JOURNAL_ERROR = 17005

}

public enum UsnReasonCode {

USN_REASON_DATA_OVERWRITE = 0x00000001,

USN_REASON_DATA_EXTEND = 0x00000002,

USN_REASON_DATA_TRUNCATION = 0x00000004,

USN_REASON_NAMED_DATA_OVERWRITE = 0x00000010,

USN_REASON_NAMED_DATA_EXTEND = 0x00000020,

USN_REASON_NAMED_DATA_TRUNCATION = 0x00000040,

USN_REASON_FILE_CREATE = 0x00000100,

USN_REASON_FILE_DELETE = 0x00000200,

USN_REASON_EA_CHANGE = 0x00000400,

USN_REASON_SECURITY_CHANGE = 0x00000800,

USN_REASON_RENAME_OLD_NAME = 0x00001000,

USN_REASON_RENAME_NEW_NAME = 0x00002000,

USN_REASON_INDEXABLE_CHANGE = 0x00004000,

USN_REASON_BASIC_INFO_CHANGE = 0x00008000,

USN_REASON_HARD_LINK_CHANGE = 0x00010000,

USN_REASON_COMPRESSION_CHANGE = 0x00020000,

USN_REASON_ENCRYPTION_CHANGE = 0x00040000,

USN_REASON_OBJECT_ID_CHANGE = 0x00080000,

USN_REASON_REPARSE_POINT_CHANGE = 0x00100000,

USN_REASON_STREAM_CHANGE = 0x00200000,

USN_REASON_CLOSE = -1

}

#endregion

#region private member variables

private DriveInfo _driveInfo = null;

private uint _volumeSerialNumber;

private IntPtr _usnJournalRootHandle;

private bool bNtfsVolume;

#endregion

#region properties

private static TimeSpan _elapsedTime;

public static TimeSpan ElapsedTime {

get { return _elapsedTime; }

}

public string VolumeName {

get { return _driveInfo.Name; }

}

public long AvailableFreeSpace {

get { return _driveInfo.AvailableFreeSpace; }

}

public long TotalFreeSpace {

get { return _driveInfo.TotalFreeSpace; }

}

public string Format {

get { return _driveInfo.DriveFormat; }

}

public DirectoryInfo RootDirectory {

get { return _driveInfo.RootDirectory; }

}

public long TotalSize {

get { return _driveInfo.TotalSize; }

}

public string VolumeLabel {

get { return _driveInfo.VolumeLabel; }

}

public uint VolumeSerialNumber {

get { return _volumeSerialNumber; }

}

#endregion

#region constructor(s)

/// <summary>

/// Constructor for NtfsUsnJournal class. If no exception is thrown, _usnJournalRootHandle and

/// _volumeSerialNumber can be assumed to be good. If an exception is thrown, the NtfsUsnJournal

/// object is not usable.

/// </summary>

/// <param name="driveInfo">DriveInfo object that provides access to information about a volume</param>

/// <remarks>

/// An exception thrown if the volume is not an 'NTFS' volume or

/// if GetRootHandle() or GetVolumeSerialNumber() functions fail.

/// Each public method checks to see if the volume is NTFS and if the _usnJournalRootHandle is

/// valid. If these two conditions aren't met, then the public function will return a UsnJournalReturnCode

/// error.

/// </remarks>

public NtfsUsnJournal(DriveInfo driveInfo) {

DateTime start = DateTime.Now;

_driveInfo = driveInfo;

if (0 == string.Compare(_driveInfo.DriveFormat, "ntfs", true)) {

bNtfsVolume = true;

IntPtr rootHandle = IntPtr.Zero;

UsnJournalReturnCode usnRtnCode = GetRootHandle(out rootHandle);

if (usnRtnCode == UsnJournalReturnCode.USN_JOURNAL_SUCCESS) {

_usnJournalRootHandle = rootHandle;

usnRtnCode = GetVolumeSerialNumber(_driveInfo, out _volumeSerialNumber);

if (usnRtnCode != UsnJournalReturnCode.USN_JOURNAL_SUCCESS) {

_elapsedTime = DateTime.Now - start;

throw new Win32Exception((int)usnRtnCode);

}

else {

_elapsedTime = DateTime.Now - start;

throw new Win32Exception((int)usnRtnCode);

}

else {

_elapsedTime = DateTime.Now - start;

throw new Exception(string.Format("{0} is not an 'NTFS' volume.", _driveInfo.Name));

}

_elapsedTime = DateTime.Now - start;

}

#endregion

#region public methods

/// <summary>

/// CreateUsnJournal() creates a usn journal on the volume. If a journal already exists this function

/// will adjust the MaximumSize and AllocationDelta parameters of the journal if the requested size

/// is larger.

/// </summary>

/// <param name="maxSize">maximum size requested for the UsnJournal</param>

/// <param name="allocationDelta">when space runs out, the amount of additional

/// space to allocate</param>

/// <param name="elapsedTime">The TimeSpan object indicating how much time this function

/// took</param>

/// <returns>a UsnJournalReturnCode

/// USN_JOURNAL_SUCCESS CreateUsnJournal() function succeeded.

/// VOLUME_NOT_NTFS volume is not an NTFS volume.

/// INVALID_HANDLE_VALUE NtfsUsnJournal object failed initialization.

/// USN_JOURNAL_NOT_ACTIVE usn journal is not active on volume.

/// ERROR_ACCESS_DENIED accessing the usn journal requires admin rights, see remarks.

/// ERROR_INVALID_FUNCTION error generated by DeviceIoControl() call.

/// ERROR_FILE_NOT_FOUND error generated by DeviceIoControl() call.

/// ERROR_PATH_NOT_FOUND error generated by DeviceIoControl() call.

/// ERROR_TOO_MANY_OPEN_FILES error generated by DeviceIoControl() call.

/// ERROR_INVALID_HANDLE error generated by DeviceIoControl() call.

/// ERROR_INVALID_DATA error generated by DeviceIoControl() call.

/// ERROR_NOT_SUPPORTED error generated by DeviceIoControl() call.

/// ERROR_INVALID_PARAMETER error generated by DeviceIoControl() call.

/// ERROR_JOURNAL_DELETE_IN_PROGRESS usn journal delete is in progress.

/// ERROR_INVALID_USER_BUFFER error generated by DeviceIoControl() call.

/// USN_JOURNAL_ERROR unspecified usn journal error.

/// </returns>

/// <remarks>

/// If function returns ERROR_ACCESS_DENIED you need to run application as an Administrator.

/// </remarks>

public UsnJournalReturnCode

CreateUsnJournal(ulong maxSize, ulong allocationDelta) {

UsnJournalReturnCode usnRtnCode = UsnJournalReturnCode.VOLUME_NOT_NTFS;

DateTime startTime = DateTime.Now;

if (bNtfsVolume) {

if (_usnJournalRootHandle.ToInt32() != Win32Api.INVALID_HANDLE_VALUE) {

usnRtnCode = UsnJournalReturnCode.USN_JOURNAL_SUCCESS;

UInt32 cb;

Win32Api.CREATE_USN_JOURNAL_DATA cujd = new Win32Api.CREATE_USN_JOURNAL_DATA();

cujd.MaximumSize = maxSize;

cujd.AllocationDelta = allocationDelta;

int sizeCujd = Marshal.SizeOf(cujd);

IntPtr cujdBuffer = Marshal.AllocHGlobal(sizeCujd);

Win32Api.ZeroMemory(cujdBuffer, sizeCujd);

Marshal.StructureToPtr(cujd, cujdBuffer, true);

bool fOk = Win32Api.DeviceIoControl(

_usnJournalRootHandle,

Win32Api.FSCTL_CREATE_USN_JOURNAL,

cujdBuffer,

sizeCujd,

IntPtr.Zero,

0,

out cb,

IntPtr.Zero);

if (!fOk) {

usnRtnCode = ConvertWin32ErrorToUsnError((Win32Api.GetLastErrorEnum)Marshal.GetLastWin32Error());

}

Marshal.FreeHGlobal(cujdBuffer);

}

else {

usnRtnCode = UsnJournalReturnCode.INVALID_HANDLE_VALUE;

}

_elapsedTime = DateTime.Now - startTime;

return usnRtnCode;

}

/// <summary>

/// DeleteUsnJournal() deletes a usn journal on the volume. If no usn journal exists, this

/// function simply returns success.

/// </summary>

/// <param name="journalState">USN_JOURNAL_DATA object for this volume</param>

/// <param name="elapsedTime">The TimeSpan object indicating how much time this function

/// took</param>

/// <returns>a UsnJournalReturnCode

/// USN_JOURNAL_SUCCESS DeleteUsnJournal() function succeeded.