7 replies to this topic

[escafandra]

Hace algún tiempo publiqué una clase TGif que mostraba como es el estándar de ese formato y permitía extraer las imágenes, crear archivos gif desde varias imágenes, o crear un visor como el que publiqué aquí. La clase TGif estaba orientada a la VCL usando alguno de sus componentes, el visor TGifViewer pecaba de lo mismo.

Hoy os quiero presentar otro visor gif completamente distinto basado en el uso de GDI+ con lo que la dependencia de Windows es total pero ahorra mucho código. Este visor es totalmente independiente de la VCL y usará cualquier ventana, incluidas las de la VCL, para visualizar en ella nuestro gif. Para ello intercepta la función de tratamiento de mensajes evitando que se procese el mensaje WM_PAINT y controlando un evento que servirá para sincronizar un Thread. Este Thread será el encargado de realizar la visualización del gif.

El visor está implementado como una clase y no como un componente pero es muy intuitivo y fácil de usar, además de su constructor y destructor, tiene los siguientes métodos:
GifView(Handle: HWND; FileName: PWCHAR) Establece el fichero y la ventana donde se representará y comienza la visualización.
Finish: Termina la visualización pero no libera la ventana.
Start: Comienza la visualización si ya tenemos fichero y ventana
SetHandle(Handle: THANDLE): Asocia el visor a una ventana.
LoadFile(FileName: PWCHAR): Abre un fichero gif y obtiene sus características
GetWidth: Nos informa del ancho
GetHeight: Nos informa del alto
GetFrames: Nos informa del número de imágenes del gif

La característica fundamental de este visor es que cualquier ventana puede servir como “pantalla” y también funcionará en aplicaciones que no sean VCL, es decir, aplicaciones Windows API puras.

El código de la clase es el siguiente:

delphi

unit _GifViewer;
 
//------------------------------------------------------------------------------
// GifViewer V 2.0
// escafandra 2018
// Clase para representar un gif estático o animado sobre cualquier ventana.
// Usa GDI+
 
 
interface
 
uses Windows, Messages;
 
