TRACE.C

Go to the documentation of this file.

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

/*  TRACE.C  DLL to trace round image file by hand */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <setjmp.h>
#include <windows.h>
#include <commctrl.h>

#include "struct.h"
#include "callback.h"
#include "dstruct.h"

#include "trace.h"

typedef struct tagMENUHELPDATA{
  int iCode;
  char *str;
} MENUHELPDATA;

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

#define DESELECTED 0
#define SELECTED   1

#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

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;

static HWND      hParent,hInfo;
static HINSTANCE hThisInstance;
static HPALETTE  hpalCurrent    = NULL;         /* Handle to current palette            */
static HBITMAP   hbmCurrent     = NULL;         /* Handle to current memory BITMAP      */
static RGBQUAD   *pRgb          = NULL;
static LPSTR     lpBitmapHeader = NULL;
static 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:TraceClass";
static char ghFilename[255];
static SYSTEM_INFO sys_info;
static int DisplayWidth,DisplayHeight,DisplayBits,DisplayPlanes,
           xScreen,yScreen,rowcount,rowinc,x4_size,file_format=FI_GIF;
static LPSTR pixels;
static POINT ptSize;
static DWORD fdwStyle = WS_POPUP | WS_CAPTION | ! WS_SYSMENU |
                        WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME;
static HCURSOR hcurSave;

static int pen=0,stretched=1,tracetool=0;
static long Lv= -1,Fv= -1,Nv=0,Ne=0;
static struct TVLIST {BOOL inc; int x,y; long id;}  *TVlist=NULL;
static struct TELIST {BOOL inc; int v1,v2;}         *TElist=NULL;
#define NMENUHELPDATA 12
static MENUHELPDATA MenuHelpData[NMENUHELPDATA]={
  0xFFFF,             "   ",
  IDM_PEN_RED,        "Draw vertices  and edges with RED pen",
  IDM_PEN_WHITE,      "Draw vertices  and edges with WHITE pen",
  IDM_PEN_BLACK,      "Draw vertices  and edges with BLACK pen",
  IDM_PEN_CYAN,       "Draw vertices  and edges with CYAN pen",
  IDM_ADD,            "Click to add vertex, click RIGHT button to end sequence",
  IDM_MOVE,           "Click on vertex to pick it up, drag to new position, click to put it down",
  IDM_DELETE,         "Click on vertex to delete it",
  IDM_INSERT,         "Click on vertex to break in two edges attached to vertex",
  IDM_EXIT,           "Finish and make the draw edges and vertices",
  IDM_ABORT,          "Cancel the function and to NOT make the edges and vertices",
  IDM_STRETCH,        "Stretch the image to fill the window or draw it actual size"
};

static int identify_file_format(void);
static int ErrMsg(char *sz,...);
static void PutMsg(char *s);
static LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam);
static BOOL MenuCommand(HWND hWnd, WORD id);
static int identify_file_format(void);
static void FreeDib(void);
static void SizeWindow(HWND hWnd);
static HPALETTE CreateImagePalette(LPBITMAPINFOHEADER lpbi);
static WORD NumColours(LPBITMAPINFOHEADER lpbi);
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,char *filename);
static BOOL Viewer(void);
static void DrawRubberLine(HWND hwnd, int x, int y);
static void DrawRubberLines(HWND hwnd, int x, int y);
static void DrawList(HWND hwnd, HDC hDC);
static void AddTraceVertex(int x,int y);
static int GetVertexAtCursor(int x, int y);
static void MoveVertex(HWND hWnd, int x, int y);
static void TraceSubdivide(long v);
static void BuildFromTrace(HWND hWnd);

