ATM.C

Go to the documentation of this file.

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

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* file ATM.C  ATM font DLL */

#ifdef __BETA35__
#define _DLL
#endif
#include <ctype.h>
#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 "atm.h"
#include "atmdlg.h"

#ifndef PI
#define PI 3.1415926
#endif

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#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
#define LINESIZE 256
#define cgetc()  cdecrypt(egetc())
#define SP type1_stackpointer

static void MakeNewPSletter(HWND);
static void DrawATMfontShapePreview(HDC hdc,RECT rc);
static void DrawATMfontProfilePreview(HDC hdc,RECT rc);
static void LoadATMfontPreviewCharacter(HWND hwnd);
static BOOL CALLBACK AtmDlgProc(HWND hwnd, UINT msg,
                                WPARAM wparam, LPARAM lparam);
static BOOL GetATMfontfile(HWND parent, char *szdir);
static void output_token(char *token);
static short decode_build_type1(int tc, char *PSfile);
static int eexec_scanner(char c);
static int hexval(char c);
static int bgetc(void);
static byte edecrypt(byte cipher);
static byte cdecrypt(byte cipher);
static int immediate_eexec(void);
static int egetc(void);
static void egetline(void);
static void set_lenIV(void);
static int get_character_name(void);
static short add_build_command(int b, int com);
static short do_charstring(void);
static int get_subroutine_number(void);
static int get_Subroutines(void);
static void process_pseudo_routine(character_program Cp);
static void PseudoCurveUpto(point *p, double d, long n, long xx, long yy);
static void CreateCharacterEdge(long x1, long y1, long x2, long y2);
static void Casteljau2(point p, point *va, long i, long j, double mu);

static BITMAP    AtmHelpBitmap;
static HBITMAP   hBitmap=NULL;
static HINSTANCE hThisInstance=NULL;
static HWND      hwndParent=NULL;
static FILE *ifp;
static ATM_STRUCTURE *lpAtm;
static char load_line[LINESIZE],ATMfontDir[255],*szRoot;
static char character_name[64],this_character[64];
static int PS_fail=0,*type1_stack,type1_stack_size=512,SP;
static long  nATM_preview_list=0,nATM_preview_piece=0;
static four_integers *ATM_preview_list=NULL;
static long IVP,IVF,XX,YY,Cwidthx,Cwidthy,Scale=32,Nmax=40;
static double MaxScale=1000.0;

#include "atm1.c"

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 GetATMfontfile(HWND parent, char *szdir){
 int i;
 OPENFILENAME ofn;
 char szFilter[80],szdummy[255];
 szdummy[0]='\0';
 strcpy(szFilter,"(*.PFB)|*.pfb|(*.PFA)|*.pfa|");
 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=lpAtm->last_ATM_font;
 ofn.nMaxFile=255;
 ofn.lpstrFileTitle=szdummy;
 ofn.nMaxFileTitle=255;
 ofn.lpstrInitialDir=szdir;
 ofn.lpstrTitle="PFB Program to Execute";
 ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST;
 i=(int)(GetOpenFileName(&ofn));
 if(i){
   strcpy(szdummy,lpAtm->last_ATM_font);
   *AnsiPrev(szdummy,FileInPath(szdummy)) = '\0';
   strcpy(szdir,szdummy);
   return TRUE;
 }
 return FALSE;
}

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

#if __SC__
#pragma startaddress(DllMain)
#endif

