home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 9 / 09.iso / l / l045 / 2.ddi / GRAFHGC.ASM < prev    next >
Encoding:
Assembly Source File  |  1987-12-23  |  10.1 KB  |  285 lines
  1. ;********************************************************************
  2. ;*                         GRAPHIX TOOLBOX 4.0                      *
  3. ;*       Copyright (c) 1985, 87 by  Borland International, Inc.     *
  4. ;*                                                                  *
  5. ;* Externals for Hercules Monochrome 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.  
  12.          RightBit DB    0             ;Local variables used in DC routine
  13.          XShr3    DW    0
  14. DATA     ENDS
  15.  
  16. HardwareGrafBase  EQU 0B000H          ;Segment of graphics screen buffer
  17. ScreenSizeGlb     EQU 16383           ;The size of the screen in words
  18.  
  19. CODE     SEGMENT  BYTE PUBLIC
  20.  
  21.          ASSUME   CS:CODE, DS:DATA
  22.  
  23.          PUBLIC   DC, DP, SwapScreen, InvertScreen  ;Public routines
  24.  
  25. ; procedure DC(C : byte);
  26. ; { Draw the the character with ASCII code C }
  27. ; { at position (XTextGlb, YTextGlb).        }
  28. ; var
  29. ;   X, Y, I, Adr, Bit, Mask, F : word;
  30. ;
  31. ; begin
  32. ;   X := (XTextGlb-1) * 9;
  33. ;   Y := YTextGlb-1;
  34. ;   Bit := 7 - (X and 7);
  35. ;   Mask := not ($FF80 shr (7-Bit));
  36. ;   for I := 0 To 13 do
  37. ;   begin
  38. ;     Adr := BaseAddress(Y*14+I) + X shr 3;
  39. ;     F := (Font[C][I]) shl 1;
  40. ;     if ((C and $E0) = $C0) then
  41. ;       F := F or ((F and 2) shr 1);
  42. ;     MemW[GrafBase:Adr] := Swap(Swap(MemW[GrafBase:Adr])
  43. ;                           and Mask or (F shl Bit));
  44. ;   end;
  45. ; end; { DC }
  46.  
  47. CPtr              EQU     BYTE PTR [BP+6]
  48.  
  49. DC                PROC FAR
  50.  
  51.          PUSH     BP                       ;Save BP
  52.          MOV      BP,SP                    ;Set up stack frame
  53.          MOV      CH,CPtr                  ;CH := C;
  54.          MOV      AL,CH
  55.          AND      AL,0E0H
  56.          CMP      AL,0C0H
  57.          JNE      XX1
  58.          MOV      AL,1
  59. XX1:     AND      AL,1
  60.          MOV      [RightBit],AL            ;RightBit := (CH in [$C0..$DF]);
  61.          MOV      BL,[XTextGlb]            ;BL := XTextGlb;
  62.          DEC      BL                       ;BL := XTextGlb - 1
  63.          MOV      BH,[YTextGlb]            ;BH := YTextGlb;
  64.          DEC      BH                       ;BH := YTextGlb - 1
  65.          MOV      AL,CH
  66.          XOR      AH,AH
  67.          MOV      DX,AX
  68.          MOV      CL,4
  69.          SHL      AX,CL
  70.          SHL      DX,1
  71.          SUB      AX,DX
  72.          MOV      SI,AX                    ;SI := Ofs(Font[CH]);
  73.          MOV      AX,[GrafBase]
  74.          MOV      ES,AX                    ;ES := GrafBase;
  75.          XOR      DH,DH
  76.          MOV      DL,BL
  77.          MOV      CL,3                     ;CL := 3;
  78.          SHL      DX,CL
  79.          ADD      DL,BL
  80.          ADC      DH,0                     ;DX := BL * 9;
  81.          MOV      AX,DX
  82.          SHR      AX,CL
  83.          MOV      [XShr3],AX               ;XShr3 := DX shl CL;
  84.          MOV      CL,DL
  85.          AND      CL,7                     ;CL := DX and 7;
  86.          MOV      DL,BH
  87.          MOV      BX,0FF80H
  88.          SHR      BX,CL
  89.          NOT      BX                       ;BX := not($7FC0 shr CL);
  90.          XOR      CL,7                     ;CL := CL xor 7;
  91.          XOR      DH,DH
  92.          MOV      AX,DX
  93.          SHL      DX,1
  94.          SHL      DX,1
  95.          SHL      DX,1
  96.          SUB      DX,AX
  97.          SHL      DX,1                     ;DX := BH * 14;
  98.          MOV      CH,0DH                   ;for CH := 0 to 13 do
  99. Loop:    PUSH     BX                       ;begin
  100.          PUSH     CX                       ;Save BX and CX
  101.          XCHG     BX,CX
  102.          XOR      AH,AH
  103.          MOV      AL,BH
  104.          ADD      AX,DX                    ;AX := DX + BH;
  105.          MOV      BX,AX                    ;BX := AX;
  106.          AND      BL,3                     ;BX := BX and 3;
  107.          MOV      CL,0DH                   ;CL := 13;
  108.          SHL      BX,CL                    ;BX := BX shl CL;
  109.          SHR      AX,1
  110.          SHR      AX,1                     ;AX := AX shr 2;
  111.          MOV      AH,5AH
  112.          MUL      AH                       ;AX := AX * 90;
  113.          ADD      AX,BX
  114.          ADD      AX,[XShr3]
  115.          MOV      DI,AX                    ;DI := BX + AX + XShr3;
  116.          POP      CX
  117.          POP      BX                       ;Restore BX and CX
  118.          MOV      AX,ES:[DI]               ;MemW[ES:DI] :=
  119.          XCHG     AL,AH                    ;  Swap(Swap(MemW[ES:DI]) and BX);
  120.          AND      AX,BX
  121.          PUSH     BX
  122.          MOV      BL,CH
  123.          XOR      BH,BH
  124.          MOV      BL,[SI+BX+Font]
  125.          PUSH     AX
  126.          MOV      AL,[RightBit]
  127.          AND      AL,BL
  128.          SHL      BX,1
  129.          OR       BL,AL
  130.          POP      AX
  131.          SHL      BX,CL
  132.          OR       AX,BX                    ;or (Font[C][CH] shl CL);
  133.          XCHG     AL,AH
  134.          MOV      ES:[DI],AX
  135.          POP      BX
  136.          DEC      CH                       ;end;
  137.          JNS      Loop
  138.          POP      BP                       ;Restore BP and return
  139.          RET      2
  140.  
  141. DC                ENDP
  142.  
  143. ; procedure DP(X, Y : word);
  144. ; var
  145. ;   I : word;
  146. ; begin
  147. ;   I := BaseAddress(Y) + X shr 3;
  148. ;   if ColorGlb = 255 then
  149. ;     Mem[GrafBase:I] := Mem[GrafBase:I] or 128 shr (X and 7)
  150. ;   else
  151. ;     Mem[GrafBase:I] := Mem[GrafBase:I] and ($FF7F shr (X and 7));
  152. ; end; { DP }
  153.  
  154. XPtr              EQU     WORD PTR [BP+8]
  155. YPtr              EQU     WORD PTR [BP+6]
  156.  
  157. DP                PROC FAR
  158.  
  159.          PUSH     BP                       ;Save BP
  160.          MOV      BP,SP                    ;Set up stack frame
  161.          MOV      DX,YPtr                  ;DX := Y
  162.          MOV      AX,3
  163.          AND      AX,DX
  164.          MOV      CL,0DH
  165.          SHL      AX,CL
  166.          SHR      DX,1
  167.          AND      DX,0FFFEH
  168.          MOV      BX,DX
  169.          SHL      DX,1
  170.          ADD      DX,BX
  171.          MOV      BX,DX
  172.          MOV      CL,4
  173.          SHL      DX,CL
  174.          SUB      DX,BX
  175.          ADD      AX,DX                    ;AX := BaseAddress(Y)
  176.          MOV      BX,XPtr                  ;BX := X
  177.          MOV      DX,BX
  178.          MOV      CL,03
  179.          SHR      BX,CL                    ;BX := X shr 3
  180.          ADD      BX,AX                    ;BX := BaseAddress(Y) + (X shr 3)
  181.          MOV      CL,DL
  182.          AND      CL,07                    ;CL := X and 7
  183.          MOV      DL,80H                   ;DL := 128
  184.          SHR      DL,CL                    ;DL := 128 shr (X and 7)
  185.          MOV      ES,[GrafBase]            ;ES := base of graphics screen
  186.          CMP      BYTE PTR [ColorGlb],0FFH ;Is ColorGlb = 255 ?
  187.          JNZ      AndBit
  188.          OR    ES:[BX],DL                  ;YES : OR the bit onto the screen
  189.          JMP      Done
  190. AndBit:  NOT      DL                       ;NO  : Invert the bits in DL
  191.          AND   ES:[BX],DL                  ;      AND the bit onto the screen
  192. Done:    POP      BP                       ;Restore BP
  193.          RET      4                        ;Remove parameters and return
  194.  
  195. DP                ENDP
  196.  
  197. ; procedure SwapScreen;
  198. ; { Exchanges the contents the of the displayed }
  199. ; { screen with the contents of the RAM screen  }
  200. ; const
  201. ;   HardwareGrafBase = $B000;
  202. ; var
  203. ;   ScanLine,
  204. ;   LineBase,
  205. ;   RamScrSeg  : word;
  206. ;   LineBuffer : array[0..XMaxGlb] of byte;
  207. ; begin
  208. ;   if RamScreenGlb then
  209. ;   begin
  210. ;     RamScrSeg := Seg(ScreenGlb^);
  211. ;     for ScanLine := 0 to YMaxGlb do
  212. ;     begin
  213. ;       LineBase := BaseAddress(Scanline);
  214. ;       Move(Mem[HardwareGrafBase:LineBase], LineBuffer, XMaxGlb+1);
  215. ;       Move(Mem[RamScrSeg:LineBase], Mem[HardwareGrafBase:LineBase], XMaxGlb+1);
  216. ;       Move(LineBuffer, Mem[RamScrSeg:LineBase], XMaxGlb+1);
  217. ;     end;
  218. ;   end;
  219. ; end; { SwapScreen }
  220.  
  221. SwapScreen          PROC FAR
  222.  
  223.            PUSH     BP                     ;Save BP
  224.            MOV      BP,SP                  ;Set up stack frame
  225.            MOV      AL,RamScreenGlb        ;Load boolean into AL
  226.            XOR      AH,AH                  ;AH <- 0
  227.            OR       AX,AX
  228.            JZ       JumpOut                ;Exit if boolean is false
  229.            LES      DI,[ScreenGlb]         ;ES <- Seg(ScreenGlb^)
  230.            PUSH     DS                     ;Save DS
  231.            MOV      AX,HardwareGrafBase    ;
  232.            MOV      DS,AX                  ;DS <- Seg of hardware screen
  233.            MOV      CX,ScreenSizeGlb       ;CX <- Size of screen in words
  234.            XOR      BX,BX                  ;BX <- word offset of zero
  235. SwapWords: MOV      AX,[BX]                ;AX <- word from hardware screen
  236.            XCHG     AX,ES:[BX]             ;AX <-> soft screen
  237.            MOV      [BX],AX                ;Hardware screen <- AX
  238.            INC      BX
  239.            INC      BX                     ;Increment word offset by 2
  240.            LOOP     SwapWords              ;Swap next byte
  241.            POP      DS                     ;Restore DS
  242. JumpOut:   POP      BP                     ;Restore BP
  243.            RET                             ;Return
  244.  
  245. SwapScreen        ENDP
  246.  
  247. ; procedure InvertScreen;
  248. ; { Invert the contents of screen memory }
  249. ; var
  250. ;   Offset : word;
  251. ; begin
  252. ;   for Offset := 0 to (16383 shl 1)+1 do
  253. ;     Mem[GrafBase:Offset] := Not(Mem[GrafBase:Offset]);
  254. ; end; { InvertScreen }
  255.  
  256. InvertScreen      PROC FAR
  257.  
  258.          PUSH     BP                  ;Save BP
  259.          MOV      BP,SP               ;Set up stack frame
  260.          PUSH     DS                  ;Save data segment
  261.          MOV      AX,[GrafBase]
  262.          MOV      DS,AX               ;DS := base address of graphics screen
  263.          MOV      CX,ScreenSizeGlb    ;CX := Size of screen in integers
  264.          XOR      BX,BX               ;Zero out BX
  265. InvWrd:  NOT      WORD PTR [BX]       ;Invert word at DS:BX
  266.          INC      BX
  267.          INC      BX                  ;Increment to next word
  268.          Loop     InvWrd
  269.          POP      DS                  ;Restore data segment
  270.          POP      BP                  ;Restore BP
  271.          RET                          ;Return
  272.  
  273. InvertScreen      ENDP
  274.  
  275. CODE     ENDS
  276.          END
  277.  
  278.  
  279.  
  280.  
  281.  
  282.  
  283.  
  284.  
  285.