---

gadget_Group.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
 *
 */
/*
 *  group.c
 */
#include <stdlib.h>

#include "debug.h"
#include "classes.h"
#include "Memory.h"
#include "Bases.h"
#include "Module.h"
#include "Common.h"

#include "gadgets/gadget_Group.h"


#define ERR_NOTYPE                   "No orientation given"
#define ERR_BADID                    "Bad ID given"
#define ERR_BADSIZE                  "Bad size given for layout"
#define ERR_DONT_SUGGEST_LARGER_SIZE "Don't suggest larger size"
#define ERR_BADGADEV                 "Bad Gadget_t event arrived"

#define MIN   0
#define MAX   1

struct gadget_stat
{
  Gadget_t *gad;      /* pointer to the gadget          */
  int curr;           /* actual size                    */
  int limit[2];       /* 0-min 1-max                    */
  int in_race;        /* race for area                  */
  int weight;
  Extent_t minsize;
  Extent_t maxsize;
  Rect_t counted_rect;
};

struct _group
{
  Gadget_t gadget;
  struct gadget_stat *gad_stat;
  int gad_stat_cnt;
  int orientation;
  int size;
  int gap_size;
  int border_size;
  int gadget_count;
  Rect_t act_rect;
  Extent_t min_ext;
  Extent_t max_ext;
  Extent_t sug_ext;
};


static u32 group_add_gadget(Gadget_t *this_gadget, tag *taglist);
static u32 group_add_gadget_tail(Gadget_t *this_gadget, tag *taglist);
static u32 group_remove_gadget(Gadget_t *this_gadget, tag *taglist);
static u32 group_get_gadget(Gadget_t *this_gadget, tag *taglist);
static u32 group_resize(Gadget_t *this_gadget, tag *taglist);
static u32 group_get_size(Gadget_t *this_gadget, tag *taglist);
static u32 group_invalidate_size(Gadget_t *this_gadget, tag *taglist);


static bases_Modules_t *api;
VERSION("Group.gadget",1,0,"Gergely Gati","g.gati@freemail.hu");

static gadget_Method_t methods[]=
{
  {"add_gadget",group_add_gadget,0L},
  {"add_gadget_tail",group_add_gadget_tail,0L},
  {"remove_gadget",group_remove_gadget,0L},
  {"get_gadget",group_get_gadget,0L},
  {"resize",group_resize,0L},
  {"get_size",group_get_size,0L},
  {"invalidate_size",group_invalidate_size,0L},
  GADGET_METHOD_DONE
};


static gadget_Binding_t binding[]=
{
  {"orientation",TAG_GRP_ORIENTATION,GADGET_SELECT,"horizontal|vertical|matrix"},
  {"gapsize",TAG_GRP_GAPSIZE,GADGET_INT,NULL},
  {"bordersize",TAG_GRP_BORDERSIZE,GADGET_INT,NULL},
  {"size",TAG_GRP_SIZE,GADGET_SELECT,"flexible|fixed_width|fixed_height|fixed"},
  GADGET_BINDING_DONE
};


/*
 *  At the first call of group_get_extent() calls this to count
 *  the actual extents, but the following calls uses this stored
 *  values, and they don't call this function anymore.
 */