BOOL _ATMbuilder(
  HWND parent, char *szdir, X__STRUCTURE *lpevi, ATM_STRUCTURE *lpatm){
  int i;
  szRoot=szdir;
  hwndParent=parent;
  lpAtm=lpatm;
  lpEVI=lpevi;
  strcpy(ATMfontDir,szdir);
  strcat(ATMfontDir,"fonts");
  if(lpAtm->last_ATM_font[0] == 0){
    if(!GetATMfontfile(parent,ATMfontDir))return FALSE;
  }
  else{
    strcpy(ATMfontDir,lpAtm->last_ATM_font);
    *AnsiPrev(ATMfontDir,FileInPath(ATMfontDir)) = '\0';
  }
  if(DialogBox(hThisInstance,MAKEINTRESOURCE(DLG_ATM),hwndParent,
            (DLGPROC)AtmDlgProc) == OK){
//    MessageBox(parent,lpAtm->ATM_Letters,"ATM",MB_OK);
    MakeNewPSletter(parent);
    return TRUE;
  }
  return FALSE;
}

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 SetAtmColour(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 UpdateAtmSlider(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_ATM_ADOBE_NAME,WM_SETTEXT,0,(LPARAM)load_line);
}

static BOOL CALLBACK AtmDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 RECT rc;
 char str[16];
 int iMin,iMax;
 int hp[7]={DLG_ATM_CPDL,DLG_ATM_CPDC,DLG_ATM_CPDR,DLG_ATM_CPCC,
            DLG_ATM_CPUL,DLG_ATM_CPUC,DLG_ATM_CPUR};
 HWND hctl;
 BITMAP bmp;
 switch( msg ) {
   case WM_INITDIALOG:
     hBitmap=LoadBitmap(hThisInstance,MAKEINTRESOURCE(IDBM_HELP));
     if(hBitmap != NULL){
       GetObject(hBitmap,sizeof(BITMAP),&AtmHelpBitmap);
     }
     LoadATMfontPreviewCharacter(hwnd);
     EnableWindow(GetDlgItem(hwnd,DLG_ATM_ADOBE_NAME),FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_ATM_BEVEL_ANGLE),SB_CTL,5,80,FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_ATM_BEVEL_DEPTH),SB_CTL,0,100,FALSE);
     SetScrollRange(GetDlgItem(hwnd,DLG_ATM_CHAR_WIDTH),SB_CTL,0,100,FALSE);
     SendDlgItemMessage(hwnd,hp[lpAtm->ATM_offset],BM_SETCHECK,TRUE,0);
     UpdateAtmSlider(hwnd,DLG_ATM_BEVEL_ANGLE,DLG_ATM_BEVEL_ANGLEN,
                     lpAtm->ATM_bevel_angle);
     UpdateAtmSlider(hwnd,DLG_ATM_BEVEL_DEPTH,DLG_ATM_BEVEL_DEPTHN,
                     lpAtm->ATM_bevel_width);
     UpdateAtmSlider(hwnd,DLG_ATM_CHAR_WIDTH,DLG_ATM_CHAR_WIDTHN,
                     lpAtm->ATM_chara_width);
     sprintf(str,"%c",lpAtm->ATM_char_preview);
     SendDlgItemMessage(hwnd,DLG_ATM_PREVIEW,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_ATM_FONTID,WM_SETTEXT,0,(LPARAM)lpAtm->last_ATM_font);
     if(lpAtm->FORB > 0)
       SendDlgItemMessage(hwnd,DLG_ATM_LR,BM_SETCHECK,TRUE,0);
     else SendDlgItemMessage(hwnd,DLG_ATM_RL,BM_SETCHECK,TRUE,0);
     if(lpAtm->ATM_bevel_back)
       SendDlgItemMessage(hwnd,DLG_ATM_BEVEL_BACK,BM_SETCHECK,TRUE,0);
     if(lpAtm->ATM_bevel_front)
       SendDlgItemMessage(hwnd,DLG_ATM_BEVEL_FRONT,BM_SETCHECK,TRUE,0);
     if(lpAtm->ATM_cap)
       SendDlgItemMessage(hwnd,DLG_ATM_FILL,BM_SETCHECK,TRUE,0);
     else  SendDlgItemMessage(hwnd,DLG_ATM_NOFILL,BM_SETCHECK,TRUE,0);
     sprintf(str,"%s",lpAtm->ATM_Letters);
     SendDlgItemMessage(hwnd,DLG_ATM_TEXT,WM_SETTEXT,0,(LPARAM)str);
     SendDlgItemMessage(hwnd,DLG_ATM_TEXT,EM_LIMITTEXT,(WPARAM)60,0);
     EnableWindow(GetDlgItem(hwnd,DLG_ATM_MAKE),
                  Edit_LineLength(GetDlgItem(hwnd,DLG_ATM_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_ATM_COLOUR_FACES ||
          lpdis->CtlID == DLG_ATM_COLOUR_SIDES ||
          lpdis->CtlID == DLG_ATM_COLOUR_BEVEL){
         if(lpdis->CtlID == DLG_ATM_COLOUR_FACES){
           r=lpAtm->ATM_face_colour[0];
           g=lpAtm->ATM_face_colour[1];
           b=lpAtm->ATM_face_colour[2];
         }
         else if(lpdis->CtlID == DLG_ATM_COLOUR_SIDES){
           r=lpAtm->ATM_side_colour[0];
           g=lpAtm->ATM_side_colour[1];
           b=lpAtm->ATM_side_colour[2];
         }
         else if(lpdis->CtlID == DLG_ATM_COLOUR_BEVEL){
           r=lpAtm->ATM_beve_colour[0];
           g=lpAtm->ATM_beve_colour[1];
           b=lpAtm->ATM_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_ATM_SHAPE)
         DrawATMfontShapePreview(lpdis->hDC,lpdis->rcItem);
       else if(lpdis->CtlID == DLG_ATM_PROFILE)
         DrawATMfontProfilePreview(lpdis->hDC,lpdis->rcItem);
       else if(lpdis->CtlID == DLG_ATM_INFO && hBitmap != NULL){
         HDC hMemDC;
         HBITMAP hbmOld;
         hMemDC = CreateCompatibleDC(lpdis->hDC);
         hbmOld = SelectObject(hMemDC,hBitmap);
         BitBlt(lpdis->hDC,lpdis->rcItem.left
                          ,lpdis->rcItem.top
                          ,AtmHelpBitmap.bmWidth
                          ,AtmHelpBitmap.bmHeight
                          ,hMemDC,0,0,SRCCOPY);
         SelectObject(hMemDC,hbmOld);
         DeleteDC(hMemDC);
       }
     }
     return TRUE;
   case WM_HSCROLL:
     if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_ATM_BEVEL_ANGLE))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpAtm->ATM_bevel_angle = min(iMax,lpAtm->ATM_bevel_angle+1);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpAtm->ATM_bevel_angle = max(iMin,lpAtm->ATM_bevel_angle-1);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpAtm->ATM_bevel_angle=HIWORD(wparam);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateAtmSlider(hwnd,DLG_ATM_BEVEL_ANGLE,DLG_ATM_BEVEL_ANGLEN,
                       lpAtm->ATM_bevel_angle);
     }
     else if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_ATM_BEVEL_DEPTH))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpAtm->ATM_bevel_width = min(iMax,lpAtm->ATM_bevel_width+1);
           if(lpAtm->ATM_bevel_front || lpAtm->ATM_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpAtm->ATM_bevel_width = max(iMin,lpAtm->ATM_bevel_width-1);
           if(lpAtm->ATM_bevel_front || lpAtm->ATM_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpAtm->ATM_bevel_width=HIWORD(wparam);
           if(lpAtm->ATM_bevel_front || lpAtm->ATM_bevel_back)
             InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateAtmSlider(hwnd,DLG_ATM_BEVEL_DEPTH,DLG_ATM_BEVEL_DEPTHN,
                       lpAtm->ATM_bevel_width);
     }
     else if((HWND)lparam == (hctl=GetDlgItem(hwnd,DLG_ATM_CHAR_WIDTH))){
       GetScrollRange(hctl,SB_CTL,&iMin,&iMax);
       switch (LOWORD(wparam)) {
         case SB_PAGEDOWN:
         case SB_LINEDOWN:
           lpAtm->ATM_chara_width = min(iMax,lpAtm->ATM_chara_width+1);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_PAGEUP:
         case SB_LINEUP:
           lpAtm->ATM_chara_width = max(iMin,lpAtm->ATM_chara_width-1);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         case SB_THUMBTRACK:
         case SB_THUMBPOSITION:
           lpAtm->ATM_chara_width=HIWORD(wparam);
           InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
           break;
         default: break;
       }
       UpdateAtmSlider(hwnd,DLG_ATM_CHAR_WIDTH,DLG_ATM_CHAR_WIDTHN,
                       lpAtm->ATM_chara_width);
     }
     break;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_ATM_CPDL: lpAtm->ATM_offset=0; break;
        case DLG_ATM_CPDC: lpAtm->ATM_offset=1; break;
        case DLG_ATM_CPDR: lpAtm->ATM_offset=2; break;
        case DLG_ATM_CPCC: lpAtm->ATM_offset=3; break;
        case DLG_ATM_CPUL: lpAtm->ATM_offset=4; break;
        case DLG_ATM_CPUC: lpAtm->ATM_offset=5; break;
        case DLG_ATM_CPUR: lpAtm->ATM_offset=6; break;
        case DLG_ATM_BEVEL_FRONT:
          lpAtm->ATM_bevel_front ^= 1;
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
          break;
        case DLG_ATM_BEVEL_BACK:
          lpAtm->ATM_bevel_back ^= 1;
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
          break;
        case DLG_ATM_FILL:
          lpAtm->ATM_cap=1;
          break;
        case DLG_ATM_NOFILL:
          lpAtm->ATM_cap=0;
          break;
        case DLG_ATM_PREVIEW:
          if(Edit_LineLength(GetDlgItem(hwnd,DLG_ATM_PREVIEW),0) > 0){
            GetDlgItemText(hwnd,DLG_ATM_PREVIEW,str,10);
            if(lpAtm->ATM_char_preview != (int)str[0]){
              lpAtm->ATM_char_preview=(int)str[0];
              LoadATMfontPreviewCharacter(hwnd);
              InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
              InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
            }
          }
          break;
        case DLG_ATM_TEXT:
          EnableWindow(GetDlgItem(hwnd,DLG_ATM_MAKE),
                  Edit_LineLength((HWND)(lparam), 0) > 0);
          break;
        case DLG_ATM_CHOOSE:
          if(!GetATMfontfile(hwnd,ATMfontDir)){
            break;
          }
          LoadATMfontPreviewCharacter(hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_SHAPE),NULL,FALSE);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_PROFILE),NULL,FALSE);
          SendDlgItemMessage(hwnd,DLG_ATM_FONTID,WM_SETTEXT,0,
                            (LPARAM)lpAtm->last_ATM_font);
          break;
        case DLG_ATM_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,"::/Add_Postscript_Text.htm");
              HtmlHelp(hwnd,NULL,HH_SET_WIN_TYPE,(DWORD)&hhwin);
              HtmlHelp(hwnd,">MyHelp",HH_DISPLAY_TOPIC,(DWORD)res_str1);
            }
