/// <summary>
/// Gets or sets the physicalAngle at which the text is rotated.
/// </summary>
/// <value>
/// The physicalAngle at which the text is rotated.
/// </value>
//public float Rotation { get; set; }
#endregion
#region Constructors
public AngledLabel(PolygonControl container, string label, Font font, Brush fontBrush, float distance, float angle, float rotation, Brush brush, Pen pen)
: base(container, distance, angle, rotation, brush, pen)
{
Label = label;
LabelFont = font;
FontBrush = fontBrush;
}
internal GraphicItemSet(PolygonControl cc)
{
this.Container = cc;
Items = new List <T>();
Toolkit = new List <IDisposable>();
Mapper = new ToPhysicalAngleDelegate(Container.PhysicalAngleOf);
}
public Overlay(PolygonControl container, int division, Color scaleColor) : this(container, scaleColor)
{
OverlayHands newHands = new OverlayHands(container, division);
HandSets.Add(division, newHands);
//ScaleColor = scaleColor;
//Circles = new CircleSet(Container);
//Circles.Add(container.radius - overlayMargin);
//Circles.Add(container.radius - overlayMargin, new SolidBrush(WeightedColor(ScaleColor, 0.2f)), new Pen(WeightedColor(ScaleColor), 2));
//Circles.Add(3f, null, new Pen(WeightedColor(ScaleColor, 0.5f), 2));
//TicksAndLables = new AngledItemSet(container);
//SetScale();
//Scale = new Dialer(container, true, container.radius -3, 15, 15, 5, -1, 30, 1f, Color.FromArgb(0, Color.Yellow), Color.Transparent,
// Color.FromArgb(0, Color.Turquoise), Color.FromArgb(127, Color.LightSkyBlue), Color.FromArgb(127, Color.Orange));
//ShowScale = true;
//Scale.Circles.Add(1f, null, new Pen(WeightedColor(ScaleColor, 0.5f), 2));
//Scale = new Dialer(container, true, radius - Dialer.DefaultLoopWidthInPoints, radius, 1,
// WeightedColor(ScaleColor, 1f), Color.Transparent, WeightedColor(ScaleColor, 0.8f),
// WeightedColor(Dialer.DefaultLoopColor, 0.5f), WeightedColor(Dialer.DefaultLabelColor));
//AddOrShowHands(division, 1f);
}
internal Collection(PolygonControl cc)
{
Debug.Assert(cc != null);
this.cc = cc;
list = new List <T>();
}
public PolygonCalculator(PolygonControl container, Polygon polygon, int cycles)
{
Shape = polygon;
MaxCycle = Shape.IsPolygon ? cycles : 360 / Shape.Edges;
MinCycle = Shape.IsEven ? 1 : 0;
VerticesPositions = getVertices();
}
protected AngledItem(PolygonControl container, float distance, float angle, float rotation, Brush brush, Pen pen)
: base(container, brush, pen)
{
Distance = distance;
Angle = angle;
Rotation = rotation;
}
public PivotWrapper NearestPivot(float angle, float distance)
{
//float sectorAngle = 180f / (Container.Calculator.Edges);
List <PivotWrapper> around = (from pivot in Items
where Math.Abs(pivot.Angle - angle) < 45f && Math.Abs(pivot.Distance - distance) < 0.5
select pivot).ToList();
PivotWrapper nearest = null;
float minPow = float.MaxValue, angleDif, difPow, cos;
float distancePow = distance * distance;
foreach (PivotWrapper pivot in around)
{
angleDif = angle - pivot.Angle;
cos = PolygonControl.COS(angleDif);
difPow = distancePow + pivot.Distance * pivot.Distance - 2 * distance * pivot.Distance * cos;
if (difPow < minPow)
{
minPow = difPow;
nearest = pivot;
}
}
if (Math.Sqrt(minPow) < PivotWrapper.DefaultSymbolSize)
{
return(nearest);
}
else
{
return(null);
}
}
protected GraphicItem(PolygonControl container)
{
Container = container;
TheBrush = DefaultBrush;
ThePen = DefaultPen;
IsVisible = true;
}
public AngledItemSet(PolygonControl container)
: base(container)
{
AngleOffset = 0f;
//Mapper = new ToControlPositionDelegate(ToControlPosition);
Mapper = new ToPhysicalAngleDelegate(toContainerAngle);
//Container.UnitSizeChanged += new PolygonControl.UnitSizeChangedDelegate(Container_UnitSizeChanged);
}
public CircledPathes(PolygonControl container, GraphicsPath path, float distance, float angleOffset, float rotation, int repetition, AngleFilterDelegate isBypassed, bool isFixed, Brush brush, Pen pen)
: base(container, distance, angleOffset, rotation, brush, pen)
{
Path = path;
Repetition = repetition;
BypassPredicate = isBypassed;
IsFixed = isFixed;
}
protected GraphicItem(PolygonControl container, Brush brush, Pen pen)
{
Container = container;
TheBrush = brush;
ThePen = pen;
IsVisible = true;
}
//public bool ShowScale
//{
// get { return Scale.IsVisible; }
// set { Scale.IsVisible = value; }
//}
#endregion
#region Constructors
public Overlay(PolygonControl container, Color scaleColor)
{
Container = container;
HandSets = new Dictionary <int, OverlayHands>();
Ring = new Ruler(container, true, 2, scaleColor);
Ring.IsVisible = false;
IsOverlayChanged = true;
}
public PivotSet(PolygonControl container)
: base(container)
{
load();
IsVisible = false;
PlanetForStudy = PlanetId.SE_ECL_NUT;
container.CalculatorChanged += new PolygonControl.CalculatorChangedDelegate(container_CalculatorChanged);
container.AdapterChanged += new PolygonControl.AdapterChangedDelegate(container_AdapterChanged);
}
public PivotWrapper(PolygonControl container, GraphicsPath path, Brush brush, Pen pen, Pen leadingPen, OutlineItem pivot)
: base(container, path, 0, 0, 0, false, brush, pen)
{
Pivot = pivot;
double index = ToIndex(pivot.Price);
Position = container.Calculator.IndexedPositionOf(index);
Distance = Position.Radius;
Angle = Position.Angle;
LeadingPen = leadingPen;
DisplayHint = false;
Hint = "";
}
public bool IsOnHandle(float angle, float distance)
{
if (HandSets.Count == 0)
{
return(false);
}
float radius = Ruler.RulerRadius(Container, 1);
float angleDif = angle > AngleOffset ? angle - AngleOffset : AngleOffset - angle;
float cos = PolygonControl.COS(angleDif);
double distanceToHandle = Math.Sqrt(distance * distance + radius * radius - 2 * distance * radius * cos);
return(distanceToHandle <= OverlayHands.HandleSize);
}
public TimeSettingForm(PolygonControl control)
{
polygon = control;
InitializeComponent();
this.timeZoneList.DataSource = timeZones;
timeZoneList.SelectedIndex = 0;
//System.Collections.ObjectModel.ReadOnlyCollection<TimeZoneInfo> tzCollection;
//tzCollection = TimeZoneInfo.GetSystemTimeZones();
//this.timeZoneList.DataSource = tzCollection;
//timeZoneList.SelectedIndex = tzCollection.IndexOf(TimeZoneInfo.Local);
}
public OverlayHands(PolygonControl container, int divisions)
: base(container)
{
Scheme = OverlayScheme.SchemeOf(divisions);
IsVisble = true;
float step = 360f / divisions;
float radius = Ruler.RulerRadius(Container, 1);
PointF[] vertices = PolygonControl.VerticesPointsOf(divisions);
GraphicsPath buttonPath = new GraphicsPath();
buttonPath.AddPolygon(vertices);
buttonPath = AngledItem.Multiply(buttonPath, HandleSize);
Indicator = AddPath(buttonPath, radius, step, 0, false,
new SolidBrush(Color.FromArgb(180, Scheme.BaseColor)), new Pen(Color.FromArgb(127, Scheme.BaseColor)));
buttonPath = new GraphicsPath();
buttonPath.AddEllipse(-HandleSize, -HandleSize, 2 * HandleSize, 2 * HandleSize);
Handle = AddPath(buttonPath, radius, 0, 0, false, new SolidBrush(Color.FromArgb(200, Color.White)), new Pen(Color.FromArgb(127, Color.Yellow)));
Pen pen = new Pen(Color.FromArgb(127, Scheme.DarkColor), 0.5f);
pen.DashStyle = DashStyle.Dash;
SolidBrush brush = new SolidBrush(Color.FromArgb(127, Scheme.LightColor));
GraphicsPath handPath = new GraphicsPath();
RectangleF outRect = new RectangleF(-radius, -radius, 2 * radius, 2 * radius);
RectangleF inRect = new RectangleF(-emptyDistance, -emptyDistance, 2 * emptyDistance, 2 * emptyDistance);
float sin = PolygonControl.SIN(Scheme.Orb);
float cos = PolygonControl.COS(Scheme.Orb);
handPath.AddLine(radius * cos, radius * sin, emptyDistance * cos, sin * emptyDistance);
handPath.AddArc(inRect, Scheme.Orb, -2 * Scheme.Orb);
handPath.AddLine(cos * emptyDistance, -sin * emptyDistance, radius * cos, -radius * sin);
handPath.AddArc(outRect, 360f - Scheme.Orb, 2 * Scheme.Orb);
//handPath.AddLine(new PointF(0, 0), new PointF(radius, 0));
//handPath.CloseAllFigures();
Hands = AddPathSet(handPath, 0, 0, divisions, false, brush, pen);
//Hands = new List<AngledPath>();
//for (float angleLow = step; angleLow <= 360; angleLow += step )
//{
// Hands.Add(AddPath(handPath, 0, 0, angleLow, false, brush, pen));
//}
}
public Ruler(PolygonControl container,
bool isTransparent,
float insideRadius,
int signOffset,
int majorTick,
int middleTick,
int minorTick,
int labelTick,
float borderWidth,
Color borderColor,
Color faceColor,
Color loopColor,
Color scaleColor,
Color labelColor
)
{
Container = container;
IsVisible = true;
Circles = new CircleSet(container);
TicksAndLables = new AngledItemSet(container);
IsTransparent = isTransparent;
InsideRadius = insideRadius;
OutsideRadius = insideRadius + DefaultLoopWidthInPoints / Container.UnitSize;
BorderWidth = borderWidth;
BorderColor = borderColor;
FaceColor = faceColor;
LoopColor = loopColor;
ScaleColor = scaleColor;
LabelColor = labelColor;
MajorTickStep = majorTick;
MiddleTickStep = middleTick;
MinorTickStep = minorTick;
LabelStep = labelTick;
SignOffset = signOffset;
AngleOffset = 0;
Initialize();
//Container.MaxCycleChanged += new PolygonControl.MaxCycleChangedDelegate(Container_MaxCycleChanged);
//Container.UnitSizeChanged += new PolygonControl.UnitSizeChangedDelegate(Container_UnitSizeChanged);
//Container.CalculatorChanged += new PolygonControl.CalculatorChangedDelegate(container_CalculatorChanged);
}
public Ruler(PolygonControl container, bool isTransparent, float insideRadius)
: this(container,
isTransparent,
insideRadius,
DefaultMajorTickStep,
DefaultMajorTickStep,
DefaultMiddleTickStep,
DefaultMinorTickStep,
DefaultMajorTickStep,
DefaultBorderWidth,
DefaultBorderColor,
isTransparent ? Color.Transparent : DefaultFaceColor,
DefaultLoopColor,
DefaultScaleColor,
DefaultLabelColor)
{
}
public PlanetSet(PolygonControl container) : base(container)
{
DirectFont = new Font("StarFont Sans", 16f, FontStyle.Bold);
RetroFont = new Font("StarFont Sans", 16f, FontStyle.Italic | FontStyle.Underline);
//StarBrush = new SolidBrush(DefaultStarColor);
//RetroBrush = new SolidBrush(DefaultRetroColor);
StarPen = new Pen(DefaultStarColor);
Toolkit.Add(DirectFont);
Toolkit.Add(RetroFont);
//Toolkit.Add(RetroBrush);
//Toolkit.Add(StarBrush);
Toolkit.Add(StarPen);
Date = new DateTimeOffset(DateTime.UtcNow.Date);
IsVisible = true;
container.CalculatorChanged += new PolygonControl.CalculatorChangedDelegate(container_CalculatorChanged);
}
public PropertiesForm(PolygonControl polygon)
{
polygonControl1 = polygon;
InitializeComponent();
int selected = -1;
string name = polygon.Calculator.Shape.Name;
foreach (KeyValuePair <String, Polygon> kvp in Polygon.All)
{
//if (kvp.Value.IsPolygon)
comboBoxCalculator.Items.Add(kvp.Key);
if (kvp.Key == name)
{
selected = comboBoxCalculator.Items.Count - 1;
}
}
if (selected != -1)
{
comboBoxCalculator.SelectedIndex = selected;
}
selected = -1;
foreach (FirstQuadrantOrientation orientation in Enum.GetValues(typeof(FirstQuadrantOrientation)))
{
comboBoxOrientation.Items.Add(orientation.ToString());
if (orientation == polygon.FirstQuadrant)
{
selected = comboBoxOrientation.Items.Count - 1;
}
}
if (selected != -1)
{
comboBoxOrientation.SelectedIndex = selected;
}
numericUpDownMaxCycle.Value = polygon.MaxCycle;
numericUpDownUnitSize.Value = polygon.UnitSize;
}
public Ruler(PolygonControl container, bool isTransparent, float innerSize,
int signOffset,
int majorTick,
int middleTick,
int minorTick,
int labelTick
)
:
this(container,
isTransparent,
innerSize,
signOffset,
majorTick,
middleTick,
minorTick,
labelTick,
DefaultBorderWidth,
DefaultBorderColor,
DefaultFaceColor,
DefaultLoopColor,
DefaultScaleColor,
DefaultLabelColor)
{
}
public AngledLabel(PolygonControl container, string label, Font font, Brush fontBrush, float distance, float angle)
: this(container, label, font, fontBrush, distance, angle, 0, null, null)
{
}
public CircleSet(PolygonControl container) : this(container, new PointF(0, 0))
{
}
protected AngledItem(PolygonControl container, float distance, float angle, float rotation) : base(container)
{
Distance = distance;
Angle = angle;
Rotation = rotation;
}
public CircleSet(PolygonControl container, PointF center) : base(container)
{
AllHideBorder = false;
Center = center;
}
public Ruler(PolygonControl container, bool isTransparent, int index, Color scaleColor)
: this(container, isTransparent, index)
{
ScaleColor = scaleColor;
}
public Ruler(PolygonControl container, bool isTransparent, int index)
: this(container, isTransparent, RulerRadius(container, index - 1))
{
}
public static float RulerRadius(PolygonControl Container, float index)
{
return(Container.Calculator.Radius + index * (Ruler.DefaultLoopWidthInPoints / Container.UnitSize + RulerMargin));
}
public AngledLabel(PolygonControl container, Font font, float distance, float angle)
: this(container, angle.ToString(), font, DefaultBrush, distance, angle, 0)
{
}
