WebSVN – Kolibri OS – Diff – /kernel/trunk/gui/font.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 6036 $
 
dtext:
; edx -> string
; esi = number of characters
; ebx = output coordinates XXXXYYYY h
; ecx = char color and flags flRRGGBB h
; fl = ZBFFRSSS b
; Z=1: edx -> zero terminated string, esi = ?
; B=1: fill background with color eax
; R=1: edi -> user area for redirect
; FF=3: UTF-8 8x16, FF=2: UTF-16LE 8x16
; FF=1: cp866 8x16, FF=0: cp866 6x9
; SSS = (font multiplier)-1
; edi=1: force output
        and     eax, 0xFFFFFF
        bt      ecx, 30
        jc      @f
        xor     eax, eax
        dec     eax
@@:
        pushd   0 0 0 eax
        movsx   eax, bx
        sar     ebx, 16
        push    eax ebx edi
        bt      ecx, 27
        jc      .redirect
        mov     ebp, [_display.width]
        xor     edi, edi
        jmp     @f
.ret:
        add     esp, 28
        ret
.redirect:
        mov     ebp, [edi]
        add     edi, 8
@@:
        shl     ebp, 2
        imul    eax, ebp
        shl     ebx, 2
        add     eax, ebx
        js      .ret
        add     edi, eax
        mov     eax, ecx
        mov     ebx, ecx
        test    ecx, ecx
        jns     @f
        mov     esi, 256
@@:
        shr     ecx, 24
        and     cl, 7
        inc     ecx
        push    ebp ecx esi
        mov     esi, edx
        or      eax, 0xFF000000
        bt      ebx, 27
        jc      .bufferReady
        mov     eax, 9
        test    ebx, 0x30000000
        jz      @f
        add     eax, 7
@@:
        imul    eax, ecx
        mov     [esp+32], eax
        imul    ebp, eax
        stdcall kernel_alloc, ebp
        mov     ecx, ebp
        shr     ecx, 2
        mov     [esp+36], eax
        sub     edi, eax
        mov     edx, eax
        mov     eax, [esp+24]
        cmp     eax, -1
        jnz     @f
        mov     [esp+28], edi
@@:
        mov     edi, edx
        rep stosd
        mov     edi, edx
        mov     eax, ebx
        and     eax, 0xFFFFFF
.bufferReady:
        mov     ebp, eax
        xor     edx, edx
        bt      ebx, 29
        jc      @f
        bt      ebx, 28
        jc      .draw866toUni
        jmp     .draw866
@@:
        bt      ebx, 28
        jc      .drawUTF8
 
; ebp = font color
; esi -> string
; edi -> buffer
 
; Stack map:
; char counter +0
fontMultiplier = 4
widthX = 8
; edi +12
; X +16
; Y +20
; background +24
deltaToScreen = 28
; temp buffer height +32
; temp buffer pointer +36
 
.drawUTF16:
        dec     dword [esp]
        js      .done
        movzx   ebx, word [esi]
        test    ebx, ebx
        jz      .done
        inc     esi
        inc     esi
        cmp     bx, 1419
        jc      @f
        xor     ebx, ebx
@@:
        pushd   esi edi 16
        shl     ebx, 4
        add     ebx, fontUni
        mov     esi, [esp+12+fontMultiplier]
        call    drawChar
        imul    esi, 8*4
        pop     edi
        pop     edi
        add     edi, esi
        pop     esi
        jmp     .drawUTF16
 
.drawUTF8:
        dec     dword [esp]
        js      .done
@@:
        movzx   ebx, byte [esi]
        inc     esi
        test    bl, bl
        jz      .done
        jns     .valid
        shl     bx, 10
        jnc     @b
        mov     bl, [esi]
        test    bl, bl
        jns     @b
        shl     bl, 2
        jc      @b
        shr     bh, 2
        shr     bx, 2
        inc     esi
        cmp     bx, 1419
        jc      .valid
        shl     bh, 4
        jns     @f
.tail:
        mov     bl, [esi]
        shl     bl, 1
        jnc     @b
        js      @b
        inc     esi
        shl     bh, 1
        js      .tail
@@:
        xor     ebx, ebx
.valid:
        pushd   esi edi 16
        shl     ebx, 4
        add     ebx, fontUni
        mov     esi, [esp+12+fontMultiplier]
        call    drawChar
        imul    esi, 8*4
        pop     edi
        pop     edi
        add     edi, esi
        pop     esi
        jmp     .drawUTF8
 
.draw866:
        dec     dword [esp]
        js      .done
        movzx   ebx, byte [esi]
        test    ebx, ebx
        jz      .done
        inc     esi
        pushd   esi edi 9
        lea     ebx, [ebx*8+ebx+font1]
        mov     esi, [esp+12+fontMultiplier]
        call    drawChar
        imul    esi, 6*4
        pop     edi
        pop     edi
        add     edi, esi
        pop     esi
        jmp     .draw866
 
.draw866toUni:
        dec     dword [esp]
        js      .done
        movzx   eax, byte [esi]
        test    eax, eax
        jz      .done
        call    ansi2uni_char
        shl     eax, 4
        lea     ebx, [eax+fontUni]
        inc     esi
        pushd   esi edi 16
        mov     esi, [esp+12+fontMultiplier]
        call    drawChar
        imul    esi, 8*4
        pop     edi
        pop     edi
        add     edi, esi
        pop     esi
        jmp     .draw866toUni
 
.done:
        mov     ecx, edi
        pop     eax eax eax esi edx ebx ebp ebp ebp
        mov     edi, [esp]
        test    edi, edi
        jnz     @f
        pop     eax
        ret