//function SetWindowLongPtr(hWnd: HWND; nIndex: Integer; dwNewLong: Pointer): Pointer; stdcall external 'user32';
function GdiplusStartup(var GdiToken: DWORD; Startup, Output: PBYTE): DWORD; stdcall external 'gdiplus';
function GdipLoadImageFromFile(lpFileName: PWideChar; var hImage: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipDrawImageRectI(hGraphics, hImage: THANDLE; Left, Top, Width, Height: Integer): DWORD; stdcall external 'gdiplus';
function GdipCreateFromHDC(DC: HDC; var hGraphics: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipImageSelectActiveFrame(hImage: THANDLE; DimensionID: PGUID; frameIndex: Integer): DWORD; stdcall external 'gdiplus';
function GdipImageGetFrameDimensionsList(hImage: THANDLE; dimensionIDs: PGUID; Count: Integer): DWORD; stdcall external 'gdiplus';
function GdipGetPropertyItemSize(hImage: THANDLE; dwPropId: Integer; var Size: UINT): Integer; stdcall external 'gdiplus';
function GdipGetPropertyItem(hImage: THANDLE; dwPropID, Size: Integer; lpBuffer: Pointer): DWORD; stdcall external 'gdiplus';
function GdipImageGetFrameCount(hImage: THANDLE; lpDimensionID: PGUID; out Count: UINT): DWORD; stdcall external 'gdiplus';
function GdipGetImageWidth(hImage: THANDLE; var Width: UINT): DWORD; stdcall external 'gdiplus';
function GdipGetImageHeight(hImage: THANDLE; var Height: UINT): DWORD; stdcall external 'gdiplus';
function GdipDeleteGraphics(hGraphics: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipDisposeImage(hImage: THANDLE): DWORD; stdcall external 'gdiplus';
procedure GdiplusShutdown(GdiToken: DWORD); stdcall external 'gdiplus';
 
type
TGifViewer = class
  private
    Wnd: HWND;
    OldWndProc: Pointer;
    OldUserData: DWORD;
    gdiplusToken: DWORD;
    hThread: THANDLE;
    hGdipImage: THANDLE;
    Width:  integer;
    Height: integer;
    Frames: UINT;
    function WndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
 
  public
    Left:     integer;
    Top:      integer;
    function  GifView(Handle: HWND; FileName: PWCHAR): boolean;
    function  SetHandle(Handle: THANDLE): boolean;
    function  LoadFile(FileName: PWCHAR): boolean;
    function  GetWidth:  integer;
    function  GetHeight: integer;
    function  GetFrames: UINT;
    function  Start: boolean;
    procedure Finish;
 
    constructor Create;
    destructor Destroy; override;
end;
PGifViewer = ^TGifViewer;
 
TPropertyItem = record
  id:	    ULONG;
  length: ULONG;
  _type:  WORD;
  value:  Pointer;
end;
PPropertyItem = ^TPropertyItem;
 
const
  PropertyTagFrameDelay = $5100;
var
  GDI:    DWORD = 0;
  hEvent: THandle = 0;
 
implementation
 
function RePaintWindow(Wnd: HWND): boolean;
var
  Rect: TRect;
begin
  GetClientRect(Wnd, Rect);
  Result:= RedrawWindow(Wnd, @Rect, 0, RDW_INVALIDATE or RDW_ERASE or RDW_UPDATENOW or RDW_ALLCHILDREN);
end;
 
function ThGif(GV: TGifViewer): DWORD; stdcall;
var
  Wait: PIntegerArray;
  Pi:   PPropertyItem;
  DC: HDC;
  hGdipGraphics: THANDLE;
  nBytes, Frames, Index: UINT;
  FrameDimensionTime: TGUID;
begin
  // Esperamos a que se pinte una ventana WM_PAINT
  if hEvent <> 0 then WaitForSingleObject(hEvent, INFINITE);
 
  if (GV.hGdipImage <> 0) and (GV.Wnd <> 0) then
  begin
    GdipGetPropertyItemSize(GV.hGdipImage, PropertyTagFrameDelay, nBytes);
    Pi:= Pointer(LocalAlloc(LMEM_FIXED, nBytes));
    GdipGetPropertyItem(GV.hGdipImage, PropertyTagFrameDelay, nBytes, Pi);
    GdipImageGetFrameDimensionsList(GV.hGdipImage, @FrameDimensionTime, 1);
    GdipImageGetFrameCount(GV.hGdipImage, @FrameDimensionTime, Frames);
 
    Index:= 0;
    Wait:= PIntegerArray(Pi.value);
    if Pi._type = sizeof(DWORD) then
    repeat
      DC:= GetDC(GV.Wnd);
      GdipCreateFromHDC(DC, hGdipGraphics);
      GdipImageSelectActiveFrame(GV.hGdipImage, @FrameDimensionTime, Index);
      GdipDrawImageRectI(hGdipGraphics, GV.hGdipImage, GV.Left, GV.Top, GV.Width, GV.Height);
      GdipDeleteGraphics(hGdipGraphics);
      ReleaseDC(GV.Wnd, DC);
      Sleep(Wait[Index] * 10);
      Index:= (Index + 1) mod Frames;
    until (GV.Wnd = 0) or (GV.hGdipImage = 0);
  end;
  LocalFree(HLOCAL(Pi));
  Result:= 0;
end;
 
function DefWndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
var
  pGifViewer: TGifViewer;
begin
  if (Msg = WM_PAINT) and (hEvent <> 0) then SetEvent(hEvent);  // Pemitimos que arranque el Thread
 
  pGifViewer:= TGifViewer(GetWindowLong(Handle, GWL_USERDATA));
  if pGifViewer <> nil then
    Result:= pGifViewer.WndProc(Handle, Msg, WParam, LParam)
  else
    Result:= DefWindowProc(Handle, Msg, WParam, LParam);
end;
 
function TGifViewer.WndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
var
  R: TRect;
begin
  if (Msg = WM_PAINT) and (hGdipImage <> 0) then
  begin
    R.Left:= Left; R.Top:= Top; R.Right:= Left+Width; R.Bottom:= Top+Height;
    ValidateRect(Wnd, @R);
    //Result:= DefWindowProc(Handle, Msg, WParam, LParam);
    //Exit;
  end;
  Result:= CallWindowProc(OldWndProc, Handle, Msg, WParam, LParam);
end;
 
function TGifViewer.SetHandle(Handle: THANDLE): boolean;
begin
  Result:= false;
  if(Pointer(GetWindowLong(Handle, GWL_WNDPROC)) <> @DefWndProc) then
  begin
    SuspendThread(hThread);
    if (Wnd <> 0) then
    begin
      SetWindowLong(Wnd, GWL_USERDATA, OldUserData);
      SetWindowLong(Wnd, GWL_WNDPROC, LongInt(OldWndProc));
      RePaintWindow(Wnd);
      Wnd:= 0;
    end;
 
    if (Handle <> 0) and IsWindow(Handle) then
    begin
      Wnd:= Handle;
      OldUserData:= SetWindowLong(Wnd, GWL_USERDATA, LongInt(self));
      OldWndProc:= Pointer(SetWindowLong(Wnd, GWL_WNDPROC, LongInt(@DefWndProc)));
      RePaintWindow(Wnd);
    end;
    Result:= true;
    ResumeThread(hThread);
  end;
end;
 
function TGifViewer.LoadFile(FileName: PWCHAR): boolean;
var
  FrameDimensionTime: TGUID;
begin
  Finish;
  if GdipLoadImageFromFile(FileName, hGdipImage) = 0 then
  begin
    GdipGetImageWidth(hGdipImage, UINT(Width));
    GdipGetImageHeight(hGdipImage, UINT(Height));
    GdipImageGetFrameDimensionsList(hGdipImage, @FrameDimensionTime, 1);
    GdipImageGetFrameCount(hGdipImage, @FrameDimensionTime, UINT(Frames));
  end
  else hGdipImage:= 0;
 
  Result:= hGdipImage <> 0;
end;
 
function TGifViewer.GifView(Handle: HWND; FileName: PWCHAR): boolean;
begin
  Finish;
  LoadFile(FileName);
  SetHandle(Handle);
  Result:= Start;
end;
 
procedure TGifViewer.Finish;
begin
  if hGdipImage <> 0 then
  begin
    GdipDisposeImage(hGdipImage);
    hGdipImage:= 0;
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    hThread:= 0;
  end;
  RePaintWindow(Wnd);
end;
 
function TGifViewer.Start(): boolean;
begin
  if (Wnd <> 0) and (hGdipImage <> 0) and (hThread = 0) then
    hThread:= CreateThread(nil, 0, @ThGif, self, 0, PDWORD(0)^);
  Result:= hThread <> 0;
end;
 
function TGifViewer.GetWidth: integer;
begin
  Result:= Width;
end;
 
function TGifViewer.GetHeight: integer;
begin
  Result:= Height;
end;
 
function TGifViewer.GetFrames: UINT;
begin
  Result:= Frames;
end;
 
constructor TGifViewer.Create;
var
  GdiPlusStartupInput: array[0..2] of int64;
begin
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) = 0 then inc(GDI);
  if hEvent = 0 then hEvent:= CreateEvent(nil, true, false, nil);
end;
 
destructor TGifViewer.Destroy;
begin
  dec(GDI);
  Finish;
  SetHandle(0);
  if GDI = 0 then GdiplusShutdown(gdiplusToken);
  inherited Destroy;
end;
 
end.

Un ejemplo con VCL:

delphi

unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, _GifViewer, StdCtrls, ExtCtrls;
 
type
  TForm1 = class(TForm)
    Panel1: TPanel;
    Button1: TButton;
    OpenDialog1: TOpenDialog;
    Panel2: TPanel;
    Button2: TButton;
    Button3: TButton;
    Button4: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure Button4Click(Sender: TObject);
  private
    GV1: TGifViewer;
    GV2: TGifViewer;
  public
    { Public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.FormCreate(Sender: TObject);
begin
  GV1:= TGifViewer.Create;
  GV2:= TGifViewer.Create;
  //GV1.GifView(Panel1.Handle, 'Muerte.gif');
  if not GV1.GifView(Panel1.Handle, 'Muerte.gif') then GV1.SetHandle(0);
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  if OpenDialog1.Execute then
    GV1.GifView(Panel1.Handle, PWCHAR(WideString(OpenDialog1.FileName)));
end;
 
procedure TForm1.Button2Click(Sender: TObject);
begin
  if OpenDialog1.Execute then
  begin
    if GV2 = nil then GV2:= TGifViewer.Create;
    GV2.GifView(Panel2.Handle, PWCHAR(WideString(OpenDialog1.FileName)));
  end;  
end;
 
procedure TForm1.Button3Click(Sender: TObject);
begin
   GV2.Free;
   GV2:= nil;
end;
 
procedure TForm1.Button4Click(Sender: TObject);
begin
  if Assigned(GV2) then
  begin
    GV1.SetHandle(0);
//    GV2.SetHandle(0);
    GV2.SetHandle(Panel1.Handle);
  end;
end;
 
end.

Un ejemplo usando sólo API:

delphi

program GifTopMost;
 
uses
  Windows,
  Messages,
  _GifViewer;
 
var
  lpFileName: PWCHAR;
  GV: TGifViewer;
  WinClass: WNDCLASS;
  Rect: TRect;
  hFrame: HWND;
  Msg: TMsg;
 
begin
  if ParamStr(1) = '' then
    lpFileName := 'muerte.gif'
  else
    lpFileName:= PWideChar(WideString(ParamStr(1)));
 
  // Abrimos un archivo Gif para saber sus dimnesiones y crear una ventana
  GV:= TGifViewer.Create;
  GV.LoadFile(lpFileName);
 
  // Creamos una ventana...
  GetClientRect(GetDesktopWindow, Rect);
  ZeroMemory(@WinClass, sizeof(WinClass));
  WinClass.lpfnWndProc:= @DefWindowProc;
  WinClass.lpszClassName:= 'GIFFRAME';
  WinClass.hCursor:= LoadCursor(0, IDC_ARROW);
  RegisterClass(WinClass);
  hFrame:= CreateWindowEx(WS_EX_LAYERED or WS_EX_TOPMOST or WS_EX_TOOLWINDOW, 'GIFFRAME', '', WS_VISIBLE or WS_POPUP,
                          (Rect.right - integer(GV.GetWidth)) div 2,
                          (Rect.bottom - integer(GV.GetHeight)) div 2,
                          GV.GetWidth, GV.GetHeight,
                          HWND_DESKTOP, HMENU(0), 0, nil);
  SetLayeredWindowAttributes(hFrame, 0, 220, LWA_ALPHA);
 
  GV.SetHandle(hFrame);   // Asociamos el Handle de nuestra ventana donde pintará el Gif
  if GV.Start then        // Si el Gif arranca iniciamos el bucle de mensajes de la app
  repeat
    GetMessage(Msg, 0, 0, 0);
    TranslateMessage(Msg);
    DispatchMessage(Msg);
  until not IsWindow(hFrame);
 
  // Alt+F4 Cerrará la ventana y termina la app
  GV.Free;
end.

 
 
Está probado en delphi 6, 7, y Berlin.
 
Por las limitaciones de D6 y 7 he usado la API SetWindowLong para realizar el subclassing. En el caso de querer compilar para 64bits debería usarse SetWindowLongPtr. más abajo publico una versión de la clase adaptada a Lazarus que está preparada para compilar a 32 y 64 bits y puede servir de guía. Aprovechando la adaptación a Lazarus, he incluido alguna pequeña mejora a la clase que publico en las entradas correspondientes a delphi y C++
 

Saludos.

Attached Files

•  Berlin.rar   605.37KB   6 downloads
•  Delphi.rar   164.07KB   8 downloads
•  GifTopMost.rar   17.27KB   7 downloads

[escafandra]

Ahora le toca a C++ aunque en realidad el código delphi es una traducción y adaptación del código inicialmente escrito en C++.

La clase es totalmente equivalente a la mostrada.
 
GifViewer.h

cpp

//------------------------------------------------------------------------------
// GifViewer V 2.0
// escafandra 2018
// Clase para representar un gif estático o animado sobre cualquier ventana.
// Usa GDI+
 
#ifndef GifViewer_H
#define GifViewer_H
 
#include <windows.h>
 
#ifndef STRICT
  typedef int  (__stdcall *PLRESULT)();
#else
  typedef WNDPROC PLRESULT;
#endif
 
class TGifViewer
{
  private:
  ULONG_PTR gdiplusToken;
  HWND      hWnd;
  PLRESULT  OldWndProc;
  LONG_PTR  OldUserData;
  HANDLE    hThread;
  HANDLE    hGdipImage;
  INT       Width;
  INT       Height;
  UINT      Frames;
 
  static HANDLE hEvent;
  static DWORD  GDI;
 
  static LRESULT __stdcall DefWndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam);
  LRESULT __stdcall WndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam);
  static DWORD __stdcall ThGif(PVOID GifViewer);
 
  public:
  INT  Left;
  INT  Top;
  BOOL GifView(HWND hWnd, PWCHAR FileName);
  BOOL SetHandle(HWND hWnd);
  BOOL LoadFile(PWCHAR FileName);
  INT  GetWidth()  {return Width;}
  INT  GetHeight() {return Height;}
  UINT GetFrames() {return Frames;}
  BOOL Start();
  void End();
 
  TGifViewer();
  ~TGifViewer();
};
 
#endif

GifViewer.cpp

cpp

//------------------------------------------------------------------------------
// GifViewer V 2.0
// escafandra 2018
// Clase para representar un gif estático o animado sobre cualquier ventana.
// Usa GDI+
 
 
#include <windows.h>
#include <initguid.h>
#pragma hdrstop
#include "GifViewer.h"
 
#pragma link "gdiplus.lib"
 
extern "C"{
DWORD __stdcall GdiplusStartup(ULONG_PTR *hToken, void *input, void *Output);
void  __stdcall GdiplusShutdown(ULONG_PTR token);
DWORD __stdcall GdipLoadImageFromFile(PWCHAR FileName, HANDLE &hImage);
DWORD __stdcall GdipDrawImageRectI(HANDLE hGraphics, HANDLE hImage, INT Left, INT Top, INT Width, INT Height);
DWORD __stdcall GdipCreateFromHDC(HDC hDC, HANDLE* hGraphics);
DWORD __stdcall GdipImageGetFrameDimensionsList(HANDLE image, GUID* dimensionIDs, UINT count);
DWORD __stdcall GdipImageGetFrameCount(HANDLE image, const GUID* dimensionIDs, UINT *count);
DWORD __stdcall GdipImageSelectActiveFrame(HANDLE image, const GUID* dimensionIDs, UINT frameIndex);
DWORD __stdcall GdipGetPropertyItemSize(HANDLE image, UINT dwPropId, PUINT Size);
DWORD __stdcall GdipGetPropertyItem(HANDLE image, UINT dwPropId, UINT Size, PVOID lpBuffer);
DWORD __stdcall GdipGetImageWidth(HANDLE image, PUINT Width);
DWORD __stdcall GdipGetImageHeight(HANDLE image, PUINT Height);
DWORD __stdcall GdipDeleteGraphics(HANDLE hGraphics);
DWORD __stdcall GdipDisposeImage(HANDLE hImage);
}
 
 
struct TPropertyItem
{
  PROPID id;
  ULONG  length;
  WORD   type;
  PVOID  value;
};
typedef TPropertyItem* PPropertyItem;
 
#define PropertyTagFrameDelay 0x5100
DEFINE_GUID(FrameDimensionTime, 0x6aedbd6d,0x3fb5,0x418a,0x83,0xa6,0x7f,0x45,0x22,0x9d,0xc8,0x72);
 
WCHAR lpFileName[MAX_PATH];
 
BOOL RePaintWindow(HWND hWnd)
{
  RECT Rect;
  GetClientRect(hWnd, &Rect);
  return RedrawWindow(hWnd, &Rect, 0, RDW_INVALIDATE|RDW_ERASE|RDW_UPDATENOW|RDW_ALLCHILDREN);
}
 
//---------------------------------------------------------------------------
void TGifViewer::End()
{
  if(hGdipImage){
    GdipDisposeImage(hGdipImage);
    hGdipImage = 0;
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    hThread = 0;
  }
  RePaintWindow(hWnd);
}
//---------------------------------------------------------------------------
 
BOOL TGifViewer::Start()
{
  if(hWnd && hGdipImage && !hThread)
    hThread = CreateThread(0, 0, &TGifViewer::ThGif, this, 0, 0);
 
  return hThread != 0;
}
//---------------------------------------------------------------------------
 
 
BOOL TGifViewer::LoadFile(PWCHAR FileName)
{
  End();
  if(GdipLoadImageFromFile(FileName, hGdipImage) == 0){
	GdipGetImageWidth(hGdipImage, (PUINT)&Width);
	GdipGetImageHeight(hGdipImage,  (PUINT)&Height);
	GdipImageGetFrameCount(hGdipImage, &FrameDimensionTime, (PUINT)&Frames);
  }
  else hGdipImage = 0;
 
  return hGdipImage != 0;
}
//---------------------------------------------------------------------------
 
DWORD __stdcall TGifViewer::ThGif(PVOID Param)
{
  RECT Rect, RParent;
  PDWORD Wait;
  PPropertyItem Pi;
  //GUID FrameDimensionTime;
  HDC hDC;
  HANDLE hGraphics;
  UINT nBytes, Frames, Index;
  TGifViewer *GV = (TGifViewer*)Param;
 
  // Esperamos a que se inicien los mensajes de ventana
  if(hEvent) WaitForSingleObject(hEvent, INFINITE);
  if(GV->hGdipImage && GV->hWnd){
    GdipGetPropertyItemSize(GV->hGdipImage, PropertyTagFrameDelay, &nBytes);
    Pi = (PPropertyItem)LocalAlloc(LMEM_FIXED, nBytes);
    GdipGetPropertyItem(GV->hGdipImage, PropertyTagFrameDelay, nBytes, Pi);
  //  GdipImageGetFrameDimensionsList(hImage, &_FrameDimensionTime, 1);
    GdipImageGetFrameCount(GV->hGdipImage, &FrameDimensionTime, &Frames);
 
    Index = 0;
    Wait = PDWORD(Pi->value);
    if(Pi->type == sizeof(DWORD))
    do{
      hDC = GetDC(GV->hWnd);
      GdipCreateFromHDC(hDC, &hGraphics);
      GdipImageSelectActiveFrame(GV->hGdipImage, &FrameDimensionTime, Index);
      GdipDrawImageRectI(hGraphics, GV->hGdipImage, GV->Left, GV->Top, GV->Width, GV->Height);
      GdipDeleteGraphics(hGraphics);
      ReleaseDC(GV->hWnd, hDC);
      Sleep(Wait[Index] * 10);
      Index = (Index + 1) % Frames;
    } while(GV->hWnd && GV->hGdipImage);
  }
  LocalFree(Pi);
  return 0;
}
 
//---------------------------------------------------------------------------
// Tratamiento de Mensajes
LRESULT __stdcall TGifViewer::DefWndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam)
{
  if(Msg == WM_PAINT && hEvent) SetEvent(hEvent);  // Pemitimos que arranque el Thread
 
  TGifViewer* pGifViewer = (TGifViewer*)GetWindowLongPtr(hWnd, GWL_USERDATA);
  if(pGifViewer)
    return pGifViewer->WndProc(hWnd, Msg, WParam, LParam);
  else return DefWindowProc(hWnd, Msg, WParam, LParam);
}
 
