begin process at 2012 02 11 08:48:17
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

Composants

 > COMPOSANT TDBPPROCESSEUR : DES INFOS SUR LE PROC ET SON UTILISATION !!

COMPOSANT TDBPPROCESSEUR : DES INFOS SUR LE PROC ET SON UTILISATION !!




 Description

Cliquez pour voir la capture en taille normale
hello,

petit compo tres utile pour connaitre l'utilisation de son proc, le temps d'utilisation, et des infos (MHz, fabriquant, etc)

bye

Source

  • {
  • ################################################################################
  • # DBPPROCESSEUR #
  • ################################################################################
  • # #
  • # VERSION : 1.8 #
  • # FICHIERS : dbpVersionInfo.pas,.dcu,.dcr,.bmp,ReadMe.htm #
  • # AUTEUR : Julio P. (Diabloporc) #
  • # CREATION : 19 jul 2004 #
  • # MODIFIEE : 27 jul 2004 #
  • # SITE WEB : http://diabloporc.free.fr #
  • # MAIL : diabloporc@laposte.net #
  • # LEGAL : Free sous Licence GNU/GPL #
  • # INFOS : Retrouvez moi sur www.delphifr.com : "JulioDelphi" #
  • # #
  • ################################################################################
  • }
  • unit dbpProcesseur;
  • interface
  • uses
  • ExtCtrls, forms, ComCtrls, Gauges, mgProgress, windows, sysutils, classes, Registry;
  • type
  • TSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION=Record
  • Case Integer Of
  • 1:( IdleTime : Int64;
  • KernelTime : Int64;
  • UserTime : Int64;
  • Reserved1 : Array[0..2]Of Int64;
  • Reserved2 : Cardinal;);
  • 2:( Res : Array[1..$138]Of Byte);
  • End;
  • type
  • TdbpInterval = 100..3600000;
  • TdbpTimerEvent = procedure(Sender: TObject) of object;
  • TdbpProcesseur = class(TComponent)
  • private
  • FAbout, FTempsOccupe, FTempsInoccupe: String;
  • FEnabled, FChauffe, FTBFull: Boolean;
  • FUtilisation: Integer;
  • FInterval: TdbpInterval;
  • FTimer: TTimer;
  • FProgressBar: TProgressBar;
  • FGauge: TGauge;
  • FTrackBar: TTrackBar;
  • FmgProgress: TmgProgress;
  • FTimerEvent: TdbpTimerEvent;
  • procedure SetEnabled(const Value: Boolean);
  • procedure SetInterval(Value: TdbpInterval);
  • procedure SetProgressBar(Value: TProgressBar);
  • procedure SetmgProgress(Value: TmgProgress);
  • procedure SetGauge(Value: TGauge);
  • procedure SetTrackBar(Value: TTrackBar);
  • procedure SetChauffe(const Value: Boolean);
  • procedure SetTBFull(const Value: Boolean);
  • function GetMhz: integer;
  • function GetIdentifier: String;
  • function GetProcName: String;
  • function GetVendor: String;
  • function GetAbout: string;
  • protected
  • procedure ActTimer(Sender: TObject);
  • public
  • constructor Create(AOwner: TComponent); override;
  • destructor Destroy; override;
  • property Chauffe : Boolean read FChauffe write SetChauffe;
  • property CPUID_Identifier : String read GetIdentifier;
  • property CPUID_Mhz : Integer read GetMhz;
  • property CPUID_ProcName : String read GetProcName;
  • property CPUID_Vendor : String read GetVendor;
  • property TempsOccupe : String read FTempsOccupe;
  • property TempsTotal : String read FTempsInoccupe;
  • property Utilisation : Integer read FUtilisation;
  • procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  • published
  • procedure ChauffeMarcel;
  • procedure ArreteDeChauffer;
  • property About : String read GetAbout write FAbout;
  • property Enabled : Boolean read FEnabled write SetEnabled;
  • property Interval : TdbpInterval read FInterval write SetInterval;
  • property TGauge : TGauge read FGauge write SetGauge;
  • property TmgProgress : TmgProgress read FmgProgress write SetmgProgress;
  • property TProgressBar : TProgressBar read FProgressBar write SetProgressBar;
  • property TTrackBar : TTrackBar read FTrackbar write SetTrackBar;
  • property TTrackBar_full : boolean read FTBFull write SetTBFull;
  • property OnTimer: TdbpTimerEvent read FTimerEvent write FTimerEvent;
  • end;
  • procedure Register;
  • implementation
  • {$R dbpProcesseur.dcr}
  • Function NtQuerySystemInformation(SystemInfoClass:Integer;Info:Pointer;InfoLength:Cardinal;
  • Var ReturnLength:Cardinal):Integer;StdCall;
  • External 'NTDLL.DLL' Name 'NtQuerySystemInformation';
  • Const
  • SystemProcessorPerformanceInformation=$2;
  • CentNanoSecondesParJour = 24.0*60.0*60.0*10000000.0;
  • MilliSecondesParJour = 24.0*60.0*60.0*1000.0;
  • Var
  • MemTickTotal : Integer = 0;
  • MemTickIdle : Integer = 0;
  • procedure TdbpProcesseur.Notification(AComponent: TComponent; Operation: TOperation);
  • begin
  • if (aComponent = FProgressBar) and (Operation = opRemove) then
  • begin
  • FProgressBar := nil;
  • end;
  • if (aComponent = FmgProgress) and (Operation = opRemove) then
  • begin
  • FmgProgress := nil;
  • end;
  • if (aComponent = FGauge) and (Operation = opRemove) then
  • begin
  • FGauge := nil;
  • end;
  • if (aComponent = FTrackBar) and (Operation = opRemove) then
  • begin
  • FTrackBar := nil;
  • end;
  • end;
  • function ReadStringReg(Base: HKEY; KeyName, ValueName: string): string;
  • begin
  • result := '';
  • with TRegistry.Create do
  • begin
  • RootKey:=Base;
  • OpenKeyReadOnly(KeyName);
  • try
  • if ValueExists(ValueName) then
  • Result := ReadString(ValueName)
  • else
  • Result := '';
  • except
  • Result := '';
  • end;
  • Free;
  • end;
  • end;
  • function ReadIntegerReg(Base: HKEY; KeyName, ValueName: string): Integer;
  • begin
  • with TRegistry.Create do
  • begin
  • RootKey:=Base;
  • if KeyExists(KeyName) then OpenKey(KeyName, False);
  • try
  • if ValueExists(ValueName) then
  • Result:=ReadInteger(ValueName)
  • else
  • Result:=0;
  • except
  • Result:=0;
  • end;
  • Free;
  • end;
  • end;
  • function TdbpProcesseur.GetAbout: string;
  • begin
  • Result:='V1.8 : Julio P. (Diabloporc)';
  • end;
  • function TdbpProcesseur.GetMhz: Integer;
  • begin
  • result := ReadIntegerReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','~MHz');
  • end;
  • function TdbpProcesseur.GetIdentifier: String;
  • begin
  • result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','Identifier');
  • end;
  • var FFinChauffe: Boolean;
  • procedure TdbpProcesseur.SetChauffe(const Value: Boolean);
  • begin
  • FChauffe := Value;
  • if not (csDesigning in ComponentState) then
  • begin
  • FFinChauffe := not FChauffe;
  • if FChauffe then
  • while not FFinChauffe do Application.ProcessMessages;
  • end;
  • end;
  • procedure TdbpProcesseur.SetEnabled(const Value: Boolean);
  • begin
  • FEnabled := Value;
  • FTimer.Enabled := Value;
  • end;
  • procedure TdbpProcesseur.SetTBFull(const Value: Boolean);
  • begin
  • FTBFull := Value;
  • if (not FTBFull) and (FTrackBar<>nil) then
  • begin
  • FTrackBar.SelStart := 0;
  • FTrackBar.SelEnd := 0;
  • end;
  • end;
  • function TdbpProcesseur.GetProcName: String;
  • begin
  • result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','ProcessorNameString');
  • end;
  • procedure TdbpProcesseur.SetInterval(Value: TdbpInterval);
  • begin
  • FInterval := Value;
  • FTimer.Interval := Value;
  • end;
  • procedure TdbpProcesseur.SetProgressBar(Value: TProgressBar);
  • begin
  • if (FProgressBar <> Value) and (Value<>nil) then
  • begin
  • FProgressBar := value;
  • FProgressBar.Min := 0;
  • FProgressBar.Max := 100;
  • end
  • else
  • if Value=nil then FProgressBar := nil;
  • end;
  • procedure TdbpProcesseur.SetmgProgress(Value: TmgProgress);
  • begin
  • if (FmgProgress <> Value) and (Value<>nil) then
  • begin
  • FmgProgress := value;
  • FmgProgress.MinValue := 0;
  • FmgProgress.MaxValue := 100;
  • end
  • else
  • if Value=nil then FmgProgress := nil;
  • end;
  • procedure TdbpProcesseur.SetGauge(Value: TGauge);
  • begin
  • if (FGauge <> Value) and (Value<>nil) then
  • begin
  • FGauge := value;
  • FGauge.MinValue := 0;
  • FGauge.MaxValue := 100;
  • end
  • else
  • if Value=nil then FGauge := nil;
  • end;
  • procedure TdbpProcesseur.SetTrackBar(Value: TTrackBar);
  • begin
  • if (FTrackBar <> Value) and (Value<>nil) then
  • begin
  • FTrackBar := value;
  • FTrackbar.Min := 0;
  • FTrackBar.Max := 100;
  • FTrackBar.SelStart := 0;
  • FTrackBar.SelEnd := 0;
  • end
  • else
  • if Value=nil then FTrackBar := nil;
  • end;
  • function TdbpProcesseur.GetVendor: String;
  • begin
  • result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','VendorIdentifier');
  • end;
  • procedure TdbpProcesseur.ActTimer(Sender: TObject);
  • Var Info : TSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
  • Long : Cardinal;
  • TickTotal : Integer;
  • TickIdle : Integer;
  • DiffTotal : Integer;
  • DiffIdle : Integer;
  • Occupe : Double;
  • begin
  • NtQuerySystemInformation(SystemProcessorPerformanceInformation,@Info,SizeOf(Info),Long);
  • TickIdle := Info.IdleTime Div 10000;
  • TickTotal := GetTickCount;
  • DiffIdle := TickIdle - MemTickIdle;
  • DiffTotal := TickTotal - MemTickTotal;
  • Occupe := 100-DiffIdle/DiffTotal*100;
  • If Occupe<0 Then Occupe:=0;
  • FTempsOccupe := FormatDateTime('HH:NN:SS:zzz',Info.IdleTime /CentNanoSecondesParJour);
  • FTempsInoccupe := FormatDateTime('HH:NN:SS:zzz',TickTotal /MilliSecondesParJour );
  • FUtilisation := Round(Occupe);
  • if not (csDesigning in ComponentState) then
  • begin
  • if FProgressBar<>nil then FProgressBar.Position := FUtilisation;
  • if FmgProgress<>nil then FmgProgress.Progress := FUtilisation;
  • if FGauge<>nil then FGauge.Progress := FUtilisation;
  • if FTrackBar<>nil then FTrackBar.Position := FUtilisation;
  • if (FTBFull) and (FTrackBar<>nil) then FTrackBar.SelEnd := FUtilisation;
  • end;
  • MemTickIdle := TickIdle;
  • MemTickTotal := TickTotal;
  • if Assigned(FTimerEvent) then FTimerEvent(Self);
  • end;
  • procedure TdbpProcesseur.ChauffeMarcel;
  • begin
  • SetChauffe(true);
  • end;
  • procedure TdbpProcesseur.ArreteDeChauffer;
  • begin
  • SetChauffe(False);
  • end;
  • constructor TdbpProcesseur.Create(AOwner: TComponent);
  • begin
  • inherited Create(AOwner);
  • FChauffe := False;
  • FFinChauffe := True;
  • FTBFull := False;
  • FInterval := 500;
  • FTimer := TTimer.Create(self);
  • FTimer.Enabled := False;
  • FTimer.Interval := FInterval;
  • FTimer.OnTimer := ActTimer;
  • end;
  • destructor TdbpProcesseur.destroy;
  • begin
  • SetChauffe(false);
  • inherited Destroy;
  • FTimer := nil;
  • end;
  • procedure Register;
  • begin
  • RegisterComponents('Diabloporc', [TdbpProcesseur]);
  • end;
  • end.
{
################################################################################
# DBPPROCESSEUR                                                                #
################################################################################
#                                                                              #
# VERSION       : 1.8                                                          #
# FICHIERS      : dbpVersionInfo.pas,.dcu,.dcr,.bmp,ReadMe.htm                 #
# AUTEUR        : Julio P. (Diabloporc)                                        #
# CREATION      : 19 jul 2004                                                  #
# MODIFIEE      : 27 jul 2004                                                  #
# SITE WEB      : http://diabloporc.free.fr                                    #
# MAIL          : diabloporc@laposte.net                                       #
# LEGAL         : Free sous Licence GNU/GPL                                    #
# INFOS         : Retrouvez moi sur www.delphifr.com : "JulioDelphi"           #
#                                                                              #
################################################################################
}
unit dbpProcesseur;

