[Func] Restreindre la saisie dans un Edit

Partagez des fonctions et des UDF AutoIt.
Règles du forum
.
Répondre
Jerem
Niveau 2
Niveau 2
Messages : 18
Enregistré le : ven. 17 mai 2013 10:13
Status : Hors ligne

[Func] Restreindre la saisie dans un Edit

#1

Message par Jerem » lun. 25 sept. 2017 18:52

Bonjour à vous,

Je voulais avoir un moyen de contrôler, quasiment en temps réel, la saisie dans mes champs de saisie.
Un peu à la manière du style "$ES_NUMBER" mais pour tous type de saisie.
Je voulais également que la sélection ne soit pas modifiée en cas de valeur incorrecte.

J'ai cherché, mais je n'ai rien trouvé de tel alors j'ai essayé de le faire par moi-même.

Mon but était de créer une fonction complètement indépendante mais je n'ai pas réussi à le faire à cause du mode de fonctionnement même de la mise à jour d'un champ de texte.

J'ai essayé de simplifier le code au maximum. Je suis désolé si ma façon de coder ne correspond pas à vos standards, mes noms de variables sont très verbalisés et francisés.

Je livre la fonction en l'état, je l'ai, bien évidemment, testée mais je n'ai pas pris de précaution particulière quant à l'appel de la fonction pour vérifier les variables.

Je précise également que cette fonction ne peut s'appliquer qu'à des contrôles de type "Edit", pas aux "Input".


Voici la fonction.

#cs ----------------------------------------------------------------------------

 AutoIt Version: 3.3.14.2
        Auteur : Jérémy

        Description :
                Restreint les possibilités de saisie dans un champ de texte.
                Ne fonctionne pas avec les contrôles de type "Input".


                Cette fonction implique l'utilisation de 3 variables prédéfnies dans le script.
                Il faut également utiliser  GUIRegisterMsg ($WM_COMMAND, "").
                Enfin, il faut réinitialiser les variables dans la boucle principale du programme.

#ce ----------------------------------------------------------------------------

#include <GuiEdit.au3>

#Region ### RestreindreEdit
#cs
        Paramètres :
                $pVar : Cette variable sera modifiée par la fonction et doit exister dans le code d'appel.
                                Elle doit contenir le même texte que le contrôle d'édition.
                                Elle doit être réinitialisée à chaque fin de modification.
                $pTailleModif : Cette variable sera modifiée par la fonction et doit exister dans le code d'appel.
                                Elle n'a pas besoin d'avoir de valeur au début du programme.
                                Elle contiendra un nombre qui fait référence au nombre de caractères supprimés.
                $pBoolModif : Cette variable sera modifiée par la fonction et doit exister dans le code d'appel.
                                Elle doit être initialisée à "False" et réinitialisée à chaque fin de modification.
                $pCtrlId : Cette variable contient l'ID du contrôle d'édition. !! Pas de handle !!
                $pAction : Cette variable contient l'action réalisée sur le contrôle d'édition.
                $pRestriction : Cette variable représente le type de vérification que l'on souhaite effectuer sur le contrôle d'édition.
                                Par défaut, aucune restriction ne s'applique, les autres sont :
                                        1 => Seules les lettres sont autorisées.
                                        2 => Les lettres et les tirets "-" sont autorisés .
                                        3 => Les lettres, Les chiffres, les espaces et les caractères   -  ,  '  (  )   sont autorisés.

        Il est possible d'ajouter d'autre type de restriction dans le switch.
