/**
                                                                          
  @file       r2d.c   
  
  @author     Christophe Favergeon

  @version    0.5
                                                                          
  Function    Riviera 2D system implementation
              (higher software layer)                       
     
*/

/*
  Date        Modification                                                 
  ------------------------                                                 
  06/12/2001    Create    
  10/18/2001    Version 0.5 for first integration with Riviera database
 **************************************************************************
  History       
                                                                          
  Apr-06-2005 MMI-SPR-29655 - xreddymn
  Added function r2d_flush_region to allow flushing of portions 
  of framebuffer to the display

*/

 
#include "rv/general.h"
#include "rvf/rvf_api.h"
#include "r2d/r2d_config.h"
#include "r2d/r2d.h"
#include "r2d/r2d_i.h"
#include "r2d/r2d_independance_layer.h"
#include "r2d/r2d_convertion_table.h"
#include "r2d/r2d_env.h"
#include "rvm/rvm_use_id_list.h"
#include <string.h>

#include "r2d_cos.c"


#ifdef _WINDOWS
  #pragma warning(disable:4761) // integral size mismatch in argument; conversion supplied
#endif


/***************************************

     IMPORTANT INFORMATION

***************************************/

/*

Clipping is done on original coordinates.
Then those coordinates are modified to take into account a possible
mirror symetry of the LCD. 
Then the scanning algorithm is applied on those transformed and clipped
coordinates. It assumes a vertical scanning (column per column).
If it is not the case. The high level coordinates (x,y) are swapped
after clipping and mirroring. The scanning is done on the swapped coordinates
so that coulmns are mapped to lines.

Subroutine's comment use following rule:
H -> High level user coordinates
L -> LCD coordinates (mirroring or not and local_to_global applied)
S -> Scanning coordinates (vertical or horizontal)
*/

/***************************************

     CONSTANTS

***************************************/

// Used for char drawing algorithm with unicode
typedef enum K_R2D_CHAR_DRAWING_MODE
{
R2D_COMBINING_CHAR=1
} T_R2D_CHAR_DRAWING_MODE;

// Used for internal drawing function
typedef enum K_R2D_TEXT_DRAWING_SETTINGS
{
  R2D_TEXT_DRAW=1
} T_R2D_TEXT_DRAWING_SETTINGS;





/***************************************

     REFRESH TASK RELATED GLOBALS

***************************************/

extern INT16 r2d_update_ul_x,r2d_update_ul_y,r2d_update_br_x,r2d_update_br_y;

/***************************************

     STATIC INTERNAL FUNCTIONS
	 AND GLOBALS

***************************************/


#define IND_r2d_write_lcd_line r2d_write_lcd_line
#define IND_r2d_write_lcd_pixel r2d_write_lcd_pixel
#define IND_r2d_blit_lcd_to_lcd r2d_blit_lcd_to_lcd
#define IND_r2d_blit_lcd_to_color r2d_blit_lcd_to_color
#define IND_r2d_blit_color_to_lcd r2d_blit_color_to_lcd
#define IND_r2d_blit_color_to_color r2d_blit_color_to_color
#define IND_r2d_get_color_pixel_value r2d_get_color_pixel_value

static T_R2D_GC_PTR r2d_new_font_buffer_context(T_RVF_MB_ID bank,
												T_R2D_FRAMEBUFFER_KIND kind,
												UINT16 max_width,
												UINT16 ascent);
static T_R2D_FONT_CACHE_FRAMEBUFFER* r2d_new_font_framebuffer(T_RVF_MB_ID bank,
															  T_R2D_FRAMEBUFFER_KIND the_kind,UINT16 width, UINT16 height);
static T_R2D_SHAPE_PTR r2d_s_level(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR self);
static void r2d_mirror_rectangle(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR rectangle);
static void r2d_mirror_clip_rectangle(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR rectangle);
static void r2d_diagonal_mirror(T_R2D_SHAPE_PTR rectangle);

static void r2d_update_region(T_R2D_GC *gc,INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y);

void r2d_translate_shape(T_R2D_SHAPE_PTR self,INT16 dx,INT16 dy);

// Used for pen_size != 1. It computes the bounding rect and calls
// fillrectangle
static void r2d_s_fill_point(T_R2D_GC_PTR gc,INT16 x,INT16 y,INT16 pen_size);

static void           r2d_df_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,BOOLEAN background);
static void           r2d_s_fill_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,BOOLEAN background);



#define R2D_SQUARE_P(x) (x*x)
#define R2D_SWAP(x,y) tmp=x; x=y; y=tmp
#define SQRT2 0x16A09
#define PI 0x3243F

////////////////////////////////////////
//
// Utility functions
//

// L COORDINATES
void r2d_update_region(T_R2D_GC* gc,INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y)
{

	INT16 tmp;

	rvf_lock_mutex(r2d_g_global_mutex);

	if (ul_x>br_x)
	{
		tmp=ul_x;
		ul_x=br_x;
		br_x=tmp;
	}

	if (ul_y>br_y)
	{
		tmp=ul_y;
		ul_y=br_y;
		br_y=tmp;
	}

	if (gc)
	{
	  if (ul_x<((T_R2D_RECT*)(gc->p_clipping_shape))->ul_x-gc->org_x)
         ul_x=((T_R2D_RECT*)(gc->p_clipping_shape))->ul_x-gc->org_x;
      if (ul_y<((T_R2D_RECT*)(gc->p_clipping_shape))->ul_y-gc->org_y)
         ul_y=((T_R2D_RECT*)(gc->p_clipping_shape))->ul_y-gc->org_y;
      if (br_x>=((T_R2D_RECT*)(gc->p_clipping_shape))->br_x-1-gc->org_x)
         br_x=((T_R2D_RECT*)(gc->p_clipping_shape))->br_x-1-gc->org_x;
      if (br_y>=((T_R2D_RECT*)(gc->p_clipping_shape))->br_y-1-gc->org_y)
         br_y=((T_R2D_RECT*)(gc->p_clipping_shape))->br_y-1-gc->org_y;
    }

	if (ul_x < r2d_update_ul_x)
		r2d_update_ul_x=ul_x;
    if (ul_y < r2d_update_ul_y)
		r2d_update_ul_y=ul_y;
	if (br_x > r2d_update_br_x)
		r2d_update_br_x=br_x;
	if (br_y > r2d_update_br_y)
		r2d_update_br_y=br_y;

	
	  if (r2d_update_ul_x<0)
         r2d_update_ul_x=0;
      if (r2d_update_ul_y<0)
         r2d_update_ul_y=0;
      if (r2d_update_br_x>=R2D_WIDTH)
         r2d_update_br_x=R2D_WIDTH-1;
      if (r2d_update_br_y>=R2D_HEIGHT)
         r2d_update_br_y=R2D_HEIGHT-1;
	
	
	rvf_unlock_mutex(r2d_g_global_mutex);
}


void r2d_check_and_send_event(T_R2D_GC_PTR gc)
{
	  // If routine has drawn into the LCD framebuffer
	  // then refresh may be required
	  // If LCD framebuffer ONLY
	  if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==0)
	  {
	  if ((r2d_g_event_was_sent==FALSE) && (r2d_g_refresh_disabled==0))
      {
		  //rvf_send_trace("R2D SEND EVENT",strlen("R2D SEND EVENT"), NULL_PARAM, 
			   //RV_TRACE_LEVEL_DEBUG_HIGH, TRACE_XXX );
		     r2d_g_event_was_sent=TRUE;
			 rvf_send_event( (UINT8)(r2d_addr_id & 0xFF), EVENT_MASK(RVF_APPL_EVT_0) );
	  }
	  }
}

// WILL HAVE TO BE IMPROVED

INT32 r2d_fixed_division(INT32 a,INT32 b)
{
    INT16 k;
    UINT32 q,nb;
    INT16 right_shift=0;
    INT16 sign=0;

	// Convert to positive values
    if ((b<0) && (a<0))
	{
		b=-b;
		a=-a;
	}
	if ((b<0) && (a>=0))
	{
		b=-b;
		sign=1;
	}
	if ((a<0) && (b>=0))
	{
		a=-a;
		sign=1;
	}


    // Normalize b between in [0.5,1[
    

    nb=b;

    if (nb>=0x10000)
    {
      //printf("%08X/%08X\n",a,nb);
      while(((nb>>16)&0x0FFFF)!=0)
      {
         nb>>=1;
         right_shift++;
         //printf("%08X\n",nb);
      }
    } else if (nb<0x8000)
    {
      while((nb&0x8000)==0)
      {
         nb<<=1;
         right_shift--;
         //printf("%08X\n",nb);
      }
    }
    //printf("right_shift=%d\n",right_shift);
    if (nb==0x8000)
    {
      //printf("nb=0x8000, return %08X\n",((a>>right_shift)<<1));
      if (sign)
        return (-((a>>right_shift)<<1));
      else
        return (((a>>right_shift)<<1));
    }


    

    // Newton method used to compute 1/nb with
    // q=q(2-nb * q)

    // Which first choice for q and which accuracies for intermediate
    // computations ?

    
    // nb being in ]0.5,1[ one must has q in ]0.5, 3[
    // And one must check that the function is contracting
    // Derivative is nul for q*nb = 1. Below, sign of
    // derivatuve (relatively to q) is positive if a<1 and
    // the derivative is between 2 and 0
    // <1 is got for q>1/(2 nb) and q must be < 1/nb
    // One can take q=1 as starting value. It solves
    // for the bounds except for nb=1 or nb=0.5

    // if q in ]1/2nb, 1/nb[ one can check that qnew
    // will at most reach 3/2nb at next iteration and then will
    // fall back into the intervall
    // So, one needs to represents values up to 3 for q
    // and 2 bits are required for integer part
    
    // So, q is 2.16, nb is 0.16
    // q*nb is 2.32 which cannot be represented and one needs
    // to shift value by 1 bit
    // nb will be 0.15 and q 2.15 sor nb*q is 2.30
    // It must be multiplied by a format 2.16
    // so both intermediate result must be shifted to
    // 2.15 (1 for q and 15 for np*q)
    
    

    q=(1<<16);
    //printf("-- q=%08X\n",q);

    
    for(k=0;k<5;k++)
    {
       q=((q>>1) * ((2 << 15) - (((nb>>1) * (q>>1))  >> 15))) >> 14;
       //printf("-- q=%08X\n",q);
    }
    
    // a is known to be an integer and q is know to be less than 1
    // so a 64 bits product is not required

    //printf("a=%08X, q=%08X\n",a,q);

    q>>=right_shift;

    q=((a>>16)*q) ;


    //printf("right_shift=%d, q=%08X\n",right_shift,q);

    if (sign)
     return(-((INT32)q));
    else
     return(q);

    
}

////////////////////////////////////////
//
// Texture
//

T_R2D_FREE_TEXTURE_PTR r2d_new_free_texture(T_RVF_MB_ID bank,INT16 size,T_R2D_ARGB_COLOR *pattern)
{
   T_R2D_FREE_TEXTURE *t;

   R2D_MALLOC(bank,T_R2D_FREE_TEXTURE,sizeof(T_R2D_FREE_TEXTURE),t);

   if (t)
   {
	   t->refcount=1;
	   t->size=size;
	   t->pattern=pattern;
   }

   return(t);
}

T_R2D_FREE_TEXTURE_PTR r2d_new_const_free_texture(T_RVF_MB_ID bank,INT16 size,T_R2D_ARGB_COLOR *pattern)
{
   T_R2D_FREE_TEXTURE *t;

   R2D_MALLOC(bank,T_R2D_FREE_TEXTURE,sizeof(T_R2D_FREE_TEXTURE),t);

   if (t)
   {
	   t->refcount=-1;
	   t->size=size;
	   t->pattern=pattern;
   }

   return(t);
}

void              r2d_release_free_texture(T_R2D_FREE_TEXTURE_PTR texture)
{
	if (texture)
    {
      // Remove the array of words if needed
      // (refcount must be 1 else the array should not be deleted)
      if (R2D_REFCOUNT(texture)==1) 
	  {
		if (((T_R2D_FREE_TEXTURE*)texture)->pattern)
          R2D_FREE(((T_R2D_FREE_TEXTURE*)texture)->pattern);
	  }
    }
    // Autorelease
    r2d_release(texture);
}

T_R2D_ANCHORED_TEXTURE_PTR r2d_new_anchored_texture(T_RVF_MB_ID bank,T_R2D_GC_PTR gc,T_R2D_FREE_TEXTURE_PTR texture)
{

  INT16 length;
  T_R2D_FREE_TEXTURE *ft;
  T_R2D_ANCHORED_TEXTURE *at;
  INT16 i,j,x,y,ni,nj,pos;
  UINT32 *p;

		 T_R2D_ARGB_COLOR b;

   // If a new texture is installed,
   // one must recompute p_background
   if (texture==NULL)
	  goto erroranchored;

   
     
   ft=(T_R2D_FREE_TEXTURE *)texture;

   length=1<<(ft->size);

   R2D_MALLOC(bank,T_R2D_ANCHORED_TEXTURE,sizeof(T_R2D_ANCHORED_TEXTURE),at);

   if (at==NULL)
	   goto erroranchored;

   at->refcount=1;

   at->size=ft->size;

   R2D_MALLOC(bank,UINT32,sizeof(UINT32)*length*length,at->pattern);

   if (at->pattern==NULL)
   {
	   R2D_FREE(at);
	   goto erroranchored;
   }
     
	 
   p=at->pattern;
   b=r2d_get_background_color(gc);

   if (((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)gc)->p_frame_buffer))->kind==R2D_FULL_KIND)
   {
			 x=0;
			 y=0;
			 for(i=0;i<length;i++) // Horizontal
				 for(j=0;j<length;j++) // Vertical
			 {
			   r2d_convert_background_color_color(gc,ft->pattern[i*length+j]);

               #if (R2D_REFRESH == R2D_VERTICAL)
                 #ifdef R2D_MIRRORED_X
			       ni=(length-1)-i;
                 #else
				   ni=i;
                 #endif

				 #ifdef R2D_MIRRORED_Y
			       nj=(length-1)-j;
                 #else
				   nj=j;
                 #endif
                 p[ni*length+nj]=((T_R2D_GC*)gc)->background_pixel_value;
               #else
				 #ifdef R2D_MIRRORED_X
			       nj=(length-1)-j;
                 #else
				   nj=j;
                 #endif

				 #ifdef R2D_MIRRORED_Y
			       ni=(length-1)-i;
                 #else
				   ni=i;
                 #endif

				 p[nj*length+ni]=((T_R2D_GC*)gc)->background_pixel_value;
               #endif
               
			 }
	}
	else
	{
			 for(i=0;i<length;i++)
				 for(j=0;j<length;j++)
			 {
			  r2d_convert_background_color(gc,ft->pattern[i*length+j]);
			  #if (R2D_REFRESH == R2D_VERTICAL)
                 #ifdef R2D_MIRRORED_X
			       ni=(length-1)-i;
                 #else
				   ni=i;
                 #endif

				 #ifdef R2D_MIRRORED_Y
			       nj=(length-1)-j;
                 #else
				   nj=j;
                 #endif
                 pos=ni*length+nj;
               #else
				 #ifdef R2D_MIRRORED_X
			       nj=(length-1)-j;
                 #else
				   nj=j;
                 #endif

				 #ifdef R2D_MIRRORED_Y
			       ni=(length-1)-i;
                 #else
				   ni=i;
                 #endif

				 pos=nj*length+ni;
               #endif
			  #if (R2D_DITHERING == R2D_OFF)
                  p[pos]=((T_R2D_GC*)gc)->background_pixel_value;
              #else
				  p[pos]=r2d_get_dithering_matrix_entry(((T_R2D_GC*)gc)->p_background_dithered_cache,x,y);      
              #endif

              #if (R2D_REFRESH == R2D_VERTICAL)
			    y++;
			    if (y==length)
				{
				  y=0;
				  x++;
				}
              #else
				x++;
			    if (x==length)
				{
				  x=0;
				  y++;
				}
              #endif
			 }
	}
		 // Force change
	r2d_set_background_color(gc,b^1);
    r2d_set_background_color(gc,b);
		 
   return((T_R2D_ANCHORED_TEXTURE_PTR)at);