static BOOL Viewer(void){
 MSG msg;
 HWND hDesktopWnd,hWnd;
 HDC hDCcaps;
 WNDCLASS wndclass;
 TVlist=NULL; TElist=NULL; Nv=0; Ne=0;
 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     = hThisInstance ;
 wndclass.hIcon         = NULL;
 wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW) ;
 wndclass.hbrBackground = GetStockObject (WHITE_BRUSH) ;
 wndclass.lpszMenuName  = "tracemenu" ;
 wndclass.lpszClassName = szViewClass;
 if (!RegisterClass (&wndclass))  return FALSE ;
 xScreen = GetSystemMetrics (SM_CXSCREEN) ;
 yScreen = GetSystemMetrics (SM_CYSCREEN) ;
 hWnd = CreateWindow(
        szViewClass,
        "Image Trace Utility",
        fdwStyle,
        25,
        25,
        xScreen-50,
        yScreen-50,
        hParent,
        NULL,
        hThisInstance,
        NULL) ;
 if(hWnd == NULL)return FALSE;
 ShowWindow (hWnd,SW_SHOWNA);
 PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_DRAWIT,0);
 while(GetMessage (&msg,NULL,0,0)){
   TranslateMessage (&msg);
   DispatchMessage (&msg);
 }
 DestroyWindow(hWnd);
 UnregisterClass(wndclass.lpszClassName,wndclass.hInstance);
 if(TVlist != NULL)X__Free(TVlist); TVlist=NULL; Nv=0;
 if(TElist != NULL)X__Free(TElist); TElist=NULL; Ne=0;
 return TRUE;
}

LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,
                             LPARAM lParam){
 static BOOL bToolCaptured=FALSE;
 static HCURSOR hCursorSave;
 static POINT LastPt;
 PAINTSTRUCT ps;
 HDC hDC;
 int i;
 RECT rc;
 POINT pt;
 switch (iMessage) {
   case WM_DESTROY:
    FreeDib();
    break;
  case WM_COMMAND:
    return MenuCommand(hWnd,LOWORD(wParam));
    break;
  case WM_MENUSELECT: {
      HMENU hmenu;
      UINT fuFlags,uItem,id;
      hmenu=(HMENU)lParam;
      fuFlags=(UINT)HIWORD(wParam);
      uItem=(UINT)LOWORD(wParam);
      id=0;
      if(fuFlags == 0xFFFF)id=0;
      else if(fuFlags & MF_POPUP){;}
      else{
        for(i=0;i<NMENUHELPDATA;i++){
          if(uItem == MenuHelpData[i].iCode){id=(UINT)i; break;}
        }
      }
      SendMessage(hInfo,SB_SETTEXT,(WPARAM)0,(LPARAM)MenuHelpData[id].str);
    }
    break;
  case WM_RBUTTONUP:
    if(!bToolCaptured)break;
    if(tracetool == 1)DrawRubberLine(hWnd,LOWORD(lParam),HIWORD(lParam));
    if(tracetool == 2){
      DrawRubberLines(hWnd,LOWORD(lParam),HIWORD(lParam));
      MoveVertex(hWnd,LOWORD(lParam),HIWORD(lParam));
    }
    SetCursor(hCursorSave);
    ClipCursor(NULL);
    ReleaseCapture();
    bToolCaptured=FALSE;
    Lv= -1;
    break;
  case WM_LBUTTONDOWN:
    if(tracetool == 0 || bToolCaptured)break;
    else if(tracetool == 2){
      if((Fv=GetVertexAtCursor(LOWORD(lParam),HIWORD(lParam))) < 0)break;
    }
    else if(tracetool == 3){ /* delete */
      if((Fv=GetVertexAtCursor(LOWORD(lParam),HIWORD(lParam))) >= 0){
        if(Ne > 0 && TElist != NULL)for(i=0;i<Ne;i++){
          if(TElist[i].v1 == Fv || TElist[i].v2 == Fv)TElist[i].inc=FALSE;
        }
        TVlist[Fv].inc=FALSE;
        InvalidateRect(hWnd,NULL,FALSE);
        Fv= -1;
      }
      break;
    }
    else if(tracetool == 4){ /* subdivide */
      if((Fv=GetVertexAtCursor(LOWORD(lParam),HIWORD(lParam))) >= 0){
        TraceSubdivide(Fv);
        InvalidateRect(hWnd,NULL,FALSE);
        Fv= -1;
      }
      break;
    }
    bToolCaptured=TRUE;
    SetCapture(hWnd);
    hCursorSave=SetCursor(LoadCursor(NULL,IDC_SIZE));
    GetClientRect(hWnd,&rc);
    pt.x=rc.left; pt.y=rc.top;
    ClientToScreen(hWnd,&pt);
    rc.left=pt.x; rc.top=pt.y;
    pt.x=rc.right; pt.y=rc.bottom;
    ClientToScreen(hWnd,&pt);
    rc.right=pt.x; rc.bottom=pt.y;
    ClipCursor(&rc);
    break;
  case WM_MOUSEMOVE:
    if(!bToolCaptured)break;
    if(tracetool == 1){
      DrawRubberLine(hWnd,(int)LastPt.x,(int)LastPt.y);
      LastPt.x=LOWORD(lParam); LastPt.y=HIWORD(lParam);
      DrawRubberLine(hWnd,(int)LastPt.x,(int)LastPt.y);
    }
    if(tracetool == 2){
      DrawRubberLines(hWnd,(int)LastPt.x,(int)LastPt.y);
      LastPt.x=LOWORD(lParam); LastPt.y=HIWORD(lParam);
      DrawRubberLines(hWnd,(int)LastPt.x,(int)LastPt.y);
    }
    break;
  case WM_LBUTTONUP:
    if(!bToolCaptured)break;
    if(tracetool == 1){ /* add */
      LastPt.x=LOWORD(lParam); LastPt.y=HIWORD(lParam);
      if(Lv >= 0)DrawRubberLine(hWnd,(int)LastPt.x,(int)LastPt.y);
      AddTraceVertex((int)LOWORD(lParam),(int)HIWORD(lParam));
      DrawList(hWnd,NULL);
      DrawRubberLine(hWnd,(int)LastPt.x,(int)LastPt.y);
    }
    else if(tracetool == 2){ /* move */
      if(Lv < 0){
        Lv=Fv; Fv=-1;
        LastPt.x=LOWORD(lParam); LastPt.y=HIWORD(lParam);
        DrawRubberLines(hWnd,(int)LastPt.x,(int)LastPt.y);
      }
      else{
        DrawRubberLines(hWnd,LOWORD(lParam),HIWORD(lParam));
        MoveVertex(hWnd,LOWORD(lParam),HIWORD(lParam));
        SetCursor(hCursorSave);
        ClipCursor(NULL);
        ReleaseCapture();
        bToolCaptured=FALSE;
        Lv= -1;
      }
    }
    break;
  case WM_PAINT:
    hDC = BeginPaint(hWnd, &ps);
    AppPaint(hWnd,hDC,0,0);
    DrawList(hWnd,hDC);
    EndPaint(hWnd,&ps);
    break ;
  case WM_SIZE:
    InvalidateRect(hWnd,NULL,FALSE);
    return 0;
  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),FALSE);
      SelectPalette(hDC,hpalT,FALSE);
      ReleaseDC(hWnd,hDC);
      return TRUE;
    }
  case WM_PALETTECHANGED:
    if ((HWND)wParam != hWnd ){
      HDC hDC;
      HPALETTE hpalT;
      if(hpalCurrent == NULL)break;
      hDC=GetDC(hWnd);
      hpalT = SelectPalette(hDC,hpalCurrent,FALSE);
      if(RealizePalette (hDC) > 0)InvalidateRect (hWnd, (LPRECT) (NULL),FALSE);
      SelectPalette(hDC,hpalT,FALSE);
      ReleaseDC(hWnd,hDC);
    }
    break;
  default:
      return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
 }
 return 0L ;
}