#endif
          }
          break;
        case DLG_ATM_COLOUR_FACES:
          SetAtmColour(lpAtm->ATM_face_colour,"Set Face Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_COLOUR_FACES),NULL,FALSE);
          break;
        case DLG_ATM_COLOUR_BEVEL:
          SetAtmColour(lpAtm->ATM_beve_colour,"Set Bevel Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_COLOUR_BEVEL),NULL,FALSE);
          break;
        case DLG_ATM_COLOUR_SIDES:
          SetAtmColour(lpAtm->ATM_side_colour,"Set Side Color",hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_ATM_COLOUR_SIDES),NULL,FALSE);
          break;
        case DLG_ATM_LR:
          lpAtm->FORB =  1;
          break;
        case DLG_ATM_RL:
          lpAtm->FORB = -1;
          break;
        case DLG_ATM_MAKE:
        case DLG_ATM_CANCEL:
          if(hBitmap != NULL)DeleteObject(hBitmap);
          hBitmap=NULL;
          if(ATM_preview_list != NULL)X__Free(ATM_preview_list);
          ATM_preview_list=NULL; nATM_preview_list=0;
          if(LOWORD(wparam) == DLG_ATM_MAKE){
            GetDlgItemText(hwnd,DLG_ATM_TEXT,lpAtm->ATM_Letters,21);
            EndDialog(hwnd, OK);
          }
          else EndDialog(hwnd, FAIL);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

static void LoadATMfontPreviewCharacter(HWND hwnd){
 int i,ifail;
 if(ATM_preview_list != NULL)X__Free(ATM_preview_list);
 ATM_preview_list=NULL; nATM_preview_list=0; nATM_preview_piece=0;
 n_Subroutines = 0; C_Subs=NULL; Cprogram.n=0; Cprogram.p=NULL;
 if((type1_stack=(int *)X__Malloc(512*sizeof(int))) == NULL){
   MessageBox(hwnd,"Out of memory","ATM",MB_OK);
   return;
 }
 if((ifp = fopen(lpAtm->last_ATM_font,"rb")) != NULL){
   p_key = 0; first_byte = 1; is_pfa = 0; is_pfb = 0;  pfb_remaining = 0;
   reported = 0; in_eexec = 0; start = 1; start_charstring = 0; lenIV = 4;
   in_EncodingArray = 0; in_Subroutines = 0;  in_charstring = 0; PS_fail=0;
   StandardEncoding=0;
   egetline();
   for(i=0;i<60;i++)if(load_line[i] == 13 || load_line[i] == 10){
    load_line[i]=0; break;
   }
   load_line[60]=0;
   UpdateAdobeName(hwnd);
   fclose(ifp);
 }
 if((ifail=decode_build_type1(lpAtm->ATM_char_preview,
                              lpAtm->last_ATM_font)) != OK){
   if(ifail == FAIL)MessageBox(hwnd,"Font corrupt","ATM",MB_OK);
   else if(ifail == MEMFAIL)MessageBox(hwnd,"Out of memory","ATM",MB_OK);
   goto FREEALL;
 }
 SP=0; Cwidthx=0; Cwidthy=0; XX=0; YY=0; IVP = -1; IVF = -1;
 process_pseudo_routine(Cprogram);
 FREEALL:
 X__Free(type1_stack);
 if(Cprogram.p != NULL)X__Free(Cprogram.p);
 if(C_Subs != NULL && n_Subroutines > 0){
   for(i=0;i<n_Subroutines;i++){
     if(C_Subs[i].p != NULL)X__Free(C_Subs[i].p);
   }
   X__Free(C_Subs);
 }
 C_Subs=NULL;
 n_Subroutines=0;
 if(nATM_preview_list > 0){
   long xmin=1000000, ymin=1000000, xmax = -1000000, ymax = -1000000;
   double sx,sy,s;
   for(i=0;i<nATM_preview_list;i++){
     if(ATM_preview_list[i].x1 < xmin)xmin=ATM_preview_list[i].x1;
     if(ATM_preview_list[i].y1 < ymin)ymin=ATM_preview_list[i].y1;
     if(ATM_preview_list[i].x2 > xmax)xmax=ATM_preview_list[i].x2;
     if(ATM_preview_list[i].y2 > ymax)ymax=ATM_preview_list[i].y2;
     sx=(double)(ATM_preview_list[i].x2-ATM_preview_list[i].x1);
     sy=(double)(ATM_preview_list[i].y2-ATM_preview_list[i].y1);
     s=1.0/sqrt(sx*sx+sy*sy);    /* these are the inward pointing normals */
     ATM_preview_list[i].dx = (float)(-sy*s);
     ATM_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<nATM_preview_list;i++){
     ATM_preview_list[i].x1=(long)((double)(ATM_preview_list[i].x1-xmin)*s);
     ATM_preview_list[i].y1=(long)((double)(ATM_preview_list[i].y1-ymin)*s);
     ATM_preview_list[i].x2=(long)((double)(ATM_preview_list[i].x2-xmin)*s);
     ATM_preview_list[i].y2=(long)((double)(ATM_preview_list[i].y2-ymin)*s);
   }
 }
}

static void process_pseudo_routine(character_program Cp){
  int i,com,sid;
  long u,v,w,x,y,z,XX1,YY1;
  for(i=0;i<Cp.n;i++){
    com=(int)Cp.p[i].i;
    if(Cp.p[i].com == 0)type1_stack[SP++] = com;
    else{
      switch(com){
        case 1:  /* hstem */          SP=0; break;     /* ignored */
        case 3:  /* vstem */          SP=0; break;     /* ignored */
        case 4:  /* vmoveto */
          x = 0; y = (long)type1_stack[SP-1];
          goto MOVEJUMP;
        case 5:  /* rlineto */
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          LINEJUMP:
          CreateCharacterEdge(XX,YY,XX+x*Scale,YY+y*Scale);
          if(IVF < 0)IVF=nATM_preview_list-1;
          IVP=nATM_preview_list-1;
          XX += x*Scale; YY += y*Scale;
          SP=0; break;
        case 6:  /* hlineto */
          y = 0; x = (long)type1_stack[SP-1];
          goto LINEJUMP;
        case 7:  /* vlineto */
          x = 0; y = (long)type1_stack[SP-1];
          goto LINEJUMP;
        case 8:  /* rrcurveto */
          u = (long)type1_stack[SP-6];
          v = (long)type1_stack[SP-5];
          w = (long)type1_stack[SP-4];
          x = (long)type1_stack[SP-3];
          y = (long)type1_stack[SP-2];
          z = (long)type1_stack[SP-1];
          CURVEJUMP:
          XX1=XX; YY1=YY;
          PP[0][0]=XX; PP[0][1]=YY; PP[0][2]=0; XX += u*Scale; YY += v*Scale;
          PP[1][0]=XX; PP[1][1]=YY; PP[1][2]=0; XX += w*Scale; YY += x*Scale;
          PP[2][0]=XX; PP[2][1]=YY; PP[2][2]=0; XX += y*Scale; YY += z*Scale;
          PP[3][0]=XX; PP[3][1]=YY; PP[3][2]=0;
          PseudoCurveUpto(PP,MaxScale*Scale,Nmax,XX1,YY1);
          IVP=nATM_preview_list-1;
          SP=0; break;
        case 9:  /* closepath */
          if(IVF == IVP){ /* path already closed */
            SP=0; IVF=IVP = -1;
            nATM_preview_piece=0;
            break;
          }
          if(IVF >= 0 && IVP >= 0){
            CreateCharacterEdge(ATM_preview_list[IVP].x2,
                                ATM_preview_list[IVP].y2,
                                ATM_preview_list[IVF].x1,
                                ATM_preview_list[IVF].y1);
          }
          nATM_preview_piece=0;
          IVF=IVP = -1;
          SP=0; break;
        case 10: /* callsubr */
          /* if other subs return -1 then sub is invalid and not called */
          sid=type1_stack[SP-1];
          SP=0;
          if(sid >= 0 && sid < n_Subroutines)
             process_pseudo_routine(C_Subs[sid]);
          break;
        case 11: /* return */
          SP=0; return;
        case 13: /* hsbw */
          XX = (long)type1_stack[SP-2]*Scale;
          Cwidthx=(long)type1_stack[SP-1]*Scale;
          SP=0; break;
        case 14: /* endchar */
          SP=0; break;  /* this should be the last command anyway */
        case 21: /* rmoveto */
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          MOVEJUMP:
          XX += x*Scale; YY += y*Scale;
          SP=0; break;
        case 22: /* hmoveto */
          y = 0; x = (long)type1_stack[SP-1];
          goto MOVEJUMP;
        case 30: /* vhcurveto */
          u = 0;
          v = (long)type1_stack[SP-4];
          w = (long)type1_stack[SP-3];
          x = (long)type1_stack[SP-2];
          y = (long)type1_stack[SP-1];
          z = 0;
          goto CURVEJUMP;
        case 31: /* hvcurveto */
          u = (long)type1_stack[SP-4];
          v = 0;
          w = (long)type1_stack[SP-3];
          x = (long)type1_stack[SP-2];
          y = 0;
          z = (long)type1_stack[SP-1];
          goto CURVEJUMP;
        case 12:
          i++; com=Cp.p[i].i; /* assume that it is a command */
          switch (com) {
            case 0:  /* dotsection */   SP=0; break;
            case 1:  /* vstem3 */       SP=0; break;
            case 2:  /* hstem3 */       SP=0; break;
            case 6:  /* seac */
              SP=0; break;      /* not implemented */
            case 7:  /* sbw */
              XX = (long)type1_stack[SP-4]*Scale;
              YY = (long)type1_stack[SP-3]*Scale;
              Cwidthx=(long)type1_stack[SP-2]*Scale;
              Cwidthy=(long)type1_stack[SP-1]*Scale;
              SP=0; break;
            case 12: /* div */
              x = (long)type1_stack[SP-2];
              y = (long)type1_stack[SP-1];
              SP -= 1;
              type1_stack[SP-1] = (int)((double)x/(double)y);
              break;
            case 16: /* callothersubr */
              SP=0; break;  /* ignore other sub calls for 3D work; */
            case 17: /* pop  is only used for other subs which we ignore  */
              type1_stack[SP++] = -1; /* push a dummy variable onto stack */
              break;
            case 33: /* setcurrentpoint */
              SP=0; break; /* ignore this it is used with Other subs      */
            default:  SP=0; break;
          }
          break;
        default: SP=0; break;
      }
    }
  }
}

static void PseudoCurveUpto(point *p, double d, long n, long xx, long yy){
 long i,j,N;
 double l=0,mu;
 point po;
 for(i=0;i<3;i++)for(j=0;j<2;j++){
   l += ((double)(p[i+1][j] - p[i][j]))*(double)((p[i+1][j] - p[i][j]));
 }
 N=(long)((sqrt(l)/d)*(double)n);
 N=max(N,2);
 for(i=1;i<=N;i++){
   mu=(double)i/(double)N;
   Casteljau2(po,p,0,3,mu);
   CreateCharacterEdge(xx,yy,po[0],po[1]);
   if(IVF < 0)IVF=nATM_preview_list-1;
   xx=po[0]; yy=po[1];
 }
 return;
}

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(nATM_preview_piece > 0 &&     /* close any gap with last; a bit of a fudge */
   (ATM_preview_list[nATM_preview_list-1].x2 != x1 ||
    ATM_preview_list[nATM_preview_list-1].y2 != y1)){
   if(ATM_preview_list == NULL){
     if((fouri = (four_integers *)X__Malloc(/* silently give up */
       sizeof(four_integers))) == NULL)return;
   }
   else {
     if((fouri = (four_integers *)X__Realloc(ATM_preview_list,
       (nATM_preview_list+1)*sizeof(four_integers))) == NULL)return;
   }
   fouri[nATM_preview_list].x1=fouri[nATM_preview_list-1].x2;
   fouri[nATM_preview_list].y1=fouri[nATM_preview_list-1].y2;
   fouri[nATM_preview_list].x2=x1;
   fouri[nATM_preview_list].y2=y1;
   nATM_preview_list++; nATM_preview_piece++;
   ATM_preview_list=fouri;
 }
 if(ATM_preview_list == NULL){
   if((fouri = (four_integers *)X__Malloc(sizeof(four_integers))) == NULL)return;
 }
 else {
   if((fouri = (four_integers *)X__Realloc(ATM_preview_list,
     (nATM_preview_list+1)*sizeof(four_integers))) == NULL)return;
 }
 fouri[nATM_preview_list].x1=x1;
 fouri[nATM_preview_list].y1=y1;
 fouri[nATM_preview_list].x2=x2;
 fouri[nATM_preview_list].y2=y2;
 nATM_preview_list++; nATM_preview_piece++;
 ATM_preview_list=fouri;
}

