private void cmdSupprimerLesAnciennesConfigs(ModelDoc2 mdl)
{
WindowLog.SautDeLigne();
if (mdl.eNomConfigActive().eEstConfigDepliee())
{
mdl.ShowConfiguration2(mdl.eListeNomConfiguration()[0]);
}
mdl.EditRebuild3();
WindowLog.Ecrire(" - Suppression des cfgs depliées :");
var liste = mdl.eListeConfigs(eTypeConfig.Depliee);
if (liste.Count == 0)
{
WindowLog.EcrireF(" Aucune configuration à supprimer");
}
foreach (Configuration Cf in liste)
{
String IsSup = Cf.eSupprimerConfigAvecEtatAff(mdl) ? "Ok" : "Erreur";
WindowLog.EcrireF(" {0} : {1}", Cf.Name, IsSup);
}
}
private Boolean InclureExclure(Component2 cp)
{
if (!cp.IsSuppressed() && (eTypeDoc.Assemblage | eTypeDoc.Piece).HasFlag(cp.TypeDoc()))
{
if (cp.eModelDoc2().ePropExiste(_pPropExclureNomenclature.GetValeur <String>()))
{
int MdlIntVal = cp.eModelDoc2().eGetProp(_pPropExclureNomenclature.GetValeur <String>()).eToInteger();
switch (MdlIntVal)
{
case 0:
{
cp.ExcludeFromBOM = false;
break;
}
case 1:
{
cp.ExcludeFromBOM = true;
WindowLog.Ecrire(cp.Name2 + " : Est exclu");
break;
}
case 2:
{
if (cp.ePropExiste(_pPropExclureNomenclature.GetValeur <String>()))
{
int CfgIntVal = cp.eProp(_pPropExclureNomenclature.GetValeur <String>()).eToInteger();
switch (CfgIntVal)
{
case 0:
{
cp.ExcludeFromBOM = false;
break;
}
case 1:
{
cp.ExcludeFromBOM = true;
//WindowLog.Ecrire(cp.Name2);
//WindowLog.Ecrire(cp.eNomConfiguration());
WindowLog.EcrireF("{0} \"{1}\" : Est exclu", cp.Name2, cp.eNomConfiguration());
break;
}
default:
break;
}
}
break;
}
default:
break;
}
}
}
return(false);
}
public void AjouterDossier(BodyFolder dossier, Component2 comp)
{
Body2 corps = dossier.ePremierCorps();
if (corps.IsNull())
{
return;
}
String BaseMateriau;
String Materiau = corps.eGetMateriauCorpsOuComp(comp, out BaseMateriau);
string Profil;
if (corps.eTypeDeCorps() == eTypeCorps.Tole)
{
Double Ep = corps.eEpaisseurCorpsOuDossier(dossier);
if (Ep == -1)
{
WindowLog.EcrireF("Pb d'epaisseur sur le corps {0}", corps.Name);
return;
}
Profil = "Ep " + Ep.ToString();
}
else if (dossier.ePropExiste(CONSTANTES.PROFIL_NOM))
{
Profil = dossier.eProp(CONSTANTES.PROFIL_NOM);
}
else
{
Profil = NomVolume;
}
Ajouter(BaseMateriau, Materiau, Profil, dossier, comp);
}
protected void RunOkCommand()
{
if (!ChargerCmd())
{
SauverLg();
}
if (ListeLgProfil.IsNull())
{
return;
}
WindowLog.Ecrire("Lg max des barres :");
foreach (var materiau in ListeLgProfil.DicLg.Keys)
{
foreach (var profil in ListeLgProfil.DicLg[materiau].Keys)
{
String lg = ListeLgProfil.DicLg[materiau][profil].ToString();
WindowLog.EcrireF("{0,10} [{1:10}] {2,10}", profil, materiau, lg);
}
}
Cmd.Executer();
if (File.Exists(Cmd.CheminFichier))
{
System.Diagnostics.Process.Start(Cmd.CheminFichier);
}
}
protected override void Command()
{
try
{
if (MdlBase.TypeDoc() == eTypeDoc.Piece)
{
Decompter(MdlBase.eComposantRacine());
}
else
{
MdlBase.eRecParcourirComposants(Decompter);
}
WindowLog.SautDeLigne();
foreach (var item in DicQte)
{
WindowLog.EcrireF("{0,-5} : {1,-5}", "Ø " + Math.Round(item.Key, 2), "×" + item.Value);
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
try
{
String NomFichier = String.Format("{0}{1}", String.IsNullOrWhiteSpace(RefFichier) ? "" : RefFichier + "-", IndiceCampagne);
switch (TypeSortie)
{
case eTypeSortie.ListeDebit:
{
var DicBarre = _listeElement.ListeBarre();
String ResumeBarre = DicBarre.ResumeNbBarre();
String ResumeListeDebit = DicBarre.ResumeListeDebit();
String Complet = RefFichier + "\r\n" + ResumeBarre + "\r\n\r\n" + ResumeListeDebit;
WindowLog.Ecrire(ResumeBarre);
CheminFichier = Path.Combine(MdlBase.eDossier(), NomFichier + " - Liste de débit.txt");
StreamWriter s = new StreamWriter(CheminFichier);
s.Write(Complet);
s.Close();
WindowLog.SautDeLigne(2);
WindowLog.EcrireF("Nb d'éléments {0}", _listeElement.NbElement);
WindowLog.EcrireF("Nb de barres {0}", DicBarre.NbBarre);
}
break;
case eTypeSortie.ListeBarre:
{
String ResumeListeBarre = _listeElement.ResumeListeBarre();
CheminFichier = Path.Combine(MdlBase.eDossier(), NomFichier + " - Liste des barres.txt");
String Complet = RefFichier + "\r\n" + ResumeListeBarre;
WindowLog.Ecrire(ResumeListeBarre);
StreamWriter s = new StreamWriter(CheminFichier);
s.Write(Complet);
s.Close();
WindowLog.SautDeLigne(2);
}
break;
default:
break;
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
try
{
var mass = MdlBase.Extension.CreateMassProperty();
WindowLog.EcrireF("Ecraser la masse : {0}", mass.OverrideMass);
mass.OverrideMass = false;
}
catch (Exception e)
{
this.LogMethode(new Object[] { e });
}
}
protected void ExecuterEn(Boolean SansSautDeLigne = false)
{
if (!LogToWindowLog)
{
return;
}
TimeSpan t = DateTime.Now - _DateTimeStart;
if (!SansSautDeLigne)
{
WindowLog.SautDeLigne();
}
WindowLog.EcrireF("Executé en {0}", GetSimplestTimeSpan(t));
}
protected override void Command()
{
try
{
WindowLog.EcrireF("Export : {0}", typeExport.GetEnumInfo <Intitule>().ToUpperInvariant());
WindowLog.SautDeLigne();
WindowLog.EcrireF(" Dossier : {0}", new DirectoryInfo(CheminDossier).Name);
WindowLog.EcrireF(" {0}", NomFichier + typeExport.GetEnumInfo <ExtFichier>());
CheminFichierExport = Feuille.eExporterEn(Dessin, typeExport, CheminDossier, NomFichier, ToutesLesFeuilles);
}
catch (Exception e)
{
WindowLog.Ecrire("Erreur : Consultez le fichier LOG");
this.LogMethode(new Object[] { e });
}
}
public PageRepereCorps()
{
try
{
Mt = (MathUtility)App.Sw.GetMathUtility();
ListeCorps = MdlBase.pChargerNomenclature();
InitSouris();
WindowLog.EcrireF("Nb Corps : {0}", MdlBase.eComposantRacine().eListeCorps().Count);
OnCalque += Calque;
OnRunAfterActivation += ChargerCorps;
OnRunAfterClose += RunAfterClose;
}
catch (Exception e)
{ this.LogMethode(new Object[] { e }); }
}
protected override void Command()
{
try
{
var ListeCorps = MdlBase.pChargerNomenclature();
foreach (var corps in ListeCorps.Values)
{
WindowLog.EcrireF("{0} -> dvp", corps.Repere);
corps.pCreerDvp(MdlBase.pDossierPiece(), SupprimerLesAnciennesConfigs);
}
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.EditRebuild3();
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
private void Start()
{
try
{
NettoyerFichier();
foreach (var corps in ListeCorps.Values)
{
CreerVue(corps);
}
foreach (DrawingDoc dessin in DicDessins.Values)
{
dessin.eModelDoc2().eActiver();
dessin.eFeuilleActive().eAjusterAutourDesVues();
dessin.eModelDoc2().ViewZoomtofit2();
dessin.eModelDoc2().eSauver();
}
WindowLog.SautDeLigne();
WindowLog.Ecrire("Resumé :");
foreach (var corps in ListeCorps.Values)
{
if (corps.Dvp && corps.Maj)
{
WindowLog.EcrireF("{2} P{0} ×{1}", corps.Repere, corps.Qte, IndiceCampagne);
if ((corps.DiffPliage > 0) || ((corps.NbPli > 0) && (corps.DiffPliage == 0)))
{
WindowLog.EcrireF(" - Controle : {0}% [{1}] / Nb pli : {2}", corps.DiffPliagePct, corps.DiffPliage, corps.NbPli);
}
}
}
ListeCorps.EcrireProduction(DossierDVP, IndiceCampagne);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
private Boolean SupprimerConfigs(Component2 Cp)
{
try
{
if ((Cp.TypeDoc() == eTypeDoc.Piece) && !Cp.IsHidden(true) && !_Dic.ContainsKey(Cp.eKeySansConfig()) && Cp.eEstDansLeDossier(MdlBase))
{
_Dic.Add(Cp.eKeySansConfig(), "");
WindowLog.Ecrire(Cp.eNomAvecExt());
foreach (Configuration Cf in Cp.eModelDoc2().eListeConfigs(eTypeConfig.Depliee))
{
String IsSup = Cf.eSupprimerConfigAvecEtatAff(Cp.eModelDoc2()) ? "Ok" : "Erreur";
WindowLog.EcrireF(" {0} : {1}", Cf.Name, IsSup);
}
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
return(false);
}
private void SupprimerDefBloc(ModelDoc2 mdl)
{
var TabDef = (Object[])mdl.SketchManager.GetSketchBlockDefinitions();
if (TabDef.IsRef())
{
foreach (SketchBlockDefinition blocdef in TabDef)
{
Feature f = blocdef.GetFeature();
WindowLog.EcrireF(" - {0}", f.Name);
if (blocdef.GetInstanceCount() > 0)
{
continue;
}
f.eSelect();
var res = mdl.Extension.DeleteSelection2((int)(swDeleteSelectionOptions_e.swDelete_Absorbed | swDeleteSelectionOptions_e.swDelete_Children));
WindowLog.EcrireF(" Supprimée : {0}", res);
mdl.eEffacerSelection();
}
}
}
private GeomVue AppliquerOptionsVue(DrawingDoc dessin, PartDoc piece, View vue)
{
vue.ShowSheetMetalBendNotes = AfficherNotePliage;
MathUtility SwMath = App.Sw.GetMathUtility();
var liste = piece.eListeFonctionsDepliee();
if (liste.Count == 0)
{
return(null);
}
Feature FonctionDepliee = liste[0];
GeomVue g = null;
var Liste = FonctionDepliee.eListeSousFonction();
Feature f = Liste[0];
// Les fonctions "Lignes de pliage" et "Cube de visualisation" ne sont pas toujours correctement
// nommées donc ont considère que la première fonction = Ligne de pliage et la deuxième = Cube de visualisation
if (f.GetTypeName2() == FeatureType.swTnProfileFeature)
{
ModelDoc2 mdlBase = dessin.eModelDoc2();
f.eSelectionnerById2Dessin(mdlBase, vue);
if (AfficherLignePliage)
{
mdlBase.UnblankSketch();
}
else
{
mdlBase.BlankSketch();
}
mdlBase.eEffacerSelection();
}
f = Liste[1];
if (f.GetTypeName2() == FeatureType.swTnProfileFeature)
{
try
{
f.eModifierEtat(swFeatureSuppressionAction_e.swUnSuppressFeature);
Sketch Esquisse = f.GetSpecificFeature2();
if (OrienterDvp)
{
Double Angle = AngleCubeDeVisualisation(vue, Esquisse);
// On oriente la vue
switch (OrientationDvp)
{
case eOrientation.Portrait:
if (Math.Abs(Angle) != MathX.eRad90D)
{
Double a = MathX.eRad90D - Math.Abs(Angle);
vue.Angle = (Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a;
}
break;
case eOrientation.Paysage:
if (Math.Abs(Angle) != 0 || Math.Abs(Angle) != MathX.eRad180D)
{
Double a = MathX.eRad90D - Math.Abs(Angle);
vue.Angle = ((Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a) - MathX.eRad90D;
}
break;
default:
break;
}
}
g = new GeomVue(vue, Esquisse);
}
catch
{
WindowLog.EcrireF("Impossible d'orienter la vue : {0}", vue.Name);
}
}
//FonctionDepliee.eParcourirSousFonction(
// f =>
// {
// if (f.Name.StartsWith(CONSTANTES.LIGNES_DE_PLIAGE))
// {
// //String NomSelection = f.Name + "@" + vue.RootDrawingComponent.Name + "@" + vue.Name;
// //Dessin.Extension.SelectByID2(NomSelection, "SKETCH", 0, 0, 0, false, 0, null, 0);
// ModelDoc2 mdlBase = dessin.eModelDoc2();
// f.eSelectionnerById2Dessin(mdlBase, vue);
// if (AfficherLignePliage)
// mdlBase.UnblankSketch();
// else
// mdlBase.BlankSketch();
// mdlBase.eEffacerSelection();
// }
// else if (f.Name.StartsWith(CONSTANTES.CUBE_DE_VISUALISATION))
// {
// try
// {
// f.eModifierEtat(swFeatureSuppressionAction_e.swUnSuppressFeature);
// Sketch Esquisse = f.GetSpecificFeature2();
// if (OrienterDvp)
// {
// Double Angle = AngleCubeDeVisualisation(vue, Esquisse);
// // On oriente la vue
// switch (OrientationDvp)
// {
// case eOrientation.Portrait:
// if (Math.Abs(Angle) != MathX.eRad90D)
// {
// Double a = MathX.eRad90D - Math.Abs(Angle);
// vue.Angle = (Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a;
// }
// break;
// case eOrientation.Paysage:
// if (Math.Abs(Angle) != 0 || Math.Abs(Angle) != MathX.eRad180D)
// {
// Double a = MathX.eRad90D - Math.Abs(Angle);
// vue.Angle = ((Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a) - MathX.eRad90D;
// }
// break;
// default:
// break;
// }
// }
// g = new GeomVue(vue, Esquisse);
// }
// catch
// {
// WindowLog.EcrireF("Impossible d'orienter la vue : {0}", vue.Name);
// }
// return true;
// }
// return false;
// }
// );
return(g);
}
private void CreerVue(Corps corps)
{
if (!corps.Dvp || !corps.Maj)
{
return;
}
var QuantiteDiff = Quantite * (corps.Qte + corps.QteSup);
Double Epaisseur = corps.Dimension.eToDouble();
var cheminFichier = corps.CheminFichierRepere;
if (!File.Exists(cheminFichier))
{
return;
}
var mdlCorps = Sw.eOuvrir(cheminFichier);
if (mdlCorps.IsNull())
{
return;
}
var piece = mdlCorps.ePartDoc();
var listeCfgPliee = mdlCorps.eListeNomConfiguration(eTypeConfig.Pliee);
var NomConfigPliee = listeCfgPliee[0];
if (mdlCorps.eNomConfigActive() != NomConfigPliee)
{
mdlCorps.ShowConfiguration2(NomConfigPliee);
}
WindowLog.EcrireF("{0} x{1}", corps.RepereComplet, QuantiteDiff);
piece.ePremierCorps(false).eVisible(true);
Double Volume1 = piece.ePremierCorps().eVolume();
piece.ePremierCorps(false).eVisible(true);
corps.NbPli = piece.pNbPli();
var listeCfgDepliee = mdlCorps.eListeNomConfiguration(eTypeConfig.Depliee);
if (listeCfgDepliee.Count == 0)
{
return;
}
var NomConfigDepliee = listeCfgDepliee[0];
if (!mdlCorps.ShowConfiguration2(NomConfigDepliee))
{
WindowLog.EcrireF(" - Pas de configuration dvp");
return;
}
corps.CalculerDiffPliage(Volume1, piece.ePremierCorps().eVolume());
mdlCorps.ePartDoc().ePremierCorps(false).eVisible(true);
mdlCorps.EditRebuild3();
mdlCorps.ePartDoc().ePremierCorps(false).eVisible(true);
DrawingDoc dessin = CreerPlan(corps.Materiau, Epaisseur, MettreAjourCampagne);
dessin.eModelDoc2().eActiver();
Sheet Feuille = dessin.eFeuilleActive();
try
{
if (MettreAjourCampagne)
{
foreach (var vue in Feuille.eListeDesVues())
{
var mdlVue = vue.ReferencedDocument;
if (mdlCorps.GetPathName() == mdlVue.GetPathName())
{
vue.eSelectionner(dessin);
dessin.eModelDoc2().EditDelete();
dessin.eModelDoc2().eEffacerSelection();
break;
}
}
}
View v = CreerVueToleDvp(dessin, Feuille, piece, NomConfigDepliee, corps.RepereComplet, corps.Materiau, QuantiteDiff, Epaisseur);
}
catch (Exception e)
{
WindowLog.Ecrire(" - Erreur");
this.LogMethode(new Object[] { e });
}
finally
{
WindowLog.Ecrire(" - Ok");
}
mdlCorps.ShowConfiguration2(NomConfigPliee);
mdlCorps.eFermer();
}
protected override void Command()
{
try
{
CreerDossierExport(MdlBase);
var dic = MdlBase.ListerComposants(false);
int MdlPct = 0;
foreach (var mdl in dic.Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF("[{1}/{2}] {0}", mdl.eNomSansExt(), ++MdlPct, dic.Count);
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
var cfgActive = mdl.eNomConfigActive();
var ListeNomConfigs = dic[mdl];
int CfgPct = 0;
foreach (var NomConfigPliee in ListeNomConfigs.Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF(" [{1}/{2}] Config : \"{0}\"", NomConfigPliee, ++CfgPct, ListeNomConfigs.Count);
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
mdl.eEffacerSelection();
var NbConfig = dic[mdl][NomConfigPliee];
PartDoc Piece = mdl.ePartDoc();
var ListeDossier = Piece.eListeDesDossiersDePiecesSoudees(
dossier =>
{
if (dossier.eEstExclu() || dossier.IsNull() || (dossier.GetBodyCount() == 0))
{
return(false);
}
String Profil = dossier.eProp(CONSTANTES.PROFIL_NOM);
String Longueur = dossier.eProp(CONSTANTES.PROFIL_LONGUEUR);
if (String.IsNullOrWhiteSpace(Profil) || String.IsNullOrWhiteSpace(Longueur))
{
return(false);
}
foreach (var Barre in dossier.eListeDesCorps())
{
Barre.Select2(true, null);
}
return(true);
}
);
if (ListeDossier.Count == 0)
{
continue;
}
var NomFichier = String.Format("{0}-{1} (x{2}) - {3}", mdl.eNomSansExt(), NomConfigPliee, NbConfig, Indice);
var mdlExport = ExportSelection(Piece, NomFichier, eTypeFichierExport.Piece);
if (mdlExport.IsNull())
{
WindowLog.EcrireF("Erreur : {0}", NomFichier);
continue;
}
WindowLog.EcrireF(" {0}", NomFichier);
mdlExport.ViewZoomtofit2();
mdlExport.ShowNamedView2("*Isométrique", 7);
int lErrors = 0, lWarnings = 0;
mdlExport.Save3((int)swSaveAsOptions_e.swSaveAsOptions_Silent, ref lErrors, ref lWarnings);
mdlExport.eFermer();
mdl.eFermerSiDifferent(MdlBase);
}
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
CreerDossierDVP();
WindowLog.Ecrire(String.Format("Dossier :\r\n{0}", new DirectoryInfo(DossierExport).Name));
try
{
eTypeCorps Filtre = PrendreEnCompteTole ? eTypeCorps.Barre | eTypeCorps.Tole : eTypeCorps.Barre;
HashSet <String> HashMateriaux = new HashSet <string>(ListeMateriaux);
var dic = MdlBase.DenombrerDossiers(ComposantsExterne,
fDossier =>
{
BodyFolder swDossier = fDossier.GetSpecificFeature2();
if (Filtre.HasFlag(swDossier.eTypeDeDossier()) && HashMateriaux.Contains(swDossier.eGetMateriau()))
{
return(true);
}
return(false);
}
);
if (ListerUsinages)
{
Nomenclature.TitreColonnes("Barre ref.", "Materiau", "Profil", "Lg", "Nb", "Usinage Ext 1", "Usinage Ext 2", "Détail des Usinage interne");
}
else
{
Nomenclature.TitreColonnes("Barre ref.", "Materiau", "Profil", "Lg", "Nb");
}
int MdlPct = 0;
foreach (var mdl in dic.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
WindowLog.SautDeLigne();
WindowLog.EcrireF("[{1}/{2}] {0}", mdl.eNomSansExt(), ++MdlPct, dic.Count);
int CfgPct = 0;
foreach (var NomConfigPliee in dic[mdl].Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF(" [{1}/{2}] Config : \"{0}\"", NomConfigPliee, ++CfgPct, dic[mdl].Count);
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
PartDoc Piece = mdl.ePartDoc();
var ListeDossier = dic[mdl][NomConfigPliee];
int DrPct = 0;
foreach (var t in ListeDossier)
{
var IdDossier = t.Key;
var QuantiteBarre = t.Value * Quantite;
Feature fDossier = Piece.FeatureById(IdDossier);
BodyFolder dossier = fDossier.GetSpecificFeature2();
var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
Body2 Barre = dossier.ePremierCorps();
String Profil = dossier.eProp(CONSTANTES.PROFIL_NOM);
String Longueur = dossier.eProp(CONSTANTES.PROFIL_LONGUEUR);
String Materiau = Barre.eGetMateriauCorpsOuPiece(Piece, NomConfigPliee);
Materiau = ForcerMateriau.IsRefAndNotEmpty(Materiau);
String NomFichierBarre = ConstruireNomFichierBarre(RefDossier, QuantiteBarre);
WindowLog.SautDeLigne();
WindowLog.EcrireF(" - [{1}/{2}] Dossier : \"{0}\" x{3}", RefDossier, ++DrPct, ListeDossier.Count, QuantiteBarre);
WindowLog.EcrireF(" Profil {0} Materiau {1}", Profil, Materiau);
List <String> Liste = new List <String>()
{
RefDossier, Materiau, Profil, Math.Round(Longueur.eToDouble()).ToString(), "× " + QuantiteBarre.ToString()
};
if (ListerUsinages)
{
var analyse = new AnalyseBarre(Barre, mdl);
Dictionary <String, Double> Dic = new Dictionary <string, double>();
foreach (var u in analyse.ListeFaceUsinageSection)
{
String nom = u.ListeFaceDecoupe.Count + " face - Lg " + Math.Round(u.LgUsinage * 1000, 1);
if (Dic.ContainsKey(nom))
{
Dic[nom] += 1;
}
else
{
Dic.Add(nom, 1);
}
}
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[0].LgUsinage * 1000, 1).ToString());
if (analyse.ListeFaceUsinageExtremite.Count > 1)
{
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[1].LgUsinage * 1000, 1).ToString());
}
else
{
Liste.Add("");
}
foreach (var nom in Dic.Keys)
{
Liste.Add(Dic[nom] + "x [ " + nom + " ]");
}
}
Nomenclature.AjouterLigne(Liste.ToArray());
if (ExporterBarres)
{
//mdl.ViewZoomtofit2();
//mdl.ShowNamedView2("*Isométrique", 7);
String CheminFichier;
ModelDoc2 mdlBarre = Barre.eEnregistrerSous(Piece, DossierExport, NomFichierBarre, TypeExport, out CheminFichier);
if (CreerPdf3D)
{
String CheminPDF = Path.Combine(DossierExportPDF, NomFichierBarre + eTypeFichierExport.PDF.GetEnumInfo <ExtFichier>());
mdlBarre.SauverEnPdf3D(CheminPDF);
}
mdlBarre.eFermer();
}
}
}
mdl.eFermerSiDifferent(MdlBase);
}
WindowLog.SautDeLigne();
WindowLog.Ecrire(Nomenclature.ListeLignes());
CheminNomenclature = Path.Combine(DossierExport, "Nomenclature.txt");
StreamWriter s = new StreamWriter(CheminNomenclature);
s.Write(Nomenclature.GenererTableau());
s.Close();
}
catch (Exception e) { this.LogErreur(new Object[] { e }); }
}
protected void RechercherIndiceCampagne()
{
try
{
WindowLog.Ecrire("Recherche des éléments existants :");
// Recherche du dernier indice de la campagne de repérage
// Création du dossier pièces s'il n'existe pas
MdlBase.pCreerDossier(CONST_PRODUCTION.DOSSIER_PIECES);
// Recherche de la nomenclature
MdlBase.pCreerFichierTexte(CONST_PRODUCTION.DOSSIER_PIECES, CONST_PRODUCTION.FICHIER_NOMENC);
// Recherche des exports laser, tole ou tube, existant
var IndiceLaser = Math.Max(MdlBase.pRechercherIndiceDossier(CONST_PRODUCTION.DOSSIER_LASERTOLE),
MdlBase.pRechercherIndiceDossier(CONST_PRODUCTION.DOSSIER_LASERTUBE)
);
IndiceCampagne = IndiceLaser + 1;
// Aquisition de la liste des corps déjà repérées
ListeCorps = MdlBase.pChargerNomenclature();
_Texte_IndiceCampagneDepartDecompte.Text = ListeCorps.CampagneDepartDecompte.ToString();
WindowLog.EcrireF("{0} pièce(s) sont référencé(s)", ListeCorps.Count);
// S'il n'y a aucun corps, on désactive les options
if (ListeCorps.Count == 0)
{
_CheckBox_MajCampagnePrecedente.IsEnabled = false;
_CheckBox_MajCampagnePrecedente.Visible = false;
_CheckBox_ReinitCampagneActuelle.IsEnabled = false;
_CheckBox_ReinitCampagneActuelle.Visible = false;
}
// Si aucun corps n'a déjà été comptabilisé pour cette campagne,
// on ne propose pas la réinitialisation
foreach (var corps in ListeCorps.Values)
{
if (corps.Campagne.Keys.Max() >= IndiceCampagne)
{
ReinitCampagneActuelle = true;
break;
}
}
if (!ReinitCampagneActuelle)
{
_CheckBox_ReinitCampagneActuelle.IsEnabled = false;
_CheckBox_ReinitCampagneActuelle.Visible = false;
}
// Si c'est la première campagne, on désactive des options
if (IndiceCampagne == 1)
{
_CheckBox_CampagneDepartDecompte.IsEnabled = false;
_CheckBox_CampagneDepartDecompte.Visible = false;
_Texte_IndiceCampagneDepartDecompte.IsEnabled = false;
_Texte_IndiceCampagneDepartDecompte.Visible = false;
_CheckBox_MajCampagnePrecedente.IsEnabled = false;
_CheckBox_MajCampagnePrecedente.Visible = false;
_CheckBox_CombinerAvecCampagnePrecedente.IsEnabled = false;
_CheckBox_CombinerAvecCampagnePrecedente.Visible = false;
}
}
catch (Exception e) { this.LogErreur(new Object[] { e }); }
}
/// <summary>
/// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
/// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
/// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
/// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
/// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
/// Les propriétés des dossiers ne sont pas configurables.
/// </summary>
protected override void Command()
{
try
{
if (MajDossiers)
{
IndiceMax();
}
var ListeCorps = new List <Corps>();
var lst = MdlBase.ListerComposants(false);
foreach (var mdl in lst.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
EsquisseRepere(mdl);
foreach (var cfg in lst[mdl].Keys)
{
mdl.ShowConfiguration2(cfg);
mdl.EditRebuild3();
WindowLog.SautDeLigne();
WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), cfg);
var piece = mdl.ePartDoc();
var NbConfig = lst[mdl][cfg];
var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder Dossier = swD.GetSpecificFeature2();
// Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
if (Dossier.IsRef() && Dossier.eNbCorps() > 0 &&
(eTypeCorps.Barre | eTypeCorps.Tole).HasFlag(Dossier.eTypeDeDossier()))
{
return(true);
}
return(false);
}
);
foreach (var fDossier in ListeDossier)
{
BodyFolder Dossier = fDossier.GetSpecificFeature2();
CustomPropertyManager PM = fDossier.CustomPropertyManager;
// Si MajDossier et PropExiste, ne pas mettre à jour
Boolean Maj = !(MajDossiers && PM.ePropExiste(CONSTANTES.REF_DOSSIER));
String NomParam = "";
WindowLog.EcrireF(" {0}", fDossier.Name);
// On recherche si le dossier à déjà été traité.
// Si non, on ajoute le dossier à la liste
// On met à jour la liste des index des dimensions :
// On ajoute le nom du modele et on itiniatile l'index à 1
// Ou, puisque c'est un nouveau dossier, on ajoute un à l'index existant.
// On créer le nom du paramètre
// On ajoute la propriété au dossier selon le modèle suivant :
// P"D1@REPERAGE_DOSSIER@Nom_de_la_piece.SLDPRT"
// Si oui, on récupère le nom du paramètre
var clef = HashDossier(mdl, fDossier);
if (!DossierTraite.Contains(clef))
{
DossierTraite.Add(clef);
IndexDimension.AddIfNotExistOrPlus(mdl.GetPathName());
NomParam = String.Format("D{0}@{1}", IndexDimension[mdl.GetPathName()]++, CONSTANTES.NOM_ESQUISSE_NUMEROTER);
var propVal = String.Format("{0}\"{1}@{2}\"", CONSTANTES.PREFIXE_REF_DOSSIER, NomParam, mdl.eNomAvecExt());
var r = PM.ePropAdd(CONSTANTES.REF_DOSSIER, propVal);
if (r > 0)
{
WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété ajoutée {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoAddResult_e)r);
}
PM.ePropAdd(CONSTANTES.DESC_DOSSIER, propVal);
}
else
{
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
if (r == 1)
{
WindowLog.EcrireF("{0}-{1}-{2} : Pas de propriété {3}", mdl.eNomSansExt(), cfg, fDossier.Name, (swCustomInfoGetResult_e)r);
}
NomParam = ExtractNomParam(val);
}
{
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
PM.ePropAdd(CONSTANTES.DESC_DOSSIER, val);
}
// On ajoute la propriété NomDossier
// permettant de récupérer le nom du dossier dans la mise en plan
if (!PM.ePropExiste(CONSTANTES.NOM_DOSSIER))
{
var propVal = String.Format("\"SW-CutListItemName@@@{0}@{1}\"", fDossier.Name, mdl.eNomAvecExt());
PM.ePropAdd(CONSTANTES.NOM_DOSSIER, propVal);
}
var SwCorps = Dossier.ePremierCorps();
Boolean Ajoute = false;
var MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, cfg);
var nbCorps = Dossier.eNbCorps() * NbConfig;
Dimension param = mdl.Parameter(NomParam);
eTypeCorps TypeCorps = Dossier.eTypeDeDossier();
if (CombinerCorpsIdentiques)
{
// On recherche s'il existe des corps identiques
// Si oui, on applique le même repère au parametre
foreach (var CorpsTest in ListeCorps)
{
if ((MateriauCorps != CorpsTest.Materiau) || (TypeCorps != CorpsTest.TypeCorps))
{
continue;
}
if (SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
{
CorpsTest.Nb += nbCorps;
if (Maj)
{
var errors = param.SetSystemValue3(CorpsTest.Repere * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);
if (errors > 0)
{
WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
}
}
CorpsTest.AjouterModele(mdl, cfg, fDossier.GetID());
Ajoute = true;
break;
}
}
}
if ((Ajoute == false) && Maj)
{
var rep = GenRepereDossier;
var errors = param.SetSystemValue3(rep * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, cfg);
if (errors > 0)
{
WindowLog.EcrireF(" Erreur de mise à jour {0}", (swSetValueReturnStatus_e)errors);
}
var corps = new Corps(SwCorps, TypeCorps, MateriauCorps);
corps.Nb = nbCorps;
corps.Repere = rep;
corps.AjouterModele(mdl, cfg, fDossier.GetID());
ListeCorps.Add(corps);
}
}
}
mdl.eFermerSiDifferent(MdlBase);
}
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
int Errors = 0, Warnings = 0;
MdlBase.Save3((int)swSaveAsOptions_e.swSaveAsOptions_SaveReferenced + (int)swSaveAsOptions_e.swSaveAsOptions_Silent, ref Errors, ref Warnings);
MdlBase.EditRebuild3();
// Petit récap
WindowLog.SautDeLigne();
WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);
int nbtt = 0;
foreach (var corps in ListeCorps)
{
nbtt += corps.Nb;
WindowLog.EcrireF("P{0} ×{1}", corps.Repere, corps.Nb);
}
WindowLog.EcrireF("Nb total de corps : {0}", nbtt);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
/// <summary>
/// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
/// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
/// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
/// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
/// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
/// Les propriétés des dossiers ne sont pas configurables.
/// </summary>
protected override void Command()
{
try
{
App.Sw.CommandInProgress = true;
// Si aucun corps n'a déjà été repéré, on reinitialise tout
if (ListeCorps.Count == 0)
{
// On supprime tout les fichiers
foreach (FileInfo file in new DirectoryInfo(MdlBase.pDossierPiece()).GetFiles())
{
file.Delete();
}
}
if (ReinitCampagneActuelle && (ListeCorps.Count > 0))
{
// On supprime les repères de la campagne actuelle
// On recherche les repères appartenant aux campagnes précédentes
// pour ne pas supprimer les fichiers
// Si la somme des quantités des campagnes précédente est superieure à 0
// on garde le repère
ListeSortedCorps FichierAsauvegarder = new ListeSortedCorps();
FichierAsauvegarder.CampagneDepartDecompte = ListeCorps.CampagneDepartDecompte;
foreach (var corps in ListeCorps.Values)
{
int nb = 0;
foreach (var camp in corps.Campagne)
{
if (camp.Key < IndiceCampagne)
{
nb += camp.Value;
}
else
{
break;
}
}
if (nb > 0)
{
FichierAsauvegarder.Add(corps.Repere, corps);
}
}
// On nettoie les fichiers précedement crées
foreach (var corps in ListeCorps.Values)
{
if (FichierAsauvegarder.ContainsKey(corps.Repere))
{
continue;
}
corps.SupprimerFichier();
}
ListeCorps = FichierAsauvegarder;
}
// On supprime les campagnes superieures à l'indice actuelle
foreach (var corps in ListeCorps.Values)
{
for (int i = IndiceCampagne; i < corps.Campagne.Keys.Max(); i++)
{
if (corps.Campagne.ContainsKey(i + 1))
{
corps.Campagne.Remove(i + 1);
}
}
}
WindowLog.SautDeLigne();
WindowLog.EcrireF("Campagne de départ : {0}", ListeCorps.CampagneDepartDecompte);
// On charge les corps existant à partir des fichiers
// et seulement ceux dont la quantité pour CampagneDepartDecompte est supérieure à 0
if (CombinerCorpsIdentiques && (ListeCorps.Count > 0))
{
var FiltreCampagne = IndiceCampagne;
if (CombinerAvecCampagnePrecedente)
{
FiltreCampagne = ListeCorps.CampagneDepartDecompte;
}
WindowLog.SautDeLigne();
WindowLog.Ecrire("Chargement des corps existants :");
foreach (var corps in ListeCorps.Values)
{
// On additionne les quantités pour les corps supperieur à filtreCampagne
// S
if (corps.Campagne.ContainsKey(FiltreCampagne) &&
corps.Campagne.Sum(d => d.Key >= FiltreCampagne? d.Value : 0) > 0 &&
File.Exists(corps.CheminFichierRepere)
)
{
WindowLog.EcrireF(" - {0}", corps.RepereComplet);
corps.ChargerCorps();
}
}
}
// On reinitialise la quantité pour la campagne actuelle à 0
foreach (var corps in ListeCorps.Values)
{
corps.InitCampagne(IndiceCampagne);
}
////////////////////////////////// DEBUT DU REPERAGE ////////////////////////////////////////////////////
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.eActiverManager(false);
WindowLog.SautDeLigne();
WindowLog.Ecrire("Debut du repérage");
// On recherche l'indice de repere max
if (ListeCorps.Count > 0)
{
_GenRepereDossier = ListeCorps.Keys.Max();
}
// On liste les composants
var ListeComposants = MdlBase.pListerComposants();
// On boucle sur les modeles
foreach (var mdl in ListeComposants.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
mdl.eActiverManager(false);
// On met à jour les options
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swDisableDerivedConfigurations)), 0, false);
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentRenameCutlistDescriptionPropertyValue)), 0, true);
mdl.Extension.SetUserPreferenceToggle(((int)(swUserPreferenceToggle_e.swWeldmentCollectIdenticalBodies)), 0, true);
mdl.Extension.SetUserPreferenceString(((int)(swUserPreferenceStringValue_e.swSheetMetalDescription)), 0, "Tôle");
if (mdl.ePartDoc().eDossierListeDesPiecesSoudees().GetAutomaticUpdate() == false)
{
mdl.ePartDoc().eMajListeDesPiecesSoudeesAuto(true);
mdl.EditRebuild3();
}
// On crée l'esquisse pour le reperage des dossiers
mdl.pEsquisseRepere();
// Si le modele est a repérer complètement
Boolean InitModele = true;
// On recherche l'index de la dimension maximum
int IndexDimension = 0;
// On liste les dossiers déja traité pour l'attribution des nouveaux index de dimension
HashSet <int> HashPieceIdDossiers = new HashSet <int>();
// Les données sont stockées dans des propriétés du modèle
// Le nom du modèle est stocké dans une propriété, si le modèle est copié
// la propriété n'est plus valable, on force le repérage
// On récupère également le dernier indice de la dimension utilisée
if (mdl.ePropExiste(CONST_PRODUCTION.ID_PIECE) && (mdl.eGetProp(CONST_PRODUCTION.ID_PIECE) == mdl.eNomSansExt()))
{
InitModele = false;
if (mdl.ePropExiste(CONST_PRODUCTION.MAX_INDEXDIM))
{
IndexDimension = mdl.eGetProp(CONST_PRODUCTION.MAX_INDEXDIM).eToInteger();
}
if (mdl.ePropExiste(CONST_PRODUCTION.PIECE_ID_DOSSIERS))
{
var tab = mdl.eGetProp(CONST_PRODUCTION.PIECE_ID_DOSSIERS).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var id in tab)
{
HashPieceIdDossiers.Add(id.eToInteger());
}
}
}
////////////////////////////////// BOUCLE SUR LES CONFIGS ////////////////////////////////////////////////////
foreach (var nomCfg in ListeComposants[mdl].Keys)
{
mdl.ShowConfiguration2(nomCfg);
mdl.EditRebuild3();
WindowLog.SautDeLigne();
WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), nomCfg);
HashSet <int> HashConfigIdDossiers = new HashSet <int>();
Boolean InitConfig = true;
int IdCfg = mdl.GetConfigurationByName(nomCfg).GetID();
// Idem modèle, on stock l'id de la config dans une propriété.
// Si une nouvelle config est crée, la valeur de cette propriété devient caduc,
// on repère alors les dossiers
// On en profite pour récupérer la liste des ids de dossiers déjà traité dans les précédentes
// campagne de repérage
if (!InitModele && mdl.ePropExiste(CONST_PRODUCTION.ID_CONFIG, nomCfg) && (mdl.eGetProp(CONST_PRODUCTION.ID_CONFIG, nomCfg) == IdCfg.ToString()))
{
InitConfig = false;
if (mdl.ePropExiste(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg))
{
var tab = mdl.eGetProp(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, nomCfg).Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var id in tab)
{
HashConfigIdDossiers.Add(id.eToInteger());
}
}
}
var piece = mdl.ePartDoc();
var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder Dossier = swD.GetSpecificFeature2();
// Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
if (Dossier.IsRef() && (Dossier.eNbCorps() > 0) && !Dossier.eEstExclu() &&
FiltrerCorps.HasFlag(Dossier.eTypeDeDossier()))
{
return(true);
}
return(false);
}
);
var NbConfig = ListeComposants[mdl][nomCfg];
////////////////////////////////// BOUCLE SUR LES DOSSIERS ////////////////////////////////////////////////////
foreach (var fDossier in ListeDossier)
{
BodyFolder Dossier = fDossier.GetSpecificFeature2();
int IdDossier = fDossier.GetID();
Dimension param = null;
if (!HashPieceIdDossiers.Contains(IdDossier))
{
param = CreerParam(mdl, fDossier, nomCfg, ++IndexDimension);
}
else
{
param = GetParam(mdl, fDossier, nomCfg);
}
var SwCorps = Dossier.ePremierCorps();
var NomCorps = SwCorps.Name;
var MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, nomCfg);
eTypeCorps TypeCorps = Dossier.eTypeDeDossier();
var nbCorps = Dossier.eNbCorps() * NbConfig;
int Repere = -1;
if (CombinerCorpsIdentiques)
{
// On recherche s'il existe des corps identiques
// Si oui, on applique le même repère au parametre
foreach (var CorpsTest in ListeCorps.Values)
{
if (CorpsTest.SwCorps.IsRef() &&
(CombinerAvecCampagnePrecedente || CorpsTest.Campagne.ContainsKey(IndiceCampagne)) &&
(MateriauCorps == CorpsTest.Materiau) &&
(TypeCorps == CorpsTest.TypeCorps) &&
SwCorps.eComparerGeometrie(CorpsTest.SwCorps) == Sw.Comparaison_e.Semblable)
{
Repere = CorpsTest.Repere;
SetRepere(param, CorpsTest.Repere, nomCfg);
break;
}
}
}
// Initialisation du repère
if (Repere.eEstNegatif())
{
// A tester
// Si on est mode "MajCampagnePrecedente", ça évite de repérer une seconde fois les pièces
// Si on est pas en mode "Combiner les corps"
// on recupère le repère du dossier
// Sinon c'est forcément un nouveau repère
if (!CombinerCorpsIdentiques)
{
Repere = GetRepere(param, nomCfg);
}
// Création d'un nouveau repère suivant conditions
// Dans tous les cas, si la clé est négative, on crée un nouveau repère
if (Repere.eEstNegatif() ||
InitConfig ||
!HashConfigIdDossiers.Contains(IdDossier) ||
!ListeCorps.ContainsKey(Repere))
{
Repere = GenRepereDossier;
SetRepere(param, Repere, nomCfg);
}
}
// Initialisation du corps
Corps corps = null;
if (!ListeCorps.ContainsKey(Repere))
{
corps = new Corps(SwCorps, TypeCorps, MateriauCorps, MdlBase);
corps.InitCampagne(IndiceCampagne);
ListeCorps.Add(Repere, corps);
}
else
{
corps = ListeCorps[Repere];
}
corps.Campagne[IndiceCampagne] += nbCorps;
corps.Repere = Repere;
corps.InitCaracteristiques(Dossier, SwCorps);
corps.AjouterModele(mdl, nomCfg, IdDossier, NomCorps);
HashPieceIdDossiers.Add(IdDossier);
HashConfigIdDossiers.Add(IdDossier);
WindowLog.EcrireF(" - {1} -> {0}", fDossier.Name, corps.RepereComplet);
}
mdl.ePropAdd(CONST_PRODUCTION.ID_CONFIG, IdCfg, nomCfg);
mdl.ePropAdd(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, String.Join(" ", HashConfigIdDossiers), nomCfg);
}
mdl.ePropAdd(CONST_PRODUCTION.ID_PIECE, mdl.eNomSansExt());
mdl.ePropAdd(CONST_PRODUCTION.PIECE_ID_DOSSIERS, String.Join(" ", HashPieceIdDossiers));
mdl.ePropAdd(CONST_PRODUCTION.MAX_INDEXDIM, IndexDimension);
mdl.eActiverManager(true);
mdl.eSauver();
mdl.eFermerSiDifferent(MdlBase);
}
MdlBase.eActiverManager(true);
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.EditRebuild3();
MdlBase.eSauver();
////////////////////////////////// FIN DU REPERAGE ////////////////////////////////////////////////////
// On fermer les fichiers chargé
foreach (var corps in ListeCorps.Values)
{
Sw.eFermer(corps.CheminFichierRepere);
}
WindowLog.SautDeLigne();
if (ListeCorps.Count > 0)
{
WindowLog.EcrireF("Nb de repères : {0}", ListeCorps.Keys.Max());
}
else
{
WindowLog.Ecrire("Aucun corps repéré");
}
// S'il n'y a aucun corps, on se barre
if (ListeCorps.Count == 0)
{
return;
}
////////////////////////////////// EXPORTER LES CORPS /////////////////////////////////////////////////
WindowLog.SautDeLigne();
WindowLog.Ecrire("Export des corps :");
foreach (var corps in ListeCorps.Values)
{
if (corps.Modele.IsNull())
{
continue;
}
// Si on est pas en mode "Combiner corps identique" et que le fichier existe
// on le supprime pour le mettre à jour, sinon on peut se retrouver
// avec des fichiers ne correpondants pas au corps
if (!CombinerCorpsIdentiques)
{
corps.SupprimerFichier();
}
// Si le fichier existe, on passe au suivant
if (File.Exists(corps.CheminFichierRepere))
{
continue;
}
WindowLog.EcrireF("- {0} exporté", CONSTANTES.PREFIXE_REF_DOSSIER + corps.Repere);
corps.SauverRepere(CreerDvp);
}
////////////////////////////////// RECAP /////////////////////////////////////////////////
// Petit récap
WindowLog.SautDeLigne();
WindowLog.EcrireF("Nb de corps unique : {0}", ListeCorps.Count);
int nbtt = 0;
foreach (var corps in ListeCorps.Values)
{
nbtt += corps.Campagne[IndiceCampagne];
if (corps.Campagne[IndiceCampagne] > 0)
{
WindowLog.EcrireF("{2} P{0} ×{1}", corps.Repere, corps.Campagne[IndiceCampagne], IndiceCampagne);
}
}
WindowLog.EcrireF("Nb total de corps : {0}", nbtt);
////////////////////////////////// SAUVEGARDE DE LA NOMENCLATURE /////////////////////////////////////////////
ListeCorps.EcrireNomenclature(MdlBase.pDossierPiece(), IndiceCampagne);
////////////////////////////////////////////////////////////////////////////////////////////////////////////
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
App.Sw.CommandInProgress = false;
var aff = new AffichageElementWPF(ListeCorps, IndiceCampagne);
aff.ShowDialog();
ListeCorps = null;
ListeComposants = null;
}
catch (Exception e) { this.LogErreur(new Object[] { e }); }
}
public ListeLgProfil Analyser()
{
InitTime();
try
{
listeElement = new ListeElement(LgBarre);
eTypeCorps Filtre = PrendreEnCompteTole ? eTypeCorps.Barre | eTypeCorps.Tole : eTypeCorps.Barre;
HashSet <String> HashMateriaux = new HashSet <string>(ListeMateriaux);
var dic = MdlBase.DenombrerDossiers(ComposantsExterne,
fDossier =>
{
BodyFolder swDossier = fDossier.GetSpecificFeature2();
if (Filtre.HasFlag(swDossier.eTypeDeDossier()) && HashMateriaux.Contains(swDossier.eGetMateriau()))
{
return(true);
}
return(false);
}
);
foreach (var mdl in dic.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
foreach (var NomConfigPliee in dic[mdl].Keys)
{
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
PartDoc Piece = mdl.ePartDoc();
var ListeDossier = dic[mdl][NomConfigPliee];
foreach (var t in ListeDossier)
{
var IdDossier = t.Key;
var QuantiteBarre = t.Value * Quantite;
Feature fDossier = Piece.FeatureById(IdDossier);
BodyFolder dossier = fDossier.GetSpecificFeature2();
var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
String Profil = dossier.eProp(CONSTANTES.PROFIL_NOM);
Double Longueur = dossier.eProp(CONSTANTES.PROFIL_LONGUEUR).eToDouble();
Double A = dossier.eProp(CONSTANTES.PROFIL_ANGLE1).eToDouble();
Double B = dossier.eProp(CONSTANTES.PROFIL_ANGLE2).eToDouble();
if (String.IsNullOrWhiteSpace(Profil) || (Longueur == 0))
{
continue;
}
if (String.IsNullOrWhiteSpace(RefDossier))
{
WindowLog.EcrireF("{0}-{1}-{2} : Pas de reférence profil", mdl.eNomSansExt(), NomConfigPliee, fDossier.Name);
continue;
}
var Materiau = dossier.ePremierCorps().eGetMateriauCorpsOuPiece(Piece, NomConfigPliee);
if (!HashMateriaux.Contains(Materiau))
{
continue;
}
Materiau = ForcerMateriau.IsRefAndNotEmpty(Materiau);
listeElement.AjouterElement(QuantiteBarre, RefDossier, Materiau, Profil, Longueur, A, B);
}
}
}
ExecuterEn();
return(listeElement.ListeLgProfil);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
return(null);
}
protected override void Command()
{
try
{
if (ConvertirEsquisse)
{
WindowLog.Ecrire("Attention !!!");
WindowLog.Ecrire("Les dvp seront convertis en esquisse");
WindowLog.SautDeLigne();
}
CreerDossierDVP();
eTypeCorps Filtre = eTypeCorps.Tole;
HashSet <String> HashMateriaux = new HashSet <string>(ListeMateriaux);
HashSet <String> HashEp = new HashSet <string>(ListeEp);
var dic = MdlBase.DenombrerDossiers(ComposantsExterne,
fDossier =>
{
BodyFolder swDossier = fDossier.GetSpecificFeature2();
if (Filtre.HasFlag(swDossier.eTypeDeDossier()) && HashMateriaux.Contains(swDossier.eGetMateriau()))
{
String Ep = swDossier.ePremierCorps().eEpaisseurCorps().ToString();
if (HashEp.Contains(Ep))
{
return(true);
}
}
return(false);
}
);
int MdlPct = 0;
foreach (var mdl in dic.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
WindowLog.SautDeLigne();
WindowLog.EcrireF("[{1}/{2}] {0}", mdl.eNomSansExt(), ++MdlPct, dic.Count);
int CfgPct = 0;
foreach (var NomConfigPliee in dic[mdl].Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF(" [{1}/{2}] Config : \"{0}\"", NomConfigPliee, ++CfgPct, dic[mdl].Count);
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
PartDoc Piece = mdl.ePartDoc();
var ListeDossier = dic[mdl][NomConfigPliee];
int DrPct = 0;
foreach (var t in ListeDossier)
{
var IdDossier = t.Key;
var QuantiteTole = t.Value * Quantite;
Feature fDossier = Piece.FeatureById(IdDossier);
BodyFolder dossier = fDossier.GetSpecificFeature2();
var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
Body2 Tole = dossier.eCorpsDeTolerie();
WindowLog.SautDeLigne();
WindowLog.EcrireF(" - [{1}/{2}] Dossier : \"{0}\" x{3}", RefDossier, ++DrPct, ListeDossier.Count, QuantiteTole);
String Materiau = Tole.eGetMateriauCorpsOuPiece(Piece, NomConfigPliee);
Materiau = ForcerMateriau.IsRefAndNotEmpty(Materiau);
Double Epaisseur = Tole.eEpaisseurCorps();
String NomConfigDepliee = Sw.eNomConfigDepliee(NomConfigPliee, RefDossier);
WindowLog.EcrireF(" Ep {0} / Materiau {1}", Epaisseur, Materiau);
WindowLog.EcrireF(" Config {0}", NomConfigDepliee);
if (ConvertirEsquisse)
{
if (!mdl.eListeNomConfiguration().Contains(NomConfigDepliee))
{
mdl.CreerConfigDepliee(NomConfigDepliee, NomConfigPliee);
}
WindowLog.EcrireF(" Configuration crée : {0}", NomConfigDepliee);
mdl.ShowConfiguration2(NomConfigDepliee);
Tole.DeplierTole(mdl, NomConfigDepliee);
}
else if (!mdl.ShowConfiguration2(NomConfigDepliee))
{
DicErreur.Add(mdl.eNomSansExt() + " -> cfg : " + NomConfigPliee + " - No : " + RefDossier + " = " + NomConfigDepliee);
WindowLog.EcrireF("La configuration n'éxiste pas");
continue;
}
mdl.EditRebuild3();
DrawingDoc dessin = CreerPlan(Materiau, Epaisseur);
dessin.eModelDoc2().eActiver();
Sheet Feuille = dessin.eFeuilleActive();
View v = CreerVueToleDvp(dessin, Feuille, Piece, NomConfigDepliee, RefDossier, Materiau, QuantiteTole, Epaisseur);
if (ConvertirEsquisse)
{
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
mdl.DeleteConfiguration2(NomConfigDepliee);
}
}
NouvelleLigne = true;
}
mdl.eFermerSiDifferent(MdlBase);
}
foreach (DrawingDoc dessin in DicDessins.Values)
{
int Errors = 0, Warnings = 0;
dessin.eModelDoc2().eActiver();
dessin.eFeuilleActive().eAjusterAutourDesVues();
dessin.eModelDoc2().ViewZoomtofit2();
dessin.eModelDoc2().Save3((int)swSaveAsOptions_e.swSaveAsOptions_SaveReferenced + (int)swSaveAsOptions_e.swSaveAsOptions_Silent, ref Errors, ref Warnings);
}
if (FermerPlan)
{
foreach (ModelDoc2 dessin in DicDessins.Values)
{
dessin.eFermer();
}
}
if (DicErreur.Count > 0)
{
WindowLog.SautDeLigne();
WindowLog.Ecrire("Liste des erreurs :");
foreach (var item in DicErreur)
{
WindowLog.Ecrire(" - " + item);
}
WindowLog.SautDeLigne();
}
else
{
WindowLog.Ecrire("Pas d'erreur");
}
File.WriteAllText(Path.Combine(DossierDVP, "Log_CreerDvp.txt"), WindowLog.Resume);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
try
{
Face2 Face = MdlBase.eSelect_RecupererObjet <Face2>();
if (Face.IsNull())
{
WindowLog.Ecrire("Pas de face selectionnée");
return;
}
Body2 CorpsBase = Face.GetBody();
if (CorpsBase.IsNull())
{
WindowLog.Ecrire("Pas de corps selectionnée");
return;
}
String MateriauxCorpsBase = "";
if (MdlBase.TypeDoc() == eTypeDoc.Piece)
{
MateriauxCorpsBase = CorpsBase.eGetMateriauCorpsOuPiece(MdlBase.ePartDoc(), MdlBase.eNomConfigActive());
}
else
{
Component2 cpCorpsBase = MdlBase.eSelect_RecupererComposant();
MateriauxCorpsBase = CorpsBase.eGetMateriauCorpsOuComp(cpCorpsBase);
}
MdlBase.eEffacerSelection();
WindowLog.Ecrire("Matériau : " + MateriauxCorpsBase);
var ListeCorpsIdentiques = new List <Body2>();
Action <Body2, String> Test = delegate(Body2 corps, String mat)
{
if (MateriauxCorpsBase != mat)
{
return;
}
if (corps.eComparerGeometrie(CorpsBase) == Sw.Comparaison_e.Semblable)
{
ListeCorpsIdentiques.Add(corps);
}
};
if (MdlBase.TypeDoc() == eTypeDoc.Piece)
{
var Piece = MdlBase.ePartDoc();
foreach (var Corps in Piece.eListeCorps())
{
var MateriauCorpsTest = Corps.eGetMateriauCorpsOuPiece(Piece, MdlBase.eNomConfigActive());
Test(Corps, MateriauCorpsTest);
}
}
else
{
foreach (var comp in MdlBase.eComposantRacine().eRecListeComposant(c => { return(c.TypeDoc() == eTypeDoc.Piece); }))
{
foreach (var Corps in comp.eListeCorps())
{
var MateriauCorpsTest = Corps.eGetMateriauCorpsOuComp(comp);
Test(Corps, MateriauCorpsTest);
}
}
}
WindowLog.EcrireF("Nb de corps identiques : {0}", ListeCorpsIdentiques.Count);
foreach (var corps in ListeCorpsIdentiques)
{
corps.eSelect(true);
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
try
{
var ListeComposants = MdlBase.ListerComposants(false);
eTypeCorps Filtre = eTypeCorps.Barre | eTypeCorps.Tole;
var Dic = new HashSet <String>();
Boolean Erreur = false;
Predicate <Feature> Test =
f =>
{
BodyFolder dossier = f.GetSpecificFeature2();
if (dossier.IsRef() && dossier.eNbCorps() > 0 && Filtre.HasFlag(dossier.eTypeDeDossier()))
{
var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
if (String.IsNullOrWhiteSpace(RefDossier))
{
return(true);
}
}
return(false);
};
foreach (var mdl in ListeComposants.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
foreach (var t in ListeComposants[mdl])
{
var cfg = t.Key;
var nbCfg = t.Value;
mdl.ShowConfiguration2(cfg);
mdl.EditRebuild3();
var Piece = mdl.ePartDoc();
foreach (var fDossier in Piece.eListeDesFonctionsDePiecesSoudees(Test))
{
WindowLog.EcrireF("{0} \"{1}\"", mdl.eNomSansExt(), cfg);
WindowLog.EcrireF(" {0} : Pas de reference", fDossier.Name);
Erreur = true;
}
}
mdl.eFermerSiDifferent(MdlBase);
}
if (!Erreur)
{
WindowLog.Ecrire("Aucune erreur\n");
}
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
private void IndiceMax()
{
eTypeCorps Filtre = eTypeCorps.Barre | eTypeCorps.Tole;
var ListeComposants = MdlBase.ListerComposants(false);
Func <Feature, Tuple <String, String> > ExtractRef = delegate(Feature dossier)
{
CustomPropertyManager PM = dossier.CustomPropertyManager;
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
return(new Tuple <String, String>(result.Replace(CONSTANTES.PREFIXE_REF_DOSSIER, ""), val));
};
Predicate <Feature> Test = delegate(Feature f)
{
BodyFolder dossier = f.GetSpecificFeature2();
if (dossier.IsRef() && dossier.eNbCorps() > 0 && Filtre.HasFlag(dossier.eTypeDeDossier()))
{
CustomPropertyManager PM = f.CustomPropertyManager;
String val, result = ""; Boolean wasResolved, link;
var r = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
var RefDossier = ExtractRef(f).Item1;
if (RefDossier.eIsInteger())
{
return(true);
}
}
return(false);
};
foreach (var mdl in ListeComposants.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
foreach (var t in ListeComposants[mdl])
{
var cfg = t.Key;
var nbCfg = t.Value;
mdl.ShowConfiguration2(cfg);
mdl.EditRebuild3();
var Piece = mdl.ePartDoc();
foreach (var f in Piece.eListeDesFonctionsDePiecesSoudees(Test))
{
var RefDossier = ExtractRef(f);
indice = Math.Max(indice, RefDossier.Item1.eToInteger());
var hashDossier = HashDossier(mdl, f);
DossierTraite.Add(hashDossier);
// On recherche l'index max pour chaque modele
var NomParam = ExtractNomParam(RefDossier.Item2);
var dim = NomParam.Split('@')[0].CleanStringOfNonDigits().eToInteger();
var hashMdl = mdl.GetPathName();
if (IndexDimension.ContainsKey(hashMdl))
{
IndexDimension[hashMdl] = Math.Max(IndexDimension[hashMdl], dim);
}
else
{
IndexDimension[hashMdl] = dim;
}
}
}
mdl.eFermerSiDifferent(MdlBase);
}
WindowLog.EcrireF("Indice Max : {0}", indice);
}
private String CreerBarre(Corps corps)
{
string CheminFichierExportBarre = "";
if (!corps.Dvp)
{
return(CheminFichierExportBarre);
}
var QuantiteDiff = Quantite * (corps.Qte + corps.QteSup);
var cheminFichier = corps.CheminFichierRepere;
if (!File.Exists(cheminFichier))
{
return(CheminFichierExportBarre);
}
String Repere = corps.RepereComplet;
String Profil = corps.Dimension;
String Longueur = corps.Volume;
String Materiau = corps.Materiau;
String NomFichierBarre = ConstruireNomFichierBarre(Repere, IndiceCampagne, QuantiteDiff);
var mdlCorps = Sw.eOuvrir(cheminFichier);
if (mdlCorps.IsNull())
{
return(CheminFichierExportBarre);
}
var Piece = mdlCorps.ePartDoc();
corps.SwCorps = Piece.ePremierCorps();
Body2 Barre = corps.SwCorps;
if (corps.Maj)
{
WindowLog.EcrireF("{0} x{1}", corps.RepereComplet, QuantiteDiff);
}
mdlCorps.EditRebuild3();
try
{
List <String> Liste = new List <String>()
{
Repere, Materiau, Profil, Math.Round(Longueur.eToDouble()).ToString(), "× " + QuantiteDiff.ToString()
};
if (ListerUsinages)
{
var analyse = new AnalyseBarre(Barre, mdlCorps);
Dictionary <String, Double> Dic = new Dictionary <string, double>();
foreach (var u in analyse.ListeFaceUsinageSection)
{
String nom = u.ListeFaceDecoupe.Count + " face - Lg " + Math.Round(u.LgUsinage * 1000, 1);
if (Dic.ContainsKey(nom))
{
Dic[nom] += 1;
}
else
{
Dic.Add(nom, 1);
}
}
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[0].LgUsinage * 1000, 1).ToString());
if (analyse.ListeFaceUsinageExtremite.Count > 1)
{
Liste.Add(Math.Round(analyse.ListeFaceUsinageExtremite[1].LgUsinage * 1000, 1).ToString());
}
else
{
Liste.Add("");
}
foreach (var nom in Dic.Keys)
{
Liste.Add(Dic[nom] + "x [ " + nom + " ]");
}
}
Nomenclature.AjouterLigne(Liste.ToArray());
if (corps.Maj && ExporterBarres)
{
ModelDoc2 mdlBarre = Barre.eEnregistrerSous(Piece, DossierBarre, NomFichierBarre, TypeExport, out CheminFichierExportBarre);
if (CreerPdf3D)
{
String CheminPDF = Path.Combine(DossierBarrePDF, NomFichierBarre + eTypeFichierExport.PDF.GetEnumInfo <ExtFichier>());
mdlBarre.SauverEnPdf3D(CheminPDF);
}
mdlBarre.eFermer();
}
}
catch (Exception e)
{
WindowLog.Ecrire(" - Erreur");
this.LogMethode(new Object[] { e });
}
finally
{
WindowLog.Ecrire(" - Ok");
}
mdlCorps.eFermer();
return(CheminFichierExportBarre);
}
protected override void Command()
{
try
{
// On liste les composants
var ListeComposants = MdlBase.pListerComposants();
// On boucle sur les modeles
foreach (var mdl in ListeComposants.Keys)
{
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
foreach (var nomCfg in ListeComposants[mdl].Keys)
{
mdl.ShowConfiguration2(nomCfg);
mdl.EditRebuild3();
var piece = mdl.ePartDoc();
var ListeDossier = piece.eListeDesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder Dossier = swD.GetSpecificFeature2();
// Si le dossier est la racine d'un sous-ensemble soudé, il n'y a rien dedans
if (Dossier.IsRef() && (Dossier.eEstExclu() == false) && (Dossier.eNbCorps() > 0) &&
(eTypeCorps.Barre).HasFlag(Dossier.eTypeDeDossier()))
{
return(true);
}
return(false);
}
);
var NbConfig = ListeComposants[mdl][nomCfg];
foreach (var fDossier in ListeDossier)
{
BodyFolder Dossier = fDossier.GetSpecificFeature2();
var SwCorps = Dossier.ePremierCorps();
var NomCorps = SwCorps.Name;
var MateriauCorps = SwCorps.eGetMateriauCorpsOuPiece(piece, nomCfg);
var NbCorps = Dossier.eNbCorps() * NbConfig;
var Profil = Dossier.eProfilDossier();
var Longueur = Dossier.eLongueurProfilDossier().eToDouble();
for (int i = 0; i < NbCorps; i++)
{
var LgTmp = Longueur;
while (LgTmp > LgMax)
{
RassemblerBarre(MateriauCorps, Profil, LgMax);
LgTmp -= LgMax;
}
RassemblerBarre(MateriauCorps, Profil, LgTmp);
}
}
}
mdl.eFermerSiDifferent(MdlBase);
}
// On fait la mise en barre
foreach (var Materiau in DicBarres.Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF("{0}", Materiau);;
foreach (var Profil in DicBarres[Materiau].Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF(" {0}", Profil);
var lst = DicBarres[Materiau][Profil];
lst.Sort();
lst.Reverse();
foreach (var lg in lst)
{
WindowLog.EcrireF(" - {0}", lg);
}
int i = 0;
while (true)
{
var lg = lst[i];
if (AjouterBarre(Materiau, Profil, lg))
{
lst.RemoveAt(i);
if (lst.Count == 0)
{
break;
}
}
else
{
i++;
}
if (i >= lst.Count)
{
i = 0;
NouvelleBarre(Materiau, Profil);
}
}
}
}
String Resume = "";
foreach (var Materiau in DicMateriau.Keys)
{
Resume += System.Environment.NewLine;
Resume += String.Format("{0}", Materiau);
foreach (var Profil in DicMateriau[Materiau].Keys)
{
var Ligne = DicMateriau[Materiau][Profil];
Resume += System.Environment.NewLine;
Resume += String.Format(" {1,4}× {0,-25} [{2:N0}]", Profil, Ligne.NbBarre, Ligne.Reste);
}
}
WindowLog.SautDeLigne();
WindowLog.Ecrire("A commander");
WindowLog.Ecrire(Resume);
WindowLog.SautDeLigne();
File.WriteAllText(Path.Combine(MdlBase.eDossier(), "CommandeProfil.txt"), Resume);
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
protected override void Command()
{
try
{
int NbDvp = 0;
var dic = MdlBase.ListerComposants(false);
int MdlPct = 0;
foreach (var mdl in dic.Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF("[{1}/{2}] {0}", mdl.eNomSansExt(), ++MdlPct, dic.Count);
mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
var cfgActive = mdl.eNomConfigActive();
var ListeNomConfigs = dic[mdl];
if (ToutesLesConfigurations)
{
mdl.eParcourirConfiguration(
(String c) =>
{
if (c.eEstConfigPliee() && !ListeNomConfigs.ContainsKey(c))
{
ListeNomConfigs.Add(c, 1);
}
return(false);
}
);
}
if (MasquerEsquisses)
{
cmdMasquerEsquisses(mdl);
}
if (SupprimerLesAnciennesConfigs)
{
cmdSupprimerLesAnciennesConfigs(mdl);
}
if (!mdl.Extension.LinkedDisplayState)
{
mdl.Extension.LinkedDisplayState = true;
foreach (var c in mdl.eListeConfigs(eTypeConfig.Tous))
{
c.eRenommerEtatAffichage();
}
}
int CfgPct = 0;
foreach (var NomConfigPliee in ListeNomConfigs.Keys)
{
WindowLog.SautDeLigne();
WindowLog.EcrireF(" [{1}/{2}] Config : \"{0}\"", NomConfigPliee, ++CfgPct, ListeNomConfigs.Count);
mdl.ShowConfiguration2(NomConfigPliee);
mdl.EditRebuild3();
if (SupprimerFonctions)
{
cmdSupprimerFonctions(mdl, NomConfigPliee);
}
PartDoc Piece = mdl.ePartDoc();
var ListeDossier = Piece.eListePIDdesFonctionsDePiecesSoudees(
swD =>
{
BodyFolder dossier = swD.GetSpecificFeature2();
if (dossier.eEstExclu() || dossier.IsNull() || (dossier.GetBodyCount() == 0) || dossier.eTypeDeDossier() != eTypeCorps.Tole)
{
return(false);
}
return(true);
}
);
for (int noD = 0; noD < ListeDossier.Count; noD++)
{
var f = ListeDossier[noD];
BodyFolder dossier = f.GetSpecificFeature2();
var RefDossier = dossier.eProp(CONSTANTES.REF_DOSSIER);
Body2 Tole = dossier.eCorpsDeTolerie();
var pidTole = new SwObjectPID <Body2>(Tole, MdlBase);
String NomConfigDepliee = Sw.eNomConfigDepliee(NomConfigPliee, RefDossier);
WindowLog.EcrireF(" - [{1}/{2}] Dossier : \"{0}\" -> {3}", f.Name, noD + 1, ListeDossier.Count, NomConfigDepliee);
Configuration CfgDepliee = null;
if (ReconstuireLesConfigs)
{
CfgDepliee = MdlBase.GetConfigurationByName(NomConfigDepliee);
}
if (CfgDepliee.IsNull())
{
CfgDepliee = mdl.CreerConfigDepliee(NomConfigDepliee, NomConfigPliee);
}
else if (!ReconstuireLesConfigs)
{
continue;
}
if (CfgDepliee.IsNull())
{
WindowLog.Ecrire(" - Config non crée");
continue;
}
NbDvp++;
try
{
mdl.ShowConfiguration2(NomConfigDepliee);
// On ajoute le numero de la config parent aux propriétés de la configuration depliée
CfgDepliee.CustomPropertyManager.Add3(CONSTANTES.NO_CONFIG, (int)swCustomInfoType_e.swCustomInfoText, NomConfigPliee, (int)swCustomPropertyAddOption_e.swCustomPropertyDeleteAndAdd);
pidTole.Maj(ref Tole);
Tole.DeplierTole(mdl, NomConfigDepliee);
}
catch (Exception e)
{
DicErreur.Add(mdl.eNomSansExt() + " -> cfg : " + NomConfigPliee + " - No : " + RefDossier + " = " + NomConfigDepliee);
WindowLog.Ecrire("Erreur de depliage");
this.LogMethode(new Object[] { e });
}
try
{
mdl.ShowConfiguration2(NomConfigPliee);
pidTole.Maj(ref Tole);
Tole.PlierTole(mdl, NomConfigPliee);
}
catch (Exception e)
{
WindowLog.Ecrire("Erreur de repliage");
this.LogMethode(new Object[] { e });
}
}
}
mdl.ShowConfiguration2(cfgActive);
WindowLog.SautDeLigne();
mdl.eFermerSiDifferent(MdlBase);
}
if (DicErreur.Count > 0)
{
WindowLog.SautDeLigne();
WindowLog.Ecrire("Liste des erreurs :");
foreach (var item in DicErreur)
{
WindowLog.Ecrire(" - " + item);
}
WindowLog.SautDeLigne();
}
else
{
WindowLog.Ecrire("Pas d'erreur");
}
WindowLog.SautDeLigne();
WindowLog.Ecrire("Resultat :");
WindowLog.Ecrire("----------------");
WindowLog.EcrireF(" {0} dvp crées", NbDvp);
File.WriteAllText(Path.Combine(MdlBase.eDossier(), "Log_CreerConfigDvp.txt"), WindowLog.Resume);
MdlBase.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
MdlBase.ShowConfiguration2(nomConfigBase);
MdlBase.EditRebuild3();
}
catch (Exception e)
{
this.LogErreur(new Object[] { e });
}
}
private GeomVue AppliquerOptionsVue(DrawingDoc dessin, PartDoc piece, View vue)
{
vue.ShowSheetMetalBendNotes = AfficherNotePliage;
MathUtility SwMath = App.Sw.GetMathUtility();
ModelDoc2 mdl = dessin.eModelDoc2();
Body2 c = piece.eChercherCorps(CONSTANTES.NOM_CORPS_DEPLIEE, true);
GeomVue g = null;
c.eFonctionEtatDepliee().eParcourirSousFonction(
f =>
{
if (f.Name.StartsWith(CONSTANTES.LIGNES_DE_PLIAGE))
{
String NomSelection = f.Name + "@" + vue.RootDrawingComponent.Name + "@" + vue.Name;
mdl.Extension.SelectByID2(NomSelection, "SKETCH", 0, 0, 0, false, 0, null, 0);
if (AfficherLignePliage)
{
mdl.UnblankSketch();
}
else
{
mdl.BlankSketch();
}
mdl.eEffacerSelection();
}
else if (f.Name.StartsWith(CONSTANTES.CUBE_DE_VISUALISATION))
{
try
{
f.eModifierEtat(swFeatureSuppressionAction_e.swUnSuppressFeature);
Sketch Esquisse = f.GetSpecificFeature2();
if (OrienterDvp)
{
Double Angle = AngleCubeDeVisualisation(vue, Esquisse);
// On oriente la vue
switch (OrientationDvp)
{
case eOrientation.Portrait:
if (Math.Abs(Angle) != MathX.eRad90D)
{
Double a = MathX.eRad90D - Math.Abs(Angle);
vue.Angle = (Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a;
}
break;
case eOrientation.Paysage:
if (Math.Abs(Angle) != 0 || Math.Abs(Angle) != MathX.eRad180D)
{
Double a = MathX.eRad90D - Math.Abs(Angle);
vue.Angle = ((Math.Sign(Angle) == 0 ? 1 : Math.Sign(Angle)) * a) - MathX.eRad90D;
}
break;
default:
break;
}
}
g = new GeomVue(vue, Esquisse);
}
catch
{
WindowLog.EcrireF("Impossible d'orienter la vue : {0}", vue.Name);
}
return(true);
}
return(false);
}
);
return(g);
}
