Subversion Repositories Kolibri OS

.;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;                                                              ;;

;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;

;; Distributed under terms of the GNU General Public License    ;;

;;                                                              ;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

$Revision: 2321 $

; // Alver 22.06.2008 // {

align 4

dtext_asciiz_esi:			   ; for skins title out

    push eax

    xor eax, eax

    inc eax

    jmp    dtext.1

; } \\ Alver \\

align 4

dtext:	; Text String Output (rw by Johnny_B[john@kolibrios.org])

	; ebx x & y

	; ecx style ( 0xX0000000 ) & color ( 0x00RRGGBB )

	; X = ABnnb:

	; nn = font

	; A = 0 <=> output esi characters; otherwise output ASCIIZ string

	; B = 1 <=> fill background with color eax

	; edx start of text

	; edi 1 force

; // Alver 22.06.2008 // {

       push eax

	xor	eax, eax

.1:

; } \\ Alver \\

	pushad

	call	[_display.disable_mouse]

	movsx	eax, bx 	; eax=y

	sar	ebx, 16 	; ebx=x

	xchg	eax, ebx	; eax=x, ebx=y

	cmp	esi, 255

	jb	.loop

	mov	esi, 255

.loop:

	test	ecx, ecx

	js	.test_asciiz

	dec	esi

	js	.end

	jmp	@f

.test_asciiz:

	cmp	byte [edx], 0

	jz	.end

; // Alver 22.06.2008 // {

	cmp byte [esp+28], 1	;  was the entry point = dtext.1 ?

	jne   @f

	dec	esi

	js	  .end

; } \\ Alver \\

@@:

	inc	edx

	pushad			; esp -= 64 !

	movzx	edx, byte [edx-1]

	test	ecx, 0x10000000

	jnz	.font2

	mov	esi, 9

	lea	ebp, [FONT_I+8*edx+edx]

.symloop1:

	mov	dl, byte [ebp]

	or	dl, 1 shl 6

.pixloop1:

	shr	dl, 1

	jz	.pixloop1end

	jnc	.nopix

	call	[putpixel]

	jmp	.pixloop1cont

.nopix:

	test	ecx, 0x40000000

	jz	.pixloop1cont

	push	ecx

	mov	ecx, [esp+4+20h+20h]	; original eax?

	call	[putpixel]

	pop	ecx

.pixloop1cont:

	inc	eax

	jmp	.pixloop1

.pixloop1end:

	sub	eax, 6

	inc	ebx

	inc	ebp

	dec	esi

	jnz	.symloop1

	popad

	add	eax, 6

	jmp	.loop

.font2:

	add	edx, edx

	lea	ebp, [FONT_II+4*edx+edx+1]

	push	9

	movzx	esi, byte [ebp-1]

.symloop2:

	mov	dl, byte [ebp]

	push	esi

.pixloop2:

	shr	dl, 1

	jnc	.nopix2

	call	[putpixel]

	jmp	.pixloop2cont

.nopix2:

	test	ecx, 0x40000000

	jz	.pixloop2cont

	push	ecx

	mov	ecx, [esp+12+20h+20h]

	call	[putpixel]

	pop	ecx

.pixloop2cont:

	inc	eax

	dec	esi

	jnz	.pixloop2

	pop	esi

	sub	eax, esi

	inc	ebx

	inc	ebp

	dec	dword [esp]

	jnz	.symloop2

	pop	eax

	add	dword [esp+28], esi

	popad

	jmp	.loop

.end:

	popad

	pop  eax		; << // Alver 22.06.2008 // <<

	ret

;=====================================================

; NEW FONTS

;_____________________________________________________

;

align 8

sdsh_data:

include 'sdsh.inc'

sdsh_code:

; eax	=	if (bit[31])

;				then lower 31 bits points to the user-selected font

;				else ax = number of preloaded system font

; ebx	=	x<<16 + y

; ecx	=	0x00RRGGBB

; edx	=	if (bits[31:8] == 0)

;				then dl = single char to write

;				else edx= pointer to asciiz-string

sdsh_draw_char:

; eax = left side X

; ebx = bottom Y

; edi = color 0x0RRGGBB

; ebp = font@

