/// <summary>
/// Retourne l'objet sélectionné.
/// </summary>
/// <param name="Index"></param>
/// <param name="Marque"></param>
/// <returns></returns>
public dynamic Objet(int Index, int Marque = -1, Boolean RenvoyerObjet = false)
{
Log.Methode(cNOMCLASSE);
if (NbObjetsSelectionnes() == 0)
return null;
eModele pModele = _Modele;
if (_Modele.TypeDuModele != TypeFichier_e.cDessin)
pModele = Composant(Index, Marque).Modele;
dynamic pSwObjet = _SwGestDeSelection.GetSelectedObject6(Index, Marque);
swSelectType_e pType = TypeObjet(Index, Marque);
if ((pModele != null) && pModele.EstInitialise && !RenvoyerObjet)
{
switch (pType)
{
case swSelectType_e.swSelCOMPONENTS:
Component2 pSwComposant = pSwObjet;
eComposant pComposant = new eComposant();
if (pComposant.Init(pSwComposant, pModele))
{
Modele.Composant = pComposant;
return pComposant;
}
break;
case swSelectType_e.swSelCONFIGURATIONS:
Configuration pSwConfiguration = pSwObjet;
eConfiguration pConfiguration = new eConfiguration();
if (pConfiguration.Init(pSwConfiguration, pModele))
return pConfiguration;
break;
case swSelectType_e.swSelDRAWINGVIEWS:
View pSwVue = pSwObjet;
eVue pVue = new eVue();
if (pVue.Init(pSwVue, pModele))
return pVue;
break;
case swSelectType_e.swSelSHEETS:
Sheet pSwFeuille = pSwObjet;
eFeuille pFeuille = new eFeuille();
if (pFeuille.Init(pSwFeuille, pModele))
return pFeuille;
break;
case swSelectType_e.swSelSOLIDBODIES:
Body2 pSwCorps = pSwObjet;
eCorps pCorps = new eCorps();
if (pCorps.Init(pSwCorps, pModele))
return pCorps;
break;
case swSelectType_e.swSelDATUMPLANES:
case swSelectType_e.swSelDATUMAXES:
case swSelectType_e.swSelDATUMPOINTS:
case swSelectType_e.swSelATTRIBUTES:
case swSelectType_e.swSelSKETCHES:
case swSelectType_e.swSelSECTIONLINES:
case swSelectType_e.swSelDETAILCIRCLES:
case swSelectType_e.swSelMATES:
case swSelectType_e.swSelBODYFEATURES:
case swSelectType_e.swSelREFCURVES:
case swSelectType_e.swSelREFERENCECURVES:
case swSelectType_e.swSelREFSILHOUETTE:
case swSelectType_e.swSelCAMERAS:
case swSelectType_e.swSelSWIFTANNOTATIONS:
case swSelectType_e.swSelSWIFTFEATURES:
case swSelectType_e.swSelCTHREADS:
eFonction pFonction = new eFonction();
if (pFonction.Init(pSwObjet, pModele))
return pFonction;
break;
default:
eObjet pObjet = new eObjet();
eModele pInitModele;
if ((pModele != null) && pModele.EstInitialise)
pInitModele = pModele;
else
pInitModele = _Modele;
if (pObjet.Init(pInitModele, pSwObjet, pType))
return pObjet;
break;
}
}
else if (RenvoyerObjet)
{
eObjet pObjet = new eObjet();
eModele pInitModele = _Modele;
if ((pModele != null) && pModele.EstInitialise)
pInitModele = pModele;
pObjet.Init(pInitModele, pSwObjet, pType);
if (pObjet.EstInitialise)
return pObjet;
}
return null;
}
/// <summary>
/// Méthode privée.
/// Méthode récursive permettant de traverser tous les composants d'une pièce ou d'un assemblage
/// </summary>
/// <param name="ComposantRacine"></param>
/// <param name="TypeComposant"></param>
/// <param name="DicComposants"></param>
/// <param name="NomComposant"></param>
private void RecListerComposants(eComposant ComposantRacine, TypeFichier_e TypeComposant, Dictionary<String, eComposant> DicComposants, String NomComposant = "")
{
Log.Methode(cNOMCLASSE);
foreach (eComposant pComp in ComposantRacine.ComposantsEnfants("", _PrendreEnCompteSupprime))
{
// Operateur "Implique" sur la propriété EstExclu
if (!pComp.EstExclu | _PrendreEnCompteExclus)
{
// Attention, Regex.IsMatch peut renvoyer une erreur si NomComposant est égal à un caractère spécial
// du style "*" ou "[" et autre. Pb à corriger.
if (TypeComposant.HasFlag(pComp.Modele.TypeDuModele) && Regex.IsMatch(pComp.Modele.FichierSw.Chemin, NomComposant))
{
eComposant pComposant = new eComposant();
String pCle = NomCle(pComp);
Log.Message("Clé : " + pCle);
// S'il est déjà dans le dico, on on rajoute 1
if (DicComposants.ContainsKey(pCle))
{
pComposant = DicComposants[pCle];
pComposant.Nb += 1;
}
// sinon on le rajoute
else
{
// Si on supprime les doublons et que l'on ne prend pas e compte les configs, on associe au modèle le composant racine
// et non le composant de l'assemblage
if (_SupprimerDoublons && !_PrendreEnCompteConfig)
{
eModele pModele = pComp.Modele;
pModele.ReinitialiserComposant();
pComposant = pModele.Composant;
}
else
{
pComposant = pComp;
}
pComposant.Nb = 1;
DicComposants.Add(pCle, pComposant);
}
}
// Si c'est un assemblage et qu'il n'est pas supprimé, on scan
if ((pComp.Modele.TypeDuModele == TypeFichier_e.cAssemblage) && (pComp.EstSupprime == false))
{
RecListerComposants(pComp, TypeComposant, DicComposants, NomComposant);
}
}
}
}
/// <summary>
/// Retourne le composant associé à l'objet sélectionné.
/// </summary>
/// <param name="Index"></param>
/// <param name="Marque"></param>
/// <returns></returns>
public eComposant Composant(int Index, int Marque = -1)
{
Log.Methode(cNOMCLASSE);
if (NbObjetsSelectionnes() == 0)
return null;
Component2 pSwComposant = _SwGestDeSelection.GetSelectedObjectsComponent4(Index, Marque);
Log.Message("OKKKKKK");
// Si le composant racine est sélectionné et que l'on est dans un assemblage, rien n'est renvoyé.
// Donc on le récupère.
if ((pSwComposant == null) && (Modele.TypeDuModele == TypeFichier_e.cAssemblage))
{
Log.Message("OKKKKKK222222222222222");
pSwComposant = _SwGestDeSelection.GetSelectedObject6(Index, Marque);
Log.Message("OKKKKKK3333333333333333");
}
else if ((pSwComposant == null) && (Modele.TypeDuModele == TypeFichier_e.cPiece))
pSwComposant = Modele.Composant.SwComposant;
// Si c'est un dessin, pas de composant
else if ((pSwComposant == null) && (Modele.TypeDuModele == TypeFichier_e.cDessin))
return null;
if (pSwComposant == null)
Log.Message(" ========================= Erreur de composant");
// Pour intitialiser le composant correctement il faut un peu de bidouille
// sinon on à le droit à une belle reference circulaire
// Donc d'abord, on recherche le modele du SwComposant
Log.Message(pSwComposant.GetPathName());
eModele pModele = _Modele.SW.Modele(pSwComposant.GetPathName());
// Ensuite, on créer un nouveau Composant avec la ref du SwComposant et du modele
eComposant pComposant = new eComposant();
// Et pour que les deux soit liés, on passe la ref du Composant que l'on vient de creer
// au modele. Comme ca, Modele.Composant pointe sur Composant et Composant.Modele pointe sur Modele,
// la boucle est bouclée
pComposant.Init(pSwComposant, pModele);
pModele.Composant = pComposant;
if (pComposant.EstInitialise)
return pComposant;
return null;
}
/// <summary>
/// Méthode privée.
/// Retourne la clé de tri suivant les filtres activé.
/// </summary>
/// <param name="Composant"></param>
/// <returns></returns>
private String NomCle(eComposant Composant)
{
Log.Methode(cNOMCLASSE);
String pNomCle = "";
if ((Composant != null) && Composant.EstInitialise)
{
pNomCle = Composant.Modele.FichierSw.Chemin;
// Si on prend en compte les configs, on rajoute le nom de la config dans la clé
if (_PrendreEnCompteConfig)
pNomCle += "_" + Composant.Configuration.Nom;
// Si on garde toutes les occurences, on rajoute un index pour eviter les doublons de clés
if (!_SupprimerDoublons)
pNomCle += "_" + _IndexComposant++;
}
return pNomCle;
}
/// <summary>
/// Méthode interne.
/// Initialiser l'objet ExtRecherche.
/// </summary>
/// <param name="Composant"></param>
/// <returns></returns>
internal Boolean Init(eComposant Composant)
{
Log.Methode(cNOMCLASSE);
if ((Composant != null) && Composant.EstInitialise)
{
_Composant = Composant;
_EstInitialise = true;
}
else
{
Log.Message("!!!!! Erreur d'initialisation");
}
return _EstInitialise;
}
/// <summary>
/// Méthode interne
/// Renvoi la liste des composants filtrées par les arguments
/// </summary>
/// <param name="TypeComposant"></param>
/// <param name="NomComposant"></param>
/// <returns></returns>
public ArrayList ListeComposants(TypeFichier_e TypeComposant, String NomComposant = "")
{
Log.Methode(cNOMCLASSE);
Dictionary<String, eComposant> pDicComposants = new Dictionary<string, eComposant>();
// On met l'index à 0
_IndexComposant = 0;
// On renvoi le composant de base
if ((_RenvoyerComposantRacine == true) && TypeComposant.HasFlag(_Composant.Modele.TypeDuModele))
{
// On renvoi un composant par config
if (_PrendreEnCompteConfig && _RenvoyerConfigComposantRacine)
{
foreach (eConfiguration pConfig in _Composant.Modele.GestDeConfigurations.ListerLesConfigs(TypeConfig_e.cDeBase))
{
Component2 pSwComp = pConfig.SwConfiguration.GetRootComponent3(false);
eModele pModele = _Composant.Modele.SW.Modele(pSwComp.GetPathName());
eComposant pComp = new eComposant();
pComp.Init(pSwComp, pModele);
pModele.Composant = pComp;
pComp.Configuration = pConfig;
pDicComposants.Add(NomCle(pComp), pComp);
}
}
else
pDicComposants.Add(NomCle(_Composant), _Composant);
}
// Si le composant est un assemblage contenant plusieurs composants, on renvoi la liste des composants recherchés
if ((_Composant.Modele.TypeDuModele == TypeFichier_e.cAssemblage) && (_Composant.SwComposant.IGetChildrenCount() > 0))
RecListerComposants(_Composant, TypeComposant, pDicComposants, NomComposant);
// Nouvelle liste à renvoyer
ArrayList pListeComposants = new ArrayList();
// Si le dictionnaire n'est pas vide, on rempli la liste avec les valeurs du dictionnaire
if (pDicComposants.Count > 0)
pListeComposants = new ArrayList(pDicComposants.Values);
// On trie et c'est parti
//pListeComposants.Sort();
return pListeComposants;
}
/// <summary>
/// Renvoi le modele en cours d'edition
/// </summary>
/// <returns></returns>
public eModele ModeleEnCoursEdition()
{
Log.Methode(cNOMCLASSE);
eModele pModeleActif = this.Modele();
eModele pModeleEdite = new eModele();
if (pModeleActif.EstInitialise && (pModeleActif.TypeDuModele == TypeFichier_e.cAssemblage))
{
if (pModeleEdite.Init(pModeleActif.Assemblage.SwAssemblage.GetEditTarget(), this))
{
eComposant pComposant = new eComposant();
if (pComposant.Init(pModeleActif.Assemblage.SwAssemblage.GetEditTargetComponent(), pModeleEdite))
{
pModeleEdite.Composant = pComposant;
return pModeleEdite;
}
}
}
return pModeleActif;
}
/// <summary>
/// Editer le composant dans le contexte de l'assemblage
/// </summary>
public void EditerLeComposant(eComposant Composant)
{
Modele.EffacerLesSelections();
Composant.SwComposant.Select4(false, null, false);
int info = 0;
_SwAssemblage.EditPart2(true, false, ref info);
Modele.EffacerLesSelections();
}
