GridViewEventResult IGridViewEventListener.ProcessEvent(
GridViewEvent eventData)
{
GridViewColumn sender1 = eventData.Sender as GridViewColumn;
if (sender1 != null && eventData.Info.Id == KnownEvents.PropertyChanged)
{
RadPropertyChangedEventArgs changedEventArgs = eventData.Arguments[0] as RadPropertyChangedEventArgs;
if (changedEventArgs.Property == GridViewColumn.IsVisibleProperty || changedEventArgs.Property == GridViewColumn.VisibleInColumnChooserProperty)
{
this.template = sender1.OwnerTemplate;
this.UpdateView();
}
}
else if (eventData.Info.Id == KnownEvents.ViewChanged)
{
DataViewChangedEventArgs changedEventArgs = eventData.Arguments[0] as DataViewChangedEventArgs;
GridViewTemplate sender2 = eventData.Sender as GridViewTemplate;
if (changedEventArgs.Action == ViewChangedAction.Reset || changedEventArgs.Action == ViewChangedAction.ColumnGroupPropertyChanged)
{
this.template = sender2;
this.UpdateView();
}
}
return((GridViewEventResult)null);
}
protected virtual GridViewEventResult ProcessViewChangedEvent(
GridViewEvent eventData)
{
DataViewChangedEventArgs changedEventArgs = eventData.Arguments[0] as DataViewChangedEventArgs;
if (changedEventArgs.Action == ViewChangedAction.Reset)
{
this.groupPanelElement.UpdateVisibility();
}
else if (changedEventArgs.Action == ViewChangedAction.CurrentViewChanged)
{
GridViewInfo oldView = (GridViewInfo)null;
if (this.currentView != null)
{
oldView = this.currentView.ViewInfo;
}
IRowView rowView = this.GetRowView((GridViewInfo)changedEventArgs.NewItems[0]);
if (rowView != null)
{
this.currentView = rowView;
}
this.OnCurrentViewChanged(new GridViewCurrentViewChangedEventArgs(oldView, (GridViewInfo)changedEventArgs.NewItems[0]));
}
return((GridViewEventResult)null);
}
GridViewEventResult IGridViewEventListener.ProcessEvent(
GridViewEvent eventData)
{
if (eventData.Info.Id == KnownEvents.CurrentChanged)
return this.ProcessCurrentChanged(eventData);
return (GridViewEventResult) null;
}
public static bool IsConditionalFormattingCollectionChangedEvent(GridViewEvent gridViewEvent)
{
if (gridViewEvent.Originator is ConditionalFormattingObjectCollection && gridViewEvent.Sender is GridViewColumn)
{
return(gridViewEvent.Info.Id == KnownEvents.CollectionChanged);
}
return(false);
}
public static bool IsTemplatePropertyChangingEvent(GridViewEvent gridViewEvent)
{
if (gridViewEvent.Info.Id == KnownEvents.PropertyChanging)
{
return(gridViewEvent.Sender is GridViewTemplate);
}
return(false);
}
public static bool IsGroupCollectionChangedEvent(GridViewEvent gridViewEvent)
{
if (gridViewEvent.Info.Id == KnownEvents.CollectionChanged)
{
return(gridViewEvent.Sender is GridViewGroupDescriptorCollection);
}
return(false);
}
public static bool IsRowPropertyChangedEvent(GridViewEvent gridViewEvent)
{
if (gridViewEvent.Info.Id == KnownEvents.PropertyChanged)
{
return(gridViewEvent.Sender is GridViewRowInfo);
}
return(false);
}
public static bool IsColumnsCollectionChangedEvent(GridViewEvent gridViewEvent)
{
GridViewTemplate sender = gridViewEvent.Sender as GridViewTemplate;
if (gridViewEvent.Info.Id == KnownEvents.CollectionChanged && sender != null)
{
return(gridViewEvent.Originator == sender.Columns);
}
return(false);
}
GridViewEventResult IGridViewEventListener.ProcessEvent(
GridViewEvent eventData)
{
if (eventData.Info.Id != KnownEvents.CurrentChanged)
{
return((GridViewEventResult)null);
}
this.OnPositionChanged(new PositionChangedEventArgs(eventData.Arguments[0] as GridViewRowInfo, eventData.Arguments[1] as GridViewColumn));
return((GridViewEventResult)null);
}
protected virtual void NotifyListeners(GridViewEvent gridEvent)
{
GridViewEventInfo info = gridEvent.Info;
bool flag = (info.Type & GridEventType.Data) == GridEventType.Data;
if (flag && !this.IsDataEventDispatchSuspended && (!this.dataEntity.PreProcess(gridEvent) || !this.dataEntity.Process(gridEvent)) || (info.Type & GridEventType.UI) == GridEventType.UI && !this.IsUIEventDispatchSuspended && !this.uiEntity.ProcessEvent(gridEvent) || (!flag || this.IsDataEventDispatchSuspended))
{
return;
}
this.dataEntity.PostProcess(gridEvent);
}
GridViewEventResult IGridViewEventListener.PostProcessEvent(
GridViewEvent eventData)
{
if (eventData.Info.Id == KnownEvents.BeginEdit)
{
this.GridViewElement.CurrentView.EnsureCellVisible(eventData.Arguments[0] as GridViewRowInfo, eventData.Arguments[1] as GridViewColumn);
this.GridViewElement.UpdateLayout();
this.BeginEdit();
}
return((GridViewEventResult)null);
}
protected virtual GridViewEventResult ProcessTemplatePropertyChanging(
GridViewEvent eventData)
{
PropertyChangingEventArgsEx changingEventArgsEx = eventData.Arguments[0] as PropertyChangingEventArgsEx;
if (this.IsInEditMode && (changingEventArgsEx.PropertyName == "DataSource" || changingEventArgsEx.PropertyName == "DataMember"))
{
this.EndEdit();
}
return((GridViewEventResult)null);
}
public GridViewEventResult PostProcessEvent(GridViewEvent eventData)
{
if (eventData.Info.Id == KnownEvents.ViewChanged)
{
DataViewChangedEventArgs changedEventArgs = eventData.Arguments[0] as DataViewChangedEventArgs;
if (changedEventArgs.Action == ViewChangedAction.Add || changedEventArgs.Action == ViewChangedAction.Remove || (changedEventArgs.Action == ViewChangedAction.FilteringChanged || changedEventArgs.Action == ViewChangedAction.GroupingChanged) || (changedEventArgs.Action == ViewChangedAction.PagingChanged || changedEventArgs.Action == ViewChangedAction.Reset))
{
this.UpdateVisibility();
this.UpdateView();
}
}
return((GridViewEventResult)null);
}
public GridViewEventResult ProcessEvent(GridViewEvent eventData)
{
if (eventData.Info.Id == KnownEvents.ViewChanged)
{
DataViewChangedEventArgs changedEventArgs = (DataViewChangedEventArgs)eventData.Arguments[0];
switch (changedEventArgs.Action)
{
case ViewChangedAction.Add:
if (changedEventArgs.NewItems[0] is GridViewDataRowInfo)
{
this.UpdateDistinctValues();
this.UpdateDistinctValuesWithFilter();
break;
}
break;
case ViewChangedAction.Remove:
if (changedEventArgs.NewItems[0] is GridViewDataRowInfo)
{
this.UpdateDistinctValues();
this.UpdateDistinctValuesWithFilter();
break;
}
break;
case ViewChangedAction.Reset:
this.distinctValues = (GridViewColumnValuesCollection)null;
this.distinctValuesWithFilter = (GridViewColumnValuesCollection)null;
break;
case ViewChangedAction.ItemChanged:
if (changedEventArgs.NewItems[0] is GridViewDataRowInfo)
{
this.UpdateDistinctValues();
this.UpdateDistinctValuesWithFilter();
break;
}
break;
}
}
else if (eventData.Info.Id == KnownEvents.CollectionChanged)
{
NotifyCollectionChangedEventArgs changedEventArgs = (NotifyCollectionChangedEventArgs)eventData.Arguments[0];
if (changedEventArgs.Action == NotifyCollectionChangedAction.Remove && changedEventArgs.NewItems[0] == this)
{
this.OwnerTemplate.MasterTemplate.SynchronizationService.RemoveListener((IGridViewEventListener)this);
}
}
return((GridViewEventResult)null);
}
protected virtual bool VerifyDispatch(GridViewEvent gridEvent)
{
if (this.IsDisposing || this.IsDisposed)
{
throw new ObjectDisposedException(nameof(GridViewSynchronizationService));
}
GridViewEventInfo info = gridEvent.Info;
if (this.IsDispatchSuspended || this.IsUIEventDispatchSuspended && info.Type == GridEventType.UI || this.IsDataEventDispatchSuspended && info.Type == GridEventType.Data)
{
return(false);
}
return(!this.IsEventSuspended(info.Id));
}
private bool IsGridViewEventToRemove(GridViewEvent gridEvent)
{
if (GridViewSynchronizationService.IsTemplatePropertyChangingEvent(gridEvent))
{
return((gridEvent.Arguments[0] as PropertyChangingEventArgsEx).PropertyName == "DataSource");
}
if (gridEvent.Info.Id != KnownEvents.ViewChanged)
{
return(false);
}
DataViewChangedEventArgs changedEventArgs = gridEvent.Arguments[0] as DataViewChangedEventArgs;
int action = (int)changedEventArgs.Action;
return(changedEventArgs.Action == ViewChangedAction.Reset);
}
protected virtual GridViewEventResult ProcessTemplatePropertyChangedEvent(
GridViewEvent eventData)
{
PropertyChangedEventArgs changedEventArgs = eventData.Arguments[0] as PropertyChangedEventArgs;
if (changedEventArgs.PropertyName == "ViewDefinition")
{
this.SetViewElement();
}
if (changedEventArgs.PropertyName == "EnableGrouping")
{
this.groupPanelElement.UpdateVisibility();
}
return((GridViewEventResult)null);
}
public void FlushEvents()
{
if (this.IsDisposing || this.IsDisposed)
{
throw new ObjectDisposedException(nameof(GridViewSynchronizationService));
}
++this.dispatchingCount;
do
{
this.AnalyzeQueue();
if (this.eventsQueue.Count != 0)
{
this.currentEvent = this.eventsQueue.First.Value;
this.eventsQueue.RemoveFirst();
if (this.currentEvent.Info.DispatchMode == GridEventDispatchMode.Post)
{
this.syncContext.Post(new SendOrPostCallback(this.OnPostCallback), (object)this.currentEvent);
}
else
{
GridViewEvent currentEvent = this.currentEvent;
GridViewEventInfo info = currentEvent.Info;
bool flag = this.CanBeSuspended(info);
if (flag)
{
this.SuspendEvent(info.Id);
}
this.NotifyListeners(currentEvent);
this.currentEvent = currentEvent;
if (flag)
{
this.ResumeEvent(info.Id);
}
}
this.currentEvent = (GridViewEvent)null;
}
else
{
break;
}
}while (this.eventsQueue.Count > 0);
--this.dispatchingCount;
}
bool IGridViewEventListener.AnalyzeQueue(List <GridViewEvent> events)
{
int count = events.Count;
for (int index = count - 1; index >= 0; --index)
{
GridViewEvent gridViewEvent = events[index];
if (gridViewEvent.Info.Id == KnownEvents.ViewChanged)
{
DataViewChangedEventArgs changedEventArgs = gridViewEvent.Arguments[0] as DataViewChangedEventArgs;
if (changedEventArgs.Action == ViewChangedAction.FilteringChanged || changedEventArgs.Action == ViewChangedAction.FilterExpressionChanged)
{
events.RemoveAll(new Predicate <GridViewEvent>(this.IsGridViewEventToRemove));
return(count != events.Count);
}
}
}
return(false);
}
public GridViewEventResult ProcessEvent(GridViewEvent eventData)
{
bool flag1 = GridViewSynchronizationService.IsTemplatePropertyChangedEvent(eventData) && (eventData.Arguments[0] as PropertyChangedEventArgs).PropertyName == "EnableGrouping";
bool flag2 = GridViewSynchronizationService.IsTemplatePropertyChangedEvent(eventData) && (eventData.Arguments[0] as PropertyChangedEventArgs).PropertyName == "AllowDragToGroup";
if (flag1 || GridViewSynchronizationService.IsColumnsCollectionChangedEvent(eventData))
{
this.UpdateVisibility();
}
else if (GridViewSynchronizationService.IsGroupCollectionChangedEvent(eventData) || eventData.Info.Id == KnownEvents.ViewChanged && (eventData.Arguments[0] as DataViewChangedEventArgs).Action == ViewChangedAction.Reset)
{
this.UpdateView();
}
else if (flag2 || eventData.Info.Id == KnownEvents.LocalizationProviderChanged)
{
this.UpdateView();
}
return((GridViewEventResult)null);
}
GridViewEventResult IGridViewEventListener.ProcessEvent(
GridViewEvent eventData)
{
if (GridViewSynchronizationService.IsTemplatePropertyChangingEvent(eventData))
{
return(this.ProcessTemplatePropertyChanging(eventData));
}
if (eventData.Sender != this.template)
{
return((GridViewEventResult)null);
}
if (GridViewSynchronizationService.IsTemplatePropertyChangedEvent(eventData))
{
return(this.ProcessTemplatePropertyChangedEvent(eventData));
}
if (eventData.Info.Id == KnownEvents.ViewChanged)
{
return(this.ProcessViewChangedEvent(eventData));
}
return((GridViewEventResult)null);
}
GridViewEventResult IGridViewEventListener.ProcessEvent(
GridViewEvent eventData)
{
GridViewFilterDescriptorCollection sender1 = eventData.Sender as GridViewFilterDescriptorCollection;
GridViewTemplate sender2 = eventData.Sender as GridViewTemplate;
GridViewDataColumn sender3 = eventData.Sender as GridViewDataColumn;
if (sender2 == this.ViewTemplate && eventData.Info.Id == KnownEvents.ViewChanged)
{
this.ProcessViewChanged(eventData.Arguments[0] as DataViewChangedEventArgs);
}
else if (sender3 != null && sender3.OwnerTemplate == this.ViewTemplate && (eventData.Info.Id == KnownEvents.PropertyChanged && sender3.FilterDescriptor == null))
{
this.CreateFilterDescriptor(sender3, this.GetDefaultFilterOperator(sender3));
}
else if (sender1 != null && sender1.Owner == this.ViewTemplate && eventData.Info.Id == KnownEvents.CollectionChanged)
{
this.ProcessFilterDescriptorCollectionChanged(eventData.Arguments[0] as NotifyCollectionChangedEventArgs);
}
return((GridViewEventResult)null);
}
public static void DispatchEvent(
GridViewTemplate template,
GridViewEvent eventData,
bool postUI)
{
if (template == null)
{
throw new ArgumentNullException("Template");
}
MasterGridViewTemplate masterTemplate = template.MasterTemplate;
if (masterTemplate == null)
{
return;
}
GridViewSynchronizationService synchronizationService = masterTemplate.SynchronizationService;
if (synchronizationService == null)
{
return;
}
if (eventData.Info.Type == GridEventType.Both && postUI)
{
KnownEvents id = eventData.Info.Id;
bool critical = eventData.Info.Critical;
object[] arguments = eventData.Arguments;
object sender = eventData.Sender;
object originator = eventData.Originator;
GridViewEventInfo eventInfo1 = new GridViewEventInfo(id, GridEventType.Data, GridEventDispatchMode.Send, critical);
GridViewEvent gridEvent1 = new GridViewEvent(sender, originator, arguments, eventInfo1);
GridViewEventInfo eventInfo2 = new GridViewEventInfo(id, GridEventType.UI, GridEventDispatchMode.Post, critical);
GridViewEvent gridEvent2 = new GridViewEvent(sender, originator, arguments, eventInfo2);
synchronizationService.DispatchEvent(gridEvent1);
synchronizationService.DispatchEvent(gridEvent2);
}
else
{
synchronizationService.DispatchEvent(eventData);
}
}
private void OnPostCallback(object state)
{
GridViewEvent gridEvent = state as GridViewEvent;
if (gridEvent == null || this.IsDisposing || this.IsDisposed)
{
return;
}
GridViewEventInfo info = gridEvent.Info;
bool flag = this.CanBeSuspended(info);
if (flag)
{
this.SuspendEvent(info.Id);
}
this.NotifyListeners(gridEvent);
if (!flag)
{
return;
}
this.ResumeEvent(info.Id);
}
public void DispatchEvent(GridViewEvent gridEvent)
{
if (!this.VerifyDispatch(gridEvent))
{
return;
}
gridEvent.SynchronizationService = this;
if (gridEvent.Info.Critical)
{
this.eventsQueue.AddFirst(gridEvent);
}
else
{
this.eventsQueue.AddLast(gridEvent);
}
if (this.beginDispatchCount != (byte)0)
{
return;
}
this.BeginDispatch();
this.FlushEvents();
this.EndDispatch();
}
GridViewEventResult IGridViewEventListener.PostProcessEvent(
GridViewEvent eventData)
{
if (eventData.Info.Id == KnownEvents.ViewChanged)
{
DataViewChangedEventArgs changedEventArgs = eventData.Arguments[0] as DataViewChangedEventArgs;
if (changedEventArgs.Action == ViewChangedAction.Add || changedEventArgs.Action == ViewChangedAction.Remove || (changedEventArgs.Action == ViewChangedAction.FilteringChanged || changedEventArgs.Action == ViewChangedAction.GroupingChanged) || (changedEventArgs.Action == ViewChangedAction.SortingChanged || changedEventArgs.Action == ViewChangedAction.ItemChanged || changedEventArgs.Action == ViewChangedAction.Reset))
{
this.cache.Clear();
this.Search(this.searchCriteria);
}
else if ((changedEventArgs.Action == ViewChangedAction.CurrentCellChanged || changedEventArgs.Action == ViewChangedAction.CurrentColumnChanged || changedEventArgs.Action == ViewChangedAction.CurrentRowChanged) && !this.isNavigating)
{
this.selectionChangedByUser = true;
}
}
else if (eventData.Info.Id == KnownEvents.PropertyChanged && eventData.Sender is GridViewDataColumn && (eventData.Arguments[0] as RadPropertyChangedEventArgs).Property.Name == "IsVisible")
{
this.cache.Clear();
this.Search(this.searchCriteria);
}
return((GridViewEventResult)null);
}
public bool AnalyzeQueue(List <GridViewEvent> events)
{
bool flag1 = false;
GridViewEvent gridViewEvent1 = (GridViewEvent)null;
for (int index = events.Count - 1; index >= 0; --index)
{
GridViewEvent gridViewEvent2 = events[index];
bool flag2 = GridViewSynchronizationService.IsGroupCollectionChangedEvent(gridViewEvent2);
if (flag2)
{
if (gridViewEvent1 == null || gridViewEvent1 == gridViewEvent2)
{
gridViewEvent1 = gridViewEvent2;
}
else if (flag2)
{
events.Remove(gridViewEvent2);
flag1 = true;
}
}
}
return(flag1);
}
GridViewEventResult IGridViewEventListener.PreProcessEvent(
GridViewEvent eventData)
{
if (eventData.Info.Id != KnownEvents.CurrentChanged)
{
return((GridViewEventResult)null);
}
if (eventData.Originator is RadDataView <GridViewRowInfo> )
{
if (this.IsInEditMode)
{
return(new GridViewEventResult(true, true));
}
return((GridViewEventResult)null);
}
PositionChangingEventArgs args = new PositionChangingEventArgs(eventData.Arguments[0] as GridViewRowInfo, eventData.Arguments[1] as GridViewColumn);
this.OnPositionChanging(args);
if (args.Cancel)
{
return(new GridViewEventResult(false, true));
}
return((GridViewEventResult)null);
}
public GridViewEventResult PostProcessEvent(GridViewEvent eventData)
{
return((GridViewEventResult)null);
}
GridViewEventResult IGridViewEventListener.PostProcessEvent(
GridViewEvent eventData)
{
return (GridViewEventResult) null;
}
