mui/gtk-mui/classes/table.c

   1 /*****************************************************************************
   2  *
   3  * mui-gtk - a wrapper library to wrap GTK+ calls to MUI
   4  *
   5  * Copyright (C) 2005 Oliver Brunner
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  * Contact information:
  22  *
  23  * Oliver Brunner
  24  *
  25  * E-Mail: mui-gtk "at" oliver-brunner.de
  26  *
  27  * $Id$
  28  *
  29  *****************************************************************************/
  30
  31 /* table class
  32 **
  33 ** emulates table widget in gtk
  34 **
  35 ** supports:
  36 **
  37 ** gtk_table_attach() (no options, no padding)
  38 ** gtk_table_attach_defaults()
  39 ** gtk_table_set_row_spacings()
  40 ** gtk_table_set_col_spacings()
  41 ** gtk_table_get_default_col_spacing()
  42 ** gtk_table_get_default_row_spacing()
  43 **
  44 ** todo:
  45 **
  46 ** gtk_table_set_homogeneous()
  47 ** gtk_table_get_col_spacing()
  48 ** gtk_table_get_row_spacing()
  49 **
  50 ** in short, cells are homogenous
  51 **
  52 */
  53
  54 #include <clib/alib_protos.h>
  55 #include <proto/utility.h>
  56 #include <exec/types.h>
  57 #include <mui.h>
  58
  59 #include "classes.h"
  60 #include "gtk_globals.h"
  61 #include "gtk.h"
  62 #include "debug.h"
  63
  64 /*********************************************************************/
  65
  66 struct Data
  67 {
  68   struct Hook LayoutHook;
  69   struct MinList ChildList;
  70
  71   ULONG columns, rows, vertspacing, horizspacing;
  72   LONG  defwidth, defheight;
  73 };
  74
  75 struct TableNode
  76 {
  77   struct MinNode node;
  78   GtkWidget *widget;
  79   UWORD left, right, top, bottom;
  80 };
  81
  82 static VOID mSet(struct Data *data, APTR obj, struct opSet *msg, ULONG is_new);
  83
  84 #ifndef __AROS__
  85 HOOKPROTO(LayoutHook, ULONG, APTR obj, struct MUI_LayoutMsg *lm)
  86 {
  87 #else
  88 AROS_UFH3(static ULONG, LayoutHook, AROS_UFHA(struct Hook *, hook, a0), AROS_UFHA(APTR, obj, a2), AROS_UFHA(struct MUI_LayoutMsg *, lm, a1))
  89 #endif
  90   switch (lm->lm_Type)
  91   {
  92     case MUILM_MINMAX:
  93     {
  94       struct Data *data = hook->h_Data;
  95       struct TableNode *node;
  96       ULONG mincw, minch, defcw, defch, maxcw, maxch;
  97
  98       mincw = 0;
  99       minch = 0;
 100       defcw = data->horizspacing;
 101       defch = data->vertspacing;
 102       maxcw = 0;
 103       maxch = 0;
 104
 105       ForeachNode(&data->ChildList, node)
 106       {
 107         ULONG w, h, cols, rows;
 108
 109         w = _minwidth(node->widget->MuiObject);
 110         h = _minheight(node->widget->MuiObject);
 111
 112         cols = node->right - node->left;
 113         rows = node->bottom - node->top;
 114
 115         if (cols)
 116         {
 117           ULONG s = w / cols;
 118
 119           if (s > mincw)
 120           {
 121             mincw = s + (s % cols ? 1 : 0);
 122           }
 123         }
 124
 125         if (rows)
 126         {
 127           ULONG s = h / rows;
 128
 129           if (s > minch)
 130           {
 131             minch = s + (s % rows ? 1 : 0);
 132           }
 133         }
 134
 135         // calculate default cell width/height
 136
 137         w = _defwidth(node->widget->MuiObject);
 138         h = _defheight(node->widget->MuiObject);
 139
 140         if (cols)
 141         {
 142           ULONG s = w / cols;
 143
 144           if (s > defcw)
 145           {
 146             defcw = s + (s % cols ? 1 : 0);
 147           }
 148         }
 149
 150         if (rows)
 151         {
 152           ULONG s = h / rows;
 153
 154           if (s > defch)
 155           {
 156             defch = s + (s % rows ? 1 : 0);
 157           }
 158         }
 159
 160         // calculate max cell width/height
 161
 162         w = _maxwidth(node->widget->MuiObject);
 163         h = _maxheight(node->widget->MuiObject);
 164
 165         if (cols)
 166         {
 167           ULONG s = w / cols;
 168
 169           if (s > maxcw)
 170           {
 171             maxcw = s + (s % cols ? 1 : 0);
 172           }
 173         }
 174
 175         if (rows)
 176         {
 177           ULONG s = h / rows;
 178
 179           if (s > maxch)
 180           {
 181             maxch = s + (s % rows ? 1 : 0);
 182           }
 183         }
 184       }
 185
 186       lm->lm_MinMax.MinWidth  = mincw * data->columns;
 187       lm->lm_MinMax.MinHeight = minch * data->rows;
 188       lm->lm_MinMax.DefWidth  = defcw * data->columns;
 189       lm->lm_MinMax.DefHeight = defch * data->rows;
 190       lm->lm_MinMax.MaxWidth  = maxcw * data->columns;
 191       lm->lm_MinMax.MaxHeight = maxch * data->rows;
 192     }
 193     return 0;
 194
 195     case MUILM_LAYOUT:
 196     {
 197       struct Data *data = hook->h_Data;
 198
 199       if (data->columns && data->rows)
 200       {
 201         struct TableNode *node;
 202         ULONG cw, ch;
 203
 204         cw = lm->lm_Layout.Width / data->columns;
 205         ch = lm->lm_Layout.Height / data->rows; /* +1 ? */
 206
 207         ForeachNode(&data->ChildList, node)
 208         {
 209           if (!MUI_Layout(node->widget->MuiObject,
 210             node->left * cw,
 211             node->top * ch ,
 212             (node->right - node->left) * cw,
 213             (node->bottom - node->top ) * ch,
 214             0))
 215           {
 216             return FALSE;
 217           }
 218         }
 219       }
 220     }
 221     return TRUE;
 222   }
 223
 224   return MUILM_UNKNOWN;
 225 }
 226
 227 static ULONG mNew(struct IClass *cl, APTR obj, Msg msg)
 228 {
 229   obj = (APTR)DoSuperMethodA(cl, obj, msg);
 230
 231   if (obj)
 232   {
 233     GETDATA;
 234
 235     SETUPHOOK(&data->LayoutHook, LayoutHook, data);
 236 //afxgroup - Is this a typo? (&data->ChildList)
 237     MGTK_NEWLIST(data->ChildList);
 238
 239     data->vertspacing = 0;
 240     data->horizspacing = 0;
 241     data->defwidth = -1;
 242     data->defheight = -1;
 243
 244     set(obj, MUIA_Group_LayoutHook, &data->LayoutHook);
 245     mSet(data, obj, (APTR)msg, TRUE);
 246   }
 247
 248   return (ULONG)obj;
 249 }
 250
 251 static ULONG mGet(struct Data *data, APTR obj, struct opGet *msg, struct IClass *cl)
 252 {
 253   ULONG rc;
 254
 255   switch (msg->opg_AttrID)
 256   {
 257     case MA_Table_VertSpacing : rc = data->vertspacing; break;
 258     case MA_Table_HorizSpacing: rc = data->horizspacing; break;
 259
 260     default: return DoSuperMethodA(cl, obj, (Msg)msg);
 261   }
 262
 263   *msg->opg_Storage = rc;
 264   return TRUE;
 265 }
 266
 267 static VOID mSet(struct Data *data, APTR obj, struct opSet *msg, ULONG is_new)
 268 {
 269   struct TagItem *tstate, *tag;
 270   ULONG relayout = 0;
 271
 272   tstate = msg->ops_AttrList;
 273
 274   while ((tag = NextTagItem(&tstate)))
 275   {
 276     switch (tag->ti_Tag)
 277     {
 278       case MA_Table_Columns:
 279         data->columns = tag->ti_Data;
 280         break;
 281
 282       case MA_Table_Rows:
 283         data->rows = tag->ti_Data;
 284         break;
 285
 286       case MA_Table_VertSpacing:
 287         if (data->vertspacing != tag->ti_Data)
 288         {
 289           data->vertspacing = tag->ti_Data;
 290           relayout = 1;
 291         }
 292         break;
 293
 294       case MA_Table_HorizSpacing:
 295         if (data->horizspacing != tag->ti_Data)
 296         {
 297           data->horizspacing = tag->ti_Data;
 298           relayout = 1;
 299         }
 300         break;
 301
 302       case MA_DefWidth:
 303         if (data->defwidth != tag->ti_Data)
 304         {
 305           data->defwidth = tag->ti_Data;
 306           relayout = 1;
 307         }
 308         break;
 309
 310       case MA_DefHeight:
 311         if (data->defheight != tag->ti_Data)
 312         {
 313           data->defheight = tag->ti_Data;
 314           relayout = 1;
 315         }
 316         break;
 317     }
 318   }
 319
 320   if (relayout)
 321   {
 322     DoMethod(obj, MUIM_Group_InitChange);
 323     DoMethod(obj, MUIM_Group_ExitChange);
 324   }
 325 }
 326
 327 static VOID mRemMember(struct Data *data, struct opMember *msg)
 328 {
 329   struct TableNode *node;
 330
 331   ForeachNode(&data->ChildList, node)
 332   {
 333     if (node->widget->MuiObject == msg->opam_Object)
 334     {
 335       REMOVE(node);
 336       mgtk_freemem(node, sizeof(*node));
 337       return;
 338     }
 339   }
 340 }
 341
 342 static ULONG mAttach(struct Data *data, APTR obj, struct MUIP_Table_Attach *msg) {
 343   struct TableNode *node;
 344 //afxgroup - msg redeclared as different kind of symbol
 345
 346   DebOut("mAttach(..)\n");
 347
 348   DebOut("msg=%lx\n",msg);
 349
 350   node = mgtk_allocmem(sizeof(*node), MEMF_ANY);
 351
 352   if (node)
 353   {
 354     ADDTAIL(&data->ChildList, node);
 355
 356     node->widget = msg->widget;
 357     node->left = msg->left;
 358     node->right = msg->right;
 359     node->top = msg->top;
 360     node->bottom = msg->bottom;
 361
 362     DebOut("  msg->widget: %lx\n",msg->widget);
 363     DebOut("  msg->widget->MuiObject: %lx\n",msg->widget->MuiObject);
 364     DebOut("  obj: %lx\n",obj);
 365     DoMethod(obj, MUIM_Group_InitChange);
 366     DoMethod(obj, OM_ADDMEMBER, msg->widget->MuiObject);
 367     DoMethod(obj, MUIM_Group_ExitChange);
 368   }
 369
 370   return 0;
 371 }
 372
 373 BEGINMTABLE
 374 GETDATA;
 375
 376   switch (msg->MethodID)
 377   {
 378     case OM_NEW         : return mNew           (cl, obj, msg);
 379         case OM_SET         :        mSet           (data, obj, (APTR)msg, FALSE); break;
 380     case OM_GET         : return mGet           (data, obj, (APTR)msg, cl);
 381     case OM_REMMEMBER   :        mRemMember     (data,      (APTR)msg); break;
 382     case MM_Table_Attach: return mAttach        (data, obj, (APTR)msg);
 383   }
 384
 385 ENDMTABLE
 386
 387 int mgtk_create_table_class(void)
 388 {
 389   CL_Table = MUI_CreateCustomClass(NULL, MUIC_Group, NULL, sizeof(struct Data), (APTR)&mDispatcher);
 390   return CL_Table ? 1 : 0;
 391 }
 392
 393 void mgtk_delete_table_class(void)
 394 {
 395   if (CL_Table)
 396   {
 397     MUI_DeleteCustomClass(CL_Table);
 398   }
 399 }