sdongles/kolibrios
1
0
Fork 0
forked from KolibriOS/kolibrios
Code Pull Requests Activity

New libGUI library. Written an pure C.

Browse Source 
git-svn-id: svn://kolibrios.org@1157 a494cfbc-eb01-0410-851d-a64ba20cac60
This commit is contained in:
andrew_programmer 2009-09-11 10:19:20 +00:00
parent 03cd817d40
commit d59b725fc3
44 changed files with 11624 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

243
programs/develop/new libGUI_C/SDK/MinGW(windows)/libGUI.c Executable file
View File

@ -0,0 +1,243 @@
/*
libGUI dinamic library SDK
load library and link function
*/
#include "libGUI.h"
struct IMPORT
{
char *name;
void *function;
}__attribute__((packed));
typedef struct IMPORT import_t;
static char *sys_libGUI_path="/sys/lib/libGUI.obj";
static char* funcnames[] = {"LibGUIversion","InitLibGUI","LibGUImain","QuitLibGUI",
"CreateWindow","SetWindowSizeRequest",
"PackControls","DestroyControl","SetControlSizeRequest","GetControlSizeX",
"GetControlSizeY","SetControlNewPosition","GetControlPositionX",
"GetControlPositionY","SetFocuse","RedrawControl","SpecialRedrawControl",
"SetCallbackFunction","BlockCallbackFunction","UnblockCallbackFunction",
"SetIDL_Function","DestroyIDL_Function",
"SetTimerCallbackForFunction","DestroyTimerCallbackForFunction",
"SetCallbackFunctionForEvent","DestroyCallbackFunctionForEvent",
"CreateButton","CreateButtonWithText",
"CreateProgressBar","SetProgressBarPulse","ProgressBarSetText","ProgressBarGetText",
"CreateHorizontalScrollBar","CreateVerticalScrollBar",
"CreateScrolledWindow","ScrolledWindowPackControls",
"CreateImage",
"CreateText","TextBackgroundOn","TextBackgroundOff",
"LoadFont","FreeFont"};
static inline void* gui_ksys_load_dll(char *path)
{
void *dll_export;
__asm__ __volatile__(
"int $0x40"
:"=a"(dll_export)
:"a"(68),"b"(19),"c"(path));
return(dll_export);
}
static inline void gui_ksys_debug_out(int c)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(63),"b"(1),"c"(c));
}
static void gui_debug_out_str(char *s)
{
while(*s)
{
if (*s=='\n') gui_ksys_debug_out(13);
gui_ksys_debug_out(*s);
s++;
}
}
static int gui_strcmp(const char* string1, const char* string2)
{
while (1)
{
if (*string1<*string2)
return -1;
if (*string1>*string2)
return 1;
if (*string1=='\0')
return 0;
string1++;
string2++;
}
}
static void* gui_cofflib_getproc(import_t *lib, char *name)
{
int i;
for(i = 0; lib[i].name && gui_strcmp(name, lib[i].name); i++);
if(lib[i].name) return lib[i].function;
else return NULL;
}
static inline void gui_ksys_exit(int value)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(-1),"b"(value));
}
void link_libGUI(import_t *exp,char **imports)
{
LibGUIversion=(DWORD (stdcall *)(void))
gui_cofflib_getproc(exp,imports[0]);
InitLibGUI=(char (stdcall *)(void))
gui_cofflib_getproc(exp,imports[1]);
LibGUImain=(void (stdcall *)(parent_t *WindowParent))
gui_cofflib_getproc(exp,imports[2]);
QuitLibGUI=(void (stdcall *)(parent_t *window))
gui_cofflib_getproc(exp,imports[3]);
CreateWindow=(void* (stdcall *)(void))
gui_cofflib_getproc(exp,imports[4]);
SetWindowSizeRequest=(void (stdcall *)(parent_t *WindowParent,int size_x,int size_y))
gui_cofflib_getproc(exp,imports[5]);
PackControls=(void (stdcall *)(void *Parent,void *control))
gui_cofflib_getproc(exp,imports[6]);
DestroyControl=(void (stdcall *)(void *control))
gui_cofflib_getproc(exp,imports[7]);
SetControlSizeRequest=(void (stdcall *)(void *Control,int new_size_x,int new_size_y))
gui_cofflib_getproc(exp,imports[8]);
GetControlSizeX=(int (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[9]);
GetControlSizeY=(int (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[10]);
SetControlNewPosition=(void (stdcall *)(void *Control,int new_x,int new_y))
gui_cofflib_getproc(exp,imports[11]);
GetControlPositionX=(int (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[12]);
GetControlPositionY=(int (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[13]);
SetFocuse=(void* (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[14]);
RedrawControl=(void (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[15]);
SpecialRedrawControl=(void (stdcall *)(void *Control))
gui_cofflib_getproc(exp,imports[16]);
SetCallbackFunction=(gui_callback_t* (stdcall *)(void *Control,
int event_name,void *callback_func,void *callback_func_data))
gui_cofflib_getproc(exp,imports[17]);
BlockCallbackFunction=(void (stdcall *)(void *Control,gui_callback_t *callback_ID))
gui_cofflib_getproc(exp,imports[18]);
UnblockCallbackFunction=(void (stdcall *)(void *Control,gui_callback_t *callback_ID))
gui_cofflib_getproc(exp,imports[19]);
SetIDL_Function=(void (stdcall *)(parent_t *Parent,void *function,void *function_data))
gui_cofflib_getproc(exp,imports[20]);
DestroyIDL_Function=(void (stdcall *)(parent_t *Parent))
gui_cofflib_getproc(exp,imports[21]);
SetTimerCallbackForFunction=(gui_timer_t* (stdcall *)(parent_t *parent_window,
int time_tick,void *func,void *func_data))
gui_cofflib_getproc(exp,imports[22]);
DestroyTimerCallbackForFunction=(void (stdcall *)(gui_timer_t *timer))
gui_cofflib_getproc(exp,imports[23]);
SetCallbackFunctionForEvent=(gui_callbackevent_t* (stdcall *)(parent_t *parent_window,
int event_type,void *func,void *func_data))
gui_cofflib_getproc(exp,imports[24]);
DestroyCallbackFunctionForEvent=(void (stdcall *)(gui_callbackevent_t *callback_event))
gui_cofflib_getproc(exp,imports[25]);
CreateButton=(gui_button_t* (stdcall *)(gui_button_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[26]);
CreateButtonWithText=(gui_button_t* (stdcall *)(gui_button_data_t *info,char *txt))
gui_cofflib_getproc(exp,imports[27]);
CreateProgressBar=(gui_progress_bar_t* (stdcall *)(gui_progress_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[28]);
SetProgressBarPulse=(void (stdcall *)(gui_progress_bar_t *ProgressBar,int time_update))
gui_cofflib_getproc(exp,imports[29]);
ProgressBarSetText=(void (stdcall *)(gui_progress_bar_t *pbar,char *txt))
gui_cofflib_getproc(exp,imports[30]);
ProgressBarGetText=(char* (stdcall *)(gui_progress_bar_t *pbar))
gui_cofflib_getproc(exp,imports[31]);
CreateHorizontalScrollBar=(gui_scroll_bar_t* (stdcall *)(gui_scroll_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[32]);
CreateVerticalScrollBar=(gui_scroll_bar_t* (stdcall *)(gui_scroll_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[33]);
CreateScrolledWindow=(gui_scrolled_window_t* (stdcall *)(gui_scrolled_window_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[34]);
ScrolledWindowPackControls=(void (stdcall *)(gui_scrolled_window_t *parent,void *Control))
gui_cofflib_getproc(exp,imports[35]);
CreateImage=(gui_image_t* (stdcall *)(gui_image_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[36]);
CreateText=(gui_text_t* (stdcall *)(gui_text_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[37]);
TextBackgroundOn=(void (stdcall *)(gui_text_t *Text))
gui_cofflib_getproc(exp,imports[38]);
TextBackgroundOff=(void (stdcall *)(gui_text_t *Text))
gui_cofflib_getproc(exp,imports[39]);
LoadFont=(font_t* (stdcall *)(char *fullfontname))
gui_cofflib_getproc(exp,imports[40]);
FreeFont=(void (stdcall *)(font_t *font))
gui_cofflib_getproc(exp,imports[41]);
}
void LoadLibGUI(char *lib_path)
{
import_t *export;
char *path;
DWORD vers;
if (lib_path==NULL)
{
path=sys_libGUI_path;
export=(import_t*)gui_ksys_load_dll(path);
}
else
{
path=lib_path;
export=(import_t*)gui_ksys_load_dll(path);
}
if (export==NULL)
{
gui_debug_out_str("\ncan't load lib=");
gui_debug_out_str(path);
gui_ksys_exit(0);
}
else
{
link_libGUI(export,funcnames);
if (InitLibGUI())
{
gui_debug_out_str("\ncan't initialize libGUI");
gui_ksys_exit(0);
}
gui_debug_out_str(" initialized");
}
}

591
programs/develop/new libGUI_C/SDK/MinGW(windows)/libGUI.h Executable file
View File

@ -0,0 +1,591 @@
/*
service structures of libGUI
*/
#define NULL (void*)0
typedef unsigned int DWORD;
typedef unsigned char BYTE;
typedef unsigned short int WORD;
typedef unsigned int size_t;
#define stdcall __stdcall
#define cdecl __cdecl
/////////////////////////////////////////////////////////////////////////
// libGUI sysyem messages types
/////////////////////////////////////////////////////////////////////////
#define MESSAGE_FULL_REDRAW_ALL 1
#define MESSAGE_KEYS_EVENT 2
#define MESSAGE_SPECIALIZED 3
#define MESSAGE_SET_FOCUSE 4
#define MESSAGE_CHANGE_FOCUSE 5
#define MESSAGE_MOUSE_EVENT 6
#define MESSAGE_CHANGE_POSITION_EVENT 7
#define MESSAGE_CHANGESIZE_EVENT 8
#define MESSAGE_CALL_TIMER_EVENT 9
#define MESSAGE_FULL_REDRAW_ALL_WITH_FINITION 10
#define MESSAGE_SET_MAIN_PARENT 11
#define MESSAGE_DESTROY_CONTROL -1
/////////////////////////////////////////////////////////////////////////
// system keys states
/////////////////////////////////////////////////////////////////////////
#define KEY_DOWN 16
#define KEY_UP 17
#define KEY_HOTKEY 18
/////////////////////////////////////////////////////////////////////////
// system mouse buttons states
/////////////////////////////////////////////////////////////////////////
#define MOUSE_LEFT_BUTTON_DOWN 19
#define MOUSE_LEFT_BUTTON_UP 20
#define MOUSE_RIGHT_BUTTON_DOWN 21
#define MOUSE_RIGHT_BUTTON_UP 22
#define MOUSE_MIDDLE_BUTTON_DOWN 23
#define MOUSE_MIDDLE_BUTTON_UP 24
#define MOUSE_4_BUTTON_DOWN 25
#define MOUSE_4_BUTTON_UP 26
#define MOUSE_5_BUTTON_DOWN 27
#define MOUSE_5_BUTTON_UP 28
//-----------------------------------------------------------------------
// CONNECT EVENTS FOR CALLBACKs
//-----------------------------------------------------------------------
////////////////////////////////////////////////////////////////
// connect events for button
////////////////////////////////////////////////////////////////
#define BUTTON_ENTER_EVENT 29
#define BUTTON_LEAVE_EVENT 30
#define BUTTON_PRESSED_EVENT 31
#define BUTTON_RELEASED_EVENT 32
////////////////////////////////////////////////////////////////
// connect events for scroll bar
////////////////////////////////////////////////////////////////
#define SCROLLBAR_CHANGED_EVENT 33
////////////////////////////////////////////////////////////////
// connect events for main parent window
////////////////////////////////////////////////////////////////
#define DELETE_EVENT 36
////////////////////////////////////////////////////////////////
// font type structure
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct FONT
{
DWORD *fnt_draw;
DWORD *fnt_unpacker;
DWORD *fnt_fd;
DWORD *fnt_bk;
int sizex;
int sizey;
int size;
int encoding_type;
char *font;
char *fnt_name;
DWORD type;
DWORD flags;
};
#pragma pack(pop)
typedef struct FONT font_t;
////////////////////////////////////////////////////////////////
// header of parent of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct HEADERPARENT
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD **control_for_callback_function;
DWORD **callback_for_control_callback;
DWORD number_callbacks;
DWORD *global_active_control_for_keys;
DWORD *message;
DWORD *timer_bk;
DWORD *timer_fd;
DWORD number_timers_for_controls;
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *IDL_func;
DWORD *IDL_func_data;
};
#pragma pack(pop)
typedef struct HEADERPARENT parent_t;
////////////////////////////////////////////////////////////////
// header of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct HEADER
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
};
#pragma pack(pop)
typedef struct HEADER header_t;
////////////////////////////////////////////////////////////////
// callback structure for callback function of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct CALLBACK
{
DWORD *clb_bk;
DWORD *clb_fd;
DWORD *clb_control;
DWORD *func;
DWORD *func_data;
DWORD connect_event;
DWORD flags;
};
#pragma pack(pop)
typedef struct CALLBACK gui_callback_t;
////////////////////////////////////////////////////////////////
// timer
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct TIMER
{
DWORD *tmr_bk;
DWORD *tmr_fd;
DWORD *tmr_parent;
DWORD *func;
DWORD *func_data;
DWORD last_time;
DWORD time_tick;
DWORD flags;
};
#pragma pack(pop)
typedef struct TIMER gui_timer_t;
////////////////////////////////////////////////////////////////
// structure for callback events
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct CALLBACKEVENT
{
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *calev_parent;
DWORD *func;
DWORD *func_data;
DWORD event_type;
};
#pragma pack(pop)
typedef struct CALLBACKEVENT gui_callbackevent_t;
////////////////////////////////////////////////////////////////
// type of data - structure message
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct MESSAGE
{
DWORD type;
DWORD arg1;
DWORD arg2;
DWORD arg3;
DWORD arg4;
};
#pragma pack(pop)
typedef struct MESSAGE gui_message_t;
////////////////////////////////////////////////////////////////
// button
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlButton
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//button's data
BYTE btn_flags;
};
#pragma pack(pop)
typedef struct ControlButton gui_button_t;
// information for creating control Button
#pragma pack(push,1)
struct ButtonData
{
int x;
int y;
int width;
int height;
};
#pragma pack(pop)
typedef struct ButtonData gui_button_data_t;
////////////////////////////////////////////////////////////////
// scroller
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlScrollBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scroll bar's data
float ruller_size;
float ruller_pos;
float ruller_step;
BYTE scb_flags;
};
typedef struct ControlScrollBar gui_scroll_bar_t;
#pragma pack(push,1)
struct ScrollBarData
{
int x;
int y;
int width;
int height;
float ruller_size;
float ruller_pos;
float ruller_step;
};
#pragma pack(pop)
typedef struct ScrollBarData gui_scroll_bar_data_t;
////////////////////////////////////////////////////////////////
// progressbar
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlProgressBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//progress bar's data
float progress;
BYTE prb_flags;
};
#pragma pack(pop)
typedef struct ControlProgressBar gui_progress_bar_t;
#pragma pack(push,1)
struct ProgressBarData
{
int x;
int y;
int width;
int height;
float progress;
};
#pragma pack(pop)
typedef struct ProgressBarData gui_progress_bar_data_t;
////////////////////////////////////////////////////////////////
// scrolled window
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlScrolledWindow
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scrolled windows's data
DWORD virtual_x;
DWORD virtual_y;
DWORD virtual_sizex;
DWORD virtual_sizey;
DWORD *virtual_controls_x;
DWORD *virtual_controls_y;
DWORD number_virtual_controls;
DWORD scroll_arrea_sizex;
DWORD scroll_arrea_sizey;
DWORD *horizontal_scroll;
DWORD *vertical_scroll;
BYTE scw_flags;
};
#pragma pack(pop)
typedef struct ControlScrolledWindow gui_scrolled_window_t;
#pragma pack(push,1)
struct ScrolledWindowData
{
int x;
int y;
int width;
int height;
};
#pragma pack(pop)
typedef struct ScrolledWindowData gui_scrolled_window_data_t;
////////////////////////////////////////////////////////////////
// image
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlImage
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
char bits_per_pixel;
char bytes_per_pixel;
char *img;
};
#pragma pack(pop)
typedef struct ControlImage gui_image_t;
#pragma pack(push,1)
struct ImageData
{
int x;
int y;
int width;
int height;
char bits_per_pixel;
};
#pragma pack(pop)
typedef struct ImageData gui_image_data_t;
////////////////////////////////////////////////////////////////
// text
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlText
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD *font;
DWORD color;
DWORD background_color;
char *text;
BYTE txt_flags;
};
#pragma pack(pop)
typedef struct ControlText gui_text_t;
#pragma pack(push,1)
struct TextData
{
int x;
int y;
DWORD *font;
DWORD color;
DWORD background_color;
char background;
char *text;
};
#pragma pack(pop)
typedef struct TextData gui_text_data_t;
/////////////////////////////////////////////////////////////////
// load libGUI library and link functions
/////////////////////////////////////////////////////////////////
void LoadLibGUI(char *lib_path);
//**********************************************************************
// libGUI service functions
//**********************************************************************
DWORD (stdcall *LibGUIversion)(void);
char (stdcall *InitLibGUI)(void);
void (stdcall *LibGUImain)(parent_t *WindowParent);
void (stdcall *QuitLibGUI)(parent_t *window);
void* (stdcall *CreateWindow)(void);
void (stdcall *SetWindowSizeRequest)(parent_t *WindowParent,int size_x,int size_y);
void (stdcall *PackControls)(void *Parent,void *control);
void (stdcall *DestroyControl)(void *control);
void (stdcall *SetControlSizeRequest)(void *Control,int new_size_x,int new_size_y);
int (stdcall *GetControlSizeX)(void *Control);
int (stdcall *GetControlSizeY)(void *Control);
void (stdcall *SetControlNewPosition)(void *Control,int new_x,int new_y);
int (stdcall *GetControlPositionX)(void *Control);
int (stdcall *GetControlPositionY)(void *Control);
void* (stdcall *SetFocuse)(void *Control);
void (stdcall *RedrawControl)(void *Control);
void (stdcall *SpecialRedrawControl)(void *Control);
gui_callback_t* (stdcall *SetCallbackFunction)(void *Control,
int event_name,void *callback_func,
void *callback_func_data);
void (stdcall *BlockCallbackFunction)(void *Control,gui_callback_t *callback_ID);
void (stdcall *UnblockCallbackFunction)(void *Control,gui_callback_t *callback_ID);
void (stdcall *SetIDL_Function)(parent_t *Parent,void *function,void *function_data);
void (stdcall *DestroyIDL_Function)(parent_t *Parent);
gui_timer_t* (stdcall *SetTimerCallbackForFunction)(parent_t *parent_window,
int time_tick,void *func,void *func_data);
void (stdcall *DestroyTimerCallbackForFunction)(gui_timer_t *timer);
gui_callbackevent_t* (stdcall *SetCallbackFunctionForEvent)(parent_t *parent_window,
int event_type,void *func,void *func_data);
void (stdcall *DestroyCallbackFunctionForEvent)(gui_callbackevent_t *callback_event);
gui_button_t* (stdcall *CreateButton)(gui_button_data_t *info_for_control);
gui_button_t* (stdcall *CreateButtonWithText)(gui_button_data_t *info,char *txt);
gui_progress_bar_t* (stdcall *CreateProgressBar)(gui_progress_bar_data_t *info_for_control);
void (stdcall *SetProgressBarPulse)(gui_progress_bar_t *ProgressBar,int time_update);
void (stdcall *ProgressBarSetText)(gui_progress_bar_t *pbar,char *txt);
char* (stdcall *ProgressBarGetText)(gui_progress_bar_t *pbar);
gui_scroll_bar_t* (stdcall *CreateHorizontalScrollBar)(gui_scroll_bar_data_t *info_for_control);
gui_scroll_bar_t* (stdcall *CreateVerticalScrollBar)(gui_scroll_bar_data_t *info_for_control);
gui_scrolled_window_t* (stdcall *CreateScrolledWindow)(gui_scrolled_window_data_t *info_for_control);
void (stdcall *ScrolledWindowPackControls)(gui_scrolled_window_t *parent,void *Control);
gui_image_t* (stdcall *CreateImage)(gui_image_data_t *info_for_control);
gui_text_t* (stdcall *CreateText)(gui_text_data_t *info_for_control);
void (stdcall *TextBackgroundOn)(gui_text_t *Text);
void (stdcall *TextBackgroundOff)(gui_text_t *Text);
font_t* (stdcall *LoadFont)(char *fullfontname);
void (stdcall *FreeFont)(font_t *font);

241
programs/develop/new libGUI_C/SDK/gcc(unix)/libGUI.c Executable file
View File

@ -0,0 +1,241 @@
/*
libGUI dinamic library SDK
load library and link function
*/
#include "libGUI.h"
struct IMPORT
{
char *name;
void *function;
}__attribute__((packed));
typedef struct IMPORT import_t;
static char *sys_libGUI_path="/sys/lib/libGUI.obj";
static char* funcnames[] = {"LibGUIversion","InitLibGUI","LibGUImain","QuitLibGUI",
"CreateWindow","SetWindowSizeRequest",
"PackControls","DestroyControl","SetControlSizeRequest","GetControlSizeX",
"GetControlSizeY","SetControlNewPosition","GetControlPositionX",
"GetControlPositionY","SetFocuse","RedrawControl","SpecialRedrawControl",
"SetCallbackFunction","BlockCallbackFunction","UnblockCallbackFunction",
"SetIDL_Function","DestroyIDL_Function",
"SetTimerCallbackForFunction","DestroyTimerCallbackForFunction",
"SetCallbackFunctionForEvent","DestroyCallbackFunctionForEvent",
"CreateButton","CreateButtonWithText",
"CreateProgressBar","SetProgressBarPulse","ProgressBarSetText","ProgressBarGetText",
"CreateHorizontalScrollBar","CreateVerticalScrollBar",
"CreateScrolledWindow","ScrolledWindowPackControls",
"CreateImage",
"CreateText","TextBackgroundOn","TextBackgroundOff",
"LoadFont","FreeFont"};
static inline void* gui_ksys_load_dll(char *path)
{
void *dll_export;
__asm__ __volatile__(
"int $0x40"
:"=a"(dll_export)
:"a"(68),"b"(19),"c"(path));
return(dll_export);
}
static inline void gui_ksys_debug_out(int c)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(63),"b"(1),"c"(c));
}
static void gui_debug_out_str(char *s)
{
while(*s)
{
if (*s=='\n') gui_ksys_debug_out(13);
gui_ksys_debug_out(*s);
s++;
}
}
static int gui_strcmp(const char* string1, const char* string2)
{
while (1)
{
if (*string1<*string2)
return -1;
if (*string1>*string2)
return 1;
if (*string1=='\0')
return 0;
string1++;
string2++;
}
}
static void* gui_cofflib_getproc(import_t *lib, char *name)
{
int i;
for(i = 0; lib[i].name && gui_strcmp(name, lib[i].name); i++);
if(lib[i].name) return lib[i].function;
else return NULL;
}
static inline void gui_ksys_exit(int value)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(-1),"b"(value));
}
void link_libGUI(import_t *exp,char **imports)
{
LibGUIversion=(DWORD stdcall (*)(void))
gui_cofflib_getproc(exp,imports[0]);
InitLibGUI=(char stdcall (*)(void))
gui_cofflib_getproc(exp,imports[1]);
LibGUImain=(void stdcall (*)(parent_t *WindowParent))
gui_cofflib_getproc(exp,imports[2]);
QuitLibGUI=(void stdcall (*)(parent_t *window))
gui_cofflib_getproc(exp,imports[3]);
CreateWindow=(void* stdcall (*)(void))
gui_cofflib_getproc(exp,imports[4]);
SetWindowSizeRequest=(void stdcall (*)(parent_t *WindowParent,int size_x,int size_y))
gui_cofflib_getproc(exp,imports[5]);
PackControls=(void stdcall (*)(void *Parent,void *control))
gui_cofflib_getproc(exp,imports[6]);
DestroyControl=(void stdcall (*)(void *control))
gui_cofflib_getproc(exp,imports[7]);
SetControlSizeRequest=(void stdcall (*)(void *Control,int new_size_x,int new_size_y))
gui_cofflib_getproc(exp,imports[8]);
GetControlSizeX=(int stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[9]);
GetControlSizeY=(int stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[10]);
SetControlNewPosition=(void stdcall (*)(void *Control,int new_x,int new_y))
gui_cofflib_getproc(exp,imports[11]);
GetControlPositionX=(int stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[12]);
GetControlPositionY=(int stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[13]);
SetFocuse=(void* stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[14]);
RedrawControl=(void stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[15]);
SpecialRedrawControl=(void stdcall (*)(void *Control))
gui_cofflib_getproc(exp,imports[16]);
SetCallbackFunction=(gui_callback_t* stdcall (*)(void *Control,
int event_name,void *callback_func,void *callback_func_data))
gui_cofflib_getproc(exp,imports[17]);
BlockCallbackFunction=(void stdcall (*)(void *Control,gui_callback_t *callback_ID))
gui_cofflib_getproc(exp,imports[18]);
UnblockCallbackFunction=(void stdcall (*)(void *Control,gui_callback_t *callback_ID))
gui_cofflib_getproc(exp,imports[19]);
SetIDL_Function=(void stdcall (*)(parent_t *Parent,void *function,void *function_data))
gui_cofflib_getproc(exp,imports[20]);
DestroyIDL_Function=(void stdcall (*)(parent_t *Parent))
gui_cofflib_getproc(exp,imports[21]);
SetTimerCallbackForFunction=(gui_timer_t* stdcall (*)(parent_t *parent_window,
int time_tick,void *func,void *func_data))
gui_cofflib_getproc(exp,imports[22]);
DestroyTimerCallbackForFunction=(void stdcall (*)(gui_timer_t *timer))
gui_cofflib_getproc(exp,imports[23]);
SetCallbackFunctionForEvent=(gui_callbackevent_t* stdcall (*)(parent_t *parent_window,
int event_type,void *func,void *func_data))
gui_cofflib_getproc(exp,imports[24]);
DestroyCallbackFunctionForEvent=(void stdcall (*)(gui_callbackevent_t *callback_event))
gui_cofflib_getproc(exp,imports[25]);
CreateButton=(gui_button_t* stdcall (*)(gui_button_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[26]);
CreateButtonWithText=(gui_button_t* stdcall (*)(gui_button_data_t *info,char *txt))
gui_cofflib_getproc(exp,imports[27]);
CreateProgressBar=(gui_progress_bar_t* stdcall (*)(gui_progress_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[28]);
SetProgressBarPulse=(void stdcall (*)(gui_progress_bar_t *ProgressBar,int time_update))
gui_cofflib_getproc(exp,imports[29]);
ProgressBarSetText=(void stdcall (*)(gui_progress_bar_t *pbar,char *txt))
gui_cofflib_getproc(exp,imports[30]);
ProgressBarGetText=(char* stdcall (*)(gui_progress_bar_t *pbar))
gui_cofflib_getproc(exp,imports[31]);
CreateHorizontalScrollBar=(gui_scroll_bar_t* stdcall (*)(gui_scroll_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[32]);
CreateVerticalScrollBar=(gui_scroll_bar_t* stdcall (*)(gui_scroll_bar_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[33]);
CreateScrolledWindow=(gui_scrolled_window_t* stdcall (*)(gui_scrolled_window_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[34]);
ScrolledWindowPackControls=(void stdcall (*)(gui_scrolled_window_t *parent,void *Control))
gui_cofflib_getproc(exp,imports[35]);
CreateImage=(gui_image_t* stdcall (*)(gui_image_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[36]);
CreateText=(gui_text_t* stdcall (*)(gui_text_data_t *info_for_control))
gui_cofflib_getproc(exp,imports[37]);
TextBackgroundOn=(void stdcall (*)(gui_text_t *Text))
gui_cofflib_getproc(exp,imports[38]);
TextBackgroundOff=(void stdcall (*)(gui_text_t *Text))
gui_cofflib_getproc(exp,imports[39]);
LoadFont=(font_t* stdcall (*)(char *fullfontname))
gui_cofflib_getproc(exp,imports[40]);
FreeFont=(void stdcall (*)(font_t *font))
gui_cofflib_getproc(exp,imports[41]);
}
void LoadLibGUI(char *lib_path)
{
import_t *export;
char *path;
if (lib_path==NULL)
{
path=sys_libGUI_path;
export=(import_t*)gui_ksys_load_dll(path);
}
else
{
path=lib_path;
export=(import_t*)gui_ksys_load_dll(path);
}
if (export==NULL)
{
gui_debug_out_str("\ncan't load lib=");
gui_debug_out_str(path);
gui_ksys_exit(0);
}
else
{
link_libGUI(export,funcnames);
if (InitLibGUI())
{
gui_debug_out_str("\ncan't initialize libGUI");
gui_ksys_exit(0);
}
}
}

589
programs/develop/new libGUI_C/SDK/gcc(unix)/libGUI.h Executable file
View File

@ -0,0 +1,589 @@
/*
service structures of libGUI
*/
#define NULL (void*)0
typedef unsigned int DWORD;
typedef unsigned char BYTE;
typedef unsigned short int WORD;
typedef unsigned int size_t;
#define stdcall __attribute__ ((stdcall))
#define cdecl __attribute__ ((cdecl))
#define pack __attribute__ ((packed))
/////////////////////////////////////////////////////////////////////////
// libGUI sysyem messages types
/////////////////////////////////////////////////////////////////////////
#define MESSAGE_FULL_REDRAW_ALL 1
#define MESSAGE_KEYS_EVENT 2
#define MESSAGE_SPECIALIZED 3
#define MESSAGE_SET_FOCUSE 4
#define MESSAGE_CHANGE_FOCUSE 5
#define MESSAGE_MOUSE_EVENT 6
#define MESSAGE_CHANGE_POSITION_EVENT 7
#define MESSAGE_CHANGESIZE_EVENT 8
#define MESSAGE_CALL_TIMER_EVENT 9
#define MESSAGE_FULL_REDRAW_ALL_WITH_FINITION 10
#define MESSAGE_SET_MAIN_PARENT 11
#define MESSAGE_DESTROY_CONTROL -1
/////////////////////////////////////////////////////////////////////////
// system keys states
/////////////////////////////////////////////////////////////////////////
#define KEY_DOWN 16
#define KEY_UP 17
#define KEY_HOTKEY 18
/////////////////////////////////////////////////////////////////////////
// system mouse buttons states
/////////////////////////////////////////////////////////////////////////
#define MOUSE_LEFT_BUTTON_DOWN 19
#define MOUSE_LEFT_BUTTON_UP 20
#define MOUSE_RIGHT_BUTTON_DOWN 21
#define MOUSE_RIGHT_BUTTON_UP 22
#define MOUSE_MIDDLE_BUTTON_DOWN 23
#define MOUSE_MIDDLE_BUTTON_UP 24
#define MOUSE_4_BUTTON_DOWN 25
#define MOUSE_4_BUTTON_UP 26
#define MOUSE_5_BUTTON_DOWN 27
#define MOUSE_5_BUTTON_UP 28
//-----------------------------------------------------------------------
// CONNECT EVENTS FOR CALLBACKs
//-----------------------------------------------------------------------
////////////////////////////////////////////////////////////////
// connect events for button
////////////////////////////////////////////////////////////////
#define BUTTON_ENTER_EVENT 29
#define BUTTON_LEAVE_EVENT 30
#define BUTTON_PRESSED_EVENT 31
#define BUTTON_RELEASED_EVENT 32
////////////////////////////////////////////////////////////////
// connect events for scroll bar
////////////////////////////////////////////////////////////////
#define SCROLLBAR_CHANGED_EVENT 33
////////////////////////////////////////////////////////////////
// connect events for main parent window
////////////////////////////////////////////////////////////////
#define DELETE_EVENT 36
////////////////////////////////////////////////////////////////
// font type structure
////////////////////////////////////////////////////////////////
struct FONT
{
DWORD *fnt_draw;
DWORD *fnt_unpacker;
DWORD *fnt_fd;
DWORD *fnt_bk;
int sizex;
int sizey;
int size;
int encoding_type;
char *font;
char *fnt_name;
DWORD type;
DWORD flags;
}pack;
typedef struct FONT font_t;
////////////////////////////////////////////////////////////////
// header of parent of control
////////////////////////////////////////////////////////////////
struct HEADERPARENT
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD **control_for_callback_function;
DWORD **callback_for_control_callback;
DWORD number_callbacks;
DWORD *global_active_control_for_keys;
DWORD *message;
DWORD *timer_bk;
DWORD *timer_fd;
DWORD number_timers_for_controls;
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *IDL_func;
DWORD *IDL_func_data;
}pack;
typedef struct HEADERPARENT parent_t;
////////////////////////////////////////////////////////////////
// header of control
////////////////////////////////////////////////////////////////
struct HEADER
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
}pack;
typedef struct HEADER header_t;
////////////////////////////////////////////////////////////////
// callback structure for callback function of control
////////////////////////////////////////////////////////////////
struct CALLBACK
{
DWORD *clb_bk;
DWORD *clb_fd;
DWORD *clb_control;
DWORD *func;
DWORD *func_data;
DWORD connect_event;
DWORD flags;
}pack;
typedef struct CALLBACK gui_callback_t;
////////////////////////////////////////////////////////////////
// timer
////////////////////////////////////////////////////////////////
struct TIMER
{
DWORD *tmr_bk;
DWORD *tmr_fd;
DWORD *tmr_parent;
DWORD *func;
DWORD *func_data;
DWORD last_time;
DWORD time_tick;
DWORD flags;
}pack;
typedef struct TIMER gui_timer_t;
////////////////////////////////////////////////////////////////
// structure for callback events
////////////////////////////////////////////////////////////////
struct CALLBACKEVENT
{
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *calev_parent;
DWORD *func;
DWORD *func_data;
DWORD event_type;
}pack;
typedef struct CALLBACKEVENT gui_callbackevent_t;
////////////////////////////////////////////////////////////////
// type of data - structure message
////////////////////////////////////////////////////////////////
struct MESSAGE
{
DWORD type;
DWORD arg1;
DWORD arg2;
DWORD arg3;
DWORD arg4;
}pack;
typedef struct MESSAGE gui_message_t;
////////////////////////////////////////////////////////////////
// button
////////////////////////////////////////////////////////////////
struct ControlButton
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//button's data
BYTE btn_flags;
}pack;
typedef struct ControlButton gui_button_t;
// information for creating control Button
struct ButtonData
{
int x;
int y;
int width;
int height;
}pack;
typedef struct ButtonData gui_button_data_t;
////////////////////////////////////////////////////////////////
// scroller
////////////////////////////////////////////////////////////////
struct ControlScrollBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scroll bar's data
float ruller_size;
float ruller_pos;
float ruller_step;
BYTE scb_flags;
}pack;
typedef struct ControlScrollBar gui_scroll_bar_t;
struct ScrollBarData
{
int x;
int y;
int width;
int height;
float ruller_size;
float ruller_pos;
float ruller_step;
}pack;
typedef struct ScrollBarData gui_scroll_bar_data_t;
////////////////////////////////////////////////////////////////
// progressbar
////////////////////////////////////////////////////////////////
struct ControlProgressBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//progress bar's data
float progress;
BYTE prb_flags;
}pack;
typedef struct ControlProgressBar gui_progress_bar_t;
struct ProgressBarData
{
int x;
int y;
int width;
int height;
float progress;
}pack;
typedef struct ProgressBarData gui_progress_bar_data_t;
////////////////////////////////////////////////////////////////
// scrolled window
////////////////////////////////////////////////////////////////
struct ControlScrolledWindow
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scrolled windows's data
DWORD virtual_x;
DWORD virtual_y;
DWORD virtual_sizex;
DWORD virtual_sizey;
DWORD *virtual_controls_x;
DWORD *virtual_controls_y;
DWORD number_virtual_controls;
DWORD scroll_arrea_sizex;
DWORD scroll_arrea_sizey;
DWORD *horizontal_scroll;
DWORD *vertical_scroll;
BYTE scw_flags;
}pack;
typedef struct ControlScrolledWindow gui_scrolled_window_t;
struct ScrolledWindowData
{
int x;
int y;
int width;
int height;
}pack;
typedef struct ScrolledWindowData gui_scrolled_window_data_t;
////////////////////////////////////////////////////////////////
// image
////////////////////////////////////////////////////////////////
struct ControlImage
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
char bits_per_pixel;
char bytes_per_pixel;
char *img;
}pack;
typedef struct ControlImage gui_image_t;
struct ImageData
{
int x;
int y;
int width;
int height;
char bits_per_pixel;
}pack;
typedef struct ImageData gui_image_data_t;
////////////////////////////////////////////////////////////////
// text
////////////////////////////////////////////////////////////////
struct ControlText
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD *font;
DWORD color;
DWORD background_color;
char *text;
BYTE txt_flags;
}pack;
typedef struct ControlText gui_text_t;
struct TextData
{
int x;
int y;
DWORD *font;
DWORD color;
DWORD background_color;
char background;
char *text;
}pack;
typedef struct TextData gui_text_data_t;
/////////////////////////////////////////////////////////////////
// load libGUI library and link functions
/////////////////////////////////////////////////////////////////
void LoadLibGUI(char *lib_path);
//**********************************************************************
// libGUI service functions
//**********************************************************************
DWORD stdcall (*LibGUIversion)(void);
char stdcall (*InitLibGUI)(void);
void stdcall (*LibGUImain)(parent_t *WindowParent);
void stdcall (*QuitLibGUI)(parent_t *window);
void* stdcall (*CreateWindow)(void);
void stdcall (*SetWindowSizeRequest)(parent_t *WindowParent,int size_x,int size_y);
void stdcall (*PackControls)(void *Parent,void *control);
void stdcall (*DestroyControl)(void *control);
void stdcall (*SetControlSizeRequest)(void *Control,int new_size_x,int new_size_y);
int stdcall (*GetControlSizeX)(void *Control);
int stdcall (*GetControlSizeY)(void *Control);
void stdcall (*SetControlNewPosition)(void *Control,int new_x,int new_y);
int stdcall (*GetControlPositionX)(void *Control);
int stdcall (*GetControlPositionY)(void *Control);
void* stdcall (*SetFocuse)(void *Control);
void stdcall (*RedrawControl)(void *Control);
void stdcall (*SpecialRedrawControl)(void *Control);
gui_callback_t* stdcall (*SetCallbackFunction)(void *Control,
int event_name,void *callback_func,
void *callback_func_data);
void stdcall (*BlockCallbackFunction)(void *Control,gui_callback_t *callback_ID);
void stdcall (*UnblockCallbackFunction)(void *Control,gui_callback_t *callback_ID);
void stdcall (*SetIDL_Function)(parent_t *Parent,void *function,void *function_data);
void stdcall (*DestroyIDL_Function)(parent_t *Parent);
gui_timer_t* stdcall (*SetTimerCallbackForFunction)(parent_t *parent_window,
int time_tick,void *func,void *func_data);
void stdcall (*DestroyTimerCallbackForFunction)(gui_timer_t *timer);
gui_callbackevent_t* stdcall (*SetCallbackFunctionForEvent)(parent_t *parent_window,
int event_type,void *func,void *func_data);
void stdcall (*DestroyCallbackFunctionForEvent)(gui_callbackevent_t *callback_event);
gui_button_t* stdcall (*CreateButton)(gui_button_data_t *info_for_control);
gui_button_t* stdcall (*CreateButtonWithText)(gui_button_data_t *info,char *txt);
gui_progress_bar_t* stdcall (*CreateProgressBar)(gui_progress_bar_data_t *info_for_control);
void stdcall (*SetProgressBarPulse)(gui_progress_bar_t *ProgressBar,int time_update);
void stdcall (*ProgressBarSetText)(gui_progress_bar_t *pbar,char *txt);
char* stdcall (*ProgressBarGetText)(gui_progress_bar_t *pbar);
gui_scroll_bar_t* stdcall (*CreateHorizontalScrollBar)(gui_scroll_bar_data_t *info_for_control);
gui_scroll_bar_t* stdcall (*CreateVerticalScrollBar)(gui_scroll_bar_data_t *info_for_control);
gui_scrolled_window_t* stdcall (*CreateScrolledWindow)(gui_scrolled_window_data_t *info_for_control);
void stdcall (*ScrolledWindowPackControls)(gui_scrolled_window_t *parent,void *Control);
gui_image_t* stdcall (*CreateImage)(gui_image_data_t *info_for_control);
gui_text_t* stdcall (*CreateText)(gui_text_data_t *info_for_control);
void stdcall (*TextBackgroundOn)(gui_text_t *Text);
void stdcall (*TextBackgroundOff)(gui_text_t *Text);
font_t* stdcall (*LoadFont)(char *fullfontname);
void stdcall (*FreeFont)(font_t *font);