interface

uses
   ExtCtrls, forms, ComCtrls, Gauges, mgProgress, windows, sysutils, classes, Registry;

type
  TSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION=Record
    Case Integer Of
    1:( IdleTime   : Int64;
        KernelTime : Int64;
        UserTime   : Int64;
        Reserved1  : Array[0..2]Of Int64;
        Reserved2  : Cardinal;);
    2:( Res        : Array[1..$138]Of Byte);
  End;

type
   TdbpInterval   = 100..3600000;
   TdbpTimerEvent = procedure(Sender: TObject) of object;
   TdbpProcesseur = class(TComponent)
  private
    FAbout, FTempsOccupe, FTempsInoccupe: String;
    FEnabled, FChauffe, FTBFull:         Boolean;
    FUtilisation:         Integer;
    FInterval: TdbpInterval;
    FTimer: TTimer;
    FProgressBar: TProgressBar;
    FGauge: TGauge;
    FTrackBar: TTrackBar;
    FmgProgress: TmgProgress;
    FTimerEvent: TdbpTimerEvent;

    procedure SetEnabled(const Value: Boolean);
    procedure SetInterval(Value: TdbpInterval);
    procedure SetProgressBar(Value: TProgressBar);
    procedure SetmgProgress(Value: TmgProgress);
    procedure SetGauge(Value: TGauge);
    procedure SetTrackBar(Value: TTrackBar);
    procedure SetChauffe(const Value: Boolean);
    procedure SetTBFull(const Value: Boolean);

    function GetMhz: integer;
    function GetIdentifier: String;
    function GetProcName: String;
    function GetVendor: String;
    function GetAbout: string;
  protected
    procedure ActTimer(Sender: TObject);
  public
    constructor Create(AOwner: TComponent);                   override;
    destructor  Destroy;                                      override;
    property Chauffe          : Boolean   read FChauffe       write SetChauffe;
    property CPUID_Identifier : String    read GetIdentifier;
    property CPUID_Mhz        : Integer   read GetMhz;
    property CPUID_ProcName   : String    read GetProcName;
    property CPUID_Vendor     : String    read GetVendor;
    property TempsOccupe      : String    read FTempsOccupe;
    property TempsTotal       : String    read FTempsInoccupe;
    property Utilisation      : Integer   read FUtilisation;
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  published
    procedure ChauffeMarcel;
    procedure ArreteDeChauffer;
    property About            : String    read GetAbout       write FAbout;
    property Enabled          : Boolean   read FEnabled       write SetEnabled;
    property Interval         : TdbpInterval   read FInterval      write SetInterval;
    property TGauge           : TGauge    read FGauge         write SetGauge;
    property TmgProgress      : TmgProgress    read FmgProgress    write SetmgProgress;
    property TProgressBar     : TProgressBar   read FProgressBar   write SetProgressBar;
    property TTrackBar        : TTrackBar      read FTrackbar      write SetTrackBar;
    property TTrackBar_full   : boolean   read FTBFull        write SetTBFull;
    property OnTimer:         TdbpTimerEvent   read FTimerEvent    write FTimerEvent;
  end;

