hre_api.c

开放源码实时操作系统源码.

		memcpy((void*)re->re_result.gval,trans,sizeof(gesture));
	    }
	    break;
	    
	  case REC_ASCII:
	  case REC_VAR:
	  case REC_OTHER:
	    if( size > 0 && trans != NULL ) {
		re->re_result.aval = 
		     (char*)safe_malloc((size+1)*sizeof(char));
		memcpy((void*)re->re_result.aval,trans,size*sizeof(char));
		re->re_result.aval[size] = '\000';
	    }
	    break;
	    
	  case REC_WCHAR:
	    if( size > 0 && trans != NULL ) {
		re->re_result.wval = 
		     (wchar_t*)safe_malloc((size+1)*sizeof(wchar_t));
		memcpy((void*)re->re_result.wval,trans,size*sizeof(wchar_t));
		re->re_result.wval[size] = '\000';
	    }
	    break;
	    
	  case REC_CORR:
	    if( size > 0 && trans != NULL ) {
	      re->re_result.rcval =
		   (rec_correlation*)safe_malloc(sizeof(rec_correlation));
	      memcpy((void*)re->re_result.rcval,
		     trans,
		     sizeof(rec_correlation));
	    }
	    break;

	  default:
	    return(NULL);
	}

    }

    return(re);
}

static void cleanup_rec_element(rec_element* re,bool delete_points_p)
{
  switch(re->re_type) {
    
  case REC_NONE:
    break;
    
  case REC_ASCII:
  case REC_VAR:
  case REC_WCHAR:
  case REC_OTHER:
    free(re->re_result.aval);
    break;
    
  case REC_GESTURE:
    delete_gesture_array(1,re->re_result.gval,true);
    break;

  case REC_CORR:
    delete_rec_correlation(re->re_result.rcval,
			   delete_points_p);
    break;
    
  }
  
}

/*
 * rec_correlation
*/


rec_correlation* 
make_rec_correlation(char type,
		     u_int size,
		     void* trans,
		     rec_confidence conf,
		     u_int ps_size)
{
  rec_correlation* rc;

    rc = (rec_correlation*)safe_malloc(sizeof(rec_correlation));

    rc->ro_nstrokes = ps_size;

    /*First initialize element.*/

    if( initialize_rec_element(&(rc->ro_elem),
			       type,
			       size,
			       trans,
			       conf) == NULL ) {
      return(NULL);
    }
    
    if( (rc->ro_strokes = make_pen_stroke_array(ps_size)) == NULL ) {
      return(NULL);
    }
    
    rc->ro_start = (u_int*)safe_malloc(ps_size * sizeof(int));
    rc->ro_stop = (u_int*)safe_malloc(ps_size * sizeof(int));
    return(rc);
}

void delete_rec_correlation(rec_correlation* rc,bool delete_points_p)
{
  if( rc != NULL ) {

    cleanup_rec_element(&rc->ro_elem,delete_points_p);

    delete_pen_stroke_array(rc->ro_nstrokes,rc->ro_strokes,delete_points_p);

    if( rc->ro_start != NULL ) {
      free(rc->ro_start);
    }

    if( rc->ro_stop != NULL ) {
      free(rc->ro_stop);
    }

    free(rc);
  }

}


/*
 * rec_fn
*/


rec_fn* make_rec_fn_array(u_int size)
{
    rec_fn* ri = (rec_fn*)safe_malloc((size + 1) * sizeof(rec_fn));
    int i;

    for( i = 0; i < size; i++ ) {
	ri[i] = NULL;
    }

    ri[i] = NULL;

    return(ri);
}

void delete_rec_fn_array(rec_fn* rf)
{
    if( rf != NULL ) {
	free(rf);
    }
}

/*
 * pen_stroke
*/


pen_stroke* make_pen_stroke_array(u_int size)
{
    int i;
    pen_stroke* ri;

    ri = (pen_stroke*) safe_malloc(size * sizeof(pen_stroke));
    for( i = 0; i < size; i++ ) {
	ri[i].ps_npts = 0;
	ri[i].ps_pts = NULL;
	ri[i].ps_nstate = 0;
	ri[i].ps_state = NULL;
    }

    return(ri);       
}

pen_stroke* initialize_pen_stroke(pen_stroke* ps,
				  u_int npts,
				  pen_point* pts,
				  u_int nstate,
				  u_int* trans,
				  pen_state* state)
{
  if( ps != NULL ) {
    ps->ps_npts = npts;
    ps->ps_pts = pts;
    ps->ps_nstate = nstate;
    ps->ps_trans = trans;
    ps->ps_state = state;
  }
  return (ps);
}

void delete_pen_stroke_array(u_int size,pen_stroke* ps,bool delete_points_p)
{
  int i;
  
    if( ps != NULL ) {

      for( i = 0; i < size; i++ ) {

	    if( ps[i].ps_state != NULL ) {
		free(ps[i].ps_state);
	    }

	    if( ps[i].ps_trans != NULL ) {
	        free(ps[i].ps_trans);
	    }

	    if( delete_points_p ) {
		delete_pen_point_array(ps[i].ps_pts);
	    }

      }
	
      free(ps);
    }
}

/*
 * pen_point
*/


pen_point* make_pen_point_array(u_int size)
{
    pen_point* pp = (pen_point*)safe_malloc(size * sizeof(pen_point));
    int i;

    for( i = 0; i < size; i++ ) {
	pp[i].time = 0;
	pp[i].x = pp[i].y = 0;
    }

    return(pp);
}

void delete_pen_point_array(pen_point* pp)
{
    if( pp != NULL ) {
	free(pp);
    }
}

/*
 * pen_state
*/


pen_state* make_pen_state_array(u_int size)
{
  int i;

  pen_state* ps = (pen_state*)safe_malloc(size*sizeof(pen_state));
  
  for( i = 0; i < size; i++ ) {
    ps[i].pt_button = 0;
    ps[i].pt_pen = 0;
    ps[i].pt_pressure = 0;
    ps[i].pt_anglex = 0.0;
    ps[i].pt_angley = 0.0;
    ps[i].pt_barrelrotate = 0.0;
  }

  return(ps);

}

pen_state* initialize_pen_state(pen_state* ps,
				u_short button,
				u_short pen,
				short pressure,
				double anglex,
				double angley,
				double barrelrotate)
{
  if( ps != NULL ) {
    ps->pt_button = button;
    ps->pt_pen = pen;
    ps->pt_pressure = pressure;
    ps->pt_anglex = anglex;
    ps->pt_angley = angley;
    ps->pt_barrelrotate = barrelrotate;
  }

  return(ps);
}

void delete_pen_state_array(pen_state* ps)
{
  if( ps != NULL ) {
    free(ps);
  }
}

/*
 * gesture 
*/

gesture*
make_gesture_array(u_int size)
{
    return((gesture*)safe_malloc(size * sizeof(gesture)));
}

gesture* initialize_gesture(gesture* g,
			    char* name,
			    u_int nhs,
			    pen_point* hspots,
			    pen_rect bbox,
			    xgesture fn,
			    void* wsinfo)
{
    if( g != NULL ) {

	/*We don't do points, 'cause they come from the window system.*/

	g->g_nhs = nhs;
	g->g_hspots = hspots;

	g->g_name = strdup(name);

	g->g_bbox.x = bbox.x;
	g->g_bbox.y = bbox.y;
	g->g_bbox.width = bbox.width;
	g->g_bbox.height = bbox.height;
	g->g_action = fn;
	g->g_wsinfo = wsinfo;
    }

    return(g);
}

void
delete_gesture_array(u_int size,gesture* ga,bool delete_points_p)
{
    int i;

    if( ga != NULL ) {

      for( i = 0; i < size; i++ ) {
	
	free(ga[i].g_name);
	
	if( delete_points_p ) {
	  delete_pen_point_array(ga[i].g_hspots);
	}
      }
      
      free(ga);
    }
}

/*
 * copy fns for stroke buffer management.
*/

static pen_stroke* 
copy_pen_stroke(pen_stroke* ps1,pen_stroke* ps2)
{
  u_int* trans = NULL;
  pen_state* state = NULL;
  
  if( (trans = 
       copy_state_trans_array(ps2->ps_nstate,
			      ps2->ps_trans)) == NULL ) {
    return(NULL);
  }
  
  if( (state = 
       copy_pen_state_array(ps2->ps_nstate,
			    ps2->ps_state)) == NULL ) {
    free(trans);
    return(NULL);
  }
  
  initialize_pen_stroke(ps1,
			ps2->ps_npts,
			ps2->ps_pts,
			ps2->ps_nstate,
			trans,
			state);
  return(ps1);

}

pen_stroke*
 copy_pen_stroke_array(u_int nstrokes,
		    pen_stroke* strokes)
{
  int i;
  pen_stroke* ps = make_pen_stroke_array(nstrokes);

  if( ps != NULL ) {

    for( i = 0; i < nstrokes; i++ ) {

      copy_pen_stroke(&ps[i],&strokes[i]);

    }

  }

  return(ps);
}

pen_state*
 copy_pen_state_array(u_int nstate,pen_state* state)
{
  pen_state* ps = make_pen_state_array(nstate);
  int i;

  if( ps != NULL ) {

    for( i = 0; i < nstate; i++ ) {
      
      initialize_pen_state(&ps[i],
			   state[i].pt_button,
			   state[i].pt_pen,
			   state[i].pt_pressure,
			   state[i].pt_anglex,
			   state[i].pt_angley,
			   state[i].pt_barrelrotate);
    }
    
  }

  return(ps);
}

u_int*
 copy_state_trans_array(u_int ntrans,u_int* trans)
{
  u_int* pt = (u_int*)safe_malloc(ntrans*sizeof(u_int));
  int i;

  for( i = 0; i < ntrans; i++ ) {
    pt[i] = trans[i];
  }
  return(pt);

}

pen_stroke*
concatenate_pen_strokes(int nstrokes1,
			pen_stroke* strokes1,
			int nstrokes2,
			pen_stroke* strokes2,
			int* nstrokes3,
			pen_stroke** strokes3)
{
  int i;
  int ns;
  pen_stroke* ps;

  /*Measure new strokes*/

  ns = nstrokes1 + nstrokes2;

  /*Allocate memory*/

  if( (ps = make_pen_stroke_array(ns)) == NULL ) {
    return(NULL);
  }

  /*Copy old ones into new.*/

  for( i = 0; i < nstrokes1; i++ ) {
    if( copy_pen_stroke(&ps[i],&strokes1[i]) == NULL ) {
      delete_pen_stroke_array(ns,ps,false);
      return(NULL);
    }
  }

  for( ; i < ns; i++ ) {
    if( copy_pen_stroke(&ps[i],&strokes2[i - nstrokes1]) == NULL ) {
      delete_pen_stroke_array(ns,ps,false);
      return(NULL);
    }
  }

  *nstrokes3 = ns;
  *strokes3 = ps;

  return(ps);
}