erroranchored: return(NULL);
}

void              r2d_release_anchored_texture(T_R2D_ANCHORED_TEXTURE_PTR texture)
{
	if (texture)
    {
      // Remove the array of words if needed
      // (refcount must be 1 else the array should not be deleted)
      if (R2D_REFCOUNT(texture)==1) 
	  {
		if (((T_R2D_ANCHORED_TEXTURE*)texture)->pattern)
          R2D_FREE(((T_R2D_ANCHORED_TEXTURE*)texture)->pattern);
	  }
    }
    // Autorelease
    r2d_release(texture);
}


////////////////////////////////////////
//
// Framebuffer
//

UINT32 r2d_get_framebuffer_size(T_R2D_FRAMEBUFFER_KIND the_kind,UINT16 width, UINT16 height)
{
	UINT32 t;
	UINT32 length;

	t=0;

	
			

	t+=sizeof(T_R2D_FRAMEBUFFER);
		
	switch(the_kind) 
	{
       case R2D_LCD_KIND:
		    #if (R2D_REFRESH==R2D_VERTICAL)
              // Column is contiguous in memory
              length=width*R2D_ALIGNED_MWLENGTH(height);
              t+=((length+1)<<R2D_LONGSIZE_FACTOR);
            #else
			  length=height*R2D_ALIGNED_MWLENGTH(width);
              t+=((length+1)<<R2D_LONGSIZE_FACTOR);
            #endif
	   break;
	   default:
			  length=width*height;
              t+=((length+1)<<R2D_LONGSIZE_FACTOR);
	   break;
	}

	t+=sizeof(T_RVF_MUTEX);
	

	return(t);
}

UINT32 r2d_get_gc_size(void)
{
	UINT32 t;

	t=0;

	
	t+=sizeof(T_R2D_GC);
	t+=sizeof(T_R2D_RECT); // clipping
	t+=sizeof(T_R2D_RECT); // s_clipping
	t+=sizeof(UINT32)*4; // foreground dithering cache
	t+=sizeof(UINT32)*4; // backround dithering cache
	

	return(t);
}


T_R2D_FRAMEBUFFER_PTR r2d_new_framebuffer(T_RVF_MB_ID bank,T_R2D_FRAMEBUFFER_KIND the_kind,UINT16 width, UINT16 height)
{
   UINT32 length;
   T_R2D_FRAMEBUFFER *p;
//   UINT32 *elem;
   T_RVF_RET err;

   R2D_MALLOC(bank,T_R2D_FRAMEBUFFER,sizeof(T_R2D_FRAMEBUFFER),p);

   if (p)
   {
     switch(the_kind) 
     {
        case R2D_LCD_KIND:
          #if (R2D_REFRESH==R2D_VERTICAL)
            // Column is contiguous in memory
            length=width*R2D_ALIGNED_MWLENGTH(height);
            R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
			if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
			p->refcount=1;
            p->kind=R2D_LCD_KIND;
            p->p_frame_buffer_end=p->p_memory_words+length;
            p->width=width;
            p->height=height;
			R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
			
         #else
             // Line is contiguous in memory
             length=height*R2D_ALIGNED_MWLENGTH(width);
             R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
             if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
			 p->refcount=1;
             p->kind=R2D_LCD_KIND;
             p->p_frame_buffer_end=p->p_memory_words+length;
             p->width=width;
             p->height=height;
			 R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
         #endif
        break;
        default:
            length=width*height;
            R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
            if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
			p->refcount=1;
            p->kind=R2D_FULL_KIND;
            p->p_frame_buffer_end=p->p_memory_words+length;
            p->width=width;
            p->height=height;
			R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
        break;
     }
   } else p=NULL;

   return(p);
}

static T_R2D_FONT_CACHE_FRAMEBUFFER* r2d_new_font_framebuffer(T_RVF_MB_ID bank,T_R2D_FRAMEBUFFER_KIND the_kind,UINT16 width, UINT16 height)
{
   UINT32 length;
   T_R2D_FONT_CACHE_FRAMEBUFFER *p;
//   UINT32 *elem;
   T_RVF_RET err;

   R2D_MALLOC(bank,T_R2D_FONT_CACHE_FRAMEBUFFER,sizeof(T_R2D_FONT_CACHE_FRAMEBUFFER),p);

   if (p)
   {
     switch(the_kind) 
     {
        case R2D_LCD_KIND:
          #if (R2D_REFRESH==R2D_VERTICAL)
            // Column is contiguous in memory
            length=width*R2D_ALIGNED_MWLENGTH(height);
            R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
			if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
            p->refcount=1;
            p->kind=R2D_LCD_KIND;
            p->p_frame_buffer_end=p->p_memory_words+length;
            p->width=width;
            p->height=height;
			R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
         #else
             // Line is contiguous in memory
             length=height*R2D_ALIGNED_MWLENGTH(width);
             R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
             if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
			 p->refcount=1;
             p->kind=R2D_LCD_KIND;
             p->p_frame_buffer_end=p->p_memory_words+length;
             p->width=width;
             p->height=height;
			 R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
         #endif
        break;
        default:
            length=width*height;
            R2D_MALLOC(bank,UINT32,((length+1)<<R2D_LONGSIZE_FACTOR),p->p_memory_words);
            if (!(p->p_memory_words))
			{
		        R2D_FREE(p);
		        p=NULL;
				return(p);
			}
			p->refcount=1;
            p->kind=R2D_FULL_KIND;
            p->p_frame_buffer_end=p->p_memory_words+length;
            p->width=width;
            p->height=height;
			R2D_MALLOC(bank,T_RVF_MUTEX,sizeof(T_RVF_MUTEX),p->mutex);
		    if (p->mutex!=NULL)
			{
			  err=rvf_initialize_mutex(p->mutex);
			  if (err!=RVF_OK)
			  {
				 R2D_FREE(p->mutex);
				 R2D_FREE(p->p_memory_words);
				 R2D_FREE(p);
				 p=NULL;
				 return(p);
			  }
			}
			else
			{
				R2D_FREE(p->p_memory_words);
				R2D_FREE(p);
				p=NULL;
				return(p);
			}
        break;
     }
     
   } else p=NULL;

   return(p);
}


// Release a framebuffer
void r2d_release_framebuffer(T_R2D_FRAMEBUFFER_PTR p)
{
    if (p)
    {
      // Remove the array of words if needed
      // (refcount must be 1 else the array should not be deleted)
      if (R2D_REFCOUNT(p)==1) 
	  {
        R2D_FREE(((T_R2D_FRAMEBUFFER*)p)->p_memory_words);
		rvf_delete_mutex(((T_R2D_FRAMEBUFFER*)p)->mutex);
		R2D_FREE(((T_R2D_FRAMEBUFFER*)p)->mutex);
	  }
    }
    // Autorelease
    r2d_release(p);
}


////////////////////////////////////////
//
// Graphic context
//


static T_R2D_GC_PTR r2d_new_font_buffer_context(T_RVF_MB_ID bank,
												T_R2D_FRAMEBUFFER_KIND kind,
												UINT16 max_width,
												UINT16 ascent)
{
   T_R2D_FRAMEBUFFER_PTR cache_buffer;
   T_R2D_GC_PTR result;

   //printf("width=%d,height=%d\n",the_width,((T_R2D_FRAMEBUFFER*)font_frame_buffer)->height);

   cache_buffer=r2d_new_font_framebuffer(bank,kind,
   max_width,ascent);

   

   if (cache_buffer!=NULL)
   {
     result=r2d_new_context(bank,cache_buffer);
     r2d_release_framebuffer(cache_buffer);
     
     return(result);
   } else return(NULL);
}


