Subversion Repositories Kolibri OS

Rev

Rev 7227 | Rev 7244 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 7227 Rev 7235
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
#define CLOSE_BTN 1
65
#define CLOSE_BTN 1
66
 
66
 
67
//-------------------------------------------------------------------------
67
//-------------------------------------------------------------------------
68
 
68
 
69
#include "../lib/system.h"
69
#include "../lib/system.h"
70
#include "../lib/mouse.h"
70
#include "../lib/mouse.h"
71
#include "../lib/keyboard.h"
71
#include "../lib/keyboard.h"
72
 
72
 
73
inline fastcall dword calc(EAX) { return EAX; }
73
inline fastcall dword calc(EAX) { return EAX; }
74
 
74
 
75
:struct raw_image {
75
:struct raw_image {
76
	dword w, h, data;
76
	dword w, h, data;
77
};
77
};
78
 
78
 
79
//------------------------------------------------------------------------------
79
//------------------------------------------------------------------------------
80
:dword wait_event_code;
80
:dword wait_event_code;
81
inline fastcall dword WaitEvent()
81
inline fastcall dword WaitEvent()
82
{
82
{
83
	$mov eax,10
83
	$mov eax,10
84
	$int 0x40
84
	$int 0x40
85
	wait_event_code = EAX;
85
	wait_event_code = EAX;
86
	//if(wait_event_code==evMouse) MOUSE.get();
86
	//if(wait_event_code==evMouse) MOUSE.get();
87
	//return wait_event_code;
87
	//return wait_event_code;
88
}
88
}
89
 
89
 
90
inline fastcall dword CheckEvent()
90
inline fastcall dword CheckEvent()
91
{
91
{
92
	$mov eax,11
92
	$mov eax,11
93
	$int 0x40
93
	$int 0x40
94
}
94
}
95
 
95
 
96
inline fastcall dword WaitEventTimeout(EBX)
96
inline fastcall dword WaitEventTimeout(EBX)
97
{
97
{
98
	$mov eax,23
98
	$mov eax,23
99
	$int 0x40
99
	$int 0x40
100
} 
100
} 
101
 
101
 
102
inline fastcall dword SetEventMask(EBX)
102
inline fastcall dword SetEventMask(EBX)
103
{
103
{
104
	$mov eax,40
104
	$mov eax,40
105
	$int 0x40
105
	$int 0x40
106
}
106
}
107
 
107
 
108
 
108
 
109
inline fastcall pause(EBX)
109
inline fastcall pause(EBX)
110
{
110
{
111
	$mov eax, 5
111
	$mov eax, 5
112
	$int 0x40
112
	$int 0x40
113
}
113
}
114
 
114
 
115
inline fastcall word GetButtonID()
115
inline fastcall word GetButtonID()
116
{
116
{
117
	$mov eax,17
117
	$mov eax,17
118
	$int  0x40
118
	$int  0x40
119
	$shr eax,8
119
	$shr eax,8
120
}
120
}
121
 
121
 
122
inline fastcall dword GetFreeRAM()
122
inline fastcall dword GetFreeRAM()
123
{
123
{
124
	$mov eax, 18
124
	$mov eax, 18
125
	$mov ebx, 16
125
	$mov ebx, 16
126
	$int 0x40
126
	$int 0x40
127
	//return eax = free RAM in Kb
127
	//return eax = free RAM in Kb
128
}
128
}
129
 
129
 
130
inline fastcall dword LoadDriver(ECX) //ECX - èìÿ äðàéâåðà
130
inline fastcall dword LoadDriver(ECX) //ECX - èìÿ äðàéâåðà
131
{
131
{
132
	$mov eax, 68
132
	$mov eax, 68
133
	$mov ebx, 16
133
	$mov ebx, 16
134
	$int 0x40
134
	$int 0x40
135
	//return 0 - íåóäà÷à, èíà÷å eax = õýíäë äðàéâåðà 
135
	//return 0 - íåóäà÷à, èíà÷å eax = õýíäë äðàéâåðà 
136
}
136
}
137
 
137
 
138
inline fastcall dword RuleDriver(ECX) //óêàçàòåëü íà óïðàâëÿþùóþ ñòðóêòóðó
138
inline fastcall dword RuleDriver(ECX) //óêàçàòåëü íà óïðàâëÿþùóþ ñòðóêòóðó
139
{
139
{
140
	$mov eax, 68
140
	$mov eax, 68
141
	$mov ebx, 17
141
	$mov ebx, 17
142
	$int 0x40
142
	$int 0x40
143
	//return eax = îïðåäåëÿåòñÿ äðàéâåðîì
143
	//return eax = îïðåäåëÿåòñÿ äðàéâåðîì
144
}
144
}
145
 
145
 
