r2d.c

是一个手机功能的模拟程序

}

void r2d_release_round_rectangle(T_R2D_SHAPE* self)
{
   T_R2D_ROUND_RECTANGLE *r;
   r=(T_R2D_ROUND_RECTANGLE *)self;

   r2d_release(r);
   #if (R2D_DEBUG == R2D_ON)
   r=NULL;
#endif
}

void r2d_draw_round_rectangle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_ROUND_RECTANGLE *r;
   r=(T_R2D_ROUND_RECTANGLE *)self;
   r2d_draw_round_rectangle(gc,r->ul_x,r->ul_y,r->br_x,r->br_y,r->h,r->v);
}

void r2d_fill_round_rectangle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_ROUND_RECTANGLE *r;
   r=(T_R2D_ROUND_RECTANGLE *)self;
   r2d_fill_round_rectangle(gc,r->ul_x,r->ul_y,r->br_x,r->br_y,r->h,r->v);
}

T_R2D_SHAPE_PTR r2d_clone_round_rectangle_shape(T_RVF_MB_ID bank,T_R2D_SHAPE* self)
{
   T_R2D_ROUND_RECTANGLE *r;
   r=(T_R2D_ROUND_RECTANGLE *)self;

   return(r2d_new_round_rectangle(bank,r->ul_x,r->ul_y,r->br_x,r->br_y,r->h,r->v));
}

T_R2D_SHAPE_PTR r2d_new_round_rectangle(T_RVF_MB_ID bank,INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y,INT16 h,INT16 v)
{
  T_R2D_ROUND_RECTANGLE *r;
  R2D_MALLOC(bank,T_R2D_ROUND_RECTANGLE,sizeof(T_R2D_ROUND_RECTANGLE),r);
  if (r)
  {
  r->refcount=1;
  r->ul_x=ul_x;
  r->ul_y=ul_y;
  r->br_x=br_x;
  r->br_y=br_y;
  r->h=h;
  r->v=v;
  r->p_r2d_class=&r2d_class_round_rectangle;
  } else r=NULL;
  return(r);
}

T_R2D_SHAPE_PTR r2d_clone_arc_shape(T_RVF_MB_ID bank,T_R2D_SHAPE* self)
{
   T_R2D_ARC *r;
   r=(T_R2D_ARC *)self;

   return(r2d_new_arc(bank,r->start_angle,r->stop_angle,r->ul_x,r->ul_y,r->br_x,r->br_y));
}

T_R2D_SHAPE_PTR r2d_new_arc(T_RVF_MB_ID bank,INT16 start_angle, INT16 stop_angle,INT16 ul_x,INT16 ul_y,
                                         INT16 br_x,INT16 br_y)
{
  T_R2D_ARC *r;
  R2D_MALLOC(bank,T_R2D_ARC,sizeof(T_R2D_ARC),r);
  if (r)
  {
  r->refcount=1;
  r->ul_x=ul_x;
  r->ul_y=ul_y;
  r->br_x=br_x;
  r->br_y=br_y;
  r->start_angle=start_angle;
  r->stop_angle=stop_angle;
  r->p_r2d_class=&r2d_class_arc;
  } else r=NULL;
  return(r);
}

void r2d_release_arc(T_R2D_SHAPE *self)
{
  T_R2D_ARC *r;
  r=(T_R2D_ARC *)self;

  r2d_release(r);
}

void r2d_draw_arc_shape(T_R2D_SHAPE *self,T_R2D_GC_PTR gc)
{
}

void r2d_fill_arc_shape(T_R2D_SHAPE *self,T_R2D_GC_PTR gc)
{
}

T_R2D_SHAPE_PTR r2d_new_rectangle_intersection(T_RVF_MB_ID bank,T_R2D_SHAPE_PTR a,T_R2D_SHAPE_PTR b)
{
if ( a && b && (((T_R2D_SHAPE*)a)->p_r2d_class==&r2d_class_rectangle)
&& (((T_R2D_SHAPE*)b)->p_r2d_class==&r2d_class_rectangle))
{
	T_R2D_RECTANGLE *ra;
	T_R2D_RECTANGLE *rb;
	INT16 xa,ya,xb,yb;

	ra=(T_R2D_RECTANGLE *)a;
	rb=(T_R2D_RECTANGLE *)b;

    if (ra->ul_x>rb->ul_x)
		xa=ra->ul_x;
	else
		xa=rb->ul_x;

    if (ra->ul_y>rb->ul_y)
		ya=ra->ul_y;
	else
		ya=rb->ul_y;

	if (ra->br_x<rb->br_x)
		xb=ra->br_x;
	else
		xb=rb->br_x;

    if (ra->br_y<rb->br_y)
		yb=ra->br_y;
	else
		yb=rb->br_y;

	if ((xa<=xb) && (ya<=yb))
		return(r2d_new_rectangle(bank,xa,ya,xb,yb));
	else
		return(R2D_EMPTY_RECT);

}
else return(NULL);
}

