WebSVN – Kolibri OS – Diff – /programs/cmm/lib/kolibri.h


//CODED by Veliant, Leency, Nable, Pavelyakov. GNU GPL licence.
 
#ifndef INCLUDE_KOLIBRI_H
#define INCLUDE_KOLIBRI_H
 
#pragma option OST
#pragma option ON
#pragma option cri-
#pragma option -CPA
#initallvar 0
#jumptomain FALSE
 
#startaddress 0
 
#code32 TRUE
 
char   os_name[8]   = {'M','E','N','U','E','T','0','1'};
dword  os_version   = 0x00000001;
dword  start_addr   = #______INIT______;
dword  final_addr   = #______STOP______+32;
dword  alloc_mem    = MEMSIZE;
dword  x86esp_reg   = MEMSIZE;
dword  I_Param      = #param;
dword  I_Path       = #program_path;
char param[4096];
char program_path[4096];
 
#define bool      int
 
#define NULL      0
#define OLD      -1
#define true      1
#define false     0
 
//Process Events
#define evReDraw  1
#define evKey     2
#define evButton  3
#define evExit    4
#define evDesktop 5
#define evMouse   6
#define evIPC     7
#define evNetwork 8
#define evDebug   9
 
//Event mask bits for function 40
#define EVM_REDRAW                1b
#define EVM_KEY                  10b
#define EVM_BUTTON              100b
#define EVM_EXIT               1000b
#define EVM_BACKGROUND        10000b
#define EVM_MOUSE            100000b
#define EVM_IPC             1000000b
#define EVM_STACK          10000000b
#define EVM_DEBUG         100000000b
#define EVM_STACK2       1000000000b
#define EVM_MOUSE_FILTER  0x80000000
#define EVM_CURSOR_FILTER 0x40000000
 
//Button options
#define BT_DEL      0x80000000
#define BT_HIDE     0x40000000
#define BT_NOFRAME  0x20000000
 
//-------------------------------------------------------------------------
 
#include "../lib/system.h"
#include "../lib/mouse.h"
#include "../lib/keyboard.h"
 
inline fastcall dword calc(EAX) { return EAX; }
 
:struct raw_image {
	dword w, h, data;
};
 
//------------------------------------------------------------------------------
:dword wait_event_code;
inline fastcall dword WaitEvent()
{
	$mov eax,10
	$int 0x40
	wait_event_code = EAX;
	//if(wait_event_code==evMouse) MOUSE.get();
	//return wait_event_code;
}
 
inline fastcall dword CheckEvent()
{
	$mov eax,11
	$int 0x40
}
 
inline fastcall dword WaitEventTimeout(EBX)
{
	$mov eax,23
	$int 0x40
} 
 
inline fastcall dword SetEventMask(EBX)
{
	$mov eax,40
	$int 0x40
}
 
 
inline fastcall pause(EBX)
{
	$mov eax, 5
	$int 0x40
}
 
inline fastcall word GetButtonID()
{
	$mov eax,17
	$int  0x40
	$shr eax,8
}
 
inline fastcall dword GetFreeRAM()
{
	$mov eax, 18
	$mov ebx, 16
	$int 0x40
	//return eax = free RAM in Kb
}
 
inline fastcall dword LoadDriver(ECX) //ECX - èìÿ äðàéâåðà
{
	$mov eax, 68
	$mov ebx, 16
	$int 0x40
	//return 0 - íåóäà÷à, èíà÷å eax = õýíäë äðàéâåðà 
}
 
inline fastcall dword RuleDriver(ECX) //óêàçàòåëü íà óïðàâëÿþùóþ ñòðóêòóðó
{
	$mov eax, 68
	$mov ebx, 17
	$int 0x40
	//return eax = îïðåäåëÿåòñÿ äðàéâåðîì
}
 
struct proc_info
{
	#define SelfInfo -1
	dword	use_cpu;
	word	pos_in_stack,num_slot,rezerv1;
	unsigned char name[11];
	char	rezerv2;
	dword	adress,use_memory,ID,left,top,width,height;
	word	status_slot,rezerv3;
	dword	work_left,work_top,work_width,work_height;
	char	status_window;
	dword   cwidth,cheight;
	byte    reserved[1024-71-8];
};
 
inline fastcall void GetProcessInfo(EBX, ECX)
{
	$mov eax,9;
	$int  0x40
	DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth
	DSDWORD[EBX+75] = DSDWORD[EBX+46] - skin_height - 4; //set cheight
}
 
inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y
{
	$mov eax,34
	$int 0x40
}
 
inline fastcall int GetProcessSlot( ECX)
{
	EAX = 18;
	EBX = 21;
	$int 0x40
}
 
inline fastcall int GetActiveProcess()
{
	EAX = 18;
	EBX = 7;
	$int 0x40
}
 
:int CheckActiveProcess(int Form_ID)
{
	int id9=GetProcessSlot(Form_ID);
	if (id9==GetActiveProcess()) return 1;
	return 0;
}
 
inline fastcall void ActivateWindow( ECX)
{
	EAX = 18;
	EBX = 3;
	$int 0x40
}
 
inline fastcall int MinimizeWindow()
{
	EAX = 18;
	EBX = 10;
	$int 0x40
}
 
inline fastcall int CreateThread(ECX,EDX)
{
	$mov eax,51
	$mov ebx,1
	$int 0x40
}
 
inline fastcall void SwitchToAnotherThread()
{
	$mov eax,68
	$mov ebx,1
	$int 0x40
}
 
inline fastcall int SendWindowMessage( ECX, EDX)
{
	$mov eax, 72
	$mov ebx, 1
	$int 0x40
}
 
