Beispiel #1
0
        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);
            }
        }
Beispiel #2
0
        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 });
            }
        }
Beispiel #3
0
        protected void Rechercher_Infos()
        {
            WindowLog.Ecrire("Recherche des materiaux : ");

            ListeMateriaux = MdlBase.ListeMateriaux(eTypeCorps.Tole);

            foreach (var m in ListeMateriaux)
            {
                WindowLog.Ecrire(" - " + m);
            }

            WindowLog.SautDeLigne();

            _TextListBox_Materiaux.Liste = ListeMateriaux;
            _TextListBox_Materiaux.ToutSelectionner(false);
            _TextComboBox_ForcerMateriau.Liste         = ListeMateriaux;
            _TextComboBox_ForcerMateriau.SelectedIndex = 0;

            WindowLog.Ecrire("Recherche des ep de tôle : ");

            ListeEp = MdlBase.ListeEp();

            foreach (var m in ListeEp)
            {
                WindowLog.Ecrire(" - ep" + m);
            }

            WindowLog.SautDeLigne();

            _TextListBox_Ep.Liste = ListeEp;
            _TextListBox_Ep.ToutSelectionner(false);
        }
        private Boolean CreerConfigs()
        {
            Dictionary <String, ModelDoc2> ListeMdl = new Dictionary <String, ModelDoc2>()
            {
                { MdlBase.GetPathName(), MdlBase }
            };
            Dictionary <String, String> ListeMdlDisplayState = new Dictionary <string, string>()
            {
                { MdlBase.GetPathName(), MdlBase.eComposantRacine().ReferencedDisplayState }
            };

            foreach (Component2 cp in ListeComposants)
            {
                ModelDoc2 mdl = cp.GetModelDoc2();
                ListeMdl.AddIfNotExist(mdl.GetPathName(), mdl);
                ListeMdlDisplayState.AddIfNotExist(mdl.GetPathName(), cp.ReferencedDisplayState);

                foreach (Component2 cpParent in cp.eListeComposantParent())
                {
                    ModelDoc2 mdlParent = cpParent.GetModelDoc2();
                    ListeMdl.AddIfNotExist(mdlParent.GetPathName(), mdlParent);
                    ListeMdlDisplayState.AddIfNotExist(mdlParent.GetPathName(), cpParent.ReferencedDisplayState);
                }
            }

            int Options = (int)swConfigurationOptions2_e.swConfigOption_InheritProperties;

            if (SupprimerNvlFonction)
            {
                Options += (int)swConfigurationOptions2_e.swConfigOption_SuppressByDefault;
            }

            if (SupprimerNvComposant)
            {
                Options += (int)swConfigurationOptions2_e.swConfigOption_HideByDefault;
            }

            if ((ListeConfig.IsRef()) && (ListeConfig.Count > 0) && !String.IsNullOrWhiteSpace(ListeConfig[0]))
            {
                foreach (ModelDoc2 mdl in ListeMdl.Values)
                {
                    WindowLog.Ecrire(mdl.eNomAvecExt());
                    WindowLog.Ecrire(" - " + String.Join(" ", ListeConfig));
                    foreach (String nomConfig in ListeConfig)
                    {
                        String NomCurrentDisplayState = ListeMdlDisplayState[mdl.GetPathName()];

                        mdl.eAddConfiguration(nomConfig, nomConfig, "", Options);
                    }

                    WindowLog.SautDeLigne();
                }

                return(true);
            }

            return(false);
        }
Beispiel #5
0
        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 });
            }
        }
Beispiel #6
0
        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));
        }
