Les messages subliminaux n'existe pas!

il existe bien des images cachée etc, mais il n'est etablis aucunes preuve scientifique, comme quoi ces messages ou images cachée influance réellement l'esprit ou l'inconscient. en gros, c'est de la connerie.

alors désolé si mes propos t'ont parus "mechant" ... mais comem c'est les vaccances ont a droit a toute sorte de choses et donc on ne fait pas de traitement de faveur.

bon je vois bien qu'apparement, tu ne cherche qu'une chose, progresser. c'est tout a ton honneur.

je remarque aussi, que tu ne t'attaque pas trop a des trucs qui te depasse, cesar et vigenere sont deux petite methode amusante a programmer au debut.

aprés ça je ne saurais trop te conseiller de passer a CRC16, CRC32, MD5, SHA1, etc. bien que pour MD5 et SHA1 ont commence vraiment a donner dans le truc trés "haut vol".

la ou il faut faire neanmoins attention, c'est dans les termes que tu choisis.
Keygen est le terme qui designe un programme qui genere une clef, un numero de serie, mais avec une conotation "cracking".
d'ou ma premiere remarque.

voila et bonne continuation.

inutile et sans interet.

de plus, hors de question de voir des logiciels de ce genre ici (KeyGen, Crack, NoCD etc).

Kilo n'a qu'un L

Mega n'a pas de T

pour la gauge et les personnes ayant plus de 2Go de RAM il est plus interessant de faire :

// main.Gauge1.MaxValue := on laisse a 100
   main.Gauge1.Progress := round( 100 / lpBuffer.dwTotalPhys) * lpBuffer.dwAvailPhys);


On appel JAMAIS la variable de la fiche dans la classe!

#  with main do begin

ne sert a rien du tout!



pour le timer il faut plutot faire :

const
  BCTTS : array[boolean] of ('Démarrer','Arrêter');
begin
  Timer1.Enabled := not Timer1.Enabled;
  Button1.Caption:= BCTTS[ Timer1.Enabled ];
  Gauge1.Visible := Timer1.Enabled;
end;


enfin, on affiche toujours les infos au format Kilo-octet (avec separateur de millier en prime)

function Tmain.Octet_Megat(const Size : int64): string;
begin
  result := format('%.0n Ko',[Size/1024]);
end;


les StdCall sont inutile ici.

c'est pas faute d'avoir prevenus.

essaye de fournir un travail plus propre et lisible si tu veux que les gens s'y interesse.

tu peu remplacer dans l'unité HexFile.pas :

>>>

implementation

