WebSVN – Kolibri OS – Diff – /programs/develop/tinypad/trunk/tp-key.asm


key:
	mov	ecx,1
	mcall	66,3
	xor	ebx,ebx
	test	al,0x03
	jz	@f
	or	ebx,KM_SHIFT
    @@: test	al,0x0C
	jz	@f
	or	ebx,KM_CTRL
    @@: test	al,0x30
	jz	@f
	or	ebx,KM_ALT
    @@: mov	[shi],ebx
	test	al,0x03
	jz	@f
	inc	cl
    @@: mcall	26,2,,key1
 
	mcall	2
	cmp	al,0
	jne	still.skip_write
	shr	eax,8
	cmp	al,224
	jne	@f
	mov	[ext],0x01
	jmp	still.skip_write
    @@: cmp	al,225
	jne	@f
	mov	[ext],0x02
	jmp	still.skip_write
    @@:
	mov	ah,[ext]
	mov	[ext],0
	or	eax,[shi]
 
	test	al,0x80
	jnz	still.skip_write
	mov	[chr],al
 
	cmp	[bot_mode],0
	je	@f
	mov	ebx,eax
	mov	al,2
	call	[bot_dlg_handler]
	jmp	still
    @@:
 
	mov	esi,accel_table_main
  .acc: cmp	eax,[esi]
	jne	@f
	test	[options],OPTS_SECURESEL
	jz	.lp1
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
  .lp1: mov	[s_status],0
	call	dword[esi+4]
	call	editor_check_for_changes
	jmp	still
    @@: add	esi,8
	cmp	byte[esi],0
	jne	.acc
 
	test	dword[shi],KM_CTRLALT
	jnz	still.skip_write
 
	mov	[s_status],0
 
	movzx	eax,[chr]
	movzx	eax,[eax+key0]
	or	al,al
	jz	still.skip_write
	movzx	eax,[eax+key1]
	push	eax
 
	test	[options],OPTS_SECURESEL
	jz	.lp2
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
	jmp	.put
  .lp2: call	delete_selection
 
	test	[options],OPTS_AUTOBRACES
	jz	.put
	cmp	al,'['
	jne	@f
	mov	al,']'
	call	.lp3
	dec	[cur_editor.Caret.X]
	jmp	.put
    @@: cmp	al,'('
	jne	@f
	mov	al,')'
	call	.lp3
	dec	[cur_editor.Caret.X]
	jmp	.put
    @@: cmp	al,'{'
	jne	.put
	mov	al,'}'
	call	.lp3
	dec	[cur_editor.Caret.X]
 
  .put: pop	eax
	push	still editor_check_for_changes
	inc	[cur_editor.SelStart.X]
  .lp3: push	[cur_editor.Caret.X] eax
	inc	dword[esp+4]
	mov	eax,1
	jmp	key.tab.direct
 
;-----------------------------------------------------------------------------
func key.ctrl_a ;///// SELECT ALL DOCUMENT ///////////////////////////////////
;-----------------------------------------------------------------------------
	xor	eax,eax
	mov	[cur_editor.SelStart.X],eax
	mov	[cur_editor.SelStart.Y],eax
	mov	ecx,[cur_editor.Lines.Count]
	dec	ecx
	mov	[cur_editor.Caret.Y],ecx
	call	get_line_offset
	call	get_real_length
	mov	[cur_editor.Caret.X],eax
	call	draw_editor
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_o ;///// ENTER OPEN FILENAME ///////////////////////////////////
;-----------------------------------------------------------------------------
	mov	[bot_dlg_mode2],0
 
  .direct:
	cmp	[bot_dlg_mode2], 2
	je	.ask
	mov	[s_status],s_enter_filename
	jmp	.ask1
 
   .ask:
	mov	[s_status],s_ask_save
  .ask1:
	mov	[bot_mode],1
	mov	[bot_dlg_height],16*2+4*2-1
	mov	[bot_dlg_handler],osdlg_handler
	mov	[focused_tb],tb_opensave
 
    @@: mov	al,[tb_opensave.length]
	mov	[tb_opensave.pos.x],al
	mov	[tb_opensave.sel.x],0
	mov	[tb_casesen],0;1
	call	drawwindow
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_s ;///// ENTER SAVE FILENAME ///////////////////////////////////
;-----------------------------------------------------------------------------
	cmp	[cur_editor.FilePath], 0
	je	key.shift_ctrl_s
	cmp	[cur_editor.Modified],0
	je	.exit
	call	save_file
	call	drawwindow
  .exit:
	ret
 
    key.shift_ctrl_s:
	mov	[bot_dlg_mode2],1
	jmp	key.ctrl_o.direct
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_n ;///// CREATE NEW FILE (TAB) /////////////////////////////////
;-----------------------------------------------------------------------------
	call	create_tab
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_f ;///// ENTER KEYWORD TO FIND /////////////////////////////////
;-----------------------------------------------------------------------------
	mov	[bot_dlg_mode2],0
	mov	[bot_dlg_height],16*2+4*2-1
 
	mov	[s_status],s_enter_text_to_find
 
  .direct:
	mov	[bot_mode],1
	mov	[bot_dlg_handler],finddlg_handler
	mov	[focused_tb],tb_find
 
	mov	ecx,[s_search.size]
	mov	[tb_find.length],cl
	jecxz	@f
	mov	esi,s_search
	mov	edi,tb_find.text
	cld
	rep	movsb
 
    @@: mov	al,[tb_find.length]
	mov	[tb_find.pos.x],al
	mov	[tb_find.sel.x],0
	mov	[tb_casesen],0
	call	drawwindow
	ret
endf
 
func key.ctrl_h
	mov	[bot_dlg_mode2],1
	mov	[bot_dlg_height],16*3+4*2+1
 
	mov	[s_status],s_enter_text_to_replace
 
	jmp	key.ctrl_f.direct
endf
 
func key.ctrl_g
	ret
@^
	mov	[bot_dlg_mode2],0
	mov	[bot_dlg_height],16*2+4*2-1
 
	mov	[bot_mode],1
	mov	[bot_dlg_handler],gotodlg_handler
	mov	[focused_tb],tb_gotorow
 
	mov	al,[tb_gotorow.length]
	mov	[tb_gotorow.pos.x],al
	mov	[tb_gotorow.sel.x],0
	mov	[tb_casesen],0
	call	drawwindow
	ret
^@
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_left ;///// GO TO PREVIOUS WORD ////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_left: ;///// GO TO PREVIOUS WORD, WITH SELECTION /////////
;-----------------------------------------------------------------------------
	mov	ebx,[cur_editor.Caret.Y]
	mov	edx,[cur_editor.Caret.X]
	cld
	mov	ecx,ebx
	call	get_line_offset
  .lp1: cmp	dx,[esi]
	jle	@f
	movzx	edx,word[esi]
    @@: dec	edx
	jl	.nx1
	add	esi,4
	add	esi,edx
	mov	ecx,edx
    @@: push	ecx
	mov	edi,symbols_ex
	mov	ecx,symbols_ex.size+symbols.size
	mov	al,[esi]
	dec	esi
	repne	scasb
	pop	ecx
	jne	@f
	dec	edx
	dec	ecx
	jnz	@b
  .nx1: dec	ebx
	js	.exit.2
	mov	ecx,ebx
	call	get_line_offset
	movzx	edx,word[esi]
	dec	edx
	jmp	.lp1
    @@:
	mov	ecx,ebx
	call	get_line_offset
  .lp2: cmp	dx,[esi]
	jle	@f
	movzx	edx,word[esi]
    @@: or	edx,edx
	jl	.nx2
	add	esi,4
	add	esi,edx
    @@: mov	edi,symbols_ex
	mov	ecx,symbols_ex.size+symbols.size
	mov	al,[esi]
	dec	esi
	repne	scasb
	je	@f
	dec	edx
	jns	@b
	jmp	@f
  .nx2: dec	ebx
	js	.exit.2
	mov	ecx,ebx
	call	get_line_offset
	movzx	edx,word[esi]
	dec	edx
	jmp	.lp2
    @@:
	inc	edx
	mov	[cur_editor.Caret.Y],ebx
	mov	[cur_editor.Caret.X],edx
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],ebx
	mov	[cur_editor.SelStart.X],edx
    @@: sub	ebx,[cur_editor.TopLeft.Y]
	jge	@f
	add	[cur_editor.TopLeft.Y],ebx
    @@: mov	eax,edx
	sub	eax,[cur_editor.TopLeft.X]
	cmp	eax,[columns.scr]
	jl	@f
	sub	eax,[columns.scr]
	inc	eax
	add	[cur_editor.TopLeft.X],eax
	jmp	.exit
    @@: cmp	edx,[cur_editor.TopLeft.X]
	jge	.exit
	mov	[cur_editor.TopLeft.X],edx
  .exit:
	call	editor_check_for_changes
  .exit.2:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_right ;///// GO TO NEXT WORD ///////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_right: ;///// GO TO NEXT WORD, WITH SELECTION ////////////
