Envoyer du texte après l'execution du commande DOS ? [Résolu]

kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 25 nov. 2004 à 21:32 - Dernière réponse : kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention
- 27 nov. 2004 à 17:08
Bonjour,

je suis confronté à un pb après l'execution d'une appli exe sous DOS, l'application, une fois lancée, demande des paramètres (ke l'on ne peut pas entrer en arguments au lancement du shell).

il fodrait donc ke je puisse envoyer des strings à mon shell DOS, avec pk pas gestion du temps de la frappe aléatoire...

après avoir rechercher des infos dans le forum et les sources, je suis tombé sur une source super bien faite, ki permet de récupérer le résultat de l'appli sous DOS:
http://www.vbfrance.com/code.aspx?ID=6395

mais je ne vois pas comment y ajouter les fonctions ki m'interessent... j'avous etre newbie dans le domaine de la programmation...

merci d'avance pour votre aide... ;)
Afficher la suite 

9 réponses

Meilleure réponse
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 27 nov. 2004 à 17:08
3
Merci
Après des heures de mission, g réussi a trouvé un code créé par Bryan Wolf en 1999 et le je l'ai un peu modif pour faire tt ca a partir d'1 module de classe... ce ke j'esplike ci dessous...

Dans un module de classe ke vous nommez DOSSendKeys.cls:

Private Declare Function OemKeyScan Lib "user32" (ByVal wOemChar As Integer) As _
    Long
Private Declare Function CharToOem Lib "user32" Alias "CharToOemA" (ByVal _
    lpszSrc As String, ByVal lpszDst As String) As Long
Private Declare Function VkKeyScan Lib "user32" Alias "VkKeyScanA" (ByVal cChar _
    As Byte) As Integer
Private Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" _
    (ByVal wCode As Long, ByVal wMapType As Long) As Long
Private Declare Sub keybd_event Lib "user32" (ByVal bVk As Byte, _
    ByVal bScan As Byte, ByVal dwFlags As Long, ByVal dwExtraInfo As Long)

Private Const KEYEVENTF_KEYDOWN      As Long = &H0
Private Const KEYEVENTF_KEYUP        As Long = &H2

Private Type VKType
    VKCode As Integer
    scanCode As Integer
    Control As Boolean
    Shift As Boolean
    Alt As Boolean
End Type

'---------------------------------------------------------------------
' Routine: VBSendKeys()
'
' Author:  Bryan Wolf, 1999
' Adapté:  en module de classe par kouby2k4 (DOSSendKeys.cls)
'
' Purpose: Imitate VB's internal SendKeys statement, but add the
'          ability to send keypresses to a DOS application.  You
'          can use SendKeys, to paste ASCII characters to a DOS
'          window from the clipboard, but you can't send function
'          keys.  This module solves that problem and makes sending
'          any keys to any Application, DOS or Windows, easy.
'
' Arguments: Keystrokes.  Note that this does not implement the
'            SendKeys's 'wait' argument.  If you need to wait,
'            try using a timing loop.
'
'            The syntax for specifying keystrokes is the
'            same as that of SendKeys - Please refer to VB's
'            documentation for an in-depth description.  Support
'            for the following codes has been added, in addition
'            to the standard set of codes suppored by SendKeys:
'
'            KEY                  CODE
'            break                {CANCEL}
'            escape               {ESCAPE}
'            left mouse button    {LBUTTON}
'            right mouse button   {RBUTTON}
'            middle mouse button  {MBUTTON}
'            clear                {CLEAR}
'            shift                {SHIFT}
'            control              {CONTROL}
'            alt                  {MENU} or {ALT}
'            pause                {PAUSE}
'            space                {SPACE}
'            select               {SELECT}
'            execute              {EXECUTE}
'            snapshot             {SNAPSHOT}
'            number pad 0         {NUMPAD0}
'            number pad 1         {NUMPAD1}
'            number pad 2         {NUMPAD2}
'            number pad 3         {NUMPAD3}
'            number pad 4         {NUMPAD4}
'            number pad 5         {NUMPAD5}
'            number pad 6         {NUMPAD6}
'            number pad 7         {NUMPAD7}
'            number pad 8         {NUMPAD8}
'            number pad 9         {NUMPAD9}
'            number pad multiply  {MULTIPLY}
'            number pad add       {ADD}
'            number pad separator {SEPARATOR}
'            number pad subtract  {SUBTRACT}
'            number pad decimal   {DECIMAL}
'            number pad divide    {DIVIDE}
'
' Sample Calls:
'   VbSendKeys "Dir~"   ' View a directory of in DOS
'
' NOTE: there is a minor difference with SendKeys syntax. You can
'       group multiple characters under the same shift key using
'       curly brackets, while VB's SendKeys uses regular brackets.
'       For example, to keep the SHIFT key pressed while you type
'       A, B, and C keys, you must run the following statement
'           VBSendKeys "+{abc}"
'       while the syntax of the built-in VB function is
'           SendKeys "+(abc)"
'---------------------------------------------------------------------

