public override bool OnOptionsItemSelected(IMenuItem item) {
Android_Content.ContentResolver cr = GetActivity().GetContentResolver();
switch (item.GetItemId()) {
case POPULATE_ID:
if (mPopulatingTask != null) {
mPopulatingTask.Cancel(false);
}
mPopulatingTask = new PopulateAsyncTask(cr);
mPopulatingTask.Execute((object[]) null);
return true;
case CLEAR_ID:
if (mPopulatingTask != null) {
mPopulatingTask.Cancel(false);
mPopulatingTask = null;
}
AsyncTask<object, object, object> task = new ClearAsyncTask(cr);
task.Execute((object[])null);
return true;
default:
return base.OnOptionsItemSelected(item);
}
}
public override void Process(IODataRequestMessage requestMessage, IODataResponseMessage responseMessage)
{
string asyncToken = this.QueryContext.AsyncToken;
AsyncTask asyncTask = AsyncTask.GetTask(asyncToken);
if (asyncTask == null)
{
// token is invalid or expired.
throw Utility.BuildException(HttpStatusCode.NotFound);
}
else
{
if (!asyncTask.Ready)
{
ResponseWriter.WriteAsyncPendingResponse(responseMessage, asyncToken);
}
else
{
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentType, "application/http");
responseMessage.SetHeader(ServiceConstants.HttpHeaders.ContentTransferEncoding, ServiceConstants.HttpHeaderValues.Binary);
using (var messageWriter = this.CreateMessageWriter(responseMessage))
{
var asyncWriter = messageWriter.CreateODataAsynchronousWriter();
var innerResponse = asyncWriter.CreateResponseMessage();
asyncTask.Execute(innerResponse);
}
}
}
}
private IEnumerator CreateBuilding_Short()
{
//Debug.Log("CreateBuilding detour");
UndoMod.Instsance.BeginObserving("Build building", "Vanilla");
IEnumerator result = null;
RedirectionHelper.RevertRedirect(createBuilding_originalShort, state);
state = RedirectionHelper.RedirectCalls(shortPatch, createBuilding_originalShort);
try
{
// This is a genius piece of code. No joking!
//result = (IEnumerator) createBuilding_originalShort.Invoke(ToolsModifierControl.GetTool<BuildingTool>(), new object[] {});
result = CreateBuilding_Short();
AsyncTask asyncTask = new AsyncTask(result, null);
asyncTask.Execute();
}
catch (Exception e)
{
Debug.LogError(e);
UndoMod.Instsance.InvalidateAll();
} finally {
RedirectionHelper.RevertRedirect(shortPatch, state);
state = RedirectionHelper.RedirectCalls(createBuilding_originalShort, shortPatch);
}
//Singleton<SimulationManager>.instance.AddAction(() => {
UndoMod.Instsance.EndObserving();
//});
yield return(0);
yield break;
}
private IEnumerator CreateProp()
{
Debug.Log("CreateProp detour");
UndoMod.Instsance.BeginObserving("Build prop", "Vanilla");
IEnumerator result = null;
RedirectionHelper.RevertRedirect(createProp_original, state);
try
{
result = (IEnumerator)createProp_original.Invoke(ToolsModifierControl.GetTool <PropTool>(), new object[] { });
AsyncTask asyncTask = new AsyncTask(result, null);
asyncTask.Execute();
}
catch (Exception e)
{
Debug.LogError(e);
UndoMod.Instsance.InvalidateAll();
}
state = RedirectionHelper.RedirectCalls(createProp_original, patch);
//Singleton<SimulationManager>.instance.AddAction(() => {
UndoMod.Instsance.EndObserving();
//});
yield return(0);
yield break;
}
private void Read(int id)
{
Action <AsyncResult <ReadResult> > executing = (res) =>
{
res.Item = Queries.Read();
};
Action <AsyncResult <ReadResult> > executed = (res) =>
{
Cursor = Cursors.Default;
LblInfo.Text = string.Empty;
if (res.Exception != null)
{
MessageBox.Show(res.Exception.Message);
return;
}
Grid.DataSource = null;
for (int i = 0; i < res.Item.Mitglieder.Count; i++)
{
Mitglied mitglied = res.Item.Mitglieder[i];
mBindingSource.Add(mitglied);
if (mitglied.Id == id)
{
mBindingSource.Position = i;
}
}
Grid.DataSource = mBindingSource;
string m = res.Item.Maennlich.ToString("N2", Config.Culture);
string w = res.Item.Weiblich.ToString("N2", Config.Culture);
LblInfo.Text = "männlich: " + m + " %" + " " + "weiblich: " + w + " %";
};
Cursor = Cursors.WaitCursor;
LblInfo.Text = "Daten werden abgefragt ...";
LblNotiz.Text = string.Empty;
mBindingSource.Clear();
LblInfoCount.Text = string.Empty;
Application.DoEvents();
mAsyncTask.Execute(executing, executed);
}
private void btnTruncateSelected_Click(object sender, EventArgs e)
{
AsyncTask<string,string, string> task = new AsyncTask<string,string,string>(this);
TextBox LogTxt = null;
Trunc.OnProgress += new TableTruncator.TableItemTruncateEventHandler(
delegate(string TableName, string Operation)
{
task.PublishProgress(string.Format("{0} -> {1}", Operation, TableName));
}
);
task.doInBackground = delegate(string[] param)
{
task.PublishProgress("Truncating tables...");
Trunc.TruncateTable(param);
return "Done";
};
task.onProgressUpdate = delegate(string[] param)
{
lblStatus.Text = param[0];
LogTxt.AppendText(param[0] + "\r\n");
LogTxt.SelectionStart = LogTxt.Text.Length;
};
task.onPostExecute = delegate(string result)
{
lblStatus.Text = result;
LogTxt.AppendText(result + "\r\n");
LogTxt.SelectionStart = LogTxt.Text.Length;
LogTxt.AppendText("Disconnecting\r\n");
if (chkShowScript.Checked)
{
frmScriptViewer ScriptViewDlg = new frmScriptViewer(Trunc.ToString());
ScriptViewDlg.ShowDialog();
}
Trunc.Release();
};
Trunc.OnlyGenerateSQLScript = chkOnlyGenScript.Checked;
LogTxt = PassProgressMode();
task.Execute(GetCheckedTables());
}
private void frmApplication_Shown(object sender, EventArgs e)
{
lblName.Text = lblRelatedColumn.Text = lblRelatedTo.Text = lblRelationState.Text = "";
Trunc = new TableTruncator(Connection);
AsyncTask<string, string, string> task = new AsyncTask<string, string, string>(this);
task.doInBackground = delegate(string[] param)
{
task.PublishProgress("Connecting to the SQL Server");
Connection.Connect();
task.PublishProgress("Gathering & inspecting tables...");
Trunc.Initialize();
return "Ready";
};
task.onProgressUpdate = delegate(string[] param)
{
lblStatus.Text = param[0];
};
task.onPostExecute = delegate(string result)
{
lblStatus.Text = result;
List<string> Tables = Trunc.GetTables();
TreeNode Root = tvTables.Nodes.Add(Setting.Database);
foreach (string table in Tables)
{
Root.Nodes.Add(table);
}
};
task.Execute();
}
private void ProcessTaskInternal(AsyncTask asyncTask)
{
NotifyTaskStateChanged(asyncTask, TaskStateChangedEventArgs.State.ExecutionStarting);
var executionState = asyncTask.Execute()
? TaskStateChangedEventArgs.State.ExecutionCompleted
: TaskStateChangedEventArgs.State.ExecutionFailed;
NotifyTaskStateChanged(asyncTask, executionState);
asyncTask.HandleTaskCompletion();
NotifyTaskStateChanged(asyncTask, TaskStateChangedEventArgs.State.CompletionHandled);
}
