---

Gui.c

Go to the documentation of this file.

/*
 *    gui - [gega user interface] the flexible solution for user interface problems
 *    Copyright (C) 2002  Gergely Gati
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; version 2 of the License.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *    Gergely Gati
 *      email:           g.gati@freemail.hu
 *      AIM screenname:  GatiGergely
 *      ICQ number:      93131690
 *
 */
/* DOXYGEN section: */
#include <stdlib.h>
#include <string.h>

#include "macros.h"
#include "debug.h"
#include "Bases.h"
#include "Locale.h"
#include "Memory.h"
#include "Net.h"
#include "Skin.h"
#include "xml_Gui.h"
#include "classes.h"
#include "Image.h"
#include "Prefs.h"
#include "Window.h"
#include "Common.h"
#include "Bitmap.h"
#include "Terminal.h"


#define GUI_TMP_STRING_BUFFER_SIZE  64
//#define GUI_SERVER_BUFFER_SIZE      8192

struct gui_Timer_s
{
  Window_t *win;
  int (*callback)(Window_t *,u32);
  int flags;
  u32 millisec;
  u32 userdata;
  u32 id;
  Node_t *node;
};


static int gui_TimerCanceller(Window_t *win, u32 userdata);


//Declare call_vector[]
static u32 (*call_vector[GUI_FUNC_DONE-GUI_FUNCBASE+1])(tag *);
VERSION("gui server",1,0,"Gergely Gati","g.gati@freemail.hu");


static char *langs[]=
{
  "ro",
  "hu",
  "ru",
  NULL
};


// r1 metszi r2-t?
u32 gui_IsOverlap(u32 firsttag, ...)
{
  return(gui_IsOverlapTL((tag *)&firsttag));
}
u32 gui_IsOverlapTL(tag *taglist)
{
  Rect_t *r1;
  Rect_t *r2;

  int ret=TRUE;


  debug_Begin();

  r1=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_R1,0L);
  r2=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_R2,0L);

  if(r1->left+r1->width<=r2->left) ret=FALSE;
  else if(r1->left>=r2->left+r2->width) ret=FALSE;
  else if(r1->top+r1->height<=r2->top) ret=FALSE;
  else if(r1->top>=r2->top+r2->height) ret=FALSE;

  debug_End();

  return((u32)ret);
}



// r1 es r2 metszetet r3-ba
u32 gui_CalculateOverlap(u32 firsttag, ...)
{
  return(gui_CalculateOverlapTL((tag *)&firsttag));
}
u32 gui_CalculateOverlapTL(tag *taglist)
{
  Rect_t *r1;
  Rect_t *r2;
  Rect_t *r3;

  int x1,y1,x2,y2;

  debug_Begin();

  r1=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_R1,0L);
  r2=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_R2,0L);
  r3=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_R3,0L);

  x1=max(r1->left,r2->left);
  y1=max(r1->top,r2->top);
  x2=min(r1->left+r1->width,r2->left+r2->width);
  y2=min(r1->top+r1->height,r2->top+r2->height);
  r3->left=x1;
  r3->top=y1;
  r3->width=x2-x1;
  r3->height=y2-y1;

  debug_End();
  return(0L);
}


u32 gui_LoadFile(u32 firsttag, ...)
{
  return(gui_LoadFileTL((tag *)&firsttag));
}
u32 gui_LoadFileTL(tag *taglist)
{
  char *name;
  int *len;

  char *ret=NULL;
  int file_len;
  FILE *f;


  debug_Begin();

  name=(char *)tag_GetTagData(taglist,TAG_GUI_NAME,0L);
  len=(int *)tag_GetTagData(taglist,TAG_GUI_LEN,0L);

  if(name!=NULL&&NULL!=(f=fopen(name,"rb")))
  {
    fseek(f,0L,SEEK_END);
    file_len=ftell(f);
    fseek(f,0L,SEEK_SET);
    if(NULL!=(ret=mem_malloc(file_len+1)))
    {
      ret[0]='\0';
      fread(ret,file_len,1,f);
      if(len!=NULL) *len=file_len;
      ret[file_len]='\0';
    }
    fclose(f);
  }
  else debug_Warning("BAD file req name='%s'",name);

  debug_End();

  return((u32)ret);
}


