FASTGRADIENT (METTEZ DES DÉGRADÉS DE COULEURS DANS VOS APPLICATIONS)

Commentaire de cantador le 17/04/2006 12:39:49

sauf erreur de ma part, il doit manquer un fichier dans ton ZIP..
essaie de tout installer à partir de ton fichier compressé.

Commentaire de shining le 17/04/2006 15:34:33

Autre chose aussi certaines valeurs on une précision double(avec virgule), il faut y aller molo généralement un chiffre après la virgule peut avoir une affluence sur tout le reste, c'est notamment le cas des "Facteurs", evitez de mettre des zero au facteur sinon ya risque de division par zero !!!, la demo integre petite protection.

Commentaire de shining le 17/04/2006 16:40:14

Décidemment lol
non seulement l'auteur du composant SpinEdit diffuse un compo sans package et en plus il es bourré d'erreurs !!! mdr, je n'ai pas le droit de modifier le fichier sans l'accord de l'auteur j'ai donc tout simplement mis le zip tel quel !!! car entre temps visiblement l'auteur à changer le nom du fichier resource BmSpinEditInt.res par BmpSpinEdit.dcr

donc voilà la rectif à faire toi même !!!
Mon Package gère automatiquement le fichier resource donc en principe il n'est plus utile de re déclarer le fichier resource

donc dans BmSpinEdit.pas juste en dessous de implementation
l'auteur à mis
{$R BmSpinEditInt.res} <=== retire cette déclaration à la ligne 250

au pire des cas si ça ne marche toujours pas il suffit alors de changer BmpSpinEditInt.res par BmpSpinEdit.dcr

mais ya pas de raison que cette manip ne marche pas !!
@+

Commentaire de f0xi le 18/04/2006 09:47:16 administrateur CS

pourquoi ne pas remplacer les composants non standard par de simple trackbar ?



sinon voila quelques resolutions de problemes :


procedure TFrmMain.DoSpinEditChange(Sender: TObject);
begin
    if not FBeginUpdate then
       UpdateGradient;
end;


procedure TFrmMain.UpdateGradient;
begin
    // avec uses Math :
    with BmLightAngle do Value := Max(1,Value);
    with BmIntensisty do Value := Max(1,Value);
    with BmRangeRGB   do Value := Max(1,Value);

    with Mat do begin
       LightAngle := BmLightAngle.Value;
       with Intensity do begin
          Factor  := BmIntensityFactor.Value;
          Value   := BmIntensity.Value;
          RGB     := Trunc(BMIntensityRGB.Value);
       end;
       with Color do begin
          Factor  := BmColorFactor.Value;
          RGB     := Trunc(BmColorRGB.Value);
          Range   := Trunc(BmRangeRGB.Value);
          R       := Trunc(BmR.Value);
          G       := Trunc(BmG.Value);
          B       := Trunc(BmB.Value);
       end;
    end;
    DrawGradient;
end;


procedure TFrmMain.LoadGradients;
var
SearchRec : TSearchRec;
begin
    lstbGradientExplorer.Clear;
    // FindFirst, FindNext,FindCloses doit etre dans un bloc Try Finally
    try
      with lstbGradientExplorer.Items do begin
          // il faut forcer SysUtils pour les fonctions Find* a cause de l'unité Windows.
          if SysUtils.FindFirst(GetGradDir+'*.fgd' , faAnyFile, SearchRec) = 0 then begin
             // ne pas oublier d'ajouter le premier elements trouvé.
             Add(SearchRec.Name+'='+LoadGradient(SearchRec.Name));
             while SysUtils.FindNext(SearchRec) = 0 do
                   // ne pas utiliser Format pour concatener les chaines.
                   Add(SearchRec.Name+'='+LoadGradient(SearchRec.Name));
          end;
      end;
    finally
      SysUtils.FindClose(SearchRec);
    end;
end;


procedure TFrmMain.DrawGradient;
const
BoolToOrient : array[boolean] of TGradientOrientation = (goVert,goHorz);
begin
    Grad.BackColor := PanGradient.Color;
    Grad.DrawGradientMat( PaintBoxGradient.Canvas,
                          PanGradient.ClientRect,
                          Mat,
                          BoolToOrient[ChkOrientation.Checked]);
end;