146
struct proc_info
146
struct proc_info
147
{
147
{
148
	#define SelfInfo -1
148
	#define SelfInfo -1
149
	dword	use_cpu;
149
	dword	use_cpu;
150
	word	pos_in_stack,num_slot,rezerv1;
150
	word	pos_in_stack,num_slot,rezerv1;
151
	unsigned char name[11];
151
	unsigned char name[11];
152
	char	rezerv2;
152
	char	rezerv2;
153
	dword	adress,use_memory,ID,left,top,width,height;
153
	dword	adress,use_memory,ID,left,top,width,height;
154
	word	status_slot,rezerv3;
154
	word	status_slot,rezerv3;
155
	dword	work_left,work_top,work_width,work_height;
155
	dword	work_left,work_top,work_width,work_height;
156
	char	status_window;
156
	char	status_window;
157
	dword   cwidth,cheight;
157
	dword   cwidth,cheight;
158
	byte    reserved[1024-71-8];
158
	byte    reserved[1024-71-8];
159
};
159
};
160
 
160
 
161
:void GetProcessInfo(dword _process_struct_pointer, _process_id)
161
:void GetProcessInfo(dword _process_struct_pointer, _process_id)
162
{
162
{
163
	skin_height = GetSkinHeight();
163
	skin_height = GetSkinHeight();
164
	EAX = 9;
164
	EAX = 9;
165
	EBX = _process_struct_pointer;
165
	EBX = _process_struct_pointer;
166
	ECX = _process_id;
166
	ECX = _process_id;
167
	$int  0x40
167
	$int  0x40
168
	DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth
168
	DSDWORD[EBX+71] = DSDWORD[EBX+42] - 9; //set cwidth
169
	DSDWORD[EBX+75] = DSDWORD[EBX+46] - skin_height - 4; //set cheight
169
	DSDWORD[EBX+75] = DSDWORD[EBX+46] - skin_height - 4; //set cheight
170
}
170
}
171
 
171
 
172
inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y
172
inline fastcall int GetPointOwner( EBX, ECX) //ebx=m.x, ecx=m.y
173
{
173
{
174
	$mov eax,34
174
	$mov eax,34
175
	$int 0x40
175
	$int 0x40
176
}
176
}
177
 
177
 
178
inline fastcall int GetProcessSlot( ECX)
178
inline fastcall int GetProcessSlot( ECX)
179
{
179
{
180
	EAX = 18;
180
	EAX = 18;
181
	EBX = 21;
181
	EBX = 21;
182
	$int 0x40
182
	$int 0x40
183
}
183
}
184
 
184
 
185
inline fastcall int GetActiveProcess()
185
inline fastcall int GetActiveProcess()
186
{
186
{
187
	EAX = 18;
187
	EAX = 18;
188
	EBX = 7;
188
	EBX = 7;
189
	$int 0x40
189
	$int 0x40
190
}
190
}
191
 
191
 
192
:int CheckActiveProcess(int Form_ID)
192
:int CheckActiveProcess(int Form_ID)
193
{
193
{
194
	int id9=GetProcessSlot(Form_ID);
194
	int id9=GetProcessSlot(Form_ID);
195
	if (id9==GetActiveProcess()) return 1;
195
	if (id9==GetActiveProcess()) return 1;
196
	return 0;
196
	return 0;
197
}
197
}
198
 
198
 
199
inline fastcall void ActivateWindow( ECX)
199
inline fastcall void ActivateWindow( ECX)
200
{
200
{
201
	EAX = 18;
201
	EAX = 18;
202
	EBX = 3;
202
	EBX = 3;
203
	$int 0x40
203
	$int 0x40
204
}
204
}
205
 
205
 
206
inline fastcall int MinimizeWindow()
206
inline fastcall int MinimizeWindow()
207
{
207
{
208
	EAX = 18;
208
	EAX = 18;
209
	EBX = 10;
209
	EBX = 10;
210
	$int 0x40
210
	$int 0x40
211
}
211
}
212
 
212
 
213
inline fastcall int CreateThread(ECX,EDX)
213
inline fastcall int CreateThread(ECX,EDX)
214
{
214
{
215
	$mov eax,51
215
	$mov eax,51
216
	$mov ebx,1
216
	$mov ebx,1
217
	$int 0x40
217
	$int 0x40
218
}
218
}
219
 
219
 
220
inline fastcall void SwitchToAnotherThread()
220
inline fastcall void SwitchToAnotherThread()
221
{
221
{
222
	$mov eax,68
222
	$mov eax,68
223
	$mov ebx,1
223
	$mov ebx,1
224
	$int 0x40
224
	$int 0x40
225
}
225
}
226
 
226
 
227
inline fastcall int SendWindowMessage( ECX, EDX)
227
inline fastcall int SendWindowMessage( ECX, EDX)
228
{
228
{
229
	$mov eax, 72
229
	$mov eax, 72
230
	$mov ebx, 1
230
	$mov ebx, 1
231
	$int 0x40
231
	$int 0x40
232
}
232
}
233
 
233
 
234
inline fastcall int KillProcess( ECX)
234
inline fastcall int KillProcess( ECX)
235
{
235
{
236
	$mov eax,18;
236
	$mov eax,18;
237
	$mov ebx,18;
237
	$mov ebx,18;
238
	$int 0x40
238
	$int 0x40
239
}
239
}
240
 
240
 
241
#define TURN_OFF 2
241
#define TURN_OFF 2
242
#define REBOOT 3
242
#define REBOOT 3
243
#define KERNEL 4
243
#define KERNEL 4
244
inline fastcall int ExitSystem( ECX)
244
inline fastcall int ExitSystem( ECX)
245
{
245
{
246
	$mov eax, 18
246
	$mov eax, 18
247
	$mov ebx, 9
247
	$mov ebx, 9
248
	$int 0x40
248
	$int 0x40
249
}
249
}
250
 
