public async Task LoadProject(string filename)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(StatusName.MarqueeProgressBarStyle, "Loading project...", OperationTag.Active | OperationTag.Cancellable));
var stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
Project proj = null;
await Task.Run(() => proj = ConfigurationBase.Deserialize <Project>(System.IO.File.ReadAllText(filename), new PluginSerializationBinder()));
proj.Name = System.IO.Path.GetFileName(filename);
stopwatch.Stop();
logger.Debug($"Project loaded in {stopwatch.Elapsed}.");
var curmod = 0;
var loadAwareModules = proj.Modules.OfType <ISaveLoadAware>();
foreach (var module in loadAwareModules)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, loadAwareModules.Count(), "Loading project...", OperationTag.Active | OperationTag.Cancellable));
module.AfterLoad();
}
proj.Modules.ToList().ForEach(m => m.StatusChanged += Module_StatusChanged);
Project = proj;
IsModified = false;
await RefreshModuleStatus();
}
public async Task <double> TrainNetwork(double[][] inputs, double[][] outputs, double learningrate, double momentum, int iterations, double minerror)
{
try
{
_run = true;
SetMomentum(momentum);
for (_iteration = 0; _iteration < iterations; _iteration++)
{
double error = 0;
for (int s = 0; s < inputs.Length; s++)
{
if (!_run)
{
return(_error);
}
error += await TrainSample(inputs[s], outputs[s], learningrate);
}
_error = error / inputs.Length;
ReportProgress?.Invoke(this, EventArgs.Empty);
if (_error < minerror)
{
break;
}
}
return(_error);
}
finally
{
ReportProgress = null;
}
}
public async Task LoadModules(string path, string filter)
{
await Task.Run(() =>
{
try
{
var curplug = 0;
var pluginFiles = System.IO.Directory.GetFiles(path, filter, System.IO.SearchOption.TopDirectoryOnly);
foreach (var filename in pluginFiles)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curplug, pluginFiles.Length, "Loading plugins...", OperationTag.Active));
var types = AssemblyLoader.LoadClassesFromFile <IInstallerModule>(System.IO.Path.GetFullPath(filename)).Where(t => t != null);
if (types.Any())
{
PluginLoaded?.Invoke(this, new PluginLoadedEventArgs(types));
}
}
}
catch (Exception ex)
{
ErrorOccured?.Invoke(this, new ErrorOccuredEventArgs(ex, "Error loading modules"));
}
finally
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(0, StatusName.Idle, OperationTag.None));
LoadingFinished?.Invoke(this, EventArgs.Empty);
}
});
}
public static Bitmap ToGrayscale(
Bitmap source,
CancellationToken token,
ReportProgress onProgress = null)
{
Bitmap result = new Bitmap(source);
for (int y = 0; y < source.Height; y++)
{
int currentProgress = (int)(((double)y / source.Height) * 100);
onProgress?.Invoke(currentProgress);
for (int x = 0; x < source.Width; x++)
{
if (token.IsCancellationRequested)
{
return(result);
}
Color c = source.GetPixel(x, y);
var gray = (int)
(c.R * 0.299 +
c.G * 0.587 +
c.B * 0.114);
var grayColor = Color.FromArgb(gray, gray, gray);
result.SetPixel(x, y, grayColor);
}
}
return(result);
}
public void Publish(DeployConfigurationModel deployConfiguration, TelemetryWrapper telemetry, string singleResourceName, string project, string projectPath, string basePath)
{
try
{
Action <string> reportAction = (m) => { ReportProgress?.Invoke(this, m); };
var context = new XrmService(deployConfiguration.DynamicsSettings, deployConfiguration.Solution, telemetry, reportAction);
var sourceControl = new VersioningService(projectPath, basePath, deployConfiguration.Branch, reportAction, telemetry);
var sourceControlResult = sourceControl.QueryLocalRepository();
// Must resolve conflicts or something went wrong with TFS interaction
if (!sourceControlResult.Continue && sourceControlResult.Changes == null)
{
return;
}
var changeList = sourceControlResult.Changes;
if (!string.IsNullOrEmpty(singleResourceName))
{
var filteredChangeList = sourceControlResult.Changes.Where(x => x.FileName.Equals(singleResourceName)).ToArray();
changeList = filteredChangeList;
}
PublishImpl(context, sourceControl, deployConfiguration, telemetry, changeList, project);
}
catch (Exception exception)
{
ReportProgress?.Invoke(this, $"[ERROR] => {exception.Message}\n");
if (!(exception is ToolkitException))
{
telemetry.TrackExceptionWithCustomMetrics(exception);
}
}
}
private async void GetData(CancellationToken cancelationToken)
{
try
{
m_Source.MessageRecieved += ProcessMessage;
int count = 0;
if (!m_Source.SupportProgress)
{
ProgressArgs args = new ProgressArgs("This DataSource does not support Progress updates.", false, (int)50);
ReportProgress?.Invoke(this, args);
}
await foreach (IFrame frame in m_Source.GetData(m_sourceSignals, m_start, m_end))
{
frame.Timestamp = Ticks.AlignToMicrosecondDistribution(frame.Timestamp, m_commonFrameRate);
await m_sourceQueue.Writer.WriteAsync(frame, cancelationToken);
count++;
if (count % 1000 == 0 && m_Source.SupportProgress)
{
ReportDatasourceProgress(m_Source.GetProgress());
}
}
}
finally
{
MessageRecieved?.Invoke(this, new MessageArgs("Finished Loading Data from DataSource", MessageArgs.MessageLevel.Info));
m_sourceQueue.Writer.Complete();
}
}
public async Task RefreshModuleStatus(IEnumerable <IInstallerModule> pickModules = null, bool throwIfCancelled = false)
{
await Task.Run(() =>
{
var options = new ParallelOptions()
{
//CancellationToken = GetCancellationToken()
};
try
{
IEnumerable <IInstallerModule> modules;
if (pickModules != null)
{
modules = pickModules;
}
else
{
modules = Project.ModuleList;
}
var currow = 0;
Parallel.ForEach(modules, options, module =>
{
Interlocked.Add(ref currow, 1);
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++currow, modules.Count(), "Refreshing list...", OperationTag.Active));
try
{
options.CancellationToken.ThrowIfCancellationRequested();
//logger.Info($"Module {module.Name} - Checking status...");
if (module != null && module.Status != InstallerModuleStatus.Refreshing)
{
module.CheckStatus();
}
}
catch (Exception ex)
{
logger.Error($"Error checking status of module {module.FriendlyName}.", ex);
}
});
}
catch (OperationCanceledException)
{
if (throwIfCancelled)
{
throw;
}
}
finally
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(0, StatusName.Idle, OperationTag.None));
}
});
}
private void ReportDatasourceProgress(double dataSourceProgress)
{
double totalProgress = dataSourceProgress * 0.5D;
double wFactor = 1.0D / (double)m_writers.Count() * 0.5D;
foreach (KeyValuePair <string, SignalWritter> writer in m_writers)
{
totalProgress += dataSourceProgress * wFactor * ((-1.0D / 10000.0D) * (double)writer.Value.Backlog + 1.0D);
}
ProgressArgs args = new ProgressArgs("Loading Data.", false, (int)totalProgress);
ReportProgress?.Invoke(this, args);
}
private void PrefetchingTask_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
if (Items.Count > 0)
{
if (ReportProgressSlim is Action)
{
ReportProgressSlim.Invoke(async: false);
}
else if (ReportProgress is Action <double, string, TaskStatus> )
{
ReportProgress.Invoke(Percentage, Comments, State);
}
}
}
private int NotifyProgress(long currentBytes, long totalBytes, int skip)
{
skip++;
if (skip >= 10)
{
skip = 0;
int percent = (int)((currentBytes * 100) / totalBytes);
if (percent > _lastProgress)
{
_lastProgress = percent;
ReportProgress?.Invoke(_lastProgress);
}
}
return(skip);
}
public void Execute(Action action)
{
string key = Guid.NewGuid().ToString();
int res = RmStartSession(out IntPtr handle, 0, key);
if (res == 0)
{
ReportProgress?.Invoke($"Restart Manager session created with ID {key}");
RM_UNIQUE_PROCESS[] processes = GetProcesses("explorer");
res = RmRegisterResources(
handle,
0, null,
(uint)processes.Length, processes,
0, null
);
if (res == 0)
{
ReportProgress?.Invoke("Successfully registered resources.");
res = RmShutdown(handle, RM_SHUTDOWN_TYPE.RmForceShutdown, (percent) => ReportPercentage?.Invoke(percent));
if (res == 0)
{
ReportProgress?.Invoke("Applications stopped successfully.");
action();
res = RmRestart(handle, 0, (percent) => ReportPercentage?.Invoke(percent));
if (res == 0)
{
ReportProgress?.Invoke("Applications restarted successfully.");
}
}
}
res = RmEndSession(handle);
if (res == 0)
{
ReportProgress?.Invoke("Restart Manager session ended.");
}
}
}
private void CopyRun()
{
CopyQueue = new Queue <Uri>();
CopyQueue.OnItemAdded += () =>
{
ReportProgress?.Invoke(FileAction.Copy, CopyQueue.Count);
Uri nextFile;
while ((nextFile = CopyQueue.GetNext()) != null)
{
List <Uri> outputs = workspace.GetSlavesPaths(nextFile);
foreach (var file in outputs)
{
File.Copy(nextFile.AbsolutePath, file.AbsolutePath, true);
}
ReportProgress?.Invoke(FileAction.Copy, CopyQueue.Count);
}
};
}
public void Sort(ref Color[] color)
{
for (int i = 0; i < color.Length; i++)
{
for (int j = 0; j < color.Length - i - 1; j++)
{
int A_Hue = (int)Math.Round(color[j].GetHue());
int A1_Hue = (int)Math.Round(color[j + 1].GetHue());
if (A_Hue > A1_Hue)
{
Swap(color, j, j + 1);
}
ReportProgress?.Invoke();
}
Thread.Sleep((int)Utility.SleepTime);
}
}
private void Work(object ithread)
{
ReportProgress?.Invoke(0);
while (true)
{
int x;
lock (locker) {
if (toBeProcessed.Count == 0)
{
break;
}
x = toBeProcessed.Pop();
}
calculation(x, (int)ithread);
lock (locker) {
tasksDone++;
ReportProgress?.Invoke(tasksDone / (double)nTasks);
}
}
}
private void PrefetchingTask_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (Items.Count > 0)
{
if (State == TaskStatus.Faulted || State == TaskStatus.Canceled)
{
if (ReportProgressSlim is Action)
{
ReportProgressSlim.Invoke(async: false);
}
else if (ReportProgress is Action <double, string, TaskStatus> )
{
ReportProgress.Invoke(Percentage, Comments, State);
}
}
//Application.Current.MergeToSystemPrefetchedList(PrefetchedList);
}
if (CanPrefetching is SemaphoreSlim && CanPrefetching.CurrentCount < 1)
{
CanPrefetching.Release();
}
}
private void PublishImpl(XrmService context, VersioningService gitvc, DeployConfigurationModel deployConfiguration, TelemetryWrapper telemetry, RawChanges[] changes, string project)
{
try
{
ChangeManagerService container = new ChangeManagerService(changes, deployConfiguration.Prefix, context);
telemetry.TrackCustomEventWithCustomMetrics("Deploy Started", new MetricData("Project Name", project));
if (container.WebResources.Count > 0)
{
ReportProgress?.Invoke(this, $"[DYNAMICS] => Found {container.WebResources.Count} Web Resource.");
ReportProgress?.Invoke(this, $"[DYNAMICS] => '{deployConfiguration.Prefix}' used as base path.");
ReportProgress?.Invoke(this, $"[DYNAMICS] => Fetching '{deployConfiguration.Solution}' solution from CRM.");
container.EnsureContinue(deployConfiguration.Solution, deployConfiguration.Prefix);
ReportProgress?.Invoke(this, $"[DYNAMICS] => Publishing changes to the CRM.");
var faultedFlushResult = context.Flush(container.BuildRequestList(deployConfiguration.Solution));
if (!faultedFlushResult && deployConfiguration.CheckInEnabled)
{
ReportProgress?.Invoke(this, $"[AZOPS] => Commit & Push in progress.");
gitvc.CommitAndPush(deployConfiguration.Password);
}
ReportProgress?.Invoke(this, $"[AZOPS] => Publish completed.");
}
telemetry.TrackCustomEventWithCustomMetrics("Deploy Finished", new MetricData("Project Name", project));
}
catch (Exception exception)
{
ReportProgress?.Invoke(this, $"[ERROR] => {exception.Message}\n");
if (!(exception is ToolkitException))
{
telemetry.TrackExceptionWithCustomMetrics(exception);
}
}
}
public void SaveProject(string filename)
{
var saveAwareModules = Project.Modules.OfType <ISaveLoadAware>();
var curmod = 0;
var allmods = saveAwareModules.Count() * 2;
foreach (var module in saveAwareModules)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, allmods, "Saving project..", OperationTag.Active | OperationTag.Cancellable));
module.BeforeSave();
}
System.IO.File.WriteAllText(filename, Project.Serialize());
foreach (var module in Project.Modules.OfType <ISaveLoadAware>())
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, allmods, "Saving project...", OperationTag.Active | OperationTag.Cancellable));
module.AfterSave();
}
Project.Name = System.IO.Path.GetFileName(filename);
NotifyProjectChange();
IsModified = false;
}
public void Download()
{
WebRequest request = WebRequest.Create(downloadItem.SourceName);
request.Credentials = CredentialCache.DefaultCredentials;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
Stream stream = response.GetResponseStream();
Int64 fileSize = response.ContentLength;
const int size = 65535;//4096;
byte[] bytes = new byte[size];
int numBytes = 0;
using (FileStream fileStream = new FileStream(downloadItem.DestinationName, FileMode.Create, FileAccess.Write))
{
while ((numBytes = stream.Read(bytes, 0, size)) > 0)
{
ReportProgress.Invoke(downloadItem);
if (fileStream.Length > 0)
{
downloadItem.Persentage = (int)((float)fileStream.Length / (float)fileSize * 100);
}
downloadItem.State = TaskState.Processing;
fileStream.Write(bytes, 0, numBytes);
}
}
downloadItem.Persentage = 100;
downloadItem.State = TaskState.Completed;
ReportProgress.Invoke(downloadItem);
//const int startPoint = 0;
//Stream strResponse = null;
//Stream strLocal = null;
//HttpWebRequest webRequest = null;
//HttpWebResponse webResponse = null;
//try
//{
// // Put the object argument into an int variable
// int startPointInt = Convert.ToInt32(startPoint);
// // Create a request to the file we are downloading
// webRequest = (HttpWebRequest)WebRequest.Create(downloadItem.SourceName);
// // Set the starting point of the request
// webRequest.AddRange(startPointInt);
// // Set default authentication for retrieving the file
// webRequest.Credentials = CredentialCache.DefaultCredentials;
// // Retrieve the response from the server
// webResponse = (HttpWebResponse)webRequest.GetResponse();
// // Ask the server for the file size and store it
// Int64 fileSize = webResponse.ContentLength;
// // Open the URL for download
// strResponse = webResponse.GetResponseStream();
// // Create a new file stream where we will be saving the data (local drive)
// if (startPointInt == 0)
// {
// strLocal = new FileStream(downloadItem.DestinationName, FileMode.Create, FileAccess.Write, FileShare.None);
// }
// else
// {
// strLocal = new FileStream(downloadItem.DestinationName, FileMode.Append, FileAccess.Write, FileShare.None);
// }
// // It will store the current number of bytes we retrieved from the server
// int bytesSize = 0;
// // A buffer for storing and writing the data retrieved from the server
// byte[] downBuffer = new byte[2048];
// int i = 0;
// // Loop through the buffer until the buffer is empty
// while ((bytesSize = strResponse.Read(downBuffer, 0, downBuffer.Length)) > 0)
// {
// // Write the data from the buffer to the local hard drive
// ReportProgress.Invoke(downloadItem);
// downloadItem.Persentage++;
// downloadItem.State = TaskState.Processing;
// strLocal.Write(downBuffer, 0, bytesSize);
// // Invoke the method that updates the form's label and progress bar
// }
//}
//finally
//{
// // When the above code has ended, close the streams
// strResponse.Close();
// strLocal.Close();
// downloadItem.Persentage = 100;
// downloadItem.State = TaskState.Completed;
// ReportProgress.Invoke(downloadItem);
//}
}
private void BackgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
ReportProgress?.Invoke(this, e);
}
/// <summary>
/// Reveals, unlocks or increment achievement.
/// </summary>
/// <remarks>
/// Call after setting <see cref="id" />, <see cref="completed" />,
/// as well as <see cref="currentSteps" /> and <see cref="totalSteps" />
/// for incremental achievements. Equivalent to calling
/// <see cref="PlayGamesPlatform.ReportProgress" />.
/// </remarks>
public void ReportProgress(Action <bool> callback)
{
mProgressCallback.Invoke(mId, mPercentComplete, callback);
}
/// <summary>
/// Gets the files based on the class initialization.
/// </summary>
/// <param name="path">The path to start enumerating the files from.</param>
/// <param name="subDirectories">if set to <c>true</c> the files in subdirectories are also included in the result.</param>
/// <returns>IEnumerable<System.String>.</returns>
private IEnumerable <string> GetFiles(string path, bool subDirectories)
{
List <string> result = new List <string>();
// a SecurityException or a UnauthorizedAccessException may intrude the enumeration
// process any time and it will also result in exception if the files where enumerated
// solely depending on the Directory.EnumerateFiles(path, ...,SearchOption.AllDirectories)..
try
{
// based on the search type append to the result..
if (SearchType == SearchTypeMatch.Regex)
{
foreach (var file in Directory.EnumerateFiles(path).Where(f => FileExtensionMatch.IsMatch(f)))
{
// the process was requested to be canceled..
if (Canceled)
{
return(result);
}
// report the progress if subscribed..
ReportProgress?.Invoke(this,
new DirectoryCrawlerEventArgs
{
CurrentDirectory = path, FileName = file, Directory = string.Empty
});
// add to the result..
result.Add(file);
}
}
else if (SearchType == SearchTypeMatch.AllFiles || SearchType == SearchTypeMatch.FileMask ||
SearchType == SearchTypeMatch.FilesNoExtension)
{
foreach (var file in Directory.EnumerateFiles(path, SearchMask))
{
// the process was requested to be canceled..
if (Canceled)
{
return(result);
}
// report the progress if subscribed..
ReportProgress?.Invoke(this,
new DirectoryCrawlerEventArgs
{
CurrentDirectory = path, FileName = file, Directory = string.Empty
});
// add to the result..
result.Add(file);
}
}
if (subDirectories)
{
// a SecurityException or a UnauthorizedAccessException may intrude the enumeration
// process any time and it will also result in exception if the directories where
// enumerated solely depending on the Directory.EnumerateDirectories(path, ...,SearchOption.AllDirectories)..
try
{
foreach (var directory in Directory.EnumerateDirectories(path))
{
// the process was requested to be canceled..
if (Canceled)
{
return(result);
}
// report the progress if subscribed..
ReportProgress?.Invoke(this,
new DirectoryCrawlerEventArgs
{
CurrentDirectory = path, FileName = string.Empty, Directory = directory
});
// add to the result..
result.AddRange(GetFiles(directory, true));
}
}
catch (Exception ex)
{
// log the exception..
ExceptionLogAction?.Invoke(ex);
}
}
}
catch (Exception ex)
{
// log the exception..
ExceptionLogAction?.Invoke(ex);
}
return(result);
}
/// <summary>
/// Gets the directories based on the class initialization.
/// </summary>
/// <param name="path">The path to start enumerating the directories from.</param>
/// <param name="subDirectories">if set to <c>true</c> the subdirectories are also included in the result.</param>
/// <returns>IEnumerable<System.String>.</returns>
private IEnumerable <string> GetDirectories(string path, bool subDirectories)
{
List <string> result = new List <string>();
// a SecurityException or a UnauthorizedAccessException may intrude the enumeration
// process any time and it will also result in exception if the directories where
// enumerated solely depending on the Directory.EnumerateDirectories(path, ...,SearchOption.AllDirectories)..
try
{
List <string> directories = new List <string>();
foreach (var directory in Directory.EnumerateDirectories(path))
{
// the process was requested to be canceled..
if (Canceled)
{
return(result);
}
// report the progress if subscribed..
ReportProgress?.Invoke(this,
new DirectoryCrawlerEventArgs
{
CurrentDirectory = path, FileName = string.Empty, Directory = directory
});
result.Add(directory);
directories.Add(directory);
}
if (subDirectories)
{
// a SecurityException or a UnauthorizedAccessException may intrude the enumeration
// process any time and it will also result in exception if the directories where
// enumerated solely depending on the Directory.EnumerateDirectories(path, ...,SearchOption.AllDirectories)..
try
{
foreach (var directory in directories)
{
// the process was requested to be canceled..
if (Canceled)
{
return(result);
}
result.AddRange(GetDirectories(directory, true));
}
}
catch (Exception ex)
{
// log the exception..
ExceptionLogAction?.Invoke(ex);
}
}
}
catch (Exception ex)
{
// log the exception..
ExceptionLogAction?.Invoke(ex);
}
return(result);
}
public bool Solve()
{
Solution = null;
EnqueuePossibleMovements(_initialState, _rows - 1, new List <Movement>());
while (Solution == null)
{
var dequeued = _movementQueue.Dequeue();
var movement = dequeued.Item1;
var visited = dequeued.Item2;
Progress newProgress = new Progress(visited.Count, _movementQueue.Count);
int queueSizeGranularity = 10_000;
if (newProgress.Steps > _currentProgress.Steps || newProgress.QueueSize > _currentProgress.QueueSize + queueSizeGranularity)
{
_currentProgress = new Progress(newProgress.Steps, newProgress.QueueSize - newProgress.QueueSize % queueSizeGranularity);
ReportProgress?.Invoke(this, newProgress);
}
var state = movement.State.Clone();
int dY;
if (movement.MovementDirection == MovementDirection.Up)
{
dY = -1;
}
else
{
dY = 1;
}
var newYPos = movement.ElevatorYPosBefore + dY;
if (newYPos < 0 || newYPos >= _rows)
{
continue;
}
foreach (int x in movement.SelectionXPositions)
{
string tmp = state.GetData(x, movement.ElevatorYPosBefore);
state.MoveOrAdd(x, newYPos, tmp);
state.MoveOrAdd(0, newYPos, "E");
}
var rawState = state.Expand();
List <int> friedChips = new List <int>();
friedChips.AddRange(CheckForFriedMicrochips(rawState, movement.ElevatorYPosBefore));
friedChips.AddRange(CheckForFriedMicrochips(rawState, newYPos));
if (friedChips.Count != 0)
{
continue;
}
else
{
var visitedClone = visited.Clone();
visitedClone.Add(movement);
EnqueuePossibleMovements(state, newYPos, visitedClone);
if (CheckForFinishedState(rawState))
{
visited.Add(movement);
Solution = visited;
}
}
if (_cancellationToken.IsCancellationRequested)
{
break;
}
}
return(Solution != null);
}
protected override void ParseAsXmlStream(Stream stream, ReportProgress ProgressReport)
{
using (XmlTextReader reader = new XmlTextReader(stream))
{
ItemInfo item = new ItemInfo();
string value = null;
while (reader.Read())
{
ProgressReport.Invoke();
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "ROW": item = new ItemInfo(); continue;
default: value = null; break;
}
break;
case XmlNodeType.Text:
value = reader.Value;
break;
case XmlNodeType.EndElement:
switch (reader.Name.ToUpperInvariant())
{
case "ID": item.item = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "ADDITION": item.addition = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PART": item.part = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TYPE": item.type = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PRICE": item.price = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TRADE": item.trade = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "DROP": item.drop = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "NAME": item.name = value; break;
case "QUEST": item.quest = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CLV": item.req_clvl = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_MALE": item.req_male = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_FEMALE": item.req_female = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_NORMAN": item.req_norman = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_ELLR": item.req_ellr = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DIMAGO": item.req_dimago = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_STR": item.req_str = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DEX": item.req_dex = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_INT": item.req_int = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CON": item.req_con = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_LUC": item.req_luc = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_STACK": item.max_stack = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_DUR": item.max_durability = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "SKILL": item.skill = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "OPTION_ID": item.option_id = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "CATEGORIE": item.categorie = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "JOBREQUIREMENT":
string[] values = value.Split(',');
item.JobRequirement = new byte[]
{
byte.Parse(values[0], NumberFormatInfo.InvariantInfo), //NOVICE
byte.Parse(values[1], NumberFormatInfo.InvariantInfo), //SWORDSMAN
byte.Parse(values[3], NumberFormatInfo.InvariantInfo), //RECRUIT
byte.Parse(values[2], NumberFormatInfo.InvariantInfo), //THIEF
byte.Parse(values[4], NumberFormatInfo.InvariantInfo), //ENCHANTER
byte.Parse(values[5], NumberFormatInfo.InvariantInfo), //CLOWN
byte.Parse(values[6], NumberFormatInfo.InvariantInfo), //KNIGHT
byte.Parse(values[7], NumberFormatInfo.InvariantInfo), //ASSASIN
byte.Parse(values[8], NumberFormatInfo.InvariantInfo), //SPECIALIST
byte.Parse(values[9], NumberFormatInfo.InvariantInfo), //SAGE
byte.Parse(values[10], NumberFormatInfo.InvariantInfo), //GAMBLER
byte.Parse(values[11], NumberFormatInfo.InvariantInfo), //FALCATA
byte.Parse(values[12], NumberFormatInfo.InvariantInfo), //FPRSYTHIE
byte.Parse(values[13], NumberFormatInfo.InvariantInfo), //NEMOPHILA
byte.Parse(values[14], NumberFormatInfo.InvariantInfo) //VEILCHENBLAU
};
break;
case "ROW": goto Add;
}
break;
}
continue;
Add:
this.item_drops.Add(item.item, item);
}
}
}
private void ResetStatus()
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs_OLD(0, StatusName.Idle, OperationTrait.Inactive));
}
private void SetStatus(int num, int qty, string messaage)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs_OLD(num, qty, messaage, OperationTrait.Active,
OperationTrait.NoGetProjectAllowed,
OperationTrait.NoSetProjectAllowed));
}
/// <summary>
/// Reveals, unlocks or increment achievement.
/// </summary>
/// <remarks>
/// Call after setting <see cref="id" />, <see cref="completed" />,
/// as well as <see cref="currentSteps" /> and <see cref="totalSteps" />
/// for incremental achievements. Equivalent to calling
/// <see cref="PlayGamesPlatform.ReportProgress" />.
/// </remarks>
public void ReportProgress(Action <bool> callback)
{
mProgressCallback.Invoke(id, percentCompleted, callback);
}
// This event handler updates the progress bar.
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
percentCompleted = e.ProgressPercentage;
ReportProgress?.Invoke(sender, e);
}
protected override void ParseAsXmlStream(Stream stream, ReportProgress ProgressReport)
{
using (XmlTextReader reader = new XmlTextReader(stream))
{
ItemInfo item = new ItemInfo();
string value = null;
while (reader.Read())
{
ProgressReport.Invoke();
switch (reader.NodeType)
{
case XmlNodeType.Element:
switch (reader.Name.ToUpperInvariant())
{
case "ROW": item = new ItemInfo(); continue;
default: value = null; break;
}
break;
case XmlNodeType.Text:
value = reader.Value;
break;
case XmlNodeType.EndElement:
switch (reader.Name.ToUpperInvariant())
{
case "ID": item.item = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "ADDITION": item.addition = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PART": item.part = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TYPE": item.type = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "PRICE": item.price = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "TRADE": item.trade = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "DROP": item.drop = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "NAME": item.name = value; break;
case "QUEST": item.quest = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CLV": item.req_clvl = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_MALE": item.req_male = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_FEMALE": item.req_female = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_NORMAN": item.req_norman = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_ELLR": item.req_ellr = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DIMAGO": item.req_dimago = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_STR": item.req_str = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_DEX": item.req_dex = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_INT": item.req_int = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_CON": item.req_con = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "REQ_LUC": item.req_luc = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_STACK": item.max_stack = byte.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "MAX_DUR": item.max_durability = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "SKILL": item.skill = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "OPTION_ID": item.option_id = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "CATEGORIE": item.categorie = uint.Parse(value, NumberFormatInfo.InvariantInfo); break;
case "JOBREQUIREMENT":
string[] values = value.Split(',');
item.JobRequirement = new byte[]
{
byte.Parse(values[0], NumberFormatInfo.InvariantInfo), //NOVICE
byte.Parse(values[1], NumberFormatInfo.InvariantInfo), //SWORDSMAN
byte.Parse(values[3], NumberFormatInfo.InvariantInfo), //RECRUIT
byte.Parse(values[2], NumberFormatInfo.InvariantInfo), //THIEF
byte.Parse(values[4], NumberFormatInfo.InvariantInfo), //ENCHANTER
byte.Parse(values[5], NumberFormatInfo.InvariantInfo), //CLOWN
byte.Parse(values[6], NumberFormatInfo.InvariantInfo), //KNIGHT
byte.Parse(values[7], NumberFormatInfo.InvariantInfo), //ASSASIN
byte.Parse(values[8], NumberFormatInfo.InvariantInfo), //SPECIALIST
byte.Parse(values[9], NumberFormatInfo.InvariantInfo), //SAGE
byte.Parse(values[10], NumberFormatInfo.InvariantInfo), //GAMBLER
byte.Parse(values[11], NumberFormatInfo.InvariantInfo), //FALCATA
byte.Parse(values[12], NumberFormatInfo.InvariantInfo), //FPRSYTHIE
byte.Parse(values[13], NumberFormatInfo.InvariantInfo), //NEMOPHILA
byte.Parse(values[14], NumberFormatInfo.InvariantInfo) //VEILCHENBLAU
};
break;
case "ROW": goto Add;
}
break;
}
continue;
Add:
this.item_drops.Add(item.item, item);
}
}
}
private void _RaiseReportProgress(int value) => ReportProgress?.Invoke(this, new UpdateProgressEventArgs(value));
public async Task InstallAllModules()
{
try
{
await RefreshModuleStatus(throwIfCancelled : true);
}
catch (OperationCanceledException)
{
return;
}
await Task.Run(() =>
{
try
{
var options = new ParallelOptions()
{
//CancellationToken = GetCancellationToken()
};
Parallel.ForEach(Project.ModuleList.Where(m => m.Status == InstallerModuleStatus.NotInstalled), options, module =>
{
try
{
options.CancellationToken.ThrowIfCancellationRequested();
module.PrepareInstall();
}
catch (Exception ex)
{
logger.Error($"Error preparing module {module.FriendlyName} for install.", ex);
}
});
}
catch (OperationCanceledException)
{
return;
}
var refreshTasks = new List <Task>();
//var token = GetCancellationToken();
var pending = Project.ModuleList.Where(m => m.Status == InstallerModuleStatus.InstallationPending);
var curmod = 0;
var allmods = pending.Count();
foreach (var module in pending)
{
ReportProgress?.Invoke(this, new ReportProgressEventArgs(++curmod, allmods, $"Installing module {module.FriendlyName ?? module.Name}...", OperationTag.Active));
try
{
//token.ThrowIfCancellationRequested();
module.Install();
refreshTasks.Add(Task.Run(() => module.CheckStatus()));
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
logger.Error($"Error installing module {module.FriendlyName}.", ex);
}
}
Task.WaitAll(refreshTasks.ToArray());
ReportProgress?.Invoke(this, new ReportProgressEventArgs(0, StatusName.Idle, OperationTag.None));
});
}