Discussion :

[rico32fr]

Bonjour,

je souhaiterais savoir comment remplire les champs d'une autre application dont je connais le nom.
Probleme: je ne connais pas le nom des differents champs
Existe t il un moyen de recuperer le nom des combobox d'une autre application ?

En gros, au travail, on utilise une petite appli qui lorsqu'on clique sur un bouton rempli certains champs d'un logiciel de prise d 'appel.
Cet appli utilise la resolution et la position des differents champs mais c'est plutot mal foutu car si on bouge la souris apres le clic sur le bouton les données recuperées dans la base de donnée sont ajoutées n'importe ou dans le logiciel de saisie ou bien un mail s'ouvre par exemple (et oui !) bref c'est la catastrophe.
Donc je voudrais developper la meme appli mais en accedant directement aux champs du logiciel de saisie et les remplire.

Merci d'avance pour vos reponses

[Djob]

Il est possible de faire ceci, si ton logiciel utilise des fenetres et des composants window (Edit, ComboBox) standards..

en utilisant les API window...mais il existe quelques obstacles...notamment comment identifier un control( il a parfois des ID, parfois pas, des fois un titre ou un texte,parfois rien...)


Ayant déjà utilisé cette technique mais seulement sur des fenêtres genre MessageBox..pour agir seulement sur le texte
ou simuler un click ou un sendkey...

... j'ai décidé de creuser un peu le sujet...pour les EditBox et les Combobox


MINI TUTO :
Passage de données dans les Controls d'une application externe (Edit et ComboBox).

Les étapes nécessaires:

L'étape préliminaire :
-> A. Programmer (ou trouver) un outil d'analyse de fenetre qui soit à même de te donner tous renseignements nécessaires sur les controls d'une fenêtre.

->B. Disposer d'un Executable de test (juste une fiche avec des Edit et des ComboBox) auquel on fera subir les actions de notre outil d'analyse et ,les actions sur les control.

Le but à atteindre :
->B. le 1er but est de déduire une methode pour retrouver efficacement le Handle du Control en question..ainsi que le Handle de la fenetre qui le contient.

->C. le 2eme but est de pouvoir envoyer du text ou des instructions au control dont on a recuperé le Handle... ( voir le msdn )

Je vais simplement me limiter aux exemples des EditBox (TEdit et autre)
( il sera facile prolonger ces actions pour les checkbox en modifiant la nature du message).


A. Création de L'outil d'analyse :

Il faut un outil qui nous permette de pointer avec la souris sur le control à analyser, et puis , sous l'action d'une touche clavier, de reporter ces informations dans une ListBox:

je t'en propose 1 ( inspiré de WindowsSpy ,1 programme delphi ) mais qui utilise un hook clavier...et donne des informations dont on aura besoin par la suite.

1. Une fiche munie de:

- 1 ListBox en haut
- 1 Bouton Clear
- 1 SpeedButton "Enfonçable" avec les propriétés GroupIndex=1, AllowUp=true,Caption="Activé"
- 1 ActionList avec 3 actions : ActiveHook,DeActiveHook,GetWindowInfo

