WebSVN – Kolibri OS – Diff – /programs/develop/cedit/SRC/KolibriOS.ob07


﻿(*
    Copyright 2021-2023 Anton Krotov
 
    This file is part of CEdit.
 
    CEdit is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    CEdit is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with CEdit. If not, see .
*)
 
MODULE KolibriOS;
 
IMPORT
	KOSAPI, SYSTEM, U := Utils;
 
CONST
	fontWidth* = 8;
	fontHeight* = 16;
 
VAR
 
	colors*: RECORD
		rsrvd,
		taskbar,
		dark*,
		light*,
		window_title*,
		work*,
		button*,
		button_text*,
		work_text*,
		line*: INTEGER
	END;
 
 
PROCEDURE CreateWindow* (x, y, w, h, color, style, hcolor, hstyle: INTEGER; htext: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc6(0, x*65536 + w, y*65536 + h, color + LSL(style, 24), hcolor + LSL(hstyle, 24), SYSTEM.ADR(htext[0]))
END CreateWindow;
 
 
PROCEDURE BeginDraw*;
BEGIN
	KOSAPI.sysfunc2(12, 1)
END BeginDraw;
 
 
PROCEDURE EndDraw*;
BEGIN
	KOSAPI.sysfunc2(12, 2)
END EndDraw;
 
 
PROCEDURE EventTimeout* (t: INTEGER): INTEGER;
	RETURN KOSAPI.sysfunc2(23, t)
END EventTimeout;
 
 
PROCEDURE ThreadInfo (offsa, offsb: INTEGER; VAR a, b: INTEGER);
VAR
	buffer: ARRAY 1024 OF BYTE;
BEGIN
	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1);
	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsa, a);
	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsb, b);
END ThreadInfo;
 
 
PROCEDURE WinSize* (VAR width, height: INTEGER);
BEGIN
	ThreadInfo(42, 46, width, height)
END WinSize;
 
 
PROCEDURE WinPos* (VAR x, y: INTEGER);
BEGIN
	ThreadInfo(34, 38, x, y)
END WinPos;
 
 
PROCEDURE ClientSize* (VAR width, height: INTEGER);
BEGIN
	ThreadInfo(62, 66, width, height)
END ClientSize;
 
 
PROCEDURE ClientPos* (VAR x, y: INTEGER);
BEGIN
	ThreadInfo(54, 58, x, y)
END ClientPos;
 
 
PROCEDURE ScreenSize* (VAR width, height: INTEGER);
VAR
	eax, ebx: INTEGER;
	right, left, top, bottom: INTEGER;
BEGIN
	eax := KOSAPI.sysfunc22(48, 5, ebx);
	left := LSR(eax, 16);
	right := eax MOD 65536;
	top := LSR(ebx, 16);
	bottom := ebx MOD 65536;
	width := right - left + 1;
	height := bottom - top + 1
END ScreenSize;
 
 
PROCEDURE ThreadID* (): INTEGER;
VAR
	id: INTEGER;
BEGIN
	ThreadInfo(30, 30, id, id)
	RETURN id
END ThreadID;
 
 
PROCEDURE RolledUp* (): BOOLEAN;
VAR
	buffer: ARRAY 1024 OF BYTE;
BEGIN
	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1)
	RETURN ODD(LSR(buffer[70], 2))
END RolledUp;
 
 
PROCEDURE SetWinSize* (width, height: INTEGER);
BEGIN
	KOSAPI.sysfunc5(67, -1, -1, width, height)
END SetWinSize;
 
 
PROCEDURE DrawText* (x, y, color: INTEGER; text: ARRAY OF WCHAR);
BEGIN
	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0A0H, 24), SYSTEM.ADR(text[0]), 0, 0)
END DrawText;
 
 
PROCEDURE DrawText69* (x, y, color: INTEGER; text: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(080H, 24), SYSTEM.ADR(text[0]), 0, 0)
END DrawText69;
 
 
PROCEDURE DrawText866* (x, y, color: INTEGER; text: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, colors.work)
END DrawText866;
 
 
PROCEDURE DrawText866bk* (x, y, color, bkColor: INTEGER; text: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, bkColor)
END DrawText866bk;
 
 
PROCEDURE MousePos* (VAR x, y: INTEGER);
VAR
	res: INTEGER;
BEGIN
	res := KOSAPI.sysfunc2(37, 0);
	y := res MOD 65536;
	x := res DIV 65536
END MousePos;
 
 
PROCEDURE CreateButton* (id, Left, Top, Width, Height, Color: INTEGER; Caption: ARRAY OF WCHAR);
VAR
	x, y: INTEGER;
BEGIN
	KOSAPI.sysfunc5(8, LSL(Left, 16) + Width, LSL(Top, 16) + Height, id, Color);
	x := Left + (Width - fontWidth * LENGTH(Caption)) DIV 2;
	y := Top + (Height - fontHeight) DIV 2 + 1;
	DrawText(x, y, colors.button_text, Caption)
END CreateButton;
 
 
PROCEDURE DeleteButton* (id: INTEGER);
BEGIN
	KOSAPI.sysfunc5(8, 0, 0, id + 80000000H, 0)
END DeleteButton;
 
 
PROCEDURE GetTickCount* (): INTEGER;
	RETURN KOSAPI.sysfunc2(26, 9)
END GetTickCount;
 
 
PROCEDURE Pause* (time: INTEGER);
BEGIN
	KOSAPI.sysfunc2(5, time)
END Pause;
 
 
PROCEDURE ButtonCode* (VAR middle: BOOLEAN): INTEGER;
VAR
	res: INTEGER;
BEGIN
	middle := FALSE;
	res := KOSAPI.sysfunc1(17);
	IF res MOD 256 = 0 THEN
		res := LSR(res, 8)
	ELSIF res MOD 256 = 4 THEN
		res := LSR(res, 8);
		middle := TRUE
	ELSE
		res := 0
	END
	RETURN res
END ButtonCode;
 
 
PROCEDURE Exit*;
BEGIN
	KOSAPI.sysfunc1(-1)
END Exit;
 
 
PROCEDURE ExitID* (tid: INTEGER);
BEGIN
	KOSAPI.sysfunc3(18, 18, tid)
END ExitID;
 
 
PROCEDURE CreateThread* (proc: INTEGER; stack: ARRAY OF INTEGER): INTEGER;
VAR
	tid: INTEGER;
BEGIN
	tid := KOSAPI.sysfunc4(51, 1, proc, SYSTEM.ADR(stack[LEN(stack) - 2]));
	IF tid = -1 THEN
		tid := 0
	END
	RETURN tid
END CreateThread;
 
 
PROCEDURE Run* (program, param: ARRAY OF CHAR);
TYPE
 
	info_struct = RECORD
		subfunc : INTEGER;
		flags   : INTEGER;
		param   : INTEGER;
		rsrvd1  : INTEGER;
		rsrvd2  : INTEGER;
		fname   : ARRAY 1024 OF CHAR
	END;
 
VAR
	info: info_struct;
 
BEGIN
	info.subfunc := 7;
	info.flags   := 0;
	info.param   := SYSTEM.ADR(param[0]);
	info.rsrvd1  := 0;
	info.rsrvd2  := 0;
	COPY(program, info.fname);
	KOSAPI.sysfunc2(70, SYSTEM.ADR(info))