11
programs/develop/new libGUI_C/SRC/compilation/MinGW/Makefile Executable file
View File

@ -0,0 +1,11 @@
SRC = libGUI.c
TARGET = libGUI.obj
CFLAGS = -O2 -nostdinc -nostdlib -march=pentium -fomit-frame-pointer -fno-builtin
CC = gcc
AR=ar
all:
$(CC) -c $(SRC) $(CFLAGS) -o $(TARGET)
clean:
rm *.obj
rm $(TARGET)

2
programs/develop/new libGUI_C/SRC/compilation/MinGW/build.bat Executable file
View File

@ -0,0 +1,2 @@
gcc -c -O2 -nostdinc -nostdlib -march=pentium -fomit-frame-pointer -fno-builtin -o libGUI.obj libGUI.c
@pause

11
programs/develop/new libGUI_C/SRC/control_button.h Executable file
View File

@ -0,0 +1,11 @@
/*
control button data
*/
#define FLAG_INSERT_BUTTON_ON 0x1;
#define FLAG_INSERT_BUTTON_OFF 0xfe;
#define FLAG_PRESSED_BUTTON_ON 0x2
#define FLAG_PRESSED_BUTTON_OFF 0xfd
#define FLAG_RELEASED_BUTTON_ON 0x4
#define FLAG_RELEASED_BUTTON_OFF 0xfb

411
programs/develop/new libGUI_C/SRC/control_button.inc Executable file
View File

@ -0,0 +1,411 @@
/*
control Button
*/
void DrawFocuseForButton(struct ControlButton *Button)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
x=Button->ctrl_x;
y=Button->ctrl_y;
sizex=Button->ctrl_sizex;
sizey=Button->ctrl_sizey;
fin=(struct FINITION*)Button->finition;
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,0xbfff);
}
void DrawPressedButton(struct ControlButton *Button)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
gui_message_t message;
x=Button->ctrl_x;
y=Button->ctrl_y;
sizex=Button->ctrl_sizex;
sizey=Button->ctrl_sizey;
fin=(struct FINITION*)Button->finition;
Draw(fin,TOOL_GRADIENT_DOWN_FILLED_RECTANGLE,x,y,sizex,sizey/2,COLOR_FON,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_GRADIENT_DOWN_FILLED_RECTANGLE,x,y+sizey/2,sizex,sizey/2,COLOR_MIDDLE_LIGHT,COLOR_FON);
Draw(fin,TOOL_HORIZONTAL_LINE,x,x+sizex-1,y,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_VERTICAL_LINE,x,y,y+sizey-1,COLOR_LIGHT);
Draw(fin,TOOL_HORIZONTAL_LINE,x,x+sizex-1,y+sizey-1,COLOR_LIGHT);
Draw(fin,TOOL_VERTICAL_LINE,x,y,y+sizey-1,COLOR_ABSOLUTE_DARK);
if (fin->flags & FINITION_ON)
{
message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
message.arg1=fin->x;
message.arg2=fin->y;
message.arg3=fin->sizex;
message.arg4=fin->sizey;
}
else
{
message.type=MESSAGE_FULL_REDRAW_ALL;
}
SendMessage((struct HEADER*)Button,&message);
if (Button->flags & FLAG_FOCUSE_INPUT_ON) DrawFocuseForButton(Button);
}
void DrawInsertButton(struct ControlButton *Button)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
x=Button->ctrl_x;
y=Button->ctrl_y;
sizex=Button->ctrl_sizex;
sizey=Button->ctrl_sizey;
fin=(struct FINITION*)Button->finition;
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_INSERT);
}
void DrawButton(struct ControlButton *Button)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
gui_message_t message;
x=Button->ctrl_x;
y=Button->ctrl_y;
sizex=Button->ctrl_sizex;
sizey=Button->ctrl_sizey;
fin=(struct FINITION*)Button->finition;
Draw(fin,TOOL_GRADIENT_UP_FILLED_RECTANGLE,x,y,sizex,sizey,COLOR_FON,COLOR_MIDDLE_LIGHT);
//Draw(fin,TOOL_GRADIENT_DOWN_FILLED_RECTANGLE,x,y+sizey/2,sizex,sizey/2,COLOR_FON,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_HORIZONTAL_LINE,x+1,x+sizex-2,y+1,COLOR_LIGHT);
Draw(fin,TOOL_VERTICAL_LINE,x+sizex-2,y+1,y+sizey-2,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_HORIZONTAL_LINE,x+1,x+sizex-2,y+sizey-2,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_VERTICAL_LINE,x+1,y+1,y+sizey-2,COLOR_LIGHT);
if (Button->child_bk!=NULL)
{
if (fin->flags & FINITION_ON)
{
message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
message.arg1=fin->x;
message.arg2=fin->y;
message.arg3=fin->sizex;
message.arg4=fin->sizey;
}
else
{
message.type=MESSAGE_FULL_REDRAW_ALL;
}
SendMessage((struct HEADER*)Button,&message);
}
if (Button->flags & FLAG_FOCUSE_INPUT_ON) DrawFocuseForButton(Button);
}
//---------------------------------------------------------------------------------
// control Button
//---------------------------------------------------------------------------------
void ButtonProc(struct ControlButton *button,struct MESSAGE *message)
{
int x,y,btn_state;
char v;
struct TIMER *timer;
struct FINITION *fin;
parent_t *main_parent;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw button
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)button->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DrawButton(button);
break;
}
case MESSAGE_KEYS_EVENT:
{
main_parent=(parent_t*)button->main_parent;
//not relazed yet
if (button->flags & FLAG_FOCUSE_INPUT_ON)
{
if (message->arg1==KEY_DOWN)
{
if (message->arg2==SC_SPACE)
{
button->btn_flags=button->btn_flags | FLAG_PRESSED_BUTTON_ON;
if (ControlCheckCallbackEvent(button,(DWORD)BUTTON_PRESSED_EVENT)!=NULL)
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_PRESSED_EVENT);
main_parent->number_callbacks++;
}
if (button->flags & FLAG_SHOW_CONTROL) DrawPressedButton(button);
}
}
else
{
if (message->arg2==SC_SPACE)
{
button->btn_flags=button->btn_flags | FLAG_RELEASED_BUTTON_ON;
button->btn_flags=button->btn_flags & FLAG_PRESSED_BUTTON_OFF;
if (ControlCheckCallbackEvent(button,(DWORD)BUTTON_RELEASED_EVENT)!=NULL)
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_RELEASED_EVENT);
main_parent->number_callbacks++;
}
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
}
}
}
break;
}
case MESSAGE_SPECIALIZED:
{
if (button->flags & FLAG_GET_SPECIALIZED_MESSAGE_ON)
{
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
button->flags=button->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
}
break;
}
case MESSAGE_MOUSE_EVENT:
{ //check press of mouse buttons
x=message->arg1;
y=message->arg2;
main_parent=(parent_t*)button->main_parent;
if (message->arg3==MOUSE_LEFT_BUTTON_UP)
{
//insert of button
if (CheckCrossBox((struct HEADER*)button,x,y)==TRUE)
{
v=button->btn_flags & FLAG_INSERT_BUTTON_ON;
if ((ControlCheckCallbackEvent(button,(DWORD)BUTTON_ENTER_EVENT)!=NULL) && (v==FALSE))
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_ENTER_EVENT);
main_parent->number_callbacks++;
}
button->btn_flags=button->btn_flags | FLAG_INSERT_BUTTON_ON;
if (button->flags & FLAG_SHOW_CONTROL) DrawInsertButton(button);
}
else
{
v=button->btn_flags & FLAG_INSERT_BUTTON_ON;
if (v==TRUE)
{
if (ControlCheckCallbackEvent(button,(DWORD)BUTTON_LEAVE_EVENT)!=NULL)
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_LEAVE_EVENT);
main_parent->number_callbacks++;
}
button->btn_flags=button->btn_flags & FLAG_INSERT_BUTTON_OFF;
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
}
}
if (button->btn_flags & FLAG_PRESSED_BUTTON_ON)
{
button->btn_flags=button->btn_flags & FLAG_PRESSED_BUTTON_OFF;
button->btn_flags=button->btn_flags | FLAG_RELEASED_BUTTON_ON;
if (ControlCheckCallbackEvent(button,(DWORD)BUTTON_RELEASED_EVENT)!=NULL)
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_RELEASED_EVENT);
main_parent->number_callbacks++;
}
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
}
}
else
{
if (CheckCrossBox((struct HEADER*)button,x,y)==TRUE)
{
if (message->arg3==MOUSE_LEFT_BUTTON_DOWN)
{
button->btn_flags=button->btn_flags | FLAG_PRESSED_BUTTON_ON;
}
}
if ((message->arg3==MOUSE_LEFT_BUTTON_DOWN) && (button->btn_flags & FLAG_PRESSED_BUTTON_ON))
{
if (ControlCheckCallbackEvent(button,(DWORD)BUTTON_PRESSED_EVENT)!=NULL)
{
button->flags=button->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)button;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(button,(DWORD)BUTTON_PRESSED_EVENT);
main_parent->number_callbacks++;
}
if (button->flags & FLAG_SHOW_CONTROL) DrawPressedButton(button);
}
}
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
button->ctrl_x=button->ctrl_x+message->arg1;
button->ctrl_y=button->ctrl_y+message->arg2;
break;
}
case MESSAGE_CALL_TIMER_EVENT:
{
if (button->timer!=(DWORD*)NULL)
{
timer=(struct TIMER*)button->timer;
if (timer->flags & FLAG_TIMER_ON) Timer(timer);
}
break;
}
case MESSAGE_SET_FOCUSE:
{
button->flags=button->flags | FLAG_FOCUSE_INPUT_ON;
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
break;
}
case MESSAGE_CHANGE_FOCUSE:
{
button->flags=button->flags & FLAG_FOCUSE_INPUT_OFF;
if (button->flags & FLAG_SHOW_CONTROL) DrawButton(button);
break;
}
case MESSAGE_DESTROY_CONTROL:
{
if (button->timer!=(DWORD*)NULL) free(button->timer);
free(button->finition);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)button,message);
button->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
//send message to child controls(if there is)
SendMessage((struct HEADER*)button,message);
}
//---------------------------------------------------------------------------------
// create control Button
//---------------------------------------------------------------------------------
void* CreateButton(struct ButtonData *info_for_control)
{
struct ControlButton *Button;
struct FINITION *fin;
Button=malloc(sizeof(struct ControlButton));
Button->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)Button->finition;
fin->flags=0;
ID++;
#ifdef DEBUG
printf("\ncreated button with ID=%d",(int)ID);
#endif
Button->child_bk=(DWORD*)NULL;
Button->child_fd=(DWORD*)NULL;
Button->active_control_for_keys=(DWORD*)NULL;
Button->active_control_for_mouse=(DWORD*)NULL;
Button->callback=(DWORD*)NULL;
Button->timer=(DWORD*)NULL;
Button->ctrl_proc=(DWORD*)&ButtonProc;
Button->ctrl_x=info_for_control->x;
Button->ctrl_y=info_for_control->y;
Button->ctrl_sizex=info_for_control->width;
Button->ctrl_sizey=info_for_control->height;
Button->ctrl_ID=ID;
Button->flags=0;
Button->flags=Button->flags | FLAG_SHOW_CONTROL;
Button->flags=Button->flags | FLAG_FOCUSE_INPUT_SUPPOROTE;
Button->btn_flags=0;
return(Button);
}
void* CreateButtonWithText(gui_button_data_t *info,char *txt)
{
gui_button_t *Button;
gui_text_t *text;
gui_text_data_t txtdata;
int len;
Button=CreateButton(info);
len=strlen(txt);
txtdata.x=0;
txtdata.y=0;
txtdata.font=NULL;
txtdata.background=FALSE;
txtdata.color=0;
txtdata.text=malloc(len);
memmove(txtdata.text,txt,len);
text=CreateText(&txtdata);
if (text->ctrl_sizex>Button->ctrl_sizex) Button->ctrl_sizex=text->ctrl_sizex+6;
if (text->ctrl_sizey>Button->ctrl_sizey) Button->ctrl_sizey=text->ctrl_sizey+6;
text->ctrl_x=(Button->ctrl_sizex/2)-(text->ctrl_sizex/2);
text->ctrl_y=(Button->ctrl_sizey/2)-(text->ctrl_sizey/2);
PackControls(Button,text);
return(Button);
}