static void group_real_get_extent(Gadget_t *this, Extent_t *min, Extent_t *max)
{
  Gadget_t *node;
  Extent_t child_min,child_max;
  int gadget_count=0;

  debug_Begin();

  min->width=min->height=0;
  if(((group *)this)->orientation==GRP_ORIENTATION_HORIZONTAL)
  {
    debug_Message("horizontal group");
    max->width=0;
    max->height=GADGET_MAXIMUM_SIZE;
    for(node=(Gadget_t *)api->gadget_Call(GADGET_FIRST_CHILD,TAG_GADGET_OBJECT,this,TAG_DONE);node!=NULL;node=(Gadget_t *)api->gadget_Call(GADGET_RIGHT_BROTHER,TAG_GADGET_OBJECT,node,TAG_DONE))
    {
      debug_Message("node: %s.%04lx",node->class_data->class_name,node->gadget_id);
      if((node->class_data->flags&GAD_INVISIBLE)!=0) continue;
      api->gadget_Call(GADGET_GET_EXTENT,TAG_GADGET_OBJECT,node,TAG_GADGET_MIN,&child_min,TAG_GADGET_MAX,&child_max,TAG_DONE);
      debug_Message("  extent (min): %dx%d",child_min.width,child_min.height);
      min->width+=child_min.width;
      max->width+=child_max.width;
      if(child_min.height>min->height) min->height=child_min.height;
      if(child_max.height<max->height) max->height=child_max.height;
      gadget_count++;
    }
    if(gadget_count==0) {debug_End();return;}
    min->width+=(gadget_count-1)*((group *)this)->gap_size;
    max->width+=(gadget_count-1)*((group *)this)->gap_size;
  }

  if(((group *)this)->orientation==GRP_ORIENTATION_VERTICAL)
  {
    debug_Message("vertical group");
    max->width=GADGET_MAXIMUM_SIZE;
    max->height=0;
    for(node=(Gadget_t *)api->gadget_Call(GADGET_FIRST_CHILD,TAG_GADGET_OBJECT,this,TAG_DONE);node!=NULL;node=(Gadget_t *)api->gadget_Call(GADGET_RIGHT_BROTHER,TAG_GADGET_OBJECT,node,TAG_DONE))
    {
      debug_Message("node: %s.%04lx",node->class_data->class_name,node->gadget_id);
      if((node->class_data->flags&GAD_INVISIBLE)!=0) continue;
      api->gadget_Call(GADGET_GET_EXTENT,TAG_GADGET_OBJECT,node,TAG_GADGET_MIN,&child_min,TAG_GADGET_MAX,&child_max,TAG_DONE);
      debug_Message("  extent (min): %dx%d",child_min.width,child_min.height);
      min->height+=child_min.height;
      max->height+=child_max.height;
      if(child_min.width>min->width) min->width=child_min.width;
      if(child_max.width<max->width) max->width=child_max.width;
      gadget_count++;
    }
    if(gadget_count==0) {debug_End();return;}
    min->height+=(gadget_count-1)*((group *)this)->gap_size;
    max->height+=(gadget_count-1)*((group *)this)->gap_size;
  }

  if(max->height<min->height) max->height=min->height;
  if(max->width<min->width) max->width=min->width;
  debug_Message("  ID=%04lx -- %dx%d -> %dx%d (+border=%d)",this->gadget_id,min->width,min->height,max->width,max->height,((group *)this)->border_size);
  min->width+=((group *)this)->border_size*2;
  max->width+=((group *)this)->border_size*2;
  min->height+=((group *)this)->border_size*2;
  max->height+=((group *)this)->border_size*2;
  if(((group *)this)->size==GRP_SIZE_FIXED_HEIGHT) max->height=min->height;
  if(((group *)this)->size==GRP_SIZE_FIXED_WIDTH) max->width=min->width;
  ((group *)this)->gadget_count=gadget_count;
  debug_Message("TOTAL: %d gadgets",gadget_count);

  debug_End();
}


/*
 *  This function is always called after the Gadget_t has been created and
 *  attached to the Gadget_t tree, but before the call to group_layout(). It may be
 *  called more than once. It must fill in the Gadget_t's minimum and maximum
 *  sizes into the supplied extent structures.
 */
static void group_get_extent(Gadget_t *this, Extent_t *min, Extent_t *max)
{
  debug_Begin();

  if(this!=NULL)
  {
    if(((group *)this)->min_ext.width>0)
    {
      min->width=((group *)this)->min_ext.width;
      min->height=((group *)this)->min_ext.height;
      max->width=((group *)this)->max_ext.width;
      max->height=((group *)this)->max_ext.height;
    }
    else
    {
      group_real_get_extent(this,min,max);
      ((group *)this)->min_ext.width=min->width;
      ((group *)this)->min_ext.height=min->height;
      ((group *)this)->max_ext.width=max->width;
      ((group *)this)->max_ext.height=max->height;
    }
  }
  debug_Message("  ID=%04lx  %dx%d -> %dx%d",this->gadget_id,min->width,min->height,max->width,max->height);

  debug_End();
}


static void group_damage(Gadget_t *this, Rect_t *rect)
{
  int i;
  group *gad=(group *)this;
  Rect_t rgad;

  debug_Begin();

  for(i=0;i<gad->gadget_count;i++)
  {
    if(api->gui_Call(GUI_ISOVERLAP,TAG_GUI_R1,rect,TAG_GUI_R2,&gad->gad_stat[i].counted_rect,TAG_DONE))
    {
      api->gui_Call(GUI_CALCULATEOVERLAP,TAG_GUI_R1,rect,TAG_GUI_R2,&gad->gad_stat[i].counted_rect,TAG_GUI_R3,&rgad,TAG_DONE);
      api->gadget_Call(GADGET_DAMAGE,TAG_GADGET_OBJECT,gad->gad_stat[i].gad,TAG_GADGET_RECT,&rgad,TAG_DONE);
    }
  }

  debug_End();
}


static int group_calculate_layout_sizes(group *this, Rect_t *rect)
{
  Gadget_t *gad;
  int gad_cnt,W,i,dist=0,dist2;
  struct gadget_stat *gadst;
  Rect_t srect;
  int left,top,lm,w,racers;
  int opt_inc,cur_inc,max_inc,need;

  debug_Begin();

  if(this->gadget_count>0&&(this->gad_stat!=NULL||NULL!=(this->gad_stat=mem_malloc(this->gadget_count*sizeof(struct gadget_stat)))))
  {
    gadst=this->gad_stat;
    memcpy(&this->act_rect,rect,sizeof(Rect_t));
    this->sug_ext.width=rect->width;
    this->sug_ext.height=rect->height;

    if(this->orientation==GRP_ORIENTATION_HORIZONTAL) dist=rect->width;
    else if(this->orientation==GRP_ORIENTATION_VERTICAL) dist=rect->height;
    else debug_Error("Orientation not supported!");

    for(i=W=0,gad=(Gadget_t *)api->gadget_Call(GADGET_FIRST_CHILD,TAG_GADGET_OBJECT,(Gadget_t *)this,TAG_DONE);gad!=NULL;gad=(Gadget_t *)api->gadget_Call(GADGET_RIGHT_BROTHER,TAG_GADGET_OBJECT,gad,TAG_DONE))
    {
      if((gad->class_data->flags&GAD_INVISIBLE)==0)
      {
        W+=gad->weight;
        gadst[i].in_race=1;
        gadst[i].gad=gad;
        gadst[i].weight=gad->weight;
        api->gadget_Call(GADGET_GET_EXTENT,TAG_GADGET_OBJECT,gadst[i].gad,TAG_GADGET_MIN,&gadst[i].minsize,TAG_GADGET_MAX,&gadst[i].maxsize,TAG_DONE);
        if(this->orientation==GRP_ORIENTATION_HORIZONTAL)
        {
          gadst[i].limit[MIN]=gadst[i].minsize.width;
          gadst[i].limit[MAX]=gadst[i].maxsize.width;
        }
        else // ha tobb orientation lesz, akkor ide else if() kell
        {
          gadst[i].limit[MIN]=gadst[i].minsize.height;
          gadst[i].limit[MAX]=gadst[i].maxsize.height;
        }
        i++;
      }
    }
    this->gad_stat_cnt=gad_cnt=i;
    dist-=((gad_cnt-1)*this->gap_size)+(this->border_size<<1);

    do
    {
      for(dist2=dist,w=W,i=0;i<gad_cnt;i++)
      {
        if(gadst[i].in_race==0) continue;
        gadst[i].curr=(dist2*gadst[i].weight)/w;
        dist-=gadst[i].curr;
        dist2-=gadst[i].curr;
        w-=gadst[i].weight;
        if(gadst[i].curr<gadst[i].limit[MIN])
        {
          dist+=gadst[i].curr-gadst[i].limit[MIN];
          gadst[i].curr=gadst[i].limit[MIN];
        }
        else if(gadst[i].curr>gadst[i].limit[MAX])
        {
          dist+=gadst[i].curr-gadst[i].limit[MAX];
          gadst[i].curr=gadst[i].limit[MAX];
        }
      }
      if(dist==0) break;
      lm=(dist>0?MAX:MIN);
      for(i=0;i<gad_cnt;i++)
      {
        if(gadst[i].in_race==0) continue;
        if(gadst[i].curr==gadst[i].limit[lm])
        {
          gadst[i].in_race=0;
          W-=gadst[i].weight;
        }
        else dist+=gadst[i].curr;
      }
    } while(1);

    // suggest extent
    need=W=racers=0;
    if(this->orientation==GRP_ORIENTATION_HORIZONTAL)
    {
      for(i=0;i<gad_cnt;i++)
      {
        gadst[i].counted_rect.width=gadst[i].curr;
        gadst[i].counted_rect.height=rect->height-(this->border_size<<1);
        if(gadst[i].maxsize.height<gadst[i].counted_rect.height) gadst[i].counted_rect.height=gadst[i].maxsize.height;
        memcpy(&srect,&gadst[i].counted_rect,sizeof(Rect_t));
        debug_Message("[horiz] %04lx's child: %04lx min=%dx%d max=%dx%d curr=%dx%d",this->gadget.gadget_id,gadst[i].gad->gadget_id,gadst[i].minsize.width,gadst[i].minsize.height,gadst[i].maxsize.width,gadst[i].maxsize.height,srect.width,srect.height);
        if(srect.height<gadst[i].minsize.height) debug_Error("ROSSZ MAGASSAG ID=%04lx min=%d curr=%d rect.height=%d",gadst[i].gad->gadget_id,gadst[i].minsize.height,srect.height,rect->height);
        api->gadget_Call(GADGET_SUGGEST_EXTENT,TAG_GADGET_OBJECT,gadst[i].gad,TAG_GADGET_RECT,&srect,TAG_DONE);
        gadst[i].in_race=1;
        W+=gadst[i].weight;
        if(srect.width<=gadst[i].counted_rect.width&&srect.height<=gadst[i].counted_rect.height)
        {
          gadst[i].counted_rect.height=srect.height;
          if(srect.width<gadst[i].counted_rect.width)
          {
            gadst[i].in_race=0;
            W-=gadst[i].weight;
            need+=gadst[i].counted_rect.width-srect.width;
            gadst[i].counted_rect.width=srect.width;
          }
        }
        else debug_Error(ERR_DONT_SUGGEST_LARGER_SIZE " gadget_id=%04lx",gadst[i].gad->gadget_id);
        gadst[i].curr=gadst[i].counted_rect.width;
        racers+=gadst[i].in_race;
      }
    }
    else // GRP_ORIENTATION_VERTICAL
    {
      for(i=0;i<gad_cnt;i++)
      {
        gadst[i].counted_rect.width=rect->width-(this->border_size<<1);
        gadst[i].counted_rect.height=gadst[i].curr;
        if(gadst[i].maxsize.width<gadst[i].counted_rect.width) gadst[i].counted_rect.width=gadst[i].maxsize.width;
        memcpy(&srect,&gadst[i].counted_rect,sizeof(Rect_t));
        debug_Message("[vert] %04lx's child: %04lx min=%dx%d max=%dx%d curr=%dx%d",this->gadget.gadget_id,gadst[i].gad->gadget_id,gadst[i].minsize.width,gadst[i].minsize.height,gadst[i].maxsize.width,gadst[i].maxsize.height,srect.width,srect.height);
        if(srect.width<gadst[i].minsize.width) debug_Error("ROSSZ SZELESSEG ID=%04lx min=%d curr=%d",gadst[i].gad->gadget_id,gadst[i].minsize.width,srect.width);
        api->gadget_Call(GADGET_SUGGEST_EXTENT,TAG_GADGET_OBJECT,gadst[i].gad,TAG_GADGET_RECT,&srect,TAG_DONE);
        gadst[i].in_race=1;
        W+=gadst[i].weight;
        if(srect.width<=gadst[i].counted_rect.width&&srect.height<=gadst[i].counted_rect.height)
        {
          gadst[i].counted_rect.width=srect.width;
          if(srect.height<gadst[i].counted_rect.height)
          {
            gadst[i].in_race=0;
            W-=gadst[i].weight;
            need+=gadst[i].counted_rect.height-srect.height;
            gadst[i].counted_rect.height=srect.height;
          }
        }
        else debug_Error(ERR_DONT_SUGGEST_LARGER_SIZE " gadget_id=%04lx",gadst[i].gad->gadget_id);
        gadst[i].curr=gadst[i].counted_rect.height;
        racers+=gadst[i].in_race;
      }
    }
    while(racers>0&&need>0)
    {
      for(w=W,i=0;i<gad_cnt;i++)
      {
        if(gadst[i].in_race==0) continue;
        opt_inc=(need*gadst[i].weight)/w;
        max_inc=gadst[i].limit[MAX]-gadst[i].curr;
        cur_inc=min(opt_inc,max_inc);
        if(opt_inc>=max_inc)
        {
          cur_inc=max_inc;
          racers--;
          gadst[i].in_race=0;
          W-=gadst[i].weight;
        }
        w-=gadst[i].weight;
        gadst[i].curr+=cur_inc;
        need-=cur_inc;
      }
    }

    left=rect->left+this->border_size;
    top=rect->top+this->border_size;
    if(this->orientation==GRP_ORIENTATION_HORIZONTAL)
    {
      this->sug_ext.height=0;
      left+=need>>1;
      for(i=0;i<gad_cnt;i++)
      {
        gadst[i].counted_rect.width=gadst[i].curr;
        gadst[i].counted_rect.top=top+(((rect->height-(this->border_size<<1))-gadst[i].counted_rect.height)>>1);
        gadst[i].counted_rect.left=left;
        if(gadst[i].counted_rect.height>this->sug_ext.height) this->sug_ext.height=gadst[i].counted_rect.height;
        left+=gadst[i].counted_rect.width+this->gap_size;
      }
      this->sug_ext.width=rect->width-need;
      this->sug_ext.height+=this->border_size<<1;
    }
    else if(this->orientation==GRP_ORIENTATION_VERTICAL)
    {
      this->sug_ext.width=0;
      top+=need>>1;
      for(i=0;i<gad_cnt;i++)
      {
        gadst[i].counted_rect.height=gadst[i].curr;
        gadst[i].counted_rect.top=top;
        gadst[i].counted_rect.left=left+(((rect->width-(this->border_size<<1))-gadst[i].counted_rect.width)>>1);
        if(gadst[i].counted_rect.width>this->sug_ext.width) this->sug_ext.width=gadst[i].counted_rect.width;
        top+=gadst[i].counted_rect.height+this->gap_size;
      }
      this->sug_ext.width+=this->border_size<<1;
      this->sug_ext.height=rect->height-need;
    }
  }

  debug_End();

  return(0);
}


static void group_suggest_extent(Gadget_t *this, Rect_t *rect)
{

  debug_Begin();

  if(0==(group_calculate_layout_sizes((group *)this, rect)))
  {
    rect->width=((group *)this)->sug_ext.width;
    rect->height=((group *)this)->sug_ext.height;
  }

  debug_End();
}

/*
 *  This function is called always after group_get_extent() has been called at
 *  least once. It receives a position and an extent which determine the
 *  position and the size of the Gadget_t on the screen. This extent is always
 *  between the minimum and maximum sizes which were returned by
 *  group_get_extent() of the same gadget. After this call the Gadget_t is made
 *  visible.
 */
static void group_layout(Gadget_t *this, Rect_t *rect)
{
  int i;

  debug_Begin();

  debug_Message("----ID=%04lx  %dx%d",this->gadget_id,rect->width,rect->height);
  if(0==(group_calculate_layout_sizes((group *)this,rect)))
  {
    for(i=0;i<((group *)this)->gad_stat_cnt;i++)
    {
      api->gadget_Call(GADGET_LAYOUT,TAG_GADGET_OBJECT,((group *)this)->gad_stat[i].gad,TAG_GADGET_RECT,&((group *)this)->gad_stat[i].counted_rect,TAG_DONE);
    }
  }

  debug_End();
}


static int group_input_event_handler(Gadget_t *gad, struct glw_Event *event)
{
  group *this;
  int ret=-1;

  debug_Begin();

  this=(group *)gad;
  switch(event->event)
  {
    case GLWEV_KEYUP:
    {
      printf("%04lx key up\n",gad->gadget_id);
      ret=0;
      break;
    }
    case GLWEV_KEYDOWN:
    {
      printf("%04lx key down\n",gad->gadget_id);
      ret=0;
      break;
    }
  }

  debug_End();

  return(ret);
}


static int group_init_gadget(Gadget_t *this, tag *taglist)
{
  debug_Begin();

  ((group *)this)->orientation=tag_GetTagData(taglist,TAG_GRP_ORIENTATION,0L);
  ((group *)this)->size=tag_GetTagData(taglist,TAG_GRP_SIZE,0L);
  ((group *)this)->gap_size=tag_GetTagData(taglist,TAG_GRP_GAPSIZE,0L);
  ((group *)this)->border_size=tag_GetTagData(taglist,TAG_GRP_BORDERSIZE,0L);
  ((group *)this)->gad_stat=NULL;
  ((group *)this)->min_ext.width=-1;
  ((group *)this)->max_ext.width=-1;
  ((group *)this)->min_ext.height=-1;
  ((group *)this)->max_ext.height=-1;
  ((group *)this)->gadget_count=0;

  debug_End();

  return(0);
}

static void group_delete_gadget(Gadget_t *this)
{
  if(((group *)this)->gad_stat!=NULL)
  {
    mem_free(((group *)this)->gad_stat);
    ((group *)this)->gad_stat=NULL;
  }
}

/*
 *  Since the group become dynamic, you able to add gadgets (or groups) to it.
 *  You must create (and setup) your gadgets and call this function to add
 *  and make visible the new Gadget_t in the group. This function may returns
 *  FALSE, if the available extents less than the required. In this case the
 *  Gadget_t isn't added.
 */
static u32 group_add_gadget_tail(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}

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


/*
 *  Removes the given gadget.
 */
static u32 group_remove_gadget(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}


/*
 *  Returns the Gadget_t at position 'index'.
 */
static u32 group_get_gadget(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}


/*
 *  Experimental function, do not use. It works fine, but it doesn't fit into our concepts.
 *  Until the window doesn't become resizeable it's unusable.
 */
static u32 group_resize(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}


/*
 *  Returns the actual extent of the given group.
 */
static u32 group_get_size(Gadget_t *this_gadget, tag *taglist)
{
  return(0L);
}


static u32 group_invalidate_size(Gadget_t *this_gadget, tag *taglist)
{
  if(this_gadget!=NULL) ((group *)this_gadget)->min_ext.width=-1;
  return(0L);
}

static int group_gadget_event_handler(Gadget_t *this, int event, tag *taglist)
{
  int ret=-1;

  debug_Begin();

  if(this!=NULL&&event>=0)
  {
    switch(event)
    {
      case GADEV_INIT_GADGET:
      {
        ret=group_init_gadget(this,taglist);
        break;
      }
      case GADEV_DELETE_GADGET:
      {
        group_delete_gadget(this);
        ret=0;
        break;
      }
      case GADEV_GET_EXTENT:
      {
        Extent_t *min,*max,n,x;
        min=(Extent_t *)tag_GetTagData(taglist,TAG_GAD_EXTMIN,(u32)&n);
        max=(Extent_t *)tag_GetTagData(taglist,TAG_GAD_EXTMAX,(u32)&x);
        group_get_extent(this,min,max);
        ret=0;
        break;
      }
      case GADEV_SUGGEST_EXTENT:
      {
        Rect_t *rect,r;
        rect=(Rect_t *)tag_GetTagData(taglist,TAG_GAD_RECT,(u32)&r);
        group_suggest_extent(this,rect);
        ret=0;
        break;
      }
      case GADEV_LAYOUT:
      {
        Rect_t *rect,r;
        rect=(Rect_t *)tag_GetTagData(taglist,TAG_GAD_RECT,(u32)&r);
        group_layout(this,rect);
        ret=0;
        break;
      }
      case GADEV_DAMAGE:
      {
        Rect_t *rect,r;
        rect=(Rect_t *)tag_GetTagData(taglist,TAG_GAD_RECT,(u32)&r);
        group_damage(this,rect);
        ret=0;
        break;
      }
      case GADEV_SAVE:
      {
        u8 **mem;
        int *size;
        u32 *p;
        mem=(u8 **)tag_GetTagData(taglist,TAG_GADGET_MEM,0L);
        size=(int *)tag_GetTagData(taglist,TAG_GADGET_SIZE,0L);
        *size=4*sizeof(u32);
        if(NULL!=(*mem=mem_malloc(*size)))
        {
          p=(u32 *)*mem;
          *p++=api->glw_Call(GLW_HTONL2,TAG_GLW_VALUE,(u32)((group *)this)->orientation,TAG_DONE);
          *p++=api->glw_Call(GLW_HTONL2,TAG_GLW_VALUE,(u32)((group *)this)->size,TAG_DONE);
          *p++=api->glw_Call(GLW_HTONL2,TAG_GLW_VALUE,(u32)((group *)this)->gap_size,TAG_DONE);
          *p++=api->glw_Call(GLW_HTONL2,TAG_GLW_VALUE,(u32)((group *)this)->border_size,TAG_DONE);
          ret=0;
        }
        break;
      }
      case GADEV_RESTORE:
      {
        u8 *mem;
        int size;
        u32 *p;
        mem=(u8 *)tag_GetTagData(taglist,TAG_GADGET_MEM,0L);
        size=(int)tag_GetTagData(taglist,TAG_GADGET_SIZE,0L);
        if(size==(4*sizeof(u32)))
        {
          p=(u32 *)mem;
          ((group *)this)->orientation=(int)api->glw_Call(GLW_NTOHL2,TAG_GLW_VALUE,*p++,TAG_DONE);
          ((group *)this)->size=(int)api->glw_Call(GLW_NTOHL2,TAG_GLW_VALUE,*p++,TAG_DONE);
          ((group *)this)->gap_size=(int)api->glw_Call(GLW_NTOHL2,TAG_GLW_VALUE,*p++,TAG_DONE);
          ((group *)this)->border_size=(int)api->glw_Call(GLW_NTOHL2,TAG_GLW_VALUE,*p++,TAG_DONE);
          ret=0;
        }
        break;
      }
    }
  }

  debug_End();

  return(ret);
}


/*
 *  This function is called once before the creation of any Gadget_t of this
 *  class. Gadgets can be created only after this function has been called.
 */
static void init_group_class(u32 module)
{
  api->gadget_Call(GADGET_REGISTER_CLASS,
                            TAG_GADGET_CLASS_ID,CLASS_GROUP_ID,
                            TAG_GADGET_NAME,CLASS_GROUP_NAME,
                TAG_GADGET_BINDING,binding,
                TAG_GADGET_COLOR_NAMES,NULL,
                TAG_GADGET_CUSTOM_NAMES,NULL,
                TAG_GADGET_STATE_MASK,GADSTF_NORMAL,
                TAG_GADGET_MODULE,module,
                TAG_GADGET_GADGET_SIZE,sizeof(group),
                TAG_GADGET_METHODS,methods,
                TAG_GADGET_INPUT_EVENT_HANDLER,group_input_event_handler,
                TAG_GADGET_EVENT_HANDLER,NULL,
                TAG_GADGET_GADGET_EVENT_HANDLER,group_gadget_event_handler,
                TAG_DONE);
}


EXPORT int module_Init(u32 module, bases_Modules_t *bases)
{
    api=bases;
    init_group_class(module);
    return(0);
}

---