Kategorie: Resourcen

• öffnen des Objektgalerie-Fenster mit Datei -> Neu… -> Textdatei wählen
• Namen und Typ der Ressourcen sowie die dazugehörigen Dateinamen eingeben
• Ressourcen-Name (String den wir später für den Zugriff auf diese Ressource brauchen)
• Typ der Ressource (BITMAP, CURSOR, ICON, WAVE oder AVI)
• Name der Datei
• Beispielaufbau der resource.txt

RES_LAKE BITMAP "mybitmap.bmp"
RES_CURSOR CURSOR "mycursor.cur"
RES_SOUND WAVE "mysound.wav"

• Speichern der erstellten Textdatei als z.B. resource.rc
• einbinden der Datei in das Projekt über den Menüpunkt Projekt -> Dem Projekt hinzufügen…
• es ist nun möglich auf Bitmaps, Cursor, Sounds etc. mit Hilfe der Funktionen LoadFromResourceName() , LoadCursor(), PlaySound() usw. zuzugreifen.
• Zum folgenden Beispiel gehören ein Formular frmMain und eine ComboBox cmbLoadPics. In die Ressourcen wurden folgende Objekte eingebunden

RES_LAKE BITMAP "reslake.bmp"
RES_SYDNEY BITMAP "ressydney.bmp"
RES_CURSOR CURSOR "resbluecurs.cur"
RES_SOUND WAVE "respicture.wav"

• Items-Eigenschaft der Combobox beinhaltet 3 Strings: Zeichenfläche löschen, Bitmap-Ressource RES_LAKE und Bitmap-Ressource RES_SIDNEY. Beim änderungen der ItemIndex-Eigenschaft der ComboBox wird entsprechendes Bitmap auf Canvas des Formulars gezeichnet und eine Wave-Datei abgespielt. Als Cursor wird ebenfalls ein Cursor aus den Ressourcen verwendet.
• Quelltext der Anwendung

#include <vcl.h>
#pragma hdrstop
#include "MainForm.h"
#include "mmsystem.h" // für PlaySound()
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TfrmMain *frmMain;
//---------------------------------------------------------------------------
__fastcall TfrmMain::TfrmMain(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
// Wird beim Anzeigen des Formulars ausgeführt:
//---------------------------------------------------------------------------
void __fastcall TfrmMain::FormShow(TObject *Sender)
{
    cmbLoadPics -> ItemIndex = 0;

    // Cursor aus Ressourcen laden und zuweisen:
    Screen->Cursors[crArrow] = LoadCursor(HInstance, "RES_CURSOR");
    Cursor = crArrow;
}
//---------------------------------------------------------------------------
// Eventhandler für OnClick-Ereignis der ComboBox
//---------------------------------------------------------------------------
void __fastcall TfrmMain::cmbLoadPicsClick(TObject *Sender)
{
    frmMain->Invalidate(); // Zeichenfläche löschen
    Application->ProcessMessages();

    if (cmbLoadPics -> ItemIndex > 0) // falls Bitmap zeichnen:
    {
        // TBitmap erzeugen:
        Graphics::TBitmap * pResImg = new Graphics::TBitmap;

        // Bitmap aus Ressourcen laden:
        if(cmbLoadPics > ItemIndex == 1) // falls Bitmap RES_LAKE:
        pResImg->LoadFromResourceName(int(HInstance), "RES_LAKE");
        else if(cmbLoadPics > ItemIndex == 2) // falls Bitmap RES_SYDNEY:
        pResImg->LoadFromResourceName(int(HInstance), "RES_SYDNEY");

        // Bitmap auf Canvas der frmMain zeichnen:
        Canvas->Draw(ClientWidth / 2 - pResImg->Width / 2, ClientHeight / 2 - pResImg->Height / 2 - 20, pResImg);

        // Speicher aufräumen
        if (pResImg != NULL)
        {
            delete pResImg;
            pResImg = NULL;
        }
    }

    // Sound aus Ressourcen abspielen:
    PlaySound("RES_SOUND", HANDLE(HInstance), SND_RESOURCE);
}

• *.rh file erstellen

// resource.rh
#ifndef RESOURCE_RH
#define RESOURCE_RH
#define ID_JPEG 1000
#endif

• *.rc file erzeugen, in dem JPEG als RCDATA resource type steht

#include "resource.rh"

ID_JPEG RCDATA "conf99.JPG"

• *.rc file zum Projekt hinzufügen
• TImage irgenwo auf der Form plazieren und ‚MyImage‘ nennen
• Code um Image aus der Resource zu laden

#include <jpeg.hpp>
#include "main.h"
#include "resource.rh"
#include <memory>

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    // Find the resource using the resource ID from resource.rh
    HRSRC rsrc = FindResource(HInstance, MAKEINTRESOURCE(ID_JPEG),RT_RCDATA);
    if (!rsrc) return;

    // Load the resource and save its total size. We will need the size
    // when we read the data.
    DWORD Size = SizeofResource(HInstance , rsrc);
    HGLOBAL MemoryHandle = LoadResource(HInstance,rsrc);
    if (MemoryHandle == NULL) return;

    // We need to get the bytes out of the resource somehow.
    // The API function LockResource allows us to do that.
    // It returns a BYTE pointer to the raw data in the resource
    // In this case, the resource is a .JPG file.
    BYTE *MemPtr = (BYTE *)LockResource(MemoryHandle);

    // Now the jpeg image is memory is in MemPtr.
    // Copy from MemPtr into a TMemoryStream
    std::auto_ptr<TMemoryStream->stream(new TMemoryStream);
    stream->Write(MemPtr, Size);
    stream->Position = 0;

    // Create a TJPEGImage, and tell it to load from the memory stream.
    std::auto_ptr<TJPEGImage-> JImage(new TJPEGImage());
    JImage->LoadFromStream(stream.get());

    // Now that we have a TJEGImage, we can use Assign to
    // copy that image into a TImage.
    MyImage->Width = JImage->Width;
    MyImage->Height = JImage->Height;
    MyImage->Picture->Assign(JImage.get());
}