T_R2D_GC_PTR   r2d_new_context(T_RVF_MB_ID bank,T_R2D_FRAMEBUFFER_PTR the_frame_buffer)
{
   T_R2D_GC *gc;

   // Allocate a new gc structure
   R2D_MALLOC(bank,T_R2D_GC,sizeof(T_R2D_GC),gc);
   if (gc)
   {
      // gc is pointing to the LCD framebuffer
      gc->p_frame_buffer=(T_R2D_FRAMEBUFFER*)the_frame_buffer;
      r2d_retain(the_frame_buffer);

      // Default initialization for a gc
	  gc->background_texture=NULL;
      gc->foreground_color=r2d_get_standard_argb_color(R2D_BLACK);
      gc->background_color=r2d_get_standard_argb_color(R2D_WHITE);
      

	  #if (R2D_REFRESH == R2D_VERTICAL)
		gc->p_s_clipping_shape=r2d_new_rectangle(bank,0,0,((T_R2D_FRAMEBUFFER*)the_frame_buffer)->width,
        ((T_R2D_FRAMEBUFFER*)the_frame_buffer)->height);

      #else
		 gc->p_s_clipping_shape=r2d_new_rectangle(bank,0,0,((T_R2D_FRAMEBUFFER*)the_frame_buffer)->height,((T_R2D_FRAMEBUFFER*)the_frame_buffer)->width);

      #endif

	  if (gc->p_s_clipping_shape==NULL)
	  {
		  r2d_release_framebuffer(the_frame_buffer);
          R2D_FREE(gc);
          gc=NULL;
		  return(NULL);
	  }

	  gc->p_clipping_shape=r2d_new_rectangle(bank,0,0,((T_R2D_FRAMEBUFFER*)the_frame_buffer)->width,
      ((T_R2D_FRAMEBUFFER*)the_frame_buffer)->height);

      
      gc->drawing_mode=R2D_COPY_MODE;
	  
	  gc->drawing_op=r2d_get_drawing_op(gc,R2D_COPY_MODE);

      gc->org_x=gc->org_y=0;
	  gc->s_org_x=gc->s_org_y=0;

      gc->pen_size=1;
      gc->dash=0;
      gc->text_face=R2D_SYSTEM;
      gc->text_style=R2D_PLAIN;
      gc->internal_text_style=R2D_PLAIN;
      gc->text_size=R2D_SMALL;
	  gc->script_mode=R2D_LEFT_TO_RIGHT;
      gc->font_frame_buffer=r2d_g_default_font_framebuffer;
      gc->font_metrics=r2d_g_default_font_metrics;
	  gc->font_table=r2d_g_default_font_table;
	  if (gc->p_clipping_shape)
	  {
        r2d_retain(r2d_g_default_font_framebuffer);
      
        // refcount set to 1 for creation
        gc->refcount=1;
        R2D_MALLOC(bank,UINT32,sizeof(UINT32)*4,gc->p_foreground_dithered_cache);
        if (gc->p_foreground_dithered_cache)
		{
            R2D_MALLOC(bank,UINT32,sizeof(UINT32)*4,gc->p_background_dithered_cache);
              if (gc->p_background_dithered_cache)
			  {
				if (((T_R2D_FRAMEBUFFER*)the_frame_buffer)->kind==R2D_FULL_KIND)
				{
				  r2d_convert_foreground_color_color(gc,gc->foreground_color);
                  r2d_convert_background_color_color(gc,gc->background_color);
				}
				else
				{
                  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[2];

   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_release_picture_context(T_R2D_GC_PTR gc)
{
    T_R2D_FRAMEBUFFER *fb_p;

    if (gc)
    {
        if (R2D_REFCOUNT(gc) == 1)
        {
            r2d_release_context(gc);
            fb_p = (T_R2D_FRAMEBUFFER *) ((T_R2D_GC *) gc)->p_frame_buffer;
            rvf_delete_mutex(fb_p->mutex);
            R2D_FREE(fb_p->mutex);
            R2D_FREE(fb_p);
        }

        r2d_release(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;

   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 (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
      r2d_update_region((T_R2D_GC*)gc,x,y,x+r2d_get_width(gc)-1,y+r2d_get_height(gc)-1);
   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(NULL,0,
		  0,
		  R2D_WIDTH-1,
		  R2D_HEIGHT-1);
    r2d_check_and_send_event(r2d_g_lcd_gc);
}

// xreddymn Apr-06-2005 MMI-SPR-29655
// Force the flushing of a portion of LCD framebuffer to display its
// content 
void r2d_flush_region(INT16 ul_x,INT16 ul_y,INT16 br_x,INT16 br_y)
{
	r2d_update_region(NULL, ul_x,
		  ul_y,
		  br_x,
		  br_y);
    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_send_trace("R2D : disable refresh\n",sizeof("R2D : disable refresh\n"), NULL_PARAM, 
	//			   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
	rvf_unlock_mutex(r2d_g_global_mutex);
}

void r2d_enable_refresh(void) 
{
	//rvf_send_trace("R2D : enable refresh\n",sizeof("R2D : enable refresh\n"), NULL_PARAM, 
	//			   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
	rvf_lock_mutex(r2d_g_global_mutex);
	r2d_g_refresh_disabled--;
    if (r2d_g_refresh_disabled==0)
	{
		//rvf_send_trace("R2D : flush\n",sizeof("R2D : flush\n"), NULL_PARAM, 
				   //RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
	  //rvf_send_trace("Enable refresh and flush",sizeof("Enable refresh and flush")-1, NULL_PARAM, 
	  //		   RV_TRACE_LEVEL_DEBUG_HIGH, R2D_USE_ID );
		// The flush will not raise a context commutation to R2D since R2D may
		// be sleeping waiting for the current refresh perio.
		// So, the event will not be processed at once. While R2D is sleeping,
		// another task may call r2d_disable_refresh and thus
		// when R2D is awaken, it will not process the event which is waiting.
		// So, finally, the display will not be refreshed.
		// To avoid this problem which occurs for a quick succession of
		// r2d_disable_refresh
		// r2d_enable_refresh
		// one should try to call them with a rate which is lower than the refresh rate
        rvf_unlock_mutex(r2d_g_global_mutex);
		//r2d_flush();
		
        r2d_check_and_send_event(r2d_g_lcd_gc);
	}
	else
	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)
{
	
//    INT16 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;
  T_R2D_ERROR err;
  err=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);
}

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)
{
  T_R2D_ARC *r;
  r=(T_R2D_ARC *)self;

	r2d_draw_arc(gc,r->start_angle,r->stop_angle,
                  r->ul_x,r->ul_y,r->br_x,r->br_y);
}

void r2d_fill_arc_shape(T_R2D_SHAPE *self,T_R2D_GC_PTR gc)
{
 T_R2D_ARC *r;
  r=(T_R2D_ARC *)self;

	r2d_fill_arc(gc,r->start_angle,r->stop_angle,
                  r->ul_x,r->ul_y,r->br_x,r->br_y);
}

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_RECT *ra;
	T_R2D_RECT *rb;
	INT16 xa,ya,xb,yb;

	ra=(T_R2D_RECT *)a;
	rb=(T_R2D_RECT *)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_RECT *r;
	   INT16 orgx,orgy;

       r=(T_R2D_RECT *)self;

	   r2d_get_context_origin(gc,&orgx,&orgy);

	   if (r->ul_x-orgx<0)
		   r->ul_x=orgx;

	   if (r->ul_y-orgy<0)
		   r->ul_y=orgy;

	   if (r->br_x-orgx>=r2d_get_width(gc))
		   r->br_x=orgx+r2d_get_width(gc);

	   if (r->br_y-orgy>=r2d_get_height(gc))
		  r->br_y=orgy+r2d_get_height(gc);

		  
       {
       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,INT32 l)
{
  UINT32 pixel_value;
  INT16 pen_size;
  BOOLEAN isLCD_format,can_draw;
  T_R2D_GC* pgc;

  can_draw=FALSE;

  if (r2d_dash_enabled(gc))
  {
	  // Q16, 0x0008000 is 8 pixels
	  if (!(l&0x00080000))
		  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_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 (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 (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
      r2d_update_region((T_R2D_GC*)gc,x,y,x,y);
#if (R2D_REFRESH == R2D_VERTICAL)
	r2d_s_draw_point(gc,x,y,0);
#else
	r2d_s_draw_point(gc,y,x,0);
#endif

	}
}

void           r2d_erase_point(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{

   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 (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
      r2d_update_region((T_R2D_GC*)gc,x,y,x,y);
   
	#if (R2D_REFRESH == R2D_VERTICAL)
	r2d_s_draw_point(gc,x,y,0);
#else
	r2d_s_draw_point(gc,y,x,0);
#endif

   r2d_set_foreground_color(gc,col);
}
   

}

// Move pen to point (x,y)
// H_COORDINATES
void           r2d_moveto(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
   ((T_R2D_GC*)gc)->pen_x=x;
   ((T_R2D_GC*)gc)->pen_y=y;
}


static BOOLEAN r2d_clipt(INT32 denom,INT32 num,INT32 *tE,INT32 *tL)
{
    INT32 t;
    
    //printf("clipt %08X %08X\n",denom,num);
    if (denom<0)
    {
       t=r2d_fixed_division(num,denom);
       //printf("denom<0 ; t=%08X\n",t);
       if (t>*tL)
         return FALSE;
       else if (t > *tE)
         *tE=t;
    }
    else if (denom>0)
    {
       t=r2d_fixed_division(num,denom);
       //printf("denom>0 ; t=%08X\n",t);
       if (t<*tE)
         return FALSE;
       else if (t < *tL)
          *tL=t;
    } else if (num<0)
      return FALSE;

     //printf("t=%08X tE=%08X tL=%08X\n",t,*tE,*tL);
     return TRUE;
}

static BOOLEAN r2d_clip_line(T_R2D_SHAPE *self,INT32 *x0,INT32 *y0,INT32 *x1, INT32 *y1)
{
	T_R2D_RECTANGLE *r;
    BOOLEAN visible=FALSE;
    INT32 dx=*x1-*x0;
    INT32 dy=*y1-*y0;

	r=(T_R2D_RECTANGLE*)self;
  
    // Can only clip against reactangular shapes
    if (self->p_r2d_class==&r2d_class_rectangle)
    {
      
      if ((dx==0) && (dy==0) && r2d_point_in_shape(self,(*x0>>16) & 0x0FFFF,(*y0>>16) & 0x0FFFF))
        visible=TRUE;
      else
      {
         INT32 tE=0;
         INT32 tL=(1<<16);


         if (r2d_clipt(dx,((r2d_get_xmax(self)-1)<<16)-*x0,&tE,&tL)==TRUE)
           if (r2d_clipt(-dx,*x0-(r2d_get_xmin(self)<<16),&tE,&tL)==TRUE)
             if (r2d_clipt(-dy,*y0-(r2d_get_ymin(self)<<16),&tE,&tL)==TRUE)
               if (r2d_clipt(dy,((r2d_get_ymax(self)-1)<<16) -*y0,&tE,&tL)==TRUE)
               {
                   visible=TRUE;

                   //printf("tE=%08X tL=%08X\n",tE,tL);
                   // 1 with fixed point representation
                   if (tL < (1<<16))
                   {
                       // dx and dy are integer
                       // tL and tE should be lower than 1
                       // So intermediate values are shifted so that
                       // the product can be done on 32 bits instead of 64 bits
                       *x1=*x0 + (tL*(dx>>16)) ;
                       *y1=*y0 + (tL*(dy>>16)) ;
                       //printf("x1=%08X y1=%08X\n",*x1,*y1);
                   }
                   if (tE > 0)
                   {
                       *x0 += (tE*(dx>>16)) ;
                       *y0 += (tE*(dy>>16)) ;
                       //printf("x0=%08X y0=%08X\n",*x0,*y0);

                   }
               }
      }
    }
    return(visible);
}

// 0.5 is rounded down because in line drawing the bottom
// point is chosen when the line is passing through the middle
// point
#define R2D_Q16INT_VALUE(x) ((x+(0x7FFF)) & 0xFFFF0000)

#define R2D_FLOOR_VALUE(x) (x & 0xFFFF0000)

// Positive times signed value
#define R2D_MULT_PN(x,y) ((((x >> 16) & 0x0FFFF)*y) + (((x & 0x0FFFF) * y) >> 16))

// draw line from pen position to point (x,y)
void           r2d_lineto(T_R2D_GC_PTR gc,INT16 x,INT16 y)
{
    // Clipping
    // Now drawing with low level function

    UINT32 pixel_value;
    INT32 P0X,P0Y,P1X,P1Y,c,cy,cx;
    INT32 current_x,current_y,tmp,tmpx,tmpy;
    INT32 dx,dy,dn,dnp,dnn;
    INT16 xincrement,yincrement,reverse;
    INT32 nx,ny;
    INT16 pen_size;
	INT32 l;
    BOOLEAN isLCD_format;
	l=0;

	

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

    pixel_value=((T_R2D_GC*)gc)->foreground_pixel_value;
    pen_size=r2d_get_pen_size(gc);

    P0X=((T_R2D_GC*)gc)->pen_x << 16;
    P0Y=((T_R2D_GC*)gc)->pen_y << 16;
    P1X=x << 16;
    P1Y=y << 16;
    //printf("\n\n(%d,%d) ; (%d,%d)\n",P0X>>16,P0Y>>16,P1X>>16,P1Y>>16);
    
// As far as possible, most datas are computed before clipping to get same accuracy
// Update pen position
    ((T_R2D_GC*)gc)->pen_x=x;
    ((T_R2D_GC*)gc)->pen_y=y;

if (r2d_clip_line((((T_R2D_GC*)gc)->p_clipping_shape),&P0X,&P0Y,&P1X,&P1Y))
{

// Local to global

	P0X-=((T_R2D_GC*)gc)->org_x << 16;
    P0Y-=((T_R2D_GC*)gc)->org_y << 16;
    P1X-=((T_R2D_GC*)gc)->org_x << 16;
    P1Y-=((T_R2D_GC*)gc)->org_y << 16;

	 
#ifdef R2D_MIRRORED_X
  P0X=((r2d_get_width(gc)-1)<<16)-P0X;
  P1X=((r2d_get_width(gc)-1)<<16)-P1X;
#endif

#ifdef R2D_MIRRORED_Y
  P0Y=((r2d_get_height(gc)-1)<<16)-P0Y;
  P1Y=((r2d_get_height(gc)-1)<<16)-P1Y;
#endif

    
    /*printf("%d %d %d %d\n",r2d_get_xmin(((T_R2D_GC*)gc)->p_clipping_shape),
    r2d_get_xmax(((T_R2D_GC*)gc)->p_clipping_shape),
    r2d_get_ymin(((T_R2D_GC*)gc)->p_clipping_shape),
    r2d_get_ymax(((T_R2D_GC*)gc)->p_clipping_shape)
   );*/

    //r2d_clip_line(&(((T_R2D_GC*)gc)->clipping_rectangle),&P0X,&P0Y,&P1X,&P1Y);
    
        //printf("(%d,%d) ; (%d,%d)\n",P0X>>16,P0Y>>16,P1X>>16,P1Y>>16);
        //printf("(%08X,%08X) ; (%08X,%08X)\n------------------\n",P0X,P0Y,P1X,P1Y);
      
      //printf("(%d,%d) ; (%d,%d)\n",P0X>>16,P0Y>>16,P1X>>16,P1Y>>16);

if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
      r2d_update_region((T_R2D_GC*)gc,P0X>>16,P0Y>>16,P1X>>16,P1Y>>16);


#if (R2D_REFRESH==R2D_VERTICAL)
    current_x=P0Y;
    current_y=P0X;
    nx=P1Y; ny=P1X;

    
#else
    current_x=P0X;
    current_y=P0Y;
    nx=P1X; ny=P1Y;
#endif

    dx=nx-current_x;
    dy=ny-current_y;
    
    yincrement=1;

    if (dx>=0)
    {
       xincrement=1;
    }
    else
    {
       xincrement=-1;
       dx=-dx;
    }

    if (dy>=0)
    {
       yincrement=1;
    }
    else
    {
       yincrement=-1;
       dy=-dy;
    }

    if (dy<=dx)
      reverse=0;
    else
    {
      reverse=1;
      tmp=dy;
      dy=dx;
      dx=tmp;
      tmp=current_y;
      current_y=current_x;
      current_x=tmp;
      tmp=ny;
      ny=nx;
      nx=tmp;
      tmp=yincrement;
      yincrement=xincrement;
      xincrement=tmp;
    }

    reverse=1-reverse;


    //printf("dx,dy,current_x,current_y,nx,ny\n%08X %08X %08X %08X %08X %08X\n",dx,dy,current_x,current_y,nx,ny);


    // Remember that when one is speaking about a move of 1 horizontally
    // one is talking about internal coordinates used by the algorithm
    // In the window it may be vertical or horizontal depending on the
    // refresh mode and on the line slope (<1 or >1)


    dn=dy - (dx >> 1)  ; // d0 = a-b/2 
    dnp=dy-dx ;
    dnn=dy;
    
    // We draw the point which is the closest to the line so we use INT
    // instead of FLOOR or CEIL
    // But, then, the drawing algorithm assumes that the first drawn point is
    // the lowest one

    // If F(P) = 0 is a parametric description of the line
    // The, when one is moving from the point of the line on the frontier
    // of the clipping rectangle to the closest
    // point with x,y integer coordinate then one needs to compute dx*cy and dy*cx
    // since it is the variation of F along that path
    tmpx=(INT32)R2D_Q16INT_VALUE(current_x);
    tmpy=(INT32)R2D_Q16INT_VALUE(current_y);
    cx = current_x - tmpx;
    cy = current_y - tmpy;


    c= -R2D_MULT_PN(dx,cy) + R2D_MULT_PN(dy,cx);
    

    //printf("cx=%08X, cy=%08X, c=%08X, dx=%08X, dy=%08X \n",cx,cy,c,dx,dy);

    // Then, one can add c to the variation due to a move of 1 horizontally
    // an a move of 1/2 vertically.
    // One finally get the value of the decision variable at the midpoint
    dn+=c;

    //printf("%08X %08X %08X %08X %08X\n",current_x,current_y,nx,ny);
    current_x=((INT32)R2D_Q16INT_VALUE(current_x)) >> 16;
    current_y=((INT32)R2D_Q16INT_VALUE(current_y)) >> 16;
    nx=((INT32)R2D_Q16INT_VALUE(nx)) >> 16;
    ny=((INT32)R2D_Q16INT_VALUE(ny)) >> 16;

    
    //printf("dx=%08X dy=%08X dn=%08X dnp=%08X dnn=%08X\n",dx,dy,dn,dnp,dnn);
    
    if (reverse)
    {
        r2d_s_draw_point(gc,current_y,current_x,l);
        
    }
    else
    {
        r2d_s_draw_point(gc,current_x,current_y,l);
    }
    
    

    while(current_x != nx)
    {

      if (dn>0)
      {
        dn += dnp; 
        current_y+=yincrement;
		l=l+SQRT2;
      }
      else if (dn<0)
      {
        dn += dnn;
		l=l+0x10000;
      } 
      else
      {
          if (xincrement<0)
          {
             dn += dnp; 
             current_y+=yincrement;
			 l=l+SQRT2;
          }
          else
          {
             dn += dnn;
			 l=l+0x10000;
          }
      }

      current_x+=xincrement;
      //printf("    -->%08X %d %d\n",dn,current_x,current_y);
      // Color is recomputed only when dithering is on


      if (reverse)
      {

          r2d_s_draw_point(gc,current_y,current_x,l);
      }
      else
      {
          r2d_s_draw_point(gc,current_x,current_y,l);
      }
   }
   } // END CLIPPING

   //printf("END LINE\n");
   
  
   r2d_check_and_send_event(gc);
}

// Used for filling
// Do clipping and coordinate transforms then call
// low levl line filling algorithm
// No mirroring check since it is a low level routine
// S COORDINATES
static void r2d_s_fill_line(T_R2D_GC_PTR gc,INT16 x,INT16 y,INT16 nb,BOOLEAN background)
{
   T_R2D_SHAPE_PTR clip;
   T_R2D_RECTANGLE *r;
//   INT16 tmp;

   clip=((T_R2D_GC*)gc)->p_s_clipping_shape;
   r=(T_R2D_RECTANGLE*)clip;


   if ((x>=r2d_get_xmin(clip)) && ( x<r2d_get_xmax(clip)))
   {
      if (y<r2d_get_ymin(clip))
      {
       nb-=r2d_get_ymin(clip)-y;
       y=r2d_get_ymin(clip);
      }

      if (y+nb-1>=r2d_get_ymax(clip))
        nb=r2d_get_ymax(clip)-y;

      if (nb>0)

        IND_r2d_write_lcd_line(gc,x,y,nb,background); 
   }


}

// Used for filling
// Do clipping and coordinate transforms then call
// low levl line filling algorithm
// No mirroring check since it is a low level routine
// S COORDINATES
static void r2d_s_arc_fill_line(T_R2D_GC_PTR gc,INT16 x,INT16 y,
								INT16 org_x,INT16 org_y,INT16 nb,T_R2D_ARC_REGION *rgn,BOOLEAN background)
{
   T_R2D_SHAPE_PTR clip;
   T_R2D_RECTANGLE *r;
//   INT16 tmp;

   clip=((T_R2D_GC*)gc)->p_s_clipping_shape;
   r=(T_R2D_RECTANGLE*)clip;


   if ((x>=r2d_get_xmin(clip)) && ( x<r2d_get_xmax(clip)))
   {
      if (y<r2d_get_ymin(clip))
      {
       nb-=r2d_get_ymin(clip)-y;
       y=r2d_get_ymin(clip);
      }

      if (y+nb-1>=r2d_get_ymax(clip))
        nb=r2d_get_ymax(clip)-y;

      if (nb>0)

        r2d_arc_write_lcd_line(gc,x,y,org_x,org_y,nb,rgn,background); 
   }


}

// S coordinates
static void           r2d_s_fill_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,BOOLEAN background)
{

    INT16 i;
	// The ifdef is not passing the coordinates to S frame.
	// It just changing the way the square is scanned
	// to improve behavior relatively to the scanning mode.
       for(i=ul_x+1;i<=br_x-1;i++)
       {
           r2d_s_fill_line(gc,i,ul_y+1,(br_y-ul_y)+1-2,background);
       }
     
}

// Background allows to chose the color for filling
// If TRUE, background color is used
// (required for pen_size different from 1)
// L coordinates
static void           r2d_df_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,BOOLEAN background)
{

    INT16 i;
	// The ifdef is not passing the coordinates to S frame.
	// It just changing the way the square is scanned
	// to improve behavior relatively to the scanning mode.
     #if (R2D_REFRESH==R2D_VERTICAL)
       for(i=ul_x+1;i<=br_x-1;i++)
       {
           r2d_s_fill_line(gc,i,ul_y+1,(br_y-ul_y)+1-2,background);
       }
     #else
       for(i=ul_y+1;i<=br_y-1;i++)
       {
           r2d_s_fill_line(gc,i,ul_x+1,(br_x-ul_x)+1-2,background);
       }
     #endif
}

void           r2d_draw_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{

	 
     r2d_moveto(gc,ul_x,ul_y);
     r2d_lineto(gc,br_x,ul_y);

	 
     r2d_moveto(gc,br_x,ul_y+1);
     r2d_lineto(gc,br_x,br_y);

	 
     r2d_moveto(gc,br_x-1,br_y);
     r2d_lineto(gc,ul_x,br_y);

	 
	 r2d_moveto(gc,ul_x,ul_y+1);
     r2d_lineto(gc,ul_x,br_y-1);
	 
}

void           r2d_fill_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	r2d_local_to_global(gc,&ul_x,&ul_y);
	r2d_local_to_global(gc,&br_x,&br_y);

	
#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
       R2D_SWAP(ul_x,br_x);
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;	   
	   R2D_SWAP(ul_y,br_y);
#endif
       r2d_df_rectangle(gc,ul_x,ul_y,br_x,br_y,TRUE);
	   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

   r2d_check_and_send_event(gc);
}



void           r2d_df_circle(T_R2D_GC_PTR gc,
                 INT16 x,INT16 y,INT16 r,BOOLEAN filling)
{
  INT32 current_x,current_y,my,mx;
  INT32 dn,dnp,dnn,org_x,org_y,limit,rs,tmp,D_yx;
  INT32 l;
  INT32 p; // perimeter divided by 4

  l=0;

  p=(PI*r)>>1;
  

  #if (R2D_REFRESH==R2D_VERTICAL)
    current_x=y;
    current_y=x+r;
    org_x=y; 
    org_y=x;
	
  #else
    current_x=x;
    current_y=y+r;
    org_x=x;
    org_y=y;
  #endif

  D_yx=org_y-org_x;

  dnp=((-r) << 1) + 5;
  dnn=3;
  dn=-r;
  rs=r*r;
  limit=-r;

 



  tmp=1;
  while(limit<=0)
  {

     // Some points are their own image with symetries
     // and yet they must not be drawn twice for drawing
     // modes other than copy hence the tests

     my=(org_y << 1) - current_y;
     mx=(org_x << 1) - current_x;

     // PY or PX is reflection relatively to horizontal line or vertical line
     // PY = vertical mirroring where bottom becomes top

     // D = diagonal mirroring

     // AB means apply transform A then B

     // I is identity

     // Everything is done relatively to what is displayed on the LCD
     // so my may be PX according to the refresh mode


     if (!filling)
     {
        if (mx != current_x)
        {
          r2d_s_draw_point(gc,current_y,current_x,l); // I : 3
          r2d_s_draw_point(gc,mx+D_yx,current_y-D_yx,l); // D PX : 5
          r2d_s_draw_point(gc,my,mx,l); // PX.PY : 7
          r2d_s_draw_point(gc,current_x+D_yx,my-D_yx,l); // D PY : 1
        }

        if (current_x != current_y)
        {
          r2d_s_draw_point(gc,current_x+D_yx,current_y-D_yx,l+p); // D : 4
          r2d_s_draw_point(gc,current_y,mx,l+p); // PY : 2
        }

        if ((mx != my) || (current_x != current_y))
          r2d_s_draw_point(gc,my,current_x,l+p); // PX : 6


        if (mx != my)
          r2d_s_draw_point(gc,mx+D_yx,my-D_yx,l+p); // D PX PY : 8

     }
     else
     {
         //printf("%d\n",current_x);
         if (tmp)
         {
           if (current_x-mx!=0)
           {
             r2d_s_fill_line(gc,my,mx+1,(current_x-mx)+1-2,TRUE);
             r2d_s_fill_line(gc,current_y,mx+1,(current_x-mx)+1-2,TRUE);
           }
         }
         if (mx != my) 
         {
           r2d_s_fill_line(gc,mx+D_yx,my+1-D_yx,(current_y-my)+1-2,TRUE);
           if (current_x != mx);
            r2d_s_fill_line(gc,current_x+D_yx,my+1-D_yx,(current_y-my)+1-2,TRUE);
         }
     }


     if (dn>0) // M outside circle, point below must be drawn
     {
        dn+=dnp;
        dnp+=4;
        
        current_y--;
		l+=SQRT2;
        limit+=2;
        tmp=1;
     }
     else
     {
        dn+=dnn;
        dnp+=2;
        limit+=1;
        tmp=0;
		l+=0x10000;
     }
     
     current_x++;
     dnn+=2;

     
     
     
  }
  //printf("%08X\n",limit);
}

void           r2d_draw_circle(T_R2D_GC_PTR gc,
                 INT16 x,INT16 y,INT16 r)
{

	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


   r2d_df_circle(gc,x,y,r,FALSE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,x-r,y-r,x+r,y+r);
   r2d_check_and_send_event(gc);
}

void           r2d_fill_circle(T_R2D_GC_PTR gc,
                 INT16 x,INT16 y,INT16 r)
{
	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

   r2d_df_circle(gc,x,y,r,TRUE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,x-r,y-r,x+r,y+r);
   r2d_check_and_send_event(gc);
}



// h and v are used to draw roundrectangle (each piece of the ellipse must be
// separated from other parts)
void           r2d_df_ellipse(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y, INT16 h,INT16 v,BOOLEAN filling)
{
  INT32 current_x,current_y,limit,newx,newy,org_x,org_y;
  INT32 dn,dnp,dnn,as,bs,tmp,a,b,mx,my,lastx,lasty,round;
  INT32 l;
  l=0;

  if ((h!=0) || (v!=0))
   round=1;
  else
   round=0;


  // Width of rectangle is assumed to be even
  // and it is forced to even dimension


  #if (R2D_REFRESH==R2D_VERTICAL)
    org_x=(ul_y + br_y)>>1;
    org_y=(br_x + ul_x)>>1; 
    a=(br_y-ul_y)>>1;
    as=R2D_SQUARE_P(a);
    b=(br_x-ul_x)>>1;
    bs=R2D_SQUARE_P(b);

    current_x=org_x ;
    current_y=org_y+b; 
    newx=org_y;
    newy=org_x+a;
    
  #else
    org_x=(ul_x + br_x)>>1; 
    org_y=(br_y + ul_y)>>1;

    b=(br_y-ul_y)>>1;
    bs=R2D_SQUARE_P(b);
    a=(br_x-ul_x)>>1;
    as=R2D_SQUARE_P(a);

    current_x=org_x;
    current_y=org_y+b; 
    newx=org_y;
    newy=org_x+a;
	R2D_SWAP(h,v);
    
  #endif

  // Now, shift by 2 to have the accuracy required by division by four


  //printf("current_x=%d, current_y=%d,as=%08X bs=%08X\n",current_x,current_y,as,bs);


  // New shift by 2 because one needs to compute quarter of values
  bs<<=2; as <<=2;b<<=2;a<<=2;

  limit = - ((as * b) >> 2); // -a^2 * b in Q2

  tmp=-((as * b) >> 2);
  dnp=(bs << 1) + bs + (tmp<<1) + (as << 1);
  dnn=(bs << 1) + bs;
  dn=bs + tmp + (as >>2);
  
  
  
  //printf("dn=%f dnp=%f dnn=%f\n",dn / 8.0,dnp / 8.0,dnn / 8.0);

/*#if (R2D_REFRESH==R2D_VERTICAL)
  r2d_draw_point(gc,current_y,current_x);
#else
  r2d_draw_point(gc,current_x,current_y);
#endif*/
  
  //printf("as=%08X bs=%08X\n",as,bs);

  tmp=1;
  while(limit<=0)
  {
     my=(org_y << 1) - current_y;
     mx=(org_x << 1) - current_x;

     lastx=current_y;
     lasty=current_x;

     if (!filling)
     {
       r2d_s_draw_point(gc,(current_y)+h,(current_x)+v,l); // I : 1
       r2d_s_draw_point(gc,my,mx,l); // PX PY : 2

       if ((mx != current_x) || (round))
       {
          r2d_s_draw_point(gc,(current_y)+h,mx,l); // PY : 3
          r2d_s_draw_point(gc,my,current_x+v,l); // PX : 4
       }
     }
     else
     {
         if (tmp)
         {

           // Used to remove point on horizontal extremity
           if (current_x+v-mx !=0)
           {
             r2d_s_fill_line(gc,my,mx+1,(current_x+v-mx)+1-2,TRUE);
             r2d_s_fill_line(gc,current_y+h,mx+1,(current_x+v-mx)+1-2,TRUE);
           }
         }  
     }

     if (dn>=0) // M outside circle, point below must be drawn
     {
        dn+=dnp;
        dnp+=((bs + as) << 1);
        current_y--; 
        limit+=(as + bs);
        tmp=1;
		l+=SQRT2;
     }
     else

     {
        dn+=dnn;
        dnp+=(bs << 1);
        limit+=bs;
        tmp=0;
		l+=0x10000;
        
     }
     current_x++; 
     dnn+=(bs << 1);

     
     //printf("limit=%f, dn=%f,dnn=%f,dnp=%f, pos= %d %d\n",limit / 4.0,dn / 4.0,dnn / 4.0,dnp /
//4.0,current_y,current_x);
     
     
  }
  
  current_x=newx;
  current_y=newy;
  R2D_SWAP(as,bs);
  R2D_SWAP(a,b);
  
  limit = - ((as * b) >> 2);

  tmp=-((as * b) >> 2);
  dnp=(bs << 1) + bs + (tmp<<1) + (as << 1);
  dnn=(bs << 1) + bs;
  dn=bs + tmp + (as >>2);

  //printf("newx=%d, newy=%d,a=%d,b=%d\n",newx,newy,a,b);
  //printf("dn=%f dnp=%f dnn=%f\n",dn / 4.0,dnp / 4.0,dnn / 4.0);

  tmp=1;

 /* #if (R2D_REFRESH==R2D_VERTICAL)
    r2d_draw_point(gc,current_x,current_y);
  #else
    r2d_draw_point(gc,current_y,current_x);
  #endif*/

  while(limit<0)
  {
     
     my=(org_x << 1) - current_y;
     mx=(org_y << 1) - current_x;

     if (!filling)
     {
        if ((lastx!=current_x) || (lasty!=current_y))
        {

          r2d_s_draw_point(gc,(current_x)+h,(current_y)+v,l); // D : 5


          r2d_s_draw_point(gc,mx,my,l); // D PX PY : 6

          if ((mx != (current_x+h)) || (round))
          {
            r2d_s_draw_point(gc,(current_x)+h,my,l); // D PY : 7
            r2d_s_draw_point(gc,mx,(current_y)+v,l); // D PX : 8
          }

        }
     }
     else
     {
        if (current_x != lastx)
        {
           r2d_s_fill_line(gc,mx,my+1,(current_y+v-my)+1-2,TRUE);
           if ((current_x+h) !=mx)
             r2d_s_fill_line(gc,current_x+h,my+1,(current_y+v-my)+1-2,TRUE);
        }
     }

     if (dn>0) // M outside circle, point below must be drawn
     {
        dn+=dnp;
        dnp+=((bs + as) << 1);
        current_y--; // Q1
        limit+=(as + bs);
        tmp=1;
		l+=SQRT2;
     }
     else
     {
        dn+=dnn;
        dnp+=(bs << 1);
        limit+=bs;
        tmp=0;
		l+=0x10000;
        
     }
     current_x++; // Q1
     dnn+=(bs << 1);

     
     
     
     //printf("limit=%f, dn=%f,dnn=%f,dnp=%f, pos= %d %d\n",limit / 4.0,dn / 4.0,dnn / 4.0,dnp / 4.0,current_y,current_x);
     
     
  }
}

void           r2d_draw_ellipse(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	r2d_local_to_global(gc,&ul_x,&ul_y);
	r2d_local_to_global(gc,&br_x,&br_y);
	

#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
	   R2D_SWAP(ul_x,br_x);
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);
#endif

   r2d_df_ellipse(gc,ul_x,ul_y,br_x,br_y,0,0,FALSE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

   r2d_check_and_send_event(gc);
}

void           r2d_fill_ellipse(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	r2d_local_to_global(gc,&ul_x,&ul_y);
	r2d_local_to_global(gc,&br_x,&br_y);

	
#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
       R2D_SWAP(ul_x,br_x);
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);
#endif

   r2d_df_ellipse(gc,ul_x,ul_y,br_x,br_y,0,0,TRUE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

   r2d_check_and_send_event(gc);
}

void           r2d_draw_round_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,INT16 h,INT16 v)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	r2d_moveto(gc,ul_x+h+1,ul_y);
  r2d_lineto(gc,br_x-h-1,ul_y);

  r2d_moveto(gc,ul_x+h+1,br_y);
  r2d_lineto(gc,br_x-h-1,br_y);

  r2d_moveto(gc,ul_x,ul_y+v+1);
  r2d_lineto(gc,ul_x,br_y-v-1);

  r2d_moveto(gc,br_x,ul_y+v+1);
  r2d_lineto(gc,br_x,br_y-v-1);

   r2d_local_to_global(gc,&ul_x,&ul_y);
   r2d_local_to_global(gc,&br_x,&br_y);

	
#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
       R2D_SWAP(ul_x,br_x);
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);  
#endif
  r2d_df_ellipse(gc,ul_x,ul_y,ul_x+(h<<1),ul_y+(v<<1),(br_x - ul_x) - (h<<1),(br_y - ul_y) - (v<<1),FALSE);
if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

  //printf("%d %d\n",ul_x+h+1,br_x-h-1);
  
  
  r2d_check_and_send_event(gc);
}

void           r2d_fill_round_rectangle(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,INT16 h,INT16 v)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	r2d_local_to_global(gc,&ul_x,&ul_y);
   r2d_local_to_global(gc,&br_x,&br_y);

#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
       R2D_SWAP(ul_x,br_x);
#endif


#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);
#endif

  r2d_df_ellipse(gc,ul_x,ul_y,ul_x+(h<<1),ul_y+(v<<1),(br_x - ul_x) - (h<<1),(br_y - ul_y) - (v<<1),TRUE);
#if (R2D_REFRESH == R2D_VERTICAL)
  r2d_df_rectangle(gc,ul_x+h,ul_y,br_x-h+1,br_y,TRUE);

#else
  
  r2d_df_rectangle(gc,ul_x,ul_y+v,br_x,br_y-v+1,TRUE);
#endif
  if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);
  //printf("%d %d\n",ul_x+h+1,br_x-h-1);
  /*r2d_moveto(gc,ul_x+h+1,ul_y);
  r2d_lineto(gc,br_x-h-1,ul_y);

  r2d_moveto(gc,ul_x+h+1,br_y);
  r2d_lineto(gc,br_x-h-1,br_y);

  r2d_moveto(gc,ul_x,ul_y+v+1);
  r2d_lineto(gc,ul_x,br_y-v-1);

  r2d_moveto(gc,br_x,ul_y+v+1);
  r2d_lineto(gc,br_x,br_y-v-1);*/
  r2d_check_and_send_event(gc);
}

// angle must be between 0 and 359
static INT32 r2d_cos(INT16 angle)
{
	

	if (angle<=90)
		return(r2d_cos_table[angle]);
	else if (angle<=180)
		return(-r2d_cos_table[180-angle]);
	else if (angle<=270)
         return(-r2d_cos_table[angle-180]);
	else
         return(r2d_cos_table[360-angle]);
}

// angle must be between 0 and 359
static INT32 r2d_sin(INT16 angle)
{
	angle=angle+90;
	if (angle>=360)
		angle=angle-360;

	return(-r2d_cos(angle));
}

static void r2d_check_angles(INT16 *start,INT16 *stop)
{
//   INT16 tmp;
   

   while(*start<0)
	   *start+=360;
   while(*start>=360)
	   *start-=360;

   while(*stop<0)
	   *stop+=360;
   while(*stop>=360)
	   *stop-=360;

   //if (*start>*stop)
   //{
//	   R2D_SWAP((*start),(*stop));
	  
   //}

}



void           r2d_df_arc(T_R2D_GC_PTR gc,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y,T_R2D_ARC_REGION *rgn ,BOOLEAN filling)
{
  INT32 current_x,current_y,limit,newx,newy,org_x,org_y;
  INT32 dn,dnp,dnn,as,bs,tmp,a,b,mx,my,lastx,lasty;
  INT32 l;

  l=0;

  // Width of rectangle is assumed to be even
  // and it is forced to even dimension

  if (rgn->is_null)
	  goto end_arc;

  #if (R2D_REFRESH==R2D_VERTICAL)
    org_x=(ul_y + br_y)>>1;
    org_y=(br_x + ul_x)>>1; 
    a=(br_y-ul_y)>>1;
    as=R2D_SQUARE_P(a);
    b=(br_x-ul_x)>>1;
    bs=R2D_SQUARE_P(b);

    current_x=org_x ;
    current_y=org_y+b; 
    newx=org_y;
    newy=org_x+a;

    
    
  #else
    org_x=(ul_x + br_x)>>1; 
    org_y=(br_y + ul_y)>>1;

    b=(br_y-ul_y)>>1;
    bs=R2D_SQUARE_P(b);
    a=(br_x-ul_x)>>1;
    as=R2D_SQUARE_P(a);

    current_x=org_x;
    current_y=org_y+b; 
    newx=org_y;
    newy=org_x+a;
	
    r2d_arc_region_diagonal_reflect(rgn);
	r2d_arc_region_x_reflect(rgn);
	r2d_arc_region_y_reflect(rgn);
  #endif

	
	
	// Orthogonal is (eb,-ea)

	//r2d_s_draw_point(gc,org_y,org_x);
	//r2d_s_draw_point(gc,((rgn->sa)>>16)+org_y,((rgn->sb)>>16)+org_x);
	//r2d_s_draw_point(gc,((rgn->sb)>>16)+org_y,((-rgn->sa)>>16)+org_x);

	//r2d_s_draw_point(gc,((rgn->ea)>>16)+org_y,((rgn->eb)>>16)+org_x);
	
	//goto end_arc;

  // Now, shift by 2 to have the accuracy required by division by four


  //printf("current_x=%d, current_y=%d,as=%08X bs=%08X\n",current_x,current_y,as,bs);


  // New shift by 2 because one needs to compute quarter of values
  bs<<=2; as <<=2;b<<=2;a<<=2;

  limit = - ((as * b) >> 2); // -a^2 * b in Q2

  tmp=-((as * b) >> 2);
  dnp=(bs << 1) + bs + (tmp<<1) + (as << 1);
  dnn=(bs << 1) + bs;
  dn=bs + tmp + (as >>2);
  
  
  
  //printf("dn=%f dnp=%f dnn=%f\n",dn / 8.0,dnp / 8.0,dnn / 8.0);

/*#if (R2D_REFRESH==R2D_VERTICAL)
  r2d_draw_point(gc,current_y,current_x);
#else
  r2d_draw_point(gc,current_x,current_y);
#endif*/
  
  //printf("as=%08X bs=%08X\n",as,bs);

  tmp=1;
  while(limit<=0)
  {
     my=(org_y << 1) - current_y;
     mx=(org_x << 1) - current_x;

     lastx=current_y;
     lasty=current_x;

     if (!filling)
     {
	   if (r2d_check_is_in_arc_region(current_y-org_y,current_x-org_x,rgn))
         r2d_s_draw_point(gc,(current_y),(current_x),l); // I : 1

	   if (r2d_check_is_in_arc_region(my-org_y,mx-org_x,rgn))
          r2d_s_draw_point(gc,my,mx,l); // PX PY : 2

       if ((mx != current_x) )
       {
		  if (r2d_check_is_in_arc_region(current_y-org_y,mx-org_x,rgn))
             r2d_s_draw_point(gc,current_y,mx,l); // PY : 3

		  if (r2d_check_is_in_arc_region(my-org_y,current_x-org_x,rgn))
             r2d_s_draw_point(gc,my,current_x,l); // PX : 4
       }
     }
     else
     {
         if (tmp)
         {

           // Used to remove point on horizontal extremity
           if (current_x-mx !=0)
           {
			 r2d_s_arc_fill_line(gc,my,mx+1,org_y,org_x,(current_x-mx)+1-2
				 ,rgn,TRUE);

             r2d_s_arc_fill_line(gc,current_y,mx+1,org_y,org_x,(current_x-mx)+1-2
				 ,rgn,TRUE);
           }
         }  
     }

     if (dn>=0) // M outside circle, point below must be drawn
     {
        dn+=dnp;
        dnp+=((bs + as) << 1);
        current_y--; 
        limit+=(as + bs);
        tmp=1;
		l+=SQRT2;
     }
     else

     {
        dn+=dnn;
        dnp+=(bs << 1);
        limit+=bs;
        tmp=0;
        l+=0x10000;
     }
     current_x++; 
     dnn+=(bs << 1);

     
     //printf("limit=%f, dn=%f,dnn=%f,dnp=%f, pos= %d %d\n",limit / 4.0,dn / 4.0,dnn / 4.0,dnp /
//4.0,current_y,current_x);
     
     
  }
  
  current_x=newx;
  current_y=newy;
  R2D_SWAP(as,bs);
  R2D_SWAP(a,b);
  
  limit = - ((as * b) >> 2);

  tmp=-((as * b) >> 2);
  dnp=(bs << 1) + bs + (tmp<<1) + (as << 1);
  dnn=(bs << 1) + bs;
  dn=bs + tmp + (as >>2);

  //printf("newx=%d, newy=%d,a=%d,b=%d\n",newx,newy,a,b);
  //printf("dn=%f dnp=%f dnn=%f\n",dn / 4.0,dnp / 4.0,dnn / 4.0);

  tmp=1;

 /* #if (R2D_REFRESH==R2D_VERTICAL)
    r2d_draw_point(gc,current_x,current_y);
  #else
    r2d_draw_point(gc,current_y,current_x);
  #endif*/

  while(limit<0)
  {
     
     my=(org_x << 1) - current_y;
     mx=(org_y << 1) - current_x;

     if (!filling)
     {
        if ((lastx!=current_x) || (lasty!=current_y))
        {

		  if (r2d_check_is_in_arc_region(current_x-org_y,current_y-org_x,rgn))
             r2d_s_draw_point(gc,(current_x),(current_y),l); // D : 5


		  if (r2d_check_is_in_arc_region(mx-org_y,my-org_x,rgn))
            r2d_s_draw_point(gc,mx,my,l); // D PX PY : 6

          if ((mx != current_x) )
          {
			if (r2d_check_is_in_arc_region(current_x-org_y,my-org_x,rgn))
              r2d_s_draw_point(gc,(current_x),my,l); // D PY : 7

			if (r2d_check_is_in_arc_region(mx-org_y,current_y-org_x,rgn))
              r2d_s_draw_point(gc,mx,(current_y),l); // D PX : 8
          }

        }
     }
     else
     {
        if (current_x != lastx)
        {
		   r2d_s_arc_fill_line(gc,mx,my+1,org_y,org_x,(current_y-my)+1-2
			   ,rgn,TRUE);
           
		   if (current_x !=mx)
             r2d_s_arc_fill_line(gc,current_x,my+1,org_y,org_x,(current_y-my)+1-2
			 ,rgn,TRUE);
        }
     }

     if (dn>0) // M outside circle, point below must be drawn
     {
        dn+=dnp;
        dnp+=((bs + as) << 1);
        current_y--; // Q1
        limit+=(as + bs);
        tmp=1;
		l+=SQRT2;
     }
     else
     {
        dn+=dnn;
        dnp+=(bs << 1);
        limit+=bs;
        tmp=0;
		l+=0x10000;
        
     }
     current_x++; // Q1
     dnn+=(bs << 1);

     
     
     
     //printf("limit=%f, dn=%f,dnn=%f,dnp=%f, pos= %d %d\n",limit / 4.0,dn / 4.0,dnn / 4.0,dnp / 4.0,current_y,current_x);
     
     
  }

  end_arc:  current_x=0;
}

void           r2d_draw_arc(T_R2D_GC_PTR gc,INT16 start_angle,INT16 stop_angle,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	BOOLEAN large=FALSE;
	T_R2D_ARC_REGION rgn;
	INT32 sa,sb,ea,eb;
	INT32 a,b;

	a=(br_x-ul_x)>>1;
	b=(br_y-ul_y)>>1;

	r2d_local_to_global(gc,&ul_x,&ul_y);
	r2d_local_to_global(gc,&br_x,&br_y);

    rgn.one_sector=0;
	if (stop_angle-start_angle>180)
		rgn.one_sector=1;

	if (stop_angle-start_angle==360)
         rgn.one_sector=2;

	if (start_angle==stop_angle)
		rgn.is_null=TRUE;
	else
		rgn.is_null=FALSE;
	r2d_check_angles(&start_angle,&stop_angle);
	

	sa=a * r2d_cos(start_angle); // Q16
	sb=  -b* r2d_sin(start_angle); // Q16
	// Orthogonal is (sb,-sa)

	ea= a * r2d_cos(stop_angle); // Q16
	eb= -b* r2d_sin(stop_angle); // Q16
	// Orthogonal is (-sb,sa)

	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(sa>>16),ul_y+b+(sb>>16));

	// Orthogonal
	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(sb>>16),ul_y+b+((-sa)>>16));

	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(ea>>16),ul_y+b+(eb>>16));

	rgn.sa=sa;
	rgn.sb=sb;


	rgn.ea=-ea;
	rgn.eb=-eb;

	
	

	

#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
	   R2D_SWAP(ul_x,br_x);

	   r2d_arc_region_x_reflect(&rgn);
	   
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);

	   r2d_arc_region_y_reflect(&rgn);
