[occt.git] / src / Xw / Xw_draw_line.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 S3593           /*GG_130398
OPTIMISATION MFT
                        Activer le clipping de maniere optionnelle
*/

#include <Xw_Extension.h>

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

/*
   STATUS Xw_draw_line (awindow,npoint,x,y):
   XW_EXT_WINDOW *awindow
   int npoint		Polyline point number
   float *x,*y		Points Arrays


	Display continuous line in current QG set by set_line_attrib .
        Note that lines can be buffered depending of the DisplayMode context
        and Flush at Xw_flush time .

	returns ERROR if npoint > MAXPOINTS
	returns SUCCESS always 

*/

static int BeginLine = -1 ;
static XW_EXT_LINE *plinelist ;
static XW_EXT_POINT *plinedesc ;
static XSegment segment;

#ifdef XW_PROTOTYPE
XW_STATUS Xw_draw_line (void* awindow,int npoint,float* px,float* py) 
#else
XW_STATUS Xw_draw_line (awindow,npoint,px,py) 
void *awindow;
int npoint ;
float *px,*py ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*) awindow ;
XW_EXT_BUFFER *pbuffer ;
int i,nline,ldesc,bindex;
int x,y,lx=0,ly=0 ;

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

        if( npoint > MAXPOINTS ) {
	    npoint = MAXPOINTS;
	    /*ERROR*Too many points in LINE*/
	    Xw_set_error(28,"Xw_draw_line",&npoint) ;
            return (XW_ERROR) ;
        }

	bindex = _BINDEX ;
	pbuffer = &_BUFFER(bindex) ;
        for( plinelist = pbuffer->plinelist ; plinelist ;
                       	plinelist = (XW_EXT_LINE*)plinelist->link ) {
            if( plinelist->nline < MAXLINES ) break ;
        }

        if( !plinelist ) {
            plinelist = Xw_add_polyline_structure(pbuffer) ;
        }

	if( !plinelist ) return XW_ERROR ;

        for( plinedesc = pbuffer->plinedesc ; plinedesc ;
                       	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
            if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
        }

        if( !plinedesc ) {
            plinedesc = Xw_add_line_desc_structure(pbuffer) ;
        }

	if( !plinedesc ) return XW_ERROR ;

	nline = plinelist->nline ;
	ldesc = plinedesc->npoint ;
	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
	for( i=0 ; i<npoint ; i++ ) {
//OCC186
	  x = PXPOINT(px[i], pwindow->xratio) ;
	  y = PYPOINT(py[i], pwindow->attributes.height, pwindow->yratio) ;
//OCC186
#ifdef S3593
	  if( pwindow->clipflag ) {  
#endif
	    if( i > 0 ) {
	      int status;
	      status = Xw_clip_segment(pwindow,lx,ly,x,y,&segment);
	      if( status >= 0 ) { 
	        if( (i < 2) || (status & 0xF ) ) {
                  plinedesc->rpoints[ldesc].x = segment.x1 ;
                  plinedesc->rpoints[ldesc].y = segment.y1 ;
	          ldesc++;
	          if( bindex > 0 ) {
		    int xx = segment.x1,yy = segment.y1;
                    pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
                    pbuffer->rymin = min(pbuffer->rymin,yy) ;
                    pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
                    pbuffer->rymax = max(pbuffer->rymax,yy) ;
	          }
	        }
                plinedesc->rpoints[ldesc].x = segment.x2 ;
                plinedesc->rpoints[ldesc].y = segment.y2 ;
	        ldesc++;
	        if( bindex > 0 ) {
	 	  int xx = segment.x2,yy = segment.y2;
                  pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
                  pbuffer->rymin = min(pbuffer->rymin,yy) ;
                  pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
                  pbuffer->rymax = max(pbuffer->rymax,yy) ;
	        }
	      }
	    }
	    lx = x; ly = y;
#ifdef S3593
	  } else {
            plinedesc->rpoints[ldesc].x = x ;
            plinedesc->rpoints[ldesc].y = y ;
	    ldesc++ ;
	    if( bindex > 0 ) {
              pbuffer->rxmin = min(pbuffer->rxmin,x) ;
              pbuffer->rymin = min(pbuffer->rymin,y) ;
              pbuffer->rxmax = max(pbuffer->rxmax,x) ;
              pbuffer->rymax = max(pbuffer->rymax,y) ;
	    }
	  }
#endif
	}
	plinelist->lines[nline] = ldesc - plinedesc->npoint ;
	if( plinelist->lines[nline] > 1 ) {
	  plinedesc->npoint = ldesc ;
	  plinelist->nline++ ;
	  if( bindex > 0 ) {
	    pbuffer->isempty = False ;
	  } else if( BeginLine < 0 ) {
	    int index = pwindow->lineindex ;
	    Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc);
	    plinelist->nline = 0 ;
	    plinedesc->npoint = 0 ;
	  }
	}

