/*--------------------------------------------------------------------------------------------*/
public void OnRowSwitched(IItemDataSelectable pItemData)
{
HovercastRowSwitchingInfo switchInfo =
pItemData.gameObject.GetComponent <HovercastRowSwitchingInfo>();
if (switchInfo == null)
{
Debug.LogError("Selected item requires a '" +
typeof(HovercastRowSwitchingInfo).Name + "' component.", pItemData.gameObject);
return;
}
if (PreviousRow != null)
{
PreviousRow.gameObject.SetActive(false);
}
if (switchInfo.NavigateBack)
{
NavigateBack(switchInfo.RowEntryTransition);
}
else
{
NavigateToRow(switchInfo.NavigateToRow, switchInfo.RowEntryTransition);
}
}
/*--------------------------------------------------------------------------------------------*/
private void FillCursorLists()
{
for (int i = 0; i < vItems.Count; i++)
{
HoverItemData data = vItems[i].Data;
IItemDataSelectable selData = (IItemDataSelectable)data;
HoverItemHighlightState highState = data.GetComponent <HoverItemHighlightState>();
ICursorData cursorData = highState.NearestHighlight.Value.Cursor;
if (cursorData.Idle.Progress >= 1)
{
selData.DeselectStickySelections();
continue;
}
HoverItemSelectionState selState = data.GetComponent <HoverItemSelectionState>();
HoverRenderer rend = data.GetComponent <HoverItemRendererUpdater>().ActiveRenderer;
var info = new StickySelectionInfo {
ItemWorldPosition = rend.GetCenterWorldPosition(),
SelectionProgress = selState.SelectionProgress
};
cursorData.ActiveStickySelections.Add(info);
}
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateSelectionProgress()
{
HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
if (vSelectionStart == null)
{
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
if (selData == null || !selData.IsStickySelected)
{
SelectionProgress = 0;
return;
}
HoverItemHighlightState.Highlight?nearestHigh = highState.NearestHighlight;
float nearDist = highState.InteractionSettings.StickyReleaseDistance;
float minHighDist = (nearestHigh == null ? float.MaxValue : nearestHigh.Value.Distance);
SelectionProgress = Mathf.InverseLerp(nearDist, vDistanceUponSelection, minHighDist);
return;
}
float ms = (float)(DateTime.UtcNow - (DateTime)vSelectionStart).TotalMilliseconds;
SelectionProgress = Math.Min(1, ms / highState.InteractionSettings.SelectionMilliseconds);
}
/*--------------------------------------------------------------------------------------------*/
private bool UpdateState()
{
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
WasSelectedThisFrame = false;
if (selData == null)
{
return(false);
}
////
HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
bool canSelect = (
!highState.IsHighlightPrevented &&
highState.IsNearestAcrossAllItemsForAnyCursor &&
selData.AllowSelection
);
if (SelectionProgress <= 0 || !canSelect)
{
selData.DeselectStickySelections();
}
if (!canSelect || highState.MaxHighlightProgress < 1)
{
IsSelectionPrevented = false;
vSelectionStart = null;
return(false);
}
////
if (IsSelectionPrevented)
{
vSelectionStart = null;
return(false);
}
if (vSelectionStart == null)
{
vSelectionStart = DateTime.UtcNow;
return(false);
}
if (SelectionProgress < 1)
{
return(false);
}
vSelectionStart = null;
IsSelectionPrevented = true;
WasSelectedThisFrame = true;
vDistanceUponSelection = highState.NearestHighlight.Value.Distance;
selData.Select();
return(true);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void SetSplitMode(IItemDataSelectable <bool> pItemData)
{
bool isSplit = pItemData.Value;
HoverkeyMain.SetActive(!isSplit);
HoverkeySplit.SetActive(isSplit);
Hoverkey.RefreshKeyLists();
}
public void MakeHapticFeedbback(IItemDataSelectable itemdataSelectable, HoverkeyItemLabels labels)
{
//Debug.Log($"item select label: {itemdataSelectable.Label}");
Debug.Log($"label data: {labels.DefaultLabel}");
//todo determine hand.
haptic.Execute(0, .05f, 75, 25, SteamVR_Input_Sources.RightHand);
}
/*--------------------------------------------------------------------------------------------*/
public void SetFontSize(IItemDataSelectable <float> pItemData)
{
HoverCanvas[] canvases = GetComponentsInChildren <HoverCanvas>(true);
int size = Mathf.RoundToInt(((IItemDataSlider)pItemData).SnappedRangeValue);
foreach (HoverCanvas canvas in canvases)
{
canvas.Label.TextComponent.fontSize = size;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void TryResetSelection(HoverItemHighlightState pHighState,
IItemDataSelectable pSelData)
{
if (!pHighState.IsHighlightPrevented)
{
return;
}
vSelectionStart = null;
pSelData?.DeselectStickySelections();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void UpdateViaManager()
{
HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
TryResetSelection(highState, selData);
UpdateSelectionProgress(highState, selData);
UpdateNearestCursor(highState);
UpdateState(selData);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private bool FilterItems(HoverItem pItem)
{
IItemDataSelectable selData = (pItem.Data as IItemDataSelectable);
if (selData == null || !selData.IsStickySelected || !selData.AllowIdleDeselection)
{
return(false);
}
return(pItem.GetComponent <HoverItemHighlightState>().NearestHighlight != null);
}
/*--------------------------------------------------------------------------------------------*/
private void HandleRadioValueChanged(IItemDataSelectable <bool> pSelData)
{
IItemDataRadio radData = (IItemDataRadio)pSelData;
if (!radData.Value)
{
return;
}
DeselectRemainingRadioGroupMembers(radData);
}
/*--------------------------------------------------------------------------------------------*/
public void SetBgAlpha(IItemDataSelectable <float> pItemData)
{
float bgAlpha = ((IItemDataSlider)pItemData).SnappedRangeValue;
if (Math.Abs(bgAlpha - vCurrBgAlpha) < 2 / 255f)
{
return;
}
vCurrBgAlpha = bgAlpha;
SetTheme(vCurrTheme);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private IEnumerator UpdateForAutoFire(IItemDataSelectable pSelItem)
{
if (DelaySeconds != vPrevDelaySec)
{
vWaitForSec = new WaitForSeconds(DelaySeconds);
vPrevDelaySec = DelaySeconds;
}
yield return(vWaitForSec);
HoverItemData item = (HoverItemData)pSelItem;
item.GetComponent <HoverItemSelectionState>().ReleaseSelectionPrevention();
}
public void OnSliderRelease(IItemDataSelectable data)
{
//SlideNum = (int)Mathf.Round(data.Value);
if (SlideNum > Slides.Count)
{
SlideNum = Slides.Count;
}
if (SlideNum <= 0)
{
SlideNum = 0;
}
Activate();
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void UpdateIsHighlightPrevented()
{
HoverItem hoverItem = GetComponent <HoverItem>();
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
IsHighlightPrevented = (
selData == null ||
!itemData.IsEnabled ||
//!itemData.IsVisible ||
!itemData.IsAncestryEnabled ||
//!itemData.IsAncestryVisible ||
!hoverItem.gameObject.activeInHierarchy ||
IsHighlightPreventedViaAnyDisplay()
);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void HandleKeySelected(IItemDataSelectable pItemData, HoverkeyItemLabels pLabels)
{
if (pLabels.ActionType == HoverkeyItemLabels.KeyActionType.Character)
{
char letter = (Hoverkey.IsInShiftMode && pLabels.HasShiftLabel ?
pLabels.ShiftLabel[0] : pLabels.DefaultLabel[0]);
Enviro.AddLetter(letter);
return;
}
if (pLabels.DefaultKey == KeyCode.Backspace)
{
Enviro.RemoveLatestLetter();
return;
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void TryResetSelection()
{
if (!GetComponent <HoverItemHighlightState>().IsHighlightPrevented)
{
return;
}
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
vSelectionStart = null;
if (selData != null)
{
selData.DeselectStickySelections();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private void HandleKeySelected(IItemDataSelectable pItemData, HoverkeyItemLabels pLabels)
{
switch (pLabels.ActionType)
{
case HoverkeyItemLabels.KeyActionType.Character:
AddCharacter(pLabels);
break;
case HoverkeyItemLabels.KeyActionType.Control:
AddControl(pLabels);
break;
case HoverkeyItemLabels.KeyActionType.Navigation:
AddNavigation(pLabels);
break;
}
SendInputFieldEvent(pLabels);
}
/*--------------------------------------------------------------------------------------------*/
private void UpdateSelectionProgress(HoverItemHighlightState pHighState,
IItemDataSelectable pSelData)
{
if (vSelectionStart == null)
{
if (pSelData == null || !pSelData.IsStickySelected)
{
SelectionProgress = 0;
return;
}
HoverItemHighlightState.Highlight?nearestHigh = pHighState.NearestHighlight;
float nearDist = pHighState.InteractionSettings.StickyReleaseDistance;
float minHighDist = nearestHigh?.Distance ?? float.MaxValue;
SelectionProgress = Mathf.InverseLerp(nearDist, vDistanceUponSelection, minHighDist);
return;
}
float ms = (float)(DateTime.UtcNow - (DateTime)vSelectionStart).TotalMilliseconds;
SelectionProgress = Math.Min(1, ms / pHighState.InteractionSettings.SelectionMilliseconds);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
private HoverkeyItemLabels GetLabels(IItemDataSelectable pItemData)
{
return(pItemData.gameObject.GetComponent <HoverkeyItemLabels>());
}
/*--------------------------------------------------------------------------------------------*/
public void HandleItemValueChanged(IItemDataSelectable <bool> pItemData)
{
OnItemToggledEvent.Invoke(pItemData, GetLabels(pItemData));
}
/*--------------------------------------------------------------------------------------------*/
public void HandleItemDeselected(IItemDataSelectable pItemData)
{
OnItemDeselectedEvent.Invoke(pItemData, GetLabels(pItemData));
}
/*--------------------------------------------------------------------------------------------*/
private bool UpdateState()
{
HoverItemData itemData = GetComponent <HoverItem>().Data;
IItemDataSelectable selData = (itemData as IItemDataSelectable);
WasSelectedThisFrame = false;
if (selData == null || selData.IgnoreSelection)
{
return(false);
}
////
HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>();
bool hasNearestCursorWithFullHigh = false;
bool canDeselect = (
highState.IsHighlightPrevented ||
!highState.IsNearestAcrossAllItemsForAnyCursor ||
!selData.IsEnabled
);
for (int i = 0; i < highState.Highlights.Count; i++)
{
HoverItemHighlightState.Highlight high = highState.Highlights[i];
if (high.IsNearestAcrossAllItems && high.Progress >= 1)
{
hasNearestCursorWithFullHigh = true;
break;
}
}
if (SelectionProgress <= 0 || canDeselect)
{
selData.DeselectStickySelections();
}
if (canDeselect || !hasNearestCursorWithFullHigh)
{
IsSelectionPrevented = false;
vSelectionStart = null;
return(false);
}
////
if (IsSelectionPrevented)
{
vSelectionStart = null;
return(false);
}
if (vSelectionStart == null)
{
vSelectionStart = DateTime.UtcNow;
return(false);
}
if (SelectionProgress < 1)
{
return(false);
}
vSelectionStart = null;
IsSelectionPrevented = true;
WasSelectedThisFrame = true;
vDistanceUponSelection = highState.NearestHighlight.Value.Distance;
selData.Select();
return(true);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void EnableWithBoolValue(IItemDataSelectable <bool> pItemData)
{
GetComponent <HoverItemData>().IsEnabled = pItemData.Value;
}
/*--------------------------------------------------------------------------------------------*/
public void SetAllowThumb(IItemDataSelectable <bool> pItemData)
{
vAllowThumb = pItemData.Value;
UpdateCursorCapabilities();
}
/*--------------------------------------------------------------------------------------------*/
public void SetLightingPower(IItemDataSelectable <float> pItemData)
{
Enviro.SetLightIntensitiy(((IItemDataSlider)pItemData).RangeValue);
}
/*--------------------------------------------------------------------------------------------*/
public void SetLightingSpotlight(IItemDataSelectable pItemData)
{
Enviro.ShowSpotlight(pItemData.IsStickySelected);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public void OnOpenToggled(IItemDataSelectable pItemData)
{
IsOpen = !IsOpen;
OnOpenToggledEvent.Invoke();
}
/*--------------------------------------------------------------------------------------------*/
public void SetFastSelect(IItemDataSelectable <bool> pItemData)
{
InteractionSettings.SelectionMilliseconds = (pItemData.Value ? 200 : 400);
}
/*--------------------------------------------------------------------------------------------*/
public void HideWithBoolValue(IItemDataSelectable <bool> pItemData)
{
GetComponent <HoverItemData>().gameObject.SetActive(!pItemData.Value);
}
