private void DataUpdateEventHandler(object sender, DataUpdateEventArgs args)
{
if (isVisible)
{
if (updating)
{
UpdateAltitudeBuffer(args.DataSets);
}
else
{
updating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAltitude(args.DataSets);
updating = false;
});
}
}
else
{
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAltitudeBuffer(args.DataSets);
});
}
}
private void DataUpdateHandler(object sender, DataUpdateEventArgs args)
{
if (this._rTData.ContainsKey(args.TagName))
{
this._rTData[args.TagName] = args.TagData;
}
}
private void DataUpdateEventHandler(object sender, DataUpdateEventArgs args)
{
if (args.DataSets == null || args.DataSets.Count == 0)
{
return; // No updating to be done
}
generalService.FlightMode = args.DataSets.Last().FlightMode; //Set flight mode to most up to date value
if (isVisible)
{
if (motUpdating)
{
UpdateMotorBuffer(args.DataSets);
}
else
{
motUpdating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateMotors(args.DataSets);
motUpdating = false;
});
}
}
else
{
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateMotorBuffer(args.DataSets);
});
}
}
public async Task UpdateWater()
{
// Fetch values from API
var response = await _graphQLService.FetchValuesAsync <WatersResponse>(Queries.Waters);
// Insert or Update values
foreach (var water in response.Waters)
{
var tmp = await _repositoryWrapper.Waters.GetByUuidAsync(water.Pk);
if (tmp == null)
{
await _repositoryWrapper.Waters.InsertAsync(water);
}
else if (tmp.Updated != water.Updated)
{
await _repositoryWrapper.Waters.UpdateAsync(tmp.Id, water);
}
}
// Fire event
var eventArgs = new DataUpdateEventArgs <Water>
{
Type = DataT.Water,
Data = await _repositoryWrapper.Waters.GetAllAsync()
};
_eventAggregator
.GetEvent <UpdateReadyEvent <Water> >()
.Publish(eventArgs);
}
public async Task UpdateMarina()
{
var response = await _graphQLService
.FetchValuesAsync <MarinasResponse>(Queries.Marinas)
.ConfigureAwait(false);
foreach (var marina in response.Ports.OrderBy(_ => _.Name))
{
marina.WaterPk = marina.Water.Pk;
var tmp = await _repositoryWrapper.Marinas.GetByUuidAsync(marina.Pk);
if (tmp == null)
{
await _repositoryWrapper.Marinas.InsertAsync(marina);
}
else if (tmp.Updated != marina.Updated)
{
marina.Id = tmp.Id;
await _repositoryWrapper.Marinas.UpdateAsync(tmp.Id, marina);
}
}
var eventArgs = new DataUpdateEventArgs <Marina>
{
Type = "marina",
Data = await _repositoryWrapper.Marinas.GetAllAsync()
};
_eventAggregator
.GetEvent <UpdateReadyEvent <Marina> >()
.Publish(eventArgs);
}
/// <summary>
/// 焦点离开控件时发生。
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected virtual void AccessItem_LostFocus(object sender, EventArgs e)
{
//判断是否是设置数据
if (isSettingValue)
{
return;//如果是，就直接返回吧。
}
if (((Control)sender).Tag == null) //如果没设置tag属性，就不会
{
return; //触发这个事件，得自己重写
}
//定义一个事件变量
DataUpdateEventArgs ev = new DataUpdateEventArgs();
//是什么列改变值
ev.Column_name = ((Control)sender).Tag.ToString();
//关键的一点，先看看这列的列名是否在Datarow的列名中
if (DR.Table.Columns.Contains(ev.Column_name))
{
ev.Old_DR = DR.Table.Copy().Rows[0];//先复制到DataTable，然后选择第一列
//然后更新
updateDR(DR);
ev.New_DR = DR;
OnDataUpdate(ev);
}
//throw new NotImplementedException();
}
/// <summary>
/// 调用事件
/// </summary>
/// <param name="e"></param>
protected void OnDataUpdate(DataUpdateEventArgs e)
{
//如果有监听者
if (DataUpdate != null)
{
DataUpdate(this, e);
}
}
private void DateTimePicker1_ValueChanged(object sender, EventArgs e)
{
//判断是否是设置数据
if (isSettingValue)
{
return;//如果是，就直接返回吧。
}
//定义一个事件变量
DataUpdateEventArgs ev = new DataUpdateEventArgs();
//是什么列改变值
ev.Column_name = "日期";
//关键的一点，先看看这列的列名是否在Datarow的列名中
if (DR.Table.Columns.Contains(ev.Column_name))
{
ev.Old_DR = DR.Table.Copy().Rows[0];//先复制到DataTable，然后选择第一列
updateDR(DR);
ev.New_DR = DR;
OnDataUpdate(ev);
}
//throw new NotImplementedException();
}
private void Txt_ID_LostFocus(object sender, EventArgs e)
{
//判断是否是设置数据
if (isSettingValue)
{
return;//如果是，就直接返回吧。
}
//定义一个事件变量
DataUpdateEventArgs ev = new DataUpdateEventArgs();
//是什么列改变值
ev.Column_name = "ID";
//关键的一点，先看看这列的列名是否在Datarow的列名中
if (DR.Table.Columns.Contains(ev.Column_name))
{
ev.Old_DR = DataRowCopy(DR);//
updateDR(DR);
ev.New_DR = DR;
OnDataUpdate(ev);
}
//throw new NotImplementedException();
}
private void DataUpdateEventHandler(object sender, DataUpdateEventArgs args)
{
if (args.DataSets == null || args.DataSets.Count == 0)
{
return; // No updating to be done
}
if (navigationMonitoringViewModel.NavCoorVis)
{
if (posUpdating || framePosCount > 0)
{
framePosCount--;
UpdateNavigationCoorBuffer(args.DataSets);
}
else
{
posUpdating = true;
framePosCount = settingsService.FPS / 20;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateNavigationCoor(args.DataSets);
posUpdating = false;
});
}
}
else
{
UpdateNavigationCoorBuffer(args.DataSets);
}
if (navigationMonitoringViewModel.NavVelVis)
{
if (velUpdating || frameVelCount > 0)
{
frameVelCount--;
UpdateNavigationVelBuffer(args.DataSets);
}
else
{
velUpdating = true;
frameVelCount = settingsService.FPS / 20;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateNavigationVel(args.DataSets);
velUpdating = false;
});
}
}
else
{
UpdateNavigationVelBuffer(args.DataSets);
}
if (navigationMonitoringViewModel.NavTrackingVis)
{
if (trackingUpdating)
{
UpdateNavigationTrackingBuffer(args.DataSets);
}
else
{
trackingUpdating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateNavigationTracking(args.DataSets);
trackingUpdating = false;
});
}
}
else
{
UpdateNavigationTrackingBuffer(args.DataSets);
}
}
public static async void UpdateDataAsync() //This method should be rewritten to for your task
{
IndexRow = Convert.ToInt32(keeper.GetParam("IndexRow"));
SqlCommand dbCommand1 = new SqlCommand
{
CommandText = "GetErrorDrawingsArchivation",
Connection = connect as SqlConnection,
CommandType = System.Data.CommandType.StoredProcedure,
CommandTimeout = 3600
};
System.Data.IDataParameter ParamInput = new SqlParameter {
ParameterName = "@LastIndexError", Value = IndexRow
};
dbCommand1.Parameters.Add(ParamInput);
Task <System.Data.DataTable> task1 = Task <System.Data.DataTable> .Factory.StartNew(() =>
{
System.Data.DataTable TaskTable = new System.Data.DataTable();
System.Data.DataColumn dataColumn1 = new System.Data.DataColumn("ID");
System.Data.DataColumn dataColumn2 = new System.Data.DataColumn("NameFile");
System.Data.DataColumn dataColumn3 = new System.Data.DataColumn("IDLast");
TaskTable.Columns.Add(dataColumn1);
TaskTable.Columns.Add(dataColumn2);
TaskTable.Columns.Add(dataColumn3);
try
{
lock (CountConnectedLock)
{
if (CountConnected == 0)
{
connect.Open();
}
CountConnected++;
}
System.Data.IDataReader dataReader = dbCommand1.ExecuteReader();
while (dataReader.Read())
{
var newRow = TaskTable.Rows.Add();
foreach (System.Data.DataColumn col in TaskTable.Columns)
{
newRow[col.ColumnName] = dataReader[col.ColumnName];
}
}
System.Diagnostics.Debug.WriteLine(TaskTable.Rows[0][0].ToString());
System.Diagnostics.Debug.WriteLine(TaskTable.Rows[0][1].ToString());
System.Diagnostics.Debug.WriteLine(TaskTable.Rows[0][2].ToString());
}
catch (Exception err)
{
log.Save("Task Reader errors", err.Message);
}
finally
{
lock (CountConnectedLock)
{
if (CountConnected == 1)
{
connect.Close();
}
CountConnected--;
}
}
return(TaskTable);
});
table = await task1;
int CountTable = table.Rows.Count;
if (CountTable > 0)
{
keeper.Save("IndexRow", table.Rows[0][2].ToString());
}
System.Diagnostics.Debug.WriteLine(CountTable);
DataUpdateEventArgs eventArgs = new DataUpdateEventArgs {
Count = CountTable
};
DataUpdated?.Invoke(null, eventArgs);
}
private void DataUpdateEventHandler(object sender, DataUpdateEventArgs args)
{
if (args.DataSets == null || args.DataSets.Count == 0)
{
return; // No updating to be done
}
generalService.FlightMode = args.DataSets.Last().FlightMode; //Set flight mode to most up to date value
if (isVisible)
{
if (attUpdating)
{
UpdateAttitudeBuffer(args.DataSets);
}
else
{
attUpdating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAttitude(args.DataSets);
attUpdating = false;
});
}
if (mainMonitoringViewModel.AltMode || mainMonitoringViewModel.AltOverride)
{
if (altUpdating)
{
UpdateAltitudeBuffer(args.DataSets);
}
else
{
altUpdating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAltitude(args.DataSets);
altUpdating = false;
});
}
}
if (mainMonitoringViewModel.NavMode || mainMonitoringViewModel.NavOverride)
{
if (navUpdating)
{
UpdateNavigationBuffer(args.DataSets);
}
else
{
navUpdating = true;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateNavigation(args.DataSets);
navUpdating = false;
});
}
}
}
else
{
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAttitudeBuffer(args.DataSets);
UpdateAltitudeBuffer(args.DataSets);
UpdateNavigationBuffer(args.DataSets);
});
}
}
private void DataUpdateEventHandler(object sender, DataUpdateEventArgs args)
{
if (args.DataSets == null || args.DataSets.Count == 0)
{
return; // No updating to be done
}
if (attitudeMonitoringViewModel.RotVis)
{
if (rotUpdating || frameRotCount > 0)
{
frameRotCount--;
UpdateRotBuffer(args.DataSets);
}
else
{
rotUpdating = true;
frameRotCount = settingsService.FPS / 20;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAttitudeRot(args.DataSets);
rotUpdating = false;
});
}
}
else
{
UpdateRotBuffer(args.DataSets);
}
if (attitudeMonitoringViewModel.VelVis)
{
if (velUpdating || frameVelCount > 0)
{
frameVelCount--;
UpdateVelBuffer(args.DataSets);
}
else
{
velUpdating = true;
frameVelCount = settingsService.FPS / 20;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAttitudeVel(args.DataSets);
velUpdating = false;
});
}
}
else
{
UpdateVelBuffer(args.DataSets);
}
if (attitudeMonitoringViewModel.MotorVis)
{
if (motUpdating || frameMotCount > 0)
{
frameMotCount--;
UpdateMotorBuffer(args.DataSets);
}
else
{
motUpdating = true;
frameMotCount = settingsService.FPS / 20;
ThreadPool.QueueUserWorkItem((x) =>
{
UpdateAttitudeMotors(args.DataSets);
motUpdating = false;
});
}
}
else
{
UpdateMotorBuffer(args.DataSets);
}
}
