Subversion Repositories Kolibri OS

Rev

Rev 2322 | Rev 2470 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2322 Rev 2461
Line 3... Line 3...
3 
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
 3 
;; Copyright (C) KolibriOS team 2004-2008. 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 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 7... Line 7...
7 
 
 7 
 
Line 8... Line 8...
8 
$Revision: 2322 $
 8 
$Revision: 2461 $
9 
 
 9 
 
10 
; // Alver 22.06.2008 // {
 10 
; // Alver 22.06.2008 // {
11 
align 4
 11 
align 4
Line 139... Line 139...
139 
;
 139 
;
Line 140... Line 140...
140 
 
 140 
 
141 
align 8
 141 
align 8
Line -... Line 142...
- 
 
 142 
sdsh_data:
- 
 
 143 
 
142 
sdsh_data:
 144 
diff16 "sdsh_data      : ",0,$
Line 143... Line 145...
143 
 
 145 
 
Line 144... Line 146...
144 
include 'fonts/sd_data.asm'
 146 
include 'fonts/sd_data.asm'
145 
 
 147 
 
146 
sdsh_code:
 148 
sdsh_code:
147 
 
 149 
 
148 
; eax	=	if (bit[31])
150 
; eax   =       if (bit[31])
149 
;				then lower 31 bits points to the user-selected font
 151 
;                               then lower 31 bits points to the user-selected font
150 
;				else ax = number of preloaded system font
152 
;                               else ax = number of preloaded system font
151 
; ebx	=	x<<16 + y
 153 
; ebx   =       x<<16 + y
- 
 
 154 
; ecx   =       0x00RRGGBB
- 
 
 155 
; edx   =       if (bits[31:8] == 0)
Line 152... Line 156...
152 
; ecx	=	0x00RRGGBB
 156 
;                               then dl = single char to write
153 
; edx	=	if (bits[31:8] == 0)
 157 
;                               else edx= pointer to asciiz-string
154 
;				then dl = single char to write
158 
 
155 
;				else edx= pointer to asciiz-string
 159 
diff16 "draw_char      : ",0,$
156 
 
 160 
 
157 
draw_char:
 161 
draw_char:
158 
; font test
 162 
; font test
159 
; bl=y; bh=x
 163 
; bl=y; bh=x
160 
; dl=ascii
 164 
; dl=ascii
- 
 
 165 
	movzx	eax, bh
161 
        movzx   eax, bh
 166 
	movzx	ebx, bl
162 
        movzx   ebx, bl
 167 
	movzx	ecx, dl
163 
        movzx   ecx, dl
 168 
	xor	edi, edi
164 
        xor     edi, edi
 169 
	mov	ebp, edi
165 
        mov     ebp, edi
 170 
 
166
171 
 
167 
sdsh_draw_char:
 172 
sdsh_draw_char:
168 
; eax = left side X
 173 
; eax = left side X
169 
; ebx = bottom Y
 174 
; ebx = bottom Y
170 
; edi = color 0x0RRGGBB
 175 
; edi = color 0x0RRGGBB
171 
; ebp = font@
176 
; ebp = font@
172 
; ecx = ascii, zero-extended to 32bits
 177 
; ecx = ascii, zero-extended to 32bits
173 
        push    ecx
 178 
	push	ecx
174 
        push    edx
179 
	push	edx
175 
        push    ebp
 180 
	push	ebp
176 
        shl     ebp, 4
 181 
	shl	ebp, 4
177 
        add     ebp, sdsh_data.info
 - 
 
178 
        call	ch_checkscreen
 182 
	add	ebp, sdsh_data.info
179 
        jb		.exit
 183 
;        call   ch_checkscreen
180 
        call	ch_checkwin
 184 
;        jb             .exit
181 
        jc		.exit
 185 
;        call   ch_checkwin
182 
        xor		ch, ch
 186 
;        jc             .exit
183 
        mov     edx, [ebp + 4]              ; chartable addr
 187 
	mov	edx, [ebp + 4]		    ; chartable addr
184 
        mov		cx, word[edx + ecx*2]       ; tick info
 188 
	mov	cx, word[edx + ecx*2]	    ; tick info
185 
        mov		edx, ecx
 189 
	mov	edx, ecx
186 
        and     ecx, 7                      ; cl = number of ticks
 190 
	and	ecx, 7			    ; cl = number of ticks
187 
        jz      .blank
 191 
	jz	.blank
188 
        shr     edx, 4                      ; offset in the chartable
 192 
	shr	edx, 4			    ; offset in the chartable