LRESULT __stdcall TGifViewer::WndProc(HWND hWnd, UINT Msg, WPARAM WParam, LPARAM LParam)
{
  if(Msg == WM_PAINT && hGdipImage){ // && hGdipImage)
    RECT R = {Left, Top, Left+Width, Top+Height};
    ValidateRect(hWnd, &R);
//    return DefWindowProc(hWnd, Msg, WParam, LParam);
  }
  return CallWindowProc(OldWndProc, hWnd, Msg, WParam, LParam);
}
//---------------------------------------------------------------------------
 
BOOL TGifViewer::SetHandle(HWND Handle)
{
  if((PVOID)GetWindowLongPtr(Handle, GWL_WNDPROC) != &TGifViewer::DefWndProc){
    SuspendThread(hThread);
    if(hWnd){
      SetWindowLongPtr(hWnd, GWL_USERDATA, OldUserData);
      SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG_PTR)OldWndProc);
      RePaintWindow(hWnd);
      hWnd = 0;
    }
 
    if(Handle && IsWindow(Handle)){
      hWnd = Handle;
      OldUserData = SetWindowLongPtr(hWnd, GWL_USERDATA, (LONG_PTR)this);
      OldWndProc = (PLRESULT)SetWindowLongPtr(hWnd, GWL_WNDPROC, (LONG)&TGifViewer::DefWndProc);
      RePaintWindow(hWnd);
//      PostMessage(hWnd, WM_PAINT, 0, 0);
    }
    ResumeThread(hThread);
    return true;
  }
  return false;
}
//---------------------------------------------------------------------------
 