procedure Register;

implementation

{$R dbpProcesseur.dcr}

Function NtQuerySystemInformation(SystemInfoClass:Integer;Info:Pointer;InfoLength:Cardinal;
            Var ReturnLength:Cardinal):Integer;StdCall;
            External 'NTDLL.DLL' Name 'NtQuerySystemInformation';

Const
  SystemProcessorPerformanceInformation=$2;
  CentNanoSecondesParJour = 24.0*60.0*60.0*10000000.0;
  MilliSecondesParJour    = 24.0*60.0*60.0*1000.0;

Var
  MemTickTotal : Integer = 0;
  MemTickIdle  : Integer = 0;

procedure TdbpProcesseur.Notification(AComponent: TComponent; Operation: TOperation);
begin
  if (aComponent = FProgressBar) and (Operation = opRemove) then
  begin
    FProgressBar := nil;
  end;
  if (aComponent = FmgProgress) and (Operation = opRemove) then
  begin
    FmgProgress := nil;
  end;
  if (aComponent = FGauge) and (Operation = opRemove) then
  begin
    FGauge := nil;
  end;
  if (aComponent = FTrackBar) and (Operation = opRemove) then
  begin
    FTrackBar := nil;
  end;
end;

function ReadStringReg(Base: HKEY; KeyName, ValueName: string): string;
begin
  result := '';
  with TRegistry.Create do
  begin
    RootKey:=Base;
    OpenKeyReadOnly(KeyName);
    try
      if ValueExists(ValueName) then
        Result := ReadString(ValueName)
      else
        Result := '';
    except
      Result := '';
    end;
    Free;
  end;
