public void RemovePlot(IPlot plot)
{
if (plot == null)
{
return;
}
int index = plots.IndexOf(plot);
if (index < 0)
{
return;
}
RemovePlotListeners(plot);
plots.RemoveAt(index);
if (Allocation.X >= 0 && Allocation.Y >= 0)
{
foreach (IAxis axis in axes)
{
axis.SetRange(Plots, Allocation);
}
}
if (PlotsChanged != null)
{
PlotsChanged(this, Plots);
}
QueueResize();
}
private void graph_PlotAreaMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
if (graph.Plots.Count() == 0)
{
return;
}
Point screenPosition = e.GetPosition(graph);
Point relativePosition = graph.ScreenToRelative(screenPosition);
PlotValue nearestValue = graph.FindNearestValue(graph.Plots[0], relativePosition, query);
IPlot plot1 = nearestValue.PlotObserver;
var plot = (Plot)graph.Plots[plot1.Index];
if (plot == null || plot == _SelectedPlot)
{
return;
}
_SelectedPlot = plot;
foreach (Plot p in graph.Plots)
{
((LinePlotRenderer)p.Renderer).StrokeThickness = 1.0;
}
((LinePlotRenderer)_SelectedPlot.Renderer).StrokeThickness = 2.0;
int index = graph.Plots.IndexOf(plot);
lstYxis.SelectedIndex = index;
}
private IEnumerator Start()
{
PlotQueue = new Queue <MonoBehaviour>(PlotList);
PlayerInput.Instance.ReleaseControl(true);
PlayerInput.Instance.Interact.GainControl();
yield return(new WaitForSeconds(2f));
IPlot plot = null;
if (PlotQueue.Count > 0)
{
plot = PlotQueue.Dequeue() as IPlot;
}
while (plot != null)
{
yield return(StartCoroutine(plot.DoPlot()));
if (PlotQueue.Count > 0)
{
plot = PlotQueue.Dequeue() as IPlot;
}
else
{
plot = null;
break;
}
}
PlayerInput.Instance.GainControl();
yield break;
}
// param specify reference or name of axis.
public void Add(IPlot p, XAxisPosition xp, YAxisPosition yp)
{
plots_.Add(p);
xAxisPositions_.Add(xp);
yAxisPositions_.Add(yp);
UpdateAxes();
}
/// <summary>
/// Returns the y-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated y-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichYAxis(IPlot plot)
{
int index = drawables_.IndexOf(plot);
YAxisPosition p = (YAxisPosition)yAxisPositions_[index];
return((yAxisOverrides_[index] != null) ? (Axis)yAxisOverrides_[index] :
(p == YAxisPosition.Left) ? this.yAxis1_ : this.yAxis2_);
}
/// <summary>
/// Returns the x-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated x-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichXAxis(IPlot plot)
{
int index = drawables_.IndexOf(plot);
XAxisPosition p = (XAxisPosition)xAxisPositions_[index];
return((xAxisOverrides_[index] != null) ? (Axis)xAxisOverrides_[index] :
(p == XAxisPosition.Bottom) ? this.xAxis1_ : this.xAxis2_);
}
private static IPlot GetInstance()
{
IPlot result = Implementation.Value;
if (result == null)
{
throw new NotImplementedException();
}
return(result);
}
public ProcessPlot(IPlot newPlot, List <OBBox> obbs)
{
plot = newPlot;
this.obbs = obbs;
shortSplit = true;
longSplit = false;
variationA = false;
variationB = false;
variationAmount = 0.5f;
}
public ProcessPlot(IPlot newPlot)
{
plot = newPlot;
obbs = new List <OBBox>();
shortSplit = true;
longSplit = false;
variationA = false;
variationB = false;
variationAmount = 0.5f;
}
public AddPlotWindow()
{
InitializeComponent();
this.dbInit = new DatabaseInitializer();
this.repo = new LandRepository();
this.plot = new Plot();
PopulateFormFields();
}
protected virtual void RemovePlotListeners(IPlot plot)
{
plot.Changed -= new EventHandler(OnPlotChanged);
plot.SelectionChanged -= new EventHandler(OnPlotSelectionChanged);
if (plot is ITreeModelPlot)
{
((ITreeModelPlot)plot).ModelChanged -= new EventHandler(OnModelChanged);
}
}
public AddPlotWindow()
{
InitializeComponent();
this.dbInit = new DatabaseInitializer();
this.repo = new LandRepository();
this.plot = new Plot();
PopulateFormFields();
}
private IPlot GetPlotById(int plotId)
{
IPlot plot = ObjectFactory.Instance.CreatePlot();
try
{
conn.Open();
SqlCommand command = new SqlCommand("CH_SP_GetPlotById", conn);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@PlotId", plotId));
SqlDataReader reader = command.ExecuteReader();
if (reader.HasRows)
{
reader.Read();
string zipcode = reader.GetString(0);
string address = reader.GetString(1);
string city = reader.GetString(2);
int area = reader.GetInt32(3);
string municipality = reader.GetString(4);
DateTime?availabilityDate;
if (reader.IsDBNull(5))
{
availabilityDate = null;
}
else
{
availabilityDate = reader.GetDateTime(5);
}
plot.Zipcode = zipcode;
plot.Address = address;
plot.City = city;
plot.Area = area;
plot.Municipality = municipality;
plot.AvailabilityDate = availabilityDate;
}
reader.Close();
reader.Dispose();
}
catch (SqlException)
{
}
finally
{
if (conn.State == ConnectionState.Open)
{
conn.Close();
}
}
return(plot);
}
public APlotVM(IPlot plot)
{
_plot = plot;
_lastKeyboardInput = new KeyboardInput();
_lastMouseInput = new MouseInput();
_selection = new SelectionManager(plot);
_plotPoints = new PlotPoints();
Update();
Step = new Vector3D(0, 0, 1);
}
/// <summary>
/// Returns the y-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated y-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichYAxis(IPlot plot)
{
int index = drawables_.IndexOf(plot);
YAxisPosition p = (YAxisPosition)yAxisPositions_[index];
if (p == YAxisPosition.Left)
{
return(yAxis1_);
}
else
{
return(yAxis2_);
}
}
/// <summary>
/// Returns the x-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated x-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichXAxis(IPlot plot)
{
int index = drawables_.IndexOf(plot);
XAxisPosition p = (XAxisPosition)xAxisPositions_[index];
if (p == XAxisPosition.Bottom)
{
return(xAxis1_);
}
else
{
return(xAxis2_);
}
}
protected override void OnFocusGrabbed()
{
base.OnFocusGrabbed();
if (plots.Count < 1)
{
return;
}
// don't switch focus if any plot already has focus
foreach (IPlot plot in plots)
{
if (plot.HasFocus)
{
return;
}
}
// find the plot with the smallest x value, and focus it
int min_plot = -1;
int min_x = Int32.MaxValue;
int min_y = Int32.MaxValue;
for (int i = 0; i < plots.Count; i++)
{
IPlot plot = (IPlot)plots[i];
if (!plot.CanFocus)
{
continue;
}
int x, y;
plot.GetGrabFocusRequest(out x, out y);
if ((min_x > x) || (min_x == x && min_y > y))
{
min_x = x;
min_y = y;
min_plot = i;
}
}
if (min_plot == -1)
{
return;
}
((IPlot)plots[min_plot]).GrabFocus();
focused_plot_index = min_plot;
}
public void InitializePlotControl(IPlot iPlot)
{
this.iPlot = iPlot;
ArrayList oxVars = iPlot.GetOxVariables();
ArrayList oyVars = iPlot.GetOyVariables();
this.comboBoxOxVariables.Items.Clear();
this.comboBoxOyVariables.Items.Clear();
// populate the ox variables
IEnumerator e1 = oxVars.GetEnumerator();
while (e1.MoveNext())
{
this.comboBoxOxVariables.Items.Add(e1.Current);
}
if (oxVars != null && oxVars.Count > 0)
{
this.comboBoxOxVariables.SelectedIndex = 0;
}
// populate the oy variables
IEnumerator e2 = oyVars.GetEnumerator();
while (e2.MoveNext())
{
this.comboBoxOyVariables.Items.Add(e2.Current);
}
if (oyVars != null && oyVars.Count > 0)
{
this.comboBoxOyVariables.SelectedIndex = 0;
}
PlotData plotData = iPlot.GetPlotData(this.OxVariable, this.OyVariable);
// update the ranges
this.UpdateRangesOnUI(this.OxVariable, this.OyVariable);
// update the plot
this.plotGraph.UpdatePlot(plotData, this.OxVariable, this.OyVariable);
//
this.UpdateFamiliesList(plotData);
if (this.iPlot != null)
{
this.iPlot.PlotChanged += new PlotChangedEventHandler(iPlot_PlotChanged);
}
}
private static string plotFigure(string caption, IPlot plot, string pictureText)
{
var tex = new StringBuilder();
tex.Append(Helper.Begin(Helper.Environments.figure));
tex.AppendFormat((string)"[{0}]\n", (object)plot.Position);
tex.Append(Helper.NoIndent());
tex.Append(Helper.Centering());
tex.Append(setSubfolderForPlots());
tex.Append(pictureText);
tex.Append(Helper.Caption(caption));
tex.Append(Helper.Label(plot.Label));
tex.Append(Helper.End(Helper.Environments.figure));
return(tex.ToString());
}
public void Create(IPlot plot)
{
MinMaxRange xRange = new MinMaxRange();
MinMaxRange yRange = new MinMaxRange();
MinMaxRange zRange = new MinMaxRange();
foreach (ISeries series in plot.Series)
{
foreach (IPoint point in series.Points)
{
xRange.Update(point.Position.X);
yRange.Update(point.Position.Y);
zRange.Update(point.Position.Z);
}
}
//foreach( xRange.Min =
}
public AutoRenderPolicy(IPlot plot)
: base(plot)
{
task = Task.Factory.StartNew(async() =>
{
try
{
var channel = Channel.CreateUnbounded <int>(new UnboundedChannelOptions
{
SingleReader = true,
SingleWriter = true
});
var reader = channel.Reader;
writer = channel.Writer;
var token = cancellationTokenSource.Token;
while (await reader.WaitToReadAsync(token).ConfigureAwait(false))
{
while (reader.TryRead(out _))
{
}
plot.Render();
Interlocked.Exchange(ref render, 1);
await plot.StateHasChangedAsync().ConfigureAwait(false);
try
{
await semaphore.WaitAsync(token).ConfigureAwait(false);
}
finally
{
}
}
}
catch (Exception e)
{
}
}, TaskCreationOptions.LongRunning);
}
public static RawMeshData GeneratePlot(IPlot plot)
{
int pointSize = plot.numberOfEdges;
int[] sortedIndexes = BuildrUtils.SortPointByAngle(plot.pointsV2, plot.center);
Vector2[] sortedPoints = new Vector2[pointSize];
for (int i = 0; i < pointSize; i++)
{
sortedPoints[i] = plot.pointsV2[sortedIndexes[i]];
}
bool clockwise = Clockwise(sortedPoints);
int vertCount = pointSize + 1;
int triCount = pointSize * 3;
RawMeshData output = new RawMeshData(vertCount, triCount);
for (int v = 0; v < vertCount - 1; v++)
{
output.vertices[v] = new Vector3(sortedPoints[v].x, 0, sortedPoints[v].y);
}
output.vertices[vertCount - 1] = new Vector3(plot.center.x, 0, plot.center.y);
int vertIndex = 0;
for (int t = 0; t < triCount; t += 3)
{
output.triangles[t + 0] = vertCount - 1;
if (clockwise)
{
output.triangles[t + 1] = vertIndex;
output.triangles[t + 2] = (vertIndex < vertCount - 2) ? vertIndex + 1 : 0;
}
else
{
output.triangles[t + 1] = (vertIndex < vertCount - 2) ? vertIndex + 1 : 0;
output.triangles[t + 2] = vertIndex;
}
vertIndex++;
}
return(output);
}
/**
* Add a plot to the graph. This plot will use the specified
* axes when drawing. The axes specified must have already
* been appended to the Graph's axes list.
*/
public void AddPlot(IPlot plot, params IAxis[] axes)
{
if (plot == null || axes == null || axes.Length == 0)
{
return;
}
plots.Add(plot);
plot.SetAxes(axes);
plot.Style = style_prov;
AddPlotListeners(plot);
if (PlotsChanged != null)
{
PlotsChanged(this, Plots);
}
QueueResize();
}
public String DoItRight(INumericMethod <TFunc> method, IShape <TFunc> func, IPlot plotSpace, Conditions conditions, IReportGenerator reporter, bool stepByStep = false)
{
var actualPoints = conditions.InitialPoints.ToArray();
UpdateDomain(func, actualPoints);
reporter.Init(actualPoints, func, conditions);
var iterationsCounter = 0;
while (!IsAnyPointPrettyCloseToRoot(func.Generator, conditions, actualPoints) && iterationsCounter++ < conditions.MaxNumberOfIteration)
{
var newPoint = method.ComputeNext(actualPoints, func.Generator);
if (!newPoint.Any())
{
break;
}
actualPoints = actualPoints.Concat(newPoint).ToArray();
UpdateDomain(func, actualPoints);
var pictureOfStep = method.GenerateIllustrationForCurrentStep(actualPoints, func.Generator, iterationsCounter + conditions.InitialPoints.Count());
reporter.AddIntermidiateStep(actualPoints, pictureOfStep, iterationsCounter);
plotSpace.DrawShape(func);
foreach (var shape in pictureOfStep)
{
plotSpace.DrawShape(shape);
if (stepByStep)
{
Console.WriteLine("Press Enter to make step");
Console.ReadLine();
}
}
}
return(reporter.GenerateReport(actualPoints.Last(), iterationsCounter, DistanceToRoot(func.Generator, actualPoints.Last(), conditions)));
}
private int InsertPlot(IPlot plot)
{
SqlCommand command = new SqlCommand("CH_SP_InsertOrEditPlot", conn);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.Add(new SqlParameter("@ZipCode", plot.Zipcode));
command.Parameters.Add(new SqlParameter("@PlotAddress", plot.Address));
command.Parameters.Add(new SqlParameter("@City", plot.City));
command.Parameters.Add(new SqlParameter("@Area", plot.Area));
command.Parameters.Add(new SqlParameter("@Municipality", plot.Municipality));
command.Parameters.Add(new SqlParameter("@AvailabilityDate", plot.AvailabilityDate));
SqlParameter returnParameter = command.Parameters.Add("@PlotId", SqlDbType.Int);
returnParameter.Direction = ParameterDirection.ReturnValue;
command.ExecuteNonQuery();
command.Dispose();
return(int.Parse(returnParameter.Value.ToString()));
}
/// <summary>
/// Coppies data in the current plot surface view window to the clipboard
/// as text.
/// </summary>
public void CopyDataToClipboard()
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < this.InteractivePlotSurface2D.Drawables.Count; ++i)
{
IPlot plot = this.InteractivePlotSurface2D.Drawables[i] as IPlot;
if (plot != null)
{
Axis xAxis = this.InteractivePlotSurface2D.WhichXAxis(plot);
Axis yAxis = this.InteractivePlotSurface2D.WhichYAxis(plot);
RectangleD region = new RectangleD(
xAxis.WorldMin,
yAxis.WorldMin,
xAxis.WorldMax - xAxis.WorldMin,
yAxis.WorldMax - yAxis.WorldMin);
plot.WriteData(sb, region, true);
}
}
Clipboard.SetDataObject(sb.ToString(), true);
}
/// <summary>
/// Returns the x-axis associated with a given plot (XAxis1 is at Bottom).
/// </summary>
/// <param name="plot">the plot to get associated x-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichXAxis(IPlot plot)
{
int index = drawables.IndexOf (plot);
XAxisPosition p = (XAxisPosition)xAxisPositions[index];
if (p == XAxisPosition.Bottom)
return xAxis1;
else
return xAxis2;
}
public PolarGrapher(IPlot plotter)
{
this.plotter = plotter;
plotter.plot_axes();
}
/// <summary>
/// Returns the y-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated y-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichYAxis( IPlot plot )
{
int index = drawables_.IndexOf( plot );
YAxisPosition p = (YAxisPosition)yAxisPositions_[index];
if ( p == YAxisPosition.Left )
return this.yAxis1_;
else
return this.yAxis2_;
}
/// <summary>
/// Returns the x-axis associated with a given plot.
/// </summary>
/// <param name="plot">the plot to get associated x-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichXAxis( IPlot plot )
{
int index = drawables_.IndexOf( plot );
XAxisPosition p = (XAxisPosition)xAxisPositions_[index];
if ( p == XAxisPosition.Bottom )
return this.xAxis1_;
else
return this.xAxis2_;
}
/// <summary>
/// Draw The legend
/// </summary>
/// <param name="g">The graphics surface on which to draw</param>
/// <param name="position">The position of the top left of the axis.</param>
/// <param name="plots">Array of plot objects to appear in the legend.</param>
/// <param name="scale">if the legend is set to scale, the amount to scale by.</param>
/// <returns>bounding box</returns>
public Rectangle Draw(Graphics g, Point position, ArrayList plots, float scale)
{
// first of all determine the Font to use in the legend.
Font textFont;
if (this.AutoScaleText)
{
textFont = Utils.ScaleFont(this.font_, scale);
}
else
{
textFont = this.font_;
}
// determine max width and max height of label strings and
// count the labels.
int labelCount = 0;
int maxHt = 0;
int maxWd = 0;
int unnamedCount = 0;
for (int i = 0; i < plots.Count; ++i)
{
if (!(plots[i] is IPlot))
{
continue;
}
IPlot p = (IPlot)plots[i];
if (!p.ShowInLegend)
{
continue;
}
string label = p.Label;
if (label == "")
{
unnamedCount += 1;
label = "Series " + unnamedCount.ToString();
}
SizeF labelSize = g.MeasureString(label, textFont);
if (labelSize.Height > maxHt)
{
maxHt = (int)labelSize.Height;
}
if (labelSize.Width > maxWd)
{
maxWd = (int)labelSize.Width;
}
++labelCount;
}
bool extendingHorizontally = numberItemsHorizontally_ == -1;
bool extendingVertically = numberItemsVertically_ == -1;
// determine width in legend items count units.
int widthInItemCount = 0;
if (extendingVertically)
{
if (labelCount >= numberItemsHorizontally_)
{
widthInItemCount = numberItemsHorizontally_;
}
else
{
widthInItemCount = labelCount;
}
}
else if (extendingHorizontally)
{
widthInItemCount = labelCount / numberItemsVertically_;
if (labelCount % numberItemsVertically_ != 0)
{
widthInItemCount += 1;
}
}
else
{
throw new NPlotException("logic error in legend base");
}
// determine height of legend in items count units.
int heightInItemCount = 0;
if (extendingHorizontally)
{
if (labelCount >= numberItemsVertically_)
{
heightInItemCount = numberItemsVertically_;
}
else
{
heightInItemCount = labelCount;
}
}
else // extendingVertically
{
heightInItemCount = labelCount / numberItemsHorizontally_;
if (labelCount % numberItemsHorizontally_ != 0)
{
heightInItemCount += 1;
}
}
int lineLength = 20;
int hSpacing = (int)(5.0f * scale);
int vSpacing = (int)(3.0f * scale);
int boxWidth = (int)((float)widthInItemCount * (lineLength + maxWd + hSpacing * 2.0f) + hSpacing);
int boxHeight = (int)((float)heightInItemCount * (maxHt + vSpacing) + vSpacing);
int totalWidth = boxWidth;
int totalHeight = boxHeight;
// draw box around the legend.
if (this.BorderStyle == BorderType.Line)
{
g.FillRectangle(new SolidBrush(this.bgColor_), position.X, position.Y, boxWidth, boxHeight);
g.DrawRectangle(new Pen(this.borderColor_), position.X, position.Y, boxWidth, boxHeight);
}
else if (this.BorderStyle == BorderType.Shadow)
{
int offset = (int)(4.0f * scale);
g.FillRectangle(new SolidBrush(Color.FromArgb(128, Color.Gray)), position.X + offset, position.Y + offset, boxWidth, boxHeight);
g.FillRectangle(new SolidBrush(this.bgColor_), position.X, position.Y, boxWidth, boxHeight);
g.DrawRectangle(new Pen(this.borderColor_), position.X, position.Y, boxWidth, boxHeight);
totalWidth += offset;
totalHeight += offset;
}
/*
* else if ( this.BorderStyle == BorderType.Curved )
* {
* // TODO. make this nice.
* }
*/
else
{
// do nothing.
}
// now draw entries in box..
labelCount = 0;
unnamedCount = 0;
int plotCount = -1;
for (int i = 0; i < plots.Count; ++i)
{
if (!(plots[i] is IPlot))
{
continue;
}
IPlot p = (IPlot)plots[i];
if (!p.ShowInLegend)
{
continue;
}
plotCount += 1;
int xpos, ypos;
if (extendingVertically)
{
xpos = plotCount % numberItemsHorizontally_;
ypos = plotCount / numberItemsHorizontally_;
}
else
{
xpos = plotCount / numberItemsVertically_;
ypos = plotCount % numberItemsVertically_;
}
int lineXPos = (int)(position.X + hSpacing + xpos * (lineLength + maxWd + hSpacing * 2.0f));
int lineYPos = (int)(position.Y + vSpacing + ypos * (vSpacing + maxHt));
p.DrawInLegend(g, new Rectangle(lineXPos, lineYPos, lineLength, maxHt));
int textXPos = lineXPos + hSpacing + lineLength;
int textYPos = lineYPos;
string label = p.Label;
if (label == "")
{
unnamedCount += 1;
label = "Series " + unnamedCount.ToString();
}
g.DrawString(label, textFont,
new SolidBrush(this.textColor_), textXPos, textYPos);
++labelCount;
}
return(new Rectangle(position.X, position.Y, totalWidth, totalHeight));
}
public SliderAction(IPlot pc)
: base(pc)
{
}
/* XXX: Uncomment when ximian bug #81343 is closed and usable.
* protected override void OnActivate ()
* {
* foreach (IPlot plot in plots)
* {
* plot.UnselectAll ();
* }
*
* foreach (IPlot plot in plots)
* {
* if (plot.HasFocus) {
* int x, y;
* plot.GetFocusedPoint (axes, out x, out y);
* plot.SelectPoint (axes, x, y);
* break;
* }
* }
* }
*/
protected override bool OnFocused(DirectionType dir)
{
if (plots.Count < 1)
{
return(false);
}
if (!HasFocus)
{
GrabFocus();
return(true);
}
int visits;
int focused_x = -1, focused_y = -1;
switch (dir)
{
case DirectionType.Left:
((IPlot)plots[focused_plot_index]).FocusPrev();
return(true);
case DirectionType.Right:
((IPlot)plots[focused_plot_index]).FocusNext();
return(true);
case DirectionType.Up:
// Don't move selection if there is only one
// plot
if (plots.Count <= 1)
{
return(true);
}
// get the currently focused point
((IPlot)plots[focused_plot_index]).GetFocusedPoint(out focused_x,
out focused_y);
// Iterate through the plots in the zorder,
// looking for the next plot which CanFocus.
// Also, make sure we don't see plots twice, or
// infinite loop.
visits = 0;
do
{
// move to the next plot in the z-order
focused_plot_index--;
if (focused_plot_index < 0)
{
focused_plot_index = plots.Count - 1;
}
visits++;
IPlot plot = (IPlot)plots[focused_plot_index];
if (!plot.CanFocus)
{
continue;
}
// clear focus on all the plots
foreach (IPlot p in plots)
{
if (p.HasFocus)
{
p.ReleaseFocus();
}
}
// focus the nearest to the last
// focused point
plot.FocusNearest(focused_x, focused_y);
break;
} while (visits <= plots.Count);
return(true);
case DirectionType.Down:
// Don't move selection if there is only one
// plot
if (plots.Count <= 1)
{
return(true);
}
// get the currently focused point
((IPlot)plots[focused_plot_index]).GetFocusedPoint(out focused_x,
out focused_y);
// Iterate through the plots in the zorder,
// looking for the next plot which CanFocus.
// Also, make sure we don't see plots more than
// once, or worse, infinite loop.
visits = 0;
do
{
// move to the previous plot in the z-order
focused_plot_index++;
if (focused_plot_index >= plots.Count)
{
focused_plot_index = 0;
}
visits++;
IPlot plot = (IPlot)plots[focused_plot_index];
if (!plot.CanFocus)
{
continue;
}
// clear focus on all the plots
foreach (IPlot p in plots)
{
if (p.HasFocus)
{
p.ReleaseFocus();
}
}
// focus the nearest to the last
// focused point
plot.FocusNearest(focused_x, focused_y);
break;
} while (visits <= plots.Count);
return(true);
case DirectionType.TabForward:
default:
// let focus jump to the next widget
return(false);
}
}
public void Add(IPlot p, XAxisPosition xp, YAxisPosition yp)
{
ps_.Add(p, xp, yp);
}
public RectangleF Draw(Graphics g, int xPos, int yPos, ArrayList plots, float scale)
{
// determine max width and max height of label strings.
float maxHt = 0.0f;
float maxWd = 0.0f;
for (int i = 0; i < plots.Count; ++i)
{
IPlot p = (IPlot)plots[i];
float lHt = g.MeasureString(p.Label, FontScaler.scaleFont(font_, scale)).Height;
float lWd = g.MeasureString(p.Label, FontScaler.scaleFont(font_, scale)).Width;
if (lHt > maxHt)
{
maxHt = lHt;
}
if (lWd > maxWd)
{
maxWd = lWd;
}
}
float lineLength = 20.0f;
float lineHeight = maxHt;
float hSpacing = 5.0f * scale;
float vSpacing = 3.0f * scale;
float boxWidth = hSpacing * 3.0f + lineLength + maxWd;
float boxHeight = vSpacing * (float)(plots.Count + 1) + maxHt * (float)plots.Count;
float totalWidth = boxWidth;
float totalHeight = boxHeight;
// draw box..
if (BorderStyle == BorderType.Line)
{
g.FillRectangle(new SolidBrush(Color.White), xPos, yPos, boxWidth, boxHeight);
g.DrawRectangle(new Pen(Color.Black), xPos, yPos, boxWidth, boxHeight);
}
else if (BorderStyle == BorderType.Shadow)
{
float offset = 4.0f * (float)scale;
g.FillRectangle(new SolidBrush(Color.LightGray), xPos + offset, yPos + offset, boxWidth, boxHeight);
g.FillRectangle(new SolidBrush(Color.White), xPos, yPos, boxWidth, boxHeight);
g.DrawRectangle(new Pen(Color.Black), xPos, yPos, boxWidth, boxHeight);
totalWidth += offset;
totalHeight += offset;
}
/*
* else if ( this.BorderStyle == BorderType.Curved )
* {
* // TODO. make this nice.
* }
*/
else
{
// do nothing.
}
// now draw entries in box..
int unnamedCount = 0;
for (int i = 0; i < plots.Count; ++i)
{
IPlot p = (IPlot)plots[i];
float lineXPos = xPos + hSpacing;
float lineYPos = yPos + vSpacing + (float)i * (vSpacing + maxHt);
p.DrawLegendLine(g, new RectangleF(lineXPos, lineYPos, lineLength, lineHeight));
float textXPos = lineXPos + hSpacing + lineLength;
float textYPos = lineYPos;
string label = p.Label;
if (label == "")
{
unnamedCount += 1;
label = "Series " + unnamedCount.ToString();
}
g.DrawString(label, FontScaler.scaleFont(Font, scale),
new SolidBrush(Color.Black), textXPos, textYPos);
}
return(new RectangleF(xPos, yPos, totalWidth, totalHeight));
}
public PolarGrapher(IPlot plotter)
{
this.plotter = plotter;
plotter.plot_axes();
}
public SkewPlotter(IPlot base_plotter, Point skew)
{
this.base_plotter = base_plotter;
this.skew = skew;
}
/// <summary>
/// Returns the y-axis associated with a given plot (YAxis1 is at Left).
/// </summary>
/// <param name="plot">the plot to get associated y-axis.</param>
/// <returns>the axis associated with the plot.</returns>
public Axis WhichYAxis(IPlot plot)
{
int index = drawables.IndexOf (plot);
YAxisPosition p = (YAxisPosition)yAxisPositions[index];
if (p == YAxisPosition.Left)
return yAxis1;
else
return yAxis2;
}
public Story(IPlot plot)
{
this.Plot = plot;
setTarget();
}