250
 
251
inline fastcall ExitProcess()
251
inline fastcall ExitProcess()
252
{
252
{
253
	$mov eax,-1;
253
	$mov eax,-1;
254
	$int 0x40
254
	$int 0x40
255
}
255
}
256
 
256
 
257
//------------------------------------------------------------------------------
257
//------------------------------------------------------------------------------
258
 
258
 
259
inline fastcall void SetCurDir( ECX)
259
inline fastcall void SetCurDir( ECX)
260
{
260
{
261
  EAX=30;
261
  EAX=30;
262
  EBX=1;
262
  EBX=1;
263
  $int 0x40
263
  $int 0x40
264
}
264
}
265
 
265
 
266
 
266
 
267
//eax = ÿçûê ñèñòåìû (1=eng, 2=fi, 3=ger, 4=rus)
267
//eax = ÿçûê ñèñòåìû (1=eng, 2=fi, 3=ger, 4=rus)
268
#define SYS_LANG_ENG 1
268
#define SYS_LANG_ENG 1
269
#define SYS_LANG_FIN 2
269
#define SYS_LANG_FIN 2
270
#define SYS_LANG_GER 3
270
#define SYS_LANG_GER 3
271
#define SYS_LANG_RUS 4
271
#define SYS_LANG_RUS 4
272
inline fastcall int GetSystemLanguage()
272
inline fastcall int GetSystemLanguage()
273
{
273
{
274
	EAX = 26;
274
	EAX = 26;
275
	EBX = 5;
275
	EBX = 5;
276
	$int 0x40
276
	$int 0x40
277
}
277
}
-
 
278
 
-
 
279
#define BUTTON_STYLE_FLAT 0
-
 
280
#define BUTTON_STYLE_GRADIENT 1
-
 
281
inline fastcall SetButtonStyle(ECX) //ECX - button style
-
 
282
{
-
 
283
	$mov eax,48
-
 
284
	$mov ebx,1
-
 
285
	int 64
-
 
286
}
278
 
287
 
279
inline fastcall GetSkinHeight()
288
inline fastcall GetSkinHeight()
280
{
289
{
281
	$push ebx
290
	$push ebx
282
	$mov  eax,48
291
	$mov  eax,48
283
	$mov  ebx,4
292
	$mov  ebx,4
284
	$int 0x40
293
	$int 0x40
285
	$pop  ebx
294
	$pop  ebx
286
}
295
}
287
 
296
 
288
inline fastcall void SetSystemSkin( ECX)
297
inline fastcall void SetSystemSkin( ECX)
289
{
298
{
290
	EAX = 48;
299
	EAX = 48;
291
	EBX = 8;
300
	EBX = 8;
292
	$int 0x40
301
	$int 0x40
293
}
302
}
294
 
303
 
295
inline fastcall int GetScreenWidth()
304
inline fastcall int GetScreenWidth()
296
{
305
{
297
	$mov eax, 14
306
	$mov eax, 14
298
	$int 0x40
307
	$int 0x40
299
	$shr eax, 16
308
	$shr eax, 16
300
}
309
}
301
 
310
 
302
inline fastcall int GetScreenHeight()
311
inline fastcall int GetScreenHeight()
303
{
312
{
304
	$mov eax, 14
313
	$mov eax, 14
305
	$int 0x40
314
	$int 0x40
306
	$and eax,0x0000FFFF
315
	$and eax,0x0000FFFF
307
}
316
}
308
 
317
 
309
inline fastcall int GetClientTop()
318
inline fastcall int GetClientTop()
310
{
319
{
311
	$mov eax, 48
320
	$mov eax, 48
312
	$mov ebx, 5
321
	$mov ebx, 5
313
	$int 0x40
322
	$int 0x40
314
	$mov eax, ebx
323
	$mov eax, ebx
315
	$shr eax, 16
324
	$shr eax, 16
316
}
325
}
317
 
326
 
318
inline fastcall int GetClientHeight()
327
inline fastcall int GetClientHeight()
319
{
328
{
320
	$mov eax, 48
329
	$mov eax, 48
321
	$mov ebx, 5
330
	$mov ebx, 5
322
	$int 0x40
331
	$int 0x40
323
	$mov eax, ebx
332
	$mov eax, ebx
324
}
333
}
325
 
334
 
326
inline fastcall dword LoadLibrary( ECX)
335
inline fastcall dword LoadLibrary( ECX)
327
{
336
{
328
	$mov eax, 68 
337
	$mov eax, 68 
329
	$mov ebx, 19
338
	$mov ebx, 19
330
	$int  0x40
339
	$int  0x40
331
}
340
}
332
 
341
 
333
inline fastcall int TestBit( EAX, CL)
342
inline fastcall int TestBit( EAX, CL)
334
{
343
{
335
	$shr eax,cl
344
	$shr eax,cl
336
	$and eax,1
345
	$and eax,1
337
}
346
}
338
 
347
 
