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: 7718 $
 
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    
; flag CF=1 means that we deal with asciiz but need to draw no more than esi symbols
        clc
._:        
        push    ecx edx
        setc    dl        
        and     eax, 0xFFFFFF
        and     ecx, 1 shl 31
        shl     edx, 29
        or      eax, ecx    
        or      eax, edx
        pop     edx ecx        
        bt      ecx, 30
        jc      @f
        or      eax, 1 shl 30
@@:
        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]
        test    eax, 1 shl 30
        jz      @f
        or      eax, -1
        mov     [esp+28], edi
        jmp     .1
@@:     
        and     eax, 0x00ffffff          
.1:
        mov     edi, edx
        rep stosd
        mov     edi, edx
        mov     eax, ebx
        and     eax, 0xFFFFFF
.bufferReady:
        mov     ebp, eax
        mov     eax, [esp+8]
        shr     eax, 2
        sub     eax, [esp+16]
        shr     eax, 3
        xor     edx, edx
        div     dword[esp+4]
        mov     ecx, [esp]
        cmp     eax, ecx
        jnc     @f
        mov     [esp], eax
@@:
        xor     edx, edx
        bt      ebx, 29
        jc      @f
        bt      ebx, 28
        jc      .draw866toUni
        shl     eax, 3
        mov     bx, 6
        div     bx
        xor     edx, edx
        inc     eax
        mov     [esp], ecx
        cmp     eax, ecx
        jnc     .draw866
        mov     [esp], eax
        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
; internal flags & background +24
deltaToScreen = 28
; temp buffer height +32
; temp buffer pointer +36
 
.drawUTF16:
        dec     dword [esp]
        js      .done
        movzx   ebx, word [esi]
        test    dword [esp + 24], 1 shl 31
        jnz     @f                
        test    dword [esp + 24], 1 shl 29
        jz      .u16Still
@@:        
        test    ebx, ebx
        jz      .done
.u16Still:        
        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
        xor     eax, eax
        call    utf8to16
        test    dword [esp + 24], 1 shl 31
        jnz     @f                
        test    dword [esp + 24], 1 shl 29
        jz      .u8Still
@@:        
        test    eax, eax
        jz      .done
.u8Still:        
        cmp     eax, 1419
        jc      @f
        xor     eax, eax
@@:
        shl     eax, 4
        lea     ebx, [eax+fontUni]
        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     .drawUTF8
 
.draw866:
        dec     dword [esp]
        js      .done
        movzx   ebx, byte [esi]
        test    dword [esp + 24], 1 shl 31
        jnz     @f                
        test    dword [esp + 24], 1 shl 29
        jz      .866Still
@@:        
        test    ebx, ebx
        jz      .done
.866Still:        
        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    dword [esp + 24], 1 shl 31
        jnz     @f                
        test    dword [esp + 24], 1 shl 29
        jz      .8662uStill         
@@:        
        test    eax, eax
        jz      .done
.8662uStill:        
        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
 
iglobal
fontSmoothing   db  2   ; = 0, 1 or 2
fontSize        db  0   ; user mode setting
font1:
  if lang eq sp
  file 'gui/char_sp.mt'
  else if lang eq et
  file 'gui/char_et.mt'
  else
  file 'gui/char.mt'
  end if
fontUni:
file 'gui/charUni.mt'
endg

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

Subversion Repositories Kolibri OS

(root)/kernel/trunk/gui/font.inc @ 106 – Rev 7103 → 7718