~ubuntu-branches/ubuntu/jaunty/flwm/jaunty

// Rotated text drawing with X.

// Original code:
// Copyright (c) 1992 Alan Richardson (mppa3@uk.ac.sussex.syma) */
//
// Modifications for fltk:
// Copyright (c) 1997 Bill Spitzak (spitzak@d2.com)
// Modifications are to draw using the current fl_font.  All fonts
// used are cached in local structures.  This can get real expensive,
// use "

/* xvertext, Copyright (c) 1992 Alan Richardson (mppa3@uk.ac.sussex.syma)
 *
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose and without fee is hereby granted, provided
 * that the above copyright notice appear in all copies and that both the
 * copyright notice and this permission notice appear in supporting
 * documentation.  All work developed as a consequence of the use of
 * this program should duly acknowledge such use. No representations are
 * made about the suitability of this software for any purpose.  It is
 * provided "as is" without express or implied warranty.
 */

// if not defined then portions not used by flwm are included:
#define FLWM 1

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

#include <FL/x.H>
#if FL_MAJOR_VERSION < 2
# define XWindow Window
#endif
#include <FL/fl_draw.H>
#include "Rotated.H"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

struct BitmapStruct {
  int			 bit_w;
  int			 bit_h;
  Pixmap bm;
};

struct XRotCharStruct {
  int			 ascent;
  int			 descent;
  int			 lbearing;
  int			 rbearing;
  int			 width;
  BitmapStruct	 glyph;
};

struct XRotFontStruct {
  int			 dir;
  int			 height;
  int			 max_ascent;
  int			 max_descent;
  int			 max_char;
  int			 min_char;
  XFontStruct*		 xfontstruct;
  XRotCharStruct	 per_char[256];
};

/* *** Load the rotated version of a given font *** */
 
