private static Vector3 GetPosition(Rect target, TooltipPosition position)
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
switch (position)
{
case TooltipPosition.Top:
return(Vector2.op_Implicit(new Vector2(target.get_x() + target.get_width() * 0.5f, target.get_yMax())));
case TooltipPosition.Bottom:
return(Vector2.op_Implicit(new Vector2(target.get_x() + target.get_width() * 0.5f, target.get_yMin())));
case TooltipPosition.Left:
return(Vector2.op_Implicit(new Vector2(target.get_xMin(), target.get_y() + target.get_height() * 0.5f)));
case TooltipPosition.Right:
return(Vector2.op_Implicit(new Vector2(target.get_xMax(), target.get_y() + target.get_height() * 0.5f)));
default:
throw new ArgumentOutOfRangeException("position", position, null);
}
}
/// <summary>
/// Returns the left, top coordinate of the tooltip based on the found points, the position and the tooltip size.
/// </summary>
/// <param name="foundPoints"></param>
/// <param name="position"></param>
/// <param name="tooltipSize"></param>
/// <returns></returns>
public static PointF?GetCartesianTooltipLocation(
this IEnumerable <TooltipPoint> foundPoints, TooltipPosition position, SizeF tooltipSize)
{
var count = 0f;
var placementContext = new TooltipPlacementContext();
foreach (var point in foundPoints)
{
if (point.Point.Context.HoverArea == null)
{
continue;
}
point.Point.Context.HoverArea.SuggestTooltipPlacement(placementContext);
count++;
}
if (count == 0)
{
return(null);
}
var avrgX = (placementContext.MostRight + placementContext.MostLeft) / 2f - tooltipSize.Width * 0.5f;
var avrgY = (placementContext.MostTop + placementContext.MostBottom) / 2f - tooltipSize.Height * 0.5f;
return(position switch
{
TooltipPosition.Top => new PointF(avrgX, placementContext.MostTop - tooltipSize.Height),
TooltipPosition.Bottom => new PointF(avrgX, placementContext.MostBottom),
TooltipPosition.Left => new PointF(placementContext.MostLeft - tooltipSize.Width, avrgY),
TooltipPosition.Right => new PointF(placementContext.MostRight, avrgY),
TooltipPosition.Center => new PointF(avrgX, avrgY),
TooltipPosition.Hidden => new PointF(),
_ => new PointF(),
});
protected Vector2 GetPivotForPosition(TooltipPosition position)
{
Vector2 pivot = new Vector2(0.5f, 0.5f);
switch (position)
{
case TooltipPosition.Above:
pivot = new Vector2(0.5f, 0);
break;
case TooltipPosition.Below:
pivot = new Vector2(0.5f, 1);
break;
case TooltipPosition.Left:
pivot = new Vector2(1, 0.5f);
break;
case TooltipPosition.Right:
pivot = new Vector2(0, 0.5f);
break;
}
return(pivot);
}
public void Show(RectTransform onRect, TooltipPosition position = TooltipPosition.TOP, float usedOffset = 10f)
{
currentPositioning = position;
// Debug.Log ("showing on " + onRect.transform.position);
//Set position to rect
StartCoroutine(DelaySetPosition(onRect, usedOffset));
}
public static void ShowTooltip(ITooltipDataProvider tooltipDataProvider, TooltipPosition position, RectTransform rectTransform)
{
FightTooltip fightTooltip = GetFightTooltip();
if (fightTooltip != null)
{
fightTooltip.Initialize(tooltipDataProvider);
fightTooltip.ShowAt(position, rectTransform);
}
}
public void LoadAttributes(AttributeDictionary attributes)
{
if (attributes.ContainsKey("tooltipTextColor"))
{
SetTextColor(attributes["tooltipTextColor"].ToColor());
}
if (attributes.ContainsKey("tooltipBackgroundColor"))
{
SetBackgroundColor(attributes["tooltipBackgroundColor"].ToColor());
}
if (attributes.ContainsKey("tooltipBorderColor"))
{
SetBorderColor(attributes["tooltipBorderColor"].ToColor());
}
if (attributes.ContainsKey("tooltipBackgroundImage"))
{
SetBackgroundImage(attributes["tooltipBackgroundImage"].ToSprite());
}
if (attributes.ContainsKey("tooltipBorderImage"))
{
SetBorderImage(attributes["tooltipBorderImage"].ToSprite());
}
if (attributes.ContainsKey("tooltipFontSize"))
{
SetFontSize(int.Parse(attributes["tooltipfontsize"]));
}
if (attributes.ContainsKey("tooltipPadding"))
{
SetTooltipPadding(attributes["tooltipPadding"].ToRectOffset());
}
if (attributes.ContainsKey("tooltipTextOutlineColor"))
{
SetTextOutlineColor(attributes["tooltipTextOutlineColor"].ToColor());
}
if (attributes.ContainsKey("tooltipFont"))
{
SetFont(attributes["tooltipFont"].ToFont());
}
if (attributes.ContainsKey("tooltipPosition"))
{
tooltipPosition = (TooltipPosition)Enum.Parse(typeof(TooltipPosition), attributes["tooltipPosition"]);
}
if (attributes.ContainsKey("tooltipFollowMouse"))
{
followMouse = attributes["tooltipFollowMouse"].ToBoolean();
}
if (attributes.ContainsKey("tooltipOffset"))
{
offsetDistance = float.Parse(attributes["tooltipOffset"]);
}
}
public static void ShowTooltip(ITooltipDataProvider tooltipDataProvider, TooltipPosition position, Vector3 worldPosition)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
FightTooltip fightTooltip = GetFightTooltip();
if (fightTooltip != null)
{
fightTooltip.Initialize(tooltipDataProvider);
fightTooltip.ShowAt(position, worldPosition);
}
}
public void ShowTooltip(string text, TooltipPosition position)
{
Vector3 pos;
RectTransformUtility.ScreenPointToWorldPointInRectangle(canvas.transform as RectTransform, new Vector2(-Screen.width, 0), canvas.worldCamera, out pos);
transform.position = pos;
tooltipText.text = text;
gameObject.SetActive(true);
transform.SetAsLastSibling();
StartCoroutine(set_position_in_bounds(position));
}
protected Vector2 GetTooltipOffset(XmlElement element, TooltipPosition position, float tooltipOffsetDistance)
{
float desiredXChange = 0, desiredYChange = 0;
Vector3[] elementCorners = new Vector3[4], tooltipCorners = new Vector3[4];
((RectTransform)element.rectTransform).GetWorldCorners(elementCorners);
rectTransform.GetWorldCorners(tooltipCorners);
switch (position)
{
case TooltipPosition.Above:
{
// distance from the element's bottom edge to the parent's top edge
var parentTopEdge = elementCorners[2].y;
var elementBottomEdge = tooltipCorners[0].y;
desiredYChange = parentTopEdge - elementBottomEdge + tooltipOffsetDistance;
}
break;
case TooltipPosition.Below:
{
// distance from the element's top edge to the parent's bottom edge
var parentBottomEdge = elementCorners[3].y;
var elementTopEdge = tooltipCorners[1].y;
desiredYChange = parentBottomEdge - elementTopEdge - tooltipOffsetDistance;
}
break;
case TooltipPosition.Left:
{
// distance from the element's right edge to the parent's left edge
var parentLeftEdge = elementCorners[0].x;
var elementRightEdge = tooltipCorners[3].x;
desiredXChange = parentLeftEdge - elementRightEdge - tooltipOffsetDistance;
}
break;
case TooltipPosition.Right:
{
// distance from the element's left edge to the parent's right edge
var parentRightEdge = elementCorners[3].x;
var elementLeftEdge = tooltipCorners[0].x;
desiredXChange = parentRightEdge - elementLeftEdge + tooltipOffsetDistance;
}
break;
}
return(new Vector2(desiredXChange, desiredYChange));
}
public unsafe void ShowAt(TooltipPosition position, Vector3 worldPosition)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
_003F val = this.get_transform();
Vector3 lossyScale = val.get_lossyScale();
val.set_pivot(GetPivotFor(position));
RectTransform transform = val.get_root();
Rect val2 = RectTransformToScreenSpace(val, worldPosition);
Rect rect = RectTransformToScreenSpace(transform);
Enlarge(ref rect, -10f * ((IntPtr)(void *)lossyScale).x, -10f * ((IntPtr)(void *)lossyScale).y);
float num = rect.get_xMax() - val2.get_xMax();
float num2 = val2.get_xMin() - rect.get_xMin();
float num3 = rect.get_yMax() - val2.get_yMax();
float num4 = val2.get_yMin() - rect.get_yMin();
m_borderDistanceToScreen = new RectOffset(num2, num, num3, num4);
if (num < 0f)
{
worldPosition.x += num;
}
if (num2 < 0f)
{
worldPosition.x -= num2;
}
if (num3 < 0f)
{
worldPosition.y += num3;
}
if (num4 < 0f)
{
worldPosition.y -= num4;
}
DisplayTooltip(worldPosition);
}
/// <summary>
/// Returns the left, top coordinate of the tooltip based on the found points, the position and the tooltip size.
/// </summary>
/// <param name="foundPoints"></param>
/// <param name="position"></param>
/// <param name="tooltipSize"></param>
/// <returns></returns>
public static PointF?GetTooltipLocation <TDrawingContext>(
this IEnumerable <FoundPoint <TDrawingContext> > foundPoints,
TooltipPosition position,
SizeF tooltipSize)
where TDrawingContext : DrawingContext
{
float count = 0f, mostTop = float.MaxValue, mostBottom = float.MinValue, mostRight = float.MinValue, mostLeft = float.MaxValue;
foreach (var point in foundPoints)
{
var ha = point.Coordinate.HoverArea;
if (ha.Y < mostTop)
{
mostTop = ha.Y;
}
if (ha.Y + ha.Height > mostBottom)
{
mostBottom = ha.Y + ha.Height;
}
if (ha.X + ha.Width > mostRight)
{
mostRight = ha.X + ha.Width;
}
if (ha.X < mostLeft)
{
mostLeft = ha.X;
}
count++;
}
if (count == 0)
{
return(null);
}
var avrgX = ((mostRight + mostLeft) / 2f) - tooltipSize.Width * 0.5f;
var avrgY = ((mostTop + mostBottom) / 2f) - tooltipSize.Height * 0.5f;
switch (position)
{
case TooltipPosition.Top: return(new PointF(avrgX, mostTop - tooltipSize.Height));
case TooltipPosition.Bottom: return(new PointF(avrgX, mostBottom));
case TooltipPosition.Left: return(new PointF(mostLeft - tooltipSize.Width, avrgY));
case TooltipPosition.Right: return(new PointF(mostRight, avrgY));
case TooltipPosition.Center: return(new PointF(avrgX, avrgY));
default: throw new NotImplementedException();
}
}
IEnumerator set_position_in_bounds(TooltipPosition position)
{
yield return(null);
Vector3 pos;
RectTransformUtility.ScreenPointToWorldPointInRectangle(canvas.transform as RectTransform, Input.mousePosition, canvas.worldCamera, out pos);
rectT.position = offset_position(pos, position);
var old_pos = rectT.position;
ScreenBoundRect.ClampToScreen(rectT, canvas);
}
public void ShowTooltip(Transform skillTransform, TooltipPosition pos)
{
BaseSkill skill = selectCharacter.value.GetSkillInfo(pos);
if (skill == null)
{
tooltipObject.SetActive(false);
return;
}
tooltipObject.SetActive(true);
tooltipMessage.text = skill.description;
tooltipObject.transform.position = skillTransform.position;
tooltipBackground.sizeDelta = new Vector2(Mathf.Min(tooltipMessage.preferredWidth + 16, 216), tooltipMessage.preferredHeight + 8);
}
public BaseSkill GetSkillInfo(TooltipPosition pos)
{
BaseSkill skill = null;
PassiveSkill pSkill;
switch (pos)
{
case TooltipPosition.WEAPON:
skill = GetWeapon();
break;
case TooltipPosition.SUPPORT:
skill = GetSupport();
break;
case TooltipPosition.SKILL:
skill = GetSkill();
break;
case TooltipPosition.TYPEA:
pSkill = stats.GetPassive(SkillSlot.SLOTA);
if (pSkill != null)
{
skill = pSkill.baseSkill;
}
break;
case TooltipPosition.TYPEB:
pSkill = stats.GetPassive(SkillSlot.SLOTB);
if (pSkill != null)
{
skill = pSkill.baseSkill;
}
break;
case TooltipPosition.TYPEC:
pSkill = stats.GetPassive(SkillSlot.SLOTC);
if (pSkill != null)
{
skill = pSkill.baseSkill;
}
break;
default:
throw new ArgumentOutOfRangeException("pos", pos, null);
}
return(skill);
}
Vector3 offset_position(Vector3 position, TooltipPosition offset)
{
switch (offset)
{
case TooltipPosition.BOTTOM:
position.y -= rectT.rect.height;
break;
case TooltipPosition.TOP:
position.y += rectT.rect.height + 5;
break;
default:
goto case TooltipPosition.BOTTOM;
}
return(position);
}
public static string GetTooltipData(string key, TooltipPosition position = TooltipPosition.RightDown)
{
string pos = "";
switch (position)
{
case TooltipPosition.LeftBottom: pos = "lb"; break;
case TooltipPosition.LeftUp: pos = "lu"; break;
case TooltipPosition.RightDown: pos = "rb"; break;
case TooltipPosition.RightUp: pos = "ru"; break;
}
return(string.Format(@"<a class='tooltip' href='javascript://'>?<span class='{0}'>{1}</span></a>",
pos,
ResourceManager.GetResource(key)));
}
public static PointF?GetPieTooltipLocation(
this IEnumerable <TooltipPoint> foundPoints, TooltipPosition position, SizeF tooltipSize)
{
var placementContext = new TooltipPlacementContext();
var found = false;
foreach (var foundPoint in foundPoints)
{
if (foundPoint.Point.Context.HoverArea == null)
{
continue;
}
foundPoint.Point.Context.HoverArea.SuggestTooltipPlacement(placementContext);
found = true;
break; // we only care about the first one.
}
return(found ? new PointF(placementContext.PieX, placementContext.PieY) : null);
}
public unsafe void ShowAt(TooltipPosition location, RectTransform targetRect)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0049: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
_003F val = this.get_transform();
Vector3 lossyScale = val.get_lossyScale();
Rect screenRect = RectTransformToScreenSpace(val.get_root());
Rect rect = RectTransformToScreenSpace(targetRect);
Enlarge(ref rect, 10f * ((IntPtr)(void *)lossyScale).x, 10f * ((IntPtr)(void *)lossyScale).y);
Rect rect2 = val.get_rect();
location = BestLocation(Vector2.Scale(rect2.get_size(), Vector2.op_Implicit(lossyScale)), screenRect, rect, location);
Vector3 position = GetPosition(rect, location);
position.z = ((IntPtr)(void *)this.get_transform().get_position()).z;
ShowAt(location, position);
}
private void UpdateThrottlerUnlocked()
{
// before measure every element in the chart
// we copy the properties that might change while we are updating the chart
// this call should be thread safe
// ToDo: ensure it is thread safe...
viewDrawMargin = chartView.DrawMargin;
controlSize = chartView.ControlSize;
yAxes = chartView.YAxes.Select(x => x.Copy()).ToArray();
xAxes = chartView.XAxes.Select(x => x.Copy()).ToArray();
measureWorker = new object();
series = chartView.Series.Select(series =>
{
// a good implementation of ISeries<T>
// must use the measureWorker to identify
// if the points are already fetched.
// this way no matter if the Series.Values collection changes
// the fetch method will always return the same collection for the
// current measureWorker instance
series.Fetch(this);
return(series);
}).ToArray();
legendPosition = chartView.LegendPosition;
legendOrientation = chartView.LegendOrientation;
legend = chartView.Legend; // ... this is a reference type.. this has no sense
tooltipPosition = chartView.TooltipPosition;
tooltipFindingStrategy = chartView.TooltipFindingStrategy;
tooltip = chartView.Tooltip; //... no sense again...
animationsSpeed = chartView.AnimationsSpeed;
easingFunction = chartView.EasingFunction;
Measure();
}
/// <summary>
/// Returns the left, top coordinate of the tooltip based on the found points, the position and the tooltip size.
/// </summary>
/// <param name="foundPoints"></param>
/// <param name="position"></param>
/// <param name="tooltipSize"></param>
/// <returns></returns>
public static PointF?GetCartesianTooltipLocation(
this IEnumerable <TooltipPoint> foundPoints, TooltipPosition position, SizeF tooltipSize)
{
float count = 0f;
var placementContext = new TooltipPlacementContext();
foreach (var point in foundPoints)
{
if (point.Point.Context.HoverArea == null)
{
continue;
}
point.Point.Context.HoverArea.SuggestTooltipPlacement(placementContext);
count++;
}
if (count == 0)
{
return(null);
}
var avrgX = ((placementContext.MostRight + placementContext.MostLeft) / 2f) - tooltipSize.Width * 0.5f;
var avrgY = ((placementContext.MostTop + placementContext.MostBottom) / 2f) - tooltipSize.Height * 0.5f;
switch (position)
{
case TooltipPosition.Top: return(new PointF(avrgX, placementContext.MostTop - tooltipSize.Height));
case TooltipPosition.Bottom: return(new PointF(avrgX, placementContext.MostBottom));
case TooltipPosition.Left: return(new PointF(placementContext.MostLeft - tooltipSize.Width, avrgY));
case TooltipPosition.Right: return(new PointF(placementContext.MostRight, avrgY));
case TooltipPosition.Center: return(new PointF(avrgX, avrgY));
default: throw new NotImplementedException();
}
}
public void LoadAttributes(AttributeDictionary attributes)
{
if (!started) Start();
#if TEXTMESHPRO_PRESENT
if (attributes.ContainsKey("tooltipUseTextMeshPro")) ToggleTextMeshPro(attributes["tooltipUseTextMeshPro"].ToBoolean());
#endif
if (attributes.ContainsKey("tooltipTextColor")) SetTextColor(attributes["tooltipTextColor"].ToColor(xmlLayout));
if (attributes.ContainsKey("tooltipBackgroundColor")) SetBackgroundColor(attributes["tooltipBackgroundColor"].ToColor(xmlLayout));
if (attributes.ContainsKey("tooltipBorderColor")) SetBorderColor(attributes["tooltipBorderColor"].ToColor(xmlLayout));
if (attributes.ContainsKey("tooltipBackgroundImage")) SetBackgroundImage(attributes["tooltipBackgroundImage"].ToSprite());
if (attributes.ContainsKey("tooltipBorderImage")) SetBorderImage(attributes["tooltipBorderImage"].ToSprite());
if (attributes.ContainsKey("tooltipFontSize")) SetFontSize(int.Parse(attributes["tooltipfontsize"]));
if (attributes.ContainsKey("tooltipPadding")) SetTooltipPadding(attributes["tooltipPadding"].ToRectOffset());
if (attributes.ContainsKey("tooltipTextOutlineColor")) SetTextOutlineColor(attributes["tooltipTextOutlineColor"].ToColor(xmlLayout));
if (attributes.ContainsKey("tooltipFont")) SetFont(attributes["tooltipFont"]);
if (attributes.ContainsKey("tooltipPosition")) tooltipPosition = (TooltipPosition)Enum.Parse(typeof(TooltipPosition), attributes["tooltipPosition"]);
if (attributes.ContainsKey("tooltipFollowMouse")) followMouse = attributes["tooltipFollowMouse"].ToBoolean();
if (attributes.ContainsKey("tooltipOffset")) offsetDistance = float.Parse(attributes["tooltipOffset"]);
if (attributes.ContainsKey("tooltipFadeTime")) fadeTime = attributes["tooltipFadeTime"].ToFloat();
if (attributes.ContainsKey("tooltipDelayTime")) showDelayTime = attributes["tooltipDelayTime"].ToFloat();
if (attributes.ContainsKey("tooltipWidth"))
{
width = attributes["tooltipWidth"].ToFloat();
}
else
{
width = 0;
}
}
private static Vector2 GetPivotFor(TooltipPosition position)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
switch (position)
{
case TooltipPosition.Top:
return(new Vector2(0.5f, 0f));
case TooltipPosition.Bottom:
return(new Vector2(0.5f, 1f));
case TooltipPosition.Left:
return(new Vector2(1f, 0.5f));
case TooltipPosition.Right:
return(new Vector2(0f, 0.5f));
default:
throw new ArgumentOutOfRangeException("position", position, null);
}
}
public static void SetPosition(BindableObject view, TooltipPosition value)
{
view.SetValue(PositionProperty, value);
}
public AvailablePositions(string name, TooltipPosition position)
{
Name = name;
Position = position;
}
/// <summary>
/// The position (relative to the target) at which the Tooltip will be shown
/// </summary>
/// <param name="position">The position</param>
/// <returns></returns>
public virtual TooltipBuilder Position(TooltipPosition position)
{
Component.Position = position;
return this;
}
public void SetTooltip(FightTooltip tooltip, TooltipPosition tooltipPosition)
{
m_tooltip = tooltip;
m_tooltipPosition = tooltipPosition;
UpdateAllChildren(instant: true);
}
public void SetTooltip(FightTooltip tooltip, TooltipPosition tooltipPosition)
{
m_tooltip = tooltip;
m_tooltipPosition = tooltipPosition;
}
private static TooltipPosition BestLocation(Vector2 tooltipSize, Rect screenRect, Rect targetRect, TooltipPosition position)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
_003C_003Ec__DisplayClass22_0 _003C_003Ec__DisplayClass22_ = default(_003C_003Ec__DisplayClass22_0);
_003C_003Ec__DisplayClass22_.targetRect = targetRect;
_003C_003Ec__DisplayClass22_.tooltipSize = tooltipSize;
_003C_003Ec__DisplayClass22_.screenRect = screenRect;
switch (position)
{
case TooltipPosition.Top:
if (_003CBestLocation_003Eg__InsideTop_007C22_0(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Top);
}
if (!_003CBestLocation_003Eg__InsideBottom_007C22_1(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Top);
}
return(TooltipPosition.Bottom);
case TooltipPosition.Bottom:
if (_003CBestLocation_003Eg__InsideBottom_007C22_1(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Bottom);
}
if (!_003CBestLocation_003Eg__InsideTop_007C22_0(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Bottom);
}
return(TooltipPosition.Top);
case TooltipPosition.Left:
if (_003CBestLocation_003Eg__InsideLeft_007C22_2(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Left);
}
if (!_003CBestLocation_003Eg__InsideRight_007C22_3(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Left);
}
return(TooltipPosition.Right);
case TooltipPosition.Right:
if (_003CBestLocation_003Eg__InsideRight_007C22_3(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Right);
}
if (!_003CBestLocation_003Eg__InsideLeft_007C22_2(ref _003C_003Ec__DisplayClass22_))
{
return(TooltipPosition.Right);
}
return(TooltipPosition.Left);
default:
throw new ArgumentOutOfRangeException("position", position, null);
}
}
/// <summary>
/// Handles tooltips for tools
/// </summary>
void HandleTooltip(string ToolName, float UIScale, float ToolBaseX, int Position, string Tooltip = "", bool PositionIsY = false, bool IsInput = true)
{
// Only assign tooltip if it hasn't been already
if (Tooltip == "")
{
// First get the tooltip
if (ToolName == "AND")
{
Tooltip = Gates.Gate_AND.GateDescription;
}
if (ToolName == "OR")
{
Tooltip = Gates.Gate_OR.GateDescription;
}
if (ToolName == "XOR")
{
Tooltip = Gates.Gate_XOR.GateDescription;
}
if (ToolName == "NAND")
{
Tooltip = Gates.Gate_NAND.GateDescription;
}
if (ToolName == "NOR")
{
Tooltip = Gates.Gate_NOR.GateDescription;
}
if (ToolName == "XNOR")
{
Tooltip = Gates.Gate_XNOR.GateDescription;
}
if (ToolName == "NOT")
{
Tooltip = Gates.Gate_NOT.GateDescription;
}
if (ToolName == "Wire")
{
Tooltip = "Place wires to connect logic gates, inputs and outputs.";
}
if (ToolName == "Ship")
{
Tooltip = "Return to the ship's bridge and get back into the action!";
}
}
// Now create a rect for the tooltip position
Rect TooltipPosition;
if (!PositionIsY)
{
TooltipPosition = new Rect(ToolBaseX + 40f * UIScale + 240f * UIScale * Position, 70f * UIScale, 160f * UIScale, 160f * UIScale);
}
else
{
if (IsInput)
{
TooltipPosition = new Rect(SourceBasePos.x, SourceBasePos.y + 90f * Position * UIScale, 28f * UIScale, 28f * UIScale);
}
else
{
TooltipPosition = new Rect(OutBasePos.x, OutBasePos.y + 90f * Position * UIScale, 28f * UIScale, 28f * UIScale);
}
}
// Need a different mouse vector, since the y pos is wrong (o.0)
Vector2 MousePosition = Input.mousePosition;
MousePosition.y = Screen.height - MousePosition.y;
// Make use of the general tool style
ToolMiscStyle.normal.background = TooltipBG;
ToolMiscStyle.hover.background = TooltipBG;
ToolMiscStyle.font = TooltipFont;
ToolMiscStyle.normal.textColor = Color.white;
ToolMiscStyle.hover.textColor = Color.white;
// Padding
int Padding = (int)(4 * UIScale);
ToolMiscStyle.padding = new RectOffset(Padding, Padding, Padding, Padding);
// Render the tooltip if mouse is in bounds
if (TooltipPosition.Contains(MousePosition) && !Input.GetMouseButton(0))
{
// Calculate width
float WidthMult = Tooltip.Length / 40f;
// Set the base X position
float TooltipX = TooltipPosition.x;
float TooltipWidth = 400f * WidthMult;
// Make sure it'll be on-screen
if (TooltipPosition.x + TooltipWidth > Screen.width * 0.9f)
{
TooltipX = Screen.width * 0.9f - TooltipWidth;
}
GUI.Box(new Rect(TooltipX, TooltipPosition.y, TooltipWidth, 100f), ToolName + "\n\n" + Tooltip, ToolMiscStyle);
}
}
/// <summary>
/// The position (relative to the target) at which the Tooltip will be shown
/// </summary>
/// <param name="position">The position</param>
/// <returns></returns>
public virtual TBuilder Position(TooltipPosition position)
{
Component.Position = position;
return(this as TBuilder);
}
