EPRINT.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/*  file to print GIF, TGA and CEL files */

// This is not very successful and should be rewritten since it
// does not seem to work with colour printers.

#include <windows.h>
#include <io.h>
#include <stdio.h>
#include <string.h>

#if __SC__
#pragma ZTC align 1
#endif

#include "../common/mem.h"

#define FI_DIB 0
#define FI_GIF 1
#define FI_TGA 2
#define FI_CEL 3
#define PALVERSION  0x300
#define MAXPALETTE  256
#define MAXTEXT     256

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif
extern short read_gif_image(char *, short);
extern unsigned char p_red[],p_green[],p_blue[];
extern int colourmap_size,x_size,y_size,gif_iLace;

HINSTANCE hInst          = NULL;
HPALETTE  hpalCurrent    = NULL;         /* Handle to current palette            */
HBITMAP   hbmCurrent     = NULL;         /* Handle to current memory BITMAP      */
HDC       hdcCurrent     = NULL;
RGBQUAD   *pRgb          = NULL;
LPSTR     lpBitmapHeader = NULL;
LPSTR     lpBitmapBits   = NULL;

#define BOUND(x,min,max) ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))
#define SWAP(x,y)   ((x)^=(y)^=(x)^=(y))
#define MIN(x,y) (((x) <= (y)) : x ? y)
#define StartWait() hcurSave = SetCursor(LoadCursor(NULL,IDC_WAIT))
#define EndWait()   SetCursor(hcurSave)
/* macro to determine if resource is a DIB */
#define ISDIB(bft) ((bft) == BFT_BITMAP)
/* Macro to align given value to the closest DWORD (unsigned long ) */
#define ALIGNULONG(i)   ((i+3)/4*4)
/* Macro to determine to round off the given value to the closest byte */
#define WIDTHBYTES(i)   ((i+31)/32*4)

static int x4_size,rowcount,rowinc;
static LPSTR pixels;
static POINT ptSize;
static HCURSOR hcurSave;

static void FreeDib(void);
static HPALETTE CreateImagePalette(LPBITMAPINFOHEADER lpbi);
static WORD NumColours(LPBITMAPINFOHEADER lpbi);
static HBITMAP BitmapFromDib(LPSTR lpHeader,LPSTR lpBits,HPALETTE hpal);

static void FreeDib(void){
 if (hpalCurrent) DeleteObject(hpalCurrent);
 if (hbmCurrent)  DeleteObject(hbmCurrent);
 if(lpBitmapBits   != NULL)X__Free((char *)lpBitmapBits);
 if(lpBitmapHeader != NULL)X__Free((char *)lpBitmapHeader);
 lpBitmapHeader = NULL;
 lpBitmapBits   = NULL;
 hpalCurrent    = NULL;
 hbmCurrent     = NULL;
 pRgb           = NULL;
}

#define DibNumColors(bmih) (bmih.biClrUsed == 0 && bmih.biBitCount <= 8 \
                            ? (int)(1 << (int)bmih.biBitCount)          \
                            : (int)bmih.biClrUsed)