BOOL MenuCommand (HWND hWnd, WORD id){
 int i;
 char lpMessage[MAXTEXT],lpCaption[64];
 switch (id) {
   case IDM_DRAWIT:
     StartWait();
     file_format=identify_file_format();
     switch(file_format){
       case FI_GIF:
         if(gifview(hWnd,ghFilename))InvalidateRect (hWnd, NULL, FALSE);
         else PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_ABORT,0);
         break;
       case FI_TGA:
         if(tgaview(hWnd,ghFilename))InvalidateRect (hWnd, NULL, FALSE);
         else PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_ABORT,0);
         break;
       //case FI_CEL:
       //  if(celview(hWnd,ghFilename))InvalidateRect (hWnd, NULL, FALSE);
       //  else PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_ABORT,0);
       //  break;
       default:
       case FI_DIB:
         if(bmpview(hWnd,ghFilename))InvalidateRect (hWnd, NULL, FALSE);
         else PostMessage(hWnd,WM_COMMAND,(WPARAM)IDM_ABORT,0);
         break;
         break;
     }
     EndWait();
     break;
   case IDM_PEN_RED  : pen=0; goto PENID;
   case IDM_PEN_WHITE: pen=1; goto PENID;
   case IDM_PEN_BLACK: pen=2; goto PENID;
   case IDM_PEN_CYAN : pen=3; goto PENID;
     PENID:
     CheckMenuItem(GetMenu(hWnd),IDM_PEN_RED,MF_UNCHECKED);
     CheckMenuItem(GetMenu(hWnd),IDM_PEN_WHITE,MF_UNCHECKED);
     CheckMenuItem(GetMenu(hWnd),IDM_PEN_BLACK,MF_UNCHECKED);
     CheckMenuItem(GetMenu(hWnd),IDM_PEN_CYAN,MF_UNCHECKED);
     if(pen == 0)CheckMenuItem(GetMenu(hWnd),IDM_PEN_RED,MF_CHECKED);
     if(pen == 1)CheckMenuItem(GetMenu(hWnd),IDM_PEN_WHITE,MF_CHECKED);
     if(pen == 2)CheckMenuItem(GetMenu(hWnd),IDM_PEN_BLACK,MF_CHECKED);
     if(pen == 3)CheckMenuItem(GetMenu(hWnd),IDM_PEN_CYAN,MF_CHECKED);
     DrawList(hWnd,NULL);
     break;
   case IDM_STRETCH:
     stretched ^= 1;
     if(stretched)ModifyMenu(GetMenu(hWnd),IDM_STRETCH,MF_BYCOMMAND|MF_STRING,
                IDM_STRETCH,"&Actual Size");
     else ModifyMenu(GetMenu(hWnd),IDM_STRETCH,MF_BYCOMMAND|MF_STRING,
                IDM_STRETCH,"&Stretch to fit");
     InvalidateRect (hWnd, (LPRECT) (NULL), FALSE);
     break;
   case IDM_ADD:
     Lv= -1;
     EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_GRAYED);
     EnableMenuItem(GetMenu(hWnd),IDM_MOVE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_DELETE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_INSERT,MF_ENABLED);
     DrawMenuBar(hWnd);
     tracetool=1;
     break;
   case IDM_MOVE:
     Lv= -1;
     EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_MOVE,MF_GRAYED);
     EnableMenuItem(GetMenu(hWnd),IDM_DELETE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_INSERT,MF_ENABLED);
     DrawMenuBar(hWnd);
     tracetool=2;
     break;
   case IDM_DELETE:
     Lv= -1;
     EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_MOVE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_DELETE,MF_GRAYED);
     EnableMenuItem(GetMenu(hWnd),IDM_INSERT,MF_ENABLED);
     DrawMenuBar(hWnd);
     tracetool=3;
     break;
   case IDM_INSERT:
     Lv= -1;
     EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_MOVE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_DELETE,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_INSERT,MF_GRAYED);
     DrawMenuBar(hWnd);
     tracetool=4;
     break;
   case IDM_EXIT:
     BuildFromTrace(hWnd);
   case IDM_ABORT:
     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(ghFilename);
 if     (strstr(ghFilename,".GIF"))ff=FI_GIF;
 //else if(strstr(ghFilename,".CEL"))ff=FI_CEL;
 else if(strstr(ghFilename,".TGA"))ff=FI_TGA;
 else if(strstr(ghFilename,".DIB") ||
         strstr(ghFilename,".BMP") ||
         strstr(ghFilename,".RLE"))ff=FI_DIB;
 return ff;
}