Const
  HexChars : array[$0..$f] of char = '0123456789ABCDEF';

  CRC32Table : array[Byte] of cardinal = (
    $00000000, $77073096, $EE0E612C, $990951BA, $076DC419, $706AF48F, $E963A535, $9E6495A3, $0EDB8832, $79DCB8A4, $E0D5E91E, $97D2D988, $09B64C2B, $7EB17CBD, $E7B82D07, $90BF1D91,
    $1DB71064, $6AB020F2, $F3B97148, $84BE41DE, $1ADAD47D, $6DDDE4EB, $F4D4B551, $83D385C7, $136C9856, $646BA8C0, $FD62F97A, $8A65C9EC, $14015C4F, $63066CD9, $FA0F3D63, $8D080DF5,
    $3B6E20C8, $4C69105E, $D56041E4, $A2677172, $3C03E4D1, $4B04D447, $D20D85FD, $A50AB56B, $35B5A8FA, $42B2986C, $DBBBC9D6, $ACBCF940, $32D86CE3, $45DF5C75, $DCD60DCF, $ABD13D59,
    $26D930AC, $51DE003A, $C8D75180, $BFD06116, $21B4F4B5, $56B3C423, $CFBA9599, $B8BDA50F, $2802B89E, $5F058808, $C60CD9B2, $B10BE924, $2F6F7C87, $58684C11, $C1611DAB, $B6662D3D,
    $76DC4190, $01DB7106, $98D220BC, $EFD5102A, $71B18589, $06B6B51F, $9FBFE4A5, $E8B8D433, $7807C9A2, $0F00F934, $9609A88E, $E10E9818, $7F6A0DBB, $086D3D2D, $91646C97, $E6635C01,
    $6B6B51F4, $1C6C6162, $856530D8, $F262004E, $6C0695ED, $1B01A57B, $8208F4C1, $F50FC457, $65B0D9C6, $12B7E950, $8BBEB8EA, $FCB9887C, $62DD1DDF, $15DA2D49, $8CD37CF3, $FBD44C65,
    $4DB26158, $3AB551CE, $A3BC0074, $D4BB30E2, $4ADFA541, $3DD895D7, $A4D1C46D, $D3D6F4FB, $4369E96A, $346ED9FC, $AD678846, $DA60B8D0, $44042D73, $33031DE5, $AA0A4C5F, $DD0D7CC9,
    $5005713C, $270241AA, $BE0B1010, $C90C2086, $5768B525, $206F85B3, $B966D409, $CE61E49F, $5EDEF90E, $29D9C998, $B0D09822, $C7D7A8B4, $59B33D17, $2EB40D81, $B7BD5C3B, $C0BA6CAD,
    $EDB88320, $9ABFB3B6, $03B6E20C, $74B1D29A, $EAD54739, $9DD277AF, $04DB2615, $73DC1683, $E3630B12, $94643B84, $0D6D6A3E, $7A6A5AA8, $E40ECF0B, $9309FF9D, $0A00AE27, $7D079EB1,
    $F00F9344, $8708A3D2, $1E01F268, $6906C2FE, $F762575D, $806567CB, $196C3671, $6E6B06E7, $FED41B76, $89D32BE0, $10DA7A5A, $67DD4ACC, $F9B9DF6F, $8EBEEFF9, $17B7BE43, $60B08ED5,
    $D6D6A3E8, $A1D1937E, $38D8C2C4, $4FDFF252, $D1BB67F1, $A6BC5767, $3FB506DD, $48B2364B, $D80D2BDA, $AF0A1B4C, $36034AF6, $41047A60, $DF60EFC3, $A867DF55, $316E8EEF, $4669BE79,
    $CB61B38C, $BC66831A, $256FD2A0, $5268E236, $CC0C7795, $BB0B4703, $220216B9, $5505262F, $C5BA3BBE, $B2BD0B28, $2BB45A92, $5CB36A04, $C2D7FFA7, $B5D0CF31, $2CD99E8B, $5BDEAE1D,
    $9B64C2B0, $EC63F226, $756AA39C, $026D930A, $9C0906A9, $EB0E363F, $72076785, $05005713, $95BF4A82, $E2B87A14, $7BB12BAE, $0CB61B38, $92D28E9B, $E5D5BE0D, $7CDCEFB7, $0BDBDF21,
    $86D3D2D4, $F1D4E242, $68DDB3F8, $1FDA836E, $81BE16CD, $F6B9265B, $6FB077E1, $18B74777, $88085AE6, $FF0F6A70, $66063BCA, $11010B5C, $8F659EFF, $F862AE69, $616BFFD3, $166CCF45,
    $A00AE278, $D70DD2EE, $4E048354, $3903B3C2, $A7672661, $D06016F7, $4969474D, $3E6E77DB, $AED16A4A, $D9D65ADC, $40DF0B66, $37D83BF0, $A9BCAE53, $DEBB9EC5, $47B2CF7F, $30B5FFE9,
    $BDBDF21C, $CABAC28A, $53B39330, $24B4A3A6, $BAD03605, $CDD70693, $54DE5729, $23D967BF, $B3667A2E, $C4614AB8, $5D681B02, $2A6F2B94, $B40BBE37, $C30C8EA1, $5A05DF1B, $2D02EF8D
    );

{ CRC32 }
//> on calcul pas un checksum en additionant betement les bytes...
//> rien ne vaut un bon vieux CRC32 que tout le monde connait!
function CRC32(const Buffer; const BufferLen : Integer; const Old : Cardinal = 0) : Cardinal;
var pB : ^Byte;
    I  : Integer;