puis : pour tester la partie 2 ( action sur les controls )
-6 TEdit :
EDT_WINDOWTITLE (titre de la fenetre parente),
EDT_EXENAME (nom de l'executable )
EDT_CONTROLNAME (titre du Control)
EDT_CLASSE (classe/type du control)
EDT_RANG (rang/numero du control dans sa fenetre parente)
EDT_NEWTEXT (texte à envoyer dans le control)

-1 Bouton: BTN_SENDTEXT



Code de l'outil : 1ère partie : Analyse:

D'abord la gestion du Hook clavier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
//---------------------------------------------------------------------------
// Code source libre 
// par Djob.
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include "psapi.h"        //<- ajouter C:\...CBuilder6\\Lib\Psdk\psapi.lib au projet
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
HHOOK hHook;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
/*---------------------------------------------------------------------------
  PARTIE I . CREATION DE L'OUTIL PERMETTANT LA RECUPERATION DES INFORMATIONS
             CONCERNANT LES CONTROLS PLACES DANS UNE AUTRE APPLICATION
  ---------------------------------------------------------------------------
*/
 
/*   --------------------------------------------------------------------------
     FONCTION DU HOOK CLAVIER :
     ( interception des touches clavier en dehors de l'executable )
     si la barre d'espace est préssé (en mode activé) on récupere les
     informations du control ou de la fenetre placée en dessous
     du curseur de la souris.
     --------------------------------------------------------------------------
*/
 
__declspec(dllexport) LRESULT CALLBACK HookProc ( int nCode, WPARAM wParam, LPARAM lParam)
{
        if ((nCode == HC_ACTION) && (wParam == WM_KEYDOWN))
        {
        KBDLLHOOKSTRUCT hookstruct = *((KBDLLHOOKSTRUCT*)lParam);
        DWORD vkCode = hookstruct.vkCode;
 
          // si on appuie sur la touche espace..
         //  on déclenche la récupération des informations du control 
        //   sous la souris....
 
          if(vkCode==VK_SPACE){   
             Form1->ActGetWindowInfo->Execute();
          }
        }
        return CallNextHookEx(hHook, nCode, wParam, lParam);
}
 
/* ---------------------------------------------------------------------------
     ACTION Activer la Détection Clavier
   ---------------------------------------------------------------------------
*/
void __fastcall TForm1::ActActiveHookExecute(TObject *Sender)
{
        BTN_HOOK->Caption="Désactiver";
        HWND hExe= GetModuleHandle(NULL);//Application->Handle;
        hHook = SetWindowsHookEx( WH_KEYBOARD_LL, (HOOKPROC) HookProc, hExe, NULL);
}
/* ---------------------------------------------------------------------------
     ACTION Désactiver la Détection Clavier
   ---------------------------------------------------------------------------
*/
void __fastcall TForm1::ActDeActiveHookExecute(TObject *Sender)
{
        UnhookWindowsHookEx(hHook);
        BTN_HOOK->Caption="Activer";
}
/* ---------------------------------------------------------------------------
   BTN_HOOK (Activer/Désactiver): speedbutton enfonçable : propriété Groupindex=1, Allowup=true
   ---------------------------------------------------------------------------
*/
void __fastcall TForm1::BTN_HOOKClick(TObject *Sender)
{
        if(BTN_HOOK->Down){
            ActActiveHook->Execute();
        }else{
            ActDeActiveHook->Execute();
        }
}

.... Puis les fonctions de récupération des informations :

une fonction pour récuperer le rang/numéro du control dans sa fenetre
parente ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
/* ---------------------------------------------------------------------------
   FONCTION QUI RETOURNE LE NUMERO (SON RANG) DU CONTROL DANS SA FENETRE OU
   SON CONTROL PARENT.
   ---------------------------------------------------------------------------
*/
int __fastcall GetControlNumber(HWND ParentWindow,HWND ControlToFind){
 
     HWND hCurrentControl=NULL;
     int pos=0;
     do{
       pos++;
       hCurrentControl=FindWindowEx(ParentWindow,hCurrentControl,NULL,NULL);
       if(hCurrentControl== ControlToFind) return pos;
 
     }while(hCurrentControl!=NULL);
     pos=-1;
     return pos;
 
}

... Une fonction pour retrouver le nom de l'executable associé au control pointé par la souris:
Cela va nous permettre d'avoir 2 paramètres pour retrouver une fenetre:
son titre et l'executable qui l'a produite.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
/* ---------------------------------------------------------------------------
   FONCTION QUI RETOURNE LE CHEMIN DE L'EXCUTABLE ASSOCIE AU CONTROL
   ---------------------------------------------------------------------------
*/
String __fastcall GetExePath(HWND AWindow){
 
           DWORD ProcessID;
           GetWindowThreadProcessId(AWindow,&ProcessID);
           char file_path[MAX_PATH];
            HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, ProcessID);
           if(hProcess!=0){
              GetModuleFileNameEx(hProcess,0,file_path,MAX_PATH);
              CloseHandle(hProcess);
              String ExeName(file_path);
              return ExeName;
           }else{
              CloseHandle(hProcess);
              return "";
           }
}

[Edit : ajout] Ajout d'une fonction qui calcule de dégré d'encastrement du control : i.e : un Edit dans un Panel lui même posé sur une fiche :
degré=2;
Ce parametre vous sert à controler de combien vous allez descendre en profondeur pour allez chercher le Handle du control : si le Panel a comme numero d'ordre 3, et l'Edit 2 dans le Panel , il vous faudra trouver le Handle du rang 2, du Handle du Rang 3, du Handle de la fenetre ...etc..

