[occt.git] / src / Xw / Xw_draw_text.cxx

#define GG002   /*GG_020197
                Renvoyer la hauteur du texte et non de la font
*/

#define GG010   /*GG_150197
                Ameliorer la conformiter de l'underline vis a vis de WORLD
*/

#include <Xw_Extension.h>

	/* ifdef then trace on */
#ifdef TRACE
#define TRACE_DRAW_TEXT
#endif

/*
   STATUS Xw_draw_text (awindow,x,y,text,angle,mode):
   XW_EXT_WINDOW *awindow
   float x,y		Position of the beginning of text in world coordinate
   char text[]		String to display
   float angle		Rotated text angle
   mode			1 si outline

	Display text in current QG set by set_text_attrib .

	returns ERROR if text length > MAXCHARS
	returns SUCCESS if successful

*/

#define MAXCOORD 32767
#define MINCOORD -32768

#define XROTATE(x,y) (x*cosa + y*sina)
#define YROTATE(x,y) (y*cosa - x*sina)

static XW_EXT_LTEXT *ptextlist ;
static XW_EXT_CHAR *ptextdesc ;

#ifdef XW_PROTOTYPE
XW_STATUS Xw_draw_text (void* awindow,float x,float y,char* text,float angle,int mode)
#else
XW_STATUS Xw_draw_text (awindow,x,y,text,angle,mode)
void *awindow;
float x,y ;
float angle ;
char *text ;
int mode ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow;
XW_EXT_BUFFER *pbuffer ;
int ntext,nchar,length,bindex,ix,iy,textindex,textfont,texttype ;
XW_ATTRIB textcode;

        if( !Xw_isdefine_window(pwindow) ) {
            /*ERROR*Bad EXT_WINDOW Address*/
            Xw_set_error(24,"Xw_draw_text",pwindow) ;
            return (XW_ERROR) ;
        }

	length = strlen(text) ;
	if( length+1 > MAXCHARS ) {
	    length = MAXCHARS-1 ;
	    /*ERROR*Too big text string*/
	    Xw_set_error(38,"Xw_draw_text",&length) ;
	    return (XW_ERROR) ;
	}

	bindex = _BINDEX ;
	pbuffer = &_BUFFER(bindex) ;
        for( ptextlist = pbuffer->pltextlist ; ptextlist ;
                    		ptextlist = (XW_EXT_LTEXT*)ptextlist->link ) {
            if( ptextlist->ntext < MAXLTEXTS ) break ;
        }

        if( !ptextlist ) {
                ptextlist = Xw_add_text_structure(pbuffer) ;
        }

	if( !ptextlist ) return XW_ERROR ;

        for( ptextdesc = pbuffer->ptextdesc ; ptextdesc ;
                    		ptextdesc = (XW_EXT_CHAR*)ptextdesc->link ) {
            if( ptextdesc->nchar + length < MAXCHARS ) break ;
        }

        if( !ptextdesc ) {
                ptextdesc = Xw_add_text_desc_structure(pbuffer) ;
        }

	if( !ptextdesc ) return XW_ERROR ;

//OCC186
	ix = PXPOINT(x, pwindow->xratio) ;
	iy = PYPOINT(y, pwindow->attributes.height, pwindow->yratio) ;