u32 gui_LoadSubgadgetDescriptor(u32 firsttag, ...)
{
  return(gui_LoadSubgadgetDescriptorTL((tag *)&firsttag));
}
u32 gui_LoadSubgadgetDescriptorTL(tag *taglist)
{
  Window_t *win;
  char *class_name;

static char ext[]=".xml";
static char pre[]="gadget_";
  char *ret=NULL;
  char *fname;

  debug_Begin();

  win=(Window_t *)tag_GetTagData(taglist,TAG_GUI_WIN,0L);
  class_name=(char *)tag_GetTagData(taglist,TAG_GUI_CLASS_NAME,0L);

  if(class_name!=NULL&&NULL!=(fname=mem_malloc(sizeof(pre)-1+strlen(class_name)+sizeof(ext)-1+1)))
  {
    strcpy(fname,pre);
    strcat(fname,class_name);
    strcat(fname,ext);
//    ret=(char *)net_LoadFile(TAG_NET_CONN,glw_GetConnection(window_GetHandle(win)),TAG_NET_NAME,fname,TAG_DONE);
    ret=(char *)net_LoadFile(TAG_NET_CONN,window_GetConnection(win),TAG_NET_NAME,fname,TAG_DONE);
    mem_free(fname);
  }

  debug_End();

  return((u32)ret);
}


u32 gui_UnLoadSubgadgetDescriptor(u32 firsttag, ...)
{
  return(gui_UnLoadSubgadgetDescriptorTL((tag *)&firsttag));
}
u32 gui_UnLoadSubgadgetDescriptorTL(tag *taglist)
{
  char *gui_file;

  debug_Begin();

  gui_file=(char *)tag_GetTagData(taglist,TAG_GUI_FILE,0L);

  if(gui_file!=NULL) mem_free(gui_file);

  debug_End();

  return(0L);
}


u32 gui_IsInside(u32 firsttag, ...)
{
  return(gui_IsInsideTL((tag *)&firsttag));
}
u32 gui_IsInsideTL(tag *taglist)
{
  Rect_t *rect;
  int x;
  int y;

  int ret=TRUE;


  debug_Begin();

  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GUI_RECT,0L);
  x=(int )tag_GetTagData(taglist,TAG_GUI_X,0L);
  y=(int )tag_GetTagData(taglist,TAG_GUI_Y,0L);

  if(x<rect->left||x>=rect->left+rect->width||y<rect->top||y>=rect->top+rect->height) ret=FALSE;

  debug_End();

  return((u32)ret);
}


u32 gui_TimerStart(u32 firsttag, ...)
{
  return(gui_TimerStartTL((tag *)&firsttag));
}
u32 gui_TimerStartTL(tag *taglist)
{
    Window_t *win;
    u32 millisec;
    int flags;
    u32 userdata;
    int (*callback)(Window_t *,u32);

  gui_Timer_t *timer;
  Node_t *node;

  debug_Begin();

  win=(Window_t *)tag_GetTagData(taglist,TAG_GUI_WIN,0L);
  millisec=(u32 )tag_GetTagData(taglist,TAG_GUI_MILLISEC,0L);
  flags=(int )tag_GetTagData(taglist,TAG_GUI_FLAGS,0L);
  userdata=(u32 )tag_GetTagData(taglist,TAG_GUI_USERDATA,0L);
  callback=(int (*)(Window_t *,u32))tag_GetTagData(taglist,TAG_GUI_CALLBACK,0L);

  if(NULL!=(timer=mem_malloc(sizeof(gui_Timer_t)))&&NULL!=(node=list_CreateNode()))
  {
    list_SetNodeData(node,timer);
    list_InsertNodeTail(window_GetTimerList(win),node);
    timer->win=win;
    timer->callback=callback;
    timer->flags=flags;
    timer->millisec=millisec;
    timer->userdata=userdata;
    timer->id=glw_TimerStart(TAG_GLW_WINDOW,win->handle,TAG_GLW_MILLISEC,millisec,TAG_GLW_USERDATA,(u32)timer,TAG_DONE);
    timer->node=node;
  }

  debug_End();

  return((u32)timer);
}


