/programs/cmm/notify/Tupfile.lua |
---|
File deleted |
/programs/cmm/notify/notify.c |
---|
File deleted |
/programs/cmm/notify/compile_en.bat |
---|
File deleted |
/programs/cmm/notify/compile_ru.bat |
---|
File deleted |
/programs/cmm/notify |
---|
Property changes: |
Deleted: tsvn:logminsize |
-5 |
\ No newline at end of property |
/programs/cmm/easyshot/compile_en.bat |
---|
File deleted |
/programs/cmm/easyshot/easyshot.c |
---|
File deleted |
/programs/cmm/easyshot/compile_ru.bat |
---|
File deleted |
/programs/cmm/easyshot/Tupfile.lua |
---|
File deleted |
/programs/cmm/easyshot |
---|
Property changes: |
Deleted: tsvn:logminsize |
-5 |
\ No newline at end of property |
/programs/cmm/pipet/pipet.c |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/pipet/Tupfile.lua |
---|
File deleted |
/programs/cmm/pipet/compile_en.bat |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/Calypte/compile_en.bat |
---|
File deleted |
/programs/cmm/Calypte/Calypte.c |
---|
File deleted |
/programs/cmm/Calypte/Tupfile.lua |
---|
File deleted |
/programs/cmm/Calypte |
---|
Property changes: |
Deleted: tsvn:logminsize |
-5 |
\ No newline at end of property |
/programs/cmm/mblocks/mblocks.c |
---|
File deleted |
/programs/cmm/mblocks/compile_en.bat |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/mblocks/Tupfile.lua |
---|
File deleted |
/programs/cmm/python/static/head.h |
---|
File deleted |
/programs/cmm/python/static/init.h |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/static/function.h |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/static/lib.h |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/static/opcode.h |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/static/array.h |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/examples/example.py |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/python/examples/dectohex.py |
---|
File deleted |
\ No newline at end of file |
/programs/cmm/software_widget/Tupfile.lua |
---|
File deleted |
/programs/cmm/software_widget/compile.bat |
---|
File deleted |
/programs/cmm/software_widget/software_widget.c |
---|
File deleted |
/programs/cmm/software_widget |
---|
Property changes: |
Deleted: tsvn:logminsize |
-5 |
\ No newline at end of property |
/programs/cmm/kolibrin/Tupfile.lua |
---|
File deleted |
/programs/cmm/kolibrin/kolibrin.c |
---|
File deleted |
/programs/cmm/kolibrin/compile.bat |
---|
File deleted |
/programs/cmm/kolibrin |
---|
Property changes: |
Deleted: tsvn:logminsize |
-5 |
\ No newline at end of property |
/programs/cmm/experimental/python/static/array.h |
---|
0,0 → 1,266 |
:dword arrayInit(dword len) |
{ |
dword alloc = 0; |
dword position = 0; |
alloc = malloc(len*4+MEMBUF); |
position = alloc; |
DSDWORD[position] = 0; |
position+=4; |
DSDWORD[position] = len; |
return alloc; |
} |
:dword ReallocArray(dword array,nMem) |
{ |
dword NEW = 0; |
dword OLD = 0; |
dword FLEN = 0; |
dword LEN = 0; |
//test2("relloc",0); |
OLD = array; |
FLEN = nMem*4+8; |
LEN = DSDWORD[array]; |
NEW = arrayInit(nMem); |
array+=8; |
while(LEN) |
{ |
A = DSDWORD[array]; |
IF(A) |
{ |
arraySet(#NEW,DSDWORD[A],DSDWORD[A+4]); |
free(A); |
} |
LEN--; |
array+=4; |
} |
free(OLD); |
return NEW; |
} |
:byte arraySet(dword array,key,value) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword FLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
dword OST = 0; |
dword BEGIN = 0; |
dword gArray = 0; |
gArray = DSDWORD[array]; |
IF(gArray) |
{ |
LEN = DSDWORD[gArray]; |
OST = DSDWORD[gArray+4]; |
} |
ELSE |
{ |
LEN = 0; |
OST = 8; |
} |
IF(LEN) |
{ |
IF(!(LEN%OST)) |
{ |
gArray = ReallocArray(gArray,OST<<1); |
DSDWORD[array] = gArray; |
} |
} |
ELSE |
{ |
gArray = arrayInit(OST); |
DSDWORD[array] = gArray; |
} |
BEGIN = gArray; |
gArray+=4; |
FLEN = DSDWORD[gArray]; |
gArray+=4; |
POSITION = key%FLEN*4+gArray; |
FULL = FLEN*4+gArray; |
LOOP_COL2: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) |
{ |
NEW = malloc(8); |
DSDWORD[NEW] = key; |
DSDWORD[NEW+4] = value; |
DSDWORD[POSITION] = NEW; |
DSDWORD[BEGIN] = DSDWORD[BEGIN]+1; |
return 1; |
} |
IF(DSDWORD[VKEY] == key) |
{ |
DSDWORD[VKEY+4] = value; |
return 2; |
} |
// collision |
POSITION+=4; |
IF(POSITION>FULL) POSITION = gArray+8; |
goto LOOP_COL2; |
return 3; |
} |
:dword arrayGet(dword array,key) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword MEMLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
LEN = DSDWORD[array]; |
array+=4; |
MEMLEN = DSDWORD[array]; |
array+=4; |
POSITION = key%MEMLEN*4+array; |
FULL = LEN*4+array; |
Z = 2; |
LOOP_COL1: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) return 0; |
IF(DSDWORD[VKEY] == key) return DSDWORD[VKEY+4]; |
// collision |
POSITION+=4; |
IF(POSITION>FULL) |
{ |
POSITION = array+8; |
Z--; |
IF(!Z) return 0; |
} |
goto LOOP_COL1; |
} |
:dword arrayDelete(dword array,key) |
{ |
dword NEW = 0; |
dword LEN = 0; |
dword MEMLEN = 0; |
dword POSITION = 0; |
dword VKEY = 0; |
dword FULL = 0; |
dword TMP = 0; |
LEN = DSDWORD[array]; |
array+=4; |
MEMLEN = DSDWORD[array]; |
array+=4; |
POSITION = key%MEMLEN*4+array; |
FULL = LEN*4+array; |
Z = 2; |
LOOP_COL1: |
VKEY = DSDWORD[POSITION]; |
IF(!VKEY) return 0; |
IF(DSDWORD[VKEY] == key) |
{ |
TMP = DSDWORD[VKEY+4]; |
free(VKEY); |
DSDWORD[POSITION] = 0; |
DSDWORD[array] = DSDWORD[array]-1; |
return TMP; |
} |
// collision |
POSITION+=4; |
IF(POSITION>FULL) |
{ |
POSITION = array+8; |
Z--; |
IF(!Z) return 0; |
} |
goto LOOP_COL1; |
} |
// dict |
:dword hash(dword str) |
{ |
byte S = 0; |
dword s1 = 0; |
dword s2 = 0; |
S = DSBYTE[str]; |
WHILE(S) |
{ |
s1 += S; |
s2 += s1; |
S = DSBYTE[str]; |
str++; |
} |
s1<<=16; |
RETURN s1|s2; |
} |
:byte dictSet(dword array,key,data) |
{ |
RETURN arraySet(array,hash(key),data); |
} |
:byte dictDel(dword array,key) |
{ |
RETURN arrayDelete(array,hash(key)); |
} |
:dword dictGet(dword array,key) |
{ |
RETURN arrayGet(array,hash(key)); |
} |
// list |
:void listAppend(dword position,data) // TODO Fixed!! |
{ |
dword len = 0; |
dword flen = 0; |
dword news = 0; |
dword array = 0; |
dword i = 0; |
array = DSDWORD[position]; |
len = DSDWORD[array]; |
flen = DSDWORD[array+4]; |
IF(len>=flen) |
{ |
news = malloc(flen<<3+8); |
DSDWORD[position] = news; |
i = flen<<1+2; |
while(i) |
{ |
DSDWORD[news] = DSDWORD[array]; |
news+=4; |
array+=4; |
i--; |
} |
array = news; |
} |
DSDWORD[len*4+array+8] = data; |
DSDWORD[array] = DSDWORD[array]+1; |
} |
:dword listGet(dword array,key) |
{ |
return DSDWORD[key*4+array+8]; |
} |
/programs/cmm/experimental/python/static/function.h |
---|
0,0 → 1,114 |
:void copyVariable(dword x) |
{ |
load_const(DSDWORD[x],DSBYTE[x+4],DSDWORD[x+5]); |
} |
:dword LenStdout = 0; |
:void _stdout(dword txt) |
{ |
dword addr = txt; |
WHILE(DSBYTE[addr]) addr++; |
IF(!LenStdout) |
{ |
LenStdout = addr-txt; |
CreateFile(LenStdout,txt,"/sys/stdout"); |
} |
ELSE |
{ |
AddFile(LenStdout,addr-txt,txt,"/sys/stdout"); |
LenStdout+=addr-txt; |
} |
} |
:dword std__stdStr(dword count) |
{ |
return _str(popFast()); |
} |
:dword stdcall std__stdout(dword count) |
{ |
std__str(count); |
popStack(); |
_stdout(DSDWORD[EAX]); |
} |
:dword stdcall std__len(dword c) |
{ |
popFast(); |
load_const(DSDWORD[EAX+5],PY_INT,0); |
RETURN 0; |
} |
:dword stdcall std__INT40(dword c) |
{ |
X = popFast(); |
Y = DSDWORD[X+5]; |
X = DSDWORD[X]; |
X = DSDWORD[X]; |
X = DSDWORD[X]; |
test(X,1); |
RETURN 0; |
} |
:void hexAddress(dword x,y) |
{ |
dword i = 0; |
i = 8; |
WHILE(i) |
{ |
DSBYTE[x] = DSBYTE[y&0xF+#arraySymbolHEX]; |
y>>=4; |
x--; |
i--; |
} |
} |
#define rSize DSBYTE[#RDATA+5] |
#define rData DSBYTE[#RDATA] |
#define rType DSBYTE[#RDATA+4] |
:dword stdcall std__str(dword c) |
{ |
dword n = 0; |
dword m = 0; |
dword l = 0; |
dword v = 0; |
dword f = "<function a at 0x00000000>"; |
dword t = 0; |
dword o = 0; |
v = popFast(); |
IF(DSBYTE[v+4] == PY_STR) |
{ |
copyVariable(v); |
return 0; |
} |
switch(DSBYTE[v+4]) |
{ |
case PY_BOOL: |
if(DSDWORD[v]) |
{ |
load_const("True",PY_STR,4); |
return 0; |
} |
load_const("False",PY_STR,5); |
return 0; |
break; |
case PY_INT: |
m = malloc(MEMBUF); |
l = itoa(DSDWORD[v],m); |
load_const(m,PY_STR,l); |
return 0; |
break; |
case PY_NONE: |
load_const("None",PY_STR,4); |
return 0; |
break; |
case PY_FNC: |
hexAddress(f+24,v); |
load_const(f,PY_STR,26); |
return 0; |
break; |
} |
} |
/programs/cmm/experimental/python/static/gui.h |
---|
--- cmm/experimental/python/static/head.h (nonexistent) |
+++ cmm/experimental/python/static/head.h (revision 7911) |
@@ -0,0 +1,100 @@ |
+#pragma option OST |
+#pragma option ON |
+#pragma option cri- |
+#pragma option -CPA |
+#initallvar 0 |
+#jumptomain FALSE |
+ |
+#startaddress 65536 |
+ |
+#code32 TRUE |
+ |
+#define PY_NONE 0 |
+#define PY_BOOL 1 |
+#define PY_INT 2 |
+#define PY_FLT 3 |
+#define PY_STR 4 |
+#define PY_FNC 6 |
+#define PY_CPL 7 |
+#define PY_LST 8 |
+#define PY_TPL 9 |
+#define PY_RNG 10 |
+#define PY_BTS 11 |
+#define PY_BTA 12 |
+#define PY_MVW 13 |
+#define PY_SET 14 |
+#define PY_FST 15 |
+#define PY_DCT 16 |
+#define PY_CLS 17 |
+#define PY_MDL 18 |
+ |
+#define PY_STD_FNC 30 |
+ |
+#define PY_NA_STR 32 |
+#define PY_SYM_STR 33 |
+ |
+ |
+#define PY_ADD 0 |
+#define PY_POW 1 |
+#define PY_MUL 2 |
+#define PY_SUB 3 |
+#define PY_DIV 4 |
+#define PY_MOD 5 |
+#define PY_XOR 6 |
+#define PY_AND 7 |
+#define PY__OR 8 |
+#define PY_LSH 9 |
+#define PY_RSH 10 |
+#define PY_FDV 11 |
+#define PY_TDV 12 |
+ |
+#define MEMBUF 0xF |
+#define MEMARR 0xF |
+ |
+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 = 160000; |
+dword x86esp_reg = 160000; |
+dword I_Param = #param; |
+dword I_Path = #program_path; |
+char param[4096]={0}; |
+char program_path[4096]={0}; |
+ |
+:dword arraySymbolHEX = "0123456789ABCDEF"; |
+:dword libPath = "/sys/lib/"; |
+:dword HASH = 0; |
+:dword TEMP = 0; |
+:dword RDATA[30] = {0}; |
+ |
+// global variable |
+:dword X = 0; |
+:dword Y = 0; |
+:dword Z = 0; |
+:dword A = 0; |
+:dword B = 0; |
+:dword C = 0; |
+:dword D = 0; |
+:dword E = 0; |
+:dword F = 0; |
+ |
+:dword beginStack = 0; |
+ |
+:dword COUNT_CONST = 0; |
+ |
+:byte std__STRING = 0; |
+:byte std__INTEGER = 1; |
+ |
+:byte S = 0; |
+//-------------- |
+ |
+:struct f70{ |
+ dword func; |
+ dword param1; |
+ dword param2; |
+ dword param3; |
+ dword param4; |
+ char rezerv; |
+ dword name; |
+}; |
/programs/cmm/experimental/python/static/init.h |
---|
0,0 → 1,375 |
:void ExitProcess() |
{ |
EAX = -1; |
$int 0x40 |
} |
:f70 write_file_70; |
:int CreateFile(dword data_size, buffer, file_path) |
{ |
write_file_70.func = 2; |
write_file_70.param1 = 0; |
write_file_70.param2 = 0; |
write_file_70.param3 = data_size; |
write_file_70.param4 = buffer; |
write_file_70.rezerv = 0; |
write_file_70.name = file_path; |
$mov eax,70 |
$mov ebx,#write_file_70.func |
$int 0x40 |
} |
:int AddFile(dword begin,data_size, buffer, file_path) |
{ |
write_file_70.func = 3; |
write_file_70.param1 = begin; |
write_file_70.param2 = 0; |
write_file_70.param3 = data_size; |
write_file_70.param4 = buffer; |
write_file_70.rezerv = 0; |
write_file_70.name = file_path; |
$mov eax,70 |
$mov ebx,#write_file_70.func |
$int 0x40 |
} |
dword malloc(dword size) |
{ |
$push ebx |
$push ecx |
$mov eax, 68 |
$mov ebx, 12 |
$mov ecx, size |
$int 0x40 |
$pop ecx |
$pop ebx |
return EAX; |
} |
dword free(dword mptr) |
{ |
$push ebx |
$push ecx |
$mov eax, 68 |
$mov ebx, 13 |
$mov ecx, mptr |
$test ecx, ecx |
$jz end0 |
$int 0x40 |
@end0: |
$pop ecx |
$pop ebx |
return 0; |
} |
stdcall dword realloc(dword mptr, size) |
{ |
$push ebx |
$push ecx |
$push edx |
$mov eax, 68 |
$mov ebx, 20 |
$mov ecx, size |
$mov edx, mptr |
$int 0x40 |
$pop edx |
$pop ecx |
$pop ebx |
return EAX; |
} |
:void memcpy(dword x,y,size) |
{ |
dword ost = 0; |
dword del = 0; |
del = size/4; |
ost = size%4; |
WHILE(del) |
{ |
DSDWORD[x] = DSDWORD[y]; |
del--; |
x+=4; |
y+=4; |
} |
IF(ost>1) |
{ |
DSWORD[x] = DSWORD[y]; |
x+=2; |
y+=2; |
ost-=2; |
} |
IF(ost==1) DSBYTE[x] = DSBYTE[y]; |
} |
:dword sleep(dword x) |
{ |
EAX = 5; |
EBX = x; |
$int 0x40 |
} |
:dword memInit() |
{ |
$push ebx |
$mov eax, 68 |
$mov ebx, 11 |
$int 0x40 |
$pop ebx |
return EAX; |
} |
:dword itoa(signed long number,dword p) |
{ |
dword ret=0; |
byte cmd=0; |
long mask=0; |
long tmp=0; |
IF(!number) |
{ |
DSBYTE[p] = '0'; |
p++; |
DSBYTE[p] = 0; |
return 1; |
} |
mask = 1000000000; |
cmd = 1; |
if(!number){ |
ESBYTE[p] = '0'; |
ESBYTE[p+1] = 0; |
return p; |
} |
ret = p; |
if(number<0) |
{ |
$neg number |
ESBYTE[p] = '-'; |
$inc p |
} |
while(mask) |
{ |
tmp = number / mask; |
tmp = tmp%10; |
if(cmd){ |
if(tmp){ |
ESBYTE[p] = tmp + '0'; |
$inc p |
cmd = 0; |
} |
} |
else { |
ESBYTE[p] = tmp + '0'; |
$inc p |
} |
mask /= 10; |
} |
ESBYTE[p] = 0; |
return p - ret; |
} |
:dword strcpy(dword s1,s2) |
{ |
X = s1; |
WHILE(DSBYTE[s2]) |
{ |
DSBYTE[s1] = DSBYTE[s2]; |
s1++; |
s2++; |
} |
RETURN s1-X; |
} |
:dword strlcpy(dword s1,s2,l) |
{ |
X = l; |
WHILE(l) |
{ |
DSBYTE[s1] = DSBYTE[s2]; |
s1++; |
s2++; |
l--; |
} |
RETURN X; |
} |
:dword _str(dword v) |
{ |
SWITCH(DSBYTE[v+4]) |
{ |
CASE PY_STR: |
RETURN DSDWORD[v]; |
CASE PY_BOOL: |
IF(DSDWORD[v]) RETURN "True"; |
RETURN "False"; |
} |
} |
:dword stack = 0; |
:dword popStack() |
{ |
stack-=4; |
RETURN DSDWORD[stack]; |
} |
:void pushStack(dword x) |
{ |
dword tmp = 0; |
IF(!DSDWORD[stack]) tmp = malloc(30); |
ELSE tmp = DSDWORD[stack]; |
IF(x) memcpy(tmp,x,30); |
DSDWORD[stack] = tmp; |
stack+=4; |
} |
:dword stackFast = 0; |
:dword beginStackFast = 0; |
:dword popFast() |
{ |
stackFast-=4; |
RETURN DSDWORD[stackFast]; |
} |
:void pushFast(dword x) |
{ |
dword tmp = 0; |
IF(!DSDWORD[stackFast]) tmp = malloc(30); |
ELSE tmp = DSDWORD[stackFast]; |
IF(x) memcpy(tmp,x,30); |
DSDWORD[stackFast] = tmp; |
stackFast+=4; |
} |
:dword stackLoop = 0; |
:dword popLoop() |
{ |
stackLoop-=4; |
RETURN DSDWORD[stackLoop]; |
} |
:void pushLoop(dword x) |
{ |
DSDWORD[stackLoop] = x; |
stackLoop+=4; |
} |
:void checkType(dword x,y) |
{ |
IF(DSBYTE[x+4]!=DSBYTE[y+4]) |
{ |
_stdout("Error type!"); |
ExitProcess(); |
} |
} |
:void sprintf(dword str, ...) |
{ |
//S = DSBYTE[format]; |
X = DSDWORD[ESP]-ESP-8; |
X += ESP; |
A = DSDWORD[X]; |
X-=4; |
B = DSDWORD[X]; |
S = DSBYTE[B]; |
while(S) |
{ |
if(S=='%') |
{ |
B++; |
S = DSBYTE[B]; |
IF(S=='s') |
{ |
X-=4; |
strcpy(A,DSDWORD[X]); |
A+=EAX; |
B++; |
S = DSBYTE[B]; |
continue; |
} |
IF(S=='c') |
{ |
X-=4; |
EAX = DSDWORD[X]; |
test(EAX,1); |
A++; |
B++; |
S = DSBYTE[B]; |
continue; |
} |
ELSE IF(S=='d') |
{ |
} |
ELSE |
{ |
DSBYTE[A] = S; |
A++; |
} |
} |
else |
{ |
DSBYTE[A] = S; |
A++; |
} |
B++; |
S = DSBYTE[B]; |
} |
} |
:byte BUFTST[15] = {0}; |
:void test1(dword x,y) |
{ |
IF(y) |
{ |
itoa(x,#BUFTST); |
_stdout(#BUFTST); |
} |
ELSE _stdout(x); |
EAX = -1; |
$int 0x40; |
} |
:void test2(dword x,y) |
{ |
_stdout("["); |
IF(y) |
{ |
itoa(x,#BUFTST); |
_stdout(#BUFTST); |
} |
ELSE _stdout(x); |
_stdout("]"); |
} |
:void ______INIT______() |
{ |
dword o = 0; |
dword o2 = 0; |
memInit(); |
stack = malloc(1000); |
beginStack = stack; |
stackFast = malloc(1000); |
beginStackFast = stackFast; |
stackLoop = malloc(1000); |
TEMP = malloc(500); |
//o = malloc(16*4); |
//memcpy(o,"test123456789",9); |
//test(123); |
//sprintf(TEMP,"asd%sa=%c123","ok",123); |
//test(TEMP,0); |
//importLibrary("console"); |
main(); |
ExitProcess(); |
} |
:void ______STOP______() |
{ |
ExitProcess(); |
} |
/programs/cmm/experimental/python/static/lib.h |
---|
0,0 → 1,201 |
:dword strcmp(dword str1,str2) |
{ |
LOOPCMP: |
IF(DSBYTE[str1]!=DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
IF(!DSBYTE[str1]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
IF(!DSBYTE[str2]) RETURN DSBYTE[str1]-DSBYTE[str2]; |
str1++; |
str2++; |
GOTO LOOPCMP; |
} |
/* |
void dll_Load() { |
asm { |
push ebp |
mov ebp, esp |
mov esi, SSDWORD[EBP+8] |
@next_lib: |
mov edx, DSDWORD[ESI] |
or edx, edx |
jz exit |
push esi |
mov esi, DSDWORD[ESI+4] |
mov edi, #libPath |
add edi,9 |
@loc01: |
lodsb |
stosb |
or al, al |
jnz loc01 |
mov eax, 68 |
mov ebx, 19 |
mov ecx, #libPath |
int 0x40 |
or eax, eax |
jz fail |
push edx |
push eax |
call dll_Link |
push eax |
mov eax, DSDWORD[eax] |
cmp DSDWORD[EAX], '_bil' // somehow this needs to be reversed.. |
pop eax |
jnz loc02 |
push DSDWORD[EAX+4] |
call dll_Init |
@loc02: |
pop esi |
add esi, 8 |
jmp next_lib |
@exit: |
xor eax, eax |
leave |
ret 4 |
@fail: |
add esp, 4 |
xor eax, eax |
inc eax |
leave |
ret 4 |
} |
} |
void dll_GetProcAddress(){ |
asm { |
push ebp |
mov ebp, esp |
mov edx, CSDWORD[EBP+8] |
xor eax, eax |
@next: |
or edx, edx |
jz end |
cmp CSDWORD[edx], 0 |
jz end |
push CSDWORD[EBP+12] |
push CSDWORD[EDX] |
call dll_StrCmp |
test eax, eax |
jz ok |
add edx, 8 |
jmp next |
@ok: |
mov eax, DSDWORD[EDX+4] |
@end: |
leave |
ret 8 |
} |
} |
void dll_StrCmp() { |
asm { |
push ebp |
mov ebp, esp |
push esi |
push edi |
mov esi, CSDWORD[EBP+8] |
mov edi, CSDWORD[EBP+12] |
xor eax, eax |
@label1: |
lodsb |
scasb |
jne fail |
or al, al |
jnz label1 |
jmp label_ok |
@fail: |
or eax, -1 |
@label_ok: |
pop edi |
pop esi |
leave |
ret 8 |
} |
} |
void dll_Link() { |
asm { |
push ebp |
mov ebp, esp |
push eax |
mov esi, SSDWORD[EBP+12] |
test esi, esi |
jz done |
@next: |
lodsd |
test eax, eax |
jz done |
push eax |
push SSDWORD[EBP+8] |
call dll_GetProcAddress |
or eax, eax |
jz loc03 |
mov DSDWORD[esi-4], eax |
jmp next |
@loc03: |
mov SSDWORD[esp], 0 |
@done: |
pop eax |
leave |
ret 8 |
} |
} |
void dll_Init() { |
asm { |
push ebp |
mov ebp, esp |
pushad |
mov eax, #malloc |
mov ebx, #free; |
mov ecx, #realloc; |
mov edx, #dll_Load; |
call SSDWORD[EBP+8] |
popad |
leave |
ret 4 |
} |
} |
*/ |
:dword importLibrary(dword name) |
{ |
dword l = 0; |
dword i = 0; |
dword list = 0; |
dword key = 0; |
dword data = 0; |
dword ret = 0; |
i = malloc(1000); |
l = strcpy(TEMP,#libPath); |
l += strcpy(TEMP+l,name); |
memcpy(TEMP+l,".obj",5); |
EAX = 68; |
EBX = 19; |
ECX = TEMP; |
$int 0x40; |
list = EAX; |
while(DSDWORD[list]) |
{ |
test2(DSDWORD[list],0); |
IF(!strcmp(DSDWORD[list],"con_init")) |
{ |
//dll_Init(DSDWORD[list+4]); |
} |
ELSE dictSet(ret,DSDWORD[list],DSDWORD[list+4]); |
list+=8; |
} |
EAX = DSDWORD[i+92]; |
i = malloc(10); |
strcpy(i,"test"); |
i = realloc(i,19); |
test1(i,0); |
} |
/programs/cmm/experimental/python/static/opcode.h |
---|
0,0 → 1,717 |
#define buffer 1024 |
:struct VAR |
{ |
dword data; |
byte type; |
dword length; |
dword stack; |
}; |
:dword build_map(dword count) |
{ |
dword o = 0; |
dword a1 = 0; |
dword a2 = 0; |
IF(count>8) o = arrayInit(count); |
ELSE o = arrayInit(8); |
WHILE(count) |
{ |
a1 = popStack(); |
a2 = popStack(); |
SWITCH(DSBYTE[a2+4]) |
{ |
CASE PY_STR: |
dictSet(#o,DSDWORD[a2],a1); |
BREAK; |
CASE PY_INT: |
arraySet(#o,1,a1); |
BREAK; |
} |
count--; |
} |
load_const(o,PY_DCT,0); |
} |
:void load_const(dword data,type,length) |
{ |
DSDWORD[#RDATA] = data; |
DSBYTE[#RDATA+4] = type; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = 0; |
pushStack(#RDATA); |
} |
:void compare_op(byte cmd) |
{ |
dword n = 0; |
dword y = popStack(); |
dword x = popStack(); |
dword dx = 0; |
dword dy = 0; |
dword i = 0; |
checkType(x,y); |
IF(DSBYTE[x+4] == PY_STR) |
{ |
IF(DSDWORD[x+5] == DSDWORD[y+5]) |
{ |
dx = DSDWORD[x]; |
dy = DSDWORD[y]; |
i = DSDWORD[x+5]; |
WHILE(i) |
{ |
IF(DSBYTE[dx]!=DSBYTE[dy]) BREAK; |
dx++; |
dy++; |
i--; |
} |
IF(!i) load_const(1,PY_BOOL,0); |
ELSE load_const(0,PY_BOOL,0); |
} |
return; |
} |
IF(!cmd)IF(DSDWORD[x] == DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==1)IF(DSDWORD[x] != DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==2)IF(DSDWORD[x] >= DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==3)IF(DSDWORD[x] <= DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==4)IF(DSDWORD[x] > DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
IF(cmd==5)IF(DSDWORD[x] < DSDWORD[y]) |
{ |
load_const(1,PY_BOOL,0); |
return; |
} |
load_const(0,PY_BOOL,0); |
} |
:byte pop_jump_if(byte cmd) |
{ |
dword x = 0; |
x = popStack(); |
//test(DSDWORD[x+4],1); |
SWITCH(DSBYTE[x+4]) |
{ |
CASE PY_INT: |
CASE PY_BOOL: |
IF(cmd){ IF (DSDWORD[x]) RETURN 1;} |
IF(!cmd){ IF (!DSDWORD[x]) RETURN 1;} |
BREAK; |
CASE PY_STR: |
IF(cmd){ IF (DSDWORD[x+5]) RETURN 1;} |
IF(!cmd){ IF (!DSDWORD[x+5]) RETURN 1;} |
BREAK; |
} |
RETURN 0; |
} |
:void pop_block() |
{ |
stackLoop-=4; |
} |
:void unary_invert() |
{ |
dword x = 0; |
x = DSDWORD[stack-4]; |
EAX = DSDWORD[x]; |
$not eax; |
DSDWORD[x] = EAX; |
} |
:void inplace(byte cmd) |
{ |
dword buffer = 0; |
dword length = 0; |
Y = popStack(); |
X = DSDWORD[stack-4]; |
IF(cmd==PY_ADD) checkType(X,Y); |
E = DSBYTE[X+4]; |
if(E==PY_STR) |
{ |
A = DSDWORD[X+5]; |
IF(cmd==PY_ADD) B = DSDWORD[Y+5]; |
ELSE |
{ |
C = DSDWORD[Y]; |
B = C*A; |
} |
length = A+B; |
buffer = length+MEMBUF; |
D = malloc(buffer); |
IF(cmd==PY_ADD) |
{ |
memcpy(D,DSDWORD[X],A); |
memcpy(D+A,DSDWORD[Y],B); |
} |
ELSE IF(cmd==PY_MUL) |
{ |
B = D; |
E = DSDWORD[X]; |
WHILE(C) |
{ |
memcpy(B,E,A); |
B+=4; |
C--; |
} |
} |
DSDWORD[#RDATA] = D; |
DSBYTE[#RDATA+4] = PY_STR; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = buffer; |
pushStack(#RDATA); |
return; |
} |
if(E==PY_INT) |
{ |
switch(cmd) |
{ |
case PY_ADD: |
DSDWORD[X] += DSDWORD[Y]; |
break; |
case PY_POW: |
length = DSDWORD[Y]; |
D = DSDWORD[X]; |
DSDWORD[X] = 1; |
WHILE(length) {DSDWORD[X]*=D; length--;} |
break; |
case PY_SUB: |
DSDWORD[X] -= DSDWORD[Y]; |
break; |
case PY_MUL: |
DSDWORD[X] *= DSDWORD[Y]; |
break; |
case PY_MOD: |
DSDWORD[X] = DSDWORD[X]%DSDWORD[Y]; |
break; |
case PY_XOR: |
DSDWORD[X] ^= DSDWORD[Y]; |
break; |
case PY_AND: |
DSDWORD[X] &= DSDWORD[Y]; |
break; |
case PY__OR: |
DSDWORD[X] |= DSDWORD[Y]; |
break; |
case PY_LSH: |
DSDWORD[X] <<= DSDWORD[Y]; |
break; |
case PY_RSH: |
DSDWORD[X] >>= DSDWORD[Y]; |
break; |
case PY_FDV: |
DSDWORD[X] /= DSDWORD[Y]; |
break; |
case PY_TDV: |
DSDWORD[X] /= DSDWORD[Y]; |
break; |
} |
} |
} |
:void binary(byte cmd) |
{ |
dword buffer = 0; |
dword length = 0; |
Y = popStack(); |
X = popStack(); |
IF(cmd==PY_ADD) checkType(X,Y); |
E = DSBYTE[X+4]; |
if(E==PY_STR) |
{ |
A = DSDWORD[X+5]; |
IF(cmd==PY_ADD) B = DSDWORD[Y+5]; |
ELSE |
{ |
C = DSDWORD[Y]; |
B = C*A; |
} |
length = A+B; |
buffer = length+MEMBUF; |
D = malloc(buffer); |
IF(cmd==PY_ADD) |
{ |
memcpy(D,DSDWORD[X],A); |
memcpy(D+A,DSDWORD[Y],B); |
} |
ELSE IF(cmd==PY_MUL) |
{ |
B = D; |
E = DSDWORD[X]; |
WHILE(C) |
{ |
memcpy(B,E,A); |
B+=4; |
C--; |
} |
} |
DSDWORD[#RDATA] = D; |
DSBYTE[#RDATA+4] = PY_STR; |
DSDWORD[#RDATA+5] = length; |
DSDWORD[#RDATA+9] = buffer; |
pushStack(#RDATA); |
return; |
} |
if(E==PY_INT) |
{ |
switch(cmd) |
{ |
case PY_ADD: |
A = DSDWORD[X] + DSDWORD[Y]; |
break; |
case PY_POW: |
length = DSDWORD[Y]; |
D = DSDWORD[X]; |
DSDWORD[Z] = 1; |
WHILE(length) {A*=D; length--;} |
break; |
case PY_SUB: |
A = DSDWORD[X] - DSDWORD[Y]; |
break; |
case PY_MUL: |
A = DSDWORD[X] * DSDWORD[Y]; |
break; |
case PY_MOD: |
A = DSDWORD[X] % DSDWORD[Y]; |
break; |
case PY_XOR: |
A = DSDWORD[X] ^ DSDWORD[Y]; |
break; |
case PY_AND: |
A = DSDWORD[X] & DSDWORD[Y]; |
break; |
case PY__OR: |
A = DSDWORD[X] | DSDWORD[Y]; |
break; |
case PY_LSH: |
A = DSDWORD[X] << DSDWORD[Y]; |
break; |
case PY_RSH: |
A = DSDWORD[X] >> DSDWORD[Y]; |
break; |
case PY_FDV: |
A = DSDWORD[X] / DSDWORD[Y]; |
break; |
case PY_TDV: |
A = DSDWORD[X] / DSDWORD[Y]; |
break; |
} |
load_const(A,PY_INT,0); |
} |
} |
:byte del(dword v) |
{ |
dword x = 0; |
x = DSDWORD[v]; |
IF(x) |
{ |
IF(DSDWORD[x+9]) free(DSDWORD[x]); |
free(x); |
DSDWORD[v] = 0; |
RETURN 1; |
} |
RETURN 0; |
} |
:void build_class(dword count) |
{ |
dword name = 0; |
dword func = 0; |
func = popFast(); |
name = popFast(); |
load_const(func,PY_CLS,0); |
} |
:void load_build_class() |
{ |
load_const(#build_class,PY_FNC,0); |
} |
:void make_function() |
{ |
stack-=4; |
} |
:void store_name(dword x) |
{ |
dword tmp = 0; |
dword stk = 0; |
stk = popStack(); |
IF(!DSDWORD[x]) |
{ |
tmp = malloc(30); |
memcpy(tmp,stk,30); |
DSDWORD[x] = tmp; |
return; |
} |
memcpy(DSDWORD[x],stk,30); |
} |
:void rot(dword x,y) |
{ |
EAX = DSDWORD[stack-8]; |
DSDWORD[stack-8] = DSDWORD[stack-4]; |
DSDWORD[stack-4] = EAX; |
} |
:void build_tuple(dword len) |
{ |
dword tuple = 0; |
dword buf = 0; |
dword l = 0; |
l = len; |
tuple = malloc(4*len+MEMBUF); |
buf = tuple; |
WHILE(len) |
{ |
DSDWORD[buf] = popStack(); |
buf+=4; |
len--; |
} |
load_const(tuple,PY_TPL,l); |
} |
:void unpack_sequence(dword len) |
{ |
dword tuple = 0; |
dword x = 0; |
popStack(); |
tuple = DSDWORD[EAX]; |
WHILE(len) |
{ |
pushStack(DSDWORD[tuple]); |
tuple+=4; |
len--; |
} |
} |
:void rot_two() |
{ |
rot(DSDWORD[stack-8],DSDWORD[stack-4]); |
} |
:void rot_three() |
{ |
rot(DSDWORD[stack-12],DSDWORD[stack-4]); |
rot(DSDWORD[stack-8],DSDWORD[stack-4]); |
} |
:void load_name(dword addr) |
{ |
pushStack(addr); |
} |
:void load_global(dword addr) |
{ |
pushStack(addr); |
} |
:dword strlen(dword txt) |
{ |
dword i = 0; |
i = txt; |
WHILE(DSBYTE[i]) i++; |
RETURN i - txt; |
} |
:dword hashString(dword x) |
{ |
dword l = 0; |
dword h = 0; |
l = x; |
WHILE(DSBYTE[x]) |
{ |
h+=DSBYTE[x]; |
h<<=1; |
x++; |
h/=x-l; |
} |
return h; |
} |
:void pop_top() |
{ |
stack-=4; |
} |
:void load_fast(dword addr) |
{ |
dword x = 0; |
IF(!DSDWORD[addr]) |
{ |
x = popFast(); |
DSDWORD[addr] = x; |
} |
ELSE x = DSDWORD[addr]; |
pushStack(x); |
} |
:void call_function(dword arg) |
{ |
dword count = 0; |
dword func = 0; |
byte type = 0; |
dword stackRet = 0; |
count = arg; |
WHILE(count) |
{ |
pushFast(popStack()); |
count--; |
} |
func = popStack(); |
//IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0); |
type = DSBYTE[func+4]; |
func = DSDWORD[func]; |
IF(!func) |
{ |
test1("Null function!",0); |
pushStack(0); |
return; |
} |
IF(type==PY_FNC) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
ELSE IF(type==PY_CLS) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
stackFast = beginStackFast; |
} |
:void call_method(dword arg) |
{ |
dword count = 0; |
dword func = 0; |
byte type = 0; |
dword stackRet = 0; |
count = arg; |
WHILE(count) |
{ |
pushFast(popStack()); |
count--; |
} |
func = popStack(); |
//IF(DSBYTE[Z+4]!=PY_FNC) test("No function!",0); |
type = DSBYTE[func+4]; |
func = DSDWORD[func]; |
IF(!func) |
{ |
test1("Null function!",0); |
pushStack(0); |
return; |
} |
IF(type==PY_FNC) |
{ |
stackRet = stack; |
func(arg); |
IF(stackRet == stack) load_const(0,PY_NONE,0); |
} |
ELSE IF(type==PY_CLS) |
{ |
func(arg); |
pushStack(EAX); |
} |
stackFast = beginStackFast; |
} |
:void load_method(dword name) |
{ |
dword x = 0; |
dword data = 0; |
dword get = 0; |
x = popStack(); |
data = DSDWORD[x]; |
get = dictGet(DSDWORD[data],name); |
pushStack(get); |
} |
:void append(dword count) |
{ |
dword x = 0; |
dword y = 0; |
x = popFast(); |
y = popFast(); |
test1(DSBYTE[x+4],1); |
} |
:void build_list(dword count) |
{ |
dword n = 0; |
dword mem = 0; |
dword i = 0; |
dword tmp = 0; |
dword method = 0; |
mem = malloc(count*4+MEMBUF); |
i = count; |
n = i*4+mem+4; |
load_const(#append,PY_FNC,0); |
dictSet(#method,"append",popStack()); |
DSDWORD[mem] = method; |
WHILE(i) |
{ |
n-=4; |
tmp = malloc(30); |
memcpy(tmp,popStack(),30); |
DSDWORD[n] = tmp; |
i--; |
} |
load_const(mem,PY_LST,count); |
} |
:dword store_fast() |
{ |
return popStack(); |
} |
:void binary_subscr() |
{ |
dword x = 0; |
dword y = 0; |
dword l1 = 0; |
dword l2 = 0; |
dword tmp = 0; |
dword ret = 0; |
byte t = 0; |
x = popStack(); |
y = popStack(); |
//IF(DSBYTE[x+4]!=PY_INT) error type; |
l1 = DSDWORD[y+5]; |
t = DSBYTE[y+4]; |
IF(t==PY_LST) |
{ |
IF(l1<=x) test1("error max list",0); |
IF(0>l1) test1("error min list",0); |
y = DSDWORD[y]; |
pushStack(DSDWORD[x*4+y]); |
return; |
} |
IF(t==PY_DCT) |
{ |
y = DSDWORD[y]; // data object |
SWITCH(DSBYTE[x+4]) |
{ |
CASE PY_INT: |
test1(DSDWORD[y],1); |
x = arrayGet(DSDWORD[y],DSDWORD[x]); |
BREAK; |
CASE PY_STR: |
x = dictGet(DSDWORD[y],DSDWORD[x]); |
BREAK; |
} |
pushStack(x); |
//test1(DSBYTE[x+4],1); |
return; |
} |
IF(t==PY_STR) |
{ |
x = DSDWORD[x]; |
IF (l1<=x)||(l1<0) test1("IndexError: string index out of range",0); |
y = DSDWORD[y]; |
tmp = malloc(MEMBUF); |
ret = malloc(30); |
DSBYTE[tmp] = DSBYTE[x+y]; |
DSDWORD[ret] = tmp; |
DSBYTE[ret+4] = PY_STR; |
DSDWORD[ret+5] = 1; |
DSDWORD[ret+9] = MEMBUF; |
pushStack(ret); |
return; |
} |
} |
:void build_slice(dword count) |
{ |
} |
/* |
:void call_function(dword arg) |
{ |
dword x = 0; |
dword c = arg; |
dword o = 0; |
dword v = 0; |
WHILE(c) |
{ |
o+=4; |
popStack(); |
$push eax |
c--; |
} |
$push arg |
v = popStack(); |
IF(DSBYTE[v+4]!=PY_FNC) test("No function!",0); |
v = DSDWORD[v]; |
IF(!v) |
{ |
test(1,1); |
pushStack(0); |
return; |
} |
$call v |
ESP+=o; |
pushStack(EAX); |
} |
*/ |
/programs/cmm/experimental/python/examples/example.py |
---|
0,0 → 1,3 |
text1 = "Hello" |
text2 = "World!" |
stdout(text1+' '+text2) |
/programs/cmm/experimental/python/examples/dectohex.py |
---|
0,0 → 1,10 |
def test(x): |
f = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'] |
txt = "" |
while x: |
txt = f[x&0xF]+txt |
x = x>>4 |
return txt |
stdout(test(0x123454)) |
/programs/cmm/misc/Tupfile.lua |
---|
0,0 → 1,13 |
if tup.getconfig("NO_CMM") ~= "" then return end |
if tup.getconfig("LANG") == "ru" |
then C_LANG = "LANG_RUS" |
else C_LANG = "LANG_ENG" -- this includes default case without config |
end |
tup.rule("easyshot.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "easyshot.com") |
tup.rule("calypte.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "calypte.com") |
tup.rule("kolibrin.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "kolibrin.com") |
tup.rule("mblocks.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "mblocks.com") |
tup.rule("notify.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "notify.com") |
tup.rule("pipet.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "pipet.com") |
tup.rule("software_widget.c", "c-- /D=AUTOBUILD /D=$(C_LANG) %f" .. tup.getconfig("KPACK_CMD"), "software_widget.com") |
/programs/cmm/misc/build.bat |
---|
0,0 → 1,13 |
@echo off |
del *.kex |
For /R %%i In (*.c) Do c-- "%%i" |
rename *.com *.kex |
mkdir bin |
move *.kex bin\ |
del warning.txt |
pause |
/programs/cmm/misc/calypte.c |
---|
0,0 → 1,492 |
//Calypte 0.35 - Leency |
//Calypte 0.15 - Punk Joker |
/* |
TODO |
- word wrap |
- draw by line |
- text selection |
*/ |
#define MEMSIZE 1024*200 |
#ifndef AUTOBUILD |
#include "lang.h--" |
#endif |
//===================================================// |
// // |
// LIB // |
// // |
//===================================================// |
#include "../lib/kolibri.h" |
#include "../lib/fs.h" |
#include "../lib/gui.h" |
#include "../lib/list_box.h" |
#include "../lib/collection.h" |
#include "../lib/obj/iconv.h" |
#include "../lib/obj/box_lib.h" |
#include "../lib/obj/libio.h" |
#include "../lib/obj/proc_lib.h" |
#include "../lib/obj/librasterworks.h" |
#include "../lib/patterns/simple_open_dialog.h" |
//===================================================// |
// // |
// DATA // |
// // |
//===================================================// |
char default_dir[] = "/rd/1"; |
od_filter filter2 = { 8, "TXT\0\0" }; |
/*========= MENU ==========*/ |
?define MENU1 "File" |
?define MENU2 "Encoding" |
?define MENU3 "Reopen" |
char menu_file_list[] = |
"Open|Ctrl+O |
Close |
Properties |
Exit"; |
char menu_encoding_list[] = |
"UTF-8 |
KOI8-RU |
CP1251 |
CP1252 |
ISO8859-5 |
CP866"; |
char menu_reopen_list[] = |
"Tinypad |
TextEdit |
TextRead |
WebView |
FB2Read |
HexView"; |
enum |
{ |
MENU_ID_FILE=10, |
FILE_SUBMENU_ID_OPEN=10, |
FILE_SUBMENU_ID_CLOSE, |
FILE_SUBMENU_ID_PROPERTIES, |
FILE_SUBMENU_ID_EXIT, |
MENU_ID_ENCODING=20, |
MENU_ID_REOPEN=30, |
FILE_SUBMENU_ID_TINYPAD=30, |
FILE_SUBMENU_ID_TEXTEDIT, |
FILE_SUBMENU_ID_TEXTREAD, |
FILE_SUBMENU_ID_WEBVIEW, |
FILE_SUBMENU_ID_FB2READ, |
FILE_SUBMENU_ID_HEXVIEW |
}; |
int menu_file_x = 6; |
int menu_encoding_x = NULL; |
int menu_reopen_x = NULL; |
/*======== MENU END ==========*/ |
#define TITLE "Calypte v0.38 dev" |
char win_title[4096] = TITLE; |
#define TOPPANELH 23 |
#define BOTPANELH 10 |
#define WIN_W 750 |
#define WIN_H 550 |
#define SCROLL_SIZE 15 |
proc_info Form; |
llist rows; |
int encoding; |
dword old_width,old_height; |
dword bufpointer; |
dword bufsize; |
scroll_bar scroll_v = { SCROLL_SIZE,200,398,44,0,2,115,15,0,0xeeeeee,0xBBBbbb,0xeeeeee,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}; |
scroll_bar scroll_h = { SCROLL_SIZE,200,398,44,0,2,115,15,0,0xeeeeee,0xBBBbbb,0xeeeeee,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1}; |
collection s; |
//===================================================// |
// // |
// CODE // |
// // |
//===================================================// |
void main() |
{ |
int id; |
load_dll(boxlib, #box_lib_init, 0); |
load_dll(libio, #libio_init, 1); |
//load_dll(libini, #lib_init, 1); |
load_dll(iconv_lib, #iconv_open, 0); |
load_dll(Proc_lib, #OpenDialog_init,0); |
load_dll(librasterworks, #rasterworks_drawText,0); |
OpenDialog_init stdcall (#o_dialog); |
if (param) |
{ |
draw_window(); |
OpenFile(#param); |
Prepare(); |
DrawText(); |
} |
SetEventMask(EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER); |
loop() |
{ |
switch(WaitEvent()) |
{ |
case evMouse: |
mouse.get(); |
rows.wheel_size = 3; |
if (rows.MouseScroll(mouse.vert)) |
{ |
DrawText(); |
} |
break; |
case evButton: |
id=GetButtonID(); |
if (id==1) |
{ |
ExitProcess(); |
} |
if (id==MENU_ID_FILE) |
{ |
EventShowMenu(menu_file_x, #menu_file_list, MENU_ID_FILE, NULL); |
} |
if (id==MENU_ID_ENCODING) |
{ |
EventShowMenu(menu_encoding_x, #menu_encoding_list, MENU_ID_ENCODING, encoding+1); |
} |
if (id==MENU_ID_REOPEN) |
{ |
EventShowMenu(menu_reopen_x, #menu_reopen_list, MENU_ID_REOPEN, NULL); |
} |
break; |
case evKey: |
GetKeys(); |
if (key_modifier&KEY_LCTRL) || (key_modifier&KEY_RCTRL) |
{ |
if (key_scancode == SCAN_CODE_KEY_O) |
{ |
EventOpenFile(); |
} |
break; |
} |
if (rows.ProcessKey(key_scancode)) |
{ |
DrawText(); |
} |
break; |
case evReDraw: |
if (CheckActiveProcess(Form.ID)) EventMenuClick(); |
draw_window(); |
break; |
} |
} |
} |
int DrawMenuButton(dword x,y,id,text) |
{ |
int textlen = strlen(text)*8; |
int padding = 12; |
DefineHiddenButton(x, y, textlen+padding+padding, TOPPANELH-2, id); |
WriteText(x+padding,y+4, 0x90, MixColors(sc.work, sc.work_text, 70), text); |
return textlen+padding+padding; |
} |
void draw_window() |
{ |
sc.get(); |
DefineAndDrawWindow(screen.width-WIN_W/2,screen.height-WIN_H/2,WIN_W,WIN_H,0x73,0xFFFFFF,#win_title,0); |
GetProcessInfo(#Form, SelfInfo); |
DrawBar(0, 0, Form.cwidth, TOPPANELH-1, sc.work); |
DrawBar(0, TOPPANELH-1, Form.cwidth, 1, sc.work_dark); |
DrawBar(0, Form.cheight-BOTPANELH, Form.cwidth, BOTPANELH, sc.work); |
menu_encoding_x = menu_file_x + DrawMenuButton(menu_file_x, 0, MENU_ID_FILE, MENU1); |
menu_reopen_x = menu_encoding_x + DrawMenuButton(menu_encoding_x, 0, MENU_ID_ENCODING, MENU2); |
DrawMenuButton(menu_reopen_x, 0, MENU_ID_REOPEN, MENU3); |
if (old_width!=Form.width) || (old_height!=Form.height) |
{ |
old_width = Form.width; |
old_height = Form.height; |
rows.no_selection = true; |
rows.SetFont(8, 14, 0x90); |
rows.SetSizes(0, TOPPANELH, Form.cwidth - SCROLL_SIZE, Form.cheight - TOPPANELH - BOTPANELH, 20); |
rows.column_max = rows.w / rows.font_w; |
if (bufpointer) |
{ |
Prepare(); |
} |
rows.CheckDoesValuesOkey(); |
} |
DrawRectangle(rows.x+rows.w-1, rows.y, SCROLL_SIZE, rows.h-1, 0xEEEeee); |
DrawText(); |
} |
void OpenFile(dword _path) |
{ |
strcpy(#param, _path); |
sprintf(#win_title, "%s - %s", TITLE, #param); |
rows.KeyHome(); |
file_size stdcall (#param); |
bufsize = EBX; |
if (bufsize) |
{ |
bufpointer = mem_Free(bufpointer); |
bufpointer = mem_Alloc(bufsize); |
if (ReadFile(0, bufsize, bufpointer, #param) != 0) |
{ |
bufpointer = 0; |
notify("'Error opening file'-E"); |
return; |
} |
} |
if (encoding!=CH_CP866) |
{ |
ChangeCharset(encoding, "CP866", bufpointer); |
} |
} |
enum |
{ |
PARSE_CALCULATE_ROWS_COUNT, |
PARSE_DRAW_PREPARE, |
}; |
void Parse(int mode) |
{ |
int pos=0; |
int sub_pos=0; |
int len_str = 0; |
bool do_eof = false; |
word bukva[2]; |
while(1) |
{ |
while(1) |
{ |
bukva = DSBYTE[bufpointer+pos+len_str]; |
if (bukva=='\0') |
{ |
do_eof = true; |
break; |
} |
if (bukva==0x0a) |
{ |
break; |
} |
else |
{ |
len_str++; |
} |
} |
if (len_str<=rows.column_max) |
{ |
if (mode==PARSE_DRAW_PREPARE) |
{ |
s.addn(bufpointer+pos, len_str); |
} |
pos += len_str+1; |
} |
else |
{ |
if (mode==PARSE_DRAW_PREPARE) |
{ |
s.addn(bufpointer+pos, rows.column_max); |
} |
pos += rows.column_max; |
} |
sub_pos++; |
if (mode==PARSE_CALCULATE_ROWS_COUNT) && (do_eof) |
{ |
break; |
} |
if (mode==PARSE_DRAW_PREPARE) && (pos>=bufsize-1) |
{ |
break; |
} |
len_str = 0; |
} |
if (mode == PARSE_CALCULATE_ROWS_COUNT) |
{ |
rows.count = sub_pos; |
Parse(PARSE_DRAW_PREPARE); |
} |
} |
void Prepare() |
{ |
Parse(PARSE_CALCULATE_ROWS_COUNT); |
} |
void DrawText() |
{ |
int i=0, top; |
if (rows.count<rows.visible) |
{ |
top = rows.count; |
} |
else |
{ |
if (rows.count-rows.first<=rows.visible) |
{ |
top = rows.count-rows.first-1; |
} |
else |
{ |
top = rows.visible; |
} |
} |
if (bufpointer) |
{ |
for (i=0; i<top; i++) |
{ |
DrawBar(0, i*rows.item_h+TOPPANELH, rows.w, rows.item_h, 0xFFFFFF); |
WriteText(2, i*rows.item_h+TOPPANELH, 0x90, 0x000000, s.get(i+rows.first)); |
} |
} |
DrawBar(0, i*rows.item_h+rows.y, rows.w, -i*rows.item_h + rows.h, 0xFFFfff); |
DrawVerticalScroll(); |
} |
void DrawVerticalScroll() |
{ |
scroll_v.max_area = rows.count; |
scroll_v.cur_area = rows.visible; |
scroll_v.position = rows.first; |
scroll_v.start_y = rows.y; |
scroll_v.size_y = rows.h; |
scroll_v.start_x = rows.w + rows.x -1; |
scroll_v.all_redraw = 0; |
scrollbar_v_draw(#scroll_v); |
} |
//===================================================// |
// // |
// EVENTS // |
// // |
//===================================================// |
dword menu_id; |
void EventMenuClick() |
{ |
dword click_id = get_menu_click(); |
if (click_id) switch(click_id + menu_id - 1) |
{ |
//File |
case FILE_SUBMENU_ID_OPEN: |
EventOpenFile(); |
break; |
case FILE_SUBMENU_ID_CLOSE: |
EventCloseFile(); |
break; |
case FILE_SUBMENU_ID_PROPERTIES: |
EventShowFileProperties(); |
break; |
case FILE_SUBMENU_ID_EXIT: |
ExitProcess(); |
break; |
//Encoding |
case MENU_ID_ENCODING...MENU_ID_ENCODING+9: |
EventChangeEncoding(click_id-1); |
break; |
//Reopen |
case FILE_SUBMENU_ID_TINYPAD: |
EventOpenFileInAnotherProgram("/sys/tinypad"); |
break; |
case FILE_SUBMENU_ID_TEXTEDIT: |
EventOpenFileInAnotherProgram("/sys/develop/t_edit"); |
break; |
case FILE_SUBMENU_ID_TEXTREAD: |
EventOpenFileInAnotherProgram("/sys/txtread"); |
break; |
case FILE_SUBMENU_ID_WEBVIEW: |
EventOpenFileInAnotherProgram("/sys/network/webview"); |
break; |
case FILE_SUBMENU_ID_FB2READ: |
EventOpenFileInAnotherProgram("/sys/fb2read"); |
break; |
case FILE_SUBMENU_ID_HEXVIEW: |
EventOpenFileInAnotherProgram("/sys/develop/heed"); |
break; |
} |
} |
void EventShowMenu(dword _menu_item_x, _menu_list, _id, _selected) |
{ |
open_lmenu(Form.left+5 + _menu_item_x, Form.top+skin_height + TOPPANELH, |
MENU_ALIGN_TOP_LEFT, _selected, _menu_list); |
menu_id = _id; |
} |
void EventOpenFile() |
{ |
OpenDialog_start stdcall (#o_dialog); |
if (o_dialog.status) |
{ |
OpenFile(#openfile_path); |
Prepare(); |
draw_window(); |
} |
} |
void EventCloseFile() |
{ |
if (bufpointer) |
{ |
s.drop(); |
bufpointer = mem_Free(bufpointer); |
strcpy(#win_title, TITLE); |
draw_window(); |
} |
} |
void EventShowFileProperties() |
{ |
char ss_param[4096]; |
if (bufpointer) |
{ |
sprintf(#ss_param, "-p %s", #param); |
RunProgram("/sys/File managers/Eolite", #ss_param); |
} |
} |
void EventChangeEncoding(dword id) |
{ |
encoding = id; |
OpenFile(#openfile_path); |
Prepare(); |
draw_window(); |
} |
void EventOpenFileInAnotherProgram(dword _app) |
{ |
RunProgram(_app, #param); |
} |
stop: |
/programs/cmm/misc/easyshot.c |
---|
0,0 → 1,189 |
#define MEMSIZE 1024 * 50 |
#include "../lib/kolibri.h" |
#include "../lib/strings.h" |
#include "../lib/mem.h" |
#include "../lib/gui.h" |
#include "../lib/obj/libimg.h" |
#include "../lib/obj/box_lib.h" |
#include "../lib/obj/proc_lib.h" |
#ifndef AUTOBUILD |
#include "lang.h--" |
#endif |
/* === TRANSLATIONS === */ |
#ifdef LANG_RUS |
?define T_TAKE_SCREENSHOT "¤¥« âì áªà¨è®â" |
?define T_SETTINGS " áâனª¨" |
?define T_EDITBOX_FRAME "ãâì á®åà ¥¨ï áªà¨è®â " |
?define T_DELAY " ¤¥à¦ª ¢ ᥪ㤠å" |
?define T_NO_DIR "' ¯ª ¥ áãé¥áâ¢ã¥â!' -E" |
#else |
?define T_TAKE_SCREENSHOT "Take a screenshot" |
?define T_SETTINGS "Settings" |
?define T_EDITBOX_FRAME "Save path" |
?define T_DELAY "Delay in seconds" |
?define T_NO_DIR "'Directory does not exists!' -E" |
#endif |
/* === DATA === */ |
proc_info Form; |
enum { |
BTN_MAKE_SCREENSHOT=10, |
BTN_SETTINGS, |
BTN_CHOOSE_SAVING_PATH |
}; |
#define PD 18 //padding |
#define SETTINGS_Y PD+PD+30+10 |
char save_path[4096]; |
char open_dir[4096]; |
more_less_box delay = { 1, 0, SETTINGS_Y, T_DELAY }; |
edit_box edit_save = {260,PD,SETTINGS_Y+50,0xffffff,0x94AECE,0xFFFfff,0xffffff, |
0x10000000,sizeof(save_path)-2,#save_path,0, 0b}; |
bool show_settings = false; |
opendialog open_folder_dialog = |
{ |
2, //0-file, 2-save, 3-select folder |
#Form, |
#communication_area_name, |
0, |
0, //dword opendir_path, |
#open_dir, //dword dir_default_path, |
#open_dialog_path, |
#DrawWindow, |
0, |
#open_dir, //dword openfile_path, |
0, //dword filename_area, |
0, //dword filter_area, |
420, |
NULL, |
320, |
NULL |
}; |
/* === CODE === */ |
void init_libraries() |
{ |
load_dll(libio, #libio_init, 1); |
load_dll(libimg, #libimg_init, 1); |
load_dll(boxlib, #box_lib_init,0); |
load_dll(Proc_lib, #OpenDialog_init,0); |
OpenDialog_init stdcall (#open_folder_dialog); |
} |
void main() |
{ |
int id; |
init_libraries(); |
strcpy(#save_path, "/tmp0/1"); |
EditBox_UpdateText(#edit_save, 0); |
SetEventMask(EVM_REDRAW+EVM_KEY+EVM_BUTTON+EVM_MOUSE+EVM_MOUSE_FILTER); |
loop() switch(WaitEvent()) |
{ |
case evMouse: |
edit_box_mouse stdcall (#edit_save); |
break; |
case evButton: |
id = GetButtonID(); |
switch(id){ |
case CLOSE_BTN: ExitProcess(); |
case BTN_MAKE_SCREENSHOT: EventTakeScreenshot(); break; |
case BTN_SETTINGS: EventClickSettings(); break; |
case BTN_CHOOSE_SAVING_PATH: EventChooseSavePath(); break; |
default: delay.click(id); |
} |
break; |
case evKey: |
GetKeys(); |
if (SCAN_CODE_ENTER == key_scancode) EventTakeScreenshot(); |
if (SCAN_CODE_ESC == key_scancode) ExitProcess(); |
EAX = key_editbox; |
edit_box_key stdcall (#edit_save); |
break; |
case evReDraw: |
DrawWindow(); |
} |
} |
void DrawWindow() |
{ |
int i; |
sc.get(); |
DefineAndDrawWindow(screen.width-400, screen.height/3, 270, |
skin_height + 30+PD+PD, 0x34, sc.work, "EasyShot",0); |
GetProcessInfo(#Form, SelfInfo); |
DrawCaptButton(PD, PD, 170, 28, BTN_MAKE_SCREENSHOT, 0x0090B8, 0xFFFfff, T_TAKE_SCREENSHOT); |
DefineButton(PD+170+20, PD, 35, 28, BTN_SETTINGS, sc.button); |
for (i=0; i<=2; i++) DrawBar(PD+170+30, i*5+PD+9, 15, 2, sc.button_text); |
delay.draw(PD, SETTINGS_Y); |
DrawFileBox(#edit_save, T_EDITBOX_FRAME, BTN_CHOOSE_SAVING_PATH); |
} |
void EventChooseSavePath() |
{ |
OpenDialog_start stdcall (#open_folder_dialog); |
if (open_folder_dialog.status) { |
strcpy(#save_path, open_folder_dialog.opendir_path); |
EditBox_UpdateText(#edit_save, 0); |
} |
} |
void EventClickSettings() |
{ |
show_settings ^= 1; |
MoveSize(OLD, OLD, show_settings*75 + 270, |
show_settings*110 + skin_height + PD+PD+30); |
} |
void EventTakeScreenshot() |
{ |
int i=0; |
char save_file_name[4096]; |
static dword screenshot; |
if (!screenshot) screenshot = malloc(screen.width * screen.height * 3); |
do { |
i++; |
//sprintf(, "%s/screen_%i.png", #save_path, i); |
strcpy(#save_file_name, #save_path); |
if (save_file_name[strlen(#save_file_name)-1]!='/') chrcat(#save_file_name, '/'); |
strcat(#save_file_name, "screen_"); |
strcat(#save_file_name, itoa(i)); |
strcat(#save_file_name, ".png"); |
} while (file_exists(#save_file_name)); |
if (!dir_exists(#save_path)) { |
notify(T_NO_DIR); |
return; |
} |
MinimizeWindow(); |
pause(delay.value*100); |
CopyScreen(screenshot, 0, 0, screen.width, screen.height); |
save_image(screenshot, screen.width, screen.height, #save_file_name); |
ActivateWindow(GetProcessSlot(Form.ID)); |
} |
/programs/cmm/misc/mblocks.c |
---|
0,0 → 1,206 |
/* |
Memory Blocks for KolibriOS v1.11 |
Leency&Veliant Edition |
2008-2019 |
*/ |
#define MEMSIZE 4096 * 15 |
#include "..\lib\gui.h" |
#include "..\lib\random.h" |
#include "..\lib\obj\libio.h" |
#include "..\lib\obj\libimg.h" |
proc_info Form; |
#ifndef AUTOBUILD |
#include "lang.h--" |
#endif |
#define COLOR_CELL_BG 0xFFFfff |
#define COLOR_CELL_BORDER 0x94AECE |
#define CELL_SIZE 43 |
#define PANEL_Y CELL_SIZE+4*6 + 4 |
#define PANEL_H 36 |
#define strok 6 //cell count x |
#define stolbcov 10 //cell count y |
#ifdef LANG_RUS |
#define LABEL_NEW_GAME "®¢ ï ¨£à (F2)"; |
#else |
#define LABEL_NEW_GAME "New game (F2)"; |
#endif |
int bitstat[60], bitpict[60]; |
dword butonsx[60], butonsy[60]; |
dword firstbit, secondbit; |
int count; |
void main() |
{ |
dword id; |
load_dll(libio, #libio_init,1); |
load_dll(libimg, #libimg_init,1); |
Libimg_LoadImage(#skin, "/sys/icons32.png"); |
Libimg_FillTransparent(skin.image, skin.w, skin.h, COLOR_CELL_BG); |
NewGame(); |
loop() switch(WaitEvent()) |
{ |
case evKey: |
GetKeys(); |
if (key_scancode==60) NewGame(); |
break; |
case evButton: |
id = GetButtonID(); |
if (id==1) ExitProcess(); |
else if (id==5) NewGame(); |
else { |
if (bitstat[id-100] == 0) |
{ |
if (firstbit <> 0x0BAD) |
{ |
if (secondbit <> 0x0BAD) |
{ |
if (bitpict[firstbit-100] == bitpict[secondbit-100]) |
bitstat[firstbit-100] = bitstat[secondbit-100] = 2; |
else |
bitstat[firstbit-100] = bitstat[secondbit-100] = 0; |
ReDraw_Game_Button(firstbit - 100); |
ReDraw_Game_Button(secondbit - 100); |
secondbit = 0x0BAD; |
firstbit = id; |
bitstat[id-100] = 1; |
ReDraw_Game_Button(id - 100); |
count++; |
} |
else if (firstbit<>id) |
{ |
secondbit = id; |
bitstat[id-100] = 1; |
ReDraw_Game_Button(id - 100); |
count++; |
} |
} |
else |
{ |
firstbit = id; |
bitstat[id-100] = 1; |
ReDraw_Game_Button(id - 100); |
count++; |
} |
} |
Draw_Count(); |
} |
break; |
case evReDraw: |
sc.get(); |
DefineAndDrawWindow(215,100,CELL_SIZE+4*10 + 4 + 9,PANEL_Y+4+PANEL_H+skin_height, |
0x34,0xC0C0C0,"Memory Blocks",0); |
GetProcessInfo(#Form, SelfInfo); |
Draw_Panel(); |
Draw_Game_Pole(); |
break; |
} |
} |
void NewGame() |
{ |
int off; |
int i; |
FOR (i = 0; i < 60; i++) |
{ |
bitstat[i] = 0; |
bitpict[i] = 0; |
} |
count = 0; |
firstbit = secondbit = 0x0BAD; |
FOR (i = 0; i < 30; i++) |
{ |
do off = random(60); while (bitpict[off] != 0); |
bitpict[off] = i; |
do off = random(60); while (bitpict[off] != 0); |
bitpict[off] = i; |
} |
Draw_Game_Pole(); |
Draw_Panel(); |
} |
void ReDraw_Game_Button(int id) |
{ |
DefineButton(butonsx[id], butonsy[id], CELL_SIZE, CELL_SIZE, 100 + id + BT_HIDE, 0); |
switch (bitstat[id]) |
{ |
case 0: |
Draw_Block(butonsx[id], butonsy[id]); |
break; |
case 1: |
Draw_Pressed_Block(butonsx[id], butonsy[id]); |
img_draw stdcall(skin.image, butonsx[id]+6, butonsy[id]+6, 32, 32, 0, bitpict[id]*32); |
BREAK; |
case 2: |
Draw_Open_Block(butonsx[id], butonsy[id]); |
img_draw stdcall(skin.image, butonsx[id]+6, butonsy[id]+6, 32, 32, 0, bitpict[id]*32); |
BREAK; |
} |
} |
void Draw_Game_Pole() |
{ |
int i; |
byte j; |
for (j = 0; j < stolbcov; j++) for (i = 0; i < strok; i++) |
{ |
butonsx[j*strok+i] = CELL_SIZE+4 * j + 4; //save coordinates to avoid |
butonsy[j*strok+i] = CELL_SIZE+4 * i + 4; //their recalculation after |
ReDraw_Game_Button(j*strok + i); |
} |
} |
void Draw_Block(dword x, y) |
{ |
DrawRectangle(x, y, CELL_SIZE, CELL_SIZE, COLOR_CELL_BORDER);//border |
DrawRectangle3D(x + 1, y + 1, CELL_SIZE-2, CELL_SIZE-2, 0xFFFFFF, 0xDEDEDE);//bump |
DrawBar(x + 2, y + 2, CELL_SIZE-3, CELL_SIZE-3, 0xBDC7D6);//background |
} |
void Draw_Open_Block(dword x, y) |
{ |
DrawRectangle(x, y, CELL_SIZE, CELL_SIZE, COLOR_CELL_BORDER);//border |
DrawBar(x + 1, y + 1, CELL_SIZE-1, CELL_SIZE-1, COLOR_CELL_BG);//background |
} |
void Draw_Pressed_Block(dword x, y) |
{ |
DrawRectangle(x, y, CELL_SIZE, CELL_SIZE, COLOR_CELL_BORDER);//border |
DrawWideRectangle(x + 1, y + 1, CELL_SIZE-1, CELL_SIZE-1, 2, 0x94DB00);//border green |
DrawBar(x + 3, y + 3, CELL_SIZE-5, CELL_SIZE-5, COLOR_CELL_BG);//background |
} |
void Draw_Panel() |
{ |
DrawBar(0, PANEL_Y, Form.cwidth, 1, sc.work_dark); |
DrawBar(0, PANEL_Y+1, Form.cwidth, 1, sc.work_light); |
DrawBar(0, PANEL_Y+2, Form.cwidth, PANEL_H-2, sc.work); |
DrawStandartCaptButton(9, PANEL_Y+5, 5, LABEL_NEW_GAME); |
Draw_Count(); |
} |
void Draw_Count() |
{ |
DrawBar(Form.cwidth-32,PANEL_Y + 12,30,12,sc.work); |
WriteNumber(Form.cwidth-32, PANEL_Y + 12, 0x90, sc.work_text, 3, count); |
} |
stop: |
/programs/cmm/misc/notify.c |
---|
0,0 → 1,150 |
//notify 0.8 |
//SoUrcerer 2010, Leency 2012-2013, GNU GPLv2 |
#define MEMSIZE 0x2F00 |
#include "..\lib\kolibri.h" |
#include "..\lib\strings.h" |
#include "..\lib\mem.h" |
#include "..\lib\gui.h" |
dword shadow_buf_24, shadow_buf_32, lighter_pixel1, lighter_pixel2; |
?define PADDING 15; |
int SCREEN_SIZE_X, |
SCREEN_SIZE_Y; |
int WIN_X, |
WIN_Y, |
WIN_SIZE_X=256, |
WIN_SIZE_Y=28; |
int TEXT_X=PADDING, |
TEXT_Y; |
int delay = 400; |
#ifdef LANG_RUS |
?define DEFAULT_TEXT "â ¯à®£à ¬¬ ¯®ª §ë¢ ¥â 㢥¤®¬«¥¨ï."; |
#else |
?define DEFAULT_TEXT "This program shows notices. Open it with params."; |
#endif |
void PutText(dword x, y) { |
WriteBufText(x,y, 0x88, 0, #param, shadow_buf_32); |
} |
void Text() |
{ |
PutText(TEXT_X-1,TEXT_Y+1); |
PutText(TEXT_X-1,TEXT_Y-1); |
PutText(TEXT_X-1,TEXT_Y ); |
PutText(TEXT_X+1,TEXT_Y-1); |
PutText(TEXT_X+1,TEXT_Y ); |
PutText(TEXT_X+1,TEXT_Y+1); |
PutText(TEXT_X, TEXT_Y+1); |
PutText(TEXT_X, TEXT_Y-1); |
WriteBufText(TEXT_X, TEXT_Y, 0x88, 0xFFFfff, #param, shadow_buf_32); |
} |
void from24to32(ESI, EDI, EAX, EBX) //src,dst,w,h |
{ |
conv24to32: |
$mul ebx |
$mov ecx, eax |
$xor al, al |
_next: |
$movsw |
$movsb |
$stosb |
$loop _next |
} |
void DrawBackground() |
{ |
PutPaletteImage(shadow_buf_32+8,WIN_SIZE_X,WIN_SIZE_Y,0,0,32,0); |
PutPixel(0,0,ESDWORD[lighter_pixel1]); |
PutPixel(0,WIN_SIZE_Y-1,ESDWORD[lighter_pixel2]); |
} |
void GetBackground() |
{ |
int i; |
static int was_once; |
if (was_once) |
{ |
DrawBackground(); |
return; |
} |
for (i=1; i<=6; i++) |
{ |
was_once = 1; |
ShadowImage(shadow_buf_24, WIN_SIZE_X, WIN_SIZE_Y, 1); |
if (i%2 == 0) ShadowImage(lighter_pixel1, 1, 1, 1); |
if (i%2 == 0) ShadowImage(lighter_pixel2, 1, 1, 1); |
from24to32(shadow_buf_24, shadow_buf_32+8, WIN_SIZE_X, WIN_SIZE_Y); |
Text(); |
DrawBackground(); |
pause(5); |
} |
} |
void Exit() |
{ |
ExitProcess(); |
} |
void main() |
{ |
if (!param) strcpy(#param, DEFAULT_TEXT); |
if (strlen(#param)*6>WIN_SIZE_X) |
{ |
WIN_SIZE_X=strlen(#param)*6+PADDING; |
delay = strlen(#param)*10; |
} |
SCREEN_SIZE_X=GetScreenWidth()+1; |
WIN_X = SCREEN_SIZE_X-WIN_SIZE_X-1; |
WIN_Y = GetClientTop(); |
TEXT_X = -6*strlen(#param)+WIN_SIZE_X/2+1; |
TEXT_Y = WIN_SIZE_Y/2-4; |
//emulate multithread :) |
while (GetPixelColorFromScreen(SCREEN_SIZE_X-1, WIN_Y)==0x333333) WIN_Y+=WIN_SIZE_Y+17; |
shadow_buf_24 = malloc(WIN_SIZE_X*WIN_SIZE_Y*3); |
shadow_buf_32 = malloc(WIN_SIZE_X*WIN_SIZE_Y*4+8); |
lighter_pixel1 = malloc(3); |
lighter_pixel2 = malloc(3); |
CopyScreen(shadow_buf_24, WIN_X, WIN_Y, WIN_SIZE_X, WIN_SIZE_Y); |
CopyScreen(lighter_pixel1, WIN_X, WIN_Y, 1, 1); |
CopyScreen(lighter_pixel2, WIN_X, WIN_Y+WIN_SIZE_Y, 1, 1); |
ESDWORD[shadow_buf_32] = WIN_SIZE_X; |
ESDWORD[shadow_buf_32+4] = WIN_SIZE_Y; |
loop() |
{ |
WaitEventTimeout(delay); |
switch(EAX & 0xFF) |
{ |
case evButton: |
Exit(); |
break; |
case evReDraw: |
DefineAndDrawWindow(WIN_X+1,WIN_Y,WIN_SIZE_X, WIN_SIZE_Y-1, 0x01, 0, 0, 0x01fffFFF); |
DrawBar(WIN_SIZE_X,0, 1, WIN_SIZE_Y, 0x333333); |
DefineButton(0,0, WIN_SIZE_X, WIN_SIZE_Y, 1+BT_HIDE+BT_NOFRAME, 0); |
GetBackground(); |
break; |
default: |
Exit(); |
} |
} |
} |
stop: |
/programs/cmm/misc/pipet.c |
---|
0,0 → 1,126 |
#define MEMSIZE 1024*20 |
#include "../lib/gui.h" |
#include "../lib/clipboard.h" |
#include "../lib/patterns/rgb.h" |
//===================================================// |
// // |
// DATA // |
// // |
//===================================================// |
dword pick_active = true; |
dword picked_color = 0; |
char picked_color_string[11]; |
#define FORM_W 167 |
#define FORM_H 60 |
#define COLOR_BLOCK_SIZE 42 |
#define COLOR_BLOCK_PADDING FORM_H - COLOR_BLOCK_SIZE / 2 |
#define COLOR_BLOCK_X FORM_W - COLOR_BLOCK_SIZE - COLOR_BLOCK_PADDING |
#define BUTTON_ID_CLOSE 1 |
#define BUTTON_ID_COPY 2 |
#define BUTTON_ID_PICK 3 |
//===================================================// |
// // |
// CODE // |
// // |
//===================================================// |
void main() |
{ |
int btn; |
proc_info Form; |
SetEventMask(EVM_REDRAW + EVM_KEY + EVM_BUTTON + EVM_MOUSE); |
SetWindowLayerBehaviour(-1, ZPOS_ALWAYS_TOP); |
loop() switch(WaitEvent()) |
{ |
case evMouse: |
mouse.get(); |
if (mouse.x>0) && (mouse.x<FORM_W) && (mouse.y>0) && (mouse.y<FORM_H) { |
EventDragWindow(); |
} else if (pick_active) { |
picked_color = GetPixelColorFromScreen(mouse.x + Form.left, mouse.y + Form.top); |
EventUpdateWindowContent(); |
if (mouse.down) && (mouse.key&MOUSE_LEFT) pick_active = false; |
} |
break; |
case evButton: |
btn = GetButtonID(); |
if (btn == BUTTON_ID_CLOSE) ExitProcess(); |
if (btn == BUTTON_ID_COPY) EventCopyHex(); |
if (btn == BUTTON_ID_PICK) pick_active = true; |
break; |
case evKey: |
GetKeys(); |
if (key_scancode == SCAN_CODE_ESC) ExitProcess(); |
if (key_scancode == SCAN_CODE_KEY_C) EventCopyHex(); |
break; |
case evReDraw: |
DefineUnDragableWindow(215, 100, FORM_W, FORM_H); |
GetProcessInfo(#Form, SelfInfo); |
draw_window(); |
break; |
} |
} |
void draw_window() |
{ |
DrawRectangle3D(0, 0, FORM_W, FORM_H, 0xCCCccc, 0x888888); |
DrawRectangle3D(1, 1, FORM_W-2, FORM_H-2, 0xCCCccc, 0x888888); |
DrawBar(2,2,FORM_W-3,FORM_H-3,0xFFFfff); |
DrawRectangle(COLOR_BLOCK_X-2, COLOR_BLOCK_PADDING-2, COLOR_BLOCK_SIZE+3, COLOR_BLOCK_SIZE+3, 0xCBC6C5); |
DefineHiddenButton(COLOR_BLOCK_X-1, COLOR_BLOCK_PADDING-1, COLOR_BLOCK_SIZE+1, COLOR_BLOCK_SIZE+1, BUTTON_ID_PICK); |
DrawCopyButton(67, 11, 35, 14); |
EventUpdateWindowContent(); |
} |
//copy of sprintf() => %A |
void str2col(dword buf, number) |
{ |
byte s; |
strlcpy(buf,"0x00000000",10); |
buf+=10; |
while(number) |
{ |
$dec buf |
s=number&0xF; |
if(s>9)DSBYTE[buf]='A'+s-10; |
else DSBYTE[buf]='0'+s; |
number>>=4; |
} |
} |
void EventUpdateWindowContent() |
{ |
//sprintf(#picked_color_string, "%A", picked_color); |
str2col(#picked_color_string, picked_color); |
rgb.DwordToRgb(picked_color); |
WriteTextWithBg(12,12, 0xD0, 0x000111, #picked_color_string+4, 0xFFFfff); |
WriteNumber(12,33, 0xD0, 0xff0000, 3, rgb.r); |
WriteNumber(44,33, 0xD0, 0x008000, 3, rgb.g); |
WriteNumber(75,33, 0xD0, 0x0000ff, 3, rgb.b); |
DrawBar(COLOR_BLOCK_X, COLOR_BLOCK_PADDING, COLOR_BLOCK_SIZE, COLOR_BLOCK_SIZE, picked_color); |
} |
void DrawCopyButton(dword _x, _y, _w, _h) |
{ |
DefineHiddenButton(_x+1, _y+1, _w-2, _h-2, BUTTON_ID_COPY); |
DrawRectangle(_x, _y, _w, _h, 0x777777); |
WriteText(_x+6, _h-8/2 + _y, 0x80, 0x555555, "Copy"); |
} |
void EventCopyHex() |
{ |
Clipboard__CopyText(#picked_color_string+4); |
} |
/programs/cmm/misc/software_widget.c |
---|
0,0 → 1,295 |
/* |
SOFTWARE CENTER v2.86 |
*/ |
#define MEMSIZE 4096 * 15 |
#include "..\lib\strings.h" |
#include "..\lib\mem.h" |
#include "..\lib\io.h" |
#include "..\lib\gui.h" |
#include "..\lib\obj\libio.h" |
#include "..\lib\obj\libimg.h" |
#include "..\lib\obj\libini.h" |
#include "..\lib\kfont.h" |
#include "..\lib\list_box.h" |
#include "..\lib\collection.h" |
proc_info Form; |
llist list; |
collection app_path_collection; |
bool kolibrios_mounted; |
int window_width, |
window_height; |
int list_pos, |
row, |
col, |
default_icon; |
char window_title[128], |
settings_ini_path[256]; |
bool small_screen = false; |
struct SW_COLORS |
{ |
dword list_bg; |
dword text; |
dword graph; |
dword dark; |
dword light; |
} swc; |
block selection[128]; |
void load_ini_config(dword _ini_path) |
{ |
_ini ini; |
ini.path = _ini_path; |
ini.section = "Config"; |
ini.GetString("title", #window_title, sizeof(window_title), "Software widget"); |
window_width = ini.GetInt("win_width", 690); |
list.item_w = ini.GetInt("cell_w", 73); |
list.item_h = ini.GetInt("cell_h", 71); |
default_icon = ini.GetInt("default_icon", 2); |
} |
void main() |
{ |
dword id; |
kfont.init(DEFAULT_FONT); |
load_dll(libio, #libio_init,1); |
load_dll(libimg, #libimg_init,1); |
load_dll(libini, #lib_init,1); |
kolibrios_mounted = dir_exists("/kolibrios"); |
if (param) { |
strcpy(#settings_ini_path, #param); |
} else { |
strcpy(#settings_ini_path, "/sys/settings/"); |
strcat(#settings_ini_path, I_Path + strrchr(I_Path, '/')); |
strcat(#settings_ini_path, ".ini"); |
} |
load_ini_config(#settings_ini_path); |
list.cur_y = -1; |
list.y = 32; |
DrawList(); |
window_height = row+1*list.item_h + list_pos + skin_height + 15; |
if (window_height>screen.height) { |
window_width = screen.width; |
list.item_h -= 5; |
window_height = row+1*list.item_h + list_pos + skin_height + 15; |
small_screen = true; |
} |
loop() switch(WaitEvent()) |
{ |
case evKey: |
GetKeys(); |
if (SCAN_CODE_LEFT == key_scancode) key_scancode = SCAN_CODE_UP; |
if (SCAN_CODE_RIGHT == key_scancode) key_scancode = SCAN_CODE_DOWN; |
if (list.ProcessKey(key_scancode)) DrawSelection(); |
if (SCAN_CODE_ENTER == key_scancode) EventIconClick(list.cur_y); |
break; |
case evButton: |
id=GetButtonID(); |
if (id==1) ExitProcess(); |
if (id>=100) EventIconClick(id-100); |
break; |
case evReDraw: |
SetAppColors(); |
DefineAndDrawWindow(screen.width-window_width/2,screen.height-window_height/2,window_width,window_height,0x74,sc.work,"",0); |
GetProcessInfo(#Form, SelfInfo); |
if (Form.status_window>2) { |
DrawTitle(#window_title); |
break; |
} |
if (small_screen) { |
DrawTitle(#window_title); |
list.y = 0; |
} else { |
DrawTitle(NULL); |
DrawTopBar(); |
} |
DrawList(); |
DrawBar(0, row +1 * list.item_h + list_pos, Form.cwidth, -row - 1 * list.item_h - list_pos + Form.cheight, swc.list_bg); |
DrawSelection(); |
} |
} |
void SetAppColors() |
{ |
dword bg_col, old_list_bg_color; |
sc.get(); |
old_list_bg_color = swc.list_bg; |
bg_col = sc.work; |
if (skin_is_dark()) |
{ |
//dark colors |
swc.list_bg = sc.work; |
swc.text = sc.work_text; |
swc.dark = sc.work_dark; |
swc.light = sc.work_light; |
} else { |
//light colors |
swc.list_bg = 0xF3F3F3; |
swc.text = 0x000000; |
swc.dark = 0xDCDCDC; |
swc.light = 0xFCFCFC; |
} |
if (swc.list_bg != old_list_bg_color) |
{ |
Libimg_LoadImage(#skin, "/sys/icons32.png"); |
Libimg_FillTransparent(skin.image, skin.w, skin.h, swc.list_bg); |
} |
} |
void DrawList() { |
list.count = 0; |
row = -1; |
app_path_collection.drop(); |
list_pos = list.y; |
list.column_max = window_width - 10 / list.item_w; |
ini_enum_sections stdcall (#settings_ini_path, #process_sections); |
list.visible = list.count; |
} |
byte draw_icons_from_section(dword key_value, key_name, sec_name, f_name) |
{ |
int icon_id = default_icon, |
icon_char_pos; |
int space_pos; |
dword icon_x, icon_y, text_x, text_y; |
//do not show items located in /kolibrios/ if this directory not mounted |
if (!strncmp(key_value, "/kolibrios/", 11)) || (!strncmp(key_value, "/k/", 3)) |
if (!kolibrios_mounted) return true; |
if (col==list.column_max) { |
row++; |
col=0; |
} |
if (col==0) DrawBar(0, row * list.item_h + list_pos, Form.cwidth, list.item_h, swc.list_bg); |
DefineButton(col*list.item_w+6, row*list.item_h + list_pos,list.item_w,list.item_h-3,list.count + 100 + BT_HIDE,0); |
icon_char_pos = strchr(key_value, ','); |
icon_x = col*list.item_w+calc(list.item_w/2)-10; |
icon_y = row*list.item_h+5 + list_pos; |
selection[list.count].x = icon_x-2; |
selection[list.count].y = icon_y-2; |
if (icon_char_pos) ESBYTE[icon_char_pos] = '\0'; //delete icon from string |
app_path_collection.add(key_value); |
text_x = col*list.item_w+5; |
text_y = list.item_h - 40 / 2; |
if (!strchr(key_name, ' ')) {//|| (kfont.getsize(key_name)+30<list.item_w) <== too slow |
kfont.WriteIntoWindowCenter(text_x, row*list.item_h+46 + list_pos, list.item_w,0, swc.list_bg, swc.text, 12, key_name); |
//WriteTextCenter(text_x, row*list.item_h+46 + list_pos+3, list.item_w, swc.text, key_name); |
} else { |
space_pos = strrchr(key_name, ' '); |
ESBYTE[key_name+space_pos-1] = '\0'; |
kfont.WriteIntoWindowCenter(text_x, row*list.item_h+46 + list_pos - 2, list.item_w,0, swc.list_bg, swc.text, 12, key_name); |
kfont.WriteIntoWindowCenter(text_x, row*list.item_h+46 + list_pos + 13, list.item_w,0, swc.list_bg, swc.text, 12, key_name+space_pos); |
//WriteTextCenter(text_x, row*list.item_h+46 + list_pos, list.item_w, swc.text, key_name); |
//WriteTextCenter(text_x, row*list.item_h+46 + list_pos + 10, list.item_w, swc.text, key_name+space_pos); |
} |
if (icon_char_pos) icon_id = atoi(icon_char_pos+1); |
img_draw stdcall(skin.image, icon_x, icon_y, 32, 32, 0, icon_id*32); |
list.count++; |
col++; |
return true; |
} |
int old_row; //to detect empty sections |
byte process_sections(dword sec_name, f_name) |
{ |
int text_len; |
if (!strcmp(sec_name, "Config")) return true; |
if ((col==0) && (row==old_row)) |
{ |
list_pos -= 28; |
} |
else |
{ |
row++; |
} |
col = 0; |
old_row = row; |
if (!small_screen) { |
DrawBar(0, row * list.item_h + list_pos, Form.cwidth , 29, swc.list_bg); |
text_len = kfont.WriteIntoWindow(10, row * list.item_h + 10 + list_pos, swc.list_bg, swc.text, 15, sec_name); |
DrawBar(text_len+20, row * list.item_h + list_pos + 20, Form.cwidth-text_len-20, 1, swc.dark); |
DrawBar(text_len+20, row * list.item_h + list_pos + 21, Form.cwidth-text_len-20, 1, swc.light); |
list_pos += 29; |
} |
ini_enum_keys stdcall (f_name, sec_name, #draw_icons_from_section); |
return true; |
} |
void DrawTopBar() |
{ |
DrawBar(0,0,Form.cwidth, list.y-2, sc.work); |
DrawBar(0,list.y-2, Form.cwidth, 1, MixColors(sc.work, sc.work_graph, 180)); |
DrawBar(0,list.y-1, Form.cwidth, 1, sc.work_graph); |
kfont.WriteIntoWindowCenter(0,5, Form.cwidth, list.y, sc.work, sc.work_text, 16, #window_title); |
} |
void EventIconClick(dword appid) |
{ |
char run_app_path[4096]=0; |
dword app_path = app_path_collection.get(appid); |
dword param_pos = strchr(app_path, '|'); |
if (param_pos) { |
ESBYTE[param_pos] = NULL; |
param_pos++; |
} |
// the next block is created to save some space in ramdisk{ |
// |
// convert relative path to absolute "calc" => "/sys/calc" |
// convert short kolibrios path to full "/k/calc" => "/kolibrios/calc" |
// other copy => as is |
if (ESBYTE[app_path]!='/') { |
strcpy(#run_app_path, "/sys/"); |
} |
else if (!strncmp(app_path, "/k/",3)) { |
strcpy(#run_app_path, "/kolibrios/"); |
app_path+=3; |
} |
strcat(#run_app_path, app_path); |
// }end |
if (file_exists(#run_app_path)) { |
io.run(#run_app_path, param_pos); //0 or offset |
if (param_pos) ESBYTE[param_pos - 1] = '|'; |
} else { |
notify("'Application not found' -E"); |
} |
} |
void DrawSelection() |
{ |
int i; |
dword col; |
for (i=0; i<list.count; i++) { |
if (i==list.cur_y) col=0x0080FF; else col=swc.list_bg; |
DrawWideRectangle(selection[i].x, selection[i].y, 36, 36, 2, col); |
} |
} |
stop: |