0
programs/develop/new libGUI_C/SRC/control_image.h Executable file
View File

162
programs/develop/new libGUI_C/SRC/control_image.inc Executable file
View File

@ -0,0 +1,162 @@
/*
control Image
*/
void DisplayImage(gui_image_t *Image)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
x=Image->ctrl_x;
y=Image->ctrl_y;
sizex=Image->ctrl_sizex;
sizey=Image->ctrl_sizey;
fin=(struct FINITION*)Image->finition;
Draw(fin,TOOL_IMAGE,x,y,sizex,sizey,Image->bits_per_pixel,Image->img);
}
//---------------------------------------------------------------------------------
// control Image
//---------------------------------------------------------------------------------
void ImageProc(gui_image_t *Image,gui_message_t *message)
{
finition_t *fin;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw Image
if (Image->flags & FLAG_SHOW_CONTROL) DisplayImage(Image);
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)Image->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DisplayImage(Image);
break;
}
case MESSAGE_SPECIALIZED:
{
if (Image->flags & FLAG_GET_SPECIALIZED_MESSAGE_ON)
{
if (Image->flags & FLAG_SHOW_CONTROL) DisplayImage(Image);
Image->flags=Image->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
}
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
Image->ctrl_x=Image->ctrl_x+message->arg1;
Image->ctrl_y=Image->ctrl_y+message->arg2;
break;
}
case MESSAGE_DESTROY_CONTROL:
{
free(Image->finition);
free(Image->img);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)Image,message);
Image->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
//send message to child controls(if there is)
SendMessage((struct HEADER*)Image,message);
}
//---------------------------------------------------------------------------------
// create control Image
//---------------------------------------------------------------------------------
void* CreateImage(struct ImageData *info_for_control)
{
gui_image_t *Image;
finition_t *fin;
DWORD sizemem;
Image=malloc(sizeof(struct ControlImage));
Image->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)Image->finition;
fin->flags=0;
ID++;
#ifdef DEBUG
printf("\ncreated image with ID=%d",(int)ID);
#endif
Image->child_bk=(DWORD*)NULL;
Image->child_fd=(DWORD*)NULL;
Image->active_control_for_keys=(DWORD*)NULL;
Image->active_control_for_mouse=(DWORD*)NULL;
Image->callback=(DWORD*)NULL;
Image->timer=(DWORD*)NULL;
Image->ctrl_proc=(DWORD*)&ImageProc;
Image->ctrl_x=(DWORD)info_for_control->x;
Image->ctrl_y=(DWORD)info_for_control->y;
Image->ctrl_sizex=(DWORD)info_for_control->width;
Image->ctrl_sizey=(DWORD)info_for_control->height;
Image->bits_per_pixel=info_for_control->bits_per_pixel;
Image->ctrl_ID=ID;
Image->flags=0;
Image->flags=Image->flags | FLAG_SHOW_CONTROL;
switch(Image->bits_per_pixel)
{
case 32:
{
sizemem=(Image->ctrl_sizex*Image->ctrl_sizey)*4;
Image->bytes_per_pixel=4;
break;
}
case 24:
{
sizemem=(Image->ctrl_sizex*Image->ctrl_sizey)*3;
Image->bytes_per_pixel=3;
break;
}
case 16:
{
sizemem=(Image->ctrl_sizex*Image->ctrl_sizey)*2;
Image->bytes_per_pixel=2;
break;
}
case 15:
{
sizemem=(Image->ctrl_sizex*Image->ctrl_sizey)*2;
Image->bytes_per_pixel=2;
break;
}
case 8:
{
sizemem=Image->ctrl_sizex*Image->ctrl_sizey;
Image->bytes_per_pixel=1;
break;
}
case 4:
{
sizemem=((Image->ctrl_sizex*Image->ctrl_sizey)>>1)+1;
Image->bytes_per_pixel=0;
break;
}
default: return(NULL);
}
Image->img=malloc(sizemem);
return(Image);
}

16
programs/develop/new libGUI_C/SRC/control_progress_bar.h Executable file
View File

@ -0,0 +1,16 @@
#define FLAG_PB_VERTICAL_ORIENTATION_ON 0x1
#define FLAG_PB_HORIZONTAL_ORIENTATION_ON 0x2
#define FLAG_PB_FROM_LEFT_TO_RIGHT_ON 0x4
#define FLAG_PB_FROM_RIGHT_TO_LEFT_ON 0x8
#define FLAG_PB_FROM_DOWN_TO_UP_ON 0x10
#define FLAG_PB_FROM_UP_TO_DOWN_ON 0x20
#define FLAG_PB_TEXT_ON 0x40
#define FLAG_PB_VERTICAL_ORIENTATION_OFF 0xfe
#define FLAG_PB_HORIZONTAL_ORIENTATION_OFF 0xfd
#define FLAG_PB_FROM_LEFT_TO_RIGHT_OFF 0xfb
#define FLAG_PB_FROM_RIGHT_TO_LEFT_OFF 0xf7
#define FLAG_PB_FROM_DOWN_TO_UP_OFF 0xef
#define FLAG_PB_FROM_UP_TO_DOWN_OFF 0xdf
#define FLAG_PB_TEXT_OFF 0xbf

268
programs/develop/new libGUI_C/SRC/control_progress_bar.inc Executable file
View File

@ -0,0 +1,268 @@
/*
control ProgressBar
*/
void ProgressBarDrawProgress(struct ControlProgressBar *ProgressBar)
{
int x;
int y;
int pos_progress;
int sizex;
int sizey;
char v;
struct FINITION *fin;
gui_message_t message;
gui_text_size_t size;
gui_text_t *Text;
if ((ProgressBar->flags & FLAG_SHOW_CONTROL)==FALSE) return;
x=ProgressBar->ctrl_x;
y=ProgressBar->ctrl_y;
sizex=ProgressBar->ctrl_sizex;
sizey=ProgressBar->ctrl_sizey;
fin=(struct FINITION*)ProgressBar->finition;
if (ProgressBar->progress<0.0) ProgressBar->progress=0.0;
if (ProgressBar->progress>1.0) ProgressBar->progress=1.0;
v=ProgressBar->prb_flags & FLAG_PB_HORIZONTAL_ORIENTATION_ON;
if (v!=FALSE)
{
pos_progress=(int)(ProgressBar->progress*(sizex-2));
if (ProgressBar->prb_flags & FLAG_PB_FROM_LEFT_TO_RIGHT_ON)
{
Draw(fin,TOOL_GRADIENT_UP_FILLED_RECTANGLE,x+1,y+1,pos_progress,sizey-2,COLOR_FON,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_GRADIENT_UP_FILLED_RECTANGLE,x+1+pos_progress,y+1,sizex-2-pos_progress,
sizey-2,COLOR_MIDDLE_LIGHT,COLOR_LIGHT);
if (ProgressBar->prb_flags & FLAG_PB_TEXT_ON)
{
if (fin->flags & FINITION_ON)
{
message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
message.arg1=fin->x;
message.arg2=fin->y;
message.arg3=fin->sizex;
message.arg4=fin->sizey;
}
else
{
message.type=MESSAGE_FULL_REDRAW_ALL;
}
Text=(gui_text_t*)ProgressBar->child_bk;
size=GetStringSize((font_t*)Text->font,Text->text);
Text->ctrl_sizex=(DWORD)size.sizex;
Text->ctrl_sizey=(DWORD)size.sizey;
Text->ctrl_x=x+(sizex/2)-(Text->ctrl_sizex/2);
Text->ctrl_y=y+(sizey/2)-(Text->ctrl_sizey/2);
SendMessage((struct HEADER*)ProgressBar,&message);
}
}
if (ProgressBar->prb_flags & FLAG_PB_FROM_RIGHT_TO_LEFT_ON)
{
//Draw(fin,"filled_rectangle",x+sizex-pos_progress-1,y+1,x+sizex-1,sizey-2,0xff0000);
}
}
}
void DrawProgressBar(struct ControlProgressBar *ProgressBar)
{
int x;
int y;
int sizex;
int sizey;
struct FINITION *fin;
x=ProgressBar->ctrl_x;
y=ProgressBar->ctrl_y;
sizex=ProgressBar->ctrl_sizex;
sizey=ProgressBar->ctrl_sizey;
fin=(struct FINITION*)ProgressBar->finition;
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_GRADIENT_UP_FILLED_RECTANGLE,x+1,y+1,sizex-2,sizey-2,COLOR_MIDDLE_LIGHT,COLOR_LIGHT);
ProgressBarDrawProgress(ProgressBar);
}
void SetProgressBarPulse(struct ControlProgressBar *ProgressBar,int time_tick)
{
struct TIMER *timer;
struct HEADERPARENT *main_parent;
main_parent=(struct HEADERPARENT*)ProgressBar->main_parent;
if (main_parent!=(struct HEADERPARENT*)NULL)
{
main_parent->number_timers_for_controls++;
ProgressBar->timer=(DWORD*)SetTimerCallbackForControl(time_tick,&ProgressBarDrawProgress,ProgressBar);
timer=(struct TIMER*)ProgressBar->timer;
timer->flags=timer->flags | FLAG_TIMER_ON;
}
}
//---------------------------------------------------------------------------------
// control ProgressBar
//---------------------------------------------------------------------------------
void ProgressBarProc(struct ControlProgressBar *ProgressBar,struct MESSAGE *message)
{
int btn_state;
char v;
struct TIMER *timer;
struct FINITION *fin;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw ProgressBar
if (ProgressBar->flags & FLAG_SHOW_CONTROL) DrawProgressBar(ProgressBar);
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)ProgressBar->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DrawProgressBar(ProgressBar);
break;
}
case MESSAGE_SPECIALIZED:
{ //redraw bar of progress
if (ProgressBar->flags & FLAG_GET_SPECIALIZED_MESSAGE_ON)
{
if (ProgressBar->flags & FLAG_SHOW_CONTROL) ProgressBarDrawProgress(ProgressBar);
ProgressBar->flags=ProgressBar->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
}
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
ProgressBar->ctrl_x=ProgressBar->ctrl_x+message->arg1;
ProgressBar->ctrl_y=ProgressBar->ctrl_y+message->arg2;
break;
}
case MESSAGE_CALL_TIMER_EVENT:
{
if (ProgressBar->timer!=(DWORD*)NULL)
{
timer=(struct TIMER*)ProgressBar->timer;
if (timer->flags & FLAG_TIMER_ON) Timer(timer);
}
break;
}
case MESSAGE_DESTROY_CONTROL:
{
if (ProgressBar->timer!=(DWORD*)NULL) free(ProgressBar->timer);
free(ProgressBar->finition);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)ProgressBar,message);
ProgressBar->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
//send message to child controls(if there is)
SendMessage((struct HEADER*)ProgressBar,message);
}
//---------------------------------------------------------------------------------
// create control ProgressBar
//---------------------------------------------------------------------------------
void* CreateProgressBarEmpty(struct ProgressBarData *info_for_control)
{
struct ControlProgressBar *ProgressBar;
struct FINITION *fin;
ProgressBar=malloc(sizeof(struct ControlProgressBar));
ProgressBar->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)ProgressBar->finition;
fin->flags=0;
ID++;
#ifdef DEBUG
printf("\ncreated progress bar with ID=%d",(int)ID);
#endif
ProgressBar->child_bk=(DWORD*)NULL;
ProgressBar->child_fd=(DWORD*)NULL;
ProgressBar->active_control_for_keys=(DWORD*)NULL;
ProgressBar->active_control_for_mouse=(DWORD*)NULL;
ProgressBar->callback=(DWORD*)NULL;
ProgressBar->timer=(DWORD*)NULL;
ProgressBar->ctrl_proc=(DWORD*)&ProgressBarProc;
ProgressBar->ctrl_x=(DWORD)info_for_control->x;
ProgressBar->ctrl_y=(DWORD)info_for_control->y;
ProgressBar->ctrl_sizex=(DWORD)info_for_control->width;
ProgressBar->ctrl_sizey=(DWORD)info_for_control->height;
ProgressBar->ctrl_ID=ID;
ProgressBar->progress=info_for_control->progress;
ProgressBar->flags=0;
ProgressBar->flags=ProgressBar->flags | FLAG_SHOW_CONTROL;
ProgressBar->prb_flags=0;
ProgressBar->prb_flags=ProgressBar->prb_flags | FLAG_PB_HORIZONTAL_ORIENTATION_ON;
ProgressBar->prb_flags=ProgressBar->prb_flags | FLAG_PB_FROM_LEFT_TO_RIGHT_ON;
return(ProgressBar);
}
void* CreateProgressBar(gui_progress_bar_data_t *info)
{
gui_text_t *text;
gui_text_data_t txtdata;
gui_progress_bar_t *pbar;
pbar=CreateProgressBarEmpty(info);
txtdata.x=0;
txtdata.y=0;
txtdata.font=NULL;
txtdata.background=FALSE;
txtdata.color=0;
txtdata.text=malloc(1024);
txtdata.text[0]=0;
text=CreateText(&txtdata);
text->ctrl_x=(pbar->ctrl_sizex/2)-(text->ctrl_sizex/2);
text->ctrl_y=(pbar->ctrl_sizey/2)-(text->ctrl_sizey/2);
PackControls(pbar,text);
text->flags &=FLAG_HIDE_CONTROL;
return(pbar);
}
void ProgressBarSetText(gui_progress_bar_t *pbar,char *txt)
{
gui_text_t *text;
text=(gui_text_t*)pbar->child_bk;
if (*txt!='\0')
{
pbar->prb_flags|=FLAG_PB_TEXT_ON;
memmove(text->text,txt,strlen(txt));
text->flags |=FLAG_SHOW_CONTROL;
}
}
char *ProgressBarGetText(gui_progress_bar_t *pbar)
{
gui_text_t *text;
text=(gui_text_t*)pbar->child_bk;
return(text->text);
}

6
programs/develop/new libGUI_C/SRC/control_scroll_bar.h Executable file
View File

@ -0,0 +1,6 @@
#define FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_ON 0x1
#define FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_OFF 0xfe
#define FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_ON 0x2
#define FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_OFF 0xfd
#define FLAG_SCROLL_RULLER_PRESSED 0x4
#define FLAG_SCROLL_RULLER_RELEASED 0xfb

801
programs/develop/new libGUI_C/SRC/control_scroll_bar.inc Executable file
View File

