motif_l/xtabbed.c

   1 /* ***********************************************************************
   2  * This module implements a motif tabbed window widget.
   3  * The source is copied from the Free Widget Foundation
   4  * This file is divided into thse parts
   5  *      o - Conversion routines for the X resource manager
   6  *      o - Routines for drawing rotated text
   7  *      o - A motif widget for tabbed windows
   8  *      o - A driver for the above in the flavor of the xt utilities module
   9  * ***********************************************************************
  10  */
  11
  12 \f
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <Xm/Xm.h>
  17 #include <Xm/Form.h>
  18 #include <Xm/RowColumn.h>
  19 #include <X11/StringDefs.h>
  20 #include <X11/IntrinsicP.h>
  21 #if defined(VMS_HOST)
  22 #include <DECW$INCLUDE/shape.h>
  23 #else
  24 #include <X11/extensions/shape.h>
  25 #endif
  26 #include <X11/Xlib.h>
  27 #include <X11/Xutil.h>
  28 #include <X11/Xatom.h>
  29 #include <math.h>
  30
  31 \f
  32 /* ***********************************************************************
  33  * "rotated.h"
  34  * ***********************************************************************
  35  */
  36
  37 /* ************************************************************************ */
  38
  39
  40 /* Header file for the `xvertext 5.0' routines.
  41
  42    Copyright (c) 1993 Alan Richardson (mppa3@uk.ac.sussex.syma) */
  43
  44
  45 /* ************************************************************************ */
  46
  47 #ifndef _XVERTEXT_INCLUDED_
  48 #define _XVERTEXT_INCLUDED_
  49
  50
  51 #define XV_VERSION      5.0
  52 #define XV_COPYRIGHT \
  53       "xvertext routines Copyright (c) 1993 Alan Richardson"
  54
  55
  56 /* ---------------------------------------------------------------------- */
  57
  58
  59 /* text alignment */
  60
  61 #define NONE             0
  62 #define TLEFT            1
  63 #define TCENTRE          2
  64 #define TRIGHT           3
  65 #define MLEFT            4
  66 #define MCENTRE          5
  67 #define MRIGHT           6
  68 #define BLEFT            7
  69 #define BCENTRE          8
  70 #define BRIGHT           9
  71
  72
  73 /* ---------------------------------------------------------------------- */
  74
  75 /* this shoulf be C++ compliant, thanks to
  76      vlp@latina.inesc.pt (Vasco Lopes Paulo) */
  77
  78 #if defined(__cplusplus) || defined(c_plusplus)
  79
  80 extern "C" {
  81 static float   XRotVersion(char*, int);
  82 static void    XRotSetMagnification(float);
  83 static void    XRotSetBoundingBoxPad(int);
  84 static int     XRotDrawString(Display*, XFontStruct*, float,
  85                        Drawable, GC, int, int, char*);
  86 static int     XRotDrawImageString(Display*, XFontStruct*, float,
  87                             Drawable, GC, int, int, char*);
  88 static int     XRotDrawAlignedString(Display*, XFontStruct*, float,
  89                               Drawable, GC, int, int, char*, int);
  90 static int     XRotDrawAlignedImageString(Display*, XFontStruct*, float,
  91                                    Drawable, GC, int, int, char*, int);
  92 static XPoint *XRotTextExtents(Display*, XFontStruct*, float,
  93                         int, int, char*, int);
  94 }
  95
  96 #else
  97
  98 static float   XRotVersion(char *str, int n);
  99 static void    XRotSetMagnification(float m);
 100 static void    XRotSetBoundingBoxPad(int p);
 101 static int     XRotDrawString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str);
 102 static int     XRotDrawImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str);
 103 static int     XRotDrawAlignedString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align);
 104 static int     XRotDrawAlignedImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align);
 105 static XPoint *XRotTextExtents(Display *dpy, XFontStruct *font, float angle, int x, int y, char *text, int align);
 106
 107 #endif /* __cplusplus */
 108
 109 /* ---------------------------------------------------------------------- */
 110
 111
 112 #endif /* _XVERTEXT_INCLUDED_ */
 113
 114
 115
 116 \f
 117 /* ***********************************************************************
 118  * "strarray.h"
 119  * ***********************************************************************
 120  */
 121
 122 #ifndef _strarray_h_
 123 #define _strarray_h_
 124 /*
 125    StringArray
 126    ===========
 127    The type |StringArray| represents an array of |String|s, with the
 128    proviso that by convention the last member of a |StringArray| is
 129    always a |NULL| pointer. There is a converter that can construct a
 130    |StringArray| from a single string.
 131
 132
 133    cvtStringToStringArray
 134    ======================
 135    The converter from |String| to |StringArray| makes a copy of the
 136    passed string and then replaces all occurences of the delimiter
 137    with a nul byte. The |StringArray| is filled with pointers to the
 138    parts of the string.
 139
 140    The delimiter character is the first character in the string.
 141
 142
 143    newStringArray
 144    ==============
 145    The function |newStringArray| makes a copy of a |StringArray|. It
 146    allocates new space for the array itself and for the strings that
 147    it contains.
 148
 149
 150    freeStringArray
 151    ===============
 152    |freeStringArray| deallocates the array and all strings it
 153    contains. Note that this works for StringArrays produced with
 154    |newStringArray|, but not for those created by
 155    |cvtStringToStringArray|!
 156
 157 */
 158
 159
 160 typedef String * StringArray;
 161
 162 static Boolean cvtStringToStringArray(
 163 #if NeedFunctionPrototypes
 164     Display *display,
 165     XrmValuePtr args,
 166     Cardinal *num_args,
 167     XrmValuePtr from,
 168     XrmValuePtr to,
 169     XtPointer *converter_data
 170 #endif
 171 );
 172
 173
 174 StringArray newStringArray(
 175 #if NeedFunctionPrototypes
 176     StringArray a
 177 #endif
 178 );
 179
 180
 181 void freeStringArray(
 182 #if NeedFunctionPrototypes
 183     StringArray a
 184 #endif
 185 );
 186
 187
 188 #endif /* _strarray_h_ */
 189
 190 \f
 191 /* ***********************************************************************
 192  * "XmTabs.h"
 193  * ***********************************************************************
 194  */
 195
 196 /* Generated by wbuild from "XmTabs.w"
 197 ** (generator version $Revision: 8.5 $ of $Date: 2001/06/25 15:19:28 $)
 198 */
 199 #ifndef _XmTabs_H_
 200 #define _XmTabs_H_
 201 typedef enum {
 202             XfwfUpTabs, XfwfDownTabs, XfwfLeftTabs, XfwfRightTabs,
 203         } TabsOrientation;
 204
 205 #ifndef XtNorientation
 206 #define XtNorientation "orientation"
 207 #endif
 208 #ifndef XtCOrientation
 209 #define XtCOrientation "Orientation"
 210 #endif
 211 #ifndef XtRTabsOrientation
 212 #define XtRTabsOrientation "TabsOrientation"
 213 #endif
 214
 215 #ifndef XtNlefttabs
 216 #define XtNlefttabs "lefttabs"
 217 #endif
 218 #ifndef XtCLefttabs
 219 #define XtCLefttabs "Lefttabs"
 220 #endif
 221 #ifndef XtRInt
 222 #define XtRInt "Int"
 223 #endif
 224
 225 #ifndef XtNrighttabs
 226 #define XtNrighttabs "righttabs"
 227 #endif
 228 #ifndef XtCRighttabs
 229 #define XtCRighttabs "Righttabs"
 230 #endif
 231 #ifndef XtRInt
 232 #define XtRInt "Int"
 233 #endif
 234
 235 #ifndef XtNlabels
 236 #define XtNlabels "labels"
 237 #endif
 238 #ifndef XtCLabels
 239 #define XtCLabels "Labels"
 240 #endif
 241 #ifndef XtRStringArray
 242 #define XtRStringArray "StringArray"
 243 #endif
 244
 245 #ifndef XtNtabWidthPercentage
 246 #define XtNtabWidthPercentage "tabWidthPercentage"
 247 #endif
 248 #ifndef XtCTabWidthPercentage
 249 #define XtCTabWidthPercentage "TabWidthPercentage"
 250 #endif
 251 #ifndef XtRInt
 252 #define XtRInt "Int"
 253 #endif
 254
 255 #ifndef XtNcornerwidth
 256 #define XtNcornerwidth "cornerwidth"
 257 #endif
 258 #ifndef XtCCornerwidth
 259 #define XtCCornerwidth "Cornerwidth"
 260 #endif
 261 #ifndef XtRCardinal
 262 #define XtRCardinal "Cardinal"
 263 #endif
 264
 265 #ifndef XtNcornerheight
 266 #define XtNcornerheight "cornerheight"
 267 #endif
 268 #ifndef XtCCornerheight
 269 #define XtCCornerheight "Cornerheight"
 270 #endif
 271 #ifndef XtRCardinal
 272 #define XtRCardinal "Cardinal"
 273 #endif
 274
 275 #ifndef XtNtextmargin
 276 #define XtNtextmargin "textmargin"
 277 #endif
 278 #ifndef XtCTextmargin
 279 #define XtCTextmargin "Textmargin"
 280 #endif
 281 #ifndef XtRInt
 282 #define XtRInt "Int"
 283 #endif
 284
 285 #ifndef XtNtabcolor
 286 #define XtNtabcolor "tabcolor"
 287 #endif
 288 #ifndef XtCTabcolor
 289 #define XtCTabcolor "Tabcolor"
 290 #endif
 291 #ifndef XtRPixel
 292 #define XtRPixel "Pixel"
 293 #endif
 294
 295 #ifndef XtNfont
 296 #define XtNfont "font"
 297 #endif
 298 #ifndef XtCFont
 299 #define XtCFont "Font"
 300 #endif
 301 #ifndef XtRFontStruct
 302 #define XtRFontStruct "FontStruct"
 303 #endif
 304
 305 #ifndef XtNactivateCallback
 306 #define XtNactivateCallback "activateCallback"
 307 #endif
 308 #ifndef XtCActivateCallback
 309 #define XtCActivateCallback "ActivateCallback"
 310 #endif
 311 #ifndef XtRCallback
 312 #define XtRCallback "Callback"
 313 #endif
 314
 315 typedef struct _XmTabsClassRec *XmTabsWidgetClass;
 316 typedef struct _XmTabsRec *XmTabsWidget;
 317 #endif /*_XmTabs_H_*/
 318
 319 \f
 320 /* ***********************************************************************
 321  * "XmTabsP.h"
 322  * ***********************************************************************
 323  */
 324
 325 /* Generated by wbuild from "XmTabs.w"
 326 ** (generator version $Revision: 8.5 $ of $Date: 2001/06/25 15:19:28 $)
 327 */
 328 #ifndef _XmTabsP_H_
 329 #define _XmTabsP_H_
 330
 331 /* raz modified 22 Jul 96 for bluestone */
 332 #include <Xm/XmP.h>
 333 #if ! defined(MGR_ShadowThickness)
 334 #include <Xm/ManagerP.h>
 335 #endif
 336
 337 typedef void (*border_highlight_Proc)(
 338 #if NeedFunctionPrototypes
 339 void
 340 #endif
 341 );
 342 #define XtInherit_border_highlight ((border_highlight_Proc) _XtInherit)
 343 typedef void (*border_unhighlight_Proc)(
 344 #if NeedFunctionPrototypes
 345 void
 346 #endif
 347 );
 348 #define XtInherit_border_unhighlight ((border_unhighlight_Proc) _XtInherit)
 349 typedef struct {
 350 /* Constraint resources */
 351 /* Private constraint variables */
 352 int dummy;
 353 } XmTabsConstraintPart;
 354
 355 typedef struct _XmTabsConstraintRec {
 356 XmManagerConstraintPart xmManager;
 357 XmTabsConstraintPart xmTabs;
 358 } XmTabsConstraintRec;
 359
 360
 361 typedef struct {
 362 /* methods */
 363 border_highlight_Proc border_highlight;
 364 border_unhighlight_Proc border_unhighlight;
 365 /* class variables */
 366 } XmTabsClassPart;
 367
 368 typedef struct _XmTabsClassRec {
 369 CoreClassPart core_class;
 370 CompositeClassPart composite_class;
 371 ConstraintClassPart constraint_class;
 372 XmManagerClassPart xmManager_class;
 373 XmTabsClassPart xmTabs_class;
 374 } XmTabsClassRec;
 375
 376 typedef struct {
 377 /* resources */
 378 TabsOrientation  orientation;
 379 int  lefttabs;
 380 int  righttabs;
 381 StringArray  labels;
 382 int  tabWidthPercentage;
 383 Cardinal  cornerwidth;
 384 Cardinal  cornerheight;
 385 int  textmargin;
 386 Pixel  tabcolor;
 387 XFontStruct * font;
 388 XtCallbackList  activateCallback;
 389 /* private state */
 390 GC  textgc;
 391 GC  topgc;
 392 GC  bottomgc;
 393 GC  backgc;
 394 GC  fillgc;
 395 int * tabwidths;
 396 int * offsets;
 397 } XmTabsPart;
 398
 399 typedef struct _XmTabsRec {
 400 CorePart core;
 401 CompositePart composite;
 402 ConstraintPart constraint;
 403 XmManagerPart xmManager;
 404 XmTabsPart xmTabs;
 405 } XmTabsRec;
 406
 407 #endif /* _XmTabsP_H_ */
 408
 409 \f
 410 /* ***********************************************************************
 411  * A motif widget for tabbed windows
 412  * ***********************************************************************
 413  */
 414
 415 static void activate(
 416 #if NeedFunctionPrototypes
 417 Widget,XEvent*,String*,Cardinal*
 418 #endif
 419 );
 420
 421 static XtActionsRec actionsList[] = {
 422 {"activate", activate},
 423 };
 424
 425 static char defaultTranslations[] = "\
 426 <Btn1Down>,<Btn1Up>: activate() \n\
 427 ";
 428 static void _resolve_inheritance(
 429 #if NeedFunctionPrototypes
 430 WidgetClass
 431 #endif
 432 );
 433 static void class_initialize(
 434 #if NeedFunctionPrototypes
 435 void
 436 #endif
 437 );
 438 static void initialize(
 439 #if NeedFunctionPrototypes
 440 Widget ,Widget,ArgList ,Cardinal *
 441 #endif
 442 );
 443 static Boolean  set_values(
 444 #if NeedFunctionPrototypes
 445 Widget ,Widget ,Widget,ArgList ,Cardinal *
 446 #endif
 447 );
 448 static void realize(
 449 #if NeedFunctionPrototypes
 450 Widget,XtValueMask *,XSetWindowAttributes *
 451 #endif
 452 );
 453 static void resize(
 454 #if NeedFunctionPrototypes
 455 Widget
 456 #endif
 457 );
 458 static void expose(
 459 #if NeedFunctionPrototypes
 460 Widget,XEvent *,Region
 461 #endif
 462 );
 463 static void border_highlight(
 464 #if NeedFunctionPrototypes
 465 void
 466 #endif
 467 );
 468 static void border_unhighlight(
 469 #if NeedFunctionPrototypes
 470 void
 471 #endif
 472 );
 473 static void destroy(
 474 #if NeedFunctionPrototypes
 475 Widget
 476 #endif
 477 );
 478 #define min(a, b) ((a )<(b )?(a ):(b ))
 479
 480
 481 #define abs(x) ((x )<0 ?-(x ):(x ))
 482
 483
 484 static void compute_tabsizes(
 485 #if NeedFunctionPrototypes
 486 Widget
 487 #endif
 488 );
 489 static void comp_hor_tab_shape(
 490 #if NeedFunctionPrototypes
 491 Widget,int ,XPoint  p[12],int *,int *,int *
 492 #endif
 493 );
 494 static void comp_ver_tab_shape(
 495 #if NeedFunctionPrototypes
 496 Widget,int ,XPoint  p[12],int *,int *,int *
 497 #endif
 498 );
 499 static void draw_border(
 500 #if NeedFunctionPrototypes
 501 Widget,XPoint  poly[12]
 502 #endif
 503 );
 504 static void draw_hor_tab(
 505 #if NeedFunctionPrototypes
 506 Widget,Region ,int
 507 #endif
 508 );
 509 static void draw_ver_tab(
 510 #if NeedFunctionPrototypes
 511 Widget,Region ,int
 512 #endif
 513 );
 514 static void create_topgc(
 515 #if NeedFunctionPrototypes
 516 Widget
 517 #endif
 518 );
 519 static void create_bottomgc(
 520 #if NeedFunctionPrototypes
 521 Widget
 522 #endif
 523 );
 524 static void create_textgc(
 525 #if NeedFunctionPrototypes
 526 Widget
 527 #endif
 528 );
 529 static void create_fillgc(
 530 #if NeedFunctionPrototypes
 531 Widget
 532 #endif
 533 );
 534 static void create_backgc(
 535 #if NeedFunctionPrototypes
 536 Widget
 537 #endif
 538 );
 539 static void copy_bg(
 540 #if NeedFunctionPrototypes
 541 Widget,int ,XrmValue *
 542 #endif
 543 );
 544 static void set_shape(
 545 #if NeedFunctionPrototypes
 546 Widget
 547 #endif
 548 );
 549 #define done(type, value) do {\
 550         if (to->addr != NULL) {\
 551             if (to->size < sizeof(type)) {\
 552                 to->size = sizeof(type);\
 553                 return False;\
 554             }\
 555             *(type*)(to->addr) = (value);\
 556         } else {\
 557             static type static_val;\
 558             static_val = (value);\
 559             to->addr = (XtPointer)&static_val;\
 560         }\
 561         to->size = sizeof(type);\
 562         return True;\
 563     }while (0 )
 564
 565
 566 static Boolean  cvtStringToTabsOrientation(
 567 #if NeedFunctionPrototypes
 568 Display *,XrmValuePtr ,Cardinal *,XrmValuePtr ,XrmValuePtr ,XtPointer *
 569 #endif
 570 );
 571 static Boolean  cvtTabsOrientationToString(
 572 #if NeedFunctionPrototypes
 573 Display *,XrmValuePtr ,Cardinal *,XrmValuePtr ,XrmValuePtr ,XtPointer *
 574 #endif
 575 );
 576 /*ARGSUSED*/
 577 #if NeedFunctionPrototypes
 578 static void compute_tabsizes(Widget self)
 579 #else
 580 static void compute_tabsizes(self)Widget self;
 581 #endif
 582 {
 583     int maxwd, basewidth, delta, i, n = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs + 1;
 584     int sum, len, h, length, breadth, shad = ((XmTabsWidget)self)->xmManager.shadow_thickness;
 585
 586     if (((XmTabsWidget)self)->xmTabs.offsets) XtFree((XtPointer) ((XmTabsWidget)self)->xmTabs.offsets);
 587     if (((XmTabsWidget)self)->xmTabs.tabwidths) XtFree((XtPointer) ((XmTabsWidget)self)->xmTabs.tabwidths);
 588     ((XmTabsWidget)self)->xmTabs.offsets = (XtPointer) XtMalloc(n * sizeof(*((XmTabsWidget)self)->xmTabs.offsets));
 589     ((XmTabsWidget)self)->xmTabs.tabwidths = (XtPointer) XtMalloc(n * sizeof(*((XmTabsWidget)self)->xmTabs.tabwidths));
 590
 591     if (((XmTabsWidget)self)->xmTabs.orientation == XfwfUpTabs || ((XmTabsWidget)self)->xmTabs.orientation == XfwfDownTabs) {
 592         length = ((XmTabsWidget)self)->core.width;
 593         breadth = ((XmTabsWidget)self)->core.height;
 594     } else {
 595         length = ((XmTabsWidget)self)->core.height;
 596         breadth = ((XmTabsWidget)self)->core.width;
 597     }
 598     if (((XmTabsWidget)self)->xmTabs.tabWidthPercentage != 0) {         /* Fixed width tabs */
 599         basewidth = ((XmTabsWidget)self)->xmTabs.tabWidthPercentage * length/100;
 600         if (n > 1) delta = (length - basewidth)/(((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs);
 601         for (i = 0; i < n; i++) {
 602             ((XmTabsWidget)self)->xmTabs.tabwidths[i] = basewidth;
 603             ((XmTabsWidget)self)->xmTabs.offsets[i] = i * delta;
 604         }
 605     } else if (((XmTabsWidget)self)->xmTabs.labels == NULL) {           /* Empty tabs */
 606         basewidth = length/n;
 607         delta = (length - basewidth)/(((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs);
 608         for (i = 0; i < n; i++) {
 609             ((XmTabsWidget)self)->xmTabs.tabwidths[i] = basewidth;
 610             ((XmTabsWidget)self)->xmTabs.offsets[i] = i * delta;
 611         }
 612     } else {                                    /* Variable width tabs */
 613         sum = 0;
 614         h = 2 * (((XmTabsWidget)self)->xmTabs.cornerwidth + shad + ((XmTabsWidget)self)->xmTabs.textmargin);
 615         maxwd = length - n * (shad + ((XmTabsWidget)self)->xmTabs.textmargin);
 616         for (i = 0; i < n; i++) {
 617             len = strlen(((XmTabsWidget)self)->xmTabs.labels[i]);
 618             ((XmTabsWidget)self)->xmTabs.tabwidths[i] = min(maxwd, XTextWidth(((XmTabsWidget)self)->xmTabs.font,((XmTabsWidget)self)->xmTabs.labels[i],len) + h);
 619             sum += ((XmTabsWidget)self)->xmTabs.tabwidths[i];
 620         }
 621         ((XmTabsWidget)self)->xmTabs.offsets[0] = 0;
 622         if (length >= sum)
 623             delta = (length - sum)/(n - 1);     /* Between tabs */
 624         else
 625             delta = -((sum - length + n - 2)/(n - 1)); /* Round down! */
 626         for (i = 1; i < n; i++)
 627             ((XmTabsWidget)self)->xmTabs.offsets[i] = ((XmTabsWidget)self)->xmTabs.offsets[i-1] + ((XmTabsWidget)self)->xmTabs.tabwidths[i-1] + delta;
 628     }
 629 }
 630 /*ARGSUSED*/
 631 #if NeedFunctionPrototypes
 632 static void comp_hor_tab_shape(Widget self,int  i,XPoint  p[12],int * x0,int * x1,int * midy)
 633 #else
 634 static void comp_hor_tab_shape(self,i,p,x0,x1,midy)Widget self;int  i;XPoint  p[12];int * x0;int * x1;int * midy;
 635 #endif
 636 {
 637     int shad = ((XmTabsWidget)self)->xmManager.shadow_thickness;
 638     int k = min(((XmTabsWidget)self)->xmTabs.cornerheight, (((XmTabsWidget)self)->core.height - shad)/2);
 639     /*
 640      *                4 o-------------o 5
 641      *                 /               \
 642      *              3 o                 o 6
 643      *                |                 |
 644      *              2 o                 o 7
 645      *             1 /                   \ 8
 646      *   0 o--------o                     o--------o 9
 647      *  11 o---------------------------------------o 10
 648      *
 649      *  11 o---------------------------------------o 10
 650      *   0 o--------o                     o--------o 9
 651      *             1 \                   / 8
 652      *              2 o                 o 7
 653      *                |                 |
 654      *              3 o                 o 6
 655      *                 \               /
 656      *                4 o-------------o 5
 657      */
 658     p[0].x = 0;
 659     p[1].x = ((XmTabsWidget)self)->xmTabs.offsets[i];
 660     p[2].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.cornerwidth;
 661     p[3].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.cornerwidth;
 662     p[4].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + 2 * ((XmTabsWidget)self)->xmTabs.cornerwidth;
 663     p[5].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - 2 * ((XmTabsWidget)self)->xmTabs.cornerwidth;
 664     p[6].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - ((XmTabsWidget)self)->xmTabs.cornerwidth;
 665     p[7].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - ((XmTabsWidget)self)->xmTabs.cornerwidth;
 666     p[8].x = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i];
 667     p[9].x = ((XmTabsWidget)self)->core.width;
 668     p[10].x = ((XmTabsWidget)self)->core.width;
 669     p[11].x = 0;
 670
 671     if (((XmTabsWidget)self)->xmTabs.orientation == XfwfUpTabs) {
 672         p[0].y = ((XmTabsWidget)self)->core.height - shad;
 673         p[1].y = ((XmTabsWidget)self)->core.height - shad;
 674         p[2].y = ((XmTabsWidget)self)->core.height - shad - k;
 675         p[3].y = k;
 676         p[4].y = 0;
 677         p[5].y = 0;
 678         p[6].y = k;
 679         p[7].y = ((XmTabsWidget)self)->core.height - shad - k;
 680         p[8].y = ((XmTabsWidget)self)->core.height - shad;
 681         p[9].y = ((XmTabsWidget)self)->core.height - shad;
 682         p[10].y = ((XmTabsWidget)self)->core.height;
 683         p[11].y = ((XmTabsWidget)self)->core.height;
 684     } else {
 685         p[0].y = shad;
 686         p[1].y = shad;
 687         p[2].y = shad + k;
 688         p[3].y = ((XmTabsWidget)self)->core.height - k;
 689         p[4].y = ((XmTabsWidget)self)->core.height;
 690         p[5].y = ((XmTabsWidget)self)->core.height;
 691         p[6].y = ((XmTabsWidget)self)->core.height - k;
 692         p[7].y = shad + k;
 693         p[8].y = shad;
 694         p[9].y = shad;
 695         p[10].y = 0;
 696         p[11].y = 0;
 697     }
 698     *x0 = p[4].x;
 699     *x1 = p[5].x;
 700     *midy = (p[1].y + p[4].y)/2;
 701 }
 702 /*ARGSUSED*/
 703 #if NeedFunctionPrototypes
 704 static void comp_ver_tab_shape(Widget self,int  i,XPoint  p[12],int * y0,int * y1,int * midx)
 705 #else
 706 static void comp_ver_tab_shape(self,i,p,y0,y1,midx)Widget self;int  i;XPoint  p[12];int * y0;int * y1;int * midx;
 707 #endif
 708 {
 709     int shad = ((XmTabsWidget)self)->xmManager.shadow_thickness;
 710     int k = min(((XmTabsWidget)self)->xmTabs.cornerheight, (((XmTabsWidget)self)->core.width - shad)/2);
 711     /*
 712      *       0 o_o 11  11 o_o 0
 713      *         | |        | |
 714      *       1 o |        | o 1
 715      *     3 2/  |        |  \2 3
 716      *     o-o   |        |   o-o
 717      *    /      |        |      \
 718      * 4 o       |        |       o 4
 719      *   |       |        |       |
 720      * 5 o       |        |       o 5
 721      *    \      |        |      /
 722      *     o-o   |        |   o-o
 723      *     6 7\  |        |  /7 6
 724      *       8 o |        | o 8
 725      *         | |        | |
 726      *       9 o_o 10  10 o_o 9
 727      */
 728     if (((XmTabsWidget)self)->xmTabs.orientation == XfwfLeftTabs) {
 729         p[0].x = ((XmTabsWidget)self)->core.width - shad;
 730         p[1].x = ((XmTabsWidget)self)->core.width - shad;
 731         p[2].x = ((XmTabsWidget)self)->core.width - shad - k;
 732         p[3].x = k;
 733         p[4].x = 0;
 734         p[5].x = 0;
 735         p[6].x = k;
 736         p[7].x = ((XmTabsWidget)self)->core.width - shad - k;
 737         p[8].x = ((XmTabsWidget)self)->core.width - shad;
 738         p[9].x = ((XmTabsWidget)self)->core.width - shad;
 739         p[10].x = ((XmTabsWidget)self)->core.width;
 740         p[11].x = ((XmTabsWidget)self)->core.width;
 741     } else {
 742         p[0].x = shad;
 743         p[1].x = shad;
 744         p[2].x = shad + k;
 745         p[3].x = ((XmTabsWidget)self)->core.width - k;
 746         p[4].x = ((XmTabsWidget)self)->core.width;
 747         p[5].x = ((XmTabsWidget)self)->core.width;
 748         p[6].x = ((XmTabsWidget)self)->core.width - k;
 749         p[7].x = shad + k;
 750         p[8].x = shad;
 751         p[9].x = shad;
 752         p[10].x = 0;
 753         p[11].x = 0;
 754     }
 755     p[0].y = 0;
 756     p[1].y = ((XmTabsWidget)self)->xmTabs.offsets[i];
 757     p[2].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.cornerwidth;
 758     p[3].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.cornerwidth;
 759     p[4].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + 2 * ((XmTabsWidget)self)->xmTabs.cornerwidth;
 760     p[5].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - 2 * ((XmTabsWidget)self)->xmTabs.cornerwidth;
 761     p[6].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - ((XmTabsWidget)self)->xmTabs.cornerwidth;
 762     p[7].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i] - ((XmTabsWidget)self)->xmTabs.cornerwidth;
 763     p[8].y = ((XmTabsWidget)self)->xmTabs.offsets[i] + ((XmTabsWidget)self)->xmTabs.tabwidths[i];
 764     p[9].y = ((XmTabsWidget)self)->core.height;
 765     p[10].y = ((XmTabsWidget)self)->core.height;
 766     p[11].y = 0;
 767     *y0 = p[4].y;
 768     *y1 = p[5].y;
 769     *midx = (p[1].x + p[4].x)/2;
 770 }
 771 /*ARGSUSED*/
 772 #if NeedFunctionPrototypes
 773 static void draw_border(Widget self,XPoint  poly[12])
 774 #else
 775 static void draw_border(self,poly)Widget self;XPoint  poly[12];
 776 #endif
 777 {
 778     Display *dpy = XtDisplay(self);
 779     Window win = XtWindow(self);
 780
 781     if (((XmTabsWidget)self)->xmTabs.orientation == XfwfUpTabs) {
 782         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.topgc, poly, 6, CoordModeOrigin);
 783         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.bottomgc, poly + 5, 4, CoordModeOrigin);
 784         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.topgc, poly + 8, 2, CoordModeOrigin);
 785     } else {
 786         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.bottomgc, poly, 2, CoordModeOrigin);
 787         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.topgc, poly + 1, 4, CoordModeOrigin);
 788         XDrawLines(dpy, win, ((XmTabsWidget)self)->xmTabs.bottomgc, poly + 4, 6, CoordModeOrigin);
 789     }
 790 }
 791 /*ARGSUSED*/
 792 #if NeedFunctionPrototypes
 793 static void draw_hor_tab(Widget self,Region  region,int  i)
 794 #else
 795 static void draw_hor_tab(self,region,i)Widget self;Region  region;int  i;
 796 #endif
 797 {
 798     XPoint p[12];
 799     Display *dpy = XtDisplay(self);
 800     Window win = XtWindow(self);
 801     Region clip;
 802     int x0, x1, midy;
 803
 804     comp_hor_tab_shape(self, i, p, &x0, &x1, &midy);
 805     clip = XPolygonRegion(p, XtNumber(p), WindingRule);
 806     if (region) XIntersectRegion(clip, region, clip);
 807     if (XEmptyRegion(clip)) return;
 808
 809     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.textgc, clip);
 810     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.topgc, clip);
 811     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.bottomgc, clip);
 812     if (i == ((XmTabsWidget)self)->xmTabs.lefttabs) {
 813         XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.backgc, clip);
 814         XFillPolygon(dpy, win, ((XmTabsWidget)self)->xmTabs.backgc,
 815                      p, XtNumber(p), Convex, CoordModeOrigin);
 816     } else {
 817         XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.fillgc, clip);
 818         XFillPolygon(dpy, win, ((XmTabsWidget)self)->xmTabs.fillgc,
 819                      p, XtNumber(p), Convex, CoordModeOrigin);
 820     }
 821     if (((XmTabsWidget)self)->xmTabs.labels) {
 822         int w, y, x, len = strlen(((XmTabsWidget)self)->xmTabs.labels[i]);
 823         y = midy - (((XmTabsWidget)self)->xmTabs.font->ascent + ((XmTabsWidget)self)->xmTabs.font->descent)/2 + ((XmTabsWidget)self)->xmTabs.font->ascent;
 824         w = XTextWidth(((XmTabsWidget)self)->xmTabs.font, ((XmTabsWidget)self)->xmTabs.labels[i], len);
 825         if (i == ((XmTabsWidget)self)->xmTabs.lefttabs
 826             || ((XmTabsWidget)self)->xmTabs.tabWidthPercentage <= 100/(((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs + 1))
 827             x = (x0 + x1 - w)/2;                /* Centered text */
 828         else if (i < ((XmTabsWidget)self)->xmTabs.lefttabs)
 829             x = x0 + ((XmTabsWidget)self)->xmTabs.textmargin;           /* Left aligned text */
 830         else
 831             x = x1 - ((XmTabsWidget)self)->xmTabs.textmargin - w;               /* Right aligned text */
 832         XDrawString(dpy, win, ((XmTabsWidget)self)->xmTabs.textgc, x, y, ((XmTabsWidget)self)->xmTabs.labels[i], len);
 833     }
 834     draw_border(self, p);
 835     XDestroyRegion(clip);
 836 }
 837 /*ARGSUSED*/
 838 #if NeedFunctionPrototypes
 839 static void draw_ver_tab(Widget self,Region  region,int  i)
 840 #else
 841 static void draw_ver_tab(self,region,i)Widget self;Region  region;int  i;
 842 #endif
 843 {
 844     Display *dpy = XtDisplay(self);
 845     Window win = XtWindow(self);
 846     XPoint p[12];
 847     Region clip;
 848     int y0, y1, midx;
 849
 850     comp_ver_tab_shape(self, i, p, &y0, &y1, &midx);
 851     clip = XPolygonRegion(p, XtNumber(p), WindingRule);
 852     if (region) XIntersectRegion(clip, region, clip);
 853     if (XEmptyRegion(clip)) return;
 854
 855     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.textgc, clip);
 856     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.topgc, clip);
 857     XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.bottomgc, clip);
 858     if (i == ((XmTabsWidget)self)->xmTabs.lefttabs) {
 859         XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.backgc, clip);
 860         XFillPolygon(dpy, win, ((XmTabsWidget)self)->xmTabs.backgc,
 861                      p, XtNumber(p), Convex, CoordModeOrigin);
 862     } else {
 863         XSetRegion(dpy, ((XmTabsWidget)self)->xmTabs.fillgc, clip);
 864         XFillPolygon(dpy, win, ((XmTabsWidget)self)->xmTabs.fillgc,
 865                      p, XtNumber(p), Convex, CoordModeOrigin);
 866     }
 867     if (((XmTabsWidget)self)->xmTabs.labels) {
 868         int y, align;
 869         float angle = ((XmTabsWidget)self)->xmTabs.orientation == XfwfLeftTabs ? 90.0 : -90.0;
 870         if (i == ((XmTabsWidget)self)->xmTabs.lefttabs
 871             || ((XmTabsWidget)self)->xmTabs.tabWidthPercentage <= 100/(((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs + 1)) {
 872             y = (y0 + y1)/2;
 873             align = MCENTRE;
 874         } else if (i < ((XmTabsWidget)self)->xmTabs.lefttabs) {
 875             y = y0 + ((XmTabsWidget)self)->xmTabs.textmargin;
 876             align = ((XmTabsWidget)self)->xmTabs.orientation == XfwfLeftTabs ? MRIGHT : MLEFT;
 877         } else {
 878             y = y1 - ((XmTabsWidget)self)->xmTabs.textmargin;
 879             align = ((XmTabsWidget)self)->xmTabs.orientation == XfwfLeftTabs ? MLEFT : MRIGHT;
 880         }
 881         XRotDrawAlignedString
 882             (dpy, ((XmTabsWidget)self)->xmTabs.font, angle, win, ((XmTabsWidget)self)->xmTabs.textgc, midx, y, ((XmTabsWidget)self)->xmTabs.labels[i], align);
 883     }
 884     draw_border(self, p);
 885     XDestroyRegion(clip);
 886 }
 887 /*ARGSUSED*/
 888 #if NeedFunctionPrototypes
 889 static void create_topgc(Widget self)
 890 #else
 891 static void create_topgc(self)Widget self;
 892 #endif
 893 {
 894     XtGCMask mask = GCForeground | GCLineWidth;
 895     XGCValues values;
 896
 897     if (((XmTabsWidget)self)->xmTabs.topgc != NULL) XFreeGC(XtDisplay(self), ((XmTabsWidget)self)->xmTabs.topgc);
 898     values.foreground = ((XmTabsWidget)self)->xmManager.top_shadow_color;
 899     values.line_width = 2 * ((XmTabsWidget)self)->xmManager.shadow_thickness;
 900     ((XmTabsWidget)self)->xmTabs.topgc = XCreateGC(XtDisplay(self), RootWindowOfScreen(XtScreen(self)),
 901                        mask, &values);
 902 }
 903 /*ARGSUSED*/
 904 #if NeedFunctionPrototypes
 905 static void create_bottomgc(Widget self)
 906 #else
 907 static void create_bottomgc(self)Widget self;
 908 #endif
 909 {
 910     XtGCMask mask = GCForeground | GCLineWidth;
 911     XGCValues values;
 912
 913     if (((XmTabsWidget)self)->xmTabs.bottomgc != NULL) XFreeGC(XtDisplay(self), ((XmTabsWidget)self)->xmTabs.bottomgc);
 914     values.foreground = ((XmTabsWidget)self)->xmManager.bottom_shadow_color;
 915     values.line_width = 2 * ((XmTabsWidget)self)->xmManager.shadow_thickness;
 916     ((XmTabsWidget)self)->xmTabs.bottomgc = XCreateGC(XtDisplay(self), RootWindowOfScreen(XtScreen(self)),
 917                           mask, &values);
 918 }
 919 /*ARGSUSED*/
 920 #if NeedFunctionPrototypes
 921 static void create_textgc(Widget self)
 922 #else
 923 static void create_textgc(self)Widget self;
 924 #endif
 925 {
 926     XtGCMask mask = GCForeground | GCFont;
 927     XGCValues values;
 928
 929     if (((XmTabsWidget)self)->xmTabs.textgc != NULL) XFreeGC(XtDisplay(self), ((XmTabsWidget)self)->xmTabs.textgc);
 930     values.foreground = ((XmTabsWidget)self)->xmManager.foreground;
 931     values.font = ((XmTabsWidget)self)->xmTabs.font->fid;
 932     ((XmTabsWidget)self)->xmTabs.textgc = XCreateGC(XtDisplay(self), RootWindowOfScreen(XtScreen(self)),
 933                         mask, &values);
 934 }
 935 /*ARGSUSED*/
 936 #if NeedFunctionPrototypes
 937 static void create_fillgc(Widget self)
 938 #else
 939 static void create_fillgc(self)Widget self;
 940 #endif
 941 {
 942     XtGCMask mask = GCForeground;
 943     XGCValues values;
 944
 945     if (((XmTabsWidget)self)->xmTabs.fillgc != NULL) XFreeGC(XtDisplay(self), ((XmTabsWidget)self)->xmTabs.fillgc);
 946     values.foreground = ((XmTabsWidget)self)->xmTabs.tabcolor;
 947     ((XmTabsWidget)self)->xmTabs.fillgc = XCreateGC(XtDisplay(self), RootWindowOfScreen(XtScreen(self)),
 948                         mask, &values);
 949 }
 950 /*ARGSUSED*/
 951 #if NeedFunctionPrototypes
 952 static void create_backgc(Widget self)
 953 #else
 954 static void create_backgc(self)Widget self;
 955 #endif
 956 {
 957     XtGCMask mask = GCForeground;
 958     XGCValues values;
 959
 960     if (((XmTabsWidget)self)->xmTabs.backgc != NULL) XFreeGC(XtDisplay(self), ((XmTabsWidget)self)->xmTabs.backgc);
 961     values.foreground = ((XmTabsWidget)self)->core.background_pixel;
 962     ((XmTabsWidget)self)->xmTabs.backgc = XCreateGC(XtDisplay(self), RootWindowOfScreen(XtScreen(self)),
 963                         mask, &values);
 964 }
 965 /*ARGSUSED*/
 966 #if NeedFunctionPrototypes
 967 static void copy_bg(Widget self,int  offset,XrmValue * value)
 968 #else
 969 static void copy_bg(self,offset,value)Widget self;int  offset;XrmValue * value;
 970 #endif
 971 {
 972     value->addr = (XtPointer) &((XmTabsWidget)self)->core.background_pixel;
 973 }
 974 /*ARGSUSED*/
 975 #if NeedFunctionPrototypes
 976 static void set_shape(Widget self)
 977 #else
 978 static void set_shape(self)Widget self;
 979 #endif
 980 {
 981     int x0, x1, midy, y0, y1, midx, i;
 982     Region region, clip;
 983     XPoint poly[12];
 984
 985     if (! XtIsRealized(self)) return;
 986
 987     region = XCreateRegion();
 988
 989     switch (((XmTabsWidget)self)->xmTabs.orientation) {
 990     case XfwfUpTabs:
 991     case XfwfDownTabs:
 992         for (i = 0; i <= ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i++) {
 993             comp_hor_tab_shape(self, i, poly, &x0, &x1, &midy);
 994             clip = XPolygonRegion(poly, XtNumber(poly), WindingRule);
 995             XUnionRegion(region, clip, region);
 996             XDestroyRegion(clip);
 997         }
 998         break;
 999     case XfwfLeftTabs:
1000     case XfwfRightTabs:
1001         for (i = 0; i <= ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i++) {
1002             comp_ver_tab_shape(self, i, poly, &y0, &y1, &midx);
1003             clip = XPolygonRegion(poly, XtNumber(poly), WindingRule);
1004             XUnionRegion(region, clip, region);
1005             XDestroyRegion(clip);
1006         }
1007         break;
1008     }
1009     XShapeCombineRegion(XtDisplay(self), XtWindow(self), ShapeBounding,
1010                         0, 0, region, ShapeSet);
1011     XDestroyRegion(region);
1012 }
1013
1014 /*ARGSUSED*/
1015 #if NeedFunctionPrototypes
1016 static Boolean  cvtStringToTabsOrientation(Display * display,XrmValuePtr  args,Cardinal * num_args,XrmValuePtr  from,XrmValuePtr  to,XtPointer * converter_data)
1017 #else
1018 static Boolean  cvtStringToTabsOrientation(display,args,num_args,from,to,converter_data)Display * display;XrmValuePtr  args;Cardinal * num_args;XrmValuePtr  from;XrmValuePtr  to;XtPointer * converter_data;
1019 #endif
1020 {
1021     TabsOrientation a = XfwfUpTabs;
1022     char *s = (char*) from->addr;
1023     static struct {
1024         char *name;
1025         TabsOrientation orient;
1026     } strings[] = {
1027         { "up",  XfwfUpTabs },
1028         { "uptabs",  XfwfUpTabs },
1029         { "down",  XfwfDownTabs },
1030         { "downtabs",  XfwfDownTabs },
1031         { "left",  XfwfLeftTabs },
1032         { "lefttabs",  XfwfLeftTabs },
1033         { "right",  XfwfRightTabs },
1034         { "righttabs",  XfwfRightTabs },
1035     };
1036     int i;
1037
1038     if (*num_args != 0)
1039         XtAppErrorMsg
1040             (XtDisplayToApplicationContext(display),
1041              "cvtStringToTabsOrientation", "wrongParameters", "XtToolkitError",
1042              "String to TabsOrientation conversion needs no arguments",
1043              (String*) NULL, (Cardinal*) NULL);
1044
1045     for (i=0; i<XtNumber(strings); i++)
1046         if ( strcmp( s, strings[i].name ) == 0 ) {
1047             a |= strings[i].orient;
1048             break;
1049     }
1050
1051     if ( i >= XtNumber(strings) )
1052         XtDisplayStringConversionWarning(display, s, "TabsOrientation");
1053     done(TabsOrientation, a);
1054 }
1055 /*ARGSUSED*/
1056 #if NeedFunctionPrototypes
1057 static Boolean  cvtTabsOrientationToString(Display * display,XrmValuePtr  args,Cardinal * num_args,XrmValuePtr  from,XrmValuePtr  to,XtPointer * converter_data)
1058 #else
1059 static Boolean  cvtTabsOrientationToString(display,args,num_args,from,to,converter_data)Display * display;XrmValuePtr  args;Cardinal * num_args;XrmValuePtr  from;XrmValuePtr  to;XtPointer * converter_data;
1060 #endif
1061 {
1062     TabsOrientation *a = (TabsOrientation*) from->addr;
1063
1064     if (*num_args != 0)
1065         XtAppErrorMsg
1066             (XtDisplayToApplicationContext(display),
1067              "cvtTabsOrientationToString", "wrongParameters", "XtToolkitError",
1068              "TabsOrientation to String conversion needs no arguments",
1069              (String*) NULL, (Cardinal*) NULL);
1070     switch (*a) {
1071     case XfwfUpTabs: done(String, "up");
1072     case XfwfDownTabs: done(String, "down");
1073     case XfwfLeftTabs: done(String, "left");
1074     case XfwfRightTabs: done(String, "right");
1075     }
1076     XtAppErrorMsg
1077         (XtDisplayToApplicationContext(display),
1078          "cvtTabsOrientationToString", "illParameters", "XtToolkitError",
1079              "TabsOrientation to String conversion got illegal argument",
1080              (String*) NULL, (Cardinal*) NULL);
1081     return TRUE;
1082 }
1083
1084 static XtResource resources[] = {
1085 {XtNorientation,XtCOrientation,XtRTabsOrientation,sizeof(((XmTabsRec*)NULL)->xmTabs.orientation),XtOffsetOf(XmTabsRec,xmTabs.orientation),XtRImmediate,(XtPointer)XfwfUpTabs },
1086 {XtNlefttabs,XtCLefttabs,XtRInt,sizeof(((XmTabsRec*)NULL)->xmTabs.lefttabs),XtOffsetOf(XmTabsRec,xmTabs.lefttabs),XtRImmediate,(XtPointer)0 },
1087 {XtNrighttabs,XtCRighttabs,XtRInt,sizeof(((XmTabsRec*)NULL)->xmTabs.righttabs),XtOffsetOf(XmTabsRec,xmTabs.righttabs),XtRImmediate,(XtPointer)0 },
1088 {XtNlabels,XtCLabels,XtRStringArray,sizeof(((XmTabsRec*)NULL)->xmTabs.labels),XtOffsetOf(XmTabsRec,xmTabs.labels),XtRImmediate,(XtPointer)NULL },
1089 {XtNtabWidthPercentage,XtCTabWidthPercentage,XtRInt,sizeof(((XmTabsRec*)NULL)->xmTabs.tabWidthPercentage),XtOffsetOf(XmTabsRec,xmTabs.tabWidthPercentage),XtRImmediate,(XtPointer)50 },
1090 {XtNcornerwidth,XtCCornerwidth,XtRCardinal,sizeof(((XmTabsRec*)NULL)->xmTabs.cornerwidth),XtOffsetOf(XmTabsRec,xmTabs.cornerwidth),XtRImmediate,(XtPointer)3 },
1091 {XtNcornerheight,XtCCornerheight,XtRCardinal,sizeof(((XmTabsRec*)NULL)->xmTabs.cornerheight),XtOffsetOf(XmTabsRec,xmTabs.cornerheight),XtRImmediate,(XtPointer)3 },
1092 {XtNtextmargin,XtCTextmargin,XtRInt,sizeof(((XmTabsRec*)NULL)->xmTabs.textmargin),XtOffsetOf(XmTabsRec,xmTabs.textmargin),XtRImmediate,(XtPointer)3 },
1093 {XtNtabcolor,XtCTabcolor,XtRPixel,sizeof(((XmTabsRec*)NULL)->xmTabs.tabcolor),XtOffsetOf(XmTabsRec,xmTabs.tabcolor),XtRCallProc,(XtPointer)copy_bg },
1094 {XtNfont,XtCFont,XtRFontStruct,sizeof(((XmTabsRec*)NULL)->xmTabs.font),XtOffsetOf(XmTabsRec,xmTabs.font),XtRString,(XtPointer)XtDefaultFont },
1095 {XtNactivateCallback,XtCActivateCallback,XtRCallback,sizeof(((XmTabsRec*)NULL)->xmTabs.activateCallback),XtOffsetOf(XmTabsRec,xmTabs.activateCallback),XtRImmediate,(XtPointer)NULL },
1096 };
1097
1098 XmTabsClassRec xmTabsClassRec = {
1099 { /* core_class part */
1100 /* superclass           */  (WidgetClass) &xmManagerClassRec,
1101 /* class_name           */  "XmTabs",
1102 /* widget_size          */  sizeof(XmTabsRec),
1103 /* class_initialize     */  class_initialize,
1104 /* class_part_initialize*/  _resolve_inheritance,
1105 /* class_inited         */  FALSE,
1106 /* initialize           */  initialize,
1107 /* initialize_hook      */  NULL,
1108 /* realize              */  realize,
1109 /* actions              */  actionsList,
1110 /* num_actions          */  1,
1111 /* resources            */  resources,
1112 /* num_resources        */  11,
1113 /* xrm_class            */  NULLQUARK,
1114 /* compres_motion       */  True ,
1115 /* compress_exposure    */  XtExposeCompressMultiple ,
1116 /* compress_enterleave  */  True ,
1117 /* visible_interest     */  False ,
1118 /* destroy              */  destroy,
1119 /* resize               */  resize,
1120 /* expose               */  expose,
1121 /* set_values           */  set_values,
1122 /* set_values_hook      */  NULL,
1123 /* set_values_almost    */  XtInheritSetValuesAlmost,
1124 /* get_values+hook      */  NULL,
1125 /* accept_focus         */  XtInheritAcceptFocus,
1126 /* version              */  XtVersion,
1127 /* callback_private     */  NULL,
1128 /* tm_table             */  defaultTranslations,
1129 /* query_geometry       */  XtInheritQueryGeometry,
1130 /* display_acceleator   */  XtInheritDisplayAccelerator,
1131 /* extension            */  NULL
1132 },
1133 { /* composite_class part */
1134 XtInheritGeometryManager,
1135 XtInheritChangeManaged,
1136 XtInheritInsertChild,
1137 XtInheritDeleteChild,
1138 NULL
1139 },
1140 { /* constraint_class part */
1141 /* constraint_resources     */  NULL,
1142 /* num_constraint_resources */  0,
1143 /* constraint_size          */  sizeof(XmTabsConstraintRec),
1144 /* constraint_initialize    */  NULL,
1145 /* constraint_destroy       */  NULL,
1146 /* constraint_set_values    */  NULL,
1147 /* constraint_extension     */  NULL
1148 },
1149 { /* XmManager class part */
1150 #define manager_extension extension
1151 /* translations                 */  XtInheritTranslations ,
1152 /* syn_resources                */  NULL ,
1153 /* num_syn_resources            */  0 ,
1154 /* syn_constraint_resources     */  NULL ,
1155 /* num_syn_constraint_resources */  0 ,
1156 /* parent_process               */  XmInheritParentProcess,
1157 /* manager_extension            */  NULL ,
1158 },
1159 { /* XmTabs_class part */
1160 border_highlight,
1161 border_unhighlight,
1162 },
1163 };
1164 WidgetClass xmTabsWidgetClass = (WidgetClass) &xmTabsClassRec;
1165 /*ARGSUSED*/
1166 static void activate(Widget self, XEvent *event, String *params, Cardinal *num_params)
1167 {
1168     int x0, x1, dummy, i, x, y;
1169     XPoint poly[12];
1170
1171     switch (((XmTabsWidget)self)->xmTabs.orientation) {
1172     case XfwfUpTabs:
1173     case XfwfDownTabs:
1174         x = event->xbutton.x;
1175         comp_hor_tab_shape(self, ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1176         if (x0 <= x && x < x1) {
1177             XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) 0);
1178             return;
1179         }
1180         for (i = -1; i >= -((XmTabsWidget)self)->xmTabs.lefttabs; i--) {
1181             comp_hor_tab_shape(self, i + ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1182             if (x0 <= x && x < x1) {
1183                 XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) i);
1184                 return;
1185             }
1186         }
1187         for (i = 1; i <= ((XmTabsWidget)self)->xmTabs.righttabs; i++) {
1188             comp_hor_tab_shape(self, i + ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1189             if (x0 <= x && x < x1) {
1190                 XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) i);
1191                 return;
1192             }
1193         }
1194         break;
1195     case XfwfLeftTabs:
1196     case XfwfRightTabs:
1197         y = event->xbutton.y;
1198         comp_ver_tab_shape(self, ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1199         if (x0 <= y && y < x1) {
1200             XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) 0);
1201             return;
1202         }
1203         for (i = -1; i >= -((XmTabsWidget)self)->xmTabs.lefttabs; i--) {
1204             comp_ver_tab_shape(self, i + ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1205             if (x0 <= y && y < x1) {
1206                 XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) i);
1207                 return;
1208             }
1209         }
1210         for (i = 1; i <= ((XmTabsWidget)self)->xmTabs.righttabs; i++) {
1211             comp_ver_tab_shape(self, i + ((XmTabsWidget)self)->xmTabs.lefttabs, poly, &x0, &x1, &dummy);
1212             if (x0 <= y && y < x1) {
1213                 XtCallCallbackList(self, ((XmTabsWidget)self)->xmTabs.activateCallback, (XtPointer) i);
1214                 return;
1215             }
1216         }
1217         break;
1218     }
1219 }
1220
1221 static void _resolve_inheritance(WidgetClass class)
1222 {
1223   XmTabsWidgetClass c = (XmTabsWidgetClass) class;
1224   XmTabsWidgetClass super;
1225   static CompositeClassExtensionRec extension_rec = {
1226     NULL, NULLQUARK, XtCompositeExtensionVersion,
1227     sizeof(CompositeClassExtensionRec), True};
1228   CompositeClassExtensionRec *ext;
1229   ext = (XtPointer)XtMalloc(sizeof(*ext));
1230   *ext = extension_rec;
1231   ext->next_extension = c->composite_class.extension;
1232   c->composite_class.extension = ext;
1233   if (class == xmTabsWidgetClass) return;
1234   super = (XmTabsWidgetClass)class->core_class.superclass;
1235   if (c->xmTabs_class.border_highlight == XtInherit_border_highlight)
1236     c->xmTabs_class.border_highlight = super->xmTabs_class.border_highlight;
1237   if (c->xmTabs_class.border_unhighlight == XtInherit_border_unhighlight)
1238     c->xmTabs_class.border_unhighlight = super->xmTabs_class.border_unhighlight;
1239 }
1240 /*ARGSUSED*/
1241 #if NeedFunctionPrototypes
1242 static void class_initialize(void)
1243 #else
1244 static void class_initialize(void)
1245 #endif
1246 {
1247     XtSetTypeConverter(XtRString, "StringArray",
1248                        cvtStringToStringArray,
1249                        NULL, 0, XtCacheNone, NULL);
1250     XtSetTypeConverter(XtRString, "TabsOrientation",
1251                        cvtStringToTabsOrientation,
1252                        NULL, 0, XtCacheNone, NULL);
1253     XtSetTypeConverter("TabsOrientation", XtRString,
1254                        cvtTabsOrientationToString,
1255                        NULL, 0, XtCacheNone, NULL);
1256 }
1257 /*ARGSUSED*/
1258 #if NeedFunctionPrototypes
1259 static void initialize(Widget  request,Widget self,ArgList  args,Cardinal * num_args)
1260 #else
1261 static void initialize(request,self,args,num_args)Widget  request;Widget self;ArgList  args;Cardinal * num_args;
1262 #endif
1263 {
1264     String *h;
1265     int i;
1266
1267     ((XmTabsWidget)self)->xmManager.traversal_on = FALSE;
1268     ((XmTabsWidget)self)->xmTabs.topgc = NULL;
1269     create_topgc(self);
1270     ((XmTabsWidget)self)->xmTabs.bottomgc = NULL;
1271     create_bottomgc(self);
1272     ((XmTabsWidget)self)->xmTabs.textgc = NULL;
1273     create_textgc(self);
1274     ((XmTabsWidget)self)->xmTabs.fillgc = NULL;
1275     create_fillgc(self);
1276     ((XmTabsWidget)self)->xmTabs.backgc = NULL;
1277     create_backgc(self);
1278     if (((XmTabsWidget)self)->xmTabs.labels) {
1279         h = (String*) XtMalloc((((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs + 1) * sizeof(*h));
1280         for (i = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i >= 0; i--)
1281             h[i] = XtNewString(((XmTabsWidget)self)->xmTabs.labels[i]);
1282         ((XmTabsWidget)self)->xmTabs.labels = h;
1283     }
1284     if (((XmTabsWidget)self)->xmTabs.tabWidthPercentage < 0 || ((XmTabsWidget)self)->xmTabs.tabWidthPercentage > 100) {
1285         XtAppWarning(XtWidgetToApplicationContext(self),
1286                      "tabWidthPercentage out of range; reset to 50");
1287         ((XmTabsWidget)self)->xmTabs.tabWidthPercentage = 50;
1288     }
1289     ((XmTabsWidget)self)->xmTabs.offsets = NULL;
1290     ((XmTabsWidget)self)->xmTabs.tabwidths = NULL;
1291     compute_tabsizes(self);
1292 }
1293 /*ARGSUSED*/
1294 #if NeedFunctionPrototypes
1295 static Boolean  set_values(Widget  old,Widget  request,Widget self,ArgList  args,Cardinal * num_args)
1296 #else
1297 static Boolean  set_values(old,request,self,args,num_args)Widget  old;Widget  request;Widget self;ArgList  args;Cardinal * num_args;
1298 #endif
1299 {
1300     Bool redraw = FALSE, resize_labels = FALSE;
1301     String *h;
1302     int i;
1303
1304     if (((XmTabsWidget)self)->core.background_pixel != ((XmTabsWidget)old)->core.background_pixel
1305         || ((XmTabsWidget)self)->core.background_pixmap != ((XmTabsWidget)old)->core.background_pixmap
1306         || ((XmTabsWidget)self)->xmManager.shadow_thickness != ((XmTabsWidget)old)->xmManager.shadow_thickness) {
1307         create_topgc(self);
1308         create_bottomgc(self);
1309         create_backgc(self);
1310     }
1311     if (((XmTabsWidget)self)->xmManager.foreground != ((XmTabsWidget)old)->xmManager.foreground || ((XmTabsWidget)self)->xmTabs.font != ((XmTabsWidget)old)->xmTabs.font) {
1312         create_textgc(self);
1313         redraw = TRUE;
1314     }
1315     if (((XmTabsWidget)self)->xmTabs.tabcolor != ((XmTabsWidget)old)->xmTabs.tabcolor) {
1316         create_fillgc(self);
1317         redraw = TRUE;
1318     }
1319     if ((((XmTabsWidget)self)->xmTabs.textmargin != ((XmTabsWidget)old)->xmTabs.textmargin && ((XmTabsWidget)self)->xmTabs.tabWidthPercentage == 0)
1320         || ((XmTabsWidget)self)->xmTabs.cornerwidth != ((XmTabsWidget)old)->xmTabs.cornerwidth
1321         || ((XmTabsWidget)self)->xmTabs.cornerheight != ((XmTabsWidget)old)->xmTabs.cornerheight) {
1322         resize_labels = TRUE;
1323     }
1324     if (((XmTabsWidget)self)->xmTabs.labels != ((XmTabsWidget)old)->xmTabs.labels) {
1325         if (((XmTabsWidget)self)->xmTabs.labels) {
1326             h = (String*) XtMalloc((((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs + 1) * sizeof(*h));
1327             for (i = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i >= 0; i--)
1328                 h[i] = XtNewString(((XmTabsWidget)self)->xmTabs.labels[i]);
1329             ((XmTabsWidget)self)->xmTabs.labels = h;
1330         }
1331         if (((XmTabsWidget)old)->xmTabs.labels) {
1332             for (i = ((XmTabsWidget)old)->xmTabs.lefttabs + ((XmTabsWidget)old)->xmTabs.righttabs; i >= 0; i--)
1333                 XtFree(((XmTabsWidget)old)->xmTabs.labels[i]);
1334             XtFree((XtPointer) ((XmTabsWidget)old)->xmTabs.labels);
1335         }
1336         resize_labels = TRUE;
1337     }
1338     if (((XmTabsWidget)self)->xmTabs.tabWidthPercentage < 0 || ((XmTabsWidget)self)->xmTabs.tabWidthPercentage > 100) {
1339         XtAppWarning(XtWidgetToApplicationContext(self),
1340                      "tabWidthPercentage out of range; reset to 50");
1341         ((XmTabsWidget)self)->xmTabs.tabWidthPercentage = 50;
1342     }
1343     if (((XmTabsWidget)old)->xmTabs.tabWidthPercentage != ((XmTabsWidget)self)->xmTabs.tabWidthPercentage)
1344         resize_labels = TRUE;
1345     if (((XmTabsWidget)self)->xmTabs.lefttabs != ((XmTabsWidget)old)->xmTabs.lefttabs || ((XmTabsWidget)self)->xmTabs.righttabs != ((XmTabsWidget)old)->xmTabs.righttabs)
1346         redraw = TRUE;
1347     if (resize_labels) {
1348         compute_tabsizes(self);
1349         redraw = TRUE;
1350     }
1351     return redraw;
1352 }
1353 /*ARGSUSED*/
1354 #if NeedFunctionPrototypes
1355 static void realize(Widget self,XtValueMask * mask,XSetWindowAttributes * attributes)
1356 #else
1357 static void realize(self,mask,attributes)Widget self;XtValueMask * mask;XSetWindowAttributes * attributes;
1358 #endif
1359 {
1360     *mask |= CWBitGravity;
1361     attributes->bit_gravity = ForgetGravity;
1362     xmManagerClassRec.core_class.realize(self, mask, attributes);
1363     set_shape(self);
1364 }
1365 /*ARGSUSED*/
1366 #if NeedFunctionPrototypes
1367 static void resize(Widget self)
1368 #else
1369 static void resize(self)Widget self;
1370 #endif
1371 {
1372     if (XtIsRealized(self))
1373         XClearArea(XtDisplay(self), XtWindow(self), 0, 0, 0, 0, True);
1374     compute_tabsizes(self);
1375     set_shape(self);
1376     if ( xmManagerClassRec.core_class.resize ) xmManagerClassRec.core_class.resize(self);
1377 }
1378 /*ARGSUSED*/
1379 #if NeedFunctionPrototypes
1380 static void expose(Widget self,XEvent * event,Region  region)
1381 #else
1382 static void expose(self,event,region)Widget self;XEvent * event;Region  region;
1383 #endif
1384 {
1385     int i;
1386
1387     if (! XtIsRealized(self)) return;
1388
1389     switch (((XmTabsWidget)self)->xmTabs.orientation) {
1390     case XfwfUpTabs:
1391     case XfwfDownTabs:
1392         for (i = 0; i < ((XmTabsWidget)self)->xmTabs.lefttabs; i++)
1393             draw_hor_tab(self, region, i);
1394         for (i = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i > ((XmTabsWidget)self)->xmTabs.lefttabs; i--)
1395             draw_hor_tab(self, region, i);
1396         draw_hor_tab(self, region, ((XmTabsWidget)self)->xmTabs.lefttabs);
1397         break;
1398     case XfwfLeftTabs:
1399     case XfwfRightTabs:
1400         for (i = 0; i < ((XmTabsWidget)self)->xmTabs.lefttabs; i++)
1401             draw_ver_tab(self, region, i);
1402         for (i = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i > ((XmTabsWidget)self)->xmTabs.lefttabs; i--)
1403             draw_ver_tab(self, region, i);
1404         draw_ver_tab(self, region, ((XmTabsWidget)self)->xmTabs.lefttabs);
1405         break;
1406     }
1407     /* Focus highlight? */
1408 }
1409 /*ARGSUSED*/
1410 #if NeedFunctionPrototypes
1411 static void border_highlight(void)
1412 #else
1413 static void border_highlight(void)
1414 #endif
1415 {
1416 }
1417 /*ARGSUSED*/
1418 #if NeedFunctionPrototypes
1419 static void border_unhighlight(void)
1420 #else
1421 static void border_unhighlight(void)
1422 #endif
1423 {
1424 }
1425 /*ARGSUSED*/
1426 #if NeedFunctionPrototypes
1427 static void destroy(Widget self)
1428 #else
1429 static void destroy(self)Widget self;
1430 #endif
1431 {
1432     int i;
1433
1434     if (((XmTabsWidget)self)->xmTabs.labels) {
1435         for (i = ((XmTabsWidget)self)->xmTabs.lefttabs + ((XmTabsWidget)self)->xmTabs.righttabs; i >= 0; i--)
1436             XtFree(((XmTabsWidget)self)->xmTabs.labels[i]);
1437         XtFree((XtPointer) ((XmTabsWidget)self)->xmTabs.labels);
1438     }
1439     if (((XmTabsWidget)self)->xmTabs.offsets)
1440         XtFree((XtPointer) ((XmTabsWidget)self)->xmTabs.offsets);
1441     if (((XmTabsWidget)self)->xmTabs.tabwidths)
1442         XtFree((XtPointer) ((XmTabsWidget)self)->xmTabs.tabwidths);
1443 }
1444
1445 \f
1446 /* ***********************************************************************
1447  * Routines for drawing rotated text
1448  * ***********************************************************************
1449  */
1450
1451 /* xvertext 5.0, Copyright (c) 1993 Alan Richardson (mppa3@uk.ac.sussex.syma)
1452  *
1453  * Permission to use, copy, modify, and distribute this software and its
1454  * documentation for any purpose and without fee is hereby granted, provided
1455  * that the above copyright notice appear in all copies and that both the
1456  * copyright notice and this permission notice appear in supporting
1457  * documentation.  All work developed as a consequence of the use of
1458  * this program should duly acknowledge such use. No representations are
1459  * made about the suitability of this software for any purpose.  It is
1460  * provided "as is" without express or implied warranty.
1461  *
1462  * 8 Jun '95: [Bert Bos] added GCClipXOrigin|GCClipYOrigin|GCClipMask
1463  * when calling XCopyGC()
1464  */
1465
1466 /* ********************************************************************** */
1467
1468
1469 /* BETTER: xvertext now does rotation at any angle!!
1470  *
1471  * BEWARE: function arguments have CHANGED since version 2.0!!
1472  */
1473
1474 /* ********************************************************************** */
1475
1476
1477
1478 /* ---------------------------------------------------------------------- */
1479
1480
1481 /* Make sure cache size is set */
1482
1483 #ifndef CACHE_SIZE_LIMIT
1484 #define CACHE_SIZE_LIMIT 0
1485 #endif /*CACHE_SIZE_LIMIT */
1486
1487 /* Make sure a cache method is specified */
1488
1489 #ifndef CACHE_XIMAGES
1490 #ifndef CACHE_BITMAPS
1491 #define CACHE_BITMAPS
1492 #endif /*CACHE_BITMAPS*/
1493 #endif /*CACHE_XIMAGES*/
1494
1495
1496 /* ---------------------------------------------------------------------- */
1497
1498
1499 /* Debugging macros */
1500
1501 #ifdef DEBUG
1502 static int debug=1;
1503 #else
1504 static int debug=0;
1505 #endif /*DEBUG*/
1506
1507 #define DEBUG_PRINT1(a) if (debug) printf (a)
1508 #define DEBUG_PRINT2(a, b) if (debug) printf (a, b)
1509 #define DEBUG_PRINT3(a, b, c) if (debug) printf (a, b, c)
1510 #define DEBUG_PRINT4(a, b, c, d) if (debug) printf (a, b, c, d)
1511 #define DEBUG_PRINT5(a, b, c, d, e) if (debug) printf (a, b, c, d, e)
1512
1513
1514 /* ---------------------------------------------------------------------- */
1515
1516
1517 #ifndef M_PI
1518 #define M_PI 3.14159265358979323846
1519 #endif
1520
1521
1522 /* ---------------------------------------------------------------------- */
1523
1524
1525 /* A structure holding everything needed for a rotated string */
1526
1527 typedef struct rotated_text_item_template {
1528     Pixmap bitmap;
1529     XImage *ximage;
1530
1531     char *text;
1532     char *font_name;
1533     Font fid;
1534     float angle;
1535     int align;
1536     float magnify;
1537
1538     int cols_in;
1539     int rows_in;
1540     int cols_out;
1541     int rows_out;
1542
1543     int nl;
1544     int max_width;
1545     float *corners_x;
1546     float *corners_y;
1547
1548     long int size;
1549     int cached;
1550
1551     struct rotated_text_item_template *next;
1552 } RotatedTextItem;
1553
1554 RotatedTextItem *first_text_item=NULL;
1555
1556
1557 /* ---------------------------------------------------------------------- */
1558
1559
1560 /* A structure holding current magnification and bounding box padding */
1561
1562 static struct style_template {
1563     float magnify;
1564     int bbx_pad;
1565 } style={
1566     1.,
1567     0
1568     };
1569
1570
1571 /* ---------------------------------------------------------------------- */
1572
1573
1574 static char            *my_strdup(char *str);
1575 static char            *my_strtok(char *str1, char *str2);
1576
1577 static float                   XRotVersion(char *str, int n);
1578 static void                    XRotSetMagnification(float m);
1579 static void                    XRotSetBoundingBoxPad(int p);
1580 static int                     XRotDrawString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str);
1581 static int                     XRotDrawImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str);
1582 static int                     XRotDrawAlignedString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align);
1583 static int                     XRotDrawAlignedImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align);
1584 static XPoint                 *XRotTextExtents(Display *dpy, XFontStruct *font, float angle, int x, int y, char *text, int align);
1585
1586 static XImage          *MakeXImage(Display *dpy, int w, int h);
1587 static int              XRotPaintAlignedString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align, int bg);
1588 static int              XRotDrawHorizontalString(Display *dpy, XFontStruct *font, Drawable drawable, GC gc, int x, int y, char *text, int align, int bg);
1589 static RotatedTextItem *XRotRetrieveFromCache(Display *dpy, XFontStruct *font, float angle, char *text, int align);
1590 static RotatedTextItem *XRotCreateTextItem(Display *dpy, XFontStruct *font, float angle, char *text, int align);
1591 static void             XRotAddToLinkedList(Display *dpy, RotatedTextItem *item);
1592 static void             XRotFreeTextItem(Display *dpy, RotatedTextItem *item);
1593 static XImage          *XRotMagnifyImage(Display *dpy, XImage *ximage);
1594
1595
1596 /* ---------------------------------------------------------------------- */
1597
1598
1599 /**************************************************************************/
1600 /* Routine to mimic `strdup()' (some machines don't have it)              */
1601 /**************************************************************************/
1602
1603 static char *my_strdup(char *str)
1604 {
1605     char *s;
1606
1607     if(str==NULL)
1608         return NULL;
1609
1610     s=(char *)malloc((unsigned)(strlen(str)+1));
1611     if(s!=NULL)
1612         strcpy(s, str);
1613
1614     return s;
1615 }
1616
1617
1618 /* ---------------------------------------------------------------------- */
1619
1620
1621 /**************************************************************************/
1622 /* Routine to replace `strtok' : this one returns a zero length string if */
1623 /* it encounters two consecutive delimiters                               */
1624 /**************************************************************************/
1625
1626 static char *my_strtok(char *str1, char *str2)
1627 {
1628     char *ret;
1629     int i, j, stop;
1630     static int start, len;
1631     static char *stext;
1632
1633     if(str2==NULL)
1634         return NULL;
1635
1636     /* initialise if str1 not NULL */
1637     if(str1!=NULL) {
1638         start=0;
1639         stext=str1;
1640         len=strlen(str1);
1641     }
1642
1643     /* run out of tokens ? */
1644     if(start>=len)
1645         return NULL;
1646
1647     /* loop through characters */
1648     for(i=start; i<len; i++) {
1649         /* loop through delimiters */
1650         stop=0;
1651         for(j=0; j<strlen(str2); j++)
1652             if(stext[i]==str2[j])
1653                 stop=1;
1654
1655         if(stop)
1656             break;
1657     }
1658
1659     stext[i]='\0';
1660
1661     ret=stext+start;
1662
1663     start=i+1;
1664
1665     return ret;
1666 }
1667
1668
1669 /* ---------------------------------------------------------------------- */
1670
1671
1672 /**************************************************************************/
1673 /* Return version/copyright information                                   */
1674 /**************************************************************************/
1675 static
1676 float XRotVersion(char *str, int n)
1677 {
1678     if(str!=NULL)
1679         strncpy(str, XV_COPYRIGHT, n);
1680     return XV_VERSION;
1681 }
1682
1683
1684 /* ---------------------------------------------------------------------- */
1685
1686
1687 /**************************************************************************/
1688 /* Set the font magnification factor for all subsequent operations        */
1689 /**************************************************************************/
1690 static
1691 void XRotSetMagnification(float m)
1692 {
1693     if(m>0.)
1694         style.magnify=m;
1695 }
1696
1697
1698 /* ---------------------------------------------------------------------- */
1699
1700
1701 /**************************************************************************/
1702 /* Set the padding used when calculating bounding boxes                   */
1703 /**************************************************************************/
1704 static
1705 void XRotSetBoundingBoxPad(int p)
1706 {
1707     if(p>=0)
1708         style.bbx_pad=p;
1709 }
1710
1711
1712 /* ---------------------------------------------------------------------- */
1713
1714
1715 /**************************************************************************/
1716 /*  Create an XImage structure and allocate memory for it                 */
1717 /**************************************************************************/
1718
1719 static XImage *MakeXImage(Display *dpy, int w, int h)
1720 {
1721     XImage *I;
1722     char *data;
1723
1724     /* reserve memory for image */
1725     data=(char *)calloc((unsigned)(((w-1)/8+1)*h), 1);
1726     if(data==NULL)
1727         return NULL;
1728
1729     /* create the XImage */
1730     I=XCreateImage(dpy, DefaultVisual(dpy, DefaultScreen(dpy)), 1, XYBitmap,
1731                    0, data, w, h, 8, 0);
1732     if(I==NULL)
1733         return NULL;
1734
1735     I->byte_order=I->bitmap_bit_order=MSBFirst;
1736     return I;
1737 }
1738
1739
1740 /* ---------------------------------------------------------------------- */
1741
1742
1743 /**************************************************************************/
1744 /*  A front end to XRotPaintAlignedString:                                */
1745 /*      -no alignment, no background                                      */
1746 /**************************************************************************/
1747 static
1748 int XRotDrawString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str)
1749 {
1750     return (XRotPaintAlignedString(dpy, font, angle, drawable, gc,
1751                                    x, y, str, NONE, 0));
1752 }
1753
1754
1755 /* ---------------------------------------------------------------------- */
1756
1757
1758 /**************************************************************************/
1759 /*  A front end to XRotPaintAlignedString:                                */
1760 /*      -no alignment, paints background                                  */
1761 /**************************************************************************/
1762 static
1763 int XRotDrawImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *str)
1764 {
1765     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
1766                                   x, y, str, NONE, 1));
1767 }
1768
1769
1770 /* ---------------------------------------------------------------------- */
1771
1772
1773 /**************************************************************************/
1774 /*  A front end to XRotPaintAlignedString:                                */
1775 /*      -does alignment, no background                                    */
1776 /**************************************************************************/
1777 static
1778 int XRotDrawAlignedString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align)
1779 {
1780     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
1781                                   x, y, text, align, 0));
1782 }
1783
1784
1785 /* ---------------------------------------------------------------------- */
1786
1787
1788 /**************************************************************************/
1789 /*  A front end to XRotPaintAlignedString:                                */
1790 /*      -does alignment, paints background                                */
1791 /**************************************************************************/
1792 static
1793 int XRotDrawAlignedImageString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align)
1794 {
1795     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
1796                                   x, y, text, align, 1));
1797 }
1798
1799
1800 /* ---------------------------------------------------------------------- */
1801
1802
1803 /**************************************************************************/
1804 /*  Aligns and paints a rotated string                                    */
1805 /**************************************************************************/
1806
1807 static int XRotPaintAlignedString(Display *dpy, XFontStruct *font, float angle, Drawable drawable, GC gc, int x, int y, char *text, int align, int bg)
1808 {
1809     int i;
1810     GC my_gc;
1811     int xp, yp;
1812     float hot_x, hot_y;
1813     float hot_xp, hot_yp;
1814     float sin_angle, cos_angle;
1815     RotatedTextItem *item;
1816     Pixmap bitmap_to_paint;
1817
1818     /* return early for NULL/empty strings */
1819     if(text==NULL)
1820         return 0;
1821
1822     if(strlen(text)==0)
1823         return 0;
1824
1825     /* manipulate angle to 0<=angle<360 degrees */
1826     while(angle<0)
1827         angle+=360;
1828
1829     while(angle>=360)
1830         angle-=360;
1831
1832     angle*=M_PI/180;
1833
1834     /* horizontal text made easy */
1835     if(angle==0. && style.magnify==1.)
1836         return(XRotDrawHorizontalString(dpy, font, drawable, gc, x, y,
1837                                         text, align, bg));
1838
1839     /* get a rotated bitmap */
1840     item=XRotRetrieveFromCache(dpy, font, angle, text, align);
1841     if(item==NULL)
1842         return NULL;
1843
1844     /* this gc has similar properties to the user's gc */
1845     my_gc=XCreateGC(dpy, drawable, NULL, 0);
1846     XCopyGC(dpy, gc, GCForeground|GCBackground|GCFunction|GCPlaneMask
1847             |GCClipXOrigin|GCClipYOrigin|GCClipMask, my_gc);
1848
1849     /* alignment : which point (hot_x, hot_y) relative to bitmap centre
1850        coincides with user's specified point? */
1851
1852     /* y position */
1853     if(align==TLEFT || align==TCENTRE || align==TRIGHT)
1854         hot_y=(float)item->rows_in/2*style.magnify;
1855     else if(align==MLEFT || align==MCENTRE || align==MRIGHT)
1856         hot_y=0;
1857     else if(align==BLEFT || align==BCENTRE || align==BRIGHT)
1858         hot_y = -(float)item->rows_in/2*style.magnify;
1859     else
1860         hot_y = -((float)item->rows_in/2-(float)font->descent)*style.magnify;
1861
1862     /* x position */
1863     if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
1864         hot_x = -(float)item->max_width/2*style.magnify;
1865     else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
1866         hot_x=0;
1867     else
1868         hot_x=(float)item->max_width/2*style.magnify;
1869
1870     /* pre-calculate sin and cos */
1871     sin_angle=sin(angle);
1872     cos_angle=cos(angle);
1873
1874     /* rotate hot_x and hot_y around bitmap centre */
1875     hot_xp= hot_x*cos_angle - hot_y*sin_angle;
1876     hot_yp= hot_x*sin_angle + hot_y*cos_angle;
1877
1878     /* text background will be drawn using XFillPolygon */
1879     if(bg) {
1880         GC depth_one_gc;
1881         XPoint *xpoints;
1882         Pixmap empty_stipple;
1883
1884         /* reserve space for XPoints */
1885         xpoints=(XPoint *)malloc((unsigned)(4*item->nl*sizeof(XPoint)));
1886         if(!xpoints)
1887             return 1;
1888
1889         /* rotate corner positions */
1890         for(i=0; i<4*item->nl; i++) {
1891             xpoints[i].x=(float)x + ( (item->corners_x[i]-hot_x)*cos_angle +
1892                                       (item->corners_y[i]+hot_y)*sin_angle);
1893             xpoints[i].y=(float)y + (-(item->corners_x[i]-hot_x)*sin_angle +
1894                                       (item->corners_y[i]+hot_y)*cos_angle);
1895         }
1896
1897         /* we want to swap foreground and background colors here;
1898            XGetGCValues() is only available in R4+ */
1899
1900         empty_stipple=XCreatePixmap(dpy, drawable, 1, 1, 1);
1901
1902         depth_one_gc=XCreateGC(dpy, empty_stipple, NULL, 0);
1903         XSetForeground(dpy, depth_one_gc, 0);
1904         XFillRectangle(dpy, empty_stipple, depth_one_gc, 0, 0, 2, 2);
1905
1906         XSetStipple(dpy, my_gc, empty_stipple);
1907         XSetFillStyle(dpy, my_gc, FillOpaqueStippled);
1908
1909         XFillPolygon(dpy, drawable, my_gc, xpoints, 4*item->nl, Nonconvex,
1910                      CoordModeOrigin);
1911
1912         /* free our resources */
1913         free((char *)xpoints);
1914         XFreeGC(dpy, depth_one_gc);
1915         XFreePixmap(dpy, empty_stipple);
1916     }
1917
1918     /* where should top left corner of bitmap go ? */
1919     xp=(float)x-((float)item->cols_out/2 +hot_xp);
1920     yp=(float)y-((float)item->rows_out/2 -hot_yp);
1921
1922     /* by default we draw the rotated bitmap, solid */
1923     bitmap_to_paint=item->bitmap;
1924
1925     /* handle user stippling */
1926 #ifndef X11R3
1927     {
1928         GC depth_one_gc;
1929         XGCValues values;
1930         Pixmap new_bitmap, inverse;
1931
1932         /* try and get some GC properties */
1933         if(XGetGCValues(dpy, gc,
1934                         GCStipple|GCFillStyle|GCForeground|GCBackground|
1935                         GCTileStipXOrigin|GCTileStipYOrigin,
1936                         &values)) {
1937
1938             /* only do this if stippling requested */
1939             if((values.fill_style==FillStippled ||
1940                 values.fill_style==FillOpaqueStippled) && !bg) {
1941
1942                 /* opaque stipple: draw rotated text in background colour */
1943                 if(values.fill_style==FillOpaqueStippled) {
1944                     XSetForeground(dpy, my_gc, values.background);
1945                     XSetFillStyle(dpy, my_gc, FillStippled);
1946                     XSetStipple(dpy, my_gc, item->bitmap);
1947                     XSetTSOrigin(dpy, my_gc, xp, yp);
1948                     XFillRectangle(dpy, drawable, my_gc, xp, yp,
1949                                    item->cols_out, item->rows_out);
1950                     XSetForeground(dpy, my_gc, values.foreground);
1951                 }
1952
1953                 /* this will merge the rotated text and the user's stipple */
1954                 new_bitmap=XCreatePixmap(dpy, drawable,
1955                                          item->cols_out, item->rows_out, 1);
1956
1957                 /* create a GC */
1958                 depth_one_gc=XCreateGC(dpy, new_bitmap, NULL, 0);
1959                 XSetForeground(dpy, depth_one_gc, 1);
1960                 XSetBackground(dpy, depth_one_gc, 0);
1961
1962                 /* set the relative stipple origin */
1963                 XSetTSOrigin(dpy, depth_one_gc,
1964                              values.ts_x_origin-xp, values.ts_y_origin-yp);
1965
1966                 /* fill the whole bitmap with the user's stipple */
1967                 XSetStipple(dpy, depth_one_gc, values.stipple);
1968                 XSetFillStyle(dpy, depth_one_gc, FillOpaqueStippled);
1969                 XFillRectangle(dpy, new_bitmap, depth_one_gc,
1970                                0, 0, item->cols_out, item->rows_out);
1971
1972                 /* set stipple origin back to normal */
1973                 XSetTSOrigin(dpy, depth_one_gc, 0, 0);
1974
1975                 /* this will contain an inverse copy of the rotated text */
1976                 inverse=XCreatePixmap(dpy, drawable,
1977                                       item->cols_out, item->rows_out, 1);
1978
1979                 /* invert text */
1980                 XSetFillStyle(dpy, depth_one_gc, FillSolid);
1981                 XSetFunction(dpy, depth_one_gc, GXcopyInverted);
1982                 XCopyArea(dpy, item->bitmap, inverse, depth_one_gc,
1983                           0, 0, item->cols_out, item->rows_out, 0, 0);
1984
1985                 /* now delete user's stipple everywhere EXCEPT on text */
1986                 XSetForeground(dpy, depth_one_gc, 0);
1987                 XSetBackground(dpy, depth_one_gc, 1);
1988                 XSetStipple(dpy, depth_one_gc, inverse);
1989                 XSetFillStyle(dpy, depth_one_gc, FillStippled);
1990                 XSetFunction(dpy, depth_one_gc, GXcopy);
1991                 XFillRectangle(dpy, new_bitmap, depth_one_gc,
1992                                0, 0, item->cols_out, item->rows_out);
1993
1994                 /* free resources */
1995                 XFreePixmap(dpy, inverse);
1996                 XFreeGC(dpy, depth_one_gc);
1997
1998                 /* this is the new bitmap */
1999                 bitmap_to_paint=new_bitmap;
2000             }
2001         }
2002     }
2003 #endif /*X11R3*/
2004
2005     /* paint text using stipple technique */
2006     XSetFillStyle(dpy, my_gc, FillStippled);
2007     XSetStipple(dpy, my_gc, bitmap_to_paint);
2008     XSetTSOrigin(dpy, my_gc, xp, yp);
2009     XFillRectangle(dpy, drawable, my_gc, xp, yp,
2010                    item->cols_out, item->rows_out);
2011
2012     /* free our resources */
2013     XFreeGC(dpy, my_gc);
2014
2015     /* stippled bitmap no longer needed */
2016     if(bitmap_to_paint!=item->bitmap)
2017         XFreePixmap(dpy, bitmap_to_paint);
2018
2019 #ifdef CACHE_XIMAGES
2020     XFreePixmap(dpy, item->bitmap);
2021 #endif /*CACHE_XIMAGES*/
2022
2023     /* if item isn't cached, destroy it completely */
2024     if(!item->cached)
2025         XRotFreeTextItem(dpy,item);
2026
2027     /* we got to the end OK! */
2028     return 0;
2029 }
2030
2031
2032 /* ---------------------------------------------------------------------- */
2033
2034
2035 /**************************************************************************/
2036 /*  Draw a horizontal string in a quick fashion                           */
2037 /**************************************************************************/
2038
2039 static int XRotDrawHorizontalString(Display *dpy, XFontStruct *font, Drawable drawable, GC gc, int x, int y, char *text, int align, int bg)
2040 {
2041     GC my_gc;
2042     int nl=1, i;
2043     int height;
2044     int xp, yp;
2045     char *str1, *str2, *str3;
2046     char *str2_a="\0", *str2_b="\n\0";
2047     int dir, asc, desc;
2048     XCharStruct overall;
2049
2050     DEBUG_PRINT1("**\nHorizontal text.\n");
2051
2052     /* this gc has similar properties to the user's gc (including stipple) */
2053     my_gc=XCreateGC(dpy, drawable, NULL, 0);
2054     XCopyGC(dpy, gc,
2055             GCForeground|GCBackground|GCFunction|GCStipple|GCFillStyle|
2056             GCTileStipXOrigin|GCTileStipYOrigin|GCPlaneMask|
2057             GCClipXOrigin|GCClipYOrigin|GCClipMask, my_gc);
2058     XSetFont(dpy, my_gc, font->fid);
2059
2060     /* count number of sections in string */
2061     if(align!=NONE)
2062         for(i=0; i<strlen(text)-1; i++)
2063             if(text[i]=='\n')
2064                 nl++;
2065
2066     /* ignore newline characters if not doing alignment */
2067     if(align==NONE)
2068         str2=str2_a;
2069     else
2070         str2=str2_b;
2071
2072     /* overall font height */
2073     height=font->ascent+font->descent;
2074
2075     /* y position */
2076     if(align==TLEFT || align==TCENTRE || align==TRIGHT)
2077         yp=y+font->ascent;
2078     else if(align==MLEFT || align==MCENTRE || align==MRIGHT)
2079         yp=y-nl*height/2+font->ascent;
2080     else if(align==BLEFT || align==BCENTRE || align==BRIGHT)
2081         yp=y-nl*height+font->ascent;
2082     else
2083         yp=y;
2084
2085     str1=my_strdup(text);
2086     if(str1==NULL)
2087         return 1;
2088
2089     str3=my_strtok(str1, str2);
2090
2091     /* loop through each section in the string */
2092     do {
2093         XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2094                      &overall);
2095
2096         /* where to draw section in x ? */
2097         if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
2098             xp=x;
2099         else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
2100             xp=x-overall.rbearing/2;
2101         else
2102             xp=x-overall.rbearing;
2103
2104         /* draw string onto bitmap */
2105         if(!bg)
2106             XDrawString(dpy, drawable, my_gc, xp, yp, str3, strlen(str3));
2107         else
2108             XDrawImageString(dpy, drawable, my_gc, xp, yp, str3, strlen(str3));
2109
2110         /* move to next line */
2111         yp+=height;
2112
2113         str3=my_strtok((char *)NULL, str2);
2114     }
2115     while(str3!=NULL);
2116
2117     free(str1);
2118     XFreeGC(dpy, my_gc);
2119
2120     return 0;
2121 }
2122
2123
2124 /* ---------------------------------------------------------------------- */
2125
2126
2127 /**************************************************************************/
2128 /*   Query cache for a match with this font/text/angle/alignment          */
2129 /*       request, otherwise arrange for its creation                      */
2130 /**************************************************************************/
2131
2132 static RotatedTextItem *XRotRetrieveFromCache(Display *dpy, XFontStruct *font, float angle, char *text, int align)
2133 {
2134     Font fid;
2135     char *font_name=NULL;
2136     unsigned long name_value;
2137     RotatedTextItem *item=NULL;
2138     RotatedTextItem *i1=first_text_item;
2139
2140     /* get font name, if it exists */
2141     if(XGetFontProperty(font, XA_FONT, &name_value)) {
2142         DEBUG_PRINT1("got font name OK\n");
2143         font_name=XGetAtomName(dpy, name_value);
2144         fid=0;
2145     }
2146 #ifdef CACHE_FID
2147     /* otherwise rely (unreliably?) on font ID */
2148     else {
2149         DEBUG_PRINT1("can't get fontname, caching FID\n");
2150         font_name=NULL;
2151         fid=font->fid;
2152     }
2153 #else
2154     /* not allowed to cache font ID's */
2155     else {
2156         DEBUG_PRINT1("can't get fontname, can't cache\n");
2157         font_name=NULL;
2158         fid=0;
2159     }
2160 #endif /*CACHE_FID*/
2161
2162     /* look for a match in cache */
2163
2164     /* matching formula:
2165        identical text;
2166        identical fontname (if defined, font ID's if not);
2167        angles close enough (<0.00001 here, could be smaller);
2168        HORIZONTAL alignment matches, OR it's a one line string;
2169        magnifications the same */
2170
2171     while(i1 && !item) {
2172         /* match everything EXCEPT fontname/ID */
2173         if(strcmp(text, i1->text)==0 &&
2174            fabs(angle-i1->angle)<0.00001 &&
2175            style.magnify==i1->magnify &&
2176            (i1->nl==1 ||
2177             ((align==0)?9:(align-1))%3==
2178               ((i1->align==0)?9:(i1->align-1))%3)) {
2179
2180             /* now match fontname/ID */
2181             if(font_name!=NULL && i1->font_name!=NULL) {
2182                 if(strcmp(font_name, i1->font_name)==0) {
2183                     item=i1;
2184                     DEBUG_PRINT1("Matched against font names\n");
2185                 }
2186                 else
2187                     i1=i1->next;
2188             }
2189 #ifdef CACHE_FID
2190             else if(font_name==NULL && i1->font_name==NULL) {
2191                 if(fid==i1->fid) {
2192                     item=i1;
2193                     DEBUG_PRINT1("Matched against FID's\n");
2194                 }
2195                 else
2196                     i1=i1->next;
2197             }
2198 #endif /*CACHE_FID*/
2199             else
2200                 i1=i1->next;
2201         }
2202         else
2203             i1=i1->next;
2204     }
2205
2206     if(item)
2207         DEBUG_PRINT1("**\nFound target in cache.\n");
2208     if(!item)
2209         DEBUG_PRINT1("**\nNo match in cache.\n");
2210
2211     /* no match */
2212     if(!item) {
2213         /* create new item */
2214         item=XRotCreateTextItem(dpy, font, angle, text, align);
2215         if(!item)
2216             return NULL;
2217
2218         /* record what it shows */
2219         item->text=my_strdup(text);
2220
2221         /* fontname or ID */
2222         if(font_name!=NULL) {
2223             item->font_name=my_strdup(font_name);
2224             item->fid=0;
2225         }
2226         else {
2227             item->font_name=NULL;
2228             item->fid=fid;
2229         }
2230
2231         item->angle=angle;
2232         item->align=align;
2233         item->magnify=style.magnify;
2234
2235         /* cache it */
2236         XRotAddToLinkedList(dpy, item);
2237     }
2238
2239     if(font_name)
2240         XFree(font_name);
2241
2242     /* if XImage is cached, need to recreate the bitmap */
2243
2244 #ifdef CACHE_XIMAGES
2245     {
2246         GC depth_one_gc;
2247
2248         /* create bitmap to hold rotated text */
2249         item->bitmap=XCreatePixmap(dpy, DefaultRootWindow(dpy),
2250                                    item->cols_out, item->rows_out, 1);
2251
2252         /* depth one gc */
2253         depth_one_gc=XCreateGC(dpy, item->bitmap, NULL, 0);
2254         XSetBackground(dpy, depth_one_gc, 0);
2255         XSetForeground(dpy, depth_one_gc, 1);
2256
2257         /* make the text bitmap from XImage */
2258         XPutImage(dpy, item->bitmap, depth_one_gc, item->ximage, 0, 0, 0, 0,
2259                   item->cols_out, item->rows_out);
2260
2261         XFreeGC(dpy, depth_one_gc);
2262     }
2263 #endif /*CACHE_XIMAGES*/
2264
2265     return item;
2266 }
2267
2268
2269 /* ---------------------------------------------------------------------- */
2270
2271
2272 /**************************************************************************/
2273 /*  Create a rotated text item                                            */
2274 /**************************************************************************/
2275
2276 static RotatedTextItem *XRotCreateTextItem(Display *dpy, XFontStruct *font, float angle, char *text, int align)
2277 {
2278     RotatedTextItem *item=NULL;
2279     Pixmap canvas;
2280     GC font_gc;
2281     XImage *I_in;
2282     register int i, j;
2283     char *str1, *str2, *str3;
2284     char *str2_a="\0", *str2_b="\n\0";
2285     int height;
2286     int byte_w_in, byte_w_out;
2287     int xp, yp;
2288     float sin_angle, cos_angle;
2289     int it, jt;
2290     float di, dj;
2291     int ic=0;
2292     float xl, xr, xinc;
2293     int byte_out;
2294     int dir, asc, desc;
2295     XCharStruct overall;
2296     int old_cols_in=0, old_rows_in=0;
2297
2298     /* allocate memory */
2299     item=(RotatedTextItem *)malloc((unsigned)sizeof(RotatedTextItem));
2300     if(!item)
2301         return NULL;
2302
2303     /* count number of sections in string */
2304     item->nl=1;
2305     if(align!=NONE)
2306         for(i=0; i<strlen(text)-1; i++)
2307             if(text[i]=='\n')
2308                 item->nl++;
2309
2310     /* ignore newline characters if not doing alignment */
2311     if(align==NONE)
2312         str2=str2_a;
2313     else
2314         str2=str2_b;
2315
2316     /* find width of longest section */
2317     str1=my_strdup(text);
2318     if(str1==NULL)
2319         return NULL;
2320
2321     str3=my_strtok(str1, str2);
2322
2323     XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2324                  &overall);
2325
2326     item->max_width=overall.rbearing;
2327
2328     /* loop through each section */
2329     do {
2330         str3=my_strtok((char *)NULL, str2);
2331
2332         if(str3!=NULL) {
2333             XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2334                          &overall);
2335
2336             if(overall.rbearing>item->max_width)
2337                 item->max_width=overall.rbearing;
2338         }
2339     }
2340     while(str3!=NULL);
2341
2342     free(str1);
2343
2344     /* overall font height */
2345     height=font->ascent+font->descent;
2346
2347     /* dimensions horizontal text will have */
2348     item->cols_in=item->max_width;
2349     item->rows_in=item->nl*height;
2350
2351     /* bitmap for drawing on */
2352     canvas=XCreatePixmap(dpy, DefaultRootWindow(dpy),
2353                          item->cols_in, item->rows_in, 1);
2354
2355     /* create a GC for the bitmap */
2356     font_gc=XCreateGC(dpy, canvas, NULL, 0);
2357     XSetBackground(dpy, font_gc, 0);
2358     XSetFont(dpy, font_gc, font->fid);
2359
2360     /* make sure the bitmap is blank */
2361     XSetForeground(dpy, font_gc, 0);
2362     XFillRectangle(dpy, canvas, font_gc, 0, 0,
2363                    item->cols_in+1, item->rows_in+1);
2364     XSetForeground(dpy, font_gc, 1);
2365
2366     /* pre-calculate sin and cos */
2367     sin_angle=sin(angle);
2368     cos_angle=cos(angle);
2369
2370     /* text background will be drawn using XFillPolygon */
2371     item->corners_x=
2372         (float *)malloc((unsigned)(4*item->nl*sizeof(float)));
2373     if(!item->corners_x)
2374         return NULL;
2375
2376     item->corners_y=
2377         (float *)malloc((unsigned)(4*item->nl*sizeof(float)));
2378     if(!item->corners_y)
2379         return NULL;
2380
2381     /* draw text horizontally */
2382
2383     /* start at top of bitmap */
2384     yp=font->ascent;
2385
2386     str1=my_strdup(text);
2387     if(str1==NULL)
2388         return NULL;
2389
2390     str3=my_strtok(str1, str2);
2391
2392     /* loop through each section in the string */
2393     do {
2394         XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2395                 &overall);
2396
2397         /* where to draw section in x ? */
2398         if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
2399             xp=0;
2400         else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
2401             xp=(item->max_width-overall.rbearing)/2;
2402         else
2403             xp=item->max_width-overall.rbearing;
2404
2405         /* draw string onto bitmap */
2406         XDrawString(dpy, canvas, font_gc, xp, yp, str3, strlen(str3));
2407
2408         /* keep a note of corner positions of this string */
2409         item->corners_x[ic]=((float)xp-(float)item->cols_in/2)*style.magnify;
2410         item->corners_y[ic]=((float)(yp-font->ascent)-(float)item->rows_in/2)
2411             *style.magnify;
2412         item->corners_x[ic+1]=item->corners_x[ic];
2413         item->corners_y[ic+1]=item->corners_y[ic]+(float)height*style.magnify;
2414         item->corners_x[item->nl*4-1-ic]=item->corners_x[ic]+
2415             (float)overall.rbearing*style.magnify;
2416         item->corners_y[item->nl*4-1-ic]=item->corners_y[ic];
2417         item->corners_x[item->nl*4-2-ic]=
2418             item->corners_x[item->nl*4-1-ic];
2419         item->corners_y[item->nl*4-2-ic]=item->corners_y[ic+1];
2420
2421         ic+=2;
2422
2423         /* move to next line */
2424         yp+=height;
2425
2426         str3=my_strtok((char *)NULL, str2);
2427     }
2428     while(str3!=NULL);
2429
2430     free(str1);
2431
2432     /* create image to hold horizontal text */
2433     I_in=MakeXImage(dpy, item->cols_in, item->rows_in);
2434     if(I_in==NULL)
2435         return NULL;
2436
2437     /* extract horizontal text */
2438     XGetSubImage(dpy, canvas, 0, 0, item->cols_in, item->rows_in,
2439                  1, XYPixmap, I_in, 0, 0);
2440     I_in->format=XYBitmap;
2441
2442     /* magnify horizontal text */
2443     if(style.magnify!=1.) {
2444         I_in=XRotMagnifyImage(dpy, I_in);
2445
2446         old_cols_in=item->cols_in;
2447         old_rows_in=item->rows_in;
2448         item->cols_in=(float)item->cols_in*style.magnify;
2449         item->rows_in=(float)item->rows_in*style.magnify;
2450     }
2451
2452     /* how big will rotated text be ? */
2453     item->cols_out=fabs((float)item->rows_in*sin_angle) +
2454         fabs((float)item->cols_in*cos_angle) +0.99999 +2;
2455
2456     item->rows_out=fabs((float)item->rows_in*cos_angle) +
2457         fabs((float)item->cols_in*sin_angle) +0.99999 +2;
2458
2459     if(item->cols_out%2==0)
2460         item->cols_out++;
2461
2462     if(item->rows_out%2==0)
2463         item->rows_out++;
2464
2465     /* create image to hold rotated text */
2466     item->ximage=MakeXImage(dpy, item->cols_out, item->rows_out);
2467     if(item->ximage==NULL)
2468         return NULL;
2469
2470     byte_w_in=(item->cols_in-1)/8+1;
2471     byte_w_out=(item->cols_out-1)/8+1;
2472
2473     /* we try to make this bit as fast as possible - which is why it looks
2474        a bit over-the-top */
2475
2476     /* vertical distance from centre */
2477     dj=0.5-(float)item->rows_out/2;
2478
2479     /* where abouts does text actually lie in rotated image? */
2480     if(angle==0 || angle==M_PI/2 ||
2481        angle==M_PI || angle==3*M_PI/2) {
2482         xl=0;
2483         xr=(float)item->cols_out;
2484         xinc=0;
2485     }
2486     else if(angle<M_PI) {
2487         xl=(float)item->cols_out/2+
2488             (dj-(float)item->rows_in/(2*cos_angle))/
2489                 tan(angle)-2;
2490         xr=(float)item->cols_out/2+
2491             (dj+(float)item->rows_in/(2*cos_angle))/
2492                 tan(angle)+2;
2493         xinc=1./tan(angle);
2494     }
2495     else {
2496         xl=(float)item->cols_out/2+
2497             (dj+(float)item->rows_in/(2*cos_angle))/
2498                 tan(angle)-2;
2499         xr=(float)item->cols_out/2+
2500             (dj-(float)item->rows_in/(2*cos_angle))/
2501                 tan(angle)+2;
2502
2503         xinc=1./tan(angle);
2504     }
2505
2506     /* loop through all relevent bits in rotated image */
2507     for(j=0; j<item->rows_out; j++) {
2508
2509         /* no point re-calculating these every pass */
2510         di=(float)((xl<0)?0:(int)xl)+0.5-(float)item->cols_out/2;
2511         byte_out=(item->rows_out-j-1)*byte_w_out;
2512
2513         /* loop through meaningful columns */
2514         for(i=((xl<0)?0:(int)xl);
2515             i<((xr>=item->cols_out)?item->cols_out:(int)xr); i++) {
2516
2517             /* rotate coordinates */
2518             it=(float)item->cols_in/2 + ( di*cos_angle + dj*sin_angle);
2519             jt=(float)item->rows_in/2 - (-di*sin_angle + dj*cos_angle);
2520
2521             /* set pixel if required */
2522             if(it>=0 && it<item->cols_in && jt>=0 && jt<item->rows_in)
2523                 if((I_in->data[jt*byte_w_in+it/8] & 128>>(it%8))>0)
2524                     item->ximage->data[byte_out+i/8]|=128>>i%8;
2525
2526             di+=1;
2527         }
2528         dj+=1;
2529         xl+=xinc;
2530         xr+=xinc;
2531     }
2532     XDestroyImage(I_in);
2533
2534     if(style.magnify!=1.) {
2535         item->cols_in=old_cols_in;
2536         item->rows_in=old_rows_in;
2537     }
2538
2539
2540 #ifdef CACHE_BITMAPS
2541
2542     /* create a bitmap to hold rotated text */
2543     item->bitmap=XCreatePixmap(dpy, DefaultRootWindow(dpy),
2544                                item->cols_out, item->rows_out, 1);
2545
2546     /* make the text bitmap from XImage */
2547     XPutImage(dpy, item->bitmap, font_gc, item->ximage, 0, 0, 0, 0,
2548               item->cols_out, item->rows_out);
2549
2550     XDestroyImage(item->ximage);
2551
2552 #endif /*CACHE_BITMAPS*/
2553
2554     XFreeGC(dpy, font_gc);
2555     XFreePixmap(dpy, canvas);
2556
2557     return item;
2558 }
2559
2560
2561 /* ---------------------------------------------------------------------- */
2562
2563
2564 /**************************************************************************/
2565 /*  Adds a text item to the end of the cache, removing as many items      */
2566 /*      from the front as required to keep cache size below limit         */
2567 /**************************************************************************/
2568
2569 static void XRotAddToLinkedList(Display *dpy, RotatedTextItem *item)
2570 {
2571
2572     static long int current_size=0;
2573     static RotatedTextItem *last=NULL;
2574     RotatedTextItem *i1=first_text_item, *i2=NULL;
2575
2576 #ifdef CACHE_BITMAPS
2577
2578     /* I don't know how much memory a pixmap takes in the server -
2579            probably this + a bit more we can't account for */
2580
2581     item->size=((item->cols_out-1)/8+1)*item->rows_out;
2582
2583 #else
2584
2585     /* this is pretty much the size of a RotatedTextItem */
2586
2587     item->size=((item->cols_out-1)/8+1)*item->rows_out +
2588         sizeof(XImage) + strlen(item->text) +
2589             item->nl*8*sizeof(float) + sizeof(RotatedTextItem);
2590
2591     if(item->font_name!=NULL)
2592         item->size+=strlen(item->font_name);
2593     else
2594         item->size+=sizeof(Font);
2595
2596 #endif /*CACHE_BITMAPS */
2597
2598 #ifdef DEBUG
2599     /* count number of items in cache, for debugging */
2600     {
2601         int i=0;
2602
2603         while(i1) {
2604             i++;
2605             i1=i1->next;
2606         }
2607         DEBUG_PRINT2("Cache has %d items.\n", i);
2608         i1=first_text_item;
2609     }
2610 #endif
2611
2612     DEBUG_PRINT4("current cache size=%ld, new item=%ld, limit=%ld\n",
2613                  current_size, item->size, CACHE_SIZE_LIMIT*1024);
2614
2615     /* if this item is bigger than whole cache, forget it */
2616     if(item->size>CACHE_SIZE_LIMIT*1024) {
2617         DEBUG_PRINT1("Too big to cache\n\n");
2618         item->cached=0;
2619         return;
2620     }
2621
2622     /* remove elements from cache as needed */
2623     while(i1 && current_size+item->size>CACHE_SIZE_LIMIT*1024) {
2624
2625         DEBUG_PRINT2("Removed %d bytes\n", i1->size);
2626
2627         if(i1->font_name!=NULL)
2628             DEBUG_PRINT5("  (`%s'\n   %s\n   angle=%f align=%d)\n",
2629                          i1->text, i1->font_name, i1->angle, i1->align);
2630
2631 #ifdef CACHE_FID
2632         if(i1->font_name==NULL)
2633             DEBUG_PRINT5("  (`%s'\n  FID=%ld\n   angle=%f align=%d)\n",
2634                          i1->text, i1->fid, i1->angle, i1->align);
2635 #endif /*CACHE_FID*/
2636
2637         current_size-=i1->size;
2638
2639         i2=i1->next;
2640
2641         /* free resources used by the unlucky item */
2642         XRotFreeTextItem(dpy, i1);
2643
2644         /* remove it from linked list */
2645         first_text_item=i2;
2646         i1=i2;
2647     }
2648
2649     /* add new item to end of linked list */
2650     if(first_text_item==NULL) {
2651         item->next=NULL;
2652         first_text_item=item;
2653         last=item;
2654     }
2655     else {
2656         item->next=NULL;
2657         last->next=item;
2658         last=item;
2659     }
2660
2661     /* new cache size */
2662     current_size+=item->size;
2663
2664     item->cached=1;
2665
2666     DEBUG_PRINT1("Added item to cache.\n");
2667 }
2668
2669
2670 /* ---------------------------------------------------------------------- */
2671
2672
2673 /**************************************************************************/
2674 /*  Free the resources used by a text item                                */
2675 /**************************************************************************/
2676
2677 static void XRotFreeTextItem(Display *dpy, RotatedTextItem *item)
2678 {
2679     free(item->text);
2680
2681     if(item->font_name!=NULL)
2682         free(item->font_name);
2683
2684     free((char *)item->corners_x);
2685     free((char *)item->corners_y);
2686
2687 #ifdef CACHE_BITMAPS
2688     XFreePixmap(dpy, item->bitmap);
2689 #else
2690     XDestroyImage(item->ximage);
2691 #endif /* CACHE_BITMAPS */
2692
2693     free((char *)item);
2694 }
2695
2696
2697 /* ---------------------------------------------------------------------- */
2698
2699
2700 /**************************************************************************/
2701 /* Magnify an XImage using bilinear interpolation                         */
2702 /**************************************************************************/
2703
2704 static XImage *XRotMagnifyImage(Display *dpy, XImage *ximage)
2705 {
2706     int i, j;
2707     float x, y;
2708     float u,t;
2709     XImage *I_out;
2710     int cols_in, rows_in;
2711     int cols_out, rows_out;
2712     register int i2, j2;
2713     float z1, z2, z3, z4;
2714     int byte_width_in, byte_width_out;
2715     float mag_inv;
2716
2717     /* size of input image */
2718     cols_in=ximage->width;
2719     rows_in=ximage->height;
2720
2721     /* size of final image */
2722     cols_out=(float)cols_in*style.magnify;
2723     rows_out=(float)rows_in*style.magnify;
2724
2725     /* this will hold final image */
2726     I_out=MakeXImage(dpy, cols_out, rows_out);
2727     if(I_out==NULL)
2728         return NULL;
2729
2730     /* width in bytes of input, output images */
2731     byte_width_in=(cols_in-1)/8+1;
2732     byte_width_out=(cols_out-1)/8+1;
2733
2734     /* for speed */
2735     mag_inv=1./style.magnify;
2736
2737     y=0.;
2738
2739     /* loop over magnified image */
2740     for(j2=0; j2<rows_out; j2++) {
2741         x=0;
2742         j=y;
2743
2744         for(i2=0; i2<cols_out; i2++) {
2745             i=x;
2746
2747             /* bilinear interpolation - where are we on bitmap ? */
2748             /* right edge */
2749             if(i==cols_in-1 && j!=rows_in-1) {
2750                 t=0;
2751                 u=y-(float)j;
2752
2753                 z1=(ximage->data[j*byte_width_in+i/8] & 128>>(i%8))>0;
2754                 z2=z1;
2755                 z3=(ximage->data[(j+1)*byte_width_in+i/8] & 128>>(i%8))>0;
2756                 z4=z3;
2757             }
2758             /* top edge */
2759             else if(i!=cols_in-1 && j==rows_in-1) {
2760                 t=x-(float)i;
2761                 u=0;
2762
2763                 z1=(ximage->data[j*byte_width_in+i/8] & 128>>(i%8))>0;
2764                 z2=(ximage->data[j*byte_width_in+(i+1)/8] & 128>>((i+1)%8))>0;
2765                 z3=z2;
2766                 z4=z1;
2767             }
2768             /* top right corner */
2769             else if(i==cols_in-1 && j==rows_in-1) {
2770                 u=0;
2771                 t=0;
2772
2773                 z1=(ximage->data[j*byte_width_in+i/8] & 128>>(i%8))>0;
2774                 z2=z1;
2775                 z3=z1;
2776                 z4=z1;
2777             }
2778             /* somewhere `safe' */
2779             else {
2780                 t=x-(float)i;
2781                 u=y-(float)j;
2782
2783                 z1=(ximage->data[j*byte_width_in+i/8] & 128>>(i%8))>0;
2784                 z2=(ximage->data[j*byte_width_in+(i+1)/8] & 128>>((i+1)%8))>0;
2785                 z3=(ximage->data[(j+1)*byte_width_in+(i+1)/8] &
2786                     128>>((i+1)%8))>0;
2787                 z4=(ximage->data[(j+1)*byte_width_in+i/8] & 128>>(i%8))>0;
2788             }
2789
2790             /* if interpolated value is greater than 0.5, set bit */
2791             if(((1-t)*(1-u)*z1 + t*(1-u)*z2 + t*u*z3 + (1-t)*u*z4)>0.5)
2792                 I_out->data[j2*byte_width_out+i2/8]|=128>>i2%8;
2793
2794             x+=mag_inv;
2795         }
2796         y+=mag_inv;
2797     }
2798
2799     /* destroy original */
2800     XDestroyImage(ximage);
2801
2802     /* return big image */
2803     return I_out;
2804 }
2805
2806
2807
2808 /* ---------------------------------------------------------------------- */
2809
2810
2811 /**************************************************************************/
2812 /* Calculate the bounding box some text will have when painted            */
2813 /**************************************************************************/
2814 static
2815 XPoint *XRotTextExtents(Display *dpy, XFontStruct *font, float angle, int x, int y, char *text, int align)
2816 {
2817     register int i;
2818     char *str1, *str2, *str3;
2819     char *str2_a="\0", *str2_b="\n\0";
2820     int height;
2821     float sin_angle, cos_angle;
2822     int nl, max_width;
2823     int cols_in, rows_in;
2824     float hot_x, hot_y;
2825     XPoint *xp_in, *xp_out;
2826     int dir, asc, desc;
2827     XCharStruct overall;
2828
2829     /* manipulate angle to 0<=angle<360 degrees */
2830     while(angle<0)
2831         angle+=360;
2832
2833     while(angle>360)
2834         angle-=360;
2835
2836     angle*=M_PI/180;
2837
2838     /* count number of sections in string */
2839     nl=1;
2840     if(align!=NONE)
2841         for(i=0; i<strlen(text)-1; i++)
2842             if(text[i]=='\n')
2843                 nl++;
2844
2845     /* ignore newline characters if not doing alignment */
2846     if(align==NONE)
2847         str2=str2_a;
2848     else
2849         str2=str2_b;
2850
2851     /* find width of longest section */
2852     str1=my_strdup(text);
2853     if(str1==NULL)
2854         return NULL;
2855
2856     str3=my_strtok(str1, str2);
2857
2858     XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2859                  &overall);
2860
2861     max_width=overall.rbearing;
2862
2863     /* loop through each section */
2864     do {
2865         str3=my_strtok((char *)NULL, str2);
2866
2867         if(str3!=NULL) {
2868             XTextExtents(font, str3, strlen(str3), &dir, &asc, &desc,
2869                          &overall);
2870
2871             if(overall.rbearing>max_width)
2872                 max_width=overall.rbearing;
2873         }
2874     }
2875     while(str3!=NULL);
2876
2877     free(str1);
2878
2879     /* overall font height */
2880     height=font->ascent+font->descent;
2881
2882     /* dimensions horizontal text will have */
2883     cols_in=max_width;
2884     rows_in=nl*height;
2885
2886     /* pre-calculate sin and cos */
2887     sin_angle=sin(angle);
2888     cos_angle=cos(angle);
2889
2890     /* y position */
2891     if(align==TLEFT || align==TCENTRE || align==TRIGHT)
2892         hot_y=(float)rows_in/2*style.magnify;
2893     else if(align==MLEFT || align==MCENTRE || align==MRIGHT)
2894         hot_y=0;
2895     else if(align==BLEFT || align==BCENTRE || align==BRIGHT)
2896         hot_y = -(float)rows_in/2*style.magnify;
2897     else
2898         hot_y = -((float)rows_in/2-(float)font->descent)*style.magnify;
2899
2900     /* x position */
2901     if(align==TLEFT || align==MLEFT || align==BLEFT || align==NONE)
2902         hot_x = -(float)max_width/2*style.magnify;
2903     else if(align==TCENTRE || align==MCENTRE || align==BCENTRE)
2904         hot_x=0;
2905     else
2906         hot_x=(float)max_width/2*style.magnify;
2907
2908     /* reserve space for XPoints */
2909     xp_in=(XPoint *)malloc((unsigned)(5*sizeof(XPoint)));
2910     if(!xp_in)
2911         return NULL;
2912
2913     xp_out=(XPoint *)malloc((unsigned)(5*sizeof(XPoint)));
2914     if(!xp_out)
2915         return NULL;
2916
2917     /* bounding box when horizontal, relative to bitmap centre */
2918     xp_in[0].x = -(float)cols_in*style.magnify/2-style.bbx_pad;
2919     xp_in[0].y= (float)rows_in*style.magnify/2+style.bbx_pad;
2920     xp_in[1].x= (float)cols_in*style.magnify/2+style.bbx_pad;
2921     xp_in[1].y= (float)rows_in*style.magnify/2+style.bbx_pad;
2922     xp_in[2].x= (float)cols_in*style.magnify/2+style.bbx_pad;
2923     xp_in[2].y = -(float)rows_in*style.magnify/2-style.bbx_pad;
2924     xp_in[3].x = -(float)cols_in*style.magnify/2-style.bbx_pad;
2925     xp_in[3].y = -(float)rows_in*style.magnify/2-style.bbx_pad;
2926     xp_in[4].x=xp_in[0].x;
2927     xp_in[4].y=xp_in[0].y;
2928
2929     /* rotate and translate bounding box */
2930     for(i=0; i<5; i++) {
2931         xp_out[i].x=(float)x + ( ((float)xp_in[i].x-hot_x)*cos_angle +
2932                                  ((float)xp_in[i].y+hot_y)*sin_angle);
2933         xp_out[i].y=(float)y + (-((float)xp_in[i].x-hot_x)*sin_angle +
2934                                  ((float)xp_in[i].y+hot_y)*cos_angle);
2935     }
2936
2937     free((char *)xp_in);
2938
2939     return xp_out;
2940 }
2941
2942
2943 \f
2944 /* ***********************************************************************
2945  * Conversion routines for the X resource manager
2946  * ***********************************************************************
2947  */
2948
2949 #if defined(__STDC__)
2950 static
2951 Boolean strtocard(  Display *dsp,
2952                     XrmValue *args,
2953                     Cardinal *num_args,
2954                     XrmValue *from,
2955                     XrmValue *to,
2956                     XtPointer *unused
2957                     )
2958 #else
2959 static
2960 Boolean strtocard(  dsp, args, num_args, from, to, unused )
2961 Display *dsp;
2962 XrmValue *args;
2963 Cardinal *num_args;
2964 XrmValue *from;
2965 XrmValue *to;
2966 XtPointer *unused;
2967 #endif
2968 {
2969     static Cardinal temp;
2970
2971     if ( to->addr == NULL ) {
2972         to->addr = (XtPointer) &temp;
2973         to->size = sizeof(Cardinal);
2974     }
2975
2976     *((Cardinal *) to->addr) = atoi( from->addr );
2977     return True;
2978 }
2979
2980
2981 #define done_bert(type, value) \
2982     do {\
2983         if (to->addr != NULL) {\
2984             if (to->size < sizeof(type)) {\
2985                 to->size = sizeof(type);\
2986                 return False;\
2987             }\
2988             *(type*)(to->addr) = (value);\
2989         } else {\
2990             static type static_val;\
2991             static_val = (value);\
2992             to->addr = (XtPointer)&static_val;\
2993         }\
2994         to->size = sizeof(type);\
2995         return True;\
2996     } while (0)
2997 static
2998 Boolean cvtStringToStringArray(Display *display, XrmValuePtr args, Cardinal *num_args, XrmValuePtr from, XrmValuePtr to, XtPointer *converter_data)
2999 {
3000     String t, s;
3001     StringArray a = NULL;
3002     Cardinal i;
3003     char delim;
3004
3005     if (*num_args != 0)
3006         XtAppErrorMsg(XtDisplayToApplicationContext(display),
3007                       "cvtStringToStringArray", "wrongParameters",
3008                       "XtToolkitError",
3009                       "String to StringArray conversion needs no arguments",
3010                       (String*) NULL, (Cardinal*) NULL);
3011
3012     delim = ((String) from->addr)[0];
3013     s = XtNewString((String) from->addr + 1);
3014     i = 0;
3015     while (s && *s) {
3016         t = strchr(s, delim);
3017         if (t) *t = '\0';
3018         a = (StringArray) XtRealloc((String) a, (i + 1) * sizeof(*a));
3019         a[i] = s;
3020         i++;
3021         s = t ? t + 1 : NULL;
3022     }
3023     a = (StringArray) XtRealloc((String) a, (i + 1) * sizeof(*a));
3024     a[i] = NULL;
3025     done_bert(StringArray, a);
3026 }
3027
3028 \f
3029 /* ***********************************************************************
3030  * A driver for the above in the flavor of the xt utilities module
3031  * ***********************************************************************
3032  */
3033
3034 #define TABHT 25
3035
3036 typedef struct tab_data {
3037     Widget      form;
3038     int         cur,
3039                 num_tabs;
3040     void        (*activate_func)();
3041 } *TabData;
3042
3043
3044 #if defined(__STDC__)
3045 static void handle_click( Widget w, TabData td, XtPointer call_data )
3046 #else
3047 static void handle_click(w, td, call_data)
3048     Widget w;
3049     TabData td;
3050     XtPointer call_data;
3051 #endif
3052 {
3053     int tab = (int) call_data;
3054
3055     /* note that the tab is relative to the current tab.
3056      * if tab is 0, the user clicked on the current one.
3057      * there is nothing to do
3058      */
3059     if (tab == 0) return;
3060     td->cur += tab;
3061
3062     /* Change tabs.  We must manually inform the UI which tab is current  */
3063     XtVaSetValues( w,
3064                    XtNlefttabs, td->cur,
3065                    XtNrighttabs, td->num_tabs - td->cur - 1,
3066                    NULL
3067                    );
3068
3069     (*td->activate_func)( td->form, td->cur );
3070 }
3071
3072
3073 /*
3074  * PUBLIC: Widget __vi_CreateTabbedFolder
3075  * PUBLIC:     __P((String, Widget, String, int, void (*)(Widget, int)));
3076  */
3077 #if defined(__STDC__)
3078 Widget  __vi_CreateTabbedFolder( String name,
3079                                 Widget parent,
3080                                 String tab_labels,
3081                                 int num_tabs,
3082                                 void (*activate_func)()
3083                                 )
3084 #else
3085 Widget  __vi_CreateTabbedFolder( name, parent, tab_labels, num_tabs, activate_func )
3086 String  name;
3087 String  tab_labels;
3088 Widget  parent;
3089 int     num_tabs;
3090 void    (*activate_func)();
3091 #endif
3092 {
3093     Widget      tabs;
3094     TabData     td = (TabData) malloc( sizeof(struct tab_data) );
3095     int         i;
3096
3097     XtAppSetTypeConverter(  XtDisplayToApplicationContext(XtDisplay(parent)),
3098                             XtRString,
3099                             XtRCardinal,
3100                             strtocard,
3101                             NULL,
3102                             0,
3103                             XtCacheNone,
3104                             NULL
3105                             );
3106
3107     /* init our internal structure */
3108     td->cur             = 0;
3109     td->num_tabs        = num_tabs;
3110     td->activate_func   = activate_func;
3111
3112     /* tabs go on the top */
3113     tabs = XtVaCreateManagedWidget( "tabs",
3114                                      xmTabsWidgetClass,
3115                                      parent,
3116                                      XtNlefttabs,       0,
3117                                      XtNrighttabs,      num_tabs-1,
3118                                      XtNorientation,    XfwfUpTabs,
3119                                      XmNtopAttachment,  XmATTACH_FORM,
3120                                      XmNleftAttachment, XmATTACH_FORM,
3121                                      XmNleftOffset,     TABHT/4,
3122                                      XmNrightAttachment,XmATTACH_FORM,
3123                                      XmNrightOffset,    TABHT/4,
3124                                      XmNbottomAttachment,XmATTACH_OPPOSITE_FORM,
3125                                      XmNbottomOffset,   -TABHT,
3126                                      XtNlabels,         tab_labels,
3127                                      XtVaTypedArg,      XtNlabels,
3128                                                         XtRString,
3129                                                         tab_labels,
3130                                                         strlen(tab_labels) + 1,
3131                                      NULL
3132                                      );
3133
3134     /* add the callback */
3135     XtAddCallback( tabs,
3136                    XtNactivateCallback,
3137                    (XtCallbackProc) handle_click,
3138                    td
3139                    );
3140
3141     /* another form to hold the controls */
3142     td->form = XtVaCreateWidget( "form",
3143                                  xmFormWidgetClass,
3144                                  parent,
3145                                  XmNtopAttachment,      XmATTACH_WIDGET,
3146                                  XmNtopWidget,          tabs,
3147                                  XmNleftAttachment,     XmATTACH_FORM,
3148                                  XmNbottomAttachment,   XmATTACH_FORM,
3149                                  XmNrightAttachment,    XmATTACH_FORM,
3150                                  NULL
3151                                  );
3152
3153     /* done */
3154     return td->form;
3155 }