Example #1
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_AfficherLignePliage = G.AjouterCheckBox(AfficherLignePliage);
                _CheckBox_AfficherNotePliage  = G.AjouterCheckBox(AfficherNotePliage);
                _CheckBox_AfficherNotePliage.StdIndent();

                _CheckBox_AfficherLignePliage.OnUnCheck += _CheckBox_AfficherNotePliage.UnCheck;
                _CheckBox_AfficherLignePliage.OnIsCheck += _CheckBox_AfficherNotePliage.IsEnable;

                // Pour eviter d'ecraser le parametre de "AfficherNotePliage", le met à jour seulement si
                if (!_CheckBox_AfficherLignePliage.IsChecked)
                {
                    _CheckBox_AfficherNotePliage.IsChecked = _CheckBox_AfficherLignePliage.IsChecked;
                    _CheckBox_AfficherNotePliage.IsEnabled = _CheckBox_AfficherLignePliage.IsChecked;
                }

                _CheckBox_InscrireNomTole              = G.AjouterCheckBox(InscrireNomTole);
                _Texte_TailleInscription               = G.AjouterTexteBox(TailleInscription, false);
                _Texte_TailleInscription.ValiderTexte += ValiderTextIsInteger;
                _Texte_TailleInscription.StdIndent();

                _CheckBox_InscrireNomTole.OnIsCheck += _Texte_TailleInscription.IsEnable;
                _Texte_TailleInscription.IsEnabled   = _CheckBox_InscrireNomTole.IsChecked;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #2
