DRAFT.C

Go to the documentation of this file.

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

/*  DRAFT.C  2D drawing module with Bezier Curves */

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

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

#include "draft.h"

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


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

#define PAGESIZE  2048
#define BOUND(x,min,max) ((x) < (min) ? (min) : ((x) > (max) ? (max) : (x)))

static BOOL      bSpaceDown=FALSE,bCtrlDown=FALSE;
static HWND      hParent,hInfo;
static HINSTANCE hThisInstance;
static char *szViewClass="OFX:BezierClass";
static char gszDir[256],gszFile[256];
static SYSTEM_INFO sys_info;
static int DisplayWidth,DisplayHeight,DisplayBits,DisplayPlanes,
           xScreen,yScreen,WoffX=0,WoffY=0,PanX,PanY;
static char Title[]="Bezier Curve Drawing";
static DWORD fdwStyle = WS_POPUP | WS_CAPTION | ! WS_SYSMENU |
                        WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME |
                        WS_VSCROLL | WS_HSCROLL;
//static DWORD fdwStyle = WS_POPUP | WS_CAPTION | ! WS_SYSMENU |
//                        WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_THICKFRAME |
//                        WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN;
static HCURSOR hcurArrow=NULL,hcurPen1=NULL,hcurPen2=NULL,
                hcurNear=NULL,hcurPen3=NULL,hcurPen4=NULL,
                hcurPenA=NULL,hcurPenB=NULL,hcurHand=NULL;

#define NMENUHELPDATA 14
static MENUHELPDATA MenuHelpData[NMENUHELPDATA]={
  0xFFFF,        "   ",
  IDM_OPEN,      "Open a file containing a Bezier curve",
  IDM_SAVE,      "Save changes in the current Bezier curve file",
  IDM_SAVEAS,    "Save in a named Bezier curve file",
  IDM_ABORT,     "Finish working with a 2D Bezier curve and return to the Modeler",
  IDM_VERTEX,    "Where appropriate tools apply to individual vertices in a Bezier path",
  IDM_PATH,      "Where appropriate tools apply to whole paths",
  IDM_BUILD,     "Build curve in Modeler with vertices and edges following the Bezier curve",
  IDM_CLEAR,     "Delete everthing",
  IDM_MOVE,      "Move point, whole curve or set angle of curve",
  IDM_ADD,       "Draw curve, click to place point, click and drag handles to set curvature, click back on first point to close",
  IDM_BEND,      "Click on point to make corner, click and drag to set curvature, click and drag handle to make corner",
  IDM_DELETE,    "Delete vertex or whole curve",
  IDM_INSERT,    "Add point, click on vertex in path to insert vertex in front or on last vertex to add more vertices to path"
};


typedef struct tagPATHPOINT {
  int type,hand,bent;
  POINT p,p1,p2;  /* p1 points towards next point on curve */
  double r;
} PATHPOINT;

typedef struct tagPTH {
  struct tagPATHPOINT *pts;
  int n,closed;
} PTH;

static PTH *pathlist=NULL;

static int tracetool=1,pathtool=0,panneltool=2,lasttracetool=1,lastpathtool=0;
static int Np=0, Lp= -1,Lpp= -1,LastLp= -1, LastLpp=-1;


static LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,LPARAM lParam);
static PSTR FileInPath(PSTR);
static BOOL GetFilename(int, HWND, char *, char *);
static BOOL MenuCommand(HWND hWnd, WORD id);
static BOOL Bezier(void);
static void MoveWholePath(int x, int y, HWND hwnd);
static void DrawAll(HWND hwnd, HDC hDC);
static int IdentifyPathVertex(int x, int y, int p);
static BOOL GetVertexAtCursor(int x, int y, HWND hWnd,BOOL draw);
static int GetTurnID(int x, int y, HWND hWnd);
static void GetBezierPoint(double t, PATHPOINT *pl, PATHPOINT *p,
                           long *xp, long *yp);
static void BuildFromTrace(HWND hWnd);
static void DeleteAllPath(void);
static void DeleteOnePath(int id);
static void DeletePathVertex(void);
static int CreatePath(void);
static int CreatePathPoint(int pa,int x,int y);
static void GetXtraPoints(int, PATHPOINT *, PATHPOINT *, long *, long *);
static void InsertVertex(void);
static void ResetScreen(HWND);
static void DrawFromPathPoint(BOOL, int ,int, POINT *, HWND, HDC);
static void DrawPathPoint(int, int, HWND, HDC);
static void DrawBezierCurve(HDC hDC, PATHPOINT *p, PATHPOINT *pl);
static void BuildBezierCurve(PATHPOINT *p, PATHPOINT *pl,
                             long Scale, BOOL fv);
