workbench/classes/gadgets/aroslistview/helpfuncs.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <proto/alib.h>
  10 #include <proto/dos.h>
  11 #include <proto/graphics.h>
  12 #include <proto/intuition.h>
  13 #include <proto/utility.h>
  14
  15 #include <dos/dos.h>
  16 #include <dos/rdargs.h>
  17 #include <string.h>
  18 #include <intuition/intuition.h>
  19 #include <intuition/gadgetclass.h>
  20 #include <gadgets/aroslist.h>
  21
  22 #include "aroslistview_intern.h"
  23
  24 //#define TURN_OFF_DEBUG
  25
  26 #ifndef TURN_OFF_DEBUG
  27 #define DEBUG 1
  28 #endif
  29
  30 #include <aros/debug.h>
  31
  32 STATIC VOID HandleSpecialMinWidth( struct ColumnAttrs           *colattrs,
  33                                    struct LVData                *data
  34 );
  35
  36 #define ForeachViewedCol(iterator, numcols) \
  37         for (iterator = 0; iterator < numcols; iterator ++)
  38
  39
  40 /**************************
  41 **  ParseFormatString()  **
  42 **************************/
  43 BOOL ParseFormatString( STRPTR                  formatstr,
  44                         struct LVData           *data
  45 )
  46 {
  47     #undef NUMPARAMS
  48     #define NUMPARAMS 5
  49     UBYTE templ[] = "COL=C/N,BAR=B/S,PREPARSE=P/K,DELTA=D/N,MINWIDTH=MIW/N";
  50
  51     struct RDArgs *rdarg;
  52     BOOL success = FALSE;
  53     struct ColumnAttrs *colattrs;
  54
  55     /* Give ReadArgs() som stack space to chew on so that time is not
  56      * wasted on memory allocations
  57      */
  58     #undef WORKBUFSIZE
  59     #define WORKBUFSIZE 500
  60     UBYTE workbuf[WORKBUFSIZE];
  61
  62     colattrs = data->lvd_ColAttrs;
  63
  64     rdarg = (struct RDArgs *)AllocDosObject(DOS_RDARGS, NULL);
  65     if (rdarg)
  66     {
  67         UWORD curcol = 0;
  68         BOOL morecolumns = TRUE;
  69
  70
  71         /* Reset the as-big-as-biggest-text property */
  72         data->lvd_Flags &= ~LVFLG_SPECIALCOLWIDTH;
  73
  74         do
  75         {
  76             UWORD len  = 0;
  77
  78             STRPTR str = formatstr;
  79             IPTR argsarray[NUMPARAMS];
  80             memset(argsarray, 0, UB(&argsarray[NUMPARAMS]) - UB(&argsarray[0]));
  81
  82             /* An example of format string is ",PREPARSE=c9, ," */
  83             while (*str && *str != ',')
  84             {
  85                 len ++;
  86                 str ++;
  87             }
  88             if (!*str)
  89                 morecolumns = FALSE;
  90
  91             /* Skip comma */
  92             str ++;
  93
  94             rdarg->RDA_Source.CS_Buffer = formatstr;
  95             rdarg->RDA_Source.CS_Length = len;
  96             rdarg->RDA_Source.CS_CurChr = 0;
  97             rdarg->RDA_Buffer = workbuf;
  98             rdarg->RDA_BufSiz = WORKBUFSIZE;
  99
 100             if (!ReadArgs(templ, argsarray, rdarg))
 101             {
 102                 FreeArgs(rdarg);
 103                 success = FALSE;
 104                 break;
 105             }
 106             else
 107             {
 108
 109                 /* Insert parsed info into colattr array */
 110                 /* A COL argument specified ? */
 111                 colattrs[curcol].ca_DHIndex = (UBYTE)((argsarray[0]) ? *((ULONG *)argsarray[0]) : curcol);
 112                 if (argsarray[1]) /* BAR */
 113                     colattrs[curcol].ca_Flags |= CAFLG_BAR;
 114                 if (argsarray[2]) /* PREPARSE */
 115                 {
 116                     /* Parse the preparse string */
 117                     str = (STRPTR)argsarray[2];
 118
 119                     while (*str)
 120                     {
 121                         if (*str == 'c') /* Centre align text */
 122                         {
 123                             colattrs[curcol].ca_Flags &= ~CA_ALIGN_MASK;
 124                             colattrs[curcol].ca_Flags |= CA_ALIGN_CENTRE;
 125                         }
 126                         else if (*str == 'l') /* Left align text */
 127                         {
 128                             colattrs[curcol].ca_Flags &= ~CA_ALIGN_MASK;
 129                             colattrs[curcol].ca_Flags |= CA_ALIGN_LEFT;
 130                         }
 131                         else if (*str == 'r') /* Right align text */
 132                         {
 133                             colattrs[curcol].ca_Flags &= ~CA_ALIGN_MASK;
 134                             colattrs[curcol].ca_Flags |= CA_ALIGN_RIGHT;
 135                         }
 136                         else if (*str >= '0' && *str <= 9) /* Text background pen */
 137                         {
 138                             colattrs[curcol].ca_Pen = *str - '0';;
 139                         }
 140                         str ++;
 141
 142                     }
 143                 }
 144
 145                 if (argsarray[3]) /* DELTA */
 146                     colattrs[curcol].ca_Delta = (UWORD)((ULONG *)argsarray)[3];
 147
 148                 if (argsarray[4]) /* MINWIDTH */
 149                 {
 150                     colattrs[curcol].ca_MinWidth = (UWORD)((ULONG *)argsarray)[4];
 151                     if (colattrs[curcol].ca_MinWidth == -1)
 152                     {
 153                         data->lvd_Flags |= LVFLG_SPECIALCOLWIDTH;
 154                         colattrs[curcol].ca_Flags |= CAFLG_SPECIALCOLWIDTH;
 155                     }
 156                 }
 157
 158                 curcol ++;
 159                 formatstr += len + 1;
 160             }
 161         }
 162         while (morecolumns);
 163
 164         data->lvd_ViewedColumns = curcol;
 165
 166         FreeDosObject(DOS_RDARGS, rdarg);
 167     }
 168
 169     return (success);
 170 }
 171
 172 /********************
 173 **  GetGadgetIBox  **
 174 ********************/
 175
 176 /* Figure out the size of the gadget rectangle, taking relative
 177  * positioning into account.
 178  */
 179 VOID GetGadgetIBox(Object *o, struct GadgetInfo *gi, struct IBox *ibox)
 180 {
 181     ibox->Left   = EG(o)->LeftEdge;
 182     ibox->Top    = EG(o)->TopEdge;
 183     ibox->Width  = EG(o)->Width;
 184     ibox->Height = EG(o)->Height;
 185
 186     if (gi)
 187     {
 188         if (EG(o)->Flags & GFLG_RELRIGHT)
 189             ibox->Left   += gi->gi_Domain.Width - 1;
 190
 191         if (EG(o)->Flags & GFLG_RELBOTTOM)
 192             ibox->Top    += gi->gi_Domain.Height - 1;
 193
 194         if (EG(o)->Flags & GFLG_RELWIDTH)
 195             ibox->Width  += gi->gi_Domain.Width;
 196
 197         if (EG(o)->Flags & GFLG_RELHEIGHT)
 198             ibox->Height += gi->gi_Domain.Height;
 199     }
 200 }
 201
 202 /**********************
 203 **  RenderEntries()  **
 204 **********************/
 205 VOID RenderEntries( Class                   *cl,
 206                     Object                  *o,
 207                     struct gpRender         *msg,
 208                     LONG                    startpos,
 209                     UWORD                   num,
 210                     BOOL                    erase
 211 )
 212 {
 213     struct AROSP_List_GetEntry getentry_msg, *p_getentry_msg = &getentry_msg;
 214     APTR item;
 215     struct IBox container;
 216     struct TextFont *oldfont;
 217     WORD top;
 218     LONG activepos;
 219     LONG pos;
 220
 221     struct LVData *data = INST_DATA(cl, o);
 222     UWORD *pens = msg->gpr_GInfo->gi_DrInfo->dri_Pens;
 223
 224     GetGadgetIBox(o, msg->gpr_GInfo, &container);
 225
 226     top = container.Top + LV_BORDERWIDTH_Y
 227                 + (startpos - data->lvd_First) * data->lvd_EntryHeight;
 228
 229     SetAPen(msg->gpr_RPort, pens[data->lvd_FrontPen]);
 230     SetDrMd(msg->gpr_RPort, JAM1);
 231
 232     oldfont = msg->gpr_RPort->Font;
 233     SetFont(msg->gpr_RPort, data->lvd_Font);
 234
 235     if (!(data->lvd_Flags & (LVFLG_READONLY|LVFLG_MULTISELECT)))
 236         GetAttr(AROSA_List_Active, data->lvd_List, (IPTR *)&activepos);
 237
 238     getentry_msg.MethodID  = AROSM_List_GetEntry;
 239     getentry_msg.ItemPtr   = &item;
 240
 241      /* Start rendering the listview entries */
 242     for (pos = startpos; num --; pos ++)
 243     {
 244
 245         register UWORD col;
 246         struct TextExtent te;
 247         struct ColumnAttrs *colattrs = data->lvd_ColAttrs;
 248
 249         BOOL erase_this_entry = erase;
 250         UWORD erasepen = data->lvd_BackPen;
 251
 252         if (!(data->lvd_Flags & LVFLG_READONLY))
 253         {
 254             if (data->lvd_Flags & LVFLG_MULTISELECT)
 255             {
 256                 LONG state;
 257                 DoMethod(data->lvd_List,
 258                         AROSM_List_Select,
 259                         pos,
 260                         AROSV_List_Select_Ask,
 261                         &state);
 262                 if (state)
 263                 {
 264                     erase_this_entry = TRUE;
 265                     erasepen = FILLPEN;
 266                 }
 267             }
 268             else
 269             {
 270                 if (pos == activepos)
 271                 {
 272                     erase_this_entry = TRUE;
 273                     erasepen = FILLPEN;
 274                 }
 275             }
 276         }
 277
 278         if (erase_this_entry)
 279         {
 280              /* Erase the old text line */
 281             SetAPen(msg->gpr_RPort, pens[erasepen]);
 282
 283             RectFill(msg->gpr_RPort,
 284                 container.Left + LV_BORDERWIDTH_X,
 285                 top,
 286                 container.Left + container.Width - LV_BORDERWIDTH_X - 1,
 287                 top + data->lvd_EntryHeight - 1);
 288
 289             SetAPen(msg->gpr_RPort, pens[data->lvd_FrontPen]);
 290
 291         }
 292
 293
 294         getentry_msg.Position = pos;
 295         DoMethodA(data->lvd_List, (Msg)p_getentry_msg);
 296         if (!item)
 297             break;
 298
 299         CallHookPkt( data->lvd_DisplayHook,
 300                      data->lvd_DHArray,
 301                      item);
 302
 303         ForeachViewedCol(col, data->lvd_ViewedColumns)
 304         {
 305             UWORD idx, len;
 306             WORD left;
 307
 308             /* Get the index into DisplayHookArray for getting text for this column */
 309             idx = colattrs[col].ca_DHIndex;
 310 D(bug("Render: idx=%d, col=%d\n", idx, col));
 311             /* How many characters of the string
 312              * returned by DispHook are we able to view ?
 313              */
 314             len = TextFit(msg->gpr_RPort,
 315                         data->lvd_DHArray[idx],
 316                         strlen(data->lvd_DHArray[idx]),
 317                         &te,
 318                         NULL,
 319                         1,
 320                         colattrs[col].ca_Width,
 321                         10000); /* We allready know that the height fit */
 322 D(bug("Textfit len: %d\n", len));
 323             /* Where do we place the len characters ? */
 324             switch (colattrs[col].ca_Flags & CA_ALIGN_MASK)
 325             {
 326             case CA_ALIGN_LEFT:
 327                 left = colattrs[col].ca_Left;
 328                 break;
 329
 330             case CA_ALIGN_RIGHT:
 331                 left = colattrs[col].ca_Right - te.te_Width;
 332                 break;
 333
 334             default:
 335                 left = colattrs[col].ca_Left + ((colattrs[col].ca_Width - te.te_Width) >> 1);
 336                 break;
 337             }
 338
 339 D(bug("Render: left=%d,idx=%d,text=%s\n", left, idx, data->lvd_DHArray[idx]));
 340
 341             Move(msg->gpr_RPort, left, top + data->lvd_Font->tf_Baseline);
 342             Text(msg->gpr_RPort, data->lvd_DHArray[idx], len);
 343
 344         } /* ForeachViewedCol */
 345
 346         top += data->lvd_EntryHeight;
 347
 348     } /* for (entries to view) */
 349     SetFont(msg->gpr_RPort, oldfont);
 350
 351     return;
 352 }
 353
 354
 355 /******************************
 356 **  HandleSpecialMinWidth()  **
 357 ******************************/
 358
 359 STATIC VOID HandleSpecialMinWidth( struct ColumnAttrs           *colattrs,
 360                                    struct LVData                *data
 361 )
 362 {
 363     register UWORD i;
 364     register LONG pos;
 365     APTR item;
 366     struct RastPort rp;
 367
 368     InitRastPort(&rp);
 369
 370     SetFont(&rp, data->lvd_Font);
 371
 372
 373     /* Initialize the minwidths to 0 */
 374     ForeachViewedCol(i, data->lvd_ViewedColumns)
 375         if (colattrs[i].ca_Flags & CAFLG_SPECIALCOLWIDTH)
 376             colattrs[i].ca_MinWidth = 0;
 377
 378     for (pos = 0; ; pos ++)
 379     {
 380         DoMethod(data->lvd_List, AROSM_List_GetEntry, pos, &item);
 381         if (!item)
 382             break;
 383
 384         /* Get the texts for a row in the list */
 385         CallHookPkt(data->lvd_DisplayHook,
 386                     data->lvd_DHArray,
 387                     item);
 388
 389         ForeachViewedCol(i, data->lvd_ViewedColumns)
 390         {
 391             UWORD idx = colattrs[i].ca_DHIndex;
 392
 393             if (colattrs[i].ca_Flags & CAFLG_SPECIALCOLWIDTH)
 394             {
 395                 UWORD length;
 396
 397                 length = TextLength(&rp,
 398                                     data->lvd_DHArray[idx],
 399                                     strlen(data->lvd_DHArray[idx]));
 400
 401                 if (length > colattrs[i].ca_MinWidth)
 402                      colattrs[i].ca_MinWidth = length;
 403
 404              } /* if (column should be viewed and width is as long as biggest textlength) */
 405
 406         } /* ForeachViewedCol() */
 407
 408     } /* for (iterate through list of items) */
 409
 410     return;
 411 }
 412
 413 /************************
 414 ** ComputeColumnWidts  **
 415 ************************/
 416
 417 VOID ComputeColumnWidths(UWORD                      listwidth,
 418                         struct LVData               *data
 419 )
 420 {
 421
 422     /* First handle columns that want their minwidth to be the
 423      * size of the largest entry in that column
 424      */
 425
 426     struct ColumnAttrs *colattrs = data->lvd_ColAttrs;
 427     UWORD sum_minwidths = 0;
 428     UWORD remainder;
 429     WORD on_each_col, pixels2divide;
 430     register UWORD i;
 431
 432     /* Find number of pixels to divide between columns */
 433     listwidth -=  LV_BORDERWIDTH_X * 2
 434                 + data->lvd_HorSpacing * (data->lvd_ViewedColumns + 1);
 435
 436     if (data->lvd_Flags & LVFLG_SPECIALCOLWIDTH)
 437         HandleSpecialMinWidth(colattrs, data);
 438
 439     /* Compute the sum of the minwidths and the number of columns to be  */
 440     ForeachViewedCol(i, data->lvd_ViewedColumns)
 441     {
 442         sum_minwidths += colattrs[i].ca_MinWidth;
 443     }
 444
 445
 446     /* Now we have three cases, 1) sum_minwidths > listwidth or
 447      * 2) sum_minwidths < listwidth or 3) sum_minwidths == listwidth.
 448      *
 449      * 1): Divide listwidth - sum_minwidths pixels among the columns
 450      *
 451      * 2): Take sum_minwidths - listwidth pixels away from the columns
 452      *
 453      * 3): Just use each column's minwidth as width for the column
 454      */
 455
 456     pixels2divide = listwidth - sum_minwidths;
 457
 458     /* Divide pixels equally among the columns */
 459
 460     on_each_col = pixels2divide / data->lvd_ViewedColumns;
 461     remainder = pixels2divide % data->lvd_ViewedColumns;
 462
 463     if (pixels2divide > 0)
 464     {
 465         ForeachViewedCol(i, data->lvd_ViewedColumns)
 466         {
 467             colattrs[i].ca_Width = colattrs[i].ca_MinWidth;
 468             colattrs[i].ca_Width += on_each_col;
 469
 470             if (remainder)
 471             {
 472                 colattrs[i].ca_Width ++;
 473                 remainder --;
 474             }
 475         }
 476     }
 477     else if (pixels2divide < 0)
 478     {
 479         ForeachViewedCol(i, data->lvd_ViewedColumns)
 480         {
 481             colattrs[i].ca_Width = colattrs[i].ca_MinWidth;
 482             colattrs[i].ca_Width += on_each_col;
 483
 484             if (remainder)
 485             {
 486                 colattrs[i].ca_Width --;
 487                 remainder --;
 488             }
 489         }
 490     }
 491     else /* pixels2divide == 0 */
 492     {
 493         ForeachViewedCol(i, data->lvd_ViewedColumns)
 494         {
 495             colattrs[i].ca_Width = colattrs[i].ca_MinWidth;
 496         }
 497     }
 498
 499     return;
 500 }
 501
 502 /**************************
 503 **  ComputeColLeftRight  **
 504 **************************/
 505
 506 VOID ComputeColLeftRight(UWORD gadleft, struct LVData *data)
 507 {
 508     struct ColumnAttrs *colattrs;
 509     register UWORD i;
 510     register UWORD left;
 511
 512     left = gadleft + LV_BORDERWIDTH_X;
 513     colattrs = data->lvd_ColAttrs;
 514
 515     ForeachViewedCol(i, data->lvd_ViewedColumns)
 516     {
 517         left += data->lvd_HorSpacing;
 518
 519         colattrs[i].ca_Left  = left;
 520         colattrs[i].ca_Right = (left += colattrs[i].ca_Width);
 521     }
 522     return;
 523 }
 524
 525
 526 /*********************
 527 **  DrawListBorder  **
 528 *********************/
 529
 530 VOID DrawListBorder( struct RastPort                *rp,
 531                             UWORD                   *pens,
 532                             struct IBox             *bbox,
 533                             BOOL                    recessed
 534 )
 535 {
 536     SetAPen (rp, pens[(recessed) ? SHINEPEN : SHADOWPEN]);
 537
 538     /* right */
 539     RectFill (rp
 540             , bbox->Left + bbox->Width  - LV_BORDERWIDTH_X
 541             , bbox->Top
 542             , bbox->Left + bbox->Width  - 1
 543             , bbox->Top  + bbox->Height - 1
 544         );
 545
 546                 /* bottom */
 547     RectFill (rp
 548             , bbox->Left
 549             , bbox->Top  + bbox->Height - LV_BORDERWIDTH_Y
 550             , bbox->Left + bbox->Width  - LV_BORDERWIDTH_X
 551             , bbox->Top  + bbox->Height - 1
 552         );
 553
 554     SetAPen (rp, pens[(recessed) ? SHADOWPEN : SHINEPEN]);
 555
 556     /* top */
 557     RectFill (rp
 558             , bbox->Left
 559             , bbox->Top
 560             , bbox->Left + bbox->Width - LV_BORDERWIDTH_X
 561             , bbox->Top + LV_BORDERWIDTH_Y - 1
 562         );
 563
 564     /* left */
 565     RectFill (rp
 566             , bbox->Left
 567             , bbox->Top
 568             , bbox->Left + LV_BORDERWIDTH_X - 1
 569             , bbox->Top + bbox->Height - LV_BORDERWIDTH_Y
 570         );
 571
 572     WritePixel (rp, bbox->Left + bbox->Width - 1, bbox->Top);
 573     WritePixel (rp, bbox->Left, bbox->Top + bbox->Height - 1);
 574
 575     return;
 576 }
 577
 578
 579 /*******************
 580 **  ShownEntries  **
 581 *******************/
 582 UWORD ShownEntries(struct LVData        *data,
 583                    struct IBox          *container
 584 )
 585
 586 {
 587     ULONG numentries;
 588     UWORD shown;
 589
 590     GetAttr(AROSA_List_Entries, data->lvd_List, (IPTR *)&numentries);
 591
 592     /* This formula has a little "bug": The height of the rendered texts
 593     ** are ibox.Height - height of 2 borders  - 1 horizontal spacing line, but
 594     ** since hor sp. always is < entryheight, the formula provides the right result
 595     */
 596
 597     shown = (container->Height - LV_BORDERWIDTH_Y * 2) / data->lvd_EntryHeight;
 598
 599     shown = MIN(shown, numentries - data->lvd_First);
 600
 601     return (shown);
 602 }
 603
 604 /******************
 605 **  NotifyAttrs  **
 606 ******************/
 607
 608 VOID NotifyAttrs(Class *cl, Object *o, struct opSet *msg, struct TagItem *tags)
 609 {
 610     struct TagItem idtags[] =
 611     {
 612         {GA_ID,                 (IPTR)EG(o)->GadgetID},
 613         {TAG_MORE,              (IPTR)tags}
 614     };
 615
 616     struct opUpdate nmsg =  {OM_NOTIFY, idtags, msg->ops_GInfo, 0}, *p_nmsg = &nmsg;
 617     struct LVData *data = INST_DATA(cl, o);
 618
 619     data->lvd_NotifyCount ++;
 620     DoSuperMethodA(cl, o,  (Msg)p_nmsg);
 621     data->lvd_NotifyCount --;
 622     return;
 623 }
 624