; ecx = ascii, zero-extended to 32bits

        push    ecx, edx, ebp

        shl     ebp, 4

        add     ebp, sdsh_data.info

        call	ch_checkscreen

        jb		.exit

        call	ch_checkwin

        jc		.exit

        xor		ch, ch

        mov     edx, [ebp + 4]              ; chartable addr

        mov		cx, word[edx + ecx*2]       ; tick info

        mov		edx, ecx

        and     ecx, 7                      ; cl = number of ticks

        jz      .blank

        shr     edx, 4                      ; offset in the chartable

        add     edx, [sdsh_data.chars]      ; edx -> the char's ticklist

.next_tick:

        call    parse_tick

        add     edx, 4

        dec     cl

        jnz     .next_tick

.blank:

.exit:

        pop     ebp, edx, ecx

        ret

parse_tick:

; eax = left side X

; ebx = bottom Y

; edx ->tickinfo

; edi = color 0x0RRGGBB

; ebp = font's header

        pushad

        xor     ecx, ecx

        mov     dx, word[edx]

        mov     cl, dl

        test    dl, 0xE0            ; ticks #32..255

        jz      .lntick.short

        cmp     dl, 0xE0

        jae     .lntick.long

        cmp     dl, 0xC0

        jae     .cstick

.gptick:

        push    edx

        mov     cl, dh

        shr     cl, 3               ; orig.#

        mov     edx, [ebp+8]        ; orig. table

        mov     ch, byte[edx+ecx]   ; orig. coords

        pop     edx

        mov     cl, dh

        and     cl, 7                   ; three rotation bits

        and     edx, 0xFF               ; dl = gptick#

        sub     dl, 32

        cmp     dl, (sdsh_data.v5-sdsh_data.v1)

        jae     .gptick.2

.gptick.1:

        mov     esi, sdsh_data.tick_table

        add     esi, edx                ;  1-byte tickgroups .v1-v4:

        inc     dh

        sub     dl, 2                   ; .v1 : 2 ticks only (#32, 33)

        jae     @f

        mov     dl, dh

        jmp     .gptick.done

@@:     inc     dh

        shr     dl, 3                   ; tickgroups .v2-v4 : 8 ticks each

        add     dl, dh

        jmp     .gptick.done

.gptick.2:

        sub     dl, (sdsh_data.v5-sdsh_data.v1)

        cmp     dl, (sdsh_data.v9-sdsh_data.v5)

        jae     .gptick.3

        mov     esi, sdsh_data.v5

        lea     esi, [esi+edx*2]        ; 2-byte tickgroups .v5-v8: 8 ticks each

        mov     dh, 5

        shr     dl, 3

        add     dl, dh

        jmp     .gptick.done

.gptick.3:

        sub     dl, (sdsh_data.v9-sdsh_data.v5)

        cmp     dl, (sdsh_data.v13-sdsh_data.v9)

        jae     .gptick.4

        mov     esi, sdsh_data.v9

        lea     esi,[esi+edx*2+edx]     ; 3-byte tickgroups .v9-12: 4 ticks each

        mov     dh, 9

        shr     dl, 2

        add     dl, dh

        jmp     .gptick.done

.gptick.4:

        sub     dl, (sdsh_data.v13-sdsh_data.v9)

        cmp     dl, 16

        jae     .exit

        mov     esi, sdsh_data.v13

        lea     esi,[esi+edx*4]         ; 4-byte tickgroups .v13-16: 4 ticks each

        mov     dh, 13

        shr     dl, 2

        add     dl, dh

.gptick.done:

        mov     dh, ch                  ; dh = orig.XY;     dl = numvert

        jmp     .draw                   ; cl = rotation

.cstick:

        and     cl, 4

        shr     cl, 2                   ; only one rotational bit

        and     dl, 3

        inc     dl

        dec     dl

        jz      .cstick.0

        dec     dl

        jnz     @f

        mov     dl, 6

        jz      .cstick.1

@@:     dec     dl

        jz      .cstick.2

.cstick.3:

        mov     esi, sdsh_data.cs3      ; 12pix-ring

        mov     dl, 10

        jmp     .draw

.cstick.2:

        mov     dl, 7

.cstick.1:

        mov     esi, sdsh_data.cs2      ; the square

        jmp     .draw

.cstick.0:

        mov     esi, sdsh_data.cs0      ; 4pix-square

        mov     dl, 3

        jmp     .draw

.ritick:

        test    dl, 1

        jnz     .ritick.1

.ritick.0:

        mov     cl, dh              ; y

        and     cl, 0x0F

        sub     ebx, ecx

        mov     cl, dh

        shr     cl, 4               ; x

        add     eax, ecx

        call    ch_putpixel

        jmp     .exit

.ritick.1:

        mov     esi, sdsh_data.ri1  ; 8pix-ring

        mov     dl, 4

        xor     cl, cl

        jmp     .draw

.lntick.short:

        test    dl, 0x06            ; ticks #0, 1 are reserved for

        jz      .ritick             ;             rotational invariants

        and     dl, 0x07            ; dl = line length

        jmp     .lntick.both

.lntick.long:

        and     dl, 0x07

        add     dl, 8

.lntick.both:

        sub     dl, 2               ; num_vertice = num_points - 2

        and     cl, 0x18            ; two rotation bits

        shr     cl, 3

        mov     esi, sdsh_data.blank

.draw:

; cl = rot; dl = numvert; dh = orig.xy

        push    ecx

        mov     cl, dh              ; y

        and     cl, 0x0F

        sub     ebx, ecx

        mov     cl, dh

        shr     cl, 4               ; x

        add     eax, ecx

        pop     ecx

        call    draw_tick

.gptick.5:

.exit:

        popad

        ret

draw_tick:

; eax = x-origin

; ebx = y-origin

; edi = 0x0RRGGBB

;  cl = direction (0..7)

;  dl = number of vertices  (dl)

; esi -> tick bitfield

	pushad

    inc     dl                      ; -- that's to count down to 0

	call	ch_putpixel		        ; the point of origin

	and		ecx, 7

	call	[.moves + ecx*4]        ; basic vector

	call	ch_putpixel

    dec     dl

    jz      .done                   ; 2pix lines only

    mov     esi, dword [esi]        ; max 16 vertice bitfield limit

    xchg    esi, edx

.move_and_draw:

    mov     ch, dl

    and     ch, 3

    jz      .moved

    btc     ch, 0

    jz      .2

.1:

    dec     cl                      ; right turns (1 and 3)

    and     cl, 7

@@: btc     ch, 1                   ; straight angle (3) ?

    jc      .1

    jmp     .moved

.2:

    inc     cl                      ; left turn (2)

    and     cl, 7

    btc     ch, 1                   ; just to zero ah

.moved:

	call	[.moves + ecx*4]        ; go new way

	call	ch_putpixel

    shr     edx, 2

    dec     esi

    jnz     .move_and_draw

.done:

	popad

	ret

.move000:

	inc		eax

	ret

.move001:

	inc		eax

	dec		ebx

	ret

.move010:

	dec		ebx

	ret

.move011:

	dec		eax

	dec		ebx

	ret

.move100:

	dec		eax

	ret

.move101:

	dec		eax

	inc		ebx

	ret

.move110:

	inc		ebx

	ret

.move111:

	inc		eax

	inc		ebx

	ret

align 4

.moves dd .move000, .move001, .move010, .move011, .move100, .move101, .move110, .move111

;)

align 4

ch_checkscreen:

     cmp	[Screen_Max_X], eax

     jb		.getout

     cmp	[Screen_Max_Y], ebx

.getout:

     ret

align 4

ch_checkwin:

; eax = x coordinate

; ebx = y coordinate

; ebp -> font info

;!destroys ch, edx!

        push    eax, ebx

        mov     ch,  byte[CURRENT_TASK]

        mov     al,  byte [ebp]	            ; char X-width

        mov     edx, [_display.width]       ; screen X-size

        imul    edx, ebx

        add     edx, [_WinMapAddress]

        add     edx, eax

        cmp     ch,  byte [edx]

        jne     .fail

        moxzx   eax, byte [ebp]

        cmp     ch,  byte [edx+eax]

        jne     .fail

        moxzx   ebx, byte [ebp+1]

        imul    ebx, [_display.width]

        cmp     ch,  byte [edx+ebx]

        jne     .fail

        add     edx, eax

        cmp     ch,  byte [edx+ebx]

        clc

        je     .done

.fail:

        stc                                 ; CF means the charbox is invisible

.done:

        pop     ebx, eax

        ret

align 4

ch_putpixel:

; eax = x coordinate

; ebx = y coordinate

; edi = 0x0RRGGBB

     push   edx

	 mov	edx, ebx

     imul	edx, [BytesPerScanLine]

     lea	edx, [edx+eax*4]

     mov   [LFB_BASE+edx], edi

     pop   edx

     ret

;)

;diff16 "font  code end ",0,$

diff10 "font  code size",dtext,$