procedure TFrmMain.chkOrientationClick(Sender: TObject);
const
  BoolToOrientCap : array[boolean] of string = ('Verticale','Horizontale');
begin
   ChkOrientation.Caption := BoolToOrientCap[ChkOrientation.Checked];
   DrawGradient;
end;

// pas dans destroy mais dans Close
procedure TFrmMain.FormClose(Sender: TObject);
begin
    Grad.Free;
end;

Commentaire de f0xi le 18/04/2006 14:51:03 administrateur CS

tiens je me permet de faire une grosse correction pour TGradientMat.

tu remarqueras que les fichiers sont fait avec TIniFile, ce qui permet d'aller les modifier dans le bloc note par exemple (ce qui peut etre utile quand on change la version du composant), mais ca simplifie grandement le format du fichier ce qui faciliteras l'ajout de choses et d'autre et l'utilisation concrete dans les programmes.

Le fait d'avoir mis TGradientIntensity et TGradientColor en classe TPersistent permet d'avoir une hierarchie lisible dans l'inspecteur d'objet et permet egalement un meilleur control sur les données, comme l'ajout d'evenement, de control d'interval, de calcul avancé ect... ect...

TGradientMat Remplace directement TSfcFastGradient qui s'est trouver inutile aprés reflexion.
ce composant gere seul le chargement et la sauvegarde des fichiers de dégradés et egalement le dessin dans le canvas.
Ce qui fait que TGradientMat s'utilise un peu comme les TStringLists, il permettras egalement de faire des presets plus facilement pour un composant visuel plus costaud.
Il faudrat juste que tu regarde a regler les valeurs par defaut a la creation dans les constructeurs, ne les sachants pas, je les est mises un peu au plus logique.

Sinon tout a été corrigé et ce qui été inutile (comme la couleur de fond ?! qui servait a rien du tout) ont été enlevés.

bien entendus, tout cela genere plus de code, mais au final, a l'utilisation il y'en a beaucoup moins ... c'est ça la puissance des classes.


unit GradientMat;

interface

uses Windows, Types, Classes, SysUtils, Math, Controls, Graphics, IniFiles, Dialogs;

const
  {byte 1 : major
   byte 2 : minor
   byte 3 : release
   byte 4 : build }
  GRADIENT_VERSION = $01010000; {v1.1.0.0}

type
  TGradientOrientation = (goHorz , goVert);

  TGradientIntensity = Class(TPersistent)
  private
    fControl : TControl;
    fRGB     : integer;
    fFactor  : single;
    fValue   : single;
    fOnChange: TNotifyEvent;
    procedure fSetInt(Val : integer);
    procedure fSetFloat(index : integer; Val : single);
  protected
    procedure Change; virtual;
    procedure AssignTo(Dest : TPersistent); override;
    property Control : TControl read FControl;
    property OnChange : TNotifyEvent read fOnChange write fOnChange;
  published
    property RGB   :{0..255} integer        read fRGB    write fSetInt;
    property Factor:{?..?} single index 0 read fFactor write fSetFloat;
    property Value :{?..?} single index 1 read fValue  write fSetFloat;
  public
    constructor Create(Control: TControl); virtual;
    destructor Destroy; override;
  end;

  TGradientColor = Class(TPersistent)
  private
    fControl : TControl;
    fRGB     : integer;
    fRange   : integer;
    fFactor  : single;
    fR       : byte;
    fG       : byte;
    fB       : byte;
    fOnChange: TNotifyEvent;
    procedure fSetInt(index : integer; Val : integer);
    procedure fSetFloat(Val : single);
    procedure fSetByte(index : integer; Val : byte);
  protected
    procedure Change; virtual;
    procedure AssignTo(Dest : TPersistent); override;
    property Control : TControl read FControl;
    property OnChange : TNotifyEvent read fOnChange write fOnChange;
  published
    property RGB   : {0..255} integer index 0 read fRGB    write fSetInt;
    property Range : {?..?} integer index 1 read fRange  write fSetInt;
    property Factor: {?..?} single          read fFactor write fSetFloat;
    property R     : {0..255} byte    index 0 read fR      write fSetByte;
    property G     : {0..255} byte    index 1 read fG      write fSetByte;
    property B     : {0..255} byte    index 2 read fB      write fSetByte;
  public
    constructor Create(Control: TControl); virtual;
    destructor Destroy; override;
  end;

  TGradientMat = class(TComponent)
  private
    fIntensity    : TGradientIntensity;
    fColor        : TGradientColor;
    fLightAngle   : single;
    fGradientName : string;
    fGradientVersion : integer;
    fOnChange     : TNotifyEvent;
    procedure fSetIntensity(Val : TGradientIntensity);
    procedure fSetColor(Val : TGradientColor);
    procedure fSetFloat(Val : single);
    procedure fSetGDName(Val : String);
    function fGetVersion : string;
    procedure DoIntensityChange(Sender : TObject);
    procedure DoColorChange(Sender : TObject);
  protected
    procedure Change; virtual;
  published
    property Intensity    : TGradientIntensity read fIntensity write fSetIntensity;
    property Color        : TGradientColor read fColor write fSetColor;
    property LightAngle   : single read fLightAngle write fSetFloat;
    property GradientName : string read fGradientName write fSetGDName;
    property GradientVersion : string read fGetVersion;
    property OnChange : TNotifyEvent read fOnChange write fOnChange;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure DrawGradient(ACanvas : TCanvas; ARect : TRect; AOrientation : TGradientOrientation);
    procedure LoadFromFile(FileName : string);
    procedure SaveToFile(FileName : string);
  end;

  procedure Register;

