iesave.c

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

        FreeDIBitmapInfo( bmi );
        return(FALSE);
    }

    if ( fwrite(&new_file, sizeof(BITMAPARRAYFILEHEADER2), 1, fp) != 1 ) {
        fclose( fp );
        FreeDIBitmapInfo( bmi );
        return(FALSE);
    }

    if ( fwrite(colours, clrtable_size, 1, fp) != 1 ) {
        fclose( fp );
        FreeDIBitmapInfo( bmi );
        return(FALSE);
    }

    if (!writeDataInPieces( bmi, fp, node )) {
        fclose( fp );
        FreeDIBitmapInfo( bmi );
        MessageBox(HMainWindow, "Error writing file!", "Error",
                                                MB_OK | MB_ICONEXCLAMATION);
        SetHintText("Error saving file");
        return(FALSE);
    }

    fclose( fp );
    FreeDIBitmapInfo( bmi );

    AllowRestoreOption( node );
    SetIsSaved( node->hwnd, TRUE );
    GetFnameFromPath( node->fname, filename );
    sprintf( text, "Bitmap saved to '%s'", filename );
    SetHintText( text );
    return( TRUE );
} /* saveBitmapFile */

/*
 * saveImageFile - saves a cursor or icon file
 */
static BOOL saveImageFile( img_node *node )
{
    BITMAPARRAYFILEHEADER2      new_file;
    BITMAPFILEHEADER2           *and_part;
    BITMAPFILEHEADER2           *xor_part;
    BITMAPINFO2                 *andbmi;
    BITMAPINFO2                 *xorbmi;
    long                        clrtable_size;
    long                        and_size;
    ULONG                       nextoff;
    RGB2                        *colours;
    FILE                        *fp;
    char                        text[ HINT_TEXT_LEN ];
    char                        filename[ _MAX_FNAME ];
    img_node                    *new_image;

    fp = fopen( node->fname, "wb" );
    if (fp == NULL) {
        return(FALSE);
    }
    if (fseek( fp, 0L, SEEK_SET )) {
        fclose( fp );
        return(FALSE);
    }

    new_image = node;
    nextoff = 0;

    while( new_image ) {
        new_file.usType = BFT_BITMAPARRAY;
        new_file.cbSize = sizeof( BITMAPARRAYFILEHEADER2 );
        new_file.offNext = nextoff;
        new_file.cxDisplay = 0;
        new_file.cyDisplay = 0;

        and_part = fillFileHeader( new_image );
        memcpy( &(new_file.bfh2), and_part, sizeof(BITMAPFILEHEADER2) );
        /*
         * First the info for the AND mask
         */
        andbmi = GetAndBitmapInfo(new_image);
        if (!andbmi) {
            return(FALSE);
        }
        clrtable_size = sizeof(RGB2) * (1<<(new_image->bitcount));
        and_size = sizeof(RGB2) * 2;

        new_file.bfh2.offBits = new_file.offNext + new_file.cbSize +
                                and_size + clrtable_size +
                                sizeof(BITMAPFILEHEADER2);
        memcpy( &(new_file.bfh2.bmp2), andbmi, sizeof(BITMAPINFOHEADER2) );
        colours = (void *)&(andbmi->argbColor[0]);

        if ( fwrite(&new_file, sizeof(BITMAPARRAYFILEHEADER2), 1, fp) != 1 ) {
            fclose( fp );
            FreeDIBitmapInfo( andbmi );
            free( and_part );
            return(FALSE);
        }

        if ( fwrite(colours, and_size, 1, fp) != 1 ) {
            fclose( fp );
            FreeDIBitmapInfo( andbmi );
            free( and_part );
            return(FALSE);
        }
        free( and_part );

        /*
         * Now we write the XOR part
         */
        xor_part = fillFileHeader( new_image );
        xorbmi = GetXorBitmapInfo(new_image);
        if (!xorbmi) {
            free( xor_part );
            return(FALSE);
        }
        xor_part->offBits = new_file.bfh2.offBits +
                        BITS_TO_BYTES(new_image->width, 2*new_image->height);
        memcpy( &(xor_part->bmp2), xorbmi, sizeof(BITMAPINFOHEADER2) );
        colours = (void *)&(xorbmi->argbColor[0]);

        if ( fwrite(xor_part, sizeof(BITMAPFILEHEADER2), 1, fp) != 1 ) {
            fclose( fp );
            FreeDIBitmapInfo( xorbmi );
            free( xor_part );
            return(FALSE);
        }

        if ( fwrite(colours, clrtable_size, 1, fp) != 1 ) {
            fclose( fp );
            FreeDIBitmapInfo( xorbmi );
            free( xor_part );
            return(FALSE);
        }
        free( xor_part );
        nextoff = nextoff + sizeof(BITMAPARRAYFILEHEADER2) + and_size
                        + sizeof(BITMAPFILEHEADER2) + clrtable_size;
        new_image = new_image->nexticon;
    }

    /*
     * Now we write the bits for all the images in the file.
     */
    if (!writeImageBits( fp, node )) {
        fclose( fp );
        return( FALSE );
    }

    fclose( fp );

    AllowRestoreOption( node );
    SetIsSaved( node->hwnd, TRUE );
    GetFnameFromPath( node->fname, filename );
    if (node->imgtype == ICON_IMG) {
        sprintf( text, "Icon saved to '%s'", filename );
    } else {
        sprintf( text, "Pointer saved to '%s'", filename );
    }
    SetHintText( text );
    return( TRUE );
} /* saveImageFile */