static void Casteljau2(point p, point *va, long i, long j, double mu){
  point p1,p2;
  if(j == 1){
    p[0] = (long)((1.0 - mu)*(double)(va[i][0])
                 + mu*(double)(va[i+1][0]));
    p[1] = (long)((1.0 - mu)*(double)(va[i][1])
                 + mu*(double)(va[i+1][1]));
  }
  else{
    Casteljau2(p1,va,i,j-1,mu);
    Casteljau2(p2,va,i+1,j-1,mu);
    p[0]=(long)((1.0 - mu)*(double)p1[0] + mu*(double)p2[0]);
    p[1]=(long)((1.0 - mu)*(double)p1[1] + mu*(double)p2[1]);
  }
}

static void DrawATMfontShapePreview(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)lpAtm->ATM_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(nATM_preview_list > 0 && ATM_preview_list != NULL){
   dy=dx=(double)h/1000.0;
   for(i=0;i<nATM_preview_list;i++){
     xx1=x1+(int)((double)ATM_preview_list[i].x1*dx);
     yy1=y2-(int)((double)ATM_preview_list[i].y1*dy);
     xx2=x1+(int)((double)ATM_preview_list[i].x2*dx);
     yy2=y2-(int)((double)ATM_preview_list[i].y2*dy);
     MoveToEx(hdc,xx1,yy1,NULL); LineTo(hdc,xx2,yy2);
   }
   if(lpAtm->ATM_bevel_width > 0 &&
     (lpAtm->ATM_bevel_back || lpAtm->ATM_bevel_front)){
     bs=1050.0*(double)lpAtm->ATM_bevel_width/4000.0;
     for(i=0;i<nATM_preview_list;i++){
       x=bs*(double)ATM_preview_list[i].dx;
       y=bs*(double)ATM_preview_list[i].dy;
       xx1=x1+(int)((double)ATM_preview_list[i].x1*dx);
       yy1=y2-(int)((double)ATM_preview_list[i].y1*dy);
       xx2=x1+(int)(((double)ATM_preview_list[i].x1+x)*dx);
       yy2=y2-(int)(((double)ATM_preview_list[i].y1+y)*dy);
       MoveToEx(hdc,xx1,yy1,NULL); LineTo(hdc,xx2,yy2);
       xx1=x1+(int)((double)ATM_preview_list[i].x2*dx);
       yy1=y2-(int)((double)ATM_preview_list[i].y2*dy);
       xx2=x1+(int)(((double)ATM_preview_list[i].x2+x)*dx);
       yy2=y2-(int)(((double)ATM_preview_list[i].y2+y)*dy);
       LineTo(hdc,xx2,yy2); LineTo(hdc,xx1,yy1);
     }
   }
 }
 SelectObject(hdc,holdPen);
 DeleteObject(hmyPen);
}

static void DrawATMfontProfilePreview(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)lpAtm->ATM_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(lpAtm->ATM_bevel_width > 0){
   dy=(double)h*(double)lpAtm->ATM_bevel_width/4000.0;
   dx=dy/tan((double)lpAtm->ATM_bevel_angle/180.0*PI);
   if(lpAtm->ATM_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(lpAtm->ATM_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);
}

#include "atm2.c"