vdugrafe

; Copyright 1996 Acorn Computers Ltd
;
; Licensed under the Apache License, Version 2.0 (the "License");
; you may not use this file except in compliance with the License.
; You may obtain a copy of the License at
;
;     http://www.apache.org/licenses/LICENSE-2.0
;
; Unless required by applicable law or agreed to in writing, software
; distributed under the License is distributed on an "AS IS" BASIS,
; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
; See the License for the specific language governing permissions and
; limitations under the License.
;
; > $.Source.VduGrafE
;
; ARTHUR OPERATING SYSTEM - Vdu Drivers
; =======================
;
; Vdu driver code - Line Fill L & R and Flood Fill
;
; Author R C Manby
; Date   17.10.86
;

; *****************************************************************************
;
; FillLRnonBg
; ===========
;
; On entry, R0 (X), R1 (Y) hold point to fill from
;
; On exit, R0..R11 corrupt
;

FillLRtoFg
        ADD     R2, WsPtr, #FgEcf
        MOV     R3, #0
        B       FillLRnonBg10           ; Fill L <-> R

FillLRnonBg
        ADD     R2, WsPtr, #BgEcf
        MOV     R3, #&80000000
FillLRnonBg10
        SaveRetAdr
        BL      FillAlong2
        SUBCS   R1, R1, #1              ; indicate nothing filled by Y-=1
        STR     R0, [WsPtr, #GCsIX]     ; left X
        STR     R1, [WsPtr, #GCsIY]     ; Y
        Return  CS                      ; external new pt hasn't changed
        STR     R2, [WsPtr, #NewPtX]    ; right X
        MOV     R0, R2
        BL      IEGB                    ; update external version of new NewPt
        Return                          ; then things get shuffled

; *****************************************************************************
;
; FillLRtoBg    (Really only fill right!)
; ==========
;
; On entry, R0 (X), R1 (Y) hold point to fill from
;
; On exit, R0..R11 corrupt
;

FillLRnonFg
        ADD     R2, WsPtr, #FgEcf
        MOV     R3, #&80000000
        B       FillLRtoBg10            ; Fill -> R

FillLRtoBg
        ADD     R2, WsPtr, #BgEcf
        MOV     R3, #&0
FillLRtoBg10
        SaveRetAdr
        STR     R0, [WsPtr, #GCsIX]     ; "left hand point" = given point
        STR     R1, [WsPtr, #GCsIY]
        BL      GenLineFillParm         ; if C=1 (nothing can be plotted)
        SUBCS   R0, R0, #1              ; then NewPtX-=1 ie NewPtX < GCsIX
        BLCC    FillLineRightRegs       ; else fill right
        STR     R0, [WsPtr, #NewPtX]    ; Convert NewPt(X,Y) (internal) into
        LDR     R1, [WsPtr, #NewPtY]    ; GCs(X,Y) (external)
        BL      IEGB
        Return                          ; On returning, cursors are shuffled
                                        ; which updates GCsI(X,Y)

; *****************************************************************************
;
; GenLineFillParm
; ===============
;
; On entry, R0 (X), R1 (Y) hold point to fill from
;           R2 points to delimiting colour (FgEcf/BgEcf)
;           R3 fill flag, 0/&80000000 for fill to/to-non
;
; On exit, Carry=0, valid parameter setup, R0-R10 contain copy of control block
;          Carry=1, point outside window, R0 preserved, R1-R10 undefined
;
;  Format of control block
;
;  R0  - StartX
;  R1  - DelimitColour
;  R2  - FillFlag
;  R3  - ScreenAdr
;  R4  - PixelMsk
;  R5  - zgora
;  R6  - zgeor
;  R7  - GWLCol
;  R8  - GWRCol
;  R9  - BytesPerChar
;  R10 - NPix
;
GenLineFillParm
        WINDow  R0,R1, R7,R8,R9,R10     ; Window(R0,R1) using R7-R10
                                        ;  gives GE if in window
        BGE     %FT01
        SEC                             ; If point outside window
        MOV     PC, Link                ;  then quit with carry set
01
        Push    "R2,R3,R7,R9,Link"      ; Save colourptr, fillflag
                                        ; GWLCol, GWRCol
        BL      ScreenAddr              ; Returns R2 = Addr, R3 = Mask

        LDR     R9, [WsPtr, #YWindLimit]
        SUB     R9, R9, R1              ; Flip Ycoord
        AND     R9, R9, #7              ; Line within ecf
        LDR     R5, [WsPtr, #GColAdr]   ; Base address of ecf pattern
        ADD     R5, R5, R9, LSL #3
        LDMIA   R5, {R5, R6}            ; Get zgora,zgeor

        MOV     R4, R3
        MOV     R3, R2

        Pull    "R1,R2,R7,R8,Link"      ; restore other registers
        LDR     R1, [R1, R9, LSL #2]    ; load delimiting colour
        LDR     R9, [WsPtr, #BytesPerChar]
        LDR     R10, [WsPtr, #NPix]

        ADD     R11, WsPtr, #LineFillBlk ; now save completed control block
        STMIA   R11, {R0-R10}

        LDR     R11, [R3]               ; load screen
        EOR     R11, R11, R1            ; screen EOR boundary
        TST     R11, R4                 ; just look at this pixel
        ; Blimey.
        MRS     R7, CPSR
        TEQ     R2, R7, LSL #1          ; N := (Z EOR R2) ie invert test if
                                        ; stopping on non-colour
        BICPL   R7, R7, #C_bit          ; point can be filled, exit CC
        ORRMI   R7, R7, #C_bit          ; point cannot be filled, exit CS
        MSR     CPSR_f, R7
        MOV     PC, Link

; *****************************************************************************
;
; FillLineRight - Fill right from point upto delimiting colour
; =============    or graphics window
;
;
;  R0  - RightLimitX
;  R1  - LimitColour
;  R2  - FillFlag
;  R3  - ScreenAdr
;  R4  - PixelMsk
;  R5  - zgora
;  R6  - zgeor
;  R7  - GWLCol /BPC/NPIX
;  R8  - GWRCol
;  R9  -          ScreenWord
;  R10 - NPix
;  R11 -          MultPixMsk     / temp
;
; out:  PSR must be preserved
;
FillLineRight ROUT
        ADD     R11, WsPtr, #LineFillBlk
        LDMIA   R11, {R0-R10}
FillLineRightRegs
        Push    R14
        MRS     R14, CPSR
        Push    "WsPtr, R14"            ; we also need R12 for a temp
        RSB     R7, R9, #32             ; shift factor for next pixel position
        SUB     R0, R8, R0
10
        MOV     R11, #0                 ; clear partial word mask
        LDR     R9, [R3]                ; screen word EOR delimit colour
        EOR     R14, R9, R1
30
        TST     R14, R4                 ; test pixel position for delimiting
        MRS     WsPtr, CPSR
        TEQ     R2, WsPtr, LSL #1       ; invert condition if necessary

        ORRPL   R11, R11, R4            ; add pixel to partial word mask
        SUBPLS  R0, R0, #1              ; "increment" X; if on edge of window
        BMI     %FT40                   ; then give up and plot partial word

        TEQ     R4, #0                  ; test for end of word
        MOV     R4, R4, ROR R7          ; shift pixel mask left
        BPL     %BT30

        AND     R14, R5, R11            ; fill partial word, using pixel mask
        AND     R11, R6, R11            ; in R11
        ORR     R9, R9, R14
        EOR     R9, R9, R11
        STR     R9, [R3], #4

        CMP     R2, #2                  ; CC => filling until pixel=target
        BCC     %BT10                   ; so do it slowly (goto next word)

        RSB     R0, R0, #0              ; make X in range GWLCol-GWRCol .. 0
        ADDS    R0, R0, R10             ; move R0 to end of word
        BGT     %FT36                   ; outside window, continue slowly

        ORR     R14, R1, R5             ; word to store if going fast
        EOR     R14, R14, R6

32
        LDR     R9, [R3]                ; screen word
        CMP     R9, R1                  ; EOR target colour (CS if EQ)
        BNE     %FT36
        STR     R14, [R3], #4
        ADCS    R0, R0, R10             ; C=1, so add NPix+1
        BLE     %BT32
36
        SUBS    R0, R10, R0             ; R0 back to start of word and negate
        BGE     %BT10                   ; if still inside, continue slowly
        B       %FT50

40
        AND     R14, R5, R11            ; fill partial word, using pixel mask
        AND     R11, R6, R11            ; in R11
        ORR     R9, R9, R14
        EOR     R9, R9, R11
        STR     R9, [R3]
50
        SUB     R0, R8, R0              ; make back into normal coord again
        SUB     R0, R0, #1              ; correct end point
        Pull    "WsPtr, R14"
        MSR     CPSR_f, R14
        Pull    PC

; *****************************************************************************
;
; FillLineLeft - Fill left from point upto delimiting colour
; ============    or graphics window
;
;                N.B. Starts one pixel left of point given, since
;                      FillLineRight will have already plotted it.
;
;  R0  - LeftLimitX
;  R1  - LimitColour
;  R2  - FillFlag
;  R3  - ScreenAdr
;  R4  - PixelMsk
;  R5  - zgora
;  R6  - zgeor
;  R7  - GWLCol                 } Slightly different from FillLineRight
;  R8  - GWRCol /BPC/NPIX       }
;  R9  -          ScreenWord
;  R10 -          LimitEorScreen / temp
;  R11 -          MultPixMsk     / temp
;
;
;
FillLineLeft ROUT
        ADD     R11, WsPtr, #LineFillBlk
        LDMIA   R11, {R0-R10}
FillLineLeftRegs
        Push    R14
        MRS     R14, CPSR
        Push    "WsPtr, R14"            ; also need WsPtr for a temp
        MOV     R8, R9                  ; shift factor for next pixel position

        SUB     R0, R0, R7
        LDR     R9, [R3]                ; screen word EOR delimit colour
        EOR     R14, R9, R1
        MOVS    R11, #0                 ; clear partial word mask (and set PL)
        B       %FT31

10
        MOV     R11, #0                 ; clear partial word mask
        LDR     R9, [R3]                ; screen word EOR delimit colour
        EOR     R14, R9, R1

30
        TST     R14, R4                 ; test pixel position for delimiting
        MRS     WsPtr, CPSR
        TEQ     R2, WsPtr, LSL #1       ; invert condition if appropriate
        ORRPL   R11, R11, R4            ; add pixel to partial word mask
31
        SUBPLS  R0, R0, #1              ; decrement X; if on edge of window
        BMI     %FT40                   ; then give up and plot partial word

        MOVS    R4, R4, ROR R8          ; test for end of word
        BPL     %BT30                   ; loop until mask exhausted

        AND     R14, R5, R11            ; fill partial word, using pixel mask
        AND     R11, R6, R11            ; in R11
        ORR     R9, R9, R14
        EOR     R9, R9, R11
        STR     R9, [R3], #-4

        CMP     R2, #2                  ; CC => filling until pixel=target
        BCC     %BT10                   ; so do it slowly (goto next word)

        SUBS    R0, R0, R10             ; move R0 to beginning of word
        BCC     %FT36                   ; if outside window continue slowly
        ADD     R10, R10, #1
        ORR     R14, R1, R5             ; compute target word
        EOR     R14, R14, R6
32
        LDR     R9, [R3]                ; screen word
        CMP     R9, R1
        BNE     %FT35                   ; NZ => terminate
        STR     R14, [R3], #-4
        SUBS    R0, R0, R10
        BCS     %BT32
35
        SUB     R10, R10, #1
36
        ADDS    R0, R0, R10             ; point R0 back to end of word
        BGE     %BT10                   ; if still inside, continue but slowly
        B       %FT50

40
        AND     R14, R5, R11            ; fill partial word, using pixel mask
        AND     R11, R6, R11            ; in R11
        ORR     R9, R9, R14
        EOR     R9, R9, R11
        STR     R9, [R3]
50
        ADD     R0, R0, R7              ; add GWLCol back on
        ADD     R0, R0, #1              ; Correct endpoint value
        Pull    "WsPtr, R14"
        MSR     CPSR_f, R14
        Pull    PC

; *****************************************************************************
;
; FillAlong - Fill left and right from point given
; =========
;
; On entry, R0 (X), R1(Y) hold point to fill from
;
; On exit,  R0 (X) End of scan left
;           R1 (Y) Preserved
;           R2 (X) End of scan right
;
;           Carry set = no fill performed ie outside window or already filled
;           Carry clear = fill occured
;
        ASSERT  FldBoundaryFlag = FldBoundaryCol +4

FillAlong
        ADD     R2, WsPtr, #FldBoundaryCol
        LDMIA   R2, {R2,R3}             ; R2 = colour, R3 = flag
FillAlong2                              ; entry point when R2, R3 loaded
        Push    "R1, R14"
        BL      GenLineFillParm         ; On exit C=1 if nothing can be plotted
        BLCC    FillLineRightRegs
        Push    R0                      ; New RightX
        BLCC    FillLineLeft
        Pull    R2                      ; Recover RightX
        Pull    "R1, PC"                ; Recover Y, C=1 <=> fill occured

; *****************************************************************************
;
; FloodFill
; =========
;
; On entry, R0 (X), R1 (Y) hold point to flood from
;           R2 Delimit colour, pointer to FgEcf/BgEcf
;           R3 0/&80000000 for flood until/over
;
        ASSERT  FldBoundaryFlag = FldBoundaryCol +4
        ASSERT  FldY = FldLeftXLimit +4
        ASSERT  FldRightXLimit = FldLeftXLimit +8

FloodToFg
        ADD     R2, WsPtr, #FgEcf       ; delimit colour
        MOV     R3, #0                  ; flood until
        B       FloodFill

FloodNonBg
        ADD     R2, WsPtr, #BgEcf       ; delimit colour
        MOV     R3, #&80000000          ; flood over
FloodFill ROUT
        Push    R14
        STR     R13, [WsPtr, #FldStackLevel]    ; save stack level !

        ADD     R14, WsPtr, #FldBoundaryCol
        LDR     R4, [WsPtr, #YWindLimit]
        STMIA   R14, {R2-R4}            ; store colour, flag, YWindLimit

        [ med_00001_userma

        ; the idea here is to try to use between 48k and 128k of rma instead of 16k of
        ; scratchspace. if there's less than 48k of rma in the first place we go back to
        ; scratchspace. if there's 128k or more we claim the 128k and proceed. For values
        ; between 48k and 128k we first grow the rma by 128k-largest_free_space. If this
        ; results in a lump of 128k now being free we claim it and proceed. If the largest
        ; free space hasn't grown to 128k we then claim the additional balance needed to
        ; have 128k available. Should either grow fail, we just use whatever (over 48k)
        ; was available

        ;R3-R7 spare at presenet
        Push    "R0-R2"
        MOV     R0, #0
        STR     R0, [WsPtr, #flood_cda_rma]                     ; set amount to change dyn. area by
        MOV     R0, #ModHandReason_RMADesc
        SWI     XOS_Module                                      ; get the largest free space in rma
        BVC     %FT91                                           ; if that failed, use scratchspace

use_scratchspace
        LDR     R3, =FldQueueStart                              ; head ptr (== scratchspace)
        MOV     R4, R3                                          ; tail ptr
        ADD     R5, R3, #FldQueueSize                           ; end ptr (== scratchspace size)
        MOV     R6, R3                                          ; start ptr
        B       %FT92
91
        CMP     R2, #smallest_rma_size                          ; compare against small threshold
        BLT     use_scratchspace                                ; not enough free - use scratchspace
        CMP     R2, #largest_rma_size                           ; compare against high threshold
        BHS     %FT96                                           ; lots free - use largest ceiling value

        RSB     R1, R2, #largest_rma_size                       ; work out how much more to claim
        MOV     R0, #1                                          ; rma
        SWI     XOS_ChangeDynamicArea
        STRVC   R1, [WsPtr, #flood_cda_rma]                     ; save the amount we grew the rma
        BVS     %FT94                                           ; if it failed, use the minimum<size<maximum lump

        MOV     R0, #ModHandReason_RMADesc                      ; reread the largest free space to see if
        SWI     XOS_Module                                      ; it has risen to maximum
        BVS     use_scratchspace
        CMP     R2, #largest_rma_size
        BHS     %FT96                                           ; it has, so claim the maximum

        LDR     R1, [WsPtr, #flood_cda_rma]                     ; the free space didn't grow to maximum, so the
        RSB     R1, R1, #largest_rma_size                       ; largest space wasn't at the end. Do a second
        MOV     R0, #1                                          ; grow of the rma to make the maximum
        SWI     XOS_ChangeDynamicArea
        LDRVC   R0, [WsPtr, #flood_cda_rma]                     ; if it succeeded, update the amount that we
        ADDVC   R0, R0, R1                                      ; need to shrink the rma by
        STRVC   R0, [WsPtr, #flood_cda_rma]
                                                                ; and fall into the claim largest space routine
94
        MOV     R0, #ModHandReason_RMADesc
        SWI     XOS_Module
        BVS     use_scratchspace                                ; find the largest lump now available
        CMP     R2, #largest_rma_size
96
        MOVGT   R3, #largest_rma_size
        MOVLE   R3, R2                                          ; cap it at the maximum size we want
        MOV     R0, #ModHandReason_Claim                        ; try to claim it
        SWI     XOS_Module
        BVS     use_scratchspace

        ADD     R5, R2, R3                                      ; do it in a slightly different order so
        MOV     R3, R2                                          ; we can use the R2 and R3 back from the claim
        MOV     R4, R3                                          ; (R2=where, R3=size)
        MOV     R6, R3

92
        ADD     R7, WsPtr, #QueuePtrs
        STMIA   R7, {R3, R4, R5, R6}    ; initialise queue
        Pull    "R0-R2"
        |
        LDR     R3, =FldQueueStart      ; head ptr
        MOV     R4, R3                  ; tail ptr
        ADD     R5, R3, #FldQueueSize   ; end ptr
        MOV     R6, R3                  ; start ptr
        ADD     R7, WsPtr, #QueuePtrs
        STMIA   R7, {R3, R4, R5, R6}    ; initialise queue
        ]

        BL      FillAlong               ; try filling L&R from given point
        Pull    PC, CS                  ; quit if can't be filled

        MOV     R3, #3                  ; bit0 => fill up, bit1 => fill down
10
        ADD     R14, WsPtr, #FldLeftXLimit
        STMIA   R14, {R0-R2}            ; store leftX, Y, rightX

        TST     R3, #1
        BEQ     %FT20

        LDR     R10, [WsPtr, #GWTRow]   ; if below Top of window
        CMP     R10, R1
        BLE     %FT20

        ADD     R4, WsPtr, #FldBoundaryCol      ; R4=target colour ptr,R5=flag,
        LDMIA   R4, {R4,R5,R6}                  ; R6=YWindLimit

        ORR     R5, R5, #FillingUpBit   ; fill line above
        Push    R3
        BL      CheckAlong              ; (will bomb out if queue explodes)
        Pull    R3

        ADD     R14, WsPtr, #FldLeftXLimit
        LDMIA   R14, {R0,R1}            ; reload leftX, Y
20
        TST     R3, #2
        BEQ     %FT30

        LDR     R10, [WsPtr, #GWBRow]   ; if above bottom of window
        CMP     R1, R10
        BLE     %FT30

        ADD     R4, WsPtr, #FldBoundaryCol      ; R4=target colour ptr,R5=flag,
        LDMIA   R4, {R4,R5,R6}                  ; R6=YWindLimit

;        BIC     R5, R5, #FillingUpBit  ; fill line below
        BL      CheckAlong              ; (will bomb out if queue explodes)
30
        ADD     R11, WsPtr, #QueuePtrs  ; unqueue one item
        LDMIA   R11, {R3,R4,R5}         ; head,tail,limit
        TEQ     R3, R4                  ; if queue empty
        [ med_00001_userma
        BLEQ    release_memory
        ]
        Pull    PC, EQ                  ; then exit

        [ med_00001_twowords
        LDR     R1, [R3], #4
        MOV     R0, R1, LSR #16         ; LeftX
        MOV     R2, R1
        EOR     R2, R2, R0, LSL #16     ; RightX (with LeftX EORed out)
        LDR     R1, [R3], #4            ; Recover Y
        |
        LDR     R1, [R3], #4            ; then load word
        MOV     R2, R1, LSR #21         ; Recover RightX
        EOR     R1, R1, R2, LSL #21     ; clear those bits out
        MOV     R0, R1, LSR #10         ; Recover LeftX
        EOR     R1, R1, R0, LSL #10     ; Recover Y
        ]
        TEQ     R3, R5                  ; if at limit
        LDREQ   R3, [R11, #12]          ; then reload with start
        STR     R3, [R11, #0]           ; store head ptr back

        MOV     R3, #2                  ; indicate fill down
        CMP     R2, R0                  ; if right < left then subtract 1 off
                                        ; larger and swap
        SBCCC   R0, R0, R2              ; R0 := large-small-1
        ADDCC   R2, R0, R2              ; R2 := (large-small-1)+small = large-1
        SUBCC   R0, R2, R0              ; R0 := (large-1)-(large-small-1)=small
        MOVCC   R3, #1                  ; and indicate fill up
        B       %BT10

; *****************************************************************************
;
; CheckAlong - Fill and skip background between LeftXLimit & RightXLimit
; ==========
;
; On entry, R0 LeftXLimit
;           R1 Y
;           R4 target colour
;           R5 fill flag
;           R6 YWindLimit
;
; Exits using R14 if normal termination
; Exits using FldStackLevel if queue full
;

FillingUpBit * 1

        ASSERT  FldBoundaryFlag = FldBoundaryCol +4
        ASSERT  FldYWindLimit = FldBoundaryCol +8

        ASSERT  FldY = FldLeftXLimit +4
        ASSERT  FldRightXLimit = FldLeftXLimit +8

CheckAlong ROUT
        Push    R14

        TST     R5, #FillingUpBit               ; if going up
        ADDNE   R1, R1, #1                      ; then increment Y
        SUBEQ   R1, R1, #1                      ; else decrement Y

        BL      ScreenAddr                      ; R2=screen addr, R3=mask

        SUB     R6, R6, R1                      ; flip Y
        AND     R6, R6, #7                      ; ecf offset
        LDR     R4, [R4, R6, LSL #2]            ; R4=target colour
        LDR     R7, [WsPtr, #GColAdr]           ; base address of plot ecf
        ADD     R7, R7, R6, LSL #3              ; R7 -> zgora, zgeor
        LDMIA   R7, {R10,R11}                   ; R10=zgora, R11=zgeor
        LDR     R6, [WsPtr, #BytesPerChar]      ; R6=pixel shift
        LDR     R9, [WsPtr, #NPix]              ; R9=no. of pixels per word-1

        ADD     R7, WsPtr, #FldSaveArea         ; save Y, target colour,
        STMIA   R7, {R1, R4, R9, R10, R11}      ; NPix, zgora, zgeor

; test first pixel, to see if we can go left

        LDR     R7, [R2]
        EOR     R1, R7, R4
        TST     R1, R3
        MRS     R8, CPSR
        TEQ     R5, R8, LSL #1          ; PL => it's fillable
        RSBMI   R6, R6, #32             ; not fillable, reverse pixel shift
        LDRMI   R8, [WsPtr, #GWRCol]    ; load right window limit
        BMI     %FT37                   ; and skip left+right filling bit

        Push    "R0, R2, R3"            ; save X, screen address, mask
        LDR     R8, [WsPtr, #GWLCol]
        SUB     R0, R0, R8              ; make X in range 0..GWRCol-GWLCol
        MOV     R14, #0                 ; clear partial word mask
        TEQ     R5, #0                  ; get into correct loop
        BMI     %FT84
        BPL     %FT64

10
        MOV     R14, #0                 ; clear partial word mask
        LDR     R7, [R2]                ; R7 = screen
        EOR     R1, R7, R4

 ; ***KJB - very cumbersome. Surely a temporary reg somewhere?
        TEQ     R5, #0                  ; check "not" flag
        BMI     %FT80

61      TST     R1, R3                  ; test pixel position for delimiter
        BEQ     %FT22                   ; NE => it's fillable
        ORR     R14, R14, R3            ; add pixel to partial word mask
64      SUBS    R0, R0, #1              ; decrement X; if on edge of window
        BMI     %FT22                   ; then give up and plot partial word

        MOVS    R3, R3, ROR R6          ; test for end of word
        BPL     %BT61                   ; loop until mask wraps
        B       %FT89

80      TST     R1, R3                  ; test pixel position for delimiter
        BNE     %FT22                   ; EQ => it's fillable
        ORR     R14, R14, R3            ; add pixel to partial word mask
84      SUBS    R0, R0, #1              ; decrement X; if on edge of window
        BMI     %FT22                   ; then give up and plot partial word

        MOVS    R3, R3, ROR R6          ; test for end of word
        BPL     %BT80                   ; loop until mask wraps
89

        AND     R1, R10, R14            ; R1 := zgora AND pixmask
        ORR     R7, R7, R1              ; screen := screen OR R1
        AND     R1, R11, R14            ; R1 := zgeor AND pixmask
        EOR     R7, R7, R1              ; screen := screen EOR R1
        STR     R7, [R2], #-4

        CMP     R5, #2                  ; CC => filling until target
        BCC     %BT10                   ; so do it slowly (do next word)

        SUBS    R0, R0, R9              ; move R0 to start of word
        BCC     %FT20                   ; if outside window continue slowly

        ADD     R9, R9, #1              ; R9 := pixels per word
        ORR     R1, R4, R10             ; compute word to plonk on screen
        EOR     R1, R1, R11
16
        LDR     R7, [R2]                ; screen word
        CMP     R7, R4
        BNE     %FT18                   ; NZ => terminate
        STR     R1, [R2], #-4
        SUBS    R0, R0, R9              ; back another word
        BCS     %BT16
18
        SUB     R9, R9, #1              ; R9 := pixels per word -1
20
        ADDS    R0, R0, R9              ; point R0 back to end of word
        BGE     %BT10                   ; if still inside, continue but slowly
        B       %FT24                   ; else exit
22
        AND     R1, R10, R14            ; R1 := zgora AND pixmask
        ORR     R7, R7, R1              ; screen := screen OR R1
        AND     R1, R11, R14            ; R1 := zgeor AND pixmask
        EOR     R7, R7, R1              ; screen := screen EOR R1
        STR     R7, [R2]
24
        ADD     R0, R0, R8              ; add GWLCol back on
        ADD     R0, R0, #1
        Pull    "R1, R2, R3"            ; restore X, screen addr, mask
        Push    R0                      ; save left-of-line coordinate
        MOV     R0, R1                  ; R0 = start X
        RSB     R6, R6, #32             ; reverse pixel shift
        LDR     R8, [WsPtr, #GWRCol]    ; load right window limit

; now the filling right part

26
        SUB     R0, R8, R0              ; make X in range GWRCol-GWLCol .. 0

; start of each word

27
        MOV     R14, #0
        LDR     R7, [R2]                ; screen word
        EOR     R1, R7, R4

; ***KJB - very cumbersome. Surely a temporary reg somewhere?
        TEQ     R5, #0
        BMI     %FT75
72
        TST     R1, R3                  ; test pixel position for delimiter
        BEQ     %FT34                   ; NE => it's fillable
        ORR     R14, R14, R3            ; add pixel to partial word mask
        SUBS    R0, R0, #1              ; "increment" X; if on edge of window
        BMI     %FT34                   ; then give up and plot partial word

        TEQ     R3, #0                  ; test for end of word
        MOV     R3, R3, ROR R6          ; shift pixel mask
        BPL     %BT72                   ; loop until mask wraps
        B       %FT79

75
        TST     R1, R3                  ; test pixel position for delimiter
        BNE     %FT34                   ; EQ => it's fillable
        ORR     R14, R14, R3            ; add pixel to partial word mask
        SUBS    R0, R0, #1              ; "increment" X; if on edge of window
        BMI     %FT34                   ; then give up and plot partial word

        TEQ     R3, #0                  ; test for end of word
        MOV     R3, R3, ROR R6          ; shift pixel mask
        BPL     %BT75                   ; loop until mask wraps
79

        AND     R1, R10, R14            ; R1 := zgora AND pixmask
        ORR     R7, R7, R1              ; screen := screen OR R1
        AND     R1, R11, R14            ; R1 := zgeor AND pixmask
        EOR     R7, R7, R1              ; screen := screen EOR R1
        STR     R7, [R2], #4

        CMP     R5, #2                  ; CC => filling until target
        BCC     %BT27                   ; so do it slowly (do next word)

        RSB     R0, R0, #0              ; make X in range GWLCol-GWRCol .. 0
        ADDS    R0, R0, R9              ; move R0 to end of word
        BGT     %FT32                   ; outside window, continue slowly

        ORR     R1, R4, R10             ; word to store if going fast
        EOR     R1, R1, R11
30
        LDR     R7, [R2]                ; screen word
        CMP     R7, R4                  ; EOR target colour (CS if EQ)
        BNE     %FT32                   ; NZ => terminate
        STR     R1, [R2], #4
        ADCS    R0, R0, R9              ; C=1, so add NPix +1
        BLE     %BT30
32
        SUBS    R0, R9, R0              ; R0 back to start of word and negate
        BGE     %BT27                   ; if still inside, continue slowly
        B       %FT36                   ; else exit

34
        AND     R1, R10, R14            ; R1 := zgora AND pixmask
        ORR     R7, R7, R1              ; screen := screen OR R1
        AND     R1, R11, R14            ; R1 := zgeor AND pixmask
        EOR     R7, R7, R1              ; screen := screen EOR R1
        STR     R7, [R2]
36
        SUB     R0, R8, R0              ; make back into normal coord again

; now queue this segment

        Pull    R4                      ; R4 := LH end point
        SUB     R7, R0, #1              ; R7 := corrected RH end point
        LDR     R1, [WsPtr, #FldSaveY]  ; reload Y coordinate of THIS segment
        BL      Queue

        ADD     R14, WsPtr, #FldLeftXLimit      ; load lxlim, (Y+?), rxlim
        LDMIA   R14, {R7,R10,R11}

        EOR     R5, R5, #FillingUpBit   ; invert direction

        SUB     R7, R7, #2              ; lxlim -2
        CMP     R4, R7                  ; if leftX <= lxlim-2
        BLLE    Queue                   ; then Q LH end bit in opposite dir

        ADD     R4, R11, #2             ; rxlim +2
        SUB     R7, R0, #1              ; R7 = RH end point
        CMP     R7, R4                  ; if rightX >= rxlim+2
        BLGE    Queue                   ; then Q RH end bit in opposite dir

        EOR     R5, R5, #FillingUpBit   ; invert direction back again

        SUB     R4, R4, #3              ; rxlim -1
        CMP     R7, R4                  ; if rightX >= rxlim-1
        Pull    PC, GE                  ; no point in skipping any more

; now do the skipping
; R0 points to first non-fillable pixel; R3=correct mask for this pixel

        ADD     R7, WsPtr, #FldSaveArea         ; reload target colour, NPix,
        LDMIB   R7, {R4, R9, R10, R11}          ; zgora, zgeor
37
        LDR     R1, [WsPtr, #FldRightXLimit]
38
        LDR     R7, [R2], #4
        EOR     R7, R7, R4                      ; screen EOR target
40
        TST     R7, R3                          ; if pixel is fillable
        MRS     R14, CPSR
        TEQ     R5, R14, LSL #1
        SUBPL   R2, R2, #4                      ; then correct address
        Push    R0, PL                          ; and push new X coord
        BPL     %BT26                           ; and go to fill right bit
50
        CMP     R0, R1                          ; on limit of segment ?
        Pull    PC, CS                          ; yes, so give up
        ADD     R0, R0, #1                      ; step coord
        TEQ     R3, #0                          ; test for mask wrap
        MOV     R3, R3, ROR R6                  ; rotate mask to next pixel
        BPL     %BT40                           ; continue within this word
        B       %BT38                           ; continue with next word

; *****************************************************************************
;
;       Queue - Queue a line segment
;
; in:   R1 = Y coordinate of segment
;       R4 = left X coordinate
;       R5 = fill flag (Bit0=0/1 => look downwards/upwards)
;       R7 = right X coordinate
;
; out:  R0-R8, R11, R12 preserved
;       R9,R10 corrupted
;       exits by pulling stacked R14 if queue was full
;

Queue   ROUT
        Push    "R0,R11,R14"
        TEQ     R5, R5, LSR #1          ; CS => mangle coords

        MOVCC   R9, R4
        MOVCC   R10, R7

        SUBCS   R9, R7, R4              ; R9 = R-L
        SUBCS   R10, R7, R9             ; R10 = R-(R-L) = L
        ADCCS   R9, R9, R10             ; R9 = (R-L)+L+1 = R+1

        [ med_00001_twowords
        ; revised packing, expanded to two words, LeftX in 31..16 of word 1,
        ; RightX in 15..0 of word 1, and Y in 15..0 of word 2

        MOV     R9, R9, LSL #16         ; shift LeftX up
        ORR     R9, R9, R10             ; combine in RightX

        ADD     R0, WsPtr, #QueuePtrs
        LDMIA   R0, {R10, R11, R14}     ; head,tail,limit

        STR     R9, [R11], #4           ; store word at tail and move on
        STR     R1, [R11], #4           ; store second word
        |
        ; pack Y into bits 0..9, L into bits 10..20, R into bits 21..31

        ORR     R9, R1, R9, LSL #10     ; R9 = Y + (L << 10)
        ORR     R9, R9, R10, LSL #21    ; R9 = Y + (L << 10) + (R <<21)

        ADD     R0, WsPtr, #QueuePtrs
        LDMIA   R0, {R10, R11, R14}     ; head,tail,limit

        STR     R9, [R11], #4           ; store word at tail and move on
        ]

        TEQ     R11, R14                ; if at limit
        LDREQ   R11, [R0, #12]          ; then reload with start ptr
        CMP     R11, R10                ; EQ and CS if queue full
        STRNE   R11, [R0, #4]           ; store tail ptr back if OK

        Pull    "R0,R11,PC", NE         ; queue not full, terminate normally

        [ med_00001_userma
        BL      release_memory
        ]
        LDR     R13, [WsPtr, #FldStackLevel]
        Pull    PC                      ; else bomb out

; *****************************************************************************

        [ med_00001_userma
release_memory
        ROUT
        Push   "R0-R5,lr"

        ADD    R0, WsPtr, #QueuePtrs
        LDMIA  R0, {R0-R3}

        LDR    R5, =FldQueueStart

        CMP    R3, R5                   ; did we use scratchspace ?
        BEQ    %FT20

        MOV    R2, R3
        MOV    R0, #ModHandReason_Free
        SWI    XOS_Module
20
        LDR    R0, [WsPtr, #flood_cda_rma]
        CMP    R0, #0
        BEQ    %FT30                    ; no need to shrink rma

        RSB    R1, R0, #0               ; get the signed negative value
        MOV    R0, #1                   ; rma
        SWI    XOS_ChangeDynamicArea
30
        CMP    r0, r0                   ; ensure we return EQ set
        Pull   "r0-r5,pc"
        ]

; *****************************************************************************

        END