[/Edit]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
/*
   ---------------------------------------------------------------------------
   FONCTION TEST DE PROFONDEUR  / ENCASTREMENT DANS UN AUTRE CONTROL
   // niveau 0 : Fiche, 1 : composants de premier plan
   ---------------------------------------------------------------------------
*/
int __fastcall GetProfondeur(HWND AControl){
        if(AControl==NULL) return -1;
        HWND hCurrControl=AControl;
        int deep = -1;
        do{
             hCurrControl= GetParent(hCurrControl);
           deep++;
        }while( hCurrControl!=NULL);
        return deep;
}

Voici l'action qui est déclenchée quand on tape sur la barre d'espace et que le Hook est activé....
Cette action permet de retrouver le Handle du control placé sous la souris
grace à l'api WindowFromPoint.. et d'en déduire le texte,la classe, le rang, la position de ce control ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
/* ---------------------------------------------------------------------------
   ACTION : RETROUVER LES INFORMATIONS ET LES INCRIRE DANS LA LISTBOX
   ---------------------------------------------------------------------------
*/
void __fastcall TForm1::ActGetWindowInfoExecute(TObject *Sender)
{
        TPoint  Pt;
        HWND  AHandle;  //Handle du Control trouve
        DWORD ProcessID; // ID du Process
        String ListBoxLineInfo;
        int rang; // rang du control dans sa fenetre parent
 
        // on récupere les coordonnées pointées par le curseur
        if (GetCursorPos(&Pt)){
 
           // On Recupere le Handle du Control ou de la fenetre situé en
           // dessous du curseur.
           AHandle = WindowFromPoint(Pt);
 
           //on en déduit son Parent
           HWND hParentWindow = GetParent(AHandle);
 
           //on récupère le titre de la fenetre ou du control
           char WindowCaption[255];
           GetWindowText(AHandle,WindowCaption,255);
           ListBoxLineInfo = "Caption  : "+ String(WindowCaption);
           ListBox1->Items->Add(ListBoxLineInfo);
 
           //on récupère le type  du control (le nom de la classe : TEdit,TComboBox)
 
           char ClassName[255];
           GetClassName(AHandle,ClassName,255);
           ListBoxLineInfo = "Classe : "+ String(ClassName);
           if(hParentWindow!=NULL){
                   rang =  GetControlNumber(hParentWindow,AHandle);
                   if(rang!=-1)
                     ListBoxLineInfo +=" / N°(rang): "+IntToStr(rang);
           }
           ListBox1->Items->Add(ListBoxLineInfo);
 
           //on récupère la profondeur ( encastrement dans d'autre control)
           int profondeur = GetProfondeur(AHandle);
           ListBoxLineInfo = "Profondeur/encastrement : "+ IntToStr(profondeur);
           ListBox1->Items->Add(ListBoxLineInfo);
 
 
           //on récupère l' id du thread
 
           GetWindowThreadProcessId(AHandle,&ProcessID);
           ListBoxLineInfo = "ID du processus : "+IntToStr(ProcessID);
           ListBox1->Items->Add(ListBoxLineInfo);
 
           //on récupère nom de l'executable associé
 
           String ExeName= GetExePath(AHandle);
           ListBoxLineInfo = "Chemin de l'executable : "+ExeName;
           ListBox1->Items->Add(ListBoxLineInfo);
           ListBoxLineInfo = "Nom de l'executable : "+ExtractFileName(ExeName);
 
           //on récupère l' id du control
 
           int ControlId=GetDlgCtrlID(AHandle);
           if(ControlId==0){
               ListBoxLineInfo = "ID Control : non attribué";
           }else{
               ListBoxLineInfo = "ID Control : "+IntToStr(ControlId) ;
           }
 
           ListBox1->Items->Add(ListBoxLineInfo);
 
           //poisition, taille:
 
           TRect RectPos;
           GetWindowRect(AHandle,&RectPos);
           ListBoxLineInfo = "Height = "+IntToStr(RectPos.Height());
           ListBox1->Items->Add(ListBoxLineInfo);
           ListBoxLineInfo = "Width = "+IntToStr(RectPos.Width());
           ListBox1->Items->Add(ListBoxLineInfo);
 
           TPoint  APoint;
           APoint.x=RectPos.Left;
           APoint.y=RectPos.Top;
 
           if(hParentWindow!=NULL){
 
               ::ScreenToClient(hParentWindow,&APoint);
           }
           ListBoxLineInfo = "Top    = "+IntToStr(APoint.x);
           ListBox1->Items->Add(ListBoxLineInfo);
           ListBoxLineInfo = "Left   = "+IntToStr(APoint.y);
           ListBox1->Items->Add(ListBoxLineInfo);
           ListBox1->Items->Add("");
 
           //ça c'est juste pour toujours voir le bas de la listbox
           SendMessage(ListBox1->Handle, WM_VSCROLL, SB_BOTTOM, 0 );
 
 
           /* --------pour la partie 2 uniquement-------------
            je reporte des derniers résultats  dans des Edits
            (parce ce que je suis paresseux et je melange le code
             de test avec le code de l'outil : ( bouh c po bien !)
            //////////////////////////////////////////////////
           ---------------------------------------------------
           */
           EDT_CONTROLNAME->Text = String(WindowCaption);
           //titre de la fenetre parente
           if(hParentWindow!=NULL){
                GetWindowText(hParentWindow,WindowCaption,255);
                EDT_WINDOWTITLE->Text = String(WindowCaption);
           }
           EDT_CLASSE->Text = String(String(ClassName));
           EDT_EXENAME->Text= ExtractFileName(ExeName);
           EDT_RANG->Text = IntToStr( rang);
           //------------------------------------------------
 
         }
}
//---------------------------------------------------------------------------
// JUSTE UN BOUTON POUR EFFACER LA LISTBOX
void __fastcall TForm1::BTN_CLEARClick(TObject *Sender)
{
        ListBox1->Clear();
}
//---------------------------------------------------------------------------

Utilisation : Activer ,pointer le control voulu et appuyer sur la barre d'espace:
NB: ATTENTION! On Suppose ici que les Controls sont directements
posés sur la Fenetre.
Si le control est enfermé dans un Panel ou Autre
il faudra chercher d'abors de Handle du Panel et rechercher
ensuite les control ayant comme parent le Handle du Panel..


NB(2): !!!ATTENTION au Handle du Control pointé par l'outil pour les combobox
Si la ComboBox est de type csDropDownList (non editable) : pas de problème
Par Contre si elle est ded type csDropDown (éditable) :
il faut pointer la souris sur le bouton avec la fleche pour obtenir
le Handle de la Combobox..
L'autre zone désigne une Edit qui appartient à la Combobox,
et vous trouverez comme rang : 1 ...car son parent est la combobox...

En utilisant l'outil d'analyse on se rend compte que l'on peut acceder à des ID par l'Api GetDlgItemId (ou par GetwindowLong voir GWL_ID) : cela ne nous servira à rien car pour les programme sous delphi et bcb cet ID change à chaque lancement de l'application.En ce qui concerne les programme faits sous VC++ avec MFC, il n'y a pas d'ID pour les fiches CWnd....

Il nous reste donc plus que le numero/rang du control dans la fiche :
En donnant ce rang comme parametre on pourra retrouver le handle du control ...et à partir de là , le modifier ...

B. Exploitation de ces données dans ton application :
manipulation des controls de l'application externe

Il nous faut :
- Trouver la fenetre qui contient les controls
- Trouver le control grâce à son rang
- Lui envoyer les donnée grâce à l'api SendMessage :

Suite du Code :
(ici j'ai mis le code de test à la suite du code de l'analyseur par pure paresse ,mais c'est seulement
à partir d'ici l'implantation dans le code de votre appli )

D'abord on code une fonction pour retrouver un control par rapport à son rang, connaissant le Handle de sa fenetre parente..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
   ---------------------------------------------------------------------------
    PARTIE II . MANIPULATION DES CONTROLS D'UNE AUTRE APPLICATION
   ---------------------------------------------------------------------------
*/
 
/* --------------------------------------------------------------------------
 FONCTION POUR TROUVER LE COMPOSANT N° X DONNE SUR UNE FENETRE DONNEE
  (recupération du handle du control grâce à son rang ( numero ))
   --------------------------------------------------------------------------
*/
 
