private void tmiStop_Click(object sender, EventArgs e)
{
_workTime.Dispose();
CreateWorkTime();
this.ShowInTaskbar = true;
this.Show();
}
public AsyncCommandBinding(ICommand command, ExecutedRoutedEventHandler executed, CanExecuteRoutedEventHandler canExecute, RunWorkerCompletedEventHandler runWokrerCompleted)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
_task = new BackgroundWorker();
_task.DoWork += delegate
{
executed(null, null);
};
_task.RunWorkerCompleted += (s, e) =>
{
runWokrerCompleted(s, e);
_task.Dispose();
};
Command = command;
if (executed != null)
{
Executed += delegate
{
if (!_task.IsBusy)
_task.RunWorkerAsync();
};
}
if (canExecute != null)
{
CanExecute += canExecute;
}
}
private void BindList()
{
try
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (o, ea) =>
{
if (list == null)
{
list = new List<DataModel.TranslationEntryDiff>();
list = transManage.GetDiffStrings();
searchList = list;
}
Dispatcher.Invoke(new Action(() => gvList.ItemsSource = searchList));
};
worker.RunWorkerCompleted += (o, ea) =>
{
pBar.Visibility = Visibility.Hidden;
worker.Dispose();
};
SetStatusLabelValue(tsslblException, "");
pBar.Visibility = Visibility.Visible;
worker.RunWorkerAsync();
}
catch(Exception ex)
{
SetStatusLabelValue(tsslblException, ex.Message);
}
}
public static void StartAsync(Action a)
{
BackgroundWorker bg = new BackgroundWorker();
bg.DoWork += delegate { a(); };
bg.RunWorkerCompleted += delegate { bg.Dispose(); };
bg.RunWorkerAsync();
}
/// <summary>
/// Starts execution of a background operation.
/// </summary>
/// <param name="action">The operation to be invoked by a <see cref="System.ComponentModel.BackgroundWorker"/>.</param>
public static void RunWorkerAsync(Action<object, DoWorkEventArgs> action)
{
var w = new BackgroundWorker();
w.DoWork += (s, e) => action(s, e);
w.RunWorkerCompleted += (s, e) => w.Dispose();
w.RunWorkerAsync();
}
private void search_Click(object sender, EventArgs e)
{
BackgroundWorker bgWorker = new BackgroundWorker();
bgWorker.DoWork += new DoWorkEventHandler(bgWorker_DoWork);
bgWorker.RunWorkerAsync();
bgWorker.Dispose();
search.Enabled = false;
}
private void MyToolWindow_Loaded(object sender, RoutedEventArgs e)
{
if (_loaded) return;
var overflowGrid = explorerToolbar.Template.FindName("OverflowGrid", explorerToolbar) as FrameworkElement;
if (overflowGrid != null)
{
overflowGrid.Visibility = Visibility.Collapsed;
}
//explorerToolbar.Foreground = Helpers.VSThemes.GetWindowText();
//explorerToolbar.Background = Helpers.VSThemes.GetCommandBackground();
//toolTray.Background = explorerToolbar.Background;
//sep2.Background = sep1.Background = Helpers.VSThemes.GetToolbarSeparatorBackground();
TreeView1.Background = grid1.Background = Helpers.VSThemes.GetToolWindowBackground();
Updated.Visibility = System.Windows.Visibility.Collapsed;
// Look for update async
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
bw.RunWorkerCompleted += (s, ea) =>
{
try
{
if ((Boolean)ea.Result == true)
{
Updated.Visibility = System.Windows.Visibility.Visible;
myStoryboard.Begin(this);
}
else
{
Updated.Visibility = System.Windows.Visibility.Collapsed;
}
}
finally
{
bw.Dispose();
}
};
// Animate updated button
DoubleAnimation myDoubleAnimation = new DoubleAnimation();
myDoubleAnimation.From = 0.1;
myDoubleAnimation.To = 1.0;
myDoubleAnimation.Duration = new Duration(TimeSpan.FromSeconds(5));
myDoubleAnimation.AutoReverse = true;
myDoubleAnimation.RepeatBehavior = RepeatBehavior.Forever;
myStoryboard = new Storyboard();
myStoryboard.Children.Add(myDoubleAnimation);
Storyboard.SetTargetName(myDoubleAnimation, UpdatedText.Name);
Storyboard.SetTargetProperty(myDoubleAnimation, new PropertyPath(TextBlock.OpacityProperty));
BuildDatabaseTree();
bw.RunWorkerAsync();
AddHandler(Keyboard.KeyDownEvent, (KeyEventHandler)HandleKeyDownEvent);
txtConnections.Focus();
_loaded = true;
}
private void cmdTrennen_Click(System.Object sender, System.EventArgs e)
{
if (client.IsConnected)
{
client.LeaveChannel(txtChannel1.Text);
}
client.Disconnect();
backgroundWorker1.CancelAsync();
backgroundWorker1.Dispose();
}
public DocumentUploader()
{
InitializeComponent();
CmsWebService service = new CmsWebService();
WindowsIdentity windowsUser = WindowsIdentity.GetCurrent();
if (windowsUser == null)
{
return;
}
List<string> temp = windowsUser.Name.Split('\\').ToList();
User user = service.GetUser(temp.Last());
ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings["CmsEntities"];
EntityConnectionStringBuilder builder = new EntityConnectionStringBuilder(settings.ConnectionString);
SqlConnectionStringBuilder conn = new SqlConnectionStringBuilder(builder.ProviderConnectionString);
lblTitle.Text = string.Format("Document Version Imports: by {0} into {1} on {2}", user.UserName, conn.InitialCatalog, conn.DataSource);
mMetaData.UserId = user.Id;
using (mWorker = new BackgroundWorker())
{
mWorker.WorkerSupportsCancellation = true;
mWorker.WorkerReportsProgress = true;
mWorker.ProgressChanged += bw_ProgressChanged;
mWorker.RunWorkerCompleted += bw_RunWorkerCompleted;
mWorker.DoWork += (s1, e1) =>
{
try
{
if (mWorker.CancellationPending)
{
mWorker.CancelAsync();
mWorker.Dispose();
}
else
{
//WORK
ImportDocuments(mWorker);
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
};
}
}
private void buttonValidate_Click(object sender, EventArgs e)
{
var doValidate = MessageBox.Show("SnakeBite will close the Steam validation window automatically when ready, please do not cancel or close the Steam window.", "SnakeBite", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
if (doValidate == DialogResult.Cancel) return;
System.Diagnostics.Process.Start("steam://validate/287700/");
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += (obj, var) =>
{
int sleep = 0;
int maxSleep = 7500;
while (true)
{
System.Threading.Thread.Sleep(100);
sleep += 100;
if(!BackupManager.GameFilesExist()) // break when files are removed by Steam
{
try
{
Microsoft.VisualBasic.Interaction.AppActivate("Validating Steam files");
SendKeys.SendWait("%{F4}");
}
catch
{
MessageBox.Show("Unable to locate and close the Steam window, you may need to launch Steam before trying again, or validate manually through the Steam application.", "Steam Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
break;
}
if (sleep >= maxSleep) // break on timeout
{
try
{
Microsoft.VisualBasic.Interaction.AppActivate("Validating Steam files");
SendKeys.SendWait("%{F4}");
}
catch
{
MessageBox.Show("Timed out waiting for Steam window. Please launch Steam before trying again, or validate manually through the Steam application.", "Steam Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
break;
}
}
bw.Dispose();
};
bw.RunWorkerAsync();
BackupManager.DeleteOriginals();
}
private void importBtn_Click(object sender, EventArgs e)
{
string SelectExcelFile = filePath.Text;
if (string.IsNullOrEmpty(SelectExcelFile))
{
errorMsg.Text = "Excel文件不能为空！";
return;
}
this.importBtn.Enabled = false;
this.pictureBox1.Visible = true;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(worker_DoWork);
worker.RunWorkerAsync();
worker.Dispose();
}
public static void Show(string WindowTitle, string ProgressText, Action WorkerFunction)
{
var progressWindow = new formProgress();
progressWindow.StatusText.Text = ProgressText;
var progressWorker = new BackgroundWorker();
progressWorker.DoWork += (obj, var) =>
{
WorkerFunction();
progressWindow.Invoke((MethodInvoker)delegate { progressWindow.Close(); });
progressWorker.Dispose();
};
progressWorker.RunWorkerAsync();
progressWindow.ShowDialog();
}
public static void Kill(object parameter)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
var textBlock = parameter as TextBlock;
if (textBlock != null)
await textBlock.Dispatcher.InvokeAsync(async () =>
{
FastbootTools.Kill();
await textBlock.Dispatcher.InvokeAsync(() => textBlock.Text = "FASTBOOT KILLED");
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public static void Prepare(object parameter)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
var textBlock = parameter as TextBlock;
if (textBlock != null)
await textBlock.Dispatcher.InvokeAsync(async () =>
{
Fastboot = new FastbootTools(textBlock);
await Fastboot.Prepare();
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public void SaveFile(string SVFile, List <string> Data, System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e)
{
CurrentState state = new CurrentState();
int counter = 0;
string TextSent = "";
string tempTxt = "";
// SVFile.DefaultExt = ".txt";
using (System.IO.StreamWriter file = new System.IO.StreamWriter(SVFile, false))
{
for (int y = 0; y <= Data.Count - 1;)
{
if ((worker.CancellationPending == true))
{
e.Cancel = true;
worker.Dispose();
worker = null;
GC.Collect();
MessageBox.Show("Canceled");
break;
}
TextSent = "";
for (int x = 0; x <= columns - 1; x++)
{
if (x + y != Data.Count)
{
TextSent += Data[y + x] + " ";
}
}
TextSent = Data[y] + " " + Data[y + 1] + " " + Data[y + 2] + " " + Data[y + 3] + " " + Data[y + 4] + " " + Data[y + 5] + " " + Data[y + 6] + " " + Data[y + 7] + " " + Data[y + 8] + " " + Data[y + 9] + " " + Data[y + 10];
file.WriteLine(TextSent);
y += columns;
counter++;
if (counter % 100 == 0)
{
state.LinesCounted = counter;
state.DataStorage = Data;
worker.ReportProgress(0, state);
}
}
}
if (worker != null)
{
MessageBox.Show("Finished saving the file.");
}
}
public void Stop()
{
nf.AddToINFO($@"Closing Measurment.");
Application.DoEvents();
measWorker.CancelAsync();
while (measWorker.CancellationPending)
{
nf.AddToINFO($@"Cancellation pending...", InfoLine);
Thread.Sleep(1000);
measWorker.Dispose();
Application.DoEvents();
}
nf.AddToINFO($@"Measurment is closed.", InfoLine);
WorkerEndOutput();
Application.DoEvents();
}
public static void ExecuteListDevices(object parameter)
{
UIParameters parameters = (UIParameters)parameter;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
await _adb.ListDevices(parameters.Context2, parameters.Bool);
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
public void path_DoubleClick(object sender, MouseButtonEventArgs e)
{
FolderBrowserDialog way = new FolderBrowserDialog();
DialogResult result = way.ShowDialog();
if (result == System.Windows.Forms.DialogResult.OK)
{
path.Text = way.SelectedPath;
picName = (Directory.GetFiles(path.Text, "*jpg")).ToList();
ShowImage(picName[0]);
progress.Value = 0;
progress.Maximum = picName.Count;
bw = new BackgroundWorker();
bw.WorkerReportsProgress = true;
bw.DoWork += bw_DoWork;
bw.ProgressChanged += bw_ProgressChanged;
bw.RunWorkerAsync();
bw.Dispose();
}
}
public void Generate(int size, RenderContext context)
{
m_Context = context;
m_Worker = new BackgroundWorker();
m_Worker.WorkerReportsProgress = true;
m_Worker.WorkerSupportsCancellation = true;
m_Worker.DoWork += bgw_DoWork; //Work Event
m_Worker.RunWorkerCompleted += m_Worker_RunWorkerCompleted;
//Event that is run in the background;
Console.WriteLine("Opening new Thread");
m_Worker.RunWorkerAsync(size);
m_Worker.CancelAsync();
m_Worker.Dispose();
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
lblPath.Text = ConfigurationManager.AppSettings["PathOnNova"].ToString();
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += (o, ea) =>
{
for (int i = 10; i > 0; i--)
{
Thread.Sleep(1000);
ChangeButtonText(btnClose, "Close after " + (i - 1).ToString() + " seconds");
}
};
worker.RunWorkerCompleted += (o, ea) =>
{
Application.Current.Shutdown();
worker.Dispose();
};
worker.RunWorkerAsync();
}
private void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
try
{
if (_WaitDialog != null)
{
_WaitDialog.Close();
}
_WaitDialog = null;
_WorkThread.Dispose();
}
catch { }
}
disposed = true;
}
}
public void UpdateCount(System.ComponentModel.BackgroundWorker worker, System.ComponentModel.DoWorkEventArgs e)
{
int temp = 0;
//while (temp != 9999999999999)
//{
temp += 1;
// while (flag == false)
// {
state.LinesCounted = count;
worker.ReportProgress(0, state);
if ((worker.CancellationPending == true))
{
e.Cancel = true;
worker.Dispose();
worker = null;
GC.Collect();
MessageBox.Show("Canceled");
// break;
}
// }
}
private void InitializeUpdater()
{
updater = Utilities.Updater.Instance(this);
BackgroundWorker worker = new BackgroundWorker();
worker.WorkerReportsProgress = true;
worker.DoWork += new DoWorkEventHandler(
delegate (object o, DoWorkEventArgs args)
{
BackgroundWorker theWorker = o as BackgroundWorker;
while (true)
{
// Wait 5 seconds before checking, we don't want to blast the popup in their face
Thread.Sleep(5000);
theWorker.ReportProgress((updater.CheckForUpdates() ? 100 : 1));
Thread.Sleep(300000);
}
});
worker.ProgressChanged += new ProgressChangedEventHandler(
delegate (object o, ProgressChangedEventArgs args)
{
if (args.ProgressPercentage == 100)
{
updater.StartDownload();
}
});
worker.RunWorkerAsync();
FormClosing += (send, e) =>
{
// Garbage collect the background worker
worker.Dispose();
};
}
private void Grabar()
{
WebcamCtrl.StartRecording();
stopWatch.Start();
dt.Start();
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += new DoWorkEventHandler(bw_DoWork);
// bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
bw.RunWorkerCompleted += (s, e) =>
{
try
{
if (e.Error != null)
{
// Handle failure.
}
}
finally
{
// Use wkr outer instead of casting.
bw.Dispose();
}
};
// Kick off the Async thread
bw.RunWorkerAsync();
}
private void RunBackGround(string targ)
{
BackgroundWorker W = new BackgroundWorker();
switch (targ)
{
case ND:
W.DoWork += new DoWorkEventHandler(NoD);
break;
case NV:
W.DoWork += new DoWorkEventHandler(NoV);
break;
}
W.RunWorkerAsync();
W.Dispose();
}
private void lnkGoogleAPI_Elevation_Get_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
try
{
BackgroundWorker bgw = new BackgroundWorker();
bgw.DoWork += delegate (object bgwSender, DoWorkEventArgs bgwEvent)
{
using (Process process = new Process())
{
process.StartInfo.UseShellExecute = true;
process.StartInfo.FileName = "https://developers.google.com/maps/documentation/elevation/get-api-key";
process.Start();
}
};
bgw.RunWorkerCompleted += delegate (object bgwSender, RunWorkerCompletedEventArgs bgwEvent)
{
bgw.Dispose();
};
bgw.RunWorkerAsync();
}
catch (Exception x)
{
MessageBox.Show(x.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static void ExecuteReboot(object parameter)
{
SingleCommandParameters parameters = (SingleCommandParameters)parameter;
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(() => { _adb = new AdbTools(Context); });
await Task.Run(async () => await _adb.Reboot(parameters.Bool, parameters.Target));
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public static void ExecutePrepare(object parameter)
{
Context = (TextBlock)parameter;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(() => { _adb = new AdbTools(Context); });
await Task.Run(async () => await _adb.Prepare());
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public static void ExecuteRemoteDisconnect(object parameter)
{
SingleCommandParameters parameters = parameter as SingleCommandParameters;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
await _adb.RemoteDisconnect(parameters.Bool);
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
public static void ExecuteSingleCommand(object parameter)
{
TwoCommandParameters parameters = parameter as TwoCommandParameters;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
var cmds = new string[1];
cmds[0] = parameters.Text;
await _adb.Execute(cmds, parameters.Bool, parameters.Target);
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
public static void ExecutePull(object parameter)
{
FiveTextCommandParameters parameters = (FiveTextCommandParameters)parameter;
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
String[] paths = new string[4];
if (!string.IsNullOrEmpty(parameters.Text2)) paths[0] = parameters.Text2;
if (!string.IsNullOrEmpty(parameters.Text3)) paths[1] = parameters.Text3;
if (!string.IsNullOrEmpty(parameters.Text4)) paths[2] = parameters.Text4;
if (!string.IsNullOrEmpty(parameters.Text5)) paths[3] = parameters.Text5;
await _adb.Pull(parameters.Text, parameters.Bool, paths, parameters.Target);
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public static void ExecuteRoot(object parameter)
{
var parameters = (RootParameters)parameter;
Context = parameters.Context;
AdbTools adb = new AdbTools(Context);
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await parameters.Window.Dispatcher.InvokeAsync(async () =>
{
if (parameters.SuperSU || parameters.SuperUser)
{
if (ConnectionChecker.IsConnectedToInternet)
{
var controller = await parameters.Window.ShowProgressAsync("Please wait", "Downloading...", false, new MetroDialogSettings() { AnimateShow = true, AnimateHide = true, ColorScheme = MetroDialogColorScheme.Theme });
if (parameters.SuperUser)
{
await DownloadFile("http://www.file.appsapk.com/download/Superuser.apk", "Superuser.apk", parameters.Window, controller);
if (File.Exists("Superuser.apk"))
{
await adb.Root(parameters.CreateNoWindow, parameters.Target);
}
else
{
await parameters.Window.ShowMessageAsync("Unknown error", null);
}
}
if (parameters.SuperSU)
{
await DownloadFile("http://www.file.appsapk.com/download/SuperSU.apk", "Superuser.apk", parameters.Window, controller);
if (File.Exists("Superuser.apk"))
{
await adb.Root(parameters.CreateNoWindow, parameters.Target);
}
else
{
await parameters.Window.ShowMessageAsync("Unknown error", null);
}
}
}
else
{
await parameters.Window.ShowMessageAsync("Error", "You must have an internet connection.");
}
}
else
{
await parameters.Window.ShowMessageAsync("Error", "You must select app");
}
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
public void SearchFile(string FileName, List <string> Search, System.ComponentModel.BackgroundWorker worker,
System.ComponentModel.DoWorkEventArgs e)
{
CurrentState state = new CurrentState();
int counter = 0;
List <String> TempList = new List <string>();
int tempint = 0;
string ReadLine;
int SizeCheck = 0;
int HexCounter = 0;
using (FileStream fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
while ((ReadLine = sr.ReadLine()) != null)
{
if ((worker.CancellationPending == true))
{
e.Cancel = true;
worker.Dispose();
worker = null;
GC.Collect();
MessageBox.Show("Canceled");
break;
}
bool RFlag = false;
int TempCounter = 0;
string TempString = "";
for (int x = 0; x <= ReadLine.Length - 1; x++)
{
char df = ReadLine[x];
if (ReadLine[x] != ',')
{
while (ReadLine[x] != ',')
{
TempString += ReadLine[x];
if (x != ReadLine.Length - 1)
{
x++;
}
else
{
break;
}
}
if (TempCounter == 0)
{
foreach (string search in Search)
{
// Search.GetSelected(0)
// string txt = Search.Text.ToString();
if (search == TempString)
{
if (TempCounter == 1 && TempString != "X")
{
TempDataStorage.Add("");
TempCounter++;
TempDataStorage.Add(TempString);
}
else
{
TempDataStorage.Add(TempString);
}
if (TempCounter == 2)
{
tempint = Convert.ToInt16(TempString);
SizeCheck = 8 - Convert.ToInt16(TempString);
}
if (SizeCheck != 0)
{
if (2 + tempint == TempCounter)
{
for (int Rows = 0; Rows < SizeCheck; Rows++)
{
TempDataStorage.Add("");
TempCounter++;
}
}
}
}
}
}
counter++;
if (counter % 100 == 0)
{
state.LinesCounted = counter;
state.DataStorage = TempDataStorage;
worker.ReportProgress(0, state);
}
TempCounter++;
TempString = "";
}
}
}
if (worker != null)
{
MessageBox.Show("Finished searching the file.");
}
}
}
protected override void OnDestroyed()
{
if (searchBackgoundWorker != null && searchBackgoundWorker.IsBusy)
{
searchBackgoundWorker.CancelAsync();
searchBackgoundWorker.Dispose();
searchBackgoundWorker = null;
}
if (this.TreeView != null)
{
// Dispose (TreeView.GetRootNode ());
TreeView.Tree.CursorChanged -= HandleCursorChanged;
this.TreeView.Clear();
this.TreeView = null;
}
if (definitions != null)
{
definitions.Clear();
definitions = null;
}
ActiveMember = null;
if (memberListStore != null)
{
memberListStore.Dispose();
memberListStore = null;
}
if (typeListStore != null)
{
typeListStore.Dispose();
typeListStore = null;
}
if (documentationPanel != null)
{
documentationPanel.Destroy();
documentationPanel = null;
}
if (inspectEditor != null)
{
inspectEditor.LinkRequest -= InspectEditorhandleLinkRequest;
inspectEditor.Destroy();
inspectEditor = null;
}
if (this.UIManager != null)
{
this.UIManager.Dispose();
this.UIManager = null;
}
this.languageCombobox.Changed -= LanguageComboboxhandleChanged;
// this.searchInCombobox.Changed -= SearchInComboboxhandleChanged;
// this.searchEntry.Changed -= SearchEntryhandleChanged;
this.searchTreeview.RowActivated -= SearchTreeviewhandleRowActivated;
hpaned1.ExposeEvent -= HPaneExpose;
PropertyService.PropertyChanged -= HandlePropertyChanged;
base.OnDestroyed();
}
private long MeasureProgressUpdateCost(bool doMakeProgressCalls, int iterationsToDo)
{
_dialog = new ProgressDialog();
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += OnDoSomeWork;
_dialog.BackgroundWorker = worker;
WorkArguments args = new WorkArguments();
args.doMakeProgressCalls = doMakeProgressCalls;
args.secondsToUseUp = 0;
args.iterationsToDo = iterationsToDo;
_dialog.ProgressState.Arguments = args;
Stopwatch w = new Stopwatch();
w.Start();
_dialog.ShowDialog();
_dialog.Close();
_dialog.Dispose();
_dialog = null;
w.Stop();
worker.Dispose();
Debug.WriteLine("Took "+ w.Elapsed);
return w.ElapsedMilliseconds;
}
public static void Execute(object parameter)
{
ExecuteCommandParameters parameters = parameter as ExecuteCommandParameters;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
var cmds = new List<string>
{
parameters.Text,
parameters.Text2,
parameters.Text3,
parameters.Text4,
parameters.Text5,
parameters.Text6,
parameters.Text7,
parameters.Text8,
parameters.Text9,
parameters.Text10
};
await _adb.Execute(cmds.ToArray<string>(), parameters.Bool, parameters.Target);
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
public static void ExecuteBackup(object parameter)
{
BackupParameters parameters = parameter as BackupParameters;
if (parameters != null)
{
Context = parameters.Context;
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += async (sender, args) =>
{
await Context.Dispatcher.InvokeAsync(async () =>
{
_adb = new AdbTools(Context);
if (parameters.Context2.SelectedIndex == 0)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.All, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 1)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.Apps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 2)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SystemApps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 3)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.AppsWithoutSystemApps, parameters.Bool, parameters.Target);
}
if (parameters.Context2.SelectedIndex == 4)
{
await _adb.Backup(parameters.Text, parameters.Text2, AdbBackupMode.SDCard, parameters.Bool, parameters.Target);
}
});
};
worker.RunWorkerCompleted += (sender, args) => worker.Dispose();
worker.RunWorkerAsync();
}
}
private void coordinator(object obj)
{
coordinatorIsRunning = true;
coordinatorPos = positionReader;
//readerWaitEvent.Set();
readerBackgroundWorker = new BackgroundWorker();
readerBackgroundWorker.DoWork += fillBuffer;
readerBackgroundWorker.RunWorkerAsync();
readBufferWorkerIsRunning = true;
while (!stopCoordinator && (coordinatorPos < readVidInfo.frameCount))
{
if ((internalBuffer.Count < 1) && !stopCoordinator && readBufferWorkerIsRunning)
{
waitForCoordinatorBufferToEmpty_WaitEvent.Set();
waitForCoordinatorBufferToFill_WaitEvent.WaitOne();
}
if (((coordinatorPos - positionReader) > NUMFRAMESINMEM) && buffer && !stopCoordinator)
{
coordinatorWaitEvent.WaitOne();
}
if (internalBuffer.Count > 0)
{
var ctx = internalBuffer.Dequeue();
currentHandle = (ctx as extractBitmapContext).doneEvent;
(ctx as extractBitmapContext).doneEvent.WaitOne();
readQueue.Enqueue((ctx as extractBitmapContext)._currFrame);
getFrameWaitEvent.Set();
coordinatorPos++;
}
if (buffer)
{
if (internalBuffer.Count < NUMFRAMESINMEM)
{
waitForCoordinatorBufferToEmpty_WaitEvent.Set();
//readerWaitEvent.Set();
}
}
else
break;
}
stopReadBufferWorker = true;
waitForCoordinatorBufferToEmpty_WaitEvent.Set();
waitForCoordinatorBufferToFill_WaitEvent.Set();
while (readBufferWorkerIsRunning)
{
waitForCoordinatorBufferToEmpty_WaitEvent.Set();
waitForCoordinatorBufferToFill_WaitEvent.Set();
Thread.Sleep(20);
}
stopReadBufferWorker = false;
readerBackgroundWorker.Dispose();
readerBackgroundWorker = null;
getFrameWaitEvent.Set();
coordinatorIsRunning = false;
}
//public void
public void ChopeFile(string OPFile, string SVFile, System.ComponentModel.BackgroundWorker worker,
System.ComponentModel.DoWorkEventArgs e)
{
CurrentState state = new CurrentState();
bool flag = false;
// Check = false;
List <String> TempList = new List <string>();
int FileCounter = 0;
int tempint = 0;
int counter = 0;
string ReadLine;
int SizeCheck = 0;
int HexCounter = 0;
string TextSent = "";
string tempTxt = "";
//SVFile.DefaultExt = ".txt";
//e.Value = DataStorageY[e.ColumnIndex][e.RowIndex];
System.IO.StreamReader sz = new System.IO.StreamReader(OPFile);
using (FileStream fs = File.Open(OPFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr2 = new StreamReader(bs))
{
for (int read = 0; read <= 23; read++)
{
ReadLine = sr2.ReadLine();
}
using (System.IO.StreamWriter file = new System.IO.StreamWriter(SVFile, false))
{
while ((ReadLine = sr2.ReadLine()) != null)
{
if ((worker.CancellationPending == true))
{
e.Cancel = true;
worker.Dispose();
worker = null;
GC.Collect();
MessageBox.Show("Canceled");
break;
}
bool RFlag = false;
int TempCounter = 0;
string TempString = "";
for (int x = 0; x <= ReadLine.Length - 1; x++)
{
if (ReadLine[x] == 'R')
{
ReadLine = ReadLine.Replace('R', ' ');
int df = 34;
RFlag = true;
}
int dffs = 34;
}
if (RFlag == false)
{
for (int x = 0; x <= ReadLine.Length - 1; x++)
{
char df = ReadLine[x];
if (ReadLine[x] != ' ')
{
while (ReadLine[x] != ' ')
{
TempString += ReadLine[x];
if (x != ReadLine.Length - 1)
{
x++;
}
else
{
break;
}
}
if (TempString == "416")
{
flag = true;
break;
}
else
{
flag = false;
}
if (TempCounter == 2 && TempString != "X")
{
TempRow[TempCounter] = "";
TempCounter++;
TempRow[TempCounter] = TempString;
}
else
{
TempRow[TempCounter] = TempString;
}
if (TempCounter == 3)
{
tempint = Convert.ToInt16(TempString);
SizeCheck = 8 - Convert.ToInt16(TempString);
}
if (SizeCheck != 0)
{
if (4 + tempint == TempCounter)
{
for (int Rows = 0; Rows < SizeCheck; Rows++)
{
TempRow[TempCounter] = "";
TempCounter++;
}
}
}
TempCounter++;
TempString = "";
}
}
}
if (TempRow[12] == "183")
{
int dsd = 34;
}
if (flag == false)
{
TextSent = TempRow[1] + "," + TempRow[3] + "," + TempRow[4] + "," + TempRow[5] + "," + TempRow[6] + "," + TempRow[7] + "," + TempRow[8] + "," + TempRow[9] + "," + TempRow[10] + "," + TempRow[11];
file.WriteLine(TextSent);
//label1.Name = "Lines Saved: " + TempRow[12];
for (int x = 0; x <= 12; x++)
{
TempRow[x] = "";
}
}
counter++;
if (counter % 100 == 0)
{
state.LinesCounted = counter;
worker.ReportProgress(0, state);
}
}
}
}
if (worker != null)
{
MessageBox.Show("Finished condensing the file.");
}
}