339
:void SetClientScreenArea(dword _left, _right, _top, _bottom)
348
:void SetClientScreenArea(dword _left, _right, _top, _bottom)
340
{
349
{
341
	EAX = 48;
350
	EAX = 48;
342
	EBX = 6;
351
	EBX = 6;
343
	ECX = _left * 65536 + _right;
352
	ECX = _left * 65536 + _right;
344
	EDX = _top * 65536 + _bottom;
353
	EDX = _top * 65536 + _bottom;
345
	$int 64;
354
	$int 64;
346
}
355
}
347
 
356
 
348
//------------------------------------------------------------------------------
357
//------------------------------------------------------------------------------
349
 
358
 
350
:void DefineAndDrawWindow(dword _x, _y, _w, _h, _window_type, _bgcolor, _title, _flags)
359
:void DefineAndDrawWindow(dword _x, _y, _w, _h, _window_type, _bgcolor, _title, _flags)
351
{
360
{
352
	EAX = 12;              // function 12:tell os about windowdraw
361
	EAX = 12;              // function 12:tell os about windowdraw
353
	EBX = 1;
362
	EBX = 1;
354
	$int 0x40
363
	$int 0x40
355
	
364
	
356
	$xor EAX,EAX
365
	$xor EAX,EAX
357
	EBX = _x << 16 + _w; 
366
	EBX = _x << 16 + _w; 
358
	ECX = _y << 16 + _h;
367
	ECX = _y << 16 + _h;
359
	EDX = _window_type << 24 | _bgcolor;
368
	EDX = _window_type << 24 | _bgcolor;
360
	EDI = _title;
369
	EDI = _title;
361
	ESI = _flags;
370
	ESI = _flags;
362
	$int 0x40
371
	$int 0x40
363
 
372
 
364
 
373
 
365
	EAX = 12;              // function 12:tell os about windowdraw
374
	EAX = 12;              // function 12:tell os about windowdraw
366
	EBX = 2;
375
	EBX = 2;
367
	$int 0x40
376
	$int 0x40
368
}
377
}
369
 
378
 
370
inline fastcall MoveSize( EBX,ECX,EDX,ESI)
379
inline fastcall MoveSize( EBX,ECX,EDX,ESI)
371
{
380
{
372
	$mov eax, 67
381
	$mov eax, 67
373
	$int 0x40
382
	$int 0x40
374
}
383
}
375
 
384
 
376
inline fastcall void DrawTitle( ECX)
385
inline fastcall void DrawTitle( ECX)
377
{
386
{
378
	EAX = 71;
387
	EAX = 71;
379
	EBX = 1;
388
	EBX = 1;
380
	$int 0x40;
389
	$int 0x40;
381
}
390
}
382
 
391
 
383
// @EDX is a process id, -1 for self
392
// @EDX is a process id, -1 for self
384
// @ESI is a new LayerBehaviour
393
// @ESI is a new LayerBehaviour
385
// @RETURN: EAX, 0 is fail, 1 is success
394
// @RETURN: EAX, 0 is fail, 1 is success
386
#define ZPOS_DESKTOP     -2
395
#define ZPOS_DESKTOP     -2
387
#define ZPOS_ALWAYS_BACK -1
396
#define ZPOS_ALWAYS_BACK -1
388
#define ZPOS_NORMAL      0
397
#define ZPOS_NORMAL      0
389
#define ZPOS_ALWAYS_TOP  1
398
#define ZPOS_ALWAYS_TOP  1
390
inline fastcall dword SetWindowLayerBehaviour(EDX, ESI)
399
inline fastcall dword SetWindowLayerBehaviour(EDX, ESI)
391
{
400
{
392
	EAX = 18;
401
	EAX = 18;
393
	EBX = 25;
402
	EBX = 25;
394
	ECX = 2;
403
	ECX = 2;
395
	$int 64
404
	$int 64
396
}
405
}
397
 
406
 
398
:void WriteTextB(dword x,y,byte fontType, dword color, str_offset)
407
:void WriteTextB(dword x,y,byte fontType, dword color, str_offset)
399
{
408
{
400
	EAX = 4;
409
	EAX = 4;
401
	EBX = x<<16+y;
410
	EBX = x<<16+y;
402
	ECX = fontType<<24+color;
411
	ECX = fontType<<24+color;
403
	EDX = str_offset;
412
	EDX = str_offset;
404
	ESI = 0;
413
	ESI = 0;
405
	$int 0x40;
414
	$int 0x40;
406
	$add ebx, 1<<16
415
	$add ebx, 1<<16
407
	$int 0x40
416
	$int 0x40
408
}
417
}
409
 
418
 
410
:void WriteText(dword x,y,byte fontType, dword color, str_offset)
419
:void WriteText(dword x,y,byte fontType, dword color, str_offset)
411
{
420
{
412
	EAX = 4;
421
	EAX = 4;
413
	EBX = x<<16+y;
422
	EBX = x<<16+y;
414
	ECX = fontType<<24+color;
423
	ECX = fontType<<24+color;
415
	EDX = str_offset;
424
	EDX = str_offset;
416
	$int 0x40;
425
	$int 0x40;
417
}
426
}
418
 
427
 
