protected void Rechercher_Infos()
{
WindowLog.Ecrire("Recherche des materiaux et epaisseurs ");
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);
}
public PageInsererNote()
{
try
{
LigneAttache = _Config.AjouterParam("LigneAttache", true, "Ligne d'attache");
ModifierHtTexte = _Config.AjouterParam("ModifierHtTexte", true, "Modifier la ht du texte");
HtTexte = _Config.AjouterParam("HtTexte", 7, "Ht du texte en mm", "Ht du texte en mm");
Reperage = _Config.AjouterParam("Reperage", true, "Reperage");
AfficherQuantite = _Config.AjouterParam("AfficherQuantite", true, "Ajouter la quantité");
Description = _Config.AjouterParam("Description", true, "Description");
PrefixeTole = _Config.AjouterParam("PrefixeTole", true, "Prefixe tole");
AjouterMateriau = _Config.AjouterParam("AjouterMateriau", true, "Ajouter le matériau");
ProfilCourt = _Config.AjouterParam("ProfilCourt", true, "Nom de profil court");
SautDeLigneMateriau = _Config.AjouterParam("SautDeLigneMateriau", false, "Saut de ligne matériau");
Dessin = MdlBase.eDrawingDoc();
Mt = (MathUtility)App.Sw.GetMathUtility();
ListeCorps = MdlBase.pChargerNomenclature();
InitSouris();
OnCalque += Calque;
OnRunAfterClose += RunAfterClose;
}
catch (Exception e)
{ this.LogMethode(new Object[] { e }); }
}
public AffichageElementWPF(ListeSortedCorps listeCorps)
{
Init(listeCorps);
ListeViewTole.View = ListeViewTole.FindResource("VueDvp") as ViewBase;
Cb_SelectCampagne.Visibility = Visibility.Collapsed;
Vue.Filter = FiltreQteNull;
}
public AffichageElementWPF(ListeSortedCorps listeCorps, int indiceCampagne)
{
Init(listeCorps);
ListeViewTole.View = ListeViewTole.FindResource("VueRepere") as ViewBase;
Campagne = indiceCampagne.ToString();
Bt_Annuler.Visibility = Visibility.Collapsed;
Ck_Filtrer.Visibility = Visibility.Collapsed;
Ck_Select.Visibility = Visibility.Collapsed;
RemplirListBox();
Vue.Filter = FiltreCampagne;
}
private void Init(ListeSortedCorps listeCorps)
{
InitializeComponent();
ListeCorps = listeCorps;
ListeViewTole.ItemsSource = listeCorps.Values;
Vue = (CollectionView)CollectionViewSource.GetDefaultView(ListeViewTole.ItemsSource);
PropertyGroupDescription grpDescDimension = new PropertyGroupDescription("Dimension");
PropertyGroupDescription grpDescMateriau = new PropertyGroupDescription("Materiau");
Vue.GroupDescriptions.Add(grpDescMateriau);
Vue.GroupDescriptions.Add(grpDescDimension);
EstInit = true;
}
public PageRepereCorps()
{
try
{
Mt = (MathUtility)App.Sw.GetMathUtility();
ListeCorps = MdlBase.pChargerNomenclature();
InitSouris();
WindowLog.EcrireF("Nb Corps : {0}", MdlBase.eComposantRacine().eListeCorps().Count);
OnCalque += Calque;
OnRunAfterActivation += ChargerCorps;
OnRunAfterClose += RunAfterClose;
}
catch (Exception e)
{ this.LogMethode(new Object[] { e }); }
}
protected 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 }); }
}
protected void RechercherIndiceCampagne()
{
try
{
WindowLog.Ecrire("Recherche des éléments existants :");
// Recherche du dernier indice de la campagne de repérage
// Création du dossier pièces s'il n'existe pas
MdlBase.pCreerDossier(CONST_PRODUCTION.DOSSIER_PIECES);
// Recherche de la nomenclature
MdlBase.pCreerFichierTexte(CONST_PRODUCTION.DOSSIER_PIECES, CONST_PRODUCTION.FICHIER_NOMENC);
// Recherche des exports laser, tole ou tube, existant
var IndiceLaser = Math.Max(MdlBase.pRechercherIndiceDossier(CONST_PRODUCTION.DOSSIER_LASERTOLE),
MdlBase.pRechercherIndiceDossier(CONST_PRODUCTION.DOSSIER_LASERTUBE)
);
IndiceCampagne = IndiceLaser + 1;
// Aquisition de la liste des corps déjà repérées
ListeCorps = MdlBase.pChargerNomenclature();
_Texte_IndiceCampagneDepartDecompte.Text = ListeCorps.CampagneDepartDecompte.ToString();
WindowLog.EcrireF("{0} pièce(s) sont référencé(s)", ListeCorps.Count);
// S'il n'y a aucun corps, on désactive les options
if (ListeCorps.Count == 0)
{
_CheckBox_MajCampagnePrecedente.IsEnabled = false;
_CheckBox_MajCampagnePrecedente.Visible = false;
_CheckBox_ReinitCampagneActuelle.IsEnabled = false;
_CheckBox_ReinitCampagneActuelle.Visible = false;
}
// Si aucun corps n'a déjà été comptabilisé pour cette campagne,
// on ne propose pas la réinitialisation
foreach (var corps in ListeCorps.Values)
{
if (corps.Campagne.Keys.Max() >= IndiceCampagne)
{
ReinitCampagneActuelle = true;
break;
}
}
if (!ReinitCampagneActuelle)
{
_CheckBox_ReinitCampagneActuelle.IsEnabled = false;
_CheckBox_ReinitCampagneActuelle.Visible = false;
}
// Si c'est la première campagne, on désactive des options
if (IndiceCampagne == 1)
{
_CheckBox_CampagneDepartDecompte.IsEnabled = false;
_CheckBox_CampagneDepartDecompte.Visible = false;
_Texte_IndiceCampagneDepartDecompte.IsEnabled = false;
_Texte_IndiceCampagneDepartDecompte.Visible = false;
_CheckBox_MajCampagnePrecedente.IsEnabled = false;
_CheckBox_MajCampagnePrecedente.Visible = false;
_CheckBox_CombinerAvecCampagnePrecedente.IsEnabled = false;
_CheckBox_CombinerAvecCampagnePrecedente.Visible = false;
}
}
catch (Exception e) { this.LogErreur(new Object[] { e }); }
}
/// <summary>
/// Pour pouvoir obtenir une référence unique pour chaque dossier de corps, identiques
/// dans l'assemblage, on passe par la création d'une propriété dans chaque dossier.
/// Cette propriété est liée à une cote dans une esquisse dont la valeur est égale au repère.
/// Suivant la configuration, la valeur de la cote peut changer et donc le repère du dossier.
/// C'est le seul moyen pour avoir un lien entre les dossiers et la configuration du modèle.
/// Les propriétés des dossiers ne sont pas configurables.
/// </summary>
protected override void Command()
{
try
{
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 }); }
}