WebSVN – Kolibri OS – Diff – /programs/other/t_edit/t_work.inc


struct f70
  func_n dd ?
  param1 dd ?
  param2 dd ?
  param3 dd ?
  param4 dd ?
  rezerv db ?
  name dd ?
ends
 
struct TexSelect
  x0 dd ?
  y0 dd ?
  x1 dd ?
  y1 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_opn db 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
 
hed db 'TextEditor 30.12.09',0 ;ïîäïèñü îêíà
sc system_colors
 
wndMain BOX 0,50,440,150
recMain BOX 30,23,7,10
 
curMod db 1
cur_x dd 0
cur_y dd 0
invis db 0 ;ðåæèì ïîêàçà íåïå÷àòàåìûõ ñèìâîëîâ
symbol_new_line db 20 ;ñèìâîë çàâåðøåíèÿ ñòðîêè
dragm db 0 ;âûäåëåíèå îò ìûøè
dragk db 0 ;âûäåëåíèå îò êëàâèàòóðû
sel TexSelect 0,0,0,0 ;ñòðóêòóðà âûäåëåíèÿ
seln TexSelect ;äîïîëíèòåëüíàÿ ñòðóêòóðà âûäåëåíèÿ
help_id dd -1  ;èäåíòèôèêàòîð äëÿ ñïðàâêè
 
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
IsSel:
  push ebx
  xor al,al
  cmp [dragm],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 ebx
  ret
 
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,fn_col_option
;  mov  esi,sys_path
;  mov  edi,file_name
  mov  ebx,dword[fn_col_option]
  copy_path ebx,fn_syntax_dir,file_name_rez
  copy_path file_name_rez,sys_path,file_name
 
  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
 
  ;copy new colors in dir_list
;  m2m dword[eax+28],dword[WND_WORK_COLOR]
;  m2m dword[eax+32],dword[SELECT_COLOR]
;  m2m dword[eax+36],dword[WND_CAPT_COLOR]
;  m2m dword[eax+40],dword[WND_TEXT_COLOR]
;  m2m dword[eax+44],dword[CUR_TEXT_COLOR]
  
  .no_colors:
  pop edi esi ecx ebx eax
  ret
 
 
;input:
; ebx = file size
OpenFile:
  mov [err_opn],0
  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
  call IsSel
  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
    jne .u1_0 ;Col <> cur_x
      mov [gpOpt],1
      cmp eax,ecx
      jge @f ; Row >= cur_y
    .u1_0:
    mov [gpOpt],0
    inc ebx
    cmp byte [edx],13
    jne @b
    cmp eax,ecx
    jge @f ; Row >= cur_y
    inc eax
    xor ebx,ebx
    jmp @b
  @@:
  cmp eax,ecx
  jne @f ; Row = cur_y
    inc [gpOpt]
  @@:
  cmp [gpOpt],0
  jne @f
    mov edx,[tex_1]
    ;call GetTexPervPos
  @@:
  pop ebx eax
  ret
 
 
;input:
; eax = Row
;output:
; ebx = str len
StrLen:
  push edx ecx
  ;ecx = Row, from cycle
 
  xor ebx,ebx
  xor ecx,ecx
  mov edx,[tex]
  @@:
    call IteratNext
    cmp edx,[tex_1]
    jle @f 
    inc ebx
    cmp byte [edx],13
    jne @b
    dec ebx ;lenght minus 1 sumbol to paragraph
    cmp eax,ecx
    je @f
    xor ebx,ebx
    inc ecx
    jmp @b
  @@:
 
  cmp eax,ecx
  je @f
    xor ebx,ebx
  @@:
 
  pop ecx edx
  ret
 
 
;output:
; edx = symbol position
;output:
; eax = number of line
; ebx = symbol position in line
GetTexCoords:
  push edx
  xor eax,eax
  xor ebx,ebx
  @@:
    call IteratPerv
 
    cmp eax,0
    jne .no_col_mov
    inc ebx
    .no_col_mov:
 
    cmp edx,[tex_1]
    jle @f
    cmp byte [edx],13
    jne @b
    inc eax
    jmp @b
  @@:
  dec ebx
  pop edx
  ret
 
;output:
; eax = num lines
GetNumLines:
  push edx
  mov eax,1
  mov edx,[tex]
  @@:
    call IteratNext
    cmp edx,[tex_1]
    jle @f
    cmp byte [edx],13
    jne @b
    inc eax
    jmp @b
  @@:
;...
;dec eax
  pop edx
  ret
 
SetUndo:
  mov [dragk],0 ;çàêàí÷èâàåì âûäåëåíèå îò êëàâèàòóðû
  cmp [tim_Undo],1
  jl .no_work
 
  push eax ebx edx
  mov edx,[tex]
  call GetTexNextPos ;long i=tex[0].next;
  mov eax,[tim_Undo]
  sub [ch_tim],eax ;ch_tim-=tim_Undo;
  mov eax,[ch_tim]
  cmp [ls_tim],eax ;if(ls_tim>ch_tim)
  jle @f
    mov dword [ls_tim],0
  @@:
    cmp edx,[tex]
    je @f
 
    ;if(tex[i].tc>ch_tim){ // åñëè ñîçäàíèå ñèìâîëà áûëî îòìåíåíî
    cmp [edx+10],eax
    jle .no_u1
      mov dword [edx+10],0
      mov dword [edx+14],0
 
      mov ebx,[edx+2]
      imul ebx,sizeof.symbol
      add ebx,[tex];.next
      m2m dword [ebx+6],dword [edx+6] ;tex[tex[i].perv].next=tex[i].next;
 
      mov ebx,[edx+6]
      imul ebx,sizeof.symbol
      add ebx,[tex];.perv
      m2m dword [ebx+2],dword [edx+2] ;tex[tex[i].next].perv=tex[i].perv;
 
    .no_u1:
 
    ;else if(tex[i].td>ch_tim) tex[i].td=0; // åñëè óäàëåíèå ñèìâîëà áûëî îòìåíåíî
    cmp [edx+14],eax
    jle .no_u2
      mov dword [edx+14],0
    .no_u2:
 
    call GetTexNextPos
    jmp @b
  @@:
  mov dword [tim_Undo],0
  mov eax,[co_tim]
  cmp [ch_tim],eax
  jge @f
    mov [co_tim],0
  @@:
  pop edx ebx eax
  .no_work:
  ret
 
;input:
; ecx = Col
; edx = Row
GoToPos:
  mov [cur_x],ecx
  sub edx,[wScr.position]
 
  cmp edx,[wScr.cur_area] ;[cur_y] > [.cur_area]
  jl @f
    push ebx
    mov ebx,edx
    sub ebx,[wScr.cur_area]
    inc ebx
    add [wScr.position],ebx
    sub edx,ebx
    pop ebx
    ; ??? redrav
  @@:
  mov [cur_y],edx
  ret
 
;input:
; bl = 1 change time when delete text
;output:
; al = 1 if delete
SelTextDel:
  call IsSel
  cmp al,0
  jne @f
  ret
  @@:
  ;call SelEnd
  call SelNormalize
  push esi edi ecx edx
    mov esi,[seln.x1]
    mov ecx,[seln.y1]
    call GetPosByParam
    mov edi,edx
 
    mov esi,[seln.x0]
    mov ecx,[seln.y0]
    call GetPosByParam
 
    cmp bl,0
    je @f
      inc [ch_tim]
 
    @@:
      cmp edx,[tex]
      je @f
      cmp edx,edi ;if(i==te)break;
      je @f
      m2m dword[edx+14],dword[ch_tim]
      xor bl,bl   ;n_tim=false;
      call IteratNext
      jmp @b
    @@:
    cmp bl,0
    je @f
      dec [ch_tim]
      xor al,al
    @@:
    cmp bl,0
    jne @f
      mov ecx,[seln.x0]
      mov edx,[seln.y0]
      call GoToPos
      mov [sel.x0],0
      mov [sel.y0],0
      mov [sel.x1],0
      mov [sel.y1],0
    @@:
  pop edx ecx edi esi
 
  ret
 
 
CmColored:
  push eax edx
  mov eax,[ch_tim]
  sub eax,[tim_Undo]
  mov dword[co_tim],eax
  mov edx,[tex]
  @@:
    call IteratNext
    cmp edx,[tex_1]
    jle @f
    mov byte[edx+1],0
    jmp @b
  @@:
 
  cmp dword[ColWords],1
  jl .no_colors
  mov edx,[tex]
  @@:
    call TextFSColor
    cmp edx,[tex_1]
    jle .no_colors
    jmp @b
  .no_colors:
  pop edx eax
  ret
 
 
 
;input:
; edx = pointer to start symbol
;output:
; edx = pointer to next symbol
TextFSColor:
  ;eax = word_n
  ;ecx = l_pos
  push ebp
  mov ebp,esp
  sub esp,10 ;2*4+2*1
  ;bP  = dword[ebp-4]
  ;eP  = dword[ebp-8]
  ;fnd = byte[ebp-12]
  ;f_color = byte[ebp-13]
 
  push eax ebx ecx esi edi
  mov dword[ebp-4],1
  mov dword[ebp-4],1
  mov byte[ebp-12],0
  mov byte[ebp-13],1
  @@:
    call IteratNext
    cmp edx,[tex_1]
    jle @f
 
    xor ebx,ebx
    mov bl,byte[edx]
;mov byte[buf],bl
;mov byte[buf+1],0
    shl bx,2 ;ebx*=4
    add ebx,FkPos
    mov eax,dword[ebx]
    cmp eax,0
    jl @b ;if( (word_n=FkPos[(unsigned char)tex[i].c])>-1 ){
 
    mov ecx,eax
    ;while(l_pos
    .wh_1b:
      cmp ecx,dword[ColWords]
      jge .wh_1e
      ColToIndexOffset ecx,esi
      mov bh,byte[esi]
      ColToIndexOffset eax,esi
      mov bl,byte[esi]
      cmp bh,bl
      jne .wh_1e
	inc ecx
      jmp .wh_1b
    .wh_1e:
 
    mov dword[ebp-4],edx ;bP=i;
    mov edi,1
 
    .wh_2b: ;while(1){
      call IteratNext
 
      ;while(l_pos>word_n && Col[keyw[l_pos-1]].Text[pos]!=tex[i].c)
      .wh_3b:
	cmp ecx,eax
	jle .wh_3e
	dec ecx
	ColToIndexOffset ecx,ebx
	inc ecx
	;cmp byte[ebx+edi],byte[edx]
	push ax
	  mov al,byte[ebx+edi]
	  mov bl,al
	pop ax
	cmp bl,byte[edx]
	je .wh_3e
	  dec ecx
	jmp .wh_3b
      .wh_3e:
 
      ColToIndexOffset eax,ebx
      cmp byte[ebx+edi],0
      jne .if_0 ;if(Col[keyw[word_n]].Text[pos]==0){
	mov dword[ebp-8],edx ;eP=i;
	ColToIndexOffset eax,esi
	mov bl,byte[esi+MAX_COLOR_WORD_LEN+6]
	mov byte[ebp-13],bl ;f_color=Col[keyw[word_n]].color;
 
mov byte[ebp-12],1
;... esi = Col[keyw[word_n]]
	  mov bl,byte[esi+MAX_COLOR_WORD_LEN+4]
	  cmp bl,0 ;if(Col[keyw[word_n]].wwo)
	  je .if_2n
	    push edx
	    mov edx,dword[ebp-4]
     call IteratPerv
;           mov bh,bl
 
	    btr bx,0 ;1-1
	    jae .if_3e ;if(Col[keyw[word_n]].wwo&1)
	      ;u1= !(isalnum(cont_s)||cont_s=='_')
	      call isalnum
	      jae .if_3e
		mov byte[ebp-12],0
	    .if_3e:
 
	    btr bx,3 ;4-1
	    jae .if_4e ;if(Col[keyw[word_n]].wwo&8)
	      ;u1= !isalpha(cont_s);
	      call isalpha
	      jae .if_4e
		mov byte[ebp-12],0
	    .if_4e:
 
 
	    mov edx,dword[ebp-8]
;     call IteratNext
 
	    btr bx,1 ;2-1
	    jae .if_5e ;if(Col[keyw[word_n]].wwo&2)
	      ;u1= !(isalnum(cont_s)||cont_s=='_')
	      call isalnum
	      jae .if_5e
		mov byte[ebp-12],0
	    .if_5e:
 
	    btr bx,4 ;5-1
	    jae .if_6e ;if(Col[keyw[word_n]].wwo&16)
	      ;u1= !isalpha(cont_s);
	      call isalpha
	      jae .if_6e
		mov byte[ebp-12],0
	    .if_6e:
 
	    btr bx,2 ;3-1
	    jae .if_7e ;if(Col[keyw[word_n]].wwo&4)
       mov bl,byte[esi+MAX_COLOR_WORD_LEN+5]
	      call ItPoNextUc
       cmp edx,[tex_1]
       jle .if_7e
       mov dword[ebp-8],edx
	    .if_7e:
 
	    pop edx
	  .if_2n:
;                 if(i!=1){ // íå êîíåö äîêóìåíòà
;                   cont_s=tex[eP].c;
;                   if(Col[keyw[word_n]].wwo&2) u2= !(isalnum(cont_s)||cont_s=='_');  // íå áóêâ.-÷èñë. ñèìâîë
;                   if(u2 && Col[keyw[word_n]].wwo&16) u2= !isalpha(cont_s); // íå ÷èñë. ñèìâîë
;                   if(Col[keyw[word_n]].wwo&4) eP=ItPoNextUc(eP,Col[keyw[word_n]].endc);
 
	cmp eax,ecx
	je .wh_2e ;if(word_n==l_pos) break; // do double - åñëè ñëîâî òî÷íî ïîñëåäíåå
      .if_0:
 
      cmp edx,[tex_1]
      jle .wh_2e ;if(i==1) break;
 
      ;while(l_pos>word_n && Col[keyw[word_n]].Text[pos]!=tex[i].c)
      .wh_4b:
	cmp ecx,eax
	jle .wh_4e
	ColToIndexOffset eax,ebx
	;cmp byte[ebx+edi],byte[edx]
	push ax
	  mov al,byte[ebx+edi]
	  mov bl,al
	pop ax
	cmp bl,byte[edx]
	je .wh_4e
	  inc eax
	jmp .wh_4b
      .wh_4e:
 
      cmp eax,ecx
      je .wh_2e;if(word_n==l_pos) break;
      inc edi ;pos++;
      jmp .wh_2b
    .wh_2e:
 
    cmp byte[ebp-12],1 ;if(fnd)break;
    je @f
    mov edx,dword[ebp-4];i=bP;
    jmp @b
  @@:
 
  cmp byte[ebp-12],1
  jne .if_1e ;if(fnd){ // âûäåëåíèå íàéäåíîãî òåêñòà
;    if(!mode_sf1 || (mode_sf1 && strlen(Col[keyw[word_n]].f1->c_str())>0)){
    mov eax,dword[ebp-4]
    mov bl,byte[ebp-13]
    mov byte[eax+1],bl ;tex[bP].col=f_color;
    mov eax,dword[ebp-8]
    mov byte[eax+1],0xff ;tex[eP].col=255;
;    return ItPoPerv(eP); // âîçâðàùàåì ïîçèöèþ êîíöà âõîæäåíèÿ
    mov edx,dword[ebp-8]
    call GetTexPervPos
    jmp @f
  .if_1e:
    mov edx,[tex]
  @@:
 
  pop edi esi ecx ebx eax
  mov esp,ebp
  pop ebp
  ret
 
 
;input:
; edx = pointer to char (byte)
;output:
; cf=1 if symbol is...
tab_all_num db 0,0,0,0,0,0,11111111b,11b,11111110b,0xff,0xff,111b,11111110b,0xff,0xff,111b,0,0,0,0,0,0,0,0,0,0;,0,0,0,0,0,0 - tab_alpha_0,0,0,0,0,0
tab_alpha db 0,0,0,0,0,0,0,0,11111110b,0xff,0xff,111b,11111110b,0xff,0xff,111b,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
  ;db 0,0,0,0,0,0,11111111b,11b,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
isalnum:
  push eax ebx
  mov al,byte[edx] ;al=offset
  shr al,3
  and eax,11111b
  mov ebx,tab_all_num
  add ebx,eax
  mov ah,byte[ebx]
  mov al,byte[edx] ;al=bit
  and ax,111b
  m2m bx,word[ebx]
  btr bx,ax
  pop ebx eax
  ret
isalpha:
  push eax ebx
  mov al,byte[edx] ;al=offset
  shr al,3
  and eax,11111b
  mov ebx,tab_alpha
  add ebx,eax
  mov ah,byte[ebx]
  mov al,byte[edx] ;al=bit
  and ax,111b
  m2m bx,word[ebx]
  btr bx,ax
  pop ebx eax
  ret
 
 
ShowHelpF1:
  push eax edx
 
  call GetPos
  push edx
    call ItNextColorTag
    mov eax,edx
  pop edx
  call ItPervColorTag
 
  cmp eax,[tex]
  jle @f
  cmp edx,[tex_1]
  jle @f
    call FindHelpId
  @@:
  pop edx eax
  ;call draw_main_cursor
  call draw_help_f1
  ret 
 
;input:
; edx = position begin 'symbol' struct
; eax = position end 'symbol' struct
FindHelpId:
; ecx = word_n
; ebx = l_pos
  mov [help_id],-1
 
  push ebx ecx
    xor ebx,ebx
    mov bl,byte[edx]
    shl bx,2 ;ebx*=4
    add ebx,FkPos
    mov ecx,dword[ebx]
    cmp ecx,0
    jl .if_0e ;if( (word_n=FkPos[(unsigned char)tf[0]])>-1 ){
      push esi edi
      mov ebx,ecx ;l_pos=word_n;
      ColToIndexOffset ecx,esi
      push cx
      mov cl,byte[esi]
      @@:
	cmp ebx,dword[ColWords] ;while(l_pos
	jge @f
	;ColToIndexOffset ecx,esi
	ColToIndexOffset ebx,edi
	cmp cl,byte[edi] ;&& Col[keyw[l_pos]].Text[0]==Col[keyw[word_n]].Text[0])
	jne @f
	  inc ebx ;l_pos++;
	  jmp @b
      @@:
      pop cx
      call IteratNext ;pos=1;
      mov esi,1
      @@:
	push dx
	push word[edx]
	pop dx 
	  .wh_0b:
	    cmp ebx,ecx ;while(l_pos>word_n
	    jle .wh_0e
	    dec ebx
	    ColToIndexOffset ebx,edi
	    inc ebx
	    cmp byte[edi+esi],dl ;&& Col[keyw[l_pos-1]].Text[pos]!=tf[i])
	    je .wh_0e
	      dec ebx ;l_pos--;
	    jmp .wh_0b
	  .wh_0e:
 
	  .wh_1b:
	    cmp ebx,ecx ;while(l_pos>word_n
	    jle .wh_1e
	    ColToIndexOffset ecx,edi
	    cmp byte[edi+esi],dl
	    je .wh_1e
	      inc ecx ;word_n++;
	    jmp .wh_1b
	  .wh_1e:
	pop dx
 
	cmp ecx,ebx ;if(word_n==l_pos) break;
	je @f
	call IteratNext ;pos++;
	cmp edx,eax ;for(...;i
	je @f ;jge
	inc esi
	jmp @b
      @@:
      pop edi esi
 
      mov dword[help_id],ecx
      ;return keyw[word_n];
 
    .if_0e:
  pop ecx ebx
  ret
>
>
>

Rev 1338	Rev 1343
1	struct f70	1	struct f70
2	func_n dd ?	2	func_n dd ?
3	param1 dd ?	3	param1 dd ?
4	param2 dd ?	4	param2 dd ?
5	param3 dd ?	5	param3 dd ?
6	param4 dd ?	6	param4 dd ?
7	rezerv db ?	7	rezerv db ?
8	name dd ?	8	name dd ?
9	ends	9	ends
10		10
11	struct TexSelect	11	struct TexSelect
12	x0 dd ?	12	x0 dd ?
13	y0 dd ?	13	y0 dd ?
14	x1 dd ?	14	x1 dd ?
15	y1 dd ?	15	y1 dd ?
16	ends	16	ends
17		17
18	struct TexColViv	18	struct TexColViv
19	Text rb MAX_COLOR_WORD_LEN; // ñëîâî	19	Text rb MAX_COLOR_WORD_LEN; // ñëîâî
20	f1 dd 0	20	f1 dd 0
21	wwo db ? ; whole words only	21	wwo db ? ; whole words only
22	endc db ? ; ñèìâîë êîíöà âûäåëåíèÿ (wwo&4)	22	endc db ? ; ñèìâîë êîíöà âûäåëåíèÿ (wwo&4)
23	color db ? ; íîìåð öâåòà	23	color db ? ; íîìåð öâåòà
24	ends	24	ends
25		25
26	struct symbol	26	struct symbol
27	c db ? ; +0 ñèìâîë	27	c db ? ; +0 ñèìâîë
28	col db ? ; +1 öâåò	28	col db ? ; +1 öâåò
29	perv dd ? ; +2	29	perv dd ? ; +2
30	next dd ? ; +6 óêàçàòåëè	30	next dd ? ; +6 óêàçàòåëè
31	tc dd ? ; +10 âðåì. ñîçäàíèÿ	31	tc dd ? ; +10 âðåì. ñîçäàíèÿ
32	td dd ? ; +14 âðåì. óäàëåíèÿ	32	td dd ? ; +14 âðåì. óäàëåíèÿ
33	ends	33	ends
34		34
35	ColColor dd 1	35	ColColor dd 1
36	ColWords dd 0	36	ColWords dd 0
37	CURSOR_COLOR dd 0x808080	37	CURSOR_COLOR dd 0x808080
38	WND_CAPT_COLOR dd 0x80	38	WND_CAPT_COLOR dd 0x80
39	WND_WORK_COLOR dd 0x0	39	WND_WORK_COLOR dd 0x0
40	WND_BORD_COLOR dd 0xd0d0d0	40	WND_BORD_COLOR dd 0xd0d0d0
41	SELECT_COLOR dd 0x208080	41	SELECT_COLOR dd 0x208080
42	CUR_TEXT_COLOR dd 0xff0000	42	CUR_TEXT_COLOR dd 0xff0000
43	WND_TEXT_COLOR dd 0xffff00	43	WND_TEXT_COLOR dd 0xffff00
44		44
45	options_file dd 0	45	options_file dd 0
46	options_file_end dd 0	46	options_file_end dd 0
47	tex_colors dd 0	47	tex_colors dd 0
48	tex_help_f1 dd 0	48	tex_help_f1 dd 0
49		49
50	FkPos: rd 256	50	FkPos: rd 256
51	Col dd 0 ;óêàçàòåëü íà ñòðóêòóðû êëþ÷åâûõ ñëîâ TexColViv	51	Col dd 0 ;óêàçàòåëü íà ñòðóêòóðû êëþ÷åâûõ ñëîâ TexColViv
52		52
53	conv_tabl rb 128 ; òàáëèöà äëÿ êîíâåðòèðîâàíèÿ scan-êîäà â ascii-êîä	53	conv_tabl rb 128 ; òàáëèöà äëÿ êîíâåðòèðîâàíèÿ scan-êîäà â ascii-êîä
54	keyUpr dd 0	54	keyUpr dd 0
55	err_opn db 0 ;îøèáêà îòêðûòèÿ ôàéëà	55	err_opn db 0 ;îøèáêà îòêðûòèÿ ôàéëà
56	err_sav db 0 ;îøèáêà ñîõðàíåíèÿ ôàéëà	56	err_sav db 0 ;îøèáêà ñîõðàíåíèÿ ôàéëà
57	panel_id db 0 ;íîìåð îòêðûòîé ïàíåëè	57	panel_id db 0 ;íîìåð îòêðûòîé ïàíåëè
58		58
59	ch_tim dd ? ; êîëè÷åñòâî èçìåíåíèé â ôàéëå	59	ch_tim dd ? ; êîëè÷åñòâî èçìåíåíèé â ôàéëå
60	ls_tim dd ? ; âðåìÿ ïîñëåäíåãî ñîõðàíåíèÿ	60	ls_tim dd ? ; âðåìÿ ïîñëåäíåãî ñîõðàíåíèÿ
61	co_tim dd ? ; âðåìÿ ïîñëåäíåé öâåòîâîé ðàçìåòêè	61	co_tim dd ? ; âðåìÿ ïîñëåäíåé öâåòîâîé ðàçìåòêè
62	tim_Undo dd ? ; êîëè÷åñòâî îòìåíåííûõ äåéñòâèé	62	tim_Undo dd ? ; êîëè÷åñòâî îòìåíåííûõ äåéñòâèé
63	gpOpt db 0	63	gpOpt db 0
64	mode_colored db 1 ; ðåæèì âûäåëåíèÿ ñëîâ öâåòîì (0-âûêë. 1-âêë.)	64	mode_colored db 1 ; ðåæèì âûäåëåíèÿ ñëîâ öâåòîì (0-âûêë. 1-âêë.)
65		-
66	txtBuf db 'ãä¥à: '	-
67	buf db BUF_SIZE dup(0)	65
68	key_new db 0 ; ñèìâîë, êîòîðûé áóäåò äîáàâëÿòñÿ ñ êëàâèàòóðû	66	key_new db 0 ; ñèìâîë, êîòîðûé áóäåò äîáàâëÿòñÿ ñ êëàâèàòóðû
69	tex dd 0	67	tex dd 0 ;text memory pointer
70	tex_1 dd 0	68	tex_1 dd 0 ;text first symbol pointer
71	tex_end dd 0	69	tex_end dd 0 ;text end memory pointer
72		70
73	hed db 'TextEditor 29.12.09',0 ;ïîäïèñü îêíà	71	hed db 'TextEditor 30.12.09',0 ;ïîäïèñü îêíà
74	sc system_colors	72	sc system_colors
75		73
76	wndMain BOX 0,50,440,150	74	wndMain BOX 0,50,440,150
77	recMain BOX 30,23,7,10	75	recMain BOX 30,23,7,10
78		76
79	curMod db 1	77	curMod db 1
80	cur_x dd 0	78	cur_x dd 0
81	cur_y dd 0	79	cur_y dd 0
82	invis db 0 ;ðåæèì ïîêàçà íåïå÷àòàåìûõ ñèìâîëîâ	80	invis db 0 ;ðåæèì ïîêàçà íåïå÷àòàåìûõ ñèìâîëîâ
83	symbol_new_line db 20 ;ñèìâîë çàâåðøåíèÿ ñòðîêè	81	symbol_new_line db 20 ;ñèìâîë çàâåðøåíèÿ ñòðîêè
84	dragm db 0 ;âûäåëåíèå îò ìûøè	82	dragm db 0 ;âûäåëåíèå îò ìûøè
85	dragk db 0 ;âûäåëåíèå îò êëàâèàòóðû	83	dragk db 0 ;âûäåëåíèå îò êëàâèàòóðû
86	sel TexSelect 0,0,0,0 ;ñòðóêòóðà âûäåëåíèÿ	84	sel TexSelect 0,0,0,0 ;ñòðóêòóðà âûäåëåíèÿ
87	seln TexSelect ;äîïîëíèòåëüíàÿ ñòðóêòóðà âûäåëåíèÿ	85	seln TexSelect ;äîïîëíèòåëüíàÿ ñòðóêòóðà âûäåëåíèÿ
88	help_id dd -1 ;èäåíòèôèêàòîð äëÿ ñïðàâêè	86	help_id dd -1 ;èäåíòèôèêàòîð äëÿ ñïðàâêè
89		87
90	fn_icon db 'te_icon.bmp',0	88	fn_icon db 'te_icon.bmp',0
91	bmp_icon dd 0	89	bmp_icon dd 0
92	run_file_70 f70	90	run_file_70 f70
93		91
94		92
95	;input:	93	;input:
96	; reg = index	94	; reg = index
97	;output:	95	;output:
98	; reg = pointer to 'tex' struct	96	; reg = pointer to 'tex' struct
99	macro ConvertIndexToPointer reg {	97	macro ConvertIndexToPointer reg {
100	imul reg,sizeof.symbol	98	imul reg,sizeof.symbol
101	add reg,[tex]	99	add reg,[tex]
102	}	100	}
103		101
104		102
105	;output:	103	;output:
106	; al = 1 - can save	104	; al = 1 - can save
107	CanSave:	105	CanSave:
108	push ecx	106	push ecx
109	mov ecx,[ch_tim]	107	mov ecx,[ch_tim]
110	sub ecx,[tim_Undo]	108	sub ecx,[tim_Undo]
111	mov al,1	109	mov al,1
112	cmp [ls_tim],ecx	110	cmp [ls_tim],ecx
113	jne @f	111	jne @f
114	dec al	112	dec al
115	@@:	113	@@:
116	pop ecx	114	pop ecx
117	ret	115	ret
118		116
119		117
120	;output:	118	;output:
121	; al = 1 - selected	119	; al = 1 - selected
122	IsSel:	120	IsSel:
123	push ebx	121	push ebx
124	xor al,al	122	xor al,al
125	cmp [dragm],1	123	cmp [dragm],1
126	je @f	124	je @f
127	mov al,1	125	mov al,1
128	mov ebx,[sel.x0]	126	mov ebx,[sel.x0]
129	cmp ebx,[sel.x1]	127	cmp ebx,[sel.x1]
130	jne @f	128	jne @f
131	mov ebx,[sel.y0]	129	mov ebx,[sel.y0]
132	cmp ebx,[sel.y1]	130	cmp ebx,[sel.y1]
133	jne @f	131	jne @f
134	xor al,al	132	xor al,al
135	@@:	133	@@:
136	pop ebx	134	pop ebx
137	ret	135	ret
138		136
139	SelNormalize:	137	SelNormalize:
140	push ecx esi edi	138	push ecx esi edi
141	mov esi,sel	139	mov esi,sel
142	mov edi,seln	140	mov edi,seln
143	mov ecx,sizeof.TexSelect	141	mov ecx,sizeof.TexSelect
144	rep movsb	142	rep movsb
145		143
146	jmp @f	144	jmp @f
147	.swp_f:	145	.swp_f:
148	mov ecx,[seln.x0]	146	mov ecx,[seln.x0]
149	m2m [seln.x0],[seln.x1]	147	m2m [seln.x0],[seln.x1]
150	mov [seln.x1],ecx	148	mov [seln.x1],ecx
151		149
152	mov ecx,[seln.y0]	150	mov ecx,[seln.y0]
153	cmp ecx,[seln.y1] ;(sel.y0>sel.y1)	151	cmp ecx,[seln.y1] ;(sel.y0>sel.y1)
154	jle .end_f	152	jle .end_f
155	m2m [seln.y0],[seln.y1]	153	m2m [seln.y0],[seln.y1]
156	mov [seln.y1],ecx	154	mov [seln.y1],ecx
157		155
158	jmp .end_f	156	jmp .end_f
159	@@:	157	@@:
160		158
161	mov ecx,[seln.y0]	159	mov ecx,[seln.y0]
162	cmp ecx,[seln.y1] ;(sel.y0>sel.y1)	160	cmp ecx,[seln.y1] ;(sel.y0>sel.y1)
163	jg .swp_f	161	jg .swp_f
164		162
165	cmp ecx,[seln.y1] ;(sel.y0==sel.y1)	163	cmp ecx,[seln.y1] ;(sel.y0==sel.y1)
166	jne .end_f	164	jne .end_f
167	mov ecx,[seln.x0]	165	mov ecx,[seln.x0]
168	cmp ecx,[seln.x1] ;(sel.x0>sel.x1)	166	cmp ecx,[seln.x1] ;(sel.x0>sel.x1)
169	jg .swp_f	167	jg .swp_f
170		168
171	.end_f:	169	.end_f:
172	pop edi esi ecx	170	pop edi esi ecx
173	ret	171	ret
174		172
175	SelStart:	173	SelStart:
176	push ecx	174	push ecx
177	mov ecx,[cur_x]	175	mov ecx,[cur_x]
178	add ecx,[hScr.position]	176	add ecx,[hScr.position]
179	mov [sel.x0],ecx	177	mov [sel.x0],ecx
180	mov [sel.x1],ecx	178	mov [sel.x1],ecx
181		179
182	mov ecx,[cur_y]	180	mov ecx,[cur_y]
183	add ecx,[wScr.position]	181	add ecx,[wScr.position]
184	mov [sel.y0],ecx	182	mov [sel.y0],ecx
185	mov [sel.y1],ecx	183	mov [sel.y1],ecx
186	pop ecx	184	pop ecx
187	ret	185	ret
-		186
188		187	align 4
189	SelMove:	188	SelMove:
190	push ecx	189	push ecx
191	mov ecx,[cur_x]	190	mov ecx,[cur_x]
192	add ecx,[hScr.position]	191	add ecx,[hScr.position]
193	mov [sel.x1],ecx	192	mov [sel.x1],ecx
194		193
195	mov ecx,[cur_y]	194	mov ecx,[cur_y]
196	add ecx,[wScr.position]	195	add ecx,[wScr.position]
197	mov [sel.y1],ecx	196	mov [sel.y1],ecx
198	pop ecx	197	pop ecx
-		198	call draw_but_toolbar ;redraw toolbar (need to button Copy)
199	ret	199	ret
200		200
201	;input:	201	;input:
202	; al = 1 - clear all memory	202	; al = 1 - clear all memory
203	Clear:	203	Clear:
204	mov [cur_x],0	204	mov [cur_x],0
205	mov [cur_y],0	205	mov [cur_y],0
206	mov [ch_tim],0	206	mov [ch_tim],0
207	mov [ls_tim],0	207	mov [ls_tim],0
208	mov [co_tim],0	208	mov [co_tim],0
209	mov [tim_Undo],0	209	mov [tim_Undo],0
210	mov [help_id],-1	210	mov [help_id],-1
211		211
212	mov [wScr.position],0	212	mov [wScr.position],0
213	mov [wScr.max_area],100	213	mov [wScr.max_area],100
214	mov [wScr.redraw],1	214	mov [wScr.redraw],1
215	mov [hScr.position],0	215	mov [hScr.position],0
216	mov [hScr.max_area],100	216	mov [hScr.max_area],100
217		217
218	mov [sel.x0],0	218	mov [sel.x0],0
219	mov [sel.y0],0	219	mov [sel.y0],0
220	mov [sel.x1],0	220	mov [sel.x1],0
221	mov [sel.y1],0	221	mov [sel.y1],0
222		222
223	cmp al,0	223	cmp al,0
224	je .exit	224	je .exit
225		225
226	push ecx edx	226	push ecx edx
227	mov ecx,sizeof.symbol*maxChars	227	mov ecx,sizeof.symbol*maxChars
228	mov edx,[tex]	228	mov edx,[tex]
229	@@:	229	@@:
230	mov byte [edx],0	230	mov byte [edx],0
231	inc edx	231	inc edx
232	loop @b	232	loop @b
233	mov edx,[tex]	233	mov edx,[tex]
234	mov dword [edx+6],1	234	mov dword [edx+6],1
235	pop edx ecx	235	pop edx ecx
236		236
237	.exit:	237	.exit:
238	ret	238	ret
239		239
240		240
241	;--- out_reg = Col[keyw[ind_reg]].Text[0] ---	241	;--- out_reg = Col[keyw[ind_reg]].Text[0] ---
242	macro ColToIndexOffset ind_reg,out_reg {	242	macro ColToIndexOffset ind_reg,out_reg {
243	mov out_reg,ind_reg	243	mov out_reg,ind_reg
244	imul out_reg,sizeof.TexColViv	244	imul out_reg,sizeof.TexColViv
245	add out_reg,[Col]	245	add out_reg,[Col]
246	}	246	}
247		247
248		248
249		249
250	InitColText:	250	InitColText:
251	push eax ebx ecx esi edi	251	push eax ebx ecx esi edi
252		252
253	; mov ebx,fn_col_option	253	; mov ebx,fn_col_option
254	; mov esi,sys_path	254	; mov esi,sys_path
255	; mov edi,file_name	255	; mov edi,file_name
256	mov ebx,dword[fn_col_option]	256	mov ebx,dword[fn_col_option]
257	copy_path ebx,fn_syntax_dir,file_name_rez	257	copy_path ebx,fn_syntax_dir,file_name_rez
258	copy_path file_name_rez,sys_path,file_name	258	copy_path file_name_rez,sys_path,file_name
259		259
260	mov eax,70	260	mov eax,70
261	mov [run_file_70.func_n], 0	261	mov [run_file_70.func_n], 0
262	mov [run_file_70.param1], 0	262	mov [run_file_70.param1], 0
263	mov [run_file_70.param2], 0	263	mov [run_file_70.param2], 0
264	mov ebx,[options_file_end]	264	mov ebx,[options_file_end]
265	sub ebx,[options_file]	265	sub ebx,[options_file]
266	mov [run_file_70.param3], ebx	266	mov [run_file_70.param3], ebx
267	m2m [run_file_70.param4], [options_file]	267	m2m [run_file_70.param4], [options_file]
268	mov [run_file_70.rezerv], 0	268	mov [run_file_70.rezerv], 0
269	mov [run_file_70.name], file_name	269	mov [run_file_70.name], file_name
270	mov ebx,run_file_70	270	mov ebx,run_file_70
271	int 0x40	271	int 0x40
272		272
273	mov ecx,0x100	273	mov ecx,0x100
274	mov edi,FkPos	274	mov edi,FkPos
275	@@:	275	@@:
276	mov dword[edi],-1	276	mov dword[edi],-1
277	add edi,4	277	add edi,4
278	loop @b	278	loop @b
279		279
280		280
281	;init: ColColor, ColWords, ...	281	;init: ColColor, ColWords, ...
282	mov dword[ColColor],1	282	mov dword[ColColor],1
283	mov dword[ColWords],0	283	mov dword[ColWords],0
284	mov dword[tex_help_f1],0	284	mov dword[tex_help_f1],0
285	mov [help_id],-1 ;èäåíòèôèêàòîð ñëîâà äëÿ ñïðàâêè	285	mov [help_id],-1 ;èäåíòèôèêàòîð ñëîâà äëÿ ñïðàâêè
286		286
287	cmp eax,6	287	cmp eax,6
288	je @f	288	je @f
289	cmp eax,0	289	cmp eax,0
290	je @f	290	je @f
291	cmp ax,10	291	cmp ax,10
292	jl .zifra_0_9	292	jl .zifra_0_9
293	mov al,'?'	293	mov al,'?'
294	sub ax,48	294	sub ax,48
295	.zifra_0_9:	295	.zifra_0_9:
296	add ax,48	296	add ax,48
297		297
298	mov byte[msgbox_3.err],al	298	mov byte[msgbox_3.err],al
299	push thread	299	push thread
300	push msgbox_3	300	push msgbox_3
301	call [mb_create] ;message: Can-t open color options file!	301	call [mb_create] ;message: Can-t open color options file!
302	jmp .no_colors	302	jmp .no_colors
303	@@:	303	@@:
304		304
305	mov esi,[options_file]	305	mov esi,[options_file]
306	mov edi,ColColor	306	mov edi,ColColor
307	mov ecx,9*4	307	mov ecx,9*4
308	rep movsb	308	rep movsb
309		309
310	mov eax,[options_file]	310	mov eax,[options_file]
311	add eax,32	311	add eax,32
312	mov dword[tex_colors],eax	312	mov dword[tex_colors],eax
313		313
314	mov eax,dword[ColColor] ;init: Col (offset to key words)	314	mov eax,dword[ColColor] ;init: Col (offset to key words)
315	add eax,8	315	add eax,8
316	shl eax,2	316	shl eax,2
317	add eax,[options_file]	317	add eax,[options_file]
318	mov dword[Col],eax	318	mov dword[Col],eax
319		319
320	mov ecx,dword[ColWords] ;init: FkPos (first key positions)	320	mov ecx,dword[ColWords] ;init: FkPos (first key positions)
321	xor eax,eax	321	xor eax,eax
322	@@:	322	@@:
323	ColToIndexOffset eax,edi	323	ColToIndexOffset eax,edi
324	xor ebx,ebx	324	xor ebx,ebx
325	mov bl,byte[edi]	325	mov bl,byte[edi]
326	shl bx,2	326	shl bx,2
327	mov esi,FkPos	327	mov esi,FkPos
328	add esi,ebx	328	add esi,ebx
329	cmp dword[esi],-1	329	cmp dword[esi],-1
330	jne .no_ch_key	330	jne .no_ch_key
331	mov dword[esi],eax	331	mov dword[esi],eax
332	.no_ch_key:	332	.no_ch_key:
333	inc eax	333	inc eax
334	loop @b	334	loop @b
335		335
336	;init: tex_help_f1	336	;init: tex_help_f1
337	mov ecx,dword[ColWords]	337	mov ecx,dword[ColWords]
338	imul ecx,sizeof.TexColViv	338	imul ecx,sizeof.TexColViv
339	add ecx,dword[Col]	339	add ecx,dword[Col]
340	mov dword[tex_help_f1],ecx	340	mov dword[tex_help_f1],ecx
341		341
342	;copy new colors in dir_list	342	;copy new colors in dir_list
343	; m2m dword[eax+28],dword[WND_WORK_COLOR]	343	; m2m dword[eax+28],dword[WND_WORK_COLOR]
344	; m2m dword[eax+32],dword[SELECT_COLOR]	344	; m2m dword[eax+32],dword[SELECT_COLOR]
345	; m2m dword[eax+36],dword[WND_CAPT_COLOR]	345	; m2m dword[eax+36],dword[WND_CAPT_COLOR]
346	; m2m dword[eax+40],dword[WND_TEXT_COLOR]	346	; m2m dword[eax+40],dword[WND_TEXT_COLOR]
347	; m2m dword[eax+44],dword[CUR_TEXT_COLOR]	347	; m2m dword[eax+44],dword[CUR_TEXT_COLOR]
348		348
349	.no_colors:	349	.no_colors:
350	pop edi esi ecx ebx eax	350	pop edi esi ecx ebx eax
351	ret	351	ret
352		352
353		353
354	;input:	354	;input:
355	; ebx = file size	355	; ebx = file size
356	OpenFile:	356	OpenFile:
357	mov [err_opn],0	357	mov [err_opn],0
358	push eax ;destination	358	push eax ;destination
359	push ecx ;for cycle	359	push ecx ;for cycle
360	push edx ;source	360	push edx ;source
361		361
362	xor al,al	362	xor al,al
363	call Clear	363	call Clear
364	mov eax,ebx	364	mov eax,ebx
365	mov ecx,ebx	365	mov ecx,ebx
366	add eax,2	366	add eax,2
367	ConvertIndexToPointer eax	367	ConvertIndexToPointer eax
368	mov edx,[tex]	368	mov edx,[tex]
369	add edx,ebx	369	add edx,ebx
370	push ebx	370	push ebx
371	@@:	371	@@:
372	mov ebx,[edx]	372	mov ebx,[edx]
373	mov byte [eax],bl	373	mov byte [eax],bl
374	mov dword [eax+2],ecx	374	mov dword [eax+2],ecx
375	inc dword [eax+2]	375	inc dword [eax+2]
376	mov dword [eax+6],ecx	376	mov dword [eax+6],ecx
377	add dword [eax+6],3	377	add dword [eax+6],3
378	;mov byte[eax+1],0 ;col=0	378	;mov byte[eax+1],0 ;col=0
379	mov dword [eax+10],-1 ;tc=-1	379	mov dword [eax+10],-1 ;tc=-1
380	mov dword [eax+14],0 ;td=0	380	mov dword [eax+14],0 ;td=0
381		381
382	cmp ecx,0	382	cmp ecx,0
383	je @f	383	je @f
384	dec ecx	384	dec ecx
385	dec edx	385	dec edx
386	sub eax,sizeof.symbol	386	sub eax,sizeof.symbol
387	jmp @b	387	jmp @b
388	@@:	388	@@:
389	pop ebx	389	pop ebx
390	add eax,2	390	add eax,2
391	mov dword [eax],0 ; first sumbol 'perv=0'	391	mov dword [eax],0 ; first sumbol 'perv=0'
392		392
393	mov edx,[tex]	393	mov edx,[tex]
394	; begining sumbol 'perv=0' 'next=2'	394	; begining sumbol 'perv=0' 'next=2'
395	mov dword [edx+2],0	395	mov dword [edx+2],0
396	mov dword [edx+6],2	396	mov dword [edx+6],2
397		397
398	add edx,sizeof.symbol	398	add edx,sizeof.symbol
399	mov dword [edx+6],0 ; last sumbol 'next=0'	399	mov dword [edx+6],0 ; last sumbol 'next=0'
400	mov dword [edx+2],ebx ; last sumbol 'perv=last'	400	mov dword [edx+2],ebx ; last sumbol 'perv=last'
401	inc dword [edx+2]	401	inc dword [edx+2]
402		402
403	mov edx,ebx	403	mov edx,ebx
404	inc edx ;2 = rezerv sumbols	404	inc edx ;2 = rezerv sumbols
405	imul edx,sizeof.symbol	405	imul edx,sizeof.symbol
406	add edx,[tex]	406	add edx,[tex]
407	mov dword [edx+6],1 ; last sumbol 'next=1'	407	mov dword [edx+6],1 ; last sumbol 'next=1'
408		408
409	@@: ;clear memory, need if before was open big file	409	@@: ;clear memory, need if before was open big file
410	add edx,sizeof.symbol	410	add edx,sizeof.symbol
411	cmp edx,[tex_end]	411	cmp edx,[tex_end]
412	jge @f	412	jge @f
413	mov dword[edx+10],0	413	mov dword[edx+10],0
414	mov dword[edx+14],0	414	mov dword[edx+14],0
415	jmp @b	415	jmp @b
416	@@:	416	@@:
417		417
418	call GetNumLines	418	call GetNumLines
419	cmp eax,100	419	cmp eax,100
420	jge @f	420	jge @f
421	mov eax,100	421	mov eax,100
422	@@:	422	@@:
423	mov [wScr.max_area],eax	423	mov [wScr.max_area],eax
424	; mov [wScr.redraw],1	424	; mov [wScr.redraw],1
425	pop edx ecx eax	425	pop edx ecx eax
426	call CmColored	426	call CmColored
427	ret	427	ret
428		428
429	;input:	429	;input:
430	; edx = pointer to symbol struct	430	; edx = pointer to symbol struct
431	;output:	431	;output:
432	; edx = pointer to 'perv' visible symbol struct	432	; edx = pointer to 'perv' visible symbol struct
433	IteratPerv:	433	IteratPerv:
434	cmp [tim_Undo],0	434	cmp [tim_Undo],0
435	je .else	435	je .else
436	push ebx	436	push ebx
437	@@:	437	@@:
438	call GetTexPervPos	438	call GetTexPervPos
439	cmp edx,[tex]	439	cmp edx,[tex]
440	je @f	440	je @f
441	call SymbNotVis	441	call SymbNotVis
442	cmp bl,1	442	cmp bl,1
443	je @b	443	je @b
444	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10	444	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10
445	je @b	445	je @b
446	@@:	446	@@:
447	pop ebx	447	pop ebx
448	ret	448	ret
449	.else:	449	.else:
450	call GetTexPervPos	450	call GetTexPervPos
451	cmp edx,[tex]	451	cmp edx,[tex]
452	je .endif	452	je .endif
453	cmp dword [edx+14],0	453	cmp dword [edx+14],0
454	jne .else	454	jne .else
455	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10	455	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10
456	je .else	456	je .else
457	.endif:	457	.endif:
458	ret	458	ret
459		459
460		460
461	;input:	461	;input:
462	; edx = pointer to symbol struct	462	; edx = pointer to symbol struct
463	;output:	463	;output:
464	; edx = pointer to 'next' visible symbol struct	464	; edx = pointer to 'next' visible symbol struct
465	IteratNext:	465	IteratNext:
466	cmp [tim_Undo],0	466	cmp [tim_Undo],0
467	je .else	467	je .else
468	push ebx	468	push ebx
469	@@:	469	@@:
470	call GetTexNextPos	470	call GetTexNextPos
471	cmp edx,[tex_1]	471	cmp edx,[tex_1]
472	jle @f	472	jle @f
473	call SymbNotVis	473	call SymbNotVis
474	cmp bl,1	474	cmp bl,1
475	je @b	475	je @b
476	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10	476	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10
477	je @b	477	je @b
478	@@:	478	@@:
479	pop ebx	479	pop ebx
480	ret	480	ret
481	.else:	481	.else:
482	call GetTexNextPos	482	call GetTexNextPos
483	cmp edx,[tex_1]	483	cmp edx,[tex_1]
484	jle .endif	484	jle .endif
485	cmp dword [edx+14],0	485	cmp dword [edx+14],0
486	jne .else	486	jne .else
487	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10	487	cmp byte[edx],10 ;ïðîïóñê ñèìâîëà ñ êîäîì 10
488	je .else	488	je .else
489	.endif:	489	.endif:
490	ret	490	ret
491		491
492	;input:	492	;input:
493	; edx = pointer to symbol struct	493	; edx = pointer to symbol struct
494	; bl = symbol end of select	494	; bl = symbol end of select
495	ItPoNextUc:	495	ItPoNextUc:
496	@@:	496	@@:
497	cmp bl,byte[edx]	497	cmp bl,byte[edx]
498	je @f	498	je @f

Subversion Repositories Kolibri OS

(root)/programs/other/t_edit/t_work.inc – Rev 1338 → 1343