end;

function ReadIntegerReg(Base: HKEY; KeyName, ValueName: string): Integer;
begin
  with TRegistry.Create do
  begin
    RootKey:=Base;
    if KeyExists(KeyName) then OpenKey(KeyName, False);
    try
      if ValueExists(ValueName) then
        Result:=ReadInteger(ValueName)
      else
        Result:=0;
    except
      Result:=0;
    end;
    Free;
  end;
end;

function TdbpProcesseur.GetAbout: string;
begin
  Result:='V1.8 : Julio P. (Diabloporc)';
end;

function TdbpProcesseur.GetMhz: Integer;
begin
 result := ReadIntegerReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','~MHz');
end;

function TdbpProcesseur.GetIdentifier: String;
begin
 result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','Identifier');
end;

var FFinChauffe: Boolean;
procedure TdbpProcesseur.SetChauffe(const Value: Boolean);
begin
  FChauffe := Value;
  if not (csDesigning in ComponentState) then
   begin
    FFinChauffe := not FChauffe;
    if FChauffe then
     while not FFinChauffe do Application.ProcessMessages;
   end;
end;

procedure TdbpProcesseur.SetEnabled(const Value: Boolean);
begin
  FEnabled       := Value;
  FTimer.Enabled := Value;
end;

procedure TdbpProcesseur.SetTBFull(const Value: Boolean);
begin
  FTBFull       := Value;
  if (not FTBFull) and (FTrackBar<>nil) then
   begin
    FTrackBar.SelStart := 0;
    FTrackBar.SelEnd   := 0;
   end;
