public RangeSlider(
Key key = null,
RangeValues values = null,
ValueChanged <RangeValues> onChanged = null,
ValueChanged <RangeValues> onChangeStart = null,
ValueChanged <RangeValues> onChangeEnd = null,
float min = 0.0f,
float max = 1.0f,
int?divisions = null,
RangeLabels labels = null,
Color activeColor = null,
Color inactiveColor = null
) : base(key: key)
{
D.assert(values != null);
D.assert(min <= max);
D.assert(values.start <= values.end);
D.assert(values.start >= min && values.start <= max);
D.assert(values.end >= min && values.end <= max);
D.assert(divisions == null || divisions > 0);
this.values = values;
this.onChanged = onChanged;
this.onChangeStart = onChangeStart;
this.onChangeEnd = onChangeEnd;
this.min = min;
this.max = max;
this.divisions = divisions;
this.labels = labels;
this.activeColor = activeColor;
this.inactiveColor = inactiveColor;
}
static RangeValues PopulateRangeValues(object valueCollection)
{
var rangeValues = new RangeValues();
int index = 0;
foreach (var item in (IEnumerable)valueCollection)
{
if (index == 0)
{
rangeValues.Lower = item;
}
else if (index == 1)
{
rangeValues.Upper = item;
}
index++;
}
if (index != 2)
{
throw new ArgumentException("Range rule value collection should contain exactly two values.");
}
return(rangeValues);
}
void _handleChanged(RangeValues values)
{
D.assert(widget.onChanged != null);
RangeValues lerpValues = _lerpRangeValues(values);
if (lerpValues != widget.values)
{
widget.onChanged(lerpValues);
}
}
static Thumb?_defaultRangeThumbSelector(
TextDirection textDirection,
RangeValues values,
float tapValue,
Size thumbSize,
Size trackSize,
float dx
)
{
float touchRadius = Mathf.Max(thumbSize.width, RangeSlider._minTouchTargetWidth) / 2f;
bool inStartTouchTarget = (tapValue - values.start).abs() * trackSize.width < touchRadius;
bool inEndTouchTarget = (tapValue - values.end).abs() * trackSize.width < touchRadius;
if (inStartTouchTarget && inEndTouchTarget)
{
bool towardsStart = false;
bool towardsEnd = false;
switch (textDirection)
{
case TextDirection.ltr:
towardsStart = dx < 0;
towardsEnd = dx > 0;
break;
case TextDirection.rtl:
towardsStart = dx > 0;
towardsEnd = dx < 0;
break;
}
if (towardsStart)
{
return(Thumb.start);
}
if (towardsEnd)
{
return(Thumb.end);
}
}
else
{
if (tapValue < values.start || inStartTouchTarget)
{
return(Thumb.start);
}
if (tapValue > values.end || inEndTouchTarget)
{
return(Thumb.end);
}
}
return(null);
}
private QueryStringQueryToken ParseOneHandTermQuery(string field, char[] chars, int size, ref int index)
{
char c = chars[index];
bool lt = c == TOKEN_LT;
bool eq = chars[++index] == TOKEN_EQ;
if (eq)
{
index++;
}
string value = null;
int start = index;
bool space = false;
while (index < size)
{
c = chars[index];
if (c == TOKEN_SPACE)
{
space = true;
break;
}
index++;
}
if (index >= size)
{
index = size - 1;
}
if (index > start)
{
value = AsString(chars, start, space ? index - 1 : index);
}
if (string.IsNullOrWhiteSpace(value))
{
throw new QueryStringParseException("Expected field value, found nothing");
}
else
{
var rv = new RangeValue(value, eq);
RangeValues values = lt ? new RangeValues(null, rv) : new RangeValues(rv, null);
return(new QueryStringQueryToken(new RangeQuery(field, values)));
}
}
void _handleDragUpdate(DragUpdateDetails details)
{
float dragValue = _getValueFromGlobalPosition(details.globalPosition);
bool shouldCallOnChangeStart = false;
if (_lastThumbSelection == null)
{
_lastThumbSelection = sliderTheme.thumbSelector(textDirection.Value, values, dragValue, _thumbSize,
size, details.delta.dx);
if (_lastThumbSelection != null)
{
shouldCallOnChangeStart = true;
_active = true;
_state.overlayController.forward();
if (showValueIndicator)
{
_state.valueIndicatorController.forward();
}
}
}
if (isEnabled && _lastThumbSelection != null)
{
RangeValues currentValues = _discretizeRangeValues(values);
if (onChangeStart != null && shouldCallOnChangeStart)
{
onChangeStart(currentValues);
}
float currentDragValue = _discretize(dragValue);
float minThumbSeparationValue =
isDiscrete ? 0 : sliderTheme.minThumbSeparation.Value / _trackRect.width;
if (_lastThumbSelection == Thumb.start)
{
_newValues =
new RangeValues(Mathf.Min(currentDragValue, currentValues.end - minThumbSeparationValue),
currentValues.end);
}
else if (_lastThumbSelection == Thumb.end)
{
_newValues = new RangeValues(currentValues.start,
Mathf.Max(currentDragValue, currentValues.start + minThumbSeparationValue));
}
onChanged(_newValues);
}
}
void _startInteraction(Offset globalPosition)
{
float tapValue = _getValueFromGlobalPosition(globalPosition).clamp(0.0f, 1.0f);
_lastThumbSelection = sliderTheme.thumbSelector(textDirection.Value, values, tapValue, _thumbSize, size, 0);
if (_lastThumbSelection != null)
{
_active = true;
RangeValues currentValues = _discretizeRangeValues(values);
if (_lastThumbSelection == Thumb.start)
{
_newValues = new RangeValues(tapValue, currentValues.end);
}
else if (_lastThumbSelection == Thumb.end)
{
_newValues = new RangeValues(currentValues.start, tapValue);
}
_updateLabelPainter(_lastThumbSelection.Value);
if (onChangeStart != null)
{
onChangeStart(currentValues);
}
onChanged(_discretizeRangeValues(_newValues));
_state.overlayController.forward();
if (showValueIndicator)
{
_state.valueIndicatorController.forward();
_state.interactionTimer?.cancel();
_state.interactionTimer =
Timer.create(
new TimeSpan(0, 0, 0, 0,
(int)(_minimumInteractionTime.TotalMilliseconds * scheduler_.timeDilation)), () => {
_state.interactionTimer = null;
if (!_active && _state.valueIndicatorController.status == AnimationStatus.completed)
{
_state.valueIndicatorController.reverse();
}
});
}
}
}
void _endInteraction()
{
_state.overlayController.reverse();
if (showValueIndicator && _state.interactionTimer == null)
{
_state.valueIndicatorController.reverse();
}
if (_active && _state.mounted && _lastThumbSelection != null)
{
RangeValues discreteValues = _discretizeRangeValues(_newValues);
if (onChangeEnd != null)
{
onChangeEnd(discreteValues);
}
_active = false;
}
}
public _RangeSliderRenderObjectWidget(
Key key = null,
RangeValues values = null,
int?divisions = null,
RangeLabels labels = null,
SliderThemeData sliderTheme = null,
float textScaleFactor = 0f,
ValueChanged <RangeValues> onChanged = null,
ValueChanged <RangeValues> onChangeStart = null,
ValueChanged <RangeValues> onChangeEnd = null,
_RangeSliderState state = null) : base(key: key)
{
this.values = values;
this.divisions = divisions;
this.labels = labels;
this.sliderTheme = sliderTheme;
this.textScaleFactor = textScaleFactor;
this.onChanged = onChanged;
this.onChangeStart = onChangeStart;
this.onChangeEnd = onChangeEnd;
this.state = state;
}
RangeValues _discretizeRangeValues(RangeValues values)
{
return(new RangeValues(_discretize(values.start), _discretize(values.end)));
}
public _RenderRangeSlider(
RangeValues values,
int?divisions,
RangeLabels labels,
SliderThemeData sliderTheme,
ThemeData theme,
float textScaleFactor,
RuntimePlatform platform,
ValueChanged <RangeValues> onChanged,
ValueChanged <RangeValues> onChangeStart,
ValueChanged <RangeValues> onChangeEnd,
_RangeSliderState state,
TextDirection?textDirection)
{
D.assert(values != null);
D.assert(values.start >= 0.0 && values.start <= 1.0);
D.assert(values.end >= 0.0 && values.end <= 1.0);
D.assert(state != null);
D.assert(textDirection != null);
this.onChangeStart = onChangeStart;
this.onChangeEnd = onChangeEnd;
_platform = platform;
_labels = labels;
_values = values;
_divisions = divisions;
_sliderTheme = sliderTheme;
_theme = theme;
_textScaleFactor = textScaleFactor;
_onChanged = onChanged;
_state = state;
_textDirection = textDirection;
_updateLabelPainters();
GestureArenaTeam team = new GestureArenaTeam();
_drag = new HorizontalDragGestureRecognizer();
_drag.team = team;
_drag.onStart = _handleDragStart;
_drag.onUpdate = _handleDragUpdate;
_drag.onEnd = _handleDragEnd;
_drag.onCancel = _handleDragCancel;
_tap = new TapGestureRecognizer();
_tap.team = team;
_tap.onTapDown = _handleTapDown;
_tap.onTapUp = _handleTapUp;
_tap.onTapCancel = _handleTapCancel;
_overlayAnimation = new CurvedAnimation(
parent: _state.overlayController,
curve: Curves.fastOutSlowIn
);
_valueIndicatorAnimation = new CurvedAnimation(
parent: _state.valueIndicatorController,
curve: Curves.fastOutSlowIn
);
_enableAnimation = new CurvedAnimation(
parent: _state.enableController,
curve: Curves.easeInOut
);
}
RangeValues _unlerpRangeValues(RangeValues values)
{
return(new RangeValues(_unlerp(values.start), _unlerp(values.end)));
}
void _handleDragEnd(RangeValues values)
{
D.assert(widget.onChangeEnd != null);
widget.onChangeEnd(_lerpRangeValues(values));
}
void _handleDragStart(RangeValues values)
{
D.assert(widget.onChangeStart != null);
widget.onChangeStart(_lerpRangeValues(values));
}
public override void Update(GameTime gameTime)
{
//Update Keyboard and Mouse States
PreviousKeyboardState = CurrentKeyboardState;
CurrentKeyboardState = Keyboard.GetState();
PreviousMouseState = CurrentMouseState;
CurrentMouseState = Mouse.GetState();
//Clear Data Structures
ActiveActions.Clear();
ActiveStates.Clear();
ActiveRanges.Clear();
MappedKeyboardKeys.Clear();
MappedMouseButtons.Clear();
MappedMouseRanges.Clear();
RangeValues.Clear();
MouseScreenLocation = new Point(CurrentMouseState.X, CurrentMouseState.Y);
//Sort EntityList by InputMap Priority
EntityList.Sort((Entity x, Entity y) =>
{
if (x.GetComponent <CInputMap>().Priority < y.GetComponent <CInputMap>().Priority)
{
return(-1);
}
else if (x.GetComponent <CInputMap>().Priority > y.GetComponent <CInputMap>().Priority)
{
return(1);
}
else
{
return(0);
}
});
//Map Raw Inputs to Actions, States and Ranges
foreach (Entity e in EntityList)
{
var inputMap = e.GetComponent <CInputMap>();
//KEYBOARD KEY TO ACTION
foreach (KeyValuePair <Keys, int> pair in inputMap.KeyboardKeyToAction)
{
if (!MappedKeyboardKeys.Contains(pair.Key))
{
if (PreviousKeyboardState.IsKeyUp(pair.Key) && CurrentKeyboardState.IsKeyDown(pair.Key))
{
ActiveActions.Add(pair.Value);
MappedKeyboardKeys.Add(pair.Key);
}
}
}
//KEYBOARD KEY TO STATE
foreach (KeyValuePair <Keys, int> pair in inputMap.KeyboardKeyToState)
{
if (!MappedKeyboardKeys.Contains(pair.Key))
{
if (CurrentKeyboardState.IsKeyDown(pair.Key))
{
ActiveStates.Add(pair.Value);
MappedKeyboardKeys.Add(pair.Key);
}
}
}
//MOUSE BUTTON TO ACTION
foreach (KeyValuePair <MouseButtons, int> pair in inputMap.MouseButtonToAction)
{
if (!MappedMouseButtons.Contains(pair.Key))
{
if (pair.Key == MouseButtons.LeftButton)
{
if (PreviousMouseState.LeftButton == ButtonState.Released && CurrentMouseState.LeftButton == ButtonState.Pressed)
{
ActiveActions.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.RightButton)
{
if (PreviousMouseState.RightButton == ButtonState.Released && CurrentMouseState.RightButton == ButtonState.Pressed)
{
ActiveActions.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.MiddleButton)
{
if (PreviousMouseState.MiddleButton == ButtonState.Released && CurrentMouseState.MiddleButton == ButtonState.Pressed)
{
ActiveActions.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.XButton1)
{
if (PreviousMouseState.XButton1 == ButtonState.Released && CurrentMouseState.XButton1 == ButtonState.Pressed)
{
ActiveActions.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.XButton2)
{
if (PreviousMouseState.XButton2 == ButtonState.Released && CurrentMouseState.XButton2 == ButtonState.Pressed)
{
ActiveActions.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
}
}
//MOUSE BUTTON TO STATE
foreach (KeyValuePair <MouseButtons, int> pair in inputMap.MouseButtonToState)
{
if (!MappedMouseButtons.Contains(pair.Key))
{
if (pair.Key == MouseButtons.LeftButton)
{
if (CurrentMouseState.LeftButton == ButtonState.Pressed)
{
ActiveStates.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.RightButton)
{
if (CurrentMouseState.RightButton == ButtonState.Pressed)
{
ActiveStates.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.MiddleButton)
{
if (CurrentMouseState.MiddleButton == ButtonState.Pressed)
{
ActiveStates.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.XButton1)
{
if (CurrentMouseState.XButton1 == ButtonState.Pressed)
{
ActiveStates.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
if (pair.Key == MouseButtons.XButton2)
{
if (CurrentMouseState.XButton2 == ButtonState.Pressed)
{
ActiveStates.Add(pair.Value);
MappedMouseButtons.Add(pair.Key);
}
}
}
}
//MOUSE RANGE TO RANGE
foreach (KeyValuePair <MouseRanges, int> pair in inputMap.MouseRangeToRange)
{
if (!MappedMouseRanges.Contains(pair.Key))
{
if (pair.Key == MouseRanges.ScrollDelta)
{
ActiveRanges.Add(pair.Value);
RangeValues.Add(pair.Value, CurrentMouseState.ScrollWheelValue - PreviousMouseState.ScrollWheelValue);
MappedMouseRanges.Add(pair.Key);
}
if (pair.Key == MouseRanges.MouseHorizontalDelta)
{
float hCenter = ViewPort.Width / 2;
ActiveRanges.Add(pair.Value);
RangeValues.Add(pair.Value, CurrentMouseState.X - hCenter);
MappedMouseRanges.Add(pair.Key);
}
if (pair.Key == MouseRanges.MouseVerticalDelta)
{
float vCenter = ViewPort.Height / 2;
ActiveRanges.Add(pair.Value);
RangeValues.Add(pair.Value, CurrentMouseState.Y - vCenter);
MappedMouseRanges.Add(pair.Key);
}
}
}
}
//Given the Mapped Inputs, Call all Callbacks and see if they can use the Mapped Input
foreach (Entity e in EntityList)
{
var inputHandlers = e.GetComponent <CInputHandlers>();
foreach (int callbackID in inputHandlers.InputHandlerIDs)
{
GameRegistry.FetchInputCallback(callbackID)(e, gameTime, ActiveActions, ActiveStates, ActiveRanges, RangeValues);
}
}
}