u32 gui_TimerCancel(u32 firsttag, ...)
{
  return(gui_TimerCancelTL((tag *)&firsttag));
}
u32 gui_TimerCancelTL(tag *taglist)
{
  Window_t *win;
  u32 timer_id;

  int ret=-1;
  gui_Timer_t *timer;

  debug_Begin();

  win=(Window_t *)tag_GetTagData(taglist,TAG_GUI_WIN,0L);
  timer_id=(u32 )tag_GetTagData(taglist,TAG_GUI_TIMER_ID,0L);

  timer=(gui_Timer_t *)timer_id;

  if(timer!=NULL)
  {
    timer->callback=gui_TimerCanceller;
    ret=0;
  }

  debug_End();

  return((u32)ret);
}


u32 gui_GetLimitedTextLength(u32 firsttag, ...)
{
  return(gui_GetLimitedTextLengthTL((tag *)&firsttag));
}
u32 gui_GetLimitedTextLengthTL(tag *taglist)
{
  u32 font;
  char *str;
  int len;

  char tmpbuf[GUI_TMP_STRING_BUFFER_SIZE];
  int ret=-1;
  char *text;


  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GUI_FONT,0L);
  str=(char *)tag_GetTagData(taglist,TAG_GUI_STR,0L);
  len=(int )tag_GetTagData(taglist,TAG_GUI_LEN,0L);

  if(len<GUI_TMP_STRING_BUFFER_SIZE)
  {
    strncpy(tmpbuf,str,len);
    tmpbuf[len-1]='\0';
    ret=glw_GetTextLength(TAG_GLW_FONT,font,TAG_GLW_TEXT,tmpbuf,TAG_DONE);
  }
  else if(NULL!=(text=mem_malloc(len+1)))
  {
    strncpy(text,str,len);
    text[len-1]='\0';
    ret=glw_GetTextLength(TAG_GLW_FONT,font,TAG_GLW_TEXT,text,TAG_DONE);
    mem_free(text);
  }

  debug_End();

  return((u32)ret);
}



/* a string elso RETVAL karaktere fer bele a megadott szelessegbe
*/
u32 gui_GetTextFitLength(u32 firsttag, ...)
{
  return(gui_GetTextFitLengthTL((tag *)&firsttag));
}
u32 gui_GetTextFitLengthTL(tag *taglist)
{
  u32 font;
  char *str;
  int width;

  int ret=-1;


  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GUI_FONT,0L);
  str=(char *)tag_GetTagData(taglist,TAG_GUI_STR,0L);
  width=(int )tag_GetTagData(taglist,TAG_GUI_WIDTH,0L);

  if(str!=NULL&&width>0&&font!=0L)
  {
    ret=strlen(str);
    while(width<gui_GetLimitedTextLength(TAG_GUI_FONT,font,TAG_GUI_STR,str,TAG_GUI_LEN,ret,TAG_DONE))
    {
      ret--;
    }
  }

  debug_End();

  return((u32)ret);
}


/* wrap: '\0', '\n', ' '
 * FIXME: SLOOOOW
 */
