699 lines
25 KiB
C#
699 lines
25 KiB
C#
|
#define Graph_And_Chart_PRO
|
||
|
|
|
||
|
|
using System;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Linq;
|
||
|
|
using System.Text;
|
||
|
|
using UnityEngine;
|
||
|
|
using UnityEngine.Events;
|
||
|
|
using UnityEngine.UI;
|
||
|
|
|
||
|
|
namespace ChartAndGraph
|
||
|
|
{
|
||
|
|
/// <summary>
|
||
|
|
/// Base class for all axis charts that are scrollable. This class implements some important functionallity that is common to all scrollable charts
|
||
|
|
/// </summary>
|
||
|
|
public abstract class ScrollableAxisChart : AxisChart
|
||
|
|
{
|
||
|
|
private GameObject mMask;
|
||
|
|
private Vector2? mLastPosition;
|
||
|
|
private GraphicRaycaster mCaster;
|
||
|
|
protected Dictionary<string, Dictionary<int, BillboardText>> mTexts = new Dictionary<string, Dictionary<int, BillboardText>>();
|
||
|
|
protected HashSet<BillboardText> mActiveTexts = new HashSet<BillboardText>();
|
||
|
|
// bool mMaskCreated = false;
|
||
|
|
public ScrollableChartData ScrollableData
|
||
|
|
{
|
||
|
|
get { return (ScrollableChartData)DataLink; }
|
||
|
|
}
|
||
|
|
|
||
|
|
[HideInInspector]
|
||
|
|
[SerializeField]
|
||
|
|
protected bool autoScrollHorizontally = false;
|
||
|
|
|
||
|
|
public bool AutoScrollHorizontally
|
||
|
|
{
|
||
|
|
get { return autoScrollHorizontally; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
autoScrollHorizontally = value;
|
||
|
|
InvalidateRealtime();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override void Update()
|
||
|
|
{
|
||
|
|
base.Update();
|
||
|
|
|
||
|
|
if(IsCanvas)
|
||
|
|
{
|
||
|
|
// handle mouse events for canvas charts
|
||
|
|
HandleMouseDrag();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public override void GenerateRealtime()
|
||
|
|
{
|
||
|
|
base.GenerateRealtime();
|
||
|
|
if(SupportRealtimeGeneration)
|
||
|
|
{
|
||
|
|
GenerateAxis(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override double GetScrollOffset(int axis)
|
||
|
|
{
|
||
|
|
if (Scrollable == false)
|
||
|
|
return 0f;
|
||
|
|
if ((autoScrollHorizontally && axis == 0) || (autoScrollVertically && axis == 1))
|
||
|
|
{
|
||
|
|
double sMax = ScrollableData.GetMaxValue(axis, false);
|
||
|
|
//float sMin = (float)((IInternalGraphData)Data).GetMinValue(axis,false);
|
||
|
|
double dMax = ScrollableData.GetMaxValue(axis, true);
|
||
|
|
//float dMin = (float)((IInternalGraphData)Data).GetMinValue(axis, true);
|
||
|
|
double scrolling = dMax - sMax;
|
||
|
|
if (axis == 1)
|
||
|
|
{
|
||
|
|
if (ScrollableData.VerticalViewSize < 0)
|
||
|
|
scrolling += ScrollableData.VerticalViewSize;
|
||
|
|
|
||
|
|
verticalScrolling = scrolling;
|
||
|
|
}
|
||
|
|
else if (axis == 0)
|
||
|
|
{
|
||
|
|
if (ScrollableData.HorizontalViewSize < 0)
|
||
|
|
scrolling += ScrollableData.HorizontalViewSize;
|
||
|
|
horizontalScrolling = scrolling;
|
||
|
|
}
|
||
|
|
return scrolling;
|
||
|
|
}
|
||
|
|
if (axis == 1)
|
||
|
|
return verticalScrolling;
|
||
|
|
else if (axis == 0)
|
||
|
|
return horizontalScrolling;
|
||
|
|
return base.GetScrollOffset(axis);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void AddBillboardText(string cat, int index, BillboardText text)
|
||
|
|
{
|
||
|
|
if (text.UIText != null)
|
||
|
|
ChartCommon.MakeMaskable(text.UIText, true);
|
||
|
|
Dictionary<int, BillboardText> addTo;
|
||
|
|
if (mTexts.TryGetValue(cat, out addTo) == false)
|
||
|
|
{
|
||
|
|
addTo = new Dictionary<int, BillboardText>(ChartCommon.DefaultIntComparer);
|
||
|
|
mTexts.Add(cat, addTo);
|
||
|
|
}
|
||
|
|
addTo.Add(index, text);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void ClearBillboard()
|
||
|
|
{
|
||
|
|
mTexts.Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void ClearBillboardCategories()
|
||
|
|
{
|
||
|
|
foreach (Dictionary<int, BillboardText> d in mTexts.Values)
|
||
|
|
d.Clear();
|
||
|
|
}
|
||
|
|
[HideInInspector]
|
||
|
|
// [SerializeField]
|
||
|
|
[NonSerialized]
|
||
|
|
protected bool scrollable = true;
|
||
|
|
|
||
|
|
public bool Scrollable
|
||
|
|
{
|
||
|
|
get { return true; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
scrollable = value;
|
||
|
|
Invalidate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[HideInInspector]
|
||
|
|
[SerializeField]
|
||
|
|
protected double horizontalScrolling = 0f;
|
||
|
|
|
||
|
|
public double HorizontalScrolling
|
||
|
|
{
|
||
|
|
get { return horizontalScrolling; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
horizontalScrolling = value;
|
||
|
|
InvalidateRealtime();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[HideInInspector]
|
||
|
|
[SerializeField]
|
||
|
|
protected bool autoScrollVertically = false;
|
||
|
|
|
||
|
|
public bool AutoScrollVertically
|
||
|
|
{
|
||
|
|
get { return autoScrollVertically; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
autoScrollVertically = value;
|
||
|
|
InvalidateRealtime();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[HideInInspector]
|
||
|
|
[SerializeField]
|
||
|
|
protected double verticalScrolling = 0f;
|
||
|
|
|
||
|
|
public double VerticalScrolling
|
||
|
|
{
|
||
|
|
get { return verticalScrolling; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
verticalScrolling = value;
|
||
|
|
InvalidateRealtime();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
[SerializeField]
|
||
|
|
private bool raycastTarget = true;
|
||
|
|
|
||
|
|
public bool RaycastTarget
|
||
|
|
{
|
||
|
|
get { return raycastTarget; ; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
raycastTarget = value;
|
||
|
|
Invalidate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool PointToClient(Vector3 worldPoint, out double x, out DateTime y)
|
||
|
|
{
|
||
|
|
double dx, dy;
|
||
|
|
bool res = PointToClient(worldPoint, out dx, out dy);
|
||
|
|
x = dx;
|
||
|
|
y = ChartDateUtility.ValueToDate(dy);
|
||
|
|
return res;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool PointToClient(Vector3 worldPoint, out DateTime x, out DateTime y)
|
||
|
|
{
|
||
|
|
double dx, dy;
|
||
|
|
bool res = PointToClient(worldPoint, out dx, out dy);
|
||
|
|
x = ChartDateUtility.ValueToDate(dx);
|
||
|
|
y = ChartDateUtility.ValueToDate(dy);
|
||
|
|
return res;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
public bool PointToClient(Vector3 worldPoint, out DateTime x, out double y)
|
||
|
|
{
|
||
|
|
double dx, dy;
|
||
|
|
bool res = PointToClient(worldPoint, out dx, out dy);
|
||
|
|
x = ChartDateUtility.ValueToDate(dx);
|
||
|
|
y = dy;
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// transform a point from axis units into world space. returns true on success and false on failure (failure should never happen for this implementation)
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="result"> the resulting world space point</param>
|
||
|
|
/// <param name="x">x coordinate in axis units</param>
|
||
|
|
/// <param name="y">y coodinate in axis units</param>
|
||
|
|
/// <param name="category">for 3d chart specifing a catgory will return a point with the proper depth setting</param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool PointToWorldSpace(out Vector3 result,DateTime x, double y, string category = null)
|
||
|
|
{
|
||
|
|
return PointToWorldSpace(out result,ChartDateUtility.DateToValue(x), y, category);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// transform a point from axis units into world space. returns true on success and false on failure (failure should never happen for this implementation)
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="result"> the resulting world space point</param>
|
||
|
|
/// <param name="x">x coordinate in axis units</param>
|
||
|
|
/// <param name="y">y coodinate in axis units</param>
|
||
|
|
/// <param name="category">for 3d chart specifing a catgory will return a point with the proper depth setting</param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool PointToWorldSpace(out Vector3 result,double x, DateTime y, string category = null)
|
||
|
|
{
|
||
|
|
return PointToWorldSpace(out result,x, ChartDateUtility.DateToValue(y), category);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// transform a point from axis units into world space. returns true on success and false on failure (failure should never happen for this implementation)
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="result"> the resulting world space point</param>
|
||
|
|
/// <param name="x">x coordinate in axis units</param>
|
||
|
|
/// <param name="y">y coodinate in axis units</param>
|
||
|
|
/// <param name="category">for 3d chart specifing a catgory will return a point with the proper depth setting</param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool PointToWorldSpace(out Vector3 result,DateTime x, DateTime y, string category = null)
|
||
|
|
{
|
||
|
|
return PointToWorldSpace(out result,ChartDateUtility.DateToValue(x), ChartDateUtility.DateToValue(y), category);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected abstract double GetCategoryDepth(string category);
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// internal method used bu the mixed series chart to set this chart to default settings
|
||
|
|
/// </summary>
|
||
|
|
internal abstract void SetAsMixedSeries();
|
||
|
|
|
||
|
|
|
||
|
|
private DoubleVector3 PointToNormalized(double x, double y)
|
||
|
|
{
|
||
|
|
double minX, minY, maxX, maxY, xScroll, yScroll, xSize, ySize, xOut;
|
||
|
|
GetScrollParams(out minX, out minY, out maxX, out maxY, out xScroll, out yScroll, out xSize, out ySize, out xOut);
|
||
|
|
double resX = ((x - xScroll) / xSize);
|
||
|
|
double resY = ((y - yScroll) / ySize);
|
||
|
|
return new DoubleVector3(resX, resY,0.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private DoubleVector3 NormalizedToPoint(double x, double y)
|
||
|
|
{
|
||
|
|
double minX, minY, maxX, maxY, xScroll, yScroll, xSize, ySize, xOut;
|
||
|
|
GetScrollParams(out minX, out minY, out maxX, out maxY, out xScroll, out yScroll, out xSize, out ySize, out xOut);
|
||
|
|
double resX = x * xSize + xScroll;
|
||
|
|
double resY = y * ySize + yScroll;
|
||
|
|
return new DoubleVector3(resX, resY, 0.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
private Vector3 PointShift
|
||
|
|
{
|
||
|
|
get {
|
||
|
|
if(IsCanvas)
|
||
|
|
return CanvasFitOffset;
|
||
|
|
return new Vector3();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
protected override Vector3 CanvasFitOffset { get { return new Vector3(0.5f, 0.5f, 0f); } }
|
||
|
|
/// <summary>
|
||
|
|
/// transform a point from axis units into world space. returns true on success and false on failure (failure should never happen for this implementation)
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="result"> the resulting world space point</param>
|
||
|
|
/// <param name="x">x coordinate in axis units</param>
|
||
|
|
/// <param name="y">y coodinate in axis units</param>
|
||
|
|
/// <param name="category">for 3d chart specifing a catgory will return a point with the proper depth setting</param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool PointToWorldSpace(out Vector3 result,double x,double y, string category = null)
|
||
|
|
{
|
||
|
|
Vector3 fit = PointShift;
|
||
|
|
double minX, minY, maxX, maxY, xScroll, yScroll, xSize, ySize, xOut;
|
||
|
|
GetScrollParams(out minX, out minY, out maxX, out maxY, out xScroll, out yScroll, out xSize, out ySize, out xOut);
|
||
|
|
|
||
|
|
double resX = (((x - xScroll) / xSize)- fit.x) * ((IInternalUse)this).InternalTotalWidth;
|
||
|
|
double resY = (((y-yScroll) / ySize) - fit.y) * ((IInternalUse)this).InternalTotalHeight;
|
||
|
|
double resZ = 0.0;
|
||
|
|
if(category != null)
|
||
|
|
resZ = GetCategoryDepth(category);
|
||
|
|
Transform t = transform;
|
||
|
|
if (FixPosition != null)
|
||
|
|
t = FixPosition.transform;
|
||
|
|
result = t.TransformPoint(new Vector3((float)resX, (float)resY, (float)resZ));
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// gets the mouse position on the graph in axis units. returns true if the mouse is in bounds of the chart , false otherwise
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="x"></param>
|
||
|
|
/// <param name="y"></param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool MouseToClient(out double x,out double y)
|
||
|
|
{
|
||
|
|
Vector2 mousePos;
|
||
|
|
x = y = 0.0;
|
||
|
|
|
||
|
|
mCaster = GetComponentInParent<GraphicRaycaster>();
|
||
|
|
if (mCaster == null)
|
||
|
|
return false;
|
||
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(transform as RectTransform, Input.mousePosition, mCaster.eventCamera, out mousePos);
|
||
|
|
|
||
|
|
if(FixPosition != null)
|
||
|
|
{
|
||
|
|
mousePos = transform.TransformPoint(mousePos);
|
||
|
|
mousePos = FixPosition.transform.InverseTransformPoint(mousePos);
|
||
|
|
}
|
||
|
|
|
||
|
|
mousePos.x /= TotalWidth;
|
||
|
|
mousePos.y /= TotalHeight;
|
||
|
|
|
||
|
|
Vector3 fit = PointShift;
|
||
|
|
mousePos.x += fit.x;
|
||
|
|
mousePos.y += fit.y;
|
||
|
|
bool mouseIn = RectTransformUtility.RectangleContainsScreenPoint(transform as RectTransform, Input.mousePosition);
|
||
|
|
|
||
|
|
DoubleVector3 res = NormalizedToPoint(mousePos.x, mousePos.y);
|
||
|
|
x = res.x;
|
||
|
|
y = res.y;
|
||
|
|
return mouseIn;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// transform a point from world space into axis units. for best use , provide a point which is place on the canvas plane
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="worldPoint"></param>
|
||
|
|
/// <param name="x"></param>
|
||
|
|
/// <param name="y"></param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool PointToClient(Vector3 worldPoint, out double x, out double y)
|
||
|
|
{
|
||
|
|
Vector3 fit = PointShift;
|
||
|
|
double minX, minY, maxX, maxY, xScroll, yScroll, xSize, ySize, xOut;
|
||
|
|
GetScrollParams(out minX, out minY, out maxX, out maxY, out xScroll, out yScroll, out xSize, out ySize, out xOut);
|
||
|
|
Transform t = transform;
|
||
|
|
if (FixPosition != null)
|
||
|
|
t = FixPosition.transform;
|
||
|
|
worldPoint = t.InverseTransformPoint(worldPoint);
|
||
|
|
x = xScroll + xSize * ((((double)worldPoint.x) / ((IInternalUse)this).InternalTotalWidth) + fit.x);
|
||
|
|
y = yScroll + ySize * ((((double)worldPoint.y) / ((IInternalUse)this).InternalTotalHeight) + fit.y);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// Trims a rect in axis units into the visible portion of it in axis units. returns false if the parameter rect is completely out of view , true otherwise
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="rect"></param>
|
||
|
|
/// <param name="trimmed"></param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool TrimRect(DoubleRect rect, out DoubleRect trimmed)
|
||
|
|
{
|
||
|
|
DoubleVector3 min = rect.min;
|
||
|
|
DoubleVector3 max = rect.max;
|
||
|
|
trimmed = new DoubleRect();
|
||
|
|
min = PointToNormalized(min.x, min.y);
|
||
|
|
max = PointToNormalized(max.x, max.y);
|
||
|
|
|
||
|
|
if (min.x > 1f || min.y > 1f)
|
||
|
|
return false;
|
||
|
|
if (max.x < 0f || max.y < 0f)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
double minX = ChartCommon.Clamp(Math.Min(min.x, max.x));
|
||
|
|
double minY = ChartCommon.Clamp(Math.Min(min.y, max.y));
|
||
|
|
double maxX = ChartCommon.Clamp(Math.Max(min.x, max.x));
|
||
|
|
double maxY = ChartCommon.Clamp(Math.Max(min.y, max.y));
|
||
|
|
|
||
|
|
min = NormalizedToPoint(minX, minY);
|
||
|
|
max = NormalizedToPoint(maxX, maxY);
|
||
|
|
|
||
|
|
trimmed = new DoubleRect(min.x,min.y, max.x -min.x,max.y - min.y);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// returns true if the axis unity rect is visible on the chart, even if it is only partially visible. false otherwise
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="rect"></param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool IsRectVisible(DoubleRect rect)
|
||
|
|
{
|
||
|
|
DoubleVector3 min = rect.min;
|
||
|
|
DoubleVector3 max = rect.max;
|
||
|
|
|
||
|
|
min = PointToNormalized(min.x, min.y);
|
||
|
|
max = PointToNormalized(max.x, max.y);
|
||
|
|
|
||
|
|
if (min.x > 1f || min.y > 1f)
|
||
|
|
return false;
|
||
|
|
if (max.x < 0f || max.y < 0f)
|
||
|
|
return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// <summary>
|
||
|
|
/// tranforms an axis unit rect into a recttransform. The rect transform must have a parent assigned to it. Also the chart and the rectTransform must share a common ancestor canvas
|
||
|
|
/// </summary>
|
||
|
|
/// <param name="assignTo">The rect tranform to which the result is assigned to</param>
|
||
|
|
/// <param name="rect"></param>
|
||
|
|
/// <param name="catgeory"></param>
|
||
|
|
/// <returns></returns>
|
||
|
|
public bool RectToCanvas(RectTransform assignTo, DoubleRect rect, string catgeory = null)
|
||
|
|
{
|
||
|
|
DoubleVector3 min = rect.min;
|
||
|
|
DoubleVector3 max = rect.max;
|
||
|
|
|
||
|
|
Vector3 worldMin, worldMax;
|
||
|
|
if(PointToWorldSpace(out worldMin, min.x, min.y, catgeory) == false)
|
||
|
|
return false;
|
||
|
|
if (PointToWorldSpace(out worldMax, max.x, max.y, catgeory) == false)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
|
||
|
|
Transform parent = assignTo.parent;
|
||
|
|
|
||
|
|
if (parent == null)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
worldMin = parent.transform.InverseTransformPoint(worldMin);
|
||
|
|
worldMax = parent.transform.InverseTransformPoint(worldMax);
|
||
|
|
|
||
|
|
float minX = Math.Min(worldMin.x, worldMax.x);
|
||
|
|
float minY = Math.Min(worldMin.y, worldMax.y);
|
||
|
|
float sizeX = Math.Max(worldMin.x, worldMax.x) - minX;
|
||
|
|
float sizeY = Math.Max(worldMin.y, worldMax.y) - minY;
|
||
|
|
assignTo.anchorMin = new Vector2(0.5f, 0.5f);
|
||
|
|
assignTo.anchorMax = new Vector2(0.5f, 0.5f);
|
||
|
|
assignTo.pivot = new Vector2(0f, 0f);
|
||
|
|
assignTo.anchoredPosition = new Vector2(minX, minY);
|
||
|
|
assignTo.sizeDelta = new Vector2(sizeX, sizeY);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected abstract float GetScrollingRange(int axis);
|
||
|
|
|
||
|
|
public UnityEvent MousePan;
|
||
|
|
|
||
|
|
[SerializeField]
|
||
|
|
private bool horizontalPanning;
|
||
|
|
|
||
|
|
public bool HorizontalPanning
|
||
|
|
{
|
||
|
|
get { return horizontalPanning; ; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
horizontalPanning = value;
|
||
|
|
Invalidate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
[SerializeField]
|
||
|
|
private bool verticalPanning;
|
||
|
|
|
||
|
|
public bool VerticalPanning
|
||
|
|
{
|
||
|
|
get { return verticalPanning; ; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
verticalPanning = value;
|
||
|
|
Invalidate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool mStencilMask = false;
|
||
|
|
public bool StencilMask
|
||
|
|
{
|
||
|
|
get { return mStencilMask; }
|
||
|
|
set
|
||
|
|
{
|
||
|
|
mStencilMask = value;
|
||
|
|
Invalidate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
protected GameObject CreateRectMask(Rect viewRect)
|
||
|
|
{
|
||
|
|
//GameObject obj = Instantiate(Resources.Load("Chart And Graph/RectMask") as GameObject);
|
||
|
|
GameObject obj = ChartCommon.CreateCanvasChartItem();
|
||
|
|
obj.name = "rectMask2D";;
|
||
|
|
ChartCommon.HideObject(obj, hideHierarchy);
|
||
|
|
if (mStencilMask)
|
||
|
|
{
|
||
|
|
var mask = obj.AddComponent<Mask>();
|
||
|
|
mask.showMaskGraphic = false;
|
||
|
|
var image = obj.AddComponent<Image>();
|
||
|
|
image.maskable = false;
|
||
|
|
image.raycastTarget = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
obj.AddComponent<RectMask2D>();
|
||
|
|
|
||
|
|
//obj.AddComponent<ChartItem>();
|
||
|
|
obj.transform.SetParent(transform, false);
|
||
|
|
var rectTransform = obj.GetComponent<RectTransform>();
|
||
|
|
rectTransform.anchorMin = new Vector2(0f, 0f);
|
||
|
|
rectTransform.anchorMax = new Vector2(0f, 0f);
|
||
|
|
rectTransform.pivot = new Vector2(0f, 1f);
|
||
|
|
rectTransform.sizeDelta = viewRect.size;
|
||
|
|
rectTransform.anchoredPosition = new Vector2(0f, viewRect.size.y);
|
||
|
|
|
||
|
|
mMask = obj;
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected override void ClearChart()
|
||
|
|
{
|
||
|
|
base.ClearChart();
|
||
|
|
}
|
||
|
|
|
||
|
|
protected string StringFromAxisFormat(DoubleVector3 val, AxisBase axis,bool isX)
|
||
|
|
{
|
||
|
|
double itemVal = isX ? val.x : val.y;
|
||
|
|
if (axis == null)
|
||
|
|
return ChartAdancedSettings.Instance.FormatFractionDigits(2, itemVal);
|
||
|
|
return StringFromAxisFormat(val, axis, axis.MainDivisions.FractionDigits, isX);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected string StringFromAxisFormat(DoubleVector3 val, AxisBase axis, int fractionDigits,bool isX)
|
||
|
|
{
|
||
|
|
val.z = 0;
|
||
|
|
double itemVal = isX ? val.x : val.y;
|
||
|
|
var dic = VectorValueToStringMap;
|
||
|
|
|
||
|
|
KeyValuePair<string,string> res;
|
||
|
|
// Debug.Log("try get " + val + " count is " + dic.Count);
|
||
|
|
if (dic.TryGetValue(val, out res))
|
||
|
|
{
|
||
|
|
if (isX && res.Key != null)
|
||
|
|
return res.Key;
|
||
|
|
if (isX == false && res.Value != null)
|
||
|
|
return res.Value;
|
||
|
|
}
|
||
|
|
if (axis == null)
|
||
|
|
return ChartAdancedSettings.Instance.FormatFractionDigits(fractionDigits, itemVal, CustomNumberFormat);
|
||
|
|
|
||
|
|
string toSet = "";
|
||
|
|
if (axis.Format == AxisFormat.Number)
|
||
|
|
toSet = ChartAdancedSettings.Instance.FormatFractionDigits(fractionDigits, itemVal, CustomNumberFormat);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DateTime date = ChartDateUtility.ValueToDate(itemVal);
|
||
|
|
if (axis.Format == AxisFormat.DateTime)
|
||
|
|
toSet = ChartDateUtility.DateToDateTimeString(date,CustomDateTimeFormat);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (axis.Format == AxisFormat.Date)
|
||
|
|
toSet = ChartDateUtility.DateToDateString(date);
|
||
|
|
else
|
||
|
|
toSet = ChartDateUtility.DateToTimeString(date);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return toSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void GetScrollParams(out double minX,out double minY,out double maxX,out double maxY,out double xScroll,out double yScroll,out double xSize,out double ySize,out double xOut)
|
||
|
|
{
|
||
|
|
minX = ScrollableData.GetMinValue(0, false);
|
||
|
|
minY = ScrollableData.GetMinValue(1, false);
|
||
|
|
maxX = ScrollableData.GetMaxValue(0, false);
|
||
|
|
maxY = ScrollableData.GetMaxValue(1, false);
|
||
|
|
xScroll = GetScrollOffset(0) + minX;
|
||
|
|
yScroll = GetScrollOffset(1) + minY;
|
||
|
|
xSize = maxX - minX;
|
||
|
|
ySize = maxY - minY;
|
||
|
|
xOut = xScroll + xSize;
|
||
|
|
}
|
||
|
|
|
||
|
|
private void MouseDraged(Vector2 delta)
|
||
|
|
{
|
||
|
|
bool drag = false;
|
||
|
|
if (VerticalPanning)
|
||
|
|
{
|
||
|
|
float range = GetScrollingRange(1);
|
||
|
|
VerticalScrolling -= (delta.y / TotalHeightLink) * range;
|
||
|
|
if (Mathf.Abs(delta.y) > 1f)
|
||
|
|
drag = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (HorizontalPanning)
|
||
|
|
{
|
||
|
|
float range = GetScrollingRange(0);
|
||
|
|
HorizontalScrolling -= (delta.x / TotalWidthLink) * range;
|
||
|
|
if (Mathf.Abs(delta.x) > 1f)
|
||
|
|
drag = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (drag)
|
||
|
|
{
|
||
|
|
InvalidateRealtime();
|
||
|
|
if (MousePan != null)
|
||
|
|
MousePan.Invoke();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void HandleMouseDrag()
|
||
|
|
{
|
||
|
|
if (verticalPanning == false && horizontalPanning == false)
|
||
|
|
return;
|
||
|
|
mCaster = GetComponentInParent<GraphicRaycaster>();
|
||
|
|
if (mCaster == null)
|
||
|
|
return;
|
||
|
|
if (Application.isPlaying == false)
|
||
|
|
return;
|
||
|
|
|
||
|
|
Vector2 mousePos;
|
||
|
|
var chart = GetComponentInParent<AnyChart>();
|
||
|
|
var pointer = ChartCommon.EnsureComponent<CustomChartPointer>(chart.gameObject);
|
||
|
|
|
||
|
|
if (pointer == null)
|
||
|
|
return;
|
||
|
|
Vector3 checkMousePos = pointer.ScreenPosition;
|
||
|
|
|
||
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(transform as RectTransform, checkMousePos, mCaster.eventCamera, out mousePos);
|
||
|
|
var cam = mCaster.eventCamera;
|
||
|
|
bool mouseIn = RectTransformUtility.RectangleContainsScreenPoint(transform as RectTransform, checkMousePos, cam);
|
||
|
|
if (( (pointer!=null && pointer.IsMouseDown)) && mouseIn)
|
||
|
|
{
|
||
|
|
if (mLastPosition.HasValue)
|
||
|
|
{
|
||
|
|
Vector2 delta = mousePos - mLastPosition.Value;
|
||
|
|
MouseDraged(delta);
|
||
|
|
}
|
||
|
|
mLastPosition = mousePos;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
mLastPosition = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void TriggerActiveTextsOut()
|
||
|
|
{
|
||
|
|
foreach (BillboardText t in mActiveTexts)
|
||
|
|
{
|
||
|
|
if (t == null)
|
||
|
|
continue;
|
||
|
|
if (t.UIText == null)
|
||
|
|
continue;
|
||
|
|
foreach (ChartItemEffect effect in t.UIText.GetComponents<ChartItemEffect>())
|
||
|
|
{
|
||
|
|
if (effect != null)
|
||
|
|
effect.TriggerOut(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
mActiveTexts.Clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void AddActiveText(BillboardText b)
|
||
|
|
{
|
||
|
|
mActiveTexts.Add(b);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void SelectActiveText(BillboardText b)
|
||
|
|
{
|
||
|
|
TriggerActiveTextsOut();
|
||
|
|
GameObject tx = b.UIText;
|
||
|
|
if (tx != null)
|
||
|
|
{
|
||
|
|
ChartItemEvents e = tx.GetComponent<ChartItemEvents>();
|
||
|
|
if (e != null)
|
||
|
|
{
|
||
|
|
e.OnMouseHover.Invoke(e.gameObject);
|
||
|
|
AddActiveText(b);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
}
|