@ -0,0 +1,801 @@
/*
control ScrollBar
*/
////////////////////////////////////////////////////////////////////////////////
// Draw Ruller
////////////////////////////////////////////////////////////////////////////////
void DrawRuller(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
int scrollbar_size,ruller_size,ruller_pos;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_ON)
{
scrollbar_size=sizex-sizey*2;
ruller_size=(int)(scrollbar_size*ScrollBar->ruller_size);
if (ruller_size<5) ruller_size=5;
if (ruller_size>sizex) ruller_size=sizex-2*sizey;
ruller_pos=x+sizey+(int)((scrollbar_size-ruller_size)*ScrollBar->ruller_pos);
//left bar
Draw(fin,TOOL_FILLED_RECTANGLE,x+sizey,y+1,ruller_pos-x-sizey,sizey-2,COLOR_FON);
//right bar
Draw(fin,TOOL_FILLED_RECTANGLE,ruller_pos+ruller_size,y+1,x+sizex-sizey-ruller_pos-ruller_size,sizey-2,COLOR_FON);
//roller
Draw(fin,TOOL_RECTANGLE,ruller_pos,y,ruller_size,sizey,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,ruller_pos+1,y+1,ruller_size-2,sizey-2,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_VERTICAL_LINE,ruller_pos+(ruller_size/2)-2,y+sizey/4,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_VERTICAL_LINE,ruller_pos+(ruller_size/2),y+sizey/4,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_VERTICAL_LINE,ruller_pos+(ruller_size/2)+2,y+sizey/4,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
}
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_ON)
{
scrollbar_size=sizey-sizex*2;
ruller_size=(int)(scrollbar_size*ScrollBar->ruller_size);
if (ruller_size<5) ruller_size=5;
if (ruller_size>sizey) ruller_size=sizey-2*sizex;
ruller_pos=y+sizex+(int)((scrollbar_size-ruller_size)*ScrollBar->ruller_pos);
//up bar
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+sizex,sizex-2,ruller_pos-y-sizex,COLOR_FON);
//down bar
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,ruller_pos+ruller_size,sizex-2,y+sizey-sizex-ruller_pos-ruller_size,COLOR_FON);
//roller
Draw(fin,TOOL_RECTANGLE,x,ruller_pos,sizex,ruller_size,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,ruller_pos+1,sizex-2,ruller_size-2,COLOR_MIDDLE_LIGHT);
Draw(fin,TOOL_HORIZONTAL_LINE,x+sizex/4,x+(3*sizex)/4,ruller_pos+(ruller_size/2)-2,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_HORIZONTAL_LINE,x+sizex/4,x+(3*sizex)/4,ruller_pos+(ruller_size/2),COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_HORIZONTAL_LINE,x+sizex/4,x+(3*sizex)/4,ruller_pos+(ruller_size/2)+2,COLOR_ABSOLUTE_DARK);
}
}
////////////////////////////////////////////////////////////////////////////////
// Draw full Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void DrawScrollBar(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_ON)
{
//draw child buttons and roller
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_ABSOLUTE_DARK);
//left button
Draw(fin,TOOL_RECTANGLE,x,y,sizey,sizey,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizey-2,sizey-2,COLOR_MIDDLE_LIGHT);
//left arrow of left button
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
//right button
Draw(fin,TOOL_RECTANGLE,x+sizex-sizey,y,sizey,sizey,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+sizex-sizey+1,y+1,sizey-2,sizey-2,COLOR_MIDDLE_LIGHT);
//right arrow of right button
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
//roller
DrawRuller(ScrollBar);
}
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_ON)
{
//draw child buttons and roller
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_ABSOLUTE_DARK);
//up button
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizex-2,sizex-2,COLOR_MIDDLE_LIGHT);
//up arrow of up button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+sizex/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+(3*sizex)/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+sizex/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+(3*sizex)/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
//down button
Draw(fin,TOOL_RECTANGLE,x,y+sizey-sizex,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+sizey-sizex+1,sizex-2,sizex-2,COLOR_MIDDLE_LIGHT);
//down arrow of down button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+sizex/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+(3*sizex)/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+sizex/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+(3*sizex)/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
//roller
DrawRuller(ScrollBar);
}
}
////////////////////////////////////////////////////////////////////////////////
// Vertical Scroll Bar
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// animation of up button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_DrawPressedUpButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//up button
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizex-2,sizex-2,COLOR_FON);
//up arrow of up button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+sizex/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+(3*sizex)/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+sizex/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+(3*sizex)/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
}
void ScrollBar_DrawReleasedUpButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//up button
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizex-2,sizex-2,COLOR_MIDDLE_LIGHT);
//up arrow of up button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+sizex/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizex/3,x+(3*sizex)/4,y+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+sizex/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+1+(sizex/3),x+(3*sizex)/4,y+1+(2*sizex)/3,COLOR_ABSOLUTE_DARK);
}
////////////////////////////////////////////////////////////////////////////////
// animation of down button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_DrawPressedDownButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//down button
Draw(fin,TOOL_RECTANGLE,x,y+sizey-sizex,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+sizey-sizex+1,sizex-2,sizex-2,COLOR_FON);
//down arrow of down button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+sizex/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+(3*sizex)/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+sizex/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+(3*sizex)/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
}
void ScrollBar_DrawReleasedDownButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//down button
Draw(fin,TOOL_RECTANGLE,x,y+sizey-sizex,sizex,sizex,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+sizey-sizex+1,sizex-2,sizex-2,COLOR_MIDDLE_LIGHT);
//down arrow of down button
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+sizex/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-sizex/3,x+(3*sizex)/4,y+sizey-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+sizex/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex/2,y+sizey-1-(sizex/3),x+(3*sizex)/4,y+sizey-1-(2*sizex)/3,COLOR_ABSOLUTE_DARK);
}
////////////////////////////////////////////////////////////////////////////////
// callback function for up button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_FuncCallbackForUpButton_Pressed(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
struct HEADERPARENT *main_parent;
ScrollBar=(struct ControlScrollBar*)data;
if (ScrollBar->ruller_size!=1.0)
{
ScrollBar->ruller_pos=ScrollBar->ruller_pos-ScrollBar->ruller_step;
}
if (ScrollBar->ruller_pos<0.0) ScrollBar->ruller_pos=0.0;
ScrollBar_DrawPressedUpButton(ScrollBar);
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
main_parent=(struct HEADERPARENT*)ScrollBar->main_parent;
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
DrawRuller(ScrollBar);
}
void ScrollBar_FuncCallbackForUpButton_Released(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar_DrawReleasedUpButton(ScrollBar);
}
////////////////////////////////////////////////////////////////////////////////
// callback function for down button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_FuncCallbackForDownButton_Pressed(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
struct HEADERPARENT *main_parent;
ScrollBar=(struct ControlScrollBar*)data;
if (ScrollBar->ruller_size!=1.0)
{
ScrollBar->ruller_pos=ScrollBar->ruller_pos+ScrollBar->ruller_step;
}
if (ScrollBar->ruller_pos>1.0) ScrollBar->ruller_pos=1.0;
ScrollBar_DrawPressedDownButton(ScrollBar);
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
main_parent=(struct HEADERPARENT*)ScrollBar->main_parent;
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
DrawRuller(ScrollBar);
}
void ScrollBar_FuncCallbackForDownButton_Released(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar_DrawReleasedDownButton(ScrollBar);
DrawRuller(ScrollBar);
}
////////////////////////////////////////////////////////////////////////////////
// Horizontal Scroll Bar
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// animation of left button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_DrawPressedLeftButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//left button
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizey-2,sizey-2,COLOR_FON);
//left arrow of left button
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
}
void ScrollBar_DrawReleasedLeftButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//left button
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,sizey-2,sizey-2,COLOR_MIDDLE_LIGHT);
//left arrow of left button
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizey/3,y+sizey/2,x+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+1+(sizey/3),y+sizey/2,x+1+(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
}
////////////////////////////////////////////////////////////////////////////////
// animation of right button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_DrawPressedRightButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//right button
Draw(fin,TOOL_FILLED_RECTANGLE,x+sizex-sizey+1,y+1,sizey-2,sizey-2,COLOR_FON);
//right arrow of right button
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
}
void ScrollBar_DrawReleasedRightButton(struct ControlScrollBar *ScrollBar)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
fin=(struct FINITION*)ScrollBar->finition;
//right button
Draw(fin,TOOL_FILLED_RECTANGLE,x+sizex-sizey+1,y+1,sizey-2,sizey-2,COLOR_MIDDLE_LIGHT);
//right arrow of right button
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-sizey/3,y+sizey/2,x+sizex-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+sizey/4,COLOR_ABSOLUTE_DARK);
Draw(fin,TOOL_LINE,x+sizex-1-(sizey/3),y+sizey/2,x+sizex-1-(2*sizey)/3,y+(3*sizey)/4,COLOR_ABSOLUTE_DARK);
}
////////////////////////////////////////////////////////////////////////////////
// callback function for left button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_FuncCallbackForLeftButton_Pressed(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
struct HEADERPARENT *main_parent;
ScrollBar=(struct ControlScrollBar*)data;
if (ScrollBar->ruller_size!=1.0)
{
ScrollBar->ruller_pos=ScrollBar->ruller_pos-ScrollBar->ruller_step;
}
if (ScrollBar->ruller_pos<0.0) ScrollBar->ruller_pos=0.0;
ScrollBar_DrawPressedLeftButton(ScrollBar);
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
main_parent=(struct HEADERPARENT*)ScrollBar->main_parent;
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
DrawRuller(ScrollBar);
}
void ScrollBar_FuncCallbackForLeftButton_Released(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar_DrawReleasedLeftButton(ScrollBar);
}
////////////////////////////////////////////////////////////////////////////////
// callback function for right button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_FuncCallbackForRightButton_Pressed(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
struct HEADERPARENT *main_parent;
ScrollBar=(struct ControlScrollBar*)data;
if (ScrollBar->ruller_size!=1.0)
{
ScrollBar->ruller_pos=ScrollBar->ruller_pos+ScrollBar->ruller_step;
}
if (ScrollBar->ruller_pos>1.0) ScrollBar->ruller_pos=1.0;
ScrollBar_DrawPressedRightButton(ScrollBar);
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
main_parent=(struct HEADERPARENT*)ScrollBar->main_parent;
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
DrawRuller(ScrollBar);
}
void ScrollBar_FuncCallbackForRightButton_Released(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar_DrawReleasedRightButton(ScrollBar);
DrawRuller(ScrollBar);
}
////////////////////////////////////////////////////////////////////////////////
// callback function for ruller bar button of Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void ScrollBar_FuncCallbackForScrollRullerPressed(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar->scb_flags=ScrollBar->scb_flags | FLAG_SCROLL_RULLER_PRESSED;
}
void ScrollBar_FuncCallbackForScrollRullerReleased(struct HEADER *control,void *data)
{
struct ControlScrollBar *ScrollBar;
ScrollBar=(struct ControlScrollBar*)data;
ScrollBar->scb_flags=ScrollBar->scb_flags & FLAG_SCROLL_RULLER_RELEASED;
}
//---------------------------------------------------------------------------------
// control ScrollBar
//---------------------------------------------------------------------------------
void ScrollBarProc(struct ControlScrollBar *ScrollBar,struct MESSAGE *message)
{
int mx,my;
char mouse_buttons_state;
int x,y,sizex,sizey;
int scrollbar_size,ruller_size,ruller_pos;
int ruller_min,ruller_max;
float max_pos,current_pos,last_ruller_pos;
struct FINITION *fin;
struct TIMER *timer;
struct HEADERPARENT *main_parent;
x=ScrollBar->ctrl_x;
y=ScrollBar->ctrl_y;
sizex=ScrollBar->ctrl_sizex;
sizey=ScrollBar->ctrl_sizey;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw ScrollBar
if (ScrollBar->flags & FLAG_SHOW_CONTROL) DrawScrollBar(ScrollBar);
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)ScrollBar->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DrawScrollBar(ScrollBar);
break;
}
case MESSAGE_SPECIALIZED:
{
if (ScrollBar->flags & FLAG_GET_SPECIALIZED_MESSAGE_ON)
{
if (ScrollBar->flags & FLAG_SHOW_CONTROL) DrawScrollBar(ScrollBar);
ScrollBar->flags=ScrollBar->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
}
break;
}
case MESSAGE_MOUSE_EVENT:
{
mx=message->arg1;
my=message->arg2;
mouse_buttons_state=message->arg3;
main_parent=(struct HEADERPARENT*)ScrollBar->main_parent;
//check ruller state
if (ScrollBar->scb_flags & FLAG_SCROLL_RULLER_PRESSED)
{ // horizontal ScrollBar
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_ON)
{
scrollbar_size=sizex-sizey*2;
ruller_size=scrollbar_size*ScrollBar->ruller_size;
if (ruller_size<5) ruller_size=5;
ruller_min=x+sizey; //minimum x
ruller_max=ruller_min+scrollbar_size-ruller_size;
ruller_pos=mx-(ruller_size/2);//ruller centred under mouse pointer
if (ruller_pos<ruller_min) ruller_pos=ruller_min;
if (ruller_pos>ruller_max) ruller_pos=ruller_max;
if (ruller_max!=ruller_min)
{
max_pos=(float)(ruller_max-ruller_min);
current_pos=(float)(ruller_pos-ruller_min);
last_ruller_pos=ScrollBar->ruller_pos;
ScrollBar->ruller_pos=current_pos/max_pos;
}
else {ScrollBar->ruller_pos=0.0;}
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
if (ScrollBar->ruller_pos!=last_ruller_pos)
{
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
}
if (ScrollBar->ruller_pos!=last_ruller_pos) DrawRuller(ScrollBar);
break;
}
// vertical ScrollBar
if (ScrollBar->scb_flags & FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_ON)
{
scrollbar_size=sizey-sizex*2;
ruller_size=scrollbar_size*ScrollBar->ruller_size;
if (ruller_size<5) ruller_size=5;
ruller_min=y+sizex; //minimum x
ruller_max=ruller_min+scrollbar_size-ruller_size;
ruller_pos=my-(ruller_size/2);//ruller centred under mouse pointer
if (ruller_pos<ruller_min) ruller_pos=ruller_min;
if (ruller_pos>ruller_max) ruller_pos=ruller_max;
if (ruller_max!=ruller_min)
{
max_pos=(float)(ruller_max-ruller_min);
current_pos=(float)(ruller_pos-ruller_min);
last_ruller_pos=ScrollBar->ruller_pos;
ScrollBar->ruller_pos=current_pos/max_pos;
}
else {ScrollBar->ruller_pos=0.0;}
if (ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT)!=NULL)
{
if (ScrollBar->ruller_pos!=last_ruller_pos)
{
ScrollBar->flags=ScrollBar->flags | FLAG_CONNECT_EVENT_ON;
main_parent->control_for_callback_function[main_parent->number_callbacks]=
(DWORD*)ScrollBar;
main_parent->callback_for_control_callback[main_parent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(ScrollBar,SCROLLBAR_CHANGED_EVENT);
main_parent->number_callbacks++;
}
}
if (ScrollBar->ruller_pos!=last_ruller_pos) DrawRuller(ScrollBar);
}
}
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
ScrollBar->ctrl_x=ScrollBar->ctrl_x+message->arg1;
ScrollBar->ctrl_y=ScrollBar->ctrl_y+message->arg2;
break;
}
case MESSAGE_CALL_TIMER_EVENT:
{
if (ScrollBar->timer!=(DWORD*)NULL)
{
timer=(struct TIMER*)ScrollBar->timer;
if (timer->flags & FLAG_TIMER_ON) Timer(timer);
}
break;
}
case MESSAGE_DESTROY_CONTROL:
{
if (ScrollBar->timer!=(DWORD*)NULL) free(ScrollBar->timer);
free(ScrollBar->finition);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)ScrollBar,message);
ScrollBar->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
//send message to child controls(if there is)
SendMessage((struct HEADER*)ScrollBar,message);
}
//---------------------------------------------------------------------------------
// create control ScrollBar
//---------------------------------------------------------------------------------
void* CreateScrollBar(struct ScrollBarData *info_for_control)
{
struct ControlScrollBar *ScrollBar;
struct FINITION *fin;
ScrollBar=malloc(sizeof(struct ControlScrollBar));
ScrollBar->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)ScrollBar->finition;
fin->flags=0;
ID++;
#ifdef DEBUG
printf("\ncreated scroll bar with ID=%d",(int)ID);
#endif
ScrollBar->child_bk=(DWORD*)NULL;
ScrollBar->child_fd=(DWORD*)NULL;
ScrollBar->active_control_for_keys=(DWORD*)NULL;
ScrollBar->active_control_for_mouse=(DWORD*)NULL;
ScrollBar->callback=(DWORD*)NULL;
ScrollBar->timer=(DWORD*)NULL;
ScrollBar->ctrl_proc=(DWORD*)&ScrollBarProc;
ScrollBar->ctrl_x=(DWORD)info_for_control->x;
ScrollBar->ctrl_y=(DWORD)info_for_control->y;
ScrollBar->ctrl_sizex=(DWORD)info_for_control->width;
ScrollBar->ctrl_sizey=(DWORD)info_for_control->height;
ScrollBar->ctrl_ID=ID;
ScrollBar->ruller_size=info_for_control->ruller_size;
ScrollBar->ruller_pos=info_for_control->ruller_pos;
ScrollBar->ruller_step=info_for_control->ruller_step;
ScrollBar->flags=0;
ScrollBar->flags=ScrollBar->flags | FLAG_SHOW_CONTROL;
return(ScrollBar);
}
void* CreateHorizontalScrollBar(struct ScrollBarData *info_for_control)
{
struct ControlScrollBar *ScrollBar;
struct ControlButton *ChildButton1;
struct ControlButton *ChildButton2;
struct ControlButton *ScrollRuller;
struct ButtonData ChildButton1Data;
struct ButtonData ChildButton2Data;
struct ButtonData ScrollRullerData;
ScrollBar=CreateScrollBar(info_for_control);
//set horizontal orientation
ScrollBar->scb_flags=0;
ScrollBar->scb_flags=ScrollBar->scb_flags | FLAG_SCROLL_BAR_ORIENTATION_HORIZONTAL_ON;
//fill data for first child button of scroller
ChildButton1Data.x=0;
ChildButton1Data.y=0;
ChildButton1Data.width=ScrollBar->ctrl_sizey;
ChildButton1Data.height=ChildButton1Data.width;
//fill data for second child button of scroller
ChildButton2Data.x=ScrollBar->ctrl_sizex-ScrollBar->ctrl_sizey;
ChildButton2Data.y=0;
ChildButton2Data.width=ScrollBar->ctrl_sizey;
ChildButton2Data.height=ChildButton2Data.width;
//fill data for scroll ruller button of scroller
ScrollRullerData.x=ScrollBar->ctrl_sizey;
ScrollRullerData.y=0;
ScrollRullerData.width=ScrollBar->ctrl_sizex-2*ScrollBar->ctrl_sizey;
ScrollRullerData.height=ScrollBar->ctrl_sizey;
ChildButton1=CreateButton(&ChildButton1Data);
ChildButton2=CreateButton(&ChildButton2Data);
ScrollRuller=CreateButton(&ScrollRullerData);
ChildButton1->flags=ChildButton1->flags & FLAG_HIDE_CONTROL;
ChildButton2->flags=ChildButton2->flags & FLAG_HIDE_CONTROL;
ScrollRuller->flags=ScrollRuller->flags & FLAG_HIDE_CONTROL;
SetCallbackFunction(ChildButton1,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForLeftButton_Pressed,ScrollBar);
SetCallbackFunction(ChildButton1,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForLeftButton_Released,ScrollBar);
SetCallbackFunction(ChildButton2,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForRightButton_Pressed,ScrollBar);
SetCallbackFunction(ChildButton2,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForRightButton_Released,ScrollBar);
SetCallbackFunction(ScrollRuller,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForScrollRullerPressed,ScrollBar);
SetCallbackFunction(ScrollRuller,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForScrollRullerReleased,ScrollBar);
//pack button in control ScrollBar
PackControls(ScrollBar,ChildButton1);
PackControls(ScrollBar,ChildButton2);
PackControls(ScrollBar,ScrollRuller);
return(ScrollBar);
}
void* CreateVerticalScrollBar(struct ScrollBarData *info_for_control)
{
struct ControlScrollBar *ScrollBar;
struct ControlButton *ChildButton1;
struct ControlButton *ChildButton2;
struct ControlButton *ScrollRuller;
struct ButtonData ChildButton1Data;
struct ButtonData ChildButton2Data;
struct ButtonData ScrollRullerData;
ScrollBar=CreateScrollBar(info_for_control);
//set vertical orientation
ScrollBar->scb_flags=0;
ScrollBar->scb_flags=ScrollBar->scb_flags | FLAG_SCROLL_BAR_ORIENTATION_VERTICAL_ON;
//fill data for first child button of scroller
ChildButton1Data.x=0;
ChildButton1Data.y=0;
ChildButton1Data.width=ScrollBar->ctrl_sizex;
ChildButton1Data.height=ChildButton1Data.width;
//fill data for second child button of scroller
ChildButton2Data.x=0;
ChildButton2Data.y=ScrollBar->ctrl_sizey-ScrollBar->ctrl_sizex;
ChildButton2Data.width=ScrollBar->ctrl_sizex;
ChildButton2Data.height=ChildButton2Data.width;
//fill data for scroll ruller button of scroller
ScrollRullerData.x=0;
ScrollRullerData.y=ScrollBar->ctrl_sizex;
ScrollRullerData.width=ScrollBar->ctrl_sizex;
ScrollRullerData.height=ScrollBar->ctrl_sizey-2*ScrollBar->ctrl_sizex;
ChildButton1=CreateButton(&ChildButton1Data);
ChildButton2=CreateButton(&ChildButton2Data);
ScrollRuller=CreateButton(&ScrollRullerData);
ChildButton1->flags=ChildButton1->flags & FLAG_HIDE_CONTROL;
ChildButton2->flags=ChildButton2->flags & FLAG_HIDE_CONTROL;
ScrollRuller->flags=ScrollRuller->flags & FLAG_HIDE_CONTROL;
SetCallbackFunction(ChildButton1,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForUpButton_Pressed,ScrollBar);
SetCallbackFunction(ChildButton1,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForUpButton_Released,ScrollBar);
SetCallbackFunction(ChildButton2,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForDownButton_Pressed,ScrollBar);
SetCallbackFunction(ChildButton2,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForDownButton_Released,ScrollBar);
SetCallbackFunction(ScrollRuller,BUTTON_PRESSED_EVENT,&ScrollBar_FuncCallbackForScrollRullerPressed,ScrollBar);
SetCallbackFunction(ScrollRuller,BUTTON_RELEASED_EVENT,&ScrollBar_FuncCallbackForScrollRullerReleased,ScrollBar);
//pack button in control ScrollBar
PackControls(ScrollBar,ChildButton1);
PackControls(ScrollBar,ChildButton2);
PackControls(ScrollBar,ScrollRuller);
return(ScrollBar);
}

6
programs/develop/new libGUI_C/SRC/control_scrolled_window.h Executable file
View File

@ -0,0 +1,6 @@
#define FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON 0x1
#define FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON 0x2
#define FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_OFF 0xfe
#define FLAG_SCROLL_WIN_VERTICAL_SCROLL_OFF 0xfd

609
programs/develop/new libGUI_C/SRC/control_scrolled_window.inc Executable file
View File