u32 gui_GetTextWrapLength(u32 firsttag, ...)
{
  return(gui_GetTextWrapLengthTL((tag *)&firsttag));
}
u32 gui_GetTextWrapLengthTL(tag *taglist)
{
  u32 font;
  char *str;
  int width;

  int ret=-1,sti;
  char store,*del1,*del2,*del;


  debug_Begin();

  font=(u32 )tag_GetTagData(taglist,TAG_GUI_FONT,0L);
  str=(char *)tag_GetTagData(taglist,TAG_GUI_STR,0L);
  width=(int )tag_GetTagData(taglist,TAG_GUI_WIDTH,0L);

  ret=sti=gui_GetTextFitLength(TAG_GUI_FONT,font,TAG_GUI_STR,str,TAG_GUI_WIDTH,width);
  store=str[sti];
  str[sti]='\0';
  if(store!=' '&&store!='\n'&&store!='\0')
  {
    del1=strrchr(str,'\n');
    del2=strrchr(str,' ');
    if(del1!=NULL||del2!=NULL)
    {
      del=del2;
      if(del1<del2&&del1!=NULL) del=del1;
      ret=del-str;
    }
  }
  str[sti]=store;

  debug_End();

  return((u32)++ret);
}


/*
Window_t *gui_FindWindow(Gadget_t *gadgetroot)
{
  Node_t *node;
  Window_t *win=NULL;

  debug_Begin();

  for(node=list_GetNodeHead(windowlist);node!=NULL;node=list_GetNodeNext(windowlist,node))
  {
    win=(Window_t *)list_GetNodeData(node);
    if(win!=NULL&&win->gadgetroot==gadgetroot) break;
    win=NULL;
  }

  debug_End();

  return(win);
}
*/



int gui_Event(u32 conn, struct glw_Event *event)
{
  int ret=0;
  int handled=0;
  Window_t *win;
  gui_Timer_t *timer;
  struct glw_SockMsg *msg;

  debug_Begin();

  win=(Window_t *)glw_GetWindowUserdata(TAG_GLW_WINDOW,event->window,TAG_DONE);

  debug_Message("event=%lx, data=%ld",event->event,event->data);

  if((event->mask&event->event)==0)
  {
    switch(event->event)
    {
      case GLWEV_DAMAGE:
      {
        debug_Message("GLWEV_DAMAGE");
        window_DamageWindow(win,(Rect_t *)event->data);
        handled=1;
        break;
      }
      case GLWEV_WINDOW:
      {
        debug_Message("GLWEV_WINDOW");
        switch(event->data)
        {
          case GLWEVD_REPAINT:
          case GLWEVD_SIZING:
          {
            window_RefreshWindow(TAG_WIN_OBJECT,win,TAG_DONE);
            handled=1;
            break;
          }
          case GLWEVD_SIZEBEGIN:
          {
            // vizualis jelzes: size
            handled=1;
            break;
          }
          case GLWEVD_SIZEEND:
          {
            // vizualis jelzes vege
            handled=1;
            break;
          }
          case GLWEVD_MOVING:
          {
            // semmi teendo
            handled=1;
            break;
          }
          case GLWEVD_MOVEBEGIN:
          {
            // vizualis jelzes: move
            handled=1;
            break;
          }
          case GLWEVD_MOVEEND:
          {
            // vizualis jelzes vege
            handled=1;
            break;
          }
        }
        break;
      }
      case GLWEV_TIMER:
      {
        // handle timeouts
        debug_Message("GLWEV_TIMER");
        timer=(gui_Timer_t *)event->data;
        if(0==(timer->callback(win,timer->userdata)))
        {
          if((timer->flags&GUI_TIMER_REPEAT)!=0) glw_TimerStart(TAG_GLW_WINDOW,win->handle,TAG_GLW_MILLISEC,timer->millisec,TAG_GLW_USERDATA,(u32)timer,TAG_DONE);
          else gui_TimerDelete(timer);
        }
        else gui_TimerDelete(timer);
        handled=1;
        break;
      }
      case GLWEV_ACTIVATION:
      {
        // window border color change
        debug_Message("GLWEV_ACTIVATION");
        if(event->data==GLWEVD_ACTIVATE)
        {
          window_WindowEvent(win,0L,CBK_WINDOW_ACTIVATED,window_GetUserdata(TAG_WIN_OBJECT,win,TAG_DONE));
        }
        if(event->data==GLWEVD_INACTIVATE)
        {
          window_WindowEvent(win,0L,CBK_WINDOW_INACTIVATED,window_GetUserdata(TAG_WIN_OBJECT,win,TAG_DONE));
        }
        handled=1;
        break;
      }
      case GLWEV_SYSTEM:
      {
        debug_Message("GLWEV_SYSTEM");
        if(event->data==GLWEVD_QUIT) ret=1;
        handled=1;
        break;
      }
      case GLWEV_SOCKET:
      {
        debug_Message("GLWEV_SOCKET");
        handled=1;
        if(event->data!=0L)
        {
          if(NULL!=(msg=mem_malloc(sizeof(struct glw_SockMsg))))
          {
            memcpy(msg,(struct glw_SockMsg *)event->data,sizeof(struct glw_SockMsg));
            ret=net_SerProcessMessage(conn,event->userdata,msg);
            if(ret<0)
            {
//MSG              printf("(1) az event-et nem kell a tovabbiakban feldolgozni.\n");
            }
          }
        }
        else
        {
          ret=net_SerProcessMessage(conn,event->userdata,NULL);
        }
        if(ret<0) ret=0;
        break;
      }
    }
    if(handled==0&&win!=NULL&&!window_IsSleep(win))
    {
      ret=gadget_PostMessage(TAG_GADGET_WINDOW,win,TAG_GADGET_OBJECT,window_GetRootGadget(win),TAG_GADGET_EVENT,event,TAG_DONE);
      if(ret<0) ret=0;
    }
  }

  debug_End();

  return(ret);
}


