示例#1
0
        private Dimension CreerParam(ModelDoc2 mdl, Feature fDossier, String nomCfg, int indexDimension)
        {
            Dimension param = null;

            try
            {
                // On recherche si le dossier contient déjà la propriété RefDossier
                //      Si non, 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 à configurer

                CustomPropertyManager PM = fDossier.CustomPropertyManager;
                String val;

                String nomParam = String.Format("D{0}@{1}", indexDimension, CONSTANTES.NOM_ESQUISSE_NUMEROTER);
                val = String.Format("{0}\"{1}@{2}\"", CONSTANTES.PREFIXE_REF_DOSSIER, nomParam, mdl.eNomAvecExt());
                var r = PM.ePropAdd(CONSTANTES.REF_DOSSIER, val);

                PM.ePropAdd(CONSTANTES.DESC_DOSSIER, val);
                val = String.Format("\"SW-CutListItemName@@@{0}@{1}\"", fDossier.Name, mdl.eNomAvecExt());
                PM.ePropAdd(CONSTANTES.NOM_DOSSIER, val);

                param = mdl.Parameter(nomParam);
                param.SetSystemValue3(0.5 * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, nomCfg);
            }
            catch (Exception e) { this.LogErreur(new Object[] { e }); }

            return(param);
        }
示例#2
0
        private Dimension GetParam(ModelDoc2 mdl, Feature fDossier, String nomCfg)
        {
            Dimension param = null;

            try
            {
                Func <String, String> ExtractNomParam = delegate(String s)
                {
                    s = s.Replace(CONSTANTES.PREFIXE_REF_DOSSIER + "\"", "").Replace("\"", "");
                    var t = s.Split('@');
                    if (t.Length > 2)
                    {
                        return(String.Format("{0}@{1}", t[0], t[1]));
                    }

                    this.LogErreur(new Object[] { "Pas de parametre dans la reference dossier" });
                    return("");
                };

                // On recherche si le dossier contient déjà la propriété RefDossier
                //      Si non, 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 à configurer

                CustomPropertyManager PM = fDossier.CustomPropertyManager;
                String val;

                String result = ""; Boolean wasResolved, link;
                var    r        = PM.Get6(CONSTANTES.REF_DOSSIER, false, out val, out result, out wasResolved, out link);
                String nomParam = ExtractNomParam(val);

                PM.ePropAdd(CONSTANTES.DESC_DOSSIER, val);
                val = String.Format("\"SW-CutListItemName@@@{0}@{1}\"", fDossier.Name, mdl.eNomAvecExt());
                PM.ePropAdd(CONSTANTES.NOM_DOSSIER, val);

                param = mdl.Parameter(nomParam);
                param.SetSystemValue3(0.5 * 0.001, (int)swSetValueInConfiguration_e.swSetValue_InSpecificConfigurations, nomCfg);
            }
            catch (Exception e) { this.LogErreur(new Object[] { e }); }

            return(param);
        }
        private void Nettoyer()
        {
            WindowLog.Ecrire("Nettoyer les modeles :");
            List <ModelDoc2> ListeMdl = new List <ModelDoc2>(MdlBase.pListerComposants().Keys);

            foreach (var mdl in ListeMdl)
            {
                if (mdl.TypeDoc() != eTypeDoc.Piece)
                {
                    continue;
                }

                mdl.eActiverManager(false);

                foreach (Configuration Cf in mdl.eListeConfigs(eTypeConfig.Depliee))
                {
                    Cf.eSupprimerConfigAvecEtatAff(mdl);
                }

                mdl.eActiver(swRebuildOnActivation_e.swRebuildActiveDoc);
                {
                    mdl.ePropSuppr(CONST_PRODUCTION.ID_PIECE);
                    mdl.ePropSuppr(CONST_PRODUCTION.PIECE_ID_DOSSIERS);
                    mdl.ePropSuppr(CONST_PRODUCTION.MAX_INDEXDIM);

                    // On supprime la definition du bloc
                    SupprimerDefBloc(mdl, CheminBlocEsquisseNumeroter());
                }

                foreach (var cfg in mdl.eListeNomConfiguration())
                {
                    mdl.ShowConfiguration2(cfg);
                    mdl.EditRebuild3();
                    var Piece = mdl.ePartDoc();

                    mdl.ePropSuppr(CONST_PRODUCTION.ID_CONFIG, cfg);
                    mdl.ePropSuppr(CONST_PRODUCTION.CONFIG_ID_DOSSIERS, cfg);

                    foreach (var f in Piece.eListeDesFonctionsDePiecesSoudees())
                    {
                        CustomPropertyManager PM = f.CustomPropertyManager;
                        PM.Delete2(CONSTANTES.REF_DOSSIER);
                        PM.Delete2(CONSTANTES.DESC_DOSSIER);
                        PM.Delete2(CONSTANTES.NOM_DOSSIER);

                        String ValParDefaut = mdl.Extension.GetUserPreferenceString((int)swUserPreferenceStringValue_e.swSheetMetalDescription, (int)swUserPreferenceOption_e.swDetailingNoOptionSpecified);
                        PM.ePropAdd(CONSTANTES.DESC_DOSSIER, ValParDefaut);
                    }
                }

                mdl.eActiverManager(true);

                mdl.eFermerSiDifferent(MdlBase);
            }

            int errors   = 0;
            int warnings = 0;

            MdlBase.Save3((int)swSaveAsOptions_e.swSaveAsOptions_Silent + (int)swSaveAsOptions_e.swSaveAsOptions_SaveReferenced, ref errors, ref warnings);

            WindowLog.Ecrire("- Nettoyage terminé");
        }
示例#4
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 });
                }
            }