@ -0,0 +1,609 @@
/*
control ScrolledWindow
*/
////////////////////////////////////////////////////////////////////////
// pack controls in ScrolledWindow
////////////////////////////////////////////////////////////////////////
void ScrolledWindowPackControls(void *parent,void *Control)
{
struct HEADER *control;
struct ControlScrolledWindow *ScrolledWindow;
struct ControlScrollBar *HorizontalScrollBar;
struct ControlScrollBar *VerticalScrollBar;
struct FINITION *fin;
int x,y;
ScrolledWindow=(struct ControlScrolledWindow*)parent;
control=(struct HEADER *)Control;
if (control->ctrl_x+control->ctrl_sizex>ScrolledWindow->virtual_sizex)
{
ScrolledWindow->virtual_sizex=control->ctrl_x+control->ctrl_sizex;
}
if (control->ctrl_y+control->ctrl_sizey>ScrolledWindow->virtual_sizey)
{
ScrolledWindow->virtual_sizey=control->ctrl_y+control->ctrl_sizey;
}
PackControls(ScrolledWindow,control);
//calculate new control coordinates
x=control->ctrl_x+1;//add border width
y=control->ctrl_y+1;//add border heght
SetControlNewPosition(control,x,y);
//save coordinates of control in arrea
ScrolledWindow->virtual_controls_x[ScrolledWindow->number_virtual_controls]=x;
ScrolledWindow->virtual_controls_y[ScrolledWindow->number_virtual_controls]=y;
ScrolledWindow->number_virtual_controls++;
x=ScrolledWindow->ctrl_x+1;
y=ScrolledWindow->ctrl_y+1;
//check cross control with scroll arrea
if (CheckCrossRectangles(x,y,ScrolledWindow->scroll_arrea_sizex,ScrolledWindow->scroll_arrea_sizey,
control->ctrl_x,control->ctrl_y,control->ctrl_sizex,control->ctrl_sizey)==TRUE)
{
control->flags=control->flags | FLAG_SHOW_CONTROL;
control->flags=control->flags & FLAG_MOUSE_BLOCKED_OFF;
}
else
{
control->flags=control->flags & FLAG_HIDE_CONTROL;
control->flags=control->flags | FLAG_MOUSE_BLOCKED_ON;
}
if (ScrolledWindow->virtual_sizex>ScrolledWindow->scroll_arrea_sizex)
{
HorizontalScrollBar=(struct ControlScrollBar*)ScrolledWindow->horizontal_scroll;
if ((ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON)==FALSE)
{
ScrolledWindow->scroll_arrea_sizey=ScrolledWindow->ctrl_sizey-16-2;
ScrolledWindow->scw_flags=ScrolledWindow->scw_flags | FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON;
HorizontalScrollBar->flags=HorizontalScrollBar->flags | FLAG_SHOW_CONTROL;
HorizontalScrollBar->flags=HorizontalScrollBar->flags & FLAG_MOUSE_BLOCKED_OFF;
}
}
if (ScrolledWindow->virtual_sizey>ScrolledWindow->scroll_arrea_sizey)
{
VerticalScrollBar=(struct ControlScrollBar*)ScrolledWindow->vertical_scroll;
if ((ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON)==FALSE)
{
ScrolledWindow->scroll_arrea_sizex=ScrolledWindow->ctrl_sizex-16-2;
ScrolledWindow->scw_flags=ScrolledWindow->scw_flags | FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON;
VerticalScrollBar->flags=VerticalScrollBar->flags | FLAG_SHOW_CONTROL;
VerticalScrollBar->flags=VerticalScrollBar->flags & FLAG_MOUSE_BLOCKED_OFF;
}
}
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON)
{
HorizontalScrollBar->ruller_size=(float)ScrolledWindow->scroll_arrea_sizex;
HorizontalScrollBar->ruller_size=HorizontalScrollBar->ruller_size/((float)ScrolledWindow->virtual_sizex);
}
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON)
{
VerticalScrollBar->ruller_size=(float)ScrolledWindow->scroll_arrea_sizey;
VerticalScrollBar->ruller_size=VerticalScrollBar->ruller_size/((float)ScrolledWindow->virtual_sizey);
}
//finit draw arrea for control
fin=(struct FINITION*)control->finition;
fin->x=ScrolledWindow->ctrl_x+1;
fin->y=ScrolledWindow->ctrl_y+1;
fin->sizex=ScrolledWindow->scroll_arrea_sizex;
fin->sizey=ScrolledWindow->scroll_arrea_sizey;
fin->flags=fin->flags | FINITION_ON;
}
////////////////////////////////////////////////////////////////////////////////
// Draw full Scroll Bar
////////////////////////////////////////////////////////////////////////////////
void DrawScrolledWindow(struct ControlScrolledWindow *ScrolledWindow)
{
int x,y,sizex,sizey;
struct FINITION *fin;
x=ScrolledWindow->ctrl_x;
y=ScrolledWindow->ctrl_y;
sizex=ScrolledWindow->ctrl_sizex;
sizey=ScrolledWindow->ctrl_sizey;
fin=(struct FINITION*)ScrolledWindow->finition;
Draw(fin,TOOL_FILLED_RECTANGLE,x+1,y+1,ScrolledWindow->scroll_arrea_sizex,
ScrolledWindow->scroll_arrea_sizey,COLOR_LIGHT);
if ((ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON) ||
(ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON))
{
Draw(fin,TOOL_RECTANGLE,x,y,ScrolledWindow->scroll_arrea_sizex+2,
ScrolledWindow->scroll_arrea_sizey+2,0xff0000);
}
else
Draw(fin,TOOL_RECTANGLE,x,y,sizex,sizey,COLOR_ABSOLUTE_DARK);
}
void ScrollWin_FuncCallback_HScroll(struct HEADER* control,void *data)
{
struct ControlScrollBar *Hscrollbar,*Vscrollbar;
struct ControlScrolledWindow *ScrolledWindow;
struct HEADER *seek_control,*exchange_control;
struct FINITION *fin;
struct MESSAGE local_message;
int i,new_x,new_y,x,y,sizex,sizey;
Hscrollbar=(struct ControlScrollBar*)control;
ScrolledWindow=(struct ControlScrolledWindow*)data;
ScrolledWindow->virtual_x=(ScrolledWindow->virtual_sizex-ScrolledWindow->scroll_arrea_sizex)*Hscrollbar->ruller_pos;
x=ScrolledWindow->ctrl_x+1;
y=ScrolledWindow->ctrl_y+1;
sizex=ScrolledWindow->scroll_arrea_sizex;
sizey=ScrolledWindow->scroll_arrea_sizey;
local_message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
local_message.arg1=x;
local_message.arg2=y;
local_message.arg3=sizex;
local_message.arg4=sizey;
fin=(finition_t*)ScrolledWindow->finition;
Draw(fin,TOOL_FILLED_RECTANGLE,x,y,sizex,sizey,COLOR_LIGHT);
Vscrollbar=(struct ControlScrollBar*)ScrolledWindow->vertical_scroll;
seek_control=(struct HEADER*)Vscrollbar->ctrl_fd;
//move controls in new position
for(i=0;i<ScrolledWindow->number_virtual_controls;i++)
{
new_x=ScrolledWindow->virtual_controls_x[i]-ScrolledWindow->virtual_x;
new_y=ScrolledWindow->virtual_controls_y[i]-ScrolledWindow->virtual_y;
SetControlNewPosition(seek_control,new_x,new_y);
if (CheckCrossRectangles(local_message.arg1,local_message.arg2,local_message.arg3,local_message.arg4,
seek_control->ctrl_x,seek_control->ctrl_y,seek_control->ctrl_sizex,seek_control->ctrl_sizey)==TRUE)
{
seek_control->flags=seek_control->flags | FLAG_SHOW_CONTROL;
seek_control->flags=seek_control->flags & FLAG_MOUSE_BLOCKED_OFF;
}
else
{
seek_control->flags=seek_control->flags & FLAG_HIDE_CONTROL;
seek_control->flags=seek_control->flags | FLAG_MOUSE_BLOCKED_ON;
}
if (seek_control->flags & FLAG_SHOW_CONTROL)
{
ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc;
ControlProc(seek_control,&local_message);
}
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
}
void ScrollWin_FuncCallback_VScroll(struct HEADER* control,void *data)
{
struct ControlScrollBar *Hscrollbar,*Vscrollbar;
struct ControlScrolledWindow *ScrolledWindow;
struct HEADER *seek_control,*exchange_control;
struct MESSAGE local_message;
struct FINITION *fin;
int i,new_x,new_y,x,y,sizex,sizey;
Vscrollbar=(struct ControlScrollBar*)control;
ScrolledWindow=(struct ControlScrolledWindow*)data;
ScrolledWindow->virtual_y=(ScrolledWindow->virtual_sizey-ScrolledWindow->scroll_arrea_sizey)*Vscrollbar->ruller_pos;
x=ScrolledWindow->ctrl_x+1;
y=ScrolledWindow->ctrl_y+1;
sizex=ScrolledWindow->scroll_arrea_sizex;
sizey=ScrolledWindow->scroll_arrea_sizey;
local_message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
local_message.arg1=x;
local_message.arg2=y;
local_message.arg3=sizex;
local_message.arg4=sizey;
fin=(finition_t*)ScrolledWindow->finition;
Draw(fin,TOOL_FILLED_RECTANGLE,x,y,sizex,sizey,COLOR_LIGHT);
seek_control=(struct HEADER*)Vscrollbar->ctrl_fd;
//move controls in new position
for(i=0;i<ScrolledWindow->number_virtual_controls;i++)
{
new_x=ScrolledWindow->virtual_controls_x[i]-ScrolledWindow->virtual_x;
new_y=ScrolledWindow->virtual_controls_y[i]-ScrolledWindow->virtual_y;
SetControlNewPosition(seek_control,new_x,new_y);
if (CheckCrossRectangles(local_message.arg1,local_message.arg2,local_message.arg3,local_message.arg4,
seek_control->ctrl_x,seek_control->ctrl_y,seek_control->ctrl_sizex,seek_control->ctrl_sizey)==TRUE)
{
seek_control->flags=seek_control->flags | FLAG_SHOW_CONTROL;
seek_control->flags=seek_control->flags & FLAG_MOUSE_BLOCKED_OFF;
}
else
{
seek_control->flags=seek_control->flags & FLAG_HIDE_CONTROL;
seek_control->flags=seek_control->flags | FLAG_MOUSE_BLOCKED_ON;
}
if (seek_control->flags & FLAG_SHOW_CONTROL)
{
ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc;
ControlProc(seek_control,&local_message);
}
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
}
void ScrlWinCheckActivatedForKeysControl(struct ControlScrolledWindow *ScrolledWindow)
{
struct HEADER *control,*seek_control,*exchange_control;
struct MESSAGE local_message;
struct FINITION *fin;
struct ControlScrollBar *Vscrollbar,*Hscrollbar;
int i,x,y,sizex,sizey;
int sx,sy;
control=(struct HEADER*)ScrolledWindow->active_control_for_keys;
x=ScrolledWindow->ctrl_x+1;
y=ScrolledWindow->ctrl_y+1;
sizex=ScrolledWindow->scroll_arrea_sizex;
sizey=ScrolledWindow->scroll_arrea_sizey;
if (CheckFullCrossRectangles(x,y,sizex,sizey,
control->ctrl_x,control->ctrl_y,control->ctrl_sizex,control->ctrl_sizey)==TRUE) return;
//calculate new x and y coordinates
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON)
{
sx=(control->ctrl_x-x);
if (sx<0) sx=x;
else
{
if (control->ctrl_sizex<sizex) sx=x+sizex-control->ctrl_sizex;
else sx=x;
}
}
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON)
{
sy=(control->ctrl_y-y);
if (sy<0) sy=y;
else
{
if (control->ctrl_sizey<sizey) sy=y+sizey-control->ctrl_sizey;
else sy=y;
}
}
Vscrollbar=(struct ControlScrollBar*)ScrolledWindow->vertical_scroll;
Hscrollbar=(struct ControlScrollBar*)ScrolledWindow->horizontal_scroll;
//find active control and virtual control coordinates
seek_control=(struct HEADER*)Vscrollbar->ctrl_fd;
for(i=0;i<ScrolledWindow->number_virtual_controls;i++)
{
if (seek_control==control)
{
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON)
ScrolledWindow->virtual_x=ScrolledWindow->virtual_controls_x[i]-sx;
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON)
ScrolledWindow->virtual_y=ScrolledWindow->virtual_controls_y[i]-sy;
break;
}
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_HORIZONTAL_SCROLL_ON)
{
Hscrollbar->ruller_pos=(float)ScrolledWindow->virtual_x;
Hscrollbar->ruller_pos=Hscrollbar->ruller_pos/((float)(ScrolledWindow->virtual_sizex-ScrolledWindow->scroll_arrea_sizex));
SpecialRedrawControl(Hscrollbar);
}
if (ScrolledWindow->scw_flags & FLAG_SCROLL_WIN_VERTICAL_SCROLL_ON)
{
Vscrollbar->ruller_pos=(float)ScrolledWindow->virtual_y;
Vscrollbar->ruller_pos=Vscrollbar->ruller_pos/((float)(ScrolledWindow->virtual_sizey-ScrolledWindow->scroll_arrea_sizey));
SpecialRedrawControl(Vscrollbar);
}
local_message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
local_message.arg1=x;
local_message.arg2=y;
local_message.arg3=sizex;
local_message.arg4=sizey;
fin=(finition_t*)ScrolledWindow->finition;
Draw(fin,TOOL_FILLED_RECTANGLE,x,y,sizex,sizey,COLOR_LIGHT);
seek_control=(struct HEADER*)Vscrollbar->ctrl_fd;
//move controls in new position
for(i=0;i<ScrolledWindow->number_virtual_controls;i++)
{
sx=ScrolledWindow->virtual_controls_x[i]-ScrolledWindow->virtual_x;
sy=ScrolledWindow->virtual_controls_y[i]-ScrolledWindow->virtual_y;
SetControlNewPosition(seek_control,sx,sy);
if (CheckCrossRectangles(x,y,sizex,sizey,seek_control->ctrl_x,seek_control->ctrl_y,
seek_control->ctrl_sizex,seek_control->ctrl_sizey)==TRUE)
{
seek_control->flags=seek_control->flags | FLAG_SHOW_CONTROL;
seek_control->flags=seek_control->flags & FLAG_MOUSE_BLOCKED_OFF;
}
else
{
seek_control->flags=seek_control->flags & FLAG_HIDE_CONTROL;
seek_control->flags=seek_control->flags | FLAG_MOUSE_BLOCKED_ON;
}
if (seek_control->flags & FLAG_SHOW_CONTROL)
{
ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc;
ControlProc(seek_control,&local_message);
}
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
}
//---------------------------------------------------------------------------------
// control ScrolledWindowScrolledWindow->virtual_sizex
//---------------------------------------------------------------------------------
void ScrolledWindowProc(struct ControlScrolledWindow *ScrolledWindow,struct MESSAGE *message)
{
int i,x,y,sizex,sizey;
struct HEADER *seek_control,*exchange_control;
struct ControlScrollBar *Hscrollbar,*Vscrollbar;
struct MESSAGE local_message;
struct FINITION *fin;
struct TIMER *timer;
x=ScrolledWindow->ctrl_x;
y=ScrolledWindow->ctrl_y;
sizex=ScrolledWindow->ctrl_sizex;
sizey=ScrolledWindow->ctrl_sizey;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw ScrolledWindow
if (ScrolledWindow->flags & FLAG_SHOW_CONTROL)
{
DrawScrolledWindow(ScrolledWindow);
//send message to scroll bars
Hscrollbar=(struct ControlScrollBar*)ScrolledWindow->horizontal_scroll;
Vscrollbar=(struct ControlScrollBar*)ScrolledWindow->vertical_scroll;
ControlProc=(void (*)(void *Control,struct MESSAGE *message))Hscrollbar->ctrl_proc;
ControlProc((struct HEADER*)Hscrollbar,message);
ControlProc=(void (*)(void *Control,struct MESSAGE *message))Vscrollbar->ctrl_proc;
ControlProc((struct HEADER*)Vscrollbar,message);
//send message finit redraw only to some child controls of ScrolledWondow
local_message.type=MESSAGE_FULL_REDRAW_ALL_WITH_FINITION;
local_message.arg1=ScrolledWindow->ctrl_x+1;
local_message.arg2=ScrolledWindow->ctrl_y+1;
local_message.arg3=ScrolledWindow->scroll_arrea_sizex;
local_message.arg4=ScrolledWindow->scroll_arrea_sizey;
seek_control=(struct HEADER *)Vscrollbar->ctrl_fd;
while(seek_control!=(struct HEADER*)NULL)
{
if (seek_control->flags & FLAG_SHOW_CONTROL)
{
ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc;
ControlProc(seek_control,&local_message);
}
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
}
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)ScrolledWindow->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DrawScrolledWindow(ScrolledWindow);
SendMessage((struct HEADER*)ScrolledWindow,message);//<<<<<<----------------------------------
break;
}
case MESSAGE_SPECIALIZED:
{
if (ScrolledWindow->flags & FLAG_SHOW_CONTROL) SendMessage((struct HEADER*)ScrolledWindow,message);
ScrolledWindow->flags=ScrolledWindow->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
break;
}
case MESSAGE_KEYS_EVENT:
{
if (ScrolledWindow->active_control_for_keys!=NULL) ScrlWinCheckActivatedForKeysControl(ScrolledWindow);
SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_MOUSE_EVENT:
{
SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
ScrolledWindow->ctrl_x=ScrolledWindow->ctrl_x+message->arg1;
ScrolledWindow->ctrl_y=ScrolledWindow->ctrl_y+message->arg2;
//change virtual coordinates of controls
Vscrollbar=(struct ControlScrollBar*)ScrolledWindow->vertical_scroll;
seek_control=(struct HEADER *)Vscrollbar->ctrl_fd;
for(i=0;i<ScrolledWindow->number_virtual_controls;i++)
{
ScrolledWindow->virtual_controls_x[i]+=message->arg1;
ScrolledWindow->virtual_controls_y[i]+=message->arg2;
fin=(struct FINITION*)seek_control->finition;
fin->x=ScrolledWindow->ctrl_x+1;
fin->y=ScrolledWindow->ctrl_y+1;
fin->sizex=ScrolledWindow->scroll_arrea_sizex;
fin->sizey=ScrolledWindow->scroll_arrea_sizey;
exchange_control=(struct HEADER*)seek_control->ctrl_fd;
seek_control=exchange_control;
}
SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_CALL_TIMER_EVENT:
{
if (ScrolledWindow->timer!=(DWORD*)NULL)
{
timer=(struct TIMER*)ScrolledWindow->timer;
if (timer->flags & FLAG_TIMER_ON) Timer(timer);
}
SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_SET_FOCUSE:
{
//SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_CHANGE_FOCUSE:
{
//SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_DESTROY_CONTROL:
{
if (ScrolledWindow->timer!=(DWORD*)NULL) free(ScrolledWindow->timer);
free(ScrolledWindow->finition);
SendMessage((struct HEADER*)ScrolledWindow,message);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)ScrolledWindow,message);
ScrolledWindow->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
}
//---------------------------------------------------------------------------------
// create control ScrolledWindow
//---------------------------------------------------------------------------------
void* CreateScrolledWindow(struct ScrolledWindowData *info_for_control)
{
struct ControlScrolledWindow *ScrolledWindow;
struct FINITION *fin;
struct ControlScrollBar *HorizontalScrollBar;
struct ControlScrollBar *VerticalScrollBar;
struct ScrollBarData HorizontalScrollData;
struct ScrollBarData VerticalScrollData;
ScrolledWindow=malloc(sizeof(struct ControlScrolledWindow));
ScrolledWindow->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)ScrolledWindow->finition;
fin->flags=0;
ScrolledWindow->scw_flags=0;
ID++;
#ifdef DEBUG
printf("\ncreated scrollet window with ID=%d",(int)ID);
#endif
ScrolledWindow->child_bk=(DWORD*)NULL;
ScrolledWindow->child_fd=(DWORD*)NULL;
ScrolledWindow->active_control_for_keys=(DWORD*)NULL;
ScrolledWindow->active_control_for_mouse=(DWORD*)NULL;
ScrolledWindow->callback=(DWORD*)NULL;
ScrolledWindow->timer=(DWORD*)NULL;
ScrolledWindow->ctrl_proc=(DWORD*)&ScrolledWindowProc;
ScrolledWindow->ctrl_x=(DWORD)info_for_control->x;
ScrolledWindow->ctrl_y=(DWORD)info_for_control->y;
ScrolledWindow->ctrl_sizex=(DWORD)info_for_control->width;
ScrolledWindow->ctrl_sizey=(DWORD)info_for_control->height;
ScrolledWindow->ctrl_ID=ID;
ScrolledWindow->virtual_x=0;
ScrolledWindow->virtual_y=0;
ScrolledWindow->virtual_controls_x=malloc(1024*sizeof(DWORD));
ScrolledWindow->virtual_controls_y=malloc(1024*sizeof(DWORD));
ScrolledWindow->virtual_sizex=0;
ScrolledWindow->virtual_sizey=0;
ScrolledWindow->number_virtual_controls=0;
ScrolledWindow->flags=0;
ScrolledWindow->flags=ScrolledWindow->flags | FLAG_SHOW_CONTROL;
ScrolledWindow->flags=ScrolledWindow->flags | FLAG_FOCUSE_INPUT_SUPPOROTE;
//calculate default scroll arrea size
ScrolledWindow->scroll_arrea_sizex=ScrolledWindow->ctrl_sizex-2;
ScrolledWindow->scroll_arrea_sizey=ScrolledWindow->ctrl_sizey-2;
//create child scroll bars
HorizontalScrollData.x=0;
HorizontalScrollData.y=ScrolledWindow->ctrl_sizey-16;
HorizontalScrollData.width=ScrolledWindow->ctrl_sizex-16;
HorizontalScrollData.height=16;
HorizontalScrollData.ruller_size=1.0;
HorizontalScrollData.ruller_pos=0.0;
HorizontalScrollData.ruller_step=0.05;
VerticalScrollData.x=ScrolledWindow->ctrl_sizex-16;
VerticalScrollData.y=0;
VerticalScrollData.width=16;
VerticalScrollData.height=ScrolledWindow->ctrl_sizey-16;
VerticalScrollData.ruller_size=1.0;
VerticalScrollData.ruller_pos=0.0;
VerticalScrollData.ruller_step=0.05;
HorizontalScrollBar=CreateHorizontalScrollBar(&HorizontalScrollData);
VerticalScrollBar=CreateVerticalScrollBar(&VerticalScrollData);
SetCallbackFunction(HorizontalScrollBar,SCROLLBAR_CHANGED_EVENT,&ScrollWin_FuncCallback_HScroll,ScrolledWindow);
SetCallbackFunction(VerticalScrollBar,SCROLLBAR_CHANGED_EVENT,&ScrollWin_FuncCallback_VScroll,ScrolledWindow);
PackControls(ScrolledWindow,HorizontalScrollBar);
PackControls(ScrolledWindow,VerticalScrollBar);
ScrolledWindow->horizontal_scroll=(DWORD*)HorizontalScrollBar;
ScrolledWindow->vertical_scroll=(DWORD*)VerticalScrollBar;
//disable show scrollers and block mouse for them
HorizontalScrollBar->flags=HorizontalScrollBar->flags & FLAG_HIDE_CONTROL;
HorizontalScrollBar->flags=HorizontalScrollBar->flags | FLAG_MOUSE_BLOCKED_ON;
VerticalScrollBar->flags=VerticalScrollBar->flags & FLAG_HIDE_CONTROL;
VerticalScrollBar->flags=VerticalScrollBar->flags | FLAG_MOUSE_BLOCKED_ON;
return(ScrolledWindow);
}

16
programs/develop/new libGUI_C/SRC/control_text.h Executable file
View File

@ -0,0 +1,16 @@
#define TEXT_ORIENTATION_FROM_LEFT_TO_RIGHT_ON 0x1
#define TEXT_ORIENTATION_FROM_LEFT_TO_RIGHT_OFF 0xfe
#define TEXT_BACKGROUND_ON 0x2;
#define TEXT_BACKGROUND_OFF 0xfd;
struct TextSize
{
int sizex;
int sizey;
};
typedef struct TextSize gui_text_size_t;

181
programs/develop/new libGUI_C/SRC/control_text.inc Executable file
View File

@ -0,0 +1,181 @@
/*
control Text
*/
gui_text_size_t GetStringSize(font_t *font,char *s)
{
long len;
gui_text_size_t size;
len=strlen(s);
if (font->size==FONT_CONSTANT_SIZE)
{
if (font->flags & FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON)
{
size.sizex=len*font->sizex;
size.sizey=font->sizey;
}
}
return(size);
}
void TextBackgroundOn(gui_text_t *Text)
{
Text->txt_flags |=TEXT_BACKGROUND_ON;
}
void TextBackgroundOff(gui_text_t *Text)
{
Text->txt_flags &=TEXT_BACKGROUND_ON;
}
void DisplayText(gui_text_t *Text)
{
int x;
int y;
int sizex;
int sizey;
char v;
font_t *font;
gui_text_size_t size;
struct FINITION *fin;
x=Text->ctrl_x;
y=Text->ctrl_y;
fin=(struct FINITION*)Text->finition;
font=(font_t*)Text->font;
v=Text->txt_flags & TEXT_BACKGROUND_ON;
if (v) font->flags|=FONT_FLAG_DRAW_BACKGROUND_ON;
else font->flags&=FONT_FLAG_DRAW_BACKGROUND_OFF;
v=Text->txt_flags & TEXT_ORIENTATION_FROM_LEFT_TO_RIGHT_ON;
if (v) font->flags|=FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON;
else font->flags&=FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_OFF;
size=GetStringSize((font_t*)Text->font,Text->text);
Text->ctrl_sizex=(DWORD)size.sizex;
Text->ctrl_sizey=(DWORD)size.sizey;
DrawFont=(void(*)(finition_t *fin,int fx,int fy,DWORD color,
DWORD background_color,font_t *font,BYTE *s))font->fnt_draw;
DrawFont(fin,x,y,Text->color,Text->background_color,font,Text->text);
}
//---------------------------------------------------------------------------------
// control Text
//---------------------------------------------------------------------------------
void TextProc(gui_text_t *Text,gui_message_t *message)
{
finition_t *fin;
switch(message->type)
{
case MESSAGE_FULL_REDRAW_ALL:
{
//draw Text
if (Text->flags & FLAG_SHOW_CONTROL) DisplayText(Text);
break;
}
case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION:
{
fin=(struct FINITION*)Text->finition;
fin->flags=fin->flags | FINITION_ON;
fin->x=message->arg1;
fin->y=message->arg2;
fin->sizex=message->arg3;
fin->sizey=message->arg4;
DisplayText(Text);
break;
}
case MESSAGE_SPECIALIZED:
{
if (Text->flags & FLAG_GET_SPECIALIZED_MESSAGE_ON)
{
if (Text->flags & FLAG_SHOW_CONTROL) DisplayText(Text);
Text->flags=Text->flags & FLAG_GET_SPECIALIZED_MESSAGE_OFF;
}
break;
}
case MESSAGE_CHANGE_POSITION_EVENT:
{
Text->ctrl_x=Text->ctrl_x+message->arg1;
Text->ctrl_y=Text->ctrl_y+message->arg2;
break;
}
case MESSAGE_DESTROY_CONTROL:
{
free(Text->finition);
break;
}
case MESSAGE_SET_MAIN_PARENT:
{
SendMessage((struct HEADER*)Text,message);
Text->main_parent=(DWORD*)message->arg1;
break;
}
default: break;
}
//send message to child controls(if there is)
SendMessage((struct HEADER*)Text,message);
}
//---------------------------------------------------------------------------------
// create control Text
//---------------------------------------------------------------------------------
void* CreateText(gui_text_data_t *info_for_control)
{
gui_text_t *Text;
finition_t *fin;
gui_text_size_t size;
Text=malloc(sizeof(struct ControlText));
Text->finition=malloc(sizeof(struct FINITION));
fin=(struct FINITION*)Text->finition;
fin->flags=0;
if (info_for_control->font==(DWORD*)NULL) Text->font=FontsMeneger.default_font;
else Text->font=info_for_control->font;
size=GetStringSize((font_t*)Text->font,info_for_control->text);
ID++;
#ifdef DEBUG
printf("\ncreated text with ID=%d",(int)ID);
#endif
Text->child_bk=(DWORD*)NULL;
Text->child_fd=(DWORD*)NULL;
Text->active_control_for_keys=(DWORD*)NULL;
Text->active_control_for_mouse=(DWORD*)NULL;
Text->callback=(DWORD*)NULL;
Text->timer=(DWORD*)NULL;
Text->ctrl_proc=(DWORD*)&TextProc;
Text->ctrl_x=(DWORD)info_for_control->x;
Text->ctrl_y=(DWORD)info_for_control->y;
Text->ctrl_sizex=(DWORD)size.sizex;
Text->ctrl_sizey=(DWORD)size.sizey;
Text->ctrl_ID=ID;
Text->color=info_for_control->color;
Text->background_color=info_for_control->background_color;
Text->text=info_for_control->text;
Text->txt_flags=0;
Text->txt_flags|=TEXT_ORIENTATION_FROM_LEFT_TO_RIGHT_ON;
if (info_for_control->background)
{
Text->txt_flags|=TEXT_BACKGROUND_ON;
}
else
{
Text->txt_flags&=TEXT_BACKGROUND_OFF;
}
Text->flags=0;
Text->flags=Text->flags | FLAG_SHOW_CONTROL;
return(Text);
}

31
programs/develop/new libGUI_C/SRC/draw_controls.h Executable file
View File

@ -0,0 +1,31 @@
#define FINITION_ON 0x1
#define FINITION_OFF 0xfe
#define COLOR_FON 0x924900
#define COLOR_DARK 0x5a5a5a
#define COLOR_ABSOLUTE_DARK 0x0
#define COLOR_MIDDLE_LIGHT 0xffff00
#define COLOR_LIGHT 0xffffff
#define COLOR_INSERT 0x71ff30//0xffff10
/////////////////////////////////////////////////////////////////////////////////////////
// tool's names
/////////////////////////////////////////////////////////////////////////////////////////
#define TOOL_PIXEL 128
#define TOOL_LINE 129
#define TOOL_VERTICAL_LINE 130
#define TOOL_HORIZONTAL_LINE 131
#define TOOL_RECTANGLE 132
#define TOOL_FILLED_RECTANGLE 133
#define TOOL_GRADIENT_UP_FILLED_RECTANGLE 134
#define TOOL_GRADIENT_DOWN_FILLED_RECTANGLE 135
#define TOOL_GRADIENT_LEFT_FILLED_RECTANGLE 136
#define TOOL_GRADIENT_RIGHT_FILLED_RECTANGLE 137
#define TOOL_CIRCLE 138
#define TOOL_FILLED_CIRCLE 139
#define TOOL_ELLIPSE 140
#define TOOL_FILLED_ELLIPSE 141
#define TOOL_IMAGE 142

2139
programs/develop/new libGUI_C/SRC/draw_controls.inc Executable file
View File

File diff suppressed because it is too large Load Diff

63
programs/develop/new libGUI_C/SRC/fonts_meneger.h Executable file
View File

@ -0,0 +1,63 @@
/*
font meneger header structure
*/
#define FONT_FLAG_DEFAULT_FONT_ON 0x1
#define FONT_FLAG_DEFAULT_FONT_OFF 0xfe
#define FONT_FLAG_DRAW_BACKGROUND_ON 0x2
#define FONT_FLAG_DRAW_BACKGROUND_OFF 0xfd
#define FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON 0x4
#define FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_OFF 0xfb
#define FONT_CONSTANT_SIZE -1
//some types encoding characters
#define FONT_TYPE_ASCII 0x1
#define FONT_TYPE_UNICODE 0x2
///////////////////////////////////////////////////////////
// some ASCII encodings
///////////////////////////////////////////////////////////
//cyrillic encodings
#define FONT_ENCODING_CYRILLIC_IBM866 0x1
#define FONT_ENCODING_CYRILLIC_IBM437 0x2
#define FONT_ENCODING_CYRILLIC_KOI8R 0x4
#define FONT_ENCODING_CYRILLIC_ISO8859_5 0x8
#define FONT_ENCODING_CYRILLIC_CP1251 0x10
#pragma pack(push,1)
static struct
{
DWORD *fnt_fd;
DWORD *fnt_bk;
DWORD *default_font;
DWORD number_fonts;
}FontsMeneger;
#pragma pack(pop)
#pragma pack(push,1)
struct FONT
{
DWORD *fnt_draw;
DWORD *fnt_unpacker;
DWORD *fnt_fd;
DWORD *fnt_bk;
int sizex;
int sizey;
int size;
int encoding_type;
char *font;
char *fnt_name;
DWORD type;
DWORD flags;
};
#pragma pack(pop)
typedef struct FONT font_t;
static char *default_fonts_path="/sys/fonts/";
void (*DrawFont)(finition_t *fin,int fx,int fy,DWORD color,DWORD background_color,font_t *font,BYTE *s);

373
programs/develop/new libGUI_C/SRC/fonts_meneger.inc Executable file
View File

@ -0,0 +1,373 @@
/*
menegement of fonts
*/
//---------------------------------------------------------------------------------
// destroy font
//---------------------------------------------------------------------------------
void DestroyFont(font_t *font)
{
font_t *seek_font;
font_t *exchange_font;
font_t *last_font;
font_t *next_font;
if (font==(font_t*)NULL) return;
if (FontsMeneger.fnt_bk==FontsMeneger.fnt_fd)
{
//parent have got alone font
if (FontsMeneger.fnt_bk==(DWORD*)font)
{
#ifdef DEBUG
printf("\ndestroyed font %d font name=%s",(int)font,(char*)font->fnt_name);
#endif
free(font);
FontsMeneger.fnt_bk=(DWORD*)NULL;
FontsMeneger.fnt_fd=(DWORD*)NULL;
}
return;
}
seek_font=(font_t*)FontsMeneger.fnt_bk;
while(seek_font!=(font_t*)NULL)
{
if (seek_font==font)
{
//delete font from fonts's cash
last_font=(font_t*)seek_font->fnt_bk;
next_font=(font_t*)seek_font->fnt_fd;
if ((last_font!=(font_t*)NULL) && (next_font!=(font_t*)NULL))
{//deliting font isn't first font and isn't endest
next_font->fnt_bk=(DWORD*)last_font;
last_font->fnt_fd=(DWORD*)next_font;
}
else
{
if (last_font==(font_t*)NULL)
{//deliting font is first font of Parend
FontsMeneger.fnt_bk=(DWORD*)next_font;
next_font->fnt_bk=(DWORD*)NULL;
if (next_font->fnt_fd==(DWORD*)NULL)
{
FontsMeneger.fnt_fd=(DWORD*)next_font;
FontsMeneger.fnt_bk=(DWORD*)next_font;
}
}
if (next_font==(font_t*)NULL)
{
//there isn't next fonts
last_font->fnt_fd=(DWORD*)NULL;
FontsMeneger.fnt_fd=(DWORD*)last_font;
}
}
#ifdef DEBUG
printf("\ndestroyed font %d font name=%s",(int)font,(char*)font->fnt_name);
#endif
free(font);
break;
}
exchange_font=(font_t*)seek_font->fnt_fd;
seek_font=exchange_font;
}
}
void *CreateFont(void)
{
font_t *font;
font_t *backward_font;
font=malloc(sizeof(struct FONT));
if (FontsMeneger.fnt_bk==(DWORD*)NULL)
{//not yet fonts
FontsMeneger.fnt_bk=(DWORD*)font;
FontsMeneger.fnt_fd=(DWORD*)font;
font->fnt_bk=(DWORD*)NULL;
font->fnt_fd=(DWORD*)NULL;
}
else
{
backward_font=(font_t*)FontsMeneger.fnt_fd;
FontsMeneger.fnt_fd=(DWORD*)font;
backward_font->fnt_fd=(DWORD*)font;
font->fnt_bk=(DWORD*)backward_font;
font->fnt_fd=(DWORD*)NULL;
}
return(font);
}
////////////////////////////////////////////////////////////////////////////////
// CHAR.MT and CHAR2.MT fonts unpacker
////////////////////////////////////////////////////////////////////////////////
void CHAR_MT_FontsUnpacker(unsigned char *loaded_font,font_t *font,char font_type)
{
int i,j,k;
unsigned char c;
unsigned char *p;
if (font_type==FALSE)
{//CHAR.MT
font->font=malloc(6*9*256);
p=(unsigned char*)font->font;
for(j=0;j<256;j++)
{
for(i=0;i<9;i++)
{
c=(unsigned char)(*loaded_font);
p[5]=(unsigned char)(c & 0x20);
p[4]=(unsigned char)(c & 0x10);
p[3]=(unsigned char)(c & 0x8);
p[2]=(unsigned char)(c & 0x4);
p[1]=(unsigned char)(c & 0x2);
p[0]=(unsigned char)(c & 0x1);
p+=6;
loaded_font++;
}
}
font->sizex=6;
font->sizey=9;
}
else
{//CHAR2.MT
font->font=malloc(8*10*256);
p=(unsigned char*)font->font;
for(j=0;j<256;j++)
{
for(i=0;i<10;i++)
{
c=(unsigned char)(*loaded_font);
p[7]=(unsigned char)(c & 0x80);
p[6]=(unsigned char)(c & 0x40);
p[5]=(unsigned char)(c & 0x20);
p[4]=(unsigned char)(c & 0x10);
p[3]=(unsigned char)(c & 0x8);
p[2]=(unsigned char)(c & 0x4);
p[1]=(unsigned char)(c & 0x2);
p[0]=(unsigned char)(c & 0x1);
p+=8;
loaded_font++;
}
}
font->sizex=8;
font->sizey=10;
}
font->size=FONT_CONSTANT_SIZE;
font->type=FONT_TYPE_ASCII;
font->encoding_type=FONT_ENCODING_CYRILLIC_IBM866;
}
////////////////////////////////////////////////////////////////////////////////
// CHAR.MT and CHAR2.MT fonts draw
////////////////////////////////////////////////////////////////////////////////
void MonofontDraw(finition_t *fin,int fx,int fy,
DWORD color,DWORD background_color,
font_t *font,unsigned char *s)
{
unsigned int i,j,k,step,len;
int x,y,size_x,save_size_x,save_size_y;
unsigned char *p,*buf,*save_buf;
unsigned char c,draw_output;
step=font->sizex*font->sizey;
len=strlen(s);
if (font->flags & FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON)
{
if (font->flags & FONT_FLAG_DRAW_BACKGROUND_ON)
{//there is a fon and not finition for draw
//alocate a buffer for draw text
size_x=font->sizex*len;
c=screen.bits_per_pixel >> 3;
i=step*c*len;
buf=malloc(i);
//save current screen parameters
save_buf=screen.buffer;
save_size_x=screen.size_x;
save_size_y=screen.size_y;
draw_output=screen.draw_output;
//load parameters of local buffer
screen.buffer=buf;
screen.size_x=size_x;
screen.size_y=font->sizey;
screen.draw_output=DRAW_OUTPUT_BUFFER;
//fill buffer by background color
FillArrea(buf,i,screen.bits_per_pixel,background_color);
//draw text
x=0;
for(k=0;k<len;k++)
{
c=s[k];
p=font->font+step*c;
for(j=0;j<font->sizey;j++)
{
for(i=0;i<font->sizex;i++)
{
if (*p) DrawPixel(x+i,j,color);
p++;
}
}
x=x+font->sizex;
}
//restore screen parameters
screen.buffer=save_buf;
screen.size_x=save_size_x;
screen.size_y=save_size_y;
screen.draw_output=draw_output;
//move text from local buffer to screen
if (fin->flags & FINITION_ON)
DrawImageFinit(fin,fx,fy,size_x,font->sizey,screen.bits_per_pixel,buf);
else
DrawImage(fx,fy,size_x,font->sizey,screen.bits_per_pixel,buf);
//free local buffer
free(buf);
}
else
{
if (fin->flags & FINITION_ON)
{//not background and finition for draw
x=fx;
y=fy;
for(k=0;k<len;k++)
{
c=s[k];
p=font->font+step*c;
for(j=0;j<font->sizey;j++)
{
for(i=0;i<font->sizex;i++)
{
if (*p) DrawPixelFinit(fin,x+i,y+j,color);
p++;
}
}
x=x+font->sizex;
}
}
else
{//not background and not finition for draw
x=fx;
y=fy;
for(k=0;k<len;k++)
{
c=s[k];
p=font->font+step*c;
for(j=0;j<font->sizey;j++)
{
for(i=0;i<font->sizex;i++)
{
if (*p) DrawPixel(x+i,y+j,color);
p++;
}
}
x=x+font->sizex;
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
// fonts loader
////////////////////////////////////////////////////////////////////////////////
font_t *LoadFont(char *fullfontname)
{
char *path;
char *c;
BYTE *buf;
long filesize;
int len1,len2,i;
font_t *font;
static DWORD buf_for_size[2];
static DWORD buf_for_pos[2];
path=malloc(263);
if (strchr(fullfontname,'/')==NULL)
{
len1=strlen(default_fonts_path);
len2=strlen(fullfontname);
memmove(path,default_fonts_path,len1);
memmove(path+len1,fullfontname,len2);
*(path+len1+len2)='\0';
}
else
memmove(path,fullfontname,strlen(fullfontname));
if (gui_get_file_size(path,buf_for_size)==KOLIBRIOS_SYS_FILE_ACCESS_SUCCESSFULLY)
{
filesize=buf_for_size[0];
buf=malloc(filesize);
//load fonts in buffer
gui_read_file(path,buf_for_pos,filesize,buf);
free(path);
//register font
font=CreateFont();
c=strrchr(fullfontname,'/');
if(c==NULL) font->fnt_name=fullfontname;
else
font->fnt_name=(char*)(c+1);
//check font type
c=strstr(font->fnt_name,"CHAR.MT");//check standart type of fonts
if (c!=NULL)
{
font->fnt_unpacker=(DWORD*)&CHAR_MT_FontsUnpacker;
font->fnt_draw=(DWORD*)&MonofontDraw;
CHAR_MT_FontsUnpacker(buf,font,FALSE);//CHAR.MT
free(buf);
font->flags=0;
font->flags|=FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON;
}
c=strstr(font->fnt_name,"CHAR2.MT");//check standart type of fonts
if (c!=NULL)
{
font->fnt_unpacker=(DWORD*)&CHAR_MT_FontsUnpacker;
font->fnt_draw=(DWORD*)&MonofontDraw;
CHAR_MT_FontsUnpacker(buf,font,TRUE);//CHAR2.MT
free(buf);
font->flags=0;
font->flags|=FONT_FLAG_ORIENTATION_HORIZONTAL_FROM_LEFT_TO_RIGHT_ON;
}
//not other fonts yet
}
else
{
#ifdef DEBUG
printf("\ncannot load font %s",path);
#endif
free(path);
return(NULL);
}
FontsMeneger.number_fonts++;
return(font);
}
void FreeFont(font_t *font)
{
if (font==(font_t*)FontsMeneger.default_font) return;
free(font->font);
DestroyFont(font);
}

8
programs/develop/new libGUI_C/SRC/keys.h Executable file
View File

@ -0,0 +1,8 @@
/*
scan codes of keys
*/
//Scan Codes of some keys in pressed state
#define SC_TAB 15
#define SC_ENTER 28
#define SC_SPACE 57

657
programs/develop/new libGUI_C/SRC/kolibri_system.h Executable file
View File

@ -0,0 +1,657 @@
/*
some system function of KolibriOS
*/
#define KOLIBRIOS_SYS_EVENT_REDRAW 1
#define KOLIBRIOS_SYS_EVENT_KEYS 2
#define KOLIBRIOS_SYS_EVENT_BUTTON_PRESSED 3
#define KOLIBRIOS_SYS_EVENT_REDRAW_BACKGROUND 5
#define KOLIBRIOS_SYS_EVENT_MOUSE 6
#define KOLIBRIOS_SYS_EVENT_IPC 7
#define KOLIBRIOS_SYS_EVENT_NET 8
#define KOLIBRIOS_SYS_EVENT_DEBUG 9
#define KOLIBRIOS_SYS_MOUSE_BUTTON_LEFT_DOWN 0x1
#define KOLIBRIOS_SYS_MOUSE_BUTTON_RIGHT_DOWN (0x1<<1)
#define KOLIBRIOS_SYS_MOUSE_BUTTON_MIDDLE_DOWN (0x1 <<2)
#define KOLIBRIOS_SYS_MOUSE_BUTTON_4_DOWN (0x1 <<3)
#define KOLIBRIOS_SYS_MOUSE_BUTTON_5_DOWN (0x1 <<4)
#define KOLIBRIOS_SYS_FILE_ACCESS_SUCCESSFULLY 0
#define KOLIBRIOS_SYS_FILE_UNDEFINED_PARTITION_OR_HARDDRIVE_BASE 1
#define KOLIBRIOS_SYS_FILE_FUNCTION_DONT_SUPPOROTE_FOR_CURRENT_FILE_SYSTEM 2
#define KOLIBRIOS_SYS_FILE_UNKNOWN_FILE_SYSTEM 3
#define KOLIBRIOS_SYS_FILE_NOT_FOUND 5
#define KOLIBRIOS_SYS_FILE_FINISHED 6
#define KOLIBRIOS_SYS_FILE_POINTER_OUTOFMEMORY_APPLICATION 7
#define KOLIBRIOS_SYS_FILE_MEMORY_OF_DEVICE_FILLED 8
#define KOLIBRIOS_SYS_FILE_TABLE_DESTROYED 9
#define KOLIBRIOS_SYS_FILE_ACCESS_DENITED 10
#define KOLIBRIOS_SYS_FILE_DEVICE_ERROR 11
#pragma pack(push,1)
struct KOLIBRIOS_FILEIO
{
DWORD number_subfunction;
DWORD offset_in_file_low;
DWORD offset_in_file_hight;
DWORD size;
DWORD *data;
BYTE null;
char *full_file_path;
};
#pragma pack(pop)
typedef struct KOLIBRIOS_FILEIO fileio_t;
#pragma pack(push,1)
struct BLOCK_DATA_ENTRY_DIRECTORY
{
DWORD attributes;
DWORD types_data_of_name;
DWORD time_created_file;
DWORD date_created_file;
DWORD time_last_access;
DWORD date_last_access;
DWORD time_last_modification;
DWORD date_last_modification;
DWORD file_size_low;
DWORD file_size_hight;
DWORD *filename;
};
#pragma pack(pop)
typedef struct BLOCK_DATA_ENTRY_DIRECTORY bded_t;
#pragma pack(push,1)
struct PROCESS_TABLE
{
int cpu_usage; //+0
int window_pos_info; //+4
short int reserved1; //+8
char name[12]; //+10
int memstart; //+22
int memused; //+26
int pid; //+30
int winx_start; //+34
int winy_start; //+38
int winx_size; //+42
int winy_size; //+46
short int slot_info; //+50
short int reserved2; //+52
int clientx; //+54
int clienty; //+58
int clientwidth; //+62
int clientheight; //+66
unsigned char window_state; //+70
char reserved3[1024-71]; //+71
};
#pragma pack(pop)
typedef struct PROCESS_TABLE process_table_t;
#pragma pack(push,1)
struct IMPORT
{
char *name;
void *data;
};
#pragma pack(pop)
typedef struct IMPORT import_t;
static DWORD gui_get_file_size(char *filename,DWORD *buf_for_size);
static DWORD gui_read_file(char *filename,DWORD *buf_pos_size,DWORD size_read,char *buf);
static DWORD gui_create_rewrite_file(char *filename,DWORD *buf_pos_size,DWORD size_write,char *buf);
static DWORD gui_append_to_file(char *filename,DWORD *buf_pos_size,DWORD size_write,char *buf);
static void gui_debug_out_str(char *s);
static void* gui_cofflib_getproc(import_t *lib, char *name);
#define alwinline __attribute__((always_inline))
//------------------------------------------------------------------------------------------
// draw window
//------------------------------------------------------------------------------------------
extern inline void __attribute__((always_inline)) gui_ksys_draw_window(DWORD x,DWORD y,DWORD sizex,DWORD sizey,DWORD flags)
{
__asm__ __volatile__(
"xorl %%eax,%%eax\n\t"
"movl %0,%%ebx\n\t"
"movl %1,%%ecx\n\t"
"movl %4,%%edx\n\t"
"shll $16,%%ebx\n\t"
"shll $16,%%ecx\n\t"
"addl %2,%%ebx\n\t"
"addl %3,%%ecx\n\t"
"int $0x40"
:/*no output*/
:"g"(x),"g"(y),"g"(sizex),"g"(sizey),"g"(flags)
:"eax","ebx","ecx","edx");
}
//------------------------------------------------------------------------------------------
// begin redraw window
//------------------------------------------------------------------------------------------
extern inline void __attribute__((always_inline)) gui_ksys_begin_draw_window(void)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(12),"b"(1));
}
//------------------------------------------------------------------------------------------
// finish redraw window
//------------------------------------------------------------------------------------------
extern inline void __attribute__((always_inline)) gui_ksys_finish_draw_window(void)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(12),"b"(2));
}
//------------------------------------------------------------------------------------------
// set new position and new size of window
//------------------------------------------------------------------------------------------
extern inline void alwinline gui_ksys_set_position_and_size_window(DWORD new_x,
DWORD new_y,DWORD new_sizex,DWORD new_sizey)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(67),"b"(new_x),"c"(new_y),"d"(new_sizex),"S"(new_sizey));
}
//------------------------------------------------------------------------------------------
// set title of window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_set_title_window(char *title)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(71),"b"(1),"c"(title));
}
//------------------------------------------------------------------------------------------
// delete title of window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_delete_title_window(void)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(71),"b"(1),"c"(0));
}
//------------------------------------------------------------------------------------------
// get information about current process
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_current_process_information(void *mem)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(9),"b"(mem),"c"(-1));
return(value);
}
//------------------------------------------------------------------------------------------
// delete title of window
//------------------------------------------------------------------------------------------
extern inline int __attribute__((always_inline)) gui_ksys_get_skin_height(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(48),"b"(4));
return(value);
}
//------------------------------------------------------------------------------------------
// get pressed key
//------------------------------------------------------------------------------------------
extern inline int __attribute__((always_inline)) gui_ksys_get_key(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(2));
return(value);
}
//------------------------------------------------------------------------------------------
// set keyboard input mode
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_set_keyboard_input_mode(int mode)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(66),"b"(1),"c"(mode));
}
//------------------------------------------------------------------------------------------
// get keyboard input mode
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_keyboard_input_mode(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(66),"b"(2));
return(value);
}
//------------------------------------------------------------------------------------------
// get state of menegers keys
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_state_menegers_keys(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(66),"b"(3));
return(value);
}
//------------------------------------------------------------------------------------------
// set events mask
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_set_events_mask(DWORD mask)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(40),"b"(mask));
}
//------------------------------------------------------------------------------------------
// wait event
//------------------------------------------------------------------------------------------
extern inline int __attribute__((always_inline)) gui_ksys_wait_event(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(10));
return(value);
}
//------------------------------------------------------------------------------------------
// check for event
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_check_event(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(11));
return(value);
}
//------------------------------------------------------------------------------------------
// wait event
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_wait_event_with_timeout(DWORD timeout)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(23),"b"(timeout));
return(value);
}
//------------------------------------------------------------------------------------------
// get code of pressed button
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_code_pressed_button(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(17));
return(value);
}
//------------------------------------------------------------------------------------------
// get window mouse coordinates
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_window_mouse_coordinates(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(37),"b"(1));
return(value);
}
//------------------------------------------------------------------------------------------
// get screen mouse coordinates
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_screen_mouse_coordinates(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(37),"b"(0));
return(value);
}
//------------------------------------------------------------------------------------------
// get mouse buttons state
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_mouse_buttons_state(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(37),"b"(2));
return(value);
}
//------------------------------------------------------------------------------------------
// get mouse ruler state
//------------------------------------------------------------------------------------------
extern inline int gui_ksys_get_mouse_ruler_state(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(37),"b"(7));
return(value);
}
//------------------------------------------------------------------------------------------
// put pixel in window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_put_pixel_window(int x,int y,DWORD color)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(1),"b"(x),"c"(y),"d"(color));
}
//------------------------------------------------------------------------------------------
// put image in window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_put_image_window(char *p,int x,int y,int sizex,int sizey)
{
__asm__ __volatile__(
"shll $16,%%ecx\n\t"
"shll $16,%%edx\n\t"
"addl %%esi,%%ecx\n\t"
"addl %%edi,%%edx\n\t"
"int $0x40"
:/*no output*/
:"a"(7),"b"(p),"c"(sizex),"d"(x),"S"(sizey),"D"(y));
}
//------------------------------------------------------------------------------------------
// draw filled rectangle in window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_draw_filled_rectangle_window(int x,int y,int sizex,int sizey,DWORD color)
{
__asm__ __volatile__(
"shll $16,%%ebx\n\t"
"shll $16,%%ecx\n\t"
"addl %%esi,%%ebx\n\t"
"addl %%edi,%%ecx\n\t"
"int $0x40"
:/*no output*/
:"a"(13),"b"(x),"c"(y),"d"(color),"S"(sizex),"D"(sizey));
}
//------------------------------------------------------------------------------------------
// get screen size
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_get_screen_size(void)
{
DWORD value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(14));
return(value);
}
//------------------------------------------------------------------------------------------
// get color of pixel in coordinates (x,y)
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_get_color_pixel_window(DWORD coordinates)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(35),"b"(coordinates));
return(value);
}
//------------------------------------------------------------------------------------------
// get bits per pixel on the screen
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_get_screen_bits_per_pixel(void)
{
int value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(61),"b"(2));
return(value);
}
//------------------------------------------------------------------------------------------
// draw line in window
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_draw_line_window(int x1,int y1,int x2,int y2,DWORD color)
{
__asm__ __volatile__(
"shll $16,%%ebx\n\t"
"shll $16,%%ecx\n\t"
"addl %%esi,%%ebx\n\t"
"addl %%edi,%%ecx\n\t"
"int $0x40"
:/*no output*/
:"a"(38),"b"(x1),"c"(y1),"d"(color),"S"(x2),"D"(y2));
}
//------------------------------------------------------------------------------------------
// get standart colors table
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_get_standart_colors_table(char *buf)
{
__asm__ __volatile__(
"int $0x40"
:/*no output*/
:"a"(48),"b"(3),"c"(buf),"d"(40));
}
//------------------------------------------------------------------------------------------
// get time from start system to current in 1/100 sec.
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_get_ticks(void)
{
DWORD value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(26),"b"(9));
return(value);
}
//------------------------------------------------------------------------------------------
// initialize heap of memory
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_init_user_heap(void)
{
DWORD value;
__asm__ __volatile__(
"int $0x40"
:"=a"(value)
:"a"(68),"b"(11));
return(value);
}
//------------------------------------------------------------------------------------------
// alloctae size bytes of user memory
//------------------------------------------------------------------------------------------
extern inline void* gui_ksys_malloc(DWORD size)
{
void *value;
__asm__ __volatile__(
"int $0x40" :"=a"(value)
:"a"(68),"b"(12),"c"(size)
:"memory");
return(value);
}
//------------------------------------------------------------------------------------------
// free pointer of memory
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_free(void *mem)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(68),"b"(13),"c"(mem)
:"memory");
}
//------------------------------------------------------------------------------------------
// reallocate of memory
//------------------------------------------------------------------------------------------
extern inline void* gui_ksys_realloc(DWORD new_size,void *old_mem)
{
void *new_mem;
__asm__ __volatile__(
"int $0x40"
:"=a"(new_mem)
:"a"(68),"b"(20),"c"(new_size),"d"(old_mem)
:"memory");
return(new_mem);
}
//------------------------------------------------------------------------------------------
// load user mode DLL
//------------------------------------------------------------------------------------------
extern inline void* gui_ksys_load_dll(char *path)
{
void *dll_export;
__asm__ __volatile__(
"int $0x40"
:"=a"(dll_export)
:"a"(68),"b"(19),"c"(path));
return(dll_export);
}
//------------------------------------------------------------------------------------------
// create thred
//------------------------------------------------------------------------------------------
extern inline void* gui_ksys_create_thread(DWORD *thread_eip,DWORD *thread_esp)
{
void *thread_TID;
__asm__ __volatile__(
"int $0x40"
:"=a"(thread_TID)
:"a"(51),"b"(1),"c"(thread_eip),"d"(thread_esp)
:"memory");
return(thread_TID);
}
//------------------------------------------------------------------------------------------
// acces to files input output
//------------------------------------------------------------------------------------------
extern inline DWORD gui_ksys_files_io(fileio_t *f,DWORD value)
{
DWORD err_status;
__asm__ __volatile__(
"int $0x40"
:"=a"(err_status),"=b"(value)
:"a"(70),"b"(f));
return(err_status);
}
//------------------------------------------------------------------------------------------
// debug board output
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_debug_out(int c)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(63),"b"(1),"c"(c));
}
//------------------------------------------------------------------------------------------
// KolibriOS system exit program
//------------------------------------------------------------------------------------------
extern inline void gui_ksys_exit(int value)
{
__asm__ __volatile__(
"int $0x40"
:
:"a"(-1),"b"(value));
}