;-----------------------------------------------------------------------------
	mov	ebx,[cur_editor.Caret.Y]
	mov	edx,[cur_editor.Caret.X]
	cld
  .lp1: mov	ecx,ebx
	call	get_line_offset
	movzx	ecx,word[esi]
	cmp	edx,ecx
	jge	.nx1
	add	esi,4
	add	esi,edx
	sub	ecx,edx
    @@: push	ecx
	mov	edi,symbols_ex
	mov	ecx,symbols_ex.size+symbols.size
	lodsb
	repne	scasb
	pop	ecx
	je	@f
	inc	edx
	dec	ecx
	jnz	@b
  .nx1: inc	ebx
	cmp	ebx,[cur_editor.Lines.Count]
	jge	.exit.2
	xor	edx,edx
	jmp	.lp1
    @@:
 
  .lp2: mov	ecx,ebx
	call	get_line_offset
	movzx	ecx,word[esi]
	cmp	edx,ecx
	jge	.nx2
	add	esi,4
	add	esi,edx
	sub	ecx,edx
    @@: push	ecx
	mov	edi,symbols_ex
	mov	ecx,symbols_ex.size+symbols.size
	lodsb
	repne	scasb
	pop	ecx
	jne	@f
	inc	edx
	dec	ecx
	jnz	@b
  .nx2: inc	ebx
	cmp	ebx,[cur_editor.Lines.Count]
	jge	.exit.2
	xor	edx,edx
	jmp	.lp2
    @@:
	mov	[cur_editor.Caret.Y],ebx
	mov	[cur_editor.Caret.X],edx
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],ebx
	mov	[cur_editor.SelStart.X],edx
    @@: sub	ebx,[cur_editor.TopLeft.Y]
	cmp	ebx,[lines.scr]
	jl	@f
	sub	ebx,[lines.scr]
	inc	ebx
	add	[cur_editor.TopLeft.Y],ebx
    @@: mov	eax,edx
	sub	eax,[cur_editor.TopLeft.X]
	cmp	eax,[columns.scr]
	jl	@f
	sub	eax,[columns.scr]
	inc	eax
	add	[cur_editor.TopLeft.X],eax
	jmp	.exit
    @@: cmp	edx,[cur_editor.TopLeft.X]
	jge	.exit
	mov	[cur_editor.TopLeft.X],edx
  .exit:
	call	editor_check_for_changes
  .exit.2:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_x
	cmp	[sel.selected],0
	je	@f
	call	key.ctrl_c
	call	key.del
	mov	[cur_editor.Modified],1
    @@: ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_c
	mov	[copy_size],0
	cmp	[sel.selected],0
	je	.exit
 
	call	get_selection_size
	mov	ebx,eax
	mov	eax,[copy_buf]
	call	mem.ReAlloc
	mov	[copy_buf],eax
 
	cld
	mov	eax,[sel.begin.y]
	cmp	eax,[sel.end.y]
	je	.single_line
	mov	ecx,[sel.begin.y]
	call	get_line_offset
	inc	ecx
	push	ecx
	mov	edi,[copy_buf]
	call	get_real_length
	sub	eax,[sel.begin.x]
	jge	@f
	xor	eax,eax
    @@: add	esi,[sel.begin.x]
	add	esi,4
	stosd
	mov	ecx,eax
	jecxz	@f
	rep	movsb
    @@: mov	ecx,[sel.end.y]
	call	get_line_offset
	pop	ecx
	cmp	ecx,[sel.end.y]
	je	@f
	mov	eax,esi
	call	get_line_offset
	sub	eax,esi
	mov	ecx,eax
	rep	movsb
	mov	ecx,[sel.end.y]
    @@: call	get_line_offset
	movzx	eax,word[esi]
	add	esi,4
	cmp	eax,[sel.end.x]
	jle	@f
	mov	eax,[sel.end.x]
    @@: mov	ebx,edi
	stosd
	mov	ecx,eax
	jecxz	@f
	rep	movsb
	sub	eax,[sel.end.x]
	jz	@f
	neg	eax
	mov	ecx,eax
	add	[ebx],eax
	mov	al,' '
	rep	stosb
    @@: sub	edi,[copy_buf]
	mov	[copy_size],edi
	mov	eax,[sel.end.y]
	sub	eax,[sel.begin.y]
	inc	eax
	mov	[copy_count],eax
  .exit:
	ret
 
  .single_line:
	mov	eax,[sel.end.x]
	sub	eax,[sel.begin.x]
	mov	edi,[copy_buf]
	stosd
	mov	ecx,[sel.begin.y]
	call	get_line_offset
	mov	ebx,[sel.begin.x]
	mov	ecx,[sel.end.x]
	cmp	ebx,[esi]
	jge	.add_spaces
	cmp	ecx,[esi]
	jle	.lp1
	mov	ecx,[esi]
  .lp1: sub	ecx,[sel.begin.x]
	sub	eax,ecx
	lea	esi,[esi+ebx+4]
	rep	movsb
 
  .add_spaces:
	mov	ecx,eax
	mov	al,' '
	jecxz	@b
	rep	stosb
	jmp	@b
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_v
	cmp	[copy_size],0
	je	.exit
 
	call	delete_selection
 
	mov	eax,[copy_size]
	call	editor_realloc_lines
 
	mov	eax,[cur_editor.Lines]
	mov	ebx,[cur_editor.Lines.Size]
	add	ebx,[copy_size]
	mov	[cur_editor.Lines.Size],ebx
	call	mem.ReAlloc
	mov	[cur_editor.Lines],eax
 
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	pushd	[esi] esi
	mov	ecx,[cur_editor.Caret.X]
	call	line_add_spaces
	add	[esp],eax
	add	esi,eax
	mov	ecx,[copy_size]
	sub	ecx,4
	mov	edi,[cur_editor.Lines]
	add	edi,[edi-4]
	dec	edi
	mov	eax,esi
	mov	esi,edi
	sub	esi,ecx
	lea	ecx,[eax+4]
	add	ecx,[cur_editor.Caret.X]
	neg	ecx
	lea	ecx,[esi+ecx+1]
	std
	rep	movsb
 
	mov	ecx,[copy_count]
	dec	ecx
	jz	.single_line
 
	cld
	pop	edi
	add	edi,4
	mov	esi,[copy_buf]
	lodsd
 
	mov	ebx,[cur_editor.Caret.X]
	add	eax,ebx
	mov	[edi-4],ax
	mov	byte[edi-4+2],0x0001
	sub	eax,ebx
	call	.check_columns
	add	edi,ebx
    @@: push	ecx
	mov	ecx,eax
	rep	movsb
	lodsd
	and	eax,0x0000FFFF
	stosd
	mov	byte[edi-4+2],0x0001
	pop	ecx
	loop	@b
 
	pop	ecx
	sub	ecx,ebx
	add	[edi-4],cx
	call	.check_columns
	mov	ecx,eax
	rep	movsb
 
	mov	[cur_editor.Caret.X],eax
	mov	[cur_editor.SelStart.X],eax
	mov	eax,[copy_count]
	dec	eax
	add	[cur_editor.Caret.Y],eax
	add	[cur_editor.SelStart.Y],eax
	add	[cur_editor.Lines.Count],eax
 
	mov	[cur_editor.Modified],1
	jmp	.exit
 
  .single_line:
	cld
	pop	edi
	add	edi,4
	mov	esi,[copy_buf]
	lodsd
	add	[edi-4],ax
	and	dword[edi-4],not 0x00020000
	or	dword[edi-4],0x00010000
	call	.check_columns
	add	edi,[cur_editor.Caret.X]
	add	esp,4
	mov	ecx,eax
	rep	movsb
 
	add	[cur_editor.Caret.X],eax
	add	[cur_editor.SelStart.X],eax
 
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
 
  .check_columns:
	push	eax
	movzx	eax,word[edi-4]
	cmp	eax,[cur_editor.Columns.Count]
	jbe	@f
	mov	[cur_editor.Columns.Count],eax
    @@: pop	eax
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_d ;///// INSERT SEPARATOR //////////////////////////////////////
;-----------------------------------------------------------------------------
	mov	eax,94
	call	editor_realloc_lines
 
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	mov	ebx,esi
 
	mov	ecx,[cur_editor.Lines.Count]
	call	get_line_offset
	lea	edi,[esi+90+4]
	lea	ecx,[esi+4]
	sub	ecx,ebx
	std
	rep	movsb
 
	lea	edi,[ebx+5]
	mov	word[ebx],90
	mov	al,ASEPC
	mov	ecx,79
	cld
	rep	stosb
	mov	al,' '
	mov	ecx,10
	rep	stosb
	mov	byte[ebx+4],';'
 
	inc	[cur_editor.Lines.Count]
	inc	[cur_editor.Caret.Y]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
 
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_y ;///// DELETE CURRENT LINE ///////////////////////////////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.Caret.Y]
	inc	eax
	cmp	eax,[cur_editor.Lines.Count]
	jge	.exit
 
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	mov	edi,esi
	lodsd
	and	eax,0x0000FFFF
	add	esi,eax
	push	eax
 
	dec	[cur_editor.Lines.Count]
	mov	ecx,[cur_editor.Lines]
	add	ecx,[ecx-4]
	sub	ecx,esi
	shr	ecx,2
	cld
	rep	movsd
 
	pop	eax
	add	eax,4
	neg	eax
	call	editor_realloc_lines
 
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
 
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.up ;///// GO TO PREVIOUS LINE ///////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_up: ;///// GO TO PREVIOUS LINE, WITH SELECTION ////////////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.Caret.Y]
	dec	eax
	jns	@f
	xor	eax,eax
    @@: mov	ecx,[cur_editor.TopLeft.Y]
	cmp	eax,ecx
	jae	@f
	dec	ecx
	jns	@f
	xor	ecx,ecx
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.down ;///// GO TO NEXT LINE /////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_down: ;///// GO TO NEXT LINE, WITH SELECTION //////////////////
;-----------------------------------------------------------------------------
 
	mov	eax,[cur_editor.Caret.Y]
	inc	eax
	cmp	eax,[cur_editor.Lines.Count]
	jb	@f
	dec	eax
    @@: mov	ecx,[cur_editor.TopLeft.Y]
	mov	edx,eax
	sub	edx,ecx
	cmp	edx,[lines.scr]
	jb	@f
	inc	ecx
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.left ;///// GO TO PREVIOUS CHAR /////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_left: ;///// GO TO PREVIOUS CHAR, WITH SELECTION //////////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.Caret.X]
	dec	eax
	jns	@f
	inc	eax
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.X],eax
    @@: mov	[cur_editor.Caret.X],eax
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.right ;///// GO TO NEXT CHAR ////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_right: ;///// GO TO NEXT CHAR, WITH SELECTION /////////////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.Caret.X]
	inc	eax
	cmp	eax,[cur_editor.Columns.Count]
	jbe	@f
	dec	eax
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.X],eax
    @@: mov	[cur_editor.Caret.X],eax
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.pgup ;///// GO TO PREVIOUS PAGE /////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_pgup: ;///// GO TO PREVIOUS PAGE, WITH SELECTION //////////////
;-----------------------------------------------------------------------------
	mov	edx,[lines.scr]
	dec	edx
	mov	eax,[cur_editor.Caret.Y]
	mov	ecx,[cur_editor.TopLeft.Y]
	sub	eax,edx
	jns	@f
	xor	eax,eax
    @@: sub	ecx,edx
	jns	@f
	xor	ecx,ecx
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.pgdn ;///// GO TO NEXT PAGE /////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_pgdn: ;///// GO TO NEXT PAGE, WITH SELECTION //////////////////
;-----------------------------------------------------------------------------
	mov	edx,[lines.scr]
	dec	edx
	mov	eax,[cur_editor.Caret.Y]
	mov	ecx,[cur_editor.TopLeft.Y]
	add	eax,edx
	add	ecx,edx
	cmp	eax,[cur_editor.Lines.Count]
	jb	@f
	mov	eax,[cur_editor.Lines.Count]
	dec	eax
    @@: test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.home ;///// GO TO LINE START ////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_home: ;///// GO TO LINE START, WITH SELECTION /////////////////