//static void AppendFileExtension(char *filename, char *ext);
static void WritePaths(void);
static void ReadPaths(void);
static void SetDraftCursor(BOOL bNearStart);

#include "draft0.c"
#include "draft1.c"

#if 0
static void AppendFileExtension(char *filename, char *ext){
 if(strrchr(filename,'.') == NULL){
   strcat(filename,ext);
 }
}
#endif


static void GetShiftedCoords(long *lplParam,int xws,int yws){
 int xw,yw,dx,dy,dxa,dya;
 xw=(int)((short)LOWORD(*lplParam))+WoffX;
 yw=(int)((short)HIWORD(*lplParam))+WoffY;
 dx=xw-xws; dy=yw-yws;  dxa=abs(dx); dya=abs(dy);
 if     (dya < dxa/2)yw=yws;
 else if(dxa < dya/2)xw=xws;
 else if(dya < dxa)yw=yws+(int)((double)dxa*(double)dy/(double)dya);
 else if(dxa < dya)xw=xws+(int)((double)dya*(double)dx/(double)dxa);
 xw -= WoffX; yw -= WoffY;
 *lplParam=MAKELONG((short)xw,(short)yw);
}

static BOOL Bezier(void){
 int i;
 MSG msg;
 HWND hDesktopWnd,hWnd;
 HDC hDCcaps;
 WNDCLASS wndclass;
 pathlist=NULL; Np=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,
        Title,
        fdwStyle,
        25,
        25,
        xScreen-50,
        yScreen-50,
        hParent,
        NULL,
        hThisInstance,
        NULL) ;
 if(hWnd == NULL)return FALSE;
 hcurArrow=LoadCursor(NULL, IDC_ARROW) ;
 hcurNear=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_NEAR));
 hcurPenA=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PENA));
 hcurPen1=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PEN1));
 hcurPen2=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PEN2));
 hcurPen3=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PEN3));
 hcurPenB=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PENB));
 hcurPen4=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_PEN4));
 hcurHand=LoadCursor(hThisInstance,MAKEINTRESOURCE(IDC_HAND));
 ShowWindow (hWnd,SW_SHOWNA);
 tracetool=1;
 OpenDraftToolbox(hWnd,hThisInstance);
 panneltool=2;
 SelectDraftTool(panneltool);
 EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_GRAYED);
 while(GetMessage (&msg,NULL,0,0)){
   TranslateMessage (&msg);
   DispatchMessage (&msg);
 }
 DestroyDraftToolbox();
 DestroyWindow(hWnd);
 DeleteAllPath();
 if(hcurNear != NULL)DeleteObject(hcurNear);
 if(hcurPen1 != NULL)DeleteObject(hcurPen1);
 if(hcurPenA != NULL)DeleteObject(hcurPenA);
 if(hcurPen2 != NULL)DeleteObject(hcurPen2);
 if(hcurPen3 != NULL)DeleteObject(hcurPen3);
 if(hcurPenB != NULL)DeleteObject(hcurPenB);
 if(hcurPen4 != NULL)DeleteObject(hcurPen4);
 if(hcurHand != NULL)DeleteObject(hcurHand);
 UnregisterClass(wndclass.lpszClassName,wndclass.hInstance);
 return TRUE;
}

static void SetDraftCursor(BOOL bNearStart){
 if(bSpaceDown)SetCursor(hcurHand);
 else if(bCtrlDown)SetCursor(hcurPenA);
 else if(bNearStart)SetCursor(hcurNear);
 else if(tracetool == 0 && !pathtool)SetCursor(hcurPenA);
 else if(tracetool == 1)SetCursor(hcurPen1);
 else if(tracetool == 2){
   if(pathtool)SetCursor(hcurPenB);
   else        SetCursor(hcurPen2);
 }
 else if(tracetool == 3)SetCursor(hcurPen3);
 else if(tracetool == 4)SetCursor(hcurPen4);
 else SetCursor(hcurArrow);
}