static int dib_view(char *temp){
 HDC hdc;
 HANDLE hfbm;
 BITMAPFILEHEADER bmfh;
 DWORD dwRead;
 BITMAPINFOHEADER bmih;
 LPBITMAPINFOHEADER lpbi;
 LPBITMAPINFO lpinfo;
 long imagesize,nc;
 FreeDib();
 hfbm=CreateFile(temp,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
      FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 ReadFile(hfbm,&bmfh,sizeof(BITMAPFILEHEADER),&dwRead,(LPOVERLAPPED)NULL);
 ReadFile(hfbm,&bmih,sizeof(BITMAPINFOHEADER),&dwRead,(LPOVERLAPPED)NULL);
 nc=DibNumColors(bmih);
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER)+
                   (nc*sizeof(RGBQUAD)));
 if(lpBitmapHeader == NULL)return 0;
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpinfo=(LPBITMAPINFO)lpBitmapHeader;
 lpbi->biSize=bmih.biSize;
 x_size=lpbi->biWidth=bmih.biWidth;
 lpbi->biHeight=bmih.biHeight;
 lpbi->biPlanes=bmih.biPlanes;
 lpbi->biBitCount=bmih.biBitCount;
 lpbi->biCompression=bmih.biCompression;
 lpbi->biSizeImage=bmih.biSizeImage;
 lpbi->biXPelsPerMeter=bmih.biXPelsPerMeter;
 lpbi->biYPelsPerMeter=bmih.biYPelsPerMeter;
 lpbi->biClrUsed=bmih.biClrUsed;
 lpbi->biClrImportant=bmih.biClrImportant;
 if(nc > 0)ReadFile(hfbm,lpinfo->bmiColors,(nc*sizeof(RGBQUAD)),
          &dwRead,(LPOVERLAPPED)NULL);
 hpalCurrent=NULL;
// hpalCurrent=CreateImagePalette(lpbi);
 imagesize=bmfh.bfSize-bmfh.bfOffBits;
 lpBitmapBits=(LPSTR)X__Malloc(imagesize);
 if(lpBitmapBits == NULL){
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 pixels=lpBitmapBits;
 ReadFile(hfbm,lpBitmapBits,imagesize,&dwRead,(LPOVERLAPPED)NULL);
 hdc = CreateCompatibleDC(NULL);
// hdc = CreateCompatibleDC(hdcCurrent);
 hbmCurrent=CreateDIBitmap(hdc,&bmih,CBM_INIT,lpBitmapBits,
                          lpinfo,DIB_RGB_COLORS);
 DeleteDC(hdc);
 return 1;
}

int out_line(unsigned char *linepixels, int linelen){
 register long l;
 l = (long)(y_size - 1 - rowcount)*(long)(x4_size);
 memcpy(pixels + l, linepixels, linelen);
 rowcount+=abs(rowinc);
 if(rowcount >= y_size){
  if     (rowinc == -8){rowinc=8; rowcount=4;}
  else if(rowinc ==  8){rowinc=4; rowcount=2;}
  else if(rowinc ==  4){rowinc=2; rowcount=1;}
 }
 return 0;
}

static int gif_view(char *temp){
 int i;
 long imagesize;
 LPBITMAPINFOHEADER lpbi;
 FreeDib();
 rowcount=0;
 rowinc=1;
 if(read_gif_image(temp,1) < 0)return 0;
 x4_size = ALIGNULONG(x_size);
 if(gif_iLace)rowinc = -8;
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER)
                                +256L*sizeof(RGBQUAD));
 if(lpBitmapHeader == NULL)return 0;
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)x4_size;
 lpbi->biHeight=(DWORD)y_size;
 lpbi->biPlanes=1;
 lpbi->biBitCount=8;
 lpbi->biCompression=BI_RGB;
 imagesize = lpbi->biSizeImage = (DWORD)x4_size*(DWORD)y_size;
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=256;
 lpbi->biClrImportant=256;
 pRgb=(RGBQUAD *)((LPSTR)lpbi + lpbi->biSize);
 for(i=0;i<256;i++){
   pRgb[i].rgbRed = p_red[i] << 2;
   pRgb[i].rgbGreen = p_green[i] << 2;
   pRgb[i].rgbBlue = p_blue[i] << 2;
 }
 hpalCurrent=CreateImagePalette(lpbi);
 lpBitmapBits=(LPSTR)X__Malloc(imagesize);
 if(lpBitmapBits == NULL){
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 pixels=lpBitmapBits;
 if(read_gif_image(temp,0) < 0){
   FreeDib();
   return 0;
 }
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)return 0;
 return 1;
}

