vpdf/mcc/lay_class.c

   1
   2 #include <proto/exec.h>
   3 #include <proto/dos.h>
   4 #include <proto/muimaster.h>
   5 #include <proto/utility.h>
   6 #include <proto/intuition.h>
   7 #include <proto/graphics.h>
   8 #include <clib/alib_protos.h>
   9 #include <string.h>
  10 #include <stdio.h>
  11 #include <math.h>
  12
  13 #include <private/vapor/vapor.h>
  14 #include "lay_class.h"
  15
  16 #include "util.h"
  17
  18 struct Data
  19 {
  20         int     n;  /* number of children */
  21         int     w;  /* width of children  */
  22         int     h;  /* height of children */
  23         int     hs; /* horiz spacing      */
  24         int     vs; /* vert spacing       */
  25
  26         int columns;
  27
  28         int width, height;
  29         int center;
  30         int vertdist;
  31         int childcount;
  32         int keeppos;
  33 };
  34
  35 MUI_HOOK(layoutfunc, APTR grp, struct MUI_LayoutMsg *lm)
  36 {
  37         struct IClass *cl = (struct IClass*)(h->h_Data);
  38         struct Data *data = INST_DATA(cl, grp);
  39         float vgpos = (float)xget(grp, MUIA_Virtgroup_Top) / xget(grp, MUIA_Virtgroup_Height);
  40
  41     switch (lm->lm_Type)
  42     {
  43         case MUILM_MINMAX:
  44         {
  45                         register Object *child;
  46                         Object *cstate;
  47                         unsigned int n, done = FALSE;
  48
  49                         // look for first visible child dimensions (reference)
  50
  51                         for (n = 0, cstate = (Object *)lm->lm_Children->mlh_Head; (child = NextObject(&cstate)); n++)
  52             {
  53                 ULONG sm;
  54
  55                 get(child,MUIA_ShowMe,&sm);
  56                 if (!sm) continue;
  57
  58                 if (!done)
  59                 {
  60                     data->w = _minwidth(child);
  61                     data->h = _minheight(child);
  62
  63                     done = TRUE;
  64                 }
  65             }
  66
  67             data->n = n;
  68
  69                         lm->lm_MinMax.MinWidth  = data->w;
  70                         lm->lm_MinMax.MinHeight = data->h;
  71             lm->lm_MinMax.DefWidth  = data->w;
  72             lm->lm_MinMax.DefHeight = data->h;
  73             lm->lm_MinMax.MaxWidth  = MUI_MAXMAX;
  74             lm->lm_MinMax.MaxHeight = MUI_MAXMAX;
  75
  76             return 0;
  77         }
  78
  79         case MUILM_LAYOUT:
  80         {
  81             register Object *child;
  82                         Object *cstate;
  83                         int     il, it, ir, ib, w, h, c, r, x, y, n, nd, wd, hd, hsd, vsd;
  84                         int hborder;
  85                         int count = 0;
  86                         int height;
  87
  88                         get(grp, MUIA_InnerLeft, &il);
  89                         get(grp, MUIA_InnerTop, &it);
  90                         get(grp, MUIA_InnerRight, &ir);
  91                         get(grp, MUIA_InnerBottom, &ib);
  92
  93             il = it = ir = ib = 0;
  94
  95                         get(grp, MUIA_Width, &w);
  96                         get(grp, MUIA_Height, &h);
  97
  98                         w = _mwidth(grp);
  99                         h = _mheight(grp);
 100
 101             nd  = data->n;
 102             wd  = data->w;
 103             hd  = data->h;
 104             hsd = data->hs;
 105             vsd = data->vs;
 106
 107             for (c = 1; ; c++)
 108             {
 109                 x = il+hsd*(c-1)+c*wd+ir;
 110
 111                                 if (x == w) break;
 112
 113                 if (x>w)
 114                 {
 115                                         if (c > 1)
 116                                                 c--;
 117
 118                     break;
 119                 }
 120             }
 121
 122             x = il;
 123             y = it;
 124
 125                         if (data->center)
 126                                 hborder = ( w - ( c - 1 ) * hsd - c * wd ) / 2;
 127                         else
 128                                 hborder = 0;
 129
 130             r = nd/c;
 131                         if (nd%c>0)
 132                                 r++;
 133
 134             height = it+r*hd+vsd*(r-1)+ib;
 135
 136                         /* keep focus on same entry */
 137
 138                         if (data->keeppos)
 139                         {
 140                                 nfset(grp, MUIA_Virtgroup_Top, (int)(height * vgpos));
 141                                 data->keeppos = FALSE;
 142                         }
 143
 144                         for (n = 0, cstate = (Object *)lm->lm_Children->mlh_Head; (child = NextObject(&cstate)); )
 145             {
 146                                 //ULONG sm;
 147
 148                                 //get(child,MUIA_ShowMe,&sm);
 149                                 //if (!sm) continue;
 150
 151                                 if (!MUI_Layout(child,x + hborder,y,wd,hd,0))
 152                                         return FALSE;
 153
 154                 n++;
 155
 156                                 if (n == c)
 157                 {
 158                     x =  il;
 159                     y += hd+vsd;
 160                                         n = 0;
 161                 }
 162                 else
 163                 {
 164                     x += wd+hsd;
 165                 }
 166
 167                                 count++;
 168             }
 169
 170             lm->lm_Layout.Width  = il+c*wd+hsd*(c-1)+ir;
 171                         lm->lm_Layout.Height = height;
 172
 173                         data->columns = c;
 174                         data->vertdist = hd + vsd;
 175                         data->childcount = count;
 176
 177             return TRUE;
 178         }
 179     }
 180
 181     return MUILM_UNKNOWN;
 182 }
 183
 184 DEFNEW
 185 {
 186         obj = DoSuperNew(cl,obj,
 187                         MUIA_Group_LayoutHook, (ULONG)&layoutfunc_hook,
 188                         MUIA_CustomBackfill, TRUE,
 189                         MUIA_Group_SameSize, TRUE,
 190                         TAG_MORE, INITTAGS);
 191
 192         layoutfunc_hook.h_Data = cl;
 193
 194         if (obj != NULL)
 195     {
 196                 GETDATA;
 197
 198                 data->hs = GetTagData(MUIA_Lay_HorizSpacing, 4, INITTAGS);
 199                 data->vs = GetTagData(MUIA_Lay_VertSpacing, 4, INITTAGS);
 200                 data->center = GetTagData(MUIA_Lay_Center, TRUE, INITTAGS);
 201                 data->columns = 1;
 202
 203     }
 204
 205     return (ULONG)obj;
 206 }
 207
 208 void kprintf(char *fmt, ...);
 209 #ifndef min
 210 #define min(a,b) ((a)<(b)?(a):(b))
 211 #endif
 212
 213 static void *buildregionfromicons(struct Data *data, Object *obj, int x1, int y1, int x2, int y2)
 214 {
 215         struct Region *clipregion = NewRegion();
 216
 217         if (clipregion != NULL)
 218         {
 219                 int vpos = xget(obj, MUIA_Virtgroup_Top);
 220                 int vtop = _top(obj) + vpos;
 221                 struct Rectangle r;
 222                 int columns = data->columns;
 223                 int n = 0;
 224                 int cwidth = 0, cheight = 0;
 225                 int cleft = 0;
 226                 int ctop = 0;
 227                 int i;
 228                 int count = data->childcount;
 229
 230                 void *first = (void*)DoMethod(obj, MUIM_Group_GetChild, MUIV_Group_GetChild_First);
 231
 232                 /* initial region */
 233
 234                 r.MinX = x1;
 235                 r.MinY = y1;
 236                 r.MaxX = x2;
 237                 r.MaxY = y2;
 238                 OrRectRegion(clipregion, &r);
 239
 240                 /* first child position */
 241
 242                 if (first != NULL)
 243                 {
 244                         ctop = xget(first, MUIA_TopEdge) + vpos;
 245                         cleft = _left(first);
 246                         cwidth = _width(first);
 247                         cheight = _height(first);
 248                 }
 249                 else
 250                 {
 251                         return clipregion;
 252                 }
 253
 254                 {
 255                         int skip;
 256
 257                         /* skip entries which are avobe top */
 258
 259                         skip = (vtop - ctop) / (data->vertdist);
 260                         ctop += skip * data->vertdist;
 261                         count -= columns * skip;
 262
 263                         /* calculate number of remaining entries we need to process */
 264
 265                         count = min(count, columns * ( 1 + ceil((float)xget(obj, MUIA_Height) / data->vertdist)));
 266                 }
 267
 268                 for(i = 0; i<count; i++)
 269                 {
 270                         if (n == columns)
 271                         {
 272                                 ctop += data->vertdist;
 273                                 cleft = _left(first);
 274                                 n = 0;
 275                         }
 276
 277                         r.MinX = cleft;
 278                         r.MinY = ctop - vpos;
 279                         r.MaxX = r.MinX + cwidth - 1;
 280                         r.MaxY = ctop + cheight - 1 - vpos;
 281
 282                         /* remove the area */
 283                         ClearRectRegion(clipregion, &r);
 284
 285                         cleft += cwidth + data->hs;
 286                         n++;
 287
 288                 }
 289
 290         }
 291
 292         #if 0
 293         {
 294                 int i = 0;
 295                 struct RegionRectangle *rr = clipregion->RegionRectangle;
 296                 while(rr)
 297                 {
 298                         i++;
 299                         rr = rr->Next;
 300                 }
 301
 302                 kprintf("Number of regions:%d for blit:%d,%d,%d,%d\n", i, x1, y1, x2, y2);
 303         }
 304         #endif
 305
 306         return clipregion;
 307 }
 308
 309 DEFMMETHOD(Backfill)
 310 {
 311         GETDATA;
 312
 313         {
 314                 APTR cliphandle = NULL;
 315                 struct Region *clipregion = NULL;
 316
 317                 if (msg->bottom < msg->top)
 318                         return 0;
 319                 if (msg->right < msg->left)
 320                         return 0;
 321
 322
 323                 if (muiRenderInfo(obj) != NULL && (data->width != _width(obj) || data->height != _height(obj) || (msg->right - msg->left + 1 == _mwidth(obj) && msg->bottom - msg->top + 1 == _mheight(obj)) ))
 324                 {
 325                         /*
 326                          * Iterate through thumbs and mask them from backfill.
 327                          */
 328
 329                         data->width = _width(obj);
 330                         data->height = _height(obj);
 331                         clipregion = buildregionfromicons(data, obj, msg->left, msg->top, msg->right, msg->bottom);
 332
 333                         if (clipregion != NULL)
 334                         {
 335                                 cliphandle = MUI_AddClipRegion(muiRenderInfo(obj), clipregion);
 336                         }
 337                 }
 338
 339                 /* draw */
 340
 341                 DOSUPER;
 342
 343                 if (clipregion != NULL)
 344                 {
 345                         MUI_RemoveClipRegion(muiRenderInfo(obj), cliphandle); /* DisposeRegion() is done by MUI */
 346                 }
 347         }
 348
 349         return (0);
 350 }
 351
 352 DEFSET
 353 {
 354         GETDATA;
 355
 356         FORTAG(INITTAGS)
 357         {
 358                 case MUIA_Lay_KeepPosition:
 359                         data->keeppos = tag->ti_Data;
 360                         break;
 361         }
 362         NEXTTAG
 363
 364         return DOSUPER;
 365 }
 366
 367 BEGINMTABLE
 368         DECMMETHOD(Backfill)
 369         DECSET
 370         DECNEW
 371 ENDMTABLE
 372
 373 DECSUBCLASS_NC(MUIC_Virtgroup, LayClass)