419
:dword WriteBufText(dword x,y,byte fontType, dword color, str_offset, buf_offset)
428
:dword WriteBufText(dword x,y,byte fontType, dword color, str_offset, buf_offset)
420
{
429
{
421
	EAX = 4;
430
	EAX = 4;
422
	EBX = x<<16+y;
431
	EBX = x<<16+y;
423
	ECX = fontType<<24+color;
432
	ECX = fontType<<24+color;
424
	EDX = str_offset;
433
	EDX = str_offset;
425
	EDI = buf_offset;
434
	EDI = buf_offset;
426
	$int 0x40;
435
	$int 0x40;
427
}
436
}
428
 
437
 
429
:void WriteNumber(dword x,y,byte fontType, dword color, count, number_or_offset)
438
:void WriteNumber(dword x,y,byte fontType, dword color, count, number_or_offset)
430
{
439
{
431
	EAX = 47;
440
	EAX = 47;
432
	EBX = count<<16;
441
	EBX = count<<16;
433
	ECX = number_or_offset;
442
	ECX = number_or_offset;
434
	EDX = x<<16+y;
443
	EDX = x<<16+y;
435
	ESI = fontType<<24+color;
444
	ESI = fontType<<24+color;
436
	$int 0x40;
445
	$int 0x40;
437
}
446
}
438
 
447
 
439
:void CopyScreen(dword dst_offset, x, y, w, h)
448
:void CopyScreen(dword dst_offset, x, y, w, h)
440
{
449
{
441
  EAX = 36;
450
  EAX = 36;
442
  EBX = dst_offset;
451
  EBX = dst_offset;
443
  ECX = w << 16 + h;
452
  ECX = w << 16 + h;
444
  EDX = x << 16 + y;
453
  EDX = x << 16 + y;
445
  $int  0x40;
454
  $int  0x40;
446
}
455
}
447
 
456
 
448
:dword GetPixelColorFromScreen(dword _x, _y)
457
:dword GetPixelColorFromScreen(dword _x, _y)
449
{
458
{
450
	EAX = 35;
459
	EAX = 35;
451
	EBX = _y * screen.width + _x;
460
	EBX = _y * screen.width + _x;
452
	$int 64
461
	$int 64
453
}
462
}
454
 
463
 
455
#define DRAW_DESKTOP_BG_TILE 1
464
#define DRAW_DESKTOP_BG_TILE 1
456
#define DRAW_DESKTOP_BG_STRETCH 2
465
#define DRAW_DESKTOP_BG_STRETCH 2
457
:void SetBackgroundImage(dword w,h, image, mode)
466
:void SetBackgroundImage(dword w,h, image, mode)
458
{
467
{
459
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
468
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
460
	$mov     ebx,4       // SSF_MODE_BG 4 - set drawing mode for the background
469
	$mov     ebx,4       // SSF_MODE_BG 4 - set drawing mode for the background
461
	$mov     ecx,mode    // drawing mode - tile (1), stretch (2)
470
	$mov     ecx,mode    // drawing mode - tile (1), stretch (2)
462
	$int     64
471
	$int     64
463
 
472
 
464
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
473
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
465
	$mov     ebx,1       // SSF_SIZE_BG=1 - set a size of the background image
474
	$mov     ebx,1       // SSF_SIZE_BG=1 - set a size of the background image
466
	$mov     ecx,w       // width
475
	$mov     ecx,w       // width
467
	$mov     edx,h       // height
476
	$mov     edx,h       // height
468
	$int     64
477
	$int     64
469
 
478
 
470
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
479
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
471
	$mov     ebx,5       // SSF_IMAGE_BG=5 - put block of pixels on the background image
480
	$mov     ebx,5       // SSF_IMAGE_BG=5 - put block of pixels on the background image
472
	$mov     ecx,image   // pointer to the data in the format BBGGRRBBGGRR...
481
	$mov     ecx,image   // pointer to the data in the format BBGGRRBBGGRR...
473
	$mov     edx,0       // offset in data of the background image
482
	$mov     edx,0       // offset in data of the background image
474
	ESI      = 3*w*h;    // size of data in bytes = 3 * number of pixels
483
	ESI      = 3*w*h;    // size of data in bytes = 3 * number of pixels
475
	$int     64
484
	$int     64
476
 
485
 
477
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
486
	$mov     eax,15      // SF_BACKGROUND_SET 15 - work with desktop background graphics
478
	$mov     ebx,3       // SSF_REDRAW_BG=3 - redraw background
487
	$mov     ebx,3       // SSF_REDRAW_BG=3 - redraw background
479
	$int     64
488
	$int     64
480
}
489
}
481
 
490
 
482
:void _PutImage(dword x,y, w,h, data_offset)
491
:void _PutImage(dword x,y, w,h, data_offset)
483
{
492
{
484
	EAX = 7;
493
	EAX = 7;
485
	EBX = data_offset;
494
	EBX = data_offset;
486
	ECX = w<<16+h;
495
	ECX = w<<16+h;
487
	EDX = x<<16+y;
496
	EDX = x<<16+y;
488
	$int 0x40
497
	$int 0x40
489
}
498
}
490
 
499
 
