Xw/Primitive.c

   1 /*************************************<+>*************************************
   2  *****************************************************************************
   3  **
   4  **   File:        Primitive.c
   5  **
   6  **   Project:     X Widgets
   7  **
   8  **   Description: This file contains source for the Primitive Meta Widget.
   9  **
  10  *****************************************************************************
  11  **
  12  **   Copyright (c) 1988 by Hewlett-Packard Company
  13  **   Copyright (c) 1988 by the Massachusetts Institute of Technology
  14  **
  15  **   Permission to use, copy, modify, and distribute this software
  16  **   and its documentation for any purpose and without fee is hereby
  17  **   granted, provided that the above copyright notice appear in all
  18  **   copies and that both that copyright notice and this permission
  19  **   notice appear in supporting documentation, and that the names of
  20  **   Hewlett-Packard or  M.I.T.  not be used in advertising or publicity
  21  **   pertaining to distribution of the software without specific, written
  22  **   prior permission.
  23  **
  24  *****************************************************************************
  25  *************************************<+>*************************************/
  26
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <ctype.h>
  31 #include <X11/IntrinsicP.h>
  32 #include <X11/Intrinsic.h>
  33 #include <Xw/Xw.h>
  34 #include <Xw/XwP.h>
  35 #include <Xw/MenuBtn.h>
  36 #include <X11/StringDefs.h>
  37
  38
  39 \f
  40 /*************************************<->*************************************
  41  *
  42  *
  43  *   Description:  default translation table for class: Primitive.
  44  *   -----------
  45  *
  46  *   These translations will be compiled at class initialize.  When
  47  *   a subclass of primitive is created then these translations will
  48  *   be used to augment the translations of the subclass IFF
  49  *   traversal is on.  The SetValues routine will also augment
  50  *   a subclass's translations table IFF traversal goes from off to on.
  51  *   Since we are augmenting it should not be a problem when
  52  *   traversal goes from off to on to off and on again.
  53  *
  54  *************************************<->***********************************/
  55
  56 static char defaultTranslations[] =
  57    "<FocusIn>:              focusIn() \n\
  58     <FocusOut>:             focusOut() \n\
  59     <Visible>:         visibility() \n\
  60     <Unmap>:           unmap()";
  61
  62
  63 /*************************************<->*************************************
  64  *
  65  *
  66  *   Description:  action list for class: Primtive
  67  *   -----------
  68  *   Used to provide actions for subclasses with traversal on.
  69  *
  70  *************************************<->***********************************/
  71
  72 static XtActionsRec actionsList[] =
  73 {
  74   {"focusIn", (XtActionProc) _XwPrimitiveFocusIn},
  75   {"focusOut", (XtActionProc) _XwPrimitiveFocusOut},
  76   {"visibility", (XtActionProc) _XwPrimitiveVisibility},
  77   {"unmap", (XtActionProc) _XwPrimitiveUnmap},
  78 };
  79
  80 \f
  81 /*  Resource definitions for Subclasses of Primitive */
  82
  83 static Cursor defaultCursor = None;
  84
  85 static XtResource resources[] =
  86 {
  87    {
  88      XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
  89      XtOffset (XwPrimitiveWidget, primitive.foreground),
  90      XtRString, "XtDefaultForeground"
  91    },
  92
  93    {
  94      XtNbackgroundTile, XtCBackgroundTile, XtRTileType, sizeof (int),
  95      XtOffset (XwPrimitiveWidget, primitive.background_tile),
  96      XtRString, "background"
  97    },
  98
  99    {
 100      XtNcursor, XtCCursor, XtRCursor, sizeof (Cursor),
 101      XtOffset (XwPrimitiveWidget, primitive.cursor),
 102      XtRCursor, (caddr_t) &defaultCursor
 103    },
 104
 105    {
 106      XtNtraversalType, XtCTraversalType, XtRTraversalType, sizeof (int),
 107      XtOffset (XwPrimitiveWidget, primitive.traversal_type),
 108      XtRString, "highlight_off"
 109    },
 110
 111    {
 112      XtNhighlightThickness, XtCHighlightThickness, XtRInt, sizeof (int),
 113      XtOffset (XwPrimitiveWidget, primitive.highlight_thickness),
 114      XtRString, "0"
 115    },
 116
 117    {
 118      XtNhighlightStyle, XtCHighlightStyle, XtRHighlightStyle, sizeof (int),
 119      XtOffset (XwPrimitiveWidget, primitive.highlight_style),
 120      XtRString, "pattern_border"
 121    },
 122
 123    {
 124      XtNhighlightColor, XtCForeground, XtRPixel, sizeof (Pixel),
 125      XtOffset (XwPrimitiveWidget, primitive.highlight_color),
 126      XtRString, "Black"
 127    },
 128
 129    {
 130      XtNhighlightTile, XtCHighlightTile, XtRTileType, sizeof (int),
 131      XtOffset (XwPrimitiveWidget, primitive.highlight_tile),
 132      XtRString, "foreground"
 133    },
 134
 135    {
 136      XtNrecomputeSize, XtCRecomputeSize, XtRBoolean, sizeof(Boolean),
 137      XtOffset (XwPrimitiveWidget, primitive.recompute_size),
 138      XtRString, "True"
 139    },
 140
 141    {
 142      XtNselect, XtCCallback, XtRCallback, sizeof(caddr_t),
 143      XtOffset (XwPrimitiveWidget, primitive.select),
 144      XtRPointer, (caddr_t) NULL
 145    },
 146
 147    {
 148      XtNrelease, XtCCallback, XtRCallback, sizeof(caddr_t),
 149      XtOffset (XwPrimitiveWidget, primitive.release),
 150      XtRPointer, (caddr_t) NULL
 151    },
 152 };
 153
 154
 155
 156 /*  Routine definiton used for initializing the class record.  */
 157
 158 static void              ClassInitialize();
 159 static void   ClassPartInitialize();
 160 static void          Initialize();
 161 static void        Realize();
 162 static void        Destroy();
 163 static Boolean     SetValues();
 164
 165 static void GetHighlightGC();
 166
 167
 168
 169 /*  The primitive class record definition  */
 170
 171 XwPrimitiveClassRec XwprimitiveClassRec =
 172 {
 173    {
 174       (WidgetClass) &widgetClassRec,    /* superclass            */
 175       "XwPrimitive",                    /* class_name            */
 176       sizeof(XwPrimitiveRec),           /* widget_size           */
 177       (XtProc) ClassInitialize,         /* class_initialize      */
 178       (XtWidgetClassProc) ClassPartInitialize, /* class_part_initialize */
 179       FALSE,                            /* class_inited          */
 180       (XtInitProc) Initialize,          /* initialize            */
 181       NULL,                             /* initialize_hook       */
 182       (XtRealizeProc) Realize,          /* realize               */
 183       actionsList,                      /* actions               */
 184       XtNumber(actionsList),            /* num_actions           */
 185       resources,                        /* resources             */
 186       XtNumber(resources),              /* num_resources         */
 187       NULLQUARK,                        /* xrm_class             */
 188       TRUE,                             /* compress_motion       */
 189       TRUE,                             /* compress_exposure     */
 190       TRUE,                             /* compress_enterleave   */
 191       FALSE,                            /* visible_interest      */
 192       (XtWidgetProc) Destroy,           /* destroy               */
 193       NULL,                             /* resize                */
 194       NULL,                             /* expose                */
 195       (XtSetValuesFunc) SetValues,      /* set_values            */
 196       NULL,                             /* set_values_hook       */
 197       XtInheritSetValuesAlmost,         /* set_values_almost     */
 198       NULL,                             /* get_values_hook       */
 199       NULL,                             /* accept_focus          */
 200       XtVersion,                        /* version               */
 201       NULL,                             /* callback private      */
 202       NULL,                             /* tm_table              */
 203       NULL,                             /* query_geometry        */
 204     /* display_accelerator      */      XtInheritDisplayAccelerator,
 205     /* extension                */      NULL
 206    },
 207
 208    {
 209       NULL,         /* Primitive border_highlight   */
 210       NULL,         /* Primitive border_unhighlight */
 211       NULL,         /* Primitive select_proc        */
 212       NULL,         /* Primitive release_proc       */
 213       NULL,         /* Primitive toggle_proc        */
 214       NULL,         /* default translations         */
 215    }
 216 };
 217
 218 WidgetClass XwprimitiveWidgetClass = (WidgetClass) &XwprimitiveClassRec;
 219
 220
 221
 222 /************************************************************************
 223  *
 224  *  ClassInitialize
 225  *    Initialize the primitive class structure.  This is called only
 226  *    the first time a primitive widget is created.  It registers the
 227  *    resource type converters unique to this class.
 228  *
 229  *
 230  * After class init, the "translations" variable will contain the compiled
 231  * translations to be used to augment a widget's translation
 232  * table if they wish to have keyboard traversal on.
 233  *
 234  ************************************************************************/
 235
 236 static void ClassInitialize()
 237 {
 238    XwRegisterConverters();
 239    XwprimitiveClassRec.primitive_class.translations =
 240      XtParseTranslationTable(defaultTranslations);
 241 }
 242
 243
 244
 245
 246 /************************************************************************
 247  *
 248  *  ClassPartInitialize
 249  *    Set up the inheritance mechanism for the routines exported by
 250  *    primitives class part.
 251  *
 252  ************************************************************************/
 253
 254 static void ClassPartInitialize (w)
 255 WidgetClass w;
 256
 257 {
 258     register XwPrimitiveWidgetClass wc = (XwPrimitiveWidgetClass) w;
 259     register XwPrimitiveWidgetClass super =
 260             (XwPrimitiveWidgetClass) wc->core_class.superclass;
 261
 262     if (wc -> primitive_class.border_highlight == XtInheritBorderHighlight)
 263         wc -> primitive_class.border_highlight =
 264            super -> primitive_class.border_highlight;
 265
 266     if (wc->primitive_class.border_unhighlight == XtInheritBorderUnhighlight)
 267         wc -> primitive_class.border_unhighlight =
 268            super -> primitive_class.border_unhighlight;
 269
 270     if (wc -> primitive_class.select_proc == XtInheritSelectProc)
 271         wc -> primitive_class.select_proc =
 272            super -> primitive_class.select_proc;
 273
 274     if (wc -> primitive_class.release_proc == XtInheritReleaseProc)
 275         wc -> primitive_class.release_proc =
 276            super -> primitive_class.release_proc;
 277
 278     if (wc -> primitive_class.toggle_proc == XtInheritToggleProc)
 279         wc -> primitive_class.toggle_proc =
 280            super -> primitive_class.toggle_proc;
 281 }
 282
 283
 284
 285
 286
 287 /************************************************************************
 288  *
 289  *  GetHighlightGC
 290  *     Get the graphics context used for drawing the border.
 291  *
 292  ************************************************************************/
 293
 294 static void GetHighlightGC (pw)
 295 XwPrimitiveWidget pw;
 296
 297 {
 298    XGCValues values;
 299    XtGCMask  valueMask;
 300
 301    valueMask = GCForeground | GCBackground;
 302    values.foreground = pw -> primitive.highlight_color;
 303    values.background = pw -> core.background_pixel;
 304
 305    if (pw -> primitive.highlight_tile == XwBACKGROUND)
 306    {
 307       values.foreground = pw -> core.background_pixel;
 308       values.background = pw -> primitive.highlight_color;
 309    }
 310
 311    pw -> primitive.highlight_GC = XtGetGC ((Widget) pw, valueMask, &values);
 312 }
 313
 314
 315
 316
 317
 318 /************************************************************************
 319  *
 320  *  Initialize
 321  *     The main widget instance initialization routine.
 322  *
 323  ************************************************************************/
 324
 325 static void Initialize (request, new)
 326 XwPrimitiveWidget request, new;
 327
 328 {
 329    XwPrimitiveWidget pw = (XwPrimitiveWidget) new;
 330    Arg args[1];
 331
 332
 333    /* initialize traversal flag */
 334
 335    pw->primitive.I_have_traversal = FALSE;
 336
 337
 338    /*  Check the pw widget for invalid data  */
 339
 340    if (pw -> primitive.traversal_type != XwHIGHLIGHT_OFF      &&
 341        pw -> primitive.traversal_type != XwHIGHLIGHT_ENTER    &&
 342        pw -> primitive.traversal_type != XwHIGHLIGHT_TRAVERSAL)
 343    {
 344       XtWarning ("Primitive: Incorrect traversal type");
 345       pw -> primitive.traversal_type = XwHIGHLIGHT_OFF;
 346    }
 347
 348    if (pw -> primitive.highlight_style != XwPATTERN_BORDER &&
 349        pw -> primitive.highlight_style != XwWIDGET_DEFINED)
 350    {
 351       XtWarning("Primitive: Incorrect highlight style.");
 352       pw -> primitive.highlight_style = XwPATTERN_BORDER;
 353    }
 354
 355    if (pw -> primitive.highlight_tile != XwFOREGROUND)
 356    {
 357       XtWarning("Primitive: Incorrect highlight tile.");
 358       pw -> primitive.highlight_tile = XwFOREGROUND;
 359    }
 360
 361    if (pw -> primitive.highlight_thickness < 0)
 362    {
 363       XtWarning("Primitive: Invalid highlight thickness.");
 364       pw -> primitive.highlight_thickness = 0;
 365    }
 366
 367    if (pw -> primitive.background_tile != XwBACKGROUND)
 368    {
 369       XtWarning("Primitive: Incorrect background tile.");
 370       pw -> primitive.background_tile = XwBACKGROUND;
 371    }
 372
 373
 374    /*  Check the geometry information for the widget  */
 375
 376    if (request -> core.width == 0)
 377       pw -> core.width += pw -> primitive.highlight_thickness * 2;
 378    else if (request -> core.width < pw -> primitive.highlight_thickness * 2)
 379    {
 380       pw -> primitive.highlight_thickness = request -> core.width / 2;
 381    }
 382
 383    if (request -> core.height == 0)
 384       pw -> core.height += pw -> primitive.highlight_thickness * 2;
 385    else if (request -> core.height < pw -> primitive.highlight_thickness * 2)
 386    {
 387       pw -> primitive.highlight_thickness = request -> core.height / 2;
 388    }
 389
 390
 391    /*  Get the graphics contexts for the border drawing  */
 392
 393    GetHighlightGC (pw);
 394
 395    /*  Set some additional fields of the widget  */
 396
 397    pw -> primitive.display_sensitive = FALSE;
 398    pw -> primitive.highlighted = FALSE;
 399    pw -> primitive.display_highlighted = FALSE;
 400
 401    /* If this widget is requesting traversal then augment its
 402     * translation table with some additional events.
 403     */
 404    if (pw->primitive.traversal_type == XwHIGHLIGHT_TRAVERSAL)
 405      {
 406       XtAugmentTranslations((Widget) pw,
 407                             XwprimitiveClassRec.primitive_class.translations);
 408       pw->core.widget_class->core_class.visible_interest = True;
 409     }
 410
 411 }
 412
 413
 414
 415 /************************************************************************
 416  *
 417  *  Realize
 418  *
 419  ************************************************************************/
 420
 421 static void Realize (widget, value_mask, attributes)
 422     Widget               widget;
 423     Mask                 *value_mask;
 424     XSetWindowAttributes *attributes;
 425 {
 426     XwPrimitiveWidget pw = (XwPrimitiveWidget) widget;
 427
 428     if (pw -> primitive.cursor != None) *value_mask |= CWCursor;
 429
 430     attributes->cursor = pw->primitive.cursor;
 431
 432     XtCreateWindow(widget, (unsigned int) InputOutput,
 433                    (Visual *) CopyFromParent, *value_mask, attributes);
 434 }
 435
 436
 437 /************************************************************************
 438  *
 439  *  Destroy
 440  *      Clean up allocated resources when the widget is destroyed.
 441  *
 442  ************************************************************************/
 443
 444 static void Destroy (pw)
 445 XwPrimitiveWidget pw;
 446 {
 447    XwManagerWidget parent;
 448
 449    XtRemoveCallbacks ((Widget)pw, XtNselect, pw -> primitive.select);
 450    XtRemoveCallbacks ((Widget)pw, XtNrelease, pw -> primitive.release);
 451    if (pw->primitive.I_have_traversal)
 452       XwProcessTraversal (pw, XwTRAVERSE_HOME, TRUE);
 453    else if ((XtIsSubclass((Widget)(parent = (XwManagerWidget)XtParent(pw)),
 454             XwmanagerWidgetClass)) &&
 455            (parent->manager.traversal_on) &&
 456            (parent->manager.active_child == (Widget)pw))
 457    {
 458       parent->manager.active_child = NULL;
 459
 460       /* Find the top most manager */
 461       while ((parent->core.parent != NULL) &&
 462              (XtIsSubclass(parent->core.parent, XwmanagerWidgetClass)))
 463          parent = (XwManagerWidget)parent->core.parent;
 464
 465       /* Clear the toolkit kbd focus from us */
 466       XtSetKeyboardFocus((Widget)parent, NULL);
 467    }
 468 }
 469
 470
 471
 472
 473 /************************************************************************
 474  *
 475  *  SetValues
 476  *     Perform and updating necessary for a set values call.
 477  *
 478  ************************************************************************/
 479
 480 static Boolean SetValues (current, request, new)
 481 Widget current, request, new;
 482
 483 {
 484    Boolean tempSensitive, tempAnSensitive;
 485    int tempTrav;
 486
 487    XwPrimitiveWidget curpw = (XwPrimitiveWidget) current;
 488    XwPrimitiveWidget reqpw = (XwPrimitiveWidget) request;
 489    XwPrimitiveWidget newpw = (XwPrimitiveWidget) new;
 490    Boolean returnFlag = FALSE;
 491    int     difference;
 492
 493
 494    /*  Verify correct new values.  */
 495
 496    if (newpw->primitive.traversal_type != XwHIGHLIGHT_OFF      &&
 497        newpw->primitive.traversal_type != XwHIGHLIGHT_ENTER    &&
 498        newpw->primitive.traversal_type != XwHIGHLIGHT_TRAVERSAL)
 499    {
 500       XtWarning("Primitive: Incorrect traversal type.");
 501       newpw->primitive.traversal_type = curpw->primitive.traversal_type;
 502    }
 503
 504
 505    /*  If traversal has been turned on, then augment the translations  */
 506    /*  of the new widget.                                              */
 507
 508    if ((newpw->primitive.traversal_type != curpw->primitive.traversal_type)
 509         && (newpw->primitive.traversal_type == XwHIGHLIGHT_TRAVERSAL))
 510      {
 511          /* XXX this was a hard bug!  where were the XXX's?
 512           *
 513           * In R2 we could not pass newpw to this toolkit call!  But I
 514           * have found the bug!!!!  In R2 it was a temporary structure (stack)
 515           * but now curmw is the temporary one and newpw is real!
 516           * I can see why they were worried before.  Now there is no worry.
 517           * Go ahead and pass newpw!
 518           */
 519          XtAugmentTranslations((Widget) newpw,
 520                  XwprimitiveClassRec.primitive_class.translations);
 521          newpw->core.widget_class->core_class.visible_interest = True;
 522      }
 523
 524
 525    /* IF we have the traversal and something is happening to
 526     * make that not possible then move it somewhere else!
 527     */
 528
 529      if (((curpw->core.sensitive != newpw->core.sensitive) ||
 530         (curpw->core.ancestor_sensitive != newpw->core.ancestor_sensitive) ||
 531         (newpw->primitive.traversal_type != curpw->primitive.traversal_type))
 532         && (curpw->primitive.I_have_traversal))
 533      {
 534           newpw->primitive.highlighted = FALSE;
 535
 536           tempTrav= curpw->primitive.traversal_type;
 537           tempSensitive = curpw->core.sensitive;
 538           tempAnSensitive = curpw->core.ancestor_sensitive;
 539
 540           curpw->primitive.traversal_type = newpw->primitive.traversal_type;
 541           curpw->core.ancestor_sensitive = newpw->core.ancestor_sensitive;
 542           curpw->core.sensitive = newpw->core.sensitive;
 543
 544           XwProcessTraversal (curpw, XwTRAVERSE_HOME, FALSE);
 545
 546           curpw->primitive.traversal_type = tempTrav;
 547           curpw->core.sensitive = tempSensitive;
 548           curpw->core.ancestor_sensitive = tempAnSensitive;
 549
 550         returnFlag = TRUE;
 551      }
 552
 553
 554    if (newpw->primitive.highlight_style != XwPATTERN_BORDER &&
 555        newpw->primitive.highlight_style != XwWIDGET_DEFINED)
 556    {
 557       XtWarning ("Primitive: Incorrect highlight style.");
 558       newpw->primitive.highlight_style = curpw->primitive.highlight_style;
 559    }
 560
 561    if (newpw -> primitive.highlight_tile != XwFOREGROUND)
 562    {
 563       XtWarning ("Primitive: Incorrect highlight tile.");
 564       newpw->primitive.highlight_tile = curpw->primitive.highlight_tile;
 565    }
 566
 567    if (newpw->primitive.highlight_thickness < 0)
 568    {
 569       XtWarning ("Primtive: Invalid highlight thickness.");
 570       newpw -> primitive.highlight_thickness =
 571          curpw -> primitive.highlight_thickness;
 572    }
 573
 574
 575    if (newpw -> primitive.background_tile != XwBACKGROUND)
 576    {
 577       XtWarning("Primitive: Incorrect background tile.");
 578       newpw -> primitive.background_tile =
 579          curpw -> primitive.background_tile;
 580    }
 581
 582
 583    /*  Set the widgets background tile  */
 584
 585    if (newpw -> primitive.background_tile !=
 586        curpw -> primitive.background_tile     ||
 587        newpw -> primitive.foreground !=
 588        curpw -> primitive.foreground          ||
 589        newpw -> core.background_pixel !=
 590        curpw -> core.background_pixel)
 591    {
 592       Mask valueMask;
 593       XSetWindowAttributes attributes;
 594
 595       if (newpw -> primitive.background_tile == XwFOREGROUND)
 596       {
 597          valueMask = CWBackPixel;
 598          attributes.background_pixel = newpw -> primitive.foreground;
 599       }
 600       else
 601       {
 602          valueMask = CWBackPixel;
 603          attributes.background_pixel = newpw -> core.background_pixel;
 604       }
 605
 606       if (XtIsRealized ((Widget)newpw))
 607          XChangeWindowAttributes (XtDisplay(newpw), newpw -> core.window,
 608                                   valueMask, &attributes);
 609
 610       returnFlag = TRUE;
 611    }
 612
 613    if (newpw -> primitive.cursor != curpw -> primitive.cursor) {
 614        Mask valueMask = 0;
 615        XSetWindowAttributes attributes;
 616
 617        if (newpw->primitive.cursor != None) valueMask = CWCursor;
 618        attributes.cursor = newpw->primitive.cursor;
 619
 620        if (XtIsRealized ((Widget)newpw))
 621            XChangeWindowAttributes (XtDisplay(newpw), newpw -> core.window,
 622                                     valueMask, &attributes);
 623
 624        returnFlag = TRUE;
 625    }
 626
 627    /*  Check the geometry in relationship to the highlight thickness  */
 628
 629    if (reqpw -> core.width == 0)
 630       if (curpw -> core.width == 0)
 631          newpw -> core.width += newpw -> primitive.highlight_thickness * 2;
 632    else if (reqpw -> core.width < newpw -> primitive.highlight_thickness * 2)
 633    {
 634       newpw -> primitive.highlight_thickness = reqpw -> core.width / 2;
 635    }
 636
 637    if (reqpw -> core.height == 0)
 638       if (curpw -> core.height == 0)
 639          newpw -> core.height += newpw -> primitive.highlight_thickness * 2;
 640    else if (reqpw -> core.height < newpw -> primitive.highlight_thickness * 2)
 641    {
 642       XtWarning("Primitive: The highlight thickness is too large.");
 643       newpw -> primitive.highlight_thickness = reqpw -> core.height / 2;
 644    }
 645
 646
 647    /*  If the highlight color, traversal type, highlight tile or highlight */
 648    /*  thickness has changed, regenerate the GC's.                         */
 649
 650    if (curpw->primitive.highlight_color != newpw->primitive.highlight_color ||
 651        curpw->primitive.highlight_thickness !=
 652        newpw->primitive.highlight_thickness                                 ||
 653        curpw->primitive.highlight_style != newpw->primitive.highlight_style ||
 654        curpw->primitive.highlight_tile != newpw->primitive.highlight_tile)
 655    {
 656       XtDestroyGC (newpw -> primitive.highlight_GC);
 657
 658       GetHighlightGC (newpw);
 659
 660       returnFlag = TRUE;
 661    }
 662
 663
 664    /*  Return a flag which may indicate that a redraw needs to occur.  */
 665
 666    return (returnFlag);
 667 }
 668
 669
 670
 671 /************************************************************************
 672  *
 673  *  The traversal event processing routines.
 674  *    The following set of routines are the entry points invoked from
 675  *    each primitive widget when one of the traversal event conditions
 676  *    occur.  These routines are externed in Xw.h.
 677  *
 678  ************************************************************************/
 679
 680 void _XwTraverseLeft (w, event)
 681 Widget w;
 682 XEvent * event;
 683
 684 {
 685    XwProcessTraversal (w, XwTRAVERSE_LEFT, TRUE);
 686 }
 687
 688
 689 void _XwTraverseRight (w, event)
 690 Widget w;
 691 XEvent * event;
 692
 693 {
 694    XwProcessTraversal (w, XwTRAVERSE_RIGHT, TRUE);
 695 }
 696
 697
 698 void _XwTraverseUp (w, event)
 699 Widget w;
 700 XEvent * event;
 701
 702 {
 703    XwProcessTraversal (w, XwTRAVERSE_UP, TRUE);
 704 }
 705
 706
 707 void _XwTraverseDown (w, event)
 708 Widget w;
 709 XEvent * event;
 710
 711 {
 712    XwProcessTraversal (w, XwTRAVERSE_DOWN, TRUE);
 713 }
 714
 715
 716 void _XwTraverseNext (w, event)
 717 Widget w;
 718 XEvent * event;
 719
 720 {
 721    XwProcessTraversal (w, XwTRAVERSE_NEXT, TRUE);
 722 }
 723
 724
 725 void _XwTraversePrev (w, event)
 726 Widget w;
 727 XEvent * event;
 728
 729 {
 730    XwProcessTraversal (w, XwTRAVERSE_PREV, TRUE);
 731 }
 732
 733
 734 void _XwTraverseHome (w, event)
 735 Widget w;
 736 XEvent * event;
 737
 738 {
 739    XwProcessTraversal (w, XwTRAVERSE_HOME, TRUE);
 740 }
 741
 742
 743 void _XwTraverseNextTop (w, event)
 744 Widget w;
 745 XEvent * event;
 746
 747 {
 748    XwProcessTraversal (w, XwTRAVERSE_NEXT_TOP, TRUE);
 749 }
 750
 751
 752
 753 /************************************************************************
 754  *
 755  *  XwProcessTraversal
 756  *     This function handles all of the directional traversal conditions.
 757  *     It first verifies that traversal is active, and then searches up
 758  *     the widget hierarchy until a composite widget class is found.
 759  *     If this widget also contains a ManagerWidgetClass, it invokes
 760  *     the class's traversal handler giving the widget and direction.
 761  *     If not a ManagerWidgetClass, it invokes the composits
 762  *     move_focus_to_next or move_focus_to_prev functions for directions
 763  *     of TRAVERSE_NEXT and TRAVERSE_PREV respectively.
 764  *
 765  ************************************************************************/
 766
 767 void XwProcessTraversal (w, dir, check)
 768 Widget w;
 769 int    dir;
 770 Boolean check;
 771
 772 {
 773    Widget tw;
 774    XPoint ul, lr;
 775    XwPrimitiveWidget pw = (XwPrimitiveWidget) w;
 776
 777    if (check && (pw -> primitive.traversal_type != XwHIGHLIGHT_TRAVERSAL))
 778           return;
 779
 780    /* Initialize the traversal checklist */
 781    _XwInitCheckList();
 782
 783    tw = w -> core.parent;
 784
 785    ul.x = w -> core.x;
 786    ul.y = w -> core.y;
 787    lr.x = ul.x + w->core.width - 1;
 788    lr.y = ul.y + w->core.height - 1;
 789
 790    if (XtIsSubclass (tw, XwmanagerWidgetClass))
 791    {
 792        (*(((XwManagerWidgetClass) (tw -> core.widget_class)) ->
 793                                    manager_class.traversal_handler))
 794                                       (tw, ul, lr, dir);
 795    }
 796 /* *** R3
 797    else if (dir == XwTRAVERSE_NEXT &&
 798            ((CompositeWidgetClass)(tw -> core.widget_class)) ->
 799                                    composite_class.move_focus_to_next != NULL)
 800    {
 801       (*(((CompositeWidgetClass) tw -> core.widget_class) ->
 802                                  composite_class.move_focus_to_next))(w);
 803    }
 804
 805    else if (dir == XwTRAVERSE_PREV &&
 806            ((CompositeWidgetClass)(tw -> core.widget_class)) ->
 807                                    composite_class.move_focus_to_prev != NULL)
 808    {
 809       (*(((CompositeWidgetClass) tw -> core.widget_class) ->
 810                                  composite_class.move_focus_to_prev))(w);
 811    }
 812    *** R3 */
 813 }
 814
 815
 816
 817 /************************************************************************
 818  *
 819  *  The border highlighting and unhighlighting routines.
 820  *
 821  *  These routines are called through primitive widget translations and
 822  *  by primitive widget redisplay routines.  They provide for the border
 823  *  drawing for active and inactive cases.
 824  *
 825  ************************************************************************/
 826
 827 void _XwHighlightBorder (pw)
 828 XwPrimitiveWidget pw;
 829
 830 {
 831    if ((pw -> primitive.highlight_thickness == 0
 832         ) && (!XtIsSubclass ((Widget)pw, XwmenubuttonWidgetClass)))
 833       return;
 834
 835    pw -> primitive.highlighted = TRUE;
 836    pw -> primitive.display_highlighted = TRUE;
 837
 838    switch (pw -> primitive.highlight_style)
 839    {
 840
 841       case XwWIDGET_DEFINED:
 842       {
 843          if (((XwPrimitiveWidgetClass) (pw -> core.widget_class)) ->
 844               primitive_class.border_highlight != NULL)
 845          (*(((XwPrimitiveWidgetClass) (pw -> core.widget_class)) ->
 846             primitive_class.border_highlight))((Widget)pw);
 847       }
 848       break;
 849
 850       case XwPATTERN_BORDER:
 851       {
 852          XRectangle rect[4];
 853          int windowWidth = pw -> core.width;
 854          int windowHeight = pw -> core.height;
 855          int highlightWidth = pw -> primitive.highlight_thickness;
 856
 857          rect[0].x = 0;
 858          rect[0].y = 0;
 859          rect[0].width = windowWidth;
 860          rect[0].height = highlightWidth;
 861
 862          rect[1].x = 0;
 863          rect[1].y = 0;
 864          rect[1].width = highlightWidth;
 865          rect[1].height = windowHeight;
 866
 867          rect[2].x = windowWidth - highlightWidth;
 868          rect[2].y = 0;
 869          rect[2].width = highlightWidth;
 870          rect[2].height = windowHeight;
 871
 872          rect[3].x = 0;
 873          rect[3].y = windowHeight - highlightWidth;
 874          rect[3].width = windowWidth;
 875          rect[3].height = highlightWidth;
 876
 877          XFillRectangles (XtDisplay (pw), XtWindow (pw),
 878                           pw -> primitive.highlight_GC, &rect[0], 4);
 879       }
 880       break;
 881    }
 882 }
 883
 884
 885
 886
 887 void _XwUnhighlightBorder (pw)
 888 XwPrimitiveWidget pw;
 889
 890 {
 891    if ((pw -> primitive.highlight_thickness == 0
 892         ) && (!XtIsSubclass ((Widget)pw, XwmenubuttonWidgetClass)))
 893       return;
 894
 895
 896    pw -> primitive.highlighted = FALSE;
 897    pw -> primitive.display_highlighted = FALSE;
 898
 899    switch (pw -> primitive.highlight_style)
 900    {
 901       case XwWIDGET_DEFINED:
 902       {
 903          if (((XwPrimitiveWidgetClass) (pw -> core.widget_class)) ->
 904               primitive_class.border_unhighlight != NULL)
 905             (*(((XwPrimitiveWidgetClass) (pw -> core.widget_class)) ->
 906                primitive_class.border_unhighlight))((Widget)pw);
 907       }
 908       break;
 909
 910
 911       case XwPATTERN_BORDER:
 912       {
 913          int windowWidth = pw -> core.width;
 914          int windowHeight = pw -> core.height;
 915          int highlightWidth = pw -> primitive.highlight_thickness;
 916
 917
 918          XClearArea (XtDisplay (pw), XtWindow (pw),
 919                      0, 0, windowWidth, highlightWidth, False);
 920
 921          XClearArea (XtDisplay (pw), XtWindow (pw),
 922                      0, 0, highlightWidth, windowHeight, False);
 923
 924          XClearArea (XtDisplay (pw), XtWindow (pw),
 925                      windowWidth - highlightWidth, 0,
 926                      highlightWidth, windowHeight, False);
 927
 928          XClearArea (XtDisplay (pw), XtWindow (pw),
 929                      0, windowHeight - highlightWidth,
 930                      windowWidth, highlightWidth, False);
 931       }
 932       break;
 933    }
 934 }
 935
 936
 937
 938
 939 /************************************************************************
 940  *
 941  *  Enter & Leave
 942  *      Enter and leave event processing routines.  Handle border
 943  *      highlighting and dehighlighting.
 944  *
 945  ************************************************************************/
 946
 947 void _XwPrimitiveEnter (pw, event)
 948 XwPrimitiveWidget pw;
 949 XEvent * event;
 950
 951 {
 952   if (pw -> primitive.traversal_type == XwHIGHLIGHT_ENTER)
 953      _XwHighlightBorder (pw);
 954 }
 955
 956
 957 void _XwPrimitiveLeave (pw, event)
 958 XwPrimitiveWidget pw;
 959 XEvent * event;
 960
 961 {
 962   if (pw -> primitive.traversal_type == XwHIGHLIGHT_ENTER)
 963      _XwUnhighlightBorder (pw);
 964 }
 965
 966
 967 /************************************************************************
 968  *
 969  * Visibility
 970  *      Track whether a widget is visible.
 971  *
 972  ***********************************************************************/
 973 void _XwPrimitiveVisibility (pw, event)
 974   XwPrimitiveWidget pw;
 975   XEvent * event;
 976 {
 977   XVisibilityEvent * vEvent = (XVisibilityEvent *)event;
 978
 979   if (vEvent->state == VisibilityFullyObscured)
 980     {
 981       pw->core.visible = False;
 982       if (pw->primitive.I_have_traversal)
 983        XwProcessTraversal (pw, XwTRAVERSE_HOME, FALSE);
 984      }
 985   else
 986     pw->core.visible = True;
 987
 988
 989 }
 990
 991
 992
 993 /************************************************************************
 994  *
 995  * Unmap
 996  *      Track whether a widget is visible.
 997  *
 998  ***********************************************************************/
 999 void _XwPrimitiveUnmap (pw, event)
