iesave.c

开放源码的编译器open watcom 1.6.0版的源代码

    if (bmi->bmiHeader.biWidth > 32 && FALSE)
        number_of_bytes = BITS_INTO_BYTES(bmi->bmiHeader.biBitCount *
                                        bmi->bmiHeader.biWidth,
                                        bmi->bmiHeader.biHeight);
    else
        number_of_bytes = BITS_TO_BYTES(bmi->bmiHeader.biBitCount *
                                        bmi->bmiHeader.biWidth,
                                        bmi->bmiHeader.biHeight);

    bitmap_size = DIB_INFO_SIZE( bmi->bmiHeader.biBitCount );

    hdc = GetDC( NULL );
    GetDIBits(hdc, node->hxorbitmap, 0, node->height, NULL, bmi, DIB_RGB_COLORS);
    ReleaseDC( NULL, hdc );
    if (bmi->bmiHeader.biSizeImage == 0) {
        bmi->bmiHeader.biSizeImage = number_of_bytes;
    } else {
        number_of_bytes = bmi->bmiHeader.biSizeImage;
    }

    bmfh.bfType = BITMAP_TYPE;
    bmfh.bfSize = sizeof(BITMAPFILEHEADER) + bitmap_size + number_of_bytes;
    bmfh.bfReserved1 = 0;
    bmfh.bfReserved2 = 0;
    bmfh.bfOffBits = sizeof(BITMAPFILEHEADER) + bitmap_size;

    // make sure the bitmap can actually be malloc'd!!
    if( bmfh.bfSize > INT_MAX ) {
        FreeDIBitmapInfo( bmi );
        return( FALSE );
    }

    *data = MemAlloc( bmfh.bfSize );
    if( *data == NULL ) {
        FreeDIBitmapInfo( bmi );
        return( FALSE );
    }
    *size = 0;

    memcpy( *data + *size, &bmfh, sizeof(BITMAPFILEHEADER) );
    *size += sizeof(BITMAPFILEHEADER);

    memcpy( *data + *size, bmi, bitmap_size );
    *size += bitmap_size;

    if( !writeDataInPiecesData( bmi, data, size, node ) ) {
        FreeDIBitmapInfo( bmi );
        return(FALSE);
    }

    FreeDIBitmapInfo( bmi );

    return( TRUE );
} /* saveBitmapToData */

/*
 * saveImgFile - Save the image (icon or cursor) file.  Note that node points
 *               to the "root" of the icon nodes.
 */