static HPALETTE CreateImagePalette(LPBITMAPINFOHEADER lpbi){
 LOGPALETTE *pPal;
 HPALETTE   hpal = NULL;
 WORD       nNumColors;
 BYTE       red;
 BYTE       green;
 BYTE       blue;
 int        i;
 RGBQUAD    *pRgb;
 if(lpbi == NULL)return NULL;
 if(lpbi->biSize != sizeof(BITMAPINFOHEADER))return NULL;
 /* Get a pointer to the color table and the number of colors in it */
 pRgb = (RGBQUAD *)((LPSTR)lpbi + (WORD)lpbi->biSize);
 nNumColors = NumColours(lpbi);
 if(nNumColors){
   pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors * sizeof(PALETTEENTRY));
   if(pPal == NULL)return NULL;
   pPal->palNumEntries = nNumColors;
   pPal->palVersion    = PALVERSION;
   /* Fill in the palette entries from the DIB color table and
    * create a logical color palette. */
   for (i = 0; i < nNumColors; i++){
       pPal->palPalEntry[i].peRed   = pRgb[i].rgbRed;
       pPal->palPalEntry[i].peGreen = pRgb[i].rgbGreen;
       pPal->palPalEntry[i].peBlue  = pRgb[i].rgbBlue;
       pPal->palPalEntry[i].peFlags = (BYTE)0;
   }
   hpal = CreatePalette(pPal);
   LocalFree((HANDLE)pPal);
 }
 else if (lpbi->biBitCount == 24){
   /* A 24 bitcount DIB has no color table entries so, set the number of
    * to the maximum value (256). */
   nNumColors = MAXPALETTE;
   pPal=(LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) + nNumColors * sizeof(PALETTEENTRY));
   if(pPal == NULL)return NULL;
   pPal->palNumEntries = nNumColors;
   pPal->palVersion    = PALVERSION;
   red = green = blue = 0;
   /* Generate 256 (= 8*8*4) RGB combinations to fill the palette entries. */
   for (i = 0; i < pPal->palNumEntries; i++){
       pPal->palPalEntry[i].peRed   = red;
       pPal->palPalEntry[i].peGreen = green;
       pPal->palPalEntry[i].peBlue  = blue;
       pPal->palPalEntry[i].peFlags = (BYTE)0;
       if (!(red += 32))if (!(green += 32)) blue += 64;
   }
   hpal = CreatePalette(pPal);
   LocalFree((HANDLE)pPal);
 }
 return hpal;
}

static WORD NumColours(LPBITMAPINFOHEADER lpbi){
 WORD bits;
 if (lpbi->biClrUsed != 0)return (WORD)lpbi->biClrUsed;
 bits = lpbi->biBitCount;
 switch (bits){
  case 1:    return 2;
  case 4:    return 16;
  case 8:    return 256;
  default:   return 0; /* A 24 bitcount DIB has no color table */
 }
}

static HBITMAP BitmapFromDib(LPSTR lpHeader,LPSTR lpBits,HPALETTE hpal){
 HDC       hdc;         /* make BITMAP from a memory DIB */
 HBITMAP   hbm;
 HPALETTE  hpalT;
 if (lpHeader == NULL || lpBits == NULL)return NULL;
 hdc = CreateCompatibleDC(NULL);
// hdc = CreateCompatibleDC(hdcCurrent);
 if(hpal != NULL){
   hpalT = SelectPalette(hdc,hpal,FALSE);
   RealizePalette(hdc);
 }
 hbm = CreateDIBitmap(hdc,
                (LPBITMAPINFOHEADER)lpHeader,
                (LONG)CBM_INIT,
                lpBits,
                (LPBITMAPINFO)lpHeader,
                DIB_RGB_COLORS );
 if(hpal != NULL)SelectPalette(hdc,hpalT,FALSE);
 DeleteDC(hdc);
 return hbm;
}

static void tga_display_line(unsigned char *prgb,
                             long wide, long line,
                             long upsidedown, long hi){
 register long l,x,k;
 if(upsidedown)l = 3L*(long)(line)*(long)(x4_size);
 else          l = 3L*(long)(hi - 1 - line)*(long)(x4_size);
 memcpy(pixels + l, prgb, (int)(wide*3));
}