implementation
  
procedure Register;
begin
  RegisterComponents('Exemples', [TGradientMat]);
end;

type
  TRGBRec = record
     B,G,R : byte;
  end;
  TRGBRecArray = array[0..32767] of TRGBRec;
  pRGBRecArray = ^TRGBRecArray;

{ functions -------------------------------------------------------------------------------------- }

function Clamp(const V,aMin,aMax : integer) : integer; overload;
begin
  result := Max(Min(V,aMax),aMin);
end;

function Clamp(const V,aMin,aMax : byte) : byte; overload;
begin
  result := Max(Min(V,aMax),aMin);
end;

function Clamp(const V,aMin,aMax : single) : single; overload;
begin
  result := Max(Min(V,aMax),aMin);
end;

function ValidateRGB(Color: integer): integer;
begin
  result := Max(Min(Color,255),0);
end;

{ TGradientIntensity ----------------------------------------------------------------------------- }
constructor TGradientIntensity.Create(Control : TControl);
begin
  inherited Create;
  fControl := Control;
  fRGB     := 0;
  fFactor  := 1.0;
  fValue   := 1.0;
end;

Destructor TGradientIntensity.Destroy;
begin
  inherited Destroy;
end;

procedure TGradientIntensity.fSetInt(Val : integer);
var ClV : integer;
begin
  ClV := Clamp(Val,0,255);
  if fRGB <> ClV then begin
     fRGB := ClV;
     Change;
  end;
end;

procedure TGRadientIntensity.fSetFloat(index : integer; Val : single);
begin
  case index of
    0: begin
       if fFactor <> Val then begin
          fFactor := Val;
          Change;
       end;
       end;
    1: begin
       if fValue <> Val then begin
          fValue := Val;
          Change;
       end;
       end;
  end;
end;

procedure TGRadientIntensity.Change;
begin
  if Assigned(fOnChange) then fOnChange(Self);
end;

procedure TGRadientIntensity.AssignTo(Dest : TPersistent);
begin
  if Dest is TGRadientIntensity then
    with TGRadientIntensity(Dest) do begin
      fRGB    := Self.fRGB;
      fFactor := Self.fFactor;
      fValue  := Self.fValue;
      Change;
    end
  else
    inherited AssignTo(Dest);
end;

{ TGradientColor --------------------------------------------------------------------------------- }
constructor TGradientColor.Create(Control : TControl);
begin
  inherited Create;
  fControl := Control;
  fRGB     := 0;
  fRange   := 1;
  fFactor  := 1.0;
  fR       := 0;
  fG       := 0;
  fB       := 0;
end;

destructor TGradientColor.Destroy;
begin
  inherited Destroy;
end;

procedure TGradientColor.fSetInt(index : integer; val : integer);
var ClV : integer;
begin
  case index of
    0: begin
       ClV := clamp(Val,0,255);
       if fRGB <> ClV then begin
          fRGB := ClV;
          Change;
       end;
       end;
    1: begin
       ClV := clamp(Val,1,255);
       if fRange <> ClV then begin
          fRange := ClV;
          Change;
       end;
       end;
  end;