T_R2D_SHAPE_PTR r2d_new_rectangle_union(T_RVF_MB_ID bank,T_R2D_SHAPE_PTR a,T_R2D_SHAPE_PTR b)
{
	if ( a && b && (((T_R2D_SHAPE*)a)->p_r2d_class==&r2d_class_rectangle)
&& (((T_R2D_SHAPE*)b)->p_r2d_class==&r2d_class_rectangle))
{
	T_R2D_RECTANGLE *ra;
	T_R2D_RECTANGLE *rb;
	INT16 xa,ya,xb,yb;

	ra=(T_R2D_RECTANGLE *)a;
	rb=(T_R2D_RECTANGLE *)b;

    if (ra->ul_x<rb->ul_x)
		xa=ra->ul_x;
	else
		xa=rb->ul_x;

    if (ra->ul_y<rb->ul_y)
		ya=ra->ul_y;
	else
		ya=rb->ul_y;

	if (ra->br_x>rb->br_x)
		xb=ra->br_x;
	else
		xb=rb->br_x;

    if (ra->br_y>rb->br_y)
		yb=ra->br_y;
	else
		yb=rb->br_y;

	if ((xa<=xb) && (ya<=yb))
		return(r2d_new_rectangle(bank,xa,ya,xb,yb));
	else
		return(R2D_EMPTY_RECT);

}
else if (a) 
return(r2d_clone_shape(bank,a));
else if (b)
return(r2d_clone_shape(bank,b));
else
return(NULL);
}

T_R2D_SHAPE_PTR r2d_new_text(T_RVF_MB_ID bank,INT16 x, INT16 y,T_R2D_UTF16 *the_text)
{
  T_R2D_TEXT *r;
  R2D_MALLOC(bank,T_R2D_TEXT,sizeof(T_R2D_TEXT),r);
  if (r)
  {
  r->refcount=1;
  r->x=x;
  r->y=y;
  r->p_text=the_text;
  r->p_r2d_class=&r2d_class_text;
  } else r=NULL;
  return(r);
}

T_R2D_SHAPE_PTR r2d_clone_text_shape(T_RVF_MB_ID bank,T_R2D_SHAPE* self)
{
   T_R2D_TEXT *r;
   r=(T_R2D_TEXT *)self;

   return(r2d_new_text(bank,r->x,r->y,NULL));
}


void r2d_release_text(T_R2D_SHAPE *self)
{
  T_R2D_TEXT *r;
  r=(T_R2D_TEXT *)self;

  r2d_release(r);
}

void r2d_draw_text_shape(T_R2D_SHAPE *self,T_R2D_GC_PTR gc)
{
	T_R2D_TEXT *r;
	r=(T_R2D_TEXT *)self;
	r2d_draw_text(gc,r->x,r->y,r->p_text);
}

void r2d_fill_text_shape(T_R2D_SHAPE *self,T_R2D_GC_PTR gc)
{
    // A text has no interior and thus cannot be filled.
}




////////////////////////////////////////
//
// Clipping functions
//

// Conversion is done such that line y = ymax and x=xmax MUST NOT
// be drawn. So, they do not belong to the cliiping region
// So, behavior of s_clipping_shape is using drawing convention
// and not the clipping convention
static T_R2D_SHAPE_PTR r2d_s_level(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR self)
{
	T_R2D_SHAPE_PTR result;
	T_R2D_RECTANGLE *r;

	
	r=(T_R2D_RECTANGLE*)self;

	if ((r) && (gc))
	{

	result=r2d_clone_shape(r2d_mb_id,self);
	r=(T_R2D_RECTANGLE*)result;

	r2d_local_to_global(gc,&(r->ul_x),&(r->ul_y));
	r2d_local_to_global(gc,&(r->br_x),&(r->br_y));

	//r2d_mirror_clip_rectangle(gc,result);
	r2d_mirror_rectangle(gc,result);
	r=(T_R2D_RECTANGLE*)result;

#if (R2D_REFRESH != R2D_VERTICAL)
	r2d_diagonal_mirror(result);
	r=(T_R2D_RECTANGLE*)result;
#endif
	
	return(result);
	}
	else
		return(NULL);
}

void r2d_set_clipping_shape(T_R2D_SHAPE_PTR self,T_R2D_GC_PTR gc)
{

   if ((self) && (((T_R2D_SHAPE*)self)->p_r2d_class==&r2d_class_rectangle))
   {
       T_R2D_RECTANGLE *r;
	   INT16 orgx,orgy;

       r=(T_R2D_RECTANGLE *)self;

	   r2d_get_context_origin(gc,&orgx,&orgy);

#if (R2D_DEBUG == R2D_ON)
	   if ((r->ul_x>=orgx)
		  && (r->ul_y>=orgy)
		  && (r->br_x<=r2d_get_width(gc)+orgx)
		  && (r->br_y<=r2d_get_height(gc)+orgy))
#endif
		  
       {
       r2d_release_shape(((T_R2D_GC *)gc)->p_clipping_shape);
       ((T_R2D_GC *)gc)->p_clipping_shape=self;
       r2d_retain(self);

	   r2d_release_shape(((T_R2D_GC *)gc)->p_s_clipping_shape);
       ((T_R2D_GC *)gc)->p_s_clipping_shape=r2d_s_level(gc,self);
	   }
   }
}

T_R2D_SHAPE_PTR r2d_get_clipping_shape(T_R2D_GC_PTR gc)
{
   return(((T_R2D_GC *)gc)->p_clipping_shape);
}

T_R2D_ERROR r2d_restore_standard_clipping_shape(T_R2D_GC_PTR gc)
{
    INT16 x,y;
	T_R2D_SHAPE_PTR s,sb;
    r2d_get_context_origin(gc,&x,&y);
	s=((T_R2D_GC *)gc)->p_clipping_shape;
	sb=((T_R2D_GC *)gc)->p_s_clipping_shape;
    
    ((T_R2D_GC *)gc)->p_clipping_shape=r2d_new_rectangle(r2d_mb_id,x,y,x+r2d_get_width(gc),y+r2d_get_height(gc));
    
// No mirroring when shape is the whole LCD
// Force use of global coordinates for s_ frame
#if (R2D_REFRESH == R2D_VERTICAL)
	((T_R2D_GC *)gc)->p_s_clipping_shape=
		r2d_new_rectangle(r2d_mb_id,0,0,r2d_get_width(gc),r2d_get_height(gc));
#else
	((T_R2D_GC *)gc)->p_s_clipping_shape=
		r2d_new_rectangle(r2d_mb_id,0,0,r2d_get_height(gc),r2d_get_width(gc));
#endif

	 
	if ((((T_R2D_GC *)gc)->p_clipping_shape==NULL) 
		|| (((T_R2D_GC *)gc)->p_s_clipping_shape==NULL))
	{
		if (((T_R2D_GC *)gc)->p_clipping_shape!=NULL)
          r2d_release_shape(((T_R2D_GC *)gc)->p_clipping_shape);
		if (((T_R2D_GC *)gc)->p_s_clipping_shape!=NULL)
          r2d_release_shape(((T_R2D_GC *)gc)->p_s_clipping_shape);
        ((T_R2D_GC *)gc)->p_clipping_shape=s;
		((T_R2D_GC *)gc)->p_s_clipping_shape=sb;
		return(R2D_MEMORY_ERR);
	}
	else
	{
	    r2d_release_shape(s);
		r2d_release_shape(sb);
		return(R2D_OK);
	}
}


////////////////////////////////////////
//
// Graphical primitives
//

// S COORDINATES
static void r2d_s_fill_point(T_R2D_GC_PTR gc,INT16 x,INT16 y,INT16 pen_size)
{
    INT16 ul_x,ul_y,br_x,br_y,bs,as;
    UINT32 f,b;

    bs=(pen_size>>1);
    as=(pen_size>>1) + (pen_size&1);

	// Squares are not symetrically placed
	// since pen_size is not always odd
    // Mirroring must take it into account so that the
	// asymetry is also mirrored
#ifdef R2D_MIRRORED_X
    ul_x=x-bs;
	br_x=x+as-1;
#else
	ul_x=x-bs+1;
	br_x=x+as;
    
#endif

#ifdef R2D_MIRRORED_Y
    ul_y=y-bs;
    br_y=y+as-1;
#else
    ul_y=y-bs+1;
    br_y=y+as;
#endif

    //printf("%d %d %d %d\n",ul_x,ul_y,br_x,br_y);

	
    r2d_s_fill_rectangle(gc,ul_x-1,ul_y-1,br_x+1,br_y+1,FALSE);

}

// Draw point in gc at position (x,y)
// S COORDINATES
static void r2d_s_draw_point(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
  UINT32 pixel_value;
  INT16 pen_size;
  BOOLEAN isLCD_format,can_draw;
  T_R2D_GC* pgc;

  can_draw=FALSE;

  if (r2d_dash_enabled(gc))
  {
	  if (r2d_dash[(x&0x7) + ((y&0x7)<<3)])
		  can_draw=TRUE;
  }
  else
	  can_draw=TRUE;
  
  if (can_draw==TRUE)
  {
  pgc=(T_R2D_GC*)gc;

  isLCD_format=((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind!=R2D_FULL_KIND;


  pen_size=r2d_get_pen_size(gc);

  
  if (r2d_point_in_shape(((T_R2D_GC*)gc)->p_s_clipping_shape,x,y))
  {

	 
    if (pen_size>1)
	   r2d_s_fill_point(gc,x,y,pen_size);
     
       
    else
    {
       // Dithering is relative to global coordinate system
      

   // Color is recomputed only when dithering is on
   #if (R2D_DITHERING == R2D_ON)
       if (isLCD_format)
           pixel_value=r2d_get_dithering_matrix_entry(((T_R2D_GC*)gc)->p_foreground_dithered_cache,x,y);
       else
           pixel_value=((T_R2D_GC*)gc)->foreground_pixel_value;
   #else
       pixel_value=((T_R2D_GC*)gc)->foreground_pixel_value;
   #endif

       // Low level pixel drawing routine with CONVERTED color value
	   
       IND_r2d_write_lcd_pixel(gc,x,y,pixel_value, R2D_COPY_MODE); //zhangzg 07/16/2002
    }
  }
  
  r2d_check_and_send_event(gc);
  }
}
// Draw point in gc at position (x,y)
// H COORDINATES
void r2d_draw_point(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
#if 0   //added by zym
	if (r2d_point_in_shape(((T_R2D_GC*)gc)->p_clipping_shape,x,y))
	{
		r2d_local_to_global(gc,&x,&y);
	
#ifdef R2D_MIRRORED_X
	  x=r2d_get_width(gc)-1-x;
#endif

#ifdef R2D_MIRRORED_Y
	  y=r2d_get_height(gc)-1-y;
#endif

   
	
	
	if (gc==r2d_g_lcd_gc)
      r2d_update_region(x,y,x,y);
#if (R2D_REFRESH == R2D_VERTICAL)
	r2d_s_draw_point(gc,x,y);
#else
	r2d_s_draw_point(gc,y,x);
#endif

	}

#endif

///zym  draw point by foreground 
     UINT32 color;
     UINT16 color16;
     UINT16 red,green,blue;
     while(g_test)
     	rvf_delay(1);
     color = (((T_R2D_GC*)gc)->foreground_color);
   
     red=r2d_red(color);
     green=r2d_green(color);
     blue=r2d_blue(color);

     color = 0x0;

    color = (red/8)<<11;
    color |=(green/4)<<5;
    color |=(blue/8);             //changed by zym at  6/12

     color16 = (UINT16)color;
     //IND_r2d_write_lcd_pixel(gc,y,x,color, R2D_COPY_MODE); //zhangzg 07/16/2002
     r2d_draw_lcd_pixel(gc,y,x,color16, R2D_COPY_MODE);
     
      r2d_check_and_send_event(gc);

}

void           r2d_erase_point(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
#if 0
   T_R2D_ARGB_COLOR col;

   
if (r2d_point_in_shape(((T_R2D_GC*)gc)->p_clipping_shape,x,y))
{
	r2d_local_to_global(gc,&x,&y);
	col=r2d_get_foreground_color(gc);
   r2d_set_foreground_color(gc,r2d_get_background_color(gc));
	
#ifdef R2D_MIRRORED_X
	  x=r2d_get_width(gc)-1-x;
#endif

#ifdef R2D_MIRRORED_Y
	  y=r2d_get_height(gc)-1-y;

#endif

   
   if (gc==r2d_g_lcd_gc)
      r2d_update_region(x,y,x,y);
   
	//r2d_s_draw_point(gc,x,y);