//OCC186

        ix = max(min(ix,MAXCOORD),MINCOORD);
        iy = max(min(iy,MAXCOORD),MINCOORD);

        textindex = pwindow->textindex ;
        textcode = pwindow->qgtext[textindex].code ;
        textfont = QGFONT(textcode);
        texttype = QGTYPE(textcode);
        if( mode ) texttype |= XW_EXTENDEDTEXT_OUTLINE ;

	ntext = ptextlist->ntext ;
	nchar = ptextdesc->nchar ;
	ptextlist->modes[ntext] = texttype ;
	ptextlist->texts[ntext] = length ;
	ptextlist->ptexts[ntext] = &ptextdesc->chars[nchar] ;
	ptextlist->rpoints[ntext].x = ix ;
	ptextlist->rpoints[ntext].y = iy ;
	ptextlist->rscalex[ntext] = 1. ;
	ptextlist->rscaley[ntext] = 1. ;
	ptextlist->slants[ntext] = 0. ;
	strcpy(ptextlist->ptexts[ntext],text) ;
        if( angle > 0. ) {
            while( angle > 2.*PI ) angle -= 2.*PI ;
        } else if( angle < 0. ) {
            while( angle < -2.*PI ) angle += 2.*PI ;
        }
	ptextlist->rangles[ntext] = angle ;
 
	nchar += length+1 ;
	ptextlist->ntext++ ;
	ptextdesc->nchar = nchar ;

	if( bindex > 0 ) {
	    XFontStruct *pfontinfo = _FONTMAP->fonts[textfont] ;
#ifdef GG002
	    int xmin,ymin,xmax,ymax,dir,fascent,fdescent;
	    XCharStruct overall;
	    XTextExtents(pfontinfo,text,length,
                                &dir,&fascent,&fdescent,&overall);
            xmin = overall.lbearing;
	    xmax = overall.width;
            ymin = -overall.ascent;
            ymax = overall.descent;
#else
            int xmin = 0 ;
            int xmax = XTextWidth(pfontinfo,text,length) ;
            int ymin = -pfontinfo->ascent ;
            int ymax = pfontinfo->descent ;
#endif
            pbuffer->isempty = False ;
            if( texttype & XW_EXTENDEDTEXT_UNDERLINE ) {
#ifdef GG010
              if( _FONTMAP->fratios[textfont] <= 0. )
#endif
              ymax += 2*max(2,(ymax-ymin)/8) ;
            }
//            if( abs(angle) > 0. ) {
            if( fabs(angle) > 0. ) {
              float cosa = cos((double)angle) ;
              float sina = sin((double)angle) ; 
              int tx,ty ; 
              tx = (int )( ix + XROTATE(xmin,ymin) ); 
              ty = (int )( iy + YROTATE(xmin,ymin) );  
              pbuffer->rxmin = min(pbuffer->rxmin,tx) ;         
              pbuffer->rymin = min(pbuffer->rymin,ty) ;         
              pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
              pbuffer->rymax = max(pbuffer->rymax,ty) ;
              tx = (int )( ix + XROTATE(xmax,ymax) );    
              ty = (int )( iy + YROTATE(xmax,ymax) );  
              pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
              pbuffer->rymin = min(pbuffer->rymin,ty) ;
              pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
              pbuffer->rymax = max(pbuffer->rymax,ty) ;
              tx = (int )( ix + XROTATE(xmax,ymin) );
              ty = (int )( iy + YROTATE(xmax,ymin) );
              pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
              pbuffer->rymin = min(pbuffer->rymin,ty) ;
              pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
              pbuffer->rymax = max(pbuffer->rymax,ty) ;
              tx = (int )( ix + XROTATE(xmin,ymax) );
              ty = (int )( iy + YROTATE(xmin,ymax) );
              pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
              pbuffer->rymin = min(pbuffer->rymin,ty) ;
              pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
              pbuffer->rymax = max(pbuffer->rymax,ty) ;
            } else {
              pbuffer->rxmin = min(pbuffer->rxmin,ix+xmin) ;
              pbuffer->rymin = min(pbuffer->rymin,iy+ymin) ;
              pbuffer->rxmax = max(pbuffer->rxmax,ix+xmax) ;
              pbuffer->rymax = max(pbuffer->rymax,iy+ymax) ;
            }
	} else {
	    int index = pwindow->textindex ;
	    Xw_draw_pixel_texts(pwindow,ptextlist,
			pwindow->qgtext[index].gc,
			pwindow->qgtext[index].code) ;
    	    ptextlist->ntext = 0 ;
	    ptextdesc->nchar = 0 ;
	}


#ifdef  TRACE_DRAW_TEXT
if( Xw_get_trace() > 2 ) {
    printf(" Xw_draw_text(%lx,%f,%f,'%s',%f)\n",(long ) pwindow,x,y,text,angle) ;
}
#endif

	return (XW_SUCCESS);
}

#ifdef XW_PROTOTYPE
void Xw_draw_pixel_texts(XW_EXT_WINDOW* pwindow,XW_EXT_LTEXT* ptextlist,
							GC gctext,XW_ATTRIB code)