/*
 * SaveFile - Saves the image file (bitmap, cursor or icon).
 */
BOOL SaveFile( short how )
{
    img_node    *node;
    img_node    *rootnode;
    char        new_name[ _MAX_PATH ];

    node = GetCurrentNode();
    if (!node) return(FALSE);
    rootnode = GetImageNode( node->hwnd );

    if (!rootnode) return(FALSE);

    if (strnicmp(rootnode->fname, "(Untitled)", 10) == 0) {
        how = SB_SAVE_AS;
    }

    if (how == SB_SAVE_AS) {
        if (!getSaveFName(new_name, rootnode->imgtype)) {
            return (FALSE);
        }
        node = rootnode;
        while (node) {
            strcpy( node->fname, new_name );
            node = node->nexticon;
        }
    }

    checkForExt( rootnode );

    switch( rootnode->imgtype ) {
    case BITMAP_IMG:
        if (!saveBitmapFile( rootnode )) {
            MessageBox(HMainWindow, "Error trying to save file!", "Error",
                                                MB_OK | MB_ICONEXCLAMATION);
            return(FALSE);
        }
        break;
    case ICON_IMG:
    case CURSOR_IMG:
        if (!saveImageFile( rootnode )) {
            MessageBox(HMainWindow, "Error trying to save file!", "Error",
                                                MB_OK | MB_ICONEXCLAMATION);
            return(FALSE);
        }
        break;

    default:
        return (FALSE);
    }
    return(TRUE);
} /* SaveFile */

#if 0
/*
 * getSavePalName - Get the name of the palette file to be saved.
 */
static BOOL getSavePalName( char *fname )
{
    static char         filterList[] = "Palette (*.pal)" \
                                        "\0" \
                                        "*.pal" \
                                        "\0" \
                                        "All Files (*.*)" \
                                        "\0" \
                                        "*.*" \
                                        "\0\0";
    static OPENFILENAME of;
    char                szFileTitle[_MAX_PATH];
    int                 rc;

    fname[ 0 ] = 0;
    memset( &of, 0, sizeof( OPENFILENAME ) );
    of.lStructSize = sizeof( OPENFILENAME );
    of.hwndOwner = HMainWindow;
    of.lpstrFilter = (LPSTR) filterList;
    of.nFilterIndex = 0L;
    of.lpstrFile = fname;
    of.nMaxFile = _MAX_PATH;
    of.lpstrFileTitle = szFileTitle;
    of.nMaxFileTitle = sizeof(szFileTitle);
    of.lpstrTitle = "Save Colour Palette File";
    of.lpstrInitialDir = initialDir;
    of.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT | OFN_ENABLEHOOK;
    of.lpfnHook = (LPVOID) MakeProcInstance( (LPVOID) SaveHook, Instance );
    rc = GetSaveFileName( &of );
    FreeProcInstance( (LPVOID) of.lpfnHook );
    return( rc );

} /* getSavePalName */

/*
 * SaveColourPalette - saves the current colour palette.
 */
BOOL SaveColourPalette( void )
{
    a_pal_file          pal_file;
    FILE                *fp;
    char                fname[ _MAX_PATH ];
    char                filename[ _MAX_FNAME + _MAX_EXT ];
    char                text[ HINT_TEXT_LEN ];

    if ( !getSavePalName(fname) ) {
        if ( CommDlgExtendedError() != 0 ) {
            sprintf( text, "Error saving '%s'", fname );
            SetHintText( text );
            return (FALSE);
        } else {
            return (TRUE);
        }
    }
    checkForPalExt(fname);

    if ( !GetPaletteFile(&pal_file) ) {
        sprintf( text, "Current palette not 16 colours!", fname );
        SetHintText( text );
        return(TRUE);                   // Just return ... no error
    }

    sprintf( text, "Error saving '%s'", fname );
    fp = fopen( fname, "wb" );
    if (fp == NULL) {
        SetHintText( text );
        return(FALSE);
    }

    if (fseek( fp, 0L, SEEK_SET )) {
        SetHintText( text );
        return(FALSE);
    }

    if ( fwrite(&pal_file, sizeof(a_pal_file), 1, fp) != 1 ) {
        SetHintText( text );
        return(FALSE);
    }

    fclose( fp );
    GetFnameFromPath( fname, filename );
    sprintf( text, "Palette saved to '%s'", filename );
    SetHintText( text );
    return(TRUE);

} /* SaveColourPalette */
#endif

/*
 * SetInitialSaveDir - sets the initial directory for the open filename
 */
void SetInitialSaveDir( char *new_dir )
{
    if (new_dir) {
        strcpy( initialDir, new_dir );
    } else {
        strcpy( initialDir, "" );
    }
} /* SetInitialSaveDir */

/*
 * GetInitSaveDir - gets the directory which we want to use as our initial one
 *              next time we run.
 */
char *GetInitSaveDir( void )
{
    return(initialDir);
} /* GetInitSaveDir */