bool MoveCurrentTo(int position, bool force, bool cancellable)
{
if (DeferCurrentChanged)
{
return(false);
}
object newItem = ItemAtIndex(position);
bool raiseEvents = force || CurrentItem != newItem;
if (raiseEvents)
{
CurrentChangingEventArgs e = new CurrentChangingEventArgs(cancellable && ActiveList.Contains(CurrentItem));
RaiseCurrentChanging(e);
if (e.Cancel)
{
return(true);
}
}
IsCurrentAfterLast = position == ActiveList.Count || ActiveList.Count == 0;
IsCurrentBeforeFirst = position == -1 || ActiveList.Count == 0;
UpdateCurrentPositionAndItem(position, newItem);
if (raiseEvents)
{
RaiseCurrentChanged(EventArgs.Empty);
}
return(IsValidSelection);
}
public void CurrentChangingEventArgsConstructor1Test()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs();
Assert.IsFalse(args.Cancel, "CTOR1_#1");
Assert.IsTrue(args.IsCancelable, "CTOR1_#2");
}
// Token: 0x06007429 RID: 29737 RVA: 0x0021344A File Offset: 0x0021164A
private void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (this.PrivateCurrentChanging != null)
{
this.PrivateCurrentChanging(this, args);
}
}
// move the cursor to a new position
bool MoveCurrentToIndex(int index)
{
// invalid?
if (index < -1 || index >= _view.Count)
{
return(false);
}
// no change?
if (index == _index)
{
return(false);
}
// fire changing
var e = new CurrentChangingEventArgs();
OnCurrentChanging(e);
if (e.Cancel)
{
return(false);
}
// change and fire changed
_index = index;
OnCurrentChanged(null);
return(true);
}
static void view_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
var items = (ItemCollection)sender;
if (e.IsCancelable && items.CurrentItem != null)
{
var currentView = items.CurrentItem as FrameworkElement;
if (currentView == null)
{
return;
}
var selector = FindVisualParent <Selector>(currentView);
if (selector == null)
{
return;
}
var vetoingSource = currentView as IConfirmDeactivate ?? currentView.DataContext as IConfirmDeactivate;
if (vetoingSource != null && !vetoingSource.ConfirmDeactivation())
{
e.Cancel = true;
}
selector.Dispatcher.BeginInvoke(new Action(items.Refresh));
}
}
/// <summary>
/// Raises the <see cref="CurrentChanging"/> event.
/// </summary>
protected virtual void OnCurrentChanging(CurrentChangingEventArgs e)
{
if (_updating <= 0)
{
CurrentChanging?.Invoke(this, e);
}
}
protected bool OkToChangeCurrent()
{
var args = new CurrentChangingEventArgs();
OnCurrentChanging(args);
return(!args.Cancel);
}
/// <summary>
/// Determines whether it is OK to change current item.
/// </summary>
/// <returns>
/// <c>true</c> if is OK to change current item; otherwise, <c>false</c>.
/// </returns>
protected bool IsOKToChangeCurrent()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs();
this.OnCurrentChanging(args);
return(!args.Cancel);
}
private async void OnCurrentSpeakerChanging(object sender, CurrentChangingEventArgs e)
{
if (await this.SaveChangesAsync() == false && e.IsCancelable)
{
e.Cancel = true;
}
}
public void CollectionView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
_currentChangingFired = true;
if (_expectedEventQueue.Count > 0)
{
EventNotification eventNotification = _expectedEventQueue[0];
if (eventNotification.EventType == "CurrentChanging")
{
_expectedEventQueue.RemoveAt(0);
}
else
{
if (string.IsNullOrEmpty(eventNotification.Parameter))
{
Assert.Fail("CurrentChanging event was fired when we were expecting a " +
eventNotification.EventType + " event.");
}
else
{
Assert.Fail("CurrentChanging event was fired when we were expecting a " +
eventNotification.EventType + " event with Parameter: " + eventNotification.Parameter);
}
}
}
}
protected virtual void OnCurrentChanging(CurrentChangingEventArgs args)
{
if (CurrentChanging != null)
{
CurrentChanging(this, args);
}
}
// Token: 0x06007541 RID: 30017 RVA: 0x00218250 File Offset: 0x00216450
private void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (this._ignoreEventsLevel != 0)
{
return;
}
base.OnCurrentChanging();
}
private void View_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (invoicesViewSource.View.CurrentItem is Invoices item && item.IsNewInvoice)
{
RemoveThisInvoice = item;
}
RemoveItem(true);
}
private void OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (this.ignoreEventsLevel != 0)
{
return;
}
this.OnCurrentChanging(args);
}
private bool CanChangeCurrent()
{
var e = new CurrentChangingEventArgs(true);
CurrentChanging?.Invoke(this, e);
return(false == e.Cancel);
}
void Items_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (!e.IsCancelable)
{
return;
}
Validate();
}
/// <summary>
/// Currently selected item changing event
/// </summary>
/// <param name="e">event args</param>
protected virtual void OnCurrentChanging(CurrentChangingEventArgs e)
{
if (_deferCounter > 0)
{
return;
}
CurrentChanging?.Invoke(this, e);
}
private void View_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
Items item = (Items)itemsViewSource.View.CurrentItem;
if (item != null && item.ItemId == 0)
{
RemoveThisitem = item;
}
}
/// <summary>
/// Delete view if not cached!
/// </summary>
/// <param name="sender">object</param>
/// <param name="e">CurrentChangingEventArgs</param>
private void ViewsCurrentChanging(object sender, CurrentChangingEventArgs e)
{
var viewViewModel = Views.CurrentItem as ViewViewModel;
if (!CacheViews)
{
viewViewModel.View = null;
}
}
private void Items_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (e.IsCancelable && TabChangeCommand != null && !TabChangeCommand.CanExecute(SelectedItem))
{
var item = ((ICollectionView)sender).CurrentItem;
e.Cancel = true;
SelectedItem = item;
}
}
protected void RaiseCurrentChanging(CurrentChangingEventArgs e)
{
var h = CurrentChanging;
if (h != null)
{
h(this, e);
}
}
void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
// VerifyAccess(); // will throw an exception if caller is not in correct UiContext
if (PrivateCurrentChanging != null)
{
PrivateCurrentChanging(this, args);
}
}
void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (_ignoreEventsLevel != 0)
{
return;
}
OnCurrentChanging();
}
/// <summary>
/// Raises current changing events
/// </summary>
/// <param name="e">The event args</param>
protected virtual void OnCurrentChanging(CurrentChangingEventArgs e)
{
CurrentChangingEventHandler handler = this.CurrentChanging;
if (handler != null)
{
handler(this, e);
}
}
/// <summary>
/// Currently selected item changing event
/// </summary>
/// <param name="e">event args</param>
private void OnCurrentChanging(CurrentChangingEventArgs e)
{
if (_deferCounter > 0)
{
return;
}
CurrentChanging?.Invoke(this, e);
}
private void EnumerableCollectionView_OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (_ignoreEventsLevel != 0)
{
return;
}
OnCurrentChanging(args);
}
public void ChangeCancelIfNotCancelableTest()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs(false);
Assert.IsFalse(args.Cancel, "InvOp_#1");
Assert.IsFalse(args.IsCancelable, "InvOp_#2");
args.Cancel = true;
}
private void OnCurrentChanging(CurrentChangingEventArgs e)
{
var handler = CurrentChanging;
if (handler != null)
{
handler(this, e);
}
}
public virtual bool MoveCurrentToPosition(int position)
{
VerifyRefreshNotDeferred();
CurrentChangingEventArgs e;
is_current_after_last = false;
is_current_before_first = false;
if (position < 0)
{
e = new CurrentChangingEventArgs();
OnCurrentChanging(e);
if (e.Cancel)
{
return(true);
}
current_position = -1;
current_item = null;
is_current_before_first = true;
OnCurrentChanged();
return(false);
}
current_position = 0;
foreach (object item in source_collection)
{
if (current_position == position)
{
e = new CurrentChangingEventArgs();
OnCurrentChanging(e);
if (e.Cancel)
{
return(true);
}
current_item = item;
OnCurrentChanged();
return(true);
}
current_position++;
}
if (position <= current_position)
{
e = new CurrentChangingEventArgs();
OnCurrentChanging(e);
if (e.Cancel)
{
return(true);
}
}
current_item = null;
is_current_after_last = true;
if (position > current_position)
{
throw new ArgumentOutOfRangeException("position");
}
OnCurrentChanged();
return(false);
}
/// <summary>
/// Raises the <see cref="CurrentChanging"/> event.
/// </summary>
protected virtual void OnCurrentChanging(CurrentChangingEventArgs e)
{
if (_updating <= 0)
{
if (CurrentChanging != null)
{
CurrentChanging(this, e);
}
}
}
private void CollectionView_PagingTestCurrentChanging(object source, CurrentChangingEventArgs e)
{
if (this._cancelCurrencyMove == true)
{
e.Cancel = true;
}
else if (this._cancelCurrencyMove == false)
{
// Commit the edited/addition item before the page move occurs.
IEditableCollectionView editableCollectionView = (IEditableCollectionView)source;
if (editableCollectionView.IsAddingNew)
{
editableCollectionView.CommitNew();
}
else
{
editableCollectionView.CommitEdit();
}
}
}
protected bool OKToChangeCurrent()
{
CurrentChangingEventArgs e = new CurrentChangingEventArgs();
this.OnCurrentChanging(e);
return !e.Cancel;
}
protected virtual void OnCurrentChanging(CurrentChangingEventArgs args)
{
if (this.CurrentChanging != null)
{
this.CurrentChanging(this, args);
}
}
/// <summary>
/// This method will listen to the CurrentChanging event and cancel it.
/// </summary>
/// <param name="sender">PagedCollectionView firing the event</param>
/// <param name="e">CurrentChanging event args</param>
private void CancelCurrentChanging(object sender, CurrentChangingEventArgs e)
{
e.Cancel = true;
}