static short R_getvariword(long n, FILE *f, long *vw){
 long c;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw = c;          if(n == 1)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 8);  if(n == 2)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 16); if(n == 3)return 1;
 if((c=(long)getc(f)) == EOF)return 0;
 *vw |= (c << 24);
 return 1;
}

static short LoadTGA(char *filename, short info_only){
 char c0,c1,c2;
 long i,j,k,l,m,n,cmo,cml,xor,yor,wi,hi,iok=0,idsize,cm_type,vw,
      image_type,cmes,pixel_size,image_descriptor,n_attr,upsidedown,b_size,
      s1,s2,s,pat,wi3;
 FILE *t24;
 unsigned char *prgb;
 prgb=NULL;
 if((t24=fopen(filename,"rb")) != NULL){
   if(! R_getvariword(1,t24,&idsize))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&cm_type))goto CLOSEOUT; /* 0 for non mapped */
   if(! R_getvariword(1,t24,&image_type))goto CLOSEOUT; /* image type */
   if(image_type != 2 && image_type != 10)goto CLOSEOUT;
   if(! R_getvariword(2,t24,&cmo))goto CLOSEOUT;  /* color map 5 bytes */
   if(! R_getvariword(2,t24,&cml))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&cmes))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&xor))goto CLOSEOUT;  /* Image spec 10 bytes */
   if(! R_getvariword(2,t24,&yor))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&wi))goto CLOSEOUT;
   if(! R_getvariword(2,t24,&hi))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&pixel_size))goto CLOSEOUT;
   if(! R_getvariword(1,t24,&image_descriptor))goto CLOSEOUT;
   if(idsize > 0)for(i=0;i<idsize;i++)if(getc(t24) == EOF)goto CLOSEOUT;
   if(cm_type == 1 && cml > 0){
     for(i=cmo;i<cml;i++)if(! R_getvariword(cmes/8,t24,&j))goto CLOSEOUT;
   }
   n_attr = image_descriptor & 0xf;
   upsidedown = (image_descriptor & 0x20) > 0 ? 0 : 1 ;
   if(info_only){
     x_size=(int)wi;
     y_size=(int)hi;
     fclose(t24);
     return 1;
   }
   if((prgb=(unsigned char *)X__Malloc((size_t)wi*3)) == NULL)goto CLOSEOUT;
   if((image_descriptor & 0xc0) > 0)goto CLOSEOUT; /* interlaced */
   b_size=i=wi*hi;
   if     (pixel_size == 16){n=2;s1=5;s2=10;s=3;pat=0x1f;}
   else if(pixel_size == 24){n=3;s1=8;s2=16;s=0;pat=0xff;}
   else                     {n=4;s1=8;s2=16;s=0;pat=0xff;}
   wi3=wi*3;
   if(image_type == 2){ /* uncompressed */
     m=0; k=0; for(i=0;i<hi;i++)for(j=0;j<wi;j++){
       if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
       prgb[m  ] = (char)( vw        & pat) << s;
       prgb[m+1] = (char)((vw >> s1) & pat) << s;
       prgb[m+2] = (char)((vw >> s2) & pat) << s;
       k++; m+=3;
       if(m == wi3){
         tga_display_line(prgb,wi,i,upsidedown,hi); m=0;
       }
     }
   }
   else{  /* compressed */
     m=0; l=0; k=0; while(k < b_size){
       i=getc(t24); if(feof(t24))goto CLOSEOUT;
        if(i < 128){
         for(j=0;j<i+1;j++){
           if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
           prgb[m  ] = (char)( vw        & pat) << s;
           prgb[m+1] = (char)((vw >> s1) & pat) << s;
           prgb[m+2] = (char)((vw >> s2) & pat) << s;
           k++; m+=3;
           if(m == wi3){
             tga_display_line(prgb,wi,l,upsidedown,hi); m=0; l++;
           }
         }
       }
       else{
         if(! R_getvariword(n,t24,&vw))goto CLOSEOUT;
         c0 = (char)( vw        & pat) << s;
         c1 = (char)((vw >> s1) & pat) << s;
         c2 = (char)((vw >> s2) & pat) << s;
         i -= 128;
         for(j=0;j<i+1;j++){
           prgb[m  ] = c0;
           prgb[m+1] = c1;
           prgb[m+2] = c2;
           k++;  m+=3;
           if(m == wi3){
             tga_display_line(prgb,wi,l,upsidedown,hi); m=0; l++;
           }
         }
       }
     }
   }
   iok=1;
   CLOSEOUT:
   fclose(t24);
   if(prgb != NULL)X__Free((char *)prgb);
 }
 return (short)iok;
}

