r2d.c

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

{
	rvf_lock_mutex(r2d_g_global_mutex);
	r2d_g_refresh_disabled--;
    if (r2d_g_refresh_disabled==0)
      r2d_flush();
	rvf_unlock_mutex(r2d_g_global_mutex);
}

////////////////////////////////////////
//
// Colors
//


// Return ARGB foreground color for the gc
T_R2D_ARGB_COLOR r2d_get_foreground_color(T_R2D_GC_PTR gc)
{
  return (((T_R2D_GC*)gc)->foreground_color);
}

// Set ARGB foreground color for the gc
// (Alpha channel not yet supported)
void r2d_set_foreground_color_with_argb(T_R2D_GC_PTR gc,UINT16 alpha,UINT16 red,UINT16 green,UINT16 blue)
{
 UINT32 color;
 color=r2d_new_argb_color(alpha,red,green,blue);
 if (color !=((T_R2D_GC*)gc)->foreground_color)
 {
   ((T_R2D_GC*)gc)->foreground_color=color;

   if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==R2D_FULL_KIND)
r2d_convert_foreground_color_color(gc,color);
   else
   r2d_convert_foreground_color(gc,color);
 }
}

// Set ARGB foreground color for the gc
// (Alpha channel not yet supported)
void r2d_set_foreground_color(T_R2D_GC_PTR gc,T_R2D_ARGB_COLOR color)
{
 if (color !=((T_R2D_GC*)gc)->foreground_color)
 {
   ((T_R2D_GC*)gc)->foreground_color=color;
   if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==R2D_FULL_KIND)
  r2d_convert_foreground_color_color(gc,color);
	   else
   r2d_convert_foreground_color(gc,color);
 }
}

// Return ARGB foreground color for the gc
T_R2D_ARGB_COLOR r2d_get_background_color(T_R2D_GC_PTR gc)
{
  return (((T_R2D_GC*)gc)->background_color);
}

// Set ARGB foreground color for the gc
// (Alpha channel not yet supported)
void r2d_set_background_color_with_argb(T_R2D_GC_PTR gc,UINT16 alpha,UINT16 red,UINT16 green,UINT16 blue)
{
 UINT32 color;
 color=r2d_new_argb_color(alpha,red,green,blue);
 if (color !=((T_R2D_GC*)gc)->background_color)
 {
   ((T_R2D_GC*)gc)->background_color=color;
   if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==R2D_FULL_KIND)
  r2d_convert_background_color_color(gc,color);
	   else
   r2d_convert_background_color(gc,color);
 }
}

// Set ARGB foreground color for the gc
// (Alpha channel not yet supported)
void r2d_set_background_color(T_R2D_GC_PTR gc,T_R2D_ARGB_COLOR color)
{
 if (color !=((T_R2D_GC*)gc)->background_color)
 {
   ((T_R2D_GC*)gc)->background_color=color;
   if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==R2D_FULL_KIND)
	   r2d_convert_background_color_color(gc,color);
  else
   r2d_convert_background_color(gc,color);
 }
}

void   r2d_set_background_texture(T_R2D_GC_PTR gc,T_R2D_ANCHORED_TEXTURE_PTR texture)
{
	
    UINT32 length;
	T_R2D_ANCHORED_TEXTURE *t;

	// If a texture is already in place try to release it
	if (((T_R2D_GC*)gc)->background_texture!=NULL)
	{
		r2d_release_anchored_texture(((T_R2D_GC*)gc)->background_texture);
		((T_R2D_GC*)gc)->background_texture=NULL;
	}
	

	((T_R2D_GC*)gc)->background_texture=texture;
     

   if (texture!=NULL)
   {
     r2d_retain(texture);
   }

  

	
}

T_R2D_ANCHORED_TEXTURE_PTR r2d_get_background_texture(T_R2D_GC_PTR gc)
{
	return ((T_R2D_GC*)gc)->background_texture;
}