end;

procedure TGradientColor.fSetFloat(Val : single);
begin
  if fFactor <> Val then begin
     fFactor := Val;
     Change;
  end;
end;

procedure TGradientColor.fSetByte(index : integer; val : byte);
var ClV : byte;
begin
  ClV := Clamp(Val,0,255);
  Case Index of
    0: if fR <> ClV then begin
          fR := ClV;
          Change;
       end;
    1: if fG <> ClV then begin
          fG := ClV;
          Change;
       end;
    2: if fB <> ClV then begin
          fB := ClV;
          Change;
       end;
  end;
end;

procedure TGradientColor.Change;
begin
  if Assigned(fOnChange) then fOnChange(Self);
end;

procedure TGradientColor.AssignTo(Dest : TPersistent);
begin
  if Dest is TGradientColor then
    with TGradientColor(Dest) do begin
      fRGB    := Self.fRGB;
      fFactor := Self.fFactor;
      fRange  := Self.fRange;
      fR      := Self.fR;
      fG      := Self.fG;
      fB      := Self.fB;
      Change;
    end
  else
    inherited AssignTo(Dest);
end;

{ TGradientMat --------------------------------------------------------------------------------- }
constructor TGradientMat.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);
  fIntensity := TGradientIntensity.Create(nil);
  fIntensity.OnChange := DoIntensityChange;
  fColor := TGradientColor.Create(nil);
  fColor.OnChange := DoColorChange;
  fLightAngle := 0;
  fGradientName := '(UnNamed Gradient)';
end;

destructor TGradientMat.Destroy;
begin
  fColor.Free;
  fIntensity.Free;
  inherited destroy;
end;

procedure TGradientMat.fSetIntensity(val : TGradientIntensity);
begin
  Val.AssignTo(fIntensity);
  fIntensity.OnChange(self);
end;

procedure TGradientMat.fSetColor(val : TGradientColor);
begin
  Val.AssignTo(fColor);
  fColor.OnChange(Self);
end;

procedure TGradientMat.fSetFloat(val : single);
var ClV : single;
begin
//  ClV := Clamp(Val,{MinLightAngle},{MaxLightAngle});
    if fLightAngle <> Val{ClV} then begin
       fLightAngle := Val{ClV};
       Change;
    end;
end;

procedure TGradientMat.fSetGDName(Val : String);
begin
  if fGradientName <> Val then begin
     fGradientName := Val;
     Change;
  end;
end;

function TGradientMat.fGetVersion : string;
var VMajor,VMinor,VRelease,VBuild : byte;
begin
  VMajor  := byte(fGradientVersion shr 24);
  VMinor  := byte(fGradientVersion shr 16);
  VRelease:= byte(fGradientVersion shr 8);
  VBuild  := byte(fGradientVersion);
  result := format('%d.%d.%d.%d',[VMajor,VMinor,VRelease,VBuild]);
end;

procedure TgradientMat.DoIntensityChange(Sender : TObject);
begin
  { code of Intensity change here ...}
  Change;
end;

procedure TGradientMat.DoColorChange(sender : TObject);
begin
  { code of Color change here ...}
  Change;
end;

procedure TGradientMat.Change;
begin
  if Assigned(fOnChange) then fOnChange(Self);
end;

{ DrawGradient -------------------------------------------------------------------------------- }
procedure TGradientMat.DrawGradient(ACanvas: TCanvas; ARect: TRect; AOrientation: TGradientOrientation);
var Buffer : TBitmap;
    X, Y,
    iKB   : Integer;
    FR,FG,FB,
    PL    : Single ;
    ScanLines : pRGBRecArray;
