REALISER UN DEGRADE SUR PLUSIEURS COULEURS AVEC LES API WINDOWS
Nicolas___
Messages postés
992
Date d'inscription
jeudi 2 novembre 2000
Statut
Membre
Dernière intervention
24 avril 2013
-
28 janv. 2006 à 16:29
cincap Messages postés 460 Date d'inscription dimanche 5 décembre 2004 Statut Membre Dernière intervention 6 avril 2009 - 20 nov. 2008 à 16:22
cincap Messages postés 460 Date d'inscription dimanche 5 décembre 2004 Statut Membre Dernière intervention 6 avril 2009 - 20 nov. 2008 à 16:22
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/35784-realiser-un-degrade-sur-plusieurs-couleurs-avec-les-api-windows
https://codes-sources.commentcamarche.net/source/35784-realiser-un-degrade-sur-plusieurs-couleurs-avec-les-api-windows
20 nov. 2008 à 16:22
Merci,
@+,
Cincap
20 nov. 2008 à 16:11
j'ai mis le Zip à jour (il y a encore d'autres petites corrections ;))
en fait FCouleur est initialisé à 0
donc quand tu choisis une brique de couleur noir (0) le code n'est pas executé puisqu'il n'y a pas de différence entre Value et FCouleur :
if FCouleur <> Value then
begin
FCouleur := Value;
Brush.Color := Value;
Invalidate;
end;
20 nov. 2008 à 15:45
@Cirec, merci d'avoir répondu, j'avais ajouté cette ligne ce qui me semble quif quif.
Procedure Tfrm_Color.AddBrique(Value: TColor);
Begin
if value = $00000000 then value := value + 1 ;
@+,
Cincap
20 nov. 2008 à 15:20
FCouleur := -1;
voilà c'est tout
20 nov. 2008 à 07:38
@ Cirec, bon c'est OK, j'ai trouvé une parade qui fonctionne correctement.
@+,
Cincap
19 nov. 2008 à 17:34
@ Cirec, avec Delphi 6 c'est correct, génial et le code bien structuré.
Après test, en ajoutant une brique de couleur noire, la brique apparaît en blanc, il faut choisir une brique d'une autre couleur puis modifier la couleur en noir avec le click droit et cela fonctionne.
Voila voilou, il y a peut être une raison.
@+,
Cincap
8 mai 2008 à 19:21
Je n'ai pas encore eu le temps de regarder le code, mais le résultat est magnifique. Je sens que cela va me servir...
Bravo.
4 mai 2008 à 17:25
Normalement tout est dans l'unité Gradients.pas il n'y a rien d'autre à déclarer ... et le code a été testé Ok sous D4 D7 D9 D10(Turbo Delphi)
c'est pour ça que je te demande de m'envoyer l'unité à coup sûr tu as fait ça pour rien ^^
l'intérêt du code était justement de pouvoir réaliser des dégradés sur plusieurs couleurs mais tu peux aussi en "sélectionner" que deux
4 mai 2008 à 17:02
j'ai juste un peu arrangé le code, qui beugeait un petit peu pour moi. Et puis j'ai bloqué les dégradés horizon/vertical avec 1 seule couleur, et les dégradés triangulaires avec moins de 4 couleurs (il est coupé).
C'est tout pour l'unité.
Et j'ai essayé de faire une application autour de ca aussi.
C'est dommage qu'on puisse pas faire de dégradé polygonal, et circulaire ... Il doit exister un moyen de le faire, je vais me renseigner :)
Ce code m'a redonné le gout de la programmation graphique :)
Cordialement, Bacterius !
4 mai 2008 à 16:44
je suis curieux de savoir ce que tu as mis dans ton unité ?
envoie moi le code sur ma boite Mail (tu as l'adresse)
ensuite faire un composant ne me parait pas être utile ...
En ce concerne la création de composants regarde les tutoriels.
Mais je pense que c'est encore trop tôt pour toi .. il te faut d'abord acquérir certaine bases avant de te lancer dans la création de composant.
3 mai 2008 à 22:10
Sinon j'en ai fait une unité, que j'ai mis dans le dossier delphi, je peux facilement faire des bôs dégradés maintenant merci beaucoup Cirec pour ce joli code :)
Cordialement, Bacterius !
3 mai 2008 à 21:17
je voulais juste dire que depuis que j'ai Delphi 6, je me suis souvenu de cette source, et j'étais loin de penser que c'était aussi BEAU ^^
Je vais essayer d'en faire un composant, ca peut être bien joli :)
Cordialement, Bacterius !
4 janv. 2007 à 19:09
Superbe source ! J'applaudis des 2 mains et des 2 pieds !
Bravo ! :)
2 mai 2006 à 14:07
que ferions nous sans une équipe soudée...
super le programe ,
Idefix
22 avril 2006 à 10:51
ce n'est pas plus difficile que de charger une image dans le picture puisqu'il te suffit d'appeler la procédure avec les bons paramètres
@+
jlen
22 avril 2006 à 10:32
il y a déjà la réponse à ta remarque je cite:
" Quand tu utilises un TImage pour afficher un Bmp, tu es au courant qu'il y a des dizaines
de lignes de codes derrière et que même si tu les as pas écrite elles sont quand
même "embarquées" dans ton application."
ensuite essaye de faire la même chose en dynamique avec un TImage et reviens nous dire le résultat
@+
jlen
24 mars 2006 à 21:44
@+
jlen
24 mars 2006 à 21:35
tu me rassures je commençais à penser que je l'avais rêvé ce post.
En effet il a remis le couvert, peut être qu'un jour il comprendra le but des commentaires sur CS.
En tout cas c'est allé vite cette fois (compte tenu que je n'ai pas fait de demande de suppression et je ne pense pas qu'il y ait eu une).
Du coup mon précédent post est un peut perdu sans réel raison d'être :)
Enfin bon c'est pas grave.
@+
Cirec
24 mars 2006 à 21:07
Wolf a encore fait des siennes (son commentaire a été supprimé mais j'ai eu le temps de le lire) C'est le spécialiste des posts hors sujet : celà ne mérite même pas la peine d'y répondre. Un jour peut-être il comprendra que les commentaires ou critiques ont pour but d'améliorer les sources et que les critiques sans fondements n'apportent rien
@+
jlen
24 mars 2006 à 20:51
Quand tu utilises un TImage pour afficher un Bmp, tu es au courant qu'il y a des dizaines de lignes de codes derrière et que même si tu les as pas écrite elles sont quand même "embarquées" dans ton application.
Ici c'est la même chose :
Tu déclares l'unité "Gradients" une fois pour toute dans les "Uses" et la fonction s'utilise en une seule ligne.
En faite l'unité "Gradients" à été crée pour réduire l'utilisation de la fonction "GradientFill" à un seule ligne de commande (à l'origine elle demande au minimum une dizaine de lignes)
Il n'y a pas plus simple que ça! Les autres unités ne sont la que pour l'exemple.
Maintenant si tu arrives à faire la même chose ("Dégradé, vertical, horizontal, triangulaire sur plusieurs couleurs avec fondu entre les couleurs") et le tout avec moins de code alors je te tire mon chapeau. Mais je demande à voir d'abord.
Je pense également que si tu avais pris la peine de regarder le fonctionnement de la fonction "GragientFill" tu aurais eu un autre avis sur le sujet.
@+
Cirec
19 févr. 2006 à 19:41
du coup toute l'unité a été réécrite mais je vous laisse
pour l'instant l'ancienne version en commentaire pour pouvoir voir et comprendre
ce qui a été fait.
Le bug découvert par Jlen est également corrigé.
J'ai l'impression que les performances d'affichage sont meilleurs, a vous de juger.
Dites moi ce que vous en pensez.
@+
Cirec
19 févr. 2006 à 16:49
If Length(TriShape) = 0 Then Exit;
NBrique := -1; // Ajouté
For I := 0 To High(TriShape) Do
If TriShape[I].Selected Then NBrique := I;
If nBrique = -1 Then Exit; // et ajouté
TriShape[NBrique].Free;
et le problème à disparue
dès que tout serat au point je posterai une nouvelle mise à jour
je retourne aux testes sur les propositions de F0xi.
@+
Cirec
19 févr. 2006 à 16:40
je vais verifier tout ça et je te tiens au courrant.
@ F0xi
premiere modification testé j'ai été obligé d'apporté un petit changement si non il refusait de compiler :
// le nom de cette procedure est passé de GRect à GrdRect
// puisqu'il y avait confusion par le compilateur dans la procedure GradientRect avec
// le tableau dynamique gRect
procedure GrdRect(out aGR : TGRADIENTRECT; const aUL,aLR : cardinal);
begin
aGR.UpperLeft := aUL;
aGR.LowerRight:= aLR;
end;
Function GradientRect(Dc: THandle; ColorArray: Array Of TColor; aRect: TRect; Direction: Integer): Boolean;
Var Idx, aHeight, aWidth, nbCycle,pX,pY : Integer;
Vert : Array Of TTrivertEx;
gRect : Array Of TGRADIENTRECT;
Begin
nbCycle := Length(ColorArray);
SetLength(Vert, nbCycle);
SetLength(gRect, nbCycle - 1);
aHeight := GetRectHeight(aRect);
aWidth := GetRectWidth(aRect);
PX := 0;
PY := 0;
For Idx := 0 To High(Vert) Do begin
Case Direction Of
GRADIENT_FILL_RECT_V : Begin
If Idx Mod 2 = 0 Then pX := 0 Else pX := aWidth;
pY := Round(aHeight / (nbCycle - 1) * Idx);
End;
GRADIENT_FILL_RECT_H : Begin
If Idx Mod 2 = 0 Then pY := 0 Else pY := aHeight;
pX := Round(aWidth / (nbCycle - 1) * Idx);
End;
End;
TriVertexP(Vert[Idx],PX,PY, ColorArray[Idx]);
End;
For Idx := 0 To High(gRect) Do
GrdRect(gRect[Idx],Idx,Idx + 1);
Result := GradientFill( Dc, PTRIVERTEX(vert), nbCycle, PGradientRect(gRect), nbCycle-1, Direction);
End;
et les deux fonctions : GetRectHeight et GetRectWidth sont inconue mais bon c'est pas un problème c'est fait et ça fonctionne.
Je teste la suite et je reviens vous en dire plus
@+
Cirec
19 févr. 2006 à 15:30
pour l'erreur lors de la suppression cela ce produit aussi sous toutes version (enfin sous lesquelles j'ai pu tester : D6, D7,D9) quand on fait un click droit en dehors des carrés et que l'on fait "supprimer" le debugger renvoie à la ligne:
TriShape[NBrique].Free;
@+
jlen
19 févr. 2006 à 15:02
Merci de t'être penché sur ma source.
Que dire ? wouaou ça fait beaucoup de changements d'un coup pour ma petite tête ;-)
je vais de ce pas tester le tout et dès que c'est fait je te tiens au courant.
une petite question toute fois :
Jlen ma signalé un problème dans la gestion des briques de couleurs sous D7, lors de la suppression d'une où plusieurs de ces briques (non mise à jour de l'affichage) et en retirant le fichier WinXP.res le problème serait résolue.
alors as-tu également ce genre de problème parce que moi j'ai aucun soucis à ce niveau
ni sous D4 ni sous D9 ?
@+
Cirec
19 févr. 2006 à 14:33
procedure GRect(out aGR : TGRADIENTRECT; const aUL,aLR : cardinal);
begin
aGR.UpperLeft := aUL;
aGR.LowerRight:= aLR;
end;
Function GradientRect(Dc: THandle; ColorArray: Array Of TColor; aRect: TRect; Direction: Integer): Boolean;
Var Idx, aHeight, aWidth, nbCycle,pX,pY : Integer;
Vert : Array Of TTrivertEx;
gRect : Array Of TGRADIENTRECT;
Begin
nbCycle := Length(ColorArray);
SetLength(Vert, nbCycle);
SetLength(gRect, nbCycle - 1);
aHeight := GetRectHeight(aRect);
aWidth := GetRectWidth(aRect);
PX := 0;
PY := 0;
For Idx := 0 To High(Vert) Do begin
Case Direction Of
GRADIENT_FILL_RECT_V : Begin
If Idx Mod 2 = 0 Then pX := 0 Else pX := aWidth;
pY := Round(aHeight / (nbCycle - 1) * Idx);
End;
GRADIENT_FILL_RECT_H : Begin
If Idx Mod 2 = 0 Then pY := 0 Else pY := aHeight;
pX := Round(aWidth / (nbCycle - 1) * Idx);
End;
End;
TriVertexP(Vert[Idx],PX,PY, ColorArray[Idx]);
End;
For Idx := 0 To High(gRect) Do
GRect(gRect[Idx],Idx,Idx + 1);
Result := GradientFill( Dc, PTRIVERTEX(vert), nbCycle, PGradientRect(gRect), nbCycle-1, Direction);
End;
19 févr. 2006 à 14:23
modification de la structure _TRIVERTEX :
_TRIVERTEX = Packed Record
X,Y : Longint;
Red, Green, Blue, Alpha: COLOR16;
End;
on aurait egalement pus faire :
_TRIVERTEX = Record
Coord : TPoint;
Red, Green, Blue, Alpha: COLOR16;
End;
_________________________________________
Ajout de methodes pour le type TTRIVERTEX :
procedure PointTVX(out TVX : TTriVertex; const aX,aY : LongInt); forward;
Procedure ColorTVX(out TVX : TTriVertex; const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0); overload; forward;
Procedure ColorTVX(out TVX : TTriVertex; const aCol : TColor; const aAlpha : COLOR16 = 0); overload; forward;
procedure TriVertexP(out TVX : TTriVertex; const aX,aY : LongInt;const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0); overload; forward;
procedure TriVertexP(out TVX : TTriVertex; const aX,aY : LongInt;const aCol : Tcolor; const aAlpha : COLOR16 = 0); overload; forward;
function TriVertexF(const aX,aY : LongInt;const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0) : TTriVertex; overload; forward;
function TriVertexF(const aX,aY : LongInt;const aCol : Tcolor; const aAlpha : COLOR16 = 0) : TTriVertex; overload; forward;
// permet de definir rapidement les coordonées
procedure PointTVX(out TVX : TTriVertex; const aX,aY : LongInt);
begin
TVX.X := aX;
TVX.Y := aY;
end;
// permet de definir rapidement la couleur
Procedure ColorTVX(out TVX : TTriVertex; const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0);
begin
With TVX do begin
Red := aRed;
Green := aGreen;
Blue := aBlue;
Alpha := aAlpha
end;
end;
// en incluant les traitements
Procedure ColorTVX(out TVX : TTriVertex; const aCol : TColor; const aAlpha : COLOR16 = 0);
begin
With TVX do begin
Red := GetRValue(aCol) Shl 8;
Green := GetGValue(aCol) Shl 8;
Blue := GetBValue(aCol) Shl 8;
Alpha := aAlpha
end;
end;
// permet de definir rapidement un element TTriVertex
procedure TriVertexP(out TVX : TTriVertex; const aX,aY : LongInt;const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0);
begin
PointTVX(TVX,aX,aY);
ColorTVX(TVX,aRed,aGreen,aBlue,aAlpha);
end;
procedure TriVertexP(out TVX : TTriVertex; const aX,aY : LongInt;const aCol : TColor; const aAlpha : COLOR16 = 0);
begin
PointTVX(TVX,aX,aY);
ColorTVX(TVX,aCol,aAlpha);
end;
function TriVertexF(const aX,aY : LongInt;const aRed,aGreen,aBlue : COLOR16; const aAlpha : COLOR16 = 0) : TTriVertex;
begin
PointTVX(result,aX,aY);
ColorTVX(result,aRed,aGreen,aBlue,aAlpha);
end;
function TriVertexF(const aX,aY : LongInt;const aCol : TColor; const aAlpha : COLOR16 = 0) : TTriVertex;
begin
PointTVX(result,aX,aY);
ColorTVX(result,aCol,aAlpha);
end;
_________________________________________
ajout de methode pour TGRADIENTTRIANGLE :
procedure GradientTriP(out aGT : TGRADIENTTRIANGLE; const Vx1, Vx2, Vx3 : cardinal);
begin
aGT.Vertex1 := Vx1;
aGT.Vertex2 := Vx2;
aGT.Vertex3 := Vx3;
end;
function GradientTriF(const Vx1, Vx2, Vx3 : cardinal) : TGRADIENTTRIANGLE;
begin
result.Vertex1 := Vx1;
result.Vertex2 := Vx2;
result.Vertex3 := Vx3;
end;
_________________________________________
Ajout de methodes pour le type TGRADIENTRECT :
procedure GradientRect(out aGR : TGRADIENTRECT; const aUL,aLR : cardinal);
begin
aGR.UpperLeft := aUL;
aGR.LowerRight:= aLR;
end;
_________________________________________
Modifications en consequence :
{ **** }
Function GradientRect(Dc: THandle; ColorArray: Array Of TColor; aRect: TRect; Direction: Integer): Boolean;
Var Idx, aHeight, aWidth, nbCycle,pX,pY : Integer;
Vert : Array Of TTrivertEx;
gRect : Array Of TGRADIENTRECT;
Begin
nbCycle := Length(ColorArray);
SetLength(Vert, nbCycle);
SetLength(gRect, nbCycle - 1);
aHeight := GetRectHeight(aRect);
aWidth := GetRectWidth(aRect);
PX := 0;
PY := 0;
For Idx := 0 To High(Vert) Do begin
Case Direction Of
GRADIENT_FILL_RECT_V : Begin
If Idx Mod 2 = 0 Then pX := 0 Else pX := aWidth;
pY := Round(aHeight / (nbCycle - 1) * Idx);
End;
GRADIENT_FILL_RECT_H : Begin
If Idx Mod 2 = 0 Then pY := 0 Else pY := aHeight;
pX := Round(aWidth / (nbCycle - 1) * Idx);
End;
End;
TriVertexP(Vert[Idx],PX,PY, ColorArray[Idx]);
End;
For Idx := 0 To High(gRect) Do
GradientRect(gRect[Idx],Idx,Idx + 1);
Result := GradientFill( Dc, PTRIVERTEX(vert), nbCycle, PGradientRect(gRect), nbCycle-1, Direction);
End;
{ **** }
Procedure InitTriSequence;
Var I : Integer;
Begin
For I := 1 To High(TriSequence) Do Begin
SetLength(TriSequence[I], I);
End;
For I := 1 To 8 Do Begin
if I in [1..8] then GradientTriP(TriSequence[I][0],0,1,2);
if I in [2,6..8] then GradientTriP(TriSequence[I][1],0,2,3);
if I in [3..5] then GradientTriP(TriSequence[I][1],1,2,3);
if I in [4..8] then GradientTriP(TriSequence[I][2],2,3,4);
if I in [5..8] then GradientTriP(TriSequence[I][3],2,4,5);
if I in [6..8] then GradientTriP(TriSequence[I][4],2,5,6);
if I in [7,8] then GradientTriP(TriSequence[I][5],2,6,7);
if I in [3,4] then GradientTriP(TriSequence[I][I-1],0,2,4);
if I in [5..8] then GradientTriP(TriSequence[I][I-1],0,2,I);
End;
GradientTriP(TriSequence[8][6],2,7,8);
End;
{ **** }
Procedure GetVertPos(Var Vert: Array Of TTrivertEx; aRect: TRect);
Var nbCycle, aHeight, aWidth: Integer;
Begin
aHeight := GetRectHeight(aRect);
aWidth := GetRectWidth(aRect);
nbCycle := Length(Vert);
PointTVX(Vert[0],aRect.Left,aRect.Top);
if nbCycle IN [3..5] then begin
PointTVX(Vert[1],aRect.Right,aRect.Top);
end;
if nbCycle IN [3..4] then begin
PointTVX(Vert[2],aRect.Right,aRect.Bottom);
end;
if nbCycle IN [5..9] then begin
PointTVX(Vert[2],aWidth Div 2,aHeight Div 2);
end;
if nbCycle IN [6..9] then begin
PointTVX(Vert[1],aWidth Div 2,aRect.Top);
PointTVX(Vert[3],aRect.Right,aRect.Top);
end;
if nbCycle IN [7..9] then begin
PointTVX(Vert[4],aRect.Right,aHeight Div 2);
PointTVX(Vert[5],aRect.Right,aRect.Bottom);
end;
if nbCycle IN [8..9] then begin
PointTVX(Vert[6],aWidth Div 2,aRect.Bottom);
PointTVX(Vert[7],aRect.Left,aRect.Bottom);
end;
if nbCycle = 4 then
PointTVX(Vert[3],aRect.Left,aRect.Bottom);
if nbCycle = 5 then begin
PointTVX(Vert[3],aRect.Right,aRect.Bottom);
PointTVX(Vert[4],aRect.Left,aRect.Bottom);
End;
if nbCycle = 6 then begin
PointTVX(Vert[4],aRect.Right,aRect.Bottom);
PointTVX(Vert[5],aRect.Left,aRect.Bottom);
End;
if nbCycle = 7 then
PointTVX(Vert[6],aRect.Left,aRect.Bottom);
if nbCycle = 9 then begin
PointTVX(Vert[6],aWidth Div 2,aRect.Bottom);
PointTVX(Vert[8],aRect.Left,aHeight Div 2);
End;
End;
{ **** }
Function GradientTriangle(Dc: THandle; ColorArray: Array Of TColor; aRect: TRect): Boolean;
Var Idx, nbCycle, NbTriCycle: Integer;
Vert : Array Of TTrivertEx;
Begin
nbCycle := Length(ColorArray);
If NbCycle > 9 Then NbCycle := 9;
SetLength(Vert, nbCycle);
GetVertPos(Vert, aRect);
For Idx := 0 To High(Vert) Do
ColorTVX(Vert[Idx],ColorArray[Idx]);
If NbCycle > 4 Then
NbTriCycle := NbCycle - 1
Else
NbTriCycle := NbCycle - 2;
GradientFill(dc, PTRIVERTEX(vert), NbCycle,
PGRADIENTTRIANGLE(TriSequence[NbTriCycle]), NbTriCycle, GRADIENT_FILL_TRIANGLE);
End;
voila pour celle ci au niveau optimisation / completion, tu remarqueras que tous les ajouts de methodes ne sont pas utilisés.
je les ais laissés juste a titre d'exemple.
d'ailleur je conseil a tout le monde qui voudrais créer une petite ou grande structure "record"
de creer egalement les fonctions/procedure permettant d'ameliorer et optimiser le code, exemple :
TIdentity = record
nom,prenom : string;
DdN : tdatetime;
end;
procedure Identity(out aID : TIdentity; const aNom,aPrenom : string; cont aDdN : TDateTime);
begin
aID.nom := aNom;
aID.prenom := aPrenom;
aID.DdN := aDdN;
end;
cela permet d'augementer la rapiditée d'ecriture de code et egalement d'alleger celui ci.
18 févr. 2006 à 03:21
J'ai réalisé l'implémentation de la fonction GradientTriange plus quelques petites modifications voir plus haut. A ce propos j'en appel à vos lumières si vous avez une idée pour rationaliser le code, parce que la je sèche un peut ;-) Pour plus d'informations voir l'historique des mises à jour. D'avance Merci.
@+
Cirec
30 janv. 2006 à 21:09
sur un crt chaque pixel posséde 3 lumiphores exités par le flux d'électrons et en fait ce flux ou plutot le flux secondaire emis exite les lumiphores adjacents ce qui produit une sorte de "flou"
alors de dans les TFT ou les LCD chaque pixel est activé par la matrice.
tout ce passe comme si dans une image on passait directement d'une couleur à une autre sans zone de transition (exemple d'une image détourée mise sur un fond uni: l'effet n'est pas naturel) c'est pour cela que les logiciel de retouche photo procede à un dégradé de la zone de transition.
comme quoi le mieux est l'ennemi du bien!!
@+
jlen
30 janv. 2006 à 20:50
Mais bon d'un autre coté sur la vidéo c'est génial la j'ai rien n'a dire où re-dire, il faut peut être passer à une qualité supérieur si c'est possible dans Delphi au niveau du mode d'affichage mais la ça me dépasse
@+
Cirec
30 janv. 2006 à 20:34
que sur un TFT Remarque aussi que le photos ont bien souvent un meilleurs rendu sur un crt (saturation des couleurs moins importante)
@+
jlen
30 janv. 2006 à 20:27
Merci à toi Nicolas__ pour ton commentaire et pour tes informations qui m'ont permis de faire les modifications nécessaires
pour info Ati redeon pro 9200 à 128 Mb DDR pour la carte vidéo
et comme elle a deux sortie j'ai deux écrans branchés dessus un crt et un lcd 19 pouces les deux et la qualité du dégradé je la trouve meilleur sur le vieux crt je m'explique
le fondu entre les couleurs et mieux fait plus doux.
@+
Cirec
30 janv. 2006 à 20:23
begin
Invalidate;
end;
------> Oui Oui tt a fait d acc av toi je pense que j ai ete un peu trop vite ...
Allez, Ciao et Re-Merci !
Nico
30 janv. 2006 à 20:11
pour le DoubleBuffered je suis entièrement d'accord avec toi (c'est fait) mais pour la suite seulement à moitié :
Le paramètre Sender ne peut pas être utiliser ici puisqu'il sera forcement Form1 et non un radiobutton et l'appel a la fonction GradientRect est ici inutile puisque l'appel a Invalidate envoie WM_Paint à la Form donc l'évènement OnPaint est déclanché
Voici ce que j'ai mis et ça fonctionne bien.
procedure TForm1.FormCreate(Sender: TObject);
begin
DoubleBuffered := True;
end;
procedure TForm1.FormResize(Sender: TObject);
begin
Invalidate;
end;
Teste le et dis moi.
@+
Cirec
30 janv. 2006 à 18:53
Merci Cirec pour avoir transforme le code pour qu il soit compatible Delphi7.
Et ben en tt cas vraiment excellente cette fonction
Par contre tu peux mettre,
procedure TForm1.FormCreate(Sender: TObject);
begin
doublebuffered:=true;
end;
et
procedure TForm1.FormResize(Sender: TObject);
begin
Direction := TRadioButton(Sender).Tag;
Invalidate;
GradientRect(Canvas.Handle,[cllime, clblack, clYellow, clRed], ClientRect, Direction);
end;
Ca permet comme on le voit tres bien de pouvoir modifier la taille de la form en faisant tjs le degrader
Le doublebuffered c est pr le scintillement
J ai une ATIRadeon 9600 pro et un athlon 1800+(donc pas terrible) et ya pas de prob
29 janv. 2006 à 13:27
si tu veux le rafraichissement est instantané mais il persiste deux zones qui sont en retard (genre ~ moirage) mais je viens de tester sur un autre pc ou l'effet n'est partiquement persetible et sur le vieux compaq ce n'est plus perceptible.
je crois savoir la cause le PC sur internet est éqipé d'un écran TFT ancienne génération (~5ans) tandis que le compaq est équipé d'un CRT .
Conclusion : cela constitue un bon test sur la qualité de l'écran et/ou de la carte graphique!
@+
jlen
29 janv. 2006 à 13:07
Chez moi sur un P4 HT 3Ghz je ne remarque rien c'est immédiat ce qui ma un peut surpris je m'attendais justement à voir le rafraîchissement mais non c'est impeccable.
@+
Cirec
29 janv. 2006 à 12:59
@+
jlen
29 janv. 2006 à 12:42
Les modifications sont faites merci à vous deux
Il semblerait que les Dev de chez Borland aient fait des modifications sur certain type :
Color16 était déclaré comme Shortint alors que maintenant il semblerait qu'il soit de type Word.
Je l'ai testé Ok sur Delphi4.
Testez et tenez moi informé.
@+
Cirec
28 janv. 2006 à 17:16
l'inconvénientdu composant XPman c'est que quand il n'est pas supporté par la version il te fait une superbe erreur de compilation du genre unité pas trouvée!! ce qui n'est pas du meilleur effet.
@+
jlen
28 janv. 2006 à 16:58
Pour le reste je vais essayer de voir ce que ça donne avec Delphi4
désolé je n'ai pas D7 pour faire les testes, j'ai ma petite idée sur le problème.
Par contre pour aujourd'hui ce ne sera peut être plus possible je dois me sauver
mais dès que je revient je me penche dessus et posterai une mise à jour
28 janv. 2006 à 16:37
@+
jlen
28 janv. 2006 à 16:34
intéressant.
pas mal l'effet toutefois 2/3 petites choses pas trop grave:
sous D7 cela ne se compile pas :
[Erreur] Gradients.pas(78): Les types des paramètres VAR originaux et formels doivent être identiques
alors que cela ne pose pas de probleme sous D2005 (je n'est pas testé sous D6 entreprise qui n'est pas installé sur ce PC et non raccordé au réseau)
evite de mettre un XPman qui n'est pas supporté par les version<D7 je crois (j'ai trouvé la "ruse" : mettre un fichier ressources du genre XPManifest.res et mettre :{$R XPManifest.res}
) l'effet est identique et supporté par toute les versions.
une petite remarque dans le fonctionnement de la demo (peut être du à mon PC) l'effet n'est pas instantanné quand on change de mode( qqs secondes pour avoir une stabilisation complète des couleurs).
à+
jlen
28 janv. 2006 à 16:29
[Erreur fatale] UGradient_Demo.pas(30): Impossible de compiler l'unité utilisée 'Gradients.pas'
Dommage ca pouvait etre bien pratique ...
Ps:J ai delphi7 et winXP
Ciao
Nico