END Run;
 
 
PROCEDURE SetCurFolder* (folder: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc3(30, 1, SYSTEM.ADR(folder[0]));
END SetCurFolder;
 
 
PROCEDURE DrawRect* (x, y, width, height, color: INTEGER);
BEGIN
	KOSAPI.sysfunc4(13, x*65536 + width, y*65536 + height, color)
END DrawRect;
 
 
PROCEDURE DrawLine* (x1, y1, x2, y2: INTEGER; color: INTEGER);
BEGIN
	KOSAPI.sysfunc4(38, x1*65536 + x2, y1*65536 + y2, color)
END DrawLine;
 
 
PROCEDURE DrawImage* (data, sizeX, sizeY, x, y: INTEGER);
BEGIN
	KOSAPI.sysfunc4(7, data, sizeX*65536 + sizeY, x*65536 + y)
END DrawImage;
 
 
PROCEDURE SetEventsMask* (mask: SET);
BEGIN
	KOSAPI.sysfunc2(40, ORD(mask))
END SetEventsMask;
 
 
PROCEDURE SkinHeight* (): INTEGER;
	RETURN KOSAPI.sysfunc2(48, 4)
END SkinHeight;
 
 
PROCEDURE GetKey* (): INTEGER;
	RETURN KOSAPI.sysfunc1(2)
END GetKey;
 
 
PROCEDURE MouseState* (): SET;
	RETURN BITS(KOSAPI.sysfunc2(37, 3))
END MouseState;
 
 
PROCEDURE Scroll* (): INTEGER;
	RETURN ASR(LSL(KOSAPI.sysfunc2(37, 7), 16), 16)
END Scroll;
 
 
PROCEDURE GetControlKeys* (): SET;
	RETURN BITS(KOSAPI.sysfunc2(66, 3))
END GetControlKeys;
 
 
PROCEDURE GetSystemColors*;
BEGIN
	KOSAPI.sysfunc4(48, 3, SYSTEM.ADR(colors), 40)
END GetSystemColors;
 
 
PROCEDURE getKBState* (VAR shift, ctrl: BOOLEAN);
VAR
	kbState: SET;
BEGIN
	kbState := GetControlKeys();
	shift := {0, 1} * kbState # {};
	ctrl := {2, 3} * kbState # {};
END getKBState;
 
 
PROCEDURE mouse* (VAR msState: SET; VAR x, y: INTEGER);
VAR
	mouseX, mouseY,
	cliX, cliY,
	winX, winY: INTEGER;
BEGIN
	msState := MouseState();
	MousePos(mouseX, mouseY);
	WinPos(winX, winY);
	ClientPos(cliX, cliY);
	x := mouseX - winX - cliX;
	y := mouseY - winY - cliY
END mouse;
 
 
PROCEDURE SetCaption* (text: ARRAY OF CHAR);
BEGIN
	KOSAPI.sysfunc4(71, 2, SYSTEM.ADR(text[0]), 0)
END SetCaption;
 
 
PROCEDURE CBCount* (): INTEGER;
	RETURN KOSAPI.sysfunc2(54, 0)
END CBCount;
 
 
PROCEDURE CBRead* (slot: INTEGER): INTEGER;
	RETURN KOSAPI.sysfunc3(54, 1, slot)
END CBRead;
 
 
PROCEDURE CBWrite* (size, ptr: INTEGER);
BEGIN
	KOSAPI.sysfunc4(54, 2, size, ptr)
END CBWrite;
 
 
PROCEDURE CBDelSlot*;
BEGIN
	KOSAPI.sysfunc2(54, 3)
END CBDelSlot;
 
 
PROCEDURE GetThreadSlot* (tid: INTEGER): INTEGER;
	RETURN KOSAPI.sysfunc3(18, 21, tid)
END GetThreadSlot;
 
 
PROCEDURE PutPixel* (x, y, color: INTEGER);
BEGIN
	KOSAPI.sysfunc5(1, x, y, color, 0)
END PutPixel;
 
 
PROCEDURE SetIPC* (buffer: ARRAY OF INTEGER);
BEGIN
	KOSAPI.sysfunc4(60, 1, SYSTEM.ADR(buffer[0]), LEN(buffer)*SYSTEM.SIZE(INTEGER))
END SetIPC;
 
 
PROCEDURE SendIPC* (pid, ptr, size: INTEGER);
BEGIN
	KOSAPI.sysfunc5(60, 2, pid, ptr, size)
END SendIPC;
 
 
PROCEDURE docpack* (VAR param: ARRAY OF CHAR; VAR text_ptr, text_size: INTEGER);
VAR
	i, size, ptr, ptr2: INTEGER;
	s: ARRAY 32 OF WCHAR;
BEGIN
	ptr2 := 0;
	U.reverse8(param);
	param[LENGTH(param) - 1] := 0X;
	U.reverse8(param);
	i := 0;
	WHILE param[i] # 0X DO
		s[i] := WCHR(ORD(param[i]));
		INC(i)
	END;
	IF U.str2int(s, size) THEN
		INC(size, 20);
		ptr := KOSAPI.malloc(size);
		IF ptr # 0 THEN
			SYSTEM.PUT32(ptr, 0);
			SYSTEM.PUT32(ptr + 4, 8);
			KOSAPI.sysfunc4(60, 1, ptr, size);
			SetEventsMask({6});
			IF EventTimeout(200) = 7 THEN
				SYSTEM.PUT32(ptr, 1);
				SYSTEM.GET(ptr + 12, size);
				ptr2 := KOSAPI.malloc(size);
				IF ptr2 # 0 THEN
					SYSTEM.MOVE(ptr + 16, ptr2, size)
				END
			END;
			ptr := KOSAPI.free(ptr)
		END
	END;
	text_ptr := ptr2;
	text_size := size
END docpack;
 
 
BEGIN
	GetSystemColors
END KolibriOS.

Rev 9730	Rev 9906
1	(*	1	(*
2	Copyright 2021, 2022 Anton Krotov	2	Copyright 2021-2023 Anton Krotov
3		3
4	This file is part of CEdit.	4	This file is part of CEdit.
5		5
6	CEdit is free software: you can redistribute it and/or modify	6	CEdit is free software: you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation, either version 3 of the License, or	8	the Free Software Foundation, either version 3 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	CEdit is distributed in the hope that it will be useful,	11	CEdit is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with CEdit. If not, see .	17	along with CEdit. If not, see .
18	*)	18	*)
19		19
20	MODULE KolibriOS;	20	MODULE KolibriOS;
21		21
22	IMPORT	22	IMPORT
23	KOSAPI, SYSTEM, U := Utils;	23	KOSAPI, SYSTEM, U := Utils;
24		24
25	CONST	25	CONST
26	fontWidth* = 8;	26	fontWidth* = 8;
27	fontHeight* = 16;	27	fontHeight* = 16;
28		28
29	VAR	29	VAR
30		30
31	colors*: RECORD	31	colors*: RECORD
32	rsrvd,	32	rsrvd,
33	taskbar,	33	taskbar,
34	dark*,	34	dark*,
35	light*,	35	light*,
36	window_title*,	36	window_title*,
37	work*,	37	work*,
38	button*,	38	button*,
39	button_text*,	39	button_text*,
40	work_text*,	40	work_text*,
41	line*: INTEGER	41	line*: INTEGER
42	END;	42	END;
43		43
44		44
45	PROCEDURE CreateWindow* (x, y, w, h, color, style, hcolor, hstyle: INTEGER; htext: ARRAY OF CHAR);	45	PROCEDURE CreateWindow* (x, y, w, h, color, style, hcolor, hstyle: INTEGER; htext: ARRAY OF CHAR);
46	BEGIN	46	BEGIN
47	KOSAPI.sysfunc6(0, x65536 + w, y65536 + h, color + LSL(style, 24), hcolor + LSL(hstyle, 24), SYSTEM.ADR(htext[0]))	47	KOSAPI.sysfunc6(0, x65536 + w, y65536 + h, color + LSL(style, 24), hcolor + LSL(hstyle, 24), SYSTEM.ADR(htext[0]))
48	END CreateWindow;	48	END CreateWindow;
49		49
50		50
51	PROCEDURE BeginDraw*;	51	PROCEDURE BeginDraw*;
52	BEGIN	52	BEGIN
53	KOSAPI.sysfunc2(12, 1)	53	KOSAPI.sysfunc2(12, 1)
54	END BeginDraw;	54	END BeginDraw;
55		55
56		56
57	PROCEDURE EndDraw*;	57	PROCEDURE EndDraw*;
58	BEGIN	58	BEGIN
59	KOSAPI.sysfunc2(12, 2)	59	KOSAPI.sysfunc2(12, 2)
60	END EndDraw;	60	END EndDraw;
61		61
62		62
63	PROCEDURE EventTimeout* (t: INTEGER): INTEGER;	63	PROCEDURE EventTimeout* (t: INTEGER): INTEGER;
64	RETURN KOSAPI.sysfunc2(23, t)	64	RETURN KOSAPI.sysfunc2(23, t)
65	END EventTimeout;	65	END EventTimeout;
66		66
67		67
68	PROCEDURE ThreadInfo (offsa, offsb: INTEGER; VAR a, b: INTEGER);	68	PROCEDURE ThreadInfo (offsa, offsb: INTEGER; VAR a, b: INTEGER);
69	VAR	69	VAR
70	buffer: ARRAY 1024 OF BYTE;	70	buffer: ARRAY 1024 OF BYTE;
71	BEGIN	71	BEGIN
72	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1);	72	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1);
73	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsa, a);	73	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsa, a);
74	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsb, b);	74	SYSTEM.GET32(SYSTEM.ADR(buffer[0]) + offsb, b);
75	END ThreadInfo;	75	END ThreadInfo;
76		76
77		77
78	PROCEDURE WinSize* (VAR width, height: INTEGER);	78	PROCEDURE WinSize* (VAR width, height: INTEGER);
79	BEGIN	79	BEGIN
80	ThreadInfo(42, 46, width, height)	80	ThreadInfo(42, 46, width, height)
81	END WinSize;	81	END WinSize;
82		82
83		83
84	PROCEDURE WinPos* (VAR x, y: INTEGER);	84	PROCEDURE WinPos* (VAR x, y: INTEGER);
85	BEGIN	85	BEGIN
86	ThreadInfo(34, 38, x, y)	86	ThreadInfo(34, 38, x, y)
87	END WinPos;	87	END WinPos;
88		88
89		89
90	PROCEDURE ClientSize* (VAR width, height: INTEGER);	90	PROCEDURE ClientSize* (VAR width, height: INTEGER);
91	BEGIN	91	BEGIN
92	ThreadInfo(62, 66, width, height)	92	ThreadInfo(62, 66, width, height)
93	END ClientSize;	93	END ClientSize;
94		94
95		95
96	PROCEDURE ClientPos* (VAR x, y: INTEGER);	96	PROCEDURE ClientPos* (VAR x, y: INTEGER);
97	BEGIN	97	BEGIN
98	ThreadInfo(54, 58, x, y)	98	ThreadInfo(54, 58, x, y)
99	END ClientPos;	99	END ClientPos;
100		100
101		101
102	PROCEDURE ScreenSize* (VAR width, height: INTEGER);	102	PROCEDURE ScreenSize* (VAR width, height: INTEGER);
103	VAR	103	VAR
104	eax, ebx: INTEGER;	104	eax, ebx: INTEGER;
105	right, left, top, bottom: INTEGER;	105	right, left, top, bottom: INTEGER;
106	BEGIN	106	BEGIN
107	eax := KOSAPI.sysfunc22(48, 5, ebx);	107	eax := KOSAPI.sysfunc22(48, 5, ebx);
108	left := LSR(eax, 16);	108	left := LSR(eax, 16);
109	right := eax MOD 65536;	109	right := eax MOD 65536;
110	top := LSR(ebx, 16);	110	top := LSR(ebx, 16);
111	bottom := ebx MOD 65536;	111	bottom := ebx MOD 65536;
112	width := right - left + 1;	112	width := right - left + 1;
113	height := bottom - top + 1	113	height := bottom - top + 1
114	END ScreenSize;	114	END ScreenSize;
115		115
116		116
117	PROCEDURE ThreadID* (): INTEGER;	117	PROCEDURE ThreadID* (): INTEGER;
118	VAR	118	VAR
119	id: INTEGER;	119	id: INTEGER;
120	BEGIN	120	BEGIN
121	ThreadInfo(30, 30, id, id)	121	ThreadInfo(30, 30, id, id)
122	RETURN id	122	RETURN id
123	END ThreadID;	123	END ThreadID;
124		124
125		125
126	PROCEDURE RolledUp* (): BOOLEAN;	126	PROCEDURE RolledUp* (): BOOLEAN;
127	VAR	127	VAR
128	buffer: ARRAY 1024 OF BYTE;	128	buffer: ARRAY 1024 OF BYTE;
129	BEGIN	129	BEGIN
130	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1)	130	KOSAPI.sysfunc3(9, SYSTEM.ADR(buffer[0]), -1)
131	RETURN ODD(LSR(buffer[70], 2))	131	RETURN ODD(LSR(buffer[70], 2))
132	END RolledUp;	132	END RolledUp;
133		133
134		134
135	PROCEDURE SetWinSize* (width, height: INTEGER);	135	PROCEDURE SetWinSize* (width, height: INTEGER);
136	BEGIN	136	BEGIN
137	KOSAPI.sysfunc5(67, -1, -1, width, height)	137	KOSAPI.sysfunc5(67, -1, -1, width, height)
138	END SetWinSize;	138	END SetWinSize;
139		139
140		140
141	PROCEDURE DrawText* (x, y, color: INTEGER; text: ARRAY OF WCHAR);	141	PROCEDURE DrawText* (x, y, color: INTEGER; text: ARRAY OF WCHAR);
142	BEGIN	142	BEGIN
143	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0A0H, 24), SYSTEM.ADR(text[0]), 0, 0)	143	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0A0H, 24), SYSTEM.ADR(text[0]), 0, 0)
144	END DrawText;	144	END DrawText;
145		145
146		146
147	PROCEDURE DrawText69* (x, y, color: INTEGER; text: ARRAY OF CHAR);	147	PROCEDURE DrawText69* (x, y, color: INTEGER; text: ARRAY OF CHAR);
148	BEGIN	148	BEGIN
149	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(080H, 24), SYSTEM.ADR(text[0]), 0, 0)	149	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(080H, 24), SYSTEM.ADR(text[0]), 0, 0)
150	END DrawText69;	150	END DrawText69;
151		151
152		152
153	PROCEDURE DrawText866* (x, y, color: INTEGER; text: ARRAY OF CHAR);	153	PROCEDURE DrawText866* (x, y, color: INTEGER; text: ARRAY OF CHAR);
154	BEGIN	154	BEGIN
155	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, colors.work)	155	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, colors.work)
156	END DrawText866;	156	END DrawText866;
157		157
158		158
159	PROCEDURE DrawText866bk* (x, y, color, bkColor: INTEGER; text: ARRAY OF CHAR);	159	PROCEDURE DrawText866bk* (x, y, color, bkColor: INTEGER; text: ARRAY OF CHAR);
160	BEGIN	160	BEGIN
161	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, bkColor)	161	KOSAPI.sysfunc6(4, x*65536 + y, color + LSL(0D0H, 24), SYSTEM.ADR(text[0]), 0, bkColor)
162	END DrawText866bk;	162	END DrawText866bk;
163		163
164		164
165	PROCEDURE MousePos* (VAR x, y: INTEGER);	165	PROCEDURE MousePos* (VAR x, y: INTEGER);
166	VAR	166	VAR
167	res: INTEGER;	167	res: INTEGER;
168	BEGIN	168	BEGIN
169	res := KOSAPI.sysfunc2(37, 0);	169	res := KOSAPI.sysfunc2(37, 0);
170	y := res MOD 65536;	170	y := res MOD 65536;
171	x := res DIV 65536	171	x := res DIV 65536
172	END MousePos;	172	END MousePos;
173		173
174		174
175	PROCEDURE CreateButton* (id, Left, Top, Width, Height, Color: INTEGER; Caption: ARRAY OF WCHAR);	175	PROCEDURE CreateButton* (id, Left, Top, Width, Height, Color: INTEGER; Caption: ARRAY OF WCHAR);
176	VAR	176	VAR
177	x, y: INTEGER;	177	x, y: INTEGER;
178	BEGIN	178	BEGIN
179	KOSAPI.sysfunc5(8, LSL(Left, 16) + Width, LSL(Top, 16) + Height, id, Color);	179	KOSAPI.sysfunc5(8, LSL(Left, 16) + Width, LSL(Top, 16) + Height, id, Color);
180	x := Left + (Width - fontWidth * LENGTH(Caption)) DIV 2;	180	x := Left + (Width - fontWidth * LENGTH(Caption)) DIV 2;
181	y := Top + (Height - fontHeight) DIV 2 + 1;	181	y := Top + (Height - fontHeight) DIV 2 + 1;
182	DrawText(x, y, colors.button_text, Caption)	182	DrawText(x, y, colors.button_text, Caption)
183	END CreateButton;	183	END CreateButton;
184		184
185		185
186	PROCEDURE DeleteButton* (id: INTEGER);	186	PROCEDURE DeleteButton* (id: INTEGER);
187	BEGIN	187	BEGIN
188	KOSAPI.sysfunc5(8, 0, 0, id + 80000000H, 0)	188	KOSAPI.sysfunc5(8, 0, 0, id + 80000000H, 0)
189	END DeleteButton;	189	END DeleteButton;
190		190
191		191
192	PROCEDURE GetTickCount* (): INTEGER;	192	PROCEDURE GetTickCount* (): INTEGER;
193	RETURN KOSAPI.sysfunc2(26, 9)	193	RETURN KOSAPI.sysfunc2(26, 9)
194	END GetTickCount;	194	END GetTickCount;
195		195
196		196
197	PROCEDURE Pause* (time: INTEGER);	197	PROCEDURE Pause* (time: INTEGER);
198	BEGIN	198	BEGIN
199	KOSAPI.sysfunc2(5, time)	199	KOSAPI.sysfunc2(5, time)
200	END Pause;	200	END Pause;
201		201
202		202
203	PROCEDURE ButtonCode* (VAR middle: BOOLEAN): INTEGER;	203	PROCEDURE ButtonCode* (VAR middle: BOOLEAN): INTEGER;
204	VAR	204	VAR
205	res: INTEGER;	205	res: INTEGER;
206	BEGIN	206	BEGIN
207	middle := FALSE;	207	middle := FALSE;
208	res := KOSAPI.sysfunc1(17);	208	res := KOSAPI.sysfunc1(17);
209	IF res MOD 256 = 0 THEN	209	IF res MOD 256 = 0 THEN
210	res := LSR(res, 8)	210	res := LSR(res, 8)
211	ELSIF res MOD 256 = 4 THEN	211	ELSIF res MOD 256 = 4 THEN
212	res := LSR(res, 8);	212	res := LSR(res, 8);
213	middle := TRUE	213	middle := TRUE
214	ELSE	214	ELSE
215	res := 0	215	res := 0
216	END	216	END
217	RETURN res	217	RETURN res
218	END ButtonCode;	218	END ButtonCode;
219		219
220		220
221	PROCEDURE Exit*;	221	PROCEDURE Exit*;
222	BEGIN	222	BEGIN
223	KOSAPI.sysfunc1(-1)	223	KOSAPI.sysfunc1(-1)
224	END Exit;	224	END Exit;
225		225
226		226
227	PROCEDURE ExitID* (tid: INTEGER);	227	PROCEDURE ExitID* (tid: INTEGER);
228	BEGIN	228	BEGIN
229	KOSAPI.sysfunc3(18, 18, tid)	229	KOSAPI.sysfunc3(18, 18, tid)
230	END ExitID;	230	END ExitID;
231		231
232		232
233	PROCEDURE CreateThread* (proc: INTEGER; stack: ARRAY OF INTEGER): INTEGER;	233	PROCEDURE CreateThread* (proc: INTEGER; stack: ARRAY OF INTEGER): INTEGER;
234	VAR	234	VAR
235	tid: INTEGER;	235	tid: INTEGER;
236	BEGIN	236	BEGIN
237	tid := KOSAPI.sysfunc4(51, 1, proc, SYSTEM.ADR(stack[LEN(stack) - 2]));	237	tid := KOSAPI.sysfunc4(51, 1, proc, SYSTEM.ADR(stack[LEN(stack) - 2]));
238	IF tid = -1 THEN	238	IF tid = -1 THEN
239	tid := 0	239	tid := 0
240	END	240	END
241	RETURN tid	241	RETURN tid
242	END CreateThread;	242	END CreateThread;
243		243
244		244
245	PROCEDURE Run* (program, param: ARRAY OF CHAR);	245	PROCEDURE Run* (program, param: ARRAY OF CHAR);
246	TYPE	246	TYPE
247		247
248	info_struct = RECORD	248	info_struct = RECORD
249	subfunc : INTEGER;	249	subfunc : INTEGER;
250	flags : INTEGER;	250	flags : INTEGER;
251	param : INTEGER;	251	param : INTEGER;
252	rsrvd1 : INTEGER;	252	rsrvd1 : INTEGER;
253	rsrvd2 : INTEGER;	253	rsrvd2 : INTEGER;
254	fname : ARRAY 1024 OF CHAR	254	fname : ARRAY 1024 OF CHAR
255	END;	255	END;
256		256
257	VAR	257	VAR
258	info: info_struct;	258	info: info_struct;
259		259
260	BEGIN	260	BEGIN
261	info.subfunc := 7;	261	info.subfunc := 7;
262	info.flags := 0;	262	info.flags := 0;
263	info.param := SYSTEM.ADR(param[0]);	263	info.param := SYSTEM.ADR(param[0]);
264	info.rsrvd1 := 0;	264	info.rsrvd1 := 0;
265	info.rsrvd2 := 0;	265	info.rsrvd2 := 0;
266	COPY(program, info.fname);	266	COPY(program, info.fname);
267	KOSAPI.sysfunc2(70, SYSTEM.ADR(info))	267	KOSAPI.sysfunc2(70, SYSTEM.ADR(info))
268	END Run;	268	END Run;
269		269
270		270
271	PROCEDURE SetCurFolder* (folder: ARRAY OF CHAR);	271	PROCEDURE SetCurFolder* (folder: ARRAY OF CHAR);
272	BEGIN	272	BEGIN
273	KOSAPI.sysfunc3(30, 1, SYSTEM.ADR(folder[0]));	273	KOSAPI.sysfunc3(30, 1, SYSTEM.ADR(folder[0]));
274	END SetCurFolder;	274	END SetCurFolder;
275		275
276		276
277	PROCEDURE DrawRect* (x, y, width, height, color: INTEGER);	277	PROCEDURE DrawRect* (x, y, width, height, color: INTEGER);
278	BEGIN	278	BEGIN
279	KOSAPI.sysfunc4(13, x65536 + width, y65536 + height, color)	279	KOSAPI.sysfunc4(13, x65536 + width, y65536 + height, color)
280	END DrawRect;	280	END DrawRect;
281		281
282		282
283	PROCEDURE DrawLine* (x1, y1, x2, y2: INTEGER; color: INTEGER);	283	PROCEDURE DrawLine* (x1, y1, x2, y2: INTEGER; color: INTEGER);
284	BEGIN	284	BEGIN
285	KOSAPI.sysfunc4(38, x165536 + x2, y165536 + y2, color)	285	KOSAPI.sysfunc4(38, x165536 + x2, y165536 + y2, color)
286	END DrawLine;	286	END DrawLine;
287		287
288		288
289	PROCEDURE DrawImage* (data, sizeX, sizeY, x, y: INTEGER);	289	PROCEDURE DrawImage* (data, sizeX, sizeY, x, y: INTEGER);
290	BEGIN	290	BEGIN
291	KOSAPI.sysfunc4(7, data, sizeX65536 + sizeY, x65536 + y)	291	KOSAPI.sysfunc4(7, data, sizeX65536 + sizeY, x65536 + y)
292	END DrawImage;	292	END DrawImage;
293		293
294		294
295	PROCEDURE SetEventsMask* (mask: SET);	295	PROCEDURE SetEventsMask* (mask: SET);
296	BEGIN	296	BEGIN
297	KOSAPI.sysfunc2(40, ORD(mask))	297	KOSAPI.sysfunc2(40, ORD(mask))
298	END SetEventsMask;	298	END SetEventsMask;
299		299
300		300
301	PROCEDURE SkinHeight* (): INTEGER;	301	PROCEDURE SkinHeight* (): INTEGER;
302	RETURN KOSAPI.sysfunc2(48, 4)	302	RETURN KOSAPI.sysfunc2(48, 4)
303	END SkinHeight;	303	END SkinHeight;
304		304
305		305
306	PROCEDURE GetKey* (): INTEGER;	306	PROCEDURE GetKey* (): INTEGER;
307	RETURN KOSAPI.sysfunc1(2)	307	RETURN KOSAPI.sysfunc1(2)
308	END GetKey;	308	END GetKey;
309		309
310		310
311	PROCEDURE MouseState* (): SET;	311	PROCEDURE MouseState* (): SET;
312	RETURN BITS(KOSAPI.sysfunc2(37, 3))	312	RETURN BITS(KOSAPI.sysfunc2(37, 3))
313	END MouseState;	313	END MouseState;
314		314
315		315
316	PROCEDURE Scroll* (): INTEGER;	316	PROCEDURE Scroll* (): INTEGER;
317	RETURN ASR(LSL(KOSAPI.sysfunc2(37, 7), 16), 16)	317	RETURN ASR(LSL(KOSAPI.sysfunc2(37, 7), 16), 16)
318	END Scroll;	318	END Scroll;
319		319
320		320
321	PROCEDURE GetControlKeys* (): SET;	321	PROCEDURE GetControlKeys* (): SET;
322	RETURN BITS(KOSAPI.sysfunc2(66, 3))	322	RETURN BITS(KOSAPI.sysfunc2(66, 3))
323	END GetControlKeys;	323	END GetControlKeys;
324		324
325		325
326	PROCEDURE GetSystemColors*;	326	PROCEDURE GetSystemColors*;
327	BEGIN	327	BEGIN
328	KOSAPI.sysfunc4(48, 3, SYSTEM.ADR(colors), 40)	328	KOSAPI.sysfunc4(48, 3, SYSTEM.ADR(colors), 40)
329	END GetSystemColors;	329	END GetSystemColors;
330		330
331		331
332	PROCEDURE getKBState* (VAR shift, ctrl: BOOLEAN);	332	PROCEDURE getKBState* (VAR shift, ctrl: BOOLEAN);
333	VAR	333	VAR
334	kbState: SET;	334	kbState: SET;
335	BEGIN	335	BEGIN
336	kbState := GetControlKeys();	336	kbState := GetControlKeys();
337	shift := {0, 1} * kbState # {};	337	shift := {0, 1} * kbState # {};
338	ctrl := {2, 3} * kbState # {};	338	ctrl := {2, 3} * kbState # {};
339	END getKBState;	339	END getKBState;
340		340
341		341
342	PROCEDURE mouse* (VAR msState: SET; VAR x, y: INTEGER);	342	PROCEDURE mouse* (VAR msState: SET; VAR x, y: INTEGER);
343	VAR	343	VAR
344	mouseX, mouseY,	344	mouseX, mouseY,
345	cliX, cliY,	345	cliX, cliY,
346	winX, winY: INTEGER;	346	winX, winY: INTEGER;
347	BEGIN	347	BEGIN
348	msState := MouseState();	348	msState := MouseState();
349	MousePos(mouseX, mouseY);	349	MousePos(mouseX, mouseY);
350	WinPos(winX, winY);	350	WinPos(winX, winY);
351	ClientPos(cliX, cliY);	351	ClientPos(cliX, cliY);
352	x := mouseX - winX - cliX;	352	x := mouseX - winX - cliX;
353	y := mouseY - winY - cliY	353	y := mouseY - winY - cliY
354	END mouse;	354	END mouse;
355		355
356		356
357	PROCEDURE SetCaption* (text: ARRAY OF CHAR);	357	PROCEDURE SetCaption* (text: ARRAY OF CHAR);
358	BEGIN	358	BEGIN
359	KOSAPI.sysfunc4(71, 2, SYSTEM.ADR(text[0]), 0)	359	KOSAPI.sysfunc4(71, 2, SYSTEM.ADR(text[0]), 0)
360	END SetCaption;	360	END SetCaption;
361		361
362		362
363	PROCEDURE CBCount* (): INTEGER;	363	PROCEDURE CBCount* (): INTEGER;
364	RETURN KOSAPI.sysfunc2(54, 0)	364	RETURN KOSAPI.sysfunc2(54, 0)
365	END CBCount;	365	END CBCount;
366		366
367		367
368	PROCEDURE CBRead* (slot: INTEGER): INTEGER;	368	PROCEDURE CBRead* (slot: INTEGER): INTEGER;
369	RETURN KOSAPI.sysfunc3(54, 1, slot)	369	RETURN KOSAPI.sysfunc3(54, 1, slot)
370	END CBRead;	370	END CBRead;
371		371
372		372
373	PROCEDURE CBWrite* (size, ptr: INTEGER);	373	PROCEDURE CBWrite* (size, ptr: INTEGER);
374	BEGIN	374	BEGIN
375	KOSAPI.sysfunc4(54, 2, size, ptr)	375	KOSAPI.sysfunc4(54, 2, size, ptr)
376	END CBWrite;	376	END CBWrite;
377		377
378		378
379	PROCEDURE CBDelSlot*;	379	PROCEDURE CBDelSlot*;
380	BEGIN	380	BEGIN
381	KOSAPI.sysfunc2(54, 3)	381	KOSAPI.sysfunc2(54, 3)
382	END CBDelSlot;	382	END CBDelSlot;
383		383
384		384
385	PROCEDURE GetThreadSlot* (tid: INTEGER): INTEGER;	385	PROCEDURE GetThreadSlot* (tid: INTEGER): INTEGER;
386	RETURN KOSAPI.sysfunc3(18, 21, tid)	386	RETURN KOSAPI.sysfunc3(18, 21, tid)
387	END GetThreadSlot;	387	END GetThreadSlot;
388		388
389		389
390	PROCEDURE PutPixel* (x, y, color: INTEGER);	390	PROCEDURE PutPixel* (x, y, color: INTEGER);
391	BEGIN	391	BEGIN
392	KOSAPI.sysfunc5(1, x, y, color, 0)	392	KOSAPI.sysfunc5(1, x, y, color, 0)
393	END PutPixel;	393	END PutPixel;
394		394
395		395
396	PROCEDURE SetIPC* (buffer: ARRAY OF INTEGER);	396	PROCEDURE SetIPC* (buffer: ARRAY OF INTEGER);
397	BEGIN	397	BEGIN
398	KOSAPI.sysfunc4(60, 1, SYSTEM.ADR(buffer[0]), LEN(buffer)*SYSTEM.SIZE(INTEGER))	398	KOSAPI.sysfunc4(60, 1, SYSTEM.ADR(buffer[0]), LEN(buffer)*SYSTEM.SIZE(INTEGER))
399	END SetIPC;	399	END SetIPC;
400		400
401		401
402	PROCEDURE SendIPC* (pid, ptr, size: INTEGER);	402	PROCEDURE SendIPC* (pid, ptr, size: INTEGER);
403	BEGIN	403	BEGIN
404	KOSAPI.sysfunc5(60, 2, pid, ptr, size)	404	KOSAPI.sysfunc5(60, 2, pid, ptr, size)
405	END SendIPC;	405	END SendIPC;
406		406
407		407
408	PROCEDURE docpack* (VAR param: ARRAY OF CHAR; VAR text_ptr, text_size: INTEGER);	408	PROCEDURE docpack* (VAR param: ARRAY OF CHAR; VAR text_ptr, text_size: INTEGER);
409	VAR	409	VAR
410	i, size, ptr, ptr2: INTEGER;	410	i, size, ptr, ptr2: INTEGER;
411	s: ARRAY 32 OF WCHAR;	411	s: ARRAY 32 OF WCHAR;
412	BEGIN	412	BEGIN
413	ptr2 := 0;	413	ptr2 := 0;
414	U.reverse8(param);	414	U.reverse8(param);
415	param[LENGTH(param) - 1] := 0X;	415	param[LENGTH(param) - 1] := 0X;
416	U.reverse8(param);	416	U.reverse8(param);
417	i := 0;	417	i := 0;
418	WHILE param[i] # 0X DO	418	WHILE param[i] # 0X DO
419	s[i] := WCHR(ORD(param[i]));	419	s[i] := WCHR(ORD(param[i]));
420	INC(i)	420	INC(i)
421	END;	421	END;
422	IF U.str2int(s, size) THEN	422	IF U.str2int(s, size) THEN
423	INC(size, 20);	423	INC(size, 20);
424	ptr := KOSAPI.malloc(size);	424	ptr := KOSAPI.malloc(size);
425	IF ptr # 0 THEN	425	IF ptr # 0 THEN
426	SYSTEM.PUT32(ptr, 0);	426	SYSTEM.PUT32(ptr, 0);
427	SYSTEM.PUT32(ptr + 4, 8);	427	SYSTEM.PUT32(ptr + 4, 8);
428	KOSAPI.sysfunc4(60, 1, ptr, size);	428	KOSAPI.sysfunc4(60, 1, ptr, size);
429	SetEventsMask({6});	429	SetEventsMask({6});
430	IF EventTimeout(200) = 7 THEN	430	IF EventTimeout(200) = 7 THEN
431	SYSTEM.PUT32(ptr, 1);	431	SYSTEM.PUT32(ptr, 1);
432	SYSTEM.GET(ptr + 12, size);	432	SYSTEM.GET(ptr + 12, size);
433	ptr2 := KOSAPI.malloc(size);	433	ptr2 := KOSAPI.malloc(size);
434	IF ptr2 # 0 THEN	434	IF ptr2 # 0 THEN
435	SYSTEM.MOVE(ptr + 16, ptr2, size)	435	SYSTEM.MOVE(ptr + 16, ptr2, size)
436	END	436	END
437	END;	437	END;
438	ptr := KOSAPI.free(ptr)	438	ptr := KOSAPI.free(ptr)
439	END	439	END
440	END;	440	END;
441	text_ptr := ptr2;	441	text_ptr := ptr2;
442	text_size := size	442	text_size := size
443	END docpack;	443	END docpack;
444		444
445		445
446	BEGIN	446	BEGIN
447	GetSystemColors	447	GetSystemColors
448	END KolibriOS.	448	END KolibriOS.

Subversion Repositories Kolibri OS

(root)/programs/develop/cedit/SRC/KolibriOS.ob07 @ 9175 – Rev 9730 → 9906