#endif

   

   r2d_df_arc(gc,ul_x,ul_y,br_x,br_y,&rgn,FALSE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

   r2d_check_and_send_event(gc);
}

void           r2d_fill_arc(T_R2D_GC_PTR gc, INT16 start_angle,INT16 stop_angle,
                  INT16 ul_x,INT16 ul_y,INT16 br_x, INT16 br_y)
{
#ifdef R2D_MIRRORED_X
	INT16 tmp;
#endif
	BOOLEAN large=FALSE;
	T_R2D_ARC_REGION rgn;
	INT32 sa,sb,ea,eb;
	INT32 a,b;

	a=(br_x-ul_x)>>1;
	b=(br_y-ul_y)>>1;

	r2d_local_to_global(gc,&ul_x,&ul_y);
	r2d_local_to_global(gc,&br_x,&br_y);


	rgn.one_sector=0;
	if (stop_angle-start_angle>180)
		rgn.one_sector=1;

	if (stop_angle-start_angle==360)
         rgn.one_sector=2;

	if (start_angle==stop_angle)
		rgn.is_null=TRUE;
	else
		rgn.is_null=FALSE;
	r2d_check_angles(&start_angle,&stop_angle);
	

	sa=a * r2d_cos(start_angle); // Q16
	sb=  -b* r2d_sin(start_angle); // Q16
	// Orthogonal is (sb,-sa)

	ea= a * r2d_cos(stop_angle); // Q16
	eb= -b* r2d_sin(stop_angle); // Q16
	// Orthogonal is (-sb,sa)

	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(sa>>16),ul_y+b+(sb>>16));

	// Orthogonal
	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(sb>>16),ul_y+b+((-sa)>>16));

	//r2d_moveto(gc,ul_x+a,ul_y+b);
	//r2d_lineto(gc,ul_x+a+(ea>>16),ul_y+b+(eb>>16));

	rgn.sa=sa;
	rgn.sb=sb;


	rgn.ea=-ea;
	rgn.eb=-eb;

	

