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