components/x11/libXaw4/src/Xaw3_1List.c

   1 #if ( !defined(lint) && !defined(SABER))
   2   static char Xrcs_id[] = "$XConsortium: List.c,v 1.26 89/12/11 15:08:31 kit Exp $";
   3 #endif
   4
   5 /*
   6  * Copyright 1989 Massachusetts Institute of Technology
   7  *
   8  * Permission to use, copy, modify, distribute, and sell this software and its
   9  * documentation for any purpose is hereby granted without fee, provided that
  10  * the above copyright notice appear in all copies and that both that
  11  * copyright notice and this permission notice appear in supporting
  12  * documentation, and that the name of M.I.T. not be used in advertising or
  13  * publicity pertaining to distribution of the software without specific,
  14  * written prior permission.  M.I.T. makes no representations about the
  15  * suitability of this software for any purpose.  It is provided "as is"
  16  * without express or implied warranty.
  17  *
  18  * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
  20  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  21  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  22  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  23  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24  *
  25  */
  26
  27 /*
  28  * List.c - List widget
  29  *
  30  * This is the List widget, it is useful to display a list, without the
  31  * overhead of having a widget for each item in the list.  It allows
  32  * the user to select an item in a list and notifies the application through
  33  * a callback function.
  34  *
  35  *      Created:        8/13/88
  36  *      By:             Chris D. Peterson
  37  *                      MIT X Consortium
  38  */
  39
  40 #include <stdio.h>
  41 #include <ctype.h>
  42
  43 #include <X11/IntrinsicP.h>
  44 #include <X11/StringDefs.h>
  45
  46 #include <X11/Xmu/Drawing.h>
  47
  48 #include <./Xaw3_1XawInit.h>
  49 #include <./Xaw3_1ListP.h>
  50
  51
  52 /*
  53  * Default Translation table.
  54  */
  55
  56 static char defaultTranslations[] =
  57   "<Btn1Down>:   Set()\n\
  58    <Btn1Up>:     Notify()";
  59
  60 /****************************************************************
  61  *
  62  * Full class record constant
  63  *
  64  ****************************************************************/
  65
  66 /* Private Data */
  67
  68 #define offset(field) XtOffset(ListWidget, field)
  69
  70 static XtResource resources[] = {
  71     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
  72         offset(list.foreground), XtRString, "XtDefaultForeground"},
  73     {XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
  74        offset(simple.cursor), XtRString, "left_ptr"},
  75     {XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
  76         offset(list.font),XtRString, "XtDefaultFont"},
  77     {XtNlist, XtCList, XtRPointer, sizeof(char **),
  78        offset(list.list), XtRString, NULL},
  79     {XtNdefaultColumns, XtCColumns, XtRInt,  sizeof(int),
  80         offset(list.default_cols), XtRImmediate, (caddr_t)2},
  81     {XtNlongest, XtCLongest, XtRInt,  sizeof(int),
  82         offset(list.longest), XtRImmediate, (caddr_t)0},
  83     {XtNnumberStrings, XtCNumberStrings, XtRInt,  sizeof(int),
  84         offset(list.nitems), XtRImmediate, (caddr_t)0},
  85     {XtNpasteBuffer, XtCBoolean, XtRBoolean,  sizeof(Boolean),
  86         offset(list.paste), XtRString, (caddr_t) "False"},
  87     {XtNforceColumns, XtCColumns, XtRBoolean,  sizeof(Boolean),
  88         offset(list.force_cols), XtRString, (caddr_t) "False"},
  89     {XtNverticalList, XtCBoolean, XtRBoolean,  sizeof(Boolean),
  90         offset(list.vertical_cols), XtRString, (caddr_t) "False"},
  91     {XtNinternalWidth, XtCWidth, XtRDimension,  sizeof(Dimension),
  92         offset(list.internal_width), XtRImmediate, (caddr_t)4},
  93     {XtNinternalHeight, XtCHeight, XtRDimension, sizeof(Dimension),
  94         offset(list.internal_height), XtRImmediate, (caddr_t)2},
  95     {XtNcolumnSpacing, XtCSpacing, XtRDimension,  sizeof(Dimension),
  96         offset(list.column_space), XtRImmediate, (caddr_t)6},
  97     {XtNrowSpacing, XtCSpacing, XtRDimension,  sizeof(Dimension),
  98         offset(list.row_space), XtRImmediate, (caddr_t)2},
  99     {XtNcallback, XtCCallback, XtRCallback, sizeof(caddr_t),
 100         offset(list.callback), XtRCallback, NULL},
 101 };
 102
 103 static void Initialize();
 104 static void ChangeSize();
 105 static void Resize();
 106 static void Redisplay();
 107 static Boolean Layout();
 108 static XtGeometryResult PreferredGeom();
 109 static Boolean SetValues();
 110 static void Notify(), Set(), Unset();
 111
 112 static XtActionsRec actions[] = {
 113       {"Notify",         Notify},
 114       {"Set",            Set},
 115       {"Unset",          Unset},
 116       {NULL,NULL}
 117 };
 118
 119 ListClassRec listClassRec = {
 120   {
 121 /* core_class fields */
 122 #define superclass              (&simpleClassRec)
 123     /* superclass               */      (WidgetClass) superclass,
 124     /* class_name               */      "List",
 125     /* widget_size              */      sizeof(ListRec),
 126     /* class_initialize         */      XawInitializeWidgetSet,
 127     /* class_part_initialize    */      NULL,
 128     /* class_inited             */      FALSE,
 129     /* initialize               */      Initialize,
 130     /* initialize_hook          */      NULL,
 131     /* realize                  */      XtInheritRealize,
 132     /* actions                  */      actions,
 133     /* num_actions              */      XtNumber(actions),
 134     /* resources                */      resources,
 135     /* num_resources            */      XtNumber(resources),
 136     /* xrm_class                */      NULLQUARK,
 137     /* compress_motion          */      TRUE,
 138     /* compress_exposure        */      FALSE,
 139     /* compress_enterleave      */      TRUE,
 140     /* visible_interest         */      FALSE,
 141     /* destroy                  */      NULL,
 142     /* resize                   */      Resize,
 143     /* expose                   */      Redisplay,
 144     /* set_values               */      SetValues,
 145     /* set_values_hook          */      NULL,
 146     /* set_values_almost        */      XtInheritSetValuesAlmost,
 147     /* get_values_hook          */      NULL,
 148     /* accept_focus             */      NULL,
 149     /* version                  */      XtVersion,
 150     /* callback_private         */      NULL,
 151     /* tm_table                 */      defaultTranslations,
 152    /* query_geometry            */      PreferredGeom,
 153   },
 154 /* Simple class fields initialization */
 155   {
 156     /* change_sensitive         */      XtInheritChangeSensitive
 157   }
 158 };
 159
 160 WidgetClass listWidgetClass = (WidgetClass)&listClassRec;
 161
 162 /****************************************************************
 163  *
 164  * Private Procedures
 165  *
 166  ****************************************************************/
 167
 168 static void GetGCs(w)
 169 Widget w;
 170 {
 171     XGCValues   values;
 172     ListWidget lw = (ListWidget) w;
 173
 174     values.foreground   = lw->list.foreground;
 175     values.font         = lw->list.font->fid;
 176     lw->list.normgc = XtGetGC(w, (unsigned) GCForeground | GCFont,
 177                                  &values);
 178
 179     values.foreground   = lw->core.background_pixel;
 180     lw->list.revgc = XtGetGC(w, (unsigned) GCForeground | GCFont,
 181                                  &values);
 182
 183     values.tile       = XmuCreateStippledPixmap(XtScreen(w),
 184                                                 lw->list.foreground,
 185                                                 lw->core.background_pixel,
 186                                                 lw->core.depth);
 187     values.fill_style = FillTiled;
 188
 189     lw->list.graygc = XtGetGC(w, (unsigned) GCFont | GCTile | GCFillStyle,
 190                               &values);
 191 }
 192
 193 /*      Function Name: ResetList
 194  *      Description: Resets the new list when important things change.
 195  *      Arguments: w - the widget.
 196  *                 changex, changey - allow the height or width to change?
 197  *      Returns: none.
 198  */
 199
 200 static void
 201 ResetList(w, changex, changey)
 202 Widget w;
 203 Boolean changex, changey;
 204 {
 205     ListWidget lw = (ListWidget) w;
 206     Dimension width = w->core.width;
 207     Dimension height = w->core.height;
 208     register int i, len;
 209
 210 /*
 211  * If list is NULL then the list will just be the name of the widget.
 212  */
 213
 214     if (lw->list.list == NULL) {
 215       lw->list.list = &(lw->core.name);
 216       lw->list.nitems = 1;
 217     }
 218
 219     if (lw->list.nitems == 0)       /* Get number of items. */
 220         for ( ; lw->list.list[lw->list.nitems] != NULL ; lw->list.nitems++);
 221
 222     if (lw->list.longest == 0) /* Get column width. */
 223         for ( i = 0 ; i < lw->list.nitems; i++) {
 224             len = XTextWidth(lw->list.font, lw->list.list[i],
 225                              strlen(lw->list.list[i]));
 226             if (len > lw->list.longest)
 227                 lw->list.longest = len;
 228         }
 229
 230     lw->list.col_width = lw->list.longest + lw->list.column_space;
 231
 232     if (Layout(w, changex, changey, &width, &height))
 233       ChangeSize(w, width, height);
 234 }
 235
 236 /*      Function Name: ChangeSize.
 237  *      Description: Laysout the widget.
 238  *      Arguments: w - the widget to try change the size of.
 239  *      Returns: none.
 240  */
 241
 242 static void
 243 ChangeSize(w, width, height)
 244 Widget w;
 245 Dimension width, height;
 246 {
 247     XtWidgetGeometry request, reply;
 248
 249     request.request_mode = CWWidth | CWHeight;
 250     request.width = width;
 251     request.height = height;
 252
 253     switch ( XtMakeGeometryRequest(w, &request, &reply) ) {
 254     case XtGeometryYes:
 255     case XtGeometryNo:
 256         break;
 257     case XtGeometryAlmost:
 258         Layout(w, (request.height != reply.height),
 259                   (request.width != reply.width),
 260                &(reply.width), &(reply.height));
 261         request = reply;
 262         switch (XtMakeGeometryRequest(w, &request, &reply) ) {
 263         case XtGeometryYes:
 264         case XtGeometryNo:
 265             break;
 266         case XtGeometryAlmost:
 267             request = reply;
 268             if (Layout(w, FALSE, FALSE,
 269                        &(request.width), &(request.height))) {
 270               char buf[BUFSIZ];
 271               sprintf(buf, "List Widget: %s %s",
 272                       "Size Changed when it shouldn't have",
 273                       "when computing layout");
 274               XtAppWarning(XtWidgetToApplicationContext(w), buf);
 275             }
 276             request.request_mode = CWWidth | CWHeight;
 277             XtMakeGeometryRequest(w, &request, &reply);
 278             break;
 279         default:
 280           XtAppWarning(XtWidgetToApplicationContext(w),
 281                        "List Widget: Unknown geometry return.");
 282           break;
 283         }
 284         break;
 285     default:
 286         XtAppWarning(XtWidgetToApplicationContext(w),
 287                      "List Widget: Unknown geometry return.");
 288         break;
 289     }
 290 }
 291
 292 /*      Function Name: Initialize
 293  *      Description: Function that initilizes the widget instance.
 294  *      Arguments: junk - NOT USED.
 295  *                 new  - the new widget.
 296  *      Returns: none
 297  */
 298
 299 /* ARGSUSED */
 300 static void
 301 Initialize(junk, new)
 302 Widget junk, new;
 303 {
 304     ListWidget lw = (ListWidget) new;
 305
 306 /*
 307  * Initialize all private resources.
 308  */
 309
 310     GetGCs(new);
 311
 312     /* Set row height. */
 313     lw->list.row_height = lw->list.font->max_bounds.ascent
 314                         + lw->list.font->max_bounds.descent
 315                         + lw->list.row_space;
 316
 317     ResetList(new, (new->core.width == 0), (new->core.height == 0));
 318
 319     lw->list.highlight = lw->list.is_highlighted = NO_HIGHLIGHT;
 320
 321 } /* Initialize */
 322
 323 /*      Function Name: CvtToItem
 324  *      Description: Converts Xcoord to item number of item containing that
 325  *                   point.
 326  *      Arguments: w - the list widget.
 327  *                 xloc, yloc - x location, and y location.
 328  *      Returns: the item number.
 329  */
 330
 331 static int
 332 CvtToItem(w, xloc, yloc, item)
 333 Widget w;
 334 int xloc, yloc;
 335 int *item;
 336 {
 337     int one, another;
 338     ListWidget lw = (ListWidget) w;
 339     int ret_val = OKAY;
 340
 341     if (lw->list.vertical_cols) {
 342         one = lw->list.nrows * ((xloc - (int) lw->list.internal_width)
 343             / lw->list.col_width);
 344         another = (yloc - (int) lw->list.internal_height)
 345                 / lw->list.row_height;
 346          /* If out of range, return minimum possible value. */
 347         if (another >= lw->list.nrows) {
 348             another = lw->list.nrows - 1;
 349             ret_val = OUT_OF_RANGE;
 350         }
 351     }
 352     else {
 353         one = (lw->list.ncols * ((yloc - (int) lw->list.internal_height)
 354               / lw->list.row_height)) ;
 355         /* If in right margin handle things right. */
 356         another = (xloc - (int) lw->list.internal_width) / lw->list.col_width;
 357         if (another >= lw->list.ncols) {
 358             another = lw->list.ncols - 1;
 359             ret_val = OUT_OF_RANGE;
 360         }
 361     }
 362     if ((xloc < 0) || (yloc < 0))
 363         ret_val = OUT_OF_RANGE;
 364     if (one < 0) one = 0;
 365     if (another < 0) another = 0;
 366     *item = one + another;
 367     if (*item >= lw->list.nitems) return(OUT_OF_RANGE);
 368     return(ret_val);
 369 }
 370
 371 /*      Function Name: FindCornerItems.
 372  *      Description: Find the corners of the rectangle in item space.
 373  *      Arguments: w - the list widget.
 374  *                 event - the event structure that has the rectangle it it.
 375  *                 ul_ret, lr_ret - the corners ** RETURNED **.
 376  *      Returns: none.
 377  */
 378
 379 FindCornerItems(w, event, ul_ret, lr_ret)
 380 Widget w;
 381 XEvent * event;
 382 int *ul_ret, *lr_ret;
 383 {
 384     int xloc, yloc;
 385
 386     xloc = event->xexpose.x;
 387     yloc = event->xexpose.y;
 388     CvtToItem(w, xloc, yloc, ul_ret);
 389     xloc += event->xexpose.width;
 390     yloc += event->xexpose.height;
 391     CvtToItem(w, xloc, yloc, lr_ret);
 392 }
 393
 394 /*      Function Name: ItemInRectangle
 395  *      Description: returns TRUE if the item passed is in the given rectangle.
 396  *      Arguments: w - the list widget.
 397  *                 ul, lr - corners of the rectangle in item space.
 398  *                 item - item to check.
 399  *      Returns: TRUE if the item passed is in the given rectangle.
 400  */
 401
 402 ItemInRectangle(w, ul, lr, item)
 403 Widget w;
 404 int ul, lr, item;
 405 {
 406     ListWidget lw = (ListWidget) w;
 407     register int mod_item;
 408     int things;
 409
 410     if (item < ul || item > lr)
 411         return(FALSE);
 412     if (lw->list.vertical_cols)
 413         things = lw->list.nrows;
 414     else
 415         things = lw->list.ncols;
 416
 417     mod_item = item % things;
 418     if ( (mod_item >= ul % things) && (mod_item <= lr % things ) )
 419         return(TRUE);
 420     return(FALSE);
 421 }
 422
 423 /*      Function Name: HighlightBackground
 424  *      Description: paints the color of the background for the given item.
 425  *      Arguments: w - the widget.
 426  *                 x, y - ul corner of the area item occupies.
 427  *                 item - the item we are dealing with.
 428  *                 gc - the gc that is used to paint this rectangle
 429  *      Returns:
 430  */
 431
 432 HighlightBackground(w, x, y, item, gc)
 433 Widget w;
 434 int x, y, item;
 435 GC gc;
 436 {
 437     ListWidget lw = (ListWidget) w;
 438     int hl_x, hl_y, width, height;
 439
 440     hl_x = x - lw->list.column_space/2;
 441     width = XTextWidth(lw->list.font, lw->list.list[item],
 442                          strlen(lw->list.list[item])) + lw->list.column_space;
 443     hl_y = y - lw->list.row_space/2;
 444     height = lw->list.row_height + lw->list.row_space;
 445
 446     XFillRectangle(XtDisplay(w), XtWindow(w), gc, hl_x, hl_y, width, height);
 447 }
 448
 449 /*      Function Name: PaintItemName
 450  *      Description: paints the name of the item in the appropriate location.
 451  *      Arguments: w - the list widget.
 452  *                 item - the item to draw.
 453  *      Returns: none.
 454  *
 455  *      NOTE: no action taken on an unrealized widget.
 456  */
 457
 458 PaintItemName(w, item)
 459 Widget w;
 460 int item;
 461 {
 462     char * str;
 463     GC gc;
 464     int x, y, str_y;
 465     ListWidget lw = (ListWidget) w;
 466
 467     if (!XtIsRealized(w)) return; /* Just in case... */
 468
 469     if (lw->list.vertical_cols) {
 470         x = lw->list.col_width * (item / lw->list.nrows)
 471           + lw->list.internal_width;
 472         y = lw->list.row_height * (item % lw->list.nrows)
 473           + lw->list.internal_height;
 474     }
 475     else {
 476         x = lw->list.col_width * (item % lw->list.ncols)
 477           + lw->list.internal_width;
 478         y = lw->list.row_height * (item / lw->list.ncols)
 479           + lw->list.internal_height;
 480     }
 481
 482     str_y = y + lw->list.font->max_bounds.ascent;
 483
 484     if (item == lw->list.is_highlighted) {
 485         if (item == lw->list.highlight) {
 486             gc = lw->list.revgc;
 487             HighlightBackground(w, x, y, item, lw->list.normgc);
 488         }
 489         else {
 490             if (XtIsSensitive(w))
 491                 gc = lw->list.normgc;
 492             else
 493                 gc = lw->list.graygc;
 494             HighlightBackground(w, x, y, item, lw->list.revgc);
 495             lw->list.is_highlighted = NO_HIGHLIGHT;
 496         }
 497     }
 498     else {
 499         if (item == lw->list.highlight) {
 500             gc = lw->list.revgc;
 501             HighlightBackground(w, x, y, item, lw->list.normgc);
 502             lw->list.is_highlighted = item;
 503         }
 504         else {
 505             if (XtIsSensitive(w))
 506                 gc = lw->list.normgc;
 507             else
 508                 gc = lw->list.graygc;
 509         }
 510     }
 511
 512     str =  lw->list.list[item]; /* draw it */
 513     XDrawString(XtDisplay(w), XtWindow(w), gc, x, str_y, str, strlen(str));
 514 }
 515
 516 /*      Function Name: Redisplay
 517  *      Description: Repaints the widget window on expose events.
 518  *      Arguments: w - the list widget.
 519  *                 event - the expose event for this repaint.
 520  *                 junk - NOT USED.
 521  *      Returns:
 522  */
 523
 524 /* ARGSUSED */
 525 static void
 526 Redisplay(w, event, junk)
 527 Widget w;
 528 XEvent *event;
 529 Region junk;
 530 {
 531     int item;                   /* an item to work with. */
 532     int ul_item, lr_item;       /* corners of items we need to paint. */
 533     ListWidget lw = (ListWidget) w;
 534
 535     if (event == NULL) {        /* repaint all. */
 536         ul_item = 0;
 537         lr_item = lw->list.nrows * lw->list.ncols - 1;
 538         XClearWindow(XtDisplay(w), XtWindow(w));
 539     }
 540     else
 541         FindCornerItems(w, event, &ul_item, &lr_item);
 542
 543     for (item = ul_item; (item <= lr_item && item < lw->list.nitems) ; item++)
 544       if (ItemInRectangle(w, ul_item, lr_item, item))
 545         PaintItemName(w, item);
 546 }
 547
 548 /*      Function Name: PreferredGeom
 549  *      Description: This tells the parent what size we would like to be
 550  *                   given certain constraints.
 551  *      Arguments: w - the widget.
 552  *                 intended - what the parent intends to do with us.
 553  *                 requested - what we want to happen.
 554  *      Returns: none.
 555  */
 556
 557 static XtGeometryResult
 558 PreferredGeom(w, intended, requested)
 559 Widget w;
 560 XtWidgetGeometry *intended, *requested;
 561 {
 562     Dimension new_width, new_height;
 563     Boolean change, width_req, height_req;
 564
 565     width_req = intended->request_mode & CWWidth;
 566     height_req = intended->request_mode & CWHeight;
 567
 568     if (width_req)
 569       new_width = intended->width;
 570     else
 571       new_width = w->core.width;
 572
 573     if (height_req)
 574       new_height = intended->height;
 575     else
 576       new_height = w->core.height;
 577
 578     requested->request_mode = 0;
 579
 580 /*
 581  * We only care about our height and width.
 582  */
 583
 584     if ( !width_req && !height_req)
 585       return(XtGeometryYes);
 586
 587     change = Layout(w, !width_req, !height_req, &new_width, &new_height);
 588
 589     requested->request_mode |= CWWidth;
 590     requested->width = new_width;
 591     requested->request_mode |= CWHeight;
 592     requested->height = new_height;
 593
 594     if (change)
 595         return(XtGeometryAlmost);
 596     return(XtGeometryYes);
 597 }
 598
 599 /*      Function Name: Resize
 600  *      Description: resizes the widget, by changing the number of rows and
 601  *                   columns.
 602  *      Arguments: w - the widget.
 603  *      Returns: none.
 604  */
 605
 606 static void
 607 Resize(w)
 608 Widget w;
 609 {
 610   Dimension width, height;
 611
 612   width = w->core.width;
 613   height = w->core.height;
 614
 615   if (Layout(w, FALSE, FALSE, &width, &height))
 616     XtAppWarning(XtWidgetToApplicationContext(w),
 617             "List Widget: Size changed when it shouldn't have when resising.");
 618 }
 619
 620 /*      Function Name: Layout
 621  *      Description: lays out the item in the list.
 622  *      Arguments: w - the widget.
 623  *                 xfree, yfree - TRUE if we are free to resize the widget in
 624  *                                this direction.
 625  *                 width, height - the is the current width and height that
 626  *                                 we are going to layout the list widget to,
 627  *                                 depending on xfree and yfree of course.
 628  *
 629  *      Returns: TRUE if width or height have been changed.
 630  */
 631
 632 static Boolean
 633 Layout(w, xfree, yfree, width, height)
 634 Widget w;
 635 Boolean xfree, yfree;
 636 Dimension *width, *height;
 637 {
 638     ListWidget lw = (ListWidget) w;
 639     Boolean change = FALSE;
 640
 641 /*
 642  * If force columns is set then always use number of columns specified
 643  * by default_cols.
 644  */
 645
 646     if (lw->list.force_cols) {
 647         lw->list.ncols = lw->list.default_cols;
 648         if (lw->list.ncols <= 0) lw->list.ncols = 1;
 649         /* 12/3 = 4 and 10/3 = 4, but 9/3 = 3 */
 650         lw->list.nrows = ( ( lw->list.nitems - 1) / lw->list.ncols) + 1 ;
 651         if (xfree) {            /* If allowed resize width. */
 652             *width = lw->list.ncols * lw->list.col_width
 653                    + 2 * lw->list.internal_width;
 654             change = TRUE;
 655         }
 656         if (yfree) {            /* If allowed resize height. */
 657             *height = (lw->list.nrows * lw->list.row_height)
 658                     + 2 * lw->list.internal_height;
 659             change = TRUE;
 660         }
 661         return(change);
 662     }
 663
 664 /*
 665  * If both width and height are free to change the use default_cols
 666  * to determine the number columns and set new width and height to
 667  * just fit the window.
 668  */
 669
 670     if (xfree && yfree) {
 671         lw->list.ncols = lw->list.default_cols;
 672         if (lw->list.ncols <= 0) lw->list.ncols = 1;
 673         lw->list.nrows = ( ( lw->list.nitems - 1) / lw->list.ncols) + 1 ;
 674         *width = lw->list.ncols * lw->list.col_width
 675                + 2 * lw->list.internal_width;
 676         *height = (lw->list.nrows * lw->list.row_height)
 677                 + 2 * lw->list.internal_height;
 678         change = TRUE;
 679     }
 680 /*
 681  * If the width is fixed then use it to determine the number of columns.
 682  * If the height is free to move (width still fixed) then resize the height
 683  * of the widget to fit the current list exactly.
 684  */
 685     else if (!xfree) {
 686         lw->list.ncols = ( (*width - 2 * lw->list.internal_width)
 687                             / lw->list.col_width);
 688         if (lw->list.ncols <= 0) lw->list.ncols = 1;
 689         lw->list.nrows = ( ( lw->list.nitems - 1) / lw->list.ncols) + 1 ;
 690         if ( yfree ) {
 691             *height = (lw->list.nrows * lw->list.row_height)
 692                     + 2 * lw->list.internal_height;
 693             change = TRUE;
 694         }
 695     }
 696 /*
 697  * The last case is xfree and !yfree we use the height to determine
 698  * the number of rows and then set the width to just fit the resulting
 699  * number of columns.
 700  */
 701     else if (!yfree) {          /* xfree must be TRUE. */
 702         lw->list.nrows = (*height - 2 * lw->list.internal_height)
 703                        / lw->list.row_height;
 704         if (lw->list.nrows <= 0) lw->list.nrows = 1;
 705         lw->list.ncols = (( lw->list.nitems - 1 ) / lw->list.nrows) + 1;
 706         *width = lw->list.ncols * lw->list.col_width
 707                + 2 * lw->list.internal_width;
 708         change = TRUE;
 709     }
 710     return(change);
 711 }
 712
 713 /*      Function Name: Notify
 714  *      Description: Notifies the user that a button has been pressed, and
 715  *                   calles the callback, if the XtNpasteBuffer resource
 716  *                   is true then the name of the item is also put in the
 717  *                   X cut buffer ( buf (0) ).
 718  *      Arguments: w - the widget that the notify occured in.
 719  *                 event - event that caused this notification.
 720  *                 params, num_params - not used.
 721  *      Returns: none.
 722  */
 723
 724 /* ARGSUSED */
 725 static void
 726 Notify(w, event, params, num_params)
 727 Widget w;
 728 XEvent * event;
 729 String * params;
 730 Cardinal *num_params;
 731 {
 732     ListWidget lw = ( ListWidget ) w;
 733     int item, item_len;
 734     XawListReturnStruct ret_value;
 735
 736 /*
 737  * Find item and if out of range then unhighlight and return.
 738  *
 739  * If the current item is unhighlighted then the user has aborted the
 740  * notify, so unhighlight and return.
 741  */
 742
 743     if ( ((CvtToItem(w, event->xbutton.x, event->xbutton.y, &item))
 744           == OUT_OF_RANGE) || (lw->list.highlight != item) ) {
 745         XawListUnhighlight(w);
 746         return;
 747     }
 748
 749     item_len = strlen(lw->list.list[item]);
 750
 751     if ( lw->list.paste )       /* if XtNpasteBuffer set then paste it. */
 752         XStoreBytes(XtDisplay(w), lw->list.list[item], item_len);
 753
 754 /*
 755  * Call Callback function.
 756  */
 757
 758     ret_value.string = lw->list.list[item];
 759     ret_value.list_index = item;
 760
 761     XtCallCallbacks( w, XtNcallback, (caddr_t) &ret_value);
 762 }
 763
 764 /*      Function Name: Unset
 765  *      Description: unhighlights the current element.
 766  *      Arguments: w - the widget that the event occured in.
 767  *                 event - not used.
 768  *                 params, num_params - not used.
 769  *      Returns: none.
 770  */
 771
 772 /* ARGSUSED */
 773 static void
 774 Unset(w, event, params, num_params)
 775 Widget w;
 776 XEvent * event;
 777 String * params;
 778 Cardinal *num_params;
 779 {
 780   XawListUnhighlight(w);
 781 }
 782
 783 /*      Function Name: Set
 784  *      Description: Highlights the current element.
 785  *      Arguments: w - the widget that the event occured in.
 786  *                 event - event that caused this notification.
 787  *                 params, num_params - not used.
 788  *      Returns: none.
 789  */
 790
 791 /* ARGSUSED */
 792 static void
 793 Set(w, event, params, num_params)
 794 Widget w;
 795 XEvent * event;
 796 String * params;
 797 Cardinal *num_params;
 798 {
 799   int item;
 800   ListWidget lw = (ListWidget) w;
 801
 802   if ( (CvtToItem(w, event->xbutton.x, event->xbutton.y, &item))
 803       == OUT_OF_RANGE)
 804     XawListUnhighlight(w);                      /* Unhighlight current item. */
 805   else if ( lw->list.is_highlighted != item )   /* If this item is not */
 806     XawListHighlight(w, item);                  /* highlighted then do it. */
 807 }
 808
 809 /*
 810  * Set specified arguments into widget
 811  */
 812
 813 static Boolean
 814 SetValues(current, request, new)
 815 Widget current, request, new;
 816 {
 817     ListWidget cl = (ListWidget) current;
 818     ListWidget rl = (ListWidget) request;
 819     ListWidget nl = (ListWidget) new;
 820     Boolean redraw = FALSE;
 821
 822     if ((cl->list.foreground != rl->list.foreground) ||
 823         (cl->core.background_pixel != rl->core.background_pixel) ||
 824         (cl->list.font != rl->list.font) ) {
 825         XtDestroyGC(cl->list.normgc);
 826         XtDestroyGC(cl->list.graygc);
 827         XtDestroyGC(cl->list.revgc);
 828         GetGCs(new);
 829         redraw = TRUE;
 830     }
 831
 832     /* Reset row height. */
 833
 834     if ((cl->list.row_space != rl->list.row_space) ||
 835         (cl->list.font != rl->list.font))
 836         nl->list.row_height = nl->list.font->max_bounds.ascent
 837                             + nl->list.font->max_bounds.descent
 838                             + nl->list.row_space;
 839
 840     if ((cl->core.width != rl->core.width)                     ||
 841         (cl->core.height != rl->core.height)                   ||
 842         (cl->list.internal_width != rl->list.internal_width)   ||
 843         (cl->list.internal_height != rl->list.internal_height) ||
 844         (cl->list.column_space != rl->list.column_space)       ||
 845         (cl->list.row_space != rl->list.row_space)             ||
 846         (cl->list.default_cols != rl->list.default_cols)       ||
 847         (  (cl->list.force_cols != rl->list.force_cols) &&
 848            (rl->list.force_cols != rl->list.ncols) )           ||
 849         (cl->list.vertical_cols != rl->list.vertical_cols)     ||
 850         (cl->list.longest != rl->list.longest)                 ||
 851         (cl->list.nitems != rl->list.nitems)                   ||
 852         (cl->list.font != rl->list.font)                       ||
 853         (cl->list.list != rl->list.list)                        ) {
 854
 855       ResetList(new, TRUE, TRUE);
 856       redraw = TRUE;
 857     }
 858
 859     if (cl->list.list != rl->list.list)
 860       nl->list.highlight = NO_HIGHLIGHT;
 861
 862     if ((cl->core.sensitive != rl->core.sensitive) ||
 863         (cl->core.ancestor_sensitive != rl->core.ancestor_sensitive)) {
 864         nl->list.highlight = NO_HIGHLIGHT;
 865         redraw = TRUE;
 866     }
 867
 868     if (!XtIsRealized(current))
 869       return(FALSE);
 870
 871     return(redraw);
 872 }
 873
 874 /* Exported Functions */
 875
 876 /*      Function Name: XawListChange.
 877  *      Description: Changes the list being used and shown.
 878  *      Arguments: w - the list widget.
 879  *                 list - the new list.
 880  *                 nitems - the number of items in the list.
 881  *                 longest - the length (in Pixels) of the longest element
 882  *                           in the list.
 883  *                 resize - if TRUE the the list widget will
 884  *                          try to resize itself.
 885  *      Returns: none.
 886  *      NOTE:      If nitems of longest are <= 0 then they will be calculated.
 887  *                 If nitems is <= 0 then the list needs to be NULL terminated.
 888  */
 889
 890 void
 891 XawListChange(w, list, nitems, longest, resize_it)
 892 Widget w;
 893 char ** list;
 894 int nitems, longest;
 895 Boolean resize_it;
 896 {
 897     ListWidget lw = (ListWidget) w;
 898
 899     lw->list.list = list;
 900
 901     if (nitems <= 0) nitems = 0;
 902     lw->list.nitems = nitems;
 903     if (longest <= 0) longest = 0;
 904     lw->list.longest = longest;
 905
 906     ResetList(w, resize_it, resize_it);
 907     lw->list.is_highlighted = lw->list.highlight = NO_HIGHLIGHT;
 908     if ( XtIsRealized(w) )
 909       Redisplay(w, NULL, NULL);
 910 }
 911
 912 /*      Function Name: XawListUnhighlight
 913  *      Description: unlights the current highlighted element.
 914  *      Arguments: w - the widget.
 915  *      Returns: none.
 916  */
 917
 918 void
 919 XawListUnhighlight(w)
 920 Widget w;
 921 {
 922     ListWidget lw = ( ListWidget ) w;
 923
 924     lw->list.highlight = NO_HIGHLIGHT;
 925     if (lw->list.is_highlighted != NO_HIGHLIGHT)
 926         PaintItemName(w, lw->list.is_highlighted); /* unhighlight this one. */
 927 }
 928
 929 /*      Function Name: XawListHighlight
 930  *      Description: Highlights the given item.
 931  *      Arguments: w - the list widget.
 932  *                 item - the item to hightlight.
 933  *      Returns: none.
 934  */
 935
 936 void
 937 XawListHighlight(w, item)
 938 Widget w;
 939 int item;
 940 {
 941     ListWidget lw = ( ListWidget ) w;
 942
 943     if (XtIsSensitive(w)) {
 944         lw->list.highlight = item;
 945         if (lw->list.is_highlighted != NO_HIGHLIGHT)
 946             PaintItemName(w, lw->list.is_highlighted);  /* Unhighlight. */
 947         PaintItemName(w, item); /* HIGHLIGHT this one. */
 948     }
 949 }
 950
 951 /*      Function Name: XawListShowCurrent
 952  *      Description: returns the currently highlighted object.
 953  *      Arguments: w - the list widget.
 954  *      Returns: the info about the currently highlighted object.
 955  */
 956
 957 XawListReturnStruct *
 958 XawListShowCurrent(w)
 959 Widget w;
 960 {
 961     ListWidget lw = ( ListWidget ) w;
 962     XawListReturnStruct * ret_val;
 963
 964     ret_val = (XawListReturnStruct *) XtMalloc (sizeof (XawListReturnStruct));
 965
 966     ret_val->list_index = lw->list.highlight;
 967     if (ret_val->list_index == XAW_LIST_NONE)
 968       ret_val->string = "";
 969     else
 970       ret_val->string = lw->list.list[ ret_val->list_index ];
 971
 972     return(ret_val);
 973 }
 974