491
:void PutPaletteImage(dword inbuf,w,h,x,y,bits,pal)
500
:void PutPaletteImage(dword inbuf,w,h,x,y,bits,pal)
492
{
501
{
493
	EAX = 65;
502
	EAX = 65;
494
	EBX = inbuf;
503
	EBX = inbuf;
495
	ECX = w<<16+h;
504
	ECX = w<<16+h;
496
	EDX = x<<16+y;
505
	EDX = x<<16+y;
497
	ESI = bits;
506
	ESI = bits;
498
	EDI = pal;
507
	EDI = pal;
499
	EBP = 0;
508
	EBP = 0;
500
	$int 0x40
509
	$int 0x40
501
}
510
}
502
 
511
 
503
inline fastcall void PutPixel( EBX,ECX,EDX)
512
inline fastcall void PutPixel( EBX,ECX,EDX)
504
{
513
{
505
  EAX=1;
514
  EAX=1;
506
  $int 0x40
515
  $int 0x40
507
}
516
}
508
 
517
 
509
:void DrawBar(dword x,y,w,h,color)
518
:void DrawBar(dword x,y,w,h,color)
510
{
519
{
511
	if (h<=0) || (h>60000) || (w<=0) || (w>60000) return; //bad boy :)
520
	if (h<=0) || (h>60000) || (w<=0) || (w>60000) return; //bad boy :)
512
	EAX = 13;
521
	EAX = 13;
513
	EBX = x<<16+w;
522
	EBX = x<<16+w;
514
	ECX = y<<16+h;
523
	ECX = y<<16+h;
515
	EDX = color;
524
	EDX = color;
516
	$int 0x40
525
	$int 0x40
517
}
526
}
518
 
527
 
519
:void DefineButton(dword x,y,w,h,id,color)
528
:void DefineButton(dword x,y,w,h,id,color)
520
{
529
{
521
	EAX = 8;
530
	EAX = 8;
522
	EDX = id + BT_DEL;
531
	EDX = id + BT_DEL;
523
	$int 0x40;
532
	$int 0x40;
524
	EDX = id;
533
	EDX = id;
525
	ESI = color;
534
	ESI = color;
526
	EBX = x<<16+w;
535
	EBX = x<<16+w;
527
	ECX = y<<16+h;
536
	ECX = y<<16+h;
528
	$int 0x40
537
	$int 0x40
529
}
538
}
530
 
539
 
531
inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)
540
inline RefreshWindow(dword ID_REFRESH,ID_ACTIVE)
532
{
541
{
533
	EAX = 18;
542
	EAX = 18;
534
	EBX = 22;
543
	EBX = 22;
535
	ECX = 3;
544
	ECX = 3;
536
	EDX = ID_REFRESH;
545
	EDX = ID_REFRESH;
537
	$int 0x40
546
	$int 0x40
538
	EAX = 18;
547
	EAX = 18;
539
	EBX = 3;
548
	EBX = 3;
540
	EDX = ID_ACTIVE;
549
	EDX = ID_ACTIVE;
541
	$int 0x40
550
	$int 0x40
542
}
551
}
543
 
552
 
544
:void UnsafeDefineButton(dword x,y,w,h,id,color)
553
:void UnsafeDefineButton(dword x,y,w,h,id,color)
545
{
554
{
546
	EAX = 8;
555
	EAX = 8;
547
	EBX = x<<16+w;
556
	EBX = x<<16+w;
548
	ECX = y<<16+h;
557
	ECX = y<<16+h;
549
	EDX = id;
558
	EDX = id;
550
	ESI = color;
559
	ESI = color;
551
	$int 0x40
560
	$int 0x40
552
}
561
}
553
 
562
 
554
:void DefineDragableWindow(dword _x, _y, _w, _h)
563
:void DefineDragableWindow(dword _x, _y, _w, _h)
555
{
564
{
556
	DefineAndDrawWindow(_x, _y, _w, _h, 0x41,0x000000,NULL,0b);
565
	DefineAndDrawWindow(_x, _y, _w, _h, 0x41,0x000000,NULL,0b);
557
}
566
}
558
 
567
 
559
:void DefineUnDragableWindow(dword _x, _y, _w, _h)
568
:void DefineUnDragableWindow(dword _x, _y, _w, _h)
560
{
569
{
561
	DefineAndDrawWindow(_x, _y, _w, _h, 0x01, 0, 0, 0x01fffFFF);
570
	DefineAndDrawWindow(_x, _y, _w, _h, 0x01, 0, 0, 0x01fffFFF);
562
}
571
}
563
 
572
 
