VIEWER.C

Go to the documentation of this file.

/*  file to display images */

#include <windows.h>
#include <io.h>
#include <stdio.h>
#include <string.h>
#include "viewer.h"
#include "..\common\animate\about.h"

#if __SC__ || __WATCOMC__
extern INT _argc;
extern CHAR **_argv;
#else
extern INT __argc;
extern CHAR **__argv;
#endif

#if __SC__
#pragma ZTC align 1
#endif

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

#define FI_GIF 0
#define FI_TGA 1
//#define FI_CEL 2  // REMOVED
#define FI_DIB 3
#define FI_TIF 4
#define FI_JPG 5
#define FI_PNG 6
#define PALVERSION  0x300
#define MAXPALETTE  256
#define MAXTEXT     256

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;

HWND      hWndApp        = NULL;
HINSTANCE hInst          = NULL;
HPALETTE  hpalCurrent    = NULL;         /* Handle to current palette            */
HBITMAP   hbmCurrent     = NULL;         /* Handle to current memory BITMAP      */
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 char *szViewClass="OFX:ViewClass";

char IniFilename[256],
     IniSection[]  = "VIEWER";
static SYSTEM_INFO sys_info;
static int DisplayWidth,DisplayHeight,DisplayBits,DisplayPlanes,
           xScreen,yScreen,rowcount,rowinc,x4_size,file_format=FI_GIF;
static int from_renderer=0;
static LPSTR pixels;
static char CurrentDirFile[256],CurrentDirectory[256],CurrentFile[256];
static POINT ptSize;
static DWORD fdwStyle = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU |
                        WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME;
static HCURSOR hcurSave;

static int identify_file_format(void);
static int ErrMsg(char *sz,...);
static void LoadErrMsg(int id);
static void PutMsg(char *s);
BOOL CALLBACK AboutDlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);
LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam);
BOOL MenuCommand(HWND hWnd, WORD id, LONG lparam);
static void FreeDib(void);
static void SizeWindow(HWND hWnd);
static void SetScrollRanges(HWND hwnd);
static HPALETTE CreateImagePalette(LPBITMAPINFOHEADER lpbi);
static WORD NumColours(LPBITMAPINFOHEADER lpbi);
static void GetRealClientRect(HWND hwnd, PRECT lprc);
static void AppPaint(HWND hWnd, HDC hDC, int x, int y);
static HBITMAP BitmapFromDib(LPSTR lpHeader,LPSTR lpBits,HPALETTE hpal);
static int celview(HWND hWnd);
static int dibview(HWND hWnd);
static int tifview(HWND hWnd);
static int jpgview(HWND hWnd);

static char WIN32_environment[512];

char *R_GetEnv(char const *aa){
 if(GetEnvironmentVariable((LPTSTR)aa,(LPTSTR)WIN32_environment,256) == 0)
   return NULL;
 return WIN32_environment;
}

static PSTR FileInPath(PSTR pstrPath){
 PSTR pstr;
 pstr = pstrPath + strlen(pstrPath);
 while (pstr > pstrPath) {
     pstr = (AnsiPrev(pstrPath, pstr));
     if (*pstr == '\\' || *pstr == ':' || *pstr == '/') {
         pstr = (AnsiNext(pstr));
         break;
     }
 }
 return pstr;
}