static void gui_check_types(void)
{
  int er=0;

  if(sizeof(void *)>sizeof(u32))
  {
    printf("sizeof(u32) < sizeof(void*)  Recompile the system!\n");
    er=1;
  }
  if(er!=0)
  {
    printf("Fatal error exiting.\n");
    exit(0);
  }
}


int gui_Init(void)
{
  int ret=-1;

  debug_Begin();

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[GUI_ISOVERLAP-GUI_FUNCBASE]=gui_IsOverlapTL;
  call_vector[GUI_CALCULATEOVERLAP-GUI_FUNCBASE]=gui_CalculateOverlapTL;
  call_vector[GUI_LOADFILE-GUI_FUNCBASE]=gui_LoadFileTL;
  call_vector[GUI_LOADSUBGADGETDESCRIPTOR-GUI_FUNCBASE]=gui_LoadSubgadgetDescriptorTL;
  call_vector[GUI_ISINSIDE-GUI_FUNCBASE]=gui_IsInsideTL;
  call_vector[GUI_TIMERCANCEL-GUI_FUNCBASE]=gui_TimerCancelTL;
  call_vector[GUI_GETLIMITEDTEXTLENGTH-GUI_FUNCBASE]=gui_GetLimitedTextLengthTL;
  call_vector[GUI_GETTEXTFITLENGTH-GUI_FUNCBASE]=gui_GetTextFitLengthTL;
  call_vector[GUI_GETTEXTWRAPLENGTH-GUI_FUNCBASE]=gui_GetTextWrapLengthTL;
  call_vector[GUI_TIMERSTART-GUI_FUNCBASE]=gui_TimerStartTL;
  call_vector[GUI_UNLOADSUBGADGETDESCRIPTOR-GUI_FUNCBASE]=gui_UnLoadSubgadgetDescriptorTL;
//Initialize call vector END
  bases_modules.gui_Call=gui_Call;
  bases_modules.gui_CallTL=gui_CallTL;

  gui_check_types();

  term_Init();
  bitmap_Init();
  window_Init();
  net_Init();
  gadget_Init();
  img_Init();
  prefs_Init();
  skin_Init();
  gxml_Init();

  ret=0;

  debug_End();

  return(ret);
}