begin
  result := Old;
  pB     := @Buffer;
  for I := 0 to BufferLen-1 do
  begin
    Result := (Result shr 8) xor CRC32Table[pB^ xor byte(Result)];
    Inc(pB);
  end;
end;

{ HexToLong }
//> 2 en delphi s'ecrit To!
//> on utilise les bytes pour eviter les appels redondant a Ord()
function HexToLong(const V : Char) : Byte;
Begin
  Result := Byte(V);
  case Result of
    48..57  : Dec(Result,48);
    65..70  : Dec(Result,55);
    97..102 : Dec(Result,87);
  end;
End;


{ ValueToHex }
//> pas besoin de millions de fonction, on utilise directement
//> une fonction qui fait tout! (ou presque)
function ValueToHex(const Buffer; const BufferLen : integer) : string;
var pR : pChar;
    pB : ^Byte;
    N  : integer;
begin
  pB := @Buffer;
  inc(pB, BufferLen - 1);
  SetLength(Result, BufferLen shl 1);
  pR := PChar(Result);
  for N := 0 to BufferLen-1 do
  begin
    pR[0] := HexChars[pB^ shr 4];
    pR[1] := HexChars[pB^ and $F];
    inc(pR, 2);
    dec(pB);
  end;
end;





Dans l'unité FilePath.pas :

>>

//> pourquoi reinventer la roue!?
procedure SplitFileName(const FileName : string; var Path, Name, Ext : string);
begin
  Path := ExtractFilePath(FileName);
  Name := ExtractFileName(FileName);
  Ext  := ExtractFileExt(FileName);
  Name := Copy(Name, 1, Length(Name) - Length(Ext));
end;

//> oui ... pourquoi ...
function SetFileExt(const FileName,NewExt : String): String;
begin
  result := ChangeFileExt(FileName,NewExt);
end;

//> alternative de l'alias de fonction dans une variable :
var
  SetFileExt : function(const FileName,NewExt : string) : string = SysUtils.ChangeFileExt;

mmmm ... j'aurais pas vus ça de cette façon ...

et y'a deux ou trois truc qui me chiffoune ... :)

par exemple, la methode AfficheImage necessite un index, index que l'on ne peu pas réellement controler puisque qu'il n'existe pas de methode Count par exemple ...
il faudrait aussi quelques methodes pour vider les images chargée au cas ou ...