#ifdef  TRACE_DRAW_LINE
if( Xw_get_trace() > 2 ) {
    printf(" Xw_draw_line(%lx,%d)\n",(long ) pwindow,npoint) ;
    for( i=0 ; i<npoint ; i++ ) {
	printf("	Point(%d) = {%f,%f}\n",i,px[i],py[i]) ;
    }
}
#endif

	return (XW_SUCCESS);
}

#ifdef XW_PROTOTYPE
void Xw_draw_pixel_lines (XW_EXT_WINDOW* pwindow,XW_EXT_LINE *plinelist,GC gc) 
#else
void Xw_draw_pixel_lines (pwindow,plinelist,gc) 
XW_EXT_WINDOW *pwindow;
XW_EXT_LINE *plinelist;
GC gc ;
#endif /*XW_PROTOTYPE*/
{
int i,npoint;
XPoint *ppoint ;

    for( i=0 ; i<plinelist->nline ; i++ ) {
        npoint = plinelist->lines[i] ;
	ppoint = plinelist->plines[i] ;
	if( plinelist->isupdated ) {
	  ppoint += MAXPOINTS ;
	}
	if( ppoint && npoint > 1 ) {
	  XDrawLines(_DISPLAY,_DRAWABLE,gc,ppoint,npoint,CoordModeOrigin) ;
	}
    }
}

/*
   STATUS Xw_begin_line (awindow,npoint):
   XW_EXT_WINDOW *awindow
   int npoint           Polyline point number


        Begin Polyline which must be filled by Xw_line_point and
                                     closed by Xw_close_line

        returns ERROR if npoint > MAXPOINTS
        returns SUCCESS if successful

*/

static int Npoint = 0;
static int Lx,Ly;
#ifdef XW_PROTOTYPE
XW_STATUS Xw_begin_line(void* awindow,int npoint)
#else
XW_STATUS Xw_begin_line(awindow,npoint)
void *awindow ;
int npoint ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
XW_EXT_BUFFER *pbuffer ;
int nline,ldesc,bindex ;

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

        if( npoint > MAXPOINTS ) {
	    npoint = MAXPOINTS ;
	    /*ERROR*Too many points in LINE*/
	    Xw_set_error(28,"Xw_begin_line",&npoint) ;
            return (XW_ERROR) ;
        }

	if( BeginLine >= 0 ) Xw_close_line(pwindow);

	bindex = _BINDEX ;
	pbuffer = &_BUFFER(bindex) ;
        for( plinelist = pbuffer->plinelist ; plinelist ;
                       	plinelist = (XW_EXT_LINE*)plinelist->link ) {
            if( plinelist->nline < MAXLINES ) break ;
        }

        if( !plinelist ) {
            plinelist = Xw_add_polyline_structure(pbuffer) ;
        }

	if( !plinelist ) return XW_ERROR ;

        for( plinedesc = pbuffer->plinedesc ; plinedesc ;
                       	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
            if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
        }

        if( !plinedesc ) {
            plinedesc = Xw_add_line_desc_structure(pbuffer) ;
        }

	if( !plinedesc ) return XW_ERROR ;

	nline = plinelist->nline ;
	ldesc = plinedesc->npoint ;
	plinelist->lines[nline] = Npoint = 0 ;
	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
	BeginLine = ldesc ;

#ifdef  TRACE_DRAW_LINE
if( Xw_get_trace() > 2 ) {
    printf(" Xw_begin_line(%lx,%d)\n",(long ) pwindow,npoint) ;
}
#endif
        return (XW_SUCCESS) ;
}

/*
   STATUS Xw_line_point (awindow,x,y):
   XW_EXT_WINDOW *awindow
   float x,y    New point to add in polyline in user-space coordinates

        Fill Polyline with one point more

        returns ERROR if Too Many Points in polylines
        returns SUCCESS if successful

*/

#ifdef XW_PROTOTYPE
XW_STATUS Xw_line_point(void* awindow,float x,float y)
#else
XW_STATUS Xw_line_point(awindow,x,y)
void *awindow ;
float x,y ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
XW_EXT_BUFFER *pbuffer ;
int bindex,xi,yi ;

      if( BeginLine >= 0 ) {
	int ldesc = plinedesc->npoint ;
        if( ldesc >= MAXPOINTS ) {
	  /*ERROR*Too many points in LINE*/
	  Xw_set_error(28,"Xw_line_point",&ldesc) ;
          Xw_close_line(pwindow) ;
          return (XW_ERROR) ;
        }

	bindex = _BINDEX ;
	pbuffer = &_BUFFER(bindex) ;
//OCC186
	xi = PXPOINT(x, pwindow->xratio) ;
	yi = PYPOINT(y, pwindow->attributes.height, pwindow->yratio) ;
//OCC186
#ifdef S3593
	if( pwindow->clipflag ) {  
#endif
	  if( Npoint > 0 ) {
	    int status;
	    status = Xw_clip_segment(pwindow,Lx,Ly,xi,yi,&segment);
	    if( status >= 0 ) { 
	      if( (Npoint < 2) || (status & 0xF ) ) {
                plinedesc->rpoints[ldesc].x = segment.x1 ;
                plinedesc->rpoints[ldesc].y = segment.y1 ;
	        ldesc++;
	        if( bindex > 0 ) {
		  int xx = segment.x1,yy = segment.y1;
	          pbuffer->isempty = False ;
                  pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
                  pbuffer->rymin = min(pbuffer->rymin,yy) ;
                  pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
                  pbuffer->rymax = max(pbuffer->rymax,yy) ;
	        }
	      }
              plinedesc->rpoints[ldesc].x = segment.x2 ;
              plinedesc->rpoints[ldesc].y = segment.y2 ;
	      ldesc++;
	      if( bindex > 0 ) {
	 	int xx = segment.x2,yy = segment.y2;
	        pbuffer->isempty = False ;
                pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
                pbuffer->rymin = min(pbuffer->rymin,yy) ;
                pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
                pbuffer->rymax = max(pbuffer->rymax,yy) ;
	      }
	    }
	  }
	  Lx = xi; Ly = yi;
#ifdef S3593
	} else {
          plinedesc->rpoints[ldesc].x = xi ;
          plinedesc->rpoints[ldesc].y = yi ;
	  ldesc++;
	  if( bindex > 0 ) {
	    pbuffer->isempty = False ;
            pbuffer->rxmin = min(pbuffer->rxmin,xi) ;
            pbuffer->rymin = min(pbuffer->rymin,yi) ;
            pbuffer->rxmax = max(pbuffer->rxmax,xi) ;
            pbuffer->rymax = max(pbuffer->rymax,yi) ;
	  }
	}
#endif
	Npoint++;
	plinedesc->npoint = ldesc ;
      }

#ifdef  TRACE_DRAW_LINE
if( Xw_get_trace() > 3 ) {
    printf(" Xw_line_point(%lx,%f,%f)\n",(long ) pwindow,x,y) ;
}
#endif
        return (XW_SUCCESS) ;
}

/*
   STATUS Xw_close_line (awindow):
   XW_EXT_WINDOW *awindow

        Close the Polyline

        returns ERROR if Polyline is empty
        returns SUCCESS if successful

*/

#ifdef XW_PROTOTYPE
XW_STATUS Xw_close_line(void* awindow)
#else
XW_STATUS Xw_close_line(awindow)
void *awindow ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;

        if( BeginLine >= 0 ) {
	  int nline = plinelist->nline ;
	  int ldesc = plinedesc->npoint ;
	  int bindex = _BINDEX ;
	  plinelist->lines[nline] = ldesc - BeginLine ;
          plinelist->nline++ ;

	  if( !bindex ) {	
	    int index = pwindow->lineindex ;
	    Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc) ;
	    plinelist->nline = 0 ;
	    plinedesc->npoint = 0 ;
          }
	  BeginLine = -1 ;
	}

#ifdef  TRACE_DRAW_LINE
if( Xw_get_trace() > 2 ) {
    printf(" Xw_close_line(%lx)\n",(long ) pwindow) ;
}
#endif
        return (XW_SUCCESS) ;
}

