home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l045 / 2.ddi / GRAFATT.ASM < prev    next >
Encoding:
Assembly Source File  |  1987-12-23  |  7.9 KB  |  214 lines
  1. ;********************************************************************
  2. ;*                         GRAPHIX TOOLBOX 4.0                      *
  3. ;*       Copyright (c) 1985, 87 by  Borland International, Inc.     *
  4. ;*                                                                  *
  5. ;*          Externals for ATT 6300 (640 X 400) device driver        *
  6. ;********************************************************************
  7.  
  8. DATA     SEGMENT  WORD PUBLIC
  9.          EXTRN    ScreenGlb:DWORD, GrafBase:WORD, RamScreenGlb:BYTE
  10.          EXTRN    XTextGlb:BYTE, YTextGlb:BYTE, ColorGlb:BYTE, Font:BYTE
  11.          EXTRN    RowBase:WORD
  12. DATA     ENDS
  13.  
  14. HardwareGrafBase  EQU 0B800H          ;Segment of graphics screen buffer
  15. ScreenSizeGlb     EQU 16383           ;The size of the screen in words
  16.  
  17. CODE     SEGMENT  BYTE PUBLIC
  18.  
  19.          ASSUME   CS:CODE, DS:DATA
  20.  
  21.          PUBLIC   DC, DP, SwapScreen, InvertScreen  ;Public routines
  22.  
  23. ; procedure DC(C : byte);
  24. ; var
  25. ;   X, Y, I : word;
  26. ; begin
  27. ;   X := XTextGlb-1;
  28. ;   Y := (YTextGlb-1) * 14;
  29. ;   for I := 0 to 13 do
  30. ;     Mem[GrafBase:BaseAddress(Y+I) + X] := Font[C][I];
  31. ; end; { DC }
  32.  
  33. CPtr              EQU     BYTE PTR [BP+6]
  34.  
  35. DC                PROC FAR
  36.  
  37.          PUSH     BP                      ;Save BP
  38.          MOV      BP,SP                   ;Set up stack frame
  39.          MOV      AL,[YTextGlb]
  40.          XOR      AH,AH
  41.          DEC      AX                      ;AX := YTextGlb - 1;
  42.          MOV      DI,16
  43.          MUL      DI
  44.          SHL      AX,1
  45.          XCHG     AX,DI                   ;DI := (YTextGlb-1) shl 1
  46.          MOV      AL,CPtr                 ;AL := C
  47.          XOR      AH,AH
  48.          SHL      AX,1
  49.          MOV      BX,AX
  50.          SHL      AX,1
  51.          ADD      BX,AX
  52.          SHL      AX,1
  53.          ADD      BX,AX
  54.          ADD      BX, OFFSET Font         ;BX := Addr(Font[C])
  55.          MOV      DL,[XTextGlb]
  56.          DEC      DL
  57.          MOV      DH,0                    ;DX := XTextGlb-1
  58.          MOV      AX,[GrafBase]
  59.          MOV      ES,AX                   ;ES := GrafBase
  60.          MOV      CH,14                   ;Loop 14 times
  61. Loop:    MOV      SI,[DI+OFFSET RowBase]  ;SI := BaseAddress(Y + I)
  62.          ADD      SI,DX                   ;SI := BaseAddress(Y + I) + X
  63.          MOV      AL,[BX]                 ;AL := Font[C][I]
  64.          MOV   ES:[SI],AL                 ;Write piece of char to mem
  65.          INC      BX                      ;Increment font offset
  66.          INC      DI
  67.          INC      DI                      ;Increment RowBase index
  68.          DEC      CH                      ;Decrement loop counter
  69.          JNZ      Loop                    ;If CH not zero then jump to loop
  70.  
  71.          POP      BP                      ;Restore BP
  72.          RET      2                       ;Remove parameter and return
  73.  
  74. DC                ENDP
  75.  
  76. ; procedure DP(X, Y : word);
  77. ; var
  78. ;   I : word;
  79. ; begin
  80. ;   I := BaseAddress(Y) + X shr 3;
  81. ;   if ColorGlb = 255 then
  82. ;     Mem[GrafBase:I] := Mem[GrafBase:I] or 128 shr (X and 7)
  83. ;   else
  84. ;     Mem[GrafBase:I] := Mem[GrafBase:I] and ($FF7F shr (X and 7));
  85. ; end; { DP }
  86.  
  87. XPtr              EQU     WORD PTR [BP+8]
  88. YPtr              EQU     WORD PTR [BP+6]
  89.  
  90. DP                PROC FAR
  91.  
  92.          PUSH     BP                       ;Save BP
  93.          MOV      BP,SP                    ;Set up stack frame
  94.          MOV      AX,YPtr                  ;AX := Y
  95.          AND      AX,3                     ;AX := (Y and 3)
  96.          MOV      CL,0DH
  97.          SHL      AX,CL                    ;AX := (Y and 3) shl 13
  98.          MOV      CX,AX                    ;CX := (Y and 3) shl 13
  99.          MOV      AX,YPtr                  ;AX := Y
  100.          SHR      AX,1
  101.          SHR      AX,1                     ;AX := Y shr 2
  102.          MOV      DX,80
  103.          MUL      DX                       ;AX := 80 * (Y shr 2)
  104.          ADD      AX,CX                    ;AX := BaseAddress(Y)
  105.          MOV      BX,XPtr                  ;BX := X
  106.          MOV      DX,BX
  107.          MOV      CL,03
  108.          SHR      BX,CL                    ;BX := X shr 3
  109.          ADD      BX,AX                    ;BX := BaseAddress(Y) + (X shr 3)
  110.          MOV      CL,DL
  111.          AND      CL,07                    ;CL := X and 7
  112.          MOV      DL,80H                   ;DL := 128
  113.          SHR      DL,CL                    ;DL := 128 shr (X and 7)
  114.          MOV      ES,[GrafBase]            ;ES := base of graphics screen
  115.          CMP      BYTE PTR [ColorGlb],0FFH ;Is ColorGlb = 255 ?
  116.          JNZ      AndBit
  117.          OR    ES:[BX],DL                  ;YES : OR the bit onto the screen
  118.          JMP      Done
  119. AndBit:  NOT      DL                       ;NO  : Invert the bits in DL
  120.          AND   ES:[BX],DL                  ;      AND the bit onto the screen
  121. Done:    POP      BP                       ;Restore BP
  122.          RET      4                        ;Remove parameters and return
  123.  
  124. DP                ENDP
  125.  
  126. ; procedure SwapScreen;
  127. ; { Exchanges the contents the of the displayed }
  128. ; { screen with the contents of the RAM screen  }
  129. ; const
  130. ;   HardwareGrafBase = $B800;
  131. ; var
  132. ;   ScanLine,
  133. ;   LineBase,
  134. ;   RamScrSeg  : word;
  135. ;   LineBuffer : array[0..XMaxGlb] of byte;
  136. ; begin
  137. ;   if RamScreenGlb then
  138. ;   begin
  139. ;     RamScrSeg := Seg(ScreenGlb^);
  140. ;     for ScanLine := 0 to YMaxGlb do
  141. ;     begin
  142. ;       LineBase := BaseAddress(Scanline);
  143. ;       Move(Mem[HardwareGrafBase:LineBase], LineBuffer, XMaxGlb+1);
  144. ;       Move(Mem[RamScrSeg:LineBase], Mem[HardwareGrafBase:LineBase], XMaxGlb+1);
  145. ;       Move(LineBuffer, Mem[RamScrSeg:LineBase], XMaxGlb+1);
  146. ;     end;
  147. ;   end;
  148. ; end; { SwapScreen }
  149.  
  150. SwapScreen          PROC FAR
  151.  
  152.            PUSH     BP                     ;Save BP
  153.            MOV      BP,SP                  ;Set up stack frame
  154.            MOV      AL,RamScreenGlb        ;Load boolean into AL
  155.            XOR      AH,AH                  ;AH <- 0
  156.            OR       AX,AX
  157.            JZ       JumpOut                ;Exit if boolean is false
  158.            LES      DI,[ScreenGlb]         ;ES <- Seg(ScreenGlb^)
  159.            PUSH     DS                     ;Save DS
  160.            MOV      AX,HardwareGrafBase    ;
  161.            MOV      DS,AX                  ;DS <- Seg of hardware screen
  162.            MOV      CX,ScreenSizeGlb       ;CX <- Size of screen in words
  163.            XOR      BX,BX                  ;BX <- word offset of zero
  164. SwapWords: MOV      AX,[BX]                ;AX <- word from hardware screen
  165.            XCHG     AX,ES:[BX]             ;AX <-> soft screen
  166.            MOV      [BX],AX                ;Hardware screen <- AX
  167.            INC      BX
  168.            INC      BX                     ;Increment word offset by 2
  169.            LOOP     SwapWords              ;Swap next byte
  170.            POP      DS                     ;Restore DS
  171. JumpOut:   POP      BP                     ;Restore BP
  172.            RET                             ;Return
  173.  
  174. SwapScreen        ENDP
  175.  
  176. ; procedure InvertScreen;
  177. ; { Invert the contents of screen memory }
  178. ; var
  179. ;   Offset : word;
  180. ; begin
  181. ;   for Offset := 0 to (16383 shl 1)+1 do
  182. ;     Mem[GrafBase:Offset] := Not(Mem[GrafBase:Offset]);
  183. ; end; { InvertScreen }
  184.  
  185. InvertScreen      PROC FAR
  186.  
  187.          PUSH     BP                  ;Save BP
  188.          MOV      BP,SP               ;Set up stack frame
  189.          PUSH     DS                  ;Save data segment
  190.          MOV      AX,[GrafBase]
  191.          MOV      DS,AX               ;DS := base address of graphics screen
  192.          MOV      CX,ScreenSizeGlb    ;CX := Size of screen in integers
  193.          XOR      BX,BX               ;Zero out BX
  194. InvWrd:  NOT      WORD PTR [BX]       ;Invert word at DS:BX
  195.          INC      BX
  196.          INC      BX                  ;Increment to next word
  197.          Loop     InvWrd
  198.          POP      DS                  ;Restore data segment
  199.          POP      BP                  ;Restore BP
  200.          RET                          ;Return
  201.  
  202. InvertScreen      ENDP
  203.  
  204. CODE     ENDS
  205.          END
  206.  
  207.  
  208.  
  209.  
  210.  
  211.  
  212.  
  213.  
  214.