Insertion de fichiers comme des ressources dans un exécutable Delphi

Comment faire pour intégrer des icônes, curseurs, curseurs animés, des bitmaps, des images JPEG, des fichiers, les fichiers texte et tout autre fichier exécutable à l'intérieur d'un Delphi.

Insertion de fichiers comme des ressources dans un exécutable Delphi

Il est possible d'inclure n'importe quel type de fichier dans un exécutable en utilisant les fichiers de ressources (*. RES). Certains types de ressources sont reconnus par l'API et peuvent être utilisées directement. D'autres sont tout simplement sous forme de données binaires et de son à vous de les utiliser. Dans cet article, nous allons voir des exemples des deux types.

Pour créer le fichier de ressources, nous commençons par le fichier source (*. RC), par exemple RESOURCES.RC nommé, qui est un simple fichier texte qui contient les ressources entrées (nom, la classe et le fichier):

   sample_bmp   BITMAP     sample.bmp 
   sample_ico   ICON       sample.ico 
   sample_cur   CURSOR     sample.cur 
   sample_ani   ANICURSOR  sample.ani 
   sample_jpg   JPEG       sample.jpg 
sample_wav WAVE sample.wav 
 sample_txt TEXTE Exemple.txt 

Les noms de ces ressources (sample_bmp, sample_ico, etc) sont arbitraires. Le type de ressource mai être reconnue par l'API (BITMAP, ICON, CURSOR) ou arbitraire (JPEG, WAVE, TEXT). Les noms de fichiers spécifier les fichiers qui seront inclus dans le. RES fichier (et plus tard dans le fichier. EXE).

Maintenant, nous devons compiler l'. RC pour produire le fichier. RES fichier. Pour que nous puissions utiliser les ressources de Borland Compiler (brcc32.exe) que vous pouvez probablement trouver dans le dossier BIN Delphi. C'est un simple utilitaire de ligne de commande qui attend le nom du fichier source en paramètre:

   C:\DELPHI\P0025>brcc32 resources 
   Borland Resource Compiler  Version 5.40 
   Copyright (c) 1990, 1999 Inprise Corporation.  All rights reserved. 
 
C: \ DELPHI \ P0025> _ 

Pour charger le linker pour intégrer le fichier de ressources à l'exécutable, nous utilisons le fichier de ressources directive ($ R $ ou RESSOURCES) dans notre Pascal ource code:

   {$R resources.res} 

Chargement des ressources de votre application est facile, pour le "reconnue" comme ressources BITMAP, icônes et curseurs depuis les API Windows fournit des fonctions (LoadBitmap, LoadIcon et LoadCursor respectivement) pour obtenir des poignées de ces éléments, par exemple, que nous pouvons attribuer à la Manche propriété de l'objet correspondant:

     Image1.Picture.Bitmap.Handle := 
       LoadBitmap(hInstance, 'sample_bmp'); 