#else
void Xw_draw_pixel_texts(pwindow,ptextlist,gctext,code)
XW_EXT_WINDOW *pwindow ;
XW_EXT_LTEXT *ptextlist ;
GC gctext ;
XW_ATTRIB code ;
#endif /*XW_PROTOTYPE*/
{
int i,ix,iy,mode,length,font = QGFONT(code),type = QGTYPE(code) ;
float angle,cosa,sina ;
char *pchar ;

	for( i=0 ; i<ptextlist->ntext ; i++ ) {
	    length = ptextlist->texts[i] ;
	    if( length <= 0 ) continue ;
	    if( ptextlist->isupdated ) {
	      ix = ptextlist->upoints[i].x ;
	      iy = ptextlist->upoints[i].y ;
	      angle = ptextlist->uangles[i] ;
	    } else {
	      ix = ptextlist->rpoints[i].x ;
	      iy = ptextlist->rpoints[i].y ;
	      angle = ptextlist->rangles[i] ;
	    }
	    mode = ptextlist->modes[i] ;
	    pchar = ptextlist->ptexts[i] ;
	    if( type & XW_EXTENDEDTEXT_MINHEIGHT ) {
//OCC186
              int rcx = max(4,PVALUE(FROMMILLIMETER(_FONTMAP->ssizex[font]), 
				     pwindow->xratio, pwindow->yratio)/3);
              int rcy = max(4,PVALUE(FROMMILLIMETER(_FONTMAP->ssizey[font]), 
				     pwindow->xratio, pwindow->yratio)/3);
//OCC186
             if( angle == 0. ) {
                XFillArc(_DISPLAY,_DRAWABLE,gctext,
                                        ix-rcx,iy-rcy,2*rcx,2*rcy,0,360*64) ;
              } else {
		int dx,dy ;
                cosa = cos((double)angle) ;
                sina = sin((double)angle) ;
                dx = (int )( XROTATE(0,rcx) );
                dy = (int )( YROTATE(0,rcy) );
                XFillArc(_DISPLAY,_DRAWABLE,gctext,
                                        ix-dx,iy-dy,2*rcx,2*rcy,0,360*64) ;
              }  
	    } else {
	      XFontStruct *pfontinfo = _FONTMAP->fonts[font] ;
              int xmin,ymin,xmax,ymax ;
	      if( angle == 0. ) {
                if( type & XW_EXTENDEDTEXT_UNDERLINE ) {
#ifdef GG002
	    	  int dir,fascent,fdescent;
	    	  XCharStruct overall;
	    	  XTextExtents(pfontinfo,pchar,length,
                                &dir,&fascent,&fdescent,&overall);
            	  xmin = overall.lbearing;
	    	  xmax = overall.width;
            	  ymin = -overall.ascent;
            	  ymax = overall.descent;
#else
                  xmin = 0 ;
                  xmax = XTextWidth(pfontinfo,pchar,length) ;
                  ymin = -pfontinfo->ascent ;
                  ymax = pfontinfo->descent ;
#endif
#ifdef GG010
                  if( _FONTMAP->fratios[font] > 0. ) {
//OCC186
                    ymax = PVALUE(0.6*_FONTMAP->fratios[font]*
                                        FROMMILLIMETER(_FONTMAP->ssizey[font]),
				  pwindow->xratio, pwindow->yratio);
//OCC186
                  } else {
                    ymax = max(2,(ymax-ymin)/8) ;
                  }
#else
                  ymax += max(2,(ymax-ymin)/8) ;
#endif
                  XDrawLine(_DISPLAY,_DRAWABLE,gctext,
					ix+xmin,iy+ymax,ix+xmax,iy+ymax) ;
                }
	        XDrawString(_DISPLAY,_DRAWABLE,gctext,ix,iy,pchar,length) ;
	      } else {
		int w,j,tx,ty ;
		cosa = cos((double)angle) ;
		sina = sin((double)angle) ;

                if( type & XW_EXTENDEDTEXT_UNDERLINE ) {
		  int x1,y1,x2,y2 ;
#ifdef GG002
	    	  int dir,fascent,fdescent;
	    	  XCharStruct overall;
	    	  XTextExtents(pfontinfo,pchar,length,
                                &dir,&fascent,&fdescent,&overall);
            	  xmin = overall.lbearing;
	    	  xmax = overall.width;
            	  ymin = -overall.ascent;
            	  ymax = overall.descent;
#else
                  xmin = 0 ;
                  xmax = XTextWidth(pfontinfo,pchar,length) ;
                  ymin = -pfontinfo->ascent ;
                  ymax = pfontinfo->descent ;
#endif
#ifdef GG010
                  if( _FONTMAP->fratios[font] > 0. ) {
//OCC186
                    ymax = PVALUE(0.6*_FONTMAP->fratios[font]*
                                        FROMMILLIMETER(_FONTMAP->ssizey[font]), 
				  pwindow->xratio, pwindow->yratio);
//OCC186
                  } else {
                    ymax = max(2,(ymax-ymin)/8) ;
                  }
#else
                  ymax += max(2,(ymax-ymin)/8) ;
#endif
                  x1 = (int )( XROTATE(xmin,ymax) );
                  y1 = (int )( YROTATE(xmin,ymax) );
                  x2 = (int )( XROTATE(xmax,ymax) );
                  y2 = (int )( YROTATE(xmax,ymax) );
                  XDrawLine(_DISPLAY,_DRAWABLE,gctext,
					ix+x1,iy+y1,ix+x2,iy+y2) ;
		}
                for( j=tx=ty=0 ; j<length ; j++) {
                    XDrawString(_DISPLAY,_DRAWABLE,gctext,
                                                ix+tx,iy-ty,&pchar[j],1) ;
                    w = XTextWidth(pfontinfo,pchar,j);
                    tx = ROUND(w*cosa) ;
                    ty = ROUND(w*sina) ;
                }
	      }
	    }
	}
}

