Discussion :

[Clorish]

Lors du dessin de mon composant, je souhaite me baser sur un bitmap que je copie la ou il faut.
Je voudrias bien sur que l'image en question soit inclue dans mon unitee.
Il me semble que les DCU n'uncluent pas des .res dans leur code ... il faut donc les deplacer avec.

Pouvez vous confirmer ce point ? et m'aider a trouver uen solition pour inclure une image sans Ressource ? genre avec les donnees binaire $XXXXXXXXXXXXXXX...XXXX tels que le fait Delphi dans les Dfm ....

[EDIT] Code complet solution du probleme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
unit StreamStr;
 
interface
 
Uses SysUtils, Classes;
 
{==============================================================================}
{  definition des procedures publiques  }
{==============================================================================}
 
Function StreamToStr(AStream : TStream) : String;
PRocedure  StrToStream(AString : String; AStream : TStream);
 
implementation
 
{==============================================================================}
{  StreamToStr : Transforme un stream en une chaine Hexadecimale  }
{==============================================================================}
 
Function StreamToStr(AStream : TStream) : String;
Var i : Integer;
    b : Byte;
Begin
Result := '';
For i := 1 to AStream.Size do
    Begin
    AStream.ReadBuffer(b, SizeOf(b));
    Result := Result + IntToHex(b, 2);
    End;
End;
 
