public void CurrentChangingEventArgsConstructor1Test()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs ();
Assert.IsFalse (args.Cancel, "CTOR1_#1");
Assert.IsTrue (args.IsCancelable, "CTOR1_#2");
}
private async void OnCurrentSpeakerChanging(object sender, CurrentChangingEventArgs e)
{
if (await this.SaveChangesAsync() == false && e.IsCancelable)
{
e.Cancel = true;
}
}
private void OnCurrentChanging(object sender, SCM.CurrentChangingEventArgs args)
{
SCM.CurrentChangingEventHandler currentChangingEventHandler = this.CurrentChanging;
if (currentChangingEventHandler != null)
{
currentChangingEventHandler(this, args);
}
}
void Items_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (!e.IsCancelable)
{
return;
}
Validate();
}
public void ChangeCancelIfNotCancelableTest()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs (false);
Assert.IsFalse (args.Cancel, "InvOp_#1");
Assert.IsFalse (args.IsCancelable, "InvOp_#2");
args.Cancel = true;
}
void Items_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (!e.IsCancelable)
{
return;
}
if (Validate())
{
return;
}
e.Cancel = true;
tabControl.SelectedItem = ((ICollectionView)sender).CurrentItem;
}
public void CurrentChangingEventArgsConstructor2Test()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs (false);
Assert.IsFalse (args.Cancel, "CTOR2_#1");
Assert.IsFalse (args.IsCancelable, "CTOR2_#2");
args = new CurrentChangingEventArgs (true);
Assert.IsFalse (args.Cancel, "CTOR1_#3");
Assert.IsTrue (args.IsCancelable, "CTOR1_#4");
args.Cancel = true;
Assert.IsTrue (args.Cancel, "CTOR1_#5");
}
protected virtual void OnCurrentChanging(SCM.CurrentChangingEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (this.CurrentChangedMonitor.Busy)
{
if (!args.IsCancelable)
{
return;
}
args.Cancel = true;
}
else
{
if (this.CurrentChanging == null)
{
return;
}
this.CurrentChanging((object)this, args);
}
}
/// <summary>
/// Raises the CurrentChanging event
/// </summary>
/// <param name="args">
/// CancelEventArgs used by the consumer of the event. args.Cancel will
/// be true after this call if the CurrentItem should not be changed for
/// any reason.
/// </param>
/// <exception cref="InvalidOperationException">
/// This CurrentChanging event cannot be canceled.
/// </exception>
private void OnCurrentChanging(CurrentChangingEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (this._currentChangedMonitor.Busy)
{
if (args.IsCancelable)
{
args.Cancel = true;
}
return;
}
if (this.CurrentChanging != null)
{
this.CurrentChanging(this, args);
}
}
protected bool OKToChangeCurrent()
{
SCM.CurrentChangingEventArgs args = new SCM.CurrentChangingEventArgs();
this.OnCurrentChanging(args);
return(!args.Cancel);
}
private void CollView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (_blockTabControlChanged)
{
int previousIndex = tabControl1.Items.IndexOf(tabControl1.SelectedContent);
tabControl1.SelectedIndex = previousIndex;
e.Cancel = true;
}
}
internal void OnCurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.Events))
{
TraceData.Trace(TraceEventType.Warning,
TraceData.GotEvent(
TraceData.Identify(this),
"CurrentChanging",
TraceData.Identify(sender)));
}
Update();
//
}
private async void OnCurrentSessionChanging(object sender, CurrentChangingEventArgs e)
{
if (this.IsBusy) return;
// vorherige Session speichern
if (await this.SaveChangesAsync() == false && e.IsCancelable)
e.Cancel = true;
}
/// <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 Methods
//
// event handler for CurrentChanging event
private void OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
DeliverEvent(sender, args);
}
private void OnCurrentChanging(CurrentChangingEventArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (this._currentChangedMonitor.Busy)
{
if (args.get_IsCancelable())
{
args.set_Cancel(true);
}
}
else if (this.CurrentChanging != null)
{
this.CurrentChanging.Invoke(this, args);
}
}
/// <summary>
/// Raises the CurrentChanging event
/// </summary>
/// <param name="args">
/// CancelEventArgs used by the consumer of the event. args.Cancel will
/// be true after this call if the CurrentItem should not be changed for
/// any reason.
/// </param>
/// <exception cref="InvalidOperationException">
/// This CurrentChanging event cannot be canceled.
/// </exception>
protected virtual void OnCurrentChanging(CurrentChangingEventArgs args)
{
if (args == null)
throw new ArgumentNullException("args");
if (_currentChangedMonitor.Busy)
{
if (args.IsCancelable)
args.Cancel = true;
return;
}
if (CurrentChanging != null)
{
CurrentChanging(this, args);
}
}
/// <summary>
/// ask listeners (via <seealso cref="ICollectionView.CurrentChanging"/> event) if it's OK to change currency
/// </summary>
/// <returns>false if a listener cancels the change, true otherwise</returns>
protected bool OKToChangeCurrent()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs();
OnCurrentChanging(args);
return (!args.Cancel);
}
protected virtual void OnCurrentChanging (CurrentChangingEventArgs args)
{
if (CurrentChanging != null)
CurrentChanging (this, args);
}
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>
/// Handles the situation where the current item is changing on the ICollectionView.
/// </summary>
/// <param name="sender">The ICollectionView.</param>
/// <param name="e">The event args.</param>
private void OnCollectionViewCurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (this.ShouldValidateOnCurrencyChange)
{
this.ValidateItem();
}
if (e.IsCancelable && (this.AutoCommitPreventsCurrentItemChange || !this.IsItemValid))
{
e.Cancel = true;
}
}
void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
// VerifyAccess(); // will throw an exception if caller is not in correct UiContext
if (PrivateCurrentChanging != null)
PrivateCurrentChanging(this, args);
}
/// <summary>
/// Generates script when going to Script tab, and prevents returning to Transform tab without a confirmation to lose changes.
/// </summary>
private void Items_CurrentChanging(object sender, CurrentChangingEventArgs e) {
if (string.IsNullOrEmpty(encodeSettings.FileName))
return;
SettingsTab.Focus();
var item = ((ICollectionView)sender).CurrentItem;
bool Cancel = false;
// Generate script when going to Script tab.
if (SettingsTab.SelectedIndex == 2 && string.IsNullOrEmpty(encodeSettings.CustomScript)) {
if (Validate())
business.GenerateCustomScript(encodeSettings);
else
Cancel = true;
} else if (SettingsTab.SelectedIndex == 0 && !string.IsNullOrEmpty(encodeSettings.CustomScript)) {
// Ask for confirmation before going back to Transform tab and losing changes.
if (business.CustomScriptHasChanges(encodeSettings))
if (MessageBox.Show("You will lose any changes to your script. Are you sure?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Exclamation) == MessageBoxResult.No)
Cancel = true;
if (!Cancel)
encodeSettings.CustomScript = null;
}
// Revert to previously-selected tab.
if (Cancel) {
e.Cancel = true;
SettingsTab.SelectedItem = item;
}
}
private void CollectionView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
if (this._owner.NoCurrentCellChangeCount == 0 &&
!this._expectingCurrentChanged &&
!this.CommittingEdit &&
!this._owner.CommitEdit())
{
// If CommitEdit failed, then the user has most likely input invalid data.
// We should cancel the current change if we can, otherwise we have to abort the edit.
if (e.IsCancelable)
{
e.Cancel = true;
}
else
{
this._owner.CancelEdit(DataGridEditingUnit.Row, false);
}
}
}
private void OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (this.ignoreEventsLevel != 0)
{
return;
}
this.OnCurrentChanging(args);
}
private void ActiveFilesView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
}
void _OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
if (_ignoreEventsLevel != 0)
return;
OnCurrentChanging();
}
bool MoveCurrentTo (int position, bool force)
{
object newItem = ItemAtIndex (position);
bool raiseEvents = force || CurrentItem != newItem;
if (raiseEvents) {
CurrentChangingEventArgs e = new CurrentChangingEventArgs (true);
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;
}
/// <summary>
/// Handles the event which occurs when the selected item is about to change
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void CollectionViewCurrentChanging(object sender, CurrentChangingEventArgs e)
{
CollectionView collectionView = (CollectionView)sender;
if (collectionView != null && collectionView.CurrentPosition >= 0 && collectionView.CurrentPosition <= piePieces.Count)
{
PiePiece piece = piePieces[collectionView.CurrentPosition];
DoubleAnimation a = new DoubleAnimation();
a.To = 0;
a.Duration = new Duration(TimeSpan.FromMilliseconds(200));
piece.BeginAnimation(PiePiece.PushOutProperty, a);
}
}
//
// Private Methods
//
// event handler for CurrentChanging event
private void OnCurrentChanging(object sender, CurrentChangingEventArgs args)
{
DeliverEvent(sender, args);
}
private void ItemsCollectionView_CurrentChanging(object sender, System.ComponentModel.CurrentChangingEventArgs e)
{
ModifiedRequest();
}
private bool SetCurrentItem( int newCurrentPosition, object newCurrentItem, bool isCancelable, bool beforeDeleteOperation )
{
object oldCurrentItem = this.CurrentItem;
int oldCurrentPosition = this.CurrentPosition;
bool oldIsCurrentBeforeFirst = this.IsCurrentBeforeFirst;
bool oldIsCurrentAfterLast = this.IsCurrentAfterLast;
if( ( !object.Equals( oldCurrentItem, newCurrentItem ) ) || ( oldCurrentPosition != newCurrentPosition ) )
{
// We raise the changing event even if we are in DeferCurrencyEvent
CurrentChangingEventArgs currentChangingEventArgs = new CurrentChangingEventArgs( isCancelable );
this.OnCurrentChanging( currentChangingEventArgs );
if( ( !currentChangingEventArgs.Cancel ) || ( !currentChangingEventArgs.IsCancelable ) )
{
int count = this.Count;
if( beforeDeleteOperation )
{
Debug.Assert( count > 0 );
count--;
}
bool isCurrentBeforeFirst;
bool isCurrentAfterLast;
if( count == 0 )
{
isCurrentBeforeFirst = true;
isCurrentAfterLast = true;
}
else
{
isCurrentBeforeFirst = newCurrentPosition < 0;
isCurrentAfterLast = newCurrentPosition >= count;
}
#if DEBUG
if( newCurrentItem == null )
Debug.Assert( ( newCurrentPosition == -1 ) || ( newCurrentPosition >= ( count - 1 ) ) );
#endif
this.SetCurrentItemAndPositionCore(
newCurrentItem, newCurrentPosition, isCurrentBeforeFirst, isCurrentAfterLast );
if( !this.IsCurrencyDeferred )
{
if( !object.Equals( oldCurrentItem, newCurrentItem ) )
this.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentItem" ) );
if( oldCurrentPosition != this.CurrentPosition )
this.OnPropertyChanged( new PropertyChangedEventArgs( "CurrentPosition" ) );
if( oldIsCurrentBeforeFirst != this.IsCurrentBeforeFirst )
this.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentBeforeFirst" ) );
if( oldIsCurrentAfterLast != this.IsCurrentAfterLast )
this.OnPropertyChanged( new PropertyChangedEventArgs( "IsCurrentAfterLast" ) );
this.OnCurrentChanged();
}
}
}
return ( newCurrentItem != null );
}
/// <summary>
/// Ask listeners (via ICollectionView.CurrentChanging event) if it's OK to change currency
/// </summary>
/// <returns>False if a listener cancels the change, True otherwise</returns>
private bool OkToChangeCurrent()
{
CurrentChangingEventArgs args = new CurrentChangingEventArgs();
this.OnCurrentChanging(args);
return !args.Cancel;
}
protected virtual new void OnCurrentChanging(System.ComponentModel.CurrentChangingEventArgs args)
{
}
private void OnTabItemSelecting(Object sender, CurrentChangingEventArgs e)
{
}
void collectionView_CurrentChanging(object sender, CurrentChangingEventArgs e)
{
this.mediaElement.Stop();
}
protected virtual new void OnCurrentChanging(System.ComponentModel.CurrentChangingEventArgs args)
{
Contract.Requires(args != null);
}