begin
    Buffer := TBitmap.Create;
    Buffer.PixelFormat := pf24bit;
    Buffer.Width  := ARect.Right  - ARect.Left;
    Buffer.Height := ARect.Bottom - ARect.Top;

    Case AOrientation of
       goHorz : begin
          iKB := Trunc((Buffer.Height) / fLightAngle);
          PL  := 255 div (Buffer.Height);
       end;
       goVert : begin
          if Buffer.Width > 255 then
             PL := 0.5
          else
             PL := 255 div Buffer.Width;
       end;
    end;

    FR := (((fIntensity.RGB+fColor.R*fIntensity.Factor)/fIntensity.Value)+fColor.R)/fColor.Range;
    FG := (((fIntensity.RGB+fColor.G*fIntensity.Factor)/fIntensity.Value)+fColor.G)/fColor.Range;
    FB := (((fIntensity.RGB+fColor.B*fIntensity.Factor)/fIntensity.Value)+fColor.B)/fColor.Range;

    for Y := 0 to Buffer.Height -1 do begin
        ScanLines := Buffer.Scanline[Y];
         if AOrientation = goVert then
           iKB := Trunc((Buffer.Width) / fLightAngle);
        for X := 0 to Buffer.Width -1 do begin
            with ScanLines[X] do begin
              R := ValidateRGB(Trunc((fColor.RGB + (Abs(iKB) * PL) * fColor.Factor) * FR));
              G := ValidateRGB(Trunc((fColor.RGB + (Abs(iKB) * PL) * fColor.Factor) * FG));
              B := ValidateRGB(Trunc((fColor.RGB + (Abs(iKB) * PL) * fColor.Factor) * FB));
            end;
            if AOrientation = goVert then Inc(iKB);
        end;
        if AOrientation = goHorz then Inc(iKB);
    end;
    ACanvas.Draw(ARect.Left  , ARect.Top , Buffer);
    Buffer.Free;
end;

procedure TGradientMat.LoadFromFile(FileName : string);
var FGD : TIniFile;
begin
  if FileExists(FileName) then begin
     FGD := TIniFile.Create(FileName);
     try
       fGradientName     := FGD.ReadString ('Header', 'Name',    '(UnNamed gradient)');
       fGradientVersion  := FGD.ReadInteger('Header', 'Version', 0);
       if fGradientVersion <> GRADIENT_VERSION then
          MessageDlg('La version du fichier differe de la version en cours!'+#13+#10+
                     'Il se peut que le dégradé ne s''affiche pas correctement.',mtWarning,[mbOk],0);
       fLightAngle       := FGD.ReadFloat('Params','LightAngle',0.0);
       fIntensity.RGB    := FGD.ReadInteger('Intensity', 'RGB',    0);
       fIntensity.Factor := FGD.ReadFloat  ('Intensity', 'Factor', 1.0);
       fIntensity.Value  := FGD.ReadFloat  ('Intensity', 'Value',  0);
       fColor.RGB        := FGD.ReadInteger('Color', 'RGB',    0);
       fColor.Range      := FGD.ReadInteger('Color', 'Range',  1);
       fColor.Factor     := FGD.ReadFloat  ('Color', 'Factor', 1.0);
       fColor.R          := byte(FGD.ReadInteger('Color', 'Red',    0));
       fColor.G          := byte(FGD.ReadInteger('Color', 'Green',  0));
       fColor.B          := byte(FGD.ReadInteger('Color', 'Blue',   0));
     finally
       FGD.Free;
       Change;
     end;
  end;
end;


Procedure TGradientMat.SaveToFile(FileName : string);
var FGD : TIniFile;
begin
  FGD := TIniFile.Create(FileName);
  try
    FGD.WriteString ('Header', 'Name', fGradientName);
    FGD.WriteInteger('Header', 'Version', GRADIENT_VERSION);
    FGD.WriteFloat('Params','LightAngle',fLightAngle);
    FGD.WriteInteger('Intensity', 'RGB', fIntensity.RGB);
    FGD.WriteFloat  ('Intensity', 'Factor', fIntensity.Factor);
    FGD.WriteFloat  ('Intensity', 'Value',  fIntensity.Value);
    FGD.WriteInteger('Color', 'RGB',    fColor.RGB);
    FGD.WriteInteger('Color', 'Range',  fColor.Range);
    FGD.WriteFloat  ('Color', 'Factor', fColor.Factor);
    FGD.WriteInteger('Color', 'Red',    fColor.R);
    FGD.WriteInteger('Color', 'Green',  fColor.G);
    FGD.WriteInteger('Color', 'Blue',   fColor.B);
  finally
    FGD.Free;
  end;
end;

end.

Commentaire de shining le 18/04/2006 16:08:32