Sub VbSendKeys(ByVal sKeystrokes As String)
    Dim iKeyStrokesLen As Integer
    Dim lRepetitions As Long
    Dim bShiftKey As Boolean
    Dim bControlKey As Boolean
    Dim bAltKey As Boolean
    Dim lResult As Long
    Dim sKey As String
    Dim iAsciiKey As Integer
    Dim iVirtualKey As Integer
    Dim i As Long
    Dim j As Long
  
    Static bInitialized As Boolean
    Static AsciiKeys(0 To 255) As VKType
    Static VirtualKeys(0 To 255) As VKType
  
    On Error GoTo 0

    If Not bInitialized Then
        Dim iKey As Integer
        Dim OEMChar As String
        Dim keyScan As Integer
        
        ' Initialize AsciiKeys()
        For iKey = LBound(AsciiKeys) To UBound(AsciiKeys)
            keyScan = VkKeyScan(iKey)
            AsciiKeys(iKey).VKCode = keyScan And &HFF   ' low-byte of key scan
                                                        ' code
            AsciiKeys(iKey).Shift = (keyScan And &H100)
            AsciiKeys(iKey).Control = (keyScan And &H200)
            AsciiKeys(iKey).Alt = (keyScan And &H400)
            ' Get the ScanCode
            OEMChar = "  " ' 2 Char
            CharToOem Chr(iKey), OEMChar
            AsciiKeys(iKey).scanCode = OemKeyScan(Asc(OEMChar)) And &HFF
        Next iKey
        
        ' Initialize VirtualKeys()
        For iKey = LBound(VirtualKeys) To UBound(VirtualKeys)
            VirtualKeys(iKey).VKCode = iKey
            VirtualKeys(iKey).scanCode = MapVirtualKey(iKey, 0)
            ' no use in initializing remaining elements
        Next iKey
        bInitialized = True     ' don't run this code twice
    End If    ' End of initialization routine
  
    ' Parse the string in the same way that SendKeys() would
    Do While Len(sKeystrokes)
        lRepetitions = 1 ' Default number of repetitions for each character
        bShiftKey = False
        bControlKey = False
        bAltKey = False
        
        ' Pull off Control, Alt or Shift specifiers
        sKey = Left$(sKeystrokes, 1)
        sKeystrokes = Mid$(sKeystrokes, 2)
        
        Do While InStr(" ^%+", sKey) > 1 ' The space in " ^%+" is necessary
            If sKey = "+" Then
                bShiftKey = True
            ElseIf sKey = "^" Then
                bControlKey = True
            ElseIf sKey = "%" Then
                bAltKey = True
            End If
            sKey = Left$(sKeystrokes, 1)
            sKeystrokes = Mid$(sKeystrokes, 2)
        Loop
        
        ' Look for "{}"
        If sKey = "{" Then
            ' Look for the  "}"
            i = InStr(sKeystrokes, "}")
            If i > 0 Then
                sKey = Left$(sKeystrokes, i - 1) ' extract the content between
                                                 ' the {}
                sKeystrokes = Mid$(sKeystrokes, i + 1) ' Remove the }
            End If
        
            ' Look for repetitions
            i = Len(sKey)
            Do While Mid$(sKey, i, 1) >= "0" And Mid$(sKey, i, _
                1) <= "9" And i >= 3
                i = i - 1
            Loop
        
            If i < Len(sKey) Then ' If any digits were found...
                If i >= 2 Then ' If there is something preceding it...
                    If Mid$(sKey, i, 1) = " " Then  ' If a space precedes the
                                                    ' digits...
                        On Error Resume Next ' On overflow, ignore the value
                        lRepetitions = CLng(Mid$(sKey, i + 1))
                        On Error GoTo 0
                        sKey = Left$(sKey, i - 1)
                    End If
                End If
            End If
        End If
        
        ' Look for special words
        Select Case UCase$(sKey)
            Case "LBUTTON" ' New
                iVirtualKey = vbKeyLButton
            Case "RBUTTON" ' New
                iVirtualKey = vbKeyRButton
            Case "BREAK", "CANCEL"
                iVirtualKey = vbKeyCancel
            Case "MBUTTON" ' New
                iVirtualKey = vbKeyMButton
            Case "BACKSPACE", "BS", "BKSP"
                iVirtualKey = vbKeyBack
            Case "TAB"
                iVirtualKey = vbKeyTab
            Case "CLEAR" ' New
                iVirtualKey = vbKeyClear
            Case "ENTER", "~"
                iVirtualKey = vbKeyReturn
            Case "SHIFT" ' New
                iVirtualKey = vbKeyShift
            Case "CONTROL" ' New
                iVirtualKey = vbKeyControl
            Case "MENU", "ALT" ' New
                iVirtualKey = vbKeyMenu
            Case "PAUSE" ' New
                iVirtualKey = vbKeyPause
            Case "CAPSLOCK"
                iVirtualKey = vbKeyCapital
            Case "ESCAPE", "ESC"
                iVirtualKey = vbKeyEscape
            Case "SPACE" ' New
                iVirtualKey = vbKeySpace
            Case "PGUP"
                iVirtualKey = vbKeyPageUp
            Case "PGDN"
                iVirtualKey = vbKeyPageDown
            Case "END"
                iVirtualKey = vbKeyEnd
            Case "HOME" ' New
                iVirtualKey = vbKeyHome
            Case "LEFT"
                iVirtualKey = vbKeyLeft
            Case "UP"
                iVirtualKey = vbKeyUp
            Case "RIGHT"
                iVirtualKey = vbKeyRight
            Case "DOWN"
                iVirtualKey = vbKeyDown
            Case "SELECT" ' New
                iVirtualKey = vbKeySelect
            Case "PRTSC"
                iVirtualKey = vbKeyPrint
            Case "EXECUTE" ' New
                iVirtualKey = vbKeyExecute
            Case "SNAPSHOT" ' New
                iVirtualKey = vbKeySnapshot
            Case "INSERT", "INS"
                iVirtualKey = vbKeyInsert
            Case "DELETE", "DEL"
                iVirtualKey = vbKeyDelete
            Case "HELP"
                iVirtualKey = vbKeyHelp
            Case "NUMLOCK"
                iVirtualKey = vbKeyNumlock
            Case "SCROLLLOCK"
                iVirtualKey = vbKeyScrollLock
            Case "NUMPAD0" ' New
                iVirtualKey = vbKeyNumpad0
            Case "NUMPAD1" ' New
                iVirtualKey = vbKeyNumpad1
            Case "NUMPAD2" ' New
                iVirtualKey = vbKeyNumpad2
            Case "NUMPAD3" ' New
                iVirtualKey = vbKeyNumpad3
            Case "NUMPAD4" ' New
                iVirtualKey = vbKeyNumpad4
            Case "NUMPAD5" ' New
                iVirtualKey = vbKeyNumpad5
            Case "NUMPAD6" ' New
                iVirtualKey = vbKeyNumpad6
            Case "NUMPAD7" ' New
                iVirtualKey = vbKeyNumpad7
            Case "NUMPAD8" ' New
                iVirtualKey = vbKeyNumpad8
            Case "NUMPAD9" ' New
                iVirtualKey = vbKeyNumpad9
            Case "MULTIPLY" ' New
                iVirtualKey = vbKeyMultiply
            Case "ADD" ' New
                iVirtualKey = vbKeyAdd
            Case "SEPARATOR" ' New
                iVirtualKey = vbKeySeparator
            Case "SUBTRACT" ' New
                iVirtualKey = vbKeySubtract
            Case "DECIMAL" ' New
                iVirtualKey = vbKeyDecimal
            Case "DIVIDE" ' New
                iVirtualKey = vbKeyDivide
            Case "F1"
                iVirtualKey = vbKeyF1
            Case "F2"
                iVirtualKey = vbKeyF2
            Case "F3"
                iVirtualKey = vbKeyF3
            Case "F4"
                iVirtualKey = vbKeyF4
            Case "F5"
                iVirtualKey = vbKeyF5
            Case "F6"
                iVirtualKey = vbKeyF6
            Case "F7"
                iVirtualKey = vbKeyF7
            Case "F8"
                iVirtualKey = vbKeyF8
            Case "F9"
                iVirtualKey = vbKeyF9
            Case "F10"
                iVirtualKey = vbKeyF10
            Case "F11"
                iVirtualKey = vbKeyF11
            Case "F12"
                iVirtualKey = vbKeyF12
            Case "F13"
                iVirtualKey = vbKeyF13
            Case "F14"
                iVirtualKey = vbKeyF14
            Case "F15"
                iVirtualKey = vbKeyF15
            Case "F16"
                iVirtualKey = vbKeyF16
            Case Else
                ' Not a virtual key
                iVirtualKey = -1
        End Select
        
        ' Turn on CONTROL, ALT and SHIFT keys as needed
        If bShiftKey Then
            keybd_event VirtualKeys(vbKeyShift).VKCode, _
                VirtualKeys(vbKeyShift).scanCode, KEYEVENTF_KEYDOWN, 0
        End If
        
        If bControlKey Then
            keybd_event VirtualKeys(vbKeyControl).VKCode, _
                VirtualKeys(vbKeyControl).scanCode, KEYEVENTF_KEYDOWN, 0
        End If
        
        If bAltKey Then
            keybd_event VirtualKeys(vbKeyMenu).VKCode, _
                VirtualKeys(vbKeyMenu).scanCode, KEYEVENTF_KEYDOWN, 0
        End If
        
        ' Send the keystrokes
        For i = 1 To lRepetitions
            If iVirtualKey > -1 Then
                ' Virtual key
                keybd_event VirtualKeys(iVirtualKey).VKCode, _
                    VirtualKeys(iVirtualKey).scanCode, KEYEVENTF_KEYDOWN, 0
                keybd_event VirtualKeys(iVirtualKey).VKCode, _
                    VirtualKeys(iVirtualKey).scanCode, KEYEVENTF_KEYUP, 0
            Else
                ' ASCII Keys
                For j = 1 To Len(sKey)
                    iAsciiKey = Asc(Mid$(sKey, j, 1))
                    ' Turn on CONTROL, ALT and SHIFT keys as needed
                    If Not bShiftKey Then
                        If AsciiKeys(iAsciiKey).Shift Then
                            keybd_event VirtualKeys(vbKeyShift).VKCode, _
                                VirtualKeys(vbKeyShift).scanCode, _
                                KEYEVENTF_KEYDOWN, 0
                        End If
                    End If
        
                    If Not bControlKey Then
                        If AsciiKeys(iAsciiKey).Control Then
                            keybd_event VirtualKeys(vbKeyControl).VKCode, _
                                VirtualKeys(vbKeyControl).scanCode, _
                                KEYEVENTF_KEYDOWN, 0
                        End If
                    End If
        
                    If Not bAltKey Then
                        If AsciiKeys(iAsciiKey).Alt Then
                            keybd_event VirtualKeys(vbKeyMenu).VKCode, _
                                VirtualKeys(vbKeyMenu).scanCode, _
                                KEYEVENTF_KEYDOWN, 0
                        End If
                    End If
        
                    ' Press the key
                    keybd_event AsciiKeys(iAsciiKey).VKCode, _
                        AsciiKeys(iAsciiKey).scanCode, KEYEVENTF_KEYDOWN, 0
                    keybd_event AsciiKeys(iAsciiKey).VKCode, _
                        AsciiKeys(iAsciiKey).scanCode, KEYEVENTF_KEYUP, 0
        
                    ' Turn on CONTROL, ALT and SHIFT keys as needed
                    If Not bShiftKey Then
                        If AsciiKeys(iAsciiKey).Shift Then
                            keybd_event VirtualKeys(vbKeyShift).VKCode, _
                                VirtualKeys(vbKeyShift).scanCode, _
                                KEYEVENTF_KEYUP, 0
                        End If
                    End If
        
                    If Not bControlKey Then
                        If AsciiKeys(iAsciiKey).Control Then
                            keybd_event VirtualKeys(vbKeyControl).VKCode, _
                                VirtualKeys(vbKeyControl).scanCode, _
                                KEYEVENTF_KEYUP, 0
                        End If
                    End If
        
                    If Not bAltKey Then
                        If AsciiKeys(iAsciiKey).Alt Then
                            keybd_event VirtualKeys(vbKeyMenu).VKCode, _
                                VirtualKeys(vbKeyMenu).scanCode, _
                                KEYEVENTF_KEYUP, 0
                        End If
                    End If
                Next j ' Each ASCII key
            End If  ' ASCII keys
        Next i ' Repetitions
        
        ' Turn off CONTROL, ALT and SHIFT keys as needed
        If bShiftKey Then
            keybd_event VirtualKeys(vbKeyShift).VKCode, _
                VirtualKeys(vbKeyShift).scanCode, KEYEVENTF_KEYUP, 0
        End If
        
        If bControlKey Then
            keybd_event VirtualKeys(vbKeyControl).VKCode, _
                VirtualKeys(vbKeyControl).scanCode, KEYEVENTF_KEYUP, 0
        End If
        
        If bAltKey Then
            keybd_event VirtualKeys(vbKeyMenu).VKCode, _
                VirtualKeys(vbKeyMenu).scanCode, KEYEVENTF_KEYUP, 0
        End If
        
    Loop ' sKeyStrokes