Vorraussetzung für die folgenden Beispiele ist, dass schon *.rc files in das Projekt eingebunden sind (siehe Icons, Cursors, Bitmaps, und Sound Resourcen zu einem BCB Projekt hinzufügen)

• Bitmaps

Graphics::TBitmap *bmp = new Graphics::TBitmap;
bmp->LoadFromResourceID((int)HInstance,IDB_SPLASH); // Bitmap über numerische ID laden

Graphics::TBitmap *bmp = new Graphics::TBitmap;
bmp->LoadFromResourceName((int)HInstance,"Bitmap1"); //Bitmap über ID-Strings laden

// Bitmap in TImage control laden:
Image1->Picture->Bitmap->LoadFromResourceID((int)HInstance,IDB_SPLASH);

• Icons

// 32 x 32 Icon über integer ID laden
TIcon *icon = new Graphics::TIcon;
icon->Handle=LoadIcon(HInstance, MAKEINTRESOURCE(ID_FOLDER_ICON));

// 32 x 32 Icon über string ID laden
TIcon *icon = new Graphics::TIcon;
icon->Handle=LoadIcon(HInstance, "IconFolder");

// System icon laden
TIcon *icon = new Graphics::TIcon;
icon->Handle=LoadIcon(HInstance, IDI_EXCLAMATION);

// 16 x 16 Icon über integer ID laden
TIcon *icon = new Graphics::TIcon;
icon->Handle=LoadImage(HInstance, MAKEINTRESOURCE(ID_SMALL_FOLDER), IMAGE_ICON, 16, 16, LR_LOADREALSIZE);

// 16 x 16 Icon über string ID laden
TIcon *icon = new Graphics::TIcon;
icon->Handle=LoadImage(HInstance, "SmallFolder"), IMAGE_ICON, 16, 16, LR_LOADREALSIZE);

// Icon direkt in TImage control laden
Image1->Picture->Icon->Handle = LoadIcon(HInstance, IDI_EXCLAMATION);

1. über den Image Editor (nur Bitmaps, Icons, Cursors)
• Mit dem Image Editor kann man Resourcen-Gruppen erstellen und diese in einen *.res file speichern
• Datei | Neu | res
• *.res file in die Projekt-Directory speichern.
• mit dem Image Editor Cursors, Icons, oder Bitmaps designen (immer mit Resource | Neu | … „Typ“ im *.res file erzeugen)
• jede Resource sollte einen logischen Namen besitzen.
• *.res File zum Projekt Hinzufügen (Projekt | Dem Projekt hinzufügen, oder #pragma resource „PICTURES.res“ im Quellcode.
2. über *.rc files
• Datei resource.rc generieren (bel. Editor)

#include "resource.rh"

ID_SPLASH BITMAP "splash.bmp"
ID_ABOUT BITMAP "about.bmp"
ID_HAND CURSOR "hand.cur"
ID_FOLDER ICON "folder.ico"
ID_TYPE WAVE "type.wav"
ID_SEARCHAVI AVI "search.avi"

• Recource-Header (recource.rh) erzeugen

#ifndef RESOURCE_RH
#define RESOURCE_RH

#define ID_SPLASH 1000
#define ID_ABOUT 1001
#define ID_HAND 1002
#define ID_FOLDER 1003
#define ID_TYPE 1004
#define ID_SEARCHAVI 1005

#endif

• *.rc file dem Projekt Hinzufügen (s.o.)
• #include resource.rh in die gewüschte *.cpp einfügen
• Resource anhand der ID laden (siehe Bitmaps und Icons als Resourcen in ein Programm einbinden)