static int tga_view(char *temp){
 int i;
 long imagesize;
 LPBITMAPINFOHEADER lpbi;
 if(LoadTGA(temp,1) == 0)return 0;
 x4_size=ALIGNULONG(x_size);
 FreeDib();
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER));
 if(lpBitmapHeader == NULL)return 0;
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)x4_size;
 lpbi->biHeight=(DWORD)y_size;
 lpbi->biPlanes=1;
 lpbi->biBitCount=24;
 lpbi->biCompression=BI_RGB;
 imagesize = lpbi->biSizeImage = (DWORD)x4_size*(DWORD)y_size*3L;
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=0;
 lpbi->biClrImportant=0;
 hpalCurrent=CreateImagePalette(lpbi);  /* will set up a dummy palette */
 lpBitmapBits=(LPSTR)X__Malloc(imagesize);
 if(lpBitmapBits == NULL){
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 pixels=lpBitmapBits;
 if(LoadTGA(temp,0) == 0){
   FreeDib();
   return 0;
 }
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)return 0;
 return 1;
}

#if 0
// NO USED NOW
#include "..\render2\flc.h"

static FILE *Bit_File;
static unsigned char *Screen=NULL;

static short RenderFlcBrun(FILE *f);
static short RenderFlcColor(FILE *f, short type);
static short LoadRenderAnimCel(FILE *f, Flc_head *flc, short info_only);

static long nx,ny,nx4;

static long LoadCEL(char *name, short info_only){
 long i,cel_type;
 struct pic_header aa_cel;
 Flc_head flc_cel;
 unsigned char cc,*pix;
 if((Bit_File=fopen(name,"rb")) == NULL)return 0;
 if(fread(&aa_cel,sizeof(struct pic_header),1,Bit_File) != 1)cel_type=0;
 else if(aa_cel.type == PIC_MAGIC){
   cel_type=1;
   nx = x_size = aa_cel.w;
   ny = y_size = aa_cel.h;
 }
 else{
   fseek(Bit_File,0,SEEK_SET);
   if(fread(&flc_cel,sizeof(Flc_head),1,Bit_File) != 1)cel_type=0;
   else if(flc_cel.type == FLCH_MAGIC){
     cel_type=2;
     nx = x_size = flc_cel.width;
     ny = y_size = flc_cel.height;
   }
 }
 nx4=ALIGNULONG(nx);
 if(cel_type == 0){fclose(Bit_File); return(0);}
 if(cel_type == 2){
   if(LoadRenderAnimCel(Bit_File,&flc_cel,info_only) < 0){
     fclose(Bit_File);
     return(0);
   }
 }
 else{
   for(i = 0; i < 256 ; i++) {
     fread(&cc,1,1,Bit_File); p_red[i]  = cc << 2;
     fread(&cc,1,1,Bit_File); p_green[i]  = cc << 2;
     fread(&cc,1,1,Bit_File); p_blue[i]  = cc << 2;
   }
   if(info_only){
     fclose(Bit_File);
     return 1;
   }
   for(i=0;i<ny;i++){
     pix=Screen+(ny-1-i)*nx4;
     if(fread(pix,1,nx,Bit_File) != nx){
       fclose(Bit_File);
       return(0);
     }
   }
 }
 fclose(Bit_File);
 return(1);
}