HWND __fastcall GetControlByNumber(HWND ParentWindow,int number)
{
     HWND hCurrentControl=NULL;
     for (int i=1;i<=number;i++){
       hCurrentControl=FindWindowEx(ParentWindow,hCurrentControl,NULL,NULL);
     }
     return hCurrentControl;
}

L'api FindWindowEx permet de rechercher le control suivant par rapport
à un control passé en parametre et retourne le control trouve.
on peut ainsi trouver tous les control de premier plan..
NB: Pour les controls mis dans des groupbox ...le parent doit etre le groupbox .



avant de trouver un composant , bien spur il nous faudra trouver la fenêtre qui le contient....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
 
 
/*  -------------------------------------------------------------------------
    FONCTION POUR TROUVER LA FENETRE PRINCIPALE
    NB : Cas ou ça ne marche pas :
    un executable qui a généré 2 fenetres avec le même titre ou sans titre
    pour ce cas il faudra trouver un autre moyen d'affiner la recherche
    (nombre de controls,etc..)
    ---------------------------------------------------------------------------
*/
HWND __fastcall FindWindowWithTitleAndExeName(String Title,String ExeName)
{
 
     bool trouve=false;
     HWND hCurrentWindow=NULL;
     do{
          hCurrentWindow= FindWindowEx(NULL,hCurrentWindow,NULL,NULL);
          char WindowCaption[255];
          GetWindowText(hCurrentWindow,WindowCaption,255);
          //fenetre avec titre correspondant trouvée
          if( String(WindowCaption)== Title){
 
               //on verifie que c'est une fenetre de l'excutable qu'on cherche
               if(ExeName.LowerCase()== ExtractFileName(GetExePath(hCurrentWindow)).LowerCase())
               {
                  trouve=true;
               }
          }
 
     }while(hCurrentWindow!=NULL && !trouve);
     return  hCurrentWindow;
}

NB: Prendre un café... Si vous êtes arrivé jusque là c'est que vous êtes vraiment motivé...

...Donc enfin le test....
Après la compilation, lancer l'appli de test ( fiche avec des edit et des combobox décrite au début, pointer sur un composant et taper la barre d'espace (pas trop fort.. ))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
//---------------------------------------------------------------------------
// Click sur le bouton Envoyer
 
