Einbetten von Dateien als Ressourcen in eine ausführbare delphi

Einbetten von Dateien als Ressourcen in eine ausführbare delphi

Einbetten von Dateien als Ressourcen in eine ausführbare delphi : Mehreren tausend Tipps, um Ihr Leben einfacher machen.

Sie können lernen, wie erstellen Sie Ihre eigene Software für jede Situation mit der ausgezeichneten Software Anforderungen Unleashed. Benötigen Sie wissen, wie man Symbole einbinden, lesen Cursorn, animierten Cursorn, Bitmaps, Jpeg-Bilder, Wave-Dateien, Textdateien und jede andere Datei in ein ausführbares, Delphi nur!

Einbetten von Dateien als Ressourcen in eine ausführbare Delphi
Ist es möglich, jede Art von Datei einbetten in eine ausführbare Datei mit Ressourcendateien (*. RES). Bestimmte Arten von Ressourcen werden durch die API erkannt und können direkt verwendet werden. Andere sind einfach als Binärdaten und seine bis zu ihnen genommen, deren Verwendung. In diesem Artikel werden wir Beispiele für beide Arten sehen.

Wir mit der Quelldatei beginnen erstellen die Ressourcendatei (*. RC), z.B. Ressourcen genannt. RC, die eine einfache Textdatei, die die Ressourceneinträge (Name, Klasse und Datei) enthält:

Sample_bmp BITMAP-sample.bmp

Sample_ico Symbol sample.ico

Sample_cur CURSOR sample.cur

Sample_ani ANICURSOR sample.ani

Sample_jpg JPEG sample.jpg

Sample_wav Welle sample.wav