LRESULT CALLBACK MainWndProc(HWND hWnd,UINT iMessage,WPARAM wParam,
                             LPARAM lParam){
 static int  TurnID=0,lpX,lpY,lpwX,lpwY,bAddStart=FALSE;
 static BOOL bToolCaptured=FALSE,bMoveFlag=FALSE,bFoundFlag=FALSE,
             bNearStart=FALSE,bStartTrace=FALSE;
 static POINT LastPt;
 int i,iPos,iMax,iMin,dn;
 PAINTSTRUCT ps;
 HDC hDC;
 RECT rc;
 POINT pt;
 PATHPOINT *pp;
 switch (iMessage) {
  case WM_ACTIVATE:
    SendMessage(hWnd,WM_NCACTIVATE,(WPARAM)TRUE,0);
    break;
  case WM_ACTIVATEAPP:
    if(hwndDraftTools != NULL){
      if((BOOL)wParam == TRUE)ShowWindow(hwndDraftTools,SW_SHOW);
      else                    ShowWindow(hwndDraftTools,SW_HIDE);
    }
    break;
  case WM_SETCURSOR:
    if(LOWORD(lParam) != HTCLIENT)
      return DefWindowProc(hWnd,iMessage,wParam,lParam);
    SetDraftCursor(bNearStart);
    break;
   case WM_KEYDOWN:
   case WM_KEYUP:
   case WM_SETFOCUS:
     if(!bToolCaptured){
       BOOL bCtrl;
       if(GetKeyState(VK_SPACE) & 0x8000)bSpaceDown=TRUE; else bSpaceDown=FALSE;
       if(GetKeyState(VK_CONTROL) & 0x8000)bCtrl=TRUE; else bCtrl=FALSE;
       if(bCtrl != bCtrlDown){
         if(bCtrl){
           LastLp=Lp; LastLpp=Lpp; TurnID=0;
           lasttracetool=tracetool; lastpathtool=pathtool;
           Lp=-1; Lpp=-1; tracetool=0;
         }
         else{
           if(Lp >= 0 && Lpp >= 0)pathlist[Lp].pts[Lpp].hand=0;
           Lp=LastLp; Lpp=LastLpp; TurnID=0;
           tracetool=lasttracetool; pathtool=lastpathtool;
         }
         bMoveFlag=!bMoveFlag;
         bCtrlDown=bCtrl;
         InvalidateRect(hWnd,NULL,FALSE);
       }
     }
     SetDraftCursor(bNearStart);
     break;
   case WM_KILLFOCUS:
     bSpaceDown=FALSE;
     bCtrlDown=FALSE;
     SetDraftCursor(bNearStart);
     break;
  case WM_NCMOUSEMOVE:
    if(bMoveFlag){
      DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
      bMoveFlag=FALSE;
    }
    break;
  case WM_CREATE:
    SetScrollRange(hWnd, SB_VERT, 0, PAGESIZE, TRUE);
    SetScrollRange(hWnd, SB_HORZ, 0, PAGESIZE, TRUE);
    GetClientRect(hWnd,&rc);
    SetScrollPos(hWnd, SB_HORZ, (PAGESIZE-rc.right)/2, TRUE);
    SetScrollPos(hWnd, SB_VERT, (PAGESIZE-rc.bottom)/2, TRUE);
    WoffX=GetScrollPos(hWnd,SB_HORZ);
    WoffY=GetScrollPos(hWnd,SB_VERT);
    break;
  case WM_DESTROY:
    break;
  case WM_COMMAND:
    return MenuCommand(hWnd,LOWORD(wParam));
    break;
  case WM_RBUTTONDOWN:
    break;
  case WM_LBUTTONDOWN:
    if(bToolCaptured)break;
    if(bMoveFlag){
      DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
      bMoveFlag=FALSE;
    }
    if(bSpaceDown){
      PanX=(short)LOWORD(lParam); PanY=(short)HIWORD(lParam);
    }
    else if(tracetool == 0){ /* move */
      if(pathtool){
        bFoundFlag=GetVertexAtCursor(LOWORD(lParam)+WoffX,
                                     HIWORD(lParam)+WoffY,hWnd,FALSE);
      }
      else{
        bFoundFlag=GetVertexAtCursor(LOWORD(lParam)+WoffX,
                                     HIWORD(lParam)+WoffY,hWnd,TRUE);
        if(!bFoundFlag)TurnID=GetTurnID(LOWORD(lParam)+WoffX,
                                     HIWORD(lParam)+WoffY,hWnd);
      }
      if(bFoundFlag || TurnID > 0){
        lpwX=pathlist[Lp].pts[Lpp].p.x;
        lpwY=pathlist[Lp].pts[Lpp].p.y;
      }
    }
    else if(tracetool == 1){ /* add */
      if(Lp < 0){
        Lp=CreatePath();
        Lpp=CreatePathPoint(Lp,LOWORD(lParam)+WoffX,HIWORD(lParam)+WoffY);
      }
      else{
        if(bNearStart){
          Lpp=0;
          DrawPathPoint(Lp,Lpp,hWnd,NULL);
          pathlist[Lp].closed=1;
        }
        else{
          if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
          Lpp=CreatePathPoint(Lp,LOWORD(lParam)+WoffX,HIWORD(lParam)+WoffY);
        }
      }
      bAddStart=TRUE; lpX=(short)LOWORD(lParam); lpY=(short)HIWORD(lParam);
      lpwX=lpX+WoffX; lpwY=lpY+WoffY;
      DrawPathPoint(Lp,Lpp,hWnd,NULL);
    }
    else if(tracetool == 2){ /* delete */
      if(GetVertexAtCursor(LOWORD(lParam)+WoffX,HIWORD(lParam)+WoffY,hWnd,FALSE)){
        if(pathtool)DeleteOnePath(Lp);
        else DeletePathVertex();
        InvalidateRect(hWnd,NULL,FALSE);
      }
    }
    else if(tracetool == 3){ /* insert */
      if(GetVertexAtCursor(LOWORD(lParam)+WoffX,HIWORD(lParam)+WoffY,hWnd,FALSE)){
        if(pathlist[Lp].closed == 0 && Lpp == pathlist[Lp].n - 1){ /* add to end */
          bStartTrace=TRUE;
          SetCursor(hcurPen1);
        }
        else{
          InsertVertex();
          InvalidateRect(hWnd,NULL,FALSE);
        }
      }
    }
    else if(tracetool == 4){ /* bend */
      bFoundFlag=GetVertexAtCursor(LOWORD(lParam)+WoffX,
                                   HIWORD(lParam)+WoffY,hWnd,TRUE);
      if(!bFoundFlag)TurnID=GetTurnID(LOWORD(lParam)+WoffX,
                                      HIWORD(lParam)+WoffY,hWnd);
      else{
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
        pp=(pathlist[Lp].pts + Lpp); pp->type=0; pp->hand=0;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
      }
      if(bFoundFlag || TurnID > 0){
        lpwX=pathlist[Lp].pts[Lpp].p.x;
        lpwY=pathlist[Lp].pts[Lpp].p.y;
      }
    }
    bToolCaptured=TRUE;
    SetCapture(hWnd);
    break;
  case WM_MOUSEMOVE:
    if(bMoveFlag){
      DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
      bMoveFlag=FALSE;
    }
    if(bSpaceDown){
      int iPosx,iPosy,dnx,dny;
      if(!bToolCaptured)break;
      GetScrollRange(hWnd, SB_HORZ, &iMin, &iMax);
      iPosx = GetScrollPos(hWnd, SB_HORZ);
      dnx=PanX-(short)LOWORD(lParam);
      dnx=BOUND(iPosx+dnx,iMin,iMax) - iPosx;
      GetScrollRange(hWnd, SB_VERT, &iMin, &iMax);
      iPosy = GetScrollPos(hWnd, SB_VERT);
      dny=PanY-(short)HIWORD(lParam);
      dny=BOUND(iPosy+dny,iMin,iMax) - iPosy;
      ScrollWindow(hWnd,-dnx,-dny,NULL,NULL);
      SetScrollPos(hWnd, SB_HORZ, iPosx + dnx, TRUE);
      SetScrollPos(hWnd, SB_VERT, iPosy + dny, TRUE);
      WoffX=GetScrollPos(hWnd,SB_HORZ);
      WoffY=GetScrollPos(hWnd,SB_VERT);
      PanX=(short)LOWORD(lParam); PanY=(short)HIWORD(lParam);
      break;
    }
    else if(tracetool == 0){
      if(pathtool){
        if(bFoundFlag){
          if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
          MoveWholePath(LOWORD(lParam)+WoffX,HIWORD(lParam)+WoffY,hWnd);
        }
        break;
      }
      if(bFoundFlag){
        int dx,dy;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        pp=(pathlist[Lp].pts + Lpp);
        dx=(short)LOWORD(lParam)+WoffX - pp->p.x;
        dy=(short)HIWORD(lParam)+WoffY - pp->p.y;
        pp->p.x += dx; pp->p.y += dy;
        if(pp->type == 1){
          pp->p1.x += dx; pp->p1.y += dy;
          pp->p2.x += dx; pp->p2.y += dy;
        }
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
      }
      else if(TurnID > 0){
        int dx,dy;
        double xxa,yya,ra;
        POINT *lpPta,*lpPtb;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        pp=(pathlist[Lp].pts + Lpp);
        if(pp->bent){
          if(TurnID == 1)lpPta=&(pp->p1); else lpPta=&(pp->p2);
          dx=(short)LOWORD(lParam)+WoffX - lpPta->x;
          dy=(short)HIWORD(lParam)+WoffY - lpPta->y;
          lpPta->x += dx; lpPta->y += dy;
        }
        else{
          if(TurnID == 1){lpPta=&(pp->p1); lpPtb=&(pp->p2);}
          else           {lpPta=&(pp->p2); lpPtb=&(pp->p1);}
          dx=(short)LOWORD(lParam)+WoffX - lpPta->x;
          dy=(short)HIWORD(lParam)+WoffY - lpPta->y;
          lpPta->x += dx; lpPta->y += dy;
          xxa=(double)(lpPta->x - pp->p.x);
          yya=(double)(lpPta->y - pp->p.y);
          ra=sqrt(xxa*xxa+yya*yya);
          if(ra < 0.001)ra=1.0;
          xxa /= ra; yya /= ra;
          lpPtb->x=pp->p.x-(long)(xxa*pp->r);
          lpPtb->y=pp->p.y-(long)(yya*pp->r);
        }
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
      }
    }
    else if(tracetool == 1){ /* add */
      if(bToolCaptured){
        if(Lp < 0 || Lpp < 0)break;
        if(bAddStart && abs((short)LOWORD(lParam)-lpX) < 3 &&
                        abs((short)HIWORD(lParam)-lpY) < 3)break;
        bAddStart=FALSE;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        pp=(pathlist[Lp].pts + Lpp);
        pp->type=1; pp->hand=1;
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        pp->p1.x=(short)LOWORD(lParam)+WoffX;
        pp->p1.y=(short)HIWORD(lParam)+WoffY;
        pp->p2.x=pp->p.x-(pp->p1.x-pp->p.x);
        pp->p2.y=pp->p.y-(pp->p1.y-pp->p.y);
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
      }
      else{
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        LastPt.x=(short)LOWORD(lParam)+WoffX;
        LastPt.y=(short)HIWORD(lParam)+WoffY;
        if(Lpp > 0 && IdentifyPathVertex((int)LastPt.x,(int)LastPt.y,Lp) == 0){
          SetCursor(hcurNear);
          bNearStart=TRUE;
        }
        else bNearStart=FALSE;
        DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
        bMoveFlag=TRUE;
      }
    }
    else if(tracetool == 4){ /* bend */
      if(bFoundFlag){
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        pp=(pathlist[Lp].pts + Lpp);
        pp->type=1; pp->hand=1; pp->bent=0;
        pp->p1.x=(short)LOWORD(lParam)+WoffX;
        pp->p1.y=(short)HIWORD(lParam)+WoffY;
        pp->p2.x=pp->p.x-(pp->p1.x-pp->p.x);
        pp->p2.y=pp->p.y-(pp->p1.y-pp->p.y);
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
      }
      else if(TurnID > 0){
        int dx,dy,n;
        POINT *lpPta;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
        if(GetKeyState(VK_SHIFT) & 0x8000)GetShiftedCoords(&lParam,lpwX,lpwY);
        pp=(pathlist[Lp].pts + Lpp); pp->bent=1;
        if(TurnID == 1)lpPta=&(pp->p1); else lpPta=&(pp->p2);
        dx=(short)LOWORD(lParam)+WoffX - lpPta->x;
        dy=(short)HIWORD(lParam)+WoffY - lpPta->y;
        lpPta->x += dx; lpPta->y += dy;
        DrawPathPoint(Lp,Lpp,hWnd,NULL);
        DrawPathPoint(Lp,Lpp+1,hWnd,NULL);
      }
    }
    break;
  case WM_LBUTTONUP:
    if(bToolCaptured){
      if(tracetool == 0){
        bFoundFlag=FALSE;
        TurnID=0;
      }
      else if(tracetool == 1){ /* draw */
        if(Lp >= 0 && Lpp >= 0){
          DrawPathPoint(Lp,Lpp,hWnd,NULL);
          pp=(pathlist[Lp].pts + Lpp);
          pp->hand=0;
          DrawPathPoint(Lp,Lpp,hWnd,NULL);
        }
        if(bNearStart){ /* end of draw for this curve */
          Lp= -1; Lpp= -1;
          bNearStart=FALSE;
        }
        else{
          LastPt.x=(short)LOWORD(lParam)+WoffX;
          LastPt.y=(short)HIWORD(lParam)+WoffY;
          DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
          bMoveFlag=TRUE;
        }
      }
      else if(tracetool == 3){ /* insert */
        if(bStartTrace){
          bStartTrace=FALSE;
          tracetool=1;
          EnableMenuItem(GetMenu(hWnd),IDM_ADD,MF_GRAYED);
          EnableMenuItem(GetMenu(hWnd),IDM_INSERT,MF_ENABLED);
          panneltool=2;
          SelectDraftTool(panneltool);
          LastPt.x=(short)LOWORD(lParam)+WoffX;
          LastPt.y=(short)HIWORD(lParam)+WoffY;
          DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,NULL);
          bMoveFlag=TRUE;
        }
      }
      else if(tracetool == 4){ /* bend */
        bFoundFlag=FALSE;
        TurnID=0;
      }
    }
    bToolCaptured=FALSE;
    ReleaseCapture();
    SendMessage(hWnd,WM_KEYDOWN,0,0);
    break;
  case WM_PAINT:
    hDC = BeginPaint(hWnd, &ps);
    GetClientRect(hWnd,&rc);
    PatBlt(hDC,0,0,rc.right,rc.bottom,PATCOPY);
    DrawAll(hWnd,hDC);
    if(bMoveFlag)DrawFromPathPoint(bNearStart,Lp,Lpp,&LastPt,hWnd,hDC);
    EndPaint(hWnd,&ps);
    break ;
  case WM_MENUSELECT:
    bSpaceDown=FALSE;
    {
      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_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);
    }
    WoffY=GetScrollPos(hWnd,SB_VERT);
    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);
    }
    WoffX=GetScrollPos(hWnd,SB_HORZ);
    break;
  case WM_SIZE:
    WoffX=GetScrollPos(hWnd,SB_HORZ);
    WoffY=GetScrollPos(hWnd,SB_VERT);
    InvalidateRect(hWnd,NULL,FALSE);
    return 0;
  default:
      return DefWindowProc (hWnd, iMessage, wParam, lParam) ;
 }
 return 0L ;
}