void __fastcall TForm1::BTN_SENDTEXTClick(TObject *Sender)
{
     //Saisie des nom de fenetres, du nom de l'excutable,
     // et du nouveau texte à chercher
 
     String NouveauTexte =  EDT_NEWTEXT->Text;
     if(NouveauTexte=="") return;
     String TitreFenetre = EDT_WINDOWTITLE->Text;
     String ExeName = EDT_EXENAME->Text;
     if(ExeName=="") return;
     int rang = StrToInt(EDT_RANG->Text);
 
 
     //on cherche la fenetre portant le titre ... et associé à l'executable ....
     HWND ParentWindow =  FindWindowWithTitleAndExeName(TitreFenetre,ExeName);
     if(ParentWindow==NULL) return;
 
     /*
        On cherche le Handle du Control par rapport à son rang
        (son numero donné précedemment dans la listbox).
 
        NB: ATTENTION!  On Suppose ici que les Controls sont directements
                        posés sur la Fenetre.
                        Si le control est enfermé dans un Panel ou Autre
                        il faudra chercher d'abord le Handle du Panel et rechercher
                        ensuite les control ayant comme parent le Handle du Panel..
     */
 
     HWND hControlCible = GetControlByNumber( ParentWindow,rang);
 
     //activation / mise en avant dela fenetre du programme externe
     SetForegroundWindow(ParentWindow);
 
     //On Donne le focus au control :
     //pour cela il faut attacher les thread des 2 applications pour pouvoir
     //utiliser les fonctions setFocus depuis l' application externe
     // (astuce trouvé sur developpez.com)
 
     DWORD ProcessID,ExtProcessID;
     DWORD CurrentThreadID = GetWindowThreadProcessId(Application->Handle,&ProcessID);
     DWORD ExterneThreadID = GetWindowThreadProcessId(ParentWindow,&ExtProcessID);
     AttachThreadInput(CurrentThreadID,ExterneThreadID,true);
     HWND hRes =NULL;
     hRes= ::SetFocus(hControlCible);
 
     //détacher les thread
     AttachThreadInput(CurrentThreadID,ExterneThreadID,false);
 
 
 
     /*////////////////////////////////////////////////////////////////////////
 
     EXEMPLES D' ACTIONS SUR LES CONTROLS
       2 exemples :
                   - un avec un control de type Edit,TEdit ou Autre
                   - un avec une combobox:
 
      NB: !!!ATTENTION au Handle du Control pointé par l'outil pour les combobox
      Si la ComboBox est de type csDropDownList (non editable)  : pas de problème
      Par Contre si elle est ded type csDropDown (éditable) :
      il faut pointer la souris sur le bouton avec la fleche pour obtenir
      le Handle de la Combobox..
      L'autre zone désigne une Edit qui appartient à la Combobox,
      et vous trouverez comme rang : 1 ...car son parent est la combobox...
      -------------------------------------------------------------------------
     */
 
     //type du control
     char class_name[255];
     GetClassName(hControlCible,class_name,255);
     String ClassName =String(class_name).LowerCase();
 
     //exemple avec un edit:
      if ((ClassName== "tedit") ||(ClassName== "edit") )  //ou autre nom de classe désignant l'edit
      {
                //remplacement du texte
                SendMessage(hControlCible,WM_SETTEXT,0,(LPARAM)NouveauTexte.c_str());
      }
 
      //pour les combobox ayant le style cdDropDownList ( à contenu non editable )
      if( (ClassName=="tcombobox") || ClassName=="combobox") //ou autre...
      {
               // pour selectionner un texte donné
               char * ItemText =  TrimLeft(TrimRight(NouveauTexte)).c_str();
               LRESULT lresult = SendMessage(hControlCible,CB_FINDSTRINGEXACT,-1,(LPARAM)ItemText);
               if(lresult!=CB_ERR){
                 SendMessage(hControlCible,CB_SELECTSTRING,-1,(LPARAM)ItemText);
               }else{
                 ShowMessage("nom d'item non trouvé");
               }
      }
 
 
}

NB: Lors du test d'envoi avec cette appli, lorsqu'on entre un texte à envoyer, s'il contient des espaces ,ne pas oublier pas de désactiver le Hook Clavier...

NB(2): Il est possible de gérer les rangs différemment : au lieu d'un rang
unique commun pour tous les controls , un rang pour un type de control..(ce qui se traduirait par la 2ème EditBox,au lieu du 5ème Control)

NB(3) : Pour certains type de controles l'envoi de message n'a aucun effet mais il est possible de les controler via un systeme de "SendKey" (voir l'api keybd_event )...


Voilà c'est à étudier ...
Bien sûr , chaque cas est particulier, et il y a des adaptations et des ajustements à faire...
Evidemment cette technique ne peut pas fonctionner tout le temps, il faut aussi de la chance ( imaginons qu'un programmeur se soit mis en tete de créer ses controls dynamiquement et dans un ordre aléatoire ...)


Bon Courage.8)
Djob.

[rico32fr]

Ok merci beaucoup, j'analyse un peu la chose (il y a du boulot)

[aityahia]

salut je vient d'essayer votre code et j'ai une erreur le méssage est
unresloved external 'GetModuleFileNameExA' refernecd from 'le chemin de mon unité'

[Dure_Limite]

unresloved external 'GetModuleFileNameExA' refernecd from 'le chemin de mon unité'

Ce message monte lorsque l'on n'a pas ajouté le fichier psapi.lib au projet.

Pour l'ajouter au projet tu doit faire :

Projet | Ajouter au projet |

et tu sélectionne le fichier psapi.lib qui se trouve dans le dossier
"\Lib\Psdk\"

[aityahia]

sa marche tres bien, avant j'avai ajouter la librerie uniquement dans l'entete,

merci.

[Furlaz]

J'ai testé le programme donnée mais je n'arrive pas à le faire fonctionner.

J'ai fait comme indiqué. J'ai Activer puis pointé ma souris sur un élément d'un autre exécutable (Tedit ou TComboBox) et j'ai lancer le test avec la barre d'espace mais je n'obtiens rien, le programme ne réagit pas, il ne se passe rien.

Quelque'un à-t'il une idée ?