Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Salvare su disco un hDC

Ci riprovo.
ho un'hDC che punta alla mia bella immagine in memoria.
Voglio salvarne il contenuto in un file .bmp .gif o qualsiasi altro formato
leggibile.
Ancora, non voglio passare per oggetti tipo form o picture.
Qualcuno sa come fare?
Ciao
--
' // Initialize the expression evaluator
Engines.Evaluator = CreateObject("
http://www.neodatatype.net
")
' // you can find resources for and from the NG here!
Me.SitoComune = "
http://www.it-lang-vb.it
"

 ha scritto nel messaggio
news:alhhph$9s3$1...@monty.lombardiacom.it...

Ciao
Idea, non provato DA VERIFICARE !!!
Se ti crei da codice un'oggetto picture con i comandi Set e New
l'oggetto poi espone il metodo Render a questo punto con SaveImage dovresti
poter salvarlo.
Fammi sapere se l'idea era giusta.
JKLJKL


Credo, non sono sicuro al 100%, di aver visto un codice d'esempio
ravanando nell'msdn. Io stavo guardando l'argomento Regioni, e credo
di aver visto un 'qualcosa' (forse un articolo) che diveva come usare le
regioni per salvare una parte di un'immagine.
Spero di non essermi confuso.
Saluti,
Pusky

 Ancora, non voglio passare per oggetti tipo form o picture.
Hint: "Oggetto Picture" <> "PictureBox".
Dim Foto as new stdPicture
' qui devi assegnare l'immagine a Foto, vedi tu ;-)
' poi puoi salvarla con
savepicture Foto, "File.bmp"
Bye, G.

 savepicture Foto, "File.bmp"
Ok, fino a qui ci ero arrivato :)
Adesso mi serve il passaggio intermedio:
hDC -> Foto


 ha scritto nel messaggio
news:ali78e$f6d$1...@monty.lombardiacom.it...

stdPicture espone il metodo Render non basta ?
JKLJKL

 stdPicture espone il metodo Render non basta ?
Mannaggia!
Mi sembra di parlare arabo :P
Adesso mi spiegate come cavolo mettete insieme la Render con un hDC!
I pezzi non si incastrano: sono di due puzzle diversi.


 ha scritto nel messaggio
news:alii92$htv$1...@monty.lombardiacom.it...

Non arrabiarti !! Ti fai il sangue cattivo.
Tu sicuramente hai provato ed io sono "de coccio" ma se come ha detto
anche Paperino ti crei da codice un'oggetto stdPicture a questo punto
<TuastdPicture>.Render hDc, ecc......
SavePicture <TuastdPicture>
Lascia perdere la sintassi non vuole essere codice funzionante, se
concettualmente non funziona postalo così non ci caschiamo anche noi !
JKLJKL

Hai provato con le varie GetDC, CreateCompatibleBitmap ecc?. Cosě non si
riesce a risolvere il bitmap in memoria?
In ogni caso se non ne vieni a capo prova a chiedere su
microsoft.public.vb.winapi.graphics
Fabio


 altro formato leggibile.
Volendo essere pignoli, un DC contiene qualcosa più che solo l'immagine
ma questo è un altro discorso :-))) La tua domanda dovrebbe essere "come
serializzo la bitmap attualmente selezionata in un DC?", ma io ti perdono,
ego te absolvo, in nomine Gates, Ballmer, [1] etc. etc. etc. solo perchè
tu sei tu, e io sono solo un noioso pragmatico
Comunque. Dal Platform SDK (premessa: il codice d'esempio, a tratti, è
una schifezza, e inoltre dubito che alcune cose siano fattibili in VB
senza usare le solite CopyMemory e famiglia, ma l'importante è avere un
punto di riferimento, no?):
"Storing an Image
Many applications store images permanently as files. For example, drawing
applications store pictures, spreadsheet applications store charts, CAD
applications store drawings, and so on. 
If you are writing an application that stores a bitmap image in a file,
you should use the bitmap file format described in Bitmap Storage. To
store a bitmap in this format, you must use a BITMAPINFOHEADER, a
BITMAPV4HEADER, or a BITMAPV5HEADER structure and an array of RGBQUAD
structures, as well as an array of palette indexes. 
The following example code defines a function that uses a BITMAPINFO
structure and allocates memory for and initializes members within a
BITMAPINFOHEADER structure. Note that the BITMAPINFO structure cannot
be used with either a BITMAPV4HEADER or a BITMAPV5HEADER structure.
PBITMAPINFO CreateBitmapInfoStruct(HWND hwnd, HBITMAP hBmp)
{ 
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 
    // Retrieve the bitmap color format, width, and height. 
    if (!GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp)) 
        errhandler("GetObject", hwnd); 
    // Convert the color format to a count of bits. 
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 
    // Allocate memory for the BITMAPINFO structure. (This structure 
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD 
    // data structures.) 
     if (cClrBits != 24) 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD) * (1<< cClrBits)); 
     // There is no RGBQUAD array for the 24-bit-per-pixel format. 
     else 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 
    // Initialize the fields in the BITMAPINFO structure. 
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 
    // If the bitmap is not compressed, set the BI_RGB flag. 
    pbmi->bmiHeader.biCompression = BI_RGB; 
    // Compute the number of bytes in the array of color 
    // indices and store the result in biSizeImage. 
    // For Windows NT, the width must be DWORD aligned unless 
    // the bitmap is RLE compressed. This example shows this. 
    // For Windows 95/98/Me, the width must be WORD aligned unless the 
    // bitmap is RLE compressed.
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
    // Set biClrImportant to 0, indicating that all of the 
    // device colors are important. 
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
 } 
The following example code defines a function that initializes the
remaining structures, retrieves the array of palette indices, opens the
file, copies the data, and closes the file. 
void CreateBMPFile(HWND hwnd, LPTSTR pszFile, PBITMAPINFO pbi, 
                  HBITMAP hBMP, HDC hDC) 
 { 
     HANDLE hf;                 // file handle 
    BITMAPFILEHEADER hdr;       // bitmap file-header 
    PBITMAPINFOHEADER pbih;     // bitmap info-header 
    LPBYTE lpBits;              // memory pointer 
    DWORD dwTotal;              // total count of bytes 
    DWORD cb;                   // incremental count of bytes 
    BYTE *hp;                   // byte pointer 
    DWORD dwTmp; 
    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
    if (!lpBits) 
         errhandler("GlobalAlloc", hwnd); 
    // Retrieve the color table (RGBQUAD array) and the bits 
    // (array of palette indices) from the DIB. 
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS)) 
    {
        errhandler("GetDIBits", hwnd); 
    }
    // Create the .BMP file. 
    hf = CreateFile(pszFile, 
                   GENERIC_READ | GENERIC_WRITE, 
                   (DWORD) 0, 
                    NULL, 
                   CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL); 
    if (hf == INVALID_HANDLE_VALUE) 
        errhandler("CreateFile", hwnd); 
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M" 
    // Compute the size of the entire file. 
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
                 pbih->biSize + pbih->biClrUsed 
                 * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 
    // Compute the offset to the array of color indices. 
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    pbih->biSize + pbih->biClrUsed 
                    * sizeof (RGBQUAD); 
    // Copy the BITMAPFILEHEADER into the .BMP file. 
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)) 
    {
       errhandler("WriteFile", hwnd); 
    }
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file. 
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
                  + pbih->biClrUsed * sizeof (RGBQUAD), 
                  (LPDWORD) &dwTmp, ( NULL)) 
        errhandler("WriteFile", hwnd); 
    // Copy the array of color indices into the .BMP file. 
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)) 
           errhandler("WriteFile", hwnd); 
    // Close the .BMP file. 
     if (!CloseHandle(hf)) 
           errhandler("CloseHandle", hwnd); 
    // Free memory. 
    GlobalFree((HGLOBAL)lpBits);
}"
[1] il mio latino è un po' arrugginito, abbiate pazienza

 [1] il mio latino č un po' arrugginito, abbiate pazienza

 dello stesso. Non credo che Fabio abbia questi dati
Mah, a quanto pare l'hwnd viene usato solo per gestire l'errore, quindi
potrebbe funzionare.
Se avrò tempo proverò una traduzione :)


 l'header dello stesso. Non credo che Fabio abbia questi dati
vedrai che il parametro hwnd viene usato solo nelle chiamate a 
errhandler(), presumibilmente per impostare il parent di finestre 
d'errore


ma non hai l'header del bitmap. Avere l'HBITMAP praticamente significa che
hai già la struttura che mi pare stavi cercando di ottenere.
Fabio

Fabio Guerrazzi ha scritto:

non proprio. Vedrai che un HBITMAP ha un tantino di astrazione rispetto 
ad una bitmap su disco, ragion per cui ho parlato di "serializzazione". 
Ho parlato anche di "bitmap selezionata nel DC", che si traduce in:
hBitmap = GetCurrentObject(hDC, OBJ_BITMAP)

 hBitmap = GetCurrentObject(hDC, OBJ_BITMAP)
hmm.. mi hai convinto. Proverò, perché una cosa del genere serve anche a me.
Grazie
Fabio