inline fastcall int KillProcess( ECX)
{
	$mov eax,18;
	$mov ebx,18;
	$int 0x40
}
 
#define TURN_OFF 2
#define REBOOT 3
#define KERNEL 4
inline fastcall int ExitSystem( ECX)
{
	$mov eax, 18
	$mov ebx, 9
	$int 0x40
}
 
inline fastcall ExitProcess()
{
	$mov eax,-1;
	$int 0x40
}
 
//------------------------------------------------------------------------------
 
inline fastcall void SetCurDir( ECX)
{
  EAX=30;
  EBX=1;
  $int 0x40
}
 
 
//eax = ÿçûê ñèñòåìû (1=eng, 2=fi, 3=ger, 4=rus)
#define SYS_LANG_ENG 1
#define SYS_LANG_FIN 2
#define SYS_LANG_GER 3
#define SYS_LANG_RUS 4
inline fastcall int GetSystemLanguage()
{
	EAX = 26;
	EBX = 5;
	$int 0x40
}
 
inline fastcall GetSkinHeight()
{
	$push ebx
	$mov  eax,48
	$mov  ebx,4
	$int 0x40
	$pop  ebx
}
 
inline fastcall void SetSystemSkin( ECX)
{
	EAX = 48;
	EBX = 8;
	$int 0x40
}
 
inline fastcall int GetScreenWidth()
{
	$mov eax, 14
	$int 0x40
	$shr eax, 16
}
 
inline fastcall int GetScreenHeight()
{
	$mov eax, 14
	$int 0x40
	$and eax,0x0000FFFF
}
 
inline fastcall int GetClientTop()
{
	$mov eax, 48
	$mov ebx, 5
	$int 0x40
	$mov eax, ebx
	$shr eax, 16
}
 
inline fastcall int GetClientHeight()
{
	$mov eax, 48
	$mov ebx, 5
	$int 0x40
	$mov eax, ebx
}
 
inline fastcall dword LoadLibrary( ECX)
{
	$mov eax, 68 
	$mov ebx, 19
	$int  0x40
}
 
inline fastcall int TestBit( EAX, CL)
{
	$shr eax,cl
	$and eax,1
}
 
//------------------------------------------------------------------------------
 
:void DefineAndDrawWindow(dword _x, _y, _w, _h, _window_type, _bgcolor, _title, _flags)
{
	EAX = 12;              // function 12:tell os about windowdraw
	EBX = 1;
	$int 0x40
	
	$xor EAX,EAX
	EBX = _x << 16 + _w; 
	ECX = _y << 16 + _h;
	EDX = _window_type << 24 | _bgcolor;
	EDI = _title;
	ESI = _flags;
	$int 0x40
 
 
	EAX = 12;              // function 12:tell os about windowdraw
	EBX = 2;
	$int 0x40
}
 
inline fastcall MoveSize( EBX,ECX,EDX,ESI)
{
	$mov eax, 67
	$int 0x40
}
 
inline fastcall void DrawTitle( ECX)
{
	EAX = 71;
	EBX = 1;
	$int 0x40;
}
 
// @EDX is a process id, -1 for self
// @ESI is a new LayerBehaviour
// @RETURN: EAX, 0 is fail, 1 is success
#define ZPOS_DESKTOP     -2
#define ZPOS_ALWAYS_BACK -1
#define ZPOS_NORMAL      0
#define ZPOS_ALWAYS_TOP  1
inline fastcall dword SetWindowLayerBehaviour(EDX, ESI)
{
	EAX = 18;
	EBX = 25;
	ECX = 2;
	$int 64
}
 
:void WriteTextB(dword x,y,byte fontType, dword color, str_offset)
{
	EAX = 4;
	EBX = x<<16+y;
	ECX = fontType<<24+color;
	EDX = str_offset;
	ESI = 0;
	$int 0x40;
	$add ebx, 1<<16
	$int 0x40
}
 
:void WriteText(dword x,y,byte fontType, dword color, str_offset)
{
	EAX = 4;
	EBX = x<<16+y;
	ECX = fontType<<24+color;
	EDX = str_offset;
	$int 0x40;
}
 
:dword WriteBufText(dword x,y,byte fontType, dword color, str_offset, buf_offset)
{
	EAX = 4;
	EBX = x<<16+y;
	ECX = fontType<<24+color;
	EDX = str_offset;
	EDI = buf_offset;
	$int 0x40;
}
 
:void WriteNumber(dword x,y,byte fontType, dword color, count, number_or_offset)
{
	EAX = 47;
	EBX = count<<16;
	ECX = number_or_offset;
	EDX = x<<16+y;
	ESI = fontType<<24+color;
	$int 0x40;
}
 
:void CopyScreen(dword dst_offset, x, y, w, h)
{
  EAX = 36;
  EBX = dst_offset;
  ECX = w << 16 + h;
  EDX = x << 16 + y;
  $int  0x40;
}
 
:dword GetPixelColorFromScreen(dword _x, _y)
{
	EAX = 35;
	EBX = _y * screen.width + _x;
	$int 64
}
 
:void _PutImage(dword x,y, w,h, data_offset)
{
	EAX = 7;
	EBX = data_offset;
	ECX = w<<16+h;
	EDX = x<<16+y;
	$int 0x40
}
 
void PutPaletteImage(dword EBX,w,h,x,y,ESI,EDI)
{
	EAX = 65;
	ECX = w<<16+h;
	EDX = x<<16+y;
	EBP = 0;
	$int 0x40
}
 
