menus.c

来自「FreeFem++可以生成高质量的有限元网格。可以用于流体力学」· C语言 代码 · 共 1,182 行 · 第 1/3 页

        glutIdleFunc(glutIdle);
    }
    animate = 1-animate;
    post = FALSE;
    break;
  case 'I':  /* save image */
    saveimg = 1 - saveimg;
    nbimg   = 0;
    post    = GL_FALSE;
    break;

  case 'M':  /* morphing */
    if ( morphing )
      glutIdleFunc(NULL);
    else
      glutIdleFunc(glutIdle);
    morphing = 1-morphing;
    post = FALSE;
    break;
  case 'R':  /* next morph */
    imreverse = 1-imreverse;
    break;

  case 'S':  /* start animation */
    if ( ddebug ) fprintf(stdout,"debut sequence %d a %d\n",animdep,animfin);
    glutSetWindow(sc->idwin);
    if ( option == SEQUENCE )
      playAnim(sc,mesh,animdep,animfin);
    if ( !saveimg )  post = FALSE;
    break;

  case 'f': /* first mesh */
    /* get basename */
    ptr = (char *)strrchr(mesh->name,'.');
    if ( ptr )  *ptr = '\0';
    strcpy(base,mesh->name);
    resetLists(sc,mesh);
    if ( !loadNextMesh(mesh,animdep,0) )  break;
    doLists(sc,mesh);
    if ( sc->mode & S_MAP ) doMapLists(sc,mesh,0);
    if ( sc->isotyp )       doIsoLists(sc,mesh,0);
    strcpy(mesh->name,base);
    break;

  case 'l':
    /* get basename */
    ptr = (char *)strrchr(mesh->name,'.');
    if ( ptr )  *ptr = '\0';
    strcpy(base,mesh->name);
    resetLists(sc,mesh);
    if ( !loadNextMesh(mesh,animfin,0) )  break;
    doLists(sc,mesh);
    if ( sc->mode & S_MAP ) doMapLists(sc,mesh,0);
    if ( sc->isotyp )       doIsoLists(sc,mesh,0);
    strcpy(mesh->name,base);
    break;

  case 'n':
    /* get basename */
    if ( ++depart > animfin )  depart = animdep;
    ptr = (char *)strrchr(mesh->name,'.');
    if ( ptr )  *ptr = '\0';
    strcpy(base,mesh->name);
    resetLists(sc,mesh);
    if ( !loadNextMesh(mesh,depart,0) )  break;
    doLists(sc,mesh);
    if ( sc->mode & S_MAP ) doMapLists(sc,mesh,0);
    if ( sc->isotyp )       doIsoLists(sc,mesh,0);
    strcpy(mesh->name,base);
    break;

  case 'p':
    /* get basename */
    if ( --depart < animdep )  depart = animfin;
    ptr = (char *)strrchr(mesh->name,'.');
    if ( ptr )  *ptr = '\0';
    strcpy(base,mesh->name);
    resetLists(sc,mesh);
    if ( !loadNextMesh(mesh,depart,0) )  break;
    doLists(sc,mesh);
    if ( sc->mode & S_MAP ) doMapLists(sc,mesh,0);
    if ( sc->isotyp )       doIsoLists(sc,mesh,0);
    strcpy(mesh->name,base);
    break;
  }
  
  if ( post == TRUE )   glutPostRedisplay();
}

void menuAnim(int item) {
  keyAnim((unsigned char)item,0,0);
}

void keyTrajet(unsigned char key,int x,int y) {
  pScene   sc;
  pMesh    mesh;

  sc = cv.scene[currentScene()];
  mesh = cv.mesh[sc->idmesh];
  switch(key) {
  case 'C': /* add control point */
    pathAdd(sc,x,y);
    break;
  case 'S': /* show all points */
    sc->type ^= S_PATH;
    /*if ( sc->path.tlist )  glDeleteLists(sc->path.tlist,1);*/
    if ( sc->type & S_PATH && !sc->path.tlist )
      sc->path.tlist = pathList(sc);
    break;
  case 'F': /* follow path */
    break;
  case 'L': /* load path */
    pathLoad(mesh->name,sc);
    break;
  case 'W': /* save path */
    pathSave(mesh->name,sc);
    break;
  }
  glutPostRedisplay();
}

void menuTrajet(int item) {
  keyTrajet((unsigned char)item,0,0);
}

void keyMode(unsigned char key,int x,int y) {
  pScene  sc;
  pMesh   mesh;
  ubyte   post = TRUE,dolist = FALSE,material;

  sc   = cv.scene[currentScene()];
  mesh = cv.mesh[sc->idmesh];
  material = sc->mode & S_MATERIAL;

  switch(key) {
  case 'D':  /* depth lines */
    if ( sc->mode == DEPTH ) break;
    sc->mode = DEPTH;
    break;
  case 'S': /* toggle smooth shading */
    if ( sc->mode == FILL )
      break;
    sc->mode = FILL;
    if ( material ) sc->mode |= S_MATERIAL;
    break;
  case 'P': /* toggle smooth shaded polys */
    if ( sc->mode == SHADED )
      break;
    sc->mode = SHADED;
    if ( material ) sc->mode |= S_MATERIAL;
    break;
  case 'H': /* hidden lines */
    if ( sc->mode == HIDDEN ) break;
    sc->mode = HIDDEN;
    if ( material ) sc->mode |= S_MATERIAL;
    break;
  case 'W':  /* wireframe */
    if ( sc->mode == WIRE ) break;
    sc->mode = WIRE;
    if ( material ) sc->mode |= S_MATERIAL;
    break;
  case 'n': /* toggle normals */
    if ( mesh->nvn == 0 ) {
      post = FALSE;
      break;
    }
    sc->type ^= S_FLAT;
    dolist = TRUE;
    break;
  default:
    post = FALSE;
    break;
  }
  if ( dolist == TRUE ) doLists(sc,mesh);
  if ( post == TRUE )   glutPostRedisplay();
}

void menuMode(int item) {
  keyMode((unsigned char)item,0,0);
}


void menuScene(int item) {
  keyScene((unsigned char)item,0,0);
}

void keyView(unsigned char key,int x,int y) {
  pScene  sc,sc1;
  pMesh   mesh;
  float   dmax;
  ubyte   post = FALSE;

  sc   = cv.scene[currentScene()];
  mesh = cv.mesh[sc->idmesh];
  /*glutSetMenu(vmenu);*/

  switch(key) {
  case 'R':
    sc->type |= S_RESET;
    dmax = mesh->xmax - mesh->xmin;
    dmax = max(dmax,mesh->ymax - mesh->ymin);
    dmax = max(dmax,mesh->zmax - mesh->zmin);
    sc->cx = sc->cy = sc->cz = 0.0f;
    sc->dmax = fabs(dmax);
    if ( sc->persp->pmode == PERSPECTIVE ) {
      resetTransform(sc->view);
      initPersp(sc->persp,sc->dmax);
    }
    else if ( sc->persp->pmode == CAMERA ) {
      initPersp(sc->persp,sc->dmax);
      initCamera(sc,sc->camera->vecup); 
      sc->persp->pmode = CAMERA;
    }
    reshapeScene(sc->par.xs,sc->par.ys);
    post = TRUE;
    break;
  case 'C':
    copyView(sc->view,sc->camera,sc->persp);
    copyClip(sc->clip);
    break;
  case 'L':  /* link view */
    if ( !linkView(sc) )  return;
    reshapeScene(sc->par.xs,sc->par.ys);
    post = TRUE;
    break;
  case 'P':
    if ( pasteView(sc->view,sc->camera,sc->persp) && 
         pasteClip(sc->clip) ) {
      reshapeScene(sc->par.xs,sc->par.ys);
      post = TRUE;
    }
    break;
  case 'U':
    unlinkView(sc);
    break;

  case 'D':  /* duplicate view */
    if ( cv.nbs == MAX_SCENE )  break;
    if ( !cv.scene[++cv.nbs] ) {
      cv.scene[cv.nbs] = (pScene)M_calloc(1,sizeof(Scene),"menus.scene");
      if ( !cv.scene[cv.nbs] )  break;
      sc1 = cv.scene[cv.nbs];
      sc1->material = (pMaterial)calloc(2+sc->par.nbmat,sizeof(Material));
      assert(sc1->material);
    }
    sc1 = cv.scene[cv.nbs];
    memcpy(sc1,sc,sizeof(Scene));
    memcpy(sc1->material,sc->material,sc->par.nbmat*sizeof(Material));
    memcpy(&sc1->par,&sc->par,sizeof(Param));
    if ( !createScene(sc1,sc1->idmesh) ) {
      fprintf(stdout,"  ## Unable to create\n");
      return;
    }
    copyView(sc->view,sc->camera,sc->persp);
    copyClip(sc->clip);
    pasteView(sc1->view,sc1->camera,sc1->persp);
    pasteClip(sc1->clip);
    break;
  }
  if ( post )  glutPostRedisplay();
}

void menuView(int item) {
  keyView((unsigned char)item,0,0);
}

void keyColor(unsigned char key,int x,int y) {
  pScene     sc;
  pMesh      mesh;
  pMaterial  pm;
  int        i,k;
  ubyte      post = TRUE,dolist = FALSE;

  sc   = cv.scene[currentScene()];
  mesh = cv.mesh[sc->idmesh];

  switch(key) {
  case 'b':  /* reverse backcolor */
    sc->par.back[0] = 1.0f - sc->par.back[0];
    sc->par.back[1] = 1.0f - sc->par.back[1];
    sc->par.back[2] = 1.0f - sc->par.back[2];
    glClearColor(sc->par.back[0],sc->par.back[1],sc->par.back[2],sc->par.back[3]);
    if ( !sc->par.linc ) {
      sc->par.line[0] = 1.0f - sc->par.line[0];
      sc->par.line[1] = 1.0f - sc->par.line[1];
      sc->par.line[2] = 1.0f - sc->par.line[2];
    }
    break;
  case 'e':  /* toggle matcolors */
    sc->mode ^= S_MATERIAL;
    dolist = TRUE;
    break;
  case 'E':  /* edit matcolors */
    post   = FALSE; 
    matEdit(sc);
    break;
  case 'r':
      if ( refmat<0 || ipilmat == sc->par.nbmat )  break;
      pilmat[++ipilmat] = refmat;
      pm = &sc->material[refmat];
      pm->flag = 1;
      updatePoints(sc,mesh,refmat);
      if ( sc->picklist ) glDeleteLists(sc->picklist,1);
      sc->picklist = 0;
      refmat = -1;
      dolist = TRUE;
      post   = TRUE;
    break;
  case 'R':  /* reset materials */
    for (k=0; k<sc->par.nbmat; k++) {
      pm = &sc->material[k];
      for (i=LTria; i<=LHexa; i++)
        pm->depmat[i] = abs(pm->depmat[i]);
    }
    dolist = TRUE;
    break;
  default:
    post = FALSE;
  }
  if ( dolist ) doLists(sc,mesh);
  if ( post )   glutPostRedisplay();
}

void menuColor(int item) {
  keyColor((unsigned char)item,0,0);
}


void keyClip(unsigned char key,int x,int y) {
  pScene  sc;
  pMesh   mesh;
  pClip   clip;
  ubyte   post = TRUE;

  /* default */
  sc   = cv.scene[currentScene()];
  mesh = cv.mesh[sc->idmesh];
  clip = sc->clip;

  switch(key) {
  case 'C': /* toggle clipping */
    if ( clip->active & C_ON )
      clip->active &= ~(C_ON+C_EDIT);
    else {
      clip->active |= C_ON;
      if ( mesh->ntet+mesh->nhex )  clip->active |= C_VOL;
    }
    break;
  case 'E': /* edit clip plane */
    if ( !(clip->active & C_ON) )  return;
    if ( clip->active & C_FREEZE ) clip->active ^= C_FREEZE;
    clip->active ^= C_EDIT;
    break;
  case 'F':  /* freeze clip */
    if ( !(clip->active & C_ON) )  return;
    if ( clip->active & C_EDIT )   clip->active ^= C_EDIT;
    clip->active ^= C_FREEZE;
    break;
  case 'H':  /* toggle draw plane */
    clip->active ^= C_HIDE;
    break;
  case 'I': /* inverse orientation */
    invertClip(sc,clip);
    clip->active |= C_REDO;
    break;
  case 'K':  /* toggle capping */
    clip->active ^= C_CAP;
    clip->active |= C_REDO;
    break;
  case 'R':  /* reset clip */
    if ( !(clip->active & C_ON) ) break;
    resetClip(sc,clip,mesh);
    break;
  case 'Z':  /* toggle volclip */
    clip->active ^= C_VOL;
    if ( clip->active & C_VOL )
      clip->active |= C_REDO;
    break;
  }
  if ( post ) glutPostRedisplay();
}

void menuClip(int item) {
  keyClip((unsigned char)item,0,0);
}


void keyCube(unsigned char key,int x,int y) {
  pScene  sc;
  pMesh   mesh;
  pCube   cube;
  ubyte   post = TRUE;

  /* default */