0,0 → 1,2294 |
virtual at 0 |
editor_data: |
.hPlugin dd ? |
.hFile dd ? |
if (.hPlugin <> viewer_data.hPlugin) | (.hFile <> viewer_data.hFile) |
error in viewer_IsHandleUsed/editor_IsHandleUsed |
end if |
.memsize dd ? |
.encoding db ? |
.flags db ? ; & 0x80: modified |
; & 0x40: file is locked |
; & 0x20: next key as a symbol |
; & 0x10: replace mode (vs insert) |
.eol db ? |
rb 1 |
.first_block dd ? |
.last_block dd ? |
.numfree dd ? |
.freeblocks dd ? |
.numlines dd ? |
.curline dd ? |
.curcol dd ? |
;.curpos_block dd ? |
;.curpos_offs dd ? |
.cur_block dd ? |
.cur_offs dd ? |
.cur_delta dd ? |
.cursor_x dd ? |
.cursor_y dd ? |
align 200h |
.filename rb 1024 |
.hostname rb 1024 |
if (.filename <> viewer_data.filename) | (.hostname <> viewer_data.hostname) |
error in viewer_getname/editor_getname |
end if |
.buf rb 16384 ; all I/O operations use this buffer |
.basesize = $ |
.linedata_start: |
end virtual |
|
virtual at 0 |
editor_line: |
.block dd ? |
.offs dw ? |
;.length dd ? |
.plugdata: |
end virtual |
|
; when a file is loaded into the editor, this file is fragmented to blocks |
; each block has RESERVE_IN_BLOCK empty bytes to allow quick inserting |
; must be dword-aligned! |
edit.RESERVE_IN_BLOCK = 16 |
edit.eol_dos = 1 ; DOS/Win EOLn style (0D 0A) |
edit.eol_unix = 2 ; Unix EOLn style (0A) |
edit.eol_mac = 3 ; MacOS EOLn style (0D) |
|
virtual at 0 |
edit_block_header: |
.next dd ? |
.prev dd ? |
.limit dd ? |
.size = $ ; must be dword-aligned |
end virtual |
|
edit_file: |
mov eax, [ebp + panel1_files - panel1_data] |
mov ecx, [eax+ecx*4] |
test byte [ecx], 10h |
jz .file |
ret |
.file: |
; calculate required memory size |
cmp dword [ecx+36], 0 |
jnz .nomemory |
; block size = 4096 |
; block header: edit_block_header.size bytes |
; some plugin-specific data can follow |
; reserve RESERVE_IN_BLOCK free bytes in the end of block |
mov ebx, 4096 |
mov eax, [EditPlugInfo] |
add eax, edit_block_header.size |
mov [EditBlockStart], eax |
sub ebx, eax |
sub ebx, edit.RESERVE_IN_BLOCK |
mov [EditBlockSize], ebx |
; now ebx = size of file data in each block |
mov eax, [ecx+32] |
; if eax == 0, set eax = 1 |
sub eax, 1 |
adc eax, 1 |
xor edx, edx |
div ebx |
sub edx, 1 |
sbb eax, -1 |
add eax, [EditDataSize] |
; eax = number of blocks + memory for editor_data structure |
cmp eax, 0x80000000 shr 12 |
jb .memok |
.nomemory: |
push aEditNoMemory |
mov eax, esp |
push ContinueBtn |
push 1 |
push eax |
push 1 |
call SayErr |
pop eax |
ret |
.memok: |
lea esi, [ebp + panel1_dir - panel1_data] |
push eax |
push ecx |
mov ecx, eax |
shl ecx, 12 |
mov edx, editor_vtable |
call new_screen |
pop ecx |
pop ebx |
test eax, eax |
jnz @f |
ret |
@@: |
mov [ebp + editor_data.memsize], ebx |
mov al, [EditEOLStyle] |
mov [ebp + editor_data.eol], al |
mov eax, [esi + panel1_hPlugin - panel1_data] |
mov [ebp + editor_data.hPlugin], eax |
test eax, eax |
jz .nocopyhostname |
lea edi, [ebp + editor_data.hostname] |
push esi |
mov eax, dword [esi + panel1_parents - panel1_dir] |
mov esi, dword [esi + panel1_parents_sz - panel1_dir] |
add esi, eax |
@@: |
dec esi |
cmp byte [esi-1], 0 |
jz @f |
cmp byte [esi-1], '/' |
jnz @b |
@@: |
lodsb |
stosb |
test al, al |
jnz @b |
pop esi |
.nocopyhostname: |
mov eax, dword [esi + panel1_hFile - panel1_dir] |
mov [ebp + editor_data.hFile], eax |
mov [ebp + editor_data.encoding], encodings.cp866 |
xor eax, eax |
mov [ebp + editor_data.flags], al |
inc eax |
mov [ebp + editor_data.numlines], eax |
lea edi, [ebp + editor_data.filename] |
mov ebx, readinfo |
mov [ebx+21], edi |
@@: |
lodsb |
test al, al |
jz @f |
stosb |
jmp @b |
@@: |
lea esi, [ecx+40] |
mov al, '/' |
cmp byte [edi-1], al |
jz @f |
stosb |
@@: |
lodsb |
stosb |
test al, al |
jnz @b |
; load file into memory |
mov esi, [ebp + editor_data.memsize] |
mov edi, [EditDataSize] |
sub esi, edi ; esi = number of blocks |
shl edi, 12 |
;mov [ebp + editor_data.curpos_block], edi |
mov [ebp + editor_data.first_block], edi |
mov [ebp + editor_data.cur_block], edi |
add edi, ebp ; edi -> first block |
mov [ebp + editor_data.linedata_start + editor_line.block], edi |
xor eax, eax |
mov [ebx+4], eax |
mov [ebx+8], eax |
mov dword [ebx+12], 16384 |
lea eax, [ebp + editor_data.buf] |
mov [ebx+16], eax |
mov edx, [ebp + editor_data.hPlugin] |
test edx, edx |
jz @f |
pushad |
push O_READ |
push dword [ebx+21] |
push [ebp + editor_data.hFile] |
call [edx + PluginInfo.open] |
popad |
test eax, eax |
jz ..openerr_in_screen |
mov ebx, eax |
@@: |
.readloop: |
mov edx, [ebp + editor_data.hPlugin] |
test edx, edx |
jz .readnative |
pushad |
push 16384 |
push [readinfo.data] |
push ebx |
call [edx + PluginInfo.read] |
popad |
cmp eax, -1 |
jnz .readok |
; let us hope that plugin says error itself |
push ebp |
push ebx |
call [edx + PluginInfo.close] |
pop ebp |
jmp .readfailed |
.readnative: |
push ebx |
push 70 |
pop eax |
int 40h |
mov edx, ebx |
xchg eax, edx |
pop ebx |
add dword [ebx+4], eax |
adc dword [ebx+8], 0 |
test edx, edx |
jz .readok |
cmp edx, 6 |
jz .readok |
push dword [ebx+21] |
push aCannotReadFile |
xchg eax, edx |
call get_error_msg |
push eax |
mov eax, esp |
push RetryOrCancelBtn |
push 2 |
push eax |
push 3 |
call SayErr |
add esp, 3*4 |
test eax, eax |
jz .readnative |
.readfailed: |
jmp delete_active_screen |
.readok: |
; eax = number of bytes read |
test eax, eax |
jnz @f |
mov ecx, edi |
sub ecx, ebp |
cmp ecx, [ebp + editor_data.first_block] |
jnz .readdone |
@@: |
push eax ebx |
mov ebx, [ebx+16] |
.loadloop: |
mov ecx, [EditBlockSize] |
cmp eax, ecx |
ja @f |
mov ecx, eax |
@@: |
sub eax, ecx |
push eax |
dec esi |
jns .hasblock |
push ecx |
add [ebp + editor_data.memsize], 8 |
add esi, 8 |
mov ecx, [ebp + editor_data.memsize] |
cmp ecx, 80000000h shr 12 |
jb @f |
.nomemory2: |
pop ecx eax ebx eax |
call .nomemory |
jmp .readfailed |
@@: |
sub edi, ebp |
shl ecx, 12 |
mov edx, ebp |
call xpgrealloc |
test eax, eax |
jz .nomemory2 |
mov ebp, eax |
add edi, eax |
pop ecx |
.hasblock: |
lea eax, [edi + 0x1000] |
push eax |
sub eax, ebp |
stosd ; edit_block_header.next |
sub eax, 0x2000 |
stosd ; edit_block_header.prev |
mov eax, [EditBlockStart] |
add eax, ecx |
stosd ; edit_block_header.limit |
push ecx |
mov ecx, [EditPlugInfo] |
inc ecx |
jz @f |
dec ecx |
@@: |
xor eax, eax |
rep stosb ; info for plugins: zeroed |
pop ecx |
push esi edi ecx |
mov esi, ebx |
add ecx, 3 |
shr ecx, 2 |
rep movsd |
mov ebx, esi |
pop ecx edi |
; calculate number of lines in this block |
mov esi, edi |
xor edx, edx |
test ecx, ecx |
jz .4 |
.1: |
lodsb |
cmp al, 13 |
jz @f |
cmp al, 10 |
jz @f |
mov dl, 0 |
jmp .3 |
@@: |
cmp al, dl |
mov dl, 0 |
jz .3 |
inc [ebp + editor_data.numlines] |
cmp al, 10 |
jz .3 |
mov dl, 10 |
.3: |
loop .1 |
.4: |
pop esi |
pop edi |
pop eax |
test eax, eax |
jnz .loadloop |
pop ebx eax |
cmp eax, 16384 |
jz .readloop |
.readdone: |
xor eax, eax |
mov ecx, edi |
sub ecx, ebp |
mov edx, ecx |
shr ecx, 12 |
sub ecx, [ebp + editor_data.memsize] |
neg ecx |
mov [ebp + editor_data.numfree], ecx |
jz .nofree |
mov [ebp + editor_data.freeblocks], edx |
push edi |
.addfree: |
add edx, 1000h |
mov [edi], edx |
add edi, 1000h |
loop .addfree |
mov [edi-1000h], eax |
pop edi |
.nofree: |
sub edi, 1000h |
mov [edi + edit_block_header.next], eax |
sub edi, ebp |
mov [ebp + editor_data.last_block], edi |
mov ecx, [EditDataSize] |
shl ecx, 12 |
mov [ecx + ebp + edit_block_header.prev], eax |
mov [ebp + editor_data.curline], eax |
mov [ebp + editor_data.curcol], eax |
mov [ebp + editor_data.cursor_x], eax |
inc eax |
mov [ebp + editor_data.cursor_y], eax |
mov eax, [EditBlockStart] |
;mov [ebp + editor_data.curpos_offs], eax |
mov [ebp + editor_data.linedata_start + editor_line.offs], ax |
mov [ebp + editor_data.cur_offs], eax |
mov ecx, [ebp + editor_data.first_block] |
cmp [ecx + edit_block_header.limit], eax |
setz cl |
movzx ecx, cl |
dec ecx |
mov [ebp + editor_data.cur_delta], ecx |
call editor_init_lines |
editor_OnRedraw: |
mov eax, [ebp + editor_data.cursor_x] |
mov [cursor_x], eax |
mov eax, [ebp + editor_data.cursor_y] |
mov [cursor_y], eax |
test [ebp + editor_data.flags], 10h |
jz @f |
mov [cursor_size], cursor_big_size |
@@: |
call editor_test_cursor_x |
call editor_test_cursor_y |
call editor_set_keybar |
call editor_draw_text |
ret |
|
editor_save: |
cmp [ebp + editor_data.hPlugin], 0 |
jz .native |
push aCannotSaveToPlugin |
mov eax, esp |
push ContinueBtn |
push 1 |
push eax |
push 1 |
call SayErr |
pop eax |
ret |
.native: |
call editor_calc_filesize |
mov ebx, writeinfo |
mov [ebx+4], eax |
xor eax, eax |
mov [ebx+8], eax |
mov [ebx+12], eax |
mov [ebx+16], eax |
lea eax, [ebp + editor_data.filename] |
mov [ebx+21], eax |
.setsize_retry: |
mov byte [ebx], 4 |
push 70 |
pop eax |
push ebx |
int 0x40 |
pop ebx |
mov byte [ebx], 3 |
test eax, eax |
jz .sizeok |
push dword [ebx+21] |
push aCannotWriteFile |
call get_error_msg |
push eax |
mov eax, esp |
push RetryOrCancelBtn |
push 2 |
push eax |
push 3 |
call SayErr |
add esp, 12 |
test eax, eax |
jz .setsize_retry |
.ret: |
ret |
.sizeok: |
and dword [ebx+4], 0 |
mov esi, [ebp + editor_data.first_block] |
add esi, ebp |
mov ebx, [EditBlockStart] |
call editor_normalize_offs |
jnc .writeok |
lea edi, [ebp + editor_data.buf] |
.loop: |
mov ecx, 16384 |
call editor_get_data |
test eax, eax |
jz .done |
push ebx |
mov ebx, writeinfo |
mov [ebx+12], eax |
mov [ebx+16], edi |
.write_retry: |
push 70 |
pop eax |
push ebx |
int 0x40 |
pop ebx |
test eax, eax |
jz .writeok |
push dword [ebx+21] |
push aCannotWriteFile |
call get_error_msg |
push eax |
mov eax, esp |
push RetryOrCancelBtn |
push 2 |
push eax |
push 3 |
call SayErr |
add esp, 12 |
test eax, eax |
jz .write_retry |
ret |
.writeok: |
mov eax, [ebx+12] |
add [ebx+4], eax |
adc dword [ebx+8], 0 |
pop ebx |
jmp .loop |
.done: |
and [ebp + editor_data.flags], not 0x80 |
ret |
|
editor_calc_filesize: |
xor eax, eax |
push esi |
mov esi, [ebp + editor_data.first_block] |
@@: |
add esi, ebp |
add eax, [esi + edit_block_header.limit] |
sub eax, [EditBlockStart] |
mov esi, [esi + edit_block_header.next] |
test esi, esi |
jnz @b |
pop ebx |
ret |
|
editor_get_data: |
push edi |
test esi, esi |
jz .ret |
.loop: |
mov edx, [esi + edit_block_header.limit] |
sub edx, ebx |
push ecx |
cmp ecx, edx |
jb @f |
mov ecx, edx |
@@: |
push esi |
add esi, ebx |
add ebx, ecx |
add eax, ecx |
rep movsb |
pop esi |
pop ecx |
sub ecx, edx |
jb .ret |
mov esi, [esi + edit_block_header.next] |
mov ebx, [EditBlockStart] |
test esi, esi |
jz .ret |
add esi, ebp |
jmp .loop |
.ret: |
mov eax, edi |
pop edi |
sub eax, edi |
ret |
|
editor_get_pos: |
;mov esi, [ebp + editor_data.curpos_block] |
;mov ebx, [ebp + editor_data.curpos_offs] |
mov esi, [ebp + editor_data.linedata_start + editor_line.block] |
sub esi, ebp |
movzx ebx, [ebp + editor_data.linedata_start + editor_line.offs] |
@@: |
test esi, esi |
jz @f |
add esi, ebp |
cmp ebx, [esi + edit_block_header.limit] |
jb @f |
mov esi, [esi + edit_block_header.next] |
mov ebx, [EditBlockStart] |
jmp @b |
@@: |
ret |
|
editor_curline_start: |
mov edx, [EditPlugInfo] |
add edx, editor_line.plugdata |
mov eax, [ebp + editor_data.cursor_y] |
dec eax |
imul eax, edx |
lea edi, [ebp + eax + editor_data.linedata_start] |
mov esi, [edi + editor_line.block] |
movzx ebx, [edi + editor_line.offs] |
ret |
|
editor_step_forward: |
; in: esi = block (must be nonzero), ebx = offset in block |
; out: esi = block (zero iff EOF reached), ebx = offset in block |
; out: CF=1 iff EOF NOT reached |
inc ebx |
editor_normalize_offs: |
cmp ebx, [esi + edit_block_header.limit] |
jb @f |
mov esi, [esi + edit_block_header.next] |
mov ebx, [EditBlockStart] |
test esi, esi |
jz @f |
add esi, ebp |
stc |
@@: |
ret |
|
editor_step_backward: |
; in: esi = block (must be nonzero), ebx = offset in block |
; out: esi = block (zero iff input was at the beginning), ebx = offset in block |
; out: CF=1 iff start of file reached |
dec ebx |
cmp ebx, [EditBlockStart] |
jae @f |
mov esi, [esi + edit_block_header.prev] |
test esi, esi |
stc |
jz @f |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
dec ebx |
@@: |
ret |
|
editor_get_string: |
; read string up to the end of line |
; in: esi = block, ebx = offset in block |
; in: edi = destination, ecx = maximum number of bytes to copy, edx = number of bytes to skip |
; out: esi = block, ebx = offset in block |
; out: ecx = number of rest bytes (ecx_in - ecx_out = number of copied characters) |
mov ah, [edit_normal_color] |
cmp ebx, [esi + edit_block_header.limit] |
jz .retnp |
push 0 ; current position in line |
.loop: |
test ecx, ecx |
jz .ret |
mov al, [esi + ebx] |
cmp al, 13 |
jz .ret |
cmp al, 10 |
jz .ret |
cmp al, 9 |
jz .tab |
inc dword [esp] |
dec edx |
jns .4 |
xor edx, edx |
stosw |
dec ecx |
.4: |
call editor_step_forward |
jc .loop |
.ret: |
pop edx |
.retnp: |
ret |
.tab: |
push eax edx |
mov eax, [esp+8] |
xor edx, edx |
div [editor_tabsize] |
sub edx, [editor_tabsize] |
neg edx |
add [esp+8], edx |
sub [esp], edx |
pop edx eax |
jns .4 |
mov al, ' ' |
@@: |
stosw |
dec ecx |
jz .ret |
inc edx |
jnz @b |
jmp .4 |
|
editor_find_newline: |
; in: esi = block, ebx = offset in block |
; out: esi = block, ebx = offset in block, ecx = line length |
xor ecx, ecx |
test esi, esi |
jz .ret0 |
cmp ebx, [esi + edit_block_header.limit] |
jb .1 |
xor esi, esi |
.ret0: |
ret |
.1: |
mov al, [esi + ebx] |
inc ecx |
call editor_step_forward |
cmp al, 13 |
jz .2 |
cmp al, 10 |
jz .2 |
test esi, esi |
jnz .1 |
.ret1: |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
ret |
.2: |
dec ecx |
test esi, esi |
jz .ret1 |
cmp al, 13 |
jnz .ret |
cmp byte [esi + ebx], 10 |
jnz .ret |
call editor_step_forward |
jnc .ret1 |
.ret: |
ret |
|
editor_prev_newline: |
xor ecx, ecx |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
@@: |
call editor_step_backward |
jc .ret |
mov al, [esi + ebx] |
call editor_step_backward |
jc .ret |
cmp al, 10 |
jnz .1 |
cmp byte [esi + ebx], 13 |
jnz .1 |
@@: |
call editor_step_backward |
jc .ret |
.1: |
inc ecx |
mov al, [esi + ebx] |
cmp al, 13 |
jz @f |
cmp al, 10 |
jnz @b |
@@: |
dec ecx |
inc ebx |
cmp ebx, [esi + edit_block_header.limit] |
jb .ret |
mov esi, [esi + edit_block_header.next] |
mov ebx, [EditBlockStart] |
test esi, esi |
jz .ret |
add esi, ebp |
.ret: |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.first_block] |
mov ebx, [EditBlockStart] |
add esi, ebp |
@@: |
ret |
|
editor_init_lines: |
call editor_get_pos |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
@@: |
mov ecx, max_height |
lea edi, [ebp + editor_data.linedata_start] |
.1: |
mov eax, esi |
stosd ; editor_line.block |
mov eax, ebx |
stosw ; editor_line.offs |
push ecx |
call editor_find_newline |
;mov eax, ecx |
;stosd ; editor_line.length |
xor eax, eax |
mov ecx, [EditPlugInfo] |
rep stosb |
pop ecx |
loop .1 |
ret |
|
editor_draw_status: |
lea edi, [ebp + editor_data.buf] |
mov ah, [edit_status_color] |
mov ecx, [cur_width] |
sub ecx, 56 |
cmp ecx, 25 |
jge @f |
push 25 |
pop ecx |
@@: |
call viewedit_draw_filename |
inc ecx |
rep stosw |
test [ebp + editor_data.flags], 80h |
jz @f |
mov al, '*' |
@@: |
stosw |
mov al, ' ' |
test [ebp + editor_data.flags], 40h |
jz @f |
mov al, '-' |
@@: |
stosw |
mov al, ' ' |
test [ebp + editor_data.flags], 20h |
jz @f |
mov al, '"' |
@@: |
stosw |
mov al, ' ' |
mov cl, 10 |
rep stosw |
movzx esi, [ebp+editor_data.encoding] |
lea esi, [encodings.names+esi*8] |
push edi esi |
dec edi |
dec edi |
std |
add esi, 8 |
@@: |
dec esi |
cmp byte [esi], ' ' |
jz @b |
@@: |
lodsb |
stosw |
cmp esi, [esp] |
jae @b |
cld |
pop esi edi |
mov esi, aLine |
mov cl, 8 |
@@: |
lodsb |
stosw |
loop @b |
mov cl, 13 |
mov al, ' ' |
rep stosw |
std |
push edi |
dec edi |
dec edi |
push eax |
mov eax, [ebp + editor_data.numlines] |
mov cl, 10 |
@@: |
xor edx, edx |
div ecx |
xchg eax, edx |
add al, '0' |
mov ah, [edit_status_color] |
stosw |
xchg eax, edx |
test eax, eax |
jnz @b |
mov al, '/' |
mov ah, [edit_status_color] |
stosw |
mov eax, [ebp + editor_data.curline] |
add eax, [ebp + editor_data.cursor_y] |
@@: |
xor edx, edx |
div ecx |
xchg eax, edx |
add al, '0' |
mov ah, [edit_status_color] |
stosw |
xchg eax, edx |
test eax, eax |
jnz @b |
pop eax |
stosw |
cld |
pop edi |
mov ah, [edit_status_color] |
mov esi, aCol |
mov cl, 7 |
@@: |
lodsb |
stosw |
loop @b |
mov eax, [ebp + editor_data.curcol] |
add eax, [ebp + editor_data.cursor_x] |
inc eax |
mov cl, 10 |
push -'0' |
@@: |
xor edx, edx |
div ecx |
push edx |
test eax, eax |
jnz @b |
@@: |
pop eax |
mov ah, [edit_status_color] |
add al, '0' |
jz @f |
stosw |
jmp @b |
@@: |
mov al, ' ' |
mov cl, 13 |
rep stosw |
xor eax, eax |
xor edx, edx |
call get_console_ptr |
lea esi, [ebp + editor_data.buf] |
mov ecx, [cur_width] |
shr ecx, 1 |
rep movsd |
adc ecx, ecx |
rep movsw |
cmp [ebp + editor_data.cur_delta], -1 |
jnz .a |
mov al, ' ' |
mov byte [edi-4*2], al |
mov byte [edi-3*2], al |
mov byte [edi-2*2], al |
mov byte [edi-1*2], al |
mov eax, [ebp + editor_data.cur_block] |
add eax, ebp |
add eax, [ebp + editor_data.cur_offs] |
movzx eax, byte [eax] |
mov cl, 100 |
;xor edx, edx ; edx=0 already |
div ecx |
test al, al |
jz @f |
add al, '0' |
mov [edi-3*2], al |
@@: |
xchg eax, edx |
aam |
test ah, ah |
jnz .b |
cmp byte [edi-3*2], ' ' |
jz @f |
.b: |
add ah, '0' |
mov [edi-2*2], ah |
@@: |
add al, '0' |
mov [edi-1*2], al |
.a: |
ret |
|
editor_draw_line: |
push ecx |
mov ecx, [cur_width] |
test esi, esi |
jz .2 |
lea edi, [ebp + editor_data.buf] |
push edx edi |
mov edx, [ebp + editor_data.curcol] |
call editor_get_string |
mov al, ' ' |
rep stosw |
pop esi edx |
xor eax, eax |
call get_console_ptr |
mov ecx, [cur_width] |
shr ecx, 1 |
rep movsd |
adc ecx, ecx |
rep movsw |
pop ecx |
ret |
.2: |
xor eax, eax |
call get_console_ptr |
mov al, ' ' |
mov ah, [edit_normal_color] |
rep stosw |
pop ecx |
ret |
|
editor_draw_text: |
call editor_draw_status |
push 1 |
pop edx |
lea ecx, [ebp + editor_data.linedata_start] |
.1: |
mov esi, [ecx + editor_line.block] |
movzx ebx, [ecx + editor_line.offs] |
add ecx, editor_line.plugdata |
add ecx, [EditPlugInfo] |
call editor_draw_line |
inc edx |
mov eax, [cur_height] |
dec eax |
cmp edx, eax |
jb .1 |
jmp draw_image |
|
editor_set_keybar: |
mov eax, keybar_editor |
movzx esi, [ebp+editor_data.encoding] |
dec esi |
jz @f |
push 1 |
pop esi |
@@: |
lea esi, [encodings.names+esi*8] |
lea edi, [eax+keybar_cp2-keybar_editor] |
movsd |
movsw |
jmp draw_keybar |
|
editor_up_scroll: |
push ecx |
sub [ebp + editor_data.curline], ecx |
mov edx, [EditPlugInfo] |
add edx, editor_line.plugdata |
imul eax, edx, max_height |
imul ecx, edx |
sub ecx, eax |
neg ecx |
lea esi, [ebp + ecx + editor_data.linedata_start - 4] |
lea edi, [ebp + eax + editor_data.linedata_start - 4] |
shr ecx, 2 |
std |
rep movsd |
cld |
jnc @f |
mov cx, [esi+2] |
mov [edi+2], cx |
sub edi, 2 |
@@: |
pop ecx |
add edi, 4 |
movzx ebx, [edi + editor_line.offs] |
mov esi, [edi + editor_line.block] |
@@: |
push ecx |
call editor_prev_newline |
sub edi, edx |
push edi |
mov eax, esi |
stosd ; editor_line.offs |
mov eax, ebx |
stosw ; editor_line.block |
;mov eax, ecx |
;stosd ; editor_line.length |
mov ecx, [EditPlugInfo] |
xor eax, eax |
rep stosb |
pop edi |
pop ecx |
loop @b |
; fall through to editor_update_cur |
|
editor_update_cur: |
mov ecx, [ebp + editor_data.cursor_x] |
add ecx, [ebp + editor_data.curcol] |
call editor_curline_start |
xor edx, edx ; current position in the line |
cmp ebx, [esi + edit_block_header.limit] |
jz .notfound |
.scan: |
mov al, [esi+ebx] |
cmp al, 13 |
jz .notfound |
cmp al, 10 |
jz .notfound |
test ecx, ecx |
jz .found |
cmp al, 9 |
jz .tab |
inc edx |
dec ecx |
call editor_step_forward |
jc .scan |
.notfound: |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
@@: |
mov [ebp + editor_data.cur_delta], ecx |
xor eax, eax |
jmp .reta |
.found: |
xor eax, eax |
.founda: |
or [ebp + editor_data.cur_delta], -1 |
.reta: |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
ret |
.tab: |
push edx |
mov eax, edx |
xor edx, edx |
div [editor_tabsize] |
sub edx, [editor_tabsize] |
neg edx |
add [esp], edx |
cmp ecx, edx |
jb .curintab |
sub ecx, edx |
pop edx |
call editor_step_forward |
jnc .notfound |
test ecx, ecx |
jz .found |
jmp .scan |
.curintab: |
sub [esp], edx |
pop edx |
cmp edx, [ebp + editor_data.curcol] |
setc al |
jae @f |
mov [ebp + editor_data.curcol], edx |
@@: |
sub edx, [ebp + editor_data.curcol] |
mov [ebp + editor_data.cursor_x], edx |
mov [cursor_x], edx |
jmp .founda |
|
editor_down_scroll: |
push ecx |
lea edi, [ebp + editor_data.linedata_start] |
mov edx, [EditPlugInfo] |
add edx, editor_line.plugdata |
imul ecx, edx |
lea esi, [edi + ecx] |
imul eax, edx, max_height |
sub eax, ecx |
mov ecx, eax |
shr ecx, 2 |
rep movsd |
adc ecx, ecx |
rep movsw |
@@: |
mov esi, edi |
sub esi, edx |
movzx ebx, [esi + editor_line.offs] |
mov esi, [esi + editor_line.block] |
pop ecx |
jecxz .ret |
@@: |
push ecx |
call editor_find_newline |
mov eax, esi |
stosd ; editor_line.block |
mov eax, ebx |
stosw ; editor_line.offs |
;mov eax, ecx |
;stosd ; editor_line.length |
mov ecx, [EditPlugInfo] |
xor eax, eax |
rep stosb |
pop ecx |
loop @b |
.ret: |
ret |
|
editor_end_scroll: |
call editor_curline_start |
; calculate visible length of the line (it differs from the real length if tabulations are present) |
xor ecx, ecx |
cmp ebx, [esi + edit_block_header.limit] |
jz .calcdone |
.calcloop: |
mov al, [esi+ebx] |
cmp al, 10 |
jz .calcdone |
cmp al, 13 |
jz .calcdone |
cmp al, 9 |
jz .calctab |
inc ecx |
.calcnext: |
call editor_step_forward |
jc .calcloop |
jmp .calcdone |
.calctab: |
mov eax, ecx |
xor edx, edx |
div [editor_tabsize] |
sub edx, [editor_tabsize] |
sub ecx, edx |
jmp .calcnext |
.calcdone: |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
@@: |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
and [ebp + editor_data.cur_delta], 0 |
; ecx = number of symbols in the line |
; calculate new position of view range |
mov eax, [ebp + editor_data.curcol] |
cmp ecx, eax |
jb .toleft |
add eax, [cur_width] |
cmp ecx, eax |
jae .toright |
sub ecx, [ebp + editor_data.curcol] |
mov [ebp + editor_data.cursor_x], ecx |
mov [cursor_x], ecx |
ret |
.toleft: |
mov [ebp + editor_data.curcol], ecx |
and [ebp + editor_data.cursor_x], 0 |
and [cursor_x], 0 |
stc |
ret |
.toright: |
mov eax, [cur_width] |
dec eax |
sub ecx, eax |
mov [ebp + editor_data.curcol], ecx |
mov [ebp + editor_data.cursor_x], eax |
mov [cursor_x], eax |
stc |
ret |
|
editor_move_linestart: |
; in: esi = block, ebx = start offset, ecx = delta |
lea edi, [ebp + editor_data.linedata_start] |
mov edx, max_height |
.0: |
cmp [edi + editor_line.block], esi |
jnz .1 |
movzx eax, [edi + editor_line.offs] |
cmp eax, ebx |
ja .2 |
; push eax |
; add eax, [edi + editor_line.length] |
; cmp eax, ebx |
; jb @f |
; add [edi + editor_line.length], ecx |
;@@: |
; pop eax |
cmp eax, [esi + edit_block_header.limit] |
jb .1 |
push esi ebx |
mov ebx, eax |
jmp .3 |
.2: |
push esi ebx |
mov ebx, eax |
add ebx, ecx |
.3: |
cmp ebx, [esi + edit_block_header.limit] |
jb .4 |
cmp [esi + edit_block_header.next], 0 |
jz .4 |
sub ebx, [esi + edit_block_header.limit] |
mov esi, [esi + edit_block_header.next] |
add esi, ebp |
add ebx, [EditBlockStart] |
jmp .3 |
.4: |
mov [edi + editor_line.block], esi |
mov [edi + editor_line.offs], bx |
pop ebx esi |
.1: |
add edi, editor_line.plugdata |
add edi, [EditPlugInfo] |
dec edx |
jnz .0 |
;lea edx, [ebp + editor_data.curpos_block] |
;call .5 |
;add edx, editor_data.cur_block - editor_data.curpos_block |
lea edx, [ebp + editor_data.cur_block] |
; call .5 |
; ret |
.5: |
mov eax, [edx] |
add eax, ebp |
cmp eax, esi |
jnz .6 |
cmp [edx+4], ebx |
jbe @f |
add [edx+4], ecx |
@@: |
mov eax, [edx+4] |
sub eax, [esi + edit_block_header.limit] |
jb .6 |
push ecx |
mov ecx, [esi + edit_block_header.next] |
add ecx, ebp |
add eax, [EditBlockStart] |
mov [edx], ecx |
mov [edx+4], eax |
pop ecx |
.6: |
ret |
|
editor_reserve_symbol: |
push 1 |
pop ecx |
|
editor_reserve_space: |
; áâ ¢«ï¥â ¯ãá⮥ ¬¥áâ® ¢ãâàì 楯®çª¨ ¡«®ª®¢ |
; in: ecx = number of symbols to add, esi = block, ebx = offset |
mov eax, [esi + edit_block_header.limit] |
add eax, ecx |
cmp eax, 4096 |
ja .add |
mov [esi + edit_block_header.limit], eax |
push esi ecx |
sub eax, ecx |
lea esi, [esi + eax - 1] |
lea edi, [esi + ecx] |
sub eax, ebx |
mov ecx, eax |
std |
rep movsb |
cld |
pop ecx esi |
call editor_move_linestart |
clc |
ret |
.add: |
push ecx |
mov eax, [esi + edit_block_header.limit] |
sub eax, [EditBlockStart] |
add eax, ecx |
push eax |
xor edx, edx |
div [EditBlockSize] |
push eax |
sub eax, [ebp + editor_data.numfree] |
jbe .norealloc |
mov edx, [ebp + editor_data.memsize] |
push eax edx |
add eax, edx |
mov ecx, eax |
shl ecx, 12 |
mov edx, ebp |
call xpgrealloc |
pop edx ecx |
test eax, eax |
jz .nomem |
add [ebp + editor_data.memsize], ecx |
sub eax, ebp |
add ebp, eax |
add esi, eax |
push ecx |
mov ecx, max_height |
lea edi, [ebp + editor_data.linedata_start] |
@@: |
add [edi + editor_line.block], eax |
add edi, editor_line.plugdata |
add edi, [EditPlugInfo] |
loop @b |
pop ecx |
shl edx, 12 |
add [ebp + editor_data.numfree], ecx |
lea edi, [edx + ebp] |
mov eax, [ebp + editor_data.freeblocks] |
mov [ebp + editor_data.freeblocks], edx |
@@: |
add edx, 1000h |
mov [edi], edx |
add edi, 1000h |
loop @b |
mov [edi-1000h], eax |
.norealloc: |
pop edx |
push [esi + edit_block_header.next] |
push esi |
sub [ebp + editor_data.numfree], edx |
mov edi, [ebp + editor_data.freeblocks] |
@@: |
mov [esi + edit_block_header.next], edi |
add edi, ebp |
push edi |
push dword [edi] |
stosd ; edit_block_header.next - will be filled later |
mov eax, esi |
sub eax, ebp |
stosd ; edit_block_header.prev |
mov eax, 4096 - edit.RESERVE_IN_BLOCK |
stosd ; edit_block_header.limit |
mov eax, [EditBlockSize] |
sub [esp+16], eax |
xor eax, eax |
mov ecx, [EditPlugInfo] |
rep stosb |
pop edi |
pop esi |
dec edx |
jnz @b |
mov [ebp + editor_data.freeblocks], edi |
mov edi, esi |
pop esi |
pop [edi + edit_block_header.next] |
pop ecx |
add ecx, [EditBlockSize] |
mov edx, ecx |
shr edx, 1;2 |
mov eax, ecx |
sub eax, edx |
cmp eax, [EditBlockSize] |
jb @f |
mov eax, [EditBlockSize] |
mov edx, ecx |
sub edx, eax |
@@: |
add eax, [EditBlockStart] |
add edx, [EditBlockStart] |
mov ecx, [esi + edit_block_header.limit] |
mov [esi + edit_block_header.limit], eax |
mov [edi + edit_block_header.limit], edx |
sub ecx, ebx |
push ecx |
push esi edi ecx |
add esi, ecx |
add esi, ebx |
push edx |
sub edx, [EditBlockStart] |
cmp ecx, edx |
jb @f |
mov ecx, edx |
@@: |
pop edx |
sub [esp], ecx |
add edi, edx |
sub esi, ecx |
sub edi, ecx |
rep movsb |
pop ecx edi esi |
push esi edi |
lea edi, [esi + eax - 1] |
add esi, ebx |
lea esi, [esi + ecx - 1] |
std |
rep movsb |
cld |
pop edi esi |
pop ecx |
mov ecx, ebx |
sub ecx, eax |
jb @f |
push esi edi |
add esi, eax |
add edi, [EditBlockStart] |
rep movsb |
pop edi esi |
@@: |
push esi edi |
sub esi, ebp |
sub edi, ebp |
cmp [ebp + editor_data.last_block], esi |
jnz @f |
mov [ebp + editor_data.last_block], edi |
@@: |
pop edi esi |
pop ecx |
call editor_move_linestart |
cmp ebx, [esi + edit_block_header.limit] |
jb @f |
sub ebx, [esi + edit_block_header.limit] |
mov esi, [esi + edit_block_header.next] |
add esi, ebp |
add ebx, [EditBlockStart] |
@@: |
clc |
ret |
.nomem: |
pop eax |
pop ecx |
pop ecx |
add esi, ebp |
stc |
ret |
|
editor_delete_symbol: |
push 1 |
pop ecx |
|
editor_delete_space: |
; ¤ «ï¥â ecx ¡ ©â ¨§ ⥪áâ , ç¨ ï á esi:ebx |
; ecx, esi, ebx à §àãè îâáï |
mov eax, [esi + edit_block_header.limit] |
sub eax, ebx |
cmp eax, ecx |
jb .more1 |
push esi |
sub [esi + edit_block_header.limit], ecx |
sub eax, ecx |
lea edi, [esi+ebx] |
lea esi, [edi+ecx] |
mov ecx, eax |
rep movsb |
pop esi |
.done: |
call .collapse_prev |
call .collapse_next |
call editor_init_lines |
jmp editor_update_cur |
.more1: |
mov [esi + edit_block_header.limit], ebx |
sub ecx, eax |
@@: |
mov esi, [esi + edit_block_header.next] |
add esi, ebp |
mov eax, [esi + edit_block_header.limit] |
sub eax, [EditBlockStart] |
sub ecx, eax |
jb @f |
call .delete_block |
jmp @b |
@@: |
add ecx, eax |
push esi |
mov eax, [esi + edit_block_header.limit] |
sub [esi + edit_block_header.limit], ecx |
add eax, esi |
add esi, [EditBlockStart] |
mov edi, esi |
add esi, ecx |
sub eax, esi |
mov ecx, esi |
rep movsb |
pop esi |
call .collapse_next |
mov esi, [esi + edit_block_header.prev] |
add esi, ebp |
jmp .done |
|
.delete_block: |
mov eax, [esi + edit_block_header.next] |
mov edx, [esi + edit_block_header.prev] |
test eax, eax |
jz .dbfirst |
mov [eax + ebp + edit_block_header.prev], edx |
jmp @f |
.dbfirst: |
mov [ebp + editor_data.first_block], edx |
@@: |
test edx, edx |
jz .dblast |
mov [edx + ebp + edit_block_header.next], eax |
jmp @f |
.dblast: |
mov [ebp + editor_data.last_block], eax |
@@: |
mov eax, [ebp + editor_data.freeblocks] |
mov [esi], eax |
sub esi, ebp |
mov [ebp + editor_data.freeblocks], esi |
inc [ebp + editor_data.numfree] |
ret |
|
.collapse_prev: |
mov eax, [esi + edit_block_header.prev] |
test eax, eax |
jz .cpno |
add eax, ebp |
mov edx, [esi + edit_block_header.limit] |
sub edx, [EditBlockStart] |
add edx, [eax + edit_block_header.limit] |
cmp edx, 4096 - edit.RESERVE_IN_BLOCK |
ja .cpno |
mov edi, eax |
.collapse: ; (edi) + (esi) -> (edi) |
push edi |
push esi |
mov ecx, [esi + edit_block_header.limit] |
sub ecx, [EditBlockStart] |
add esi, [EditBlockStart] |
mov eax, [edi + edit_block_header.limit] |
add [edi + edit_block_header.limit], ecx |
add edi, eax |
rep movsb |
pop esi |
call .delete_block |
pop esi |
.cpno: |
ret |
.collapse_next: |
mov eax, [esi + edit_block_header.next] |
test eax, eax |
jz .cpno |
add eax, ebp |
mov edx, [esi + edit_block_header.limit] |
sub edx, [EditBlockStart] |
add edx, [eax + edit_block_header.limit] |
cmp edx, 4096 - edit.RESERVE_IN_BLOCK |
ja .cpno |
mov edi, esi |
mov esi, eax |
jmp .collapse |
|
editor_OnKey: |
test al, 80h |
jnz .ret |
test [ebp + editor_data.flags], 20h |
jnz .symbol |
mov esi, editor_ctrlkeys |
call process_ctrl_keys |
jnc .ret |
.symbol: |
and [ebp + editor_data.flags], not 20h |
test [ebp + editor_data.flags], 40h |
jnz .ret |
or [ebp + editor_data.flags], 80h |
movzx eax, al |
call get_ascii_char |
mov esi, [ebp + editor_data.cur_block] |
add esi, ebp |
mov ebx, [ebp + editor_data.cur_offs] |
cmp al, 10 |
jz .insert_newline |
cmp al, 13 |
jz .insert_newline |
cmp [ebp + editor_data.cur_delta], -1 |
jnz .insert_after_eol |
test [ebp + editor_data.flags], 10h |
jnz .replace_symbol |
push eax |
call editor_reserve_symbol |
pop eax |
jc .ret |
.replace_symbol: |
cmp ebx, [esi + edit_block_header.limit] |
jnz @f |
mov esi, [esi + edit_block_header.next] |
add esi, ebp |
mov ebx, [EditBlockStart] |
@@: |
mov [esi + ebx], al |
.symb_inserted: |
call .redraw_curline |
jmp .right |
.redraw_curline: |
call editor_curline_start |
mov edx, [cursor_y] |
call editor_draw_line |
.ret: |
ret |
.insert_after_eol: |
mov ecx, [ebp + editor_data.cur_delta] |
inc ecx |
push eax |
call editor_reserve_space |
pop eax |
jc .ret |
push eax |
mov edx, ecx |
.2: |
mov ecx, [esi + edit_block_header.limit] |
sub ecx, ebx |
lea edi, [esi + ebx] |
cmp ecx, edx |
jb @f |
mov ecx, edx |
@@: |
add ebx, ecx |
sub edx, ecx |
mov al, ' ' |
rep stosb |
jz @f |
mov esi, [esi + edit_block_header.next] |
add esi, ebp |
mov ebx, [EditBlockStart] |
jmp .2 |
@@: |
pop eax |
mov [edi-1], al |
dec ebx |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
or [ebp + editor_data.cur_delta], -1 |
jmp .symb_inserted |
.insert_newline: |
push 1 |
pop ecx |
cmp [ebp + editor_data.eol], 2 |
adc ecx, 0 |
call editor_reserve_space |
jc .ret |
; à®áâ® â ª ¢áâ ¢«ïâì ᨬ¢®« ®¢®© áâப¨ çॢ â® - ¨§-§ áãé¥á⢮¢ ¨ï ¤¢ãå¡ ©â®¢ëå ª®¬¡¨ 権 ¯¥à¥¢®¤ áâப¨ |
; áâ àë© á¨¬¢®« ¬®¦¥â ᫨âìáï á ®¢ë¬. â ª®¬ á«ãç ¥ ¯à¨¤ñâáï § ¨¬ âìáï ª®à४â¨à®¢ª®©. |
; ஡«¥¬ ¡ë¢ ¥â ¢ ¤¢ãå á«ãç ïå: |
; ¥á«¨ । ªâ®à áâ஥ Unix-áâ¨«ì ¨ ®¢ë© ¯¥à¥¢®¤ áâப¨ ¢áâ ¢«ï¥âáï ¥¯®á।á⢥® ¯®á«¥ |
; ¯¥à¥¢®¤ áâப¨ ¢ Mac-á⨫¥; |
; ¥á«¨ । ªâ®à áâ஥ Mac-áâ¨«ì ¨ ®¢ë© ¯¥à¥¢®¤ áâப¨ ¢áâ ¢«ï¥âáï ¥¯®á।á⢥® ¯¥à¥¤ |
; ¯¥à¥¢®¤®¬ áâப¨ ¢ Unix-á⨫¥. |
; íâ¨å á«ãç ïå ä®àá¨à㥬 ¯¥à¥¢®¤ áâப¨ ¢ ⥪ã饬 á⨫¥ ä ©« . |
mov al, [ebp + editor_data.eol] |
cmp al, edit.eol_dos |
jz .insert_eol_dos |
cmp al, edit.eol_mac |
jz .insert_eol_mac |
mov al, 10 ; Unix-style for end-of-line |
push esi ebx |
call editor_step_backward |
jc @f |
cmp byte [esi+ebx], 13 |
jnz @f |
mov al, 13 ; force Mac-style to avoid collapse |
@@: |
pop ebx esi |
mov [esi+ebx], al |
jmp .eol_correct |
.insert_eol_mac: |
mov al, 13 ; Mac-style for end-of-line |
push esi ebx |
call editor_step_forward |
jnc @f |
cmp byte [esi+ebx], 10 |
jnz @f |
mov al, 10 ; force Unix-style to avoid collapse |
@@: |
pop ebx esi |
mov [esi+ebx], al |
jmp .eol_correct |
.insert_eol_dos: |
mov byte [esi+ebx], 13 |
call editor_step_forward |
mov byte [esi+ebx], 10 |
.eol_correct: |
call editor_step_forward |
test esi, esi |
jnz @f |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
@@: |
and [ebp + editor_data.cur_delta], 0 |
cmp ebx, [esi + edit_block_header.limit] |
jz @f |
mov al, [esi+ebx] |
cmp al, 10 |
jz @f |
cmp al, 13 |
jz @f |
dec [ebp + editor_data.cur_delta] |
@@: |
; ã çâ® ¦¥, ¢ ⥪áâ ã¦ë¥ ᨬ¢®«ë ¢áâ ¢¨«¨, ⥯¥àì ¤® ᪮à४â¨à®¢ âì ¨ä®à¬ æ¨î ® ç «¥ áâப íªà ¥ |
mov edi, [ebp + editor_data.cursor_y] |
mov ecx, max_height-1 |
sub ecx, edi |
dec edi |
mov eax, [EditPlugInfo] |
add eax, editor_line.plugdata |
imul edi, eax, max_height |
imul ecx, eax |
lea edi, [ebp + edi + editor_data.linedata_start - 2] |
push esi |
mov esi, edi |
sub esi, eax |
shr ecx, 1 |
std |
rep movsw |
cld |
pop esi |
add edi, 2 |
sub edi, eax |
push esi |
mov esi, edi |
sub esi, eax |
pop eax |
stosd ; editor_line.block |
sub eax, ebp |
mov [ebp + editor_data.cur_block], eax |
mov eax, ebx |
stosw ; editor_line.offs |
mov [ebp + editor_data.cur_offs], eax |
;mov eax, ecx |
;stosd ; editor_line.length |
mov ecx, [EditPlugInfo] |
xor eax, eax |
rep stosb |
; ®¤ã áâபã áâ «® ¡®«ìè¥ |
inc [ebp + editor_data.numlines] |
; ªãàá®à ®ª ¦¥âáï ¢ ç «¥ áâப¨ |
mov [ebp + editor_data.cursor_x], eax |
mov [ebp + editor_data.curcol], eax |
mov [cursor_x], eax |
; ¨ ¯¥à¥¤¢¨¥âáï áâப㠨¦¥ |
mov eax, [ebp + editor_data.cursor_y] |
inc eax |
mov edx, [cur_height] |
dec edx |
cmp eax, edx |
jae .down_scroll |
mov [ebp + editor_data.cursor_y], eax |
mov [cursor_y], eax |
jmp editor_draw_text |
|
.exit_confirm: |
test [ebp + editor_data.flags], 80h |
jz .exit |
push aFileModified |
mov eax, esp |
push EditorExitBtn |
push 3 |
push eax |
push 1 |
push aEditorTitle |
call SayErrTitle |
pop ecx |
test eax, eax |
jz .save |
dec eax |
jz .exit |
ret |
.exit_save: |
test [ebp + editor_data.flags], 80h |
jz .exit |
.save: |
call editor_save |
.exit: |
call editor_OnExit |
jmp delete_active_screen |
.f2: |
call editor_save |
jmp .redraw_status |
|
.up_scroll: |
cmp [ebp + editor_data.curline], 0 |
jz .ret |
push 1 |
pop ecx |
call editor_up_scroll |
jmp editor_draw_text |
.up: |
mov eax, [ebp + editor_data.cursor_y] |
dec eax |
jz .up_scroll |
.set_cursor_y: |
mov [ebp + editor_data.cursor_y], eax |
mov [cursor_y], eax |
call editor_update_cur |
test al, al |
jnz editor_draw_text |
.redraw_status: |
call editor_draw_status |
jmp draw_image |
.down: |
mov eax, [ebp + editor_data.cursor_y] |
inc eax |
push eax |
add eax, [ebp + editor_data.curline] |
cmp eax, [ebp + editor_data.numlines] |
pop eax |
ja .ret |
mov edx, [cur_height] |
dec edx |
cmp eax, edx |
jnz .set_cursor_y |
.down_scroll: |
inc [ebp + editor_data.curline] |
lea edi, [ebp + editor_data.linedata_start] |
mov eax, [EditPlugInfo] |
add eax, editor_line.plugdata |
lea esi, [edi + eax] |
imul ecx, eax, max_height-1 |
shr ecx, 2 |
rep movsd |
adc ecx, ecx |
rep movsw |
sub esi, eax |
sub esi, eax |
movzx ebx, [esi + editor_line.offs] |
mov esi, [esi + editor_line.block] |
call editor_find_newline |
mov eax, esi |
stosd ; editor_line.block |
mov eax, ebx |
stosw ; editor_line.offs |
;mov eax, ecx |
;stosd ; editor_line.length |
mov ecx, [EditPlugInfo] |
xor eax, eax |
rep stosb |
jmp .ret2 |
|
.pgup: |
mov ecx, [cur_height] |
sub ecx, 3 |
mov edx, [ebp + editor_data.curline] |
mov eax, edx |
push edx |
sub edx, ecx |
jnc @f |
xor edx, edx |
@@: |
mov [ebp + editor_data.curline], edx |
add eax, [ebp + editor_data.cursor_y] |
dec eax |
sub eax, ecx |
jnc @f |
xor eax, eax |
@@: |
sub eax, edx |
inc eax |
mov [ebp + editor_data.cursor_y], eax |
mov [cursor_y], eax |
pop ecx |
sub ecx, edx |
push ecx |
mov edx, [EditPlugInfo] |
add edx, editor_line.plugdata |
imul ecx, edx |
imul eax, edx, max_height |
lea edi, [ebp + editor_data.linedata_start + eax - 2] |
mov esi, edi |
sub esi, ecx |
sub eax, ecx |
mov ecx, eax |
shr ecx, 1 |
std |
rep movsw |
cld |
pop ecx |
jecxz .ret2 |
inc edi |
inc edi |
mov esi, [edi + editor_line.block] |
movzx ebx, [edi + editor_line.offs] |
@@: |
push ecx |
call editor_prev_newline |
sub edi, edx |
push edi |
mov eax, esi |
stosd ; editor_line.block |
mov eax, ebx |
stosw ; editor_line.offs |
;mov eax, ecx |
;stosd ; editor_line.length |
mov ecx, [EditPlugInfo] |
xor eax, eax |
rep stosb |
pop edi |
pop ecx |
loop @b |
.ret2: |
call editor_update_cur |
jmp editor_draw_text |
.pgdn: |
mov edx, [cur_height] |
sub edx, 2 |
mov ecx, [ebp + editor_data.curline] |
push ecx |
lea ecx, [edx + ecx - 1] |
mov eax, [ebp + editor_data.numlines] |
sub eax, edx |
jnc @f |
xor eax, eax |
@@: |
cmp ecx, eax |
jb @f |
mov ecx, eax |
@@: |
mov [ebp + editor_data.curline], ecx |
pop eax |
push eax |
add eax, [ebp + editor_data.cursor_y] |
lea eax, [eax + edx - 1] |
cmp eax, [ebp + editor_data.numlines] |
jb @f |
mov eax, [ebp + editor_data.numlines] |
@@: |
sub eax, ecx |
mov [ebp + editor_data.cursor_y], eax |
mov [cursor_y], eax |
pop edx |
sub ecx, edx |
call editor_down_scroll |
jmp .ret2 |
|
.left: |
call editor_cursor_left |
jc .redraw_status |
jmp editor_draw_text |
.ret3: |
ret |
|
.right: |
cmp [ebp + editor_data.cur_delta], -1 |
jz .right_in_text |
cmp [ebp + editor_data.curcol], 0x80000000 - 0x1000 |
jae .ret3 |
inc [ebp + editor_data.cur_delta] |
push 1 |
pop edx |
jmp .right_char |
.right_in_text: |
mov esi, [ebp + editor_data.cur_block] |
add esi, ebp |
mov ebx, [ebp + editor_data.cur_offs] |
mov al, [esi + ebx] |
push eax |
call editor_step_forward |
test esi, esi |
jz .right_eol0 |
mov al, [esi + ebx] |
cmp al, 10 |
jz .right_eol |
cmp al, 13 |
jz .right_eol |
jmp .right_ok |
.right_eol0: |
mov esi, [ebp + editor_data.last_block] |
add esi, ebp |
mov ebx, [esi + edit_block_header.limit] |
.right_eol: |
inc [ebp + editor_data.cur_delta] |
.right_ok: |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
pop eax |
push 1 |
pop edx |
cmp al, 9 |
jnz .right_char |
mov eax, [ebp + editor_data.curcol] |
add eax, [ebp + editor_data.cursor_x] |
xor edx, edx |
div [editor_tabsize] |
sub edx, [editor_tabsize] |
neg edx |
.right_char: |
mov eax, [ebp + editor_data.cursor_x] |
add eax, edx |
cmp eax, [cur_width] |
jb .set_cursor_x |
add eax, [ebp + editor_data.curcol] |
mov edx, [cur_width] |
dec edx |
sub eax, edx |
mov [ebp + editor_data.cursor_x], edx |
mov [cursor_x], edx |
mov [ebp + editor_data.curcol], eax |
jmp editor_draw_text |
.set_cursor_x: |
mov [ebp + editor_data.cursor_x], eax |
mov [cursor_x], eax |
jmp .redraw_status |
|
.home: |
call editor_curline_start |
and [ebp + editor_data.cur_delta], 0 |
cmp ebx, [esi + edit_block_header.limit] |
jz @f |
mov al, [esi+ebx] |
cmp al, 10 |
jz @f |
cmp al, 13 |
jz @f |
dec [ebp + editor_data.cur_delta] |
@@: |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
xor eax, eax |
mov [ebp + editor_data.cursor_x], eax |
mov [cursor_x], eax |
xchg eax, [ebp + editor_data.curcol] |
test eax, eax |
jnz editor_draw_text |
jmp .redraw_status |
|
.end: |
call editor_end_scroll |
jc editor_draw_text |
jmp .redraw_status |
|
.ins: |
xor [ebp + editor_data.flags], 10h |
mov eax, cursor_normal_size |
test [ebp + editor_data.flags], 10h |
jz @f |
mov eax, cursor_big_size |
@@: |
mov [cursor_size], eax |
jmp draw_image |
|
.backspace: |
cmp [ebp + editor_data.cur_delta], -1 |
jz @f |
cmp [ebp + editor_data.cur_delta], 0 |
jnz .left |
@@: |
test [ebp + editor_data.flags], 40h |
jnz .ret3 |
mov esi, [ebp + editor_data.cur_block] |
add esi, ebp |
mov ebx, [ebp + editor_data.cur_offs] |
call editor_step_backward |
jc .ret3 |
push esi ebx |
call editor_cursor_left |
pop ebx esi |
setc al |
push eax |
push esi ebx |
cmp byte [esi+ebx], 10 |
jnz @f |
call editor_step_backward |
jc @f |
cmp byte [esi+ebx], 13 |
jnz @f |
pop eax eax |
jmp .del_char |
@@: |
pop ebx esi |
jmp .del_char |
.del: |
test [ebp + editor_data.flags], 40h |
jnz .ret3 |
mov esi, [ebp + editor_data.cur_block] |
add esi, ebp |
mov ebx, [ebp + editor_data.cur_offs] |
call editor_normalize_offs |
jnc .ret3 |
push 0 |
.del_char: |
or [ebp + editor_data.flags], 80h |
mov al, [esi+ebx] |
push 1 |
pop ecx |
push eax |
push esi ebx |
cmp al, 13 |
jnz @f |
call editor_step_forward |
jnc @f |
cmp byte [esi+ebx], 10 |
jnz @f |
inc ecx |
@@: |
pop ebx esi |
call editor_delete_space |
pop eax |
cmp al, 13 |
jz @f |
cmp al, 10 |
jz @f |
pop eax |
test al, al |
jnz .del1 |
call .redraw_curline |
jmp .redraw_status |
@@: |
pop eax |
dec [ebp + editor_data.numlines] |
call editor_test_cursor_y |
.del1: |
jmp editor_draw_text |
|
editor_cursor_left: |
cmp [ebp + editor_data.cur_delta], -1 |
jz .in_text |
dec [ebp + editor_data.cur_delta] |
cmp [ebp + editor_data.cur_delta], -1 |
jnz .left_cursor |
.in_text: |
mov esi, [ebp + editor_data.cur_block] |
add esi, ebp |
mov ebx, [ebp + editor_data.cur_offs] |
call editor_step_backward |
jc .ret_clc |
mov al, [esi + ebx] |
cmp al, 13 |
jz .eol |
cmp al, 10 |
jz .eol2 |
cmp al, 9 |
jz .tab |
sub esi, ebp |
mov [ebp + editor_data.cur_block], esi |
mov [ebp + editor_data.cur_offs], ebx |
.left_cursor: |
mov eax, [ebp + editor_data.cursor_x] |
test eax, eax |
jz @f |
dec eax |
.set_cursor_x: |
mov [ebp + editor_data.cursor_x], eax |
mov [cursor_x], eax |
.ret_clc: |
clc |
ret |
@@: |
dec [ebp + editor_data.curcol] |
jmp .ret_stc |
.tab: |
mov eax, [ebp + editor_data.cursor_x] |
test eax, eax |
jz @f |
dec eax |
mov [ebp + editor_data.cursor_x], eax |
mov [cursor_x], eax |
call editor_update_cur |
test al, al |
jz .ret_clc |
.ret_stc: |
stc |
ret |
@@: |
dec [ebp + editor_data.curcol] |
call editor_update_cur |
jmp .ret_stc |
.eol2: |
push esi ebx |
call editor_step_backward |
jc @f |
cmp byte [esi + ebx], 13 |
jnz @f |
pop eax eax |
push esi ebx |
@@: |
pop ebx esi |
.eol: |
mov eax, [ebp + editor_data.cursor_y] |
dec eax |
jz .scroll_left_toup |
push 0 ; no full redraw |
mov [ebp + editor_data.cursor_y], eax |
mov [cursor_y], eax |
jmp .scroll_left_toend |
.scroll_left_toup: |
push 1 |
pop ecx |
call editor_up_scroll |
push 1 ; full redraw required |
.scroll_left_toend: |
call editor_end_scroll |
pop eax |
adc al, 0 |
jnz .ret_stc |
jmp .ret_clc |
|
editor_test_cursor_x: |
mov ecx, [cur_width] |
dec ecx |
mov eax, [ebp + editor_data.cursor_x] |
sub eax, ecx |
jbe @f |
add [ebp + editor_data.curcol], eax |
mov [ebp + editor_data.cursor_x], ecx |
mov [cursor_x], ecx |
@@: |
ret |
|
editor_test_cursor_y: |
mov ecx, [ebp + editor_data.cursor_y] |
mov edx, [cur_height] |
dec edx |
dec edx |
sub ecx, edx |
ja .scroll_down |
mov ecx, [ebp + editor_data.curline] |
add ecx, edx |
sub ecx, [ebp + editor_data.numlines] |
ja .scroll_up |
.clc_ret: |
clc |
ret |
.scroll_down: |
add [ebp + editor_data.curline], ecx |
sub [ebp + editor_data.cursor_y], ecx |
sub [cursor_y], ecx |
call editor_down_scroll |
stc |
ret |
.scroll_up: |
cmp ecx, [ebp + editor_data.curline] |
jb @f |
mov ecx, [ebp + editor_data.curline] |
@@: |
jecxz .clc_ret |
add [ebp + editor_data.cursor_y], ecx |
add [cursor_y], ecx |
call editor_up_scroll |
stc |
ret |
|
editor_OnExit: |
mov edx, [ebp+editor_data.hPlugin] |
test edx, edx |
jz @f |
mov ebx, [ebp+editor_data.hFile] |
call close_handle_if_unused |
@@: |
ret |