@@:         ; redraw from buffer to screen
        push    eax
        sub     ecx, edi
        shr     ecx, 2
        add     edx, ecx
        inc     ecx
        push    ecx
        push    edi
.drawPicture:
        mov     eax, -1
        repz scasd
        jecxz   @f
        mov     eax, edx
        sub     eax, ecx
        push    ecx
        mov     ecx, [edi-4]
        xchg    esi, edi
        call    __sys_putpixel
        xchg    esi, edi
        pop     ecx
        jmp     .drawPicture
@@:
        pop     edi
        mov     ecx, [esp]
        add     edi, [esp+4]
        inc     ebx
        push    edi
        dec     ebp
        jnz     .drawPicture
        add     esp, 12
        call    kernel_free
        ret
 
; scaling/smoothing algorithm
drawChar:
; ebp = font color
; esi = font multiplier
; edi -> buffer
; ebx -> char data
        mov     dl, [ebx]
.raw:
        bsf     eax, edx
        jz      .nextRaw
        imul    eax, esi
        shl     eax, 2
        push    edi
        add     edi, eax
        mov     ecx, esi
        dec     esi
        jnz     .square
        mov     [edi], ebp
        inc     esi
        cmp     [fontSmoothing], 0
        jz      .nextPixel
.checkLeftSM:     ; smoothing
        bsf     eax, edx
        dec     eax
        js      .checkRightSM
        bt      [ebx], eax
        jc      .checkRightSM
        dec     eax
        js      .checkLeftDownSM
        bt      [ebx], eax
        jc      .checkRightSM
.checkLeftDownSM:
        inc     eax
        bt      [ebx+1], eax
        jnc     .checkLeftUpSM
        inc     eax
        bt      [ebx+1], eax
        jnc     @f
        bt      [ebx-1], eax
        jc      .checkRightSM
        dec     eax
        dec     eax
        js      @f
        bt      [ebx+1], eax
        jnc     @f
        inc     eax
.checkLeftUpSM:
        bt      [ebx-1], eax
        jnc     .checkRightSM
        inc     eax
        bt      [ebx-1], eax
        jnc     @f
        bt      [ebx+1], eax
        jc      .checkRightSM
        dec     eax
        dec     eax
        js      @f
        bt      [ebx-1], eax
        jc      .checkRightSM
@@:
        mov     ecx, [esp+20+deltaToScreen]
        mov     eax, [edi-4]
        test    ecx, ecx
        jz      @f
        pusha
        lea     ebx, [edi+ecx-4]
        shr     ebx, 2
        call    syscall_getpixel
        popa
@@:
        push    ebx edx
        mov     ebx, ebp
        xor     ecx, ecx
        cmp     [fontSmoothing], 1
        jnz     .subpixelLeft
        call    antiAliasing
        jmp     @f
.subpixelLeft:
        mov     cl, bl
        lea     edx, [ecx*8+ecx]
        lea     edx, [ecx*2+edx]
        mov     cl, al
        lea     ecx, [ecx*4+ecx]
        add     edx, ecx
        shr     edx, 4
        mov     al, dl
 
        xor     ecx, ecx
        mov     cl, ah
        lea     edx, [ecx*8+ecx]
        lea     edx, [ecx*2+edx]
        mov     cl, bh
        lea     ecx, [ecx*4+ecx]
        add     edx, ecx
        shr     edx, 4
        mov     ah, dl
 
        rol     eax, 16
        rol     ebx, 16
        xor     ecx, ecx
        mov     cl, al
        mov     edx, ecx
        shl     ecx, 3
        sub     ecx, edx
        mov     dl, bl
        add     ecx, edx
        shr     ecx, 3
        mov     al, cl
        rol     eax, 16
@@:
        mov     [edi-4], eax
        pop     edx ebx
.checkRightSM:
        bsf     eax, edx
        inc     eax
        bt      [ebx], eax
        jc      .nextPixel
        inc     eax
        bt      [ebx], eax
        jc      .nextPixel
        dec     eax
.checkRightDownSM:
        bt      [ebx+1], eax
        jnc     .checkRightUpSM
        dec     eax
        bt      [ebx+1], eax
        jnc     @f
        bt      [ebx-1], eax
        jc      .nextPixel
        inc     eax
        inc     eax
        bt      [ebx+1], eax
        jnc     @f
        dec     eax
.checkRightUpSM:
        bt      [ebx-1], eax
        jnc     .nextPixel
        dec     eax
        bt      [ebx-1], eax
        jnc     @f
        bt      [ebx+1], eax
        jc      .nextPixel
        inc     eax
        inc     eax
        bt      [ebx-1], eax
        jc      .nextPixel
@@:
        mov     ecx, [esp+20+deltaToScreen]
        mov     eax, [edi+4]
        test    ecx, ecx
        jz      @f
        pusha
        lea     ebx, [edi+ecx+4]
        shr     ebx, 2
        call    syscall_getpixel
        popa
@@:
        push    ebx edx
        mov     ebx, ebp
        xor     ecx, ecx
        cmp     [fontSmoothing], 1
        jnz     .subpixelRight
        call    antiAliasing
        jmp     @f
.subpixelRight:
        mov     cl, al
        mov     edx, ecx
        shl     ecx, 3
        sub     ecx, edx
        mov     dl, bl
        add     ecx, edx
        shr     ecx, 3
        mov     al, cl
 
        xor     ecx, ecx
        mov     cl, ah
        lea     edx, [ecx*8+ecx]
        lea     edx, [ecx*2+edx]
        mov     cl, bh
        lea     ecx, [ecx*4+ecx]
        add     edx, ecx
        shr     edx, 4
        mov     ah, dl
 
        rol     ebx, 16
        rol     eax, 16
        xor     ecx, ecx
        mov     cl, bl
        lea     edx, [ecx*8+ecx]
        lea     edx, [ecx*2+edx]
        mov     cl, al
        lea     ecx, [ecx*4+ecx]
        add     edx, ecx
        shr     edx, 4
        mov     al, dl
        rol     eax, 16
