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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
|
AnsiString GetWinOSType(void)
{
AnsiString wintype="Windows Inconnu";
if (Win32Platform == VER_PLATFORM_WIN32_WINDOWS)
{
wintype="Windows 95";
if (Win32MajorVersion == 4)
{
if (Win32MinorVersion >= 90)
wintype="Windows 98 ME";
else
if (Win32MinorVersion >= 10)
wintype="Windows 98";
}
}
if (Win32Platform == VER_PLATFORM_WIN32_NT)
{
wintype="Windows NT";
if (Win32MajorVersion == 5)
{
if (Win32MinorVersion >= 1)
wintype="Windows XP";
else
wintype="Windows 2000";
}
}
return(wintype);
}
//---------------------------------------------------------------------------
int GetMemoryRam(void)
{
int ram;
MEMORYSTATUS X;
X.dwLength = sizeof(X);
GlobalMemoryStatus(&X);
ram = (X.dwTotalPhys+524288)/1024/1024;
return(ram);
}
//---------------------------------------------------------------------------
AnsiString TypeProcesseur(void)
{
return(StrUpper(getenv("PROCESSOR_IDENTIFIER")));
}
//---------------------------------------------------------------------------
int NombreProcesseurs(void)
{
AnsiString nombre=StrUpper(getenv("NUMBER_OF_PROCESSORS"));
return(nombre.ToIntDef(0));
}
//---------------------------------------------------------------------------
#include "stdio.h"
//---------------------------------------------------------------------------
AnsiString NumSerieDisque(void)
{
AnsiString numserie;
char Buffer[12],serial[15];
DWORD VolumeSerialNumber;
DWORD MaximumComponentLength;
DWORD FileSystemFlags;
char FileSystemNameBuffer[5];
DWORD FileSystemNameSize;
GetVolumeInformation("C:\\",
Buffer,
sizeof(Buffer),
&VolumeSerialNumber,
&MaximumComponentLength,
&FileSystemFlags,
FileSystemNameBuffer,
sizeof(FileSystemNameBuffer));
sprintf(serial,"%X-%X",HIWORD(VolumeSerialNumber),LOWORD(VolumeSerialNumber));
numserie=serial;
return(numserie);
}
//---------------------------------------------------------------------------
AnsiString TailleDisque(void)
{
AnsiString ret;
float Total=DiskSize(0);
ret.sprintf("%.f",Total/1024/1024/1024);
return(ret);
}
//---------------------------------------------------------------------------
AnsiString TailleDisqueDisponible(void)
{
AnsiString ret;
float Total=DiskFree(0);
ret.sprintf("%.f",Total/1024/1024/1024);
return(ret);
}
//---------------------------------------------------------------------------
int NombreBitsParPixel(void)
{
DEVMODE DeviceMode;
DeviceMode.dmSize=sizeof(DEVMODE);
EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&DeviceMode);
return(DeviceMode.dmBitsPerPel);
}
//---------------------------------------------------------------------------
int FrequenceRafraichissement(void)
{
DEVMODE DeviceMode;
DeviceMode.dmSize=sizeof(DEVMODE);
EnumDisplaySettings(NULL,ENUM_CURRENT_SETTINGS,&DeviceMode);
return(DeviceMode.dmDisplayFrequency);
}
//---------------------------------------------------------------------------
int LargeurResolution(void)
{
return (GetSystemMetrics(SM_CXSCREEN));
}
//---------------------------------------------------------------------------
int HauteurResolution(void)
{
return (GetSystemMetrics(SM_CYSCREEN));
}
//---------------------------------------------------------------------------
#include <Math.hpp>
//---------------------------------------------------------------------------
double NombreCouleurs(void)
{
double nbColors;
HDC hDC = GetDC(0);
int result = GetDeviceCaps(hDC,BITSPIXEL);
ReleaseDC(0, hDC);
nbColors = (double)Power(2,result);
nbColors = nbColors/1000000;
return(nbColors);
}
//---------------------------------------------------------------------------
AnsiString CheminWindows(void)
{
return (StrUpper(getenv("WINDIR")));
}
//---------------------------------------------------------------------------
AnsiString CheminSystemeWindows(void)
{
AnsiString repertoire;
char RepertoireSystem_str[256];
GetSystemDirectory(RepertoireSystem_str, sizeof(RepertoireSystem_str));
repertoire=RepertoireSystem_str;
return(repertoire);
}
//---------------------------------------------------------------------------
AnsiString NomUtilisateurCourant(void)
{
return(StrUpper(getenv("USERNAME")));
}
//---------------------------------------------------------------------------
AnsiString AdresseIP(void)
{
AnsiString ret="";
WORD wVersionRequested;
WSADATA wsaData;
char name[255];
AnsiString ip;
PHOSTENT hostinfo;
wVersionRequested = MAKEWORD( 2, 0 );
if (WSAStartup(wVersionRequested,&wsaData)==0)
{
if(gethostname(name, sizeof(name)) == 0)
if((hostinfo = gethostbyname(name)) != NULL)
ret=inet_ntoa (*(in_addr *)*hostinfo->h_addr_list);
WSACleanup( );
}
return(ret);
}
//---------------------------------------------------------------------------
AnsiString NomPC(void)
{
return(StrUpper(getenv("COMPUTERNAME")));
}
//---------------------------------------------------------------------------
AnsiString NomBaseOS(void)
{
return(StrUpper(getenv("OS")));
}
//---------------------------------------------------------------------------
#include <Forms.hpp>
//---------------------------------------------------------------------------
int NombrePolice(void)
{
return(Screen->Fonts->Count);
}
//---------------------------------------------------------------------------
void ListeLecteur(TStrings *liste)
{
AnsiString lettre=" ";
liste->Clear();
for (int i=65;i<91;i++)
{
lettre[1]=i;
liste->Add(lettre+" : "+TypeDisque(lettre));
}
}
//---------------------------------------------------------------------------
AnsiString TypeDisque(AnsiString lettre)
{
AnsiString typedisque="";
int i=GetDriveType((lettre+":\\").c_str());
switch(i)
{
case 0 : typedisque="Type inconnu"; break;
case 1 : typedisque="Inexistant"; break;
case 2 : typedisque="Lecteur externe"; break;
case 3 : typedisque="Disque dur"; break;
case 4 : typedisque="Lecteur déporté"; break;
case 5 : typedisque="Lecteur CD-Rom"; break;
case 6 : typedisque="Disque RAM"; break;
}
return(typedisque);
}
//---------------------------------------------------------------------------
#include "Registry.hpp"
//---------------------------------------------------------------------------
void ListeLogiciel(TStrings *listeprog,AnsiString Station, AnsiString RegKey,AnsiString RegValue,int Multi)
{
AnsiString temp;
listeprog->Clear();
if (Station!=NULL)
{
TRegistry* reg=new TRegistry;
reg->RootKey=HKEY_LOCAL_MACHINE;
if (reg->RegistryConnect(Station))
{
if (reg->OpenKey(RegKey, false))
{
if (Multi!=0)
{
TStringList* listeprogtemp=new TStringList();
reg->GetKeyNames(listeprogtemp);
for (int i=0;i<listeprogtemp->Count;i++)
{
reg->CloseKey();
temp=RegKey+listeprogtemp->Strings[i];
temp+="\\";
reg->RootKey = HKEY_LOCAL_MACHINE;
reg->RegistryConnect(Station);
reg->OpenKey(temp, false);
if (reg->ValueExists(RegValue))
listeprog->Add(reg->ReadString(RegValue));
}
delete listeprogtemp;
}
else
{
if (reg->ValueExists(RegValue))
{
if (reg->GetDataType(RegValue)==3)
listeprog->Add(reg->ReadInteger(RegValue));
else
listeprog->Add(reg->ReadString(RegValue));
}
else
listeprog->Add("N/A");
}
reg->CloseKey();
}
}
delete reg;
}
}
//---------------------------------------------------------------------------
double GetCPUSpeed(void)
{
int tempsdelai=100;
DWORD classepriorite=GetPriorityClass(GetCurrentProcess);
int priorite=GetThreadPriority(GetCurrentThread);
SetPriorityClass(GetCurrentProcess,REALTIME_PRIORITY_CLASS);
SetThreadPriority(GetCurrentThread,THREAD_PRIORITY_TIME_CRITICAL);
DWORD hauttimer,bastimer;
Sleep(10);
asm
{
dw 310Fh
mov bastimer, eax
mov hauttimer, edx
}
Sleep(tempsdelai);
asm
{
dw 310Fh
sub eax, bastimer
sbb edx, hauttimer
mov bastimer, eax
mov hauttimer, edx
}
SetThreadPriority(GetCurrentThread,priorite);
SetPriorityClass(GetCurrentProcess,classepriorite);
return(bastimer/(1000*tempsdelai));
}
//--------------------------------------------------------------------------- |
Récapitulatif caractéristiques systemes
Répondre avec citation
Partager