Exemple simple de programme utilisant cette Dll de ressources :

Nous allons creer une fiche qui va charger dynamiquement l'image contenue dans la dll que nous venons de compiler, le resultat  final devant resembler a cela :
 
Je parts du principe que vous savez creer une interface avec delphi et l'API windows...
Un cours sur ce sujet (niveau newbies) sera publié...( En attendant, un exemple de fenetre vide est inclus dans minidelphi...)
Creez un fichier texte nomme fenbitmap.dpr, et codez-y une fenetre classique windows.
Nous ne gererons pour cet exempleque les messages WM_CREATE et WM_DESTROY
Pour appeler dynamiquement une dll il faut :
 - la charger en memoire grace à la commande loadlibrary('Nom_de_la_dll')
 - charger les ressources incluses grace à une commande appropriée : loadbitmap(handle_de_la_dll,'nom_de_la_ressource') ou bien  loadicon, loadcursor, loadstring, loadressource... Voir l'aide de l'API windows pour plus de details...
 - trouver l'adresse d'une procedure ou d'une fonction pour l'utiliser grace à la commande GetProcAddress(handle_de_la_dll, 'nom_de_la_fonction')
 - Libérer la mémoire avec freelibrary(handle_de_la_dll)

Code source de fenbitmap.dpr
 

Program fenbitmap;
Uses Windows, Messages;          { les unites utilisees pour la compilation }
Var                                             { les variables }
   WinClass: TWndClassA;
    Inst: HINST;
    hWindow: HWND;
    TheMessage: TMsg;
    HandleDll : hwnd;
    himage : hbitmap;