static int ErrMsg(char *sz,...){
 char ach[128];
 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, "Trace", MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
}

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",
          ghFilename,
          (long)x_size,  //(long)bi->biWidth,
          (long)bi->biHeight,
          (long)bi->biBitCount);
 SetWindowText(hWnd,Title);
 InvalidateRect(hWnd,NULL,FALSE);
}

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 gifview(HWND hWnd,char *temp){
 int i;
 long imagesize;
 LPBITMAPINFOHEADER lpbi;
 FreeDib();
 rowcount=0;
 rowinc=1;
 if(read_gif_image(temp,1) < 0){
   ErrMsg("'%ls' is NOT a valid GIF file", (LPSTR)temp);
   return 0;
 }
 if(gif_iLace)rowinc = -8;
 x4_size = ALIGNULONG(x_size);
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER)
                                +256L*sizeof(RGBQUAD));
 if(lpBitmapHeader == NULL){
   ErrMsg("Out of memory");
   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){
   ErrMsg("Out of memory");
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 pixels=lpBitmapBits;
 if(read_gif_image(temp,0) < 0){
   PutMsg("Error reading GIF file");
   FreeDib();
   return 0;
 }
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)ErrMsg("Could not create bitmap");
 SizeWindow(hWnd);
 return 1;
}

static int bmpview(HWND hWnd,char *temp){
 int i,nc,bits;
 long imagesize;
 LPBITMAPINFOHEADER lpbi;
 BITMAPFILEHEADER bmfh;
 FILE *t24;
 FreeDib();
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER)
                                +256L*sizeof(RGBQUAD));
 if(lpBitmapHeader == NULL){
   ErrMsg("Out of memory");
   return 0;
 }
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 pRgb=(RGBQUAD *)((LPSTR)lpbi + lpbi->biSize);
 t24=fopen((char *)temp,"rb");
 if(t24 == NULL)return 0;
 fread((char *)&bmfh,sizeof(BITMAPFILEHEADER),1,t24);
 fread((char *)lpbi,sizeof(BITMAPINFOHEADER),1,t24);
 if(lpbi->biClrUsed != 0)nc=lpbi->biClrUsed;
 else{
   bits = lpbi->biBitCount;
   switch (bits){
     case 1:    nc=2;   break;
     case 4:    nc=16;  break;
     case 8:    nc=256; break;
     default:   nc=0;   break;
   }
 }
 x_size=lpbi->biWidth; 
 y_size=lpbi->biHeight;
 x4_size = ALIGNULONG(x_size);
 imagesize=bmfh.bfSize-bmfh.bfOffBits;
