public IScrollbar GetScrollbar(string idPrefix, SliderDirection direction,
IObject parent = null, float width = 15f, float height = 15f, float step = 10f, float buttonBorderWidth = 1f)
{
var slider = GetSlider($"{idPrefix}_{direction}Slider", null, null, 0f, 0f, 0f, parent);
slider.ShouldClampValuesWhenChangingMinMax = false;
slider.Direction = direction;
slider.HandleGraphics.Pivot = slider.IsHorizontal() ? new PointF(1f, 0f) : new PointF(0f, 1f);
slider.Graphics.Pivot = new PointF(0f, 0f);
slider.Graphics.Border = _borders.SolidColor(Colors.DarkGray, 0.5f, true);
slider.HandleGraphics.Border = _borders.SolidColor(Colors.White, 0.5f, true);
float gutterSize = slider.IsHorizontal() ? height : width;
HoverEffect.Add(slider.Graphics, Colors.Gray, Colors.LightGray);
HoverEffect.Add(slider.HandleGraphics, Colors.DarkGray, Colors.WhiteSmoke);
(var up, var down) = slider.IsHorizontal() ? (ArrowDirection.Left, ArrowDirection.Right) : (ArrowDirection.Up, ArrowDirection.Down);
PointF pivot = slider.IsHorizontal() ? (1f, 0f) : (0f, 1f);
(var upX, var upY) = slider.IsHorizontal() ? (0f, buttonBorderWidth / 2f) : (buttonBorderWidth / 2f, height - gutterSize * 2f);
(var idle, var hovered, var pushed) = getArrowButtonAnimations(up, buttonBorderWidth);
var upButton = GetButton($"{idPrefix}_Scroll{up}Button", idle, hovered, pushed, upX, upY, slider, width: gutterSize - buttonBorderWidth, height: gutterSize - buttonBorderWidth);
upButton.Pivot = pivot;
upButton.MouseClicked.Subscribe(args =>
{
if (direction == SliderDirection.TopToBottom || direction == SliderDirection.LeftToRight)
{
slider.Decrease(step);
}
else
{
slider.Increase(step);
}
_focus.HasKeyboardFocus = slider;
});
(var downX, var downY) = slider.IsHorizontal() ? (width - gutterSize * 2f, buttonBorderWidth / 2f) : (buttonBorderWidth / 2f, 0f);
(idle, hovered, pushed) = getArrowButtonAnimations(down, buttonBorderWidth);
var downButton = GetButton($"{idPrefix}_Scroll{down}Button", idle, hovered, pushed, downX, downY, slider, width: gutterSize - buttonBorderWidth, height: gutterSize - buttonBorderWidth);
downButton.Pivot = pivot;
downButton.MouseClicked.Subscribe(args =>
{
if (direction == SliderDirection.TopToBottom || direction == SliderDirection.LeftToRight)
{
slider.Increase(step);
}
else
{
slider.Decrease(step);
}
_focus.HasKeyboardFocus = slider;
});
var scrollbar = new AGSScrollbar(upButton, downButton, slider);
scrollbar.Step = step;
return(scrollbar);
}
public Scroller(float lowValue, float highValue, Action <float> valueChanged, SliderDirection direction = SliderDirection.Vertical)
{
base.AddToClassList(Scroller.ussClassName);
this.slider = new Slider(lowValue, highValue, direction, 20f)
{
name = "unity-slider",
viewDataKey = "Slider"
};
this.slider.AddToClassList(Scroller.sliderUssClassName);
this.slider.RegisterValueChangedCallback(new EventCallback <ChangeEvent <float> >(this.OnSliderValueChange));
this.lowButton = new RepeatButton(new Action(this.ScrollPageUp), 250L, 30L)
{
name = "unity-low-button"
};
this.lowButton.AddToClassList(Scroller.lowButtonUssClassName);
base.Add(this.lowButton);
this.highButton = new RepeatButton(new Action(this.ScrollPageDown), 250L, 30L)
{
name = "unity-high-button"
};
this.highButton.AddToClassList(Scroller.highButtonUssClassName);
base.Add(this.highButton);
base.Add(this.slider);
this.direction = direction;
this.valueChanged = valueChanged;
}
public Scroller(float lowValue, float highValue, System.Action <float> valueChanged, SliderDirection direction = SliderDirection.Vertical)
{
AddToClassList(ussClassName);
// Add children in correct order
slider = new Slider(lowValue, highValue, direction, kDefaultPageSize)
{
name = "unity-slider", viewDataKey = "Slider"
};
slider.AddToClassList(sliderUssClassName);
slider.RegisterValueChangedCallback(OnSliderValueChange);
lowButton = new RepeatButton(ScrollPageUp, ScrollWaitDefinitions.firstWait, ScrollWaitDefinitions.regularWait)
{
name = "unity-low-button"
};
lowButton.AddToClassList(lowButtonUssClassName);
Add(lowButton);
highButton = new RepeatButton(ScrollPageDown, ScrollWaitDefinitions.firstWait, ScrollWaitDefinitions.regularWait)
{
name = "unity-high-button"
};
highButton.AddToClassList(highButtonUssClassName);
Add(highButton);
Add(slider);
this.direction = direction;
this.valueChanged = valueChanged;
}
/// <summary>
/// Constructor.
/// </summary>
public Slider(string label, float start = 0, float end = kDefaultHighValue, SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize)
: base(label, start, end, direction, pageSize)
{
AddToClassList(ussClassName);
labelElement.AddToClassList(labelUssClassName);
visualInput.AddToClassList(inputUssClassName);
}
public Slider(float start, float end, System.Action <float> valueChanged,
SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize) :
this(start, end, direction, pageSize)
{
// We set this event last, so that the construction does not call it.
this.valueChanged = valueChanged;
}
internal BaseSlider(string label, TValueType start, TValueType end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize)
: base(label, null)
{
AddToClassList(ussClassName);
labelElement.AddToClassList(labelUssClassName);
visualInput.AddToClassList(inputUssClassName);
this.direction = direction;
this.pageSize = pageSize;
lowValue = start;
highValue = end;
pickingMode = PickingMode.Ignore;
visualInput.pickingMode = PickingMode.Position;
var trackElement = new VisualElement()
{
name = "unity-tracker"
};
trackElement.AddToClassList(trackerUssClassName);
visualInput.Add(trackElement);
dragElement = new VisualElement()
{
name = "unity-dragger"
};
dragElement.RegisterCallback <GeometryChangedEvent>(UpdateDragElementPosition);
dragElement.AddToClassList(draggerUssClassName);
visualInput.Add(dragElement);
clampedDragger = new ClampedDragger <TValueType>(this, SetSliderValueFromClick, SetSliderValueFromDrag);
visualInput.AddManipulator(clampedDragger);
}
// Update is called once per frame
void Update()
{
if (isOpen)
{
if (Input.GetMouseButtonDown(0))
{
x = Input.mousePosition.x;
}
if (Input.GetMouseButtonUp(0))
{
float xOffset = Input.mousePosition.x - x;
if (Mathf.Abs(xOffset) > CHECK_DISTANCE)
{
SliderDirection dir = xOffset > 0 ? SliderDirection.LEFT_TO_RIGHT : SliderDirection.RIGHT_TO_LEFT;
SuperEvent ev = new SuperEvent(SCREEN_SLIDER_EVENT);
ev.data = new object[] { dir };
SuperFunction.Instance.DispatchEvent(gameObject, ev);
}
}
}
}
public void RightButtonShouldChangeTheSliderImage(SliderDirection sliderButton)
{
this.homePage.Open();
var initialSliderStyle = this.homePage.Slider.SliderStyle;
this.homePage.Slider.ChangeImage(sliderButton);
Assert.AreNotEqual(initialSliderStyle, this.homePage.Slider.SliderStyle, "Slider buttons didn't change the image");
}
internal BaseSlider(string label, TValueType start, TValueType end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize)
: base(label, null)
{
AddToClassList(ussClassName);
labelElement.AddToClassList(labelUssClassName);
visualInput.AddToClassList(inputUssClassName);
this.direction = direction;
this.pageSize = pageSize;
lowValue = start;
highValue = end;
pickingMode = PickingMode.Ignore;
dragContainer = new VisualElement()
{
name = "unity-drag-container"
};
dragContainer.AddToClassList(dragContainerUssClassName);
visualInput.Add(dragContainer);
trackElement = new VisualElement()
{
name = "unity-tracker", usageHints = UsageHints.DynamicColor
};
trackElement.AddToClassList(trackerUssClassName);
dragContainer.Add(trackElement);
dragBorderElement = new VisualElement()
{
name = "unity-dragger-border"
};
dragBorderElement.AddToClassList(draggerBorderUssClassName);
dragContainer.Add(dragBorderElement);
dragElement = new VisualElement()
{
name = "unity-dragger", usageHints = UsageHints.DynamicTransform
};
dragElement.RegisterCallback <GeometryChangedEvent>(UpdateDragElementPosition);
dragElement.AddToClassList(draggerUssClassName);
dragContainer.Add(dragElement);
clampedDragger = new ClampedDragger <TValueType>(this, SetSliderValueFromClick, SetSliderValueFromDrag);
dragContainer.pickingMode = PickingMode.Position;
dragContainer.AddManipulator(clampedDragger);
RegisterCallback <KeyDownEvent>(OnKeyDown);
RegisterCallback <NavigationMoveEvent>(OnNavigationMove);
UpdateTextFieldVisibility();
var mouseDragger = new FieldMouseDragger <TValueType>(this);
mouseDragger.SetDragZone(labelElement);
labelElement.AddToClassList(labelDraggerVariantUssClassName);
}
public ValueSlider(string label, float start, float end, SliderDirection direction, int pageSize,
float defaultValue = 0f) : base(label, start, end, direction, pageSize)
{
var newFloatField = new FloatField();
value = defaultValue;
this.RegisterValueChangedCallback(evt => { newFloatField.SetValueWithoutNotify(evt.newValue); });
newFloatField.RegisterValueChangedCallback(evt => { value = evt.newValue; });
Add(newFloatField);
newFloatField.SetValueWithoutNotify(value);
}
async Task StartSliderMovement(SliderDirection direction)
{
// Direction
var directionCommand = direction == SliderDirection.Right ? "dr#" : "dl#";
await bluetoothLeService.WriteToServiceCharacteristicAsync(directionCommand, serviceUuid, characteristicUuid);
// Speed
var speedValue = 2500 - (int)SpeedSlider.Value;
await bluetoothLeService.WriteToServiceCharacteristicAsync($"sp{speedValue}#", serviceUuid, characteristicUuid);
// Start
await bluetoothLeService.WriteToServiceCharacteristicAsync("on#", serviceUuid, characteristicUuid);
}
public ConfigurationViewModel(IDialogService dialogService, IBluetoothLeService bluetoothLeService)
{
this.dialogService = dialogService;
this.bluetoothLeService = bluetoothLeService;
exposureTimeOptions = new ObservableCollection <ExposureTime>(ExposureTime.Times);
directionOptions = new ObservableCollection <SliderDirection>(Enum.GetValues(typeof(SliderDirection)).Cast <SliderDirection>());
// Set defaults
exposureTime = exposureTimeOptions.FirstOrDefault(e => e.Milliseconds == 8);
direction = directionOptions.FirstOrDefault();
totalSteps = 10000;
numberOfShots = 10;
Interval = 5;
}
internal BaseSlider(string label, TValueType start, TValueType end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = 0f)
{
this.< clamped > k__BackingField = true;
base..ctor(label, null);
base.AddToClassList(BaseSlider <TValueType> .ussClassName);
base.labelElement.AddToClassList(BaseSlider <TValueType> .labelUssClassName);
base.visualInput.AddToClassList(BaseSlider <TValueType> .inputUssClassName);
this.direction = direction;
this.pageSize = pageSize;
this.lowValue = start;
this.highValue = end;
base.pickingMode = PickingMode.Ignore;
base.visualInput.pickingMode = PickingMode.Position;
this.dragContainer = new VisualElement
{
name = "unity-drag-container"
};
this.dragContainer.AddToClassList(BaseSlider <TValueType> .dragContainerUssClassName);
base.visualInput.Add(this.dragContainer);
VisualElement visualElement = new VisualElement
{
name = "unity-tracker"
};
visualElement.AddToClassList(BaseSlider <TValueType> .trackerUssClassName);
this.dragContainer.Add(visualElement);
this.dragBorderElement = new VisualElement
{
name = "unity-dragger-border"
};
this.dragBorderElement.AddToClassList(BaseSlider <TValueType> .draggerBorderUssClassName);
this.dragContainer.Add(this.dragBorderElement);
this.dragElement = new VisualElement
{
name = "unity-dragger"
};
this.dragElement.RegisterCallback <GeometryChangedEvent>(new EventCallback <GeometryChangedEvent>(this.UpdateDragElementPosition), TrickleDown.NoTrickleDown);
this.dragElement.AddToClassList(BaseSlider <TValueType> .draggerUssClassName);
this.dragContainer.Add(this.dragElement);
this.clampedDragger = new ClampedDragger <TValueType>(this, new Action(this.SetSliderValueFromClick), new Action(this.SetSliderValueFromDrag));
base.visualInput.AddManipulator(this.clampedDragger);
base.RegisterCallback <KeyDownEvent>(new EventCallback <KeyDownEvent>(this.OnKeyDown), TrickleDown.NoTrickleDown);
this.UpdateTextFieldVisibility();
}
public void ChangeImage(SliderDirection direction)
{
switch (direction)
{
case SliderDirection.Left:
this.LeftButton.Click();
Reporter.LogPassingTestStepForBuglLogger($"Slide to the {direction}");
break;
case SliderDirection.Right:
this.RightButton.Click();
Reporter.LogPassingTestStepForBuglLogger($"Slide to the {direction}");
break;
default:
Reporter.LogTestStepForBugLogger(Status.Fail, "Unable to change the slide. Invalid direction.");
throw new InvalidOperationException("Invalid slider change direction");
}
}
public BaseSlider(T start, T end, SliderDirection direction, float pageSize = kDefaultPageSize)
{
this.direction = direction;
this.pageSize = pageSize;
lowValue = start;
highValue = end;
Add(new VisualElement()
{
name = "TrackElement"
});
dragElement = new VisualElement()
{
name = "DragElement"
};
dragElement.RegisterCallback <GeometryChangedEvent>(UpdateDragElementPosition);
Add(dragElement);
clampedDragger = new ClampedDragger <T>(this, SetSliderValueFromClick, SetSliderValueFromDrag);
this.AddManipulator(clampedDragger);
}
static float GetNormalizedValueFromCoords(SliderDirection sliderDirection, float3 inputPos, float2 lowLeft, float2 uppRight)
{
float inputPosSingleAxis;
float lowerBoundSingleAxis;
float upperBoundSingleAxis;
switch (sliderDirection)
{
case SliderDirection.LeftToRight:
inputPosSingleAxis = inputPos.x;
lowerBoundSingleAxis = lowLeft.x;
upperBoundSingleAxis = uppRight.x;
return(math.clamp((inputPosSingleAxis - lowerBoundSingleAxis) / (upperBoundSingleAxis - lowerBoundSingleAxis), 0f, 1f));
case SliderDirection.RightToLeft:
inputPosSingleAxis = inputPos.x;
lowerBoundSingleAxis = lowLeft.x;
upperBoundSingleAxis = uppRight.x;
return(1 - math.clamp((inputPosSingleAxis - lowerBoundSingleAxis) / (upperBoundSingleAxis - lowerBoundSingleAxis), 0f, 1f));
case SliderDirection.BottomToTop:
inputPosSingleAxis = inputPos.y;
lowerBoundSingleAxis = lowLeft.y;
upperBoundSingleAxis = uppRight.y;
return(math.clamp((inputPosSingleAxis - lowerBoundSingleAxis) / (upperBoundSingleAxis - lowerBoundSingleAxis), 0f, 1f));
case SliderDirection.TopToBottom:
inputPosSingleAxis = inputPos.y;
lowerBoundSingleAxis = lowLeft.y;
upperBoundSingleAxis = uppRight.y;
return(1 - math.clamp((inputPosSingleAxis - lowerBoundSingleAxis) / (upperBoundSingleAxis - lowerBoundSingleAxis), 0f, 1f));
default:
throw new ArgumentOutOfRangeException();
}
}
public Scroller(float lowValue, float highValue, System.Action <float> valueChanged, SliderDirection direction = SliderDirection.Vertical)
{
this.direction = direction;
this.valueChanged = valueChanged;
// Add children in correct order
slider = new Slider(lowValue, highValue, direction, kDefaultPageSize)
{
name = "Slider", persistenceKey = "Slider"
};
slider.OnValueChanged(OnSliderValueChange);
Add(slider);
lowButton = new ScrollerButton(ScrollPageUp, ScrollWaitDefinitions.firstWait, ScrollWaitDefinitions.regularWait)
{
name = "LowButton"
};
Add(lowButton);
highButton = new ScrollerButton(ScrollPageDown, ScrollWaitDefinitions.firstWait, ScrollWaitDefinitions.regularWait)
{
name = "HighButton"
};
Add(highButton);
}
public SliderInt(string label, int start = 0, int end = 10, SliderDirection direction = SliderDirection.Horizontal, float pageSize = 0f) : base(label, start, end, direction, pageSize)
{
base.AddToClassList(SliderInt.ussClassName);
base.labelElement.AddToClassList(SliderInt.labelUssClassName);
base.visualInput.AddToClassList(SliderInt.inputUssClassName);
}
public SliderInt(int start, int end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = 0f) : this(null, start, end, direction, pageSize)
{
}
public SliderInt(int start, int end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize) :
base(start, end, direction, pageSize)
{
}
/// <summary>
/// Constructor.
/// </summary>
public Slider(float start, float end, SliderDirection direction = SliderDirection.Horizontal, float pageSize = kDefaultPageSize)
: this(null, start, end, direction, pageSize)
{
}
static RectTransform FillRectTransformFromSlider(RectTransform rectTransform, float anchorVal, SliderDirection direction)
{
switch (direction)
{
case SliderDirection.LeftToRight:
rectTransform.AnchorMin = 0f;
rectTransform.AnchorMax = new float2(anchorVal, 1f);
break;
case SliderDirection.RightToLeft:
rectTransform.AnchorMin = new float2(1f - anchorVal, 0f);
rectTransform.AnchorMax = 1f;
break;
case SliderDirection.BottomToTop:
rectTransform.AnchorMin = 0f;
rectTransform.AnchorMax = new float2(1f, anchorVal);
break;
case SliderDirection.TopToBottom:
rectTransform.AnchorMin = new float2(0f, 1f - anchorVal);
rectTransform.AnchorMax = 1f;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(rectTransform);
}