#ifdef R2D_MIRRORED_X
	   ul_x = r2d_get_width(gc)-1-ul_x;
	   br_x = r2d_get_width(gc)-1-br_x;
       R2D_SWAP(ul_x,br_x);

	   r2d_arc_region_x_reflect(&rgn);
#endif

#ifdef R2D_MIRRORED_Y
	   ul_y = r2d_get_height(gc)-1-ul_y;
	   br_y = r2d_get_height(gc)-1-br_y;
	   R2D_SWAP(ul_y,br_y);

	   r2d_arc_region_y_reflect(&rgn);
#endif

   



   r2d_df_arc(gc,ul_x,ul_y,br_x,br_y,&rgn,TRUE);
   if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)gc,ul_x,ul_y,br_x,br_y);

   r2d_check_and_send_event(gc);
}

///////////////////////////////////////
//
// Copy function
//

static void r2d_diagonal_mirror(T_R2D_SHAPE_PTR rectangle)
{
   T_R2D_RECTANGLE *r;
   INT16 tmp;
   r=(T_R2D_RECTANGLE *)rectangle;

   tmp=r->ul_x;
   r->ul_x=r->ul_y;
   r->ul_y=tmp;

   tmp=r->br_x;
   r->br_x=r->br_y;
   r->br_y=tmp;
}