//{char ttt[256]; sprintf(ttt,"x=%ld y=%ld nc=%ld  imagesize=%ld",x_size,y_size,nc,imagesize);
//MessageBox(NULL,ttt,"Image",MB_OK);}
 if(nc > 0)fread((char *)pRgb,nc*sizeof(RGBQUAD),1,t24);
 if((lpBitmapBits=(unsigned char *)X__Malloc(imagesize)) == NULL){
   fclose(t24);
   FreeDib();
   return 0;
 }
 memset(lpBitmapBits,0,imagesize);
 fread((char *)lpBitmapBits,imagesize,1,t24);
 fclose(t24);
 hpalCurrent=CreateImagePalette(lpbi);
 hbmCurrent=BitmapFromDib(lpBitmapHeader,lpBitmapBits,hpalCurrent);
 if(hbmCurrent == NULL)ErrMsg("Could not create bitmap");
 SizeWindow(hWnd);
 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 void AppPaint(HWND hWnd,HDC hDC,int x,int y){
 RECT rc;
 HPALETTE hpalT;
 POINT Origin;
 HDC hDCbits;
 BITMAP bm;
 GetClientRect(hWnd,&rc);
 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);
     if(stretched && (GetDeviceCaps(hDC,RASTERCAPS) & RC_STRETCHBLT) ==  RC_STRETCHBLT)
       StretchBlt(hDC,0,0,rc.right,rc.bottom,hDCbits,0,0,
                    bm.bmWidth,bm.bmHeight,SRCCOPY);
     else{
        PatBlt(hDC,0,0,rc.right,rc.bottom,PATCOPY);
        BitBlt(hDC,0,0,bm.bmWidth,bm.bmHeight,hDCbits,0,0,SRCCOPY);
     }
     DeleteDC(hDCbits);
   }
   else {
     if(lpBitmapHeader != NULL && lpBitmapBits != NULL){
       StretchDIBits(hDC,
                       0,0,
                       rc.right,
                       rc.top,
                       0,0,
                       (WORD)((LPBITMAPINFOHEADER)lpBitmapHeader)->biWidth,
                       (WORD)((LPBITMAPINFOHEADER)lpBitmapHeader)->biHeight,
                       lpBitmapBits,
                       (LPBITMAPINFO)lpBitmapHeader,
                       DIB_RGB_COLORS,
                       SRCCOPY);
     }
   }
   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;
}


static void DrawRubberLine(HWND hwnd, int x, int y){
 HPEN hOldPen,MyPen;
 int oldROP;
 HDC hDClocal;
 if(Lv < 0)return;
 hDClocal=GetDC(hwnd);
 if(pen == 0)MyPen=CreatePen(PS_SOLID,0,RGB(255,0,0));
 if(pen == 1)MyPen=CreatePen(PS_SOLID,0,RGB(255,255,255));
 if(pen == 2)MyPen=CreatePen(PS_SOLID,0,RGB(0,0,0));
 if(pen == 3)MyPen=CreatePen(PS_SOLID,0,RGB(0,255,255));
 hOldPen=SelectObject(hDClocal,MyPen);
 oldROP=SetROP2(hDClocal,R2_NOT);
 MoveToEx(hDClocal,x,y,NULL);
 LineTo(hDClocal,TVlist[Lv].x,TVlist[Lv].y);
 SetROP2(hDClocal,oldROP);
 SelectObject(hDClocal,hOldPen);
 DeleteObject(MyPen);
 ReleaseDC(hwnd,hDClocal);
}

static void DrawRubberLines(HWND hwnd, int x, int y){
 int i,v1,v2;
 HPEN hOldPen;
 int oldROP;
 HDC hDClocal;
 if(Lv < 0 || Ne == 0)return;
 hDClocal=GetDC(hwnd);
 hOldPen=SelectObject(hDClocal,GetStockObject(WHITE_PEN));
 oldROP=SetROP2(hDClocal,R2_NOT);
 for(i=0;i<Ne;i++){
   if(!TElist[i].inc)continue;
   v1=TElist[i].v1; v2=TElist[i].v2;
   if(TVlist[v1].inc && v1 == Lv){
     MoveToEx(hDClocal,x,y,NULL);
     LineTo(hDClocal,TVlist[v2].x,TVlist[v2].y);
   }
   else if(TVlist[v2].inc && v2 == Lv){
     MoveToEx(hDClocal,x,y,NULL);
     LineTo(hDClocal,TVlist[v1].x,TVlist[v1].y);
   }
 }
 SetROP2(hDClocal,oldROP);
 SelectObject(hDClocal,hOldPen);
 ReleaseDC(hwnd,hDClocal);
}

