home *** CD-ROM | disk | FTP | other *** search
/ C!T ROM 2 / ctrom_ii_b.zip / ctrom_ii_b / PROGRAM / FOXPRO / WINDOW / WIND.PRG
Text File  |  1991-01-26  |  20KB  |  815 lines
  1. * TRUE windowing for force.
  2. * ALBERT ALEXANDER BUKOSKI
  3. * RELEASED TO THE PUBLIC DOMAIN
  4. *
  5. * This code was going to be part of the DFORCE.LIB. But the darn .EXE
  6. * file was just to big. This is NOT the fault of FORCE. The coding is quilty.
  7. * There are a massive amount of array handling functions. This results in
  8. * alot of allocation in the stack of sometimes empty vars. This method of
  9. * windowing is not stack based but header based.
  10. * I have ported this puppy to assembler and the exe size went way, way
  11. * south.
  12. * 
  13. * Suggestions: 
  14. * 1. Delete the information getting functions (ie w_row, w_col, etc)
  15. * and this will result in a little space savings on you EXEs
  16. * 2. Decrease the number of windows to a lesser amount.
  17. *
  18. * This is only one method of windowing.
  19.  
  20. ****************************************************************************
  21. * W_INIT()
  22. * INCLUDE FILE: dwindow.hdr
  23. *
  24. * FUNCTION LOGICAL w_init PROTOTYPE
  25. * 
  26. * PURPOSE: Sets up window procedures. Must be used before all other window
  27. * functions
  28. * 
  29. * PARAMETERS: None.
  30. *
  31. * RETURNS: .T. if sucessesful
  32. *
  33. * EXAMPLE: 
  34. * * Set up windows procedures.
  35. * w_init()
  36. * ....
  37. * ....
  38. * SEE ALSO:
  39. ****************************************************************************
  40. * W_MAKE()
  41. * INCLUDE FILE: dwindow.hdr
  42. * 
  43. * FUNCTION UINT w_make PROTOTYPE
  44. * PARAMETERS VALUE UINT r, VALUE UINT c, VALUE UINT r1, VALUE UINT c1,;
  45. * VALUE CHAR border, VALUE CHAR fill_pat, VALUE INT color, VALUE LOGICAL shadow
  46. * 
  47. * PURPOSE: Defines window for later drawing.
  48. * 
  49. * PARAMETERS: w_make(tr,tc,br,bc,border type, fill pattern, color,shadow)
  50. * tr = top row
  51. * tc = top column
  52. * br = bottom row
  53. * bc = bottom column
  54. * border =See FILL() function.
  55. * fill pattern =See FILL() function.
  56. * color    = See FILL() function.
  57. * shadow = .T. for shadows, else .F. for none
  58. *
  59. * RETURNS: Handle of window.
  60. *
  61. * EXAMPLE: 
  62. * * Set up windows procedures then define a window.
  63. * vardef
  64. *  uint max_win[10] && Array to hold window structure
  65. * enddef 
  66. * 
  67. * procedure force_main
  68. * w_init()
  69. * max_win[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  70. * ....
  71. * ....
  72. * endpro
  73. * SEE ALSO:
  74. ****************************************************************************
  75. * W_OPEN()
  76. * INCLUDE FILE: dwindow.hdr
  77. * 
  78. * PROCEDURE w_open PROTOTYPE
  79. * PARAMETERS VALUE UINT handle[]
  80.  
  81. * PURPOSE: Draws pre defined window. 
  82. * 
  83. * PARAMETERS: w_open( array[Number])
  84. * Number is window made with w_make()
  85. *
  86. * RETURNS: Nothing.
  87. *
  88. * * Set up windows procedures,define a window, then open
  89. * vardef
  90. *  uint max_win[10] && Array to hold window structure
  91. * enddef 
  92. * 
  93. * procedure force_main
  94. * w_init()
  95. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  96. * ....
  97. * ....
  98. * w_open(max_win[0])
  99. * ....
  100. * ....
  101. * endpro
  102. * SEE ALSO:
  103. ****************************************************************************
  104. * W_SAY()
  105. * INCLUDE FILE: dwindow.hdr
  106. * 
  107. * PROCEDURE w_say PROTOTYPE
  108. * PARAMETERS VALUE UINT handle[], VALUE UINT row, VALUE UINT column, ;
  109. * VALUE CHAR string
  110. *
  111. * PURPOSE: Writes string in window. 
  112. * 
  113. * PARAMETERS: w_say( array[Number], row, col, string)
  114. * Number is window made with w_make()
  115. * W_SAY() uses relative windowing positions. 
  116. *
  117. * RETURNS: Nothing.
  118. *
  119. * * Set up windows procedures,define a window, then open and say something
  120. * vardef
  121. *  uint max_win[10] && Array to hold window structure
  122. * enddef 
  123. * 
  124. * procedure force_main
  125. * w_init()
  126. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  127. * ....
  128. * ....
  129. * w_open(max_win[0])
  130. * w_say(max_win[0], 0,0,"Check this puppy out")
  131. * w_say(max_win[0], 1,0,"He is so messy")
  132. * ....
  133. * ....
  134. * endpro
  135. * SEE ALSO:
  136. ****************************************************************************
  137. * W_OPEN_EXPLODE()
  138. * INCLUDE FILE: dwindow.hdr
  139. * 
  140. * PROCEDURE w_open_explode PROTOTYPE
  141. * PARAMETERS VALUE UINT handle[], VALUE UINT speed
  142. * 
  143. * PURPOSE: Draws pre defined window that explodes. 
  144. * 
  145. * PARAMETERS: w_open_explode( array[Number], delay)
  146. * Number is window made with w_make(). This is the same function as w_open()
  147. * but is seperate to reduce code size. Delay is the time delay for exploding
  148. * imploding.
  149. *
  150. * RETURNS: Nothing.
  151. *
  152. * * Set up windows procedures,define a window, then open with exploding effect.
  153. * vardef
  154. *  uint max_win[10] && Array to hold window structure
  155. * enddef 
  156. * 
  157. * procedure force_main
  158. * w_init()
  159. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  160. * ....
  161. * ....
  162. * w_open_explode(max_win[0],2)
  163. * ....
  164. * ....
  165. * endpro
  166. * SEE ALSO:
  167. ****************************************************************************
  168. * W_CLOSE()
  169. * INCLUDE FILE: dwindow.hdr
  170. * 
  171. * PROCEDURE w_open_explode PROTOTYPE
  172. * PARAMETERS VALUE UINT handle[], VALUE UINT speed
  173. *
  174. * PURPOSE: Closes a window. 
  175. * 
  176. * PARAMETERS: w_close( array[Number])
  177. * Number is window made with w_make()
  178. *
  179. * RETURNS: Nothing.
  180. *
  181. * * Set up windows procedures,define a window, open    it, close it.
  182. * vardef
  183. *  uint max_win[10] && Array to hold window structure
  184. * enddef 
  185. * 
  186. * procedure force_main
  187. * w_init()
  188. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  189. * ....
  190. * ....
  191. * w_open(max_win[0])
  192. * delay(1)
  193. * w_close(max_win[0])
  194. * endpro
  195. * SEE ALSO:
  196. ****************************************************************************
  197. * W_CLOSE_IMPLODE()
  198. * INCLUDE FILE: dwindow.hdr
  199. * 
  200. * PROCEDURE w_open_implode PROTOTYPE
  201. * PARAMETERS VALUE UINT handle[], VALUE UINT speed
  202. *
  203. * PURPOSE: Closes a window by imploding it. 
  204. * 
  205. * PARAMETERS: w_open_explode( array[Number], delay)
  206. * Number is window made with w_make(). Delay is the time delay for imploding
  207. * window.
  208. *
  209. * RETURNS: Nothing.
  210. *
  211. * * Set up windows procedures,define a window, open it, close it.
  212. * vardef
  213. *  uint max_win[10] && Array to hold window structure
  214. * enddef 
  215. * 
  216. * procedure force_main
  217. * w_init()
  218. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  219. * ....
  220. * ....
  221. * w_open(max_win[0])
  222. * delay(1)
  223. * w_close_implode(max_win[0])
  224. * endpro
  225. * SEE ALSO:
  226. ****************************************************************************
  227. * W_CLEAR()
  228. * INCLUDE FILE: dwindow.hdr
  229. *
  230. * PROCEDURE w_clear PROTOTYPE
  231. * PARAMETERS VALUE UINT handle[]
  232. * 
  233. * PURPOSE: Clears inside a window. 
  234. * 
  235. * PARAMETERS: w_clear( array[Number])
  236. * Window is cleared from 1,1 of cursor position leaving border alone.
  237. *
  238. * RETURNS: Nothing.
  239. *
  240. * * Set up windows procedures,define a window, open    it, clear inside.
  241. * vardef
  242. *  uint max_win[10] && Array to hold window structure
  243. * enddef 
  244. * 
  245. * procedure force_main
  246. * w_init()
  247. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  248. * ....
  249. * ....
  250. * w_open(max_win[0])
  251. * delay(1)
  252. * w_clear(max_win[0])
  253. * endpro
  254. * SEE ALSO:
  255. ****************************************************************************
  256. * W_ALTER()
  257. * INCLUDE FILE: dwindow.hdr
  258. * 
  259. * PROCEDURE w_alter PROTOTYPE
  260. * PARAMETERS VALUE UINT handle[], VALUE UINT new_row, VALUE UINT new_col,;
  261. * VALUE UINT new_row1, VALUE UINT new_col1 
  262. * 
  263. * PURPOSE: Resize or move a window. 
  264. * 
  265. * PARAMETERS: w_alter(array number, row, col, bottom row, bottom col)
  266. *
  267. * RETURNS: Nothing.
  268. *
  269. * * Set up windows procedures,define a window, open it, clear inside and resize
  270. * vardef
  271. *  uint max_win[10] && Array to hold window structure
  272. * enddef 
  273. * 
  274. * procedure force_main
  275. * w_init()
  276. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  277. * ....
  278. * ....
  279. * w_open(max_win[0])
  280. * delay(1)
  281. * w_alter(max_win[0],0,0,24,79)
  282. * w_clear(max_win[0])
  283. * endpro
  284. * SEE ALSO:
  285. ****************************************************************************
  286. * W_HEADER()
  287. * INCLUDE FILE: dwindow.hdr
  288. * 
  289. * FUNCTION LOGICAL w_header PROTOTYPE
  290. * PARAMETERS VALUE UINT handle[], VALUE CHAR msg, VALUE INT color
  291. * 
  292. * PURPOSE: Places a Header in a window. 
  293. * 
  294. * PARAMETERS: w_header(array number, message, color of string)
  295. *
  296. * RETURNS: .T. if okay.
  297. *
  298. * * Place a header on a window with blue on white
  299. * vardef
  300. *  uint max_win[10] && Array to hold window structure
  301. * enddef 
  302. * 
  303. * procedure force_main
  304. * w_init()
  305. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  306. * ....
  307. * ....
  308. * w_open(max_win[0])
  309. * delay(1)
  310. * w_header(max_win[0],"[ Testing Header ]",&white_blue)
  311. * ...
  312. * endpro
  313. * SEE ALSO:
  314. ****************************************************************************
  315. * W_FOOTER()
  316. * INCLUDE FILE: dwindow.hdr
  317. * 
  318. * FUNCTION LOGICAL w_footer PROTOTYPE
  319. * PARAMETERS VALUE UINT handle[], VALUE CHAR msg, VALUE INT color
  320. * 
  321. * PURPOSE: Places a footer in a window. 
  322. * 
  323. * PARAMETERS: w_footer(array number, message, color of string)
  324. *
  325. * RETURNS: .T. if okay.
  326. *
  327. * * Place a footer on a window with blue on white
  328. * vardef
  329. *  uint max_win[10] && Array to hold window structure
  330. * enddef 
  331. * 
  332. * procedure force_main
  333. * w_init()
  334. * win_max[0] = w_make(3,3,10,55,&single_box,"    ",&white_blue,.T.)
  335. * ....
  336. * ....
  337. * w_open(max_win[0])
  338. * delay(1)
  339. * w_footer(max_win[0],"[ Testing Footer ]",&white_blue)
  340. * ...
  341. * endpro
  342. * SEE ALSO:
  343. ****************************************************************************
  344. * W_ROW()
  345. * INCLUDE FILE: dwindow.hdr
  346. * 
  347. * FUNCTION INT w_row PROTOTYPE
  348. * PARAMETERS VALUE UINT handle[]
  349. * 
  350. * PURPOSE: Returns top row of a window. 
  351. * 
  352. * PARAMETERS: w_row(array number)
  353. *
  354. * RETURNS: Row of top left of window.
  355. *
  356. * EXAMPLE:
  357. * * Where is window number 3 ?
  358. * ? w_row(win[3])
  359. * SEE ALSO:
  360. ****************************************************************************
  361. * W_COL()
  362. * INCLUDE FILE: dwindow.hdr
  363. * 
  364. * FUNCTION INT w_col PROTOTYPE
  365. * PARAMETERS VALUE UINT handle[]
  366. * 
  367. * PURPOSE: Returns bottom column of a window. 
  368. * 
  369. * PARAMETERS: w_col(array number)
  370. *
  371. * RETURNS: Bottom column of window.
  372. *
  373. * EXAMPLE:
  374. * * Where is window number 3 ?
  375. * ? w_row(win[3])
  376. * ? w_col(win[3])
  377. * SEE ALSO:
  378. ****************************************************************************
  379. * W_COLOR()
  380. * INCLUDE FILE: dwindow.hdr
  381. * 
  382. * FUNCTION INT w_color PROTOTYPE
  383. * PARAMETERS VALUE UINT handle[]
  384. * 
  385. * PURPOSE: Returns current color of a window. 
  386. * 
  387. * PARAMETERS: w_color(array number)
  388. *
  389. * RETURNS: Color number value.
  390. *
  391. * EXAMPLE:
  392. * * Where is window number 3 and the color?
  393. * ? w_row(win[3])
  394. * ? w_col(win[3])
  395. * ? w_color(win[3])
  396. * SEE ALSO:
  397. ****************************************************************************
  398. * W_ACTIVE()
  399. * INCLUDE FILE: dwindow.hdr
  400. * 
  401. * FUNCTION LOGICAL w_active PROTOTYPE
  402. * PARAMETERS VALUE UINT handle[]
  403. * 
  404. * PURPOSE: Returns if a window is active. 
  405. * 
  406. * PARAMETERS: w_active(array number)
  407. *
  408. * RETURNS: .T. if window is active.
  409. *
  410. * EXAMPLE:
  411. * * Where is window number 3 and is the window active?
  412. * ? w_row(win[3])
  413. * ? w_col(win[3])
  414. * ? w_active(win[3])
  415. * SEE ALSO:
  416. * $Header:   D:/pvcs/dforce/wind.prv   1.0   12 Dec 1991 02:08:40   ALEX  $
  417. * $Log:   D:/pvcs/dforce/wind.prv  $
  418. *  
  419. *     Rev 1.0   12 Dec 1991 02:08:40   ALEX
  420. *  Initial revision.
  421.  
  422.  
  423. #include colors.hdr
  424. #include keys.hdr
  425. #include string.hdr
  426. #include iif.hdr
  427. #include math.hdr
  428. #include io.hdr
  429. #include system.hdr
  430. #include dstring.hdr
  431. #pragma W_FUNC_PROC-
  432.  
  433. vardef extern
  434.  byte __color_std
  435. enddef
  436.  
  437. vardef private
  438. #define DWINDOWS 50
  439.   uint cur_x[&DWINDOWS]
  440.   uint cur_y[&DWINDOWS]
  441.   uint r_win[&DWINDOWS]
  442.   uint c_win[&DWINDOWS]
  443.   uint r1_win[&DWINDOWS]
  444.   uint c1_win[&DWINDOWS]
  445.   uint clr_win[&DWINDOWS]
  446.   uint w_back[&DWINDOWS]
  447.   uint max_header
  448.   uint w_head_clr[&DWINDOWS]
  449.   uint w_foot_clr[&DWINDOWS]
  450.   char bord_win[&DWINDOWS]
  451.   char fill_win[&DWINDOWS]
  452.   char(79) footer_win[&DWINDOWS]
  453.   char(79) header_win[&DWINDOWS]
  454.   logical shad_win[&DWINDOWS]
  455.   logical w_head[&DWINDOWS]
  456.   logical w_foot[&DWINDOWS]
  457.   logical expld[&DWINDOWS]
  458.   logical active_w[&DWINDOWS]
  459. enddef
  460.  
  461. * These functions are internal calls to some routines I wrote to get
  462. * the status of the called array. They are not available to be released
  463.  
  464. * All this does is clear the screen using the scroll function. Modify
  465. * the scroll function to go down and clear with current attribute.
  466.  
  467. procedure dbclr prototype
  468. parameters value uint , value uint ,value uint ,value uint ,value uint 
  469.  
  470.  
  471. * This function make a shadow on the screen
  472. * I decided not to make a shadow with FILL() in order for
  473. * W_SAY to work. You have 3 choice for this. 1 Write a routine
  474. * to make a shadow(TYPE 6 on FILL function). 2 Remove support for 
  475. * making shadows. 3. Modify W_SAY to work with what ever type
  476. * of shadow you want.
  477. procedure df_shadow prototype
  478. parameters value uint tr, value uint tc,value uint br ,value uint bc
  479.  
  480. * w_header and w_footer simply return .T. if there is a HEADER 
  481. * or FOOTER for that particular window.
  482. * for w_header
  483. function logical DF_HDR prototype
  484. PARAMETERS VALUE UINT
  485.  
  486. * for w_footer
  487. function logical DF_FTR prototype
  488. parameters value uint 
  489.  
  490.  
  491. function logical w_init
  492. max_header = 0
  493. return .t.
  494. endpro
  495.  
  496. procedure w_open_explode
  497. PARAMS VALUE UINT h, VALUE UINT speed
  498. VARDEF
  499.        UINT    ir,ic,ir1,ic1
  500.     LOGICAL    odd
  501.     UINT  BC
  502.     UINT  SC
  503. ENDDEF
  504. *w_back[h] = savescrn(r_win[h],c_win[h],r1_win[h],c1_win[h])
  505. w_back[h] = savescrn(0,0,24,79)
  506. active_w[h] = .t.
  507.     ir = (r_win[h] + r1_win[h]) / 2 - 1
  508.     ic = (c_win[h] + c1_win[h]) / 2 - 1
  509.     ir1 = ir + 1
  510.     ic1 = ic + 1
  511.     odd = .f.
  512.     REPEAT
  513.     odd = .NOT. odd
  514.     IF odd
  515.     IF ( ir > r_win[h] )
  516.             ir = ir - 1
  517.     ENDIF
  518.     IF ( ir1 < r1_win[h] )
  519.             ir1 = ir1 + 1
  520.     ENDIF
  521.     ENDIF
  522.             
  523.     IF ( ic > c_win[h] )
  524.     ic = ic - 1                           
  525.     ENDIF                               
  526.     IF ( ic1 < c1_win[h] )
  527.     ic1 = ic1 + 1
  528.     ENDIF
  529.     FILL(ir,ic,ir1,ic1,bord_win[h],fill_win[h],clr_win[h],clr_win[h] , 0 )
  530. if shad_win[h]
  531. df_shadow(ir,ic,ir1,ic1)
  532. endif
  533. * A little trick to delay for hundreths of a second
  534.  
  535.     sound(0,speed)
  536.     UNTIL ir = r_win[h] .AND. ic = c_win[h] .AND. ir1 = r1_win[h] .AND. ic1 = c1_win[h] 
  537. ENDPRO
  538.  
  539. procedure w_close_implode
  540. PARAMETERS value uint h, value int delay_len
  541. VARDEF
  542. int start_ul_row,start_ul_col,start_lr_row ,start_lr_col ,temp_ul_row,temp_ul_col,;  
  543. temp_lr_row,temp_lr_col,diff_row ,diff_col,increment 
  544. int sleep_cnt
  545. int step_cnt
  546. int inc_row
  547. int inc_col
  548. int sleep
  549. ENDDEF
  550. sleep = 1
  551.  
  552. start_ul_row = r1_win[h] - 1
  553. start_ul_col = c1_win[h] - 1
  554. start_lr_row = r1_win[h]
  555. start_lr_col = c1_win[h]
  556.  
  557. temp_ul_row  = r_win[h]
  558. temp_ul_col  = c_win[h]
  559. temp_lr_row  = r1_win[h]
  560. temp_lr_col  = c1_win[h]
  561.  
  562. diff_row     = start_ul_row - r_win[h]
  563. diff_col     = start_ul_col - c_win[h]
  564.  
  565. IF diff_row > diff_col
  566.     increment = diff_col
  567. ELSE
  568.     increment = diff_row
  569. ENDIF
  570.  
  571. inc_row = diff_row / increment
  572. inc_col = diff_col / increment
  573.  
  574. step_cnt = 1
  575.  
  576. DO WHILE step_cnt <= increment
  577. RESTORESCRN(w_back[h])
  578.  
  579.     temp_ul_row = trunc(temp_ul_row + inc_row)
  580.     temp_ul_col = trunc(temp_ul_col + inc_col)
  581.     
  582.     @ temp_ul_row + 1, temp_ul_col + 1 CLEAR TO;
  583.     temp_lr_row - 1, temp_lr_col - 1
  584.     
  585. fill(temp_ul_row, temp_ul_col, temp_lr_row, temp_lr_col,bord_win[h],fill_win[h],clr_win[h],clr_win[h] ,0)
  586. if shad_win[h]
  587. df_shadow(temp_ul_row, temp_ul_col, temp_lr_row, temp_lr_col)
  588. endif
  589.     sound(0,delay_len)
  590.     sleep_cnt = 1
  591.     
  592.     DO WHILE sleep_cnt < sleep
  593.         sleep_cnt = sleep_cnt + 1
  594.     ENDDO
  595.     
  596.     step_cnt = step_cnt + 1
  597. ENDDO
  598.  
  599. RESTORESCRN(w_back[h])
  600. active_w[h] = .f.
  601. ENDPRO
  602.  
  603. function uint w_make
  604. parameters value uint r, value uint c, value uint r1, value uint c1,;
  605. value char bord, value char fill_pat, value int clr,value logical shad
  606. vardef
  607.  uint h
  608. enddef
  609.  
  610. h = max_header 
  611. cur_x[h]    = 0
  612. cur_y[h]    = 0
  613. r_win[h]       = r    
  614. c_win[h]       = c    
  615. r1_win[h]      = r1    
  616. c1_win[h]   = c1 
  617. bord_win[h] = bord
  618. fill_win[h] = fill_pat
  619. clr_win[h]  = clr
  620. w_back[h]    = 0
  621. w_head_clr[h] =    0
  622. w_foot_clr[h] =    0
  623. footer_win[h] = ""
  624. header_win[h] =""
  625. w_head[h] = .f.
  626. w_foot[h] = .f.
  627. active_w[h] = .f.
  628. shad_win[h] = shad
  629.  
  630. max_header = max_header + 1
  631. return h
  632. endpro
  633.  
  634. procedure w_open
  635. parameters value uint h
  636.  
  637. w_back[h] = savescrn(r_win[h],c_win[h],r1_win[h]+2,c1_win[h]+2)
  638. active_w[h] = .t.
  639. fill(r_win[h],c_win[h],r1_win[h],c1_win[h],bord_win[h], fill_win[h] , clr_win[h],; 
  640. clr_win[h], 0)
  641. if shad_win[h]
  642. df_shadow(r_win[h],c_win[h],r1_win[h],c1_win[h])
  643. endif
  644.  
  645. endpro
  646.  
  647.  
  648. function int w_row
  649. parameters value uint h
  650. return    r_win[h]
  651. endpro
  652.  
  653. function int w_col
  654. parameters value uint h
  655. return    c1_win[h]
  656. endpro
  657.  
  658. function int w_color
  659. parameters value uint h
  660. return    clr_win[h]
  661. endpro
  662.  
  663.  
  664. function logical w_active
  665. parameters value uint h
  666. return    active_w[h]
  667. endpro
  668.  
  669. procedure w_close
  670. parameters value uint h
  671. cur_x[h] = 0
  672. cur_y[h] = 0
  673. active_w[h] = .f.
  674. restorescrn(w_back[h])
  675. endpro
  676.  
  677. procedure w_clear
  678. parameters value uint h
  679. vardef
  680.   byte old
  681. enddef
  682. old = __color_std
  683. __color_Std = clr_win[h]
  684. dbclr( 0, r_win[h] +1,c_win[h], r1_win[h] + 1, c1_win[h] )
  685. __color_Std = old 
  686. ENDPRO
  687.  
  688. function logical w_say
  689. parameters value uint h,value uint  X, value uint Y, value char saytext
  690.  vardef
  691.   byte old
  692.   int slen
  693.   char stext, work
  694.  enddef
  695.  work  = " "
  696.  old = __color_std
  697.  __color_std = clr_win[h]
  698.  
  699.      X = X + r_win[h]
  700.      Y = Y + c_win[h] + 1
  701.  
  702.      if Y >= r1_win[h]
  703.          Y = cur_y[h]
  704.      endif
  705.  
  706.      if X >= r1_win[h]
  707.          X = cur_x[h]
  708.      endif
  709.  
  710.      if len(SayText) >= c1_win[h] - Y
  711.          Do while len(SayText) > 1
  712.              sText = substr(SayText, 1, c1_win[h] - y)
  713.              sLen  = iifn(len(sText) = c1_win[h] - Y,rat(" ",sText),len(stext))
  714.              @ X + 1, Y say Substr(SayText, 1, sLen )
  715.         SayText = Substr(SayText,sLen+1,sLen+1)
  716.              X = X + 1
  717.              if X >= r1_win[h]
  718.                  return (.f.)
  719.              endif
  720.          Enddo
  721.          cur_x[h] = X
  722.          cur_y[h] = Y
  723.      else
  724.          @ X + 1,Y say saytext
  725.      endif
  726.  __color_std = old
  727. return (.t.)
  728.  endpro
  729.  
  730.  
  731. function logical w_header
  732. parameters value uint h, value char msg, value int clr
  733. vardef 
  734.   byte old
  735.   int  Y, Size
  736. enddef
  737. old = __color_std
  738. __color_std = clr
  739. header_win[h] = msg
  740. w_head[h] = .t.
  741. w_head_clr[h] =    clr
  742.     y = c_win[h] + 1
  743.     Size = len(msg)
  744.     Size = (c1_win[h] - Y - Size)/2
  745.  
  746.     if Size < 0
  747.         return .f.
  748.     endif
  749.  
  750.     Y = Y + Size
  751.       @ r_win[h] , Y say msg
  752.  
  753. __color_std = old
  754.  
  755. Return .t.
  756. endpro
  757.  
  758. function logical w_footer
  759. parameters value uint h, value char msg, value int clr
  760. vardef 
  761.   byte old
  762.   int  Y, Size
  763. enddef
  764. old = __color_std
  765. __color_std = clr
  766. footer_win[h] = msg
  767. w_foot[h] = .t.
  768. w_foot_clr[h] =    clr
  769.     y = c_win[h] + 1
  770.     Size = len(msg)
  771.     Size = (c1_win[h] - Y - Size)/2
  772.  
  773.     if Size < 0
  774.         return .f.
  775.     endif
  776.  
  777.  Y = Y + Size
  778. @ r1_win[h] , Y say msg
  779. __color_std = old
  780. Return .t.
  781. ENDPRO
  782.  
  783. * I wanted a move, resize function all in one. That way, any modification
  784. * could be done by the user.
  785.  
  786. procedure w_alter
  787. parameters value uint h, value uint r, value uint c, value uint r1, value uint c1 
  788. vardef 
  789.   uint saved,old
  790. enddef
  791.  
  792. old = w_back[h]          && Saved background
  793. r_win[h] = r          && Give new value to positions
  794. c_win[h] = c
  795. r1_win[h] =    r1
  796. c1_win[h] =    c1
  797. restorescrn( old)      && Restore old screen
  798. w_back[h] = savescrn(r_win[h],c_win[h],r1_win[h],c1_win[h])
  799.  
  800. fill(r_win[h],c_win[h],r1_win[h],c1_win[h],; && Redraw window in new area
  801. bord_win[h],fill_win[h],clr_win[h],clr_win[h], 0) 
  802.  
  803. if shad_win[h]
  804. df_shadow(r_win[h],c_win[h],r1_win[h],c1_win[h])
  805. endif
  806.  
  807. if w_foot[h] 
  808.   w_footer(h,footer_win[h],w_foot_clr[h]) && Check if there is a footer
  809. endif
  810. if w_head[h] 
  811.   w_header(h,header_win[h],w_head_clr[h]) && Check if there is a footer
  812. endif
  813. endpro
  814.  
  815.