SETUP.C

Go to the documentation of this file.

/* file SETUP/C  functions to setup the animator   */

#define MODULE_SETUP 1

#include "animate.h"
#include "callall.h"

extern UINT AnimationTimer;

#include "memory.c"

static long palette256[16]={
  0x00c0c0c0,  /* screen     brush */
  0x00808080,  /* window     brush */
  0x0000ffff,  /* selected   brush */
  0x00ffff00,  /* deselected brush */
  0x00ffffff,  /* invert     brush */
  0x0000ffff,  /* selected   pen   */
  0x00ffff00,  /* deselected pen   */
  0x0000ff00,  /* edit       pen   */
  0x00ffffff,  /* wireframe  pen   */
  0x00808080,  /* cursor     pen   */
  0x00808080,  /* invert     pen   */
  0x007c3c00,  /* robot     brush */
  0x00c0c0c0,  /* grid1      pen   */
//  0x00404040,  /* grid2      pen   */
//  0x00a0a0a0,  /* grid2      pen   */
  0x00b0b0b0,  /* grid2      pen   */
  0x0,0x0};

static long palette24b[16]={
  0x00c0c0c0,  /* screen     brush */
//  0x007c3c00,  /* screen     brush */
  0x00606060,  /* window     brush */
  0x0000ffff,  /* selected   brush */
  0x00ffff00,  /* deselected brush */
  0x00ffffff,  /* invert     brush */
  0x0000ffff,  /* selected   pen   */
  0x00ffff00,  /* deselected pen   */
  0x0000ff00,  /* edit       pen   */
  0x00f0f0f0,  /* wireframe  pen   */
  0x0000ff00,  /* cursor     pen   */
  0x0000ffff,  /* invert     pen   */
  0x007c3c00,  /* robot     brush */
  0x00767676,  /* grid1 118  pen   */
  0x00979797,  /* grid2 151  pen   */
  0x0,0x0};

#define PALVERSION 0x300

#define X__C(p,i) RGB(p->palPalEntry[i].peRed,   \
                       p->palPalEntry[i].peGreen, \
                       p->palPalEntry[i].peBlue)

// Create the Application palette for screens and drawing modes.

HPALETTE CreateAppPalette(int *ScreenX, int *ScreenY){
 char *cstr[16]={
                "screen",
                "window",
                "selected",
                "deselected",
                "invert",
                "selected",
                "deselected",
                "edit",
                "wireframe",
                "cursor",
                "invert",
                "robot",
                "grid1",
                "grid2",
                "un",
                "un"
                };
 char strng[64];
 LOGPALETTE *pPal;
 HPALETTE   hpal = NULL;
 WORD       nNumColors;
 BYTE red,green,blue;
 HWND hDesktopWnd;
 HDC hDCcaps;
 int  i,Dbits;
 long c,*palette;
 nNumColors = 256;
 pPal = (LOGPALETTE*)LocalAlloc(LPTR,sizeof(LOGPALETTE) +
                     nNumColors * sizeof(PALETTEENTRY));
 if(pPal == NULL)return NULL;
 pPal->palNumEntries = nNumColors;
 pPal->palVersion    = PALVERSION;
 red = green = blue = 0;
 for(i=0;i<256;i++){
   pPal->palPalEntry[i].peRed   = red;
   pPal->palPalEntry[i].peGreen = green;
   pPal->palPalEntry[i].peBlue  = blue;
   pPal->palPalEntry[i].peFlags = (BYTE)0;
   if (!(red += 32))if (!(green += 32)) blue += 64;
 }
 hDesktopWnd = GetDesktopWindow();
 hDCcaps     = GetDC(hDesktopWnd);
 Dbits = GetDeviceCaps(hDCcaps,BITSPIXEL);
 *ScreenX = GetDeviceCaps(hDCcaps,HORZRES);
 *ScreenY = GetDeviceCaps(hDCcaps,VERTRES);
 ReleaseDC(hDesktopWnd,hDCcaps);
 if(Dbits <= 8)palette=palette256;
 else          palette=palette24b;
 for(i = 0; i < 16; i++){
   GetPrivateProfileString("ACOLOURS",cstr[i],"$$$",
                    strng,sizeof(strng),IniFilename);
   // don't read any screen colours - just use the default 
   if(1){//  if(strncmp(strng,"$$$",3) == 0){
     pPal->palPalEntry[i].peRed   = (unsigned char)( palette[i]        & 0xff);
     pPal->palPalEntry[i].peGreen = (unsigned char)((palette[i] >> 8)  & 0xff);
     pPal->palPalEntry[i].peBlue  = (unsigned char)((palette[i] >> 16) & 0xff);
     pPal->palPalEntry[i].peFlags = (BYTE)0;
   }
   else{
     int r,g,b;
     sscanf(strng,"%ld %ld %ld",&r,&g,&b);
     pPal->palPalEntry[i].peRed   = (unsigned char)(r&0xff);
     pPal->palPalEntry[i].peGreen = (unsigned char)(g&0xff);
     pPal->palPalEntry[i].peBlue  = (unsigned char)(b&0xff);
     pPal->palPalEntry[i].peFlags = (BYTE)0;
   }
 }
 for(c=0,i=16;i<32;i++,c+=16){
   pPal->palPalEntry[i].peRed   = c;
   pPal->palPalEntry[i].peGreen = c;
   pPal->palPalEntry[i].peBlue  = c;
   pPal->palPalEntry[i].peFlags = (BYTE)0;
 }
 hpal = CreatePalette(pPal);
 ghbrushScreen     = CreateSolidBrush(RGB(pPal->palPalEntry[0].peRed,pPal->palPalEntry[0].peGreen,pPal->palPalEntry[0].peBlue));
 ghbrushWindow     = CreateSolidBrush(RGB(pPal->palPalEntry[1].peRed,pPal->palPalEntry[1].peGreen,pPal->palPalEntry[1].peBlue));
 ghSelectedBrush   = CreateSolidBrush(RGB(pPal->palPalEntry[2].peRed,pPal->palPalEntry[2].peGreen,pPal->palPalEntry[2].peBlue));
 ghDeselectedBrush = CreateSolidBrush(RGB(pPal->palPalEntry[3].peRed,pPal->palPalEntry[3].peGreen,pPal->palPalEntry[3].peBlue));
 ghInvertBrush     = CreateSolidBrush(RGB(pPal->palPalEntry[4].peRed,pPal->palPalEntry[4].peGreen,pPal->palPalEntry[4].peBlue));
 ghRobotBrush      = CreateSolidBrush(RGB(pPal->palPalEntry[11].peRed,pPal->palPalEntry[11].peGreen,pPal->palPalEntry[11].peBlue));
 ghSelectedPen     = CreatePen(PS_SOLID,0,X__C(pPal, 5));
 ghDeselectedPen   = CreatePen(PS_SOLID,0,RGB(pPal->palPalEntry[6].peRed,pPal->palPalEntry[6].peGreen,pPal->palPalEntry[6].peBlue));
 ghEditPen         = CreatePen(PS_SOLID,0,RGB(pPal->palPalEntry[7].peRed,pPal->palPalEntry[7].peGreen,pPal->palPalEntry[7].peBlue));
 ghWireframePen    = CreatePen(PS_SOLID,0,RGB(pPal->palPalEntry[8].peRed,pPal->palPalEntry[8].peGreen,pPal->palPalEntry[8].peBlue));
 ghCursorPen       = CreatePen(PS_SOLID,0,RGB(pPal->palPalEntry[9].peRed,pPal->palPalEntry[9].peGreen,pPal->palPalEntry[9].peBlue));
 ghInvertPen       = CreatePen(PS_SOLID,0,RGB(pPal->palPalEntry[10].peRed,pPal->palPalEntry[10].peGreen,pPal->palPalEntry[10].peBlue));
 ghDotSelectedPen  = CreatePen(PS_DOT,0,RGB(pPal->palPalEntry[5].peRed,pPal->palPalEntry[5].peGreen,pPal->palPalEntry[5].peBlue));
 ghDotDeselectedPen= CreatePen(PS_DOT,0,RGB(pPal->palPalEntry[6].peRed,pPal->palPalEntry[6].peGreen,pPal->palPalEntry[6].peBlue));
 ghDotInvertPen    = CreatePen(PS_DOT,0,RGB(pPal->palPalEntry[10].peRed,pPal->palPalEntry[10].peGreen,pPal->palPalEntry[10].peBlue));
 gScreenColourRef=(COLORREF)palette[1];
 gGridColourRef1=X__C(pPal,12);
 gGridColourRef2=X__C(pPal,13);
// gGridColourRef1=(COLORREF)palette[12];
// gGridColourRef2=(COLORREF)palette[13];
 LocalFree((HANDLE)pPal);
 return hpal;
}

void SetupStructures(void){
 ANI_STRUCTURE *lpEVI;
 X__MEMORY_MANAGER *lpEVIMM;
 lpEVI=&AniStructure;
 lpEVI->gszHomeDir=gszHomeDir;
 lpEVI->Nnodes = &Nnodes;
 lpEVI->Nground = &Nground;
 lpEVI->Nrobots = &Nrobots;
 lpEVI->Nskys =   &Nskys;
 lpEVI->Ncameras = &Ncameras;
 lpEVI->Ndirectors = &Ndirectors;
 lpEVI->MainNp = &MainNp;
 lpEVI->FirstNp = &FirstNp;
 lpEVI->SelectedNode=&SelectedNode;
 lpEVI->SelectedCamera=&SelectedCamera;
 lpEVI->Nframes = &Nframes;
 lpEVI->CurrentFrame = &CurrentFrame;
 lpEVI->NpointerX=&NpointerX;
 lpEVI->NpointerY=&NpointerY;
 lpEVI->NpointerZ=&NpointerZ;
 lpEVI->TVpointX=&TVpointX;
 lpEVI->TVpointY=&TVpointY;
 lpEVI->TVpointZ=&TVpointZ;
 lpEVI->TVsizeX=&TVsizeX;
 lpEVI->TVsizeY=&TVsizeY;
 lpEVI->TVsizeZ=&TVsizeZ;
 lpEVI->ruler=&ruler;
 lpEVI->rulerx=&rulerx; lpEVI->rulery=&rulery; lpEVI->rulerz=&rulerz;
 lpEVI->orulerx=&lrulerx; lpEVI->orulery=&lrulery; lpEVI->orulerz=&lrulerz;
#if __LITE__
 lpEVI->version=0;
#else
 lpEVI->version=1;
#endif
// 63 dummies
 lpEVI->fpGetTransform=GetTransform;
 lpEVI->fp_scal=scal;
 lpEVI->fp_rotz=rotz;
 lpEVI->fp_roty=roty;
 lpEVI->fp_rotx=rotx;
 lpEVI->fp_tram=tram;
 lpEVI->fp_m4by4=m4by4;
 lpEVI->fp_m4by1=m4by1;
 lpEVI->fp_null_transform=null_transform;
 lpEVI->fp_c4to4=c4to4;
 lpEVI->fp_arbitrary_rotate=arbitrary_rotate;
 lpEVI->fp_L_cross=L_cross;
 lpEVI->fpDrawPerspectiveView=DrawPerspectiveView;
 lpEVI->fpDeleteCostume=DeleteCostume;
 lpEVI->fpCreateCostume=CreateCostume;
 lpEVI->fpDeleteSize=DeleteSize;
 lpEVI->fpCreateSize=CreateSize;
 lpEVI->fpDeleteAlign=DeleteAlign;
 lpEVI->fpCreateAlign=CreateAlign;
 lpEVI->fpDeletePosition=DeletePosition;
 lpEVI->fpCreatePosition=CreatePosition;
 lpEVI->fpDeleteSky=DeleteSky;
 lpEVI->fpCreateSky=CreateSky;
 lpEVI->fpDeleteNode=DeleteNode;
 lpEVI->fpCreateNode=CreateNode;
 lpEVI->fpCreatePathEditControlPoint=CreatePathEditControlPoint;
 lpEVI->fpDeletePathEditControlPoint=DeletePathEditControlPoint;
 lpEVI->fpAppendPathPoint=AppendPathPoint;
 lpEVI->fpCreatePathPoint=CreatePathPoint;
 lpEVI->fpDeletePathPoint=DeletePathPoint;
 lpEVI->fpCreateIPointPath=CreateIPointPath;
 lpEVI->fpSetNumberOfFrames=SetNumberOfFrames;
 lpEVI->fpChooseFile=SelectFileName;
 lpEVI->fpLoadMeshObject=LoadMeshObject;
 lpEVI->fpChooseColour=SetColour;
 lpEVI->fpRequestNumEntry=RequestNumEntry;
 lpEVI->fpSelectNodeID=SelectNodeID;

 lpEVI->fpAppendFileExtension=AppendFileExtension;
 lpEVI->fpCentreDlgOnC=CentreDialogOnCursor;
 lpEVI->fpCentreDlgOnS=CentreDialogOnScreen;
// 64 dummies

 lpEVIMM=&EviMemoryManager;
 lpEVIMM->lpAni=(void *)lpEVI;
 lpEVIMM->lpMod=NULL;
 lpEVIMM->fpMalloc=X__AllocateRam;
 lpEVIMM->fpFree=X__FreeRam;
}

void UpdateGLview(BOOL full){
#if 0
 static BOOL in_use=FALSE;
 if(ghwndOpenGLview == NULL)return;
 if(!IsWindow(ghwndOpenGLview))return;
 UpdateFrameBox();
 if(!in_use){
   in_use=TRUE;
   if(!full){ /* draw a wire frame using NON Open GL function    */
     /* if playing in non bounding box mode Animation timer > 1  */
     /* so tell the OGL DLL to render full wireframe WM_WIREFULL */
     /* otherwise draw as a bounding box                         */
     if(AnimationTimer > 1)PostMessage(ghwndOpenGLview,(WM_USER+4),0,0);
     else                  PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
   }
   else{
     MakeScript(5,1);
     PostMessage(ghwndOpenGLview,(WM_USER+1),0,0);
   }
   in_use=FALSE;
 }
#endif
}

BOOL EnableGLview(void){
 DWORD version;
 version=GetVersion();
 return FALSE;
#if 0
 if((version & 0x80000000) == 0x80000000){ /* NOT NT */
   if(LOBYTE(LOWORD(version)) < 4)return FALSE;
 }
 else if(LOBYTE(LOWORD(version)) < 4 &&
      HIBYTE(LOWORD(version)) < 11)return FALSE;  /* NOT >=  NT 3.5 */
 {char sysdir[256];
  HANDLE hfbm;
  strcpy(sysdir,"opengl32.dll");
  hfbm=CreateFile(sysdir,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
      FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
  if(hfbm == INVALID_HANDLE_VALUE){
    GetSystemDirectory(sysdir,256); strcat(sysdir,"\\opengl32.dll");
    hfbm=CreateFile(sysdir,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
        FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
    if(hfbm == INVALID_HANDLE_VALUE)return FALSE;
    CloseHandle(hfbm);
  }
  else CloseHandle(hfbm);
 }
 EnableMenuItem(GetMenu(ghwnd_main),IDM_WINDOW_SHOWOPENGL,MF_ENABLED);
 EnableMenuItem(GetMenu(ghwnd_main),IDM_FILE_EXP_OPENGL,MF_ENABLED);
 //EnableMenuItem(GetMenu(ghwnd_main),IDM_FILE_PLAYAVI,MF_ENABLED);  // REMOVED
 //EnableMenuItem(GetMenu(ghwnd_main),IDM_FILE_FLI2AVI,MF_ENABLED);  // REMOVED
 return TRUE;
#endif
}

void StartGLview(BOOL first_time){
#if 0
 char lname[256],str[64],text[128];
 char oldname[256],newname[256];
 RECT rc;
 HWND hwnd=NULL;
 static HMODULE hLib=NULL;
 FARPROC fpFun;
 ANI_STRUCTURE *Evs;
 HWND (*fpFun1)(HWND, LPRECT, ANI_STRUCTURE *);
 DWORD version;
 version=GetVersion();
 if((version & 0x80000000) == 0x80000000){ /* NOT NT */
   if(LOBYTE(LOWORD(version)) < 4)return; /* < 4 */
 }
 else{
   if(LOBYTE(LOWORD(version)) < 4 &&
      HIBYTE(LOWORD(version)) < 11)return;  /* NOT >=  NT 3.5 */
 }
 GetCurrentDirectory(255,oldname);
 strcpy(newname,gszHomeDir);
 if(SetCurrentDirectory(newname) == FALSE)
   MessageBox(ghwnd_main,newname,NULL,MB_OK);
 {char sysdir[256];
  HANDLE hfbm;
  strcpy(sysdir,"opengl32.dll");
  hfbm=CreateFile(sysdir,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
      FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
  if(hfbm == INVALID_HANDLE_VALUE){
    GetSystemDirectory(sysdir,256); strcat(sysdir,"\\opengl32.dll");
    hfbm=CreateFile(sysdir,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
        FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
    if(hfbm == INVALID_HANDLE_VALUE){
      SetCurrentDirectory(oldname);
      return;  /* no library */
    }
    CloseHandle(hfbm);
  }
  else CloseHandle(hfbm);
 }
 if(hLib != NULL){
   if(ghwndOpenGLview != NULL)DestroyWindow(ghwndOpenGLview);
   ShowWindow(ghwnd_view,SW_SHOWNA);
   LoadString(ghinst_main,IDX_MISC_SHOWOPENGL,text,128);
   ModifyMenu(GetMenu(ghwnd_main),IDM_WINDOW_SHOWOPENGL,
              MF_BYCOMMAND|MF_STRING,IDM_WINDOW_SHOWOPENGL,
              text);
   FreeLibrary(hLib); hLib=NULL;
   ghwndOpenGLview=NULL;
   InvalidateRect(ghwnd_main,NULL,TRUE); 
   PerspectiveView(0,1);
   opengl_visible=0;
   SetCurrentDirectory(oldname);
   return;
 }
 Evs=&AniStructure;
 rc.left=WindowViewXmin;
 rc.top=WindowViewYmin;
 rc.right=WindowViewXsize;
 rc.bottom=WindowViewYsize;
 strcpy(lname,gszHomeDir); strcat(lname,"animategl.dll");
 if((hLib=LoadLibrary(lname)) != NULL){
   if((fpFun=GetProcAddress(hLib,"_AttachViewOpenGL")) != NULL){
     ShowWindow(ghwnd_view,SW_HIDE);
     fpFun1 = (void *)fpFun;
     hwnd=(*fpFun1)(ghwnd_main,&rc,Evs);
   }
   else{
     SendPrgmQuery(IDQ_FAILEDFUNCTION,3);
     FreeLibrary(hLib); hLib=NULL;
   }
 }
 else SendPrgmQuery(IDQ_FAILEDLIBRARY,3);
 ghwndOpenGLview=hwnd;
 UpdateGLview(TRUE);
 if(hwnd != NULL){
   LoadString(ghinst_main,IDX_MISC_HIDEOPENGL,text,128);
   ModifyMenu(GetMenu(ghwnd_main),IDM_WINDOW_SHOWOPENGL,
              MF_BYCOMMAND|MF_STRING,IDM_WINDOW_SHOWOPENGL,
              text);
   opengl_visible=1;
 }
 SetCurrentDirectory(oldname);
#endif
 return;
}

// These funcions are called when the animator is first started
// and just before it closes as the application is terminated

BOOL SetupMainWindow(HANDLE inst, int cmdshow){
 long i;
 RECT rc;
 HDC hdc;
 TEXTMETRIC tm;
// int StatusPartsList[2]={110,-1};
 int StatusPartsList[2]={160,-1};
 Yres=GetSystemMetrics(SM_CYSCREEN);
 Xres=GetSystemMetrics(SM_CXSCREEN);
 if(Xres      < 800 )SelectPointSize=2;
 else if(Xres < 1024)SelectPointSize=3;
 else                SelectPointSize=4;
 if(Xres < 800)WindowGap /= 2;
 View=TRIVIEW; BigCameraView=0;
 ghwndTools=NULL;    ghwndCoord1=NULL;
 ghwndDlgTools=NULL; ghwndQuicktime=NULL;
 ghwnd_current=NULL; ghwndRobotView=NULL;
 ghwndTimeline=NULL; ghwndTimelineChild=NULL;
 ghwndTooltip=NULL;  ghwndSkEdit=NULL;
 ghwnd_main = CreateWindow(
     szMainClass,     /* class */
     "  ",            /* caption */
     WS_OVERLAPPED |  WS_CAPTION | WS_SYSMENU     | WS_THICKFRAME |
     WS_MAXIMIZE   | !WS_VISIBLE | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
     0,
     0,
     Xres,                   /* init. x size */
     Yres,                   /* init. y size */
     NULL,                  /* parent window */
     NULL,                  /* menu handle */
     inst,                  /* program handle */
     NULL                   /* create parms */
     );
 if( !ghwnd_main ) return( FALSE );
 ghwnd_info=CreateWindowEx(0L,STATUSCLASSNAME,"",
    WS_CHILD | !WS_BORDER | WS_VISIBLE,
    0,0,0,0,
    ghwnd_main,
    (HMENU)NULL,
    inst,
    NULL);
 if(!ghwnd_info)return(FALSE);
 SendMessage(ghwnd_info,SB_SETPARTS,(WPARAM)2,(LPARAM)StatusPartsList);
 GetClientRect(ghwnd_info,&rc);
 InfoWindowSize=rc.bottom-rc.top;
 LoadMenuHelpTable(ghwnd_main);
 GetClientRect(ghwnd_main,&rc);
 SetWindowSize(rc.right,rc.bottom,View,TRUE);
 GetTriview(TRUE);
 for(i=0;i<3;i++){
   ghwnd_triview[i] = CreateWindow(
     szTriViewClass,
     NULL,
     WS_CHILD | WS_BORDER | WS_VISIBLE,
     WindowsXmin[i],WindowsYmin[i],WindowSizeX[i],WindowSizeY[i],
     ghwnd_main,
     (HMENU)i,
     inst,
     NULL
   );
   if(!ghwnd_triview[i])return(FALSE);
 }
 ghwnd_view = CreateWindow(
     szViewClass,
     NULL,
     WS_CHILD | WS_BORDER | WS_VISIBLE,
     WindowViewXmin,WindowViewYmin,WindowViewXsize,WindowViewYsize,
     ghwnd_main,
     NULL,
     inst,
     NULL
 );
 if(!ghwnd_view)return(FALSE);
 cmdshow=SW_SHOWMAXIMIZED;
 ghwnd_current=ghwnd_triview[ActiveView];
 ghFont1=CreateFont(-12,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
   ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
   FIXED_PITCH,"MS Sans Serif");
 ghFont2=CreateFont(-12, 0, 0, 0, FW_LIGHT, FALSE, FALSE, FALSE,
      ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
      PROOF_QUALITY, VARIABLE_PITCH | FF_SWISS,
      "Arial");
 if(ghFont1 == NULL || ghFont2 == NULL)return(FALSE);
 ToolboxShow(TRUE);
// SetScrollRange(ghwnd_xscl,SB_CTL,1,1,FALSE);
// SetScrollPos(ghwnd_xscl,SB_CTL,1,FALSE);
 SendMessage(ghwnd_xscl,TBM_SETPOS,FALSE,(LPARAM)1);
 SendMessage(ghwnd_xscl,TBM_SETRANGE,(WPARAM)TRUE,(LPARAM)MAKELONG(1,1));
 if(!ghwndTools)return(FALSE);
 hdc=GetDC(ghwnd_main);
 GetTextMetrics(hdc,&tm);
 ReleaseDC(ghwnd_main,hdc);
 Textwidth  = tm.tmAveCharWidth;
 Textheight = tm.tmHeight;
 ShowWindow( ghwnd_main, cmdshow);
 return TRUE;
}

static PSTR apstr_StringTable[CSTRINGS];
static PSTR apstr_QueryTable[QSTRINGS];
static PSTR apstr_IconHelpTable[ISTRINGS];

void SendPrgmText(PSTR p){
 SendMessage(ghwnd_info,SB_SETTEXT,(WPARAM)1,(LPARAM)p);
}

void SendPrgmMessage(int idString, int where){
 PSTR pstr,p;
 INT cch,string_id;
 idString -= FIRST_IDS_STRING;
 if(apstr_StringTable[idString] != NULL)p=apstr_StringTable[idString];
 else{
   if((pstr = (PSTR)X__Malloc(CCHTEXTMAX)) == NULL)return;
   string_id=idString+FIRST_IDS_STRING;
#if __LITE__
   if(idString == IDS_DEFAULT)string_id=IDS_DEFAULT_LITE;
   if(idString == IDS_CURRENT)string_id=IDS_CURRENT_LITE;
#endif
   if((cch = LoadString(ghinst_main,string_id,pstr,CCHTEXTMAX)) == 0){
     X__Free(pstr);
     return;
   }
   p = apstr_StringTable[idString] = pstr = (PSTR)X__Realloc(pstr, cch + 1);
   if(p == NULL)return;
 }
 if(where == 0)SendMessage(ghwnd_main,WM_SETTEXT,0,(LPARAM)p);
 else SendPrgmText(p);
}

int SendPrgmQuery(int idString, int response){
 int a;
 PSTR pstr,p;
 INT cch;
 char title[128];
 idString -= FIRST_IDQ_STRING;
 if(apstr_QueryTable[idString] != NULL)p=apstr_QueryTable[idString];
 else{
   if((pstr = (PSTR)X__Malloc(CCHTEXTMAX)) == NULL)return 0;
   if((cch = LoadString(ghinst_main,idString+FIRST_IDQ_STRING,pstr,CCHTEXTMAX)) == 0){
     X__Free(pstr);
     return 0;
   }
   p = apstr_QueryTable[idString] = pstr = (PSTR)X__Realloc(pstr, cch + 1);
   if(p == NULL)return 0;
 }
#if __LITE__
 LoadString(ghinst_main,IDS_DEFAULT_LITE,title,127);
#else
 LoadString(ghinst_main,IDS_DEFAULT,title,127);
#endif
 if(response > 0)MessageBeep(MB_ICONQUESTION);
 else            MessageBeep(MB_OK);
 if     (response == 3)a=MessageBox (GetFocus(),p,NULL,
                          MB_OK | MB_ICONEXCLAMATION | MB_TASKMODAL);
 else if(response == 2)a=MessageBox (GetFocus(),p,title,
                          MB_YESNOCANCEL | MB_ICONQUESTION | MB_TASKMODAL);
 else if(response == 1)a=MessageBox (GetFocus(),p,title,
                          MB_YESNO | MB_ICONQUESTION | MB_TASKMODAL);
 else                  a=MessageBox (GetFocus(),p,title,
                          MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
 return a;
}

void SetPrgmMessage(int idString, PSTR pstr){
 int l;
 PSTR p;
 idString -= FIRST_IDS_STRING;
 l=strlen(pstr)+1;
 if(apstr_StringTable[idString] == NULL){
   if((p=(PSTR)X__Malloc(l)) == NULL)return;
 }
 else{
   if((p=(PSTR)X__Realloc(apstr_StringTable[idString],l)) == NULL)return;
 }
 strcpy(p,pstr);
 apstr_StringTable[idString]=p;
}

void SendIconHelpMessage(int idString){
 PSTR pstr,p;
 INT cch;
 RECT rc;
 HDC hdc;
 DWORD syscolour;
 HFONT hfont;
 idString -= FIRST_IDI_STRING;
 if(apstr_IconHelpTable[idString] != NULL)p=apstr_IconHelpTable[idString];
 else{
   if((pstr = (PSTR)X__Malloc(CCHTEXTMAX)) == NULL)return;
   if((cch = LoadString(ghinst_main, idString+FIRST_IDI_STRING,pstr, CCHTEXTMAX)) == 0){
     X__Free(pstr);
     return;
   }
   p = apstr_IconHelpTable[idString] = pstr = (PSTR)X__Realloc(pstr, cch + 1);
   if(p == NULL)return;
 }
 SendMessage(ghwnd_info,SB_SETTEXT,(WPARAM)1,(LPARAM)p);
}

BOOL AnimatorStartup(UINT *screen_ready){
 int i;
 object *Op;
 //debug=fopen("c:\\debug_a.txt","w"); //RSFx
 for(i=0;i<CSTRINGS;i++)apstr_StringTable[i]=NULL;
 for(i=0;i<QSTRINGS;i++)apstr_QueryTable[i]=NULL;
 for(i=0;i<ISTRINGS;i++)apstr_IconHelpTable[i]=NULL;
 ghcurWait=LoadCursor(NULL,IDC_WAIT);
 ghcurArrow=LoadCursor(NULL,IDC_ARROW);
 ghcurCross=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_NONE));
 ghcurX=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_XCROSS));
 ghcurPan=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_PAN));
 ghcurZout=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_ZOOMOUT));
 ghcurZin=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_ZOOMIN));
 ghcurZoom=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_ZOOM));
 ghcurArrow1=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_OPENARROW));
 ghcurMove=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_GRABBER));
 ghcurRotate=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_ROTATOR));
 ghcurScale=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_SIZER));
 ghcurTracker=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_TRACKER));
 ghcurDirector=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_DIRECTOR));
 ghcurPathed=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_PATHED));
 ghcurSkeletor=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_SKELETOR));
 ghcurInsert=LoadCursor(ghinst_main,MAKEINTRESOURCE(IDC_INSERT));
 ghcurTools[0]=ghcurArrow;
 ghcurTools[1]=ghcurArrow1;
 ghcurTools[2]=ghcurPan;
 ghcurTools[3]=ghcurZoom;
 ghcurTools[4]=ghcurMove;
 ghcurTools[5]=ghcurRotate;
 ghcurTools[6]=ghcurScale;
 ghcurTools[7]=ghcurArrow;
 // down to here
 bAbortedDrawing=FALSE;
 if(FindWindow("OFX:ModelerClass",NULL) == NULL)StartedInAnimator=TRUE;
 else StartedInAnimator=FALSE;
 GetModuleFileName(ghinst_main,gszHomeDir,MAX_DIR);
 *FileInPath(gszHomeDir) = '\0';
 gszSTGfile[0]='\0';strcpy(gszSTGdir,gszHomeDir);strcat(gszSTGdir,"animations");
 gszPAKfile[0]='\0';strcpy(gszPAKdir,gszHomeDir);strcat(gszPAKdir,"animations");
 gszSCEfile[0]='\0';strcpy(gszSCEdir,gszHomeDir);strcat(gszSCEdir,"models");
 gszPTHfile[0]='\0';strcpy(gszPTHdir,gszHomeDir);strcat(gszPTHdir,"models");
 gszSCRfile[0]='\0';strcpy(gszSCRdir,gszHomeDir);strcat(gszSCRdir,"scripts");
 gszIMGfile[0]='\0';strcpy(gszIMGdir,gszHomeDir);strcat(gszIMGdir,"images");
 gszMAPfile[0]='\0';strcpy(gszMAPdir,gszHomeDir);strcat(gszMAPdir,"maps");
 gszDLLfile[0]='\0';strcpy(gszDLLdir,gszHomeDir);strcat(gszDLLdir,"effects");
 gszXIPfile[0]='\0';strcpy(gszXIPdir,gszHomeDir);strcat(gszXIPdir,"postprocess");
 gszANIfile[0]='\0';strcpy(gszANIdir,gszHomeDir);strcat(gszANIdir,"animations");
 gszPSTfile[0]='\0';strcpy(gszPSTdir,gszHomeDir);strcat(gszPSTdir,"presets");
 gszPZEfile[0]='\0';strcpy(gszPZEdir,gszHomeDir);strcat(gszPZEdir,"animations");
 gszRSQfile[0]='\0';strcpy(gszRSQdir,gszHomeDir);strcat(gszRSQdir,"animations");  // ROB
 for(i=0;i<N_OBJECTTYPELIST;i++){
   LoadString(ghinst_main,ObjectTypeListID[i],res_str,256);
   ObjectTypeList[i]=(char *)X__Malloc(strlen(res_str)+1);
   if(ObjectTypeList[i] != NULL)strcpy(ObjectTypeList[i],res_str);
 }
 for(i=0;i<NoGroundTexts;i++){
   LoadString(ghinst_main,GroundTextureListID[i],res_str,256);
   GroundTextList[i]=(char *)X__Malloc(strlen(res_str)+1);
   if(GroundTextList[i] != NULL)strcpy(GroundTextList[i],res_str);
 }
 strcpy(gszUndoFile,TempPath);
 strcat(gszUndoFile,"undo_$.ofx");
 PIo180=PI/180.0;
 SetUpWindowBoxView(0);
 gCurTool=gCurCommand=gCurSelect= -1;
 SendPrgmMessage(IDS_DEFAULT,0);
 ScrapEverything();
 SetupStructures();
 if(CreateNode() != NULL){
   strcpy(MainNp->actorname,"Camera ");
   MainNp->type=CAMERA;
   SelectedCamera=MainNp;
   if((Op=CreateCostume(MainNp,1,(short)Nframes)) == NULL)return FALSE;
   Op->type=MainNp->type;
   MainNp->fobj->morph=NO;
   Ncameras=1;
   CreatePosition(MainNp,1,(short)Nframes);
   MainNp->fpos->finish[0]=0;
   MainNp->fpos->finish[1]=-TVsizeY/3;// +TVsizeY/10;
   MainNp->fpos->finish[2]=0;
   MainNp->fpos->type=SPLINE;
   CreateAlign(FirstNp,1,(short)Nframes);
   CreateSize(FirstNp,1,(short)Nframes);
   CreateNode();
   strcpy(MainNp->actorname,"Target");
   MainNp->type=TARGET;
   Op=CreateCostume(MainNp,1,(short)Nframes);
   Op->type=MainNp->type;
   FirstNp->fali->type=TRACK;
   FirstNp->fali->topath=MainNp;
   CreatePosition(MainNp,1,Nframes);
 }
 else return FALSE;
 EDIT_ACTION=NO;
 InitializeLastFilesList();
 DeleteMemoryWindows();
 if(!CreateMemoryWindows()){
   SendPrgmQuery(IDQ_FATALERROR,3);
   return FALSE;
 }
 gToolFlags.flagX=TRUE; gToolFlags.flagY=TRUE; gToolFlags.flagZ=TRUE;
 gToolFlags.flagA=0; gToolFlags.flagT=0; gToolFlags.flagR=0;
 gToolFlags.flagP=0; gToolFlags.flagK=0;
 *screen_ready=1;
 ReDrawStageDisplay(TRUE);
 PerspectiveView(0,0);
 UpdateSelectedActor(FALSE);
 return TRUE;
}

// close all utilities - delete resources and write default properties
// to the ini file.

void AnimatorShutdown(void){
 char ss[32];
 int i;
 if(UNDO_ACTIVE)DeleteFile(gszUndoFile);
 DeleteArrowIcons();
 ScrapEverything();
 DeleteMemoryWindows();
 ToolboxDestroy();
 for(i=0;i<CSTRINGS;i++)
   if(apstr_StringTable[i] != NULL)X__Free(apstr_StringTable[i]);
 for(i=0;i<QSTRINGS;i++)
   if(apstr_QueryTable[i] != NULL)X__Free(apstr_QueryTable[i]);
 for(i=0;i<ISTRINGS;i++)
   if(apstr_IconHelpTable[i] != NULL)X__Free(apstr_IconHelpTable[i]);
 FreeMenuHelpData();
 DeleteObject(ghbrushScreen);
 DeleteObject(ghbrushWindow);
 DeleteObject(ghSelectedBrush);
 DeleteObject(ghDeselectedBrush);
 DeleteObject(ghInvertBrush);
 DeleteObject(ghRobotBrush);
 DeleteObject(ghSelectedPen);
 DeleteObject(ghDeselectedPen);
 DeleteObject(ghEditPen);
 DeleteObject(ghWireframePen);
 DeleteObject(ghCursorPen);
 DeleteObject(ghInvertPen);
 DeleteObject(ghDotSelectedPen);
 DeleteObject(ghDotDeselectedPen);
 DeleteObject(ghDotInvertPen);

 DeleteObject(ghcurCross);
 DeleteObject(ghcurX);
 DeleteObject(ghcurPan);
 DeleteObject(ghcurZout);
 DeleteObject(ghcurZin);
 DeleteObject(ghcurZoom);
 DeleteObject(ghcurArrow1);
 DeleteObject(ghcurMove);
 DeleteObject(ghcurRotate);
 DeleteObject(ghcurScale);
 DeleteObject(ghcurTracker);
 DeleteObject(ghcurDirector);
 DeleteObject(ghcurPathed);
 DeleteObject(ghcurSkeletor);
 DeleteObject(ghcurInsert);

 if(ghFont1 != NULL)DeleteObject(ghFont1);
 if(ghFont2 != NULL)DeleteObject(ghFont2);
 CloseUtilities(0);    /************* all utilities closed now !!!  *******/
 sprintf(ss,"%ld",View);
 WritePrivateProfileString(IniSection,"VIEW",ss,IniFilename);
 sprintf(ss,"%ld",ActiveView);
 WritePrivateProfileString(IniSection,"ACTIVEVIEW",ss,IniFilename);
 if(BigCameraView)
   WritePrivateProfileString(IniSection,"BIGCAMERA","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"BIGCAMERA","NO",IniFilename);
 sprintf(ss,"%ld",FramesPerSec);
 WritePrivateProfileString(IniSection,"FPS",ss,IniFilename);
 if(global_quickdraw)
   WritePrivateProfileString(IniSection,"QUICKDRAW","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"QUICKDRAW","NO",IniFilename);
 if(DrawStatus == 0)
   WritePrivateProfileString(IniSection,"DRAWFULL","NO",IniFilename);
 else
   WritePrivateProfileString(IniSection,"DRAWFULL","YES",IniFilename);
 sprintf(ss,"%ld",AllDrawStatus);
 WritePrivateProfileString(IniSection,"DRAWFULLTYPE",ss,IniFilename);
 if(show_light_cones)
   WritePrivateProfileString(IniSection,"LIGHTCONES","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"LIGHTCONES","NO",IniFilename);
 if(show_camera_fov)
   WritePrivateProfileString(IniSection,"CAMERAFOV","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"CAMERAFOV","NO",IniFilename);
 if(opengl_visible)
   WritePrivateProfileString(IniSection,"OPENGL1","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"OPENGL1","NO",IniFilename);
 if(keyframer_docked)
   WritePrivateProfileString(IniSection,"KEYDOCK","YES",IniFilename);
 else
   WritePrivateProfileString(IniSection,"KEYDOCK","NO",IniFilename);
 sprintf(ss,"%ld",coords_visible);
 WritePrivateProfileString(IniSection,"COORDSVISIBLE",ss,IniFilename);
 sprintf(ss,"%ld",draw_grid_on);
 WritePrivateProfileString(IniSection,"DRAWGRIDON",ss,IniFilename);
 sprintf(ss,"%ld",grid_on);
 WritePrivateProfileString(IniSection,"GRIDON",ss,IniFilename);
 return;
}

// Close all the utility programs including those that are part of
// the ANIMATE.EXE and those that are loaded as separate executables
// the separate exexutables are identified bu looking for a window
// of their specific window class and sending it a message that it
// will recognise as a terminating message.

void CloseUtilities(int what){
 HWND hWndPrev;
 if(IsWindow(ghwndTimeline)){
   if(IsWindowVisible(ghwndTimeline)){
     SendMessage(ghwndTimeline,WM_COMMAND,IDM_TIMELINE_HIDE,0);
   }
   DestroyTimelineEditor();
   if(keyframer_docked)FormatScreen();
 }
 //GL player unloaded along with renderer
 UnloadRenderer();
 hWndPrev = FindWindow("OFX:ModelerClass",NULL);
 if (hWndPrev != NULL){
   SetForegroundWindow(hWndPrev);
   BringWindowToTop(hWndPrev);
   ShowWindow (hWndPrev,SW_SHOW);
   if(StartedInAnimator)PostMessage(hWndPrev,WM_COMMAND,IDM_CALLBACK_SHUTDOWN,0);
 }
 hWndPrev = FindWindow("OFX:FLCPlayer",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,100,0);
 hWndPrev = FindWindow("OFX:ViewClass",NULL);
 if(StartedInAnimator && hWndPrev != NULL)
   PostMessage(hWndPrev,WM_COMMAND,106,0);
 hWndPrev = FindWindow("OFX:AVIPlay",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:Viewer",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:AVIConvertClass",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:GIFConvertClass",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:BuildClass",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:EditSoundClass",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:STV",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 hWndPrev = FindWindow("OFX:MediaPlayerClass",NULL);
 if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,1001,0);
 return;
}