189 
        add     edx, [sdsh_data.chars]      ; edx -> the char's ticklist
193 
	add	edx, sdsh_data.chars	    ; edx -> the char's ticklist
190 
.next_tick:
 194 
.next_tick:
191 
        call    parse_tick
 195 
	call	parse_tick
192 
        add     edx, 4
 196 
	add	edx, 2
193 
        dec     cl
 197 
	dec	cl
194 
        jnz     .next_tick
 198 
	jnz	.next_tick
195 
.blank:
 199 
.blank:
Line 196... Line 200...
196 
.exit:
 200 
.exit:
- 
 
 201 
	pop	ebp
197 
        pop     ebp
202 
	pop	edx
198 
        pop     edx
203 
	pop	ecx
199 
        pop     ecx
 204 
	ret
200 
        ret
 205 
 
201 
 
 206 
 
202 
 
 207 
parse_tick:
203 
parse_tick:
 208 
diff16 "parse_tick     : ",0,$
204 
; eax = left side X
 209 
; eax = left side X
205 
; ebx = bottom Y
 210 
; ebx = bottom Y
206 
; edx ->tickinfo
 211 
; edx ->tickinfo
207 
; edi = color 0x0RRGGBB
 212 
; edi = color 0x0RRGGBB
208 
; ebp = font's header
213 
; ebp = font's header
209 
        pushad
214 
	pushad
210 
        xor     ecx, ecx
 215 
	xor	ecx, ecx
211 
        mov     dx, word[edx]
 216 
	mov	dx, word[edx]
212 
        mov     cl, dl
 217 
	mov	cl, dl
213 
        test    dl, 0xE0            ; ticks #32..255
 218 
	test	dl, 0xE0	    ; ticks #32..255
214 
        jz      .lntick.short
 219 
	jz	.lntick.short
215 
        cmp     dl, 0xE0
 220 
	cmp	dl, 0xE0
216 
        jae     .lntick.long
 221 
	jae	.lntick.long
217 
        cmp     dl, 0xC0
 222 
	cmp	dl, 0xC0
218 
        jae     .cstick
 223 
	jae	.cstick
219 
.gptick:
 224 
.gptick:
220 
        push    edx
 225 
	push	edx
221 
        mov     cl, dh
 226 
	mov	cl, dh
222 
        shr     cl, 3               ; orig.#
 227 
	shr	cl, 3		    ; orig.#
223 
        mov     edx, [ebp+8]        ; orig. table
 228 
	mov	edx, [ebp+8]	    ; orig. table
224 
        mov     ch, byte[edx+ecx]   ; orig. coords
 229 
	mov	ch, byte[edx+ecx]   ; orig. coords
225 
        pop     edx
 230 
	pop	edx
226 
        mov     cl, dh
 231 
	mov	cl, dh
227 
        and     cl, 7                   ; three rotation bits
 232 
	and	cl, 7			; three rotation bits
228 
        and     edx, 0xFF               ; dl = gptick#
 233 
	and	edx, 0xFF		; dl = gptick#
229 
        sub     dl, 32
 234 
	sub	dl, 32
230 
        cmp     dl, (sdsh_data.v5-sdsh_data.v1)
 235 
	cmp	dl, (sdsh_data.v5-sdsh_data.v1)
231 
        jae     .gptick.2
 236 
	jae	.gptick.2
232 
.gptick.1:
 237 
.gptick.1:
233 
        mov     esi, sdsh_data.tick_table
 238 
	mov	esi, sdsh_data.tick_table
234 
        add     esi, edx                ;  1-byte tickgroups .v1-v4:
 239 
	add	esi, edx		;  1-byte tickgroups .v1-v4:
235 
        inc     dh
 240 
	inc	dh
