protected void OnWorkerStarting(WorkState state)
{
if (WorkStarting != null)
{
WorkStarting(this, new WorkStateEventArgs(state));
}
}
protected override WorkState Do()
{
WorkState state = new WorkState(this);
ValueToCheck = true;
return(state);
}
public Form1()
{
InitializeComponent();
WorkState = WorkState.DownloadAndInstall;
ReadInstallInfo();
ReadSetting();
if (!Directory.Exists(Utility.DownloadDirectory))
{
Directory.CreateDirectory(Utility.DownloadDirectory);
}
var pbColumn = new DataGridViewProgressBarColumn
{
Name = download,
ReadOnly = true
};
dataGridView1.Columns.Add(pbColumn);
pbColumn = new DataGridViewProgressBarColumn
{
Name = install,
ReadOnly = true
};
dataGridView1.Columns.Add(pbColumn);
CheckSetting();
CheckLangFiles();
SetLanguage(langFileName);
}
public Work()
{
_state = WorkState.INIT;
_description = string.Empty;
_priority = ThreadPriority.Normal;
_eventArgs = new WorkEventArgs(this);
}
public Device()
{
stateRegs = new WorkState();
stateRegs = WorkState.Idle;
//Regs_Update = new BackgroundWorker();
//Regs_Update.WorkerSupportsCancellation = true;
//Regs_Update.WorkerReportsProgress = true;
//Regs_Update.DoWork += Regs_Update_DoWork;
//Regs_Update.ProgressChanged += Regs_Update_ProgressChanged;
m_mbMaster = ModbusSerialMaster.CreateRtu(COM);
m_mbMaster.Transport.ReadTimeout = 100;
m_mbMaster.Transport.Retries = 3;
m_mbMaster.Transport.SlaveBusyUsesRetryCount = true;
m_mbMaster.Transport.WaitToRetryMilliseconds = 100;
m_bgwModbusUpdater = new BackgroundWorker();
m_bgwModbusUpdater.WorkerSupportsCancellation = true;
m_bgwModbusUpdater.WorkerReportsProgress = true;
m_bgwModbusUpdater.DoWork += M_bgwModbusUpdater_DoWork;;
m_bgwModbusUpdater.ProgressChanged += M_bgwModbusUpdater_ProgressChanged;;
m_bgwModbusUpdater.RunWorkerAsync();
Regs = new common.devices.ACID_Stend.Registers();
}
private void NotifyStateChanged(WorkState currentState)
{
if (currentState == WorkState.PLAYING)
{
DoStart();
if (onStart != null)
{
onStart();
}
}
else if (currentState == WorkState.FINISHED)
{
DoFinish();
if (onFinish != null)
{
onFinish();
}
}
else if (currentState == WorkState.PREPARING)
{
DoPrepare();
}
else if (currentState == WorkState.WAITING)
{
DoInit();
}
}
/// <summary>
/// Событие изменения прогресс-бара.</summary>
void bgw_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
WorkState state = (WorkState)e.UserState;
textBoxProcessed.Text = state.filesPocessed.ToString();
textBoxTotalSize.Text = SizeSuffix(totalSize, 1);
}
public void SaveDat(string nameDat, bool isAppend)
{
this.state = (isAppend) ? WorkState.SaveAppend : WorkState.Save;
this.nameDat = nameDat;
this.ShowDialog(ownerFrm);
}
public void RemoveFile(ListView.SelectedListViewItemCollection list)
{
this.state = WorkState.Delete;
this.list = list;
this.ShowDialog(ownerFrm);
}
public void OnError(object _, Exception e)
{
State = WorkState.Errored;
receiver?.Stop().Wait();
sender?.Stop().Wait();
Errored?.Invoke(this, e);
}
private static async Task FinalizationAsync(WorkState state)
{
if (LogOutcome)
{
if (state.AllStepsSuccess)
{
_logger.LogInformation($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Id: {state.Message?.MessageId} - Finished route successfully.");
}
else
{
_logger.LogInformation($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Id: {state.Message?.MessageId} - Finished route unsuccesfully.");
}
}
// Lastly mark the excution pipeline finished for this message.
state.ReceivedData?.Complete(); // This impacts wait to completion step in the Pipeline.
if (AwaitShutdown)
{
Interlocked.Increment(ref CurrentCount);
if (CurrentCount == GlobalCount - 1)
{
Stopwatch.Stop();
await _workflow.StopAsync().ConfigureAwait(false);
}
}
}
public bool Execute(int canId, int hostId, List <byte> appData)
{
switch (WorkState)
{
case WorkStateEnum.Idle:
InitFramesToSend(appData);
WorkState = WorkStateEnum.Send;
CanId = canId;
HostId = hostId;
if (appData.Count > 1)
{
SuppressResp = ((byte)0x80 & appData[1]) != 0;
}
else
{
SuppressResp = false;
}
return(false);
case WorkStateEnum.Send:
return(Send());
case WorkStateEnum.Receive:
return(Receive());
default:
throw new InvalidOperationException("DcmTpProtocalISO15765.Send: Unknown work " +
"state -> " + WorkState.ToString());
}
}
public Link(string Url, LocationUrl location, int timeDuration = -1)
{
this.Url = Url;
this.LocationUrl = location;
this.TimeDuration = timeDuration;
this.WorkState = WorkState.Create;
}
protected override WorkState Do()
{
B.ILogger threaded = Logger as B.ILogger;
if (threaded != null)
{
threaded.RestartLoggingThread();
}
this.CheckRequiredProperties();
FileInfo[] projectFiles = GetBuildFiles();
StringBuilder message = new StringBuilder();
projectFiles.Each(projectFile =>
{
message.AppendLine(Build(projectFile, _results));
});
WorkState <ProjectBuildResult[]> workState = new WorkState <ProjectBuildResult[]>(this, BuildResults);
ProjectBuildResult[] failures = BuildResults.Where(br => br.BuildResult.OverallResult == BuildResultCode.Failure).ToArray();
workState.Status = failures.Length == 0 ? Status.Succeeded: Status.Failed;
workState.Message = message.ToString();
return(workState);
}
private WorkState AckMessage(WorkState state)
{
_logger.LogDebug($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Id: {state.Message?.MessageId} - Process Step Success? {state.ProcessStepSuccess}");
if (state.ProcessStepSuccess)
{
_logger.LogDebug($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Id: {state.Message?.MessageId} - Acking message...");
if (state.ReceivedData.AckMessage())
{
state.AcknowledgeStepSuccess = true;
}
}
else
{
_logger.LogDebug($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Id: {state.Message?.MessageId} - Nacking message...");
if (state.ReceivedData.NackMessage(true))
{
state.AcknowledgeStepSuccess = true;
}
}
return(state);
}
private async Task ErrorHandlingAsync(WorkState state)
{
var failed = await _rabbitService
.Publisher
.PublishAsync("", "TestRabbitServiceQueue.Error", state.ReceivedData.Data, null)
.ConfigureAwait(false);
var stringBody = string.Empty;
try
{ stringBody = Encoding.UTF8.GetString(state.ReceivedData.Data); }
catch (Exception ex)
{
_logger.LogError(ex, "What?!");
}
if (failed)
{
_logger.LogError($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - This failed to deserialize and publish to ErrorQueue!\r\n{stringBody}\r\n");
}
else
{
_logger.LogError($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - This failed to deserialize. Published to ErrorQueue!\r\n{stringBody}\r\n");
}
}
private async Task <WorkState> DeserializeStepAsync(IReceivedData receivedData)
{
var state = new WorkState
{
ReceivedData = receivedData
};
try
{
state.Message = state.ReceivedData.ContentType switch
{
Constants.HeaderValueForLetter => await receivedData
.GetTypeFromJsonAsync <Message>()
.ConfigureAwait(false),
_ => await receivedData
.GetTypeFromJsonAsync <Message>(decrypt : false, decompress : false)
.ConfigureAwait(false),
};
if (state.ReceivedData.Data.Length > 0 && (state.Message != null || state.ReceivedData.Letter != null))
{
state.DeserializeStepSuccess = true;
}
}
catch
{ }
return(state);
}
private void WorkStateSearching()
{ // start with a clean list
m_itemsNear.Clear();
IPooledEnumerable eable = GetItemsInRange(m_scanRangeNear);
foreach (Item item in eable)
{
if (IgnoreFilter(item) || !this.InLOS(item))
{
continue;
}
if (m_itemsNear.Contains(item) == false)
{
m_itemsNear.Add(item);
}
}
eable.Free();
// post process list to allow things like a couple marked runes
AllowFilter(m_itemsNear);
if (m_itemsNear.Count > 0)
{
m_workState = WorkState.Pickup;
}
else
{
m_workState = WorkState.SearchFar;
}
}
public void Tick(float deltaTime)
{
try
{
if (state != WorkState.PLAYING)
{
return;
}
OnTick(deltaTime);
onTick?.Invoke(deltaTime);
if (GetCurrent() >= GetTotal())
{
state = WorkState.FINISHED;
OnFinished();
onFinish?.Invoke();
}
}
catch (Exception e)
{
if (exceptionHandler != null)
{
exceptionHandler(e);
}
else
{
throw;
}
}
}
public void Given_()
{
var state = TempFolderStateProvider.CreateInTempFolder("When_read_state_never_saved_before_" + Guid.NewGuid().ToString());
_storagePath = state.StoragePath;
_readState = state.Retrieve("Foo1");
}
public Work()
{
_state = WorkState.INIT;
_description = string.Empty;
_priority = ThreadPriority.Normal;
_eventArgs = new WorkEventArgs(this);
}
public void SetToIdle()
{
if (State == WorkState.Idle)
{
return;
}
Logger.Log("Setting database worker to Idle");
switch (State)
{
case WorkState.CleanSearching:
break;
case WorkState.Populating:
m_currentTaskCancellation?.Cancel();
m_currentTaskCancellation = null;
m_populateTask = m_populateSearchTask = null;
break;
case WorkState.Cleaning:
break;
}
State = WorkState.Idle;
m_onSetToIdleCallback?.Invoke();
m_onSetToIdleCallback = null;
}
public static int getTableIndex(WorkState w)
{
int index = 0;
switch (w)
{
case WorkState.Empty:
index = 0;
break;
case WorkState.WayToLoad:
index = 1;
break;
case WorkState.Loading:
index = 2;
break;
case WorkState.WayToUnload:
index = 3;
break;
case WorkState.Unloading:
index = 4;
break;
default:
break;
}
return(index);
}
private WorkState DeserializeStep(IReceivedData receivedData)
{
var state = new WorkState
{
ReceivedData = receivedData
};
try
{
state.Message = state.ReceivedData.ContentType switch
{
HouseofCat.RabbitMQ.Constants.HeaderValueForLetter =>
_serializationProvider
.Deserialize <Message>(state.ReceivedData.Letter.Body),
_ => _serializationProvider
.Deserialize <Message>(state.ReceivedData.Data),
};
if (state.ReceivedData.Data.Length > 0 && (state.Message != null || state.ReceivedData.Letter != null))
{
state.DeserializeStepSuccess = true;
}
}
catch
{ }
return(state);
}
private WorkReport(AppealCase ac, CaseStage stage, WorkerRole role, WorkState state)
{
Case = ac;
Stage = stage;
Role = role;
State = state;
}
/// <summary>
/// Start processing logic
/// </summary>
public bool StartProcessing()
{
try {
if (thread == null)
{
log.WriteAction(Localization.UseRussian ? "Запуск обработки логики" : "Start logic processing");
PrepareProcessing();
thread = new Thread(new ThreadStart(Execute));
thread.Start();
}
else
{
log.WriteAction(Localization.UseRussian
? "Обработка логики уже запущена"
: "Logic processing is already started");
}
} catch (Exception ex) {
log.WriteException(ex,
Localization.UseRussian
? "Ошибка при запуске обработки логики"
: "Error starting logic processing");
} finally {
if (thread == null)
{
workState = WorkState.Error;
WriteInfo();
}
}
return(true);
}
private async Task <WorkState> AckMessageAsync(WorkState state)
{
await Task.Yield();
_output
.WriteLine($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - LetterId: {state.LetterId} - Process Step Success? {state.ProcessStepSuccess}");
if (state.ProcessStepSuccess)
{
_output
.WriteLine($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - LetterId: {state.LetterId} - Acking message...");
if (state.ReceivedData.AckMessage())
{
state.AcknowledgeStepSuccess = true;
}
}
else
{
_output
.WriteLine($"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - LetterId: {state.LetterId} - Nacking message...");
if (state.ReceivedData.NackMessage(true))
{
state.AcknowledgeStepSuccess = true;
}
}
return(state);
}
private void OnWorkCompleted(WorkState e)
{
var workResult = e == WorkState.Success;
var handler = WorkCompleted;
if (handler != null) handler(this, new WorkResult() { IsSuccess = workResult });
}
/// <summary>
/// Остановить обработку логики
/// </summary>
public void StopProcessing()
{
try
{
if (thread != null)
{
terminated = true;
if (thread.Join(WaitForStop))
{
log.WriteAction(Localization.UseRussian ?
"Обработка логики остановлена" :
"Logic processing is stopped");
}
else
{
thread.Abort();
log.WriteAction(Localization.UseRussian ?
"Обработка логики прервана" :
"Logic processing is aborted");
}
thread = null;
}
}
catch (Exception ex)
{
workState = WorkState.Error;
WriteInfo();
log.WriteException(ex, Localization.UseRussian ?
"Ошибка при остановке обработки логики" :
"Error stopping logic processing");
}
}
protected override WorkState CanChangeState(WorkState currentState)
{
if (currentState == WorkState.PLAYING && current == works.Count)
{
return(WorkState.FINISHED);
}
return(base.CanChangeState(currentState));
}
private WorkState LogStep(WorkState state)
{
_output
.WriteLine(
$"{DateTime.Now:yyyy/MM/dd hh:mm:ss.fff} - Logging - LetterId: {state.LetterId} - All Steps Success? {state.AllStepsSuccess}");
return(state);
}
protected override WorkState CanChangeState(WorkState currentState)
{
if (currentState == WorkState.PLAYING && conditionSatisfied && (then == null || then.IsFinished()))
{
return(WorkState.FINISHED);
}
return(base.CanChangeState(currentState));
}
private void setState(WorkState s)
{
m_state = s;
Error.Visibility = s == WorkState.Error ? Visibility.Visible : Visibility.Collapsed;
Loader.Visibility = s == WorkState.GettingLocation || s == WorkState.Geocoding ? Visibility.Visible : Visibility.Collapsed;
Done.IsEnabled = s == WorkState.Done;
Consent.Visibility = s == WorkState.WaitingForConsent ? Visibility.Visible : Visibility.Collapsed;
LocationLabel.Visibility = s == WorkState.Done ? Visibility.Visible : Visibility.Collapsed;
}
public Work(DoWorkHandler work, string description, ThreadPriority threadPriority, WorkEventHandler workCompletedHandler)
{
WorkLoad = work;
_description = description;
_priority = threadPriority;
WorkCompleted = workCompletedHandler;
_eventArgs = new WorkEventArgs(this);
_simpleWork = true;
_state = WorkState.INIT;
}
private void start_operation()
{
log.debug("Starting operation...");
progressBar.Maximum = 100;
progressBar.Minimum = 0;
startButton.Text = get_lang_string("gui_dialog_startButton_cancel");
state = WorkState.running;
backgroundProcessor.RunWorkerAsync();
}
private void cancel_operation()
{
log.info("Cancelling work");
backgroundProcessor.CancelAsync();
startButton.Text = get_lang_string("gui_dialog_startButton_cancelling");
state = WorkState.canceling;
}
public EmailEntry()
{
state = WorkState.Init;
}
static WorkState()
{
Normal = new WorkState() { State = 1, Name = "正常" };
Fault = new WorkState() { State = 2, Name = "偶有故障" };
FrequentlyFault = new WorkState() { State = 3, Name = "故障频繁" };
ForRepair = new WorkState() { State = 4, Name = "待修" };
Repairing = new WorkState() { State = 5, Name = "修理中" };
ForCrapped = new WorkState() { State = 6, Name = "待报废" };
WorkStates = new Dictionary<int, WorkState>();
WorkStates.Add(Normal.State, Normal);
WorkStates.Add(Fault.State, Fault);
WorkStates.Add(FrequentlyFault.State, FrequentlyFault);
WorkStates.Add(ForRepair.State, ForRepair);
WorkStates.Add(Repairing.State, Repairing);
WorkStates.Add(ForCrapped.State, ForCrapped);
WorkStatesList = new List<WorkState>();
WorkStatesList.Add(Normal);
WorkStatesList.Add(Fault);
WorkStatesList.Add(FrequentlyFault);
WorkStatesList.Add(ForRepair);
WorkStatesList.Add(Repairing);
WorkStatesList.Add(ForCrapped);
}
private void SetWorkState(WorkState state)
{
_sc.Post(delegate
{
switch (state)
{
case WorkState.Inited:
case WorkState.Generated:
case WorkState.GeneratingCanceled:
gbGenerator.IsEnabled = true;
gbAPI.IsEnabled = true;
tbDic.IsEnabled = true;
tbDomains.IsEnabled = true;
buCheck.IsEnabled = true;
buCheck.Content = STR_BU_CHECK;
buPreview.IsEnabled = true;
buPreview.Content = STR_BU_GENERATE;
Title = STR_TITLE;
if (state == WorkState.Inited)
pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Collapsed;
break;
case WorkState.Generating:
gbGenerator.IsEnabled = true;
gbAPI.IsEnabled = false;
tbDic.IsEnabled = false;
tbDomains.Tag = null;
tbDomains.Text = "";
tbDomains.IsEnabled = false;
buCheck.IsEnabled = false;
buCheck.Content = STR_BU_CHECK;
buPreview.IsEnabled = true;
buPreview.Content = STR_BU_STOP;
Title = STR_TITLE;
pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Visible;
break;
case WorkState.GeneratingCanceling:
gbGenerator.IsEnabled = false;
gbAPI.IsEnabled = false;
tbDic.IsEnabled = false;
tbDomains.IsEnabled = false;
buCheck.IsEnabled = false;
buPreview.IsEnabled = false;
Title = STR_TITLE;
buCheck.Content = STR_BU_CHECK;
pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Collapsed;
break;
case WorkState.Checking:
lbResultUnknown.Items.Clear();
lbResultRegisted.Items.Clear();
lbResultUnRegisted.Items.Clear();
gbGenerator.IsEnabled = false;
gbAPI.IsEnabled = false;
tbDic.IsEnabled = false;
tbDomains.IsEnabled = false;
tbDomains.IsReadOnly = true;
buCheck.IsEnabled = true;
buPreview.IsEnabled = false;
Title = STR_TITLE;
buCheck.Content = STR_BU_STOP;
pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Visible;
break;
case WorkState.CheckCanceling:
gbGenerator.IsEnabled = false;
gbAPI.IsEnabled = false;
tbDic.IsEnabled = false;
tbDomains.IsEnabled = true;
tbDomains.IsReadOnly = true;
buCheck.IsEnabled = false;
buPreview.IsEnabled = false;
Title = string.Format("{0}, {1}", STR_TITLE, STR_STOPPING);
buCheck.Content = STR_STOPPING;
pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Visible;
break;
case WorkState.CheckCanceled:
gbGenerator.IsEnabled = true;
gbAPI.IsEnabled = true;
tbDic.IsEnabled = true;
tbDomains.IsEnabled = true;
tbDomains.IsReadOnly = false;
buCheck.IsEnabled = true;
buPreview.IsEnabled = true;
Title = string.Format("{0}, {1}", STR_TITLE, STR_STOPPPED);
buCheck.Content = STR_BU_CHECK;
//pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Collapsed;
break;
case WorkState.CheckCompleted:
gbGenerator.IsEnabled = true;
gbAPI.IsEnabled = true;
tbDic.IsEnabled = true;
tbDomains.IsEnabled = true;
tbDomains.IsReadOnly = false;
buCheck.IsEnabled = true;
buPreview.IsEnabled = true;
Title = string.Format("{0}, {1}", STR_TITLE, STR_COMPLETED);
buCheck.Content = STR_BU_CHECK;
//pb.ContentStringFormat = STR_READY;
pb.Value = 0;
pb.ProgressBar.Visibility = Visibility.Collapsed;
break;
break;
default:
break;
}
tbAPI_url.IsEnabled =
tbAPI_a_partten.IsEnabled =
tbAPI_u_partten.IsEnabled = (cbAPI_opt.SelectedValue as string == STR_CBAPI_OPT_CUSTOM);
}, null);
}
public void Start(List<object> parameters)
{
try
{
if (_scanState == WorkState.Stopped)
{
Threads = new Dictionary<Thread, ThreadContext>();
Log("Creating threads...", this.GetType().Name, LogType.Message, "Start");
foreach (object param in parameters as IEnumerable<object>)
{
/*ParameterizedThreadStart pts = new ParameterizedThreadStart(FactoryMethod);
Thread th = new Thread(pts);
ThreadContext tc = new ThreadContext(param, th, Thread.CurrentThread, this);
th.IsBackground = true;
th.Start(tc);*/
ThreadContext tc = GetThreadContext(param);
Threads.Add(tc.CurrentThread, tc);
}
_scanState = WorkState.Run;
}
else if (_scanState == WorkState.Pause)
{
foreach (Thread t in Threads.Keys)
t.Start();
}
}
catch (Exception ex)
{
Log(string.Format("{0} \r\n{1}", ex.Message, ex.StackTrace), this.GetType().Name, LogType.Error, "CoreConstructor");
}
}
private void OnWorkCompleted(WorkState e)
{
emailEntry.State = e;
if (e == WorkState.Success)
emailEntry.IsCompleted = true;
var handler = WorkCompleted;
if (handler != null)
handler(this, new WorkResult() { IsSuccess = emailEntry.IsCompleted });
}
public void Stop()
{
try
{
foreach (KeyValuePair<Thread, ThreadContext> t in Threads)
{
t.Value.Stop = true;
}
_scanState = WorkState.Stopped;
}
catch (Exception ex)
{
Log(string.Format("{0} \r\n{1}", ex.Message, ex.StackTrace), "SpydeeCore", LogType.Error, "CoreConstructor");
}
}
public SpydeeCore(SystemConfig sc)
{
_config = sc;
this._scanState = WorkState.Stopped;
}
public DialerEntry()
{
state = WorkState.Init;
}
/// <summary>
/// Raises the decompression event.
/// </summary>
/// <param name="curState">Current state.</param>
/// <param name="szUrl">Size URL.</param>
/// <param name="szPath">Size path.</param>
/// <param name="nPosition">N position.</param>
/// <param name="nReadSpeed">N read speed.</param>
/// <param name="nFileLength">N file length.</param>
/// <param name="szVersion">Size version.</param>
public bool OnDecompression(WorkState curState, string szUrl, string szPath,
int nPosition, int nReadSpeed, int nFileLength, string szVersion)
{
string text = LogicHelper.GetErrorText(ErrorCode.ERR_DECOMPRESS);
if (!string.IsNullOrEmpty(text))
{
float fProg = (float)nPosition / (float)nPosition;
Progress = fProg;
Text = string.Format("{0} {1}MB/{2}MB {3}KB ({4})%", text, ToMB(nPosition),
ToMB(nFileLength), ToKB(nReadSpeed), (int)(fProg * 100));
}
return true;
}
/// <summary>
/// Cancels processing of this work.
/// </summary>
/// <returns><c>true</c>, if the work was cancelled, else <c>false</c>.</returns>
public bool Cancel()
{
if (_state == WorkState.INIT || _state == WorkState.INQUEUE)
{
_state = WorkState.CANCELED;
return true;
}
else
return false;
}
/// <summary>
/// Raises the download finished event.
/// </summary>
/// <param name="curState">Current state.</param>
/// <param name="szUrl">Size URL.</param>
/// <param name="szPath">Size path.</param>
/// <param name="nPosition">N position.</param>
/// <param name="nReadSpeed">N read speed.</param>
/// <param name="nFilength">N filength.</param>
/// <param name="szVersion">Size version.</param>
public bool OnDownloading(WorkState curState, string szUrl, string szPath,
int nPosition, int nReadSpeed, int nFileLength, string szVersion)
{
string text = LogicHelper.GetErrorText(ErrorCode.ERR_DOWNLOAD);
if (!string.IsNullOrEmpty(text))
{
float fProg = (float)nPosition / (float)nPosition;
Progress = fProg;
Text = string.Format("{0} {1}MB/{2}MB {3}KB ({4})%", text, ToMB(nPosition),
ToMB(nFileLength), ToKB(nReadSpeed), (int)(fProg * 100));
}
// download finished descompress the package to local file system
if (curState == WorkState.HS_COMPLETED)
{
HttpDownloadManager.GetSingleton().Decompression(szPath,
PersistentDataPath, szVersion, OnDecompression);
}
return true;
}
public void Pause()
{
try
{
if (_scanState == WorkState.Run)
{
foreach (KeyValuePair<Thread, ThreadContext> t in Threads)
{
//t.Key.();
}
_scanState = WorkState.Pause;
}
else if (_scanState == WorkState.Pause)
{
foreach (KeyValuePair<Thread, ThreadContext> t in Threads)
{
t.Key.Interrupt();
}
}
}
catch (Exception ex)
{
Log(string.Format("{0} \r\n{1}", ex.Message, ex.StackTrace), "SpydeeCore", LogType.Error, "CoreConstructor");
}
}
private void WorkStateSearchFar()
{
ArrayList itemsFar = new ArrayList();
IPooledEnumerable eable = GetItemsInRange(m_scanRangeFar);
foreach (Item item in eable)
{
// we check LOS to prevent grounds keepers tossing their waypoint to some item on the ground if they are on the roof
// there's probably another groundskeeper there already to take care of that one
if (IgnoreFilter(item) || !this.InLOS(item))
continue;
if (itemsFar.Contains(item) == false)
itemsFar.Add(item);
}
eable.Free();
// post process list to allow things like a couple marked runes
AllowFilter(itemsFar);
if (itemsFar.Count > 0)
{
Item item = itemsFar[Utility.Random(itemsFar.Count)] as Item;
// drop an auto deleting waypoint at this bit of rubbish. DoActionWander will drive the mob towards the WayPoint
// when we arrive at the waypoint, it will auto distruct.
DestroyWayPoints(); // destroy the old waypoints
this.CurrentWayPoint = new AutoWayPoint();
this.CurrentWayPoint.MoveToWorld(item.Location, item.Map);
m_wayPointList.Add(this.CurrentWayPoint);
}
// go Idle while we wander over to the trash
m_workState = WorkState.Idle;
}
private void WorkStatePickup()
{
int count = 0;
foreach (Item item in m_itemsNear)
{
if (IgnoreFilter(item) || !this.InLOS(item))
continue;
// is the item now out of range?
if (this.GetDistanceToSqrt(item) > m_reach)
{
DebugSay("We must have walked past the item");
continue;
}
else
{
DebugSay("We will delete item {0}", item);
item.Delete();
}
// only do so much work on each tick
if (count++ > 20)
break;
}
m_itemsNear.Clear(); // since we're going to rescan anyway, there's no sense in remembering these items
if (count > 0 && Utility.RandomBool()) // let the world know what we're doing
Emote("*picks up trash*");
if (count > 0) // only delete if we're not picking up trash
ResetTimer();
// go look for more trash
m_workState = WorkState.Searching;
}
private void WorkStateIdle()
{ // just advance to the looking around state
m_workState = WorkState.Searching;
}
void OnWorkCompleted(WorkState e)
{
if(Interlocked.Exchange(ref completed, 1) != 0)
return;
entry.State = e;
entry.IsCompleted = e == WorkState.Success || e == WorkState.HungUpByRemote;
var handler = WorkCompleted;
if (handler != null)
handler(this, new WorkResult() { IsSuccess = entry.IsCompleted });
CleanUp();
}
// simple state machine - called on each OnThink() tick
private void ProcessWorkState()
{
switch (m_workState)
{
default: m_workState = WorkState.Idle; break;
case WorkState.Idle: WorkStateIdle(); break;
case WorkState.Searching: WorkStateSearching(); break;
case WorkState.SearchFar: WorkStateSearchFar(); break;
case WorkState.Pickup: WorkStatePickup(); break;
}
}
private void WorkStateSearching()
{ // start with a clean list
m_itemsNear.Clear();
IPooledEnumerable eable = GetItemsInRange(m_scanRangeNear);
foreach (Item item in eable)
{
if (IgnoreFilter(item) || !this.InLOS(item))
continue;
if (m_itemsNear.Contains(item) == false)
m_itemsNear.Add(item);
}
eable.Free();
// post process list to allow things like a couple marked runes
AllowFilter(m_itemsNear);
if (m_itemsNear.Count > 0)
m_workState = WorkState.Pickup;
else
m_workState = WorkState.SearchFar;
}