c'est bien beau un TIni mais hélas ce dernier ne permet pas un chargement depuis le resource !!!, il fraudrait enregistrer le fichier dans le DD puis l'ouvrir !! contrairement à la Structure de type "Record" !!!

TSfcFastGradient  <=== ce composant ce charge du rendu d'un gradient il ne doit pas avoir des propriétés telles ceux qui tu as mis dans TGradientMat <== et en plus ya une grosse confusion ce n'est pas un matériel !!!  tu nous fait un mixage de tout mdr, et en plus si chaque gradient devait avoir son propre renderer quel gaspillage de code !!!
car à chaque nouvelle instance de TGradientMat Delphi va copier tout le code de ce dernier !!!

et Sfc c'est pour Shining Freeman Component ça evite tout conflit avec des composants existant !!!

Concernant le problème de division par zero il faudrait retirer la fonction qui affiche en temps réel mais là on perd quant à la recherche d'un dégradé precis en jouant avec les valeurs !!!

if not FBeginUpdate then  <=== ça fait débutant ?? quoi de plus normal pour un débutant ;)

concernant le problème de conflit avec FindNext ect.. j'ai Delphi6 et jamais eu de problème avec ça !!!

maintenant concernant la modification des gradients plutôt que d'emcombrer le composant avec des propriétés publiées(TPersistent) il vaudrait mieux laisser cette tâche à l'inspecteur d'objet via un Package dédier au design !!! là au moins le code ne sera pas compiler dans l'exe !!!
le but c'est quand même de ne pas créer d'instance d'un Gradient et de permettre un Rendu avec un Simple Record même si c'est un peu galère lors d'une eventuelle mise à jour c'est pour cette raison qu'il faudra une structure flexible un peu comme celle de PaintShopPro !!

Commentaire de f0xi le 19/04/2006 00:45:44 administrateur CS

Remoi, toujours pour le bug FindClose que j'ai chez moi ...
je crois savoir precisement de ou il vient mais d'abord tu vas comparer ces deux declarations de clause uses :

chez moi (la plupart du temps) :

uses SysUtils, Windows , ... ;

chez toi :

uses Windows, ..., SysUtils, ... ;

ne remarque tu rien de particulier ?

et oui tu as bien deviné, je declare toujours SysUtils en premier et toi tu declare Windows en premier.
donc je pense et suis fortement sur que quand le compilateur cherche "FindClose" il cherche de la premiere a la dernier unités dans les uses et ne prend en compte que la derniere fonction trouvée (portée plus forte).

chez toi il tombe sur SysUtils aprés windows donc il prend bien en compte la bonne methode FindClose.
chez moi, totalement l'inverse, il tombe sur windows aprés sysutils donc prend la methode FindClose de l'unité windows ce qui provoque mon erreur.

c'est con hein ?!

au moins, ça m'aurat permis de decouvrir enfin pourquoi j'avais eu cette erreur auparavant, des fois oui, des fois non ...

Commentaire de f0xi le 20/04/2006 04:23:47 administrateur CS

re shinning!

alors oui hein, ne prend jamais mal mes commentaires, la plupart du temps, si je m'interresse de si prés a un code c'est qu'il m'interresse donc ... c'est a prendre comme un bon point ...
meme si je critique, c'est toujours dans le but de resoudre les erreurs probables ... de maniere objective et constructive, trouver les meilleures solutions.

pour le INI , alors la, demande a florenth le plaisir que tu me fait a mettre un bench de comparaison, y'a pas photo, ta methode est la meilleure, mais ça je le savais deja.

mais je persiste a croire qu'il y a une bonne possibilitée d'ecrire un trés bon manager pour les dégradés, ma methode est peut etre un peu lourde pour cela.

en fait, ce dont a quoi je pense ce serait de pouvoir integré facilement l'objet dégradé dans des composants, comme des panels, des bouttons etc...

je vois une structure de ce type :

[[gradient item] gradient list] --- > [[gradient manager] composant,canvas]

Gradient Item contient les informations du dégradé
Gradient List contient plusieurs Gradient Item et s'occupe du chargement/sauvegarde des gradient item
Gradient Manager s'occupe du dessin du dégradé


pour le Gradient List, il faudrait modifier le Header et ajouter un parametre :