BOOL saveImgFile( img_node *node )
{
    an_img_file         *img_file;
    an_img_resource     img_res;
    an_img              img;
    BITMAPINFOHEADER    *imginfo;
    FILE                *fp;
    long                bitmap_size;
    long                imgfile_size;
    DWORD               prevDIBsize = 0;
    DWORD               prevDIBoffset = 0;
    WORD                count;
    short               i;
    img_node            *currentimage;
    char                filename[ _MAX_FNAME+_MAX_EXT ];

    count = node->num_of_images;                // Will be 1 for cursors
    imgfile_size = sizeof(an_img_file) + sizeof(an_img_resource) * (count-1);
    img_file = MemAlloc( imgfile_size );

    img_file->count = count;
    img_file->reserved = 0;
    if (node->imgtype == ICON_IMG) {
        img_file->type = 1;
    } else {
        img_file->type = 2;
    }

    imginfo = MemAlloc( sizeof(BITMAPINFOHEADER) * img_file->count );

    currentimage = node;
    for (i = 0; i < img_file->count; ++i) {
        if (!currentimage) {
            break;
        }
        FillImageResource( &img_res, currentimage );

        if (currentimage->imgtype == CURSOR_IMG) {
            img_res.colour_count = 0;
        }

        GetBitmapInfoHeader( &(imginfo[i]), currentimage );
        bitmap_size = DIB_INFO_SIZE( imginfo[i].biBitCount );
        if (imginfo[i].biWidth > 32 && FALSE)
            img_res.DIB_size = bitmap_size +
                               BITS_INTO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,imginfo[i].biHeight) +
                               BITS_INTO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        else
            img_res.DIB_size = bitmap_size +
                               BITS_TO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,imginfo[i].biHeight) +
                               BITS_TO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        if (i == 0) {
            img_res.DIB_offset = sizeof( an_img_file ) +
                                 sizeof( an_img_resource) * (count - 1);
        } else {
            img_res.DIB_offset = prevDIBoffset + prevDIBsize;
        }
        prevDIBsize = img_res.DIB_size;
        prevDIBoffset = img_res.DIB_offset;

        memcpy(&(img_file->resources[i]), &(img_res), sizeof(an_img_resource));
        currentimage = currentimage->nexticon;
    }

    GetFnameFromPath( node->fname, filename );
    fp = fopen( node->fname, "wb" );
    if (fp == NULL) {
        MemFree(img_file);
        MemFree(imginfo);
        WImgEditError( WIE_ERR_SAVE_FAIL, filename );
        return(FALSE);
    }
    if (fseek( fp, 0L, SEEK_SET )) {
        MemFree(img_file);
        MemFree(imginfo);
        fclose( fp );
        WImgEditError( WIE_ERR_SAVE_FAIL, filename );
        return(FALSE);
    }
    if ( fwrite(img_file, imgfile_size, 1, fp) != 1 ) {
        MemFree(img_file);
        MemFree(imginfo);
        fclose( fp );
        WImgEditError( WIE_ERR_SAVE_FAIL, filename );
        return(FALSE);
    }

    currentimage = node;
    for (i=0; i < img_file->count; ++i) {
        if (!currentimage) {
            break;
        }
        bitmap_size = DIB_INFO_SIZE( imginfo[i].biBitCount );
        if (imginfo[i].biWidth > 32 && FALSE) {
            img.xor_size = BITS_INTO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                                        imginfo[i].biHeight);
            img.and_size = BITS_INTO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        } else {
            img.xor_size = BITS_TO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                                        imginfo[i].biHeight);
            img.and_size = BITS_TO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        }
        img.bm = MemAlloc( bitmap_size );
        // JAMIE
        MemFree (img.bm);
        img.bm = MemAlloc( bitmap_size );

        img.xor_mask = MemAlloc( img.xor_size );
        img.and_mask = MemAlloc( img.and_size );
        memcpy( &(img.bm->bmiHeader), &(imginfo[i]), sizeof(BITMAPINFOHEADER) );

        GetImageData( &img, currentimage );

        /*
         * Here's a couple of quirks:  1. we have to reverse the and_mask bits
         * We multilply the height by 2 because this height represents the
         * combined height of the and mask and the xor mask.
         * Addendum:  Actually, we only reverse the and bits when we open
         * AND if we store the bits in device DEPENDENT bitmap form.
         */

        img.bm->bmiHeader.biHeight = img.bm->bmiHeader.biHeight * 2;
        img.bm->bmiHeader.biSizeImage = img.xor_size + img.and_size;

        if ( fwrite(img.bm, bitmap_size, 1, fp) != 1 ) {
            MemFree(img_file);
            MemFree(imginfo);
            fclose( fp );
            WImgEditError( WIE_ERR_SAVE_FAIL, filename );
            return(FALSE);
        }
        if ( fwrite(img.xor_mask, sizeof(BYTE), img.xor_size, fp) != img.xor_size ) {
            MemFree(img_file);
            MemFree(imginfo);
            fclose( fp );
            WImgEditError( WIE_ERR_SAVE_FAIL, filename );
            return(FALSE);
        }
        if ( fwrite(img.and_mask, sizeof(BYTE), img.and_size, fp) != img.and_size ) {
            MemFree(img_file);
            MemFree(imginfo);
            fclose( fp );
            WImgEditError( WIE_ERR_SAVE_FAIL, filename );
            return(FALSE);
        }
        MemFree (img.bm);
        MemFree (img.xor_mask);
        MemFree (img.and_mask);
        currentimage = currentimage->nexticon;
    }

    fclose( fp );
    MemFree (img_file);
    MemFree (imginfo);

    AllowRestoreOption( node );
    SetIsSaved( node->hwnd, TRUE );

    if (node->imgtype == ICON_IMG) {
        PrintHintTextByID( WIE_ICONSAVEDTO, filename );
    } else {
        PrintHintTextByID( WIE_CURSORSAVEDTO, filename );
    }
    return( TRUE );
} /* saveImgFile */

int getSaveImgDataLength( img_node *node, an_img_file *img_file,
                          BITMAPINFOHEADER *imginfo, long imgfile_size )
{
    img_node            *currentimage;
    int                 data_length;
    int                 i;

    data_length = imgfile_size;

    currentimage = node;
    for (i=0; i < img_file->count; ++i) {
        if (!currentimage) {
            break;
        }
        data_length += DIB_INFO_SIZE(imginfo[i].biBitCount);
        if (imginfo[i].biWidth > 32 && FALSE) {
            data_length += BITS_INTO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                         imginfo[i].biHeight);
            data_length += BITS_INTO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        } else {
            data_length += BITS_TO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                         imginfo[i].biHeight);
            data_length += BITS_TO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        }
        currentimage = currentimage->nexticon;
    }

    return( data_length );
} /* getSaveImgDataLength */