BOOL MenuCommand (HWND hWnd, WORD id){
 int i;
 switch (id) {
   case IDM_MOVE:
     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);
     EnableMenuItem(GetMenu(hWnd),IDM_BEND,MF_ENABLED);
     ResetScreen(hWnd);
     tracetool=0;
     if(pathtool == 0)panneltool=0; else panneltool=1;
     SelectDraftTool(panneltool);
     break;
   case IDM_ADD:
     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);
     EnableMenuItem(GetMenu(hWnd),IDM_BEND,MF_ENABLED);
     ResetScreen(hWnd);
     tracetool=1;
     panneltool=2;
     SelectDraftTool(panneltool);
     break;
   case IDM_DELETE:
     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);
     EnableMenuItem(GetMenu(hWnd),IDM_BEND,MF_ENABLED);
     ResetScreen(hWnd);
     tracetool=2;
     if(pathtool == 0)panneltool=4; else panneltool=5;
     SelectDraftTool(panneltool);
     break;
   case IDM_INSERT:
     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);
     EnableMenuItem(GetMenu(hWnd),IDM_BEND,MF_ENABLED);
     ResetScreen(hWnd);
     tracetool=3;
     panneltool=6;
     SelectDraftTool(panneltool);
     break;
   case IDM_BEND:
     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_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_BEND,MF_GRAYED);
     ResetScreen(hWnd);
     tracetool=4;
     panneltool=3;
     SelectDraftTool(panneltool);
     break;
   case IDM_PATH:
     EnableMenuItem(GetMenu(hWnd),IDM_VERTEX,MF_ENABLED);
     EnableMenuItem(GetMenu(hWnd),IDM_PATH,MF_GRAYED);
     ResetScreen(hWnd);
     pathtool=1;
     if(panneltool == 0)panneltool=1;
     else if(panneltool == 4)panneltool=5;
     SelectDraftTool(panneltool);
     break;
   case IDM_VERTEX:
     EnableMenuItem(GetMenu(hWnd),IDM_VERTEX,MF_GRAYED);
     EnableMenuItem(GetMenu(hWnd),IDM_PATH,MF_ENABLED);
     ResetScreen(hWnd);
     pathtool=0;
     if(panneltool == 1)panneltool=0;
     else if(panneltool == 5)panneltool=4;
     SelectDraftTool(panneltool);
     break;
   case IDM_TP_0:
     panneltool=0;
     if(pathtool == 1)SendMessage(hWnd,WM_COMMAND,IDM_VERTEX,0);
     SendMessage(hWnd,WM_COMMAND,IDM_MOVE,0);
     break;
   case IDM_TP_1:
     panneltool=1;
     if(pathtool == 0)SendMessage(hWnd,WM_COMMAND,IDM_PATH,0);
     SendMessage(hWnd,WM_COMMAND,IDM_MOVE,0);
     break;
   case IDM_TP_2:
     SendMessage(hWnd,WM_COMMAND,IDM_ADD,0);
     break;
   case IDM_TP_3:
     SendMessage(hWnd,WM_COMMAND,IDM_BEND,0);
     break;
   case IDM_TP_4:
     panneltool=4;
     if(pathtool == 1)SendMessage(hWnd,WM_COMMAND,IDM_VERTEX,0);
     SendMessage(hWnd,WM_COMMAND,IDM_DELETE,0);
     break;
   case IDM_TP_5:
     panneltool=5;
     if(pathtool == 0)SendMessage(hWnd,WM_COMMAND,IDM_PATH,0);
     SendMessage(hWnd,WM_COMMAND,IDM_DELETE,0);
     break;
   case IDM_TP_6:
     SendMessage(hWnd,WM_COMMAND,IDM_INSERT,0);
     break;
   case IDM_CLEAR:
     DeleteAllPath();
     ResetScreen(hWnd);
     EnableMenuItem(GetMenu(hWnd),IDM_SAVE,MF_GRAYED);
     SendMessage(hWnd,WM_SETTEXT,0,(LPARAM)Title);
     break;
   case IDM_BUILD:
     BuildFromTrace(hWnd);
     DrawModel();
     break;
   case IDM_OPEN:
     if(GetFilename(0,hWnd,gszDir,gszFile)){
       EnableMenuItem(GetMenu(hWnd),IDM_SAVE,MF_ENABLED);
       ReadPaths();
       ResetScreen(hWnd);
       SendMessage(hWnd,WM_SETTEXT,0,(LPARAM)gszFile);
     }
     break;
   case IDM_ABORT:
     SetCursor(hcurArrow);
     PostQuitMessage(0);
     break;
   case IDM_SAVE:
     if(Np == 0)break;
     WritePaths();
     break;
   case IDM_SAVEAS:
     if(Np == 0)break;
     if(GetFilename(1,hWnd,gszDir,gszFile)){
       AppendFileExtension(gszFile,".bph");
       WritePaths();
       EnableMenuItem(GetMenu(hWnd),IDM_SAVE,MF_ENABLED);
       SendMessage(hWnd,WM_SETTEXT,0,(LPARAM)gszFile);
     }
     break;
   case IDM_CLOSETBX:
     DestroyDraftToolbox();
     break;
   default:
     break;
 }
 return TRUE;
}

