/* $XConsortium: Obso1_2.c /main/7 1996/06/14 23:10:17 pascale $ */

/*

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 * 

 */

/*

 * HISTORY

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <ctype.h>

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#endif

#include <Xm/XmP.h>

#include <Xm/BaseClassP.h>

#include <Xm/DesktopP.h>

#include <Xm/DisplayP.h>

#include <Xm/DrawingAP.h>

#include <Xm/FileSBP.h>

#include <Xm/GadgetP.h>

#include <Xm/List.h>

#include <Xm/ManagerP.h>

#include <Xm/MenuShellP.h>

#include <Xm/PrimitiveP.h>

#include <Xm/PushBGP.h>

#include <Xm/PushBP.h>

#include <Xm/RowColumnP.h>

#include <Xm/ScaleP.h>

#include <Xm/ScreenP.h>

#include <Xm/ScrolledWP.h>

#include <Xm/Text.h>

#include <Xm/TextF.h>

#include <Xm/TransltnsP.h>

#include <Xm/VendorSEP.h>

#include "BulletinBI.h"

#include "MessagesI.h"

#include "SelectioBI.h"

#include "SyntheticI.h"

#include "TraversalI.h"

#include "XmStringI.h"		/* for _XmStringGetTextConcat() */

typedef struct {

    int		segment_size;

    char*	start;

    char*	current;

    int		bytes_remaining;

} XmHeapRec, *XmHeap;

/********    Static Function Declarations    ********/

/********    End Static Function Declarations    ********/

externaldef(desktopobjectclass) WidgetClass 

      xmDesktopObjectClass = (WidgetClass) &xmDesktopClassRec;

externaldef(displayobjectclass) WidgetClass 

      xmDisplayObjectClass = (WidgetClass) (&xmDisplayClassRec);

externaldef(screenobjectclass) WidgetClass 

      xmScreenObjectClass = (WidgetClass) (&xmScreenClassRec);

externaldef(worldobjectclass) WidgetClass 

      xmWorldObjectClass = (WidgetClass) NULL;

/* WorldP.h was defuncted for 2.0 , no more ref to (&xmWorldClassRec) */

int 

XmTextFieldGetBaseLine(

        Widget w )

{

  return XmTextFieldGetBaseline( w) ;

}

int 

XmTextGetBaseLine(

        Widget w )

{

  return XmTextGetBaseline( w) ;

}

/*ARGSUSED*/

Boolean 

_XmTestTraversability(

        Widget widget,

        XRectangle *visRect )	/* unused */

{   

  return XmIsTraversable( widget) ;

}

/*ARGSUSED*/

void 

_XmClearTabGroup(

        Widget w )		/* unused */

{

  return ;

}

Widget 

_XmFindTabGroup(

        Widget widget )

{   

  return XmGetTabGroup( widget) ;

}

/*ARGSUSED*/

void 

_XmClearKbdFocus(

        Widget tabGroup )	/* unused */

{

  return ;

}

Widget 

_XmGetTabGroup(

        Widget w )

{   

  return XmGetTabGroup( w) ;

}

/*ARGSUSED*/

Boolean 

_XmWidgetIsTraversable(

        Widget widget,

#if NeedWidePrototypes

        int navType,		/* unused */

#else

        XmNavigationType navType, /* unused */

#endif /* NeedWidePrototypes */

        XRectangle *visRect )	/* unused */

{   

  return XmIsTraversable( widget) ;

}

Boolean 

_XmGetManagedInfo(

        Widget w )

{

  /* Depending upon the widget coming in, extract its mapped_when_managed flag

   * and its managed flag.

   */

    if (XmIsPrimitive (w))

      return (w->core.managed && w->core.mapped_when_managed);

    else if (XmIsGadget (w))

      return (w->core.managed);

    else

      {

	  /* Treat menupanes specially */

	  if (XmIsRowColumn(w) && XmIsMenuShell(XtParent(w)))

	    {

		return (True);

	    }

	  else

	    return (w->core.managed && w->core.mapped_when_managed);

      }

}

Boolean 

_XmChangeNavigationType(

        Widget current,

#if NeedWidePrototypes

        int newNavType )

#else

        XmNavigationType newNavType )

#endif /* NeedWidePrototypes */

