Subversion Repositories Kolibri OS

Rev

Rev 983 | Rev 1316 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 1313 $
  9.  
  10.  
  11. LOAD_FROM_FILE equ 0
  12. LOAD_FROM_MEM   equ 1
  13. LOAD_INDIRECT   equ 2
  14. LOAD_SYSTEM     equ 3
  15.  
  16. struc BITMAPINFOHEADER {
  17.   .biSize          dd ? ; DWORD
  18.   .biWidth         dd ? ; LONG
  19.   .biHeight        dd ? ; LONG
  20.   .biPlanes        dw ? ; WORD
  21.   .biBitCount      dw ? ; WORD
  22.   .biCompression   dd ? ; DWORD
  23.   .biSizeImage     dd ? ; DWORD
  24.   .biXPelsPerMeter dd ? ; LONG
  25.   .biYPelsPerMeter dd ? ; LONG
  26.   .biClrUsed       dd ? ; DWORD
  27.   .biClrImportant  dd ? ; DWORD
  28. }
  29.  
  30. virtual at 0
  31.   BI BITMAPINFOHEADER
  32. end virtual
  33.  
  34. align 4
  35. proc vesa_init_cursor stdcall, dst:dword, src:dword
  36.            locals
  37.              rBase    dd ?
  38.              pQuad    dd ?
  39.              pBits    dd ?
  40.              pAnd     dd ?
  41.              width    dd ?
  42.              height   dd ?
  43.              counter  dd ?
  44.            endl
  45.  
  46.            mov esi, [src]
  47.            add esi,[esi+18]
  48.            mov eax,esi
  49.  
  50.            cmp [esi+BI.biBitCount], 24
  51.            je .img_24
  52.            cmp [esi+BI.biBitCount], 8
  53.            je .img_8
  54.            cmp [esi+BI.biBitCount], 4
  55.            je .img_4
  56.  
  57. .img_2:
  58.            add eax, [esi]
  59.            mov [pQuad],eax
  60.            add eax,8
  61.            mov [pBits],eax
  62.            add eax, 128
  63.            mov [pAnd],eax
  64.            mov eax,[esi+4]
  65.            mov [width],eax
  66.            mov ebx,[esi+8]
  67.            shr ebx,1
  68.            mov [height],ebx
  69.  
  70.            mov edi, [dst]
  71.            add edi, 32*31*4
  72.            mov [rBase],edi
  73.  
  74.            mov esi,[pQuad]
  75. .l21:
  76.            mov ebx, [pBits]
  77.            mov ebx, [ebx]
  78.            bswap ebx
  79.            mov eax, [pAnd]
  80.            mov eax, [eax]
  81.            bswap eax
  82.            mov [counter], 32
  83. @@:
  84.            xor edx, edx
  85.            shl eax,1
  86.            setc dl
  87.            dec edx
  88.  
  89.            xor ecx, ecx
  90.            shl ebx,1
  91.            setc cl
  92.            mov ecx, [esi+ecx*4]
  93.            and ecx, edx
  94.            and edx, 0xFF000000
  95.            or edx, ecx
  96.            mov [edi], edx
  97.  
  98.            add edi, 4
  99.            dec [counter]
  100.            jnz @B
  101.  
  102.            add [pBits], 4
  103.            add [pAnd], 4
  104.            mov edi,[rBase]
  105.            sub edi,128
  106.            mov [rBase],edi
  107.            sub [height],1
  108.            jnz .l21
  109.            ret
  110.  
  111. .img_4:
  112.            add eax, [esi]
  113.            mov [pQuad],eax
  114.            add eax,64
  115.            mov [pBits],eax
  116.            add eax, 0x200
  117.            mov [pAnd],eax
  118.            mov eax,[esi+4]
  119.            mov [width],eax
  120.            mov ebx,[esi+8]
  121.            shr ebx,1
  122.            mov [height],ebx
  123.  
  124.            mov edi, [dst]
  125.            add edi, 32*31*4
  126.            mov [rBase],edi
  127.  
  128.            mov esi,[pQuad]
  129.            mov ebx, [pBits]
  130. .l4:
  131.            mov eax, [pAnd]
  132.            mov eax, [eax]
  133.            bswap eax
  134.            mov [counter], 16
  135. @@:
  136.            xor edx, edx
  137.            shl eax,1
  138.            setc dl
  139.            dec edx
  140.  
  141.            movzx ecx, byte [ebx]
  142.            and cl, 0xF0
  143.            shr ecx, 2
  144.            mov ecx, [esi+ecx]
  145.            and ecx, edx
  146.            and edx, 0xFF000000
  147.            or edx, ecx
  148.            mov [edi], edx
  149.  
  150.            xor edx, edx
  151.            shl eax,1
  152.            setc dl
  153.            dec edx
  154.  
  155.            movzx ecx, byte [ebx]
  156.            and cl, 0x0F
  157.            mov ecx, [esi+ecx*4]
  158.            and ecx, edx
  159.            and edx, 0xFF000000
  160.            or edx, ecx
  161.            mov [edi+4], edx
  162.  
  163.            inc ebx
  164.            add edi, 8
  165.            dec [counter]
  166.            jnz @B
  167.  
  168.            add [pAnd], 4
  169.            mov edi,[rBase]
  170.            sub edi,128
  171.            mov [rBase],edi
  172.            sub [height],1
  173.            jnz .l4
  174.            ret
  175. .img_8:
  176.            add eax, [esi]
  177.            mov [pQuad],eax
  178.            add eax,1024
  179.            mov [pBits],eax
  180.            add eax, 1024
  181.            mov [pAnd],eax
  182.            mov eax,[esi+4]
  183.            mov [width],eax
  184.            mov ebx,[esi+8]
  185.            shr ebx,1
  186.            mov [height],ebx
  187.  
  188.            mov edi, [dst]
  189.            add edi, 32*31*4
  190.            mov [rBase],edi
  191.  
  192.            mov esi,[pQuad]
  193.            mov ebx, [pBits]
  194. .l81:
  195.            mov eax, [pAnd]
  196.            mov eax, [eax]
  197.            bswap eax
  198.            mov [counter], 32
  199. @@:
  200.            xor edx, edx
  201.            shl eax,1
  202.            setc dl
  203.            dec edx
  204.  
  205.            movzx ecx,  byte [ebx]
  206.            mov ecx, [esi+ecx*4]
  207.            and ecx, edx
  208.            and edx, 0xFF000000
  209.            or edx, ecx
  210.            mov [edi], edx
  211.  
  212.            inc ebx
  213.            add edi, 4
  214.            dec [counter]
  215.            jnz @B
  216.  
  217.            add [pAnd], 4
  218.            mov edi,[rBase]
  219.            sub edi,128
  220.            mov [rBase],edi
  221.            sub [height],1
  222.            jnz .l81
  223.            ret
  224. .img_24:
  225.            add eax, [esi]
  226.            mov [pQuad],eax
  227.            add eax, 0xC00
  228.            mov [pAnd],eax
  229.            mov eax,[esi+BI.biWidth]
  230.            mov [width],eax
  231.            mov ebx,[esi+BI.biHeight]
  232.            shr ebx,1
  233.            mov [height],ebx
  234.  
  235.            mov edi, [dst]
  236.            add edi, 32*31*4
  237.            mov [rBase],edi
  238.  
  239.            mov esi,[pAnd]
  240.            mov ebx, [pQuad]
  241. .row_24:
  242.            mov eax, [esi]
  243.            bswap eax
  244.            mov [counter], 32
  245. @@:
  246.            xor edx, edx
  247.            shl eax,1
  248.            setc dl
  249.            dec edx
  250.  
  251.            mov ecx, [ebx]
  252.            and ecx, 0x00FFFFFF
  253.            and ecx, edx
  254.            and edx, 0xFF000000
  255.            or edx, ecx
  256.            mov [edi], edx
  257.            add ebx, 3
  258.            add edi, 4
  259.            dec [counter]
  260.            jnz @B
  261.  
  262.            add esi, 4
  263.            mov edi,[rBase]
  264.            sub edi,128
  265.            mov [rBase],edi
  266.            sub [height],1
  267.            jnz .row_24
  268.            ret
  269. endp
  270.  
  271. align 4
  272. proc set_cursor stdcall, hcursor:dword
  273.            mov eax, [hcursor]
  274.            cmp [eax+CURSOR.magic], 'CURS'
  275.            jne .fail
  276. ;           cmp [eax+CURSOR.size], CURSOR_SIZE
  277. ;           jne .fail
  278.            mov ebx, [current_slot]
  279.            xchg eax, [ebx+APPDATA.cursor]
  280.            ret
  281. .fail:
  282.            mov eax, [def_cursor]
  283.            mov ebx, [current_slot]
  284.            xchg eax, [ebx+APPDATA.cursor]
  285.            ret
  286. endp
  287.  
  288. ; param
  289. ;  eax= pid
  290. ;  ebx= src
  291. ;  ecx= flags
  292.  
  293. vesa_cursor:
  294. .src     equ esp
  295. .flags   equ esp+4
  296. .hcursor equ esp+8
  297.  
  298.            sub esp, 4          ;space for .hcursor
  299.            push ecx
  300.            push ebx
  301.  
  302.            mov ebx, eax
  303.            mov eax, CURSOR.sizeof
  304.            call create_kernel_object
  305.            test eax, eax
  306.            jz .fail
  307.  
  308.            mov [.hcursor],eax
  309.  
  310.            xor ebx, ebx
  311.            mov [eax+CURSOR.magic], 'CURS'
  312.            mov [eax+CURSOR.destroy], destroy_cursor
  313.            mov [eax+CURSOR.hot_x], ebx
  314.            mov [eax+CURSOR.hot_y], ebx
  315.  
  316.            stdcall kernel_alloc, 0x1000
  317.            test eax, eax
  318.            jz .fail
  319.  
  320.            mov edi, [.hcursor]
  321.            mov [edi+CURSOR.base], eax
  322.  
  323.            mov esi, [.src]
  324.            mov ebx, [.flags]
  325.            cmp bx, LOAD_INDIRECT
  326.            je .indirect
  327.  
  328.            movzx ecx, word [esi+10]
  329.            movzx edx, word [esi+12]
  330.            mov [edi+CURSOR.hot_x], ecx
  331.            mov [edi+CURSOR.hot_y], edx
  332.  
  333.            stdcall vesa_init_cursor, eax, esi
  334.            mov eax, [.hcursor]
  335. .fail:
  336.            add esp, 12
  337.            ret
  338. .indirect:
  339.            shr ebx, 16
  340.            movzx ecx, bh
  341.            movzx edx, bl
  342.            mov [eax+CURSOR.hot_x], ecx
  343.            mov [eax+CURSOR.hot_y], edx
  344.  
  345.            xchg edi, eax
  346.            mov ecx, 1024
  347.            cld
  348.            rep movsd
  349.            add esp, 12
  350.            ret
  351.  
  352. align 4
  353. proc load_cursor stdcall, src:dword, flags:dword
  354.            locals
  355.              handle  dd ?
  356.            endl
  357.  
  358.            xor eax, eax
  359.            cmp [create_cursor], eax
  360.            je .fail2
  361.  
  362.            mov [handle], eax
  363.            cmp word [flags], LOAD_FROM_FILE
  364.            jne @F
  365.  
  366.            stdcall load_file, [src]
  367.            test eax, eax
  368.            jz .fail
  369.            mov [src], eax
  370. @@:
  371.            push ebx
  372.            push esi
  373.            push edi
  374.  
  375.            mov eax, [CURRENT_TASK]
  376.            shl eax, 5
  377.            mov eax, [CURRENT_TASK+eax+4]
  378.            mov ebx, [src]
  379.            mov ecx, [flags]
  380.            call [create_cursor]    ;eax, ebx, ecx
  381.            mov [handle], eax
  382.  
  383.            cmp word [flags], LOAD_FROM_FILE
  384.            jne .exit
  385.            stdcall kernel_free, [src]
  386. .exit:
  387.            pop edi
  388.            pop esi
  389.            pop ebx
  390. .fail:
  391.            mov eax, [handle]
  392. .fail2:
  393.            ret
  394. endp
  395.  
  396. align 4
  397. proc delete_cursor stdcall, hcursor:dword
  398.            locals
  399.              hsrv       dd ?
  400.              io_code    dd ?
  401.              input      dd ?
  402.              inp_size   dd ?
  403.              output     dd ?
  404.              out_size   dd ?
  405.            endl
  406.  
  407.            mov esi, [hcursor]
  408.            cmp [esi+CURSOR.magic], 'CURS'
  409.            jne .fail
  410. ;           cmp [esi+CURSOR.size], CURSOR_SIZE
  411. ;           jne .fail
  412.  
  413.            mov ebx, [CURRENT_TASK]
  414.            shl ebx, 5
  415.            mov ebx, [CURRENT_TASK+ebx+4]
  416.            cmp ebx, [esi+CURSOR.pid]
  417.            jne .fail
  418.  
  419.            mov ebx, [current_slot]
  420.            cmp esi, [ebx+APPDATA.cursor]
  421.            jne @F
  422.            mov eax, [def_cursor]
  423.            mov [ebx+APPDATA.cursor], eax
  424. @@:
  425.            mov eax, [hcursor]
  426.            call [eax+APPOBJ.destroy]
  427. .fail:
  428.            ret
  429. endp
  430.  
  431. ; param
  432. ;  eax= cursor
  433.  
  434. align 4
  435. destroy_cursor:
  436.  
  437.            push eax
  438.            stdcall kernel_free, [eax+CURSOR.base]
  439.            pop eax
  440.  
  441.            call destroy_kernel_object
  442.            ret
  443.  
  444. align 4
  445. select_cursor:
  446.  
  447.            ret 4
  448.  
  449. align 4
  450. proc init_cursors
  451.  
  452.            cmp [SCR_MODE],word 0x13
  453.            jbe .fail
  454.  
  455.            test word [SCR_MODE], 0x4000
  456.            jz .fail
  457.  
  458.            movzx eax, byte [ScreenBPP]
  459.            mov ebx, [BytesPerScanLine]
  460.            cmp eax, 32
  461.            jne @F
  462.            sub ebx, 128
  463.            jmp .init
  464. @@:
  465.            cmp eax, 24
  466.            jne .fail
  467.            sub ebx, 96
  468. .init:
  469.            mov [cur_def_interl], ebx
  470.  
  471.            stdcall load_driver, szHwMouse
  472.            mov [hw_cursor], eax
  473.            test eax, eax
  474.            jz .sw_mouse
  475.  
  476.            stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
  477.            mov [def_cursor], eax
  478.            ret
  479. .sw_mouse:
  480.            mov [create_cursor], vesa_cursor
  481.  
  482.            stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
  483.            mov [def_cursor], eax
  484.  
  485.            mov ecx, [Screen_Max_X]
  486.            mov edx, [Screen_Max_Y]
  487.            inc ecx
  488.            inc edx
  489.            mov [scr_width], ecx
  490.            mov [scr_height], edx
  491.  
  492.            movzx ebx, byte [ScreenBPP]
  493.            cmp ebx, 32
  494.            jne @F
  495.  
  496.  
  497.            mov dword [select_hw_cursor], select_cursor
  498.            mov dword [set_hw_cursor], cursor_32
  499.            mov dword [hw_restore], restore_32
  500.            ret
  501. @@:
  502.            mov dword [select_hw_cursor], select_cursor
  503.            mov dword [set_hw_cursor], cursor_24
  504.            mov dword [hw_restore], restore_24
  505.            ret
  506. .fail:
  507.            xor eax, eax
  508.            mov dword [select_hw_cursor], eax
  509.            mov dword [set_hw_cursor], eax
  510.            mov dword [hw_restore], eax
  511.            ret
  512. endp
  513.  
  514. align 4
  515. proc restore_24 stdcall, x:dword, y:dword
  516.            locals
  517.              w  dd ?
  518.            endl
  519.  
  520.            mov edi, [cur_saved_base]
  521.            mov edx, [cur_saved_h]
  522.            mov ebx, [cur_saved_interl]
  523.            test edx, edx
  524.            jz  .ret
  525.  
  526.            mov esi, cur_saved_data
  527. @@:
  528.            mov ecx, [cur_saved_w]
  529.            lea ecx, [ecx+ecx*2]
  530.            rep movsb
  531.            add edi, ebx
  532.            dec edx
  533.            jnz @B
  534. .ret:
  535.            ret
  536. endp
  537.  
  538. align 4
  539. proc restore_32 stdcall, x:dword, y:dword
  540.            locals
  541.              w  dd ?
  542.            endl
  543.  
  544.            mov edi, [cur_saved_base]
  545.            mov edx, [cur_saved_h]
  546.            mov ebx, [cur_saved_interl]
  547.            test edx, edx
  548.            jz  .ret
  549.  
  550.            mov esi, cur_saved_data
  551. @@:
  552.            mov ecx, [cur_saved_w]
  553.            rep movsd
  554.            add edi, ebx
  555.            dec edx
  556.            jnz @B
  557. .ret:
  558.            ret
  559. endp
  560.  
  561. align 4
  562. proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword
  563.            locals
  564.              w      dd ?
  565.              h      dd ?
  566.              st     dd ?
  567.              _dx     dd ?
  568.              _dy     dd ?
  569.            endl
  570.  
  571.            mov esi, [hcursor]
  572.            mov ecx, [x]
  573.            mov eax, [y]
  574.            mov ebx, [BytesPerScanLine]
  575.  
  576.            xor edx, edx
  577.            sub ecx, [esi+CURSOR.hot_x]
  578.            mov [x], ecx
  579.            sets dl
  580.            dec edx
  581.            and ecx, edx       ;clip x to 0<=x
  582.            mov edi, ecx
  583.            sub edi, [x]
  584.            mov [_dx], edi
  585.  
  586.            xor edx, edx
  587.            sub eax, [esi+CURSOR.hot_y]
  588.            mov [y], eax
  589.            sets dl
  590.            dec edx
  591.            and eax, edx       ;clip y to 0<=y
  592.            mov edi, eax
  593.            sub edi, [y]
  594.            mov [_dy], edi
  595.  
  596.            mul ebx
  597.            lea esi, [ecx+ecx*2]
  598.            add esi, [LFBAddress]
  599.            add esi, eax
  600.            mov [cur_saved_base],esi
  601.  
  602.            mov edi, [scr_width]
  603.            mov edx, [scr_height]
  604.            mov eax, 32
  605.  
  606.            sub edi, ecx
  607.            cmp edi, eax
  608.            jng @F
  609.            mov edi, eax
  610. @@:
  611.            sub edi, [_dx]
  612.  
  613.            sub edx, [y]
  614.            cmp edx, eax
  615.            jng @F
  616.            mov edx, eax
  617. @@:
  618.            sub edx, [_dy]
  619.  
  620.            mov [w], edi
  621.            mov [h], edx
  622.            mov [cur_saved_w], edi
  623.            mov [cur_saved_h], edx
  624.  
  625.            sub eax, edi
  626.            shl eax, 2       ;lea eax, [eax+eax*2]
  627.            lea edi, [edi+edi*2]
  628.            sub ebx, edi
  629.            mov [cur_saved_interl], ebx
  630.  
  631.            mov edi, cur_saved_data
  632. @@:
  633.            mov ecx, [w]
  634.            lea ecx, [ecx+ecx*2]
  635.            rep movsb
  636.            add esi, ebx
  637.            dec edx
  638.            jnz @B
  639.  
  640. ;draw cursor
  641.            mov edx, eax
  642.            mov edi, [cur_saved_base]
  643.            mov eax, [_dy]
  644.            shl eax, 5
  645.            add eax, [_dx]
  646.            shl eax, 2
  647.  
  648.            mov esi, [hcursor]
  649.            mov esi, [esi+CURSOR.base]
  650.            add esi, eax
  651. .row:
  652.            mov ecx, [w]
  653. .pix:
  654.            lodsd
  655.            test eax, 0xFF000000
  656.            jz @F
  657.  
  658.            mov word [edi], ax
  659.            shr eax, 16
  660.            mov [edi+2],al
  661. @@:
  662.            add edi, 3
  663.            dec ecx
  664.            jnz .pix
  665.  
  666.            add esi, edx
  667.            add edi, ebx
  668.            dec [h]
  669.            jnz .row
  670.            ret
  671. endp
  672.  
  673. align 4
  674. proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword
  675.            locals
  676.              w      dd ?
  677.              h      dd ?
  678.              st     dd ?
  679.              _dx     dd ?
  680.              _dy     dd ?
  681.            endl
  682.  
  683.            mov esi, [hcursor]
  684.            mov ecx, [x]
  685.            mov eax, [y]
  686.            mov ebx, [BytesPerScanLine]
  687.  
  688.            xor edx, edx
  689.            sub ecx, [esi+CURSOR.hot_x]
  690.            mov [x], ecx
  691.            sets dl
  692.            dec edx
  693.            and ecx, edx       ;clip x to 0<=x
  694.            mov edi, ecx
  695.            sub edi, [x]
  696.            mov [_dx], edi
  697.  
  698.            xor edx, edx
  699.            sub eax, [esi+CURSOR.hot_y]
  700.            mov [y], eax
  701.            sets dl
  702.            dec edx
  703.            and eax, edx       ;clip y to 0<=y
  704.            mov edi, eax
  705.            sub edi, [y]
  706.            mov [_dy], edi
  707.  
  708.            mul ebx
  709.            lea esi, [eax+ecx*4]
  710.            add esi, [LFBAddress]
  711.            mov [cur_saved_base],esi
  712.  
  713.            mov edi, [scr_width]
  714.            mov edx, [scr_height]
  715.            mov eax, 32
  716.  
  717.            sub edi, ecx
  718.            cmp edi, eax
  719.            jng @F
  720.            mov edi, eax
  721. @@:
  722.            sub edi, [_dx]
  723.  
  724.            sub edx, [y]
  725.            cmp edx, eax
  726.            jng @F
  727.            mov edx, eax
  728. @@:
  729.            sub edx, [_dy]
  730.  
  731.            mov [w], edi
  732.            mov [h], edx
  733.            mov [cur_saved_w], edi
  734.            mov [cur_saved_h], edx
  735.  
  736.            sub eax, edi
  737.            shl eax, 2
  738.            shl edi, 2
  739.            sub ebx, edi
  740.            mov [cur_saved_interl], ebx
  741.  
  742.            mov edi, cur_saved_data
  743. @@:
  744.            mov ecx, [w]
  745.            rep movsd
  746.            add esi, ebx
  747.            dec edx
  748.            jnz @B
  749.  
  750. ;draw cursor
  751.            mov edx, eax
  752.            mov edi, [cur_saved_base]
  753.            mov eax, [_dy]
  754.            shl eax, 5
  755.            add eax, [_dx]
  756.            shl eax, 2
  757.  
  758.            mov esi, [hcursor]
  759.            mov esi, [esi+CURSOR.base]
  760.            add esi, eax
  761. .row:
  762.            mov ecx, [w]
  763. .pix:
  764.            lodsd
  765.            test eax, 0xFF000000
  766.            jz @F
  767.            mov [edi], eax
  768. @@:
  769.            add edi, 4
  770.            dec ecx
  771.            jnz .pix
  772.            add esi, edx
  773.            add edi, ebx
  774.            dec [h]
  775.            jnz .row
  776.            ret
  777. endp
  778.  
  779. align 4
  780. def_arrow:
  781.   file 'arrow.cur'
  782.  
  783.