static void DrawAll(HWND hWnd, HDC hDC){
 int i,j,n;
 PATHPOINT *pp;
 if(Np == 0 || pathlist == NULL)return;
 for(i=0;i<Np;i++){
   pp=pathlist[i].pts;
   if(pp != NULL)for(j=0;j<pathlist[i].n;j++){
     DrawPathPoint(i,j,hWnd,hDC);
   }
 }
}

static BOOL GetVertexAtCursor(int x, int y, HWND hWnd, BOOL draw){
 int i,j,n;
 PATHPOINT *pp;
 if(Np == 0 || pathlist == NULL)return FALSE;
 for(i=0;i<Np;i++){
   pp=pathlist[i].pts;
   if(pp != NULL)for(j=0;j<pathlist[i].n;j++,pp++){
     if(abs(x - pp->p.x) < 3 && abs(y - pp->p.y) < 3){
       if(Lp >= 0 && Lpp >= 0){
         if(draw){
           DrawPathPoint(Lp,Lpp,hWnd,NULL);
           pathlist[Lp].pts[Lpp].hand=0;
           DrawPathPoint(Lp,Lpp,hWnd,NULL);
         }
       }
       Lp=i; Lpp=j;
       if(draw){
         DrawPathPoint(Lp,Lpp,hWnd,NULL);
         pathlist[Lp].pts[Lpp].hand=1;
         DrawPathPoint(Lp,Lpp,hWnd,NULL);
       }
       return TRUE;
     }
   }
 }
 return FALSE;
}