end;

function TdbpProcesseur.GetProcName: String;
begin
 result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','ProcessorNameString');
end;

procedure TdbpProcesseur.SetInterval(Value: TdbpInterval);
begin
  FInterval       := Value;
  FTimer.Interval := Value;
end;

procedure TdbpProcesseur.SetProgressBar(Value: TProgressBar);
begin
 if (FProgressBar <> Value) and (Value<>nil) then
  begin
   FProgressBar     := value;
   FProgressBar.Min := 0;
   FProgressBar.Max := 100;
  end
 else
  if Value=nil then FProgressBar := nil;
end;

procedure TdbpProcesseur.SetmgProgress(Value: TmgProgress);
begin
 if (FmgProgress <> Value) and (Value<>nil) then
  begin
   FmgProgress          := value;
   FmgProgress.MinValue := 0;
   FmgProgress.MaxValue := 100;
  end
 else
  if Value=nil then FmgProgress := nil;
end;

procedure TdbpProcesseur.SetGauge(Value: TGauge);
begin
 if (FGauge <> Value) and (Value<>nil) then
  begin
   FGauge          := value;
   FGauge.MinValue := 0;
   FGauge.MaxValue := 100;
  end
 else
  if Value=nil then FGauge := nil;
end;

procedure TdbpProcesseur.SetTrackBar(Value: TTrackBar);
begin
 if (FTrackBar <> Value) and (Value<>nil) then
  begin
   FTrackBar           := value;
   FTrackbar.Min       := 0;
   FTrackBar.Max       := 100;
   FTrackBar.SelStart  := 0;
   FTrackBar.SelEnd    := 0;
  end
 else
  if Value=nil then FTrackBar := nil;