static void DrawList(HWND hwnd, HDC hDC){
 int i,x,y;
 HPEN hOldPen,MyPen;
 HBRUSH hOldBrush;
 HDC hDClocal;
 if(hDC == NULL){
   hDClocal=GetDC(hwnd);
 }
 else hDClocal=hDC;
 if(pen == 0)MyPen=CreatePen(PS_SOLID,0,RGB(255,0,0));
 if(pen == 1)MyPen=CreatePen(PS_SOLID,0,RGB(255,255,255));
 if(pen == 2)MyPen=CreatePen(PS_SOLID,0,RGB(0,0,0));
 if(pen == 3)MyPen=CreatePen(PS_SOLID,0,RGB(0,255,255));
 hOldPen=SelectObject(hDClocal,MyPen);
 hOldBrush=SelectObject(hDClocal,GetStockObject(BLACK_BRUSH));
 if(Ne > 0 && TElist != NULL){
   for(i=0;i<Ne;i++){
     if(!TElist[i].inc)continue;
     x=TVlist[TElist[i].v1].x; y=TVlist[TElist[i].v1].y;
     MoveToEx(hDClocal,x,y,NULL);
     x=TVlist[TElist[i].v2].x; y=TVlist[TElist[i].v2].y;
     LineTo(hDClocal,x,y);
   }
 }
 if(Nv > 0 && TVlist != NULL){
   for(i=0;i<Nv;i++)if(TVlist[i].inc)Rectangle(hDClocal,
      TVlist[i].x-2,TVlist[i].y-2,TVlist[i].x+2,TVlist[i].y+2);
 }
 SelectObject(hDClocal,hOldPen);
 SelectObject(hDClocal,hOldBrush);
 DeleteObject(MyPen);
 if(hDC == NULL){
   ReleaseDC(hwnd,hDClocal);
 }
}

static void AddTraceVertex(int x,int y){
 int i,id,found=0,flag=0;
 struct TVLIST *v;
 struct TELIST *e;
 if(Nv > 0){
   for(i=0;i<Nv;i++){
     if(TVlist[i].inc && abs(x-TVlist[i].x) < 4 && abs(y-TVlist[i].y) < 4){
       found=1;
       if(Lv >= 0)flag=1;
       id=i;
     }
   }
 }
 if(!found){
   if(TVlist == NULL){
     if((v=(struct TVLIST *)X__Malloc(sizeof(struct TVLIST))) == NULL)return;
   }
   else{
     if((v=(struct TVLIST *)X__Realloc(TVlist,(Nv+1)*sizeof(struct TVLIST))) == NULL)return;
   }
   TVlist=v;
   v[Nv].x=x; v[Nv].y=y; v[Nv].inc=TRUE;
   id=Nv;
   Nv++;
 }
 if(Lv < 0){
   Lv=id;
 }
 else{
   if(TElist == NULL){
     if((e=(struct TELIST *)X__Malloc(sizeof(struct TELIST))) == NULL)return;
   }
   else{
     if((e=(struct TELIST *)X__Realloc(TElist,(Ne+1)*sizeof(struct TELIST))) == NULL)return;
   }
   TElist=e;
   e[Ne].v1=id; e[Ne].v2=Lv; e[Ne].inc=TRUE;
   Lv=id;
   Ne++;
 }
 if(flag)Lv= -1;
}

static void MoveVertex(HWND hWnd,int x, int y){
 if(Lv < 0)return;
 TVlist[Lv].x=x; TVlist[Lv].y=y;
 InvalidateRect(hWnd,NULL,FALSE);
 return;
}

int GetVertexAtCursor(int x, int y){
 int i,id= -1;
 if(Nv > 0)for(i=0;i<Nv;i++){
   if(TVlist[i].inc && abs(x-TVlist[i].x) < 4 && abs(y-TVlist[i].y) < 4)id=i;
 }
 return id;
}

static void TraceSubdivide(long vv){
 struct TVLIST *v;
 struct TELIST *e;
 int ne1,i,x,y;
 if(Nv == 0 || Ne == 0 || TVlist == NULL || TElist == NULL)return;
 ne1=Ne; for(i=0;i<ne1;i++){
   if(!TElist[i].inc)continue;
   x=(TVlist[TElist[i].v1].x+TVlist[TElist[i].v2].x)/2;
   y=(TVlist[TElist[i].v1].y+TVlist[TElist[i].v2].y)/2;
   if(TElist[i].v1 == vv){
     if((v=(struct TVLIST *)X__Realloc(TVlist,(Nv+1)*sizeof(struct TVLIST))) == NULL)return;
     TVlist=v; v[Nv].x=x; v[Nv].y=y; v[Nv].inc=TRUE;
     TElist[i].v1=Nv;
     if((e=(struct TELIST *)X__Realloc(TElist,(Ne+1)*sizeof(struct TELIST))) == NULL)return;
     TElist=e; e[Ne].v1=Nv; e[Ne].v2=vv; e[Ne].inc=TRUE;
     Ne++;
     Nv++;
   }
   else if(TElist[i].v2 == vv){
     if((v=(struct TVLIST *)X__Realloc(TVlist,(Nv+1)*sizeof(struct TVLIST))) == NULL)return;
     TVlist=v; v[Nv].x=x; v[Nv].y=y; v[Nv].inc=TRUE;
     TElist[i].v2=Nv;
     if((e=(struct TELIST *)X__Realloc(TElist,(Ne+1)*sizeof(struct TELIST))) == NULL)return;
     TElist=e; e[Ne].v1=Nv; e[Ne].v2=vv; e[Ne].inc=TRUE;
     Ne++;
     Nv++;
   }
 }
}

static void BuildFromTrace(HWND hWnd){
 RECT rc;
 long Scale,v1,v2;
 int i,vc=0,ec=0;
 GetClientRect(hWnd,&rc);
 if(Nv == 0 || TVlist == NULL)return;
 Scale=100;
 for(i=0;i<Nv;i++){
   if(TVlist[i].inc)vc++;
   TVlist[i].id = -1;
 }
 if(vc == 0)return;
 UpdateVertexHeap(Nvert+vc);
 for(i=0;i<Nv;i++){
   if(!TVlist[i].inc)continue;
   CreateVertex();
   (MainVp+Nvert-1)->xyz[0]=TVlist[i].x*Scale;
   (MainVp+Nvert-1)->xyz[1]=NpointerY;
   (MainVp+Nvert-1)->xyz[2]=(rc.bottom-TVlist[i].y)*Scale;
   TVlist[i].id=Nvert-1; /* use to point to actual vertex */
 }
 if(Ne == 0)return;
 for(i=0;i<Ne;i++)if(TVlist[i].inc)ec++;
 if(ec == 0)return;
 UpdateEdgeHeap(Nedge+vc);
 for(i=0;i<Ne;i++){
   if(!TElist[i].inc)continue;
   v1=TVlist[TElist[i].v1].id; v2=TVlist[TElist[i].v2].id;
   if(v1 >= 0 && v2 >= 0)CreateEdge(v1,v2);
 }
}

//#include "..\render2\flc.h"

#include "trace1.c"

#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(),"Trace attaching","Debug",MB_OK);
#endif
      hThisInstance=hDLL;
      break;
    }
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
//      MessageBox (GetFocus(),"Trace detaching","Debug",MB_OK);
#endif
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

BOOL _TraceOutline(
 HWND parent_window, HWND info_window,
 char *filename,X__STRUCTURE *lpX__in){
 tracetool=0;
 hParent=parent_window;
 hInfo=info_window;
 lpEVI=lpX__in;
#include "keyfile.c"
 strcpy(ghFilename,filename);
 return Viewer();
}