---

Skin.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 <stdlib.h>
#include <string.h>

#define __SKIN_MODULE

#include "debug.h"
#include "Memory.h"
#include "Net.h"
#include "Common.h"
#include "Crc.h"
#include "Skin.h"
#include "Image.h"
#include "Gadget.h"



struct skin_Class_s
{
  char *name;
  int counter;
  u32 module;
  Node_t *node;
  Skin_t *(*CreateSkin)(gui_App_t *app, char *path);
  void (*DeleteSkin)(Skin_t *skin);
  int (*RenderBehind)(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state);
  int (*RenderOver)(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state);
  int (*RenderBackground)(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state);
  int (*RenderCustom)(Skin_t *skin, Gadget_t *gad, Rect_t *rect, int custom);
  int (*GetExtent)(Skin_t *skin, Gadget_t *gad, Extent_t *ext, Extent_t *outer);
  int (*GetInnerRect)(Skin_t *skin, Gadget_t *gad, Rect_t *rect, Rect_t *inner);
  int (*FillColorTable)(Skin_t *skin, Gadget_t *gad, int state);
  int (*FillGadgetInfo)(Skin_t *skin, Gadget_t *gad);
  u32 (*GetFont)(Skin_t *skin, Gadget_t *gad);
  int (*LoadSkin)(Skin_t *skin, char *gadget_class);
  int (*UnloadSkin)(Skin_t *skin, u32 class_id);
  u32 (*GetCustomTaglist)(Skin_t *skin, Gadget_t *gad);
};


static u32 (*call_vector[SKIN_FUNC_DONE-SKIN_FUNCBASE+1])(tag *);

static List_t *skinclasslist=NULL;


u32 skin_RegisterSkin(u32 firsttag, ...)
{
  return(skin_RegisterSkinTL((tag *)&firsttag));
}
u32 skin_RegisterSkinTL(tag *taglist)
{
  char *name;
  u32 module;
  Skin_t *(*CreateSkin)(gui_App_t *,char *);
  void (*DeleteSkin)(Skin_t *);
  int (*RenderBehind)(Skin_t *,Gadget_t *,Rect_t *,u32);
  int (*RenderOver)(Skin_t *,Gadget_t *,Rect_t *,u32);
  int (*RenderBackground)(Skin_t *,Gadget_t *,Rect_t *,u32);
  int (*RenderCustom)(Skin_t *,Gadget_t *,Rect_t *,int);
  int (*GetExtent)(Skin_t *,Gadget_t *,Extent_t *,Extent_t *);
  int (*GetInnerRect)(Skin_t *,Gadget_t *,Rect_t *,Rect_t *);
  int (*FillColorTable)(Skin_t *,Gadget_t *,int);
  int (*FillGadgetInfo)(Skin_t *,Gadget_t *);
  u32 (*GetFont)(Skin_t *,Gadget_t *);
  int (*LoadSkin)(Skin_t *,char *);
  int (*UnloadSkin)(Skin_t *,u32);
  u32 (*GetCustomTaglist)(Skin_t *skin, Gadget_t *gad);

  int ret=-1;
  Node_t *node;
  skin_Class_t *skinclass;

  debug_Begin();

  name=(char *)tag_GetTagData(taglist,TAG_SKIN_NAME,0L);
  module=(u32)tag_GetTagData(taglist,TAG_SKIN_MODULE,0L);
  CreateSkin=(Skin_t *(*)(gui_App_t *,char *))tag_GetTagData(taglist,TAG_SKIN_CREATESKIN,0L);
  DeleteSkin=(void (*)(Skin_t *))tag_GetTagData(taglist,TAG_SKIN_DELETESKIN,0L);
  RenderBehind=(int (*)(Skin_t *,Gadget_t *,Rect_t *,u32))tag_GetTagData(taglist,TAG_SKIN_RENDERBEHIND,0L);
  RenderOver=(int (*)(Skin_t *,Gadget_t *,Rect_t *,u32))tag_GetTagData(taglist,TAG_SKIN_RENDEROVER,0L);
  RenderBackground=(int (*)(Skin_t *,Gadget_t *,Rect_t *,u32))tag_GetTagData(taglist,TAG_SKIN_RENDERBACKGROUND,0L);
  RenderCustom=(int (*)(Skin_t *,Gadget_t *,Rect_t *,int))tag_GetTagData(taglist,TAG_SKIN_RENDERCUSTOM,0L);
  GetExtent=(int (*)(Skin_t *,Gadget_t *,Extent_t *,Extent_t *))tag_GetTagData(taglist,TAG_SKIN_GETEXTENT,0L);
  GetInnerRect=(int (*)(Skin_t *,Gadget_t *,Rect_t *,Rect_t *))tag_GetTagData(taglist,TAG_SKIN_GETINNERRECT,0L);
  FillColorTable=(int (*)(Skin_t *,Gadget_t *,int))tag_GetTagData(taglist,TAG_SKIN_FILLCOLORTABLE,0L);
  FillGadgetInfo=(int (*)(Skin_t *,Gadget_t *))tag_GetTagData(taglist,TAG_SKIN_FILLGADGETINFO,0L);
  GetFont=(u32 (*)(Skin_t *,Gadget_t *))tag_GetTagData(taglist,TAG_SKIN_GETFONT,0L);
  LoadSkin=(int (*)(Skin_t *,char *))tag_GetTagData(taglist,TAG_SKIN_LOADSKIN,0L);
  UnloadSkin=(int (*)(Skin_t *,u32))tag_GetTagData(taglist,TAG_SKIN_UNLOADSKIN,0L);
  GetCustomTaglist=(u32 (*)(Skin_t *, Gadget_t *))tag_GetTagData(taglist,TAG_SKIN_GETCUSTOMTAGLIST,0L);

  if(CreateSkin!=NULL&&name!=NULL&&NULL!=(skinclass=mem_calloc(1,sizeof(skin_Class_t))))
  {
    if(NULL!=(node=list_CreateNode()))
    {
      skinclass->name=common_strdup(name);
      skinclass->counter=0;
      skinclass->node=node;
      skinclass->module=module;
      skinclass->CreateSkin=CreateSkin;
      skinclass->DeleteSkin=DeleteSkin;
      skinclass->RenderBehind=RenderBehind;
      skinclass->RenderOver=RenderOver;
      skinclass->RenderBackground=RenderBackground;
      skinclass->RenderCustom=RenderCustom;
      skinclass->GetExtent=GetExtent;
      skinclass->GetInnerRect=GetInnerRect;
      skinclass->FillColorTable=FillColorTable;
      skinclass->FillGadgetInfo=FillGadgetInfo;
      skinclass->GetFont=GetFont;
      skinclass->LoadSkin=LoadSkin;
      skinclass->UnloadSkin=UnloadSkin;
      skinclass->GetCustomTaglist=GetCustomTaglist;
      list_SetNodeData(node,skinclass);
      list_InsertNodeTail(skinclasslist,node);
      ret=0;
    }
  }

  debug_End();

  return((u32)ret);
}


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

  debug_Begin();

  call_vector[SKIN_REGISTERSKIN-SKIN_FUNCBASE]=skin_RegisterSkinTL;
  bases_modules.skin_Call=skin_Call;
  bases_modules.skin_CallTL=skin_CallTL;

  if(NULL!=(skinclasslist=list_CreateList()))
  {
    ret=0;
  }

  debug_End();

  return(ret);
}


void skin_CleanUp(void)
{
  Node_t *node;

  debug_Begin();

  if(skinclasslist!=NULL)
  {
    while(NULL!=(node=list_RemoveNodeHead(skinclasslist)))
    {
      skin_Class_t *skinclass;
      if(NULL!=(skinclass=(skin_Class_t *)list_GetNodeData(node)))
      {
        glw_CloseModule(skinclass->module);
        if(skinclass->name!=NULL) mem_free(skinclass->name);
        mem_free(skinclass);
      }
      list_DeleteNode(node);
    }
    list_DeleteList(skinclasslist);
  }

  debug_End();
}


Skin_t *skin_CreateSkin(gui_App_t *app, char *skinname)
{
  Skin_t *ret=NULL;

  debug_Begin();

  if(skinname!=NULL)
  {
    char *skinpath;
    if(NULL!=(skinpath=mem_malloc(strlen(skinname)+2)))
    {
      char *fnam;
      strcpy(skinpath,skinname);
      strcat(skinpath,"/");
      if(NULL!=(fnam=mem_malloc(strlen(skinpath)+4)))
      {
        int fsiz;
        char *id;
        strcpy(fnam,skinpath);
        strcat(fnam,"_ID");
        if(NULL!=(id=(char *)net_LoadFile(TAG_NET_CONN,app->conn,TAG_NET_NAME,fnam,TAG_NET_LEN,&fsiz,TAG_DONE)))
        {
          int i;
          char *classname;
          for(i=0;i<fsiz;i++) if(((unsigned char)id[i])<32||((unsigned char)id[i])>127) id[i]='\0';
          if(NULL!=(classname=mem_calloc(1,fsiz+1)))
          {
            Node_t *node;
            skin_Class_t *skinclass=NULL;
            memcpy(classname,id,fsiz);
            for(node=list_GetNodeHead(skinclasslist);node!=NULL;node=list_GetNodeNext(skinclasslist,node))
            {
              if(NULL!=(skinclass=(skin_Class_t *)list_GetNodeData(node)))
              {
                        if(strcmp(skinclass->name,classname)==0) break;
                skinclass=NULL;
              }
            }
            if(skinclass==NULL)
            {
              char *name;
              //SEMAPHORE BEGIN
              if(NULL!=(name=mem_malloc(strlen(classname)+1+5+6)))
              {
                strcpy(name,"skins/");
                strcat(name,classname);
                strcat(name,".skin");
                //NET ha nem sikerul, kerjuk el a klienstol!
                if(0L==(glw_OpenModule(name)))
                {
                  u8 *skinfile;
                  int slen;
                  FILE *f;
                  if(NULL!=(skinfile=(u8 *)net_LoadFile(TAG_NET_CONN,app->conn,TAG_NET_NAME,name,TAG_NET_LEN,&slen,TAG_DONE)))
                  {
                    if(NULL!=(f=fopen(name,"wb")))
                    {
                      fwrite(skinfile,1,slen,f);
                      fclose(f);
                    }
                    mem_free(skinfile);
                    if(0L!=glw_OpenModule(name)) debug_Warning("Cannot open downloaded module '%s'!",name);
                  }
                  else debug_Warning("Cannot find module '%s'!",name);
                }
                mem_free(name);
                for(node=list_GetNodeHead(skinclasslist);node!=NULL;node=list_GetNodeNext(skinclasslist,node))
                {
                  if(NULL!=(skinclass=(skin_Class_t *)list_GetNodeData(node)))
                  {
                            if(strcmp(skinclass->name,classname)==0) break;
                    skinclass=NULL;
                  }
                }
              }
              //SEMAPHORE END
            }
            mem_free(classname);
            if(skinclass!=NULL&&NULL!=(ret=skinclass->CreateSkin(app,skinpath)))
            {
              skin_Common_t *common;
              common=(skin_Common_t *)ret;
              common->skinclass=skinclass;
              common->path=skinpath;
              skinclass->counter++;
            }
          }
          mem_free(id);
        }
        mem_free(fnam);
      }
    }
  }
  if(ret==NULL) debug_Error("cannot create skin");

  debug_End();

  return(ret);
}


void skin_DeleteSkin(Skin_t *skin)
{
  skin_Common_t *common;
  skin_Class_t *skinclass;

  debug_Begin();

  common=(skin_Common_t *)skin;
  if(skin!=NULL)
  {
    skinclass=common->skinclass;
    if(common->path!=NULL) mem_free(common->path);
    common->path=NULL;
    skinclass->DeleteSkin(skin);
//SEMAPHORE BEGIN
    skinclass->counter--;
    if(skinclass->counter==0&&skinclass->module!=0L)
    {
      list_RemoveNode(skinclasslist,skinclass->node);
      glw_CloseModule(skinclass->module);
      if(skinclass->name!=NULL) mem_free(skinclass->name);
      list_DeleteNode(skinclass->node);
      mem_free(skinclass);
    }
  }
//SEMAPHORE END

  debug_End();
}




int skin_RenderBackground(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&rect!=NULL)
  {
    ret=common->skinclass->RenderBackground(skin,gad,rect,state);
  }

  debug_End();

  return(ret);
}


int skin_RenderBehind(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&rect!=NULL)
  {
    ret=common->skinclass->RenderBehind(skin,gad,rect,state);
  }

  debug_End();

  return(ret);
}


int skin_RenderOver(Skin_t *skin, Gadget_t *gad, Rect_t *rect, u32 state)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&rect!=NULL)
  {
    ret=common->skinclass->RenderOver(skin,gad,rect,state);
  }

  debug_End();

  return(ret);
}


int skin_RenderCustom(Skin_t *skin, Gadget_t *gad, Rect_t *rect, int custom)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&rect!=NULL)
  {
    ret=common->skinclass->RenderCustom(skin,gad,rect,custom);
  }

  debug_End();

  return(ret);
}


int skin_GetExtent(Skin_t *skin, Gadget_t *gad, Extent_t *ext, Extent_t *outer)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&ext!=NULL&&outer!=NULL)
  {
    ret=common->skinclass->GetExtent(skin,gad,ext,outer);
  }

  debug_End();

  return(ret);
}


int skin_GetInnerRect(Skin_t *skin, Gadget_t *gad, Rect_t *rect, Rect_t *inner)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL&&rect!=NULL&&inner!=NULL)
  {
    ret=common->skinclass->GetInnerRect(skin,gad,rect,inner);
  }

  debug_End();

  return(ret);
}


int skin_FillGadgetInfo(Skin_t *skin, Gadget_t *gad)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL)
  {
    ret=common->skinclass->FillGadgetInfo(skin,gad);
  }

  debug_End();

  return(ret);
}


int skin_FillColorTable(Skin_t *skin, Gadget_t *gad, int state)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL)
  {
    ret=common->skinclass->FillColorTable(skin,gad,state);
  }

  debug_End();

  return(ret);
}


int skin_GetFont(Skin_t *skin, Gadget_t *gad)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL)
  {
    ret=common->skinclass->GetFont(skin,gad);
  }

  debug_End();

  return(ret);
}


int skin_LoadSkin(Skin_t *skin, char *class)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&class!=NULL)
  {
    ret=common->skinclass->LoadSkin(skin,class);
  }

  debug_End();

  return(ret);
}


int skin_UnloadSkin(Skin_t *skin, u32 class_id)
{
  int ret=-1;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL)
  {
    ret=common->skinclass->UnloadSkin(skin,class_id);
  }

  debug_End();

  return(ret);
}


tag *skin_GetCustomTaglist(Skin_t *skin, Gadget_t *gad)
{
  tag *ret=NULL;
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL&&gad!=NULL)
  {
    ret=(tag *)common->skinclass->GetCustomTaglist(skin,gad);
  }

  debug_End();

  return(ret);
}


char *skin_GetWindowDecorationName(Skin_t *skin)
{
  char *ret=NULL;
  char name[]="WindowDecoration.xml";
  skin_Common_t *common=(skin_Common_t *)skin;

  debug_Begin();

  if(skin!=NULL)
  {
    if(NULL!=(ret=mem_malloc(strlen(common->path)+sizeof(name)+1)))
    {
      strcpy(ret,common->path);
      strcat(ret,name);
    }
  }

  debug_End();

  return(ret);
}


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

  debug_Begin();

  debug_Message("%s() function ID : %d",__FUNCTION__,function-SKIN_FUNCBASE);

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

  debug_End();

  return(ret);
}

---