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