End Sub


Dans une nouvelle forme, vous insérez:
- une textbox nommée "TextToSend"
- un bouton nommé "GO9X"
- un bouton nommé "GO2000"

et vous y insérez le code suivant:
Private Function LaunchTheClass(Choice As Integer)

  'ouverture d'1 fenetre DOS
    Dim toto
    If Choice = 1 Then
        toto = Shell("command.com", vbNormalFocus)
    ElseIf Choice = 0 Then
        toto = Shell("cmd.exe /C dir c:", vbNormalFocus)
    End If

  'envoi du texte vers la fenetre DOS
    Set DOSClass = New DOSSendKeys
    DOSClass.VbSendKeys (TextToSend.Text)

End Function

'' mis en place pour lancer la bonne commande avec le shell
Private Sub GO2000_Click()
    LaunchTheClass (0)
End Sub

Private Sub GO9X_Click()
    LaunchTheClass (1)
End Sub

Private Sub Form_Load()
  'on efface ce k'il y a dans le textbox
    Text1.Text = ""
End Sub


voili voilou, g testé ce code sur ME, ca fonctionne au poil...

en espérant ke ca puisse servir à kelk'un...

je n'ai pas posté ce code en tant ke source car apparement, le site ne supporte pas mon naviguateur web (béonex)...

++

Merci kouby2k3 3

Avec quelques mots c'est encore mieux Ajouter un commentaire

Codes Sources a aidé 93 internautes ce mois-ci

cboulas 2641 Messages postés mercredi 2 juin 2004Date d'inscription 8 janvier 2014 Dernière intervention - 25 nov. 2004 à 21:43
0
Merci
Salut, bien je viens d'essayez ceci et je peux envoyé des argument avec le shell :

Shell "notepad.Exe c:\résultat.txt"


Chris...
Web : Firstruner - eMail : [mailto:support@firstruner.com Support]
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 25 nov. 2004 à 21:55
0
Merci
en fait, je réexplike...

je sais lancer une application DOS... mais dans le traitement de cette application, elle me demande des infos, ke je ne peux pas passer en arguments au lancement de celle-ci... je voudrais savoir si c possible d'envoyer des chaines de caractères dans le shell DOS lorsk'il me demande des renseignements lors de son traitement... et essayer de rendre tt ca compatible avec le lien de la source ke g balancé dans mon premier message...

exemple:

- je lance: prog.exe

- il commence son traitement, et d'un coup, il se pause et

- il me demande: entrer une phrase... (c ca ke je veux faire)

- ensuite encore un peu de traitement... et

- il demande a nouveau une nouvelle phrase...

- ensuite c'est la fin du traitement, et l'affichage du résultat sur la fenetre DOS...

d'ou l'interet d'utiliser la source de fredlynx pour récupérer mes infos a la fin de l'execution... un grand merci a ce Monsieur... :p

voili voilou, j'espère avoir été + clair... :)
cboulas 2641 Messages postés mercredi 2 juin 2004Date d'inscription 8 janvier 2014 Dernière intervention - 25 nov. 2004 à 22:09
0
Merci
Bon j'ai ceci, ça me pose un petit soucis chez moi (ouvre plusieurs fois cmd.exe)

toto = Shell("cmd.exe", vbNormalFocus)
    SendKeys "edit"
    SendKeys "{ENTER}"


Chris...
Web : Firstruner - eMail : [mailto:support@firstruner.com Support]
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 25 nov. 2004 à 22:32
0
Merci
je v tester... et je v ossi essayer de bidouiller la source de fredlynx, meme si c super compliké... mais bon fo bien comprendre...

je te tiens au courant,

si kelk'1 voit une otre solution pouvant etre adapté a la source de fredlinx, je suis preneur...

merci bocoups pour la participation de tt le monde, c vraiment cool, il assure ce forum...

++
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 25 nov. 2004 à 23:01
0
Merci
 'Création du process = Exécution de la commande
    If CreateProcessA(0&, mCommand, Sa, Sa, 1&, NORMAL_PRIORITY_CLASS, 0&, 0&, Start, ProcI) <> 1 Then
        'Si une erreur, fermeture des Handles
        Result = CloseHandle(HLecturePipe)
        Result = CloseHandle(HEcriturePipe)
        MsgBox "Fichier ou commande non trouvé.", vbCritical
        Exit Function
    End If


donc:

lpApplicationName = 0&
lpCommandLine = mCommand
lpProcessAttributes = Sa
lpThreadAttributes = Sa
bInheritHandles = 1&
dwCreationFlags = NORMAL_PRIORITY_CLASS
lpEnvironment = 0&
lpCurrentDirectory = 0&
lpStartupInfo = Start
lpProcessInformation = ProcI

le but serait alors d'envoyer plusieurs mCommand tt en gardant le pipe ouvert??? j'avous etre un peu perdu, c plus du tout de mon nivo... :p

@ bientot... :)
cboulas 2641 Messages postés mercredi 2 juin 2004Date d'inscription 8 janvier 2014 Dernière intervention - 25 nov. 2004 à 23:30
0
Merci
Je suis en train d'essayé 2, 3 truc sur cette source mais c'est CHAUD !!!

Chris...
Web : Firstruner - eMail : [mailto:support@firstruner.com Support]
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 25 nov. 2004 à 23:39
0
Merci
merci bocoups... ;)

moi de mon coté, j'essaye de me renseigner... g essayé la fonction SendKeys ke tu me donnes + haut... apprement avec w98, ca ne fonctionne pas... mais de tte facon, je voudrais ke ca soit compatible 98/nt...

merci encore... :)
kouby2k3 13 Messages postés samedi 8 novembre 2003Date d'inscription 28 novembre 2004 Dernière intervention - 27 nov. 2004 à 13:41
0
Merci
j'avous etre sacrement perdu...

j'essaye de me servir de SendKeyx, mais apparement, il y a un pb au nivo de l'application sur lakelle on envoit le SendKeys... ca peut planter et ne pas envoyer les touches vers le bon prog...

je suis bon là???

TIA.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.