{==============================================================================}
{  StrToStream : Cree un stream a partir d'une representation en chaine haxadecimale  }
{==============================================================================}
 
PRocedure  StrToStream(AString : String; AStream : TStream);
Var Index : Integer;
    b : byte;
    Size : Integer;
Begin
Size := Length(AString);
AStream.Size := Size div 2;
AStream.Position := 0;
Index := 1;
While Index+1 <= Size do
    Begin
    b := StrToInt('$' + AString[Index] + AString[Index+1]);
    AStream.Write(b, sizeof(b));
    Index := Index+2;
    End;
AStream.Position := 0;  // Replacement en debut de stream pour la manipulation.
End;

Programe utilitaire :
- Charger un fichier dans un Stream (LoadFromFile)
- Appeler StreamToStr
- Afficher la chaine dans un memo.

Programme gerant ce type de ressoruce :
- Copier la chaine du memo de l'utilitaire precedant.
- Coller la chaine dans uen focntion en l'affectant a la variable Result (pensez a decouper sur plusieurs lignes la chaine)
- A l'utilisation appeler StreamToStr
- Manipuler le Stream comme si il afait ete charge depuis un loadFromFile ou un LoadFromRessourceName.

Bonne Prog !

[Merlin]

un composant peut fort bien posséder des ressources graphiques linkée, il suffit de faire un fichier res et de le lier par la directive {$R <nom>}.
Ensuite il faut utilise dans le code les api pour retrouver la ressource et s'en servir.

[Clorish]

Oui ca je sais m'en servir .. je le fait bie nsouvent. D'ailleur les TRessourceStream sont tres bien poour ca.
PAr contre il me semble bien que le DCU n'inclue pas la ressource mais ne fait justement que la linker. Donc il faut fournir le DCU et le RES.

Je me lance dans la conception de pas mal de compos et j'aimerais eviter de trimbaler plein de fichiers res avec chacun de mes compos.
Deplus, comme le fait delphi, certains compos seront regroupper dans une meme unitee, et je ne peut pas fusionner les res ensemble, au cas ou je deplace un compos dans une autre unitee. Je me retrouverais donc avec pleisn de res associer a un fichier .. alors commetn savoir lesquels appartiennet auxquelles .... et etre sur de ne pas en oublier lors de la distribution des fichiers ...

En bref, je souhaiterais inclure tout le code de dessin dans l'unitee elle meme mais dessiner pixel par pixel l'image ne me plait gere non plus .... d'ou l'idee de l'inclure directement sous forme de variable binaire comme on peut les trouver dans les fichier DFM en mode texte, lorsqu'une image/logi/icone et chargee depuis le mode designe ...

[Tardiff Jean-François]

Bonnjour,

Si j'ai bien compris vous voudriez l'équivalent d'un TImage invisible dans votre unité.

Le problème est que TImage ne stoke pas l'image dans le fichier pas mais dans le dfm.

Si vous savez convertir votre image en base 64 vous pourriez la stocker en base 64 dans l'unité et la traduire à la volé (attention au temps de réponse).

[sjrd]

Attention, j'ai l'impression que tu crois que les dfm, eux, sont bien intégrés au dcu. Or ce sont des ressources aussi, comme le prouve le code suivant inclus dans toute unité de fiche :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

{$R *.dfm}

Donc soit tu fais un tableau constante soit c'est une ressource. Il n'y a pas d'autre possibilité.

[Clorish]

Attention, j'ai l'impression que tu crois que les dfm, eux, sont bien intégrés au dcu. Or ce sont des ressources aussi, comme le prouve le code suivant inclus dans toute unité de fiche :

Oui je le sais mais ce qui m'interessait est la maniere de l'ecrire .....
Pour moi une ressource est un fichier binaire ecrit en copiant les donnees binaires d'un fichier dans un autre (grossomodo) or avec ce systeme, j'ai vu qu'on pouvait en quelque sorte inclure le fichier binaire desire dans un fichier texte .... et c'est cela qui m'interesse.

Mon but etant de pouvoir ecire quelque part et sous forme texte le contenu d'un fichier binaire de maniere a ce que je puisse creer une variable initialisé avec cette "chaine" dans mon code et obtenir en memoire a l'execution une variable contenant donc la reprensetation de mon image telle qu'elle l'aurait ete apres un loadfromfile.

Donc soit tu fais un tableau constante soit c'est une ressource. Il n'y a pas d'autre possibilité.

Les ressources etant "out" comment on manipule les constantes dans ce cas precis ?

[sjrd]

Si tu veux coder en dur ton bitmap dans ton source, tu faire ceci :
Déclare un tableau de byte de taille égale au fichier du bitmap.
Puis tu rempli ce tableau en constante byte par byte de cette façon (l'hexadécimal rend la chose plus facile à lire) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
const
  MonBitmapEnTableau : array[1..TailleFichier] of Byte =
    ($00, $01, $AF, $5D, ...);

Je te conseille vivement de créer un tout petit programme à côté qui lit un fichier et le transforme dans sous cette forme

[Clorish]

Je te conseille vivement de créer un tout petit programme à côté qui lit un fichier et le transforme dans sous cette forme
Bien sur

et eventuelement il n'ets pas possible de le gerer de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Const MonBmp = $0001AF5D ....;

Par contre apres je peut l'utiliser comment : Avec uen double boucle for (et affectation des pixels) ou bien plus simplemente a l'aide d'afectation dans un objet canvas/Bitmap .. et des copyRect ?

Ha aussi : Je suppose que tu nemet que le code correspondant aux pixels ? ou le fichier entier ? (avec les entetes ....)

[sjrd]

et eventuelement il n'ets pas possible de le gerer de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Const MonBmp = $0001AF5D ....;

Non, car de quel type serait cette constante ?

Par contre apres je peut l'utiliser comment : Avec uen double boucle for (et affectation des pixels) ou bien plus simplemente a l'aide d'afectation dans un objet canvas/Bitmap .. et des copyRect ?

Dans mon idée, le but était de remplir un TMemoryStream avec le contenu de cette constante. Ca se fait en 3 lignes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Stream := TMemoryStream.Create;
Stream.Size := TailleFichier;
Stream.WriteBuffer(MonBmp, TailleFichier);

Ensuite, tu utilise TBitmap.LoadFromStream pour charger l'image dans un TBitmap

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Stream.Position := 0;
Bitmap := TBitmap.Create;
Bitmap.LoadFromStream(Stream);

Pour simplifier cette technique si tu as beaucoup d'images à charger de cette manière de coder cette routine :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure LoadBitmapFromConst(var Constant; Size : Int64; Bitmap : TBitmap);
var Stream : TStream;
begin
  Stream := TMemoryStream.Create;
  try
    Stream.Size := Size;
    Stream.WriteBuffer(Constant, Size);
    Stream.Position := 0;
    Bitmap.LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

Cette routine s'appelle de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Bitmap := TBitmap.Create;
LoadBitmapFromConst(MonBitmapEnTableau, TailleFichier, Bitmap);

Une variante, si tu ne veux pas devoir créer le bitmap avant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure LoadBitmapFromConst(var Constant; Size : Int64; out Bitmap : TBitmap);
var Stream : TStream;
begin
  Stream := TMemoryStream.Create;
  try
    Stream.Size := Size;
    Stream.WriteBuffer(Constant, Size);
    Stream.Position := 0;
    Bitmap := TBitmap.Create;
    Bitmap.LoadFromStream(Stream);
  finally
    Stream.Free;
  end;
end;

Qui s'appelle de la même façon que l'autre, mais qui ne nécessite pas de créer le bitmap avant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

LoadBitmapFromConst(MonBitmapEnTableau, TailleFichier, Bitmap);

Ha aussi : Je suppose que tu nemet que le code correspondant aux pixels ? ou le fichier entier ? (avec les entetes ....)

Avec la méthode que je viens de t'exposer, la méthode LoadFromStream ayant besoin de tout le contenu du fichier, oui tu dois coder de cette façon l'intégralité du fichier.

[Clorish]

Effectivement !!
L'idee de passer par un Stream n'est pas bete du tout.
Bonne idee a approfondire

Par contre je vois que tu utilise le parametre "out" je le vois souvent mais je n'ai pas encore compris son utilité en fait et la difference avec "Var" ... (en fait j'ai pas vraiement cherche non plus :$)

[sjrd]

Par contre je vois que tu utilise le parametre "out" je le vois souvent mais je n'ai pas encore compris son utilité en fait et la difference avec "Var" ... (en fait j'ai pas vraiement cherche non plus :$)

En fait c'est la même chose que var, mis à part le fait que mettre out indique au compilateur qu'on attend pas de valeur en entrée, et donc il peut optimiser le code.
De plus, sous les Delphi récents, cela évitera d'avoir sans arrêt des messages d'avertissements disant que la variable passée n'est peut-être pas initialisée : vu que le out spécifie justement qu'on attend pas de valeur en entrée, il sait que c'est normal que la valeur ne soit pas initialisée.

[Clorish]

Oki.
Bonne nouvelle !!
J'en ai marre de ces conseils a la noix je sais ce que je fait quand meme non !
Apres tout .. si je veux pas initialiser c'est bien qu'il y a une raison a cela ... non ?

[Clorish]

Bon ca y est je suis arrive a faire ce que je veux

Je ne donnerais pas le code ici car il est trop long et pas encore stabilisé mais l'algo est le suivant :

- Charger un fichier en memoire via un TMemoryStream.LoadFromFile.
- Pour tout i alant de 0 a TMemoryStream.Size faire :
- confertir l'octer en chaine hexa sur 2 chiffres et concatener a une chaine representative du fichier.
- Copier cette chaine dans un fichier (eventuelement la couper en plusieurs lignes).

Ainsi on optien dont une enorme chaine qui est la representation hexadecimale de notre fichier.

On peut donc maintenant ecrire le code proprement dit :
Affecter de maniere statique cette chaine a une variable String

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
s := '0001EFFF5F5CB6...';

Creer une petite fonction qui parcours la chaine 2 caracteres par 2 caracteres et qui converti ces 2 caracteres en byte (octets) pour les ecrire dans un Stream.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
Procedure StrToStream(s : String; M : TMemoryStream);
Var i : Integer;
    b : byte;
Begin
M.SetSize(Length(s) div 2);
i := 1;
While True do
    Begin
    if i+1 > Length(s) Then break;
    b := StrToInt('$'+s[i]+s[i+1]);
    M.Write(b, sizeof(b));
    i := i+2;
    End;
End;

Enfin ... manipuler le stream exactement comme un stream charge via loadfromfile ou loadfromressorucename......

Je ne saurais trop vous conseiller d'ecrire une methode "LoadMonBitmap" qui s'occupe de charger la chaine string dans un TStream .... histoire de pouvoir mettre les longues ligens de codes de cette procedure tout en bas de votre unitee pour ne pas gener dans l'implementation du reste de l'unitee.
Voire meme utiliser des fichiers Inc tres pratique pour separer le code de ces "ressources" sans genrer de fichier supplementaire lors de la compilation en DCU.


Bonne Prog!

[Clorish]

Code complet rajouté au premier post.
Merci a tous !