Newsgroup: it.comp.lang.delphi
Titolo: Stampare un Jpeg [lunghetto]

Ciao a tutti.
Ho un piccolo preblema e spero di avere da qualcuno di voi qualche dritta.
Sto realizzando un programmino che stampa delle immagini (in pratica il
contenuto di un componente TImage); per svlupparlo mi sono appoggiato ad una
procedura presa dal sito Borland qualche anno fa, che converte il bitmap del
componente in un formato compatibile con il "canvas" del TPrinter.
In realtà tutto funziona a dovere, però se carico nella TIMage un file jpg
l'immagine non viene stampata; ovviamente per poter usare TImage con i jpg
ho inserito "uses Jpeg".
Forse è a causa del fatto che il formato jpeg è l'unico ad essere compreso
(bmp e gif non lo sono) tra quelli utilizzabili dal TImage?
Come posso fare per stampare anche i jpeg?
Uso D5 pro. In basso trovate la procedura principale.
Grazie anticipate a tutti :o)
Panoramix
Ecco allegato il codice della procedura di conversione Bitmap:
{---------------------------------------------------------------------------
---}
procedure BltTBitmapAsDib(DestDc : hdc;   {Handle of where to blt}
                          x : word;       {Bit at x}
                          y : word;       {Blt at y}
                          Width : word;   {Width to stretch}
                          Height : word;  {Height to stretch}
                          bm : TBitmap);  {the TBitmap to Blt}
var
  MainForm         : TMainForm;
  Ratio            : real;
  RTx, RTy         : real;
  NoPrnMM, NoPrnPX : TPoint;
  Sele             : byte;
  FF               : File of TRecFile ;
  RF               : TRecFile;
  ProgPath         : String;
  MRG              : array[1..5] of TPoint;
  VisBuco          : Boolean;
  Dime             : array[1..5] of TPoint;
  ImgFile          : string;
implementation
uses UPrint, UPage, USplash, UEdit;
{$R *.DFM}
{---------------------------------------------------------------------------
---}
procedure BltTBitmapAsDib(DestDc : hdc;   {Handle of where to blt}
                          x : word;       {Bit at x}
                          y : word;       {Blt at y}
                          Width : word;   {Width to stretch}
                          Height : word;  {Height to stretch}
                          bm : TBitmap);  {the TBitmap to Blt}
var
  OriginalWidth :LongInt;               {width of BM}
  dc : hdc;                             {screen dc}
  IsPaletteDevice : bool;               {if the device uses palettes}
  IsDestPaletteDevice : bool;           {if the device uses palettes}
  BitmapInfoSize : integer;             {sizeof the bitmapinfoheader}
  lpBitmapInfo : PBitmapInfo;           {the bitmap info header}
  hBm : hBitmap;                        {handle to the bitmap}
  hPal : hPalette;                      {handle to the palette}
  OldPal : hPalette;                    {temp palette}
  hBits : THandle;                      {handle to the DIB bits}
  pBits : pointer;                      {pointer to the DIB bits}
  lPPalEntriesArray : PPalEntriesArray; {palette entry array}
  NumPalEntries : integer;              {number of palette entries}
  i : integer;                          {looping variable}