1000   XwPrimitiveWidget pw;
1001   XEvent * event;
1002 {
1003    pw->core.visible = False;
1004    if (pw->primitive.I_have_traversal)
1005        XwProcessTraversal (pw, XwTRAVERSE_HOME, FALSE);
1006
1007 }
1008
1009 /************************************************************************
1010  *
1011  *  Focus In & Out
1012  *      Handle border highlighting and dehighlighting.
1013  *
1014  ************************************************************************/
1015
1016 void _XwPrimitiveFocusIn (pw, event)
1017 XwPrimitiveWidget pw;
1018 XEvent * event;
1019
1020 {
1021    int widgetType;
1022
1023
1024    /*  SET THE FOCUS PATH DOWN TO THIS WIDGET.  */
1025
1026    XwSetFocusPath((Widget)pw);
1027
1028
1029    /*  IF THE SPECIFIED WIDGET CANNOT BE TRAVERSED TO, THEN INVOKE  */
1030    /*  MANAGER'S TRAVERSAL HANDLER WITH DIRECTION = HOME.           */
1031
1032    if (! XwTestTraversability((Widget)pw, &widgetType))
1033      XwProcessTraversal (pw, XwTRAVERSE_HOME, FALSE);
1034    else
1035    {
1036       _XwHighlightBorder (pw);
1037       pw->primitive.I_have_traversal = TRUE;
1038    }
1039 }
1040
1041
1042 void _XwPrimitiveFocusOut (pw, event)
1043 XwPrimitiveWidget pw;
1044 XEvent * event;
1045
1046 {
1047    if (pw -> primitive.traversal_type == XwHIGHLIGHT_TRAVERSAL)
1048    {
1049       _XwUnhighlightBorder (pw);
1050       pw->primitive.I_have_traversal = FALSE;
1051    }
1052 }
1053
1054
1055 void XwSetFocusPath(w)
1056 Widget w;
1057
1058 {
1059    XwManagerWidget mw;
1060    Widget tempoldActive, oldActive;
1061
1062
1063    /*  IF THE PARENT OF THIS WIDGET IS NOT A MANAGER THEN THERE'S NO  */
1064    /*  PATH TO SET, SO RETURN.                                        */
1065
1066    if (! XtIsSubclass(w->core.parent, XwmanagerWidgetClass)) return;
1067
1068    mw = (XwManagerWidget)w->core.parent;
1069
1070
1071    /*  IF THIS WIDGET IS ALREADY THE ACTIVE CHID THEN THERE'S NOTHING  */
1072    /*  TO DO.                                                          */
1073
1074    if (mw->manager.active_child == w) return;
1075
1076    oldActive = mw->manager.active_child;
1077    mw->manager.active_child = w;
1078    XwProcessTraversal (w, XwTRAVERSE_CURRENT, FALSE);
1079
1080
1081    /*  TRAVERSE DOWN THE OTHER BRANCH OF TREE TO CLEAN UP ACTIVE CHILD  */
1082    /*  PATH.                                                            */
1083
1084    while (oldActive != NULL)
1085    {
1086       if (! XtIsSubclass(oldActive, XwmanagerWidgetClass))
1087          oldActive = NULL;
1088       else
1089       {
1090          tempoldActive = ((XwManagerWidget)oldActive)->manager.active_child;
1091          ((XwManagerWidget)oldActive)->manager.active_child = NULL;
1092          oldActive=tempoldActive;
1093       }
1094    }
1095
1096    XwSetFocusPath((Widget)mw);
1097 }
1098
1099
1100
1101
1102
1103
1104 /************************************************************************
1105  *
1106  *  _XwDrawBox
1107  *      Draw the bordering on the drawable d, thick pixels wide,
1108  *      using the provided GC and rectangle.
1109  *
1110  ************************************************************************/
1111
1112 void _XwDrawBox (display, d, normal_GC, thick, x, y, width, height)
1113 Display * display;
1114 Drawable d;
1115 GC normal_GC;
1116 register int thick;
1117 register int x;
1118 register int y;
1119 register int width;
1120 register int height;
1121
1122 {
1123    XRectangle rect[4];
1124
1125    rect[0].x = x;               /*  top   */
1126    rect[0].y = y;
1127    rect[0].width = width;
1128    rect[0].height = 2;
1129
1130    rect[1].x = x;               /*  left  */
1131    rect[1].y = y + 2;
1132    rect[1].width = 2;
1133    rect[1].height = height - 4;
1134
1135    rect[2].x = x;               /*  bottom  */
1136    rect[2].y = y + height - 2;
1137    rect[2].width = width;
1138    rect[2].height = 2;
1139
1140    rect[3].x = x + width - 2;   /*  Right two segments  */
1141    rect[3].y = y + 2;
1142    rect[3].width = 2;
1143    rect[3].height = height - 4;
1144
1145    XFillRectangles (display, d, normal_GC, &rect[0], 4);
1146 }