0
        protected void Calque()
        {
            try
            {
                Groupe G;
                G = _Calque.AjouterGroupe("Appliquer");

                _Button_Preselection = G.AjouterBouton("Preselectionner");
                _Button_Preselection.OnButtonPress += delegate(object sender) { PreSelection(); };

                G = _Calque.AjouterGroupe("Plan de symetrie");

                _Select_P_Symetrie = G.AjouterSelectionBox("Selectionnez le plan");
                _Select_P_Symetrie.SelectionMultipleMemeEntite = false;
                _Select_P_Symetrie.SelectionDansMultipleBox    = false;
                _Select_P_Symetrie.UneSeuleEntite = true;
                _Select_P_Symetrie.FiltreSelection(swSelectType_e.swSelDATUMPLANES);

                G             = _Calque.AjouterGroupe("Corps à symétriser");
                _Select_Corps = G.AjouterSelectionBox("Selectionnez les corps");
                _Select_Corps.SelectionMultipleMemeEntite = false;
                _Select_Corps.SelectionDansMultipleBox    = false;
                _Select_Corps.UneSeuleEntite = false;
                _Select_Corps.Hauteur        = 13;
                _Select_Corps.FiltreSelection(swSelectType_e.swSelSOLIDBODIES);

                G = _Calque.AjouterGroupe("Options");

                _Check_SupprimerSymetrie           = G.AjouterCheckBox("Supprimer l'original");
                _Check_SupprimerSymetrie.IsChecked = true;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #3
0
        protected void Calque()
        {
            try
            {
                Groupe G;
                G = _Calque.AjouterGroupe("Appliquer");

                _CheckBox_SupprimerLesAnciennesConfigs = G.AjouterCheckBox(SupprimerLesAnciennesConfigs);
                _CheckBox_ReconstuireLesConfigs        = G.AjouterCheckBox(ReconstuireLesConfigs);

                _CheckBox_SupprimerLesAnciennesConfigs.OnCheck   += _CheckBox_ReconstuireLesConfigs.UnCheck;
                _CheckBox_SupprimerLesAnciennesConfigs.OnIsCheck += _CheckBox_ReconstuireLesConfigs.IsDisable;

                // Pour eviter d'ecraser le parametre de "Reconstruire les configs", le met à jour seulement si
                if (_CheckBox_SupprimerLesAnciennesConfigs.IsChecked)
                {
                    _CheckBox_ReconstuireLesConfigs.IsChecked = !_CheckBox_SupprimerLesAnciennesConfigs.IsChecked;
                    _CheckBox_ReconstuireLesConfigs.IsEnabled = !_CheckBox_SupprimerLesAnciennesConfigs.IsChecked;
                }

                _CheckBox_ToutesLesConfigurations = G.AjouterCheckBox(ToutesLesConfigurations);

                G = _Calque.AjouterGroupe("Options");
                _CheckBox_MasquerEsquisses = G.AjouterCheckBox(MasquerEsquisses);

                _GroupeAvecCheckBox                     = _Calque.AjouterGroupeAvecCheckBox(SupprimerFonctions);
                _TextBox_NomFonctionSupprimer           = _GroupeAvecCheckBox.AjouterTexteBox(NomFonctionSupprimer);
                _TextBox_NomFonctionSupprimer.IsEnabled = _GroupeAvecCheckBox.IsChecked;

                _GroupeAvecCheckBox.OnIsCheck += _TextBox_NomFonctionSupprimer.IsEnable;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #4
0
        public static HtmlString CtrlParagraph(this HtmlHelper html, string id, string label, string columnDataName = "")
        {
            var ctrl = new CtrlCheckBox
            {
                Id             = id,
                Label          = label,
                ColumnDataName = columnDataName
            };

            return(new HtmlString(ctrl.GetHtml()));
        }
        protected void Calque()
        {
            try
            {
                Groupe G;
                G = _Calque.AjouterGroupe("Options");

                _CheckBox_SupprimerLesAnciennesConfigs = G.AjouterCheckBox(SupprimerLesAnciennesConfigs);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #6
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                _Groupe1 = _Calque.AjouterGroupe("Selectionner les composants de base");

                _Select_CompBase = _Groupe1.AjouterSelectionBox("", "Selectionnez les composants");
                _Select_CompBase.SelectionMultipleMemeEntite = false;
                _Select_CompBase.SelectionDansMultipleBox    = false;
                _Select_CompBase.UneSeuleEntite = false;
                _Select_CompBase.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_CompBase.OnSubmitSelection += SelectionnerPiece;
                _Select_CompBase.Hauteur            = 8;
                _Select_CompBase.Focus              = true;

                Isoler.ListSelectionBox.Add(_Select_CompBase);

                _FiltreCompBase = new FiltreComp(MdlBase, _Groupe1, _Select_CompBase, PrefixeBase);

                _Groupe2 = _Calque.AjouterGroupe("Selectionner les composants empreinte");

                _Select_CompEmpreinte = _Groupe2.AjouterSelectionBox("", "Selectionnez les composants");
                _Select_CompEmpreinte.SelectionMultipleMemeEntite = false;
                _Select_CompEmpreinte.SelectionDansMultipleBox    = false;
                _Select_CompEmpreinte.UneSeuleEntite = false;
                _Select_CompEmpreinte.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_CompEmpreinte.OnSubmitSelection += SelectionnerPiece;
                _Select_CompEmpreinte.Hauteur            = 8;

                Isoler.ListSelectionBox.Add(_Select_CompEmpreinte);

                _FiltreCompEmpreinte = new FiltreComp(MdlBase, _Groupe2, _Select_CompEmpreinte, PrefixeEmpreinte);

                _Groupe1.OnExpand   += _Groupe2.UnExpand;
                _Groupe1.OnUnExpand += _Groupe2.Expand;
                _Groupe2.OnExpand   += _Groupe1.UnExpand;
                _Groupe2.OnUnExpand += _Groupe1.Expand;
                _Groupe2.UnExpand();

                G = _Calque.AjouterGroupe("Options");

                _Button_IsolerComposants = G.AjouterBouton("Isoler les composants");
                _Button_IsolerComposants.OnButtonPress += delegate(Object sender) { Isoler.Run(MdlBase); };

                Isoler.Bouton = _Button_IsolerComposants;

                _CheckBox_MasquerLesEmpreintes = G.AjouterCheckBox("Masquer toutes les empreintes");
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #7
0
            protected void Calque()
            {
                try
                {
                    Groupe G;

                    G = _Calque.AjouterGroupe("Options");

                    _CheckBox_CombinerCorps = G.AjouterCheckBox(CombinerCorpsIdentiques);
                    _CheckBox_MajDossiers   = G.AjouterCheckBox("Ne pas supprimer les refs existantes");
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
Example #8
0
        void IPropertyManagerPage2Handler9.OnCheckboxCheck(int Id, bool Checked)
        {
            if (!CanRaiseEvent())
            {
                return;
            }

            CtrlCheckBox CheckBox = _Calque.DicControl[Id] as CtrlCheckBox;

            if (CheckBox.IsRef())
            {
                CheckBox.IsChecked = Checked;
            }
        }
Example #9
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_SelectionnerCorpsIdentiques = G.AjouterCheckBox("Selectionner les corps identiques");

                _CheckBox_SupprimerLesNotes           = G.AjouterCheckBox("Supprimer les notes à la fin");
                _CheckBox_SupprimerLesNotes.IsChecked = true;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #10
0
            protected void Calque()
            {
                try
                {
                    G = _Calque.AjouterGroupe("Options");

                    _CheckBox_ExporterEnCouleur             = G.AjouterCheckBox(ExporterEnCouleur);
                    _CheckBox_IncorporerLesPolices          = G.AjouterCheckBox(IncorporerLesPolices);
                    _CheckBox_ExporterEnHauteQualite        = G.AjouterCheckBox(ExporterEnHauteQualite);
                    _CheckBox_ImprimerEnTeteEtPiedDePage    = G.AjouterCheckBox(ImprimerEnTeteEtPiedDePage);
                    _CheckBox_EpaisseursDeLigneDeImprimante = G.AjouterCheckBox(EpaisseursDeLigneDeImprimante);

                    AjouterCalqueDossier();
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
Example #11
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Options");

                _Texte_ValAmbiante = G.AjouterTexteBox(ValAmbiante);
                _Texte_ValAmbiante.ValiderTexte += ValiderTextIsDouble;

                _CheckBox_ToutesLesConfigs          = G.AjouterCheckBox(ToutesLesConfigs);
                _CheckBox_DesactiverDirectionnelles = G.AjouterCheckBox(DesactiverDirectionnelles);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #12
0
        protected void Calque()
        {
            try
            {
                Groupe G;
                G = _Calque.AjouterGroupe("Appliquer");

                _CheckBox_EnregistrerSelection      = G.AjouterCheckBox("Enregistrer les selections");
                _Button_Preselection                = G.AjouterBouton("Preselectionner");
                _Button_Preselection.OnButtonPress += delegate(object sender) { PreSelection(); };

                G = _Calque.AjouterGroupe("Piece sur laquelle inserer les perçages");

                _Select_Base = G.AjouterSelectionBox("Selectionnez le composant");
                _Select_Base.SelectionMultipleMemeEntite = false;
                _Select_Base.SelectionDansMultipleBox    = false;
                _Select_Base.UneSeuleEntite = true;
                _Select_Base.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_Base.OnSubmitSelection  += SelectionnerPiece;
                _Select_Base.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, _pPieceBase); };

                G = _Calque.AjouterGroupe("Composant de perçage");

                _Select_Percage = G.AjouterSelectionBox("Selectionnez le composant");
                _Select_Percage.SelectionMultipleMemeEntite = false;
                _Select_Percage.SelectionDansMultipleBox    = false;
                _Select_Percage.UneSeuleEntite = true;
                _Select_Percage.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_Percage.OnSubmitSelection  += SelectionnerComposant1erNvx;
                _Select_Percage.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, _pPercage); };

                _Select_Base.OnApplyOnSelection += _Select_Percage.GainedFocus;

                G = _Calque.AjouterGroupe("Diametres des trous à contraindre en mm"
                                          + "\r\n  0 ou vide pour tout les perçages"
                                          + "\r\n  Valeurs séparés par une virgule");

                _Text_Diametre = G.AjouterTexteBox(_pDiametre, false);

                // OnCheck, on enregistre les parametres
                _CheckBox_EnregistrerSelection.OnCheck += _Select_Base.ApplyOnSelection;
                _CheckBox_EnregistrerSelection.OnCheck += _Select_Percage.ApplyOnSelection;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Selectionnez le fichier : ");

                _Texte_SelectionnerFichierInfos = G.AjouterTexteBox();
                _Texte_SelectionnerFichierInfos.LectureSeule = true;

                _Bouton_Parcourir = G.AjouterBouton("Parcourir");
                _Bouton_Parcourir.OnButtonPress += delegate(Object Bouton)
                {
                    OpenFileDialog pDialogue = new OpenFileDialog
                    {
                        Filter           = "Fichier texte (*.txt)|*.txt|Tout les fichiers (*.*)|*.*",
                        Multiselect      = false,
                        InitialDirectory = Path.GetDirectoryName(MdlBase.GetPathName()),
                        RestoreDirectory = true
                    };

                    String pChemin = "";

                    if (pDialogue.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        pChemin = pDialogue.FileName;
                    }

                    PublierInfos(pChemin);
                };

                _TextListBox_AfficherInfos = G.AjouterTextListBox("Contenu du fichier :");
                _TextListBox_AfficherInfos.TouteHauteur      = true;
                _TextListBox_AfficherInfos.Height            = 90;
                _TextListBox_AfficherInfos.SelectionMultiple = true;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_ComposantsExterne = G.AjouterCheckBox(_pComposantsExterne);
                _CheckBox_ToutReconstruire  = G.AjouterCheckBox(_pToutReconstruire);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #14
0
        private void SelectionChanged(Object sender, int Item)
        {
            try
            {
                ConfigModule M = _ListeConfigModule[((CtrlTextComboBox)sender).Text];
                _GroupeModule.Titre = M.Intitule;

                var ListeParams = M.ListeParametre;

                for (int i = 0; i < _MaxCtrl; i++)
                {
                    if (i < ListeParams.Count)
                    {
                        var P = ListeParams[i];

                        CtrlCheckBox c = _ListeCheckBox[i];
                        CtrlTextBox  t = _ListeTextBox[i];
                        if (P.Type == typeof(Boolean))
                        {
                            c.Visible = true;
                            t.Visible = false;
                            c.Param   = P;
                            c.Caption = P.Intitule;
                            c.ApplyParam();
                        }
                        else if (P.Type == typeof(String))
                        {
                            c.Visible   = false;
                            t.Visible   = true;
                            t.Param     = P;
                            t.LabelText = P.Intitule;
                            t.ApplyParam();
                        }
                    }
                    else
                    {
                        _ListeCheckBox[i].Visible = false;
                        _ListeTextBox[i].Visible  = false;
                    }
                }
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #15
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_IsolerComposants            = G.AjouterCheckBox("Isoler les composants selectionnés");
                _CheckBox_IsolerComposants.OnIsCheck += delegate(Object sender, Boolean value) { SelectionChanged(null, _TextListBox_Configs.SelectedIndex); };

                G = _Calque.AjouterGroupe("Composant");

                _Select_CompBase = G.AjouterSelectionBox("", "Selectionnez le composant");
                _Select_CompBase.SelectionMultipleMemeEntite = true;
                _Select_CompBase.SelectionDansMultipleBox    = true;
                _Select_CompBase.UneSeuleEntite = true;
                _Select_CompBase.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_CompBase.OnSelectionChanged += delegate(Object sender, int nb) { AfficherConfigs(); };
                _Select_CompBase.Hauteur             = 2;
                _Select_CompBase.Focus = true;

                _TextBox_NomComp = G.AjouterTexteBox("");
                _TextBox_NomComp.LectureSeule = true;

                _TextListBox_Configs = G.AjouterTextListBox("Liste des configurations dans le modèle");
                _TextListBox_Configs.TouteHauteur        = true;
                _TextListBox_Configs.Height              = 80;
                _TextListBox_Configs.SelectionMultiple   = false;
                _TextListBox_Configs.OnSelectionChanged += SelectionChanged;

                G = _Calque.AjouterGroupe("Configurations du composant");

                _Select_Configs = G.AjouterSelectionBox("");
                _Select_Configs.SelectionMultipleMemeEntite = true;
                _Select_Configs.SelectionDansMultipleBox    = true;
                _Select_Configs.UneSeuleEntite = false;
                _Select_Configs.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                _Select_Configs.Hauteur = 15;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #16
0
            protected void Calque()
            {
                try
                {
                    G = _Calque.AjouterGroupe("Options");

                    _EnumComboBox_FormatExport             = G.AjouterEnumComboBox <eTypeFichierExport, Intitule>(FormatExport);
                    _EnumComboBox_FormatExport.FiltrerEnum = eTypeFichierExport.DXF | eTypeFichierExport.DWG;

                    _EnumComboBox_VersionExport = G.AjouterEnumComboBox <eDxfFormat, Intitule>(VersionExport);

                    _CheckBox_UtiliserPoliceACAD = G.AjouterCheckBox(UtiliserPolicesACAD);
                    _CheckBox_UtiliserStylesACAD = G.AjouterCheckBox(UtiliserStylesACAD);

                    _CheckBox_FusionnerExtremites = G.AjouterCheckBox(FusionnerExtremites);
                    _TextBox_ToleranceFusion      = G.AjouterTexteBox(ToleranceFusion);
                    _TextBox_ToleranceFusion.StdIndent();
                    _CheckBox_FusionnerExtremites.OnIsCheck += _TextBox_ToleranceFusion.IsEnable;
                    _CheckBox_ExporterHauteQualite           = G.AjouterCheckBox(ExporterHauteQualite);
                    _CheckBox_ExporterHauteQualite.StdIndent();
                    _CheckBox_FusionnerExtremites.OnIsCheck += _CheckBox_ExporterHauteQualite.IsEnable;
                    _CheckBox_FusionnerExtremites.ApplyParam();

                    _CheckBox_ConvertirSplineToPolyligne = G.AjouterCheckBox(ConvertirSplineToPolyligne);

                    _CheckBox_ExporterFeuilleEspacePapier = G.AjouterCheckBox(ExporterFeuilleEspacePapier);

                    AvecIndiceFichier = false;
                    AvecIndiceDossier = false;

                    AjouterCalqueDossier();

                    _EnumComboBox_FormatExport.OnSelectionChanged += delegate(Object sender, int Item)
                    {
                        _SelectionnerDossier.TypeFichier = _EnumComboBox_FormatExport.Val;
                        _SelectionnerDossier.Maj();
                        _DernierDossier.TypeFichier = _EnumComboBox_FormatExport.Val;
                        _DernierDossier.Maj();
                    };
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
        protected void Calque()
        {
            try
            {
                Groupe G;

                if (MdlBase.TypeDoc() == eTypeDoc.Assemblage)
                {
                    G = _Calque.AjouterGroupe("Options");

                    _Button_IsolerComposants = G.AjouterBouton("Isoler les composants");
                    _Button_IsolerComposants.OnButtonPress += delegate(Object sender) { IsolerComposants(); };
                }

                G = _Calque.AjouterGroupe("Repères :");

                _TextListBox_Reperes = G.AjouterTextListBox();
                _TextListBox_Reperes.TouteHauteur        = true;
                _TextListBox_Reperes.Height              = 170;
                _TextListBox_Reperes.SelectionMultiple   = false;
                _TextListBox_Reperes.OnSelectionChanged += SelectionChanged;

                _CheckBox_ComposantsCache            = G.AjouterCheckBox("Prendre en compte les composants cachés");
                _CheckBox_ComposantsCache.OnIsCheck += delegate(Object sender, Boolean value) { AfficherReperes(); };

                G = _Calque.AjouterGroupe("Selection");

                _TextBox_Nb = G.AjouterTexteBox("Nb de corps :");
                _TextBox_Nb.LectureSeule = true;

                _Select_Selection = G.AjouterSelectionBox("");
                _Select_Selection.SelectionMultipleMemeEntite = true;
                _Select_Selection.SelectionDansMultipleBox    = true;
                _Select_Selection.UneSeuleEntite = false;
                _Select_Selection.FiltreSelection(swSelectType_e.swSelSOLIDBODIES, swSelectType_e.swSelCOMPONENTS);
                _Select_Selection.Hauteur             = 15;
                _Select_Selection.OnSelectionChanged += delegate(Object sender, int nb) { _TextBox_Nb.Text = nb.ToString(); };
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #18
0
        public VehiculeCheckBox(string text)
        {
            Text = text;
            Dock = DockStyle.Top;

            AutoSize = true;
            Font     = new System.Drawing.Font("Microsoft Sans Serif", 8F, System.Drawing.FontStyle.Regular);
            Location = new System.Drawing.Point(0, 5);
            Size     = new System.Drawing.Size(80, 24);

            this.CheckedChanged += (s, e) =>
            {
                ApercuDataGridView gridView = new ApercuDataGridView();              // création nouveau ApercuDataGridView

                AddVehiculesRows(gridView);                                          // ajout des lignes
                CtrlCheckBox.AddControlesColumns(gridView);                          // ajout des colonnes

                MainForm.MainTabControl.ApercuTabPage.ApercuDataGridView = gridView; // Remplassement de MainForm.MainTabControl.ApercuTabPage.ApercuDataGridView par gridView
                MainForm.MainTabControl.ApercuTabPage.Controls.Clear();              //vider l'onglet ApercuTabPage
                MainForm.MainTabControl.ApercuTabPage.Controls.Add(gridView);        // ajout de ApercuDataGridView dans ApercuTabPage
            };
        }
Example #19
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Ajouter des configs : ");

                _Texte_ListeConfigs = G.AjouterTexteBox(_pListeConfigs);

                if (MdlBase.TypeDoc() != eTypeDoc.Piece)
                {
                    G = _Calque.AjouterGroupe("Selectionner les composants à lier");

                    _Select_Composants = G.AjouterSelectionBox("Selectionnez les composants");
                    _Select_Composants.SelectionMultipleMemeEntite = false;
                    _Select_Composants.SelectionDansMultipleBox    = false;
                    _Select_Composants.UneSeuleEntite = false;
                    _Select_Composants.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                    // Filtre sur les composants autre que root
                    //_Select_Composants.OnSubmitSelection += SelectionnerComposantsParent;
                    _Select_Composants.Hauteur = 8;
                }

                G = _Calque.AjouterGroupe("Options");

                if (MdlBase.TypeDoc() != eTypeDoc.Piece)
                {
                    _CheckBox_CreerLesConfigsManquantes = G.AjouterCheckBox(_pCreerConfig);
                }

                _CheckBox_SupprimerNvlFonction = G.AjouterCheckBox(_pSupprimerNvlFonction);
                _CheckBox_SupprimerNvComposant = G.AjouterCheckBox(_pSupprimerNvComposant);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Selectionner le composant de base ou vide");

                _Select_CompBase = G.AjouterSelectionBox("Selectionnez le composant");
                _Select_CompBase.SelectionMultipleMemeEntite = false;
                _Select_CompBase.SelectionDansMultipleBox    = false;
                _Select_CompBase.UneSeuleEntite = true;
                _Select_CompBase.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                // Filtre sur les composants autre que root
                //_Select_CompBase.OnSubmitSelection += SelectionnerComposant1erNvx;

                G = _Calque.AjouterGroupe("Selectionner les composants à contraindre");

                _Select_Composants = G.AjouterSelectionBox("Selectionnez les composants");
                _Select_Composants.SelectionMultipleMemeEntite = false;
                _Select_Composants.SelectionDansMultipleBox    = false;
                _Select_Composants.UneSeuleEntite = false;
                _Select_Composants.FiltreSelection(swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);
                // Filtre sur les composants autre que root
                _Select_Composants.OnSubmitSelection += SelectionnerComposant1erNvx;
                _Select_Composants.Hauteur            = 8;

                _Select_Composants.Focus = true;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_FixerComposant = G.AjouterCheckBox(_pFixerComposant);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #21
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Options");
                _CheckBox_LigneAttache = G.AjouterCheckBox(LigneAttache);

                _CheckBox_ModifierHtTexte    = G.AjouterCheckBox(ModifierHtTexte);
                _Texte_HtTexte               = G.AjouterTexteBox(HtTexte, false);
                _Texte_HtTexte.ValiderTexte += ValiderTextIsInteger;
                _Texte_HtTexte.StdIndent();

                _CheckBox_ModifierHtTexte.OnIsCheck += _Texte_HtTexte.IsEnable;
                _Texte_HtTexte.IsEnabled             = _CheckBox_ModifierHtTexte.IsChecked;

                _GroupeReperage = _Calque.AjouterGroupeAvecCheckBox(Reperage);

                _CheckBox_AfficherQuantite = _GroupeReperage.AjouterCheckBox(AfficherQuantite);

                _GroupeDescription = _Calque.AjouterGroupeAvecCheckBox(Description);

                _CheckBox_PrefixeTole         = _GroupeDescription.AjouterCheckBox(PrefixeTole);
                _CheckBox_ProfilCourt         = _GroupeDescription.AjouterCheckBox(ProfilCourt);
                _CheckBox_AjouterMateriau     = _GroupeDescription.AjouterCheckBox(AjouterMateriau);
                _CheckBox_SautDeLigneMateriau = _GroupeDescription.AjouterCheckBox(SautDeLigneMateriau);
                _CheckBox_SautDeLigneMateriau.StdIndent();

                _CheckBox_AjouterMateriau.OnUnCheck += _CheckBox_SautDeLigneMateriau.UnCheck;
                _CheckBox_AjouterMateriau.OnIsCheck += _CheckBox_SautDeLigneMateriau.IsEnable;
                _CheckBox_AjouterMateriau.ApplyParam();
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Reperage");

                _Texte_IndiceCampagne = G.AjouterTexteBox("Indice de la campagne de repérage :");
                _Texte_IndiceCampagne.LectureSeule = true;

                _CheckBox_CampagneDepartDecompte = G.AjouterCheckBox("Indice actuel comme depart pour le decompte");

                _Texte_IndiceCampagneDepartDecompte = G.AjouterTexteBox("Indice précédent pour le décompte :");
                _Texte_IndiceCampagneDepartDecompte.LectureSeule = true;
                //_Texte_IndiceCampagneDepartDecompte.StdIndent();

                _CheckBox_ReinitCampagneActuelle = G.AjouterCheckBox("Reinitialiser la campagne actuelle");
                _CheckBox_MajCampagnePrecedente  = G.AjouterCheckBox("Mettre à jour la campagne précédente (en cas d'oubli)");

                _CheckBox_ReinitCampagneActuelle.OnCheck   += delegate { _CheckBox_MajCampagnePrecedente.IsEnabled = false; _CheckBox_MajCampagnePrecedente.IsChecked = false; };
                _CheckBox_ReinitCampagneActuelle.OnUnCheck += delegate { if (IndiceCampagne > 1)
                                                                         {
                                                                             _CheckBox_MajCampagnePrecedente.IsEnabled = true;
                                                                         }
                };

                _CheckBox_MajCampagnePrecedente.OnCheck   += delegate { _CheckBox_ReinitCampagneActuelle.IsEnabled = false; _CheckBox_ReinitCampagneActuelle.IsChecked = false; };
                _CheckBox_MajCampagnePrecedente.OnUnCheck += delegate { _CheckBox_ReinitCampagneActuelle.IsEnabled = true; };

                _CheckBox_MajCampagnePrecedente.OnCheck += delegate
                {
                    if (_CheckBox_MajCampagnePrecedente.IsEnabled && (IndiceCampagne > 1))
                    {
                        IndiceCampagne -= 1;
                    }

                    if (ReinitCampagneActuelle)
                    {
                        _CheckBox_ReinitCampagneActuelle.IsEnabled = false;
                    }

                    _CheckBox_CampagneDepartDecompte.IsEnabled    = false;
                    _Texte_IndiceCampagneDepartDecompte.IsEnabled = false;
                };
                _CheckBox_MajCampagnePrecedente.OnUnCheck += delegate
                {
                    if (_CheckBox_MajCampagnePrecedente.IsEnabled)
                    {
                        IndiceCampagne += 1;
                    }

                    if (ReinitCampagneActuelle)
                    {
                        _CheckBox_ReinitCampagneActuelle.IsEnabled = true;
                        _CheckBox_ReinitCampagneActuelle.Visible   = true;
                    }

                    _CheckBox_CampagneDepartDecompte.IsEnabled    = true;
                    _Texte_IndiceCampagneDepartDecompte.IsEnabled = true;
                };

                G = _Calque.AjouterGroupe("Options");
                _CheckBox_CombinerCorpsIdentiques        = G.AjouterCheckBox(CombinerCorpsIdentiques);
                _CheckBox_CombinerAvecCampagnePrecedente = G.AjouterCheckBox(CombinerAvecCampagnePrecedente);
                _CheckBox_CombinerAvecCampagnePrecedente.StdIndent();
                _CheckBox_CreerDvp = G.AjouterCheckBox(CreerDvp);


                _CheckBox_CombinerCorpsIdentiques.OnUnCheck += _CheckBox_CombinerAvecCampagnePrecedente.UnCheck;
                _CheckBox_CombinerCorpsIdentiques.OnIsCheck += _CheckBox_CombinerAvecCampagnePrecedente.IsEnable;

                _EnumComboBox_TypeCorps             = G.AjouterEnumComboBox <eTypeCorps, Intitule>(TypeCorps);
                _EnumComboBox_TypeCorps.FiltrerEnum = eTypeCorps.Tole | eTypeCorps.Barre | eTypeCorps.Piece;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
            public void AjouterAuCalque()
            {
                _Groupe = _Calque.AjouterGroupeAvecCheckBox(_ParamGroupe);

                _TextBox_CheminDossier = _Groupe.AjouterTexteBox();
                AfficherCheminDossier();
                _TextBox_CheminDossier.LectureSeule = true;

                if (_Selectionnable)
                {
                    _Button_Parcourir = _Groupe.AjouterBouton("Parcourir");
                    _Button_Parcourir.OnButtonPress += delegate(Object Bouton)
                    {
                        System.Windows.Forms.FolderBrowserDialog pDialogue = new System.Windows.Forms.FolderBrowserDialog();
                        pDialogue.SelectedPath = _Mdl.eDossier();

                        if (pDialogue.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                        {
                            _NomDossierRelatif = OutilsCommun.CheminRelatif(_Mdl.eDossier(), pDialogue.SelectedPath);
                            AfficherCheminDossier();
                        }

                        Maj();
                    };

                    _TextListBox_ListeDossiers = _Groupe.AjouterTextListBox("Liste des dossiers");
                    _TextListBox_ListeDossiers.TouteHauteur = true;
                    _TextListBox_ListeDossiers.Height       = 50;

                    _TextListBox_ListeDossiers.OnSelectionChanged += delegate(Object sender, int Item)
                    {
                        _NomDossierCourant = _TextListBox_ListeDossiers.SelectedText;
                        MajListeFichiers();
                    };

                    _CheckBox_CreerDossier            = _Groupe.AjouterCheckBox("Nouveau dossier");
                    _TextBox_NomNvxDossier            = _Groupe.AjouterTexteBox();
                    _Button_CreerDossier              = _Groupe.AjouterBouton("Creer");
                    _CheckBox_CreerDossier.OnIsCheck += _TextBox_NomNvxDossier.IsEnable;
                    _CheckBox_CreerDossier.OnIsCheck += _Button_CreerDossier.IsEnable;
                    _CheckBox_CreerDossier.OnIsCheck += _TextBox_NomNvxDossier.IsVisible;
                    _CheckBox_CreerDossier.OnIsCheck += _Button_CreerDossier.IsVisible;
                    _CheckBox_CreerDossier.IsChecked  = false;

                    _Button_CreerDossier.OnButtonPress += delegate(Object Bouton)
                    {
                        String n = _TextBox_NomNvxDossier.Text;
                        Directory.CreateDirectory(Path.Combine(CheminDossierRelatif(), n));

                        Maj();

                        _CheckBox_CreerDossier.IsChecked        = false;
                        _TextListBox_ListeDossiers.SelectedText = n;
                    };
                }

                _TextListBox_ListeFichiers = _Groupe.AjouterTextListBox("Contenu du dossier :");
                _TextListBox_ListeFichiers.TouteHauteur = true;
                _TextListBox_ListeFichiers.Height       = 50;

                _TextBox_NomNvxFichier = _Groupe.AjouterTexteBox();
                _TextBox_NomNvxFichier.OnTextBoxChanged += delegate(Object sender, String text)
                {
                    if (!EcraserInfos)
                    {
                        return;
                    }

                    _NomFichierComplet = text;
                };
            }
        protected void Calque()
        {
            try
            {
                Groupe G;

                ListeGroupe1.Add(_Calque.AjouterGroupe("Fichier"));
                G = ListeGroupe1.Last();

                _Texte_RefFichier = G.AjouterTexteBox("Référence du fichier :", "la référence est ajoutée au début du nom de chaque fichier généré");

                _Texte_RefFichier.Text         = MdlBase.eRefFichierComplet();
                _Texte_RefFichier.LectureSeule = false;

                // S'il n'y a pas de reference, on met le texte en rouge
                if (String.IsNullOrWhiteSpace(_Texte_RefFichier.Text))
                {
                    _Texte_RefFichier.BackgroundColor(Color.Red, true);
                }

                _TextBox_Campagne = G.AjouterTexteBox("Campagne :", "");
                _TextBox_Campagne.LectureSeule = true;

                ListeGroupe1.Add(_Calque.AjouterGroupe("Quantité"));
                G = ListeGroupe1.Last();

                _Texte_Quantite               = G.AjouterTexteBox("Quantité :", "Multiplier les quantités par");
                _Texte_Quantite.Text          = MdlBase.pQuantite();
                _Texte_Quantite.ValiderTexte += ValiderTextIsInteger;

                ListeGroupe1.Add(_Calque.AjouterGroupe("Materiaux :"));
                G = ListeGroupe1.Last();

                _TextListBox_Materiaux = G.AjouterTextListBox();
                _TextListBox_Materiaux.TouteHauteur      = true;
                _TextListBox_Materiaux.Height            = 60;
                _TextListBox_Materiaux.SelectionMultiple = true;

                ListeGroupe1.Add(_Calque.AjouterGroupe("Profil :"));
                G = ListeGroupe1.Last();

                _TextListBox_Profils = G.AjouterTextListBox();
                _TextListBox_Profils.TouteHauteur      = true;
                _TextListBox_Profils.Height            = 50;
                _TextListBox_Profils.SelectionMultiple = true;

                ListeGroupe1.Add(_Calque.AjouterGroupe("Options"));
                G = ListeGroupe1.Last();

                _Option_ListeDebit           = G.AjouterOption("Liste de débit");
                _Option_ListeBarres          = G.AjouterOption("Liste des barres");
                _Option_ListeDebit.OnCheck  += delegate(Object sender) { TypeSortie = eTypeSortie.ListeDebit; };
                _Option_ListeBarres.OnCheck += delegate(Object sender) { TypeSortie = eTypeSortie.ListeBarre; };
                _Option_ListeDebit.IsChecked = true;

                _Texte_LgBarre = G.AjouterTexteBox(LgBarre, true);

                _CheckBox_AfficherListe = G.AjouterCheckBox(AfficherListe);

                ListeGroupe2.Add(_Calque.AjouterGroupe("Lg des barres"));
                G         = ListeGroupe2.Last();
                G.Visible = false;

                for (int i = 0; i < NbProfilMax; i++)
                {
                    ListeCheckBoxLg.Add(G.AjouterCheckBox("Profil " + (i + 1)));
                    CtrlCheckBox c = ListeCheckBoxLg.Last();
                    c.Visible = false;

                    ListeTextBoxLg.Add(G.AjouterTexteBox());
                    CtrlTextBox t = ListeTextBoxLg.Last();
                    t.Text    = _Texte_LgBarre.Text.eToInteger().ToString();
                    t.Visible = false;
                }
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
Example #25
0
        //OneValの生成
        //デフォルト値(nullを設定した場合、適切な値を自動でセットする)
        public static OneVal CreateOneVal(CtrlType ctrlType, Object val)
        {
            //Kernel kernel = new Kernel();
            const string help = "help";
            OneCtrl      oneCtrl;

            switch (ctrlType)
            {
            case CtrlType.CheckBox:
                if (val == null)
                {
                    val = true;
                }
                oneCtrl = new CtrlCheckBox(help);
                break;

            case CtrlType.Int:
                if (val == null)
                {
                    val = 1;
                }
                oneCtrl = new CtrlInt(help, 3);                         // 3桁で決め打ち
                break;

            case CtrlType.File:
                if (val == null)
                {
                    val = "1.txt";
                }
                oneCtrl = new CtrlFile(help, 200, new Kernel());
                break;

            case CtrlType.Folder:
                if (val == null)
                {
                    val = "c:\temp";
                }
                oneCtrl = new CtrlFolder(help, 200, new Kernel());
                break;

            case CtrlType.TextBox:
                if (val == null)
                {
                    val = "abc";
                }
                oneCtrl = new CtrlTextBox(help, 20);
                break;

            case CtrlType.Radio:
                if (val == null)
                {
                    val = 0;
                }
                oneCtrl = new CtrlRadio(help, new[] { "1", "2", "3" }, 30, 3);
                break;

            case CtrlType.Font:
                if (val == null)
                {
                    val = new Font("MS ゴシック", 10f);
                }
                oneCtrl = new CtrlFont(help, LangKind.Jp);
                break;

            case CtrlType.Memo:
                if (val == null)
                {
                    val = "1";
                }
                oneCtrl = new CtrlMemo(help, 10, 10);
                break;

            case CtrlType.Hidden:
                if (val == null)
                {
                    val = "";
                }
                oneCtrl = new CtrlHidden(help, 30);
                break;

            case CtrlType.AddressV4:
                if (val == null)
                {
                    val = "";
                }
                oneCtrl = new CtrlAddress(help);
                break;

            case CtrlType.BindAddr:
                if (val == null)
                {
                    val = "V4ONLY,INADDR_ANY,IN6ADDR_ANY_INIT";
                }
                var list = new List <Ip>();
                try {
                    list.Add(new Ip(IpKind.InAddrAny));
                    list.Add(new Ip("192.168.0.1"));
                } catch (ValidObjException ex) {
                    Assert.Fail(ex.Message);
                }
                oneCtrl = new CtrlBindAddr(help, list.ToArray(), list.ToArray());
                break;

            case CtrlType.ComboBox:
                //listを{"1","2"}で決め打ち

                if (val == null)
                {
                    val = 0;
                }
                oneCtrl = new CtrlComboBox(help, new[] { "1", "2" }, 10);
                break;

            case CtrlType.Dat:
                //カラムはTEXTBOX×2で決め打ち
                var listVal = new ListVal {
                    new OneVal("name1", true, Crlf.Nextline, new CtrlCheckBox("help")),
                    new OneVal("name2", true, Crlf.Nextline, new CtrlCheckBox("help"))
                };

                if (val == null)
                {
                    val = new Dat(new[] { CtrlType.CheckBox, CtrlType.CheckBox });
                }

                oneCtrl = new CtrlDat(help, listVal, 300, LangKind.Jp);
                break;

            default:
                throw new Exception(ctrlType.ToString());
            }
            return(new OneVal("name", val, Crlf.Nextline, oneCtrl));
        }
Example #26
0
            protected void Calque()
            {
                try
                {
                    Groupe G;
                    G = _Calque.AjouterGroupe("Appliquer");

                    _CheckBox_ToutesLesConfig           = G.AjouterCheckBox(pToutesLesConfig);
                    _CheckBox_EnregistrerSelection      = G.AjouterCheckBox("Enregistrer les selections");
                    _Button_Preselection                = G.AjouterBouton("Preselectionner");
                    _Button_Preselection.OnButtonPress += delegate(object sender) { PreSelection(); };

                    G = _Calque.AjouterGroupe("Face du dessus" + " ( " + pFaceDessus.GetValeur <String>() + "@" + pMarche.GetValeur <String>() + " )");

                    _Select_F_Dessus = G.AjouterSelectionBox("", "Selectionnez la face du dessus");
                    _Select_F_Dessus.SelectionMultipleMemeEntite = false;
                    _Select_F_Dessus.SelectionDansMultipleBox    = false;
                    _Select_F_Dessus.UneSeuleEntite = true;
                    _Select_F_Dessus.FiltreSelection(swSelectType_e.swSelFACES, swSelectType_e.swSelCOMPONENTS);

                    _Select_F_Dessus.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltreFace((CtrlSelectionBox)SelBox, selection, selType, pFaceDessus)); };

                    _Select_F_Dessus.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pMarche); };

                    G = _Calque.AjouterGroupe("Face de devant" + " ( " + pFaceDevant.GetValeur <String>() + "@" + pMarche.GetValeur <String>() + " )");

                    _Select_F_Devant = G.AjouterSelectionBox("", "Selectionnez la face de devant");
                    _Select_F_Devant.SelectionMultipleMemeEntite = false;
                    _Select_F_Devant.SelectionDansMultipleBox    = false;
                    _Select_F_Devant.UneSeuleEntite = true;
                    _Select_F_Devant.FiltreSelection(swSelectType_e.swSelFACES, swSelectType_e.swSelCOMPONENTS);

                    _Select_F_Devant.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltreFace((CtrlSelectionBox)SelBox, selection, selType, pFaceDevant)); };

                    _Select_F_Devant.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pMarche); };

                    _Select_F_Dessus.OnApplyOnSelection += _Select_F_Devant.GainedFocus;

                    G = _Calque.AjouterGroupe("Platine gauche" + " ( " + pPlanContrainte.GetValeur <String>() + "@" + pPlatineG.GetValeur <String>() + " )");

                    _Select_PlatineG = G.AjouterSelectionBox("Plan à contraindre");
                    _Select_PlatineG.SelectionMultipleMemeEntite = false;
                    _Select_PlatineG.SelectionDansMultipleBox    = false;
                    _Select_PlatineG.UneSeuleEntite = true;
                    _Select_PlatineG.FiltreSelection(swSelectType_e.swSelDATUMPLANES, swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);

                    _Select_PlatineG.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltrePlan((CtrlSelectionBox)SelBox, selection, selType, pPlanContrainte)); };

                    // Svg des parametres
                    _Select_PlatineG.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pPlatineG); };
                    _Select_PlatineG.OnApplyOnSelection += delegate(Object Box) { SvgNomFonction(Box, pPlanContrainte); };

                    _Select_F_Devant.OnApplyOnSelection += _Select_PlatineG.GainedFocus;

                    G = _Calque.AjouterGroupe("Platine droite" + " ( " + pPlanContrainte.GetValeur <String>() + "@" + pPlatineD.GetValeur <String>() + " )");

                    _Select_PlatineD = G.AjouterSelectionBox("Plan à contraindre");
                    _Select_PlatineD.SelectionMultipleMemeEntite = false;
                    _Select_PlatineD.SelectionDansMultipleBox    = false;
                    _Select_PlatineD.UneSeuleEntite = true;
                    _Select_PlatineD.FiltreSelection(swSelectType_e.swSelDATUMPLANES, swSelectType_e.swSelCOMPONENTS, swSelectType_e.swSelFACES);

                    _Select_PlatineD.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltrePlan((CtrlSelectionBox)SelBox, selection, selType, pPlanContrainte)); };

                    // Svg des parametres
                    _Select_PlatineD.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pPlatineD); };
                    _Select_PlatineD.OnApplyOnSelection += delegate(Object Box) { SvgNomFonction(Box, pPlanContrainte); };

                    _Select_PlatineG.OnApplyOnSelection += _Select_PlatineD.GainedFocus;

                    // OnCheck, on enregistre les parametres
                    _CheckBox_EnregistrerSelection.OnCheck += _Select_F_Dessus.ApplyOnSelection;
                    _CheckBox_EnregistrerSelection.OnCheck += _Select_F_Devant.ApplyOnSelection;
                    _CheckBox_EnregistrerSelection.OnCheck += _Select_PlatineG.ApplyOnSelection;
                    _CheckBox_EnregistrerSelection.OnCheck += _Select_PlatineD.ApplyOnSelection;
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
Example #27
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Fichier");

                _Texte_RefFichier = G.AjouterTexteBox("Référence du fichier :", "la référence est ajoutée au début du nom de chaque fichier généré");

                _Texte_RefFichier.Text         = MdlBase.eRefFichierComplet();
                _Texte_RefFichier.LectureSeule = false;

                // S'il n'y a pas de reference, on met le texte en rouge
                if (String.IsNullOrWhiteSpace(_Texte_RefFichier.Text))
                {
                    _Texte_RefFichier.BackgroundColor(Color.Red, true);
                }

                _TextBox_Campagne = G.AjouterTexteBox("Campagne :", "");
                _TextBox_Campagne.LectureSeule = true;

                _CheckBox_MettreAjourCampagne = G.AjouterCheckBox("Mettre à jour la campagne");

                G = _Calque.AjouterGroupe("Quantité :");

                _Texte_Quantite               = G.AjouterTexteBox("Multiplier par quantité :", "Multiplier les quantités par");
                _Texte_Quantite.Text          = MdlBase.pQuantite();
                _Texte_Quantite.ValiderTexte += ValiderTextIsInteger;

                G = _Calque.AjouterGroupe("Materiaux :");

                _TextListBox_Materiaux = G.AjouterTextListBox();
                _TextListBox_Materiaux.TouteHauteur      = true;
                _TextListBox_Materiaux.Height            = 50;
                _TextListBox_Materiaux.SelectionMultiple = true;

                G = _Calque.AjouterGroupe("Profil :");

                _TextListBox_Profils = G.AjouterTextListBox();
                _TextListBox_Profils.TouteHauteur      = true;
                _TextListBox_Profils.Height            = 50;
                _TextListBox_Profils.SelectionMultiple = true;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_ExporterBarres             = G.AjouterCheckBox(ExporterBarres);
                _EnumComboBox_TypeExport             = G.AjouterEnumComboBox <eTypeFichierExport, Intitule>(TypeExport);
                _EnumComboBox_TypeExport.FiltrerEnum = eTypeFichierExport.Parasolid |
                                                       eTypeFichierExport.ParasolidBinary |
                                                       eTypeFichierExport.STEP;

                _CheckBox_CreerPdf3D = G.AjouterCheckBox(CreerPdf3D);
                _CheckBox_ExporterBarres.OnIsCheck += _CheckBox_CreerPdf3D.IsEnable;
                _CheckBox_ExporterBarres.OnIsCheck += _EnumComboBox_TypeExport.IsEnable;
                _CheckBox_ExporterBarres.ApplyParam();

                _CheckBox_ListerUsinages = G.AjouterCheckBox(ListerUsinages);
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }
            protected void Calque()
            {
                try
                {
                    Groupe G;
                    G = _Calque.AjouterGroupe("Appliquer");

                    _CheckBox_ToutesLesConfig           = G.AjouterCheckBox(pToutesLesConfig);
                    _CheckBox_EnregistrerSelection      = G.AjouterCheckBox("Enregistrer les selections");
                    _Button_Preselection                = G.AjouterBouton("Preselectionner");
                    _Button_Preselection.OnButtonPress += delegate(object sender) { PreSelection(); };

                    G = _Calque.AjouterGroupe("Face du dessus" + " ( " + pFaceDessus.GetValeur <String>() + "@" + pMarche.GetValeur <String>() + " )");

                    _Select_F_Dessus = G.AjouterSelectionBox("Selectionnez la face du dessus");
                    _Select_F_Dessus.SelectionMultipleMemeEntite = false;
                    _Select_F_Dessus.SelectionDansMultipleBox    = false;
                    _Select_F_Dessus.UneSeuleEntite = true;
                    _Select_F_Dessus.FiltreSelection(swSelectType_e.swSelFACES);

                    _Select_F_Dessus.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltreFace((CtrlSelectionBox)SelBox, selection, selType, pFaceDessus)); };

                    _Select_F_Dessus.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pMarche); };

                    G = _Calque.AjouterGroupe("Face de devant" + " ( " + pFaceDevant.GetValeur <String>() + "@" + pMarche.GetValeur <String>() + " )");

                    _Select_F_Devant = G.AjouterSelectionBox("Selectionnez la face de devant");
                    _Select_F_Devant.SelectionMultipleMemeEntite = false;
                    _Select_F_Devant.SelectionDansMultipleBox    = false;
                    _Select_F_Devant.UneSeuleEntite = true;
                    _Select_F_Devant.FiltreSelection(swSelectType_e.swSelFACES);

                    _Select_F_Devant.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltreFace((CtrlSelectionBox)SelBox, selection, selType, pFaceDevant)); };

                    _Select_F_Devant.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pMarche); };

                    _Select_F_Dessus.OnApplyOnSelection += _Select_F_Devant.GainedFocus;

                    G = _Calque.AjouterGroupe("Contremarche" + " ( " + pNomEsquisse.GetValeur <String>() + "@" + pEsquisse.GetValeur <String>() + " )");

                    _Select_ContreMarche_Esquisse = G.AjouterSelectionBox("Selectionnez l'esquisse à configurer", "Esquisse à configurer");
                    _Select_ContreMarche_Esquisse.SelectionMultipleMemeEntite = false;
                    _Select_ContreMarche_Esquisse.SelectionDansMultipleBox    = false;
                    _Select_ContreMarche_Esquisse.UneSeuleEntite = true;
                    _Select_ContreMarche_Esquisse.FiltreSelection(swSelectType_e.swSelSKETCHES, swSelectType_e.swSelCOMPONENTS);

                    _Select_ContreMarche_Esquisse.OnSubmitSelection += delegate(Object SelBox, Object selection, int selType, String itemText)
                    { return(FiltreEsquisse((CtrlSelectionBox)SelBox, selection, selType, pNomEsquisse)); };

                    _Select_ContreMarche_Esquisse.OnApplyOnSelection += delegate(Object Box) { SvgNomComposant(Box, pEsquisse); };
                    _Select_ContreMarche_Esquisse.OnApplyOnSelection += delegate(Object Box) { SvgNomFonction(Box, pNomEsquisse); };

                    _Select_F_Devant.OnApplyOnSelection += _Select_ContreMarche_Esquisse.GainedFocus;

                    //G = _Calque.AjouterGroupe("Options");

                    //_Text_NomEsquisse = G.AjouterTexteBox(_Config.GetParam("NomEsquisse"));
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
Example #29
0
            protected void Calque()
            {
                try
                {
                    Groupe G;

                    G = _Calque.AjouterGroupe("Fichier");

                    _Texte_RefFichier = G.AjouterTexteBox("Référence du fichier :", "la référence est ajoutée au début du nom de chaque fichier généré");

                    String Ref = MdlBase.eRefFichier();
                    _Texte_RefFichier.Text         = Ref;
                    _Texte_RefFichier.LectureSeule = false;

                    // S'il n'y a pas de reference, on met le texte en rouge
                    if (String.IsNullOrWhiteSpace(Ref))
                    {
                        _Texte_RefFichier.BackgroundColor(Color.Red, true);
                    }

                    _Texte_Quantite               = G.AjouterTexteBox("Quantité :", "Multiplier les quantités par");
                    _Texte_Quantite.Text          = Quantite();
                    _Texte_Quantite.ValiderTexte += ValiderTextIsInteger;

                    _CheckBox_ComposantsExterne = G.AjouterCheckBox(ComposantsExterne);

                    G = _Calque.AjouterGroupe("Materiaux :");

                    _TextListBox_Materiaux = G.AjouterTextListBox();
                    _TextListBox_Materiaux.TouteHauteur      = true;
                    _TextListBox_Materiaux.Height            = 60;
                    _TextListBox_Materiaux.SelectionMultiple = true;

                    _CheckBox_ForcerMateriau                         = G.AjouterCheckBox("Forcer le materiau");
                    _TextComboBox_ForcerMateriau                     = G.AjouterTextComboBox();
                    _TextComboBox_ForcerMateriau.Editable            = true;
                    _TextComboBox_ForcerMateriau.LectureSeule        = false;
                    _TextComboBox_ForcerMateriau.NotifieSurSelection = false;
                    _TextComboBox_ForcerMateriau.IsEnabled           = false;
                    _CheckBox_ForcerMateriau.OnIsCheck              += _TextComboBox_ForcerMateriau.IsEnable;

                    G = _Calque.AjouterGroupe("Options");

                    _CheckBox_PrendreEnCompteTole            = G.AjouterCheckBox(PrendreEnCompteTole);
                    _CheckBox_PrendreEnCompteTole.OnIsCheck += delegate(Object sender, Boolean value) { Rechercher_Materiaux(); };

                    _CheckBox_ExporterBarres             = G.AjouterCheckBox(ExporterBarres);
                    _EnumComboBox_TypeExport             = G.AjouterEnumComboBox <eTypeFichierExport, Intitule>(TypeExport);
                    _EnumComboBox_TypeExport.FiltrerEnum = eTypeFichierExport.Parasolid |
                                                           eTypeFichierExport.ParasolidBinary |
                                                           eTypeFichierExport.STEP;

                    _CheckBox_CreerPdf3D = G.AjouterCheckBox(CreerPdf3D);
                    _CheckBox_ExporterBarres.OnIsCheck += _CheckBox_CreerPdf3D.IsEnable;
                    _CheckBox_ExporterBarres.OnIsCheck += _EnumComboBox_TypeExport.IsEnable;
                    _CheckBox_ExporterBarres.ApplyParam();

                    _CheckBox_ListerUsinages = G.AjouterCheckBox(ListerUsinages);
                }
                catch (Exception e)
                { this.LogMethode(new Object[] { e }); }
            }
