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