public void RefreshMainWindow()
{
ToDo.Clear();
Doing.Clear();
Backlog.Clear();
Done.Clear();
var result = readDbDataToDisplay();
foreach (var i in result)
{
if (i.States == BackLog.State.IsToDo)
{
ToDo.Add(i);
}
else if (i.States == BackLog.State.IsDoing)
{
Doing.Add(i);
}
else if (i.States == BackLog.State.Backlog)
{
Backlog.Add(i);
}
else
{
Done.Add(i);
}
}
}
public async Task RunAsync(Version vsVersion, IVsExtensionRepository repository, IVsExtensionManager manager, CancellationToken cancellationToken)
{
_log.Debug("RunAsync started");
IEnumerable <ExtensionEntry> toUninstall = GetExtensionsMarkedForDeletion(vsVersion);
IEnumerable <ExtensionEntry> toInstall = GetMissingExtensions(manager).Except(toUninstall);
int actions = toUninstall.Count() + toInstall.Count();
if (actions > 0)
{
_progress = new Progress(actions);
await UninstallAsync(toUninstall, repository, manager, cancellationToken).ConfigureAwait(false);
var installationResult = await InstallAsync(toInstall, repository, manager, cancellationToken).ConfigureAwait(false);
_log.Debug("Installation Completed ");
_logger.Log(Environment.NewLine + _settings.ResourceProvider.InstallationComplete + Environment.NewLine);
Done?.Invoke(this, installationResult);
}
else
{
_log.Debug("No actions to do");
}
_log.Debug("RunAsync ended");
}
/// <summary>
/// Add the retrieved data to the datatable
/// </summary>
/// <param name="data"></param>
/// <param name="request"></param>
public void HandInAssignment(string data, TableMetadata request)
{
HandInAssignment_m.WaitOne();
Data[request] = data;
Done.Add(request);
HandInAssignment_m.ReleaseMutex();
}
private async void OnSave()
{
var editingCompany = Mapper.Map <EditableCompany, Company>(Company);
editingCompany.RelatedPeople = RelatedPersonListViewModel.RelatedPeople;
try
{
if (EditMode)
{
await _companiesService.UpdateCompanyAsync(editingCompany);
}
else
{
await _companiesService.AddCompanyAsync(editingCompany);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
Company = null;
}
}
public void Clear()
{
ToDo.Clear();
InProgress.Clear();
Done.Clear();
Cancelled.Clear();
}
public void answer()
{
if (Sequence_Question < Question.Length - 1)
{
if (input_Answer.text == Answer [Sequence_Question])
{
Feed_Right.SetActive(false);
Feed_Right.SetActive(true);
Feed_False.SetActive(false);
Score += 20;
}
else
{
Feed_Right.SetActive(false);
Feed_False.SetActive(false);
Feed_False.SetActive(true);
}
input_Answer.text = "";
Displayed_Question();
}
else
{
if (input_Answer.text == Answer [Sequence_Question])
{
Score += 20;
}
Done.SetActive(true);
Question_Spot.SetActive(false);
}
}
void ReleaseDesignerOutlets()
{
if (Delete != null)
{
Delete.Dispose();
Delete = null;
}
if (Done != null)
{
Done.Dispose();
Done = null;
}
if (Name != null)
{
Name.Dispose();
Name = null;
}
if (Notes != null)
{
Notes.Dispose();
Notes = null;
}
if (Save != null)
{
Save.Dispose();
Save = null;
}
}
private async void OnSave()
{
var editingExchangeRate = Mapper.Map <EditableExchangeRate, ExchangeRate>(ExchangeRate);
try
{
if (EditMode)
{
await _exchangeRatesService.UpdateExchangeRateAsync(editingExchangeRate);
}
else
{
await _exchangeRatesService.AddExchangeRateAsync(editingExchangeRate);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
ExchangeRate = null;
}
}
public IObservable <ITransition> Start()
=> dataSource.User.Get()
.Select(user => user.DefaultWorkspaceId.HasValue)
.Do(trackNoDefaultWorkspaceIfNeeded)
.Select(userHasDefaultWorkspace => userHasDefaultWorkspace
? Done.Transition()
: NoDefaultWorkspaceDetected.Transition());
private void Button_Click(object sender, RoutedEventArgs e)
{
var formatter = new BinaryFormatter();
switch (ActionId)
{
case ActionName.Doing:
var DoingClass = new Doing(Time.SelectedDate.Value, ActionNameText.Text);
using (var fs = new FileStream(FileName, FileMode.OpenOrCreate))
{
formatter.Serialize(fs, DoingClass);
}
break;
case ActionName.NeedToDo:
var NeedToDoClass = new NeedToDo(Time.SelectedDate.Value, ActionNameText.Text);
using (var fs = new FileStream(FileName, FileMode.OpenOrCreate))
{
formatter.Serialize(fs, NeedToDoClass);
}
break;
case ActionName.Done:
var DoneClass = new Done(Time.SelectedDate.Value, ActionNameText.Text);
using (var fs = new FileStream(FileName, FileMode.OpenOrCreate))
{
formatter.Serialize(fs, DoneClass);
}
break;
}
}
private async void OnSave()
{
var editingDL = Mapper.Map <EditableDL, DL>(DL);
try
{
if (EditMode)
{
await _dLsService.UpdateDLAsync(editingDL);
}
else
{
await _dLsService.AddDLAsync(editingDL);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
DL = null;
}
}
/*[MenuItem("AAA/BBB")]
* private static void Goga()
* {
* FindObjectOfType<PutCopy>().Go();
* }
*
* [MenuItem("AAA/CCC")]
* private static void Gogaaaa()
* {
* StaticBatchingUtility.Combine(GameObject.Find("terrain"));
* }*/
public void Go()
{
PrepareTextureSwitchesCaches();
var copies = new GameObject("copies");
copies.transform.parent = GameObject.Find("terrain").transform;
foreach (var copy in Copies)
{
/*if (copy.ToCopy.activeSelf)
* copy.ToCopy.SetActive(false);*/
if (!copy.ToCopy)
{
continue;
}
foreach (Rigidbody rb in copy.ToCopy.GetComponentsInChildren <Rigidbody>())
{
Destroy(rb);
}
GameObject gameObj = Instantiate(copy.ToCopy, copy.Position, copy.Rotation, copies.transform);
gameObj.name = copy.ToCopy.name;
ApplyTextureSwitches(gameObj);
}
Done?.Invoke();
}
public void Restore(string filePath, string destFolder)
{
Initializing?.Invoke();
using (FileStream fs = File.OpenRead(filePath))
{
var reader = new RawDataReader(fs, Encoding.UTF8);
byte[] sign = Signature;
foreach (byte b in sign)
{
if (reader.ReadByte() != b)
{
throw new CorruptedFileException(filePath);
}
}
reader.ReadTime(); //ignore creation time
int headerLen = reader.ReadInt();
reader.ReadBytes(headerLen); //ignore header
Restoring?.Invoke();
var bag = new FilesBag();
Clean(destFolder);
bag.Decompress(fs, destFolder);
Done?.Invoke();
}
}
public void Backup(string filePath, string srcFolder, byte[] archHeader)
{
Initializing?.Invoke();
FilesBag bag = CreateBag(srcFolder);
FileStream fsDest = null;
try
{
fsDest = File.Create(filePath);
var writer = new RawDataWriter(fsDest, Encoding.UTF8);
writer.Write(Signature);
writer.Write(DateTime.Now);
writer.Write(archHeader.Length);
writer.Write(archHeader);
Compressing?.Invoke();
bag.Compress(fsDest);
Done?.Invoke();
}
catch
{
if (fsDest != null)
{
fsDest.Dispose();
File.Delete(filePath);
}
throw;
}
}
/// <summary>
/// Execution of new scrum that will dete tasks from Done, and put all current task to BackLog.
/// </summary>
public void NewScrumCommandExecute()
{
foreach (var i in Done)
{
DeleteTask(i);
}
Done.Clear();
foreach (var i in Doing)
{
i.States = BackLog.State.Backlog;
PutTask(i);
Backlog.Add(i);
}
foreach (var i in ToDo)
{
i.States = BackLog.State.Backlog;
PutTask(i);
Backlog.Add(i);
}
Doing.Clear();
ToDo.Clear();
}
private async void OnSave()
{
var editingCurrency = Mapper.Map <EditableCurrency, Currency>(Currency);
try
{
if (EditMode)
{
await _currenciesService.UpdateCurrencyAsync(editingCurrency);
}
else
{
await _currenciesService.AddCurrencyAsync(editingCurrency);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed.Invoke(ex);
}
finally
{
Currency = null;
}
}
private async void OnSave()
{
var editingGL = Mapper.Map <EditableGL, GL>(GL);
try
{
if (EditMode)
{
await _gLsService.UpdateGLAsync(editingGL);
}
else
{
await _gLsService.AddGLAsync(editingGL);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
GL = null;
}
}
private async void OnSave()
{
var editingDocumentNumbering = Mapper.Map <EditableDocumentNumbering, DocumentNumbering>(DocumentNumbering);
try
{
if (EditMode)
{
await _documentNumberingsService.UpdateDocumentNumberingAsync(editingDocumentNumbering);
}
else
{
await _documentNumberingsService.AddDocumentNumberingAsync(editingDocumentNumbering);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
DocumentNumbering = null;
}
}
private void webView_Navigating(object sender, NavigatingCancelEventArgs e)
{
if (e.Uri.ToString().StartsWith(_callbackUri.AbsoluteUri))
{
if (e.Uri.AbsoluteUri.Contains("#"))
{
AuthorizeResponse = new AuthorizeResponse(e.Uri.AbsoluteUri);
}
else
{
var document = (IHTMLDocument3)((WebBrowser)sender).Document;
var inputElements = document.getElementsByTagName("INPUT").OfType <IHTMLElement>();
var resultUrl = "?";
foreach (var input in inputElements)
{
resultUrl += input.getAttribute("name") + "=";
resultUrl += input.getAttribute("value") + "&";
}
resultUrl = resultUrl.TrimEnd('&');
AuthorizeResponse = new AuthorizeResponse(resultUrl);
}
e.Cancel = true;
this.Visibility = Visibility.Hidden;
if (Done != null)
{
Done.Invoke(this, AuthorizeResponse);
}
}
}
/// <summary>
/// Standard procedure to send command to the mutex thread.
/// </summary>
/// <param name="command"></param>
/// <param name="cancellationToken"></param>
/// <param name="pollInterval"></param>
/// <returns></returns>
private async Task SetCommandAsync(int command, CancellationToken cancellationToken, int pollInterval)
{
if (!IsAlive)
{
throw new InvalidOperationException("Thread should be alive.");
}
Interlocked.Exchange(ref _command, command); // Set the command.
lock (LatestHoldLockExceptionLock)
{
LatestHoldLockException = null;
}
Done.Reset(); // Reset the Done.
ToDo.Set(); // Indicate that there is a new command.
while (!Done.WaitOne(1))
{
// Waiting for Done asynchronously.
await Task.Delay(pollInterval, cancellationToken);
}
lock (LatestHoldLockExceptionLock)
{
// If we had an exception then throw it.
if (LatestHoldLockException != null)
{
throw LatestHoldLockException;
}
}
}
private async void OnSave()
{
var editingCustomer = Mapper.Map <EditableUser, User>(User);
try
{
if (EditMode)
{
await _usersService.UpdateUserAsync(editingCustomer);
}
else
{
await _usersService.AddUserAsync(editingCustomer);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
User = null;
}
}
public async Task Start(string[] arguments)
{
Settings = Config.Current.GetSettings <EngineSettings>();
Settings.WithRandomSuffixAppendedToStreamName();
Logger = LogProvider.GetCurrentClassLogger();
Engine = await new EngineBuilder().Build <KeyValueStore <int> >();
var totals = new List <TimeSpan>(Runs);
for (var run = 0; run < Runs; run++)
{
Logger.Info($"Run {run + 1}");
var stopwatch = Stopwatch.StartNew();
await Run();
stopwatch.Stop();
totals.Add(stopwatch.Elapsed);
await Total(stopwatch.Elapsed);
}
await Engine.DisposeAsync();
await Totals(totals);
Done?.Invoke(this, EventArgs.Empty);
}
private async Task LoadTasks()
{
var result = await apiService.GetAllTasks();
if (result.HttpResponse.IsSuccessStatusCode)
{
foreach (var item in result.Data)
{
switch (item.Status)
{
case 0:
ToDo.Add(ViewModelHelper.Get(item));
break;
case 1:
Doing.Add(ViewModelHelper.Get(item));
break;
case 2:
Done.Add(ViewModelHelper.Get(item));
break;
}
}
}
}
private async void OnSave()
{
var editingAccountDocument = Mapper.Map <EditableAccountDocument, AccountDocument>(AccountDocument);
try
{
if (EditMode)
{
await _accountDocumentsService.UpdateAccountDocumentAsync(editingAccountDocument);
}
else
{
await _accountDocumentsService.AddAccountDocumentAsync(editingAccountDocument);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
AccountDocument = null;
}
}
public override int GetHashCode()
{
int hash = 1;
if (Reward != 0F)
{
hash ^= pbc::ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Reward);
}
if (Done != false)
{
hash ^= Done.GetHashCode();
}
if (MaxStepReached != false)
{
hash ^= MaxStepReached.GetHashCode();
}
if (Id != 0)
{
hash ^= Id.GetHashCode();
}
hash ^= actionMask_.GetHashCode();
hash ^= observations_.GetHashCode();
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
public MainPageViewModel()
{
MessagingCenter.Subscribe <string>(this, "ExecuteAction", (actionToExecute) =>
{
switch (actionToExecute)
{
case "Clean":
ToDo.Clear();
Doing.Clear();
Done.Clear();
break;
case "Reset":
break;
case "OtherPage":
case "AboutPage":
navigationService.Navigate(actionToExecute);
break;
}
});
navigationService = new NavigationService();
apiService = new ApiService();
ToDo = new ObservableCollection <TaskItemViewModel>();
Doing = new ObservableCollection <TaskItemViewModel>();
Done = new ObservableCollection <TaskItemViewModel>();
LoadTasks();
}
public override int GetHashCode()
{
int hash = 1;
if (Name.Length != 0)
{
hash ^= Name.GetHashCode();
}
if (metadata_ != null)
{
hash ^= Metadata.GetHashCode();
}
if (Done != false)
{
hash ^= Done.GetHashCode();
}
if (resultCase_ == ResultOneofCase.Error)
{
hash ^= Error.GetHashCode();
}
if (resultCase_ == ResultOneofCase.Response)
{
hash ^= Response.GetHashCode();
}
return(hash);
}
private void button6_Click(object sender, EventArgs e)
{
Done.PerformClick();
Updated();
button7.Hide();
dataGridView5.Hide();
}
private void onAnimationDone(EventArgs i_EventArgs)
{
if (Done != null)
{
Done.Invoke(this, i_EventArgs);
}
}
private async void OnSave()
{
var editingGroup = Mapper.Map <EditableGroup, Group>(Group);
try
{
if (EditMode)
{
await _groupsService.UpdateGroupAsync(editingGroup);
}
else
{
await _groupsService.AddGroupAsync(editingGroup);
}
Done?.Invoke();
}
catch (Exception ex)
{
Failed(ex);
}
finally
{
Group = null;
}
}
// id is user data.
public Lane(ulong id, int slots)
{
Out = new PendingOut[slots];
Progress = new InProgress[slots];
Done = new Done[slots];
Acks = new uint[slots];
Id = id;
LagMsMin = 0;
ResendMs = 200;
}
static void Remoting(Action<bool> done)
{
var d = AppDomain.CreateDomain("RemotingTest");
var xs = Observable.Range(0, 10, Scheduler.Default).Remotable();
var dn = new Done(done);
d.SetData("xs", xs);
d.SetData("dn", dn);
d.DoCallBack(() =>
{
var ys = (IObservable<int>)AppDomain.CurrentDomain.GetData("xs");
var res = ys.ToArray().Wait();
var b = res.SequenceEqual(Enumerable.Range(0, 10));
((Done)AppDomain.CurrentDomain.GetData("dn")).Set(b);
});
}
/// <summary>
/// Informs a region about an Agent
/// </summary>
/// <param name="TalkingAbout">User to talk about</param>
/// <param name="UserToUpdate">User we're sending this too (contains the region)</param>
public void SendRegionPresenceUpdate(UserPresenceData TalkingAbout, UserPresenceData UserToUpdate)
{
// TODO: Fill in pertenant Presence Data from 'TalkingAbout'
RegionProfileData whichRegion = new RegionProfileData();
if (lookupRegion)
{
handlerGetRegionData = OnGetRegionData;
if (handlerGetRegionData != null)
{
whichRegion = handlerGetRegionData(UserToUpdate.regionData.regionHandle);
}
//RegionProfileData rp = RegionProfileData.RequestSimProfileData(UserToUpdate.regionData.regionHandle, gridserverurl, gridserversendkey, gridserverrecvkey);
//whichRegion = rp;
}
else
{
whichRegion = UserToUpdate.regionData;
}
//whichRegion.httpServerURI
if (whichRegion != null)
{
Hashtable PresenceParams = new Hashtable();
PresenceParams.Add("agent_id",TalkingAbout.agentData.AgentID.ToString());
PresenceParams.Add("notify_id",UserToUpdate.agentData.AgentID.ToString());
if (TalkingAbout.OnlineYN)
PresenceParams.Add("status","TRUE");
else
PresenceParams.Add("status","FALSE");
ArrayList SendParams = new ArrayList();
SendParams.Add(PresenceParams);
m_log.InfoFormat("[PRESENCE]: Informing {0}@{1} at {2} about {3}", TalkingAbout.agentData.FirstName + " " + TalkingAbout.agentData.LastName, whichRegion.regionName, whichRegion.httpServerURI, UserToUpdate.agentData.FirstName + " " + UserToUpdate.agentData.LastName);
// Send
string methodName = "presence_update";
XmlRpcRequest RegionReq = new XmlRpcRequest(methodName, SendParams);
try
{
// XmlRpcResponse RegionResp = RegionReq.Send(whichRegion.httpServerURI, 6000);
RegionReq.Send(Util.XmlRpcRequestURI(whichRegion.httpServerURI, methodName), 6000);
}
catch (WebException)
{
m_log.WarnFormat("[INFORM]: failed notifying region {0} containing user {1} about {2}", whichRegion.regionName, UserToUpdate.agentData.FirstName + " " + UserToUpdate.agentData.LastName, TalkingAbout.agentData.FirstName + " " + TalkingAbout.agentData.LastName);
}
}
else
{
m_log.Info("[PRESENCEUPDATER]: Region data was null skipping");
}
handlerDone = OnDone;
if (handlerDone != null)
{
handlerDone(this);
}
}
// Return if there is more to come.
public static bool ProcessLanesIncoming(LaneSetup setup, Lane[] lanes, Done[] output, out uint numOut)
{
numOut = 0;
// Check the progress if we can pick another one.
for (int i=0;i<lanes.Length;i++)
{
Lane lane = lanes[i];
while (lane.DoneTail != lane.DoneHead)
{
uint t = lane.DoneTail % (uint)lane.Done.Length;
output[numOut] = lane.Done[t];
lane.DoneTail = lane.DoneTail + 1;
if (++numOut == output.Length)
{
return true;
}
}
if (lane.ProgressHead == lane.ProgressTail)
{
continue;
}
uint numProgress = (uint)lane.Progress.Length;
// Clear out any seqId=0 (these are empty slots).
while (lane.ProgressHead != lane.ProgressTail && lane.Progress[lane.ProgressTail % numProgress].SeqId == 0)
{
lane.ProgressTail++;
}
// And from the head too...
while (lane.ProgressHead != lane.ProgressTail && lane.Progress[(numProgress + lane.ProgressHead-1) % numProgress].SeqId == 0)
{
lane.ProgressHead--;
}
if (lane.ProgressHead == lane.ProgressTail)
{
continue;
}
// Sort them by seq. There shouldn't be so many here. Maybe do something more clever if the count grows big.
uint count = lane.ProgressHead - lane.ProgressTail;
while (count > 1)
{
bool swapped = false;
for (uint j = 0;j < (count-1); j++)
{
uint idx0 = (lane.ProgressTail + j) % numProgress;
uint idx1 = (lane.ProgressTail + j + 1) % numProgress;
if (lane.Progress[idx0].SeqId > lane.Progress[idx1].SeqId)
{
InProgress tmp = lane.Progress[idx0];
lane.Progress[idx0] = lane.Progress[idx1];
lane.Progress[idx1] = tmp;
swapped = true;
}
}
if (!swapped)
{
break;
}
}
// Guaranteed to have them sorted in order now.
uint head = lane.ProgressTail;
uint next = lanes[i].ReliableSeq + 1;
uint[] aggregateIdx = new uint[128];
uint aggregateCount = 0;
uint tail = lane.ProgressTail;
while (tail != lane.ProgressHead)
{
uint idx = tail % numProgress;
if (lane.Progress[idx].SeqId != next)
{
break;
}
if (lane.Progress[idx].IsFinalPiece)
{
if (aggregateCount == 0)
{
output[numOut].ArrivalTime = lane.Progress[idx].ArrivalTime;
output[numOut].CompletionTime = lane.Progress[idx].ArrivalTime;
output[numOut].Reliable = true;
output[numOut].SeqId = lane.Progress[idx].SeqId;
output[numOut].Data = lane.Progress[idx].Data;
output[numOut].Lane = lane;
lane.Progress[idx].SeqId = 0;
lane.ReliableSeq = next;
tail = tail + 1;
next = next + 1;
if (++numOut == output.Length)
{
return true;
}
}
else
{
// There is always one room because check belowe makes sure of that.
aggregateIdx[aggregateCount++] = idx;
uint bits = 0;
for (int k=0;k<aggregateCount;k++)
{
uint ki = aggregateIdx[k];
bits = bits + lane.Progress[ki].Data.BitsLeft();
}
Bitstream.Buffer total = setup.Factory.GetBuffer(bits / 8 + 16);
for (int k=0;k<aggregateCount;k++)
{
uint ki = aggregateIdx[k];
Bitstream.Insert(total, lane.Progress[ki].Data);
lane.Progress[ki].SeqId = 0;
}
total.Flip();
output[numOut].ArrivalTime = lane.Progress[aggregateIdx[0]].ArrivalTime;
output[numOut].CompletionTime = lane.Progress[idx].ArrivalTime;
output[numOut].Reliable = true;
output[numOut].SeqId = lane.Progress[idx].SeqId;
output[numOut].Data = total;
output[numOut].Lane = lane;
lane.ReliableSeq = next;
tail = tail + 1;
next = next + 1;
aggregateCount = 0;
if (++numOut == output.Length)
{
return true;
}
}
}
else
{
aggregateIdx[aggregateCount] = idx;
next = next + 1;
tail = tail + 1;
if (++aggregateCount >= (aggregateIdx.Length-1))
{
// THis should never happen.
Console.WriteLine("ERROR: Progress buffer reset because aggregateIdx overflowed.");
lane.ProgressHead = 0;
lane.ProgressTail = 0;
break;
}
}
}
}
return false;
}
