some questions about the slider control in wp7

private System.Windows.Controls.Primitives.Thumb _thumb;

public override void OnApplyTemplate()
{
	base.OnApplyTemplate();

	if (_thumb != null)
	{
		_thumb.MouseEnter -= new MouseEventHandler(thumb_MouseEnter);
	}

	if (_thumb == null)
	{
		System.Windows.Controls.Primitives.Track track = this.Template.FindName(
		   "PART_Track", this) as System.Windows.Controls.Primitives.Track;
		if (track != null)
			_thumb = track.Thumb;
	}

	if (_thumb != null)
	{
		_thumb.MouseEnter += thumb_MouseEnter;
	}
}

void thumb_MouseEnter(object sender, MouseEventArgs e)
{
	if (!this.IsMoveToPointEnabled)
		return;
            
	if (e.LeftButton == MouseButtonState.Pressed)
	{
		// the left button is pressed on mouse enter
		// but the mouse isn't captured (when MouseEnter fires), so the thumb
		// must have been moved under the mouse in response
		// to a click on the track.
		// Generate a MouseLeftButtonDown event so that
		// the user can just drag the thumb without having to click again.

		var args = new MouseButtonEventArgs(
			e.MouseDevice, e.Timestamp, MouseButton.Left);

		args.RoutedEvent = MouseLeftButtonDownEvent;
		(sender as System.Windows.Controls.Primitives.Thumb).RaiseEvent(args);
	}
}



public static readonly RoutedEvent CommandChangedEvent = EventManager.RegisterRoutedEvent(
	"CommandChangedEvent",
	RoutingStrategy.Bubble,
	typeof(RoutedPropertyChangedEventHandler<icommand>),
	typeof(XSlider));


public event RoutedPropertyChangedEventHandler<icommand> CommandChanged
{
	add { AddHandler(CommandChangedEvent, value); }
	remove { RemoveHandler(CommandChangedEvent, value); }
}


protected virtual void OnCommandChanged(ICommand oldValue, ICommand newValue)
{
	RoutedPropertyChangedEventArgs<icommand> args = new RoutedPropertyChangedEventArgs<icommand>(oldValue, newValue);
	args.RoutedEvent = XSlider.CommandChangedEvent;
	RaiseEvent(args);              

	if (cmd_CanExecuteChangedHandler == null)
		cmd_CanExecuteChangedHandler = cmd_CanExecuteChanged;
	if (oldValue != null)
		oldValue.CanExecuteChanged -= cmd_CanExecuteChangedHandler;
	if (newValue != null)
		newValue.CanExecuteChanged += cmd_CanExecuteChangedHandler;
	else
		cmd_CanExecuteChangedHandler = null;

	UpdateCanExecute();
}

// hold a reference to it, it might me stored as a weak reference and never be called otherwise...
EventHandler cmd_CanExecuteChangedHandler;

void cmd_CanExecuteChanged(object sender, EventArgs e)
{            
	UpdateCanExecute();
}

void UpdateCanExecute()
{
	if (IsCommandExecuting)
		return;

	ICommand cmd = Command;
	if (cmd == null)
	{
		IsEnabled = true;
	}
	else
	{
		try
		{
			IsCommandExecuting = true;

			var ca = new CommandCanExecuteParameter(CommandParameter);
			bool enabled = CommandUtil.CanExecute(this, CommandParameter);                    
			IsEnabled = enabled;
			CommandUtil.CanExecute(this, ca);
			if (enabled && ca.CurrentValue != null)
			{
				if (ca.CurrentValue is float)
				{
					Value = (float)ca.CurrentValue;
				}
				else if (ca.CurrentValue is double)
				{
					Value = (double)ca.CurrentValue;
				}
				if (ca.CurrentValue is RangedValue)
				{
					var rangedValue = (RangedValue)ca.CurrentValue;
					Value = rangedValue.Value;
					if (rangedValue.Minimum.HasValue)
						Minimum = rangedValue.Minimum.Value;
					if (rangedValue.Maximum.HasValue)
						Maximum = rangedValue.Maximum.Value;
				}
			}
		}
		finally { IsCommandExecuting = false; }
	}
}

private bool IsCommandExecuting { get; set; }