BOOL TGifViewer::GifView(HWND Wnd, PWCHAR FileName)
{
  End();
  LoadFile(FileName);
  SetHandle(Wnd);
  return Start();
}
//---------------------------------------------------------------------------
 
TGifViewer::TGifViewer()
{
  char GdiPlusStartupInput[16] = {1,0};
  if(!GDI) GdiplusStartup(&gdiplusToken, GdiPlusStartupInput, NULL);
  GDI++;
  hThread    = 0;
  hGdipImage = 0;
  Left       = 0;
  Top        = 0;
  Width      = 0;
  Height     = 0;
}
//---------------------------------------------------------------------------
 
TGifViewer::~TGifViewer()
{
  GDI--;
  End();
  SetHandle(0);
  if(!GDI) GdiplusShutdown(gdiplusToken);
}
 
HANDLE TGifViewer::hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
DWORD  TGifViewer::GDI = 0;

Un ejemplo usando VCL:

cpp

//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
#include "GifViewer.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
 
TGifViewer GV1;
TGifViewer *GV2 = 0;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
  : TForm(Owner)
{
//  GV1.GifView(Panel1->Handle, L"Muerte.gif");
  if(!GV1.GifView(Panel1->Handle, L"Muerte.gif")) GV1.SetHandle(0);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button1Click(TObject *Sender)
{
  if(OpenDialog1->Execute()) {
    GV1.GifView(Panel1->Handle, WideString(OpenDialog1->FileName).c_bstr());
  }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
  if(OpenDialog1->Execute()) {
    if(GV2) delete GV2;
    GV2 = new TGifViewer;
    GV2->GifView(Panel2->Handle, WideString(OpenDialog1->FileName).c_bstr());
  }
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button3Click(TObject *Sender)
{
  delete GV2;
  GV2 = 0;
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::Button4Click(TObject *Sender)
{
  if(GV2){
    GV1.SetHandle(0);
    GV2->SetHandle(Panel1->Handle);
  }  
}
//---------------------------------------------------------------------------

Un ejemplo usando API:

cpp

//---------------------------------------------------------------------------
 
#include <windows.h>
#include "GifViewer.h"
 
#pragma hdrstop
 
//---------------------------------------------------------------------------
 
#pragma argsused
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  MSG Msg;
  WNDCLASS WinClass = {0};
  HWND hFrame;
  RECT Rect;
  PWCHAR lpFileName;
 
  int Argc;
  LPWSTR *Argv = CommandLineToArgvW(GetCommandLineW(), &Argc);
  if(Argc >= 2)
    lpFileName = Argv[1];
   else
    lpFileName = L"muerte.gif";
 
  // Abrimos un archivo Gif para saber sus dimnesiones y crear una ventana
  TGifViewer GV;
  GV.LoadFile(lpFileName);
  GetClientRect(GetDesktopWindow(), &Rect);
 
  // Creamos una ventana...
  WinClass.lpfnWndProc = DefWindowProc;
  WinClass.lpszClassName = "GIFFRAME";
  WinClass.hCursor = LoadCursor(0, IDC_ARROW);
  RegisterClass(&WinClass);
  hFrame = CreateWindowEx(WS_EX_LAYERED|WS_EX_TOPMOST|WS_EX_TOOLWINDOW, "GIFFRAME", "", WS_VISIBLE|WS_POPUP,
                          (Rect.right - GV.GetWidth())/2,
                          (Rect.bottom - GV.GetHeight())/2,
                          GV.GetWidth(), GV.GetHeight(),
                          HWND_DESKTOP, (HMENU)0, 0, 0);
  SetLayeredWindowAttributes(hFrame, 0, 220, LWA_ALPHA);
 
  GV.SetHandle(hFrame); // Asociamos el Handle de nuestra ventana
  if(GV.Start())        // Si el Gif arranca iniciamos el bucle de mensajes de la app
  do{
    GetMessage(&Msg, 0, 0, 0);
    TranslateMessage(&Msg);
    DispatchMessage(&Msg);
  }while(IsWindow(hFrame));
 
  // Alt+F4 Cerrará la ventana y termina la app
  return 0;
}
//---------------------------------------------------------------------------

Probado en Builder BCB5 y Berlin
 
BCB5 no tiene las limitaciones de D6 y 7 por lo que he usado la API SetWindowLongPtr para realizar el subclassing. Aprovechando la adaptación de la clase a Lazarus, para incluir alguna pequeña mejora a la clase.
 
 
Saludos.

Attached Files

•  TGifViewer C++.rar   184.15KB   2 downloads
•  GifTopMost C++.rar   43.64KB   2 downloads
•  Berlin C++.rar   73.22KB   2 downloads

[egostar]

Vaya, que daría por tener el tiempo para aprender C++ y poder "traducir" de un lenguaje a otro como lo haces tu amigo escafandra. 

 

Muy buen aporte.

 

Saludos

[escafandra]

Vaya, que daría por tener el tiempo para aprender C++ y poder "traducir" de un lenguaje a otro como lo haces tu amigo escafandra. 

 

Muy buen aporte.

 

Saludos

 

En realidad no es complejo en absoluto una vez que has parido el código y personalmente paso buenos ratos con estas cosas.

 

Saludos.

[escafandra]

No he podido resistir la tentación de probar el código en Lazarus. Para ello he tenido que realizar algún cambio para adaptarlo desde delphi ya que a bajo nivel hay alguna pequeña diferencia sintáctica con los punteros y algún tipo, además, he aprovechado para que compile también en 64bits y dotarle de alguna mejora que he trasladado a las versiones delphi y cpp.

 

La explicación de la primera entrada de delphi, es totalmente válida para la versión Lazarus dado que la clase es básicamente la misma. 

 

Este es el código de la clase, adjunto un archivo con el código y una APP de ejemplo similar a las versiones delphi y cpp.

delphi

unit Lz_gifviewer;
 
//------------------------------------------------------------------------------
// GifViewer V 2.0
// escafandra 2018
// Clase para representar un gif estático o animado sobre cualquier ventana.
// Usa GDI+
// Versión Lazarus para compilar en 32 y 64 bits
 
 
interface
 
uses Windows, Messages;
 
function GdiplusStartup(var GdiToken: DWORD; Startup, Output: PBYTE): DWORD; stdcall external 'gdiplus';
function GdipLoadImageFromFile(lpFileName: PWideChar; var hImage: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipDrawImageRectI(hGraphics, hImage: THANDLE; Left, Top, Width, Height: Integer): DWORD; stdcall external 'gdiplus';
function GdipCreateFromHDC(DC: HDC; var hGraphics: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipImageSelectActiveFrame(hImage: THANDLE; DimensionID: PGUID; frameIndex: Integer): DWORD; stdcall external 'gdiplus';
function GdipImageGetFrameDimensionsList(hImage: THANDLE; dimensionIDs: PGUID; Count: Integer): DWORD; stdcall external 'gdiplus';
function GdipGetPropertyItemSize(hImage: THANDLE; dwPropId: Integer; var Size: UINT): Integer; stdcall external 'gdiplus';
function GdipGetPropertyItem(hImage: THANDLE; dwPropID, Size: Integer; lpBuffer: Pointer): DWORD; stdcall external 'gdiplus';
function GdipImageGetFrameCount(hImage: THANDLE; lpDimensionID: PGUID; out Count: UINT): DWORD; stdcall external 'gdiplus';
function GdipGetImageWidth(hImage: THANDLE; var Width: UINT): DWORD; stdcall external 'gdiplus';
function GdipGetImageHeight(hImage: THANDLE; var Height: UINT): DWORD; stdcall external 'gdiplus';
function GdipDeleteGraphics(hGraphics: THANDLE): DWORD; stdcall external 'gdiplus';
function GdipDisposeImage(hImage: THANDLE): DWORD; stdcall external 'gdiplus';
procedure GdiplusShutdown(GdiToken: DWORD); stdcall external 'gdiplus';
 
type
TWNDPROC = function(Wnd: HWND; msg: UINT; WParam: WPARAM; LParam: LPARAM): LRESULT; stdcall;
TDWORDArray = array[0..0] of DWORD;
PDWORDArray = ^TDWORDArray;
 
TGifViewer = class
  private
    Wnd: HWND;
    OldWndProc: TWNDPROC;
    OldUserData: DWORD;
    gdiplusToken: DWORD;
    hThread: THANDLE;
    hGdipImage: THANDLE;
    Width:  integer;
    Height: integer;
    Frames: UINT;
    function WndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
 
  public
    Left:     integer;
    Top:      integer;
    function  GifView(Handle: HWND; FileName: PWCHAR): boolean;
    function  SetHandle(Handle: THANDLE): boolean;
    function  LoadFile(FileName: PWCHAR): boolean;
    function  GetWidth:  integer;
    function  GetHeight: integer;
    function  GetFrames: UINT;
    function  Start: boolean;
    procedure Finish;
 
    constructor Create;
    destructor Destroy; override;
end;
PGifViewer = ^TGifViewer;
 
TPropertyItem = record
  id:     ULONG;
  length: ULONG;
  _type:  WORD;
  value:  Pointer;
end;
PPropertyItem = ^TPropertyItem;
 
 
const
  PropertyTagFrameDelay = $5100;
var
  GDI:    DWORD = 0;
  hEvent: THandle = 0;
 
implementation
 
function RePaintWindow(Wnd: HWND): boolean;
var
  Rect: TRect;
begin
  GetClientRect(Wnd, @Rect);
  Result:= RedrawWindow(Wnd, @Rect, 0, RDW_INVALIDATE or RDW_ERASE or RDW_UPDATENOW or RDW_ALLCHILDREN);
end;
 
function ThGif(GV: TGifViewer): DWORD; stdcall;
var
  Pi: PPropertyItem;
  Wait: PDWORDArray;
  DC: HDC;
  hGdipGraphics: THANDLE;
  nBytes, Frames, Index: UINT;
  FrameDimensionTime: TGUID;
begin
  // Esperamos a que se pinte una ventana WM_PAINT
  if hEvent <> 0 then WaitForSingleObject(hEvent, INFINITE);
 
  if (GV.hGdipImage <> 0) and (GV.Wnd <> 0) then
  begin
    GdipGetPropertyItemSize(GV.hGdipImage, PropertyTagFrameDelay, nBytes);
    Pi:= PPropertyItem(LocalAlloc(LMEM_FIXED, nBytes));
    GdipGetPropertyItem(GV.hGdipImage, PropertyTagFrameDelay, nBytes, Pi);
    GdipImageGetFrameDimensionsList(GV.hGdipImage, @FrameDimensionTime, 1);
    GdipImageGetFrameCount(GV.hGdipImage, @FrameDimensionTime, Frames);
 
    Index:= 0;
    Wait:= PDWORDArray(Pi^.value);
    if Pi^._type = sizeof(DWORD) then
    repeat
      DC:= GetDC(GV.Wnd);
      GdipCreateFromHDC(DC, hGdipGraphics);
      GdipImageSelectActiveFrame(GV.hGdipImage, @FrameDimensionTime, Index);
      GdipDrawImageRectI(hGdipGraphics, GV.hGdipImage, GV.Left, GV.Top, GV.Width, GV.Height);
      GdipDeleteGraphics(hGdipGraphics);
      ReleaseDC(GV.Wnd, DC);
      Sleep(Wait^[Index] * 10);
      Index:= (Index + 1) mod Frames;
    until (GV.Wnd = 0) or (GV.hGdipImage = 0);
  end;
  LocalFree(HLOCAL(Pi));
  Result:= 0;
end;
 
function DefWndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
var
  pGifViewer: TGifViewer;
begin
  if (Msg = WM_PAINT) and (hEvent <> 0) then SetEvent(hEvent);  // Pemitimos que arranque el Thread
 
  pGifViewer:= TGifViewer(GetWindowLongPtr(Handle, GWL_USERDATA));
  if pGifViewer <> nil then
    Result:= pGifViewer.WndProc(Handle, Msg, WParam, LParam)
  else
    Result:= DefWindowProc(Handle, Msg, WParam, LParam);
end;
 
function TGifViewer.WndProc(Handle: HWND; Msg: DWORD; WParam: DWORD; LParam: DWORD): DWORD; stdcall;
var
  R: TRect;
begin
  if (Msg = WM_PAINT) and (hGdipImage <> 0) then
  begin
    R.Left:= Left; R.Top:= Top; R.Right:= Left+Width; R.Bottom:= Top+Height;
    ValidateRect(Wnd, R);
    //Result:= DefWindowProc(Handle, Msg, WParam, LParam);
    //Exit;
  end;
  Result:= CallWindowProc(OldWndProc, Handle, Msg, WParam, LParam);
end;
 
function TGifViewer.SetHandle(Handle: THANDLE): boolean;
begin
  Result:= false;
  if Pointer(GetWindowLongPtr(Handle, GWL_WNDPROC)) <> Pointer(@DefWndProc) then
  begin
    SuspendThread(hThread);
    if (Wnd <> 0) then
    begin
      SetWindowLongPtr(Wnd, GWL_USERDATA, OldUserData);
      SetWindowLongPtr(Wnd, GWL_WNDPROC, LongInt(OldWndProc));
      RePaintWindow(Wnd);
      Wnd:= 0;
    end;
 
    if (Handle <> 0) and IsWindow(Handle) then
    begin
      Wnd:= Handle;
      OldUserData:= SetWindowLongPtr(Wnd, GWL_USERDATA, LONG_PTR(self));
      OldWndProc:= TWNDPROC(SetWindowLongPtr(Wnd, GWL_WNDPROC, LONG_PTR(@DefWndProc)));
      RePaintWindow(Wnd);
    end;
    Result:= true;
    ResumeThread(hThread);
  end;
end;
 
function TGifViewer.LoadFile(FileName: PWCHAR): boolean;
var
  FrameDimensionTime: TGUID;
begin
  Finish;
  if GdipLoadImageFromFile(FileName, hGdipImage) = 0 then
  begin
    GdipGetImageWidth(hGdipImage, UINT(Width));
    GdipGetImageHeight(hGdipImage, UINT(Height));
    GdipImageGetFrameDimensionsList(hGdipImage, @FrameDimensionTime, 1);
    GdipImageGetFrameCount(hGdipImage, @FrameDimensionTime, UINT(Frames));
  end
  else hGdipImage:= 0;
 
  Result:= hGdipImage <> 0;
end;
 
function TGifViewer.GifView(Handle: HWND; FileName: PWCHAR): boolean;
begin
  Finish;
  LoadFile(FileName);
  SetHandle(Handle);
  Result:= Start;
end;
 
procedure TGifViewer.Finish;
begin
  if hGdipImage <> 0 then
  begin
    GdipDisposeImage(hGdipImage);
    hGdipImage:= 0;
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);
    hThread:= 0;
  end;
  RePaintWindow(Wnd);
end;
 
function TGifViewer.Start(): boolean;
begin
  if (Wnd <> 0) and (hGdipImage <> 0) and (hThread = 0) then
    hThread:= CreateThread(nil, 0, @ThGif, self, 0, PDWORD(0)^);
  Result:= hThread <> 0;
end;
 
function TGifViewer.GetWidth: integer;
begin
  Result:= Width;
end;
 
function TGifViewer.GetHeight: integer;
begin
  Result:= Height;
end;
 
function TGifViewer.GetFrames: UINT;
begin
  Result:= Frames;
end;
 
constructor TGifViewer.Create;
var
  GdiPlusStartupInput: array[0..2] of int64;
begin
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) = 0 then inc(GDI);
  if hEvent = 0 then hEvent:= CreateEvent(nil, true, false, nil);
end;
 
destructor TGifViewer.Destroy;
begin
  dec(GDI);
  Finish;
  SetHandle(0);
  if GDI = 0 then GdiplusShutdown(gdiplusToken);
  inherited Destroy;
end;
 
end.

Saludos.

Attached Files

•  Lazarus 32-64bits.rar   249.62KB   3 downloads

[escafandra]

GifViewer V 3.1

He necesitado usar este visor portando la imagen Gif en un archivo de recursos. Como ya ocurrió con el componente VCL TGifViewer al que tuve que dotarle de la posibilidad de cargar la imagen desde el archivo de recursos, ahora lo hago para este visor API GDIplus.

Siguiendo la filosofía de este visor, no uso la VCL y me ciño al uso exclusivo de la API de Windows. Hay dos novedades interesantes. por un lado permite cargar archivos desde un recurso RCDATA. Por otro lado permite centrar la imagen en la ventana seleccionada. Desde el punto de vista del usuario estas son las funciones añadidas:

delphi y Lazarus:

delphi

function  GifView(Handle: HWND; FileName: PWCHAR; VCenter: boolean = false): boolean;
function  GifViewFromResource(Handle: HWND; ID_GIF: PWCHAR; VCenter: boolean = false): boolean;
function  LoadFromResource(ID_GIF: PWCHAR): boolean;

C++

cpp

BOOL GifView(HWND hWnd, PWCHAR FileName, BOOL Center = false);
BOOL GifViewFromResource(HWND hWnd, PWCHAR ID_GIF, BOOL Center = false);
BOOL LoadFromResource(PWCHAR ID_GIF);

El método GifView sustituye al anterior del mismo nombre, siendo ambos totalmente compatibles, sólo añade la posibilidad de centrar el Gif en la ventana destino y por defecto no se centra.

 

El código que permite la carga del recurso es como sigue:

delphi

uses Windows, Messages, ActiveX;
 
//------------------
function SHCreateMemStream(pInit: PBYTE; cbInit: DWORD): Pointer; stdcall external 'shlwapi';
 
//------------------
 
function TGifViewer.LoadFromResource(ID_GIF: PWCHAR): boolean;
const
  RT_RCDATAW: PWCHAR = MakeIntResourceW(10);
var
  FrameDimensionTime: TGUID;
  Res: HRSRC;
  ResSize: DWORD;
  ResData: HGLOBAL;
  Stream: IStream;
begin
  Finish;
  Res:= FindResourceW(0, ID_GIF, RT_RCDATAW);
  if Res <> 0 then
  begin
    ResSize:= SizeofResource(0, Res);
    ResData:= LoadResource(0, Res);
    Stream:= IStream(SHCreateMemStream(PBYTE(LockResource(ResData)), ResSize));
    if GdipLoadImageFromStream(Stream, hGdipImage) = 0 then
    begin
      GdipGetImageWidth(hGdipImage, UINT(Width));
      GdipGetImageHeight(hGdipImage, UINT(Height));
      GdipImageGetFrameCount(hGdipImage, @FrameDimensionTime, UINT(Frames));
    end
    else hGdipImage:= 0;
    Stream._Release;
  end;
  Result:= hGdipImage <> 0;
end;

Para CBC5 y C++ Berlin

cpp

#ifndef BERLIN
IStream* __stdcall SHCreateMemStream(const BYTE *pInit, UINT cbInit);
typedef IStream* (__stdcall *PSHCreateMemStream)(const BYTE *pInit, UINT cbInit);
 
PSHCreateMemStream _SHCreateMemStream = 0;
#endif
 
 
//-------------------------
 
 
#define RT_RCDATAW           MAKEINTRESOURCEW(10)
BOOL TGifViewer::LoadFromResource(PWCHAR ID_GIF)
{
  End();
//  HRSRC Res = ::FindResourceA(NULL, ID_GIF, RT_RCDATA);
  HRSRC Res = ::FindResourceW(NULL, ID_GIF, RT_RCDATAW);
  HGLOBAL ResData = ::LoadResource(NULL, Res);
  UINT ResSize = ::SizeofResource(NULL, Res);
 
#ifndef BERLIN
  if(!_SHCreateMemStream)
    _SHCreateMemStream = (PSHCreateMemStream)GetProcAddress(LoadLibraryA("SHLWAPI.DLL"), "SHCreateMemStream");
 
  if(!_SHCreateMemStream)
    return false;
 
  IStream *pStream = _SHCreateMemStream((LPBYTE)LockResource(ResData), ResSize);
#else
  IStream *pStream = SHCreateMemStream((LPBYTE)LockResource(ResData), ResSize);
#endif
  if(GdipLoadImageFromStream(pStream, hGdipImage) == 0){
    GdipGetImageWidth(hGdipImage, (PUINT)&Width);
    GdipGetImageHeight(hGdipImage,  (PUINT)&Height);
    GdipImageGetFrameCount(hGdipImage, &FrameDimensionTime, (PUINT)&Frames);
  }
  else hGdipImage = 0;
  pStream->Release();
 
  return hGdipImage != 0;
}

En el  caso de que vuestro compilador defina la API SHCreateMemStream puede incluirse  una linea  #define BERLIN al principio del código de GifViewer.cpp. He comprobado que es una API bastante desconocida y que delphi Berlin no la incluye aunque si lo hace Builder Berlin. Si buscáis información para delphi en la web, no la vais a encontrar. Al menos hasta la fecha yo no lo he podido hacer.

 

Propongo un ejemplo de uso para visualizar un GIF desde un archivo de recursos:

delphi

MiGif.rc:
 
ID_WAIT RCDATA "busy.gif"

Así lo usamos en delphi y Lazarus:

delphi

GV.GifViewFromResource(Panel1.Handle, 'ID_WAIT', true);

En la versión C++ sería muy similar:

cpp

GV.GifViewFromResource(Panel1->Handle, L"ID_WAIT", true);

Como resumen completo de los métodos de la clase:

GifView(Handle: HWND; FileName: PWCHAR; VCenter: boolean = false) Establece el fichero y la ventana donde se representará y comienza la visualización.
GifViewFromResource(Handle: HWND; ID_GIF: PWCHAR; VCenter: boolean = false) Establece el Gif desde un recurso y comienza la visualización.

Finish: Termina la visualización pero no libera la ventana.
Start: Comienza la visualización si ya tenemos fichero y ventana
SetHandle(Handle: THANDLE): Asocia el visor a una ventana.
LoadFile(FileName: PWCHAR): Abre un fichero gif y obtiene sus características.
LoadFromResource(ID_GIF: PWCHAR) Carga un Gif desde un recurso,

GetWidth: Nos informa del ancho.
GetHeight: Nos informa del alto.
GetFrames: Nos informa del número de imágenes del gif.

 

 

 

Adjunto el código de la actualización para
C++ BCB5 y Berlin
delphi 7 y Berlin
Lazarus 32 y 64 bits


Saludos

Attached Files

•  GifViewer3 Lazarus.rar   274.16KB   5 downloads
•  GifViewer3 delphi Berlin.rar   655.05KB   9 downloads
•  GifViewer3 BCB5.rar   239.18KB   2 downloads
•  GifViewer3 Delphi7.rar   213.67KB   6 downloads
•  GifViewer3 Berlin C++.rar   103.65KB   3 downloads

[egostar]

A esto es lo que yo llamo un código multilenguaje. mis respetos 

 

Saludo amigo escafandra

[escafandra]

Para mejorar el comportamiento gráfico al centrar el Gif, he actualizado a GifViewer V 3.1

Los nuevos enlaces del código están en esa entrada a la que he añadido un pequeño resumen de todos métodos para compactar la publicación.

Saludos.