begin
  OriginalWidth := bm.Width;
  dc := GetDc(0);
  IsPaletteDevice :=
    GetDeviceCaps(dc, RASTERCAPS) and RC_PALETTE = RC_PALETTE;
  dc := ReleaseDc(0, dc);
  if IsPaletteDevice then
    BitmapInfoSize := sizeof(TBitmapInfo) + (sizeof(TRGBQUAD) * 255)
  else
    BitmapInfoSize := sizeof(TBitmapInfo);
  GetMem(lpBitmapInfo, BitmapInfoSize);
  FillChar(lpBitmapInfo^, BitmapInfoSize, #0);
  lpBitmapInfo^.bmiHeader.biSize := sizeof(TBitmapInfoHeader);
  lpBitmapInfo^.bmiHeader.biWidth := OriginalWidth;
  lpBitmapInfo^.bmiHeader.biHeight := bm.Height;
  lpBitmapInfo^.bmiHeader.biPlanes := 1;
  if IsPaletteDevice then
    lpBitmapInfo^.bmiHeader.biBitCount := 8
  else
    lpBitmapInfo^.bmiHeader.biBitCount := 24;
  lpBitmapInfo^.bmiHeader.biCompression := BI_RGB;
  lpBitmapInfo^.bmiHeader.biSizeImage :=
    ((lpBitmapInfo^.bmiHeader.biWidth *
      longint(lpBitmapInfo^.bmiHeader.biBitCount)) div 8) *
      lpBitmapInfo^.bmiHeader.biHeight;
  lpBitmapInfo^.bmiHeader.biXPelsPerMeter := 0;
  lpBitmapInfo^.bmiHeader.biYPelsPerMeter := 0;
  if IsPaletteDevice then begin
    lpBitmapInfo^.bmiHeader.biClrUsed := 256;
    lpBitmapInfo^.bmiHeader.biClrImportant := 256;
  end else begin
    lpBitmapInfo^.bmiHeader.biClrUsed := 0;
    lpBitmapInfo^.bmiHeader.biClrImportant := 0;
  end;
  hBm := bm.ReleaseHandle;
  hPal := bm.ReleasePalette;
  dc := GetDc(0);
  if IsPaletteDevice then
  begin
    OldPal := SelectPalette(dc, hPal, TRUE);
    RealizePalette(dc);
  end;
GetDiBits(dc,hBm,0,lpBitmapInfo^.bmiHeader.biHeight,nil,TBitmapInfo(lpBitmap
Info^),DIB_RGB_COLORS);
  hBits := GlobalAlloc(GMEM_MOVEABLE,lpBitmapInfo^.bmiHeader.biSizeImage);
  pBits := GlobalLock(hBits);
GetDiBits(dc,hBm,0,lpBitmapInfo^.bmiHeader.biHeight,pBits,TBitmapInfo(lpBitm
apInfo^),DIB_RGB_COLORS);
  if IsPaletteDevice then
  begin
    GetMem(lPPalEntriesArray, sizeof(TPaletteEntry) * 256);
   {$IFDEF VER100}
      NumPalEntries := GetPaletteEntries(hPal,0,256,lPPalEntriesArray^);
   {$ELSE}
      NumPalEntries := GetSystemPaletteEntries(dc,0,256,lPPalEntriesArray^);
   {$ENDIF}
    for i := 0 to (NumPalEntries - 1) do begin
      lpBitmapInfo^.bmiColors[i].rgbRed := lPPalEntriesArray^[i].peRed;
      lpBitmapInfo^.bmiColors[i].rgbGreen := lPPalEntriesArray^[i].peGreen;
      lpBitmapInfo^.bmiColors[i].rgbBlue := lPPalEntriesArray^[i].peBlue;
    end;
    FreeMem(lPPalEntriesArray, sizeof(TPaletteEntry) * 256);
  end;
  if IsPaletteDevice then
  begin
    SelectPalette(dc, OldPal, TRUE);
    RealizePalette(dc);
  end;
  dc := ReleaseDc(0, dc);
  IsDestPaletteDevice := GetDeviceCaps(DestDc, RASTERCAPS) and RC_PALETTE =
RC_PALETTE;
  if IsPaletteDevice then
  begin
    OldPal := SelectPalette(DestDc, hPal, TRUE);
    RealizePalette(DestDc);
  end;
  { IMPOSTARE LE QUI DIMENSIONI }
  StretchDiBits(DestDc, x, y, Width, Height, 0, 0,
                OriginalWidth, lpBitmapInfo^.bmiHeader.biHeight,
                pBits, lpBitmapInfo^, DIB_RGB_COLORS, SrcCopy);
  if IsDestPaletteDevice then
  begin
    SelectPalette(DestDc, OldPal, TRUE);
    RealizePalette(DestDc);
  end;
  GlobalUnLock(hBits);
  GlobalFree(hBits);
  FreeMem(lpBitmapInfo, BitmapInfoSize);
  bm.Handle := hBm;
  bm.Palette := hPal;
{$IFDEF CKRANGE}
  {$UNDEF CKRANGE}
  {$R+}
{$ENDIF}
end;


Forse dico una cavolata ma non puoi usare il componente TQRImage di
QuickReport ?
^_Goblin_^

 QuickReport ?
Potrei, ma preferirei evitarlo: non mi ci trovo molto bene, e poi non sono
sicuro che funzioni con i jpeg...
E poi, questa cosa ha per lo più valenza didattica (vorrei imparare a
maneggiare i file immagini) ed appoggiarmi al QR non mi fa imparare nulla
:o)
Grazie comunque!
Panoramix