graphics/win32/xpm2bmp.c

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <wingdi.h>
#include <glib/glib.h>
#include "xpm2bmp.h"

/* #define _DBG */

// function prototypes
static int CreateBitmapFromXpm( const char* filename, PXPM2BMP pXpm2bmp );

// typedefs
static XPMCOLORENTRY theRGBRecords[] =
{
    {"ALICEBLUE", 240, 248, 255},
    {"ANTIQUEWHITE", 250, 235, 215},
    {"AQUAMARINE", 50, 191, 193},
    {"AZURE", 240, 255, 255},
    {"BEIGE", 245, 245, 220},
    {"BISQUE", 255, 228, 196},
    {"BLACK", 0, 0, 0},
    {"BLANCHEDALMOND", 255, 235, 205},
    {"BLUE", 0, 0, 255},
    {"BLUEVIOLET", 138, 43, 226},
    {"BROWN", 165, 42, 42},
    {"BURLYWOOD", 222, 184, 135},
    {"CADETBLUE", 95, 146, 158},
    {"CHARTREUSE", 127, 255, 0},
    {"CHOCOLATE", 210, 105, 30},
    {"CORAL", 255, 114, 86},
    {"CORNFLOWERBLUE", 34, 34, 152},
    {"CORNSILK", 255, 248, 220},
    {"CYAN", 0, 255, 255},
    {"DARKGOLDENROD", 184, 134, 11},
    {"DARKGREEN", 0, 86, 45},
    {"DARKKHAKI", 189, 183, 107},
    {"DARKOLIVEGREEN", 85, 86, 47},
    {"DARKORANGE", 255, 140, 0},
    {"DARKORCHID", 139, 32, 139},
    {"DARKSALMON", 233, 150, 122},
    {"DARKSEAGREEN", 143, 188, 143},
    {"DARKSLATEBLUE", 56, 75, 102},
    {"DARKSLATEGRAY", 47, 79, 79},
    {"DARKTURQUOISE", 0, 166, 166},
    {"DARKVIOLET", 148, 0, 211},
    {"DEEPPINK", 255, 20, 147},
    {"DEEPSKYBLUE", 0, 191, 255},
    {"DIMGRAY", 84, 84, 84},
    {"DODGERBLUE", 30, 144, 255},
    {"FIREBRICK", 142, 35, 35},
    {"FLORALWHITE", 255, 250, 240},
    {"FORESTGREEN", 80, 159, 105},
    {"GAINSBORO", 220, 220, 220},
    {"GHOSTWHITE", 248, 248, 255},
    {"GOLD", 218, 170, 0},
    {"GOLDENROD", 239, 223, 132},
    {"GRAY", 126, 126, 126},
    {"GRAY0", 0, 0, 0},
    {"GRAY1", 3, 3, 3},
    {"GRAY10", 26, 26, 26},
    {"GRAY100", 255, 255, 255},
    {"GRAY11", 28, 28, 28},
    {"GRAY12", 31, 31, 31},
    {"GRAY13", 33, 33, 33},
    {"GRAY14", 36, 36, 36},
    {"GRAY15", 38, 38, 38},
    {"GRAY16", 41, 41, 41},
    {"GRAY17", 43, 43, 43},
    {"GRAY18", 46, 46, 46},
    {"GRAY19", 48, 48, 48},
    {"GRAY2", 5, 5, 5},
    {"GRAY20", 51, 51, 51},
    {"GRAY21", 54, 54, 54},
    {"GRAY22", 56, 56, 56},
    {"GRAY23", 59, 59, 59},
    {"GRAY24", 61, 61, 61},
    {"GRAY25", 64, 64, 64},
    {"GRAY26", 66, 66, 66},
    {"GRAY27", 69, 69, 69},
    {"GRAY28", 71, 71, 71},
    {"GRAY29", 74, 74, 74},
    {"GRAY3", 8, 8, 8},
    {"GRAY30", 77, 77, 77},
    {"GRAY31", 79, 79, 79},
    {"GRAY32", 82, 82, 82},
    {"GRAY33", 84, 84, 84},
    {"GRAY34", 87, 87, 87},
    {"GRAY35", 89, 89, 89},
    {"GRAY36", 92, 92, 92},
    {"GRAY37", 94, 94, 94},
    {"GRAY38", 97, 97, 97},
    {"GRAY39", 99, 99, 99},
    {"GRAY4", 10, 10, 10},
    {"GRAY40", 102, 102, 102},
    {"GRAY41", 105, 105, 105},
    {"GRAY42", 107, 107, 107},
    {"GRAY43", 110, 110, 110},
    {"GRAY44", 112, 112, 112},
    {"GRAY45", 115, 115, 115},
    {"GRAY46", 117, 117, 117},
    {"GRAY47", 120, 120, 120},
    {"GRAY48", 122, 122, 122},
    {"GRAY49", 125, 125, 125},
    {"GRAY5", 13, 13, 13},
    {"GRAY50", 127, 127, 127},
    {"GRAY51", 130, 130, 130},
    {"GRAY52", 133, 133, 133},
    {"GRAY53", 135, 135, 135},
    {"GRAY54", 138, 138, 138},
    {"GRAY55", 140, 140, 140},
    {"GRAY56", 143, 143, 143},
    {"GRAY57", 145, 145, 145},
    {"GRAY58", 148, 148, 148},
    {"GRAY59", 150, 150, 150},
    {"GRAY6", 15, 15, 15},
    {"GRAY60", 153, 153, 153},
    {"GRAY61", 156, 156, 156},
    {"GRAY62", 158, 158, 158},
    {"GRAY63", 161, 161, 161},
    {"GRAY64", 163, 163, 163},
    {"GRAY65", 166, 166, 166},
    {"GRAY66", 168, 168, 168},
    {"GRAY67", 171, 171, 171},
    {"GRAY68", 173, 173, 173},
    {"GRAY69", 176, 176, 176},
    {"GRAY7", 18, 18, 18},
    {"GRAY70", 179, 179, 179},
    {"GRAY71", 181, 181, 181},
    {"GRAY72", 184, 184, 184},
    {"GRAY73", 186, 186, 186},
    {"GRAY74", 189, 189, 189},
    {"GRAY75", 191, 191, 191},
    {"GRAY76", 194, 194, 194},
    {"GRAY77", 196, 196, 196},
    {"GRAY78", 199, 199, 199},
    {"GRAY79", 201, 201, 201},
    {"GRAY8", 20, 20, 20},
    {"GRAY80", 204, 204, 204},
    {"GRAY81", 207, 207, 207},
    {"GRAY82", 209, 209, 209},
    {"GRAY83", 212, 212, 212},
    {"GRAY84", 214, 214, 214},
    {"GRAY85", 217, 217, 217},
    {"GRAY86", 219, 219, 219},
    {"GRAY87", 222, 222, 222},
    {"GRAY88", 224, 224, 224},
    {"GRAY89", 227, 227, 227},
    {"GRAY9", 23, 23, 23},
    {"GRAY90", 229, 229, 229},
    {"GRAY91", 232, 232, 232},
    {"GRAY92", 235, 235, 235},
    {"GRAY93", 237, 237, 237},
    {"GRAY94", 240, 240, 240},
    {"GRAY95", 242, 242, 242},
    {"GRAY96", 245, 245, 245},
    {"GRAY97", 247, 247, 247},
    {"GRAY98", 250, 250, 250},
    {"GRAY99", 252, 252, 252},
    {"GREEN", 0, 255, 0},
    {"GREENYELLOW", 173, 255, 47},
    {"HONEYDEW", 240, 255, 240},
    {"HOTPINK", 255, 105, 180},
    {"INDIANRED", 107, 57, 57},
    {"IVORY", 255, 255, 240},
    {"KHAKI", 179, 179, 126},
    {"LAVENDER", 230, 230, 250},
    {"LAVENDERBLUSH", 255, 240, 245},
    {"LAWNGREEN", 124, 252, 0},
    {"LEMONCHIFFON", 255, 250, 205},
    {"LIGHTBLUE", 176, 226, 255},
    {"LIGHTCORAL", 240, 128, 128},
    {"LIGHTCYAN", 224, 255, 255},
    {"LIGHTGOLDENROD", 238, 221, 130},
    {"LIGHTGOLDENRODYELLOW", 250, 250, 210},
    {"LIGHTGRAY", 168, 168, 168},
    {"LIGHTPINK", 255, 182, 193},
    {"LIGHTSALMON", 255, 160, 122},
    {"LIGHTSEAGREEN", 32, 178, 170},
    {"LIGHTSKYBLUE", 135, 206, 250},
    {"LIGHTSLATEBLUE", 132, 112, 255},
    {"LIGHTSLATEGRAY", 119, 136, 153},
    {"LIGHTSTEELBLUE", 124, 152, 211},
    {"LIGHTYELLOW", 255, 255, 224},
    {"LIMEGREEN", 0, 175, 20},
    {"LINEN", 250, 240, 230},
    {"MAGENTA", 255, 0, 255},
    {"MAROON", 143, 0, 82},
    {"MEDIUMAQUAMARINE", 0, 147, 143},
    {"MEDIUMBLUE", 50, 50, 204},
    {"MEDIUMFORESTGREEN", 50, 129, 75},
    {"MEDIUMGOLDENROD", 209, 193, 102},
    {"MEDIUMORCHID", 189, 82, 189},
    {"MEDIUMPURPLE", 147, 112, 219},
    {"MEDIUMSEAGREEN", 52, 119, 102},
    {"MEDIUMSLATEBLUE", 106, 106, 141},
    {"MEDIUMSPRINGGREEN", 35, 142, 35},
    {"MEDIUMTURQUOISE", 0, 210, 210},
    {"MEDIUMVIOLETRED", 213, 32, 121},
    {"MIDNIGHTBLUE", 47, 47, 100},
    {"MINTCREAM", 245, 255, 250},
    {"MISTYROSE", 255, 228, 225},
    {"MOCCASIN", 255, 228, 181},
    {"NAVAJOWHITE", 255, 222, 173},
    {"NAVY", 35, 35, 117},
    {"NAVYBLUE", 35, 35, 117},
    {"OLDLACE", 253, 245, 230},
    {"OLIVEDRAB", 107, 142, 35},
    {"ORANGE", 255, 135, 0},
    {"ORANGERED", 255, 69, 0},
    {"ORCHID", 239, 132, 239},
    {"PALEGOLDENROD", 238, 232, 170},
    {"PALEGREEN", 115, 222, 120},
    {"PALETURQUOISE", 175, 238, 238},
    {"PALEVIOLETRED", 219, 112, 147},
    {"PAPAYAWHIP", 255, 239, 213},
    {"PEACHPUFF", 255, 218, 185},
    {"PERU", 205, 133, 63},
    {"PINK", 255, 181, 197},
    {"PLUM", 197, 72, 155},
    {"POWDERBLUE", 176, 224, 230},
    {"PURPLE", 160, 32, 240},
    {"RED", 255, 0, 0},
    {"ROSYBROWN", 188, 143, 143},
    {"ROYALBLUE", 65, 105, 225},
    {"SADDLEBROWN", 139, 69, 19},
    {"SALMON", 233, 150, 122},
    {"SANDYBROWN", 244, 164, 96},
    {"SEAGREEN", 82, 149, 132},
    {"SEASHELL", 255, 245, 238},
    {"SIENNA", 150, 82, 45},
    {"SKYBLUE", 114, 159, 255},
    {"SLATEBLUE", 126, 136, 171},
    {"SLATEGRAY", 112, 128, 144},
    {"SNOW", 255, 250, 250},
    {"SPRINGGREEN", 65, 172, 65},
    {"STEELBLUE", 84, 112, 170},
    {"TAN", 222, 184, 135},
    {"THISTLE", 216, 191, 216},
    {"TOMATO", 255, 99, 71},
    {"TRANSPARENT", 0, 0, 1},
    {"TURQUOISE", 25, 204, 223},
    {"VIOLET", 156, 62, 206},
    {"VIOLETRED", 243, 62, 150},
    {"WHEAT", 245, 222, 179},
    {"WHITE", 255, 255, 255},
    {"WHITESMOKE", 245, 245, 245},
    {"YELLOW", 255, 255, 0},
    {"YELLOWGREEN", 50, 216, 56}
};


