LIBRARY.C

Go to the documentation of this file.

/* file LIBRARY.C  library of helper functions */

#define MODULE_LIBS 1

#include "animate.h"
#include "spin_dll.h"

typedef struct tagNUMENTRY {
  long low,high,val;
  char *title;
  char *message;
} NUMENTRY;


static long local_grid_size=UNIT;

static BOOL CALLBACK NumEntryDlgProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam ){
 NUMENTRY *dp;
 BOOL err;
 int i;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       dp=(NUMENTRY *)lparam;
       SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)dp->title);
       SendDlgItemMessage(hwnd,DLG_NUMENTRY_TEXT,WM_SETTEXT,0,
                          (LPARAM)dp->message);
       SetDlgItemInt(hwnd,DLG_NUMENTRY_EDIT,dp->val,FALSE);
       SendDlgItemMessage(hwnd,DLG_NUMENTRY_SPIN,SPNM_SETRANGE,0,
                          MAKELPARAM(dp->low,dp->high));
       SendDlgItemMessage(hwnd,DLG_NUMENTRY_SPIN,SPNM_SETCRNTVALUE,
                          (WPARAM)dp->val,0);
       SendDlgItemMessage(hwnd,DLG_NUMENTRY_SPIN,SPNM_SETEDITCTRL,0,
                          (LPARAM)GetDlgItem(hwnd,DLG_NUMENTRY_EDIT));
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       CentreDialogOnCursor(hwnd);
     }
     return (TRUE);
   case WM_COMMAND:
      dp=(NUMENTRY *)GetWindowLong(hwnd,GWL_USERDATA);
      switch(LOWORD(wparam)){
        case DLG_NUMENTRY_SPIN:
          switch(HIWORD(wparam)){
            case SPNN_VALUECHANGE:
            break;
            default: break;
          }
          break;
        case IDCANCEL:
        case DLG_NUMENTRY_CANCEL:
          EndDialog(hwnd, -1);
          return(TRUE);
        case IDOK:
        case DLG_NUMENTRY_OK:
          i=GetDlgItemInt(hwnd,DLG_NUMENTRY_EDIT,&err,FALSE);
          if(!err)goto CANCELX;
          if(i > dp->high)i=dp->high; if(i < dp->low)i=dp->low;
          EndDialog(hwnd,i);
          return(TRUE);
          CANCELX:
          EndDialog(hwnd, -1);
          return TRUE;
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

short RequestNumEntry(long val, long minval, long maxval,
                      char *title, char *message){
 int i;
 NUMENTRY Numentry;
 Numentry.low=minval;
 Numentry.high=maxval;
 Numentry.val=val;
 Numentry.title=title;
 Numentry.message=message;
 EnableToolPannels(ALL_PANNELS,FALSE);
 i=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_NUMENTRY),ghwnd_main,
            (DLGPROC)NumEntryDlgProc,(LPARAM)&Numentry);
 EnableToolPannels(ALL_PANNELS,TRUE);
 return (short)i;
}

typedef struct tagSTRINGDLGLIST {
  int  len;
  char *title;
  char *string;
} STRINGDLGLIST;

static BOOL CALLBACK StringDlgProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam ){
 HWND hctl;
 STRINGDLGLIST *dp;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       dp=(STRINGDLGLIST *)lparam;
       hctl=GetDlgItem(hwnd,DLG_STRING_EDIT);
       SendMessage(hctl,WM_SETTEXT,0,(LPARAM)dp->string);
       SendMessage(hctl,EM_LIMITTEXT,(WPARAM)dp->len,0);
       SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)dp->title);
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       CentreDialogOnCursor(hwnd);
     }
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDOK:
        case IDCANCEL:
        case DLG_STRING_OK:
          dp=(STRINGDLGLIST *)GetWindowLong(hwnd,GWL_USERDATA);
          hctl=GetDlgItem(hwnd,DLG_STRING_EDIT);
          SendMessage(hctl,WM_GETTEXT,(WPARAM)dp->len,(LPARAM)dp->string);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

int RequestCharString(int len, char *string, char *title){
 STRINGDLGLIST StringDlgList;
 StringDlgList.len=len;
 StringDlgList.string=string;
 StringDlgList.title=title;
 EnableToolPannels(ALL_PANNELS,FALSE);
 DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_STRING),ghwnd_main,
            (DLGPROC)StringDlgProc,(LPARAM)&StringDlgList);
 EnableToolPannels(ALL_PANNELS,TRUE);
 return 1;
}

void EnableToolPannels(int what_one,BOOL status){
  if(what_one & MAIN_WINDOW   )EnableWindow(ghwnd_main,status);
  if(what_one & TOOL_PANNEL   )EnableTools(status);
  if(what_one & COORD_PANNEL  )EnableWindow(ghwndCoord1,status);
  if(what_one & KEYS_WINDOW && ghwndTimeline != NULL)
                               EnableWindow(ghwndTimeline,status);
}

typedef struct tagSELECTDLGLIST {
  int n;
  char *title;
  char **list;
} SELECTDLGLIST;

BOOL CALLBACK ItemSelectDlgProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam ){
 int i;
 SELECTDLGLIST *dp;
 HWND hctl;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       dp=(SELECTDLGLIST *)lparam;
       hctl=GetDlgItem(hwnd,DLG_CHOOSE_LIST);
       for(i=0;i<dp->n;i++)SendMessage(hctl,LB_ADDSTRING,0,(LPARAM)dp->list[i]);
       SendMessage(hctl,LB_SETCURSEL,0,0);
       SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)dp->title);
       CentreDialogOnCursor(hwnd);
     }
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_CHOOSE_LIST:
          switch(HIWORD(wparam)){
            case LBN_DBLCLK:
            SendMessage(hwnd,WM_COMMAND,MAKEWPARAM(DLG_CHOOSE_OK,0),0);
              break;
            default:
              break;
          }
          break;
        case IDCANCEL:
        case DLG_CHOOSE_CANCEL:
          EndDialog(hwnd, -1);
          return (TRUE);
        case IDOK:
        case DLG_CHOOSE_OK:
          hctl=GetDlgItem(hwnd,DLG_CHOOSE_LIST);
          i=SendMessage(hctl,LB_GETCURSEL,0,0);
          EndDialog(hwnd,i);
          return(TRUE);
        default:
          break;
      }
      break;
 }
 return(FALSE);
}

int SelectScrolledItemList(int n, char **list, char *title,
                           BOOL wide, HWND parent){
 int i;
 HWND hwnd;
 SELECTDLGLIST SelectDlgList;
 SelectDlgList.n=n;
 SelectDlgList.list=list;
 SelectDlgList.title=title;
 if(!wide)i=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_CHOOSE),parent,
            (DLGPROC)ItemSelectDlgProc,(LPARAM)&SelectDlgList);
 else i=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_CHOOSE_WIDE),parent,
            (DLGPROC)ItemSelectDlgProc,(LPARAM)&SelectDlgList);
 return i;
}

static int SelectItemListID;

#if 0
// these methods are not used now
static LRESULT CALLBACK SelectItemListWndProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam ){
 switch( msg ){
   case WM_COMMAND:
     SelectItemListID=LOWORD(wparam);
   break;
   default:
   return( DefWindowProc( hwnd, msg, wparam, lparam ) );
 }
 return( 0L );
}

int SelectItemList(int n, char **list, char *title){
 WNDCLASS wc;
 BOOL     rc;
 HWND     hwnd;
 HMENU    hmenu;
 POINT    p;
 int i;
 SelectItemListID = -1;
 wc.lpszClassName = "OFX:TEMPCLASS";
 wc.style = CS_HREDRAW | CS_VREDRAW;
 wc.lpfnWndProc = (WNDPROC)SelectItemListWndProc;
 wc.cbClsExtra = 0;
 wc.cbWndExtra = 0;
 wc.hInstance = ghinst_main;
 wc.hIcon = NULL;
 wc.hCursor = NULL;
 wc.hbrBackground = NULL;
 wc.lpszMenuName = NULL;
 rc = RegisterClass( &wc );
 if(!rc)return -1;
 hwnd = CreateWindow(
     wc.lpszClassName,"  ",
     0,
     0,0,0,0,NULL,NULL,ghinst_main,NULL);
 if(hwnd != NULL){
   if((hmenu=CreatePopupMenu()) != NULL){
     for(i=0;i<n;i++)AppendMenu(hmenu,MF_ENABLED,(UINT)i,(LPCTSTR)list[i]);
     GetCursorPos(&p);
     SendPrgmText(title);
     MessageBeep(MB_ICONQUESTION);
     TrackPopupMenu(hmenu,TPM_CENTERALIGN | TPM_LEFTBUTTON,(int)p.x,(int)p.y,0,hwnd,NULL);
   }
   {MSG msg;  /* allow WM_COMMAND message to be processed */
    while(PeekMessage(&msg,hwnd,0,0,PM_REMOVE)){
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
   }
   DestroyMenu(hmenu);
   DestroyWindow(hwnd);
 }
 UnregisterClass(wc.lpszClassName,wc.hInstance);
 return SelectItemListID;
}

static BOOL CALLBACK EnumSelectItemsProc(HWND hwnd, LPARAM lparam){
 char m[8];
 SendMessage(hwnd,WM_GETTEXT,8,(LPARAM)&m);
 if(m[0] > '`' && m[0] < '{')m[0] -= 32;
 if(lparam > '`' && lparam < '{')lparam -= 32;
 if((LPARAM)m[0] == lparam){
   SendMessage(GetParent(hwnd),WM_COMMAND,
               MAKELONG(0,BN_CLICKED),(LPARAM)hwnd);
   return FALSE;
 }
 return TRUE;
}

static LRESULT CALLBACK SelectItemsWndProc(HWND hwnd, UINT msg, WPARAM wparam,
                                    LPARAM lparam ){
 switch( msg ){
   case WM_KEYDOWN:
     switch(wparam){
       case VK_ESCAPE:
       SelectItemListID = -1;
       PostQuitMessage(0);
     }
     return( DefWindowProc( hwnd, msg, wparam, lparam ) );
   case WM_CHAR:  /* check first character of button names */
     EnumChildWindows(hwnd,EnumSelectItemsProc,(LPARAM)wparam);
     return( DefWindowProc( hwnd, msg, wparam, lparam ) );
   case WM_COMMAND:
     if(HIWORD(wparam) == BN_CLICKED){
       SelectItemListID=GetWindowLong((HWND)lparam,GWL_ID);
       PostQuitMessage(0);
     }
     break;
   default:
   return( DefWindowProc( hwnd, msg, wparam, lparam ) );
 }
 return( 0L );
}

int SelectItems(int n, char **list, char *title, int where){
 WNDCLASS   wc;
 BOOL       rc;
 HWND       hwnd,*hwndlist,*original;
 TEXTMETRIC tm;
 HDC        hdc;
 POINT      p;
 MSG        msg;
 int i,j,x,y,dx,dy,bsx,bsy;
 original=GetActiveWindow();
 wc.lpszClassName = "OFX:TEMPCLASS";
 wc.style = CS_SAVEBITS;
 wc.lpfnWndProc = (WNDPROC)SelectItemsWndProc;
 wc.cbClsExtra = 0;
 wc.cbWndExtra = 0;
 wc.hInstance = ghinst_main;
 wc.hIcon = NULL;
 wc.hCursor = NULL;
 wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND+1);
 wc.lpszMenuName = NULL;
 rc = RegisterClass( &wc );
 if(!rc)return -1;
 SelectItemListID = -1;
 hdc=GetDC(ghwnd_main);
 GetTextMetrics(hdc,&tm);
 ReleaseDC(ghwnd_main,hdc);
 bsx=strlen(title)+2;
 for(i=0;i<n;i++)if(strlen(list[i]) > bsx)bsx=strlen(list[i]);
 bsx += 2; bsx *= tm.tmAveCharWidth;
 bsy = tm.tmHeight+8;
 dx=bsx+20; dy=(bsy+8)*(n+1)-10;
 GetCursorPos(&p);
 x=max(p.x-dx/2,0); x=min(x,Xres-dx);
 y=max(p.y-dy/2,0); y=min(y,Yres-dy);
 hwnd = CreateWindow(
     wc.lpszClassName,title,
     WS_POPUP | WS_CLIPSIBLINGS | WS_CAPTION,
     x,y,dx,dy,ghwnd_main,NULL,ghinst_main,NULL);
 if(hwnd != NULL){
   if((hwndlist = (HWND *)X__Malloc(n*sizeof(HWND))) != NULL){
     y=5;
     for(i=0;i<n;i++){
       if((hwndlist[i] = CreateWindow("BUTTON","Stop",
          WS_CHILD | BS_DEFPUSHBUTTON | WS_VISIBLE | WS_TABSTOP,
          10,y,
          bsx,bsy,hwnd,(HMENU)i,ghinst_main,NULL)) == NULL){
         for(j=0;j<i;i++)DestroyWindow(hwndlist[i]);
         goto BREAK_LOOP;
       }
       y += (bsy+8);
     }
     ShowWindow(hwnd,SW_SHOWNA);
     SetActiveWindow(hwnd);
     for(i=0;i<n;i++){
       SendMessage(hwndlist[i],WM_SETTEXT,0,(LPARAM)(list[i]));
       ShowWindow(hwndlist[i],SW_SHOWNA);
     }
     EnableToolPannels(ALL_PANNELS,FALSE);
     SetFocus(hwnd);
     while (GetMessage(&msg,NULL,0,0)){
       TranslateMessage(&msg);
       DispatchMessage(&msg);
     }
     EnableToolPannels(ALL_PANNELS,TRUE);
     for(i=0;i<n;i++)DestroyWindow(hwndlist[i]);
   }
   BREAK_LOOP:
   X__Free(hwndlist);
   DestroyWindow(hwnd);
 }
 UnregisterClass(wc.lpszClassName,wc.hInstance);
 if(original != NULL)SetActiveWindow(original);
 return SelectItemListID;
}
#endif

void  ActivateAllMenus(HWND hwnd, UINT fuFlags){
 static WORD enable_state[256];  /* must be >= number of menu commands */
 int id,i,j,k,n,m,o,c=0;
 HMENU hmenu,hsubmenu,hsubsubmenu;
 hmenu=GetMenu(hwnd);
 n=GetMenuItemCount(hmenu);
 if(n < 1)return;
 for(i=0;i<n;i++){
  if((hsubmenu=GetSubMenu(hmenu,i)) == NULL){
    if((id=GetMenuItemID(hmenu,i)) < 0xffffffff){
      if(fuFlags == MF_GRAYED){
        enable_state[c] = GetMenuState(hmenu,id,MF_BYCOMMAND);
        EnableMenuItem(hmenu,id,fuFlags);
      }
      else EnableMenuItem(hmenu,id,enable_state[c]);
      c++;
    }
  }
  else{
    m=GetMenuItemCount(hsubmenu);
    for(j=0;j<m;j++){
      if((hsubsubmenu=GetSubMenu(hsubmenu,j)) == NULL){
        if((id=GetMenuItemID(hsubmenu,j)) < 0xffffffff){
          if(fuFlags == MF_GRAYED){
            enable_state[c] = GetMenuState(hsubmenu,id,MF_BYCOMMAND);
            EnableMenuItem(hsubmenu,id,fuFlags);
          }
          else EnableMenuItem(hsubmenu,id,enable_state[c]);
          c++;
        }
      }
      else{
        o=GetMenuItemCount(hsubsubmenu);
        for(k=0;k<o;k++){
          if((id=GetMenuItemID(hsubsubmenu,k)) < 0xffffffff){
            if(fuFlags == MF_GRAYED){
              enable_state[c] = GetMenuState(hsubsubmenu,id,MF_BYCOMMAND);
              EnableMenuItem(hsubsubmenu,id,fuFlags);
            }
            else EnableMenuItem(hsubsubmenu,id,enable_state[c]);
            c++;
          }
        }
      }
    }
  }
 }
}

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

#define ATOL 0.5

void GetWorldCoords0(int W, long *x, long *y, long *z,
                     int hpos, int vpos);
void GetWindowCoords0(int W, long x, long y, long z,
                     int *hpos, int *vpos);
void GetWorldCoords1(int W, long *x, long *y, long *z,
                    int hpos, int vpos);
void GetWindowCoords1(int W, long x, long y, long z,
                     int *hpos, int *vpos);

void GetWorldCoords0(int W, long *x, long *y, long *z,
                    int hpos, int vpos){
  if(W == TRITOP){
    *x=(long)((double)(hpos-WindowCentreX[0])*WindowPixelSize)+TVcentreX;
    *y=(long)((double)(WindowCentreY[0]-vpos)*WindowPixelSize)+TVcentreY;
    *z=NpointerZ;
  }
  else if(W == TRIFRONT){
    *x=(long)((double)(hpos-WindowCentreX[1])*WindowPixelSize)+TVcentreX;
    *y=NpointerY;
    *z=(long)((double)(WindowCentreY[1]-vpos)*WindowPixelSize)+TVcentreZ;
  }
  else if(W == TRIRIGHT){
    *x=NpointerX;
    *y=(long)((double)(hpos-WindowCentreX[2])*WindowPixelSize)+TVcentreY;
    *z=(long)((double)(WindowCentreY[2]-vpos)*WindowPixelSize)+TVcentreZ;
  }
}

void GetWindowCoords0(int W, long x, long y, long z, int *hpos, int *vpos){
  if(W == TRITOP){
   *hpos=(int)((double)WindowCentreX[0]+(double)(x-TVcentreX)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[0]-(double)(y-TVcentreY)/WindowPixelSize+ATOL);
  }
  else if(W == TRIFRONT){
   *hpos=(int)((double)WindowCentreX[1]+(double)(x-TVcentreX)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[1]-(double)(z-TVcentreZ)/WindowPixelSize+ATOL);
  }
  else if(W == TRIRIGHT){
   *hpos=(int)((double)WindowCentreX[2]+(double)(y-TVcentreY)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[2]-(double)(z-TVcentreZ)/WindowPixelSize+ATOL);
  }
}

void GetWorldCoords1(int W, long *x, long *y, long *z,
                    int hpos, int vpos){
  if(W == TRITOP){
    *x=(long)((double)(WindowCentreX[0]-hpos)*WindowPixelSize)+TVcentreX;
    *y=(long)((double)(vpos-WindowCentreY[0])*WindowPixelSize)+TVcentreY;
    *z=NpointerZ;
  }
  else if(W == TRIFRONT){
    *x=(long)((double)(WindowCentreX[1]-hpos)*WindowPixelSize)+TVcentreX;
    *y=NpointerY;
    *z=(long)((double)(WindowCentreY[1]-vpos)*WindowPixelSize)+TVcentreZ;
  }
  else if(W == TRIRIGHT){
    *x=NpointerX;
    *y=(long)((double)(WindowCentreX[2]-hpos)*WindowPixelSize)+TVcentreY;
    *z=(long)((double)(WindowCentreY[2]-vpos)*WindowPixelSize)+TVcentreZ;
  }
}

void GetWindowCoords1(int W, long x, long y, long z,
                     int *hpos, int *vpos){
 double wdx,wdy;
  if(W == TRITOP){
   *hpos=(int)((double)WindowCentreX[0]-(double)(x-TVcentreX)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[0]+(double)(y-TVcentreY)/WindowPixelSize+ATOL);
  }
  else if(W == TRIFRONT){
   *hpos=(int)((double)WindowCentreX[1]-(double)(x-TVcentreX)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[1]-(double)(z-TVcentreZ)/WindowPixelSize+ATOL);
  }
  else if(W == TRIRIGHT){
   *hpos=(int)((double)WindowCentreX[2]-(double)(y-TVcentreY)/WindowPixelSize+ATOL);
   *vpos=(int)((double)WindowCentreY[2]-(double)(z-TVcentreZ)/WindowPixelSize+ATOL);
  }
}

void SetUpWindowBoxView(int view){
 if(view == 0){
   GetWorldCoords  = GetWorldCoords0;
   GetWindowCoords = GetWindowCoords0;
   WindowBox_view=0;
 }
 else if(view == 1){
   WindowBox_view=1;
   GetWorldCoords  = GetWorldCoords1;
   GetWindowCoords = GetWindowCoords1;
 }
}

void GetTriview(BOOL reset){
 double scale;
 if(reset){
   TVsizeX=TVsizeY=TVsizeZ=UNIT2*4;
   TVcentreX=TVcentreY=TVcentreZ=0;
 }
 if(View == TRIVIEW){
   scale=(double)WindowSizeX[1]/(double)WindowSizeY[1];
   TVsizeX=(long)((double)TVsizeZ*scale);
   scale=(double)WindowSizeX[2]/(double)WindowSizeY[1];
   TVsizeY=(long)((double)TVsizeZ*scale);
   scale=(double)WindowSizeY[0]/(double)WindowSizeX[1];
   TVsizeY=max(TVsizeY,(long)((double)TVsizeX*scale));
 }
 else{
   scale=(double)WindowSizeX[ActiveView]/(double)WindowSizeY[ActiveView];
   if     (ActiveView == TRITOP){
     TVsizeX=(long)((double)TVsizeZ*scale);
   }
   else if(ActiveView == TRIFRONT){
     TVsizeY=TVsizeX=(long)((double)TVsizeZ*scale);
   }
   else if(ActiveView == TRIRIGHT){
     TVsizeY=TVsizeX=(long)((double)TVsizeZ*scale);
   }
 }
 TVpointX=(TVcentreX-TVsizeX/2);
 TVpointY=(TVcentreY-TVsizeY/2);
 TVpointZ=(TVcentreZ-TVsizeZ/2);
 WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
}

void Draw3dCursor(void){
 int i;
 HDC hdc;
 int ifd,ild;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   hdc=GetDC(ghwnd_triview[i]);
//SelectPalette(hdc,ghpaletteScreen,FALSE);
//RealizePalette (hdc);
   DrawOne3dCursor(hdc,i);
   ReleaseDC(ghwnd_triview[i],hdc);
 }
}

void DrawOne3dCursor(HDC hdc, int i){
 int sho,svo,oldROP;
 HPEN holdpen;
 GetWindowCoords(i,NpointerX,NpointerY,NpointerZ,&sho,&svo);
 oldROP=SetROP2(hdc,R2_XORPEN);
 holdpen=SelectObject(hdc,ghCursorPen);
 if(CursorToggle == 0){
   MoveToEx(hdc,sho-10,svo,NULL); LineTo(hdc,sho-3,svo);
   MoveToEx(hdc,sho+3,svo,NULL);  LineTo(hdc,sho+10,svo);
   MoveToEx(hdc,sho,svo-10,NULL); LineTo(hdc,sho,svo-3);
   MoveToEx(hdc,sho,svo+3,NULL);  LineTo(hdc,sho,svo+10);
 }
 else{
   MoveToEx(hdc,0,svo,NULL); LineTo(hdc,WindowSizeX[i],svo);
   MoveToEx(hdc,sho,0,NULL); LineTo(hdc,sho,WindowSizeY[i]);
 }
 SelectObject(hdc,holdpen);
 SetROP2(hdc,oldROP);
}

void Move3dCursor(int stor, int xw, int yw){
 int i;
 HDC hdc;
 HWND hwnd;
 static int xws=0,yws=0;
 long x,y,z,g2;
 int ifd,ild,dx,dy,dxa,dya;
 if(stor){
   xws=xw; yws=yw;
 }
 else if((GetKeyState(VK_SHIFT) & 0x8000)){
//         (tool == GRABBER || tool == NODETOOL)){
   dx=xw-xws; dy=yw-yws;  dxa=abs(dx); dya=abs(dy);
   if(dxa == 0)dxa=1;
   if(dya == 0)dya=1;
   if     (dya < dxa/2)yw=yws;
   else if(dxa < dya/2)xw=xws;
   else if(dya < dxa)yw=yws+(int)((double)dxa*(double)dy/(double)dya);
   else if(dxa < dya)xw=xws+(int)((double)dya*(double)dx/(double)dxa);
 }
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++){
   hwnd=ghwnd_triview[i];
   hdc=GetDC(hwnd);
//   SelectPalette(hdc,ghpaletteScreen,FALSE);
//   RealizePalette (hdc);
   DrawOne3dCursor(hdc,i);
   ReleaseDC(hwnd,hdc);
 }
 GetWorldCoords(ActiveView,&x,&y,&z,xw,yw);
 if(grid_on){
//   g2=grid_size/2;
//   x = lrulerx+((x+(x >= 0  ? g2 : -g2)-lrulerx)/grid_size)*grid_size;
//   y = lrulery+((y+(y >= 0  ? g2 : -g2)-lrulery)/grid_size)*grid_size;
//   z = lrulerz+((z+(z >= 0  ? g2 : -g2)-lrulerz)/grid_size)*grid_size;
   g2=local_grid_size/2;
   x = lrulerx+((x+(x >= 0  ? g2 : -g2)-lrulerx)/local_grid_size)*local_grid_size;
   y = lrulery+((y+(y >= 0  ? g2 : -g2)-lrulery)/local_grid_size)*local_grid_size;
   z = lrulerz+((z+(z >= 0  ? g2 : -g2)-lrulerz)/local_grid_size)*local_grid_size;
 }
 NpointerX=x; NpointerY=y; NpointerZ=z;
 for(i=ifd;i<ild;i++){
   hwnd=ghwnd_triview[i];
   hdc=GetDC(hwnd);
//   SelectPalette(hdc,ghpaletteScreen,FALSE);
//   RealizePalette (hdc);
   DrawOne3dCursor(hdc,i);
   ReleaseDC(hwnd,hdc);
 }
 if(coords_visible)UpdateRuler(0);
}

#define ARROW_ICON_SIZE 12

static HBITMAP hbmArrow[6]={NULL,NULL,NULL,NULL,NULL,NULL};
static int ArrowOK,ArrowID[6]={IDBM_ARROW_Zp,IDBM_ARROW_Zm,
                               IDBM_ARROW_Xp,IDBM_ARROW_Xm,
                               IDBM_ARROW_Yp,IDBM_ARROW_Ym};

void LoadArrowIcons(void){
 int i;
#if 0
 unsigned char camera[64]={
  0x00,0x03,0xc0,0x00,
  0x00,0x03,0xc0,0x00,
  0x00,0x0f,0xf8,0x78,
  0x00,0x0f,0xf8,0x48,
  0x0f,0xfc,0x1f,0xf8,
  0x1f,0xf8,0x0f,0xfc,
  0x19,0xf0,0x07,0xdc,
  0x19,0xf0,0x07,0xdc,
  0x19,0xf0,0x07,0xdc,
  0x19,0xf0,0x07,0xdc,
  0x19,0xf0,0x07,0xdc,
  0x19,0xf8,0x0f,0xdc,
  0x1f,0xfc,0x1f,0xfc,
  0x0f,0xff,0xff,0xf8,
  0x00,0x03,0xe0,0x00,
  0x00,0x00,0x00,0x00
 };
 unsigned char light[32] = {
  0x00,0x00,  0x01,0x80,
  0x03,0xc0,  0x02,0x40,
  0x02,0x40,  0x02,0x40,
  0x02,0x40,  0x02,0x40,
  0x04,0x20,  0x08,0x10,
  0x10,0x08,  0x10,0x08,
  0x10,0x08,  0x08,0x10,
  0x04,0x20,  0x03,0xc0
 };
#endif
 ArrowOK=1;
// Camera and Light use loaded bitmaps. (1 bit bitmaps !!!!)
// ghCameraBitmap=CreateBitmap(32,16,1,1,camera);
// ghLightBitmap=CreateBitmap(16,16,1,1,light);
 ghCameraBitmap=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_I_CAMERA));
 ghLightBitmap=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_I_LIGHT));
 for(i=0;i<6;i++){
   if((hbmArrow[i]=LoadBitmap(ghinst_main,
      MAKEINTRESOURCE(ArrowID[i]))) == NULL)ArrowOK=0;
 }
 if(!Preferences.buttons){
   if((hbmName[0]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_Th))) == NULL)ArrowOK=0;
   if((hbmName[1]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_Rh))) == NULL)ArrowOK=0;
   if((hbmName[2]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_Sh))) == NULL)ArrowOK=0;
   if((hbmName[4]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_Fh))) == NULL)ArrowOK=0;
 }
 else{
   if((hbmName[0]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_T))) == NULL)ArrowOK=0;
   if((hbmName[1]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_R))) == NULL)ArrowOK=0;
   if((hbmName[2]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_S))) == NULL)ArrowOK=0;
   if((hbmName[4]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_F))) == NULL)ArrowOK=0;
 }
 if((hbmName[5]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(IDBM_WIN_C))) == NULL)ArrowOK=0;
}

void DrawArrowIcons(HDC hDC, int id){
 int i,ic,x,y;
 HDC hMemDC;
 HBITMAP hbmOld;
 HBRUSH holdBrush;
 static int arrow_table[2][3][4]={
  {{3,2,4,5} ,     /* top   */
   {3,2,0,1} ,     /* rear  */
   {5,4,0,1} } ,   /* right */
  {{2,3,5,4} ,
   {2,3,0,1} ,
   {4,5,0,1} }
 };
 if(!ArrowOK)return;
 hMemDC = CreateCompatibleDC(hDC);
 for(i=0;i<4;i++){
   ic=arrow_table[WindowBox_view][id][i];
   if(i == 0)hbmOld = SelectObject(hMemDC,hbmArrow[ic]);
   else      SelectObject(hMemDC,hbmArrow[ic]);
   if     (i == 0){x=0; y=WindowSizeY[id]/2-ARROW_ICON_SIZE/2;}
   else if(i == 1){x=WindowSizeX[id]-ARROW_ICON_SIZE-1;
                   y=WindowSizeY[id]/2-ARROW_ICON_SIZE/2;}
   else if(i == 2){x=WindowSizeX[id]/2-ARROW_ICON_SIZE/2; y=0;}
   else if(i == 3){x=WindowSizeX[id]/2-ARROW_ICON_SIZE/2;
                   y=WindowSizeY[id]-ARROW_ICON_SIZE-1;}
   BitBlt(hDC,x,y,ARROW_ICON_SIZE,ARROW_ICON_SIZE,hMemDC,0,0,SRCPAINT);
 }
 SelectObject(hMemDC,hbmName[id]);

// x=WindowSizeX[id]-WINDOW_ID_XSIZE-1;
// y=WindowSizeY[id]-WINDOW_ID_YSIZE-1;
 x=0;
 y=0;

 if(!Preferences.buttons)
      BitBlt(hDC,x,y,WINDOW_ID_XSIZE,WINDOW_ID_YSIZE,hMemDC,0,0,SRCPAINT);
 else BitBlt(hDC,x,y,WINDOW_ID_XSIZE,WINDOW_ID_YSIZE,hMemDC,0,0,SRCCOPY);
 if(View == ONEVIEW){

//   x=1;
//   y=WindowSizeY[id]-WINDOW_ID_YSIZE-1;

   x=WindowSizeX[id]-2*WINDOW_ID_XSIZE-1;
   y=0;

   holdBrush=SelectObject(hDC,GetStockObject(LTGRAY_BRUSH));
   for(i=0;i<3;i++)if(i != id){
     SelectObject(hMemDC,hbmName[i]);
     if(!Preferences.buttons){
       BitBlt(hDC,x,y,WINDOW_ID_XSIZE,WINDOW_ID_YSIZE,hMemDC,0,0,0x00220326); /*  DSna */
       BitBlt(hDC,x,y,WINDOW_ID_XSIZE,WINDOW_ID_YSIZE,hMemDC,0,0,0x00ea02e9); /* DPSao */
     }
     else BitBlt(hDC,x,y,WINDOW_ID_XSIZE,WINDOW_ID_YSIZE,hMemDC,0,0,SRCCOPY);
     x+=WINDOW_ID_XSIZE;
   }
   SelectObject(hDC,holdBrush);
 }
 SelectObject(hMemDC, hbmOld);
 DeleteDC(hMemDC);
}

int CheckWindowIcon(int xi, int yi){
#if 0
 int i,x,y;
 if(xi > WindowSizeX[ActiveView]-WINDOW_ID_XSIZE &&
    xi < WindowSizeX[ActiveView] &&
    yi > WindowSizeY[ActiveView]-WINDOW_ID_YSIZE &&
    yi < WindowSizeY[ActiveView])return 4;
 if(View == ONEVIEW){
   if(xi > 1 && xi < WINDOW_ID_XSIZE &&
      yi > WindowSizeY[ActiveView]-WINDOW_ID_YSIZE &&
      yi < WindowSizeY[ActiveView])return 5;
   if(xi > 1+WINDOW_ID_XSIZE && xi < 2*WINDOW_ID_XSIZE &&
      yi > WindowSizeY[ActiveView]-WINDOW_ID_YSIZE &&
      yi < WindowSizeY[ActiveView])return 6;
 }
#endif
 if(xi >=0 &&
    xi < WINDOW_ID_XSIZE &&
    yi >=0 &&
    yi < WINDOW_ID_YSIZE)return 4;
 if(View == ONEVIEW){
   if(xi > WindowSizeX[ActiveView]-2*WINDOW_ID_XSIZE &&
      xi < WindowSizeX[ActiveView]-WINDOW_ID_XSIZE &&
      yi > 0 &&
      yi < WINDOW_ID_YSIZE)return 5;
   if(xi > WindowSizeX[ActiveView]-WINDOW_ID_XSIZE &&
      xi < WindowSizeX[ActiveView] &&
      yi > 0 &&
      yi < WINDOW_ID_YSIZE)return 6;
 }
 return -1;
}

void InvertWindowIcon(int i, HWND hwnd){
 HDC hdc;
 RECT rc;
 if     (i == 0){rc.left=0;
                 rc.top=WindowSizeY[ActiveView]/2-ARROW_ICON_SIZE/2;}
 else if(i == 1){rc.left=WindowSizeX[ActiveView]-ARROW_ICON_SIZE-1;
                 rc.top=WindowSizeY[ActiveView]/2-ARROW_ICON_SIZE/2;}
 else if(i == 2){rc.left=WindowSizeX[ActiveView]/2-ARROW_ICON_SIZE/2;
                 rc.top=0;}
 else if(i == 3){rc.left=WindowSizeX[ActiveView]/2-ARROW_ICON_SIZE/2;
                 rc.top=WindowSizeY[ActiveView]-ARROW_ICON_SIZE-1;}
 if(i > 3){
#if 0
   rc.top = WindowSizeY[ActiveView]-WINDOW_ID_YSIZE;
   if     (i == 4)rc.left=WindowSizeX[ActiveView]-WINDOW_ID_XSIZE;
   else if(i == 5)rc.left=1;
   else if(i == 6)rc.left=1+WINDOW_ID_XSIZE;
#endif
   rc.top = 0;
   if     (i == 4)rc.left=0;
   else if(i == 5)rc.left=WindowSizeX[ActiveView]-2*WINDOW_ID_XSIZE;
   else if(i == 6)rc.left=WindowSizeX[ActiveView]-WINDOW_ID_XSIZE;
   rc.right=rc.left+WINDOW_ID_XSIZE;
   rc.bottom=rc.top+WINDOW_ID_YSIZE;
 }
 else{  /* other corner for arrows */
   rc.right=rc.left+ARROW_ICON_SIZE;
   rc.bottom=rc.top+ARROW_ICON_SIZE;
 }
 hdc=GetDC(hwnd);
 InvertRect(hdc,&rc);
 ReleaseDC(hwnd,hdc);
 return;
}

int CheckViewWindowIcon(int xi, int yi){
 int i,x,y;
// if(xi > WindowViewXsize-WINDOW_ID_VSIZE && xi < WindowViewXsize &&
//    yi > WindowViewYsize-WINDOW_ID_YSIZE && yi < WindowViewYsize)return 1;

 if(xi > 0 && xi < WINDOW_ID_VSIZE &&
    yi > 0 && yi < WINDOW_ID_YSIZE)return 1;

 return -1;
}

void InvertViewWindowIcon(int i, HWND hwnd){
 HDC hdc;
 RECT rc;
 if(i == 1){
//   rc.top=WindowViewYsize-WINDOW_ID_YSIZE;
//   rc.left=WindowViewXsize-WINDOW_ID_VSIZE;

   rc.top=0;
   rc.left=0;

   rc.right=rc.left+WINDOW_ID_VSIZE;
   rc.bottom=rc.top+WINDOW_ID_YSIZE;
 }
 hdc=GetDC(hwnd);
 InvertRect(hdc,&rc);
 ReleaseDC(hwnd,hdc);
 return;
}

void DeleteArrowIcons(void){
 int i;
 for(i=0;i<6;i++){
   if(hbmArrow != NULL)DeleteObject(hbmArrow[i]);
   hbmArrow[i]=NULL;
 }
 if(hbmName[0] != NULL)DeleteObject(hbmName[0]); hbmName[0]=NULL;
 if(hbmName[1] != NULL)DeleteObject(hbmName[1]); hbmName[1]=NULL;
 if(hbmName[2] != NULL)DeleteObject(hbmName[2]); hbmName[2]=NULL;
 if(hbmName[4] != NULL)DeleteObject(hbmName[4]); hbmName[4]=NULL;
}

void SwapViewBitmaps(void){
 HBITMAP hbmTemp;
 hbmTemp=hbmName[1];
 hbmName[1]=hbmName[4];
 hbmName[4]=hbmTemp;
}

static BOOL CALLBACK ThreeRealsDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 char tempstr[128];
 struct np {char *title,*name1,*name2,*name3; double cal1,cal2,cal3;} *dp;
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:{
       RECT rcDlg;
       POINT p;
       dp=(struct np *)lparam;
       SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)dp->title);
       SendDlgItemMessage(hwnd,DLG_3REALS_NAME1,WM_SETTEXT,0,(LPARAM)dp->name1);
       SendDlgItemMessage(hwnd,DLG_3REALS_NAME2,WM_SETTEXT,0,(LPARAM)dp->name2);
       SendDlgItemMessage(hwnd,DLG_3REALS_NAME3,WM_SETTEXT,0,(LPARAM)dp->name3);
       sprintf(tempstr,"%.4lf",dp->cal1);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL1,WM_SETTEXT,0,(LPARAM)tempstr);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL1,EM_LIMITTEXT,(WPARAM)12,0);
       sprintf(tempstr,"%.4lf",dp->cal2);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL2,WM_SETTEXT,0,(LPARAM)tempstr);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL2,EM_LIMITTEXT,(WPARAM)12,0);
       sprintf(tempstr,"%.4lf",dp->cal3);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL3,WM_SETTEXT,0,(LPARAM)tempstr);
       SendDlgItemMessage(hwnd,DLG_3REALS_CAL3,EM_LIMITTEXT,(WPARAM)12,0);
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       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,Yres-rcDlg.bottom,0);
       SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
     }
     return (TRUE);
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
        case DLG_3REALS_CANCEL:
          EndDialog(hwnd, FAIL);
          return(TRUE);
        case IDOK:
        case DLG_3REALS_OK:
          dp=(struct np *)GetWindowLong(hwnd,GWL_USERDATA);
          if(GetDlgItemText(hwnd,DLG_3REALS_CAL1,tempstr,10) == 0)goto CANCELX;
          dp->cal1=atof(tempstr);
          if(GetDlgItemText(hwnd,DLG_3REALS_CAL2,tempstr,10) == 0)goto CANCELX;
          dp->cal2=atof(tempstr);
          if(GetDlgItemText(hwnd,DLG_3REALS_CAL3,tempstr,10) == 0)goto CANCELX;
          dp->cal3=atof(tempstr);
          EndDialog(hwnd,OK);
          return(TRUE);
          CANCELX:
          EndDialog(hwnd,FAIL);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

int Read3Reals(char *title, double *r1, double *r2, double *r3, int list){
 int rv;
 char ttt[24];
 char lists0[]="                        ";
 char lists1[]="                        ";
 char lists2[]="                        ";
 char lists3[]="                        ";
 char lists4[]="                        ";
 char lists5[]="                        ";
 struct np {char *title,*name1,*name2,*name3; double cal1,cal2,cal3;} d,*dp;
 LoadString(ghinst_main,IDX_MISC_LEFT_RIGHT,ttt,24);
 strcpy(lists0,ttt);
 LoadString(ghinst_main,IDX_MISC_BACK_FRONT,ttt,24);
 strcpy(lists1,ttt);
 LoadString(ghinst_main,IDX_MISC_UP_DOWN,ttt,24);
 strcpy(lists2,ttt);
 LoadString(ghinst_main,IDX_MISC_DIRECTION,ttt,24);
 strcpy(lists3,ttt);
 LoadString(ghinst_main,IDX_MISC_ELEVATION,ttt,24);
 strcpy(lists4,ttt);
 LoadString(ghinst_main,IDX_MISC_BANK,ttt,24);
 strcpy(lists5,ttt);
 d.title=title;
 if(list == 0){
   d.name1=lists0;
   d.name2=lists1;
   d.name3=lists2;
 }
 else{
   d.name1=lists3;
   d.name2=lists4;
   d.name3=lists5;
 }
 d.cal1 = *r1;
 d.cal2 = *r2;
 d.cal3 = *r3;
 EnableToolPannels(ALL_PANNELS,FALSE);
 if(DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_3REALS),ghwnd_main,
            (DLGPROC)ThreeRealsDlgProc,(LPARAM)&d) == OK){
   *r1 = d.cal1;
   *r2 = d.cal2;
   *r3 = d.cal3;
   rv=OK;
 }
 else rv=FAIL;
 EnableToolPannels(ALL_PANNELS,TRUE);
 return rv;
}

static char *ColorSelectDlgString;

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

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

void SetSfxColour(unsigned char colour[], long ID, HWND parent){
 char szTitle[256];
 LoadString(ghinst_main,ID,szTitle,255);
 SetColour(colour,szTitle,parent);
}

void scal(double t[4][4], double sx, double sy, double sz){
 long i,j;
 for(i=0;i<4;i++) for(j=0;j<4;j++) t[i][j]=0.0;
 t[0][0]=sx; t[1][1]=sy; t[2][2]=sz; t[3][3]=1;
 return;
}

void rotz(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][1]=-sin(ang);
  tr[1][0]= sin(ang);
  tr[1][1]= cos(ang);
  return;
}

void roty(double tr[4][4], double ang){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[0][0]= cos(ang);
  tr[0][2]=-sin(ang);
  tr[2][0]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

void rotx(double tr[4][4], double ang){
 long i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  if(i == j)tr[i][j]=1.0;
 }
  tr[1][1]= cos(ang);
  tr[1][2]=-sin(ang);
  tr[2][1]= sin(ang);
  tr[2][2]= cos(ang);
  return;
}

void tram(double t[4][4], double dx, double dy, double dz){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  t[i][j]=0.0;
  if(i == j)t[i][j]=1.0;
 }
 t[0][3]=dx;
 t[1][3]=dy;
 t[2][3]=dz;
 t[3][3]=1;
 return;
}

void m4by4(double t1[4][4], double t2[4][4], double tr[4][4]){
 short n=4,i,j,k;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 {
  tr[i][j]=0.0;
  for(k=0;k<4;k++)tr[i][j]=tr[i][j]+t1[i][k]*t2[k][j];
 }
 return;
}

void m4by1(double t4[4][4], double x, double y, double z,
           double *xx, double *yy, double *zz){
 *xx=t4[0][0]*x+t4[0][1]*y+t4[0][2]*z+t4[0][3];
 *yy=t4[1][0]*x+t4[1][1]*y+t4[1][2]*z+t4[1][3];
 *zz=t4[2][0]*x+t4[2][1]*y+t4[2][2]*z+t4[2][3];
 return;
}

void c4to4(double tin[4][4], double tout[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 tout[i][j]=tin[i][j];
}

void null_transform(double t[4][4]){
 short i,j;
 for(i=0;i<4;i++)
 for(j=0;j<4;j++)
 if(i == j)t[i][j]=1.0;
 else      t[i][j]=0.0;
}

void arbitrary_rotate(double angle, point p1, point p2, double t[4][4]){
  double dx,dy,dz,phi,theta,dxy;
  double t1[4][4],t2[4][4],t3[4][4];
  angle *= PI/180.0;
  dx=p2[0]-p1[0]; dy=p2[1]-p1[1]; dz=p2[2]-p1[2];
  dxy=dx*dx+dy*dy;
  tram(t1, -p1[0], -p1[1], -p1[2]);
  if(dxy < 1.0){ /* vertical so just rotate about z  and return */
    rotz(t2, angle);
    m4by4(t2,t1,t3);
    tram(t1,p1[0],p1[1],p1[2]);
    m4by4(t1,t3,t);
    return;
  }
  dxy=sqrt(dxy);
  if     (dx == 0.0 && dy > 0.0)phi =  PI2;
  else if(dx == 0.0 && dy < 0.0)phi = -PI2;
  else phi = atan2(dy,dx);
  theta = atan2(dz,dxy);
  rotz(t2, -phi);
  m4by4(t2,t1,t3);
  roty(t2, -theta);
  m4by4(t2,t3,t1);
  rotx(t2, angle);
  m4by4(t2,t1,t3);
  roty(t2,theta);
  m4by4(t2,t3,t1);
  rotz(t2,phi);
  m4by4(t2,t1,t3);
  tram(t1,p1[0],p1[1],p1[2]);
  m4by4(t1,t3,t);
}

void L_cross(point p1, point p2, point p3, point p4){
 double v1[3],v2[3],r[3];
 v1[0]=(double)(p2[0]-p1[0]);
 v1[1]=(double)(p2[1]-p1[1]);
 v1[2]=(double)(p2[2]-p1[2]);
 v2[0]=(double)(p3[0]-p1[0]);
 v2[1]=(double)(p3[1]-p1[1]);
 v2[2]=(double)(p3[2]-p1[2]);
 r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);
 r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);
 r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);
 p4[0] = p1[0] + (long)(r[0]/UNIT);
 p4[1] = p1[1] + (long)(r[1]/UNIT);
 p4[2] = p1[2] + (long)(r[2]/UNIT);
}

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

static BOOL CALLBACK CoordinateDlgProc(HWND hwnd, UINT msg,
                                    WPARAM wparam, LPARAM lparam){
 char tempstr[128];
 struct np {char *name; double cal;} *dp;
 switch( msg ) {
   case WM_INITDIALOG:{
       RECT rcDlg;
       POINT p;
       dp=(struct np *)lparam;
       SendDlgItemMessage(hwnd,DLG_COORD_NAME,WM_SETTEXT,0,(LPARAM)dp->name);
       SendDlgItemMessage(hwnd,DLG_COORD_NAME,EM_LIMITTEXT,(WPARAM)6,0);
       sprintf(tempstr,"%.4lf",dp->cal);
       SendDlgItemMessage(hwnd,DLG_COORD_CAL,WM_SETTEXT,0,(LPARAM)tempstr);
       SendDlgItemMessage(hwnd,DLG_COORD_CAL,EM_LIMITTEXT,(WPARAM)12,0);
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       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,Yres-rcDlg.bottom,0);
       SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
     }
     return (TRUE);
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
        case DLG_COORD_CANCEL:
          EndDialog(hwnd, FAIL);
          return(TRUE);
        case IDOK:
        case DLG_COORD_OK:
          dp=(struct np *)GetWindowLong(hwnd,GWL_USERDATA);
          if(GetDlgItemText(hwnd,DLG_COORD_NAME,dp->name,7) == 0)goto CANCELX;
          if(GetDlgItemText(hwnd,DLG_COORD_CAL,tempstr,10) == 0)goto CANCELX;
          dp->cal=atof(tempstr);
          EndDialog(hwnd,OK);
          return(TRUE);
          CANCELX:
          EndDialog(hwnd, FAIL);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

void UpdateRuler(short m){
 double dx,dy,dz;
 char tempstr[32];
 if(m == 1){ /* cancel */
   rulerx=NpointerX; rulery=NpointerY; rulerz=NpointerZ;
 }
 if(m == 2){ /* set origin*/
   if(SendPrgmQuery(IDQ_SET_COORD_ORIGIN,1) != IDYES)return;
   EDIT_ACTION=YES;
   lrulerx=NpointerX; lrulery=NpointerY; lrulerz=NpointerZ;
 }
 if(m == 3){ /* set ruler */
   char name[10];
   struct np {char *name; double cal;} d;
   dx = (double)(NpointerX-lrulerx);
   dy = (double)(NpointerY-lrulery);
   dz = (double)(NpointerZ-lrulerz);
   if(dx < (double)MINUNIT || dy < (double)MINUNIT || dz < (double)MINUNIT){
     double dd;
     EDIT_ACTION=YES;
     if(ruler_name[0] == 0)strcpy(name,"<cms>");
     else                  strcpy(name,ruler_name);
     dd=sqrt(dx*dx+dy*dy+dz*dz);
     d.name=name; d.cal=dd/ruler;
     EnableToolPannels(ALL_PANNELS,FALSE);
     if(DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_COORD),ghwnd_main,
                (DLGPROC)CoordinateDlgProc,(LPARAM)&d) == OK){
       strcpy(ruler_name,d.name);
       LoadString(ghinst_main,IDX_MISC_COORDS,tempstr,32);
       strcat(tempstr,ruler_name);
       SendMessage(ghwndCoord1,WM_SETTEXT,0,(LPARAM)tempstr);
       ruler = dd;
       if(d.cal > 0.0)ruler /= d.cal;
     }
     EnableToolPannels(ALL_PANNELS,TRUE);
   }
   else SendPrgmQuery(IDQ_COORD_BAD_RANGE,0);
 }
 SendMessage(ghwndCoord1,WM_COMMAND,IDC_COORD_UPDATE,0);
}

static BOOL CALLBACK GridSizeDlgProc(HWND hwnd, UINT msg,
                                     WPARAM wparam, LPARAM lparam){
 double d;
 char size[16];
 switch( msg ) {
   case WM_INITDIALOG:{
       RECT rcDlg;
       POINT p;
       SetWindowLong(hwnd,GWL_USERDATA,lparam);
       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,Yres-rcDlg.bottom,0);
       SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
       if(draw_grid_on)SendDlgItemMessage(hwnd,DLG_GRIDSIZE_ON ,BM_SETCHECK,1,0);
       else            SendDlgItemMessage(hwnd,DLG_GRIDSIZE_OFF,BM_SETCHECK,1,0);
       sprintf(size,"%.4lf",((double)grid_size)/ruler);
       SendDlgItemMessage(hwnd,DLG_GRIDSIZE_EDIT,WM_SETTEXT,0,
                          (LPARAM)(LPSTR)size);
       SendDlgItemMessage(hwnd,DLG_GRIDSIZE_EDIT,EM_LIMITTEXT,12,0);
     }
     SetFocus(GetDlgItem(hwnd,DLG_GRIDSIZE_OK)); return(FALSE);
     return (TRUE);  /* must be used unless SetFocus */
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case IDCANCEL:
        case DLG_GRIDSIZE_CANCEL:
          EndDialog(hwnd, FAIL);
          return(TRUE);
        case IDOK:
        case DLG_GRIDSIZE_OK:
          if(SendDlgItemMessage(hwnd,DLG_GRIDSIZE_ON,BM_GETCHECK,0,0))
               draw_grid_on=1;
          else draw_grid_on=0;
          if(GetDlgItemText(hwnd,DLG_GRIDSIZE_EDIT,size,12)){
            if((d=atof(size)) > 0.0)grid_size=(long)(d*ruler);
          }
          EndDialog(hwnd,OK);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

void SetUpGrid(void){
 EnableToolPannels(ALL_PANNELS,FALSE);
 DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_GRIDSIZE),ghwnd_main,
            (DLGPROC)GridSizeDlgProc);
 EnableToolPannels(ALL_PANNELS,TRUE);
 return;
}

#if 0
void DrawGrid(HDC hdc[]){
 int ifd,ild;
 int ng,ngx,ngy,ngz,ng1,ng2,j,k,xx[50],yy[50],d;
 long i,x,y,z,x1,y1,z1,g2;
 HPEN hOldPen[3];
 BOOL bSmall=FALSE;
// LOGPEN lopn;
// GetObject(ghSelectedPen,sizeof(LOGPEN),&lopn);
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 g2=grid_size/2;
 x=TVpointX; y=TVpointY; z=TVpointZ;
 x1 = lrulerx+((x+(x >= 0  ? g2 : -g2)-lrulerx)/grid_size)*grid_size;
 y1 = lrulery+((y+(y >= 0  ? g2 : -g2)-lrulery)/grid_size)*grid_size;
 z1 = lrulerz+((z+(z >= 0  ? g2 : -g2)-lrulerz)/grid_size)*grid_size;
 if(x1 <= TVpointX)x1 += grid_size;
 if(y1 <= TVpointY)y1 += grid_size;
 if(z1 <= TVpointZ)z1 += grid_size;
 ngx=(short)(TVsizeX/grid_size);
 ngy=(short)(TVsizeY/grid_size);
 ngz=(short)(TVsizeZ/grid_size);
 ng = max(ngx,ngy);   ng=max(ngz,ng); ng++;
 if((View == TRIVIEW && ng > 25)  || ng > 50 || ng == 0)return;
 if((View == TRIVIEW && ng > 10)  || ng > 20)bSmall=TRUE;
 for(i=ifd;i<ild;i++){
   hOldPen[i]=SelectObject(hdc[i],GetStockObject(BLACK_PEN));
   ng1 = ng2 = -1; x=x1; y=y1; z=z1;
   for(j=0;j<ng;j++){
     GetWindowCoords(i,x,y,z,&xx[j],&yy[j]);
     x += grid_size; y += grid_size; z += grid_size;
     if(WindowBox_view == 0){
       if(xx[j] >= WindowSizeX[i] && ng1 < 0)ng1=j;
       if(yy[j] <= 0               && ng2 < 0)ng2=j;
     }
     else{
       if(xx[j] <= 0 && ng1 < 0)ng1=j;
       if(i==TRITOP){if(yy[j] >= WindowSizeY[i] && ng2 < 0)ng2=j;}
       else         {if(yy[j] <= 0              && ng2 < 0)ng2=j;}
     }
   }
   if(ng1 < 0)ng1=ng; if(ng2 < 0)ng2=ng;
   if(ng1 > 0 && ng2 > 0)for(j=0;j<ng2;j++)for(k=0;k<ng1;k++){
//     X__SetPixel(hdc[i],xx[k],yy[j],lopn.lopnColor);
     if(bSmall){
       MoveToEx(hdc[i],xx[k],yy[j],NULL); LineTo(hdc[i],xx[k]+1,yy[j]);
     }
     else{
       MoveToEx(hdc[i],xx[k]-2,yy[j],NULL); LineTo(hdc[i],xx[k]+3,yy[j]);
       MoveToEx(hdc[i],xx[k],yy[j]-2,NULL); LineTo(hdc[i],xx[k],yy[j]+3);
     }
   }
   SelectObject(hdc[i],hOldPen[i]);
 }
 return;
}
#endif

void DrawGrid(HDC hdc[]){
 int ifd,ild;
 COLORREF OldColour;
 HPEN hPen1,hPen2,hPen3,hOldPen,hTempPen;
 BOOL flagx[50],flagy[50];
 int ng,ngx,ngy,ngz,ng1,ng2,j,k,xx[50],yy[50],d;
 long i,x,y,z,x1,y1,z1,g2,nx,ny,nz,iter;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 local_grid_size=grid_size/10;
 iter=0;
 TRYAGAIN:
 g2=local_grid_size/2;
 x=TVpointX; y=TVpointY; z=TVpointZ;
 x1 = lrulerx+((x+(x >= 0  ? g2 : -g2)-lrulerx)/local_grid_size)*local_grid_size;
 y1 = lrulery+((y+(y >= 0  ? g2 : -g2)-lrulery)/local_grid_size)*local_grid_size;
 z1 = lrulerz+((z+(z >= 0  ? g2 : -g2)-lrulerz)/local_grid_size)*local_grid_size;
 if(x1 <= TVpointX)x1 += local_grid_size;
 if(y1 <= TVpointY)y1 += local_grid_size;
 if(z1 <= TVpointZ)z1 += local_grid_size;
 ngx=(short)(TVsizeX/local_grid_size);
 ngy=(short)(TVsizeY/local_grid_size);
 ngz=(short)(TVsizeZ/local_grid_size);
 ng = max(ngx,ngy);   ng=max(ngz,ng); ng++;
 if(ng == 0)return;
 if(ng > 30){
   local_grid_size *= 10;
   if(iter++ > 100)return;
   goto TRYAGAIN;
 }
 for(i=ifd;i<ild;i++){
   ng1 = ng2 = -1; x=x1; y=y1; z=z1;
   for(j=0;j<ng;j++){
     nx = labs(x-lrulerx)/local_grid_size;
     ny = labs(y-lrulery)/local_grid_size;
     nz = labs(z-lrulerz)/local_grid_size;
     flagx[j]=flagy[j]=FALSE;
     if(i == TRIRIGHT){
       nx=ny;
       ny=nz;
     }
     else if(i == TRIFRONT){
       ny=nz;
     }
     if(nx%10 == 0)flagx[j]=TRUE;
     if(ny%10 == 0)flagy[j]=TRUE;
     GetWindowCoords(i,x,y,z,&xx[j],&yy[j]);
     x += local_grid_size; y += local_grid_size; z += local_grid_size;
     if(WindowBox_view == 0){
       if(xx[j] >= WindowSizeX[i] && ng1 < 0)ng1=j;
       if(yy[j] <= 0              && ng2 < 0)ng2=j;
     }
     else{
       if(xx[j] <= 0 && ng1 < 0)ng1=j;
       if(i==TRITOP){if(yy[j] >= WindowSizeY[i] && ng2 < 0)ng2=j;}
       else         {if(yy[j] <= 0              && ng2 < 0)ng2=j;}
     }
   }
   if(ng1 < 0)ng1=ng; if(ng2 < 0)ng2=ng;
   if(iter == 0)hPen1=CreatePen(PS_DOT,0,gGridColourRef1);
   else         hPen1=CreatePen(PS_SOLID,0,gGridColourRef1);
   hPen2=CreatePen(PS_SOLID,0,gGridColourRef2);
   hPen3=CreatePen(PS_SOLID,0,RGB(255,255,255));
   OldColour=SetBkColor(hdc[i],gScreenColourRef);
   hOldPen=SelectObject(hdc[i],hPen1);
   x= -1; y = -1;
   if(lrulerx > TVpointX || lrulerx < TVpointX+TVsizeX ||
      lrulery > TVpointY || lrulery < TVpointY+TVsizeY ||
      lrulerz > TVpointZ || lrulerz < TVpointZ+TVsizeZ){
     GetWindowCoords(i,lrulerx,lrulery,lrulerz,(int *)(&x),(int *)&y);
   }
   if(ng1 > 0 && ng2 > 0){
     for(j=0;j<ng2;j++){
       if(yy[j] == y)continue;
       if(flagy[j])hTempPen=SelectObject(hdc[i],hPen2);
       MoveToEx(hdc[i],0,yy[j],NULL); LineTo(hdc[i],WindowSizeX[i]+1,yy[j]);
       if(flagy[j])SelectObject(hdc[i],hTempPen);
     }
     for(k=0;k<ng1;k++){
       if(xx[k] == x)continue;
       if(flagx[k])hTempPen=SelectObject(hdc[i],hPen2);
       MoveToEx(hdc[i],xx[k],0,NULL); LineTo(hdc[i],xx[k],WindowSizeY[i]+1);
       if(flagx[k])SelectObject(hdc[i],hTempPen);
     }
   }
   SetBkColor(hdc[i],OldColour);
   SelectObject(hdc[i],hPen3);
   if(y >= 0 && y <= WindowSizeY[i]){
     MoveToEx(hdc[i],0,y,NULL); LineTo(hdc[i],WindowSizeX[i]+1,y);
   }
   if(x >= 0 && x <= WindowSizeX[i]){
     MoveToEx(hdc[i],x,0,NULL); LineTo(hdc[i],x,WindowSizeY[i]+1);
   }
   SelectObject(hdc[i],hOldPen);
   DeleteObject(hPen1);
   DeleteObject(hPen2);
   DeleteObject(hPen3);
 }
 return;
}