Aren/kolibrios
1
0
Fork 0
mirror of https://github.com/KolibriOS/kolibrios.git synced 2024-12-27 16:59:41 +03:00
Code Issues Packages Projects Releases Wiki Activity
82bb415d1c
kolibrios/programs/develop/libraries/libGUI/SRC/libGUI_management.inc
vkos 1560e4ca7a Replaced meneger with manager, corrected makefile to work on x86-64 
git-svn-id: svn://kolibrios.org@1223 a494cfbc-eb01-0410-851d-a64ba20cac60
2009-10-21 15:47:20 +00:00

1658 lines
53 KiB
PHP
Raw Blame History

/*
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 control
//---------------------------------------------------------------------------------
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;
}
}
#ifdef DEBUG
printf("\ncreated callback %d for function %d data %d",
(DWORD)new_callback,
(DWORD)callback_func,
(DWORD)callback_func_data);
#endif
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;
}
}
//---------------------------------------------------------------------------------
// check 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);
//------------------------------------------------------------------------------------
FontsManager.fnt_fd=(DWORD*)NULL;
FontsManager.fnt_bk=(DWORD*)NULL;
FontsManager.number_fonts=0;
//load default fonts
font=LoadFont("CHAR.MT");
if (font==NULL) return (TRUE);
else FontsManager.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;
#ifdef DEBUG
printf("\nbegin free libGUI...");
#endif
//destroy controls of parent window
message.type=MESSAGE_DESTROY_CONTROL;
SendMessage((header_t*)window,&message);
#ifdef DEBUG
printf("\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
printf("\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
printf("\narrays destroyed");
#endif
//destroy parent window
free(window);
#ifdef DEBUG
printf("\nparent window destroyed");
#endif
//destroy fonts cash
seek_font=(font_t*)FontsManager.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
printf("\nfonts destroyed");
printf("\nexit program...");
#endif
exit(0);
}
DWORD LibGUIversion(void)
{ //25.10.09
return(91025);
}
Reference in New Issue View Git Blame Copy Permalink