r2d.c

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

                  r2d_convert_foreground_color(gc,gc->foreground_color);
                  r2d_convert_background_color(gc,gc->background_color);
				}
			  } else // cannot create backround dithered matrix
			  {
                r2d_release_shape(gc->p_clipping_shape);
				r2d_release_shape(gc->p_s_clipping_shape);
                r2d_release_framebuffer(gc->p_frame_buffer);
			    r2d_release_framebuffer(r2d_g_default_font_framebuffer);
                R2D_FREE(((T_R2D_GC *)gc)->p_foreground_dithered_cache);
				R2D_FREE(gc);
                gc=NULL;
			  }
		} else // Cannot create foreground dithered matrix
		{
          r2d_release_shape(gc->p_clipping_shape);
		  r2d_release_shape(gc->p_s_clipping_shape);
          r2d_release_framebuffer(gc->p_frame_buffer);
		  r2d_release_framebuffer(r2d_g_default_font_framebuffer);
		  R2D_FREE(gc);
          gc=NULL;
		}
	  } else // Cannot create clipping shape
	  {
		  R2D_FREE(gc);
		  gc=NULL;
	  }
   }
   else 
   gc=NULL;
   return(gc);
}

T_R2D_GC_PTR r2d_new_lcd_context(T_RVF_MB_ID bank)
{
   T_R2D_GC *gc;
   T_R2D_GC_PTR result;

   result=r2d_new_context(bank,r2d_g_framebuffer);
   r2d_release_framebuffer(r2d_g_framebuffer);
   return (result);
}

void r2d_release_context(T_R2D_GC_PTR gc)
{
    if (gc)
    {
      if (R2D_REFCOUNT(gc)==1) 
      {
		  // framebuffer release since it is no more used
        r2d_release_framebuffer(((T_R2D_GC *)gc)->font_frame_buffer);
        r2d_release_shape(((T_R2D_GC *)gc)->p_clipping_shape);
	    r2d_release_shape(((T_R2D_GC *)gc)->p_s_clipping_shape);
        r2d_release_framebuffer(((T_R2D_GC *)gc)->p_frame_buffer);
        R2D_FREE((((T_R2D_GC *)gc)->p_foreground_dithered_cache));
        R2D_FREE((((T_R2D_GC *)gc)->p_background_dithered_cache));
      }
    }

    // Autodelete of the gc if required
    r2d_release(gc);
}

T_R2D_GC_PTR r2d_new_picture_context(T_RVF_MB_ID bank,const UINT32 *the_picture,T_R2D_FRAMEBUFFER_KIND kind)
{
   UINT32 h,v,length;
   UINT32 *p;
   T_R2D_FRAMEBUFFER *buf;
   T_R2D_GC_PTR result;
   T_RVF_RET err;

   p=((UINT32*)the_picture)+3;

   h=the_picture[0];
   v=the_picture[1];
   length=the_picture[3];

   rvf_get_buf(bank, sizeof(T_R2D_FRAMEBUFFER), 
   (T_RVF_BUFFER**)&buf);

   if (buf != NULL)
   {

	   
			
           
			
			
   buf->p_memory_words=p; 
   buf->refcount=-1; // Emulate infinite refcount
   buf->kind=kind; 
   buf->p_frame_buffer_end=p+length;
   buf->width=h; 
   buf->height=v; 

   R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),buf->mutex);
   if (buf->mutex!=NULL)
   {
		err=rvf_initialize_mutex(buf->mutex);
		if (err!=RVF_OK)
		{
				 R2D_FREE(buf->mutex);
				 R2D_FREE(buf);
				 buf=NULL;
				 return(buf);
		}
	}
	else
	{
		R2D_FREE(buf);
		buf=NULL;
		return(buf);
	}

   result=r2d_new_context(bank,(T_R2D_FRAMEBUFFER_PTR)buf);
   r2d_release_framebuffer(buf);

   return(result);
   } else return(NULL);
}

