TTF.C

Go to the documentation of this file.

/* --
OpenFX version 2.x  - Modelling, Animation and Rendering Package
-- */

/* file TTF.C  TTF font DLL */

#ifdef __BETA35__
#define _DLL
#endif
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <setjmp.h>
#include <windows.h>
#include <windowsx.h>
#if __HELP_WS__
#include "..\help_ws\include\htmlhelp.h"
#endif

#include "struct.h"
#include "dstruct.h"
#include "ttf.h"
#include "ttfdlg.h"

#ifndef PI
#define PI 3.1415926
#endif
#ifndef min
#define min(a,b)  ( ((a) < (b)) ? (a) : (b) )
#endif
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif

typedef struct FOUR_INTEGERS {  /* each edge in the preview  integers */
  long x1,y1,x2,y2;
  float dx,dy;
} four_integers;

#define OK         1
#define FAIL       0

static void MakeNewTTFletter(HWND);
static void DrawTTFfontShapePreview(HDC hdc,RECT rc);
static void DrawTTFfontProfilePreview(HDC hdc,RECT rc);
static void LoadTTFfontPreviewCharacter(HWND hwnd);
static BOOL CALLBACK TtfDlgProc(HWND hwnd, UINT msg,
                                WPARAM wparam, LPARAM lparam);
static void BuildTTFchar(BOOL preview, UINT c);

static BITMAP    TtfHelpBitmap;
static HBITMAP   hBitmap=NULL;
static HINSTANCE hThisInstance=NULL;
static HWND      hwndParent=NULL;
static TTF_STRUCTURE *lpTtf;
static long  nTTF_preview_list=0,nTTF_preview_piece=0;
static four_integers *TTF_preview_list=NULL;
static long Cwidthx,Cwidthy,Scale=32;
static double MaxScale=1000.0;

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

#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: {
      hThisInstance=hDLL;
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

//void TTFthread(void *vvv){
BOOL _TTFbuilder(
  HWND parent_window, char *szdir, X__STRUCTURE *lpevi, TTF_STRUCTURE *lpatm){
  int i;
  hwndParent=parent_window;
  lpTtf=lpatm;
  lpEVI=lpevi;
  if(lpTtf->cf.lStructSize == 0){
    lpTtf->cf.lStructSize=sizeof(CHOOSEFONT);
    lpTtf->cf.hwndOwner=hwndParent;
    lpTtf->cf.lpLogFont=&(lpTtf->lf);
    lpTtf->cf.iPointSize=10;
    lpTtf->cf.Flags=CF_SCREENFONTS|CF_TTONLY;
    lpTtf->cf.nFontType=SCREEN_FONTTYPE;
    if(!ChooseFont(&(lpTtf->cf)))return FALSE;
//    if(!ChooseFont(&(lpTtf->cf))){_endthread(); return;}
  }
  if(DialogBox(hThisInstance,MAKEINTRESOURCE(DLG_TTF),hwndParent,
            (DLGPROC)TtfDlgProc) == OK){
    MakeNewTTFletter(hwndParent);
    return TRUE;
  }
  return FALSE;
//  PostMessage(hwndParent,WM_QUIT,0,0);
//  _endthread();
}

#if 0
BOOL _TTFbuilder(
  HWND parent_window, char *szdir, X__STRUCTURE *lpevi, TTF_STRUCTURE *lpatm){
  void (*fp)(void *);
  hwndParent=parent_window;
  lpTtf=lpatm;
  lpEVI=lpevi;
  fp=TTFthread;
#if  __WATCOMC__ && __WATCOMC__ < 1100
  _beginthread(fp,0,65536,(void *)0);
#else
  _beginthread(fp,0,(void *)0);
#endif
  {
   MSG msg;
   while(GetMessage(&msg,NULL,0,0)){
     TranslateMessage(&msg);
     DispatchMessage(&msg);
   }
  }
//  MessageBox(NULL,"Terminating Thread",NULL,MB_OK);
  return TRUE;
}
#endif

static char *ColorSelectDlgString;

static BOOL CALLBACK ColorSelectDlgProc(HWND hwnd, UINT msg, WPARAM wparam,
                                        LPARAM lparam){
 switch( msg ) {
   case WM_INITDIALOG:
     SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)ColorSelectDlgString);
     return TRUE;
   default:
     break;
 }
 return FALSE;
}

static void SetTtfColour(unsigned char colour[], char *Title, HWND parent){
 CHOOSECOLOR cc;
 static COLORREF CustColours[16]={
   RGB(255,255,255), RGB(239,239,239), RGB(223,223,223), RGB(207,207,207),
   RGB(191,191,191), RGB(175,175,175), RGB(159,159,159), RGB(143,143,143),
   RGB(127,127,127), RGB(111,111,111), RGB( 95, 95, 95), RGB( 79, 79, 79),
   RGB( 63, 63, 63), RGB( 47, 47, 47), RGB( 31, 31, 31), RGB( 15, 15, 15) };
 cc.lStructSize=sizeof(CHOOSECOLOR);
 cc.hwndOwner=parent;
 cc.rgbResult=RGB(colour[0],colour[1],colour[2]);
 cc.lpCustColors=(LPDWORD)CustColours;
 cc.Flags=CC_FULLOPEN | CC_RGBINIT | CC_ENABLEHOOK;
 cc.lCustData=(DWORD)0;
 ColorSelectDlgString=Title;
 cc.lpfnHook=(LPCCHOOKPROC)ColorSelectDlgProc;
 if(ChooseColor(&cc)){
   colour[0]=GetRValue(cc.rgbResult);
   colour[1]=GetGValue(cc.rgbResult);
   colour[2]=GetBValue(cc.rgbResult);
 }
}

