Subversion Repositories Kolibri OS

struct f70

  func_n dd ?

  param1 dd ?

  param2 dd ?

  param3 dd ?

  param4 dd ?

  rezerv db ?

  name dd ?

ends

struct TexColViv

  Text rb MAX_COLOR_WORD_LEN; // ñëîâî

  f1 dd 0

  wwo db ? ; whole words only

  endc db ? ; ñèìâîë êîíöà âûäåëåíèÿ (wwo&4)

  color db ? ; íîìåð öâåòà

ends

struct symbol

  c db ?    ;  +0 ñèìâîë

  col db ?  ;  +1 öâåò

  perv dd ? ;  +2

  next dd ? ;  +6 óêàçàòåëè

  tc dd ?   ; +10 âðåì. ñîçäàíèÿ

  td dd ?   ; +14 âðåì. óäàëåíèÿ

ends

ColColor dd 1

ColWords dd 0

CURSOR_COLOR dd 0x808080

WND_CAPT_COLOR dd 0x80

WND_WORK_COLOR dd 0x0

WND_BORD_COLOR dd 0xd0d0d0

SELECT_COLOR dd 0x208080

CUR_TEXT_COLOR dd 0xff0000

WND_TEXT_COLOR dd 0xffff00

options_file dd 0

options_file_end dd 0

tex_colors dd 0

tex_help_f1 dd 0

FkPos: rd 256

Col dd 0 ;óêàçàòåëü íà ñòðóêòóðû êëþ÷åâûõ ñëîâ TexColViv

conv_tabl rb 128 ; òàáëèöà äëÿ êîíâåðòèðîâàíèÿ scan-êîäà â ascii-êîä

keyUpr dd 0

err_sav db 0 ;îøèáêà ñîõðàíåíèÿ ôàéëà

panel_id db 0 ;íîìåð îòêðûòîé ïàíåëè

ch_tim	 dd ? ; êîëè÷åñòâî èçìåíåíèé â ôàéëå

ls_tim	 dd ? ; âðåìÿ ïîñëåäíåãî ñîõðàíåíèÿ

co_tim	 dd ? ; âðåìÿ ïîñëåäíåé öâåòîâîé ðàçìåòêè

tim_Undo dd ? ; êîëè÷åñòâî îòìåíåííûõ äåéñòâèé

gpOpt db 0

mode_colored db 1 ; ðåæèì âûäåëåíèÿ ñëîâ öâåòîì (0-âûêë. 1-âêë.)

key_new db 0 ; ñèìâîë, êîòîðûé áóäåò äîáàâëÿòñÿ ñ êëàâèàòóðû

tex	dd 0 ;text memory pointer

tex_1	dd 0 ;text first symbol pointer

tex_end dd 0 ;text end memory pointer

curMod db 1

cur_x dd 0

cur_y dd 0

invis db 0 ;ðåæèì ïîêàçà íåïå÷àòàåìûõ ñèìâîëîâ

symbol_new_line db 20 ;ñèìâîë çàâåðøåíèÿ ñòðîêè

help_id dd -1  ;èäåíòèôèêàòîð äëÿ ñïðàâêè

hed db 'TextEditor 15.04.10',0 ;ïîäïèñü îêíà

sc system_colors

fn_icon db 'te_icon.bmp',0

bmp_icon dd 0

run_file_70 f70

;input:

; reg = index

;output:

; reg = pointer to 'tex' struct

macro ConvertIndexToPointer reg {

  imul reg,sizeof.symbol

  add reg,[tex]

}

;output:

; al = 1 - can save

CanSave:

  push ecx

  mov ecx,[ch_tim]

  sub ecx,[tim_Undo]

  mov al,1

  cmp [ls_tim],ecx

  jne @f

    dec al

  @@:

  pop ecx

  ret

;output:

; al = 1 - selected

proc IsSel, edit:dword

  push ebx edi

  mov edi,dword[edit]

  xor al,al

  cmp ted_drag_m,1

  je @f

    mov al,1

    mov ebx,[sel.x0]

    cmp ebx,[sel.x1]

    jne @f

    mov ebx,[sel.y0]

    cmp ebx,[sel.y1]

    jne @f

    xor al,al

  @@:

  pop edi ebx

  ret