end;

function TdbpProcesseur.GetVendor: String;
begin
 result := ReadStringReg(HKEY_LOCAL_MACHINE,'HARDWARE\DESCRIPTION\System\CentralProcessor\0','VendorIdentifier');
end;

procedure TdbpProcesseur.ActTimer(Sender: TObject);
Var Info      : TSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
    Long      : Cardinal;
    TickTotal : Integer;
    TickIdle  : Integer;
    DiffTotal : Integer;
    DiffIdle  : Integer;
    Occupe    : Double;
begin
  NtQuerySystemInformation(SystemProcessorPerformanceInformation,@Info,SizeOf(Info),Long);

  TickIdle  := Info.IdleTime Div 10000;
  TickTotal := GetTickCount;

  DiffIdle  := TickIdle  - MemTickIdle;
  DiffTotal := TickTotal - MemTickTotal;
  Occupe    := 100-DiffIdle/DiffTotal*100;
  If Occupe<0 Then Occupe:=0;

  FTempsOccupe   := FormatDateTime('HH:NN:SS:zzz',Info.IdleTime   /CentNanoSecondesParJour);
  FTempsInoccupe := FormatDateTime('HH:NN:SS:zzz',TickTotal       /MilliSecondesParJour   );
  FUtilisation   := Round(Occupe);

  if not (csDesigning in ComponentState) then
   begin
    if FProgressBar<>nil then FProgressBar.Position := FUtilisation;
    if FmgProgress<>nil  then FmgProgress.Progress  := FUtilisation;
    if FGauge<>nil       then FGauge.Progress       := FUtilisation;
    if FTrackBar<>nil    then FTrackBar.Position    := FUtilisation;
    if (FTBFull) and (FTrackBar<>nil)  then FTrackBar.SelEnd      := FUtilisation;
   end;

  MemTickIdle  := TickIdle;
  MemTickTotal := TickTotal;
  if Assigned(FTimerEvent) then FTimerEvent(Self);
end;

procedure TdbpProcesseur.ChauffeMarcel;
begin
 SetChauffe(true);
end;

procedure TdbpProcesseur.ArreteDeChauffer;
begin
 SetChauffe(False);
end;

constructor TdbpProcesseur.Create(AOwner: TComponent);
begin
 inherited Create(AOwner);
 FChauffe        := False;
 FFinChauffe     := True;
 FTBFull         := False;
 FInterval       := 500;
 FTimer          := TTimer.Create(self);
 FTimer.Enabled  := False;
 FTimer.Interval := FInterval;
 FTimer.OnTimer  := ActTimer;
end;

destructor TdbpProcesseur.destroy;
begin
  SetChauffe(false);
  inherited Destroy;
  FTimer := nil;
end;

procedure Register;
begin
  RegisterComponents('Diabloporc', [TdbpProcesseur]);
end;

end.

 Conclusion

bug ou autre : msg ou mail merci

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip


 Sources du même auteur

Source avec Zip Source avec une capture SCREENCAMTURE 0.2
Source avec Zip Source avec une capture JOUEZ : LIGHTS 1.4
Source avec Zip Source avec une capture FICLOCK : LOCKEZ LES FICHIERS
Source avec Zip Source avec une capture COMPOSANT TDBPTRACKBARVOLUME - JOUEZ AVEC LE SON !
Source avec Zip Source avec une capture COMPOSANT : TDBPLINKMAKER CREEZ DES .LNK

 Sources de la même categorie

Source avec Zip MOVCONTROL par abmed1963
Source avec Zip Source avec une capture PACKAGE DE COMPOSANTS CINDY V4.41 par MAURICIO
Source avec Zip Source avec une capture DBNAVIGATORPLUS par pascal1541
Source avec Zip Source avec une capture EVALUATION D' EXPRESSIONS MATHÉMATIQUE (MÉTHODE RPN) par MAURICIO
Source avec Zip Source avec une capture COMPOSANT TQPROGRESSBAR UNE BARRE DE PROGRESSION... par yanb

 Sources en rapport avec celle ci

Source avec Zip NUANCIER POUR CODER EN RGB par Toidil
Source avec Zip Source avec une capture SIMULATEUR DU L'ORDONNANCEUR SRT par offlake
Source avec Zip Source avec une capture INFORMATIONS DISQUE ET SYSTEME par HAFTARIFOUAD
Source avec Zip Source avec une capture INFORMATIONS SYSTÈME (VIA WMI) par fjohnny
Source avec Zip Source avec une capture HINT, SHORTHINT, LONGHINT OU COMMENT UTILISER PLEINEMENT LES... par cirec

Commentaires et avis

Commentaire de jmp77 le 04/08/2004 09:39:53

Sympa comme code.

Merci.

Commentaire de Forman le 09/08/2004 11:41:56

Merci pour ce code, j'en avais besoin!

Commentaire de ni69 le 04/05/2008 11:27:23

Il faut prendre quelques précautions quant à l'usage de ce code, notamment vis-à-vis de la constante SystemProcessorPerformanceInformation : On n'est en effet jamais vraiment sûr de la SIGNIFICATION du pourcentage d'usage du CPU renvoyé, car celle-ci varie selon les machines !

Voir le code http://www.delphifr.com/code.aspx?ID=12521
que j'ai commenté dans ce sens

Commentaire de JulioDelphi le 04/05/2008 12:37:27 administrateur CS

De plus mon (ancien) code ne prends pas en charge le dual core.

 Ajouter un commentaire


Discussions en rapport avec ce code source dans le forum

Contrôle de l'utilisation du processeur sous windows [ par plexus ] Quelqu'un connaît-il un moyen de lire l'état de la charge CPU sous windows, dans le but d'écrire un petit logiciel de contrôle sous Windows (style con Utilisation d'un MEMO [ par BRIVE ] Votre texte ICIVotre texte ICIBONJOURObjet:Utilisation d'un MEMOPour obtenir une égalité entre les items d'un mémo et lenombre de lignes textes affich utilisation TList [ par aaleex ] Bonjour à tous !Voilà mon problème :J'aimerais utiliser des TList pour y stocker des string.Et un autre TList pour stocker les listes de stringJ'ai es UTILISATION DE FILTERRECORD [ par cocoriri ] cocoririSi quelq'un pouvait me dire de façon précise si possible comment definir un filtre complexe (donc par une procedure filterRecord)pour recherch utilisation de tcpclient [ par dk ] voila ben je sais que la question a deja ete posée sur le forum et que la reponse indiquait l'aide de delphi comme un bon debut mais voila g la versio !!! Enregistrer un chemin UNIQUEMENT à la 1ère utilisation [ par floherz ] BonjourJe développe un lecteur et gestionnaire de .mp3.J'aimerais, à la TOUTE PREMIERE utilisation (et uniquement à la première utilisation), afficher Utilisation de ListBox... [ par mentral ] Bonjour à tous,Voilà, dans le cadre d'un petit programme sans grande valeur, j'aimerais savoir comment utiliser un ListBox. Je m'explique : L'objectif DBEdit double utilisation [ par jookeer3 ] Voila, Je voudrais savoir si il est possible a partir d'un DBEdit de lire un DataField d'une table et en meme temps , si on modifie ce DataField ca m utilisation ADO Connection pour delphi 6 entreprise [ par abdel_nab ] Ben voila, je veux savoir comment utilisé ADO connection avec delphi6 entreprise, car j'ai un probleme avec les tables paradox7 pour basculer bers aux utilisation du debogeur [ par oxboff5000 ] Boujour !j'ai une appli qui se compil sans pb mais au moment de creer certaines fenetre : c'est le drame l'exe ne repond + . je ne sais donc pas ou es


Nos sponsors


Sondage...

CalendriCode

Février 2012
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
272829    

Consulter la suite du CalendriCode

Photothèque

 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 2,870 sec (3)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales