public override void Execute()
        {
            try
            {
                Sm = DsApp.GetActiveDocument().GetModel().GetSketchManager();

                DsApp.AbortRunningCommand();

                CommandMessage CmdLine = DsApp.GetCommandMessage();
                if (null == CmdLine)
                {
                    return;
                }

                //Entree utilisateur
                double toleranceEcart = 0.1, toleranceAngle = 5, toleranceEcartMax = 0.1;
                bool   methodeCalcul = true, toutesLesSplines = true, supprimerOriginal = true;

                // Erreur avec le premier prompt, la commande est automatiquement annulée
                // Pour contourner le pb, on lance une commande à vide.
                {
                    String sss = "";
                    CmdLine.PromptForString(true, "", "", out sss);
                }

                string[] KeyWord = new string[] { "Oui", "Non", "Distance", "Max", "Angle", "Calcul", "SupprimerOriginal" };

                Action <string> ModifierOptions = delegate(string s)
                {
                    if (s == "Distance")
                    {
                        CmdLine.PromptForDouble("Deviation de distance par rapport à la spline ", toleranceEcart, out toleranceEcart);
                    }
                    else if (s == "Max")
                    {
                        CmdLine.PromptForDouble("Deviation de distance maximum absolue ", toleranceEcartMax, out toleranceEcartMax);
                    }
                    else if (s == "Angle")
                    {
                        CmdLine.PromptForDouble("Deviation d'angle par rapport à la spline ", toleranceAngle, out toleranceAngle);
                    }
                    else if (s == "Calcul")
                    {
                        CmdLine.PromptForBool("Deviation en pourcent de la longueur ", "Oui", "Non", methodeCalcul, out methodeCalcul);
                    }
                    else if (s == "SupprimerOriginal")
                    {
                        CmdLine.PromptForBool("Supprimer l'original ", "Oui", "Non", supprimerOriginal, out supprimerOriginal);
                    }
                };

                string Option;
                dsPromptResultType_e result;
                CmdLine.PromptExplanation = "Oui";
                do
                {
                    result = CmdLine.PromptForBoolOrKeyword("Convertir toutes les splines", "Erreur", KeyWord, KeyWord, (int)dsPromptInit_e.dsPromptInit_UsePromptExplanation, "Oui", "Non", true, out Option, out toutesLesSplines);

                    switch (result)
                    {
                    case dsPromptResultType_e.dsPromptResultType_Keyword:
                        ModifierOptions(Option);
                        break;

                    case dsPromptResultType_e.dsPromptResultType_Cancel:
                        return;

                    default:
                        break;
                    }
                } while (result != dsPromptResultType_e.dsPromptResultType_Value);

                if (result == dsPromptResultType_e.dsPromptResultType_Cancel)
                {
                    return;
                }

                Document         DsDoc = DsApp.GetActiveDocument();
                Model            Mdl   = DsDoc.GetModel();
                SketchManager    SkMgr = Mdl.GetSketchManager();
                SelectionManager SlMgr = DsDoc.GetSelectionManager();
                SelectionFilter  SlFilter;
                SlFilter = SlMgr.GetSelectionFilter();

                object[] TabEntites = null;

                CmdLine.PrintLine($"Angle : {toleranceAngle}° Dist : {toleranceEcart}mm Max : {toleranceEcartMax}mm");
                CmdLine.PrintLine($" Toutes les splines : {(toutesLesSplines ? "Oui" : "Non")} Supprimer l'original : {(supprimerOriginal?"Oui":"Non")} Calcul % : {(methodeCalcul ? "Oui" : "Non")}");

                if (toutesLesSplines)
                {
                    SlFilter.Clear();
                    SlFilter.AddEntityType(dsObjectType_e.dsSplineType);
                    SlFilter.Active = true;

                    object   ObjType        = null;
                    object   ObjEntites     = null;
                    string[] TabNomsCalques = GetTabNomsCalques(DsDoc);
                    SkMgr.GetEntities(SlFilter, TabNomsCalques, out ObjType, out ObjEntites);
                    TabEntites = ObjEntites as object[];
                }
                else
                {
                    SlFilter.Clear();
                    SlFilter.AddEntityType(dsObjectType_e.dsSplineType);
                    SlFilter.Active = true;

                    if (CmdLine.PromptForSelection(false, "Selectionnez la spline", "Ce n'est pas une spline"))
                    {
                        dsObjectType_e entityType;
                        var            count = SlMgr.GetSelectedObjectCount(dsSelectionSetType_e.dsSelectionSetType_Previous);
                        TabEntites = new object[count];

                        for (int i = 0; i < count; i++)
                        {
                            object selectedEntity = SlMgr.GetSelectedObject(dsSelectionSetType_e.dsSelectionSetType_Previous, i, out entityType);

                            if (dsObjectType_e.dsSplineType == entityType)
                            {
                                TabEntites[i] = selectedEntity;
                            }
                        }
                    }
                }

                var DateTimeStart = DateTime.Now;

                long NbArc = 0;

                Action <object> Convertir = delegate(object o)
                {
                    Spline Spline = o as Spline;
                    if (Spline == null)
                    {
                        return;
                    }

                    SplineConverter SplConverter = new SplineConverter(
                        Spline,
                        toleranceEcart,
                        toleranceAngle,
                        toleranceEcartMax,
                        methodeCalcul ? SplineConverter.eCalculTolerance.Absolu : SplineConverter.eCalculTolerance.Pourcent
                        );
                    iLine?L = SplConverter.EnLigne();
                    if (L != null)
                    {
                        var l = (iLine)L;
                        SkMgr.InsertLine(l.P1.X, l.P1.Y, l.P1.Z, l.P2.X, l.P2.Y, l.P2.Z);
                    }
                    else
                    {
                        var List = SplConverter.EnPolyligne();
                        foreach (var arc in List)
                        {
                            SkMgr.InsertArcBy3Points(arc.P1.MathPoint(), arc.P2.MathPoint(), arc.P3.MathPoint());
                        }

                        NbArc += List.Count;
                    }
                };

                if (TabEntites != null && TabEntites.Length > 0)
                {
                    CmdLine.PrintLine($"{TabEntites.Length} spline(s) selectionnées");

                    if (TabEntites.Length == 1)
                    {
                        Convertir(TabEntites[0]);
                    }
                    else
                    {
                        Parallel.ForEach(TabEntites, Convertir);
                    }

                    CmdLine.PrintLine($"{TabEntites.Length} spline(s) converties en {NbArc} arc(s)");

                    if (supprimerOriginal)
                    {
                        for (int i = 0; i < TabEntites.Length; i++)
                        {
                            Spline s = (Spline)TabEntites[i];
                            s.Erased = true;
                        }
                    }
                }

                TimeSpan t = DateTime.Now - DateTimeStart;
                CmdLine.PrintLine(String.Format("Executé en {0}", GetSimplestTimeSpan(t)));
            }
            catch (Exception e)
            { Log.Write(e); }
        }