Annamaria Sassi
2346 lines
74 KiB
C#
2346 lines
74 KiB
C#
using Newtonsoft.Json;
|
||
using Newtonsoft.Json.Linq;
|
||
using System.Collections;
|
||
using System.Collections.ObjectModel;
|
||
using System.ComponentModel;
|
||
using System.Drawing;
|
||
using System.Runtime.Intrinsics.Arm;
|
||
using System.Xml.Serialization;
|
||
using WebWindowJWD;
|
||
using WebWindowJWD.Json;
|
||
using static WebWindowJWD.Json.WindowConst;
|
||
|
||
namespace WebWindowJWD
|
||
{
|
||
|
||
public class Window
|
||
{
|
||
public event EventHandler<OnPreviewEventArgs> OnPreview = delegate { };
|
||
|
||
private String m_sProfilePath;
|
||
public string sProfilePath
|
||
{
|
||
get
|
||
{
|
||
return m_sProfilePath;
|
||
}
|
||
set
|
||
{
|
||
m_sProfilePath = value;
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<Frame> m_AreaList = new ObservableCollection<Frame>();
|
||
public ObservableCollection<Frame> AreaList
|
||
{
|
||
get
|
||
{
|
||
return m_AreaList;
|
||
}
|
||
set
|
||
{
|
||
m_AreaList = value;
|
||
}
|
||
}
|
||
|
||
internal JsonWindow Serialize()
|
||
{
|
||
JsonWindow JsonWindow = new JsonWindow(sProfilePath);
|
||
foreach (var Area in AreaList)
|
||
JsonWindow.AreaList.Add(Area.Serialize());
|
||
return JsonWindow;
|
||
}
|
||
|
||
internal string sSerialized()
|
||
{
|
||
return JsonConvert.SerializeObject(Serialize(), Formatting.Indented);
|
||
|
||
}
|
||
|
||
internal void OnUpdatePreview(string sJwd)
|
||
{
|
||
OnPreviewEventArgs e = new OnPreviewEventArgs(sJwd);
|
||
EventHandler<OnPreviewEventArgs> handler = OnPreview;
|
||
if (handler != null)
|
||
{
|
||
handler(this, e);
|
||
}
|
||
}
|
||
}
|
||
|
||
public class OnPreviewEventArgs : EventArgs
|
||
{
|
||
public string sJwd;
|
||
|
||
public OnPreviewEventArgs(string sJwd)
|
||
{
|
||
this.sJwd = sJwd;
|
||
}
|
||
}
|
||
|
||
public abstract class Area
|
||
{
|
||
|
||
protected Window m_ParentWindow;
|
||
public Window ParentWindow
|
||
{
|
||
get
|
||
{
|
||
return m_ParentWindow;
|
||
}
|
||
}
|
||
|
||
protected int m_nAreaId = -1;
|
||
public int nAreaId
|
||
{
|
||
get
|
||
{
|
||
return m_nAreaId;
|
||
}
|
||
set
|
||
{
|
||
m_nAreaId = value;
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
private List<Area> m_AreaList = new List<Area>();
|
||
public List<Area> AreaList
|
||
{
|
||
get
|
||
{
|
||
return m_AreaList;
|
||
}
|
||
set
|
||
{
|
||
m_AreaList = value;
|
||
}
|
||
}
|
||
|
||
private AreaTypes m_AreaType;
|
||
public AreaTypes AreaType
|
||
{
|
||
get
|
||
{
|
||
return m_AreaType;
|
||
}
|
||
set
|
||
{
|
||
m_AreaType = value;
|
||
//m_delDrawWindow();
|
||
}
|
||
}
|
||
internal void SetAreaType(AreaTypes AreaType)
|
||
{
|
||
m_AreaType = AreaType;
|
||
}
|
||
|
||
private Area m_ParentArea;
|
||
public Area ParentArea
|
||
{
|
||
get
|
||
{
|
||
return m_ParentArea;
|
||
}
|
||
}
|
||
internal void SetParentArea(Area ParentArea)
|
||
{
|
||
m_ParentArea = ParentArea;
|
||
}
|
||
|
||
public Area(Area ParentArea, Window ParentWindow)
|
||
{
|
||
m_ParentWindow = ParentWindow;
|
||
m_ParentArea = ParentArea;
|
||
}
|
||
|
||
internal abstract JsonArea Serialize();
|
||
}
|
||
|
||
public class Frame : Area
|
||
{
|
||
private ObservableCollection<IdNameStruct> m_ShapeList = new ObservableCollection<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)Shapes.RECTANGLE, "Rectangle"),
|
||
new IdNameStruct((int)Shapes.RIGHTCHAMFER, "Right Chamfer"),
|
||
new IdNameStruct((int)Shapes.LEFTCHAMFER, "Left Chamfer"),
|
||
new IdNameStruct((int)Shapes.DOUBLECHAMFER, "Double Chamfer"),
|
||
new IdNameStruct((int)Shapes.ARC, "Arc"),
|
||
new IdNameStruct((int)Shapes.ARC_FULL, "Arc Full"),
|
||
new IdNameStruct((int)Shapes.DOUBLEARC, "Double Arc"),
|
||
new IdNameStruct((int)Shapes.TRIANGLE, "Triangle")
|
||
};
|
||
public ObservableCollection<IdNameStruct> ShapeList
|
||
{
|
||
get
|
||
{
|
||
return m_ShapeList;
|
||
}
|
||
}
|
||
|
||
private Shapes m_Shape;
|
||
public Shapes Shape
|
||
{
|
||
get
|
||
{
|
||
return m_Shape;
|
||
}
|
||
}
|
||
|
||
public int SelShapeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_Shape, m_ShapeList);
|
||
}
|
||
set
|
||
{
|
||
Shapes SelShape = (Shapes)IdNameStruct.IdFromInd(value, m_ShapeList);
|
||
if (m_Shape != SelShape)
|
||
{
|
||
// verifico parametri Dimension
|
||
DimensionList.Clear();
|
||
// aggiungo Dimensioni
|
||
switch (SelShape)
|
||
{
|
||
case Shapes.RECTANGLE:
|
||
case Shapes.ARC_FULL:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.RIGHTCHAMFER:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1800, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1500, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.LEFTCHAMFER:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.DOUBLECHAMFER:
|
||
case Shapes.ARC:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Full Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.DOUBLEARC:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Full Height", 2400, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.TRIANGLE:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 2000, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Height projection", 0, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.CUSTOM:
|
||
{
|
||
DimensionList.Clear();
|
||
break;
|
||
}
|
||
}
|
||
// aggiungo Joint
|
||
m_JointList.Clear();
|
||
switch (SelShape)
|
||
{
|
||
case Shapes.RECTANGLE:
|
||
case Shapes.RIGHTCHAMFER:
|
||
case Shapes.LEFTCHAMFER:
|
||
case Shapes.DOUBLECHAMFER:
|
||
case Shapes.ARC:
|
||
case Shapes.DOUBLEARC:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 4, Joints.FULL_H));
|
||
break;
|
||
}
|
||
|
||
case Shapes.ARC_FULL:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.ANGLED));
|
||
JointList.Add(new Joint(this, 4, Joints.ANGLED));
|
||
break;
|
||
}
|
||
|
||
case Shapes.TRIANGLE:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.ANGLED));
|
||
break;
|
||
}
|
||
|
||
case Shapes.CUSTOM:
|
||
{
|
||
JointList.Clear();
|
||
break;
|
||
}
|
||
}
|
||
m_Shape = SelShape;
|
||
}
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
internal void SetSelShape(Shapes Value)
|
||
{
|
||
DimensionList.Clear();
|
||
// aggiungo Dimension
|
||
switch (Value)
|
||
{
|
||
case Shapes.RECTANGLE:
|
||
case Shapes.ARC_FULL:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.RIGHTCHAMFER:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1800, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1500, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.LEFTCHAMFER:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Left Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Right Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.DOUBLECHAMFER:
|
||
case Shapes.ARC:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Full Height", 1800, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.DOUBLEARC:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Full Height", 2400, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.TRIANGLE:
|
||
{
|
||
DimensionList.Add(new FrameDimension(this, 1, "Width", 2000, true));
|
||
DimensionList.Add(new FrameDimension(this, 2, "Height", 1500, true));
|
||
DimensionList.Add(new FrameDimension(this, 3, "Height projection", 0, true));
|
||
break;
|
||
}
|
||
|
||
case Shapes.CUSTOM:
|
||
{
|
||
DimensionList.Clear();
|
||
break;
|
||
}
|
||
}
|
||
// aggiungo Joint
|
||
int nJointQty = 4;
|
||
switch (Value)
|
||
{
|
||
case Shapes.RECTANGLE:
|
||
case Shapes.RIGHTCHAMFER:
|
||
case Shapes.LEFTCHAMFER:
|
||
case Shapes.DOUBLECHAMFER:
|
||
case Shapes.ARC:
|
||
case Shapes.DOUBLEARC:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 4, Joints.FULL_H));
|
||
break;
|
||
}
|
||
|
||
case Shapes.ARC_FULL:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.ANGLED));
|
||
JointList.Add(new Joint(this, 4, Joints.ANGLED));
|
||
break;
|
||
}
|
||
|
||
case Shapes.TRIANGLE:
|
||
{
|
||
JointList.Add(new Joint(this, 1, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 2, Joints.FULL_H));
|
||
JointList.Add(new Joint(this, 3, Joints.ANGLED));
|
||
break;
|
||
}
|
||
|
||
case Shapes.CUSTOM:
|
||
{
|
||
JointList.Clear();
|
||
break;
|
||
}
|
||
}
|
||
m_Shape = Value;
|
||
}
|
||
|
||
private ObservableCollection<FrameDimension> m_DimensionList = new ObservableCollection<FrameDimension>();
|
||
public ObservableCollection<FrameDimension> DimensionList
|
||
{
|
||
get
|
||
{
|
||
return m_DimensionList;
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<Joint> m_JointList = new ObservableCollection<Joint>();
|
||
public ObservableCollection<Joint> JointList
|
||
{
|
||
get
|
||
{
|
||
return m_JointList;
|
||
}
|
||
set
|
||
{
|
||
m_JointList = value;
|
||
}
|
||
}
|
||
|
||
private bool m_bBottomRail;
|
||
public bool BottomRail
|
||
{
|
||
get
|
||
{
|
||
return m_bBottomRail;
|
||
}
|
||
set
|
||
{
|
||
m_bBottomRail = value;
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetBottomRail(bool bBottomRail)
|
||
{
|
||
m_bBottomRail = bBottomRail;
|
||
}
|
||
|
||
private int m_nBottomRailQty = 0;
|
||
public int BottomRailQty
|
||
{
|
||
get
|
||
{
|
||
return m_nBottomRailQty;
|
||
}
|
||
set
|
||
{
|
||
m_nBottomRailQty = value;
|
||
if (m_nBottomRailQty > 0)
|
||
{
|
||
m_bBottomRail = true;
|
||
}
|
||
else
|
||
{
|
||
m_bBottomRail = false;
|
||
}
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetBottomRailQty(int nBottomRailQty)
|
||
{
|
||
m_nBottomRailQty = nBottomRailQty;
|
||
}
|
||
|
||
private ObservableCollection<Curve> m_Outline;
|
||
public ObservableCollection<Curve> Outline
|
||
{
|
||
get
|
||
{
|
||
return m_Outline;
|
||
}
|
||
set
|
||
{
|
||
m_Outline = value;
|
||
}
|
||
}
|
||
|
||
public Frame(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
||
{
|
||
}
|
||
|
||
internal static Area CreateFrame(Window Window)
|
||
{
|
||
Frame NewFrame = new Frame(null, Window);
|
||
NewFrame.SetAreaType(AreaTypes.FRAME);
|
||
NewFrame.SetSelShape(Shapes.RECTANGLE);
|
||
NewFrame.SetBottomRail(false);
|
||
NewFrame.SetBottomRailQty(0);
|
||
return NewFrame;
|
||
}
|
||
|
||
private LuaShapes ConvertShape(Shapes value)
|
||
{
|
||
switch (value)
|
||
{
|
||
case Shapes.RECTANGLE:
|
||
{
|
||
return LuaShapes.RECT;
|
||
}
|
||
|
||
case Shapes.RIGHTCHAMFER:
|
||
{
|
||
return LuaShapes.CHAMFER_SIDE;
|
||
}
|
||
|
||
case Shapes.LEFTCHAMFER:
|
||
{
|
||
return LuaShapes.CHAMFER_SIDE;
|
||
}
|
||
|
||
case Shapes.DOUBLECHAMFER:
|
||
{
|
||
return LuaShapes.CHAMFER;
|
||
}
|
||
|
||
case Shapes.ARC:
|
||
{
|
||
return LuaShapes.SEGMENTAL_ARC;
|
||
}
|
||
|
||
case Shapes.ARC_FULL:
|
||
{
|
||
return LuaShapes.ROUND_ARC;
|
||
}
|
||
|
||
case Shapes.DOUBLEARC:
|
||
{
|
||
return LuaShapes.POINTED_ARC;
|
||
}
|
||
|
||
case Shapes.TRIANGLE:
|
||
{
|
||
return LuaShapes.TRIANGLE;
|
||
}
|
||
|
||
default:
|
||
{
|
||
return LuaShapes.RECT;
|
||
}
|
||
}
|
||
}
|
||
|
||
internal override JsonArea Serialize()
|
||
{
|
||
JsonFrame JsonFrame = new JsonFrame(m_Shape, m_bBottomRail, m_nBottomRailQty);
|
||
foreach (var Dimension in DimensionList)
|
||
JsonFrame.DimensionList.Add(Dimension.Serialize());
|
||
foreach (var Joint in JointList)
|
||
JsonFrame.JointList.Add(Joint.Serialize());
|
||
foreach (var Area in AreaList)
|
||
JsonFrame.AreaList.Add(Area.Serialize());
|
||
return JsonFrame;
|
||
}
|
||
}
|
||
|
||
public class Sash : Area
|
||
{
|
||
public int nSashQty
|
||
{
|
||
get
|
||
{
|
||
return m_SashList.Count > 0 ? m_SashList.Count : 1;
|
||
}
|
||
set
|
||
{
|
||
if (value > m_SashList.Count)
|
||
{
|
||
// recupero larghezza ultimo
|
||
double dLastDimension = 100;
|
||
double dNewDimension = 100;
|
||
if (m_SashList.Count > 0)
|
||
{
|
||
dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
|
||
dNewDimension = dLastDimension / (value + 1 - nSashQty);
|
||
m_SashList[m_SashList.Count - 1].SetDimension(dNewDimension);
|
||
}
|
||
else
|
||
dNewDimension = dLastDimension / (value + 1 - nSashQty);
|
||
// aggiungo area Sash di default
|
||
for (var SplitIndex = m_SashList.Count; SplitIndex <= value - 1; SplitIndex++)
|
||
{
|
||
SashList.Add(new SashDimension(dNewDimension, true, this));
|
||
}
|
||
}
|
||
else if (value < m_SashList.Count)
|
||
{
|
||
double dLastDimension = 0;
|
||
for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
||
{
|
||
dLastDimension += m_SashList[SplitIndex].dDimension;
|
||
SashList.RemoveAt(SplitIndex);
|
||
}
|
||
dLastDimension += m_SashList[SashList.Count - 1].dDimension;
|
||
SashList[SashList.Count - 1].SetDimension(dLastDimension);
|
||
}
|
||
if (m_SashList.Count == 1)
|
||
{
|
||
List<Area> ContentArea = new List<Area>();
|
||
while (AreaList.Count > 0)
|
||
{
|
||
if (AreaList.Count == 1 & AreaList[0].AreaList.Count > 0)
|
||
{
|
||
foreach (Area selArea in AreaList[0].AreaList)
|
||
{
|
||
ContentArea.Add(selArea);
|
||
}
|
||
}
|
||
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
||
}
|
||
if (ContentArea.Count > 0)
|
||
{
|
||
AreaList = ContentArea;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
List<Area> ContentArea = new List<Area>();
|
||
if (AreaList.Count == 1 & SashList.Count > AreaList.Count)
|
||
{
|
||
ContentArea.Add(AreaList.ElementAt(0));
|
||
AreaList.Clear();
|
||
}
|
||
for (int SplitIndex = AreaList.Count; SplitIndex <= SashList.Count - 1; SplitIndex++)
|
||
{
|
||
AreaList.Add(Splitted.CreateSplitted(this));
|
||
}
|
||
for (int SplitIndex = SashList.Count; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
|
||
{
|
||
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
||
}
|
||
if (AreaList[AreaList.Count - 1].AreaList.Count == 0)
|
||
{
|
||
if (ContentArea.Count > 0)
|
||
{
|
||
for (int SplitIndex = 0; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
|
||
{
|
||
if (SplitIndex == 0)
|
||
{
|
||
AreaList[0].AreaList.Add(ContentArea[0]);
|
||
}
|
||
else
|
||
{
|
||
AreaList[SplitIndex].AreaList.Add(Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS));
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AreaList[AreaList.Count - 1].AreaList.Add(Fill.CreateFill(AreaList[AreaList.Count - 1], FillTypes.GLASS));
|
||
//AreaList[AreaList.Count - 1] = AreaList[AreaList.Count - 2];
|
||
}
|
||
}
|
||
}
|
||
//RefreshHardwareList();
|
||
RefreshHardwareOptionList();
|
||
//SetFirstHardware();
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetSashQty(int Qty)
|
||
{
|
||
if (Qty > m_SashList.Count)
|
||
{
|
||
// recupero larghezza ultimo
|
||
double dLastDimension = 100;
|
||
double dNewDimension = 100;
|
||
if (m_SashList.Count > 0)
|
||
{
|
||
dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
|
||
dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
|
||
m_SashList[m_SashList.Count - 1].dDimension = dNewDimension;
|
||
}
|
||
else
|
||
dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
|
||
// aggiungo area Sash di default
|
||
for (var SplitIndex = m_SashList.Count; SplitIndex <= Qty - 1; SplitIndex++)
|
||
SashList.Add(new SashDimension(dNewDimension, true, this));
|
||
}
|
||
else if (Qty < m_SashList.Count)
|
||
{
|
||
for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
|
||
SashList.RemoveAt(SplitIndex);
|
||
}
|
||
}
|
||
|
||
private List<IdNameStruct> m_OrientationSashTypeList = new List<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)OrientationSash.VERTICAL, "Vertical"),
|
||
new IdNameStruct((int)OrientationSash.HORIZONTAL, "Horizontal"),
|
||
};
|
||
public List<IdNameStruct> OrientationSashTypeList
|
||
{
|
||
get
|
||
{
|
||
return m_OrientationSashTypeList;
|
||
}
|
||
}
|
||
|
||
private OrientationSash m_SelOrientationSashType;
|
||
public OrientationSash SelOrientationSashType
|
||
{
|
||
get
|
||
{
|
||
return m_SelOrientationSashType;
|
||
}
|
||
set
|
||
{
|
||
m_SelOrientationSashType = value;
|
||
}
|
||
}
|
||
|
||
public OrientationSash OrientationSashType
|
||
{
|
||
get
|
||
{
|
||
return (OrientationSash)m_SelOrientationSashType;
|
||
}
|
||
}
|
||
internal void SetOrientationSashType(OrientationSash value)
|
||
{
|
||
m_SelOrientationSashType = value;
|
||
}
|
||
public int SelOrientationSashTypeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_SelOrientationSashType, m_OrientationSashTypeList);
|
||
}
|
||
set
|
||
{
|
||
m_SelOrientationSashType = (OrientationSash)IdNameStruct.IdFromInd(value, m_OrientationSashTypeList);
|
||
if (value == 0)
|
||
{
|
||
m_bIsSashVertical = true;
|
||
}
|
||
else
|
||
{
|
||
m_bIsSashVertical = false;
|
||
}
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
|
||
private bool m_bIsSashVertical;
|
||
public bool bIsSashVertical
|
||
{
|
||
get
|
||
{
|
||
return m_bIsSashVertical;
|
||
}
|
||
set
|
||
{
|
||
m_bIsSashVertical = value;
|
||
}
|
||
}
|
||
internal void SetIsSashVertical(bool IsSashVertical)
|
||
{
|
||
m_bIsSashVertical = IsSashVertical;
|
||
if (IsSashVertical)
|
||
{
|
||
m_SelOrientationSashType = OrientationSash.VERTICAL;
|
||
}
|
||
else
|
||
{
|
||
m_SelOrientationSashType = OrientationSash.HORIZONTAL;
|
||
}
|
||
}
|
||
|
||
private bool m_bIsMeasureGlass;
|
||
public bool bIsMeasureGlass
|
||
{
|
||
get
|
||
{
|
||
return m_bIsMeasureGlass;
|
||
}
|
||
set
|
||
{
|
||
m_bIsMeasureGlass = value;
|
||
}
|
||
}
|
||
internal void SetIsMeasureGlass(bool IsMeasureGlass)
|
||
{
|
||
m_bIsMeasureGlass = IsMeasureGlass;
|
||
}
|
||
|
||
private ObservableCollection<SashDimension> m_SashList = new ObservableCollection<SashDimension>();
|
||
public ObservableCollection<SashDimension> SashList
|
||
{
|
||
get
|
||
{
|
||
return m_SashList;
|
||
}
|
||
set
|
||
{
|
||
m_SashList = value;
|
||
}
|
||
}
|
||
|
||
private SashTypes m_SashType;
|
||
public SashTypes SashType
|
||
{
|
||
get
|
||
{
|
||
return m_SashType;
|
||
}
|
||
set
|
||
{
|
||
m_SashType = value;
|
||
}
|
||
}
|
||
internal void SetSashType(SashTypes SashType)
|
||
{
|
||
m_SashType = SashType;
|
||
}
|
||
|
||
private ObservableCollection<Joint> m_JointList = new ObservableCollection<Joint>();
|
||
public ObservableCollection<Joint> JointList
|
||
{
|
||
get
|
||
{
|
||
return m_JointList;
|
||
}
|
||
set
|
||
{
|
||
m_JointList = value;
|
||
}
|
||
}
|
||
|
||
private bool m_bSashBottomRail;
|
||
public bool SashBottomRail
|
||
{
|
||
get
|
||
{
|
||
return m_bSashBottomRail;
|
||
}
|
||
set
|
||
{
|
||
m_bSashBottomRail = value;
|
||
}
|
||
}
|
||
internal void SetSashBottomRail(bool bBottomRail)
|
||
{
|
||
m_bSashBottomRail = bBottomRail;
|
||
}
|
||
|
||
private int m_nSashBottomRailQty;
|
||
public int SashBottomRailQty
|
||
{
|
||
get
|
||
{
|
||
return m_nSashBottomRailQty;
|
||
}
|
||
set
|
||
{
|
||
m_nSashBottomRailQty = value;
|
||
if (m_nSashBottomRailQty > 0)
|
||
{
|
||
m_bSashBottomRail = true;
|
||
}
|
||
else
|
||
{
|
||
m_bSashBottomRail = false;
|
||
}
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetSashBottomRailQty(int nBottomRailQty)
|
||
{
|
||
m_nSashBottomRailQty = nBottomRailQty;
|
||
}
|
||
|
||
private bool m_bIsPercentage = true;
|
||
public bool bIsPercentage
|
||
{
|
||
get
|
||
{
|
||
return m_bIsPercentage;
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<Hardware> m_HardwareList = new ObservableCollection<Hardware>();
|
||
public ObservableCollection<Hardware> HardwareList
|
||
{
|
||
get
|
||
{
|
||
return m_HardwareList;
|
||
}
|
||
}
|
||
|
||
private Hardware m_SelHardware;
|
||
//public Hardware SelHardware
|
||
//{
|
||
// get
|
||
// {
|
||
// return m_SelHardware;
|
||
// }
|
||
// set
|
||
// {
|
||
// m_SelHardware = value;
|
||
// if (m_SelHardware != null && m_SelHardware.sId != "000000")
|
||
// {
|
||
// string sHwdOptPath = "";
|
||
// var gf = EgtLuaCreateGlobTable("WDG");
|
||
// var tft = EgtLuaSetGlobIntVar("WDG.AREAID", m_nAreaId);
|
||
// var tfy = EgtLuaSetGlobStringVar("WDG.HDWFAVOURITE", value.sId);
|
||
// SashDimension HandleSash = m_SashList.FirstOrDefault(x => x.bHasHandle);
|
||
// string sHandle = "Dx";
|
||
// switch (GetOpeningSide(HandleSash.OpeningType))
|
||
// {
|
||
// case object _ when OpeningSides.LEFT:
|
||
// {
|
||
// sHandle = "Sx";
|
||
// break;
|
||
// }
|
||
|
||
// case object _ when OpeningSides.RIGHT:
|
||
// {
|
||
// sHandle = "Dx";
|
||
// break;
|
||
// }
|
||
// }
|
||
// var tfd = EgtLuaSetGlobStringVar("WDG.HDWHANDLE", sHandle);
|
||
// var tlt = EgtLuaCallFunction("WinCreate_GetHardwareOptionPath");
|
||
// var tltf = EgtLuaGetGlobStringVar("WDG.HWDOPTPATH", sHwdOptPath);
|
||
// if (!string.IsNullOrWhiteSpace(sHwdOptPath))
|
||
// {
|
||
// XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
|
||
// ParametriOpzioni HwdOptions = null/* TODO Change to default(_) if this is not a reference type */;
|
||
// string sHdwOptPath = Path.ChangeExtension(sHwdOptPath, ".opt");
|
||
// bool bHdwOptFound = false;
|
||
// for (var WaitIndex = 0; WaitIndex <= 100; WaitIndex++)
|
||
// {
|
||
// if (File.Exists(sHdwOptPath))
|
||
// {
|
||
// bHdwOptFound = true;
|
||
// break;
|
||
// }
|
||
// System.Threading.Thread.Sleep(100);
|
||
// }
|
||
// if (bHdwOptFound)
|
||
// {
|
||
// string sHwdOptText = "";
|
||
// try
|
||
// {
|
||
// sHwdOptText = File.ReadAllText(sHdwOptPath);
|
||
// }
|
||
// catch (Exception ex)
|
||
// {
|
||
// EgtOutLog("Hardware file opt not found or read!");
|
||
// }
|
||
// if (!string.IsNullOrWhiteSpace(sHwdOptText))
|
||
// {
|
||
// using (TextReader reader = new StringReader(sHwdOptText))
|
||
// {
|
||
// HwdOptions = serializer.Deserialize(reader);
|
||
// }
|
||
// if (!IsNothing(HwdOptions))
|
||
// {
|
||
// m_HwdOptionList.Clear();
|
||
// foreach (var HdwOption in HwdOptions.Items)
|
||
// m_HwdOptionList.Add(new AGBOption(HdwOption));
|
||
// NotifyPropertyChanged(nameof(HwdOptionList));
|
||
// }
|
||
// }
|
||
// }
|
||
// var ud = EgtLuaResetGlobVar("WDG");
|
||
// }
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
//internal void SetSelHardware(Hardware value)
|
||
//{
|
||
// m_SelHardware = value;
|
||
//}
|
||
|
||
//internal void SetSelHardwareFromId(string sId)
|
||
//{
|
||
// m_SelHardware = m_HardwareList.FirstOrDefault(x => x.sId == sId);
|
||
// if (IsNothing(m_SelHardware))
|
||
// m_SelHardware = m_HardwareList(0);
|
||
//}
|
||
|
||
//internal void SetFirstHardware()
|
||
//{
|
||
// if (m_HardwareList.Count > 0)
|
||
// {
|
||
// m_SelHardware = m_HardwareList(0);
|
||
// }
|
||
//}
|
||
|
||
private ObservableCollection<AGBOption> m_HwdOptionList = new ObservableCollection<AGBOption>();
|
||
public ObservableCollection<AGBOption> HwdOptionList
|
||
{
|
||
get
|
||
{
|
||
return m_HwdOptionList;
|
||
}
|
||
}
|
||
|
||
public Sash(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
||
{
|
||
}
|
||
|
||
internal static Sash CreateSash(Area Area)
|
||
{
|
||
Sash NewSash = new Sash(Area, Area.ParentWindow);
|
||
NewSash.SetAreaType(AreaTypes.SASH);
|
||
NewSash.SetSashQty(1);
|
||
NewSash.SetOrientationSashType(OrientationSash.VERTICAL);
|
||
NewSash.SetIsSashVertical(true);
|
||
// recupero numero di lati dell'area contenitore
|
||
//int nOutlineLayerId = EgtGetFirstNameInGroup(Area.nAreaId, WIN_OUTLINE);
|
||
//int nJointQty = EgtGetGroupObjs(nOutlineLayerId);
|
||
//for (var JointIndex = 0; JointIndex <= nJointQty - 1; JointIndex++)
|
||
// NewSash.JointList.Add(new Joint(JointIndex + 1, Joints.FULL_H));
|
||
NewSash.SetSashBottomRail(false);
|
||
NewSash.SetSashBottomRailQty(0);
|
||
//NewSash.RefreshHardwareList();
|
||
NewSash.RefreshHardwareOptionList();
|
||
//NewSash.SetFirstHardware();
|
||
return NewSash;
|
||
}
|
||
|
||
internal OpeningTypes GetOpeningType(Openings OpeningType)
|
||
{
|
||
switch (OpeningType)
|
||
{
|
||
case Openings.TURNONLY_LEFT:
|
||
case Openings.TURNONLY_RIGHT:
|
||
{
|
||
return OpeningTypes.TURNONLY;
|
||
}
|
||
|
||
case Openings.TILTTURN_LEFT:
|
||
case Openings.TILTTURN_RIGHT:
|
||
{
|
||
return OpeningTypes.TILTTURN;
|
||
}
|
||
|
||
case Openings.TILTONLY_TOP:
|
||
case Openings.TILTONLY_BOTTOM:
|
||
{
|
||
return OpeningTypes.TILTONLY;
|
||
}
|
||
|
||
case Openings.PIVOT:
|
||
{
|
||
return OpeningTypes.PIVOT;
|
||
}
|
||
|
||
case Openings.FIXED:
|
||
{
|
||
return OpeningTypes.FIXED;
|
||
}
|
||
|
||
case Openings.COMPLANARSLIDE_LEFT:
|
||
case Openings.COMPLANARSLIDE_RIGHT:
|
||
{
|
||
return OpeningTypes.COMPLANARSLIDE;
|
||
}
|
||
|
||
case Openings.LIFTSLIDE_LEFT:
|
||
case Openings.LIFTSLIDE_RIGHT:
|
||
{
|
||
return OpeningTypes.LIFTSLIDE;
|
||
}
|
||
|
||
default:
|
||
{
|
||
return OpeningTypes.NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
private string ConvertOpeningType()
|
||
{
|
||
if (m_SashList.Any(x => GetOpeningType(x.OpeningType) == OpeningTypes.TILTTURN))
|
||
return "AR";
|
||
else
|
||
switch (GetOpeningType(m_SashList[0].OpeningType))
|
||
{
|
||
case OpeningTypes.TURNONLY:
|
||
{
|
||
return "AB";
|
||
}
|
||
|
||
case OpeningTypes.TILTONLY:
|
||
{
|
||
return "VA";
|
||
}
|
||
|
||
case OpeningTypes.PIVOT:
|
||
{
|
||
return "BI";
|
||
}
|
||
|
||
case OpeningTypes.COMPLANARSLIDE:
|
||
{
|
||
return "CO";
|
||
}
|
||
|
||
case OpeningTypes.LIFTSLIDE:
|
||
{
|
||
return "AS";
|
||
}
|
||
|
||
default:
|
||
{
|
||
return "";
|
||
}
|
||
}
|
||
}
|
||
|
||
//internal void RefreshHardwareList()
|
||
//{
|
||
// m_HardwareList.Clear();
|
||
// string sSashShape = FindSashShape();
|
||
// string sOpeningType = ConvertOpeningType();
|
||
// m_HardwareList = new ObservableCollection<Hardware>(from Hardware in Map.refManageWindowVM.HardwareList
|
||
// where Hardware.sId == "000000" || (Hardware.nSashQty == nSashQty && Hardware.sShape == sSashShape && Hardware.sOpeningType == sOpeningType)
|
||
// select Hardware);
|
||
//}
|
||
|
||
internal void RefreshHardwareOptionList()
|
||
{
|
||
m_HwdOptionList.Clear();
|
||
}
|
||
|
||
internal OpeningSides GetOpeningSide(Openings OpeningType)
|
||
{
|
||
switch (OpeningType)
|
||
{
|
||
case Openings.TURNONLY_LEFT:
|
||
case Openings.TILTTURN_LEFT:
|
||
case Openings.TILTONLY_TOP:
|
||
case Openings.COMPLANARSLIDE_LEFT:
|
||
case Openings.LIFTSLIDE_LEFT:
|
||
{
|
||
return OpeningSides.LEFT;
|
||
}
|
||
|
||
case Openings.TURNONLY_RIGHT:
|
||
case Openings.TILTTURN_RIGHT:
|
||
case Openings.TILTONLY_BOTTOM:
|
||
case Openings.COMPLANARSLIDE_RIGHT:
|
||
case Openings.LIFTSLIDE_RIGHT:
|
||
{
|
||
return OpeningSides.RIGHT;
|
||
}
|
||
|
||
default:
|
||
{
|
||
return OpeningSides.NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
internal override JsonArea Serialize()
|
||
{
|
||
JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty/*, m_SelHardware.sId*/);
|
||
foreach (var SashDimension in SashList)
|
||
JsonSash.SashList.Add(SashDimension.Serialize());
|
||
foreach (var Joint in JointList)
|
||
JsonSash.JointList.Add(Joint.Serialize());
|
||
foreach (var Area in AreaList)
|
||
JsonSash.AreaList.Add(Area.Serialize());
|
||
return JsonSash;
|
||
}
|
||
}
|
||
|
||
public class Split : Area
|
||
{
|
||
public int nSplitQty
|
||
{
|
||
get
|
||
{
|
||
return m_SplitPositionList.Count > 0 ? m_SplitPositionList.Count - 1 : 0;
|
||
}
|
||
set
|
||
{
|
||
if (value > m_SplitPositionList.Count - 1)
|
||
{
|
||
// recupero larghezza ultimo
|
||
double dLastDimension = 100;
|
||
double dNewDimension = 100;
|
||
if (m_SplitPositionList.Count > 0)
|
||
{
|
||
dLastDimension = m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension;
|
||
dNewDimension = dLastDimension / (value + 1 - nSplitQty);
|
||
m_SplitPositionList[m_SplitPositionList.Count - 1].SetDimension(dNewDimension);
|
||
}
|
||
else
|
||
dNewDimension = dLastDimension / (value + 1 - nSplitQty);
|
||
// aggiungo area Split di default
|
||
for (var SplitIndex = m_SplitPositionList.Count; SplitIndex <= value; SplitIndex++)
|
||
SplitPositionList.Add(new SplitDimension(dNewDimension, true, this));
|
||
}
|
||
else if (value < m_SplitPositionList.Count - 1)
|
||
{
|
||
double dLastDimension = 0;
|
||
for (var SplitIndex = m_SplitPositionList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
|
||
{
|
||
dLastDimension += m_SplitPositionList[SplitIndex].dDimension;
|
||
SplitPositionList.RemoveAt(SplitIndex);
|
||
}
|
||
dLastDimension += m_SplitPositionList[SplitPositionList.Count - 1].dDimension;
|
||
SplitPositionList[SplitPositionList.Count - 1].SetDimension(dLastDimension);
|
||
}
|
||
for (var SplitIndex = AreaList.Count; SplitIndex <= SplitPositionList.Count - 1; SplitIndex++)
|
||
{
|
||
AreaList.Add(Splitted.CreateSplitted(this));
|
||
AreaList.Last().AreaList.Add(Fill.CreateFill(AreaList.Last(), FillTypes.GLASS));
|
||
}
|
||
for (var SplitIndex = SplitPositionList.Count; SplitIndex <= AreaList.Count - 1; SplitIndex++)
|
||
{
|
||
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
||
}
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
internal void SetSplitQty(int Qty, bool NotifyProperty = false)
|
||
{
|
||
if (Qty > m_SplitPositionList.Count)
|
||
{
|
||
// recupero larghezza ultimo
|
||
double dLastDimension = 100;
|
||
double dNewDimension = 100;
|
||
if (m_SplitPositionList.Count > 0)
|
||
{
|
||
dLastDimension = m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension;
|
||
dNewDimension = dLastDimension / (Qty + 1 - nSplitQty);
|
||
m_SplitPositionList[m_SplitPositionList.Count - 1].dDimension = dNewDimension;
|
||
}
|
||
else
|
||
dNewDimension = dLastDimension / (Qty + 1 - nSplitQty);
|
||
// aggiungo area Split di default
|
||
for (var SplitIndex = m_SplitPositionList.Count; SplitIndex <= Qty; SplitIndex++)
|
||
SplitPositionList.Add(new SplitDimension(dNewDimension, true, this));
|
||
}
|
||
else if (Qty < m_SplitPositionList.Count)
|
||
{
|
||
for (var SplitIndex = m_SplitPositionList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
|
||
SplitPositionList.RemoveAt(SplitIndex);
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<IdNameStruct> m_SplitShapeList = new ObservableCollection<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)SplitShapes.VERTICAL, "Vertical"),
|
||
new IdNameStruct((int)SplitShapes.HORIZONTAL, "Horizontal"),
|
||
new IdNameStruct((int)SplitShapes.GRID, "Grid"),
|
||
new IdNameStruct((int)SplitShapes.CUSTOM, "Custom")
|
||
};
|
||
public ObservableCollection<IdNameStruct> SplitShapeList
|
||
{
|
||
get
|
||
{
|
||
return m_SplitShapeList;
|
||
}
|
||
}
|
||
|
||
private SplitShapes m_SelSplitShape;
|
||
public int SelSplitShapeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_SelSplitShape, m_SplitShapeList);
|
||
}
|
||
set
|
||
{
|
||
m_SelSplitShape = (SplitShapes)IdNameStruct.IdFromInd(value, m_SplitShapeList);
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetSplitShape(SplitShapes Value, bool NotifyProperty = false)
|
||
{
|
||
m_SelSplitShape = Value;
|
||
}
|
||
internal SplitShapes SelSplitShape
|
||
{
|
||
get
|
||
{
|
||
return m_SelSplitShape;
|
||
}
|
||
}
|
||
|
||
private bool m_bIsPercentage = true;
|
||
public bool bIsPercentage
|
||
{
|
||
get
|
||
{
|
||
return m_bIsPercentage;
|
||
}
|
||
}
|
||
|
||
private ObservableCollection<SplitDimension> m_SplitPositionList = new ObservableCollection<SplitDimension>();
|
||
public ObservableCollection<SplitDimension> SplitPositionList
|
||
{
|
||
get
|
||
{
|
||
return m_SplitPositionList;
|
||
}
|
||
set
|
||
{
|
||
m_SplitPositionList = value;
|
||
}
|
||
}
|
||
|
||
private Curve m_Split;
|
||
public Curve sSplit
|
||
{
|
||
get
|
||
{
|
||
return m_Split;
|
||
}
|
||
set
|
||
{
|
||
m_Split = value;
|
||
}
|
||
}
|
||
|
||
public Split(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
||
{
|
||
}
|
||
|
||
internal static Split CreateSplit(Area Area, SplitShapes SplitShape)
|
||
{
|
||
Split Split = new Split(Area, Area.ParentWindow);
|
||
Split.SetAreaType(AreaTypes.SPLIT);
|
||
Split.SetSplitShape(SplitShape, true);
|
||
return Split;
|
||
}
|
||
|
||
internal override JsonArea Serialize()
|
||
{
|
||
JsonSplit JsonSplit = new JsonSplit(m_SelSplitShape);
|
||
foreach (var SplitPosition in m_SplitPositionList)
|
||
JsonSplit.SplitPositionList.Add(SplitPosition.Serialize());
|
||
foreach (var Area in AreaList)
|
||
JsonSplit.AreaList.Add(Area.Serialize());
|
||
return JsonSplit;
|
||
}
|
||
}
|
||
|
||
public class Splitted : Area
|
||
{
|
||
public Splitted(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
||
{
|
||
}
|
||
|
||
internal static Splitted CreateSplitted(Area Area)
|
||
{
|
||
Splitted Splitted = new Splitted(Area, Area.ParentWindow);
|
||
Splitted.SetAreaType(AreaTypes.SPLITTED);
|
||
return Splitted;
|
||
}
|
||
|
||
internal override JsonArea Serialize()
|
||
{
|
||
JsonSplitted JsonSplitted = new JsonSplitted();
|
||
foreach (var Area in AreaList)
|
||
JsonSplitted.AreaList.Add(Area.Serialize());
|
||
return JsonSplitted;
|
||
}
|
||
}
|
||
|
||
public class Fill : Area
|
||
{
|
||
private List<IdNameStruct> m_FillTypeList = new List<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)FillTypes.GLASS, "Glass"),
|
||
new IdNameStruct((int)FillTypes.WOOD, "Wood")
|
||
};
|
||
public List<IdNameStruct> FillTypeList
|
||
{
|
||
get
|
||
{
|
||
return m_FillTypeList;
|
||
}
|
||
}
|
||
private FillTypes m_SelFillType;
|
||
public FillTypes SelFillType
|
||
{
|
||
get
|
||
{
|
||
return m_SelFillType;
|
||
}
|
||
set
|
||
{
|
||
m_SelFillType = value;
|
||
}
|
||
}
|
||
|
||
public FillTypes FillType
|
||
{
|
||
get
|
||
{
|
||
return (FillTypes)m_SelFillType;
|
||
}
|
||
}
|
||
internal void SetFillType(FillTypes value)
|
||
{
|
||
m_SelFillType = value;
|
||
}
|
||
public int SelFillTypeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_SelFillType, m_FillTypeList);
|
||
}
|
||
set
|
||
{
|
||
m_SelFillType = (FillTypes)IdNameStruct.IdFromInd(value, m_FillTypeList);
|
||
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
public Fill(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
||
{
|
||
}
|
||
|
||
internal static Fill CreateFill(Area Area, FillTypes FillType)
|
||
{
|
||
Fill Fill = new Fill(Area, Area.ParentWindow);
|
||
Fill.SetAreaType(AreaTypes.FILL);
|
||
Fill.SetFillType(FillType);
|
||
return Fill;
|
||
}
|
||
|
||
internal override JsonArea Serialize()
|
||
{
|
||
JsonFill JsonFill = new JsonFill(FillType);
|
||
foreach (var Area in AreaList)
|
||
JsonFill.AreaList.Add(Area.Serialize());
|
||
return JsonFill;
|
||
}
|
||
}
|
||
|
||
public class Joint
|
||
{
|
||
protected Area m_ParentArea;
|
||
public Area ParentArea
|
||
{
|
||
get
|
||
{
|
||
return m_ParentArea;
|
||
}
|
||
}
|
||
private int m_nIndex;
|
||
public int nIndex
|
||
{
|
||
get
|
||
{
|
||
return m_nIndex;
|
||
}
|
||
}
|
||
|
||
private List<IdNameStruct> m_JointTypeList = new List<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)Joints.ANGLED, "Angled"),
|
||
new IdNameStruct((int)Joints.FULL_H, "Full H"),
|
||
new IdNameStruct((int)Joints.FULL_V, "Full V")
|
||
};
|
||
public List<IdNameStruct> JointTypeList
|
||
{
|
||
get
|
||
{
|
||
return m_JointTypeList;
|
||
}
|
||
}
|
||
|
||
private Joints m_SelJointType;
|
||
public int SelJointTypeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_SelJointType, m_JointTypeList);
|
||
}
|
||
set
|
||
{
|
||
m_SelJointType = (Joints)IdNameStruct.IdFromInd(value, m_JointTypeList);
|
||
m_ParentArea.ParentWindow.OnUpdatePreview(m_ParentArea.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
public Joints SelJointType
|
||
{
|
||
get
|
||
{
|
||
return m_SelJointType;
|
||
}
|
||
set
|
||
{
|
||
m_SelJointType = value;
|
||
}
|
||
}
|
||
internal void SetSelJointType(Joints value)
|
||
{
|
||
m_SelJointType = value;
|
||
//NotifyPropertyChanged(nameof(SelJointTypeIndex));
|
||
}
|
||
public Joint(Area ParentArea, int nIndex, Joints SelJointType)
|
||
{
|
||
m_ParentArea = ParentArea;
|
||
m_nIndex = nIndex;
|
||
m_SelJointType = SelJointType;
|
||
}
|
||
|
||
internal JsonJoint Serialize()
|
||
{
|
||
JsonJoint JsonJoint = new JsonJoint(m_nIndex, m_SelJointType);
|
||
return JsonJoint;
|
||
}
|
||
}
|
||
|
||
public class Curve
|
||
{
|
||
private GDB_TY m_CurveType;
|
||
public GDB_TY CurveType
|
||
{
|
||
get
|
||
{
|
||
return m_CurveType;
|
||
}
|
||
set
|
||
{
|
||
m_CurveType = value;
|
||
}
|
||
}
|
||
|
||
private Point3d m_ptStart;
|
||
public Point3d ptStart
|
||
{
|
||
get
|
||
{
|
||
return m_ptStart;
|
||
}
|
||
set
|
||
{
|
||
m_ptStart = value;
|
||
}
|
||
}
|
||
|
||
private Point3d m_ptEnd;
|
||
public Point3d ptEnd
|
||
{
|
||
get
|
||
{
|
||
return m_ptEnd;
|
||
}
|
||
set
|
||
{
|
||
m_ptEnd = value;
|
||
}
|
||
}
|
||
}
|
||
|
||
public class Hardware
|
||
{
|
||
private string m_sId;
|
||
public string sId
|
||
{
|
||
get
|
||
{
|
||
return m_sId;
|
||
}
|
||
}
|
||
|
||
private string m_sName;
|
||
public string sName
|
||
{
|
||
get
|
||
{
|
||
return m_sName;
|
||
}
|
||
}
|
||
|
||
private string m_sOpeningType;
|
||
public string sOpeningType
|
||
{
|
||
get
|
||
{
|
||
return m_sOpeningType;
|
||
}
|
||
}
|
||
|
||
private string m_sShape;
|
||
public string sShape
|
||
{
|
||
get
|
||
{
|
||
return m_sShape;
|
||
}
|
||
}
|
||
|
||
private int m_nSashQty;
|
||
public int nSashQty
|
||
{
|
||
get
|
||
{
|
||
return m_nSashQty;
|
||
}
|
||
}
|
||
|
||
private int m_nSashPosition;
|
||
public int nSashPosition
|
||
{
|
||
get
|
||
{
|
||
return m_nSashPosition;
|
||
}
|
||
}
|
||
|
||
public Hardware(string sId, string sName, string sOpeningType, string sShape, int nSashQty, int nSashPosition)
|
||
{
|
||
m_sId = sId;
|
||
m_sName = sName;
|
||
m_sOpeningType = sOpeningType;
|
||
m_sShape = sShape;
|
||
m_nSashQty = nSashQty;
|
||
m_nSashPosition = nSashPosition;
|
||
}
|
||
}
|
||
|
||
public class AGBOption
|
||
{
|
||
public enum HDWOPTIONTYPES : int
|
||
{
|
||
TEXT = 1,
|
||
LENGHT = 2,
|
||
COMBO = 3
|
||
}
|
||
|
||
private HDWOPTIONTYPES m_Type;
|
||
public HDWOPTIONTYPES Type
|
||
{
|
||
get
|
||
{
|
||
return m_Type;
|
||
}
|
||
}
|
||
|
||
private string m_sName;
|
||
public string sName
|
||
{
|
||
get
|
||
{
|
||
return m_sName;
|
||
}
|
||
}
|
||
|
||
private string m_sDescription;
|
||
public string sDescription
|
||
{
|
||
get
|
||
{
|
||
return m_sDescription;
|
||
}
|
||
}
|
||
|
||
private List<AGBOptionParameter> m_ValueList = new List<AGBOptionParameter>();
|
||
public List<AGBOptionParameter> ValueList
|
||
{
|
||
get
|
||
{
|
||
return m_ValueList;
|
||
}
|
||
}
|
||
|
||
private AGBOptionParameter m_sValue;
|
||
public AGBOptionParameter sValue
|
||
{
|
||
get
|
||
{
|
||
return m_sValue;
|
||
}
|
||
set
|
||
{
|
||
m_sValue = value;
|
||
}
|
||
}
|
||
|
||
private Visibility m_OptVisibility;
|
||
public Visibility OptVisibility
|
||
{
|
||
get
|
||
{
|
||
return m_OptVisibility;
|
||
}
|
||
}
|
||
|
||
//public AGBOption(ParametriOpzioniParametri HdwOptionParam)
|
||
//{
|
||
// if (HdwOptionParam.Opzioni.Count > 0)
|
||
// {
|
||
// m_Type = HDWOPTIONTYPES.COMBO;
|
||
// foreach (var Value in HdwOptionParam.Opzioni)
|
||
// m_ValueList.Add(new AGBOptionParameter(Value.Valore, Value.DescrizioneOpzione));
|
||
// }
|
||
// else
|
||
// m_Type = HDWOPTIONTYPES.TEXT;
|
||
// m_sName = HdwOptionParam.NomeParametro;
|
||
// m_sDescription = HdwOptionParam.DescrizioneParametro;
|
||
// m_sValue = m_ValueList.FirstOrDefault(x => x.sValue == HdwOptionParam.ValoreCorrente);
|
||
// m_OptVisibility = Visibility.Visible; // If(HdwOptionParam.Visible.ToLower = "true", Visibility.Visible, Visibility.Collapsed)
|
||
//}
|
||
}
|
||
|
||
public class AGBOptionParameter
|
||
{
|
||
private string m_sValue;
|
||
public string sValue
|
||
{
|
||
get
|
||
{
|
||
return m_sValue;
|
||
}
|
||
}
|
||
|
||
private string m_sDescription;
|
||
public string sDescription
|
||
{
|
||
get
|
||
{
|
||
return m_sDescription;
|
||
}
|
||
}
|
||
|
||
public AGBOptionParameter(string sValue, string sDescription)
|
||
{
|
||
m_sValue = sValue;
|
||
m_sDescription = sDescription;
|
||
}
|
||
}
|
||
|
||
public class FrameDimension
|
||
{
|
||
protected Frame m_ParentFrame;
|
||
public Frame ParentFrame
|
||
{
|
||
get
|
||
{
|
||
return m_ParentFrame;
|
||
}
|
||
}
|
||
|
||
private bool m_bIsLen = false;
|
||
|
||
private int m_nIndex;
|
||
public int nIndex
|
||
{
|
||
get
|
||
{
|
||
return m_nIndex;
|
||
}
|
||
}
|
||
|
||
private string m_sName;
|
||
public string sName
|
||
{
|
||
get
|
||
{
|
||
return m_sName;
|
||
}
|
||
}
|
||
|
||
private double m_dValue;
|
||
public double dValue
|
||
{
|
||
get
|
||
{
|
||
return m_dValue;
|
||
}
|
||
set
|
||
{
|
||
m_dValue = value;
|
||
m_ParentFrame.ParentWindow.OnUpdatePreview(m_ParentFrame.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
public FrameDimension(Frame ParentFrame, int nIndex, string sName, double dValue, bool bIsLen)
|
||
{
|
||
m_ParentFrame = ParentFrame;
|
||
m_nIndex = nIndex;
|
||
m_sName = sName;
|
||
m_dValue = dValue;
|
||
m_bIsLen = bIsLen;
|
||
}
|
||
|
||
internal JsonFrameDimension Serialize()
|
||
{
|
||
JsonFrameDimension JsonFrameDimension = new JsonFrameDimension(m_nIndex, m_sName, m_dValue);
|
||
return JsonFrameDimension;
|
||
}
|
||
}
|
||
|
||
public class SashDimension
|
||
{
|
||
// reference
|
||
private Sash m_Parent;
|
||
|
||
private bool m_bIsRelative = false;
|
||
public bool bIsRelative
|
||
{
|
||
get
|
||
{
|
||
return m_bIsRelative;
|
||
}
|
||
}
|
||
|
||
private List<IdNameStruct> m_OpeningTypeList = new List<IdNameStruct>
|
||
{
|
||
new IdNameStruct((int)Openings.TURNONLY_LEFT, ">"),
|
||
new IdNameStruct((int)Openings.TURNONLY_RIGHT, "<"),
|
||
new IdNameStruct((int)Openings.TILTTURN_LEFT, ">*"),
|
||
new IdNameStruct((int)Openings.TILTTURN_RIGHT, "<*"),
|
||
new IdNameStruct((int)Openings.TILTONLY_TOP, "˄"),
|
||
new IdNameStruct((int)Openings.TILTONLY_BOTTOM, "˅"),
|
||
new IdNameStruct((int)Openings.PIVOT, "◊"),
|
||
new IdNameStruct((int)Openings.FIXED, "X"),
|
||
new IdNameStruct((int)Openings.COMPLANARSLIDE_LEFT, "-→"),
|
||
new IdNameStruct((int)Openings.COMPLANARSLIDE_RIGHT, "←-"),
|
||
new IdNameStruct((int)Openings.LIFTSLIDE_LEFT, "┌→"),
|
||
new IdNameStruct((int)Openings.LIFTSLIDE_RIGHT, "←┐")
|
||
};
|
||
public List<IdNameStruct> OpeningTypeList
|
||
{
|
||
get
|
||
{
|
||
return m_OpeningTypeList;
|
||
}
|
||
}
|
||
|
||
private Openings m_SelOpeningType;
|
||
public Openings SelOpeningType
|
||
{
|
||
get
|
||
{
|
||
return m_SelOpeningType;
|
||
}
|
||
set
|
||
{
|
||
m_SelOpeningType = value;
|
||
//m_Parent.RefreshHardwareList();
|
||
m_Parent.RefreshHardwareOptionList();
|
||
//m_Parent.SetFirstHardware();
|
||
}
|
||
}
|
||
|
||
public Openings OpeningType
|
||
{
|
||
get
|
||
{
|
||
return (Openings)m_SelOpeningType;
|
||
}
|
||
}
|
||
internal void SetOpeningType(Openings value)
|
||
{
|
||
m_SelOpeningType = value;
|
||
}
|
||
public int SelOpeningTypeIndex
|
||
{
|
||
get
|
||
{
|
||
return IdNameStruct.IndFromId((int)m_SelOpeningType, m_OpeningTypeList);
|
||
}
|
||
set
|
||
{
|
||
m_SelOpeningType = (Openings)IdNameStruct.IdFromInd(value, m_OpeningTypeList);
|
||
m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
|
||
private bool m_bHasHandle;
|
||
public bool bHasHandle
|
||
{
|
||
get
|
||
{
|
||
return m_bHasHandle;
|
||
}
|
||
set
|
||
{
|
||
m_bHasHandle = value;
|
||
m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetHasHandle(bool value)
|
||
{
|
||
m_bHasHandle = value;
|
||
}
|
||
|
||
private double m_dDimension;
|
||
public double dDimension
|
||
{
|
||
get
|
||
{
|
||
return m_dDimension;
|
||
}
|
||
set
|
||
{
|
||
// se sono in percentuale
|
||
if (m_bIsRelative)
|
||
{
|
||
// verifico se ci sono assoluti
|
||
List<SashDimension> RelativeDimList = m_Parent.SashList.Where(x => x.bIsRelative).ToList();
|
||
if (RelativeDimList.Count > 0)
|
||
{
|
||
if (m_Parent.bIsPercentage)
|
||
{
|
||
int nIndex = RelativeDimList.IndexOf(this);
|
||
if (value < m_dDimension)
|
||
{
|
||
if (nIndex < RelativeDimList.Count - 1)
|
||
RelativeDimList[nIndex + 1].SetDimension(RelativeDimList[nIndex + 1].dDimension + (m_dDimension - value));
|
||
else if (RelativeDimList.Count > 1)
|
||
RelativeDimList[nIndex - 1].SetDimension(RelativeDimList[nIndex - 1].dDimension + (m_dDimension - value));
|
||
else
|
||
{
|
||
m_dDimension = 100;
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double dRes = value;
|
||
if (nIndex < RelativeDimList.Count - 1)
|
||
{
|
||
for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
||
dRes += RelativeDimList[nInd].dDimension;
|
||
dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
|
||
for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
|
||
RelativeDimList[Ind].SetDimension(dRes);
|
||
}
|
||
else if (RelativeDimList.Count > 1)
|
||
{
|
||
for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
|
||
dRes += RelativeDimList[Ind].dDimension;
|
||
dRes = (100 - dRes) / (nIndex - 1);
|
||
for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
||
RelativeDimList[nInd].SetDimension(dRes);
|
||
}
|
||
else
|
||
{
|
||
m_dDimension = 100;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
}
|
||
}
|
||
}
|
||
m_dDimension = value;
|
||
m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetDimension(double dValue)
|
||
{
|
||
m_dDimension = dValue;
|
||
}
|
||
|
||
public SashDimension(double dDimension, bool bIsRelative, Sash Parent)
|
||
{
|
||
m_dDimension = dDimension;
|
||
m_bIsRelative = bIsRelative;
|
||
m_Parent = Parent;
|
||
// assengno maniglia
|
||
if (Parent.SashList.Count == 0 || !Parent.SashList.Any(x => x.bHasHandle))
|
||
m_bHasHandle = true;
|
||
// assegno tipo di anta
|
||
if (Parent.SashList.Count == 0)
|
||
SetOpeningType(Openings.TILTTURN_LEFT);
|
||
else if (Parent.SashList.Count == 1)
|
||
{
|
||
switch (Parent.SashList[0].OpeningType)
|
||
{
|
||
case Openings.TURNONLY_LEFT:
|
||
{
|
||
SetOpeningType(Openings.TURNONLY_RIGHT);
|
||
break;
|
||
}
|
||
|
||
case Openings.TURNONLY_RIGHT:
|
||
{
|
||
SetOpeningType(Openings.TURNONLY_LEFT);
|
||
break;
|
||
}
|
||
|
||
case Openings.TILTTURN_LEFT:
|
||
{
|
||
SetOpeningType(Openings.TILTTURN_RIGHT);
|
||
break;
|
||
}
|
||
|
||
case Openings.TILTTURN_RIGHT:
|
||
{
|
||
SetOpeningType(Openings.TILTTURN_LEFT);
|
||
break;
|
||
}
|
||
|
||
case Openings.TILTONLY_TOP:
|
||
{
|
||
SetOpeningType(Openings.TILTONLY_BOTTOM);
|
||
break;
|
||
}
|
||
|
||
case Openings.TILTONLY_BOTTOM:
|
||
{
|
||
SetOpeningType(Openings.TILTONLY_TOP);
|
||
break;
|
||
}
|
||
|
||
case Openings.COMPLANARSLIDE_LEFT:
|
||
{
|
||
SetOpeningType(Openings.COMPLANARSLIDE_RIGHT);
|
||
break;
|
||
}
|
||
|
||
case Openings.COMPLANARSLIDE_RIGHT:
|
||
{
|
||
SetOpeningType(Openings.COMPLANARSLIDE_LEFT);
|
||
break;
|
||
}
|
||
|
||
case Openings.LIFTSLIDE_LEFT:
|
||
{
|
||
SetOpeningType(Openings.LIFTSLIDE_RIGHT);
|
||
break;
|
||
}
|
||
|
||
case Openings.LIFTSLIDE_RIGHT:
|
||
{
|
||
SetOpeningType(Openings.LIFTSLIDE_LEFT);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
SetOpeningType(Parent.SashList[Parent.SashList.Count - 1].OpeningType);
|
||
}
|
||
|
||
internal JsonSashDimension Serialize()
|
||
{
|
||
JsonSashDimension JsonSashDimension = new JsonSashDimension(OpeningType, m_bHasHandle, m_dDimension);
|
||
return JsonSashDimension;
|
||
}
|
||
}
|
||
|
||
public class SplitDimension
|
||
{
|
||
// reference
|
||
private Split m_Parent;
|
||
|
||
private bool m_bIsRelative = false;
|
||
public bool bIsRelative
|
||
{
|
||
get
|
||
{
|
||
return m_bIsRelative;
|
||
}
|
||
}
|
||
internal void SetIsRelative(bool value)
|
||
{
|
||
m_bIsRelative = value;
|
||
}
|
||
|
||
private double m_dDimension;
|
||
public double dDimension
|
||
{
|
||
get
|
||
{
|
||
return m_dDimension;
|
||
}
|
||
set
|
||
{
|
||
// se sono in percentuale
|
||
if (m_bIsRelative)
|
||
{
|
||
// verifico se ci sono assoluti
|
||
List<SplitDimension> RelativeDimList = m_Parent.SplitPositionList.Where(x => x.bIsRelative).ToList();
|
||
if (RelativeDimList.Count > 0)
|
||
{
|
||
if (m_Parent.bIsPercentage)
|
||
{
|
||
int nIndex = RelativeDimList.IndexOf(this);
|
||
if (value < m_dDimension)
|
||
{
|
||
if (nIndex < RelativeDimList.Count - 1)
|
||
RelativeDimList[nIndex + 1].SetDimension(RelativeDimList[nIndex + 1].dDimension + (m_dDimension - value));
|
||
else if (RelativeDimList.Count > 1)
|
||
RelativeDimList[nIndex - 1].SetDimension(RelativeDimList[nIndex - 1].dDimension + (m_dDimension - value));
|
||
else
|
||
{
|
||
m_dDimension = 100;
|
||
return;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
double dRes = value;
|
||
if (nIndex < RelativeDimList.Count - 1)
|
||
{
|
||
for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
||
dRes += RelativeDimList[nInd].dDimension;
|
||
dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
|
||
for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
|
||
RelativeDimList[Ind].SetDimension(dRes);
|
||
}
|
||
else if (RelativeDimList.Count > 1)
|
||
{
|
||
for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
|
||
dRes += RelativeDimList[Ind].dDimension;
|
||
dRes = (100 - dRes) / (nIndex - 1);
|
||
for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
||
RelativeDimList[nInd].SetDimension(dRes);
|
||
}
|
||
else
|
||
{
|
||
m_dDimension = 100;
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
}
|
||
}
|
||
}
|
||
m_dDimension = value;
|
||
m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
||
}
|
||
}
|
||
internal void SetDimension(double dValue)
|
||
{
|
||
m_dDimension = dValue;
|
||
}
|
||
|
||
public SplitDimension(double dDimension, bool bIsRelative, Split Parent)
|
||
{
|
||
m_dDimension = dDimension;
|
||
m_bIsRelative = bIsRelative;
|
||
m_Parent = Parent;
|
||
}
|
||
|
||
internal JsonSplitDimension Serialize()
|
||
{
|
||
JsonSplitDimension JsonSplitDimension = new JsonSplitDimension(m_bIsRelative, m_dDimension);
|
||
return JsonSplitDimension;
|
||
}
|
||
}
|
||
|
||
|
||
public struct IdNameStruct
|
||
{
|
||
private int m_Id;
|
||
|
||
private string m_Name;
|
||
|
||
public int Id
|
||
{
|
||
get
|
||
{
|
||
return m_Id;
|
||
}
|
||
set
|
||
{
|
||
m_Id = value;
|
||
}
|
||
}
|
||
|
||
public string Name
|
||
{
|
||
get
|
||
{
|
||
return m_Name;
|
||
}
|
||
set
|
||
{
|
||
m_Name = value;
|
||
}
|
||
}
|
||
|
||
public IdNameStruct(int Id, string Name)
|
||
{
|
||
this = default(IdNameStruct);
|
||
m_Id = Id;
|
||
m_Name = Name;
|
||
}
|
||
|
||
public override string ToString()
|
||
{
|
||
return Name;
|
||
}
|
||
|
||
public static int IndFromId(int Id, ObservableCollection<IdNameStruct> List)
|
||
{
|
||
checked
|
||
{
|
||
int num = List.Count - 1;
|
||
for (int i = 0; i <= num; i++)
|
||
{
|
||
if (List[i].Id == Id)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
public static int IndFromId(int Id, List<IdNameStruct> List)
|
||
{
|
||
checked
|
||
{
|
||
int num = List.Count - 1;
|
||
for (int i = 0; i <= num; i++)
|
||
{
|
||
if (List[i].Id == Id)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
public static int IdFromInd(int Ind, ObservableCollection<IdNameStruct> List)
|
||
{
|
||
return List[Ind].Id;
|
||
}
|
||
|
||
public static int IdFromInd(int Ind, List<IdNameStruct> List)
|
||
{
|
||
return List[Ind].Id;
|
||
}
|
||
|
||
public static int IndFromId(int Id, ObservableCollection<object> List)
|
||
{
|
||
checked
|
||
{
|
||
int num = List.Count - 1;
|
||
for (int i = 0; i <= num; i++)
|
||
{
|
||
if (List[i] is IdNameStruct && ((IdNameStruct)List[i]).Id == Id)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
public static int IndFromId(int Id, List<object> List)
|
||
{
|
||
checked
|
||
{
|
||
int num = List.Count - 1;
|
||
for (int i = 0; i <= num; i++)
|
||
{
|
||
if (List[i] is IdNameStruct && ((IdNameStruct)List[i]).Id == Id)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
public static int IdFromInd(int Ind, ObservableCollection<object> List)
|
||
{
|
||
if (List[Ind] is IdNameStruct)
|
||
{
|
||
return ((IdNameStruct)List[Ind]).Id;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
public static int IdFromInd(int Ind, List<object> List)
|
||
{
|
||
if (List[Ind] is IdNameStruct)
|
||
{
|
||
return ((IdNameStruct)List[Ind]).Id;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
//public static int IdFromName(string Name, ObservableCollection<object> List)
|
||
//{
|
||
// checked
|
||
// {
|
||
// int num = List.Count - 1;
|
||
// for (int i = 0; i <= num; i++)
|
||
// {
|
||
// if (Operators.CompareString(((IdNameStruct)List[i]).Name, Name, TextCompare: false) == 0)
|
||
// {
|
||
// return ((IdNameStruct)List[i]).Id;
|
||
// }
|
||
// }
|
||
|
||
// return 0;
|
||
// }
|
||
//}
|
||
|
||
//public static int IdFromName(string Name, List<object> List)
|
||
//{
|
||
// checked
|
||
// {
|
||
// int num = List.Count - 1;
|
||
// for (int i = 0; i <= num; i++)
|
||
// {
|
||
// if (Operators.CompareString(((IdNameStruct)List[i]).Name, Name, TextCompare: false) == 0)
|
||
// {
|
||
// return ((IdNameStruct)List[i]).Id;
|
||
// }
|
||
// }
|
||
|
||
// return 0;
|
||
// }
|
||
//}
|
||
}
|
||
|
||
}
|