Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 1375 → Rev 1376

/kernel/branches/net/blkdev/cd_drv.inc
12,7 → 12,7
; Íåïîñðåäñòâåííàÿ ðàáîòà ñ óñòðîéñòâîì ÑD (ATAPI)
;**********************************************************
; Àâòîð ÷àñòè èñõîäíîãî òåêñòà Êóëàêîâ Âëàäèìèð Ãåííàäüåâè÷
; Àäàïòàöèÿ, äîðàáîòêà è ðàçðàáîòêà Mario79
; Àäàïòàöèÿ, äîðàáîòêà è ðàçðàáîòêà Mario79,<Lrz>
 
; Ìàêñèìàëüíîå êîëè÷åñòâî ïîâòîðåíèé îïåðàöèè ÷òåíèÿ
MaxRetr equ 10
20,46 → 20,7
; (â òèêàõ)
BSYWaitTime equ 1000 ;2
NoTickWaitTime equ 0xfffff
 
;*************************************************
;* ÏÎËÍÎÅ ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ ÊÎÌÏÀÊÒ-ÄÈÑÊÀ *
;* Ñ÷èòûâàþòñÿ äàííûå ïîëüçîâàòåëÿ, èíôîðìàöèÿ *
;* ñóáêàíàëà è êîíòðîëüíàÿ èíôîðìàöèÿ *
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå *
;* ïåðìåííûå: *
;* ChannelNumber - íîìåð êàíàëà; *
;* DiskNumber - íîìåð äèñêà íà êàíàëå; *
;* CDSectorAddress - àäðåñ ñ÷èòûâàåìîãî ñåêòîðà. *
;* Äàííûå ñ÷èòûâàåòñÿ â ìàññèâ CDDataBuf. *
;*************************************************
ReadCD:
pusha
; Çàäàòü ðàçìåð ñåêòîðà
mov [CDBlockSize],2048 ;2352
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû
call clear_packet_buffer
; Ñôîðìèðîâàòü ïàêåòíóþ êîìàíäó äëÿ ñ÷èòûâàíèÿ
; ñåêòîðà äàííûõ
; Çàäàòü êîä êîìàíäû Read CD
mov [PacketCommand],byte 0x28 ;0xBE
; Çàäàòü àäðåñ ñåêòîðà
mov AX,word [CDSectorAddress+2]
xchg AL,AH
mov word [PacketCommand+2],AX
mov AX,word [CDSectorAddress]
xchg AL,AH
mov word [PacketCommand+4],AX
; mov eax,[CDSectorAddress]
; mov [PacketCommand+2],eax
; Çàäàòü êîëè÷åñòâî ñ÷èòûâàåìûõ ñåêòîðîâ
mov [PacketCommand+8],byte 1
; Çàäàòü ñ÷èòûâàíèå äàííûõ â ïîëíîì îáúåìå
; mov [PacketCommand+9],byte 0xF8
; Ïîäàòü êîìàíäó
call SendPacketDatCommand
popa
ret
 
CDBlockSize equ 2048
;********************************************
;* ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ Ñ ÏÎÂÒÎÐÀÌÈ *
;* Ìíîãîêðàòíîå ïîâòîðåíèå ÷òåíèÿ ïðè ñáîÿõ *
73,8 → 34,9
mov eax,[CDSectorAddress]
mov ebx,[CDDataBuf_pointer]
call cd_calculate_cache
xor edi,edi
add esi,8
mov edi,1
inc edi
.hdreadcache:
; cmp dword [esi+4],0 ; empty
; je .nohdcache
128,10 → 90,50
mov ECX,MaxRetr
@@NextRetr:
; Ïîäàòü êîìàíäó
call ReadCD
cmp [DevErrorCode],0
je @@End_4
;*************************************************
;* ÏÎËÍÎÅ ×ÒÅÍÈÅ ÑÅÊÒÎÐÀ ÊÎÌÏÀÊÒ-ÄÈÑÊÀ *
;* Ñ÷èòûâàþòñÿ äàííûå ïîëüçîâàòåëÿ, èíôîðìàöèÿ *
;* ñóáêàíàëà è êîíòðîëüíàÿ èíôîðìàöèÿ *
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå *
;* ïåðìåííûå: *
;* ChannelNumber - íîìåð êàíàëà; *
;* DiskNumber - íîìåð äèñêà íà êàíàëå; *
;* CDSectorAddress - àäðåñ ñ÷èòûâàåìîãî ñåêòîðà. *
;* Äàííûå ñ÷èòûâàåòñÿ â ìàññèâ CDDataBuf. *
;*************************************************
;ReadCD:
push ecx
; pusha
; Çàäàòü ðàçìåð ñåêòîðà
; mov [CDBlockSize],2048 ;2352
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû
call clear_packet_buffer
; Ñôîðìèðîâàòü ïàêåòíóþ êîìàíäó äëÿ ñ÷èòûâàíèÿ
; ñåêòîðà äàííûõ
; Çàäàòü êîä êîìàíäû Read CD
mov [PacketCommand],byte 0x28 ;0xBE
; Çàäàòü àäðåñ ñåêòîðà
mov AX,word [CDSectorAddress+2]
xchg AL,AH
mov word [PacketCommand+2],AX
mov AX,word [CDSectorAddress]
xchg AL,AH
mov word [PacketCommand+4],AX
; mov eax,[CDSectorAddress]
; mov [PacketCommand+2],eax
; Çàäàòü êîëè÷åñòâî ñ÷èòûâàåìûõ ñåêòîðîâ
mov [PacketCommand+8],byte 1
; Çàäàòü ñ÷èòûâàíèå äàííûõ â ïîëíîì îáúåìå
; mov [PacketCommand+9],byte 0xF8
; Ïîäàòü êîìàíäó
call SendPacketDatCommand
pop ecx
; ret
 
; cmp [DevErrorCode],0
test eax,eax
jz @@End_4
 
or ecx,ecx ;{SPraid.simba} (for cd load)
jz @@End_4
dec ecx
141,8 → 143,8
mov eax,NoTickWaitTime
.wait:
dec eax
cmp eax,0
je @@NextRetr
; test eax,eax
jz @@NextRetr
jmp .wait
@@:
; Çàäåðæêà íà 2,5 ñåêóíäû
154,6 → 156,7
; ja @@Wait
loop @@NextRetr
@@End_4:
mov dword [DevErrorCode],eax
popad
ret
 
163,14 → 166,15
 
; Ìàêñèìàëüíî äîïóñòèìîå âðåìÿ îæèäàíèÿ ðåàêöèè
; óñòðîéñòâà íà ïàêåòíóþ êîìàíäó (â òèêàõ)
 
MaxCDWaitTime equ 1000 ;200 ;10 ñåêóíä
 
uglobal
; Îáëàñòü ïàìÿòè äëÿ ôîðìèðîâàíèÿ ïàêåòíîé êîìàíäû
PacketCommand: rb 12 ;DB 12 DUP (?)
; Îáëàñòü ïàìÿòè äëÿ ïðèåìà äàííûõ îò äèñêîâîäà
;CDDataBuf DB 4096 DUP (0)
; Ðàçìåð ïðèíèìàåìîãî áëîêà äàííûõ â áàéòàõ
CDBlockSize DW ?
;CDBlockSize DW ?
; Àäðåñ ñ÷èòûâàåìîãî ñåêòîðà äàííûõ
CDSectorAddress: DD ?
; Âðåìÿ íà÷àëà î÷åðåäíîé îïåðàöèè ñ äèñêîì
179,7 → 183,7
WURStartTime DD 0
; óêàçàòåëü áóôåðà äëÿ ñ÷èòûâàíèÿ
CDDataBuf_pointer dd 0
 
endg
;****************************************************
;* ÏÎÑËÀÒÜ ÓÑÒÐÎÉÑÒÂÓ ATAPI ÏÀÊÅÒÍÓÞ ÊÎÌÀÍÄÓ, *
;* ÏÐÅÄÓÑÌÀÒÐÈÂÀÞÙÓÞ ÏÅÐÅÄÀ×Ó ÎÄÍÎÃÎ ÑÅÊÒÎÐÀ ÄÀÍÍÛÕ *
190,24 → 194,26
;* DiskNumber - íîìåð äèñêà íà êàíàëå; *
;* PacketCommand - 12-áàéòíûé êîìàíäíûé ïàêåò; *
;* CDBlockSize - ðàçìåð ïðèíèìàåìîãî áëîêà äàííûõ. *
; return eax DevErrorCode
;****************************************************
SendPacketDatCommand:
pushad
mov [DevErrorCode],0
xor eax,eax
; mov byte [DevErrorCode],al
; Çàäàòü ðåæèì CHS
mov [ATAAddressMode],0
mov byte [ATAAddressMode],al
; Ïîñëàòü ATA-êîìàíäó ïåðåäà÷è ïàêåòíîé êîìàíäû
mov [ATAFeatures],0
mov [ATASectorCount],0
mov [ATASectorNumber],0
mov byte [ATAFeatures],al
mov byte [ATASectorCount],al
mov byte [ATASectorNumber],al
; Çàãðóçèòü ðàçìåð ïåðåäàâàåìîãî áëîêà
mov AX,[CDBlockSize]
mov [ATACylinder],AX
mov [ATAHead],0
mov [ATAHead],al
; mov AX,[CDBlockSize]
mov [ATACylinder],CDBlockSize
mov [ATACommand],0A0h
call SendCommandToHDD_1
cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè
jne @@End_8 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè
test eax,eax
; cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè
jnz @@End_8 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè
 
; Îæèäàíèå ãîòîâíîñòè äèñêîâîäà ê ïðèåìó
; ïàêåòíîé êîìàíäû
218,8 → 224,8
cmp [timer_ticks_enable],0
jne @f
dec ecx
cmp ecx,0
je @@Err1_1
; test ecx,ecx
jz @@Err1_1
jmp .test
@@:
call change_task
261,8 → 267,8
cmp [timer_ticks_enable],0
jne @f
dec ecx
cmp ecx,0
je @@Err1_1
; test ecx,ecx
jz @@Err1_1
jmp .test_1
@@:
call change_task
286,7 → 292,7
mov DX,[ATABasePortAddr] ;ïîðò 1x0h
; Çàãðóçèòü â ñ÷åò÷èê ðàçìåð áëîêà â áàéòàõ
xor ecx,ecx
mov CX,[CDBlockSize]
mov CX,CDBlockSize
; Âû÷èñëèòü ðàçìåð áëîêà â 16-ðàçðÿäíûõ ñëîâàõ
shr CX,1 ;ðàçäåëèòü ðàçìåð áëîêà íà 2
; Ïðèíÿòü áëîê äàííûõ
295,20 → 301,28
rep insw
sti
; Óñïåøíîå çàâåðøåíèå ïðèåìà äàííûõ
jmp @@End_8
@@End_8:
xor eax,eax
ret
 
; Çàïèñàòü êîä îøèáêè
@@Err1_1:
mov [DevErrorCode],1
jmp @@End_8
xor eax,eax
inc eax
ret
; mov [DevErrorCode],1
; ret
@@Err6_temp:
mov [DevErrorCode],7
jmp @@End_8
mov eax,7
ret
; mov [DevErrorCode],7
; ret
@@Err6:
mov [DevErrorCode],6
@@End_8:
popad
mov eax,6
ret
; mov [DevErrorCode],6
;@@End_8:
; ret
 
 
 
323,19 → 337,21
;***********************************************
SendPacketNoDatCommand:
pushad
mov [DevErrorCode],0
xor eax,eax
; mov byte [DevErrorCode],al
; Çàäàòü ðåæèì CHS
mov [ATAAddressMode],0
mov byte [ATAAddressMode],al
; Ïîñëàòü ATA-êîìàíäó ïåðåäà÷è ïàêåòíîé êîìàíäû
mov [ATAFeatures],0
mov [ATASectorCount],0
mov [ATASectorNumber],0
mov [ATACylinder],0
mov [ATAHead],0
mov byte [ATAFeatures],al
mov byte [ATASectorCount],al
mov byte [ATASectorNumber],al
mov word [ATACylinder],ax
mov byte [ATAHead],al
mov [ATACommand],0A0h
call SendCommandToHDD_1
cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè
jne @@End_9 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè
; cmp [DevErrorCode],0 ;ïðîâåðèòü êîä îøèáêè
test eax,eax
jnz @@End_9 ;çàêîí÷èòü, ñîõðàíèâ êîä îøèáêè
; Îæèäàíèå ãîòîâíîñòè äèñêîâîäà ê ïðèåìó
; ïàêåòíîé êîìàíäû
mov DX,[ATABasePortAddr]
372,7 → 388,7
out DX,AX
; sti
cmp [ignore_CD_eject_wait],1
je @@End_9
je @@clear_DEC
; Îæèäàíèå ïîäòâåðæäåíèÿ ïðèåìà êîìàíäû
mov DX,[ATABasePortAddr]
add DX,7 ;ïîðò 1õ7h
391,15 → 407,19
jnz @@Err6_1
test AL,40h ;ñîñòîÿíèå ñèãíàëà DRDY
jz @@WaitDevice1_1
jmp @@End_9
 
@@clear_DEC:
and [DevErrorCode],0
popad
ret
; Çàïèñàòü êîä îøèáêè
@@Err1_3:
mov [DevErrorCode],1
xor eax,eax
inc eax
jmp @@End_9
@@Err6_1:
mov [DevErrorCode],6
mov eax,6
@@End_9:
mov [DevErrorCode],eax
popad
ret
 
420,11 → 440,11
;* â ATABasePortAddr - áàçîâûé àäðåñ HDD; *
;* â DevErrorCode - íîëü. *
;* Ïðè âîçíèêíîâåíèè îøèáêè â DevErrorCode áóäåò *
;* âîçâðàùåí êîä îøèáêè. *
;* âîçâðàùåí êîä îøèáêè â eax *
;****************************************************
SendCommandToHDD_1:
pushad
mov [DevErrorCode],0
; pushad
; mov [DevErrorCode],0 not need
; Ïðîâåðèòü çíà÷åíèå êîäà ðåæèìà
cmp [ATAAddressMode],1
ja @@Err2_4
459,8 → 479,8
cmp [timer_ticks_enable],0
jne @f
dec ecx
cmp ecx,0
je @@Err1_4
; test ecx,ecx
jz @@Err1_4
jmp .test
@@:
call change_task
514,28 → 534,35
out DX,AL
sti
; Ñáðîñèòü ïðèçíàê îøèáêè
mov [DevErrorCode],0
jmp @@End_10
; mov [DevErrorCode],0
@@End_10:
xor eax,eax
ret
; Çàïèñàòü êîä îøèáêè
@@Err1_4:
mov [DevErrorCode],1
jmp @@End_10
xor eax,eax
inc eax
; mov [DevErrorCode],1
ret
@@Err2_4:
mov [DevErrorCode],2
jmp @@End_10
mov eax,2
; mov [DevErrorCode],2
ret
@@Err3_4:
mov [DevErrorCode],3
jmp @@End_10
mov eax,3
; mov [DevErrorCode],3
ret
@@Err4_4:
mov [DevErrorCode],4
jmp @@End_10
mov eax,4
; mov [DevErrorCode],4
ret
@@Err5_4:
mov [DevErrorCode],5
mov eax,5
; mov [DevErrorCode],5
; Çàâåðøåíèå ðàáîòû ïðîãðàììû
@@End_10:
ret
; sti
popad
ret
; popad
 
;*************************************************
;* ÎÆÈÄÀÍÈÅ ÃÎÒÎÂÍÎÑÒÈ ÓÑÒÐÎÉÑÒÂÀ Ê ÐÀÁÎÒÅ *
563,8 → 590,8
cmp [DevErrorCode],0
je @@End_11
dec ecx
cmp ecx,0
je .Error
; cmp ecx,0
jz .Error
jmp @@SendCommand
@@:
call change_task
815,7 → 842,7
call EjectMedium
mov [ignore_CD_eject_wait],0
ret
 
iglobal
timer_ATAPI_check dd 0
ATAPI_IDE0_lock db 0
ATAPI_IDE1_lock db 0
822,7 → 849,7
ATAPI_IDE2_lock db 0
ATAPI_IDE3_lock db 0
ignore_CD_eject_wait db 0
 
endg
;*************************************************
;* Ïîëó÷èòü ñîîáùåíèå î ñîáûòèè èëè ñîñòîÿíèè *
;* óñòðîéñòâà *
896,7 → 923,7
 
clear_packet_buffer:
; Î÷èñòèòü áóôåð ïàêåòíîé êîìàíäû
mov [PacketCommand],dword 0
mov [PacketCommand+4],dword 0
mov [PacketCommand+8],dword 0
and [PacketCommand],dword 0
and [PacketCommand+4],dword 0
and [PacketCommand+8],dword 0
ret
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/cdrom.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/fdc.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/flp_drv.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/hd_drv.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/ide_cache.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/rd.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/blkdev/rdsave.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/ETFONT.FNT
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/boot/bootcode.inc
42,7 → 42,7
@@:
call putchar
lodsb
cmp al, 0
test al,al
jnz @b
popa
ret
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/booteng.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/bootet.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/bootge.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/bootru.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/bootstr.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/bootvesa.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/et.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/preboot.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/rdload.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/ru.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/boot/shutdown.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/bus/pci/pci16.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/bus/pci/pci32.inc
30,7 → 30,9
; Description
; entry point for system PCI calls
;***************************************************************************
;mmio_pci_addr equ 0x400 ; set actual PCI address here to activate user-MMIO
 
 
align 4
 
pci_api:
74,9 → 76,18
cmp al,10
jz pci_write_reg ;dword
 
if defined mmio_pci_addr
cmp al,11 ; user-level MMIO functions
jz pci_mmio_init
cmp al,12
jz pci_mmio_map
cmp al,13
jz pci_mmio_unmap
end if
 
no_pci_access_for_applications:
 
mov eax,-1
or eax,-1
 
ret
 
366,19 → 377,150
dec eax
ret
 
if defined mmio_pci_addr ; must be set above
;***************************************************************************
; Function
; pci_mmio_init
;
; Description
; IN: bx = device's PCI bus address (bbbbbbbbdddddfff)
; Returns eax = user heap space available (bytes)
; Error codes
; eax = -1 : PCI user access blocked,
; eax = -2 : device not registered for uMMIO service
; eax = -3 : user heap initialization failure
;***************************************************************************
pci_mmio_init:
cmp bx, mmio_pci_addr
jz @f
mov eax,-2
ret
@@:
call init_heap ; (if not initialized yet)
or eax,eax
jz @f
ret
@@:
mov eax,-3
ret
 
 
;***************************************************************************
; Function
; pci_mmio_map
;
; Description
; maps a block of PCI memory to user-accessible linear address
;
; WARNING! This VERY EXPERIMENTAL service is for one chosen PCI device only!
; The target device address should be set in kernel var mmio_pci_addr
;
; IN: ah = BAR#;
; IN: ebx = block size (bytes);
; IN: ecx = offset in MMIO block (in 4K-pages, to avoid misaligned pages);
;
; Returns eax = MMIO block's linear address in the userspace (if no error)
;
;
; Error codes
; eax = -1 : user access to PCI blocked,
; eax = -2 : an invalid BAR register referred
; eax = -3 : no i/o space on that BAR
; eax = -4 : a port i/o BAR register referred
; eax = -5 : dynamic userspace allocation problem
;***************************************************************************
 
pci_mmio_map:
and edx,0x0ffff
cmp ah,6
jc .bar_0_5
jz .bar_rom
mov eax,-2
ret
.bar_rom:
mov ah, 8 ; bar6 = Expansion ROM base address
.bar_0_5:
push ecx
add ebx, 4095
and ebx,-4096
push ebx
mov bl, ah ; bl = BAR# (0..5), however bl=8 for BAR6
shl bl, 1
shl bl, 1
add bl, 0x10 ; now bl = BAR offset in PCI config. space
mov ax, mmio_pci_addr
mov bh, al ; bh = dddddfff
mov al, 2 ; al : DW to read
call pci_read_reg
or eax, eax
jnz @f
mov eax,-3 ; empty I/O space
jmp mmio_ret_fail
@@:
test eax, 1
jz @f
mov eax,-4 ; damned ports (not MMIO space)
jmp mmio_ret_fail
@@:
pop ecx ; ecx = block size, bytes (expanded to whole page)
mov ebx, ecx ; user_alloc destroys eax, ecx, edx, but saves ebx
push eax ; store MMIO physical address + keep 2DWords in the stack
stdcall user_alloc, ecx
or eax, eax
jnz mmio_map_over
mov eax,-5 ; problem with page allocation
 
mmio_ret_fail:
pop ecx
pop edx
ret
 
mmio_map_over:
mov ecx, ebx ; ecx = size (bytes, expanded to whole page)
shr ecx, 12 ; ecx = number of pages
mov ebx, eax ; ebx = linear address
pop eax ; eax = MMIO start
pop edx ; edx = MMIO shift (pages)
shl edx, 12 ; edx = MMIO shift (bytes)
add eax, edx ; eax = uMMIO physical address
or eax, PG_SHARED
or eax, PG_UW
or eax, PG_NOCACHE
mov edi, ebx
call commit_pages
mov eax, edi
ret
 
;***************************************************************************
; Function
; pci_mmio_unmap_page
;
; Description
; unmaps the linear space previously tied to a PCI memory block
;
; IN: ebx = linear address of space previously allocated by pci_mmio_map
; returns eax = 1 if successfully unmapped
;
; Error codes
; eax = -1 if no user PCI access allowed,
; eax = 0 if unmapping failed
;***************************************************************************
 
pci_mmio_unmap:
stdcall user_free, ebx
ret
 
end if
 
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
uglobal
align 4
; VendID (2), DevID (2), Revision = 0 (1), Class Code (3), FNum (1), Bus (1)
pci_emu_dat: times 30*10 db 0
 
endg
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
align 4
sys_pcibios:
xchg ebx, eax
xchg ecx, eax
xchg edx, eax
xchg esi, eax
xchg edi, eax
cmp [pci_access_enabled], 1
jne .unsupported_func
cmp [pci_bios_entry], 0
470,14 → 612,14
.not_WRITE_CONFIG:
.unsupported_func:
mov ah, 0x81 ; FUNC_NOT_SUPPORTED
.return:mov dword[esp + 8 ], edi
mov dword[esp + 12], esi
.return:mov dword[esp + 4 ], edi
mov dword[esp + 8], esi
.return_abcd:
mov dword[esp + 28], edx
mov dword[esp + 24], edx
.return_abc:
mov dword[esp + 32], ecx
mov dword[esp + 28], ecx
.return_ab:
mov dword[esp + 24], ebx
mov dword[esp + 20], ebx
.return_a:
mov dword[esp + 36], eax
mov dword[esp + 32], eax
ret
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/const.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
309,15 → 309,13
BgrDrawMode equ (OS_BASE+0x033BFF4)
BgrDataWidth equ (OS_BASE+0x033BFF8)
BgrDataHeight equ (OS_BASE+0x033BFFC)
WinMapAddress equ (OS_BASE+0x033C000)
display_data equ (OS_BASE+0x033C000) ;1024*1280=0x140000
 
virtual at (OS_BASE+0x047CF80)
sys_pgmap equ (OS_BASE+0x033C000)
 
virtual at (OS_BASE+0x05FFF80)
tss TSS
end virtual
 
sys_pgmap equ (OS_BASE+0x047F000)
 
HEAP_BASE equ (OS_BASE+0x0800000)
HEAP_MIN_SIZE equ 0x01000000
 
439,7 → 437,8
APP_EV_OFFSET equ 40
 
struc CURSOR
{;common object header
{
;common object header
.magic dd ? ;'CURS'
.destroy dd ? ;internal destructor
.fd dd ? ;next object in list
450,12 → 449,17
.base dd ? ;allocated memory
.hot_x dd ? ;hotspot coords
.hot_y dd ?
 
.list_next dd ? ;next cursor in cursor list
.list_prev dd ? ;prev cursor in cursor list
.dev_obj dd ? ;device depended data
 
.sizeof:
}
virtual at 0
CURSOR CURSOR
end virtual
 
CURSOR_SIZE equ 32
 
struc EVENT
{
511,7 → 515,78
SMAP SMAP
end virtual
 
struc DLLDESCR
{
.bk dd ?
.fd dd ? ;+4
.data dd ? ;+8
.size dd ? ;+12
.timestamp dq ?
.refcount dd ?
.defaultbase dd ?
.coff_hdr dd ?
.symbols_ptr dd ?
.symbols_num dd ?
.symbols_lim dd ?
.exports dd ? ;export table
.name:
.sizeof:
}
 
struc HDLL
{
.fd dd ? ;next object in list
.bk dd ? ;prev object in list
.pid dd ? ;owner id
 
.base dd ? ;mapped base
.size dd ? ;mapped size
.refcount dd ? ;reference counter for this process and this lib
.parent dd ? ;DLLDESCR
.sizeof:
}
 
virtual at 0
DLLDESCR DLLDESCR
end virtual
 
virtual at 0
HDLL HDLL
end virtual
 
struc display_t
{
.x dd ?
.y dd ?
.width dd ?
.height dd ?
.bpp dd ?
.vrefresh dd ?
.pitch dd ?
.lfb dd ?
 
.modes dd ?
.ddev dd ?
.connector dd ?
.crtc dd ?
 
.cr_list.next dd ?
.cr_list.prev dd ?
 
.cursor dd ?
 
.init_cursor dd ?
.select_cursor dd ?
.show_cursor dd ?
.move_cursor dd ?
.restore_cursor dd ?
.disable_mouse dd ?
}
 
virtual at 0
display_t display_t
end virtual
 
struc HEAP_DATA
{
.mutex rd 1
595,7 → 670,8
;}
 
struc SRV
{ .srv_name rb 16 ;ASCIIZ string
{
.srv_name rb 16 ;ASCIIZ string
.magic dd ? ;+0x10 ;'SRV '
.size dd ? ;+0x14 ;size of structure SRV
.fd dd ? ;+0x18 ;next SRV descriptor
602,11 → 678,12
.bk dd ? ;+0x1C ;prev SRV descriptor
.base dd ? ;+0x20 ;service base address
.entry dd ? ;+0x24 ;service START function
.srv_proc dd ? ;+0x28 ;main service handler
.srv_proc dd ? ;+0x28 ;user mode service handler
.srv_proc_ex dd ? ;+0x2C ;kernel mode service handler
.sizeof:
}
 
SRV_FD_OFFSET equ 0x18
SRV_SIZE equ 44
 
DRV_ENTRY equ 1
DRV_EXIT equ -1
/kernel/branches/net/core/conf_lib.inc
12,11 → 12,11
 
$Revision$
 
 
iglobal
conf_path_sect: db 'path',0
 
conf_fname db '/sys/sys.conf',0
 
endg
; set soke kernel configuration
proc set_kernel_conf
locals
64,7 → 64,7
popad
ret
endp
 
iglobal
ugui db 'gui',0
ugui_mouse_speed db 'mouse_speed',0
ugui_mouse_speed_def db '2',0
74,8 → 74,63
udev db 'dev',0
udev_midibase db 'midibase',0
udev_midibase_def db '0x320',0
endg
;set up netvork configuration
proc set_network_conf
locals
par db 30 dup(?)
endl
pushad
 
;[net]
;active
lea eax,[par]
invoke ini.get_int,conf_fname, unet, unet_active, 0
or eax,eax
jz .do_not_set_net
mov eax, [stack_config]
and eax, 0xFFFFFF80
add eax, 3
mov [stack_config], eax
call ash_eth_enable
 
;addr
lea eax,[par]
push eax
invoke ini.get_str,conf_fname, unet, unet_addr, eax,30, unet_def
pop eax
stdcall do_inet_adr,eax
mov [stack_ip], eax
 
;mask
lea eax,[par]
push eax
invoke ini.get_str,conf_fname, unet, unet_mask, eax,30, unet_def
pop eax
stdcall do_inet_adr,eax
mov [subnet_mask], eax
 
;gate
lea eax,[par]
push eax
invoke ini.get_str,conf_fname, unet, unet_gate, eax,30, unet_def
pop eax
stdcall do_inet_adr,eax
mov [gateway_ip], eax
.do_not_set_net:
popad
ret
 
 
endp
iglobal
unet db 'net',0
unet_active db 'active',0
unet_addr db 'addr',0
unet_mask db 'mask',0
unet_gate db 'gate',0
unet_def db 0
endg
; convert string to DWord
proc strtoint stdcall,strs
pushad
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/debug.inc
10,10 → 10,12
 
; diamond, 2006
sys_debug_services:
cmp eax, 9
cmp ebx, 9
ja @f
jmp dword [sys_debug_services_table+eax*4]
jmp dword [sys_debug_services_table+ebx*4]
@@: ret
iglobal
align 4
sys_debug_services_table:
dd debug_set_event_data
dd debug_getcontext
25,21 → 27,21
dd debug_write_process_memory
dd debug_terminate
dd debug_set_drx
 
endg
debug_set_event_data:
; in: ebx = pointer
; in: ecx = pointer
; destroys eax
mov eax, [current_slot]
mov [eax+APPDATA.dbg_event_mem], ebx
mov [eax+APPDATA.dbg_event_mem], ecx
ret
 
get_debuggee_slot:
; in: ebx=PID
; in: ecx=PID
; out: CF=1 if error
; CF=0 and eax=slot*0x20 if ok
; out: interrupts disabled
cli
mov eax, ebx
mov eax, ecx
call pid_to_slot
test eax, eax
jz .ret_bad
56,7 → 58,7
ret
 
debug_detach:
; in: ebx=pid
; in: ecx=pid
; destroys eax,ebx
call get_debuggee_slot
jc .ret
67,54 → 69,55
ret
 
debug_terminate:
; in: ebx=pid
; in: ecx=pid
call get_debuggee_slot
jc debug_detach.ret
mov ecx, eax
shr ecx, 5
push 2
pop ebx
jmp sys_system
; push 2
; pop ebx
mov edx,esi
jmp sysfn_terminate
 
debug_suspend:
; in: ebx=pid
; destroys eax,ebx
; in: ecx=pid
; destroys eax,ecx
cli
mov eax, ebx
mov eax, ecx
call pid_to_slot
shl eax, 5
jz .ret
mov bl, [CURRENT_TASK+eax+TASKDATA.state] ; process state
test bl, bl
mov cl, [CURRENT_TASK+eax+TASKDATA.state] ; process state
test cl, cl
jz .1
cmp bl, 5
cmp cl, 5
jnz .ret
mov bl, 2
.2: mov [CURRENT_TASK+eax+TASKDATA.state], bl
mov cl, 2
.2: mov [CURRENT_TASK+eax+TASKDATA.state], cl
.ret:
sti
ret
.1:
inc ebx
inc ecx
jmp .2
 
do_resume:
mov bl, [CURRENT_TASK+eax+TASKDATA.state]
cmp bl, 1
mov cl, [CURRENT_TASK+eax+TASKDATA.state]
cmp cl, 1
jz .1
cmp bl, 2
cmp cl, 2
jnz .ret
mov bl, 5
.2: mov [CURRENT_TASK+eax+TASKDATA.state], bl
mov cl, 5
.2: mov [CURRENT_TASK+eax+TASKDATA.state], cl
.ret: ret
.1: dec ebx
.1: dec ecx
jmp .2
 
debug_resume:
; in: ebx=pid
; in: ecx=pid
; destroys eax,ebx
cli
mov eax, ebx
mov eax, ecx
call pid_to_slot
shl eax, 5
jz .ret
124,23 → 127,24
 
debug_getcontext:
; in:
; ebx=pid
; ecx=sizeof(CONTEXT)
; edx->CONTEXT
; ecx=pid
; edx=sizeof(CONTEXT)
; esi->CONTEXT
; destroys eax,ecx,edx,esi,edi
cmp ecx, 28h
cmp edx, 28h
jnz .ret
push ebx
mov ebx, edx
; push ecx
; mov ecx, esi
call check_region
pop ebx
; pop ecx
dec eax
jnz .ret
call get_debuggee_slot
jc .ret
mov edi, esi
mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
lea esi, [eax+RING0_STACK_SIZE]
mov edi, edx
 
.ring0:
; note that following code assumes that all interrupt/exception handlers
; saves ring-3 context by pushad in this order
174,23 → 178,24
 
debug_setcontext:
; in:
; ebx=pid
; ecx=sizeof(CONTEXT)
; edx->CONTEXT
; ecx=pid
; edx=sizeof(CONTEXT)
; esi->CONTEXT
; destroys eax,ecx,edx,esi,edi
cmp ecx, 28h
cmp edx, 28h
jnz .ret
push ebx
mov ebx, edx
; push ebx
; mov ebx, edx
call check_region
pop ebx
; pop ebx
dec eax
jnz .ret
call get_debuggee_slot
jc .stiret
; mov esi, edx
mov eax, [eax*8+SLOT_BASE+APPDATA.pl0_stack]
lea edi, [eax+RING0_STACK_SIZE]
mov esi, edx
 
.ring0:
sub edi, 8+12+20h
mov eax, [esi+24h] ;edi
227,22 → 232,26
lea eax, [eax*8+SLOT_BASE+APPDATA.dbg_regs]
; [eax]=dr0, [eax+4]=dr1, [eax+8]=dr2, [eax+C]=dr3
; [eax+10]=dr7
cmp edx, OS_BASE
cmp esi, OS_BASE
jae .errret
cmp cl, 3
cmp dl, 3
ja .errret
mov ebx, dr7
shr ebx, cl
shr ebx, cl
test ebx, 2 ; bit 1+2*index = G0..G3, global break enable
mov ecx, dr7
;fix me
xchg ecx,edx
shr edx, cl
shr edx, cl
xchg ecx,edx
 
test ecx, 2 ; bit 1+2*index = G0..G3, global break enable
jnz .errret2
test ch, ch
test dh, dh
jns .new
; clear breakpoint
movzx ecx, cl
add ecx, ecx
and dword [eax+ecx*2], 0 ; clear DR<i>
btr dword [eax+10h], ecx ; clear L<i> bit
movzx edx, dl
add edx, edx
and dword [eax+edx*2], 0 ; clear DR<i>
btr dword [eax+10h], edx ; clear L<i> bit
test byte [eax+10h], 55h
jnz .okret
; imul eax, ebp, tss_step/32
249,45 → 258,49
; and byte [eax + tss_data + TSS._trap], not 1
and [ebp*8 + SLOT_BASE+APPDATA.dbg_state], not 1
.okret:
and dword [esp+36], 0
and dword [esp+32], 0
sti
ret
.errret:
sti
mov dword [esp+36], 1
mov dword [esp+32], 1
ret
.errret2:
sti
mov dword [esp+36], 2
mov dword [esp+32], 2
ret
.new:
; add new breakpoint
; cl=index; ch=flags; edx=address
test ch, 0xF0
; dl=index; dh=flags; esi=address
test dh, 0xF0
jnz .errret
mov bl, ch
and bl, 3
cmp bl, 2
mov cl, dh
and cl, 3
cmp cl, 2
jz .errret
mov bl, ch
shr bl, 2
cmp bl, 2
mov cl, dh
shr cl, 2
cmp cl, 2
jz .errret
test dl, bl
 
mov ebx,esi
test bl, dl
 
jnz .errret
or byte [eax+10h+1], 3 ; set GE and LE flags
movzx ebx, ch
movzx ecx, cl
 
movzx edx, dh
movzx ecx, dl
add ecx, ecx
bts dword [eax+10h], ecx ; set L<i> flag
add ecx, ecx
mov [eax+ecx], edx ; set DR<i>
mov [eax+ecx], ebx;esi ; set DR<i>
shl edx, cl
mov ebx, 0xF
shl ebx, cl
mov edx, 0xF
shl edx, cl
not edx
and [eax+10h+2], dx
or [eax+10h+2], bx ; set R/W and LEN fields
not ebx
and [eax+10h+2], bx
or [eax+10h+2], dx ; set R/W and LEN fields
; imul eax, ebp, tss_step/32
; or byte [eax + tss_data + TSS._trap], 1
or [ebp*8 + SLOT_BASE+APPDATA.dbg_state], 1
295,51 → 308,51
 
debug_read_process_memory:
; in:
; ebx=pid
; ecx=length
; esi->buffer in debugger
; edx=address in debuggee
; ecx=pid
; edx=length
; edi->buffer in debugger
; esi=address in debuggee
; out: [esp+36]=sizeof(read)
; destroys all
push ebx
mov ebx, esi
; push ebx
; mov ebx, esi
call check_region
pop ebx
; pop ebx
dec eax
jnz .err
call get_debuggee_slot
jc .err
shr eax, 5
mov ebx, esi
; mov ebx, esi
call read_process_memory
sti
mov dword [esp+36], eax
mov dword [esp+32], eax
ret
.err:
or dword [esp+36], -1
or dword [esp+32], -1
ret
 
debug_write_process_memory:
; in:
; ebx=pid
; ecx=length
; esi->buffer in debugger
; edx=address in debuggee
; ecx=pid
; edx=length
; edi->buffer in debugger
; esi=address in debuggee
; out: [esp+36]=sizeof(write)
; destroys all
push ebx
mov ebx, esi
; push ebx
; mov ebx, esi
call check_region
pop ebx
; pop ebx
dec eax
jnz debug_read_process_memory.err
call get_debuggee_slot
jc debug_read_process_memory.err
shr eax, 5
mov ebx, esi
; mov ebx, esi
call write_process_memory
sti
mov [esp+36], eax
mov [esp+32], eax
ret
 
debugger_notify:
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/dll.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
315,7 → 315,7
cmp [edi+SRV.magic], ' SRV'
jne .fail
 
cmp [edi+SRV.size], SRV_SIZE
cmp [edi+SRV.size], SRV.sizeof
jne .fail
 
stdcall [edi+SRV.srv_proc], esi
333,7 → 333,7
endp
 
; param
; ebx= io_control
; ecx= io_control
;
; retval
; eax= error code
340,17 → 340,17
 
align 4
srv_handlerEx:
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
 
mov eax, [ebx+handle]
mov eax, [ecx+handle]
cmp [eax+SRV.magic], ' SRV'
jne .fail
 
cmp [eax+SRV.size], SRV_SIZE
cmp [eax+SRV.size], SRV.sizeof
jne .fail
 
stdcall [eax+SRV.srv_proc], ebx
stdcall [eax+SRV.srv_proc], ecx
ret
.fail:
or eax, -1
402,8 → 402,8
cmp [handler], eax
je .fail
 
mov eax, SRV_SIZE
call malloc ;call alloc_service
mov eax, SRV.sizeof
call malloc
test eax, eax
jz .fail
 
411,13 → 411,15
push edi
mov edi, eax
mov esi, [name]
mov ecx, 16/4
rep movsd
movsd
movsd
movsd
movsd
pop edi
pop esi
 
mov [eax+SRV.magic], ' SRV'
mov [eax+SRV.size], SRV_SIZE
mov [eax+SRV.size], SRV.sizeof
 
mov ebx, srv.fd-SRV_FD_OFFSET
mov edx, [ebx+SRV.fd]
472,8 → 474,8
xor eax, eax
ret
.ok:
mov ebx, [pSym]
mov eax, [ebx+8]
mov eax, [pSym]
mov eax, [eax+8]
ret
endp
 
611,7 → 613,10
jz .cleanup
 
mov [file2], eax
pushfd
cli
stdcall unpack, [file], eax
popfd
stdcall kernel_free, [file]
mov eax, [file2]
mov ebx, [file_size]
676,7 → 681,7
endp
 
align 4
proc fix_coff_symbols stdcall, sec:dword, symbols:dword,\
proc fix_coff_symbols stdcall uses ebx esi, sec:dword, symbols:dword,\
sym_count:dword, strings:dword, imports:dword
locals
retval dd ?
738,7 → 743,8
endp
 
align 4
proc fix_coff_relocs stdcall, coff:dword, sec:dword, sym:dword
proc fix_coff_relocs stdcall uses ebx esi, coff:dword, sym:dword, \
delta:dword
locals
n_sec dd ?
endl
746,8 → 752,8
mov eax, [coff]
movzx ebx, [eax+CFH.nSections]
mov [n_sec], ebx
lea esi, [eax+20]
.fix_sec:
mov esi, [sec]
mov edi, [esi+CFS.PtrReloc]
add edi, [coff]
 
754,7 → 760,7
movzx ecx, [esi+CFS.NumReloc]
test ecx, ecx
jz .next
.next_reloc:
.reloc_loop:
mov ebx, [edi+CRELOC.SymIndex]
add ebx,ebx
lea ebx,[ebx+ebx*8]
777,12 → 783,14
mov eax, [edi+CRELOC.VirtualAddress]
add eax, [esi+CFS.VirtualAddress]
.fix:
add eax, [delta]
add [eax], edx
.next_reloc:
add edi, 10
dec ecx
jnz .next_reloc
jnz .reloc_loop
.next:
add [sec], COFF_SECTION_SIZE
add esi, COFF_SECTION_SIZE
dec [n_sec]
jnz .fix_sec
.exit:
789,6 → 797,43
ret
endp
 
proc rebase_coff stdcall uses ebx esi, coff:dword, sym:dword, \
delta:dword
locals
n_sec dd ?
endl
 
mov eax, [coff]
movzx ebx, [eax+CFH.nSections]
mov [n_sec], ebx
lea esi, [eax+20]
mov edx, [delta]
.fix_sec:
mov edi, [esi+CFS.PtrReloc]
add edi, [coff]
 
movzx ecx, [esi+CFS.NumReloc]
test ecx, ecx
jz .next
.reloc_loop:
cmp [edi+CRELOC.Type], 6
jne .next_reloc
.dir_32:
mov eax, [edi+CRELOC.VirtualAddress]
add eax, [esi+CFS.VirtualAddress]
add [eax+edx], edx
.next_reloc:
add edi, 10
dec ecx
jnz .reloc_loop
.next:
add esi, COFF_SECTION_SIZE
dec [n_sec]
jnz .fix_sec
.exit:
ret
endp
 
align 4
proc load_driver stdcall, driver_name:dword
locals
900,10 → 945,8
jz .link_fail
 
mov ebx, [coff]
add ebx, 20
stdcall fix_coff_relocs, [coff], ebx, [sym]
stdcall fix_coff_relocs, ebx, [sym], 0
 
mov ebx, [coff]
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szVersion
test eax, eax
jz .link_fail
975,117 → 1018,530
ret
endp
 
; in: edx -> COFF_SECTION struct
; out: eax = alignment as mask for bits to drop
coff_get_align:
; Rules:
; - if alignment is not given, use default = 4K;
; - if alignment is given and is no more than 4K, use it;
; - if alignment is more than 4K, revert to 4K.
push ecx
mov cl, byte [edx+CFS.Characteristics+2]
mov eax, 1
shr cl, 4
dec cl
js .default
cmp cl, 12
jbe @f
.default:
mov cl, 12
@@:
shl eax, cl
pop ecx
dec eax
ret
 
align 4
proc load_library stdcall, file_name:dword
locals
fullname rb 260
fileinfo rb 40
coff dd ?
sym dd ?
strings dd ?
img_size dd ?
img_base dd ?
exports dd ?
endl
 
cli
 
stdcall load_file, [file_name]
; resolve file name
mov ebx, [file_name]
lea edi, [fullname+1]
mov byte [edi-1], '/'
stdcall get_full_file_name, edi, 259
test al, al
jz .fail
 
; scan for required DLL in list of already loaded for this process,
; ignore timestamp
mov esi, [CURRENT_TASK]
shl esi, 8
lea edi, [fullname]
mov ebx, [esi+SLOT_BASE+APPDATA.dlls_list_ptr]
test ebx, ebx
jz .not_in_process
mov esi, [ebx+HDLL.fd]
.scan_in_process:
cmp esi, ebx
jz .not_in_process
mov eax, [esi+HDLL.parent]
add eax, DLLDESCR.name
stdcall strncmp, eax, edi, -1
test eax, eax
jnz .next_in_process
; simple variant: load DLL which is already loaded in this process
; just increment reference counters and return address of exports table
inc [esi+HDLL.refcount]
mov ecx, [esi+HDLL.parent]
inc [ecx+DLLDESCR.refcount]
mov eax, [ecx+DLLDESCR.exports]
sub eax, [ecx+DLLDESCR.defaultbase]
add eax, [esi+HDLL.base]
ret
.next_in_process:
mov esi, [esi+HDLL.fd]
jmp .scan_in_process
.not_in_process:
 
; scan in full list, compare timestamp
lea eax, [fileinfo]
stdcall get_fileinfo, edi, eax
test eax, eax
jnz .fail
mov esi, [dll_list.fd]
.scan_for_dlls:
cmp esi, dll_list
jz .load_new
lea eax, [esi+DLLDESCR.name]
stdcall strncmp, eax, edi, -1
test eax, eax
jnz .continue_scan
.test_prev_dll:
mov eax, dword [fileinfo+24] ; last modified time
mov edx, dword [fileinfo+28] ; last modified date
cmp dword [esi+DLLDESCR.timestamp], eax
jnz .continue_scan
cmp dword [esi+DLLDESCR.timestamp+4], edx
jz .dll_already_loaded
.continue_scan:
mov esi, [esi+DLLDESCR.fd]
jmp .scan_for_dlls
 
; new DLL
.load_new:
; load file
stdcall load_file, edi
test eax, eax
jz .fail
mov [coff], eax
mov dword [fileinfo+32], ebx
 
mov [coff], eax
movzx ecx, [eax+CFH.nSections]
; allocate DLLDESCR struct; size is DLLDESCR.sizeof plus size of DLL name
mov esi, edi
mov ecx, -1
xor eax, eax
repnz scasb
not ecx
lea eax, [ecx+DLLDESCR.sizeof]
push ecx
call malloc
pop ecx
test eax, eax
jz .fail_and_free_coff
; save timestamp
lea edi, [eax+DLLDESCR.name]
rep movsb
mov esi, eax
mov eax, dword [fileinfo+24]
mov dword [esi+DLLDESCR.timestamp], eax
mov eax, dword [fileinfo+28]
mov dword [esi+DLLDESCR.timestamp+4], eax
; initialize DLLDESCR struct
and dword [esi+DLLDESCR.refcount], 0 ; no HDLLs yet; later it will be incremented
mov [esi+DLLDESCR.fd], dll_list
mov eax, [dll_list.bk]
mov [dll_list.bk], esi
mov [esi+DLLDESCR.bk], eax
mov [eax+DLLDESCR.fd], esi
 
; calculate size of loaded DLL
mov edx, [coff]
movzx ecx, [edx+CFH.nSections]
xor ebx, ebx
 
lea edx, [eax+20]
add edx, 20
@@:
call coff_get_align
add ebx, eax
not eax
and ebx, eax
add ebx, [edx+CFS.SizeOfRawData]
add ebx, 15
and ebx, not 15
add edx, COFF_SECTION_SIZE
dec ecx
jnz @B
mov [img_size], ebx
 
call init_heap
stdcall user_alloc, [img_size]
 
; it must be nonzero and not too big
mov [esi+DLLDESCR.size], ebx
test ebx, ebx
jz .fail_and_free_dll
cmp ebx, MAX_DEFAULT_DLL_ADDR-MIN_DEFAULT_DLL_ADDR
ja .fail_and_free_dll
; allocate memory for kernel-side image
stdcall kernel_alloc, ebx
test eax, eax
jz .fail
mov [img_base], eax
jz .fail_and_free_dll
mov [esi+DLLDESCR.data], eax
; calculate preferred base address
add ebx, 0x1FFF
and ebx, not 0xFFF
mov ecx, [dll_cur_addr]
lea edx, [ecx+ebx]
cmp edx, MAX_DEFAULT_DLL_ADDR
jb @f
mov ecx, MIN_DEFAULT_DLL_ADDR
lea edx, [ecx+ebx]
@@:
mov [esi+DLLDESCR.defaultbase], ecx
mov [dll_cur_addr], edx
 
; copy sections and set correct values for VirtualAddress'es in headers
push esi
mov edx, [coff]
movzx ebx, [edx+CFH.nSections]
mov edi, [img_base]
lea eax, [edx+20]
mov edi, eax
add edx, 20
cld
@@:
mov [eax+CFS.VirtualAddress], edi
mov esi, [eax+CFS.PtrRawData]
call coff_get_align
add ecx, eax
add edi, eax
not eax
and ecx, eax
and edi, eax
mov [edx+CFS.VirtualAddress], ecx
add ecx, [edx+CFS.SizeOfRawData]
mov esi, [edx+CFS.PtrRawData]
push ecx
mov ecx, [edx+CFS.SizeOfRawData]
test esi, esi
jnz .copy
add edi, [eax+CFS.SizeOfRawData]
xor eax, eax
rep stosb
jmp .next
.copy:
add esi, edx
mov ecx, [eax+CFS.SizeOfRawData]
cld
add esi, [coff]
rep movsb
.next:
add edi, 15 ;-new_app_base
and edi, -16
add eax, COFF_SECTION_SIZE
pop ecx
add edx, COFF_SECTION_SIZE
dec ebx
jnz @B
pop esi
 
; save some additional data from COFF file
; later we will use COFF header, headers for sections and symbol table
; and also relocations table for all sections
mov edx, [coff]
mov ebx, [edx+CFH.pSymTable]
mov edi, dword [fileinfo+32]
sub edi, ebx
jc .fail_and_free_data
mov [esi+DLLDESCR.symbols_lim], edi
add ebx, edx
mov [sym], ebx
movzx ecx, [edx+CFH.nSections]
lea ecx, [ecx*5]
lea edi, [edi+ecx*8+20]
add edx, 20
@@:
movzx eax, [edx+CFS.NumReloc]
lea eax, [eax*5]
lea edi, [edi+eax*2]
add edx, COFF_SECTION_SIZE
sub ecx, 5
jnz @b
stdcall kernel_alloc, edi
test eax, eax
jz .fail_and_free_data
mov edx, [coff]
movzx ecx, [edx+CFH.nSections]
lea ecx, [ecx*5]
lea ecx, [ecx*2+5]
mov [esi+DLLDESCR.coff_hdr], eax
push esi
mov esi, edx
mov edi, eax
rep movsd
pop esi
mov [esi+DLLDESCR.symbols_ptr], edi
push esi
mov ecx, [edx+CFH.nSymbols]
mov [esi+DLLDESCR.symbols_num], ecx
mov ecx, [esi+DLLDESCR.symbols_lim]
mov esi, ebx
rep movsb
pop esi
mov ebx, [esi+DLLDESCR.coff_hdr]
push esi
movzx eax, [edx+CFH.nSections]
lea edx, [ebx+20]
@@:
movzx ecx, [edx+CFS.NumReloc]
lea ecx, [ecx*5]
mov esi, [edx+CFS.PtrReloc]
mov [edx+CFS.PtrReloc], edi
sub [edx+CFS.PtrReloc], ebx
add esi, [coff]
shr ecx, 1
rep movsd
adc ecx, ecx
rep movsw
add edx, COFF_SECTION_SIZE
dec eax
jnz @b
pop esi
 
; fixup symbols
mov edx, ebx
mov eax, [ebx+CFH.nSymbols]
add edx, 20
mov ecx, [esi+DLLDESCR.symbols_num]
lea ecx, [ecx*9]
add ecx,ecx
lea ecx,[ecx+ecx*8] ;ecx*=18 = nSymbols*CSYM_SIZE
add ecx, [sym]
mov [strings], ecx
add ecx, [esi+DLLDESCR.symbols_ptr]
 
lea eax, [edx+20]
stdcall fix_coff_symbols, edx, [esi+DLLDESCR.symbols_ptr], eax,\
ecx, 0
; test eax, eax
; jnz @F
;
;@@:
 
stdcall fix_coff_symbols, eax, [sym], [edx+CFH.nSymbols],\
[strings], dword 0
stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],szEXPORTS
test eax, eax
jnz @F
 
stdcall get_coff_sym,[esi+DLLDESCR.symbols_ptr],[ebx+CFH.nSymbols],sz_EXPORTS
@@:
mov edx, [coff]
movzx ebx, [edx+CFH.nSections]
mov edi, new_app_base
lea eax, [edx+20]
@@:
add [eax+CFS.VirtualAddress], edi ;patch user space offset
add eax, COFF_SECTION_SIZE
dec ebx
jnz @B
mov [esi+DLLDESCR.exports], eax
 
add edx, 20
stdcall fix_coff_relocs, [coff], edx, [sym]
; fix relocs in the hidden copy in kernel memory to default address
; it is first fix; usually this will be enough, but second fix
; can be necessary if real load address will not equal assumption
mov eax, [esi+DLLDESCR.data]
sub eax, [esi+DLLDESCR.defaultbase]
stdcall fix_coff_relocs, ebx, [esi+DLLDESCR.symbols_ptr], eax
 
mov ebx, [coff]
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],szEXPORTS
stdcall kernel_free, [coff]
 
.dll_already_loaded:
inc [esi+DLLDESCR.refcount]
push esi
call init_heap
pop esi
 
mov edi, [esi+DLLDESCR.size]
stdcall user_alloc_at, [esi+DLLDESCR.defaultbase], edi
test eax, eax
jnz @F
jnz @f
stdcall user_alloc, edi
test eax, eax
jz .fail_and_dereference
@@:
mov [img_base], eax
mov eax, HDLL.sizeof
call malloc
test eax, eax
jz .fail_and_free_user
mov ebx, [CURRENT_TASK]
shl ebx, 5
mov edx, [CURRENT_TASK+ebx+TASKDATA.pid]
mov [eax+HDLL.pid], edx
push eax
call init_dlls_in_thread
pop ebx
test eax, eax
jz .fail_and_free_user
mov edx, [eax+HDLL.fd]
mov [ebx+HDLL.fd], edx
mov [ebx+HDLL.bk], eax
mov [eax+HDLL.fd], ebx
mov [edx+HDLL.bk], ebx
mov eax, ebx
mov ebx, [img_base]
mov [eax+HDLL.base], ebx
mov [eax+HDLL.size], edi
mov [eax+HDLL.refcount], 1
mov [eax+HDLL.parent], esi
mov edx, ebx
shr edx, 12
or dword [page_tabs+(edx-1)*4], DONT_FREE_BLOCK
; copy entries of page table from kernel-side image to usermode
; use copy-on-write for user-mode image, so map as readonly
xor edi, edi
mov ecx, [esi+DLLDESCR.data]
shr ecx, 12
.map_pages_loop:
mov eax, [page_tabs+ecx*4]
and eax, not 0xFFF
or al, PG_USER
xchg eax, [page_tabs+edx*4]
test al, 1
jz @f
call free_page
@@:
invlpg [ebx+edi]
inc ecx
inc edx
add edi, 0x1000
cmp edi, [esi+DLLDESCR.size]
jb .map_pages_loop
 
mov ebx, [coff]
stdcall get_coff_sym,[sym],[ebx+CFH.nSymbols],sz_EXPORTS
; if real user-mode base is not equal to preferred base, relocate image
sub ebx, [esi+DLLDESCR.defaultbase]
jz @f
stdcall rebase_coff, [esi+DLLDESCR.coff_hdr], [esi+DLLDESCR.symbols_ptr], ebx
@@:
mov [exports], eax
 
mov eax, [esi+DLLDESCR.exports]
sub eax, [esi+DLLDESCR.defaultbase]
add eax, [img_base]
ret
.fail_and_free_data:
stdcall kernel_free, [esi+DLLDESCR.data]
.fail_and_free_dll:
mov eax, esi
call free
.fail_and_free_coff:
stdcall kernel_free, [coff]
mov eax, [exports]
ret
.fail:
xor eax, eax
ret
.fail_and_free_user:
stdcall user_free, [img_base]
.fail_and_dereference:
mov eax, 1 ; delete 1 reference
call dereference_dll
xor eax, eax
ret
endp
 
; initialize [APPDATA.dlls_list_ptr] for given thread
; DLL is per-process object, so APPDATA.dlls_list_ptr must be
; kept in sync for all threads of one process.
; out: eax = APPDATA.dlls_list_ptr if all is OK,
; NULL if memory allocation failed
init_dlls_in_thread:
mov ebx, [current_slot]
mov eax, [ebx+APPDATA.dlls_list_ptr]
test eax, eax
jnz .ret
push [ebx+APPDATA.dir_table]
mov eax, 8
call malloc
pop edx
test eax, eax
jz .ret
mov [eax], eax
mov [eax+4], eax
mov ecx, [TASK_COUNT]
mov ebx, SLOT_BASE+256
.set:
cmp [ebx+APPDATA.dir_table], edx
jnz @f
mov [ebx+APPDATA.dlls_list_ptr], eax
@@:
add ebx, 256
dec ecx
jnz .set
.ret:
ret
 
; in: eax = number of references to delete, esi -> DLLDESCR struc
dereference_dll:
sub [esi+DLLDESCR.refcount], eax
jnz .ret
mov eax, [esi+DLLDESCR.fd]
mov edx, [esi+DLLDESCR.bk]
mov [eax+DLLDESCR.bk], edx
mov [edx+DLLDESCR.fd], eax
stdcall kernel_free, [esi+DLLDESCR.coff_hdr]
stdcall kernel_free, [esi+DLLDESCR.data]
mov eax, esi
call free
.ret:
ret
 
destroy_hdll:
push ebx ecx esi edi
push eax
mov ebx, [eax+HDLL.base]
mov esi, [eax+HDLL.parent]
mov edx, [esi+DLLDESCR.size]
; The following actions require the context of application where HDLL is mapped.
; However, destroy_hdll can be called in the context of OS thread when
; cleaning up objects created by the application which is destroyed.
; So remember current cr3 and set it to page table of target.
mov eax, [ecx+APPDATA.dir_table]
; Because we cheat with cr3, disable interrupts: task switch would restore
; page table from APPDATA of current thread.
; Also set [current_slot] because it is used by user_free.
pushf
cli
push [current_slot]
mov [current_slot], ecx
mov ecx, cr3
push ecx
mov cr3, eax
push ebx ; argument for user_free
mov eax, ebx
shr ebx, 12
push ebx
mov esi, [esi+DLLDESCR.data]
shr esi, 12
.unmap_loop:
push eax
mov eax, 2
xchg eax, [page_tabs+ebx*4]
mov ecx, [page_tabs+esi*4]
and eax, not 0xFFF
and ecx, not 0xFFF
cmp eax, ecx
jz @f
call free_page
@@:
pop eax
invlpg [eax]
add eax, 0x1000
inc ebx
inc esi
sub edx, 0x1000
ja .unmap_loop
pop ebx
and dword [page_tabs+(ebx-1)*4], not DONT_FREE_BLOCK
call user_free
; Restore context.
pop eax
mov cr3, eax
pop [current_slot]
popf
; Ok, cheating is done.
pop eax
push eax
mov esi, [eax+HDLL.parent]
mov eax, [eax+HDLL.refcount]
call dereference_dll
pop eax
mov edx, [eax+HDLL.bk]
mov ebx, [eax+HDLL.fd]
mov [ebx+HDLL.bk], edx
mov [edx+HDLL.fd], ebx
call free
pop edi esi ecx ebx
ret
 
; ecx -> APPDATA for slot, esi = dlls_list_ptr
destroy_all_hdlls:
test esi, esi
jz .ret
.loop:
mov eax, [esi+HDLL.fd]
cmp eax, esi
jz free
call destroy_hdll
jmp .loop
.ret:
ret
 
align 4
proc stop_all_services
 
stop_all_services:
push ebp
mov edx, [srv.fd]
.next:
cmp edx, srv.fd-SRV_FD_OFFSET
1092,7 → 1548,7
je .done
cmp [edx+SRV.magic], ' SRV'
jne .next
cmp [edx+SRV.size], SRV_SIZE
cmp [edx+SRV.size], SRV.sizeof
jne .next
 
mov ebx, [edx+SRV.entry]
1101,12 → 1557,16
jz .next
 
push edx
stdcall ebx, dword -1
mov ebp, esp
push 0
push -1
call ebx
mov esp, ebp
pop edx
jmp .next
.done:
pop ebp
ret
endp
 
; param
; eax= size
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/export.inc
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/exports.inc
60,10 → 60,6
szClearEvent db 'ClearEvent',0
 
szLoadCursor db 'LoadCursor',0
szSelectHwCursor db 'SelectHwCursor',0
szSetHwCursor db 'SetHwCursor',0
szHwCursorRestore db 'HwCursorRestore', 0
szHwCursorCreate db 'HwCursorCreate', 0
 
szSysMsgBoardStr db 'SysMsgBoardStr', 0
szSysMsgBoardChar db 'SysMsgBoardChar', 0
139,11 → 135,6
 
dd szLoadCursor , load_cursor ;stdcall
 
dd szSelectHwCursor , select_hw_cursor ;import stdcall
dd szSetHwCursor , set_hw_cursor ;import stdcall
dd szHwCursorRestore , hw_restore ;import
dd szHwCursorCreate , create_cursor ;import
 
dd szSysMsgBoardStr , sys_msg_board_str
dd szSysMsgBoardChar , sys_msg_board
dd szGetCurrentTask , get_curr_task
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/ext_lib.inc
13,7 → 13,9
 
$Revision$
 
 
if 0
; The code currently does not work. Kill "if 0/end if" only after correcting
; to current kernel (dll.inc).
macro library [name,fname]
{
forward
315,3 → 317,4
uglobal
s_libname db 64 dup (0)
endg
end if
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/fpu.inc
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/heap.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
140,7 → 140,7
 
mov ecx, [pg_data.kernel_pages]
shl ecx, 12
sub ecx, HEAP_BASE+4096*MEM_BLOCK_SIZE
sub ecx, HEAP_BASE-OS_BASE+4096*MEM_BLOCK_SIZE
mov [heap_size], ecx
mov [heap_free], ecx
mov [ebx+block_size], ecx
759,6 → 759,102
endp
 
align 4
proc user_alloc_at stdcall, address:dword, alloc_size:dword
 
push ebx
push esi
push edi
 
mov ebx, [current_slot]
mov edx, [address]
and edx, not 0xFFF
mov [address], edx
sub edx, 0x1000
jb .error
mov esi, [ebx+APPDATA.heap_base]
mov edi, [ebx+APPDATA.heap_top]
cmp edx, esi
jb .error
.scan:
cmp esi, edi
jae .error
mov ebx, esi
shr ebx, 12
mov eax, [page_tabs+ebx*4]
mov ecx, eax
and ecx, 0xFFFFF000
add ecx, esi
cmp edx, ecx
jb .found
mov esi, ecx
jmp .scan
.error:
xor eax, eax
pop edi
pop esi
pop ebx
ret
.found:
test al, FREE_BLOCK
jz .error
mov eax, ecx
sub eax, edx
sub eax, 0x1000
cmp eax, [alloc_size]
jb .error
 
; Here we have 1 big free block which includes requested area.
; In general, 3 other blocks must be created instead:
; free at [esi, edx);
; busy at [edx, edx+0x1000+ALIGN_UP(alloc_size,0x1000));
; free at [edx+0x1000+ALIGN_UP(alloc_size,0x1000), ecx)
; First or third block (or both) may be absent.
mov eax, edx
sub eax, esi
jz .nofirst
or al, FREE_BLOCK
mov [page_tabs+ebx*4], eax
.nofirst:
mov eax, [alloc_size]
add eax, 0x1FFF
and eax, not 0xFFF
mov ebx, edx
add edx, eax
shr ebx, 12
or al, USED_BLOCK
mov [page_tabs+ebx*4], eax
shr eax, 12
dec eax
jz .second_nofill
inc ebx
.fill:
mov dword [page_tabs+ebx*4], 2
inc ebx
dec eax
jnz .fill
.second_nofill:
sub ecx, edx
jz .nothird
or cl, FREE_BLOCK
mov [page_tabs+ebx*4], ecx
.nothird:
 
mov edx, [current_slot]
mov ebx, [alloc_size]
add ebx, 0xFFF
and ebx, not 0xFFF
add ebx, [edx+APPDATA.mem_size]
call update_mem_size
 
mov eax, [address]
 
pop edi
pop esi
pop ebx
ret
endp
 
align 4
proc user_free stdcall, base:dword
 
push esi
1221,10 → 1317,10
and eax, SHM_OPEN_MASK
mov [action], eax
 
mov eax, [name]
test eax, eax
mov ebx, [name]
test ebx, ebx
mov edx, E_PARAM
jz .exit
jz .fail
 
mov esi, [shmem_list.fd]
align 4
1233,7 → 1329,7
je .not_found
 
lea edx, [esi+SMEM.name] ; link , base, size
stdcall strncmp, edx, eax, 32
stdcall strncmp, edx, ebx, 32
test eax, eax
je .found
 
1245,7 → 1341,7
 
cmp eax, SHM_OPEN
mov edx, E_NOTFOUND
je .exit
je .fail
 
cmp eax, SHM_CREATE
mov edx, E_PARAM
1252,13 → 1348,13
je .create_shm
 
cmp eax, SHM_OPEN_ALWAYS
jne .exit
jne .fail
 
.create_shm:
 
mov ecx, [size]
test ecx, ecx
jz .exit
jz .fail
 
add ecx, 4095
and ecx, -4096
1269,7 → 1365,7
test eax, eax
mov esi, eax
mov edx, E_NOMEM
jz .exit
jz .fail
 
stdcall kernel_alloc, [size]
test eax, eax
1312,7 → 1408,7
je .create_map
 
cmp eax, SHM_OPEN_ALWAYS
jne .exit
jne .fail
 
.create_map:
 
1321,7 → 1417,7
cmp eax, [esi+SMEM.access]
mov [access], eax
mov edx, E_ACCESS
ja .exit
ja .fail
 
mov ebx, [CURRENT_TASK]
shl ebx, 5
1332,12 → 1428,14
test eax, eax
mov edi, eax
mov edx, E_NOMEM
jz .exit
jz .fail
 
inc [esi+SMEM.refcount]
 
mov [edi+SMAP.magic], 'SMAP'
mov [edi+SMAP.destroy], destroy_smap
mov [edi+SMAP.parent], esi
mov [edi+SMAP.base], 0
mov [edi+SMAP.parent], 0
 
stdcall user_alloc, [esi+SMEM.size]
test eax, eax
1345,9 → 1443,7
mov edx, E_NOMEM
jz .cleanup2
 
lock inc [esi+SMEM.refcount]
mov [edi+SMAP.base], eax
mov [edi+SMAP.parent], esi
 
mov ecx, [esi+SMEM.size]
mov [size], ecx
1374,10 → 1470,10
xor edx, edx
 
cmp [owner_access], 0
jne .exit
 
jne .fail
.exit:
mov edx, [size]
.exit:
.fail:
mov eax, [mapped]
 
popfd
1385,13 → 1481,14
pop esi
pop ebx
ret
 
.cleanup:
mov [size], edx
mov eax, esi
call free
jmp .exit
 
.cleanup2:
mov [size], edx
mov eax, edi
call destroy_smap
jmp .exit
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/malloc.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
20,6 → 20,7
; esi= nb
; ebx= idx
;
align 16
malloc:
push esi
 
134,13 → 135,17
mov [eax+12], ecx ; r->bk = B;
mov eax, ebx
pop esi
mov [mst.mutex], 0
ret
.small:
 
; if (ms.treemap != 0 && (mem = malloc_small(nb)) != 0)
 
cmp [mst.treemap], 0
je .from_top
;;;;;;;;;;; start a change <lrz>
mov eax,[mst.treemap]
test eax,eax
;;;;;;;;;;; end the change <lrz>
; cmp [mst.treemap], 0
jz .from_top
mov eax, esi
call malloc_small
test eax, eax
196,7 → 201,6
; param
; eax= mem
 
align 4
free:
push edi
mov edi, eax
246,7 → 250,7
shr ecx, 3
cmp eax, edx
jne @F
and [mst.smallmap], ecx
btr [mst.smallmap], ecx
@@:
mov [eax+12], edx ;F->bk = B;
mov [edx+8], eax ;B->fd = F
383,7 → 387,6
; ecx = chunk
; eax = size
 
align 4
insert_chunk:
 
cmp eax, 256
416,13 → 419,11
and [mst.mutex], 0
ret
 
align 4
 
; param
; esi= chunk
; ebx= size
 
align 4
insert_large_chunk:
 
; I = compute_tree_index(S);
475,7 → 476,6
shl eax, cl ;eax= K
 
jmp .loop
 
.not_eq_size:
 
; C = &(T->child[(K >> 31) & 1]);
517,7 → 517,6
mov [esi+8], eax
mov [esi+12], edx
ret
 
.insert_child:
 
; *C = X;
536,7 → 535,6
; param
; edx= chunk
 
align 4
unlink_large_chunk:
 
mov eax, [edx+12]
593,6 → 591,7
btr [mst.treemap], ecx
pop edi
ret
.l3:
cmp [edi+16], edx
jne @F
599,11 → 598,14
 
mov [edi+16], eax
jmp .l4
@@:
mov [edi+20], eax
.l4:
test eax, eax
je .done
.l5:
mov [eax+24], edi
mov ecx, [edx+16]
612,6 → 614,7
 
mov [eax+16], ecx
mov [ecx+24], eax
.l6:
mov edx, [edx+20]
test edx, edx
619,6 → 622,7
 
mov [eax+20], edx
mov [edx+24], eax
.done:
pop edi
ret
626,7 → 630,6
; param
; esi= nb
 
align 4
malloc_small:
push ebp
mov ebp, esi
641,8 → 644,10
mov edi, [ecx+4]
and edi, -4
sub edi, esi
.loop:
mov ebx, ecx
.loop_1:
 
; while ((t = leftmost_child(t)) != 0)
652,8 → 657,10
jz @F
mov ecx, eax
jmp .l1
@@:
mov ecx, [ecx+20]
.l1:
test ecx, ecx
jz .unlink
704,6 → 711,7
 
lea eax, [ebx+8]
ret
.split:
 
; v->head = nb|PINUSE_BIT|CINUSE_BIT;
736,6 → 744,7
pop ebp
lea eax, [ebx+8]
ret
.large:
lea eax, [ebx+8]
push eax
750,12 → 759,12
; param
; esi= nb
 
align 4
malloc_large:
.idx equ esp+4
.rst equ esp
 
push ebp
push esi
push edi
sub esp, 8
; v = 0;
789,11 → 798,13
jne @F
xor ecx, ecx
jmp .l1
@@:
mov edx, ecx
shr edx, 1
mov ecx, 37
sub ecx, edx
.l1:
mov edx, ebx
shl edx, cl
800,6 → 811,7
 
; rst = 0;
mov [.rst], ebp
.loop:
 
; trem = (t->head & ~INUSE_BITS) - nb;
819,6 → 831,7
mov ebp, eax
mov edi, ecx
je .l2
@@:
 
; rt = t->child[1];
840,6 → 853,7
 
; rst = rt;
mov [.rst], ecx
@@:
; if (t == 0)
 
850,9 → 864,11
 
add edx, edx
jmp .loop
@@:
; t = rst;
mov eax, [.rst]
.l2:
; if (t == 0 && v == 0)
 
861,6 → 877,7
test ebp, ebp
jne .l7
mov ecx, [.idx]
.l3:
 
; leftbits = (-1<<idx) & ms.treemap;
874,11 → 891,13
bsf eax, edx
; t = ms.treebins[i];
mov eax, [mst.treebins+eax*4]
@@:
 
; while (t != 0)
test eax, eax
jz .l5
.l4:
 
; trem = (t->head & ~INUSE_BITS) - nb;
896,6 → 915,7
mov edi, ecx
; v = t;
mov ebp, eax
@@:
 
; t = leftmost_child(t);
905,8 → 925,10
je @F
mov eax, ecx
jmp .l6
@@:
mov eax, [eax+20]
.l6:
 
; while (t != 0)
913,6 → 935,7
 
test eax, eax
jne .l4
.l5:
 
; if (v != 0)
919,6 → 942,7
 
test ebp, ebp
jz .done
.l7:
 
; r = chunk_plus_offset((mchunkptr)v, nb);
947,8 → 971,10
lea eax, [ebp+8]
add esp, 8
pop edi
pop esi
pop ebp
ret
.large:
 
; v->head = nb|PINUSE_BIT|CINUSE_BIT;
971,16 → 997,18
lea eax, [ebp+8]
add esp, 8
pop edi
pop esi
pop ebp
ret
.done:
add esp, 8
pop edi
pop esi
pop ebp
xor eax, eax
ret
 
align 4
init_malloc:
 
stdcall kernel_alloc, 0x40000
989,6 → 1017,7
mov [mst.topsize], 128*1024
mov dword [eax+4], (128*1024) or 1
mov eax, mst.smallbins
@@:
mov [eax+8], eax
mov [eax+12], eax
998,6 → 1027,3
 
ret
 
 
 
 
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/memory.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
167,7 → 167,7
@@:
mov [page_tabs+eax*4], edx
; push eax
; invlpg [ebx]
invlpg [ebx]
; pop eax
inc eax
add ebx, edi
205,7 → 205,7
@@:
mov [page_tabs+ebx*4], eax
; push eax
; invlpg [edi]
invlpg [edi]
; pop eax
add edi, edx
add eax, edx
321,8 → 321,17
cmp dword [LFBAddress], -1
jne @f
mov [BOOT_VAR+0x901c],byte 2
stdcall kernel_alloc, 0x280000
mov [LFBAddress], eax
stdcall alloc_pages, (0x280000 / 4096)
 
push eax
call alloc_page
stdcall map_page_table, LFB_BASE, eax
pop eax
or eax, PG_UW
mov ebx, LFB_BASE
mov ecx, 0x280000 / 4096
call commit_pages
mov [LFBAddress], dword LFB_BASE
ret
@@:
test [SCR_MODE],word 0100000000000000b
334,7 → 343,7
 
mov edx, LFB_BASE
mov esi, [LFBAddress]
mov edi, 0x00800000
mov edi, 0x00C00000
mov dword [exp_lfb+4], edx
 
shr edi, 12
558,14 → 567,6
push ebx ;that is locals: .err_addr = cr2
inc [pg_data.pages_faults]
 
; push eax
; push edx
; mov edx, 0x400 ;bochs
; mov al,0xff ;bochs
; out dx, al ;bochs
; pop edx
; pop eax
 
mov eax, [pf_err_code]
 
cmp ebx, OS_BASE ;ebx == .err_addr
592,6 → 593,11
pop ebx ;restore exception number (#PF)
ret
 
; xchg bx, bx
; add esp,12 ;clear in stack: locals(.err_addr) + #PF + ret_to_caller
; restore_ring3_context
; iretd
 
.user_space:
test eax, PG_MAP
jnz .err_access ;Ñòðàíèöà ïðèñóòñòâóåò
614,7 → 620,7
test eax, eax
jz .fail
 
stdcall map_page,[.err_addr],eax,dword PG_UW
stdcall map_page,[.err_addr],eax,PG_UW
 
mov edi, [.err_addr]
and edi, 0xFFFFF000
627,9 → 633,40
restore_ring3_context
iretd
 
.err_access = .fail
;íèêîãäà íå ïðîèñõîäèò
;jmp .fail
.err_access:
; access denied? this may be a result of copy-on-write protection for DLL
; check list of HDLLs
and ebx, not 0xFFF
mov eax, [CURRENT_TASK]
shl eax, 8
mov eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
test eax, eax
jz .fail
mov esi, [eax+HDLL.fd]
.scan_hdll:
cmp esi, eax
jz .fail
mov edx, ebx
sub edx, [esi+HDLL.base]
cmp edx, [esi+HDLL.size]
jb .fault_in_hdll
.scan_hdll.next:
mov esi, [esi+HDLL.fd]
jmp .scan_hdll
.fault_in_hdll:
; allocate new page, map it as rw and copy data
call alloc_page
test eax, eax
jz .fail
stdcall map_page,ebx,eax,PG_UW
mov edi, ebx
mov ecx, 1024
sub ebx, [esi+HDLL.base]
mov esi, [esi+HDLL.parent]
mov esi, [esi+DLLDESCR.data]
add esi, ebx
rep movsd
jmp .exit
 
.kernel_space:
test eax, PG_MAP
677,14 → 714,17
jmp .exit
endp
 
align 4
proc map_mem stdcall, lin_addr:dword,pdir:dword,\
ofs:dword,buf_size:dword
mov eax, [buf_size]
test eax, eax
; returns number of mapped bytes
proc map_mem stdcall, lin_addr:dword,slot:dword,\
ofs:dword,buf_size:dword,req_access:dword
push 0 ; initialize number of mapped bytes
 
cmp [buf_size], 0
jz .exit
 
mov eax, [pdir]
mov eax, [slot]
shl eax, 8
mov eax, [SLOT_BASE+eax+APPDATA.dir_table]
and eax, 0xFFFFF000
 
stdcall map_page,[ipc_pdir],eax,PG_UW
716,10 → 756,11
and edx, 0x3FF
mov esi, [ipc_ptab]
 
.map: mov eax, [esi+edx*4]
and eax, 0xFFFFF000
jz .exit
stdcall map_page,edi,eax,PG_UW
.map:
stdcall safe_map_page,[slot],[req_access],[ofs]
jnc .exit
add dword [ebp-4], 4096
add [ofs], 4096
dec ecx
jz .exit
add edi, 0x1000
736,20 → 777,23
jmp .map
 
.exit:
pop eax
ret
endp
 
align 4
proc map_memEx stdcall, lin_addr:dword,pdir:dword,\
ofs:dword,buf_size:dword
mov eax, [buf_size]
test eax, eax
proc map_memEx stdcall, lin_addr:dword,slot:dword,\
ofs:dword,buf_size:dword,req_access:dword
push 0 ; initialize number of mapped bytes
 
cmp [buf_size], 0
jz .exit
 
mov eax, [pdir]
mov eax, [slot]
shl eax, 8
mov eax, [SLOT_BASE+eax+APPDATA.dir_table]
and eax, 0xFFFFF000
 
stdcall map_page,[proc_mem_pdir],eax,dword PG_UW
stdcall map_page,[proc_mem_pdir],eax,PG_UW
mov ebx, [ofs]
shr ebx, 22
mov esi, [proc_mem_pdir]
758,7 → 802,7
and eax, 0xFFFFF000
test eax, eax
jz .exit
stdcall map_page,edi,eax,dword PG_UW
stdcall map_page,edi,eax,PG_UW
 
@@: mov edi, [lin_addr]
and edi, 0xFFFFF000
772,22 → 816,102
and edx, 0x3FF
mov esi, [proc_mem_tab]
 
.map: mov eax, [esi+edx*4]
; and eax, 0xFFFFF000
; test eax, eax
; jz .exit
stdcall map_page,edi,eax,dword PG_UW
.map:
stdcall safe_map_page,[slot],[req_access],[ofs]
jnc .exit
add dword [ebp-4], 0x1000
add edi, 0x1000
add [ofs], 0x1000
inc edx
dec ecx
jnz .map
.exit:
pop eax
ret
endp
 
; in: esi+edx*4 = pointer to page table entry
; in: [slot], [req_access], [ofs] on the stack
; in: edi = linear address to map
; out: CF cleared <=> failed
; destroys: only eax
proc safe_map_page stdcall, slot:dword, req_access:dword, ofs:dword
mov eax, [esi+edx*4]
test al, PG_MAP
jz .not_present
test al, PG_WRITE
jz .resolve_readonly
; normal case: writable page, just map with requested access
.map:
stdcall map_page, edi, eax, [req_access]
stc
.fail:
ret
.not_present:
; check for alloc-on-demand page
test al, 2
jz .fail
; allocate new page, save it to source page table
push ecx
call alloc_page
pop ecx
test eax, eax
jz .fail
or al, PG_UW
mov [esi+edx*4], eax
jmp .map
.resolve_readonly:
; readonly page, probably copy-on-write
; check: readonly request of readonly page is ok
test [req_access], PG_WRITE
jz .map
; find control structure for this page
pushf
cli
cld
push ebx ecx
mov eax, [slot]
shl eax, 8
mov eax, [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
test eax, eax
jz .no_hdll
mov ecx, [eax+HDLL.fd]
.scan_hdll:
cmp ecx, eax
jz .no_hdll
mov ebx, [ofs]
and ebx, not 0xFFF
sub ebx, [ecx+HDLL.base]
cmp ebx, [ecx+HDLL.size]
jb .hdll_found
mov ecx, [ecx+HDLL.fd]
jmp .scan_hdll
.no_hdll:
pop ecx ebx
popf
clc
ret
.hdll_found:
; allocate page, save it in page table, map it, copy contents from base
mov eax, [ecx+HDLL.parent]
add ebx, [eax+DLLDESCR.data]
call alloc_page
test eax, eax
jz .no_hdll
or al, PG_UW
mov [esi+edx*4], eax
stdcall map_page, edi, eax, [req_access]
push esi edi
mov esi, ebx
mov ecx, 4096/4
rep movsd
pop edi esi
pop ecx ebx
popf
stc
ret
endp
 
 
 
sys_IPC:
;input:
; eax=1 - set ipc buffer area
870,15 → 994,15
mov ecx, [ipc_tmp]
cmp esi, 0x40000-0x1000 ; size of [ipc_tmp] minus one page
jbe @f
push eax esi edi
push esi edi
add esi,0x1000
stdcall alloc_kernel_space,esi
mov ecx, eax
pop edi esi eax
pop edi esi
@@:
mov [used_buf], ecx
stdcall map_mem, ecx, [SLOT_BASE+eax+0xB8],\
edi, esi
stdcall map_mem, ecx, [dst_slot],\
edi, esi, PG_SW
 
mov edi, [dst_offset]
add edi, [used_buf]
986,109 → 1110,99
mov [ecx+24], eax
ret
.fail:
mov dword [esp+32], -1
or dword [esp+32], -1
ret
 
iglobal
align 4
f68call:
dd f68.11
dd f68.12
dd f68.13
dd f68.14
dd f68.11 ; init_heap
dd f68.12 ; user_alloc
dd f68.13 ; user_free
dd f68.14 ; get_event_ex
dd f68.fail ;moved to f68.24
dd f68.16
dd f68.17
dd f68.16 ; get_service
dd f68.17 ; call_service
dd f68.fail ;moved to f68.25
dd f68.19
dd f68.20
dd f68.21
dd f68.22
dd f68.23
dd f68.19 ; load_dll
dd f68.20 ; user_realloc
dd f68.21 ; load_driver
dd f68.22 ; shmem_open
dd f68.23 ; shmem_close
dd f68.24
dd f68.25
 
endg
align 4
f68:
cmp eax,4
jle sys_sheduler
cmp ebx,4
jbe sys_sheduler
 
cmp eax, 11
cmp ebx, 11
jb .fail
 
cmp eax, 25
cmp ebx, 25
ja .fail
 
jmp dword [f68call+eax*4-11*4]
jmp dword [f68call+ebx*4-11*4]
.11:
call init_heap
mov [esp+36], eax
mov [esp+32], eax
ret
.12:
stdcall user_alloc, ebx
mov [esp+36], eax
stdcall user_alloc, ecx
mov [esp+32], eax
ret
.13:
stdcall user_free, ebx
mov [esp+36], eax
stdcall user_free, ecx
mov [esp+32], eax
ret
.14:
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
mov edi,ebx
mov edi,ecx
call get_event_ex
mov [esp+36], eax
mov [esp+32], eax
ret
.24:
mov eax, [current_slot]
xchg ebx, [eax+APPDATA.exc_handler]
xchg ecx, [eax+APPDATA.except_mask]
mov [esp+36], ebx ; reg_eax+8
mov [esp+24], ecx ; reg_ebx+8
ret
.16:
test ebx, ebx
test ecx, ecx
jz .fail
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
stdcall get_service, ebx
mov [esp+36], eax
stdcall get_service, ecx
mov [esp+32], eax
ret
.17:
call srv_handlerEx ;ebx
mov [esp+36], eax
call srv_handlerEx ;ecx
mov [esp+32], eax
ret
.25:
cmp ebx,32
jae .fail
mov eax, [current_slot]
btr [eax+APPDATA.except_mask],ebx
setc byte[esp+36]
jecxz @f
bts [eax+APPDATA.except_mask],ebx
@@: ret
.19:
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
stdcall load_library, ebx
mov [esp+36], eax
stdcall load_library, ecx
mov [esp+32], eax
ret
.20:
mov eax, ecx
call user_realloc
mov [esp+36], eax
mov eax, edx
mov ebx, ecx
call user_realloc ;in: eax = pointer, ebx = new size
mov [esp+32], eax
ret
.21:
cmp ecx, OS_BASE
jae .fail
 
cmp ebx, OS_BASE
jae .fail
 
stdcall load_PE, ebx
 
mov edi, edx
stdcall load_PE, ecx
mov esi, eax
test eax, eax
jz @F
 
mov esi, eax
stdcall eax, DRV_ENTRY
 
push edi
push DRV_ENTRY
call eax
add esp, 8
test eax, eax
jz @F
 
1095,28 → 1209,45
mov [eax+SRV.entry], esi
 
@@:
mov [esp+36], eax
mov [esp+32], eax
ret
.22:
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
 
stdcall shmem_open, ebx, ecx, edx
mov [esp+28], edx
mov [esp+36], eax
stdcall shmem_open, ecx, edx, esi
mov [esp+24], edx
mov [esp+32], eax
ret
 
.23:
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae .fail
 
stdcall shmem_close, ebx
mov [esp+36], eax
stdcall shmem_close, ecx
mov [esp+32], eax
ret
.24:
mov eax, [current_slot]
xchg ecx, [eax+APPDATA.exc_handler]
xchg edx, [eax+APPDATA.except_mask]
mov [esp+32], ecx ; reg_eax+8
mov [esp+20], edx ; reg_ebx+8
ret
.25:
cmp ecx,32
jae .fail
mov eax, [current_slot]
btr [eax+APPDATA.except_mask],ecx
setc byte[esp+32]
jecxz @f
bts [eax+APPDATA.except_mask],ecx
@@:
ret
 
.fail:
xor eax, eax
mov [esp+36], eax
mov [esp+32], eax
ret
 
align 4
1156,41 → 1287,52
 
mov ecx, 0x2FF
rdmsr ;
; has BIOS already initialized MTRRs?
test ah, 8
jnz .skip_init
; rarely needed, so mainly placeholder
; main memory - cached
push eax
 
xor edx, edx
xor eax, eax
mov ecx, 0x2FF
wrmsr ;disable all MTRR
 
mov eax, [MEM_AMOUNT]
; round eax up to next power of 2
dec eax
bsr ecx, eax
mov eax, 2
shl eax, cl
stdcall set_mtrr, edx,edx,eax,MEM_WB
stdcall set_mtrr, 1,[LFBAddress],[LFBSize],MEM_WC
mov ebx, 2
shl ebx, cl
dec ebx
; base of memory range = 0, type of memory range = MEM_WB
xor edx, edx
mov eax, MEM_WB
mov ecx, 0x200
wrmsr
; mask of memory range = 0xFFFFFFFFF - (size - 1), ebx = size - 1
mov eax, 0xFFFFFFFF
mov edx, 0x0000000F
sub eax, ebx
sbb edx, 0
or eax, 0x800
inc ecx
wrmsr
; clear unused MTRRs
xor eax, eax
mov ecx, 0x204
mov ebx, 6
xor edx, edx
@@:
wrmsr ;disable unused MTRR
wrmsr
inc ecx
cmp ecx, 0x210
jb @b
; enable MTRRs
pop eax
or ah, 8
and al, 0xF0 ; default memtype = UC
mov ecx, 0x2FF
wrmsr
inc ecx
dec ebx
jnz @b
.skip_init:
stdcall set_mtrr, [LFBAddress],[LFBSize],MEM_WC
 
wbinvd ;again invalidate
 
pop eax
or eax, 0x800 ;set default memtype to UC
and al, 0xF0
mov ecx, 0x2FF
wrmsr ;and enable MTRR
 
mov eax, cr0
and eax, not 0x60000000
mov cr0, eax ; enable caching
1199,13 → 1341,29
endp
 
align 4
proc set_mtrr stdcall, reg:dword,base:dword,size:dword,mem_type:dword
 
proc set_mtrr stdcall, base:dword,size:dword,mem_type:dword
; find unused register
mov ecx, 0x201
@@:
rdmsr
dec ecx
test ah, 8
jz .found
rdmsr
mov al, 0 ; clear memory type field
cmp eax, [base]
jz .ret
add ecx, 3
cmp ecx, 0x210
jb @b
; no free registers, ignore the call
.ret:
ret
.found:
; found, write values
xor edx, edx
mov eax, [base]
or eax, [mem_type]
mov ecx, [reg]
lea ecx, [0x200+ecx*2]
wrmsr
 
mov ebx, [size]
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/peload.inc
280,6 → 280,8
__exports:
export 'KERNEL', \
alloc_kernel_space, 'AllocKernelSpace', \ ; stdcall
alloc_page, 'AllocPage', \ ; gcc ABI
alloc_pages, 'AllocPages', \ ; stdcall
commit_pages, 'CommitPages', \ ; eax, ebx, ecx
create_kernel_object, 'CreateObject', \
create_ring_buffer, 'CreateRingBuffer', \ ; stdcall
287,17 → 289,12
free_kernel_space, 'FreeKernelSpace', \ ; stdcall
kernel_alloc, 'KernelAlloc', \ ; stdcall
kernel_free, 'KernelFree', \ ; stdcall
alloc_pages, 'AllocPages', \ ; stdcall
malloc, 'Kmalloc', \
free, 'Kfree', \
map_io_mem, 'MapIoMem', \ ; stdcall
get_pg_addr, 'GetPgAddr', \ ; eax
\
select_hw_cursor, 'SelectHwCursor', \ ; stdcall
set_hw_cursor, 'SetHwCursor', \ ; stdcall
hw_restore, 'HwCursorRestore', \ ;
create_cursor, 'HwCursorCreate', \ ;
\
get_display, 'GetDisplay', \
set_screen, 'SetScreen', \
pci_api, 'PciApi', \
pci_read8, 'PciRead8', \ ; stdcall
307,6 → 304,7
pci_write16, 'PciWrite16', \ ; stdcall
pci_write32, 'PciWrite32', \ ; stdcall
\
get_service, 'GetService', \ ;
reg_service, 'RegService', \ ; stdcall
attach_int_handler, 'AttachIntHandler', \ ; stdcall
user_alloc, 'UserAlloc', \ ; stdcall
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/sched.inc
174,8 → 174,23
cmp eax, [esi+ecx] ;offset>0x7F
je @f
mov cr3, eax
@@: ; set tss.esp0
@@:
; set tss.esp0
 
Mov [tss._esp0],eax,[ebx+APPDATA.saved_esp0]
 
mov edx, [ebx+APPDATA.tls_base]
cmp edx, [esi+APPDATA.tls_base]
je @f
 
mov [tls_data_l+2],dx
shr edx,16
mov [tls_data_l+4],dl
mov [tls_data_l+7],dh
 
mov dx, app_tls
mov fs, dx
@@:
; set gs selector unconditionally
Mov gs,ax,graph_data
; set CR0.TS
211,6 → 226,7
.arg dd ?
}
 
 
MAX_PROIRITY 0 ; highest, used for kernel tasks
MAX_USER_PRIORITY 0 ; highest priority for user processes
USER_PRIORITY 7 ; default (should correspond to nice 0)
218,7 → 234,9
IDLE_PRIORITY 15 ; lowest, only IDLE process goes here
NR_SCHED_QUEUES 16 ; MUST equal IDLE_PRIORYTY + 1
 
uglobal
rdy_head rd 16
endg
 
align 4
pick_task:
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/string.inc
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/sync.inc
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/sys32.inc
279,14 → 279,19
iret
 
ready_for_next_irq:
mov [check_idle_semaphore],5
mov al, 0x20
mov eax,5
mov [check_idle_semaphore],eax
; mov al, 0x20
add eax,(0x20-0x5)
 
out 0x20, al
ret
 
;destroy eax
ready_for_next_irq_1:
mov [check_idle_semaphore],5
mov al, 0x20
mov eax,5
mov [check_idle_semaphore],eax
; mov al, 0x20
add eax,(0x20-0x5)
out 0xa0,al
out 0x20, al
ret
293,7 → 298,7
 
irqD:
push eax
mov al,0
xor eax,eax
out 0xf0,al
mov al,0x20
out 0xa0,al
396,7 → 401,8
 
cmp eax,[application_table_status]
jne apptsl1
mov [application_table_status],0
xor eax,eax
mov [application_table_status],eax
apptsl1:
 
pop eax
403,30 → 409,25
 
ret
 
; * eax = 64 - íîìåð ôóíêöèè
; * ebx = 1 - åäèíñòâåííàÿ ïîäôóíêöèÿ
; * ecx = íîâûé ðàçìåð ïàìÿòè
;Âîçâðàùàåìîå çíà÷åíèå:
; * eax = 0 - óñïåøíî
; * eax = 1 - íåäîñòàòî÷íî ïàìÿòè
 
sys_resize_app_memory:
; eax = 1 - resize
; ebx = new amount of memory
; ebx = 1 - resize
; ecx = new amount of memory
 
cmp eax,1
jne .no_application_mem_resize
 
stdcall new_mem_resize, ebx
mov [esp+36], eax
ret
 
; cmp eax,1
dec ebx
jnz .no_application_mem_resize
stdcall new_mem_resize, ecx
mov [esp+32], eax
.no_application_mem_resize:
ret
 
sys_threads:
 
; eax=1 create thread
;
; ebx=thread start
; ecx=thread stack value
;
; on return : eax = pid
jmp new_sys_threads
 
iglobal
; process_terminating db 'K : Process - terminating',13,10,0
; process_terminated db 'K : Process - done',13,10,0
497,10 → 498,10
pop esi
jmp @B
@@:
 
mov eax, [.slot]
shl eax, 8
mov eax,[SLOT_BASE+eax+APPDATA.dir_table]
stdcall destroy_app_space, eax
stdcall destroy_app_space, [SLOT_BASE+eax+APPDATA.dir_table], [SLOT_BASE+eax+APPDATA.dlls_list_ptr]
 
mov esi, [.slot]
cmp [fpu_owner],esi ; if user fpu last -> fpu user = 1
586,13 → 587,13
shl esi,5
add esi,window_data
mov eax,[esi+WDATA.box.left]
mov [dlx],eax
mov [draw_limits.left],eax
add eax,[esi+WDATA.box.width]
mov [dlxe],eax
mov [draw_limits.right],eax
mov eax,[esi+WDATA.box.top]
mov [dly],eax
mov [draw_limits.top],eax
add eax,[esi+WDATA.box.height]
mov [dlye],eax
mov [draw_limits.bottom],eax
 
xor eax, eax
mov [esi+WDATA.box.left],eax
641,12 → 642,12
add edi,SLOT_BASE
 
mov eax, [edi+APPDATA.io_map]
cmp eax, (tss._io_map_0-OS_BASE+PG_MAP)
cmp eax, [SLOT_BASE+256+APPDATA.io_map]
je @F
call free_page
@@:
mov eax, [edi+APPDATA.io_map+4]
cmp eax, (tss._io_map_1-OS_BASE+PG_MAP)
cmp eax, [SLOT_BASE+256+APPDATA.io_map+4]
je @F
call free_page
@@:
689,22 → 690,22
cmp [hd1_status], esi
jnz @f
call free_hd_channel
mov [hd1_status], 0
and [hd1_status], 0
@@:
cmp [cd_status], esi
jnz @f
call free_cd_channel
mov [cd_status], 0
and [cd_status], 0
@@:
cmp [flp_status], esi
jnz @f
mov [flp_status], 0
and [flp_status], 0
@@:
pop esi
cmp [bgrlockpid], esi
jnz @f
and [bgrlockpid], 0
mov [bgrlock], 0
and [bgrlock], 0
@@:
 
pusha ; remove all irq reservations
736,8 → 737,8
 
mov esi,[RESERVED_PORTS]
 
cmp esi,0
je rmpr9
test esi,esi
jz rmpr9
 
rmpr3:
 
796,10 → 797,10
; call systest
sti ; .. and life goes on
 
mov eax, [dlx]
mov ebx, [dly]
mov ecx, [dlxe]
mov edx, [dlye]
mov eax, [draw_limits.left]
mov ebx, [draw_limits.top]
mov ecx, [draw_limits.right]
mov edx, [draw_limits.bottom]
call calculatescreen
xor eax, eax
xor esi, esi
808,7 → 809,7
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse
 
mov [application_table_status],0
and [application_table_status],0
;mov esi,process_terminated
;call sys_msg_board_str
add esp, 4
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/syscall.inc
20,7 → 20,6
call dword [servetable+edi*4]
ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; SYSENTER ENTRY ;;
123,17 → 122,9
dd 0
dd 0
dd 0
dd sys_midi ; 20-ResetMidi and OutputMidi
dd sys_setup ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
dd sys_settime ; 22-setting date,time,clock and alarm-clock
dd 0
dd syscall_cdaudio ; 24-PlayCdTrack,StopCd and GetCdPlaylist
dd 0 ;
dd sys_getsetup ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
dd 0
dd 0 ;
dd 0
dd sys_current_directory ; 30-Get/SetCurrentDirectory
dd 0
dd 0
dd 0
140,27 → 131,35
dd 0
dd 0
dd 0
dd readmousepos ; 37-GetMousePosition_ScreenRelative,.
dd 0 ; 38-DrawLine
dd sys_getbackground ; 39-GetBackgroundSize,ReadBgrData,.
dd 0
dd 0
dd 0
dd sys_outport ; 43-SendDeviceData
dd 0
dd 0
dd syscall_reserveportarea ; 46-ReservePortArea and FreePortArea
dd display_number ; 47-WriteNum
dd display_settings ; 48-SetRedrawType and SetButtonType
dd sys_apm ; 49-Advanced Power Management (APM)
dd random_shaped_window ; 50-Window shape & scale
dd syscall_threads ; 51-Threads
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd 0
dd sound_interface ; 55-Sound interface
dd 0
dd sys_pcibios ; 57-PCI BIOS32
dd 0
dd file_system ; 58-Common file system interface
dd 0
dd sys_IPC ; 60-Inter Process Communication
167,16 → 166,14
dd sys_gs ; 61-Direct graphics access
dd sys_pci ; 62-PCI functions
dd sys_msg_board ; 63-System message board
dd sys_resize_app_memory ; 64-Resize application memory usage
dd 0
dd syscall_putimage_palette; 65-PutImagePalette
dd sys_process_def ; 66-Process definitions - keyboard
dd sys_window_move ; 67-Window move or resize
dd f68 ; 68-Some internal services
dd sys_debug_services ; 69-Debug
dd 0
dd 0
dd file_system_lfn ; 70-Common file system interface, version 2
dd syscall_windowsettings ; 71-Window settings
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; NEW SYSTEM FUNCTIONS TABLE ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
191,7 → 188,7
dd delay_hs ; 5-DelayHs
dd syscall_openramdiskfile ; 6-OpenRamdiskFile
dd syscall_putimage ; 7-PutImage
dd sys_button ; 8-DefineButton
dd syscall_button ; 8-DefineButton
dd sys_cpuusage ; 9-GetProcessInfo
dd sys_waitforevent ; 10-WaitForEvent
dd sys_getevent ; 11-CheckForEvent
203,17 → 200,17
dd sys_getbutton ; 17-GetButton
dd sys_system ; 18-System Services
dd paleholder ; 19-reserved
dd cross_order ; 20-ResetMidi and OutputMidi
dd cross_order ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
dd cross_order ; 22-setting date,time,clock and alarm-clock
dd sys_midi ; 20-ResetMidi and OutputMidi
dd sys_setup ; 21-SetMidiBase,SetKeymap,SetShiftKeymap,.
dd sys_settime ; 22-setting date,time,clock and alarm-clock
dd sys_wait_event_timeout ; 23-TimeOutWaitForEvent
dd cross_order ; 24-PlayCdTrack,StopCd and GetCdPlaylist
dd syscall_cdaudio ; 24-PlayCdTrack,StopCd and GetCdPlaylist
dd undefined_syscall ; 25-reserved
dd cross_order ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
dd sys_getsetup ; 26-GetMidiBase,GetKeymap,GetShiftKeymap,.
dd undefined_syscall ; 27-reserved
dd undefined_syscall ; 28-reserved
dd sys_date ; 29-GetDate
dd cross_order ; 30-Get/SetCurrentDirectory
dd sys_current_directory ; 30-Get/SetCurrentDirectory
dd undefined_syscall ; 31-reserved
dd undefined_syscall ; 32-reserved
dd undefined_syscall ; 33-reserved
220,27 → 217,27
dd undefined_syscall ; 34-reserved
dd syscall_getpixel ; 35-GetPixel
dd syscall_getarea ; 36-GetArea
dd cross_order ; 37-GetMousePosition_ScreenRelative,.
dd readmousepos ; 37-GetMousePosition_ScreenRelative,.
dd syscall_drawline ; 38-DrawLine
dd cross_order ; 39-GetBackgroundSize,ReadBgrData,.
dd sys_getbackground ; 39-GetBackgroundSize,ReadBgrData,.
dd set_app_param ; 40-WantEvents
dd syscall_getirqowner ; 41-GetIrqOwner
dd get_irq_data ; 42-ReadIrqData
dd cross_order ; 43-SendDeviceData
dd sys_outport ; 43-SendDeviceData
dd sys_programirq ; 44-ProgramIrqs
dd reserve_free_irq ; 45-ReserveIrq and FreeIrq
dd cross_order ; 46-ReservePortArea and FreePortArea
dd cross_order ; 47-WriteNum
dd cross_order ; 48-SetRedrawType and SetButtonType
dd cross_order ; 49-Advanced Power Management (APM)
dd cross_order ; 50-Window shape & scale
dd cross_order ; 51-Threads
dd cross_order ; 52-Stack driver status
dd cross_order ; 53-Socket interface
dd syscall_reserveportarea ; 46-ReservePortArea and FreePortArea
dd display_number ; 47-WriteNum
dd syscall_display_settings ; 48-SetRedrawType and SetButtonType
dd sys_apm ; 49-Advanced Power Management (APM)
dd syscall_set_window_shape ; 50-Window shape & scale
dd syscall_threads ; 51-Threads
dd undefined_syscall ; 52-Stack driver status
dd undefined_syscall ; 53-Socket interface
dd undefined_syscall ; 54-reserved
dd cross_order ; 55-Sound interface
dd undefined_syscall ; 56-reserved
dd cross_order ; 57-PCI BIOS32
dd sys_pcibios ; 57-PCI BIOS32
dd cross_order ; 58-Common file system interface
dd undefined_syscall ; 59-reserved
dd cross_order ; 60-Inter Process Communication
247,14 → 244,14
dd cross_order ; 61-Direct graphics access
dd cross_order ; 62-PCI functions
dd cross_order ; 63-System message board
dd cross_order ; 64-Resize application memory usage
dd sys_resize_app_memory ; 64-Resize application memory usage
dd cross_order ; 65-PutImagePalette
dd cross_order ; 66-Process definitions - keyboard
dd cross_order ; 67-Window move or resize
dd cross_order ; 68-Some internal services
dd cross_order ; 69-Debug
dd f68 ; 68-Some internal services
dd sys_debug_services ; 69-Debug
dd cross_order ; 70-Common file system interface, version 2
dd cross_order ; 71-Window settings
dd syscall_windowsettings ; 71-Window settings
dd sys_sendwindowmsg ; 72-Send window message
dd sys_network ; 73-Network stack
dd sys_socket ; 74-Sockets
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/taskman.inc
113,6 → 113,7
popad
mov eax, -ERROR_FILE_NOT_FOUND
ret
 
.namecopied:
 
mov [cmdline], ebx
150,8 → 151,8
.get_lock:
mov eax, 1
xchg eax, [application_table_status]
cmp eax, 0
jne .wait_lock
test eax, eax
jnz .wait_lock
 
call set_application_table_status
 
201,6 → 202,14
mov eax,[hdr_mem]
mov [ebx+APPDATA.mem_size],eax
 
xor edx, edx
cmp word [6], '02'
jne @f
 
not edx
@@:
mov [ebx+APPDATA.tls_base],edx
 
if GREEDY_KERNEL
else
mov ecx, [hdr_mem]
278,8 → 287,10
.check_01_header:
 
cmp [eax+6],word '01'
je @f
cmp [eax+6], word '02'
jne .fail
 
@@:
mov ecx,[APP_HEADER_01.start]
mov [ebx+0x08], ecx ;app_eip
mov edx,[APP_HEADER_01.mem_size]
475,7 → 486,7
dec [pg_data.pg_mutex]
cmp [dir_addr], 0
je @f
stdcall destroy_app_space, [dir_addr]
stdcall destroy_app_space, [dir_addr], 0
@@:
xor eax, eax
ret
512,12 → 523,10
endp
 
align 4
proc destroy_app_space stdcall, pg_dir:dword
proc destroy_app_space stdcall, pg_dir:dword, dlls_list:dword
 
mov ebx, pg_data.pg_mutex
call wait_mutex ;ebx
 
xor edx,edx
push edx
mov eax,0x2
mov ebx, [pg_dir]
.loop:
527,8 → 536,10
cmp byte [CURRENT_TASK+ecx+0xa],9 ;if process running?
jz @f ;skip empty slots
shl ecx,3
cmp [SLOT_BASE+ecx+0xB8],ebx ;compare page directory addresses
add ecx,SLOT_BASE
cmp [ecx+APPDATA.dir_table],ebx ;compare page directory addresses
jnz @f
mov [ebp-4],ecx
inc edx ;thread found
@@:
inc eax
537,13 → 548,19
 
;edx = number of threads
;our process is zombi so it isn't counted
pop ecx
cmp edx,1
jg .exit
jg .ret
;if there isn't threads then clear memory.
mov esi, [dlls_list]
call destroy_all_hdlls
 
mov ebx, pg_data.pg_mutex
call wait_mutex ;ebx
 
mov eax, [pg_dir]
and eax, not 0xFFF
stdcall map_page,[tmp_task_pdir],eax,dword PG_SW
stdcall map_page,[tmp_task_pdir],eax,PG_SW
mov esi, [tmp_task_pdir]
mov edi, (OS_BASE shr 20)/4
.destroy:
551,7 → 568,7
test eax, 1
jz .next
and eax, not 0xFFF
stdcall map_page,[tmp_task_ptab],eax,dword PG_SW
stdcall map_page,[tmp_task_ptab],eax,PG_SW
stdcall destroy_page_table, [tmp_task_ptab]
mov eax, [esi]
call free_page
563,9 → 580,10
mov eax, [pg_dir]
call free_page
.exit:
stdcall map_page,[tmp_task_ptab],dword 0,dword PG_UNMAP
stdcall map_page,[tmp_task_pdir],dword 0,dword PG_UNMAP
stdcall map_page,[tmp_task_ptab],0,PG_UNMAP
stdcall map_page,[tmp_task_pdir],0,PG_UNMAP
dec [pg_data.pg_mutex]
.ret:
ret
endp
 
613,24 → 631,24
 
check_region:
;input:
; ebx - start of buffer
; ecx - size of buffer
; esi - start of buffer
; edx - size of buffer
;result:
; eax = 1 region lays in app memory
; eax = 0 region don't lays in app memory
mov eax,[CURRENT_TASK]
jmp check_process_region
; jmp check_process_region
;-----------------------------------------------------------------------------
check_process_region:
;check_process_region:
;input:
; eax - slot
; ebx - start of buffer
; ecx - size of buffer
; esi - start of buffer
; edx - size of buffer
;result:
; eax = 1 region lays in app memory
; eax = 0 region don't lays in app memory
 
test ecx,ecx
test edx,edx
jle .ok
shl eax,5
cmp word [CURRENT_TASK+eax+0xa],0
698,9 → 716,9
proc read_process_memory
;Input:
; eax - process slot
; ebx - buffer address
; ecx - buffer size
; edx - start address in other process
; ecx - buffer address
; edx - buffer size
; esi - start address in other process
;Output:
; eax - number of bytes read.
locals
712,10 → 730,10
endl
 
mov [slot], eax
mov [buff], ebx
mov [buff], ecx
and [r_count], 0
mov [tmp_r_cnt], ecx
mov [offset], edx
mov [tmp_r_cnt], edx
mov [offset], esi
 
pushad
.read_mem:
733,18 → 751,22
jna @F
mov ecx, 0x8000
@@:
mov eax, [slot]
shl eax,8
mov ebx, [offset]
; add ebx, new_app_base
 
push ecx
stdcall map_memEx, [proc_mem_map],\
[SLOT_BASE+eax+0xB8],\
ebx, ecx
[slot], ebx, ecx, PG_MAP
pop ecx
 
mov esi, [offset]
and esi, 0xfff
sub eax, esi
jbe .ret
cmp ecx, eax
jbe @f
mov ecx, eax
mov [tmp_r_cnt], eax
@@:
add esi, [proc_mem_map]
mov edi, [buff]
mov edx, ecx
754,7 → 776,7
add [offset], edx
sub [tmp_r_cnt], edx
jnz .read_mem
 
.ret:
popad
mov eax, [r_count]
ret
764,9 → 786,9
proc write_process_memory
;Input:
; eax - process slot
; ebx - buffer address
; ecx - buffer size
; edx - start address in other process
; ecx - buffer address
; edx - buffer size
; esi - start address in other process
;Output:
; eax - number of bytes written
 
779,10 → 801,10
endl
 
mov [slot], eax
mov [buff], ebx
mov [buff], ecx
and [w_count], 0
mov [tmp_w_cnt], ecx
mov [offset], edx
mov [tmp_w_cnt], edx
mov [offset], esi
 
pushad
.read_mem:
800,18 → 822,22
jna @F
mov ecx, 0x8000
@@:
mov eax, [slot]
shl eax,8
mov ebx, [offset]
; add ebx, new_app_base
push ecx
stdcall map_memEx, [proc_mem_map],\
[SLOT_BASE+eax+0xB8],\
ebx, ecx
[slot], ebx, ecx, PG_SW
pop ecx
 
mov edi, [offset]
and edi, 0xfff
sub eax, edi
jbe .ret
cmp ecx, eax
jbe @f
mov ecx, eax
mov [tmp_w_cnt], eax
@@:
add edi, [proc_mem_map]
mov esi, [buff]
mov edx, ecx
821,7 → 847,7
add [offset], edx
sub [tmp_w_cnt], edx
jnz .read_mem
 
.ret:
popad
mov eax, [w_count]
ret
838,15 → 864,14
app_mem dd ? ;0x10
endl
 
cmp eax,1
cmp ebx,1
jne .failed ;other subfunctions
 
xor eax,eax
mov [app_eip], ecx
mov [app_cmdline], eax
mov [app_esp], edx
mov [app_path], eax
mov [app_eip], ebx
mov [app_esp], ecx
 
;mov esi,new_process_loading
;call sys_msg_board_str
.wait_lock:
858,8 → 883,8
.get_lock:
mov eax, 1
xchg eax, [application_table_status]
cmp eax, 0
jne .wait_lock
test eax, eax
jnz .wait_lock
 
call set_application_table_status
 
897,6 → 922,21
mov ecx,[ebx+APPDATA.dir_table]
mov [edx+APPDATA.dir_table],ecx ;copy page directory
 
mov eax,[ebx+APPDATA.dlls_list_ptr]
mov [edx+APPDATA.dlls_list_ptr],eax
 
mov eax, [ebx+APPDATA.tls_base]
test eax, eax
jz @F
 
push edx
stdcall user_alloc, 4096
pop edx
test eax, eax
jz .failed1 ;eax=0
@@:
mov [edx+APPDATA.tls_base], eax
 
lea eax, [app_cmdline]
stdcall set_app_params ,[slot],eax,dword 0,\
dword 0,dword 0
903,13 → 943,15
 
;mov esi,new_process_running
;call sys_msg_board_str ;output information about succefull startup
 
mov [application_table_status],0 ;unlock application_table_status mutex
xor eax,eax
mov [application_table_status],eax ;unlock application_table_status mutex
mov eax,[process_number] ;set result
ret
.failed:
mov [application_table_status],0
mov eax,-1
xor eax,eax
.failed1:
mov [application_table_status],eax
dec eax ;-1
ret
endp
 
931,6 → 973,24
pop eax
ret
 
align 4
tls_app_entry:
 
call init_heap
stdcall user_alloc, 4096
 
mov edx, [current_slot]
mov [edx+APPDATA.tls_base], eax
mov [tls_data_l+2],ax
shr eax,16
mov [tls_data_l+4],al
mov [tls_data_l+7],ah
mov dx, app_tls
mov fs, dx
popad
iretd
 
 
EFL_IF equ 0x0200
EFL_IOPL1 equ 0x1000
EFL_IOPL2 equ 0x2000
959,10 → 1019,10
mov [eax+SLOT_BASE+APPDATA.except_mask], 0
 
;set default io permission map
mov [eax+SLOT_BASE+APPDATA.io_map],\
(tss._io_map_0-OS_BASE+PG_MAP)
mov [eax+SLOT_BASE+APPDATA.io_map+4],\
(tss._io_map_1-OS_BASE+PG_MAP)
mov ecx, [SLOT_BASE+256+APPDATA.io_map]
mov [eax+SLOT_BASE+APPDATA.io_map], ecx
mov ecx, [SLOT_BASE+256+APPDATA.io_map+4]
mov [eax+SLOT_BASE+APPDATA.io_map+4], ecx
 
mov esi, fpu_data
mov ecx, 512/4
1037,6 → 1097,11
shl ebx,5
lea ecx,[draw_data+ebx] ;ecx - pointer to draw data
 
mov edx, irq0.return
cmp [ebx*8+SLOT_BASE+APPDATA.tls_base], -1
jne @F
mov edx, tls_app_entry
@@:
; set window state to 'normal' (non-minimized/maximized/rolled-up) state
mov [ebx+window_data+WDATA.fl_wstate], WSTATE_NORMAL
mov [ebx+window_data+WDATA.fl_redraw], 1
1050,9 → 1115,9
mov [ebx+4],eax ;set PID
 
;set draw data to full screen
 
mov [ecx+0],dword 0
mov [ecx+4],dword 0
xor eax,eax
mov [ecx+0],dword eax
mov [ecx+4],dword eax
mov eax,[Screen_Max_X]
mov [ecx+8],eax
mov eax,[Screen_Max_Y]
1063,7 → 1128,7
lea ecx, [ebx+REG_EIP]
xor eax, eax
 
mov [ebx+REG_RET], dword irq0.return
mov [ebx+REG_RET], edx
mov [ebx+REG_EDI], eax
mov [ebx+REG_ESI], eax
mov [ebx+REG_EBP], eax
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/test_malloc.asm
0,0 → 1,223
; Tests of malloc()/free() from the kernel heap.
; This file is not included in the kernel, it is just test application.
use32
db 'MENUET01'
dd 1, start, i_end, mem, mem, 0, 0
 
start:
; Zero-initialize uglobals (as in kernel at boot)
mov ecx, (zeroend - zerostart + 3) / 4
xor eax, eax
mov edi, zerostart
rep stosd
; Initialize small heap (as in kernel at boot)
call init_malloc
; Run tests
call run_test1
call run_test2
call run_test3
; All is OK, return
or eax, -1
int 0x40
 
run_test1:
; basic test
mov eax, 1
call malloc_with_test
mov byte [eax], 0xDD
mov esi, eax
mov eax, 1
call malloc_with_test
cmp byte [esi], 0xDD
jnz memory_destroyed
mov byte [eax], 0xEE
xchg eax, esi
call free
cmp byte [esi], 0xEE
jnz memory_destroyed
xchg eax, esi
call free
ret
 
run_test2:
ret
 
run_test3:
; 1024000 times run random operation.
; Randomly select malloc(random size from 1 to 1023)
; or free(random of previously allocated areas)
mov edi, 0x12345678
xor esi, esi ; 0 areas allocated
mov ebx, 1024000
.loop:
imul edi, 1103515245
add edi, 12345
mov eax, edi
shr eax, 16
test ebx, 64
jz .prefer_free
.prefer_malloc:
test eax, 3
jz .free
jmp @f
.prefer_free:
test eax, 3
jnz .free
@@:
shr eax, 2
and eax, 1023
jz .loop
push ebx
push eax
; mov ecx, [saved_state_num]
; mov [saved_state+ecx*8], eax
call malloc_with_test
; mov ecx, [saved_state_num]
; mov [saved_state+ecx*8+4], eax
; inc [saved_state_num]
pop ecx
pop ebx
inc esi
push ecx eax
push edi
mov edi, eax
mov eax, esi
rep stosb
pop edi
jmp .common
.free:
test esi, esi
jz .loop
xor edx, edx
div esi
sub edx, esi
neg edx
dec edx
mov eax, [esp+edx*8]
; mov ecx, [saved_state_num]
; mov [saved_state+ecx*8], -1
; mov [saved_state+ecx*8+4], eax
; inc [saved_state_num]
mov ecx, [esp+edx*8+4]
push edi eax
mov edi, eax
mov al, [edi]
repz scasb
jnz memory_destroyed
pop eax edi
push ebx edx
call free
pop edx ebx
dec esi
pop eax ecx
push edi
lea edi, [esp+4]
@@:
dec edx
js @f
xchg eax, [edi]
xchg ecx, [edi+4]
add edi, 8
jmp @b
@@:
pop edi
.common:
dec ebx
jnz .loop
@@:
dec esi
js @f
pop eax ecx
call free
jmp @b
@@:
ret
 
malloc_with_test:
; calls malloc() and checks returned value
call malloc
test eax, eax
jz generic_malloc_fail
call check_mutex
call check_range
ret
 
; Stubs for kernel procedures used by heap code
wait_mutex:
inc dword [ebx]
ret
 
kernel_alloc:
cmp dword [esp+4], bufsize
jnz error1
mov eax, buffer
ret 4
 
macro $Revision [args]
{
}
 
; Error handlers
error1:
mov eax, 1
jmp error_with_code
 
generic_malloc_fail:
mov eax, 2
jmp error_with_code
 
check_mutex:
cmp [mst.mutex], 0
jnz @f
ret
@@:
mov eax, 3
jmp error_with_code
 
check_range:
cmp eax, buffer
jb @f
cmp eax, buffer+bufsize
jae @f
ret
@@:
mov eax, 4
jmp error_with_code
 
memory_destroyed:
mov eax, 5
jmp error_with_code
 
error_with_code:
mov edx, saved_state_num
; eax = error code
; 1 signals error in testing code (wrong bufsize)
; 2 = malloc() returned NULL
; 3 = mutex not released
; 4 = weird returned value from malloc()
; 5 = memory destroyed by malloc() or free()
int3 ; simplest way to report error
jmp $-1 ; just in case
 
; Include main heap code
include '../proc32.inc'
include '../const.inc'
include 'malloc.inc'
 
i_end:
 
align 4
zerostart:
mst MEM_STATE
 
align 16
bufsize = 0x40000 ; change if malloc.inc changes
buffer rb bufsize
zeroend:
 
saved_state_num dd ?
saved_state rd 0x10000
 
align 4
rb 0x10000 ; for stack
mem:
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/core/v86.inc
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/data32.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
47,7 → 47,6
db 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
 
 
boot_memdetect db 'Determining amount of memory',0
boot_fonts db 'Fonts loaded',0
boot_tss db 'Setting TSSs',0
119,34 → 118,21
.bk dd shmem_list
.fd dd shmem_list
 
dll_list:
.bk dd dll_list
.fd dd dll_list
 
MAX_DEFAULT_DLL_ADDR = 0x20000000
MIN_DEFAULT_DLL_ADDR = 0x10000000
dll_cur_addr dd MIN_DEFAULT_DLL_ADDR
 
; supported videomodes
 
mode_1280_1024_32:
dw 1280,1024,32,60
mode_1280_1024_24:
dw 1280,1024,24,60
mode_1024_768_32:
dw 1024,768,32,60
mode_1024_768_24:
dw 1024,768,24,60
mode_800_600_32:
dw 800,600,32,60
mode_800_600_24:
dw 800,600,24,60
mode_640_480_32:
dw 640,480,32,60
mode_640_480_24:
dw 640,480,24,60
mode_640_480_16:
dw 640,480,16,60
mode_320_240_8:
dw 320,240,8,60
 
; mike.dld {
db 0
dd servetable-0x10000
draw_line dd __sys_draw_line
disable_mouse dd __sys_disable_mouse
draw_pointer dd __sys_draw_pointer
;//mike.dld, 2006-08-02 [
;drawbar dd __sys_drawbar
202,7 → 188,7
dw 0
db 0
db cpl3
dw G32+D32+(new_app_base shr 16)+0xF;
dw G32+D32+0xF;
 
app_data_l:
dw 0xFFFF
209,7 → 195,7
dw 0
db 0
db drw3
dw G32+D32+(new_app_base shr 16)+0xF;
dw G32+D32+0xF;
 
; ------------- PCI BIOS ------------------
 
260,6 → 246,14
db (tss shr 16) and 0xFF
db 10001001b
dw (tss shr 16) and 0xFF00
 
tls_data_l:
dw 0x0FFF
dw 0
db 0
db drw3
dw D32
 
endofcode:
gdte:
 
321,23 → 315,27
srv.fd rd 1
srv.bk rd 1
 
scr_width rd 1
scr_height rd 1
 
create_cursor rd 1
select_hw_cursor rd 1
set_hw_cursor rd 1
hw_restore rd 1
align 16
 
_display display_t
 
_WinMapAddress rd 1
_WinMapSize rd 1
 
def_cursor rd 1
current_cursor rd 1
hw_cursor rd 1
cur_def_interl rd 1
cur_saved_base rd 1
cur_saved_interl rd 1
cur_saved_w rd 1
cur_saved_h rd 1
 
cur.lock rd 1 ;1 - lock update, 2- hide
cur.left rd 1 ;cursor clip box
cur.top rd 1
cur.right rd 1
cur.bottom rd 1
cur.w rd 1
cur.h rd 1
 
ipc_tmp rd 1
ipc_pdir rd 1
ipc_ptab rd 1
/kernel/branches/net/detect/biosdisk.inc
55,7 → 55,8
inc ax
cmp word [si], 170h
jz @f
mov ax, -1
or ax,-1
; mov ax, -1
@@:
stosw
pop ds
63,10 → 64,14
bddl:
mov al, dl
stosb
mov al, 0
xor ax,ax
stosb
mov ax, -1
dec ax
stosw
; mov al, 0
; stosb
; mov ax, -1
; stosw
bddc2:
cmp cl, [es:0x475]
jae bdde
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/biosmem.inc
Property changes:
Deleted: svn:keywords
-Revision
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/dev_fd.inc
24,7 → 24,7
mov cx,0xff
wait_cmos:
dec cx
cmp cx,0
jne wait_cmos
test cx,cx
jnz wait_cmos
in al,0x71
mov [DRIVE_DATA],al
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/dev_hdcd.inc
72,8 → 72,9
 
 
; Àäðåñ ñ÷èòûâàåìîãî ñåêòîðà â ðåæèìå LBA
uglobal
SectorAddress DD ?
 
endg
;*************************************************
;* ×ÒÅÍÈÅ ÈÄÅÍÒÈÔÈÊÀÒÎÐÀ ÆÅÑÒÊÎÃÎ ÄÈÑÊÀ *
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå *
99,8 → 100,8
@@WaitCompleet:
; Ïðîâåðèòü âðåìÿ âûïîëíåíèÿ êîìàíäû
dec ecx
cmp ecx,0
je @@Error1 ;îøèáêà òàéì-àóòà
; cmp ecx,0
jz @@Error1 ;îøèáêà òàéì-àóòà
; Ïðîâåðèòü ãîòîâíîñòü
in AL,DX
test AL,80h ;ñîñòîÿíèå ñèãíàëà BSY
116,19 → 117,21
mov DX,[ATABasePortAddr] ;ðåãèñòð äàííûõ
mov CX,256 ;÷èñëî ñ÷èòûâàåìûõ ñëîâ
rep insw ;ïðèíÿòü áëîê äàííûõ
jmp @@End
ret
; Çàïèñàòü êîä îøèáêè
@@Error1:
mov [DevErrorCode],1
jmp @@End
ret
@@Error6:
mov [DevErrorCode],6
@@End: ret
 
 
 
iglobal
; Ñòàíäàðòíûå áàçîâûå àäðåñà êàíàëîâ 1 è 2
StandardATABases DW 1F0h, 170h
endg
uglobal
; Íîìåð êàíàëà
ChannelNumber DW ?
; Íîìåð äèñêà
148,8 → 151,8
; 3 - íåâåðíûé íîìåð êàíàëà, 4 - íåâåðíûé íîìåð äèñêà,
; 5 - íåâåðíûé íîìåð ãîëîâêè, 6 - îøèáêà ïðè âûïîëíåíèè
; êîìàíäû)
DevErrorCode DB ?
 
DevErrorCode dd ?
endg
;****************************************************
;* ÏÎÑËÀÒÜ ÊÎÌÀÍÄÓ ÇÀÄÀÍÍÎÌÓ ÄÈÑÊÓ *
;* Âõîäíûå ïàðàìåòðû ïåðåäàþòñÿ ÷åðåç ãëîáàëüíûå *
203,8 → 206,8
@@WaitHDReady:
; Ïðîâåðèòü âðåìÿ îæèäàíè
dec ecx
cmp ecx,0
je @@Err1
; cmp ecx,0
jz @@Err1
; mov eax,[timer_ticks]
; sub eax,[TickCounter_1]
; cmp eax,300 ;îæèäàòü 300 òèêîâ
253,19 → 256,18
sti
; Ñáðîñèòü ïðèçíàê îøèáêè
mov [DevErrorCode],0
jmp @@End_2
ret
; Çàïèñàòü êîä îøèáêè
@@Err1: mov [DevErrorCode],1
jmp @@End_2
ret
@@Err2: mov [DevErrorCode],2
jmp @@End_2
ret
@@Err3: mov [DevErrorCode],3
jmp @@End_2
ret
@@Err4: mov [DevErrorCode],4
jmp @@End_2
ret
@@Err5: mov [DevErrorCode],5
; Çàâåðøåíèå ðàáîòû ïðîãðàììû
@@End_2:
ret
 
;*************************************************
297,8 → 299,8
@@WaitCompleet_1:
; Ïðîâåðèòü âðåì
dec ecx
cmp ecx,0
je @@Error1_1 ;îøèáêà òàéì-àóòà
; cmp ecx,0
jz @@Error1_1 ;îøèáêà òàéì-àóòà
; Ïðîâåðèòü ãîòîâíîñòü
in AL,DX
test AL,80h ;ñîñòîÿíèå ñèãíàëà BSY
314,11 → 316,11
mov DX,[ATABasePortAddr] ;ïîðò 1x0h
mov CX,256 ;÷èñëî ñ÷èòûâàåìûõ ñëîâ
rep insw
jmp @@End_1
ret
; Çàïèñàòü êîä îøèáêè
@@Error1_1:
mov [DevErrorCode],1
jmp @@End_1
ret
@@Error6_1:
mov [DevErrorCode],6
@@End_1:
360,7 → 362,7
@@WaitHDReady_1:
; Ïðîâåðèòü âðåìÿ îæèäàíè
dec ecx
cmp ecx,0
; cmp ecx,0
je @@Err1_2 ;îøèáêà òàéì-àóòà
; Ïðî÷èòàòü ðåãèñòð ñîñòîÿíè
in AL,DX
369,15 → 371,14
jnz @@WaitHDReady_1
; Ñáðîñèòü ïðèçíàê îøèáêè
mov [DevErrorCode],0
jmp @@End_3
ret
; Îáðàáîòêà îøèáîê
@@Err1_2: mov [DevErrorCode],1
jmp @@End_3
ret
@@Err3_2: mov [DevErrorCode],3
jmp @@End_3
ret
@@Err4_2: mov [DevErrorCode],4
; Çàïèñàòü êîä îøèáêè
@@End_3:
ret
 
EndFindHDD:
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/disks.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/getcache.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/detect/sear_par.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fdo.inc
6,6 → 6,7
 
$Revision$
 
_esp equ esp
 
;
; Formatted Debug Output (FDO)
61,9 → 62,11
jmp ..label
..str db _str,0
..label:
add esp,4*8+4
; add esp,4*8+4
esp equ esp+4*8+4
mov edx,..str
sub esp,4*8+4
esp equ _esp
; sub esp,4*8+4
else
mov edx,_str
end if
147,7 → 150,8
else if _dec eqtype 0
mov eax,_dec
else
add esp,4*8+4
; add esp,4*8+4
esp equ esp+4*8+4
if _num eq
mov eax,dword _dec
else if _num = 1
165,7 → 169,8
else
mov eax,dword _dec
end if
sub esp,4*8+4
esp equ _esp
; sub esp,4*8+4
end if
mov cl,_sign
call fdo_debug_outdec
215,9 → 220,11
else if _hex eqtype 0
mov eax,_hex
else
add esp,4*8+4
; add esp,4*8+4
esp equ esp+4*8+4
mov eax,dword _hex
sub esp,4*8+4
esp equ _esp
; sub esp,4*8+4
end if
if ~_num eq
mov edx,_num
286,9 → 293,8
.l3: ret
debug_endf
 
debug_func fdo_debug_outhex
__fdo_hexdigits db '0123456789ABCDEF'
debug_func fdo_debug_outhex
 
debug_beginf
mov cl,dl
neg cl
/kernel/branches/net/fs/fat12.inc
65,13 → 65,13
 
mov [save_flag],0
mov [path_pointer_flp],edi
cmp esi,0 ; return ramdisk root
jne fr_noroot_1
test esi,esi ; return ramdisk root
jnz fr_noroot_1
cmp ebx,224/16
jbe fr_do_1
mov eax,5
mov ebx,0
mov [flp_status],0
xor ebx,ebx
mov [flp_status],ebx
ret
 
fr_do_1:
88,14 → 88,17
shl ecx,9
cld
rep movsb
mov eax,0 ; ok read
mov ebx,0
mov [flp_status],0
xor eax,eax
xor ebx,ebx
; mov eax,0 ; ok read
; mov ebx,0
mov [flp_status],eax
ret
fdc_status_error_1:
mov [flp_status],0
xor eax,eax
mov [flp_status],eax
mov eax,10
mov ebx,-1
or ebx,-1
ret
 
fr_noroot_1:
102,12 → 105,12
sub esp,32
call expand_filename
frfloppy_1:
cmp ebx,0
jne frfl5_1
test ebx,ebx
jnz frfl5_1
mov ebx,1
frfl5_1:
cmp ecx,0
jne frfl6_1
test ecx,ecx
jnz frfl6_1
mov ecx,1
frfl6_1:
dec ebx
137,14 → 140,14
add ecx,21
add edi, ecx ;Advance to next entry
dec dl
cmp dl,0
jne l.21_1
test dl,dl
jnz l.21_1
dec dh
cmp dh,0
jne l.20_1
test dh,dh
jnz l.20_1
fdc_status_error_3:
mov eax,5 ; file not found ?
mov ebx,-1
or ebx,-1
add esp,32+28
mov [flp_status],0
ret
232,8 → 235,8
add esp,4
pop ebx ; ebx <- eax : size of file
add esp,36
mov eax,0
mov [flp_status],0
xor eax,eax
mov [flp_status],eax
ret
 
fdc_status_error_5:
499,8 → 502,8
div ebx
mov [FDD_Track],al
mov [FDD_Head],0
cmp edx,0
je no_head_2
test edx,edx
jz no_head_2
inc [FDD_Head]
no_head_2:
mov dl,[old_track]
2131,7 → 2134,7
popa
pop edi
xor eax, eax
cmp [FDC_Status], 0
cmp [FDC_Status], al
jz @f
mov al, 11
@@:
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/fat32.inc
169,6 → 169,7
call clear_hd_cache
@@:
pop eax
sti
.ret:
ret
 
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/fs.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/fs_lfn.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
372,7 → 372,7
mov edi, fs_additional_handlers
@@:
cmp dword [edi], 0
jz @f
jz .notfound
call dword [edi]
scasd
scasd
967,43 → 967,76
ret
 
sys_current_directory:
mov esi, [current_slot]
mov esi, [esi+APPDATA.cur_dir]
mov edx, esi
dec eax
; mov esi, [current_slot]
; mov esi, [esi+APPDATA.cur_dir]
; mov edx, esi
 
;get length string of appdata.cur_dir
mov eax, [current_slot]
mov edi, [eax+APPDATA.cur_dir]
 
dec ebx
jz .set
dec eax
dec ebx
jz .get
ret
.get:
; sysfunction 30.2: [for app] eax=30,ebx=2,ecx->buffer,edx=len
; for our code: ebx->buffer,ecx=len
@@:
lodsb
test al, al
jnz @b
sub esi, edx
inc esi
mov [esp+36], esi
cmp ecx, esi
max_cur_dir equ 0x1000
 
mov ebx,edi
 
push ecx
push edi
 
xor eax,eax
mov ecx,max_cur_dir
 
repne scasb ;find zerro at and string
jnz .error ; no zero in cur_dir: internal error, should not happen
 
sub edi,ebx ;lenght for copy
inc edi
mov [esp+32+8],edi ;return in eax
 
cmp edx, edi
jbe @f
mov ecx, esi
mov edx, edi
@@:
cmp ecx, 1
;source string
pop esi
;destination string
pop edi
cmp edx, 1
jbe .ret
mov esi, edx
mov edi, ebx
mov al, '/'
 
mov al,'/' ;start string with '/'
stosb
dec ecx
dec ecx
rep movsb
mov byte [edi], 0
.ret:
mov ecx,edx
rep movsb ;copy string
.ret: ret
 
.error: add esp,8
or dword [esp+32],-1 ;error not found zerro at string ->[eax+APPDATA.cur_dir]
ret
.set:
; sysfunction 30.1: [for app] eax=30,ebx=1,ecx->string
; for our code: ebx->string to set
; use generic resolver with APPDATA.cur_dir as destination
push max_cur_dir ;0x1000
push edi ;destination
mov ebx,ecx
call get_full_file_name
ret
 
; in: ebx = file name, [esp+4] = destination, [esp+8] = sizeof destination
; destroys all registers except ebp,esp
get_full_file_name:
push ebp
mov esi, [current_slot]
mov esi, [esi+APPDATA.cur_dir]
mov edx, esi
@@:
inc esi
cmp byte [esi-1], 0
1012,6 → 1045,7
cmp byte [ebx], '/'
jz .set_absolute
; string gives relative path
mov edi, [esp+8] ; destination
.relative:
cmp byte [ebx], 0
jz .set_ok
1032,33 → 1066,67
dec esi
cmp byte [esi], '/'
jnz @b
mov byte [esi], 0
add ebx, 3
jmp .relative
.set_ok:
cmp edx, edi ; is destination equal to APPDATA.cur_dir?
jz .set_ok.cur_dir
sub esi, edx
cmp esi, [esp+12]
jb .set_ok.copy
.fail:
mov byte [edi], 0
xor eax, eax ; fail
pop ebp
ret 8
.set_ok.copy:
mov ecx, esi
mov esi, edx
rep movsb
mov byte [edi], 0
.ret.ok:
mov al, 1 ; ok
pop ebp
ret 8
.set_ok.cur_dir:
mov byte [esi], 0
jmp .ret.ok
.doset_relative:
add edx, 0x1000
mov byte [esi], '/'
inc esi
cmp esi, edx
jae .overflow_esi
cmp edx, edi
jz .doset_relative.cur_dir
sub esi, edx
cmp esi, [esp+12]
jae .fail
mov ecx, esi
mov esi, edx
mov edx, edi
rep movsb
jmp .doset_relative.copy
.doset_relative.cur_dir:
mov edi, esi
.doset_relative.copy:
add edx, [esp+12]
mov byte [edi], '/'
inc edi
cmp edi, edx
jae .overflow
@@:
mov al, [ebx]
inc ebx
mov [esi], al
inc esi
stosb
test al, al
jz .set_ok
cmp esi, edx
jz .ret.ok
cmp edi, edx
jb @b
.overflow_esi:
mov byte [esi-1], 0 ; force null-terminated string
.set_ok:
ret
.overflow:
dec edi
jmp .fail
.set_absolute:
lea esi, [ebx+1]
call process_replace_file_name
mov edi, edx
add edx, 0x1000
mov edi, [esp+8]
mov edx, [esp+12]
add edx, edi
.set_copy:
lodsb
stosb
1067,13 → 1135,11
.set_copy_cont:
cmp edi, edx
jb .set_copy
.overflow_edi:
mov byte [edi-1], 0
ret
jmp .overflow
.set_part2:
mov esi, ebp
xor ebp, ebp
test esi, esi
jz .set_ok
jz .ret.ok
mov byte [edi-1], '/'
jmp .set_copy_cont
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/iso9660.inc
5,7 → 5,7
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision$
$Revision:1322 $
 
 
uglobal
625,8 → 625,8
mov ebp,[cd_current_pointer_of_input_2]
mov [cd_current_pointer_of_input],ebp
mov eax,[ebp]
cmp eax,0 ; âõîäû çàêîí÷èëèñü?
je .next_sector
test eax,eax ; âõîäû çàêîí÷èëèñü?
jz .next_sector
cmp ebp,CDDataBuf+2048 ; áóôåð çàêîí÷èëñÿ?
jae .next_sector
movzx eax, byte [ebp]
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/ntfs.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/parse_fn.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/fs/part_set.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/button.inc
3,89 → 3,172
;; Copyright (C) KolibriOS team 2004-2008. All rights reserved. ;;
;; Copyright (C) MenuetOS 2000-2004 Ville Mikael Turjanmaa ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision$
 
 
max_buttons=4095
dececx:
push edx
push ecx
button._.MAX_BUTTONS = 4095
 
mov edx,2
.loop:
 
cmp byte [esp+edx],0x20
jae @f
mov [esp+edx],byte 0x20
@@:
sub [esp+edx],byte 0x20
;==============================================================================
;///// public functions ///////////////////////////////////////////////////////
;==============================================================================
 
dec edx
jns .loop
struc SYS_BUTTON
{
.pslot dw ?
.id_lo dw ?
.left dw ?
.width dw ?
.top dw ?
.height dw ?
.id_hi dw ?
.sizeof:
}
virtual at 0
SYS_BUTTON SYS_BUTTON
end virtual
 
pop ecx
pop edx
ret
iglobal
mx dw 0x0 ; keeps the x mouse's position when it was clicked
my dw 0x0 ; keeps the y mouse's position when it was clicked
bPressedMouseXY_B db 0x0
btn_down_determ db 0x0
endg
 
incecx:
push edx
push ecx
align 4
;------------------------------------------------------------------------------
syscall_button: ;///// system function 8 //////////////////////////////////////
;------------------------------------------------------------------------------
;? Define/undefine GUI button object
;------------------------------------------------------------------------------
;; Define button:
;> ebx = pack[16(x), 16(width)]
;> ecx = pack[16(y), 16(height)]
;> edx = pack[8(flags), 24(button identifier)]
;> flags bits:
;> 7 (31) = 0
;> 6 (30) = don't draw button
;> 5 (29) = don't draw button frame when pressed
;> esi = button color
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Undefine button:
;> edx = pack[8(flags), 24(button identifier)]
;> flags bits:
;> 7 (31) = 1
;------------------------------------------------------------------------------
; do we actually need to undefine the button?
test edx, 0x80000000
jnz .remove_button
 
mov edx,2
.loop:
; do we have free button slots available?
mov edi, [BTN_ADDR]
mov eax, [edi]
cmp eax, button._.MAX_BUTTONS
jge .exit
 
cmp byte [esp+edx],0xdf
jbe @f
mov [esp+edx],byte 0xdf
@@:
add [esp+edx],byte 0x20
; does it have positive size? (otherwise it doesn't have sense)
or bx, bx
jle .exit
or cx, cx
jle .exit
 
dec edx
jns .loop
pop ecx
pop edx
ret
; make coordinates clientbox-relative
push eax
mov eax, [current_slot]
rol ebx, 16
add bx, word[eax + APPDATA.wnd_clientbox.left]
rol ebx, 16
rol ecx, 16
add cx, word[eax + APPDATA.wnd_clientbox.top]
rol ecx, 16
pop eax
 
incecx2:
push edx
push ecx
; basic checks passed, define the button
push ebx ecx edx
inc eax
mov [edi], ax
shl eax, 4
add edi, eax
; NOTE: this code doesn't rely on SYS_BUTTON struct, please revise it
; if you change something
mov ax, [CURRENT_TASK]
stosw
mov ax, dx
stosw ; button id number: bits 0-15
mov eax, ebx
rol eax, 16
stosd ; x start | x size
mov eax, ecx
rol eax, 16
stosd ; y start | y size
mov eax, edx
shr eax, 16
stosw ; button id number: bits 16-31
pop edx ecx ebx
 
mov edx,2
.loop:
; do we also need to draw the button?
test edx, 0x40000000
jnz .exit
 
cmp byte [esp+edx],0xeb
jbe @f
mov [esp+edx],byte 0xeb
@@:
add [esp+edx],byte 0x14
; draw button body
 
dec edx
jns .loop
pop ecx
pop edx
ret
pushad
 
drawbuttonframes:
; calculate window-relative coordinates
movzx edi, cx
shr ebx, 16
shr ecx, 16
mov eax, [TASK_BASE]
add ebx, [eax - twdw + WDATA.box.left]
add ecx, [eax - twdw + WDATA.box.top]
mov eax, ebx
shl eax, 16
mov ax, bx
add ax, word[esp + 16]
mov ebx, ecx
shl ebx, 16
mov bx, cx
 
push esi
; calculate initial color
mov ecx, esi
cmp [buttontype], 0
je @f
call button._.incecx2
 
; set button height counter
@@: mov edx, edi
 
.next_line:
call button._.button_dececx
push edi
push eax
push ebx
push ecx
push edx
xor edi, edi
call [draw_line]
pop edi
add ebx, 0x00010001
dec edx
jnz .next_line
 
popad
 
; draw button frame
 
push ebx ecx
 
; calculate window-relative coordinates
shr ebx,16
shr ecx,16
mov eax,[TASK_BASE]
 
add ebx,[eax-twdw + WDATA.box.left]
add ecx,[eax-twdw + WDATA.box.top]
 
; top border
mov eax, ebx
shl eax, 16
mov ax, bx
add ax, word [esp+8]
add ax, [esp + 4]
mov ebx, ecx
shl ebx, 16
mov bx, cx
92,17 → 175,19
push ebx
xor edi, edi
mov ecx, esi
call incecx
call button._.incecx
call [draw_line]
 
movzx edx,word [esp+4+4]
; bottom border
movzx edx, word[esp + 4 + 0]
add ebx,edx
shl edx,16
add ebx,edx
mov ecx,esi
call dececx
call button._.dececx
call [draw_line]
 
; left border
pop ebx
push edx
mov edx,eax
111,342 → 196,92
mov edx,ebx
shr edx,16
mov bx,dx
mov dx,[esp+4+4]
add bx,dx
add bx, [esp + 4 + 0]
pop edx
mov ecx,esi
call incecx
call button._.incecx
call [draw_line]
 
mov dx,[esp+8]
; right border
mov dx, [esp + 4]
add ax,dx
shl edx,16
add eax,edx
add ebx,1*65536
add ebx, 0x00010000
mov ecx,esi
call dececx
call button._.dececx
call [draw_line]
 
pop edx
pop ecx
pop ebx
pop eax
pop edi
pop esi
pop ecx ebx
 
.exit:
ret
 
button_dececx:
 
cmp [buttontype],dword 1
jne .finish
; je bdece
; ret
; bdece:
push eax
mov eax,0x01
cmp edi,20
jg @f
mov eax,0x02
@@:
test ecx,0xff
jz @f
sub ecx,eax
@@:
shl eax,8
test ecx,0xff00
jz @f
sub ecx,eax
@@:
shl eax,8
test ecx,0xff0000
jz @f
sub ecx,eax
@@:
pop eax
.finish:
ret
 
 
sys_button:
 
mov eax, [current_slot]
rol ebx, 16
add bx, word [eax+APPDATA.wnd_clientbox.left]
rol ebx, 16
rol ecx, 16
add cx, word [eax+APPDATA.wnd_clientbox.top]
rol ecx, 16
.forced:
 
test edx, 0x80000000
jnz remove_button
 
or bx, bx
jle noaddbutt
or cx, cx
jle noaddbutt
 
test edx, 0x40000000
jnz button_no_draw
 
pushad ; button body
movzx edi, cx
shr ebx, 16
shr ecx, 16
mov eax, [TASK_BASE]
add ebx, [eax-twdw + WDATA.box.left]
add ecx, [eax-twdw + WDATA.box.top]
mov eax, ebx
shl eax, 16
mov ax, bx
add ax, word [esp+16]
mov ebx, ecx
shl ebx, 16
mov bx, cx
mov ecx, esi
cmp [buttontype], 0
je @f
call incecx2
@@:
mov edx, edi
 
.newline:
call button_dececx
push edi
xor edi, edi
call [draw_line]
pop edi
add ebx, 1*65536+1 ; [ y start | y end ]
dec edx
jnz .newline
popad
 
call drawbuttonframes
 
button_no_draw:
 
; FIXME: mutex needed
syscall_button.remove_button:
and edx, 0x00ffffff
mov edi, [BTN_ADDR]
movzx eax, word [edi]
cmp eax, max_buttons
jge noaddbutt
inc eax
mov [edi], ax
 
shl eax, 4
add edi, eax
 
mov ax, [CURRENT_TASK]
stosw
mov ax, dx
stosw ; button id number: bits 0-15
mov eax, ebx
rol eax, 16
stosd ; x start | x size
mov eax, ecx
rol eax, 16
stosd ; y start | y size
mov eax, edx
shr eax, 16
stosw ; button id number: bits 16-31
 
noaddbutt:
 
ret
 
 
remove_button:
 
and edx, 0x7fffffff
 
rnewba2:
 
mov edi, [BTN_ADDR]
mov eax, edi
movzx ebx, word [edi]
mov ebx, [edi]
inc ebx
imul esi, ebx, SYS_BUTTON.sizeof
add esi, edi
xor ecx, ecx
add ecx, -SYS_BUTTON.sizeof
 
rnewba:
 
.next_button:
dec ebx
jz rnmba
jz .exit
 
add eax, 0x10
add ecx, SYS_BUTTON.sizeof
add esi, -SYS_BUTTON.sizeof
 
mov cx, [CURRENT_TASK]
cmp cx, [eax]
jnz rnewba
cmp dx, [eax+2]
jnz rnewba
; does it belong to our process?
mov ax, [CURRENT_TASK]
cmp ax, [esi + SYS_BUTTON.pslot]
jne .next_button
 
lea ecx, [ebx+1]
shl ecx, 4
mov ebx, eax
add eax, 0x10
; does the identifier match?
mov eax, dword[esi + SYS_BUTTON.id_hi - 2]
mov ax, [esi + SYS_BUTTON.id_lo]
and eax, 0x00ffffff
cmp edx, eax
jne .next_button
 
; okay, undefine it
push ebx
mov ebx, esi
lea eax, [esi + SYS_BUTTON.sizeof]
call memmove
dec dword [edi]
jmp rnewba2
add ecx, -SYS_BUTTON.sizeof
pop ebx
jmp .next_button
 
rnmba:
 
.exit:
ret
 
find_pressed_button_frames:
 
pushad
 
movzx ebx,word [eax+0]
shl ebx,5
add ebx,window_data
mov ecx, [ebx+ WDATA.box.left] ; window x start
movzx edx,word [eax+4] ; button x start
add ecx,edx
push ecx
 
mov dx,[eax+6] ; button x size
add cx,dx
mov esi,ecx
inc esi
mov ecx, [ebx+WDATA.box.top] ; window y start
mov dx,[eax+8] ; button y start
add ecx,edx
mov ebx,ecx
mov dx,[eax+10] ; button y size
add dx,cx
inc dx
 
pop eax
 
; eax x beginning
; ebx y beginning
; esi x end
; edx y end
; ecx color
 
mov [pressed_button_eax],eax
mov [pressed_button_ebx],ebx
mov [pressed_button_ecx],ecx
mov [pressed_button_edx],edx
mov [pressed_button_esi],esi
 
popad
ret
 
uglobal
pressed_button_eax dd 0
pressed_button_ebx dd 0
pressed_button_ecx dd 0
pressed_button_edx dd 0
pressed_button_esi dd 0
endg
 
; negative button image
 
negativebutton:
; If requested, do not display button
; boarder on press.
test ebx,0x20000000
jz draw_negative_button
ret
draw_negative_button:
 
pushad
 
mov eax,[pressed_button_eax]
mov ebx,[pressed_button_ebx]
mov ecx,[pressed_button_ecx]
mov edx,[pressed_button_edx]
mov esi,[pressed_button_esi]
mov ecx,0x01000000
 
dec edx
push edx
inc edx
dec esi
push esi
inc esi
 
push eax
push ebx
push ecx
push edx
push edi
 
call [disable_mouse]
 
bdbnewline:
mov edi,1 ; force
cmp eax,[esp+16]
jz bneg
cmp eax,[esp+20]
jz bneg
cmp ebx,[esp+12]
jz bneg
cmp ebx,[esp+24]
jnz nbneg
; jz bneg
; jmp nbneg
 
bneg:
 
;;;call [disable_mouse]
call [putpixel]
 
nbneg:
 
inc eax
cmp eax,esi
jnz bdbnewline
mov eax,[esp+16]
inc ebx
cmp ebx,edx
jnz bdbnewline
 
add esp,28
 
popad
 
ret
 
; check buttons
 
 
; 0000 word process number
; 0002 word button id number : bits 0-15
; 0004 word x start
; 0006 word x size
; 0008 word y start
; 000A word y size
; 000C word button id number : bits 16-31
;
; button table in 0x10 increments
;
; first at 0x10
 
align 4
checkbuttons:
 
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed
;------------------------------------------------------------------------------
check_buttons: ;///////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
cmp byte[BTN_DOWN], 0 ; mouse buttons pressed
jnz @f
;..................................... start 1/5 : modified by vhanla .............................
mov [bPressedMouseXY_B],0
;..................................... end 1/5 : modified by vhanla .............................
ret
@@:
pushad
 
@@: pushad
xor esi, esi
mov edi, [BTN_ADDR]
movzx edx, word [edi]
mov edx, [edi]
test edx, edx
jne @f
popad
ret
 
@@:
;..................................... start 2/5 : modified by vhanla .............................
;here i catch the coordinates when the mouse's button is clicked
push ax
@@: push ax
cmp [bPressedMouseXY_B],0;FALSE
jnz @f
mov [bPressedMouseXY_B],1;TRUE - it was already clicked
454,28 → 289,24
mov [mx],ax
mov ax,[MOUSE_Y]
mov [my],ax
@@:
pop ax
@@: pop ax
;and it is only refreshed after the mouse's button release
;..................................... end 2/5 : modified by vhanla .............................
 
push esi
inc edx
push edx
 
buttonnewcheck:
 
.buttonnewcheck:
pop edx
pop esi
inc esi
cmp edx,esi
jge bch
jge .bch
 
popad ; no button pressed
popad
ret
 
bch:
 
.bch:
push esi
push edx
mov eax,esi
483,67 → 314,56
add eax,edi
 
; check that button is at top of windowing stack
 
movzx ebx,word [eax]
movzx ebx, [eax + SYS_BUTTON.pslot]
movzx ecx,word [WIN_STACK + ebx * 2]
cmp ecx,[TASK_COUNT]
jne buttonnewcheck
jne .buttonnewcheck
 
; check that button start is inside window x/y end
 
movzx ebx,word [eax+0]
shl ebx,5
 
test [ebx+window_data+WDATA.fl_wstate],WSTATE_MINIMIZED
jnz buttonnewcheck
jnz .buttonnewcheck
 
; add ebx,window_data
; mov ecx,[window_data+ebx+8] ; window end X
movzx edx,word [eax+4] ; button start X
movzx edx, [eax + SYS_BUTTON.left]
cmp edx, [window_data+ebx+WDATA.box.width] ;ecx
jge buttonnewcheck
jge .buttonnewcheck
 
; mov ecx,[window_data+ebx+12] ; window end Y
movzx edx, word [eax+8] ; button start Y
movzx edx, [eax + SYS_BUTTON.top]
cmp edx, [window_data+ebx+WDATA.box.height] ;ecx
jge buttonnewcheck
jge .buttonnewcheck
 
; check coordinates
 
; mouse x >= button x ?
movzx ebx,word [eax+0]
shl ebx,5
add ebx,window_data
mov ecx, [ebx+WDATA.box.left] ; window x start
movzx edx,word [eax+4] ; button x start
mov ecx, [ebx + WDATA.box.left]
movzx edx, [eax + SYS_BUTTON.left]
add edx,ecx
;..................................... start 3/5 : modified by vhanla .............................
mov cx,[mx] ;mov cx,[MOUSE_X]
;..................................... end 3/5 : modified by vhanla .............................
cmp edx,ecx
jg buttonnewcheck
jg .buttonnewcheck
 
movzx ebx,word [eax+6] ; button x size
movzx ebx, [eax + SYS_BUTTON.width]
add edx,ebx
cmp ecx,edx
jg buttonnewcheck
jg .buttonnewcheck
 
; mouse y >= button y ?
movzx ebx,word [eax+0]
movzx ebx, [eax + SYS_BUTTON.pslot]
shl ebx,5
add ebx,window_data
mov ecx, [ebx+WDATA.box.top] ; window y start
movzx edx,word [eax+8] ; button y start
mov ecx, [ebx + WDATA.box.top]
movzx edx, [eax + SYS_BUTTON.top]
add edx,ecx
;..................................... start 4/5 : modified by vhanla .............................
mov cx,[my] ;mov cx,[MOUSE_Y]
;..................................... start 4/5 : modified by vhanla .............................
cmp edx,ecx
jg buttonnewcheck
jg .buttonnewcheck
 
movzx ebx,word [eax+10] ; button y size
movzx ebx, [eax + SYS_BUTTON.height]
add edx,ebx
cmp ecx,edx
jg buttonnewcheck
jg .buttonnewcheck
 
; mouse on button
 
550,27 → 370,21
pop edx
pop esi
 
mov bx,[eax+0xc] ; button id : bits 16-31
shl ebx,16
mov bx,[eax+2] ; button id : bits 00-16
mov ebx, dword[eax + SYS_BUTTON.id_hi - 2] ; button id : bits 16-31
mov bx, [eax + SYS_BUTTON.id_lo] ; button id : bits 00-16
push ebx
 
mov [MOUSE_DOWN],byte 1 ; no mouse down checks
call find_pressed_button_frames
call negativebutton
mov byte[MOUSE_DOWN], 1 ; no mouse down checks
call button._.negative_button
 
pushad
; // Alver 22.06.2008 // {
push eax
mov al, byte [BTN_DOWN]
mov al, [BTN_DOWN]
mov byte [btn_down_determ], al
pop eax
; } \\ Alver \\
 
cbwaitmouseup:
 
.cbwaitmouseup:
call checkidle
 
call [draw_pointer]
 
pushad
577,68 → 391,189
call stack_handler
popad
 
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed ?
jnz cbwaitmouseup
cmp byte[BTN_DOWN], 0 ; mouse buttons pressed ?
jnz .cbwaitmouseup
popad
 
call negativebutton
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse
;..................................... start 5/5 : modified by vhanla .............................
call button._.negative_button
mov byte[MOUSE_BACKGROUND], 0 ; no mouse background
mov byte[DONT_DRAW_MOUSE], 0 ; draw mouse
 
; check coordinates
iglobal
mx dw 0x0 ; keeps the x mouse's position when it was clicked
my dw 0x0 ; keeps the y mouse's position when it was clicked
bPressedMouseXY_B db 0x0
btn_down_determ db 0x0 ; << // Alver 22.06.2008// <<
endg
pusha
 
pusha
; mouse x >= button x ?
movzx ebx,word [eax+0]
movzx ebx, [eax + SYS_BUTTON.pslot]
shl ebx,5
add ebx,window_data
mov ecx, [ebx+WDATA.box.left] ; window x start
movzx edx,word [eax+4] ; button x start
mov ecx, [ebx + WDATA.box.left]
movzx edx, [eax + SYS_BUTTON.left]
add edx,ecx
mov cx,[MOUSE_X]
cmp edx,ecx
jg no_on_button ;if we release the pointer out of the button area
jg .no_on_button ;if we release the pointer out of the button area
 
movzx ebx,word [eax+6] ; button x size
movzx ebx, [eax + SYS_BUTTON.width]
add edx,ebx
cmp ecx,edx
jg no_on_button
jg .no_on_button
 
; mouse y >= button y ?
movzx ebx,word [eax+0]
movzx ebx, [eax + SYS_BUTTON.pslot]
shl ebx,5
add ebx,window_data
mov ecx, [ebx+WDATA.box.top] ; window y start
movzx edx,word [eax+8] ; button y start
mov ecx, [ebx + WDATA.box.top]
movzx edx, [eax + SYS_BUTTON.top]
add edx,ecx
mov cx,[MOUSE_Y]
cmp edx,ecx
jg no_on_button
jg .no_on_button
 
movzx ebx,word [eax+10] ; button y size
movzx ebx, [eax + SYS_BUTTON.height]
add edx,ebx
cmp ecx,edx
jg no_on_button
jg .no_on_button
 
popa
mov [BTN_COUNT],byte 1 ; no of buttons in buffer
 
mov byte[BTN_COUNT], 1 ; no of buttons in buffer
pop ebx
mov [BTN_BUFF],ebx ; lets put the button id in buffer
push ebx
pusha
jmp yes_on_button
no_on_button:
mov [BTN_COUNT],byte 0 ; no of buttons in buffer
yes_on_button:
mov [MOUSE_DOWN],byte 0 ; mouse down -> do not draw
jmp .yes_on_button
 
.no_on_button:
mov byte[BTN_COUNT], 0 ; no of buttons in buffer
 
.yes_on_button:
mov byte[MOUSE_DOWN], 0 ; mouse down -> do not draw
popa
pop ebx
popa
ret
 
;..................................... end 5/5 : modified by vhanla ................................
;==============================================================================
;///// private functions //////////////////////////////////////////////////////
;==============================================================================
 
;------------------------------------------------------------------------------
button._.dececx: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
sub cl, 0x20
jnc @f
xor cl, cl
@@: sub ch, 0x20
jnc @f
xor ch, ch
@@: rol ecx, 16
sub cl, 0x20
jnc @f
xor cl, cl
@@: rol ecx, 16
ret
 
;------------------------------------------------------------------------------
button._.incecx: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
add cl, 0x20
jnc @f
or cl, -1
@@: add ch, 0x20
jnc @f
or ch, -1
@@: rol ecx, 16
add cl, 0x20
jnc @f
or cl, -1
@@: rol ecx, 16
ret
 
;------------------------------------------------------------------------------
button._.incecx2: ;////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
add cl, 0x14
jnc @f
or cl, -1
@@: add ch, 0x14
jnc @f
or ch, -1
@@: rol ecx, 16
add cl, 0x14
jnc @f
or cl, -1
@@: rol ecx, 16
ret
 
;------------------------------------------------------------------------------
button._.button_dececx: ;//////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
cmp [buttontype], 1
jne .finish
 
push eax
mov al, 1
cmp edi, 20
jg @f
mov al, 2
 
@@: sub cl, al
jnc @f
xor cl, cl
@@: sub ch, al
jnc @f
xor ch, ch
@@: rol ecx, 16
sub cl, al
jnc @f
xor cl, cl
@@: rol ecx, 16
 
pop eax
 
.finish:
ret
 
;------------------------------------------------------------------------------
button._.negative_button: ;////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
; if requested, do not display button border on press.
test ebx, 0x20000000
jnz .exit
 
pushad
 
xchg esi, eax
 
movzx ecx, [esi + SYS_BUTTON.pslot]
shl ecx, 5
add ecx, window_data
 
mov eax, dword[esi + SYS_BUTTON.left]
mov ebx, dword[esi + SYS_BUTTON.top]
add eax, [ecx + WDATA.box.left]
add ebx, [ecx + WDATA.box.top]
push eax ebx
pop edx ecx
rol eax, 16
rol ebx, 16
add ax, cx
add bx, dx
 
mov esi, 0x01000000
call draw_rectangle.forced
 
popad
 
.exit:
ret
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/event.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/font.inc
33,7 → 33,7
.1:
; } \\ Alver \\
pushad
call [disable_mouse]
call [_display.disable_mouse]
 
movsx eax, bx ; eax=y
sar ebx, 16 ; ebx=x
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/mouse.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/skincode.inc
311,7 → 311,6
; shr esi,1
; and esi,0x007f7f7f
mov esi,[ebp+SKIN_DATA.colors.outer]
or [edi+WDATA.fl_wdrawn], 4
call draw_rectangle
mov ecx,3
_dw3l:
455,12 → 454,6
 
no_skin_add_button:
pop edi
and [edi+WDATA.fl_wdrawn], not 4
test [edi+WDATA.fl_wdrawn], 2
jz @f
call drawwindowframes2
@@:
 
popa
 
ret 4
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/skindata.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/gui/window.inc
9,658 → 9,606
$Revision$
 
 
get_titlebar_height: ; edi = window draw_data pointer
mov al,[edi+WDATA.fl_wstyle]
and al,0x0F
cmp al,0x03
jne @f
mov eax,[_skinh]
;==============================================================================
;///// public functions ///////////////////////////////////////////////////////
;==============================================================================
 
macro FuncTable name, [label]
{
common
align 4
\label name#.ftable dword
forward
dd name#.#label
common
name#.sizeof.ftable = $ - name#.ftable
}
 
iglobal
FuncTable syscall_display_settings, \
00, 01, 02, 03, 04, 05, 06, 07, 08
endg
 
uglobal
common_colours rd 32
new_window_starting dd ?
latest_window_touch dd ?
latest_window_touch_delta dd ?
old_window_pos BOX
new_window_pos BOX
draw_limits RECT
bPressedMouseXY_W db ?
do_resize db ?
do_resize_from_corner db ?
reposition db ?
endg
 
align 4
;------------------------------------------------------------------------------
syscall_display_settings: ;///// system function 48 ///////////////////////////
;------------------------------------------------------------------------------
;; Redraw screen:
;< ebx = 0
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set button style:
;< ebx = 1
;< ecx = 0 (flat) or 1 (with gradient)
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set system color palette:
;< ebx = 2
;< ecx = pointer to color table
;< edx = size of color table
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get system color palette:
;< ebx = 3
;< ecx = pointer to color table buffer
;< edx = size of color table buffer
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get skinned caption height:
;< ebx = 4
;> eax = height in pixels
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get screen working area:
;< ebx = 5
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set screen working area:
;< ebx = 6
;< ecx = pack[16(left), 16(right)]
;< edx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Get skin margins:
;< ebx = 7
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set skin:
;< ebx = 8
;< ecx = pointer to FileInfoBlock struct
;> eax = FS error code
;------------------------------------------------------------------------------
cmp ebx, .sizeof.ftable / 4
ja @f
jmp [.ftable + ebx * 4]
@@: ret
 
 
align 4
syscall_display_settings.00:
xor eax, eax
inc ebx
cmp [windowtypechanged], ebx
jne .exit
mov [windowtypechanged], eax
 
jmp syscall_display_settings._.redraw_whole_screen
 
.exit:
ret
@@: mov eax,21
 
align 4
syscall_display_settings.01:
and ecx, 1
cmp ecx, [buttontype]
je .exit
mov [buttontype], ecx
mov [windowtypechanged], ebx
 
.exit:
ret
 
get_rolledup_height: ; edi = window draw_data pointer
mov al,[edi+WDATA.fl_wstyle]
and al,0x0F
cmp al,0x03
jb @f
mov eax,[_skinh]
add eax,3
align 4
syscall_display_settings.02:
dec ebx
mov esi, ecx
and edx, 127
mov edi, common_colours
mov ecx, edx
rep movsb
mov [windowtypechanged], ebx
ret
@@: or al,al
jnz @f
mov eax,21
 
align 4
syscall_display_settings.03:
mov edi, ecx
and edx, 127
mov esi, common_colours
mov ecx, edx
rep movsb
ret
@@: mov eax,21+2
 
align 4
syscall_display_settings.04:
mov eax, [_skinh]
mov [esp + 32], eax
ret
 
align 4
syscall_display_settings.05:
mov eax, [screen_workarea.left - 2]
mov ax, word[screen_workarea.right]
mov [esp + 32], eax
mov eax, [screen_workarea.top - 2]
mov ax, word[screen_workarea.bottom]
mov [esp + 20], eax
ret
 
setwindowdefaults:
pushad
align 4
syscall_display_settings.06:
xor esi, esi
 
mov edi, [Screen_Max_X]
mov eax, ecx
movsx ebx, ax
sar eax, 16
cmp eax, ebx
jge .check_horizontal
inc esi
or eax, eax
jge @f
xor eax,eax
mov ecx,WIN_STACK
@@:
inc eax
add ecx,2
mov [ecx+0x000],ax ; process no
mov [ecx+0x400],ax ; positions in stack
cmp ecx,WIN_POS-2 ; the more high, the more surface
jnz @b
@@: mov [screen_workarea.left], eax
cmp ebx, edi
jle @f
mov ebx, edi
@@: mov [screen_workarea.right], ebx
 
popad
.check_horizontal:
mov edi, [Screen_Max_Y]
mov eax, edx
movsx ebx, ax
sar eax, 16
cmp eax, ebx
jge .check_if_redraw_needed
inc esi
or eax, eax
jge @f
xor eax, eax
@@: mov [screen_workarea.top], eax
cmp ebx, edi
jle @f
mov ebx, edi
@@: mov [screen_workarea.bottom], ebx
 
.check_if_redraw_needed:
or esi, esi
jz .exit
 
call repos_windows
jmp syscall_display_settings._.calculate_whole_screen
 
.exit:
ret
 
align 4
syscall_display_settings.07:
mov eax, [_skinmargins + 0]
mov [esp + 32], eax
mov eax, [_skinmargins + 4]
mov [esp + 20], eax
ret
 
align 4
syscall_display_settings.08:
mov ebx, ecx
call read_skin_file
mov [esp + 32], eax
test eax, eax
jnz .exit
 
; eax = cx
; ebx = cy
; ecx = ex
; edx = ey
; èäåÿ: ïåðåáðàòü âñå îêíà, íà÷èíàÿ ñ ñàìîãî íèæíåãî,
; è äëÿ ïîïàâøèõ â çàäàííóþ îáëàñòü
; ÷àñòåé îêîí âûçâàòü setscreen
call syscall_display_settings._.calculate_whole_screen
jmp syscall_display_settings._.redraw_whole_screen
 
.exit:
ret
 
syscall_display_settings._.calculate_whole_screen:
xor eax, eax
xor ebx, ebx
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
jmp calculatescreen
 
syscall_display_settings._.redraw_whole_screen:
xor eax, eax
mov [draw_limits.left], eax
mov [draw_limits.top], eax
mov eax, [Screen_Max_X]
mov [draw_limits.right], eax
mov eax, [Screen_Max_Y]
mov [draw_limits.bottom], eax
mov eax, window_data
jmp redrawscreen
 
align 4
calculatescreen:
pushad
;------------------------------------------------------------------------------
syscall_set_window_shape: ;///// system function 50 ///////////////////////////
;------------------------------------------------------------------------------
;; Set window shape address:
;> ebx = 0
;> ecx = shape data address
; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
;; Set window shape scale:
;> ebx = 1
;> ecx = scale power (resulting scale is 2^ebx)
;------------------------------------------------------------------------------
mov edi, [current_slot]
 
test ebx, ebx
jne .shape_scale
mov [edi + APPDATA.wnd_shape], ecx
 
.shape_scale:
dec ebx
jnz .exit
mov [edi + APPDATA.wnd_shape_scale], ecx
 
.exit:
ret
 
align 4
;------------------------------------------------------------------------------
set_window_defaults: ;/////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
push eax ecx
xor eax, eax
mov ecx, WIN_STACK
@@: inc eax
add ecx, 2
; process no
mov [ecx + 0x000], ax
; positions in stack
mov [ecx + 0x400], ax
cmp ecx, WIN_POS - 2
jne @b
pop ecx eax
ret
 
align 4
;------------------------------------------------------------------------------
calculatescreen: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Scan all windows from bottom to top, calling `setscreen` for each one
;? intersecting given screen area
;------------------------------------------------------------------------------
;> eax = left
;> ebx = top
;> ecx = right
;> edx = bottom
;------------------------------------------------------------------------------
push esi
pushfd
cli
 
push edx ecx ebx eax
 
mov esi, 1
call setscreen
call window._.set_screen
 
mov ebp, [TASK_COUNT] ; number of processes
push ebp
 
mov ebp, [TASK_COUNT]
cmp ebp, 1
jbe .finish
align 4
.new_wnd:
jbe .exit
 
push edx ecx ebx eax
 
.next_window:
movzx edi, word [WIN_POS + esi * 2]
shl edi, 5
 
cmp [CURRENT_TASK+edi+TASKDATA.state], byte 9
je .not_wnd
cmp [CURRENT_TASK + edi + TASKDATA.state], TSTATE_FREE
je .skip_window
 
add edi, window_data
test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
jnz .not_wnd
jnz .skip_window
 
mov eax,[edi+WDATA.box.left]
cmp eax, [esp+RECT.right]
ja .out_of_bounds
jg .skip_window
mov ebx,[edi+WDATA.box.top]
cmp ebx, [esp+RECT.bottom]
ja .out_of_bounds
jg .skip_window
mov ecx,[edi+WDATA.box.width]
add ecx, eax
cmp ecx, [esp+RECT.left]
jb .out_of_bounds
jl .skip_window
mov edx,[edi+WDATA.box.height]
add edx, ebx
cmp edx, [esp+RECT.top]
jb .out_of_bounds
jl .skip_window
 
cmp eax, [esp+RECT.left]
jae @f
mov eax, [esp+RECT.left]
@@:
cmp ebx, [esp+RECT.top]
@@: cmp ebx, [esp + RECT.top]
jae @f
mov ebx, [esp+RECT.top]
@@:
cmp ecx, [esp+RECT.right]
@@: cmp ecx, [esp + RECT.right]
jbe @f
mov ecx, [esp+RECT.right]
@@:
cmp edx, [esp+RECT.bottom]
@@: cmp edx, [esp + RECT.bottom]
jbe @f
mov edx, [esp+RECT.bottom]
@@:
 
push esi
@@: push esi
movzx esi, word [WIN_POS + esi * 2]
call setscreen
call window._.set_screen
pop esi
 
.not_wnd:
.out_of_bounds:
.skip_window:
inc esi
dec ebp
jnz .new_wnd
.finish:
jnz .next_window
 
pop eax ebx ecx edx
 
.exit:
pop ebp
popfd
popad
pop esi
ret
 
 
 
virtual at esp
ff_x dd ?
ff_y dd ?
ff_width dd ?
ff_xsz dd ?
ff_ysz dd ?
ff_scale dd ?
end virtual
 
align 4
; ðåçåðâèðóåò ìåñòî ïîä îêíî çàäàííîãî ïðîöåññà
setscreen:
; eax x start
; ebx y start
; ecx x end
; edx y end
; esi process number
pushad
; \begin{diamond}[29.08.2006]
cmp esi, 1
jz @f
mov edi, esi
shl edi, 5
cmp [edi+window_data+WDATA.box.width], 0
jnz @f
cmp [edi+window_data+WDATA.box.height], 0
jz .ret
@@:
; \end{diamond}[29.08.2006]
mov edi, esi ;;;word [esi*2+WIN_POS]
shl edi, 8
add edi, SLOT_BASE ; address of random shaped window area
cmp [edi+APPDATA.wnd_shape], dword 0
jne .free_form
 
; get x&y size
sub ecx, eax
sub edx, ebx
inc ecx
inc edx
 
; get WinMap start
mov edi, [Screen_Max_X] ; screen_sx
inc edi
imul edi, ebx
add edi, eax
add edi, WinMapAddress
 
.new_y:
push ecx ; sx
push edx
 
mov edx, esi
align 4
.new_x:
mov byte [edi], dl
inc edi
dec ecx
jnz .new_x
 
pop edx
pop ecx
add edi, [Screen_Max_X]
inc edi
sub edi, ecx
dec edx
jnz .new_y
.ret:
popad
ret
.read_byte:
;eax - address
;esi - slot
push eax
push ebx
push ecx
push edx
mov edx,eax
mov eax,esi
lea ebx,[esp+12]
mov ecx,1
call read_process_memory
pop edx
pop ecx
pop ebx
pop eax
ret
.free_form:
 
; for (y=0; y <= x_size; y++)
; for (x=0; x <= x_size; x++)
; if (shape[coord(x,y,scale)]==1)
; set_pixel(x, y, process_number);
 
sub ecx, eax
sub edx, ebx
inc ecx
inc edx
 
push dword [edi+APPDATA.wnd_shape_scale] ; push scale first -> for loop
 
; get WinMap start -> ebp
push eax
mov eax, [Screen_Max_X] ; screen_sx
inc eax
imul eax, ebx
add eax, [esp]
add eax, WinMapAddress
mov ebp, eax
 
mov edi, [edi+APPDATA.wnd_shape]
pop eax
 
; eax = x_start
; ebx = y_start
; ecx = x_size
; edx = y_size
; esi = process_number
; edi = &shape
; [scale]
push edx ecx ; for loop - x,y size
 
mov ecx, esi
shl ecx, 5
mov edx, [window_data+ecx+WDATA.box.top]
push [window_data+ecx+WDATA.box.width] ; for loop - width
mov ecx, [window_data+ecx+WDATA.box.left]
sub ebx, edx
sub eax, ecx
push ebx eax ; for loop - x,y
 
add [ff_xsz], eax
add [ff_ysz], ebx
 
mov ebx, [ff_y]
 
.ff_new_y:
mov edx, [ff_x]
 
.ff_new_x:
; -- body --
mov ecx, [ff_scale]
mov eax, [ff_width]
inc eax
shr eax, cl
push ebx edx
shr ebx, cl
shr edx, cl
imul eax, ebx
add eax, edx
pop edx ebx
add eax, edi
call .read_byte
test al,al
jz @f
mov eax, esi
mov [ebp], al
@@:
; -- end body --
inc ebp
inc edx
cmp edx, [ff_xsz]
jb .ff_new_x
sub ebp, [ff_xsz]
add ebp, [ff_x]
add ebp, [Screen_Max_X] ; screen.x
inc ebp
inc ebx
cmp ebx, [ff_ysz]
jb .ff_new_y
 
add esp, 24
popad
ret
 
 
display_settings:
 
; eax = 0 ; DISPLAY redraw
; ebx = 0 ; all
;
; eax = 1 ; BUTTON type
; ebx = 0 ; flat
; ebx = 1 ; 3D
; eax = 2 ; set WINDOW colours
; ebx = pointer to table
; ecx = number of bytes define
; eax = 3 ; get WINDOW colours
; ebx = pointer to table
; ecx = number of bytes wanted
; eax = 4 ; get skin height
; input : nothing
; output : eax = skin height in pixel
; eax = 5 ; get screen workarea
; input : nothing
; output : eax = [left]*65536+[right]
; ebx = [top]*65536+[bottom]
; eax = 6 ; set screen workarea
; input : ecx = [left]*65536+[right]
; edx = [top]*65536+[bottom]
; output : nothing
; eax = 7 ; get skin margins
; input : nothing
; output : eax = [left]*65536+[right]
; ebx = [top]*65536+[bottom]
; eax = 8 ; set window skin
; input : ecx = pointer to file info block
; output : eax = FS error code
 
 
pushad
 
test eax, eax ; redraw display
jnz dspl0
test ebx, ebx
jnz dspl0
cmp [windowtypechanged],dword 1
jne dspl00
mov [windowtypechanged],dword 0
redraw_screen_direct:
mov [dlx],dword 0
mov [dly],dword 0
mov eax,[Screen_Max_X]
mov [dlxe],eax
mov eax,[Screen_Max_Y]
mov [dlye],eax
mov eax,window_data
call redrawscreen
dspl00:
popad
ret
dspl0:
 
cmp eax,1 ; button type
jne dspl1
and ebx,1
cmp ebx,[buttontype]
je dspl9
mov [buttontype],ebx
mov [windowtypechanged],dword 1
dspl9:
popad
ret
dspl1:
 
cmp eax,2 ; set common window colours
jne no_com_colours
mov [windowtypechanged],dword 1
mov esi,[TASK_BASE]
add esi,TASKDATA.mem_start
add ebx,[esi]
mov esi,ebx
mov edi,common_colours
and ecx,127
cld
rep movsb
popad
ret
no_com_colours:
 
cmp eax,3 ; get common window colours
jne no_get_com
mov esi,[TASK_BASE]
add esi,TASKDATA.mem_start
add ebx,[esi]
mov edi,ebx
mov esi,common_colours
and ecx,127
cld
rep movsb
popad
ret
no_get_com:
 
cmp eax,4 ; get skin height
jne no_skin_height
popad
mov eax,[_skinh]
mov [esp+36],eax
ret
no_skin_height:
 
cmp eax,5 ; get screen workarea
jne no_get_workarea
popad
mov eax,[screen_workarea.left-2]
mov ax,word[screen_workarea.right]
mov [esp+36],eax
mov eax,[screen_workarea.top-2]
mov ax,word[screen_workarea.bottom]
mov [esp+24],eax
ret
no_get_workarea:
 
cmp eax,6 ; set screen workarea
jne no_set_workarea
movsx eax,word[esp+16+2]
movsx ebx,word[esp+16]
cmp eax,ebx
jge .lp1
or eax,eax;[Screen_Max_X]
jl @f
mov [screen_workarea.left],eax
@@: cmp ebx,[Screen_Max_X]
jg .lp1
mov [screen_workarea.right],ebx
.lp1: movsx eax,word[esp+24+2]
movsx ebx,word[esp+24]
cmp eax,ebx
jge .lp2
or eax,eax;[0xFE04]
jl @f
mov [screen_workarea.top],eax
@@: cmp ebx,[Screen_Max_Y]
jg .lp2
mov [screen_workarea.bottom],ebx
.lp2: call repos_windows
mov eax, 0
mov ebx, 0
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
call calculatescreen
; jmp redraw_screen_direct
.exit:
popad
ret
no_set_workarea:
 
cmp eax,7 ; get skin margins
jne no_get_skinmargins
popad
mov eax,dword[_skinmargins+0]
mov [esp+36],eax
mov eax,dword[_skinmargins+4]
mov [esp+24],eax
ret
no_get_skinmargins:
 
cmp eax,8 ; set window skin
jne no_set_skin
call read_skin_file
mov [esp+32+36], eax
test eax, eax
jnz .ret
xor eax, eax
xor ebx, ebx
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
call calculatescreen
jmp redraw_screen_direct
.ret:
popad
ret
no_set_skin:
 
popad
ret
 
 
repos_windows:
;------------------------------------------------------------------------------
repos_windows: ;///////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
mov ecx,[TASK_COUNT]
mov edi, OS_BASE+0x20*2
mov edi, window_data + WDATA.sizeof * 2
call force_redraw_background
dec ecx
jge @f
ret
@@: mov [edi+WDATA.fl_redraw],1
jle .exit
 
.next_window:
mov [edi + WDATA.fl_redraw], 1
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jz .lp2
mov eax,[screen_workarea.left]
mov [edi+WDATA.box.left],eax
sub eax,[screen_workarea.right]
neg eax
mov [edi+WDATA.box.width],eax
mov eax,[screen_workarea.top]
mov [edi+WDATA.box.top],eax
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
jnz .lp1
sub eax,[screen_workarea.bottom]
neg eax
mov [edi+WDATA.box.height],eax
.lp1:
jnz .fix_maximized
 
call set_window_clientbox
add edi,0x20
loop @b
ret
.lp2: mov eax,[edi+WDATA.box.left]
mov eax, [edi + WDATA.box.left]
add eax,[edi+WDATA.box.width]
mov ebx,[Screen_Max_X]
; inc ebx
cmp eax,ebx
jle .lp4
jle .fix_vertical
mov eax,[edi+WDATA.box.width]
sub eax,ebx
jle .lp3
jle @f
mov [edi+WDATA.box.width],ebx
.lp3: sub ebx,[edi+WDATA.box.width]
@@: sub ebx, [edi + WDATA.box.width]
mov [edi+WDATA.box.left],ebx
.lp4: mov eax,[edi+WDATA.box.top]
 
.fix_vertical:
mov eax, [edi + WDATA.box.top]
add eax,[edi+WDATA.box.height]
mov ebx,[Screen_Max_Y]
; inc ebx
cmp eax,ebx
jle .lp6
jle .fix_client_box
mov eax,[edi+WDATA.box.height]
sub eax,ebx
jle .lp5
jle @f
mov [edi+WDATA.box.height],ebx
.lp5: sub ebx,[edi+WDATA.box.height]
@@: sub ebx, [edi + WDATA.box.height]
mov [edi+WDATA.box.top],ebx
.lp6: jmp .lp1
jmp .fix_client_box
 
uglobal
common_colours:
times 128 db 0x0
endg
.fix_maximized:
mov eax, [screen_workarea.left]
mov [edi + WDATA.box.left], eax
sub eax, [screen_workarea.right]
neg eax
mov [edi + WDATA.box.width], eax
mov eax, [screen_workarea.top]
mov [edi + WDATA.box.top], eax
test [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP
jnz .fix_client_box
sub eax, [screen_workarea.bottom]
neg eax
mov [edi + WDATA.box.height], eax
 
.fix_client_box:
call set_window_clientbox
 
add edi, WDATA.sizeof
loop .next_window
 
.exit:
ret
 
check_window_position:
align 4
;------------------------------------------------------------------------------
check_window_position: ;///////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Check if window is inside screen area
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
push eax ebx ecx edx esi
 
pushad ; window inside screen ?
 
mov eax, [edi+WDATA.box.left]
mov ebx, [edi+WDATA.box.top]
mov ecx, [edi+WDATA.box.width]
mov edx, [edi+WDATA.box.height]
 
cmp ecx,[Screen_Max_X] ; check x size
jbe x_size_ok
mov ecx,[Screen_Max_X]
mov [edi+WDATA.box.width],ecx
mov esi, [Screen_Max_X]
cmp ecx, esi
ja .fix_width
 
x_size_ok:
.check_left:
or eax, eax
jl .fix_left_low
add eax, ecx
cmp eax, esi
jg .fix_left_high
 
cmp edx,[Screen_Max_Y] ; check y size
jbe y_size_ok
mov edx,[Screen_Max_Y]
mov [edi+WDATA.box.height],edx
.check_height:
mov esi, [Screen_Max_Y]
cmp edx, esi
ja .fix_height
 
y_size_ok:
.check_top:
or ebx, ebx
jl .fix_top_low
add ebx, edx
cmp ebx, esi
jg .fix_top_high
 
cmp eax,0 ; check x pos
jnle @f
.exit:
pop esi edx ecx ebx eax
ret
 
.fix_width:
mov ecx, esi
mov [edi + WDATA.box.width], esi
jmp .check_left
 
.fix_left_low:
xor eax,eax
mov [edi+WDATA.box.left],eax
jmp x_pos_ok
@@:
add eax,ecx
cmp eax,[Screen_Max_X]
jbe x_pos_ok
mov eax,[Screen_Max_X]
jmp .check_height
 
.fix_left_high:
mov eax, esi
sub eax,ecx
mov [edi+WDATA.box.left],eax
jmp .check_height
 
x_pos_ok:
.fix_height:
mov edx, esi
mov [edi + WDATA.box.height], esi
jmp .check_top
 
cmp ebx,0 ; check x pos
jnle @f
.fix_top_low:
xor ebx,ebx
mov [edi+WDATA.box.top],ebx
jmp y_pos_ok
@@:
add ebx,edx
cmp ebx,[Screen_Max_Y]
jbe y_pos_ok
mov ebx,[Screen_Max_Y]
jmp .exit
 
.fix_top_high:
mov ebx, esi
sub ebx,edx
mov [edi+WDATA.box.top],ebx
jmp .exit
 
y_pos_ok:
align 4
;------------------------------------------------------------------------------
sys_window_mouse: ;////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
push eax
 
popad
mov eax, [timer_ticks]
cmp [new_window_starting], eax
jb .exit
 
mov byte[MOUSE_BACKGROUND], 0
mov byte[DONT_DRAW_MOUSE], 0
 
mov [new_window_starting], eax
 
.exit:
pop eax
ret
 
align 4
;------------------------------------------------------------------------------
draw_rectangle: ;//////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = pack[16(left), 16(right)]
;> ebx = pack[16(top), 16(bottom)]
;> esi = color
;------------------------------------------------------------------------------
push eax ebx ecx edi
 
uglobal
new_window_starting dd 0
endg
xor edi, edi
 
.flags_set:
push ebx
 
sys_window_mouse:
; set line color
mov ecx, esi
 
push eax
; draw top border
rol ebx, 16
push ebx
rol ebx, 16
pop bx
call [draw_line]
 
mov eax,[timer_ticks]
cmp [new_window_starting],eax
jb swml1
; draw bottom border
mov ebx, [esp - 2]
pop bx
call [draw_line]
 
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse
pop ebx
add ebx, 1 * 65536 - 1
 
mov [new_window_starting],eax
; draw left border
rol eax, 16
push eax
rol eax, 16
pop ax
call [draw_line]
 
swml1:
; draw right border
mov eax, [esp - 2]
pop ax
call [draw_line]
 
pop eax
 
pop edi ecx ebx eax
ret
 
.forced:
push eax ebx ecx edi
xor edi, edi
inc edi
jmp .flags_set
 
align 4
;------------------------------------------------------------------------------
drawwindow_I_caption: ;////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
push [edx + WDATA.cl_titlebar]
mov esi, edx
 
 
drawwindow_I_caption:
 
mov ecx,[edx+WDATA.cl_titlebar] ; grab bar
push ecx
mov esi,edx
mov edx,[esi+WDATA.box.top]
add edx,1
mov ebx,[esi+WDATA.box.top]
add ebx,21
mov eax,[esi+WDATA.box.top]
mov eax, edx
lea ebx, [edx + 21]
inc edx
add eax,[esi+WDATA.box.height]
 
cmp ebx,eax
jb .wdsizeok
jbe @f
mov ebx,eax
.wdsizeok:
push ebx
.drwi:
@@: push ebx
 
xor edi, edi
 
.next_line:
mov ebx,edx
shl ebx,16
add ebx,edx
669,126 → 617,79
shl eax,16
add eax,[esi+WDATA.box.left]
add eax,[esi+WDATA.box.width]
sub eax,1
push edx
mov edx,0x80000000
dec eax
mov ecx,[esi+WDATA.cl_titlebar]
and ecx,edx
cmp ecx,edx
jnz .nofa
mov ecx,[esi+WDATA.cl_titlebar]
test ecx, 0x80000000
jz @f
sub ecx,0x00040404
mov [esi+WDATA.cl_titlebar],ecx
and ecx,0x00ffffff
jmp .faj
.nofa:
mov ecx,[esi+WDATA.cl_titlebar]
and ecx,0x00ffffff
.faj:
pop edx
mov edi,0
@@: and ecx, 0x00ffffff
call [draw_line]
inc edx
cmp edx,[esp]
jb .drwi
jb .next_line
 
add esp,4
pop ecx
mov [esi+WDATA.cl_titlebar],ecx
 
pop [esi + WDATA.cl_titlebar]
ret
 
align 4
;------------------------------------------------------------------------------
drawwindow_I: ;////////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
pushad
 
drawwindow_I:
; window border
 
pushad
or [edx+WDATA.fl_wdrawn], 4
mov eax, [edx + WDATA.box.left - 2]
mov ax, word[edx + WDATA.box.left]
add ax, word[edx + WDATA.box.width]
mov ebx, [edx + WDATA.box.top - 2]
mov bx, word[edx + WDATA.box.top]
add bx, word[edx + WDATA.box.height]
 
mov esi,[edx+WDATA.cl_frames] ; rectangle
mov eax,[edx+WDATA.box.left]
shl eax,16
add eax,[edx+WDATA.box.left]
add eax,[edx+WDATA.box.width]
mov ebx,[edx+WDATA.box.top]
shl ebx,16
add ebx,[edx+WDATA.box.top]
add ebx,[edx+WDATA.box.height]
mov esi, [edx + WDATA.cl_frames]
call draw_rectangle
 
and [edx+WDATA.fl_wdrawn], not 4
test [edx+WDATA.fl_wdrawn], 2
jz @f
call drawwindowframes2
@@:
; window caption
 
call drawwindow_I_caption
 
mov edx,[esi+WDATA.box.top] ; inside work area
; window client area
 
; do we need to draw it?
mov edi, [esi + WDATA.cl_workarea]
test edi, 0x40000000
jnz .exit
 
; does client area have a positive size on screen?
mov edx, [esi + WDATA.box.top]
add edx,21+5
mov ebx,[esi+WDATA.box.top]
add ebx,[esi+WDATA.box.height]
cmp edx,ebx
jg noinside
jg .exit
 
; okay, let's draw it
mov eax,1
mov ebx,21
mov ecx,[esi+WDATA.box.width]
mov edx,[esi+WDATA.box.height]
mov edi,[esi+WDATA.cl_workarea]
test edi,0x40000000
jnz noinside
call [drawbar]
noinside:
 
.exit:
popad
 
ret
 
 
draw_rectangle:
 
r_eax equ [esp+28] ; x start
r_ax equ [esp+30] ; x end
r_ebx equ [esp+16] ; y start
r_bx equ [esp+18] ; y end
;esi ; color
 
pushad
 
mov ecx,esi ; yb,xb -> yb,xe
mov eax, r_eax
rol eax, 16
mov ebx,r_ebx
shl ebx,16
mov bx,r_ebx
xor edi, edi
call [draw_line]
 
mov ebx,r_bx ; ye,xb -> ye,xe
shl ebx,16
mov bx,r_bx
call [draw_line]
 
mov ecx,esi ; ya,xa -> ye,xa
mov eax,r_eax
shl eax,16
mov ax,r_eax
mov ebx,r_ebx
shl ebx,16
mov bx,r_bx
mov edi,0
call [draw_line]
 
mov eax,r_ax ; ya,xe -> ye,xe
shl eax,16
mov ax,r_ax
call [draw_line]
 
popad
ret
 
 
drawwindow_III_caption:
 
mov ecx,[edx+WDATA.cl_titlebar] ; GRAB BAR
align 4
;------------------------------------------------------------------------------
drawwindow_III_caption: ;/////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
mov ecx, [edx + WDATA.cl_titlebar]
push ecx
mov esi,edx
mov edx,[esi+WDATA.box.top]
797,12 → 698,15
add ebx,20
mov eax,[esi+WDATA.box.top]
add eax,[esi+WDATA.box.height]
 
cmp ebx,eax
jb .wdsizeok
jb @f
mov ebx,eax
.wdsizeok:
push ebx
.drwi:
@@: push ebx
 
xor edi, edi
 
.next_line:
mov ebx,edx
shl ebx,16
add ebx,edx
813,72 → 717,80
add eax,4*65536-4
mov ecx,[esi+WDATA.cl_titlebar]
test ecx,0x40000000
jz .nofa
add ecx,0x040404
.nofa:
test ecx,0x80000000
jz .nofa2
sub ecx,0x040404
.nofa2:
mov [esi+WDATA.cl_titlebar],ecx
and ecx,0xffffff
xor edi, edi
jz @f
add ecx, 0x00040404
@@: test ecx, 0x80000000
jz @f
sub ecx, 0x00040404
@@: mov [esi + WDATA.cl_titlebar], ecx
and ecx, 0x00ffffff
call [draw_line]
inc edx
cmp edx,[esp]
jb .drwi
jb .next_line
 
add esp,4
pop ecx
mov [esi+WDATA.cl_titlebar],ecx
 
pop [esi + WDATA.cl_titlebar]
ret
 
align 4
;------------------------------------------------------------------------------
drawwindow_III: ;//////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? <description>
;------------------------------------------------------------------------------
pushad
 
drawwindow_III:
; window border
 
pushad
mov eax, [edx + WDATA.box.left - 2]
mov ax, word[edx + WDATA.box.left]
add ax, word[edx + WDATA.box.width]
mov ebx, [edx + WDATA.box.top - 2]
mov bx, word[edx + WDATA.box.top]
add bx, word[edx + WDATA.box.height]
 
mov edi,edx ; RECTANGLE
mov eax,[edi+WDATA.box.left]
shl eax,16
mov ax, word [edi+WDATA.box.left]
add ax, word [edi+WDATA.box.width]
mov ebx,[edi+WDATA.box.top]
shl ebx,16
mov bx, word [edi+WDATA.box.top]
add bx, word [edi+WDATA.box.height]
mov esi,[edi+WDATA.cl_frames]
mov esi, [edx + WDATA.cl_frames]
shr esi,1
and esi,0x007f7f7f
call draw_rectangle
 
push esi
or [edi+WDATA.fl_wdrawn], 4
call draw_rectangle
and [edi+WDATA.fl_wdrawn], not 4
test [edi+WDATA.fl_wdrawn], 2
jz @f
call drawwindowframes2
@@:
mov ecx,3
dw3l:
mov esi, [edx + WDATA.cl_frames]
 
.next_frame:
add eax,1*65536-1
add ebx,1*65536-1
mov esi,[edi+WDATA.cl_frames]
call draw_rectangle
dec ecx
jnz dw3l
jnz .next_frame
 
pop esi
add eax,1*65536-1
add ebx,1*65536-1
call draw_rectangle
 
; window caption
 
call drawwindow_III_caption
 
mov edx,[esi+WDATA.box.top] ; WORK AREA
; window client area
 
; do we need to draw it?
mov edi, [esi + WDATA.cl_workarea]
test edi, 0x40000000
jnz .exit
 
; does client area have a positive size on screen?
mov edx, [esi + WDATA.box.top]
add edx,21+5
mov ebx,[esi+WDATA.box.top]
add ebx,[esi+WDATA.box.height]
cmp edx,ebx
jg noinside2
jg .exit
 
; okay, let's draw it
mov eax,5
mov ebx,20
mov ecx,[esi+WDATA.box.width]
885,632 → 797,454
mov edx,[esi+WDATA.box.height]
sub ecx,4
sub edx,4
mov edi,[esi+WDATA.cl_workarea]
test edi,0x40000000
jnz noinside2
call [drawbar]
noinside2:
 
.exit:
popad
 
ret
 
 
 
; activate window
align 4
windowactivate:
 
; esi = abs mem position in stack 0xC400+
 
pushad
 
; if type of current active window is 3,
; it must be redrawn
mov eax, [TASK_COUNT]
movzx eax, word [WIN_POS + eax*2]
shl eax, 5
add eax, window_data
mov ebx, [eax + WDATA.cl_workarea]
and ebx, 0x0f000000
cmp ebx, 0x03000000
je .set_WDATA_fl_redraw ; for 3 and 4 style
cmp ebx, 0x04000000
je .set_WDATA_fl_redraw
jmp @f
.set_WDATA_fl_redraw:
mov [eax + WDATA.fl_redraw], byte 1
@@:
 
push esi
movzx eax, word [esi] ; ax <- process no
movzx eax, word [WIN_STACK+eax*2] ; ax <- position in window stack
 
xor esi, esi ; drop others
waloop:
cmp esi, dword [TASK_COUNT]
jae wacont
inc esi
lea edi, [WIN_STACK + esi*2]
mov bx, [edi] ; position of the current process
cmp bx, ax
jbe @f
dec bx ; upper? => drop!
mov [edi], bx
@@:
jmp waloop
wacont:
; set to no 1
pop esi ; esi = pointer at 0xC400
 
movzx eax, word [esi]
mov bx, [TASK_COUNT] ; number of processes
mov [WIN_STACK+eax*2], bx ; this is the last (and the upper)
 
; update on screen -window stack
xor esi, esi
waloop2:
mov edi, [TASK_COUNT]
cmp esi, edi
jae wacont2
inc esi
movzx ebx, word [esi*2 + WIN_STACK]
mov [ebx*2 + WIN_POS], si
jmp waloop2
wacont2:
mov [KEY_COUNT], byte 0 ; empty keyboard buffer
mov [BTN_COUNT], byte 0 ; empty button buffer
mov [MOUSE_SCROLL_H], word 0 ; zero mouse z-index
mov [MOUSE_SCROLL_V], word 0 ; zero mouse z-index
popad
ret
 
 
; check if window is necessary to draw
 
checkwindowdraw:
 
; edi = position in window_data+
 
mov eax, [edi + WDATA.cl_workarea]
and eax, 0x0f000000
cmp eax, 0x03000000
je .return_yes ; window type 3
cmp eax, 0x04000000
je .return_yes ; window type 4
 
mov esi, edi
sub esi, window_data
shr esi, 5
 
; esi = process number
 
movzx eax, word [WIN_STACK + esi * 2] ; get value of the curr process
lea esi, [WIN_POS + eax * 2] ; get address of this process at 0xC400
 
push esi
 
.new_check:
 
pop esi
add esi, 2
push esi
 
mov eax, [TASK_COUNT]
lea eax, word [WIN_POS + eax * 2] ; number of the upper window
 
cmp esi, eax
ja .all_wnds_to_top
 
movzx eax, word [esi]
shl eax, 5
cmp [CURRENT_TASK + eax + TASKDATA.state], byte 9
je .new_check ; skip dead windows
 
lea esi, [eax+window_data]
 
mov ebx, [edi+WDATA.box.top] ; y0
mov edx, [edi+WDATA.box.height]
add edx, ebx ; y0e
 
mov ecx, [esi+WDATA.box.top] ; y ; y check
cmp ecx, edx
jae .new_check ; y < y0e
mov eax, [esi+WDATA.box.height]
add ecx, eax ; ye
cmp ebx, ecx ; y0 >= ye
ja .new_check
 
mov eax, [edi+WDATA.box.left] ; x0
mov ecx, [edi+WDATA.box.width]
add ecx, eax ; x0e
 
mov edx, [esi+WDATA.box.left] ; x ; x check
cmp edx, ecx
jae .new_check ; x < x0e
mov ecx, [esi+WDATA.box.width]
add edx, ecx
cmp eax, edx
ja .new_check
 
pop esi
.return_yes:
mov ecx,1 ; overlap some window
ret
 
.all_wnds_to_top:
 
pop esi
 
xor ecx, ecx ; passed all windows to top
ret
 
 
 
 
waredraw: ; if redraw necessary at activate
 
pushad
 
call checkwindowdraw ; draw window on activation ?
;------------------------------------------------------------------------------
waredraw: ;////////////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Activate window, redrawing if necessary
;------------------------------------------------------------------------------
; is it overlapped by another window now?
push ecx
call window._.check_window_draw
test ecx, ecx
pop ecx
jz .do_not_draw
 
popad
mov [MOUSE_DOWN], byte 1 ; do draw mouse
call windowactivate
; yes it is, activate and update screen buffer
mov byte[MOUSE_DOWN], 1
call window._.window_activate
 
; update screen info
pushad
mov edi, [TASK_COUNT] ; the last process (number)
mov edi, [TASK_COUNT]
movzx esi, word [WIN_POS + edi * 2]
shl esi, 5
add esi, window_data
 
; coordinates of the upper window
mov eax, [esi + WDATA.box.left] ; cx
mov ebx, [esi + WDATA.box.top] ; cy
mov ecx, [esi + WDATA.box.width] ; sx
mov edx, [esi + WDATA.box.height] ; sy
mov eax, [esi + WDATA.box.left]
mov ebx, [esi + WDATA.box.top]
mov ecx, [esi + WDATA.box.width]
mov edx, [esi + WDATA.box.height]
 
add ecx, eax ; ecx = x_end
add edx, ebx ; edx = y_end
add ecx, eax
add edx, ebx
 
mov edi, [TASK_COUNT]
movzx esi, word [WIN_POS + edi * 2]
call setscreen
call window._.set_screen
popad
 
mov [edi + WDATA.fl_redraw], 1 ; redraw flag for app
mov [MOUSE_DOWN],byte 0 ; mouse down checks
 
; tell application to redraw itself
mov [edi + WDATA.fl_redraw], 1
mov byte[MOUSE_DOWN], 0
ret
 
.do_not_draw:
; no it's not, just activate the window
call window._.window_activate
mov byte[MOUSE_DOWN], 0
mov byte[MOUSE_BACKGROUND], 0
mov byte[DONT_DRAW_MOUSE], 0
ret
 
popad
align 4
;------------------------------------------------------------------------------
minimize_window: ;/////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = window number on screen
;------------------------------------------------------------------------------
;# corrupts [dl*]
;------------------------------------------------------------------------------
push edi
pushfd
cli
 
call windowactivate
mov [MOUSE_DOWN],byte 0 ; mouse down checks
mov [MOUSE_BACKGROUND],byte 0 ; no mouse background
mov [DONT_DRAW_MOUSE],byte 0 ; draw mouse
ret
; is it already minimized?
movzx edi, word[WIN_POS + eax * 2]
shl edi, 5
add edi, window_data
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
jnz .exit
 
push eax ebx ecx edx esi
 
; eax = window number on screen
; corrupts registers and [dl*]
minimize_window:
movzx eax, word [WIN_POS+eax*2]
shl eax, 5
add eax, window_data
test [eax+WDATA.fl_wstate], WSTATE_MINIMIZED
jnz .skip_redrawings
pushfd
cli
or [eax+WDATA.fl_wstate], WSTATE_MINIMIZED
mov edi, eax
;call calculatescreen
; no it's not, let's do that
or [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
mov eax, [edi+WDATA.box.left]
mov [dlx], eax
mov [draw_limits.left], eax
mov ecx, eax
add ecx, [edi+WDATA.box.width]
mov [dlxe], ecx
mov [draw_limits.right], ecx
mov ebx, [edi+WDATA.box.top]
mov [dly], ebx
mov [draw_limits.top], ebx
mov edx, ebx
add edx, [edi+WDATA.box.height]
mov [dlye], edx
mov [draw_limits.bottom], edx
call calculatescreen
xor esi, esi
xor eax, eax
call redrawscreen
 
pop esi edx ecx ebx eax
 
.exit:
popfd
.skip_redrawings:
pop edi
ret
 
; eax = window number on screen
; corrupts registers and [dl*]
restore_minimized_window:
align 4
;------------------------------------------------------------------------------
restore_minimized_window: ;////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> eax = window number on screen
;------------------------------------------------------------------------------
;# corrupts [dl*]
;------------------------------------------------------------------------------
pushad
pushfd
cli
 
; is it already restored?
movzx esi, word [WIN_POS+eax*2]
mov edi, esi
shl edi, 5
add edi, window_data
test [edi+WDATA.fl_wstate], WSTATE_MINIMIZED
jz .skip_redrawings
jz .exit
 
; no it's not, let's do that
mov [edi+WDATA.fl_redraw], 1
and [edi+WDATA.fl_wstate], not WSTATE_MINIMIZED
cmp eax, [TASK_COUNT] ; the uppermost window
jnz .no_uppermost
mov eax, [edi+WDATA.box.left]
mov ebp, window._.set_screen
cmp eax, [TASK_COUNT]
jz @f
mov ebp, calculatescreen
@@: mov eax, [edi + WDATA.box.left]
mov ebx, [edi+WDATA.box.top]
mov ecx, eax
mov edx, ebx
add ecx, [edi+WDATA.box.width]
add edx, [edi+WDATA.box.height]
call setscreen
jmp .done
.no_uppermost:
mov eax, [edi+WDATA.box.left]
mov ebx, [edi+WDATA.box.top]
mov ecx, eax
mov edx, ebx
add ecx, [edi+WDATA.box.width]
add edx, [edi+WDATA.box.height]
call calculatescreen
.done:
mov [MOUSE_BACKGROUND],byte 0 ; no mouse under
.skip_redrawings:
mov ecx, [edi + WDATA.box.width]
mov edx, [edi + WDATA.box.height]
add ecx, eax
add edx, ebx
call ebp
 
mov byte[MOUSE_BACKGROUND], 0
 
.exit:
popfd
popad
ret
 
 
;iglobal
; window_moving db 'K : Window - move/resize',13,10,0
; window_moved db 'K : Window - done',13,10,0
;endg
 
; check window touch
align 4
checkwindows:
;------------------------------------------------------------------------------
checkwindows: ;////////////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Check for user-initiated window operations
;------------------------------------------------------------------------------
pushad
 
; do we have window minimize/restore request?
cmp [window_minimize], 0
je .no_minimizing
mov eax, [TASK_COUNT] ; the uppermost window
je .check_for_mouse_buttons_state
 
; okay, minimize or restore top-most window and exit
mov eax, [TASK_COUNT]
mov bl, 0
xchg [window_minimize], bl
cmp bl, 1
jne .restore
dec bl
jnz @f
call minimize_window
jmp .continue
.restore:
call restore_minimized_window
.continue:
.no_minimizing:
jmp .check_for_mouse_buttons_state
@@: call restore_minimized_window
 
cmp [BTN_DOWN],byte 0 ; mouse buttons pressed ?
.check_for_mouse_buttons_state:
; do we have any mouse buttons pressed?
cmp byte[BTN_DOWN], 0
jne .mouse_buttons_pressed
;..................................... start 1/4 : modified by vhanla .................
 
mov [bPressedMouseXY_W],0
;..................................... end 1/4 : modified by vhanla ...................
popad
ret
jmp .exit
 
.mouse_buttons_pressed:
;..................................... start 2/4 : modified by vhanla .................
uglobal
bPressedMouseXY_W db 0x0
endg
;..................................... end 2/4 : modified by vhanla ...................
; yes we do, iterate and ...
mov esi,[TASK_COUNT]
inc esi
 
;..................................... start 3/4 : modified by vhanla .................
cmp [bPressedMouseXY_W],1
ja @f
ja .next_window
inc [bPressedMouseXY_W]
jnc @f
;mov ax,[MOUSE_X]
;mov [mx],ax
;mov ax,[MOUSE_Y]
;mov [my],ax
mov eax,dword[MOUSE_X]
mov dword[mx],eax
@@:
;..................................... end 3/4 : modified by vhanla ...................
jnc .next_window
push dword[MOUSE_X]
pop dword[mx]
 
cwloop:
.next_window:
cmp esi,2
jb .exit
 
dec esi
movzx edi, word [WIN_POS + esi * 2] ; ebx
 
; is that window not minimized?
movzx edi, word[WIN_POS + esi * 2]
shl edi, 5
add edi, window_data
; mov edi, ebx
test [edi + WDATA.fl_wstate], WSTATE_MINIMIZED
jnz .next_window
 
movzx eax, [mx]
movzx ebx, [my]
 
; is the cursor inside screen bounds of that window?
mov ecx, [edi + WDATA.box.left]
mov edx, [edi + WDATA.box.top]
 
mov eax,ecx
mov ebx,edx
test [edi+WDATA.fl_wstate],WSTATE_MINIMIZED
jnz cwloop
 
;..................................... start 4/4 : modified by vhanla .................
movzx eax, word [mx]; movzx eax,word[MOUSE_X]
movzx ebx, word [my]; movzx ebx,word[MOUSE_Y]
;..................................... endt 4/4 : modified by vhanla ..................
cmp ecx, eax
jae cwloop
cmp edx, ebx
jae cwloop
cmp eax, ecx
jl .next_window
cmp ebx, edx
jl .next_window
add ecx, [edi + WDATA.box.width]
add edx, [edi + WDATA.box.height]
cmp eax, ecx
jae cwloop
jge .next_window
cmp ebx, edx
jae cwloop
jge .next_window
 
pushad
mov eax, esi
mov ebx, [TASK_COUNT]
cmp eax, ebx ; is this window active?
jz .move_resize_window
; is that a top-most (which means active) window?
cmp esi, [TASK_COUNT]
je .check_for_moving_or_resizing
 
; no it's not, did we just press mouse button down above it or was it
; already pressed before?
cmp [bPressedMouseXY_W], 1
ja .exit_popa
ja .exit
 
; eax = position in windowing stack
; redraw must ?
; okay, we just pressed the button, activate this window and exit
lea esi, [WIN_POS + esi * 2]
call waredraw
.exit_popa:
add esp, 32
jmp .exit
 
.exit:
popad
ret
.check_for_moving_or_resizing:
; is that window movable?
test byte[edi + WDATA.cl_titlebar + 3], 0x01
jnz .exit
 
.move_resize_window: ; MOVE OR RESIZE WINDOW
popad
 
; Check for user enabled fixed window
mov edx, [edi + WDATA.cl_titlebar]
and edx, 0x0f000000
cmp edx, 0x01000000
jne .window_move_enabled_for_user
popad
ret
.window_move_enabled_for_user:
 
; yes it is, is it rolled up?
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
jnz .no_resize_2
jnz .check_for_cursor_on_caption
 
mov [do_resize_from_corner],byte 0 ; resize for skinned window
mov edx, [edi + WDATA.cl_workarea]
and edx, 0x0f000000
cmp edx, 0x00000000 ;{test for resized}
je .no_resize_2
cmp edx, 0x01000000 ;{test for resized}
je .no_resize_2
cmp edx, 0x04000000 ;{test for resized}
je .no_resize_2
; jb .no_resize_2 ; not type 2 wnd
; no it's not, can it be resized then?
mov [do_resize_from_corner], 0
mov dl, [edi + WDATA.fl_wstyle]
and dl, 0x0f
cmp dl, 0x00
je .check_for_cursor_on_caption
cmp dl, 0x01
je .check_for_cursor_on_caption
cmp dl, 0x04
je .check_for_cursor_on_caption
 
; are we going to resize it?
mov edx, [edi + WDATA.box.top]
add edx, [edi + WDATA.box.height]
sub edx, 6 ; edx = y_end - 6
cmp ebx, edx ; ebx = mouse_y
jb .no_resize_2
mov [do_resize_from_corner],byte 1
jmp .continue
.no_resize_2:
sub edx, 6
cmp ebx, edx
jl .check_for_cursor_on_caption
 
; yes we do, remember that
mov [do_resize_from_corner], 1
jmp .set_move_resize_flag
 
.check_for_cursor_on_caption:
; is the cursor inside window titlebar?
push eax
call get_titlebar_height
call window._.get_titlebar_height
add eax,[edi + WDATA.box.top]
cmp ebx,eax
pop eax
jae .exit
jge .exit
 
.continue:
 
; push esi
; mov esi, window_moving
; call sys_msg_board_str
; pop esi
 
mov ecx, [timer_ticks] ; double-click ?
; calculate duration between two clicks
mov ecx, [timer_ticks]
mov edx, ecx
sub edx, [latest_window_touch]
mov [latest_window_touch], ecx
mov [latest_window_touch_delta], edx
 
mov cl, [BTN_DOWN] ; save for shade check
.set_move_resize_flag:
mov cl, [BTN_DOWN]
mov [do_resize], cl
no_emulation_righ_button:
 
mov ecx, [edi + WDATA.box.left]
mov edx, [edi + WDATA.box.top]
 
push eax ecx edx
mov [dlx], ecx ; save for drawlimits
mov [dly], edx
mov eax, [edi + WDATA.box.width]
add ecx, eax
mov eax, [edi + WDATA.box.height]
add edx, eax
mov [dlxe], ecx
mov [dlye], edx
pop edx ecx eax
push ecx edx
mov [draw_limits.left], ecx
mov [draw_limits.top], edx
add ecx, [edi + WDATA.box.width]
add edx, [edi + WDATA.box.height]
mov [draw_limits.right], ecx
mov [draw_limits.bottom], edx
pop edx ecx
 
; calculate window-relative cursor coordinates
sub eax, ecx
sub ebx, edx
 
mov esi, [MOUSE_X]
mov [WIN_TEMP_XY], esi
push dword[MOUSE_X]
pop dword[WIN_TEMP_XY]
 
pushad ; wait for putimages to finish
; mov ebx,5
; call delay_hs
; save old window coordinates
push eax
mov eax,[edi + WDATA.box.left]
mov [npx],eax
mov [old_window_pos.left], eax
mov [new_window_pos.left], eax
mov eax,[edi + WDATA.box.top]
mov [npy],eax
popad
 
push eax ; save old coordinates
mov ax, word [edi + WDATA.box.left]
mov word [oldc+BOX.left],ax
mov ax, word [edi + WDATA.box.top]
mov word [oldc+BOX.top],ax
mov ax, word [edi + WDATA.box.width]
mov word [oldc+BOX.width],ax
mov word [npxe],ax
mov ax, word [edi + WDATA.box.height]
mov word [oldc+BOX.height],ax
mov word [npye],ax
mov [old_window_pos.top], eax
mov [new_window_pos.top], eax
mov eax, [edi + WDATA.box.width]
mov [old_window_pos.width], eax
mov [new_window_pos.width], eax
mov eax, [edi + WDATA.box.height]
mov [old_window_pos.height], eax
mov [new_window_pos.height], eax
pop eax
 
call drawwindowframes
; draw negative moving/sizing frame
call window._.draw_window_frames
 
mov [reposition],0
mov [MOUSE_DOWN],byte 1 ; no reaction to mouse up/down
mov byte[MOUSE_DOWN], 1
 
; move window
 
newchm:
 
mov [DONT_DRAW_MOUSE],byte 1
 
.next_mouse_state_check:
; process OS events
mov byte[DONT_DRAW_MOUSE], 1
call checkidle
 
call checkVga_N13
 
mov [MOUSE_BACKGROUND],byte 0
 
mov byte[MOUSE_BACKGROUND], 0
call [draw_pointer]
 
pushad
call stack_handler
popad
 
; did cursor position change?
mov esi,[WIN_TEMP_XY]
cmp esi,[MOUSE_X]
je cwb
je .check_for_new_mouse_buttons_state
 
mov cx,[MOUSE_X]
mov dx,[MOUSE_Y]
sub cx,ax
sub dx,bx
; yes it did, calculate window-relative cursor coordinates
movzx ecx, word[MOUSE_X]
movzx edx, word[MOUSE_Y]
sub ecx, eax
sub edx, ebx
 
push ax
push bx
push eax ebx
 
call drawwindowframes
; we're going to draw new frame, erasing the old one
call window._.draw_window_frames
 
mov ax,[Screen_Max_X]
mov bx,[Screen_Max_Y]
; are we moving it right now?
cmp [do_resize_from_corner], 0
jne .resize_window
 
cmp [do_resize_from_corner],1
je no_new_position
; yes we do, check if it's inside the screen area
mov eax, [Screen_Max_X]
mov ebx, [Screen_Max_Y]
 
mov word [npx],word 0 ; x repos ?
cmp ax,cx
jb noreposx
mov [new_window_pos.left], 0
or ecx, ecx
jle .check_for_new_vert_cursor_pos
mov [reposition],1
sub ax,word [npxe]
mov word [npx],ax
cmp ax,cx
jb noreposx
mov word [npx],cx
noreposx:
sub eax, [new_window_pos.width]
mov [new_window_pos.left], eax
cmp ecx, eax
jge .check_for_new_vert_cursor_pos
mov [new_window_pos.left], ecx
 
mov word [npy],word 0 ; y repos ?
cmp bx,dx
jb noreposy
.check_for_new_vert_cursor_pos:
mov [new_window_pos.top], 0
or edx, edx
jle .draw_new_window_frame
mov [reposition],1
sub bx,word [npye]
mov word [npy],bx
cmp bx,dx
jb noreposy
mov word [npy],dx
noreposy:
sub ebx, [new_window_pos.height]
mov [new_window_pos.top], ebx
cmp edx, ebx
jge .draw_new_window_frame
mov [new_window_pos.top], edx
jmp .draw_new_window_frame
 
no_new_position:
.resize_window:
push eax ebx edx
 
cmp [do_resize_from_corner],0 ; resize from right corner
je norepos_size
pushad
 
mov edx,edi
sub edx,window_data
;shr edx,5
;shl edx,8
;add edx,0x80000 ; process base at 0x80000+
lea edx, [SLOT_BASE + edx*8]
 
movzx eax,word [MOUSE_X]
cmp eax,[edi + WDATA.box.left]
jb nnepx
jb .fix_new_vert_size
sub eax,[edi + WDATA.box.left]
cmp eax,32 ; [edx+0x90+8]
jge nnepx2
mov eax,32 ; [edx+0x90+8]
nnepx2:
mov [npxe],eax
nnepx:
cmp eax, 32
jge @f
mov eax, 32
@@: mov [new_window_pos.width], eax
 
call get_rolledup_height
.fix_new_vert_size:
call window._.get_rolledup_height
mov ebx,eax
movzx eax,word [MOUSE_Y]
cmp eax,[edi + WDATA.box.top]
jb nnepy
jb .set_reposition_flag
sub eax,[edi + WDATA.box.top]
cmp eax,ebx ; [edx+0x90+12]
jge nnepy2
mov eax,ebx ; [edx+0x90+12]
nnepy2:
mov [npye],eax
nnepy:
cmp eax, ebx
jge @f
mov eax, ebx
@@: mov [new_window_pos.height], eax
 
.set_reposition_flag:
mov [reposition],1
 
popad
norepos_size:
pop edx ebx eax
 
pop bx
pop ax
call drawwindowframes
.draw_new_window_frame:
pop ebx eax
 
; draw new window moving/sizing frame
call window._.draw_window_frames
 
mov esi,[MOUSE_X]
mov [WIN_TEMP_XY],esi
 
cwb:
cmp [BTN_DOWN],byte 0
jne newchm
; new position done
mov [DONT_DRAW_MOUSE],byte 1
.check_for_new_mouse_buttons_state:
; did user release mouse button(s)?
cmp byte[BTN_DOWN], 0
jne .next_mouse_state_check
 
; yes he did, moving/sizing is over
mov byte[DONT_DRAW_MOUSE], 1
mov cl,0
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jnz @f
jnz .check_other_actions
 
mov cl,[reposition]
call drawwindowframes
 
mov eax,[npx]
; draw negative frame once again to hide it
call window._.draw_window_frames
 
; save new window bounds
mov eax, [new_window_pos.left]
mov [edi + WDATA.box.left],eax
mov eax,[npy]
mov eax, [new_window_pos.top]
mov [edi + WDATA.box.top],eax
mov eax,[npxe]
mov eax, [new_window_pos.width]
mov [edi + WDATA.box.width],eax
mov eax,[npye]
mov eax, [new_window_pos.height]
mov [edi + WDATA.box.height],eax
call set_window_clientbox
 
@@: mov [reposition],cl
 
cmp [reposition],1 ; save new position and size
jne no_bounds_save
cmp cl, 1
jne .check_other_actions
push esi edi ecx
mov esi,edi
mov ecx,2
1524,44 → 1258,48
cld
rep movsd
pop ecx edi esi
no_bounds_save:
 
pushad ; WINDOW SHADE/FULLSCREEN
.check_other_actions:
mov [reposition], cl
 
;{doule click not worked for 4 type window}
mov edx, [edi + WDATA.cl_workarea]
and edx, 0x0f000000
cmp edx, 0x00000000
je no_fullscreen_restore
cmp edx, 0x01000000
je no_fullscreen_restore
pushad
 
cmp [reposition],1
je no_window_sizing
mov dl, [edi + WDATA.fl_wstyle]
and dl, 0x0f
cmp dl, 0x00
je .check_if_window_fits_screen
cmp dl, 0x01
je .check_if_window_fits_screen
 
cmp cl, 1
je .no_window_sizing
mov edx,edi
sub edx,window_data
shr edx,5
shl edx,8
add edx,SLOT_BASE ; process base at 0x80000+
add edx, SLOT_BASE
 
cmp [do_resize],2 ; window shade ?
jne no_window_shade
; did we right-click on titlebar?
cmp [do_resize], 2
jne .check_maximization_request
 
; yes we did, toggle normal/rolled up window state
xor [edi + WDATA.fl_wstate], WSTATE_ROLLEDUP
mov [reposition],1
 
; calculate and set appropriate window height
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
jnz wnd_rolldown
wnd_rollup:
or [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
call get_rolledup_height
jmp @f
wnd_rolldown:
and [edi+WDATA.fl_wstate],not WSTATE_ROLLEDUP
mov eax,[edx + APPDATA.saved_box.height] ; 0x90+BOX.height
jz @f
call window._.get_rolledup_height
jmp .set_new_window_height
@@: mov eax, [edx + APPDATA.saved_box.height]
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jz @f
jz .set_new_window_height
mov eax,[screen_workarea.bottom]
sub eax,[screen_workarea.top]
@@: mov [edi+WDATA.box.height],eax
 
.set_new_window_height:
mov [edi + WDATA.box.height], eax
add eax, [edi+WDATA.box.top]
cmp eax, [Screen_Max_Y]
jbe @f
1571,23 → 1309,30
@@: call check_window_position
call set_window_clientbox
 
no_window_shade:
 
.check_maximization_request:
; can window change its height?
push edx
mov edx, [edi + WDATA.cl_workarea]
and edx, 0x0f000000
cmp edx, 0x04000000
mov dl, [edi + WDATA.fl_wstyle]
and dl, 0x0f
cmp dl, 0x04
pop edx
je no_fullscreen_restore
je .check_if_window_fits_screen
 
cmp [do_resize],1 ; fullscreen/restore ?
jne no_fullscreen_restore
cmp [latest_window_touch_delta],dword 50
jg no_fullscreen_restore
; was it really a maximize/restore request?
cmp [do_resize], 1
jne .check_if_window_fits_screen
cmp [do_resize_from_corner], 0
jne .check_if_window_fits_screen
cmp [latest_window_touch_delta], 50
jg .check_if_window_fits_screen
 
; yes is was, toggle normal/maximized window state
xor [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
mov [reposition],1
 
; calculate and set appropriate window bounds
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jnz restore_from_fullscreen
or [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jz .restore_normal_window_size
mov eax,[screen_workarea.left]
mov [edi+WDATA.box.left],eax
sub eax,[screen_workarea.right]
1596,16 → 1341,15
mov eax,[screen_workarea.top]
mov [edi+WDATA.box.top],eax
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
jnz @f
jnz .calculate_window_client_area
sub eax,[screen_workarea.bottom]
neg eax
mov [edi+WDATA.box.height],eax
@@:
jmp restore_from_fullscreen.clientbox
restore_from_fullscreen:
and [edi+WDATA.fl_wstate],not WSTATE_MAXIMIZED
jmp .calculate_window_client_area
 
.restore_normal_window_size:
push [edi+WDATA.box.height]
push edi ; restore
push edi
lea esi, [edx + APPDATA.saved_box]
mov ecx,4
cld
1613,22 → 1357,24
pop edi
pop eax
test [edi+WDATA.fl_wstate],WSTATE_ROLLEDUP
jz @f
jz .calculate_window_client_area
mov [edi+WDATA.box.height],eax
@@:
.clientbox:
 
.calculate_window_client_area:
call set_window_clientbox
 
no_fullscreen_restore:
 
mov eax,[edi+WDATA.box.top] ; check Y inside screen
.check_if_window_fits_screen:
; does window fit into screen area?
mov eax, [edi + WDATA.box.top]
add eax,[edi+WDATA.box.height]
cmp eax,[Screen_Max_Y]
jbe no_window_sizing
mov eax,[edi+WDATA.box.left] ; check X inside screen
jbe .no_window_sizing
mov eax, [edi + WDATA.box.left]
add eax,[edi+WDATA.box.width]
cmp eax,[Screen_Max_X]
jbe no_window_sizing
jbe .no_window_sizing
 
; no it doesn't, fix that
mov eax,[Screen_Max_X]
sub eax,[edi+WDATA.box.width]
mov [edi+WDATA.box.left],eax
1636,17 → 1382,19
sub eax,[edi+WDATA.box.height]
mov [edi+WDATA.box.top],eax
call set_window_clientbox
no_window_sizing:
 
.no_window_sizing:
popad
 
; did somethins actually change its place?
cmp [reposition],0
je retwm
je .reset_vars
 
mov [DONT_DRAW_MOUSE],byte 1 ; no mouse
mov byte[DONT_DRAW_MOUSE], 1
 
push eax ebx ecx edx
 
push eax ebx ecx edx
; recalculate screen buffer at new position
mov eax,[edi+WDATA.box.left]
mov ebx,[edi+WDATA.box.top]
mov ecx,[edi+WDATA.box.width]
1655,169 → 1403,444
add edx,ebx
call calculatescreen
 
mov eax,[oldc+BOX.left]
mov ebx,[oldc+BOX.top]
mov ecx,[oldc+BOX.width]
mov edx,[oldc+BOX.height]
; recalculate screen buffer at old position
mov eax, [old_window_pos.left]
mov ebx, [old_window_pos.top]
mov ecx, [old_window_pos.width]
mov edx, [old_window_pos.height]
add ecx,eax
add edx,ebx
call calculatescreen
 
pop edx ecx ebx eax
 
mov eax,edi
call redrawscreen
 
 
; tell window to redraw itself
mov [edi+WDATA.fl_redraw],1
 
mov ecx,100 ; wait to avoid mouse residuals
waitre2:
mov [DONT_DRAW_MOUSE],byte 1
; wait a bit for window to redraw itself
mov ecx, 100
 
.next_idle_cycle:
mov byte[DONT_DRAW_MOUSE], 1
call checkidle
cmp [edi+WDATA.fl_redraw],0
jz retwm
loop waitre2
jz .reset_vars
loop .next_idle_cycle
 
retwm:
.reset_vars:
mov byte[DONT_DRAW_MOUSE], 0 ; mouse pointer
mov byte[MOUSE_BACKGROUND], 0 ; no mouse under
mov byte[MOUSE_DOWN], 0 ; react to mouse up/down
 
mov [DONT_DRAW_MOUSE],byte 0 ; mouse pointer
mov [MOUSE_BACKGROUND],byte 0 ; no mouse under
mov [MOUSE_DOWN],byte 0 ; react to mouse up/down
.exit:
popad
ret
 
; mov esi,window_moved
; call sys_msg_board_str
;==============================================================================
;///// private functions //////////////////////////////////////////////////////
;==============================================================================
 
popad
align 4
;------------------------------------------------------------------------------
window._.get_titlebar_height: ;////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
mov al, [edi + WDATA.fl_wstyle]
and al, 0x0f
cmp al, 0x03
jne @f
mov eax, [_skinh]
ret
@@: mov eax, 21
ret
 
align 4
;------------------------------------------------------------------------------
window._.get_rolledup_height: ;////////////////////////////////////////////////
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
mov al, [edi + WDATA.fl_wstyle]
and al, 0x0f
cmp al, 0x03
jb @f
mov eax, [_skinh]
add eax, 3
ret
@@: or al, al
jnz @f
mov eax, 21
ret
@@: mov eax, 21 + 2
ret
 
align 4
;------------------------------------------------------------------------------
window._.set_screen: ;/////////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Reserve window area in screen buffer
;------------------------------------------------------------------------------
;> eax = left
;> ebx = top
;> ecx = right
;> edx = bottom
;> esi = process number
;------------------------------------------------------------------------------
virtual at esp
ff_x dd ?
ff_y dd ?
ff_width dd ?
ff_xsz dd ?
ff_ysz dd ?
ff_scale dd ?
end virtual
 
uglobal
add_window_data dd 0
do_resize_from_corner db 0x0
reposition db 0x0
latest_window_touch dd 0x0
latest_window_touch_delta dd 0x0
pushad
 
do_resize db 0x0
cmp esi, 1
jz .check_for_shaped_window
mov edi, esi
shl edi, 5
cmp [window_data + edi + WDATA.box.width], 0
jnz .check_for_shaped_window
cmp [window_data + edi + WDATA.box.height], 0
jz .exit
 
oldc dd 0x0,0x0,0x0,0x0
.check_for_shaped_window:
mov edi, esi
shl edi, 8
add edi, SLOT_BASE
cmp [edi + APPDATA.wnd_shape], 0
jne .shaped_window
 
dlx dd 0x0
dly dd 0x0
dlxe dd 0x0
dlye dd 0x0
; get x&y size
sub ecx, eax
sub edx, ebx
inc ecx
inc edx
 
npx dd 0x0
npy dd 0x0
npxe dd 0x0
npye dd 0x0
; get WinMap start
push esi
mov edi, [Screen_Max_X]
inc edi
mov esi, edi
imul edi, ebx
add edi, eax
add edi, [_WinMapAddress]
pop eax
mov ah, al
push ax
shl eax, 16
pop ax
 
mpx dd 0x0
mpy dd 0x0
endg
.next_line:
push ecx
shr ecx, 2
rep stosd
mov ecx, [esp]
and ecx, 3
rep stosb
pop ecx
add edi, esi
sub edi, ecx
dec edx
jnz .next_line
 
jmp .exit
 
; draw negative window frames
drawwindowframes2:
pushad
cli
jmp drawwindowframes.do
drawwindowframes:
pushad
cli
.shaped_window:
; for (y=0; y <= x_size; y++)
; for (x=0; x <= x_size; x++)
; if (shape[coord(x,y,scale)]==1)
; set_pixel(x, y, process_number);
 
test [edi+WDATA.fl_wstate],WSTATE_MAXIMIZED
jnz .ret
mov eax, [npx]
cmp eax, [edi+WDATA.box.left]
jnz .nowndframe
mov eax, [npxe]
cmp eax, [edi+WDATA.box.width]
jnz .nowndframe
mov eax, [npy]
cmp eax, [edi+WDATA.box.top]
jnz .nowndframe
mov eax, [npye]
cmp eax, [edi+WDATA.box.height]
jnz .nowndframe
xor [edi+WDATA.fl_wdrawn], 2
test [edi+WDATA.fl_wdrawn], 4
jnz .ret
sub ecx, eax
sub edx, ebx
inc ecx
inc edx
 
.nowndframe:
.do:
mov edi, 1
mov ecx, 0x01000000
mov eax,[npx]
shl eax,16
add eax,[npx]
add eax,[npxe]
add eax,65536*1-1
mov ebx,[npy]
shl ebx,16
add ebx,[npy]
call [draw_line]
push [edi + APPDATA.wnd_shape_scale] ; push scale first -> for loop
 
mov eax,[npx]
shl eax,16
add eax,[npx]
add eax,[npxe]
add eax,65536*1-1
mov ebx,[npy]
add ebx,[npye]
shl ebx,16
add ebx,[npy]
add ebx,[npye]
call [draw_line]
; get WinMap start -> ebp
push eax
mov eax, [Screen_Max_X] ; screen_sx
inc eax
imul eax, ebx
add eax, [esp]
add eax, [_WinMapAddress]
mov ebp, eax
 
mov eax,[npx]
shl eax,16
add eax,[npx]
mov ebx,[npy]
shl ebx,16
add ebx,[npy]
add ebx,[npye]
call [draw_line]
mov edi, [edi + APPDATA.wnd_shape]
pop eax
 
mov eax,[npx]
add eax,[npxe]
shl eax,16
add eax,[npx]
add eax,[npxe]
mov ebx,[npy]
shl ebx,16
add ebx,[npy]
add ebx,[npye]
call [draw_line]
; eax = x_start
; ebx = y_start
; ecx = x_size
; edx = y_size
; esi = process_number
; edi = &shape
; [scale]
push edx ecx ; for loop - x,y size
 
.ret:
sti
mov ecx, esi
shl ecx, 5
mov edx, [window_data + ecx + WDATA.box.top]
push [window_data + ecx + WDATA.box.width] ; for loop - width
mov ecx, [window_data + ecx + WDATA.box.left]
sub ebx, edx
sub eax, ecx
push ebx eax ; for loop - x,y
 
add [ff_xsz], eax
add [ff_ysz], ebx
 
mov ebx, [ff_y]
 
.ff_new_y:
mov edx, [ff_x]
 
.ff_new_x:
; -- body --
mov ecx, [ff_scale]
mov eax, [ff_width]
inc eax
shr eax, cl
push ebx edx
shr ebx, cl
shr edx, cl
imul eax, ebx
add eax, edx
pop edx ebx
add eax, edi
call .read_byte
test al,al
jz @f
mov eax, esi
mov [ebp], al
; -- end body --
@@: inc ebp
inc edx
cmp edx, [ff_xsz]
jb .ff_new_x
 
sub ebp, [ff_xsz]
add ebp, [ff_x]
add ebp, [Screen_Max_X] ; screen.x
inc ebp
inc ebx
cmp ebx, [ff_ysz]
jb .ff_new_y
 
add esp, 24
 
.exit:
popad
ret
 
.read_byte:
; eax - address
; esi - slot
push eax ecx edx esi
xchg eax, esi
lea ecx, [esp + 12]
mov edx, 1
call read_process_memory
pop esi edx ecx eax
ret
 
align 4
;------------------------------------------------------------------------------
window._.window_activate: ;////////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Activate window
;------------------------------------------------------------------------------
;> esi = pointer to WIN_POS+ window data
;------------------------------------------------------------------------------
push eax ebx
 
random_shaped_window:
; if type of current active window is 3 or 4, it must be redrawn
mov ebx, [TASK_COUNT]
movzx ebx, word[WIN_POS + ebx * 2]
shl ebx, 5
add eax, window_data
mov al, [window_data + ebx + WDATA.fl_wstyle]
and al, 0x0f
cmp al, 0x03
je .set_window_redraw_flag
cmp al, 0x04
jne .move_others_down
 
;
; eax = 0 giving address of data area
; ebx address
; eax = 1 shape area scale
; ebx 2^ebx scale
.set_window_redraw_flag:
mov [window_data + ebx + WDATA.fl_redraw], 1
 
test eax, eax
jne rsw_no_address
mov eax,[current_slot]
mov [eax+APPDATA.wnd_shape],ebx
rsw_no_address:
.move_others_down:
; ax <- process no
movzx ebx, word[esi]
; ax <- position in window stack
movzx ebx, word[WIN_STACK + ebx * 2]
 
cmp eax,1
jne rsw_no_scale
mov eax,[current_slot]
mov byte [eax+APPDATA.wnd_shape_scale], bl
rsw_no_scale:
; drop others
xor eax, eax
 
.next_stack_window:
cmp eax, [TASK_COUNT]
jae .move_self_up
inc eax
cmp [WIN_STACK + eax * 2], bx
jbe .next_stack_window
dec word[WIN_STACK + eax * 2]
jmp .next_stack_window
 
.move_self_up:
movzx ebx, word[esi]
; number of processes
mov ax, [TASK_COUNT]
; this is the last (and the upper)
mov [WIN_STACK + ebx * 2], ax
 
; update on screen - window stack
xor eax, eax
 
.next_window_pos:
cmp eax, [TASK_COUNT]
jae .reset_vars
inc eax
movzx ebx, word[WIN_STACK + eax * 2]
mov [WIN_POS + ebx * 2], ax
jmp .next_window_pos
 
.reset_vars:
mov byte[KEY_COUNT], 0
mov byte[BTN_COUNT], 0
mov word[MOUSE_SCROLL_H], 0
mov word[MOUSE_SCROLL_V], 0
 
pop ebx eax
ret
 
align 4
;------------------------------------------------------------------------------
window._.check_window_draw: ;//////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Check if window is necessary to draw
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
mov cl, [edi + WDATA.fl_wstyle]
and cl, 0x0f
cmp cl, 0x03
je .exit.redraw ; window type 3
cmp cl, 0x04
je .exit.redraw ; window type 4
 
push eax ebx edx esi
 
mov eax, edi
sub eax, window_data
shr eax, 5
 
; esi = process number
 
movzx eax, word[WIN_STACK + eax * 2] ; get value of the curr process
lea esi, [WIN_POS + eax * 2] ; get address of this process at 0xC400
 
.next_window:
add esi, 2
 
mov eax, [TASK_COUNT]
lea eax, word[WIN_POS + eax * 2] ; number of the upper window
 
cmp esi, eax
ja .exit.no_redraw
 
movzx edx, word[esi]
shl edx, 5
cmp [CURRENT_TASK + edx + TASKDATA.state], TSTATE_FREE
je .next_window
 
mov eax, [edi + WDATA.box.top]
mov ebx, [edi + WDATA.box.height]
add ebx, eax
 
mov ecx, [window_data + edx + WDATA.box.top]
cmp ecx, ebx
jge .next_window
add ecx, [window_data + edx + WDATA.box.height]
cmp eax, ecx
jge .next_window
 
mov eax, [edi + WDATA.box.left]
mov ebx, [edi + WDATA.box.width]
add ebx, eax
 
mov ecx, [window_data + edx + WDATA.box.left]
cmp ecx, ebx
jge .next_window
add ecx, [window_data + edx + WDATA.box.width]
cmp eax, ecx
jge .next_window
 
pop esi edx ebx eax
 
.exit.redraw:
xor ecx, ecx
inc ecx
ret
 
.exit.no_redraw:
pop esi edx ebx eax
xor ecx, ecx
ret
 
align 4
;------------------------------------------------------------------------------
window._.draw_window_frames: ;/////////////////////////////////////////////////
;------------------------------------------------------------------------------
;? Draw negative window frames
;------------------------------------------------------------------------------
;> edi = pointer to WDATA
;------------------------------------------------------------------------------
push eax
cli
 
test [edi + WDATA.fl_wstate], WSTATE_MAXIMIZED
jnz .exit
mov eax, [new_window_pos.left]
cmp eax, [edi + WDATA.box.left]
jnz .draw
mov eax, [new_window_pos.width]
cmp eax, [edi + WDATA.box.width]
jnz .draw
mov eax, [new_window_pos.top]
cmp eax, [edi + WDATA.box.top]
jnz .draw
mov eax, [new_window_pos.height]
cmp eax, [edi + WDATA.box.height]
jnz .draw
xor [edi + WDATA.fl_wdrawn], 2
 
.draw:
push ebx esi
mov eax, [new_window_pos.left - 2]
mov ax, word[new_window_pos.left]
add ax, word[new_window_pos.width]
mov ebx, [new_window_pos.top - 2]
mov bx, word[new_window_pos.top]
add bx, word[new_window_pos.height]
mov esi, 0x01000000
call draw_rectangle.forced
pop esi ebx
 
.exit:
sti
pop eax
ret
 
.forced:
push eax
cli
jmp .draw
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/hid/keyboard.inc
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/hid/mousedrv.inc
51,12 → 51,13
draw_mouse_under:
; return old picture
 
cmp [set_hw_cursor], 0
jz @F
cmp [_display.restore_cursor], 0
je @F
 
pushad
movzx eax,word [X_UNDER]
movzx ebx,word [Y_UNDER]
stdcall [hw_restore], eax, ebx
stdcall [_display.restore_cursor], eax, ebx
popad
ret
@@:
97,7 → 98,7
 
save_draw_mouse:
 
cmp [set_hw_cursor], 0
cmp [_display.move_cursor], 0
je .no_hw_cursor
pushad
 
111,8 → 112,8
mov ecx, [Screen_Max_X]
inc ecx
mul ecx
 
movzx edx, byte [display_data+ebx+eax]
add eax, [_WinMapAddress]
movzx edx, byte [ebx+eax]
shl edx, 8
mov esi, [edx+SLOT_BASE+APPDATA.cursor]
 
119,20 → 120,17
cmp esi, [current_cursor]
je .draw
 
; cmp [esi+CURSOR.magic], 'CURS'
; jne .fail
 
push esi
call [select_hw_cursor]
call [_display.select_cursor]
mov [current_cursor], esi
.draw:
stdcall [set_hw_cursor], esi
stdcall [_display.move_cursor], esi
popad
ret
.fail:
mov ecx, [def_cursor]
mov [edx+SLOT_BASE+APPDATA.cursor], ecx
stdcall [set_hw_cursor], ecx ; stdcall: [esp]=ebx,eax
stdcall [_display.move_cursor], ecx ; stdcall: [esp]=ebx,eax
popad
ret
 
292,7 → 290,7
inc ecx
imul ecx,ebx
add ecx,eax
add ecx, display_data
add ecx, [_WinMapAddress]
mov eax, [CURRENT_TASK]
movzx ebx, byte [ecx]
cmp eax,ebx
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/hid/set_dtc.inc
1,6 → 1,6
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;;
;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;
;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License ;;
;; ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
17,7 → 17,7
; ebx =3 - set alarm-clock ecx - 00SSMMHH
; out: 0 -Ok 1 -wrong format 2 -battery low
sys_settime:
mov ecx,eax
cli
mov al,0x0d
out 0x70,al
24,130 → 24,132
in al,0x71
bt ax,7
jnc bat_low
cmp ecx,2 ;day of week
cmp ebx,2 ;day of week
jne nosetweek
test ebx,ebx ;test day of week
test ecx,ecx ;test day of week
je wrongtime
cmp ebx,7
cmp ecx,7
ja wrongtime
mov dx,0x70
mov edx,0x70
call startstopclk
dec edx
mov al,6
out dx,al
inc edx
mov al,bl
mov al,cl
out dx,al
jmp endsettime
nosetweek: ;set date
cmp ecx,1
cmp ebx,1
jne nosetdate
cmp bl,0x99 ;test year
cmp cl,0x99 ;test year
ja wrongtime
shl ebx,4
cmp bl,0x90
shl ecx,4
cmp cl,0x90
ja wrongtime
cmp bh,0x99 ;test month
cmp ch,0x99 ;test month
ja wrongtime
shr ebx,4
test bh,bh
shr ecx,4
test ch,ch
je wrongtime
cmp bh,0x12
cmp ch,0x12
ja wrongtime
shl ebx,8
bswap ebx ;ebx=00YYMMDD
test bl,bl ;test day
shl ecx,8
bswap ecx ;ebx=00YYMMDD
test cl,cl ;test day
je wrongtime
shl ebx,4
cmp bl,0x90
shl ecx,4
cmp cl,0x90
ja wrongtime
shr ebx,4
cmp bh,2 ;February
shr ecx,4
cmp ch,2 ;February
jne testday
cmp bl,0x29
cmp cl,0x29
ja wrongtime
jmp setdate
testday:
cmp bh,8
cmp ch,8
jb testday1 ;Aug-Dec
bt bx,8
bt cx,8
jnc days31
jmp days30
testday1:
bt bx,8 ;Jan-Jul ex.Feb
bt cx,8 ;Jan-Jul ex.Feb
jnc days30
days31:
cmp bl,0x31
cmp cl,0x31
ja wrongtime
jmp setdate
days30:
cmp bl,0x30
cmp cl,0x30
ja wrongtime
setdate:
mov dx,0x70
mov edx,0x70
call startstopclk
dec edx
mov al,7 ;set days
out dx,al
inc edx
mov al,bl
mov al,cl
out dx,al
dec edx
mov al,8 ;set months
out dx,al
inc edx
mov al,bh
mov al,ch
out dx,al
dec edx
mov al,9 ;set years
out dx,al
inc edx
shr ebx,8
mov al,bh
shr ecx,8
mov al,ch
out dx,al
jmp endsettime
nosetdate: ;set time or alarm-clock
cmp ecx,3
cmp ebx,3
ja wrongtime
cmp bl,0x23
cmp cl,0x23
ja wrongtime
cmp bh,0x59
cmp ch,0x59
ja wrongtime
shl ebx,4
cmp bl,0x90
shl ecx,4
cmp cl,0x90
ja wrongtime
cmp bh,0x92
cmp ch,0x92
ja wrongtime
shl ebx,4
bswap ebx ;00HHMMSS
cmp bl,0x59
shl ecx,4
bswap ecx ;00HHMMSS
cmp cl,0x59
ja wrongtime
shl ebx,4
cmp bl,0x90
shl ecx,4
cmp cl,0x90
ja wrongtime
shr ebx,4
mov dx,0x70
shr ecx,4
 
mov edx,0x70
call startstopclk
dec edx
cmp ecx,3
cmp ebx,3
je setalarm
xor eax,eax ;al=0-set seconds
out dx,al
inc edx
mov al,bl
mov al,cl
out dx,al
dec edx
mov al,2 ;set minutes
out dx,al
inc edx
mov al,bh
mov al,ch
out dx,al
dec edx
mov al,4 ;set hours
out dx,al
inc edx
shr ebx,8
mov al,bh
shr ecx,8
mov al,ch
out dx,al
jmp endsettime
setalarm:
154,20 → 156,20
mov al,1 ;set seconds for al.
out dx,al
inc edx
mov al,bl
mov al,cl
out dx,al
dec edx
mov al,3 ;set minutes for al.
out dx,al
inc edx
mov al,bh
mov al,ch
out dx,al
dec edx
mov al,5 ;set hours for al.
out dx,al
inc edx
shr ebx,8
mov al,bh
shr ecx,8
mov al,ch
out dx,al
dec edx
mov al,0x0b ;enable irq's
180,15 → 182,15
dec edx
call startstopclk
sti
mov [esp+36],dword 0
and [esp+36-4],dword 0
ret
bat_low:
sti
mov [esp+36],dword 2
mov [esp+36-4],dword 2
ret
wrongtime:
sti
mov [esp+36],dword 1
mov [esp+36-4],dword 1
ret
 
startstopclk:
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/init.inc
114,9 → 114,9
mov edx, (OS_BASE/4096)
jmp .set
@@:
cmp edx, (HEAP_BASE+HEAP_MIN_SIZE)/4096
cmp edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096
jae .set
mov edx, (HEAP_BASE+HEAP_MIN_SIZE)/4096
mov edx, (HEAP_BASE-OS_BASE+HEAP_MIN_SIZE)/4096
.set:
mov [pg_data.kernel_pages-OS_BASE], edx
shr edx, 10
205,19 → 205,18
mov edi, [ebx]
shr edi, 12 ; edi = first page
mov eax, edi
neg eax
shr edi, 5
shl edi, 2
add edi, sys_pgmap-OS_BASE
and eax, 31
jz .startok
sub ecx, eax
add ecx, eax
sub ecx, 32
jbe .onedword
push ecx
mov ecx, eax
xor eax, eax
inc eax
or eax, -1
shl eax, cl
dec eax
or [edi], eax
add edi, 4
pop ecx
228,15 → 227,17
rep stosd
pop ecx
and ecx, 31
not eax
neg eax
shl eax, cl
dec eax
or [edi], eax
jmp .next
.onedword:
add ecx, eax
add ecx, 32
sub ecx, eax
@@:
dec eax
bts [edi], eax
inc eax
loop @b
.next:
add ebx, 20
/kernel/branches/net/kernel.asm
17,7 → 17,8
;; Sergey Semyonov (Serge)
;; Johnny_B
;; SPraid (simba)
;; hidnplayr
;; Hidnplayr
;; Alexey Teplov (<Lrz>)
;;
;; Data in this file was originally part of MenuetOS project which is
;; distributed under the terms of GNU GPL. It is modified and redistributed as
79,6 → 80,7
tss0 equ (tss0_l-gdts)
app_code equ (3+app_code_l-gdts)
app_data equ (3+app_data_l-gdts)
app_tls equ (3+tls_data_l-gdts)
pci_code_sel equ (pci_code_32-gdts)
pci_data_sel equ (pci_data_32-gdts)
 
117,7 → 119,7
org 0x0
jmp start_of_code
 
version db 'Kolibri OS version 0.7.5.0 ',13,10,13,10,0
version db 'Kolibri OS version 0.7.7.0+ ',13,10,13,10,0
 
include "boot/bootstr.inc" ; language-independent boot messages
include "boot/preboot.inc"
283,12 → 285,13
high_code:
mov ax,os_stack
mov bx,app_data
mov cx, app_tls
mov ss,ax
add esp, OS_BASE
 
mov ds,bx
mov es,bx
mov fs,bx
mov fs, cx
mov gs,bx
 
bt [cpu_caps], CAPS_PGE
346,14 → 349,20
; mov [0xF604],byte 1 ;al
mov al, [BOOT_VAR+0x901F] ; DMA access
mov [allow_dma_access], al
mov al,[BOOT_VAR+0x9000] ; bpp
movzx eax, byte [BOOT_VAR+0x9000] ; bpp
mov [ScreenBPP],al
 
mov [_display.bpp], eax
mov [_display.vrefresh], 60
mov [_display.disable_mouse], __sys_disable_mouse
 
movzx eax,word [BOOT_VAR+0x900A] ; X max
mov [_display.width], eax
dec eax
mov [Screen_Max_X],eax
mov [screen_workarea.right],eax
movzx eax,word [BOOT_VAR+0x900C] ; Y max
mov [_display.height], eax
dec eax
mov [Screen_Max_Y],eax
mov [screen_workarea.bottom],eax
366,9 → 375,14
je @f
cmp [SCR_MODE],word 0x12 ; VGA 640x480
je @f
mov ax,[BOOT_VAR+0x9001] ; for other modes
movzx eax, word[BOOT_VAR+0x9001] ; for other modes
mov [BytesPerScanLine],ax
mov [_display.pitch], eax
@@:
mov eax, [_display.width]
mul [_display.height]
mov [_WinMapSize], eax
 
mov esi, BOOT_VAR+0x9080
movzx ecx, byte [esi-1]
mov [NumBiosDisks], ecx
377,7 → 391,7
 
; GRAPHICS ADDRESSES
 
mov byte [BOOT_VAR+0x901e],0x0
and byte [BOOT_VAR+0x901e],0x0
mov eax,[BOOT_VAR+0x9018]
mov [LFBAddress],eax
 
451,6 → 465,16
wrmsr
.noSYSCALL:
; -----------------------------------------
stdcall alloc_page
stdcall map_page, tss-0xF80, eax, PG_SW
stdcall alloc_page
inc eax
mov [SLOT_BASE+256+APPDATA.io_map], eax
stdcall map_page, tss+0x80, eax, PG_SW
stdcall alloc_page
inc eax
mov dword [SLOT_BASE+256+APPDATA.io_map+4], eax
stdcall map_page, tss+0x1080, eax, PG_SW
 
; LOAD IDT
 
538,14 → 562,18
mov [graph_data_l+4],al
mov [graph_data_l+7],ah
 
mov [CURRENT_TASK],dword 1
mov [TASK_COUNT],dword 1
stdcall kernel_alloc, [_WinMapSize]
mov [_WinMapAddress], eax
 
xor eax,eax
inc eax
mov [CURRENT_TASK],eax ;dword 1
mov [TASK_COUNT],eax ;dword 1
mov [TASK_BASE],dword TASK_DATA
mov [current_slot], SLOT_BASE+256
 
; set background
xor eax,eax
inc eax
 
mov [BgrDrawMode],eax
mov [BgrDataWidth],eax
mov [BgrDataHeight],eax
601,6 → 629,7
include 'vmodeld.inc'
;!!!!!!!!!!!!!!!!!!!!!!!
 
if 0
mov ax,[OS_BASE+0x10000+bx_from_load]
cmp ax,'r1' ; if using not ram disk, then load librares and parameters {SPraid.simba}
je no_lib_load
609,6 → 638,7
call load_file_parse_table ; prepare file parse table
call set_kernel_conf ; configure devices and gui
no_lib_load:
end if
 
; LOAD FONTS I and II
 
628,8 → 658,9
mov edx, 0xFFFFFF
mov ebx, [MEM_AMOUNT]
shr ebx, 20
mov edi, 1
xor edi,edi
mov eax, 0x00040000
inc edi
call display_number_force
 
; BUILD SCHEDULER
646,7 → 677,7
 
mov esi,boot_windefs
call boot_log
call setwindowdefaults
call set_window_defaults
 
; SET BACKGROUND DEFAULTS
 
686,10 → 717,7
add edi, 0x2000-512
mov dword [SLOT_BASE+256+APPDATA.fpu_state], edi
mov dword [SLOT_BASE+256+APPDATA.saved_esp0], edi ; just for case
mov dword [SLOT_BASE+256+APPDATA.io_map],\
(tss._io_map_0-OS_BASE+PG_MAP)
mov dword [SLOT_BASE+256+APPDATA.io_map+4],\
(tss._io_map_1-OS_BASE+PG_MAP)
; [SLOT_BASE+256+APPDATA.io_map] was set earlier
 
mov esi, fpu_data
mov ecx, 512/4
704,17 → 732,19
mov dword [SLOT_BASE+256+APPDATA.bk_obj], ebx
 
mov dword [SLOT_BASE+256+APPDATA.cur_dir], sysdir_path
mov dword [SLOT_BASE+256+APPDATA.tls_base], eax
 
; task list
mov [CURRENT_TASK],dword 1
mov [TASK_COUNT],dword 1
mov dword [TASK_DATA+TASKDATA.mem_start],eax ; process base address
inc eax
mov dword [CURRENT_TASK],eax
mov dword [TASK_COUNT],eax
mov [current_slot], SLOT_BASE+256
mov [TASK_BASE],dword TASK_DATA
mov [TASK_DATA+TASKDATA.wnd_number], 1 ; on screen number
mov [TASK_DATA+TASKDATA.pid], 1 ; process id number
mov [TASK_DATA+TASKDATA.mem_start], 0 ; process base address
mov byte[TASK_DATA+TASKDATA.wnd_number],al ; on screen number
mov dword [TASK_DATA+TASKDATA.pid], eax ; process id number
 
call init_cursors
call init_display
mov eax, [def_cursor]
mov [SLOT_BASE+APPDATA.cursor],eax
mov [SLOT_BASE+APPDATA.cursor+256],eax
750,8 → 780,9
movzx ecx, word [boot_y]
add ecx, (10+17*6) shl 16 - 10 ; 'CPU frequency is '
mov edx, 0xFFFFFF
mov edi, 1
xor edi,edi
mov eax, 0x00040000
inc edi
call display_number_force
 
; SET VARIABLES
797,16 → 828,15
;protect io permission map
 
mov esi, [default_io_map]
stdcall map_page,esi,(tss._io_map_0-OS_BASE), PG_MAP
stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map], PG_MAP
add esi, 0x1000
stdcall map_page,esi,(tss._io_map_1-OS_BASE), PG_MAP
stdcall map_page,esi,[SLOT_BASE+256+APPDATA.io_map+4], PG_MAP
 
stdcall map_page,tss._io_map_0,\
(tss._io_map_0-OS_BASE), PG_MAP
[SLOT_BASE+256+APPDATA.io_map], PG_MAP
stdcall map_page,tss._io_map_1,\
(tss._io_map_1-OS_BASE), PG_MAP
[SLOT_BASE+256+APPDATA.io_map+4], PG_MAP
 
 
; LOAD FIRST APPLICATION
cli
 
816,8 → 846,9
mov ebp, vrr_m
call fs_execute_from_sysdir
 
cmp eax,2 ; if vrr_m app found (PID=2)
je first_app_found
; cmp eax,2 ; if vrr_m app found (PID=2)
sub eax,2
jz first_app_found
 
no_load_vrr_m:
 
824,8 → 855,9
mov ebp, firstapp
call fs_execute_from_sysdir
 
cmp eax,2 ; continue if a process has been loaded
je first_app_found
; cmp eax,2 ; continue if a process has been loaded
sub eax,2
jz first_app_found
 
mov esi, boot_failed
call boot_log
838,7 → 870,8
cli
 
;mov [TASK_COUNT],dword 2
mov [CURRENT_TASK],dword 1 ; set OS task fisrt
push 1
pop dword [CURRENT_TASK] ; set OS task fisrt
 
; SET KEYBOARD PARAMETERS
mov al, 0xf6 ; reset keyboard, scan enabled
969,8 → 1002,9
mov bx,word [boot_y]
add [boot_y],dword 10
mov ecx,0x80ffffff ; ASCIIZ string with white color
xor edi,edi
mov edx,esi
mov edi,1
inc edi
call dtext
 
mov [novesachecksum],1000
980,7 → 1014,6
 
ret
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; ;
; MAIN OS LOOP START ;
989,7 → 1022,7
align 32
osloop:
call [draw_pointer]
call checkbuttons
call check_buttons
call checkwindows
; call check_window_move_request
call checkmisc
1055,51 → 1088,52
 
reserve_irqs_ports:
 
pushad
 
mov [irq_owner+4*0], 1 ; timer
push eax
xor eax,eax
inc eax
mov byte [irq_owner+4*0],al ;1 ; timer
;mov [irq_owner+4*1], 1 ; keyboard
mov [irq_owner+4*6], 1 ; floppy diskette
mov [irq_owner+4*13], 1 ; math co-pros
mov [irq_owner+4*14], 1 ; ide I
mov [irq_owner+4*15], 1 ; ide II
mov byte [irq_owner+4*6],al ;1 ; floppy diskette
mov byte [irq_owner+4*13],al ;1 ; math co-pros
mov byte [irq_owner+4*14],al ;1 ; ide I
mov byte [irq_owner+4*15],al ;1 ; ide II
pop eax
 
; RESERVE PORTS
mov edi,1 ; 0x00-0x2d
mov [RESERVED_PORTS],edi
shl edi,4
mov [RESERVED_PORTS+edi+0],dword 1
mov [RESERVED_PORTS+edi+4],dword 0x0
mov [RESERVED_PORTS+edi+8],dword 0x2d
push 4
pop dword [RESERVED_PORTS] ;,edi
 
inc dword [RESERVED_PORTS] ; 0x30-0x4d
mov edi,[RESERVED_PORTS]
shl edi,4
mov [RESERVED_PORTS+edi+0],dword 1
mov [RESERVED_PORTS+edi+4],dword 0x30
mov [RESERVED_PORTS+edi+8],dword 0x4d
push 1
pop dword [RESERVED_PORTS+16+0] ;,dword 1
and dword [RESERVED_PORTS+16+4],0 ;,dword 0x0
mov dword [RESERVED_PORTS+16+8],0x2d ;,dword 0x2d
 
inc dword [RESERVED_PORTS] ; 0x50-0xdf
mov edi,[RESERVED_PORTS]
shl edi,4
mov [RESERVED_PORTS+edi+0],dword 1
mov [RESERVED_PORTS+edi+4],dword 0x50
mov [RESERVED_PORTS+edi+8],dword 0xdf
push 1
pop dword [RESERVED_PORTS+32+0] ;,dword 1
push 0x30
pop dword [RESERVED_PORTS+32+4] ;,dword 0x30
push 0x4d
pop dword [RESERVED_PORTS+32+8] ;,dword 0x4d
 
inc dword [RESERVED_PORTS] ; 0xe5-0xff
mov edi,[RESERVED_PORTS]
shl edi,4
mov [RESERVED_PORTS+edi+0],dword 1
mov [RESERVED_PORTS+edi+4],dword 0xe5
mov [RESERVED_PORTS+edi+8],dword 0xff
push 1
pop dword [RESERVED_PORTS+48+0] ;,dword 1
push 0x50
pop dword [RESERVED_PORTS+48+4] ;,dword 0x50
mov dword [RESERVED_PORTS+48+8],0xdf ;,dword 0xdf
 
popad
push 1
pop dword [RESERVED_PORTS+64+0] ;,dword 1
 
mov dword [RESERVED_PORTS+64+4],0xe5 ;,dword 0xe5
mov dword [RESERVED_PORTS+64+8],0xff ;,dword 0xff
 
ret
 
setirqreadports:
 
mov [irq12read+0],dword 0x60 + 0x01000000 ; read port 0x60 , byte
mov [irq12read+4],dword 0 ; end of port list
and dword [irq12read+4],0 ; end of port list
; mov [irq12read+4],dword 0 ; end of port list
;mov [irq04read+0],dword 0x3f8 + 0x01000000 ; read port 0x3f8 , byte
;mov [irq04read+4],dword 0 ; end of port list
;mov [irq03read+0],dword 0x2f8 + 0x01000000 ; read port 0x2f8 , byte
1116,12 → 1150,8
mov ecx,0x100 ; flush port 0x60
.fl60: in al,0x60
loop .fl60
mov [MOUSE_BUFF_COUNT],byte 0 ; mouse buffer
mov [KEY_COUNT],byte 0 ; keyboard buffer
mov [BTN_COUNT],byte 0 ; button buffer
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y
push eax
 
push eax
mov ax,[BOOT_VAR+0x900c]
shr ax,1
shl eax,16
1128,87 → 1158,86
mov ax,[BOOT_VAR+0x900A]
shr ax,1
mov [MOUSE_X],eax
pop eax
 
xor eax,eax
mov [BTN_ADDR],dword BUTTON_INFO ; address of button list
 
mov byte [MOUSE_BUFF_COUNT],al ; mouse buffer
mov byte [KEY_COUNT],al ; keyboard buffer
mov byte [BTN_COUNT],al ; button buffer
; mov [MOUSE_X],dword 100*65536+100 ; mouse x/y
 
;!! IP 04.02.2005:
mov byte [DONT_SWITCH], 0 ; change task if possible
 
ret
 
;* mouse centered - start code- Mario79
mouse_centered:
push eax
mov eax,[Screen_Max_X]
shr eax,1
mov [MOUSE_X],ax
mov eax,[Screen_Max_Y]
shr eax,1
mov [MOUSE_Y],ax
mov byte [DONT_SWITCH],al ; change task if possible
pop eax
ret
;* mouse centered - end code- Mario79
 
align 4
 
;input eax=43,bl-byte of output, ecx - number of port
sys_outport:
 
mov edi,ebx ; separate flag for read / write
and ebx,65535
mov edi,ecx ; separate flag for read / write
and ecx,65535
 
mov ecx,[RESERVED_PORTS]
test ecx,ecx
jne sopl8
mov [esp+36],dword 1
mov eax,[RESERVED_PORTS]
test eax,eax
jnz .sopl8
inc eax
mov [esp+32],eax
ret
 
sopl8:
.sopl8:
mov edx,[TASK_BASE]
mov edx,[edx+0x4]
and ebx,65535
cld
sopl1:
;and ecx,65535
;cld - set on interrupt 0x40
.sopl1:
 
mov esi,ecx
mov esi,eax
shl esi,4
add esi,RESERVED_PORTS
cmp edx,[esi+0]
jne sopl2
cmp ebx,[esi+4]
jb sopl2
cmp ebx,[esi+8]
jg sopl2
jmp sopl3
jne .sopl2
cmp ecx,[esi+4]
jb .sopl2
cmp ecx,[esi+8]
jg .sopl2
.sopl3:
 
sopl2:
test edi,0x80000000 ; read ?
jnz .sopl4
 
dec ecx
jnz sopl1
mov [esp+36],dword 1
mov eax,ebx
mov dx,cx ; write
out dx,al
and [esp+32],dword 0
ret
 
sopl3:
.sopl2:
 
test edi,0x80000000 ; read ?
jnz sopl4
 
mov dx,bx ; write
out dx,al
mov [esp+36],dword 0
dec eax
jnz .sopl1
inc eax
mov [esp+32],eax
ret
 
sopl4:
 
mov dx,bx ; read
.sopl4:
 
mov dx,cx ; read
in al,dx
and eax,0xff
mov [esp+36],dword 0
mov [esp+24],eax
and [esp+32],dword 0
mov [esp+20],eax
ret
 
display_number:
 
;It is not optimization
mov eax, ebx
mov ebx, ecx
mov ecx, edx
mov edx, esi
mov esi, edi
; eax = print type, al=0 -> ebx is number
; al=1 -> ebx is pointer
; ah=0 -> display decimal
1248,8 → 1277,8
displnl1:
sub esp,64
 
cmp ah,0 ; DECIMAL
jne no_display_desnum
test ah,ah ; DECIMAL
jnz no_display_desnum
shr eax,16
and eax,0xC03f
; and eax,0x3f
1406,18 → 1435,20
; 12 = enable pci access
 
 
mov [esp+36],dword 0
cmp eax,1 ; MIDI
and [esp+32],dword 0
dec ebx ; MIDI
jnz nsyse1
cmp ebx,0x100
cmp ecx,0x100
 
jb nsyse1
mov edx,65535
cmp edx,ebx
mov esi,65535
cmp esi,ecx
 
jb nsyse1
mov [midi_base],bx
mov word [mididp],bx
inc bx
mov word [midisp],bx
mov [midi_base],cx ;bx
mov word [mididp],cx ;bx
inc cx ;bx
mov word [midisp],cx ;bx
ret
 
iglobal
1425,70 → 1456,69
endg
 
nsyse1:
dec ebx ; KEYBOARD
jnz nsyse2
mov edi,[TASK_BASE]
mov eax,[edi+TASKDATA.mem_start]
add eax,edx
 
cmp eax,2 ; KEYBOARD
jnz nsyse2
cmp ebx,1
dec ecx
jnz kbnobase
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov eax,ecx
mov ebx,keymap
mov ecx,128
call memmove
ret
kbnobase:
cmp ebx,2
dec ecx
jnz kbnoshift
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov eax,ecx
 
mov ebx,keymap_shift
mov ecx,128
call memmove
ret
kbnoshift:
cmp ebx,3
jne kbnoalt
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov eax,ecx
dec ecx
jnz kbnoalt
mov ebx,keymap_alt
mov ecx,128
call memmove
ret
kbnoalt:
cmp ebx,9
sub ecx,6
jnz kbnocountry
mov word [keyboard],cx
mov word [keyboard],dx
ret
kbnocountry:
mov [esp+36],dword 1
mov [esp+32],dword 1
ret
nsyse2:
cmp eax,3 ; CD
dec ebx ; CD
jnz nsyse4
test ebx,ebx
 
test ecx,ecx
jz nosesl
cmp ebx, 4
 
cmp ecx, 4
ja nosesl
mov [cd_base],bl
cmp ebx,1
mov [cd_base],cl
 
dec ecx
jnz noprma
mov [cdbase],0x1f0
mov [cdid],0xa0
noprma:
cmp ebx,2
 
dec ecx
jnz noprsl
mov [cdbase],0x1f0
mov [cdid],0xb0
noprsl:
cmp ebx,3
dec ecx
jnz nosema
mov [cdbase],0x170
mov [cdid],0xa0
nosema:
cmp ebx,4
dec ecx
jnz nosesl
mov [cdbase],0x170
mov [cdid],0xb0
1495,55 → 1525,63
nosesl:
ret
 
iglobal
cd_base db 0
 
endg
nsyse4:
 
cmp eax,5 ; SYSTEM LANGUAGE
sub ebx,2 ; SYSTEM LANGUAGE
jnz nsyse5
mov [syslang],ebx
mov [syslang],ecx
ret
nsyse5:
 
cmp eax,7 ; HD BASE
jne nsyse7
test ebx,ebx
sub ebx,2 ; HD BASE
jnz nsyse7
 
test ecx,ecx
jz nosethd
cmp ebx,4
 
cmp ecx,4
ja nosethd
mov [hd_base],bl
cmp ebx,1
mov [hd_base],cl
 
cmp ecx,1
jnz noprmahd
mov [hdbase],0x1f0
mov [hdid],0x0
mov [hdpos],1
and dword [hdid],0x0
mov dword [hdpos],ecx
; call set_FAT32_variables
noprmahd:
cmp ebx,2
 
cmp ecx,2
jnz noprslhd
mov [hdbase],0x1f0
mov [hdid],0x10
mov [hdpos],2
mov dword [hdpos],ecx
; call set_FAT32_variables
noprslhd:
cmp ebx,3
 
cmp ecx,3
jnz nosemahd
mov [hdbase],0x170
mov [hdid],0x0
mov [hdpos],3
and dword [hdid],0x0
mov dword [hdpos],ecx
; call set_FAT32_variables
nosemahd:
cmp ebx,4
 
cmp ecx,4
jnz noseslhd
mov [hdbase],0x170
mov [hdid],0x10
mov [hdpos],4
mov dword [hdpos],ecx
; call set_FAT32_variables
noseslhd:
call reserve_hd1
call reserve_hd_channel
call free_hd_channel
mov [hd1_status],0 ; free
and dword [hd1_status],0 ; free
nosethd:
ret
 
1553,31 → 1591,33
 
nsyse7:
 
cmp eax,8 ; HD PARTITION
jne nsyse8
mov [fat32part],ebx
; cmp eax,8 ; HD PARTITION
dec ebx
jnz nsyse8
mov [fat32part],ecx
; call set_FAT32_variables
call reserve_hd1
call reserve_hd_channel
call free_hd_channel
pusha
; pusha
call choice_necessity_partition_1
popa
mov [hd1_status],0 ; free
; popa
and dword [hd1_status],0 ; free
ret
 
nsyse8:
cmp eax,11 ; ENABLE LBA READ
jne no_set_lba_read
and ebx,1
mov [lba_read_enabled],ebx
; cmp eax,11 ; ENABLE LBA READ
and ecx,1
sub ebx,3
jnz no_set_lba_read
mov [lba_read_enabled],ecx
ret
 
no_set_lba_read:
cmp eax,12 ; ENABLE PCI ACCESS
jne no_set_pci_access
and ebx,1
mov [pci_access_enabled],ebx
; cmp eax,12 ; ENABLE PCI ACCESS
dec ebx
jnz no_set_pci_access
mov [pci_access_enabled],ecx
ret
no_set_pci_access:
 
1586,7 → 1626,7
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
sys_setup_err:
mov [esp+36],dword -1
or [esp+32],dword -1
ret
 
align 4
1601,97 → 1641,109
; 8=fat32 partition in hd
; 9=get hs timer tic
 
cmp eax,1
jne ngsyse1
; cmp eax,1
dec ebx
jnz ngsyse1
movzx eax,[midi_base]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse1:
; cmp eax,2
dec ebx
jnz ngsyse2
 
cmp eax,2
jne ngsyse2
cmp ebx,1
mov edi,[TASK_BASE]
mov ebx,[edi+TASKDATA.mem_start]
add ebx,edx
 
; cmp ebx,1
dec ecx
jnz kbnobaseret
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov ebx,ecx
mov eax,keymap
mov ecx,128
call memmove
ret
kbnobaseret:
cmp ebx,2
; cmp ebx,2
dec ecx
jnz kbnoshiftret
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov ebx,ecx
 
mov eax,keymap_shift
mov ecx,128
call memmove
ret
kbnoshiftret:
cmp ebx,3
; cmp ebx,3
dec ecx
jne kbnoaltret
mov edi,[TASK_BASE]
add ecx,[edi+TASKDATA.mem_start]
mov ebx,ecx
 
mov eax,keymap_alt
mov ecx,128
call memmove
ret
kbnoaltret:
cmp ebx,9
; cmp ebx,9
sub ecx,6
jnz ngsyse2
movzx eax,word [keyboard]
mov [esp+36],eax
mov [esp+32],eax
ret
 
 
ngsyse2:
 
cmp eax,3
; cmp eax,3
dec ebx
jnz ngsyse3
movzx eax,[cd_base]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse3:
cmp eax,5
; cmp eax,5
sub ebx,2
jnz ngsyse5
mov eax,[syslang]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse5:
cmp eax,7
; cmp eax,7
sub ebx,2
jnz ngsyse7
movzx eax,[hd_base]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse7:
cmp eax,8
; cmp eax,8
dec ebx
jnz ngsyse8
mov eax,[fat32part]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse8:
cmp eax,9
jne ngsyse9
; cmp eax,9
dec ebx
jnz ngsyse9
mov eax,[timer_ticks] ;[0xfdf0]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse9:
cmp eax,11
; cmp eax,11
sub ebx,2
jnz ngsyse11
mov eax,[lba_read_enabled]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse11:
cmp eax,12
; cmp eax,12
dec ebx
jnz ngsyse12
mov eax,[pci_access_enabled]
mov [esp+36],eax
mov [esp+32],eax
ret
ngsyse12:
mov [esp+36],dword 1
mov [esp+32],dword 1
ret
 
get_timer_ticks:
mov eax,[timer_ticks]
ret
1716,14 → 1768,14
; eax=6 delete cursor ; reserved
; eax=7 get mouse_z
 
cmp eax, 7
cmp ebx, 7
ja msset
jmp [mousefn+eax*4]
jmp [mousefn+ebx*4]
msscreen:
mov eax,[MOUSE_X]
shl eax,16
mov ax,[MOUSE_Y]
mov [esp+36],eax
mov [esp+36-4],eax
ret
mswin:
mov eax,[MOUSE_X]
1741,11 → 1793,11
rol eax,16
sub ax,word[edi+SLOT_BASE+APPDATA.wnd_clientbox.left]
rol eax,16
mov [esp+36],eax
mov [esp+36-4],eax
ret
msbutton:
movzx eax,byte [BTN_DOWN]
mov [esp+36],eax
mov [esp+36-4],eax
ret
msz:
mov edi, [TASK_COUNT]
1755,32 → 1807,31
mov ax,[MOUSE_SCROLL_H]
shl eax,16
mov ax,[MOUSE_SCROLL_V]
mov [esp+36],eax
mov [MOUSE_SCROLL_H],word 0
mov [MOUSE_SCROLL_V],word 0
mov [esp+36-4],eax
and [MOUSE_SCROLL_H],word 0
and [MOUSE_SCROLL_V],word 0
ret
@@:
mov [esp+36],dword 0
ret
and [esp+36-4],dword 0
; ret
msset:
ret
 
app_load_cursor:
; add ebx, new_app_base
cmp ebx, OS_BASE
cmp ecx, OS_BASE
jae msset
stdcall load_cursor, ebx, ecx
mov [esp+36], eax
stdcall load_cursor, ecx, edx
mov [esp+36-4], eax
ret
 
app_set_cursor:
stdcall set_cursor, ebx
mov [esp+36], eax
stdcall set_cursor, ecx
mov [esp+36-4], eax
ret
 
app_delete_cursor:
stdcall delete_cursor, ebx
mov [esp+36], eax
stdcall delete_cursor, ecx
mov [esp+36-4], eax
ret
 
is_input:
1820,11 → 1871,22
ret
 
 
setuart:
 
align 4
 
sys_midi:
cmp [mididp],0
jnz sm0
mov [esp+36],dword 1
ret
sm0:
and [esp+36],dword 0
dec ebx
jnz smn1
; call setuart
su1:
call is_output
cmp al,0
test al,al
jnz su1
mov dx,word [midisp]
mov al,0xff
1834,7 → 1896,7
mov al,0xff
out dx,al
call is_input
cmp al,0
test al,al
jnz su2
call get_mpu_in
cmp al,0xfe
1841,33 → 1903,14
jnz su2
su3:
call is_output
cmp al,0
test al,al
jnz su3
mov dx,word [midisp]
mov al,0x3f
out dx,al
 
ret
 
 
align 4
 
sys_midi:
 
cmp [mididp],0
jnz sm0
mov [esp+36],dword 1
ret
sm0:
 
cmp eax,1
mov [esp+36],dword 0
jnz smn1
call setuart
ret
smn1:
 
cmp eax,2
dec ebx
jnz smn2
sm10:
call get_mpu_in
1876,12 → 1919,9
jnz sm10
mov al,bl
call put_mpu_out
ret
smn2:
 
ret
 
 
detect_devices:
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
;include 'detect/commouse.inc'
1892,9 → 1932,16
;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
ret
 
 
sys_end:
 
mov ecx, [current_slot]
mov eax, [ecx+APPDATA.tls_base]
test eax, eax
jz @F
 
stdcall user_free, eax
@@:
 
mov eax,[TASK_BASE]
mov [eax+TASKDATA.state], 3 ; terminate this program
 
1977,7 → 2024,7
 
cmp edx,[application_table_status] ; clear app table stat
jne noatsc
mov [application_table_status],0
and [application_table_status],0
noatsc:
noprocessterminate:
ret
2000,7 → 2047,7
mov ecx,eax
cli
call sysfn_terminate
mov [application_table_status],0
and [application_table_status],0
sti
and dword [esp+32],0
ret
2044,7 → 2091,7
;!!!!!!!!!!!!!!!!!!!!!!!!
include 'blkdev/rdsave.inc'
;!!!!!!!!!!!!!!!!!!!!!!!!
 
align 4
sysfn_getactive: ; 18.7 = get active window
mov eax, [TASK_COUNT]
movzx eax, word [WIN_POS + eax*2]
2052,13 → 2099,15
ret
 
sysfn_sound_flag: ; 18.8 = get/set sound_flag
cmp ecx,1
jne nogetsoundflag
; cmp ecx,1
dec ecx
jnz nogetsoundflag
movzx eax,byte [sound_flag] ; get sound_flag
mov [esp+32],eax
ret
nogetsoundflag:
cmp ecx,2
; cmp ecx,2
dec ecx
jnz nosoundflag
xor byte [sound_flag], 1
nosoundflag:
2067,9 → 2116,10
sysfn_minimize: ; 18.10 = minimize window
mov [window_minimize],1
ret
 
align 4
sysfn_getdiskinfo: ; 18.11 = get disk info table
cmp ecx,1
; cmp ecx,1
dec ecx
jnz full_table
small_table:
call for_all_tables
2082,7 → 2132,8
mov esi,DRIVE_DATA
ret
full_table:
cmp ecx,2
; cmp ecx,2
dec ecx
jnz exit_for_anyone
call for_all_tables
mov ecx,16384
2112,13 → 2163,29
and [esp+32],dword 0
ret
 
align 4
sysfn_centermouse: ; 18.15 = mouse centered
call mouse_centered
and [esp+32],dword 0
; removed here by <Lrz>
; call mouse_centered
;* mouse centered - start code- Mario79
;mouse_centered:
; push eax
mov eax,[Screen_Max_X]
shr eax,1
mov [MOUSE_X],ax
mov eax,[Screen_Max_Y]
shr eax,1
mov [MOUSE_Y],ax
; ret
;* mouse centered - end code- Mario79
xor eax,eax
and [esp+32],eax
; pop eax
 
ret
 
align 4
sysfn_mouse_acceleration: ; 18.19 = set/get mouse features
cmp ecx,0 ; get mouse speed factor
test ecx,ecx ; get mouse speed factor
jnz .set_mouse_acceleration
xor eax,eax
mov ax,[mouse_speed_factor]
2125,23 → 2192,27
mov [esp+32],eax
ret
.set_mouse_acceleration:
cmp ecx,1 ; set mouse speed factor
; cmp ecx,1 ; set mouse speed factor
dec ecx
jnz .get_mouse_delay
mov [mouse_speed_factor],dx
ret
.get_mouse_delay:
cmp ecx,2 ; get mouse delay
; cmp ecx,2 ; get mouse delay
dec ecx
jnz .set_mouse_delay
mov eax,[mouse_delay]
mov [esp+32],eax
ret
.set_mouse_delay:
cmp ecx,3 ; set mouse delay
; cmp ecx,3 ; set mouse delay
dec ecx
jnz .set_pointer_position
mov [mouse_delay],edx
ret
.set_pointer_position:
cmp ecx,4 ; set mouse pointer position
; cmp ecx,4 ; set mouse pointer position
dec ecx
jnz .set_mouse_button
mov [MOUSE_Y],dx ;y
ror edx,16
2149,7 → 2220,8
rol edx,16
ret
.set_mouse_button:
cmp ecx,5 ; set mouse button features
; cmp ecx,5 ; set mouse button features
dec ecx
jnz .end
mov [BTN_DOWN],dl
mov [mouse_active],1
2217,7 → 2289,7
 
iglobal
version_inf:
db 0,7,5,0 ; version 0.7.5.0
db 0,7,7,0 ; version 0.7.7.0
db UID_KOLIBRI
dd __REV__
version_end:
2257,10 → 2329,12
 
cmp ebx,1 ; BACKGROUND SIZE
jnz nosb1
cmp ecx,0
je sbgrr
cmp edx,0
je sbgrr
test ecx,ecx
; cmp ecx,0
jz sbgrr
test edx,edx
; cmp edx,0
jz sbgrr
@@:
;;Maxis use atomic bts for mutexes 4.4.2009
bts dword [bgrlock], 0
2446,6 → 2520,7
jnp .err
push eax
shr ecx, 12
dec ecx
@@:
and dword [page_tabs+eax*4], 0
mov edx, eax
2470,8 → 2545,8
ret
 
force_redraw_background:
mov [draw_data+32 + RECT.left],dword 0
mov [draw_data+32 + RECT.top],dword 0
and [draw_data+32 + RECT.left],dword 0
and [draw_data+32 + RECT.top],dword 0
push eax ebx
mov eax,[Screen_Max_X]
mov ebx,[Screen_Max_Y]
2484,49 → 2559,50
align 4
 
sys_getbackground:
 
cmp eax,1 ; SIZE
; cmp eax,1 ; SIZE
dec ebx
jnz nogb1
mov eax,[BgrDataWidth]
shl eax,16
mov ax,[BgrDataHeight]
mov [esp+36],eax
mov [esp+32],eax
ret
 
nogb1:
 
cmp eax,2 ; PIXEL
; cmp eax,2 ; PIXEL
dec ebx
jnz nogb2
 
mov eax, [img_background]
test ebx, ebx
test ecx, ecx
jz @f
cmp eax, static_background_data
jz .ret
@@:
mov ecx, [mem_BACKGROUND]
add ecx, 4095
and ecx, -4096
sub ecx, 4
cmp ebx, ecx
mov ebx, [mem_BACKGROUND]
add ebx, 4095
and ebx, -4096
sub ebx, 4
cmp ecx, ebx
ja .ret
 
mov eax,[ebx+eax]
mov eax,[ecx+eax]
 
and eax, 0xFFFFFF
mov [esp+36],eax
mov [esp+32],eax
.ret:
ret
nogb2:
 
cmp eax,4 ; TILED / STRETCHED
; cmp eax,4 ; TILED / STRETCHED
dec ebx
dec ebx
jnz nogb4
mov eax,[BgrDrawMode]
nogb4:
mov [esp+36],eax
mov [esp+32],eax
ret
 
 
align 4
 
sys_getkey:
2832,9 → 2908,9
; cmp eax,0 ; type I - original style
jne nosyswI
inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
call sys_set_window
call [disable_mouse]
call [_display.disable_mouse]
call drawwindow_I
;dec [mouse_pause]
;call [draw_pointer]
2845,9 → 2921,9
cmp al,1 ; type II - only reserve area, no draw
jne nosyswII
inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
call sys_set_window
call [disable_mouse]
call [_display.disable_mouse]
call sys_window_mouse
dec [mouse_pause]
call [draw_pointer]
2857,9 → 2933,9
cmp al,2 ; type III - new style
jne nosyswIII
inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
call sys_set_window
call [disable_mouse]
call [_display.disable_mouse]
call drawwindow_III
;dec [mouse_pause]
;call [draw_pointer]
2874,9 → 2950,9
draw_skin_window:
 
inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
call sys_set_window
call [disable_mouse]
call [_display.disable_mouse]
mov eax, [TASK_COUNT]
movzx eax, word [WIN_POS + eax*2]
cmp eax, [CURRENT_TASK]
2895,7 → 2971,7
 
draw_window_caption:
inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
 
xor eax,eax
mov edx,[TASK_COUNT]
3159,8 → 3235,8
syscall_windowsettings:
 
.set_window_caption:
dec eax ; subfunction #1 - set window caption
jnz .get_window_caption
dec ebx ; subfunction #1 - set window caption
jnz .exit_fail
 
; NOTE: only window owner thread can set its caption,
; so there's no parameter for PID/TID
3178,7 → 3254,7
; cmp ebx,ecx
; ja .exit_fail
 
mov [edi*8+SLOT_BASE+APPDATA.wnd_caption],ebx
mov [edi*8+SLOT_BASE+APPDATA.wnd_caption],ecx
or [edi+window_data+WDATA.fl_wstyle],WSTYLE_HASCAPTION
 
call draw_window_caption
3186,9 → 3262,9
xor eax,eax ; eax = 0 (success)
ret
 
.get_window_caption:
dec eax ; subfunction #2 - get window caption
jnz .exit_fail
; .get_window_caption:
; dec eax ; subfunction #2 - get window caption
; jnz .exit_fail
 
; not implemented yet
 
3264,10 → 3340,10
pop eax
add ecx,eax
add edx,ebx
mov [dlx],eax ; save for drawlimits
mov [dly],ebx
mov [dlxe],ecx
mov [dlye],edx
mov [draw_limits.left],eax ; save for drawlimits
mov [draw_limits.top],ebx
mov [draw_limits.right],ecx
mov [draw_limits.bottom],edx
call calculatescreen
 
mov [edi + WDATA.fl_redraw], 1 ; flag the process as redraw
3313,67 → 3389,76
;3 - rdmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok.
;4 - wrmsr. Counter in edx. (edx:eax) [esi:edi, edx] => [edx:esi, ecx]. Ret in ebx:eax. Block. ok.
;---------------------------------------------------------------------------------------------
sys_sheduler: ;noname & halyavin
cmp eax,0
je shed_counter
cmp eax,2
je perf_control
cmp eax,3
je rdmsr_instr
cmp eax,4
je wrmsr_instr
cmp eax,1
jne not_supported
call change_task ;delay,0
ret
shed_counter:
iglobal
align 4
sheduler:
dd sys_sheduler.00
dd change_task
dd sys_sheduler.02
dd sys_sheduler.03
dd sys_sheduler.04
endg
sys_sheduler:
;rewritten by <Lrz> 29.12.2009
jmp dword [sheduler+ebx*4]
;.shed_counter:
.00:
mov eax,[context_counter]
mov [esp+36],eax
not_supported:
mov [esp+32],eax
ret
perf_control:
inc eax ;now eax=3
cmp ebx,eax
je cache_disable
dec eax
cmp ebx,eax
je cache_enable
dec eax
cmp ebx,eax
je is_cache_enabled
dec eax
cmp ebx,eax
je modify_pce
 
.02:
;.perf_control:
inc ebx ;before ebx=2, ebx=3
cmp ebx,ecx ;if ecx=3, ebx=3
jz cache_disable
 
dec ebx ;ebx=2
cmp ebx,ecx ;
jz cache_enable ;if ecx=2 and ebx=2
 
dec ebx ;ebx=1
cmp ebx,ecx
jz is_cache_enabled ;if ecx=1 and ebx=1
 
dec ebx
test ebx,ecx ;ebx=0 and ecx=0
jz modify_pce ;if ecx=0
 
ret
 
rdmsr_instr:
.03:
;.rdmsr_instr:
;now counter in ecx
;(edx:eax) esi:edi => edx:esi
mov eax,esi
mov ecx,edx
rdmsr
mov [esp+36],eax
mov [esp+24],edx ;ret in ebx?
mov [esp+32],eax
mov [esp+20],edx ;ret in ebx?
ret
 
wrmsr_instr:
.04:
;.wrmsr_instr:
;now counter in ecx
;(edx:eax) esi:edi => edx:esi
; Fast Call MSR can't be destroy
; Íî MSR_AMD_EFER ìîæíî èçìåíÿòü, ò.ê. â ýòîì ðåãèñòðå ëèø
; âêëþ÷àþòñÿ/âûêëþ÷àþòñÿ ðàñøèðåííûå âîçìîæíîñòè
cmp ecx, MSR_SYSENTER_CS
; ® MSR_AMD_EFER ¬®¦­® ¨§¬¥­ïâì, â.ª. ¢ í⮬ ॣ¨áâॠ«¨è
; ¢ª«îç îâáï/¢ëª«îç îâáï à áè¨à¥­­ë¥ ¢®§¬®¦­®áâ¨
cmp edx,MSR_SYSENTER_CS
je @f
cmp ecx, MSR_SYSENTER_ESP
cmp edx,MSR_SYSENTER_ESP
je @f
cmp ecx, MSR_SYSENTER_EIP
cmp edx,MSR_SYSENTER_EIP
je @f
cmp ecx, MSR_AMD_STAR
cmp edx,MSR_AMD_STAR
je @f
 
mov eax, esi
mov ecx,edx
wrmsr
; mov [esp + 36], eax
; mov [esp + 24], edx ;ret in ebx?
; mov [esp + 32], eax
; mov [esp + 20], edx ;ret in ebx?
@@:
ret
 
3395,9 → 3480,9
mov ebx,eax
and eax,01100000000000000000000000000000b
jz cache_disabled
mov [esp+36],ebx
mov [esp+32],ebx
cache_disabled:
mov dword [esp+36],eax ;0
mov dword [esp+32],eax ;0
ret
 
modify_pce:
3407,7 → 3492,7
; xor eax,ebx ;invert pce
bts eax,8 ;pce=cr4[8]
mov cr4,eax
mov [esp+36],eax
mov [esp+32],eax
ret
;---------------------------------------------------------------------------------------------
 
3420,7 → 3505,8
mov edx,[Screen_Max_X] ; screen x size
inc edx
imul edx, ebx
mov dl, [eax+edx+display_data] ; lea eax, [...]
add eax, [_WinMapAddress]
mov dl, [eax+edx] ; lea eax, [...]
 
xor ecx, ecx
mov eax, [CURRENT_TASK]
3509,7 → 3595,7
 
no_mark_system_shutdown:
 
call [disable_mouse]
call [_display.disable_mouse]
 
dec byte [SYS_SHUTDOWN]
je system_shutdown
3572,11 → 3658,11
add ecx,eax
add edx,ebx
 
mov ecx,[dlye] ; ecx = area y end ebx = window y start
mov ecx,[draw_limits.bottom] ; ecx = area y end ebx = window y start
cmp ecx,ebx
jb ricino
 
mov ecx,[dlxe] ; ecx = area x end eax = window x start
mov ecx,[draw_limits.right] ; ecx = area x end eax = window x start
cmp ecx,eax
jb ricino
 
3587,11 → 3673,11
add ecx, eax
add edx, ebx
 
mov eax,[dly] ; eax = area y start edx = window y end
mov eax,[draw_limits.top] ; eax = area y start edx = window y end
cmp edx,eax
jb ricino
 
mov eax,[dlx] ; eax = area x start ecx = window x end
mov eax,[draw_limits.left] ; eax = area x start ecx = window x end
cmp ecx,eax
jb ricino
 
3605,22 → 3691,22
test al,al
jz .az
lea eax,[edi+draw_data-window_data]
mov ebx,[dlx]
mov ebx,[draw_limits.left]
cmp ebx,[eax+RECT.left]
jae @f
mov [eax+RECT.left],ebx
@@:
mov ebx,[dly]
mov ebx,[draw_limits.top]
cmp ebx,[eax+RECT.top]
jae @f
mov [eax+RECT.top],ebx
@@:
mov ebx,[dlxe]
mov ebx,[draw_limits.right]
cmp ebx,[eax+RECT.right]
jbe @f
mov [eax+RECT.right],ebx
@@:
mov ebx,[dlye]
mov ebx,[draw_limits.bottom]
cmp ebx,[eax+RECT.bottom]
jbe @f
mov [eax+RECT.bottom],ebx
3631,13 → 3717,13
mov eax,edi
add eax,draw_data-window_data
 
mov ebx,[dlx] ; set limits
mov ebx,[draw_limits.left] ; set limits
mov [eax + RECT.left], ebx
mov ebx,[dly]
mov ebx,[draw_limits.top]
mov [eax + RECT.top], ebx
mov ebx,[dlxe]
mov ebx,[draw_limits.right]
mov [eax + RECT.right], ebx
mov ebx,[dlye]
mov ebx,[draw_limits.bottom]
mov [eax + RECT.bottom], ebx
 
sub eax,draw_data-window_data
3667,9 → 3753,10
 
calculatebackground: ; background
 
mov edi,display_data ; set os to use all pixels
mov edi, [_WinMapAddress] ; set os to use all pixels
mov eax,0x01010101
mov ecx,1280*1024 / 4
mov ecx, [_WinMapSize]
shr ecx, 2
rep stosd
 
mov byte [REDRAW_BACKGROUND], 0 ; do not draw background!
3745,7 → 3832,7
 
ret
 
 
align 16 ;very often call this subrutine
memmove: ; memory move in bytes
 
; eax = from
3754,7 → 3841,6
test ecx, ecx
jle .ret
 
 
push esi edi ecx
 
mov edi, ebx
3925,43 → 4011,41
 
 
set_io_access_rights:
 
pushad
 
push edi eax
mov edi, tss._io_map_0
 
; mov ecx,eax
; and ecx,7 ; offset in byte
 
; shr eax,3 ; number of byte
; add edi,eax
 
; mov ebx,1
; shl ebx,cl
 
cmp ebp,0 ; enable access - ebp = 0
jne siar1
 
test ebp,ebp
; cmp ebp,0 ; enable access - ebp = 0
jnz siar1
; not ebx
; and [edi],byte bl
btr [edi], eax
 
popad
 
pop eax edi
ret
 
siar1:
 
bts [edi], eax
; or [edi],byte bl ; disable access - ebp = 1
 
popad
 
pop eax edi
ret
 
;reserve/free group of ports
; * eax = 46 - number function
; * ebx = 0 - reserve, 1 - free
; * ecx = number start arrea of ports
; * edx = number end arrea of ports (include last number of port)
;Return value:
; * eax = 0 - succesful
; * eax = 1 - error
; * The system has reserve this ports:
; 0..0x2d, 0x30..0x4d, 0x50..0xdf, 0xe5..0xff (include last number of port).
;destroys eax,ebx, ebp
r_f_port_area:
 
test eax, eax
test ebx, ebx
jnz free_port_area
; je r_port_area
; jmp free_port_area
3968,78 → 4052,70
 
; r_port_area:
 
pushad
; pushad
 
cmp ebx,ecx ; beginning > end ?
cmp ecx,edx ; beginning > end ?
ja rpal1
cmp ecx,65536
cmp edx,65536
jae rpal1
mov esi,[RESERVED_PORTS]
test esi,esi ; no reserved areas ?
mov eax,[RESERVED_PORTS]
test eax,eax ; no reserved areas ?
je rpal2
cmp esi,255 ; max reserved
cmp eax,255 ; max reserved
jae rpal1
rpal3:
mov edi,esi
shl edi,4
add edi,RESERVED_PORTS
cmp ebx,[edi+8]
mov ebx,eax
shl ebx,4
add ebx,RESERVED_PORTS
cmp ecx,[ebx+8]
ja rpal4
cmp ecx,[edi+4]
cmp edx,[ebx+4]
jae rpal1
; jb rpal4
; jmp rpal1
rpal4:
 
dec esi
dec eax
jnz rpal3
jmp rpal2
rpal1:
popad
mov eax,1
; popad
; mov eax,1
xor eax,eax
inc eax
ret
 
rpal2:
popad
 
 
; popad
; enable port access at port IO map
cli
pushad ; start enable io map
 
cmp ecx,65536 ;16384
cmp edx,65536 ;16384
jae no_unmask_io ; jge
 
mov eax,ebx
 
mov eax,ecx
; push ebp
xor ebp,ebp ; enable - eax = port
new_port_access:
 
pushad
 
xor ebp,ebp ; enable - eax = port
; pushad
call set_io_access_rights
 
popad
 
; popad
inc eax
cmp eax,ecx
cmp eax,edx
jbe new_port_access
 
; pop ebp
no_unmask_io:
 
popad ; end enable io map
sti
 
mov edi,[RESERVED_PORTS]
add edi,1
mov [RESERVED_PORTS],edi
shl edi,4
add edi,RESERVED_PORTS
mov esi,[TASK_BASE]
mov esi,[esi+TASKDATA.pid]
mov [edi],esi
mov [edi+4],ebx
mov [edi+8],ecx
mov eax,[RESERVED_PORTS]
add eax,1
mov [RESERVED_PORTS],eax
shl eax,4
add eax,RESERVED_PORTS
mov ebx,[TASK_BASE]
mov ebx,[ebx+TASKDATA.pid]
mov [eax],ebx
mov [eax+4],ecx
mov [eax+8],edx
 
xor eax, eax
ret
4046,34 → 4122,34
 
free_port_area:
 
pushad
 
mov esi,[RESERVED_PORTS] ; no reserved areas ?
test esi,esi
je frpal2
mov edx,[TASK_BASE]
mov edx,[edx+TASKDATA.pid]
; pushad
mov eax,[RESERVED_PORTS] ; no reserved areas ?
test eax,eax
jz frpal2
mov ebx,[TASK_BASE]
mov ebx,[ebx+TASKDATA.pid]
frpal3:
mov edi,esi
mov edi,eax
shl edi,4
add edi,RESERVED_PORTS
cmp edx,[edi]
cmp ebx,[edi]
jne frpal4
cmp ebx,[edi+4]
cmp ecx,[edi+4]
jne frpal4
cmp ecx,[edi+8]
cmp edx,[edi+8]
jne frpal4
jmp frpal1
frpal4:
dec esi
dec eax
jnz frpal3
frpal2:
popad
mov eax,1
; popad
inc eax
ret
frpal1:
push ecx
mov ecx,256
sub ecx,esi
sub ecx,eax
shl ecx,4
mov esi,edi
add esi,16
4081,36 → 4157,27
rep movsb
 
dec dword [RESERVED_PORTS]
 
popad
 
 
;popad
; disable port access at port IO map
 
pushad ; start disable io map
 
cmp ecx,65536 ;16384
; pushad ; start disable io map
pop eax ;start port
cmp edx,65536 ;16384
jge no_mask_io
 
mov eax,ebx
 
; mov eax,ecx
xor ebp,ebp
inc ebp
new_port_access_disable:
 
pushad
 
mov ebp,1 ; disable - eax = port
; pushad
; mov ebp,1 ; disable - eax = port
call set_io_access_rights
 
popad
 
; popad
inc eax
cmp eax,ecx
cmp eax,edx
jbe new_port_access_disable
 
no_mask_io:
 
popad ; end disable io map
 
; popad ; end disable io map
xor eax, eax
ret
 
4805,13 → 4872,13
 
push dx ax
 
@@: ; wait for empty transmit register
@@: ; Wait for empty transmit register (yes, this slows down system..)
mov dx, debug_com_base+5
in al, dx
test al, 1 shl 5
jz @r
 
mov dx, debug_com_base ; TODO: replace this with variable
mov dx, debug_com_base ; Output the byte
mov al, bl
out dx, al
 
4819,7 → 4886,6
 
end if
 
 
mov [msg_board_data+ecx],bl
inc ecx
and ecx, 4095
4991,7 → 5057,7
ret
no_gs3:
 
mov [esp+36],dword -1
or [esp+36],dword -1
ret
 
 
5019,7 → 5085,7
add ebx, [edi+APPDATA.wnd_clientbox.top]
xor edi, edi ; no force
; mov edi, 1
call [disable_mouse]
call [_display.disable_mouse]
jmp [putpixel]
 
align 4
5093,37 → 5159,39
 
syscall_cdaudio: ; CD
 
cmp eax, 4
cmp ebx, 4
jb .audio
jz .eject
cmp eax, 5
cmp ebx, 5
jnz .ret
.load:
call .reserve
call LoadMedium
call .free
ret
;call .free
jmp .free
; ret
.eject:
call .reserve
call clear_CD_cache
call allow_medium_removal
call EjectMedium
call .free
ret
; call .free
jmp .free
; ret
.audio:
call sys_cd_audio
mov [esp+36],eax
mov [esp+36-4],eax
.ret:
ret
 
.reserve:
call reserve_cd
mov eax, ebx
mov eax, ecx
shr eax, 1
and eax, 1
inc eax
mov [ChannelNumber], ax
mov eax, ebx
mov eax, ecx
and eax, 1
mov [DiskNumber], al
call reserve_cd_channel
5136,7 → 5204,7
mov al, [DRIVE_DATA+1]
shr al, cl
test al, 2
jz .err
jz .free;.err
ret
.free:
call free_cd_channel
5144,7 → 5212,7
ret
.err:
call .free
pop eax
; pop eax
ret
 
align 4
5171,7 → 5239,7
pushad
inc [mouse_pause]
; Check of use of the hardware cursor.
cmp [disable_mouse],__sys_disable_mouse
cmp [_display.disable_mouse],__sys_disable_mouse
jne @f
; Since the test for the coordinates of the mouse should not be used,
; then use the call [disable_mouse] is not possible!
5235,7 → 5303,7
jnz .start_y
dec [mouse_pause]
; Check of use of the hardware cursor.
cmp [disable_mouse],__sys_disable_mouse
cmp [_display.disable_mouse],__sys_disable_mouse
jne @f
call [draw_pointer]
@@:
5289,18 → 5357,24
syscall_reserveportarea: ; ReservePortArea and FreePortArea
 
call r_f_port_area
mov [esp+36],eax
mov [esp+32],eax
ret
 
align 4
 
syscall_threads: ; CreateThreads
; eax=1 create thread
;
; ebx=thread start
; ecx=thread stack value
;
; on return : eax = pid
 
call sys_threads
mov [esp+36],eax
call new_sys_threads
 
mov [esp+32],eax
ret
 
 
align 4
 
read_from_hd: ; Read from hd - fn not in use
5334,18 → 5408,33
 
mov [Screen_Max_X], eax
mov [Screen_Max_Y], edx
mov [BytesPerScanLine], ecx
 
mov [screen_workarea.right],eax
mov [screen_workarea.bottom], edx
inc eax
shl eax, 2 ;32 bpp
mov [BytesPerScanLine], eax
 
push ebx
push esi
push edi
 
pushad
 
stdcall kernel_free, [_WinMapAddress]
 
mov eax, [_display.width]
mul [_display.height]
mov [_WinMapSize], eax
 
stdcall kernel_alloc, eax
mov [_WinMapAddress], eax
test eax, eax
jz .epic_fail
 
popad
 
call repos_windows
mov eax, 0
mov ebx, 0
xor eax, eax
xor ebx, ebx
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
call calculatescreen
5356,28 → 5445,37
popfd
ret
 
.epic_fail:
hlt ; Houston, we've had a problem
 
; --------------- APM ---------------------
uglobal
apm_entry dp 0
apm_vf dd 0
endg
 
align 4
sys_apm:
cmp word [apm_vf], 0 ; Check APM BIOS enable
xor eax,eax
cmp word [apm_vf], ax ; Check APM BIOS enable
jne @f
or [esp + 48], byte 1 ; error
mov [esp + 36], dword 8 ; 32-bit protected-mode interface not supported
inc eax
or dword [esp + 44], eax ; error
add eax,7
mov dword [esp + 32], eax ; 32-bit protected-mode interface not supported
ret
 
@@:
xchg eax, ecx
xchg ebx, ecx
; xchg eax, ecx
; xchg ebx, ecx
 
cmp al, 3
cmp dx, 3
ja @f
and [esp + 48], byte 0xfe ; emulate func 0..3 as func 0
and [esp + 44], byte 0xfe ; emulate func 0..3 as func 0
mov eax, [apm_vf]
mov [esp + 36], eax
mov [esp + 32], eax
shr eax, 16
mov [esp + 32], eax
mov [esp + 28], eax
ret
 
@@:
5396,17 → 5494,15
mov cr3, eax
pop eax
 
mov [esp + 8 ], edi
mov [esp + 12], esi
mov [esp + 24], ebx
mov [esp + 28], edx
mov [esp + 32], ecx
mov [esp + 36], eax
mov [esp + 4 ], edi
mov [esp + 8], esi
mov [esp + 20], ebx
mov [esp + 24], edx
mov [esp + 28], ecx
mov [esp + 32], eax
setc al
and [esp + 48], byte 0xfe
or [esp + 48], al
 
 
and [esp + 44], byte 0xfe
or [esp + 44], al
ret
; -----------------------------------------
 
/kernel/branches/net/kernel32.inc
99,6 → 99,14
TASKDATA TASKDATA
end virtual
 
TSTATE_RUNNING = 0
TSTATE_RUN_SUSPENDED = 1
TSTATE_WAIT_SUSPENDED = 2
TSTATE_ZOMBIE = 3
TSTATE_TERMINATING = 4
TSTATE_WAITING = 5
TSTATE_FREE = 9
 
; structures definition
struc WDATA {
.box BOX
109,11 → 117,12
.fl_wstate db ?
.fl_wdrawn db ?
.fl_redraw db ?
.sizeof:
}
virtual at 0
WDATA WDATA
end virtual
label WDATA.fl_wstyle byte at 0x13
label WDATA.fl_wstyle byte at WDATA.cl_workarea + 3
 
struc APPDATA
{
141,7 → 150,9
.wait_begin dd ? ;+92 +++
.wait_test dd ? ;+96 +++
.wait_param dd ? ;+100 +++
db 24 dup(?) ;+104
.tls_base dd ? ;+104
.dlls_list_ptr dd ? ;+108
db 16 dup(?) ;+112
 
.wnd_shape dd ? ;+128
.wnd_shape_scale dd ? ;+132
/kernel/branches/net/sound/playnote.inc
143,22 → 143,24
;result:
; al - note
push eax
push ebx
push ecx
push edx
push esi
 
mov eax,[pidProcessNote]
call pid_to_slot
test eax,eax
jz .failed
lea ebx,[esp+12]
mov ecx,1
mov edx,[memAdrNote]
lea ecx,[esp+12]
mov edx,1
mov esi,[memAdrNote]
inc [memAdrNote]
 
call read_process_memory
.failed:
pop esi
pop edx
pop ecx
pop ebx
pop eax
ret
;------------------- END CODE -------------------
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/video/arrow.cur
Property changes:
Added: svn:mergeinfo
/kernel/branches/net/video/cursors.inc
32,7 → 32,7
end virtual
 
align 4
proc vesa_init_cursor stdcall, dst:dword, src:dword
proc init_cursor stdcall, dst:dword, src:dword
locals
rBase dd ?
pQuad dd ?
290,7 → 290,7
; ebx= src
; ecx= flags
 
vesa_cursor:
create_cursor:
.src equ esp
.flags equ esp+4
.hcursor equ esp+8
300,7 → 300,7
push ebx
 
mov ebx, eax
mov eax, CURSOR_SIZE
mov eax, CURSOR.sizeof
call create_kernel_object
test eax, eax
jz .fail
330,8 → 330,33
mov [edi+CURSOR.hot_x], ecx
mov [edi+CURSOR.hot_y], edx
 
stdcall vesa_init_cursor, eax, esi
stdcall init_cursor, eax, esi
 
mov eax, [.hcursor]
lea eax, [eax+CURSOR.list_next]
lea edx, [_display.cr_list.next]
 
pushfd
cli
mov ecx, [edx]
 
mov [eax], ecx
mov [eax+4], edx
 
mov [ecx+4], eax
mov [edx], eax
popfd
 
mov eax, [.hcursor]
.check_hw:
cmp [_display.init_cursor], 0
je .fail
 
push eax
call [_display.init_cursor]
add esp, 4
 
mov eax, [.hcursor]
.fail:
add esp, 12
ret
346,8 → 371,7
mov ecx, 1024
cld
rep movsd
add esp, 12
ret
jmp .check_hw
 
align 4
proc load_cursor stdcall, src:dword, flags:dword
377,7 → 401,7
mov eax, [CURRENT_TASK+eax+4]
mov ebx, [src]
mov ecx, [flags]
call [create_cursor] ;eax, ebx, ecx
call create_cursor ;eax, ebx, ecx
mov [handle], eax
 
cmp word [flags], LOAD_FROM_FILE
407,8 → 431,6
mov esi, [hcursor]
cmp [esi+CURSOR.magic], 'CURS'
jne .fail
; cmp [esi+CURSOR.size], CURSOR_SIZE
; jne .fail
 
mov ebx, [CURRENT_TASK]
shl ebx, 5
443,127 → 465,78
 
align 4
select_cursor:
 
mov eax, [esp+4]
mov [_display.cursor], eax
ret 4
 
align 4
proc init_cursors
proc restore_24 stdcall, x:dword, y:dword
 
cmp [SCR_MODE],word 0x13
jbe .fail
push ebx
 
test word [SCR_MODE], 0x4000
jz .fail
 
movzx eax, byte [ScreenBPP]
mov ebx, [BytesPerScanLine]
cmp eax, 32
jne @F
sub ebx, 128
jmp .init
@@:
cmp eax, 24
jne .fail
sub ebx, 96
.init:
mov [cur_def_interl], ebx
 
stdcall load_driver, szHwMouse
mov [hw_cursor], eax
test eax, eax
jz .sw_mouse
 
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
mov [def_cursor], eax
ret
.sw_mouse:
mov [create_cursor], vesa_cursor
 
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
mov [def_cursor], eax
 
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
inc ecx
inc edx
mov [scr_width], ecx
mov [scr_height], edx
 
movzx ebx, byte [ScreenBPP]
cmp ebx, 32
jne @F
 
 
mov dword [select_hw_cursor], select_cursor
mov dword [set_hw_cursor], cursor_32
mov dword [hw_restore], restore_32
ret
@@:
mov dword [select_hw_cursor], select_cursor
mov dword [set_hw_cursor], cursor_24
mov dword [hw_restore], restore_24
ret
.fail:
xor eax, eax
mov dword [select_hw_cursor], eax
mov dword [set_hw_cursor], eax
mov dword [hw_restore], eax
ret
endp
 
align 4
proc restore_24 stdcall, x:dword, y:dword
locals
w dd ?
endl
 
mov edi, [cur_saved_base]
mov edx, [cur_saved_h]
mov ebx, [cur_saved_interl]
mov ebx, [cur_saved_base]
mov edx, [cur.h]
test edx, edx
jz .ret
 
push esi
push edi
 
mov esi, cur_saved_data
mov ecx, [cur.w]
lea ecx, [ecx+ecx*2]
push ecx
@@:
mov ecx, [cur_saved_w]
lea ecx, [ecx+ecx*2]
mov edi, ebx
add ebx, [BytesPerScanLine]
 
mov ecx, [esp]
rep movsb
add edi, ebx
dec edx
jnz @B
 
pop ecx
pop edi
pop esi
.ret:
pop ebx
ret
endp
 
align 4
proc restore_32 stdcall, x:dword, y:dword
locals
w dd ?
endl
 
mov edi, [cur_saved_base]
mov edx, [cur_saved_h]
mov ebx, [cur_saved_interl]
push ebx
 
mov ebx, [cur_saved_base]
mov edx, [cur.h]
test edx, edx
jz .ret
 
push esi
push edi
 
mov esi, cur_saved_data
@@:
mov ecx, [cur_saved_w]
mov edi, ebx
add ebx, [BytesPerScanLine]
 
mov ecx, [cur.w]
rep movsd
add edi, ebx
dec edx
jnz @B
 
pop edi
.ret:
pop esi
pop ebx
ret
endp
 
align 4
proc cursor_24 stdcall, hcursor:dword, x:dword, y:dword
proc move_cursor_24 stdcall, hcursor:dword, x:dword, y:dword
locals
w dd ?
h dd ?
st dd ?
_dx dd ?
_dy dd ?
endl
575,10 → 548,12
 
xor edx, edx
sub ecx, [esi+CURSOR.hot_x]
lea ebx, [ecx+32-1]
mov [x], ecx
sets dl
dec edx
and ecx, edx ;clip x to 0<=x
mov [cur.left], ecx
mov edi, ecx
sub edi, [x]
mov [_dx], edi
585,77 → 560,72
 
xor edx, edx
sub eax, [esi+CURSOR.hot_y]
lea edi, [eax+32-1]
mov [y], eax
sets dl
dec edx
and eax, edx ;clip y to 0<=y
mov edi, eax
sub edi, [y]
mov [_dy], edi
mov [cur.top], eax
mov edx, eax
sub edx, [y]
mov [_dy], edx
 
mul ebx
lea esi, [ecx+ecx*2]
add esi, [LFBAddress]
add esi, eax
mov [cur_saved_base],esi
mul dword [BytesPerScanLine]
lea edx, [LFB_BASE+ecx*3]
add edx, eax
mov [cur_saved_base],edx
 
mov edi, [scr_width]
mov edx, [scr_height]
mov eax, 32
 
sub edi, ecx
cmp edi, eax
jng @F
mov edi, eax
cmp ebx, [Screen_Max_X]
jbe @F
mov ebx, [Screen_Max_X]
@@:
sub edi, [_dx]
 
sub edx, [y]
cmp edx, eax
jng @F
mov edx, eax
cmp edi, [Screen_Max_Y]
jbe @F
mov edi, [Screen_Max_Y]
@@:
sub edx, [_dy]
mov [cur.right], ebx
mov [cur.bottom], edi
 
mov [w], edi
mov [h], edx
mov [cur_saved_w], edi
mov [cur_saved_h], edx
sub ebx, [x]
sub edi, [y]
inc ebx
inc edi
 
sub eax, edi
shl eax, 2 ;lea eax, [eax+eax*2]
lea edi, [edi+edi*2]
sub ebx, edi
mov [cur_saved_interl], ebx
mov [cur.w], ebx
mov [cur.h], edi
mov [h], edi
 
mov eax, edi
mov edi, cur_saved_data
@@:
mov ecx, [w]
mov esi, edx
add edx, [BytesPerScanLine]
mov ecx, [cur.w]
lea ecx, [ecx+ecx*2]
rep movsb
add esi, ebx
dec edx
dec eax
jnz @B
 
;draw cursor
mov edx, eax
mov edi, [cur_saved_base]
mov ebx, [cur_saved_base]
mov eax, [_dy]
shl eax, 5
add eax, [_dx]
shl eax, 2
 
mov esi, [hcursor]
mov esi, [esi+CURSOR.base]
add esi, eax
lea edx, [esi+eax*4]
.row:
mov ecx, [w]
mov ecx, [cur.w]
mov esi, edx
mov edi, ebx
add edx, 32*4
add ebx, [BytesPerScanLine]
.pix:
lodsd
test eax, 0xFF000000
jz @F
 
mov word [edi], ax
mov [edi], ax
shr eax, 16
mov [edi+2],al
@@:
663,19 → 633,16
dec ecx
jnz .pix
 
add esi, edx
add edi, ebx
dec [h]
jnz .row
ret
endp
 
 
align 4
proc cursor_32 stdcall, hcursor:dword, x:dword, y:dword
proc move_cursor_32 stdcall, hcursor:dword, x:dword, y:dword
locals
w dd ?
h dd ?
st dd ?
_dx dd ?
_dy dd ?
endl
683,14 → 650,15
mov esi, [hcursor]
mov ecx, [x]
mov eax, [y]
mov ebx, [BytesPerScanLine]
 
xor edx, edx
sub ecx, [esi+CURSOR.hot_x]
lea ebx, [ecx+32-1]
mov [x], ecx
sets dl
dec edx
and ecx, edx ;clip x to 0<=x
mov [cur.left], ecx
mov edi, ecx
sub edi, [x]
mov [_dx], edi
697,69 → 665,65
 
xor edx, edx
sub eax, [esi+CURSOR.hot_y]
lea edi, [eax+32-1]
mov [y], eax
sets dl
dec edx
and eax, edx ;clip y to 0<=y
mov edi, eax
sub edi, [y]
mov [_dy], edi
mov [cur.top], eax
mov edx, eax
sub edx, [y]
mov [_dy], edx
 
mul ebx
lea esi, [eax+ecx*4]
add esi, [LFBAddress]
mov [cur_saved_base],esi
mul dword [BytesPerScanLine]
lea edx, [LFB_BASE+eax+ecx*4]
mov [cur_saved_base],edx
 
mov edi, [scr_width]
mov edx, [scr_height]
mov eax, 32
 
sub edi, ecx
cmp edi, eax
jng @F
mov edi, eax
cmp ebx, [Screen_Max_X]
jbe @F
mov ebx, [Screen_Max_X]
@@:
sub edi, [_dx]
 
sub edx, [y]
cmp edx, eax
jng @F
mov edx, eax
cmp edi, [Screen_Max_Y]
jbe @F
mov edi, [Screen_Max_Y]
@@:
sub edx, [_dy]
mov [cur.right], ebx
mov [cur.bottom], edi
 
mov [w], edi
mov [h], edx
mov [cur_saved_w], edi
mov [cur_saved_h], edx
sub ebx, [x]
sub edi, [y]
inc ebx
inc edi
 
sub eax, edi
shl eax, 2
shl edi, 2
sub ebx, edi
mov [cur_saved_interl], ebx
mov [cur.w], ebx
mov [cur.h], edi
mov [h], edi
 
mov eax, edi
mov edi, cur_saved_data
@@:
mov ecx, [w]
mov esi, edx
add edx, [BytesPerScanLine]
mov ecx, [cur.w]
rep movsd
add esi, ebx
dec edx
dec eax
jnz @B
 
;draw cursor
mov edx, eax
mov edi, [cur_saved_base]
mov ebx, [cur_saved_base]
mov eax, [_dy]
shl eax, 5
add eax, [_dx]
shl eax, 2
 
mov esi, [hcursor]
mov esi, [esi+CURSOR.base]
add esi, eax
lea edx, [esi+eax*4]
.row:
mov ecx, [w]
mov ecx, [cur.w]
mov esi, edx
mov edi, ebx
add edx, 32*4
add ebx, [BytesPerScanLine]
.pix:
lodsd
test eax, 0xFF000000
769,14 → 733,74
add edi, 4
dec ecx
jnz .pix
add esi, edx
add edi, ebx
 
dec [h]
jnz .row
ret
endp
 
 
align 4
get_display:
mov eax, _display
ret
 
align 4
init_display:
 
xor eax, eax
mov edi, _display
 
mov [edi+display_t.init_cursor], eax
mov [edi+display_t.select_cursor], eax
mov [edi+display_t.show_cursor], eax
mov [edi+display_t.move_cursor], eax
mov [edi+display_t.restore_cursor], eax
 
lea ecx, [edi+display_t.cr_list.next]
mov [edi+display_t.cr_list.next], ecx
mov [edi+display_t.cr_list.prev], ecx
 
cmp [SCR_MODE],word 0x13
jbe .fail
 
test word [SCR_MODE], 0x4000
jz .fail
 
mov ebx, restore_32
mov ecx, move_cursor_32
movzx eax, byte [ScreenBPP]
cmp eax, 32
je @F
 
mov ebx, restore_24
mov ecx, move_cursor_24
cmp eax, 24
jne .fail
@@:
mov [_display.select_cursor], select_cursor
mov [_display.move_cursor], ecx
mov [_display.restore_cursor], ebx
 
stdcall load_cursor, def_arrow, dword LOAD_FROM_MEM
mov [def_cursor], eax
ret
.fail:
xor eax, eax
mov [_display.select_cursor], eax
mov [_display.move_cursor], eax
ret
 
 
 
 
 
 
 
 
 
 
align 4
def_arrow:
file 'arrow.cur'
 
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/video/vesa12.inc
242,7 → 242,7
 
vesa12_drawbackground:
 
call [disable_mouse]
call [_display.disable_mouse]
 
push eax
push ebx
258,7 → 258,7
mov [imax],eax
mov eax,[draw_data+32+RECT.left]
mov ebx,[draw_data+32+RECT.top]
mov edi,0 ;no force
xor edi,edi ;no force
 
v12dp3:
 
327,7 → 327,8
mov eax,[Screen_Max_X]
add eax,1
mul ebx
cmp [eax+esi+WinMapAddress],byte 1
add eax, [_WinMapAddress]
cmp [eax+esi],byte 1
jnz v12nbgp
mov eax,[BytesPerScanLine]
mov ebx,edi
386,7 → 387,7
 
vesa12_drawbar:
 
call [disable_mouse]
call [_display.disable_mouse]
 
;; mov [novesachecksum],dword 0
sub edx,ebx
494,7 → 495,7
sub eax,VGABasePtr
mov ebx,3
div ebx
add eax,WinMapAddress
add eax, [_WinMapAddress]
mov ebx,[CURRENT_TASK]
cld
 
585,7 → 586,7
mov eax,edi
sub eax,VGABasePtr
shr eax,2
add eax,WinMapAddress
add eax, [_WinMapAddress]
mov ebx,[CURRENT_TASK]
cld
 
753,7 → 754,7
; mov ecx,320*65536+240
; mov edx,20*65536+20
 
call [disable_mouse]
call [_display.disable_mouse]
 
mov [novesachecksum],dword 0
push esi
830,7 → 831,7
sub edx,VGABasePtr
mov ebx,3
div ebx
add edx,WinMapAddress
add edx, [_WinMapAddress]
mov ebx,[CURRENT_TASK]
mov bh,[esp+4*3]
 
909,7 → 910,7
mov edx,edi
sub edx,VGABasePtr
shr edx,2
add edx,WinMapAddress
add edx, [_WinMapAddress]
mov ebx,[CURRENT_TASK]
mov bh,[esp+4*3]
 
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/video/vesa20.inc
28,7 → 28,6
;BytesPerScanLine equ 0xfe08
;LFBAddress equ 0xfe80
;ScreenBPP equ 0xfbf1
;WinMapAddress equ 0x460000
 
 
 
54,8 → 53,7
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
lea edi, [eax+eax*2] ; edi = x*3
add edi, ebx ; edi = x*3+(y*y multiplier)
add edi, [LFBAddress] ; ebx = where pixel is in memory
mov ecx, [edi]
mov ecx, [LFB_BASE+edi]
and ecx, 0xffffff
ret
 
62,8 → 60,7
Vesa20_getpixel32:
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
add edi, [LFBAddress] ; ebx = where pixel is in memory
mov ecx, [edi]
mov ecx, [LFB_BASE+edi]
and ecx, 0xffffff
ret
 
106,7 → 103,7
 
vesa20_putimage:
pushad
call [disable_mouse]
call [_display.disable_mouse]
sub esp, putimg.stack_data
; save pointer to image
mov [putimg.pti], ebx
194,13 → 191,12
shr ebx, 3
imul eax, ebx
add edx, eax
add edx, [LFBAddress]
; pointer to pixel map
mov eax, [putimg.abs_cy]
imul eax, [Screen_Max_X]
add eax, [putimg.abs_cy]
add eax, [putimg.abs_cx]
add eax, WinMapAddress
add eax, [_WinMapAddress]
xchg eax, ebp
; get process number
mov ebx, [CURRENT_TASK]
220,9 → 216,9
cmp [ebp], bl
jne .skip
; mov eax, [esi] ; eax = RRBBGGRR
mov [edx], ax
mov [LFB_BASE+edx], ax
shr eax, 16
mov [edx+2], al
mov [LFB_BASE+edx+2], al
.skip:
; add esi, 3 ;[putimg.source_bpp]
add edx, 3
265,7 → 261,7
cmp [ebp], bl
jne .skip
; mov eax, [esi] ; ecx = RRBBGGRR
mov [edx], eax
mov [LFB_BASE+edx], eax
.skip:
; add esi, [putimg.source_bpp]
add edx, 4
308,20 → 304,25
 
;;; mov [novesachecksum], dword 0
pushad
cmp [Screen_Max_X], eax
jb .exit
cmp [Screen_Max_Y], ebx
jb .exit
test edi,1 ; force ?
jnz .forced
 
; not forced:
push ecx ; save 24th bit in case negative pixel wanted
call checkpixel
test ecx,ecx
pop ecx
jnz .exit
 
push eax
mov edx,[_display.width] ; screen x size
imul edx, ebx
add eax, [_WinMapAddress]
movzx edx, byte [eax+edx]
cmp edx, [CURRENT_TASK]
pop eax
jne .exit
 
.forced:
cmp [Screen_Max_X], eax
jb .exit
cmp [Screen_Max_Y], ebx
jb .exit
.ok:
; check if negation
test ecx,0x01000000
jz .noneg
342,11 → 343,9
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
lea edi, [eax+eax*2] ; edi = x*3
mov eax, [esp+32-8+4]
add edi, [LFBAddress]
add edi, ebx ; ebx = where to put pixel in memory
mov [edi], ax
mov [LFB_BASE+ebx+edi], ax
shr eax, 16
mov [edi+2], al
mov [LFB_BASE+ebx+edi+2], al
ret
 
 
357,8 → 356,7
imul ebx, [BytesPerScanLine] ; ebx = y * y multiplier
lea edi, [ebx+eax*4] ; edi = x*4+(y*y multiplier)
mov eax, [esp+32-8+4] ; eax = color
add edi, [LFBAddress] ; ebx = where to put pixel in memory
mov [edi], eax
mov [LFB_BASE+edi], eax
ret
 
;*************************************************
378,7 → 376,7
align 4
__sys_draw_line:
; inc [mouse_pause]
call [disable_mouse]
call [_display.disable_mouse]
 
; draw a line
; eax = HIWORD = x1
568,7 → 566,7
; edi color
vesa20_drawbar:
pushad
call [disable_mouse]
call [_display.disable_mouse]
sub esp, drbar.stack_data
mov [drbar.color], edi
sub edx, ebx
643,13 → 641,12
; shr ebx, 3
imul eax, ebx
add edx, eax
add edx, [LFBAddress]
; pointer to pixel map
mov eax, [drbar.abs_cy]
imul eax, [Screen_Max_X]
add eax, [drbar.abs_cy]
add eax, [drbar.abs_cx]
add eax, WinMapAddress
add eax, [_WinMapAddress]
xchg eax, ebp
; get process number
mov ebx, [CURRENT_TASK]
674,8 → 671,9
.new_x:
cmp byte [ebp], bl
jne .skip
mov [edx], bh
mov [edx + 1], ax
 
mov [LFB_BASE+edx], bh
mov [LFB_BASE+edx + 1], ax
.skip:
; add pixel
add edx, 3
710,7 → 708,8
.new_x:
cmp byte [ebp], bl
jne .skip
mov [edx], eax
 
mov [LFB_BASE+edx], eax
.skip:
; add pixel
add edx, 4
737,62 → 736,9
mov [EGA_counter],1
ret
 
;voodoodbcplimit:
 
; ebp:=(y+Ywin)*(ScreenXSize+1)+(x+Xwin)+AddrBuffer
 
 
; pusha
 
; xor edx,edx
; mov eax,ebp
; mov ebx,[Screen_Max_X] ; Screen_X_size
; inc ebx ; +1
; sub eax,WinMapAddress ; -AddrBuffer
; div ebx ;
; mov ebx,eax ; ebx:=Y
; mov eax,edx ; eax:=X
; call cplimit
 
; test ecx,ecx
; jne dbcpl12
; popa
; clc
; ret
; dbcpl12:
; popa
; stc
; ret
 
 
 
 
;dbcplimit:
 
; pusha
 
; xor edx,edx
; mov ebx,[Screen_Max_X]
; inc ebx
; sub eax,WinMapAddress
; div ebx
; mov ebx,eax
; mov eax,edx
; call cplimit
 
; test ecx,ecx
; jne dbcpl1
; popa
; clc
; ret
; dbcpl1:
; popa
; stc
; ret
 
 
align 4
vesa20_drawbackground_tiled:
call [disable_mouse]
call [_display.disable_mouse]
pushad
; External loop for all y from start to end
mov ebx, [draw_data+32+RECT.top] ; y start
810,10 → 756,11
jz @f
add ebp, eax
@@:
add ebp, [LFBAddress]
add ebp, LFB_BASE
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
call calculate_edi
xchg edi, ebp
add ebp, [_WinMapAddress]
; Now eax=x, ebx=y, edi->output, ebp=offset in WinMapAddress
; 2) Calculate offset in background memory block
push eax
842,7 → 789,7
; esi -> bgr memory, edi -> output
; ebp = offset in WinMapAddress
dp3:
cmp [ebp+WinMapAddress], dl
cmp [ebp], dl
jnz nbgp
movsb
movsb
881,7 → 828,7
 
 
vesa20_drawbackground_stretch:
call [disable_mouse]
call [_display.disable_mouse]
pushad
; Helper variables
; calculate 2^32*(BgrDataWidth-1) mod (ScreenWidth-1)
917,7 → 864,6
jz @f
add ebp, eax
@@:
add ebp, [LFBAddress]
; ebp:=Y*BytesPerScanLine+X*BytesPerPixel+AddrLFB
call calculate_edi
xchg edi, ebp
985,7 → 931,8
; qword [esp+28] = 2^32*(BgrDataHeight-1)/(ScreenHeight-1)
; qword [esp+36] = 2^32*(BgrDataWidth-1)/(ScreenWidth-1)
sdp3a:
cmp [ebp+WinMapAddress], byte 1
mov eax, [_WinMapAddress]
cmp [ebp+eax], byte 1
jnz snbgp
mov eax, [bgr_cur_line+esi]
test ecx, ecx
993,9 → 940,11
mov ebx, [bgr_next_line+esi]
call [overlapping_of_points_ptr]
.novert:
mov [edi], ax
 
mov [LFB_BASE+edi], ax
shr eax, 16
mov [edi+2], al
 
mov [LFB_BASE+edi+2], al
snbgp:
cmp [ScreenBPP], byte 25
sbb edi, -4
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/video/vga.inc
175,8 → 175,8
cld
m13pix:
lodsd
cmp eax,0
je .save_pixel
test eax,eax
jz .save_pixel
push eax
mov ebx,eax
and eax,(128+64+32) ; blue
259,8 → 259,8
mov cl,8
.convert_pixels_to_VGA:
lodsd ; eax = 24bit colour
cmp eax,0
je .end
test eax,eax
jz .end
rol eax,8
mov al,ch
ror eax,8
335,8 → 335,8
pushfd
; edi = address, eax = 24bit colour, ecx = bit no. (modulo 8)
xor edx,edx
cmp eax,0
je .p13cont
test eax,eax
jz .p13cont
cmp al,85
jbe .p13green
or dl,0x01
Property changes:
Modified: svn:keywords
-Revision
\ No newline at end of property
+Rev
\ No newline at end of property
Added: svn:mergeinfo
/kernel/branches/net/vmodeint.inc
24,15 → 24,16
old_screen_height dd ?
endg
 
cmp eax,13 ; CALL VIDEOMODE DRIVER FUNCTIONS
jne .no_vmode_drv_access
; cmp eax,13 ; CALL VIDEOMODE DRIVER FUNCTIONS
dec ebx
jnz .no_vmode_drv_access
pushd [Screen_Max_X] [Screen_Max_Y]
popd [old_screen_height] [old_screen_width]
or eax,-1 ; If driver is absent then eax does not change
call (VMODE_BASE+0x100) ; Entry point of video driver
mov [esp+36],eax
mov [esp+24],ebx
mov [esp+32],ecx
mov [esp+36-4],eax
mov [esp+24-4],ebx
mov [esp+32-4],ecx
; mov [esp+28],edx
mov eax,[old_screen_width]
mov ebx,[old_screen_height]
46,8 → 47,8
sub [screen_workarea.bottom],ebx
 
call repos_windows
mov eax, 0
mov ebx, 0
xor eax,eax
xor ebx,ebx
mov ecx, [Screen_Max_X]
mov edx, [Screen_Max_Y]
call calculatescreen