Beispiel #7
0
        protected override void Command()
        {
            try
            {
                WindowLog.Ecrire("Nettoyer les blocs :");

                SupprimerDefBloc(MdlBase);

                WindowLog.SautDeLigne();
                WindowLog.Ecrire("Nettoyage terminé");
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }
Beispiel #8
0
            protected void Rechercher_Materiaux()
            {
                WindowLog.Ecrire("Recherche des materiaux : ");

                ListeMateriaux = MdlBase.ListeMateriaux(_CheckBox_PrendreEnCompteTole.IsChecked ? eTypeCorps.Tole | eTypeCorps.Barre : eTypeCorps.Barre);

                foreach (var m in ListeMateriaux)
                {
                    WindowLog.Ecrire(" - " + m);
                }

                WindowLog.SautDeLigne();

                _TextListBox_Materiaux.Liste = ListeMateriaux;
                _TextListBox_Materiaux.ToutSelectionner(false);
                _TextComboBox_ForcerMateriau.Liste         = ListeMateriaux;
                _TextComboBox_ForcerMateriau.SelectedIndex = 0;
            }
Beispiel #9
0
        protected void Rechercher_Infos()
        {
            try
            {
                WindowLog.Ecrire("Recherche des materiaux et profils ");

                ListeCorps     = MdlBase.pChargerNomenclature(eTypeCorps.Barre);
                ListeMateriaux = new List <String>();
                ListeProfil    = new List <String>();
                Campagne       = 1;

                foreach (var corps in ListeCorps.Values)
                {
                    Campagne = Math.Max(Campagne, corps.Campagne.Keys.Max());

                    ListeMateriaux.AddIfNotExist(corps.Materiau);
                    ListeProfil.AddIfNotExist(corps.Dimension);
                }

                WindowLog.SautDeLigne();

                ListeMateriaux.Sort(new WindowsStringComparer());
                ListeProfil.Sort(new WindowsStringComparer());

                _TextBox_Campagne.Text = Campagne.ToString();

                _TextListBox_Materiaux.Liste = ListeMateriaux;
                _TextListBox_Materiaux.ToutSelectionner(false);

                _TextListBox_Profils.Liste = ListeProfil;
                _TextListBox_Profils.ToutSelectionner(false);

                if (!File.Exists(Path.Combine(MdlBase.pDossierLaserTube(), Campagne.ToString(), CONST_PRODUCTION.FICHIER_NOMENC)))
                {
                    _CheckBox_MettreAjourCampagne.IsEnabled = false;
                    _CheckBox_MettreAjourCampagne.Visible   = false;
                }
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Beispiel #10
0
        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 });
            }
        }
        protected override void Command()
        {
            try
            {
                DrawingDoc dessin = MdlBase.eDrawingDoc();

                String FeuilleCourante = dessin.eFeuilleActive().GetName();

                Boolean HauteQualite = true;

                WindowLog.Ecrire("Haute qualité : " + (HauteQualite ? "oui" : "non"));
                WindowLog.SautDeLigne();

                MdlBase.Extension.UsePageSetup = (int)swPageSetupInUse_e.swPageSetupInUse_DrawingSheet;

                App.Sw.RunCommand((int)swCommands_e.swCommands_Page_Setup, "");

                dessin.eParcourirLesFeuilles(
                    f =>
                {
                    //dessin.ActivateSheet(f.GetName());
                    WindowLog.Ecrire(" - " + f.GetName());
                    String res = dessin.eMettreEnPagePourImpression(f, swPageSetupDrawingColor_e.swPageSetup_AutomaticDrawingColor, HauteQualite);
                    WindowLog.Ecrire("    " + res);
                    WindowLog.SautDeLigne();
                    return(false);
                }
                    );

                //dessin.ActivateSheet(FeuilleCourante);
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }
Beispiel #12
0
        /// <summary>
        /// Liste les corps avec Composant.eListeDesCorps()
        /// </summary>
        protected void OldCommand()
        {
            try
            {
                Dictionary <String, Piece> _DicPiece = new Dictionary <String, Piece>();
                int NbTotalComposant = 0;

                // Si c'est une piece, on ajoute le composant racine
                if (MdlBase.TypeDoc() == eTypeDoc.Piece)
                {
                    _DicPiece.Add(MdlBase.eComposantRacine().eKeyAvecConfig(), new Piece(MdlBase.eComposantRacine()));
                    NbTotalComposant = 1;
                }

                // Si c'est un assemblage, on liste les composants
                if (MdlBase.TypeDoc() == eTypeDoc.Assemblage)
                {
                    MdlBase.eRecListeComposant(
                        c =>
                    {
                        if (!c.IsHidden(false) && (c.TypeDoc() == eTypeDoc.Piece))
                        {
                            if (_DicPiece.ContainsKey(c.eKeyAvecConfig()))
                            {
                                _DicPiece[c.eKeyAvecConfig()].Nb += 1;
                                return(true);
                            }

                            _DicPiece.Add(c.eKeyAvecConfig(), new Piece(c));
                            NbTotalComposant++;
                            return(true);
                        }
                        return(false);
                    },
                        null,
                        true);
                }


                WindowLog.Ecrire("Nb de composants : " + NbTotalComposant);
                WindowLog.SautDeLigne();

                List <Piece> ListePiece = _DicPiece.Values.ToList <Piece>();

                // On trie
                ListePiece.Sort((c1, c2) => { WindowsStringComparer sc = new WindowsStringComparer(); return(sc.Compare(c1.Composant.eKeyAvecConfig(), c2.Composant.eKeyAvecConfig())); });

                Ensemble Ensemble = new Ensemble();

                foreach (Piece piece in ListePiece)
                {
                    WindowLog.Ecrire(piece.Nb + " × " + piece.Composant.eNomAvecExt() + " Config \"" + piece.Composant.eNomConfiguration() + "\"");
                    WindowLog.Ecrire(" -> Mat : " + piece.Info.Materiau + " / Base : " + piece.Info.Base);

                    foreach (Body2 corps in piece.Composant.eListeCorps())
                    {
                        Info InfoCorps = piece.AjouterCorps(corps);

                        String herite = InfoCorps.Herite ? " (herité) " : "";

                        String Ligne = String.Format(" -- {0} -> {1} : {2:0.0} kg / Base : {3}{4}",
                                                     corps.Name,
                                                     InfoCorps.Materiau,
                                                     InfoCorps.Masse,
                                                     InfoCorps.Base,
                                                     herite
                                                     );

                        WindowLog.Ecrire(Ligne);
                    }

                    Ensemble.AjouterPiece(piece);

                    if (piece.Masse > 0.01)
                    {
                        List <String> TextePiece = new List <String>();
                        foreach (String classe in piece.ListeClasse.Keys)
                        {
                            Double Masse = 0;

                            foreach (Info i in piece.ListeClasse[classe].Values)
                            {
                                Masse += i.Masse;
                                TextePiece.Add(String.Format("  -- {0} : {1:0.0} kg", i.Materiau, i.Masse));
                            }
                            TextePiece.Insert(0, String.Format("  {0} : {1:0.0} kg", classe, Masse));
                        }
                        TextePiece.Insert(0, String.Format("Poids de la piece : {0:0.0} kg", piece.Masse));
                        WindowLog.Ecrire(TextePiece);
                        WindowLog.SautDeLigne();
                    }
                }

                WindowLog.SautDeLigne();

                WindowLog.Ecrire("Resultat :");
                WindowLog.Ecrire("----------------");

                List <String> TexteEnsemble = new List <String>();
                foreach (String classe in Ensemble.ListeClasse.Keys)
                {
                    Double Masse = 0;

                    List <String> Texte = new List <String>();
                    foreach (Info i in Ensemble.ListeClasse[classe].Values)
                    {
                        Masse += i.Masse;
                        Texte.Add(String.Format("  -- {0} : {1:0.0} kg", i.Materiau, i.Masse));
                    }

                    if (Masse > 0.01)
                    {
                        TexteEnsemble.Add(String.Format("  {0} : {1:0.0} kg", classe, Masse));
                        TexteEnsemble.AddRange(Texte);
                    }
                }
                TexteEnsemble.Insert(0, String.Format("Poids de l'ensemble : {0:0.0} kg", Ensemble.Masse));
                WindowLog.Ecrire(TexteEnsemble);
                WindowLog.SautDeLigne();
            }
            catch (Exception e)
            { Log.Message(e); }
        }
Beispiel #13
0
        /// <summary>
        /// Liste les corps avec Composant.eListeDesDossiersDePiecesSoudees().eListeDesCorps()
        /// Permet de regrouper
        /// </summary>
        protected override void Command()
        {
            try
            {
                Dictionary <String, Piece> _DicPiece = new Dictionary <String, Piece>();
                int NbTotalComposant = 0;

                // Si c'est une piece, on ajoute le composant racine
                if (MdlBase.TypeDoc() == eTypeDoc.Piece)
                {
                    _DicPiece.Add(MdlBase.eComposantRacine().eKeyAvecConfig(), new Piece(MdlBase.eComposantRacine()));
                    NbTotalComposant = 1;
                }

                // Si c'est un assemblage, on liste les composants
                if (MdlBase.TypeDoc() == eTypeDoc.Assemblage)
                {
                    MdlBase.eRecListeComposant(
                        c =>
                    {
                        if (!c.IsHidden(false) && (c.TypeDoc() == eTypeDoc.Piece))
                        {
                            if (_DicPiece.ContainsKey(c.eKeyAvecConfig()))
                            {
                                _DicPiece[c.eKeyAvecConfig()].Nb += 1;
                                return(true);
                            }

                            _DicPiece.Add(c.eKeyAvecConfig(), new Piece(c));
                            NbTotalComposant++;
                            return(true);
                        }
                        return(false);
                    },
                        null,
                        true);
                }


                WindowLog.Ecrire("Nb de composants : " + NbTotalComposant);
                WindowLog.SautDeLigne();

                List <Piece> ListePiece = _DicPiece.Values.ToList <Piece>();

                // On trie
                ListePiece.Sort((c1, c2) => { WindowsStringComparer sc = new WindowsStringComparer(); return(sc.Compare(c1.Composant.eKeyAvecConfig(), c2.Composant.eKeyAvecConfig())); });

                Ensemble Ensemble = new Ensemble();

                foreach (Piece piece in ListePiece)
                {
                    WindowLog.Ecrire(piece.Nb + " × " + piece.Composant.eNomSansExt() + " Config \"" + piece.Composant.eNomConfiguration() + "\"");
                    WindowLog.Ecrire(" -> Mat : " + piece.Info.Materiau + " / Base : " + piece.Info.Base);

                    var ListeDossier = piece.Composant.eListeDesDossiersDePiecesSoudees();

                    if (piece.Composant.IsRoot())
                    {
                        ListeDossier = piece.Composant.ePartDoc().eListeDesDossiersDePiecesSoudees();
                    }

                    foreach (var dossier in ListeDossier)
                    {
                        if (dossier.eNbCorps() == 0)
                        {
                            continue;
                        }

                        var listeCorps = dossier.eListeDesCorps();

                        if (listeCorps.IsNull())
                        {
                            continue;
                        }

                        Body2 corps = listeCorps[0];

                        Info InfoCorps = piece.AjouterCorps(corps, dossier.eNbCorps());

                        String herite = InfoCorps.Herite ? " (herité) " : "";

                        String nomCorps = corps.Name;
                        if (!dossier.eNom().eIsLike(CONSTANTES.ARTICLE_LISTE_DES_PIECES_SOUDEES, false))
                        {
                            nomCorps = dossier.eNom();
                        }

                        String Ligne = String.Format(" -- ×{5} {0} -> {1} : {2:0.0} kg / Base : {3}{4}",
                                                     nomCorps,
                                                     InfoCorps.Materiau,
                                                     InfoCorps.Masse,
                                                     InfoCorps.Base,
                                                     herite,
                                                     dossier.eNbCorps()
                                                     );

                        WindowLog.Ecrire(Ligne);
                    }

                    Ensemble.AjouterPiece(piece);

                    if (piece.Masse > 0.01)
                    {
                        List <String> TextePiece = new List <String>();
                        foreach (String classe in piece.ListeClasse.Keys)
                        {
                            Double Masse = 0;

                            foreach (Info i in piece.ListeClasse[classe].Values)
                            {
                                Masse += i.Masse;
                                TextePiece.Add(String.Format("  -- {0} : {1:0.0} kg", i.Materiau, i.Masse));
                            }
                            TextePiece.Insert(0, String.Format("  {0} : {1:0.0} kg", classe, Masse));
                        }
                        TextePiece.Insert(0, String.Format("Poids de la piece : {0:0.0} kg", piece.Masse));
                        WindowLog.Ecrire(TextePiece);
                    }

                    WindowLog.SautDeLigne();
                }

                WindowLog.SautDeLigne();

                WindowLog.Ecrire("Resultat :");
                WindowLog.Ecrire("----------------");

                List <String> TexteEnsemble = new List <String>();
                foreach (String classe in Ensemble.ListeClasse.Keys)
                {
                    Double Masse = 0;

                    List <String> Texte = new List <String>();
                    foreach (Info i in Ensemble.ListeClasse[classe].Values)
                    {
                        Masse += i.Masse;
                        Texte.Add(String.Format("  -- {0} : {1:0.0} kg", i.Materiau, i.Masse));
                    }

                    if (Masse > 0.01)
                    {
                        TexteEnsemble.Add(String.Format("  {0} : {1:0.0} kg", classe, Masse));
                        TexteEnsemble.AddRange(Texte);
                    }
                }
                TexteEnsemble.Insert(0, String.Format("Poids de l'ensemble : {0:0.0} kg", Ensemble.Masse));
                WindowLog.Ecrire(TexteEnsemble);
                WindowLog.SautDeLigne();
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }
Beispiel #14
0
        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 });
            }
        }
