Annamaria Sassi
1014 lines
37 KiB
C#
1014 lines
37 KiB
C#
using Egw.Window.Data;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.AspNetCore.Components.Web;
|
|
using Microsoft.Net.Http.Headers;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using System.Reflection.Metadata;
|
|
using System.Reflection.Metadata.Ecma335;
|
|
using System.Runtime.InteropServices;
|
|
using WebWindowComplex.DTO;
|
|
using WebWindowComplex.Json;
|
|
using static WebWindowComplex.Json.WindowConst;
|
|
|
|
namespace WebWindowComplex
|
|
{
|
|
public partial class TableComp : IDisposable
|
|
{
|
|
#region Public Properties
|
|
|
|
[Parameter]
|
|
public string CssSvg { get; set; } = "responsive-svg";
|
|
|
|
[Parameter]
|
|
public EventCallback<bool> EC_OnClose { get; set; }
|
|
|
|
[Parameter]
|
|
public EventCallback<TemplateSelectDTO> EC_OnSelectedTemplate { get; set; }
|
|
|
|
[Parameter]
|
|
public EventCallback<Dictionary<string, string>> EC_OnUpdate { get; set; }
|
|
|
|
[Parameter]
|
|
public string CurrJwd
|
|
{
|
|
get => m_CurrJwd;
|
|
set
|
|
{
|
|
// Se viene passato un JWD
|
|
if (m_CurrJwd != value && value != "")
|
|
{
|
|
m_CurrJwd = value;
|
|
// Aggiornati parametri di ingresso selezionati
|
|
UpdateSelParameter();
|
|
JsonWindow WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_CurrJwd, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
|
|
if (m_CurrWindow != null)
|
|
{
|
|
m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
|
|
m_CurrWindow = null;
|
|
}
|
|
m_CurrWindow = WindowFromJson.Deserialize();
|
|
m_CurrWindow.OnPreview += M_CurrWindow_OnPreview;
|
|
// Recupero dimensioni Frame e Joint del frame della finestra precedente
|
|
if (m_PreviousWindow != null)
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
m_CurrWindow.AreaList[0].DimensionList[i] = m_PreviousWindow.AreaList[0].DimensionList[i];
|
|
for (int i = 0; i < 4; i++)
|
|
m_CurrWindow.AreaList[0].JointList[i] = m_PreviousWindow.AreaList[0].JointList[i];
|
|
}
|
|
}
|
|
if (m_CurrWindow != null)
|
|
{
|
|
// Aggiornate liste di sash, split, splitted, fill e itemTable
|
|
UpdateLists();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Parameter]
|
|
public Template IN_SelTemplate
|
|
{
|
|
get => m_SelTemplate;
|
|
set
|
|
{
|
|
// Se viene passato il template selezionato oppure se non è ancora stato selezionato un template oppure se si cambia template di selezione
|
|
if (value != null && (m_SelTemplate == null || (m_SelTemplate != null && value.nIndex != m_SelTemplate.nIndex)) && !string.IsNullOrEmpty(value.JWD))
|
|
{
|
|
m_SelTemplate = value;
|
|
// Aggiornamento parametri di ingresso selezionati
|
|
UpdateSelParameter();
|
|
JsonWindow WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_SelTemplate.JWD, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
|
|
if (m_CurrWindow != null)
|
|
{
|
|
m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
|
|
m_CurrWindow = null;
|
|
}
|
|
m_CurrWindow = WindowFromJson.Deserialize();
|
|
m_CurrWindow.OnPreview += M_CurrWindow_OnPreview;
|
|
// Recupero dimensioni Frame e Joint del frame della finestra precedente
|
|
if (m_PreviousWindow != null)
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
m_CurrWindow.AreaList[0].DimensionList[i] = m_PreviousWindow.AreaList[0].DimensionList[i];
|
|
for (int i = 0; i < 4; i++)
|
|
m_CurrWindow.AreaList[0].JointList[i] = m_PreviousWindow.AreaList[0].JointList[i];
|
|
}
|
|
}
|
|
if (m_CurrWindow != null)
|
|
{
|
|
// Aggiornamento liste sash, split, splitted, fill e itemTable
|
|
UpdateLists();
|
|
}
|
|
}
|
|
}
|
|
|
|
[Parameter]
|
|
public List<TemplateSelectDTO> IN_TemplateDTOList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public List<string> IN_FamilyHardwareList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public string IN_SelFamilyHardware { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public List<Hardware> IN_HardwareList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public List<string> IN_ColorMaterialList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public string? IN_SelColorMaterial { get; set; } = null;
|
|
|
|
[Parameter]
|
|
public List<string> IN_MaterialList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public string? IN_SelMaterial { get; set; } = null;
|
|
|
|
[Parameter]
|
|
public List<string> IN_GlassList { get; set; } = null!;
|
|
|
|
[Parameter]
|
|
public string? IN_SelGlass { get; set; } = null;
|
|
|
|
[Parameter]
|
|
public string LiveSVG
|
|
{
|
|
get => m_SelSVG;
|
|
set => m_SelSVG = value;
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public void Dispose()
|
|
{
|
|
if (m_CurrWindow != null)
|
|
{
|
|
m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
|
|
m_CurrWindow = null;
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Enums
|
|
|
|
protected enum CompileStep
|
|
{
|
|
Template = 0,
|
|
Gerarchia = 1,
|
|
Frame,
|
|
Split,
|
|
Sash,
|
|
Fill,
|
|
General
|
|
}
|
|
|
|
protected enum PositionJoints
|
|
{
|
|
BL = 0, // Bottom Left
|
|
BR = 1, // Bottom Right
|
|
TR, // Top Right
|
|
TL // Top Left
|
|
}
|
|
|
|
#endregion Protected Enums
|
|
|
|
#region Protected Properties
|
|
|
|
protected Frame FrameWindow
|
|
{
|
|
get => m_Frame!;
|
|
set => m_Frame = value;
|
|
}
|
|
protected string? m_CurrJwd { get; set; }
|
|
protected string m_SelSVG { get; set; } = "";
|
|
|
|
/// <summary>
|
|
/// Componente SVG da mostrare
|
|
/// </summary>
|
|
protected MarkupString outSvg
|
|
{
|
|
get
|
|
{
|
|
// aggiunta gestione classe svg per posizionamento con costraints
|
|
var newSvg = LiveSVG.Replace("<svg", $"<svg class=\"{CssSvg}\"");
|
|
return (MarkupString)newSvg;
|
|
}
|
|
}
|
|
|
|
protected List<Sash> SashList
|
|
{
|
|
get => m_SashList;
|
|
}
|
|
protected List<Split> SplitList
|
|
{
|
|
get => m_SplitList;
|
|
}
|
|
protected List<Fill> FillList
|
|
{
|
|
get => m_FillList;
|
|
}
|
|
protected List<Splitted> SplittedList
|
|
{
|
|
get => m_SplittedList;
|
|
}
|
|
protected List<ItemTable> ItemTableList
|
|
{
|
|
get => m_ItemTableList;
|
|
}
|
|
protected TemplateSelectDTO? SelTemplateDTO { get; set; } = null;
|
|
protected string SelFamilyHardware
|
|
{
|
|
get
|
|
{
|
|
return m_SelFamilyHardware;
|
|
}
|
|
set
|
|
{
|
|
m_SelFamilyHardware = value;
|
|
Sash.s_SelFamilyHW = value;
|
|
for (int i = 0; i < SashList.Count; i++)
|
|
{
|
|
SashList[i].RefreshHardwareList();
|
|
SashList[i].RefreshHardwareOptionList();
|
|
SashList[i].SetFirstHardware();
|
|
}
|
|
if (m_CurrWindow != null)
|
|
{
|
|
m_CurrWindow.OnUpdatePreview(m_CurrWindow.sSerialized());
|
|
}
|
|
}
|
|
}
|
|
protected string SelColorMaterial { get; set; } = "";
|
|
|
|
protected string SelMaterial { get; set; } = ""!;
|
|
|
|
protected string SelGlass { get; set; } = "";
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Protected Methods
|
|
|
|
protected override async Task OnInitializedAsync()
|
|
{
|
|
if (string.IsNullOrEmpty(CurrJwd))
|
|
{
|
|
currStep = CompileStep.Template;
|
|
}
|
|
else
|
|
{
|
|
currStep = CompileStep.Gerarchia;
|
|
}
|
|
if (SashList.Count > 0)
|
|
currAnta = 0;
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo che resetta le liste (sash, split, splitted, fill e itemTable) e le crea nuovamente
|
|
/// </summary>
|
|
protected void UpdateLists()
|
|
{
|
|
m_maxCol = 0;
|
|
m_maxRow = 0;
|
|
m_FillList = new List<Fill>();
|
|
m_SashList = new List<Sash>();
|
|
m_SplitList = new List<Split>();
|
|
m_SplittedList = new List<Splitted>();
|
|
m_ItemTableList = new List<ItemTable>();
|
|
CreateWindowsList((m_CurrWindow!).AreaList[0], false);
|
|
CreateElementTable(m_CurrWindow.AreaList[0], 1, 1, 1, 1);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per settare i parmateri di ingresso selezionati
|
|
/// </summary>
|
|
protected void UpdateSelParameter()
|
|
{
|
|
SelFamilyHardware = IN_SelFamilyHardware;
|
|
SelColorMaterial = IN_SelColorMaterial ?? "";
|
|
SelMaterial = IN_SelMaterial ?? "";
|
|
SelGlass = IN_SelGlass ?? "";
|
|
Sash.m_HardwareCompleteList = IN_HardwareList;
|
|
Sash.s_FamilyHardwareList = IN_FamilyHardwareList;
|
|
Sash.s_SelFamilyHW = IN_SelFamilyHardware;
|
|
}
|
|
|
|
// Ancora da fare...
|
|
protected async Task DoClose()
|
|
{
|
|
await EC_OnClose.InvokeAsync(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Anteprima SVG
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected async Task DoPreviewSvg()
|
|
{
|
|
if (m_CurrWindow != null)
|
|
{
|
|
var CurrJwd = JsonConvert.SerializeObject(m_CurrWindow.Serialize(), Formatting.Indented);
|
|
Dictionary<string, string> Args = new Dictionary<string, string>();
|
|
Args.Add("Mode", $"{(int)Enums.QuestionModes.PREVIEW}");
|
|
Args.Add("Jwd", CurrJwd);
|
|
await EC_OnUpdate.InvokeAsync(Args);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo di reset dei dati a quelli del template
|
|
/// </summary>
|
|
protected async Task DoReset()
|
|
{
|
|
// Aggiornati parametri di ingresso selezionati
|
|
Area.nCounterGroup = 0;
|
|
UpdateSelParameter();
|
|
JsonWindow WindowFromJson;
|
|
if (string.IsNullOrEmpty(CurrJwd))
|
|
WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_SelTemplate.JWD, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
|
|
else
|
|
WindowFromJson = JsonConvert.DeserializeObject<JsonWindow>(m_CurrJwd!, new PolymorphicJsonConverter()) ?? new JsonWindow("", "", "", "");
|
|
if (m_CurrWindow != null)
|
|
{
|
|
m_CurrWindow.OnPreview -= M_CurrWindow_OnPreview;
|
|
m_CurrWindow = null;
|
|
}
|
|
m_CurrWindow = WindowFromJson.Deserialize();
|
|
m_CurrWindow.OnPreview += M_CurrWindow_OnPreview;
|
|
// Aggiorante liste sash, split, splitted, fill e itemTable
|
|
UpdateLists();
|
|
currSash = -1;
|
|
currFill = -1;
|
|
currSplit = -1;
|
|
currStep = CompileStep.Gerarchia;
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
// Ancora da fare..
|
|
protected async Task DoSave()
|
|
{
|
|
//manca salvataggio JWD
|
|
await EC_OnClose.InvokeAsync(true);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per la scelta della maniglia univoca
|
|
/// </summary>
|
|
/// <param name="sashDim"> anta su cui si seleziona la maniglia </param>
|
|
/// <returns></returns>
|
|
protected void changeHandle(SashDimension sashDim, Sash currSash)
|
|
{
|
|
// Cerco la Sash che si sta considerando nella lista Sash
|
|
foreach (Sash s in SashList)
|
|
{
|
|
if (s.Equals(currSash))
|
|
{
|
|
// Per ogni anta della Sash setto bHasHandle
|
|
foreach (SashDimension item in s.SashList)
|
|
{
|
|
if (item.Equals(sashDim))
|
|
{
|
|
item.bHasHandle = true;
|
|
}
|
|
else
|
|
{
|
|
if (item.bHasHandle)
|
|
{
|
|
switch (item.SelOpeningType)
|
|
{
|
|
case Openings.TILTTURN_LEFT:
|
|
item.SetOpeningType(Openings.TURNONLY_LEFT);
|
|
break;
|
|
case Openings.TILTTURN_RIGHT:
|
|
item.SetOpeningType(Openings.TURNONLY_RIGHT);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
item.bHasHandle = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per la scelta dello split intero nella modalità griglia
|
|
/// </summary>
|
|
/// <param name="currSplit"> split su cui si sceglie </param>
|
|
/// <returns></returns>
|
|
protected void changeStartVert(ChangeEventArgs e, Split currSplit)
|
|
{
|
|
// Cerco la Sash che si sta considerando nella lista Sash
|
|
foreach (Split s in SplitList)
|
|
{
|
|
if (s.Equals(currSplit))
|
|
{
|
|
s.SetSplitStartVert((bool)e.Value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per determinare la descrizione del parent dello split corrente
|
|
/// </summary>
|
|
/// <param name="currSplit"> split corrente </param>
|
|
/// <returns></returns>
|
|
protected string descParentSplit(Split currSplit)
|
|
{
|
|
if ((currSplit.ParentArea is Splitted || currSplit.ParentArea is Sash) && SashList.Count > 0)
|
|
{
|
|
for (int j = 0; j < SashList.Count; j++)
|
|
{
|
|
if (SashList[j].Equals(currSplit.ParentArea))
|
|
{
|
|
return "Sash " + (j + 1);
|
|
}
|
|
else if (SashList[j].Equals(currSplit.ParentArea.ParentArea))
|
|
{
|
|
for (int k = 0; k < SashList[j].AreaList.Count; k++)
|
|
{
|
|
if (SashList[j].AreaList[k].AreaList[0].Equals(currSplit))
|
|
{
|
|
return "Sash " + (j + 1) + " - anta " + (k + 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return "Frame";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Selezione del template
|
|
/// </summary>
|
|
/// <param name="newSel"> template selezionato </param>
|
|
protected async void DoSelect(TemplateSelectDTO newSel)
|
|
{
|
|
SelTemplateDTO = newSel;
|
|
await EC_OnSelectedTemplate.InvokeAsync(newSel);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per riempire le liste Sash, Split, Splitted e Fill
|
|
/// </summary>
|
|
/// <param name="node"> Area da classificare </param>
|
|
/// <param name="IntoSash"> Parametro per sapere se si è dentro un'anta </param>
|
|
protected void CreateWindowsList(Area node, bool IntoSash)
|
|
{
|
|
if (node != null)
|
|
{
|
|
if (node.ParentArea is Sash || IntoSash == true)
|
|
IntoSash = true;
|
|
switch (node.AreaType)
|
|
{
|
|
case AreaTypes.FRAME:
|
|
{
|
|
FrameWindow = (Frame)node;
|
|
break;
|
|
}
|
|
case AreaTypes.SASH:
|
|
{
|
|
m_SashList.Add((Sash)node);
|
|
break;
|
|
}
|
|
case AreaTypes.FILL:
|
|
{
|
|
m_FillList.Add((Fill)node);
|
|
break;
|
|
}
|
|
case AreaTypes.SPLIT:
|
|
{
|
|
m_SplitList.Add((Split)node);
|
|
break;
|
|
}
|
|
case AreaTypes.SPLITTED:
|
|
{
|
|
if (node.ParentArea is Split && !IntoSash && node.AreaList[0] is Fill)
|
|
{
|
|
m_SplittedList.Add((Splitted)node);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
foreach (var item in node.AreaList)
|
|
{
|
|
CreateWindowsList(item, IntoSash);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per riempire la lista ItemTable in modo da poter rappresentarla come tabella
|
|
/// </summary>
|
|
/// <param name="node"> Area da classificare </param>
|
|
/// <param name="row"> numero di riga </param>
|
|
/// <param name="col"> numero di colonna </param>
|
|
/// <param name="maxRow"> numero di riga massimo </param>
|
|
/// <param name="maxCol"> numero di colonna massimo </param>
|
|
protected void CreateElementTable(Area node, int row, int col, int maxRow, int maxCol)
|
|
{
|
|
if (node != null)
|
|
{
|
|
switch (node.AreaType)
|
|
{
|
|
case AreaTypes.FRAME:
|
|
{
|
|
if (node.AreaList.Count >= 1)
|
|
ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, node.AreaList.Count));
|
|
else
|
|
ItemTableList.Add(new ItemTable(AreaTypes.FRAME, "FR", row, col, -1, 0));
|
|
row++;
|
|
col++;
|
|
maxRow++;
|
|
maxCol++;
|
|
break;
|
|
}
|
|
case AreaTypes.SASH:
|
|
{
|
|
string nWIndow;
|
|
// Se ha fratelli
|
|
if ((node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1) ||
|
|
(node.ParentArea != null && node.ParentArea.AreaList.Count > 1))
|
|
{
|
|
for (int i = 0; i < SashList.Count; i++)
|
|
{
|
|
if (SashList[i].Equals(node))
|
|
{
|
|
nWIndow = SashList.Count == 1 ? "" : $"{i + 1}";
|
|
// Se il nodo ha figli, salvo il numero nell'oggetto
|
|
if (node.AreaList.Count >= 1)
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SASH, "WIN" + nWIndow, maxRow, col, i, node.AreaList.Count));
|
|
else
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SASH, "WIN" + nWIndow, maxRow, col, i, 0));
|
|
}
|
|
}
|
|
maxCol++;
|
|
}
|
|
else
|
|
{
|
|
// Se il nodo ha figli, salvo il numero nell'oggetto
|
|
if (node.AreaList.Count >= 1)
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SASH, "WIN", row, col, 0, node.AreaList.Count));
|
|
else
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SASH, "WIN", row, col, 0, 0));
|
|
maxCol++;
|
|
}
|
|
row++;
|
|
col++;
|
|
maxRow++;
|
|
break;
|
|
}
|
|
case AreaTypes.FILL:
|
|
{
|
|
if ((node.ParentArea.AreaList.Count > 1 && node.ParentArea.AreaList[0].Equals(node)) ||
|
|
(node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1 && node.ParentArea.ParentArea.AreaList[0].AreaList[0].Equals(node)))
|
|
maxCol++;
|
|
string nFill;
|
|
for (int i = 0; i < FillList.Count; i++)
|
|
{
|
|
if (FillList[i].Equals(node))
|
|
{
|
|
nFill = FillList.Count == 1 ? "" : $"{i + 1}";
|
|
ItemTableList.Add(new ItemTable(AreaTypes.FILL, "FL" + nFill, maxRow, col, i, 0));
|
|
break;
|
|
}
|
|
}
|
|
row++;
|
|
col++;
|
|
maxRow++;
|
|
break;
|
|
}
|
|
case AreaTypes.SPLIT:
|
|
{
|
|
// Se il nodo ha fratelli o cugini
|
|
if (node.ParentArea.AreaList.Count > 1 || (node.ParentArea.ParentArea != null && node.ParentArea.ParentArea.AreaList.Count > 1))
|
|
{
|
|
if (node.ParentArea.AreaList[0].Equals(node) || node.ParentArea.ParentArea.AreaList[0].Equals(node))
|
|
maxCol++;
|
|
for (int i = 0; i < SplitList.Count; i++)
|
|
{
|
|
if (SplitList[i].Equals(node))
|
|
{
|
|
string nSplit = SplitList.Count == 1 ? "" : $"{i + 1}";
|
|
if (node.AreaList.Count >= 1)
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, maxRow, col, i, node.AreaList.Count));
|
|
else
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, maxRow, col, i, 0));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < SplitList.Count; i++)
|
|
{
|
|
if (SplitList[i].Equals(node))
|
|
{
|
|
string nSplit = SplitList.Count == 1 ? "" : $"{i + 1}";
|
|
if (node.AreaList.Count >= 1)
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, row, col, i, node.AreaList.Count));
|
|
else
|
|
ItemTableList.Add(new ItemTable(AreaTypes.SPLIT, "SP" + nSplit, row, col, i, 0));
|
|
maxCol++;
|
|
}
|
|
}
|
|
}
|
|
row++;
|
|
col++;
|
|
maxRow++;
|
|
break;
|
|
}
|
|
case AreaTypes.SPLITTED:
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
foreach (var item in node.AreaList)
|
|
{
|
|
if (maxRow < m_maxRow)
|
|
CreateElementTable(item, row, col, m_maxRow, maxCol);
|
|
else
|
|
CreateElementTable(item, row, col, maxRow, maxCol);
|
|
}
|
|
}
|
|
if (maxCol > m_maxCol)
|
|
{
|
|
m_maxCol = maxCol;
|
|
}
|
|
if (maxRow > m_maxRow)
|
|
{
|
|
m_maxRow = maxRow;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per riempire tabella con contenuto vuoto o con i simboli per rappresentare la struttura
|
|
/// </summary>
|
|
/// <param name="row"> riga della cella </param>
|
|
/// <param name="col"> colonna della cella </param>
|
|
/// <returns></returns>
|
|
private string FillTable(int row, int col)
|
|
{
|
|
List<ItemTable> itemSameCol = new List<ItemTable>();
|
|
for (int k = 0; k < row; k++)
|
|
{
|
|
if (ItemTableList[k].Col == col + 1)
|
|
{
|
|
itemSameCol.Add(ItemTableList[k]);
|
|
}
|
|
continue;
|
|
}
|
|
int numItemNextCol = 0;
|
|
for (int k = 0; k < row; k++)
|
|
{
|
|
if (ItemTableList[k].Row <= row && ItemTableList[k].Col == col + 2)
|
|
{
|
|
numItemNextCol++;
|
|
}
|
|
continue;
|
|
}
|
|
if (itemSameCol.Count > 1)
|
|
{
|
|
for (int i = 0; i <= itemSameCol.Count - 2; i++)
|
|
{
|
|
if (itemSameCol[i].NumChild > 0)
|
|
numItemNextCol = numItemNextCol - itemSameCol[i].NumChild;
|
|
}
|
|
}
|
|
if (itemSameCol.Count > 0)
|
|
{
|
|
// Sono alla riga successiva di un elemento e nella stessa colonna
|
|
if (itemSameCol.Last().Row == row)
|
|
{
|
|
// se ha un solo figlio
|
|
if (itemSameCol.Last().NumChild == 1)
|
|
{
|
|
return "└";
|
|
}
|
|
else if (itemSameCol.Last().NumChild == 0)
|
|
{
|
|
return " ";
|
|
}
|
|
else
|
|
{
|
|
return "├";
|
|
}
|
|
}
|
|
// Non sono alla riga successiva
|
|
else
|
|
{
|
|
// se ha un solo figlio
|
|
if (itemSameCol.Last().NumChild == 1)
|
|
{
|
|
return " ";
|
|
}
|
|
else if (col + 2 <= m_maxCol && ItemTableList[row].Col == col + 2)
|
|
{
|
|
if (numItemNextCol < itemSameCol.Last().NumChild && numItemNextCol != (itemSameCol.Last().NumChild - 1))
|
|
{
|
|
return "├";
|
|
}
|
|
return "└";
|
|
}
|
|
else if (numItemNextCol < itemSameCol.Last().NumChild)
|
|
{
|
|
return "│";
|
|
}
|
|
else
|
|
{
|
|
return " ";
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return " ";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per settare tutti i Joints di Frame o Sash come ANGLED o FULL_H o FULL_V
|
|
/// </summary>
|
|
/// <param name="n_type"> tipo di giunzione (ANGLED o FULL_H o FULL_V) </param>
|
|
/// <param name="area"> area su cui eseguire la funzione (Frame o Sash) </param>
|
|
/// <returns></returns>
|
|
private async Task ChangeAllJoints(WindowConst.Joints type, Area area)
|
|
{
|
|
if (area is Frame)
|
|
{
|
|
foreach (Joint joint in FrameWindow.JointList)
|
|
{
|
|
joint.SetSelJointType(type);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Sash a = (Sash)area;
|
|
foreach (Joint joint in a.JointList)
|
|
{
|
|
joint.SetSelJointType(type);
|
|
}
|
|
}
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per settare tutti i Fill in contemporanea
|
|
/// </summary>
|
|
/// <param name="type"> tipo di riempimento (GLASS o WOOD) </param>
|
|
/// <returns></returns>
|
|
private async Task ChangeAllFill(FillTypes type)
|
|
{
|
|
foreach (Fill currFill in FillList)
|
|
{
|
|
currFill.SetFillType(type);
|
|
}
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per settare tutti i Fill in contemporanea
|
|
/// </summary>
|
|
/// <param name="type"> tipo di riempimento (GLASS o WOOD) </param>
|
|
/// <returns></returns>
|
|
private async Task ChangeOneFill(FillTypes type)
|
|
{
|
|
Fill fillChange = FillList.ElementAt(currFill);
|
|
fillChange.SetFillType(type);
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per copiare contenuto di un'anta in un'altra anta
|
|
/// </summary>
|
|
/// <param name="sashItem"> Sash corrispondente all'anta </param>
|
|
/// <param name="IndexCopy"> Indice dell'anta che si copia </param>
|
|
/// <param name="IndexModify"> Indice dell'anta che si modifica </param>
|
|
private async Task CopyContentSash(Sash sashItem, int IndexCopy, int IndexModify)
|
|
{
|
|
// Anta selezionata
|
|
Area sashSplitted = sashItem.AreaList[IndexModify];
|
|
// Rimuovo riempimento da anta selezionata
|
|
sashSplitted.AreaList.RemoveAt(0);
|
|
// Creo la copia dell'anta scelta
|
|
Area a = sashItem.AreaList[IndexCopy].AreaList[0].Copy(sashSplitted);
|
|
// Aggiungo copia all'anta selezionata
|
|
sashItem.AreaList[IndexModify].AreaList.Add(a);
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per copiare una Sash intera
|
|
/// </summary>
|
|
/// <param name="currSplitted"> Area Splitted corrente </param>
|
|
/// <param name="numSash"> Indice della Sash che si vuole copiare </param>
|
|
/// <returns></returns>
|
|
private async Task CopySash(Splitted currSplitted, int numSash)
|
|
{
|
|
//Rimuovo contenuto di Splitted e rimuovo area da conteggio gruppi
|
|
currSplitted.AreaList.RemoveAll(i => i != null);
|
|
//Area.DelCounterGroup();
|
|
// Copio sash
|
|
Area a = SashList[numSash].Copy(currSplitted);
|
|
a.SetParentArea(currSplitted);
|
|
// Aggiungo copia a Splitted
|
|
currSplitted.AreaList.Add(a);
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
private CompileStep currStep;
|
|
private int currAnta = 0;
|
|
private int currSash = -1;
|
|
private int currSplit = -1;
|
|
private int currFill = -1;
|
|
private Frame? m_Frame;
|
|
private List<Sash> m_SashList = new List<Sash>();
|
|
private List<Split> m_SplitList = new List<Split>();
|
|
private List<Fill> m_FillList = new List<Fill>();
|
|
private List<Splitted> m_SplittedList = new List<Splitted>();
|
|
private List<ItemTable> m_ItemTableList = new List<ItemTable>();
|
|
private int m_maxCol = 0;
|
|
private int m_maxRow = 0;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Properties
|
|
|
|
private Window? m_CurrWindow { get; set; } = null;
|
|
private Window? m_PreviousWindow { get; set; } = null;
|
|
private Template m_SelTemplate { get; set; } = null!;
|
|
private string m_SelFamilyHardware { get; set; } = "";
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Metodo per scambiare due aree di uno split
|
|
/// </summary>
|
|
/// <param name="currArea"> Area corrente </param>
|
|
/// <returns></returns>
|
|
private async Task SwapTwoAree(Area currArea)
|
|
{
|
|
currArea.SwapAree();
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per eliminare Split o Sash
|
|
/// </summary>
|
|
/// <param name="currArea"> Area corrente </param>
|
|
/// <returns></returns>
|
|
private void RemoveArea(Area currArea)
|
|
{
|
|
if (currArea is Split)
|
|
((Split)currArea).Remove();
|
|
else if (currArea is Sash)
|
|
{
|
|
((Sash)currArea).Remove();
|
|
}
|
|
currStep = CompileStep.Gerarchia;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per cambiare step e aggiornare preview svg
|
|
/// </summary>
|
|
/// <param name="newStep"> step successivo </param>
|
|
private async void NextStepAndPreview(CompileStep newStep, int Index = -1)
|
|
{
|
|
currStep = newStep;
|
|
switch (newStep)
|
|
{
|
|
case CompileStep.Sash:
|
|
{
|
|
currSash = Index;
|
|
currFill = -1;
|
|
currSplit = -1;
|
|
break;
|
|
}
|
|
case CompileStep.Fill:
|
|
{
|
|
currFill = Index;
|
|
currSash = -1;
|
|
currSplit = -1;
|
|
break;
|
|
}
|
|
case CompileStep.Split:
|
|
{
|
|
currSplit = Index;
|
|
currSash = -1;
|
|
currFill = -1;
|
|
break;
|
|
}
|
|
}
|
|
await DoPreviewSvg();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per andare allo step successivo
|
|
/// </summary>
|
|
/// <param name="newStep"> step successivo </param>
|
|
private void AdvStep(CompileStep newStep)
|
|
{
|
|
currStep = newStep;
|
|
currSash = -1;
|
|
currFill = -1;
|
|
currSplit = -1;
|
|
}
|
|
|
|
private void M_CurrWindow_OnPreview(object? sender, OnPreviewEventArgs e)
|
|
{
|
|
Dictionary<string, string> Args = new Dictionary<string, string>();
|
|
Args.Add("Mode", $"{(int)Enums.QuestionModes.PREVIEW}");
|
|
Args.Add("Jwd", e.sJwd);
|
|
EC_OnUpdate.InvokeAsync(Args);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola il css del tab selezionato
|
|
/// </summary>
|
|
/// <param name="testStep"> Step </param>
|
|
/// <returns></returns>
|
|
private string tabNavCss(CompileStep testStep, int Index = -1)
|
|
{
|
|
if (testStep == CompileStep.Sash)
|
|
{
|
|
if ((currSash == 0 && Index == 0) || (currSash == 1 && Index == 1))
|
|
return "nav-link active fw-bold";
|
|
else
|
|
return "nav-link text-secondary";
|
|
}
|
|
else if (testStep == CompileStep.Fill)
|
|
{
|
|
if ((currFill == 0 && Index == 0) || (currFill == 1 && Index == 1))
|
|
return "nav-link active fw-bold";
|
|
else
|
|
return "nav-link text-secondary";
|
|
}
|
|
else if (testStep == CompileStep.Split)
|
|
{
|
|
if ((currSplit == 0 && Index == 0) || (currSplit == 1 && Index == 1))
|
|
return "nav-link active fw-bold";
|
|
else
|
|
return "nav-link text-secondary";
|
|
}
|
|
return (testStep == currStep) ? "nav-link active fw-bold" : "nav-link text-secondary";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola larghezza colonna contenente nav da mostrare
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private string mainCss()
|
|
{
|
|
return (currStep == CompileStep.Template) ? "col-12" : "col-6";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola larghezza colonna header nav
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private string headerCss()
|
|
{
|
|
return (currStep == CompileStep.Template) ? "col-8 d-grid px-2 d-md-flex justify-content-md-start" : "col-8 d-grid px-2 d-md-flex justify-content-md-start";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola larghezza colonna button nav
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private string buttonCss()
|
|
{
|
|
return (currStep == CompileStep.Template) ? "col-4 d-grid gap-1 d-md-flex justify-content-md-end align-items-center" : "col-4 d-grid gap-1 d-md-flex justify-content-md-end align-items-center";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcola bottone selezionato per il Fill
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private string buttonFillCss(FillTypes currFillTypes)
|
|
{
|
|
if (FillList.ElementAt(currFill).SelFillType == currFillTypes)
|
|
return "btn btn-secondary btn-sm";
|
|
else
|
|
return "btn btn-outline-secondary btn-sm";
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |