---

Client.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
 *
 */
#include <string.h>
#include <zlib.h>

#include "Client.h"
#include "Memory.h"
#include "App.h"
#include "Window.h"
#include "NetCommon.h"
#include "Common.h"
//#include "Prefs.h"
#include "debug.h"
#include "xml_Gui.h"


typedef struct client_Window_s
{
  Window_t *window;
  char *name;
  int (*event_handler)(gui_App_t *app, Window_t *win, u32 gadget_id, int event, u32 event_data);
  gui_App_t *app;
  Node_t *node;
  List_t *timerlist;
  int timer_stop;
  u32 userdata;
} client_Window_t;


typedef struct client_File_s
{
  u8 *data;
  u32 type;
  int size;
  int real_size;
} client_File_t;


typedef struct client_Timer_s
{
  u32 timer;
  u32 millis;
  u32 flags;
  u32 userdata;
  client_Window_t *nwin;
} client_Timer_t;


static u32 client_CliSRq_CallGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist);
static u32 client_CliARq_CallGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist);
static void client_CliARq_CloseWindow(gui_App_t *app, Window_t *win);
static Window_t *client_CliSRq_OpenWindowTL(gui_App_t *app, Rect_t *rect, char *window_name, int (*event_handler)(gui_App_t *,Window_t *,u32,int,u32), u32 flags, tag *taglist);


static client_Window_t *client_FindWindow(List_t *winlist, Window_t *win)
{
  client_Window_t *ret=NULL;
  Node_t *node;

  debug_Begin();

  for(node=list_GetNodeHead(winlist);node!=NULL;node=list_GetNodeNext(winlist,node))
  {
    ret=(client_Window_t *)list_GetNodeData(node);
    if(win==ret->window) break;
    ret=NULL;
  }

  debug_End();

  return(ret);
}


static /*@null@*/ char *client_LoadFile(char *name, int *len)
{
  char *ret=NULL;
  size_t file_len;
  FILE *f;

  debug_Begin();

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

  debug_End();

  return(ret);
}


static u32 client_GetClientId(void)
{
  static u32 curr_id=2;
  return(curr_id+=2);
}


static void client_ClientCleanup(gui_App_t *app)
{
  debug_Begin();

  if(app!=NULL&&0L!=app->conn)
  {
    net_ClearMsgList(app->conn);
  }

  debug_End();
}


// byteorder: 0-azonos, 1-kulonbozo
static int client_ClientInit(gui_App_t *app, int *byteorder)
{
  int ret=-1,rl,mlen;
  char *init, *initstr="?GUI L v1.1 ";
  char reply[]=".. . ..";
  struct glw_ConnUser *cuser;

  debug_Begin();

  if(app!=NULL&&NULL!=(cuser=(struct glw_ConnUser *)app->conn))
  {
    if(cuser->waitlist!=NULL) client_ClientCleanup(app);
    mlen=strlen(initstr)+strlen(app->name)+1;
    if(NULL!=(init=mem_malloc((size_t)mlen))&&NULL!=(cuser->waitlist=list_CreateList()))
    {
      strcpy(init,initstr);
      strcat(init,app->name);
      if(0<=(glw_Send(app->conn,(u8 *)init,mlen)))
      {
        rl=glw_Recv(app->conn,(u8 *)reply,7);
        debug_Message("reply: '%s'",reply);
        if(reply[3]=='L') *byteorder=0;
        else *byteorder=1;
        if(strncmp(reply,"OK",2)==0) ret=0;
        else debug_Error("Connection failed (code: %c%c)",reply[0],reply[1]);
      }
      mem_free(init);
    }
  }

  debug_End();

  return(ret);
}


void client_SendCloseApp(u32 conn, gui_App_t *app)
{
  u32 m;

  debug_Begin();

  m=glw_htonl((u32)app);
  (void)glw_SendMsg(conn,REQ_CCLOSEAPP,client_GetClientId(),(u8 *)&m,4);
  glw_CloseApp(conn);

  debug_End();
}


static int client_IsCompressableType(char *filename, u8 *file, int len)
{
  int ret=0;

  debug_Begin();

  if(len>128)
  {
    if(strstr(filename,"xml")!=NULL&&strncmp("<?xml",(char *)file,5)==0) ret=1;
    else if(file[0]=='M'&&file[1]=='Z'&&file[2]==0x90) ret=1;
  }

  debug_End();

  return(ret);
}


static u8 *client_LoadAFile(char *filename, u32 *type, int *size, int *orig_len)
{
  u8 *send_file=NULL,*file;
  int send_len,len=0;

  debug_Begin();

  if(orig_len!=NULL) *orig_len=0;
  if(size!=NULL) *size=0;
  if(type!=NULL) *type=FT_NORMAL;
  if(filename!=NULL&&NULL!=(file=(u8 *)client_LoadFile(filename,&len)))
  {
    if(orig_len!=NULL) *orig_len=len;
    send_file=file;
    send_len=len;
    if(client_IsCompressableType(filename,file,len)!=0)
    {
      send_len=(len*1.01)+12;
      if(NULL!=(send_file=mem_malloc(send_len)))
      {
        (void)compress(send_file,(u32 *)&send_len,file,(uLong)len);
        mem_free(file);
        if(type!=NULL) *type=FT_DEFLATED;
      }
      else send_len=len;
    }
    if(size!=NULL) *size=send_len;
  }

  debug_End();

  return(send_file);
}


static int client_LoadFiles(u32 conn, u8 **bd, u32 msgid)
{
  int ret=-1,i;
  int filecnt,msg_size=0;
  char *name;
  client_File_t *files;
  u8 *msg,*m,*msg2;

  debug_Begin();

  if(bd!=NULL)
  {
    filecnt=net_MarshalGetLong(bd);
    if(NULL!=(files=mem_malloc(filecnt*sizeof(client_File_t))))
    {
      for(i=0;i<filecnt;i++)
      {
        name=net_MarshalGetString(bd);
        files[i].data=client_LoadAFile(name,&files[i].type,&files[i].size,&files[i].real_size);
        mem_free(name);
        msg_size+=files[i].size+12;
      }
      if(NULL!=(msg=mem_malloc(msg_size)))
      {
        m=msg;
        for(i=0;i<filecnt;i++)
        {
          m=net_MarshalPutLong(m,files[i].type);
          m=net_MarshalPutLong(m,files[i].real_size);
          m=net_MarshalPutBinary(m,files[i].data,files[i].size);
        }
        if(NULL!=(msg2=mem_malloc(msg_size+4)))
        {
          net_MarshalPutBinary(msg2,msg,msg_size);
          glw_SendMsg(conn,REQ_SLOADFILES|FL_REPLY,msgid,msg2,msg_size+4);
          mem_free(msg2);
        }
        mem_free(msg);
      }
      for(i=0;i<filecnt;i++) if(NULL!=files[i].data) mem_free(files[i].data);
      mem_free(files);
    }
  }

  debug_End();

  return(ret);
}


int client_CliProcessMessage(u32 conn, u32 userdata, struct glw_SockMsg *messg)
{
  int ret=0,fromwait,stored=0;
  u8 *bd,*reply,*m;
  struct glw_ConnUser *cuser=(struct glw_ConnUser *)conn;
  gui_App_t *app=(gui_App_t *)userdata;
  struct glw_SockMsg *msg=NULL;

  debug_Begin();

  if(messg!=NULL)
  {
    fromwait=0;
    if(NULL!=(msg=mem_malloc(sizeof(struct glw_SockMsg))))
    {
      memcpy(msg,messg,sizeof(struct glw_SockMsg));
    }
  }
  else fromwait=1;
  do
  {
    if(fromwait!=0||msg==NULL) msg=net_MsgFromWaitList(conn);
    if(msg==NULL) break;
//    printf("%s() socket message arrived. type=0x%02x id=%ld length: %ld\n",__FUNCTION__,msg->type,msg->id,msg->length);
    bd=msg->body;
    switch(msg->type)
    {
      case REQ_SAPP:
      {
        if(net_GetWaitfor(conn)==msg->type)
        {
          cuser->app=net_MarshalGetLong(&bd);
          ret=1;
        }
        break;
      }
      case REQ_SECHO:
      {
        glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,NULL,0);
        break;
      }
      case REQ_SLOADFILES:
      {
        client_LoadFiles(conn,&bd,msg->id);
        break;
      }
      case REQ_SLOADFILE:
      {
        char *filename;
        u8 *send_file;
        u32 type;
        int send_len,msglen,ok=0,len;
        char empty[4+8];

        filename=net_MarshalGetString(&bd);
        if(NULL!=(send_file=client_LoadAFile(filename,&type,&send_len,&len)))
        {
          msglen=send_len+4+8;
          if(NULL!=(reply=mem_malloc(msglen)))
          {
            m=reply;
            m=net_MarshalPutLong(m,type);
            m=net_MarshalPutLong(m,len);
            m=net_MarshalPutBinary(m,send_file,send_len);
            glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,reply,msglen);
            mem_free(reply);
            ok=1;
          }
          mem_free(send_file);
        }
        if(ok==0)
        {
          m=empty;
          m=net_MarshalPutLong(m,FT_NORMAL);
          m=net_MarshalPutLong(m,0);
          m=net_MarshalPutBinary(m,NULL,0);
          glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,empty,sizeof(empty));
        }
        mem_free(filename);
        break;
      }
      case REQ_SWINEVENT:
      {
        u32 rapp,gadget_id,event,event_data,ret;
        client_Window_t *nwin;
        Window_t *win;
        int msglen;
        u8 r[16];

        if(cuser->waitfor==REQ_NONE)
        {
          rapp=net_MarshalGetLong(&bd);
          win=(Window_t *)net_MarshalGetLong(&bd);
          gadget_id=net_MarshalGetLong(&bd);
          event=net_MarshalGetLong(&bd);
          event_data=net_MarshalGetLong(&bd);
          nwin=client_FindWindow(app->windowlist,win);
          ret=(int)nwin->event_handler(app,(Window_t *)win,gadget_id,event,event_data);
          //if(ret>0) client_CloseWindow(app,win);
          m=r;
          if(ret==CLIENT_DISCARD_EVENT)
          {
//            printf("Event discard request: id=%ld  event=%ld\n",gadget_id,event);
            msglen=16;
            m=net_MarshalPutLong(m,ret);
            m=net_MarshalPutLong(m,(u32)win);
            m=net_MarshalPutLong(m,gadget_id);
            m=net_MarshalPutLong(m,event);
          }
          else
          {
            msglen=4;
            m=net_MarshalPutLong(m,ret);
          }
          glw_SendMsg(conn,msg->type|FL_REPLY,msg->id,r,msglen);
          ret=0;
        }
        else
        {
//          printf("SYSTEM BUSY, MSG STORED.\n");
          stored=net_MsgToWaitList(conn,msg);
        }
        break;
      }
      case REQ_CECHO|FL_REPLY:
      {
        break;
      }
      case REQ_CCALLGAD|FL_REPLY: // blokkolas vege
      {
        if(cuser->waitfor!=REQ_NONE)
        {
          if(msg->id==cuser->userdata&&cuser->waitfor==msg->type)
          {
            cuser->userdata=net_MarshalGetLong(&bd);
            cuser->waitfor=REQ_NONE;
            ret=1;
          }
          else debug_Error("invalid message order - not implemented yet");
        }
        break;
      }
      case REQ_COPENWIN|FL_REPLY: // blokkolas vege
      {
//printf("ABLAKREPLY MEGIS\n");
        if(msg->id==net_GetUserData(conn)&&net_GetWaitfor(conn)==msg->type)
        {
          cuser->userdata=net_MarshalGetLong(&bd);
          cuser->waitfor=REQ_NONE;
          ret=1;
        }
        else debug_Error("invalid message order - not implemented yet");
        break;
      }
      default:
      {
        debug_Error("Illegal message type: 0x%02x",(int)msg->type);
      }
    }
    if(stored==0)
    {
      mem_free(msg->body);
      mem_free(msg);
    }
    msg=NULL;
  }
  while(fromwait==0);

  debug_End();

  return(ret);
}



static int client_TaglistMsgLen(tag *taglist)
{
  int ret;
  tag *tags;

  debug_Begin();

  for(ret=4,tags=taglist;tags->Name!=TAG_DONE;tags=tag_GetNextTag(tags),ret+=4)
  {
    if((tags->Name&TAGT_STRING)!=0) ret+=net_StrMsgLen((char *)tags->Data);
    else ret+=4;
  }

  debug_End();

  return(ret);
}


u32 client_CallSGadget(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, u32 firsttag, ...)
{
  return(client_CliSRq_CallGadgetTL(app,window,gadget_id,method,(tag *)&firsttag));
}
u32 client_CallSGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist)
{
  return(client_CliSRq_CallGadgetTL(app,window,gadget_id,method,taglist));
}
u32 client_CallAGadget(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, u32 firsttag, ...)
{
  return(client_CliARq_CallGadgetTL(app,window,gadget_id,method,(tag *)&firsttag));
}
u32 client_CallAGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist)
{
  return(client_CliARq_CallGadgetTL(app,window,gadget_id,method,taglist));
}
void client_CloseWindow(gui_App_t *app, Window_t *win)
{
  client_CliARq_CloseWindow(app,win);
}
Window_t *client_OpenWindow(gui_App_t *app, Rect_t *rect, char *window_name, int (*event_handler)(gui_App_t *,Window_t *,u32,int,u32), u32 flags, u32 firsttag, ...)
{
  return(client_CliSRq_OpenWindowTL(app,rect,window_name,event_handler,flags,(tag *)&firsttag));
}
Window_t *client_OpenWindowTL(gui_App_t *app, Rect_t *rect, char *window_name, int (*event_handler)(gui_App_t *,Window_t *,u32,int,u32), u32 flags, tag *taglist)
{
  return(client_CliSRq_OpenWindowTL(app,rect,window_name,event_handler,flags,taglist));
}



/* Sync Gadget_t call (with retval)
 */
static u32 client_CliSRq_CallGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist)
{
  u32 ret,id;

  debug_Begin();

  id=client_CliARq_CallGadgetTL(app,window,gadget_id,method,taglist);
  net_SetState(app->conn,REQ_CCALLGAD|FL_REPLY,id);
  glw_MainLoopCli(app->conn,(u32)app);
  ret=net_GetUserData(app->conn);

  debug_End();

  return(ret);
}


/* Async Gadget_t call (weithout retval)
 */
static u32 client_CliARq_CallGadgetTL(gui_App_t *app, Window_t *window, u32 gadget_id, u32 method, tag *taglist)
{
  u32 id=0L;
  int mlen;
  u8 *msg,*m;

  debug_Begin();

  mlen=3*4+client_TaglistMsgLen(taglist);
  if(NULL!=(msg=mem_malloc(mlen)))
  {
    m=msg;
    m=net_MarshalPutLong(m,(u32)window);
    m=net_MarshalPutLong(m,gadget_id);
    m=net_MarshalPutLong(m,method);
    m=net_MarshalPutTaglist(m,taglist);
    glw_SendMsg(app->conn,REQ_CCALLGAD,id=client_GetClientId(),(u8 *)msg,mlen);
    mem_free(msg);
  }

  debug_End();

  return(id);
}


static void client_TimerClearList(gui_App_t *app, Window_t *win)
{
  Node_t *node;
  client_Window_t *nwin;
  client_Timer_t *ctimer;


  debug_Begin();

  if(app!=NULL)
  {
    if(NULL!=(nwin=client_FindWindow(app->windowlist,win)))
    {
      for(node=list_RemoveNodeHead(nwin->timerlist);node!=NULL;node=list_RemoveNodeHead(nwin->timerlist))
      {
        ctimer=(client_Timer_t *)list_GetNodeData(node);
        glw_TimerCancel((u32)nwin,ctimer->timer);
        mem_free(ctimer);
        list_DeleteNode(node);
      }
      list_DeleteList(nwin->timerlist);
    }
  }

  debug_End();
}


static void client_CliARq_CloseWindow(gui_App_t *app, Window_t *win)
{
  client_Window_t *nwin;
  u8 m[4];

  debug_Begin();

  if(NULL!=(nwin=client_FindWindow(app->windowlist,win)))
  {
    nwin->event_handler(app,win,0L,CBK_WINDOW_CLOSED,nwin->userdata);
    client_TimerClearList(app,win);
    list_RemoveNode(app->windowlist,nwin->node);
    list_SetNodeData(nwin->node,NULL);
    list_DeleteNode(nwin->node);
    if(nwin->name!=NULL) mem_free(nwin->name);
    mem_free(nwin);
    net_MarshalPutLong(m,(u32)win);
    glw_SendMsg(app->conn,REQ_CCLOSEWIN,client_GetClientId(),m,4);
  }

  debug_End();
}


void client_WinSleep(gui_App_t *app, Window_t *win)
{
  u8 m[4];
  u32 conn;

  debug_Begin();

  if(app!=NULL&&win!=NULL)
  {
    conn=app->conn;
    net_MarshalPutLong(m,(u32)win);
    glw_SendMsg(conn,REQ_CWINSLEEP,client_GetClientId(),(u8 *)&m,4);
  }

  debug_End();
}


void client_WinAwake(gui_App_t *app, Window_t *win)
{
  u8 m[4];
  u32 conn;

  debug_Begin();

  if(app!=NULL&&win!=NULL)
  {
    conn=app->conn;
    net_MarshalPutLong(m,(u32)win);
    glw_SendMsg(conn,REQ_CWINAWAKE,client_GetClientId(),(u8 *)&m,4);
  }

  debug_End();
}



static Window_t *client_CliSRq_OpenWindowTL(gui_App_t *app, Rect_t *rect, char *window_name, int (*event_handler)(gui_App_t *,Window_t *,u32,int,u32), u32 flags, tag *taglist)
{
  client_Window_t *nwin;
  Window_t *win=NULL;
  Node_t *node;
  u8 *msg,*m;
  struct glw_ConnUser *cuser;
  int mlen,checklist_count=0,i;
  gadget_Check_t *checklist=NULL;
  tag *t;
  u32 id;
  // 1. letrehozni egy net_Window-t
  // 2. kitoltjuk, handler, app, node, (win)
  // 3. felfuzni az app listajara
  // 4. marshalling (cuser->app, window_name, flags, taglist)
  // 5. elkuldeni a kerest
  // 6. set status -> waitfor reply
  // 7. mainloop
  // 8. retval kiszedese

  debug_Begin();

  cuser=(struct glw_ConnUser *)app->conn;
  if(NULL!=(node=list_CreateNode()))
  {
    mlen=0;
    if(NULL!=(t=tag_FindTag(taglist,TAG_WIN_CHECKLIST)))
    {
      checklist=(gadget_Check_t *)t->Data;
      if(checklist!=NULL) while(checklist[checklist_count].gadget_id!=GADGET_ILLEGAL_ID)
      {
        mlen+=net_StrMsgLen(checklist[checklist_count].class_name);
        checklist_count++;
      }
      t->Data=(u32)checklist_count;
    }
    mlen+=net_StrMsgLen(window_name)+4*2+client_TaglistMsgLen(taglist)+(checklist_count*sizeof(gadget_Check_t));
    if(NULL!=(msg=mem_malloc(mlen)))
    {
      m=msg;
      if(NULL!=(nwin=mem_calloc(1,sizeof(client_Window_t))))
      {
        if(NULL!=(nwin->timerlist=list_CreateList()))
        {
          nwin->userdata=tag_GetTagData(taglist,TAG_WIN_USERDATA,0L);
          nwin->name=common_strdup(window_name);
          nwin->event_handler=event_handler;
          nwin->app=app;
          nwin->node=node;
          list_SetNodeData(node,nwin);

          m=net_MarshalPutLong(m,cuser->app);
          m=net_MarshalPutString(m,window_name);
          m=net_MarshalPutLong(m,flags);
          m=net_MarshalPutTaglist(m,taglist);
          for(i=0;i<checklist_count;i++)
          {
            m=net_MarshalPutLong(m,checklist[i].gadget_id);
            m=net_MarshalPutString(m,checklist[i].class_name);
//            m=net_MarshalPutLong(m,checklist[i].class_id);
            m=net_MarshalPutLong(m,checklist[i].flags);
          }

          glw_SendMsg(app->conn,REQ_COPENWIN,id=client_GetClientId(),msg,mlen);
          cuser->waitfor=REQ_COPENWIN|FL_REPLY;
          cuser->userdata=id;
          glw_MainLoopCli(app->conn,(u32)app);
          win=(Window_t *)net_GetUserData(app->conn);
          nwin->window=win;
          if(win==NULL)
          {
            mem_free(nwin);
            list_DeleteNode(node);
          }
          else
          {
            list_InsertNodeTail(app->windowlist,node);
          }
        }
      }
      mem_free(msg);
    }
  }

  debug_End();

  return(win);
}


int client_Init(u32 conn, int *byteorder)
{
  gui_App_t *app;

  debug_Begin();

  if(NULL!=(app=mem_malloc(sizeof(gui_App_t))))
  {
    if(NULL!=(app->windowlist=list_CreateList()))
    {
      app->conn=conn;
      app->name=app_name();
      if(0==client_ClientInit(app,byteorder))
      {
//        app->prefs=prefs_InitApp(app->name);
                app->prefs=NULL;
        app->locale=NULL;

        net_SetState(conn,REQ_SAPP,0L);
        glw_MainLoopCli(conn,(u32)app);

        if(0==app_Init(app))
        {
          glw_MainLoopCli(conn,(u32)app);
          app_CleanUp(app);
        }

//        prefs_CleanUpApp(app->prefs);
        client_ClientCleanup(app);
      }
      list_DeleteList(app->windowlist);
    }
    mem_free(app);
  }

  debug_End();

  return(0);
}


u32 client_TimerStart(gui_App_t *app, Window_t *win, u32 millisec, int flags, u32 userdata, int (*callback)(Window_t *,u32))
{
  client_Window_t *nwin;
  client_Timer_t *ctimer=NULL;
  Node_t *node;

  debug_Begin();

  if(NULL!=(nwin=client_FindWindow(app->windowlist,win)))
  {
    if(NULL!=(ctimer=mem_malloc(sizeof(client_Timer_t))))
    {
      if(NULL!=(node=list_CreateNode()))
      {
        ctimer->nwin=nwin;
        ctimer->flags=flags;
        ctimer->userdata=userdata;
        list_SetNodeData(node,ctimer);
        list_InsertNodeHead(nwin->timerlist,node);
        ctimer->timer=glw_TimerStart((u32)nwin,millisec,(u32)ctimer);
      }
    }
  }

  debug_End();

  return((u32)ctimer);
}


void client_TimerHandler(u32 timer, u32 userdata)
{
  client_Timer_t *ctimer=(client_Timer_t *)userdata;

  debug_Begin();

  ctimer->nwin->event_handler(ctimer->nwin->app,ctimer->nwin->window,0L,GLWEV_TIMER,ctimer->userdata);
  if(ctimer->flags!=0L)
  {
  }

  debug_End();
}


int client_ChangeServer(gui_App_t *app, char *new_server)
{
  int port;

  debug_Begin();

  port=net_GetPort();
  /*
      1. check server
        1.1: connect
        1.2:
  */

  debug_End();

  return(0);
}


int client_ChangeSkin(gui_App_t *app, Window_t *win, char *skinname)
{
  u8 *msg,*m;
  u32 conn;
  int mlen;

  debug_Begin();

  if(app!=NULL&&win!=NULL&&skinname!=NULL)
  {
    conn=app->conn;
    mlen=net_StrMsgLen(skinname)+4;
    if(NULL!=(m=msg=mem_malloc(mlen)))
    {
      m=net_MarshalPutLong(m,(u32)win);
      net_MarshalPutString(m,skinname);
      glw_SendMsg(conn,REQ_CNEWSKIN,client_GetClientId(),(u8 *)msg,mlen);
      mem_free(msg);
    }
  }

  debug_End();

  return(0);
}

---