TTFX.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.
-- */

/*  TTFX.C  */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <windows.h>

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

#include "ttf.h"

#define DESELECTED 0
#define SELECTED   1

#define UNITL 65536.0

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


static HWND      hParent;
static HINSTANCE hThisInstance;

#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;
      if(hDLL == NULL)MessageBox ( GetFocus()," NULL instance",NULL, MB_OK);
      break;
    }
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 CHOOSEFONT cf;
 LOGFONT    lf;
 char stxx[256],*pcc;
 lpEVI=lpevi;
 hParent=parent_window;
 memset(&cf,0,sizeof(CHOOSEFONT));
 memset(&lf,0,sizeof(LOGFONT));
 cf.lStructSize=sizeof(CHOOSEFONT);
 cf.hwndOwner=hParent;
 cf.lpLogFont=&lf;
 cf.iPointSize=10;
 cf.Flags=CF_SCREENFONTS|CF_TTONLY;
 cf.nFontType=SCREEN_FONTTYPE;
 if(ChooseFont(&cf)){
  HDC hdc;
  HFONT hfont,hfontOld;
  GLYPHMETRICS gm;
  static MAT2 m2;  // very important for strange bug !!!!!
  BYTE *buffer,c;
  long zpos,offset,dmax;
  long size,csize,npoints,ctype,i,j,vc,vl,vf,maxx;
  vertex *vp;
  hdc=GetDC(hParent);
  hfont=CreateFontIndirect(cf.lpLogFont);
  hfontOld=SelectObject(hdc,hfont);

  strcpy(stxx,"RSF 1234 abc");

  offset=NpointerY; zpos=NpointerZ;

  pcc=stxx;

  while((c = (BYTE)(*pcc++)) > 0){
  if(c == ' '){
    offset += 2*(long)(UNITL*0.1);
  }
  else{

  maxx=offset; dmax=(long)(UNITL*0.1);
  if((size=GetGlyphOutline(hdc,c,GGO_NATIVE,&gm,0,NULL,&m2)) > 0){
    if((buffer = (BYTE *)X__Malloc(size)) != NULL){
      memset(buffer,0,size);
      if((size=GetGlyphOutline(hdc,c,GGO_NATIVE,&gm,size,buffer,&m2)) > 0){
        //FILE *ff;
        TTPOLYGONHEADER *lpTT;
        //ff=fopen("d:\\debug","w");
        lpTT=(TTPOLYGONHEADER *)buffer;
        //fprintf(ff,"Size %ld\n",size);
        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;
          //fprintf(ff,"Polygon Header %ld bytes  Type %ld\n",lpTT->cb,lpTT->dwType);
          lpPFX = (POINTFX *)(((BYTE *)lpTT) +(2*sizeof(DWORD)));
          memcpy(&fx,&(lpPFX->x),sizeof(FIXED));
          memcpy(&fy,&(lpPFX->y),sizeof(FIXED));
          //fprintf(ff,"%ld %ld     %ld %ld\n",fx.value,fx.fract,fy.value,fy.fract);
          x=(double)fx.value + (((double)fx.fract)/65525.0);
          y=(double)fy.value + (((double)fy.fract)/65525.0);
          //fprintf(ff,"Start Point x=%lf y=%lf\n",x,y);
          UpdateVertexHeap(Nvert+1);
          CreateVertex();    // First point
          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;
            //fprintf(ff,"Curve type %ld with %ld points\n",(long)lpTP->wType,npoints);
            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);
              //fprintf(ff,"Point x=%lf y=%lf\n",x,y);
              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
                    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{
                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)));
          }
          UpdateEdgeHeap(Nedge+1);
          CreateEdge(vl,vf);
          size -= lpTT->cb;
          lpTT=(TTPOLYGONHEADER *)(((BYTE *)lpTT) + lpTT->cb);
        }
        //fclose(ff);
      }
      X__Free(buffer);
    }
  }
  offset=maxx+dmax;

  }
  }

  SelectObject(hdc,hfontOld);
  DeleteObject(hfont);
  ReleaseDC(hParent,hdc);
 }
 return TRUE;
}