#ifdef XW_PROTOTYPE
XW_EXT_LINE* Xw_add_polyline_structure(XW_EXT_BUFFER* pbuflist )
#else
XW_EXT_LINE* Xw_add_polyline_structure(pbuflist )
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Create and Insert at end one Extended polyline structure in the
        polyline List

        returns Extended polyline address if successful
                or NULL if Bad Allocation
*/
{
XW_EXT_LINE *pline ;

        pline = (XW_EXT_LINE*) Xw_malloc(sizeof(XW_EXT_LINE)) ;
        if( pline ) {
            pline->link = pbuflist->plinelist ;
	    pline->isupdated = False ;
            pline->nline = 0 ;
            pbuflist->plinelist = pline ;
        } else {
	    /*ERROR*EXT_LINE allocation failed*/
	    Xw_set_error(30,"Xw_add_polyline_structure",NULL) ;
        }

        return (pline) ;
}

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

        SUCCESS always
*/
{
XW_EXT_LINE *pline,*qline ;

        for( pline = pbuflist->plinelist ; pline ; pline = qline ) {
            qline = (XW_EXT_LINE*)pline->link ;
            Xw_free(pline) ;
        }
	pbuflist->plinelist = NULL ;

        return (XW_SUCCESS) ;
}

#ifdef XW_PROTOTYPE
XW_EXT_POINT* Xw_add_line_desc_structure(XW_EXT_BUFFER* pbuflist )
#else
XW_EXT_POINT* Xw_add_line_desc_structure(pbuflist )
XW_EXT_BUFFER *pbuflist ;
#endif /*XW_PROTOTYPE*/
/*
        Create and Insert at end one Extended line_desc structure in the
        line_desc List

        returns Extended line_desc address if successful
                or NULL if Bad Allocation
*/
{
XW_EXT_POINT *pdesc ;

        pdesc = (XW_EXT_POINT*) Xw_malloc(sizeof(XW_EXT_POINT)) ;
        if( pdesc ) {
            pdesc->link = pbuflist->plinedesc ;
            pdesc->npoint = 0 ;
            pbuflist->plinedesc = pdesc ;
        } else {
	    /*ERROR*EXT_POINT allocation failed*/
	    Xw_set_error(117,"Xw_add_line_desc_structure",NULL) ;
        }

        return (pdesc) ;
}

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

        SUCCESS always
*/
{
XW_EXT_POINT *pdesc,*qdesc ;

        for( pdesc = pbuflist->plinedesc ; pdesc ; pdesc = qdesc ) {
            qdesc = (XW_EXT_POINT*)pdesc->link ;
            Xw_free(pdesc) ;
        }
	pbuflist->plinedesc = 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 S3593 /*GG_130398
b311480e	19	OPTIMISATION MFT
7fd59977	20	Activer le clipping de maniere optionnelle
	21	*/
	22
	23	#include <Xw_Extension.h>
	24
	25	/* ifdef then trace on */
	26	#ifdef TRACE
	27	#define TRACE_DRAW_LINE
	28	#endif
	29
	30	/*
	31	STATUS Xw_draw_line (awindow,npoint,x,y):
	32	XW_EXT_WINDOW *awindow
	33	int npoint Polyline point number
	34	float x,y Points Arrays
	35
	36
	37	Display continuous line in current QG set by set_line_attrib .
	38	Note that lines can be buffered depending of the DisplayMode context
	39	and Flush at Xw_flush time .
	40
	41	returns ERROR if npoint > MAXPOINTS
	42	returns SUCCESS always
	43
	44	*/
	45
	46	static int BeginLine = -1 ;
	47	static XW_EXT_LINE *plinelist ;
	48	static XW_EXT_POINT *plinedesc ;
	49	static XSegment segment;
	50
	51	#ifdef XW_PROTOTYPE
	52	XW_STATUS Xw_draw_line (void* awindow,int npoint,float* px,float* py)
	53	#else
	54	XW_STATUS Xw_draw_line (awindow,npoint,px,py)
	55	void *awindow;
	56	int npoint ;
	57	float px,py ;
	58	#endif /XW_PROTOTYPE/
	59	{
	60	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW) awindow ;
	61	XW_EXT_BUFFER *pbuffer ;
	62	int i,nline,ldesc,bindex;
	63	int x,y,lx=0,ly=0 ;
	64
	65	if( !Xw_isdefine_window(pwindow) ) {
	66	/ERRORBad EXT_WINDOW Address*/
	67	Xw_set_error(24,"Xw_draw_line",pwindow) ;
	68	return (XW_ERROR) ;
	69	}
	70
	71	if( npoint > MAXPOINTS ) {
	72	npoint = MAXPOINTS;
	73	/ERRORToo many points in LINE*/
	74	Xw_set_error(28,"Xw_draw_line",&npoint) ;
	75	return (XW_ERROR) ;
	76	}
	77
	78	bindex = _BINDEX ;
	79	pbuffer = &_BUFFER(bindex) ;
	80	for( plinelist = pbuffer->plinelist ; plinelist ;
	81	plinelist = (XW_EXT_LINE*)plinelist->link ) {
	82	if( plinelist->nline < MAXLINES ) break ;
	83	}
84
85	if( !plinelist ) {
86	plinelist = Xw_add_polyline_structure(pbuffer) ;
87	}
88
89	if( !plinelist ) return XW_ERROR ;
90
91	for( plinedesc = pbuffer->plinedesc ; plinedesc ;
92	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
93	if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
94	}
95
96	if( !plinedesc ) {
97	plinedesc = Xw_add_line_desc_structure(pbuffer) ;
98	}
99
100	if( !plinedesc ) return XW_ERROR ;
101
102	nline = plinelist->nline ;
103	ldesc = plinedesc->npoint ;
104	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
105	for( i=0 ; i<npoint ; i++ ) {
106	//OCC186
107	x = PXPOINT(px[i], pwindow->xratio) ;
108	y = PYPOINT(py[i], pwindow->attributes.height, pwindow->yratio) ;
109	//OCC186
110	#ifdef S3593
111	if( pwindow->clipflag ) {
112	#endif
113	if( i > 0 ) {
114	int status;
115	status = Xw_clip_segment(pwindow,lx,ly,x,y,&segment);
116	if( status >= 0 ) {
117	if( (i < 2) \|\| (status & 0xF ) ) {
118	plinedesc->rpoints[ldesc].x = segment.x1 ;
119	plinedesc->rpoints[ldesc].y = segment.y1 ;
120	ldesc++;
121	if( bindex > 0 ) {
122	int xx = segment.x1,yy = segment.y1;
123	pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
124	pbuffer->rymin = min(pbuffer->rymin,yy) ;
125	pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
126	pbuffer->rymax = max(pbuffer->rymax,yy) ;
127	}
128	}
129	plinedesc->rpoints[ldesc].x = segment.x2 ;
130	plinedesc->rpoints[ldesc].y = segment.y2 ;
131	ldesc++;
132	if( bindex > 0 ) {
133	int xx = segment.x2,yy = segment.y2;
134	pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
135	pbuffer->rymin = min(pbuffer->rymin,yy) ;
136	pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
137	pbuffer->rymax = max(pbuffer->rymax,yy) ;
138	}
139	}
140	}
141	lx = x; ly = y;
142	#ifdef S3593
143	} else {
144	plinedesc->rpoints[ldesc].x = x ;
145	plinedesc->rpoints[ldesc].y = y ;
146	ldesc++ ;
147	if( bindex > 0 ) {
148	pbuffer->rxmin = min(pbuffer->rxmin,x) ;
149	pbuffer->rymin = min(pbuffer->rymin,y) ;
150	pbuffer->rxmax = max(pbuffer->rxmax,x) ;
151	pbuffer->rymax = max(pbuffer->rymax,y) ;
152	}
153	}
154	#endif
155	}
156	plinelist->lines[nline] = ldesc - plinedesc->npoint ;
157	if( plinelist->lines[nline] > 1 ) {
158	plinedesc->npoint = ldesc ;
159	plinelist->nline++ ;
160	if( bindex > 0 ) {
161	pbuffer->isempty = False ;
162	} else if( BeginLine < 0 ) {
163	int index = pwindow->lineindex ;
164	Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc);
165	plinelist->nline = 0 ;
166	plinedesc->npoint = 0 ;
167	}
168	}
169
170	#ifdef TRACE_DRAW_LINE
171	if( Xw_get_trace() > 2 ) {
172	printf(" Xw_draw_line(%lx,%d)\n",(long ) pwindow,npoint) ;
173	for( i=0 ; i<npoint ; i++ ) {
174	printf(" Point(%d) = {%f,%f}\n",i,px[i],py[i]) ;
175	}
176	}
177	#endif
178
179	return (XW_SUCCESS);
180	}
181
182	#ifdef XW_PROTOTYPE
183	void Xw_draw_pixel_lines (XW_EXT_WINDOW* pwindow,XW_EXT_LINE *plinelist,GC gc)
184	#else
185	void Xw_draw_pixel_lines (pwindow,plinelist,gc)
186	XW_EXT_WINDOW *pwindow;
187	XW_EXT_LINE *plinelist;
188	GC gc ;
189	#endif /XW_PROTOTYPE/
190	{
191	int i,npoint;
192	XPoint *ppoint ;
193
194	for( i=0 ; i<plinelist->nline ; i++ ) {
195	npoint = plinelist->lines[i] ;
196	ppoint = plinelist->plines[i] ;
197	if( plinelist->isupdated ) {
198	ppoint += MAXPOINTS ;
199	}
200	if( ppoint && npoint > 1 ) {
201	XDrawLines(_DISPLAY,_DRAWABLE,gc,ppoint,npoint,CoordModeOrigin) ;
202	}
203	}
204	}
205
206	/*
207	STATUS Xw_begin_line (awindow,npoint):
208	XW_EXT_WINDOW *awindow
209	int npoint Polyline point number
210
211
212	Begin Polyline which must be filled by Xw_line_point and
213	closed by Xw_close_line
214
215	returns ERROR if npoint > MAXPOINTS
216	returns SUCCESS if successful
217
218	*/
219
220	static int Npoint = 0;
221	static int Lx,Ly;
222	#ifdef XW_PROTOTYPE
223	XW_STATUS Xw_begin_line(void* awindow,int npoint)
224	#else
225	XW_STATUS Xw_begin_line(awindow,npoint)
226	void *awindow ;
227	int npoint ;
228	#endif /XW_PROTOTYPE/
229	{
230	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow ;
231	XW_EXT_BUFFER *pbuffer ;
232	int nline,ldesc,bindex ;
233
234	if( !Xw_isdefine_window(pwindow) ) {
235	/ERRORBad EXT_WINDOW Address*/
236	Xw_set_error(24,"Xw_begin_line",pwindow) ;
237	return (XW_ERROR) ;
238	}
239
240	if( npoint > MAXPOINTS ) {
241	npoint = MAXPOINTS ;
242	/ERRORToo many points in LINE*/
243	Xw_set_error(28,"Xw_begin_line",&npoint) ;
244	return (XW_ERROR) ;
245	}
246
247	if( BeginLine >= 0 ) Xw_close_line(pwindow);
248
249	bindex = _BINDEX ;
250	pbuffer = &_BUFFER(bindex) ;
251	for( plinelist = pbuffer->plinelist ; plinelist ;
252	plinelist = (XW_EXT_LINE*)plinelist->link ) {
253	if( plinelist->nline < MAXLINES ) break ;
254	}
255
256	if( !plinelist ) {
257	plinelist = Xw_add_polyline_structure(pbuffer) ;
258	}
259
260	if( !plinelist ) return XW_ERROR ;
261
262	for( plinedesc = pbuffer->plinedesc ; plinedesc ;
263	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
264	if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
265	}
266
267	if( !plinedesc ) {
268	plinedesc = Xw_add_line_desc_structure(pbuffer) ;
269	}
270
271	if( !plinedesc ) return XW_ERROR ;
272
273	nline = plinelist->nline ;
274	ldesc = plinedesc->npoint ;
275	plinelist->lines[nline] = Npoint = 0 ;
276	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
277	BeginLine = ldesc ;
278
279	#ifdef TRACE_DRAW_LINE
280	if( Xw_get_trace() > 2 ) {
281	printf(" Xw_begin_line(%lx,%d)\n",(long ) pwindow,npoint) ;
282	}
283	#endif
284	return (XW_SUCCESS) ;
285	}
286
287	/*
288	STATUS Xw_line_point (awindow,x,y):
289	XW_EXT_WINDOW *awindow
290	float x,y New point to add in polyline in user-space coordinates
291
292	Fill Polyline with one point more
293
294	returns ERROR if Too Many Points in polylines
295	returns SUCCESS if successful
296
297	*/
298
299	#ifdef XW_PROTOTYPE
300	XW_STATUS Xw_line_point(void* awindow,float x,float y)
301	#else
302	XW_STATUS Xw_line_point(awindow,x,y)
303	void *awindow ;
304	float x,y ;
305	#endif /XW_PROTOTYPE/
306	{
307	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow ;
308	XW_EXT_BUFFER *pbuffer ;
309	int bindex,xi,yi ;
310
311	if( BeginLine >= 0 ) {
312	int ldesc = plinedesc->npoint ;
313	if( ldesc >= MAXPOINTS ) {
314	/ERRORToo many points in LINE*/
315	Xw_set_error(28,"Xw_line_point",&ldesc) ;
316	Xw_close_line(pwindow) ;
317	return (XW_ERROR) ;
318	}
319
320	bindex = _BINDEX ;
321	pbuffer = &_BUFFER(bindex) ;
322	//OCC186
323	xi = PXPOINT(x, pwindow->xratio) ;
324	yi = PYPOINT(y, pwindow->attributes.height, pwindow->yratio) ;
325	//OCC186
326	#ifdef S3593
327	if( pwindow->clipflag ) {
328	#endif
329	if( Npoint > 0 ) {
330	int status;
331	status = Xw_clip_segment(pwindow,Lx,Ly,xi,yi,&segment);
332	if( status >= 0 ) {
333	if( (Npoint < 2) \|\| (status & 0xF ) ) {
334	plinedesc->rpoints[ldesc].x = segment.x1 ;
335	plinedesc->rpoints[ldesc].y = segment.y1 ;
336	ldesc++;
337	if( bindex > 0 ) {
338	int xx = segment.x1,yy = segment.y1;
339	pbuffer->isempty = False ;
340	pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
341	pbuffer->rymin = min(pbuffer->rymin,yy) ;
342	pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
343	pbuffer->rymax = max(pbuffer->rymax,yy) ;
344	}
345	}
346	plinedesc->rpoints[ldesc].x = segment.x2 ;
347	plinedesc->rpoints[ldesc].y = segment.y2 ;
348	ldesc++;
349	if( bindex > 0 ) {
350	int xx = segment.x2,yy = segment.y2;
351	pbuffer->isempty = False ;
352	pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
353	pbuffer->rymin = min(pbuffer->rymin,yy) ;
354	pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
355	pbuffer->rymax = max(pbuffer->rymax,yy) ;
356	}
357	}
358	}
359	Lx = xi; Ly = yi;
360	#ifdef S3593
361	} else {
362	plinedesc->rpoints[ldesc].x = xi ;
363	plinedesc->rpoints[ldesc].y = yi ;
364	ldesc++;
365	if( bindex > 0 ) {
366	pbuffer->isempty = False ;
367	pbuffer->rxmin = min(pbuffer->rxmin,xi) ;
368	pbuffer->rymin = min(pbuffer->rymin,yi) ;
369	pbuffer->rxmax = max(pbuffer->rxmax,xi) ;
370	pbuffer->rymax = max(pbuffer->rymax,yi) ;
371	}
372	}
373	#endif
374	Npoint++;
375	plinedesc->npoint = ldesc ;
376	}
377
378	#ifdef TRACE_DRAW_LINE
379	if( Xw_get_trace() > 3 ) {
380	printf(" Xw_line_point(%lx,%f,%f)\n",(long ) pwindow,x,y) ;
381	}
382	#endif
383	return (XW_SUCCESS) ;
384	}
385
386	/*
387	STATUS Xw_close_line (awindow):
388	XW_EXT_WINDOW *awindow
389
390	Close the Polyline
391
392	returns ERROR if Polyline is empty
393	returns SUCCESS if successful
394
395	*/
396
397	#ifdef XW_PROTOTYPE
398	XW_STATUS Xw_close_line(void* awindow)
399	#else
400	XW_STATUS Xw_close_line(awindow)
401	void *awindow ;
402	#endif /XW_PROTOTYPE/
403	{
404	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow ;
405
406	if( BeginLine >= 0 ) {
407	int nline = plinelist->nline ;
408	int ldesc = plinedesc->npoint ;
409	int bindex = _BINDEX ;
410	plinelist->lines[nline] = ldesc - BeginLine ;
411	plinelist->nline++ ;
412
413	if( !bindex ) {
414	int index = pwindow->lineindex ;
415	Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc) ;
416	plinelist->nline = 0 ;
417	plinedesc->npoint = 0 ;
418	}
419	BeginLine = -1 ;
420	}
421
422	#ifdef TRACE_DRAW_LINE
423	if( Xw_get_trace() > 2 ) {
424	printf(" Xw_close_line(%lx)\n",(long ) pwindow) ;
425	}
426	#endif
427	return (XW_SUCCESS) ;
428	}
429
430	#ifdef XW_PROTOTYPE
431	XW_EXT_LINE* Xw_add_polyline_structure(XW_EXT_BUFFER* pbuflist )
432	#else
433	XW_EXT_LINE* Xw_add_polyline_structure(pbuflist )
434	XW_EXT_BUFFER *pbuflist ;
435	#endif /XW_PROTOTYPE/
436	/*
437	Create and Insert at end one Extended polyline structure in the
438	polyline List
439
440	returns Extended polyline address if successful
441	or NULL if Bad Allocation
442	*/
443	{
444	XW_EXT_LINE *pline ;
445
446	pline = (XW_EXT_LINE*) Xw_malloc(sizeof(XW_EXT_LINE)) ;
447	if( pline ) {
448	pline->link = pbuflist->plinelist ;
449	pline->isupdated = False ;
450	pline->nline = 0 ;
451	pbuflist->plinelist = pline ;
452	} else {
453	/ERROREXT_LINE allocation failed*/
454	Xw_set_error(30,"Xw_add_polyline_structure",NULL) ;
455	}
456
457	return (pline) ;
458	}
459
460	#ifdef XW_PROTOTYPE
461	XW_STATUS Xw_del_polyline_structure(XW_EXT_BUFFER* pbuflist)
462	#else
463	XW_STATUS Xw_del_polyline_structure(pbuflist)
464	XW_EXT_BUFFER *pbuflist ;
465	#endif /XW_PROTOTYPE/
466	/*
467	Remove ALL Extended polyline structure in the
468	polyline List
469
470	SUCCESS always
471	*/
472	{
473	XW_EXT_LINE pline,qline ;
474
475	for( pline = pbuflist->plinelist ; pline ; pline = qline ) {
476	qline = (XW_EXT_LINE*)pline->link ;
477	Xw_free(pline) ;
478	}
479	pbuflist->plinelist = NULL ;
480
481	return (XW_SUCCESS) ;
482	}
483
484	#ifdef XW_PROTOTYPE
485	XW_EXT_POINT* Xw_add_line_desc_structure(XW_EXT_BUFFER* pbuflist )
486	#else
487	XW_EXT_POINT* Xw_add_line_desc_structure(pbuflist )
488	XW_EXT_BUFFER *pbuflist ;
489	#endif /XW_PROTOTYPE/
490	/*
491	Create and Insert at end one Extended line_desc structure in the
492	line_desc List
493
494	returns Extended line_desc address if successful
495	or NULL if Bad Allocation
496	*/
497	{
498	XW_EXT_POINT *pdesc ;
499
500	pdesc = (XW_EXT_POINT*) Xw_malloc(sizeof(XW_EXT_POINT)) ;
501	if( pdesc ) {
502	pdesc->link = pbuflist->plinedesc ;
503	pdesc->npoint = 0 ;
504	pbuflist->plinedesc = pdesc ;
505	} else {
506	/ERROREXT_POINT allocation failed*/
507	Xw_set_error(117,"Xw_add_line_desc_structure",NULL) ;
508	}
509
510	return (pdesc) ;
511	}
512
513	#ifdef XW_PROTOTYPE
514	XW_STATUS Xw_del_line_desc_structure(XW_EXT_BUFFER* pbuflist)
515	#else
516	XW_STATUS Xw_del_line_desc_structure(pbuflist)
517	XW_EXT_BUFFER *pbuflist ;
518	#endif /XW_PROTOTYPE/
519	/*
520	Remove ALL Extended line_desc structure in the
521	line_desc List
522
523	SUCCESS always
524	*/
525	{
526	XW_EXT_POINT pdesc,qdesc ;
527
528	for( pdesc = pbuflist->plinedesc ; pdesc ; pdesc = qdesc ) {
529	qdesc = (XW_EXT_POINT*)pdesc->link ;
530	Xw_free(pdesc) ;
531	}
532	pbuflist->plinedesc = NULL ;
533
534	return (XW_SUCCESS) ;
535	}