#ifdef XW_PROTOTYPE
XW_EXT_LTEXT* Xw_add_text_structure(XW_EXT_BUFFER* pbuflist )
#else
XW_EXT_LTEXT* Xw_add_text_structure(pbuflist )
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Create and Insert at end one Extended text structure in the
        text List

        returns Extended text address if successful
                or NULL if Bad Allocation
*/
{
XW_EXT_LTEXT *ptext ;

        ptext = (XW_EXT_LTEXT*) Xw_malloc(sizeof(XW_EXT_LTEXT)) ;
        if( ptext ) {
            ptext->link = pbuflist->pltextlist ;
            ptext->isupdated = False ;
            ptext->ntext = 0 ;
	    pbuflist->pltextlist = ptext ;
        } else {
	    /*ERROR*EXT_TEXT Allocation failed*/
	    Xw_set_error(39,"Xw_add_text_structure",NULL) ;
        }

        return (ptext) ;
}

#ifdef XW_PROTOTYPE
XW_STATUS Xw_del_text_structure(XW_EXT_BUFFER* pbuflist)
#else
XW_STATUS Xw_del_text_structure(pbuflist)
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Remove ALL Extended text structure in the
        text List

        SUCCESS always
*/
{
XW_EXT_LTEXT *ptext,*qtext ;

        for( ptext = pbuflist->pltextlist ; ptext ; ptext = qtext ) {
            qtext = (XW_EXT_LTEXT*)ptext->link ;
            Xw_free(ptext) ;
        }
	pbuflist->pltextlist = NULL ;

        return (XW_SUCCESS) ;
}

#ifdef XW_PROTOTYPE
XW_EXT_CHAR* Xw_add_text_desc_structure(XW_EXT_BUFFER* pbuflist )
#else
XW_EXT_CHAR* Xw_add_text_desc_structure(pbuflist )
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Create and Insert at end one Extended char structure in the
        char List

        returns Extended char address if successful
                or NULL if Bad Allocation
*/
{
XW_EXT_CHAR *pchar ;

        pchar = (XW_EXT_CHAR*) Xw_malloc(sizeof(XW_EXT_CHAR)) ;
        if( pchar ) {
            pchar->link = pbuflist->ptextdesc ;
            pchar->nchar = 0 ;
	    pbuflist->ptextdesc = pchar ;
        } else {
	    /*ERROR*EXT_CHAR Allocation failed*/
	    Xw_set_error(118,"Xw_add_text_desc_structure",NULL) ;
        }

        return (pchar) ;
}

#ifdef XW_PROTOTYPE
XW_STATUS Xw_del_text_desc_structure(XW_EXT_BUFFER* pbuflist)
#else
XW_STATUS Xw_del_text_desc_structure(pbuflist)
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Remove ALL Extended char structure in the
        char List

        SUCCESS always
