---

Gadget.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
 *
 */
/*
 *  gadget.c
 */
#include <string.h>

#include "debug.h"
#include "Memory.h"
#include "Crc.h"
#include "Common.h"
#include "Skin.h"
#include "Window.h"
#include "Gadget.h"
#include "Prefs.h"
#include "Net.h"
#include "Locale.h"
#include "gadgets/gadget_Group.h"


static u32 gadget_SetFont(Gadget_t *this_gadget, tag *taglist);
static u32 gadget_SetHint(Gadget_t *this_gadget, tag *taglist);

//Declare call_vector[]
static u32 (*call_vector[GADGET_FUNC_DONE-GADGET_FUNCBASE+1])(tag *);

static List_t *class_list=NULL;           //SEMAPHORE PROTECTED!
static gadget_Method_t no_methods[]={ GADGET_METHOD_DONE };
static gadget_Binding_t common_bind[]=
{
  {"font-name",TAG_GAD_FONTNAME,GADGET_STRING,""},
  {"font-size",TAG_GAD_FONTSIZE,GADGET_INT,NULL},
  {"font-style",TAG_GAD_FONTSTYLE,GADGET_SELECT,"normal|italic"},
  {"font-weight",TAG_GAD_FONTWEIGHT,GADGET_SELECT,"normal|bold"},
  {"font-decoration",TAG_GAD_FONTDECORATION,GADGET_SELECT,"normal|underline|line-through"},
  {"skin",TAG_GAD_SKIN,GADGET_STRING,""},
  {"hint",TAG_GAD_HINT,GADGET_STRING,""},
  {"width",TAG_GAD_WIDTH,GADGET_INT,NULL},            // pixel-ertek (ha <min -> min, ha >max -> max)
  {"height",TAG_GAD_HEIGHT,GADGET_INT,NULL},          // pixel-ertek (ha <min -> min, ha >max -> max)
  {"layout",TAG_GAD_LAYOUT,GADGET_SELECT,"free|fixed|square"},
  GADGET_BINDING_DONE
};
static gadget_Method_t gadget_methods[]=
{
  {"set_font",gadget_SetFont,0L},
  {"set_hint",gadget_SetHint,0L},
  GADGET_METHOD_DONE
};
static char *state_names[]=
{
  "Normal",
  "Pressed",
  "Disabled",
  "Focused",
  "Default",
  NULL
};


u32 gadget_Bind(u32 firsttag, ...)
{
  return(gadget_BindTL((tag *)&firsttag));
}
u32 gadget_BindTL(tag *taglist)
{
  Locale_t *locale;
  gadget_Binding_t *binding;
  char *name;
  char *value;
  u32 *tagname;
  u32 *tagvalue;

  int ret=-1;
  u32 tnam,tval=0L;
  gadget_Binding_t *cbind=NULL;
  int i;
  char *here;

  debug_Begin();

  locale=(Locale_t *)tag_GetTagData(taglist,TAG_GADGET_LOCALE,0L);
  binding=(gadget_Binding_t *)tag_GetTagData(taglist,TAG_GADGET_BINDING,0L);
  name=(char *)tag_GetTagData(taglist,TAG_GADGET_NAME,0L);
  value=(char *)tag_GetTagData(taglist,TAG_GADGET_VALUE,0L);
  tagname=(u32 *)tag_GetTagData(taglist,TAG_GADGET_TAGNAME,0L);
  tagvalue=(u32 *)tag_GetTagData(taglist,TAG_GADGET_TAGVALUE,0L);

  if(binding!=NULL&&name!=NULL&&value!=NULL)
  {
    for(i=0;binding[i].name!=NULL;i++) if(strcmp(binding[i].name,name)==0) { cbind=&binding[i]; break; }
    if(cbind!=NULL)
    {
      ret=0;
      tnam=cbind->tagname;
      switch(cbind->datatype)
      {
        case GADGET_INT:
        {
          // decimal (atoi), hexa (0x, #, $)
          if(strlen(value)>1)
          {
            if(value[0]=='0'&&value[1]=='x') sscanf(&value[2],"%lx",&tval);
            else if(value[0]=='#'||value[0]=='$') sscanf(&value[1],"%lx",&tval);
            else tval=atoi(value);
          }
          else tval=atoi(value);
          break;
        }
        case GADGET_STRING:
        {
          here=value;
          if(here[0]=='#'&&strlen(here)>1)
          {
            here++;
            if(here[0]!='#'&&locale!=NULL) here=(char *)locale_GetString(TAG_LOCALE_LOCALE,locale,TAG_LOCALE_MSG,here,TAG_DONE);
          }
          tval=(u32)here;
          break;
        }
        case GADGET_SELECT:
        {
          if(NULL!=(here=strstr(cbind->value_mask,value)))
          {
            for(tval=0L;here!=cbind->value_mask;here--) if(*here=='|') tval++;
          }
          break;
        }
        case GADGET_BOOL:
        {
          if(strcmp(value,"true")==0) tval=TRUE;
          else if(strcmp(value,"false")==0) tval=FALSE;
          else if(strcmp(value,"t")==0) tval=TRUE;
          else if(strcmp(value,"f")==0) tval=FALSE;
          else if(strcmp(value,"yes")==0) tval=TRUE;
          else if(strcmp(value,"no")==0) tval=FALSE;
          else if(strcmp(value,"on")==0) tval=TRUE;
          else if(strcmp(value,"off")==0) tval=FALSE;
          else { tnam=TAG_SKIP; debug_Error("Unknown boolean value"); }
          break;
        }
        default:
        {
          tnam=TAG_SKIP;
          ret=-1;
          debug_Error("Unknown datatype");
          break;
        }
      }
      if(tagname!=NULL) *tagname=tnam;
      if(tagvalue!=NULL) *tagvalue=tval;
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_GetStateName(u32 firsttag, ...)
{
  return(gadget_GetStateNameTL((tag *)&firsttag));
}
u32 gadget_GetStateNameTL(tag *taglist)
{
  char *state_name;

  int ret=GADST_NONE,i;

  debug_Begin();

  state_name=(char *)tag_GetTagData(taglist,TAG_GADGET_STATE_NAME,0L);

  if(state_name!=NULL)
  {
    for(i=0;state_names[i]!=NULL;i++)
    {
      if(strcmp(state_name,state_names[i])==0)
      {
        ret=i;
        break;
      }
    }
  }

  debug_End();

  return((u32)ret);
}



static u32 gadget_SetFont(Gadget_t *this_gadget, tag *taglist)
{
  u32 ret=~0;
  char *font_name;
  int font_size;
  int font_style;
  int font_weight;
  int font_decoration;
  u32 font_flags=0L;
  u32 new_font=0L;

  debug_Begin();

  if(this_gadget!=NULL&&taglist!=NULL)
  {
    font_name=(char *)tag_GetTagData(taglist,TAG_GAD_FONTNAME,0L);
    font_size=(int)tag_GetTagData(taglist,TAG_GAD_FONTSIZE,GADGET_DEFAULT_FONTSIZE);
    font_style=(int)tag_GetTagData(taglist,TAG_GAD_FONTSTYLE,0L);
    font_weight=(int)tag_GetTagData(taglist,TAG_GAD_FONTWEIGHT,0L);
    font_decoration=(int)tag_GetTagData(taglist,TAG_GAD_FONTDECORATION,0L);
    if(font_style==GADGET_FONTSTYLE_ITALIC) font_flags|=GLWFS_ITALIC;
    if(font_weight==GADGET_FONTWEIGHT_BOLD) font_flags|=GLWFS_BOLD;
    if(font_decoration==GADGET_FONTDECORATION_UNDERLINED) font_flags|=GLWFS_UNDERLINE;
    if(font_name!=NULL) new_font=glw_OpenFont(TAG_GLW_CONN,window_GetConnection(this_gadget->window),TAG_GLW_FACE,font_name,TAG_GLW_SIZE,font_size,TAG_GLW_STYLE,font_flags,TAG_DONE);
    if(new_font!=0L&&this_gadget->font!=0L) glw_CloseFont(TAG_GLW_FONT,this_gadget->font,TAG_DONE);
    if(new_font!=0L)
    {
      this_gadget->font=new_font;
      ret=0L;
    }
  }

  debug_End();

  return(ret);
}
static u32 gadget_SetHint(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}


gadget_Binding_t *gadget_GetCommonBind(void)
{
  return(common_bind);
}


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

  debug_Begin();

//Initialize call vector BEGIN - put this into the init function of this module
  call_vector[GADGET_GET_STATE_NAME-GADGET_FUNCBASE]=gadget_GetStateNameTL;
  call_vector[GADGET_REGISTER_CLASS-GADGET_FUNCBASE]=gadget_RegisterClassTL;
  call_vector[GADGET_FIND_CLASS-GADGET_FUNCBASE]=gadget_FindClassTL;
  call_vector[GADGET_FIND_CLASS_BY_NAME-GADGET_FUNCBASE]=gadget_FindClassByNameTL;
  call_vector[GADGET_FATHER-GADGET_FUNCBASE]=gadget_FatherTL;
  call_vector[GADGET_FIRST_CHILD-GADGET_FUNCBASE]=gadget_FirstChildTL;
  call_vector[GADGET_LAST_CHILD-GADGET_FUNCBASE]=gadget_LastChildTL;
  call_vector[GADGET_NTH_CHILD-GADGET_FUNCBASE]=gadget_NthChildTL;
  call_vector[GADGET_LEFT_BROTHER-GADGET_FUNCBASE]=gadget_LeftBrotherTL;
  call_vector[GADGET_RIGHT_BROTHER-GADGET_FUNCBASE]=gadget_RightBrotherTL;
  call_vector[GADGET_FIRST_BROTHER-GADGET_FUNCBASE]=gadget_FirstBrotherTL;
  call_vector[GADGET_LAST_BROTHER-GADGET_FUNCBASE]=gadget_LastBrotherTL;
  call_vector[GADGET_LEFT_BROTHER_CIRCULAR-GADGET_FUNCBASE]=gadget_LeftBrotherCircularTL;
  call_vector[GADGET_RIGHT_BROTHER_CIRCULAR-GADGET_FUNCBASE]=gadget_RightBrotherCircularTL;
  call_vector[GADGET_FIRST_NODE-GADGET_FUNCBASE]=gadget_FirstNodeTL;
  call_vector[GADGET_NEXT_NODE-GADGET_FUNCBASE]=gadget_NextNodeTL;
  call_vector[GADGET_ATTACH_FIRST-GADGET_FUNCBASE]=gadget_AttachFirstTL;
  call_vector[GADGET_ATTACH-GADGET_FUNCBASE]=gadget_AttachTL;
  call_vector[GADGET_DETACH-GADGET_FUNCBASE]=gadget_DetachTL;
  call_vector[GADGET_SET_STATE-GADGET_FUNCBASE]=gadget_SetStateTL;
  call_vector[GADGET_POST_MESSAGE-GADGET_FUNCBASE]=gadget_PostMessageTL;
  call_vector[GADGET_GET_FONT-GADGET_FUNCBASE]=gadget_GetFontTL;
  call_vector[GADGET_GET_COLOR-GADGET_FUNCBASE]=gadget_GetColorTL;
  call_vector[GADGET_GET_STATE-GADGET_FUNCBASE]=gadget_GetStateTL;
  call_vector[GADGET_NEW-GADGET_FUNCBASE]=gadget_NewTL;
  call_vector[GADGET_DELETE_SUBTREE-GADGET_FUNCBASE]=gadget_DeleteSubtreeTL;
  call_vector[GADGET_SEARCH-GADGET_FUNCBASE]=gadget_SearchTL;
  call_vector[GADGET_SEARCH_IN_WINDOW-GADGET_FUNCBASE]=gadget_SearchInWindowTL;
  call_vector[GADGET_RENDER_CUSTOM-GADGET_FUNCBASE]=gadget_RenderCustomTL;
  call_vector[GADGET_REFRESH-GADGET_FUNCBASE]=gadget_RefreshTL;
  call_vector[GADGET_FIND_PARENT-GADGET_FUNCBASE]=gadget_FindParentTL;
  call_vector[GADGET_HIDE_ALL-GADGET_FUNCBASE]=gadget_HideAllTL;
  call_vector[GADGET_FIND_RIGHT_MOST-GADGET_FUNCBASE]=gadget_FindRightMostTL;
  call_vector[GADGET_GET_HINT-GADGET_FUNCBASE]=gadget_GetHintTL;
  call_vector[GADGET_GET_EXTENT-GADGET_FUNCBASE]=gadget_GetExtentTL;
  call_vector[GADGET_GET_RECT-GADGET_FUNCBASE]=gadget_GetRectTL;
  call_vector[GADGET_SUGGEST_EXTENT-GADGET_FUNCBASE]=gadget_SuggestExtentTL;
  call_vector[GADGET_DELETE_GADGET-GADGET_FUNCBASE]=gadget_DeleteGadgetTL;
  call_vector[GADGET_INIT_GADGET-GADGET_FUNCBASE]=gadget_InitGadgetTL;
  call_vector[GADGET_INPUT_EVENT_HANDLER-GADGET_FUNCBASE]=gadget_InputEventHandlerTL;
  call_vector[GADGET_LAYOUT-GADGET_FUNCBASE]=gadget_LayoutTL;
  call_vector[GADGET_DAMAGE-GADGET_FUNCBASE]=gadget_DamageTL;
  call_vector[GADGET_CALLBACK-GADGET_FUNCBASE]=gadget_CallBackTL;
  call_vector[GADGET_GET_UNIQUE_ID-GADGET_FUNCBASE]=gadget_GetUniqueIdTL;
  call_vector[GADGET_SAVE-GADGET_FUNCBASE]=gadget_SaveTL;
  call_vector[GADGET_RESTORE-GADGET_FUNCBASE]=gadget_RestoreTL;
  call_vector[GADGET_METHODCALL-GADGET_FUNCBASE]=gadget_MethodCallTL;
  call_vector[GADGET_BIND-GADGET_FUNCBASE]=gadget_BindTL;
  bases_modules.gadget_Call=gadget_Call;
  bases_modules.gadget_CallTL=gadget_CallTL;
//Initialize call vector END

  if(class_list==NULL)
  {
    class_list=list_CreateList();
    ret=0;
  }

  debug_End();

  return(ret);
}


void gadget_CleanUp(void)
{
  Node_t *node;
  gadget_ClassData_t *classdata;

  debug_Begin();

  if(class_list!=NULL)
  {
    for(node=list_GetNodeHead(class_list);node!=NULL;node=list_GetNodeHead(class_list))
    {
      list_RemoveNode(class_list,node);
      if(NULL!=(classdata=(gadget_ClassData_t *)list_GetNodeData(node)))
      {
        glw_CloseModule(classdata->module);
        if(NULL!=classdata->class_name) mem_free(classdata->class_name);
        mem_free(classdata);
      }
      list_DeleteNode(node);
    }
    list_DeleteList(class_list);
  }
  class_list=NULL;

  debug_End();
}


int gadget_LoadClass(gui_App_t *app, char *class, Skin_t *skin)
{
  int ret=-1;
  char *path_gadgets,*fnam;
  int flen;
  u8 *mod;
  FILE *f;

  debug_Begin();

  if(class!=NULL)
  {
    path_gadgets=prefs_GetString(NULL,"path.gadgets","gadgets");
    if(NULL!=(fnam=mem_malloc(strlen(path_gadgets)+1+1+7+strlen(class))))
    {
      strcpy(fnam,path_gadgets);
      strcat(fnam,"/");
      strcat(fnam,class);
      strcat(fnam,".gadget");
      if(0L==glw_OpenModule(fnam))
      {
        // get the module from the client
        if(NULL!=(mod=(u8 *)net_LoadFile(TAG_NET_CONN,app->conn,TAG_NET_NAME,fnam,TAG_NET_LEN,&flen,TAG_DONE)))
        {
          if(NULL!=(f=fopen(fnam,"wb")))
          {
            fwrite(mod,1,flen,f);
            fclose(f);
          }
          mem_free(mod);
          if(0L!=glw_OpenModule(fnam)) ret=0;
        }
      }
      else ret=0;
      mem_free(fnam);
      if(ret==0&&skin!=NULL) skin_LoadSkin(skin,class);
    }
  }

  debug_End();

  return(ret);
}


u32 gadget_RegisterClass(u32 firsttag, ...)
{
  return(gadget_RegisterClassTL((tag *)&firsttag));
}
u32 gadget_RegisterClassTL(tag *taglist)
{
  u32 class_id;
  char *name;
  gadget_Binding_t *binding;
  char **color_names;
  char **custom_names;
  u32 state_mask;
  u32 module;
  int gadget_size;
  gadget_Method_t *methods;
  int (*ie_h)(Gadget_t *,struct glw_Event *);
  int (*e_h)(Gadget_t *,Gadget_t *,int,u32);
  int (*ge_h)(Gadget_t *,int,tag *);

  int ret=-1;
  Node_t *node;
  gadget_ClassData_t *classdata;

  debug_Begin();

  class_id=(u32 )tag_GetTagData(taglist,TAG_GADGET_CLASS_ID,0L);
  name=(char *)tag_GetTagData(taglist,TAG_GADGET_NAME,0L);
  binding=(gadget_Binding_t *)tag_GetTagData(taglist,TAG_GADGET_BINDING,0L);
  color_names=(char **)tag_GetTagData(taglist,TAG_GADGET_COLOR_NAMES,0L);
  custom_names=(char **)tag_GetTagData(taglist,TAG_GADGET_CUSTOM_NAMES,0L);
  state_mask=(u32 )tag_GetTagData(taglist,TAG_GADGET_STATE_MASK,0L);
  module=(u32 )tag_GetTagData(taglist,TAG_GADGET_MODULE,0L);
  gadget_size=(int )tag_GetTagData(taglist,TAG_GADGET_GADGET_SIZE,0L);
  methods=(gadget_Method_t *)tag_GetTagData(taglist,TAG_GADGET_METHODS,0L);
  ie_h=(void *)tag_GetTagData(taglist,TAG_GADGET_INPUT_EVENT_HANDLER,0L);
  e_h=(void *)tag_GetTagData(taglist,TAG_GADGET_EVENT_HANDLER,0L);
  ge_h=(void *)tag_GetTagData(taglist,TAG_GADGET_GADGET_EVENT_HANDLER,0L);

  if(class_list!=NULL&&ge_h!=NULL)
  {
    if(NULL==(gadget_ClassData_t *)gadget_FindClass(TAG_GADGET_CLASS_ID,class_id,TAG_DONE)&&NULL==(gadget_ClassData_t *)gadget_FindClassByName(TAG_GADGET_CLASS_NAME,name,TAG_DONE))
    {
      classdata=mem_calloc(1,sizeof(gadget_ClassData_t));
      if(classdata!=NULL)
      {
        if(NULL!=(node=list_CreateNode()))
        {
          classdata->class_id=class_id;
          classdata->module=module;
          classdata->class_name=common_strdup(name);
          classdata->color_names=color_names;
          classdata->color_count=0;
          classdata->custom_names=custom_names;
          classdata->custom_count=0;
          classdata->xmlbinding=binding;
          if(color_names!=NULL) while(NULL!=color_names[classdata->color_count]) classdata->color_count++;
          if(custom_names!=NULL) while(NULL!=custom_names[classdata->custom_count]) classdata->custom_count++;
          classdata->state_mask=state_mask;
          classdata->input_event_handler=ie_h;
          classdata->event_handler=e_h;
          classdata->gadget_event_handler=ge_h;
          classdata->gadget_counter=0;
          classdata->gadget_size=gadget_size;
          classdata->methods=(methods==NULL?no_methods:methods);
          for(classdata->method_count=0;classdata->methods[classdata->method_count].function!=NULL&&classdata->method_count<GADGET_METHOD_MAX_COUNT;classdata->method_count++);
          list_SetNodeData(node,classdata);
          list_InsertNodeTail(class_list,node);
          ret=0;
        }
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_FindClass(u32 firsttag, ...)
{
  return(gadget_FindClassTL((tag *)&firsttag));
}
u32 gadget_FindClassTL(tag *taglist)
{
  u32 class_id;

  Node_t *node;
  gadget_ClassData_t *ret=NULL;


  debug_Begin();

  class_id=(u32 )tag_GetTagData(taglist,TAG_GADGET_CLASS_ID,0L);

  if(class_list!=NULL)
  {
    for(node=list_GetNodeHead(class_list);node!=NULL;node=list_GetNodeNext(class_list,node))
    {
      ret=(gadget_ClassData_t *)list_GetNodeData(node);
      if(ret!=NULL&&ret->class_id==class_id) break;
      ret=NULL;
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_FindClassByName(u32 firsttag, ...)
{
  return(gadget_FindClassByNameTL((tag *)&firsttag));
}
u32 gadget_FindClassByNameTL(tag *taglist)
{
  char *class_name;

  Node_t *node;
  gadget_ClassData_t *ret=NULL;

  debug_Begin();

  class_name=(char *)tag_GetTagData(taglist,TAG_GADGET_CLASS_NAME,0L);

  if(class_list!=NULL)
  {
    for(node=list_GetNodeHead(class_list);node!=NULL;node=list_GetNodeNext(class_list,node))
    {
      ret=(gadget_ClassData_t *)list_GetNodeData(node);
      if(strcmp(ret->class_name,class_name)==0) break;
      ret=NULL;
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_MethodCall(u32 firsttag, ...)
{
  return(gadget_MethodCallTL((tag *)&firsttag));
}
u32 gadget_MethodCallTL(tag *taglist)
{
  Window_t *window;
  u32 gadget_id;
  u32 method;
  Gadget_t *this;

  u32 ret=0L;

  debug_Begin();

  window=(Window_t *)tag_GetTagDataChg(taglist,TAG_GADGET_WINDOW,0L);
  gadget_id=(u32)tag_GetTagDataChg(taglist,TAG_GADGET_GADGET_ID,0L);
  method=(u32)tag_GetTagDataChg(taglist,TAG_GADGET_METHOD,0L);
  this=(Gadget_t *)tag_GetTagDataChg(taglist,TAG_GADGET_OBJECT,0L);

  if(this==NULL) this=(Gadget_t *)gadget_SearchInWindow(TAG_GADGET_WINDOW,window,TAG_GADGET_GADGET_ID,gadget_id,TAG_DONE);
  if(this!=NULL)
  {
    if(method<GADGET_METHOD_BASE&&method<GADGET_METHOD_COUNT)
    {
//printf("  call: %ld gadget_%s\n",this->gadget_id,gadget_methods[method].name);
      ret=gadget_methods[method].function(this,taglist);
    }
    else
    {
      method-=GADGET_METHOD_BASE;
      if(this->class_data->method_count>method)
      {
//printf("  call: %ld %s_%s\n",this->gadget_id,this->class_data->class_name,this->class_data->methods[method].name);
        ret=this->class_data->methods[method].function(this,taglist);
      }
    }
  }

  debug_End();

  return(ret);
}


u32 gadget_Father(u32 firsttag, ...)
{
  return(gadget_FatherTL((tag *)&firsttag));
}
u32 gadget_FatherTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  debug_End();

  return((u32)gad->parent);
}

u32 gadget_FirstChild(u32 firsttag, ...)
{
  return(gadget_FirstChildTL((tag *)&firsttag));
}
u32 gadget_FirstChildTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  debug_End();
  return((u32)gad->firstchild);
}

u32 gadget_LastChild(u32 firsttag, ...)
{
  return(gadget_LastChildTL((tag *)&firsttag));
}
u32 gadget_LastChildTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  debug_End();
  return((u32)gad->lastchild);
}

u32 gadget_NthChild(u32 firsttag, ...)
{
  return(gadget_NthChildTL((tag *)&firsttag));
}
u32 gadget_NthChildTL(tag *taglist)
{
  Gadget_t *gad;
  int index;

  Gadget_t *ret;
  int i;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  index=(int )tag_GetTagData(taglist,TAG_GADGET_INDEX,0L);

  for(i=0,ret=gad->firstchild;i<=index&&gad!=NULL;gad=gad->next);

  debug_End();

  return((u32)ret);
}

u32 gadget_LeftBrother(u32 firsttag, ...)
{
  return(gadget_LeftBrotherTL((tag *)&firsttag));
}
u32 gadget_LeftBrotherTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  debug_End();
  return((u32)gad->prev);
}

u32 gadget_RightBrother(u32 firsttag, ...)
{
  return(gadget_RightBrotherTL((tag *)&firsttag));
}
u32 gadget_RightBrotherTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  debug_End();
  return((u32)gad->next);
}

u32 gadget_FirstBrother(u32 firsttag, ...)
{
  return(gadget_FirstBrotherTL((tag *)&firsttag));
}
u32 gadget_FirstBrotherTL(tag *taglist)
{
  Gadget_t *gad;

  Gadget_t *ret=NULL;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  for(;gad!=NULL;gad=gad->prev) ret=gad;

  debug_End();

  return((u32)ret);
}

u32 gadget_LastBrother(u32 firsttag, ...)
{
  return(gadget_LastBrotherTL((tag *)&firsttag));
}
u32 gadget_LastBrotherTL(tag *taglist)
{
  Gadget_t *gad;

  Gadget_t *ret=NULL;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  for(;gad!=NULL;gad=gad->next) ret=gad;

  debug_End();

  return((u32)ret);
}

u32 gadget_LeftBrotherCircular(u32 firsttag, ...)
{
  return(gadget_LeftBrotherCircularTL((tag *)&firsttag));
}
u32 gadget_LeftBrotherCircularTL(tag *taglist)
{
  Gadget_t *gad;

  Gadget_t *ret=NULL;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(gad!=NULL&&NULL==(ret=gad->prev)) ret=(Gadget_t *)gadget_LastBrother(TAG_GADGET_OBJECT,gad,TAG_DONE);

  debug_End();

  return((u32)ret);
}

u32 gadget_RightBrotherCircular(u32 firsttag, ...)
{
  return(gadget_RightBrotherCircularTL((tag *)&firsttag));
}
u32 gadget_RightBrotherCircularTL(tag *taglist)
{
  Gadget_t *gad;

  Gadget_t *ret=NULL;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(gad!=NULL&&NULL==(ret=gad->next)) ret=(Gadget_t *)gadget_FirstBrother(TAG_GADGET_OBJECT,gad,TAG_DONE);

  debug_End();

  return((u32)ret);
}

// szelessegi bejaro rutinok

u32 gadget_FirstNode(u32 firsttag, ...)
{
  return(gadget_FirstNodeTL((tag *)&firsttag));
}
u32 gadget_FirstNodeTL(tag *taglist)
{
  Gadget_t *root;


  debug_Begin();

  root=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_ROOT,0L);

  debug_End();
  return((u32)root);
}

u32 gadget_NextNode(u32 firsttag, ...)
{
  return(gadget_NextNodeTL((tag *)&firsttag));
}
u32 gadget_NextNodeTL(tag *taglist)
{
  Gadget_t *gad;
  Gadget_t *root;

  Gadget_t *ret=NULL;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  root=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_ROOT,0L);

  if(gad!=NULL)
  {
    if(NULL==(ret=gad->firstchild))
    {
      if(NULL==(ret=gad->next))
      {
        for(gad=gad->parent;gad!=root&&gad->next==NULL;gad=gad->parent);
        if(gad!=root) ret=gad->next;
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_AttachFirst(u32 firsttag, ...)
{
  return(gadget_AttachFirstTL((tag *)&firsttag));
}
u32 gadget_AttachFirstTL(tag *taglist)
{
  Gadget_t *new_parent;
  Gadget_t *new_child;


  debug_Begin();

  new_parent=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_NEW_PARENT,0L);
  new_child=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_NEW_CHILD,0L);

  new_child->parent=new_parent;
  new_child->prev=NULL;
  new_child->next=new_parent->firstchild;
  if(new_parent->firstchild!=NULL) new_parent->firstchild->prev=new_child;
  else new_parent->lastchild=new_child;
  new_parent->firstchild=new_child;

  debug_End();
  return(0L);
}

u32 gadget_Attach(u32 firsttag, ...)
{
  return(gadget_AttachTL((tag *)&firsttag));
}
u32 gadget_AttachTL(tag *taglist)
{
  Gadget_t *new_parent;
  Gadget_t *new_child;


  debug_Begin();

  new_parent=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_NEW_PARENT,0L);
  new_child=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_NEW_CHILD,0L);
//78
  new_child->parent=new_parent;
  new_child->next=NULL;
  new_child->prev=new_parent->lastchild;
  if(new_parent->lastchild!=NULL) new_parent->lastchild->next=new_child;
  else new_parent->firstchild=new_child;
  new_parent->lastchild=new_child;

  debug_End();
  return(0L);
}

u32 gadget_Detach(u32 firsttag, ...)
{
  return(gadget_DetachTL((tag *)&firsttag));
}
u32 gadget_DetachTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(gad->parent!=NULL)
  {
    if(gad->prev!=NULL) gad->prev->next=gad->next;
    if(gad->next!=NULL) gad->next->prev=gad->prev;
    if(gad->parent->firstchild==gad) gad->parent->firstchild=gad->prev;
    if(gad->parent->lastchild==gad) gad->parent->lastchild=gad->next;
    gad->parent=NULL;
  }

  debug_End();
  return(0L);
}


u32 gadget_SetState(u32 firsttag, ...)
{
  return(gadget_SetStateTL((tag *)&firsttag));
}
u32 gadget_SetStateTL(tag *taglist)
{
  Gadget_t *gad;
  int state;
  int visual;

  int ret=-1;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  state=(int )tag_GetTagData(taglist,TAG_GADGET_STATE,0L);
  visual=(int )tag_GetTagData(taglist,TAG_GADGET_VISUAL,0L);

  if(gad!=NULL&&(gad->class_data->state_mask&(1<<state))!=0)
  {
    ret=gad->state;
    gad->state=state;
    if(ret!=state&&visual!=0) gadget_Refresh(TAG_GADGET_OBJECT,gad,TAG_DONE);
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_PostMessage(u32 firsttag, ...)
{
  return(gadget_PostMessageTL((tag *)&firsttag));
}
u32 gadget_PostMessageTL(tag *taglist)
{
  Gadget_t *gad;
  struct glw_Event *event;
  Window_t *window;

  int ret=-1;
  Gadget_t *node,*this;

  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  event=(struct glw_Event *)tag_GetTagData(taglist,TAG_GADGET_EVENT,0L);
  window=(Window_t *)tag_GetTagData(taglist,TAG_GADGET_WINDOW,0L);

  if(gad!=NULL&&window!=NULL)
  {
    if(NULL==window->active_gadget&&((event->event&GLWEV_KEYUP)!=0||(event->event&GLWEV_KEYDOWN)!=0)&&window->focused_gadget!=NULL) this=window->focused_gadget;
    else if(NULL==(this=window->active_gadget)) this=gad;
    if(0>(ret=gadget_InputEventHandler(TAG_GADGET_OBJECT,this,TAG_GADGET_EVENT,event,TAG_DONE)))
    {
      for(node=(Gadget_t *)gadget_FirstNode(TAG_GADGET_ROOT,this,TAG_DONE);node!=NULL&&ret<0;node=(Gadget_t *)gadget_NextNode(TAG_GADGET_OBJECT,node,TAG_GADGET_ROOT,this,TAG_DONE))
      {
        if((node->class_data->flags&GAD_INVISIBLE)!=0||(node->flags&GAD_HIDDEN)!=0) continue;
        if(gui_IsInside(TAG_GUI_RECT,&node->rect,TAG_GUI_X,event->mousex,TAG_GUI_Y,event->mousey,TAG_DONE))
        {
          ret=gadget_InputEventHandler(TAG_GADGET_OBJECT,node,TAG_GADGET_EVENT,event,TAG_DONE);
        }
      }
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_GetFont(u32 firsttag, ...)
{
  return(gadget_GetFontTL((tag *)&firsttag));
}
u32 gadget_GetFontTL(tag *taglist)
{
  Gadget_t *this;

  u32 ret=0L;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(NULL!=this)
  {
    ret=this->font;
    if(ret==0L) ret=skin_GetFont(window_GetSkin(this->window),this);
    for(;ret==0L&&this!=NULL;this=(Gadget_t *)gadget_Father(TAG_GADGET_OBJECT,this,TAG_DONE)) ret=this->font;
  }

  debug_End();

  return((u32)ret);
}



u32 gadget_GetColor(u32 firsttag, ...)
{
  return(gadget_GetColorTL((tag *)&firsttag));
}
u32 gadget_GetColorTL(tag *taglist)
{
  Gadget_t *this;
  int color;

  u32 ret=~0L;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  color=(int )tag_GetTagData(taglist,TAG_GADGET_COLOR,0L);

  if(this!=NULL&&this->class_data->color_count>color&&this->color_table[this->state]!=NULL)
  {
    ret=this->color_table[this->state][color];
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_GetState(u32 firsttag, ...)
{
  return(gadget_GetStateTL((tag *)&firsttag));
}
u32 gadget_GetStateTL(tag *taglist)
{
  Gadget_t *this;

  int ret=-1;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(this!=NULL) ret=this->state;

  debug_End();

  return((u32)ret);
}


static int gadget_InitColorTable(Gadget_t *gad)
{
  int ret=-1,i;

  debug_Begin();

  if(gad!=NULL)
  {
    ret=0;
    for(i=0;i<GADST_COUNT;i++)
    {
      if(((gad->class_data->state_mask)&(1<<i))!=0)
      {
        if(gad->class_data->color_count>0)
        {
          if(gad->color_table[i]!=NULL) mem_free(gad->color_table[i]);
          if(NULL==(gad->color_table[i]=mem_calloc(sizeof(u32),gad->class_data->color_count)))
          {
            ret=-1;
            break;
          }
          skin_FillColorTable(window_GetSkin(gad->window),gad,i);
        }
        else gad->color_table[i]=NULL;
      }
      else gad->color_table[i]=NULL;
    }
  }

  debug_End();

  return(ret);
}


u32 gadget_New(u32 firsttag, ...)
{
  return(gadget_NewTL((tag *)&firsttag));
}
u32 gadget_NewTL(tag *taglist)
{
  gadget_Descriptor_t *descriptor;
  Window_t *window;
  Gadget_t *parent;
  tag *closing_tag=NULL,*custom_taglist;

  Gadget_t *ret=NULL;
  gadget_ClassData_t *gadget_class;
  char *skinname;
  Skin_t *skin;

  debug_Begin();

  descriptor=(gadget_Descriptor_t *)tag_GetTagData(taglist,TAG_GADGET_DESCRIPTOR,0L);
  window=(Window_t *)tag_GetTagData(taglist,TAG_GADGET_WINDOW,0L);
  parent=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_PARENT,0L);

  if(descriptor!=NULL&&window!=NULL)
  {
    if(NULL!=(gadget_class=(gadget_ClassData_t *)gadget_FindClassByName(TAG_GADGET_CLASS_NAME,descriptor->class_name,TAG_DONE)))
    {
      if(NULL!=(ret=mem_calloc(1,gadget_class->gadget_size)))
      {
        gadget_class->gadget_counter++;
        ret->gadget_id=(descriptor->gadget_id==GADGET_ILLEGAL_ID?gadget_GetUniqueId():descriptor->gadget_id);
        ret->class_data=gadget_class;
        ret->weight=descriptor->weight;
        ret->window=window;
        ret->layout=(int)tag_GetTagData(descriptor->taglist,TAG_GAD_LAYOUT,GADGET_LAYOUT_FREE);
        ret->layout_width=(int)tag_GetTagData(descriptor->taglist,TAG_GAD_WIDTH,(u32)-1);
        ret->layout_height=(int)tag_GetTagData(descriptor->taglist,TAG_GAD_HEIGHT,(u32)-1);
        ret->hint=(char *)tag_GetTagData(descriptor->taglist,TAG_GAD_HINT,0L);
        ret->skincrc=0L;
        if(NULL!=(skinname=(char *)tag_GetTagData(descriptor->taglist,TAG_GAD_SKIN,0L)))
        {
          ret->skincrc=crc_CalcBuffer(skinname,strlen(skinname));
          if(ret->skincrc==0L) ret->skincrc=1L;
        }
        ret->font=0L;
        ret->callback_discard_mask=0L;
        if(parent!=NULL)
        {
          gadget_Attach(TAG_GADGET_NEW_PARENT,parent,TAG_GADGET_NEW_CHILD,ret,TAG_DONE);
        }
        gadget_InitColorTable(ret);
        gadget_SetFont(ret,descriptor->taglist);
        skin_FillGadgetInfo(skin=window_GetSkin(window),ret);
        if(NULL!=(custom_taglist=skin_GetCustomTaglist(skin,ret)))
        {
          closing_tag=tag_FindTag(descriptor->taglist,TAG_DONE);
          closing_tag->Name=TAG_MORE;
          closing_tag->Data=(u32)custom_taglist;
        }
        gadget_InitGadget(TAG_GADGET_OBJECT,ret,TAG_GADGET_TAGLIST,descriptor->taglist,TAG_DONE);
        if(NULL!=closing_tag)
        {
          closing_tag->Name=TAG_DONE;
          closing_tag->Data=0L;
        }
      }
    }
  }

  debug_End();

  return((u32)ret);
}



static Gadget_t *gadget_DeleteOne(Gadget_t *gad)
{
  Gadget_t *ret=NULL;
  int i;

  debug_Begin();

  gad->flags&=~GAD_ONSCREEN;
  gadget_DeleteGadget(TAG_GADGET_OBJECT,gad,TAG_DONE);
  gad->class_data->gadget_counter--;
  if(gad->class_data->gadget_counter<=0)
  {
    Node_t *node;
    for(node=list_GetNodeHead(class_list);node!=NULL;node=list_GetNodeNext(class_list,node))
    {
      if(gad->class_data==(gadget_ClassData_t *)list_GetNodeData(node))
      {
        skin_UnloadSkin(window_GetSkin(gad->window),gad->class_data->class_id);
        list_RemoveNode(class_list,node);
        glw_CloseModule(gad->class_data->module);
        if(NULL!=gad->class_data->class_name) mem_free(gad->class_data->class_name);
        mem_free(gad->class_data);
        list_DeleteNode(node);
        break;
      }
    }
  }
  if(gad->next!=NULL) gad->next->prev=gad->prev;
  if(gad->prev!=NULL) gad->prev->next=gad->next;
  if(gad->font!=0L) glw_CloseFont(TAG_GLW_FONT,gad->font,TAG_DONE);
  for(i=0;i<GADST_COUNT;i++) if(gad->color_table[i]!=NULL) mem_free(gad->color_table[i]);
  ret=gad->firstchild;
  mem_free(gad);

  debug_End();

  return(ret);
}


u32 gadget_DeleteSubtree(u32 firsttag, ...)
{
  return(gadget_DeleteSubtreeTL((tag *)&firsttag));
}
u32 gadget_DeleteSubtreeTL(tag *taglist)
{
  Gadget_t *this;

  Gadget_t *next;
  tag intaglist1[]=
  {
    {TAG_GADGET_OBJECT, 0L},
    {TAG_DONE,0L}
  };
  tag intaglist2[]=
  {
    {TAG_GADGET_OBJECT, 0L},
    {TAG_DONE,0L}
  };


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(this!=NULL)
  {
    while(this!=NULL)
    {
      intaglist2[0].Data=(u32)this;
      next=(Gadget_t *)gadget_RightBrotherTL(intaglist2);
      intaglist1[0].Data=(u32)this->firstchild;
      gadget_DeleteSubtreeTL(intaglist1);
      gadget_DetachTL(intaglist2);
      gadget_DeleteOne(this);
      this=next;
    }
  }

  debug_End();

  return(0L);
}


u32 gadget_Search(u32 firsttag, ...)
{
  return(gadget_SearchTL((tag *)&firsttag));
}
u32 gadget_SearchTL(tag *taglist)
{
  Gadget_t *root;
  u32 gadget_id;

  Gadget_t *gad=NULL;


  debug_Begin();

  root=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_ROOT,0L);
  gadget_id=(u32 )tag_GetTagData(taglist,TAG_GADGET_GADGET_ID,0L);

  if (root != NULL)
  {
    for(gad=(Gadget_t *)gadget_FirstNode(TAG_GADGET_ROOT,root,TAG_DONE);gad!=NULL;gad=(Gadget_t *)gadget_NextNode(TAG_GADGET_OBJECT,gad,TAG_GADGET_ROOT,root,TAG_DONE))
    {
      if(gad->gadget_id==gadget_id) break;
    }
  }

  debug_End();

  return((u32)gad);
}


u32 gadget_SearchInWindow(u32 firsttag, ...)
{
  return(gadget_SearchInWindowTL((tag *)&firsttag));
}
u32 gadget_SearchInWindowTL(tag *taglist)
{
  Window_t *window;
  u32 gadget_id;

  u32 ret;

  debug_Begin();

  window=(Window_t *)tag_GetTagData(taglist,TAG_GADGET_WINDOW,0L);
  gadget_id=(u32 )tag_GetTagData(taglist,TAG_GADGET_GADGET_ID,0L);

  ret=gadget_Search(TAG_GADGET_ROOT,window_GetRootGadget(window),TAG_GADGET_GADGET_ID,gadget_id,TAG_DONE);

  debug_End();

  return((u32)ret);
}


u32 gadget_RenderCustom(u32 firsttag, ...)
{
  return(gadget_RenderCustomTL((tag *)&firsttag));
}
u32 gadget_RenderCustomTL(tag *taglist)
{
  Gadget_t *this;
  Rect_t *rect;
  int custom;
  int flags;

  int ret=-1;
  Rect_t inner;
  tag intaglist[]=
  {
    {TAG_GAD_RECT, 0L},
    {TAG_DONE,0L}
  };


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GADGET_RECT,0L);
  custom=(int )tag_GetTagData(taglist,TAG_GADGET_CUSTOM,0L);
  flags=(int )tag_GetTagData(taglist,TAG_GADGET_FLAGS,0L);

  if(this!=NULL)
  {
    if((flags&GADGET_CUS_BACKGROUND)!=0) skin_RenderBackground(window_GetSkin(this->window),this,&this->rect,this->state);
    if((flags&GADGET_CUS_LAYOUT)!=0)
    {
      skin_GetInnerRect(window_GetSkin(this->window),this,rect,&inner);
      intaglist[0].Data=(u32)&inner;
      this->class_data->gadget_event_handler(this,GADEV_LAYOUT,intaglist);
    }
    skin_RenderCustom(window_GetSkin(this->window),this,rect,custom);
    if((flags&GADGET_CUS_REFRESH)!=0) glw_RefreshWindowPartial(TAG_GLW_WINDOW,this->window->handle,TAG_GLW_RECT,&this->rect,TAG_DONE);
    ret=0;
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_Refresh(u32 firsttag, ...)
{
  return(gadget_RefreshTL((tag *)&firsttag));
}
u32 gadget_RefreshTL(tag *taglist)
{
  Gadget_t *gad;


  debug_Begin();

  gad=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(gad!=NULL)
  {
    if((gad->flags&GAD_ONSCREEN)!=0) gadget_Layout(TAG_GADGET_OBJECT,gad,TAG_GADGET_RECT,&gad->rect,TAG_DONE);
    glw_RefreshWindowPartial(TAG_GLW_WINDOW,gad->window->handle,TAG_GLW_RECT,&gad->rect,TAG_DONE);
  }

  debug_End();
  return(0L);
}


u32 gadget_FindParent(u32 firsttag, ...)
{
  return(gadget_FindParentTL((tag *)&firsttag));
}
u32 gadget_FindParentTL(tag *taglist)
{
  Gadget_t *this;
  int class_id;

  Gadget_t *gad=NULL;

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  class_id=(int )tag_GetTagData(taglist,TAG_GADGET_CLASS_ID,0L);

  if(this!=NULL)
  {
    gad=(Gadget_t *)gadget_Father(TAG_GADGET_OBJECT,this,TAG_DONE);
  }

  debug_End();

  return((u32)gad);
}


u32 gadget_HideAll(u32 firsttag, ...)
{
  return(gadget_HideAllTL((tag *)&firsttag));
}
u32 gadget_HideAllTL(tag *taglist)
{
  Gadget_t *this;
  int hidden;

  Gadget_t *gad;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  hidden=(int )tag_GetTagData(taglist,TAG_GADGET_HIDDEN,0L);

  if (this != NULL)
  {
    for(gad=(Gadget_t *)gadget_FirstNode(TAG_GADGET_ROOT,this,TAG_DONE);gad!=NULL;gad=(Gadget_t *)gadget_NextNode(TAG_GADGET_OBJECT,gad,TAG_GADGET_ROOT,this,TAG_DONE))
    {
      if(hidden)
      {
        gad->flags|=GAD_HIDDEN;
      }
      else
      {
        gad->flags&=~GAD_HIDDEN;
      }
    }
  }

  debug_End();

  return(0L);
}


u32 gadget_FindRightMost(u32 firsttag, ...)
{
  return(gadget_FindRightMostTL((tag *)&firsttag));
}
u32 gadget_FindRightMostTL(tag *taglist)
{
  Gadget_t *this;

  Gadget_t *ret=NULL;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(ret!=NULL)
  {
    while(((Gadget_t *)gadget_LastChild(TAG_GADGET_OBJECT,ret,TAG_DONE))!=NULL)
    {
      ret=(Gadget_t *)gadget_LastChild(TAG_GADGET_OBJECT,ret,TAG_DONE);
    }
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_GetHint(u32 firsttag, ...)
{
  return(gadget_GetHintTL((tag *)&firsttag));
}
u32 gadget_GetHintTL(tag *taglist)
{
  Gadget_t *this;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if (this != NULL)
  {
    return((u32)this->hint);
  }
  else
  {
    return(0L);
  }

  debug_End();
}


u32 gadget_GetExtent(u32 firsttag, ...)
{
  return(gadget_GetExtentTL((tag *)&firsttag));
}
u32 gadget_GetExtentTL(tag *taglist)
{
  Gadget_t *this;
  Extent_t *min;
  Extent_t *max;

  Extent_t gadmin,gadmax;
  tag intaglist[]=
  {
    {TAG_GAD_EXTMIN, 0L},
    {TAG_GAD_EXTMAX, 0L},
    {TAG_DONE,0L}
  };


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  min=(Extent_t *)tag_GetTagData(taglist,TAG_GADGET_MIN,0L);
  max=(Extent_t *)tag_GetTagData(taglist,TAG_GADGET_MAX,0L);

  if(this!=NULL)
  {
    intaglist[0].Data=(u32)&gadmin;
    intaglist[1].Data=(u32)&gadmax;
    this->class_data->gadget_event_handler(this,GADEV_GET_EXTENT,intaglist);
    debug_Message("  from gad:  min:%dx%d  max:%dx%d",gadmin.width,gadmin.height,gadmax.width,gadmax.height);
    skin_GetExtent(window_GetSkin(this->window),this,&gadmin,min);
    debug_Message("  from skin: min:%dx%d",min->width,min->height);
    skin_GetExtent(window_GetSkin(this->window),this,&gadmax,max);
    debug_Message("  from skin: max:%dx%d",max->width,max->height);
    if(this->layout_width>=0&&this->layout_width>=min->width&&this->layout_width<=max->width) min->width=max->width=this->layout_width;
    if(this->layout_height>=0&&this->layout_height>=min->height&&this->layout_height<=max->height) min->height=max->height=this->layout_height;
    if(this->layout==GADGET_LAYOUT_FIXED)
    {
      max->width=min->width;
      max->height=min->height;
    }
    debug_Message("  final:     min:%dx%d  max:%dx%d",min->width,min->height,max->width,max->height);
  }

  debug_End();

  return(0L);
}


u32 gadget_GetRect(u32 firsttag, ...)
{
  return(gadget_GetRectTL((tag *)&firsttag));
}
u32 gadget_GetRectTL(tag *taglist)
{
  Gadget_t *this;
  Rect_t *rect;

  int ret=-1;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GADGET_RECT,0L);

  if(this!=NULL)
  {
    skin_GetInnerRect(window_GetSkin(this->window),this,&this->rect,rect);
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_Save(u32 firsttag, ...)
{
  return(gadget_SaveTL((tag *)&firsttag));
}
u32 gadget_SaveTL(tag *taglist)
{
  Gadget_t *this;
  u8 **mem;
  int *size;

  int ret=-1;

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  mem=(u8 **)tag_GetTagData(taglist,TAG_GADGET_MEM,0L);
  size=(int *)tag_GetTagData(taglist,TAG_GADGET_SIZE,0L);

//  printf("save event posting...\n");
  if(this!=NULL&&mem!=NULL&&size!=NULL)
  {
    ret=this->class_data->gadget_event_handler(this,GADEV_SAVE,taglist);
//    printf("save event posted\n");
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_Restore(u32 firsttag, ...)
{
  return(gadget_RestoreTL((tag *)&firsttag));
}
u32 gadget_RestoreTL(tag *taglist)
{
  Gadget_t *this;
  u8 *mem;
  int size;

  int ret=-1;

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  mem=(u8 *)tag_GetTagData(taglist,TAG_GADGET_MEM,0L);
  size=(int)tag_GetTagData(taglist,TAG_GADGET_SIZE,0L);

  if(this!=NULL&&mem!=NULL&&size!=0)
  {
    ret=this->class_data->gadget_event_handler(this,GADEV_RESTORE,taglist);
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_SuggestExtent(u32 firsttag, ...)
{
  return(gadget_SuggestExtentTL((tag *)&firsttag));
}
u32 gadget_SuggestExtentTL(tag *taglist)
{
  Gadget_t *this;
  Rect_t *rect;

  Rect_t inner,store;
  Extent_t ext,inn,min,max;
  tag taglist2[]=
  {
    {TAG_GAD_EXTMIN, 0L},
    {TAG_GAD_EXTMAX, 0L},
    {TAG_DONE,0L}
  };
  tag taglist1[]=
  {
    {TAG_GAD_RECT, 0L},
    {TAG_DONE,0L}
  };

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GADGET_RECT,0L);

  if(this!=NULL)
  {
    debug_Message("BEG %lx [class=%s] (width=%d height=%d)",this->gadget_id,this->class_data->class_name,rect->width,rect->height);
    skin_GetInnerRect(window_GetSkin(this->window),this,rect,&inner);
    memcpy(&store,&inner,sizeof(Rect_t));
    taglist1[0].Data=(u32)&inner;
    this->class_data->gadget_event_handler(this,GADEV_SUGGEST_EXTENT,taglist1);
    if(this->layout==GADGET_LAYOUT_SQUARE&&inner.width!=inner.height)
    {
      taglist2[0].Data=(u32)&min;
      taglist2[1].Data=(u32)&max;
      this->class_data->gadget_event_handler(this,GADEV_GET_EXTENT,taglist2);
      inner.width=min(inner.width,inner.height);
      inner.height=min(inner.width,inner.height);
      if(inner.width<min.width) inner.width=min.width;
      if(inner.height<min.height) inner.height=min.height;
    }
    ext.width=inner.width;
    ext.height=inner.height;
    skin_GetExtent(window_GetSkin(this->window),this,&ext,&inn);
    if(store.width!=inner.width||store.height!=inner.height||this->layout==GADGET_LAYOUT_SQUARE)
    {
      rect->width=inn.width;
      rect->height=inn.height;
    }
    debug_Message("END %lx (w=%d, h=%d)",this->gadget_id,rect->width,rect->height);
  }

  debug_End();
  return(0L);
}


u32 gadget_DeleteGadget(u32 firsttag, ...)
{
  return(gadget_DeleteGadgetTL((tag *)&firsttag));
}
u32 gadget_DeleteGadgetTL(tag *taglist)
{
  Gadget_t *this;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);

  if(this!=NULL)
  {
    this->class_data->gadget_event_handler(this,GADEV_DELETE_GADGET,NULL);
  }

  debug_End();

  return(0L);
}


u32 gadget_InitGadget(u32 firsttag, ...)
{
  return(gadget_InitGadgetTL((tag *)&firsttag));
}
u32 gadget_InitGadgetTL(tag *taglist)
{
  Gadget_t *this;
  tag *intaglist;

  int ret=0;


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  intaglist=(tag *)tag_GetTagData(taglist,TAG_GADGET_TAGLIST,0L);

  if(this!=NULL)
  {
    ret=this->class_data->gadget_event_handler(this,GADEV_INIT_GADGET,intaglist);
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_InputEventHandler(u32 firsttag, ...)
{
  return(gadget_InputEventHandlerTL((tag *)&firsttag));
}
u32 gadget_InputEventHandlerTL(tag *taglist)
{
  Gadget_t *this;
  struct glw_Event *event;

  int ret=-1;

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  event=(struct glw_Event *)tag_GetTagData(taglist,TAG_GADGET_EVENT,0L);

  if(this!=NULL&&this->class_data->input_event_handler!=NULL)
  {
    ret=this->class_data->input_event_handler(this,event);
  }

  debug_End();

  return((u32)ret);
}


u32 gadget_Layout(u32 firsttag, ...)
{
  return(gadget_LayoutTL((tag *)&firsttag));
}
u32 gadget_LayoutTL(tag *taglist)
{
  Gadget_t *this;
  Rect_t *rect;

  Rect_t inner;
  tag intaglist[]=
  {
    {TAG_GAD_RECT, 0L},
    {TAG_DONE,0L}
  };


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GADGET_RECT,0L);

  if(this!=NULL&&rect!=NULL)
  {
    debug_Message("gadget_id: 0x%08lx",this->gadget_id);
    memmove(&this->rect,rect,sizeof(Rect_t));
    skin_RenderBehind(window_GetSkin(this->window),this,rect,this->state);
    skin_GetInnerRect(window_GetSkin(this->window),this,rect,&inner);
    intaglist[0].Data=(u32)&inner;
    this->class_data->gadget_event_handler(this,GADEV_LAYOUT,intaglist);
    skin_RenderOver(window_GetSkin(this->window),this,rect,this->state);
    this->flags|=GAD_ONSCREEN;
  }

  debug_End();

  return(0L);
}


u32 gadget_Damage(u32 firsttag, ...)
{
  return(gadget_DamageTL((tag *)&firsttag));
}
u32 gadget_DamageTL(tag *taglist)
{
  Gadget_t *this;
  Rect_t *rect;

  tag intaglist[]=
  {
    {TAG_GAD_RECT, 0L},
    {TAG_DONE,0L}
  };


  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  rect=(Rect_t *)tag_GetTagData(taglist,TAG_GADGET_RECT,0L);

  intaglist[0].Data=(u32)rect;
  this->class_data->gadget_event_handler(this,GADEV_DAMAGE,intaglist);

  debug_End();
  return(0L);
}


u32 gadget_CallBack(u32 firsttag, ...)
{
  return(gadget_CallBackTL((tag *)&firsttag));
}
u32 gadget_CallBackTL(tag *taglist)
{
  Gadget_t *this;
  int event;
  u32 event_data;

  Gadget_t *receiver=NULL, *last;
  Window_t *win;
  int ret=0;

  debug_Begin();

  this=(Gadget_t *)tag_GetTagData(taglist,TAG_GADGET_OBJECT,0L);
  event=(int )tag_GetTagData(taglist,TAG_GADGET_EVENT,0L);
  event_data=(u32 )tag_GetTagData(taglist,TAG_GADGET_EVENT_DATA,0L);

  if((this->callback_discard_mask&event)==0)
  {
    last=this;
    if(this!=NULL&&this->gadget_id<GADGET_NOID)
    {
      for(receiver=(Gadget_t *)gadget_Father(TAG_GADGET_OBJECT,this,TAG_DONE); receiver!=NULL && receiver->class_data->event_handler==NULL; receiver=(Gadget_t *)gadget_Father(TAG_GADGET_OBJECT,receiver,TAG_DONE)) last=receiver;
        if(receiver!=NULL)
      {
        ret=receiver->class_data->event_handler(receiver, this, event, event_data);
      }
      else
      {
        win=last->window;
        if(win!=NULL) ret=window_WindowEvent(win,this->gadget_id,event,event_data);
      }
    }
  }

  debug_End();

  return((u32)ret);
}


/*
 *  Returns a unique ID which should be used by subgadgets.
 */
u32 gadget_GetUniqueIdTL(tag *taglist)
{
  return(gadget_GetUniqueId());
}
u32 gadget_GetUniqueId(void)
{
  static int unique_id = 0x9000;

  debug_Begin();

  if (unique_id == 0x10000)
  {
    unique_id = 0x9000;
  }

  debug_End();

  return(unique_id++);
}


//END//


void gadget_SetDiscardMask(Gadget_t *this, u32 add_event, u32 remove_event)
{
  debug_Begin();

  if(this!=NULL)
  {
    this->callback_discard_mask|=add_event;
    this->callback_discard_mask&=~remove_event;
  }

  debug_End();
}


int gadget_ChangeSkin(Gadget_t *this, Skin_t *skin)
{
  int ret=-1;
  Node_t *node;
  gadget_ClassData_t *classdata=NULL;
  Gadget_t *gad;

  debug_Begin();

  if(this!=NULL&&skin!=NULL&&class_list!=NULL)
  {
    for(node=list_GetNodeHead(class_list);node!=NULL;node=list_GetNodeNext(class_list,node))
    {
      classdata=(gadget_ClassData_t *)list_GetNodeData(node);
      skin_LoadSkin(skin,classdata->class_name);
    }
    for(gad=(Gadget_t *)gadget_FirstNode(TAG_GADGET_ROOT,this,TAG_DONE);gad!=NULL;gad=(Gadget_t *)gadget_NextNode(TAG_GADGET_OBJECT,gad,TAG_GADGET_ROOT,this,TAG_DONE))
    {
      if(gad->class_data->class_name[0]=='G'&&strcmp(gad->class_data->class_name,"Group")==0) gadget_MethodCall(TAG_GADGET_OBJECT,gad,TAG_GADGET_METHOD,MET_GROUP_INVALIDATE_SIZE,TAG_DONE);
      if((gad->class_data->flags&GAD_INVISIBLE)!=0) continue;
      debug_Message("  %04lx - %s\n",gad->gadget_id,gad->class_data->class_name);
//      gadget_SetFont(gad,descriptor->taglist);
      gadget_InitColorTable(gad);
      skin_FillGadgetInfo(skin,gad);
    }
  }

  debug_End();

  return(ret);
}


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

  debug_Begin();

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

  debug_End();

  return(ret);
}

---