static int IdentifyPathVertex(int x, int y, int p){
 int j;
 PATHPOINT *pp;
 if(p < 0)return -1;
 pp=pathlist[p].pts;
 if(pp != NULL)for(j=0;j<pathlist[p].n;j++,pp++){
   if(abs(x - pp->p.x) < 3 && abs(y - pp->p.y) < 3)return j;
 }
 return -1;
}

static int GetTurnID(int x, int y, HWND hWnd){
 PATHPOINT *pp;
 double xxb,yyb;
 if(Lp < 0 || Lpp < 0)return 0;
 pp=(pathlist[Lp].pts+Lpp);
 if(pp->hand == 0 || pp->type == 0)return 0;
 if((Lpp < pathlist[Lp].n - 1 || pathlist[Lp].closed) &&
    abs(x - pp->p1.x) < 3 && abs(y - pp->p1.y) < 3){
   xxb=(double)(pp->p2.x - pp->p.x);
   yyb=(double)(pp->p2.y - pp->p.y);
   pp->r=sqrt(xxb*xxb+yyb*yyb);
   return 1;
 }
 if((Lpp > 0 || pathlist[Lp].closed) &&
    abs(x - pp->p2.x) < 3 && abs(y - pp->p2.y) < 3){
   xxb=(double)(pp->p1.x - pp->p.x);
   yyb=(double)(pp->p1.y - pp->p.y);
   pp->r=sqrt(xxb*xxb+yyb*yyb);
   return 2;
 }
 return 0;
}