*/
{
XW_EXT_CHAR *pchar,*qchar ;

        for( pchar = pbuflist->ptextdesc ; pchar ; pchar = qchar ) {
            qchar = (XW_EXT_CHAR*)pchar->link ;
            Xw_free(pchar) ;
        }
	pbuflist->ptextdesc = NULL ;

        return (XW_SUCCESS) ;
}
Commit	Line	Data
7fd59977	1	#define GG002 /*GG_020197
	2	Renvoyer la hauteur du texte et non de la font
	3	*/
	4
	5	#define GG010 /*GG_150197
	6	Ameliorer la conformiter de l'underline vis a vis de WORLD
	7	*/
	8
	9	#include <Xw_Extension.h>
	10
	11	/* ifdef then trace on */
	12	#ifdef TRACE
	13	#define TRACE_DRAW_TEXT
	14	#endif
	15
	16	/*
	17	STATUS Xw_draw_text (awindow,x,y,text,angle,mode):
	18	XW_EXT_WINDOW *awindow
	19	float x,y Position of the beginning of text in world coordinate
	20	char text[] String to display
	21	float angle Rotated text angle
	22	mode 1 si outline
	23
	24	Display text in current QG set by set_text_attrib .
	25
	26	returns ERROR if text length > MAXCHARS
	27	returns SUCCESS if successful
	28
	29	*/
	30
	31	#define MAXCOORD 32767
	32	#define MINCOORD -32768
	33
	34	#define XROTATE(x,y) (xcosa + ysina)
	35	#define YROTATE(x,y) (ycosa - xsina)
	36
	37	static XW_EXT_LTEXT *ptextlist ;
	38	static XW_EXT_CHAR *ptextdesc ;
	39
	40	#ifdef XW_PROTOTYPE
	41	XW_STATUS Xw_draw_text (void* awindow,float x,float y,char* text,float angle,int mode)
	42	#else
	43	XW_STATUS Xw_draw_text (awindow,x,y,text,angle,mode)
	44	void *awindow;
	45	float x,y ;
	46	float angle ;
	47	char *text ;
	48	int mode ;
	49	#endif /XW_PROTOTYPE/
	50	{
	51	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow;
	52	XW_EXT_BUFFER *pbuffer ;
	53	int ntext,nchar,length,bindex,ix,iy,textindex,textfont,texttype ;
	54	XW_ATTRIB textcode;
	55
	56	if( !Xw_isdefine_window(pwindow) ) {
	57	/ERRORBad EXT_WINDOW Address*/
	58	Xw_set_error(24,"Xw_draw_text",pwindow) ;
	59	return (XW_ERROR) ;
	60	}
	61
	62	length = strlen(text) ;
	63	if( length+1 > MAXCHARS ) {
	64	length = MAXCHARS-1 ;
65	/ERRORToo big text string*/
66	Xw_set_error(38,"Xw_draw_text",&length) ;
67	return (XW_ERROR) ;
68	}
69
70	bindex = _BINDEX ;
71	pbuffer = &_BUFFER(bindex) ;
72	for( ptextlist = pbuffer->pltextlist ; ptextlist ;
73	ptextlist = (XW_EXT_LTEXT*)ptextlist->link ) {
74	if( ptextlist->ntext < MAXLTEXTS ) break ;
75	}
76
77	if( !ptextlist ) {
78	ptextlist = Xw_add_text_structure(pbuffer) ;
79	}
80
81	if( !ptextlist ) return XW_ERROR ;
82
83	for( ptextdesc = pbuffer->ptextdesc ; ptextdesc ;
84	ptextdesc = (XW_EXT_CHAR*)ptextdesc->link ) {
85	if( ptextdesc->nchar + length < MAXCHARS ) break ;
86	}
87
88	if( !ptextdesc ) {
89	ptextdesc = Xw_add_text_desc_structure(pbuffer) ;
90	}
91
92	if( !ptextdesc ) return XW_ERROR ;
93
94	//OCC186
95	ix = PXPOINT(x, pwindow->xratio) ;
96	iy = PYPOINT(y, pwindow->attributes.height, pwindow->yratio) ;
97	//OCC186
98
99	ix = max(min(ix,MAXCOORD),MINCOORD);
100	iy = max(min(iy,MAXCOORD),MINCOORD);
101
102	textindex = pwindow->textindex ;
103	textcode = pwindow->qgtext[textindex].code ;
104	textfont = QGFONT(textcode);
105	texttype = QGTYPE(textcode);
106	if( mode ) texttype \|= XW_EXTENDEDTEXT_OUTLINE ;
107
108	ntext = ptextlist->ntext ;
109	nchar = ptextdesc->nchar ;
110	ptextlist->modes[ntext] = texttype ;
111	ptextlist->texts[ntext] = length ;
112	ptextlist->ptexts[ntext] = &ptextdesc->chars[nchar] ;
113	ptextlist->rpoints[ntext].x = ix ;
114	ptextlist->rpoints[ntext].y = iy ;
115	ptextlist->rscalex[ntext] = 1. ;
116	ptextlist->rscaley[ntext] = 1. ;
117	ptextlist->slants[ntext] = 0. ;
118	strcpy(ptextlist->ptexts[ntext],text) ;
119	if( angle > 0. ) {
120	while( angle > 2.PI ) angle -= 2.PI ;
121	} else if( angle < 0. ) {
122	while( angle < -2.PI ) angle += 2.PI ;
123	}
124	ptextlist->rangles[ntext] = angle ;
125
126	nchar += length+1 ;
127	ptextlist->ntext++ ;
128	ptextdesc->nchar = nchar ;
129
130	if( bindex > 0 ) {
131	XFontStruct *pfontinfo = _FONTMAP->fonts[textfont] ;
132	#ifdef GG002
133	int xmin,ymin,xmax,ymax,dir,fascent,fdescent;
134	XCharStruct overall;
135	XTextExtents(pfontinfo,text,length,
136	&dir,&fascent,&fdescent,&overall);
137	xmin = overall.lbearing;
138	xmax = overall.width;
139	ymin = -overall.ascent;
140	ymax = overall.descent;
141	#else
142	int xmin = 0 ;
143	int xmax = XTextWidth(pfontinfo,text,length) ;
144	int ymin = -pfontinfo->ascent ;
145	int ymax = pfontinfo->descent ;
146	#endif
147	pbuffer->isempty = False ;
148	if( texttype & XW_EXTENDEDTEXT_UNDERLINE ) {
149	#ifdef GG010
150	if( _FONTMAP->fratios[textfont] <= 0. )
151	#endif
152	ymax += 2*max(2,(ymax-ymin)/8) ;
153	}
154	// if( abs(angle) > 0. ) {
155	if( fabs(angle) > 0. ) {
156	float cosa = cos((double)angle) ;
157	float sina = sin((double)angle) ;
158	int tx,ty ;
159	tx = (int )( ix + XROTATE(xmin,ymin) );
160	ty = (int )( iy + YROTATE(xmin,ymin) );
161	pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
162	pbuffer->rymin = min(pbuffer->rymin,ty) ;
163	pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
164	pbuffer->rymax = max(pbuffer->rymax,ty) ;
165	tx = (int )( ix + XROTATE(xmax,ymax) );
166	ty = (int )( iy + YROTATE(xmax,ymax) );
167	pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
168	pbuffer->rymin = min(pbuffer->rymin,ty) ;
169	pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
170	pbuffer->rymax = max(pbuffer->rymax,ty) ;
171	tx = (int )( ix + XROTATE(xmax,ymin) );
172	ty = (int )( iy + YROTATE(xmax,ymin) );
173	pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
174	pbuffer->rymin = min(pbuffer->rymin,ty) ;
175	pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
176	pbuffer->rymax = max(pbuffer->rymax,ty) ;
177	tx = (int )( ix + XROTATE(xmin,ymax) );
178	ty = (int )( iy + YROTATE(xmin,ymax) );
179	pbuffer->rxmin = min(pbuffer->rxmin,tx) ;
180	pbuffer->rymin = min(pbuffer->rymin,ty) ;
181	pbuffer->rxmax = max(pbuffer->rxmax,tx) ;
182	pbuffer->rymax = max(pbuffer->rymax,ty) ;
183	} else {
184	pbuffer->rxmin = min(pbuffer->rxmin,ix+xmin) ;
185	pbuffer->rymin = min(pbuffer->rymin,iy+ymin) ;
186	pbuffer->rxmax = max(pbuffer->rxmax,ix+xmax) ;
187	pbuffer->rymax = max(pbuffer->rymax,iy+ymax) ;
188	}
189	} else {
190	int index = pwindow->textindex ;
191	Xw_draw_pixel_texts(pwindow,ptextlist,
192	pwindow->qgtext[index].gc,
193	pwindow->qgtext[index].code) ;
194	ptextlist->ntext = 0 ;
195	ptextdesc->nchar = 0 ;
196	}
197
198
199	#ifdef TRACE_DRAW_TEXT
200	if( Xw_get_trace() > 2 ) {
201	printf(" Xw_draw_text(%lx,%f,%f,'%s',%f)\n",(long ) pwindow,x,y,text,angle) ;
202	}
203	#endif
204
205	return (XW_SUCCESS);
206	}
207
208	#ifdef XW_PROTOTYPE
209	void Xw_draw_pixel_texts(XW_EXT_WINDOW* pwindow,XW_EXT_LTEXT* ptextlist,
210	GC gctext,XW_ATTRIB code)
211	#else
212	void Xw_draw_pixel_texts(pwindow,ptextlist,gctext,code)
213	XW_EXT_WINDOW *pwindow ;
214	XW_EXT_LTEXT *ptextlist ;
215	GC gctext ;
216	XW_ATTRIB code ;
217	#endif /XW_PROTOTYPE/
218	{
219	int i,ix,iy,mode,length,font = QGFONT(code),type = QGTYPE(code) ;
220	float angle,cosa,sina ;
221	char *pchar ;
222
223	for( i=0 ; i<ptextlist->ntext ; i++ ) {
224	length = ptextlist->texts[i] ;
225	if( length <= 0 ) continue ;
226	if( ptextlist->isupdated ) {
227	ix = ptextlist->upoints[i].x ;
228	iy = ptextlist->upoints[i].y ;
229	angle = ptextlist->uangles[i] ;
230	} else {
231	ix = ptextlist->rpoints[i].x ;
232	iy = ptextlist->rpoints[i].y ;
233	angle = ptextlist->rangles[i] ;
234	}
235	mode = ptextlist->modes[i] ;
236	pchar = ptextlist->ptexts[i] ;
237	if( type & XW_EXTENDEDTEXT_MINHEIGHT ) {
238	//OCC186
239	int rcx = max(4,PVALUE(FROMMILLIMETER(_FONTMAP->ssizex[font]),
240	pwindow->xratio, pwindow->yratio)/3);
241	int rcy = max(4,PVALUE(FROMMILLIMETER(_FONTMAP->ssizey[font]),
242	pwindow->xratio, pwindow->yratio)/3);
243	//OCC186
244	if( angle == 0. ) {
245	XFillArc(_DISPLAY,_DRAWABLE,gctext,
246	ix-rcx,iy-rcy,2rcx,2rcy,0,360*64) ;
247	} else {
248	int dx,dy ;
249	cosa = cos((double)angle) ;
250	sina = sin((double)angle) ;
251	dx = (int )( XROTATE(0,rcx) );
252	dy = (int )( YROTATE(0,rcy) );
253	XFillArc(_DISPLAY,_DRAWABLE,gctext,
254	ix-dx,iy-dy,2rcx,2rcy,0,360*64) ;
255	}
256	} else {
257	XFontStruct *pfontinfo = _FONTMAP->fonts[font] ;
258	int xmin,ymin,xmax,ymax ;
259	if( angle == 0. ) {
260	if( type & XW_EXTENDEDTEXT_UNDERLINE ) {
261	#ifdef GG002
262	int dir,fascent,fdescent;
263	XCharStruct overall;
264	XTextExtents(pfontinfo,pchar,length,
265	&dir,&fascent,&fdescent,&overall);
266	xmin = overall.lbearing;
267	xmax = overall.width;
268	ymin = -overall.ascent;
269	ymax = overall.descent;
270	#else
271	xmin = 0 ;
272	xmax = XTextWidth(pfontinfo,pchar,length) ;
273	ymin = -pfontinfo->ascent ;
274	ymax = pfontinfo->descent ;
275	#endif
276	#ifdef GG010
277	if( _FONTMAP->fratios[font] > 0. ) {
278	//OCC186
279	ymax = PVALUE(0.6_FONTMAP->fratios[font]
280	FROMMILLIMETER(_FONTMAP->ssizey[font]),
281	pwindow->xratio, pwindow->yratio);
282	//OCC186
283	} else {
284	ymax = max(2,(ymax-ymin)/8) ;
285	}
286	#else
287	ymax += max(2,(ymax-ymin)/8) ;
288	#endif
289	XDrawLine(_DISPLAY,_DRAWABLE,gctext,
290	ix+xmin,iy+ymax,ix+xmax,iy+ymax) ;
291	}
292	XDrawString(_DISPLAY,_DRAWABLE,gctext,ix,iy,pchar,length) ;
293	} else {
294	int w,j,tx,ty ;
295	cosa = cos((double)angle) ;
296	sina = sin((double)angle) ;
297
298	if( type & XW_EXTENDEDTEXT_UNDERLINE ) {
299	int x1,y1,x2,y2 ;
300	#ifdef GG002
301	int dir,fascent,fdescent;
302	XCharStruct overall;
303	XTextExtents(pfontinfo,pchar,length,
304	&dir,&fascent,&fdescent,&overall);
305	xmin = overall.lbearing;
306	xmax = overall.width;
307	ymin = -overall.ascent;
308	ymax = overall.descent;
309	#else
310	xmin = 0 ;
311	xmax = XTextWidth(pfontinfo,pchar,length) ;
312	ymin = -pfontinfo->ascent ;
313	ymax = pfontinfo->descent ;
314	#endif
315	#ifdef GG010
316	if( _FONTMAP->fratios[font] > 0. ) {
317	//OCC186
318	ymax = PVALUE(0.6_FONTMAP->fratios[font]
319	FROMMILLIMETER(_FONTMAP->ssizey[font]),
320	pwindow->xratio, pwindow->yratio);
321	//OCC186
322	} else {
323	ymax = max(2,(ymax-ymin)/8) ;
324	}
325	#else
326	ymax += max(2,(ymax-ymin)/8) ;
327	#endif
328	x1 = (int )( XROTATE(xmin,ymax) );
329	y1 = (int )( YROTATE(xmin,ymax) );
330	x2 = (int )( XROTATE(xmax,ymax) );
331	y2 = (int )( YROTATE(xmax,ymax) );
332	XDrawLine(_DISPLAY,_DRAWABLE,gctext,
333	ix+x1,iy+y1,ix+x2,iy+y2) ;
334	}
335	for( j=tx=ty=0 ; j<length ; j++) {
336	XDrawString(_DISPLAY,_DRAWABLE,gctext,
337	ix+tx,iy-ty,&pchar[j],1) ;
338	w = XTextWidth(pfontinfo,pchar,j);
339	tx = ROUND(w*cosa) ;
340	ty = ROUND(w*sina) ;
341	}
342	}
343	}
344	}
345	}
346
347	#ifdef XW_PROTOTYPE
348	XW_EXT_LTEXT* Xw_add_text_structure(XW_EXT_BUFFER* pbuflist )
349	#else
350	XW_EXT_LTEXT* Xw_add_text_structure(pbuflist )
351	XW_EXT_BUFFER *pbuflist ;
352	#endif /XW_PROTOTYPE/
353	/*
354	Create and Insert at end one Extended text structure in the
355	text List
356
357	returns Extended text address if successful
358	or NULL if Bad Allocation
359	*/
360	{
361	XW_EXT_LTEXT *ptext ;
362
363	ptext = (XW_EXT_LTEXT*) Xw_malloc(sizeof(XW_EXT_LTEXT)) ;
364	if( ptext ) {
365	ptext->link = pbuflist->pltextlist ;
366	ptext->isupdated = False ;
367	ptext->ntext = 0 ;
368	pbuflist->pltextlist = ptext ;
369	} else {
370	/ERROREXT_TEXT Allocation failed*/
371	Xw_set_error(39,"Xw_add_text_structure",NULL) ;
372	}
373
374	return (ptext) ;
375	}
376
377	#ifdef XW_PROTOTYPE
378	XW_STATUS Xw_del_text_structure(XW_EXT_BUFFER* pbuflist)
379	#else
380	XW_STATUS Xw_del_text_structure(pbuflist)
381	XW_EXT_BUFFER *pbuflist ;
382	#endif /XW_PROTOTYPE/
383	/*
384	Remove ALL Extended text structure in the
385	text List
386
387	SUCCESS always
388	*/
389	{
390	XW_EXT_LTEXT ptext,qtext ;
391
392	for( ptext = pbuflist->pltextlist ; ptext ; ptext = qtext ) {
393	qtext = (XW_EXT_LTEXT*)ptext->link ;
394	Xw_free(ptext) ;
395	}
396	pbuflist->pltextlist = NULL ;
397
398	return (XW_SUCCESS) ;
399	}
400
401	#ifdef XW_PROTOTYPE
402	XW_EXT_CHAR* Xw_add_text_desc_structure(XW_EXT_BUFFER* pbuflist )
403	#else
404	XW_EXT_CHAR* Xw_add_text_desc_structure(pbuflist )
405	XW_EXT_BUFFER *pbuflist ;
406	#endif /XW_PROTOTYPE/
407	/*
408	Create and Insert at end one Extended char structure in the
409	char List
410
411	returns Extended char address if successful
412	or NULL if Bad Allocation
413	*/
414	{
415	XW_EXT_CHAR *pchar ;
416
417	pchar = (XW_EXT_CHAR*) Xw_malloc(sizeof(XW_EXT_CHAR)) ;
418	if( pchar ) {
419	pchar->link = pbuflist->ptextdesc ;
420	pchar->nchar = 0 ;
421	pbuflist->ptextdesc = pchar ;
422	} else {
423	/ERROREXT_CHAR Allocation failed*/
424	Xw_set_error(118,"Xw_add_text_desc_structure",NULL) ;
425	}
426
427	return (pchar) ;
428	}
429
430	#ifdef XW_PROTOTYPE
431	XW_STATUS Xw_del_text_desc_structure(XW_EXT_BUFFER* pbuflist)
432	#else
433	XW_STATUS Xw_del_text_desc_structure(pbuflist)
434	XW_EXT_BUFFER *pbuflist ;
435	#endif /XW_PROTOTYPE/
436	/*
437	Remove ALL Extended char structure in the
438	char List
439
440	SUCCESS always
441	*/
442	{
443	XW_EXT_CHAR pchar,qchar ;
444
445	for( pchar = pbuflist->ptextdesc ; pchar ; pchar = qchar ) {
446	qchar = (XW_EXT_CHAR*)pchar->link ;
447	Xw_free(pchar) ;
448	}
449	pbuflist->ptextdesc = NULL ;
450
451	return (XW_SUCCESS) ;
452	}