private void OnSelectedCompletionSetSelectionStatusChanged(object sender, ValueChangedEventArgs<CompletionSelectionStatus> e)
 {
     if (e.NewValue != null && e.NewValue.Completion != null)
     {
         this.view.Select(e.NewValue.Completion);
     }
 }

		private void OnActivityChanged(object sender, ValueChangedEventArgs<Activity> valueChangedEventArgs)
		{
			if (valueChangedEventArgs.NewValue != null)
			{
				_semaphore.Release();
			}
		}

		//todo a tester sur faible api
		private void InitTts(object sender, ValueChangedEventArgs<Activity> valueChangedEventArgs)
		{
			if (_speakerSpeech == null)
			{
				Initialize();
			}
		}

 private void rate_ValueChanged_1(object sender, ValueChangedEventArgs<double> e)
 {
     Rating r = sender as Rating;
     if (EventOutput != null)
     {
         EventOutput.Text = string.Format("You selected '{0}'", e.NewValue.ToString());
         EventOutput.Text += string.Format("\nOld Value: {0}, New Value: {1}", e.OldValue.ToString(), e.NewValue.ToString());
     }
 }

        protected override void OnSourceServerChanged(object sender, ValueChangedEventArgs<SourceTileServer> e)
        {
            base.OnSourceServerChanged(sender, e);

            var mapTileProvider = TileProvider as MapTileProvider;
            if (mapTileProvider == null)
                throw new ArgumentException("MercatorShaderMap's TileProvider should be only MapTileProvider.");

            mercatorTransform = new MercatorTransform(mapTileProvider.MaxShaderLatitude);
        }

        /// <summary>
        /// Handles the corresponding event.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="ValueChangedEventArgs{EditorMap}"/> instance containing the event data.</param>
        void MapScreenControl_MapChanged(MapScreenControl sender, ValueChangedEventArgs<EditorMap> e)
        {
            // When the map changes, and it was our map that made the ToolBar visibile, then update the reference on the ToolBar

            var tb = ToolBar.GetToolBar(ToolBarVisibility);
            if (tb == null)
                return;

            var dispObj = GetToolBarObject();
            if (dispObj != null && tb.DisplayObject == dispObj)
                tb.DisplayObject = dispObj;
        }

        //If a child row switches to a new parent, both the old and
        //the new parents are affected.  (eg, depositing a payment)
        void ChildTable_ValueChanged(object sender, ValueChangedEventArgs e)
        {
            if (e.Column == ChildRelation.ChildColumn) {
                var oldRow = (Row)e.OldValue;
                if (oldRow != null)
                    OnRowInvalidated(oldRow);

                var newRow = e.Row.Field<Row>(e.Column);
                if (newRow != null)
                    OnRowInvalidated(newRow);
            }
        }

        /// <summary>
        /// Handles the pin's value changed event.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="args"></param>
        private void _echoPin_ValueChanged(IGpioPin sender, ValueChangedEventArgs args)
        {
            if (args.Edge == GpioPinEdge.RisingEdge)
            {
                _timer.Reset();
                _timer.Start();
            }

            if (args.Edge == GpioPinEdge.FallingEdge)
            {
                _timer.Stop();
                this.OnDistanceSensed(this, new DistanceSensedEventArgs(_timer.Elapsed));
            }
        }

		private void viewport_PanningStateChanged(object sender, ValueChangedEventArgs<Viewport2DPanningState> e)
		{
			if (e.CurrentValue == Viewport2DPanningState.Panning && e.PreviousValue == Viewport2DPanningState.NotPanning)
			{
				prevVisible = Visible;
			}
			else if (e.CurrentValue == Viewport2DPanningState.NotPanning && e.PreviousValue == Viewport2DPanningState.Panning)
			{
				notMineEvent = true;
				try
				{
					Visible = viewport.Visible;
				}
				finally { notMineEvent = false; }
			}
		}

 private void trackBar1_ValueChanged(object sender, EventArgs e)
 {
     if (this.ValueUpdated != null)
     {
         TrackBar bar = (TrackBar)sender;
         
         //reduce # of unnecessary value changed events
         if (Math.Abs(bar.Value - prevValue) >= bar.SmallChange)
         {
             prevValue = bar.Value;
             //Console.WriteLine(prevValue);
             ValueChangedEventArgs args = new ValueChangedEventArgs(bar.Value);
             this.ValueUpdated(this, args);
         }
     }
 }

        private static void p_ValueDelegate(object sender, ValueChangedEventArgs args)
        {
#if BASIC // comment/uncomment first line to switch logic path
            // basic event handling
            Console.WriteLine("{0} changed to {1}", args.OldValue, args.NewValue);
            Console.WriteLine(sender.ToString()); // call overridden ToString() on the sender object (person in this case)
#else
            // more advanced event handling; allows for reflection inside the object to get property NAME, the value of which is compared to the argument value
            PropertyInfo[] properties = sender.GetType().GetProperties();
            string changedProperty = "";

            foreach (PropertyInfo property in properties)
            {
                if (property.GetValue(sender).Equals(args.NewValue)) // may be more efficient with a do or while loop
                {
                    changedProperty = property.Name;
                }
            }

            Console.WriteLine("{0} changed from {1} to {2}", changedProperty, args.OldValue, args.NewValue);
            Console.WriteLine(sender.ToString());
#endif
        }

        private void OnOverlayDisplayModeChanged(object sender, ValueChangedEventArgs<OverlayDisplayMode> e)
        {
            OverlayWindow overlay = sender as OverlayWindow;

            if (overlay != null)
            {
                Settings.Default.OverlayDisplayMode = (int)overlay.DisplayMode;
                Settings.Default.Save();
            }
        }

 private void OnDataPointValueChanged_EventHandler(object sender, ValueChangedEventArgs e)
 {
     this.OnDataPointValueChanged(sender as DataPoint, e.ValueName, e.OldValue, e.NewValue);
     if (this.DataPointValueChanged == null)
         return;
     this.DataPointValueChanged(sender, e);
 }

 void hsb3_ValueChanged(object sender, ValueChangedEventArgs e)
 {
     if (btnTitle.Text == "Sprite Change Attribute") {
         lbl3.Text = "Value: " + hsb3.Value;
     } else if (btnTitle.Text == "Arena Attribute") {
         lbl1.Text = "Maps: " + hsb3.Value;
     } else if (btnTitle.Text == "Drop Shop Attribute") {
         lbl3.Text = "Given Value: " + hsb3.Value;
     }
 }

 protected internal void OnValueChanged(ValueChangedEventArgs<decimal> args)
 {
     this.Invoke(VALUE_CHANGED_ID, args);
 }

 void hTilesetSelect_ValueChanged(object sender, ValueChangedEventArgs e)
 {
     if (lblSelectedTileset.Text != "Tileset " + e.NewValue.ToString()) {
         lblSelectedTileset.Text = "Tileset " + e.NewValue.ToString();
         for (int i = 0; i < picTilesetPreview.Length; i++) {
             if (picTilesetPreview[i].Image != null) {
                 picTilesetPreview[i].Image.Dispose();
                 picTilesetPreview[i].Image = null;
             }
             picTilesetPreview[i].Image = new Surface(Graphics.GraphicsManager.Tiles[e.NewValue][(i + 1)]);
         }
     }
 }

 public override void CallEvent(FirebaseException firebaseException)
 {
     var valueChangedEventArgs = new ValueChangedEventArgs(firebaseException);
     @event(valueChangedEventArgs);
 }

 void Tickets_ValueChanged(object sender, ValueChangedEventArgs<RaffleTicket> e)
 {
     UpdateStats();
 }

        private void ViewGroup_DockStateChanging(object sender, ValueChangedEventArgs<ViewGroup, DockState> e)
        {
            if (e.NewValue == DockingLibrary.DockState.Hide)
                Hide();

            if (DockState != DockingLibrary.DockState.Hide && e.NewValue != DockingLibrary.DockState.Hide)
                OnDockStateChangingInternal(e.OldValue, e.NewValue);
        }

 /// <summary>
 /// Handles the map change event for targeting.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="ValueChangedEventArgs{Map}"/> instance containing the event data.</param>
 void World_MapChanged(World sender, ValueChangedEventArgs<Map> e)
 {
     MouseOverTarget = null;
     _target = null;
 }