BOOL saveImgToData( img_node *node, BYTE **data, uint_32 *size )
{
    an_img_file         *img_file;
    an_img_resource     img_res;
    an_img              img;
    BITMAPINFOHEADER    *imginfo;
    long                bitmap_size;
    long                imgfile_size;
    DWORD               prevDIBsize = 0;
    DWORD               prevDIBoffset = 0;
    WORD                count;
    short               i;
    img_node            *currentimage;
    uint_32             data_length;

    if( !data || !size ) {
        return( FALSE );
    }

    count = node->num_of_images;                // Will be 1 for cursors
    imgfile_size = sizeof(an_img_file) + sizeof(an_img_resource) * (count-1);
    img_file = MemAlloc( imgfile_size );

    img_file->count = count;
    img_file->reserved = 0;
    if (node->imgtype == ICON_IMG) {
        img_file->type = 1;
    } else {
        img_file->type = 2;
    }

    imginfo = MemAlloc( sizeof(BITMAPINFOHEADER) * img_file->count );

    currentimage = node;
    for (i = 0; i < img_file->count; ++i) {
        if (!currentimage) {
            break;
        }
        FillImageResource( &img_res, currentimage );

        if (currentimage->imgtype == CURSOR_IMG) {
            img_res.colour_count = 0;
        }

        GetBitmapInfoHeader( &(imginfo[i]), currentimage );
        bitmap_size = DIB_INFO_SIZE( imginfo[i].biBitCount );
        if (imginfo[i].biWidth > 32 && FALSE)
            img_res.DIB_size = bitmap_size +
                               BITS_INTO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,imginfo[i].biHeight) +
                               BITS_INTO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        else
            img_res.DIB_size = bitmap_size +
                               BITS_TO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,imginfo[i].biHeight) +
                               BITS_TO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        if (i == 0) {
            img_res.DIB_offset = sizeof( an_img_file ) +
                                 sizeof( an_img_resource) * (count - 1);
        } else {
            img_res.DIB_offset = prevDIBoffset + prevDIBsize;
        }
        prevDIBsize = img_res.DIB_size;
        prevDIBoffset = img_res.DIB_offset;

        memcpy(&(img_file->resources[i]), &(img_res), sizeof(an_img_resource));
        currentimage = currentimage->nexticon;
    }

    data_length = getSaveImgDataLength( node, img_file, imginfo,
                                        imgfile_size );
    // make sure the bitmap can actually be malloc'd!!
    if( data_length > INT_MAX ) {
        MemFree(img_file);
        MemFree(imginfo);
        return( FALSE );
    }

    // allocate the data for the image
    *data = MemAlloc( data_length );
    if( *data == NULL ) {
        MemFree(img_file);
        MemFree(imginfo);
        return( FALSE );
    }
    *size = 0;

    memcpy( *data + *size, img_file, imgfile_size );
    *size += imgfile_size;

    currentimage = node;
    for (i=0; i < img_file->count; ++i) {
        if (!currentimage) {
            break;
        }
        bitmap_size = DIB_INFO_SIZE( imginfo[i].biBitCount );
        img.bm = MemAlloc( bitmap_size );
        if (imginfo[i].biWidth > 32 && FALSE) {
            img.xor_size = BITS_INTO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                                        imginfo[i].biHeight);
            img.and_size = BITS_INTO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        } else {
            img.xor_size = BITS_TO_BYTES(imginfo[i].biWidth*imginfo[i].biBitCount,
                                                        imginfo[i].biHeight);
            img.and_size = BITS_TO_BYTES(imginfo[i].biWidth, imginfo[i].biHeight);
        }
        img.xor_mask = MemAlloc( img.xor_size );
        img.and_mask = MemAlloc( img.and_size );
        memcpy( &(img.bm->bmiHeader), &(imginfo[i]), sizeof(BITMAPINFOHEADER) );

        GetImageData( &img, currentimage );

        /*
         * Here's a couple of quirks:  1. we have to reverse the and_mask bits
         * We multilply the height by 2 because this height represents the
         * combined height of the and mask and the xor mask.
         * Addendum:  Actually, we only reverse the and bits when we open
         * AND if we store the bits in device DEPENDENT bitmap form.
         */

        img.bm->bmiHeader.biHeight = img.bm->bmiHeader.biHeight * 2;
        img.bm->bmiHeader.biSizeImage = img.xor_size + img.and_size;

        memcpy( *data + *size, img.bm, bitmap_size );
        *size += bitmap_size;

        memcpy( *data + *size, img.xor_mask, img.xor_size );
        *size += img.xor_size;

        memcpy( *data + *size, img.and_mask, img.and_size );
        *size += img.and_size;

        MemFree (img.bm);
        MemFree (img.xor_mask);
        MemFree (img.and_mask);
        currentimage = currentimage->nexticon;
    }