Récapitulatif caractéristiques systemes

voici ce que j'ai pu collecter sur diverses informations des caractéristiques systèmes :

Code:

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));
}
//---------------------------------------------------------------------------

au cas ou ca pourrait intéresser du monde ...

On n'est pas en C, donc on évite les void pour les fonctions qui ne prennent pas d'arguments.

Et généralement on place les #include tout en haut du fichier, et pas au coup par coup comme ça...

ET ça change rien, mais pourquoi mettre tes return entre parenthèses?

Citation:

Envoyé par zoubidaman

On n'est pas en C, donc on évite les void pour les fonctions qui ne prennent pas d'arguments.

ah bon ?? pourquoi cela

Citation:

Envoyé par zoubidaman

Et généralement on place les #include tout en haut du fichier, et pas au coup par coup comme ça...

ah bon ... et pourquoi cela ??

quant aux parenthèses ... je sais pas ... j'ai pris cette habitude ... c'est pas bien non plus ??[/quote]

Citation:

Envoyé par Freeze

Citation:

Envoyé par zoubidaman

On n'est pas en C, donc on évite les void pour les fonctions qui ne prennent pas d'arguments.

ah bon ?? pourquoi cela

Ben question de norme...

Citation:

Envoyé par Freeze

Citation:

Envoyé par zoubidaman

Et généralement on place les #include tout en haut du fichier, et pas au coup par coup comme ça...

ah bon ... et pourquoi cela ??

C'est plus clair... T'as qu'à regarder dans Borland, il les met tous en haut des fichiers ;)

Citation:

Envoyé par Freeze

quant aux parenthèses ... je sais pas ... j'ai pris cette habitude ... c'est pas bien non plus ??

Ca ne change rien du tout... Là c'est juste une question d'habitude de codage :)

merci de tes conseils ... tu dois avoir raison mais je ne connais pas cette norme et côté lisibilité je trouve ca plus clair d'avoir les bibliotheques correspondant à une fonction au dessus de cette fonction ... question d'habitude ...

Ben pis l'inconvénient de mettre les #include au fur et à mesure, c'est que si tu modifies une fonction au dessus d'un #include, et qu'après modif cette fonction requiert cet #include, si tu fais pas attention tu peux le mettre deux fois, et/ou galérer parce que ça marche plus et que pourtant t'as ton #include, mais en dessous...

T'es un peu chiant zoubidaman. OK pour les #include en haut de fichier, mais le reste c'est lourd.

Merci Freeze pour les fonctions. Tu peux peut être les envoyer aux trucs et astuces.

Citation:

Envoyé par slylafone

T'es un peu chiant zoubidaman. OK pour les #include en haut de fichier, mais le reste c'est lourd.

C'est juste des conseils, il en fait ce qu'il veut, mais autant coder proprement dès le départ, même sur des détails "insignifiants"...

Et si t'es pas interessé, t'es pas obligé de les suivre !!!

Franchement,

mettre un void ou pas...moi je trouve que c'est plus parlant avec le void.
Et les parenthèses....(fail).

Je n'appel pas ça coder proprement, pour moi ce genre de détails ne font pas la propreté d'un code ( à part les include en haut du fichier, là je suis d'accord avec toi), c'est une question de style...chaque programmeur à son style !

Citation:

Envoyé par Neilos

Franchement,

mettre un void ou pas...moi je trouve que c'est plus parlant avec le void.
Et les parenthèses....(fail).

Je n'appel pas ça coder proprement, pour moi ce genre de détails ne font pas la propreté d'un code ( à part les include en haut du fichier, là je suis d'accord avec toi), c'est une question de style...chaque programmeur à son style !

C'est parce que je vois d'autres programmeurs beaucoup plus confirmés que moi, certains étant même membres de la comission de codification du C++, faire les même remarques sur d'autres forums ou newsgroups, que je me dis qu'il est bon d'en faire profiter tout le monde ;)

Sinon c'est vrai qu'après tout chacun fait comme il veut, tant que ça compile! :D