static void UpdateTtfSlider(HWND hwnd,int sliderID,int valueID,int value){
 char str[16];
 SetScrollPos(GetDlgItem(hwnd,sliderID),SB_CTL,value,TRUE);
 sprintf(str,"%ld",value);
 SendDlgItemMessage(hwnd,valueID,WM_SETTEXT,0,(LPARAM)str);
}

//static void UpdateAdobeName(HWND hwnd){
// SendDlgItemMessage(hwnd,DLG_TTF_ADOBE_NAME,WM_SETTEXT,0,(LPARAM)load_line);
//}

static BOOL CALLBACK TtfDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 RECT rc;
 char str[16],*nn;
 int iMin,iMax;
 int hp[7]={DLG_TTF_CPDL,DLG_TTF_CPDC,DLG_TTF_CPDR,DLG_TTF_CPCC,
            DLG_TTF_CPUL,DLG_TTF_CPUC,DLG_TTF_CPUR};
 HWND hctl;
 BITMAP bmp;
 switch( msg ) {
   case WM_INITDIALOG:
     hBitmap=LoadBitmap(hThisInstance,MAKEINTRESOURCE(IDBM_HELP));
     if(hBitmap != NULL){
       GetObject(hBitmap,sizeof(BITMAP),&TtfHelpBitmap);
     }
     LoadTTFfontPreviewCharacter(hwnd);
//     EnableWindow(GetDlgItem(hwnd,DLG_TTF_ADOBE_NAME),FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_TTF_BEVEL_ANGLE),SB_CTL,5,80,FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_TTF_BEVEL_DEPTH),SB_CTL,0,100,FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_TTF_CHAR_WIDTH),SB_CTL,0,100,FALSE);
     SendDlgItemMessage(hwnd,hp[lpTtf->TTF_offset],BM_SETCHECK,TRUE,0);
     UpdateTtfSlider(hwnd,DLG_TTF_BEVEL_ANGLE,DLG_TTF_BEVEL_ANGLEN,
                     lpTtf->TTF_bevel_angle);
     UpdateTtfSlider(hwnd,DLG_TTF_BEVEL_DEPTH,DLG_TTF_BEVEL_DEPTHN,
                     lpTtf->TTF_bevel_width);
     UpdateTtfSlider(hwnd,DLG_TTF_CHAR_WIDTH,DLG_TTF_CHAR_WIDTHN,
                     lpTtf->TTF_chara_width);
     sprintf(str,"%c",lpTtf->TTF_char_preview);
     SendDlgItemMessage(hwnd,DLG_TTF_PREVIEW,WM_SETTEXT,0,(LPARAM)str);
     if((nn=lpTtf->lf.lfFaceName) != NULL){
       SendDlgItemMessage(hwnd,DLG_TTF_FONTID,WM_SETTEXT,0,(LPARAM)nn);
     }
     if(lpTtf->FORB > 0)
       SendDlgItemMessage(hwnd,DLG_TTF_LR,BM_SETCHECK,TRUE,0);
     else SendDlgItemMessage(hwnd,DLG_TTF_RL,BM_SETCHECK,TRUE,0);
     if(lpTtf->TTF_bevel_back)
       SendDlgItemMessage(hwnd,DLG_TTF_BEVEL_BACK,BM_SETCHECK,TRUE,0);
     if(lpTtf->TTF_bevel_front)
       SendDlgItemMessage(hwnd,DLG_TTF_BEVEL_FRONT,BM_SETCHECK,TRUE,0);
     if(lpTtf->TTF_cap)
       SendDlgItemMessage(hwnd,DLG_TTF_FILL,BM_SETCHECK,TRUE,0);
     else  SendDlgItemMessage(hwnd,DLG_TTF_NOFILL,BM_SETCHECK,TRUE,0);
     sprintf(str,"%s",lpTtf->TTF_Letters);
     SendDlgItemMessage(hwnd,DLG_TTF_TEXT,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_TTF_TEXT,EM_LIMITTEXT,(WPARAM)60,0);
     EnableWindow(GetDlgItem(hwnd,DLG_TTF_MAKE),
                  Edit_LineLength(GetDlgItem(hwnd,DLG_TTF_TEXT), 0) > 0);
     GetWindowRect(hwnd, &rc);
     SetWindowPos(hwnd, 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_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_TTF_COLOUR_FACES ||
          lpdis->CtlID == DLG_TTF_COLOUR_SIDES ||
          lpdis->CtlID == DLG_TTF_COLOUR_BEVEL){
         if(lpdis->CtlID == DLG_TTF_COLOUR_FACES){
           r=lpTtf->TTF_face_colour[0];
           g=lpTtf->TTF_face_colour[1];
           b=lpTtf->TTF_face_colour[2];
         }
         else if(lpdis->CtlID == DLG_TTF_COLOUR_SIDES){
           r=lpTtf->TTF_side_colour[0];
           g=lpTtf->TTF_side_colour[1];
           b=lpTtf->TTF_side_colour[2];
         }
         else if(lpdis->CtlID == DLG_TTF_COLOUR_BEVEL){
           r=lpTtf->TTF_beve_colour[0];
           g=lpTtf->TTF_beve_colour[1];
           b=lpTtf->TTF_beve_colour[2];
         }
         if(lpdis->itemState & ODS_SELECTED)
            InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
       else if(lpdis->CtlID == DLG_TTF_SHAPE)
         DrawTTFfontShapePreview(lpdis->hDC,lpdis->rcItem);
       else if(lpdis->CtlID == DLG_TTF_PROFILE)
         DrawTTFfontProfilePreview(lpdis->hDC,lpdis->rcItem);
       else if(lpdis->CtlID == DLG_TTF_INFO && hBitmap != NULL){
         HDC hMemDC;
         HBITMAP hbmOld;
         hMemDC = CreateCompatibleDC(lpdis->hDC);
         hbmOld = SelectObject(hMemDC,hBitmap);
         BitBlt(lpdis->hDC,lpdis->rcItem.left
                          ,lpdis->rcItem.top
                          ,TtfHelpBitmap.bmWidth
                          ,TtfHelpBitmap.bmHeight
                          ,hMemDC,0,0,SRCCOPY);
         SelectObject(hMemDC,hbmOld);
         DeleteDC(hMemDC);
       }
     }
     return TRUE;
   case WM_HSCROLL:
     if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_TTF_BEVEL_ANGLE))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpTtf->TTF_bevel_angle = min(iMax,lpTtf->TTF_bevel_angle+1);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpTtf->TTF_bevel_angle = max(iMin,lpTtf->TTF_bevel_angle-1);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpTtf->TTF_bevel_angle=HIWORD(wparam);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateTtfSlider(hwnd,DLG_TTF_BEVEL_ANGLE,DLG_TTF_BEVEL_ANGLEN,
                       lpTtf->TTF_bevel_angle);
     }
     else if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_TTF_BEVEL_DEPTH))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpTtf->TTF_bevel_width = min(iMax,lpTtf->TTF_bevel_width+1);
           if(lpTtf->TTF_bevel_front || lpTtf->TTF_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpTtf->TTF_bevel_width = max(iMin,lpTtf->TTF_bevel_width-1);
           if(lpTtf->TTF_bevel_front || lpTtf->TTF_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpTtf->TTF_bevel_width=HIWORD(wparam);
           if(lpTtf->TTF_bevel_front || lpTtf->TTF_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateTtfSlider(hwnd,DLG_TTF_BEVEL_DEPTH,DLG_TTF_BEVEL_DEPTHN,
                       lpTtf->TTF_bevel_width);
     }
     else if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_TTF_CHAR_WIDTH))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpTtf->TTF_chara_width = min(iMax,lpTtf->TTF_chara_width+1);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpTtf->TTF_chara_width = max(iMin,lpTtf->TTF_chara_width-1);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpTtf->TTF_chara_width=HIWORD(wparam);
           InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateTtfSlider(hwnd,DLG_TTF_CHAR_WIDTH,DLG_TTF_CHAR_WIDTHN,
                       lpTtf->TTF_chara_width);
     }
     break;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_TTF_CPDL: lpTtf->TTF_offset=0; break;
        case DLG_TTF_CPDC: lpTtf->TTF_offset=1; break;
        case DLG_TTF_CPDR: lpTtf->TTF_offset=2; break;
        case DLG_TTF_CPCC: lpTtf->TTF_offset=3; break;
        case DLG_TTF_CPUL: lpTtf->TTF_offset=4; break;
        case DLG_TTF_CPUC: lpTtf->TTF_offset=5; break;
        case DLG_TTF_CPUR: lpTtf->TTF_offset=6; break;
        case DLG_TTF_BEVEL_FRONT:
          lpTtf->TTF_bevel_front ^= 1;
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
          break;
        case DLG_TTF_BEVEL_BACK:
          lpTtf->TTF_bevel_back ^= 1;
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
          break;
        case DLG_TTF_FILL:
          lpTtf->TTF_cap=1;
          break;
        case DLG_TTF_NOFILL:
          lpTtf->TTF_cap=0;
          break;
        case DLG_TTF_PREVIEW:
          if(Edit_LineLength(GetDlgItem(hwnd,DLG_TTF_PREVIEW),0) > 0){
            GetDlgItemText(hwnd,DLG_TTF_PREVIEW,str,10);
            if(lpTtf->TTF_char_preview != (int)str[0]){
              lpTtf->TTF_char_preview=(int)str[0];
              LoadTTFfontPreviewCharacter(hwnd);
              InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
              InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
            }
          }
          break;
        case DLG_TTF_TEXT:
          EnableWindow(GetDlgItem(hwnd,DLG_TTF_MAKE),
                  Edit_LineLength((HWND)(lparam), 0) > 0);
          break;
        case DLG_TTF_CHOOSE:
          if(!ChooseFont(&(lpTtf->cf)))break;
          LoadTTFfontPreviewCharacter(hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_PROFILE),NULL,FALSE);
          if((nn=lpTtf->lf.lfFaceName) != NULL){
            SendDlgItemMessage(hwnd,DLG_TTF_FONTID,WM_SETTEXT,0,(LPARAM)nn);
          }
          break;
        case DLG_TTF_HELP:{
            char lname[256],res_str1[256],res_str2[256];
            GetModuleFileName(hThisInstance,lname,225);
            *FileInPath(lname) = '\0';
            strcat(lname,"help\\");
            strcpy(res_str1,lname);
#if !__HELP_WS__
            strcat(res_str1,"des_help.chm");
            ShellExecute(hwnd,NULL,res_str1,
                    NULL,lname,SW_SHOW);
#else
            {
              HH_WINTYPE hhwin;
              memset(&hhwin,0,sizeof(HH_WINTYPE));
              hhwin.cbStruct=sizeof(HH_WINTYPE);
              hhwin.nShowState=SW_SHOW;
              hhwin.pszType="MyHelp";
              hhwin.pszCaption="OpenFX Help";
              hhwin.fsValidMembers = HHWIN_PARAM_SHOWSTATE |
                                     HHWIN_PARAM_PROPERTIES|
                                     HHWIN_PARAM_CUR_TAB|
                                     HHWIN_PARAM_EXPANSION|
                                     HHWIN_PARAM_RECT;
              hhwin.rcWindowPos.top=0;
              hhwin.rcWindowPos.left=0;
              hhwin.rcWindowPos.right=500;
              hhwin.rcWindowPos.bottom=500;
              hhwin.nShowState=SW_SHOW;
              strcat(res_str1,"des_help.chm");
              hhwin.fNotExpanded = TRUE;
              hhwin.fsWinProperties = HHWIN_PROP_TRI_PANE|HHWIN_PROP_TAB_SEARCH;
              hhwin.curNavType=HHWIN_NAVTYPE_TOC;
              strcpy(res_str2,res_str1);
              strcat(res_str2,"::toc.hhc");
              hhwin.pszToc=res_str2;
              strcat(res_str1,"::/TTF_Text_Builder.htm");
              HtmlHelp(hwnd,NULL,HH_SET_WIN_TYPE,(DWORD)&hhwin);
              HtmlHelp(hwnd,">MyHelp",HH_DISPLAY_TOPIC,(DWORD)res_str1);
            }
#endif
//            WinHelp(hwnd,lname,HELP_INDEX,0L);
//            EnableWindow(GetDlgItem(hwnd,DLG_TTF_HELP),FALSE);
          }
          break;
        case DLG_TTF_COLOUR_FACES:
          SetTtfColour(lpTtf->TTF_face_colour,"Set Face Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_COLOUR_FACES),NULL,FALSE);
          break;
        case DLG_TTF_COLOUR_BEVEL:
          SetTtfColour(lpTtf->TTF_beve_colour,"Set Bevel Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_COLOUR_BEVEL),NULL,FALSE);
          break;
        case DLG_TTF_COLOUR_SIDES:
          SetTtfColour(lpTtf->TTF_side_colour,"Set Side Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_TTF_COLOUR_SIDES),NULL,FALSE);
          break;
        case DLG_TTF_LR:
          lpTtf->FORB =  1;
          break;
        case DLG_TTF_RL:
          lpTtf->FORB = -1;
          break;
        case DLG_TTF_MAKE:
        case DLG_TTF_CANCEL:
          if(hBitmap != NULL)DeleteObject(hBitmap);
          hBitmap=NULL;
          if(TTF_preview_list != NULL)X__Free(TTF_preview_list);
          TTF_preview_list=NULL; nTTF_preview_list=0;
          if(LOWORD(wparam) == DLG_TTF_MAKE){
            GetDlgItemText(hwnd,DLG_TTF_TEXT,lpTtf->TTF_Letters,21);
            EndDialog(hwnd, OK);
          }
          else EndDialog(hwnd, FAIL);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

static void LoadTTFfontPreviewCharacter(HWND hwnd){
 UINT cch;
 if(TTF_preview_list != NULL)X__Free(TTF_preview_list);
 TTF_preview_list=NULL; nTTF_preview_list=0; nTTF_preview_piece=0;
 cch=(UINT)lpTtf->TTF_char_preview;
 BuildTTFchar(TRUE,cch);
 if(nTTF_preview_list > 0){
   long i;
   long xmin=1000000, ymin=1000000, xmax = -1000000, ymax = -1000000;
   double sx,sy,s;
   for(i=0;i<nTTF_preview_list;i++){
     if(TTF_preview_list[i].x1 < xmin)xmin=TTF_preview_list[i].x1;
     if(TTF_preview_list[i].y1 < ymin)ymin=TTF_preview_list[i].y1;
     if(TTF_preview_list[i].x2 > xmax)xmax=TTF_preview_list[i].x2;
     if(TTF_preview_list[i].y2 > ymax)ymax=TTF_preview_list[i].y2;
     sx=(double)(TTF_preview_list[i].x2-TTF_preview_list[i].x1);
     sy=(double)(TTF_preview_list[i].y2-TTF_preview_list[i].y1);
     s=1.0/sqrt(sx*sx+sy*sy);    /* these are the inward pointing normals */
//     TTF_preview_list[i].dx = (float)(-sy*s);
//     TTF_preview_list[i].dy = (float)( sx*s);
     TTF_preview_list[i].dx = (float)( sy*s);
     TTF_preview_list[i].dy = (float)(-sx*s);
   }
   sx=(double)(xmax-xmin); sy=(double)(ymax-ymin); s=max(sx,sy);
   s=1050.0/s;
   for(i=0;i<nTTF_preview_list;i++){
     TTF_preview_list[i].x1=(long)((double)(TTF_preview_list[i].x1-xmin)*s);
     TTF_preview_list[i].y1=(long)((double)(TTF_preview_list[i].y1-ymin)*s);
     TTF_preview_list[i].x2=(long)((double)(TTF_preview_list[i].x2-xmin)*s);
     TTF_preview_list[i].y2=(long)((double)(TTF_preview_list[i].y2-ymin)*s);
   }
 }
}

static void CreateCharacterEdge(long x1, long y1, long x2, long y2){
 four_integers *fouri;
 if(x1 == x2 && y1 == y2)return; /* dont add a zero size edge */
 if(TTF_preview_list == NULL){
   if((fouri = (four_integers *)X__Malloc(sizeof(four_integers))) == NULL)return;
 }
 else {
   if((fouri = (four_integers *)X__Realloc(TTF_preview_list,
     (nTTF_preview_list+1)*sizeof(four_integers))) == NULL)return;
 }
 fouri[nTTF_preview_list].x1=x1;
 fouri[nTTF_preview_list].y1=y1;
 fouri[nTTF_preview_list].x2=x2;
 fouri[nTTF_preview_list].y2=y2;
 nTTF_preview_list++; nTTF_preview_piece++;
 TTF_preview_list=fouri;
}

static void DrawTTFfontShapePreview(HDC hdc,RECT rc){
 HPEN hmyPen,holdPen;
 long i;
 int h,w,ww,hh=10,x1,y1,x2,y2,xl,xr,xx1,xx2,yy1,yy2;
 double x,y,dx,dy,bs;
 ww=rc.bottom-rc.top-2; h=ww-hh;
 w=(int)((double)h*(double)lpTtf->TTF_chara_width/100.0);
 x1=rc.left+1;  x2=rc.right-1;
 y1=rc.top+1;   y2=rc.bottom-1;
 Rectangle(hdc,rc.left,rc.top,rc.right,rc.bottom);
 hmyPen=CreatePen(PS_SOLID,0,RGB(255,0,0));
 holdPen=SelectObject(hdc,hmyPen);
 if(nTTF_preview_list > 0 && TTF_preview_list != NULL){
   dy=dx=(double)h/1000.0;
   for(i=0;i<nTTF_preview_list;i++){
     xx1=x1+(int)((double)TTF_preview_list[i].x1*dx);
     yy1=y2-(int)((double)TTF_preview_list[i].y1*dy);
     xx2=x1+(int)((double)TTF_preview_list[i].x2*dx);
     yy2=y2-(int)((double)TTF_preview_list[i].y2*dy);
     MoveToEx(hdc,xx1,yy1,NULL); LineTo(hdc,xx2,yy2);
   }
   if(lpTtf->TTF_bevel_width > 0 &&
     (lpTtf->TTF_bevel_back || lpTtf->TTF_bevel_front)){
     bs=1050.0*(double)lpTtf->TTF_bevel_width/4000.0;
     for(i=0;i<nTTF_preview_list;i++){
       x=bs*(double)TTF_preview_list[i].dx;
       y=bs*(double)TTF_preview_list[i].dy;
       xx1=x1+(int)((double)TTF_preview_list[i].x1*dx);
       yy1=y2-(int)((double)TTF_preview_list[i].y1*dy);
       xx2=x1+(int)(((double)TTF_preview_list[i].x1+x)*dx);
       yy2=y2-(int)(((double)TTF_preview_list[i].y1+y)*dy);
       MoveToEx(hdc,xx1,yy1,NULL); LineTo(hdc,xx2,yy2);
       xx1=x1+(int)((double)TTF_preview_list[i].x2*dx);
       yy1=y2-(int)((double)TTF_preview_list[i].y2*dy);
       xx2=x1+(int)(((double)TTF_preview_list[i].x2+x)*dx);
       yy2=y2-(int)(((double)TTF_preview_list[i].y2+y)*dy);
       LineTo(hdc,xx2,yy2); LineTo(hdc,xx1,yy1);
     }
   }
 }
 SelectObject(hdc,holdPen);
 DeleteObject(hmyPen);
}

static void DrawTTFfontProfilePreview(HDC hdc,RECT rc){
 HPEN hmyPen,holdPen;
 long i;
 int h,w,ww,hh=10,x1,y1,x2,y2,xl,xr,xx1,xx2,yy1,yy2;
 double x,y,dx,dy,bs;
 ww=rc.bottom-rc.top-2; h=ww-hh;
 w=(int)((double)h*(double)lpTtf->TTF_chara_width/100.0);
 x1=rc.left+1;  x2=rc.right-1;
 y1=rc.top+1;   y2=rc.bottom-1;
 xl=x1+(ww-w)/2; xr=x1+(ww+w)/2;
 Rectangle(hdc,rc.left,rc.top,rc.right,rc.bottom);
 xl=x1+(ww-w)/2; xr=x1+(ww+w)/2+1;
 hmyPen=CreatePen(PS_SOLID,0,RGB(255,0,0));
 holdPen=SelectObject(hdc,hmyPen);
 Rectangle(hdc,xl,y1+hh/2,xr,y2-hh/2);
 if(lpTtf->TTF_bevel_width > 0){
   dy=(double)h*(double)lpTtf->TTF_bevel_width/4000.0;
   dx=dy/tan((double)lpTtf->TTF_bevel_angle/180.0*PI);
   if(lpTtf->TTF_bevel_front){
     MoveToEx(hdc,xr,y1+hh/2,NULL);
     LineTo(hdc,min(x2,xr+(int)dx),y1+hh/2+(int)dy);
     LineTo(hdc,min(x2,xr+(int)dx),y2-hh/2-(int)dy);
     LineTo(hdc,xr,y2-hh/2);
   }
   if(lpTtf->TTF_bevel_back){
     MoveToEx(hdc,xl,y1+hh/2,NULL);
     LineTo(hdc,max(x1,xl-(int)dx),y1+hh/2+(int)dy);
     LineTo(hdc,max(x1,xl-(int)dx),y2-hh/2-(int)dy);
     LineTo(hdc,xl,y2-hh/2);
   }
 }
 SelectObject(hdc,holdPen);
 DeleteObject(hmyPen);
}

#define SELECTED   1
#define DESELECTED 0

static long VP,VF;

static void GetTTFholdPoint(long *x, long *y, long cx, long cy, short pt);

static void DeselectVertexSet(long vs, long vf){
 vertex *Vs;
 while(vs < vf){
   Vs=(MainVp+vs);
   if(Vs->status == SELECTED){
      Vs->status = DESELECTED; NvertSelect--; NvertDeselect++;
   }
   vs++;
 }
}

static void SelectVertexSet(long vs, long vf){
 vertex *Vs;
 while(vs < vf){
   Vs=(MainVp+vs);
   if(Vs->status == DESELECTED){
      Vs->status = SELECTED; NvertSelect++; NvertDeselect--;
   }
   vs++;
 }
}

static void MakeNewTTFletter(HWND hwnd){
 long i,j,char_id,Depth,Opx,Opy,Opz;
 int ifail=OK,capped=0;
 long Vstart,Vstop,BackStart,BackStop,fBevelStart,fBevelStop,Vfirst;
 long ep,Estart=-1;
 long fp,LastFace;
 skel *sp;
 Vfirst=Nvert;
 char_id=0;
 Opx=NpointerX; Opy=NpointerY; Opz=NpointerZ;
 DeselectVertexSet(0,Nvert);
 while ((j=(long)lpTtf->TTF_Letters[char_id++]) > 0){
   Cwidthx=0; Cwidthy=0; Vstart=Nvert; Estart=Nedge; VF=VP= -1;
   if(lpTtf->TTF_chara_width > 0){
     Depth=MaxScale*(double)lpTtf->TTF_chara_width/100.0*Scale;
   }
   else Depth=0;
   BuildTTFchar(FALSE,j);
   if(j == 32){
     UpdateVertexHeap(Nvert+2);
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0]=NpointerX-Depth/2;
     (MainVp+Nvert-1)->xyz[1]=NpointerY;
     (MainVp+Nvert-1)->xyz[2]=NpointerZ;
     CreateVertex();
     (MainVp+Nvert-1)->xyz[0]=NpointerX-Depth/2;
     (MainVp+Nvert-1)->xyz[1]=NpointerY+Cwidthx*lpTtf->FORB;
     (MainVp+Nvert-1)->xyz[2]=NpointerZ+Cwidthy;
     UpdateEdgeHeap(Nedge+1);
     CreateEdge(Nvert-1,Nvert-2);
   }
   NpointerY += Cwidthx*lpTtf->FORB; NpointerZ += Cwidthy;
//   FREEALL:
   Vstop=Nvert; VP=Vstart; while(VP < Nvert){
     (MainVp+VP)->xyz[1] += rand()%4-2;  /* NB this helps fools the filling */
                                /* which can fail on some cases    */
     VP++;
   }
   if(Vstop == Vstart)ifail=FAIL;
   if(ifail == FAIL)break;
   CreateSkeleton(FirstSp);  sp=MainSp;
   if(j == 32){
     strcpy(MainSp->name,"Space");
   }
   else{
     if(j > 64 && j < 91)sprintf(MainSp->name,"%c%ld-C",j,char_id);
     else                sprintf(MainSp->name,"%c%ld",j,char_id);
   }
   MainSp->xyz[0]=NpointerX-Depth/2;
   GetTTFholdPoint(&MainSp->xyz[1],&MainSp->xyz[2],Cwidthx,Cwidthy,0);
   CreateSkeleton(MainSp);
   strcpy(MainSp->name,"F.Pt.");
   MainSp->xyz[0]=NpointerX-Depth/2;
   GetTTFholdPoint(&MainSp->xyz[1],&MainSp->xyz[2],Cwidthx,Cwidthy,1);
   DeselectVertexSet(Vstart,Vstop);
   Estart=Nedge;
   LastFace=Nface;
   if(j == 32)goto SPACEBREAK;
   if(lpTtf->TTF_cap && !lpTtf->TTF_bevel_front && !lpTtf->TTF_bevel_back){
     capped=1;
     SelectVertexSet(Vstart,Vstop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(Vstart,Vstop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   if(lpTtf->TTF_chara_width > 0){
     SelectVertexSet(Vstart,Vstop);
     BackStart=Nvert; LastFace=Nface;
     if(!CreateAttachedCopy(1))break; /* copy failed */
     BackStop=Nvert;
     DeselectVertexSet(BackStart,BackStop);
     VP=BackStart; while(VP < BackStop){
       (MainVp+VP)->xyz[0] -= Depth;
       VP++;
     }
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_side_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
   }
   else{BackStart=Vstart; BackStop=Vstop;}
   if((lpTtf->FORB > 0 && lpTtf->TTF_bevel_front) ||
      (lpTtf->FORB < 0 && lpTtf->TTF_bevel_back)){
     SelectVertexSet(Vstart,Vstop);
     fBevelStart=Nvert; LastFace=Nface;
     if(AutoFacetCurveWithHoles(3,0,1,(double)lpTtf->TTF_bevel_angle,
       (double)lpTtf->TTF_bevel_width/2000.0*MaxScale*Scale) == FAIL)break;
     fBevelStop=Nvert;
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_beve_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
     if(lpTtf->TTF_cap){
       if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
       fp=LastFace; while(fp < Nface){
         for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_face_colour[i];
         fp++;
       }
       LastFace=Nface;
     }
     DeselectVertexSet(fBevelStart,fBevelStop);
   }
   else if(lpTtf->TTF_cap && !capped){
     SelectVertexSet(Vstart,Vstop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(Vstart,Vstop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   if((lpTtf->FORB > 0 && lpTtf->TTF_bevel_back) ||
      (lpTtf->FORB < 0 && lpTtf->TTF_bevel_front)){
     SelectVertexSet(BackStart,BackStop);
     fBevelStart=Nvert; LastFace=Nface;
     if(AutoFacetCurveWithHoles(3,0,1,(double)(lpTtf->TTF_bevel_angle * -1),
       (double)lpTtf->TTF_bevel_width/2000.0*MaxScale*Scale) == FAIL)break;
     fBevelStop=Nvert;
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_beve_colour[i];
//       (MainFp+fp)->attrib |= 0x80;
       fp++;
     }
     LastFace=Nface;
     if(lpTtf->TTF_cap){
       if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
       fp=LastFace; while(fp < Nface){
         for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_face_colour[i];
         fp++;
       }
       LastFace=Nface;
     }
     DeselectVertexSet(fBevelStart,fBevelStop);
   }
   else if(lpTtf->TTF_cap && !capped){
     SelectVertexSet(BackStart,BackStop);
     LastFace=Nface;
     if(AutoFacetCurveWithHoles(0,0,1,0.0,0.0) == FAIL)break;
     DeselectVertexSet(BackStart,BackStop);
     fp=LastFace; while(fp < Nface){
       for(i=0;i<3;i++)(MainFp+fp)->color[i]=lpTtf->TTF_face_colour[i];
       fp++;
     }
     LastFace=Nface;
   }
   SPACEBREAK:
   VP=Vstart; while(VP < Nvert){
     (MainVp+VP)->sp=sp;
     VP++;
   }
   DrawModel();
 }
 SelectVertexSet(Vfirst,Nvert);
 NpointerX=Opx; NpointerY=Opy; NpointerZ=Opz;
 return;
}

static void GetTTFholdPoint(long *x, long *y, long cx, long cy, short pt){
  long x0,y0;
  double offx[]={0.0,0.5,1.0,  0.5,  0.0  ,0.5,  1.0};
  double offy[]={0.0,0.0,0.0,300.0,600.0,600.0,600.0};
  x0=NpointerY-cx*lpTtf->FORB;
  y0=NpointerZ-cy;
  if(pt == 0){
   *x=x0+(long)(offx[lpTtf->TTF_offset]*(double)cx)*lpTtf->FORB;
   *y=y0+(long)(offy[lpTtf->TTF_offset]*Scale);
  }
  else{ /* follow point */
   *x=x0+(long)((offx[lpTtf->TTF_offset]+1.0)*(double)cx)*lpTtf->FORB;
   *y=y0+(long)(offy[lpTtf->TTF_offset]*Scale+(double)cy);
  }
}

//#define UNITL 65536.0
#define UNITL 32000.0
#define UNITP 1000.0

static void BuildTTFchar(BOOL preview, UINT c){
  HDC hdc;
  HFONT hfont,hfontOld;
  GLYPHMETRICS gm;
//  static MAT2 m2;  // very important for strange bug !!!!!
  MAT2 mymatrix;
  FIXED val_0,val_1;
  BYTE *buffer;
  long zpos,offset;
  long size,csize,npoints,ctype,i,j,vc,vl,vf,maxx;
  long vc_x,vc_y,vl_x,vl_y,vf_x,vf_y;
  vertex *vp;
  val_0.fract=0;val_0.value=0;
  val_1.fract=0;val_1.value=1;
  memset(&mymatrix,0,sizeof(MAT2));
  mymatrix.eM11=val_1;
  mymatrix.eM12=val_0;
  mymatrix.eM21=val_0;
  mymatrix.eM22=val_1;
  if(c == ' '){
    Cwidthx = 2*(long)(UNITL*0.1);
    return;
  }
  hdc=GetDC(hwndParent);
  hfont=CreateFontIndirect(lpTtf->cf.lpLogFont);
  hfontOld=SelectObject(hdc,hfont);
  offset=NpointerY; zpos=NpointerZ;
  maxx=offset;
  if((size=GetGlyphOutline(hdc,c,GGO_NATIVE,&gm,0,NULL,&mymatrix)) > 0){
    if((buffer = (BYTE *)X__Malloc(size)) != NULL){
      memset(buffer,0,size);
      if((size=GetGlyphOutline(hdc,c,GGO_NATIVE,&gm,size,buffer,&mymatrix)) > 0){
        TTPOLYGONHEADER *lpTT;
        lpTT=(TTPOLYGONHEADER *)buffer;
        while(size > 0){
          TTPOLYCURVE *lpTP;
          POINTFX *lpPFX;
          FIXED fx,fy;
          double x,y,last_x,last_y,off_x,off_y,mid_x,mid_y;
          long x_f,y_f;
          lpPFX = (POINTFX *)(((BYTE *)lpTT) +(2*sizeof(DWORD)));
          memcpy(&fx,&(lpPFX->x),sizeof(FIXED));
          memcpy(&fy,&(lpPFX->y),sizeof(FIXED));
          x=(double)fx.value + (((double)fx.fract)/65525.0);
          y=(double)fy.value + (((double)fy.fract)/65525.0);
          // First point
          if(preview){
           vc_x=vl_x=vf_x=(long)(x*UNITP);
           vc_y=vl_y=vf_y=(long)(y*UNITP);
          }
          else{
            UpdateVertexHeap(Nvert+1);
            CreateVertex();
            vl=Nvert-1;
            vp=(MainVp+vl);
            vp->xyz[0]=NpointerX;
            x_f=vp->xyz[1]=offset+(long)(x*UNITL);
            y_f=vp->xyz[2]=zpos+(long)(y*UNITL);
            maxx=max(maxx,vp->xyz[1]);
            vc=vf=vl;
          }
          last_x=x; last_y=y;
          csize=lpTT->cb - sizeof(TTPOLYGONHEADER);
          lpTP=(TTPOLYCURVE *)(((BYTE*)lpTT)+sizeof(TTPOLYGONHEADER));
          while(csize > 0){
            npoints=(long)(lpTP->cpfx);
            ctype=(long)lpTP->wType;
            lpPFX = (POINTFX *)(((BYTE *)lpTP) +(2*sizeof(WORD)));
            for(i=0;i<npoints;i++){
              memcpy(&fx,&(lpPFX->x),sizeof(FIXED));
              memcpy(&fy,&(lpPFX->y),sizeof(FIXED));
              x=(double)fx.value + (((double)fx.fract)/65525.0);
              y=(double)fy.value + (((double)fy.fract)/65525.0);
              if(ctype == 2){
                if(i > 0){
                  if(i < npoints-1){
                    mid_x=(off_x + x)*0.5;
                    mid_y=(off_y + y)*0.5;
                  }
                  else{
                    mid_x=x;
                    mid_y=y;
                  }
                  //
                  // build spline last  - off  - mid
                  //
                  if(!(x_f == offset+(long)(mid_x*UNITL) &&
                       y_f == zpos+(long)(mid_y*UNITL) )){ // not back at start
                    float ax,bx,cx,ay,by,cy,t,step;
                    ax=(mid_x - 2.0*off_x + last_x);
                    bx=2.0*(off_x - last_x);
                    cx=last_x;
                    ay=(mid_y - 2.0*off_y + last_y);
                    by=2.0*(off_y - last_y);
                    cy=last_y;
                    t=0.0;
                    if(preview)step=5;
                    else       step=3;
                    for(j=0;j<step;j++){
                      t += 1.0/(double)step;
                      mid_x = t*(t*ax + bx) + cx;
                      mid_y = t*(t*ay + by) + cy;
                      if(preview){
                        vc_x=(long)(mid_x*UNITP);
                        vc_y=(long)(mid_y*UNITP);
                        CreateCharacterEdge(vl_x,vl_y,vc_x,vc_y);
                        vl_x=vc_x;
                        vl_y=vc_y;
                      }
                      else{
                        UpdateVertexHeap(Nvert+1);
                        CreateVertex();
                        vc=Nvert-1;
                        vp=(MainVp+vc);
                        vp->xyz[0]=NpointerX;
                        vp->xyz[1]=offset+(long)(mid_x*UNITL);
                        vp->xyz[2]=zpos+(long)(mid_y*UNITL);
                        maxx=max(maxx,vp->xyz[1]);
                        UpdateEdgeHeap(Nedge+1);
                        CreateEdge(vc,vl);
                        vl=vc;
                      }
                    }
                  }
                  //
                  //
                  last_x=mid_x; last_y=mid_y;
                }
                off_x=x; off_y=y;
              }
              else{
                if(preview){
                  vc_x=(long)(x*UNITP);
                  vc_y=(long)(y*UNITP);
                  CreateCharacterEdge(vl_x,vl_y,vc_x,vc_y);
                  vl_x=vc_x;
                  vl_y=vc_y;
                }
                else{
                  UpdateVertexHeap(Nvert+1);
                  CreateVertex();
                  vc=Nvert-1;
                  vp=(MainVp+vc);
                  vp->xyz[0]=NpointerX;
                  vp->xyz[1]=offset+(long)(x*UNITL);
                  vp->xyz[2]=zpos+(long)(y*UNITL);
                  maxx=max(maxx,vp->xyz[1]);
                  UpdateEdgeHeap(Nedge+1);
                  CreateEdge(vc,vl);
                  vl=vc;
                }
                last_x=x; last_y=y;
              }
              lpPFX++;
            }
            csize -= (2*sizeof(WORD) + npoints*sizeof(POINTFX));
            lpTP = (TTPOLYCURVE *)(((BYTE *)lpTP) +
                   (2*sizeof(WORD) + npoints*sizeof(POINTFX)));
          }
          if(preview){
            CreateCharacterEdge(vf_x,vf_y,vl_x,vl_y);
          }
          else{
            UpdateEdgeHeap(Nedge+1);
            CreateEdge(vl,vf);
          }
          size -= lpTT->cb;
          lpTT=(TTPOLYGONHEADER *)(((BYTE *)lpTT) + lpTT->cb);
        }
      }
      X__Free(buffer);
    }
  }
  Cwidthx = maxx-offset;
  SelectObject(hdc,hfontOld);
  DeleteObject(hfont);
  ReleaseDC(hwndParent,hdc);
  return;
}

#if 0
float ax,bx,cx,ay,by,cy,t;
#if 0
cx=3.0*(0.6*(off_x-last_x)+last_x - last_x);
bx=3.0*(0.4*(mid_x-off_x)+off_x - 0.6*(off_x-last_x) - last_x) - cx;
ax=(mid_x - last_x)-bx-cx;
cy=3.0*(0.6*(off_y-last_y)+last_y - last_y);
by=3.0*(0.4*(mid_y-off_y)+off_y - 0.6*(off_y-last_y) - last_y) - cy;
ay=(mid_y - last_y)-by-cy;
#else
ax=(mid_x - 2.0*off_x + last_x);
bx=2.0*(off_x - last_x);
cx=last_x;
ay=(mid_y - 2.0*off_y + last_y);
by=2.0*(off_y - last_y);
cy=last_y;
#endif
t=0.0;
for(j=0;j<5;j++){
  t += 0.2;
//   mid_x = t*(t*(t*ax + bx) + cx) + last_x;
//  mid_y = t*(t*(t*ay + by) + cy) + last_y;
  mid_x = t*(t*ax + bx) + cx;
  mid_y = t*(t*ay + by) + cy;
  vc_x=(long)(mid_x*UNITP);
  vc_y=(long)(mid_y*UNITP);
  CreateCharacterEdge(vl_x,vl_y,vc_x,vc_y);
  vl_x=vc_x;
  vl_y=vc_y;
}
                      vc_x=(long)(mid_x*UNITP);
                      vc_y=(long)(mid_y*UNITP);
                      CreateCharacterEdge(vl_x,vl_y,vc_x,vc_y);
                      vl_x=vc_x;
                      vl_y=vc_y;
#endif

#if 0
static TTF_STRUCTURE TtfStructure;

BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
  hwndParent=parent_window;
  lpTtf=&TtfStructure;

  ZeroMemory(lpTtf,sizeof(TTF_STRUCTURE));
  lpTtf->TTF_face_colour[0]=255;
  lpTtf->TTF_side_colour[2]=255;
  lpTtf->TTF_beve_colour[0]=255;
  lpTtf->TTF_beve_colour[1]=255;
  lpTtf->TTF_bevel_angle=45;
  lpTtf->TTF_char_preview='Q';
  lpTtf->FORB=1;
  lpTtf->TTF_cap=1;
  strcpy(lpTtf->TTF_Letters,"");

#endif