static short LoadRenderAnimCel(FILE *f,Flc_head *flc, short info_only){
 Flc_frame f_frame;
 Flc_chunk f_chunk;
 long i,j,k;
 char c;
 unsigned char *p;
/*printf("size of flc head %ld\n",(long)sizeof(Flc_head));*/
 fseek(f,flc->oframe1,SEEK_SET);
 if(fread(&f_frame,sizeof(Flc_frame),1,f) != 1 ||
           f_frame.type != FLCF_MAGIC)return -1;
/*printf("point2  %ld chunks\n",f_frame.chunks);*/
 for(i=0;i<f_frame.chunks;i++){
   if(fread(&f_chunk,sizeof(Flc_chunk),1,f) != 1)return -1;
/*printf("chunk type %ld\n",(long)f_chunk.type);*/
   if(f_chunk.type == FLC_COLOR256 || f_chunk.type == FLC_COLOR){
     if(RenderFlcColor(f,f_chunk.type) < 0)return -1;
     if(info_only)return 0;
   }
   else if(!info_only && f_chunk.type == FLC_BRUN){
     if(RenderFlcBrun(f) < 0)return -1;
   }
   else if(!info_only && f_chunk.type == FLC_COPY){
     for (k=0;k<ny;k++){
       p=Screen+(ny-1-k)*nx4;
      if(fread(p,1,nx,f) != nx)return -1;
     }
   }
   else{
     for(j=0;j<f_chunk.size-6;j++)fread(&c,1,1,f);
   }
 }
 return 0;
}

static short RenderFlcColor(FILE *f, short type){
 short i,j,pk,packets,ci=0;
 unsigned char skip=0,change,colour;
 if(fread(&packets,2,1,f) != 1)return -1;
 for (pk=0; pk<packets; pk++ ) {
   if(fread(&skip,1,1,f) != 1)return -1;
   ci += skip;
   if(fread(&change,1,1,f) != 1)return -1;
   if (change == 0) change=255;
   for (i=0; i<=change; i++) {
     if(fread(&colour,1,1,f) != 1)return -1;
     if(type == FLC_COLOR)colour = colour << 2;
     p_red[ci] = colour;
     if(fread(&colour,1,1,f) != 1)return -1;
     if(type == FLC_COLOR)colour = colour << 2;
     p_green[ci] = colour;
     if(fread(&colour,1,1,f) != 1)return -1;
     if(type == FLC_COLOR)colour = colour << 2;
     p_blue[ci] = colour;
     ci++;
   }
 }
 return 0;
}

static short RenderFlcBrun(FILE *f){
 char size=0;
 unsigned char packet,*p,colour;
 short i,line,pk;
 for (line=0;line<ny;line++){
   p=Screen+(ny-1-line)*nx4;
   if(fread(&packet,1,1,f) != 1)return -1;
   for(pk=0; pk<nx; pk+=abs(size)){
     if(fread(&size,1,1,f) != 1)return -1;
     if(size > 0){
       if(fread(&colour,1,1,f) != 1)return -1;
       for (i=0; i<size; i++) *p++ = colour;
     }
     else{
       for (i = size; i<0; i++){
         if(fread(&colour,1,1,f) != 1)return -1;
         *p++ = colour;
       }
     }
   }
 }
 return 0;
}

static int cel_view(char *temp){
 int i;
 long imagesize;
 LPBITMAPINFOHEADER lpbi;
 FreeDib();
 rowcount=0;
 if(LoadCEL(temp,1) < 0){
   return 0;
 }
 x4_size = ALIGNULONG(x_size);
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER)
                                +256L*sizeof(RGBQUAD));
 if(lpBitmapHeader == NULL){
   return 0;
 }
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)x4_size;
 lpbi->biHeight=(DWORD)y_size;
 lpbi->biPlanes=1;
 lpbi->biBitCount=8;
 lpbi->biCompression=BI_RGB;
 imagesize = lpbi->biSizeImage = (DWORD)x4_size*(DWORD)y_size;
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=256;
 lpbi->biClrImportant=256;
 pRgb=(RGBQUAD *)((LPSTR)lpbi + lpbi->biSize);
 for(i=0;i<256;i++){
   pRgb[i].rgbRed = p_red[i];
   pRgb[i].rgbGreen = p_green[i];
   pRgb[i].rgbBlue = p_blue[i];
 }
 hpalCurrent=CreateImagePalette(lpbi);
 lpBitmapBits=(LPSTR)X__Malloc(imagesize);
 if(lpBitmapBits == NULL){
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 Screen=(unsigned char *)lpBitmapBits;
 if(LoadCEL(temp,0) < 0){
   FreeDib();
   return 0;
 }
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)return 0;
 return 1;
}
// END of NOT USED
#endif

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
//      MessageBox (GetFocus(),"Attaching","Debug",MB_OK);
#endif
      hInst=hDLL;
      break;
    }
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
//      MessageBox (GetFocus(),"Detaching","Debug",MB_OK);
#endif
      hInst=hDLL;
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

static BOOL bPrint=TRUE;
static HWND hdlgCancel=NULL;

