private void lengthTextBox_TextChanged(object sender, EventArgs e)
{
// Return if OnChange handlers have been disabled.
if (m_IsStatic)
return;
if (lengthTextBox.Text.Trim().Length==0)
{
// If we already had length info, reset it.
if (m_LengthOffset!=null)
SetNormalColour(m_LengthOffset.Point);
m_Length = new Distance();
m_LengthOffset = null;
}
else
{
// The length could have been specified by the
// user, or it could have been set as the result of
// a pointing operation. In the latter case,
// m_LengthOffset will be defined.
if (m_LengthOffset==null)
ParseLength();
else
{
// Confirm that the displayed text is the text that was
// added by OnSelectPoint. If not, the user may be trying
// to type in a length. Permit fewer chars, in case the
// user is erasing.
string keystr = String.Format("+{0}", m_LengthOffset.Point.FormattedKey);
string curstr = lengthTextBox.Text.Trim();
if (curstr.Length > keystr.Length)
{
string msg = "What are you trying to do? If you want to type in a" + System.Environment.NewLine +
"new length, you must initially delete the point ID" + System.Environment.NewLine +
"that is currently displayed.";
MessageBox.Show(msg);
return;
}
}
}
OnChange();
}
void HandleSelectPoint(PointFeature point)
{
if (m_Focus == backsightTextBox)
{
// If the user has checked the "use centre" checkbox, how
// come the user is trying to select another backsight.
// Ensure that any previously selected backsight reverts
// to its normal colour.
SetNormalColour(m_Backsight);
// Save the specified backsight.
m_Backsight = point;
// Display it (causes a call to OnChangeBacksight).
backsightTextBox.Text = String.Format("+{0}", point.FormattedKey);
// Move focus to the angle field.
angleTextBox.Focus();
return;
}
if (m_Focus == angleTextBox)
{
// The direction must be getting specified by pointing
// to two parallel points.
// Disable the backsight and "use centre" fields.
backsightTextBox.Enabled = false;
centreOfCurveCheckBox.Enabled = false;
// Define either the first or the second parallel point.
if (m_Par1!=null)
{
SetNormalColour(m_Par2);
m_Par2 = point;
}
else
{
SetNormalColour(m_Par1);
m_Par1 = point;
}
// Figure out the window text.
if (m_Par1!=null && m_Par2!=null)
angleTextBox.Text = String.Format("+{0}->{1}", m_Par1.FormattedKey, m_Par2.FormattedKey);
else
angleTextBox.Text = String.Format("+{0} & ...", m_Par1.FormattedKey);
// Move focus to the length field if we have both parallel points.
if (m_Par2!=null)
lengthTextBox.Focus();
return;
}
if (m_Focus == lengthTextBox)
{
// The length is being specified as an offset point.
// Hold on to the offset point & ensure distance is null.
if (m_LengthOffset!=null)
SetNormalColour(m_LengthOffset.Point);
m_LengthOffset = new OffsetPoint(point);
m_Length = new Distance();
// Display the window text.
lengthTextBox.Text = String.Format("+{0}", point.FormattedKey);
// Move focus to the point type.
entityTypeComboBox.Focus();
return;
}
}
bool InitOp(RadialOperation pop)
{
if (pop==null)
return false;
// Get the point the sideshot was observed from (unless
// it is already defined).
if (m_From==null)
m_From = pop.From;
// Was a backsight specified?
Direction dir = pop.Direction;
if (dir is AngleDirection)
{
AngleDirection angle = (AngleDirection)dir;
m_Backsight = angle.Backsight;
m_Radians = angle.ObservationInRadians;
if (m_Radians < 0.0)
{
m_Radians = Math.Abs(m_Radians);
m_IsClockwise = false;
}
else
m_IsClockwise = true;
// Is it a deflection?
m_IsDeflection = (dir is DeflectionDirection);
}
// Was direction specified using 2 points (not possible
// if we've already picked up a backsight).
if (m_Backsight==null)
{
ParallelDirection par = (dir as ParallelDirection);
if (par!=null)
{
m_Par1 = par.Start;
m_Par2 = par.End;
}
}
else
{
// Does the backsight point correspond to the centre of a
// circle that passes through the from-point?
double radius = Geom.Distance(m_Backsight, m_From);
if (m_Backsight.GetCircle(radius)!=null)
m_WantCentre = true;
}
// If we don't have a backsight or a parallel point, it must be a bearing.
if (!(m_Backsight!=null || m_Par1!=null))
m_Radians = dir.Bearing.Radians;
// Did the direction have an offset? If so, make a transient
// copy (specifying m_Length since it's transient).
Offset offset = dir.Offset;
if (offset!=null)
m_Offset = offset;
//m_Offset = offset.MakeNewCopy(m_Length);
// The length was either entered explicitly, or via an offset point.
Observation length = pop.Length;
Distance dist = (length as Distance);
if (dist!=null)
{
m_Length = new Distance(dist);
}
else
{
// It SHOULD be an offset point.
OffsetPoint offsetPoint = (OffsetPoint)length;
if (offsetPoint!=null)
m_LengthOffset = new OffsetPoint(offsetPoint);
}
// Remember whether a line was added.
if (pop.Line!=null)
m_WantLine = true;
return true;
}
/// <summary>
/// Parses an explicitly entered sideshot length.
/// </summary>
/// <returns>True if length parses ok.</returns>
bool ParseLength()
{
// Get the entered string.
string str = lengthTextBox.Text.Trim();
// Try to parse it.
Distance length = new Distance(str);
if (!length.IsDefined)
{
MessageBox.Show("Invalid length");
return false;
}
// Hold on to the parsed length (and ensure that any previously
// defined offset point is null -- should really be null already).
m_Length = length;
m_LengthOffset = null;
return true;
}
private void Zero()
{
m_Cmd = null;
m_Recall = null;
m_From = null;
m_Backsight = null;
m_Par1 = null;
m_Par2 = null;
m_Radians = 0.0;
m_IsClockwise = true;
m_IsDeflection = false;
m_Length = new Distance();
m_LengthOffset = null;
m_DialOff = null;
m_Offset = null;
m_Dir = null;
m_To = null;
m_Circles = new List<Circle>();
m_Focus = null;
m_WantLine = false;
m_WantCentre = false;
m_IsStatic = false;
m_PointId = null;
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="copy">The offset to copy</param>
internal OffsetPoint(OffsetPoint copy)
{
m_Point = copy.m_Point;
}
/// <summary>
/// Uses the currently displayed information to try to construct a
/// direction object.
/// </summary>
/// <returns>The constructed direction (null if a direction cannot be created
/// based on the information that's currently displayed)</returns>
Direction GetCurrentDirection()
{
Direction result = null;
// Get signed direction
double srad = (m_IsClockwise ? m_Radians : -m_Radians);
IAngle dir = new RadianValue(srad);
if (m_Backsight!=null)
{
// If we have a backsight, we could either have a regular
// angle or a deflection. To construct either, we need a
// from-point as well.
// Note that an angle of zero (passing through the backsight
// or foresight) is fine.
if (m_From!=null)
{
if (m_IsDeflection)
result = new DeflectionDirection(m_Backsight, m_From, dir);
else
result = new AngleDirection(m_Backsight, m_From, dir);
}
}
else if (m_From!=null)
{
// No backsight, so we could have either a bearing,
// or a direction defined using 2 parallel points.
// Since a bearing of zero is quite valid, we check
// the dialog field to see if this is an entered value,
// or just the initial value.
if (m_Par1!=null && m_Par2!=null)
result = new ParallelDirection(m_From, m_Par1, m_Par2);
else if (m_Radians > Constants.TINY || directionTextBox.Text.Length>0)
result = new BearingDirection(m_From, dir);
}
// If we haven't formed a direction, ignore any offset
if (result==null)
return null;
// An offset could have been specified by a point, or by
// entering a distance left or right of the direction.
Offset offset = null;
if (m_OffsetPoint!=null)
offset = new OffsetPoint(m_OffsetPoint);
else if (m_OffsetDistance!=null)
offset = new OffsetDistance(m_OffsetDistance, !m_IsRight);
// If we got an offset, include it in the direction.
if (offset!=null)
result.Offset = offset;
return result;
}
/// <summary>
/// Copy constructor.
/// </summary>
/// <param name="copy">The offset to copy</param>
internal OffsetPoint(OffsetPoint copy)
{
m_Point = copy.m_Point;
}
/// <summary>
/// Reacts to selection of the OK button in the dialog.
/// </summary>
/// <param name="wnd">The dialog window. If this matches the dialog that
/// this command knows about, the command will be executed (and, on success,
/// the dialog will be destroyed). If it's some other window, it must
/// be a sub-dialog created by our guy, so let it handle the request.</param>
/// <returns>True if command finished ok</returns>
internal override bool DialFinish(Control wnd)
{
// If it's the offset dialog that's just finished, grab info
// from it, delete it, and go to the dialog for the first
// terminal line.
ISpatialDisplay view = ActiveDisplay;
UpdateUI up = this.Update;
if (m_ParDial!=null)
{
// Get info from dialog (it'll be ONE of the two). The dialog
// should only call this function after validating that one
// of them is defined.
m_OffsetPoint = m_ParDial.OffsetPoint;
if (m_OffsetPoint==null)
m_Offset = m_ParDial.OffsetDistance;
// Destroy the dialog.
KillDialogs();
// Calculate the positions for the parallel points.
Calculate();
// Repaint what we know about.
Draw();
// And start the dialog for the first terminal line.
if (up!=null)
m_TermDial1 = new TerminalControl(up, false);
else
m_TermDial1 = new TerminalControl(this, false);
//m_TermDial1.Show();
this.Container.Display(m_TermDial1);
return true;
}
if (m_TermDial1!=null)
{
// Get the first terminal line (if any). And the position.
m_TermLine1 = m_TermDial1.TerminalLine;
m_Term1 = m_TermDial1.TerminalPosition;
// And move on to the 2nd terminal dialog.
KillDialogs();
// Repaint what we know about.
Draw();
// And start the dialog for the first terminal line.
if (up!=null)
m_TermDial2 = new TerminalControl(up, true);
else
m_TermDial2 = new TerminalControl(this, true);
this.Container.Display(m_TermDial2);
//m_TermDial2.Show();
return true;
}
if (m_TermDial2==null)
throw new Exception("ParallelLineUI.DialFinish - No dialog!");
// Get the nortthern terminal line (if any). And the position.
m_TermLine2 = m_TermDial2.TerminalLine;
m_Term2 = m_TermDial2.TerminalPosition;
// Erase everything special that we've drawn.
ErasePainting();
// And ensure the view has nothing selected (sometimes the line
// last selected had been unhighlighted, although it's end points
// stay highlighted for some reason).
EditingController.Current.ClearSelection();
// If we are doing an update, remember the changes
if (up!=null)
{
// Get the original operation.
ParallelLineOperation op = (ParallelLineOperation)up.GetOp();
if (op==null)
throw new Exception("ParallelLineUI.DialFinish - Unexpected edit type.");
// Note the offset (it SHOULD be defined)
Observation offset = null;
if (m_Offset != null)
offset = m_Offset;
else if (m_OffsetPoint != null)
offset = new OffsetPoint(m_OffsetPoint);
Debug.Assert(offset != null);
// Remember the changes as part of the UI object (the original edit remains
// unchanged for now)
UpdateItemCollection changes = op.GetUpdateItems(m_Line, offset, m_TermLine1, m_TermLine2, m_IsReversed);
if (!up.AddUpdate(op, changes))
return false;
}
else
{
Observation offset = m_Offset;
if (offset == null && m_OffsetPoint != null)
offset = new OffsetPoint(m_OffsetPoint);
Debug.Assert(offset!= null);
// Execute the edit
ParallelLineOperation op = null;
try
{
op = new ParallelLineOperation(m_Line, offset, m_TermLine1, m_TermLine2, m_IsReversed);
op.Execute();
}
catch (Exception ex)
{
MessageBox.Show(ex.StackTrace, ex.Message);
return false;
}
}
// Destroy the dialog(s).
KillDialogs();
// Get the base class to finish up.
return FinishCommand();
}
public GetDistanceControl()
{
InitializeComponent();
m_From = null;
m_ObservedDistance = null;
m_LineType = null;
m_Circle = null;
m_DistancePoint = null;
m_Distance = null;
m_OffsetPoint = null;
m_Focus = null;
}
/// <summary>
/// Displays info for a specific distance observation.
/// </summary>
/// <param name="from">The point the distance was observed from.</param>
/// <param name="obsv">The distance observation (either a <see cref="Distance"/>,
/// or an <see cref="OffsetPoint"/>)</param>
/// <param name="line">The line to show (null if no line).</param>
void ShowDistance(PointFeature from, Observation obsv, LineFeature line)
{
// If we have an arc, define its entity type and scroll the
// entity combo box to that type. Note that when the string
// is selected, it is important that m_From and m_Distance
// are null; otherwise <mf CdGetDist::OnSelChangeLineType>
// may automatically move on to the next page of the wizard
// dialog.
m_From = null;
m_Distance = null;
m_LineType = null;
if (line!=null)
{
m_LineType = line.EntityType;
lineTypeComboBox.SelectEntity(m_LineType);
}
// Define the from-point of the distance
m_From = from;
fromPointTextBox.Text = m_From.FormattedKey;
// What sort of distance observation do we have?
m_ObservedDistance = null; // m_pDistance
m_DistancePoint = null;
m_Distance = null;
if (obsv is Distance)
{
// Display the distance in the original data entry units.
Distance dist = (obsv as Distance);
m_Distance = new Distance(dist);
distanceTextBox.Text = m_Distance.Format();
// Create the appropriate distance observation (this is what
// gets picked up when we actually go to work out the intersection.
// (was on the last page of the property sheet -- see CdIntersectTwo)
m_ObservedDistance = m_Distance;
}
else
{
// It SHOULD be an offset point.
OffsetPoint off = (obsv as OffsetPoint);
if (off==null)
throw new Exception("GetDistanceControl.ShowDistance - Unexpected type of distance.");
// Get the point involved & display it's ID.
m_DistancePoint = off.Point;
distanceTextBox.Text = m_DistancePoint.FormattedKey;
// Create the appropriate distance observation
m_OffsetPoint = new OffsetPoint(m_DistancePoint);
m_ObservedDistance = m_OffsetPoint;
}
}
/// <summary>
/// Uses the currently displayed information to try to construct a
/// circle representing the distance.
/// </summary>
/// <returns>The constructed circle (null if a circle cannot be created
/// based on the information that's currently displayed)</returns>
Circle GetCurrentCircle()
{
Circle result = null;
// Undefine the address of the relevant distance observation.
m_ObservedDistance = null;
if (m_From==null)
return null;
if (m_DistancePoint!=null || (m_Distance!=null && m_Distance.Meters>Constants.TINY))
{
double radius;
// If we have an offset point, get the radius.
if (m_DistancePoint!=null)
radius = Geom.Distance(m_From, m_DistancePoint);
else
radius = m_Distance.Meters;
// Construct the circle
result = new Circle(m_From, radius);
// Create the appropriate distance observation (this is what
// gets picked up when we actually go to work out the
// intersection on the last page of the intersect dialog.
if (m_DistancePoint!=null)
{
m_OffsetPoint = new OffsetPoint(m_DistancePoint);
m_ObservedDistance = m_OffsetPoint;
}
else
m_ObservedDistance = m_Distance;
}
return result;
}