BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /programs/develop/libraries/libGUI/ @ 1222

  → /programs/develop/libraries/libGUI/ @ 1223

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Regard whitespace Rev 1222 → Rev 1223

/programs/develop/libraries/libGUI/SRC/fonts_meneger.h
File deleted

/programs/develop/libraries/libGUI/SRC/fonts_meneger.inc
File deleted

/programs/develop/libraries/libGUI/SRC/libGUI_menegement.inc
File deleted

/programs/develop/libraries/libGUI/SRC/compilation/cygwin/Makefile
1,6 → 1,6
SRC = libGUI.c
TARGET = libGUI.obj
CFLAGS = -O2 -nostdinc -nostdlib -march=pentium -fomit-frame-pointer -fno-builtin -fno-builtin-printf
CFLAGS = -O2 -nostdinc -nostdlib -m32 -march=i686 -fomit-frame-pointer -fno-builtin -fno-builtin-printf
CC = gcc
all:

/programs/develop/libraries/libGUI/SRC/fonts_manager.h
0,0 → 1,63
/*
font manager 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;
}FontsManager;
#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);

/programs/develop/libraries/libGUI/SRC/fonts_manager.inc
0,0 → 1,373
/*
management 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 (FontsManager.fnt_bk==FontsManager.fnt_fd)
{
//parent have got alone font
if (FontsManager.fnt_bk==(DWORD*)font)
{
#ifdef DEBUG
printf("\ndestroyed font %d font name=%s",(int)font,(char*)font->fnt_name);
#endif
free(font);
FontsManager.fnt_bk=(DWORD*)NULL;
FontsManager.fnt_fd=(DWORD*)NULL;
}
return;
}
seek_font=(font_t*)FontsManager.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
FontsManager.fnt_bk=(DWORD*)next_font;
next_font->fnt_bk=(DWORD*)NULL;
if (next_font->fnt_fd==(DWORD*)NULL)
{
FontsManager.fnt_fd=(DWORD*)next_font;
FontsManager.fnt_bk=(DWORD*)next_font;
}
}
if (next_font==(font_t*)NULL)
{
//there isn't next fonts
last_font->fnt_fd=(DWORD*)NULL;
FontsManager.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 (FontsManager.fnt_bk==(DWORD*)NULL)
{//not yet fonts
FontsManager.fnt_bk=(DWORD*)font;
FontsManager.fnt_fd=(DWORD*)font;
font->fnt_bk=(DWORD*)NULL;
font->fnt_fd=(DWORD*)NULL;
}
else
{
backward_font=(font_t*)FontsManager.fnt_fd;
FontsManager.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;
DWORD 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);
}
FontsManager.number_fonts++;
return(font);
}
void FreeFont(font_t *font)
{
if (font==(font_t*)FontsManager.default_font) return;
free(font->font);
DestroyFont(font);
}

/programs/develop/libraries/libGUI/SRC/libGUI_management.inc
0,0 → 1,1657
/*
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);
}