/// <summary>
/// Gets the parent object.
/// </summary>
/// <param name="obj">The parent object.</param>
/// <returns>The parent object</returns>
public static RivieraObject GetParent(this RivieraObject obj)
{
if (obj.Handle.Value != 0)
{
return(App.Riviera.Database.Objects.FirstOrDefault(x => x.Handle.Value == obj.Parent));
}
else
{
return(null);
}
}
/// <summary>
/// Regens the CAD object as line object
/// </summary>
/// <param name="obj">The object.</param>
/// <param name="line">The line.</param>
public static void RegenAsLine(this RivieraObject obj, ref Line line)
{
if (obj.CADGeometry == null)
{
line = new Line(obj.Start.ToPoint3d(), obj.End.ToPoint3d());
}
else
{
line.StartPoint = obj.Start.ToPoint3d();
line.EndPoint = obj.End.ToPoint3d();
}
}
/// <summary>
/// Sows in the specified direction.
/// </summary>
/// <typeparam name="T">The user interface menu type</typeparam>
/// <param name="dir">The sowing direction.</param>
/// <param name="menu">The user menu.</param>
/// <param name="baseObject">The base object.</param>
/// <param name="startState">The start state.</param>
public void Sow(ArrowDirection dir, RivieraObject baseObject, int startState = 0)
{
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
RivieraObject obj = baseObject;
this.CurrentState = startState;
while (dir != ArrowDirection.NONE)
{
obj = this.TransitionMatrix[this.CurrentState].Transition(dir, out this.CurrentState, obj, this.PickSizes(dir));
ed.Regen();
dir = this.PickArrow(obj as ISowable);
}
}
/// <summary>
/// Translates between nodes with the specified token.
/// </summary>
/// <param name="token">The transition token.</param>
/// <param name="nextState">The transition end state.</param>
/// <param name="inputObject">The input object.</param>
/// <param name="sizes">The Riviera given sizes.</param>
/// <returns>The sowed element</returns>
public RivieraObject Transition(ArrowDirection token, out int nextState, RivieraObject inputObject, params RivieraMeasure[] sizes)
{
RivieraObject obj = null;
if (Transitions.ContainsKey(token))
{
nextState = Connections[token];
obj = Transitions[token](inputObject, token, sizes);
}
else
{
nextState = Connections[ArrowDirection.NONE];
}
return(obj);
}
/// <summary>
/// Sows as L panel.
/// </summary>
/// <param name="doc">The active document.</param>
/// <param name="tr">The active transaction.</param>
protected RivieraObject InsertLPanel(RivieraObject obj, ArrowDirection direction, params RivieraMeasure[] sizes)
{
//1: Se calcula la dirección y orientación del panel
Point3d end, start;
//Siempre se inserta en la posición inicial del bloque insertado
//Selección de la dirección
start = obj.Start.ToPoint3d();
end = direction.IsFront() ? start.ToPoint2d().ToPoint2dByPolar(1, obj.Angle).ToPoint3d() //Misma dirección
: start.ToPoint2d().ToPoint2dByPolar(1, obj.Angle + Math.PI).ToPoint3d(); //Dirección Invertida
//Selección de la rotación
SweepDirection rotation = direction.IsLeft() ? SweepDirection.Counterclockwise : SweepDirection.Clockwise;
//Seleccion de tipo de L
BordeoLPanelAngle lAng = direction.GetArrowDirectionName().Contains("90") ? BordeoLPanelAngle.ANG_90 : BordeoLPanelAngle.ANG_135;
//Se convierten los tamaños a tamaños de bordeo
IEnumerable <LPanelMeasure> pSizes = sizes.Select(x => x as LPanelMeasure);
//El panel inferios se usa como distancia base del arreglo de paneles.
var first = sizes[0] as LPanelMeasure;
//Se crea el panel
BordeoLPanelStack stack = new BordeoLPanelStack(start, end, first, rotation, lAng);
//Se agregan los tamaños superiores
for (int i = 1; i < sizes.Length; i++)
{
stack.AddPanel(sizes[i] as LPanelMeasure);
}
//Se dibuja en el plano y se borra el panel anterior
RivieraObject objParent = obj.GetParent();
this.DrawObjects((Document doc, Transaction tr, RivieraObject[] objs) => obj.Delete(tr), stack);
if (objParent != null)
{
objParent.Connect(direction, stack);
}
else
{
var db = App.Riviera.Database.Objects;
if (db.FirstOrDefault(x => x.Handle.Value == stack.Handle.Value) == null)
{
db.Add(stack);
}
}
//Se regresa el stack como objeto creado
return(stack);
}
public void ContinueSowing()
{
App.RunCommand(
delegate()
{
try
{
ObjectId entId;
int state;
if (Picker.ObjectId("Selecciona un panel para continuar la inserción", out entId, typeof(Line), typeof(Polyline)))
{
RivieraObject rivObj = App.Riviera.Database.Objects.FirstOrDefault(x => x.Id == entId);
if (rivObj != null)
{
TabBordeoMenu ctrl = this.Controls.Where(x => x is TabBordeoMenu).FirstOrDefault() as TabBordeoMenu;
BordeoSower sow = new BordeoSower(ctrl);
if (rivObj is BordeoPanelStack)
{
state = 1;
}
else if (rivObj is BordeoLPanelStack)
{
state = 2;
}
else
{
state = 0;
}
var dir = sow.PickArrow(rivObj as ISowable);
sow.Sow(dir, rivObj, state);
}
else
{
Selector.Ed.WriteMessage("No es un elemento de bordeo");
}
}
}
catch (System.Exception exc)
{
Selector.Ed.WriteMessage(exc.Message);
}
});
}
/// <summary>
/// Sows as Linear panel.
/// </summary>
/// <param name="doc">The active document.</param>
/// <param name="tr">The active transaction.</param>
protected RivieraObject InsertLinearPanel(RivieraObject obj, ArrowDirection direction, params RivieraMeasure[] sizes)
{
//1: Se calcula la dirección y orientación del panel
Point3d end, start;
if (direction == ArrowDirection.FRONT) //Misma dirección
{
if (obj is BordeoLPanelStack)
{
Polyline pl = (obj as BordeoLPanelStack).FirstOrDefault().PanelGeometry;
start = obj.End.ToPoint3d();
double angle = pl.GetPoint2dAt(2).GetVectorTo(pl.GetPoint2dAt(3)).Angle;
end = start.ToPoint2d().ToPoint2dByPolar(1, angle).ToPoint3d();
}
else
{
start = obj.End.ToPoint3d();
end = start.ToPoint2d().ToPoint2dByPolar(1, obj.Angle).ToPoint3d();
}
}
else //Se invierte la dirección
{
start = obj.Start.ToPoint3d();
end = start.ToPoint2d().ToPoint2dByPolar(1, obj.Angle + Math.PI).ToPoint3d();
}
//Se convierten los tamaños a tamaños de bordeo
IEnumerable <PanelMeasure> pSizes = sizes.Select(x => x as PanelMeasure);
//El panel inferios se usa como distancia base del arreglo de paneles.
var first = sizes[0] as PanelMeasure;
//Se crea el panel
BordeoPanelStack stack = new BordeoPanelStack(start, end, first);
//Se agregan los tamaños superiores
for (int i = 1; i < sizes.Length; i++)
{
stack.AddPanel(sizes[i] as PanelMeasure);
}
//Se dibuja en el plano
this.DrawObjects(null, stack);
obj.Connect(direction, stack);
//Se regresa el stack como objeto creado
return(stack);
}
/// <summary>
/// Defines the transaction that draws the arrows of a Bordeo Entity
/// </summary>
/// <param name="doc">The active document.</param>
/// <param name="tr">The active transaction.</param>
/// <param name="input">The transaction input, needs a <see cref="ISowable"/>,a <see cref="RivieraObject"/>, start point flag as <see cref="Boolean"/> and
/// end point flag as <see cref="Boolean"/>.</param>
/// <returns>The arrows drew ids</returns>
private static ObjectIdCollection DrawArrows(Document doc, Transaction tr, params Object[] input)
{
ISowable sowEnt = (ISowable)input[0];
Boolean atStart = (Boolean)input[1],
atEnd = (Boolean)input[2];
RivieraObject obj = (RivieraObject)input[3];
ObjectIdCollection ids = new ObjectIdCollection();
if (atStart)
{
foreach (ObjectId id in sowEnt.DrawArrows(BordeoGeometryUtils.IsBack, obj.Start.ToPoint3d(), obj.Angle, tr))
{
ids.Add(id);
}
}
if (atEnd)
{
foreach (ObjectId id in sowEnt.DrawArrows(BordeoGeometryUtils.IsFront, obj.End.ToPoint3d(), obj.Angle, tr))
{
ids.Add(id);
}
}
return(ids);
}
/// <summary>
/// Picks the arrow.
/// </summary>
/// <param name="sowEntity">The sow entity.</param>
/// <param name="rivObject">The riv object.</param>
/// <param name="atStartPoint">if set to <c>true</c> [at start point].</param>
/// <param name="atEndPoint">if set to <c>true</c> [at end point].</param>
public override ArrowDirection PickArrow(ISowable sowEntity, Boolean atStartPoint = false, Boolean atEndPoint = false)
{
Editor ed = Application.DocumentManager.MdiActiveDocument.Editor;
RivieraObject rivObject = (RivieraObject)sowEntity;
String keyFront = ArrowDirection.FRONT.GetArrowDirectionName(),
keyBack = ArrowDirection.BACK.GetArrowDirectionName();
atStartPoint = !rivObject.Children.ContainsKey(keyBack) || rivObject.Children[keyBack] == 0;
atEndPoint = !rivObject.Children.ContainsKey(keyFront) || rivObject.Children[keyFront] == 0;
if (!atStartPoint && !atEndPoint)
{
return(ArrowDirection.NONE);
}
var drewIds = BordeoAutoCADTransactions.DrawArrows(sowEntity, rivObject, atStartPoint, atEndPoint);
//Se borra las direcciones de los tamaños no soportados
//this.EraseUnsupportedDirections(drewIds);
rivObject.ZoomAt(2.5d);
ed.Regen();
ArrowDirection direction = AutoCADTransactions.PickArrowDirection(sowEntity, drewIds);
ed.Regen();
return(direction);
}
/// <summary>
/// Draws the arrows.
/// </summary>
/// <param name="sowEntity">The sow entity.</param>
/// <param name="rivObject">The riviera object.</param>
/// <param name="atStartPoint">if set to <c>true</c> draw arrows [at start point].</param>
/// <param name="atEndPoint">if set to <c>true</c> draw arrows [at end point].</param>
/// <returns></returns>
public static ObjectIdCollection DrawArrows(ISowable sowEntity, RivieraObject rivObject, Boolean atStartPoint = false, Boolean atEndPoint = false)
{
return(new TransactionWrapper <Object, ObjectIdCollection>(BordeoAutoCADTransactions.DrawArrows).Run(sowEntity, atStartPoint, atEndPoint, rivObject));
}