Icon.Handle: = LoadIcon (HINSTANCE, sample_ico '); 
 Screen.Cursors [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 difficile à gérer. On commence avec des images JPEG. La fonction suivante utilise TResourceStream de charger la ressource en eau qui seront chargés dans un TJPEGImage objet:

GetResourceAsJpeg fonction (const resname: string): TJPEGImage; 
 var 
 Stream: TResourceStream; 
 commencer 
 Stream: = TResourceStream.Create (HINSTANCE, ResName, "JPEG"); 
 essayer 
 Résultat: = TJPEGImage.Create; 
 Result.LoadFromStream (Stream); 
 enfin 
Stream.Free; 
 fin; 
 fin; 

Exemple:

   var 
     Jpg: TJPEGImage; 
   begin 
     // ... 
     Jpg := GetResourceAsJpeg('sample_jpg'); 
     Image2.Picture.Bitmap.Assign(Jpg); 
     Jpg.Free; 
     // ... 
   end; 

Pour les fichiers WAV, nous avons besoin d'un pointeur vers la ressource chargé en mémoire, et pour un fichier texte dont nous avons besoin de charger une ressource dans une chaîne de caractères. Nous pouvons le faire en utilisant TResourceStream, mais nous allons voir un exemple en utilisant l'API:

   function GetResourceAsPointer(ResName: pchar; ResType: pchar; 
de taille: longword): pointer; 
 var 
 InfoBlock: HRSRC; 
 GlobalMemoryBlock: HGLOBAL; 
 commencer 
 InfoBlock: = FindResource (HINSTANCE, resname, restype); 
InfoBlock si = 0 alors 
 augmenter Exception.Create (SysErrorMessage (GetLastError)); 
 taille: = SizeofResource (HINSTANCE, InfoBlock); 
 si size = 0, alors 
 augmenter Exception.Create (SysErrorMessage (GetLastError)); 
 GlobalMemoryBlock: = LoadResource (HINSTANCE, InfoBlock); 
 GlobalMemoryBlock si = 0 alors
 augmenter Exception.Create (SysErrorMessage (GetLastError)); 
 Résultat: = LockResource (GlobalMemoryBlock); 
 si Result = nil alors 
 augmenter Exception.Create (SysErrorMessage (GetLastError)); 
 fin; 

 fonction GetResourceAsString (ResName: PChar; ResType: PChar): string; 
 var 
 ResData: PChar; 
ResSize: Longword; 
 commencer 
 ResData: = GetResourceAsPointer (resname, restype, ResSize); 
 SetString (Résultat, ResData, ResSize); 
 fin; 

Exemple de demande:

   var 
     sample_wav: pointer; 
 
   procedure TForm1.FormCreate(Sender: TObject); 
   var 
     size: longword; 
   begin
 ... 
 sample_wav: = GetResourceAsPointer ( 'sample_wav »,« vague », de la taille); 
 Memo1.Lines.Text: = GetResourceAsString ( 'sample_txt', 'text'); 
 fin; 

Une fois que nous avons la vague de ressources chargés en mémoire on peut jouer autant de fois que nous voulons que l'aide de l'API sndPlaySound déclaré dans le MMSystem unité:

   procedure TForm1.Button1Click(Sender: TObject); 
   begin
 sndPlaySound (sample_wav, SND_MEMORY ou SND_NODEFAULT ou SND_ASYNC); 
 fin; 

Il existe des ressources (comme les polices et les curseurs animés), qui ne peut pas être utilisé de la mémoire. Nous avons forcément à mettre ces ressources à un fichier temporaire du disque et de les charger à partir de là. La fonction suivante enregistre une ressource dans un fichier:

   procedure SaveResourceAsFile(const ResName: string; ResType: pchar; 
const FileName: string); 
 commencer 
 avec TResourceStream.Create (HINSTANCE, ResName, ResType) ne 
 essayer 
 SaveToFile (FileName); 
 enfin 
 Free; 
 fin; 
 fin; 

La fonction suivante fait usage de la précédente pour enregistrer une ressource dans un fichier temporaire:

   function SaveResourceAsTempFile(const ResName: string; 
     ResType: pchar): string; 
   begin 
     Result := CreateTempFile; 
     SaveResourceAsFile(ResName, ResType, Result); 
   end; 

GetResourceAsAniCursor fonction (const ResName: string): HCursor;
var
CursorFile: string;
commencer
CursorFile: = SaveResourceAsTempFile (ResName, 'ANICURSOR');
Résultat: = loadImage (0, PChar (CursorFile), IMAGE_CURSOR, 0,
0, LR_DEFAULTSIZE ou LR_LOADFROMFILE);
DeleteFile (CursorFile);
Résultat, si = 0 alors
augmenter Exception.Create (SysErrorMessage (GetLastError));
fin;

Exemple d'appel:

Screen.Cursors [1]: = GetResourceAsAniCursor ( 'sample_ani'); 
 Form1.Cursor: = 1; 

Eh bien, c'est tout. J'espère qu'il vous sera utile. Vous pouvez trouver plus d'informations sur les fichiers de ressources dans le MSDN Library:

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

Vous pouvez trouver le code source complet de cet article de laarchives, qui accompagne le Pascal Newsletter # 25.