L'inclusion des fichiers comme des ressources dans une delphi exécutable

L'inclusion des fichiers comme des ressources dans une delphi executable

L'inclusion des fichiers comme des ressources dans une delphi executable : Plusieurs milliers de conseils pour vous faciliter la vie.

Vous pouvez apprendre comment creer votre propre logiciel pour n'importe quelle situation avec l'excellent Logiciels Exigences Dechaîne. Si vous avez besoin de savoir comment integrer des icones, des curseurs curseurs animes, des images, des images jpeg, des fichiers wave, fichiers texte et tout autre fichier a l'interieur d'un Delphi executable, il suffit de garder la lecture!

l'inclusion des fichiers comme des ressources dans une Delphi executable
Il est possible d'integrer n'importe quel type de fichier dans un fichier executable a l'aide de fichiers de ressources (*.RES). Certains types de ressources sont reconnus par l'API et peut etre utilise directement. D'autres sont simplement prises comme des donnees binaires et c'est a vous de les utiliser. Dans cet article nous allons voir des exemples de ces deux types.

Pour creer le fichier de ressources, nous commençons avec le fichier source (*.RC), par exemple les RESSOURCES nommees.RC, qui est un simple fichier texte qui contient les entrees de ressource (nom, la classe et le fichier):

sample_bmp BITMAP de l'echantillon.bmp

sample_ico ICONE de l'echantillon.ico

sample_cur CURSEUR de l'echantillon.cur

sample_ani ANICURSOR de l'echantillon.ani

sample_jpg JPEG sample.jpg

sample_wav d'ONDE de l'echantillon.wav

sample_txt TEXTE sample.txt
Les noms des ressources (sample_bmp, sample_ico, etc.) sont arbitraires. Le type de ressource peut etre reconnu par l'Api (BITMAP, ICONE, CURSEUR) ou arbitraires (JPEG, la VAGUE, le TEXTE). Les noms de fichier specifier les fichiers qui seront inclus dans le .Fichier RES (et plus tard dans le .EXE).

Maintenant, nous avons pour compiler le .Fichier RC pour produire de l' .Fichier RES. Pour cela, nous pouvons utiliser Borland Compilateur de Ressources (brcc32.exe) que vous pouvez probablement trouver dans Delphi dossier BIN. C'est un simple utilitaire de ligne de commande qui attend le nom de la source de fichier en parametre:

C:\DELPHI\P0025>brcc32 ressources

Borland Compilateur de Ressources Version 5.40

Copyright (c) 1990, 1999 Inprise Corporation. Tous droits reserves.

C:\DELPHI\P0025>_
Pour charger l'editeur de liens pour integrer le fichier de ressources dans le fichier executable, nous utilisons le fichier de ressources de la directive ($R $ou $ RESSOURCE) dans notre Pascal ource code:

{$R ressources.res}
Chargement des ressources dans votre application est facile pour l' 'se succedent dans le temps' des ressources comme BITMAP, ICONE, CURSEUR, depuis l'API Windows fournit des fonctions (LoadBitmap, LoadIcon et LoadCursor respectivement) pour obtenir les poignees de ces elements, que, par exemple, nous pouvons attribuer a la propriete Handle de l'objet correspondant:

Image1.Image.Bitmap.Poignee :=

LoadBitmap(hInstance, 'sample_bmp')

Icone.Poignee := LoadIcon(hInstance, 'sample_ico')

l'Ecran.Les curseurs[1] := LoadCursor(hInstance, 'sample_cur')
Pour plus d'alternatives lors du chargement de l'image des ressources, voir l'API LoadImage.

d'Autres ressources sont un peu plus difficiles a gerer. Commençons avec des images JPEG. La fonction suivante utilise TResourceStream pour charger la ressource comme un flux qui va etre charge dans un TJPEGImage objet:

la fonction GetResourceAsJpeg(const resname: string): TJPEGImage

var

Stream: TResourceStream

commencer

Stream := TResourceStream.Creer(hInstance, ResName, 'JPEG')

Resultat := TJPEGImage.Creer

Resultat.LoadFromStream(Stream)

enfin

Stream.Gratuit

fin

fin
Exemple:

var

Jpg: TJPEGImage

commencer

// ...

Jpg := GetResourceAsJpeg('sample_jpg')

Image2.Image.Bitmap.Attribuer(Jpg)

Jpg.Gratuit

// ...