@@:
        mov     [edi+4], eax
        pop     edx ebx
        jmp     .nextPixel
 
.square:    ; scaling
        mov     eax, esi
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        dec     ecx
        jnz     .square
        inc     esi
        mov     edi, [esp]
.checkLeft:
        bsf     eax, edx
        dec     eax
        js      .checkRight
        bt      [ebx], eax
        jc      .checkRight
.checkLeftDown:
        bt      [ebx+1], eax
        jnc     .checkLeftUp
        mov     ecx, eax
        inc     eax
        bt      [ebx+1], eax
        jc      @f
        bt      [ebx-1], eax
        jnc     .downRightLow
        bt      [ebx-2], eax
        jc      .downRightLow
        dec     eax
        bt      [ebx-1], eax
        jc      .downRightLow
        dec     eax
        js      .downRightHigh
        bt      [ebx-2], eax
        jc      .downRightLow
        jmp     .downRightHigh
 
@@:
        bt      [ebx-1], eax
        jc      .checkLeftUp
        dec     eax
        dec     eax
        js      .downRightLow
        bt      [ebx+1], eax
        jc      .checkLeftUp
.downRightLow:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        dec     esi
        mov     eax, [esp+20+widthX]
        imul    eax, esi
        add     edi, eax
        add     edi, 4
        mov     ecx, esi
        dec     ecx
.drawDownRight:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        add     edi, 4
        dec     ecx
        jns     .drawDownRight
        inc     esi
        mov     edi, [esp]
        jmp     .checkLeftUp
 
.downRightHigh:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        dec     esi
        mov     eax, [esp+20+widthX]
        imul    eax, esi
        add     edi, eax
        add     edi, 4
        mov     ecx, esi
        dec     ecx
.drawDownRightHigh:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        add     edi, 4
        dec     ecx
        jns     .drawDownRightHigh
        inc     esi
        mov     edi, [esp]
.checkLeftUp:
        bsf     eax, edx
        dec     eax
        bt      [ebx-1], eax
        jnc     .checkRight
        mov     ecx, eax
        inc     eax
        bt      [ebx-1], eax
        jc      @f
        bt      [ebx+1], eax
        jnc     .upRightLow
        bt      [ebx+2], eax
        jc      .upRightLow
        dec     eax
        bt      [ebx+1], eax
        jc      .upRightLow
        dec     eax
        js      .upRightHigh
        bt      [ebx+2], eax
        jc      .upRightLow
        jmp     .upRightHigh
 
@@:
        bt      [ebx+1], eax
        jc      .checkRight
        dec     eax
        dec     eax
        js      .upRightLow
        bt      [ebx-1], eax
        jc      .checkRight
.upRightLow:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        add     edi, 4
        mov     ecx, esi
        dec     ecx
        dec     ecx
.drawUpRight:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        add     edi, 4
        dec     ecx
        jns     .drawUpRight
        mov     edi, [esp]
        jmp     .checkRight
 
.upRightHigh:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        add     edi, 4
        mov     ecx, esi
        dec     ecx
        dec     ecx
.drawUpRightHigh:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        add     edi, 4
        dec     ecx
        jns     .drawUpRightHigh
        mov     edi, [esp]
.checkRight:
        bsf     eax, edx
        inc     eax
        bt      [ebx], eax
        jc      .nextPixel
.checkRightDown:
        bt      [ebx+1], eax
        jnc     .checkRightUp
        mov     ecx, eax
        dec     eax
        bt      [ebx+1], eax
        jc      @f
        bt      [ebx-1], eax
        jnc     .downLeftLow
        bt      [ebx-2], eax
        jc      .downLeftLow
        inc     eax
        bt      [ebx-1], eax
        jc      .downLeftLow
        inc     eax
        bt      [ebx-2], eax
        jc      .downLeftLow
        jmp     .downLeftHigh
 
@@:
        bt      [ebx-1], eax
        jc      .checkRightUp
        inc     eax
        inc     eax
        bt      [ebx+1], eax
        jc      .checkRightUp
.downLeftLow:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        dec     esi
        mov     eax, [esp+20+widthX]
        imul    eax, esi
        add     edi, eax
        mov     ecx, esi
        dec     ecx
.drawDownLeft:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        dec     ecx
        jns     .drawDownLeft
        inc     esi
        mov     edi, [esp]
        jmp     .checkRightUp
 
.downLeftHigh:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        dec     esi
        mov     eax, [esp+20+widthX]
        imul    eax, esi
        add     edi, eax
        mov     ecx, esi
        dec     ecx
.drawDownLeftHigh:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        sub     edi, [esp+20+widthX]
        dec     ecx
        jns     .drawDownLeftHigh
        inc     esi
        mov     edi, [esp]
.checkRightUp:
        bsf     eax, edx
        inc     eax
        bt      [ebx-1], eax
        jnc     .nextPixel
        mov     ecx, eax
        dec     eax
        bt      [ebx-1], eax
        jc      @f
        bt      [ebx+1], eax
        jnc     .upLeftLow
        bt      [ebx+2], eax
        jc      .upLeftLow
        inc     eax
        bt      [ebx+1], eax
        jc      .upLeftLow
        inc     eax
        bt      [ebx+2], eax
        jc      .upLeftLow
        jmp     .upLeftHigh
 
@@:
        bt      [ebx+1], eax
        jc      .nextPixel
        inc     eax
        inc     eax
        bt      [ebx-1], eax
        jc      .nextPixel
.upLeftLow:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        mov     ecx, esi
        dec     ecx
        dec     ecx
.drawUpLeft:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        dec     ecx
        jns     .drawUpLeft
        jmp     .nextPixel
 
.upLeftHigh:
        imul    ecx, esi
        shl     ecx, 2
        add     edi, ecx
        mov     ecx, esi
        dec     ecx
        dec     ecx
.drawUpLeftHigh:
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        mov     eax, ecx
@@:
        mov     [edi+eax*4], ebp
        dec     eax
        jns     @b
        add     edi, [esp+20+widthX]
        dec     ecx
        jns     .drawUpLeftHigh
.nextPixel:
        bsf     eax, edx
        btr     edx, eax
        pop     edi
        jmp     .raw
 
.nextRaw:
        inc     ebx
        mov     eax, [esp+16+widthX]
        imul    eax, esi
        add     edi, eax
        dec     dword [esp+4]
        jnz     drawChar
        ret
 
antiAliasing:
        mov     bp, 3
@@:
        mov     cl, al
        mov     dl, bl
        lea     ecx, [ecx*2+ecx]
        add     ecx, edx
        shr     ecx, 2
        mov     al, cl
        ror     eax, 8
        ror     ebx, 8
        dec     bp
        jnz     @b
        ror     eax, 8
        ror     ebx, 8
        mov     ebp, ebx
        ret
 
fontSmoothing   db  2   ; = 0, 1 or 2
fontSize        db  0   ; user mode setting
font1:
  if lang eq sp
  file 'char_sp.mt'
  else if lang eq et
  file 'char_et.mt'
  else
  file 'char.mt'
  end if
fontUni:
file 'charUni.mt'

Rev 5926	Rev 6036
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
4	;; Distributed under terms of the GNU General Public License ;;	4	;; Distributed under terms of the GNU General Public License ;;
5	;; ;;	5	;; ;;
6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 5926 $	8	$Revision: 6036 $
9		9
10	dtext:	10	dtext:
11	; edx -> string	11	; edx -> string
12	; esi = number of characters	12	; esi = number of characters
13	; ebx = output coordinates XXXXYYYY h	13	; ebx = output coordinates XXXXYYYY h
14	; ecx = char color and flags flRRGGBB h	14	; ecx = char color and flags flRRGGBB h
15	; fl = ZBFFRSSS b	15	; fl = ZBFFRSSS b
16	; Z=1: edx -> zero terminated string, esi = ?	16	; Z=1: edx -> zero terminated string, esi = ?
17	; B=1: fill background with color eax	17	; B=1: fill background with color eax
18	; R=1: edi -> user area for redirect	18	; R=1: edi -> user area for redirect
19	; FF=3: UTF-8 8x16, FF=2: UTF-16LE 8x16	19	; FF=3: UTF-8 8x16, FF=2: UTF-16LE 8x16
20	; FF=1: cp866 8x16, FF=0: cp866 6x9	20	; FF=1: cp866 8x16, FF=0: cp866 6x9
21	; SSS = (font multiplier)-1	21	; SSS = (font multiplier)-1
22	; edi=1: force output	22	; edi=1: force output
23	and eax, 0xFFFFFF	23	and eax, 0xFFFFFF
24	bt ecx, 30	24	bt ecx, 30
25	jc @f	25	jc @f
26	xor eax, eax	26	xor eax, eax
27	dec eax	27	dec eax
28	@@:	28	@@:
29	pushd 0 0 0 eax	29	pushd 0 0 0 eax
30	movsx eax, bx	30	movsx eax, bx
31	sar ebx, 16	31	sar ebx, 16
32	push eax ebx edi	32	push eax ebx edi
33	bt ecx, 27	33	bt ecx, 27
34	jc .redirect	34	jc .redirect
35	mov ebp, [_display.width]	35	mov ebp, [_display.width]
36	xor edi, edi	36	xor edi, edi
37	jmp @f	37	jmp @f
38	.ret:	38	.ret:
39	add esp, 28	39	add esp, 28
40	ret	40	ret
41	.redirect:	41	.redirect:
42	mov ebp, [edi]	42	mov ebp, [edi]
43	add edi, 8	43	add edi, 8
44	@@:	44	@@:
45	shl ebp, 2	45	shl ebp, 2
46	imul eax, ebp	46	imul eax, ebp
47	shl ebx, 2	47	shl ebx, 2
48	add eax, ebx	48	add eax, ebx
49	js .ret	49	js .ret
50	add edi, eax	50	add edi, eax
51	mov eax, ecx	51	mov eax, ecx
52	mov ebx, ecx	52	mov ebx, ecx
53	test ecx, ecx	53	test ecx, ecx
54	jns @f	54	jns @f
55	mov esi, 256	55	mov esi, 256
56	@@:	56	@@:
57	shr ecx, 24	57	shr ecx, 24
58	and cl, 7	58	and cl, 7
59	inc ecx	59	inc ecx
60	push ebp ecx esi	60	push ebp ecx esi
61	mov esi, edx	61	mov esi, edx
62	or eax, 0xFF000000	62	or eax, 0xFF000000
63	bt ebx, 27	63	bt ebx, 27
64	jc .bufferReady	64	jc .bufferReady
65	mov eax, 9	65	mov eax, 9
66	test ebx, 0x30000000	66	test ebx, 0x30000000
67	jz @f	67	jz @f
68	add eax, 7	68	add eax, 7
69	@@:	69	@@:
70	imul eax, ecx	70	imul eax, ecx
71	mov [esp+32], eax	71	mov [esp+32], eax
72	imul ebp, eax	72	imul ebp, eax
73	stdcall kernel_alloc, ebp	73	stdcall kernel_alloc, ebp
74	mov ecx, ebp	74	mov ecx, ebp
75	shr ecx, 2	75	shr ecx, 2
76	mov [esp+36], eax	76	mov [esp+36], eax
77	sub edi, eax	77	sub edi, eax
78	mov edx, eax	78	mov edx, eax
79	mov eax, [esp+24]	79	mov eax, [esp+24]
80	cmp eax, -1	80	cmp eax, -1
81	jnz @f	81	jnz @f
82	mov [esp+28], edi	82	mov [esp+28], edi
83	@@:	83	@@:
84	mov edi, edx	84	mov edi, edx
85	rep stosd	85	rep stosd
86	mov edi, edx	86	mov edi, edx
87	mov eax, ebx	87	mov eax, ebx
88	and eax, 0xFFFFFF	88	and eax, 0xFFFFFF
89	.bufferReady:	89	.bufferReady:
90	mov ebp, eax	90	mov ebp, eax
91	xor edx, edx	91	xor edx, edx
92	bt ebx, 29	92	bt ebx, 29
93	jc @f	93	jc @f
94	bt ebx, 28	94	bt ebx, 28
95	jc .draw866toUni	95	jc .draw866toUni
96	jmp .draw866	96	jmp .draw866
97	@@:	97	@@:
98	bt ebx, 28	98	bt ebx, 28
99	jc .drawUTF8	99	jc .drawUTF8
100		100
101	; ebp = font color	101	; ebp = font color
102	; esi -> string	102	; esi -> string
103	; edi -> buffer	103	; edi -> buffer
104		104
105	; Stack map:	105	; Stack map:
106	; char counter +0	106	; char counter +0
107	fontMultiplier = 4	107	fontMultiplier = 4
108	widthX = 8	108	widthX = 8
109	; edi +12	109	; edi +12
110	; X +16	110	; X +16
111	; Y +20	111	; Y +20
112	; background +24	112	; background +24
113	deltaToScreen = 28	113	deltaToScreen = 28
114	; temp buffer height +32	114	; temp buffer height +32
115	; temp buffer pointer +36	115	; temp buffer pointer +36
116		116
117	.drawUTF16:	117	.drawUTF16:
118	dec dword [esp]	118	dec dword [esp]
119	js .done	119	js .done
120	movzx ebx, word [esi]	120	movzx ebx, word [esi]
121	test ebx, ebx	121	test ebx, ebx
122	jz .done	122	jz .done
123	inc esi	123	inc esi
124	inc esi	124	inc esi
125	cmp bx, 1419	125	cmp bx, 1419
126	jc @f	126	jc @f
127	xor ebx, ebx	127	xor ebx, ebx
128	@@:	128	@@:
129	pushd esi edi 16	129	pushd esi edi 16
130	shl ebx, 4	130	shl ebx, 4
131	add ebx, fontUni	131	add ebx, fontUni
132	mov esi, [esp+12+fontMultiplier]	132	mov esi, [esp+12+fontMultiplier]
133	call drawChar	133	call drawChar
134	imul esi, 8*4	134	imul esi, 8*4
135	pop edi	135	pop edi
136	pop edi	136	pop edi
137	add edi, esi	137	add edi, esi
138	pop esi	138	pop esi
139	jmp .drawUTF16	139	jmp .drawUTF16
140		140
141	.drawUTF8:	141	.drawUTF8:
142	dec dword [esp]	142	dec dword [esp]
143	js .done	143	js .done
144	@@:	144	@@:
145	movzx ebx, byte [esi]	145	movzx ebx, byte [esi]
146	inc esi	146	inc esi
147	test bl, bl	147	test bl, bl
148	jz .done	148	jz .done
149	jns .valid	149	jns .valid
150	shl bx, 10	150	shl bx, 10
151	jnc @b	151	jnc @b
152	mov bl, [esi]	152	mov bl, [esi]
153	test bl, bl	153	test bl, bl
154	jns @b	154	jns @b
155	shl bl, 2	155	shl bl, 2
156	jc @b	156	jc @b
157	shr bh, 2	157	shr bh, 2
158	shr bx, 2	158	shr bx, 2
159	inc esi	159	inc esi
160	cmp bx, 1419	160	cmp bx, 1419
161	jc .valid	161	jc .valid
162	shl bh, 4	162	shl bh, 4
163	jns @f	163	jns @f
164	.tail:	164	.tail:
165	mov bl, [esi]	165	mov bl, [esi]
166	shl bl, 1	166	shl bl, 1
167	jnc @b	167	jnc @b
168	js @b	168	js @b
169	inc esi	169	inc esi
170	shl bh, 1	170	shl bh, 1
171	js .tail	171	js .tail
172	@@:	172	@@:
173	xor ebx, ebx	173	xor ebx, ebx
174	.valid:	174	.valid:
175	pushd esi edi 16	175	pushd esi edi 16
176	shl ebx, 4	176	shl ebx, 4
177	add ebx, fontUni	177	add ebx, fontUni
178	mov esi, [esp+12+fontMultiplier]	178	mov esi, [esp+12+fontMultiplier]
179	call drawChar	179	call drawChar
180	imul esi, 8*4	180	imul esi, 8*4
181	pop edi	181	pop edi
182	pop edi	182	pop edi
183	add edi, esi	183	add edi, esi
184	pop esi	184	pop esi
185	jmp .drawUTF8	185	jmp .drawUTF8
186		186
187	.draw866:	187	.draw866:
188	dec dword [esp]	188	dec dword [esp]
189	js .done	189	js .done
190	movzx ebx, byte [esi]	190	movzx ebx, byte [esi]
191	test ebx, ebx	191	test ebx, ebx
192	jz .done	192	jz .done
193	inc esi	193	inc esi
194	pushd esi edi 9	194	pushd esi edi 9
195	lea ebx, [ebx*8+ebx+font1]	195	lea ebx, [ebx*8+ebx+font1]
196	mov esi, [esp+12+fontMultiplier]	196	mov esi, [esp+12+fontMultiplier]
197	call drawChar	197	call drawChar
198	imul esi, 6*4	198	imul esi, 6*4
199	pop edi	199	pop edi
200	pop edi	200	pop edi
201	add edi, esi	201	add edi, esi
202	pop esi	202	pop esi
203	jmp .draw866	203	jmp .draw866
204		204
205	.draw866toUni:	205	.draw866toUni:
206	dec dword [esp]	206	dec dword [esp]
207	js .done	207	js .done
208	movzx eax, byte [esi]	208	movzx eax, byte [esi]
209	test eax, eax	209	test eax, eax
210	jz .done	210	jz .done
211	call ansi2uni_char	211	call ansi2uni_char
212	shl eax, 4	212	shl eax, 4
213	lea ebx, [eax+fontUni]	213	lea ebx, [eax+fontUni]
214	inc esi	214	inc esi
215	pushd esi edi 16	215	pushd esi edi 16
216	mov esi, [esp+12+fontMultiplier]	216	mov esi, [esp+12+fontMultiplier]
217	call drawChar	217	call drawChar
218	imul esi, 8*4	218	imul esi, 8*4
219	pop edi	219	pop edi
220	pop edi	220	pop edi
221	add edi, esi	221	add edi, esi
222	pop esi	222	pop esi
223	jmp .draw866toUni	223	jmp .draw866toUni
224		224
225	.done:	225	.done:
226	mov ecx, edi	226	mov ecx, edi
227	pop eax eax eax esi edx ebx ebp ebp ebp	227	pop eax eax eax esi edx ebx ebp ebp ebp
228	mov edi, [esp]	228	mov edi, [esp]
229	test edi, edi	229	test edi, edi
230	jnz @f	230	jnz @f
231	pop eax	231	pop eax
232	ret	232	ret
233	@@: ; redraw from buffer to screen	233	@@: ; redraw from buffer to screen
234	push eax	234	push eax
235	sub ecx, edi	235	sub ecx, edi
236	shr ecx, 2	236	shr ecx, 2
237	add edx, ecx	237	add edx, ecx
238	inc ecx	238	inc ecx
239	push ecx	239	push ecx
240	push edi	240	push edi
241	.drawPicture:	241	.drawPicture:
242	mov eax, -1	242	mov eax, -1
243	repz scasd	243	repz scasd
244	jcxz @f	244	jecxz @f
245	mov eax, edx	245	mov eax, edx
246	sub eax, ecx	246	sub eax, ecx
247	push ecx	247	push ecx
248	mov ecx, [edi-4]	248	mov ecx, [edi-4]
249	xchg esi, edi	249	xchg esi, edi
250	call __sys_putpixel	250	call __sys_putpixel
251	xchg esi, edi	251	xchg esi, edi
252	pop ecx	252	pop ecx
253	jmp .drawPicture	253	jmp .drawPicture
254	@@:	254	@@:
255	pop edi	255	pop edi
256	mov ecx, [esp]	256	mov ecx, [esp]
257	add edi, [esp+4]	257	add edi, [esp+4]
258	inc ebx	258	inc ebx
259	push edi	259	push edi
260	dec ebp	260	dec ebp
261	jnz .drawPicture	261	jnz .drawPicture
262	add esp, 12	262	add esp, 12
263	call kernel_free	263	call kernel_free
264	ret	264	ret
265		265
266	; scaling/smoothing algorithm	266	; scaling/smoothing algorithm
267	drawChar:	267	drawChar:
268	; ebp = font color	268	; ebp = font color
269	; esi = font multiplier	269	; esi = font multiplier
270	; edi -> buffer	270	; edi -> buffer
271	; ebx -> char data	271	; ebx -> char data
272	mov dl, [ebx]	272	mov dl, [ebx]
273	.raw:	273	.raw:
274	bsf eax, edx	274	bsf eax, edx
275	jz .nextRaw	275	jz .nextRaw
276	imul eax, esi	276	imul eax, esi
277	shl eax, 2	277	shl eax, 2
278	push edi	278	push edi
279	add edi, eax	279	add edi, eax
280	mov ecx, esi	280	mov ecx, esi
281	dec esi	281	dec esi
282	jnz .square	282	jnz .square
283	mov [edi], ebp	283	mov [edi], ebp
284	inc esi	284	inc esi
285	cmp [fontSmoothing], 0	285	cmp [fontSmoothing], 0
286	jz .nextPixel	286	jz .nextPixel
287	.checkLeftSM: ; smoothing	287	.checkLeftSM: ; smoothing
288	bsf eax, edx	288	bsf eax, edx
289	dec eax	289	dec eax
290	js .checkRightSM	290	js .checkRightSM
291	bt [ebx], eax	291	bt [ebx], eax
292	jc .checkRightSM	292	jc .checkRightSM
293	dec eax	293	dec eax
294	js .checkLeftDownSM	294	js .checkLeftDownSM
295	bt [ebx], eax	295	bt [ebx], eax
296	jc .checkRightSM	296	jc .checkRightSM
297	.checkLeftDownSM:	297	.checkLeftDownSM:
298	inc eax	298	inc eax
299	bt [ebx+1], eax	299	bt [ebx+1], eax
300	jnc .checkLeftUpSM	300	jnc .checkLeftUpSM
301	inc eax	301	inc eax
302	bt [ebx+1], eax	302	bt [ebx+1], eax
303	jnc @f	303	jnc @f
304	bt [ebx-1], eax	304	bt [ebx-1], eax
305	jc .checkRightSM	305	jc .checkRightSM
306	dec eax	306	dec eax
307	dec eax	307	dec eax
308	js @f	308	js @f
309	bt [ebx+1], eax	309	bt [ebx+1], eax
310	jnc @f	310	jnc @f
311	inc eax	311	inc eax
312	.checkLeftUpSM:	312	.checkLeftUpSM:
313	bt [ebx-1], eax	313	bt [ebx-1], eax
314	jnc .checkRightSM	314	jnc .checkRightSM
315	inc eax	315	inc eax
316	bt [ebx-1], eax	316	bt [ebx-1], eax
317	jnc @f	317	jnc @f
318	bt [ebx+1], eax	318	bt [ebx+1], eax
319	jc .checkRightSM	319	jc .checkRightSM
320	dec eax	320	dec eax
321	dec eax	321	dec eax
322	js @f	322	js @f
323	bt [ebx-1], eax	323	bt [ebx-1], eax
324	jc .checkRightSM	324	jc .checkRightSM
325	@@:	325	@@:
326	mov ecx, [esp+20+deltaToScreen]	326	mov ecx, [esp+20+deltaToScreen]
327	mov eax, [edi-4]	327	mov eax, [edi-4]
328	test ecx, ecx	328	test ecx, ecx
329	jz @f	329	jz @f
330	pusha	330	pusha
331	lea ebx, [edi+ecx-4]	331	lea ebx, [edi+ecx-4]
332	shr ebx, 2	332	shr ebx, 2
333	call syscall_getpixel	333	call syscall_getpixel
334	popa	334	popa
335	@@:	335	@@:
336	push ebx edx	336	push ebx edx
337	mov ebx, ebp	337	mov ebx, ebp
338	xor ecx, ecx	338	xor ecx, ecx
339	cmp [fontSmoothing], 1	339	cmp [fontSmoothing], 1
340	jnz .subpixelLeft	340	jnz .subpixelLeft
341	call antiAliasing	341	call antiAliasing
342	jmp @f	342	jmp @f
343	.subpixelLeft:	343	.subpixelLeft:
344	mov cl, bl	344	mov cl, bl
345	lea edx, [ecx*8+ecx]	345	lea edx, [ecx*8+ecx]
346	lea edx, [ecx*2+edx]	346	lea edx, [ecx*2+edx]
347	mov cl, al	347	mov cl, al
348	lea ecx, [ecx*4+ecx]	348	lea ecx, [ecx*4+ecx]
349	add edx, ecx	349	add edx, ecx
350	shr edx, 4	350	shr edx, 4
351	mov al, dl	351	mov al, dl
352		352
353	xor ecx, ecx	353	xor ecx, ecx
354	mov cl, ah	354	mov cl, ah
355	lea edx, [ecx*8+ecx]	355	lea edx, [ecx*8+ecx]
356	lea edx, [ecx*2+edx]	356	lea edx, [ecx*2+edx]
357	mov cl, bh	357	mov cl, bh
358	lea ecx, [ecx*4+ecx]	358	lea ecx, [ecx*4+ecx]
359	add edx, ecx	359	add edx, ecx
360	shr edx, 4	360	shr edx, 4
361	mov ah, dl	361	mov ah, dl
362		362
363	rol eax, 16	363	rol eax, 16
364	rol ebx, 16	364	rol ebx, 16
365	xor ecx, ecx	365	xor ecx, ecx
366	mov cl, al	366	mov cl, al
367	mov edx, ecx	367	mov edx, ecx
368	shl ecx, 3	368	shl ecx, 3
369	sub ecx, edx	369	sub ecx, edx
370	mov dl, bl	370	mov dl, bl
371	add ecx, edx	371	add ecx, edx
372	shr ecx, 3	372	shr ecx, 3
373	mov al, cl	373	mov al, cl
374	rol eax, 16	374	rol eax, 16
375	@@:	375	@@:
376	mov [edi-4], eax	376	mov [edi-4], eax
377	pop edx ebx	377	pop edx ebx
378	.checkRightSM:	378	.checkRightSM:
379	bsf eax, edx	379	bsf eax, edx
380	inc eax	380	inc eax
381	bt [ebx], eax	381	bt [ebx], eax
382	jc .nextPixel	382	jc .nextPixel
383	inc eax	383	inc eax
384	bt [ebx], eax	384	bt [ebx], eax
385	jc .nextPixel	385	jc .nextPixel
386	dec eax	386	dec eax
387	.checkRightDownSM:	387	.checkRightDownSM:
388	bt [ebx+1], eax	388	bt [ebx+1], eax
389	jnc .checkRightUpSM	389	jnc .checkRightUpSM
390	dec eax	390	dec eax
391	bt [ebx+1], eax	391	bt [ebx+1], eax
392	jnc @f	392	jnc @f
393	bt [ebx-1], eax	393	bt [ebx-1], eax
394	jc .nextPixel	394	jc .nextPixel
395	inc eax	395	inc eax
396	inc eax	396	inc eax
397	bt [ebx+1], eax	397	bt [ebx+1], eax
398	jnc @f	398	jnc @f
399	dec eax	399	dec eax
400	.checkRightUpSM:	400	.checkRightUpSM:
401	bt [ebx-1], eax	401	bt [ebx-1], eax
402	jnc .nextPixel	402	jnc .nextPixel
403	dec eax	403	dec eax
404	bt [ebx-1], eax	404	bt [ebx-1], eax
405	jnc @f	405	jnc @f
406	bt [ebx+1], eax	406	bt [ebx+1], eax
407	jc .nextPixel	407	jc .nextPixel
408	inc eax	408	inc eax
409	inc eax	409	inc eax
410	bt [ebx-1], eax	410	bt [ebx-1], eax
411	jc .nextPixel	411	jc .nextPixel
412	@@:	412	@@:
413	mov ecx, [esp+20+deltaToScreen]	413	mov ecx, [esp+20+deltaToScreen]
414	mov eax, [edi+4]	414	mov eax, [edi+4]
415	test ecx, ecx	415	test ecx, ecx
416	jz @f	416	jz @f
417	pusha	417	pusha
418	lea ebx, [edi+ecx+4]	418	lea ebx, [edi+ecx+4]
419	shr ebx, 2	419	shr ebx, 2
420	call syscall_getpixel	420	call syscall_getpixel
421	popa	421	popa
422	@@:	422	@@:
423	push ebx edx	423	push ebx edx
424	mov ebx, ebp	424	mov ebx, ebp
425	xor ecx, ecx	425	xor ecx, ecx
426	cmp [fontSmoothing], 1	426	cmp [fontSmoothing], 1
427	jnz .subpixelRight	427	jnz .subpixelRight
428	call antiAliasing	428	call antiAliasing
429	jmp @f	429	jmp @f
430	.subpixelRight:	430	.subpixelRight:
431	mov cl, al	431	mov cl, al
432	mov edx, ecx	432	mov edx, ecx
433	shl ecx, 3	433	shl ecx, 3
434	sub ecx, edx	434	sub ecx, edx
435	mov dl, bl	435	mov dl, bl
436	add ecx, edx	436	add ecx, edx
437	shr ecx, 3	437	shr ecx, 3
438	mov al, cl	438	mov al, cl
439		439
440	xor ecx, ecx	440	xor ecx, ecx
441	mov cl, ah	441	mov cl, ah
442	lea edx, [ecx*8+ecx]	442	lea edx, [ecx*8+ecx]
443	lea edx, [ecx*2+edx]	443	lea edx, [ecx*2+edx]
444	mov cl, bh	444	mov cl, bh
445	lea ecx, [ecx*4+ecx]	445	lea ecx, [ecx*4+ecx]
446	add edx, ecx	446	add edx, ecx
447	shr edx, 4	447	shr edx, 4
448	mov ah, dl	448	mov ah, dl
449		449
450	rol ebx, 16	450	rol ebx, 16
451	rol eax, 16	451	rol eax, 16
452	xor ecx, ecx	452	xor ecx, ecx
453	mov cl, bl	453	mov cl, bl
454	lea edx, [ecx*8+ecx]	454	lea edx, [ecx*8+ecx]
455	lea edx, [ecx*2+edx]	455	lea edx, [ecx*2+edx]
456	mov cl, al	456	mov cl, al
457	lea ecx, [ecx*4+ecx]	457	lea ecx, [ecx*4+ecx]
458	add edx, ecx	458	add edx, ecx
459	shr edx, 4	459	shr edx, 4
460	mov al, dl	460	mov al, dl
461	rol eax, 16	461	rol eax, 16
462	@@:	462	@@:
463	mov [edi+4], eax	463	mov [edi+4], eax
464	pop edx ebx	464	pop edx ebx
465	jmp .nextPixel	465	jmp .nextPixel
466		466
467	.square: ; scaling	467	.square: ; scaling
468	mov eax, esi	468	mov eax, esi
469	@@:	469	@@:
470	mov [edi+eax*4], ebp	470	mov [edi+eax*4], ebp
471	dec eax	471	dec eax
472	jns @b	472	jns @b
473	add edi, [esp+20+widthX]	473	add edi, [esp+20+widthX]
474	dec ecx	474	dec ecx
475	jnz .square	475	jnz .square
476	inc esi	476	inc esi
477	mov edi, [esp]	477	mov edi, [esp]
478	.checkLeft:	478	.checkLeft:
479	bsf eax, edx	479	bsf eax, edx
480	dec eax	480	dec eax
481	js .checkRight	481	js .checkRight
482	bt [ebx], eax	482	bt [ebx], eax
483	jc .checkRight	483	jc .checkRight
484	.checkLeftDown:	484	.checkLeftDown:
485	bt [ebx+1], eax	485	bt [ebx+1], eax
486	jnc .checkLeftUp	486	jnc .checkLeftUp
487	mov ecx, eax	487	mov ecx, eax
488	inc eax	488	inc eax
489	bt [ebx+1], eax	489	bt [ebx+1], eax
490	jc @f	490	jc @f
491	bt [ebx-1], eax	491	bt [ebx-1], eax
492	jnc .downRightLow	492	jnc .downRightLow
493	bt [ebx-2], eax	493	bt [ebx-2], eax
494	jc .downRightLow	494	jc .downRightLow
495	dec eax	495	dec eax
496	bt [ebx-1], eax	496	bt [ebx-1], eax
497	jc .downRightLow	497	jc .downRightLow
498	dec eax	498	dec eax
499	js .downRightHigh	499	js .downRightHigh
500	bt [ebx-2], eax	500	bt [ebx-2], eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/font.inc @ 6472 – Rev 5926 → 6036