564
:void EventDragWindow()
573
:void EventDragWindow()
565
{
574
{
566
	dword tmp_x,tmp_y;
575
	dword tmp_x,tmp_y;
567
	dword z1,z2;
576
	dword z1,z2;
568
	tmp_x = mouse.x;
577
	tmp_x = mouse.x;
569
	tmp_y = mouse.y;
578
	tmp_y = mouse.y;
570
	do {
579
	do {
571
		mouse.get();
580
		mouse.get();
572
		if (tmp_x!=mouse.x) || (tmp_y!=mouse.y) 
581
		if (tmp_x!=mouse.x) || (tmp_y!=mouse.y) 
573
		{
582
		{
574
			z1 = Form.left + mouse.x - tmp_x;
583
			z1 = Form.left + mouse.x - tmp_x;
575
			z2 = Form.top + mouse.y - tmp_y;
584
			z2 = Form.top + mouse.y - tmp_y;
576
			if(z1<=10) || (z1>20000) z1=0; else if(z1>screen.width-Form.width-10)z1=screen.width-Form.width;
585
			if(z1<=10) || (z1>20000) z1=0; else if(z1>screen.width-Form.width-10)z1=screen.width-Form.width;
577
			if(z2<=10) || (z2>20000) z2=0; else if(z2>screen.height-Form.height-10)z2=screen.height-Form.height;
586
			if(z2<=10) || (z2>20000) z2=0; else if(z2>screen.height-Form.height-10)z2=screen.height-Form.height;
578
			MoveSize(z1 , z2, OLD, OLD);
587
			MoveSize(z1 , z2, OLD, OLD);
579
			draw_window();
588
			draw_window();
580
		}
589
		}
581
		pause(1);
590
		pause(1);
582
	} while (mouse.lkm);
591
	} while (mouse.lkm);
583
}
592
}
584
 
593
 
585
:void DefineHiddenButton(dword _x, _y, _w, _h, _id)
594
:void DefineHiddenButton(dword _x, _y, _w, _h, _id)
586
{
595
{
587
	DefineButton(_x, _y, _w, _h, _id + BT_HIDE, 0);
596
	DefineButton(_x, _y, _w, _h, _id + BT_HIDE, 0);
588
}
597
}
589
 
598
 
590
inline fastcall void DeleteButton( EDX)
599
inline fastcall void DeleteButton( EDX)
591
{
600
{
592
	EAX = 8;
601
	EAX = 8;
593
	EDX += BT_DEL;
602
	EDX += BT_DEL;
594
	$int 0x40
603
	$int 0x40
595
}
604
}
596
 
605
 
597
inline fastcall dword GetStartTime()
606
inline fastcall dword GetStartTime()
598
{
607
{
599
	$mov eax,26
608
	$mov eax,26
600
	$mov ebx,9
609
	$mov ebx,9
601
	$int 0x40
610
	$int 0x40
602
}
611
}
603
 
612
 