LRESULT CALLBACK AbortPrintJob(HWND hwndDlg, UINT message,
                               WPARAM wParam,LPARAM lParam){
 RECT rc;
 switch(message){
   case WM_INITDIALOG:
     GetWindowRect(hwndDlg, &rc);
     SetWindowPos(hwndDlg, NULL,
       (GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2,
       (GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2,
       0, 0, SWP_NOSIZE | SWP_NOZORDER);
     return TRUE;
   case WM_COMMAND:
     bPrint=FALSE;
     return TRUE;
   default:
     return FALSE;
 }
 return FALSE;
}

BOOL CALLBACK AbortProc(HDC hdc, int nCode){
 MSG msg;
 while(PeekMessage((LPMSG)&msg,(HWND)NULL,0,0,PM_REMOVE)){
   if(!IsDialogMessage(hdlgCancel,(LPMSG)&msg)){
     TranslateMessage((LPMSG)&msg);
     DispatchMessage((LPMSG)&msg);
   }
 }
 return bPrint;
}

BOOL _PrintBitmap(HWND parent_window, char *filename){
 PRINTDLG pd;
 DOCINFO  di;
 HPALETTE hpalT;
 HBITMAP holdBitmap;
 RECT rc;
 SIZE szMetric;
 int result=0,nError,imax,imin;
 char temp[256];
 memset(&pd,0,sizeof(PRINTDLG));
 pd.lStructSize=sizeof(PRINTDLG);
 pd.Flags=PD_RETURNDC;
 pd.hwndOwner=parent_window;
 pd.hDC=(HDC)NULL;
 pd.nFromPage=1;
 pd.nToPage=1;
 pd.nMinPage=0;
 pd.nMaxPage=1;
 pd.nCopies=1;
 pd.hInstance=NULL;
 pd.lCustData=0L;
 if(!PrintDlg(&pd))return FALSE;
 if(pd.hDC == NULL){
   MessageBox(parent_window,"Printer cannot draw.","Printing",MB_OK);
   return FALSE;
 }
 if(!(GetDeviceCaps(pd.hDC,RASTERCAPS) & RC_BITBLT)){
   DeleteDC(pd.hDC);
   MessageBox(parent_window,"Printer cannot display bitmaps.","Printing",MB_OK);
   return FALSE;
 }
 FreeDib();
 StartWait();
 strcpy(temp,filename);
 strupr(temp);
 hdcCurrent=pd.hDC;
 if     (strstr(temp,".GIF"))result=gif_view(temp);
 //else if(strstr(temp,".CEL"))result=cel_view(temp); REMOVED
 else if(strstr(temp,".TGA"))result=tga_view(temp);
 else if(strstr(temp,".BMP"))result=dib_view(temp);
 else result=0;
 EndWait();
 if(result == 1){
   HDC hdcMem;
   LPBITMAPINFOHEADER lpbi;
   float fScaleX,fScaleY;
   int xLeft,yTop,cWidthPels,cHeightPels;
   bPrint=TRUE;
   SetAbortProc(pd.hDC,AbortProc);
   hdlgCancel=CreateDialog(hInst,(LPSTR)"AbortDialog",parent_window,
                           (DLGPROC)AbortPrintJob);
   di.cbSize=sizeof(DOCINFO);
   di.lpszDocName="Printing Image";
   di.lpszOutput=NULL;
   if((nError=StartDoc(pd.hDC,&di)) == SP_ERROR)goto Error;
   if((nError=StartPage(pd.hDC)) <= 0)goto Error;
   lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
   cWidthPels=GetDeviceCaps(pd.hDC,HORZRES);
   cHeightPels=GetDeviceCaps(pd.hDC,VERTRES);
   imax=max(lpbi->biWidth,lpbi->biHeight);
   imin=min(cWidthPels,cHeightPels);
   fScaleX=fScaleY=((float)imin/(float)imax)*0.9;
//sprintf(temp,"BMP %ldx%ld\nPrinter x=%ld y=%ld\nnx=%ld ny=%ld",
//lpbi->biWidth,lpbi->biHeight,cWidthPels,cHeightPels,
//(int)(fScaleX*(float)lpbi->biWidth),
//(int)(fScaleY*(float)lpbi->biHeight));
//MessageBox(parent_window,temp,"debug",MB_OK);
   xLeft=((cWidthPels/2)-((int)(((float)lpbi->biWidth)*fScaleX))/2);
   yTop=((cHeightPels/2)-((int)(((float)lpbi->biHeight)*fScaleY))/2);
   hdcMem=CreateCompatibleDC(pd.hDC);
   if(hdcMem == NULL){
     MessageBox(parent_window,"Bad Memory DC","Debug",MB_OK);
     goto Error;
   }
   if(hbmCurrent == NULL){
     MessageBox(parent_window,"No bitmap to print","Debug",MB_OK);
     DeleteDC(hdcMem);
     goto Error;
   }
   holdBitmap=SelectObject(hdcMem,hbmCurrent);
   if(holdBitmap == NULL){
     MessageBox(parent_window,"Bad Object Selection","Debug",MB_OK);
     DeleteDC(hdcMem);
     goto Error;
   }
//else MessageBox(parent_window,"Good Object Selection","Debug",MB_OK);
   if(hpalCurrent != NULL){
     hpalT = SelectPalette(pd.hDC,hpalCurrent,FALSE);
     RealizePalette (pd.hDC);
   }
   StretchBlt(pd.hDC,xLeft,yTop,
              (int)((float)lpbi->biWidth*fScaleX),
              (int)((float)lpbi->biHeight*fScaleY),
              hdcMem,0,0,
              lpbi->biWidth,
              lpbi->biHeight,
              SRCCOPY);
   SelectObject(hdcMem,holdBitmap);
   DeleteDC(hdcMem);
   if(hpalCurrent != NULL)SelectPalette(pd.hDC,hpalT,FALSE);
   GetTextExtentPoint(pd.hDC,filename,strlen(filename),&szMetric);
   xLeft=((cWidthPels/2)-(szMetric.cx/2));
   yTop=szMetric.cy;
   TextOut(pd.hDC,xLeft,yTop,filename,strlen(filename));
   if((nError=EndPage(pd.hDC)) <= 0)goto Error;
   if((nError=EndDoc(pd.hDC)) <= 0)goto Error;
   goto NoError;
   Error:
   MessageBox(parent_window,"Error setting up printer","Printing",MB_OK);
   NoError:
   DestroyWindow(hdlgCancel);
 }
 else MessageBox(parent_window,"Could not open image","Printing",MB_OK);
 DeleteDC(pd.hDC);
 FreeDib();
 return TRUE;
}