67
programs/develop/new libGUI_C/SRC/kolibri_system.inc Executable file
View File

@ -0,0 +1,67 @@
/*
some system function of KolibriOS and founded of them functions
*/
static DWORD gui_get_file_size(char *filename,DWORD *buf_for_size)
{
static char buf[44];
static fileio_t f;
bded_t *bded;
DWORD status,value;
f.number_subfunction=5;
f.data=(DWORD*)buf;
f.full_file_path=filename;
status=gui_ksys_files_io(&f,value);
if (status==KOLIBRIOS_SYS_FILE_ACCESS_SUCCESSFULLY)
{
bded=(bded_t*)buf;
*buf_for_size=bded->file_size_low;
buf_for_size++;
*buf_for_size=bded->file_size_hight;
}
return(status);
}
static DWORD gui_read_file(char *filename,DWORD *buf_pos_size,DWORD size_read,char *buf)
{
static fileio_t f;
DWORD status,value;
f.number_subfunction=0;
f.offset_in_file_low=(DWORD)*buf_pos_size;buf_pos_size++;
f.offset_in_file_hight=(DWORD)*buf_pos_size;
f.size=size_read;
f.data=(DWORD*)buf;
f.full_file_path=filename;
status=gui_ksys_files_io(&f,value);
return(status);
}
static void gui_debug_out_str(char *s)
{
while(*s)
{
if (*s=='\n') gui_ksys_debug_out(13);
gui_ksys_debug_out(*s);
s++;
}
}
static void* gui_cofflib_getproc(import_t *lib, char *name)
{
int i;
for(i = 0; lib[i].name && strcmp(name, lib[i].name); i++);
if(lib[i].name) return lib[i].data;
else return NULL;
}

167
programs/develop/new libGUI_C/SRC/libGUI.c Executable file
View File

@ -0,0 +1,167 @@
/*
libGUI dinamic library
(c) andrew_programmer 2009
*/
//service libGUI types of data,functions and constants
#include "types.h"
#include "libGUI.h"
#include "kolibri_system.h"
#include "draw_controls.h"
#include "fonts_meneger.h"
#include "keys.h"
//controls
#include "control_button.h"
#include "control_image.h"
#include "control_progress_bar.h"
#include "control_scroll_bar.h"
#include "control_scrolled_window.h"
#include "control_text.h"
//some libC functions
#include "stdarg.h"
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include "stdio.inc"
#include "string.inc"
#include "stdlib.inc"
#include "kolibri_system.inc"
#include "draw_controls.inc"
#include "fonts_meneger.inc"
#include "libGUI_menegement.inc"
#include "parent_window.inc"
#include "main_libGUI.inc"
#include "control_text.inc"
#include "control_image.inc"
#include "control_button.inc"
#include "control_progress_bar.inc"
#include "control_scroll_bar.inc"
#include "control_scrolled_window.inc"
typedef struct
{
char *name;
void *function;
}export_t;
//char szSTART[] = "START";
char szLibGUIversion[] = "LibGUIversion";
char szInitLibGUI[] = "InitLibGUI";
char szLibGUImain[] = "LibGUImain";
char szQuitLibGUI[] = "QuitLibGUI";
char szCreateWindow[] = "CreateWindow";
char szSetWindowSizeRequest[] = "SetWindowSizeRequest";
char szPackControls[] = "PackControls";
char szDestroyControl[] = "DestroyControl";
char szSetControlSizeRequest[] = "SetControlSizeRequest";
char szGetControlSizeX[] = "GetControlSizeX";
char szGetControlSizeY[] = "GetControlSizeY";
char szSetControlNewPosition[] = "SetControlNewPosition";
char szGetControlPositionX[] = "GetControlPositionX";
char szGetControlPositionY[] = "GetControlPositionY";
char szSetFocuse[] = "SetFocuse";
char szRedrawControl[] = "RedrawControl";
char szSpecialRedrawControl[] = "SpecialRedrawControl";
char szSetCallbackFunction[] = "SetCallbackFunction";
char szBlockCallbackFunction[] = "BlockCallbackFunction";
char szUnblockCallbackFunction[] = "UnblockCallbackFunction";
char szSetIDL_Function[] = "SetIDL_Function";
char szDestroyIDL_Function[] = "DestroyIDL_Function";
char szSetTimerCallbackForFunction[] = "SetTimerCallbackForFunction";
char szDestroyTimerCallbackForFunction[] = "DestroyTimerCallbackForFunction";
char szSetCallbackFunctionForEvent[] = "SetCallbackFunctionForEvent";
char szDestroyCallbackFunctionForEvent[] = "DestroyCallbackFunctionForEvent";
char szCreateButton[] = "CreateButton";
char szCreateButtonWithText[] = "CreateButtonWithText";
char szCreateProgressBar[] = "CreateProgressBar";
char szSetProgressBarPulse[] = "SetProgressBarPulse";
char szProgressBarSetText[] = "ProgressBarSetText";
char szProgressBarGetText[] = "ProgressBarGetText";
char szCreateHorizontalScrollBar[] = "CreateHorizontalScrollBar";
char szCreateVerticalScrollBar[] = "CreateVerticalScrollBar";
char szCreateScrolledWindow[] = "CreateScrolledWindow";
char szScrolledWindowPackControls[] = "ScrolledWindowPackControls";
char szCreateImage[] = "CreateImage";
char szCreateText[] = "CreateText";
char szTextBackgroundOn[] = "TextBackgroundOn";
char szTextBackgroundOff[] = "TextBackgroundOff";
char szLoadFont[] = "LoadFont";
char szFreeFont[] = "FreeFont";
export_t EXPORTS[]__asm__("EXPORTS") =
{
{szLibGUIversion, LibGUIversion },
{szInitLibGUI, InitLibGUI },
{szLibGUImain, LibGUImain },
{szQuitLibGUI, QuitLibGUI },
{szCreateWindow, CreateWindow },
{szSetWindowSizeRequest, SetWindowSizeRequest },
{szPackControls, PackControls },
{szDestroyControl, DestroyControl },
{szSetControlSizeRequest, SetControlSizeRequest },
{szGetControlSizeX, GetControlSizeX },
{szGetControlSizeY, GetControlSizeY },
{szSetControlNewPosition, SetControlNewPosition },
{szGetControlPositionX, GetControlPositionX },
{szGetControlPositionY, GetControlPositionY },
{szSetFocuse, SetFocuse },
{szRedrawControl, RedrawControl },
{szSpecialRedrawControl, SpecialRedrawControl },
{szSetCallbackFunction, SetCallbackFunction },
{szBlockCallbackFunction, BlockCallbackFunction },
{szUnblockCallbackFunction, UnblockCallbackFunction },
{szSetIDL_Function, SetIDL_Function },
{szDestroyIDL_Function, DestroyIDL_Function },
{szSetTimerCallbackForFunction, SetTimerCallbackForFunction },
{szDestroyTimerCallbackForFunction, DestroyTimerCallbackForFunction },
{szSetCallbackFunctionForEvent, SetCallbackFunctionForEvent },
{szDestroyCallbackFunctionForEvent, DestroyCallbackFunctionForEvent },
{szCreateButton, CreateButton },
{szCreateButtonWithText, CreateButtonWithText },
{szCreateProgressBar, CreateProgressBar },
{szSetProgressBarPulse, SetProgressBarPulse },
{szProgressBarSetText, ProgressBarSetText },
{szProgressBarGetText, ProgressBarGetText },
{szCreateHorizontalScrollBar, CreateHorizontalScrollBar },
{szCreateVerticalScrollBar, CreateVerticalScrollBar },
{szCreateScrolledWindow, CreateScrolledWindow },
{szScrolledWindowPackControls, ScrolledWindowPackControls },
{szCreateImage, CreateImage },
{szCreateText, CreateText },
{szTextBackgroundOn, TextBackgroundOn },
{szTextBackgroundOff, TextBackgroundOff },
{szLoadFont, LoadFont },
{szFreeFont, FreeFont },
{NULL,NULL},
};

580
programs/develop/new libGUI_C/SRC/libGUI.h Executable file
View File