TGradientHeader = record
Header    : array[0..3] of Char;
Version   : array[0..5] of Char;
//--[remove to gradient struct) Name      : array[0..55] of Char;
ItemCount : word; {0..65535}
end;

la lecture de ItemCount permettras de repeter l'operation de lecture des item et de faire par exemple :
GradientList.Add(GradientItem);

la structure de GradientItem deviendrais :

TGradientTemplate = record
  Intensity  : TGradientIntensity;
  Color      : TGradientColor;
  LightAngle : single;
  Name       : array[0..55] of char;
end;

et pour l'item

TGradientItem = class(TCollectionItem)
private
  fTemplate : TGradientTemplate;
  fOnChange : TNotifyEvent;
  function fGetFloat(index : integer) : single;
  procedure fSetFloat(index : integer; val : single);
  function fGetInteger(index : integer) : integer;
  procedure fSetInteger(index : integer; val : integer);
  function fGetByte(index : integer) : byte;
  procedure fSetByte(index : integer; val : byte);
  function fGetName : string;
  procedure fSetName(val : string);
  procedure Change; virtual;
protected
  property OnChange : TNotifyEvent read fOnChange write fOnChange;
published
  property GradientName    : string read fGetName write fSetName;
  property IntensityRGB    : Integer index 0 read fGetInteger write fSetInteger;
  property ColorRGB        : Integer index 1 read fGetInteger write fSetInteger;
  property ColorRange      : Integer index 2 read fGetInteger write fSetInteger;
  property IntensityFactor : Single index 0 read fGetFloat write fSetFloat;
  property IntensityValue  : Single index 1 read fGetFloat write fSetFloat;
  property ColorFactor     : Single index 2 read fGetFloat write fSetFloat;
  property LightAngle      : Single index 3 read fGetFloat write fSetFloat;
  property ColorR          : Byte index 0 read fGetByte write fSetByte;
  property ColorG          : Byte index 1 read fGetByte write fSetByte;
  property ColorB          : Byte index 2 read fGetByte write fSetByte;
public
  constructor create(...); override;
end;

qu'en pense tu ?

Commentaire de cantador le 21/04/2006 14:52:25

N'oubliez pas de jeter un oeil sur le TjvgBevel et Le
TjvGradient de JEDI.
C'est vrai il n'y pas les boutons ni les labels..

ça serait bien en effet un petit compo qui se loggerait direct sur ces objets et permettrait l'apparition de dégradés.

Commentaire de shining le 24/04/2006 21:35:42

le SpinEdit à été mise à jour !! j'ai rectifié le problème des caractères "lettre" car avant on pouvait taper "Z" et on avait une belle exception !!!, j'ai aussi rajouter dans la demo une petite fenêtre qui montre la couleur d'origine ça peut toujours servir !!!

Commentaire de shining le 25/04/2006 18:54:58

Salut Cirec,
bah je viens de télécharger le zip et ça compile correctement et j'ai la même chose que dans le Screenshot donc no problemo !!!

Maintenant je ne sais pas si tu as schtroumpfé quelque chose avec soit les fichiers *.dof, *.cfg(il ne faut pas les effacés !!!), soit le fichier des dégradés en principe tu dois avoir un repertoire "Exe\" qui contient Demo.exe puis un sous repertoire "Gradients\" qui contient "Gradients.fgd" <== tous les dégradés se trouvent désormais dans ce même fichier, il ne faut surtout pas mettre les autres dégradés dans ce rep car il scan tout le rep et il risque d'y avoir des duplications de noms !!!

concernant le Skinneur il est inutile de chosir dans la liste le dégadé que tu veux car j'ai fait des tests en y mettant ma propre selection !!! il suffit donc de cliquer sur "TestSkin"
donc assure toi que tu as bien ces fichiers dans ton rep 'Exe', par ce que là

concernant le bot c'est rien, c'est juste quelques lignes de codes qui evite les trucs répétitifs !!!
@+

Commentaire de shining le 27/04/2006 20:53:36

ah okay  bah là ya toujours pas de protection contre les mauvaises versions lol c'est pour ça, maintenant les fichiers *.dof & *.cfg contiennent les repertoires de sortie donc si tu les vires et que l'exe et le gradient se trouve dans le même rep ya pas de problème !!, bon essaie d'installer le designer et dit moi si ça marche !!!
@+