{   

  /* This is a convenience routine for widgets wanting to change

   * their navigation type without using XtSetValues().

   */

  XmFocusData focusData ;

  Widget new_wid = current->core.self ;

  XmNavigationType curNavType = _XmGetNavigationType( current) ;

  XmTravGraph tgraph ;

  if(    (curNavType != newNavType)

     &&  (focusData = _XmGetFocusData( new_wid))

     &&  (tgraph = &(focusData->trav_graph))->num_entries    )

    {

      _XmTravGraphUpdate( tgraph, new_wid) ;

      if(    (focusData->focus_policy == XmEXPLICIT)

	 &&  (focusData->focus_item == new_wid)

	 &&  !XmIsTraversable( new_wid)    )

	{

	  Widget new_focus = _XmTraverseAway( tgraph, new_wid,

				    (focusData->active_tab_group != new_wid)) ;

	  if(    !new_focus    )

	    {

	      new_focus = new_wid ;

	    }

	  _XmMgrTraversal( new_focus, XmTRAVERSE_CURRENT) ;

	}

    }

  return TRUE ;

}

/********************************************************************/

/* Following is the old code needed for subclasses already using it */

/* They can either define the macro and change nothing (but suffer

   the addition of code and the drawing performance) or adapt to the 

   new interface (better) */

/************************************************************************

 *

 *  Primitive:_XmDrawShadow, become XmDrawShadow

 *

 *      Draw an n segment wide bordering shadow on the drawable

 *      d, using the provided GC's and rectangle.

 *

 ************************************************************************/

void _XmDrawShadow (Display *display, Drawable d, 

                    GC top_GC, GC bottom_GC, int size, int x, int y, 

                    int width, int height)

{

   static XRectangle * rects = NULL;

   static int rect_count = 0;

   register int i;

   register int size2;

   register int size3;

   if (size <= 0) return;

   if (size > width / 2) size = width / 2;

   if (size > height / 2) size = height / 2;

   if (size <= 0) return;

   if (rect_count == 0)

   {

      rects = (XRectangle *) XtMalloc (sizeof (XRectangle) * size * 4);

      rect_count = size;

   }

   if (rect_count < size)

   {

      rects = (XRectangle *) XtRealloc((char *)rects, sizeof (XRectangle) * size * 4);

      rect_count = size;

   }

   size2 = size + size;

   size3 = size2 + size;

   for (i = 0; i < size; i++)

   {

      /*  Top segments  */

      rects[i].x = x;

      rects[i].y = y + i;

      rects[i].width = width - i;

      rects[i].height = 1;

      /*  Left segments  */

      rects[i + size].x = x + i;

      rects[i + size].y = y;

      rects[i + size].width = 1;

      rects[i + size].height = height - i;

      /*  Bottom segments  */

      rects[i + size2].x = x + i + 1;

      rects[i + size2].y = y + height - i - 1;

      rects[i + size2].width = width - i - 1;

      rects[i + size2].height = 1;

      /*  Right segments  */

      rects[i + size3].x = x + width - i - 1;

      rects[i + size3].y = y + i + 1;

      rects[i + size3].width = 1;

      rects[i + size3].height = height - i - 1;

   }

   XFillRectangles (display, d, top_GC, &rects[0], size2);

   XFillRectangles (display, d, bottom_GC, &rects[size2], size2);

}

/************************************************************************

 *

 *  Primitive:_XmEraseShadow become XmClearShadow

 *

 *      Erase an n segment wide bordering shadow on the drawable

 *      d, using the provided  rectangle.

 *

 ************************************************************************/

void _XmEraseShadow (Display *display, Drawable d, int size, 

                     int x, int y, int width, int height)

{

   if (width > 0 && size > 0)

   {

      XClearArea (display, d, x, y, width, size, FALSE);

      XClearArea (display, d, x, y + height - size, width, size, FALSE);

   }

   if (size > 0 && height - (2 * size) > 0)

   {

      XClearArea (display, d, x, y + size, size, height - (2 * size), FALSE);

      XClearArea (display, d, x + width - size, y + size, size, 

                  height - (2 * size), FALSE);

   }

}

/************************************************************************

 *    ArrowBI:_XmGetArrowDrawRects, become XmDrawArrow

 *

 *      Calculate the drawing rectangles.

 *

 ************************************************************************/

void _XmGetArrowDrawRects (int highlight_thickness, int shadow_thickness, unsigned int direction, int core_width, int core_height, short *top_count, short *cent_count, short *bot_count, XRectangle **top, XRectangle **cent, XRectangle **bot)