// Global coordinates
static void r2d_mirror_rectangle(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR rectangle)
{
   T_R2D_RECTANGLE *r;
   //INT16 org_x,org_y;
#ifdef R2D_MIRRORED_X
   INT16 tmp;
#endif
   r=(T_R2D_RECTANGLE *)rectangle;

   
#ifdef R2D_MIRRORED_X
   r->ul_x = r2d_get_width(gc)-r->ul_x;
   r->br_x = r2d_get_width(gc)-r->br_x;
   tmp=r->ul_x;
	r->ul_x=r->br_x;
	r->br_x=tmp;
#endif

#ifdef R2D_MIRRORED_Y
	r->ul_y = r2d_get_height(gc)-r->ul_y;
	r->br_y = r2d_get_height(gc)-r->br_y;

    tmp=r->ul_y;
	r->ul_y=r->br_y;
	r->br_y=tmp;
#endif

	   
}

// Global coordinates
// Here a rectangle with clipping convention is mirrored
// The resulting rectangle (s_clipping) is used with drawing
// convention. So, the boundary must be updated
static void r2d_mirror_clip_rectangle(T_R2D_GC_PTR gc,T_R2D_SHAPE_PTR rectangle)
{
   T_R2D_RECTANGLE *r;
//   INT16 org_x,org_y;
#ifdef R2D_MIRRORED_X
   INT16 tmp;
#endif
   r=(T_R2D_RECTANGLE *)rectangle;

   
   //Be careful br_x is NOT a line wich must be drawn
#ifdef R2D_MIRRORED_X
   r->ul_x = r2d_get_width(gc)-r->ul_x+1;
   r->br_x = r2d_get_width(gc)-(r->br_x-1);
   tmp=r->ul_x;
	r->ul_x=r->br_x;
	r->br_x=tmp;
#endif

#ifdef R2D_MIRRORED_Y
	r->ul_y = r2d_get_height(gc)-r->ul_y+1;
	r->br_y = r2d_get_height(gc)-(r->br_y-1);

    tmp=r->ul_y;
	r->ul_y=r->br_y;
	r->br_y=tmp;
#endif

	   
}

// Compute the intersection of the clipping shape of srcGc with
// the srcRectangle. Report he size reduction onto dstRectangle.
// Compute the intersection between dstRectangle and the clipping rectangle
// of dstGc and report the size reduction to srcRectangle.
// At the end, one get two rectangles of same size.
// The first one is contained in the clipping shape of srcGc
// and the second one in the clipping shape of dstGc.
// If the result is null, false is returned and no  copy is done
// The rectangles are modified.
static BOOLEAN r2d_clipped_is_not_null(T_R2D_GC* src_gc,T_R2D_GC *dst_gc,
                                       T_R2D_RECTANGLE* src_rectangle,T_R2D_RECTANGLE* dst_rectangle)
{
  BOOLEAN result=TRUE;
  //CC : clipping coordinate , RC : rectangle coordinate
  INT16 delta,CC,RC;

#if (R2D_DEBUG == R2D_ON)
#if (R2D_DEBUG_WARNING == R2D_DEBUG_HIGH)
	if (src_gc->p_clipping_shape==NULL)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
	if (dst_gc->p_clipping_shape==NULL)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
#endif
#endif

  //T_R2D_RECTANGLE *debug;

  //debug=(T_R2D_RECTANGLE*)src_gc->p_clipping_shape;


  // Intersections in src context
  CC=r2d_get_xmin(src_gc->p_clipping_shape);
  RC=r2d_get_xmin(src_rectangle);
  if ( CC > RC)
  {
     delta=CC-RC;
     src_rectangle->ul_x=CC;
     dst_rectangle->ul_x+=delta;
  }

  CC=r2d_get_xmax(src_gc->p_clipping_shape);
  RC=r2d_get_xmax(src_rectangle);
  if ( RC > CC)
  {
     delta=RC-CC;
     src_rectangle->br_x=CC;
     dst_rectangle->br_x-=delta;
  }

  CC=r2d_get_ymin(src_gc->p_clipping_shape);
  RC=r2d_get_ymin(src_rectangle);
  if ( CC > RC)
  {
     delta=CC-RC;
     src_rectangle->ul_y=CC;
     dst_rectangle->ul_y+=delta;
  }

  CC=r2d_get_ymax(src_gc->p_clipping_shape);
  RC=r2d_get_ymax(src_rectangle);
  if ( RC > CC)
  {
     delta=RC-CC;
     src_rectangle->br_y=CC;
     dst_rectangle->br_y-=delta;
  }

  // Intersection in dst context
  CC=r2d_get_xmin(dst_gc->p_clipping_shape);
  RC=r2d_get_xmin(dst_rectangle);
  if ( CC > RC)
  {
     delta=CC-RC;
     dst_rectangle->ul_x=CC;
     src_rectangle->ul_x+=delta;
  }

  CC=r2d_get_xmax(dst_gc->p_clipping_shape);
  RC=r2d_get_xmax(dst_rectangle);
  if ( RC > CC)
  {
     delta=RC-CC;
     dst_rectangle->br_x=CC;
     src_rectangle->br_x-=delta;
  }

  CC=r2d_get_ymin(dst_gc->p_clipping_shape);
  RC=r2d_get_ymin(dst_rectangle);
  if ( CC > RC)
  {
     delta=CC-RC;
     dst_rectangle->ul_y=CC;
     src_rectangle->ul_y+=delta;
  }

  CC=r2d_get_ymax(dst_gc->p_clipping_shape);
  RC=r2d_get_ymax(dst_rectangle);
  if ( RC > CC)
  {
     delta=RC-CC;
     dst_rectangle->br_y=CC;
     src_rectangle->br_y-=delta;
  }

  if (src_rectangle->ul_x>=src_rectangle->br_x)
   result=FALSE;


  if (src_rectangle->ul_y>=src_rectangle->br_y)
   result=FALSE;

  if (result)
  {
    /*printf("src: (%d,%d) -- (%d,%d)\n",src_rectangle->ul_x,src_rectangle->ul_y
    ,src_rectangle->br_x,src_rectangle->br_y);
    printf("dst: (%d,%d) -- (%d,%d)\n",dst_rectangle->ul_x,dst_rectangle->ul_y
    ,dst_rectangle->br_x,dst_rectangle->br_y);*/

    // Conversion of clipped rectangles to framebuffer coordinates
    r2d_local_to_global(src_gc,&(src_rectangle->ul_x),&(src_rectangle->ul_y));
    r2d_local_to_global(src_gc,&(src_rectangle->br_x),&(src_rectangle->br_y));
    r2d_local_to_global(dst_gc,&(dst_rectangle->ul_x),&(dst_rectangle->ul_y));
    r2d_local_to_global(dst_gc,&(dst_rectangle->br_x),&(dst_rectangle->br_y));

#if (R2D_DEBUG == R2D_ON)
#if (R2D_DEBUG_WARNING == R2D_DEBUG_HIGH)
	if (src_rectangle->ul_x<0)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (src_rectangle->ul_y<0)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (dst_rectangle->ul_x<0)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );


	if (dst_rectangle->ul_y<0)
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (src_rectangle->br_x>r2d_get_width(src_gc))
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (src_rectangle->br_y>r2d_get_height(src_gc))
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (dst_rectangle->br_x>r2d_get_width(dst_gc))
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

	if (dst_rectangle->br_y>r2d_get_height(dst_gc))
	  rvf_send_trace("R2D : clipping shape error",26, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );

#endif
#endif
    /*printf("src: (%d,%d) -- (%d,%d)\n",src_rectangle->ul_x,src_rectangle->ul_y
    ,src_rectangle->br_x,src_rectangle->br_y);
    printf("dst: (%d,%d) -- (%d,%d)\n",dst_rectangle->ul_x,dst_rectangle->ul_y
    ,dst_rectangle->br_x,dst_rectangle->br_y);*/
  }

  return(result);
}

