FAQ C++ BuilderConsultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
AnsiString __fastcall TForm1::GetACtiveWindowCaption() 
{ 
   HWND hwnd; 
   // On récupère le handle de la fenêtre située au premier plan 
   hwnd = GetForegroundWindow(); 
   // on alloue un buffer de caractères destiné à recevoie le texte 
   char * caption = new char[255]; 
   // on récupère le texte dans ce buffer, en laissant la place pour le zéro terminal 
   int length = GetWindowText(hwnd,caption,254); 
   // on place le zéro terminal 
   caption[length] = '\0'; 
   // on retourne le contenu sous la forme d'une AnsiString 
   return AnsiString(caption); 
}

SendMessage(ProgressBar1->Handle,PBM_SETBARCOLOR,0,clLime);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
bool __fastcall SetPrivilege(AnsiString name, bool grant) 
{ 
   TOKEN_PRIVILEGES wTokenIn, wTokenOut; 
   DWORD wLength; 
   HANDLE wCurrentProcess, wToken; 
   _LUID wLuid; 
   bool ret; 
  
   wCurrentProcess = GetCurrentProcess(); 
   OpenProcessToken(wCurrentProcess, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &wToken); 
   LookupPrivilegeValue(NULL, name.c_str(), &wLuid); 
   wTokenIn.PrivilegeCount = 1; 
   wTokenIn.Privileges[0].Luid = wLuid; 
   wTokenIn.Privileges[0].Attributes = (grant?SE_PRIVILEGE_ENABLED:0); 
   ret = AdjustTokenPrivileges(wToken, FALSE, &wTokenIn, sizeof(TOKEN_PRIVILEGES), &wTokenOut,&wLength)) 
   CloseHandle(wToken); 
  
   return ret; 
}

1
2
3
SetPrivilege("SeShutdownPrivilege",true); 
// actions 
SetPrivilege("SeShutdownPrivilege",false);

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
#include <windows.h> 
#include <stdio.h> 
#include <conio.h> 
int main(int argc, char * argv[]) 
{ 
   HWND hFore; 
   char* pszBuffer; 
   int iNbChar = 1; 
   int iNbCharReturned; 
  
   printf("Vous avez 5 secondes pour activer la fenetre dont vous voulez connaitre le class name\r\n"); 
   printf("Appuyez sur une touche pour declancher le compteur ..."); 
   getch(); 
   Sleep(5000); 
  
   hFore = GetForegroundWindow(); 
  
   do 
   { 
      iNbChar = iNbChar * 2; 
      pszBuffer = new char[iNbChar]; 
      iNbCharReturned = GetClassName(hFore,pszBuffer,iNbChar); 
      if (iNbCharReturned == 0) 
      { 
         printf("Impossible de recuperer le class name\r\n"); 
      } 
      if (iNbCharReturned < (iNbChar - 1)) 
      { 
         printf("\r\nLe class name de cette fenetre est :\r\n|%s|",pszBuffer); 
         printf("\r\nLes barres verticales (|) de gauche et droite n'en font pas partie\r\n\a"); 
      } 
      delete[] pszBuffer; 
   } 
   while ((iNbCharReturned >= (iNbChar - 1))); 
  
   printf("Appuyez sur une touche pour fermer la fenetre..."); 
   getch(); 
  
   return 0; 
}

1
2
3
4
HWND h = FindWindow("SciCalc", NULL); 
SetForegroundWindow(h); 
PostMessage(h, WM_KEYDOWN, 'R', 0); 
PostMessage(h, WM_KEYUP, 'R', 0);

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
void __fastcall TForm1::Button1Click(TObject *Sender) 
{ 
   Memo1->Clear(); 
  
   String PathNomExt = Application->ExeName; 
   DWORD Size = GetFileVersionInfoSize(PathNomExt.c_str(), &Size); 
   if (Size <= 0) { 
      Memo1->Lines->Add( "Pas d'information de version dans cette application." ); 
      return; 
   } 
  
   BYTE *Buffer; 
   try{ 
      Buffer = new unsigned char[Size]; 
      LPVOID   Str; 
      UINT     Len; 
      String   TypeInfo; 
      LPDWORD lpdwLangCp; 
      char szFileInfo[26]; 
  
      GetFileVersionInfo(PathNomExt.c_str(), 0, Size, Buffer); 
  
      // Lecture de la table des langues et jeux de caractères 
      if (!VerQueryValue(Buffer, "\\VarFileInfo\\Translation",  (LPVOID *)&lpdwLangCp, &Len)) return; // erreur 
      wsprintf(szFileInfo, "\\StringFileInfo\\%04x%04x\\", LOWORD(*lpdwLangCp), HIWORD(*lpdwLangCp)); 
  
      // Nom de l'organisation 
      TypeInfo = szFileInfo + (AnsiString) "CompanyName"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Nom de l'organisation :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Nom de l'organisation :\tErreur de lecture" ); 
  
      // Description 
      TypeInfo = szFileInfo + (AnsiString) "FileDescription"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Description :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Description :\tErreur de lecture" ); 
  
      // Version de fichier 
      TypeInfo = szFileInfo + (AnsiString) "FileVersion"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Version de fichier :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Version de fichier :\tErreur de lecture" ); 
  
      // Nom interne 
      TypeInfo = szFileInfo + (AnsiString) "InternalName"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Nom interne :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Nom interne :\tErreur de lecture" ); 
  
      // Copyright 
      TypeInfo = szFileInfo + (AnsiString) "LegalCopyRight"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Copyright :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Copyright :\tErreur de lecture" ); 
  
      // Marques légales 
      TypeInfo = szFileInfo + (AnsiString) "LegalTrademarks"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Marques légales :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Marques légales :\tErreur de lecture" ); 
  
      // Nom d'origine du fichier 
      TypeInfo = szFileInfo + (AnsiString) "OriginalFileName"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Nom d'origine du fichier :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Nom d'origine du fichier :\tErreur de lecture" ); 
  
      // Nom du produit 
      TypeInfo = szFileInfo + (AnsiString) "ProductName"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Nom du produit :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Nom du produit :\tErreur de lecture" ); 
  
      // Version du produit 
      TypeInfo = szFileInfo + (AnsiString) "ProductVersion"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Version du produit :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Version du produit :\tErreur de lecture" ); 
  
      // Commentaire 
      TypeInfo = szFileInfo + (AnsiString) "Comments"; 
      if (VerQueryValue(Buffer, TypeInfo.c_str(), &Str, &Len)) 
            Memo1->Lines->Add( "Commentaire :\t" + (AnsiString) reinterpret_cast<char *>(Str) ); 
      else  Memo1->Lines->Add( "Commentaire :\tErreur de lecture" ); 
  
   } 
   __finally{ 
      delete Buffer; 
      Memo1->Lines->Add( "\t----------------------------" ); 
   } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* creation des variables */ 
HWND hWnd; 
DWORD processId; 
HANDLE hProcess; 
/*CODE*/ 
do 
{ 
    hWnd = FindWindow(NULL,"Calculatrice"); 
    if (hWnd) 
    { 
        GetWindowThreadProcessId(hWnd,&processId); 
        hProcess = OpenProcess(PROCESS_TERMINATE,false,processId); 
        if (hProcess) 
        { 
            TerminateProcess(hProcess,0); 
            CloseHandle(hProcess); 
        } 
    } 
} 
while(hWnd); 
}