/*--------------------------------------------------------------------------------------------*/
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;
}
}
/*--------------------------------------------------------------------------------------------*/
private void RemoveItemListeners(HoverItem pItem)
{
pItem.OnTypeChanged -= AddRadioDataListeners;
RemoveRadioDataListeners(pItem);
}
/// <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;
}
}
/*--------------------------------------------------------------------------------------------*/
private void AddItemListeners(HoverItem pItem)
{
AddRadioDataListeners(pItem);
pItem.OnTypeChanged += AddRadioDataListeners;
}