PXPM2BMP Xpm2bmp_new(void)
{
        PXPM2BMP preturn = g_malloc0( sizeof(XPM2BMP) );
        return preturn;
}


int Xpm2bmp_load( PXPM2BMP pXpm2bmp, const char* filename )
{
        return CreateBitmapFromXpm( filename, pXpm2bmp );
}

int Xpm2bmp_paint( PXPM2BMP pXpm2bmp, HDC hdc, int x1,int y1 )
{
        StretchDIBits(hdc,
                                        x1, y1, pXpm2bmp->size_x, pXpm2bmp->size_y,
                                        0, 0, pXpm2bmp->size_x, pXpm2bmp->size_y,
                                        pXpm2bmp->wimage_data_trans,
                                        (BITMAPINFO *)pXpm2bmp->bmih_trans,
                                        DIB_RGB_COLORS,
                                        SRCAND );

        StretchDIBits(hdc,
                                        x1, y1, pXpm2bmp->size_x, pXpm2bmp->size_y,
                                        0, 0, pXpm2bmp->size_x, pXpm2bmp->size_y,
                                        pXpm2bmp->wimage_data,
                                        (BITMAPINFO *)pXpm2bmp->bmih,
                                        DIB_RGB_COLORS,
                                        SRCPAINT );

        return 0;
}