Sample_txt TEXT Beispiel.txt
Die Namen der Ressourcen (Sample_bmp, Sample_ico, etc.) sind willkürlich. Die Art der Ressource möglicherweise eins von den APIs (BITMAP, Symbol, CURSOR) erkannt oder willkürliche (JPEG, Welle, TEXT). Die Dateinamen angeben, die Dateien, die in eingeschlossen ist die. RES-Datei (und später in der. (EXE).

Jetzt haben wir zum Kompilieren der. RC-Datei produzieren die. RES-Datei. Dafür nutzen wir die Borland-Ressourcen-Compiler (brcc32.exe), die Sie wahrscheinlich in Delphi Ordner 'BIN' zu finden. Es ist ein einfaches Befehlszeilen-Dienstprogramm, das den Namen der Quelldatei als Parameter erwartet:

C:\DELPHI\P0025 > brcc32 Ressourcen

Borland Resource Compiler Version 5.40

Copyright (c) 1990, 1999 Inprise Corporation. Alle Rechte vorbehalten.

C:\DELPHI\P0025 > _
Den Linker die Ressourcendatei einbetten in die ausführbare Datei verwenden, damit wir die Ressource-Datei-Richtlinie ($R oder $RESOURCE) in unserem Pascal Ource Code:

{$R resources.res}
Laden der Ressourcen in der Anwendung ist für die 'erkannt' Ressourcen wie BITMAP, ICON und CURSOR einfach, da die Windows-API zur Verfügung stellt (LoadBitmap, LoadIcon und LoadCursor-beziehungsweise) Griffe für diese Elemente erhalten, so z. B. haben wir können der Handle-Eigenschaft des entsprechenden Objekts zuweisen:

Image1.Picture.Bitmap.handle: =

Die LoadBitmap (hInstance, 'Sample_bmp');

Icon.Handle: = LoadIcon (hInstance, 'Sample_ico');

Screen.Cursors[1]: = LoadCursor (hInstance, 'Sample_cur');
Weitere Alternativen beim Laden von Bildressourcen finden Sie unter der API LoadImage.

Andere Ressourcen sind etwas schwieriger zu verwalten. Beginnen wir mit JPEG-Bilder. Die folgende Funktion verwendet TResourceStream, um die Ressource als Stream zu laden, die in ein TJPEGImage-Objekt geladen werden:

Funktion GetResourceAsJpeg (const Resname: Zeichenfolge): TJPEGImage;

var

Stream: TResourceStream;

beginnen

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

versuchen Sie

Ergebnis: = TJPEGImage.Create;

Result.LoadFromStream(Stream);

Schließlich

Stream.Free;

Ende;

Ende;
Beispiel:

var

JPG: TJPEGImage;

beginnen

// ...

JPG: = GetResourceAsJpeg('sample_jpg');

Image2.Picture.Bitmap.assign(JPG);

Jpg.Free;

// ...

Ende;
WAV-Dateien brauchen wir einen Zeiger auf die Ressource, die in den Speicher geladen und für eine Textdatei, die wir brauchen, um eine Ressource in einer Zeichenfolge zu laden. Wir können es mit TResourceStream zu tun, aber mal sehen, ein Beispiel zur Verwendung der API:

Funktion GetResourceAsPointer (ResName: Pchar; {ResType: Pchar;

Größe: Longword): Zeiger;

var

InfoBlock: HRSRC;

GlobalMemoryBlock: HGLOBAL;

beginnen

InfoBlock: = FindResource (hInstance, Resname, {Restype);

Wenn InfoBlock = 0 then

Exception.Create(SysErrorMessage(GetLastError)) zu erhöhen;

Größe: = SizeofResource (hInstance, InfoBlock);

Wenn Größe = 0 then

Exception.Create(SysErrorMessage(GetLastError)) zu erhöhen;

GlobalMemoryBlock: = LoadResource (hInstance, InfoBlock);

Wenn GlobalMemoryBlock = 0 then

Exception.Create(SysErrorMessage(GetLastError)) zu erhöhen;

Ergebnis: = LockResource(GlobalMemoryBlock);

Wenn Ergebnis = NULL Then

Exception.Create(SysErrorMessage(GetLastError)) zu erhöhen;

Ende;

Funktion GetResourceAsString (ResName: Pchar; {ResType: Pchar): string;

var

ResData: PChar;

ResSize: Longword;

beginnen

ResData: = GetResourceAsPointer (Resname, {Restype, ResSize);

SetString (Ergebnis, ResData, ResSize);

Ende;
Beispiel für Anrufe:

var

Sample_wav: Zeiger;

Prozedur TForm1.FormCreate(Sender: TObject);

var

Größe: Longword;

beginnen

...

Sample_wav: = GetResourceAsPointer ('Sample_wav', 'Welle', Größe);

Memo1.Lines.Text: = GetResourceAsString ('Sample_txt', 'Text');

Ende;
Sobald wir haben die Welle-Ressource geladen, das wir es so oft wie wir, durch wollen spielen kann deklariert mit der API-SndPlaySound in die Unit MMSystem:

Prozedur TForm1.Button1Click(Sender: TObject);

beginnen

SndPlaySound (Sample_wav, SND_MEMORY oder SND_NODEFAULT oder SND_ASYNC);

Ende;
Es gibt einige Ressourcen (wie Schriftarten und animierte Cursor), die nicht aus dem Speicher verwendet werden können. Wir müssen unbedingt diese Ressourcen in eine temporäre Datei speichern und von dort zu laden. Die folgende Funktion speichert eine Ressource in einer Datei:

Procedure SaveResourceAsFile (const ResName: string; {ResType: Pchar;

const FileName: String);

beginnen

mit TResourceStream.Create (hInstance, ResName, {ResType) tun

versuchen Sie

SaveToFile(FileName);

Schließlich

Frei;

Ende;

Ende;
Die folgende Funktion nutzt das vorhergehende um eine Ressource in eine temporäre Datei zu speichern:

Funktion SaveResourceAsTempFile (const ResName: string;

{ResType: Pchar): string;

beginnen

Ergebnis: = CreateTempFile;

SaveResourceAsFile (ResName, {ResType, Result);

Ende;
Die Diskussion über die Funktion CreateTempFile fällt, würde den Rahmen dieses Artikels sprengen und seine Umsetzung kann gesehen werden, im Beispiel den Newsletter angefügt.

Die folgende Funktion nutzt SaveResourceAsTempFile um eine animierte Cursor-Ressource in eine temporäre Datei zu speichern, dann lädt den Cursor aus der Datei mit LoadImage und schließlich löscht die temporäre Datei. Die Funktion gibt das Handle von LoadImage zurückgegeben:

Funktion GetResourceAsAniCursor (const ResName: Zeichenfolge): HCursor;

var

CursorFile: String;

beginnen

CursorFile: = SaveResourceAsTempFile (ResName, 'ANICURSOR');

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

0, LR_DEFAULTSIZE oder LR_LOADFROMFILE);

DeleteFile(CursorFile);

Wenn Ergebnis = 0 then

Exception.Create(SysErrorMessage(GetLastError)) zu erhöhen;

Ende;
Beispielaufruf:

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

Form1.Cursor: = 1;
Nun, war das's. Ich hoffe, dass Sie es nützlich finden. Weitere Informationen über Ressourcendateien finden Sie in der MSDN Library:

https://msdn.Microsoft.com/library/en-US/WinUI/HH/WinUI/rc_6cs3.ASP

Den vollständigen Quellcode dieses Artikels finden Sie im Archiv, die die Pascal Newsletter #25 begleitet.