private void LocalFetchCompleted(object sender, FetchTileCompletedEventArgs e)
{
try
{
if (e.Error == null && e.Cancelled == false && _isThreadRunning && e.Image != null)
{
var ms = new MemoryStream(e.Image);
_memoryCache.Add(e.TileInfo.Index, ms);
_fileCache?.Add(e.TileInfo.Index, e.Image);
}
}
catch (Exception ex)
{
e.Error = ex;
}
finally
{
_threadCount--;
lock (_tilesInProgress)
{
if (_tilesInProgress.Contains(e.TileInfo.Index))
{
_tilesInProgress.Remove(e.TileInfo.Index);
}
}
_waitHandle.Set();
}
DataChanged?.Invoke(this, new DataChangedEventArgs(e.Error, e.Cancelled, e.TileInfo)
{
Image = e.Image
});
}
public virtual void RemoveAllDelegate()
{
foreach (var item in DataChanged.GetInvocationList())
{
DataChanged -= item as EventHandler;
}
}
public override bool AddData(string key, object data, TimeSpan?span = null)
{
if (data == null || key == null)
{
return(false);
}
if (!DataChanged.ContainsKey(key))
{
DataChanged.Add(key, false);
}
else
{
DataChanged[key] = false;
}
//
Action act;
if (span == null)
{
act = () => _cache.Set(key, data);
}
else
{
act = () => _cache.Set(key, data, (System.TimeSpan)span);
}
Task task = new Task(act);
task.Start();
return(true);
}
private void OPCGroup_DataChanged(int TransactionID, int NumItems, ref Array ClientHandles, ref Array ItemValues, ref Array Qualities, ref Array TimeStamps)
{
Objects.OpcItemEventArgs e = new Objects.OpcItemEventArgs();
for (int i = 1; i <= ClientHandles.Length; i++)
{
if (ItemValues.GetValue(i) == null)
{
continue;
}
e.ItemHandle = (int)ClientHandles.GetValue(i);
if (typeof(double) == ItemValues.GetValue(i).GetType())
{
e.ItemValue = ItemValues.GetValue(i) != null ? (double)ItemValues.GetValue(i) : 0.0;
}
else if (typeof(bool) == ItemValues.GetValue(i).GetType())
{
e.ItemValue = ItemValues.GetValue(i) != null ? (bool)ItemValues.GetValue(i) : false;
e.IsFault = (bool)e.ItemValue && ((e.ItemHandle <= 18 && e.ItemHandle >= 15) || (e.ItemHandle <= 98 && e.ItemHandle >= 93));
}
else if (typeof(byte) == ItemValues.GetValue(i).GetType())
{
e.ItemValue = ItemValues.GetValue(i) != null ? (byte)ItemValues.GetValue(i) : new Byte();
}
else if (typeof(string) == ItemValues.GetValue(i).GetType())
{
e.ItemValue = ItemValues.GetValue(i) != null ? (string)ItemValues.GetValue(i) : "";
}
Module1.TagList[e.ItemHandle].Value = e.ItemValue;
Module1.TagList[e.ItemHandle].Timestamp = DateTime.Now;
DataChanged?.Invoke(this, e);
}
}
public async Task StartWeatherLoading()
{
var weather = await Task.Run(() =>
{
try
{
return(_dataProvider.GetWeather().Result);
}
catch (Exception)
{
return(new Weather.Weather("Error", null, null));
}
}, _tokenSource.Token);
if (weather.Main == null || weather.Description == null)
{
DataChanged?.Invoke(new WeatherData(weather.Name, -273.0,
WeatherIcon.THUNDERSTORM));
}
else
{
DataChanged?.Invoke(new WeatherData(weather.Name, weather.Main.Temp,
_iconConverter.Convert(weather.Description.Icon)));
}
}
private void ListenForChanges()
{
//Remove existing dependency, if necessary
if (Dependency != null)
{
Dependency.OnChange -= Dependency_OnChange;
Dependency = null;
}
SqlConnection connection = new SqlConnection(ConnectionString);
connection.Open();
SqlCommand command = new SqlCommand(ListenerQuery, connection);
Dependency = new SqlDependency(command);
// Subscribe to the SqlDependency event.
Dependency.OnChange += Dependency_OnChange;
SqlDependency.Start(ConnectionString);
command.ExecuteReader();
//Perform this action when SQL notifies of a change
DataChanged?.Invoke(this, EventArgs.Empty);
connection.Close();
}
public void Replace_ReplacedAndEventRaised()
{
TestDataManager dm = new TestDataManager();
TestDataType data1 = new TestDataType {
Id = 1U
}, data2 = new TestDataType {
Id = 2U
};
dm.Add(data1);
TestDataObserver obs = new TestDataObserver();
using IDisposable unsubscriber = dm.Subscribe(obs);
Assert.AreEqual(dm.Get(1U), data1);
dm.ReplaceData(new HashSet <TestDataType> {
data2
});
Assert.AreEqual(dm.Get(2U), data2);
Assert.AreEqual(0, obs.CompleteCount);
Assert.AreEqual(0, obs.Errors.Count);
Assert.AreEqual(1, obs.Next.Count);
DataChanged <TestDataType> change = obs.Next.Dequeue();
Assert.IsTrue(change.Action == DataChangedAction.Replace &&
change.OldItems?.FirstOrDefault() == data1 &&
change.NewItems?.FirstOrDefault() == data2);
}
internal void FireTableChanged(IEnumerable <DataChange> dataChanges)
{
if (DataChanged != null && dataChanges != null)
{
DataChanged?.Invoke(dataChanges);
}
}
public void OnNext(DataChanged <IOrder> value)
{
if (value.Action == DataChangedAction.Add)
{
List <uint> newOrders = value.NewItems.Select(o => o.Id).ToList();
Task.Run(async delegate
{
await Task.Delay(5000);
lock (OrderLock)
{
foreach (uint id in newOrders)
{
IOrder order = OrderManager.Get(id);
if (order != null && !order.DeliveryDate.HasValue)
{
order.DeliveryDate = DateTime.Now;
foreach (IObserver <OrderSent> observer in OrderSentObservers.ToList())
{
observer.OnNext(new OrderSent(order));
}
Update(order).GetAwaiter().GetResult();
}
}
}
});
}
}
public Del_data_id(Dictionary <int, string> dat, DataChanged _db, string tbox)
{
InitializeComponent();
dic = dat;
db = _db;
textBox1.Text = tbox;
}
private void b_save_Click(object sender, RoutedEventArgs e)
{
try
{
if (CheckFields())
{
//ID und Skill Level koennen nicht durch den Benutzer bearbeitet werden
Guid ID = ApplicationState.GetValue <Competitor>("SelectedCompetitor").CompetitorID;
int skill = ApplicationState.GetValue <Competitor>("SelectedCompetitor").SkillLevel;
comp.UpdateCompetitor(ID, tb_name.Text, tb_surname.Text, cb_gender.Text, skill, cb_visibility.Text);
DataChanged?.Invoke(this, new EventArgs());
Close();
}
else
{
MessageBox.Show("Bitte alle Felder ausfüllen!", "KICKERCUP", MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
catch
{
MessageBox.Show("Fehler beim Speichern der Änderungen!", "KICKERCUP", MessageBoxButton.OK,
MessageBoxImage.Error);
}
}
private void ReportProgress(object sender, CurrencyData e)
{
CurrencyDatas.Add(e); // add data from listing to our curreny data list
_indexOfDownloadedFile++;
var now = DateTime.Now;
if (previousDataReport == null)
{
previousDataReport = now;
}
if (previousProgressReport == null)
{
previousProgressReport = now;
}
if (now - previousProgressReport >= TimeSpan.FromSeconds(1))
{
previousProgressReport = now;
ProgressChanged?.Invoke(null, new CurrencyInformationProgressEventArgs {
FilesParsed = _indexOfDownloadedFile, FilesOverall = _rangeOfFiles
});
}
if (now - previousDataReport >= TimeSpan.FromSeconds(4))
{
previousDataReport = now;
DataChanged?.Invoke(null, this); // invoke our event
}
}
private void TileFetcherDataChanged(object sender, DataChangedEventArgs e)
{
OnLayerDataLoaded();
e.Layer = this;
DataChanged?.Invoke(this, e);
}
private void OperatorCombo_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
if (_suppressControls)
{
return;
}
Operator op;
if (Enum.TryParse((c_operatorCombo.SelectedItem as string), true, out op))
{
_op = op;
if (_cond != null)
{
_cond.Operator = op;
}
DataChanged?.Invoke(this, EventArgs.Empty);
}
MainWindow.Current.UpdateFilterConditionLayout();
}
catch (Exception ex)
{
this.ShowError(ex);
}
}
private void Changed(object sender, PropertyChangedEventArgs args)
{
if (args.PropertyName == "Value")
{
DataChanged?.Invoke(this, EventArgs.Empty);
}
}
/// <summary>
/// Add data to the table
/// </summary>
/// <param name="data">Info to add</param>
public override bool Add(T data)
{
DBBusy.WaitOne();
try
{
using (var cnn = new SQLiteConnection(LoadConnectionString()))
{
cnn.Open();
string request = "INSERT INTO " + table.ToString() + " ( " + table.GetFields() + " ) VALUES ( " + table.GetFieldsForQuery() + " )";
cnn.Execute(request, data);
}
}
catch (Exception e)
{
Console.WriteLine(e);
DBBusy.ReleaseMutex();
return(false);
}
var ls = new List <T>();
ls.Add(data);
//Fires INotifyDataChanged event
DataChanged?.Invoke(this, new DataChangedArgs <IEnumerable <T> >(ls, table.ToString(), RepositoryActions.Add));
DBBusy.ReleaseMutex();
return(true);
}
private void LocalFetchCompleted(object sender, FetchTileCompletedEventArgs e)
{
//todo remove object sender
try
{
if (e.Error == null && e.Cancelled == false && _isThreadRunning && e.Image != null)
{
var feature = new Feature
{
Geometry = new Raster(new MemoryStream(e.Image), e.TileInfo.Extent.ToBoundingBox())
};
_memoryCache.Add(e.TileInfo.Index, feature);
}
}
catch (Exception ex)
{
e.Error = ex;
}
finally
{
_threadCount--;
lock (_tilesInProgress)
{
if (_tilesInProgress.Contains(e.TileInfo.Index))
{
_tilesInProgress.Remove(e.TileInfo.Index);
}
}
_waitHandle.Set();
}
DataChanged?.Invoke(this, new DataChangedEventArgs(e.Error, e.Cancelled, e.TileInfo));
}
private async Task Serve(CancellationToken token)
{
var helloBuffer = encoder.GetBytes("HELLO!!");
while (!token.IsCancellationRequested)
{
if (clients.TryDequeue(out var client))
{
await Task.Delay(TimeSpan.FromSeconds(1));
var stream = client.Client.GetStream();
await stream.WriteAsync(helloBuffer, 0, helloBuffer.Length, token);
var waitTime = DateTime.Now.Subtract(client.ReceivedTime);
lock (status)
{
status.PendingRequests = clients.Count;
status.ServedClients++;
status.AvarageWaitTime = CalculateAvarage(status.AvarageWaitTime, status.ServedClients, waitTime);
status.RPS = status.ServedClients / status.AvarageWaitTime.TotalSeconds;
DataChanged?.Invoke(this, status);
}
}
}
}
/// <summary>
/// Writes data into an existing (single) segment.
/// </summary>
/// <param name="address">The address to write to.</param>
/// <param name="bytes">The bytes to write.</param>
internal void SetData(ModuleAddress address, byte[] bytes)
{
var segment = GetSegment(address);
segment.SetData(address, bytes);
DataChanged?.Invoke(this, new ModuleDataChangedEventArgs(segment));
}
public void RaiseDataChanged(SectionDataChangedEventArgs e)
{
_sectionDataChanged = true;
UpdateCollectionItemsInfo();
UpdateSummaryState();
DataChanged?.Invoke(ActiveEditor, e);
}
private void OnSettingsChanged(object sender, EventArgs e)
{
if (!_allowToSave)
{
return;
}
_content.StandalonePackage.DigitalPackageSettings.ShowCategory = buttonXCategory.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowGroup = buttonXGroup.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowProduct = buttonXProduct.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowImpressions = buttonXImpressions.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowCPM = buttonXCPM.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowRate = buttonXRate.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowInvestment = buttonXInvestment.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowInfo = buttonXInfo.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowLocation = buttonXLocation.Checked;
_content.StandalonePackage.DigitalPackageSettings.ShowScreenshot = buttonXScreenshot.Checked;
if (checkEditFormulaCPM.Checked)
{
_content.StandalonePackage.DigitalPackageSettings.Formula = FormulaType.CPM;
}
else if (checkEditFormulaInvestment.Checked)
{
_content.StandalonePackage.DigitalPackageSettings.Formula = FormulaType.Investment;
}
else if (checkEditFormulaImpressions.Checked)
{
_content.StandalonePackage.DigitalPackageSettings.Formula = FormulaType.Impressions;
}
DataChanged?.Invoke(this, new SettingsChangedEventArgs {
ChangedSettingsType = SettingsType
});
}
void editor_DataChanged(object sender, EventArgs e)
{
if (DataChanged != null)
{
DataChanged.Invoke(this, e);
}
}
protected virtual void OnDataChange()
{
if (DataChanged != null)
{
DataChanged.Invoke(this, EventArgs.Empty);
}
}
public void OnDataChanged()
{
DataChanged?.Invoke(this, new EventArgs());
if (PortTypes != PortTypes.Output)
{
return;
}
for (var index = 0; index < ConnectedConnectors.Count; index++)
{
var inConnectedConnector = ConnectedConnectors[index];
if (Equals(inConnectedConnector.StartPort, this))
{
if (((ObjectPort)inConnectedConnector.EndPort).Data.Value != Data.Value)
{
((ObjectPort)inConnectedConnector.EndPort).Data.Value = Data.Value;
}
}
else if (Equals(inConnectedConnector.EndPort, this))
{
if (Data.Value != ((ObjectPort)inConnectedConnector.StartPort).Data.Value)
{
Data.Value = ((ObjectPort)inConnectedConnector.StartPort).Data.Value;
}
}
}
for (var index = ConnectedConnectors.Count - 1; index >= 0; index--)
{
var conn = ConnectedConnectors[index];
conn.Wire?.HeartBeatsAnimation(false);
}
}
public T this[int i, int j]
{
get
{
if (i > rows || j > columns)
{
throw new Exception($"Matrix Index out of bound [{i},{j}] for size [{rows},{columns}]");
}
return(data[i][j]);
}
set
{
if (i > rows || j > columns)
{
throw new Exception($"Matrix Index out of bound [{i},{j}] for size [{rows},{columns}]");
}
DataChanged?.Invoke(this, new DataChangeArgs()
{
NewValue = value,
OldValue = data[i][j],
IndexCol = (uint)j,
IndexRow = (uint)i
});
data[i][j] = value;
}
}
private void Channel_DataChanged(object sender, DataChangedEventArgs e)
{
DataChanged?.Invoke(this, e);
int index = Array.IndexOf(channels, e.Channel);
if (index < 0)
{
throw new ArgumentOutOfRangeException("channel", "The channel passed to the multichannel input's datachanged event is not part of that multichannel input.");
}
lock (changedChannels)
{
if (changedChannels.Add(e.Channel.ChannelId))
{
channelDataChanges[index] = new DataChangedEventArgs(e.Channel, e.Position, e.DataCount);
}
else
{
channelDataChanges[index].Position = e.Position;
channelDataChanges[index].DataCount += e.DataCount;
}
if (changedChannels.Count == channels.Length)
{
AllChannelsDataChanged?.Invoke(this, new AllChannelsDataChangedEventArgs(channelDataChanges));
changedChannels.Clear();
channelDataChanges = new DataChangedEventArgs[this.ChannelCount];
}
}
}
private void NewReaderData()
{
if (DataChanged != null)
{
DataChanged.Invoke(this, new EventArgs());
}
}
public static void UpdateData(string serverName, Item updatedItem, int id)
{
ExecuteCommand($"UPDATE {serverName} " +
$"SET i_header='{updatedItem.Header}', i_count={updatedItem.Count}, i_price={updatedItem.Price}, i_mod='{updatedItem.Mod}' " +
$"WHERE i_id={id}");
DataChanged?.Invoke();
}
private void OnDataChanged()
{
if (!_updatingModel)
{
DataChanged.SafeInvoke();
}
}
private void OnGridViewRowCellClick(object sender, RowCellClickEventArgs e)
{
if (e.Column != bandedGridColumnLogo)
{
return;
}
if (e.Clicks < 2)
{
return;
}
var selectedProgram = advBandedGridView.GetFocusedRow() as OptionSet;
if (selectedProgram == null)
{
return;
}
using (var form = new FormImageGallery(MediaMetaData.Instance.ListManager.Images))
{
if (form.ShowDialog() != DialogResult.OK)
{
return;
}
if (form.SelectedImageSource == null)
{
return;
}
selectedProgram.Logo = form.SelectedImageSource.Clone <ImageSource, ImageSource>();
advBandedGridView.UpdateCurrentRow();
DataChanged?.Invoke(this, EventArgs.Empty);
}
}
public EnhancedTimetableControl()
{
this.InitializeComponent();
this.DataContext = this;
DataUpdated += DataUpdatedHandler;
CurrentStub = null;
ReminderSetupVisible = false;
#if !DEBUG
GoogleAnalytics.EasyTracker.GetTracker().SendView("Daily Buzz");
#endif
if (AppSettings.FirstRun == true)
ShowPromptAsync();
}
public IDEEditor(FileBaseItem aItem)
{
InitializeComponent();
item = aItem;
changeChecker = new DataChanged { editor = editor };
SetCode(aItem);
editor.ShowLineNumbers = true;
editor.Options.ConvertTabsToSpaces = true;
editor.Options.IndentationSize = 4;
editor.FontFamily = new FontFamily("Consolas");
editor.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFDCDCCC"));
editor.TextArea.TextView.BackgroundRenderers.Add(new LineHighlighter());
editor.TextArea.TextView.BackgroundRenderers.Add(new ErrorLineHighlighter(aItem));
// Buggy
//editor.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.CSharp.CSharpIndentationStrategy();
Debugger.Editor.SearchPanel.Install(editor);
editor.TextChanged += editor_TextChanged;
scanner = new DepthScanner();
scanner.Process(editor.Text);
editor.MouseHover += editor_MouseHover;
editor.TextArea.MouseWheel += editor_MouseWheel;
editor.KeyUp += editor_KeyUp;
editor.MouseUp += editor_MouseUp;
codeFolding = Intellisense.Sources.SourceBuilder.GetFoldingStrategyForExtension(System.IO.Path.GetExtension(item.Path));
if (FOLDED_EXTENSIONS.Contains(System.IO.Path.GetExtension(aItem.Path)))
{
foldingManager = FoldingManager.Install(editor.TextArea);
UpdateFoldings();
}
intelSource = Intellisense.Sources.SourceBuilder.GetSourceForExtension(System.IO.Path.GetExtension(item.Path));
editor.ContextMenu = new ContextMenu();
// Hook the source, so we can get context menu commands from it
if (intelSource != null)
intelSource.HookEditor(editor, item);
editor.ContextMenu.Items.Add(new MenuItem
{
Header = "Snippet",
Command = new RelayCommand(p =>
{
ObservableCollection<Snippets.CodeSnippet> snips = new ObservableCollection<Snippets.CodeSnippet>();
string ext = System.IO.Path.GetExtension(item.Path);
foreach (Snippets.CodeSnippet snip in Snippets.SnippetData.inst().Snippets)
{
if (snip.Extension.Equals(ext))
snips.Add(snip);
}
if (snips.Count > 0)
{
Snippets.SnippetDlg dlg = new Snippets.SnippetDlg(editor, snips);
dlg.ShowDialog();
}
}, sp =>
{
ObservableCollection<Snippets.CodeSnippet> snips = new ObservableCollection<Snippets.CodeSnippet>();
string exte = System.IO.Path.GetExtension(item.Path);
foreach (Snippets.CodeSnippet snip in Snippets.SnippetData.inst().Snippets)
{
if (snip.Extension.Equals(exte))
return true;
}
return false;
})
});
editor.ContextMenu.Items.Add(new Separator());
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Cut",
Command = ApplicationCommands.Cut
});
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Copy",
Command = ApplicationCommands.Copy
});
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Paste",
Command = ApplicationCommands.Paste
});
editor.ContextMenu.Items.Add(new Separator());
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Undo",
Command = ApplicationCommands.Undo
});
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Redo",
Command = ApplicationCommands.Redo
});
editor.ContextMenu.Items.Add(new Separator());
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Save",
Command = ApplicationCommands.Save
});
editor.ContextMenu.Items.Add(new Separator());
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Save As",
Command = ApplicationCommands.SaveAs
});
editor.ContextMenu.Items.Add(new Separator());
editor.ContextMenu.Items.Add(new MenuItem {
Header = "Open",
Command = ApplicationCommands.Open
});
}