604
:dword X_EventRedrawWindow,Y_EventRedrawWindow;
613
:dword X_EventRedrawWindow,Y_EventRedrawWindow;
605
:void _EventRedrawWindow()
614
:void _EventRedrawWindow()
606
{
615
{
607
	loop()switch(WaitEvent())
616
	loop()switch(WaitEvent())
608
	{
617
	{
609
		case evReDraw:
618
		case evReDraw:
610
			DefineAndDrawWindow(X_EventRedrawWindow,Y_EventRedrawWindow,100,1,0x34,0xFFFFFF,NULL,0);
619
			DefineAndDrawWindow(X_EventRedrawWindow,Y_EventRedrawWindow,100,1,0x34,0xFFFFFF,NULL,0);
611
			pause(10);
620
			pause(10);
612
			ExitProcess();
621
			ExitProcess();
613
			break;
622
			break;
614
	}
623
	}
615
}
624
}
616
:char REDRAW_BUFF_EVENT_[4096];
625
:char REDRAW_BUFF_EVENT_[4096];
617
:void EventRedrawWindow(dword x,y)
626
:void EventRedrawWindow(dword x,y)
618
{
627
{
619
	X_EventRedrawWindow = x;
628
	X_EventRedrawWindow = x;
620
	Y_EventRedrawWindow = y;
629
	Y_EventRedrawWindow = y;
621
	CreateThread(#_EventRedrawWindow,#REDRAW_BUFF_EVENT_+4092);
630
	CreateThread(#_EventRedrawWindow,#REDRAW_BUFF_EVENT_+4092);
622
}
631
}
623
 
632
 
624
:struct _screen
633
:struct _screen
625
{
634
{
626
	dword width,height;
635
	dword width,height;
627
} screen;
636
} screen;
628
 
637
 
629
:byte skin_height;
638
:byte skin_height;
630
 
639
 
631
:void DrawDate(dword x, y, color, in_date)
640
:void DrawDate(dword x, y, color, in_date)
632
{
641
{
633
	EDI = in_date;
642
	EDI = in_date;
634
	EAX = 47;
643
	EAX = 47;
635
	EBX = 2<<16;
644
	EBX = 2<<16;
636
	EDX = x<<16+y;
645
	EDX = x<<16+y;
637
	ESI = 0x90<<24+color;
646
	ESI = 0x90<<24+color;
638
	ECX = EDI.date.day;
647
	ECX = EDI.date.day;
639
	$int 0x40;
648
	$int 0x40;
640
	EDX += 20<<16;
649
	EDX += 20<<16;
641
	ECX = EDI.date.month;
650
	ECX = EDI.date.month;
642
	$int 0x40;
651
	$int 0x40;
643
	EDX += 20<<16;
652
	EDX += 20<<16;
644
	EBX = 4<<16;
653
	EBX = 4<<16;
645
	ECX = EDI.date.year;
654
	ECX = EDI.date.year;
646
	$int 0x40;
655
	$int 0x40;
647
	DrawBar(x+17,y+10,2,2,color);
656
	DrawBar(x+17,y+10,2,2,color);
648
	DrawBar(x+37,y+10,2,2,color);
657
	DrawBar(x+37,y+10,2,2,color);
649
}
658
}
650
 
659
 
651
:void __path_name__(dword BUF,PATH)
660
:void __path_name__(dword BUF,PATH)
652
{
661
{
653
	dword beg = PATH;
662
	dword beg = PATH;
654
	dword pos = PATH;
663
	dword pos = PATH;
655
	dword sav = PATH;
664
	dword sav = PATH;
656
	dword i;
665
	dword i;
657
	while(DSBYTE[pos])
666
	while(DSBYTE[pos])
658
	{
667
	{
659
		if(DSBYTE[pos]=='/')sav = pos;
668
		if(DSBYTE[pos]=='/')sav = pos;
660
		pos++;
669
		pos++;
661
	}
670
	}
662
	i = sav-beg;
671
	i = sav-beg;
663
	while(i)
672
	while(i)
664
	{
673
	{
665
		DSBYTE[BUF] = DSBYTE[beg];
674
		DSBYTE[BUF] = DSBYTE[beg];
666
		beg++;
675
		beg++;
667
		BUF++;
676
		BUF++;
668
		i--;
677
		i--;
669
	}
678
	}
670
	/*while(DSBYTE[beg])
679
	/*while(DSBYTE[beg])
671
	{
680
	{
672
		DSBYTE[BUF1] = DSBYTE[beg];
681
		DSBYTE[BUF1] = DSBYTE[beg];
673
		beg++;
682
		beg++;
674
		BUF1++;
683
		BUF1++;
675
	}*/
684
	}*/
676
	//DSBYTE[BUF1] = 0;
685
	//DSBYTE[BUF1] = 0;
677
	DSBYTE[BUF] = 0;
686
	DSBYTE[BUF] = 0;
678
}
687
}
679
char __BUF_DIR__[4096];
688
char __BUF_DIR__[4096];
680
:struct SELF
689
:struct SELF
681
{
690
{
682
	dword dir;
691
	dword dir;
683
	dword file;
692
	dword file;
684
	dword path;
693
	dword path;
685
} self;
694
} self;
686
 
695
 
687
dword __generator;  // random number generator - äëÿ ãåíåðàöèè ñëó÷àéíûõ ÷èñåë
696
dword __generator;  // random number generator - äëÿ ãåíåðàöèè ñëó÷àéíûõ ÷èñåë
688
 
697
 
689
:dword program_path_length;
698
:dword program_path_length;
690
 
699
 
691
//The initialization of the initial data before running
700
//The initialization of the initial data before running
692
void ______INIT______()
701
void ______INIT______()
693
{
702
{
694
	//if (program_path[0]!='/') I_Path++;
703
	//if (program_path[0]!='/') I_Path++;
695
	
704
	
696
	self.dir = #__BUF_DIR__;
705
	self.dir = #__BUF_DIR__;
697
	self.file = 0;
706
	self.file = 0;
698
	self.path = I_Path;
707
	self.path = I_Path;
699
	__path_name__(#__BUF_DIR__,I_Path);
708
	__path_name__(#__BUF_DIR__,I_Path);
700
	
709
	
701
	skin_height   = GetSkinHeight();
710
	skin_height   = GetSkinHeight();
702
	screen.width  = GetScreenWidth()+1;
711
	screen.width  = GetScreenWidth()+1;
703
	screen.height = GetScreenHeight()+1;
712
	screen.height = GetScreenHeight()+1;
704
	
713
	
705
	__generator = GetStartTime();
714
	__generator = GetStartTime();
706
	
715
	
707
	mem_init();
716
	mem_init();
708
 
717
 
709
 
718
 
710
	main();
719
	main();
711
	ExitProcess();
720
	ExitProcess();
712
}
721
}
713
______STOP______:
722
______STOP______:
714
#endif
723
#endif
715
 
724
 
716
#ifndef INCLUDE_MEM_H
725
#ifndef INCLUDE_MEM_H
717
#include "../lib/mem.h"
726
#include "../lib/mem.h"
718
#endif
727
#endif
719
 
728
 
720
#ifndef INCLUDE_DEBUG_H
729
#ifndef INCLUDE_DEBUG_H
721
#include "../lib/debug.h"
730
#include "../lib/debug.h"
722
#endif
731
#endif
723
>
732
>
724
>
733
>
725
>
734
>
726
>
735
>
727
>
736
>
728
>
737
>
729
>
738
>
730
>
739
>
731
>
740
>
732
>
741
>
733
>
742
>
734
>
743
>
735
>
744
>
736
>
745
>
737
>
746
>
738
>
747
>
739
>
748
>
740
>
749
>
741
>
750
>
742
>
751
>
743
>
752
>
744
>
753
>
745
>
754
>
746
>
755
>
747
>
756
>
748
>
757
>
749
>
758
>
750
>
759
>
751
>
760
>
752
>
761
>
753
>
762
>
754
>
763
>
755
>
764
>
756
>
765
>
757
>
766
>
758
>
767
>
759
>
768
>
760
>
769
>
761
>
770
>
762
>
771
>
763
>
772
>
764
>
773
>
765
>
774
>
766
>
775
>
767
>
776
>
768
>
777
>
769
>
778
>
770
>
779
>
771
>
780
>
772
>
781
>
773
>
782
>
774
>
783
>