home *** CD-ROM | disk | FTP | other *** search
/ POINT Software Programming / PPROG1.ISO / pascal / swag / scroll.swg / 0017_Window Scrolling.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1995-03-26  |  8.2 KB  |  151 lines
  1. {
  2. > I'd like to do left & right screen scrolling, like the INT 10 functions
  3. > for up & down screen scrolling.
  4. }
  5.  
  6. procedure scroll_left(x1,y1,x2,y2:byte); assembler; 
  7.  
  8. asm 
  9.    mov al,[y1]     {put y1 coordinate in al} 
  10.    xor ah,ah       {set ah to 0 so we can deal with ax} 
  11.    mov bx,80       {set bx=80} 
  12.    mul bl          {multiply by bl, which equals 80 by the previous statement} 
  13.    mov bl,[x1]     {put x1 coordinate in bl} 
  14.    add ax,bx       {add the x1 coord. to y1*80 since there are 80 cols in a row
  15.    shl ax,1        {multiply by 2 because info is stored as words, attribute 
  16.                     in the high byte and the ASCII code for the character in 
  17.                     the low byte} 
  18.    mov si,ax       {all this calculated the offset in video memory of the
  19. upper}                    {left-hand corner, which is put in si for later use} 
  20.    mov al,[x2]     {put x2 coord. in al} 
  21.    xor ah,ah       {set ah=0 so we can deal with ax} 
  22.    sub al,bl       {subtract bl, which still contains x1, from al} 
  23.    mov dx,ax       {put this in dx, this is the number of cols to copy at 
  24.                     to move} 
  25.    mov bx,80       {put 80 in bx} 
  26.    sub bx,ax       {subtract this from ax, this value is the number of columns 
  27.                     we will skip over to get to the next value} 
  28.    shl bx,1        {multiply by 2 since the data is stored as words} 
  29.    mov di,si       {set di=si, di points to the offset in memory to move the 
  30.                     characters to, in this case to the left} 
  31.    inc si          {add one to si} 
  32.    inc si          {add one to si, this places si one character ahead of di} 
  33.    mov cl,[y2]     {put y2 coord. in cl} 
  34.    mov ch,[y1]     {put y1 coord. in ch} 
  35.    sub cl,ch       {subtract ch from cl, this value is the number of lines to 
  36.                     scroll} 
  37.    xor ch,ch       {set ch=0 since we don't need that anymore, and because the 
  38.                     the CPU will use all of cx to calculate the number of
  39. lines}    inc cx          {add one to cx because the subtraction only counts
  40. one of                     the y-coords., this accounts for the other} 
  41.    push ds         {save the ds register, which points to the data segment} 
  42.    mov ax,0b800h   {put $b800, the video segment for 80x25 text mode on color 
  43.                     monitors in ax, if the mode you are using has its video 
  44.                     segment different from $b800, put the other value here} 
  45.    mov es,ax       {put ax into es because one cannot move a value into a 
  46.                     segment register, nor can one move one segment register 
  47.                     into another} 
  48.    mov ds,ax       {put ax in ds} 
  49.    cld             {clear direction flag so we will write forward in memory} 
  50. @copyloopl:        {this loops scrolls one line from x1 to x2 left one space}
  51.    push cx         {save cx (number of lines to do)}
  52.    mov cx,dx       {put dx (number of cols to scroll) in cx}
  53.    rep movsw       {movsw moves a word from ds:si to es:di, the first register
  54.                     being the segment in memory and the second the offset, rep
  55.                     repeats the following instruction, in this case movsw, the
  56.                     number of times in cx}
  57.    mov [WORD PTR ds:si-2],0720h  {this puts a word with the value $0720 at
  58.                                   ds:si-2, this puts a space with attribute
  59.                                   lightgray on black at the beginning of the
  60.                                   line, to change the character output,
  61.                                   replace the 20 part with the hex number
  62.                                   for the character, to change the color,
  63.                                   change the 07 to the hex number for the
  64.                                   attribute you want}
  65.    pop cx          {restores cx from where we saved it earlier}
  66.    add si,bx       {adds bx to si to make get ready to do the next line}
  67.    add di,bx       {do the same for di}
  68.    loop @copyloopl {loop loops to the label after it cx number of times}
  69.    pop ds          {restore ds from where we saved it earlier}
  70. end;
  71.  
  72.  
  73. procedure scroll_right(x1,y1,x2,y2:byte); assembler; 
  74.  
  75. asm 
  76.    mov al,[y1]     {put y1 into al} 
  77.    xor ah,ah       {set ah to 0 so we can work with ax} 
  78.    mov bx,80       {set bx=80} 
  79.    mul bl          {mulitiply ax by bl} 
  80.    mov bl,[x2]     {put x2 in bl} 
  81.    add ax,bx       {add ax to bx} 
  82.    shl ax,1        {multiply ax by 2 since data stored as words} 
  83.    mov si,ax       {set si (source index) equal to ax} 
  84.    mov al,[x1]     {put x1 into al} 
  85.    xor ah,ah       {set ah=0} 
  86.    sub bl,al       {subtract bl from al to get number of characters to scroll} 
  87.    xchg ax,bx      {switch ax with bx} 
  88.    mov dx,ax       {put ax (# of cols to scroll) in dx} 
  89.    mov bx,ax       {put ax in bx} 
  90.    shl bx,1        {multiply bx by 2 since dealing with words} 
  91.    add bx,0a0h     {add $00A0 to bx, this is the number of bytes in one row 
  92.                     of data, the reason being that in scroll_left we wrote 
  93.                     forward in video memory, in scroll_right we have to write 
  94.                     backward since otherwise we would destroy the data we were 
  95.                     scrolling and fill the window with the first row of 
  96.                     characters.  When we add this to si and di as in 
  97.                     scroll_left, the # of cols part will take si and di back 
  98.                     to where they started, and the $00a0 part will send them 
  99.                     down one line} 
  100.    mov di,si       {set di = si} 
  101.    dec si          {decrement si because si needs to be behind di one 
  102.                     character, since we are going backwards, si will be 
  103.                     "ahead" of di which is how we keep from losing data} 
  104.    dec si          {decrement si again since we are dealing with words} 
  105.    mov cl,[y2]     {put y2 in cl} 
  106.    mov ch,[y1]     {put y1 in ch} 
  107.    sub cl,ch       {subtract ch (y1) from cl (y2) to get # or rows} 
  108.    xor ch,ch       {clear ch since CPU uses all of cx} 
  109.    inc cx          {increment cx to include both y-coords.} 
  110.    push ds         {save ds so your program want lose its data segment, 
  111.                     which would be REALLY bad} 
  112.    mov ax,0b800h   {set ax = $B800, video memory segment} 
  113.    mov es,ax       {set es = ax} 
  114.    mov ds,ax       {set ds = ax} 
  115.    std             {set direction flag since we want to go backwards in 
  116.                     memory this time} 
  117. @copyloopr:        {label for loop that scrolls one line right}
  118.    push cx         {save cx}
  119.    mov cx,dx       {put dx (#of cols) in cx so the rep instruction will
  120.                     repeat the right number of times}
  121.    rep movsw       {scroll one line right}
  122.    mov [WORD PTR ds:si+2],0720h {Put a space in the character at col x1,
  123.                                  ds:si points to col x1+1 at the end of the
  124.                                  movsw stuff, so ds:si+2 = col x1}
  125.    pop cx          {restore cx from where it was saved earlier}
  126.    add si,bx       {add bx to si to send si to the next line}
  127.    add di,bx       {ditto for di}
  128.    loop @copyloopr {loop back to @copyloopr to do the next line until done}
  129.    pop ds          {restore ds so your program will know where all its data
  130.                     is}
  131. end;
  132.  
  133. {
  134. These procedures scroll the text in the window with the upper righthand
  135. corner being (x1,y1) and the lower lefthand corner being (x1,y2).  The text
  136. will not scroll outside of the window and the empty columns will be filled
  137. with spaces with an attribute of lightgray on black.  To change what
  138. character and color to put in the new columns, determine the hex number
  139. for the character and color you want, then put the color byte in front of
  140. the character byte and replace the 0720h with it.  For example, to select
  141. character $20 with a color of $04, change the 0720h to 0420h like so:
  142.  
  143.    mov [WORD PTR ds:si+2],0420h  (in scroll_right)
  144.       or
  145.    mov [WORD PTR ds:si-2],0420h  (in scroll_left)
  146.  
  147. these procs simply copy chunks of video memory.  One thing that might help
  148. understand the value for bx and other stuff: the movsw copys the word from
  149. ds:si to es:di, then if the direction flag is clear, it adds 2 to si and to
  150. di, if the direction flag is set, it subtracts 2 from si and di.
  151. }