static void ResetScreen(HWND hWnd){
 if(Lp >= 0 && Lpp >= 0)pathlist[Lp].pts[Lpp].hand=0;
 Lp= -1; Lpp= -1;
 InvalidateRect(hWnd,NULL,FALSE);
}

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

static BOOL GetFilename(int save, HWND parent, char *szdir, char *szfile){
 int i;
 OPENFILENAME ofn;
 char szFilter[60],szdummy[256];
 szdummy[0]='\0';
 strcpy(szFilter,"Bezier Paths|*.bph|");
 i=0; while(szFilter[i] != '\0'){
   if(szFilter[i] == '|')szFilter[i]='\0'; i++;
 }
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=parent;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=1;
 ofn.lpstrFile=szfile;
 ofn.nMaxFile=255;
 ofn.lpstrFileTitle=szdummy;
 ofn.nMaxFileTitle=255;
 ofn.lpstrInitialDir=szdir;
 ofn.lpstrTitle="Bezier Paths File to Open";
 if(save){
  ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
   i=(int)(GetSaveFileName(&ofn));
 }
 else{
  ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST;
   i=(int)(GetOpenFileName(&ofn));
 }
 if(i){
   strcpy(szdummy,szfile);
   *AnsiPrev(szdummy,FileInPath(szdummy)) = '\0';
   strcpy(szdir,szdummy);
   return TRUE;
 }
 return FALSE;
}

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#elif __BC__
BOOL WINAPI DllEntryPoint(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;
#endif
      hThisInstance=hDLL;
      break;
    }
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      break;
  }
  return TRUE;
}


BOOL _BezierModeler
 (HWND parent_window, HWND info_window,X__STRUCTURE *lpevi){
 lpEVI=lpevi;
 tracetool=0;
 hParent=parent_window;
 hInfo=info_window;
 GetModuleFileName(hThisInstance,gszDir,255);
 *FileInPath(gszDir) = '\0';
 strcat(gszDir,"objects");
 gszFile[0]='\0';
 return Bezier();
}