{

   /*  Arrow rectangle generation function  */

   int size, width, start;

   register int y;

   XRectangle *tmp;

   register int temp;

   short t = 0;

   short b = 0;

   short c = 0;

   int xOffset = 0;

   int yOffset = 0;

   /*  Free the old lists  */

   if (*top != NULL)

   {

      XtFree ((char *) *top);   *top  = NULL;

      XtFree ((char *) *cent);  *cent = NULL;

      XtFree ((char *) *bot);   *bot  = NULL;

      *top_count = 0;

      *cent_count = 0;

      *bot_count = 0;

   }

   /*  Get the size and allocate the rectangle lists  */

   if (core_width > core_height) 

   {

      size = core_height - 2 - 

             2 * (highlight_thickness + shadow_thickness);

      xOffset = (core_width - core_height) / 2;

   }

   else

   {

      size = core_width - 2 - 

             2 * (highlight_thickness + shadow_thickness);

      yOffset = (core_height - core_width) / 2;

   }

   if (size < 1) return;

   if (direction == XmARROW_RIGHT ||

       direction == XmARROW_LEFT)

   {

      temp = xOffset;

      xOffset = yOffset;

      yOffset = temp;

   }

   *top  = (XRectangle *) XtMalloc (sizeof (XRectangle) * (size / 2 + 6));

   *cent = (XRectangle *) XtMalloc (sizeof (XRectangle) * (size  / 2 + 6));

   *bot  = (XRectangle *) XtMalloc (sizeof (XRectangle) * (size / 2 + 6));

   /*  Set up a loop to generate the segments.  */

   width = size;

   y = size + highlight_thickness + shadow_thickness - 1 + yOffset;

   start = highlight_thickness + shadow_thickness + 1 + xOffset;

   while (width > 0)

   {

      if (width == 1)

      {

         (*top)[t].x = start; (*top)[t].y = y + 1;

         (*top)[t].width = 1; (*top)[t].height = 1;

         t++;

      }

      else if (width == 2)

      {

         if (size == 2 || 

             (direction == XmARROW_UP ||

              direction == XmARROW_LEFT))

         {

            (*top)[t].x = start; (*top)[t].y = y;

            (*top)[t].width = 2; (*top)[t].height = 1;

            t++;

            (*top)[t].x = start; (*top)[t].y = y + 1;

            (*top)[t].width = 1; (*top)[t].height = 1;

            t++;

            (*bot)[b].x = start + 1; (*bot)[b].y = y + 1;

            (*bot)[b].width = 1; (*bot)[b].height = 1;

            b++;

         }

         else if (direction == XmARROW_UP ||

                  direction == XmARROW_LEFT)

         {

            (*top)[t].x = start; (*top)[t].y = y;

            (*top)[t].width = 2; (*top)[t].height = 1;

            t++;

            (*bot)[b].x = start; (*bot)[b].y = y + 1;

            (*bot)[b].width = 2; (*bot)[b].height = 1;

            b++;

         }

      }

      else

      {

         if (start == highlight_thickness +

                      shadow_thickness + 1 + xOffset)

         {

            if (direction == XmARROW_UP ||

                direction == XmARROW_LEFT)

            {

               (*top)[t].x = start; (*top)[t].y = y;

               (*top)[t].width = 2; (*top)[t].height = 1;

               t++;

               (*top)[t].x = start; (*top)[t].y = y + 1;

               (*top)[t].width = 1; (*top)[t].height = 1;

               t++;

               (*bot)[b].x = start + 1; (*bot)[b].y = y + 1;

               (*bot)[b].width = 1; (*bot)[b].height = 1;

               b++;

               (*bot)[b].x = start + 2; (*bot)[b].y = y;

               (*bot)[b].width = width - 2; (*bot)[b].height = 2;

               b++;

            }

            else

            {

               (*top)[t].x = start; (*top)[t].y = y;

               (*top)[t].width = 2; (*top)[t].height = 1;

               t++;

               (*bot)[b].x = start; (*bot)[b].y = y + 1;

               (*bot)[b].width = 2; (*bot)[b].height = 1;

               b++;

               (*bot)[b].x = start + 2; (*bot)[b].y = y;

               (*bot)[b].width = width - 2; (*bot)[b].height = 2;

               b++;

            }

         }

         else

         {

            (*top)[t].x = start; (*top)[t].y = y;

            (*top)[t].width = 2; (*top)[t].height = 2;

            t++;

            (*bot)[b].x = start + width - 2; (*bot)[b].y = y;

            (*bot)[b].width = 2; (*bot)[b].height = 2;

            if (width == 3)

            {

               (*bot)[b].width = 1;

               (*bot)[b].x += 1;

            }

            b++;

            if (width > 4)

            {

               (*cent)[c].x = start + 2; (*cent)[c].y = y;

               (*cent)[c].width = width - 4; (*cent)[c].height = 2;

               c++;

            }

         }

      }

      start++;

      width -= 2;

      y -= 2;

   }

   if (direction == XmARROW_UP ||

       direction == XmARROW_LEFT)

   {

      *top_count = t;

      *cent_count = c;

      *bot_count = b;

   }

   else

   {   

      tmp = *top;

      *top = *bot;

      *bot = tmp;

      *top_count = b;

      *cent_count = c;

      *bot_count = t;

   }

   /*  Transform the "up" pointing arrow to the correct direction  */

   switch (direction)

   {

      case XmARROW_LEFT:

      {

          register int i; 

          i = -1;

          do

          {

             i++;

             if (i < *top_count)

             {

                temp = (*top)[i].y; (*top)[i].y =

                    (*top)[i].x; (*top)[i].x = temp;

                temp = (*top)[i].width; 

                (*top)[i].width = (*top)[i].height; (*top)[i].height = temp;

             }             

             if (i < *bot_count)

             {

                temp = (*bot)[i].y; (*bot)[i].y =

                    (*bot)[i].x; (*bot)[i].x = temp;

                temp = (*bot)[i].width; 

                (*bot)[i].width = (*bot)[i].height; (*bot)[i].height = temp;

             }             

             if (i < *cent_count)

             {

                temp = (*cent)[i].y; (*cent)[i].y =

                    (*cent)[i].x; (*cent)[i].x = temp;

                temp = (*cent)[i].width; 

                (*cent)[i].width = (*cent)[i].height; (*cent)[i].height = temp;

             }             

          }

          while (i < *top_count || i < *bot_count || i < *cent_count);

      }

      break;

      case XmARROW_RIGHT:

      {

          register int h_right = core_height - 2;

          register int w_right = core_width - 2;

          register int i; 

          i = -1;

          do

          {

             i++;

             if (i < *top_count)

             {

                temp = (*top)[i].y; (*top)[i].y = (*top)[i].x; 

                (*top)[i].x = temp; 

                temp = (*top)[i].width; (*top)[i].width = (*top)[i].height; 

                (*top)[i].height = temp;

                (*top)[i].x = w_right - (*top)[i].x - (*top)[i].width + 2;

                (*top)[i].y = h_right - (*top)[i].y - (*top)[i].height + 2;

             }             

             if (i < *bot_count)

             {

                temp = (*bot)[i].y; (*bot)[i].y = (*bot)[i].x; 

                (*bot)[i].x = temp; 

                temp = (*bot)[i].width; (*bot)[i].width = (*bot)[i].height; 

                (*bot)[i].height = temp;

                (*bot)[i].x = w_right - (*bot)[i].x - (*bot)[i].width + 2;

                (*bot)[i].y = h_right - (*bot)[i].y - (*bot)[i].height + 2;

             }             

             if (i < *cent_count)

             {

                temp = (*cent)[i].y; (*cent)[i].y = (*cent)[i].x; 

                (*cent)[i].x = temp; 

                temp = (*cent)[i].width; (*cent)[i].width = (*cent)[i].height;

                (*cent)[i].height = temp;

                (*cent)[i].x = w_right - (*cent)[i].x - (*cent)[i].width + 2;

                (*cent)[i].y = h_right - (*cent)[i].y - (*cent)[i].height + 2;

             }

          }

          while (i < *top_count || i < *bot_count || i < *cent_count);

      }

      break;

      case XmARROW_UP:

      {

      }

      break;

      case XmARROW_DOWN:

      {

          register int w_down = core_width - 2;

          register int h_down = core_height - 2;

          register int i; 

          i = -1;

          do

          {

             i++;

             if (i < *top_count)

             {

                (*top)[i].x = w_down - (*top)[i].x - (*top)[i].width + 2;

                (*top)[i].y = h_down - (*top)[i].y - (*top)[i].height + 2;

             }

             if (i < *bot_count)

             {

                (*bot)[i].x = w_down - (*bot)[i].x - (*bot)[i].width + 2;

                (*bot)[i].y = h_down - (*bot)[i].y - (*bot)[i].height + 2;

             }

             if (i < *cent_count)

             {

                (*cent)[i].x = w_down - (*cent)[i].x - (*cent)[i].width + 2;

                (*cent)[i].y = h_down - (*cent)[i].y - (*cent)[i].height + 2;

             }

          }

          while (i < *top_count || i < *bot_count || i < *cent_count);

      }

      break;

   }

}

