/src/Xw/Xw_draw_line.cxx

https://github.com/hmeyer/oce · C++ · 518 lines · 375 code · 53 blank · 90 comment · 63 complexity · e7f229e6f0b12d991b119dc53d1b39c7 MD5 · raw file 

    

  1. #define S3593           /*GG_130398
    2. 

  2.                         OPTIMISATION MFT
    3. 

  3.                         Activer le clipping de maniere optionnelle
    4. 

  4. */
    5. 

  5. 

  6. #include <Xw_Extension.h>
    7. 

  7. 

  8. 	/* ifdef then trace on */
    9. 

  9. #ifdef TRACE
    10. 

  10. #define TRACE_DRAW_LINE
    11. 

  11. #endif
    12. 

  12. 

  13. /*
    14. 

  14.    STATUS Xw_draw_line (awindow,npoint,x,y):
    15. 

  15.    XW_EXT_WINDOW *awindow
    16. 

  16.    int npoint		Polyline point number
    17. 

  17.    float *x,*y		Points Arrays
    18. 

    19. 

    20. 

  20. 	Display continuous line in current QG set by set_line_attrib .
    21. 

  21.         Note that lines can be buffered depending of the DisplayMode context
    22. 

  22.         and Flush at Xw_flush time .
    23. 

    24. 

  24. 	returns ERROR if npoint > MAXPOINTS
    25. 

  25. 	returns SUCCESS always 
    26. 

    27. 

  27. */
    28. 

  28. 

  29. static int BeginLine = -1 ;
    30. 

  30. static XW_EXT_LINE *plinelist ;
    31. 

  31. static XW_EXT_POINT *plinedesc ;
    32. 

  32. static XSegment segment;
    33. 

  33. 

  34. #ifdef XW_PROTOTYPE
    35. 

  35. XW_STATUS Xw_draw_line (void* awindow,int npoint,float* px,float* py) 
    36. 

  36. #else
    37. 

  37. XW_STATUS Xw_draw_line (awindow,npoint,px,py) 
    38. 

  38. void *awindow;
    39. 

  39. int npoint ;
    40. 

  40. float *px,*py ;
    41. 

  41. #endif /*XW_PROTOTYPE*/
    42. 

  42. {
    43. 

  43. XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*) awindow ;
    44. 

  44. XW_EXT_BUFFER *pbuffer ;
    45. 

  45. int i,nline,ldesc,bindex;
    46. 

  46. int x,y,lx=0,ly=0 ;
    47. 

  47. 

  48.         if( !Xw_isdefine_window(pwindow) ) {
    49. 

  49.             /*ERROR*Bad EXT_WINDOW Address*/
    50. 

  50.             Xw_set_error(24,"Xw_draw_line",pwindow) ;
    51. 

  51.             return (XW_ERROR) ;
    52. 

  52.         }
    53. 

  53. 

  54.         if( npoint > MAXPOINTS ) {
    55. 

  55. 	    npoint = MAXPOINTS;
    56. 

  56. 	    /*ERROR*Too many points in LINE*/
    57. 

  57. 	    Xw_set_error(28,"Xw_draw_line",&npoint) ;
    58. 

  58.             return (XW_ERROR) ;
    59. 

  59.         }
    60. 

  60. 

  61. 	bindex = _BINDEX ;
    62. 

  62. 	pbuffer = &_BUFFER(bindex) ;
    63. 

  63.         for( plinelist = pbuffer->plinelist ; plinelist ;
    64. 

  64.                        	plinelist = (XW_EXT_LINE*)plinelist->link ) {
    65. 

  65.             if( plinelist->nline < MAXLINES ) break ;
    66. 

  66.         }
    67. 

  67. 

  68.         if( !plinelist ) {
    69. 

  69.             plinelist = Xw_add_polyline_structure(pbuffer) ;
    70. 

  70.         }
    71. 

  71. 

  72. 	if( !plinelist ) return XW_ERROR ;
    73. 

  73. 

  74.         for( plinedesc = pbuffer->plinedesc ; plinedesc ;
    75. 

  75.                        	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
    76. 

  76.             if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
    77. 

  77.         }
    78. 

  78. 

  79.         if( !plinedesc ) {
    80. 

  80.             plinedesc = Xw_add_line_desc_structure(pbuffer) ;
    81. 

  81.         }
    82. 

  82. 

  83. 	if( !plinedesc ) return XW_ERROR ;
    84. 

  84. 

  85. 	nline = plinelist->nline ;
    86. 

  86. 	ldesc = plinedesc->npoint ;
    87. 

  87. 	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
    88. 

  88. 	for( i=0 ; i<npoint ; i++ ) {
    89. 

  89. //OCC186
    90. 

  90. 	  x = PXPOINT(px[i], pwindow->xratio) ;
    91. 

  91. 	  y = PYPOINT(py[i], pwindow->attributes.height, pwindow->yratio) ;
    92. 

  92. //OCC186
    93. 

  93. #ifdef S3593
    94. 

  94. 	  if( pwindow->clipflag ) {  
    95. 

  95. #endif
    96. 

  96. 	    if( i > 0 ) {
    97. 

  97. 	      int status;
    98. 

  98. 	      status = Xw_clip_segment(pwindow,lx,ly,x,y,&segment);
    99. 

  99. 	      if( status >= 0 ) { 
    100. 

  100. 	        if( (i < 2) || (status & 0xF ) ) {
    101. 

  101.                   plinedesc->rpoints[ldesc].x = segment.x1 ;
    102. 

  102.                   plinedesc->rpoints[ldesc].y = segment.y1 ;
    103. 

  103. 	          ldesc++;
    104. 

  104. 	          if( bindex > 0 ) {
    105. 

  105. 		    int xx = segment.x1,yy = segment.y1;
    106. 

  106.                     pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
    107. 

  107.                     pbuffer->rymin = min(pbuffer->rymin,yy) ;
    108. 

  108.                     pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
    109. 

  109.                     pbuffer->rymax = max(pbuffer->rymax,yy) ;
    110. 

  110. 	          }
    111. 

  111. 	        }
    112. 

  112.                 plinedesc->rpoints[ldesc].x = segment.x2 ;
    113. 

  113.                 plinedesc->rpoints[ldesc].y = segment.y2 ;
    114. 

  114. 	        ldesc++;
    115. 

  115. 	        if( bindex > 0 ) {
    116. 

  116. 	 	  int xx = segment.x2,yy = segment.y2;
    117. 

  117.                   pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
    118. 

  118.                   pbuffer->rymin = min(pbuffer->rymin,yy) ;
    119. 

  119.                   pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
    120. 

  120.                   pbuffer->rymax = max(pbuffer->rymax,yy) ;
    121. 

  121. 	        }
    122. 

  122. 	      }
    123. 

  123. 	    }
    124. 

  124. 	    lx = x; ly = y;
    125. 

  125. #ifdef S3593
    126. 

  126. 	  } else {
    127. 

  127.             plinedesc->rpoints[ldesc].x = x ;
    128. 

  128.             plinedesc->rpoints[ldesc].y = y ;
    129. 

  129. 	    ldesc++ ;
    130. 

  130. 	    if( bindex > 0 ) {
    131. 

  131.               pbuffer->rxmin = min(pbuffer->rxmin,x) ;
    132. 

  132.               pbuffer->rymin = min(pbuffer->rymin,y) ;
    133. 

  133.               pbuffer->rxmax = max(pbuffer->rxmax,x) ;
    134. 

  134.               pbuffer->rymax = max(pbuffer->rymax,y) ;
    135. 

  135. 	    }
    136. 

  136. 	  }
    137. 

  137. #endif
    138. 

  138. 	}
    139. 

  139. 	plinelist->lines[nline] = ldesc - plinedesc->npoint ;
    140. 

  140. 	if( plinelist->lines[nline] > 1 ) {
    141. 

  141. 	  plinedesc->npoint = ldesc ;
    142. 

  142. 	  plinelist->nline++ ;
    143. 

  143. 	  if( bindex > 0 ) {
    144. 

  144. 	    pbuffer->isempty = False ;
    145. 

  145. 	  } else if( BeginLine < 0 ) {
    146. 

  146. 	    int index = pwindow->lineindex ;
    147. 

  147. 	    Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc);
    148. 

  148. 	    plinelist->nline = 0 ;
    149. 

  149. 	    plinedesc->npoint = 0 ;
    150. 

  150. 	  }
    151. 

  151. 	}
    152. 

  152. 

  153. #ifdef  TRACE_DRAW_LINE
    154. 

  154. if( Xw_get_trace() > 2 ) {
    155. 

  155.     printf(" Xw_draw_line(%lx,%d)\n",(long ) pwindow,npoint) ;
    156. 

  156.     for( i=0 ; i<npoint ; i++ ) {
    157. 

  157. 	printf("	Point(%d) = {%f,%f}\n",i,px[i],py[i]) ;
    158. 

  158.     }
    159. 

  159. }
    160. 

  160. #endif
    161. 

  161. 

  162. 	return (XW_SUCCESS);
    163. 

  163. }
    164. 

  164. 

  165. #ifdef XW_PROTOTYPE
    166. 

  166. void Xw_draw_pixel_lines (XW_EXT_WINDOW* pwindow,XW_EXT_LINE *plinelist,GC gc) 
    167. 

  167. #else
    168. 

  168. void Xw_draw_pixel_lines (pwindow,plinelist,gc) 
    169. 

  169. XW_EXT_WINDOW *pwindow;
    170. 

  170. XW_EXT_LINE *plinelist;
    171. 

  171. GC gc ;
    172. 

  172. #endif /*XW_PROTOTYPE*/
    173. 

  173. {
    174. 

  174. int i,npoint;
    175. 

  175. XPoint *ppoint ;
    176. 

  176. 

  177.     for( i=0 ; i<plinelist->nline ; i++ ) {
    178. 

  178.         npoint = plinelist->lines[i] ;
    179. 

  179. 	ppoint = plinelist->plines[i] ;
    180. 

  180. 	if( plinelist->isupdated ) {
    181. 

  181. 	  ppoint += MAXPOINTS ;
    182. 

  182. 	}
    183. 

  183. 	if( ppoint && npoint > 1 ) {
    184. 

  184. 	  XDrawLines(_DISPLAY,_DRAWABLE,gc,ppoint,npoint,CoordModeOrigin) ;
    185. 

  185. 	}
    186. 

  186.     }
    187. 

  187. }
    188. 

  188. 

  189. /*
    190. 

  190.    STATUS Xw_begin_line (awindow,npoint):
    191. 

  191.    XW_EXT_WINDOW *awindow
    192. 

  192.    int npoint           Polyline point number
    193. 

    194. 

    195. 

  195.         Begin Polyline which must be filled by Xw_line_point and
    196. 

  196.                                      closed by Xw_close_line
    197. 

    198. 

  198.         returns ERROR if npoint > MAXPOINTS
    199. 

  199.         returns SUCCESS if successful
    200. 

    201. 

  201. */
    202. 

  202. 

  203. static int Npoint = 0;
    204. 

  204. static int Lx,Ly;
    205. 

  205. #ifdef XW_PROTOTYPE
    206. 

  206. XW_STATUS Xw_begin_line(void* awindow,int npoint)
    207. 

  207. #else
    208. 

  208. XW_STATUS Xw_begin_line(awindow,npoint)
    209. 

  209. void *awindow ;
    210. 

  210. int npoint ;
    211. 

  211. #endif /*XW_PROTOTYPE*/
    212. 

  212. {
    213. 

  213. XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
    214. 

  214. XW_EXT_BUFFER *pbuffer ;
    215. 

  215. int nline,ldesc,bindex ;
    216. 

  216. 

  217.         if( !Xw_isdefine_window(pwindow) ) {
    218. 

  218.             /*ERROR*Bad EXT_WINDOW Address*/
    219. 

  219.             Xw_set_error(24,"Xw_begin_line",pwindow) ;
    220. 

  220.             return (XW_ERROR) ;
    221. 

  221.         }
    222. 

  222. 

  223.         if( npoint > MAXPOINTS ) {
    224. 

  224. 	    npoint = MAXPOINTS ;
    225. 

  225. 	    /*ERROR*Too many points in LINE*/
    226. 

  226. 	    Xw_set_error(28,"Xw_begin_line",&npoint) ;
    227. 

  227.             return (XW_ERROR) ;
    228. 

  228.         }
    229. 

  229. 

  230. 	if( BeginLine >= 0 ) Xw_close_line(pwindow);
    231. 

  231. 

  232. 	bindex = _BINDEX ;
    233. 

  233. 	pbuffer = &_BUFFER(bindex) ;
    234. 

  234.         for( plinelist = pbuffer->plinelist ; plinelist ;
    235. 

  235.                        	plinelist = (XW_EXT_LINE*)plinelist->link ) {
    236. 

  236.             if( plinelist->nline < MAXLINES ) break ;
    237. 

  237.         }
    238. 

  238. 

  239.         if( !plinelist ) {
    240. 

  240.             plinelist = Xw_add_polyline_structure(pbuffer) ;
    241. 

  241.         }
    242. 

  242. 

  243. 	if( !plinelist ) return XW_ERROR ;
    244. 

  244. 

  245.         for( plinedesc = pbuffer->plinedesc ; plinedesc ;
    246. 

  246.                        	plinedesc = (XW_EXT_POINT*)plinedesc->link ) {
    247. 

  247.             if( plinedesc->npoint + npoint <= MAXPOINTS ) break ;
    248. 

  248.         }
    249. 

  249. 

  250.         if( !plinedesc ) {
    251. 

  251.             plinedesc = Xw_add_line_desc_structure(pbuffer) ;
    252. 

  252.         }
    253. 

  253. 

  254. 	if( !plinedesc ) return XW_ERROR ;
    255. 

  255. 

  256. 	nline = plinelist->nline ;
    257. 

  257. 	ldesc = plinedesc->npoint ;
    258. 

  258. 	plinelist->lines[nline] = Npoint = 0 ;
    259. 

  259. 	plinelist->plines[nline] = &plinedesc->rpoints[ldesc] ;
    260. 

  260. 	BeginLine = ldesc ;
    261. 

  261. 

  262. #ifdef  TRACE_DRAW_LINE
    263. 

  263. if( Xw_get_trace() > 2 ) {
    264. 

  264.     printf(" Xw_begin_line(%lx,%d)\n",(long ) pwindow,npoint) ;
    265. 

  265. }
    266. 

  266. #endif
    267. 

  267.         return (XW_SUCCESS) ;
    268. 

  268. }
    269. 

  269. 

  270. /*
    271. 

  271.    STATUS Xw_line_point (awindow,x,y):
    272. 

  272.    XW_EXT_WINDOW *awindow
    273. 

  273.    float x,y    New point to add in polyline in user-space coordinates
    274. 

    275. 

  275.         Fill Polyline with one point more
    276. 

    277. 

  277.         returns ERROR if Too Many Points in polylines
    278. 

  278.         returns SUCCESS if successful
    279. 

    280. 

  280. */
    281. 

  281. 

  282. #ifdef XW_PROTOTYPE
    283. 

  283. XW_STATUS Xw_line_point(void* awindow,float x,float y)
    284. 

  284. #else
    285. 

  285. XW_STATUS Xw_line_point(awindow,x,y)
    286. 

  286. void *awindow ;
    287. 

  287. float x,y ;
    288. 

  288. #endif /*XW_PROTOTYPE*/
    289. 

  289. {
    290. 

  290. XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
    291. 

  291. XW_EXT_BUFFER *pbuffer ;
    292. 

  292. int bindex,xi,yi ;
    293. 

  293. 

  294.       if( BeginLine >= 0 ) {
    295. 

  295. 	int ldesc = plinedesc->npoint ;
    296. 

  296.         if( ldesc >= MAXPOINTS ) {
    297. 

  297. 	  /*ERROR*Too many points in LINE*/
    298. 

  298. 	  Xw_set_error(28,"Xw_line_point",&ldesc) ;
    299. 

  299.           Xw_close_line(pwindow) ;
    300. 

  300.           return (XW_ERROR) ;
    301. 

  301.         }
    302. 

  302. 

  303. 	bindex = _BINDEX ;
    304. 

  304. 	pbuffer = &_BUFFER(bindex) ;
    305. 

  305. //OCC186
    306. 

  306. 	xi = PXPOINT(x, pwindow->xratio) ;
    307. 

  307. 	yi = PYPOINT(y, pwindow->attributes.height, pwindow->yratio) ;
    308. 

  308. //OCC186
    309. 

  309. #ifdef S3593
    310. 

  310. 	if( pwindow->clipflag ) {  
    311. 

  311. #endif
    312. 

  312. 	  if( Npoint > 0 ) {
    313. 

  313. 	    int status;
    314. 

  314. 	    status = Xw_clip_segment(pwindow,Lx,Ly,xi,yi,&segment);
    315. 

  315. 	    if( status >= 0 ) { 
    316. 

  316. 	      if( (Npoint < 2) || (status & 0xF ) ) {
    317. 

  317.                 plinedesc->rpoints[ldesc].x = segment.x1 ;
    318. 

  318.                 plinedesc->rpoints[ldesc].y = segment.y1 ;
    319. 

  319. 	        ldesc++;
    320. 

  320. 	        if( bindex > 0 ) {
    321. 

  321. 		  int xx = segment.x1,yy = segment.y1;
    322. 

  322. 	          pbuffer->isempty = False ;
    323. 

  323.                   pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
    324. 

  324.                   pbuffer->rymin = min(pbuffer->rymin,yy) ;
    325. 

  325.                   pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
    326. 

  326.                   pbuffer->rymax = max(pbuffer->rymax,yy) ;
    327. 

  327. 	        }
    328. 

  328. 	      }
    329. 

  329.               plinedesc->rpoints[ldesc].x = segment.x2 ;
    330. 

  330.               plinedesc->rpoints[ldesc].y = segment.y2 ;
    331. 

  331. 	      ldesc++;
    332. 

  332. 	      if( bindex > 0 ) {
    333. 

  333. 	 	int xx = segment.x2,yy = segment.y2;
    334. 

  334. 	        pbuffer->isempty = False ;
    335. 

  335.                 pbuffer->rxmin = min(pbuffer->rxmin,xx) ;
    336. 

  336.                 pbuffer->rymin = min(pbuffer->rymin,yy) ;
    337. 

  337.                 pbuffer->rxmax = max(pbuffer->rxmax,xx) ;
    338. 

  338.                 pbuffer->rymax = max(pbuffer->rymax,yy) ;
    339. 

  339. 	      }
    340. 

  340. 	    }
    341. 

  341. 	  }
    342. 

  342. 	  Lx = xi; Ly = yi;
    343. 

  343. #ifdef S3593
    344. 

  344. 	} else {
    345. 

  345.           plinedesc->rpoints[ldesc].x = xi ;
    346. 

  346.           plinedesc->rpoints[ldesc].y = yi ;
    347. 

  347. 	  ldesc++;
    348. 

  348. 	  if( bindex > 0 ) {
    349. 

  349. 	    pbuffer->isempty = False ;
    350. 

  350.             pbuffer->rxmin = min(pbuffer->rxmin,xi) ;
    351. 

  351.             pbuffer->rymin = min(pbuffer->rymin,yi) ;
    352. 

  352.             pbuffer->rxmax = max(pbuffer->rxmax,xi) ;
    353. 

  353.             pbuffer->rymax = max(pbuffer->rymax,yi) ;
    354. 

  354. 	  }
    355. 

  355. 	}
    356. 

  356. #endif
    357. 

  357. 	Npoint++;
    358. 

  358. 	plinedesc->npoint = ldesc ;
    359. 

  359.       }
    360. 

  360. 

  361. #ifdef  TRACE_DRAW_LINE
    362. 

  362. if( Xw_get_trace() > 3 ) {
    363. 

  363.     printf(" Xw_line_point(%lx,%f,%f)\n",(long ) pwindow,x,y) ;
    364. 

  364. }
    365. 

  365. #endif
    366. 

  366.         return (XW_SUCCESS) ;
    367. 

  367. }
    368. 

  368. 

  369. /*
    370. 

  370.    STATUS Xw_close_line (awindow):
    371. 

  371.    XW_EXT_WINDOW *awindow
    372. 

    373. 

  373.         Close the Polyline
    374. 

    375. 

  375.         returns ERROR if Polyline is empty
    376. 

  376.         returns SUCCESS if successful
    377. 

    378. 

  378. */
    379. 

  379. 

  380. #ifdef XW_PROTOTYPE
    381. 

  381. XW_STATUS Xw_close_line(void* awindow)
    382. 

  382. #else
    383. 

  383. XW_STATUS Xw_close_line(awindow)
    384. 

  384. void *awindow ;
    385. 

  385. #endif /*XW_PROTOTYPE*/
    386. 

  386. {
    387. 

  387. XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
    388. 

  388. 

  389.         if( BeginLine >= 0 ) {
    390. 

  390. 	  int nline = plinelist->nline ;
    391. 

  391. 	  int ldesc = plinedesc->npoint ;
    392. 

  392. 	  int bindex = _BINDEX ;
    393. 

  393. 	  plinelist->lines[nline] = ldesc - BeginLine ;
    394. 

  394.           plinelist->nline++ ;
    395. 

  395. 

  396. 	  if( !bindex ) {	
    397. 

  397. 	    int index = pwindow->lineindex ;
    398. 

  398. 	    Xw_draw_pixel_lines(pwindow,plinelist,pwindow->qgline[index].gc) ;
    399. 

  399. 	    plinelist->nline = 0 ;
    400. 

  400. 	    plinedesc->npoint = 0 ;
    401. 

  401.           }
    402. 

  402. 	  BeginLine = -1 ;
    403. 

  403. 	}
    404. 

  404. 

  405. #ifdef  TRACE_DRAW_LINE
    406. 

  406. if( Xw_get_trace() > 2 ) {
    407. 

  407.     printf(" Xw_close_line(%lx)\n",(long ) pwindow) ;
    408. 

  408. }
    409. 

  409. #endif
    410. 

  410.         return (XW_SUCCESS) ;
    411. 

  411. }
    412. 

  412. 

  413. #ifdef XW_PROTOTYPE
    414. 

  414. XW_EXT_LINE* Xw_add_polyline_structure(XW_EXT_BUFFER* pbuflist )
    415. 

  415. #else
    416. 

  416. XW_EXT_LINE* Xw_add_polyline_structure(pbuflist )
    417. 

  417. XW_EXT_BUFFER *pbuflist ;
    418. 

  418. #endif /*XW_PROTOTYPE*/
    419. 

  419. /*
    420. 

  420.         Create and Insert at end one Extended polyline structure in the
    421. 

  421.         polyline List
    422. 

    423. 

  423.         returns Extended polyline address if successful
    424. 

  424.                 or NULL if Bad Allocation
    425. 

  425. */
    426. 

  426. {
    427. 

  427. XW_EXT_LINE *pline ;
    428. 

  428. 

  429.         pline = (XW_EXT_LINE*) Xw_malloc(sizeof(XW_EXT_LINE)) ;
    430. 

  430.         if( pline ) {
    431. 

  431.             pline->link = pbuflist->plinelist ;
    432. 

  432. 	    pline->isupdated = False ;
    433. 

  433.             pline->nline = 0 ;
    434. 

  434.             pbuflist->plinelist = pline ;
    435. 

  435.         } else {
    436. 

  436. 	    /*ERROR*EXT_LINE allocation failed*/
    437. 

  437. 	    Xw_set_error(30,"Xw_add_polyline_structure",NULL) ;
    438. 

  438.         }
    439. 

  439. 

  440.         return (pline) ;
    441. 

  441. }
    442. 

  442. 

  443. #ifdef XW_PROTOTYPE
    444. 

  444. XW_STATUS Xw_del_polyline_structure(XW_EXT_BUFFER* pbuflist)
    445. 

  445. #else
    446. 

  446. XW_STATUS Xw_del_polyline_structure(pbuflist)
    447. 

  447. XW_EXT_BUFFER *pbuflist ;
    448. 

  448. #endif /*XW_PROTOTYPE*/
    449. 

  449. /*
    450. 

  450.         Remove ALL Extended polyline structure in the
    451. 

  451.         polyline List
    452. 

    453. 

  453.         SUCCESS always
    454. 

  454. */
    455. 

  455. {
    456. 

  456. XW_EXT_LINE *pline,*qline ;
    457. 

  457. 

  458.         for( pline = pbuflist->plinelist ; pline ; pline = qline ) {
    459. 

  459.             qline = (XW_EXT_LINE*)pline->link ;
    460. 

  460.             Xw_free(pline) ;
    461. 

  461.         }
    462. 

  462. 	pbuflist->plinelist = NULL ;
    463. 

  463. 

  464.         return (XW_SUCCESS) ;
    465. 

  465. }
    466. 

  466. 

  467. #ifdef XW_PROTOTYPE
    468. 

  468. XW_EXT_POINT* Xw_add_line_desc_structure(XW_EXT_BUFFER* pbuflist )
    469. 

  469. #else
    470. 

  470. XW_EXT_POINT* Xw_add_line_desc_structure(pbuflist )
    471. 

  471. XW_EXT_BUFFER *pbuflist ;
    472. 

  472. #endif /*XW_PROTOTYPE*/
    473. 

  473. /*
    474. 

  474.         Create and Insert at end one Extended line_desc structure in the
    475. 

  475.         line_desc List
    476. 

    477. 

  477.         returns Extended line_desc address if successful
    478. 

  478.                 or NULL if Bad Allocation
    479. 

  479. */
    480. 

  480. {
    481. 

  481. XW_EXT_POINT *pdesc ;
    482. 

  482. 

  483.         pdesc = (XW_EXT_POINT*) Xw_malloc(sizeof(XW_EXT_POINT)) ;
    484. 

  484.         if( pdesc ) {
    485. 

  485.             pdesc->link = pbuflist->plinedesc ;
    486. 

  486.             pdesc->npoint = 0 ;
    487. 

  487.             pbuflist->plinedesc = pdesc ;
    488. 

  488.         } else {
    489. 

  489. 	    /*ERROR*EXT_POINT allocation failed*/
    490. 

  490. 	    Xw_set_error(117,"Xw_add_line_desc_structure",NULL) ;
    491. 

  491.         }
    492. 

  492. 

  493.         return (pdesc) ;
    494. 

  494. }
    495. 

  495. 

  496. #ifdef XW_PROTOTYPE
    497. 

  497. XW_STATUS Xw_del_line_desc_structure(XW_EXT_BUFFER* pbuflist)
    498. 

  498. #else
    499. 

  499. XW_STATUS Xw_del_line_desc_structure(pbuflist)
    500. 

  500. XW_EXT_BUFFER *pbuflist ;
    501. 

  501. #endif /*XW_PROTOTYPE*/
    502. 

  502. /*
    503. 

  503.         Remove ALL Extended line_desc structure in the
    504. 

  504.         line_desc List
    505. 

    506. 

  506.         SUCCESS always
    507. 

  507. */
    508. 

  508. {
    509. 

  509. XW_EXT_POINT *pdesc,*qdesc ;
    510. 

  510. 

  511.         for( pdesc = pbuflist->plinedesc ; pdesc ; pdesc = qdesc ) {
    512. 

  512.             qdesc = (XW_EXT_POINT*)pdesc->link ;
    513. 

  513.             Xw_free(pdesc) ;
    514. 

  514.         }
    515. 

  515. 	pbuflist->plinedesc = NULL ;
    516. 

  516. 

  517.         return (XW_SUCCESS) ;
    518. 

  518. }
    519.