static XRotFontStruct*
XRotLoadFont(Display *dpy, XFontStruct* fontstruct, int dir)
{
  char val;
  XImage *I1, *I2;
  Pixmap canvas;
  XWindow root;
  int screen;
  GC font_gc;
  char text[3];/*, errstr[300];*/
  
  XRotFontStruct *rotfont;
  int ichar, i, j, index, boxlen = 60;
  int vert_w, vert_h, vert_len, bit_w, bit_h, bit_len;
  int min_char, max_char;
  unsigned char *vertdata, *bitdata;
  int ascent, descent, lbearing, rbearing;
  int on = 1, off = 0;

  /* useful macros ... */
  screen = DefaultScreen(dpy);
  root = DefaultRootWindow(dpy);

  /* create the depth 1 canvas bitmap ... */
  canvas = XCreatePixmap(dpy, root, boxlen, boxlen, 1);
 
  /* create a GC ... */
  font_gc = XCreateGC(dpy, canvas, 0, 0);
  XSetBackground(dpy, font_gc, off);

  XSetFont(dpy, font_gc, fontstruct->fid);

  /* allocate space for rotated font ... */
  rotfont = (XRotFontStruct *)malloc((unsigned)sizeof(XRotFontStruct));
   
  /* determine which characters are defined in font ... */
  min_char = fontstruct->min_char_or_byte2; 
  if (min_char<0)  min_char = 0;
  rotfont->min_char = min_char;
  max_char = fontstruct->max_char_or_byte2;
  if (max_char>255) max_char = 255;
  rotfont->max_char = max_char;
     
  /* some overall font data ... */
  rotfont->dir = dir;
  rotfont->max_ascent = fontstruct->max_bounds.ascent;
  rotfont->max_descent = fontstruct->max_bounds.descent;   
  rotfont->height = rotfont->max_ascent+rotfont->max_descent;

  rotfont->xfontstruct = fontstruct;
  /* remember xfontstruct for `normal' text ... */
  if (dir != 0) {
    /* font needs rotation ... */
    /* loop through each character ... */
    for (ichar = min_char; ichar <= max_char; ichar++) {

      index = ichar-fontstruct->min_char_or_byte2;

      XCharStruct* charstruct;
      if (fontstruct->per_char)
	charstruct = fontstruct->per_char+index;
      else
	charstruct = &fontstruct->min_bounds;

      /* per char dimensions ... */
      ascent =   rotfont->per_char[ichar].ascent   = charstruct->ascent;
      descent =  rotfont->per_char[ichar].descent  = charstruct->descent;
      lbearing = rotfont->per_char[ichar].lbearing = charstruct->lbearing;
      rbearing = rotfont->per_char[ichar].rbearing = charstruct->rbearing;
                 rotfont->per_char[ichar].width    = charstruct->width;

      /* some space chars have zero body, but a bitmap can't have ... */
      if (!ascent && !descent)   
	ascent =   rotfont->per_char[ichar].ascent =   1;
      if (!lbearing && !rbearing) 
	rbearing = rotfont->per_char[ichar].rbearing = 1;

      /* glyph width and height when vertical ... */
      vert_w = rbearing-lbearing;
      vert_h = ascent+descent;

      /* width in bytes ... */
      vert_len = (vert_w-1)/8+1;   
 
      XSetForeground(dpy, font_gc, off);
      XFillRectangle(dpy, canvas, font_gc, 0, 0, boxlen, boxlen);

      /* draw the character centre top right on canvas ... */
      sprintf(text, "%c", ichar);
      XSetForeground(dpy, font_gc, on);
      XDrawImageString(dpy, canvas, font_gc, boxlen/2 - lbearing,
		       boxlen/2 - descent, text, 1);

      /* reserve memory for first XImage ... */
      vertdata = (unsigned char *) malloc((unsigned)(vert_len*vert_h));
  
      /* create the XImage ... */
      I1 = XCreateImage(dpy, DefaultVisual(dpy, screen), 1, XYBitmap,
			0, (char *)vertdata, vert_w, vert_h, 8, 0);

//      if (I1 == NULL) ... do something here
  
      I1->byte_order = I1->bitmap_bit_order = MSBFirst;
   
      /* extract character from canvas ... */
      XGetSubImage(dpy, canvas, boxlen/2, boxlen/2-vert_h,
		   vert_w, vert_h, 1, XYPixmap, I1, 0, 0);
      I1->format = XYBitmap; 
 
      /* width, height of rotated character ... */
      if (dir == 2) { 
	bit_w = vert_w;
	bit_h = vert_h; 
      } else {
	bit_w = vert_h;
	bit_h = vert_w; 
      }

      /* width in bytes ... */
      bit_len = (bit_w-1)/8 + 1;

      rotfont->per_char[ichar].glyph.bit_w = bit_w;
      rotfont->per_char[ichar].glyph.bit_h = bit_h;

      /* reserve memory for the rotated image ... */
      bitdata = (unsigned char *)calloc((unsigned)(bit_h*bit_len), 1);

      /* create the image ... */
      I2 = XCreateImage(dpy, DefaultVisual(dpy, screen), 1, XYBitmap, 0,
			(char *)bitdata, bit_w, bit_h, 8, 0); 
 
//    if (I2 == NULL) ... error

      I2->byte_order = I2->bitmap_bit_order = MSBFirst;
 
      /* map vertical data to rotated character ... */
      for (j = 0; j < bit_h; j++) {
	for (i = 0; i < bit_w; i++) {
	  /* map bits ... */
	  if (dir == 1)
	    val = vertdata[i*vert_len + (vert_w-j-1)/8] &
	      (128>>((vert_w-j-1)%8));
   
	  else if (dir == 2)
	    val = vertdata[(vert_h-j-1)*vert_len + (vert_w-i-1)/8] &
	      (128>>((vert_w-i-1)%8));
                    
	  else 
	    val = vertdata[(vert_h-i-1)*vert_len + j/8] & 
	      (128>>(j%8));
        
	  if (val) 
	    bitdata[j*bit_len + i/8] = bitdata[j*bit_len + i/8] |
	      (128>>(i%8));
	}
      }
   
      /* create this character's bitmap ... */
      rotfont->per_char[ichar].glyph.bm = 
	XCreatePixmap(dpy, root, bit_w, bit_h, 1);
     
      /* put the image into the bitmap ... */
      XPutImage(dpy, rotfont->per_char[ichar].glyph.bm, 
		font_gc, I2, 0, 0, 0, 0, bit_w, bit_h);
  
      /* free the image and data ... */
      XDestroyImage(I1);
      XDestroyImage(I2);
      /*      free((char *)bitdata);  -- XDestroyImage does this
	      free((char *)vertdata);*/
    }

  }
  
  for (ichar = 0; ichar < min_char; ichar++)
    rotfont->per_char[ichar] = rotfont->per_char[int('?')];
  for (ichar = max_char+1; ichar < 256; ichar++)
    rotfont->per_char[ichar] = rotfont->per_char[int('?')];

  /* free pixmap and GC ... */
  XFreePixmap(dpy, canvas);
  XFreeGC(dpy, font_gc);

  return rotfont;
}