// GESTION DES MESSAGES
function WindowProc(hWindow: HWnd; Msg,wParam,lParam: Integer): Integer; stdcall;
begin
   Result := 0;
   case Msg of
   { Avant la creation de la fiche }
   WM_CREATE :
    begin
        { chargement de la dll }
        HandleDll := Loadlibrary('DllResources.dll') ;
        { en cas d'echec de chargement }
        if HandleDll = 0 then
           begin
              messagebox(0,'Attention','Dll non trouvée', MB_OK) ;
              Postquitmessage(0);
           end
           { sinon }
           else begin
               himage := loadbitmap(handledll,pchar('MonImage')); { chargement de l'image }
               { on cree une image vide sur notre fenetre window }
               CreateWindow('Static','', WS_VISIBLE or WS_CHILD or SS_BITMAP,
               32,18,   // coordonnees / droite et haut
               202,76,  // largeur hauteur
               hWindow, 0, Inst, nil);
               { on y applique l'image chargee }
              SendMessage(Image1,STM_SETIMAGE,IMAGE_BITMAP,himage);
           end;
         { On libere la dll }
         FreeLibrary(HandleDll);
    end;
   { Avant la destruction de la fiche }
   WM_DESTROY :
   begin
       deleteobject(himage) ; { destruction de l'iimage }
       postquitmessage(0) ; { fermeture propre }
   end;
   ELSE
   Result := DefWindowProc(hWindow, Msg, wParam, lParam);
   end;
end;


// PROGRAMME PRINCIPAL
begin
  { enregistrement WndClass }
  Inst := hInstance;
  with WinClass do
  begin
      style                    := CS_CLASSDC or CS_PARENTDC;
      lpfnWndProc       := @WindowProc;
      hInstance             := Inst;
      hbrBackground    := color_btnface + 1; { Astuce : pour une couleur personnalisee du fond utiliser createsolidbrush(RGB(0,0,0)) avec les chiffres de votre choix }
      lpszClassname      := 'MyWindowClass';
      hCursor                := LoadCursor(0, IDC_ARROW);
  end; {  du with }


  RegisterClass(WinClass);

  { Creation de la fenetre }
  { utilisez l'aide sdk window incluse avec delphi si vous voulez des détails
   sur les differents styles disponibles avec createwindowex }
  hWindow := CreateWindowEx(WS_EX_DLGMODALFRAME,   { style general de la fenetre (non redimensionnable)}
                           'MyWindowClass',                                                { le nom de votre wndclass }
                           'Image dans dll',  // titre de la fenetre
                            WS_VISIBLE or WS_CAPTION or WS_SYSMENU,  { styles particuliers de la fenetre (visible,titre et bouton)}
                            round(getsystemmetrics(SM_CXSCREEN)/2)-139,        { distance/gauche de votre ecran ici on centre la fiche en prenant le milieu de l'ecran moins la demi largeur }
                            round(getsystemmetrics(SM_CXSCREEN)/2)-70,     { distance /haut de votre ecran }
                            278,            { largeur de votre fenetre (proportion choisie pour une bitmap de 202 pixels) }
                            140,            { hauteur de votre fenetre (pour une bitmap de 76 pixels) }
                            0,                { handle de la fenetre parente : ici laisser 0 }
                            0,                { handle du menu ou d'une fenetre fille : ici laisser 0 }
                            Inst,             { handle de cette instance de l'application }
                            nil);              { pointeur vers les datas de création de cette fenetre laisser nil }
  UpdateWindow(hWindow);

  {La boucle principale}
  while GetMessage(TheMessage,0,0,0) do begin
    if not IsDialogMessage(hWindow,TheMessage) then begin
      TranslateMessage(TheMessage);
      DispatchMessage(TheMessage);
    end;
  end;
end.

Compilez cet exemple dans delphi, ou en utilisant le compilateur dcc32 (contenu dans le repertoire bin de votre delphi) à la souris en glissant votre fichier source sur dcc32.exe ou bien avec minidelphi.

 

Exemple de Dll de fonction :

Nous allons creer une dll contenant une fonction.
J'ai choisi une fonction de génération de clef (celle d'un exercice du REA)

Code source de madllfonction.dpr
 

library madllfonction; { le nom de notre dll }
{ pas besoin de spécifier d'uses ni de variables globales pour cette dll }

function calculserial(name :pchar):pchar; stdcall;  { La fonction que l'on veut exporter }
{ je n'entrerai pas dans les détails pour expliquer le fonctionnement de cet algorithme simplissime, ce n'est pas le but de ce tutoriel... disons simplement que cette fonction prend un pchar, fait quelques opérations dessus, et renvoie le resultat sous forme de pchar }

var      { les variables utilisees par la fonction }
b,i : integer ;
s, texte : string ;
begin   { debut }
  texte := '' ;
  s := name ;
  getmem(result, 11) ;
  for i:= 1 to length(s) do
  begin
   if i<11 then
   begin
     b := ord(s[i]);
     b := b mod 10 ;
     b := b XOR (i-1) ;
     b := b+2 ;
      if b>9 then b := b-10 ;
     b := b+50 ;
      if b>57 then b := b-10 ;
     Texte  := texte+chr(b) ;
   end ;
  end ;
Texte := Texte+#0 ;
result := pchar(Texte) ; { le resultat sous forme de pchar}
end ; { fin de la fonction }

Exports { la partie qui stipule les exports }
calculserial;

begin
{ code au chargement de la dll, ici rien... }
end.

Utilisation dynamique de cette Dll de fonction :

Nous allons creer une fiche contenant deux champs de saisie et un bouton. Lorsqu'on appuiera sur le bouton, on chargera la dll (et sa fonction) pour calculer à partir de la valeur du champ de saisie1,  le serial généré que l'on placera dans le champs de saisie2.
En bref : nous allons creer un keygen avec son algorithme dans une dll...

Program MonGenerateur;
Uses Windows, Messages;
Var
    WinClass: TWndClassA;
    Inst: HINST;
    hWindow, memo1, memo2, button1: HWND;  { handles :  fenetre, champ1, champ2, bouton }
    TheMessage: TMsg;
    HandleDll : hwnd;  { handle de la dll }
    calculserial : function (name:pchar): pchar;stdcall;

{ procedure liee au click sur le bouton}
procedure click;  
var
   nom : pchar;
   longueurtexte : integer;
begin
   { Je charge ma dll }
    HandleDll := Loadlibrary('madllfonction.dll');
   { en cas d'erreur :}
   if HandleDll = 0 then
       begin
          messagebox(0,'Attention','Dll non trouvée', MB_OK);
          Postquitmessage(0);
       end;
    longueurtexte := GetWindowTextLength(memo1);
    { Si on a ecrit quelque chose ...}
    if longueurtexte > 0 then
        begin
          GetMem(nom, longueurtexte +1);     { memoire pour le nom }
          GetWindowText(memo1, nom, longueurtexte +1);    { recup du nom en memoire }
          @calculserial := GetProcAddress(handledll,'calculserial');    { recup de l'adresse de la fonction }
          setwindowtext(memo2,calculserial(nom));   { affichage du resultat dans le champ de saisie 2 }
          FreeLibrary(HandleDll);    { liberation de la dll }
          freemem(nom);    { liberation de la memoire (du nom) }
        end
     { Sinon }
    else setwindowtext(memo2,'');    { on efface le champ de saisie 2 }
end;

{ gestion des messages : interception }
function WindowProc(hWindow: HWnd; Message,wParam,lParam: Integer): Integer; stdcall;
begin
  Result := 0;
  case Message of
   { en cas de fermeture }
    WM_DESTROY:
    begin
      postquitmessage(0);
    end;
   { En cas de commande }
    WM_COMMAND:
    begin
     if (lParam = Button1) then  click;     { Si la commande vient du bouton, j'appelle la procedure click }
    end;
   { Autres cas }
    ELSE
    Result := DefWindowProc(hWindow, Message, wParam, lParam);

  end;
end;

begin
  Inst := hInstance;
  with WinClass do
  begin
    style                  := CS_CLASSDC or CS_PARENTDC;
    lpfnWndProc     := @WindowProc;
    hInstance           := Inst;
    hbrBackground  := color_btnface + 1;
    lpszClassname   := 'MyWindowClass';
    hCursor            := LoadCursor(0, IDC_ARROW);
  end;
  RegisterClass(WinClass);

  { Creation de la fenetre }
  hWindow := CreateWindowEx(WS_EX_DLGMODALFRAME,'MyWindowClass','Fonction dans dll',
              WS_VISIBLE or WS_CAPTION or WS_SYSMENU,
              round(getsystemmetrics(SM_CXSCREEN)/2)-130,
              round(getsystemmetrics(SM_CXSCREEN)/2)-60,
              160,120,0,0,Inst,nil);
   { Creation du champ de saisie1 }
   Memo1:= CreateWindowEx(WS_EX_CLIENTEDGE, 'Edit','', WS_CHILD or WS_VISIBLE or
              WS_BORDER or ES_LEFT,5,5,140,25, hWindow, 0, Inst, nil);
   { Creation du champ de saisie2 }
   Memo2:= CreateWindowEx(WS_EX_CLIENTEDGE, 'Edit','', WS_CHILD or WS_VISIBLE or
              WS_BORDER or ES_LEFT,5,35,140,25, hWindow, 0, Inst, nil);
   { Creation du bouton}
   Button1 := CreateWindow('Button', 'Generer serial', WS_VISIBLE or WS_CHILD or
              BS_TEXT, 6, 65, 138, 24, hwindow, 0, Inst, nil);

  UpdateWindow(hWindow);

  while GetMessage(TheMessage,0,0,0) do begin
    if not IsDialogMessage(hWindow,TheMessage) then begin
      TranslateMessage(TheMessage);
      DispatchMessage(TheMessage);
    end;
  end;
end.

Comment compiler un code source DRP :

Si vous avez Delphi :
Les codes sources donnes ici peuvent directement etre compiles dans l'interface de Delphi si vous le desirez.
Vous pouvez aussi compiler un code source en faisant un drag and drop a la souris de votre fichier sur le compilateur dcc32.exe que vous trouverez dans le repertoire bin de borland Delphi ou de Borland C++
Vous pouvez aussi lancer dcc32 en ligne de commande dans une console pour compiler votre projet, vous aurez ainsi les message de reussite ou d'erreur du compilateur...

La syntaxe a utiliser :
dcc32 [options] fichier [options]

Options du compilateur :
-$<lettre><état> (voir défauts ci-dessous)

Compilation avec minidelphi :

Pour compiler un projet avec minidelphi il suffit de choisir dans le menu outils le sous menu compiler :