static int parse_line_values( const char* line, PXPM2BMP pXpm2bmp )
{
        int return_value = 0;
        char* parse_line = (char*)line;
        char* tok;
        int value_pos = 0;

        parse_line = strchr( parse_line, '"' );
        parse_line++;

        tok = strtok( parse_line, " \t\n" );

        while ( tok != 0 )
        {
                int val = atoi( tok );
                switch ( value_pos )
                {
                        case 0: pXpm2bmp->size_x = val; break;
                        case 1: pXpm2bmp->size_y = val; break;
                        case 2: pXpm2bmp->colors = val; break;
                        case 3: pXpm2bmp->chars_per_pixel = val; break;
                        case 4: pXpm2bmp->hotspot_x = val; break;
                        case 5: pXpm2bmp->hotspot_y = val; break;
                }
                tok = strtok( NULL, " \t" );
                value_pos ++;

        }

        return return_value;
}

static int hex2int( char c )
{
        if ((c >= '0') && (c <='9' )) return c - '0';
        if ((c >= 'A') && (c <= 'F')) return c - 'A' + 10;
        if ((c >= 'a') && (c <= 'f')) return c - 'a' + 10;
        return -1;
}

static DWORD string2hex16( const char* str )
{
        int i1 = hex2int( str[0] );
        int i2 = hex2int( str[1] );
        if ( ( i1 >= 0 ) && ( i2 >= 0 ) )
                return i1*16+i2;
        return -1;
}

static int parse_color_values( const char* line, PXPM2BMP pXpm2bmp )
{
        int return_value = 0;
        char* cq    = strchr( line, '"' );
        char* cchar = strchr(  cq+pXpm2bmp->chars_per_pixel+1, 'c' );
        char* chash = strchr(  cq+pXpm2bmp->chars_per_pixel+1, '#' );
        char* qe    = strchr(  cq+pXpm2bmp->chars_per_pixel+1, '"' );

        cq++;

        if ( cq )
        {
                memcpy( pXpm2bmp->color_entires[ pXpm2bmp-> color_entires_size].color_str, cq, pXpm2bmp->chars_per_pixel + 1 );
                pXpm2bmp->color_entires[ pXpm2bmp-> color_entires_size].color_str[ pXpm2bmp->chars_per_pixel ] = '\0';


                if ( cchar && chash && qe)
                {
                        int len;
                        chash++;
                        *qe = 0;
                        len = strlen( chash );

                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = string2hex16( &chash[0] );
                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = string2hex16( &chash[len / 3] );
                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = string2hex16( &chash[len * 2 / 3] );
#ifdef _DBG
printf( "adding color %s => %d RGB %x %x %x to index %d\n",
                        line,
                        pXpm2bmp->color_entires_size,
                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r,
                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g,
                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b,
                        pXpm2bmp->color_entires_size );
#endif
                }
                else
                {
                        int q;
                        char *start = cchar + 1;
                        char *end = start;

                        while ( *start != 0 )
                        {
                                if ( ( *start != '\t' ) &&  ( *start != ' ' ) )
                                {
                                        break;
                                }
                                start++;
                        }

                        end = start;
                        while ( *end != 0 )
                        {
                                if ( ( *end == '\t' ) ||  ( *end == ' ' ) ||  ( *end == '"' ))
                                {
                                        *end = 0;
                                }
                                end++;
                        }

                        start = _strupr( start );

                        for ( q=0; q < sizeof( theRGBRecords ) / sizeof( theRGBRecords[0] ); q++ )
                        {

                                if ( 0 == strcmp( start, theRGBRecords[q].color_str  ) )
                                {
                                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = theRGBRecords[q].r;
                                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = theRGBRecords[q].g;
                                        pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = theRGBRecords[q].b;
                                }
                        }
                        if ( 0 == strcmp( start, "NONE" ) )
                        {
                                pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = 255;
                                pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = 0;
                                pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = 255;
                        }
                }
        }
        pXpm2bmp->color_entires_size++;

        return return_value;
}

static int vv = 0;

static int parse_pixel_line_values( const char* line, PXPM2BMP pXpm2bmp, unsigned char* pixel_data, unsigned char* pixel_data_trans )
{
        int return_value = 0;
        int i,j;


        char* cq    = strchr( line, '"' );
        int pix_idx = 0;
        int size_x = pXpm2bmp->size_x;
        int len = strlen( cq );

        cq++;

        if ( len > pXpm2bmp->chars_per_pixel * size_x )
        {
                for ( i=0; i< size_x; i++ )
                {
                        int found = 0;
                        char* cmp = &cq[ i * pXpm2bmp->chars_per_pixel];

                        for ( j=0; j< pXpm2bmp-> color_entires_size; j++ )
                        {
                                if ( strncmp( cmp, pXpm2bmp->color_entires[ j ].color_str, pXpm2bmp->chars_per_pixel ) == 0 )
                                {
                                        int r = pXpm2bmp->color_entires[ j ].r;
                                        int g = pXpm2bmp->color_entires[ j ].g;
                                        int b = pXpm2bmp->color_entires[ j ].b;

                                        if ( ( r == 255 ) && ( g == 0 ) && ( r == 255 ) )
                                        {
                                                r=g=b=0;
                                                pixel_data_trans[ pix_idx ] = 255;
                                                pixel_data_trans[ pix_idx+1 ] = 255;
                                                pixel_data_trans[ pix_idx+2 ] = 255;
                                        }
                                        else
                                        {
                                                pixel_data_trans[ pix_idx ] = 0;
                                                pixel_data_trans[ pix_idx+1 ] = 0;
                                                pixel_data_trans[ pix_idx+2 ] = 0;
                                        }

                                        // pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].r;
                                        // pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].g;
                                        // pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].b;
                                        pixel_data[ pix_idx++ ] = b;
                                        pixel_data[ pix_idx++ ] = g;
                                        pixel_data[ pix_idx++ ] = r;
                                        found = 1;
                                        vv++;
                                        break;
                                }
                        }
                        if ( !found )
                        {
                                fprintf( stderr, "XPMLIB: error color not found\n" );
                        }

                }
        }
        else
        {
                return_value = -1;
                fprintf( stderr, "XPMLIB: invalid line length\n" );
        }
        return return_value;
}


