XenOn/kolibrios-fun
1
1
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Wiki Activity

Eolite 3.92: remove duplicated functions, move global variables to local

Browse Source 
SysMon 0.85: get tmp disk sizes, code refactoring

git-svn-id: svn://kolibrios.org@7369 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
Kirill Lipatov (Leency) 2018-09-15 10:48:42 +00:00
parent 0ca3575285
commit fd19f06ec5
9 changed files with 195 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
programs/cmm/eolite/Eolite.c
View File

@ -117,7 +117,6 @@ edit_box new_file_ed = {200,213,180,0xFFFFFF,0x94AECE,0xFFFFFF,0xFFFFFF,0x100000
PathShow_data FileShow = {0, 56,215, 8, 100, 1, 0, 0x0, 0xFFFfff, #file_name, #temp, 0}; PathShow_data FileShow = {0, 56,215, 8, 100, 1, 0, 0x0, 0xFFFfff, #file_name, #temp, 0};
byte cmd_free=0; byte cmd_free=0;
#include "include\translations.h" #include "include\translations.h"
#include "include\fs.h"
#include "include\settings.h" #include "include\settings.h"
#include "include\progress_dialog.h" #include "include\progress_dialog.h"

14
programs/cmm/eolite/include/copy.h
View File

@ -78,7 +78,10 @@ void PasteThread()
int paste_elements_count = 0; int paste_elements_count = 0;
dword buf; dword buf;
dword path_offset; dword path_offset;
file_count_copy = 0; dword file_count_paste = 0;
_dir_size paste_dir_size;
BDVK file_info_count;
copy_bar.value = 0; copy_bar.value = 0;
buf = Clipboard__GetSlotData(Clipboard__GetSlotCount()-1); buf = Clipboard__GetSlotData(Clipboard__GetSlotCount()-1);
@ -88,11 +91,14 @@ void PasteThread()
//calculate copy files count for progress bar //calculate copy files count for progress bar
for (j = 0; j < paste_elements_count; j++) { for (j = 0; j < paste_elements_count; j++) {
GetFileInfo(path_offset, #file_info_count); GetFileInfo(path_offset, #file_info_count);
if ( file_info_count.isfolder ) DirFileCount(path_offset); if ( file_info_count.isfolder ) {
else file_count_copy++; paste_dir_size.get(path_offset);
file_count_paste += paste_dir_size.files;
}
else file_count_paste++;
path_offset += strlen(path_offset) + 1; path_offset += strlen(path_offset) + 1;
} }
copy_bar.max = file_count_copy; copy_bar.max = file_count_paste;
if (cut_active) operation_flag = MOVE_FLAG; if (cut_active) operation_flag = MOVE_FLAG;
else operation_flag = COPY_FLAG; else operation_flag = COPY_FLAG;

20
programs/cmm/eolite/include/delete.h
View File

@ -31,7 +31,9 @@ void Del_File_Thread()
byte del_from[4096]; byte del_from[4096];
int tst, count, i; int tst, count, i;
file_count_copy = 0; BDVK file_info_count;
_dir_size delete_dir_size;
dword file_count_delete = 0;
copy_bar.value = 0; copy_bar.value = 0;
operation_flag = DELETE_FLAG; operation_flag = DELETE_FLAG;
@ -42,18 +44,24 @@ void Del_File_Thread()
if (getElementSelectedFlag(i) == true) { if (getElementSelectedFlag(i) == true) {
sprintf(#del_from,"%s/%s",#path,file_mas[i]*304+buf+72); sprintf(#del_from,"%s/%s",#path,file_mas[i]*304+buf+72);
GetFileInfo(#del_from, #file_info_count); GetFileInfo(#del_from, #file_info_count);
if ( file_info_count.isfolder ) DirFileCount(#del_from); if ( file_info_count.isfolder ) {
else file_count_copy++; delete_dir_size.get(#del_from);
file_count_delete += delete_dir_size.files;
}
else file_count_delete++;
} }
} }
} }
else else
{ {
if (itdir) DirFileCount(#file_path); if (itdir) {
else file_count_copy++; delete_dir_size.get(#file_path);
file_count_delete += delete_dir_size.files;
}
else file_count_delete++;
} }
copy_bar.max = file_count_copy; copy_bar.max = file_count_delete;
del_error = 0; del_error = 0;
DisplayOperationForm(); DisplayOperationForm();

34
programs/cmm/eolite/include/fs.h
View File

@ -1,34 +0,0 @@
BDVK file_info_count;
int file_count_copy;
void DirFileCount(dword way)
{
dword dirbuf, fcount, i, filename;
dword cur_file;
if (dir_exists(way))
{
cur_file = malloc(4096);
// In the process of recursive descent, memory must be allocated
// dynamically, because the static variable cause a fault!!!
// But unfortunately pass away to sacrifice speed.
GetDir(#dirbuf, #fcount, way, DIRS_ONLYREAL);
filename = dirbuf+72;
for (i=0; i<fcount; i++)
{
filename += 304;
sprintf(cur_file,"%s/%s",way,filename);
if (TestBit(ESDWORD[filename-40], 4) )
{
file_count_copy++;
DirFileCount(cur_file);
}
else
{
file_count_copy++;
}
}
free(cur_file);
}
}

72
programs/cmm/eolite/include/properties.h
View File

@ -36,22 +36,18 @@
?define SET_BYTE_LANG "byte" ?define SET_BYTE_LANG "byte"
#endif #endif
dword mouse_2;
char path_to_file[4096]; char path_to_file[4096];
char file_name2[4096]; char file_name2[4096];
edit_box file_name_ed = {230,59,32,0xffffff,0x94AECE,0xFFFfff,0xffffff,0x10000000,sizeof(file_name2),#file_name2,#mouse_2, 1000000000000000b,2,2}; edit_box file_name_ed = {230,59,32,0xffffff,0x94AECE,0xFFFfff,0xffffff,0x10000000,sizeof(file_name2),#file_name2,NULL, 1000000000000000b,2,2};
edit_box path_to_file_ed = {160,120,79,0xffffff,0x94AECE,0xFFFfff,0xffffff,2,sizeof(path_to_file),#path_to_file,#mouse_2, 1000000000000000b,2,2}; edit_box path_to_file_ed = {160,120,79,0xffffff,0x94AECE,0xFFFfff,0xffffff,2,sizeof(path_to_file),#path_to_file,NULL, 1000000000000000b,2,2};
int file_count, dir_count, size_dir;
char folder_info[200];
dword element_size;
char element_size_label[32];
BDVK file_info_general; BDVK file_info_general;
BDVK file_info_dirsize; BDVK file_info_dirsize;
proc_info settings_form;
bool quest_active; bool quest_active;
_dir_size more_files_count;
checkbox ch_read_only = { PR_T_ONLY_READ, NULL }; checkbox ch_read_only = { PR_T_ONLY_READ, NULL };
checkbox ch_hidden = { PR_T_HIDDEN, NULL }; checkbox ch_hidden = { PR_T_HIDDEN, NULL };
checkbox ch_system = { PR_T_SYSTEM, NULL }; checkbox ch_system = { PR_T_SYSTEM, NULL };
@ -147,38 +143,6 @@ void ShowConfirmQuestionPopin()
DrawStandartCaptButton(155,138,302,T_NO); DrawStandartCaptButton(155,138,302,T_NO);
} }
void GetSizeDir(dword way)
{
dword dirbuf, fcount, i, filename;
dword cur_file;
if (dir_exists(way))
{
cur_file = malloc(4096);
// In the process of recursive descent, memory must be allocated dynamically,
// because the static memory -> was a bug !!! But unfortunately pass away to sacrifice speed.
GetDir(#dirbuf, #fcount, way, DIRS_ONLYREAL);
for (i=0; i<fcount; i++)
{
filename = i*304+dirbuf+72;
sprintf(cur_file,"%s/%s",way,filename);
if (TestBit(ESDWORD[filename-40], 4) )
{
dir_count++;
GetSizeDir(cur_file);
}
else
{
GetFileInfo(cur_file, #file_info_dirsize);
size_dir += file_info_dirsize.sizelo;
file_count++;
}
}
free(cur_file);
free(dirbuf);
}
}
void GetSizeMoreFiles(dword way) void GetSizeMoreFiles(dword way)
{ {
char cur_file[4096]; char cur_file[4096];
@ -190,14 +154,14 @@ void GetSizeMoreFiles(dword way)
sprintf(#cur_file,"%s/%s",way,file_mas[i]*304+buf+72); sprintf(#cur_file,"%s/%s",way,file_mas[i]*304+buf+72);
if (TestBit(ESDWORD[file_mas[i]*304+buf+32], 4) ) if (TestBit(ESDWORD[file_mas[i]*304+buf+32], 4) )
{ {
GetSizeDir(#cur_file); more_files_count.calculate_loop(#cur_file);
dir_count++; more_files_count.folders++;
} }
else else
{ {
GetFileInfo(#cur_file, #file_info_dirsize); GetFileInfo(#cur_file, #file_info_dirsize);
size_dir += file_info_dirsize.sizelo; more_files_count.bytes += file_info_dirsize.sizelo;
file_count++; more_files_count.files++;
} }
} }
} }
@ -207,13 +171,9 @@ void properties_dialog()
{ {
int id; int id;
DSBYTE[#folder_info]=0;
file_count = 0;
dir_count = 0;
size_dir = 0;
if (selected_count) if (selected_count)
{ {
more_files_count.get(NULL);
GetSizeMoreFiles(#path); GetSizeMoreFiles(#path);
ch_read_only.checked = 0; ch_read_only.checked = 0;
ch_hidden.checked = 0; ch_hidden.checked = 0;
@ -224,7 +184,7 @@ void properties_dialog()
GetFileInfo(#file_path, #file_info_general); GetFileInfo(#file_path, #file_info_general);
strcpy(#file_name2, #file_name); strcpy(#file_name2, #file_name);
file_name_ed.size = strlen(#file_name2); file_name_ed.size = strlen(#file_name2);
if(itdir) GetSizeDir(#file_path); if(itdir) dir_size.get(#file_path);
ch_read_only.checked = file_info_general.readonly; ch_read_only.checked = file_info_general.readonly;
ch_hidden.checked = file_info_general.hidden; ch_hidden.checked = file_info_general.hidden;
ch_system.checked = file_info_general.system; ch_system.checked = file_info_general.system;
@ -309,7 +269,11 @@ void properties_dialog()
void DrawPropertiesWindow() void DrawPropertiesWindow()
{ {
proc_info settings_form;
char element_size_label[32];
char folder_info[200];
dword ext1; dword ext1;
dword element_size;
incn y; incn y;
char temp_path[sizeof(file_path)]; char temp_path[sizeof(file_path)];
DefineAndDrawWindow(Form.left + 150,150,315,360+skin_height,0x34,system.color.work,WINDOW_TITLE_PROPERTIES,0); DefineAndDrawWindow(Form.left + 150,150,315,360+skin_height,0x34,system.color.work,WINDOW_TITLE_PROPERTIES,0);
@ -326,9 +290,9 @@ void DrawPropertiesWindow()
if (selected_count) if (selected_count)
{ {
PropertiesDrawIcon(NULL, "<lot>"); PropertiesDrawIcon(NULL, "<lot>");
sprintf(#folder_info,"%s%d%s%d",SET_6,file_count,SET_7,dir_count); sprintf(#folder_info,"%s%d%s%d",SET_6,more_files_count.files,SET_7,more_files_count.folders);
WriteText(file_name_ed.left+4, 30, 0x90, system.color.work_text, #folder_info); WriteText(file_name_ed.left+4, 30, 0x90, system.color.work_text, #folder_info);
sprintf(#element_size_label,"%s (%d %s)",ConvertSize64(size_dir, NULL),size_dir,SET_BYTE_LANG); sprintf(#element_size_label,"%s (%d %s)",ConvertSize64(more_files_count.bytes, NULL),more_files_count.bytes,SET_BYTE_LANG);
WriteText(120, 97, 0x90, system.color.work_text, #element_size_label); WriteText(120, 97, 0x90, system.color.work_text, #element_size_label);
} }
else else
@ -348,9 +312,9 @@ void DrawPropertiesWindow()
else else
{ {
WriteText(10,116, 0x90, system.color.work_text, PR_T_CONTAINS); WriteText(10,116, 0x90, system.color.work_text, PR_T_CONTAINS);
sprintf(#folder_info,"%s%d%s%d",SET_6,file_count,SET_7,dir_count); sprintf(#folder_info,"%s%d%s%d",SET_6,dir_size.files,SET_7,dir_size.folders);
WriteText(120, 116, 0x90, system.color.work_text, #folder_info); WriteText(120, 116, 0x90, system.color.work_text, #folder_info);
element_size = size_dir; element_size = dir_size.bytes;
} }
WriteTextLines(10, 136, 0x90, system.color.work_text, CREATED_OPENED_MODIFIED, 20); WriteTextLines(10, 136, 0x90, system.color.work_text, CREATED_OPENED_MODIFIED, 20);
DrawDate(120, 136, system.color.work_text, #file_info_general.datecreate); DrawDate(120, 136, system.color.work_text, #file_info_general.datecreate);

4
programs/cmm/eolite/include/translations.h
View File

@ -1,5 +1,5 @@
#define TITLE "Eolite File Manager v3.91" #define TITLE "Eolite File Manager v3.92"
#define ABOUT_TITLE "EOLITE 3.91" #define ABOUT_TITLE "EOLITE 3.92"
#ifdef LANG_RUS #ifdef LANG_RUS
?define T_FILE "” ©«" ?define T_FILE "” ©«"

105
programs/cmm/lib/fs.h
View File

@ -6,6 +6,12 @@
#include "../lib/date.h" #include "../lib/date.h"
#endif #endif
//===================================================//
// //
// Basic System Functions //
// //
//===================================================//
:struct f70{ :struct f70{
dword func; dword func;
dword param1; dword param1;
@ -156,7 +162,6 @@
$int 0x40 $int 0x40
} }
:f70 read_dir_70; :f70 read_dir_70;
:int ReadDir(dword file_count, read_buffer, dir_path) :int ReadDir(dword file_count, read_buffer, dir_path)
{ {
@ -172,6 +177,12 @@
$int 0x40 $int 0x40
} }
//===================================================//
// //
// Misc //
// //
//===================================================//
:bool dir_exists(dword fpath) :bool dir_exists(dword fpath)
{ {
char buf[32]; char buf[32];
@ -180,7 +191,6 @@
} }
/* /*
// This implementation of dir_exists() is faster than // This implementation of dir_exists() is faster than
// previous but here virtual folders like // previous but here virtual folders like
// '/' and '/tmp' are not recognised as FOLDERS // '/' and '/tmp' are not recognised as FOLDERS
@ -194,7 +204,6 @@
} }
*/ */
:bool file_exists(dword fpath) :bool file_exists(dword fpath)
{ {
BDVK ReadFile_atr; BDVK ReadFile_atr;
@ -202,7 +211,6 @@
return false; return false;
} }
enum enum
{ {
DIRS_ALL, DIRS_ALL,
@ -269,6 +277,23 @@ enum
return ini_path; return ini_path;
} }
:dword notify(dword notify_param)
{
return RunProgram("/sys/@notify", notify_param);
}
:void die(dword _last_msg)
{
notify(_last_msg);
ExitProcess();
}
//===================================================//
// //
// Convert Size //
// //
//===================================================//
:byte ConvertSize_size_prefix[8]; :byte ConvertSize_size_prefix[8];
:dword ConvertSize(dword bytes) :dword ConvertSize(dword bytes)
{ {
@ -292,18 +317,7 @@ enum
else return ConvertSize(bytes_lo); else return ConvertSize(bytes_lo);
} }
:dword notify(dword notify_param) :unsigned char size[25];
{
return RunProgram("/sys/@notify", notify_param);
}
:void die(dword _last_msg)
{
notify(_last_msg);
ExitProcess();
}
:unsigned char size[25]=0;
:dword ConvertSizeToKb(unsigned int bytes) :dword ConvertSizeToKb(unsigned int bytes)
{ {
unsigned int kb; unsigned int kb;
@ -324,6 +338,12 @@ enum
return #size; return #size;
} }
//===================================================//
// //
// Copy //
// //
//===================================================//
:int CopyFileAtOnce(dword size, copyFrom, copyTo) :int CopyFileAtOnce(dword size, copyFrom, copyTo)
dword cbuf; dword cbuf;
int error; int error;
@ -379,5 +399,58 @@ int block_size=1024*1024*4; //copy by 4 MiB
return error; return error;
} }
//===================================================//
// //
// Directory Size //
// //
//===================================================//
:struct _dir_size
{
BDVK dir_info;
dword folders;
dword files;
dword bytes;
void get();
void calculate_loop();
} dir_size;
:void _dir_size::get(dword way)
{
folders = files = bytes = 0;
if (way) calculate_loop(way);
}
:void _dir_size::calculate_loop(dword way)
{
dword dirbuf, fcount, i, filename;
dword cur_file;
if (dir_exists(way))
{
cur_file = malloc(4096);
// In the process of recursive descent, memory must be allocated dynamically,
// because the static memory -> was a bug !!! But unfortunately pass away to sacrifice speed.
GetDir(#dirbuf, #fcount, way, DIRS_ONLYREAL);
for (i=0; i<fcount; i++)
{
filename = i*304+dirbuf+72;
sprintf(cur_file,"%s/%s",way,filename);
if (TestBit(ESDWORD[filename-40], 4) )
{
folders++;
calculate_loop(cur_file);
}
else
{
GetFileInfo(cur_file, #dir_info);
bytes += dir_info.sizelo;
files++;
}
}
free(cur_file);
free(dirbuf);
}
}
#endif #endif

10
programs/cmm/lib/obj/libini.h
View File

@ -41,7 +41,7 @@ char aini_get_color[] = "ini_get_color";
// // // //
//===================================================// //===================================================//
struct _ini :struct _ini
{ {
dword path; dword path;
dword section; dword section;
@ -53,23 +53,23 @@ struct _ini
void SetString(); void SetString();
}; };
int _ini::GetInt(dword key, default_value) :int _ini::GetInt(dword key, default_value)
{ {
ini_get_int stdcall (path, section, key, default_value); ini_get_int stdcall (path, section, key, default_value);
return EAX; return EAX;
} }
void _ini::SetInt(dword key, value) :void _ini::SetInt(dword key, value)
{ {
ini_set_int stdcall (path, section, key, value); ini_set_int stdcall (path, section, key, value);
} }
void _ini::GetString(dword key, dst, len, default_value) :void _ini::GetString(dword key, dst, len, default_value)
{ {
ini_get_str stdcall (path, section, key, dst, len, default_value); ini_get_str stdcall (path, section, key, dst, len, default_value);
} }
void _ini::SetString(dword key, value, len) :void _ini::SetString(dword key, value, len)
{ {
ini_set_str stdcall (path, section, key, value, len); ini_set_str stdcall (path, section, key, value, len);
} }

143
programs/cmm/sysmon/sysmon.c
View File

@ -1,6 +1,6 @@
/* /*
* System Monitor * System Monitor
* version 0.7 * version 0.85
* Author: Leency * Author: Leency
*/ */
@ -8,6 +8,7 @@
#include "../lib/io.h" #include "../lib/io.h"
#include "../lib/gui.h" #include "../lib/gui.h"
#include "../lib/fs.h"
#include "../lib/obj/libio.h" #include "../lib/obj/libio.h"
#include "../lib/obj/libimg.h" #include "../lib/obj/libimg.h"
@ -21,7 +22,7 @@
#define MIN_PB_BLOCK_W 19 #define MIN_PB_BLOCK_W 19
#define LOAD_BG 0xFFFfff #define LOAD_BG 0xFFFfff
#define LOAD_ACTIVE 0x4C52FF #define LOAD_ACTIVE 0x3887EE
struct sensor { struct sensor {
int x,y,w,h; int x,y,w,h;
@ -36,6 +37,7 @@ void sensor::set_size(dword _x, _y, _w, _h)
y=_y; y=_y;
w=_w; w=_w;
h=_h; h=_h;
draw_wrapper();
} }
void sensor::draw_wrapper() void sensor::draw_wrapper()
@ -58,57 +60,6 @@ void sensor::draw_progress(dword progress_w, active_value, bg_value, mesure)
WriteText(-progress_w - calc(strlen(#param)*8)/2 + w+x, h/2-7+y, 0x90, LOAD_ACTIVE, #param); WriteText(-progress_w - calc(strlen(#param)*8)/2 + w+x, h/2-7+y, 0x90, LOAD_ACTIVE, #param);
} }
//===================================================//
// //
// GetSizeDir //
// //
//===================================================//
BDVK file_info_dirsize;
dword dir_count;
dword file_count;
dword size_dir;
void GetDirSizeAndCountFiles(dword way)
{
dir_count=0;
file_count=0;
size_dir=0;
GetDirSizeAndCountFiles_loop(way);
}
void GetDirSizeAndCountFiles_loop(dword way)
{
dword dirbuf, fcount, i, filename;
dword cur_file;
if (dir_exists(way))
{
cur_file = malloc(4096);
// In the process of recursive descent, memory must be allocated dynamically,
// because the static memory -> was a bug !!! But unfortunately pass away to sacrifice speed.
GetDir(#dirbuf, #fcount, way, DIRS_ONLYREAL);
for (i=0; i<fcount; i++)
{
filename = i*304+dirbuf+72;
sprintf(cur_file,"%s/%s",way,filename);
if (TestBit(ESDWORD[filename-40], 4) )
{
dir_count++;
GetDirSizeAndCountFiles_loop(cur_file);
}
else
{
GetFileInfo(cur_file, #file_info_dirsize);
size_dir += file_info_dirsize.sizelo;
file_count++;
}
}
free(cur_file);
free(dirbuf);
}
}
//===================================================// //===================================================//
// // // //
// DATA // // DATA //
@ -123,6 +74,8 @@ sensor ram;
sensor rd; sensor rd;
sensor tmp[10]; sensor tmp[10];
dword tmp_size[10];
//===================================================// //===================================================//
// // // //
// CODE // // CODE //
@ -141,6 +94,8 @@ void main()
load_dll(libimg, #libimg_init,1); load_dll(libimg, #libimg_init,1);
load_dll(libini, #lib_init,1); load_dll(libini, #lib_init,1);
GetTmpDiskSizesFromIni();
loop() loop()
{ {
WaitEventTimeout(25); WaitEventTimeout(25);
@ -163,33 +118,21 @@ void main()
GetProcessInfo(#Form, SelfInfo); GetProcessInfo(#Form, SelfInfo);
y.n = 0; y.n = 0;
WriteTextB(LEFT+ICONGAP, y.inc(20), 0x90, system.color.work_text, "CPU load");
DrawIcon32(LEFT, y.n, system.color.work, 37);
if (cpu_frequency < 1000) sprintf(#param, "CPU frequency: %i Hz", cpu_frequency); if (cpu_frequency < 1000) sprintf(#param, "CPU frequency: %i Hz", cpu_frequency);
else sprintf(#param, "CPU frequency: %i MHz", cpu_frequency/1000); else sprintf(#param, "CPU frequency: %i MHz", cpu_frequency/1000);
WriteText(LEFT+ICONGAP, y.inc(20), 0x90, system.color.work_text, #param); DrawBlockHeader(LEFT, y.inc(20), 37, "CPU load", #param);
cpu.set_size(LEFT, y.inc(25), CPU_STACK, 100); cpu.set_size(LEFT, y.inc(45), CPU_STACK, 100);
cpu.draw_wrapper();
WriteTextB(LEFT+ICONGAP, y.inc(cpu.h + 25), 0x90, system.color.work_text, "RAM usage");
DrawIcon32(LEFT, y.n, system.color.work, 36);
sprintf(#param, "Total RAM: %i MiB", GetTotalRAM()/1024); sprintf(#param, "Total RAM: %i MiB", GetTotalRAM()/1024);
WriteText(LEFT+ICONGAP, y.inc(20), 0x90, system.color.work_text, #param); DrawBlockHeader(LEFT, y.inc(cpu.h + 25), 36, "RAM usage", #param);
ram.set_size(LEFT, y.inc(25), CPU_STACK, 25); ram.set_size(LEFT, y.inc(45), CPU_STACK, 23);
ram.draw_wrapper();
WriteTextB(LEFT+ICONGAP, y.inc(ram.h + 25), 0x90, system.color.work_text, "System RAM Disk usage"); DrawBlockHeader(LEFT, y.inc(ram.h + 25), 3, "System RAM Disk usage", "Fixed size: 1.44 MiB");
DrawIcon32(LEFT, y.n, system.color.work, 3); rd.set_size(LEFT, y.inc(45), CPU_STACK, 23);
WriteText(LEFT+ICONGAP, y.inc(20), 0x90, system.color.work_text, "Fixed size: 1.44 MiB");
rd.set_size(LEFT, y.inc(25), CPU_STACK, 25);
rd.draw_wrapper();
WriteTextB(LEFT+ICONGAP, y.inc(ram.h + 25), 0x90, system.color.work_text, "Virtual drive usage"); sprintf(#param, "TMP Disk 0 size: %i MiB", tmp_size[0]);
DrawIcon32(LEFT, y.n, system.color.work, 50); DrawBlockHeader(LEFT, y.inc(rd.h + 25), 50, "Virtual drive usage", #param);
WriteText(LEFT+ICONGAP, y.inc(20), 0x90, system.color.work_text, "TMP Disk 0 size: 49 MiB"); tmp[0].set_size(LEFT, y.inc(45), CPU_STACK, 23);
tmp[0].set_size(LEFT, y.inc(25), CPU_STACK, 25);
tmp[0].draw_wrapper();
default: default:
MonitorCpu(); MonitorCpu();
@ -201,32 +144,40 @@ void main()
"M" "M"
); );
GetDirSizeAndCountFiles("/rd/1"); dir_size.get("/rd/1");
size_dir += 32*512; //add FAT table size
size_dir += file_count*512/2; //add MAGIC NUMBER dir_size.bytes += dir_size.files/2 + 32 * 512; //file attr size + FAT table size
size_dir /= 1024; //convert to KiB dir_size.bytes /= 1024; //convert to KiB
size_dir= 1440 - size_dir; dir_size.bytes = 1440 - dir_size.bytes;
rd.draw_progress( rd.draw_progress(
size_dir*rd.w/1440, dir_size.bytes*rd.w/1440,
1440-size_dir, 1440 - dir_size.bytes,
size_dir, dir_size.bytes,
"K" "K"
); );
GetDirSizeAndCountFiles("/tmp0/1"); if (tmp_size[0]) {
size_dir += 32*512; //add FAT table size dir_size.get("/tmp0/1");
size_dir += file_count*512/2; //add MAGIC NUMBER dir_size.bytes += dir_size.files/2 + 32 * 512; //file attr size + FAT table size
size_dir /= 1024*1024; //convert to MiB dir_size.bytes /= 1024*1024; //convert to MiB
size_dir= 49 - size_dir; dir_size.bytes= tmp_size[0] - dir_size.bytes;
tmp[0].draw_progress( tmp[0].draw_progress(
size_dir*tmp[0].w/49, dir_size.bytes*tmp[0].w/tmp_size[0],
49-size_dir, tmp_size[0] - dir_size.bytes,
size_dir, dir_size.bytes,
"M" "M"
); );
} }
} }
} }
}
void DrawBlockHeader(dword _x, _y, _icon, _title, _subtitle)
{
WriteTextB(_x+ICONGAP, _y, 0x90, system.color.work_text, _title);
DrawIcon32(_x, _y, system.color.work, _icon);
WriteText(_x+ICONGAP, _y+20, 0x90, system.color.work_text, _subtitle);
}
dword GetCpuLoad(dword max_h) dword GetCpuLoad(dword max_h)
{ {
@ -243,6 +194,18 @@ dword GetCpuLoad(dword max_h)
return max_h - idle; return max_h - idle;
} }
_ini ini = { "/sys/settings/system.ini", "DiskSizes" };
void GetTmpDiskSizesFromIni()
{
char i, key[2];
key[1]=0;
for (i=0; i<=9; i++)
{
key[0]=i+'0';
tmp_size[i] = ini.GetInt(#key, 0) / 1024 / 1024;
}
}
//===================================================// //===================================================//
// // // //
// MONITORS // // MONITORS //