T_R2D_ARGB_COLOR         r2d_new_argb_color(UINT16 alpha,UINT16 red,UINT16 green,UINT16 blue)
{
   T_R2D_ARGB_COLOR col;
   col=0;

   col=col|(alpha&0xFF);
   col=col<<8;
   col=col|(red&0xFF);
   col=col<<8;
   col=col|(green&0xFF);
   col=col<<8;
   col=col|(blue&0xFF);
  
   return(col);
}

T_R2D_ARGB_COLOR         r2d_get_argb_color_at_point(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
  UINT32 result;
  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 (R2D_REFRESH == R2D_VERTICAL)
	result=IND_r2d_get_color_pixel_value(gc,x,y);
#else
	result=IND_r2d_get_color_pixel_value(gc,y,x);
#endif
    return(result);
  } 
  else
  return(0);
}

T_R2D_ARGB_COLOR         r2d_get_standard_argb_color(T_R2D_COLOR_REF ref)
{
  switch(ref)
  {
     case R2D_RED: return(r2d_new_argb_color(0,255,0,0)); break;
     case R2D_BLUE:return(r2d_new_argb_color(0,0,0,255)); break;
     case R2D_GREEN:return(r2d_new_argb_color(0,0,255,0)); break;
     case R2D_WHITE:return(r2d_new_argb_color(0,255,255,255)); break;
     case R2D_BLACK:return(r2d_new_argb_color(0,0,0,0)); break;
     case R2D_GRAY50:return(r2d_new_argb_color(0,127,127,12)); break;
     default:return(r2d_new_argb_color(0,0,0,0)); break;
  }
}

// h from 0 to 360 : 
// s from 0 to 1 : 1 is 0x800000
// v from 0 to 1
// r,g,b from 0 to 1
// Value in Q8
void r2d_hsv_to_rgb( INT16 *r, INT16 *g, INT16 *b, INT32 h, INT32 s, INT32 v )
{
        int i;
        INT32 f, p, q, t;

		//s and v in Q8. So 255 is FF is 1
		
        if( s == 0 ) {
                // achromatic (grey)
                *r = *g = *b = (v>>13);
                return;
        }
        h = h * (0x3000000 >> 8) ; // 360/256 / 60 ;Q23 ; sector 0 to 5
        i = h & 0xFF800000;
        f = h - i;                      // factorial part of h
		i=i>>15;
        f = f >> 15; // Q16
        p = (v * ( 0x100 - s )) >> 8;
        q = (v * ( 0x100 - ((s * f) >> 8) )) >> 8;
        t = (v * ( 0x100 - ((s * ( 0x100 - f )) >> 8) )) >> 8;
        switch( i>>8 ) {
                case 0:
                        *r = v;
                        *g = t;
                        *b = p;
                        break;
                case 1:
                        *r = q;
                        *g = v;
                        *b = p;
                        break;
                case 2:
                        *r = p;  
                        *g = v;
                        *b = t;
                        break;
                case 3:
                        *r = p;
                        *g = q;
                        *b = v;
                        break;
                case 4:
                        *r = t;
                        *g = p;
                        *b = v;
                        break; 
                default:                // case 5:
                        *r = v;
                        *g = p;
                        *b = q;
                        break; 
        }
}

////////////////////////////////////////
//
// Shapes
//

// H COORDINATES ...
void r2d_draw_shape(T_R2D_SHAPE_PTR self,T_R2D_GC_PTR gc)
{
	
    if (self)
	{
		((T_R2D_SHAPE*)self)->p_r2d_class->draw(self,gc);
	  
	}
}

void r2d_fill_shape(T_R2D_SHAPE_PTR self,T_R2D_GC_PTR gc)
{
    if (self)
	{
      ((T_R2D_SHAPE*)self)->p_r2d_class->fill(self,gc);
	  
	}
}

void r2d_release_shape(T_R2D_SHAPE_PTR self)
{


   if (self)
     ((T_R2D_SHAPE*)self)->p_r2d_class->release(self);
}

T_R2D_SHAPE_PTR r2d_clone_shape(T_RVF_MB_ID bank,T_R2D_SHAPE_PTR self)
{
   if (self)
     return (((T_R2D_SHAPE*)self)->p_r2d_class->clone(bank,self));
   else
     return(NULL);
}

void r2d_translate_shape(T_R2D_SHAPE_PTR self,INT16 dx,INT16 dy)
{
   if (self)
     ((T_R2D_SHAPE*)self)->p_r2d_class->translate(self,dx,dy);
     
} 

BOOLEAN r2d_point_in_shape(T_R2D_SHAPE_PTR self,INT16 x,INT16 y)
{

  if (self)
     return(((T_R2D_SHAPE*)self)->p_r2d_class->point_in_shape(self,x,y));
  else
      return(FALSE);

}


BOOLEAN r2d_point_in_rectangle_shape(T_R2D_SHAPE* self,INT16 x,INT16 y)
{
	T_R2D_RECTANGLE *r;

	r=(T_R2D_RECTANGLE*)self;

    return (((x>=r2d_get_xmin(self))
    && (x<r2d_get_xmax(self))
    && (y>=r2d_get_ymin(self))
    && (y<r2d_get_ymax(self))));
}

BOOLEAN r2d_point_in_circle_shape(T_R2D_SHAPE* self,INT16 x,INT16 y)
{
	T_R2D_CIRCLE *c;
	c=(T_R2D_CIRCLE*)self;

	return((x-c->x)*(x-c->x)+(y-c->y)*(y-c->y)-c->r*c->r<0);
}

BOOLEAN r2d_point_in_ellipse_shape(T_R2D_SHAPE* self,INT16 x,INT16 y)
{
	T_R2D_ELLIPSE *c;
	INT32 a,b,cx,cy,nx,ny;

	c=(T_R2D_ELLIPSE*)self;
	// Work on Q1
	
	// a is half width so no <<1 is used here
	a=(c->br_x-c->ul_x);
	b=(c->br_y-c->ul_y);

	nx=x<<1;
	ny=y<<1;

	cx=((c->ul_x)<<1)+a;
    cy=((c->ul_y)<<1)+b;

    //b^2*x^2+a^2y^2-a^2b^2=0

	return((b*b*(nx-cx)*(nx-cx)+a*a*(ny-cy)*(ny-cy)-a*a*b*b)<0);

}

BOOLEAN r2d_point_in_round_rectangle_shape(T_R2D_SHAPE* self,INT16 x,INT16 y)
{
  T_R2D_ROUND_RECTANGLE *r;
  BOOLEAN result;

  result=FALSE;
  r=(T_R2D_ROUND_RECTANGLE *)self;

  if ((x>=r->ul_x+r->h+1) && (x<r->br_x-r->h) && (y>=r->ul_y) && (y<r->br_y))
	  result=TRUE;
  else if ((x>=r->ul_x) && (x<r->br_x) && (y>=r->ul_y+r->v+1) && (y<r->br_y-r->v))
	  result=TRUE;
  else
  {
	  INT32 a,b,cx,cy,nx,ny;

      if (x>=r->br_x-r->h)
		  x=x-(r->br_x-r->ul_x)+((r->h)<<1);

      if (y>=r->br_y-r->v)
	      y=y-(r->br_y-r->ul_y)+((r->v)<<1);

	  
	  a=(r->h<<1);
	  b=(r->v<<1);

	  nx=x<<1;
	  ny=y<<1;

	  cx=((r->ul_x)<<1)+a;
      cy=((r->ul_y)<<1)+b;

    //b^2*x^2+a^2y^2-a^2b^2=0

	 result=(b*b*(nx-cx)*(nx-cx)+a*a*(ny-cy)*(ny-cy)-a*a*b*b)<0;

   
  }
  
  return(result);
  
}

BOOLEAN r2d_point_in_not_supported_shape(T_R2D_SHAPE* self,INT16 x,INT16 y)
{
    return FALSE;
}

void r2d_translate_rectangle_shape(T_R2D_SHAPE* self,INT16 dx,INT16 dy)
{
   T_R2D_RECTANGLE *r;
   r=(T_R2D_RECTANGLE *)self;
   r->ul_x+=dx;
   r->ul_y+=dy;
   r->br_x+=dx;
   r->br_y+=dy;
} 

void r2d_translate_point_shape(T_R2D_SHAPE* self,INT16 dx,INT16 dy)
{
   T_R2D_CIRCLE *r;
   r=(T_R2D_CIRCLE *)self;
   r->x+=dx;
   r->y+=dy;
} 


T_R2D_SHAPE_PTR r2d_new_rectangle(T_RVF_MB_ID bank,INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y)
{
  T_R2D_RECTANGLE *r;
  R2D_MALLOC(bank,T_R2D_RECTANGLE,sizeof(T_R2D_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->p_r2d_class=&r2d_class_rectangle;
  } else r=NULL;
  return(r);
}

void r2d_release_rectangle(T_R2D_SHAPE* self)
{
   T_R2D_RECTANGLE *r;
   r=(T_R2D_RECTANGLE *)self;

   r2d_release(r);
}

T_R2D_SHAPE_PTR r2d_clone_rectangle_shape(T_RVF_MB_ID bank,T_R2D_SHAPE* self)
{
   T_R2D_RECTANGLE *r;
   r=(T_R2D_RECTANGLE *)self;

   return(r2d_new_rectangle(bank,r->ul_x,r->ul_y,r->br_x,r->br_y));
}

void r2d_draw_rectangle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_RECTANGLE *r;
   r=(T_R2D_RECTANGLE *)self;
   r2d_draw_rectangle(gc,r->ul_x,r->ul_y,r->br_x,r->br_y);
}

void r2d_fill_rectangle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_RECTANGLE *r;
   r=(T_R2D_RECTANGLE *)self;
   r2d_fill_rectangle(gc,r->ul_x,r->ul_y,r->br_x,r->br_y);
}


void r2d_release_circle(T_R2D_SHAPE* self)
{
   T_R2D_CIRCLE *r;
   r=(T_R2D_CIRCLE *)self;

   r2d_release(r);

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

T_R2D_SHAPE_PTR r2d_clone_circle_shape(T_RVF_MB_ID bank,T_R2D_SHAPE* self)
{
   T_R2D_CIRCLE *r;
   r=(T_R2D_CIRCLE *)self;

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

void r2d_draw_circle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_CIRCLE *r;
   r=(T_R2D_CIRCLE *)self;
   r2d_draw_circle(gc,r->x,r->y,r->r);
}

void r2d_fill_circle_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_CIRCLE *r;
   r=(T_R2D_CIRCLE *)self;
   r2d_fill_circle(gc,r->x,r->y,r->r);
}

T_R2D_SHAPE_PTR r2d_new_circle(T_RVF_MB_ID bank,INT16 x,INT16 y,INT16 r)
{
  T_R2D_CIRCLE *c;
  R2D_MALLOC(bank,T_R2D_CIRCLE,sizeof(T_R2D_CIRCLE),c);
  if (c)
  {
  c->refcount=1;
  c->x=x;
  c->y=y;
  c->r=r;
  c->p_r2d_class=&r2d_class_circle;
  } else c=NULL;
  return(c);
}

void r2d_release_ellipse(T_R2D_SHAPE* self)
{
   T_R2D_ELLIPSE *r;
   r=(T_R2D_ELLIPSE *)self;

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

void r2d_draw_ellipse_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_ELLIPSE *r;
   r=(T_R2D_ELLIPSE *)self;
   r2d_draw_ellipse(gc,r->ul_x,r->ul_y,r->br_x,r->br_y);
}

void r2d_fill_ellipse_shape(T_R2D_SHAPE* self,T_R2D_GC_PTR gc)
{
   T_R2D_ELLIPSE *r;
   r=(T_R2D_ELLIPSE *)self;
   r2d_fill_ellipse(gc,r->ul_x,r->ul_y,r->br_x,r->br_y);
}

T_R2D_SHAPE_PTR r2d_new_ellipse(T_RVF_MB_ID bank,INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y)
{
  T_R2D_ELLIPSE *r;
  R2D_MALLOC(bank,T_R2D_ELLIPSE,sizeof(T_R2D_ELLIPSE),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->p_r2d_class=&r2d_class_ellipse;
  } else r=NULL;
  return(r);