static int CreateBitmapFromXpm( const char* filename, PXPM2BMP pXpm2bmp )
{
        int return_val = 0;
    unsigned char i, row;
        char line[ 1024   ];
        int nbytes ;
        FILE* file_xpm = fopen( filename, "r" );

        int phase = 0;
        row = 0;

        if ( file_xpm )
        {
                while ( fgets(line, sizeof( line ), file_xpm ) )
                {
#ifdef _DBG
                        printf( "PARSING: %s\n", line );
#endif
                        if ( line[ 0 ] != '"' )
                                continue;

                        switch ( phase )
                        {
                                case 0:
                                        parse_line_values( line, pXpm2bmp );
#ifdef _DBG
                                        printf( "size_x %d\n", pXpm2bmp->size_x );
                                        printf( "size_y %d\n", pXpm2bmp->size_y );
#endif
                                        phase = 1;

                                        pXpm2bmp->color_entires_size = 0;
                                        nbytes = ( pXpm2bmp->chars_per_pixel + 1 ) * pXpm2bmp->colors;

                                        pXpm2bmp->color_entires = g_malloc0( sizeof(XPMCOLORENTRY) * (pXpm2bmp->colors + 100) );
                                        pXpm2bmp->color_entires[0].color_str = g_malloc0( nbytes * pXpm2bmp->colors );
                                        for ( i = 1; i< pXpm2bmp->colors; i++ )
                                        {
                                                pXpm2bmp->color_entires[i].color_str = pXpm2bmp->color_entires[0].color_str + ( pXpm2bmp->chars_per_pixel + 1 ) * i;
                                        }

                                        if (!(pXpm2bmp->dib = (unsigned char *)g_malloc(sizeof(BITMAPINFOHEADER) + pXpm2bmp->size_x * pXpm2bmp->size_y * 3)))
                                        {
                                                return 4;
                                        }
                                        if (!(pXpm2bmp->dib_trans = (unsigned char *)g_malloc0(sizeof(BITMAPINFOHEADER) + pXpm2bmp->size_x * pXpm2bmp->size_y * 3)))
                                        {
                                                return 4;
                                        }

                                        memset(pXpm2bmp->dib, 0, sizeof(BITMAPINFOHEADER));
                                        pXpm2bmp->bmih = (BITMAPINFOHEADER *)pXpm2bmp->dib;
                                        pXpm2bmp->bmih->biSize = sizeof(BITMAPINFOHEADER);
                                        pXpm2bmp->bmih->biWidth = pXpm2bmp->size_x;
                                        pXpm2bmp->bmih->biHeight = -((long)pXpm2bmp->size_y);
                                        pXpm2bmp->bmih->biPlanes = 1;
                                        pXpm2bmp->bmih->biBitCount = 24;
                                        pXpm2bmp->bmih->biCompression = 0;
                                        pXpm2bmp->wimage_data = pXpm2bmp->dib + sizeof(BITMAPINFOHEADER);


                                        pXpm2bmp->bmih_trans = (BITMAPINFOHEADER *)pXpm2bmp->dib_trans;
                                        pXpm2bmp->bmih_trans->biSize = sizeof(BITMAPINFOHEADER);
                                        pXpm2bmp->bmih_trans->biWidth = pXpm2bmp->size_x;
                                        pXpm2bmp->bmih_trans->biHeight = -((long)pXpm2bmp->size_y);
                                        pXpm2bmp->bmih_trans->biPlanes = 1;
                                        pXpm2bmp->bmih_trans->biBitCount = 24;
                                        pXpm2bmp->bmih_trans->biCompression = 0;
                                        pXpm2bmp->wimage_data_trans = pXpm2bmp->dib_trans + sizeof(BITMAPINFOHEADER);
//                                      memset( pXpm2bmp->wimage_data_trans, 255, 5* 22 * 3 );

                                break;
                                case 1:
                                        parse_color_values( line, pXpm2bmp  );
                                        if ( pXpm2bmp->color_entires_size >= pXpm2bmp->colors )
                                        {
                                                phase = 2;
                                        }

                                break;
                                case 2:
                                        parse_pixel_line_values( line, pXpm2bmp,
                                        pXpm2bmp->wimage_data + row * pXpm2bmp->size_x * 3,
                                        pXpm2bmp->wimage_data_trans + row * pXpm2bmp->size_x * 3 );

                                        row++;
                                        if ( row >= pXpm2bmp->size_y )
                                        {
                                                phase = 3;
                                        }
                                break;
                        }

                }

                fclose( file_xpm );
        }
        return return_val;
}
1	#include <stdio.h>
2	#include <stdlib.h>
3	#include <windows.h>
4	#include <wingdi.h>
5	#include <glib/glib.h>
6	#include "xpm2bmp.h"
7
8	/* #define _DBG */
9
10	// function prototypes
11	static int CreateBitmapFromXpm( const char* filename, PXPM2BMP pXpm2bmp );
12
13	// typedefs
14	static XPMCOLORENTRY theRGBRecords[] =
15	{
16	{"ALICEBLUE", 240, 248, 255},
17	{"ANTIQUEWHITE", 250, 235, 215},
18	{"AQUAMARINE", 50, 191, 193},
19	{"AZURE", 240, 255, 255},
20	{"BEIGE", 245, 245, 220},
21	{"BISQUE", 255, 228, 196},
22	{"BLACK", 0, 0, 0},
23	{"BLANCHEDALMOND", 255, 235, 205},
24	{"BLUE", 0, 0, 255},
25	{"BLUEVIOLET", 138, 43, 226},
26	{"BROWN", 165, 42, 42},
27	{"BURLYWOOD", 222, 184, 135},
28	{"CADETBLUE", 95, 146, 158},
29	{"CHARTREUSE", 127, 255, 0},
30	{"CHOCOLATE", 210, 105, 30},
31	{"CORAL", 255, 114, 86},
32	{"CORNFLOWERBLUE", 34, 34, 152},
33	{"CORNSILK", 255, 248, 220},
34	{"CYAN", 0, 255, 255},
35	{"DARKGOLDENROD", 184, 134, 11},
36	{"DARKGREEN", 0, 86, 45},
37	{"DARKKHAKI", 189, 183, 107},
38	{"DARKOLIVEGREEN", 85, 86, 47},
39	{"DARKORANGE", 255, 140, 0},
40	{"DARKORCHID", 139, 32, 139},
41	{"DARKSALMON", 233, 150, 122},
42	{"DARKSEAGREEN", 143, 188, 143},
43	{"DARKSLATEBLUE", 56, 75, 102},
44	{"DARKSLATEGRAY", 47, 79, 79},
45	{"DARKTURQUOISE", 0, 166, 166},
46	{"DARKVIOLET", 148, 0, 211},
47	{"DEEPPINK", 255, 20, 147},
48	{"DEEPSKYBLUE", 0, 191, 255},
49	{"DIMGRAY", 84, 84, 84},
50	{"DODGERBLUE", 30, 144, 255},
51	{"FIREBRICK", 142, 35, 35},
52	{"FLORALWHITE", 255, 250, 240},
53	{"FORESTGREEN", 80, 159, 105},
54	{"GAINSBORO", 220, 220, 220},
55	{"GHOSTWHITE", 248, 248, 255},
56	{"GOLD", 218, 170, 0},
57	{"GOLDENROD", 239, 223, 132},
58	{"GRAY", 126, 126, 126},
59	{"GRAY0", 0, 0, 0},
60	{"GRAY1", 3, 3, 3},
61	{"GRAY10", 26, 26, 26},
62	{"GRAY100", 255, 255, 255},
63	{"GRAY11", 28, 28, 28},
64	{"GRAY12", 31, 31, 31},
65	{"GRAY13", 33, 33, 33},
66	{"GRAY14", 36, 36, 36},
67	{"GRAY15", 38, 38, 38},
68	{"GRAY16", 41, 41, 41},
69	{"GRAY17", 43, 43, 43},
70	{"GRAY18", 46, 46, 46},
71	{"GRAY19", 48, 48, 48},
72	{"GRAY2", 5, 5, 5},
73	{"GRAY20", 51, 51, 51},
74	{"GRAY21", 54, 54, 54},
75	{"GRAY22", 56, 56, 56},
76	{"GRAY23", 59, 59, 59},
77	{"GRAY24", 61, 61, 61},
78	{"GRAY25", 64, 64, 64},
79	{"GRAY26", 66, 66, 66},
80	{"GRAY27", 69, 69, 69},
81	{"GRAY28", 71, 71, 71},
82	{"GRAY29", 74, 74, 74},
83	{"GRAY3", 8, 8, 8},
84	{"GRAY30", 77, 77, 77},
85	{"GRAY31", 79, 79, 79},
86	{"GRAY32", 82, 82, 82},
87	{"GRAY33", 84, 84, 84},
88	{"GRAY34", 87, 87, 87},
89	{"GRAY35", 89, 89, 89},
90	{"GRAY36", 92, 92, 92},
91	{"GRAY37", 94, 94, 94},
92	{"GRAY38", 97, 97, 97},
93	{"GRAY39", 99, 99, 99},
94	{"GRAY4", 10, 10, 10},
95	{"GRAY40", 102, 102, 102},
96	{"GRAY41", 105, 105, 105},
97	{"GRAY42", 107, 107, 107},
98	{"GRAY43", 110, 110, 110},
99	{"GRAY44", 112, 112, 112},
100	{"GRAY45", 115, 115, 115},
101	{"GRAY46", 117, 117, 117},
102	{"GRAY47", 120, 120, 120},
103	{"GRAY48", 122, 122, 122},
104	{"GRAY49", 125, 125, 125},
105	{"GRAY5", 13, 13, 13},
106	{"GRAY50", 127, 127, 127},
107	{"GRAY51", 130, 130, 130},
108	{"GRAY52", 133, 133, 133},
109	{"GRAY53", 135, 135, 135},
110	{"GRAY54", 138, 138, 138},
111	{"GRAY55", 140, 140, 140},
112	{"GRAY56", 143, 143, 143},
113	{"GRAY57", 145, 145, 145},
114	{"GRAY58", 148, 148, 148},
115	{"GRAY59", 150, 150, 150},
116	{"GRAY6", 15, 15, 15},
117	{"GRAY60", 153, 153, 153},
118	{"GRAY61", 156, 156, 156},
119	{"GRAY62", 158, 158, 158},
120	{"GRAY63", 161, 161, 161},
121	{"GRAY64", 163, 163, 163},
122	{"GRAY65", 166, 166, 166},
123	{"GRAY66", 168, 168, 168},
124	{"GRAY67", 171, 171, 171},
125	{"GRAY68", 173, 173, 173},
126	{"GRAY69", 176, 176, 176},
127	{"GRAY7", 18, 18, 18},
128	{"GRAY70", 179, 179, 179},
129	{"GRAY71", 181, 181, 181},
130	{"GRAY72", 184, 184, 184},
131	{"GRAY73", 186, 186, 186},
132	{"GRAY74", 189, 189, 189},
133	{"GRAY75", 191, 191, 191},
134	{"GRAY76", 194, 194, 194},
135	{"GRAY77", 196, 196, 196},
136	{"GRAY78", 199, 199, 199},
137	{"GRAY79", 201, 201, 201},
138	{"GRAY8", 20, 20, 20},
139	{"GRAY80", 204, 204, 204},
140	{"GRAY81", 207, 207, 207},
141	{"GRAY82", 209, 209, 209},
142	{"GRAY83", 212, 212, 212},
143	{"GRAY84", 214, 214, 214},
144	{"GRAY85", 217, 217, 217},
145	{"GRAY86", 219, 219, 219},
146	{"GRAY87", 222, 222, 222},
147	{"GRAY88", 224, 224, 224},
148	{"GRAY89", 227, 227, 227},
149	{"GRAY9", 23, 23, 23},
150	{"GRAY90", 229, 229, 229},
151	{"GRAY91", 232, 232, 232},
152	{"GRAY92", 235, 235, 235},
153	{"GRAY93", 237, 237, 237},
154	{"GRAY94", 240, 240, 240},
155	{"GRAY95", 242, 242, 242},
156	{"GRAY96", 245, 245, 245},
157	{"GRAY97", 247, 247, 247},
158	{"GRAY98", 250, 250, 250},
159	{"GRAY99", 252, 252, 252},
160	{"GREEN", 0, 255, 0},
161	{"GREENYELLOW", 173, 255, 47},
162	{"HONEYDEW", 240, 255, 240},
163	{"HOTPINK", 255, 105, 180},
164	{"INDIANRED", 107, 57, 57},
165	{"IVORY", 255, 255, 240},
166	{"KHAKI", 179, 179, 126},
167	{"LAVENDER", 230, 230, 250},
168	{"LAVENDERBLUSH", 255, 240, 245},
169	{"LAWNGREEN", 124, 252, 0},
170	{"LEMONCHIFFON", 255, 250, 205},
171	{"LIGHTBLUE", 176, 226, 255},
172	{"LIGHTCORAL", 240, 128, 128},
173	{"LIGHTCYAN", 224, 255, 255},
174	{"LIGHTGOLDENROD", 238, 221, 130},
175	{"LIGHTGOLDENRODYELLOW", 250, 250, 210},
176	{"LIGHTGRAY", 168, 168, 168},
177	{"LIGHTPINK", 255, 182, 193},
178	{"LIGHTSALMON", 255, 160, 122},
179	{"LIGHTSEAGREEN", 32, 178, 170},
180	{"LIGHTSKYBLUE", 135, 206, 250},
181	{"LIGHTSLATEBLUE", 132, 112, 255},
182	{"LIGHTSLATEGRAY", 119, 136, 153},
183	{"LIGHTSTEELBLUE", 124, 152, 211},
184	{"LIGHTYELLOW", 255, 255, 224},
185	{"LIMEGREEN", 0, 175, 20},
186	{"LINEN", 250, 240, 230},
187	{"MAGENTA", 255, 0, 255},
188	{"MAROON", 143, 0, 82},
189	{"MEDIUMAQUAMARINE", 0, 147, 143},
190	{"MEDIUMBLUE", 50, 50, 204},
191	{"MEDIUMFORESTGREEN", 50, 129, 75},
192	{"MEDIUMGOLDENROD", 209, 193, 102},
193	{"MEDIUMORCHID", 189, 82, 189},
194	{"MEDIUMPURPLE", 147, 112, 219},
195	{"MEDIUMSEAGREEN", 52, 119, 102},
196	{"MEDIUMSLATEBLUE", 106, 106, 141},
197	{"MEDIUMSPRINGGREEN", 35, 142, 35},
198	{"MEDIUMTURQUOISE", 0, 210, 210},
199	{"MEDIUMVIOLETRED", 213, 32, 121},
200	{"MIDNIGHTBLUE", 47, 47, 100},
201	{"MINTCREAM", 245, 255, 250},
202	{"MISTYROSE", 255, 228, 225},
203	{"MOCCASIN", 255, 228, 181},
204	{"NAVAJOWHITE", 255, 222, 173},
205	{"NAVY", 35, 35, 117},
206	{"NAVYBLUE", 35, 35, 117},
207	{"OLDLACE", 253, 245, 230},
208	{"OLIVEDRAB", 107, 142, 35},
209	{"ORANGE", 255, 135, 0},
210	{"ORANGERED", 255, 69, 0},
211	{"ORCHID", 239, 132, 239},
212	{"PALEGOLDENROD", 238, 232, 170},
213	{"PALEGREEN", 115, 222, 120},
214	{"PALETURQUOISE", 175, 238, 238},
215	{"PALEVIOLETRED", 219, 112, 147},
216	{"PAPAYAWHIP", 255, 239, 213},
217	{"PEACHPUFF", 255, 218, 185},
218	{"PERU", 205, 133, 63},
219	{"PINK", 255, 181, 197},
220	{"PLUM", 197, 72, 155},
221	{"POWDERBLUE", 176, 224, 230},
222	{"PURPLE", 160, 32, 240},
223	{"RED", 255, 0, 0},
224	{"ROSYBROWN", 188, 143, 143},
225	{"ROYALBLUE", 65, 105, 225},
226	{"SADDLEBROWN", 139, 69, 19},
227	{"SALMON", 233, 150, 122},
228	{"SANDYBROWN", 244, 164, 96},
229	{"SEAGREEN", 82, 149, 132},
230	{"SEASHELL", 255, 245, 238},
231	{"SIENNA", 150, 82, 45},
232	{"SKYBLUE", 114, 159, 255},
233	{"SLATEBLUE", 126, 136, 171},
234	{"SLATEGRAY", 112, 128, 144},
235	{"SNOW", 255, 250, 250},
236	{"SPRINGGREEN", 65, 172, 65},
237	{"STEELBLUE", 84, 112, 170},
238	{"TAN", 222, 184, 135},
239	{"THISTLE", 216, 191, 216},
240	{"TOMATO", 255, 99, 71},
241	{"TRANSPARENT", 0, 0, 1},
242	{"TURQUOISE", 25, 204, 223},
243	{"VIOLET", 156, 62, 206},
244	{"VIOLETRED", 243, 62, 150},
245	{"WHEAT", 245, 222, 179},
246	{"WHITE", 255, 255, 255},
247	{"WHITESMOKE", 245, 245, 245},
248	{"YELLOW", 255, 255, 0},
249	{"YELLOWGREEN", 50, 216, 56}
250	};
251
252
253	PXPM2BMP Xpm2bmp_new(void)
254	{
255	PXPM2BMP preturn = g_malloc0( sizeof(XPM2BMP) );
256	return preturn;
257	}
258
259
260	int Xpm2bmp_load( PXPM2BMP pXpm2bmp, const char* filename )
261	{
262	return CreateBitmapFromXpm( filename, pXpm2bmp );
263	}
264
265	int Xpm2bmp_paint( PXPM2BMP pXpm2bmp, HDC hdc, int x1,int y1 )
266	{
267	StretchDIBits(hdc,
268	x1, y1, pXpm2bmp->size_x, pXpm2bmp->size_y,
269	0, 0, pXpm2bmp->size_x, pXpm2bmp->size_y,
270	pXpm2bmp->wimage_data_trans,
271	(BITMAPINFO *)pXpm2bmp->bmih_trans,
272	DIB_RGB_COLORS,
273	SRCAND );
274
275	StretchDIBits(hdc,
276	x1, y1, pXpm2bmp->size_x, pXpm2bmp->size_y,
277	0, 0, pXpm2bmp->size_x, pXpm2bmp->size_y,
278	pXpm2bmp->wimage_data,
279	(BITMAPINFO *)pXpm2bmp->bmih,
280	DIB_RGB_COLORS,
281	SRCPAINT );
282
283	return 0;
284	}
285
286	static int parse_line_values( const char* line, PXPM2BMP pXpm2bmp )
287	{
288	int return_value = 0;
289	char* parse_line = (char*)line;
290	char* tok;
291	int value_pos = 0;
292
293	parse_line = strchr( parse_line, '"' );
294	parse_line++;
295
296	tok = strtok( parse_line, " \t\n" );
297
298	while ( tok != 0 )
299	{
300	int val = atoi( tok );
301	switch ( value_pos )
302	{
303	case 0: pXpm2bmp->size_x = val; break;
304	case 1: pXpm2bmp->size_y = val; break;
305	case 2: pXpm2bmp->colors = val; break;
306	case 3: pXpm2bmp->chars_per_pixel = val; break;
307	case 4: pXpm2bmp->hotspot_x = val; break;
308	case 5: pXpm2bmp->hotspot_y = val; break;
309	}
310	tok = strtok( NULL, " \t" );
311	value_pos ++;
312
313	}
314
315	return return_value;
316	}
317
318	static int hex2int( char c )
319	{
320	if ((c >= '0') && (c <='9' )) return c - '0';
321	if ((c >= 'A') && (c <= 'F')) return c - 'A' + 10;
322	if ((c >= 'a') && (c <= 'f')) return c - 'a' + 10;
323	return -1;
324	}
325
326	static DWORD string2hex16( const char* str )
327	{
328	int i1 = hex2int( str[0] );
329	int i2 = hex2int( str[1] );
330	if ( ( i1 >= 0 ) && ( i2 >= 0 ) )
331	return i1*16+i2;
332	return -1;
333	}
334
335	static int parse_color_values( const char* line, PXPM2BMP pXpm2bmp )
336	{
337	int return_value = 0;
338	char* cq = strchr( line, '"' );
339	char* cchar = strchr( cq+pXpm2bmp->chars_per_pixel+1, 'c' );
340	char* chash = strchr( cq+pXpm2bmp->chars_per_pixel+1, '#' );
341	char* qe = strchr( cq+pXpm2bmp->chars_per_pixel+1, '"' );
342
343	cq++;
344
345	if ( cq )
346	{
347	memcpy( pXpm2bmp->color_entires[ pXpm2bmp-> color_entires_size].color_str, cq, pXpm2bmp->chars_per_pixel + 1 );
348	pXpm2bmp->color_entires[ pXpm2bmp-> color_entires_size].color_str[ pXpm2bmp->chars_per_pixel ] = '\0';
349
350
351	if ( cchar && chash && qe)
352	{
353	int len;
354	chash++;
355	*qe = 0;
356	len = strlen( chash );
357
358	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = string2hex16( &chash[0] );
359	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = string2hex16( &chash[len / 3] );
360	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = string2hex16( &chash[len * 2 / 3] );
361	#ifdef _DBG
362	printf( "adding color %s => %d RGB %x %x %x to index %d\n",
363	line,
364	pXpm2bmp->color_entires_size,
365	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r,
366	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g,
367	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b,
368	pXpm2bmp->color_entires_size );
369	#endif
370	}
371	else
372	{
373	int q;
374	char *start = cchar + 1;
375	char *end = start;
376
377	while ( *start != 0 )
378	{
379	if ( ( start != '\t' ) && ( start != ' ' ) )
380	{
381	break;
382	}
383	start++;
384	}
385
386	end = start;
387	while ( *end != 0 )
388	{
389	if ( ( end == '\t' ) \|\| ( end == ' ' ) \|\| ( *end == '"' ))
390	{
391	*end = 0;
392	}
393	end++;
394	}
395
396	start = _strupr( start );
397
398	for ( q=0; q < sizeof( theRGBRecords ) / sizeof( theRGBRecords[0] ); q++ )
399	{
400
401	if ( 0 == strcmp( start, theRGBRecords[q].color_str ) )
402	{
403	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = theRGBRecords[q].r;
404	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = theRGBRecords[q].g;
405	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = theRGBRecords[q].b;
406	}
407	}
408	if ( 0 == strcmp( start, "NONE" ) )
409	{
410	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].r = 255;
411	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].g = 0;
412	pXpm2bmp->color_entires[ pXpm2bmp->color_entires_size].b = 255;
413	}
414	}
415	}
416	pXpm2bmp->color_entires_size++;
417
418	return return_value;
419	}
420
421	static int vv = 0;
422
423	static int parse_pixel_line_values( const char* line, PXPM2BMP pXpm2bmp, unsigned char* pixel_data, unsigned char* pixel_data_trans )
424	{
425	int return_value = 0;
426	int i,j;
427
428
429	char* cq = strchr( line, '"' );
430	int pix_idx = 0;
431	int size_x = pXpm2bmp->size_x;
432	int len = strlen( cq );
433
434	cq++;
435
436	if ( len > pXpm2bmp->chars_per_pixel * size_x )
437	{
438	for ( i=0; i< size_x; i++ )
439	{
440	int found = 0;
441	char* cmp = &cq[ i * pXpm2bmp->chars_per_pixel];
442
443	for ( j=0; j< pXpm2bmp-> color_entires_size; j++ )
444	{
445	if ( strncmp( cmp, pXpm2bmp->color_entires[ j ].color_str, pXpm2bmp->chars_per_pixel ) == 0 )
446	{
447	int r = pXpm2bmp->color_entires[ j ].r;
448	int g = pXpm2bmp->color_entires[ j ].g;
449	int b = pXpm2bmp->color_entires[ j ].b;
450
451	if ( ( r == 255 ) && ( g == 0 ) && ( r == 255 ) )
452	{
453	r=g=b=0;
454	pixel_data_trans[ pix_idx ] = 255;
455	pixel_data_trans[ pix_idx+1 ] = 255;
456	pixel_data_trans[ pix_idx+2 ] = 255;
457	}
458	else
459	{
460	pixel_data_trans[ pix_idx ] = 0;
461	pixel_data_trans[ pix_idx+1 ] = 0;
462	pixel_data_trans[ pix_idx+2 ] = 0;
463	}
464
465	// pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].r;
466	// pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].g;
467	// pixel_data[ pix_idx++ ] = pXpm2bmp->color_entires[ j ].b;
468	pixel_data[ pix_idx++ ] = b;
469	pixel_data[ pix_idx++ ] = g;
470	pixel_data[ pix_idx++ ] = r;
471	found = 1;
472	vv++;
473	break;
474	}
475	}
476	if ( !found )
477	{
478	fprintf( stderr, "XPMLIB: error color not found\n" );
479	}
480
481	}
482	}
483	else
484	{
485	return_value = -1;
486	fprintf( stderr, "XPMLIB: invalid line length\n" );
487	}
488	return return_value;
489	}
490
491
492	static int CreateBitmapFromXpm( const char* filename, PXPM2BMP pXpm2bmp )
493	{
494	int return_val = 0;
495	unsigned char i, row;
496	char line[ 1024 ];
497	int nbytes ;
498	FILE* file_xpm = fopen( filename, "r" );
499
500	int phase = 0;
501	row = 0;
502
503	if ( file_xpm )
504	{
505	while ( fgets(line, sizeof( line ), file_xpm ) )
506	{
507	#ifdef _DBG
508	printf( "PARSING: %s\n", line );
509	#endif
510	if ( line[ 0 ] != '"' )
511	continue;
512
513	switch ( phase )
514	{
515	case 0:
516	parse_line_values( line, pXpm2bmp );
517	#ifdef _DBG
518	printf( "size_x %d\n", pXpm2bmp->size_x );
519	printf( "size_y %d\n", pXpm2bmp->size_y );
520	#endif
521	phase = 1;
522
523	pXpm2bmp->color_entires_size = 0;
524	nbytes = ( pXpm2bmp->chars_per_pixel + 1 ) * pXpm2bmp->colors;
525
526	pXpm2bmp->color_entires = g_malloc0( sizeof(XPMCOLORENTRY) * (pXpm2bmp->colors + 100) );
527	pXpm2bmp->color_entires[0].color_str = g_malloc0( nbytes * pXpm2bmp->colors );
528	for ( i = 1; i< pXpm2bmp->colors; i++ )
529	{
530	pXpm2bmp->color_entires[i].color_str = pXpm2bmp->color_entires[0].color_str + ( pXpm2bmp->chars_per_pixel + 1 ) * i;
531	}
532
533	if (!(pXpm2bmp->dib = (unsigned char )g_malloc(sizeof(BITMAPINFOHEADER) + pXpm2bmp->size_x pXpm2bmp->size_y * 3)))
534	{
535	return 4;
536	}
537	if (!(pXpm2bmp->dib_trans = (unsigned char )g_malloc0(sizeof(BITMAPINFOHEADER) + pXpm2bmp->size_x pXpm2bmp->size_y * 3)))
538	{
539	return 4;
540	}
541
542	memset(pXpm2bmp->dib, 0, sizeof(BITMAPINFOHEADER));
543	pXpm2bmp->bmih = (BITMAPINFOHEADER *)pXpm2bmp->dib;
544	pXpm2bmp->bmih->biSize = sizeof(BITMAPINFOHEADER);
545	pXpm2bmp->bmih->biWidth = pXpm2bmp->size_x;
546	pXpm2bmp->bmih->biHeight = -((long)pXpm2bmp->size_y);
547	pXpm2bmp->bmih->biPlanes = 1;
548	pXpm2bmp->bmih->biBitCount = 24;
549	pXpm2bmp->bmih->biCompression = 0;
550	pXpm2bmp->wimage_data = pXpm2bmp->dib + sizeof(BITMAPINFOHEADER);
551
552
553	pXpm2bmp->bmih_trans = (BITMAPINFOHEADER *)pXpm2bmp->dib_trans;
554	pXpm2bmp->bmih_trans->biSize = sizeof(BITMAPINFOHEADER);
555	pXpm2bmp->bmih_trans->biWidth = pXpm2bmp->size_x;
556	pXpm2bmp->bmih_trans->biHeight = -((long)pXpm2bmp->size_y);
557	pXpm2bmp->bmih_trans->biPlanes = 1;
558	pXpm2bmp->bmih_trans->biBitCount = 24;
559	pXpm2bmp->bmih_trans->biCompression = 0;
560	pXpm2bmp->wimage_data_trans = pXpm2bmp->dib_trans + sizeof(BITMAPINFOHEADER);
561	// memset( pXpm2bmp->wimage_data_trans, 255, 5* 22 * 3 );
562
563	break;
564	case 1:
565	parse_color_values( line, pXpm2bmp );
566	if ( pXpm2bmp->color_entires_size >= pXpm2bmp->colors )
567	{
568	phase = 2;
569	}
570
571	break;
572	case 2:
573	parse_pixel_line_values( line, pXpm2bmp,
574	pXpm2bmp->wimage_data + row * pXpm2bmp->size_x * 3,
575	pXpm2bmp->wimage_data_trans + row * pXpm2bmp->size_x * 3 );
576
577	row++;
578	if ( row >= pXpm2bmp->size_y )
579	{
580	phase = 3;
581	}
582	break;
583	}
584
585	}
586
587	fclose( file_xpm );
588	}
589	return return_val;
590	}