fin
Pour les fichiers WAV nous avons besoin d'un pointeur vers la ressource charge en memoire, et un fichier texte nous avons besoin de charger une ressource dans une chaîne de caracteres. Nous pouvons le faire en utilisant TResourceStream, mais nous allons voir un exemple d'utilisation de l'API:

la fonction GetResourceAsPointer(ResName: pchar ResType: pchar

out Taille: longword): pointeur

var

InfoBlock: HRSRC

GlobalMemoryBlock: HGLOBAL

commencer

InfoBlock := FindResource(hInstance, resname, restype)

si InfoBlock = 0 alors

raise Exception.Creer(SysErrorMessage(GetLastError))

taille := SizeofResource(hInstance, InfoBlock)

si taille = 0, alors

raise Exception.Creer(SysErrorMessage(GetLastError))

GlobalMemoryBlock := LoadResource(hInstance, InfoBlock)

si GlobalMemoryBlock = 0 alors

raise Exception.Creer(SysErrorMessage(GetLastError))

Resultat := LockResource(GlobalMemoryBlock)

si Resultat = nil alors

raise Exception.Creer(SysErrorMessage(GetLastError))

fin

la fonction GetResourceAsString(ResName: pchar ResType: pchar): string

var

ResData: PChar

ResSize: Longword

commencer

ResData := GetResourceAsPointer(resname, restype, ResSize)

SetString(Resultat, ResData, ResSize)

fin
exemples d'appels:

var

sample_wav: pointeur

procedure TForm1.FormCreate(Sender: TObject)

var

taille: longword

commencer

...

sample_wav := GetResourceAsPointer('sample_wav', 'wave', taille)

Memo1.Les lignes.Text := GetResourceAsString('sample_txt', 'texte')

fin
une Fois que nous avons la vague de ressources charge dans la memoire nous permet de jouer autant de fois que nous voulons en utilisant l'API sndPlaySound declare dans le MMSystem de l'unite:

procedure TForm1.Button1Click(Sender: TObject)

commencer

sndPlaySound(sample_wav, SND_MEMORY ou SND_NODEFAULT ou SND_ASYNC)

fin
Il y a certaines ressources, comme les polices et les curseurs animes) qui ne peuvent pas etre utilises a partir de la memoire. Nous devons imperativement sauvegarder ces ressources a un fichier de disque temporaire et de les charger a partir de la. La fonction suivante permet d'economiser des ressources dans un fichier:

procedure SaveResourceAsFile(const ResName: string ResType: pchar

const FileName: string)

commencer

avec TResourceStream.Creer(hInstance, ResName, ResType) n'

SaveToFile(nom de fichier)

enfin

fin

fin
La fonction suivante permet l'utilisation de la precedente pour enregistrer une ressource dans un fichier temporaire:

la fonction SaveResourceAsTempFile(const ResName: string

ResType: pchar): string

commencer

Resultat := CreateTempFile

SaveResourceAsFile(ResName, ResType, Resultat)

fin
La discussion de la fonction CreateTempFile tombe au-dela de la portee de cet article et sa mise en œuvre peut etre vu dans l'exemple joint au bulletin d'information.

La fonction suivante permet l'utilisation de SaveResourceAsTempFile pour enregistrer une animation curseur de la ressource dans un fichier temporaire, puis il charge le curseur du fichier avec LoadImage et enfin supprime le fichier temporaire. La fonction retourne le handle retourne par LoadImage:

la fonction GetResourceAsAniCursor(const ResName: string): HCursor

var

CursorFile: string

commencer

CursorFile := SaveResourceAsTempFile(ResName, 'ANICURSOR')

Resultat := LoadImage(0, PChar(CursorFile), IMAGE_CURSOR, 0,

0, LR_DEFAULTSIZE ou LR_LOADFROMFILE)

DeleteFile(CursorFile)

si le Resultat = 0 alors

raise Exception.Creer(SysErrorMessage(GetLastError))

fin
Exemple d'appel:

l'Ecran.Les curseurs[1] := GetResourceAsAniCursor('sample_ani')

Form1.Curseur := 1
eh Bien, c'est ça. J'espere que vous le trouverez utile. Vous pouvez trouver plus d'informations sur les fichiers de ressources dans la Bibliotheque MSDN:

http://msdn.microsoft.com/library/en-us/winui/hh/winui/rc_6cs3.asp

Vous pouvez trouver le code source complet de cet article dans les archives qui accompagne le Pascal Newsletter #25.