XREF    _interpret       ; Bitmap-to-Ascii function
        XREF    _CopyFont        ; Copies a font and aligns it to 16 bit.
        XREF    _CharData        ; Font data
        XREF    _SrcData
        XREF    _CharLoc
        XREF    _Modulo
        XREF    _FontWidth
        XREF    _FontHeight
        XREF    _LoChar
        XREF    _HiChar

_interpret:
        link    a5,#0
        movem.l d1-d6/a1,-(sp)   ; Free a couple of registers
        move.l  8(a5),a1         ; Bitmap
        move.w  (a1),d2          ; First row
        moveq   #0,d4            ; Code
        move.b  _LoChar,d4       ; First char
        move.w  _FontWidth,d0
        asl.w   #1,d0            ; Times two for words
        lea     MaskTable,a0
        adda.w  d0,a0
        move.w  (a0),d3          ; d3 := mask
        move.l  _CharData,a0     ; Char image data
.Search
        cmp.w   (a0),d2          ; Compare first word
        bne     .tryinverted     ; Not this one
        moveq   #1,d0            ; current word
        moveq   #0,d6            ; Modulo
.morerows
        addq    #2,d6            ; Add modulo - next bit row in image data
        move.w  (a0,d6.w),d1     ; Character row
        cmp.w   (a1,d6.w),d1
        bne     .tryinverted     ; Rows didn't match
        addq    #1,d0            ; Next row in bitmap
        cmp.w   _FontHeight,d0   ; Are we done?
        bne     .morerows        ; Not yet
        bra     .interpreted     ; Got it

.tryinverted
        move.w  d2,d1            ; Copy first row
        eor.w   d3,d1            ; and invert the bits
        cmp.w   (a0),d1          ; Compare inverted rows
        bne     .trybold         ; No match
        moveq   #1,d0            ; current row
        moveq   #0,d6            ; Modulo
.moreinverted
        addq    #2,d6
        move.w  (a0,d6.w),d1     ; Character row
        eor.w   d3,d1            ; and invert the bits
        cmp.w   (a1,d6.w),d1
        bne     .trybold         ; Rows didn't match
        addq    #1,d0            ; Next row in bitmap
        cmp.w   _FontHeight,d0   ; Are we done?
        bne     .moreinverted    ; Not yet
        bra     .interpreted     ; Got it

.trybold
        move.w  d2,d1            ; Copy first row
        lsr.w   #1,d1            ; Shift one step left
        or.w    d2,d1            ; Make bold
        and.w   d3,d1            ; and mask out unwanted bits
        cmp.w   (a0),d1          ; Compare bold rows
        bne     .trynext         ; No match
        moveq   #1,d0            ; current row
        moveq   #0,d6            ; Modulo
.morebold
        addq    #2,d6
        move.w  (a0,d6.w),d1     ; Character row
        lsr.w   #1,d1            ; Shift one step left
        or.w    (a0,d6.w),d1     ; Make bold
        and.w   d3,d1            ; and mask out unwanted bits
        cmp.w   (a1,d6.w),d1
        bne     .trynext         ; Rows didn't match
        addq    #1,d0            ; Next row in bitmap
        cmp.w   _FontHeight,d0   ; Are we done?
        bne     .morebold        ; Not yet
        bra     .interpreted     ; Got it

.trynext
        adda.l  #32,a0           ; Try next character, 32 bytes/char
        addq    #1,d4            ;
        cmp.b   _HiChar,d4       ; Tried all chars?
        bne     .Search          ; More to try
        move.l  #255,d4          ; Not found

.interpreted
        move.l  d4,d0
        movem.l (sp)+,d1-d6/a1
        unlk    a5
        rts


_CopyFont:
        movem.l d2-d5/a2-a3,-(sp)   ; Free a couple of registers
        moveq   #0,d0
        move.l  _CharData,a2        ; a2 := Destination area
        move.l  _CharLoc,a3
        move.b  _LoChar,d5
        move.w  _Modulo,d3

.NextChar
        move.w  (a3),d0             ; Get char location
        adda.w  #4,a3               ; To next, and skip width
        move.w  d0,d1
        and.w   #15,d1              ; Shift amount
        eori.b  #15,d1              ; Negate shift value
        addq.b  #1,d1               ; d1 := Shift Amount

        move.l  _SrcData,a0
        lsr.w   #3,d0               ; Byte offset
        bclr    #0,d0               ; But we deal in words
        adda.w  d0,a0               ; a0 := chardata

        move.w  _FontWidth,d0
        asl.w   #1,d0               ; Times two for words
        lea     MaskTable,a1
        adda.w  d0,a1
        move.w  (a1),d2             ; d2 := mask

        moveq   #0,d4
        move.w  _FontHeight,d4
        move.l  a2,a1               ; a1 := Destination area
        adda.w  #32,a2              ; a2 to next dest area
        bra     .loop
.copyrow
        move.l  (a0),d0             ; Get character row
        adda.w  d3,a0               ; Add modulo -- To next row
        lsr.l   d1,d0               ; Shift data to bit 0 alignment
        and.w   d2,d0               ; Mask out unwanted bits
        move.w  d0,(a1)+            ; Save row
.loop
        dbra    d4,.copyrow         ; Do all rows

        addq    #1,d5               ; Next char
        cmp.b   _HiChar,d5          ; Finished?
        bne     .NextChar           ; Nope -- do next.
        movem.l (sp)+,d2-d5/a2-a3
        rts

MaskTable
        dc.w    $0000
        dc.w    $8000
        dc.w    $c000
        dc.w    $e000
        dc.w    $f000
        dc.w    $f800
        dc.w    $fc00
        dc.w    $fe00
        dc.w    $ff00
        dc.w    $ff80
        dc.w    $ffc0
        dc.w    $ffe0
        dc.w    $fff0
        dc.w    $fff8
        dc.w    $fffc
        dc.w    $fffe
        dc.w    $ffff


        dseg
        XREF   _LVOActivateWindow
        XREF   _LVOWindowToFront
        XREF   _LVOWindowToBack
        XREF   _lvoActivateWindow
        XREF   _lvoWindowToFront
        XREF   _lvoWindowToBack

; Find out offsets for functions. Anybody know of a better way?
_lvoActivateWindow   dc.w _LVOActivateWindow
_lvoWindowToFront    dc.w _LVOWindowToFront
_lvoWindowToBack     dc.w _LVOWindowToBack

        cseg

        XREF   _myActivateWindow
        XREF   _myWindowToFront
        XREF   _myWindowToBack

_myActivateWindow:
        rts

_myWindowToFront:
        rts

_myWindowToBack:
        rts

        END