endp

SelNormalize:

  push ecx esi edi

    mov esi,sel

    mov edi,seln

    mov ecx,sizeof.TexSelect

    rep movsb

    jmp @f

    .swp_f:

      mov ecx,[seln.x0]

      m2m [seln.x0],[seln.x1]

      mov [seln.x1],ecx

      mov ecx,[seln.y0]

      cmp ecx,[seln.y1] ;(sel.y0>sel.y1)

      jle .end_f

      m2m [seln.y0],[seln.y1]

      mov [seln.y1],ecx

    jmp .end_f

    @@:

    mov ecx,[seln.y0]

    cmp ecx,[seln.y1] ;(sel.y0>sel.y1)

    jg .swp_f

    cmp ecx,[seln.y1] ;(sel.y0==sel.y1)

    jne .end_f

      mov ecx,[seln.x0]

      cmp ecx,[seln.x1] ;(sel.x0>sel.x1)

      jg .swp_f

    .end_f:

  pop edi esi ecx

  ret

SelStart:

  push ecx

    mov ecx,[cur_x]

    add ecx,[hScr.position]

    mov [sel.x0],ecx

    mov [sel.x1],ecx

    mov ecx,[cur_y]

    add ecx,[wScr.position]

    mov [sel.y0],ecx

    mov [sel.y1],ecx

  pop ecx

  ret

align 4

SelMove:

  push ecx

    mov ecx,[cur_x]

    add ecx,[hScr.position]

    mov [sel.x1],ecx

    mov ecx,[cur_y]

    add ecx,[wScr.position]

    mov [sel.y1],ecx

  pop ecx

  call draw_but_toolbar ;redraw toolbar (need to button Copy)

  ret

;input:

; al = 1 - clear all memory

Clear:

  mov [cur_x],0

  mov [cur_y],0

  mov [ch_tim],0

  mov [ls_tim],0

  mov [co_tim],0

  mov [tim_Undo],0

  mov [help_id],-1

  mov [wScr.position],0

  mov [wScr.max_area],100

  mov [wScr.redraw],1

  mov [hScr.position],0

  mov [hScr.max_area],100

  mov [sel.x0],0

  mov [sel.y0],0

  mov [sel.x1],0

  mov [sel.y1],0

  cmp al,0

  je .exit

  push ecx edx

  mov ecx,sizeof.symbol*maxChars

  mov edx,[tex]

  @@:

    mov byte [edx],0

    inc edx

  loop @b

  mov edx,[tex]

  mov dword [edx+6],1

  pop edx ecx

  .exit:

  ret

;--- out_reg = Col[keyw[ind_reg]].Text[0] ---

macro ColToIndexOffset ind_reg,out_reg {

  mov out_reg,ind_reg

  imul out_reg,sizeof.TexColViv

  add out_reg,[Col]

}

InitColText:

  push eax ebx ecx esi edi

  mov  ebx,dword[fn_col_option]

  copy_path ebx,fn_syntax_dir,file_name_rez,0x0

  copy_path file_name_rez,sys_path,file_name,0x0

  mov eax,70

  mov [run_file_70.func_n], 0

  mov [run_file_70.param1], 0

  mov [run_file_70.param2], 0

  mov ebx,[options_file_end]

  sub ebx,[options_file]

  mov [run_file_70.param3], ebx

  m2m [run_file_70.param4], [options_file]

  mov [run_file_70.rezerv], 0

  mov [run_file_70.name], file_name

  mov ebx,run_file_70

  int 0x40

  mov ecx,0x100

  mov edi,FkPos

  @@:

    mov dword[edi],-1

    add edi,4

  loop @b

  ;init: ColColor, ColWords, ...

  mov dword[ColColor],1

  mov dword[ColWords],0

    mov dword[tex_help_f1],0

  mov [help_id],-1 ;èäåíòèôèêàòîð ñëîâà äëÿ ñïðàâêè

  cmp eax,6

  je @f

  cmp eax,0

  je @f

    cmp ax,10

    jl .zifra_0_9

      mov al,'?'

      sub ax,48

    .zifra_0_9:

    add ax,48

    mov byte[msgbox_3.err],al

    push thread

    push msgbox_3

    call [mb_create] ;message: Can-t open color options file!

    jmp .no_colors

  @@:

  mov esi,[options_file]

  mov edi,ColColor

  mov ecx,9*4

  rep movsb

  mov eax,[options_file]

  add eax,32

  mov dword[tex_colors],eax

  mov eax,dword[ColColor] ;init: Col (offset to key words)

  add eax,8

  shl eax,2

  add eax,[options_file]

  mov dword[Col],eax

  mov ecx,dword[ColWords] ;init: FkPos (first key positions)

  xor eax,eax

  @@:

    ColToIndexOffset eax,edi

    xor ebx,ebx

    mov bl,byte[edi]

    shl bx,2

    mov esi,FkPos

    add esi,ebx

    cmp dword[esi],-1

    jne .no_ch_key

      mov dword[esi],eax

    .no_ch_key:

    inc eax

  loop @b

  ;init: tex_help_f1

  mov ecx,dword[ColWords]

  imul ecx,sizeof.TexColViv

  add ecx,dword[Col]

  mov dword[tex_help_f1],ecx

  .no_colors:

  pop edi esi ecx ebx eax

  ret

;input:

; ebx = file size

OpenFile:

  push eax ;destination

  push ecx ;for cycle

  push edx ;source

    xor al,al

    call Clear

    mov eax,ebx

    mov ecx,ebx

    add eax,2

    ConvertIndexToPointer eax

    mov edx,[tex]

    add edx,ebx

  push ebx

    @@:

      mov ebx,[edx]

      mov byte [eax],bl

      mov dword [eax+2],ecx

      inc dword [eax+2]

      mov dword [eax+6],ecx

      add dword [eax+6],3

      ;mov byte[eax+1],0 ;col=0

      mov dword [eax+10],-1 ;tc=-1

      mov dword [eax+14],0 ;td=0

      cmp ecx,0

      je @f

      dec ecx

      dec edx

      sub eax,sizeof.symbol

      jmp @b

    @@:

  pop ebx

    add eax,2

    mov dword [eax],0 ; first sumbol 'perv=0'

    mov edx,[tex]

    ; begining sumbol 'perv=0' 'next=2'

    mov dword [edx+2],0

    mov dword [edx+6],2

    add edx,sizeof.symbol

    mov dword [edx+6],0 ; last sumbol 'next=0'

    mov dword [edx+2],ebx ; last sumbol 'perv=last'

    inc dword [edx+2]

    mov edx,ebx

    inc edx ;2 = rezerv sumbols

    imul edx,sizeof.symbol

    add edx,[tex]

    mov dword [edx+6],1 ; last sumbol 'next=1'

    @@: ;clear memory, need if before was open big file

      add edx,sizeof.symbol

      cmp edx,[tex_end]

      jge @f

	mov dword[edx+10],0

	mov dword[edx+14],0

      jmp @b

    @@:

    call GetNumLines

    cmp eax,100

    jge @f

      mov eax,100

    @@:

    mov [wScr.max_area],eax

;    mov [wScr.redraw],1

  pop edx ecx eax

  call CmColored

  ret

;input:

; edx = pointer to symbol struct

;output:

; edx = pointer to 'perv' visible symbol struct

IteratPerv:

  cmp [tim_Undo],0

  je .else

  push ebx

  @@:

    call GetTexPervPos

    cmp edx,[tex]

    je @f

    call SymbNotVis

    cmp bl,1

    je @b

    cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10

    je @b

  @@:

  pop ebx

  ret

  .else:

    call GetTexPervPos

    cmp edx,[tex]

    je .endif

    cmp dword [edx+14],0

    jne .else

    cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10

    je .else

  .endif:

  ret

;input:

; edx = pointer to symbol struct

;output:

; edx = pointer to 'next' visible symbol struct

IteratNext:

  cmp [tim_Undo],0

  je .else

  push ebx

  @@:

    call GetTexNextPos

    cmp edx,[tex_1]

    jle @f

    call SymbNotVis

    cmp bl,1

    je @b

    cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10

    je @b

  @@:

  pop ebx

  ret

  .else:

    call GetTexNextPos

    cmp edx,[tex_1]

    jle .endif

    cmp dword [edx+14],0

    jne .else

    cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10

    je .else

  .endif:

  ret

;input:

; edx = pointer to symbol struct

; bl = symbol end of select

ItPoNextUc:

  @@:

    cmp bl,byte[edx]

    je @f

    cmp edx,[tex_1]

    jle @f

    call IteratNext

    jmp @b

  @@:

  call IteratNext

  ret

;input:

; edx = pointer to symbol struct

ItPervColorTag:

  @@:

    cmp byte[edx+1],0

    jne @f

    call IteratPerv

    cmp edx,[tex_1]

    jle @f

    jmp @b

  @@:

  ret

;input:

; edx = pointer to symbol struct

ItNextColorTag:

  @@:

    call IteratNext

    cmp byte[edx+1],0

    jne @f

    cmp edx,[tex_1]

    jle @f

    jmp @b

  @@:

  ;call IteratNext

  ret

;input:

; edx = pointer to symbol struct

;output:

; bl = 1 if sumbol not visible

; (tex[i].td+tim_Undo<=ch_tim && tex[i].td) || (tex[i].tc>ch_tim-tim_Undo)

SymbNotVis:

  push eax

  xor bl,bl

  cmp dword [edx+14],0

  je @f

  mov eax,[edx+14] ;eax=tex[i].td

  add eax,[tim_Undo]

  cmp eax,[ch_tim]

  jg @f

    mov bl,1

    pop eax

    ret

  @@:

  mov eax,[ch_tim]

  sub eax,[tim_Undo]

  cmp [edx+10],eax

  jle @f

    or bl,1

  @@:

  pop eax

  ret

;input:

; bh = 1 - move cursor after text add

; bl = 1 - change time when text add

; esi = add text len

; edi = pointer to text string

TextAdd:

  push ebp

  mov ebp,esp

  sub esp,4*2

  push eax ;po_t

  push ecx edx edi

  call GetPos

  call GetTexPervPos

  call GetTexArrIndex ;eax=po_t

  mov dword[ebp-4],0 ;count new spaces

  cmp [gpOpt],2

  je @f

    push eax ebx ;c_sp=cur[cn].x+Scroller->XPos-StrLen(cur[cn].y+Scroller->YPos);

      mov eax,[cur_x]

      add eax,[hScr.position]

      mov dword[ebp-4],eax

      mov eax,[cur_y]

      add eax,[wScr.position]

      call StrLen

      sub dword[ebp-4],ebx

    pop ebx eax

  @@:

  mov dword[ebp-8],0 ;count new lines

  cmp [gpOpt],0

  jne @f

    push eax

      mov eax,[cur_y]

      add eax,[wScr.position]

      inc eax

      mov dword[ebp-8],eax

      call GetNumLines

      sub dword[ebp-8],eax

    pop eax

  @@:

  mov edx,sizeof.symbol

  shl edx,1

  add edx,[tex]

  @@: ;for(i=2;i

    cmp dword [edx+10],0 ;if(!tex[i].tc && !tex[i].td)

    jne .u1f

    cmp dword [edx+14],0

    jne .u1f

      cmp bl,0 ;if(n_tim) ch_tim++;

      je .no_tim

	inc [ch_tim]

      .no_tim:

      cmp bh,0

      je .no_cur_mov

      cmp dword[ebp-8],0 ;åñëè åñòü äîáàâî÷íûå ñòðîêè, òî êóðñîð åùå íå äâèãàåì

      jg .no_cur_mov

      cmp dword[ebp-4],0 ;åñëè íåò äîáàâî÷íûõ ïðîáåëîâ, òî êóðñîð òîæå íå äâèãàåì

      jg .no_cur_mov

	inc [cur_x] ;move cursor

	;call GoToPos

	cmp byte [edi],13

	jne .no_cur_mov

	  mov [cur_x],0

	  inc [cur_y]

      .no_cur_mov:

      xor bl,bl ;n_tim=false;

      mov cl,byte [edi] ;tex[i].c=ta[ns];

      mov byte [edx],cl

      m2m dword [edx+10],dword [ch_tim] ;tex[i].tc=ch_tim;

      mov [edx+2],eax ;tex[i].perv=po_t;

      mov ecx,eax

      imul ecx,sizeof.symbol

      add ecx,[tex] ; *** ecx = tex[po_t] ***

      add ecx,6   ; *** ecx = tex[po_t].next ***

      m2m dword [edx+6],dword [ecx] ;tex[i].next=tex[po_t].next;

      call GetTexArrIndex ;*** eax = i ***

      cmp eax,maxChars

      jge @f

      mov [ecx],eax ;tex[po_t].next=i; // ññûëêè ïåðåíàïðàâëÿåì

      mov ecx,[edx+6] ; *** ecx = tex[i].next ***

      imul ecx,sizeof.symbol

      add ecx,[tex] ; *** ecx = tex[tex[i].next] ***

      mov [ecx+2],eax ;tex[tex[i].next].perv=i;

      cmp dword[ebp-8],0 ;add lines or text

      jle .spc_add

	dec dword[ebp-8]

	mov byte [edx],13

	jmp .u1f

      .spc_add:

      cmp dword[ebp-4],0 ;add spaces or text

      jle .tex_add

	dec dword[ebp-4]

	mov byte [edx],' '

	jmp .u1f

      .tex_add:

      inc edi

      dec esi

    .u1f:

    add edx,sizeof.symbol

    cmp edx,[tex_end]

    jge @f ;out of memory

    cmp esi,0

    jne @b

  @@:

  pop edi edx ecx eax

  mov esp,ebp ; âîññòàíàâëèâàåì ñòåê

  pop ebp

  call CmColored

  ret

;input:

;  ecx = position to free insert cell

;  edx = pointer to sumbol, when insert

;  esi = pointer to added symbol

;output:

;  ecx = position to inserted cell

CharAdd:

  .loop_b:

    cmp ecx,[tex_end]

    jge .end_f

    cmp dword[ecx+10],0

    jne @f

      cmp dword[ecx+14],0

      je .loop_e

    @@:

    add ecx,sizeof.symbol

    jmp .loop_b

  .loop_e:

  push eax ebx

  mov eax,[ch_tim]

  mov dword[ecx+10],eax

  mov al,byte[esi]

  mov byte[ecx],al

  call GetTexArrIndex ; *** eax=pos ***

  mov [ecx+2],eax ;tex[i].perv=pos;

  m2m dword[ecx+6],dword[edx+6] ;tex[i].next=tex[pos].next;

  push edx

    mov edx,ecx

    call GetTexArrIndex ; *** eax=i ***

  pop edx

  mov [edx+6],eax ;tex[pos].next=i; // ññûëêè ïåðåíàïðàâëÿåì

  mov ebx,[ecx+6]

  ConvertIndexToPointer ebx

  mov [ebx+2],eax ;tex[tex[i].next].perv=i; // ...

  pop ebx eax

  .end_f:

  call CmColored

  ret

;input:

; conv_table = pointert to convert table

;output:

; edi = count converted symbols

ConvertSelText:

  xor edi,edi

  push eax ebx ecx edx esi

  stdcall IsSel, tedit0

  cmp al,0

  je .end_f

    call SetUndo

    call SelNormalize

    mov esi,[seln.x0]

    mov ecx,[seln.y0]

    call GetPosByParam

    mov eax,edx

    mov esi,[seln.x1]

    mov ecx,[seln.y1]

    call GetPosByParam

    ;call GetTexPervPos

    mov ebx,edx

    cmp eax,ebx

    je .end_f

    inc [ch_tim]

    mov edx,eax ;i=p0;

    mov ecx,2

    ConvertIndexToPointer ecx

    @@:

      mov esi,[edx]

      and esi,0xff

      add esi,[conv_table] ;EvUpper

      cmp byte [esi],0

      je .no_change

	m2m dword [edx+14],dword [ch_tim]

	call CharAdd ;b_pos=CharAdd(tex[i].c^32,i,false,b_pos);

	call GetTexNextPos ;go to added symbol

	inc edi

      .no_change:

      call IteratNext

      cmp edx,[tex]

      je @f

      cmp edx,ebx

      je @f

      jmp @b

    @@:

    cmp edi,0

    jne @f

      dec [ch_tim]

    @@:

  .end_f:

  pop esi edx ecx ebx eax

  ret

;input:

; bh = (0-backspace, 1-delete)

; bl = 1 - change time

;output:

; bl = 0 - no delete

; bl = 1 - delete

TextDel:

  push edx cx

  xor cl,cl

  cmp bh,1

  je @f

    call CurMoveLeft

    cmp dl,0

    je .no_del

  @@:

  call GetPos

  cmp [gpOpt],1

  je .no_del

    cmp bl,0

    je @f

      inc [ch_tim]

    @@:

    m2m dword [edx+14], dword [ch_tim]

    mov cl,1

  .no_del:

  mov bl,cl

  pop cx edx

  ret

;input:

; eax = pointer to begin select

; ebx = pointer to end select

Revers:

  cmp eax,ebx

  jne @f

    ret

  @@:

  push ecx edx

  mov edx,[tex_1]

  cmp edx,ebx ;if(p1==1)p1=tex[1].perv;

  jne @f

    call GetTexPervPos

    mov ebx,edx

  @@:

  push esi

    mov edx,[eax+2] ; *** edx = tex[p0].perv ***

    ConvertIndexToPointer edx

    add edx,6

    mov ecx,[edx] ;tmp = tex[tex[p0].perv].next;

    mov esi,[ebx+6] ; *** esi = tex[p1].next ***

    ConvertIndexToPointer esi

    add esi,2

    m2m dword[edx],dword[esi] ;tex[tex[p0].perv].next = tex[tex[p1].next].perv;

    mov [esi],ecx ;tex[tex[p1].next].perv = tmp;

  pop esi

  mov ecx,[eax+2] ;tmp = tex[p0].perv;

  m2m dword[eax+2],dword[ebx+6] ;tex[p0].perv = tex[p1].next;

  mov [ebx+6],ecx ;tex[p1].next = tmp;

  mov edx,eax ;i=p0;

  @@:

    mov ecx,[edx+6] ;tmp = tex[i].next;

    m2m dword[edx+6],dword[edx+2] ;tex[i].next = tex[i].perv;

    mov [edx+2],ecx ;tex[i].perv = tmp;

    cmp edx,ebx ;if(i==p1)break;

    je @f

; ---

;cmp edx,[tex]

;je @f

; ---

    mov edx,ecx ;i = tmp;

    ConvertIndexToPointer edx

    jmp @b

  @@:

  pop edx ecx

  call CmColored

  ret

;output:

; dl = 0 not move

; dl = 2 if move up

; dl = 8 if scroll move up

CurMoveUp:

  cmp [cur_y],0

  je @f

    dec [cur_y]

    mov dl,2

    ret

  @@:

  cmp [wScr.position],0

  je @f

    dec [wScr.position]

    mov dl,8

    ret

  @@:

  mov dl,0

  ret

;output:

; dl = 0 not move

; dl = 2 if move down

; dl = 8 if scroll move down

CurMoveDown:

  push eax

  mov dl,0

  mov eax,[wScr.cur_area]

  dec eax

  cmp [cur_y],eax

  jge @f

    inc [cur_y]

    mov dl,2

    jmp .ret_f

  @@:

  mov eax,[cur_y]

  add eax,[wScr.position]

  inc eax

  cmp [wScr.max_area],eax

  jle @f

    inc [wScr.position]

    mov dl,8

  @@:

  .ret_f:

  pop eax

  ret

;output:

; dl = 0 not move

; dl = 1 if move up

CurMovePageUp:

  push eax

  mov eax,[wScr.cur_area]

  xor dl,dl

  cmp eax,[wScr.position]

  jg @f

    sub [wScr.position],eax

    mov dl,1

  @@:

  cmp [wScr.position],0

  je @f

  cmp dl,1

  je @f

    mov [wScr.position],0

    mov dl,1

  @@:

  pop eax

  ret

CurMovePageDown:

  push eax ebx

  xor dl,dl

  mov eax,[wScr.max_area]

  sub eax,[wScr.cur_area]

  cmp [wScr.position],eax

  jge @f

    mov ebx,[wScr.cur_area]

    add [wScr.position],ebx

    mov dl,1

    mov [wScr.redraw],1

    cmp [wScr.position],eax

    jle @f

      mov [wScr.position],eax

  @@:

  pop ebx eax

  ret

;output:

; dl = 0 not move

; dl = 1 if move left

; dl = 3 if move left and up

; dl = 8 if scroll move up

CurMoveLeft:

  cmp [cur_x],0

  je @f

    dec [cur_x]

    mov dl,1

    ret

  @@:

  cmp [hScr.position],0

  je @f

    dec [hScr.position]

    mov dl,8

    ret

  @@:

  cmp [cur_y],0

  jne @f

    mov dl,0

    cmp [wScr.position],0

    je .ret_f

      dec [wScr.position]

      call OnInitialUpdate

      call CurMoveX_LastChar

      mov dl,8

    jmp .ret_f

  @@:

  cmp [cur_y],0

  je @f

  dec [cur_y]

  call CurMoveX_LastChar

  cmp dl,8

  je .ret_f

  mov dl,3

  ret

  @@:

  mov dl,0

  .ret_f:

  ret

CurMoveRight:

  push eax

  xor dl,dl

  mov eax,[hScr.cur_area]

  cmp [cur_x],eax

  jge @f

    inc [cur_x]

    mov dl,1

    jmp .ret_f

  @@:

    inc [hScr.position]

    mov dl,8

  .ret_f:

  pop eax

  ret

CurMoveX_LastChar:

;[hScr.position]

;[hScr.cur_area]

;dl-???

  push eax ebx

  mov eax,[cur_y]

  add eax,[wScr.position]

  call StrLen

  xor dl,dl

  cmp ebx,[hScr.position]

  jge @f

    mov dl,8

    mov [hScr.position],ebx

  @@:

  sub ebx,[hScr.position]

  cmp ebx,[hScr.cur_area]

  jle @f ; b---[---]---e

    add [hScr.position],ebx

    mov ebx,[hScr.cur_area]

    sub [hScr.position],ebx

    mov dl,8

  @@:

  mov [cur_x],ebx

  pop ebx eax

  ret

;output:

; dl = 0 not move

; dl = 1 move cursor

; dl = 8 move cursor and scroll

CurMoveX_FirstChar:

  xor dl,dl

  cmp [cur_x],0

  je @f

  mov [cur_x],0

  mov dl,1

  @@:

  cmp [hScr.position],0

  je @f

    mov [hScr.position],0

    mov dl,8

  @@:

  ret

;input:

; edx = pointer to symbol struct

;output:

; eax = array index

GetTexArrIndex:

  push ecx edx

  mov eax,edx

  sub eax,[tex]

  xor edx,edx

  mov ecx,sizeof.symbol

  div ecx

  pop edx ecx

  ret

;input:

; edx = pointer to symbol struct

;output:

; edx = pointer to 'perv' struct

GetTexPervPos:

  push dword [edx+2]

  pop edx

  imul edx,sizeof.symbol

  add edx,[tex]

  ret

;input:

; edx = pointer to symbol struct

;output:

; edx = pointer to 'next' symbol struct

GetTexNextPos:

  push dword [edx+6]

  pop edx

  imul edx,sizeof.symbol

  add edx,[tex]

  ret

;output:

; edx = symbol under cursor

; gpOpt = 1,2

; edx = tex[1].perv if error

; gpOpt = 0

GetPos:

  push esi ecx

    mov esi,[cur_x]

    add esi,[hScr.position]

    mov ecx,[cur_y]

    add ecx,[wScr.position]

    call GetPosByParam

  pop ecx esi

  ret

;input:

; esi = XPos

; ecx = YPos

;output:

; edx = symbol under cursor

; gpOpt = 1 if found text line

; gpOpt = 2 if found text line and column

; edx = tex[1] if error

; gpOpt = 0 if text no found

GetPosByParam:

  push eax ;Row

  push ebx ;Col

  xor eax,eax

  xor ebx,ebx

  mov [gpOpt],0

  mov edx,[tex]

  @@:

    call IteratNext

    cmp edx,[tex_1]

    jle @f

    cmp ebx,esi