| /programs/develop/new libGUI_C/SDK/MinGW(windows)/libGUI.c |
|---|
| 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"); |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SDK/MinGW(windows)/libGUI.h |
|---|
| 0,0 → 1,592 |
| /* |
| 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 |
| + |
| +}; |
| +#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); |
| + |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SDK/gcc(unix)/libGUI.c |
|---|
| 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); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SDK/gcc(unix)/libGUI.h |
|---|
| 0,0 → 1,590 |
| /* |
| 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 |
| + |
| +}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); |
| + |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/compilation/MinGW/Makefile |
|---|
| 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) |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/compilation/MinGW/build.bat |
|---|
| 0,0 → 1,2 |
| gcc -c -O2 -nostdinc -nostdlib -march=pentium -fomit-frame-pointer -fno-builtin -o libGUI.obj libGUI.c |
| @pause |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_button.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_button.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_image.h |
|---|
| ___________________________________________________________________ |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_image.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_progress_bar.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_progress_bar.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_scroll_bar.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_scroll_bar.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_scrolled_window.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_scrolled_window.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_text.h |
|---|
| 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; |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/control_text.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/draw_controls.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/draw_controls.inc |
|---|
| 0,0 → 1,2139 |
| /* |
| function for draw controls |
| */ |
| //--------------------------------------------------------------------------------- |
| // fill buffer by value |
| //--------------------------------------------------------------------------------- |
| void FillArrea(void *buf,DWORD size,BYTE bits_per_pixel,DWORD value) |
| { |
| DWORD i,j; |
| char r,g,b; |
| switch(bits_per_pixel) |
| { |
| case 32: |
| { |
| j=(size >> 2)+4; |
| for(i=0;i<j;i++) |
| { |
| *(DWORD*)buf=(DWORD)value; |
| buf=(DWORD*)buf+1; |
| } |
| break; |
| } |
| case 24: |
| { |
| b=value & 0xff; |
| value=value >> 8; |
| g=value & 0xff; |
| value=value >> 8; |
| r=value & 0xff; |
| j=(size/3)+3; |
| for(i=0;i<j;i++) |
| { |
| *(char*)buf=(char)b; |
| *((char*)buf+1)=(char)g; |
| *((char*)buf+2)=(char)r; |
| buf=(char*)buf+3; |
| } |
| break; |
| } |
| case 16: |
| { |
| break; |
| } |
| case 8: |
| { |
| break; |
| } |
| case 4: |
| { |
| break; |
| } |
| default: break; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // draw pixel on screen |
| //--------------------------------------------------------------------------------- |
| void DrawPixel(int x,int y,DWORD color) |
| { |
| char r,g,b; |
| char *ptr; |
| DWORD *ptr2; |
| if (x>screen.size_x-1) {x=screen.size_x-1;} |
| if (y>screen.size_y-1) {y=screen.size_y-1;} |
| if (x<0) {x=0;} |
| if (y<0) {y=0;} |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x+=screen.x; |
| y+=screen.y; |
| gui_ksys_put_pixel_window(x,y,color); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| ptr=screen.buffer; |
| switch(screen.bits_per_pixel) |
| { |
| case 24: |
| { |
| ptr=ptr+(y*screen.size_x+x)*3; |
| b=color & 0xff; |
| color=color >>8; |
| g=color & 0xff; |
| color=color >>8; |
| r=color & 0xff; |
| ptr[0]=b; |
| ptr[1]=g; |
| ptr[2]=r; |
| break; |
| } |
| case 32: |
| { |
| ptr2=(DWORD*)ptr+y*screen.size_x+x; |
| *ptr2=color; |
| break; |
| } |
| default: break; |
| } |
| break; |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing pixels on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawPixelFinit(struct FINITION *fin,int x,int y,DWORD color) |
| { |
| if (x>=fin->x && x<=fin->x+fin->sizex-1 && |
| y>=fin->y && y<=fin->y+fin->sizey-1) DrawPixel(x,y,color); |
| } |
| //--------------------------------------------------------------------------------- |
| // get color of pixel inc coordinates x,y |
| //--------------------------------------------------------------------------------- |
| DWORD GetColorPixel(int x,int y) |
| { |
| char r,g,b; |
| char *ptr; |
| DWORD color,coordinates; |
| DWORD *ptr2; |
| if (x>screen.size_x-1) {x=screen.size_x-1;} |
| if (y>screen.size_y-1) {y=screen.size_y-1;} |
| if (x<0) {x=0;} |
| if (y<0) {y=0;} |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x+=screen.x; |
| y+=screen.y; |
| coordinates=x; |
| coordinates=coordinates << 16; |
| coordinates +=y; |
| color=gui_ksys_get_color_pixel_window(coordinates); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| ptr=screen.buffer; |
| switch(screen.bits_per_pixel) |
| { |
| case 24: |
| { |
| ptr=ptr+(y*screen.size_x+x)*3; |
| color=*ptr; |
| color=color & 0xffffff; |
| break; |
| } |
| case 32: |
| { |
| ptr2=(DWORD*)ptr+y*screen.size_x+x; |
| color=*ptr2; |
| break; |
| } |
| default: break; |
| } |
| } |
| } |
| return(color); |
| } |
| //--------------------------------------------------------------------------------- |
| // draw vertical line on screen |
| //--------------------------------------------------------------------------------- |
| void DrawVerticalLine(int x,int y1,int y2,DWORD color) |
| { |
| char r,g,b; |
| char *ptr; |
| DWORD *ptr2; |
| int a,i,count; |
| if (x>screen.size_x-1) {x=screen.size_x-1;} |
| if (y1>screen.size_y-1) {y1=screen.size_y-1;} |
| if (y2>screen.size_y-1) {y2=screen.size_y-1;} |
| if (x<0) {x=0;} |
| if (y1<0) {y1=0;} |
| if (y2<0) {y2=0;} |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x+=screen.x; |
| y1+=screen.y; |
| y2+=screen.y; |
| gui_ksys_draw_line_window(x,y1,x,y2,color); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| if (y1<y2) {a=y1;count=y2-y1;} |
| else |
| {a=y2;count=y1-y2;} |
| ptr=screen.buffer; |
| switch(screen.bits_per_pixel) |
| { |
| case 24: |
| { |
| ptr=ptr+(a*screen.size_x+x)*3; |
| b=color & 0xff; |
| color=color >>8; |
| g=color & 0xff; |
| color=color >>8; |
| r=color & 0xff; |
| a=screen.size_x*3; |
| for(i=0;i<=count;i++) |
| { |
| ptr[0]=b; |
| ptr[1]=g; |
| ptr[2]=r; |
| ptr+=a; |
| } |
| break; |
| } |
| case 32: |
| { |
| ptr2=(DWORD*)ptr+a*screen.size_x+x; |
| a=screen.size_x; |
| for(i=0;i<=count;i++) |
| { |
| *ptr2=color; |
| ptr2+=a; |
| } |
| break; |
| } |
| default: break; |
| } |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // draw finited vertical line on screen |
| //--------------------------------------------------------------------------------- |
| void DrawVerticalLineFinit(struct FINITION *fin,int x,int y1,int y2,DWORD color) |
| { |
| int xmin,xmax,ymin,ymax,v,sy; |
| xmin=fin->x; |
| xmax=fin->x+fin->sizex-1; |
| ymin=fin->y; |
| ymax=fin->y+fin->sizey-1; |
| if (y2<y1) |
| { |
| v=y1; |
| y1=y2; |
| y2=v; |
| } |
| if (x<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y1>ymax) return; |
| //finit x coordinates and sizex |
| sy=y1-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y1=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| DrawVerticalLine(x,y1,y2,color); |
| } |
| //--------------------------------------------------------------------------------- |
| // draw horizontal line on screen |
| //--------------------------------------------------------------------------------- |
| void DrawHorizontalLine(int x1,int x2,int y,DWORD color) |
| { |
| char r,g,b; |
| char *ptr; |
| int a,i,count; |
| DWORD *ptr2; |
| if (y>screen.size_y-1) {y=screen.size_y-1;} |
| if (x1>screen.size_x-1) {x1=screen.size_x-1;} |
| if (x2>screen.size_x-1) {x2=screen.size_x-1;} |
| if (y<0) {y=0;} |
| if (x1<0) {x1=0;} |
| if (x2<0) {x2=0;} |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x1+=screen.x; |
| x2+=screen.x; |
| y+=screen.y; |
| gui_ksys_draw_line_window(x1,y,x2,y,color); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| if (x1<x2) {a=x1;count=x2-x1;} |
| else |
| {a=x2;count=x1-x2;} |
| ptr=screen.buffer; |
| switch(screen.bits_per_pixel) |
| { |
| case 24: |
| { |
| ptr=ptr+(y*screen.size_x+a)*3; |
| b=color & 0xff; |
| color=color >>8; |
| g=color & 0xff; |
| color=color >>8; |
| r=color & 0xff; |
| for(i=0;i<=count;i++) |
| { |
| ptr[0]=b; |
| ptr[1]=g; |
| ptr[2]=r; |
| ptr=ptr+3; |
| } |
| break; |
| } |
| case 32: |
| { |
| ptr2=(DWORD*)ptr+y*screen.size_x+a; |
| for(i=0;i<=count;i++) |
| { |
| *ptr2=color;ptr2++; |
| } |
| break; |
| } |
| default:break; |
| } |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // draw finited vertical line on screen |
| //--------------------------------------------------------------------------------- |
| void DrawHorizontalLineFinit(struct FINITION *fin,int x1,int x2,int y,DWORD color) |
| { |
| int xmin,xmax,ymin,ymax,v,sx; |
| xmin=fin->x; |
| xmax=fin->x+fin->sizex-1; |
| ymin=fin->y; |
| ymax=fin->y+fin->sizey-1; |
| if (x2<x1) |
| { |
| v=x1; |
| x1=x2; |
| x2=v; |
| } |
| if (y<ymin) return; |
| if (y>ymax) return; |
| if (x2<xmin) return; |
| if (x1>xmax) return; |
| //finit x coordinates and sizex |
| sx=x1-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x1=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| DrawHorizontalLine(x1,x2,y,color); |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing line on screen |
| //--------------------------------------------------------------------------------- |
| int sign(int value) |
| { |
| if (value==0) return(0); |
| if (value<0) {return(-1);} |
| else {return(1);} |
| } |
| int abs(int value) |
| { |
| if (value<0) {value=-value;} |
| return(value); |
| } |
| void DrawLine(int x1, int y1, int x2, int y2,DWORD color) |
| { |
| int x; |
| int y; |
| int dx; |
| int dy; |
| int sx; |
| int sy; |
| int z; |
| int e; |
| int i; |
| char ch; |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| if (y1>screen.size_y-1) {y1=screen.size_y-1;} |
| if (y2>screen.size_y-1) {y2=screen.size_y-1;} |
| if (x1>screen.size_x-1) {x1=screen.size_x-1;} |
| if (x2>screen.size_x-1) {x2=screen.size_x-1;} |
| if (y1<0) {y1=0;} |
| if (y2<0) {y2=0;} |
| if (x1<0) {x1=0;} |
| if (x2<0) {x2=0;} |
| x1+=screen.x; |
| x2+=screen.x; |
| y1+=screen.y; |
| y2+=screen.y; |
| gui_ksys_draw_line_window(x1,y1,x2,y2,color); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| x = x1; |
| y = y1; |
| dx = abs(x2-x1); |
| dy = abs(y2-y1); |
| sx = sign(x2-x1); |
| sy = sign(y2-y1); |
| if( dx==0 && dy==0 ) |
| { |
| DrawPixel(x1, y1,color); |
| return; |
| } |
| if( dy>dx ) |
| { |
| z = dx; |
| dx = dy; |
| dy = z; |
| ch = 1; |
| } |
| else |
| { |
| ch = 0; |
| } |
| e = 2*dy-dx; |
| i = 1; |
| do |
| { |
| DrawPixel(x,y,color); |
| while(e>=0) |
| { |
| if( ch==1 ) x = x+sx; |
| else y = y+sy; |
| if( ch==1 ) y = y+sy; |
| else x = x+sx; |
| e = e-2*dx; |
| } |
| if( ch==1 ) y = y+sy; |
| else x = x+sx; |
| e = e+2*dy; |
| i++; |
| } |
| while(i<=dx); |
| DrawPixel(x, y,color); |
| break; |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing rectangle on screen |
| //--------------------------------------------------------------------------------- |
| void DrawRectangle(int x,int y,int size_x,int size_y,DWORD color) |
| { |
| if (size_x==0 || size_y==0) return; |
| DrawHorizontalLine(x,x+size_x-1,y,color); |
| DrawVerticalLine(x+size_x-1,y,y+size_y-1,color); |
| DrawHorizontalLine(x,x+size_x-1,y+size_y-1,color); |
| DrawVerticalLine(x,y,y+size_y-1,color); |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing finited rectangle on screen |
| //--------------------------------------------------------------------------------- |
| void DrawRectangleFinit(struct FINITION *fin,int x,int y,int size_x,int size_y,DWORD color) |
| { |
| if (size_x==0 || size_y==0) return; |
| DrawHorizontalLineFinit(fin,x,x+size_x-1,y,color); |
| DrawVerticalLineFinit(fin,x+size_x-1,y,y+size_y-1,color); |
| DrawHorizontalLineFinit(fin,x,x+size_x-1,y+size_y-1,color); |
| DrawVerticalLineFinit(fin,x,y,y+size_y-1,color); |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled rectangle on screen |
| //--------------------------------------------------------------------------------- |
| void DrawFilledRectangle(int x,int y,int size_x,int size_y,DWORD color) |
| { |
| int i,j; |
| int x1,y1,x2,y2; |
| if (size_x==0 || size_y==0) return; |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x1=x; |
| y1=y; |
| x2=x+size_x-1; |
| y2=y+size_y-1; |
| if (y1>screen.size_y-1) {y1=screen.size_y-1;} |
| if (y2>screen.size_y-1) {y2=screen.size_y-1;} |
| if (x1>screen.size_x-1) {x1=screen.size_x-1;} |
| if (x2>screen.size_x-1) {x2=screen.size_x-1;} |
| if (y1<0) {y1=0;} |
| if (y2<0) {y2=0;} |
| if (x1<0) {x1=0;} |
| if (x2<0) {x2=0;} |
| size_x=x2-x1+1; |
| size_y=y2-y1+1; |
| x1+=screen.x; |
| y1+=screen.y; |
| gui_ksys_draw_filled_rectangle_window(x1,y1,size_x,size_y,color); |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| j=y; |
| for(i=0;i<size_y;i++) |
| { |
| DrawHorizontalLine(x,x+size_x-1,j,color); |
| j++; |
| } |
| break; |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled gradient up and down rectangles on screen |
| //--------------------------------------------------------------------------------- |
| void DrawGradientUpDownFilledRectangle(char flag_up,int x,int y,int sizex,int sizey,DWORD color_from,DWORD color_to) |
| { |
| unsigned char r_f,g_f,b_f; |
| unsigned char r_t,g_t,b_t; |
| unsigned char r,g,b; |
| float f_r,f_g,f_b; |
| float d_r,d_g,d_b; |
| float div; |
| DWORD color; |
| int i,j,dj; |
| if (sizex==0 || sizey==0) return; |
| color=color_from; |
| b_f=color & 0xff; |
| color=color >> 8; |
| g_f=color & 0xff; |
| color=color >> 8; |
| r_f=color & 0xff; |
| color=color_to; |
| b_t=color & 0xff; |
| color=color >> 8; |
| g_t=color & 0xff; |
| color=color >> 8; |
| r_t=color & 0xff; |
| div=sizey-1; |
| d_r=(float)(r_t-r_f); |
| d_r=d_r/div; |
| d_g=(float)(g_t-g_f); |
| d_g=d_g/div; |
| d_b=(float)(b_t-b_f); |
| d_b=d_b/div; |
| f_r=r_f; |
| f_g=g_f; |
| f_b=b_f; |
| r=r_f; |
| g=g_f; |
| b=b_f; |
| if (flag_up==TRUE) |
| { |
| j=y+sizey-1; |
| dj=-1; |
| } |
| else |
| { |
| j=y; |
| dj=1; |
| } |
| for(i=0;i<sizey;i++) |
| { |
| color=0; |
| color=color | r; |
| color=color << 8; |
| color=color | g; |
| color=color << 8; |
| color=color | b; |
| DrawHorizontalLine(x,x+sizex-1,j,color); |
| f_r=f_r+d_r; |
| f_g=f_g+d_g; |
| f_b=f_b+d_b; |
| r=(char)f_r; |
| g=(char)f_g; |
| b=(char)f_b; |
| j=j+dj; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled gradient left and right rectangles on screen |
| //--------------------------------------------------------------------------------- |
| void DrawGradientLeftRightFilledRectangle(char flag_left,int x,int y,int sizex,int sizey,DWORD color_from,DWORD color_to) |
| { |
| unsigned char r_f,g_f,b_f; |
| unsigned char r_t,g_t,b_t; |
| unsigned char r,g,b; |
| float f_r,f_g,f_b; |
| float d_r,d_g,d_b; |
| float div; |
| DWORD color; |
| int i,j,dj; |
| if (sizex==0 || sizey==0) return; |
| color=color_from; |
| b_f=color & 0xff; |
| color=color >> 8; |
| g_f=color & 0xff; |
| color=color >> 8; |
| r_f=color & 0xff; |
| color=color_to; |
| b_t=color & 0xff; |
| color=color >> 8; |
| g_t=color & 0xff; |
| color=color >> 8; |
| r_t=color & 0xff; |
| div=sizex-1; |
| d_r=(float)(r_t-r_f); |
| d_r=d_r/div; |
| d_g=(float)(g_t-g_f); |
| d_g=d_g/div; |
| d_b=(float)(b_t-b_f); |
| d_b=d_b/div; |
| f_r=r_f; |
| f_g=g_f; |
| f_b=b_f; |
| r=r_f; |
| g=g_f; |
| b=b_f; |
| if (flag_left==TRUE) |
| { |
| j=x; |
| dj=1; |
| } |
| else |
| { |
| j=x+sizex-1; |
| dj=-1; |
| } |
| for(i=0;i<sizex;i++) |
| { |
| color=0; |
| color=color | r; |
| color=color << 8; |
| color=color | g; |
| color=color << 8; |
| color=color | b; |
| DrawVerticalLine(j,y,y+sizey-1,color); |
| f_r=f_r+d_r; |
| f_g=f_g+d_g; |
| f_b=f_b+d_b; |
| r=(char)f_r; |
| g=(char)f_g; |
| b=(char)f_b; |
| j=j+dj; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing circle on screen |
| //--------------------------------------------------------------------------------- |
| void DrawCircle(int xc, int yc, int r,DWORD color) |
| { |
| int x; |
| int y; |
| int d; |
| x = 0; |
| y = r; |
| d = 3-2*r; |
| while(y>=x) |
| { |
| DrawPixel(x+xc,y+yc,color); |
| DrawPixel(x+xc,-y+yc,color); |
| DrawPixel(-x+xc,y+yc,color); |
| DrawPixel(-x+xc,-y+yc,color); |
| DrawPixel(y+xc,x+yc,color); |
| DrawPixel(y+xc,-x+yc,color); |
| DrawPixel(-y+xc,x+yc,color); |
| DrawPixel(-y+xc,-x+yc,color); |
| if( d<0 ) |
| { |
| d = d+4*x+6; |
| } |
| else |
| { |
| d = d+4*(x-y)+10; |
| y--; |
| } |
| x++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing circle on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawCircleFinit(struct FINITION *fin,int xc, int yc, int r,DWORD color) |
| { |
| int x; |
| int y; |
| int d; |
| x = 0; |
| y = r; |
| d = 3-2*r; |
| while(y>=x) |
| { |
| DrawPixelFinit(fin,x+xc,y+yc,color); |
| DrawPixelFinit(fin,x+xc,-y+yc,color); |
| DrawPixelFinit(fin,-x+xc,y+yc,color); |
| DrawPixelFinit(fin,-x+xc,-y+yc,color); |
| DrawPixelFinit(fin,y+xc,x+yc,color); |
| DrawPixelFinit(fin,y+xc,-x+yc,color); |
| DrawPixelFinit(fin,-y+xc,x+yc,color); |
| DrawPixelFinit(fin,-y+xc,-x+yc,color); |
| if( d<0 ) |
| { |
| d = d+4*x+6; |
| } |
| else |
| { |
| d = d+4*(x-y)+10; |
| y--; |
| } |
| x++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled circle on screen |
| //--------------------------------------------------------------------------------- |
| void DrawFilledCircle(int xc, int yc, int r,DWORD color) |
| { |
| int xl,yu,xr,yd; |
| int i,j; |
| DWORD pixcolor; |
| DrawCircle(xc,yc,r,color); |
| yu=yc; |
| yd=yc; |
| for(i=0;i<r;i++) |
| { |
| xl=xc; |
| xr=xc+1; |
| j=0; |
| //fill left up |
| while((pixcolor=GetColorPixel(xl,yu))!=color) |
| { |
| DrawPixel(xl,yu,color); |
| xl--; |
| j++; |
| if (j>r) break; |
| } |
| j=0; |
| //fill right up |
| while((pixcolor=GetColorPixel(xr,yu))!=color) |
| { |
| DrawPixel(xr,yu,color); |
| xr++; |
| j++; |
| if (j>r) break; |
| } |
| xl=xc; |
| xr=xc+1; |
| j=0; |
| //fill left down |
| while((pixcolor=GetColorPixel(xl,yd))!=color) |
| { |
| DrawPixel(xl,yd,color); |
| xl--; |
| j++; |
| if (j>r) break; |
| } |
| j=0; |
| //fill right down |
| while((pixcolor=GetColorPixel(xr,yd))!=color) |
| { |
| DrawPixel(xr,yd,color); |
| xr++; |
| j++; |
| if (j>r) break; |
| } |
| yu--; |
| yd++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled circle on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawFilledCircleFinit(struct FINITION *fin,int xc, int yc, int r,DWORD color) |
| { |
| int xl,yu,xr,yd; |
| int i,j; |
| DWORD pixcolor; |
| DrawCircleFinit(fin,xc,yc,r,color); |
| yu=yc; |
| yd=yc; |
| for(i=0;i<r;i++) |
| { |
| xl=xc; |
| xr=xc+1; |
| //fill left up |
| for(j=0;j<r;j++) |
| { |
| if (xl>=fin->x && xl<=fin->x+fin->sizex && |
| yu>=fin->y && yu<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xl,yu); |
| if (pixcolor!=color) DrawPixel(xl,yu,color); |
| else break; |
| } |
| xl--; |
| } |
| //fill right up |
| for(j=0;j<r;j++) |
| { |
| if (xr>=fin->x && xr<=fin->x+fin->sizex && |
| yu>=fin->y && yu<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xr,yu); |
| if (pixcolor!=color) DrawPixel(xr,yu,color); |
| else break; |
| } |
| xr++; |
| } |
| xl=xc; |
| xr=xc+1; |
| //fill left down |
| for(j=0;j<r;j++) |
| { |
| if (xl>=fin->x && xl<=fin->x+fin->sizex && |
| yd>=fin->y && yd<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xl,yd); |
| if (pixcolor!=color) DrawPixel(xl,yd,color); |
| else break; |
| } |
| xl--; |
| } |
| //fill right down |
| for(j=0;j<r;j++) |
| { |
| if (xr>=fin->x && xr<=fin->x+fin->sizex && |
| yd>=fin->y && yd<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xr,yd); |
| if (pixcolor!=color) DrawPixel(xr,yd,color); |
| else break; |
| } |
| xr++; |
| } |
| yu--; |
| yd++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing ellipse on screen |
| //--------------------------------------------------------------------------------- |
| void DrawEllipse(int x,int y,int a,int b,DWORD color) |
| { |
| int col,i,row,bnew; |
| long a_square,b_square,two_a_square,two_b_square,four_a_square,four_b_square,d; |
| b_square=b*b; |
| a_square=a*a; |
| row=b; |
| col=0; |
| two_a_square=a_square<<1; |
| four_a_square=a_square<<2; |
| four_b_square=b_square<<2; |
| two_b_square=b_square<<1; |
| d=two_a_square*((row-1)*(row))+a_square+two_b_square*(1-a_square); |
| while(a_square*(row)>b_square*(col)) |
| { |
| DrawPixel(col+x,row+y,color); |
| DrawPixel(col+x,y-row,color); |
| DrawPixel(x-col,row+y,color); |
| DrawPixel(x-col,y-row,color); |
| if (d>=0) |
| { |
| row--; |
| d-=four_a_square*(row); |
| } |
| d+=two_b_square*(3+(col<<1)); |
| col++; |
| } |
| d=two_b_square*(col+1)*col+two_a_square*(row*(row-2)+1)+(1-two_a_square)*b_square; |
| while ((row) + 1) |
| { |
| DrawPixel(col+x, row+y, color); |
| DrawPixel(col+x, y-row, color); |
| DrawPixel(x-col, row+y, color); |
| DrawPixel(x-col, y-row, color); |
| if (d<=0) |
| { |
| col++; |
| d+=four_b_square*col; |
| } |
| row--; |
| d+=two_a_square*(3-(row <<1)); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing ellipse on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawEllipseFinit(struct FINITION *fin,int x,int y,int a,int b,DWORD color) |
| { |
| int col,i,row,bnew; |
| long a_square,b_square,two_a_square,two_b_square,four_a_square,four_b_square,d; |
| b_square=b*b; |
| a_square=a*a; |
| row=b; |
| col=0; |
| two_a_square=a_square<<1; |
| four_a_square=a_square<<2; |
| four_b_square=b_square<<2; |
| two_b_square=b_square<<1; |
| d=two_a_square*((row-1)*(row))+a_square+two_b_square*(1-a_square); |
| while(a_square*(row)>b_square*(col)) |
| { |
| DrawPixelFinit(fin,col+x,row+y,color); |
| DrawPixelFinit(fin,col+x,y-row,color); |
| DrawPixelFinit(fin,x-col,row+y,color); |
| DrawPixelFinit(fin,x-col,y-row,color); |
| if (d>=0) |
| { |
| row--; |
| d-=four_a_square*(row); |
| } |
| d+=two_b_square*(3+(col<<1)); |
| col++; |
| } |
| d=two_b_square*(col+1)*col+two_a_square*(row*(row-2)+1)+(1-two_a_square)*b_square; |
| while ((row) + 1) |
| { |
| DrawPixelFinit(fin,col+x, row+y, color); |
| DrawPixelFinit(fin,col+x, y-row, color); |
| DrawPixelFinit(fin,x-col, row+y, color); |
| DrawPixelFinit(fin,x-col, y-row, color); |
| if (d<=0) |
| { |
| col++; |
| d+=four_b_square*col; |
| } |
| row--; |
| d+=two_a_square*(3-(row <<1)); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled ellips on screen |
| //--------------------------------------------------------------------------------- |
| void DrawFilledEllipse(int xc, int yc, int a,int b,DWORD color) |
| { |
| int xl,yu,xr,yd; |
| int i,j; |
| DWORD pixcolor; |
| DrawEllipse(xc,yc,a,b,color); |
| yu=yc; |
| yd=yc; |
| for(i=0;i<b;i++) |
| { |
| xl=xc; |
| xr=xc+1; |
| j=0; |
| //fill left up |
| while((pixcolor=GetColorPixel(xl,yu))!=color) |
| { |
| DrawPixel(xl,yu,color); |
| xl--; |
| j++; |
| if (j>a) break; |
| } |
| j=0; |
| //fill right up |
| while((pixcolor=GetColorPixel(xr,yu))!=color) |
| { |
| DrawPixel(xr,yu,color); |
| xr++; |
| j++; |
| if (j>a) break; |
| } |
| xl=xc; |
| xr=xc+1; |
| j=0; |
| //fill left down |
| while((pixcolor=GetColorPixel(xl,yd))!=color) |
| { |
| DrawPixel(xl,yd,color); |
| xl--; |
| j++; |
| if (j>a) break; |
| } |
| j=0; |
| //fill right down |
| while((pixcolor=GetColorPixel(xr,yd))!=color) |
| { |
| DrawPixel(xr,yd,color); |
| xr++; |
| j++; |
| if (j>a) break; |
| } |
| yu--; |
| yd++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing filled circle on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawFilledEllipseFinit(struct FINITION *fin,int xc, int yc, int a,int b,DWORD color) |
| { |
| int xl,yu,xr,yd; |
| int i,j; |
| DWORD pixcolor; |
| DrawEllipseFinit(fin,xc,yc,a,b,color); |
| yu=yc; |
| yd=yc; |
| for(i=0;i<b;i++) |
| { |
| xl=xc; |
| xr=xc+1; |
| //fill left up |
| for(j=0;j<a;j++) |
| { |
| if (xl>=fin->x && xl<=fin->x+fin->sizex && |
| yu>=fin->y && yu<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xl,yu); |
| if (pixcolor!=color) DrawPixel(xl,yu,color); |
| else break; |
| } |
| xl--; |
| } |
| //fill right up |
| for(j=0;j<a;j++) |
| { |
| if (xr>=fin->x && xr<=fin->x+fin->sizex && |
| yu>=fin->y && yu<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xr,yu); |
| if (pixcolor!=color) DrawPixel(xr,yu,color); |
| else break; |
| } |
| xr++; |
| } |
| xl=xc; |
| xr=xc+1; |
| //fill left down |
| for(j=0;j<a;j++) |
| { |
| if (xl>=fin->x && xl<=fin->x+fin->sizex && |
| yd>=fin->y && yd<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xl,yd); |
| if (pixcolor!=color) DrawPixel(xl,yd,color); |
| else break; |
| } |
| xl--; |
| } |
| //fill right down |
| for(j=0;j<a;j++) |
| { |
| if (xr>=fin->x && xr<=fin->x+fin->sizex && |
| yd>=fin->y && yd<=fin->y+fin->sizey) |
| { |
| pixcolor=GetColorPixel(xr,yd); |
| if (pixcolor!=color) DrawPixel(xr,yd,color); |
| else break; |
| } |
| xr++; |
| } |
| yu--; |
| yd++; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing image on screen |
| //--------------------------------------------------------------------------------- |
| void DrawImage(int x,int y,int sizex,int sizey,char bits_per_pixel,char *img) |
| { |
| char r,g,b; |
| int i,j,countx,county; |
| int x2,y2; |
| DWORD pitch_src,pitch_screen,add_src,add_screen; |
| char *ptr_src,*ptr_screen,ptr_max; |
| char *ptr_src2,*ptr_screen2; |
| DWORD *ptr_src3; |
| if (img==NULL) return; |
| if (x>screen.size_x-1) return; |
| if (y>screen.size_y-1) return; |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (y2>screen.size_y-1) {y2=screen.size_y-1;} |
| if (x2>screen.size_x-1) {x2=screen.size_x-1;} |
| if (y<0) y=0; |
| if (y2<0) y2=0; |
| if (x<0) x=0; |
| if (x2<0) x2=0; |
| countx=x2-x+1; |
| county=y2-y+1; |
| switch(screen.draw_output) |
| { |
| case DRAW_OUTPUT_SCREEN: |
| { |
| x+=screen.x; |
| y+=screen.y; |
| switch(screen.bits_per_pixel) |
| { |
| case 32: |
| { |
| if (bits_per_pixel==32) |
| {//convert 32 bit image to 24 bit image |
| j=sizex*sizey; |
| ptr_src=img; |
| ptr_screen=malloc(j*3); |
| ptr_screen2=ptr_screen; |
| for(i=0;i<j;i++) |
| { |
| *(char*)ptr_screen=*(char*)ptr_src; |
| *((char*)ptr_screen+1)=*((char*)ptr_src+1); |
| *((char*)ptr_screen+2)=*((char*)ptr_src+2); |
| ptr_src+=4; |
| ptr_screen+=3; |
| } |
| gui_ksys_put_image_window(ptr_screen2,x,y,countx,county); |
| free(ptr_screen2); |
| } |
| break; |
| } |
| case 24: |
| { |
| gui_ksys_put_image_window(img,x,y,countx,county); |
| break; |
| } |
| default: break; |
| } |
| break; |
| } |
| case DRAW_OUTPUT_BUFFER: |
| { |
| switch(screen.bits_per_pixel) |
| { |
| case 24: |
| {//check source image resolution |
| switch(bits_per_pixel) |
| { |
| case 32://display 32 bit image in 24 bit mode |
| { |
| pitch_screen=screen.size_x*3; |
| pitch_src=countx << 2; |
| ptr_screen=screen.buffer+pitch_screen*y+x*3; |
| ptr_src=img; |
| add_screen=pitch_screen-pitch_src; |
| //copy line of byte with size x |
| for(i=0;i<county;i++) |
| { |
| for(j=0;j<pitch_src;j++) |
| { |
| *(char*)ptr_screen=*(char*)ptr_src; |
| ptr_src++; |
| ptr_screen++; |
| } |
| ptr_screen+=add_screen; |
| } |
| break; |
| } |
| case 24://display 24 bit image in 24 bit mode |
| { |
| pitch_screen=screen.size_x*3; |
| pitch_src=countx*3; |
| ptr_screen=screen.buffer+pitch_screen*y+x*3; |
| ptr_src=img; |
| add_screen=pitch_screen-pitch_src; |
| //copy line of byte with size x |
| for(i=0;i<county;i++) |
| { |
| for(j=0;j<pitch_src;j++) |
| { |
| *(char*)ptr_screen=*(char*)ptr_src; |
| ptr_src++; |
| ptr_screen++; |
| } |
| ptr_screen+=add_screen; |
| } |
| break; |
| } |
| default: break; |
| } |
| break; |
| } |
| case 32: |
| { //check source image resolution |
| switch(bits_per_pixel) |
| { |
| case 32://display 32 bit image in 32 bit mode |
| { |
| pitch_screen=screen.size_x << 2; |
| pitch_src=countx << 2; |
| ptr_screen=screen.buffer+pitch_screen*y+x*4; |
| ptr_src=img; |
| add_screen=pitch_screen-pitch_src; |
| //copy line of byte with size x |
| for(i=0;i<county;i++) |
| { |
| for(j=0;j<pitch_src;j++) |
| { |
| *(char*)ptr_screen=*(char*)ptr_src; |
| ptr_src++; |
| ptr_screen++; |
| } |
| ptr_screen+=add_screen; |
| } |
| break; |
| } |
| case 24://display 24 bit image in 32 bit mode |
| { |
| break; |
| } |
| default: break; |
| } |
| default: break; |
| } |
| } |
| } |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function drawing image on screen with finition |
| //--------------------------------------------------------------------------------- |
| void DrawImageFinit(finition_t *fin,int x,int y,int sizex,int sizey,char bits_per_pixel,char *img) |
| { |
| int x1,y1,x2,y2,sx,sy; |
| int xmin,xmax,ymin,ymax; |
| int countline,countx,county,i,j; |
| DWORD pitch_src,add_src; |
| char *ptr_dest,*ptr_src; |
| char bytes_per_pixel; |
| char *buf; |
| xmin=fin->x; |
| xmax=fin->x+fin->sizex-1; |
| ymin=fin->y; |
| ymax=fin->y+fin->sizey-1; |
| x1=x; |
| y1=y; |
| x2=x1+sizex-1; |
| y2=y1+sizey-1; |
| if (x2<xmin) return; |
| if (x1>xmax) return; |
| if (y2<ymin) return; |
| if (y1>ymax) return; |
| if (x1>=xmin && x2<=xmax && y1>=ymin && y2<=ymax) |
| { |
| DrawImage(x,y,sizex,sizey,bits_per_pixel,img); |
| return; |
| } |
| //finit x coordinates and sizex |
| sx=x1-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x1=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y1-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y1=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| countx=x2-x1+1; |
| county=y2-y1+1; |
| //cut finited rectangle from image and move them into buffer |
| switch(bits_per_pixel) |
| { |
| case 32: |
| case 24: |
| case 16: |
| case 8: |
| { //allocate buffer |
| bytes_per_pixel=bits_per_pixel >> 3; |
| buf=malloc(countx*county*bytes_per_pixel); |
| ptr_dest=buf; |
| pitch_src=sizex*bytes_per_pixel; |
| ptr_src=img+pitch_src*(y1-y)+(x1-x)*bytes_per_pixel; |
| add_src=(sizex-countx)*bytes_per_pixel; |
| countline=countx*bytes_per_pixel; |
| //copy line of byte with size x |
| for(i=0;i<county;i++) |
| { |
| for(j=0;j<countline;j++) |
| { |
| *(char*)ptr_dest=*(char*)ptr_src; |
| ptr_dest++; |
| ptr_src++; |
| } |
| ptr_src+=add_src; |
| } |
| break; |
| } |
| default: break; |
| } |
| //draw cutted by finition image |
| DrawImage(x1,y1,countx,county,bits_per_pixel,buf); |
| free(buf); |
| } |
| //--------------------------------------------------------------------------------- |
| // libGUI function draw |
| //--------------------------------------------------------------------------------- |
| void Draw(struct FINITION *finition,int tool_name,...) |
| { |
| va_list arguments; |
| char *img; |
| char first,second,bits_per_pixel; |
| int xmin,xmax,ymin,ymax; |
| int radius; |
| int x,y,x2,y2,x_i,y_i; |
| int sizex,sizey,sx,sy; |
| float x_l1,y_l1,x_l2,y_l2,k,b; |
| DWORD color,color_from,color_to; |
| arguments=(va_list)&tool_name+sizeof(int); |
| xmin=finition->x; |
| xmax=finition->x+finition->sizex-1; |
| ymin=finition->y; |
| ymax=finition->y+finition->sizey-1; |
| switch(tool_name) |
| { |
| //tool Pixel |
| case TOOL_PIXEL: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| if (x>=finition->x && x<=finition->x+finition->sizex |
| && y>=finition->y && y<=finition->y+finition->sizey) |
| { //pixel inside finition arrea |
| DrawPixel(x,y,color); |
| } |
| } |
| else |
| { //no finition |
| DrawPixel(x,y,color); |
| } |
| break; |
| } |
| //tool Line |
| case TOOL_LINE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| x2=va_arg(arguments,int); |
| y2=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| sizex=abs(x2-x); |
| sizey=abs(y2-y); |
| if (CheckCrossRectangles(finition->x,finition->y,finition->sizex, |
| finition->sizey,x,y,sizex,sizey)==FALSE) break; |
| if (x>=finition->x && x<=finition->x+finition->sizex && |
| y>=finition->y && y<=finition->y+finition->sizey && |
| x2>=finition->x && x2<=finition->x+finition->sizex && |
| y2>=finition->y && y2<=finition->y+finition->sizey) |
| { |
| //line inside finition arrea |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| if (x==x2) break; |
| //find coefficients of line |
| x_l1=x; |
| y_l1=y; |
| x_l2=x2; |
| y_l2=y2; |
| k=(y_l1-y_l2)/(x_l1-x_l2); |
| b=(y_l2*x_l1-y_l1*x_l2)/(x_l1-x_l2); |
| sx=x2-x;//vectore x |
| sy=y2-y;//vectore y |
| if (x>=finition->x && x<=finition->x+finition->sizex && |
| y>=finition->y && y<=finition->y+finition->sizey) |
| { //point x,y inside finition arrea |
| //check cross with left vertical line of finition |
| y_l1=k*finition->x+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx<0) |
| { //first point for finited line |
| x2=finition->x; |
| y2=y_i; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with up horizontal line of finition |
| x_l1=(finition->y-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy<0) |
| { |
| x2=x_i; |
| y2=finition->y; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with right vertical line of finition |
| y_l1=k*(finition->x+finition->sizex)+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx>0) |
| { |
| x2=finition->x+finition->sizex; |
| y2=y_i; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with down horizontal line of finition |
| x_l1=((finition->y+finition->sizey)-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy>0) |
| { |
| x2=x_i; |
| y2=finition->y+finition->sizey; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| } |
| if (x2>=finition->x && x2<=finition->x+finition->sizex && |
| y2>=finition->y && y2<=finition->y+finition->sizey) |
| { //point x,y inside finition arrea |
| //check cross with left vertical line of finition |
| y_l1=k*finition->x+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx>0) |
| { //first point for finited line |
| x=finition->x; |
| y=y_i; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with up horizontal line of finition |
| x_l1=(finition->y-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy>0) |
| { |
| x=x_i; |
| y=finition->y; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with right vertical line of finition |
| y_l1=k*(finition->x+finition->sizex)+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey && sx<0) |
| { |
| x=finition->x+finition->sizex; |
| y=y_i; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| //check cross with down horizontal line of finition |
| x_l1=((finition->y+finition->sizey)-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex && sy<0) |
| { |
| x=x_i; |
| y=finition->y+finition->sizey; |
| DrawLine(x,y,x2,y2,color); |
| break; |
| } |
| } |
| first=FALSE; |
| second=FALSE; |
| //check cross with left vertical line of finition |
| y_l1=k*finition->x+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey) |
| { //first point for finited line |
| x=finition->x; |
| y=y_i; |
| first=TRUE; |
| } |
| //check cross with up horizontal line of finition |
| x_l1=(finition->y-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex) |
| { |
| if (first==FALSE) |
| { |
| x=x_i; |
| y=finition->y; |
| } |
| else |
| { |
| x2=x_i; |
| y2=finition->y; |
| second=TRUE; |
| } |
| } |
| //check cross with right vertical line of finition |
| y_l1=k*(finition->x+finition->sizex)+b; |
| y_i=(int)y_l1; |
| if (y_i>=finition->y && y_i<=finition->y+finition->sizey) |
| { |
| if (first==FALSE) |
| { |
| x=finition->x+finition->sizex; |
| y=y_i; |
| } |
| else |
| { |
| x2=finition->x+finition->sizex; |
| y2=y_i; |
| second=TRUE; |
| } |
| } |
| //check cross with down horizontal line of finition |
| x_l1=((finition->y+finition->sizey)-b)/k; |
| x_i=(int)x_l1; |
| if (x_i>=finition->x && x_i<=finition->x+finition->sizex) |
| { |
| if (first==FALSE) |
| { |
| x=x_i; |
| y=finition->y+finition->sizey; |
| } |
| else |
| { |
| x2=x_i; |
| y2=finition->y+finition->sizey; |
| second=TRUE; |
| } |
| } |
| if (first==TRUE && second==TRUE) |
| { |
| //draw finited line |
| DrawLine(x,y,x2,y2,color); |
| } |
| break; |
| } |
| else |
| { //no finition |
| DrawLine(x,y,x2,y2,color); |
| } |
| break; |
| } |
| //tool VerticalLine |
| case TOOL_VERTICAL_LINE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| y2=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawVerticalLineFinit(finition,x,y,y2,color); |
| } |
| else |
| { |
| DrawVerticalLine(x,y,y2,color); |
| } |
| break; |
| } |
| //tool HorizontalLine |
| case TOOL_HORIZONTAL_LINE: |
| { |
| x=va_arg(arguments,int); |
| x2=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawHorizontalLineFinit(finition,x,x2,y,color); |
| } |
| else |
| { |
| DrawHorizontalLine(x,x2,y,color); |
| } |
| break; |
| } |
| //tool Rectangle |
| case TOOL_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| DrawRectangleFinit(finition,x,y,sizex,sizey,color); |
| } |
| else |
| { |
| DrawRectangle(x,y,sizex,sizey,color); |
| } |
| break; |
| } |
| //tool FilledRectangle |
| case TOOL_FILLED_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| sizex=x2-x+1; |
| sizey=y2-y+1; |
| DrawFilledRectangle(x,y,sizex,sizey,color); |
| } |
| else |
| { |
| DrawFilledRectangle(x,y,sizex,sizey,color); |
| } |
| break; |
| } |
| //tool GradientUpFilledRectangle |
| case TOOL_GRADIENT_UP_FILLED_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color_from=va_arg(arguments,DWORD); |
| color_to=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| sizex=x2-x+1; |
| sizey=y2-y+1; |
| DrawGradientUpDownFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to); |
| } |
| else |
| { |
| DrawGradientUpDownFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to); |
| } |
| break; |
| } |
| //tool GradientDownFilledRectangle |
| case TOOL_GRADIENT_DOWN_FILLED_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color_from=va_arg(arguments,DWORD); |
| color_to=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| sizex=x2-x+1; |
| sizey=y2-y+1; |
| DrawGradientUpDownFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to); |
| } |
| else |
| { |
| DrawGradientUpDownFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to); |
| } |
| break; |
| } |
| //tool GradientLeftFilledRectangle |
| case TOOL_GRADIENT_LEFT_FILLED_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color_from=va_arg(arguments,DWORD); |
| color_to=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| sizex=x2-x+1; |
| sizey=y2-y+1; |
| DrawGradientLeftRightFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to); |
| } |
| else |
| { |
| DrawGradientLeftRightFilledRectangle(TRUE,x,y,sizex,sizey,color_from,color_to); |
| } |
| break; |
| } |
| //tool GradientRightFilledRectangle |
| case TOOL_GRADIENT_RIGHT_FILLED_RECTANGLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color_from=va_arg(arguments,DWORD); |
| color_to=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| x2=x+sizex-1; |
| y2=y+sizey-1; |
| if (x2<xmin) return; |
| if (x>xmax) return; |
| if (y2<ymin) return; |
| if (y>ymax) return; |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| sizex=x2-x+1; |
| sizey=y2-y+1; |
| DrawGradientLeftRightFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to); |
| } |
| else |
| { |
| DrawGradientLeftRightFilledRectangle(FALSE,x,y,sizex,sizey,color_from,color_to); |
| } |
| break; |
| } |
| //tool Circle |
| case TOOL_CIRCLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| radius=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawCircleFinit(finition,x,y,radius,color); |
| } |
| else |
| { |
| DrawCircle(x,y,radius,color); |
| } |
| break; |
| } |
| //tool FilledCircle |
| case TOOL_FILLED_CIRCLE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| radius=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawFilledCircleFinit(finition,x,y,radius,color); |
| } |
| else |
| { |
| DrawFilledCircle(x,y,radius,color); |
| } |
| break; |
| } |
| //tool Ellipse |
| case TOOL_ELLIPSE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawEllipseFinit(finition,x,y,sizex,sizey,color); |
| } |
| else |
| { |
| DrawEllipse(x,y,sizex,sizey,color); |
| } |
| break; |
| } |
| //tool FilledEllipse |
| case TOOL_FILLED_ELLIPSE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| color=va_arg(arguments,DWORD); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawFilledEllipseFinit(finition,x,y,sizex,sizey,color); |
| } |
| else |
| { |
| DrawFilledEllipse(x,y,sizex,sizey,color); |
| } |
| break; |
| } |
| //tool Image |
| case TOOL_IMAGE: |
| { |
| x=va_arg(arguments,int); |
| y=va_arg(arguments,int); |
| sizex=va_arg(arguments,int); |
| sizey=va_arg(arguments,int); |
| bits_per_pixel=(char)va_arg(arguments,int); |
| img=va_arg(arguments,char*); |
| if (finition->flags & FINITION_ON) |
| { |
| DrawImageFinit(finition,x,y,sizex,sizey,bits_per_pixel,img); |
| } |
| else |
| { |
| DrawImage(x,y,sizex,sizey,bits_per_pixel,img); |
| } |
| break; |
| } |
| } |
| va_end(arguments); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/fonts_meneger.h |
|---|
| 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); |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/fonts_meneger.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/keys.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/kolibri_system.h |
|---|
| 0,0 → 1,658 |
| /* |
| 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__( |
| + :"=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)); |
| +} |
| + |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/kolibri_system.inc |
|---|
| 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; |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/libGUI.c |
|---|
| 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}, |
| }; |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/libGUI.h |
|---|
| 0,0 → 1,581 |
| /* |
| 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 |
| + |
| +}; |
| +#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); |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/libGUI_menegement.inc |
|---|
| 0,0 → 1,1642 |
| /* |
| libGUI main part of code |
| */ |
| //--------------------------------------------------------------------------------- |
| // destroy_control for libGUI |
| //--------------------------------------------------------------------------------- |
| void DestroyControl(void *control_ptr) |
| { |
| struct HEADER *Parent; |
| struct HEADER *control; |
| struct HEADER *seek_control; |
| struct HEADER *exchange_control; |
| struct HEADER *last_control; |
| struct HEADER *next_control; |
| if (control_ptr==NULL) return; |
| control=control_ptr; |
| Parent=(struct HEADER *)control->parent; |
| if (Parent->child_bk==Parent->child_fd) |
| { |
| //parent have got alone child control |
| if (Parent->child_bk==(DWORD*)control) |
| { |
| //current control is child control of parent |
| #ifdef DEBUG |
| printf("\ndestroyed control=%d parent=%d ID=%d",(int)control,(int)Parent,(int)control->ctrl_ID); |
| #endif |
| free(control); |
| Parent->child_bk=(DWORD*)NULL; |
| Parent->child_fd=(DWORD*)NULL; |
| } |
| return; |
| } |
| seek_control=(struct HEADER*)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (seek_control==control) |
| { |
| //delete control from control's stack |
| last_control=(struct HEADER*)seek_control->ctrl_bk; |
| next_control=(struct HEADER*)seek_control->ctrl_fd; |
| if ((last_control!=Parent) && (next_control!=NULL)) |
| {//deliting control isn't first control and isn't endest of parent |
| next_control->ctrl_bk=(DWORD*)last_control; |
| last_control->ctrl_fd=(DWORD*)next_control; |
| } |
| else |
| { |
| if (last_control==Parent) |
| {//deliting control is first control of Parend |
| Parent->child_bk=(DWORD*)next_control; |
| next_control->ctrl_bk=(DWORD*)Parent; |
| if (next_control->ctrl_fd==(DWORD*)NULL) |
| { |
| Parent->child_fd=(DWORD*)next_control; |
| Parent->child_bk=(DWORD*)next_control; |
| } |
| } |
| if (next_control==(struct HEADER*)NULL) |
| { |
| //there isn't next controls |
| last_control->ctrl_fd=(DWORD*)NULL; |
| Parent->ctrl_fd=(DWORD*)last_control; |
| } |
| } |
| #ifdef DEBUG |
| printf("\ndestroyed control=%d parent=%d ID=%d",(int)control,(int)Parent,(int)control->ctrl_ID); |
| #endif |
| free(control); |
| break; |
| } |
| exchange_control=(struct HEADER*)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // create new timer for parent window |
| //--------------------------------------------------------------------------------- |
| void *CreateTimerForParentWindow(parent_t *parent) |
| { |
| struct TIMER *timer; |
| struct TIMER *backward_timer; |
| timer=malloc(sizeof(struct TIMER)); |
| timer->tmr_parent=(DWORD*)parent; |
| if (parent->timer_bk==(DWORD*)NULL) |
| {//not yet timers |
| parent->timer_bk=(DWORD*)timer; |
| parent->timer_fd=(DWORD*)timer; |
| timer->tmr_bk=(DWORD*)parent; |
| timer->tmr_fd=(DWORD*)NULL; |
| } |
| else |
| { |
| backward_timer=(struct TIMER*)parent->timer_fd; |
| parent->timer_fd=(DWORD*)timer; |
| backward_timer->tmr_fd=(DWORD*)timer; |
| timer->tmr_bk=(DWORD*)backward_timer; |
| timer->tmr_fd=(DWORD*)NULL; |
| } |
| return(timer); |
| } |
| //--------------------------------------------------------------------------------- |
| // destroy timer for parent window |
| //--------------------------------------------------------------------------------- |
| void DestroyTimerCallbackForFunction(struct TIMER *timer) |
| { |
| struct HEADERPARENT *Parent; |
| struct TIMER *seek_timer; |
| struct TIMER *exchange_timer; |
| struct TIMER *last_timer; |
| struct TIMER *next_timer; |
| if (timer==(struct TIMER*)NULL) return; |
| Parent=(struct HEADERPARENT *)timer->tmr_parent; |
| if (Parent->timer_bk==Parent->timer_fd) |
| { |
| //parent have got alone timer |
| if (Parent->timer_bk==(DWORD*)timer) |
| { |
| Parent->timer_bk=(DWORD*)NULL; |
| Parent->timer_fd=(DWORD*)NULL; |
| #ifdef DEBUG |
| printf("\ndestroyed timer %d parent window %d",(int)timer,(int)timer->tmr_parent); |
| #endif |
| free(timer); |
| return; |
| } |
| return; |
| } |
| seek_timer=(struct TIMER*)Parent->timer_bk; |
| while(seek_timer!=(struct TIMER*)NULL) |
| { |
| if (seek_timer==timer) |
| { |
| //delete timer from timers's stack |
| last_timer=(struct TIMER*)seek_timer->tmr_bk; |
| next_timer=(struct TIMER*)seek_timer->tmr_fd; |
| if ((last_timer!=(struct TIMER*)Parent) && (next_timer!=(struct TIMER*)NULL)) |
| {//deliting timer isn't first timer and isn't endest |
| next_timer->tmr_bk=(DWORD*)last_timer; |
| last_timer->tmr_fd=(DWORD*)next_timer; |
| } |
| else |
| { |
| if (last_timer==(struct TIMER*)Parent) |
| {//deliting timer is first timer of Parend |
| Parent->timer_bk=(DWORD*)next_timer; |
| next_timer->tmr_bk=(DWORD*)Parent; |
| if (next_timer->tmr_fd==(DWORD*)NULL) |
| { |
| Parent->timer_fd=(DWORD*)next_timer; |
| Parent->timer_bk=(DWORD*)next_timer; |
| } |
| } |
| if (next_timer==(struct TIMER*)NULL) |
| { |
| //there isn't next controls |
| last_timer->tmr_fd=(DWORD*)NULL; |
| Parent->timer_fd=(DWORD*)last_timer; |
| } |
| } |
| #ifdef DEBUG |
| printf("\ndestroyed timer %d parent window %d",(int)timer,(int)timer->tmr_parent); |
| #endif |
| free(timer); |
| break; |
| } |
| exchange_timer=(struct TIMER*)seek_timer->tmr_fd; |
| seek_timer=exchange_timer; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // create timer for function of parent window |
| //--------------------------------------------------------------------------------- |
| void *SetTimerCallbackForFunction(parent_t *parent_window,int time_tick,void *func,void *func_data) |
| { |
| struct TIMER *timer; |
| timer=CreateTimerForParentWindow(parent_window); |
| timer->func=(DWORD*)func; |
| timer->func_data=(DWORD*)func_data; |
| timer->time_tick=(DWORD)time_tick; |
| timer->last_time=gui_ksys_get_ticks(); |
| timer->flags=timer->flags | FLAG_TIMER_ON; |
| return(timer); |
| } |
| //--------------------------------------------------------------------------------- |
| // create timer for callback |
| //--------------------------------------------------------------------------------- |
| void *SetTimerCallbackForControl(int time_tick,void *func,void *func_data) |
| { |
| struct TIMER *timer; |
| timer=malloc(sizeof(struct TIMER)); |
| timer->func=(DWORD*)func; |
| timer->func_data=(DWORD*)func_data; |
| timer->time_tick=(DWORD)time_tick; |
| timer->last_time=gui_ksys_get_ticks(); |
| timer->flags=timer->flags & FLAG_TIMER_OFF; |
| return(timer); |
| } |
| //--------------------------------------------------------------------------------- |
| // call timer |
| //--------------------------------------------------------------------------------- |
| void Timer(struct TIMER *timer) |
| { |
| DWORD time,delta_time; |
| time=gui_ksys_get_ticks(); |
| delta_time=time-timer->last_time; |
| if (delta_time>=timer->time_tick) |
| { |
| TimerCallbackFunction=(void(*)(void *data))timer->func; |
| TimerCallbackFunction(timer->func_data); |
| timer->last_time=gui_ksys_get_ticks(); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // create new callback for event |
| //--------------------------------------------------------------------------------- |
| void *CreateCallbackForEvent(parent_t *parent) |
| { |
| gui_callbackevent_t *calev; |
| gui_callbackevent_t *backward_calev; |
| calev=malloc(sizeof(gui_callbackevent_t)); |
| calev->calev_parent=(DWORD*)parent; |
| if (parent->calev_bk==(DWORD*)NULL) |
| {//not yet timers |
| parent->calev_bk=(DWORD*)calev; |
| parent->calev_fd=(DWORD*)calev; |
| calev->calev_bk=(DWORD*)parent; |
| calev->calev_fd=(DWORD*)NULL; |
| } |
| else |
| { |
| backward_calev=(gui_callbackevent_t*)parent->calev_fd; |
| parent->calev_fd=(DWORD*)calev; |
| backward_calev->calev_fd=(DWORD*)calev; |
| calev->calev_bk=(DWORD*)backward_calev; |
| calev->calev_fd=(DWORD*)NULL; |
| } |
| return(calev); |
| } |
| //--------------------------------------------------------------------------------- |
| // destroy callback function for eventcalev |
| //--------------------------------------------------------------------------------- |
| void DestroyCallbackFunctionForEvent(gui_callbackevent_t *calev) |
| { |
| struct HEADERPARENT *Parent; |
| struct CALLBACKEVENT *seek_calev; |
| struct CALLBACKEVENT *exchange_calev; |
| struct CALLBACKEVENT *last_calev; |
| struct CALLBACKEVENT *next_calev; |
| if (calev==(gui_callbackevent_t*)NULL) return; |
| Parent=(parent_t*)calev->calev_parent; |
| if (Parent->calev_bk==Parent->calev_fd) |
| { |
| //parent have got alone timer |
| if (Parent->calev_bk==(DWORD*)calev) |
| { |
| free(calev); |
| Parent->calev_bk=(DWORD*)NULL; |
| Parent->calev_fd=(DWORD*)NULL; |
| } |
| return; |
| } |
| seek_calev=(struct CALLBACKEVENT*)Parent->calev_bk; |
| while(seek_calev!=(struct CALLBACKEVENT*)NULL) |
| { |
| if (seek_calev==calev) |
| { |
| //delete timer from timers's stack |
| last_calev=(struct CALLBACKEVENT*)seek_calev->calev_bk; |
| next_calev=(struct CALLBACKEVENT*)seek_calev->calev_fd; |
| if ((last_calev!=(struct CALLBACKEVENT*)Parent) && (next_calev!=(struct CALLBACKEVENT*)NULL)) |
| {//deliting timer isn't first timer and isn't endest |
| next_calev->calev_bk=(DWORD*)last_calev; |
| last_calev->calev_fd=(DWORD*)next_calev; |
| } |
| else |
| { |
| if (last_calev==(struct CALLBACKEVENT*)Parent) |
| {//deliting timer is first timer of Parend |
| Parent->calev_bk=(DWORD*)next_calev; |
| next_calev->calev_bk=(DWORD*)Parent; |
| if (next_calev->calev_fd==(DWORD*)NULL) |
| { |
| Parent->calev_fd=(DWORD*)next_calev; |
| Parent->calev_bk=(DWORD*)next_calev; |
| } |
| } |
| if (next_calev==(struct CALLBACKEVENT*)NULL) |
| { |
| //there isn't next controls |
| last_calev->calev_fd=(DWORD*)NULL; |
| Parent->calev_fd=(DWORD*)last_calev; |
| } |
| } |
| free(calev); |
| break; |
| } |
| exchange_calev=(struct CALLBACKEVENT*)seek_calev->calev_fd; |
| seek_calev=exchange_calev; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // create callback for messenger of events |
| //--------------------------------------------------------------------------------- |
| void *SetCallbackFunctionForEvent(parent_t *parent_window,int event_type,void *func,void *func_data) |
| { |
| gui_callbackevent_t *calev; |
| calev=CreateCallbackForEvent(parent_window); |
| calev->func=(DWORD*)func; |
| calev->func_data=(DWORD*)func_data; |
| calev->event_type=(DWORD)event_type; |
| return(calev); |
| } |
| //--------------------------------------------------------------------------------- |
| // check cross control and mouse |
| //--------------------------------------------------------------------------------- |
| char CheckCrossBox(struct HEADER *control,int mouse_x,int mouse_y) |
| { |
| struct FINITION *fin; |
| int x,y,x2,y2; |
| int xmin,xmax,ymin,ymax,sx,sy; |
| fin=(struct FINITION*)control->finition; |
| if (fin->flags & FINITION_ON) |
| { |
| xmin=fin->x; |
| xmax=fin->x+fin->sizex-1; |
| ymin=fin->y; |
| ymax=fin->y+fin->sizey-1; |
| x=control->ctrl_x; |
| y=control->ctrl_y; |
| x2=x+control->ctrl_sizex-1; |
| y2=y+control->ctrl_sizey-1; |
| if (x2<xmin) return(FALSE); |
| if (x>xmax) return(FALSE); |
| if (y2<ymin) return(FALSE); |
| if (y>ymax) return(FALSE); |
| //finit x coordinates and sizex |
| sx=x-xmin; |
| if (sx>=0) |
| { |
| if (x2>xmax) x2=xmax; |
| } |
| else |
| { |
| x=xmin; |
| if (x2>xmax) x2=xmax; |
| } |
| //finit y coordinates and sizey |
| sy=y-ymin; |
| if (sy>=0) |
| { |
| if (y2>ymax) y2=ymax; |
| } |
| else |
| { |
| y=ymin; |
| if (y2>ymax) y2=ymax; |
| } |
| //check cross finited control with mouse |
| if ((mouse_x>=x) && (mouse_x<=x2) && (mouse_y>=y) && (mouse_y<=y2)) |
| return(TRUE); |
| else |
| return(FALSE); |
| } |
| else |
| { |
| if ((mouse_x>=control->ctrl_x) && (mouse_x<=control->ctrl_x+control->ctrl_sizex) && |
| (mouse_y>=control->ctrl_y) && (mouse_y<=control->ctrl_y+control->ctrl_sizey)) |
| return(TRUE); |
| else |
| return(FALSE); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // check cross two rectaangles |
| //--------------------------------------------------------------------------------- |
| char CheckCrossRectangles(int x1,int y1,int sizex1,int sizey1,int x2,int y2,int sizex2,int sizey2) |
| { |
| int s; |
| int xmax,ymax; |
| xmax=x1+sizex1-1; |
| ymax=y1+sizey1-1; |
| //check x cross |
| s=x2-x1; |
| if (s>0) |
| {//second rectangle have right position |
| if (x2>xmax) return(FALSE); |
| } |
| if (s<0) |
| {//second rectangle have left position |
| s=-s; |
| if (s>=sizex2) return(FALSE); |
| } |
| //check y cross |
| s=y2-y1; |
| if (s>0) |
| {//second rectangle have down position |
| if (y2>ymax) return(FALSE); |
| } |
| if (s<0) |
| {//second rectangle have up position |
| s=-s; |
| if (s>=sizey2) return(FALSE); |
| } |
| return(TRUE); |
| } |
| //--------------------------------------------------------------------------------- |
| // check full cross two rectaangles |
| //--------------------------------------------------------------------------------- |
| char CheckFullCrossRectangles(int x1,int y1,int sizex1,int sizey1,int x2,int y2,int sizex2,int sizey2) |
| { |
| int s; |
| int xmax,ymax; |
| xmax=x1+sizex1-1; |
| ymax=y1+sizey1-1; |
| if (x2>=x1 && x2+sizex2-1<=xmax && y2>=y1 && y2+sizey2-1<=ymax) return(TRUE); |
| else return(FALSE); |
| } |
| //--------------------------------------------------------------------------------- |
| // send message to controls |
| //--------------------------------------------------------------------------------- |
| void SendMessage(struct HEADER *Parent,struct MESSAGE *message) |
| { |
| struct HEADER *seek_control; |
| struct HEADER *exchange_control; |
| struct HEADER *parent; |
| struct HEADERPARENT *main_parent; |
| struct MESSAGE local_service_message; |
| struct HEADER *active_control_for_keys; |
| struct HEADER *active_control_for_mouse; |
| char cross; |
| //Parent haven't got child controls |
| if ((Parent->child_bk==NULL) && (Parent->child_fd==NULL)) return; |
| //load main parent |
| main_parent=(struct HEADERPARENT*)Parent->main_parent; |
| //load active controls from Parent |
| active_control_for_keys=(struct HEADER*)Parent->active_control_for_keys; |
| active_control_for_mouse=(struct HEADER*)Parent->active_control_for_mouse; |
| //Parent have got alon child control |
| if (Parent->child_bk==Parent->child_fd) |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| switch(message->type) |
| { |
| case MESSAGE_FULL_REDRAW_ALL: |
| { |
| //send message redraw to all child controls |
| if (seek_control->flags & FLAG_SHOW_CONTROL) ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION: |
| { |
| //send message finited redraw to all child controls |
| if (seek_control->flags & FLAG_SHOW_CONTROL) ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_KEYS_EVENT: |
| { //change active control for keyboard by TAB press |
| if ((message->arg1==KEY_DOWN) && (message->arg2==SC_TAB)) |
| { |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| if (active_control_for_keys==seek_control) |
| {//focuse of input set for current control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| local_service_message.arg1=FALSE; |
| active_control_for_keys->flags=active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| parent=(struct HEADER*)active_control_for_keys->parent; |
| seek_control=parent; |
| do |
| { |
| if (parent==(struct HEADER*)main_parent) break; |
| //if next control NULL go to parent |
| if (seek_control==(struct HEADER*)NULL) seek_control=parent; |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| if (seek_control==(struct HEADER*)NULL) |
| parent=(struct HEADER*)parent->parent; |
| } |
| while((seek_control==(struct HEADER*)NULL) || |
| ((seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE)==FALSE)); |
| if (parent==(struct HEADER*)main_parent) |
| { |
| //find first control of main parent with focuse of input supporote |
| seek_control=(struct HEADER *)main_parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) break; |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| main_parent->active_control_for_keys=(DWORD*)seek_control; |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| //send message enable focuse of input to control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| local_service_message.arg1=FALSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=(struct HEADER*)NULL; |
| break; |
| } |
| if (seek_control!=(struct HEADER*)NULL) |
| { |
| parent=(struct HEADER*)seek_control->parent; |
| parent->active_control_for_keys=(DWORD*)seek_control; |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| //send message enable focuse of input to control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| local_service_message.arg1=FALSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=(struct HEADER*)NULL; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| break; |
| } |
| } |
| else |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| local_service_message.arg1=FALSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=seek_control; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| } |
| } |
| } |
| //send message of keys only to active control |
| if (active_control_for_keys!=NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_keys->ctrl_proc; |
| ControlProc(active_control_for_keys,message); |
| } |
| break; |
| } |
| case MESSAGE_SPECIALIZED: |
| { |
| //send specialized message to all child controls |
| ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_MOUSE_EVENT: |
| { |
| if (seek_control->flags & FLAG_MOUSE_BLOCKED_ON) break; |
| if (message->arg3==MOUSE_LEFT_BUTTON_DOWN) |
| { |
| if (active_control_for_mouse!=NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_mouse->ctrl_proc; |
| ControlProc(active_control_for_mouse,message); |
| break; |
| } |
| } |
| else |
| { |
| if (active_control_for_mouse!=NULL) {active_control_for_mouse=NULL;} |
| } |
| cross=FALSE; |
| if (CheckCrossBox(seek_control,message->arg1,message->arg2)==TRUE) |
| { |
| if (message->arg3==MOUSE_LEFT_BUTTON_DOWN) |
| { |
| cross=TRUE; |
| active_control_for_mouse=seek_control; |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| parent=(struct HEADER*)seek_control->parent; |
| if (parent->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| active_control_for_keys=(struct HEADER*)main_parent->global_active_control_for_keys; |
| if (active_control_for_keys!=(struct HEADER*)NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags= |
| active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| } |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| Parent->active_control_for_keys=(DWORD*)seek_control; |
| } |
| } |
| } |
| } |
| if ((cross==FALSE) && (message->arg3==MOUSE_LEFT_BUTTON_DOWN)) |
| { |
| if (active_control_for_keys!=NULL) |
| {//disable focuse of input for active control of keys |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags=active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| } |
| } |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_CHANGE_POSITION_EVENT: |
| { |
| ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_CALL_TIMER_EVENT: |
| { |
| ControlProc(seek_control,message); |
| break; |
| } |
| case MESSAGE_DESTROY_CONTROL: |
| { |
| //send message to control for destroing child controls |
| ControlProc(seek_control,message); |
| DestroyControl(seek_control); |
| break; |
| } |
| case MESSAGE_SET_MAIN_PARENT: |
| { |
| ControlProc(seek_control,message); |
| break; |
| } |
| default:break; |
| } |
| } |
| else |
| { |
| switch(message->type) |
| { |
| case MESSAGE_FULL_REDRAW_ALL: |
| { |
| //send message redraw to all child controls of Parent |
| seek_control=(struct HEADER *)Parent->child_bk; |
| 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,message); |
| } |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_FULL_REDRAW_ALL_WITH_FINITION: |
| { |
| //send message redraw to all child controls of Parent |
| seek_control=(struct HEADER *)Parent->child_bk; |
| 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,message); |
| } |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_KEYS_EVENT: |
| { |
| if ((message->arg1==KEY_DOWN) && (message->arg2==SC_TAB)) |
| { //change active control for keyboard by TAB press |
| if (active_control_for_keys==NULL) |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| if ((seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE)==FALSE) |
| { //find first control of parend with supporote of input |
| while(seek_control->ctrl_fd!=(DWORD*)NULL) |
| { |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| active_control_for_keys=seek_control; |
| main_parent->global_active_control_for_keys= |
| (DWORD*)active_control_for_keys; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| break; |
| } |
| } |
| if (active_control_for_keys!=NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| } |
| } |
| else |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=seek_control; |
| main_parent->global_active_control_for_keys=(DWORD*)active_control_for_keys; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| } |
| } |
| else |
| { |
| if (active_control_for_keys==(struct HEADER*)main_parent->global_active_control_for_keys) |
| { |
| seek_control=active_control_for_keys; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| if (seek_control==(struct HEADER*)NULL) |
| { //send message disable focuse of input to current control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags= |
| active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| //back into main parent of tree and find next not NULL control |
| parent=(struct HEADER*)active_control_for_keys->parent; |
| do |
| { |
| if (parent==(struct HEADER*)main_parent) break; |
| //if next control NULL go to parent |
| if (seek_control==(struct HEADER*)NULL) seek_control=parent; |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| if (seek_control==(struct HEADER*)NULL) |
| parent=(struct HEADER*)parent->parent; |
| } |
| while((seek_control==(struct HEADER*)NULL) || |
| ((seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE)==FALSE)); |
| if (parent==(struct HEADER*)main_parent) |
| { |
| //find first control of main parent with focuse of input supporote |
| seek_control=(struct HEADER *)main_parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| break; |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| main_parent->active_control_for_keys=(DWORD*)seek_control; |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| //send message enable focuse of input to control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=(struct HEADER*)NULL; |
| break; |
| } |
| if (seek_control!=(struct HEADER*)NULL) |
| { |
| parent=(struct HEADER*)seek_control->parent; |
| parent->active_control_for_keys=(DWORD*)seek_control; |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| //send message enable focuse of input to control |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=(struct HEADER*)NULL; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| break; |
| } |
| } |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags= |
| active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=seek_control; |
| main_parent->global_active_control_for_keys= |
| (DWORD*)active_control_for_keys; |
| Parent->active_control_for_keys=(DWORD*)active_control_for_keys; |
| break; |
| } |
| } |
| } |
| } |
| } |
| //send message of keys only to active control |
| if (active_control_for_keys!=NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_keys->ctrl_proc; |
| ControlProc(active_control_for_keys,message); |
| } |
| break; |
| } |
| case MESSAGE_SPECIALIZED: |
| { |
| //send specialized message to all child controls |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_MOUSE_EVENT: |
| { |
| if (message->arg3==MOUSE_LEFT_BUTTON_DOWN) |
| { |
| if (active_control_for_mouse!=NULL) |
| { |
| if (active_control_for_mouse->flags & FLAG_MOUSE_BLOCKED_ON) break; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_mouse->ctrl_proc; |
| ControlProc(active_control_for_mouse,message); |
| break; |
| } |
| } |
| else |
| { |
| if (active_control_for_mouse!=NULL) {active_control_for_mouse=NULL;} |
| } |
| cross=FALSE; |
| seek_control=(struct HEADER*)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (CheckCrossBox(seek_control,message->arg1,message->arg2)==TRUE && |
| (seek_control->flags & FLAG_MOUSE_BLOCKED_ON)==FALSE) |
| { |
| if (message->arg3==MOUSE_LEFT_BUTTON_DOWN) |
| { |
| cross=TRUE; |
| active_control_for_mouse=seek_control; |
| if (active_control_for_mouse->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| //set focuse of input for new active control |
| active_control_for_mouse->flags=active_control_for_mouse->flags | FLAG_FOCUSE_INPUT_ON; |
| if (active_control_for_keys!=NULL) |
| { |
| if (active_control_for_keys!=seek_control) |
| { |
| //check seek control for supporote focuse of input |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| //check parent for supporote focuse of input |
| parent=(struct HEADER*)seek_control->parent; |
| if (parent->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| local_service_message.arg1=FALSE; |
| active_control_for_keys->flags= |
| active_control_for_keys->flags & |
| FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| local_service_message.arg1=FALSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| active_control_for_keys=seek_control; |
| main_parent->global_active_control_for_keys= |
| (DWORD*)active_control_for_keys; |
| Parent->active_control_for_keys= |
| (DWORD*)active_control_for_keys; |
| } |
| } |
| } |
| } |
| else |
| { |
| //check seek control for supporote focuse of input |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| //check parent for supporote focuse of input |
| parent=(struct HEADER*)seek_control->parent; |
| if (parent->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| active_control_for_keys=(struct HEADER*)main_parent->global_active_control_for_keys; |
| if (active_control_for_keys!=NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags= |
| active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| } |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message)) |
| seek_control->ctrl_proc; |
| local_service_message.type=MESSAGE_SET_FOCUSE; |
| seek_control->flags=seek_control->flags | FLAG_FOCUSE_INPUT_ON; |
| ControlProc(seek_control,&local_service_message); |
| main_parent->global_active_control_for_keys=(DWORD*)seek_control; |
| Parent->active_control_for_keys=(DWORD*)seek_control; |
| } |
| } |
| } |
| } |
| } |
| } |
| if ((seek_control->flags & FLAG_MOUSE_BLOCKED_ON)==FALSE) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| } |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| if ((cross==FALSE) && (message->arg3==MOUSE_LEFT_BUTTON_DOWN)) |
| { |
| if (active_control_for_keys!=NULL) |
| {//disable focuse of input for active control of keys |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))active_control_for_keys->ctrl_proc; |
| local_service_message.type=MESSAGE_CHANGE_FOCUSE; |
| active_control_for_keys->flags=active_control_for_keys->flags & FLAG_FOCUSE_INPUT_OFF; |
| ControlProc(active_control_for_keys,&local_service_message); |
| main_parent->global_active_control_for_keys=(DWORD*)NULL; |
| Parent->active_control_for_keys=(DWORD*)NULL; |
| } |
| } |
| break; |
| } |
| case MESSAGE_CHANGE_POSITION_EVENT: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_CALL_TIMER_EVENT: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_SET_FOCUSE: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| break; |
| } |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_CHANGE_FOCUSE: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| if (seek_control->flags & FLAG_FOCUSE_INPUT_SUPPOROTE) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| ControlProc(seek_control,message); |
| break; |
| } |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_DESTROY_CONTROL: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { //befor delet control get next control of parent |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| //send message to control for destroyng child controls |
| ControlProc(seek_control,message); |
| DestroyControl(seek_control); |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| case MESSAGE_SET_MAIN_PARENT: |
| { |
| seek_control=(struct HEADER *)Parent->child_bk; |
| while(seek_control!=(struct HEADER*)NULL) |
| { |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))seek_control->ctrl_proc; |
| //send message to control for destroyng child controls |
| ControlProc(seek_control,message); |
| seek_control->main_parent=(DWORD*)message->arg1; |
| exchange_control=(struct HEADER *)seek_control->ctrl_fd; |
| seek_control=exchange_control; |
| } |
| break; |
| } |
| default:break; |
| } |
| } |
| Parent->active_control_for_mouse=(DWORD*)active_control_for_mouse; |
| } |
| //--------------------------------------------------------------------------------- |
| // pack control_child in control_parent for libGUI |
| //--------------------------------------------------------------------------------- |
| //add new control for Parent |
| void PackControls(void *parent,void *Control) |
| { |
| struct HEADER *Parent; |
| struct HEADER *last_control; |
| struct HEADER *control; |
| struct MESSAGE message; |
| Parent=(struct HEADER *)parent; |
| control=(struct HEADER *)Control; |
| //set control's dependeces |
| if (Parent->child_bk==NULL) |
| { |
| //create first child control for parent |
| Parent->child_bk=(DWORD*)control; |
| Parent->child_fd=(DWORD*)control; |
| //init control |
| control->parent=(DWORD*)Parent; |
| control->ctrl_bk=(DWORD*)Parent;//last control is parent |
| control->ctrl_fd=(DWORD*)NULL;//haven't next control |
| } |
| else |
| { |
| //set new control as endest child control of parent |
| last_control=(struct HEADER*)Parent->child_fd; |
| Parent->child_fd=(DWORD*)control; |
| last_control->ctrl_fd=(DWORD*)control; |
| control->ctrl_bk=(DWORD*)last_control; |
| control->ctrl_fd=(DWORD*)NULL; |
| control->parent=(DWORD*)Parent; |
| } |
| //finite control's coordinates and size |
| control->ctrl_x=control->ctrl_x+Parent->ctrl_x; |
| control->ctrl_y=control->ctrl_y+Parent->ctrl_y; |
| if (control->ctrl_sizex<=1) {control->ctrl_sizex=1;} |
| if (control->ctrl_sizey<=1) {control->ctrl_sizey=1;} |
| message.type=(DWORD)MESSAGE_CHANGE_POSITION_EVENT; |
| message.arg1=Parent->ctrl_x; |
| message.arg2=Parent->ctrl_y; |
| //send message change position to child controls |
| SendMessage(control,&message); |
| if (Parent->main_parent!=(DWORD*)NULL) |
| { |
| //tell all child controls of main parent who is main parent |
| message.type=MESSAGE_SET_MAIN_PARENT; |
| message.arg1=(DWORD)Parent->main_parent; |
| SendMessage((struct HEADER *)Parent,&message); |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // show/hide controls |
| //--------------------------------------------------------------------------------- |
| void ShowControl(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| control->flags=control->flags | FLAG_SHOW_CONTROL; |
| } |
| void HideControl(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| control->flags=control->flags & FLAG_HIDE_CONTROL; |
| } |
| //--------------------------------------------------------------------------------- |
| // redraw control |
| //--------------------------------------------------------------------------------- |
| void RedrawControl(void *Control) |
| { |
| struct HEADER *control; |
| struct MESSAGE message; |
| control=(struct HEADER*)Control; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))control->ctrl_proc; |
| message.type=MESSAGE_FULL_REDRAW_ALL; |
| ControlProc(control,&message); |
| } |
| //--------------------------------------------------------------------------------- |
| // special redraw of control |
| //--------------------------------------------------------------------------------- |
| void SpecialRedrawControl(void *Control) |
| { |
| struct HEADER *control; |
| struct MESSAGE message; |
| struct HEADERPARENT *main_parent; |
| control=(struct HEADER*)Control; |
| main_parent=(struct HEADERPARENT*)control->main_parent; |
| control->flags=control->flags | FLAG_GET_SPECIALIZED_MESSAGE_ON; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))control->ctrl_proc; |
| message.type=MESSAGE_SPECIALIZED; |
| ControlProc((struct HEADER*)main_parent,&message); |
| } |
| //--------------------------------------------------------------------------------- |
| // set new size for control |
| //--------------------------------------------------------------------------------- |
| void SetControlSizeRequest(void *Control,int new_size_x,int new_size_y) |
| { |
| struct HEADER *control; |
| struct HEADER *Parent; |
| control=(struct HEADER*)Control; |
| Parent=(struct HEADER*)control->parent; |
| control->ctrl_sizex=(DWORD)new_size_x; |
| control->ctrl_sizey=(DWORD)new_size_y; |
| if ((control->ctrl_x+control->ctrl_sizex)>Parent->ctrl_sizex) {control->ctrl_sizex=Parent->ctrl_sizex-control->ctrl_x;} |
| if ((control->ctrl_y+control->ctrl_sizey)>Parent->ctrl_sizey) {control->ctrl_sizey=Parent->ctrl_sizey-control->ctrl_y;} |
| if (control->ctrl_sizex<=1) {control->ctrl_sizex=1;} |
| if (control->ctrl_sizey<=1) {control->ctrl_sizey=1;} |
| } |
| //--------------------------------------------------------------------------------- |
| // get size x of control |
| //--------------------------------------------------------------------------------- |
| int GetControlSizeX(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| return ((int)control->ctrl_sizex); |
| } |
| //--------------------------------------------------------------------------------- |
| // get size y of control |
| //--------------------------------------------------------------------------------- |
| int GetControlSizeY(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| return ((int)control->ctrl_sizey); |
| } |
| //--------------------------------------------------------------------------------- |
| // set new size for control |
| //--------------------------------------------------------------------------------- |
| void SetControlNewPosition(void *Control,int new_x,int new_y) |
| { |
| struct HEADER *control; |
| struct HEADER *Parent; |
| struct MESSAGE message; |
| parent_t *main_parent; |
| int old_x; |
| int old_y; |
| control=(struct HEADER*)Control; |
| main_parent=(parent_t*)control->main_parent; |
| if (control->parent==(DWORD*)main_parent) |
| {//check position of child control of main parent |
| if (new_x+control->ctrl_sizex-1>screen.size_x) return; |
| if (new_y+control->ctrl_sizey-1>screen.size_y) return; |
| } |
| message.type=(DWORD)MESSAGE_CHANGE_POSITION_EVENT; |
| message.arg1=(DWORD)(new_x-control->ctrl_x); |
| message.arg2=(DWORD)(new_y-control->ctrl_y); |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))control->ctrl_proc; |
| ControlProc(control,&message); |
| } |
| //--------------------------------------------------------------------------------- |
| // get x position of control |
| //--------------------------------------------------------------------------------- |
| int GetControlPositionX(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| return ((int)control->ctrl_x); |
| } |
| //--------------------------------------------------------------------------------- |
| // get y position of control |
| //--------------------------------------------------------------------------------- |
| int GetControlPositionY(void *Control) |
| { |
| struct HEADER *control; |
| control=(struct HEADER *)Control; |
| return ((int)control->ctrl_y); |
| } |
| //--------------------------------------------------------------------------------- |
| // set focuse of input for control |
| //--------------------------------------------------------------------------------- |
| void *SetFocuse(void *Control) |
| { |
| struct HEADER *control; |
| struct HEADERPARENT *main_parent; |
| struct HEADER *old_control; |
| struct MESSAGE *message; |
| //new active control with focuse |
| control=(struct HEADER*)Control; |
| main_parent=(struct HEADERPARENT*)control->main_parent; |
| if (main_parent==(struct HEADERPARENT*)NULL) return; |
| //old control with focuse |
| old_control=(struct HEADER*)main_parent->global_active_control_for_keys; |
| if (old_control!=(struct HEADER*)NULL) |
| { |
| message->type=MESSAGE_CHANGE_FOCUSE; |
| message->arg1=FALSE; |
| message->arg2=FALSE; |
| message->arg3=FALSE; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))old_control->ctrl_proc; |
| ControlProc(old_control,message); |
| } |
| message->type=MESSAGE_SET_FOCUSE; |
| message->arg1=FALSE; |
| message->arg2=FALSE; |
| message->arg3=FALSE;; |
| ControlProc=(void (*)(void *Control,struct MESSAGE *message))control->ctrl_proc; |
| ControlProc(control,message); |
| return(old_control); |
| } |
| //--------------------------------------------------------------------------------- |
| // set callback function for control |
| //--------------------------------------------------------------------------------- |
| void *SetCallbackFunction(void *Control,int event_name,void *callback_func,void *callback_func_data) |
| { |
| struct HEADER *control; |
| struct CALLBACK *seek_callback; |
| struct CALLBACK *exchange_callback; |
| struct CALLBACK *new_callback; |
| control=(struct HEADER *)Control; |
| seek_callback=(struct CALLBACK*)control->callback; |
| if (seek_callback==(struct CALLBACK *)NULL) |
| { //callback function creating at first |
| new_callback=malloc(sizeof(struct CALLBACK)); |
| control->callback=(DWORD*)new_callback; |
| new_callback->clb_bk=(DWORD*)control; |
| new_callback->clb_fd=(DWORD*)NULL; |
| new_callback->clb_control=(DWORD*)control; |
| new_callback->connect_event=(DWORD)event_name; |
| new_callback->func=(DWORD*)callback_func; |
| new_callback->func_data=(DWORD*)callback_func_data; |
| new_callback->flags=0x0; |
| } |
| else |
| { |
| while(seek_callback!=(struct CALLBACK*)NULL) |
| { |
| if (seek_callback->clb_fd==(DWORD*)NULL) |
| {//create new callback control for callback function |
| new_callback=malloc(sizeof(struct CALLBACK)); |
| seek_callback->clb_fd=(DWORD*)new_callback; |
| new_callback->clb_bk=(DWORD*)seek_callback; |
| new_callback->clb_fd=(DWORD*)NULL; |
| new_callback->clb_control=(DWORD*)control; |
| new_callback->connect_event=(DWORD)event_name; |
| new_callback->func=(DWORD*)callback_func; |
| new_callback->func_data=(DWORD*)callback_func_data; |
| new_callback->flags=0x0; |
| break; |
| } |
| exchange_callback=(struct CALLBACK*)seek_callback->clb_fd; |
| seek_callback=exchange_callback; |
| } |
| } |
| return(new_callback); |
| } |
| //--------------------------------------------------------------------------------- |
| // block current callback function for control |
| //--------------------------------------------------------------------------------- |
| void BlockCallbackFunction(void *Control,void *callback_ID) |
| { |
| struct HEADER *control; |
| struct CALLBACK *seek_callback; |
| struct CALLBACK *exchange_callback; |
| struct CALLBACK *unknown_callback; |
| control=(struct HEADER *)Control; |
| seek_callback=(struct CALLBACK *)control->callback; |
| unknown_callback=(struct CALLBACK*)callback_ID; |
| while(seek_callback!=(struct CALLBACK*)NULL) |
| { |
| if (seek_callback==unknown_callback) |
| { |
| unknown_callback->flags=unknown_callback->flags | FLAG_BLOCK_CALLBACK_ON; |
| break; |
| } |
| exchange_callback=(struct CALLBACK*)seek_callback->clb_fd; |
| seek_callback=exchange_callback; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // unblock current callback function for control |
| //--------------------------------------------------------------------------------- |
| void UnblockCallbackFunction(void *Control,void *callback_ID) |
| { |
| struct HEADER *control; |
| struct CALLBACK *seek_callback; |
| struct CALLBACK *exchange_callback; |
| struct CALLBACK *unknown_callback; |
| control=(struct HEADER *)Control; |
| seek_callback=(struct CALLBACK *)control->callback; |
| unknown_callback=(struct CALLBACK*)callback_ID; |
| while(seek_callback!=(struct CALLBACK*)NULL) |
| { |
| if (seek_callback==unknown_callback) |
| { |
| unknown_callback->flags=unknown_callback->flags & FLAG_BLOCK_CALLBACK_OFF; |
| break; |
| } |
| exchange_callback=(struct CALLBACK*)seek_callback->clb_fd; |
| seek_callback=exchange_callback; |
| } |
| } |
| //--------------------------------------------------------------------------------- |
| // chack callback event for control |
| //--------------------------------------------------------------------------------- |
| void *ControlCheckCallbackEvent(void *Control,DWORD event) |
| { |
| struct HEADER *control; |
| struct CALLBACK *seek_callback; |
| struct CALLBACK *exchange_callback; |
| control=(struct HEADER *)Control; |
| seek_callback=(struct CALLBACK *)control->callback; |
| while(seek_callback!=(struct CALLBACK*)NULL) |
| { |
| if ((seek_callback->flags & FLAG_BLOCK_CALLBACK_ON)==FALSE) |
| { |
| if (seek_callback->connect_event==event) return (seek_callback); |
| } |
| exchange_callback=(struct CALLBACK*)seek_callback->clb_fd; |
| seek_callback=exchange_callback; |
| } |
| return(NULL); |
| } |
| //--------------------------------------------------------------------------------- |
| // set IDL function for libGUI |
| //--------------------------------------------------------------------------------- |
| void SetIDL_Function(parent_t *parent,void *function,void *function_data) |
| { |
| parent->IDL_func=(DWORD*)function; |
| parent->IDL_func_data=(DWORD*)function_data; |
| } |
| //--------------------------------------------------------------------------------- |
| // destroy IDL function for libGUI |
| //--------------------------------------------------------------------------------- |
| void DestroyIDL_Function(parent_t *parent) |
| { |
| parent->IDL_func=(DWORD*)NULL; |
| } |
| //--------------------------------------------------------------------------------- |
| // initialize libGUI |
| //--------------------------------------------------------------------------------- |
| char InitLibGUI() |
| { |
| font_t *font; |
| //--------------------------------------------------------------------------------- |
| //---------------------------platform depended part of code------------------------ |
| //--------------------------------------------------------------------------------- |
| //set new events mask |
| gui_ksys_set_events_mask(119); |
| //set scan codes input mode for keyboard |
| gui_ksys_set_keyboard_input_mode(1); |
| //------------------------------------------------------------------------------------ |
| FontsMeneger.fnt_fd=(DWORD*)NULL; |
| FontsMeneger.fnt_bk=(DWORD*)NULL; |
| FontsMeneger.number_fonts=0; |
| //load default fonts |
| font=LoadFont("CHAR.MT"); |
| if (font==NULL) return (TRUE); |
| else FontsMeneger.default_font=(DWORD*)font; |
| font->flags=font->flags | FONT_FLAG_DEFAULT_FONT_ON; |
| return(FALSE); |
| } |
| //--------------------------------------------------------------------------------- |
| // quit from libGUI loop and destroy all GUI objects |
| //--------------------------------------------------------------------------------- |
| void QuitLibGUI(parent_t *window) |
| { |
| font_t *font,*seek_font,*exchange_font; |
| gui_timer_t *seek_timer,*exchange_timer; |
| gui_message_t message; |
| //destroy controls of parent window |
| message.type=MESSAGE_DESTROY_CONTROL; |
| SendMessage((header_t*)window,&message); |
| #ifdef DEBUG |
| gui_debug_out_str("\ncontrols destroyed"); |
| #endif |
| //destroy timers for callback functions |
| seek_timer=(gui_timer_t*)window->timer_bk; |
| while(seek_timer!=(gui_timer_t*)NULL) |
| { |
| exchange_timer=(gui_timer_t*)seek_timer->tmr_fd; |
| DestroyTimerCallbackForFunction(seek_timer); |
| seek_timer=exchange_timer; |
| } |
| #ifdef DEBUG |
| gui_debug_out_str("\ntimers destroyed"); |
| #endif |
| //free arrays of parent window |
| free(window->message); |
| free(window->control_for_callback_function); |
| free(window->callback_for_control_callback); |
| #ifdef DEBUG |
| gui_debug_out_str("\narrays destroyed"); |
| #endif |
| //destroy parent window |
| free(window); |
| #ifdef DEBUG |
| gui_debug_out_str("\nparent window destroyed"); |
| #endif |
| //destroy fonts cash |
| seek_font=(font_t*)FontsMeneger.fnt_bk; |
| while(seek_font!=(font_t*)NULL) |
| { |
| exchange_font=(font_t*)seek_font->fnt_fd; |
| free(seek_font->font); |
| DestroyFont(seek_font); |
| seek_font=exchange_font; |
| } |
| #ifdef DEBUG |
| gui_debug_out_str("\nfonts destroyed"); |
| #endif |
| exit(0); |
| } |
| DWORD LibGUIversion(void) |
| { //03.10.09 |
| return(91003); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/main_libGUI.inc |
|---|
| 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); |
| } |
| } |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/parent_window.inc |
|---|
| 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(); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/stdarg.h |
|---|
| 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) |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/stdio.h |
|---|
| 0,0 → 1,4 |
| + |
| + |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/stdio.inc |
|---|
| 0,0 → 1,791 |
| /* |
| 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); |
| + //con_printf(simbol,s); |
| + free(s); |
| + |
| + return(printed_simbols); |
| +} |
| + |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/stdlib.h |
|---|
| 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); |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/stdlib.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/string.h |
|---|
| 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,...); |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/string.inc |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/SRC/types.h |
|---|
| 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 |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/button.c |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/image.c |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/progress_bar.c |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/scroll_bar.c |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/scrolled_window.c |
|---|
| 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); |
| } |
| Property changes: |
| Added: svn:executable |
| /programs/develop/new libGUI_C/examples/src/text.c |
|---|
| 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); |
| } |