T_R2D_ERROR           r2d_low_level_blit_rect(T_R2D_GC_PTR src_gc,T_R2D_GC_PTR dst_gc,
                         T_R2D_SHAPE_PTR org_src_rectangle, T_R2D_SHAPE_PTR org_dst_rectangle,
						 BOOLEAN src_mirrored,BOOLEAN dst_mirrored,
						 BOOLEAN use_foreground_color)
{

   INT16 kind_src,kind_dst,org_bx,org_by,org_ux,org_uy;
#if (R2D_ASM == R2D_ON)
   T_R2D_DRAWING_MODE mode;
#endif

   T_R2D_SHAPE_PTR src_rectangle,dst_rectangle;

#if (R2D_DEBUG == R2D_ON)
#if (R2D_DEBUG_WARNING == R2D_DEBUG_HIGH)
   if (src_gc==NULL)
   {
	  rvf_send_trace("src_gc NULL",11, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
	  rvf_delay(RVF_SECS_TO_TICKS(1));
   }

   if (dst_gc==NULL)
   {
	  rvf_send_trace("dst_gc NULL",11, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
	  rvf_delay(RVF_SECS_TO_TICKS(1));\
   }

   if (org_src_rectangle==NULL)
   {
	  rvf_send_trace("org_src NULL",12, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
	  rvf_delay(RVF_SECS_TO_TICKS(1));\
   }

   if (org_dst_rectangle==NULL)
   {
	  rvf_send_trace("org_dst NULL",12, NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, r2d_use_id );
	  rvf_delay(RVF_SECS_TO_TICKS(1));\
   }
#endif
#endif

   

    src_rectangle=r2d_clone_shape(r2d_mb_id,org_src_rectangle);
    if (src_rectangle==NULL)
	   return(R2D_MEMORY_ERR);
	

    dst_rectangle=r2d_clone_shape(r2d_mb_id,org_dst_rectangle);
    if (dst_rectangle==NULL)
    {
	   r2d_release_shape(src_rectangle);
	   return(R2D_MEMORY_ERR);
    }

	r2d_disable_refresh();

	org_bx=((T_R2D_RECT*)src_rectangle)->br_x;
    org_by=((T_R2D_RECT*)src_rectangle)->br_y;
	org_ux=((T_R2D_RECT*)src_rectangle)->ul_x;
    org_uy=((T_R2D_RECT*)src_rectangle)->ul_y;
	r2d_local_to_global(src_gc,&org_ux,&org_uy);
	r2d_local_to_global(src_gc,&org_bx,&org_by);
    if (r2d_clipped_is_not_null(src_gc,dst_gc,src_rectangle,dst_rectangle))
	{
   // Rects are now clipped and in global coordinates

if (src_mirrored) 
  r2d_mirror_rectangle(src_gc,src_rectangle);

if (dst_mirrored)
   r2d_mirror_rectangle(dst_gc,dst_rectangle);

// In that case we are drawing text.
// If dst rect clipped by the right side, the src must be shifted to 
// the start of the char
// and must not remained aligned with the end of the char
// (don't forget that since char is drawn with mirror its start
// is corresponding to the right and bottom side of the bounding
// rectangle)
// There is the dual problem when the dst rect is clipped by the
// left side

if ((dst_mirrored) && (!src_mirrored))
{
  INT16 dbx,dby,dux,duy;
  dbx=0;
  dux=0;
  dby=0;
  duy=0;

#ifdef R2D_MIRRORED_X
  dbx=org_bx-((T_R2D_RECT*)src_rectangle)->br_x;
  dux=org_ux-((T_R2D_RECT*)src_rectangle)->ul_x;
#endif

#ifdef R2D_MIRRORED_Y
  dby=org_by-((T_R2D_RECT*)src_rectangle)->br_y;
  duy=org_uy-((T_R2D_RECT*)src_rectangle)->ul_y;
#endif

  r2d_translate_shape(src_rectangle,dbx,dby);
  r2d_translate_shape(src_rectangle,dux,duy);
}



 // After mirrong one is in L coordinates


  if (((T_R2D_FRAMEBUFFER*)((T_R2D_GC*)dst_gc)->p_frame_buffer)->kind==0)
          r2d_update_region((T_R2D_GC*)dst_gc,r2d_get_xmin(dst_rectangle),
		  r2d_get_ymin(dst_rectangle),
		  r2d_get_xmax(dst_rectangle),
		  r2d_get_ymax(dst_rectangle));

#if (R2D_REFRESH != R2D_VERTICAL)
  r2d_diagonal_mirror(src_rectangle);
  r2d_diagonal_mirror(dst_rectangle);
#endif

  // After swap one is in S coordinates

   kind_src=((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)src_gc)->p_frame_buffer))->kind;
   kind_dst=((T_R2D_FRAMEBUFFER*)(((T_R2D_GC*)dst_gc)->p_frame_buffer))->kind;

    
#if (R2D_ASM == R2D_OFF)

   if ((kind_src!=R2D_FULL_KIND) && (kind_dst!=R2D_FULL_KIND))
     IND_r2d_blit_lcd_to_lcd(src_gc,dst_gc,src_rectangle,dst_rectangle,use_foreground_color);
   else
   if ((kind_src==R2D_FULL_KIND) && (kind_dst==R2D_FULL_KIND))
     IND_r2d_blit_color_to_color(src_gc,dst_gc,src_rectangle,dst_rectangle,use_foreground_color);
   else
   if ((kind_src!=R2D_FULL_KIND) && (kind_dst==R2D_FULL_KIND))
     IND_r2d_blit_lcd_to_color(src_gc,dst_gc,src_rectangle,dst_rectangle,use_foreground_color);
   else
   if ((kind_src==R2D_FULL_KIND) && (kind_dst!=R2D_FULL_KIND))
     IND_r2d_blit_color_to_lcd(src_gc,dst_gc,src_rectangle,dst_rectangle,use_foreground_color);

#else
   mode=(((T_R2D_GC*)dst_gc))->drawing_mode;
   rvf_lock_mutex(r2d_g_blit_mutex);

   if ((kind_src!=R2D_FULL_KIND) && (kind_dst!=R2D_FULL_KIND))
   {
	 r2d_patch_blit(dst_gc,mode,
					use_foreground_color,R2D_LCDLCD);
     r2d_blit_asm(src_gc,dst_gc,src_rectangle,dst_rectangle,
	 use_foreground_color,R2D_LCDLCD);
   }
   else
   if ((kind_src==R2D_FULL_KIND) && (kind_dst==R2D_FULL_KIND))
   {
	   r2d_patch_blit(dst_gc,mode,
					use_foreground_color,R2D_COLORCOLOR);
     r2d_blit_asm(src_gc,dst_gc,src_rectangle,dst_rectangle,
	 use_foreground_color,R2D_COLORCOLOR);
   }
   else
   if ((kind_src!=R2D_FULL_KIND) && (kind_dst==R2D_FULL_KIND))
   {
	   r2d_patch_blit(dst_gc,mode,
					use_foreground_color,R2D_LCDCOLOR);
     r2d_blit_asm(src_gc,dst_gc,src_rectangle,dst_rectangle,
	 use_foreground_color,R2D_LCDCOLOR);
   }
   else
   if ((kind_src==R2D_FULL_KIND) && (kind_dst!=R2D_FULL_KIND))
   {
	   r2d_patch_blit(dst_gc,mode,
					use_foreground_color,R2D_COLORLCD);
     r2d_blit_asm(src_gc,dst_gc,src_rectangle,dst_rectangle,
	 use_foreground_color,R2D_COLORLCD);
   }
   rvf_unlock_mutex(r2d_g_blit_mutex);

#endif

   
   r2d_check_and_send_event(dst_gc);
	}
	 r2d_release_shape(src_rectangle);
   r2d_release_shape(dst_rectangle);
   r2d_enable_refresh();
   return(R2D_OK);
}

T_R2D_ERROR           r2d_blit_rect(T_R2D_GC_PTR src_gc,T_R2D_GC_PTR dst_gc,
                         T_R2D_SHAPE_PTR org_src_rectangle, 
						 T_R2D_SHAPE_PTR org_dst_rectangle,
						 BOOLEAN use_foreground_color)
{
		// Allow reversing if needed
	return(r2d_low_level_blit_rect(src_gc,dst_gc,org_src_rectangle,org_dst_rectangle,TRUE,TRUE,use_foreground_color));
}



///////////////////////////////////////
//
// Text functions
//

T_R2D_CHAR_METRIC_PTR r2d_get_char_metrics(T_R2D_GC_PTR gc,UINT32 the_char)
{
  INT32 *p;
  INT32 new_char;

  new_char=r2d_ptree_find(((T_R2D_GC*)gc)->font_table,the_char);

  p=((T_R2D_GC*)gc)->font_metrics;
  p+=(new_char<<3);

  *p++;

  return((T_R2D_CHAR_METRIC_PTR)p);
}

T_R2D_ERROR r2d_draw_char(T_R2D_GC_PTR font_cache_gc,
                    T_R2D_GC_PTR gc,
                    T_R2D_GC_PTR fontgc,
                    INT16 x,INT16 y,INT16 org_size,T_R2D_CHAR_METRIC_PTR met)
{
    
    T_R2D_SHAPE_PTR src_rectangle,dst_rectangle,tdst_rectangle;
    

    INT32 *p;
    INT16 underline;
//	INT32 new_char;
	INT16 style;
	INT16 ascent;
	T_R2D_ERROR err;

	style=((T_R2D_GC *)gc)->internal_text_style;
	ascent=((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+1];

	err=R2D_OK;


    p=((T_R2D_GC*)gc)->font_metrics;
    underline=*--p;
   

    
    {
       
	   
       
       if (style & R2D_BOLD)
       {
//           T_R2D_DRAWING_MODE the_mode;
//           T_R2D_ARGB_COLOR bg_color;

#if (R2D_REFRESH == R2D_VERTICAL)
           src_rectangle=r2d_new_rectangle(r2d_mb_id,r2d_get_char_x(met),0,
		   r2d_get_char_x(met)+r2d_get_char_width(met),
		   r2d_get_char_height(met));
#else
		   // In horizontal mode char are organized vertically
		   src_rectangle=r2d_new_rectangle(r2d_mb_id,0,r2d_get_char_x(met),
			   r2d_get_char_width(met),r2d_get_char_x(met)+r2d_get_char_height(met));
#endif
		   if (src_rectangle==NULL)
		   {
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }
		   //dst_rectangle=r2d_new_rectangle(0,0,char_width+1,char_height);
		   //if (dst_rectangle==NULL)
		   //{
		//	   r2d_release_shape(src_rectangle);
		//	   *err=1;
		//	   return(0);
		   //}
           
           // erase temporary char if R2D is starting to draw a new char
           // (it is not always the case with diacritics chars)
           
		   //r2d_set_background_color_with_argb(font_cache_gc,0,0,255,0);
		   r2d_fill_rectangle(font_cache_gc,-1,-1,r2d_get_width(font_cache_gc)+1,
			   r2d_get_height(font_cache_gc)+1);
		   //r2d_set_background_color_with_argb(font_cache_gc,0,255,255,255);

           //r2d_release_shape(dst_rectangle);
                
           // Create destination rectangles 
		   dst_rectangle=r2d_new_rectangle(r2d_mb_id,0,0,r2d_get_char_width(met),
			   r2d_get_char_height(met));
		   if (dst_rectangle==NULL)
		   {
			   r2d_release_shape(src_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }

           tdst_rectangle=r2d_clone_shape(r2d_mb_id,dst_rectangle);
		   if (tdst_rectangle==NULL)
		   {
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }

           r2d_translate_shape(tdst_rectangle,1,0);


           // set mode
           r2d_set_drawing_mode(font_cache_gc,R2D_OR_MODE);

           // Build bold char

           if (r2d_low_level_blit_rect(fontgc,font_cache_gc,src_rectangle,dst_rectangle,
			   FALSE,FALSE,FALSE)!=R2D_OK)
		   {
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   r2d_release_shape(tdst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }

           if (r2d_low_level_blit_rect(fontgc,font_cache_gc,src_rectangle,tdst_rectangle,
			   FALSE,FALSE,FALSE)!=R2D_OK)
		   {
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   r2d_release_shape(tdst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }

		   if (style & R2D_STRIKETHROUGH)
		   {
		     r2d_moveto(font_cache_gc,0,ascent>>1);
		     r2d_lineto(font_cache_gc,r2d_get_char_width(met),ascent>>1);
		   }

           // Reset mode
           r2d_set_drawing_mode(font_cache_gc,R2D_COPY_MODE);

           r2d_release_shape(tdst_rectangle);

           r2d_release_shape(dst_rectangle);
           r2d_release_shape(src_rectangle);

           // Recreate src and dest rectangle
           src_rectangle=r2d_new_rectangle(r2d_mb_id,0,0,r2d_get_char_width(met)+1,
			   r2d_get_char_height(met));
		   if (src_rectangle==NULL)
		   {
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }
		   
		   if (org_size != 0)
		  {
			  INT16 tmp;

			  tmp=(org_size-r2d_get_char_width(met))>>1;
			  dst_rectangle=r2d_new_rectangle(r2d_mb_id,x+tmp,y-r2d_get_char_height(met),
				  x+tmp+r2d_get_char_width(met)+1,y);
		  }
		  else
          dst_rectangle=r2d_new_rectangle(r2d_mb_id,x+r2d_get_char_org_x(met),
		  y-r2d_get_char_org_y(met),
		  x+r2d_get_char_width(met)+r2d_get_char_org_x(met)+1,
		  y+r2d_get_char_height(met)-r2d_get_char_org_y(met));
          
           if (dst_rectangle==NULL)
		   {
			   r2d_release_shape(src_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }
           //printf("free_pos=%d, char_width=%d\n",free_pos,char_width);
           if (r2d_low_level_blit_rect(font_cache_gc,gc,src_rectangle,dst_rectangle,
			   FALSE,TRUE,TRUE)!=R2D_OK)
		   {
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		   }

       }
       else 
       {
          #if (R2D_REFRESH == R2D_VERTICAL)
           src_rectangle=r2d_new_rectangle(r2d_mb_id,r2d_get_char_x(met),
			   0,
			   r2d_get_char_x(met)+r2d_get_char_width(met),
			   r2d_get_char_height(met));
#else
		   // In horizontal mode char are organized vertically
		   src_rectangle=r2d_new_rectangle(r2d_mb_id,0,
			   r2d_get_char_x(met),
			   r2d_get_char_width(met),
			   r2d_get_char_x(met)+r2d_get_char_height(met));
#endif
		  if (src_rectangle==NULL)
		  {
			   err=R2D_MEMORY_ERR;
			   return(err);
		  }
          
		  if (org_size != 0)
		  {
			  INT16 tmp;

			  tmp=(org_size-r2d_get_char_width(met))>>1;
			  dst_rectangle=r2d_new_rectangle(r2d_mb_id,x+tmp,
				  y-r2d_get_char_height(met),
				  x+tmp+r2d_get_char_width(met),y);
		  }
		  else
          dst_rectangle=r2d_new_rectangle(r2d_mb_id,
		  x+r2d_get_char_org_x(met),
		  y-r2d_get_char_org_y(met),
		  x+r2d_get_char_width(met)+r2d_get_char_org_x(met),
		  y+r2d_get_char_height(met)-r2d_get_char_org_y(met));
          
		  if (dst_rectangle==NULL)
		  {
			   r2d_release_shape(src_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		  }

		  if (style & R2D_STRIKETHROUGH)
		  {
			  r2d_fill_rectangle(font_cache_gc,-1,-1,r2d_get_width(font_cache_gc)+1,
			   r2d_get_height(font_cache_gc)+1);
			  tdst_rectangle=r2d_new_rectangle(r2d_mb_id,0,0,r2d_get_char_width(met),
			   r2d_get_char_height(met));

            if (tdst_rectangle==NULL)
			{
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
			}

              err=r2d_low_level_blit_rect(fontgc,font_cache_gc,src_rectangle,tdst_rectangle,
			  FALSE,FALSE,FALSE);
			  if (err==R2D_OK)
			  {
			    r2d_moveto(font_cache_gc,0,ascent>>1);
			    r2d_lineto(font_cache_gc,r2d_get_char_width(met),ascent>>1);
                err=r2d_low_level_blit_rect(font_cache_gc,gc,tdst_rectangle,dst_rectangle,
			      FALSE,TRUE,TRUE);
			  }

			  r2d_release_shape(tdst_rectangle);
		  }
		  else
		  {
			  err=r2d_low_level_blit_rect(fontgc,gc,src_rectangle,dst_rectangle,
			  FALSE,TRUE,TRUE);
		  }

          if (err!=R2D_OK)
		  {
			   r2d_release_shape(src_rectangle);
			   r2d_release_shape(dst_rectangle);
			   err=R2D_MEMORY_ERR;
			   return(err);
		  }


       }



       if (style & R2D_UNDERLINED)
       {
           r2d_moveto(gc,x+r2d_get_char_org_x(met),y+underline);
           r2d_lineto(gc,x+r2d_get_char_org_x(met)+
			   r2d_get_char_dx(met),y+underline);
       }
       
       r2d_release_shape(src_rectangle);
       r2d_release_shape(dst_rectangle);

       
    }
   return(err);
}


#define R2D_ENDIAN_SWAP(a) {misc=(a&0x0FF) << 8;a=a>>8;a=a|misc;a=a&0x0FFFF;}

UINT32 r2d_get_next_char(T_R2D_UTF16 *the_text,INT16 *pos,UINT16 max_chars,
							  BOOLEAN *swapping)
{
	T_R2D_UTF16 current;
	INT16 temp;
	INT32 the_char;
	BOOLEAN must_display,combining,done;
	T_R2D_UTF16 next, misc;
//	T_R2D_CHAR_METRIC_PTR p;
	// Swapping should be set to FALSE first time this function is called


	
	
	// current char consider a WHOLE char
	// (when combining char are used, they are considered
	// as making ONE char)
	done=FALSE;

   // Detection of byte order mark
	if (the_text[*pos] == 0xFFFE)
	{
		*swapping=TRUE;
		*pos=*pos+1;
	}
    while ((!done) && (the_text[*pos]!=0) && (*pos<max_chars))
    {
		must_display=FALSE;
		combining=FALSE;

        current=the_text[*pos];
		*pos=*pos+1;
        if (*swapping)
			R2D_ENDIAN_SWAP(current);
		
	    if ((current != 0x0FFFF))
		{
	     // If High-surrogate 
		 if ((current >= 0xd800) && (current <= 0xdbff))
		 {
			 // Then check that next char if a low-surrogate
			 next=the_text[*pos];
			 if (*swapping)
			   R2D_ENDIAN_SWAP(next);
			 
			 if ((next >= 0xdc00) && (next<=0xdfff))
			 {
				 *pos=*pos+1;
				 the_char=(current - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
				 must_display=TRUE;
			 }
			 else
			 {
			     rvf_send_trace("r2d_get_next_char() missing low surrogate char",
			        strlen("r2d_get_next_char() missing low surrogate char"), NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
			 }
		 }
		 else
		 {
			 // If not a high-surrogate then check it is not
			 // a low-surrogate
			 if ((current < 0xdc00) || (current>0xdfff))
			 {
				 the_char=current;
				 must_display=TRUE;
			 }
			 else
			 {
			     rvf_send_trace("R2D : r2d_get_next_char unexpected low surrogate char",
			        strlen("R2D : r2d_get_next_char unexpected low surrogate char"), NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
			 }

		 }
		}
		
		 if ((the_char>=0x300) && (the_char <=0x36f))
			combining=TRUE;

		 if (must_display)
		 {
		   
		   if (!combining)
		   {
		     // Next char
			   done=TRUE;
			   
		   }
		 }
		
       
    }
	if (done)
	  return(the_char);
	else
		return(0);
}
//
static T_R2D_ERROR          r2d_low_draw_text(T_R2D_GC_PTR gc,INT16 x,INT16 y,
									   T_R2D_UTF16 *the_text,
									   T_R2D_TEXT_DRAWING_SETTINGS settings,
									   UINT16 max_words,
									   UINT16 *width,
									   UINT16 *height)
{
    T_R2D_GC_PTR fontgc;
    T_R2D_GC_PTR cache_gc;
    BOOLEAN draw;
    T_R2D_DRAWING_MODE the_mode;
	T_R2D_UTF16 *temp;
	INT16 err;
	INT16 current_word;
	INT32 the_char;
	BOOLEAN must_display,swapping,combining;
	INT16 delta,deltay,misc,current_y,maxx,delta_line,y_org;
	T_R2D_UTF16 next,current;
	T_R2D_CHAR_METRIC_PTR p;
	
	
    INT16 x_org;



	draw=((settings & R2D_TEXT_DRAW)==R2D_TEXT_DRAW);

	if (the_text==NULL)
		return(R2D_MEMORY_ERR);

	x_org=x;
	y_org=y;

	maxx=0;

	

	current_word=0; // We are at first word in string
	// current word consider a word which may be a partial char
	// (when combining char are used, they are considered
	// as making ONE char)
    swapping=FALSE;

    if (draw)
    {
        // +1 used since blit_rect is using a bounding rect
        cache_gc=r2d_new_font_buffer_context(r2d_mb_id,((T_R2D_GC*)gc)->font_frame_buffer->kind,
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS]+1,// max width for free area
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+1]+ // ascent
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+2]+ // descent
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+3]); // leading
        
        delta_line=((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+1]+ // ascent
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+2]+ // descent
            ((T_R2D_GC*)gc)->font_metrics[R2D_BUFFER_WIDTH_POS+3];
        
        
        if (cache_gc==NULL)
            return(R2D_MEMORY_ERR);
        
        r2d_context_lock(cache_gc);
        
        fontgc=r2d_new_context(r2d_mb_id,((T_R2D_GC*)gc)->font_frame_buffer);
        //r2d_release_framebuffer(((T_R2D_GC*)gc)->font_frame_buffer);
        
        
        if (fontgc==NULL)
        {
            r2d_context_unlock(cache_gc);
            r2d_release_context(cache_gc);
            return(R2D_MEMORY_ERR);
        }
        
        r2d_context_lock(fontgc);
    
        r2d_set_background_color_with_argb(fontgc,0,255,255,255);
        r2d_set_foreground_color_with_argb(fontgc,0,0,0,0);
    
        the_mode=r2d_get_drawing_mode(gc);
    }
    
    err=R2D_OK;
	delta=0;
	deltay=0;
	current_y=y;
	// Detection of byte order mark
	if (*the_text == 0xFFFE)
	{
		swapping=TRUE;
		the_text++;
		current_word++;
	}
    while((*the_text!=0) && (err==R2D_OK) && (current_word<max_words))
    {
		must_display=FALSE;
		combining=FALSE;
		if (the_char!=0xa)
		  x+=delta;

		delta = 0;

        current=*the_text++;
		current_word++;

		if (swapping)
			R2D_ENDIAN_SWAP(current);
		
	    if ((current != 0x0FFFF))
		{
	     // If High-surrogate 
		 if ((current >= 0xd800) && (current <= 0xdbff))
		 {
			 // Then check that next char if a low-surrogate
			 next=*the_text;
			 if (swapping)
			    R2D_ENDIAN_SWAP(next);
			 if ((next >= 0xdc00) && (next<=0xdfff))
			 {
				 the_text++;
				 current_word++;
				 the_char=(current - 0xd800) * 0x400 + (next - 0xdc00) + 0x10000;
				 must_display=TRUE;
			 }
			 else
			 {
			     rvf_send_trace("r2d_low_draw_text() missing low surrogate char",
			        strlen("r2d_low_draw_text() missing low surrogate char"), NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
			 }
		 }
		 else
		 {
			 // If not a high-surrogate then check it is not
			 // a low-surrogate
			 if ((current < 0xdc00) || (current>0xdfff))
			 {
				 the_char=current;
				 must_display=TRUE;
			 }
			 else
			 {
			     rvf_send_trace("r2d_low_draw_text() unexpected low surrogate char",
			        strlen("r2d_low_draw_text() unexpected low surrogate char"), NULL_PARAM, 
				   RV_TRACE_LEVEL_ERROR, R2D_USE_ID );
			 }
		 }
		}
		
		 if ((the_char>=0x300) && (the_char <=0x36f))
			combining=TRUE;
		 else
			current_y=y;

		 if (the_char==0xa)
		 {
			 if ((x-x_org)>maxx)
				 maxx=x-x_org;
			 
			 if ((x_org-x)>maxx)
				 maxx=x_org-x;
			 x=x_org;
			 y += delta_line;

		 }

		 if ((must_display) && (the_char!=0xa))
		 {
		   p=r2d_get_char_metrics(gc,the_char);
		   if (combining)
		   {
			  
			  if (draw)
			  {
				
				current_y -= deltay;
				x=x-delta;
				
				if (((T_R2D_GC*)gc)->script_mode==R2D_LEFT_TO_RIGHT)
                  err=r2d_draw_char(cache_gc,gc,fontgc,x,current_y,delta,p);
				else
                  err=r2d_draw_char(cache_gc,gc,fontgc,x+delta,current_y,delta,p);
				deltay=r2d_get_char_height(p);
			  }
		   }
		   else
		   {
		     if (draw)
			 {
				 
                
				if (((T_R2D_GC*)gc)->script_mode==R2D_LEFT_TO_RIGHT)
				{
				  delta=r2d_get_char_dx(p);
				  err=r2d_draw_char(cache_gc,gc,fontgc,x,current_y,0,p);
			      
				}
				else
				{
				   delta=-r2d_get_char_dx(p);
				   err=r2d_draw_char(cache_gc,gc,fontgc,x+delta,current_y,0,p);
				}
				deltay=r2d_get_char_height(p);
				
			 }
			 else
			 {
				 
				if (((T_R2D_GC*)gc)->script_mode==R2D_LEFT_TO_RIGHT)
			      delta=r2d_get_char_dx(p);
				else
                  delta=-r2d_get_char_dx(p);
			 }
		   }
		 }
		
       
    }
	if (the_char!=0xa)
	  x+=delta;

	if ((x-x_org)>maxx)
				 maxx=x-x_org;
			 
	if ((x_org-x)>maxx)
				 maxx=x_org-x;

	/*if (((T_R2D_GC*)gc)->script_mode==R2D_LEFT_TO_RIGHT)
	  *result=x-x_org;
	else
      *result=x_org-x;*/

	*width=maxx;
	*height=y-y_org+delta_line;

    if (draw)
    {
        r2d_set_drawing_mode(gc,the_mode);

        r2d_context_unlock(fontgc);
        r2d_context_unlock(cache_gc);
        r2d_release_context(fontgc);
        r2d_release_context(cache_gc);

	    r2d_check_and_send_event(gc);
    }

	return(err);
	
}

T_R2D_ERROR   r2d_get_text_width(T_R2D_GC_PTR gc,T_R2D_UTF16 *the_text,UINT16 *size)
{
    UINT16 x,y;
	T_R2D_ERROR err;
	err=R2D_OK;


    err=r2d_low_draw_text(gc,0,0,the_text,0,-1,&x,&y);

	if (err!=R2D_OK)
	 *size=1;
    else
	{
	  if (x>=0)
        *size=x;
      else
        *size=-x;
	}

	return(err);
}

T_R2D_ERROR   r2d_get_width_of_chars(T_R2D_GC_PTR gc,T_R2D_UTF16 *the_text,
									 UINT16 nb_chars,UINT16 *size)
{
    UINT16 x,y;
	T_R2D_ERROR err;

    err=r2d_low_draw_text(gc,0,0,the_text,0,nb_chars,&x,&y);


	if (err!=R2D_OK)
		*size=1;
    else
	{
	  if (x>=0)
        *size=x;
      else
        *size=-x;
	}

	return(err);
}


T_R2D_ERROR          r2d_draw_text(T_R2D_GC_PTR gc,INT16 x,INT16 y,T_R2D_UTF16 *the_text)
{
	UINT16 r,h;
	return(r2d_low_draw_text(gc,x,y,the_text,R2D_TEXT_DRAW,-1,&r,&h));
}


T_R2D_ERROR          r2d_draw_chars(T_R2D_GC_PTR gc,INT16 x,INT16 y,
									T_R2D_UTF16 *the_text,UINT16 nb_chars)
{
	UINT16 r,h;
	return(r2d_low_draw_text(gc,x,y,the_text,R2D_TEXT_DRAW,nb_chars,&r,&h));
}

T_R2D_ERROR   r2d_draw_chars_and_get_size(T_R2D_GC_PTR gc,INT16 x,INT16 y,T_R2D_UTF16 *the_text,
							 UINT16 nb_words16,UINT16 *width,UINT16 *height)
{
	return(r2d_low_draw_text(gc,x,y,the_text,R2D_TEXT_DRAW,nb_words16,width,height));
}

T_R2D_UTF16 *r2d_new_unicode_from_cstring(T_RVF_MB_ID bank,unsigned char *the_string)
{
 T_R2D_UTF16 *result,*p;
// INT16 i;
 INT16 index;

 R2D_MALLOC(bank,T_R2D_UTF16,sizeof(T_R2D_UTF16)*(strlen((char*)the_string)+1),result);
 if (result!=NULL)
 {
   p=result;
   while(*the_string!='\0')
   {
	 index=*the_string++;
     *p++ = R2D_WIN_LATIN1_TO_UNICODE[index];
   }
   *p++ = 0;
 }
 return(result);
}

T_R2D_UTF16 *r2d_new_unicode_from_pstring(T_RVF_MB_ID bank,unsigned char *the_string)
{
 T_R2D_UTF16 *result,*p;
 INT16 l,index;
// INT16 i;

 R2D_MALLOC(bank,T_R2D_UTF16,sizeof(T_R2D_UTF16)*(the_string[0]+1),result);
 if (result!=NULL)
 {
   p=result;
   l=*the_string++;

   while(l!=0)
   {
	 index=*the_string++;
     *p++ = R2D_WIN_LATIN1_TO_UNICODE[index];
     l--;
   }
   *p++ = 0;
 }
 return(result);
}


void          r2d_get_font_info(T_R2D_GC_PTR gc,INT16 *ascent,INT16 *descent,INT16 *leading)
{
   INT32 *p;

    
   p=((T_R2D_GC*)gc)->font_metrics;

   *p--;
   *leading=*--p;
   *descent=*--p;
   *ascent=*--p;
   
}

INT16 r2d_str_nb_word16(T_R2D_UTF16 *l)
{
	INT16 res;
	T_R2D_UTF16 *p;

	if (l==NULL)
		return 0;

	p=l;
	res=0;

	while(*p!=0)
	{
		p++;
		res++;
	}
	return(res);
}

T_R2D_UTF16 *r2d_duplicate_text(T_RVF_MB_ID bank,T_R2D_UTF16 *l)
{
	T_R2D_UTF16 *ret;
	INT16 len;

	if (l==NULL)
		return(NULL);

	len=r2d_str_nb_word16(l);
	rvf_get_buf(bank,(len+1)*sizeof(T_R2D_UTF16),(void*)&ret);
	if (ret)
	{
		memcpy(ret,l,(len+1)*2);
		return(ret);
	}
    else return(NULL);
}



T_R2D_SCRIPT_MODE r2d_get_script_mode(T_R2D_GC_PTR gc)
{
	return(((T_R2D_GC*)gc)->script_mode);
}

void r2d_set_script_mode(T_R2D_GC_PTR gc,T_R2D_SCRIPT_MODE mode)
{
	((T_R2D_GC*)gc)->script_mode=mode;
}