inline fastcall void PutPixel( EBX,ECX,EDX)
{
  EAX=1;
  $int 0x40
}
 
:void DrawBar(dword x,y,w,h,color)
{
	if (h<=0) || (h>60000) || (w<=0) || (w>60000) return; //bad boy :)
	EAX = 13;
	EBX = x<<16+w;
	ECX = y<<16+h;
	EDX = color;
	$int 0x40
}
 
void DefineButton(dword x,y,w,h,EDX,ESI)
{
	EAX = 8;
	$push edx
	EDX += BT_DEL;
	$int 0x40;
	$pop edx
	EBX = x<<16+w;
	ECX = y<<16+h;
	$int 0x40
}
 
inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)
{
	EAX = 18;
	EBX = 22;
	ECX = 3;
	EDX = ID_REFRESH;
	$int 0x40
	EAX = 18;
	EBX = 3;
	EDX = ID_ACTIVE;
	$int 0x40
}
 
:void UnsafeDefineButton(dword x,y,w,h,id,color)
{
	EAX = 8;
	EBX = x<<16+w;
	ECX = y<<16+h;
	EDX = id;
	ESI = color;
	$int 0x40
}
 
void DefineDragableWindow(dword _x, _y, _w, _h)
{
	DefineAndDrawWindow(_x, _y, _w, _h, 0x41,0x000000,NULL,0b);
}
 
:void EventDragWindow()
{
	dword tmp_x,tmp_y;
	dword z1,z2;
	tmp_x = mouse.x;
	tmp_y = mouse.y;
	do {
		mouse.get();
		if (tmp_x!=mouse.x) || (tmp_y!=mouse.y) 
		{
			z1 = Form.left + mouse.x - tmp_x;
			z2 = Form.top + mouse.y - tmp_y;
			if(z1<=10) || (z1>20000) z1=0; else if(z1>screen.width-Form.width-10)z1=screen.width-Form.width;
			if(z2<=10) || (z2>20000) z2=0; else if(z2>screen.height-Form.height-10)z2=screen.height-Form.height;
			MoveSize(z1 , z2, OLD, OLD);
			draw_window();
		}
		pause(1);
	} while (mouse.lkm);
}
 
:void DefineHiddenButton(dword _x, _y, _w, _h, _id)
{
	DefineButton(_x, _y, _w, _h, _id + BT_HIDE, 0);
}
 
inline fastcall void DeleteButton( EDX)
{
	EAX = 8;
	EDX += BT_DEL;
	$int 0x40
}
 
inline fastcall dword GetStartTime()
{
	$mov eax,26
	$mov ebx,9
	$int 0x40
}
 
:dword X_EventRedrawWindow,Y_EventRedrawWindow;
:void _EventRedrawWindow()
{
	loop()switch(WaitEvent())
	{
		case evReDraw:
			DefineAndDrawWindow(X_EventRedrawWindow,Y_EventRedrawWindow,100,1,0x34,0xFFFFFF,NULL,0);
			pause(10);
			ExitProcess();
			break;
	}
}
:char REDRAW_BUFF_EVENT_[4096];
:void EventRedrawWindow(dword x,y)
{
	X_EventRedrawWindow = x;
	Y_EventRedrawWindow = y;
	CreateThread(#_EventRedrawWindow,#REDRAW_BUFF_EVENT_+4092);
}
 
:struct obj
{
	dword x,y,w,h;
	void set_size();
};
 
:void obj::set_size(dword _x, _y, _w, _h)
{
	x=_x; 
	y=_y;
	w=_w;
	h=_h;
}
 
:struct _screen
{
	dword width,height;
} screen;
 
:byte skin_height;
 
:void DrawDate(dword x, y, color, in_date)
{
	EDI = in_date;
	EAX = 47;
	EBX = 2<<16;
	EDX = x<<16+y;
	ESI = 0x90<<24+color;
	ECX = EDI.date.day;
	$int 0x40;
	EDX += 20<<16;
	ECX = EDI.date.month;
	$int 0x40;
	EDX += 20<<16;
	EBX = 4<<16;
	ECX = EDI.date.year;
	$int 0x40;
	DrawBar(x+17,y+10,2,2,color);
	DrawBar(x+37,y+10,2,2,color);
}
 
:void __path_name__(dword BUF,PATH)
{
	dword beg = PATH;
	dword pos = PATH;
	dword sav = PATH;
	dword i;
	while(DSBYTE[pos])
	{
		if(DSBYTE[pos]=='/')sav = pos;
		pos++;
	}
	i = sav-beg;
	while(i)
	{
		DSBYTE[BUF] = DSBYTE[beg];
		beg++;
		BUF++;
		i--;
	}
	/*while(DSBYTE[beg])
	{
		DSBYTE[BUF1] = DSBYTE[beg];
		beg++;
		BUF1++;
	}*/
	//DSBYTE[BUF1] = 0;
	DSBYTE[BUF] = 0;
}
char __BUF_DIR__[4096];
:struct SELF
{
	dword dir;
	dword file;
	dword path;
} self;
 
dword __generator;  // random number generator - äëÿ ãåíåðàöèè ñëó÷àéíûõ ÷èñåë
 
:dword program_path_length;
 
//The initialization of the initial data before running
void ______INIT______()
{
	//if (program_path[0]!='/') I_Path++;
	
	self.dir = #__BUF_DIR__;
	self.file = 0;
	self.path = I_Path;
	__path_name__(#__BUF_DIR__,I_Path);
	
	skin_height   = GetSkinHeight();
	screen.width  = GetScreenWidth()+1;
	screen.height = GetScreenHeight()+1;
	
	DOUBLE_CLICK_DELAY = GetMouseDoubleClickDelay();
	__generator = GetStartTime();
	
	mem_init();
 
 
	main();
	ExitProcess();
}
______STOP______:
#endif
 
#ifndef INCLUDE_MEM_H
#include "../lib/mem.h"
#endif
 
#ifndef INCLUDE_DEBUG_H
#include "../lib/debug.h"
#endif
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

Rev 7031	Rev 7051
1	//CODED by Veliant, Leency, Nable, Pavelyakov. GNU GPL licence.	1	//CODED by Veliant, Leency, Nable, Pavelyakov. GNU GPL licence.
2		2
3	#ifndef INCLUDE_KOLIBRI_H	3	#ifndef INCLUDE_KOLIBRI_H
4	#define INCLUDE_KOLIBRI_H	4	#define INCLUDE_KOLIBRI_H
5		5
6	#pragma option OST	6	#pragma option OST
7	#pragma option ON	7	#pragma option ON
8	#pragma option cri-	8	#pragma option cri-
9	#pragma option -CPA	9	#pragma option -CPA
10	#initallvar 0	10	#initallvar 0
11	#jumptomain FALSE	11	#jumptomain FALSE
12		12
13	#startaddress 0	13	#startaddress 0
14		14
15	#code32 TRUE	15	#code32 TRUE
16		16
17	char os_name[8] = {'M','E','N','U','E','T','0','1'};	17	char os_name[8] = {'M','E','N','U','E','T','0','1'};
18	dword os_version = 0x00000001;	18	dword os_version = 0x00000001;
19	dword start_addr = #______INIT______;	19	dword start_addr = #______INIT______;
20	dword final_addr = #______STOP______+32;	20	dword final_addr = #______STOP______+32;
21	dword alloc_mem = MEMSIZE;	21	dword alloc_mem = MEMSIZE;
22	dword x86esp_reg = MEMSIZE;	22	dword x86esp_reg = MEMSIZE;
23	dword I_Param = #param;	23	dword I_Param = #param;
24	dword I_Path = #program_path;	24	dword I_Path = #program_path;
25	char param[4096];	25	char param[4096];
26	char program_path[4096];	26	char program_path[4096];
27		27
28	#define bool int	28	#define bool int
29		29
30	#define NULL 0	30	#define NULL 0
31	#define OLD -1	31	#define OLD -1
32	#define true 1	32	#define true 1
33	#define false 0	33	#define false 0
34		34
35	//Process Events	35	//Process Events
36	#define evReDraw 1	36	#define evReDraw 1
37	#define evKey 2	37	#define evKey 2
38	#define evButton 3	38	#define evButton 3
39	#define evExit 4	39	#define evExit 4
40	#define evDesktop 5	40	#define evDesktop 5
41	#define evMouse 6	41	#define evMouse 6
42	#define evIPC 7	42	#define evIPC 7
43	#define evNetwork 8	43	#define evNetwork 8
44	#define evDebug 9	44	#define evDebug 9
45		45
46	//Event mask bits for function 40	46	//Event mask bits for function 40
47	#define EVM_REDRAW 1b	47	#define EVM_REDRAW 1b
48	#define EVM_KEY 10b	48	#define EVM_KEY 10b
49	#define EVM_BUTTON 100b	49	#define EVM_BUTTON 100b
50	#define EVM_EXIT 1000b	50	#define EVM_EXIT 1000b
51	#define EVM_BACKGROUND 10000b	51	#define EVM_BACKGROUND 10000b
52	#define EVM_MOUSE 100000b	52	#define EVM_MOUSE 100000b
53	#define EVM_IPC 1000000b	53	#define EVM_IPC 1000000b
54	#define EVM_STACK 10000000b	54	#define EVM_STACK 10000000b
55	#define EVM_DEBUG 100000000b	55	#define EVM_DEBUG 100000000b
56	#define EVM_STACK2 1000000000b	56	#define EVM_STACK2 1000000000b
57	#define EVM_MOUSE_FILTER 0x80000000	57	#define EVM_MOUSE_FILTER 0x80000000
58	#define EVM_CURSOR_FILTER 0x40000000	58	#define EVM_CURSOR_FILTER 0x40000000
59		59
60	//Button options	60	//Button options
61	#define BT_DEL 0x80000000	61	#define BT_DEL 0x80000000
62	#define BT_HIDE 0x40000000	62	#define BT_HIDE 0x40000000
63	#define BT_NOFRAME 0x20000000	63	#define BT_NOFRAME 0x20000000
64		64
65	//-------------------------------------------------------------------------	65	//-------------------------------------------------------------------------
66		66
67	#include "../lib/system.h"	67	#include "../lib/system.h"
68	#include "../lib/mouse.h"	68	#include "../lib/mouse.h"
69	#include "../lib/keyboard.h"	69	#include "../lib/keyboard.h"
70		70
71	inline fastcall dword calc(EAX) { return EAX; }	71	inline fastcall dword calc(EAX) { return EAX; }
72		72
73	:struct raw_image {	73	:struct raw_image {
74	dword w, h, data;	74	dword w, h, data;
75	};	75	};
76		76
77	//------------------------------------------------------------------------------	77	//------------------------------------------------------------------------------
78	:dword wait_event_code;	78	:dword wait_event_code;
79	inline fastcall dword WaitEvent()	79	inline fastcall dword WaitEvent()
80	{	80	{
81	$mov eax,10	81	$mov eax,10
82	$int 0x40	82	$int 0x40
83	wait_event_code = EAX;	83	wait_event_code = EAX;
84	//if(wait_event_code==evMouse) MOUSE.get();	84	//if(wait_event_code==evMouse) MOUSE.get();
85	//return wait_event_code;	85	//return wait_event_code;
86	}	86	}
87		87
88	inline fastcall dword CheckEvent()	88	inline fastcall dword CheckEvent()
89	{	89	{
90	$mov eax,11	90	$mov eax,11
91	$int 0x40	91	$int 0x40
92	}	92	}
93		93
94	inline fastcall dword WaitEventTimeout(EBX)	94	inline fastcall dword WaitEventTimeout(EBX)
95	{	95	{
96	$mov eax,23	96	$mov eax,23
97	$int 0x40	97	$int 0x40
98	}	98	}
99		99
100	inline fastcall dword SetEventMask(EBX)	100	inline fastcall dword SetEventMask(EBX)
101	{	101	{
102	$mov eax,40	102	$mov eax,40
103	$int 0x40	103	$int 0x40
104	}	104	}
105		105
106		106
107	inline fastcall pause(EBX)	107	inline fastcall pause(EBX)
108	{	108	{
109	$mov eax, 5	109	$mov eax, 5
110	$int 0x40	110	$int 0x40
111	}	111	}
112		112
113	inline fastcall word GetButtonID()	113	inline fastcall word GetButtonID()
114	{	114	{
115	$mov eax,17	115	$mov eax,17
116	$int 0x40	116	$int 0x40
117	$shr eax,8	117	$shr eax,8
118	}	118	}
119		119
120	inline fastcall dword GetFreeRAM()	120	inline fastcall dword GetFreeRAM()
121	{	121	{
122	$mov eax, 18	122	$mov eax, 18
123	$mov ebx, 16	123	$mov ebx, 16
124	$int 0x40	124	$int 0x40
125	//return eax = free RAM in Kb	125	//return eax = free RAM in Kb
126	}	126	}
127		127
128	inline fastcall dword LoadDriver(ECX) //ECX - èìÿ äðàéâåðà	128	inline fastcall dword LoadDriver(ECX) //ECX - èìÿ äðàéâåðà
129	{	129	{
130	$mov eax, 68	130	$mov eax, 68
131	$mov ebx, 16	131	$mov ebx, 16
132	$int 0x40	132	$int 0x40
133	//return 0 - íåóäà÷à, èíà÷å eax = õýíäë äðàéâåðà	133	//return 0 - íåóäà÷à, èíà÷å eax = õýíäë äðàéâåðà
134	}	134	}
135		135
136	inline fastcall dword RuleDriver(ECX) //óêàçàòåëü íà óïðàâëÿþùóþ ñòðóêòóðó	136	inline fastcall dword RuleDriver(ECX) //óêàçàòåëü íà óïðàâëÿþùóþ ñòðóêòóðó
137	{	137	{
138	$mov eax, 68	138	$mov eax, 68
139	$mov ebx, 17	139	$mov ebx, 17
140	$int 0x40	140	$int 0x40
141	//return eax = îïðåäåëÿåòñÿ äðàéâåðîì	141	//return eax = îïðåäåëÿåòñÿ äðàéâåðîì
142	}	142	}
143		143
144	struct proc_info	144	struct proc_info
145	{	145	{
146	#define SelfInfo -1	146	#define SelfInfo -1
147	dword use_cpu;	147	dword use_cpu;
148	word pos_in_stack,num_slot,rezerv1;	148	word pos_in_stack,num_slot,rezerv1;
149	unsigned char name[11];	149	unsigned char name[11];
150	char rezerv2;	150	char rezerv2;
151	dword adress,use_memory,ID,left,top,width,height;	151	dword adress,use_memory,ID,left,top,width,height;
152	word status_slot,rezerv3;	152	word status_slot,rezerv3;
153	dword work_left,work_top,work_width,work_height;	153	dword work_left,work_top,work_width,work_height;
154	char status_window;	154	char status_window;
155	dword cwidth,cheight;	155	dword cwidth,cheight;
156	byte reserved[1024-71-8];	156	byte reserved[1024-71-8];
157	};	157	};
158		158
159	inline fastcall void GetProcessInfo(EBX, ECX)	159	inline fastcall void GetProcessInfo(EBX, ECX)
160	{	160	{
161	$mov eax,9;	161	$mov eax,9;
162	$int 0x40	162	$int 0x40
163	DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth	163	DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth
164	DSDWORD[EBX+75] = DSDWORD[EBX+46] - GetSkinHeight() - 4; //set cheight	164	DSDWORD[EBX+75] = DSDWORD[EBX+46] - skin_height - 4; //set cheight
165	}	165	}
166		166
167	inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y	167	inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y
168	{	168	{
169	$mov eax,34	169	$mov eax,34
170	$int 0x40	170	$int 0x40
171	}	171	}
172		172
173	inline fastcall int GetProcessSlot( ECX)	173	inline fastcall int GetProcessSlot( ECX)
174	{	174	{
175	EAX = 18;	175	EAX = 18;
176	EBX = 21;	176	EBX = 21;
177	$int 0x40	177	$int 0x40
178	}	178	}
179		179
180	inline fastcall int GetActiveProcess()	180	inline fastcall int GetActiveProcess()
181	{	181	{
182	EAX = 18;	182	EAX = 18;
183	EBX = 7;	183	EBX = 7;
184	$int 0x40	184	$int 0x40
185	}	185	}
186		186
187	:int CheckActiveProcess(int Form_ID)	187	:int CheckActiveProcess(int Form_ID)
188	{	188	{
189	int id9=GetProcessSlot(Form_ID);	189	int id9=GetProcessSlot(Form_ID);
190	if (id9==GetActiveProcess()) return 1;	190	if (id9==GetActiveProcess()) return 1;
191	return 0;	191	return 0;
192	}	192	}
193		193
194	inline fastcall void ActivateWindow( ECX)	194	inline fastcall void ActivateWindow( ECX)
195	{	195	{
196	EAX = 18;	196	EAX = 18;
197	EBX = 3;	197	EBX = 3;
198	$int 0x40	198	$int 0x40
199	}	199	}
200		200
201	inline fastcall int MinimizeWindow()	201	inline fastcall int MinimizeWindow()
202	{	202	{
203	EAX = 18;	203	EAX = 18;
204	EBX = 10;	204	EBX = 10;
205	$int 0x40	205	$int 0x40
206	}	206	}
207		207
208	inline fastcall int CreateThread(ECX,EDX)	208	inline fastcall int CreateThread(ECX,EDX)
209	{	209	{
210	$mov eax,51	210	$mov eax,51
211	$mov ebx,1	211	$mov ebx,1
212	$int 0x40	212	$int 0x40
213	}	213	}
214		214
215	inline fastcall void SwitchToAnotherThread()	215	inline fastcall void SwitchToAnotherThread()
216	{	216	{
217	$mov eax,68	217	$mov eax,68
218	$mov ebx,1	218	$mov ebx,1
219	$int 0x40	219	$int 0x40
220	}	220	}
221		221
222	inline fastcall int SendWindowMessage( ECX, EDX)	222	inline fastcall int SendWindowMessage( ECX, EDX)
223	{	223	{
224	$mov eax, 72	224	$mov eax, 72
225	$mov ebx, 1	225	$mov ebx, 1
226	$int 0x40	226	$int 0x40
227	}	227	}
228		228
229	inline fastcall int KillProcess( ECX)	229	inline fastcall int KillProcess( ECX)
230	{	230	{
231	$mov eax,18;	231	$mov eax,18;
232	$mov ebx,18;	232	$mov ebx,18;
233	$int 0x40	233	$int 0x40
234	}	234	}
235		235
236	#define TURN_OFF 2	236	#define TURN_OFF 2
237	#define REBOOT 3	237	#define REBOOT 3
238	#define KERNEL 4	238	#define KERNEL 4
239	inline fastcall int ExitSystem( ECX)	239	inline fastcall int ExitSystem( ECX)
240	{	240	{
241	$mov eax, 18	241	$mov eax, 18
242	$mov ebx, 9	242	$mov ebx, 9
243	$int 0x40	243	$int 0x40
244	}	244	}
245		245
246	inline fastcall ExitProcess()	246	inline fastcall ExitProcess()
247	{	247	{
248	$mov eax,-1;	248	$mov eax,-1;
249	$int 0x40	249	$int 0x40
250	}	250	}
251		251
252	//------------------------------------------------------------------------------	252	//------------------------------------------------------------------------------
253		253
254	inline fastcall void SetCurDir( ECX)	254	inline fastcall void SetCurDir( ECX)
255	{	255	{
256	EAX=30;	256	EAX=30;
257	EBX=1;	257	EBX=1;
258	$int 0x40	258	$int 0x40
259	}	259	}
260		260
261		261
262	//eax = ÿçûê ñèñòåìû (1=eng, 2=fi, 3=ger, 4=rus)	262	//eax = ÿçûê ñèñòåìû (1=eng, 2=fi, 3=ger, 4=rus)
263	#define SYS_LANG_ENG 1	263	#define SYS_LANG_ENG 1
264	#define SYS_LANG_FIN 2	264	#define SYS_LANG_FIN 2
265	#define SYS_LANG_GER 3	265	#define SYS_LANG_GER 3
266	#define SYS_LANG_RUS 4	266	#define SYS_LANG_RUS 4
267	inline fastcall int GetSystemLanguage()	267	inline fastcall int GetSystemLanguage()
268	{	268	{
269	EAX = 26;	269	EAX = 26;
270	EBX = 5;	270	EBX = 5;
271	$int 0x40	271	$int 0x40
272	}	272	}
273		273
274	inline fastcall GetSkinHeight()	274	inline fastcall GetSkinHeight()
275	{	275	{
276	$push ebx	276	$push ebx
277	$mov eax,48	277	$mov eax,48
278	$mov ebx,4	278	$mov ebx,4
279	$int 0x40	279	$int 0x40
280	$pop ebx	280	$pop ebx
281	}	281	}
282		282
283	inline fastcall void SetSystemSkin( ECX)	283	inline fastcall void SetSystemSkin( ECX)
284	{	284	{
285	EAX = 48;	285	EAX = 48;
286	EBX = 8;	286	EBX = 8;
287	$int 0x40	287	$int 0x40
288	}	288	}
289		289
290	inline fastcall int GetScreenWidth()	290	inline fastcall int GetScreenWidth()
291	{	291	{
292	$mov eax, 14	292	$mov eax, 14
293	$int 0x40	293	$int 0x40
294	$shr eax, 16	294	$shr eax, 16
295	}	295	}
296		296
297	inline fastcall int GetScreenHeight()	297	inline fastcall int GetScreenHeight()
298	{	298	{
299	$mov eax, 14	299	$mov eax, 14
300	$int 0x40	300	$int 0x40
301	$and eax,0x0000FFFF	301	$and eax,0x0000FFFF
302	}	302	}
303		303
304	inline fastcall int GetClientTop()	304	inline fastcall int GetClientTop()
305	{	305	{
306	$mov eax, 48	306	$mov eax, 48
307	$mov ebx, 5	307	$mov ebx, 5
308	$int 0x40	308	$int 0x40
309	$mov eax, ebx	309	$mov eax, ebx
310	$shr eax, 16	310	$shr eax, 16
311	}	311	}
312		312
313	inline fastcall int GetClientHeight()	313	inline fastcall int GetClientHeight()
314	{	314	{
315	$mov eax, 48	315	$mov eax, 48
316	$mov ebx, 5	316	$mov ebx, 5
317	$int 0x40	317	$int 0x40
318	$mov eax, ebx	318	$mov eax, ebx
319	}	319	}
320		320
321	inline fastcall dword LoadLibrary( ECX)	321	inline fastcall dword LoadLibrary( ECX)
322	{	322	{
323	$mov eax, 68	323	$mov eax, 68
324	$mov ebx, 19	324	$mov ebx, 19
325	$int 0x40	325	$int 0x40
326	}	326	}
327		327
328	inline fastcall int TestBit( EAX, CL)	328	inline fastcall int TestBit( EAX, CL)
329	{	329	{
330	$shr eax,cl	330	$shr eax,cl
331	$and eax,1	331	$and eax,1
332	}	332	}
333		333
334	//------------------------------------------------------------------------------	334	//------------------------------------------------------------------------------
335		335
336	:void DefineAndDrawWindow(dword _x, _y, _w, _h, _window_type, _bgcolor, _title, _flags)	336	:void DefineAndDrawWindow(dword _x, _y, _w, _h, _window_type, _bgcolor, _title, _flags)
337	{	337	{
338	EAX = 12; // function 12:tell os about windowdraw	338	EAX = 12; // function 12:tell os about windowdraw
339	EBX = 1;	339	EBX = 1;
340	$int 0x40	340	$int 0x40
341		341
342	$xor EAX,EAX	342	$xor EAX,EAX
343	EBX = _x << 16 + _w;	343	EBX = _x << 16 + _w;
344	ECX = _y << 16 + _h;	344	ECX = _y << 16 + _h;
345	EDX = _window_type << 24 \| _bgcolor;	345	EDX = _window_type << 24 \| _bgcolor;
346	EDI = _title;	346	EDI = _title;
347	ESI = _flags;	347	ESI = _flags;
348	$int 0x40	348	$int 0x40
349		349
350		350
351	EAX = 12; // function 12:tell os about windowdraw	351	EAX = 12; // function 12:tell os about windowdraw
352	EBX = 2;	352	EBX = 2;
353	$int 0x40	353	$int 0x40
354	}	354	}
355		355
356	inline fastcall MoveSize( EBX,ECX,EDX,ESI)	356	inline fastcall MoveSize( EBX,ECX,EDX,ESI)
357	{	357	{
358	$mov eax, 67	358	$mov eax, 67
359	$int 0x40	359	$int 0x40
360	}	360	}
361		361
362	inline fastcall void DrawTitle( ECX)	362	inline fastcall void DrawTitle( ECX)
363	{	363	{
364	EAX = 71;	364	EAX = 71;
365	EBX = 1;	365	EBX = 1;
366	$int 0x40;	366	$int 0x40;
367	}	367	}
368		368
369	// @EDX is a process id, -1 for self	369	// @EDX is a process id, -1 for self
370	// @ESI is a new LayerBehaviour	370	// @ESI is a new LayerBehaviour
371	// @RETURN: EAX, 0 is fail, 1 is success	371	// @RETURN: EAX, 0 is fail, 1 is success
372	#define ZPOS_DESKTOP -2	372	#define ZPOS_DESKTOP -2
373	#define ZPOS_ALWAYS_BACK -1	373	#define ZPOS_ALWAYS_BACK -1
374	#define ZPOS_NORMAL 0	374	#define ZPOS_NORMAL 0
375	#define ZPOS_ALWAYS_TOP 1	375	#define ZPOS_ALWAYS_TOP 1
376	inline fastcall dword SetWindowLayerBehaviour(EDX, ESI)	376	inline fastcall dword SetWindowLayerBehaviour(EDX, ESI)
377	{	377	{
378	EAX = 18;	378	EAX = 18;
379	EBX = 25;	379	EBX = 25;
380	ECX = 2;	380	ECX = 2;
381	$int 64	381	$int 64
382	}	382	}
383		383
384	:void WriteTextB(dword x,y,byte fontType, dword color, str_offset)	384	:void WriteTextB(dword x,y,byte fontType, dword color, str_offset)
385	{	385	{
386	EAX = 4;	386	EAX = 4;
387	EBX = x<<16+y;	387	EBX = x<<16+y;
388	ECX = fontType<<24+color;	388	ECX = fontType<<24+color;
389	EDX = str_offset;	389	EDX = str_offset;
390	ESI = 0;	390	ESI = 0;
391	$int 0x40;	391	$int 0x40;
392	$add ebx, 1<<16	392	$add ebx, 1<<16
393	$int 0x40	393	$int 0x40
394	}	394	}
395		395
396	:void WriteText(dword x,y,byte fontType, dword color, str_offset)	396	:void WriteText(dword x,y,byte fontType, dword color, str_offset)
397	{	397	{
398	EAX = 4;	398	EAX = 4;
399	EBX = x<<16+y;	399	EBX = x<<16+y;
400	ECX = fontType<<24+color;	400	ECX = fontType<<24+color;
401	EDX = str_offset;	401	EDX = str_offset;
402	$int 0x40;	402	$int 0x40;
403	}	403	}
404		404
405	:dword WriteBufText(dword x,y,byte fontType, dword color, str_offset, buf_offset)	405	:dword WriteBufText(dword x,y,byte fontType, dword color, str_offset, buf_offset)
406	{	406	{
407	EAX = 4;	407	EAX = 4;
408	EBX = x<<16+y;	408	EBX = x<<16+y;
409	ECX = fontType<<24+color;	409	ECX = fontType<<24+color;
410	EDX = str_offset;	410	EDX = str_offset;
411	EDI = buf_offset;	411	EDI = buf_offset;
412	$int 0x40;	412	$int 0x40;
413	}	413	}
414		414
415	:void WriteNumber(dword x,y,byte fontType, dword color, count, number_or_offset)	415	:void WriteNumber(dword x,y,byte fontType, dword color, count, number_or_offset)
416	{	416	{
417	EAX = 47;	417	EAX = 47;
418	EBX = count<<16;	418	EBX = count<<16;
419	ECX = number_or_offset;	419	ECX = number_or_offset;
420	EDX = x<<16+y;	420	EDX = x<<16+y;
421	ESI = fontType<<24+color;	421	ESI = fontType<<24+color;
422	$int 0x40;	422	$int 0x40;
423	}	423	}
424		424
425	:void CopyScreen(dword dst_offset, x, y, w, h)	425	:void CopyScreen(dword dst_offset, x, y, w, h)
426	{	426	{
427	EAX = 36;	427	EAX = 36;
428	EBX = dst_offset;	428	EBX = dst_offset;
429	ECX = w << 16 + h;	429	ECX = w << 16 + h;
430	EDX = x << 16 + y;	430	EDX = x << 16 + y;
431	$int 0x40;	431	$int 0x40;
432	}	432	}
433		433
434	:dword GetPixelColorFromScreen(dword _x, _y)	434	:dword GetPixelColorFromScreen(dword _x, _y)
435	{	435	{
436	EAX = 35;	436	EAX = 35;
437	EBX = _y * screen.width + _x;	437	EBX = _y * screen.width + _x;
438	$int 64	438	$int 64
439	}	439	}
440		440
441	:void _PutImage(dword x,y, w,h, data_offset)	441	:void _PutImage(dword x,y, w,h, data_offset)
442	{	442	{
443	EAX = 7;	443	EAX = 7;
444	EBX = data_offset;	444	EBX = data_offset;
445	ECX = w<<16+h;	445	ECX = w<<16+h;
446	EDX = x<<16+y;	446	EDX = x<<16+y;
447	$int 0x40	447	$int 0x40
448	}	448	}
449		449
450	void PutPaletteImage(dword EBX,w,h,x,y,ESI,EDI)	450	void PutPaletteImage(dword EBX,w,h,x,y,ESI,EDI)
451	{	451	{
452	EAX = 65;	452	EAX = 65;
453	ECX = w<<16+h;	453	ECX = w<<16+h;
454	EDX = x<<16+y;	454	EDX = x<<16+y;
455	EBP = 0;	455	EBP = 0;
456	$int 0x40	456	$int 0x40
457	}	457	}
458		458
459	inline fastcall void PutPixel( EBX,ECX,EDX)	459	inline fastcall void PutPixel( EBX,ECX,EDX)
460	{	460	{
461	EAX=1;	461	EAX=1;
462	$int 0x40	462	$int 0x40
463	}	463	}
464		464
465	:void DrawBar(dword x,y,w,h,color)	465	:void DrawBar(dword x,y,w,h,color)
466	{	466	{
467	if (h<=0) \|\| (h>60000) \|\| (w<=0) \|\| (w>60000) return; //bad boy :)	467	if (h<=0) \|\| (h>60000) \|\| (w<=0) \|\| (w>60000) return; //bad boy :)
468	EAX = 13;	468	EAX = 13;
469	EBX = x<<16+w;	469	EBX = x<<16+w;
470	ECX = y<<16+h;	470	ECX = y<<16+h;
471	EDX = color;	471	EDX = color;
472	$int 0x40	472	$int 0x40
473	}	473	}
474		474
475	void DefineButton(dword x,y,w,h,EDX,ESI)	475	void DefineButton(dword x,y,w,h,EDX,ESI)
476	{	476	{
477	EAX = 8;	477	EAX = 8;
478	$push edx	478	$push edx
479	EDX += BT_DEL;	479	EDX += BT_DEL;
480	$int 0x40;	480	$int 0x40;
481	$pop edx	481	$pop edx
482	EBX = x<<16+w;	482	EBX = x<<16+w;
483	ECX = y<<16+h;	483	ECX = y<<16+h;
484	$int 0x40	484	$int 0x40
485	}	485	}
486		486
487	inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)	487	inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)
488	{	488	{
489	EAX = 18;	489	EAX = 18;
490	EBX = 22;	490	EBX = 22;
491	ECX = 3;	491	ECX = 3;
492	EDX = ID_REFRESH;	492	EDX = ID_REFRESH;
493	$int 0x40	493	$int 0x40
494	EAX = 18;	494	EAX = 18;
495	EBX = 3;	495	EBX = 3;
496	EDX = ID_ACTIVE;	496	EDX = ID_ACTIVE;
497	$int 0x40	497	$int 0x40
498	}	498	}
499		499
500	:void UnsafeDefineButton(dword x,y,w,h,id,color)	500	:void UnsafeDefineButton(dword x,y,w,h,id,color)

Subversion Repositories Kolibri OS

(root)/programs/cmm/lib/kolibri.h @ 7089 – Rev 7031 → 7051