Beispiel #15
0
        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 });
            }
        }
Beispiel #16
0
            /// <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 });
                }
            }
Beispiel #17
0
        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 }); }
        }
Beispiel #18
0
        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 });
            }
        }
Beispiel #19
0
        /// <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 }); }
        }
Beispiel #20
0
        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 void Start()
        {
            try
            {
                NettoyerFichier();
                List <String> ListeFichiersZip = new List <string>();

                foreach (var corps in ListeCorps.Values)
                {
                    var chemin = CreerBarre(corps);
                    if (File.Exists(chemin))
                    {
                        ListeFichiersZip.Add(chemin);
                    }
                }

                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);
                    }
                }

                ListeCorps.EcrireProduction(DossierBarre, IndiceCampagne);

                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");
                }

                WindowLog.SautDeLigne();
                WindowLog.Ecrire(Nomenclature.ListeLignes());

                String       FichierNomenclature_Laser = Path.Combine(DossierBarre, "Nomenclature_Laser.txt");
                StreamWriter s = new StreamWriter(FichierNomenclature_Laser);
                s.Write(Nomenclature.GenererTableau());
                s.Close();

                ListeFichiersZip.Add(FichierNomenclature_Laser);

                // Création du dossier ZIP
                if (ListeFichiersZip.Count > 1)
                {
                    WindowLog.SautDeLigne();
                    WindowLog.Ecrire(NomFichierZip);
                    WindowLog.Ecrire("  -> " + CheminFichierZip);

                    using (ZipArchive archive = ZipFile.Open(CheminFichierZip, ZipArchiveMode.Create))
                    {
                        foreach (var f in ListeFichiersZip)
                        {
                            archive.CreateEntryFromFile(f, Path.GetFileName(f), CompressionLevel.Optimal);
                        }

                        if (CreerPdf3D)
                        {
                            archive.CreateEntryFromFile(DossierBarrePDF, NomDossierPDF, CompressionLevel.Optimal);
                        }
                    }

                    foreach (var f in ListeFichiersZip)
                    {
                        File.Delete(f);
                    }

                    if (CreerPdf3D && Directory.Exists(DossierBarrePDF))
                    {
                        foreach (var f in Directory.GetFiles(DossierBarrePDF))
                        {
                            File.Delete(f);
                        }

                        Directory.Delete(DossierBarrePDF);
                    }
                }
            }
            catch (Exception e)
            {
                this.LogErreur(new Object[] { e });
            }
        }