private void OnLoaded(EventPattern <RoutedEventArgs> eventPattern)
{
var dispatcherScheduler = new DispatcherScheduler(Dispatcher);
var client = new ChatClient();
ObserveOnClick(ConnectBtn)
.Where(AddressIsValid)
.Where(PortIsValid)
.SelectMany(_ =>
client.TryConnectAsync(new IPEndPoint(IPAddress.Parse(Address.Text), int.Parse(Port.Text)))
)
.ObserveOn(dispatcherScheduler)
.Subscribe(OnConnectAttempt);
ObserveOnClick(RegisterBtn)
.SelectMany(_ => client.RegisterAsync(UserNameBox.Text)) // Consumes the task
.ObserveOn(dispatcherScheduler) // Use the dispatcher for the following UI updates.
.Subscribe(successfulRegister => {
if (successfulRegister)
{
ProceedToMainWindow(client);
}
else
{
Label.Text = $"{UserNameBox.Text} is taken, try with a different name";
}
});
}
private void TrySetDataContext(EventPattern <DependencyPropertyChangedEventArgs> dc)
{
if (Layout != null)
{
Layout.DataContext = dc.EventArgs.NewValue;
}
}
private void Update(EventPattern <NotifyCollectionChangedEventArgs> e)
{
this.VerifyDisposed();
lock (this.@lock)
{
switch (e.EventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
this.AddRange(e.EventArgs.NewItems);
break;
case NotifyCollectionChangedAction.Remove:
this.RemoveRange(e.EventArgs.OldItems);
break;
case NotifyCollectionChangedAction.Replace:
this.AddRange(e.EventArgs.NewItems);
this.RemoveRange(e.EventArgs.OldItems);
break;
case NotifyCollectionChangedAction.Move:
break;
case NotifyCollectionChangedAction.Reset:
this.Reset(this.Collection);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
internal static IObservable <EventPattern <PropertyChangedAndValueEventArgs <TProperty> > > ObservePropertyChangedWithValue <TNotifier, TProperty>(
this TNotifier source,
PropertyPath <TNotifier, TProperty> propertyPath,
bool signalInitial = true) where TNotifier : INotifyPropertyChanged
{
var wr = new WeakReference(source);
var observable = source.ObservePropertyChanged(propertyPath, false);
return(Observable.Defer(
() =>
{
var withValues =
observable.Select(
x =>
new EventPattern <PropertyChangedAndValueEventArgs <TProperty> >(
x.Sender,
new PropertyChangedAndValueEventArgs <TProperty>(
x.EventArgs.PropertyName,
propertyPath.GetValue((TNotifier)wr.Target))));
if (signalInitial)
{
var valueAndSource = propertyPath.GetValueAndSender((TNotifier)wr.Target);
var current =
new EventPattern <PropertyChangedAndValueEventArgs <TProperty> >(
valueAndSource.Source,
new PropertyChangedAndValueEventArgs <TProperty>(
propertyPath.Last.PropertyInfo.Name,
valueAndSource.Value));
return Observable.Return(current).Concat(withValues);
}
return withValues;
}));
}
public ShortLivedViewModel(LongLivedViewModel longLivedViewModel, EventPattern eventPattern)
{
_longLivedViewModel = longLivedViewModel ?? throw new ArgumentNullException(nameof(longLivedViewModel));
switch (eventPattern)
{
case EventPattern.StrongReference:
// potential memory leak - no garbage collection of ShortLivedViewModel due to subscription
// to LongLivedViewModel_EventOnLongLivedViewModel
longLivedViewModel.EventOnLongLivedViewModel += LongLivedViewModel_EventOnLongLivedViewModel;
break;
case EventPattern.GenericWeakEventManager:
// avoids memory leak
// generic weak event manager is less performant than a custom weak event manager
WeakEventManager <LongLivedViewModel, EventArgs> .AddHandler(
longLivedViewModel,
nameof(LongLivedViewModel.EventOnLongLivedViewModel),
LongLivedViewModel_EventOnLongLivedViewModel);
break;
case EventPattern.CustomEventManager:
// avoids memory leak
// custom weak event manager is most performant
EventOnLongLivedViewModelWeakEventManager.AddHandler(
longLivedViewModel,
LongLivedViewModel_EventOnLongLivedViewModel);
break;
default:
throw new ArgumentOutOfRangeException(nameof(eventPattern), eventPattern, null);
}
}
/// <summary>
/// Observes collectionchanged events for source.
/// </summary>
/// <typeparam name="TCollection"></typeparam>
/// <param name="source"></param>
/// <param name="signalInitial"></param>
/// <returns></returns>
public static IObservable <EventPattern <NotifyCollectionChangedEventArgs> > ObserveCollectionChanged <TCollection>(
this TCollection source,
bool signalInitial = true)
where TCollection : IEnumerable, INotifyCollectionChanged
{
//Contract.Requires<ArgumentNullException>(source != null);
IObservable <EventPattern <NotifyCollectionChangedEventArgs> > observable =
Observable.FromEventPattern <NotifyCollectionChangedEventHandler, NotifyCollectionChangedEventArgs>(
x => source.CollectionChanged += x,
x => source.CollectionChanged -= x);
if (signalInitial)
{
var wr = new WeakReference(source);
return(Observable.Defer(
() =>
{
var current = new EventPattern <NotifyCollectionChangedEventArgs>(
wr.Target,
new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
return Observable.Return(current)
.Concat(observable);
}));
}
return(observable);
}
private void OnDrawerOpened(EventPattern <DrawerLayout.DrawerOpenedEventArgs> e)
{
var drawerLayout = (e.Sender as DrawerLayout);
drawerLayout?.BringToFront();
RaiseEvent(drawerLayout);
}
private IEnumerable<Event> SelectLines(EventPattern<EntryWrittenEventArgs> arg)
{
dynamic ev = new Event(Type, Alias, arg.EventArgs.Entry.TimeGenerated);
ev.Message = arg.EventArgs.Entry.Message;
yield return ev;
}
private void CheckQuickMenuPullOutGesture(EventPattern <PanUpdatedEventArgs> x)
{
var e = x.EventArgs;
var typeOfAction = x.Sender as StackLayout;
switch (e.StatusType)
{
case GestureStatus.Running:
MethodLockedSync(() =>
{
Device.BeginInvokeOnMainThread(() =>
{
QuickMenuPullLayout.TranslationY = Math.Max(0,
Math.Min(Notification.HeightRequest, QuickMenuPullLayout.TranslationY + e.TotalY));
});
}, 2);
break;
case GestureStatus.Completed:
// Store the translation applied during the pan
_transY = QuickMenuPullLayout.TranslationY;
break;
case GestureStatus.Canceled:
Debug.WriteLine("Canceled");
break;
}
}
internal CdkWorkshopStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Function(scope, identical_id_in_scope, props)
var handler = new Function(this, "EventHandler", new FunctionProps()
{
Runtime = Runtime.DOTNET_CORE_3_1,
Code = Code.FromAsset("src/MyFunction/src/MyFunction/bin/Release/netcoreapp3.1/publish"), // Code loaded from the "lambda" directory
Handler = "MyFunction::MyFunction.Function::FunctionHandler" // file is "hello", function is hander
});
var eventPattern = new EventPattern();
// "PipelineMetricsEventPattern"
eventPattern.Source = new string[] { "aws.codepipeline" };
eventPattern.DetailType = new string[]
{
"CodePipeline Pipeline Execution State Change",
"CodePipeline Action Execution State Change",
"CodePipeline Stage Execution State Change"
};
var rule = new Rule(this, "PipelineMetricsRule", new RuleProps
{
Description = "Push pipeline events to a lambda function.",
RuleName = "PipelineMetricsRule",
EventPattern = eventPattern,
Enabled = true
});
rule.AddTarget(new LambdaFunction(handler, null));
}
public ItemPropertyChangedEventArgs(TItem item, EventPattern <PropertyChangedAndValueEventArgs <TValue> > e)
: base(e.EventArgs.PropertyName)
{
this.Item = item;
this.Value = e.EventArgs.Value;
this.Sender = e.Sender;
}
private void _watcher_Event(EventPattern <FileSystemEventArgs> args)
{
switch (args.EventArgs.ChangeType)
{
case WatcherChangeTypes.Changed:
lock (_sync)
{
if (_activeScripts.ContainsKey(args.EventArgs.FullPath))
{
FiddlerApplication.Log.LogString($"Re-initializing script file \"{args.EventArgs.FullPath}\".");
_activeScripts[args.EventArgs.FullPath].Initialize();
}
else
{
FiddlerApplication.Log.LogString($"Initializing new script file \"{args.EventArgs.FullPath}\".");
var script = _engine.CreateScript(args.EventArgs.FullPath);
script.Initialize();
_activeScripts.Add(args.EventArgs.FullPath, script);
}
}
break;
case WatcherChangeTypes.Created:
lock (_sync)
{
FiddlerApplication.Log.LogString($"Initializing new script file \"{args.EventArgs.FullPath}\".");
var script = _engine.CreateScript(args.EventArgs.FullPath);
script.Initialize();
_activeScripts.Add(args.EventArgs.FullPath, script);
}
break;
}
}
public void OnNext(EventPattern <WhenClipboardContainsTextEventArgs> value)
{
Task.Run(async() =>
{
try
{
string currentString = value.EventArgs.CurrentString;
if (_previousString == currentString)
{
return;
}
_previousString = currentString;
Maybe <string> failedResults;
string fromLanguageExtension = await _languageDetector.DetectLanguage(currentString);
TranslateResult[] results = await GetMeansFromCache(currentString, fromLanguageExtension);
Maybe <string> findedMeans = await _resultOrganizer.OrganizeResult(results, currentString, out failedResults).ConfigureAwait(false);
await Notify(currentString, findedMeans);
await Notify(currentString, failedResults);
await Trace(currentString, fromLanguageExtension);
}
catch (Exception ex)
{
await Notify("Error", new Maybe <string>(ex.Message));
}
});
}
public bool IsEvent(EventPatternKey EventPatternKey)
{
if (!EventPatterns.ContainsKey(EventPatternKey))
{
throw new ApplicationException("Incorrect event passed.");
}
EventPattern pattern = EventPatterns[EventPatternKey];
string stateString = String.Empty;
switch (pattern.StateType)
{
case StateType.Position:
stateString = this.PositionStates;
break;
case StateType.Range:
stateString = this.RangeStates;
break;
default:
throw new ApplicationException("Incorrect state type.");
}
if (stateString.Length == this.LastMatchedLengths[pattern.EventType])
{
return(false);
}
return(pattern.Pattern.IsMatch(stateString));
}
private void OnCameraChanged(EventPattern <GoogleMap.CameraChangeEventArgs> e)
{
if (_bypassCameraChangeEvent)
{
_bypassCameraChangeEvent = false;
return;
}
var bounds = GetMapBoundsFromProjection();
if (!_lockGeocoding)
{
ViewModel.UserMovedMap.ExecuteIfPossible(bounds);
}
if (!_settings.ShowIndividualTaxiMarkerOnly)
{
ShowAvailableVehicles(VehicleClusterHelper.Clusterize(AvailableVehicles, bounds));
}
if (TaxiLocation != null)
{
CancelAutoFollow.ExecuteIfPossible();
}
}
/// <summary>
/// COnvenience wrapper for listening to property changes
/// </summary>
/// <typeparam name="TNotifier"></typeparam>
/// <typeparam name="TProperty"></typeparam>
/// <param name="source"></param>
/// <param name="property"></param>
/// <param name="signalInitial">Default true means that the current value is signaled on Subscribe()</param>
/// <returns></returns>
public static IObservable <EventPattern <PropertyChangedEventArgs> > ToObservable <TNotifier, TProperty>(
this TNotifier source,
Expression <Func <TNotifier, TProperty> > property,
bool signalInitial = true)
where TNotifier : INotifyPropertyChanged
{
var me = (MemberExpression)property.Body;
var pe = me.Expression as ParameterExpression;
if (pe == null)
{
var wr = new WeakReference(source);
var observable = new NestedObservable <TNotifier, TProperty>(source, property);
if (signalInitial)
{
return(Observable.Defer(
() =>
{
var current = new EventPattern <PropertyChangedEventArgs>(
wr.Target, new PropertyChangedEventArgs(observable.Path.Last().PropertyInfo.Name));
return Observable.Return(current)
.Concat(observable);
}));
}
return(observable);
}
string name = me.Member.Name;
return(source.ToObservable(name, signalInitial));
}
IEnumerable<Event> ParserText(EventPattern<StrEventArgs> e)
{
Event item=new Event();
item.SetMember("str", e.EventArgs.Text);
return new List<Event>() { item };
}
Binance.WsTrade OnTradeSocketMessage(EventPattern <object, MessageReceivedEventArgs> p)
{
var trade = JsonConvert.DeserializeObject <Binance.WsTrade>(p.EventArgs.Message);
Debug.Print($"Trade: {trade.tradeId} {trade.symbol} {trade.price} {trade.quantity} {trade.isBuyerMaker}");
return(trade);
}
public async void OnNext(EventPattern <WhenClipboardContainsTextEventArgs> value)
{
await Task.Run(async() =>
{
var currentString = value.EventArgs.CurrentString;
if (previousString == currentString)
{
return;
}
previousString = currentString;
var fromLanguageExtension = await languageDetector.DetectLanguage(currentString);
var results = await cache.GetAsync(currentString,
async() => await Task.WhenAll(meanFinderFactory.GetFinders().Select(t => t.Find(new TranslateRequest(currentString, fromLanguageExtension)))))
.ConfigureAwait(false);
var findedMeans = await resultOrganizer.OrganizeResult(results, currentString).ConfigureAwait(false);
await notifier.AddNotificationAsync(currentString, ImageUrls.NotificationUrl, findedMeans.DefaultIfEmpty(string.Empty).First()).ConfigureAwait(false);
await googleAnalytics.TrackEventAsync("DynamicTranslator", "Translate", currentString, null).ConfigureAwait(false);
await googleAnalytics.TrackAppScreenAsync("DynamicTranslator",
ApplicationVersion.GetCurrentVersion(),
"dynamictranslator",
"dynamictranslator",
"notification").ConfigureAwait(false);
});
}
Binance.WsPriceTicker24hr OnTickerSocketMessage(EventPattern <object, MessageReceivedEventArgs> p)
{
var response = JsonConvert.DeserializeObject <Binance.WsResponse <Binance.WsPriceTicker24hr> >(p.EventArgs.Message);
var ticker = response.data;
return(ticker);
}
/// <summary>
/// Copy the value specified by the property name from the source to the haveDisplayName
/// </summary>
/// <param name="haveDisplayName">IHaveDisplayName</param>
/// <param name="eventPattern"></param>
private static void CopyValue(this IHaveDisplayName haveDisplayName, EventPattern <PropertyChangedEventArgs> eventPattern)
{
var source = eventPattern.Sender;
var propertyName = eventPattern.EventArgs.PropertyName;
var value = source.GetType().GetProperty(propertyName)?.GetValue(source) as string;
haveDisplayName.DisplayName = value;
}
void HandleSourceChanged(EventPattern <NotifyCollectionChangedEventArgs> eventPattern)
{
var source = (IEnumerable <T>)eventPattern.Sender;
_list = new List <T>(source);
OnPropertyChanged("Count");
OnCollectionChanged();
}
protected override void OnProcessorError(EventPattern <PipelineProcessorExceptionEventArgs> args)
{
PipelineTrace pipelineTrace = _traceStack.Peek();
Stack <ProcessorTrace> processorStack = pipelineTrace.ProcessorStack;
ProcessorTrace processorTrace = processorStack.Pop();
pipelineTrace.Traces.Add(processorTrace);
}
private void OnReportLoaded(EventPattern <RoutedEventArgs> obj)
{
string currentDir = Path.Combine(Environment.CurrentDirectory, @"Modules\Orders\Reports\InvoiceReport.rdlc");
this.InvoiceReport.ProcessingMode = Syncfusion.Windows.Reports.Viewer.ProcessingMode.Local;
this.InvoiceReport.ReportPath = currentDir;
}
private void DrawStop(EventPattern <DrawStatusChangedEventArgs> e)
{
_runTimer = false;
_drawTimer.Stop();
DrawStatusLabel.Text = "Draw Complete";
UpdateDrawTime(TimeSpan.FromSeconds(2));
_drawTimer.Reset();
}
private void CamerPositionIdle(EventPattern <EventArgs> eventPattern)
{
_estimatedTimeTimeTextView.Visibility = ViewStates.Visible;
Random rnd = new Random();
var min = rnd.Next(0, 10);
_estimatedTimeTimeTextView.Text = $"{min}\nmin";
_centeredAnimatableDot.Visibility = ViewStates.Gone;
}
private void ToggleEventHandlingMechanism(object sender, RoutedEventArgs e)
{
_longLivedViewModel = new LongLivedViewModel();
_testWeakEventManager = (EventPattern)((int)(_testWeakEventManager + 1) % 3);
DataContext = _longLivedViewModel;
TestWeakEventManager(_longLivedViewModel);
}
IEnumerable <Event> ParserText(EventPattern <StrEventArgs> e)
{
Event item = new Event();
item.SetMember("str", e.EventArgs.Text);
return(new List <Event>()
{
item
});
}
private void FieldFilterEditorCreatedHandler(EventPattern <EditorCreatedEventArgs> args)
{
var column = args.EventArgs.Column;
var editor = args.EventArgs.Editor;
IsPopupOpen.OnNext(true);
TracePopupCreationValues(MethodBase.GetCurrentMethod()
.Name);
CustomFilterInstance.FilterEditor = editor;
}
private bool PortIsValid(EventPattern <RoutedEventArgs> eventPattern)
{
var isInteger = IsInteger(Port.Text);
if (!isInteger)
{
Label.Text = "Port is invalid";
}
return(isInteger);
}
private bool AddressIsValid(EventPattern <RoutedEventArgs> eventPattern)
{
var isIpAddress = IsIpAddress(Address.Text);
if (!isIpAddress)
{
Label.Text = "Address is invalid";
}
return(isIpAddress);
}
private void OnLiveStreamEvent(EventPattern <EventArgsLiveStreamMessage> e)
{
var applicationEvent = e.EventArgs.Message.ApplicationEvent;
if (applicationEvent != null)
{
var handler = _eventHandlerFactory.Get(applicationEvent);
handler?.Handle(applicationEvent);
e.EventArgs.Ack();
}
}
protected virtual void OnNext(EventPattern<FileSystemEventArgs> newFileEvent)
{
var fullPath = newFileEvent.EventArgs.FullPath;
RetryScheduler.Schedule(0, TimeSpan.Zero, (state, recurse) =>
{
Stream stream;
try
{
stream = File.OpenRead(fullPath);
}
catch (Exception ex)
{
Interlocked.Increment(ref state);
if (state < RetryCount)
{
recurse(state, Interval);
return;
}
fileHandler.ReportError(fullPath, ex);
return;
}
try
{
fileHandler.ProcessFile(fullPath, stream);
}
catch (Exception ex)
{
fileHandler.ReportError(fullPath, ex);
}
finally
{
stream.Dispose();
}
});
}
private static string PathFromEventArgs(EventPattern<object> a)
{
return Path.GetFullPath(((FileSystemEventArgs)a.EventArgs).FullPath);
}
private void UpdateAvailability(EventPattern<PropertyChangedEventArgs> ev)
{
Execute.OnUIThread(() => context.Message.UpdateAvailability());
}
public void PriceUpdate(EventPattern<PriceUpdateEventArgs> e)
{
var displayRate = DisplayFxRates.First(rate => rate.Ccy == e.EventArgs.LatestPrice.Ccy);
if (displayRate != null)
displayRate.Update(e.EventArgs.LatestPrice);
}
private void UpdatePoints(RunChartView instance, EventPattern<PropertyChangedEventArgs> handler)
{
if (((ChartBase)DataContext).DataSource.Count > 0)
{
if (handler.EventArgs.PropertyName == "USL" || handler.EventArgs.PropertyName == "LSL")
UpdateDataPointTemplates(instance);
if (handler.EventArgs.PropertyName.Contains("Show"))
OnPropertyChanged("ShowSpecsCheckbox");
}
}
IEnumerable<FileSystemEventArgs> GetDirectoryChangedEventArgs(
EventPattern<FileSystemEventArgs> eventPattern, bool bubble, string rootPath)
{
yield return eventPattern.EventArgs;
if (!bubble) yield break;
// bubble to parents
foreach (var directory in _fileSystemInfoProvider
.GetParentDirectories(eventPattern.EventArgs.FullPath))
{
var parentDirectory = Path.GetDirectoryName(directory);
if (parentDirectory != null)
yield return new FileSystemEventArgs(
WatcherChangeTypes.Changed,
parentDirectory,
Path.GetFileName(directory) + "\\");
if (rootPath.Length > directory.Length) yield break;
}
}
private static ZeroconfRecord ProcessMessage(EventPattern<DatagramSocketMessageReceivedEventArgs> eventPattern)
{
var dr = eventPattern.EventArgs.GetDataReader();
var byteCount = dr.UnconsumedBufferLength;
Debug.WriteLine("IP: {0} Bytes:{1}", eventPattern.EventArgs.RemoteAddress.DisplayName, byteCount);
var msg = ReadDnsMessage(dr);
return DnsToZeroconf(msg);
}
private void OnDataContextPropertyChanged(PChartView instance, EventPattern<PropertyChangedEventArgs> handler)
{
if (handler.EventArgs.PropertyName.Contains("Show"))
UpdateDataPointTemplates(instance);
if (handler.EventArgs.PropertyName == "AverageLimits")
UpdateControlLimits(instance.DataContext as ChartBase);
}
private void OnDataContextPropertyChanged(HistogramChartView instance, EventPattern<PropertyChangedEventArgs> handler)
{
if (handler.EventArgs.PropertyName == "DataSource")
AdjustLabelsAndTicks(instance.HistogramChart, (ChartBase) DataContext);
if (handler.EventArgs.PropertyName == "BellCurveData")
OnPropertyChanged("BellCurvePeak");
}
private void UpdatePoints(HistogramChartView instance, EventPattern<PropertyChangedEventArgs> handler)
{
if (((ChartBase)instance.DataContext).DataSource.Count > 0)
{
if (handler.EventArgs.PropertyName == "LSL")
{
instance.LslData = PerSampleControlLimitsHelper.BuildHistogramControlLimit(((ChartBase)instance.DataContext).ParentPanel.LSL);
OnPropertyChanged("LslData");
}
if (handler.EventArgs.PropertyName == "USL")
{
instance.UslData = PerSampleControlLimitsHelper.BuildHistogramControlLimit(((ChartBase)instance.DataContext).ParentPanel.USL);
OnPropertyChanged("UslData");
}
if (handler.EventArgs.PropertyName.Contains("Show"))
OnPropertyChanged("ShowSpecsCheckbox");
}
}
public void PriceChanged(EventPattern<PriceChangedEventArgs> e)
{
var displayRate = DisplayStockPrices.First(
rate => rate.Symbol == e.EventArgs.Price.Symbol);
if (displayRate != null)
displayRate.Update(e.EventArgs.Price);
}
/// <summary>
/// Obtain the track history parameters from the labels.
/// </summary>
/// <param name="e"></param>
private void ProcessLabels(EventPattern<LabelChangedEventArgs> e)
{
var label = e.EventArgs.Label;
if (!(string.IsNullOrEmpty(label)
|| label.StartsWith("Data." + Model.Id)
|| string.Equals(label, "UserIdentity", StringComparison.InvariantCultureIgnoreCase))) return;
UpdateInfoFromLabels();
}
IEnumerable<FileSystemEventArgs> GetDirectoryChangedEventArgs(
EventPattern<RenamedEventArgs> eventPattern, bool bubble, string rootPath)
{
return GetDirectoryChangedEventArgs(
new EventPattern<FileSystemEventArgs>(eventPattern.Sender, eventPattern.EventArgs),
bubble, rootPath);
// bubble to parents
}
private void OnAddNativeBehavior(RunChartView currentControl, EventPattern<EventArgs> eventPattern)
{
Dispatcher.BeginInvoke(() =>
{
var nativeBehavior = ((TrackballBehavior)eventPattern.Sender);
Observable.FromEventPattern<EventHandler<TrackBallInfoEventArgs>, TrackBallInfoEventArgs>(
handler => nativeBehavior.TrackInfoUpdated += handler,
handler => nativeBehavior.TrackInfoUpdated -= handler
).SubscribeWeakly(this, (target, handler) => target.ChartTrackBallBehavior_TrackInfoUpdated(handler.Sender, handler.EventArgs));
try
{
currentControl.RunChart.Behaviors.Add(nativeBehavior);
nativeBehavior.Parents.Add(currentControl.RunChart);
}
catch (InvalidOperationException){}
});
_isObsolete = true;
}
private void FieldFilterEditorCreatedHandler(EventPattern<EditorCreatedEventArgs> args){
var column = args.EventArgs.Column;
var editor = args.EventArgs.Editor;
IsPopupOpen.OnNext(true);
TracePopupCreationValues(MethodBase.GetCurrentMethod()
.Name);
CustomFilterInstance.FilterEditor = editor;
}
private void OnDataContextPropertyChanged(RunChartView instance, EventPattern<PropertyChangedEventArgs> handler)
{
if (handler.EventArgs.PropertyName.Contains("Show"))
UpdateDataPointTemplates(instance);
}
private static void OnComboBoxSelectionChanged(ProcessFilterDetailsView target, EventPattern<SelectionChangedEventArgs> handler)
{
OnComboBoxSelectionChanged(handler.Sender, handler.EventArgs);
}
void PerformOnDispatcher(EventPattern<KeyEventArgs> eventPattern)
{
//Dispatcher.BeginInvoke(DispatcherPriority.Background,new Action(()=>PerfromAction(eventPattern.EventArgs)));
}
private static void Static(DataCollectProcessViewConfigurator target, EventPattern<NotifyCollectionChangedEventArgs> handler)
{
target.RaiseConfigurationChanged();
}
private void OnNextItemChange(EventPattern<NotifyCollectionChangedEventArgs> eventData)
{
var children = (ITemplatedList<IElement>)this.ItemsPanel.Children;
switch (eventData.EventArgs.Action)
{
case NotifyCollectionChangedAction.Add:
foreach (object newItem in eventData.EventArgs.NewItems)
{
children.Add(newItem, this.ItemTemplate);
}
break;
case NotifyCollectionChangedAction.Remove:
{
int startingIndex = eventData.EventArgs.OldStartingIndex;
for (int index = startingIndex;
index < startingIndex + eventData.EventArgs.OldItems.Count;
index++)
{
children.RemoveAt(index);
}
break;
}
case NotifyCollectionChangedAction.Replace:
{
int startingIndex = eventData.EventArgs.NewStartingIndex;
foreach (object newItem in eventData.EventArgs.NewItems)
{
this.ItemsPanel.Children.RemoveAt(startingIndex);
children.Insert(startingIndex, newItem, this.ItemTemplate);
startingIndex++;
}
break;
}
#if !WINDOWS_PHONE
case NotifyCollectionChangedAction.Move:
children.Move(eventData.EventArgs.OldStartingIndex, eventData.EventArgs.NewStartingIndex);
break;
#endif
case NotifyCollectionChangedAction.Reset:
this.PopulatePanelFromItemsSource();
break;
}
}
private static void OnComboBoxSelectionChanged(FilterSetupView target, EventPattern<SelectionChangedEventArgs> handler)
{
target.ComboBoxOnSelectionChanged(handler.Sender, handler.EventArgs);
}
