wzwindow.c

Delaunay三角形的网格剖分程序

    *value = win->c.value[obj][par].i;
}
void wzwGetEnum(       wzWindow win, int obj, int par, int *value)
{
    if(obj<0 || obj >= WZW_OBJECTS)    {*value = 0; return;}
    if(par<0 || par >= WZW_PARAMETERS) {*value = 0; return;}
    *value = win->c.value[obj][par].i;
}
   
void wzwUndefineObject(   wzWindow win, int obj)
{
  if(obj<0 || obj >= WZW_OBJECTS)    return;
  win->c.defined[WZW_MODE_O][obj] = win->objectDefined[obj] = 0;
}

void wzwUndefineParameter(wzWindow win, int obj, int par)
{
  if(obj<0 || obj >= WZW_OBJECTS)    return;
  if(par<0 || par >= WZW_PARAMETERS) return;
  win->parDefined[obj][par] = 0;
}

void wzwSetObject(        wzWindow win, int obj, void *data)
{
    if(obj<1 || obj > win->c.maxObjects[WZW_MODE_O]) return;
    win->object[obj]         = data;
}

/*#############################@status@############################*/

static void wzwInitStatus(wzwStatus *s)
{
    int i,j,k;
    for(i=0;i<WZW_MODI;i++){
	s->maxObjects[i] = WZW_OBJECTS-1;
	s->current[i]    = 1;
    }
    for(i=0;i<WZW_MODI;i++){
	for(j=0;j<WZW_OBJECTS;j++){
	    s->defined[i][j]=0;
	    s->move[i][j]=0;
	    s->show[i][j]=1;
	    for(k=0;k<WZW_MOVES;k++){
		s->matrix[i][j][k]=0;
	    }
	}
	s->defined[i][1]=1;
	s->move[i][1]=1;
	s->show[i][1]=1;
    }
    for(j=0;j<WZW_OBJECTS;j++){
	s->move[WZW_MODE_O][j]=1;
	s->show[WZW_MODE_O][j]=0;
	s->sliceOn[j][0]    = s->sliceOn[j][1]    = s->sliceOn[j][2]    = 1;
	s->lightcolor[j][0] = s->lightcolor[j][1] = s->lightcolor[j][2] = 1.0;
	for(k=0;k<WZW_PARAMETERS;k++){
	    s->value[j][k].s=0;
	}
    }
    s->defined[WZW_MODE_O][1]=0;
}

static void wzwWriteStatus(wzwStatus *s, char *file)
{FILE *f = fopen(file,"w");
 if(f){
     fwrite(s,sizeof(wzwStatus),1,f);
     fclose(f);
 }
}

static void wzwReadStatus(wzwStatus *s, char *file)
{FILE *f = fopen(file,"r");
 if(f){
     fread(s,sizeof(wzwStatus),1,f);
     fclose(f);
 }
}

/*#############################@selection@############################*/

static int wzwSelectObject(wzWindow win, int o)
{
    int i,j,k,m=win->mode;
    int l = win->current;
    if(o<0 || o >= WZW_OBJECTS) return 0;
    win->current = win->c.current[m] = o;
    if(!win->c.defined[m][o]){
        if(m==WZW_MODE_O) return 0;
        win->c.defined[m][o] = 1;
        win->c.show[m][o] = 1;
        for(k=0;k<WZW_MOVES;k++){
            win->c.matrix[m][o][k] = win->c.matrix[m][l][k];
        }
        sprintf(tmp,"%s %d created",wzwModeName[win->mode],o);
    }else{
        sprintf(tmp,"%s %d selected",wzwModeName[win->mode],o);
    }
    if(l) win->c.move[m][l] = 0;
    win->c.move[m][o] = 1;
    wzwMessage(win,tmp);
    if(m==WZW_MODE_O || m==WZW_MODE_S) win->list_valid = 0;
    if(m==WZW_MODE_O){
	win->draw=win->objectCallback[win->c.current[WZW_MODE_O]];
	win->info=win->object[win->c.current[WZW_MODE_O]];
    }
    wzwDefinePosition(win);
    return 1;
}

static void wzwMessage(wzWindow win, char *msg)
{
    glwShowState(win->glwin,msg);
}

static int wzwActionParameter(wzWindow win)
{
  char temp[256];
  int obj,par,val;
  obj = wzwGetObject(win);
  for(par=0;par<WZW_PARAMETERS;par++){
    if(win->parDefined[obj][par])
      if(win->key == win->parKey[obj][par]){
	if(win->parType[obj][par] == WZW_TYPE_Switch){
	  if(win->c.value[obj][par].i){
	    win->c.value[obj][par].i = 0;
	    sprintf(temp,"%s off",win->parName[obj][par]);
	  }else{
	    win->c.value[obj][par].i = 1;
	    sprintf(temp,"%s on",win->parName[obj][par]);
	  }
	  win->list_valid=0;
	}else if(win->parType[obj][par] == WZW_TYPE_Enum){
	  val= win->c.value[obj][par].i + 1;
	  if(val>=win->par[obj][par].Enum.values) val=0;
	  win->c.value[obj][par].i=val;
	  win->list_valid=0;
	  sprintf(temp,"%s set to %s",win->parName[obj][par],win->par[obj][par].Enum.value[val]);
	}else if(win->parType[obj][par] == WZW_TYPE_Integer){
	  wzwStartTextInput(win,win->key,win->mask,WZW_INTEGER_INPUT);
	  sprintf(temp,"type new %s value",win->parName[obj][par]);
	}else if(win->parType[obj][par] == WZW_TYPE_Double){
	  wzwStartTextInput(win,win->key,win->mask,WZW_FLOAT_INPUT);
	  sprintf(temp,"type new %s value",win->parName[obj][par]);
	}else if(win->parType[obj][par] == WZW_TYPE_Action){
	  (*win->par[obj][par].Action.call)(win,win->info);
	  win->list_valid=0;
	  sprintf(temp,"%s",win->parName[obj][par]);
	}else{
	  sprintf(temp,"key %s was pressed",win->parName[obj][par]);
	}
	glwShowState(win->glwin,temp);
	return 1;
      }
  }
  return 0;
}

static int wzwActionValue(wzWindow win)
{
  char temp[256];
  int obj,par,ival,rc;
  float fval; double dval;
  obj = wzwGetObject(win);
  for(par=0;par<WZW_PARAMETERS;par++){
    if(win->parDefined[obj][par])
      if(win->key == win->parKey[obj][par]){
	if(win->parType[obj][par] == WZW_TYPE_Integer){
	  rc=sscanf(win->text,"%d",&ival);
	  if(rc!=1) ival=0;
	  if(ival<win->par[obj][par].Int.min) ival = win->par[obj][par].Int.min;
	  if(ival>win->par[obj][par].Int.max) ival = win->par[obj][par].Int.max;
	  sprintf(temp,"%d",ival);
	  win->c.value[obj][par].i=ival;
	}else if(win->parType[obj][par] == WZW_TYPE_Double){
	  rc=sscanf(win->text,"%f",&fval);
	  if(rc!=1) fval=0;
	  dval=fval;
	  if(dval<win->par[obj][par].Double.min) dval = win->par[obj][par].Double.min;
	  if(dval>win->par[obj][par].Double.max) dval = win->par[obj][par].Double.max;
	  sprintf(temp,"%lf",dval);
	  win->c.value[obj][par].d=dval;
	}
	wzwSetTitle(win,win->parName[obj][par]);
	glwShowState(win->glwin,temp);
	break;
      }
  }
  win->list_valid=0;
  return 1;
}

static int wzwActionMisc(wzWindow win)
{
    char resets[6]={0,0,0,0,0,0};
    int pl; char tmp[500];
    switch(win->key){
    case WZW_KEY_Help:
    case WZW_KEY_HelpAlt:
	goto help;
    case WZW_KEY_SaveFile:
      sprintf(tmp,win->saveFilePattern,win->name);
      wzwWriteStatus(&(win->c),tmp);
      return GL_TRUE;
    case WZW_KEY_LoadFile:
      sprintf(tmp,win->saveFilePattern,win->name);
      wzwReadStatus(&(win->c),tmp);
      goto status;
    case WZW_KEY_ResetStatus:
      wzwInitStatus(&(win->c));
      goto status;
    case WZW_KEY_SaveLocal:
      win->old = win->c;
      return GL_TRUE;
    case WZW_KEY_LoadLocal:
      win->c = win->old;
      goto status;
    case WZW_KEY_SliceX:
	pl = 0; goto sliceswitch;
    case WZW_KEY_SliceY:
	pl = 1; goto sliceswitch;
    case WZW_KEY_SliceZ:
	pl = 2; goto sliceswitch;
    case WZW_KEY_ResetTranslation:
      resets[WZW_MOVE_TX] = resets[WZW_MOVE_TY] =  resets[WZW_MOVE_TZ] = 1;
      goto reset;
    case WZW_KEY_ResetRotation:
      resets[WZW_MOVE_RX] = resets[WZW_MOVE_RY] = 1;
      goto reset;
    case WZW_KEY_ResetScaling:
      resets[WZW_MOVE_SC] = 1;
      goto reset;
    case WZW_KEY_Refresh:
      goto status;
    default: return GL_FALSE;
    }
reset:
    wzwMoveReset(win,resets);
    return GL_TRUE;
status:
    win->list_valid = 0;
    wzwDefinePosition(win);
    return GL_TRUE;
sliceswitch:
    win->c.sliceOn[win->c.current[WZW_MODE_S]][pl]
	=  win->sliceOn[pl] = 1 - win->sliceOn[pl];
    if(win->sliceOn[pl]) wzwMessage(win, "slice now on");
    else                 wzwMessage(win, "slice now off");
    win->list_valid = 0;
    return GL_TRUE;
help:
    win->helpMode = WZW_HELP_Key;
    wzwStartHelpMode(win);
    return GL_TRUE;
}

static int wzwActionSelectObject(wzWindow win)
{
    int obj;
    char tmp[256];
    switch(win->key){
    case GLW_1: obj = 1; break;
    case GLW_2: obj = 2; break;
    case GLW_3: obj = 3; break;
    case GLW_4: obj = 4; break;
    case GLW_5: obj = 5; break;
    case GLW_6: obj = 6; break;
    case GLW_7: obj = 7; break;
    case GLW_8: obj = 8; break;
    case GLW_9: obj = 9; break;
    case GLW_0: obj = 0; break;
    default: return GL_FALSE;
    }
    if(wzwSelectObject(win,obj))    return GL_TRUE;
    return GL_FALSE;
}

/*#############################@help@############################*/

static int   wzwBaseHelpLines = 11;
static char* wzwBaseHelpText[]={
    "Key Help Mode: F1: quit; Up Down: more; other: help for key;",
    "help keys: F1: key help;",
    "rotation: left mouse button or Up Down Left Right",
    "xy-shift: right mouse button or KP_8 KP_2 KP_4 KP_6",
    "z-shift: middle mouse button or KP_1 KP_9",
    "zoom: middle mouse button or KP_0 KP_Decimal",
    "modi for movement: F5,F6,F7,F8: move camera|object|slices|light",
    "reset keys: KP_5, KP_7, KP_Add, KP_Enter;",
    "load/save keys: F9/F10 into file, F11/F12 for session;",
    "switch slices: KP_Divide: yz; KP_Multiply: zx; KP_Minus: xy",
    "1..9: select camera|object|slices|light (depends on current mode)",
    "end of help",
    "",
    "Key Help Mode left;"};
static int   wzwBaseHelpEndLine = 13;

static void wzwStartHelpMode(wzWindow win)
{
    wzwSetTitle(win,"");
    win->helpText = wzwBaseHelpText;
    win->helpLine = 0;
    glwShowState(win->glwin, win->helpText[win->helpLine]);
}

static int wzwActionHelpKey(wzWindow win)
{
    char *c,*d,temp[256];
    int obj,par;
    switch(win->key){
    case WZW_KEY_Help_Prev:
	if(win->helpLine > 0) win->helpLine--;
	glwShowState(win->glwin, win->helpText[win->helpLine]);
	return 1;
    case WZW_KEY_Help_Next:
	if(win->helpText[win->helpLine][0]){
	    win->helpLine++;
	}else{
	  win->helpMode = WZW_HELP_Off;
	}
	glwShowState(win->glwin, win->helpText[win->helpLine]);
	return 1;
    case WZW_KEY_Help_End:
	glwShowState(win->glwin, win->helpText[wzwBaseHelpEndLine]);
	win->helpMode = WZW_HELP_Off;
	return 1;
    }
    d = 0;
    switch(win->key){
    case WZW_KEY_Help:
    case WZW_KEY_HelpAlt:
      d = "wzwindow.html#Help";
      c = "toggles key help mode"; break;
    case WZW_KEY_SetModeC:
      d = "wzwindow.html#SetModeC";
      c = "camera mode - mouse modifies camera position"; break;
    case WZW_KEY_SetModeO:
      d = "wzwindow.html#SetModeO";
      c = "object mode - mouse modifies box in the objects"; break;
    case WZW_KEY_SetModeP:
      d = "wzwindow.html#SetModeP";
      c = "slice mode - mouse modifies intersection slices"; break;
    case WZW_KEY_SetModeL:
      d = "wzwindow.html#SetModeL";
      c = "light mode - mouse modifies light position"; break;
    case WZW_KEY_LoadLocal:
      d = "wzwindow.html#SaveLoad";
      c = "session load: loads previously saved session state"; break;
    case WZW_KEY_SaveLocal:
      d = "wzwindow.html#SaveLoad";
      c = "session save: saves the state for this session"; break;
    case WZW_KEY_SaveFile:
      d = "wzwindow.html#SaveLoad";
      c = "global save: saves the state into state file"; break;
    case WZW_KEY_LoadFile:
      d = "wzwindow.html#SaveLoad";
      c = "global load: loads the state from state file"; break;
    case WZW_KEY_ResetTranslation:
	c = "resets the translation of the current %s"; break;
    case WZW_KEY_ResetRotation:
	c = "resets the rotation of the current %s"; break;
    case WZW_KEY_ResetScaling:
	c = "resets the scaling of the current %s"; break;
    case WZW_KEY_P_MOVE_TX:
	c = "translation of the current %s in positive x-direction"; break;
    case WZW_KEY_N_MOVE_TX:
	c = "translation of the current %s in negative x-direction"; break;
    case WZW_KEY_P_MOVE_TY:
	c = "translation of the current %s in positive y-direction"; break;
    case WZW_KEY_N_MOVE_TY:
	c = "translation of the current %s in negative y-direction"; break;
    case WZW_KEY_P_MOVE_TZ:
	c = "translation of the current %s in positive z-direction"; break;
    case WZW_KEY_N_MOVE_TZ:
	c = "translation of the current %s in negative z-direction"; break;
    case WZW_KEY_P_MOVE_RX:
	c = "positive rotation of the current %s in the yz-slice"; break;
    case WZW_KEY_N_MOVE_RX:
	c = "negative rotation of the current %s in the yz-slice"; break;
    case WZW_KEY_P_MOVE_RY:
	c = "positive rotation of the current %s in the zx-slice"; break;
    case WZW_KEY_N_MOVE_RY:
	c = "negative rotation of the current %s in the zx-slice"; break;
    case WZW_KEY_P_MOVE_SC:
	c = "zoom in for the current %s"; break;
    case WZW_KEY_N_MOVE_SC:
	c = "zoom out for the current %s"; break;
    case WZW_KEY_SliceX:
	c = "switches the yz-slice on/off"; break;
    case WZW_KEY_SliceY:
	c = "switches the zx-slice on/off"; break;
    case WZW_KEY_SliceZ:
	c = "switches the xy-slice on/off"; break;
    case GLW_1:	c = "selects the %s 1 as current %s (if defined)"; break;
    case GLW_2:	c = "selects the %s 2 as current %s (if defined)"; break;
    case GLW_3:	c = "selects the %s 3 as current %s (if defined)"; break;
    case GLW_4:	c = "selects the %s 4 as current %s (if defined)"; break;
    case GLW_5:	c = "selects the %s 5 as current %s (if defined)"; break;
    case GLW_6:	c = "selects the %s 6 as current %s (if defined)"; break;
    case GLW_7:	c = "selects the %s 7 as current %s (if defined)"; break;
    case GLW_8:	c = "selects the %s 8 as current %s (if defined)"; break;
    case GLW_9:	c = "selects the %s 9 as current %s (if defined)"; break;
    default:  
      if (win->key_action_table[win->key])
	c = win->key_help_table[win->key];
      else
	c = "key undefined; ""F1"" quits key help mode"; break;
    }
    if (!d)
      switch(win->key){
      case GLW_1:
      case GLW_2:
      case GLW_3:
      case GLW_4:
      case GLW_5:
      case GLW_6:
      case GLW_7:
      case GLW_8:
      case GLW_9:
	d = "wzwindow.html#numeric"; break;
      default:  
	if (win->key_action_table[win->key])
	  d = win->key_url_table[win->key];
	else
	  d = "wzwindow.html#unknown_key"; break;
      }
    obj = wzwGetObject(win);
    for(par=0;par<WZW_PARAMETERS;par++){
      if(win->parDefined[obj][par])
	if(win->key == win->parKey[obj][par]){
	  c = win->parHelp[obj][par];
	  d = win->parURL[obj][par];
	}
    }
    wzPrintDocumentationEntry(d);
    sprintf(temp,c,wzwModeName[win->mode],wzwModeName[win->mode]);
    glwShowState(win->glwin, temp);
    return 1;
}
/*#############################@move@############################*/

static void wzwMove(wzWindow win, double move[WZW_MOVES])
{
    int i,j,k;
    wzwStatus *s = &win->c;
    wzwDefineMoveMode(win);
    for(i=0;i<WZW_MODI;i++){
	if(! win->moveMode[i]) continue;
	for(j=0;j<WZW_OBJECTS;j++){
	    if(! s->move[i][j]) continue;
	    for(k=0;k<WZW_MOVES;k++){
		s->matrix[i][j][k] += move[k];
	    }
	}
    }
    wzwDefinePosition(win);
}

static void wzwMoveReset(wzWindow win, char resets[WZW_MOVES])
{
    int i,j,k;
    wzwStatus *s = &win->c;
    wzwDefineMoveMode(win);
    for(i=0;i<WZW_MODI;i++){
	if(! win->moveMode[i]) continue;
	for(j=0;j<WZW_OBJECTS;j++){
	    if(! s->move[i][j]) continue;
	    for(