;-----------------------------------------------------------------------------
	mov	[cur_editor.Caret.X],0
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.X],0
    @@:
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.end ;///// GO TO LINE END ///////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_end: ;///// GO TO LINE END, WITH SELECTION ////////////////////
;-----------------------------------------------------------------------------
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	call	get_real_length
	mov	[cur_editor.Caret.X],eax
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.X],eax
    @@:
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_home ;///// GO TO PAGE START ///////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_home: ;///// GO TO PAGE START, WITH SELECTION ////////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.TopLeft.Y]
	mov	ecx,eax
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_end ;///// GO TO PAGE END //////////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_end: ;///// GO TO PAGE END, WITH SELECTION ///////////////
;-----------------------------------------------------------------------------
	mov	ecx,[cur_editor.TopLeft.Y]
	mov	eax,[lines.scr]
	cmp	eax,[cur_editor.Lines.Count]
	jle	@f
	mov	eax,[cur_editor.Lines.Count]
    @@: add	eax,ecx
	dec	eax
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@: mov	[cur_editor.Caret.Y],eax
	mov	[cur_editor.TopLeft.Y],ecx
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_pgup ;///// GO TO DOCUMENT START ///////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_pgup: ;///// GO TO DOCUMENT START, WITH SELECTION ////////
;-----------------------------------------------------------------------------
	xor	eax,eax
	mov	[cur_editor.TopLeft.Y],eax
	mov	[cur_editor.Caret.Y],eax
	test	byte[shi+2],0x01
	jnz	@f
	mov	[cur_editor.SelStart.Y],eax
    @@:
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_pgdn ;///// GO TO DOCUMENT END /////////////////////////////////
;-----------------------------------------------------------------------------
	call	clear_selection
 
;-----------------------------------------------------------------------------
     key.shift_ctrl_pgdn: ;///// GO TO DOCUMENT END, WITH SELECTION //////////
;-----------------------------------------------------------------------------
	mov	eax,[cur_editor.Lines.Count]
	mov	[cur_editor.Caret.Y],eax
	sub	eax,[lines.scr]
	jns	@f
	xor	eax,eax
    @@: mov	[cur_editor.TopLeft.Y],eax
	dec	[cur_editor.Caret.Y]
	test	byte[shi+2],0x01
	jnz	@f
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
    @@:
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.del ;///// DELETE NEXT CHAR OR SELECTION ////////////////////////////
;-----------------------------------------------------------------------------
	call	delete_selection
	jnc	.exit
 
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	and	dword[esi],not 0x00020000
	or	dword[esi],0x00010000
	lea	ebx,[esi+4]
	mov	ebp,esi
 
	call	get_real_length
	or	eax,eax
	je	.line_up
 
	mov	ecx,[cur_editor.Caret.X]
	cmp	ecx,eax
	jae	.line_up
	lea	edi,[ebx+ecx]
	neg	ecx
	movzx	eax,word[ebp]
	add	ecx,eax;[ebp]
	repe	scasb
	je	.line_up
 
	mov	edi,ebx
	mov	ecx,[cur_editor.Caret.X]
	add	edi,ecx
	lea	esi,[edi+1]
	neg	ecx
	movzx	eax,word[ebp]
	add	ecx,eax;[ebp]
	dec	ecx
	rep	movsb
	mov	byte[edi],' '
 
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
	mov	[cur_editor.Modified],1
	ret
 
  .line_up:
	mov	eax,[cur_editor.Lines.Count]
	dec	eax
	cmp	eax,[cur_editor.Caret.Y]
	je	.exit
	mov	edi,[temp_buf]
	add	edi,4
	mov	esi,ebx
	mov	ecx,[cur_editor.Caret.X]
	rep	movsb
	mov	ecx,[cur_editor.Caret.X]
	mov	eax,[temp_buf]
	mov	[eax],ecx
	cmp	cx,[ebp]
	jbe	@f
	movzx	eax,word[ebp]
	sub	ecx,eax
	sub	edi,ecx
	mov	al,' '
	rep	stosb
    @@: lea	esi,[ebx+4]
	movzx	eax,word[ebp]
	add	esi,eax
	movzx	ecx,word[esi-4]
	mov	eax,[temp_buf]
	add	[eax],ecx
	or	dword[eax],0x00010000
	rep	movsb
 
	mov	ecx,edi
	sub	ecx,[temp_buf]
 
	mov	esi,[temp_buf]
	call	get_real_length
	cmp	eax,[cur_editor.Columns.Count]
	jbe	@f
	mov	[cur_editor.Columns.Count],eax
    @@:
	push	ecx
	mov	edi,[cur_editor.Lines]
	add	edi,[edi-4]
	dec	edi
	lea	esi,[edi+8]
	sub	esi,ecx
	movzx	eax,word[ebp]
	add	esi,eax
	movzx	eax,word[ebp]
	movzx	eax,word[ebp+eax+4]
	add	esi,eax
	lea	ecx,[esi-4]
	sub	ecx,ebp
	std
	cmp	esi,edi
	jb	@f
	jz	.lp1
	mov	edi,ebp
	add	edi,[esp]
	lea	esi,[ebp+8]
	movzx	eax,word[esi-8]
	add	esi,eax
	movzx	eax,word[esi-4]
	add	esi,eax
	mov	ecx,[cur_editor.Lines]
	add	ecx,[ecx-4]
	sub	ecx,esi
	cld
    @@: rep	movsb
  .lp1: pop	ecx
	mov	esi,[temp_buf]
	mov	edi,ebp
	cld
	rep	movsb
 
  .ok.dec.lines:
	dec	[cur_editor.Lines.Count]
	mov	eax,[cur_editor.Lines.Count]
	cmp	[cur_editor.Caret.Y],eax
	jb	@f
	dec	eax
	mov	[cur_editor.Caret.Y],eax
    @@: m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
 
	mov	ecx,[cur_editor.Lines.Count]
	call	get_line_offset
	movzx	eax,word[esi]
	lea	esi,[esi+eax+4]
	mov	eax,[cur_editor.Lines]
	add	eax,[eax-4]
	sub	esi,eax
	lea	eax,[esi+4096]
	call	editor_realloc_lines
 
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
  key.ins:
;// ... toggle insert/overwrite mode here ...
	xor	[ins_mode],1
	mov	eax,[cur_editor.Caret.Y]
	mov	ebx,eax
	call	draw_editor_text.part
	call	draw_editor_caret
	ret
 
;-----------------------------------------------------------------------------
func key.bkspace ;///// DELETE PREVIOUS CHAR OR SELECTION ////////////////////
;-----------------------------------------------------------------------------
	call	delete_selection
	jnc	key.del.exit
 
	mov	eax,[cur_editor.Caret.X]
	dec	eax
	js	.line_up
 
	dec	[cur_editor.Caret.X]
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	and	dword[esi],not 0x00020000
	or	dword[esi],0x00010000
 
	mov	ebx,eax
	call	get_real_length
	cmp	eax,[cur_editor.Caret.X]
	jae	@f
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	mov	[cur_editor.Modified],1
	ret
 
    @@: lea	edi,[esi+4+ebx]
	mov	ecx,ebx
	neg	ecx
	movzx	eax,word[esi]
	add	ecx,eax
	dec	ecx
	lea	esi,[edi+1]
	cld
	rep	movsb
	mov	byte[edi],' '
 
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
	mov	[cur_editor.Modified],1
	ret
 
  .line_up:
	cmp	[cur_editor.Caret.Y],0
	jne	@f
	ret
    @@: mov	ecx,[cur_editor.Caret.Y]
	dec	ecx
	call	get_line_offset
	and	dword[esi],not 0x00020000
	or	dword[esi],0x00010000
 
	mov	ebp,esi
	lea	ebx,[esi+4]
	movzx	ecx,word[ebp]
    @@: cmp	byte[ebx+ecx-1],' '
	jne	@f
	dec	ecx
	jg	@b
    @@: mov	[cur_editor.Caret.X],ecx
	dec	[cur_editor.Caret.Y]
	cld
	jmp	key.del.line_up
endf
 
;-----------------------------------------------------------------------------
func key.tab ;///// TABULATE /////////////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	delete_selection
	mov	eax,[cur_editor.Caret.X]
 
	mov	ecx,eax
	add	eax,ATABW
	and	eax,not(ATABW-1)
	push	eax ' '
	sub	eax,ecx
  .direct:
	push	eax
	call	editor_realloc_lines
	pop	eax
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
	and	dword[esi],not 0x00020000
	or	dword[esi],0x00010000
 
	xchg	eax,ecx
 
	call	get_real_length
	cmp	eax,[cur_editor.Caret.X]
	jae	@f
	mov	eax,[cur_editor.Caret.X]
    @@: movzx	edx,word[esi]
	sub	edx,eax
	cmp	ecx,edx
	jl	@f
	push	eax
	mov	eax,10
	call	editor_realloc_lines
	add	esi,eax
	pop	eax
	pushad
	mov	ecx,[cur_editor.Lines]
	add	ecx,[ecx-4]
	dec	ecx
	mov	edi,ecx
	add	ecx,-10+1
	movzx	eax,word[esi]
	lea	eax,[esi+eax+4]
	sub	ecx,eax
	lea	esi,[edi-10]
	std
	rep	movsb
	mov	ecx,10
	mov	al,' '
	rep	stosb
	popad
	add	word[esi],10
	jmp	@b
    @@: lea	ebx,[esi+4]
	push	ecx
	movzx	edi,word[esi]
	lea	edi,[ebx+edi-1]
	mov	esi,edi
	sub	esi,ecx
	lea	ecx,[esi+1]
	sub	ecx,ebx
	sub	ecx,[cur_editor.Caret.X]
	std
	rep	movsb
  .ok:	pop	ecx
	pop	eax
	rep	stosb
	cld
	pop	[cur_editor.Caret.X]
	lea	esi,[ebx-4]
	call	get_real_length
	cmp	eax,[cur_editor.Caret.X]
	jae	@f
	mov	eax,[cur_editor.Caret.X]
    @@: cmp	eax,[cur_editor.Columns.Count]
	jbe	@f
	mov	[cur_editor.Columns.Count],eax
    @@: m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
	m2m	[cur_editor.SelStart.Y],[cur_editor.Caret.Y]
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.return ;///// CARRIAGE RETURN ///////////////////////////////////////
;-----------------------------------------------------------------------------
	call	delete_selection
 
	mov	eax,14
	call	editor_realloc_lines
 
	mov	ecx,[cur_editor.Caret.Y]
	call	get_line_offset
 
	mov	ebx,[cur_editor.Caret.X]
	cmp	bx,[esi]
	jb	@f
	movzx	ebx,word[esi]
	dec	ebx
	jns	@f
	xor	ebx,ebx
    @@:
	cld
 
	mov	edi,[temp_buf]
	mov	ebp,esi
	lea	ecx,[ebx+1]
    @@: dec	ecx
	jz	@f
	cmp	byte[esi+ecx+4-1],' '
	je	@b
    @@: lea	eax,[ecx+10]
	or	eax,0x00010000
	stosd
	jecxz	@f
	push	esi
	add	esi,4
	rep	movsb
	pop	esi
    @@: mov	al,' '
	mov	ecx,10
	rep	stosb
 
	movzx	ecx,word[esi]
	sub	ecx,ebx
	add	esi,ebx
	add	esi,4
	inc	ecx
    @@: dec	ecx
	jz	@f
	cmp	byte[esi+ecx-1],' '
	je	@b
    @@: jz	.lp1
    @@: cmp	byte[esi],' '
	jne	.lp1
	inc	esi
	loop	@b
  .lp1: test	[options],OPTS_AUTOINDENT
	jz	.lp2
	push	edi ecx
	movzx	ecx,word[ebp]
	lea	edi,[ebp+4]
	mov	al,' '
	repe	scasb
	mov	eax,ecx
	pop	ecx edi
	je	.lp2
	neg	eax
	movzx	edx,word[ebp]
	add	eax,edx;[ebp]
	dec	eax
	jmp	@f
  .lp2: xor	eax,eax
    @@: mov	edx,edi
	add	edi,4
	mov	[cur_editor.Caret.X],eax
	jecxz	@f
	push	ecx
	mov	ecx,eax
	mov	al,' '
	rep	stosb
	pop	ecx
    @@: jecxz	@f
	rep	movsb
    @@: mov	ecx,10
	mov	al,' '
	rep	stosb
 
	lea	eax,[edi-4]
	sub	eax,edx
	or	eax,0x00010000
	mov	[edx],eax
 
	mov	ecx,edi
	sub	ecx,[temp_buf]
 
	push	ecx
	mov	edi,[cur_editor.Lines]
	add	edi,[edi-4]
	dec	edi
	lea	esi,[edi+4]
	sub	esi,ecx
	movzx	ecx,word[ebp]
	add	esi,ecx
	lea	ecx,[esi-4]
	sub	ecx,ebp
	std
	cmp	esi,edi
	jb	@f
	je	.lp3
	lea	esi,[ebp+4]
	mov	eax,[esp]
	lea	edi,[esi+eax-4]
	movzx	ecx,word[ebp]
	add	esi,ecx
	mov	ecx,[cur_editor.Lines]
	add	ecx,[ecx-4]
	sub	ecx,esi
	cld
    @@: rep	movsb
  .lp3: pop	ecx
	mov	esi,[temp_buf]
	mov	edi,ebp
	cld
	rep	movsb
 
	inc	[cur_editor.Caret.Y]
	inc	[cur_editor.SelStart.Y]
	inc	[cur_editor.Lines.Count]
 
	m2m	[cur_editor.SelStart.X],[cur_editor.Caret.X]
 
	mov	[cur_editor.Modified],1
 
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_tab ;///// SWITCH TO NEXT TAB //////////////////////////////////
;-----------------------------------------------------------------------------
	cmp	[tab_bar.Items.Count],1
	je	.exit
	xor	eax,eax
	mov	ebp,[tab_bar.Items]
    @@: cmp	ebp,[tab_bar.Current.Ptr]
	je	@f
	inc	eax
	add	ebp,sizeof.TABITEM
	jmp	@b
    @@: add	ebp,sizeof.TABITEM
	inc	eax
	cmp	eax,[tab_bar.Items.Count]
	jb	@f
	mov	ebp,[tab_bar.Items]
    @@: call	set_cur_tab
	call	make_tab_visible
	call	align_editor_in_tab
	call	draw_editor
	call	draw_tabctl
	call	update_caption
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.shift_ctrl_tab ;///// SWITCH TO PREVIOUS TAB ////////////////////////
;-----------------------------------------------------------------------------
	cmp	[tab_bar.Items.Count],1
	je	.exit
	xor	eax,eax
	mov	ebp,[tab_bar.Items]
    @@: cmp	ebp,[tab_bar.Current.Ptr]
	je	@f
	inc	eax
	add	ebp,sizeof.TABITEM
	jmp	@b
    @@: add	ebp,-sizeof.TABITEM
	dec	eax
	jge	@f
	imul	eax,[tab_bar.Items.Count],sizeof.TABITEM
	add	eax,[tab_bar.Items]
	lea	ebp,[eax-sizeof.TABITEM]
    @@: call	set_cur_tab
	call	make_tab_visible
	call	align_editor_in_tab
	call	draw_editor
	call	draw_tabctl
	call	update_caption
  .exit:
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_f4 ;///// CLOSE CURRENT TAB ////////////////////////////////////
;-----------------------------------------------------------------------------
	cmp	[cur_editor.Modified], 0
	je	.close
	mov	[bot_dlg_mode2], 2
	jmp	key.ctrl_o.direct
 .close:
	mov	[do_not_draw],1
	push	[tab_bar.Current.Ptr]
	cmp	[tab_bar.Items.Count],1
	jne	@f
	;call    create_tab
	jmp	key.alt_x.close 	; close program
    @@: pop	ebp
	call	delete_tab
	dec	[do_not_draw]
	call	align_editor_in_tab
	call	draw_editor
	call	draw_tabctl
	call	draw_statusbar
	ret
endf
 
;-----------------------------------------------------------------------------
func key.shift_f9 ;///// SET DEFAULT TAB /////////////////////////////////////
;-----------------------------------------------------------------------------
	mov	eax,[tab_bar.Current.Ptr]
	cmp	eax,[tab_bar.Default.Ptr]
	jne	@f
	xor	eax,eax
    @@: mov	[tab_bar.Default.Ptr],eax
	mov	ebp,[tab_bar.Current.Ptr]
	call	make_tab_visible
	cmp	[tab_bar.Style],2
	jbe	@f
	call	align_editor_in_tab
	call	draw_editor
    @@: call	draw_tabctl
	ret
endf
 
;-----------------------------------------------------------------------------
func key.f3 ;///// FIND NEXT MATCH ///////////////////////////////////////////
;-----------------------------------------------------------------------------
	call	search
	jc	@f
    @@: ret
endf
 
;-----------------------------------------------------------------------------
func key.f9 ;///// COMPILE AND RUN ///////////////////////////////////////////
;-----------------------------------------------------------------------------
	mov	bl,1
	call	start_fasm
	ret
endf
 
;-----------------------------------------------------------------------------
func key.ctrl_f9 ;///// COMPILE //////////////////////////////////////////////
;-----------------------------------------------------------------------------
	mov	bl,0
	call	start_fasm
	ret
endf
 
;-----------------------------------------------------------------------------
func key.alt_x ;///// EXIT PROGRAM ///////////////////////////////////////////
;-----------------------------------------------------------------------------
	mov	esi,self_path
	mov	byte[esi+PATHL-1],0
	mov	edi,f_info.path
	cld
    @@: lodsb
	stosb
	or	al,al
	jnz	@b
 
	mov	[f_info70+0],2
	mov	[f_info70+4],0
	mov	[f_info70+8],0
	mov	[f_info70+12],TINYPAD_END
	mov	[f_info70+16],0
	mov	byte[f_info70+20],0
	mov	[f_info70+21],f_info.path
	mcall	70,f_info70
 
  .bgn_rp:
	call	key.ctrl_f4
  .close:
	cmp	[tab_bar.Items.Count],1
	jne	.bgn_rp
	mov	[main_closed],1
	mcall	-1
endf

Rev 327	Rev 595
1	key:	1	key:
2	mov ecx,1	2	mov ecx,1
3	mcall 66,3	3	mcall 66,3
4	xor ebx,ebx	4	xor ebx,ebx
5	test al,0x03	5	test al,0x03
6	jz @f	6	jz @f
7	or ebx,KM_SHIFT	7	or ebx,KM_SHIFT
8	@@: test al,0x0C	8	@@: test al,0x0C
9	jz @f	9	jz @f
10	or ebx,KM_CTRL	10	or ebx,KM_CTRL
11	@@: test al,0x30	11	@@: test al,0x30
12	jz @f	12	jz @f
13	or ebx,KM_ALT	13	or ebx,KM_ALT
14	@@: mov [shi],ebx	14	@@: mov [shi],ebx
15	test al,0x03	15	test al,0x03
16	jz @f	16	jz @f
17	inc cl	17	inc cl
18	@@: mcall 26,2,,key1	18	@@: mcall 26,2,,key1
19		19
20	mcall 2	20	mcall 2
21	cmp al,0	21	cmp al,0
22	jne still.skip_write	22	jne still.skip_write
23	shr eax,8	23	shr eax,8
24	cmp al,224	24	cmp al,224
25	jne @f	25	jne @f
26	mov [ext],0x01	26	mov [ext],0x01
27	jmp still.skip_write	27	jmp still.skip_write
28	@@: cmp al,225	28	@@: cmp al,225
29	jne @f	29	jne @f
30	mov [ext],0x02	30	mov [ext],0x02
31	jmp still.skip_write	31	jmp still.skip_write
32	@@:	32	@@:
33	mov ah,[ext]	33	mov ah,[ext]
34	mov [ext],0	34	mov [ext],0
35	or eax,[shi]	35	or eax,[shi]
36		36
37	test al,0x80	37	test al,0x80
38	jnz still.skip_write	38	jnz still.skip_write
39	mov [chr],al	39	mov [chr],al
40		40
41	cmp [bot_mode],0	41	cmp [bot_mode],0
42	je @f	42	je @f
43	mov ebx,eax	43	mov ebx,eax
44	mov al,2	44	mov al,2
45	call [bot_dlg_handler]	45	call [bot_dlg_handler]
46	jmp still	46	jmp still
47	@@:	47	@@:
48		48
49	mov esi,accel_table_main	49	mov esi,accel_table_main
50	.acc: cmp eax,[esi]	50	.acc: cmp eax,[esi]
51	jne @f	51	jne @f
52	test [options],OPTS_SECURESEL	52	test [options],OPTS_SECURESEL
53	jz .lp1	53	jz .lp1
54	m2m [cur_editor.SelStart.X],[cur_editor.Caret.X]	54	m2m [cur_editor.SelStart.X],[cur_editor.Caret.X]
55	m2m [cur_editor.SelStart.Y],[cur_editor.Caret.Y]	55	m2m [cur_editor.SelStart.Y],[cur_editor.Caret.Y]
56	.lp1: mov [s_status],0	56	.lp1: mov [s_status],0
57	call dword[esi+4]	57	call dword[esi+4]
58	call editor_check_for_changes	58	call editor_check_for_changes
59	jmp still	59	jmp still
60	@@: add esi,8	60	@@: add esi,8
61	cmp byte[esi],0	61	cmp byte[esi],0
62	jne .acc	62	jne .acc
63		63
64	test dword[shi],KM_CTRLALT	64	test dword[shi],KM_CTRLALT
65	jnz still.skip_write	65	jnz still.skip_write
66		66
67	mov [s_status],0	67	mov [s_status],0
68		68
69	movzx eax,[chr]	69	movzx eax,[chr]
70	movzx eax,[eax+key0]	70	movzx eax,[eax+key0]
71	or al,al	71	or al,al
72	jz still.skip_write	72	jz still.skip_write
73	movzx eax,[eax+key1]	73	movzx eax,[eax+key1]
74	push eax	74	push eax
75		75
76	test [options],OPTS_SECURESEL	76	test [options],OPTS_SECURESEL
77	jz .lp2	77	jz .lp2
78	m2m [cur_editor.SelStart.X],[cur_editor.Caret.X]	78	m2m [cur_editor.SelStart.X],[cur_editor.Caret.X]
79	m2m [cur_editor.SelStart.Y],[cur_editor.Caret.Y]	79	m2m [cur_editor.SelStart.Y],[cur_editor.Caret.Y]
80	jmp .put	80	jmp .put
81	.lp2: call delete_selection	81	.lp2: call delete_selection
82		82
83	test [options],OPTS_AUTOBRACES	83	test [options],OPTS_AUTOBRACES
84	jz .put	84	jz .put
85	cmp al,'['	85	cmp al,'['
86	jne @f	86	jne @f
87	mov al,']'	87	mov al,']'
88	call .lp3	88	call .lp3
89	dec [cur_editor.Caret.X]	89	dec [cur_editor.Caret.X]
90	jmp .put	90	jmp .put
91	@@: cmp al,'('	91	@@: cmp al,'('
92	jne @f	92	jne @f
93	mov al,')'	93	mov al,')'
94	call .lp3	94	call .lp3
95	dec [cur_editor.Caret.X]	95	dec [cur_editor.Caret.X]
96	jmp .put	96	jmp .put
97	@@: cmp al,'{'	97	@@: cmp al,'{'
98	jne .put	98	jne .put
99	mov al,'}'	99	mov al,'}'
100	call .lp3	100	call .lp3
101	dec [cur_editor.Caret.X]	101	dec [cur_editor.Caret.X]
102		102
103	.put: pop eax	103	.put: pop eax
104	push still editor_check_for_changes	104	push still editor_check_for_changes
105	inc [cur_editor.SelStart.X]	105	inc [cur_editor.SelStart.X]
106	.lp3: push [cur_editor.Caret.X] eax	106	.lp3: push [cur_editor.Caret.X] eax
107	inc dword[esp+4]	107	inc dword[esp+4]
108	mov eax,1	108	mov eax,1
109	jmp key.tab.direct	109	jmp key.tab.direct
110		110
111	;-----------------------------------------------------------------------------	111	;-----------------------------------------------------------------------------
112	func key.ctrl_a ;///// SELECT ALL DOCUMENT ///////////////////////////////////	112	func key.ctrl_a ;///// SELECT ALL DOCUMENT ///////////////////////////////////
113	;-----------------------------------------------------------------------------	113	;-----------------------------------------------------------------------------
114	xor eax,eax	114	xor eax,eax
115	mov [cur_editor.SelStart.X],eax	115	mov [cur_editor.SelStart.X],eax
116	mov [cur_editor.SelStart.Y],eax	116	mov [cur_editor.SelStart.Y],eax
117	mov ecx,[cur_editor.Lines.Count]	117	mov ecx,[cur_editor.Lines.Count]
118	dec ecx	118	dec ecx
119	mov [cur_editor.Caret.Y],ecx	119	mov [cur_editor.Caret.Y],ecx
120	call get_line_offset	120	call get_line_offset
121	call get_real_length	121	call get_real_length
122	mov [cur_editor.Caret.X],eax	122	mov [cur_editor.Caret.X],eax
123	call draw_editor	123	call draw_editor
124	ret	124	ret
125	endf	125	endf
126		126
127	;-----------------------------------------------------------------------------	127	;-----------------------------------------------------------------------------
128	func key.ctrl_o ;///// ENTER OPEN FILENAME ///////////////////////////////////	128	func key.ctrl_o ;///// ENTER OPEN FILENAME ///////////////////////////////////
129	;-----------------------------------------------------------------------------	129	;-----------------------------------------------------------------------------
130	mov [bot_dlg_mode2],0	130	mov [bot_dlg_mode2],0
131		131
132	.direct:	132	.direct:
-		133	cmp [bot_dlg_mode2], 2
-		134	je .ask
133	mov [s_status],s_enter_filename	135	mov [s_status],s_enter_filename
-		136	jmp .ask1
-		137
-		138	.ask:
-		139	mov [s_status],s_ask_save
134		140	.ask1:
135	mov [bot_mode],1	141	mov [bot_mode],1
136	mov [bot_dlg_height],162+42-1	142	mov [bot_dlg_height],162+42-1
137	mov [bot_dlg_handler],osdlg_handler	143	mov [bot_dlg_handler],osdlg_handler
138	mov [focused_tb],tb_opensave	144	mov [focused_tb],tb_opensave
139		145
140	@@: mov al,[tb_opensave.length]	146	@@: mov al,[tb_opensave.length]
141	mov [tb_opensave.pos.x],al	147	mov [tb_opensave.pos.x],al
142	mov [tb_opensave.sel.x],0	148	mov [tb_opensave.sel.x],0
143	mov [tb_casesen],0;1	149	mov [tb_casesen],0;1
144	call drawwindow	150	call drawwindow
145	ret	151	ret
146	endf	152	endf
147		153
148	;-----------------------------------------------------------------------------	154	;-----------------------------------------------------------------------------
149	func key.ctrl_s ;///// ENTER SAVE FILENAME ///////////////////////////////////	155	func key.ctrl_s ;///// ENTER SAVE FILENAME ///////////////////////////////////
150	;-----------------------------------------------------------------------------	156	;-----------------------------------------------------------------------------
151	cmp [cur_editor.FilePath],'/'	157	cmp [cur_editor.FilePath], 0
152	jne key.shift_ctrl_s	158	je key.shift_ctrl_s
153	cmp [cur_editor.Modified],0	159	cmp [cur_editor.Modified],0
154	je .exit	160	je .exit
155	call save_file	161	call save_file
156	call drawwindow	162	call drawwindow
157	.exit:	163	.exit:
158	ret	164	ret
159		165
160	key.shift_ctrl_s:	166	key.shift_ctrl_s:
161	mov [bot_dlg_mode2],1	167	mov [bot_dlg_mode2],1
162	jmp key.ctrl_o.direct	168	jmp key.ctrl_o.direct
163	endf	169	endf
164		170
165	;-----------------------------------------------------------------------------	171	;-----------------------------------------------------------------------------
166	func key.ctrl_n ;///// CREATE NEW FILE (TAB) /////////////////////////////////	172	func key.ctrl_n ;///// CREATE NEW FILE (TAB) /////////////////////////////////
167	;-----------------------------------------------------------------------------	173	;-----------------------------------------------------------------------------
168	call create_tab	174	call create_tab
169	ret	175	ret
170	endf	176	endf
171		177
172	;-----------------------------------------------------------------------------	178	;-----------------------------------------------------------------------------
173	func key.ctrl_f ;///// ENTER KEYWORD TO FIND /////////////////////////////////	179	func key.ctrl_f ;///// ENTER KEYWORD TO FIND /////////////////////////////////
174	;-----------------------------------------------------------------------------	180	;-----------------------------------------------------------------------------
175	mov [bot_dlg_mode2],0	181	mov [bot_dlg_mode2],0
176	mov [bot_dlg_height],162+42-1	182	mov [bot_dlg_height],162+42-1
177		183
178	mov [s_status],s_enter_text_to_find	184	mov [s_status],s_enter_text_to_find
179		185
180	.direct:	186	.direct:
181	mov [bot_mode],1	187	mov [bot_mode],1
182	mov [bot_dlg_handler],finddlg_handler	188	mov [bot_dlg_handler],finddlg_handler
183	mov [focused_tb],tb_find	189	mov [focused_tb],tb_find
184		190
185	mov ecx,[s_search.size]	191	mov ecx,[s_search.size]
186	mov [tb_find.length],cl	192	mov [tb_find.length],cl
187	jecxz @f	193	jecxz @f
188	mov esi,s_search	194	mov esi,s_search
189	mov edi,tb_find.text	195	mov edi,tb_find.text
190	cld	196	cld
191	rep movsb	197	rep movsb
192		198
193	@@: mov al,[tb_find.length]	199	@@: mov al,[tb_find.length]
194	mov [tb_find.pos.x],al	200	mov [tb_find.pos.x],al
195	mov [tb_find.sel.x],0	201	mov [tb_find.sel.x],0
196	mov [tb_casesen],0	202	mov [tb_casesen],0
197	call drawwindow	203	call drawwindow
198	ret	204	ret
199	endf	205	endf
200		206
201	func key.ctrl_h	207	func key.ctrl_h
202	mov [bot_dlg_mode2],1	208	mov [bot_dlg_mode2],1
203	mov [bot_dlg_height],163+42+1	209	mov [bot_dlg_height],163+42+1
204		210
205	mov [s_status],s_enter_text_to_replace	211	mov [s_status],s_enter_text_to_replace
206		212
207	jmp key.ctrl_f.direct	213	jmp key.ctrl_f.direct
208	endf	214	endf
209		215
210	func key.ctrl_g	216	func key.ctrl_g
211	ret	217	ret
212	@^	218	@^
213	mov [bot_dlg_mode2],0	219	mov [bot_dlg_mode2],0
214	mov [bot_dlg_height],162+42-1	220	mov [bot_dlg_height],162+42-1
215		221
216	mov [bot_mode],1	222	mov [bot_mode],1
217	mov [bot_dlg_handler],gotodlg_handler	223	mov [bot_dlg_handler],gotodlg_handler
218	mov [focused_tb],tb_gotorow	224	mov [focused_tb],tb_gotorow
219		225
220	mov al,[tb_gotorow.length]	226	mov al,[tb_gotorow.length]
221	mov [tb_gotorow.pos.x],al	227	mov [tb_gotorow.pos.x],al
222	mov [tb_gotorow.sel.x],0	228	mov [tb_gotorow.sel.x],0
223	mov [tb_casesen],0	229	mov [tb_casesen],0
224	call drawwindow	230	call drawwindow
225	ret	231	ret
226	^@	232	^@
227	endf	233	endf
228		234
229	;-----------------------------------------------------------------------------	235	;-----------------------------------------------------------------------------
230	func key.ctrl_left ;///// GO TO PREVIOUS WORD ////////////////////////////////	236	func key.ctrl_left ;///// GO TO PREVIOUS WORD ////////////////////////////////
231	;-----------------------------------------------------------------------------	237	;-----------------------------------------------------------------------------
232	call clear_selection	238	call clear_selection
233		239
234	;-----------------------------------------------------------------------------	240	;-----------------------------------------------------------------------------
235	key.shift_ctrl_left: ;///// GO TO PREVIOUS WORD, WITH SELECTION /////////	241	key.shift_ctrl_left: ;///// GO TO PREVIOUS WORD, WITH SELECTION /////////
236	;-----------------------------------------------------------------------------	242	;-----------------------------------------------------------------------------
237	mov ebx,[cur_editor.Caret.Y]	243	mov ebx,[cur_editor.Caret.Y]
238	mov edx,[cur_editor.Caret.X]	244	mov edx,[cur_editor.Caret.X]
239	cld	245	cld
240	mov ecx,ebx	246	mov ecx,ebx
241	call get_line_offset	247	call get_line_offset
242	.lp1: cmp dx,[esi]	248	.lp1: cmp dx,[esi]
243	jle @f	249	jle @f
244	movzx edx,word[esi]	250	movzx edx,word[esi]
245	@@: dec edx	251	@@: dec edx
246	jl .nx1	252	jl .nx1
247	add esi,4	253	add esi,4
248	add esi,edx	254	add esi,edx
249	mov ecx,edx	255	mov ecx,edx
250	@@: push ecx	256	@@: push ecx
251	mov edi,symbols_ex	257	mov edi,symbols_ex
252	mov ecx,symbols_ex.size+symbols.size	258	mov ecx,symbols_ex.size+symbols.size
253	mov al,[esi]	259	mov al,[esi]
254	dec esi	260	dec esi
255	repne scasb	261	repne scasb
256	pop ecx	262	pop ecx
257	jne @f	263	jne @f
258	dec edx	264	dec edx
259	dec ecx	265	dec ecx
260	jnz @b	266	jnz @b
261	.nx1: dec ebx	267	.nx1: dec ebx
262	js .exit.2	268	js .exit.2
263	mov ecx,ebx	269	mov ecx,ebx
264	call get_line_offset	270	call get_line_offset
265	movzx edx,word[esi]	271	movzx edx,word[esi]
266	dec edx	272	dec edx
267	jmp .lp1	273	jmp .lp1
268	@@:	274	@@:
269	mov ecx,ebx	275	mov ecx,ebx
270	call get_line_offset	276	call get_line_offset
271	.lp2: cmp dx,[esi]	277	.lp2: cmp dx,[esi]
272	jle @f	278	jle @f
273	movzx edx,word[esi]	279	movzx edx,word[esi]
274	@@: or edx,edx	280	@@: or edx,edx
275	jl .nx2	281	jl .nx2
276	add esi,4	282	add esi,4
277	add esi,edx	283	add esi,edx
278	@@: mov edi,symbols_ex	284	@@: mov edi,symbols_ex
279	mov ecx,symbols_ex.size+symbols.size	285	mov ecx,symbols_ex.size+symbols.size
280	mov al,[esi]	286	mov al,[esi]
281	dec esi	287	dec esi
282	repne scasb	288	repne scasb
283	je @f	289	je @f
284	dec edx	290	dec edx
285	jns @b	291	jns @b
286	jmp @f	292	jmp @f
287	.nx2: dec ebx	293	.nx2: dec ebx
288	js .exit.2	294	js .exit.2
289	mov ecx,ebx	295	mov ecx,ebx
290	call get_line_offset	296	call get_line_offset
291	movzx edx,word[esi]	297	movzx edx,word[esi]
292	dec edx	298	dec edx
293	jmp .lp2	299	jmp .lp2
294	@@:	300	@@:
295	inc edx	301	inc edx
296	mov [cur_editor.Caret.Y],ebx	302	mov [cur_editor.Caret.Y],ebx
297	mov [cur_editor.Caret.X],edx	303	mov [cur_editor.Caret.X],edx
298	test byte[shi+2],0x01	304	test byte[shi+2],0x01
299	jnz @f	305	jnz @f
300	mov [cur_editor.SelStart.Y],ebx	306	mov [cur_editor.SelStart.Y],ebx
301	mov [cur_editor.SelStart.X],edx	307	mov [cur_editor.SelStart.X],edx
302	@@: sub ebx,[cur_editor.TopLeft.Y]	308	@@: sub ebx,[cur_editor.TopLeft.Y]
303	jge @f	309	jge @f
304	add [cur_editor.TopLeft.Y],ebx	310	add [cur_editor.TopLeft.Y],ebx
305	@@: mov eax,edx	311	@@: mov eax,edx
306	sub eax,[cur_editor.TopLeft.X]	312	sub eax,[cur_editor.TopLeft.X]
307	cmp eax,[columns.scr]	313	cmp eax,[columns.scr]
308	jl @f	314	jl @f
309	sub eax,[columns.scr]	315	sub eax,[columns.scr]
310	inc eax	316	inc eax
311	add [cur_editor.TopLeft.X],eax	317	add [cur_editor.TopLeft.X],eax
312	jmp .exit	318	jmp .exit
313	@@: cmp edx,[cur_editor.TopLeft.X]	319	@@: cmp edx,[cur_editor.TopLeft.X]
314	jge .exit	320	jge .exit
315	mov [cur_editor.TopLeft.X],edx	321	mov [cur_editor.TopLeft.X],edx
316	.exit:	322	.exit:
317	call editor_check_for_changes	323	call editor_check_for_changes
318	.exit.2:	324	.exit.2:
319	ret	325	ret
320	endf	326	endf
321		327
322	;-----------------------------------------------------------------------------	328	;-----------------------------------------------------------------------------
323	func key.ctrl_right ;///// GO TO NEXT WORD ///////////////////////////////////	329	func key.ctrl_right ;///// GO TO NEXT WORD ///////////////////////////////////
324	;-----------------------------------------------------------------------------	330	;-----------------------------------------------------------------------------
325	call clear_selection	331	call clear_selection
326		332
327	;-----------------------------------------------------------------------------	333	;-----------------------------------------------------------------------------
328	key.shift_ctrl_right: ;///// GO TO NEXT WORD, WITH SELECTION ////////////	334	key.shift_ctrl_right: ;///// GO TO NEXT WORD, WITH SELECTION ////////////
329	;-----------------------------------------------------------------------------	335	;-----------------------------------------------------------------------------
330	mov ebx,[cur_editor.Caret.Y]	336	mov ebx,[cur_editor.Caret.Y]
331	mov edx,[cur_editor.Caret.X]	337	mov edx,[cur_editor.Caret.X]
332	cld	338	cld
333	.lp1: mov ecx,ebx	339	.lp1: mov ecx,ebx
334	call get_line_offset	340	call get_line_offset
335	movzx ecx,word[esi]	341	movzx ecx,word[esi]
336	cmp edx,ecx	342	cmp edx,ecx
337	jge .nx1	343	jge .nx1
338	add esi,4	344	add esi,4
339	add esi,edx	345	add esi,edx
340	sub ecx,edx	346	sub ecx,edx
341	@@: push ecx	347	@@: push ecx
342	mov edi,symbols_ex	348	mov edi,symbols_ex
343	mov ecx,symbols_ex.size+symbols.size	349	mov ecx,symbols_ex.size+symbols.size
344	lodsb	350	lodsb
345	repne scasb	351	repne scasb
346	pop ecx	352	pop ecx
347	je @f	353	je @f
348	inc edx	354	inc edx
349	dec ecx	355	dec ecx
350	jnz @b	356	jnz @b
351	.nx1: inc ebx	357	.nx1: inc ebx
352	cmp ebx,[cur_editor.Lines.Count]	358	cmp ebx,[cur_editor.Lines.Count]
353	jge .exit.2	359	jge .exit.2
354	xor edx,edx	360	xor edx,edx
355	jmp .lp1	361	jmp .lp1
356	@@:	362	@@:
357		363
358	.lp2: mov ecx,ebx	364	.lp2: mov ecx,ebx
359	call get_line_offset	365	call get_line_offset
360	movzx ecx,word[esi]	366	movzx ecx,word[esi]
361	cmp edx,ecx	367	cmp edx,ecx
362	jge .nx2	368	jge .nx2
363	add esi,4	369	add esi,4
364	add esi,edx	370	add esi,edx
365	sub ecx,edx	371	sub ecx,edx
366	@@: push ecx	372	@@: push ecx
367	mov edi,symbols_ex	373	mov edi,symbols_ex
368	mov ecx,symbols_ex.size+symbols.size	374	mov ecx,symbols_ex.size+symbols.size
369	lodsb	375	lodsb
370	repne scasb	376	repne scasb
371	pop ecx	377	pop ecx
372	jne @f	378	jne @f
373	inc edx	379	inc edx
374	dec ecx	380	dec ecx
375	jnz @b	381	jnz @b
376	.nx2: inc ebx	382	.nx2: inc ebx
377	cmp ebx,[cur_editor.Lines.Count]	383	cmp ebx,[cur_editor.Lines.Count]
378	jge .exit.2	384	jge .exit.2
379	xor edx,edx	385	xor edx,edx
380	jmp .lp2	386	jmp .lp2
381	@@:	387	@@:
382	mov [cur_editor.Caret.Y],ebx	388	mov [cur_editor.Caret.Y],ebx
383	mov [cur_editor.Caret.X],edx	389	mov [cur_editor.Caret.X],edx
384	test byte[shi+2],0x01	390	test byte[shi+2],0x01
385	jnz @f	391	jnz @f
386	mov [cur_editor.SelStart.Y],ebx	392	mov [cur_editor.SelStart.Y],ebx
387	mov [cur_editor.SelStart.X],edx	393	mov [cur_editor.SelStart.X],edx
388	@@: sub ebx,[cur_editor.TopLeft.Y]	394	@@: sub ebx,[cur_editor.TopLeft.Y]
389	cmp ebx,[lines.scr]	395	cmp ebx,[lines.scr]
390	jl @f	396	jl @f
391	sub ebx,[lines.scr]	397	sub ebx,[lines.scr]
392	inc ebx	398	inc ebx
393	add [cur_editor.TopLeft.Y],ebx	399	add [cur_editor.TopLeft.Y],ebx
394	@@: mov eax,edx	400	@@: mov eax,edx
395	sub eax,[cur_editor.TopLeft.X]	401	sub eax,[cur_editor.TopLeft.X]
396	cmp eax,[columns.scr]	402	cmp eax,[columns.scr]
397	jl @f	403	jl @f
398	sub eax,[columns.scr]	404	sub eax,[columns.scr]
399	inc eax	405	inc eax
400	add [cur_editor.TopLeft.X],eax	406	add [cur_editor.TopLeft.X],eax
401	jmp .exit	407	jmp .exit
402	@@: cmp edx,[cur_editor.TopLeft.X]	408	@@: cmp edx,[cur_editor.TopLeft.X]
403	jge .exit	409	jge .exit
404	mov [cur_editor.TopLeft.X],edx	410	mov [cur_editor.TopLeft.X],edx
405	.exit:	411	.exit:
406	call editor_check_for_changes	412	call editor_check_for_changes
407	.exit.2:	413	.exit.2:
408	ret	414	ret
409	endf	415	endf
410		416
411	;-----------------------------------------------------------------------------	417	;-----------------------------------------------------------------------------
412	func key.ctrl_x	418	func key.ctrl_x
413	cmp [sel.selected],0	419	cmp [sel.selected],0
414	je @f	420	je @f
415	call key.ctrl_c	421	call key.ctrl_c
416	call key.del	422	call key.del
417	mov [cur_editor.Modified],1	423	mov [cur_editor.Modified],1
418	@@: ret	424	@@: ret
419	endf	425	endf
420		426
421	;-----------------------------------------------------------------------------	427	;-----------------------------------------------------------------------------
422	func key.ctrl_c	428	func key.ctrl_c
423	mov [copy_size],0	429	mov [copy_size],0
424	cmp [sel.selected],0	430	cmp [sel.selected],0
425	je .exit	431	je .exit
426		432
427	call get_selection_size	433	call get_selection_size
428	mov ebx,eax	434	mov ebx,eax
429	mov eax,[copy_buf]	435	mov eax,[copy_buf]
430	call mem.ReAlloc	436	call mem.ReAlloc
431	mov [copy_buf],eax	437	mov [copy_buf],eax
432		438
433	cld	439	cld
434	mov eax,[sel.begin.y]	440	mov eax,[sel.begin.y]
435	cmp eax,[sel.end.y]	441	cmp eax,[sel.end.y]
436	je .single_line	442	je .single_line
437	mov ecx,[sel.begin.y]	443	mov ecx,[sel.begin.y]
438	call get_line_offset	444	call get_line_offset
439	inc ecx	445	inc ecx
440	push ecx	446	push ecx
441	mov edi,[copy_buf]	447	mov edi,[copy_buf]
442	call get_real_length	448	call get_real_length
443	sub eax,[sel.begin.x]	449	sub eax,[sel.begin.x]
444	jge @f	450	jge @f
445	xor eax,eax	451	xor eax,eax
446	@@: add esi,[sel.begin.x]	452	@@: add esi,[sel.begin.x]
447	add esi,4	453	add esi,4
448	stosd	454	stosd
449	mov ecx,eax	455	mov ecx,eax
450	jecxz @f	456	jecxz @f
451	rep movsb	457	rep movsb
452	@@: mov ecx,[sel.end.y]	458	@@: mov ecx,[sel.end.y]
453	call get_line_offset	459	call get_line_offset
454	pop ecx	460	pop ecx
455	cmp ecx,[sel.end.y]	461	cmp ecx,[sel.end.y]
456	je @f	462	je @f
457	mov eax,esi	463	mov eax,esi
458	call get_line_offset	464	call get_line_offset
459	sub eax,esi	465	sub eax,esi
460	mov ecx,eax	466	mov ecx,eax
461	rep movsb	467	rep movsb
462	mov ecx,[sel.end.y]	468	mov ecx,[sel.end.y]
463	@@: call get_line_offset	469	@@: call get_line_offset
464	movzx eax,word[esi]	470	movzx eax,word[esi]
465	add esi,4	471	add esi,4
466	cmp eax,[sel.end.x]	472	cmp eax,[sel.end.x]
467	jle @f	473	jle @f
468	mov eax,[sel.end.x]	474	mov eax,[sel.end.x]
469	@@: mov ebx,edi	475	@@: mov ebx,edi
470	stosd	476	stosd
471	mov ecx,eax	477	mov ecx,eax
472	jecxz @f	478	jecxz @f
473	rep movsb	479	rep movsb
474	sub eax,[sel.end.x]	480	sub eax,[sel.end.x]
475	jz @f	481	jz @f
476	neg eax	482	neg eax
477	mov ecx,eax	483	mov ecx,eax
478	add [ebx],eax	484	add [ebx],eax
479	mov al,' '	485	mov al,' '
480	rep stosb	486	rep stosb
481	@@: sub edi,[copy_buf]	487	@@: sub edi,[copy_buf]
482	mov [copy_size],edi	488	mov [copy_size],edi
483	mov eax,[sel.end.y]	489	mov eax,[sel.end.y]
484	sub eax,[sel.begin.y]	490	sub eax,[sel.begin.y]
485	inc eax	491	inc eax
486	mov [copy_count],eax	492	mov [copy_count],eax
487	.exit:	493	.exit:
488	ret	494	ret
489		495
490	.single_line:	496	.single_line:
491	mov eax,[sel.end.x]	497	mov eax,[sel.end.x]
492	sub eax,[sel.begin.x]	498	sub eax,[sel.begin.x]
493	mov edi,[copy_buf]	499	mov edi,[copy_buf]
494	stosd	500	stosd

Subversion Repositories Kolibri OS

(root)/programs/develop/tinypad/trunk/tp-key.asm – Rev 327 → 595