/*--------------------------------------------------------------------------------------------*/ public void SetItemActiveState(HoverItem pItem, bool pIsActive) { if (vItemsActive == null) { return; } bool wasActive = vItemsActive.Contains(pItem); if (pIsActive == wasActive) { return; } if (pIsActive) { vItemsActive.Add(pItem); } else { vItemsActive.Remove(pItem); } //Debug.Log(Time.frameCount+" | SetItemActiveState: "+pIsActive+" / "+vItemsActive.Count); }
// Use this for initialization void Awake() { InvManager = FindObjectOfType(typeof(InventoryManager)) as InventoryManager; InvUI = FindObjectOfType(typeof(InventoryUI)) as InventoryUI; ItemInfo = FindObjectOfType(typeof(HoverItem)) as HoverItem; InvEq = FindObjectOfType(typeof(Equipment)) as Equipment; if (InvManager.PickupType == InventoryManager.PickupTypes.Mouse) { PickupTypeText.text = "Item pick up type: <color=red>Mouse</color>.\n(<color=red>P</color> to swtich to keyboard)."; } else if (InvManager.PickupType == InventoryManager.PickupTypes.Keyboard) { PickupTypeText.text = "Item pick up type: <color=red>E key</color>.\n(<color=red>P</color> to swtich to mouse)."; } if (InvManager.DropType == InventoryManager.DropTypes.Spawn) { DropTypeText.text = "Item drop type: <color=red>Spawn items</color>.\n(<color=red>L</color> to swtich)."; } else if (InvManager.DropType == InventoryManager.DropTypes.Destroy) { DropTypeText.text = "Item drop type: <color=red>Destroy items</color>.\n(<color=red>L</color> to swtich)."; } }
/*--------------------------------------------------------------------------------------------*/ public virtual void TreeUpdate() { HoverItem hoverItem = GetComponent <HoverItem>(); DestroyRenderersIfNecessary(); TryRebuildWithItemType(hoverItem.ItemType); //// HoverItemHighlightState highState = GetComponent <HoverItemHighlightState>(); HoverItemSelectionState selState = GetComponent <HoverItemSelectionState>(); HoverRenderer activeRenderer = ((HoverRenderer)ButtonRenderer ?? SliderRenderer); UpdateRenderer(activeRenderer, hoverItem); UpdateRendererCanvas(activeRenderer, hoverItem); UpdateRendererIndicator(activeRenderer, highState, selState); if (ButtonRenderer != null) { UpdateButtonSettings(highState); } if (SliderRenderer != null) { UpdateSliderSettings(hoverItem); UpdateSliderSettings(hoverItem, highState); } Controllers.TryExpireControllers(); }
/*--------------------------------------------------------------------------------------------* / * public void RemoveDestroyedItems() { * if ( vItems == null ) { * return; * } * * for ( int i = 0 ; i < vItems.Count ; i++ ) { * if ( vItems[i] == null ) { * Debug.LogWarning("Removing destroyed item @ "+i); * vItems.RemoveAt(i); * i--; * } * } * } * * * //////////////////////////////////////////////////////////////////////////////////////////////// * /*--------------------------------------------------------------------------------------------*/ public void FillListWithActiveItemComponents <T>(IList <T> pComponents) where T : Component { pComponents.Clear(); if (vItemsActive == null) { return; } int itemCount = vItemsActive.Count; for (int i = 0; i < itemCount; i++) { HoverItem item = vItemsActive[i]; if (item == null) { continue; } T comp = item.GetComponent <T>(); if (comp != null) { pComponents.Add(comp); } } }
void SetHoveredItem(int index) { if (hoveredItem != -1) { int realIndex = scrollOffset + hoveredItem; SetTextHovered(itemTexts[hoveredItem], false, items[realIndex].Value != null, items[realIndex].Key); } if (hoveredItem != index) { HoverItem?.Invoke(scrollOffset + index); } hoveredItem = index; if (hoveredItem != -1) { int realIndex = scrollOffset + hoveredItem; bool enabled = items[realIndex].Value != null; SetTextHovered(itemTexts[hoveredItem], true, enabled, items[realIndex].Key); hoverBox.Y = itemAreas[index].Y + relativeHoverBoxOffset.Y; hoverBox.Visible = enabled; if (hoverBox.Visible) { hoverBox.Color = game.GetTextColor(colorProvider?.Invoke(items[realIndex].Key) ?? TextColor.Bright); } } else { hoverBox.Visible = false; } }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ private void AddRadioDataListeners(HoverItem pItem) { IRadioItemData radData = (pItem.Data as IRadioItemData); if ( radData != null ) { radData.OnValueChanged += HandleRadioValueChanged; } }
/*--------------------------------------------------------------------------------------------*/ private void RemoveRadioDataListeners(HoverItem pItem) { IItemDataRadio radData = (pItem.Data as IItemDataRadio); if (radData != null) { radData.OnValueChanged -= HandleRadioValueChanged; } }
/*--------------------------------------------------------------------------------------------*/ private void UpdateRendererCanvas(HoverRenderer pRenderer, HoverItem pHoverItem) { HoverCanvasDataUpdater canvasUp = pRenderer.GetCanvasDataUpdater(); if (canvasUp == null) { return; } IItemData data = pHoverItem.Data; IItemDataCheckbox checkboxData = (data as IItemDataCheckbox); IItemDataRadio radioData = (data as IItemDataRadio); IItemDataSelector selectorData = (data as IItemDataSelector); IItemDataSticky stickyData = (data as IItemDataSticky); IItemDataSlider sliderData = (data as IItemDataSlider); var icon = HoverCanvasDataUpdater.IconPairType.Unspecified; if (checkboxData != null) { icon = (checkboxData.Value ? HoverCanvasDataUpdater.IconPairType.CheckboxOn : HoverCanvasDataUpdater.IconPairType.CheckboxOff); } else if (radioData != null) { icon = (radioData.Value ? HoverCanvasDataUpdater.IconPairType.RadioOn : HoverCanvasDataUpdater.IconPairType.RadioOff); } else if (selectorData != null) { if (selectorData.Action == SelectorActionType.NavigateIn) { icon = HoverCanvasDataUpdater.IconPairType.NavigateIn; } else if (selectorData.Action == SelectorActionType.NavigateOut) { icon = HoverCanvasDataUpdater.IconPairType.NavigateOut; } } else if (stickyData != null) { icon = HoverCanvasDataUpdater.IconPairType.Sticky; } else if (sliderData != null) { icon = HoverCanvasDataUpdater.IconPairType.Slider; } canvasUp.Controllers.Set(HoverCanvasDataUpdater.LabelTextName, this); canvasUp.Controllers.Set(HoverCanvasDataUpdater.IconTypeName, this); canvasUp.LabelText = (sliderData == null ? data.Label : sliderData.GetFormattedLabel(sliderData)); canvasUp.IconType = icon; }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ 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); }
void Awake() { InvUI = FindObjectOfType(typeof(InventoryUI)) as InventoryUI; VendorPanel = FindObjectOfType(typeof(VendorUI)) as VendorUI; SkillBarPanel = FindObjectOfType(typeof(SkillBarUI)) as SkillBarUI; EquipmentPanel = FindObjectOfType(typeof(EquipmentUI)) as EquipmentUI; InvContainer = FindObjectOfType(typeof(ContainerUI)) as ContainerUI; InvCraft = FindObjectOfType(typeof(CraftUI)) as CraftUI; InvItemGroup = FindObjectOfType(typeof(ItemGroupUI)) as ItemGroupUI; HoverScript = FindObjectOfType(typeof(HoverItem)) as HoverItem; }
/*--------------------------------------------------------------------------------------------*/ public void RemoveItem(HoverItem pItem) { if (vItems == null) { return; } if (!vItems.Remove(pItem)) { Debug.LogWarning("Cannot remove missing item '" + pItem.name + "'.", pItem); return; } OnItemRemoved.Invoke(pItem); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public void AddItem(HoverItem pItem) { if (vItems == null) { return; } if (vItems.Contains(pItem)) { Debug.LogWarning("Cannot add duplicate item '" + pItem.name + "'.", pItem); return; } vItems.Add(pItem); OnItemAdded.Invoke(pItem); }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ private void UpdateSliderSettings(HoverItem pHoverItem) { IItemDataSlider data = (IItemDataSlider)pHoverItem.Data; SliderRenderer.Controllers.Set(HoverRendererSlider.HandleValueName, this); SliderRenderer.Controllers.Set(HoverRendererSlider.FillStartingPointName, this); SliderRenderer.Controllers.Set(HoverRendererSlider.ZeroValueName, this); SliderRenderer.Controllers.Set(HoverRendererSlider.AllowJumpName, this); SliderRenderer.Controllers.Set(HoverRendererSlider.TickCountName, this); SliderRenderer.HandleValue = data.SnappedValue; SliderRenderer.FillStartingPoint = data.FillStartingPoint; SliderRenderer.ZeroValue = Mathf.InverseLerp(data.RangeMin, data.RangeMax, 0); SliderRenderer.AllowJump = data.AllowJump; SliderRenderer.TickCount = data.Ticks; }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ 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() ); }
private bool IsHoverPartOfPopup() { if (PopupItem == null || HoverItem == null) { return(false); } if (Object.ReferenceEquals(PopupItem, HoverItem)) { return(true); } if (HoverItem.IsChildOf(PopupItem)) { return(true); } return(false); }
public void DragEnded() { if (IsMovable == true) { Dragging = false; PanelDragPos.gameObject.SetActive(false); Panel.transform.SetParent(UICanvas.transform, true); ActionMenu.transform.SetParent(Panel.transform, true); DropMenu.transform.SetParent(Panel.transform, true); HoverItem ItemInfo = FindObjectOfType(typeof(HoverItem)) as HoverItem; ItemInfo.ItemInfo.transform.SetParent(Panel.transform, true); ActionMenu.transform.SetParent(UICanvas.transform, true); DropMenu.transform.SetParent(UICanvas.transform, true); ItemInfo.ItemInfo.transform.SetParent(UICanvas.transform, true); } }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ public void Start() { vItems = Resources.FindObjectsOfTypeAll <HoverItem>().ToList(); vItemsActive = new List <HoverItem>(); for (int i = 0; i < vItems.Count; i++) { HoverItem item = vItems[i]; if (!item.isActiveAndEnabled || !item.gameObject.activeInHierarchy) { continue; } vItemsActive.Add(item); } OnItemListInitialized.Invoke(); }
private bool IsHoverPartOfPopup() { if (PopupStack.Count == 0 || HoverItem == null) { return(false); } var item = PopupStack[PopupStack.Count - 1]; if (Object.ReferenceEquals(item, HoverItem)) { return(true); } if (HoverItem.IsChildOf(item)) { return(true); } return(false); }
/*--------------------------------------------------------------------------------------------*/ public void FillListWithMatchingItems(IList <HoverItem> pMatches, Func <HoverItem, bool> pFilterFunc) { pMatches.Clear(); if (vItems == null) { return; } for (int i = 0; i < vItems.Count; i++) { HoverItem item = vItems[i]; if (pFilterFunc(item)) { pMatches.Add(item); } } }
public void GenerateServiceUI(List <Services> scannedServices) { if (scannedServices == null) { Debug.Log("Stuff broke, merp."); return; } scanningMessage.gameObject.SetActive(false); // dispose items CleanUpListItem(); // create new list foreach (var s in scannedServices) { HoverItem h = GameObject.Instantiate(serviceListTemplate, rootNode); h.Data.Label = $"{s.name} :{s.portNum.ToString()}"; h.gameObject.SetActive(true); trackedHoverItems.Add(h); } }
/*--------------------------------------------------------------------------------------------*/ private void UpdateSliderSettings(HoverItem pHoverItem, HoverItemHighlightState pHighState) { HoverItemDataSlider data = (HoverItemDataSlider)pHoverItem.Data; HoverItemHighlightState.Highlight?high = pHighState.NearestHighlight; float highProg = pHighState.MaxHighlightProgress; bool isNearest = pHighState.IsNearestAcrossAllItemsForAnyCursor; SliderRenderer.Controllers.Set(HoverRendererSlider.JumpValueName, this); SliderRenderer.Controllers.Set(HoverRendererSlider.ShowButtonEdgesName, this); SliderRenderer.ShowButtonEdges = (isNearest && highProg > 0); if (high == null || highProg <= 0 || !isNearest) { data.HoverValue = null; SliderRenderer.JumpValue = -1; return; } float value = SliderRenderer.GetValueViaNearestWorldPosition(high.Value.NearestWorldPos); data.HoverValue = value; float snapValue = (float)data.SnappedHoverValue; //float easePower = (1-high.Value.Progress)*5+1; //gets "snappier" as you pull away float showValue = DisplayUtil.GetEasedValue(data.Snaps, value, snapValue, 3); SliderRenderer.JumpValue = showValue; if (data.IsStickySelected) { data.Value = value; SliderRenderer.Controllers.Set(HoverRendererSlider.HandleValueName, this); SliderRenderer.HandleValue = showValue; } }
/*--------------------------------------------------------------------------------------------*/ public void FillListWithMatchingItems(IList <HoverItem> pMatches, bool pActiveOnly, Func <HoverItem, bool> pFilterFunc) { pMatches.Clear(); List <HoverItem> items = (pActiveOnly ? vItemsActive : vItems); if (items == null) { return; } int itemCount = items.Count; for (int i = 0; i < itemCount; i++) { HoverItem item = items[i]; if (pFilterFunc(item)) { pMatches.Add(item); } } }
//////////////////////////////////////////////////////////////////////////////////////////////// /*--------------------------------------------------------------------------------------------*/ private void UpdateRenderer(HoverRenderer pRenderer, HoverItem pHoverItem) { pRenderer.Controllers.Set(HoverRenderer.IsEnabledName, this); pRenderer.IsEnabled = pHoverItem.Data.IsEnabled; }
/*--------------------------------------------------------------------------------------------*/ private void RemoveItemListeners(HoverItem pItem) { pItem.OnTypeChanged -= AddRadioDataListeners; RemoveRadioDataListeners(pItem); }
/*--------------------------------------------------------------------------------------------*/ private void AddItemListeners(HoverItem pItem) { AddRadioDataListeners(pItem); pItem.OnTypeChanged += AddRadioDataListeners; }
/*--------------------------------------------------------------------------------------------*/ private void RemoveRadioDataListeners(HoverItem pItem) { IRadioItem radData = (pItem.Data as IRadioItem); if ( radData != null ) { radData.OnValueChanged -= HandleRadioValueChanged; } }
/// <summary> /// Process mouse events. /// </summary> /// <param name="State"></param> public void HandleInput(InputEvents Event, InputEventArgs Args) { switch (Event) { case InputEvents.MouseMove: { // Destroy tooltips when the mouse moves. MouseMotionTime = DateTime.Now; if (TooltipItem != null) { DestroyWidget(TooltipItem); } MousePosition = ScreenPointToGuiPoint(new Point(Args.X, Args.Y)); var newArgs = new InputEventArgs { X = MousePosition.X, Y = MousePosition.Y }; // Detect hover item and fire mouse enter/leave events as appropriate. var newHoverItem = RootItem.FindWidgetAt(MousePosition.X, MousePosition.Y); if (!Object.ReferenceEquals(newHoverItem, HoverItem)) { if (HoverItem != null) { SafeCall(HoverItem.OnMouseLeave, HoverItem, newArgs); } if (newHoverItem != null) { SafeCall(newHoverItem.OnMouseEnter, newHoverItem, newArgs); } HoverItem = newHoverItem; } if (MouseDownItem != null) { SafeCall(MouseDownItem.OnMouseMove, MouseDownItem, new InputEventArgs { X = MousePosition.X, Y = MousePosition.Y }); } } break; case InputEvents.MouseDown: { MousePosition = ScreenPointToGuiPoint(new Point(Args.X, Args.Y)); var newArgs = new InputEventArgs { X = MousePosition.X, Y = MousePosition.Y }; MouseDownItem = null; if (PopupItem != null) { if (IsHoverPartOfPopup()) { MouseDownItem = HoverItem; } } else { MouseDownItem = HoverItem; } } break; case InputEvents.MouseUp: //MouseDownItem = null; break; case InputEvents.MouseClick: { MousePosition = ScreenPointToGuiPoint(new Point(Args.X, Args.Y)); var newArgs = new InputEventArgs { X = MousePosition.X, Y = MousePosition.Y }; if (PopupItem != null) { if (HoverItem == null || (!Object.ReferenceEquals(HoverItem, PopupItem) && !HoverItem.IsChildOf(PopupItem))) { if (DestroyPopupOnOffClick) { SafeCall(PopupItem.OnPopupClose, PopupItem); DestroyWidget(PopupItem); PopupItem = null; } MouseDownItem = null; return; } if (HoverItem != null && (Object.ReferenceEquals(HoverItem, PopupItem) || HoverItem.IsChildOf(PopupItem))) { Args.Handled = true; if (Object.ReferenceEquals(HoverItem, MouseDownItem)) { CallOnClick(HoverItem, newArgs); } MouseDownItem = null; return; } MouseDownItem = null; return; } if (HoverItem != null && Object.ReferenceEquals(HoverItem, MouseDownItem)) { Args.Handled = true; CallOnClick(HoverItem, newArgs); } MouseDownItem = null; } break; case InputEvents.KeyPress: if (FocusItem != null) { SafeCall(FocusItem.OnKeyPress, FocusItem, Args); } break; case InputEvents.KeyDown: if (FocusItem != null) { SafeCall(FocusItem.OnKeyDown, FocusItem, Args); } break; case InputEvents.KeyUp: if (FocusItem != null) { SafeCall(FocusItem.OnKeyUp, FocusItem, Args); } break; } }