/************************************************************************

 *

 *    ArrowBI:_XmOffsetArrow, become XmDrawArrow

 *  

 *      Offset the arrow drawing rectangles, if needed, by the difference

 *      of the current x, y and the saved x, y);

 *

 ************************************************************************/

void _XmOffsetArrow (int diff_x, int diff_y, XRectangle *top, XRectangle *cent, XRectangle *bot, int top_count, int cent_count, int bot_count)

{

   register int i;

   if (diff_x != 0 || diff_y != 0)

   {

      for (i = 0; i < top_count; i++)

      {

         (top + i)->x += diff_x;

         (top + i)->y += diff_y;

      }

      for (i = 0; i < cent_count; i++)

      {

         (cent + i)->x += diff_x;

         (cent + i)->y += diff_y;

      }

      for (i = 0; i < bot_count; i++)

      {

         (bot + i)->x += diff_x;

         (bot + i)->y += diff_y;

      }

   }

}

/*************************************<->*************************************

 *

 *  ToggleBI:_DrawSquareButton, become code

 *

 *

 *************************************<->***********************************/

void _XmDrawSquareButton (Widget w, int x, int y, int size, GC topGC, GC bottomGC, GC centerGC, 

#if NeedWidePrototypes

int fill)

#else

Boolean fill)

#endif /* NeedWidePrototypes */

{

   _XmDrawShadow (XtDisplay (w), XtWindow (w), 

                  topGC, bottomGC,

                  2, x, y, size, size);

   if (fill)

       if (size > 6)

           XFillRectangle (XtDisplay ((Widget) w), 

                           XtWindow ((Widget) w),

                           centerGC, 

                           ((fill) ? x+2 : x+3),

                           ((fill) ? y+2 : y+3),

                           ((fill) ? size-4 : size-6),

                           ((fill) ? size-4 : size-6));

} 

/************************************************************************

 *

 *  ToggleBI:DrawDiamondButton, become XmDrawDiamond

 *

 *      The diamond drawing routine.  Used in place of  widgets or gadgets

 *      draw routine when toggleButton's indicatorType is one_of_many.

 *

 ************************************************************************/

void _XmDrawDiamondButton (Widget tw, int x, int y, int size, GC topGC, GC bottomGC, GC centerGC, 

#if NeedWidePrototypes

int fill )

#else

Boolean fill)

#endif /* NeedWidePrototypes */

{

   XSegment seg[12];

   XPoint   pt[5];

   int midX, midY;

   if (size % 2 == 0)

      size--;

   midX = x + (size + 1) / 2;

   midY = y + (size + 1) / 2;

   /* COUNTER REVERSE DRAWING EFFECT ON TINY ToggleButtonS */

   if (size <= 3)

    {

       /*  The top shadow segments  */

       seg[0].x1 = x + size - 1;        /*  1  */

       seg[0].y1 = midY - 1;

       seg[0].x2 = midX - 1;            /*  2  */

       seg[0].y2 = y + size - 1;

       seg[1].x1 = x + size - 2;        /*  3  */

       seg[1].y1 = midY - 1;

       seg[1].x2 = midX - 1;            /*  4  */

       seg[1].y2 = y + size - 2;

       seg[2].x1 = x + size - 3;        /*  3  */

       seg[2].y1 = midY - 1;

       seg[2].x2 = midX - 1;            /*  4  */

       seg[2].y2 = y + size - 3;

       /*--*/

       seg[3].x1 = midX - 1;            /*  5  */

       seg[3].y1 = y + size - 1;

       seg[3].x2 = x;                   /*  6  */

       seg[3].y2 = midY - 1;

       seg[4].x1 = midX - 1;            /*  7  */

       seg[4].y1 = y + size - 2;

       seg[4].x2 = x + 1;               /*  8  */

       seg[4].y2 = midY - 1;

       seg[5].x1 = midX - 1;            /*  7  */

       seg[5].y1 = y + size - 3;

       seg[5].x2 = x + 2;               /*  8  */

       seg[5].y2 = midY - 1;

       /*  The bottom shadow segments  */

       seg[6].x1 = x + size - 1;        /*  9  */

       seg[6].y1 = midY - 1;

       seg[6].x2 = midX - 1;            /*  10  */

       seg[6].y2 = y;

       seg[7].x1 = x + size - 2;        /*  11  */

       seg[7].y1 = midY - 1;

       seg[7].x2 = midX - 1;            /*  12  */

       seg[7].y2 = y + 1;

       seg[8].x1 = x + size - 3;        /*  11  */

       seg[8].y1 = midY - 1;

       seg[8].x2 = midX - 1;            /*  12  */

       seg[8].y2 = y + 2;

       /*--*/

       seg[9].x1 = midX - 1;            /*  13  */

       seg[9].y1 = y;

       seg[9].x2 = x;                   /*  14  */

       seg[9].y2 = midY - 1;

       seg[10].x1 = midX - 1;           /*  15  */

       seg[10].y1 = y + 1;

       seg[10].x2 = x + 1;              /*  16  */

       seg[10].y2 = midY - 1;

       seg[11].x1 = midX - 1;           /*  15  */

       seg[11].y1 = y + 2;

       seg[11].x2 = x + 2;              /*  16  */

       seg[11].y2 = midY - 1;

    }

  else    /* NORMAL SIZED ToggleButtonS */

    {

       /*  The top shadow segments  */

       seg[0].x1 = x;                   /*  1  */

       seg[0].y1 = midY - 1;

       seg[0].x2 = midX - 1;            /*  2  */

       seg[0].y2 = y;

       seg[1].x1 = x + 1;               /*  3  */

       seg[1].y1 = midY - 1;

       seg[1].x2 = midX - 1;            /*  4  */

       seg[1].y2 = y + 1;

       seg[2].x1 = x + 2;               /*  3  */

       seg[2].y1 = midY - 1;

       seg[2].x2 = midX - 1;            /*  4  */

       seg[2].y2 = y + 2;

       /*--*/

       seg[3].x1 = midX - 1;            /*  5  */

       seg[3].y1 = y;

       seg[3].x2 = x + size - 1;        /*  6  */

       seg[3].y2 = midY - 1;

       seg[4].x1 = midX - 1;            /*  7  */

       seg[4].y1 = y + 1;

       seg[4].x2 = x + size - 2;        /*  8  */

       seg[4].y2 = midY - 1;

       seg[5].x1 = midX - 1;            /*  7  */

       seg[5].y1 = y + 2;

       seg[5].x2 = x + size - 3;        /*  8  */

       seg[5].y2 = midY - 1;

       /*  The bottom shadow segments  */

       seg[6].x1 = x;                   /*  9  */

       seg[6].y1 = midY - 1;

       seg[6].x2 = midX - 1;            /*  10  */

       seg[6].y2 = y + size - 1;

       seg[7].x1 = x + 1;               /*  11  */

       seg[7].y1 = midY - 1;

       seg[7].x2 = midX - 1;            /*  12  */

       seg[7].y2 = y + size - 2;

       seg[8].x1 = x + 2;               /*  11  */

       seg[8].y1 = midY - 1;

       seg[8].x2 = midX - 1;            /*  12  */

       seg[8].y2 = y + size - 3;

       /*--*/

       seg[9].x1 = midX - 1;            /*  13  */

       seg[9].y1 = y + size - 1;

       seg[9].x2 = x + size - 1;        /*  14  */

       seg[9].y2 = midY - 1;

       seg[10].x1 = midX - 1;           /*  15  */

       seg[10].y1 = y + size - 2;

       seg[10].x2 = x + size - 2;       /*  16  */

       seg[10].y2 = midY - 1;

       seg[11].x1 = midX - 1;           /*  15  */

       seg[11].y1 = y + size - 3;

       seg[11].x2 = x + size - 3;       /*  16  */

       seg[11].y2 = midY - 1;

    }

   XDrawSegments (XtDisplay ((Widget) tw), XtWindow ((Widget) tw),

                  topGC, &seg[3], 3);

   XDrawSegments (XtDisplay ((Widget) tw), XtWindow ((Widget) tw),

                  bottomGC, &seg[6], 6);