int Viewer(HINSTANCE hInstance){
 MSG msg;
 HWND hDesktopWnd,hWnd;
 HDC hDCcaps;
 WNDCLASS wndclass;
 hInst       = hInstance;
 hDesktopWnd = GetDesktopWindow();
 hDCcaps     = GetDC(hDesktopWnd);
 DisplayWidth= GetDeviceCaps(hDCcaps,HORZRES);
 DisplayHeight= GetDeviceCaps(hDCcaps,VERTRES);
 DisplayBits= GetDeviceCaps(hDCcaps,BITSPIXEL);
 DisplayPlanes= GetDeviceCaps(hDCcaps,PLANES);
 ReleaseDC(hDesktopWnd,hDCcaps);
 GetSystemInfo(&sys_info);
 wndclass.style         = 0;
 wndclass.lpfnWndProc   = (WNDPROC)MainWndProc;
 wndclass.cbClsExtra    = 0 ;
 wndclass.cbWndExtra    = 0 ;
 wndclass.hInstance     = hInstance ;
 wndclass.hIcon         = LoadIcon(hInst, "VIEWICON");
 wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
 wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
 wndclass.lpszMenuName  = "ShowMenu" ;
 wndclass.lpszClassName = szViewClass;
 if (!RegisterClass (&wndclass))  return FALSE ;
 xScreen = GetSystemMetrics (SM_CXSCREEN) ;
 yScreen = GetSystemMetrics (SM_CYSCREEN) ;
 hWnd = CreateWindow(
        szViewClass,
        "Viewer",
        fdwStyle,
        CW_USEDEFAULT,
        CW_USEDEFAULT,
        xScreen / 2,
        yScreen / 2,
        NULL,
        NULL,
        hInstance,
        NULL) ;
 if(hWnd == NULL)return FALSE;
 ShowWindow (hWndApp = hWnd, SW_SHOWNA);
 while(GetMessage (&msg, NULL, 0, 0)) {
   TranslateMessage (&msg);
   DispatchMessage (&msg);
 }
 FreeDib();
 UnregisterClass(wndclass.lpszClassName,wndclass.hInstance);
 return msg.wParam;
}

LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,
                             LPARAM lParam){
 PAINTSTRUCT ps;
 HDC hDC;
 int i,iPos,iMax,iMin,dn;
 RECT rc;
 switch (iMessage) {
    case WM_CREATE:
      SetWindowPos(hWnd,HWND_TOPMOST,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
      break;
//  case WM_ACTIVATEAPP:
//    if((BOOL)wParam == FALSE && !from_renderer){
//      SetWindowPos(hWnd,HWND_NOTOPMOST,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
//      ShowWindow(hWnd,SW_HIDE);
//    }
//    else SetWindowPos(hWnd,HWND_TOPMOST,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
//    break;
  case WM_SYSCOMMAND:
    switch(LOWORD(wParam & 0xfff0)){
      case SC_CLOSE:
        PostMessage(hWnd,WM_COMMAND,IDM_HIDE,0);
        break;
      default:
        return(DefWindowProc(hWnd,iMessage,wParam,lParam));
        break;
     }
     break;
  case WM_COMMAND:
    return MenuCommand(hWnd,LOWORD(wParam),lParam);
    break;
  case WM_PAINT:
    hDC = BeginPaint(hWnd, &ps);
    AppPaint(hWnd,
       hDC,
       GetScrollPos(hWnd,SB_HORZ),
       GetScrollPos(hWnd,SB_VERT) );
    EndPaint(hWnd, &ps);
    break ;
  case WM_QUERYNEWPALETTE:{
      HDC hDC;
      HPALETTE hpalT;
      if(hpalCurrent == NULL)break;
      hDC=GetDC(hWnd);
      hpalT = SelectPalette(hDC,hpalCurrent,FALSE);
      if(RealizePalette (hDC) > 0)InvalidateRect (hWnd, (LPRECT) (NULL), 1);
      SelectPalette(hDC,hpalT,FALSE);
      ReleaseDC(hWnd,hDC);
      return TRUE;
    }
  case WM_PALETTECHANGED:
    if(hpalCurrent == NULL)break;
    if ((HWND)wParam != hWnd ){
      HDC hDC;
      HPALETTE hpalT;
      hDC=GetDC(hWnd);
      hpalT = SelectPalette(hDC,hpalCurrent,FALSE);
      if(RealizePalette (hDC) > 0)InvalidateRect (hWnd, (LPRECT) (NULL), 1);
      SelectPalette(hDC,hpalT,FALSE);
      ReleaseDC(hWnd,hDC);
    }
    break;
  case WM_SIZE:
    SetScrollRanges(hWnd);
    break;
  case WM_KEYDOWN:
    switch (wParam) {
      case VK_UP:    PostMessage (hWnd, WM_VSCROLL, SB_LINEUP,   0L);  break;
      case VK_DOWN:  PostMessage (hWnd, WM_VSCROLL, SB_LINEDOWN, 0L);  break;
      case VK_PRIOR: PostMessage (hWnd, WM_VSCROLL, SB_PAGEUP,   0L);  break;
      case VK_NEXT:  PostMessage (hWnd, WM_VSCROLL, SB_PAGEDOWN, 0L);  break;
      case VK_HOME:  PostMessage (hWnd, WM_HSCROLL, SB_PAGEUP,   0L);  break;
      case VK_END:   PostMessage (hWnd, WM_HSCROLL, SB_PAGEDOWN, 0L);  break;
      case VK_LEFT:  PostMessage (hWnd, WM_HSCROLL, SB_LINEUP,   0L);  break;
      case VK_RIGHT: PostMessage (hWnd, WM_HSCROLL, SB_LINEDOWN, 0L);  break;
    }
    break;
  case WM_KEYUP:
    switch (wParam) {
      case VK_UP:
      case VK_DOWN:
      case VK_PRIOR:
      case VK_NEXT:
        PostMessage (hWnd, WM_VSCROLL, SB_ENDSCROLL, 0L);
        break;
      case VK_HOME:
      case VK_END:
      case VK_LEFT:
      case VK_RIGHT:
        PostMessage (hWnd, WM_HSCROLL, SB_ENDSCROLL, 0L);
        break;
    }
    break;
  case WM_VSCROLL:
    /* Calculate new vertical scroll position */
    GetScrollRange (hWnd, SB_VERT, &iMin, &iMax);
    iPos = GetScrollPos (hWnd, SB_VERT);
    GetClientRect (hWnd, &rc);
    switch (LOWORD(wParam)) {
      case SB_LINEDOWN:      dn =  rc.bottom / 16 + 1;    break;
      case SB_LINEUP:        dn = -rc.bottom / 16 + 1;    break;
      case SB_PAGEDOWN:      dn =  rc.bottom / 2  + 1;    break;
      case SB_PAGEUP:        dn = -rc.bottom / 2  + 1;    break;
      case SB_THUMBTRACK:
      case SB_THUMBPOSITION: dn = HIWORD(wParam)-iPos;    break;
      default:               dn = 0;
    }
    /* Limit scrolling to current scroll range */
    if ((dn = BOUND (iPos + dn, iMin, iMax) - iPos) != 0) {
      ScrollWindow(hWnd, 0, -dn, NULL, NULL);
      SetScrollPos(hWnd, SB_VERT, iPos + dn, TRUE);
    }
    break;
  case WM_HSCROLL:
    /* Calculate new horizontal scroll position */
    GetScrollRange(hWnd, SB_HORZ, &iMin, &iMax);
    iPos = GetScrollPos(hWnd, SB_HORZ);
    GetClientRect (hWnd, &rc);
    switch (LOWORD(wParam)) {
      case SB_LINEDOWN:      dn =  rc.right / 16 + 1;     break;
      case SB_LINEUP:        dn = -rc.right / 16 + 1;     break;
      case SB_PAGEDOWN:      dn =  rc.right / 2  + 1;     break;
      case SB_PAGEUP:        dn = -rc.right / 2  + 1;     break;
      case SB_THUMBTRACK:
      case SB_THUMBPOSITION: dn = HIWORD(wParam) - iPos; break;
      default:               dn = 0;
    }
    /* Limit scrolling to current scroll range */
    if ((dn = BOUND (iPos + dn, iMin, iMax) - iPos) != 0) {
      ScrollWindow (hWnd, -dn, 0, NULL, NULL);
      SetScrollPos (hWnd, SB_HORZ, iPos + dn, TRUE);
    }
    break;
  default:
    return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
 }
 return 0L ;
}

BOOL MenuCommand (HWND hWnd, WORD id, LONG lparam){
 int i;
 char lpMessage[MAXTEXT],lpCaption[64];
 switch (id) {
   case IDM_ABOUT:
     MessageBox(hWnd,"     "
                     ABOUT_VERSION
                     "        ",
                     "About OpenFX Viewer..",MB_OK);
     break;
   case IDM_DISPLAY:
     LoadString(hInst,IDS_DISPLAY,lpCaption,64);
     if     (DisplayWidth==640)
       LoadString(hInst,IDS_640,lpMessage,MAXTEXT);
     else if(DisplayWidth==800)
       LoadString(hInst,IDS_800,lpMessage,MAXTEXT);
     else if(DisplayWidth==1024)
       LoadString(hInst,IDS_1024,lpMessage,MAXTEXT);
     else
       LoadString(hInst,IDS_CUSTOM,lpMessage,MAXTEXT);
     MessageBox(GetFocus(),lpMessage,lpCaption,MB_OK);
     break;
   case IDM_COLOURS:
     LoadString(hInst,IDS_COLOUR,lpCaption,64);
     if(DisplayBits < 8)
       LoadString(hInst,IDS_COLOUR16,lpMessage,MAXTEXT);
     else if(DisplayBits==8)
       LoadString(hInst,IDS_COLOUR256,lpMessage,MAXTEXT);
     else if(DisplayBits==16)
       LoadString(hInst,IDS_COLOUR65,lpMessage,MAXTEXT);
     else if(DisplayBits==24)
       LoadString(hInst,IDS_COLOUR16M,lpMessage,MAXTEXT);
     else LoadString(hInst,IDS_CUSTOMC,lpMessage,MAXTEXT);
     MessageBox(GetFocus(),lpMessage,lpCaption,MB_OK);
     break;
   case IDM_OPEN: {
     OPENFILENAME ofn;
     char szTitle[60]="File to View",szFilter[256];
     from_renderer=0;
     CurrentDirectory[0]='\0';
     CurrentFile[0]='\0';
     GetModuleFileName(hInst,CurrentDirFile,255);
     *FileInPath(CurrentDirFile) = '\0';
     GetPrivateProfileString(IniSection,"LASTFILE","*.*",
        CurrentFile,sizeof(CurrentFile),IniFilename);
     GetPrivateProfileString(IniSection,"LASTPATH",CurrentDirFile,
       CurrentDirectory,sizeof(CurrentDirectory),IniFilename);
     if(CurrentDirectory[0] != 0)SetCurrentDirectory(CurrentDirectory);
     file_format=GetPrivateProfileInt(IniSection,"LASTTYPE",file_format,IniFilename);
     strcpy(CurrentDirFile,CurrentDirectory);
     strcat(CurrentDirFile,CurrentFile);
     strcpy(szFilter,
     "All file formats|*.bmp;*.gif;*.tga;*;*.jpg;*.tif;*.png|"
     "(*.GIF)|*.gif|"
     "(*.TGA)|*.tga|"
     "(*.BMP)|*.bmp|"
     "(*.TIF)|*.tif|"
     "(*.JPG)|*.jpg|"
     "(*.PNG)|*.png|");
     i=0; while(szFilter[i] != '\0'){
       if(szFilter[i] == '|')szFilter[i]='\0';
       i++;
     }
     memset(&ofn,0,sizeof(OPENFILENAME));
     ofn.lStructSize=sizeof(OPENFILENAME);
     ofn.hwndOwner=hWnd;
     ofn.lpstrFilter=szFilter;
     if     (file_format == FI_GIF)ofn.nFilterIndex=1;
     else if(file_format == FI_TGA)ofn.nFilterIndex=2;
     //else if(file_format == FI_CEL)ofn.nFilterIndex=3; removed
     else if(file_format == FI_DIB)ofn.nFilterIndex=4;
     else if(file_format == FI_TIF)ofn.nFilterIndex=5;
     else if(file_format == FI_JPG)ofn.nFilterIndex=6;
     else if(file_format == FI_JPG)ofn.nFilterIndex=6;
     else if(file_format == FI_PNG)ofn.nFilterIndex=7;
     ofn.lpstrFile=CurrentDirFile;   /* will contain file + path */
     ofn.nMaxFile=sizeof(CurrentDirFile);
     ofn.lpstrFileTitle=CurrentFile;  /* file name only */
     ofn.nMaxFileTitle=sizeof(CurrentFile);
     ofn.lpstrInitialDir=CurrentDirectory;
     ofn.lpstrTitle=szTitle;
     ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST;
     if(GetOpenFileName(&ofn)){
       file_format=identify_file_format();
       WritePrivateProfileString(IniSection,"LASTFILE",CurrentFile,IniFilename);
       if(FileInPath(CurrentDirFile) != NULL)*FileInPath(CurrentDirFile)='\0';
       WritePrivateProfileString(IniSection,"LASTPATH",CurrentDirFile,IniFilename);
       sprintf(lpCaption,"%ld",file_format);
       WritePrivateProfileString(IniSection,"LASTTYPE",lpCaption,IniFilename);
       PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_DRAWIT,0);
     }
     break;
   }
   case IDM_SHOWMAP:
     GetPrivateProfileString(IniSection,"MAPFILE","*.*",
        CurrentFile,sizeof(CurrentFile),IniFilename);
     SendMessage(hWnd,WM_COMMAND,IDM_DRAWIT,0);
     break;
   case IDM_SHOWLAST:
     if(lparam == 1)from_renderer=1;
     else           from_renderer=0;
     CurrentDirectory[0]='\0';
     CurrentFile[0]='\0';
     GetModuleFileName(hInst,CurrentDirFile,255);
     *FileInPath(CurrentDirFile) = '\0';
     GetPrivateProfileString(IniSection,"FILE","*.*",
        CurrentFile,sizeof(CurrentFile),IniFilename);
     GetPrivateProfileString(IniSection,"PATH",CurrentDirFile,
       CurrentDirectory,sizeof(CurrentDirectory),IniFilename);
     if(CurrentDirectory[0] != 0 && CurrentFile[0] != 0){
       strcpy(CurrentDirFile,CurrentDirectory);
       strcat(CurrentDirFile,CurrentFile);
       strcpy(CurrentFile,CurrentDirFile);
     }
     file_format=GetPrivateProfileInt(IniSection,"TYPE",file_format,IniFilename);
   case IDM_DRAWIT:
     StartWait();
     file_format=identify_file_format();
     switch(file_format){
       case FI_GIF:
         if(gifview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       case FI_TGA:
         if(tgaview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       //case FI_CEL:
       // if(celview(hWnd))InvalidateRect (hWnd, NULL, FALSE); // REMOVED
       //  break;
       case FI_DIB:
         if(dibview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       case FI_TIF:
         if(tifview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       case FI_JPG:
         if(jpgview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       case FI_PNG:
         if(pngview(hWnd))InvalidateRect (hWnd, NULL, FALSE);
         break;
       default:
         break;
     }
     EndWait();
     if(from_renderer){
       HWND hRndr;
       if((hRndr=FindWindow("OFX:RenderClass",NULL)) != NULL){
         SetForegroundWindow(hRndr);
       }
       from_renderer=0;
     }
     break;
   case IDM_HIDE:
     ShowWindow(hWnd,SW_HIDE);
     break;
   case IDM_EXIT:
     PostQuitMessage(0);
     break;
   default:
     break;
 }
 return TRUE;
}

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;
}

static int identify_file_format(void){
 int ff=FI_DIB;
 strupr(CurrentFile);
 if     (strstr(CurrentFile,".GIF"))ff=FI_GIF;
 //else if(strstr(CurrentFile,".CEL"))ff=FI_CEL; //REMOVED
 else if(strstr(CurrentFile,".TGA"))ff=FI_TGA;
 else if(strstr(CurrentFile,".DIB") ||
         strstr(CurrentFile,".BMP") ||
         strstr(CurrentFile,".RLE"))ff=FI_DIB;
 else if(strstr(CurrentFile,".TIF"))ff=FI_TIF;
 else if(strstr(CurrentFile,".JPG"))ff=FI_JPG;
 else if(strstr(CurrentFile,".PNG"))ff=FI_PNG;
 return ff;
}

static int ErrMsg(char *sz,...){
 char ach[256];
 va_list arg_ptr;
 va_start(arg_ptr,sz);
 vsprintf(ach,sz,arg_ptr);   /* Format the string */
 va_end(arg_ptr);
 MessageBox (NULL, ach, NULL, MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
 return FALSE;
}

static void PutMsg(char *s){
 MessageBox (NULL,s, "Viewer", MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
}

static void LoadErrMsg(int id){
 char mes[256];
 LoadString(hInst,id,mes,255);
 ErrMsg(mes);
}

static void SizeWindow(HWND hWnd){
 char Title[120];
 RECT  Rectangle;
 int   dx,dy;
 POINT pt;
 LPBITMAPINFOHEADER bi;
 if((bi=(LPBITMAPINFOHEADER)lpBitmapHeader) == NULL)return;
 sprintf(Title,
          "%s (%s %ldx%ldx%ld)",
          "View",
          CurrentFile,
          (long)x_size,  //(long)bi->biWidth,
          (long)bi->biHeight,
          (long)bi->biBitCount);
 SetWindowText(hWnd,Title);
 ptSize.x = (WORD)bi->biWidth;
 ptSize.y = (WORD)bi->biHeight;
 if (IsZoomed(hWnd))SetScrollRanges(hWnd);
 else {
   Rectangle.left   = 0;
   Rectangle.top    = 0;
   Rectangle.right  = (WORD)bi->biWidth;
   Rectangle.bottom = (WORD)bi->biHeight;
   AdjustWindowRect (&Rectangle,fdwStyle,TRUE);
   SetWindowPos (hWnd, (HWND)NULL, 0, 0,
                 Rectangle.right  - Rectangle.left + 1,
                 Rectangle.bottom - Rectangle.top + 1,
                 SWP_NOMOVE | SWP_NOZORDER);
 }
 InvalidateRect(hWnd,NULL,TRUE);
}

static void SetScrollRanges(HWND hwnd){
 RECT rc;
 int iRangeH,iRangeV,i;
 static int iSem = 0;
 if(!iSem){
   iSem++;
   GetRealClientRect(hwnd,&rc);
   for(i = 0; i < 2; i++){
     iRangeV = ptSize.y - rc.bottom;
     iRangeH = ptSize.x - rc.right;
     if(iRangeH < 0)iRangeH = 0;
     if(iRangeV < 0)iRangeV = 0;
     if (GetScrollPos(hwnd,SB_VERT)  > iRangeV ||
         GetScrollPos(hwnd, SB_HORZ) > iRangeH)
       InvalidateRect (hwnd, NULL, TRUE);
     SetScrollRange(hwnd, SB_VERT, 0, iRangeV, TRUE);
     SetScrollRange(hwnd, SB_HORZ, 0, iRangeH, TRUE);
     GetClientRect(hwnd, &rc);
   }
   iSem--;
 }
}

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 void GetRealClientRect(HWND hwnd, PRECT lprc){
 /* take account of scollbars as well */
 DWORD dwStyle;
 dwStyle = GetWindowLong (hwnd, GWL_STYLE);
 GetClientRect (hwnd,lprc);
 if (dwStyle & WS_HSCROLL)lprc->bottom += GetSystemMetrics(SM_CYHSCROLL);
 if (dwStyle & WS_VSCROLL)lprc->right  += GetSystemMetrics(SM_CXVSCROLL);
}

static void AppPaint(HWND hWnd,HDC hDC,int x,int y){
 HPALETTE hpalT;
 POINT Origin;
 HDC hDCbits;
 BITMAP bm;
 SetWindowOrgEx(hDC,x,y,&Origin);
 SetBkMode (hDC,TRANSPARENT);
 if(hpalCurrent != NULL){
   hpalT = SelectPalette(hDC,hpalCurrent,FALSE);
   RealizePalette (hDC);
   if(hbmCurrent != NULL){ /* compatible bit map exists; its quicker, use it */
     hDCbits = CreateCompatibleDC(hDC);
     GetObject(hbmCurrent,sizeof(BITMAP),(LPSTR)&bm);
     SelectObject(hDCbits,hbmCurrent);
     BitBlt(hDC,0,0,bm.bmWidth,bm.bmHeight,hDCbits,0,0,SRCCOPY);
     DeleteDC(hDCbits);
   }
   else {
     if(lpBitmapHeader != NULL && lpBitmapBits != NULL){
       SetDIBitsToDevice(hDC,
                       0,0,
                       (WORD)((LPBITMAPINFOHEADER)lpBitmapHeader)->biWidth,
                       (WORD)((LPBITMAPINFOHEADER)lpBitmapHeader)->biHeight,
                       0,0,
                       0,
                       (WORD)((LPBITMAPINFOHEADER)lpBitmapHeader)->biHeight,
                       lpBitmapBits,
                       (LPBITMAPINFO)lpBitmapHeader,
                       DIB_RGB_COLORS);
     }
   }
   SelectPalette(hDC,hpalT,FALSE);
 }
}

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 = GetDC(NULL);
 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(hpalCurrent)SelectPalette(hdc,hpalT,FALSE);
 ReleaseDC(NULL,hdc);
 return hbm;
}

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

static int dibview(HWND hWnd){
 char temp[256];
 HDC hdc;
 HANDLE hfbm;
 BITMAPFILEHEADER bmfh;
 DWORD dwRead;
 BITMAPINFOHEADER bmih;
 LPBITMAPINFOHEADER lpbi;
 LPBITMAPINFO lpinfo;
 long imagesize,nc;
 FreeDib();
 strcpy(temp,CurrentFile);
 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=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);
 if(!CloseHandle(hfbm)){
   MessageBeep(MB_OK);
   MessageBox(NULL,"Bad close",NULL,MB_OK);
 }
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)LoadErrMsg(IDX_ERR_NOBITMAP);
 SizeWindow(hWnd);
 return 1;
}

#include "view_gif.c"
#include "view_tga.c"
#include "view_tif.c"
#include "view_jpg.c"
#include "view_png.c"
//#include "..\render2\flc.h"
//#include "view_cel.c"

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine, int nCmdShow){
 HWND hWndPrev;
 hWndPrev = FindWindow(szViewClass,NULL);
 if (hWndPrev != NULL){
   SetForegroundWindow(hWndPrev);
   BringWindowToTop(hWndPrev);
   ShowWindow (hWndPrev,SW_SHOW);
   return 32;
 }
 if(hPrevInstance != NULL)return FALSE;
 // Get the INI file to use
 // Get the INI file to use and working folder for temporary files
 {
  FILE *fini=NULL; int ix;
  char TempPath[256];
  GetModuleFileName(hInstance,IniFilename,256);
  *FileInPath(IniFilename) = '\0';
  strcpy(TempPath,IniFilename);
  strcat(IniFilename,"OPENFX_.CFG");
  if((fini=fopen(IniFilename,"r")) != NULL){
    fscanf(fini,"%ld",&ix);
    strcpy(TempPath,"X");
    fscanf(fini," %[^\n]",TempPath);
    if(ix > 1){
      fscanf(fini," %[^\n]",IniFilename);
    }
    else  *FileInPath(IniFilename) = '\0';
    fclose(fini);
  }
  else {
    char *pE;
    pE=R_GetEnv("TEMP");
    if(pE != NULL){
      strcpy(TempPath,pE); strcat(TempPath,"\\");
      strcpy(IniFilename,TempPath);
      *FileInPath(TempPath) = '\0';
    }
    *FileInPath(IniFilename) = '\0';
  }
  strcat(IniFilename,"OPENFX_.INI");
 }
 // 
 return Viewer(hInstance);
}