private void noTerminalCheckBox_CheckedChanged(object sender, EventArgs e)
{
// If we previously had a terminal line, erase the terminal
// position and unhighlight the arc.
ISpatialDisplay draw = m_Cmd.ActiveDisplay;
if (m_Line != null)
{
m_Cmd.ErasePainting();
}
m_Line = null;
ParallelLineUI cmd = Command;
// Draw the parallel point instead.
if (m_IsLast)
{
m_Terminal = cmd.ParallelTwo;
}
else
{
m_Terminal = cmd.ParallelOne;
}
EditingController.Current.Style(Color.Yellow).Render(draw, m_Terminal);
}
private void otherWayButton_Click(object sender, EventArgs e)
{
// Tell the command that's running this dialog.
ParallelLineUI cmd = this.Command;
cmd.ReverseArc();
}
/// <summary>
/// Tries to find a terminal line to end the parallel on.
/// </summary>
/// <returns>False if parallel positions are not available. True
/// otherwise (that does not mean that a terminal was actually found).
/// </returns>
bool FindTerminal()
{
// Get the position of the parallel point.
ParallelLineUI cmd = this.Command;
IPosition parpos;
if (m_IsLast)
{
parpos = cmd.ParallelTwo;
}
else
{
parpos = cmd.ParallelOne;
}
// The parallel point HAS to be known.
if (parpos == null)
{
MessageBox.Show("Parallel point has not been calculated");
return(false);
}
// Treat the parallel point as the initial terminal.
m_Terminal = parpos;
// Get the offset to the parallel.
double offset = cmd.GetPlanarOffset();
// Figure out a search radius (the smaller of half the offset,
// or half a centimetre at the current draw scale).
double scale = cmd.ActiveDisplay.MapScale;
ILength tol = new Length(Math.Min(offset * 0.5, scale * 0.005));
// Search for the line closest to the parallel point, and
// within the search radius. The line has to be visible
// and selectable.
CadastralMapModel map = CadastralMapModel.Current;
//m_Line = map.FindClosestLine(parpos, tol, true);
m_Line = (map.Index.QueryClosest(parpos, tol, SpatialType.Line) as LineFeature);
// If we found something, highlight it (after confirming that
// it really does intersect the parallel).
if (m_Line != null)
{
IPosition xsect = cmd.GetIntersect(m_Line, m_IsLast);
if (xsect == null)
{
m_Line = null;
}
else
{
//pView->UnHighlight(m_pArc);
//pView->Highlight(*m_pArc);
m_Terminal = xsect;
}
}
return(true);
}
internal TerminalControl(ParallelLineUI cmd, bool isLast)
{
InitializeComponent();
m_Cmd = cmd;
m_IsLast = isLast;
m_Line = null;
m_Terminal = null;
}
internal ParallelControl(ParallelLineUI ui)
{
InitializeComponent();
// Initialize everything.
SetZeroValues();
// Remember the command that's running the show (and the
// line that's the reference line for the parallel).
m_Cmd = ui;
m_Line = ui.ReferenceLine;
}
bool Calculate()
{
// Ensure any previously defined end positions have been turfed.
m_South = null;
m_North = null;
// Can't do nothing if the reference line is undefined.
if (m_Line == null)
{
return(false);
}
// Calculate the parallel points, depending on what sort of
// observation we've got.
IPosition north = null;
IPosition south = null;
bool ok = false;
// Ensure the correct sign is defined in case of an offset distance.
if (m_Offset != null)
{
if (m_IsLeft)
{
m_Offset.SetNegative();
}
else
{
m_Offset.SetPositive();
}
ok = ParallelLineUI.Calculate(m_Line, m_Offset, out south, out north);
}
else if (m_Point != null)
{
ok = ParallelLineUI.Calculate(m_Line, m_Point, out south, out north);
}
// If the calculation succeeded, allocate vertices to
// hold the results we got.
if (ok)
{
m_South = south;
m_North = north;
}
return(ok);
}
/// <summary>
/// Calculates the terminal positions for the parallel.
/// </summary>
/// <param name="refLine">The reference line.</param>
/// <param name="offset">The observed offset (either a <c>Distance</c>
/// or an <c>OffsetPoint</c>).</param>
/// <param name="term1">A line that the parallel should start on (may be null).</param>
/// <param name="term2">A line that the parallel should end on (may be null).</param>
/// <param name="spar">The start of the parallel.</param>
/// <param name="epar">The end of the parallel.</param>
/// <returns>True if calculated ok.</returns>
bool Calculate(LineFeature refLine
, Observation offset
, LineFeature term1
, LineFeature term2
, out IPosition spar
, out IPosition epar)
{
spar = epar = null;
if (!ParallelLineUI.Calculate(refLine, offset, out spar, out epar))
{
return(false);
}
// If the start of the parallel should begin on a specific
// line, get the closest intersection.
if (term1 != null)
{
spar = ParallelLineUI.GetIntersect(refLine, spar, term1);
if (spar == null)
{
throw new Exception("Parallel does not intersect terminal line.");
}
}
// And similarly for the end of the parallel.
if (term2 != null)
{
IPosition tpar = ParallelLineUI.GetIntersect(refLine, epar, term2);
if (tpar == null)
//epar = ParallelLineUI.GetIntersect(refLine, epar, term2);
//if (epar == null)
{
epar = ParallelLineUI.GetIntersect(refLine, epar, term2);
throw new Exception("Parallel does not intersect terminal line.");
}
else
{
epar = tpar;
}
}
return(true);
}
int InitUpdate()
{
// Get the creating op.
ParallelLineOperation op = UpdateOp;
if (op == null)
{
return(0);
}
ISpatialDisplay view = m_Cmd.ActiveDisplay;
ParallelLineUI cmd = Command;
// The originally produced parallel may have been
// changed to have a different offset.
// Get the line that the parallel originally terminated on (if any).
if (m_IsLast)
{
m_Line = op.Terminal2;
}
else
{
m_Line = op.Terminal1;
}
// If we didn't terminate on any particular line, that's
// the way it will remain, Otherwise confirm that the
// parallel continues to intersect it. In the event that
// the parallel no longer intersects, get another
// terminal position (and maybe a different terminal line).
if (m_Line != null)
{
m_Terminal = cmd.GetIntersect(m_Line, m_IsLast);
if (m_Terminal != null)
{
// The parallel still intersects the terminal line that was originally specified,
// so highlight the terminal line (having de-selected and unhighlighted
// anything that was previously highlighted).
m_Line.Render(view, new HighlightStyle());
}
else
{
// Get a new terminal position (preferably coincident with some other line).
// DON'T try to find a new terminal if the op is being corrected due to a
// problem in rollforward preview. In that case, we want the user to see
// where the old terminal was ... well, leave that nicety for now.
if (!FindTerminal())
{
return(-1);
}
}
}
else
{
// Parallel did not terminate on a line, so grab the start or end of the parallel line
LineFeature parLine = op.ParallelLine;
if (m_IsLast)
{
m_Terminal = parLine.EndPoint;
}
else
{
m_Terminal = parLine.StartPoint;
}
}
return(1);
}
/// <summary>
/// Reacts to the selection of a line feature.
/// </summary>
/// <param name="line">The line (if any) that has been selected.</param>
internal void SelectLine(LineFeature line)
{
ISpatialDisplay view = m_Cmd.ActiveDisplay;
IPosition xsect = null;
ParallelLineUI cmd = Command;
// Confirm that the line actually intersects the parallel.
if (line != null)
{
xsect = cmd.GetIntersect(line, m_IsLast);
if (xsect == null)
{
MessageBox.Show("Selected line does not intersect the parallel");
// De-select the line the user picked
EditingController.Current.ClearSelection();
// Re-highlight the arc if had originally (if any).
if (m_Line != null)
{
EditingController.Current.Select(m_Line);
}
return;
}
}
// Ensure everything is erased.
m_Cmd.ErasePainting();
// Hold on to new terminal position.
if (xsect != null)
{
m_Terminal = xsect;
}
else if (m_IsLast)
{
m_Terminal = cmd.ParallelTwo;
}
else
{
m_Terminal = cmd.ParallelOne;
}
// If we previously had an arc selected (and it's not the
// newly selected line), ensure that it's been unhighlighted.
//if (m_pArc && m_pArc != pArc) m_pArc->UnHighlight();
// Hold on to the new terminal arc (if any).
m_Line = line;
// If it's defined, ensure the "don't use terminal" check
// box is clear. And change the static text that tells the
// user what to do.
if (m_Line != null)
{
noTerminalCheckBox.Checked = false;
messageLabel2.Text = "If you want to terminate on a different line, select it.";
}
// Ensure everything is drawn as expected.
cmd.Draw();
// Resume focus on the Next/Finish button.
okButton.Focus();
}
private void TerminalControl_Load(object sender, EventArgs e)
{
ISpatialDisplay view = m_Cmd.ActiveDisplay;
// Get the "real" command that's running this dialog (not any update).
ParallelLineUI cmd = Command;
Debug.Assert(cmd != null);
if (m_IsLast)
{
MyCaption = "Terminal 2";
okButton.Text = "&Finish";
// If the reference line for the parallel isn't a circular
// arc, disable and hide the "Other Way" button.
if (!(cmd.ReferenceLine is ArcFeature))
{
otherWayButton.Enabled = false;
otherWayButton.Visible = false;
}
}
else
{
MyCaption = "Terminal 1";
okButton.Text = "&Next...";
// Disable (and hide) the "Other Way" button.
otherWayButton.Enabled = false;
otherWayButton.Visible = false;
}
// If we are not updating a previously created parallel,
// get a terminal position.
int state = InitUpdate();
if (state == 0 && !FindTerminal())
{
state = -1;
}
// Get out if that somehow failed.
if (state < 0)
{
m_Cmd.DialAbort(this);
return;
}
// Draw the terminal point in yellow.
EditingController.Current.Style(Color.Yellow).Render(view, m_Terminal);
// If we don't have a terminal line, alter the text that says
// that it's highlighted! And make the "don't terminate" checkbox
// invisible.
if (m_Line == null)
{
messageLabel1.Visible = false;
messageLabel2.Text = "If you want to terminate on a line, select it.";
messageLabel3.Visible = false;
noTerminalCheckBox.Visible = false;
}
}
