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

// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

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