@ -0,0 +1,580 @@
/*
service structures of libGUI
*/
DWORD ID;
//screen's parameters
#define BYTES_PER_PIXEL 4
//platform parameters
#define KOLIBRIOS 1
//#define DEBUG
//boolean constants
#define TRUE 0x1
#define FALSE 0x0
//maximum callbacks for one check of callback
#define MAX_CALLBACKS 255
/////////////////////////////////////////////////////////////////////////
// libGUI sysyem messages types
/////////////////////////////////////////////////////////////////////////
#define MESSAGE_FULL_REDRAW_ALL 1
#define MESSAGE_KEYS_EVENT 2
#define MESSAGE_SPECIALIZED 3
#define MESSAGE_SET_FOCUSE 4
#define MESSAGE_CHANGE_FOCUSE 5
#define MESSAGE_MOUSE_EVENT 6
#define MESSAGE_CHANGE_POSITION_EVENT 7
#define MESSAGE_CHANGESIZE_EVENT 8
#define MESSAGE_CALL_TIMER_EVENT 9
#define MESSAGE_FULL_REDRAW_ALL_WITH_FINITION 10
#define MESSAGE_SET_MAIN_PARENT 11
#define MESSAGE_DESTROY_CONTROL -1
/////////////////////////////////////////////////////////////////////////
// system flags of controls
/////////////////////////////////////////////////////////////////////////
#define FLAG_SHOW_CONTROL 0x1
#define FLAG_HIDE_CONTROL 0xfffe
#define FLAG_FOCUSE_INPUT_SUPPOROTE 0x2
#define FLAG_FOCUSE_INPUT_NOTSUPPOROTE 0xfffd
#define FLAG_FOCUSE_INPUT_ON 0x4
#define FLAG_FOCUSE_INPUT_OFF 0xfffb
#define FLAG_CONNECT_EVENT_ON 0x8
#define FLAG_CONNECT_EVENT_OFF 0xfff7
#define FLAG_MOUSE_BLOCKED_ON 0x10
#define FLAG_MOUSE_BLOCKED_OFF 0xffef
#define FLAG_GET_SPECIALIZED_MESSAGE_ON 0x20
#define FLAG_GET_SPECIALIZED_MESSAGE_OFF 0xffdf
/////////////////////////////////////////////////////////////////////////
// system flags of callback functions
/////////////////////////////////////////////////////////////////////////
#define FLAG_BLOCK_CALLBACK_ON 0x1
#define FLAG_BLOCK_CALLBACK_OFF 0xfe
/////////////////////////////////////////////////////////////////////////
// system flags of main wondow for timers
/////////////////////////////////////////////////////////////////////////
#define FLAG_TIMER_ON 0x1
#define FLAG_TIMER_OFF 0xfe
/////////////////////////////////////////////////////////////////////////
// system keys states
/////////////////////////////////////////////////////////////////////////
#define KEY_DOWN 16
#define KEY_UP 17
#define KEY_HOTKEY 18
/////////////////////////////////////////////////////////////////////////
// system mouse buttons states
/////////////////////////////////////////////////////////////////////////
#define MOUSE_LEFT_BUTTON_DOWN 19
#define MOUSE_LEFT_BUTTON_UP 20
#define MOUSE_RIGHT_BUTTON_DOWN 21
#define MOUSE_RIGHT_BUTTON_UP 22
#define MOUSE_MIDDLE_BUTTON_DOWN 23
#define MOUSE_MIDDLE_BUTTON_UP 24
#define MOUSE_4_BUTTON_DOWN 25
#define MOUSE_4_BUTTON_UP 26
#define MOUSE_5_BUTTON_DOWN 27
#define MOUSE_5_BUTTON_UP 28
/////////////////////////////////////////////////////////////////
// CONNECT EVENTS FOR CALLBACKs
/////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////
// connect events for button
////////////////////////////////////////////////////////////////
#define BUTTON_ENTER_EVENT 29
#define BUTTON_LEAVE_EVENT 30
#define BUTTON_PRESSED_EVENT 31
#define BUTTON_RELEASED_EVENT 32
////////////////////////////////////////////////////////////////
// connect events for button
////////////////////////////////////////////////////////////////
#define SCROLLBAR_CHANGED_EVENT 33
////////////////////////////////////////////////////////////////
// connect events for main parent window
////////////////////////////////////////////////////////////////
#define DELETE_EVENT 36
////////////////////////////////////////////////////////////////////
//screen buffer parameters
////////////////////////////////////////////////////////////////////
#define DRAW_OUTPUT_SCREEN 0
#define DRAW_OUTPUT_BUFFER 1
static struct
{
char *buffer;
char bits_per_pixel;
char bytes_per_pixel;
char draw_output;
int x;
int y;
int size_x;
int size_y;
int skin_height;
int display_size_x;
int display_size_y;
}screen;
////////////////////////////////////////////////////////////////
// header of parent of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct HEADERPARENT
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD **control_for_callback_function;
DWORD **callback_for_control_callback;
DWORD number_callbacks;
DWORD *global_active_control_for_keys;
DWORD *message;
DWORD *timer_bk;
DWORD *timer_fd;
DWORD number_timers_for_controls;
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *IDL_func;
DWORD *IDL_func_data;
};
#pragma pack(pop)
typedef struct HEADERPARENT parent_t;
////////////////////////////////////////////////////////////////
// header of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct HEADER
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
};
#pragma pack(pop)
typedef struct HEADER header_t;
////////////////////////////////////////////////////////////////
// callback structure for callback function of control
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct CALLBACK
{
DWORD *clb_bk;
DWORD *clb_fd;
DWORD *clb_control;
DWORD *func;
DWORD *func_data;
DWORD connect_event;
DWORD flags;
};
#pragma pack(pop)
typedef struct CALLBACK gui_callback_t;
////////////////////////////////////////////////////////////////
// timer
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct TIMER
{
DWORD *tmr_bk;
DWORD *tmr_fd;
DWORD *tmr_parent;
DWORD *func;
DWORD *func_data;
DWORD last_time;
DWORD time_tick;
DWORD flags;
};
#pragma pack(pop)
typedef struct TIMER gui_timer_t;
////////////////////////////////////////////////////////////////
// structure for callback events
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct CALLBACKEVENT
{
DWORD *calev_bk;
DWORD *calev_fd;
DWORD *calev_parent;
DWORD *func;
DWORD *func_data;
DWORD event_type;
};
#pragma pack(pop)
typedef struct CALLBACKEVENT gui_callbackevent_t;
////////////////////////////////////////////////////////////////
// structure for callback events
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct FINITION
{
DWORD x;
DWORD y;
DWORD sizex;
DWORD sizey;
char flags;
};
#pragma pack(pop)
typedef struct FINITION finition_t;
////////////////////////////////////////////////////////////////
// type of data - structure message
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct MESSAGE
{
DWORD type;
DWORD arg1;
DWORD arg2;
DWORD arg3;
DWORD arg4;
};
#pragma pack(pop)
typedef struct MESSAGE gui_message_t;
////////////////////////////////////////////////////////////////
// prototype of functions
////////////////////////////////////////////////////////////////
void (*ControlProc)(void *Control,gui_message_t *message);
void (*CallbackFunction)(header_t *Control,void *data);
void (*TimerCallbackFunction)(void *data);
void (*CallbackFunctionForEvent)(gui_message_t *message,void *data);
void (*IDL_Function)(void *data);
////////////////////////////////////////////////////////////////
// button
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlButton
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//button's data
unsigned char btn_flags;
};
#pragma pack(pop)
typedef struct ControlButton gui_button_t;
// information for creating control Button
#pragma pack(push,1)
struct ButtonData
{
int x;
int y;
int width;
int height;
};
#pragma pack(pop)
typedef struct ButtonData gui_button_data_t;
////////////////////////////////////////////////////////////////
// scroller
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlScrollBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scroll bar's data
float ruller_size;
float ruller_pos;
float ruller_step;
unsigned char scb_flags;
};
#pragma pack(pop)
typedef struct ControlScrollBar gui_scroll_bar_t;
#pragma pack(push,1)
struct ScrollBarData
{
int x;
int y;
int width;
int height;
float ruller_size;
float ruller_pos;
float ruller_step;
};
#pragma pack(pop)
typedef struct ScrollBarData gui_scroll_bar_data_t;
////////////////////////////////////////////////////////////////
// progressbar
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlProgressBar
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//progress bar's data
float progress;
unsigned char prb_flags;
};
#pragma pack(pop)
typedef struct ControlProgressBar gui_progress_bar_t;
#pragma pack(push,1)
struct ProgressBarData
{
int x;
int y;
int width;
int height;
float progress;
};
#pragma pack(pop)
typedef struct ProgressBarData gui_progress_bar_data_t;
////////////////////////////////////////////////////////////////
// scrolled window
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlScrolledWindow
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
//scrolled windows's data
DWORD virtual_x;
DWORD virtual_y;
DWORD virtual_sizex;
DWORD virtual_sizey;
DWORD *virtual_controls_x;
DWORD *virtual_controls_y;
DWORD number_virtual_controls;
DWORD scroll_arrea_sizex;
DWORD scroll_arrea_sizey;
DWORD *horizontal_scroll;
DWORD *vertical_scroll;
unsigned char scw_flags;
};
#pragma pack(pop)
typedef struct ControlScrolledWindow gui_scrolled_window_t;
#pragma pack(push,1)
struct ScrolledWindowData
{
int x;
int y;
int width;
int height;
};
#pragma pack(pop)
typedef struct ScrolledWindowData gui_scrolled_window_data_t;
////////////////////////////////////////////////////////////////
// image
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlImage
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
char bits_per_pixel;
char bytes_per_pixel;
char *img;
};
#pragma pack(pop)
typedef struct ControlImage gui_image_t;
#pragma pack(push,1)
struct ImageData
{
int x;
int y;
int width;
int height;
char bits_per_pixel;
};
#pragma pack(pop)
typedef struct ImageData gui_image_data_t;
////////////////////////////////////////////////////////////////
// text
////////////////////////////////////////////////////////////////
#pragma pack(push,1)
struct ControlText
{
DWORD *ctrl_proc;
DWORD *ctrl_fd;
DWORD *ctrl_bk;
DWORD *child_fd;
DWORD *child_bk;
DWORD *parent;
DWORD *main_parent;
DWORD ctrl_x;
DWORD ctrl_y;
DWORD ctrl_sizex;
DWORD ctrl_sizey;
DWORD ctrl_ID;
DWORD *active_control_for_keys;
DWORD *active_control_for_mouse;
DWORD *callback;
DWORD *finition;
DWORD *timer;
DWORD flags;
DWORD *font;
DWORD color;
DWORD background_color;
char *text;
BYTE txt_flags;
};
#pragma pack(pop)
typedef struct ControlText gui_text_t;
#pragma pack(push,1)
struct TextData
{
int x;
int y;
DWORD *font;
DWORD color;
DWORD background_color;
char background;
char *text;
};
#pragma pack(pop)
typedef struct TextData gui_text_data_t;
/////////////////////////////////////////////////////////////////////////////
// prototips of some service functions
/////////////////////////////////////////////////////////////////////////////
char CheckCrossRectangles(int x1,int y1,int sizex1,int sizey1,int x2,int y2,int sizex2,int sizey2);

1642
programs/develop/new libGUI_C/SRC/libGUI_menegement.inc Executable file
View File

File diff suppressed because it is too large Load Diff

224
programs/develop/new libGUI_C/SRC/main_libGUI.inc Executable file
View File

@ -0,0 +1,224 @@
/*
main meneger loop libGUI library
*/
void LibGUImain(parent_t *WindowParent)
{
DWORD event,key,value;
header_t *control;
gui_message_t *events_message;
gui_timer_t *seek_timer,*exchange_timer;
gui_callbackevent_t *seek_calev,*calev,*exchange_calev;
int i;
char quit;
events_message=(struct MESSAGE*)WindowParent->message;
//tell all child controls of main parent who is main parent
events_message->type=MESSAGE_SET_MAIN_PARENT;
events_message->arg1=(DWORD)WindowParent;
SendMessage((struct HEADER *)WindowParent,events_message);
//display all created controls in window
gui_draw_window(WindowParent);
events_message->type=MESSAGE_FULL_REDRAW_ALL;
SendMessage((struct HEADER *)WindowParent,events_message);
events_message->type=0;
quit=FALSE;
WindowParent->number_callbacks=0;
while (quit==FALSE)
{
//check for timers
if ((WindowParent->timer_bk!=(DWORD*)NULL) ||
(WindowParent->number_timers_for_controls!=0)) {event=gui_ksys_check_event();}
else {event=gui_ksys_wait_event();}
//get and chack system events
switch(event)
{
case KOLIBRIOS_SYS_EVENT_BUTTON_PRESSED:
{
if (ControlCheckCallbackEvent(WindowParent,DELETE_EVENT)!=NULL)
{
WindowParent->flags |= FLAG_CONNECT_EVENT_ON;
WindowParent->control_for_callback_function[WindowParent->number_callbacks]=
(DWORD*)WindowParent;
WindowParent->callback_for_control_callback[WindowParent->number_callbacks]=
(DWORD*)ControlCheckCallbackEvent(WindowParent,(DWORD)DELETE_EVENT);
WindowParent->number_callbacks++;
}
quit=TRUE;
break;
}
case KOLIBRIOS_SYS_EVENT_REDRAW:
{
GetNewWindowSizePos(WindowParent);
SetWindowSizeRequest(WindowParent,WindowParent->ctrl_sizex,WindowParent->ctrl_sizey);
gui_draw_window(WindowParent);
events_message->type=MESSAGE_FULL_REDRAW_ALL;
SendMessage((struct HEADER *)WindowParent,events_message);
break;
}
case KOLIBRIOS_SYS_EVENT_KEYS:
{
key=gui_ksys_get_key();
key=key>>8;
if (key & 128)
{
events_message->arg1=KEY_UP;
events_message->arg2=key & 127;
}
else
{
events_message->arg1=KEY_DOWN;
events_message->arg2=key;
}
events_message->type=MESSAGE_KEYS_EVENT;
SendMessage((struct HEADER *)WindowParent,events_message);
break;
}
case KOLIBRIOS_SYS_EVENT_MOUSE:
{
value=gui_ksys_get_window_mouse_coordinates();
events_message->type=MESSAGE_MOUSE_EVENT;
events_message->arg2=(value & 0xffff)-screen.y;//y
value=value >>16;
events_message->arg1=value-screen.x;//x
value=gui_ksys_get_mouse_buttons_state();
switch(value)
{
case KOLIBRIOS_SYS_MOUSE_BUTTON_LEFT_DOWN:
{
events_message->arg3=MOUSE_LEFT_BUTTON_DOWN;
break;
}
case KOLIBRIOS_SYS_MOUSE_BUTTON_RIGHT_DOWN:
{
events_message->arg3=MOUSE_RIGHT_BUTTON_DOWN;
break;
}
case KOLIBRIOS_SYS_MOUSE_BUTTON_MIDDLE_DOWN:
{
events_message->arg3=MOUSE_MIDDLE_BUTTON_DOWN;
break;
}
case KOLIBRIOS_SYS_MOUSE_BUTTON_4_DOWN:
{
events_message->arg3=MOUSE_4_BUTTON_DOWN;
break;
}
case KOLIBRIOS_SYS_MOUSE_BUTTON_5_DOWN:
{
events_message->arg3=MOUSE_5_BUTTON_DOWN;
break;
}
default:
{
if (events_message->arg3==MOUSE_LEFT_BUTTON_DOWN)
{
events_message->arg3=MOUSE_LEFT_BUTTON_UP;
break;
}
if (events_message->arg3==MOUSE_RIGHT_BUTTON_DOWN)
{
events_message->arg3=MOUSE_RIGHT_BUTTON_UP;
break;
}
if (events_message->arg3==MOUSE_MIDDLE_BUTTON_DOWN)
{
events_message->arg3=MOUSE_MIDDLE_BUTTON_UP;
break;
}
if (events_message->arg3==MOUSE_4_BUTTON_DOWN)
{
events_message->arg3=MOUSE_4_BUTTON_UP;
break;
}
if (events_message->arg3==MOUSE_5_BUTTON_DOWN)
{
events_message->arg3=MOUSE_5_BUTTON_UP;
break;
}
break;
}
}
SendMessage((struct HEADER *)WindowParent,events_message);
break;
}
}
//call functions for events
seek_calev=(struct CALLBACKEVENT*)WindowParent->calev_bk;
while(seek_calev!=(struct CALLBACKEVENT*)NULL)
{
if (seek_calev->event_type==events_message->type)
{
CallbackFunctionForEvent=(void(*)(struct MESSAGE *message,void *data))seek_calev->func;
CallbackFunctionForEvent(events_message,seek_calev->func_data);
}
exchange_calev=(struct CALLBACKEVENT*)seek_calev->calev_fd;
seek_calev=exchange_calev;
}
//call timers of controls
if (WindowParent->number_timers_for_controls!=0)
{
events_message->type=(char)MESSAGE_CALL_TIMER_EVENT;
SendMessage((struct HEADER *)WindowParent,events_message);
}
//call callback functions
for(i=0;i<WindowParent->number_callbacks;i++)
{
control=(struct HEADER*)WindowParent->control_for_callback_function[i];
//check callback control
if (control!=(struct HEADER*)NULL)
{
calev=(struct CALLBACKEVENT*)WindowParent->callback_for_control_callback[i];
if (control->flags & FLAG_CONNECT_EVENT_ON)
{
CallbackFunction=(void (*)( struct HEADER *Control,void *data))calev->func;
CallbackFunction(control,calev->func_data);
control->flags=control->flags & FLAG_CONNECT_EVENT_OFF;
}
}
}
WindowParent->number_callbacks=0;
//call timers of parent window
seek_timer=(struct TIMER*)WindowParent->timer_bk;
while(seek_timer!=(struct TIMER*)NULL)
{
if (seek_timer->flags & FLAG_TIMER_ON) Timer(seek_timer);
exchange_timer=(struct TIMER*)seek_timer->tmr_fd;
seek_timer=exchange_timer;
}
//check for IDL function and call it if enabled
if (WindowParent->IDL_func!=(DWORD*)NULL)
{
IDL_Function=(void(*)(void *data))WindowParent->IDL_func;
IDL_Function(WindowParent->IDL_func_data);
}
}
}

132
programs/develop/new libGUI_C/SRC/parent_window.inc Executable file
View File

@ -0,0 +1,132 @@
/*
create parent of window
*/
#define PARENT_WINDOW_DEFAULT_SIZEX 320
#define PARENT_WINDOW_DEFAULT_SIZEY 200
#define PARENT_WINDOW_BORDER_WIDTH 5;
void gui_get_screen_parameters(void)
{
int value;
value=(int)gui_ksys_get_screen_bits_per_pixel();
screen.bits_per_pixel=(char)value;
screen.bytes_per_pixel=screen.bits_per_pixel >> 3;
screen.skin_height=gui_ksys_get_skin_height();
screen.x=PARENT_WINDOW_BORDER_WIDTH;
screen.y=screen.skin_height;
value=gui_ksys_get_screen_size();
screen.display_size_y=value & 0xffff;
screen.display_size_y=value >> 16;
}
void gui_draw_window(parent_t *window)
{
DWORD flag;
flag=3;
flag=flag<<24;
flag +=0xaabbcc;
gui_ksys_begin_draw_window();
gui_ksys_draw_window(window->ctrl_x,window->ctrl_y,window->ctrl_sizex,window->ctrl_sizey,flag);
gui_ksys_finish_draw_window();
}
//---------------------------------------------------------------------------------
// create window parent
//---------------------------------------------------------------------------------
void* CreateWindow(void)
{
struct HEADERPARENT *WindowParent;
WindowParent=malloc(sizeof(parent_t));
WindowParent->message=malloc(sizeof(gui_message_t));
WindowParent->control_for_callback_function=malloc(sizeof(DWORD)*MAX_CALLBACKS);
WindowParent->callback_for_control_callback=malloc(sizeof(DWORD)*MAX_CALLBACKS);
WindowParent->main_parent=(DWORD*)WindowParent;
WindowParent->global_active_control_for_keys=(DWORD*)NULL;
WindowParent->control_for_callback_function[0]=(DWORD*)NULL;
WindowParent->number_callbacks=0;
WindowParent->child_bk=(DWORD*)NULL;
WindowParent->active_control_for_keys=(DWORD*)NULL;
WindowParent->active_control_for_mouse=(DWORD*)NULL;
WindowParent->ctrl_x=0x0;
WindowParent->ctrl_y=0x0;
WindowParent->ctrl_sizex=PARENT_WINDOW_DEFAULT_SIZEX;
WindowParent->ctrl_sizey=PARENT_WINDOW_DEFAULT_SIZEY;
WindowParent->callback=(DWORD*)NULL;//no callbacks yet
WindowParent->timer=(DWORD*)NULL;//no timers yet
WindowParent->flags=0;
WindowParent->flags=WindowParent->flags | FLAG_SHOW_CONTROL;
WindowParent->flags=WindowParent->flags | FLAG_FOCUSE_INPUT_SUPPOROTE;
WindowParent->number_timers_for_controls=0;
WindowParent->timer_bk=(DWORD*)NULL;
WindowParent->timer_fd=(DWORD*)NULL;
WindowParent->calev_bk=(DWORD*)NULL;
WindowParent->calev_fd=(DWORD*)NULL;
WindowParent->IDL_func=(DWORD*)NULL;
//---------------------------------------------------------------------------------
//---------------------------platform depended part of code------------------------
//---------------------------------------------------------------------------------
//create and initialize screen buffer
gui_get_screen_parameters();
//by default draw output to the screen
screen.draw_output=DRAW_OUTPUT_SCREEN;
//calculate size of client's arrea
screen.size_x=WindowParent->ctrl_sizex-9;
screen.size_y=WindowParent->ctrl_sizey-screen.skin_height-4;
//----------------------------------------------------------------------------------
ID=0;
return(WindowParent);
}
//---------------------------------------------------------------------------------
// create window parent
//---------------------------------------------------------------------------------
void SetWindowSizeRequest(parent_t *WindowParent,int size_x,int size_y)
{
static int x,y,sizex,sizey;
//---------------------------------------------------------------------------------
//---------------------------platform depended part of code------------------------
//---------------------------------------------------------------------------------
x=WindowParent->ctrl_x;
y=WindowParent->ctrl_y;
sizex=size_x;
sizey=size_y;
gui_ksys_set_position_and_size_window(x,y,sizex,sizey);
//---------------------------------------------------------------------------------
WindowParent->ctrl_sizex=sizex;
WindowParent->ctrl_sizey=sizey;
screen.size_x=WindowParent->ctrl_sizex-9;
screen.size_y=WindowParent->ctrl_sizey-screen.skin_height-4;
}
void GetNewWindowSizePos(parent_t *WindowParent)
{
static process_table_t procinfo;
gui_ksys_get_current_process_information(&procinfo);
WindowParent->ctrl_x=(DWORD)procinfo.winx_start;
WindowParent->ctrl_y=(DWORD)procinfo.winy_start;
WindowParent->ctrl_sizex=(DWORD)procinfo.winx_size;
WindowParent->ctrl_sizey=(DWORD)procinfo.winy_size;
//get screen parameters again
gui_get_screen_parameters();
}

8
programs/develop/new libGUI_C/SRC/stdarg.h Executable file
View File

@ -0,0 +1,8 @@
typedef char *va_list;
#define _roundsize(n) ( (sizeof(n) + 3) & ~3 )
#define va_start(ap,v) (ap = (va_list)&v+_roundsize(v))
#define va_arg(ap,t) ( *(t *)((ap += _roundsize(t)) - _roundsize(t)) )
#define va_end(ap) (ap = (va_list)0)

3
programs/develop/new libGUI_C/SRC/stdio.h Executable file
View File

@ -0,0 +1,3 @@
static int cdecl printf(const char *format,...);

790
programs/develop/new libGUI_C/SRC/stdio.inc Executable file
View File