void gui_CleanUp(void)
{
  debug_Begin();

  gxml_CleanUp();
  skin_CleanUp();
  prefs_CleanUp();
  img_CleanUp();
  gadget_CleanUp();
  net_CleanUp();
  window_CleanUp();
  bitmap_CleanUp();
  term_CleanUp();

  debug_End();
}



int gui_ServerMain(u32 conn)
{
  gui_App_t *app;
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;

  debug_Begin();

  if(NULL!=(app=mem_malloc(sizeof(gui_App_t))))
  {
    if(NULL!=(app->windowlist=list_CreateList()))
    {
      cuser->app=(u32)app;
      app->conn=conn;
      app->name=cuser->appname;
      net_SerSendApp(conn);
      if(NULL!=(app->prefs=prefs_InitApp(app->name)))
      {
        if(NULL!=(app->locale=locale_Init(app,langs,prefs_GetString(app->prefs,"language","en"))))
        {
          if(NULL!=(app->skin=skin_CreateSkin(app,prefs_GetString(app->prefs,"skin","tst3Skin"))))
          {
            debug_Message("The new client is up.");
            glw_MainLoop(conn,0L,0L);
            window_CloseAllWindows(app);
            skin_DeleteSkin(app->skin);
          }
          locale_CleanUp(app->locale);
        }
        prefs_CleanUpApp(app->prefs);
      }
      list_DeleteList(app->windowlist);
    }
    mem_free(app);
  }

  debug_End();

  return(0);
}


static int gui_TimerCanceller(Window_t *win, u32 userdata)
{
  debug_Begin();
  debug_End();
  return(1);
}


void gui_TimerDelete(gui_Timer_t *timer)
{
  debug_Begin();

  if(timer!=NULL)
  {
    list_RemoveNode(window_GetTimerList(timer->win),timer->node);
    list_SetNodeData(timer->node,NULL);
    list_DeleteNode(timer->node);
    glw_TimerCancel(TAG_GLW_WINDOW,timer->win->handle,TAG_GLW_ID,timer->id,TAG_DONE);
    mem_free(timer);
  }

  debug_End();
}




/* OBSOLETE!!
 */
/*
u32 gui_CallGadget(u32 firsttag, ...)
{
  return(gui_CallGadgetTL((tag *)&firsttag));
}
u32 gui_CallGadgetTL(tag *taglist)
{
  u32 ret=~0L;
  tag *t;

  debug_Begin();

  if(NULL!=(t=tag_FindTag(taglist,TAG_GUI_WIN))) t->Name=TAG_GADGET_WINDOW;
  if(NULL!=(t=tag_FindTag(taglist,TAG_GUI_GADGET_ID))) t->Name=TAG_GADGET_GADGET_ID;
  if(NULL!=(t=tag_FindTag(taglist,TAG_GUI_METHOD))) t->Name=TAG_GADGET_METHOD;

  ret=gadget_MethodCallTL(taglist);

  debug_End();

  return(ret);
}
*/



u32 gui_Call(int function, u32 firsttag, ...)
{
  return(gui_CallTL(function,(tag *)&firsttag));
}
u32 gui_CallTL(int function, tag *taglist)
{
  u32 ret=~0L;

  debug_Begin();

  debug_Message("function ID : %d",function-GUI_FUNCBASE);

  if(function>=GUI_FUNCBASE&&function<GUI_FUNC_DONE)
  {
    ret=call_vector[function-GUI_FUNCBASE](taglist);
  }
  else debug_Warning("%s(): Function code out of range! code=0x%04x",__FUNCTION__,function);

  debug_End();

  return(ret);
}



//END//

---