home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume21 / xfig / patch02n / xfig.09
Encoding:
Text File  |  1993-10-21  |  27.8 KB  |  1,001 lines
  1. + 
  2.   /********************* EXPORTS *******************/
  3.   
  4.   int        put_msg();
  5. ***************
  6. *** 73,88 ****
  7.   
  8.   setup_msg()
  9.   {
  10. !     Dimension ht;
  11.   
  12. !     /* set the height of the message panel to the height of the file name panel */
  13.       XtUnmanageChild(msg_panel);
  14. !     FirstArg(XtNheight, &ht);
  15.       GetValues(name_panel);
  16. !     FirstArg(XtNheight, ht);
  17.       SetValues(msg_panel);
  18.       /* set the MSGFORM_HT variable so the mouse panel can be resized to fit */
  19. !     MSGFORM_HT = ht;
  20.       XtManageChild(msg_panel);
  21.       if (msg_win == 0)
  22.       msg_win = XtWindow(msg_panel);
  23. --- 77,97 ----
  24.   
  25.   setup_msg()
  26.   {
  27. !     Dimension htm,htf;
  28.   
  29. !     /* set the height of the message panel and filename panel to the 
  30. !        greater of the two heights */
  31.       XtUnmanageChild(msg_panel);
  32. !     FirstArg(XtNheight, &htm);
  33.       GetValues(name_panel);
  34. !     FirstArg(XtNheight, &htf);
  35. !     GetValues(msg_panel);
  36. !     htf = max2(htf,htm);
  37. !     FirstArg(XtNheight, htf);
  38.       SetValues(msg_panel);
  39. +     SetValues(name_panel);
  40.       /* set the MSGFORM_HT variable so the mouse panel can be resized to fit */
  41. !     MSGFORM_HT = htf;
  42.       XtManageChild(msg_panel);
  43.       if (msg_win == 0)
  44.       msg_win = XtWindow(msg_panel);
  45. ***************
  46. *** 95,100 ****
  47. --- 104,110 ----
  48.    * space, by getting the width of the command panel and subtract the new 
  49.    * width of the name_panel to get the new width of the message panel
  50.    */
  51. + 
  52.   update_cur_filename(newname)
  53.       char    *newname;
  54.   {
  55. ***************
  56. *** 112,120 ****
  57. --- 122,135 ----
  58.       FirstArg(XtNwidth, &namwid);
  59.       GetValues(name_panel);
  60.       MSGPANEL_WD = MSGFORM_WD-namwid;
  61. +     if (MSGPANEL_WD <= 0)
  62. +         MSGPANEL_WD = 100;
  63.       /* resize the message panel to fit with the new width of the name panel */
  64.       FirstArg(XtNwidth, MSGPANEL_WD);
  65.       SetValues(msg_panel);
  66. +     /* keep the height the same */
  67. +     FirstArg(XtNheight, MSGFORM_HT);
  68. +     SetValues(name_panel);
  69.       XtManageChild(msg_panel);
  70.       XtManageChild(name_panel);
  71.   
  72. ***************
  73. *** 122,127 ****
  74. --- 137,144 ----
  75.       FirstArg(XtNwidth, MSGFORM_WD);
  76.       SetValues(msg_form);
  77.       XtManageChild(msg_form);
  78. +     /* put the filename being edited in the icon */
  79. +     XSetIconName(tool_d, XtWindow(tool), basename(cur_filename));
  80.   }
  81.   
  82.   /* VARARGS1 */
  83. diff -rc xfig.2.1.7a/w_print.c xfig.2.1.8/w_print.c
  84. *** xfig.2.1.7a/w_print.c    Tue Mar 23 10:21:42 1993
  85. --- xfig.2.1.8/w_print.c    Tue Aug 31 14:20:47 1993
  86. ***************
  87. *** 96,103 ****
  88.          var and put it into the widget */
  89.       if (emptyname(printer_val)) {
  90.           printer_val=getenv("PRINTER");
  91. !         FirstArg(XtNstring, printer_val);
  92. !         SetValues(printer_text);
  93.       }
  94.       FirstArg(XtNstring, ¶m_val);
  95.       GetValues(param_text);
  96. --- 96,107 ----
  97.          var and put it into the widget */
  98.       if (emptyname(printer_val)) {
  99.           printer_val=getenv("PRINTER");
  100. !         if (printer_val == NULL) {
  101. !             printer_val = "";
  102. !         } else {
  103. !             FirstArg(XtNstring, printer_val);
  104. !             SetValues(printer_text);
  105. !         }
  106.       }
  107.       FirstArg(XtNstring, ¶m_val);
  108.       GetValues(param_text);
  109. ***************
  110. *** 122,128 ****
  111.       char       *pr_params;
  112.   {
  113.       if (emptyname(printer)) {    /* send to default printer */
  114. ! #if defined(SYSV) || defined(SVR4)
  115.       sprintf(cmd, "lp %s -oPS %s", 
  116.           pr_params,
  117.           shell_protect_string(file));
  118. --- 126,132 ----
  119.       char       *pr_params;
  120.   {
  121.       if (emptyname(printer)) {    /* send to default printer */
  122. ! #if (defined(SYSV) || defined(SVR4)) && !defined(BSDLPR)
  123.       sprintf(cmd, "lp %s -oPS %s", 
  124.           pr_params,
  125.           shell_protect_string(file));
  126. ***************
  127. *** 135,141 ****
  128.       put_msg("Printing figure on default printer in %s mode ...     ",
  129.           print_landscape ? "LANDSCAPE" : "PORTRAIT");
  130.       } else {
  131. ! #if defined(SYSV) || defined(SVR4)
  132.       sprintf(cmd, "lp %s, -d%s -oPS %s",
  133.           pr_params,
  134.           printer, 
  135. --- 139,145 ----
  136.       put_msg("Printing figure on default printer in %s mode ...     ",
  137.           print_landscape ? "LANDSCAPE" : "PORTRAIT");
  138.       } else {
  139. ! #if (defined(SYSV) || defined(SVR4)) && !defined(BSDLPR)
  140.       sprintf(cmd, "lp %s, -d%s -oPS %s",
  141.           pr_params,
  142.           printer, 
  143. ***************
  144. *** 160,166 ****
  145.   do_print_batch(w)
  146.       Widget        w;
  147.   {
  148. -     DeclareArgs(1);
  149.       float        mag;
  150.       FILE       *infp,*outfp;
  151.       char        tmp_exp_file[32];
  152. --- 164,169 ----
  153. ***************
  154. *** 215,222 ****
  155.   do_clear_batch(w)
  156.       Widget        w;
  157.   {
  158. -     DeclareArgs(1);
  159. -   
  160.       unlink(batch_file);
  161.       batch_exists = False;
  162.       num_batch_figures = 0;
  163. --- 218,223 ----
  164. ***************
  165. *** 228,234 ****
  166.   
  167.   update_batch_count()
  168.   {
  169. !     String        num[4];
  170.       DeclareArgs(1);
  171.   
  172.       sprintf(num,"%3d",num_batch_figures);
  173. --- 229,235 ----
  174.   
  175.   update_batch_count()
  176.   {
  177. !     char        num[4];
  178.       DeclareArgs(1);
  179.   
  180.       sprintf(num,"%3d",num_batch_figures);
  181. ***************
  182. *** 272,280 ****
  183.   popup_print_panel(w)
  184.       Widget        w;
  185.   {
  186. -     Widget        image;
  187. -     Pixmap        p;
  188. -     DeclareArgs(10);
  189.       extern        Atom wm_delete_window;
  190.   
  191.       set_temp_cursor(wait_cursor);
  192. --- 273,278 ----
  193. ***************
  194. *** 294,299 ****
  195. --- 292,298 ----
  196.       Widget        image;
  197.       Pixmap        p;
  198.       DeclareArgs(10);
  199. +     unsigned long fg, bg;
  200.   
  201.       print_w = w;
  202.       XtTranslateCoords(w, (Position) 0, (Position) 0, &xposn, &yposn);
  203. ***************
  204. *** 311,323 ****
  205.       print_panel = XtCreateManagedWidget("print_panel", formWidgetClass,
  206.                           print_popup, NULL, ZERO);
  207.   
  208. -     p = XCreateBitmapFromData(tool_d, XtWindow(canvas_sw),
  209. -               (char *) printer_ic.data, printer_ic.width, printer_ic.height);
  210. - 
  211.       FirstArg(XtNlabel, "   ");
  212.       NextArg(XtNwidth, printer_ic.width);
  213.       NextArg(XtNheight, printer_ic.height);
  214. -     NextArg(XtNbitmap, p);
  215.       NextArg(XtNborderWidth, 0);
  216.       NextArg(XtNinternalWidth, 0);
  217.       NextArg(XtNinternalHeight, 0);
  218. --- 310,318 ----
  219. ***************
  220. *** 325,330 ****
  221. --- 320,333 ----
  222.       NextArg(XtNresizable, False);
  223.       image = XtCreateManagedWidget("printer_image", labelWidgetClass,
  224.                         print_panel, Args, ArgCount);
  225. +     FirstArg(XtNforeground, &fg);
  226. +     NextArg(XtNbackground, &bg);
  227. +     GetValues(image);
  228. +     p = XCreatePixmapFromBitmapData(tool_d, XtWindow(canvas_sw),
  229. +               (char *) printer_ic.data, printer_ic.width, printer_ic.height,
  230. +               fg, bg, DefaultDepthOfScreen(tool_s));
  231. +     FirstArg(XtNbitmap, p);
  232. +     SetValues(image);
  233.   
  234.       FirstArg(XtNlabel, "  Magnification%:");
  235.       NextArg(XtNfromVert, image);
  236. diff -rc xfig.2.1.7a/w_rottext.c xfig.2.1.8/w_rottext.c
  237. *** xfig.2.1.7a/w_rottext.c    Wed Feb 10 10:25:21 1993
  238. --- xfig.2.1.8/w_rottext.c    Mon Sep 13 14:25:40 1993
  239. ***************
  240. *** 1,56 ****
  241. ! /*
  242. !  * FIG : Facility for Interactive Generation of figures
  243. !  * Copyright (c) 1992 by Alan Richardson
  244.    *
  245. !  * "Permission to use, copy, modify, distribute, and sell this software and its
  246. !  * documentation for any purpose is hereby granted without fee, provided that
  247. !  * the above copyright notice appear in all copies and that both the copyright
  248. !  * notice and this permission notice appear in supporting documentation. 
  249. !  * No representations are made about the suitability of this software for 
  250. !  * any purpose.  It is provided "as is" without express or implied warranty."
  251.    */
  252.   
  253.   #include "fig.h"
  254.   #include "w_rottext.h"
  255.   
  256.   /* ---------------------------------------------------------------------- */
  257.   
  258. - #define XROTMAX(a, b) ((a)>(b)?(a):(b))
  259.   
  260.   /* ---------------------------------------------------------------------- */
  261.   
  262. - char            *my_strdup();
  263. - char            *my_strtok();
  264. - XRotFontStruct         *XRotLoadFont();
  265. - void              XRotUnloadFont();
  266. - int               XRotTextWidth();
  267. - int               XRotTextHeight();
  268. - void             XRotDrawString();
  269. - void               XRotDrawImageString();
  270. - void                     XRotPaintString();
  271. - void               XRotDrawAlignedString();
  272. - void                     XRotDrawAlignedImageString();
  273. - void                     XRotPaintAlignedString();
  274.   
  275.   /* ---------------------------------------------------------------------- */
  276. -   
  277. - /* *** Routine to mimic `strdup()' (some machines don't have it) *** */
  278.   
  279. - char *my_strdup(str)
  280. -  char *str;
  281. - {
  282. -  char *s;
  283.   
  284. !  if(str==NULL) return (char *)NULL;
  285.   
  286. !  s=(char *)malloc((unsigned)(strlen(str)+1));
  287. !  if(!s)
  288. !   { fprintf(stderr, "Error: my_strdup(): Couldn't do malloc\n");
  289. !     exit(1); }
  290.   
  291. !  strcpy(s, str);
  292.   
  293. !  return s;
  294.   }
  295.   
  296.   
  297. --- 1,162 ----
  298. ! /* ********************************************************************** */
  299. ! 
  300. ! /* xvertext 5.0, Copyright (c) 1993 Alan Richardson (mppa3@uk.ac.sussex.syma)
  301.    *
  302. !  * Permission to use, copy, modify, and distribute this software and its
  303. !  * documentation for any purpose and without fee is hereby granted, provided
  304. !  * that the above copyright notice appear in all copies and that both the
  305. !  * copyright notice and this permission notice appear in supporting
  306. !  * documentation.  All work developed as a consequence of the use of
  307. !  * this program should duly acknowledge such use. No representations are
  308. !  * made about the suitability of this software for any purpose.  It is
  309. !  * provided "as is" without express or implied warranty.
  310.    */
  311.   
  312. + /* ********************************************************************** */
  313. + 
  314. + 
  315. + /* BETTER: xvertext now does rotation at any angle!!
  316. +  *
  317. +  * BEWARE: function arguments have CHANGED since version 2.0!!
  318. +  */
  319. + 
  320. + /* ********************************************************************** */
  321. + 
  322. + 
  323.   #include "fig.h"
  324. + #include "resources.h"
  325. + #include <X11/Xatom.h>
  326.   #include "w_rottext.h"
  327.   
  328. + 
  329.   /* ---------------------------------------------------------------------- */
  330.   
  331.   
  332. + /* Make sure cache size is set */
  333. + 
  334. + #ifndef CACHE_SIZE_LIMIT
  335. + #define CACHE_SIZE_LIMIT 0
  336. + #endif /*CACHE_SIZE_LIMIT */
  337. +     
  338. + /* Cache by FID if can't find name because OpenWindows screws up */
  339. + 
  340. + #define CACHE_FID
  341. + 
  342. + /* Make sure a cache method is specified */
  343. + 
  344. + #ifndef CACHE_XIMAGES
  345. + #ifndef CACHE_BITMAPS
  346. + #define CACHE_BITMAPS
  347. + #endif /*CACHE_BITMAPS*/
  348. + #endif /*CACHE_XIMAGES*/
  349. + 
  350. + 
  351.   /* ---------------------------------------------------------------------- */
  352.   
  353.   
  354. + /* Debugging macros */
  355. + 
  356. + #define DEBUG_PRINT1(a) if (appres.DEBUG) printf (a)
  357. + #define DEBUG_PRINT2(a, b) if (appres.DEBUG) printf (a, b)
  358. + #define DEBUG_PRINT3(a, b, c) if (appres.DEBUG) printf (a, b, c)
  359. + #define DEBUG_PRINT4(a, b, c, d) if (appres.DEBUG) printf (a, b, c, d)
  360. + #define DEBUG_PRINT5(a, b, c, d, e) if (appres.DEBUG) printf (a, b, c, d, e)
  361. + 
  362. + 
  363.   /* ---------------------------------------------------------------------- */
  364.   
  365.   
  366. ! /* A structure holding everything needed for a rotated string */
  367.   
  368. ! typedef struct rotated_text_item_template {
  369. !     Pixmap bitmap;
  370. !     XImage *ximage;
  371. !     
  372. !     char *text;
  373. !     char *font_name;
  374. !     Font fid;
  375. !     float angle;
  376. !     int align;
  377. !     float magnify;
  378. !     
  379. !     int cols_in;
  380. !     int rows_in;
  381. !     int cols_out;
  382. !     int rows_out;
  383. !     
  384. !     int nl;
  385. !     int max_width;
  386. !     float *corners_x;
  387. !     float *corners_y;
  388. !     
  389. !     long int size;
  390. !     int cached;
  391.   
  392. !     struct rotated_text_item_template *next;
  393. ! } RotatedTextItem;
  394.   
  395. ! RotatedTextItem *first_text_item=NULL;
  396. ! 
  397. ! 
  398. ! /* ---------------------------------------------------------------------- */
  399. ! 
  400. ! 
  401. ! /* A structure holding current magnification and bounding box padding */
  402. ! 
  403. ! static struct style_template {
  404. !     float magnify;
  405. !     int bbx_pad;
  406. ! } style={
  407. !     1.,
  408. !     0
  409. !     };
  410. ! 
  411. ! 
  412. ! /* ---------------------------------------------------------------------- */
  413. ! 
  414. ! 
  415. ! static char            *my_strdup();
  416. ! static char            *my_strtok();
  417. ! 
  418. ! float                   XRotVersion();
  419. ! void                    XRotSetMagnification();
  420. ! void                    XRotSetBoundingBoxPad();
  421. ! int                     XRotDrawString();
  422. ! int                     XRotDrawImageString();
  423. ! int                     XRotDrawAlignedString();
  424. ! int                     XRotDrawAlignedImageString();
  425. ! XPoint                 *XRotTextExtents();
  426. ! 
  427. ! static XImage          *MakeXImage();
  428. ! static int              XRotPaintAlignedString();
  429. ! static int              XRotDrawHorizontalString();
  430. ! static RotatedTextItem *XRotRetrieveFromCache();
  431. ! static RotatedTextItem *XRotCreateTextItem();
  432. ! static void             XRotAddToLinkedList();
  433. ! static void             XRotFreeTextItem();
  434. ! static XImage          *XRotMagnifyImage();
  435. ! 
  436. ! 
  437. ! /* ---------------------------------------------------------------------- */
  438. ! 
  439. ! 
  440. ! /**************************************************************************/
  441. ! /* Routine to mimic `strdup()' (some machines don't have it)              */
  442. ! /**************************************************************************/
  443. ! 
  444. ! static char *my_strdup(str)
  445. !     char *str;
  446. ! {
  447. !     char *s;
  448. !     
  449. !     if(str==NULL)
  450. !     return NULL;
  451. !     
  452. !     s=(char *)malloc((unsigned)(strlen(str)+1));
  453. !     if(s!=NULL) 
  454. !     strcpy(s, str);
  455. !     
  456. !     return s;
  457.   }
  458.   
  459.   
  460. ***************
  461. *** 57,331 ****
  462.   /* ---------------------------------------------------------------------- */
  463.   
  464.   
  465. ! /* *** Routine to replace `strtok' : this one returns a zero
  466. !        length string if it encounters two consecutive delimiters *** */
  467.   
  468. ! char *my_strtok(str1, str2)
  469. !  char *str1, *str2;
  470.   {
  471. !  char *ret;
  472. !  int i, j, stop;
  473. !  static int start, len;
  474. !  static char *stext;
  475.   
  476. -  if(str2==NULL)
  477. -   { fprintf(stderr, "Error: my_strtok(): null delimiter string\n");
  478. -     exit(1);
  479. -   }
  480.   
  481. !  /* initialise if str1 not NULL ... */
  482. !  if(str1!=NULL)
  483. !   { start=0;
  484. !     stext=str1;
  485. !     len=strlen(str1);
  486. !   }
  487.   
  488. -  /* run out of tokens ? ... */
  489. -  if(start>=len) return (char *)NULL;
  490.   
  491. !  /* loop through characters ... */
  492. !  for(i=start; i<len; i++)
  493. !  {
  494. !   /* loop through delimiters ... */
  495. !   stop=0;
  496. !   for(j=0; j<strlen(str2); j++) if(stext[i]==str2[j]) stop=1;
  497.   
  498. !   if(stop) break;
  499. !  }
  500.   
  501. -  stext[i]='\0';
  502.   
  503. !  ret=stext+start;
  504.   
  505. -  start=i+1;
  506.   
  507. !  return ret;
  508.   }
  509.   
  510.   
  511.   /* ---------------------------------------------------------------------- */
  512. -   
  513.   
  514. ! /* *** Load the rotated version of a given font *** */
  515. !  
  516. ! XRotFontStruct *XRotLoadFont(dpy, fontname, angle)
  517. !  Display *dpy;
  518. !  char *fontname;
  519. !  float angle;
  520.   {
  521. !  char         val;
  522. !  XImage        *I1, *I2;
  523. !  Pixmap         canvas;
  524. !  Window         root;
  525. !  int         screen;
  526. !  GC         font_gc;
  527. !  char         text[3];
  528. !  XFontStruct    *fontstruct;
  529. !  XRotFontStruct    *rotfont;
  530. !  int         ichar, i, j, index, boxlen, dir;
  531. !  int         vert_w, vert_h, vert_len, bit_w, bit_h, bit_len;
  532. !  int         min_char, max_char;
  533. !  unsigned char    *vertdata, *bitdata;
  534. !  int         ascent, descent, lbearing, rbearing;
  535. !  int         on=1, off=0;
  536.   
  537. -  dir=(int)(angle/90.0+0.01);
  538. -  if (dir > 3)
  539. -     dir -= 4;
  540.   
  541. !  /* useful macros ... */
  542. !  screen=DefaultScreen(dpy);
  543. !  root=DefaultRootWindow(dpy);
  544.   
  545. -  /* load the font ... */
  546. -  fontstruct=XLoadQueryFont(dpy, fontname);
  547. -  if(!fontstruct) { 
  548. -     fprintf(stderr,
  549. -             "Error: XRotLoadFont(): XServer couldn't load the font `%s'\n",
  550. -             fontname);
  551. -     exit(1); 
  552. -  }
  553. -  
  554. -  /* boxlen is the square size that would enclose the largest character */
  555. -  boxlen = max2(fontstruct->max_bounds.rbearing - fontstruct->max_bounds.lbearing, 
  556. -           fontstruct->max_bounds.ascent + fontstruct->max_bounds.descent);
  557. -  boxlen *= 2;
  558.   
  559. !  /* create the depth 1 canvas bitmap ... */
  560. !  canvas=XCreatePixmap(dpy, root, boxlen, boxlen, 1);
  561. !  
  562. !  /* create a GC ... */
  563. !  font_gc=XCreateGC(dpy, canvas, NULL, 0);
  564. !  XSetBackground(dpy, font_gc, off);
  565.   
  566. !  XSetFont(dpy, font_gc, fontstruct->fid);
  567.   
  568. -  /* allocate space for rotated font ... */
  569. -  rotfont=(XRotFontStruct *)malloc((unsigned)sizeof(XRotFontStruct));
  570. -  if(!rotfont) { 
  571. -     fprintf(stderr,"Error: XRotLoadFont(): Couldn't do malloc\n");
  572. -     exit(1); 
  573. -  }
  574. -    
  575. -  /* determine which characters are defined in font ... */
  576. -  min_char=fontstruct->min_char_or_byte2; 
  577. -  max_char=fontstruct->max_char_or_byte2;
  578. -  
  579. -  /* we only want printing characters ... */
  580. -  if(min_char<32)  min_char=32;
  581. -  if(max_char>126) max_char=126;
  582. -      
  583. -  /* some overall font data ... */
  584. -  rotfont->name=my_strdup(fontname);
  585. -  rotfont->dir=dir;
  586. -  rotfont->min_char=min_char;
  587. -  rotfont->max_char=max_char;
  588. -  rotfont->max_ascent=fontstruct->max_bounds.ascent;
  589. -  rotfont->max_descent=fontstruct->max_bounds.descent;   
  590. -  rotfont->height=rotfont->max_ascent+rotfont->max_descent;
  591. -  rotfont->width=fontstruct->max_bounds.width;
  592.   
  593. !  /* remember xfontstruct for `normal' text ... */
  594. !  if(dir==0) 
  595. !     rotfont->xfontstruct=fontstruct;
  596.   
  597. -  /* loop through each character ... */
  598. -  for(ichar=min_char; ichar<=max_char; ichar++) {
  599.   
  600. !      index=ichar-fontstruct->min_char_or_byte2;
  601. !      /* per char dimensions ... */
  602. !      ascent=  rotfont->per_char[ichar-32].ascent=
  603. !                       fontstruct->per_char[index].ascent;
  604. !      descent= rotfont->per_char[ichar-32].descent=
  605. !                       fontstruct->per_char[index].descent;
  606. !      lbearing=rotfont->per_char[ichar-32].lbearing=
  607. !                       fontstruct->per_char[index].lbearing;
  608. !      rbearing=rotfont->per_char[ichar-32].rbearing=
  609. !                       fontstruct->per_char[index].rbearing;
  610. !               rotfont->per_char[ichar-32].width=
  611. !                       fontstruct->per_char[index].width;
  612.   
  613. !      /* no need for the following with normal text */
  614. !      if (dir == 0)
  615. !     continue;
  616.   
  617. -      /* some space chars have zero body, but a bitmap can't have ... */
  618. -      if(!ascent && !descent)   
  619. -             ascent=  rotfont->per_char[ichar-32].ascent=  1;
  620. -      if(!lbearing && !rbearing) 
  621. -             rbearing=rotfont->per_char[ichar-32].rbearing=1;
  622.   
  623. !      /* glyph width and height when vertical ... */
  624. !      vert_w=rbearing-lbearing;
  625. !      vert_h=ascent+descent;
  626.   
  627. -      /* width in bytes ... */
  628. -      vert_len=(vert_w-1)/8+1;   
  629. -  
  630. -      XSetForeground(dpy, font_gc, off);
  631. -      XFillRectangle(dpy, canvas, font_gc, 0, 0, boxlen, boxlen);
  632.   
  633. !      /* draw the character centre top right on canvas ... */
  634. !      sprintf(text, "%c", ichar);
  635. !      XSetForeground(dpy, font_gc, on);
  636. !      XDrawImageString(dpy, canvas, font_gc, boxlen/2-lbearing,
  637. !                       boxlen/2-descent, text, 1);
  638.   
  639. !      /* reserve memory for first XImage ... */
  640. !      vertdata=(unsigned char *) malloc((unsigned)(vert_len*vert_h));
  641. !      if(!vertdata) { 
  642. !     fprintf(stderr,"Error: XRotLoadFont(): Couldn't do malloc\n");
  643. !         exit(1); 
  644. !       }
  645. !   
  646. !      /* create the XImage ... */
  647. !      I1=XCreateImage(dpy, DefaultVisual(dpy, screen), 1, XYBitmap,
  648. !                      0, (char *) vertdata, vert_w, vert_h, 8, 0);
  649.   
  650. -      if(!I1) { 
  651. -     fprintf(stderr,"Error: XRotLoadFont(): Couldn't create XImage\n");
  652. -         exit(1); 
  653. -      }
  654. -   
  655. -      I1->byte_order=I1->bitmap_bit_order=MSBFirst;
  656.   
  657. !      /* extract character from canvas ... */
  658. !      XGetSubImage(dpy, canvas, boxlen/2, boxlen/2-vert_h,
  659. !                   vert_w, vert_h, 1, XYPixmap, I1, 0, 0);
  660. !      I1->format=XYBitmap; 
  661. !  
  662. !      /* width, height of rotated character ... */
  663. !      if(dir==2) { 
  664. !     bit_w=vert_w; bit_h=vert_h; 
  665. !      } else { 
  666. !     bit_w=vert_h; bit_h=vert_w; 
  667. !      }
  668.   
  669. -      /* width in bytes ... */
  670. -      bit_len=(bit_w-1)/8+1;
  671. -    
  672. -      rotfont->per_char[ichar-32].glyph.bit_w=bit_w;
  673. -      rotfont->per_char[ichar-32].glyph.bit_h=bit_h;
  674.   
  675. !      /* reserve memory for the rotated image ... */
  676. !      bitdata=(unsigned char *)calloc((unsigned)(bit_h*bit_len), 1);
  677. !      if(!bitdata) { 
  678. !     fprintf(stderr,"Error: XRotLoadFont(): Couldn't do calloc\n");
  679. !         exit(1); 
  680. !      }
  681.   
  682. !      /* create the image ... */
  683. !      I2=XCreateImage(dpy, DefaultVisual(dpy, screen), 1, XYBitmap, 0,
  684. !                      (char *) bitdata, bit_w, bit_h, 8, 0); 
  685. !  
  686. !      if(!I2) { 
  687. !     fprintf(stderr,"Error: XRotLoadFont(): Couldn't create XImage\n");
  688. !         exit(1);
  689. !      }
  690.   
  691. -      I2->byte_order=I2->bitmap_bit_order=MSBFirst;
  692.   
  693. !      /* map vertical data to rotated character ... */
  694. !      for(j=0; j<bit_h; j++) {
  695. !       for(i=0; i<bit_w; i++) {
  696. !        /* map bits ... */
  697. !        if(dir==1)
  698. !          val=vertdata[i*vert_len + (vert_w-j-1)/8] & (128>>((vert_w-j-1)%8));
  699. !    
  700. !        else if(dir==2)
  701. !          val=vertdata[(vert_h-j-1)*vert_len + (vert_w-i-1)/8] &
  702. !                                                        (128>>((vert_w-i-1)%8));
  703. !        else 
  704. !          val=vertdata[(vert_h-i-1)*vert_len + j/8] & (128>>(j%8));
  705. !         
  706. !        if(val) bitdata[j*bit_len + i/8] = 
  707. !                    bitdata[j*bit_len + i/8]|(128>>(i%8));
  708. !       }
  709. !      }
  710. !    
  711. !      /* create this character's bitmap ... */
  712. !      rotfont->per_char[ichar-32].glyph.bm=
  713. !        XCreatePixmap(dpy, root, bit_w, bit_h, 1);
  714. !      
  715. !      /* put the image into the bitmap ... */
  716. !      XPutImage(dpy, rotfont->per_char[ichar-32].glyph.bm, 
  717. !                font_gc, I2, 0, 0, 0, 0, bit_w, bit_h);
  718. !   
  719. !      /* free the image and data ... */
  720. !      XDestroyImage(I1);
  721. !      XDestroyImage(I2);
  722. !      free((char *)bitdata);
  723. !      free((char *)vertdata);
  724. !  }
  725.   
  726. -  if (dir != 0)
  727. -     XFreeFont(dpy, fontstruct);
  728.   
  729. !  /* free pixmap and GC ... */
  730. !  XFreePixmap(dpy, canvas);
  731. !  XFreeGC(dpy, font_gc);
  732.   
  733. !  return rotfont;
  734.   }
  735.   
  736.   
  737. --- 163,382 ----
  738.   /* ---------------------------------------------------------------------- */
  739.   
  740.   
  741. ! /**************************************************************************/
  742. ! /* Routine to replace `strtok' : this one returns a zero length string if */
  743. ! /* it encounters two consecutive delimiters                               */
  744. ! /**************************************************************************/
  745.   
  746. ! static char *my_strtok(str1, str2)
  747. !     char *str1, *str2;
  748.   {
  749. !     char *ret;
  750. !     int i, j, stop;
  751. !     static int start, len;
  752. !     static char *stext;
  753. !     
  754. !     if(str2==NULL)
  755. !     return NULL;
  756. !     
  757. !     /* initialise if str1 not NULL */
  758. !     if(str1!=NULL) {
  759. !     start=0;
  760. !     stext=str1;
  761. !     len=strlen(str1);
  762. !     }
  763. !     
  764. !     /* run out of tokens ? */
  765. !     if(start>=len)
  766. !     return NULL;
  767. !     
  768. !     /* loop through characters */
  769. !     for(i=start; i<len; i++) {
  770. !     /* loop through delimiters */
  771. !     stop=0;
  772. !     for(j=0; j<strlen(str2); j++)
  773. !         if(stext[i]==str2[j])
  774. !         stop=1;
  775. !     
  776. !     if(stop)
  777. !         break;
  778. !     }
  779. !     
  780. !     stext[i]='\0';
  781. !     
  782. !     ret=stext+start;
  783. !     
  784. !     start=i+1;
  785. !     
  786. !     return ret;
  787. ! }
  788.   
  789.   
  790. ! /* ---------------------------------------------------------------------- */
  791.   
  792.   
  793. ! /**************************************************************************/
  794. ! /* Return version/copyright information                                   */
  795. ! /**************************************************************************/
  796.   
  797. ! float XRotVersion(str, n)
  798. !     char *str;
  799. !     int n;
  800. ! {
  801. !     if(str!=NULL)
  802. !     strncpy(str, XV_COPYRIGHT, n);
  803. !     return XV_VERSION;
  804. ! }
  805.   
  806.   
  807. ! /* ---------------------------------------------------------------------- */
  808.   
  809.   
  810. ! /**************************************************************************/
  811. ! /* Set the font magnification factor for all subsequent operations        */
  812. ! /**************************************************************************/
  813. ! 
  814. ! void XRotSetMagnification(m)
  815. !     float m;
  816. ! {
  817. !     if(m>0.)
  818. !     style.magnify=m;
  819.   }
  820.   
  821.   
  822.   /* ---------------------------------------------------------------------- */
  823.   
  824. ! 
  825. ! /**************************************************************************/
  826. ! /* Set the padding used when calculating bounding boxes                   */
  827. ! /**************************************************************************/
  828. ! 
  829. ! void XRotSetBoundingBoxPad(p)
  830. !     int p;
  831.   {
  832. !     if(p>=0)
  833. !     style.bbx_pad=p;
  834. ! }
  835.   
  836.   
  837. ! /* ---------------------------------------------------------------------- */
  838.   
  839.   
  840. ! /**************************************************************************/
  841. ! /*  Create an XImage structure and allocate memory for it                 */
  842. ! /**************************************************************************/
  843.   
  844. ! static XImage *MakeXImage(dpy, w, h)
  845. !     Display *dpy;
  846. !     int w, h;
  847. ! {
  848. !     XImage *I;
  849. !     char *data;
  850. !     
  851. !     /* reserve memory for image */
  852. !     data=(char *)calloc((unsigned)(((w-1)/8+1)*h), 1);
  853. !     if(data==NULL)
  854. !     return NULL;
  855. !     
  856. !     /* create the XImage */
  857. !     I=XCreateImage(dpy, DefaultVisual(dpy, DefaultScreen(dpy)), 1, XYBitmap,
  858. !                    0, data, w, h, 8, 0);
  859. !     if(I==NULL)
  860. !     return NULL;
  861. !     
  862. !     I->byte_order=I->bitmap_bit_order=MSBFirst;
  863. !     return I;
  864. ! }
  865.   
  866.   
  867. ! /* ---------------------------------------------------------------------- */
  868.   
  869.   
  870. ! /**************************************************************************/
  871. ! /*  A front end to XRotPaintAlignedString:                                */
  872. ! /*      -no alignment, no background                                      */
  873. ! /**************************************************************************/
  874.   
  875. ! int XRotDrawString(dpy, font, angle, drawable, gc, x, y, str)
  876. !     Display *dpy;
  877. !     XFontStruct *font;
  878. !     float angle;
  879. !     Drawable drawable;
  880. !     GC gc;
  881. !     int x, y;
  882. !     char *str;
  883. ! {
  884. !     return (XRotPaintAlignedString(dpy, font, angle, drawable, gc,
  885. !                    x, y, str, NONE, 0));
  886. ! }
  887.   
  888.   
  889. ! /* ---------------------------------------------------------------------- */
  890.   
  891.   
  892. ! /**************************************************************************/
  893. ! /*  A front end to XRotPaintAlignedString:                                */
  894. ! /*      -no alignment, paints background                                  */
  895. ! /**************************************************************************/
  896.   
  897. ! int XRotDrawImageString(dpy, font, angle, drawable, gc, x, y, str)
  898. !     Display *dpy;
  899. !     XFontStruct *font;
  900. !     float angle;
  901. !     Drawable drawable;
  902. !     GC gc;
  903. !     int x, y;
  904. !     char *str;
  905. ! {
  906. !     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
  907. !                   x, y, str, NONE, 1));
  908. ! }
  909.   
  910.   
  911. ! /* ---------------------------------------------------------------------- */
  912.   
  913.   
  914. ! /**************************************************************************/
  915. ! /*  A front end to XRotPaintAlignedString:                                */
  916. ! /*      -does alignment, no background                                    */
  917. ! /**************************************************************************/
  918.   
  919. ! int XRotDrawAlignedString(dpy, font, angle, drawable, gc, x, y, text, align)
  920. !     Display *dpy;
  921. !     XFontStruct *font;
  922. !     float angle;
  923. !     Drawable drawable;
  924. !     GC gc;
  925. !     int x, y;
  926. !     char *text;
  927. !     int align;
  928. ! {
  929. !     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
  930. !                   x, y, text, align, 0));
  931. ! }
  932.   
  933.   
  934. ! /* ---------------------------------------------------------------------- */
  935.   
  936.   
  937. ! /**************************************************************************/
  938. ! /*  A front end to XRotPaintAlignedString:                                */
  939. ! /*      -does alignment, paints background                                */
  940. ! /**************************************************************************/
  941.   
  942. ! int XRotDrawAlignedImageString(dpy, font, angle, drawable, gc, x, y, text,
  943. !                    align)
  944. !     Display *dpy;
  945. !     XFontStruct *font;
  946. !     float angle;
  947. !     Drawable drawable;
  948. !     GC gc;
  949. !     int x, y;
  950. !     char *text;
  951. !     int align;
  952. ! {
  953. !     return(XRotPaintAlignedString(dpy, font, angle, drawable, gc,
  954. !                   x, y, text, align, 1));
  955.   }
  956.   
  957.   
  958. ***************
  959. *** 332,608 ****
  960.   /* ---------------------------------------------------------------------- */
  961.   
  962.   
  963. ! /* *** Free the resources associated with a rotated font *** */
  964.   
  965. ! void XRotUnloadFont(dpy, rotfont)
  966. !  Display *dpy;
  967. !  XRotFontStruct *rotfont;
  968.   {
  969. !  int ichar;
  970.   
  971. !  if(rotfont->dir==0) XFreeFont(dpy, rotfont->xfontstruct);
  972.   
  973. !  else
  974. !   /* loop through each character, freeing its pixmap ... */
  975. !   for(ichar=rotfont->min_char-32; ichar<=rotfont->max_char-32; ichar++)
  976. !     XFreePixmap(dpy, rotfont->per_char[ichar].glyph.bm);
  977.   
  978. !  /* rotfont should never be referenced again ... */
  979. !  free((char *)rotfont);
  980.   }
  981.   
  982.   
  983.   /* ---------------------------------------------------------------------- */
  984. -    
  985.   
  986. - /* *** Return the width of a string *** */
  987.   
  988. ! int XRotTextWidth(rotfont, str, len)
  989. !  XRotFontStruct *rotfont;
  990. !  char *str;
  991. !  int len;
  992.   {
  993. !  int i, width=0, ichar;
  994.   
  995. !  if(str==NULL) 
  996.       return 0;
  997.   
  998. !  if(rotfont->dir==0)
  999. !     width=XTextWidth(rotfont->xfontstruct, str, len);
  1000.   
  1001.