Example #30
0
        protected void Calque()
        {
            try
            {
                Groupe G;

                G = _Calque.AjouterGroupe("Fichier");

                _Texte_RefFichier = G.AjouterTexteBox("Référence du fichier :", "la référence est ajoutée au début du nom de chaque fichier généré");

                _Texte_RefFichier.Text         = MdlBase.eRefFichierComplet();
                _Texte_RefFichier.LectureSeule = false;

                // S'il n'y a pas de reference, on met le texte en rouge
                if (String.IsNullOrWhiteSpace(_Texte_RefFichier.Text))
                {
                    _Texte_RefFichier.BackgroundColor(Color.Red, true);
                }

                _TextBox_Campagne = G.AjouterTexteBox("Campagne :", "");
                _TextBox_Campagne.LectureSeule = true;

                _CheckBox_MettreAjourCampagne = G.AjouterCheckBox("Mettre à jour la campagne");

                G = _Calque.AjouterGroupe("Quantité :");

                _Texte_Quantite               = G.AjouterTexteBox("Multiplier par quantité :", "Multiplier les quantités par");
                _Texte_Quantite.Text          = MdlBase.pQuantite();
                _Texte_Quantite.ValiderTexte += ValiderTextIsInteger;

                G = _Calque.AjouterGroupe("Materiaux :");

                _TextListBox_Materiaux = G.AjouterTextListBox();
                _TextListBox_Materiaux.TouteHauteur      = true;
                _TextListBox_Materiaux.Height            = 50;
                _TextListBox_Materiaux.SelectionMultiple = true;

                G = _Calque.AjouterGroupe("Ep :");

                _TextListBox_Ep = G.AjouterTextListBox();
                _TextListBox_Ep.TouteHauteur      = true;
                _TextListBox_Ep.Height            = 50;
                _TextListBox_Ep.SelectionMultiple = true;

                G = _Calque.AjouterGroupe("Options");

                _CheckBox_AfficherLignePliage = G.AjouterCheckBox(AfficherLignePliage);
                _CheckBox_AfficherNotePliage  = G.AjouterCheckBox(AfficherNotePliage);
                _CheckBox_AfficherNotePliage.StdIndent();

                _CheckBox_AfficherLignePliage.OnUnCheck += _CheckBox_AfficherNotePliage.UnCheck;
                _CheckBox_AfficherLignePliage.OnIsCheck += _CheckBox_AfficherNotePliage.IsEnable;

                // Pour eviter d'ecraser le parametre de "AfficherNotePliage", le met à jour seulement si
                if (!_CheckBox_AfficherLignePliage.IsChecked)
                {
                    _CheckBox_AfficherNotePliage.IsChecked = _CheckBox_AfficherLignePliage.IsChecked;
                    _CheckBox_AfficherNotePliage.IsEnabled = _CheckBox_AfficherLignePliage.IsChecked;
                }

                _CheckBox_InscrireNomTole              = G.AjouterCheckBox(InscrireNomTole);
                _Texte_TailleInscription               = G.AjouterTexteBox(TailleInscription, false);
                _Texte_TailleInscription.ValiderTexte += ValiderTextIsInteger;
                _Texte_TailleInscription.StdIndent();

                _CheckBox_InscrireNomTole.OnIsCheck += _Texte_TailleInscription.IsEnable;
                _Texte_TailleInscription.IsEnabled   = _CheckBox_InscrireNomTole.IsChecked;

                _CheckBox_OrienterDvp        = G.AjouterCheckBox(OrienterDvp);
                _EnumComboBox_OrientationDvp = G.AjouterEnumComboBox <eOrientation, Intitule>(OrientationDvp);
                _EnumComboBox_OrientationDvp.StdIndent();

                _CheckBox_OrienterDvp.OnIsCheck       += _EnumComboBox_OrientationDvp.IsEnable;
                _EnumComboBox_OrientationDvp.IsEnabled = _CheckBox_OrienterDvp.IsChecked;
            }
            catch (Exception e)
            { this.LogMethode(new Object[] { e }); }
        }