/// <summary>
/// Ask the user to begin system restore and do so if he accepts. Returns false if user decides to cancel the
/// operation.
/// </summary>
/// <param name="count">How many items are being uninstalled</param>
/// <param name="displayMessage">If user should be asked to create the restore point. If false, always create</param>
public static bool BeginSysRestore(int count, bool displayMessage = true)
{
if (SysRestore.SysRestoreAvailable())
{
switch (displayMessage ? MessageBoxes.SysRestoreBeginQuestion() : MessageBoxes.PressedButton.Yes)
{
case MessageBoxes.PressedButton.Yes:
var error = LoadingDialog.ShowDialog(null, Localisable.LoadingDialogTitleCreatingRestorePoint, x =>
{
//if (_currentRestoreId > 0)
EndSysRestore();
var result = SysRestore.StartRestore(MessageBoxes.GetSystemRestoreDescription(count),
SysRestore.RestoreType.ApplicationUninstall, out _currentRestoreId, 3);
if (result < 0)
{
throw new IOException(Localisable.SysRestoreGenericError);
}
});
return(error == null ||
MessageBoxes.SysRestoreContinueAfterError(error.Message) ==
MessageBoxes.PressedButton.Yes);
case MessageBoxes.PressedButton.Cancel:
return(false);
}
}
return(true);
}
/// <summary>
/// Cancel running restore if any
/// </summary>
public static void CancelSysRestore()
{
if (_currentRestoreId > 0)
{
SysRestore.CancelRestore(_currentRestoreId);
_currentRestoreId = 0;
}
}
public static void EndSysRestore()
{
if (_currentRestoreId > 0)
{
SysRestore.EndRestore(_currentRestoreId);
_currentRestoreId = 0;
}
}
public BeginUninstallTaskWizard()
{
InitializeComponent();
Icon = MessageBoxes.DefaultOwner.Icon;
DialogResult = DialogResult.Cancel;
tabControl1.TabIndex = 0;
buttonCreateRestore.Enabled = SysRestore.SysRestoreAvailable();
}
private async void buttonFix_Click(object sender, RoutedEventArgs e)
{
//List<FileEntry> files = (from resParent in (this._tree.Model as ResultModel).Root.Children where resParent.Children.Count > 0 from resChild in resParent.Children where resChild.IsChecked.GetValueOrDefault() select resChild.FileEntry).ToList();
var resultModel = Tree.Model as ResultModel;
if (resultModel == null)
{
return;
}
var files = resultModel.Root.Children.Where(resParent => resParent.Children.Count > 0)
.SelectMany(resParent => resParent.Children)
.Where(resChild => resChild.IsChecked.GetValueOrDefault())
.Select(resChild => resChild.FileEntry)
.ToList();
if (files.Count == 0)
{
MessageBox.Show(Application.Current.MainWindow,
"No files were selected to be removed. If you would like to not remove any files, please click cancel.",
Utils.ProductName, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (
MessageBox.Show(Application.Current.MainWindow,
"Are you sure you want to remove the selected files?\nYou may not be able to get them back once they're deleted.",
Utils.ProductName, MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
{
return;
}
Main.Watcher.Event("Duplicate Finder", "Remove Duplicates");
Main.TaskbarProgressState = TaskbarItemProgressState.Normal;
Main.TaskbarProgressValue = 0;
ProgressBar.Value = 0;
ProgressBar.Minimum = 0;
ProgressBar.Maximum = SysRestore.SysRestoreAvailable() ? files.Count + 2 : files.Count;
_taskScan = new Task(() => FixDuplicates(files));
_taskScan.Start();
await _taskScan;
MessageBox.Show(Application.Current.MainWindow, "Removed duplicate files from computer", Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Information);
Main.TaskbarProgressState = TaskbarItemProgressState.None;
Main.TaskbarProgressValue = 0;
_scanBase.MoveFirst();
}
private void Clean()
{
long lSeqNum = 0;
var report = Report.CreateReport(Settings.Default.privacyCleanerLog);
// Create system restore point
try
{
SysRestore.StartRestore("Before Little System Cleaner (Privacy Cleaner) Cleaning", out lSeqNum);
}
catch (Win32Exception ex)
{
string message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(Application.Current.MainWindow, message, Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
var observationModel = (Tree.Model as ResultModel)?.Root.Children;
if (observationModel != null)
{
foreach (var parent in observationModel)
{
foreach (var n in parent.Children.Where(n => n.IsChecked.GetValueOrDefault()))
{
report.WriteLine("Section: {0}", parent.Section);
n.Clean(report);
}
}
}
Settings.Default.totalErrorsFixed += Settings.Default.lastScanErrorsFixed;
report.WriteLine("Successfully Cleaned Disk @ " + DateTime.Now.ToLongTimeString());
report.DisplayLogFile(Settings.Default.privacyCleanerDisplayLog);
if (lSeqNum == 0)
{
return;
}
try
{
SysRestore.EndRestore(lSeqNum);
}
catch (Win32Exception ex)
{
string message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(Application.Current.MainWindow, message, Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
protected override void OnLoad(System.EventArgs e)
{
base.OnLoad(e);
if (DesignMode)
{
return;
}
var settings = Properties.Settings.Default.SettingBinder;
// Shutdown blocking not available below Windows Vista
if (Environment.OSVersion.Version < new Version(6, 0))
{
checkBoxShutdown.Enabled = false;
}
else
{
settings.BindControl(checkBoxShutdown, settings => settings.UninstallPreventShutdown, this);
}
checkBoxRestorePoint.Enabled = SysRestore.SysRestoreAvailable();
settings.BindControl(checkBoxRestorePoint, settings => settings.CreateRestorePoint, this);
settings.BindControl(checkBoxConcurrent, settings => settings.UninstallConcurrency, this);
settings.BindControl(checkBoxConcurrentOneLoud, settings => settings.UninstallConcurrentOneLoud, this);
settings.BindControl(checkBoxManualNoCollisionProtection, settings => settings.UninstallConcurrentDisableManualCollisionProtection, this);
settings.Subscribe(OnMaxCountChanged, settings => settings.UninstallConcurrentMaxCount, this);
numericUpDownMaxConcurrent.ValueChanged += NumericUpDownMaxConcurrentOnValueChanged;
settings.BindControl(checkBoxBatchSortQuiet, x => x.AdvancedIntelligentUninstallerSorting, this);
settings.BindControl(checkBoxDiisableProtection, x => x.AdvancedDisableProtection, this);
settings.BindControl(checkBoxSimulate, x => x.AdvancedSimulate, this);
settings.BindControl(checkBoxAutoKillQuiet, x => x.QuietAutoKillStuck, this);
settings.BindControl(checkBoxRetryQuiet, x => x.QuietRetryFailedOnce, this);
settings.BindControl(checkBoxGenerate, x => x.QuietAutomatization, this);
settings.BindControl(checkBoxGenerateStuck, x => x.QuietAutomatizationKillStuck, this);
settings.BindControl(checkBoxAutoDaemon, x => x.QuietUseDaemon, this);
settings.Subscribe((sender, args) => checkBoxGenerateStuck.Enabled = args.NewValue, settings => settings.QuietAutomatization, this);
settings.Subscribe(
(x, y) => checkBoxSimulate.ForeColor = y.NewValue ? Color.OrangeRed : SystemColors.ControlText,
x => x.AdvancedSimulate, this);
settings.SendUpdates(this);
Disposed += (x, y) => settings.RemoveHandlers(this);
}
private void UpdateState()
{
UseWaitCursor = true;
Application.DoEvents();
switch (PageNumber)
{
case 0:
break;
case 1:
{
processWaiterControl1.StopUpdating();
var additionals = relatedUninstallerAdder1.GetResults();
var taskEntries = ConvertToTaskEntries(_selectedUninstallers.Concat(additionals));
taskEntries = SortTaskEntryList(taskEntries);
uninstallConfirmation1.SetRelatedApps(taskEntries);
}
break;
case 2:
{
/*if (taskEntries == null || taskEntries.Count == 0) return;*/
var selectedTaskEntries = uninstallConfirmation1.GetResults().ToList();
if (!selectedTaskEntries.Any())
{
MessageBoxes.NoUninstallersSelectedInfo();
PageNumber = 1;
return;
}
var relatedPids = AppUninstaller.GetRelatedProcessIds(
selectedTaskEntries.Select(x => x.UninstallerEntry), !_quiet);
if (relatedPids.Length == 0)
{
PageNumber = _previousPageNumber < 2 ? 3 : 1;
return;
}
processWaiterControl1.Initialize(relatedPids, !_quiet);
processWaiterControl1.StartUpdating();
}
break;
case 3: // Settings
processWaiterControl1.StopUpdating();
break;
case 4: // Final
{
var taskEntries = uninstallConfirmation1.GetResults().ToList();
labelApps.Text = string.Join(", ",
taskEntries.Select(x => x.UninstallerEntry.DisplayName).OrderBy(x => x).ToArray());
labelTotalSize.Text = FileSize.SumFileSizes(taskEntries.Select(x => x.UninstallerEntry.EstimatedSize)).ToString();
labelConcurrentEnabled.Text = Settings.Default.UninstallConcurrency.ToYesNo();
labelFilesStillUsed.Text = processWaiterControl1.ProcessesStillRunning.ToYesNo();
labelRestorePointCreated.Text = (Settings.Default.CreateRestorePoint && SysRestore.SysRestoreAvailable()).ToYesNo();
labelWillBeSilent.Text = _quiet.ToYesNo();
labelOther.Text = Settings.Default.AdvancedSimulate ? "Simulating" : "-";
}
break;
}
labelProgress.Text = PageNumber + 1 + " / " + tabControl1.TabCount;
buttonPrev.Enabled = PageNumber > 0 && (PageNumber != 1 || _anyRelatedUninstallers);
buttonNext.Enabled = PageNumber + 1 < tabControl1.TabCount;
UseWaitCursor = false;
_previousPageNumber = PageNumber;
}
private async void CompactRegistry()
{
long lSeqNum = 0;
Little_System_Cleaner.Main.Watcher.Event("Registry Optimizer", "Compact Registry");
Thread.BeginCriticalRegion();
SetShutdownBlockReason(true);
try
{
SysRestore.StartRestore("Before Little System Cleaner Registry Optimization", out lSeqNum);
}
catch (Win32Exception ex)
{
string message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
foreach (var h in Wizard.RegistryHives)
{
if (h.SkipCompact)
{
TextBlockStatus.Text = $"Skipping: {h.RegistryHive}";
}
else
{
TextBlockStatus.Text = $"Compacting: {h.RegistryHive}";
await Task.Run(() => h.CompactHive(this));
}
ProgressBar.Value++;
}
if (lSeqNum != 0)
{
try
{
SysRestore.EndRestore(lSeqNum);
}
catch (Win32Exception ex)
{
string message =
$"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
SetShutdownBlockReason(false);
Thread.EndCriticalRegion();
// Set IsCompacted
Main.IsCompacted = true;
DialogResult = true;
Little_System_Cleaner.Main.TaskbarProgressState = TaskbarItemProgressState.None;
Close();
}
public static void EndSysRestore()
{
SysRestore.EndRestore(_currentRestoreId);
}
/// <summary>
/// Cancel running restore if any
/// </summary>
public static void CancelSysRestore()
{
SysRestore.CancelRestore(_currentRestoreId);
}
private void buttonRestore_Click(object sender, RoutedEventArgs e)
{
long lSeqNum = 0;
if (ListViewFiles.SelectedItem == null)
{
MessageBox.Show(Application.Current.MainWindow, "No restore file selected", Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (
MessageBox.Show(Application.Current.MainWindow, "Are you sure?", Utils.ProductName,
MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
{
return;
}
var filePath = (ListViewFiles.SelectedItem as RestoreFile)?.FileInfo.FullName;
using (var backupReg = new BackupRegistry(filePath))
{
string message;
if (!backupReg.Open(true))
{
message = $"Failed to open backup file ({filePath}).\nUnable to restore registry.";
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
try
{
SysRestore.StartRestore("Before Little System Cleaner (Registry Cleaner) Restore", out lSeqNum);
}
catch (Win32Exception ex)
{
message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
if (!backupReg.Deserialize(out message))
{
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
if (backupReg.RegistryEntries.Count == 0)
{
MessageBox.Show(Application.Current.MainWindow,
"No registry entries found in backup file.\nUnable to restore registry.", Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
if (backupReg.Restore())
{
MessageBox.Show(Application.Current.MainWindow, "Successfully restored registry", Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Information);
if (Settings.Default.registryCleanerOptionsDelBackup)
{
// Delete file
(ListViewFiles.SelectedItem as RestoreFile)?.FileInfo.Delete();
// Remove from listview and refresh
RestoreFiles.Remove(ListViewFiles.SelectedItem as RestoreFile);
PopulateListView();
}
}
else
{
MessageBox.Show(Application.Current.MainWindow, "Error restoring the registry", Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
if (lSeqNum == 0)
{
return;
}
try
{
SysRestore.EndRestore(lSeqNum);
}
catch (Win32Exception ex)
{
message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
MessageBox.Show(Application.Current.MainWindow, message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
}
public static void EndSysRestore()
{
try { SysRestore.EndRestore(_currentRestoreId); }
catch (Exception ex) { Console.WriteLine(ex); }
}
/// <summary>
/// Fixes registry problems
/// </summary>
/// <returns>Returns true if fix was successful</returns>
private bool FixProblems()
{
var cancelled = false;
try
{
var badRegKeys = GetSelectedRegKeys();
long lSeqNum = 0;
BackupRegistry backupReg;
if (SysRestore.SysRestoreAvailable())
{
// Create Restore Point
ProgressBarText = "Creating system restore point";
try
{
SysRestore.StartRestore("Before Little System Cleaner (Registry Cleaner) Fix", out lSeqNum);
}
catch (Win32Exception ex)
{
string message =
$"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
// Generate filename to backup registry
ProgressBarText = "Creating backup file";
var backupFile = string.Format("{0}\\{1:yyyy}_{1:MM}_{1:dd}_{1:HH}{1:mm}{1:ss}.bakx",
Settings.Default.OptionsBackupDir, DateTime.Now);
try
{
backupReg = new BackupRegistry(backupFile);
backupReg.Open(false);
}
catch (Exception ex)
{
string message = $"Unable to create backup file ({backupFile}).\nError: {ex.Message}";
Utils.MessageBoxThreadSafe(message, Utils.ProductName, MessageBoxButton.OK, MessageBoxImage.Error);
return(false);
}
Settings.Default.lastScanErrorsFixed = 0;
foreach (var brk in badRegKeys)
{
var skip = false;
if (_cancellationTokenSource.IsCancellationRequested)
{
break;
}
// Backup key
if (!backupReg.Store(brk))
{
if (Settings.Default.registryCleanerOptionsShowErrors)
{
string message =
$"An error occurred trying to backup registry key ({brk.RegKeyPath}).\nWould you like to remove it (not recommended)?";
if (
Utils.MessageBoxThreadSafe(message, Utils.ProductName, MessageBoxButton.YesNo,
MessageBoxImage.Exclamation) != MessageBoxResult.Yes)
{
skip = true;
}
}
else
{
skip = !Settings.Default.registryCleanerOptionsDeleteOnBackupError;
}
}
if (!skip)
{
// Delete key/value
if (!brk.Delete())
{
if (Settings.Default.registryCleanerOptionsShowErrors)
{
string message = $"An error occurred trying to remove registry key {brk.RegKeyPath}";
Utils.MessageBoxThreadSafe(message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
else
{
// Set last scan erors fixed
Settings.Default.lastScanErrorsFixed++;
}
}
Dispatcher.Invoke(() =>
{
// Set icon to check mark
brk.BitmapImg = new Image {
Source = BitmapSrcFinishedScanning
};
Tree.Items.Refresh();
// Increase & Update progress bar
ProgressBarValue++;
ProgressBarText = $"Items Repaired: {ProgressBarValue}/{ProgressBar.Maximum}";
});
}
if (!_cancellationTokenSource.IsCancellationRequested)
{
// Store data as file
backupReg.Serialize();
}
// Set total errors fixed
Settings.Default.totalErrorsFixed += Settings.Default.lastScanErrorsFixed;
if (SysRestore.SysRestoreAvailable())
{
// Finish creating restore point
if (lSeqNum != 0)
{
try
{
if (!_cancellationTokenSource.IsCancellationRequested)
{
SysRestore.EndRestore(lSeqNum);
}
else
{
SysRestore.CancelRestore(lSeqNum);
}
}
catch (Win32Exception ex)
{
string message =
$"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(message, Utils.ProductName, MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
}
_cancellationTokenSource.Token.ThrowIfCancellationRequested();
}
catch (OperationCanceledException)
{
cancelled = true;
}
finally
{
_cancellationTokenSource.Dispose();
_cancellationTokenSource = null;
}
return(!cancelled);
}
private void FixProblems()
{
long lSeqNum = 0;
try
{
SysRestore.StartRestore("Before Little System Cleaner (Disk Cleaner) Cleaning", out lSeqNum);
}
catch (Win32Exception ex)
{
string message = $"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(Application.Current.MainWindow, message, Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
foreach (var lvi in ProblemsCollection.Where(lvi => lvi.Checked.GetValueOrDefault()))
{
try
{
var fileInfo = lvi.FileInfo;
// Make sure file exists
if (!fileInfo.Exists)
{
continue;
}
switch (Settings.Default.diskCleanerRemoveMode)
{
case 0:
// Remove permanately
fileInfo.Delete();
break;
case 1:
// Recycle file
SendFileToRecycleBin(fileInfo.FullName);
break;
default:
// Move file to specified directory
if (!Directory.Exists(Settings.Default.diskCleanerMoveFolder))
{
Directory.CreateDirectory(Settings.Default.diskCleanerMoveFolder);
}
File.Move(fileInfo.FullName, $@"{Settings.Default.diskCleanerMoveFolder}\{fileInfo.Name}");
break;
}
}
catch (Exception)
{
//this.m_watcher.Exception(ex);
}
}
if (lSeqNum != 0)
{
try
{
SysRestore.EndRestore(lSeqNum);
}
catch (Win32Exception ex)
{
string message =
$"Unable to create system restore point.\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(Application.Current.MainWindow, message, Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void FixDuplicates(IEnumerable <FileEntry> files)
{
long seqNum = 0;
var sysRestoreAvailable = SysRestore.SysRestoreAvailable();
if (sysRestoreAvailable)
{
ProgressBarText = "Creating System Restore Point";
try
{
SysRestore.StartRestore("Before Little System Cleaner (Duplicate Finder) Clean", out seqNum);
}
catch (Win32Exception ex)
{
Utils.MessageBoxThreadSafe(Application.Current.MainWindow,
"The following error occurred trying to create a system restore point: " + ex.Message,
Utils.ProductName, MessageBoxButton.OK, MessageBoxImage.Error);
}
Dispatcher.Invoke(() => ProgressBar.Value++);
}
foreach (var fileEntry in files)
{
var filePath = fileEntry.FilePath;
var percent = Dispatcher.Invoke(() => ProgressBar.Value / ProgressBar.Maximum * 100);
ProgressBarText = Dispatcher.Invoke(() => $"{ProgressBar.Value}/{ProgressBar.Maximum} ({percent:0.##}%)");
try
{
System.IO.File.Delete(filePath);
}
catch (Exception ex)
{
string message = $"Unable to remove file ({filePath}).\nThe following error occurred: {ex.Message}";
Utils.MessageBoxThreadSafe(Application.Current.MainWindow, message, Utils.ProductName,
MessageBoxButton.OK, MessageBoxImage.Error);
}
Dispatcher.Invoke(() => ProgressBar.Value++);
}
if (!sysRestoreAvailable)
{
return;
}
ProgressBarText = "Finalizing system restore point";
if (seqNum != 0)
{
try
{
SysRestore.EndRestore(seqNum);
}
catch (Win32Exception ex)
{
Utils.MessageBoxThreadSafe(Application.Current.MainWindow,
"Unable to create system restore point.\nThe following error occurred: " + ex.Message,
Utils.ProductName, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
Dispatcher.Invoke(() => ProgressBar.Value++);
}
