Subversion Repositories Kolibri OS

Rev

Rev 7436 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ; Hot Angles ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  3. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  4. ; Compile with FASM
  5. ; Version 0.3.6: Oct 9, 2018
  6.  
  7. ; Copyright (c) 2018, Efremenkov Sergey aka TheOnlyMirage
  8. ; All rights reserved.
  9. ; Redistribution and use in source and binary forms, with or without modification,
  10. ; are permitted provided that the following conditions are met:
  11. ;    * Redistributions of source code must retain the above copyright notice, this
  12. ;    list of conditions and the following disclaimer.
  13. ;    * Redistributions in binary form must reproduce the above copyright  notice,
  14. ;    this list of conditions and the following disclaimer in the documentation and/or
  15. ;    other materials provided with the distribution.
  16. ;    * Neither the name of the <organization> nor the names of its contributors may
  17. ;    be used to endorse or promote products derived from this software without
  18. ;    specific prior written permission.
  19.  
  20. ; THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  21. ; INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  22. ; PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  23. ; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24. ; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25. ; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26. ; --------------------------------------------------------------------------------------
  27.  
  28. format binary as "" ;"kex"
  29. use32
  30. org 0x0    ; áàçîâûé àäðåñ ðàçìåùåíèÿ êîäà, âñåãäà 0x0
  31.  
  32. UNLOCKd = 0
  33. LOCKd   = 1
  34.  
  35. ; çàãîëîâîê
  36. db 'MENUET01'     ;ìàãè÷åñêèé èäåíòèôèêàòîð
  37. dd 0x01           ;âåðñèÿ
  38. dd START_DEBUG    ;àäðåñ òî÷êè ñòàðòà ïðîãðàììû
  39. dd I_END          ;àäðåñ êîíöà, ïî ôàêòó ðàçìåð ôàéëà ïðîãðàììû
  40. dd 0x100000       ;òðåáóåìîå êîë-âî ïàìÿòè äëÿ çàãðóçêè ïðîãðàììû
  41. dd 0x7fff0        ;íà÷àëüíîå çíà÷åíèå ðåãèñòðà esp - àäðåñ êîíöà îáëàñòè ñòýêà òàê êàê ñòýê ðàñòåò â ñòîðîíó ìåíüøèõ àäðåñîâ
  42. dd 0, 0           ;àäðåñ ñòðîêè ïàðàìåòðîâ è àäðåñ ñòðîêè ïóòè èñïîëíÿåìîãî ôàéëà
  43.  
  44.  
  45. include '../../macros.inc'
  46.  
  47. START_DEBUG:
  48.    call copyKill         ;ïðîñòåéøàÿ çàùèòà îò ïîâòîðíîãî çàïóñêà
  49.    mcall  68, 11         ;èíèöèàëèçàöèÿ êó÷è
  50.    call loadConfig       ;çàãðóæàåì êîíôèãóðàöèþ ïðèëîæåíèÿ
  51.  
  52.    cmp byte[mode], 0     ;ôóíêöèÿ îòêëþ÷åíà - âûõîä
  53.    jne @f
  54.    mcall -1
  55. @@:
  56.    ;ðåæèì æåñòà ïî ãîðÿ÷åé êëàâèøå?
  57.    cmp byte[mode], 3 ;ïîäïèñûâàåìñÿ íà èíòåðåñíûå íàì ñîáûòèÿ â çàâèñèìîñòè îò ðåæèìà ðàáîòû
  58.    jne @f
  59.    mov ebx, 00000100000000000000000000100010b    ;åñëè äà, òî ïîäïèñûâàåìñÿ íà êëàâèøè
  60.    mcall 40
  61.    jmp init03
  62. @@:
  63.    ;ðåæèì àêòèâàöèè ãîðÿ÷åé êëàâèøåé?
  64.    cmp byte[mode], 2 ;ïîäïèñûâàåìñÿ íà èíòåðåñíûå íàì ñîáûòèÿ â çàâèñèìîñòè îò ðåæèìà ðàáîòû
  65.    jne @f
  66.    mov ebx, 00000100000000000000000000100010b    ;åñëè äà, òî ïîäïèñûâàåìñÿ íà êëàâèøè
  67.    mcall 40
  68.    jmp init02
  69. @@:
  70.    ; âî âñåõ îñòàëüíûõ ñëó÷àÿõ - êëàññè÷åñêèé ðåæèì ðàáîòû
  71.    ;mode=1 êëàññè÷åñêèé ðåæèì ðàáîòû - ðåàêöèÿ ïðè íàâåäåíèè â óãîë
  72.    mov byte[mode], 1
  73.    mov ebx, 00000100000000000000000000100000b
  74.    mcall 40
  75.    jmp init01
  76.  
  77.  
  78.  
  79. init02:
  80.    mov dword[backAdr], mode02
  81.    call setHotKey
  82. mode02:
  83.    mcall 10
  84.    cmp eax, 2     ;îáðàáîòêà íàæàòèÿ êëàâèøè
  85.    je hotkey
  86.  
  87.    cmp byte[keyState], 0
  88.    je mode02
  89.    cmp   eax, 6   ;îáðàáîòêà ïåðåìåùåíèé è íàæàòèÿ ìûøè
  90.    je    mouse
  91.  
  92.    jmp mode02
  93.  
  94.  
  95. setHotKey:    ;óñòàíîâèòü ãîðÿ÷óþ êëàâèøó
  96.    push eax ebx ecx edx
  97.    xor ecx, ecx
  98.    mov cl, byte[keyActivate]  ;íàæàòèå ãîðÿ÷åé êëàâèøè
  99.    mov edx, 0x000
  100.    mcall 66, 4, ecx, edx
  101.  
  102.    ;mov cl, byte[keyActivate]
  103.    add cl, 128              ;îòïóñêàíèå ãîðÿ÷åé êëàâèøè
  104.    ;mov edx, 0x000
  105.    mcall 66, 4, ecx, edx
  106.    pop edx ecx ebx eax
  107.    ret
  108.  
  109.  
  110. hotkey:
  111.    mcall 2
  112.    cmp eax, 1     ;áóôåð êëàâèø ïóñò?
  113.    je hotkey.end
  114.  
  115.    cmp al, 2      ;íàñ èíòåðåñóåò òîëüêî ñêàí êîä ãîðÿ÷åé êëàâèøè, èíà÷å âûõîäèì
  116.    jne hotkey.end
  117.  
  118.    cmp ah, byte[keyActivate]   ;åñëè íàæàòà íàøà ãîðÿ÷àÿ êëàâèøà
  119.    jne @f
  120.  
  121. ;for mode 3 [
  122.    cmp byte[keyState], 1
  123.    je hotkey.e
  124.  
  125.    push eax ebx
  126.    mcall 37, 0 ;çàïîìèíàåì òåêóùèå(íà÷àëüíûå) êîîðäèíàòû ìûøè
  127.    ;mov dword[o.x], eax
  128.    mov word[o.y], ax
  129.    shr eax, 16
  130.    mov word[o.x], ax
  131.    pop ebx eax
  132.  
  133.    mov byte[keyState], 1
  134.    mov byte[state], UNLOCKd
  135. .e:
  136. ;]
  137.    ;mov byte[state], UNLOCKd
  138.    jmp hotkey.end
  139. @@:
  140.    push edx
  141.    xor edx, edx
  142.    mov dl, byte[keyActivate]
  143.    add dl, 128
  144.    cmp ah, dl   ;åñëè îòïóùåíà íàøà ãîðÿ÷àÿ êëàâèøà
  145.    jne @f       ;hotkey.end
  146.    ;mov ecx, 0  ;ñòðîêè äëÿ îòëàäêè è òåñòà
  147.    ;call run_command
  148.    mov byte[keyState], 0
  149.    mov byte[state], LOCKd
  150. @@:
  151.    pop edx
  152. .end:
  153.    jmp dword[backAdr]
  154.  
  155.  
  156. init01:
  157.    mov dword[backAdr], mode01
  158. mode01:
  159.   mov     eax, 10                 ; function 10 : wait until event
  160.   mcall                           ; event type is returned in eax
  161.  
  162.   cmp   eax, 6           ;îáðàáîòêà ïåðåìåùåíèé è íàæàòèÿ ìûøè
  163.   je    mouse
  164.  
  165.   jmp mode01
  166.  
  167.  
  168. mouse:
  169.    push ebx
  170.    mcall 37, 0   ;ïîëó÷àåì òåêóùèå êîîðäèíàòû ìûøè
  171.    pop ebx
  172.  
  173.   cmp eax, 0 ;ëåâûé âåðõíèé óãîë
  174.   jne @f
  175.   ; -- çäåñü âûçûâàåì ñîîòâ. âûçîâ äëÿ ëåâîãî âåðõíåãî óãëà  (X=0, Y=0)
  176.   push ecx
  177.   mov ecx, 0
  178.   call run_command
  179.   pop ecx
  180.  
  181.   jmp dword[backAdr] ;finish
  182. @@:
  183.   call get_screen_size ;èíà÷å îáíîâëÿåì ðàçìåðû ýêðàíà
  184.  
  185.   cmp ax, word[screen.height]    ;Ymouse = Yscreen ?
  186.   je Ytrue
  187.   ;åñëè Y íå ðàâíû, òî íàñ èíòåðåñóåò Y=0 è X=ScreenWidth (ïðàâûé âåðõíèé óãîë)
  188.  
  189.   cmp ax, 0
  190.   jne unlockend
  191.   shr eax, 16
  192.   cmp ax, word[screen.width]
  193.   jne unlockend
  194.   ; -- çäåñü âûçûâàåì äëÿ ïðàâîãî âåðõåíåãî óãëà
  195.   push ecx
  196.   mov ecx, 2
  197.   call run_command
  198.   pop ecx
  199.  
  200.   jmp dword[backAdr]
  201. Ytrue:
  202.   ;åñëè Y ðàâíû, òî íàñ èíòåðåñóåò X=0 (ëåâûé íèæíèé óãîë) èëè X=ScreenWidth (ïðàâûé íèæíèé)
  203.   shr eax, 16
  204.   cmp ax, 0
  205.   jne @f
  206.   ; -- X=0, Y = Height  (ëåâûé íèæíèé óãîë)
  207.   push ecx
  208.   mov ecx, 1
  209.   call run_command
  210.   pop ecx
  211.   jmp dword[backAdr]
  212. @@:
  213.   cmp ax, word[screen.width]
  214.   jne unlockend
  215.   ; -- (ïðàâûé íèæíèé óãîë)
  216.   push ecx
  217.   mov ecx, 3
  218.   call run_command
  219.   pop ecx
  220.  
  221.   jmp dword[backAdr]
  222.  
  223. unlockend:
  224.   mov byte[state], UNLOCKd
  225.   jmp dword[backAdr]
  226.  
  227.  
  228.  
  229. ;ïîëó÷èòü ðàçìåð ýêðàíà
  230. get_screen_size:
  231.    push eax
  232.    mcall 14
  233.    ;òåïåðü â eax = [xsize]*65536 + [ysize]
  234.    ;mov dword[screen], eax
  235.    mov word[screen.height], ax
  236.    shr eax, 16
  237.    mov word[screen.width], ax
  238.    pop eax
  239.    ret
  240.  
  241.  
  242.  
  243.  
  244.  
  245. ;çàïóñê ïðèëîæåíèÿ: ecx - àêòèâíûé óãîë: lu=0, ld=1, ru=2, rd=3
  246. run_command:
  247.    cmp byte[state], UNLOCKd
  248.    jne run_command.end
  249.  
  250. ;   cmp byte[mode], 2     ;åñëè ðåæèì âòîðîé
  251. ;   jne @f
  252.  
  253.    push eax ebx ecx
  254.  
  255.    cmp ecx, 0
  256.    jne @f
  257.    mov eax, dword[newData.lu]
  258.    mov dword[struct70.path_adr], eax
  259.    jmp .end_set_path
  260. @@:
  261.    cmp ecx, 1
  262.    jne @f
  263.    mov eax, dword[newData.ld]
  264.    mov dword[struct70.path_adr], eax
  265.    jmp .end_set_path
  266. @@:
  267.    cmp ecx, 2
  268.    jne @f
  269.    mov eax, dword[newData.ru]
  270.    mov dword[struct70.path_adr], eax
  271.    jmp .end_set_path
  272. @@:
  273.    cmp ecx, 3
  274.    jne .end_set_path
  275.    mov eax, dword[newData.rd]
  276.    mov dword[struct70.path_adr], eax
  277.    jmp .end_set_path
  278. .end_set_path:
  279.  
  280.    ;ïàðàìåòðû
  281.    ;mov dword[struct.adr],
  282.  
  283. ;åñëè àäðåñ 0, òî íè÷åãî íå äåëàòü
  284.    cmp dword[struct70.path_adr], 0
  285.    jne .next
  286.    ;mov eax, testData.ld
  287.    ;mov dword[struct70.path_adr], eax
  288.    jmp @f
  289. .next:
  290. ;êîíåö êîäà äëÿ çàìåíû
  291.  
  292.    mcall 70, struct70
  293. @@:
  294.    mov byte[state], LOCKd
  295.    ;mov byte[keyState], 0
  296.  
  297.    pop ecx ebx eax
  298. .end:
  299.    ret
  300.  
  301. struct70: ;Ôîðìàò èíôîðìàöèîííîé ñòðóêòóðû
  302.   .func       dd 7 ; íîìåð ïîäôóíêöèè
  303.   .mask       dd 0
  304.   .param_adr  dd 0 ; óêàçàòåëü íà ASCIIZ-ñòðîêó ñ ïàðàìåòðàìè
  305.   .other      dd 0, 0
  306.   .path       db 0 ; "/rd/1/TINYPAD",0 ; ïóòü
  307.   .path_adr   dd 0 ;testData.lu
  308.  
  309. ;èìÿ êîíôèãóðàöèîííîãî ôàéëà
  310. fileName: db 'SETTINGS/HOTANGLES.CFG', 0
  311.  
  312. loadConfig:
  313.    push eax ebx ecx edx
  314.    mcall 68, 27, fileName   ;çàãðóæàåì êîíôèãóðàöèîííûé ôàéë â ÎÇÓ
  315.    cmp eax, 0
  316.    je loadConfig.exit       ;åñëè ôàéëà êîíôèãóðàöèè íåò, òî çàâåðøàåì ðàáîòó ïðèëîæåíèÿ
  317.    ;èíà÷å äàííûå çàãðóæåíû â ÎÇÓ, ðàçìåð â edx
  318.    cmp edx, 0               ;åñëè ôàéë ïóñò, â í¸ì íåò äàííûõ, òî çàâåðøàåì ðàáîòó
  319.    je loadConfig.exit
  320.  
  321.    add edx, eax             ;èíà÷å êëàä¸ì â edx - àäðåñ êîíöà ôàéëà
  322.  
  323.    mov byte[mode], 0
  324.    cmp byte[eax], '0' ;121 ;'y'  ;åñëè ïàðàìåòð àêòèâíîñòè ïðèëîæåíèÿ èìååò ñòàòóñ: íå àêòèâíî
  325.    je loadConfig.exit      ;òî çàâåðøàåì ðàáîòó ïðèëîæåíèÿ
  326.    cmp byte[eax], 110 ;'n'
  327.    je loadConfig.exit
  328.  
  329.    ;èíà÷å âûñòàâëÿåì ðåæèì
  330.    cmp byte[eax], '2'       ;ðåæèì àêòèâàöèè ïî ãîðÿ÷åé êëàâèøå
  331.    jne @f
  332.    mov byte[mode], 2
  333.    jmp loadConfig.modeEnd
  334. @@:
  335.    cmp byte[eax], '3'       ;ðåæèì æåñòà ïðè çàæàòîé êëàâèøå
  336.    jne @f
  337.    mov byte[mode], 3
  338.    jmp loadConfig.modeEnd
  339. @@:
  340.    mov byte[mode], 1        ;âî âñåõ îñòàëüíûõ ñëó÷àÿõ - êëàññè÷åñêèé ðåæèì
  341. .modeEnd:
  342.  
  343.    push edi
  344.    push esi
  345.    ; ñîõðàíÿåì â edi óêàçàòåëü íà íà÷àëî òàáëèöû àäðåñîâ íàøèõ êîìàíä
  346.    mov edi, newData
  347.    ; ñîõðàíÿåì àäðåñà ñòðîê è äîáàâëÿåì 0 â êîíöå
  348.    mov esi, eax
  349. .block:
  350.    inc esi
  351.    cmp byte[esi], 10         ;åñëè î÷åðåäíîé êîä ñèìâîëà 10 èëè 13, òî ïðîïóñêàåì ñèìâîëû
  352.    je loadConfig.propusk     ;äî ïåðâîãî îòëè÷íîãî îò íèõ
  353.    cmp byte[esi], 13
  354.    je loadConfig.propusk
  355.  
  356.    ; ñèìâîë îòëè÷åí îò ïåðåíîñà ñòðîêè è âîçâðàòà êàðåòêè - åñëè ýòî íà çíàê ìèíóñ, òî çàïîìèíàåì åãî
  357.    mov dword[edi], esi
  358.    add edi, 4
  359.  
  360.    ;èä¸ì äî êîíöà ýòîé ñòðîêè: ïîêà íå âñòðåòèì î÷åðåäíîé 10, 13, 0 èëè file end
  361. .while:
  362.    inc esi
  363.    cmp esi, edx           ;òóò áóäåò ïðîáëåìà - òê ôàéë çàêîí÷èëñÿ, à íóëÿ íå áûëî !!! èñïðàâèòü
  364.    jae loadConfig.fileend
  365.    cmp byte[esi], 10
  366.    je loadConfig.ura
  367.    cmp byte[esi], 0
  368.    je loadConfig.ura
  369.    cmp byte[esi], 13
  370.    jne loadConfig.while
  371. .ura:
  372.    mov byte[esi], 0
  373.  
  374.    ;cmp byte[esi-1], '-'
  375.    ;jne @f
  376.    push esi  ;åñëè ýòî áûë çíàê ìèíóñ, òî ìåíÿåì àäðåñ íà íîëü
  377.    mov esi, dword[edi-4]
  378.    cmp byte[esi], '-'
  379.    jne @f
  380.    cmp byte[esi+1], 0
  381.    jne @f
  382.    mov dword[edi-4], 0
  383. @@:
  384.    pop esi
  385.  
  386.    cmp edi, newDataEnd ;newData.end      ;åñëè âñÿ òàáëèöà àäðåñîâ çàïîëíåíà, òî âûõîäèì èç öèêëà
  387.    jb loadConfig.block
  388. .fileend:
  389.  
  390.    pop esi
  391.    pop edi
  392.  
  393.    jmp loadConfig.end
  394.  
  395. .propusk:
  396.    mov byte[esi], 0
  397.    jmp loadConfig.block
  398. .exit:
  399.    pop edx ecx ebx eax
  400.    mcall -1 ;çàêðûòü ýòó ïðîãðàììó
  401. .end:
  402.    pop edx ecx ebx eax
  403.    ret
  404.  
  405.  
  406.  
  407.  
  408. ;Âûíåñòè êîä íèæå â îòäåëüíûé îáùèé ìîäóëü
  409. selfName db '@HOTANGLES',0
  410. selfNameSize = 10 ;äî 11 byte
  411. ;
  412. compareBytes:
  413.    push edi esi ecx ebx
  414.    xor eax, eax
  415.    mov ecx, selfNameSize    ;max ðàçìåð ñòðîê 11
  416. @@:
  417.    mov bl, byte[edi]
  418.    cmp bl, byte[esi]
  419.    jne compareBytes.no
  420.    inc edi
  421.    inc esi
  422.    cmp ecx, 0
  423.    je @f
  424.    dec ecx
  425.    jmp @b
  426. .no:
  427.    mov eax, 1
  428. @@:
  429.    pop ebx ecx esi edi
  430.    ret
  431. ;
  432. copyKill:
  433.    push eax ebx ecx esi edi
  434.  
  435.    ;ñïåðâà ïðî÷ò¸ì ñâîþ èíôîðìàöèþ
  436.    mcall 9, buf, -1
  437.    mov eax, dword[buf+30]
  438.    mov dword[selfPID], eax
  439.  
  440.    ;óêàçàòåëè, êîòîðûå íèêîãäà íå ìåíÿþòñÿ:
  441.    mov esi, selfName       ;ïåðâàÿ ñòðîêà - èìÿ òåêóùåãî ïðèëîæåíèÿ
  442.    mov edi, buf            ;âòîðàÿ ñòðîêà - èìÿ òåêóùåãî ñëîòà
  443.    add edi, 10
  444.  
  445.    mov ecx, 1
  446. @@:
  447.    mcall 9, buf, ecx
  448.    mov dword[slotMax], eax
  449.  
  450.    ;åñëè ýòî ìû ñàìè, òî ïðîïóñêàåì ïðîâåðêó
  451.    mov eax, dword[buf+30]
  452.    cmp eax, dword[selfPID]
  453.    je copyKill.propusk
  454.  
  455.    call compareBytes   ;ñðàâíèâàåì 11 áàéò ñòðîê, ðåçóëüòàò â eax
  456.  
  457.    cmp eax, 0
  458.    je copyKill.selfKill
  459.  
  460. .propusk:
  461.    inc ecx
  462.    cmp ecx, dword[slotMax]
  463.    ja @f
  464.    jmp @b
  465.  
  466. .selfKill:
  467.    pop edi esi ecx ebx eax
  468.    mcall -1
  469.    ret
  470. @@:
  471.    pop edi esi ecx ebx eax
  472.    ret
  473.  
  474.  
  475. ;MODE 3
  476. init03:
  477.    mov dword[radius2], 100; 10*10
  478.    mov dword[backAdr], mode03
  479.    call setHotKey
  480. mode03:
  481.    mcall 10
  482.    cmp eax, 2     ;îáðàáîòêà íàæàòèÿ êëàâèøè
  483.    je hotkey
  484.  
  485.    ;cmp byte[keyState], 0
  486.    ;je mode03
  487.    cmp   eax, 6   ;îáðàáîòêà ïåðåìåùåíèé è íàæàòèÿ ìûøè
  488.    je    mouse03
  489.  
  490.    jmp mode03
  491.  
  492. mouse03:
  493.    cmp byte[keyState], 0     ;åñëè êëàâèøà íå çàæàòà, òî îáíîâèì íà÷àëüíûå êîîðäèíàòû
  494.    je mouse03.updateCoord
  495.  
  496.    cmp byte[state], LOCKd    ;åñëè óãîë çàáëîêèðîâàí, òî îáíîâèì íà÷àëüíûå êîîðäèíàòû
  497.    je mouse03.updateCoord
  498.  
  499.    call checkPointInCircle   ;èíà÷å åñëè ïðåîäîëåëè ðàäèóñ àêòèâàöèè, òî âûçûâàåì äåéñòâèå íóæíîãî óãëà
  500.    jmp @f
  501. .updateCoord:
  502.    push eax ebx
  503.    mcall 37, 0 ;çàïîìèíàåì òåêóùèå(íà÷àëüíûå) êîîðäèíàòû ìûøè
  504.    ;mov dword[o.x], eax
  505.    mov word[o.y], ax
  506.    shr eax, 16
  507.    mov word[o.x], ax
  508.    pop ebx eax
  509. @@:
  510.    jmp dword[backAdr]
  511.  
  512.  
  513. radius2 dd 0  ;êâàäðàò ðàäèóñà äëÿ mode 3
  514. o:            ;êîîðäèíàòû íà÷àëüíîé è òåêóùåé òî÷êè
  515.  .x:   dw 0
  516.  .y:   dw 0
  517.  .cx:  dw 0
  518.  .cy:  dw 0
  519.  
  520. ;ïðîâåðêà âûõîäà çà ïðåäåëû êðóãà
  521. ; sqrt( (x2-x1)^2 + (y2-y1)^2 ) <= radius
  522. ; (x2-x1)^2 + (y2-y1)^2 <= radius^2
  523. checkPointInCircle:
  524.    push eax ebx ecx edx
  525.    mcall 37, 0 ;ïîëó÷àåì òåêóùèå êîîðäèíàòû ìûøè
  526.    ;mov dword[o.cx], eax
  527.    mov word[o.cy], ax
  528.    shr eax, 16
  529.    mov word[o.cx], ax
  530.  
  531.    xor eax, eax
  532.    xor edx, edx
  533.    mov ax, word[o.x]
  534.    mov dx, word[o.cx]
  535.    cmp dx, ax
  536.    jae @f
  537.    sub ax, dx
  538.    mov dx, ax
  539.    jmp .xend
  540. @@:
  541.    sub dx, ax
  542. .xend:
  543.    mov eax, edx
  544.    mul dx
  545.  
  546.    mov ebx, eax
  547.  
  548.    xor eax, eax
  549.    xor edx, edx
  550.    mov ax, word[o.y]
  551.    mov dx, word[o.cy]
  552.    cmp dx, ax
  553.    jae @f
  554.    sub ax, dx
  555.    mov dx, ax
  556.    jmp .yend
  557. @@:
  558.    sub dx, ax
  559. .yend:
  560.    mov eax, edx
  561.    mul dx
  562.  
  563.    add ebx, eax
  564.  
  565.    cmp ebx, dword[radius2]
  566.    jbe @f
  567.    call activateCorner ;èíà÷å àêòèâèðóåì íóæíûé óãîë
  568.  @@:
  569.    pop edx ecx ebx eax
  570.    ret
  571.  
  572. ;âûÿñíèòü â ñòîðîíó êàêîãî óãëà óøëè è àêòèâèðîâàòü åãî
  573. activateCorner:
  574.    push eax ecx
  575.    xor eax, eax
  576.  
  577.    mov ax, word[o.cx]
  578.    cmp ax, word[o.x]
  579.    je activateCorner.end       ;åñëè êîîðäèíàòà ðàâíà, òî âûõîäèì (òàêîãî áûòü íå äîëæíî)
  580.    ja activateCorner.right
  581.  
  582.    ;èíà÷å ëåâàÿ ñòîðîíà
  583.    mov ax, word[o.cy]
  584.    cmp ax, word[o.y]
  585.    je activateCorner.end       ;åñëè êîîðäèíàòà ðàâíà, òî âûõîäèì (òàêîãî áûòü íå äîëæíî)
  586.    jb activateCorner.leftup
  587.  
  588.    ;èíà÷å ëåâûé íèæíèé óãîë
  589.    mov ecx, 1
  590.    call run_command
  591.    mov byte[keyState], 0
  592.    mov byte[state], LOCKd
  593.    jmp activateCorner.end
  594.  
  595. .leftup:
  596.    ;ëåâûé âåðõíèé óãîë
  597.    mov ecx, 0
  598.    call run_command
  599.    mov byte[keyState], 0
  600.    mov byte[state], LOCKd
  601.    jmp activateCorner.end
  602.  
  603. .right: ;ïðàâàÿ ñòîðîíà ýêðàíà
  604.    mov ax, word[o.cy]
  605.    cmp ax, word[o.y]
  606.    je activateCorner.end       ;åñëè êîîðäèíàòà ðàâíà, òî âûõîäèì (òàêîãî áûòü íå äîëæíî)
  607.    jb activateCorner.rightup
  608.  
  609.    ;èíà÷å ïðàâûé íèæíèé óãîë
  610.    mov ecx, 3
  611.    call run_command
  612.    mov byte[keyState], 0
  613.    mov byte[state], LOCKd
  614.    jmp activateCorner.end
  615.  
  616. .rightup:
  617.    ;ïðàâûé âåðõíèé óãîë
  618.    mov ecx, 2
  619.    call run_command
  620.    mov byte[keyState], 0
  621.    mov byte[state], LOCKd
  622.    jmp activateCorner.end
  623.  
  624. .end:
  625.    pop ecx eax
  626.    ret
  627.  
  628.  
  629.  
  630. keyActivate db 41 ;16 ;'Q' ;êëàâèøà àêòèâàöèè
  631. keyState    db 0  ;0-êëàâèøà íå àêòèâíà, 1 - êëàâèøà àêòèâíà
  632.  
  633. backAdr rd 1      ;àäðåñ äëÿ âîçâðàòà èç ïðîâåðêè ìûøè
  634.  
  635. ;slotMax dd 0
  636. ;selfPID dd 0
  637. ;buf db 1024 dup(0)
  638. slotMax rd 1
  639. selfPID rd 1
  640. buf rb 1024
  641.  
  642. ;ñòðóêòóðêà äàííûõ äëÿ õðàíåíèÿ ïàðàìåòðîâ ýêðàíà
  643. screen:
  644.   .width  rw 1
  645.   .height rw 1
  646.  
  647. state: rb 1  ;ñîñòîÿíèå: 0=unlock, 1=lock
  648. mode:  rb 1  ;ðåæèì ðàáîòû ïðèëîæåíèÿ: 0=íå ðàáîòàåò, 1=êëàññè÷åñêèé, 2=ïî ãîðÿ÷åé êëàâèøå
  649.  
  650. newData:  ;òàáëè÷êà àäðåñîâ êîìàíäíûõ ñòðîê
  651.   .lu rd 1
  652.   .ld rd 1
  653.   .ru rd 1
  654.   .rd rd 1
  655. newDataEnd:
  656.  
  657. I_END:
  658.