/// <summary>
        /// Méthode interne.
        /// Initialiser l'objet ExtDimensionVue.
        /// </summary>
        /// <param name="Vue"></param>
        /// <returns></returns>
        internal Boolean Init(eVue Vue)
        {
            Log.Methode(cNOMCLASSE);

            if ((Vue != null) && Vue.EstInitialise)
            {
                _Vue = Vue;

                _EstInitialise = true;
            }
            else
            {
                Log.Message("!!!!! Erreur d'initialisation");
            }
            return _EstInitialise;
        }
        /// <summary>
        /// Méthode interne.
        /// Renvoi la liste des vues de la feuille filtrée par les arguments.
        /// Si NomARechercher est vide, toutes les vues sont retournées.
        /// </summary>
        /// <param name="NomARechercher"></param>
        /// <returns></returns>
        public ArrayList ListeDesVues(String NomARechercher = "")
        {
            Log.Methode(cNOMCLASSE);

            ArrayList pListeVues = new ArrayList();

            Object[] pTabVues = _SwFeuille.GetViews();

            if (pTabVues == null)
                return pListeVues;

            foreach (View pSwVue in pTabVues)
            {
                eVue pVue = new eVue();
                if (pVue.Init(pSwVue, this) && Regex.IsMatch(pSwVue.GetName2(), NomARechercher))
                    pListeVues.Add(pVue);
            }

            return pListeVues;
        }
        /// <summary>
        /// Retourne la vue associé à l'objet sélectionné.
        /// </summary>
        /// <param name="Index"></param>
        /// <param name="Marque"></param>
        /// <returns></returns>
        public eVue Vue(int Index, int Marque = -1)
        {
            Log.Methode(cNOMCLASSE);

            if (NbObjetsSelectionnes() == 0)
                return null;

            eVue pVue = new eVue();

            if (pVue.Init(_SwGestDeSelection.GetSelectedObjectsDrawingView2(Index, Marque), _Modele))
                return pVue;

            return null;
        }
        /// <summary>
        /// Creer la vue développée d'une tôle
        /// </summary>
        /// <param name="Piece"></param>
        /// <param name="Configuration"></param>
        /// <returns></returns>
        public eVue CreerVueToleDvp(eTole Tole, Boolean AfficherLesLignesDePliage)
        {
            ePiece pPiece = Tole.Corps.Piece;
            eConfiguration pConfiguration = Tole.ConfigurationDepliee;

            pPiece.Modele.GestDeConfigurations.LierLesAffichagesAuxConfigurations = true;
            eVue pVue = new eVue();
            View pSwVue = null;
            pConfiguration.Activer();

            // Si des corps autre que la tole dépliée sont encore visible dans la config, on les cache et on recontruit tout
            ArrayList pListeCorps = pPiece.ListeDesCorps();
            foreach (eCorps pCorps in pListeCorps)
            {
                if (pCorps.Nom == CONSTANTES.NOM_CORPS_DEPLIEE)
                    pCorps.Visible = true;
                else
                    pCorps.Visible = false;
            }

            if (pListeCorps.Count > 0)
                pPiece.Modele.ForcerAToutReconstruire();

            _Dessin.Modele.Activer();
            pSwVue = _Dessin.SwDessin.CreateFlatPatternViewFromModelView3(pPiece.Modele.FichierSw.Chemin, pConfiguration.Nom, 0, 0, 0, !AfficherLesLignesDePliage, false);

            if (pVue.Init(pSwVue, this))
            {
                Log.Message("Vue dvp crée");

                pVue.AfficherLignesDePliage = AfficherLesLignesDePliage;

                return pVue;
            }

            Log.Message("Vue dvp non crée");
            return null;
        }
        /// <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;
        }