236 
        sub     dl, 2                   ; .v1 : 2 ticks only (#32, 33)
241 
	sub	dl, 2			; .v1 : 2 ticks only (#32, 33)
237 
        jae     @f
 242 
	jae	@f
238 
        mov     dl, dh
 243 
	mov	dl, dh
239 
        jmp     .gptick.done
 244 
	jmp	.gptick.done
240 
@@:     inc     dh
 245 
@@:	inc	dh
241 
        shr     dl, 3                   ; tickgroups .v2-v4 : 8 ticks each
 246 
	shr	dl, 3			; tickgroups .v2-v4 : 8 ticks each
242 
        add     dl, dh
 247 
	add	dl, dh
243 
        jmp     .gptick.done
248 
	jmp	.gptick.done
244 
.gptick.2:
 249 
.gptick.2:
245 
        sub     dl, (sdsh_data.v5-sdsh_data.v1)
 250 
	sub	dl, (sdsh_data.v5-sdsh_data.v1)
246 
        cmp     dl, (sdsh_data.v9-sdsh_data.v5)
 251 
	cmp	dl, (sdsh_data.v9-sdsh_data.v5)
247 
        jae     .gptick.3
 252 
	jae	.gptick.3
248 
        mov     esi, sdsh_data.v5
 253 
	mov	esi, sdsh_data.v5
249 
        lea     esi, [esi+edx*2]        ; 2-byte tickgroups .v5-v8: 8 ticks each
 254 
	lea	esi, [esi+edx*2]	; 2-byte tickgroups .v5-v8: 8 ticks each
250 
        mov     dh, 5
 255 
	mov	dh, 5
251 
        shr     dl, 3
256 
	shr	dl, 3
252 
        add     dl, dh
 257 
	add	dl, dh
253 
        jmp     .gptick.done
258 
	jmp	.gptick.done
254 
.gptick.3:
 259 
.gptick.3:
255 
        sub     dl, (sdsh_data.v9-sdsh_data.v5)
 260 
	sub	dl, (sdsh_data.v9-sdsh_data.v5)
256 
        cmp     dl, (sdsh_data.v13-sdsh_data.v9)
 261 
	cmp	dl, (sdsh_data.v13-sdsh_data.v9)
257 
        jae     .gptick.4
 262 
	jae	.gptick.4
258 
        mov     esi, sdsh_data.v9
 263 
	mov	esi, sdsh_data.v9
259 
        lea     esi,[esi+edx*2]
 264 
	lea	esi,[esi+edx*2]
260 
        add     esi, edx                ; 3-byte tickgroups .v9-12: 4 ticks each
265 
	add	esi, edx		; 3-byte tickgroups .v9-12: 4 ticks each
261 
        mov     dh, 9
 266 
	mov	dh, 9
262 
        shr     dl, 2
267 
	shr	dl, 2
263 
        add     dl, dh
 268 
	add	dl, dh
264 
        jmp     .gptick.done
269 
	jmp	.gptick.done
265 
.gptick.4:
 270 
.gptick.4:
266 
        sub     dl, (sdsh_data.v13-sdsh_data.v9)
 271 
	sub	dl, (sdsh_data.v13-sdsh_data.v9)
267 
        cmp     dl, 16
 272 
	cmp	dl, 16
268 
        jae     .exit
 273 
	jae	.exit
269 
        mov     esi, sdsh_data.v13
 274 
	mov	esi, sdsh_data.v13
270 
        lea     esi,[esi+edx*4]         ; 4-byte tickgroups .v13-16: 4 ticks each
 275 
	lea	esi,[esi+edx*4] 	; 4-byte tickgroups .v13-16: 4 ticks each
271 
        mov     dh, 13
 276 
	mov	dh, 13
272 
        shr     dl, 2
277 
	shr	dl, 2
273 
        add     dl, dh
 278 
	add	dl, dh
274 
.gptick.done:
 279 
.gptick.done:
275 
        mov     dh, ch                  ; dh = orig.XY;     dl = numvert
 280 
	mov	dh, ch			; dh = orig.XY;     dl = numvert
276 
        jmp     .draw                   ; cl = rotation
 281 
	jmp	.draw			; cl = rotation
277
282 
 
278 
.cstick:
 283 
.cstick:
279 
        and     cl, 4
 284 
	and	cl, 4
280 
        shr     cl, 2                   ; only one rotational bit
 285 
	shr	cl, 2			; only one rotational bit
281 
        and     dl, 3
 286 
	and	dl, 3
282 
        inc     dl
 287 
	inc	dl
283 
        dec     dl
 288 
	dec	dl
284 
        jz      .cstick.0
 289 
	jz	.cstick.0
285 
        dec     dl
 290 
	dec	dl
286 
        jnz     @f
 291 
	jnz	@f
287 
        mov     dl, 6
 292 
	mov	dl, 6
288 
        jz      .cstick.1
 293 
	jz	.cstick.1
289 
@@:     dec     dl
 294 
@@:	dec	dl
290 
        jz      .cstick.2
 295 
	jz	.cstick.2
291 
.cstick.3:
 296 
.cstick.3:
292 
        mov     esi, sdsh_data.cs3      ; 12pix-ring
 297 
	mov	esi, sdsh_data.cs3	; 12pix-ring
293 
        mov     dl, 10
 298 
	mov	dl, 10
294 
        jmp     .draw
 299 
	jmp	.draw
295 
.cstick.2:
 300 
.cstick.2:
296 
        mov     dl, 7
 301 
	mov	dl, 7
Line 297... Line 302...
297 
.cstick.1:
 302 
.cstick.1:
298 
        mov     esi, sdsh_data.cs2      ; the square
 303 
	mov	esi, sdsh_data.cs2	; the square
299 
        jmp     .draw
 304 
	jmp	.draw
300 
.cstick.0:
 305 
.cstick.0:
301 
        mov     esi, sdsh_data.cs0      ; 4pix-square
 306 
	mov	esi, sdsh_data.cs0	; 4pix-square
302 
        mov     dl, 3
 307 
	mov	dl, 3
303 
        jmp     .draw
 308 
	jmp	.draw
304 
 
 309 
 
305 
.ritick:
 310 
.ritick:
306 
        test    dl, 1
 311 
	test	dl, 1
307 
        jnz     .ritick.1
 312 
	jnz	.ritick.1
308 
.ritick.0:
 313 
.ritick.0:
309 
        mov     cl, dh              ; y
 314 
	mov	cl, dh		    ; y
310 
        and     cl, 0x0F
 315 
	and	cl, 0x0F
311 
        sub     ebx, ecx
 316 
	sub	ebx, ecx
312 
        mov     cl, dh
 317 
	mov	cl, dh
313 
        shr     cl, 4               ; x
 318 
	shr	cl, 4		    ; x
314 
        add     eax, ecx
 319 
	add	eax, ecx
315 
        call    ch_putpixel
 320 
	call	ch_putpixel
316 
        jmp     .exit
 321 
	jmp	.exit
317 
.ritick.1:
 322 
.ritick.1:
318 
        mov     esi, sdsh_data.ri1  ; 8pix-ring
 323 
	mov	esi, sdsh_data.ri1  ; 8pix-ring
319 
        mov     dl, 4
324 
	mov	dl, 4
320 
        xor     cl, cl
 325 
	xor	cl, cl
321 
        jmp     .draw
326 
	jmp	.draw
322
327 
 
323 
.lntick.short:
 328 
.lntick.short:
324 
        test    dl, 0x06            ; ticks #0, 1 are reserved for
329 
	test	dl, 0x06	    ; ticks #0, 1 are reserved for
325 
        jz      .ritick             ;             rotational invariants
330 
	jz	.ritick 	    ;             rotational invariants
326 
        and     dl, 0x07            ; dl = line length
 331 
	and	dl, 0x07	    ; dl = line length
327 
        jmp     .lntick.both
 332 
	jmp	.lntick.both
328 
.lntick.long:
 333 
.lntick.long:
329 
        and     dl, 0x07
 334 
	and	dl, 0x07
330 
        add     dl, 8
 335 
	add	dl, 8
331 
.lntick.both:
 336 
.lntick.both:
332 
        sub     dl, 2               ; num_vertice = num_points - 2
 337 
	sub	dl, 2		    ; num_vertice = num_points - 2
333 
        and     cl, 0x18            ; two rotation bits
 338 
	and	cl, 0x18	    ; two (lower) rotation bits
334 
        shr     cl, 3
 339 
	shr	cl, 3
335 
        mov     esi, sdsh_data.blank
340 
	mov	esi, sdsh_data.blank
336 
.draw:
 341 
.draw:
337 
; cl = rot; dl = numvert; dh = orig.xy
342 
; cl = rot; dl = numvert; dh = orig.xy
338 
        push    ecx
 343 
	push	ecx
339 
        mov     cl, dh              ; y
 344 
	mov	cl, dh		    ; y
340 
        and     cl, 0x0F
 345 
	and	cl, 0x0F
341 
        sub     ebx, ecx
 346 
	sub	ebx, ecx
342 
        mov     cl, dh
 347 
	mov	cl, dh
- 
 
 348 
	shr	cl, 4		    ; x
- 
 
 349 
	add	eax, ecx
- 
 
 350 
	pop	ecx
Line 343... Line -...
343 
        shr     cl, 4               ; x
 - 
 
344 
        add     eax, ecx
 - 
 
345 
        pop     ecx
 351 
	call	draw_tick
346 
        call    draw_tick
 352 
.gptick.5:
347 
.gptick.5:
 353 
.exit:
348 
.exit:
 354 
	popad
349 
        popad
 355 
	ret
350 
        ret
 356 
 
351 
 
 357 
 
Line 352... Line 358...
352
358 
diff16 "draw_tick      : ",0,$
353
- 
 
354 
draw_tick:
 359 
 
355 
; eax = x-origin
 360 
draw_tick:
- 
 
 361 
; eax = x-origin
356 
; ebx = y-origin
 362 
; ebx = y-origin
357 
; edi = 0x0RRGGBB
363 
; edi = 0x0RRGGBB
358 
;  cl = direction (0..7)
364 
;  cl = direction (0..7)
359 
;  dl = number of vertices  (dl)
 365 
;  dl = number of vertice  (dl)
360 
; esi -> tick bitfield
366 
; esi -> tick bitfield
361 
 
 367 
 
362 
	pushad
 368 
	pushad
363 
    inc     dl                      ; -- that's to count down to 0
369 
	call	ch_putpixel			; the point of origin
364 
	call	ch_putpixel		        ; the point of origin
 370 
	and	ecx, 7
365 
	and		ecx, 7
 371 
	lea	ebp, [.move000+ ecx*4]
- 
 
 372 
	call	ebp		      ; basic vector
- 
 
 373 
	call	ch_putpixel
366 
	call	[.moves + ecx*4]        ; basic vector
 374 
        and     edx, 15
367 
	call	ch_putpixel
375 
        jz	.done		       ; no vertex (2pix line)
- 
 
 376 
        mov     esi, dword [esi]       ; 15 vertice will easily fit to 1dw
- 
 
 377 
        xchg    esi, edx
368 
    dec     dl
 378 
.move_and_draw:
369 
    jz      .done                   ; 2pix lines only
 - 
 
370 
    mov     esi, dword [esi]        ; max 16 vertice bitfield limit
 - 
 
371 
    xchg    esi, edx
- 
 
372 
.move_and_draw:
 379 
        mov     ch, dl
373 
    mov     ch, dl
 380 
        and     ch, 3
374 
    and     ch, 3
 381 
        jz	.moved
375 
    jz      .moved
 382 
        dec     ch
- 
 
 383 
        jz      .1
376 
    btc     ecx, 8
 384 
        dec     ch
377 
    jz      .2
 - 
 
378 
.1:
 385 
        jz      .2
- 
 
 386 
.3:
- 
 
 387 
        dec     cl
379 
    dec     cl                      ; right turns (1 and 3)
 388 
.1:
380 
    and     cl, 7
 389 
        dec     cl
381 
@@: btc     ecx, 9                  ; straight angle (3) ?
 390 
        jmp     .wipe_it
382 
    jc      .1
 391 
.2:
383 
    jmp     .moved
 392 
        inc     cl
- 
 
 393 
.wipe_it:
384 
.2:
 394 
        and     ecx, 7
385 
    inc     cl                      ; left turn (2)
 395 
.moved:
386 
    and     cl, 7
 396 
diff16 "moved          : ",0,$
Line -... Line 397...
- 
 
 397 
	lea	ebp, [.move000+ ecx*4]
- 
 
 398 
	call	ebp		    ; go new way
- 
 
 399 
	call	ch_putpixel
387 
    btc     ecx, 9                  ; just to zero ah
 400 
        shr     edx, 2
388 
.moved:
 401 
        dec     esi
389 
	call	[.moves + ecx*4]        ; go new way
 402 
        jnz     .move_and_draw
- 
 
 403 
diff16 "done           : ",0,$
390 
	call	ch_putpixel
404 
.done:
391 
    shr     edx, 2
405 
	popad
392 
    dec     esi
 406 
	ret
393 
    jnz     .move_and_draw
407 
 
- 
 
 408 
; WARNING! The order matters! ------
394 
.done:
 409 
align 4
395 
	popad
 410 
diff16 "move000        : ",0,$
396 
	ret
 411 
.move000:
- 
 
 412 
	inc		eax
397 
 
 413 
	ret
398 
.move000:
 414 
align 4
399 
	inc		eax
 415 
.move001:
400 
	ret
 416 
	inc		eax
- 
 
 417 
	dec		ebx
401 
.move001:
 418 
	ret
402 
	inc		eax
 419 
align 4
403 
	dec		ebx
 420 
.move010:
- 
 
 421 
	dec		ebx
404 
	ret
 422 
	ret
405 
.move010:
 423 
align 4
406 
	dec		ebx
 424 
.move011:
407 
	ret
 425 
	dec		eax
- 
 
 426 
	dec		ebx
408 
.move011:
 427 
	ret
409 
	dec		eax
 428 
align 4
410 
	dec		ebx
 429 
.move100:
- 
 
 430 
	dec		eax
- 
 
 431 
	ret
- 
 
 432 
align 4
411 
	ret
 433 
.move101:
412 
.move100:
 434 
	dec		eax
413 
	dec		eax
 435 
	inc		ebx
414 
	ret
 436 
	ret
Line 415... Line 437...
415 
.move101:
 437 
align 4
416 
	dec		eax
 - 
 
417 
	inc		ebx
 - 
 
418 
	ret
 - 
 
Line 419... Line 438...
419 
.move110:
 438 
.move110:
- 
 
 439 
	inc		ebx
420 
	inc		ebx
 440 
	ret
421 
	ret
 441 
 
422 
.move111:
 442 
align 4
423 
	inc		eax
 443 
diff10 "move111-move000 (must be 28!)  : ",.move000,$
424 
	inc		ebx
 444 
.move111:
425 
	ret
 445 
	inc		eax
Line 426... Line 446...
426 
 
 446 
	inc		ebx
- 
 
 447 
	ret
427 
align 4
 448 
 
428 
.moves dd .move000, .move001, .move010, .move011, .move100, .move101, .move110, .move111
 449 
;) ---------------
429 
 
 450 
 
430 
;)
 451 
align 4
431 
 
 452 
diff16 "checkscreen    : ",0,$
432 
align 4
 453 
ch_checkscreen:
433 
ch_checkscreen:
 454 
     cmp	[Screen_Max_X], eax
434 
     cmp	[Screen_Max_X], eax
 455 
     jb 	.getout
435 
     jb		.getout
 456 
     cmp	[Screen_Max_Y], ebx
436 
     cmp	[Screen_Max_Y], ebx
 457 
.getout:
437 
.getout:
 458 
     ret
438 
     ret
 459 
 
439 
 
 460 
align 4
440 
align 4
 461 
diff16 "checkwin       : ",0,$
441 
ch_checkwin:
 462 
ch_checkwin:
442 
; eax = x coordinate
 463 
; eax = x coordinate
443 
; ebx = y coordinate
 464 
; ebx = y coordinate
444 
; ebp -> font info
 465 
; ebp -> font info
445 
;!destroys ch, edx!
466 
;!destroys ch, edx!
446 
        push    eax
 467 
	push	eax
447 
        push    ebx
 468 
	push	ebx
448 
        mov     ch,  byte[CURRENT_TASK]
 469 
	mov	ch,  byte[CURRENT_TASK]
449 
        mov     al,  byte [ebp]	            ; char X-width
 470 
	mov	al,  byte [ebp] 	    ; char X-width
450 
        mov     edx, [_display.width]       ; screen X-size
 471 
	mov	edx, [_display.width]	    ; screen X-size
451 
        imul    edx, ebx
 472 
	imul	edx, ebx
452 
        add     edx, [_WinMapAddress]
 473 
	add	edx, [_WinMapAddress]
453 
        add     edx, eax
 474 
	add	edx, eax
454 
        cmp     ch,  byte [edx]
 475 
	cmp	ch,  byte [edx]
455 
        jne     .fail
 476 
	jne	.fail
456 
        movzx   eax, byte [ebp]
 477 
	movzx	eax, byte [ebp]
457 
        cmp     ch,  byte [edx+eax]
 478 
	cmp	ch,  byte [edx+eax]
458 
        jne     .fail
 479 
	jne	.fail
Line 459... Line 480...
459 
        movzx   ebx, byte [ebp+1]
 480 
	movzx	ebx, byte [ebp+1]
- 
 
 481 
	imul	ebx, [_display.width]
460 
        imul    ebx, [_display.width]
 482 
	cmp	ch,  byte [edx+ebx]
461 
        cmp     ch,  byte [edx+ebx]
 483 
	jne	.fail
462 
        jne     .fail
 484 
	add	edx, eax
463 
        add     edx, eax
 485 
	cmp	ch,  byte [edx+ebx]
464 
        cmp     ch,  byte [edx+ebx]
 486 
	clc
465 
        clc
 487 
	je     .done
466 
        je     .done
 488 
.fail:
467 
.fail:
489 
	stc				    ; CF means the charbox is invisible
468 
        stc                                 ; CF means the charbox is invisible
 490 
.done: