Subversion Repositories Kolibri OS

Rev

Rev 996 | 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: 2971 $
  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_SIZE
  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.            mov edi, eax
  317.            mov ecx, 0x1000
  318.            mov edx, PG_SW
  319.            call @mem_alloc@8
  320.            test eax, eax
  321.            mov [edi+CURSOR.base], eax
  322.            jz .fail
  323.  
  324.            mov esi, [.src]
  325.            mov ebx, [.flags]
  326.            cmp bx, LOAD_INDIRECT
  327.            je .indirect
  328.  
  329.            movzx ecx, word [esi+10]
  330.            movzx edx, word [esi+12]
  331.            mov [edi+CURSOR.hot_x], ecx
  332.            mov [edi+CURSOR.hot_y], edx
  333.  
  334.            stdcall vesa_init_cursor, eax, esi
  335.            mov eax, [.hcursor]
  336. .fail:
  337.            add esp, 12
  338.            ret
  339. .indirect:
  340.            shr ebx, 16
  341.            movzx ecx, bh
  342.            movzx edx, bl
  343.            mov [eax+CURSOR.hot_x], ecx
  344.            mov [eax+CURSOR.hot_y], edx
  345.  
  346.            xchg edi, eax
  347.            mov ecx, 1024
  348.            cld
  349.            rep movsd
  350.            add esp, 12
  351.            ret
  352.  
  353. align 4
  354. proc load_cursor stdcall, src:dword, flags:dword
  355.            locals
  356.              handle  dd ?
  357.            endl
  358.  
  359.            xor eax, eax
  360.            cmp [create_cursor], eax
  361.            je .fail2
  362.  
  363.            mov [handle], eax
  364.            cmp word [flags], LOAD_FROM_FILE
  365.            jne @F
  366.  
  367.            stdcall load_file, [src]
  368.            test eax, eax
  369.            mov [src], eax
  370.            jz .fail
  371. @@:
  372.            push ebx
  373.            push esi
  374.            push edi
  375.  
  376.            mov eax, [CURRENT_TASK]
  377.            shl eax, 5
  378.            mov eax, [CURRENT_TASK+eax+4]
  379.            mov ebx, [src]
  380.            mov ecx, [flags]
  381.            call [create_cursor]    ;eax, ebx, ecx
  382.            mov [handle], eax
  383.  
  384.            cmp word [flags], LOAD_FROM_FILE
  385.            jne .exit
  386.  
  387.            mov ecx, [src]
  388.            call @mem_free@4
  389. .exit:
  390.            pop edi
  391.            pop esi
  392.            pop ebx
  393. .fail:
  394.            mov eax, [handle]
  395. .fail2:
  396.            ret
  397. endp
  398.  
  399. align 4
  400. proc delete_cursor stdcall, hcursor:dword
  401.            locals
  402.              hsrv       dd ?
  403.              io_code    dd ?
  404.              input      dd ?
  405.              inp_size   dd ?
  406.              output     dd ?
  407.              out_size   dd ?
  408.            endl
  409.  
  410.            mov esi, [hcursor]
  411.            cmp [esi+CURSOR.magic], 'CURS'
  412.            jne .fail
  413. ;           cmp [esi+CURSOR.size], CURSOR_SIZE
  414. ;           jne .fail
  415.  
  416.            mov ebx, [CURRENT_TASK]
  417.            shl ebx, 5
  418.            mov ebx, [CURRENT_TASK+ebx+4]
  419.            cmp ebx, [esi+CURSOR.pid]
  420.            jne .fail
  421.  
  422.            mov ebx, [current_slot]
  423.            cmp esi, [ebx+APPDATA.cursor]
  424.            jne @F
  425.            mov eax, [def_cursor]
  426.            mov [ebx+APPDATA.cursor], eax
  427. @@:
  428.            mov eax, [hcursor]
  429.            call [eax+APPOBJ.destroy]
  430. .fail:
  431.            ret
  432. endp
  433.  
  434. ; param
  435. ;  eax= cursor
  436.  
  437. align 4
  438. destroy_cursor:
  439.  
  440.            push eax
  441.            mov ecx, [eax+CURSOR.base]
  442.            call @mem_free@4
  443.            pop eax
  444.  
  445.            call destroy_kernel_object
  446.            ret
  447.  
  448. align 4
  449. select_cursor:
  450.  
  451.            ret 4
  452.  
  453. align 4
  454. proc init_cursors
  455.  
  456.            cmp [scr_mode], 0x13
  457.            jbe .fail
  458.  
  459.            test [scr_mode], 0x4000
  460.            jz .fail
  461.  
  462.            mov eax, [ScreenBPP]
  463.            mov ebx, [BytesPerScanLine]
  464.            cmp eax, 32
  465.            jne @F
  466.            sub ebx, 128
  467.            jmp .init
  468. @@:
  469.            cmp eax, 24
  470.            jne .fail
  471.            sub ebx, 96
  472. .init:
  473.  
  474.         ;   stdcall load_driver, szHwMouse
  475.         ;   mov [hw_cursor], eax
  476.         ;   test eax, eax
  477.         ;   jz .sw_mouse
  478.  
  479.         ;   stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
  480.         ;   mov [def_cursor], eax
  481.         ;   ret
  482. .sw_mouse:
  483.            mov [create_cursor], vesa_cursor
  484.  
  485.            stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
  486.            mov [def_cursor], eax
  487.  
  488.            mov ebx, [ScreenBPP]
  489.            cmp ebx, 32
  490.            jne @F
  491.  
  492.            mov dword [select_hw_cursor], select_cursor
  493.            mov dword [set_hw_cursor], cursor_32
  494.            mov dword [hw_restore], restore_32
  495.            ret
  496. @@:
  497.            mov dword [select_hw_cursor], select_cursor
  498.            mov dword [set_hw_cursor], cursor_24
  499.            mov dword [hw_restore], restore_24
  500.            ret
  501. .fail:
  502.            xor eax, eax
  503.            mov dword [select_hw_cursor], eax
  504.            mov dword [set_hw_cursor], eax
  505.            mov dword [hw_restore], eax
  506.            ret
  507. endp
  508.  
  509. align 4
  510. proc restore_24 stdcall, x:dword, y:dword
  511.  
  512.            mov ebx, [cur_saved_base]
  513.            mov edx, [cur.h]
  514.            test edx, edx
  515.            jz  .ret
  516.  
  517.            mov esi, cur_saved_data
  518. @@:
  519.            mov edi, ebx
  520.            add ebx, [BytesPerScanLine]
  521.  
  522.            mov ecx, [cur.w]
  523.            lea ecx, [ecx+ecx*2]
  524.            rep movsb
  525.            dec edx
  526.            jnz @B
  527. .ret:
  528.            ret
  529. endp
  530.  
  531. align 4
  532. proc restore_32 stdcall, x:dword, y:dword
  533.  
  534.            mov ebx, [cur_saved_base]
  535.            mov edx, [cur.h]
  536.            test edx, edx
  537.            jz  .ret
  538.  
  539.            mov esi, cur_saved_data
  540. @@:
  541.            mov edi, ebx
  542.            add ebx, [BytesPerScanLine]
  543.  
  544.            mov ecx, [cur.w]
  545.            rep movsd
  546.            dec edx
  547.            jnz @B
  548. .ret:
  549.            ret
  550. endp
  551.  
  552. align 4
  553. proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword
  554.            locals
  555.              h      dd ?
  556.              _dx     dd ?
  557.              _dy     dd ?
  558.            endl
  559.  
  560.            mov esi, [hcursor]
  561.            mov ecx, [x]
  562.            mov eax, [y]
  563.            mov ebx, [BytesPerScanLine]
  564.  
  565.            xor edx, edx
  566.            sub ecx, [esi+CURSOR.hot_x]
  567.            lea ebx, [ecx+32-1]
  568.            mov [x], ecx
  569.            sets dl
  570.            dec edx
  571.            and ecx, edx       ;clip x to 0<=x
  572.            mov [cur.left], ecx
  573.            mov edi, ecx
  574.            sub edi, [x]
  575.            mov [_dx], edi
  576.  
  577.            xor edx, edx
  578.            sub eax, [esi+CURSOR.hot_y]
  579.            lea edi, [eax+32-1]
  580.            mov [y], eax
  581.            sets dl
  582.            dec edx
  583.            and eax, edx       ;clip y to 0<=y
  584.            mov [cur.top], eax
  585.            mov edx, eax
  586.            sub edx, [y]
  587.            mov [_dy], edx
  588.  
  589.            mul [BytesPerScanLine]
  590.            lea edx, [LFB_BASE+ecx*3]
  591.            add edx, eax
  592.            mov [cur_saved_base],edx
  593.  
  594.            cmp ebx, [Screen_Max_X]
  595.            jbe @F
  596.            mov ebx, [Screen_Max_X]
  597. @@:
  598.            cmp edi, [Screen_Max_Y]
  599.            jbe @F
  600.            mov edi, [Screen_Max_Y]
  601. @@:
  602.            mov [cur.right],  ebx
  603.            mov [cur.bottom], edi
  604.  
  605.            sub ebx, [x]
  606.            sub edi, [y]
  607.            inc ebx
  608.            inc edi
  609.  
  610.            mov [cur.w], ebx
  611.            mov [cur.h], edi
  612.            mov [h], edi
  613.  
  614.            mov eax, edi
  615.            mov edi, cur_saved_data
  616. @@:
  617.            mov esi, edx
  618.            add edx, [BytesPerScanLine]
  619.            mov ecx, [cur.w]
  620.            lea ecx, [ecx+ecx*2]
  621.            rep movsb
  622.            dec eax
  623.            jnz @B
  624.  
  625. ;draw cursor
  626.            mov ebx, [cur_saved_base]
  627.            mov eax, [_dy]
  628.            shl eax, 5
  629.            add eax, [_dx]
  630.  
  631.            mov esi, [hcursor]
  632.            mov esi, [esi+CURSOR.base]
  633.            lea edx, [esi+eax*4]
  634. .row:
  635.            mov ecx, [cur.w]
  636.            mov esi, edx
  637.            mov edi, ebx
  638.            add edx, 32*4
  639.            add ebx, [BytesPerScanLine]
  640. .pix:
  641.            lodsd
  642.            test eax, 0xFF000000
  643.            jz @F
  644.            mov [edi], ax
  645.            shr eax, 16
  646.            mov [edi+2], al
  647. @@:
  648.            add edi, 3
  649.            dec ecx
  650.            jnz .pix
  651.  
  652.            dec [h]
  653.            jnz .row
  654.            ret
  655. endp
  656.  
  657.  
  658. align 4
  659. proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword
  660.            locals
  661.              h      dd ?
  662.              _dx     dd ?
  663.              _dy     dd ?
  664.            endl
  665.  
  666.            mov esi, [hcursor]
  667.            mov ecx, [x]
  668.            mov eax, [y]
  669.  
  670.            xor edx, edx
  671.            sub ecx, [esi+CURSOR.hot_x]
  672.            lea ebx, [ecx+32-1]
  673.            mov [x], ecx
  674.            sets dl
  675.            dec edx
  676.            and ecx, edx       ;clip x to 0<=x
  677.            mov [cur.left], ecx
  678.            mov edi, ecx
  679.            sub edi, [x]
  680.            mov [_dx], edi
  681.  
  682.            xor edx, edx
  683.            sub eax, [esi+CURSOR.hot_y]
  684.            lea edi, [eax+32-1]
  685.            mov [y], eax
  686.            sets dl
  687.            dec edx
  688.            and eax, edx       ;clip y to 0<=y
  689.            mov [cur.top], eax
  690.            mov edx, eax
  691.            sub edx, [y]
  692.            mov [_dy], edx
  693.  
  694.            mul [BytesPerScanLine]
  695.            lea edx, [LFB_BASE+eax+ecx*4]
  696.            mov [cur_saved_base],edx
  697.  
  698.            cmp ebx, [Screen_Max_X]
  699.            jbe @F
  700.            mov ebx, [Screen_Max_X]
  701. @@:
  702.            cmp edi, [Screen_Max_Y]
  703.            jbe @F
  704.            mov edi, [Screen_Max_Y]
  705. @@:
  706.            mov [cur.right],  ebx
  707.            mov [cur.bottom], edi
  708.  
  709.            sub ebx, [x]
  710.            sub edi, [y]
  711.            inc ebx
  712.            inc edi
  713.  
  714.            mov [cur.w], ebx
  715.            mov [cur.h], edi
  716.            mov [h], edi
  717.  
  718.            mov eax, edi
  719.            mov edi, cur_saved_data
  720. @@:
  721.            mov esi, edx
  722.            add edx, [BytesPerScanLine]
  723.            mov ecx, [cur.w]
  724.            rep movsd
  725.            dec eax
  726.            jnz @B
  727.  
  728. ;draw cursor
  729.            mov ebx, [cur_saved_base]
  730.            mov eax, [_dy]
  731.            shl eax, 5
  732.            add eax, [_dx]
  733.  
  734.            mov esi, [hcursor]
  735.            mov esi, [esi+CURSOR.base]
  736.            lea edx, [esi+eax*4]
  737. .row:
  738.            mov ecx, [cur.w]
  739.            mov esi, edx
  740.            mov edi, ebx
  741.            add edx, 32*4
  742.            add ebx, [BytesPerScanLine]
  743. .pix:
  744.            lodsd
  745.            test eax, 0xFF000000
  746.            jz @F
  747.            mov [edi], eax
  748. @@:
  749.            add edi, 4
  750.            dec ecx
  751.            jnz .pix
  752.  
  753.            dec [h]
  754.            jnz .row
  755.            ret
  756. endp
  757.  
  758.  
  759. align 4
  760. def_arrow:
  761.   file 'arrow.cur'
  762.  
  763.