@ -0,0 +1,790 @@
/*
function for format output to the string
*/
static int formatted_double_to_string(long double number,int format1,int format2,char *s)
{
/*
double n;
double nbefor;
double nafter;
double v,v2;
long intdigit;
long beforpointdigit;
long div;
int i;
int pos;
int size;
int fmt1;
int fmt2;
long mul;
static char buf[200];
size=(int)s;
n=(double)number;
if (n<0) {*s='-';s++;n=-n;}
fmt1=format1;
fmt2=format2;
if (fmt2>18) {fmt2=18;} //maximum of size long long type
//clear array befor output
for(i=0;i<=200;i++) {buf[i]=0;}
if ((fmt1>=0) && (n<1))
{ //formatted output if 0<=n<1
mul=1;
for(i=0;i<fmt2;i++)
{n=n*10;mul=mul*10;}
n=n*10;
n=ceil(n);
intdigit=floor(n);
//intdigit=n;
intdigit=(intdigit/10);
pos=0;
mul=mul/10;
for(i=0;i<fmt2-1;i++)
{
div=intdigit/mul;
buf[pos]=(char)div;
pos++;
intdigit=intdigit-div*mul;
mul=mul/10;
if (mul==1) break;
}
buf[pos]=(char)intdigit;
*s='0';s++;
*s='.';s++;
for(i=0;i<format2;i++)
{
if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
else {*s='0';}
s++;
}
}
else
{ //if n>=1
//v=floorf(n+0.00000000000001);
beforpointdigit=floor(n+0.00000000000001);
//beforpointdigit=n;
nbefor=beforpointdigit;
nafter=n-nbefor;
//print part of number befor point
mul=1;
for(i=0;i<200-2;i++)
{
mul=mul*10;
if ((beforpointdigit/mul)==0) {fmt1=i+1;break;}
}
pos=0;
mul=mul/10;
for(i=0;i<fmt1-1;i++)
{
div=beforpointdigit/mul;
buf[pos]=(char)div;
pos++;
beforpointdigit=beforpointdigit-div*mul;
mul=mul/10;
if (mul==1) break;
}
buf[pos]=(char)beforpointdigit;
for(i=0;i<fmt1;i++)
{
if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
s++;
}
//print part of number after point
mul=1;
for(i=0;i<fmt2;i++)
{nafter=nafter*10;mul=mul*10;}
nafter=nafter*10;
nafter=ceil(nafter);
intdigit=floor(nafter);
//intdigit=nafter;
intdigit=intdigit/10;
pos=0;
mul=mul/10;
for(i=0;i<fmt2-1;i++)
{
div=intdigit/mul;
buf[pos]=(char)div;
pos++;
intdigit=intdigit-div*mul;
mul=mul/10;
if (mul==1) break;
}
buf[pos]=(char)intdigit;
*s='.';s++;
for(i=0;i<format2;i++)
{
if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
else {*s='0';}
s++;
}
}
size=(int)s-size;
return(size);
*/
}
static int formatted_long_to_string(long long number,int fmt1,char *s)
{
int i;
int pos;
int fmt;
int size;
int difference_pos;
long digit;
long mul;
long div;
static char buf[200];
//clear array befor output
for(i=0;i<200;i++) {buf[i]=0;}
digit=number;
size=(int)s;
if (digit<0) {*s='-';s++;digit=-digit;}
if (digit==0) {*s='0';s++;goto end;}
mul=1;
for(i=0;i<200-2;i++)
{
mul=mul*10;
if ((digit/mul)==0) {fmt=i+1;break;}
}
difference_pos=i+1;
pos=0;
mul=mul/10;
for(i=0;i<fmt-1;i++)
{
div=digit/mul;
buf[pos]=(char)div;
pos++;
digit=digit-div*mul;
mul=mul/10;
if (mul==1) break;
}
buf[pos]=(char)digit;
if (fmt1>=difference_pos) fmt=fmt1;
else
fmt=difference_pos;
for(i=0;i<fmt;i++)
{
if (i<difference_pos)
{
if ((buf[i]>=0) && (buf[i]<=9)) {*s='0'+buf[i];}
}
else
{
*s=' ';
}
s++;
}
end:
size=(int)s-size;
return(size);
}
static int formatted_hex_to_string(long long number,int fmt1,char flag_register,char *s)
{
long n;
int i,pos;
int fmt;
long size;
int difference_pos;
static char xdigs_lower[16]="0123456789abcdef";
static char xdigs_upper[16]="0123456789ABCDEF";
static char buf[200];
n=(long)number;
size=(int)s;
if (n<0) {*s='-';s++;n=-n;}
if (n==0) {*s='0';s++;goto end;}
for(i=0;i<200;i++) {buf[i]=0;}
i=0;
if (flag_register==0)
{
while (n>0)
{
buf[i]=xdigs_lower[n & 15];
n=n>>4;
i++;
}
}
else
{
while (n>0)
{
buf[i]=xdigs_upper[n & 15];
n=n>>4;
i++;
}
}
pos=i;
difference_pos=i;
for(i=pos-1;i>=0;i--)
{
*s=buf[i];
s++;
}
if (fmt1-difference_pos>0)
{
for(i=difference_pos+1;i<=fmt1;i++)
{
*s=' ';
s++;
}
}
end:size=(int)s-size;
return(size);
}
static int formatted_octa_to_string(long long number,int fmt1,char flag_register,char *s)
{
long n;
int i,pos;
int fmt;
long size;
int difference_pos;
static char xdigs_lower[16]="012345678";
static char buf[200];
n=number;
size=(int)s;
if (n<0) {*s='-';s++;n=-n;}
if (n==0) {*s='0';s++;goto end;}
for(i=0;i<200;i++) {buf[i]=0;}
i=0;
if (flag_register==0)
{
while (n>0)
{
buf[i]=xdigs_lower[n & 7];
n=n>>3;
i++;
}
}
pos=i;
difference_pos=i;
for(i=pos-1;i>=0;i--)
{
*s=buf[i];
s++;
}
if (fmt1-difference_pos>0)
{
for(i=difference_pos+1;i<=fmt1;i++)
{
*s=' ';
s++;
}
}
end:size=(int)s-size;
return(size);
}
static int format_print(char *dest, size_t maxlen,const char *fmt0, va_list argp)
{
int i,j,k;
int length;
int fmt1,fmt2,stepen;
size_t pos,posc;
long long intdigit;
long double doubledigit;
float floatdigit;
const char *fmt,*fmtc;
char *s;
char *str;
static char buffmt1[30];
static char buffmt2[30];
static char buf[1024];
char format_flag;
char flag_point;
char flag_noformat;
char flag_long;
char flag_unsigned;
char flag_register;
char flag_plus;
fmt=fmt0;
s=dest;
pos=0;
while(pos<maxlen)
{
if (*fmt=='%')
{
if (*(fmt+1)=='%')
{
*s='%';
s++;
fmt=fmt+2;
pos++;
goto exit_check;
}
//checking to containg format in the string
fmtc=fmt;
posc=pos;
format_flag=0;
flag_long=0;
flag_unsigned=0;
flag_register=0;
flag_plus=0;
while((*fmtc!='\0') || (*fmtc!=0))
{
fmtc++;
posc++;
switch(*fmtc)
{
case 'c':
case 'C':
format_flag=1;
break;
case 'd':
case 'D':
case 'i':
case 'I':
format_flag=1;
break;
case 'e':
format_flag=1;
break;
case 'E':
format_flag=1;
flag_long=1;
break;
case 'f':
format_flag=1;
break;
case 'F':
format_flag=1;
flag_long=1;
break;
case 'g':
format_flag=1;
break;
case 'G':
format_flag=1;
flag_long=1;
break;
case 'l':
flag_long=1;
break;
case 'L':
flag_long=2;
break;
case 'o':
format_flag=1;
break;
case 's':
case 'S':
format_flag=1;
break;
case 'u':
case 'U':
format_flag=1;
flag_unsigned=1;
break;
case 'x':
format_flag=1;
break;
case 'X':
flag_register=1;
format_flag=1;
break;
case 'z':
case 'Z':
format_flag=1;
flag_unsigned=1;
break;
case '+':
flag_plus=1;
break;
default:;
}
if ((*fmtc=='%') || (*fmtc==' ')) break;
if (format_flag==1) break;
}
if (format_flag==0)
{
*s=*fmt;
fmt++;
s++;
pos++;
}
else
{
if ((posc-pos)==1)
{//simbols % and format simbol near tothere(for example %c )
fmt=fmtc+1;
switch(*fmtc)
{
case 'c':
case 'C':
if ((pos+1)<maxlen)
{
//*s=(int)va_arg(argp,char*);
*s=*((char *)argp);
argp=argp+4;
*s++;pos++;
}
break;
case 's':
case 'S':
str=va_arg(argp,char*);
length=strlen(str);
if ((pos+length)<maxlen)
{
memmove(s,str,length);
s=s+length;pos=pos+length;
}
break;
case 'd':
case 'D':
case 'i':
case 'I':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
//intdigit=*((long*)argp);
//argp=argp+4;
if ((intdigit>0) && (flag_plus==1) && (pos+1<maxlen))
{
*s='+';
s++;
pos++;
}
length=formatted_long_to_string(intdigit,0,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'o':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
//intdigit=*((long int *)argp);
//argp=argp+4;
length=formatted_octa_to_string(intdigit,0,flag_register,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'u':
case 'U':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long int);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
if (flag_unsigned==1) {
if (intdigit<0) {intdigit=-intdigit;}
}
length=formatted_long_to_string(intdigit,0,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'x':
case 'X':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
//intdigit=*((long int *)argp);
//argp=argp+4;
length=formatted_hex_to_string(intdigit,0,flag_register,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'z':
case 'Z':
intdigit=va_arg(argp,size_t);
if (flag_unsigned==1) {
if (intdigit<0) {intdigit=-intdigit;}
}
length=formatted_long_to_string(intdigit,0,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
default:;
}
}
else
{
fmt++;
flag_point=0;
flag_noformat=0;
fmt1=0;
fmt2=0;
j=0;
k=0;
for(i=pos+1;i<posc;i++)
{
switch(*fmt)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (flag_point==0)
{
buffmt1[j]=*fmt-'0';
j++;
}
else
{
buffmt2[k]=*fmt-'0';
k++;
}
break;
case '.':
flag_point=1;
break;
case 'l':
case 'L':
break;
case '+':
break;
default:flag_noformat=1;
}
if (flag_noformat==1) break;
fmt++;
}
if (flag_noformat==0)
{
stepen=1;
for(i=j-1;i>=0;i--)
{
fmt1=fmt1+buffmt1[i]*stepen;
stepen=stepen*10;
}
stepen=1;
for(i=k-1;i>=0;i--)
{
fmt2=fmt2+buffmt2[i]*stepen;
stepen=stepen*10;
}
switch(*fmtc)
{
case 'f':
case 'F':
if (flag_long==0) {doubledigit=va_arg(argp,double);}
if (flag_long>=1) {doubledigit=va_arg(argp,long double);}
//doubledigit=*((double *)argp);
//sargp=argp+8;
length=formatted_double_to_string(doubledigit,fmt1,fmt2,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'd':
case 'D':
case 'i':
case 'I':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
if ((intdigit>0) && (flag_plus==1) && (pos+1<maxlen))
{
*s='+';
s++;
pos++;
}
length=formatted_long_to_string(intdigit,fmt1,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'o':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
length=formatted_octa_to_string(intdigit,fmt1,flag_register,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'u':
case 'U':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long int);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
if (flag_unsigned==1) {
if (intdigit<0) {intdigit=-intdigit;}
}
length=formatted_long_to_string(intdigit,fmt1,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'x':
case 'X':
if (flag_long==0) {intdigit=va_arg(argp,int);}
if (flag_long==1) {intdigit=va_arg(argp,long int);}
if (flag_long==2) {intdigit=va_arg(argp,long long);}
length=formatted_hex_to_string(intdigit,fmt1,flag_register,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
case 'z':
case 'Z':
intdigit=va_arg(argp,size_t);
if (flag_unsigned==1) {
if (intdigit<0) {intdigit=-intdigit;}
}
length=formatted_long_to_string(intdigit,fmt1,buf);
if ((pos+length)<maxlen)
{
memmove(s,buf,length);
s=s+length;pos=pos+length;
}
break;
default:;
}
}
fmt=fmtc+1;
}
}
}
else
{
if (*fmt=='\0') {break;}
*s=*fmt;
fmt++;
s++;
pos++;
}
exit_check:;
}
return(pos);
}
static char* dllname="/rd/1/lib/console.obj";
int console_init_status=0;
static char* imports[] = {"START","version","con_init","con_write_asciiz","con_printf","con_exit"};
static char* caption = "Console";
static DWORD (stdcall *dll_ver)(void);
static void (stdcall *con_init)(DWORD wnd_width, DWORD wnd_height, DWORD scr_width, DWORD scr_height, const char* title);
static void (stdcall *con_write_asciiz)(const char* string);
static void (cdecl *con_printf)(const char* format,...);
static void (stdcall *con_exit)(DWORD bCloseWindow);
static void printf_link(import_t *exp, char** imports)
{
dll_ver = (DWORD (stdcall *)(void))
gui_cofflib_getproc(exp, imports[1]);
con_init = (void (stdcall *)(DWORD , DWORD, DWORD, DWORD, const char*))
gui_cofflib_getproc(exp, imports[2]);
con_printf = (void (cdecl *)(const char*,...))
(exp, imports[4]);
con_exit = (void (stdcall *)(DWORD))
gui_cofflib_getproc(exp, imports[5]);
}
static int init_console(void)
{
import_t *hDll;
if((hDll = (import_t*)gui_ksys_load_dll(dllname)) == 0)
{
gui_debug_out_str("can't load lib\n");
return 1;
}
printf_link(hDll, imports);
con_init(-1, -1, -1, -1, caption);
return(0);
}
static int printf(const char *format,...)
{
int i;
int printed_simbols;
va_list arg;
static char simbol[]={"%s"};
char *s;
va_start(arg,format);
/*
if (console_init_status==0)
{
i=init_console();
console_init_status=1;
}
*/
s=malloc(4096);
printed_simbols=format_print(s,4096,format,arg);
gui_debug_out_str(s); //con_printf(simbol,s);
free(s);
return(printed_simbols);
}

9
programs/develop/new libGUI_C/SRC/stdlib.h Executable file
View File

@ -0,0 +1,9 @@
/*
some standart libC helper functions
*/
static void* malloc(DWORD size);
static void free(void *memory);
static void* realloc(void *old_mem,DWORD new_size);
static void exit(int c);

24
programs/develop/new libGUI_C/SRC/stdlib.inc Executable file
View File

@ -0,0 +1,24 @@
/*
some standart libC helper functions
*/
static void* malloc(DWORD size)
{
return(gui_ksys_malloc(size));
}
static void free(void *memory)
{
gui_ksys_free(memory);
}
static void* realloc(void *old_mem,DWORD new_size)
{
return(gui_ksys_realloc(new_size,old_mem));
}
static void exit(int c)
{
gui_ksys_exit(c);
}

16
programs/develop/new libGUI_C/SRC/string.h Executable file
View File

@ -0,0 +1,16 @@
/*
some libC function working with memory
*/
static void *memmove(void *dst,const void *src,size_t length);
static size_t strlen(const char *s);
static char* strchr(const char *string, int c);
static char* strrchr(const char *string, int c);
static char* strstr(const char *s1,const char *s2);
static int strcmp(const char*,const char*);
static int strncmp(const char* string1, const char* string2, int count);
static int vsnprintf(char *dest, size_t size,const char *format,va_list ap);
static int cdecl snprintf(char *dest, size_t size, const char *format,...);
static int cdecl sprintf(char *dest,const char *format,...);

134
programs/develop/new libGUI_C/SRC/string.inc Executable file
View File

@ -0,0 +1,134 @@
/*
some libC function working with memory
*/
static void *memmove(void *dst,const void *src,size_t length)
{
void *value;
__asm__ __volatile__(
"movl %%edi,%%eax\n\t"
"cld\n\t"
"rep\n\t"
"movsb"
:"=D"(value)
:"c"(length),"S"(src),"D"(dst)
:"eax");
return(value);
}
static size_t strlen(const char *s)
{
size_t i;
i=0;
while(*s!='\0')
{
i++;
s++;
}
return(i);
}
static char* strchr(const char *string, int c)
{
while(*string!='\0')
{
if (*string==(char)c) return((char*)string);
string++;
}
return(NULL);
}
static char* strrchr(const char *string, int c)
{
char *s;
int i,j;
s=(char*)string;
while(*s!='\0') {s++;}
j=(int)(s-string);
s--;
for(i=0;i<j;i++)
{
if (*s==(char)c) return(s);
s--;
}
return(NULL);
}
static char* strstr(const char *s1,const char *s2)
{
char *s;
int i,j,len1,len2;
len2=strlen(s2);
if (len2==0) return((char*)s1);
len1=strlen(s1);
for(i=0;i<len1-len2+1;i++)
{
if (s1[i]==s2[0])
{
for(j=0;j<len2;j++)
{
if (s1[i+j]!=s2[j]) break;
}
if (j==len2) return((char*)(s1+i));
}
}
return(NULL);
}
static int strcmp(const char* string1, const char* string2)
{
while (1)
{
if (*string1<*string2)
return -1;
if (*string1>*string2)
return 1;
if (*string1=='\0')
return 0;
string1++;
string2++;
}
}
static int strncmp(const char* string1, const char* string2, int count)
{
while(count>0 && *string1==*string2)
{
if (*string1) return 0;
++string1;
++string2;
--count;
}
if(count) return (*string1 - *string2);
return 0;
}
static int sprintf(char *dest,const char *format,...)
{
va_list arg;
va_start (arg, format);
return format_print(dest,4096, format, arg);
}
static int snprintf(char *dest, size_t size,const char *format,...)
{
va_list arg;
va_start (arg, format);
return format_print(dest,size, format, arg);
}
static int vsnprintf(char *dest, size_t size,const char *format,va_list ap)
{
return format_print(dest,size, format, ap);
}

17
programs/develop/new libGUI_C/SRC/types.h Executable file
View File

@ -0,0 +1,17 @@
/*
some used types
*/
#define NULL (void*)0
typedef unsigned int DWORD;
typedef unsigned char BYTE;
typedef unsigned short int WORD;
typedef unsigned int size_t;
//#define stdcall __attribute__((stdcall))
//#define cdecl __attribute__((cdecl))
//for win compilers
#define stdcall __stdcall
#define cdecl __cdecl

70
programs/develop/new libGUI_C/examples/src/button.c Executable file
View File

@ -0,0 +1,70 @@
/*
test libGUI library
*/
#include "stdarg.h"
#include "libGUI.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#define FALSE 0
#define TRUE 1
void callback_func_delete_window(header_t *control,void *data)
{
QuitLibGUI((parent_t*)control);
}
void callback_func1(header_t *control,void *data)
{
printf("\nentry in button");
}
void callback_func2(header_t *control,void *data)
{
printf("\nbutton pressed");
}
void callback_func3(header_t *control,void *data)
{
printf("\nbutton released");
}
void callback_func4(header_t *control,void *data)
{
printf("\nleave button");
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_callback_t *id1,*id2,*id3,*id4;
gui_button_data_t button_data;
gui_button_t *button;
//load libGUI library
LoadLibGUI(NULL);
//create main window
window=CreateWindow();
SetWindowSizeRequest(window,90,60);
//create button
button_data.x=5;
button_data.y=5;
button_data.width=70;
button_data.height=20;
//create button with text
button=CreateButtonWithText(&button_data,"Click my!");
//set callback functions for button close window
SetCallbackFunction(window,DELETE_EVENT,&callback_func_delete_window,NULL);
//set callback functions for button
id1=SetCallbackFunction(button,BUTTON_ENTER_EVENT,&callback_func1,NULL);
id2=SetCallbackFunction(button,BUTTON_PRESSED_EVENT,&callback_func2,NULL);
id3=SetCallbackFunction(button,BUTTON_RELEASED_EVENT,&callback_func3,NULL);
id4=SetCallbackFunction(button,BUTTON_LEAVE_EVENT,&callback_func4,NULL);
//pack button in window
PackControls(window,button);
//start main libGUI loop
LibGUImain(window);
}

52
programs/develop/new libGUI_C/examples/src/image.c Executable file
View File

@ -0,0 +1,52 @@
/*
test libGUI library
*/
#include "stdarg.h"
#include "libGUI.h"
#include "stdlib.h"
#include "stdio.h"
void callback_func_delete_window(header_t *control,void *data)
{
QuitLibGUI((parent_t*)control);
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_image_data_t imdata;
gui_image_t *image;
int i,j;
unsigned int *img;
//load libGUI library
LoadLibGUI(NULL);//use default system path to library
//create main window
window=CreateWindow();
//change window size
SetWindowSizeRequest(window,220,142);
//set callback function for close window button
SetCallbackFunction(window,DELETE_EVENT,&callback_func_delete_window,NULL);
//create image
imdata.x=5;
imdata.y=5;
imdata.width=200;
imdata.height=100;
imdata.bits_per_pixel=32;//bits per pixel
image=CreateImage(&imdata);
img=(unsigned int*)image->img;
//generate 32 bits image
for(i=0;i<GetControlSizeY(image);i++)
{
for(j=0;j<GetControlSizeX(image);j++)
{
*img=100*(i*i+j*j-i*3+2*j);
img++;
}
}
//pack image in window
PackControls(window,image);
//start main libGUI loop
LibGUImain(window);
}

66
programs/develop/new libGUI_C/examples/src/progress_bar.c Executable file
View File

@ -0,0 +1,66 @@
/*
test libGUI library
*/
#include "stdarg.h"
#include "libGUI.h"
#include "string.h"
void callback_func_delete_window(header_t *control,void *data)
{
QuitLibGUI((parent_t*)control);
}
void ProgressBarCallback(void *data)
{
gui_progress_bar_t *progress_bar;
int progress;
static char txt[16];
progress_bar=(gui_progress_bar_t*)data;
progress_bar->progress+=0.01;//incrase progress
if (progress_bar->progress>1.0) progress_bar->progress=0.0;
//calculate progress level in %
progress=progress_bar->progress*100;
snprintf(txt,16,"progress %d%%",progress);
//set text for progress bar
ProgressBarSetText(progress_bar,txt);
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_progress_bar_data_t progress_bar_data;
gui_progress_bar_t *progress_bar;
gui_timer_t *timer;
//load libGUI library
LoadLibGUI(NULL);//use default system path to library
//create main window
window=CreateWindow();
//change size of main window
SetWindowSizeRequest(window,320,57);
//set callback function for button close window
SetCallbackFunction(window,DELETE_EVENT,&callback_func_delete_window,NULL);
//create progress bar
progress_bar_data.x=5;
progress_bar_data.y=5;
progress_bar_data.width=300;
progress_bar_data.height=25;
progress_bar_data.progress=0.0;
progress_bar=CreateProgressBar(&progress_bar_data);
//create timer for update progress level each 50 millisecunds
timer=SetTimerCallbackForFunction(window,5,&ProgressBarCallback,progress_bar);
//pack progress bar in window
PackControls(window,progress_bar);
//update progress bar automatically each 50 millisecund
SetProgressBarPulse(progress_bar,5);
//call main libGUI loop
LibGUImain(window);
}

76
programs/develop/new libGUI_C/examples/src/scroll_bar.c Executable file
View File

@ -0,0 +1,76 @@
/*
test libGUI library
*/
#include "stdarg.h"
#include "libGUI.h"
#include "stdio.h"
#define FALSE 0
#define TRUE 1
void callback_func_delete_window(header_t *control,void *data)
{
printf("\nlibGUI quit...");
QuitLibGUI((parent_t*)control);
}
void ScrollStateH(header_t *control,void *data)
{
gui_scroll_bar_t *hsc;
hsc=(gui_scroll_bar_t*)control;
printf("\nhorizontal ruler position %d%%",(int)(hsc->ruller_pos*100));
}
void ScrollStateV(header_t *control,void *data)
{
gui_scroll_bar_t *vsc;
vsc=(gui_scroll_bar_t*)control;
printf("\nvertical ruler position %d%%",(int)(vsc->ruller_pos*100));
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_callback_t *id1,*id2;
gui_scroll_bar_data_t horizontal_sbar_data;
gui_scroll_bar_data_t vertical_sbar_data;
gui_scroll_bar_t *ScrollBarH;
gui_scroll_bar_t *ScrollBarV;
//load libGUI library
LoadLibGUI(NULL);//use default system path to library
//create main window
window=CreateWindow();
//change size of window
SetWindowSizeRequest(window,270,207);
//create horizontal scroll bar
horizontal_sbar_data.x=5;
horizontal_sbar_data.y=5;
horizontal_sbar_data.width=250;
horizontal_sbar_data.height=16;
horizontal_sbar_data.ruller_size=0.2;//size of ruler E [0,1]
horizontal_sbar_data.ruller_pos=0.5;//ruler position E [0,1]
horizontal_sbar_data.ruller_step=0.1;//step of change ruler pos after press of button E [0,1]
//create vertical scroll bar
vertical_sbar_data.x=5;
vertical_sbar_data.y=26;
vertical_sbar_data.width=16;
vertical_sbar_data.height=150;
vertical_sbar_data.ruller_size=0.5;//size of ruler E [0,1]
vertical_sbar_data.ruller_pos=0.05;//ruler position E [0,1]
vertical_sbar_data.ruller_step=0.1;//step of change ruler pos after press of button E [0,1]
//create horizontal and vertical scroll bars
ScrollBarH=CreateHorizontalScrollBar(&horizontal_sbar_data);
ScrollBarV=CreateVerticalScrollBar(&vertical_sbar_data);
//set callback functions for scroll bars
id1=SetCallbackFunction(ScrollBarH,SCROLLBAR_CHANGED_EVENT,&ScrollStateH,NULL);
id2=SetCallbackFunction(ScrollBarV,SCROLLBAR_CHANGED_EVENT,&ScrollStateV,NULL);
//pack scroll bars in window
PackControls(window,ScrollBarH);
PackControls(window,ScrollBarV);
//start minl libGUI loop
LibGUImain(window);
}

67
programs/develop/new libGUI_C/examples/src/scrolled_window.c Executable file
View File

@ -0,0 +1,67 @@
/*
test libGUI library
*/
#include "stdarg.h"
#include "libGUI.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void callback_func_delete_window(header_t *control,void *data)
{
QuitLibGUI((parent_t*)control);
}
void callback_func(header_t *control,void *data)
{
printf("\npressed button with ID=%d control=%d",(int)control->ctrl_ID,(int)control);
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_button_data_t button_data;
gui_button_t *button;
gui_scrolled_window_data_t scroll_win_data;
gui_scrolled_window_t *ScrollWin;
int i,j;
static char txt[20];
//load libGUI library
LoadLibGUI(NULL);
//create main window
window=CreateWindow();
//change size of window
SetWindowSizeRequest(window,270,282);
//create scrolled window
scroll_win_data.x=5;
scroll_win_data.y=5;
scroll_win_data.width=250;
scroll_win_data.height=250;
ScrollWin=CreateScrolledWindow(&scroll_win_data);
//create buttons
for(j=1;j<=10;j++)
{
for(i=1;i<=10;i++)
{
button_data.x=10+(i-1)*75;
button_data.y=10+(j-1)*25;
button_data.width=70;
button_data.height=20;
snprintf(txt,20,"(%d,%d)",j,i);
button=CreateButtonWithText(&button_data,txt);
SetCallbackFunction(button,BUTTON_PRESSED_EVENT,&callback_func,NULL);
ScrolledWindowPackControls(ScrollWin,button);
}
}
//set callback function for button close window
SetCallbackFunction(window,DELETE_EVENT,&callback_func_delete_window,NULL);
//pack scrolled window in window
PackControls(window,ScrollWin);
//start main libGUI loop
LibGUImain(window);
}

45
programs/develop/new libGUI_C/examples/src/text.c Normal file
View File

@ -0,0 +1,45 @@
/*
hello world example
*/
#include "libGUI.h"
#define TRUE 1
#define FALSE 0
void callback_func_delete_window(header_t *control,void *data)
{
QuitLibGUI((parent_t*)control);
}
int main(int argc, char *argv[])
{
parent_t *window;
gui_text_data_t txtdata;
gui_text_t *text;
//load libGUI library
LoadLibGUI(NULL);//load from default system path to library
//create main window
window=CreateWindow();
//change size of window
SetWindowSizeRequest(window,92,46);
//set callback function for button close window
SetCallbackFunction(window,DELETE_EVENT,&callback_func_delete_window,NULL);
//create control text
txtdata.x=5;
txtdata.y=5;
txtdata.font=NULL;//use default system libGUI font
txtdata.background=TRUE;//use background for text
txtdata.color=0xffffff;//text color
txtdata.background_color=0xff8000;//background color
txtdata.text="Hello world!";
text=CreateText(&txtdata);
//pack control text in window
PackControls(window,text);
//start libGUI main loop
LibGUImain(window);
}