#ce
Func RestreindreEdit (ByRef $pVar, ByRef $pTailleModif, ByRef $pBoolModif, $pCtrlId, $pAction, $pRestriction = 0)
        If ($pAction = $EN_UPDATE) Then
                ; On récupère la taille de la chaine de contrôle.
                Local $taillePVar = StringLen ($pVar)

                ; On récupère la valeur du contrôle.
                Local $pCtrlIdVal = GUICtrlRead ($pCtrlId)
                ; On récupère la taille de la valeur du contrôle.
                Local $taillePCtrlIdVal = StringLen ($pCtrlIdVal)

                ; Si l'Edit n'est pas encore en cours de modification.
                If Not $pBoolModif Then
                        ; On récupère la taille de la modification.
                        $pTailleModif = $taillePVar - $taillePCtrlIdVal
                        ; Si la taille de la modification est inférieure à 0, on remet à 0.
                        If $pTailleModif < 0 Then $pTailleModif = 0
                        ; L'edit est en cours de modification.
                        $pBoolModif = True
                EndIf

                ; Booléen qui permet de savoir s'il faut appliquer une restriction.
                Local $boolRestriction = False

                ; On vérifie si la chaîne respecte les règles correspondantes.
                Switch $pRestriction
                        Case 1 ; Seules les lettres sont autorisées.
                                $boolRestriction = Not (StringIsAlpha ($pCtrlIdVal) Or $pCtrlIdVal == "")
                        Case 2 ; Les lettres et les tirets "-" sont autorisés .
                                Local $tmpVal = StringReplace ($pCtrlIdVal, "-", "")
                                $boolRestriction = Not (StringIsAlpha ($tmpVal) Or $tmpVal == "")
                        Case 3 ; Les lettres, Les chiffres, les espaces et les caractères   -  ,  '  (  )   sont autorisés.
                                Local $tmpVal = StringRegExpReplace($pCtrlIdVal, "-|,|'| |\(|\)", "")
                                $boolRestriction = Not (StringIsAlNum ($tmpVal) Or $tmpVal == "")
                EndSwitch

                ; On vérifie que le nom de la base ne contient que des lettres et des chiffres et que le nom n'est pas vide ou que sa taille ne dépasse pas 40 caractères.
                If $boolRestriction Then

                        ; Point de départ de la sélection = Position actuelle - Taille de la chaine ajoutée (= taille de la valeur actuelle - (taille de la valeur de contrôle - nombre de caractères supprimés))
                        Local $departSelection = _GUICtrlEdit_GetSel ($pCtrlId) [0] - ($taillePCtrlIdVal - ($taillePVar - $pTailleModif))

                        ; Point de fin de la sélection avant la modification du nom de la base (Point de départ + taille de la sélection (=Taille de l'ancienne base - taille de la base)).
                        Local $finSelection = $departSelection + $pTailleModif

                        ; On affecte l'ancienne valeur au contrôle d'édition.
                        GUICtrlSetData ($pCtrlId, $pVar)
                        ; On positionne la sélection telle qu'elle était avant la modification.
                        _GUICtrlEdit_SetSel ($pCtrlId, $departSelection, $finSelection)
                EndIf
        EndIf
EndFunc
#EndRegion ### Fin : RestreindreEdit

Et voici le code minimale pour la tester :

#cs ----------------------------------------------------------------------------

 AutoIt Version: 3.3.14.2
        Auteur : Jérémy

        Description :
                Test RestreindreEdit

#ce ----------------------------------------------------------------------------
#include <editconstants.au3>
#include <guiconstantsEx.au3>
#include <GuiEdit.au3>
#include <windowsconstants.au3>

#include "RestreindreEdit.au3"

Opt ("GUIOnEventMode", 1)

$fenetre = GUICreate("Test", 120, 100)
GUISetOnEvent (-3, "Quitter", $fenetre)
$edit1Val = "Nom"
$edit1 = GUICtrlCreateEdit ($edit1Val, 10, 10, 100, 20, $ES_AUTOHSCROLL)
$edit2Val = "Ville"
$edit2 = GUICtrlCreateEdit ($edit2Val, 10, 40, 100, 20, $ES_AUTOHSCROLL)
$edit3Val = "Adresse"
$edit3 = GUICtrlCreateEdit ($edit3Val, 10, 70, 100, 20, $ES_AUTOHSCROLL)

; Booléen qui indique si un changement doit être validé.
Local $boolEditChange = False
; Différence de taille entre l'ancienne et la nouvelle valeur.
Local $tailleEditChange = 0

Main ()

Func Main ()
        GUIRegisterMsg ($WM_COMMAND, "SurveilleEdit")

        GUISetState()

        While True
                If $boolEditChange Then
                        $boolEditChange = False
                        $edit1Val = GUICtrlRead ($edit1)
                        $edit2Val = GUICtrlRead ($edit2)
                        $edit3Val = GUICtrlRead ($edit3)
                EndIf
        WEnd
EndFunc

Func SurveilleEdit ($hwnd, $imsg, $iwParam, $ilParam)
        Local $action = BitShift ($iwParam, 16)

        Switch $ilParam
                Case GUICtrlGetHandle ($edit1)
                        RestreindreEdit ($edit1Val, $tailleEditChange, $boolEditChange, $edit1, $action, 1)
                Case GUICtrlGetHandle ($edit2)
                        RestreindreEdit ($edit2Val, $tailleEditChange, $boolEditChange, $edit2, $action, 2)
                Case GUICtrlGetHandle ($edit3)
                        RestreindreEdit ($edit3Val, $tailleEditChange, $boolEditChange, $edit3, $action, 3)
        EndSwitch
EndFunc

Func Quitter ()
        MsgBox (0, "", "Edit1Val = " & $edit1Val & @CRLF & "Edit2Val = " & $edit2Val & @CRLF & "Edit3Val = " & $edit3Val)
        Exit
EndFunc

Si vous avez des idées d'amélioration n'hésitez pas. Et si ça existe déjà (SVP ne dites rien :P ) j'aurai passé mon week-end sur ça pour rien.
J'espère que ça pourra être utile à certains, d'autant qu'il est facile d'ajouter des modes de contrôles.

Répondre

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité