WINMAIN.C

Go to the documentation of this file.

/* --
OpenFX Modelling, Animation and Rendering Package
-- */

/* file WINMAIN.C                                                   */
/*      This is the main entry point for the RENDERER module        */
/*      it contains most of the WINDOWS code for the renderer       */
/*      The renderer is easily transportable to other OSs by        */
/*      mostly modifying this file alone + other small changes.     */ 

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <commctrl.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <vfw.h>

#include "update.h"
#include "rmessage.h"
#include "settings.h"
#include "preview.h"
#include "..\common\animate\callall.h"
#include "..\common\animate\spin_dll.h"
#include "..\common\animate\about.h"
#include "..\common\mem.h"
#include "..\animate\memory.h"
#include "..\animate\memory.c"

void UpdateNTFrame(long, long);

static void CentreDialogOnCursor(HWND);
static int SelectFileName(int save, char *szfile, char *szdir,
                          char *szTitle, char *szfilter, HWND parent);
static int SelectDirectoryName(char *szfile, char *szdir,
                          char *szTitle, char *szfilter, HWND parent);
static PSTR FileInPath(PSTR pstrPath);
static BOOL FirstInstance(HANDLE inst);
static long GetCharListID(char *item, char **list, long n);
static void PlayAnimation(char *, long);
static int  BuildAnimation(char *, long, long, long);
static void DisplayOutputFile(void);
static int RendererMainLoop(HINSTANCE hInstance, int wait);

static BOOL InitiateRendererUpdateView(HWND);
static void TerminateRendererUpdateView(void);
static void ExecuteQuickInlineRenderer(HWND,HWND);
static void GetNumberOfScriptFrames(void);
static void UpdateControlDlg(HWND hdlg,BOOL ini);
static void PaintDialogBackground(HWND hDlg, HINSTANCE hInst);
static BOOL CALLBACK TabbedDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam );
static BOOL CALLBACK UpdateDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam );
static BOOL CALLBACK UpdateXDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam );
static BOOL CALLBACK PreferencesDlgProc(HWND hdlg,UINT msg,
                          WPARAM wparam,LPARAM lparam);
static void LoadPreferences(void);

#define MAX_DIR        255
#define MAX_FILE       255
#define NOCOLOUR     32768L

// This is a local definition of the screen buffer structure - see light-fsb.h
typedef struct SCREENBUFFER {
 unsigned char R,G,B,A;
} fullscreenbuffer;


typedef struct tagPARAMLIST {
 long ot,di,re,
      aa,ae,     
      swgp,      
      ns,   // not used - left for compatibility with old settings
      ef,   // not used - left for compatibility with old settings
      bUseOpenGLrender, 
      bDrawDirectly,   
      nv_not_used, // not used 
      sc,   
      al,   
      sd,    
      sb,     
      bCopyGLdepth, 
      xres,yres,   
      zbuffer, // not used now (a Z buffer is ALWAYS used now
      colour0,speed, 
      last_ot;      
 char pic_dir[256],pic_file[256];  
 char fli_dir[256],fli_file[256];
 char scr_dir[256],scr_file[256];
 char tmp_dir[256],tmp_file[256];
 long u3,logfile;     
 long avi_fli;        
 long ntsc_colours;   
 long personal;       
 long blur;           
 long full_mirror;    
 long bUseFBO ;       
 long ob;             
 long callback;       
 long trace_shadows,  
      trace_reflections, 
      trace_refractions, 
      trace_partition,  
      trace_depth,  
      trace_face_count_target,  
      trace_voxel_min_size, 
      trace_unused;
 long jpeg_quality;   
 long tzeros;         
 long Nthreads;       
 long interlace_gif;  
 long tzero_still;    
 long beep_after;     
 long autoshow;       
 long autoplay;       
 long constrain;      
 long avi_low;        
 long avi_compress;   
 long bRenderStereo;  
} PARAMLIST;

// This is the default list of settings for the parameters
static PARAMLIST ParamList={
 0,1,1,  // output type / di / (default resolution 1=second entry)
 2,1,0,  // aa - ae - swp
 0,  // ns (not used now )
 0,  // ef (not used now )
 0,0,  // use openGL render and draw to the screen
 15,
 60,10, // sc al
 50,300,   // sd sb  (shadow density and shadow buffer size 
 0,       // bCopyGLdepth
 800,600, // set the defailt image size
 1,      // zbuffer - not used (alwauy1
 0,5,
 0,   // last ot
 " "," ",
 " "," ",
 " "," ",
 " "," ",
 1,0,  // u3 logfile
 1,  // AVI or FLI
 0,0,0, // blur
 0,   // FBO
 0, // FBO
 0, // Object buffer
 1, // callback
 0,0,0,1, // tracer options  Shadows,reflections,refractions (opts) split
 8,25,4,0,  
 75,
 4,
 0,
 0,
 0,
 0,
 1,1,// autoshow/play
 0,  // constrain
 0,  // NOT Low-res avi
 0,  // NOT compressed AVI
 0   // NOT stereo
},*plp;

FILE *debug=NULL;   // used for ourput to txt file specifically for debugging purposes
unsigned long   *colorstats0;  // used to build a paletted for an output file
unsigned short  *colorstats1;  // NOTE these variables are legacy and are not used now as FLI/FLC are no longer output options
char gszHomeDir[MAX_DIR];      // will contain the home directory of the RENDER.EXE program
HINSTANCE hThisInstance=NULL;  // the instance handle for the RENDERER EXE
HWND hWndOpenGL=NULL;    // handle for the OpenGL output window if rendering to an actual window in the hardware renderer
char TempPath[MAX_DIR];  // Includes the \ at end of path


static FILE *logfile=NULL;
static X__MEMORY_MANAGER EviMemoryManager;
static time_t last_frame_start,start_time;
static HMODULE hLibSpin=NULL;
static HMODULE hLibMeter=NULL;
static HMODULE hLibSetup=NULL;
//static HMODULE hLibAvi=NULL;
static char *szRenderClass="OFX:RenderClass";
static HWND hwndMain=NULL,hwndcontrol=NULL,
            hwndupdate=NULL,hwndupdateX=NULL,
            hwndmeter1=NULL,hwndmeterframes1=NULL,hwndframe1=NULL,
            hwndframeof1=NULL,hwndstatus1=NULL,hwndinfo1=NULL,
            hwndframetime1=NULL,hwndestimate1=NULL,
            hwndmeter2=NULL,hwndmeterframes2=NULL,hwndframe2=NULL,
            hwndframeof2=NULL,hwndstatus2=NULL,hwndinfo2=NULL,
            hwndframetime2=NULL,hwndestimate2=NULL,
            hwndmeter,hwndmeterframes,hwndframe,
            hwndframeof,hwndstatus,hwndinfo,
            hwndframetime,hwndestimate,
            hwndimage=NULL;
static HINSTANCE hResourceInstance=NULL;
static char *gszWorkDrive=NULL;
static long InModeller=0,RendererInUse=0,
            RendererStandAlone=0,RendererAborted=0,
            RendererFirstTime=1,RendererRange=0,
            RendererNotCancelled=0,
            frames=9999,frame_counter=0,current_frame=1,
            first_frame=1,last_frame=9999;
static BOOL LoggingFlag=TRUE;
static BOOL ImmediateFlag=FALSE;
static BOOL update_title=FALSE;

static long Nrlist=9,Nplist=6,Naalist=8,Ndilist=3,Ncolist=3,Nthreadlist=17;
static char *rlist[]={  // rendering resolution list
  "640 x 480",
  "800 x 600",
  "1024 x 768",
  "1280 x 1024",
  "Hi Def TV",
  "NSTC Video",
  "PAL Video",
  "2000 x 1500",
  "                                                                  "
};

static long rxlist[]={640,800,1024,1280,1920,720,720,2000};
static long rylist[]={480,600, 768,1024,1080,480,576,1500};

static char *output_switch[]={ // if changing need to check for "->ot"  in several places
  "-b24",   // default  BITMAP
  "-ani",   // animation
  "-j24",   // JPG
  "-p24",   // PNG
  "-t24",   // tiff
  "-b24"    // bitmap
};

// these strings are loaded from the resources 
static char *aalist[8]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
static char *dilist[3]={NULL,NULL,NULL};

// modify if adding new output formats
static char *plist[13]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,
                        NULL,NULL,NULL,NULL,NULL,NULL};

static char *colist[]={
  "First in Palette",
  "Black",
  "White"
};

static char *threadlist[]={ // How many things.
 "                                                                    ",
 "1", "2", "3", "4", "5", "6", "7", "8",
 "9","10","11","12","13","14","15","16"
};

LRESULT CALLBACK RendererMainWndProc(HWND hwnd, UINT msg, WPARAM wparam,
                             LPARAM lparam);
void RenderYield(void);
void WindowedRenderMessage(int message);
void WindowedRenderString(char *str);
void WindowedRenderInfo(char *str);
int ConfirmNTabort(void);
int GetRenderNTnewfile(char *name, char *rep_name);

extern HINSTANCE __cdecl ResourceX(void);
extern int render(int argc, char ** argv);
extern HWND SetUpGlWindow(HANDLE, HWND, long, long, BOOL, BOOL, BOOL, long);
extern void LoadParticleImages(void);
extern void UnloadParticleImages(void);
extern void CloseGlWindow(void);

extern long renderer_NT_abort_flag;
extern int Nprocessors,Nthreads;

int ConfirmNTabort(void){
 char text_string[512];
 char title[64];
 if(ImmediateFlag)return 1;  // In Window Quick Renderer so do not display dialog //
 LoadString(hThisInstance,IDX_MISC_CONFIRMSTOP,text_string,sizeof(text_string));
 LoadString(hThisInstance,IDX_MISC_CONFIRMSTOP1,title,sizeof(title));
 if(MessageBox(hwndMain,text_string,title,
    MB_OKCANCEL | MB_ICONSTOP) == IDOK)return 1;
 else return 0;
}

void SetTitleBarMessage(long percent, BOOL update){
 char text_string[512];
 static BOOL restore=FALSE;
 if(!update_title)return;
 if(percent < 0){
   LoadString(hThisInstance,IDX_MISC_WINDOWTITLE,text_string,
             sizeof(text_string));
   SendMessage(hwndMain,WM_SETTEXT,0,(LPARAM)(LPCTSTR)text_string);
   restore=FALSE;
 }
 else{
   if(!IsIconic(hwndMain)){
     if(restore){
       LoadString(hThisInstance,IDX_MISC_WINDOWTITLE,text_string,
                 sizeof(text_string));
       SendMessage(hwndMain,WM_SETTEXT,0,(LPARAM)(LPCTSTR)text_string);
     }
     restore=FALSE;
   }
   else if(update || percent%5 == 0){
     sprintf(text_string,"%ld%% Complete",percent);
     SendMessage(hwndMain,WM_SETTEXT,0,(LPARAM)(LPCTSTR)text_string);
     restore=TRUE;
   }
 }
 return;
}

void WindowedRenderMessage(int message){
 char szTitle[256];
 if(LoadString(hThisInstance,(UINT)message,szTitle,sizeof(szTitle))
    <= 0)return;
 SendMessage(hwndstatus,WM_SETTEXT,0,(LPARAM)(LPCTSTR)szTitle);
 if(logfile != NULL)fprintf(logfile,"%s\n",szTitle);
}

void WindowedRenderString(char *str){
 SendMessage(hwndstatus,WM_SETTEXT,0,(LPARAM)(LPCTSTR)str);
 if(logfile != NULL)fprintf(logfile,"%s\n",str);
 RenderYield();
}

void WindowedRenderInfo(char *str){
 SendMessage(hwndinfo,WM_SETTEXT,0,(LPARAM)(LPCTSTR)str);
 if(logfile != NULL)fprintf(logfile,"%s\n",str);
 RenderYield();
}

static BOOL CheckRendererStatus(void){
  char text_string[512];
  if(RendererInUse || RendererStandAlone){
    SetForegroundWindow(hwndMain);
    BringWindowToTop(hwndMain);
    ShowWindow(hwndMain,SW_SHOW);
    LoadString(hThisInstance,IDX_MISC_BUSY,text_string,sizeof(text_string));
    MessageBox(hwndMain,text_string,NULL,MB_OK|MB_SYSTEMMODAL);
    return FALSE;
  }
  return TRUE;
}

void UpdateNTTrace(long line){
  HDC hdc;
  RECT rect;
  POINT pt[4];
  long  d;
  PostMessage(hwndmeter,MM_SETPARTSCOMPLETE,(WPARAM)line,0);
  if(RendererRange == 0)SetTitleBarMessage((line*100)/plp->yres,FALSE);
  RenderYield();
  return;
}

static void UpdateNTFrameM(long f,long s){
 char str[32];
 time_t t;
 double te;
 long tm,ts;
 SendMessage(hwndmeterframes,MM_SETPARTSCOMPLETE,(WPARAM)(frame_counter),0);
 if(RendererRange == 1){
   sprintf(str,"%ld",min(f,last_frame));
   SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM)str);
   f=min(f,last_frame)-first_frame+1;
   sprintf(str,"(%ld of %ld)",f,last_frame-first_frame+1);
   SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)str);
   SetTitleBarMessage(((f-first_frame+1)*100)/(last_frame-first_frame),TRUE);
 }
 else{
   sprintf(str,"%ld",current_frame);
   SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM)str);
   SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)" ");
 }
 if(frame_counter > 0 && s == 0){
   t=time(NULL);
   te=difftime(t,last_frame_start);
   if(te < 61.0)sprintf(str,"%lds",(long)te);
   else {
     tm=(long)te/60; ts=(long)(te-(double)tm*60);
     sprintf(str,"%ldm %lds",tm,ts);
   }
   SendMessage(hwndframetime,WM_SETTEXT,0,(LPARAM)str);
   te=difftime(t,start_time);
   last_frame_start=t;
   te=difftime(t,start_time)*
         ((double)(last_frame-first_frame-frame_counter))/
          (double)(frame_counter);
   t=t+(time_t)te;
   SendMessage(hwndestimate,WM_SETTEXT,0,(LPARAM)ctime(&t));
 }
 if(s == 0)frame_counter++;
 RenderYield();
 return;
}
static void UpdateNTFrameS(long f,long s){
 char str[32];
 time_t t;
 double te;
 long tm,ts;
 f=f/2;
 SendMessage(hwndmeterframes,MM_SETPARTSCOMPLETE,(WPARAM)(frame_counter/2),0);
 if(RendererRange == 1){
   sprintf(str,"%ld",min(f,last_frame));
   SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM)str);
   f=min(f,last_frame)-first_frame+1;
   sprintf(str,"(%ld of %ld)",f,last_frame-first_frame+1);
   SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)str);
   SetTitleBarMessage(((f-first_frame+1)*100)/(last_frame-first_frame),TRUE);
 }
 else{
   sprintf(str,"%ld",current_frame);
   SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM)str);
   SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)" ");
 }
 if(frame_counter > 0 && s == 0){
   t=time(NULL);
   te=difftime(t,last_frame_start);
   if(te < 61.0)sprintf(str,"%lds",(long)te);
   else {
     tm=(long)te/60; ts=(long)(te-(double)tm*60);
     sprintf(str,"%ldm %lds",tm,ts);
   }
   SendMessage(hwndframetime,WM_SETTEXT,0,(LPARAM)str);
   te=difftime(t,start_time);
   last_frame_start=t;
   te=difftime(t,start_time)*
         ((double)(last_frame-first_frame-frame_counter/2))/
          (double)(frame_counter/2);
   t=t+(time_t)te;
   SendMessage(hwndestimate,WM_SETTEXT,0,(LPARAM)ctime(&t));
 }
 if(s == 0)frame_counter++;
 RenderYield();
 return;
}

void UpdateNTFrame(long f,long s){ 
 if(plp->bRenderStereo)UpdateNTFrameS(f,s);
 else                  UpdateNTFrameM(f,s);
}

static PSTR FileInPath(PSTR pstrPath){
 PSTR pstr;
 pstr = pstrPath + strlen(pstrPath);
 while (pstr > pstrPath) {
     pstr = (AnsiPrev(pstrPath, pstr));
     if (*pstr == '\\' || *pstr == ':' || *pstr == '/') {
         pstr = (AnsiNext(pstr));
         break;
     }
 }
 return pstr;
}

static void ShrinkWindowTo(HWND hwndf,HWND hwndto){
 RECT rc,rcto;
 GetWindowRect(hwndf,&rc);
 GetWindowRect(hwndto,&rcto);
 MoveWindow(hwndf,rc.left,rc.top,
             rcto.right-rcto.left,
             rcto.bottom-rcto.top+GetSystemMetrics(SM_CYCAPTION),
             FALSE);
}

static void WrapWindowTo(HWND hwndf,HWND hwndto){
 RECT rc,rcto;
 GetWindowRect(hwndf,&rc);
 GetWindowRect(hwndto,&rcto);
 SetWindowPos(hwndf,NULL,0,0,
              rcto.right-rcto.left,
              rcto.bottom-rcto.top+GetSystemMetrics(SM_CYCAPTION),
              SWP_NOMOVE|SWP_DRAWFRAME|SWP_FRAMECHANGED);
}

// Load the DLLs that service the TAB's dialog SPIN and PROGRESS bars.
// The SPIN and PROGESS controls were written LONG before Windows added these as standard
// SO we still use our onw.
static BOOL FirstInstance(HANDLE inst){
 WNDCLASS wc;
 BOOL     rc;
 X__MEMORY_MANAGER *lpEVIMM;
 /* setup pointers to the DLL memory allocation functions */
 lpEVIMM=&EviMemoryManager;
 lpEVIMM->lpAni=NULL;
 lpEVIMM->lpMod=NULL;
 lpEVIMM->fpMalloc=X__AllocateRam;
 lpEVIMM->fpFree=X__FreeRam;
 wc.style = CS_HREDRAW | CS_VREDRAW | CS_SAVEBITS;
 wc.lpfnWndProc = (WNDPROC)RendererMainWndProc; // define the main window that will contain the tabbed dialogs and the other output windows
 wc.cbClsExtra = 0;
 wc.cbWndExtra = 0;
 wc.hInstance = inst;
 wc.hIcon = LoadIcon( inst, "SHOWICON");
 wc.hCursor = LoadCursor( NULL, IDC_ARROW );
 wc.hbrBackground = GetStockObject( WHITE_BRUSH );
// wc.lpszMenuName  = "RenderMenu";
 wc.lpszMenuName  = NULL;
 wc.lpszClassName = szRenderClass;
 rc = RegisterClass( &wc );
 if((hLibSpin=LoadLibrary("spin.dll")) == NULL){
   MessageBox (NULL,"Can't find SPIN.DLL","Error",
               MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
 }
 if((hLibMeter=LoadLibrary("update.dll")) == NULL){
   MessageBox (NULL,"Can't find UPDATE.DLL","Error",
               MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
   return FALSE;
 }
 hResourceInstance=inst;
 return( rc );
}

static void LoadTextLists(void){ // these are teh text lists for the drop down dialog boxes (loaded from the resources to allow for internationalisation 
 char text_string[512];
 long i,ilist[]={
            IDX_MISC_GIFStills,
            IDX_MISC_Animation,
            IDX_MISC_JPEGcompressed,
            IDX_MISC_PNGcompressed,
            IDX_MISC_TIFFRGB,
            IDX_MISC_WindowsBMP
 };
 LoadString(hThisInstance,IDX_MISC_None,
            text_string,sizeof(text_string));
 aalist[0]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[0] != NULL)strcpy(aalist[0],text_string);
 LoadString(hThisInstance,IDX_MISC_Low,
            text_string,sizeof(text_string));
 aalist[1]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[1] != NULL)strcpy(aalist[1],text_string);
 LoadString(hThisInstance,IDX_MISC_Medium,
            text_string,sizeof(text_string));
 aalist[2]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[2] != NULL)strcpy(aalist[2],text_string);
 LoadString(hThisInstance,IDX_MISC_High,
            text_string,sizeof(text_string));
 aalist[3]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[3] != NULL)strcpy(aalist[3],text_string);
 LoadString(hThisInstance,IDX_MISC_Best,
            text_string,sizeof(text_string));
 aalist[4]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[4] != NULL)strcpy(aalist[4],text_string);
 LoadString(hThisInstance,IDX_MISC_AA_9,
            text_string,sizeof(text_string));
 aalist[5]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[5] != NULL)strcpy(aalist[5],text_string);
 LoadString(hThisInstance,IDX_MISC_AA_12,
            text_string,sizeof(text_string));
 aalist[6]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[6] != NULL)strcpy(aalist[6],text_string);
 LoadString(hThisInstance,IDX_MISC_AA_16,
            text_string,sizeof(text_string));
 aalist[7]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(aalist[7] != NULL)strcpy(aalist[7],text_string);

 LoadString(hThisInstance,IDX_MISC_NoneD,
            text_string,sizeof(text_string));
 dilist[0]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(dilist[0] != NULL)strcpy(dilist[0],text_string);
 LoadString(hThisInstance,IDX_MISC_FloydSteinberg,
            text_string,sizeof(text_string));
 dilist[1]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(dilist[1] != NULL)strcpy(dilist[1],text_string);
 LoadString(hThisInstance,IDX_MISC_Noise,
            text_string,sizeof(text_string));
 dilist[2]=(char *)X__Malloc(strlen(text_string)*2+1);
 if(dilist[2] != NULL)strcpy(dilist[2],text_string);
 LoadString(hThisInstance,IDX_MISC_TH_Automatic,
            text_string,sizeof(text_string));
 strcpy(threadlist[0],text_string);
 LoadString(hThisInstance,IDX_MISC_Specified,
            text_string,sizeof(text_string));
 strcpy(rlist[Nrlist-1],text_string);  // last entry - always needs updated
 for(i=0;i<Nplist;i++){
   LoadString(hThisInstance,ilist[i],text_string,sizeof(text_string));
    plist[i]=(char *)X__Malloc(strlen(text_string)*2+1);
    if(plist[i] != NULL)strcpy(plist[i],text_string);
 }
}

static int RendererMainLoop(HINSTANCE hInstance, int wait){ // THIS IS THE APPLICATIONS MESSAGE LOOP FUNCTION - called from the WinMain function
 char text_string[512];
 MSG msg;
 HMENU hmenu;
 hThisInstance=hInstance;
 plp=&ParamList;
 LoadPreferences();
 //debug=fopen("c:\\debug-r.txt","w"); 
 if(plp->u3 == 1){
   if(LOBYTE(LOWORD(GetVersion())) < 4){
     if(LoadLibrary("dlg3d.dll") == NULL)
       MessageBox(NULL,"Dlg3d DLL missing",NULL,MB_OK);
   }
 }
 LoadTextLists();
 LoadString(hThisInstance,IDX_MISC_WINDOWTITLE,text_string,sizeof(text_string));
 hwndMain=CreateWindow(szRenderClass,
     text_string,
     WS_OVERLAPPED | WS_VISIBLE | WS_CLIPCHILDREN | WS_CAPTION |
     WS_MINIMIZEBOX |
     WS_SYSMENU,
     0,0,0,0,
     NULL,NULL,hInstance,NULL);
 if(!hwndMain) return FALSE;
 hmenu = GetSystemMenu(hwndMain, FALSE);
 RemoveMenu(hmenu, 7, MF_BYPOSITION);
 RemoveMenu(hmenu, 5, MF_BYPOSITION);
 RemoveMenu(hmenu, SC_RESTORE, MF_BYCOMMAND);
 RemoveMenu(hmenu, SC_SIZE, MF_BYCOMMAND);
 RemoveMenu(hmenu, SC_MAXIMIZE, MF_BYCOMMAND);
 RemoveMenu(hmenu, SC_TASKLIST, MF_BYCOMMAND);
 if(RendererStandAlone){
   AppendMenu(hmenu,MF_SEPARATOR,0,0);
   LoadString(hThisInstance,IDX_MISC_OPENSCRIPT,text_string,sizeof(text_string));
   AppendMenu(hmenu,MF_ENABLED | MF_STRING,SYSMENU_SCRIPT,text_string);
 }
 LoadString(hThisInstance,IDX_MISC_ABOUT,text_string,sizeof(text_string));
 AppendMenu(hmenu,MF_ENABLED | MF_STRING,SYSMENU_ABOUT,text_string);
 ShowWindow(hwndMain,SW_SHOW);
 UpdateWindow(hwndMain);
 InitialiseLibraryHandleList();
 colorstats0=NULL; colorstats1=NULL;
 if((colorstats0 = (unsigned long *)
   X__Malloc(NOCOLOUR*(long)sizeof(unsigned long))) == NULL)return FALSE;
 if((colorstats1 = (unsigned short *)
   X__Malloc(NOCOLOUR*(long)sizeof(unsigned short))) == NULL)return FALSE;
 SetFocus(hwndcontrol);
 if(RendererStandAlone)PostMessage(hwndMain,WM_COMMAND,MENU_FILE_SCRIPT,0);
 while (GetMessage(&msg,NULL,0,0)){
   if(!IsWindow(hwndupdate) || !IsDialogMessage(hwndupdate,&msg)){
     if(!IsWindow(hwndupdateX) || !IsDialogMessage(hwndupdateX,&msg)){
       if(!IsWindow(hwndcontrol) || !IsDialogMessage(hwndcontrol,&msg)){
         TranslateMessage(&msg);
         DispatchMessage(&msg);
       }
     }
   }
 }
 if(hWndOpenGL)CloseGlWindow(); hWndOpenGL=NULL;
 UnloadParticleImages();
 if(colorstats0 != NULL)X__Free(colorstats0); colorstats0=NULL;
 if(colorstats1 != NULL)X__Free(colorstats1); colorstats1=NULL;
 FreeLibraryHandleList();
 DestroyWindow(hwndMain);
//MessageBox(NULL,"Window Destroyed",NULL,MB_OK);
 UnregisterClass(szRenderClass,hInstance);
//MessageBox(NULL,"Window reg",NULL,MB_OK);
 if(hLibMeter != NULL)FreeLibrary(hLibMeter);
 if(hLibSetup != NULL)FreeLibrary(hLibSetup);
 if(hLibSpin != NULL)FreeLibrary(hLibSpin);
 if(debug != NULL)fclose(debug); debug=NULL;
 //if(hLibAvi != NULL)FreeLibrary(hLibAvi);
//MessageBox(NULL,"Libs freed",NULL,MB_OK);
 return (msg.wParam);
}

LRESULT CALLBACK RendererMainWndProc(HWND hwnd, UINT msg, WPARAM wparam,
                             LPARAM lparam ){
 HWND hwndCaller,hwndTemp;
 //HDC hDC;
 RECT rc;
 char szTitle[60],szTemp[32];
 char text_string[512];
 switch( msg ){
   case WM_ACTIVATE:
     if(LOWORD(wparam) != WA_INACTIVE){
       if(IsWindowVisible(hwndcontrol))SetFocus(hwndcontrol);
       else if(IsWindowVisible(hwndupdate))SetFocus(hwndupdate);
       else if(IsWindowVisible(hwndupdateX))SetFocus(hwndupdateX);
     }
     break;
   case WM_CREATE:
     // create the three child windows for the settings dialog and the rendering progess dialogs.
     hwndcontrol=CreateDialog(hResourceInstance,MAKEINTRESOURCE(DLG_TAB),
                              hwnd,(DLGPROC)TabbedDlgProc);
     hwndupdate=CreateDialog(hResourceInstance,MAKEINTRESOURCE(RD_UPDATE),
                              hwnd,(DLGPROC)UpdateDlgProc);
     hwndupdateX=CreateDialog(hResourceInstance,MAKEINTRESOURCE(RD_UPDATEX),
                              hwnd,(DLGPROC)UpdateXDlgProc);
     if(hwndcontrol == NULL || hwndupdate == NULL || hwndupdateX == NULL)
       return -1;
     ShrinkWindowTo(hwnd,hwndcontrol);
     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);
     // DO NOT allow the GPU renderer to be used if it is not supported in hardware
     if(!CheckGPUhardware(hwnd))EnableWindow(GetDlgItem(hwndcontrol,RD_CONTROL_RENDERGL),FALSE);
     break;
   case WM_DESTROY:
     if(hwndcontrol != NULL)DestroyWindow(hwndcontrol);
     if(hwndupdate  != NULL)DestroyWindow(hwndupdate);
     if(hwndupdateX != NULL)DestroyWindow(hwndupdateX);
     break;
   case WM_PAINT: {
       HDC hdc;
       PAINTSTRUCT ps;
       hdc=BeginPaint(hwnd,&ps);
       EndPaint(hwnd,&ps);
     }
     break;
   case WM_SYSCOMMAND:
     switch(LOWORD(wparam & 0xfff0)){
       case SYSMENU_ABOUT:
         PostMessage(hwnd,WM_COMMAND,MENU_FILE_ABOUT,0);
         break;
       case SYSMENU_SCRIPT:
         PostMessage(hwnd,WM_COMMAND,MENU_FILE_SCRIPT,0);
         break;
       case SYSMENU_PREFS:{
           DialogBox(hResourceInstance,MAKEINTRESOURCE(DLG_PREFERENCES),hwnd,
                     (DLGPROC)PreferencesDlgProc);
         }
         break;
       case SYSMENU_PPREFS_LOAD: // NOT used now
         if(IsWindow(hwndcontrol))UpdateControlDlg(hwndcontrol,FALSE);
         break;
       case SYSMENU_PPREFS_SAVE: // Not used now
         break;
       case SC_CLOSE:
         if(RendererInUse)PostMessage(hwnd,WM_COMMAND,MENU_FILE_ABORT,0);
         else             PostMessage(hwnd,WM_COMMAND,MENU_FILE_EXIT,0);
         break;
       default:
         return( DefWindowProc( hwnd, msg, wparam, lparam ) );
      }
      break;
    case IDM_CALLBACK_SETUP_ANIMATOR:
      if(!CheckRendererStatus())break;
      InModeller=0;
      frames=HIWORD(lparam); current_frame=LOWORD(lparam);
      first_frame=1; last_frame=frames;
      SendMessage(hwndcontrol,WM_COMMAND,IDC_FRAMESET,0);
      break;
    case IDM_CALLBACK_SETUP_MODELLER:
      if(!CheckRendererStatus())break;
      InModeller=1;
      frames=1; current_frame=1; first_frame=1; last_frame=frames;
      SendMessage(hwndcontrol,WM_COMMAND,IDC_FRAMESET,0);
      break;
    case IDM_CALLBACK_HIDDENLINE: // not used now
      break;
    case WM_CALLBACK_MATERIAL:  
      if(!CheckRendererStatus())break;
      ShowWindow(hwnd,SW_HIDE);
      ExecuteQuickInlineRenderer(hwnd,(HWND)lparam);
      break;
    case WM_CALLBACK_ABANDON:
      if(RendererInUse && ImmediateFlag){
         renderer_NT_abort_flag=1;
      }
      break;
    case WM_COMMAND:
      switch( LOWORD(wparam) ) {
       case MENU_FILE_SCRIPT: {
           char szTitle[80],tempfile[255];
           LoadString(hThisInstance,WRM_OPENSCRIPT,szTitle,sizeof(szTitle));
           strcpy(tempfile,plp->scr_file);
           if(SelectFileName(0,tempfile,plp->scr_dir,szTitle,
             "(*.SCR)|*.scr|",hwnd) == TRUE){
             strcpy(plp->scr_file,FileInPath(tempfile));
             sprintf(tempfile,"Renderer (%s)",plp->scr_file);
             SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)tempfile);
             GetNumberOfScriptFrames();
             RendererFirstTime=0;
             SendMessage(hwndcontrol,WM_COMMAND,IDC_FRAMESET,0);
           }
           if(RendererFirstTime)PostMessage(hwnd,WM_COMMAND,MENU_FILE_EXIT,0);
         }
         break;
       case IDM_CALLBACK_RUN:  /* rendering NOW */
         if(!CheckRendererStatus())break;
         if(lparam < 1 || lparam > frames || plp->ot == 1){
           MessageBox(hwnd,"Renderer settings must be adjusted",
                      "Warning",MB_ICONSTOP);
           break;
         }
         RendererRange=0;
         current_frame=lparam;
       case MENU_FILE_START:  // START RENDERING 
         LoadParticleImages();
         if(plp->bUseOpenGLrender==TRUE){
            long aa_samples[8]={0,2,4,6,8,9,12,16};
            hWndOpenGL=SetUpGlWindow(hThisInstance,hwndMain,plp->xres,plp->yres,
                                     (BOOL)plp->bDrawDirectly,(BOOL)plp->bUseFBO,
                                     (BOOL)plp->bCopyGLdepth,aa_samples[plp->aa]);
         }
         EnableWindow(hwndcontrol,FALSE);
         ShowWindow(hwndcontrol,SW_HIDE);
         if(plp->callback == 1 && hWndOpenGL == NULL){
           if(!InitiateRendererUpdateView(hwndupdateX))plp->callback=0;
         }
         if(plp->callback == 1 && hWndOpenGL == NULL){
           hwndTemp=hwndupdateX;
           hwndmeter=hwndmeter2;
           hwndmeterframes=hwndmeterframes2;
           hwndframe=hwndframe2;
           hwndframeof=hwndframeof2;
           hwndstatus=hwndstatus2;
           hwndframetime=hwndframetime2;
           hwndestimate=hwndestimate2;
           hwndinfo=hwndinfo2;
         }
         else{
           hwndTemp=hwndupdate;
           hwndmeter=hwndmeter1;
           hwndmeterframes=hwndmeterframes1;
           hwndframe=hwndframe1;
           hwndframeof=hwndframeof1;
           hwndstatus=hwndstatus1;
           hwndframetime=hwndframetime1;
           hwndestimate=hwndestimate1;
           hwndinfo=hwndinfo1;
         }
         WrapWindowTo(hwnd,hwndTemp);
         LoadString(hThisInstance,IDX_MISC_STOP,
                    text_string,sizeof(text_string));
         SendMessage(GetDlgItem(hwndTemp,RD_UPDATE_STOP),
                     WM_SETTEXT,0,(LPARAM)text_string);
         ShowWindow(hwndTemp,SW_SHOW);
         EnableWindow(hwndTemp,TRUE);
         SetFocus(hwndTemp);
         SendMessage(hwndmeter,MM_SETPARTSCOMPLETE,0,0);
         SendMessage(hwndmeterframes,MM_SETPARTSCOMPLETE,0,0);
         SendMessage(hwndframetime,WM_SETTEXT,0,(LPARAM)"<NA>");
         SendMessage(hwndestimate,WM_SETTEXT,0,(LPARAM)"<NA>");
         SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM) " ");
         SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)" ");
         if(RendererStandAlone){
           PostMessage(hwnd,WM_COMMAND,MENU_FILE_RENDER,0);  // SEND MESSAGE TO CALL RENDER
         }
         else{
           if(RendererRange){
             WindowedRenderMessage(WRM_WRITINGSCRIPT);
             PostMessage(hwnd,WM_COMMAND,MENU_FILE_RENDERN,0);
           }
           else PostMessage(hwnd,WM_COMMAND,MENU_FILE_RENDER1,0);
         }
         break;
       case MENU_FILE_STOP:
         RendererNotCancelled=0;
         if(plp->callback == 1 && !plp->bUseOpenGLrender)hwndTemp=hwndupdateX;
         else                                            hwndTemp=hwndupdate;
         EnableWindow(hwndTemp,FALSE);
         ShowWindow(hwndTemp,SW_HIDE);
         if(plp->callback && !plp->bUseOpenGLrender)TerminateRendererUpdateView();
         plp->bUseOpenGLrender=FALSE; 
         WrapWindowTo(hwnd,hwndcontrol);
         ShowWindow(hwndcontrol,SW_SHOW);
         EnableWindow(hwndcontrol,TRUE);
         SetFocus(hwndcontrol);
         if(!RendererStandAlone && !RendererAborted)
             SendMessage(hwnd,WM_COMMAND,MENU_FILE_EXIT,0);
         RendererAborted=0;
         break;
       case MENU_FILE_RENDER: {   // EVERYTHING IS READY  - GO RENDER !!!
           char *args[50],*filter;
           int i,argc=3,ff,lf,failed;
           if(RendererInUse)break;
           RendererInUse=1;
           logfile=NULL;
           if(plp->logfile){
             char lgg[256];
             strcpy(lgg,gszHomeDir);
             strcat(lgg,"render.log");
             logfile=fopen(lgg,"w");
           }
           frame_counter=0;
           SendMessage(hwndmeter,MM_SETPARTSCOMPLETE,0,0);
           SendMessage(hwndmeter,MM_SETPARTSINJOB,(WPARAM)plp->yres,0);
           for(i=0;i<3;i++)args[i]=(char *)X__Malloc(256);
           for(i=3;i<50;i++)args[i]=(char *)X__Malloc(10);
           strcpy(args[1],plp->scr_dir);
           strcat(args[1],"\\");
           strcat(args[1],plp->scr_file);
           *strrchr(args[1],'.')='\0';
           strcpy(args[2],plp->pic_dir);
           i=strlen(plp->pic_dir);                              /*  7 NOV */
           if(*(plp->pic_dir+i-1) != '\\')strcat(args[2],"\\"); /*        */
           strcat(args[2],plp->pic_file);
           strcpy(args[argc++],"-x");
           sprintf(args[argc++],"%ld",plp->xres);
           strcpy(args[argc++],"-y");
           sprintf(args[argc++],"%ld",plp->yres);
           ff=first_frame; lf=last_frame;
           if(ff > 1){
             strcpy(args[argc++],"-ff");
             sprintf(args[argc++],"%ld",ff);
           }
           if(lf > 0 && lf < frames){
             strcpy(args[argc++],"-lf");
             sprintf(args[argc++],"%ld",lf);
           }
           SendMessage(hwndmeterframes,MM_SETPARTSCOMPLETE,0,0);
           SendMessage(hwndmeterframes,MM_SETPARTSINJOB,(WPARAM)(lf-ff+1),0);
           if(plp->ot == 1){
             strcpy(args[argc++],"-an2");
           }
           else if(plp->ot > 1){
             strcpy(args[argc++],output_switch[plp->ot]);
             if(plp->ot == 2){ // JPEG output
               sprintf(args[argc++],"%ld",plp->jpeg_quality);
             }
           }
           if(plp->aa == 1)strcpy(args[argc++],"-a");    // accelerate aa (this flag used by s/w renderer only
           if(plp->aa == 2)strcpy(args[argc++],"-aa");
           if(plp->aa == 3)strcpy(args[argc++],"-aaa");
           if(plp->aa >= 4)strcpy(args[argc++],"-aaaa");
           if(plp->bRenderStereo > 0)strcpy(args[argc++],"-sto");
           if(plp->ae && plp->aa < 5)strcpy(args[argc++],"-ae");  // accelerate anti-aliasing 
           //if(plp->ns)strcpy(args[argc++],"-f");  // no smoothing ?
           if(plp->swgp)  strcpy(args[argc++],"-h");  // use software postprocessor
           if(plp->sd != 50){
             strcpy(args[argc++],"-sd");
             sprintf(args[argc++],"%ld",plp->sd);
           }
           if(plp->al != 10){
             strcpy(args[argc++],"-al");
             sprintf(args[argc++],"%ld",plp->al);
           }
           if(plp->sb != 300){
             strcpy(args[argc++],"-sb");
             sprintf(args[argc++],"%ld",plp->sb);
           }
           if(plp->sc != 89){
             strcpy(args[argc++],"-sc");
             sprintf(args[argc++],"%ld",plp->sc);
           }
           if(plp->ntsc_colours)strcpy(args[argc++],"-ntsc");
           if(plp->full_mirror)strcpy(args[argc++],"-fm");
           if(plp->blur > 0){
             strcpy(args[argc++],"-blr");
             sprintf(args[argc++],"%ld",plp->blur);
           }
           if(plp->ob > 0)strcpy(args[argc++],"-ob");
           if(plp->callback && hWndOpenGL == NULL)strcpy(args[argc++],"-cbk");
           if(plp->tzeros != 4){
             strcpy(args[argc++],"-tz");
             sprintf(args[argc++],"%ld",plp->tzeros);
           }
           if(plp->interlace_gif != 0)strcpy(args[argc++],"-lce");
#if TRACER
           if(plp->trace_shadows)strcpy(args[argc++],"-trs");
           if(plp->trace_reflections)strcpy(args[argc++],"-trr");
           if(plp->trace_refractions)strcpy(args[argc++],"-trg");
           if(!plp->trace_partition)strcpy(args[argc++],"-to"); // 
           if(plp->trace_depth != 0){
             strcpy(args[argc++],"-tod");
             sprintf(args[argc++],"%ld",plp->trace_depth);
           }
           if(plp->trace_face_count_target != 0){
             strcpy(args[argc++],"-tot");
             sprintf(args[argc++],"%ld",plp->trace_face_count_target);
           }
           if(plp->trace_voxel_min_size != 0){
             strcpy(args[argc++],"-tos");
             sprintf(args[argc++],"%ld",plp->trace_voxel_min_size);
           }
#endif
           renderer_NT_abort_flag=0; RendererAborted=0;
           update_title=TRUE;
           SetTitleBarMessage(0,TRUE);
           WindowedRenderMessage(WRM_LOADING);
           start_time=last_frame_start=time(NULL);
           failed=render(argc,args);
           SetTitleBarMessage(-1,TRUE);
           update_title=FALSE;
           if(hWndOpenGL != NULL){
             DestroyWindow(hWndOpenGL); 
             CloseGlWindow(); hWndOpenGL=NULL;
           }
           UnloadParticleImages();
           if(!renderer_NT_abort_flag){
             if(plp->beep_after){
               for(i=0;i<1;i++){
                 MessageBeep(MB_ICONEXCLAMATION);
                 if(i<2)Sleep(200);
               }
             }
             SendMessage(hwndmeter,MM_SETPARTSCOMPLETE,plp->yres,0);
             SendMessage(hwndmeterframes,MM_SETPARTSCOMPLETE,(WPARAM)(lf-ff+1),0);
             SendMessage(hwndframe,WM_SETTEXT,0,(LPARAM) " ");
             SendMessage(hwndframeof,WM_SETTEXT,0,(LPARAM)" ");
             if(failed != -1){
             if(plp->ot == 1){
               int rval;
               rval=BuildAnimation(args[2],plp->avi_fli,plp->avi_low, plp->avi_compress);
               LoadString(hThisInstance,IDX_MISC_BUILDFINISHED,
                          text_string,sizeof(text_string));
               WindowedRenderString(text_string);
               if(rval == 1 && plp->autoplay)PlayAnimation(args[2],plp->avi_fli);
             }
             if((!plp->callback || plp->autoshow) &&
                 RendererRange == 0  && (plp->ot ==  0 ||
                                         plp->ot ==  2 ||
                                         plp->ot ==  3 ||
                                         plp->ot ==  4 ||
                                         plp->ot ==  5)){
                 if(hWndOpenGL == NULL)DisplayOutputFile(); 
               }
             }
           }
           else{
            LoadString(hThisInstance,IDX_MISC_PRETERMINATED,
                       text_string,sizeof(text_string));
             WindowedRenderString(text_string);
           }
           renderer_NT_abort_flag=0;
           for(i=0;i<50;i++)X__Free(args[i]);
           RendererInUse=0;
           if(logfile != NULL){
             fclose(logfile);
             logfile=NULL;
           }
           if(plp->callback == 1 && hWndOpenGL == NULL)hwndTemp=hwndupdateX;
           else                                        hwndTemp=hwndupdate;
           LoadString(hThisInstance,IDX_MISC_CLOSE,
                      text_string,sizeof(text_string));
           SendMessage(GetDlgItem(hwndTemp,RD_UPDATE_STOP),
                       WM_SETTEXT,0,(LPARAM)text_string);
           RendererNotCancelled=1;
         }
         break;
       case MENU_FILE_ABORT:
         renderer_NT_abort_flag=1; RendererAborted=1;
         break;
       case IDM_CALLBACK_SETUP_PREVIEW:
         break; // NOT in this renderer
       case MENU_FILE_EXIT:
         if(RendererStandAlone){
           HWND hWndPrev;
           hWndPrev = FindWindow("OFX:ViewClass",NULL);
           if(hWndPrev != NULL)PostMessage(hWndPrev,WM_COMMAND,106,0);
           PostQuitMessage(0L);
         }
         else{
           HWND lastW;
           ShowWindow(hwnd,SW_HIDE);
           if(InModeller)lastW = FindWindow("OFX:ModelerClass",NULL);
           else          lastW = FindWindow("OFX:AnimatorClass",NULL);
           if(IsWindow(lastW)){
             SetForegroundWindow(lastW);
             BringWindowToTop(lastW);
             ShowWindow(lastW,SW_SHOW);
           }
         }
         break;
       case MENU_FILE_ABOUT:
         LoadString(hThisInstance,IDX_MISC_ABOUTRENDERERBIG,
                    text_string,sizeof(text_string));
         MessageBox(hwnd,ABOUT_VERSION,text_string,MB_OK);
         break;
       case IDM_CALLBACK_SHUTDOWN:
//         MessageBox ( GetFocus(),
//                  (LPCTSTR) "Renderer: Process detaching",
//                  (LPCTSTR) "",
//                  MB_OK | MB_SYSTEMMODAL );
         PostQuitMessage(0L);
         break;
       case MENU_FILE_RENDER1:   // TELL THE AANIMATOR TO WRITE THE SCRIPT 
         if(!CheckRendererStatus())break;
         if(InModeller){
           strcpy(plp->scr_dir,gszWorkDrive);
           if(strrchr(plp->scr_dir,'\\') != NULL)
             *strrchr(plp->scr_dir,'\\')='\0';
           strcpy(plp->scr_file,"w_$.scr");
           SendMessage(hwnd,WM_COMMAND,MENU_FILE_RENDER,0);
         }
         else{
           hwndCaller=FindWindow("OFX:AnimatorClass",NULL);
           if(IsWindow(hwndCaller))SendMessage(hwndCaller,WM_COMMAND,
                         IDM_CALLBACK_FSCRIPT,(LPARAM)current_frame);
         }
         break;
       case MENU_FILE_RENDERN:    //  TELL THE ANIMATOR TO WRITER THE SCRIPT
         if(!CheckRendererStatus())break;
         if(InModeller)break;
         hwndCaller=FindWindow("OFX:AnimatorClass",NULL);
         if(IsWindow(hwndCaller))SendMessage(hwndCaller,WM_COMMAND,
                                   IDM_CALLBACK_ASCRIPT,0);
         break;
       case IDM_CALLBACK_SETUP:           
         if(gszWorkDrive != NULL){
           strcpy(plp->scr_dir,gszWorkDrive);
           if(strrchr(plp->scr_dir,'\\') != NULL)
             *strrchr(plp->scr_dir,'\\')='\0';
           strcpy(plp->scr_file,"w_$.scr");
           PostMessage(hwnd,WM_COMMAND,MENU_FILE_RENDER,0);
         }
         break;
       case IDM_CALLBACK_CANCEL:
         LoadString(hThisInstance,IDX_MISC_SETUPERROR,
                    text_string,sizeof(text_string));
         MessageBox(hwnd,text_string,NULL,MB_OK);
         break;
       default: break;
     }
     break;
   default:
     return( DefWindowProc( hwnd, msg, wparam, lparam ) );
 }
 return( 0L );
}

void RenderYield(void){
 MSG msg;
 while (PeekMessage(&msg, NULL, 0, 0,PM_REMOVE)){
   TranslateMessage(&msg);
   DispatchMessage(&msg);
 }
}

CRITICAL_SECTION g_CriticalSection;

extern char           IniFilename[];


#define FAIL            0
#define OK              1
#ifdef RENDERER_DLL
#define BITMAPSIZE    320
#else
#define BITMAPSIZE    320
#endif
#define PALVERSION  0x300

static void PaintRendererUpdateView(HDC, RECT);

static int RendererUpdateCount=0;
static HDRAWDIB hDrawDib = NULL;
static long BitmapSizeX,BitmapSizeY;
static LPSTR lpBitmapBits=NULL,lpBitmapHeader=NULL,lpBits;
static char gszDLLfile[MAX_FILE],gszDLLdir[MAX_DIR];
static BOOL StretchImage=FALSE;


static void CentreDialogOnCursor(HWND hwnd){
 RECT rcDlg;
 POINT p;
 int xres,yres;
 yres=GetSystemMetrics(SM_CYSCREEN);
 xres=GetSystemMetrics(SM_CXSCREEN);
 GetCursorPos(&p);
 GetWindowRect(hwnd,&rcDlg);
 OffsetRect(&rcDlg,-rcDlg.left,-rcDlg.top);
 OffsetRect(&rcDlg,p.x-rcDlg.right/2,p.y-rcDlg.bottom/2);
 if(rcDlg.left < 0)OffsetRect(&rcDlg,-rcDlg.left,0);
 if(rcDlg.top  < 0)OffsetRect(&rcDlg,0,-rcDlg.top);
 if(rcDlg.right  > xres)OffsetRect(&rcDlg,xres-rcDlg.right,0);
 if(rcDlg.bottom > yres)OffsetRect(&rcDlg,0,yres-rcDlg.bottom);
 SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
 return;
}


static HWND hwndAnimatorViewWindow=NULL;

static void ExecuteQuickInlineRenderer(HWND hwnd, HWND hwndView){
 if(IsWindow(hwndView)){
   HDC hDC;
   HCURSOR hSave;
   char *argu[10];
   int i,narg=10;
   RECT rc;
   HWND hwndimageSave;
   BOOL LoggingFlagSave;
   long xresSave,yresSave;
   hwndimageSave=hwndimage;
   hwndimage=hwndView;
   LoggingFlagSave=LoggingFlag;
   LoggingFlag=FALSE;
   xresSave=plp->xres;
   yresSave=plp->yres;
   GetClientRect(hwndView,&rc);
   plp->xres=rc.right;
   plp->yres=rc.bottom;
   if(InitiateRendererUpdateView(hwnd)){
     RendererInUse=1;
     ImmediateFlag=TRUE;
     hwndAnimatorViewWindow=hwndView;
     for(i=0;i<3;i++)argu[i]=(char *)X__Malloc(128);
     for(i=3;i<narg;i++)argu[i]=(char *)X__Malloc(8);
     sprintf(argu[0],"??");
     sprintf(argu[1],"%sw_$",gszWorkDrive);
     sprintf(argu[2],"%sw_$",gszWorkDrive);
     strcpy(argu[3],"-x"); sprintf(argu[4],"%ld",rc.right);
     strcpy(argu[5],"-y"); sprintf(argu[6],"%ld",rc.bottom);
     strcpy(argu[7],"-cbk");
     strcpy(argu[8],"-q");
     strcpy(argu[9],"-ac");
     hSave=SetCursor(LoadCursor(NULL,IDC_WAIT));
     renderer_NT_abort_flag=0;
     render(narg,argu);
     renderer_NT_abort_flag=0;
     hDC=GetDC(hwndAnimatorViewWindow);
     PaintRendererUpdateView(hDC,rc);
     ReleaseDC(hwndAnimatorViewWindow,hDC);
     SetCursor(hSave);
     for(i=0;i<narg;i++)X__Free(argu[i]);
     ImmediateFlag=FALSE;
     RendererInUse=0;
     TerminateRendererUpdateView();
   }
   hwndimage=hwndimageSave;
   LoggingFlag=LoggingFlagSave;
   plp->xres=xresSave;
   plp->yres=yresSave;
   hwndAnimatorViewWindow=NULL;
 }
 return;
}

// code for the settings dialog


static void LoadPreferences(void){
 char pref_id[32];
 char defd[256];
 /* gszHomeDir  has a trailing \         */
 /* all other directories do NOT         */
 /* renderer filename are only the NAMES */
 GetPrivateProfileString("RPREFERENCES","ACCELAA","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"NO",2) == 0){
   ParamList.ae=0;
 }
 GetPrivateProfileString("RPREFERENCES","DIALOGS3D","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"NO",2) == 0){
   ParamList.u3=0;
 }
 GetPrivateProfileString("RPREFERENCES","LOGFILE","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"YES",3) == 0){
   ParamList.logfile=1;
 }
 GetPrivateProfileString("RPREFERENCES","PREVIEW","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"NO",2) == 0){
  ParamList.callback=0;
 }
 GetPrivateProfileString("RPREFERENCES","AUTOSHOW","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"NO",2) == 0){
  ParamList.autoshow=0;
 }
 GetPrivateProfileString("RPREFERENCES","AUTOPLAY","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"NO",2) == 0){
  ParamList.autoplay=0;
 }

 GetModuleFileName(hThisInstance,gszHomeDir,MAX_DIR);
 *FileInPath(gszHomeDir) = '\0';
 strcpy(plp->pic_file,"temp");
 GetPrivateProfileString("RPREFERENCES","PICDIR","$$$",
                   defd,sizeof(defd),IniFilename);
 if(strncmp(defd,"$$$",3) == 0){
//   strcpy(plp->pic_dir,gszHomeDir); strcat(plp->pic_dir,"images");  
   strcpy(plp->pic_dir,TempPath); plp->pic_dir[strlen(plp->pic_dir)-1] = '\0';
 }
 else strcpy(plp->pic_dir,defd);
 strcpy(plp->fli_file,"unnamed");
 GetPrivateProfileString("RPREFERENCES","FLIDIR","$$$",
                   defd,sizeof(defd),IniFilename);
 if(strncmp(defd,"$$$",3) == 0){
   strcpy(plp->fli_dir,TempPath); plp->fli_dir[strlen(plp->fli_dir)-1] = '\0';
 }
 else strcpy(plp->fli_dir,defd);
 strcpy(plp->scr_file,"*.scr");
 strcpy(plp->scr_dir,gszHomeDir); strcat(plp->scr_dir,"scripts");
 plp->tmp_file[0]='\0';
 strcpy(plp->tmp_dir,gszHomeDir); strcat(plp->tmp_dir,"objects");
 gszWorkDrive=&TempPath[0];
 GetPrivateProfileString("RPREFERENCES","PERSONAL","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"YES",3) == 0){; } // NOT used now
 else plp->personal=FALSE;
 Nthreads=GetPrivateProfileInt("RPREFERENCES","THREADS",0,IniFilename);
 plp->Nthreads=Nthreads;
 GetPrivateProfileString("RPREFERENCES","TZERO_STILL","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"YES",3) == 0)plp->tzero_still=1;
 else                             plp->tzero_still=0;
 GetPrivateProfileString("RPREFERENCES","BEEP_AFTER","$$$",
                   pref_id,sizeof(pref_id),IniFilename);
 if(strncmp(pref_id,"YES",3) == 0)plp->beep_after=1;
 else                             plp->beep_after=0;
 return;
}

static long GetCharListID(char *item, char **list, long n){
 long i;
 for(i=0;i<n;i++){
   if(strcmp(item,list[i]) == 0)return i;
 }
 return -1;
}

static BOOL ValidFileName(char *name){
 int i,l;
 char c;
// if((l=strlen(name)) > 8 || l < 1)return FALSE;
 if((l=strlen(name)) > 256 || l < 1)return FALSE;
 for(i=0;i<l;i++){
   c = *(name+i);
   if(c == '.' || c == '\\' || c == ':')return FALSE;
   else if(c == '-' || c == '_'){;}  /* OK */
   else if( c < 48 || (c > 57 && c < 65) || (c > 90 && c < 97) || c > 123)
     return FALSE;
 }
 return TRUE;
}

static char compressed_path[256];

static char *CompressPath(char *name, int n){
 char *lp;
 int i,l;
 if((l=strlen(name)) == 0)return name;
 if(strlen(name) > n){
   strnset(compressed_path,'\0',255);
   strncpy(compressed_path,name,3);
   strcat(compressed_path,"...");
   lp=strrchr(name,'\\');
   if(lp != NULL)strcat(compressed_path,lp);
 }
 else strcpy(compressed_path,name);
 AnsiLower(compressed_path);
 return compressed_path;
}

static void EnableAnimSettings(HWND hdlg, BOOL f, int h, BOOL ff, int hh){
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_LAST),f);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FIRST),f);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME),f);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME),f);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME_SPIN),f);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME_SPIN),f);
 ShowWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME_SPIN),h);
 ShowWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME_SPIN),h);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME),ff);
 EnableWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME_SPIN),ff);
 ShowWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME_SPIN),hh);
}

static void UpdateControlDlg(HWND hdlg,BOOL ini){
 int i,v;
 HWND hctl;
 SetDlgItemInt(hdlg,RD_X_SIZE,(UINT)plp->xres,FALSE);
 SetDlgItemInt(hdlg,RD_Y_SIZE,(UINT)plp->yres,FALSE);
 SendDlgItemMessage(hdlg,RD_X_SIZE_SPIN,
                    SPNM_SETRANGE,0,MAKELPARAM(1,10000));
 SendDlgItemMessage(hdlg,RD_X_SIZE_SPIN,
                    SPNM_SETCRNTVALUE,(WPARAM)plp->xres,0);
 SendDlgItemMessage(hdlg,RD_X_SIZE_SPIN,SPNM_SETEDITCTRL,0,
                    (LPARAM)GetDlgItem(hdlg,RD_X_SIZE));
 SendDlgItemMessage(hdlg,RD_Y_SIZE_SPIN,
                    SPNM_SETRANGE,0,MAKELPARAM(1,10000));
 SendDlgItemMessage(hdlg,RD_Y_SIZE_SPIN,
                    SPNM_SETCRNTVALUE,(WPARAM)plp->yres,0);
 SendDlgItemMessage(hdlg,RD_Y_SIZE_SPIN,SPNM_SETEDITCTRL,0,
                    (LPARAM)GetDlgItem(hdlg,RD_Y_SIZE));
 hctl=GetDlgItem(hdlg,RD_FILE);
 SendMessage(hctl,CB_RESETCONTENT,0,0);
 for(i=0;i<Nplist;i++)
   SendMessage(hctl,CB_ADDSTRING,0,(LPARAM)plist[i]);
 SendMessage(hctl,CB_SELECTSTRING,0,(LPARAM)plist[plp->ot]);
 hctl=GetDlgItem(hdlg,RD_RESOLUTION);
 SendMessage(hctl,CB_RESETCONTENT,0,0);
 for(i=0;i<Nrlist;i++)
   SendMessage(hctl,CB_ADDSTRING,0,(LPARAM)rlist[i]);
 SendMessage(hctl,CB_SELECTSTRING,0,(LPARAM)rlist[plp->re]);
 hctl=GetDlgItem(hdlg,RD_AA);
 SendMessage(hctl,CB_RESETCONTENT,0,0);
 for(i=0;i<Naalist;i++)
   SendMessage(hctl,CB_ADDSTRING,0,(LPARAM)aalist[i]);
 SendMessage(hctl,CB_SELECTSTRING,0,(LPARAM)aalist[plp->aa]);
 SendDlgItemMessage(hdlg,RD_CONTROL_ONEFRAME,BM_SETCHECK,TRUE,0);
 SetDlgItemText(hdlg,RD_CONTROL_STILLFILEDIR,
                CompressPath(plp->pic_dir,18));
 SetDlgItemText(hdlg,RD_CONTROL_STILLFILENAME,plp->pic_file);
 SetDlgItemText(hdlg,RD_CONTROL_ANIMFILEDIR,
               CompressPath(plp->fli_dir,18));
 SetDlgItemText(hdlg,RD_CONTROL_ANIMFILENAME, plp->fli_file);
 if(!ini)return;
 if(plp->avi_fli == 1)
       SendDlgItemMessage(hdlg,RD_CONTROL_AVI,BM_SETCHECK,TRUE,0);
 else  SendDlgItemMessage(hdlg,RD_CONTROL_FLI,BM_SETCHECK,TRUE,0);
 if(plp->avi_compress == 1)
       SendDlgItemMessage(hdlg,RD_CONTROL_COMPRESS,BM_SETCHECK,TRUE,0);
 if((GetVersion() & 0x80000000) == 0x80000000){ /* not NT */
   if(LOBYTE(LOWORD(GetVersion())) < 4){ /* not 95 */
   EnableWindow(GetDlgItem(hdlg,RD_CONTROL_AVI),FALSE);
   ShowWindow(GetDlgItem(hdlg,RD_CONTROL_AVI),SW_HIDE);
   EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FLI),FALSE);
   ShowWindow(GetDlgItem(hdlg,RD_CONTROL_FLI),SW_HIDE);
   }
 }
 if(plp->ae)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_ACCELERATED_AA,BM_SETCHECK,v,0);
 if(plp->bRenderStereo > 0)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_CONTROL_STEREO,BM_SETCHECK,0,0);
 if(plp->constrain)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_CONTROL_CONSTRAIN,BM_SETCHECK,v,0);
 return;
}

static BOOL CALLBACK UpdateDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam ){
 switch( msg ){
   case WM_INITDIALOG:
     hwndmeter1=GetDlgItem(hdlg,RD_UPDATE_FRAME);
     hwndmeterframes1=GetDlgItem(hdlg,RD_UPDATE_FRAMES);
     hwndframe1=GetDlgItem(hdlg,RD_UPDATE_FF);
     hwndframeof1=GetDlgItem(hdlg,RD_UPDATE_LF);
     hwndstatus1=GetDlgItem(hdlg,RD_UPDATE_STATUS);
     hwndframetime1=GetDlgItem(hdlg,RD_UPDATE_LFT);
     hwndestimate1=GetDlgItem(hdlg,RD_UPDATE_ETA);
     hwndinfo1=GetDlgItem(hdlg,RD_UPDATE_INFO);
     SendMessage(hwndmeter1,MM_SETPARTSINJOB, 0, 0);
     SendMessage(hwndmeter1,MM_SETPARTSCOMPLETE, 0, 0);
     SendMessage(hwndmeterframes1,MM_SETPARTSINJOB, 0, 0);
     SendMessage(hwndmeterframes1,MM_SETPARTSCOMPLETE, 0, 0);
     return( TRUE );
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case IDCANCEL:
       case RD_UPDATE_STOP:
         if(RendererInUse)PostMessage(hwndMain,WM_COMMAND,MENU_FILE_ABORT,0);
         else             PostMessage(hwndMain,WM_COMMAND,MENU_FILE_STOP,0);
         break;
       default:
         break;
     }
     break;
   default: break;
 }
 return( FALSE );
}

static BOOL InitiateRendererUpdateView(HWND hwnd){
 long imagesize;
 int i;
 RECT rc;
 LPBITMAPINFOHEADER lpbi;
 ImmediateFlag=FALSE;
 lpBitmapHeader = (LPSTR)X__Malloc((long)sizeof(BITMAPINFOHEADER));
 if(lpBitmapHeader == NULL){
   return FALSE;
 }
 RendererUpdateCount=0;
 GetClientRect(hwndimage,&rc);
 BitmapSizeX=min(plp->xres,rc.right);
 BitmapSizeX=((BitmapSizeX+3)/4*4);
 BitmapSizeY=min(plp->yres,rc.bottom);
 lpbi=(LPBITMAPINFOHEADER)lpBitmapHeader;
 lpbi->biSize=sizeof(BITMAPINFOHEADER);
 lpbi->biWidth=(DWORD)BitmapSizeX;   /* start with it as big as possible */
 lpbi->biHeight=(DWORD)BitmapSizeY;
 lpbi->biPlanes=1;
 lpbi->biBitCount=24;
 lpbi->biCompression=BI_RGB;
 imagesize = lpbi->biSizeImage = BitmapSizeX*BitmapSizeY*3L;
 lpbi->biXPelsPerMeter=0;
 lpbi->biYPelsPerMeter=0;
 lpbi->biClrUsed=0;
 lpbi->biClrImportant=0;
 lpBitmapBits=(LPSTR)X__Malloc(imagesize);
 if(lpBitmapBits == NULL){
//   if(hpalPreview)DeleteObject(hpalPreview);
   if(lpBitmapHeader != NULL)X__Free((char *)lpBitmapHeader);
   lpBitmapHeader = NULL;
//   hpalPreview    = NULL;
   return FALSE;
 }
 memset(lpBitmapBits,0,imagesize);
 if((hDrawDib=DrawDibOpen()) == NULL)MessageBox(NULL,"No Dib",NULL,MB_OK);
 return TRUE;
}

static void TerminateRendererUpdateView(void){
 if(hDrawDib != NULL)DrawDibClose(hDrawDib);
 if(lpBitmapBits   != NULL)X__Free((char *)lpBitmapBits);
 if(lpBitmapHeader != NULL)X__Free((char *)lpBitmapHeader);
 hDrawDib       = NULL;
 lpBitmapHeader = NULL;
 lpBitmapBits   = NULL;
}

static void PaintRendererUpdateView(HDC hDC,RECT rc){
 HPALETTE hpalT;
 if(hDrawDib != NULL && lpBitmapHeader != NULL && lpBitmapBits != NULL){
   DrawDibRealize(hDrawDib,hDC,TRUE);
   DrawDibDraw(hDrawDib,hDC,
0,//         ((rc.right-rc.left)-BitmapSizeX)/2,
0,//           ((rc.bottom-rc.top)-BitmapSizeY)/2,
rc.right,//           (int)((LPBITMAPINFOHEADER)lpBitmapHeader)->biWidth,
rc.bottom,//           (int)((LPBITMAPINFOHEADER)lpBitmapHeader)->biHeight,
           (LPBITMAPINFOHEADER)lpBitmapHeader,lpBitmapBits,
           0,0,
           (int)((LPBITMAPINFOHEADER)lpBitmapHeader)->biWidth,
           (int)((LPBITMAPINFOHEADER)lpBitmapHeader)->biHeight,
           0);
 }
}

void AddToRenderImagePreview(long index,    // Renderer Preview Window and Texture Preview
                             long xmax, long ymax,
                             fullscreenbuffer *F,
                             unsigned char *R,
                             unsigned char *G,
                             unsigned char *B){
 long i,j,id;
 LPSTR p;
 fullscreenbuffer *f;
 if(lpBitmapBits == NULL)return;
 if(F != NULL){
  if(!LoggingFlag && !ImmediateFlag)return;
   for(j=0;j<BitmapSizeY;j++){
     index = BitmapSizeY - 1 - j;
     p=(lpBitmapBits+index*BitmapSizeX*3);
     id=(j*ymax)/BitmapSizeY;
     id *= xmax;
     for(i=0;i<BitmapSizeX;i++){
       f = (F + id + (i*xmax)/BitmapSizeX);
       *p++ = f->B;
       *p++ = f->G;
       *p++ = f->R;
     }
   }
   if(LoggingFlag){
     InvalidateRect(hwndimage,NULL,FALSE);
     UpdateWindow(hwndimage);
   }
 }
 else {
   index = BitmapSizeY - 1 - (index*BitmapSizeY)/ymax;
   p=(lpBitmapBits+index*BitmapSizeX*3);
   for(i=0;i<BitmapSizeX;i++){
     id = (i*xmax)/BitmapSizeX;
     *p++ = B[id];
     *p++ = G[id];
     *p++ = R[id];
   }
   if(RendererUpdateCount++ == 8){
     if(LoggingFlag)InvalidateRect(hwndimage,NULL,FALSE);
     else if(ImmediateFlag){
       if(hwndAnimatorViewWindow != NULL){
         HDC hDC;
         RECT rc;
         hDC=GetDC(hwndAnimatorViewWindow);
         GetClientRect(hwndAnimatorViewWindow,&rc);
         PaintRendererUpdateView(hDC,rc);
         ReleaseDC(hwndAnimatorViewWindow,hDC);
       }
     }
     RendererUpdateCount=0;
   }
 }
 return;
}

static BOOL CALLBACK UpdateXDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam ){
 char text_string[512];
 switch( msg ){
   case WM_INITDIALOG:
     LoggingFlag=TRUE;
     hwndmeter2=GetDlgItem(hdlg,RD_UPDATE_FRAME);
     hwndmeterframes2=GetDlgItem(hdlg,RD_UPDATE_FRAMES);
     hwndframe2=GetDlgItem(hdlg,RD_UPDATE_FF);
     hwndframeof2=GetDlgItem(hdlg,RD_UPDATE_LF);
     hwndstatus2=GetDlgItem(hdlg,RD_UPDATE_STATUS);
     hwndframetime2=GetDlgItem(hdlg,RD_UPDATE_LFT);
     hwndestimate2=GetDlgItem(hdlg,RD_UPDATE_ETA);
     hwndinfo2=GetDlgItem(hdlg,RD_UPDATE_INFO);
     hwndimage=GetDlgItem(hdlg,RD_UPDATEX_VIEW);
     SendMessage(hwndmeter2,MM_SETPARTSINJOB, 0, 0);
     SendMessage(hwndmeter2,MM_SETPARTSCOMPLETE, 0, 0);
     SendMessage(hwndmeterframes2,MM_SETPARTSINJOB, 0, 0);
     SendMessage(hwndmeterframes2,MM_SETPARTSCOMPLETE, 0, 0);
     InitializeCriticalSection(&g_CriticalSection);
     return( TRUE );
   case WM_DESTROY:
     DeleteCriticalSection(&g_CriticalSection);
     break;
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       RECT rc;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == RD_UPDATEX_VIEW){
         if(lpdis->itemAction == ODA_DRAWENTIRE){
         EnterCriticalSection(&g_CriticalSection);
         PaintRendererUpdateView(lpdis->hDC,lpdis->rcItem);
         LeaveCriticalSection(&g_CriticalSection);
         }
       }
     }
     return TRUE;
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case RD_UPDATEX_SHOWFINAL:
         DisplayOutputFile();
         break;
       case RD_UPDATEX_LOGGING:
         LoggingFlag ^= 1;
         if(LoggingFlag)
           LoadString(hThisInstance,IDX_MISC_PREVIEWOFF,
                      text_string,sizeof(text_string));
         else
           LoadString(hThisInstance,IDX_MISC_PREVIEWON,
                      text_string,sizeof(text_string));
         if(LoggingFlag)SetDlgItemText(hdlg,RD_UPDATEX_LOGGING,text_string);
         else           SetDlgItemText(hdlg,RD_UPDATEX_LOGGING,text_string);
         break;
       case IDCANCEL:
       case RD_UPDATE_STOP:
         if(RendererInUse)PostMessage(hwndMain,WM_COMMAND,MENU_FILE_ABORT,0);
         else             PostMessage(hwndMain,WM_COMMAND,MENU_FILE_STOP,0);
         break;
       default:
         break;
     }
     break;
   default: break;
 }
 return( FALSE );
}

static BOOL CALLBACK PreferencesDlgProc(HWND hdlg,UINT msg,
                           WPARAM wparam,LPARAM lparam){
 BOOL state;
 char *w, yesyes[]="YES", nono[]="NO";
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hdlg,hResourceInstance);
     break;
   case WM_INITDIALOG:
     CentreDialogOnCursor(hdlg);
     if(ParamList.ae)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_ACCELAA,BM_SETCHECK,state,0);
     if(ParamList.logfile)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_LOGFILE,BM_SETCHECK,state,0);
     if(ParamList.personal)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_PERSONAL,BM_SETCHECK,state,0);
     if(ParamList.callback)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_PREVIEW,BM_SETCHECK,state,0);
     if(ParamList.tzero_still)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_TZERO_STILL,BM_SETCHECK,state,0);
     if(ParamList.beep_after)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_BEEP_AFTER,BM_SETCHECK,state,0);
     if(ParamList.autoshow)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_AUTOSHOW,BM_SETCHECK,state,0);
     if(ParamList.autoplay)state=TRUE; else state=FALSE;
     SendDlgItemMessage(hdlg,DLG_PREFERENCES_AUTOPLAY,BM_SETCHECK,state,0);
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDOK:
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_ACCELAA,BM_GETCHECK,0,0))
            ParamList.ae=1; else ParamList.ae=0;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_LOGFILE,BM_GETCHECK,0,0))
            ParamList.logfile=TRUE; else ParamList.logfile=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_PERSONAL,BM_GETCHECK,0,0))
            ParamList.personal=TRUE; else ParamList.personal=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_PREVIEW,BM_GETCHECK,0,0))
            ParamList.callback=TRUE; else ParamList.callback=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_TZERO_STILL,BM_GETCHECK,0,0))
            ParamList.tzero_still=TRUE; else ParamList.tzero_still=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_BEEP_AFTER,BM_GETCHECK,0,0))
            ParamList.beep_after=TRUE; else ParamList.beep_after=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_AUTOSHOW,BM_GETCHECK,0,0))
            ParamList.autoshow=TRUE; else ParamList.autoshow=FALSE;
          if(SendDlgItemMessage(hdlg,DLG_PREFERENCES_AUTOPLAY,BM_GETCHECK,0,0))
            ParamList.autoplay=TRUE; else ParamList.autoplay=FALSE;

          if(ParamList.ae == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","ACCELAA",w,IniFilename);
          if(ParamList.u3 == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","DIALOGS3D",w,IniFilename);
          if(ParamList.logfile == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","LOGFILE",w,IniFilename);
          if(ParamList.personal == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","PERSONAL",w,IniFilename);
          if(ParamList.callback == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","PREVIEW",w,IniFilename);
          if(ParamList.tzero_still == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","TZERO_STILL",w,IniFilename);
          if(ParamList.beep_after == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","BEEP_AFTER",w,IniFilename);
          if(ParamList.autoshow == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","AUTOSHOW",w,IniFilename);
          if(ParamList.autoplay == 1)w=yesyes; else w=nono;
          WritePrivateProfileString("RPREFERENCES","AUTOPLAY",w,IniFilename);
          EndDialog(hdlg,TRUE);
          return(TRUE);
          break;
        case IDCANCEL:
          EndDialog(hdlg,FALSE);
          return(TRUE);
          break;
        default:  break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

// end of code for the settings dialog

// code to handle the tabbed dialog which controls the renderer

#define D_BORDER 4
#define WM_RSF_GETSTATUS  (WM_USER + 100)

typedef struct tag_dlghdr {
  HWND hwndDlgControl;
  HWND hwndDlgOptions;
  HWND hwndDlgSettings;
  HWND hwndDlgTracing;
  RECT rcTab;
} DLGHDR;

static DLGHDR DlgHdr,*lpDlgHdr;
static HWND   hwndTab;
static BOOL   TabCheckOk;

static BOOL CALLBACK TabbedDlgProcControl(HWND hdlg, UINT msg,
                                          WPARAM wparam, LPARAM lparam ){
 char text_string[512];
 static BOOL bEflag=FALSE;
 int i,istatus;
 char tempstr[64],tempdir[256],mss1[20];
 HWND hctl;
 BOOL status;
 switch( msg ){
   case WM_PAINT:
     PaintDialogBackground(hdlg,hResourceInstance);
     break;
   case WM_INITDIALOG:
     UpdateControlDlg(hdlg,TRUE);
     return( TRUE );
   case WM_COMMAND:
     switch( HIWORD(wparam) ){
       case EN_CHANGE:
         if(plp->constrain){
           if(!bEflag && LOWORD(wparam) == RD_X_SIZE){
             i=GetDlgItemInt(hdlg,RD_X_SIZE,&status,FALSE);
             i=(3*i)/4;
             bEflag=TRUE;
             SetDlgItemInt(hdlg,RD_Y_SIZE,(UINT)i,FALSE);
             SendDlgItemMessage(hdlg,RD_Y_SIZE_SPIN,
                           SPNM_SETCRNTVALUE,(WPARAM)i,0);
             bEflag=FALSE;
           }
           else if(!bEflag && LOWORD(wparam) == RD_Y_SIZE){
             i=GetDlgItemInt(hdlg,RD_Y_SIZE,&status,FALSE);
             i=(4*i)/3;
             bEflag=TRUE;
             SetDlgItemInt(hdlg,RD_X_SIZE,(UINT)i,FALSE);
             SendDlgItemMessage(hdlg,RD_X_SIZE_SPIN,
                           SPNM_SETCRNTVALUE,(WPARAM)i,0);
             bEflag=FALSE;
           }
         }
         break;
       case CBN_SELENDOK:
         if(LOWORD(wparam) == RD_RESOLUTION){
           SendDlgItemMessage(hdlg,RD_RESOLUTION,WM_GETTEXT,
             (WPARAM)18,(LPARAM)mss1);
           i=GetCharListID(mss1,rlist,Nrlist);
           if(i >= 0 && i < Nrlist - 1){ // no action on last entry
             plp->re=i; plp->xres=rxlist[i]; plp->yres=rylist[i];
             SetDlgItemInt(hdlg,RD_X_SIZE,(UINT)plp->xres,FALSE);
             SetDlgItemInt(hdlg,RD_Y_SIZE,(UINT)plp->yres,FALSE);
             SendDlgItemMessage(hdlg,RD_X_SIZE_SPIN,
                         SPNM_SETCRNTVALUE,(WPARAM)plp->xres,0);
             SendDlgItemMessage(hdlg,RD_Y_SIZE_SPIN,
                         SPNM_SETCRNTVALUE,(WPARAM)plp->yres,0);
           }
         }
         else if(LOWORD(wparam) == RD_FILE){
           SendDlgItemMessage(hdlg,RD_FILE,WM_GETTEXT,
             (WPARAM)18,(LPARAM)mss1);
           i=GetCharListID(mss1,plist,Nplist);
           if(i >= 0)plp->ot=i;
           if(i != 1)plp->last_ot=i; /* last non animation output              */
         }
         else if(LOWORD(wparam) == RD_AA){
           SendDlgItemMessage(hdlg,RD_AA,WM_GETTEXT,
             (WPARAM)18,(LPARAM)mss1);
           i=GetCharListID(mss1,aalist,Naalist);
           if(i >= 0)plp->aa=i;
         }
         break;
       default:
         break;
     }
     switch( LOWORD(wparam) ){
       case RD_CONTROL_CONSTRAIN:
         if(SendDlgItemMessage(hdlg,RD_CONTROL_CONSTRAIN,BM_GETCHECK,0,0))
              plp->constrain=1;
         else plp->constrain=0;
         break;
       case IDC_FRAMESET:
         SetDlgItemInt(hdlg,RD_CONTROL_CURRENTFRAME,current_frame,FALSE);
         SendDlgItemMessage(hdlg,RD_CONTROL_CURRENTFRAME,EM_LIMITTEXT,(WPARAM)6,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_CURRENTFRAME_SPIN,
                            SPNM_SETRANGE,0,MAKELPARAM(1,frames));
         SendDlgItemMessage(hdlg,RD_CONTROL_CURRENTFRAME_SPIN,
                            SPNM_SETCRNTVALUE,(WPARAM)current_frame,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_CURRENTFRAME_SPIN,
                            SPNM_SETEDITCTRL,0,
                            (LPARAM)GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME));
         SetDlgItemInt(hdlg,RD_CONTROL_FIRSTFRAME,first_frame,FALSE);
         SendDlgItemMessage(hdlg,RD_CONTROL_FIRSTFRAME,EM_LIMITTEXT,(WPARAM)6,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_FIRSTFRAME_SPIN,
                            SPNM_SETRANGE,0,MAKELPARAM(1,frames));
         SendDlgItemMessage(hdlg,RD_CONTROL_FIRSTFRAME_SPIN,
                            SPNM_SETCRNTVALUE,(WPARAM)first_frame,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_FIRSTFRAME_SPIN,
                            SPNM_SETEDITCTRL,0,
                            (LPARAM)GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME));
         SetDlgItemInt(hdlg,RD_CONTROL_LASTFRAME,last_frame,FALSE);
         SendDlgItemMessage(hdlg,RD_CONTROL_LASTFRAME,EM_LIMITTEXT,(WPARAM)6,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_LASTFRAME_SPIN,
                            SPNM_SETRANGE,0,MAKELPARAM(1,frames));
         SendDlgItemMessage(hdlg,RD_CONTROL_LASTFRAME_SPIN,
                            SPNM_SETCRNTVALUE,(WPARAM)last_frame,0);
         SendDlgItemMessage(hdlg,RD_CONTROL_LASTFRAME_SPIN,
                            SPNM_SETEDITCTRL,0,
                            (LPARAM)GetDlgItem(hdlg,RD_CONTROL_LASTFRAME));
         if(RendererStandAlone){
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME),FALSE);
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME_SPIN),FALSE);
           ShowWindow(GetDlgItem(hdlg,RD_CONTROL_CURRENTFRAME_SPIN),SW_HIDE);
           if(frames == 1){
             EnableWindow(GetDlgItem(hdlg,RD_CONTROL_ONEFRAME),TRUE);
             SendDlgItemMessage(hdlg,RD_CONTROL_ONEFRAME,BM_SETCHECK,TRUE,0);
             SendDlgItemMessage(hdlg,RD_CONTROL_MANYFRAMES,BM_SETCHECK,FALSE,0);
             status=FALSE;
           }
           else{
             status=TRUE;
             SendDlgItemMessage(hdlg,RD_CONTROL_ONEFRAME,BM_SETCHECK,FALSE,0);
             SendDlgItemMessage(hdlg,RD_CONTROL_MANYFRAMES,BM_SETCHECK,TRUE,0);
             EnableWindow(GetDlgItem(hdlg,RD_CONTROL_ONEFRAME),FALSE);
           }
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_MANYFRAMES),status);
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME),status);
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME),status);
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME_SPIN),status);
           EnableWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME_SPIN),status);
           if(status)istatus=SW_SHOW; else istatus=SW_HIDE;
           ShowWindow(GetDlgItem(hdlg,RD_CONTROL_FIRSTFRAME_SPIN),istatus);
           ShowWindow(GetDlgItem(hdlg,RD_CONTROL_LASTFRAME_SPIN),istatus);
         }
         else { /* called from Animator /Modeler */
           if(plp->ot == 1)plp->ot=plp->last_ot;
           SendMessage(GetDlgItem(hdlg,RD_FILE),CB_SELECTSTRING,0,
           (LPARAM)plist[plp->ot]);
           SendDlgItemMessage(hdlg,RD_CONTROL_ONEFRAME,BM_SETCHECK,TRUE,0);
           SendDlgItemMessage(hdlg,RD_CONTROL_MANYFRAMES,BM_SETCHECK,FALSE,0);
           if(frames == 1)
             EnableWindow(GetDlgItem(hdlg,RD_CONTROL_MANYFRAMES),FALSE);
           else EnableWindow(GetDlgItem(hdlg,RD_CONTROL_MANYFRAMES),TRUE);
           EnableAnimSettings(hdlg,FALSE,SW_HIDE,TRUE,SW_SHOW);
         }
         break;
       case RD_CONTROL_COMPRESS:
         if(HIWORD(wparam) != BN_CLICKED)break;
         if(SendDlgItemMessage(hdlg,RD_CONTROL_COMPRESS,BM_GETCHECK,0,0))
               plp->avi_compress=1;
          else plp->avi_compress=0;
         break;
       case RD_CONTROL_AVI:
         if(HIWORD(wparam) != BN_CLICKED)break;
         plp->avi_fli=1;
         plp->avi_low=0;
         break;
       case RD_CONTROL_FLI:  // or FLC
         if(HIWORD(wparam) != BN_CLICKED)break;
         plp->avi_fli=0;
         plp->avi_low=1;
         break;
       case RD_CONTROL_GIF:
         if(HIWORD(wparam) != BN_CLICKED)break;
         plp->avi_fli=2;
         plp->avi_low=1;
         break;
       case RD_CONTROL_ONEFRAME:
         if(HIWORD(wparam) != BN_CLICKED)break;
         EnableAnimSettings(hdlg,FALSE,SW_HIDE,TRUE,SW_SHOW);
         break;
       case RD_CONTROL_MANYFRAMES:
         if(HIWORD(wparam) != BN_CLICKED)break;
         EnableAnimSettings(hdlg,TRUE,SW_SHOW,FALSE,SW_HIDE);
         break;
       case RD_CONTROL_CDSTILL:
         strcpy(tempstr,"temp.scr"); strcpy(tempdir,plp->pic_dir);
         LoadString(hThisInstance,IDX_MISC_IMAGEFILEDIR,
                    text_string,sizeof(text_string));
         if(SelectDirectoryName(tempstr,tempdir,text_string,
           "(*.SCR)|*.scr|",hwndMain) == TRUE){
          if(strlen(tempdir) == 2)strcat(tempdir,"\\");
           strcpy(plp->pic_dir,tempdir);
           WritePrivateProfileString("RPREFERENCES","PICDIR",tempdir,
                                     IniFilename);
           SetDlgItemText(hdlg,RD_CONTROL_STILLFILEDIR,
             CompressPath(plp->pic_dir,18));
         }
         break;
       case RD_CONTROL_CDANIM:
         strcpy(tempstr,"temp.scr"); strcpy(tempdir,plp->fli_dir);
         LoadString(hThisInstance,IDX_MISC_FLICFILEDIR,
                    text_string,sizeof(text_string));
         if(SelectDirectoryName(tempstr,tempdir,text_string,
           "(*.SCR)|*.scr|",hwndMain) == TRUE){
           if(strlen(tempdir) == 2)strcat(tempdir,"\\");
           strcpy(plp->fli_dir,tempdir);
           WritePrivateProfileString("RPREFERENCES","FLIDIR",tempdir,
                                     IniFilename);
           SetDlgItemText(hdlg,RD_CONTROL_ANIMFILEDIR,
             CompressPath(plp->fli_dir,18));
         }
         break;
       default:
         break;
     }
     break;
   case WM_RSF_GETSTATUS:
   case WM_DESTROY:{
       BOOL err,err1;
       UINT result;
       int i1,i2,i3;
       if(SendDlgItemMessage(hdlg,RD_ACCELERATED_AA,BM_GETCHECK,0,0))
         plp->ae=1;else plp->ae=0;
       if(SendDlgItemMessage(hdlg,RD_CONTROL_STEREO,BM_GETCHECK,0,0))
         plp->bRenderStereo=1;else plp->bRenderStereo=0;
       result=GetDlgItemInt(hdlg,RD_X_SIZE,&err,FALSE);
       if(err)plp->xres=result;
       result=GetDlgItemInt(hdlg,RD_Y_SIZE,&err,FALSE);
       if(err)plp->yres=result;
       if(plp->yres < 10 || plp->xres < 20 ||
          plp->yres > 16348 || plp->xres > 16348){
         LoadString(hThisInstance,IDX_MISC_IMAGENOTSUPPORT,
                    text_string,sizeof(text_string));
         MessageBox(hdlg,text_string,NULL,MB_ICONSTOP);
         break;
       }
       err1=FALSE;
       i1=GetDlgItemInt(hdlg,RD_CONTROL_CURRENTFRAME,&err,FALSE);
       if(!err)err1=TRUE;
       i2=GetDlgItemInt(hdlg,RD_CONTROL_FIRSTFRAME,&err,FALSE);
       if(!err)err1=TRUE;
       i3=GetDlgItemInt(hdlg,RD_CONTROL_LASTFRAME,&err,FALSE);
       if(!err)err1=TRUE;
       if(i2 < 1 || i2 > i3)err1=TRUE;
       if(i3 < 1 || i3 > frames)err1=TRUE;
       if(i1 > frames)err1=TRUE;
       if(err1){
         LoadString(hThisInstance,IDX_MISC_INVALIDANIMATION,
                    text_string,sizeof(text_string));
         MessageBox(hdlg,text_string,NULL,MB_ICONSTOP);
         SendMessage(hdlg,WM_COMMAND,IDC_FRAMESET,0);
         break;
       }
       current_frame=i1; first_frame=i2; last_frame=i3;
       if(GetDlgItemText(hdlg,RD_CONTROL_STILLFILENAME,tempstr,64) == 0
          || strlen(tempstr) == 0 || !ValidFileName(tempstr)){
         LoadString(hThisInstance,IDX_MISC_INVALIDNAME1,
                    text_string,sizeof(text_string));
           MessageBox(hdlg,text_string,NULL,MB_ICONSTOP);
          break;
       }
       strcpy(plp->pic_file,tempstr);
       if(GetDlgItemText(hdlg,RD_CONTROL_ANIMFILENAME,tempstr,64) == 0
          || strlen(tempstr) == 0 || !ValidFileName(tempstr)){
            LoadString(hThisInstance,IDX_MISC_INVALIDNAME2,
                    text_string,sizeof(text_string));
            MessageBox(hdlg,text_string,NULL,MB_ICONSTOP);
         break;
       }
       strcpy(plp->fli_file,tempstr);
       if(SendDlgItemMessage(hdlg,RD_CONTROL_MANYFRAMES,BM_GETCHECK,0,0)){
         RendererRange=1;
         if(plp->ot != 1){ // adding new ???
           char warnt[32];
           LoadString(hThisInstance,IDX_MISC_INVALIDRANGE,
                    text_string,sizeof(text_string));
           LoadString(hThisInstance,IDX_MISC_WARNING,
                    warnt,sizeof(warnt));
           i=MessageBox(hdlg,text_string,warnt,MB_ICONQUESTION|MB_YESNOCANCEL);
            if(i == IDCANCEL)break;
            else if(i == IDYES){
              plp->ot=1;
              SendMessage(GetDlgItem(hdlg,RD_FILE),CB_SELECTSTRING,0,
              (LPARAM)plist[plp->ot]);
            }
         }
       }
       else{
         RendererRange=0;
         if(plp->ot == 1){
           LoadString(hThisInstance,IDX_MISC_NOANIMFORMAT,
                    text_string,sizeof(text_string));
           MessageBox(hdlg,text_string,NULL,MB_ICONSTOP);
           break;
         }
       }
     }
     TabCheckOk=TRUE;
     break;
   default: break;
 }
 return( FALSE );
}

static void UpdateSettingsDlg(HWND hdlg){
     int i;
     SetDlgItemInt(hdlg,RD_SMOOTHING,(UINT)plp->sc,FALSE);
     SendDlgItemMessage(hdlg,RD_SMOOTHING_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(0,89));
     SendDlgItemMessage(hdlg,RD_SMOOTHING_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->sc,0);
     SendDlgItemMessage(hdlg,RD_SMOOTHING_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_SMOOTHING));
     SetDlgItemInt(hdlg,RD_AMBIENT,(UINT)plp->al,FALSE);
     SendDlgItemMessage(hdlg,RD_AMBIENT_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(0,75));
     SendDlgItemMessage(hdlg,RD_AMBIENT_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->al,0);
     SendDlgItemMessage(hdlg,RD_AMBIENT_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_AMBIENT));
     SetDlgItemInt(hdlg,RD_SHADOW_DENSITY,(UINT)plp->sd,FALSE);
     SendDlgItemMessage(hdlg,RD_SHADOW_DENSITY_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(0,100));
     SendDlgItemMessage(hdlg,RD_SHADOW_DENSITY_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->sd,0);
     SendDlgItemMessage(hdlg,RD_SHADOW_DENSITY_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_SHADOW_DENSITY));
     SetDlgItemInt(hdlg,RD_SPOTLIGHT_SIZE,plp->sb,FALSE);
     SendDlgItemMessage(hdlg,RD_SPOTLIGHT_SIZE_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(10,9999));
     SendDlgItemMessage(hdlg,RD_SPOTLIGHT_SIZE_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->sb,0);
     SendDlgItemMessage(hdlg,RD_SPOTLIGHT_SIZE_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_SPOTLIGHT_SIZE));

     SetDlgItemInt(hdlg,RD_ANIM_SPEED,(UINT)plp->speed,FALSE);
     SendDlgItemMessage(hdlg,RD_ANIM_SPEED_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(0,9999));
     SendDlgItemMessage(hdlg,RD_ANIM_SPEED_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->speed,0);
     SendDlgItemMessage(hdlg,RD_ANIM_SPEED_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_ANIM_SPEED));
     SetDlgItemInt(hdlg,RD_MOTION_BLUR,(UINT)plp->blur,FALSE);
     SendDlgItemMessage(hdlg,RD_MOTION_BLUR_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(0,10));
     SendDlgItemMessage(hdlg,RD_MOTION_BLUR_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->blur,0);
     SendDlgItemMessage(hdlg,RD_MOTION_BLUR_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_MOTION_BLUR));
     SetDlgItemInt(hdlg,RD_TZEROS,plp->tzeros,FALSE);
     SendDlgItemMessage(hdlg,RD_TZEROS_SPIN,
                        SPNM_SETRANGE,0,MAKELPARAM(2,10));
     SendDlgItemMessage(hdlg,RD_TZEROS_SPIN,
                        SPNM_SETCRNTVALUE,(WPARAM)plp->tzeros,0);
     SendDlgItemMessage(hdlg,RD_TZEROS_SPIN,SPNM_SETEDITCTRL,0,
                        (LPARAM)GetDlgItem(hdlg,RD_TZEROS));
     SendDlgItemMessage(hdlg,RD_JPEG,TBM_SETPOS,(WPARAM)TRUE,
                        plp->jpeg_quality);
     SendDlgItemMessage(hdlg,RD_THREADS,CB_RESETCONTENT,0,0);
     for(i=0;i<Nthreadlist;i++)
       SendDlgItemMessage(hdlg,RD_THREADS,CB_ADDSTRING,
                          0,(LPARAM)threadlist[i]);
     SendDlgItemMessage(hdlg,RD_THREADS,CB_SELECTSTRING,
                          0,(LPARAM)threadlist[plp->Nthreads]);
#if __LITE__
     EnableWindow(GetDlgItem(hdlg,RD_THREADS),FALSE);
     EnableWindow(GetDlgItem(hdlg,RD_MOTION_BLUR),FALSE);
     EnableWindow(GetDlgItem(hdlg,RD_MOTION_BLUR_SPIN),FALSE);
#endif
}

static BOOL CALLBACK TabbedDlgProcSettings(HWND hdlg, UINT msg,
                                           WPARAM wparam, LPARAM lparam){
 BOOL err;
 UINT result;
 int i;
 switch( msg ){
   case WM_PAINT:
     PaintDialogBackground(hdlg,hResourceInstance);
     break;
   case WM_INITDIALOG:
     SendDlgItemMessage(hdlg,RD_JPEG,TBM_SETRANGE,(WPARAM)FALSE,
                        MAKELONG(10,100));
     SendDlgItemMessage(hdlg,RD_JPEG,TBM_SETTIC,0,(LPARAM)55);
     UpdateSettingsDlg(hdlg);
     return( TRUE );
   case WM_HSCROLL:
     switch(LOWORD(wparam)){
       case TB_ENDTRACK:
         plp->jpeg_quality=SendDlgItemMessage(hdlg,RD_JPEG,TBM_GETPOS,0,0);
         break;
       default:
         break;
     }
     break;
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case RD_LOADOWNPREFS:
         UpdateSettingsDlg(hdlg);
         break;
       case RD_SAVEOWNPREFS: // NOT used now
         SendMessage(hdlg,WM_RSF_GETSTATUS,0,0);
         break;
       default:
         break;
     }
     break;
   case WM_RSF_GETSTATUS:
   case WM_DESTROY:
     i=SendDlgItemMessage(hdlg,RD_THREADS,CB_GETCURSEL,0,0);
     if(i != CB_ERR){
       char str[16];
       plp->Nthreads=i;
       Nthreads=i;
       sprintf(str,"%ld",Nthreads);
       WritePrivateProfileString("RPREFERENCES","THREADS",str,IniFilename);
     }
     else MessageBox(NULL,"CB",NULL,MB_OK);
     result=GetDlgItemInt(hdlg,RD_SMOOTHING,&err,FALSE);
     if(err)plp->sc=result;
     result=GetDlgItemInt(hdlg,RD_AMBIENT,&err,FALSE);
     if(err)plp->al=result;
     result=GetDlgItemInt(hdlg,RD_SHADOW_DENSITY,&err,FALSE);
     if(err)plp->sd=result;
     result=GetDlgItemInt(hdlg,RD_SPOTLIGHT_SIZE,&err,FALSE);
     if(err)plp->sb=result;
     result=GetDlgItemInt(hdlg,RD_ANIM_SPEED,&err,FALSE);
     if(err)plp->speed=result;
     result=GetDlgItemInt(hdlg,RD_MOTION_BLUR,&err,FALSE);
     if(err)plp->blur=result;
     result=GetDlgItemInt(hdlg,RD_TZEROS,&err,FALSE);
     if(err){
       result=max(result,2);
       result=min(result,10);
       plp->tzeros=result;
     }
     plp->jpeg_quality=SendDlgItemMessage(hdlg,RD_JPEG,TBM_GETPOS,0,0);
     break;
   default: break;
 }
 return( FALSE );
}

static void UpdateOptionsDlg(HWND hdlg){
 int v;
 if(plp->bDrawDirectly)SendDlgItemMessage(hdlg,RD_RENDER_SCREEN,BM_SETCHECK,1,0);
 else if(plp->bUseFBO) SendDlgItemMessage(hdlg,RD_RENDER_FBO,BM_SETCHECK,1,0);
 else                  SendDlgItemMessage(hdlg,RD_RENDER_PBUFFER,BM_SETCHECK,1,0);
 if(plp->callback)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_CALLBACK,BM_SETCHECK,v,0);
 if(plp->swgp)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_SW_POSTPRO,BM_SETCHECK,v,0);
 if(plp->bCopyGLdepth)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_COPY_TO_DEPTH_BUFFER,BM_SETCHECK,v,0);
}

static BOOL CALLBACK TabbedDlgProcOptions(HWND hdlg, UINT msg,
                                          WPARAM wparam, LPARAM lparam ){
 int i;
 HWND hctl;
 switch( msg ){
   case WM_PAINT:
     PaintDialogBackground(hdlg,hResourceInstance);
     break;
   case WM_INITDIALOG:
     UpdateOptionsDlg(hdlg);
     return( TRUE );
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case RD_EDITPRESET:
         if(DialogBox(hResourceInstance,MAKEINTRESOURCE(DLG_PREFERENCES),hdlg,
                (DLGPROC)PreferencesDlgProc))UpdateOptionsDlg(hdlg);
         break;
       default:
         break;
     }
     break;
   case WM_RSF_GETSTATUS:
   case WM_DESTROY:
     plp->ob=1;
     plp->interlace_gif=0;
     if(SendDlgItemMessage(hdlg,RD_RENDER_FBO,BM_GETCHECK,0,0)){
       plp->bDrawDirectly=FALSE; plp->bUseFBO=TRUE;
     }
     else if(SendDlgItemMessage(hdlg,RD_RENDER_SCREEN,BM_GETCHECK,0,0)){
       plp->bDrawDirectly=TRUE; plp->bUseFBO=FALSE;
     }
     else {
       plp->bDrawDirectly=FALSE; plp->bUseFBO=FALSE;
     }     
     //plp->zb=1;
     if(SendDlgItemMessage(hdlg,RD_NTSC_COLOURS,BM_GETCHECK,0,0))
       plp->ntsc_colours=1;else plp->ntsc_colours=0;
     if(SendDlgItemMessage(hdlg,RD_FULL_MIRROR,BM_GETCHECK,0,0))
       plp->full_mirror=1;else plp->full_mirror=0;
     if(SendDlgItemMessage(hdlg,RD_CALLBACK,BM_GETCHECK,0,0))
        plp->callback=1;else plp->callback=0;
     if(SendDlgItemMessage(hdlg,RD_SW_POSTPRO,BM_GETCHECK,0,0))
       plp->swgp=1;else plp->swgp=0;
     if(SendDlgItemMessage(hdlg,RD_COPY_TO_DEPTH_BUFFER,BM_GETCHECK,0,0))
       plp->bCopyGLdepth=1;else plp->bCopyGLdepth=0;
     break;
   default: break;
 }
 return( FALSE );
}

static void UpdateTracingDlg(HWND hdlg){
 int v;
 if(plp->trace_shadows)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_TRACE_SHADOWS,BM_SETCHECK,v,0);
 if(plp->trace_reflections)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_TRACE_REFLECTIONS,BM_SETCHECK,v,0);
 if(plp->trace_refractions)v=1; else v=0;
 SendDlgItemMessage(hdlg,RD_TRACE_REFRACTIONS,BM_SETCHECK,v,0);


 if(plp->trace_partition)
       SendDlgItemMessage(hdlg,RD_TRACE_OPT_PARTITION,BM_SETCHECK,TRUE,0);
 else  SendDlgItemMessage(hdlg,RD_TRACE_OPT_SPLIT,BM_SETCHECK,TRUE,0);

 SetDlgItemInt(hdlg,RD_TRACE_OPT_DEPTH,plp->trace_depth,FALSE);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_DEPTH_SPIN,
                    SPNM_SETRANGE,0,MAKELPARAM(4,20));
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_DEPTH_SPIN,
                    SPNM_SETCRNTVALUE,(WPARAM)plp->trace_depth,0);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_DEPTH_SPIN,SPNM_SETEDITCTRL,0,
                    (LPARAM)GetDlgItem(hdlg,RD_TRACE_OPT_DEPTH));
 SetDlgItemInt(hdlg,RD_TRACE_OPT_THRESHOLD,plp->trace_face_count_target,FALSE);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_THRESHOLD_SPIN,
                    SPNM_SETRANGE,0,MAKELPARAM(2,100));
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_THRESHOLD_SPIN,
                    SPNM_SETCRNTVALUE,(WPARAM)plp->trace_face_count_target,0);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_THRESHOLD_SPIN,SPNM_SETEDITCTRL,0,
                    (LPARAM)GetDlgItem(hdlg,RD_TRACE_OPT_THRESHOLD));
 SetDlgItemInt(hdlg,RD_TRACE_OPT_SIZE,plp->trace_voxel_min_size,FALSE);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_SIZE_SPIN,
                    SPNM_SETRANGE,0,MAKELPARAM(1,128));
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_SIZE_SPIN,
                    SPNM_SETCRNTVALUE,(WPARAM)plp->trace_voxel_min_size,0);
 SendDlgItemMessage(hdlg,RD_TRACE_OPT_SIZE_SPIN,SPNM_SETEDITCTRL,0,
                    (LPARAM)GetDlgItem(hdlg,RD_TRACE_OPT_SIZE));
 return;
}

static BOOL CALLBACK TabbedDlgProcTracing(HWND hdlg, UINT msg,
                                           WPARAM wparam, LPARAM lparam){
 BOOL err;
 UINT result;
 switch( msg ){
   case WM_PAINT:
     PaintDialogBackground(hdlg,hResourceInstance);
     break;
   case WM_INITDIALOG:
     UpdateTracingDlg(hdlg);
     return( TRUE );
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       default:
         break;
     }
     break;
   case WM_RSF_GETSTATUS:
   case WM_DESTROY:
     if(SendDlgItemMessage(hdlg,RD_TRACE_SHADOWS,BM_GETCHECK,0,0))
           plp->trace_shadows=1;else plp->trace_shadows=0;
     if(SendDlgItemMessage(hdlg,RD_TRACE_REFLECTIONS,BM_GETCHECK,0,0))
           plp->trace_reflections=1;else plp->trace_reflections=0;
     if(SendDlgItemMessage(hdlg,RD_TRACE_REFRACTIONS,BM_GETCHECK,0,0))
           plp->trace_refractions=1;else plp->trace_refractions=0;
     if(SendDlgItemMessage(hdlg,RD_TRACE_OPT_PARTITION,BM_GETCHECK,0,0))
           plp->trace_partition=1; else plp->trace_partition=0;
     result=GetDlgItemInt(hdlg,RD_TRACE_OPT_DEPTH,&err,FALSE);
     if(err)plp->trace_depth=result;
     result=GetDlgItemInt(hdlg,RD_TRACE_OPT_THRESHOLD,&err,FALSE);
     if(err)plp->trace_face_count_target=result;
     result=GetDlgItemInt(hdlg,RD_TRACE_OPT_SIZE,&err,FALSE);
     if(err)plp->trace_voxel_min_size=result;
     plp->trace_depth=max(3,min(20,plp->trace_depth));
     plp->trace_face_count_target=max(2,min(1000,plp->trace_face_count_target));
     plp->trace_voxel_min_size=max(1,min(128,plp->trace_voxel_min_size));
     break;
   default: break;
 }
 return( FALSE );
}

static BOOL CALLBACK TabbedDlgProc(HWND hdlg, UINT msg, WPARAM wparam,
                                     LPARAM lparam ){
 char text_string[512];
 switch( msg ){
   case WM_INITDIALOG:{
       TC_ITEM tie;
       RECT rc,rd;
       int h,w;
       DWORD dwDlgBase=GetDialogBaseUnits();
       lpDlgHdr=&DlgHdr;
       GetWindowRect(hdlg,&rc);
       // size the tabbed dialog box off this control
       GetWindowRect(GetDlgItem(hdlg,IDOK),&rd);
//       h=rd.top-rc.top; // tabbed ends above control
       h=rd.bottom-rc.top;
       w=rd.left-rc.left;
       GetClientRect(hdlg,&rc);
       hwndTab=CreateWindow(WC_TABCONTROL," ",
                            WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS,
                            (D_BORDER*LOWORD(dwDlgBase))/4,
                            (D_BORDER*HIWORD(dwDlgBase))/8,
//                            rc.right-(2*D_BORDER*LOWORD(dwDlgBase))/4, //ends to right
                            w-(2*D_BORDER*LOWORD(dwDlgBase))/4, //ends to left
//                            h-(2*D_BORDER*HIWORD(dwDlgBase))/8, //ends above
                            h+(2*D_BORDER*HIWORD(dwDlgBase))/8, // ends below
                            hdlg,NULL,hThisInstance,NULL);
       LoadString(hThisInstance,IDX_MISC_LANGUAGE,
                  text_string,sizeof(text_string));
       if(strcmp(text_string,"ENGLISH") == 0)
         SendMessage(hwndTab,WM_SETFONT, /* for text in tab */
                    (WPARAM)GetStockObject(ANSI_VAR_FONT),0);
       memset(&tie,0,sizeof(TC_ITEM));
       tie.mask = TCIF_TEXT | TCIF_IMAGE;
       tie.iImage = -1;
       tie.pszText=text_string;
       LoadString(hThisInstance,IDX_MISC_TAB_CONTROL,
                  text_string,sizeof(text_string));
       TabCtrl_InsertItem(hwndTab,0,&tie);
       LoadString(hThisInstance,IDX_MISC_TAB_OPTIONS,
                  text_string,sizeof(text_string));
       TabCtrl_InsertItem(hwndTab,1,&tie);
       LoadString(hThisInstance,IDX_MISC_TAB_SETTINGS,
                  text_string,sizeof(text_string));
       TabCtrl_InsertItem(hwndTab,2,&tie);
#ifdef TRACER
       LoadString(hThisInstance,IDX_MISC_TAB_TRACING,
                  text_string,sizeof(text_string));
       TabCtrl_InsertItem(hwndTab,3,&tie);
#endif
       SetRectEmpty(&rc);
       TabCtrl_AdjustRect(hwndTab,FALSE,&rc);
       rc.left += (D_BORDER*LOWORD(dwDlgBase))/4;
       rc.top += (D_BORDER*HIWORD(dwDlgBase))/8;
       CopyRect(&(lpDlgHdr->rcTab),&rc);
       lpDlgHdr->hwndDlgControl=NULL;
       lpDlgHdr->hwndDlgOptions=NULL;
       lpDlgHdr->hwndDlgSettings=NULL;
       lpDlgHdr->hwndDlgTracing=NULL;
       lpDlgHdr->hwndDlgControl=CreateDialog(hResourceInstance,
                                    MAKEINTRESOURCE(DLG_TAB_CONTROL),
                                   hdlg,(DLGPROC)TabbedDlgProcControl);
       SetWindowPos(lpDlgHdr->hwndDlgControl,NULL,
                    lpDlgHdr->rcTab.left,lpDlgHdr->rcTab.top,0,0,
                    SWP_NOSIZE | SWP_NOZORDER);
       SendMessage(lpDlgHdr->hwndDlgControl,WM_COMMAND,IDC_FRAMESET,0);
       ShowWindow(lpDlgHdr->hwndDlgControl,SW_SHOW);
     }
     return TRUE;
   case WM_NOTIFY:
     if( ((LPNMHDR)lparam)->code == TCN_SELCHANGING){
       int id=TabCtrl_GetCurSel(hwndTab);
     }
     if( ((LPNMHDR)lparam)->code == TCN_SELCHANGE){
       int id=TabCtrl_GetCurSel(hwndTab);
       if(lpDlgHdr->hwndDlgControl != NULL){
         TabCheckOk=FALSE;
         DestroyWindow(lpDlgHdr->hwndDlgControl);
         lpDlgHdr->hwndDlgControl=NULL;
         if(!TabCheckOk){ /* don't let the page change till valid */
           TabCtrl_SetCurSel(hwndTab,0);
           id=0;
         }
       }
       if(lpDlgHdr->hwndDlgOptions != NULL){
         DestroyWindow(lpDlgHdr->hwndDlgOptions);
         lpDlgHdr->hwndDlgOptions=NULL;
       }
       if(lpDlgHdr->hwndDlgSettings != NULL){
         DestroyWindow(lpDlgHdr->hwndDlgSettings);
         lpDlgHdr->hwndDlgSettings=NULL;
       }
       if(lpDlgHdr->hwndDlgTracing != NULL){
         DestroyWindow(lpDlgHdr->hwndDlgTracing);
         lpDlgHdr->hwndDlgTracing=NULL;
       }
       if(id == 0){
         lpDlgHdr->hwndDlgControl=CreateDialog(hResourceInstance,
                                     MAKEINTRESOURCE(DLG_TAB_CONTROL),
                                     hdlg,(DLGPROC)TabbedDlgProcControl);
         SetWindowPos(lpDlgHdr->hwndDlgControl,NULL,
                      lpDlgHdr->rcTab.left,lpDlgHdr->rcTab.top,0,0,
                      SWP_NOSIZE | SWP_NOZORDER);
         SendMessage(lpDlgHdr->hwndDlgControl,WM_COMMAND,IDC_FRAMESET,0);
         ShowWindow(lpDlgHdr->hwndDlgControl,SW_SHOW);
       }
       else if(id == 1){
         lpDlgHdr->hwndDlgOptions=CreateDialog(hResourceInstance,
                                     MAKEINTRESOURCE(DLG_TAB_OPTIONS),
                                     hdlg,(DLGPROC)TabbedDlgProcOptions);
         SetWindowPos(lpDlgHdr->hwndDlgOptions,NULL,
                      lpDlgHdr->rcTab.left,lpDlgHdr->rcTab.top,0,0,
                      SWP_NOSIZE | SWP_NOZORDER);
         ShowWindow(lpDlgHdr->hwndDlgOptions,SW_SHOW);
       }
       else if(id == 2){
         lpDlgHdr->hwndDlgSettings=CreateDialog(hResourceInstance,
                                     MAKEINTRESOURCE(DLG_TAB_SETTINGS),
                                     hdlg,(DLGPROC)TabbedDlgProcSettings);
         SetWindowPos(lpDlgHdr->hwndDlgSettings,NULL,
                      lpDlgHdr->rcTab.left,lpDlgHdr->rcTab.top,0,0,
                      SWP_NOSIZE | SWP_NOZORDER);
         ShowWindow(lpDlgHdr->hwndDlgSettings,SW_SHOW);
       }
#ifdef TRACER
       else if(id == 3){
         lpDlgHdr->hwndDlgTracing=CreateDialog(hResourceInstance,
                                     MAKEINTRESOURCE(DLG_TAB_TRACING),
                                     hdlg,(DLGPROC)TabbedDlgProcTracing);
         SetWindowPos(lpDlgHdr->hwndDlgTracing,NULL,
                      lpDlgHdr->rcTab.left,lpDlgHdr->rcTab.top,0,0,
                      SWP_NOSIZE | SWP_NOZORDER);
         ShowWindow(lpDlgHdr->hwndDlgTracing,SW_SHOW);
       }
#endif
     }
     break;
   case WM_COMMAND:
     switch( LOWORD(wparam) ){
       case RD_CONTROL_HELP:{
           char lname[256],res_str1[256],res_str2[256];
           LoadString(hThisInstance,IDX_MISC_HELPFILENAME,
                      text_string,sizeof(text_string));
           strcpy(lname,gszHomeDir); strcat(lname,"help\\");
           strcpy(res_str1,lname);
#if !__HELP_WS__
           strcat(res_str1,text_string);
           ShellExecute(hdlg,NULL,res_str1,
                        NULL,lname,SW_SHOW);
#else
           {
             HH_WINTYPE hhwin;
             memset(&hhwin,0,sizeof(HH_WINTYPE));
             hhwin.cbStruct=sizeof(HH_WINTYPE);
             LoadString(hThisInstance,IDX_MISC_HELPTITLE1,text_string,256);
             hhwin.pszCaption=text_string;
             hhwin.nShowState=SW_SHOW;
             hhwin.pszType="MyHelp";
             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=750;
             hhwin.rcWindowPos.bottom=500;
             hhwin.nShowState=SW_SHOW;
             strcat(res_str1,"rnd_help.chm");
             hhwin.fNotExpanded = FALSE;
             hhwin.fsWinProperties = HHWIN_PROP_TRI_PANE|
                                    !HHWIN_PROP_POST_QUIT|
                                     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,"::/render_overview.htm");
             HtmlHelp(hdlg,NULL,HH_SET_WIN_TYPE,(DWORD)&hhwin);
             HtmlHelp(hdlg,">MyHelp",HH_DISPLAY_TOPIC,(DWORD)res_str1);
           }
#endif
         }
         break;
       case IDC_FRAMESET:
         if(lpDlgHdr->hwndDlgControl != NULL)
           SendMessage(lpDlgHdr->hwndDlgControl,WM_COMMAND,IDC_FRAMESET,0);
         break;
       case IDCANCEL:
         SendMessage(hwndMain,WM_COMMAND,MENU_FILE_EXIT,0);
         break;
       case RD_CONTROL_RENDERGL: // set the flag to use the GPU renderer
         plp->bUseOpenGLrender=TRUE;
       case IDOK: /* render : get current settings from active dialog */
         TabCheckOk=FALSE;
         if(lpDlgHdr->hwndDlgControl != NULL)
           SendMessage(lpDlgHdr->hwndDlgControl,WM_RSF_GETSTATUS,0,0);
         else TabCheckOk=TRUE;
         if(lpDlgHdr->hwndDlgOptions != NULL)
           SendMessage(lpDlgHdr->hwndDlgOptions,WM_RSF_GETSTATUS,0,0);
         if(lpDlgHdr->hwndDlgSettings != NULL)
           SendMessage(lpDlgHdr->hwndDlgSettings,WM_RSF_GETSTATUS,0,0);
         if(lpDlgHdr->hwndDlgTracing != NULL)
           SendMessage(lpDlgHdr->hwndDlgTracing,WM_RSF_GETSTATUS,0,0);
         if(TabCheckOk)PostMessage(hwndMain,WM_COMMAND,MENU_FILE_START,0);  // DISPATCH THE RENDERER !!!!!!!
         break;
       default:
         break;
     }
     break;
   case WM_DESTROY:
     break;
   default: break;
 }
 return( FALSE );
}

static void PaintDialogBackground(HWND hDlg, HINSTANCE hInst){
 int x;
 int y;
 HDC hDC;
 HPALETTE hpalT;
 HBRUSH hOldBrush;
 RECT rc1,rc2;
 HDC hMemDC;
 HBITMAP hBmBackground,hbmOld;
 BITMAP  bm;
 PAINTSTRUCT ps;
//RSF - use this function to paint dialog background
return;
//
 hDC = BeginPaint(hDlg,&ps);
 hBmBackground=LoadBitmap(hInst,MAKEINTRESOURCE(IDBM_BACKGROUND));
 if(hBmBackground != NULL){
   GetObject(hBmBackground,sizeof(BITMAP),&bm);
   hMemDC = CreateCompatibleDC(hDC);
   hbmOld = SelectObject(hMemDC,hBmBackground);
   GetClientRect(hDlg,&rc2);
   for(x=0;x<(rc2.right/bm.bmWidth)+1;x++)
   for(y=0;y<(rc2.bottom/bm.bmHeight)+1;y++)
     BitBlt(hDC,
          x*bm.bmWidth,y*bm.bmHeight,
          bm.bmWidth,
          bm.bmHeight,
          hMemDC,
          0,0,
          SRCCOPY);
   SelectObject(hMemDC,hbmOld);
   DeleteDC(hMemDC);
   DeleteObject(hBmBackground);
 }
 EndPaint(hDlg,&ps);
}

// end of code for the tabbed dialog box

int GetRenderNTnewfile(char *name, char *rep_name){ // get a replacement file - called from GetRenderReplacementFilename
 long i,l;
 OPENFILENAME ofn;
 char szDir[256],szFileTitle[256],szFilter[256];
 char szTitle[256],szFile[256];
 szFile[0]='\0';
 GetCurrentDirectory(sizeof(szDir),szDir);
 l=strlen(name);
 if(l > 3 && strnicmp((name+l-3),"mfx",3) == 0)strcpy(szFilter,"Model Files|*.mfx|");  // model file
 else strcpy(szFilter,"All file formats|*.bmp;*.gif;*.tga;*.cel;*.jpg;*.tif;*.png|");  // image file
 for(i=0;szFilter[i] != '\0';i++)if(szFilter[i] == '|')szFilter[i]='\0';
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=hwndMain;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=1;
 ofn.lpstrFile=szFile;
 ofn.nMaxFile=sizeof(szFile);
 ofn.lpstrFileTitle=szFileTitle;
 ofn.nMaxFileTitle=sizeof(szFileTitle);
 ofn.lpstrInitialDir=szDir;
 sprintf(szTitle,"Replace %s",name);
 ofn.lpstrTitle=szTitle;
 ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST;
 if(GetOpenFileName(&ofn)){
   strcpy(rep_name,szFile);
   return 1;
 }
 return 0;
}

static void GetNumberOfScriptFrames(void){
 char temp_str[80],tempfile[256];
 FILE *CF;
 strcpy(tempfile,plp->scr_dir);
 strcat(tempfile,"\\");
 strcat(tempfile,plp->scr_file);
 frames=9999; current_frame=1;
 first_frame=1; last_frame=frames;
 if((CF=fopen((char *)strlwr(tempfile),"r")) == NULL)return;
 fscanf(CF,"%s",temp_str);
 if(temp_str[0] == 'R')fscanf(CF,"%ld",&frames);
 else                  fscanf(CF,"%s",temp_str);
 first_frame=1; last_frame=frames;
 fclose(CF);
}

static int SelectFileName(int save, char *szfile, char *szdir,
                          char *szTitle, char *szfilter, HWND parent){
 int i;
 OPENFILENAME ofn;
 char szFilter[80],szdummy[MAX_FILE];
 szdummy[0]='\0';
 strcpy(szFilter,szfilter);
 i=0; while(szFilter[i] != '\0'){
   if(szFilter[i] == '|')szFilter[i]='\0'; i++;
 }
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=parent;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=1;
 ofn.lpstrFile=szfile;              /* will contain file + path */
 ofn.nMaxFile=MAX_FILE;
 ofn.lpstrFileTitle=szdummy;         /* file name only */
 ofn.nMaxFileTitle=MAX_FILE;
 ofn.lpstrInitialDir=szdir;
 ofn.lpstrTitle=szTitle;
 if(save){
  ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST;
   i=(int)(GetSaveFileName(&ofn));
 }
 else{
  ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|OFN_FILEMUSTEXIST;
   i=(int)(GetOpenFileName(&ofn));
 }
 if(i){
   strcpy(szdummy,szfile);
   *AnsiPrev(szdummy,FileInPath(szdummy)) = '\0';
   strcpy(szdir,szdummy);
 }
 return i;
}

static int SelectDirectoryName(char *szfile, char *szdir,
                               char *szTitle, char *szfilter,
                               HWND parent){
 int i;
 OPENFILENAME ofn;
 char szFilter[80],szdummy[MAX_FILE];
 szdummy[0]='\0';
 strcpy(szFilter,szfilter);
 i=0; while(szFilter[i] != '\0'){
   if(szFilter[i] == '|')szFilter[i]='\0'; i++;
 }
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=parent;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=1;
 ofn.lpstrFile=szfile;              /* will contain file + path */
 ofn.nMaxFile=MAX_FILE;
 ofn.lpstrFileTitle=szdummy;         /* file name only */
 ofn.nMaxFileTitle=MAX_FILE;
 ofn.lpstrInitialDir=szdir;
 ofn.lpstrTitle=szTitle;
 ofn.hInstance=hResourceInstance;
 ofn.lpfnHook=NULL;
 ofn.lpTemplateName="DIRECTORYOPEN";
 ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|
            OFN_ENABLETEMPLATE|OFN_NONETWORKBUTTON|
            OFN_NOTESTFILECREATE;  /* for PAR problem */
 i=(int)(GetSaveFileName(&ofn));
 if(i){
   strcpy(szdummy,szfile);
   *AnsiPrev(szdummy,FileInPath(szdummy)) = '\0';
   strcpy(szdir,szdummy);
 }
 return i;
}

static char WIN32_environment[512];

char *R_GetEnv(char const *aa){
 if(GetEnvironmentVariable((LPTSTR)aa,(LPTSTR)WIN32_environment,256) == 0)
   return NULL;
 return WIN32_environment;
}

static int BuildAnimation(char *root, long avi_fli, long avi_low, long avi_compress){
 char lname[256],fname[256],function[32];
 HMODULE hLibFlx=NULL;
 FARPROC fpFun;
 long l,result=0;
 int rval=0;
 int nCOLOUR;
 int (*fpBuildFli)(
                       HWND parent_window,HWND status_window,
                       int range_f, int range_l,
                       char *flic_file,
                       char *stem_file,
                       int ResolutionX,int ResolutionY,
                       int nCOLOUR, long speed, long tzeros,
                       unsigned long *cstats0,unsigned short *cstats1
                          );
 WindowedRenderMessage(WRM_BUILDANIM);
 nCOLOUR=NOCOLOUR;
 fpBuildFli=NULL;
 strcpy(lname,gszHomeDir);
 if(avi_fli == 1){
   if(avi_low == 1)strcat(lname,"avi_dll.dll");
   else{
     strcat(lname,"avi24_dll.dll");
     if(avi_compress)nCOLOUR=1;
     else            nCOLOUR=0;
   }
   strcpy(function,"_BuildAvi");
 }
 else if(avi_fli == 2){
   strcat(lname,"gif_dll.dll");
   strcpy(function,"_BuildGif");
 }
 else{ // avi_fli =0
   strcat(lname,"flic_dll.dll");
   strcpy(function,"_BuildFli");
 }
 strcpy(fname,plp->fli_dir);
 l=strlen(plp->fli_dir);        /* in case missing */
 if(*(plp->fli_dir+l-1) != '\\')strcat(fname,"\\");
 strcat(fname,plp->fli_file);
 if(strrchr(fname,'.') != NULL)*strrchr(fname,'.')='\0';
 if(avi_fli == 1)strcat(fname,".avi");
 else if(avi_fli == 2)strcat(fname,".gif");
 else {
   if(plp->xres <= 320 && plp->yres <= 200)strcat(fname,".fli");
   else                                    strcat(fname,".flc");
 }
 if(avi_fli == 1){
   hLibFlx=LoadLibrary(lname);
 }
 else{
   hLibFlx=LoadLibrary(lname);
 }
 if(hLibFlx != NULL){
   if((fpFun=GetProcAddress(hLibFlx,function)) != NULL){
    fpBuildFli = (int ( *)(
                       HWND, HWND,
                       int, int,
                       char *,
                       char *,
                       int, int,
                       int, long, long,
                       unsigned long *,unsigned short *))fpFun;

    if(plp->bRenderStereo)
    rval=(*fpBuildFli)(hwndMain,hwndstatus,
                   (int)first_frame,(int)(first_frame+frame_counter/2),
                   fname,
                   root,
                   (int)plp->xres,(int)plp->yres*2,
                   nCOLOUR,(long)plp->speed,(long)plp->tzeros,
                   colorstats0,colorstats1);
    else
    rval=(*fpBuildFli)(hwndMain,hwndstatus,
                   (int)first_frame,(int)(first_frame+frame_counter-1),
                   fname,
                   root,
                   (int)plp->xres,(int)plp->yres,
                   nCOLOUR,(long)plp->speed,(long)plp->tzeros,
                   colorstats0,colorstats1);
   }
   else{
     MessageBox(GetFocus(),
        (LPCTSTR) "Failed to get Animation Function",
        (LPCTSTR) "",
        MB_OK | MB_SYSTEMMODAL );
     FreeLibrary(hLibFlx);
     return 0;
   }
//   if(avi_fli != 1)FreeLibrary(hLibFlx);
   FreeLibrary(hLibFlx);
 }
 else {
   MessageBox(GetFocus(),
             (LPCTSTR) lname,
             (LPCTSTR) "Failed to load the Flics Library",
             MB_OK | MB_SYSTEMMODAL );
    return 0;
 }
 return rval;
}

static void PlayAnimation(char *root, long avi_fli){
 HWND hWndPlayer;
 char modulename[256],fname[256],classname[256];
 long l;
 strcpy(fname,plp->fli_dir);
 l=strlen(plp->fli_dir);
 if(*(plp->fli_dir+l-1) != '\\')strcat(fname,"\\");
 strcat(fname,plp->fli_file);
 if(strrchr(fname,'.') != NULL)*strrchr(fname,'.')='\0';
 if(avi_fli == 0){ // FLC
   sprintf(modulename,"%swinplay",gszHomeDir);
   if(plp->xres <= 320 && plp->yres <= 200)strcat(fname,".fli");
   else                                    strcat(fname,".flc");
   strcpy(classname,"OFX:FLCPlayer");
 }
 else if(avi_fli == 1){ // AVI
   strcat(fname,".avi");
//   sprintf(modulename,"%saviplay",gszHomeDir);
//   strcpy(classname,"OFX:AVIPlayer");
   sprintf(modulename,"%sofxmediaplayer %s",gszHomeDir,fname);
   strcpy(classname,"OFX:MediaPlayerClass");
   WinExec(modulename,SW_SHOW);
   return;  //

 }
 else return;
 WritePrivateProfileString("PLAYER","FILE",fname,IniFilename);
 if((hWndPlayer = FindWindow(classname,NULL)) == NULL){
   WinExec(modulename,SW_SHOW);
 }
 if((hWndPlayer = FindWindow(classname,NULL)) == NULL)return;
// PostMessage(hWndPlayer,WM_COMMAND,200,1); /* As stored in INI file */
 PostMessage(hWndPlayer,(WM_USER+1),0,0);
 return;
}

static void DisplayOutputFile(void){
 HWND hWndViewer;
 char modulename[256],filename[256],pathname[256];
 long l;
 if(plp->bRenderStereo > 0)return; // Don't display by default any output if Stereo Image 
 sprintf(modulename,"%swinview",gszHomeDir);
 if     (plp->ot ==  0)sprintf(filename,"%s.bmp",plp->pic_file);
 else if(plp->ot ==  2)sprintf(filename,"%s.jpg",plp->pic_file);
 else if(plp->ot ==  3)sprintf(filename,"%s.png",plp->pic_file);
 else if(plp->ot ==  4)sprintf(filename,"%s.tif",plp->pic_file);
 else if(plp->ot ==  5)sprintf(filename,"%s.bmp",plp->pic_file);
 l=strlen(plp->pic_dir);     /* in case missing */
 if(*(plp->pic_dir+l-1) == '\\')sprintf(pathname,"%s",plp->pic_dir);
 else                           sprintf(pathname,"%s\\",plp->pic_dir);
 WritePrivateProfileString("VIEWER","FILE",filename,IniFilename);
 WritePrivateProfileString("VIEWER","PATH",pathname,IniFilename);
 WinExec(modulename,SW_SHOW);
 if((hWndViewer = FindWindow("OFX:ViewClass",NULL)) == NULL)return;
 PostMessage(hWndViewer,WM_COMMAND,107,1); /* As stored in INI file */
}


int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                     LPSTR lpCmdLine, int nCmdShow){
 int rv;
 HWND hWndPrev;
 SYSTEM_INFO siSysInfo;
 hWndPrev = FindWindow(szRenderClass,NULL);
 if(hWndPrev != NULL){
   if(FindWindow("OFX:AnimatorClass",NULL) != NULL ||
      FindWindow("OFX:ModelerClass",NULL) != NULL){
     SetForegroundWindow(hWndPrev);
     BringWindowToTop(hWndPrev);
     ShowWindow (hWndPrev,SW_SHOW);
     return FALSE;
   }
 }
 // Get the INI file to use
 {
  FILE *fini=NULL; int ix;
  GetModuleFileName(hInstance,IniFilename,256);
  *FileInPath(IniFilename) = '\0';
  strcpy(TempPath,IniFilename);
  strcat(IniFilename,"OPENFX_.CFG");
  if((fini=fopen(IniFilename,"r")) != NULL){
    fscanf(fini,"%ld",&ix);
    strcpy(TempPath,"X");
    fscanf(fini," %[^\n]",TempPath);
    if(ix > 1){
      fscanf(fini," %[^\n]",IniFilename);
    }
    else  *FileInPath(IniFilename) = '\0';
    fclose(fini);
  }
  else { 
    char *pE;
    pE=R_GetEnv("TEMP");
    if(pE != NULL){
//MessageBox(NULL,pE,"TEMP",MB_OK);
      strcpy(TempPath,pE); strcat(TempPath,"\\");
      strcpy(IniFilename,TempPath);
      *FileInPath(TempPath) = '\0';
    }
    *FileInPath(IniFilename) = '\0';
  }
  strcat(IniFilename,"OPENFX_.INI");
 }
//MessageBox(NULL,IniFilename,TempPath,MB_OK);

 // 
 hInstance=ResourceX(); // for external resources
 InitCommonControls();
 AVIFileInit();          
 GetSystemInfo(&siSysInfo); Nprocessors=siSysInfo.dwNumberOfProcessors;
 if(!FirstInstance(hInstance)) return FALSE;
 if(lpCmdLine == NULL)RendererStandAlone=1;
 else{
   if(strstr(lpCmdLine,"$SAL$") == NULL)RendererStandAlone=1;
   else                                 RendererStandAlone=0;
 }
 RendererInUse=0;
 rv=RendererMainLoop(hInstance,1);
 AVIFileExit();
 return rv;
}