SELECT.C

Go to the documentation of this file.

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


/* file SELECT.C  file containing select functions */

#define MODULE_SELECT 1

#include "design.h"

static void DrawLassoList(HDC hDC);
static void DrawCircle(HDC hDC,int xx, int yy, int x, int y);
static BOOL SelectBezier(void);
static BOOL SelectMappedVertices(int status);
static void DeSelectEvery(void);

static BOOL CALLBACK SelectByColourDlgProc(HWND hdlg,UINT msg,
                           WPARAM wparam,LPARAM lparam){
 switch( msg ) {
   case WM_PAINT:
     PaintDialogBackground(hdlg,ghinst_main);
     break;
   case WM_INITDIALOG:
     EnableToolPannels(ALL_PANNELS,FALSE);
     CentreDialogOnCursor(hdlg);
     return (TRUE);
   case WM_DESTROY:
     EnableToolPannels(ALL_PANNELS,TRUE);
     break;
   case WM_DRAWITEM:{
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       LPDRAWITEMSTRUCT lpdis;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_COLSELECT_COLOUR){
         r=LastColour[0]; g=LastColour[1]; b=LastColour[2];
         if(lpdis->itemState & ODS_SELECTED)
            InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_COLSELECT_COLOUR:
          SetSfxColour(LastColour,IDX_MISC_CHOOSE_COLOUR,hdlg);
          InvalidateRect(GetDlgItem(hdlg,DLG_COLSELECT_COLOUR),NULL,FALSE);
          break;
        case IDCANCEL:
          EndDialog(hdlg,-1);
          return(TRUE);
        case DLG_COLSELECT_NEAR:
          EndDialog(hdlg,1);
          return(TRUE);
        case IDOK:
          EndDialog(hdlg,0);
          return(TRUE);
        default:  break;
      }
      break;
    default: break;
 }
 return(FALSE);
}

void ExecuteSelect(int item){
 long i;
 vertex *Vx,*vp;
 face *fp;
 Vx=NULL;
 if(Nvert == 0){
   SendPrgmQuery(IDQ_TOOFEWITEMS,0);
   return;
 }
 EDIT_ACTION=YES;
 switch(item){
   case IDM_EDIT_SELECTMAPPED:
     if(!SelectMappedVertices(SELECTED))return;
     break;
   case IDM_EDIT_DESELECTMAPPED:
     if(!SelectMappedVertices(DESELECTED))return;
     break;
   case IDM_EDIT_SELECTBY_COLOUR:{
       int id,i,j,lim=1;
       if(Nface == 0){
         SendPrgmQuery(IDQ_TOOFEWFACES,0);
         return;
       }
       id=DialogBox(ghinst_main,MAKEINTRESOURCE(DLG_COLSELECT),ghwnd_main,
                (DLGPROC)SelectByColourDlgProc);
       if(id < 0)return;
       if(id == 1)lim=32;
       else lim=1;
       fp=MainFp; if(MainFp != NULL && Nface > 0)for(i=0;i<Nface;i++){
         if(abs(fp->color[0] - LastColour[0]) < lim &&
            abs(fp->color[1] - LastColour[1]) < lim &&
            abs(fp->color[2] - LastColour[2]) < lim){
           for(j=0;j<3;j++){
             if((MainVp+fp->V[j])->status == DESELECTED){
               (MainVp+fp->V[j])->status=SELECTED;
               NvertSelect++; NvertDeselect--;
             }
           }
         }
         fp++;
       }
     }
     break;
   case IDM_EDIT_SELECTBY_MAP:{
       int id,j;
       if(Nface == 0)return;
       if(nImaps < 1){
         SendPrgmQuery(IDQ_NOBRUSH,0);
         return;
        }
        else if(nImaps > 1){
         if((id=RequestMapID(ghwnd_main,"Select by Map",0)) < 0)return;
       }
       else  id=0;
       fp=MainFp; if(MainFp != NULL && Nface > 0)for(i=0;i<Nface;i++){
         if( (int)(fp->imagemap) == id){
           for(j=0;j<3;j++){
             if((MainVp+fp->V[j])->status == DESELECTED){
               (MainVp+fp->V[j])->status=SELECTED;
               NvertSelect++; NvertDeselect--;
             }
           }
         }
         fp++;
       }
     }
     break;
   case IDM_EDIT_SELECTBY_SHADER:{
       int id,j;
       if(Nface == 0)return;
       if(nMats == 1)id=0;
       else{
         id=RequestMaterialID(ghwnd_main,"Select by Material");
         if(id < 0)return;
       }
       fp=MainFp; if(MainFp != NULL && Nface > 0)for(i=0;i<Nface;i++){
         if((int)(fp->material) == id){
           for(j=0;j<3;j++){
             if((MainVp+fp->V[j])->status == DESELECTED){
               (MainVp+fp->V[j])->status=SELECTED;
               NvertSelect++; NvertDeselect--;
             }
           }
         }
         fp++;
       }
     }
     break;
   case IDM_EDIT_SELECTBY_BEZIER:
     if(!SelectBezier())return;
     break;
   case IDM_EDIT_SELECTBY_INVIEW:
   case IDM_EDIT_SELECTBY_OUTVIEW:
     vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
       if(vp->status != HIDDEN){
         if(intriview(vp)){
           if(item == IDM_EDIT_SELECTBY_INVIEW && vp->status == DESELECTED){
             vp->status=SELECTED; NvertSelect++; NvertDeselect--;
           }
         }
         else{
           if(item == IDM_EDIT_SELECTBY_OUTVIEW && vp->status == DESELECTED){
             vp->status=SELECTED; NvertSelect++; NvertDeselect--;
           }
         }
       }
       vp++;
     }
     break;
   case IDM_EDIT_SELECTCONNECT:
     SelectConnected(SELECTED);
     return;
   case IDM_EDIT_DESELECTCONNECT:
     SelectConnected(DESELECTED);
     return;
   case IDM_EDIT_DESELECT_EVERY:
     DeSelectEvery();
     break;
   case IDM_EDIT_SELECTALL:
   case IDM_EDIT_DESELECTALL:
   case IDM_EDIT_SWAPSELECT:
     vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
       if(item == IDM_EDIT_SELECTALL &&
          vp->status != HIDDEN && vp->status==DESELECTED){
         vp->status=SELECTED; NvertSelect++; NvertDeselect--;
       }
       else if(item == IDM_EDIT_DESELECTALL &&
          vp->status != HIDDEN && vp->status==SELECTED){
         vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
       }
       else if(item == IDM_EDIT_SWAPSELECT  && vp->status != HIDDEN){
         if(vp->status==SELECTED){
           vp->status=DESELECTED; NvertSelect--; NvertDeselect++;
         }
         else{
           vp->status=SELECTED; NvertSelect++; NvertDeselect--;
         }
       }
       vp++;
     }
     break;
   default: break;
 }
 DrawVerticesOnly(Vx);
 UpdateCounters();
}

void ExecuteHide(BOOL hide){
 long i;
 vertex *vp;
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(hide){
     if(vp->status==SELECTED){
       vp->status=HIDDEN; NvertSelect--; NvertDeselect++;
     }
   }
   else{
    if(vp->status==HIDDEN)vp->status=DESELECTED;
   }
   vp++;
 }
}

void SelectConnected(int status){
 HCURSOR lhcurSave;
 vertex *vp,*vf,*V0,*V1;
 edge *ep;
 long range;
 int i,sho,svo,shp,svp,flag;
 double d,dmin,drange;
 if(sktool)return;
 EDIT_ACTION=YES;
 dmin=(double)TVsizeY*(double)TVsizeX*(double)TVsizeZ;
 vp=MainVp;
 vf=NULL;
 if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status != HIDDEN && intriview(vp)){
     GetWindowCoords(ActiveView,
                   vp->xyz[0],vp->xyz[1],vp->xyz[2],&sho,&svo);
     GetWindowCoords(ActiveView,
                   NpointerX,NpointerY,NpointerZ,&shp,&svp);
     if(abs(sho-shp) < 4 && abs(svo-svp) <4){
       d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
        +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
        +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         vf=vp;
       }
     }
   }
   vp->id=0;
   vp++;
 }
 if((vp=vf) != NULL){
   vp->status=status; vp->id=1;
   if(Nvert > 10000)lhcurSave=SetCursor(ghcurWait);
   flag=1;
   while(flag){
     flag=0;
     ep=MainEp; for(i=0;i<Nedge;i++){
       V0=(MainVp+ep->V[0]);
       V1=(MainVp+ep->V[1]);
       if(V0->id == 1 && V1->id != 1 && V1->status != HIDDEN){
         V1->id = 1; flag=1;
       }
       if(V1->id == 1 && V0->id != 1 && V0->status != HIDDEN){
         V0->id = 1; flag=1;
       }
       ep++;
     }
   }
   NvertSelect=0;
   vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
     if(vp->id == 1)vp->status = status;
     if(vp->status == SELECTED)NvertSelect++;
     vp++;
   }
   NvertDeselect=Nvert-NvertSelect;
   if(Nvert > 10000)SetCursor(lhcurSave);
   DrawVerticesOnly(NULL);
   UpdateCounters();
 }
}

void SelectConnectedTo(long id){
 BOOL bExtended;
 int status,istatus;
 HCURSOR lhcurSave;
 vertex *vp,*V0,*V1;
 edge *ep;
 long range;
 int i,flag;
 vp=(MainVp+id);
 if(vp->status == SELECTED){status=DESELECTED; istatus=SELECTED;}
 else                      {status=SELECTED; istatus=DESELECTED;}
 vp->status=status; vp->id=1;
 if(GetKeyState(VK_SHIFT) & 0x8000)bExtended=TRUE;
 else                              bExtended=FALSE;
 if(Nvert > 10000)lhcurSave=SetCursor(ghcurWait);
 flag=1;
 while(flag){
   flag=0;
   ep=MainEp; for(i=0;i<Nedge;i++){
     V0=(MainVp+ep->V[0]);
     V1=(MainVp+ep->V[1]);
     if(V0->id == 1 && V1->id != 1 && V1->status != HIDDEN){
       V1->id = 1; flag=1;
     }
     if(V1->id == 1 && V0->id != 1 && V0->status != HIDDEN){
       V0->id = 1; flag=1;
     }
     ep++;
   }
 }
 NvertSelect=0;
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->id == 1)vp->status = status;
//   else if(status == SELECTED && vp->status != HIDDEN && !bExtended)
//      vp->status = istatus;
   if(vp->status == SELECTED)NvertSelect++;
   vp++;
 }
 NvertDeselect=Nvert-NvertSelect;
 if(Nvert > 10000)SetCursor(lhcurSave);
 DrawVerticesOnly(NULL);
 UpdateCounters();
}

long SelectVertex(int criteria, int cx, int cy){
 vertex *vp,*vf;
 double d,dmin,drange;
 int i,sho,svo;
 long id;
 if(sktool)return -1;
 EDIT_ACTION=YES;
 vp=MainVp; vf=NULL; id= -1;
 dmin=(double)TVsizeX*(double)TVsizeY*(double)TVsizeZ;
 drange=dmin/32/32/32;
 if(grid_on){
   GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&cx,&cy);
 }
 if(MainVp != NULL && Nvert > 0)for(vp=MainVp,i=0;i<Nvert;i++,vp++){
  if(intriview(vp)){
    if(criteria == 0){/* select the closest to cursor in range */
      d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
       +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
       +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
      if(d < dmin){
        dmin=d;
        if(d < drange){vf=vp; id=(long)i;}
      }
    }
    else{ /* select in 2 D but use the closest in column  */
      GetWindowCoords(ActiveView,
                   vp->xyz[0],vp->xyz[1],vp->xyz[2],&sho,&svo);
      if( (sho > cx-4) && (sho < cx+4) && (svo > cy-4) && (svo < cy+4)){
        d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
         +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
         +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
        if(d < dmin){
          dmin=d;
          vf=vp;
          id=(long)i;
        }
      }
    }
  }
 }
 if(vf != NULL){
   if(vf->status==SELECTED){
     NvertSelect--;
     NvertDeselect++;
     vf->status=DESELECTED;
   }
   else{
     NvertSelect++;
     NvertDeselect--;
     vf->status=SELECTED;
   }
   DrawVerticesOnly(vf);
   UpdateCounters();
 }
 return id;
}

static int selector_xx,selector_x,selector_yy,selector_y,
           selector_type,n_lasso=0;
static HDC hDCselector;
static POINT *lasso_list=NULL;


static void DrawCircle(HDC hDC, int xx, int yy, int x, int y){
 int cx,cy,radius;
 cx=(x+xx)/2; cy=(y+yy)/2;
 radius=(int)(sqrt((double)(x-cx)*(double)(x-cx)
                  +(double)(y-cy)*(double)(y-cy)));
 if(radius > 0)Ellipse(hDC,cx-radius,cy-radius,
                           cx+radius,cy+radius);
}

void DrawLassoList(HDC hDC){
 long i;
 if(n_lasso > 0 && lasso_list != NULL){
   MoveToEx(hDC,lasso_list[0].x,lasso_list[0].y,NULL);
   if(n_lasso > 1)for(i=1;i<n_lasso;i++){
     LineTo(hDC,lasso_list[i].x,lasso_list[i].y);
   }
   LineTo(hDC,lasso_list[0].x,lasso_list[0].y);
 }
 return;
}

void SelectorDown(HWND hwnd, int view, int x, int y){
 HDC hdc;
 selector_x=selector_xx=x; selector_y=selector_yy=y;
 if(view < 0)selector_type=0;
 else if(GetAsyncKeyState(VK_CONTROL) & 0x8000)selector_type=1;
 else if(GetAsyncKeyState(VK_SHIFT) & 0x8000)selector_type=2;
 else selector_type=0;
 hDCselector=GetDC(hwnd);
 SelectObject(hDCselector,GetStockObject(NULL_BRUSH));
 if(tool == SELECTOR)SelectObject(hDCselector,ghSelectorPen);
 else                SelectObject(hDCselector,ghDeselectorPen);
 SetROP2(hDCselector,R2_XORPEN);
 SelectPalette(hDCselector,ghpaletteScreen,FALSE);
 RealizePalette(hDCselector);
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
 if(selector_type == 0)Rectangle(hDCselector,
                                 selector_xx,selector_yy,
                                 selector_x,selector_y);
 else if(selector_type == 2){
   if((lasso_list=(POINT *)X__Malloc(sizeof(point))) != NULL){
     lasso_list[0].x=x; lasso_list[0].y=y;
     n_lasso=1;
     DrawLassoList(hDCselector);
   }
 }
 else DrawCircle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
}

void SelectorMove(HWND hwnd, int view, int x, int y){
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
 if(selector_type == 0)Rectangle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 else if(selector_type == 2)DrawLassoList(hDCselector);
 else DrawCircle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 selector_x=x; selector_y=y;
 if(selector_type == 2){
   POINT *pt;
   pt=X__Realloc(lasso_list,(n_lasso+1)*sizeof(POINT));
   if(pt != NULL){
     pt[n_lasso].x=x; pt[n_lasso].y=y; n_lasso++;
     lasso_list=pt;
   }
 }
 if(selector_type == 0)Rectangle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 else if(selector_type == 2)DrawLassoList(hDCselector);
 else DrawCircle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
}

void SelectorUp(HWND hwnd, int view, int x, int y,
                BOOL bFlagMoved, BOOL bFlagNodeTool){
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
 if(selector_type == 0)Rectangle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 else if(selector_type == 2){
   DrawLassoList(hDCselector);
 }
 else DrawCircle(hDCselector,selector_xx,selector_yy,selector_x,selector_y);
 if(view >= 0)DrawOne3dCursor(hDCselector,view);
 ReleaseDC(hwnd,hDCselector);
 if(!bFlagMoved){
   if(lasso_list != NULL){
     X__Free(lasso_list);
     n_lasso=0; lasso_list=NULL;
   }
   return;
 }
 if(view < 0)SelectInPerspective(tool,selector_xx,selector_x
                                     ,selector_yy,selector_y);
 else if(selector_type < 2){ // rectangle + circle
   vertex *vp;
   int  i,sx,sy,cx,cy,xl,yt,xr,yb;
   double radius1,radius2;
   xl=min(selector_x,selector_xx); xr=max(selector_x,selector_xx);
   yt=min(selector_y,selector_yy); yb=max(selector_y,selector_yy);
   if(selector_type == 0){ // rectangle
     vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
       if(!intriview(vp))goto NEXT;
       GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sx,&sy);
       if((sx < xl) || (sx > xr) || (sy < yt) || (sy > yb))goto NEXT;
       if(tool == SELECTOR && vp->status == DESELECTED){
         vp->status=SELECTED;
         NvertSelect++; NvertDeselect--;
       }
       else if(tool == DESELECTOR && vp->status==SELECTED){
         vp->status=DESELECTED;
         NvertSelect--; NvertDeselect++;
       }
       NEXT:
       vp++;
     }
     if(Nnurbs > 0)SelectNurbsInRectangle(tool,bFlagNodeTool,xl,xr,yt,yb);
   }
   else{ // circle
     cx = (xl+xr)/2; cy = (yt+yb)/2;
     radius1 = (sqrt((double)(xl-cx)*(double)(xl-cx)
                    +(double)(yt-cy)*(double)(yt-cy)));
     vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
       if(!intriview(vp))goto NEXT1;
       GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sx,&sy);
       radius2 = (sqrt((double)(sx-cx)*(double)(sx-cx)
                      +(double)(sy-cy)*(double)(sy-cy)));
       if(radius2 > radius1)goto NEXT1;
       if(tool == SELECTOR && vp->status == DESELECTED){
         vp->status=SELECTED;
         NvertSelect++; NvertDeselect--;
       }
       else if(tool == DESELECTOR && vp->status==SELECTED){
         vp->status=DESELECTED;
         NvertSelect--; NvertDeselect++;
       }
       NEXT1:
       vp++;
     }
     if(Nnurbs > 0)SelectNurbsInCircle(tool,bFlagNodeTool,cx,cy,radius1);
   }
 }
 else if(selector_type == 2){  // Lasso
   if(lasso_list != NULL){
     vertex *vp;
     int  i,sx,sy;
     HRGN hrgn;
     if((hrgn=CreatePolygonRgn(lasso_list,n_lasso,WINDING)) != NULL){
       vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
         if(!intriview(vp))goto NEXT2;
         GetWindowCoords(view,vp->xyz[0],vp->xyz[1],vp->xyz[2],&sx,&sy);
         if(!PtInRegion(hrgn,sx,sy))goto NEXT2;
         if(tool == SELECTOR && vp->status == DESELECTED){
           vp->status=SELECTED;
           NvertSelect++; NvertDeselect--;
         }
         else if(tool == DESELECTOR && vp->status==SELECTED){
           vp->status=DESELECTED;
           NvertSelect--; NvertDeselect++;
         }
         NEXT2:
         vp++;
       }
       if(Nnurbs > 0)SelectNurbsInLasso(tool,bFlagNodeTool,hrgn);
       DeleteObject(hrgn);
     }
     X__Free(lasso_list);
     n_lasso=0; lasso_list=NULL;
   }
 }
 if(Nnurbs > 0)DrawModel();
 else DrawVerticesOnly(NULL);
 UpdateCounters();
}

void SnapCursorTo(int item){
 static point cursor_memory={0,0,0};
 char status;
 int i,id=0;
 point p,TVp;
 double d,dmin,x,y,z;
 vertex *vp,*vc=NULL;
 p[0]=NpointerX; p[1]=NpointerY; p[2]=NpointerZ; vc=NULL;
 dmin=(double)TVsizeX*(double)TVsizeY*(double)TVsizeZ;
 switch (item){
   case IDM_SNAP_CLOSEST:
     if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
       d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
        +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
        +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
       if(d < dmin){dmin=d;  vc=vp;}
       vp++;
     }
     if(vc != NULL){
       p[0]=vc->xyz[0]; p[1]=vc->xyz[1]; p[2]=vc->xyz[2];
     }
     else{
       p[0]=NpointerX; p[1]=NpointerY; p[2]=NpointerZ;
     }
     id=1;
     break;
   case IDM_SNAP_CLOSESELECT:
     if(NvertSelect == 0)break;
     if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
       if(vp->status == SELECTED){
         d=(double)(vp->xyz[0]-NpointerX)*(double)(vp->xyz[0]-NpointerX)
          +(double)(vp->xyz[1]-NpointerY)*(double)(vp->xyz[1]-NpointerY)
          +(double)(vp->xyz[2]-NpointerZ)*(double)(vp->xyz[2]-NpointerZ);
         if(d < dmin){dmin=d;  vc=vp;}
       }
       vp++;
     }
     if(vc != NULL){
       p[0]=vc->xyz[0]; p[1]=vc->xyz[1]; p[2]=vc->xyz[2];
     }
     else{
       p[0]=NpointerX; p[1]=NpointerY; p[2]=NpointerZ;
     }
     id=1;
     break;
   case IDM_SNAP_MIDPOINT:
     get_centre(1,p,TVp,TRUE);
     id=1;
     break;
   case IDM_SNAP_MIDSELECT:
     if(NvertSelect == 0)break;
     get_centre(1,p,TVp,FALSE);
     id=1;
     break;
   case IDM_SNAP_CENTROID:
     get_centre(0,p,TVp,TRUE);
     id=1;
     break;
   case IDM_SNAP_HPLANE:
     if(NvertSelect > 0)get_centre(2,p,TVp,FALSE);
     else               get_centre(2,p,TVp,TRUE);
     id=1;
     break;
   case IDM_SNAP_VPLANERL:
     if(NvertSelect > 0)get_centre(4,p,TVp,FALSE);
     else               get_centre(4,p,TVp,TRUE);
     id=1;
     break;
   case IDM_SNAP_VPLANEFB:
     if(NvertSelect > 0)get_centre(3,p,TVp,FALSE);
     else               get_centre(3,p,TVp,TRUE);
     id=1;
     break;
   case IDM_SNAP_STORE:
     cursor_memory[0]=NpointerX;
     cursor_memory[1]=NpointerY;
     cursor_memory[2]=NpointerZ;
     id=0;
     break;
   case IDM_SNAP_TOSTORED:
     p[0]=cursor_memory[0];
     p[1]=cursor_memory[1];
     p[2]=cursor_memory[2];
     id=1;
     break;
   case IDM_SNAP_TOCOORD:
     x=(double)(NpointerX-lrulerx)/ruler;
     y=(double)(NpointerY-lrulery)/ruler;
     z=(double)(NpointerZ-lrulerz)/ruler;
     if(fabs(x) > 999999 || fabs(y) > 999999 || fabs(z) > 999999){
       SendPrgmQuery(IDQ_COORDTOOBIG,0);
       break;
     }
     if(Read3Reals("To Coordinate",&x,&y,&z,0) == 0)break;
     p[0]=(long)(x*ruler)+lrulerx;
     p[1]=(long)(y*ruler)+lrulery;
     p[2]=(long)(z*ruler)+lrulerz;
     id=1;
     break;
   case IDM_SNAP_INCREMENT:
     x=y=z=0.0;
     if(Read3Reals("Move by",&x,&y,&z,0) == 0)break;
     p[0]=(long)(x*ruler)+NpointerX;
     p[1]=(long)(y*ruler)+NpointerY;
     p[2]=(long)(z*ruler)+NpointerZ;
     id=1;
     break;
   default:
     break;
 }
 if(id){
   if( (p[0] > TVpointX && p[0] < TVpointX+TVsizeX)
    && (p[1] > TVpointY && p[1] < TVpointY+TVsizeY)
    && (p[2] > TVpointZ && p[2] < TVpointZ+TVsizeZ)){ /* move 3D cursor */
     Draw3dCursor();
     NpointerX=p[0];  NpointerY=p[1];  NpointerZ=p[2];
     Draw3dCursor();
   }
   else{
     NpointerX=p[0];  NpointerY=p[1];  NpointerZ=p[2];
     TVpointX=NpointerX-TVsizeX/2; TVcentreX=NpointerX;
     TVpointY=NpointerY-TVsizeY/2; TVcentreY=NpointerY;
     TVpointZ=NpointerZ-TVsizeZ/2; TVcentreZ=NpointerZ;
     DrawModel();
   }
 }
 SendMessage(ghwndCoord1,WM_COMMAND,IDC_COORD_UPDATE,0);
 return;
}

static BOOL SelectBezier(void){
 long i;
 int id,redraw=0; /* redraw not used yet */
 char **bezier_list;
 vertex *Vp;
 if(N_Bcurves > 0){
   if((bezier_list=(char **)X__Malloc(N_Bcurves*sizeof(char *))) == NULL){
     SendPrgmQuery(IDQ_NOMEM2,0);
     return FALSE;
   }
   for(i=0;i<N_Bcurves;i++)bezier_list[i]=Bcurves[i].name;
   id=SelectScrolledItemList((int)N_Bcurves,bezier_list,"Which Curve",ghwnd_main);
   if(id >= 0){
     if(Bcurves[id].Vc != NULL)for(i=0;i<Bcurves[id].Nc;i++){
       Vp=(MainVp+Bcurves[id].Vc[i]);
       if(Vp->status == DESELECTED){
         Vp->status = SELECTED;
         NvertDeselect--; NvertSelect++;
         redraw=1;
       }
     }
     if(Bcurves[id].Vp != NULL)for(i=0;i<Bcurves[id].Np;i++){
       Vp=(MainVp+Bcurves[id].Vp[i]);
       if(Vp->status == DESELECTED){
         Vp->status = SELECTED;
         NvertDeselect--; NvertSelect++;
         redraw=1;
       }
     }
   }
   X__Free(bezier_list);
   if(redraw)return TRUE;
 }
 return FALSE;
}

static BOOL SelectMappedVertices(int status){
 long i;
 vertex *vp;
 vp=MainVp;
 if(status == SELECTED){
   for(i=0;i<Nvert;i++){
    if(vp->status == DESELECTED && vp->gp > 0){
      NvertSelect++; NvertDeselect--;
      vp->status = SELECTED;
    }
    vp++;
   }
 }
 else if(status == DESELECTED){
   for(i=0;i<Nvert;i++){
    if(vp->status == SELECTED && vp->gp > 0){
      NvertSelect--; NvertDeselect++;
      vp->status = DESELECTED;
    }
    vp++;
   }
 }
 return TRUE;
}

long PickVertex(void){
 vertex *Vp;
 long vp,vf;
 double d,dmin;
 int sho,svo,V,H;
 vp=0;
 vf=-1;
 dmin=(double)TVsizeY*(double)TVsizeY*(double)TVsizeZ;
 GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&H,&V);
 while(vp < Nvert){
   Vp=(MainVp+vp);
   if(intriview(Vp)){
     GetWindowCoords(ActiveView,Vp->xyz[0],Vp->xyz[1],Vp->xyz[2],&sho,&svo);
     if( (sho > H-4) && (sho < H+4) && (svo > V-4) && (svo < V+4)){
       d=(double)(Vp->xyz[0]-NpointerX)*(double)(Vp->xyz[0]-NpointerX)
        +(double)(Vp->xyz[1]-NpointerY)*(double)(Vp->xyz[1]-NpointerY)
        +(double)(Vp->xyz[2]-NpointerZ)*(double)(Vp->xyz[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         vf=vp;
       }
     }
   }
   Vp->id=0;
   vp++;
 }
 return vf;
}

static void DeSelectEvery(void){
 vertex *Vp;
 long vp,vf,every=1,count=1;
 if(NvertSelect < 1 || NvertSelect > 32000)return;
 if((vf=get_closest_vertex()) < 0)return;
 if((every=RequestNumEntry((short)every,1,100,"De-select","Gap")) < 0)return;
 (MainVp+vf)->id=1;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(vf,vp)){
     Vp->id=1;
     if(count == every){
       Vp->status=DESELECTED;
       NvertSelect--; NvertDeselect++; count=0;
     }
     else count++;
     vf=vp;
     vp=0;
   }
   else vp++;
 }
 return;
}