/* *** Free the resources associated with a rotated font *** */

static void XRotUnloadFont(Display *dpy, XRotFontStruct *rotfont)
{
  int ichar;

  if (rotfont->dir != 0) {
    /* loop through each character, freeing its pixmap ... */
    for (ichar = rotfont->min_char; ichar <= rotfont->max_char; ichar++)
      XFreePixmap(dpy, rotfont->per_char[ichar].glyph.bm);
  }
  /* rotfont should never be referenced again ... */
  free((char *)rotfont);
}

/* ---------------------------------------------------------------------- */

/* *** A front end to XRotPaintString : mimics XDrawString *** */

static void
XRotDrawString(Display *dpy, XRotFontStruct *rotfont, Drawable drawable,
	       GC gc, int x, int y, const char *str, int len)
{            
  int i, xp, yp, dir, ichar;

  if (str == NULL || len<1) return;

  dir = rotfont->dir;

  /* a horizontal string is easy ... */
  if (dir == 0) {
    XSetFont(dpy, gc, rotfont->xfontstruct->fid);
    XDrawString(dpy, drawable, gc, x, y, str, len);
    return;
  }

  /* vertical or upside down ... */

  XSetFillStyle(dpy, gc, FillStippled);

  /* loop through each character in string ... */
  for (i = 0; i<len; i++) {
    ichar = ((unsigned char*)str)[i];

    /* suitable offset ... */
    if (dir == 1) {
      xp = x-rotfont->per_char[ichar].ascent;
      yp = y-rotfont->per_char[ichar].rbearing; 
    }
    else if (dir == 2) {
      xp = x-rotfont->per_char[ichar].rbearing;
      yp = y-rotfont->per_char[ichar].descent+1; 
    }
    else {
      xp = x-rotfont->per_char[ichar].descent+1;  
      yp = y+rotfont->per_char[ichar].lbearing; 
    }
                   
    /* draw the glyph ... */
    XSetStipple(dpy, gc, rotfont->per_char[ichar].glyph.bm);

    XSetTSOrigin(dpy, gc, xp, yp);

    XFillRectangle(dpy, drawable, gc, xp, yp,
		   rotfont->per_char[ichar].glyph.bit_w,
		   rotfont->per_char[ichar].glyph.bit_h);

    /* advance position ... */
    if (dir == 1)
      y -= rotfont->per_char[ichar].width;
    else if (dir == 2)
      x -= rotfont->per_char[ichar].width;
    else 
      y += rotfont->per_char[ichar].width;
  }
  XSetFillStyle(dpy, gc, FillSolid);
}

#ifndef FLWM
/* *** Return the width of a string *** */

static int XRotTextWidth(XRotFontStruct *rotfont, const char *str, int len)
{
  int i, width = 0, ichar;

  if (str == NULL) return 0;

  if (rotfont->dir == 0)
    width = XTextWidth(rotfont->xfontstruct, str, strlen(str));

  else
    for (i = 0; i<len; i++) {
      width += rotfont->per_char[((unsigned char*)str)[i]].width;
    }

  return width;
}
#endif

/* ---------------------------------------------------------------------- */

// the public functions use the fltk global variables for font & gc:

static XRotFontStruct* font;

static void setrotfont(int angle) {
  /* make angle positive ... */
  if (angle < 0) do angle += 360; while (angle < 0);
  /* get nearest vertical or horizontal direction ... */
  int dir = ((angle+45)/90)%4;
  if (font) {
    if (font->xfontstruct == fl_xfont && font->dir == dir) return;
    XRotUnloadFont(fl_display, font);
  }
  font = XRotLoadFont(fl_display, fl_xfont, dir);
}

void draw_rotated(const char* text, int n, int x, int y, int angle) {
  if (!text || !*text) return;
  setrotfont(angle);
  XRotDrawString(fl_display, font, fl_window, fl_gc, x, y, text, n);
}

#if !defined(FLWM) || FL_MAJOR_VERSION>=2
void draw_rotated(const char* text, int x, int y, int angle) {
  if (!text || !*text) return;
  draw_rotated(text, strlen(text), x, y, angle);
}
#endif

static void draw_rot90(const char* str, int n, int x, int y) {
  draw_rotated(str, n, y, -x, 90);
}
void draw_rotated90(
  const char* str, 	// the (multi-line) string
  int x, int y, int w, int h, 	// bounding box
  Fl_Align align) {
  if (!str || !*str) return;
  if (w && h && !fl_not_clipped(x, y, w, h)) return;
  if (align & FL_ALIGN_CLIP) fl_clip(x, y, w, h);
#if FL_MAJOR_VERSION>1
  setrotfont(90);
  int a = font->xfontstruct->ascent;
  int d = font->xfontstruct->descent;
  XRotDrawString(fl_display, font, fl_window, fl_gc,
		 x+(w+a-d+1)/2, y+h, str, strlen(str));
#else
  int a1 = align&(-16);
  if (align & FL_ALIGN_LEFT) a1 |= FL_ALIGN_TOP;
  if (align & FL_ALIGN_RIGHT) a1 |= FL_ALIGN_BOTTOM;
  if (align & FL_ALIGN_TOP) a1 |= FL_ALIGN_RIGHT;
  if (align & FL_ALIGN_BOTTOM) a1 |= FL_ALIGN_LEFT;
  fl_draw(str, -(y+h), x, h, w, (Fl_Align)a1, draw_rot90);
#endif
  if (align & FL_ALIGN_CLIP) fl_pop_clip();
}

#ifndef FLWM
static void draw_rot180(const char* str, int n, int x, int y) {
  draw_rotated(str, n, -x, -y, 180);
}
void draw_rotated180(
  const char* str, 	// the (multi-line) string
  int x, int y, int w, int h, 	// bounding box
  Fl_Align align) {
  int a1 = align&(-16);
  if (align & FL_ALIGN_LEFT) a1 |= FL_ALIGN_RIGHT;
  if (align & FL_ALIGN_RIGHT) a1 |= FL_ALIGN_LEFT;
  if (align & FL_ALIGN_TOP) a1 |= FL_ALIGN_BOTTOM;
  if (align & FL_ALIGN_BOTTOM) a1 |= FL_ALIGN_TOP;
  fl_draw(str, -(x+w), -(y+h), w, h, (Fl_Align)a1, draw_rot180);
}

static void draw_rot270(const char* str, int n, int x, int y) {
  draw_rotated(str, n, -y, x, 270);
}
void draw_rotated270(
  const char* str, 	// the (multi-line) string
  int x, int y, int w, int h, 	// bounding box
  Fl_Align align) {
  int a1 = align&(-16);
  if (align & FL_ALIGN_LEFT) a1 |= FL_ALIGN_BOTTOM;
  if (align & FL_ALIGN_RIGHT) a1 |= FL_ALIGN_TOP;
  if (align & FL_ALIGN_TOP) a1 |= FL_ALIGN_LEFT;
  if (align & FL_ALIGN_BOTTOM) a1 |= FL_ALIGN_RIGHT;
  fl_draw(str, y, -(x+w), h, w, (Fl_Align)a1, draw_rot270);
}
#endif