home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 95 / af095a.adf / archives / extras.lzx / WebSite / PageText / L04P11.txt < prev    next >
Encoding:
Text File  |  1997-01-18  |  4.9 KB  |  159 lines
  2. L04P11.txtTEXTî®öÆ0®‹g
  3. <p>In hexadecimal a general cursor positioning sequence takes the 
  4. form... 9b [R] [3b C] 48. The first value, 9b hex, is known as the 
  5. control sequence introducer (CSI) and you'll notice in my example 
  6. sequences that I tend to define this value as the variable CSI and then 
  7. use this term rather than the numerical value itself (helps make the 
  8. resulting scripts easier to read). R represents the display row and C the 
  9. display column whilst the 3b hex value is a 'separator' that allows the 
  10. console device to distinguish between  the two real row and column 
  11. parameters. The brackets indicate items that can be treated as 
  12. optional and this means that not only can either row or column positions 
  13. be omitted but the 3b hex separator (which is in fact an ASCII semicolon 
  14. character) only need be provided when either both row and column values
  15. are given or when just a column value is specified. In other words a row 
  16. position on its own can be moved to by sending the simplified three 
  17. character sequence... 9b R 48.</p>
  18.  
  19. <p>With any script that makes more than passing use of cursor positioning 
  20. the best idea is to create an isolated SetCursor() function that takes 
  21. a pair of row/column co-ordinates and sends the appropriate command 
  22. sequence to the console window. Listing 1 shows a typical function and 
  23. you'll notice how the actual row (r) and column (c) values passed to the 
  24. function are easily embedded into the general form of the sequence by 
  25. using the ARexx '||' string concatenation operator. The benefit here is 
  26. that by isolating the cursor positioning code into a separate function 
  27. the main body of your script will be 'cleaner', ie tidier, and therefore 
  28. more understandable to both yourself and anyone else reading your code. 
  29. Cursor position is then performed using statements such as...</p>
  30.  
  31. <pre> 
  32.         call SetCursor(10,0)...</p> 
  33. </pre>
  34.  
  35. <p> Of course it's possible to go one better than this and create 
  36. a function that takes both the cursor position and the text to be 
  37. displayed as function arguments. Listing 2 shows a typical routine 
  38. called CursorWrite() which would, for example, allow you to position 
  39. and write error messages, incidental text and so on using statements 
  40. in the form...</p> 
  41.  
  42. <pre>
  43.         call CursorWrite(10,0,SIGN_ON_MESSAGE)
  44. </pre>
  45.  
  46.  
  47. <H3>Generalising The Code</H3>
  48.  
  49. <p>It's best to try and generalise the routines as much as possible. 
  50. With the listing 2 CursorWrite() routine for example improvements 
  51. could be made. Rather than have the window handle explicitly embedded 
  52. in the function code we could, for instance, pass the window handle to 
  53. the routine as a parameter. Similarly ARexx's Procedure keyword 
  54. could be used to isolate the workings of the routine from any script 
  55. that the routine was finally used in.</p>
  56.     
  57. <p>Listing 3 shows the results of such changes and the benefit is that 
  58. this function can now be incorporated and used in your own code without 
  59. you needing to worry about how it works. Simply make a call to the 
  60. CursorWrite() routine passing your window handle, the row/column screen 
  61. co-ordinates, and text to be printed as function call parameters and 
  62. your text will be duly printed at the specified position. The program 
  63. shown in listing 4 should help get you started. It opens a window and then
  64. just prints a couple of text messages!</p>. 
  65.  
  66. <pre>
  67. <hr>
  68.     SetCursor:
  69.  
  70.     parse arg r,c
  71.  
  72.     call Writech(raw_window,CSI||r||'3b'x||c||'48'x)
  73.  
  74.     return
  75.  
  76.     Listing 1: A simple cursor positioning function
  77.  
  78.  
  79. <hr>
  80.  
  81.     CursorWrite:
  82.  
  83.     parse arg r,c,text$
  84.  
  85.     call Writech(raw_window,CSI||r||'3b'x||c||'48'x)
  86.  
  87.     call Writech(raw_window,text$)
  88.  
  89.     return
  90.  
  91.     Listing 2: Text writing with cursor positioning 
  92.  
  93.  
  94. <hr>
  95.  
  96.     CursorWrite: Procedure
  97.  
  98.     parse arg window,r,c,text$
  99.  
  100.     CSI = '09'x
  101.  
  102.     call Writech(window,CSI||r||'3b'x||c||'48'x)
  103.  
  104.     call Writech(window,text$)
  105.  
  106.     return
  107.  
  108.     Listing 3: A more general form of the CursorWrite() function.
  109.  
  110.  
  111. <hr>
  112.  
  113.  
  114.  
  115.  
  116.         /* ------------------------------------------------ */
  117.  
  118.         /* example.rexx */
  119.  
  120.         MESSAGE1   = 'Just some example text'
  121.  
  122.         MESSAGE2   = 'Hit ANY key to quit program!'
  123.  
  124.         /* ------------------------------------------------ */
  125.  
  126.         call Open(raw_window,'RAW:40/40/480/200/example.rexx')
  127.  
  128.         call CursorWrite(raw_window,10,10,MESSAGE1)
  129.  
  130.         call CursorWrite(raw_window,14,10,MESSAGE2)
  131.  
  132.         keypress$=Readch(raw_window,1) /* wait for keypress */ 
  133.  
  134.         call Close(raw_window)
  135.  
  136.         exit /* logical end of program */
  137.  
  138.         /* ------------------------------------------------ */
  139.  
  140.         CursorWrite: Procedure
  141.  
  142.         parse arg window,r,c,text$
  143.  
  144.         CSI = '9b'x
  145.  
  146.         call Writech(window,CSI||r||'3B'x||c||'48'x)
  147.  
  148.         call Writech(window,text$)
  149.  
  150.         return
  151.  
  152.         /* ------------------------------------------------ */
  153.  
  154. Listing 4: Some runable example code!
  155.  
  156. </pre>
  157.  
  158. <hr>