private void BtnOk_Click(object sender, EventArgs e)
{
DialogResult dlgRes = MessageBox.Show("Are you sure you want to permanently delete these files?", "Managed Disk Cleanup", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2);
if (dlgRes == DialogResult.Yes)
{
int removedCount = 0;
for (int i = 0; i < LvwHandlers.Items.Count; i++)
{
CleanupHandler cHandler = Preferences.CleanupHandlers[(int)LvwHandlers.Items[i].Tag - removedCount];
if (!BtnElevate.Visible)
{
cHandler.StateFlag = LvwHandlers.Items[i].Checked;
Api.UpdateHandlerStateFlag(cHandler);
}
// Get rid of handlers that we won't need early on
if (!LvwHandlers.Items[i].Checked)
{
try { cHandler.Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(cHandler.Instance);
Preferences.CleanupHandlers.Remove(cHandler);
removedCount++;
}
}
Api.DeactivateHandlers(Preferences.CleanupHandlers);
Preferences.ProcessPurge = true;
Close();
}
}
public Scanner()
{
InitializeComponent();
Icon = Properties.Resources.full;
PtbLogo.Image = Icon.ToBitmap();
LblIntro.Text = string.Format(LblIntro.Text, Preferences.SelectedDrive.Name);
HandlerThread = new Thread(new ThreadStart(() => {
Preferences.CleanupHandlers = new List <CleanupHandler>();
using (RegistryKey rKey = Registry.LocalMachine.OpenSubKey(Api.VolumeCacheStoreKey, false))
{
string[] subKeyNames = rKey.GetSubKeyNames();
// Adjust progress bar maximum to discovered handler count
Invoke((MethodInvoker) delegate
{
PrgScan.Maximum = subKeyNames.Length;
});
// Set up a dummy callback because COM stuff goes haywire for particular handlers if we supply none
EmptyVolumeCacheCallBacks callBacks = new EmptyVolumeCacheCallBacks();
for (int i = 0; i < subKeyNames.Length; i++)
{
CleanupHandler evp = Api.InitializeHandler(subKeyNames[i], Preferences.SelectedDrive.Letter);
if (evp != null)
{
if (LblHandler.IsHandleCreated)
{
Invoke((MethodInvoker) delegate {
LblHandler.Text = evp.DisplayName;
PrgScan.Value = i + 1;
});
}
int spaceResult = evp.Instance.GetSpaceUsed(out long spaceUsed, callBacks);
if (spaceResult < 0 || (spaceUsed == 0 &&
((evp.Flags & HandlerFlags.DontShowIfZero) == HandlerFlags.DontShowIfZero ||
(evp.DataDrivenFlags & DDCFlags.DontShowIfZero) == DDCFlags.DontShowIfZero)))
{
try { evp.Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(evp.Instance);
}
else
{
evp.BytesUsed = spaceUsed;
Preferences.CleanupHandlers.Add(evp);
}
}
}
}
Api.DeactivateHandlers(Preferences.CleanupHandlers);
// Sort handlers by priority, making sure they'll run in correct order
Preferences.CleanupHandlers.Sort((x, y) => y.Priority.CompareTo(x.Priority));
// A (stupid?) way to close the form once we are done cleaning
Invoke((MethodInvoker) delegate {
Close();
});
}));
HandlerThread.SetApartmentState(ApartmentState.STA);
HandlerThread.Start();
}
public Cleaner()
{
InitializeComponent();
Icon = Properties.Resources._1;
PtbLogo.Image = Icon.ToBitmap();
LblIntro.Text = string.Format(LblIntro.Text, Preferences.SelectedDrive.Name);
LblHandler.Text = Preferences.CleanupHandlers[0].DisplayName;
HandlerThread = new Thread(new ThreadStart(() => {
Api.ReinstateHandlers(Preferences.CleanupHandlers, Preferences.SelectedDrive.Letter);
// Set up a callbacks for progress reporting
EmptyVolumeCacheCallBacks callBacks = new EmptyVolumeCacheCallBacks();
callBacks.PurgeProgressChanged += CallBacks_PurgeProgressChanged;
TotalBytesDeleted = 0;
for (int i = 0; i < Preferences.CleanupHandlers.Count; i++)
{
CleanupHandler oHandler = Preferences.CleanupHandlers[i];
if (oHandler.PreProcHint != null)
{
RunProcHint(oHandler.PreProcHint);
}
if (LblHandler.IsHandleCreated)
{
Invoke((MethodInvoker) delegate {
LblHandler.Text = oHandler.DisplayName;
});
}
try
{
int purgeResult = oHandler.Instance.Purge(oHandler.BytesUsed, callBacks);
if (purgeResult != 0 && purgeResult != -2147287022) // -2147287022 == 0x80030012 == STG_E_NOMOREFILES
{
MessageBox.Show("Purging " + oHandler.DisplayName + " failed with error 0x" + purgeResult.ToString("x8"), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
if (oHandler.PostProcHint != null)
{
RunProcHint(oHandler.PostProcHint);
}
try { oHandler.Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(oHandler.Instance);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), oHandler.DisplayName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
// A (stupid?) way to close the form once we are done cleaning
Invoke((MethodInvoker) delegate {
Close();
});
}));
HandlerThread.SetApartmentState(ApartmentState.STA);
HandlerThread.Start();
}
private void HandlerChoice_Load(object sender, EventArgs e)
{
Api.ReinstateHandlers(Preferences.CleanupHandlers, Preferences.SelectedDrive.Letter);
for (int i = 0; i < Preferences.CleanupHandlers.Count; i++)
{
CleanupHandler oHandler = Preferences.CleanupHandlers[i];
LvwHandlers.Items.Add(new ListViewItem(new[] { oHandler.DisplayName, NiceSize(oHandler.BytesUsed) })
{
ImageIndex = (int)oHandler.IconHint, Tag = i, Checked = oHandler.StateFlag
});
}
CalculateSelectedSavings();
// Select first loaded handler so its description gets shown
LvwHandlers.SelectedIndices.Add(0);
}
private void LvwHandlers_SelectedIndexChanged(object sender, EventArgs e)
{
if (LvwHandlers.SelectedItems.Count > 0)
{
CleanupHandler oHandler = Preferences.CleanupHandlers[(int)LvwHandlers.SelectedItems[0].Tag];
LblDesc.Text = oHandler.Description;
if ((oHandler.Flags & HandlerFlags.HasSettings) == HandlerFlags.HasSettings)
{
if (oHandler.ButtonText != null)
{
BtnAdvanced.Text = oHandler.ButtonText;
}
BtnAdvanced.Visible = true;
}
else
{
BtnAdvanced.Visible = false;
}
}
}
public HandlerChoice()
{
InitializeComponent();
Text += Preferences.SelectedDrive.Name;
Icon = Properties.Resources.full;
// Check if we are running as administrator, if yes, give the elevation button a shield
using (WindowsIdentity identity = WindowsIdentity.GetCurrent())
{
WindowsPrincipal principal = new WindowsPrincipal(identity);
if (principal.IsInRole(WindowsBuiltInRole.Administrator))
{
BtnElevate.Visible = false;
}
else
{
NativeMethods.SendMessage(BtnElevate.Handle, 0x160C, 0, 1);
}
}
ImageList il = new ImageList
{
ColorDepth = ColorDepth.Depth32Bit,
// Get proper sizes for small icon lists on different DPIs, 49 = SM_CXSMICON, 50 = SM_CYSMICON
ImageSize = new Size(NativeMethods.GetSystemMetrics(49), NativeMethods.GetSystemMetrics(50))
};
il.Images.Add(GetIconFromLib("imageres.dll", 2));
Dictionary <string, int> IconListIndexForHint = new Dictionary <string, int>();
long totalSpaceUsed = 0;
for (int i = 0; i < Preferences.CleanupHandlers.Count; i++)
{
CleanupHandler oHandler = Preferences.CleanupHandlers[i];
totalSpaceUsed += oHandler.BytesUsed;
if (oHandler.IconHint != null)
{
// Reuse already loaded icon
if (IconListIndexForHint.ContainsKey((string)oHandler.IconHint))
{
oHandler.IconHint = IconListIndexForHint[(string)oHandler.IconHint];
}
else
{
// Get icon from PE file, comma separates filename and ID
string[] splitHint = ((string)oHandler.IconHint).TrimStart('@').Split(',');
Icon obtIcon = GetIconFromLib(splitHint[0], int.Parse(splitHint[1]));
if (obtIcon != null)
{
il.Images.Add(obtIcon);
IconListIndexForHint[(string)oHandler.IconHint] = il.Images.Count - 1;
oHandler.IconHint = il.Images.Count - 1;
}
else
{
// Otherwise use placeholder icon
IconListIndexForHint[(string)oHandler.IconHint] = 0;
oHandler.IconHint = 0;
}
}
}
else
{
oHandler.IconHint = 0;
}
}
LblIntro.Text = string.Format(LblIntro.Text, NiceSize(totalSpaceUsed), Preferences.SelectedDrive.Name);
LvwHandlers.SmallImageList = il;
PtbDrive.Image = GetIconOfPath(Preferences.SelectedDrive.Letter, false).ToBitmap();
}
private void Run()
{
lblCurrentHandler.Text = Resources.Label_Preparing.Format(Preferences.CleanupHandlers[0].DisplayName);
_thread = new Thread(new ThreadStart(() =>
{
CleanupApi.ReinstateHandlers(Preferences.CleanupHandlers, Preferences.SelectedDrive.Letter);
// Set up a callback for progress reporting
_callBacks = new EmptyVolumeCacheCallBacks();
_callBacks.PurgeProgressChanged += CallBacks_PurgeProgressChanged;
_totalBytesDeleted = 0;
_processingHandlers = true;
for (int i = 0; i < Preferences.CleanupHandlers.Count; i++)
{
_currentHandler = Preferences.CleanupHandlers[i];
if (_currentHandler.PreProcHint != null)
{
RunProcHint(_currentHandler.PreProcHint);
}
_lastHandlerPercent = 0;
if (i > 0 && lblCurrentHandler.IsHandleCreated)
{
Invoke((MethodInvoker) delegate
{
lblCurrentHandler.Text = Resources.Label_Preparing.Format(_currentHandler.DisplayName);
});
}
int spaceResult = _currentHandler.Instance.GetSpaceUsed(out long newSpaceUsed, _callBacks);
if (spaceResult >= 0)
{
Preferences.CurrentSelectionSavings = Preferences.CurrentSelectionSavings - _currentHandler.BytesUsed + newSpaceUsed;
_currentHandler.BytesUsed = newSpaceUsed;
ReportLastHandlerPercent();
int purgeResult = _currentHandler.Instance.Purge(_currentHandler.BytesUsed, _callBacks);
if (purgeResult == -2147467260) // -2147467260 = 0x80004004 = E_ABORT
{
break;
}
if (purgeResult < 0 && purgeResult != -2147287022) // -2147287022 == 0x80030012 == STG_E_NOMOREFILES
{
MessageBox.Show("Purging " + _currentHandler.DisplayName + " failed with error 0x" + purgeResult.ToString("x8"), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
if (_currentHandler.PostProcHint != null)
{
RunProcHint(_currentHandler.PostProcHint);
}
}
try { _currentHandler.Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(_currentHandler.Instance);
if (spaceResult < 0)
{
break;
}
}
_processingHandlers = false;
CleanupApi.DeactivateHandlers(Preferences.CleanupHandlers);
// A (stupid?) way to close the form once we are done cleaning
Invoke((MethodInvoker) delegate
{
Close();
});
}));
_thread.SetApartmentState(ApartmentState.STA);
_thread.Start();
}
public Cleaner()
{
InitializeComponent();
Icon = Properties.Resources.full;
PtbLogo.Image = Icon.ToBitmap();
LblClnUp.Text += Preferences.SelectedDrive.Name;
LblHandler.Text = $"{Preferences.CleanupHandlers[0].DisplayName} (Preparing...)";
HandlerThread = new Thread(new ThreadStart(() => {
Api.ReinstateHandlers(Preferences.CleanupHandlers, Preferences.SelectedDrive.Letter);
// Set up a callback for progress reporting
CallBacks = new EmptyVolumeCacheCallBacks();
CallBacks.PurgeProgressChanged += CallBacks_PurgeProgressChanged;
TotalBytesDeleted = 0;
ProcessingHandlers = true;
for (int i = 0; i < Preferences.CleanupHandlers.Count; i++)
{
CurrentHandler = Preferences.CleanupHandlers[i];
if (CurrentHandler.PreProcHint != null)
{
RunProcHint(CurrentHandler.PreProcHint);
}
LastHandlerPercent = 0;
if (i > 0 && LblHandler.IsHandleCreated)
{
Invoke((MethodInvoker) delegate {
LblHandler.Text = $"{CurrentHandler.DisplayName} (Preparing...)";
});
}
int spaceResult = CurrentHandler.Instance.GetSpaceUsed(out long newSpaceUsed, CallBacks);
if (spaceResult >= 0)
{
Preferences.CurrentSelectionSavings = Preferences.CurrentSelectionSavings - CurrentHandler.BytesUsed + newSpaceUsed;
CurrentHandler.BytesUsed = newSpaceUsed;
ReportLastHandlerPercent();
int purgeResult = CurrentHandler.Instance.Purge(CurrentHandler.BytesUsed, CallBacks);
if (purgeResult == -2147467260) // -2147467260 = 0x80004004 = E_ABORT
{
break;
}
if (purgeResult < 0 && purgeResult != -2147287022) // -2147287022 == 0x80030012 == STG_E_NOMOREFILES
{
MessageBox.Show("Purging " + CurrentHandler.DisplayName + " failed with error 0x" + purgeResult.ToString("x8"), Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
if (CurrentHandler.PostProcHint != null)
{
RunProcHint(CurrentHandler.PostProcHint);
}
}
try { CurrentHandler.Instance.Deactivate(out uint dummy); } catch { }
Marshal.FinalReleaseComObject(CurrentHandler.Instance);
if (spaceResult < 0)
{
break;
}
}
ProcessingHandlers = false;
Api.DeactivateHandlers(Preferences.CleanupHandlers);
// A (stupid?) way to close the form once we are done cleaning
Invoke((MethodInvoker) delegate {
Close();
});
}));
HandlerThread.SetApartmentState(ApartmentState.STA);
HandlerThread.Start();
}