void r2d_new_draw_bmp(T_R2D_GC_PTR gc,int px, int py, int sx, int sy,
                    int ix, char *bm, T_R2D_DRAWING_MODE mode)
{
	UINT8 i ;
	UINT16  *bmpbuffer=(UINT16 *)bm, value ,num ;

	int  lcdl,lcdc,lcdcurrent,bmpcurrent;
	UINT32  pixel_value;

	while(g_test)
     	rvf_delay(1);
	num  = sx * sy;
	
	switch(mode){
		case R2D_INVERT:
			for(i = 0; i < num /2; i ++){
				value = *(bmpbuffer + i);
				*(bmpbuffer + i) = *(bmpbuffer + num -i +1);
				*(bmpbuffer + num -i +1) = value;
			}
			break;
		case R2D_OR_MODE:
		case R2D_AND_MODE:
		case R2D_XOR_MODE:
			  for(lcdl=0;(lcdl<sy)&&((lcdl+py)<R2D_HEIGHT);lcdl++){ 

				bmpcurrent=sx*lcdl;

				for(lcdc=0;(lcdc<sx)&&((lcdc+px)<R2D_WIDTH);lcdc++)
				{

				pixel_value=bmpbuffer[bmpcurrent+lcdc];


				#if (R2D_REFRESH == R2D_VERTICAL)   //R2D_REFRESH == R2D_HORIZONTAL
				  //IND_r2d_write_lcd_pixel(gc,px+lcdc,lcdl+py,pixel_value, mode);
				  r2d_draw_lcd_pixel(gc,px+lcdc,lcdl+py,pixel_value, mode);
				  #else
				  //IND_r2d_write_lcd_pixel(gc,lcdl+py,px+lcdc,pixel_value, mode);
				  r2d_draw_lcd_pixel(gc,lcdl+py,px+lcdc,pixel_value, mode);
				#endif

				 }
			}

/* zhq, 2004/08/05, add this for use use block fresh in r2d_refresh. */
			r2d_update_region(px,py,(((px+sx)>R2D_WIDTH) ? R2D_WIDTH : (px+sx)), ((py+sy)>R2D_HEIGHT ? R2D_HEIGHT : (py+sy)));
			  
			r2d_check_and_send_event(gc);
			return ;
		
		default:
			break;
	}

	r2d_draw_lcd_rect(gc,px,py,sx,sy,bmpbuffer);

/* zhq, 2004/08/05, add this for use use block fresh in r2d_refresh. */
	r2d_update_region(px,py,(((px+sx)>R2D_WIDTH) ? R2D_WIDTH : (px+sx)), ((py+sy)>R2D_HEIGHT ? R2D_HEIGHT : (py+sy)));

	r2d_check_and_send_event(gc);
}

/// for a test ,we will try to write into lcd buffer directly in the future
void r2d_draw_bmp(T_R2D_GC_PTR gc,int px, int py, int sx, int sy,
                    int ix, char *bm, T_R2D_DRAWING_MODE mode)
{
   int  lcdl,lcdc,lcdcurrent,bmpcurrent;
   int temp1, temp2;
   UINT32  pixel_value;
   UINT16  *bmpbuffer=(UINT16 *)bm;

//zhangzg 07/16/2002  if statement here is used to display a bmp to be inverted
  if(mode & R2D_INVERT)
  	{
  		mode = mode & (~R2D_INVERT); //recover the mode
  		if((py+sy)>=R2D_HEIGHT){
	    		if(py<=R2D_HEIGHT)
	        		temp1 = R2D_HEIGHT-py-1; //get the last line
	        	else
	        		temp1 = 0;
  		}
  		else
  			temp1 = sy-1; //get the last line

  		if((px+sx)>=R2D_WIDTH){
  			if(px<=R2D_WIDTH)
  				temp2 = R2D_WIDTH-px-1; //get the last colomn
  			else
  				temp2 = 0;
  		}
  		else
  			temp2 = sx-1;  //get the last colomn
  		
  		for(lcdl=temp1; lcdl>=0; lcdl--){
  			bmpcurrent = sx*lcdl;
  			for(lcdc=temp2; lcdc>=0; lcdc--){
				pixel_value=bmpbuffer[bmpcurrent+lcdc];  
                            #if (R2D_REFRESH == R2D_VERTICAL)
				IND_r2d_write_lcd_pixel(gc,px+(temp2-lcdc),(temp1-lcdl)+py,pixel_value, mode);
                            #else
				IND_r2d_write_lcd_pixel(gc,(temp1-lcdl)+py,px+(temp2-lcdc),pixel_value, mode);
                            #endif                
  			}
  		}
  	}
  	
else
{
  for(lcdl=0;(lcdl<sy)&&((lcdl+py)<R2D_HEIGHT);lcdl++)
  { 

      bmpcurrent=sx*lcdl;

   for(lcdc=0;(lcdc<sx)&&((lcdc+px)<R2D_WIDTH);lcdc++)
     {
      
      pixel_value=bmpbuffer[bmpcurrent+lcdc];


      #if (R2D_REFRESH == R2D_VERTICAL)   //R2D_REFRESH == R2D_HORIZONTAL
    	  IND_r2d_write_lcd_pixel(gc,px+lcdc,lcdl+py,pixel_value, mode);
          #else
          IND_r2d_write_lcd_pixel(gc,lcdl+py,px+lcdc,pixel_value, mode);
    #endif
    
  	 }
  	}
}
   r2d_check_and_send_event(gc);

}


UINT16          r2d_get_width(T_R2D_GC_PTR gc)
{
  return(((T_R2D_FRAMEBUFFER*)((T_R2D_GC *)gc)->p_frame_buffer)->width);
}

UINT16          r2d_get_height(T_R2D_GC_PTR gc)
{
  return(((T_R2D_FRAMEBUFFER*)((T_R2D_GC *)gc)->p_frame_buffer)->height);
}

void           r2d_erase(T_R2D_GC_PTR gc)
{
   UINT32 *p;
   INT16 x,y;
   T_R2D_ARGB_COLOR col;

   while(g_test)
     	rvf_delay(1);
   r2d_get_context_origin(gc,&x,&y);

   col=r2d_get_background_color(gc);
   r2d_set_background_color(gc,r2d_get_standard_argb_color(R2D_WHITE));

   
   r2d_fill_rectangle(gc,x-1,y-1,x+r2d_get_width(gc),y+r2d_get_height(gc));
   r2d_set_background_color(gc,col);

   if (gc==r2d_g_lcd_gc)
      r2d_update_region(x,y,x+r2d_get_width(gc),y+r2d_get_height(gc));
   r2d_check_and_send_event(gc);
}

void           r2d_erase_with_background(T_R2D_GC_PTR gc,
										 INT16 a,INT16 b,
										 INT16 c,INT16 d)
{
   
   r2d_fill_rectangle(gc,a-1,b-1,c+1,d+1);
}

T_R2D_DRAWING_MODE          r2d_get_drawing_mode(T_R2D_GC_PTR gc)
{
   return(((T_R2D_GC *)gc)->drawing_mode);
}

T_R2D_ERROR           r2d_set_drawing_mode(T_R2D_GC_PTR gc,T_R2D_DRAWING_MODE the_mode)
{
  if (the_mode!=((T_R2D_GC *)gc)->drawing_mode)
  {
	  // All modes must be supported in ASM mode

	  if (r2d_get_drawing_op(gc,the_mode)!=NULL)

	  {
	      ((T_R2D_GC *)gc)->drawing_mode=the_mode;
          ((T_R2D_GC *)gc)->drawing_op=r2d_get_drawing_op(gc,the_mode);

		  return(R2D_OK);
	  }

	  else
	   return(R2D_UNKNOWN_OP);

  }
  else
	  return(R2D_OK);
  
  
}

UINT16          r2d_get_pen_size(T_R2D_GC_PTR gc)
{
   return(((T_R2D_GC *)gc)->pen_size);
}

void           r2d_set_pen_size(T_R2D_GC_PTR gc,UINT16 the_size)
{
   ((T_R2D_GC *)gc)->pen_size=the_size;
}

// H COORDINATES
void           r2d_set_context_origin(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
  INT16 dx,dy;
  T_R2D_RECTANGLE *ra,*rb;

  dx=x-((T_R2D_GC *)gc)->org_x;
  dy=y-((T_R2D_GC *)gc)->org_y;

  ((T_R2D_GC *)gc)->org_x=x;
  ((T_R2D_GC *)gc)->org_y=y;

  r2d_translate_shape(((T_R2D_GC *)gc)->p_clipping_shape,dx,dy);


  ra=r2d_new_rectangle(r2d_mb_id,0,0,0,0);
  rb=r2d_s_level(gc,ra);

  if (rb)
  {
    ((T_R2D_GC *)gc)->s_org_x=rb->ul_x;
    ((T_R2D_GC *)gc)->s_org_y=rb->ul_y;
  }

  r2d_release_shape(ra);
  r2d_release_shape(rb);
  

 // No translation of p_s_clipping_shape which is in S coordinates.
  // Only H coordinates are impacted by the context origin
}

// H COORDINATES
void           r2d_get_context_origin(T_R2D_GC_PTR gc,INT16 *x,INT16 *y)
{
  *x=((T_R2D_GC *)gc)->org_x;
  *y=((T_R2D_GC *)gc)->org_y;
}

// H COORDINATES
void           r2d_local_to_global(T_R2D_GC_PTR gc,INT16 *x,INT16 *y)
{
  *x-=((T_R2D_GC *)gc)->org_x;
  *y-=((T_R2D_GC *)gc)->org_y;
}

// H coordinates
void           r2d_get_pen_pos(T_R2D_GC_PTR gc,INT16 *x,INT16 *y)
{
  *x=((T_R2D_GC *)gc)->pen_x;
  *y=((T_R2D_GC *)gc)->pen_y;
}

BOOLEAN        r2d_dash_enabled(T_R2D_GC_PTR gc)
{
   return(((T_R2D_GC *)gc)->dash);
}

void           r2d_set_dash_state(T_R2D_GC_PTR gc,BOOLEAN enabled)
{
   ((T_R2D_GC *)gc)->dash=enabled;
}

static void r2d_change_font(T_R2D_GC_PTR gc,T_R2D_FONT_DESCRIPTION *desc)
{
   r2d_retain(desc->framebuffer);
   r2d_release_framebuffer(((T_R2D_GC *)gc)->font_frame_buffer);
   ((T_R2D_GC *)gc)->font_frame_buffer=desc->framebuffer;

   ((T_R2D_GC *)gc)->font_metrics=desc->metrics;
   ((T_R2D_GC *)gc)->font_table=desc->table;
}

static T_R2D_FONT_DESCRIPTION *r2d_get_desc(T_R2D_GC_PTR gc)
{
    INT16 f;
	INT16 s;
	INT16 t;
	T_R2D_FONT_DESCRIPTION *p;
	INT16 temp;

	p=r2d_g_font_configuration;

	f=r2d_get_text_face(gc)-1;
    s=r2d_get_text_size(gc)-1;
    t=r2d_get_text_style(gc) & (R2D_BOLD | R2D_ITALIC);

	t=t-(t>>1);

	temp=(f<<2) + (f<<3) + (s<<2) + t;
	p=r2d_g_font_configuration+(temp);

	return(p);
}

void           r2d_set_text_face(T_R2D_GC_PTR gc,T_R2D_TEXT_FACE the_face)
{
  ((T_R2D_GC *)gc)->text_face=the_face;

  r2d_change_font(gc,r2d_get_desc(gc));

}

T_R2D_TEXT_FACE r2d_get_text_face(T_R2D_GC_PTR gc)
{
  return(((T_R2D_GC *)gc)->text_face);
}


void           r2d_set_text_style(T_R2D_GC_PTR gc,T_R2D_TEXT_STYLE the_style)
{
  T_R2D_FONT_DESCRIPTION *desc;

  ((T_R2D_GC *)gc)->text_style=the_style;

  // Clear italic bit;
  the_style=the_style & (~R2D_ITALIC);
  
  // Clear bold bit if desc for Bold is not NULL
  desc=r2d_get_desc(gc);
  if (!desc->compute_bold)
     the_style=the_style & (~R2D_BOLD);
  
  
  ((T_R2D_GC *)gc)->internal_text_style=the_style;

  r2d_change_font(gc,r2d_get_desc(gc));
  
}

T_R2D_TEXT_STYLE r2d_get_text_style(T_R2D_GC_PTR gc)
{
 return(((T_R2D_GC *)gc)->text_style);
}


void           r2d_set_text_size(T_R2D_GC_PTR gc,T_R2D_TEXT_SIZE the_size)
{
  ((T_R2D_GC *)gc)->text_size=the_size;
  r2d_change_font(gc,r2d_get_desc(gc));
}

T_R2D_TEXT_SIZE r2d_get_text_size(T_R2D_GC_PTR gc)
{
  return(((T_R2D_GC *)gc)->text_size);
}

T_R2D_ERROR r2d_context_lock(T_R2D_GC_PTR gc)
{
	T_RVF_RET err;
	err=RVF_OK;
	err=rvf_lock_mutex(((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->mutex);
	if (err!=RVF_OK)
		return(R2D_LOCK_ERROR);
	else
	    return(R2D_OK);
}

T_R2D_ERROR r2d_context_unlock(T_R2D_GC_PTR gc)
{
	T_RVF_RET err;
	err=RVF_OK;
	err=rvf_unlock_mutex(((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->mutex);
	if (err!=RVF_OK)
		return(R2D_UNLOCK_ERROR);
	else
	    return(R2D_OK);
}

// Return the a pointer to the memory area containing
// pixels for the graphic context gc
//
UINT32*        r2d_get_pixmap(T_R2D_GC_PTR gc)
{
	T_R2D_GC *src;
	T_R2D_FRAMEBUFFER *src_f;
	UINT32 *ps;

    src=(T_R2D_GC*)gc;
	src_f=(T_R2D_FRAMEBUFFER*)(src->p_frame_buffer);
    ps=src_f->p_memory_words;

	return(ps);
}

// Force the flushing of LCD framebuffer to display its
// content 
void r2d_flush(void)
{
	r2d_update_region(0,
		  0,
		  R2D_WIDTH,
		  R2D_HEIGHT);
    r2d_check_and_send_event(r2d_g_lcd_gc);
}

void    r2d_disable_refresh(void) 
{
	rvf_lock_mutex(r2d_g_global_mutex);
	r2d_g_refresh_disabled++;
	rvf_unlock_mutex(r2d_g_global_mutex);
}

void r2d_enable_refresh(void)