ensuite il me semble qu'il est superflus d'appeler le Refresh a la fin de cette methode puisque logiquement, l'assign du bitmap notifie l'objet TImage de la modification (et donc qu'il doit se rafraichir) ...

ensuite tu utilise le format bitmap en interne, soit, mais ne serait il pas judicieux de fournir une alternative (jpeg par exemple) qui prendrais moins de ressource memoire (au cas ou).

il y a aussi un manque de control dans les methodes Set* :

procedure TAnimage.SetTempo(Valeur : Integer);
begin
  if fTempo <> Valeur then
    fTempo := Valeur;
end;

procedure TAnimage.SetActive(Valeur : boolean);
var
no : integer;
begin
  if fActive <> Valeur then
  begin
    fActive := Valeur;
    if not (csDesigning in ComponentState) then
      while fActive do
        for no := 0 to fNbima-1 do
        begin
          if not fActive then
            exit;
          AfficheUneImage(no);
          Sleep(fTempo);
          Application.ProcessMessages;
        end;
  end;
end;


mais bon, je peu pas trop "critiquer" puisque j'ai moi même tenter sans succés d'ecrire de tel composant mais aucuns n'est satisfaisant.

bon je vais gueuler :

INDENTE TON CODE! NOM DE DIEU!

3 sources que tu poste, 3 sources illisible!


t'as de bonne idées mais c'est a chaque fois totalement gaché par un code ecrit avec les pieds (gauche tout les deux et ca a pas l'air d'etre les tiens!)

un peu leger ...
pas trés interressant ... (s'obtient aussi facilement en mode conception)

ne merite pas le niveau initié.

la propriété Hint2 doit etre de type String directement tout comme Hint.

tu n'indente toujours pas ton code.

tu ne devrais pas utiliser la propriété Tag pour le changement d'etat mais une variable privée de type boolean.

le gestionnaire OnClick ne doit pas etre appeler par la procedure Click surchargée ! il faut appeler la procedure Click de l'ancetre (TControl) qui elle se charge d'appeler le gestionnaire d'evenement de façon adequate. de plus les procedures et fonctions ne sont pas declarable en zone publiées ...

ce qui fait que ton composant devrait plus ressembler a cela :

(en version ameliorée sans limite de Caption et de Hint)...

type
  TMultiCapSpdBtn = class(TSpeedButton)
  private
    fCaptionsAndHints : TStrings;
    fStIndex          : integer;
    procedure SetStrings(Value : TStrings);
  protected
    procedure ChangeCaption; virtual;
    procedure DoCaptionsChange(Sender : TObject);
  public
    Constructor Create (AOwner:Tcomponent); Override;
    Destructor Destroy; Override;
    Procedure Click; override;
  published
    Property CaptionsAndHints : TStrings read fCaptionsAndHints write SetStrings;
  end;

constructor TMultiCapSpdBtn.Create(Aowner:TComponent);
begin
  inherited Create(Aowner);
  AllowAllUp := True;
  ShowHint   := True;
  fStIndex   := 0;
  fCaptionsAndHints := TStringList.Create;
  (fCaptionsAndHints as TStringList).OnChange := DoCaptionsChange;
end;

destructor TMultiCapSpdBtn.Destroy;
begin
  fCaptionsAndHints.Free;
  inherited Destroy;
end;

procedure TMultiCapSpdBtn.Click;
begin
  if fCaptionsAndHints.Count > 0 then
  begin
    fStIndex := (fStIndex + 1) mod fCaptionsAndHints.Count;
    ChangeCaption;
  end;
  Inherited Click;
end;

procedure TMultiCapSpdBtn.DoCaptionsChange(Sender: TObject);
begin
  ChangeCaption;
end;

procedure TMultiCapSpdBtn.SetStrings(Value: TStrings);
begin
  fCaptionsAndHints.Assign(Value);
end;

procedure TMultiCapSpdBtn.ChangeCaption;
var SeparatorPos : integer;
begin
  SeparatorPos := Pos('|',fCaptionsAndHints[fStIndex]);
  Caption := copy(fCaptionsAndHints[fStIndex], 1, SeparatorPos-1);
  if SeparatorPos <> 0 then
    Hint := copy(fCaptionsAndHints[fStIndex], SeparatorPos+1, Length(fCaptionsAndHints[fStIndex]) - SeparatorPos)
  else
    Hint := '';
end;

on peu egalement faire ceci :

C39 : array[0..43] of word =
($0064, // 0
$0091, // 1
$0061, // 2
$0160, // 3
$0031, // 4
$0130, // 5
$0050, // 6
$0025, // 7
$0124, // 8
$0064, // 9
ect ...


et on recupere facilement comme ceci :

bit 0 : (C39[index] and $0001) = $0001 (bit 0 = 1)
bit 1 : (C39[index] and $0002) = $0002 (bit 1 = 1)
bit 2 : (C39[index] and $0004) = $0004 (bit 2 = 1)
bit 3 : (C39[index] and $0008) = $0008 (etc)
bit 4 : (C39[index] and $0010) = $0010
bit 5 : (C39[index] and $0020) = $0020
bit 6 : (C39[index] and $0040) = $0040
bit 7 : (C39[index] and $0080) = $0080
bit 8 : (C39[index] and $0100) = $0100

ce qui fait passer le tableaux de code de 44*9 octets a 44*2 octets.


et les methodes de propriétés sont censée toujours etre dans private et non protected.

procedure SetCode(ACode:string);
procedure SetBarWide(ABarWide:integer);
procedure SetBarNarrow(ABarNarrow:integer);