This commit was manufactured by cvs2svn to create branch 'bogue40'.

1 files changed, 0 insertions, 1026 deletions

diff --git a/generic/Rectangle.c b/generic/Rectangle.c
deleted file mode 100644
index 8afb38f..0000000
--- a/generic/Rectangle.c
+++ /dev/null
@@ -1,1026 +0,0 @@
-/*
- * Rectangle.c -- Implementation of rectangle item.
- *
- * Authors              : Patrick Lecoanet.
- * Creation date        : Fri Dec  2 14:47:42 1994
- *
- * $Id$
- */
-
-/*
- *  Copyright (c) 1994 - 2005 CENA, Patrick Lecoanet --
- *
- * See the file "Copyright" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
- *
- */
-
-
-#include "Item.h"
-#include "Geo.h"
-#include "Draw.h"
-#include "Types.h"
-#include "Image.h"
-#include "Color.h"
-#include "WidgetInfo.h"
-#include "tkZinc.h"
-
-
-static const char rcsid[] = "$Id$";
-static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $";
-
-/*
- * Bit offset of flags.
- */
-#define FILLED_BIT      1       /* If the rectangle is filled with color/pattern */
-#define ALIGNED_BIT     2
-
-
-/*
- **********************************************************************************
- *
- * Specific Rectangle item record
- *
- **********************************************************************************
- */
-
-typedef struct _RectangleItemStruct {
-  ZnItemStruct  header;
-
-  /* Public data */
-  ZnPoint       coords[2];
-  unsigned short flags;
-  ZnReliefStyle relief;
-  ZnLineStyle   line_style;
-  ZnDim         line_width;
-  ZnGradient    *line_color;
-  ZnImage       line_pattern;
-  ZnGradient    *fill_color;
-  ZnImage       tile;
-  
-  /* Private data */
-  ZnPoint       dev[4];
-  ZnGradient    *gradient;
-  ZnPoint       *grad_geo;
-} RectangleItemStruct, *RectangleItem;
-
-
-static ZnAttrConfig     rect_attrs[] = {
-  { ZN_CONFIG_BOOL, "-composealpha", NULL,
-    Tk_Offset(RectangleItemStruct, header.flags), ZN_COMPOSE_ALPHA_BIT,
-    ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_BOOL, "-composerotation", NULL,
-    Tk_Offset(RectangleItemStruct, header.flags), ZN_COMPOSE_ROTATION_BIT,
-    ZN_COORDS_FLAG, False },
-  { ZN_CONFIG_BOOL, "-composescale", NULL,
-    Tk_Offset(RectangleItemStruct, header.flags), ZN_COMPOSE_SCALE_BIT,
-    ZN_COORDS_FLAG, False },
-  { ZN_CONFIG_GRADIENT, "-fillcolor", NULL,
-    Tk_Offset(RectangleItemStruct, fill_color), 0,
-    ZN_COORDS_FLAG|ZN_BORDER_FLAG, False },
-  { ZN_CONFIG_BOOL, "-filled", NULL,
-    Tk_Offset(RectangleItemStruct, flags), FILLED_BIT, ZN_COORDS_FLAG, False },
-  { ZN_CONFIG_BITMAP, "-fillpattern", NULL,
-    Tk_Offset(RectangleItemStruct, tile), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_GRADIENT, "-linecolor", NULL,
-    Tk_Offset(RectangleItemStruct, line_color), 0,
-    ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_BITMAP, "-linepattern", NULL,
-    Tk_Offset(RectangleItemStruct, line_pattern), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_LINE_STYLE, "-linestyle", NULL,
-    Tk_Offset(RectangleItemStruct, line_style), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_DIM, "-linewidth", NULL,
-    Tk_Offset(RectangleItemStruct, line_width), 0, ZN_COORDS_FLAG, False },
-  { ZN_CONFIG_PRI, "-priority", NULL,
-    Tk_Offset(RectangleItemStruct, header.priority), 0,
-    ZN_DRAW_FLAG|ZN_REPICK_FLAG, False },
-  { ZN_CONFIG_RELIEF, "-relief", NULL, Tk_Offset(RectangleItemStruct, relief), 0,
-    ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_BOOL, "-sensitive", NULL,
-    Tk_Offset(RectangleItemStruct, header.flags), ZN_SENSITIVE_BIT,
-    ZN_REPICK_FLAG, False },
-  { ZN_CONFIG_TAG_LIST, "-tags", NULL,
-    Tk_Offset(RectangleItemStruct, header.tags), 0, 0, False },
-  { ZN_CONFIG_IMAGE, "-tile", NULL,
-    Tk_Offset(RectangleItemStruct, tile), 0, ZN_DRAW_FLAG, False },
-  { ZN_CONFIG_BOOL, "-visible", NULL,
-    Tk_Offset(RectangleItemStruct, header.flags), ZN_VISIBLE_BIT,
-    ZN_DRAW_FLAG|ZN_REPICK_FLAG|ZN_VIS_FLAG, False },
-  
-  { ZN_CONFIG_END, NULL, NULL, 0, 0, 0, False }
-};
-
-
-
-/*
- **********************************************************************************
- *
- * Init --
- *
- **********************************************************************************
- */
-static int
-Init(ZnItem             item,
-     int                *argc,
-     Tcl_Obj *CONST     *args[])
-{
-  ZnWInfo       *wi = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  unsigned int  num_points;
-  ZnPoint       *points;
-
-  rect->gradient = NULL;
-  rect->grad_geo = NULL;
-
-  /* Init attributes */
-  SET(item->flags, ZN_VISIBLE_BIT);
-  SET(item->flags, ZN_SENSITIVE_BIT);
-  SET(item->flags, ZN_COMPOSE_ALPHA_BIT);
-  SET(item->flags, ZN_COMPOSE_ROTATION_BIT);
-  SET(item->flags, ZN_COMPOSE_SCALE_BIT);
-  item->priority = 1;
-  
-  if (*argc < 1) {
-    Tcl_AppendResult(wi->interp, " rectangle coords expected", NULL);
-    return TCL_ERROR;
-  }
-  if (ZnParseCoordList(wi, (*args)[0], &points,
-                       NULL, &num_points, NULL) == TCL_ERROR) {
-    return TCL_ERROR;
-  }
-  if (num_points != 2) {
-    Tcl_AppendResult(wi->interp, " malformed rectangle coords", NULL);
-    return TCL_ERROR;
-  };
-  rect->coords[0] = points[0];
-  rect->coords[1] = points[1];
-  (*args)++;
-  (*argc)--;
-  
-  CLEAR(rect->flags, FILLED_BIT);
-  rect->relief = ZN_RELIEF_FLAT;
-  rect->line_style = ZN_LINE_SIMPLE;
-  rect->line_width = 1;
-  rect->line_pattern = ZnUnspecifiedImage;
-  rect->tile = ZnUnspecifiedImage;
-  rect->line_color = ZnGetGradientByValue(wi->fore_color);
-  rect->fill_color = ZnGetGradientByValue(wi->fore_color);
-  
-  return TCL_OK;
-}
-
-
-/*
- **********************************************************************************
- *
- * Clone --
- *
- **********************************************************************************
- */
-static void
-Clone(ZnItem    item)
-{
-  RectangleItem rect = (RectangleItem) item;
-
-  if (rect->gradient) {
-    rect->gradient = ZnGetGradientByValue(rect->gradient);
-  }
-  if (rect->tile != ZnUnspecifiedImage) {
-    rect->tile = ZnGetImageByValue(rect->tile, ZnUpdateItemImage, item);
-  }
-  if (rect->line_pattern != ZnUnspecifiedImage) {
-    rect->line_pattern = ZnGetImageByValue(rect->line_pattern, NULL, NULL);
-  }
-  rect->line_color = ZnGetGradientByValue(rect->line_color);
-  rect->fill_color = ZnGetGradientByValue(rect->fill_color);
-  rect->grad_geo = NULL;
-}
-
-
-/*
- **********************************************************************************
- *
- * Destroy --
- *
- **********************************************************************************
- */
-static void
-Destroy(ZnItem  item)
-{
-  RectangleItem rect = (RectangleItem) item;
-
-  if (rect->tile != ZnUnspecifiedImage) {
-    ZnFreeImage(rect->tile, ZnUpdateItemImage, item);
-    rect->tile = ZnUnspecifiedImage;
-  }
-  if (rect->gradient) {
-    ZnFreeGradient(rect->gradient);
-  }
-  if (rect->line_pattern != ZnUnspecifiedImage) {
-    ZnFreeImage(rect->line_pattern, NULL, NULL);
-    rect->line_pattern = ZnUnspecifiedImage;
-  }
-  if (rect->grad_geo) {
-    ZnFree(rect->grad_geo);
-  }
-  ZnFreeGradient(rect->fill_color);
-  ZnFreeGradient(rect->line_color);
-}
-
-
-/*
- **********************************************************************************
- *
- * Configure --
- *
- **********************************************************************************
- */
-static int
-Configure(ZnItem        item,
-          int           argc,
-          Tcl_Obj *CONST argv[],
-          int           *flags)
-{
-  ZnWInfo       *wi = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  int           status = TCL_OK;
-  XColor        *color;
-  unsigned short alpha;
-  
-  status = ZnConfigureAttributes(wi, item, item, rect_attrs, argc, argv, flags);
-  
-  if (rect->gradient &&
-      (ISSET(*flags, ZN_BORDER_FLAG) || (rect->relief == ZN_RELIEF_FLAT))) {
-    ZnFreeGradient(rect->gradient);
-    rect->gradient = NULL;
-  }
-  if ((rect->relief != ZN_RELIEF_FLAT) && !rect->gradient) {
-    color = ZnGetGradientColor(rect->line_color, 51.0, &alpha);
-    rect->gradient = ZnGetReliefGradient(wi->interp, wi->win,
-                                         Tk_NameOfColor(color), alpha);
-    if (rect->gradient == NULL) {
-      status = TCL_ERROR;
-    }
-  }
-
-  return status;
-}
-
-
-/*
- **********************************************************************************
- *
- * Query --
- *
- **********************************************************************************
- */
-static int
-Query(ZnItem            item,
-      int               argc,
-      Tcl_Obj *CONST    argv[])
-{
-  if (ZnQueryAttribute(item->wi->interp, item, rect_attrs, argv[0]) == TCL_ERROR) {
-    return TCL_ERROR;
-  }
-
-  return TCL_OK;
-}
-
-
-/*
- **********************************************************************************
- *
- * ComputeCoordinates --
- *
- **********************************************************************************
- */
-static void
-ComputeCoordinates(ZnItem       item,
-                   ZnBool       force)
-{
-  ZnWInfo       *wi = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  ZnPoint       p[4];
-  int           i;
-  ZnBool        aligned;
-  ZnDim         delta, lw2;
-  
-  ZnResetBBox(&item->item_bounding_box);
-  if (!rect->line_width && ISCLEAR(rect->flags, FILLED_BIT)) {
-    return;
-  }
-
-  p[0] = rect->coords[0];
-  p[2] = rect->coords[1];
-  p[1].x = p[2].x;
-  p[1].y = p[0].y;
-  p[3].x = p[0].x;
-  p[3].y = p[2].y;
-  ZnTransformPoints(wi->current_transfo, p, rect->dev, 4);
-  for (i = 0; i < 4; i++) {
-    rect->dev[i].x = ZnNearestInt(rect->dev[i].x);
-    rect->dev[i].y = ZnNearestInt(rect->dev[i].y);
-  }
-
-  /*
-   * Add all points to the bounding box. Then expand by the line
-   * width to account for mitered corners. This is an overestimate.
-   */
-  ZnAddPointsToBBox(&item->item_bounding_box, rect->dev, 4);
-  if (rect->line_width > 0) {
-    lw2 = rect->line_width/2.0;
-    item->item_bounding_box.orig.x -= lw2;
-    item->item_bounding_box.orig.y -= lw2;
-    item->item_bounding_box.corner.x += lw2;
-    item->item_bounding_box.corner.y += lw2;
-  }
-  item->item_bounding_box.orig.x -= 0.5;
-  item->item_bounding_box.orig.y -= 0.5;
-  item->item_bounding_box.corner.x += 0.5;
-  item->item_bounding_box.corner.y += 0.5;
-  
-  delta = rect->dev[0].y - rect->dev[1].y;
-  delta = ABS(delta);
-  aligned = delta < X_PRECISION_LIMIT;
-  delta = rect->dev[0].x - rect->dev[3].x;
-  delta = ABS(delta);
-  aligned &= delta < X_PRECISION_LIMIT;
-  ASSIGN(rect->flags, ALIGNED_BIT, aligned);
-  
-#ifdef GL
-  /*
-   * Compute the gradient geometry
-   */
-  if (!ZnGradientFlat(rect->fill_color)) {
-    ZnPoly      shape;
-    
-    if (rect->fill_color->type == ZN_AXIAL_GRADIENT) {
-      int       angle = rect->fill_color->angle;
-      
-      if ((angle != 0) && (angle != 90) && (angle != 180) && (angle != 270)) {
-        if (!rect->grad_geo) {
-          rect->grad_geo = ZnMalloc(6*sizeof(ZnPoint));
-        }
-        ZnPolyContour1(&shape, p, 4, False);
-        ZnComputeGradient(rect->fill_color, wi, &shape, rect->grad_geo);
-      }
-      else {
-        goto free_ggeo;
-      }
-    }
-    else {
-      if (!rect->grad_geo) {
-        rect->grad_geo = ZnMalloc(6*sizeof(ZnPoint));
-      }
-      if (rect->fill_color->type == ZN_PATH_GRADIENT) {
-        ZnPolyContour1(&shape, rect->coords, 2, False);
-      }
-      else {
-        ZnPolyContour1(&shape, p, 4, False);
-      }
-      ZnComputeGradient(rect->fill_color, wi, &shape, rect->grad_geo);
-    }
-  }
-  else {
-  free_ggeo:
-    if (rect->grad_geo) {
-      ZnFree(rect->grad_geo);
-      rect->grad_geo = NULL;
-    }
-  }
-#endif
-}
-
-
-/*
- **********************************************************************************
- *
- * ToArea --
- *      Tell if the object is entirely outside (-1),
- *      entirely inside (1) or in between (0).
- *
- **********************************************************************************
- */
-static int
-ToArea(ZnItem   item,
-       ZnToArea ta)
-{
-  RectangleItem rect = (RectangleItem) item;
-  int           result, result2;
-  ZnBBox        *area = ta->area;
-
-  result = -1;
-
-  if (ISSET(rect->flags, FILLED_BIT)) {
-    result = ZnPolygonInBBox(rect->dev, 4, area, NULL);
-    if (result == 0) {
-      return 0;
-    }
-  }
-  if (rect->line_width > 0) {
-    int         i;
-    ZnPoint     pts[5];
-
-    for (i = 0; i < 4; i++) {
-      pts[i] = rect->dev[i];
-    }
-    pts[4] = pts[0];
-    result2 = ZnPolylineInBBox(pts, 5, rect->line_width,
-                               CapProjecting, JoinMiter, area);
-    if (ISCLEAR(rect->flags, FILLED_BIT)) {
-      if (result2 == 0) {
-        return 0;
-      }
-      result = result2;
-    }
-    else if (result2 != result) {
-      return 0;
-    }
-  }
-
-  return result;
-}
-
-
-/*
- **********************************************************************************
- *
- * Draw --
- *
- **********************************************************************************
- */
-static void
-Draw(ZnItem     item)
-{
-  ZnWInfo       *wi  = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  XGCValues     values;
-  unsigned int  i, gc_mask;
-  XRectangle    r;
-  XPoint        xp[5];
-  
-  if (ISSET(rect->flags, ALIGNED_BIT)) {
-    if (rect->dev[0].x < rect->dev[2].x) {
-      r.x = (int) rect->dev[0].x;
-      r.width = ((int) rect->dev[2].x) - r.x;
-    }
-    else {
-      r.x = (int) rect->dev[2].x;
-      r.width = ((int) rect->dev[0].x) - r.x;
-    }
-    if (rect->dev[0].y < rect->dev[2].y) {
-      r.y = (int) rect->dev[0].y;
-      r.height = ((int) rect->dev[2].y) - r.y;
-    }
-    else {
-      r.y = (int) rect->dev[2].y;
-      r.height = ((int) rect->dev[0].y) - r.y;
-    }
-  }
-  else {
-    for (i = 0; i < 4; i++) {
-      xp[i].x = (int) rect->dev[i].x;
-      xp[i].y = (int) rect->dev[i].y;
-    }
-    xp[i] = xp[0];
-  }
-  
-  /*
-   * Fill if requested.
-   */
-  if (ISSET(rect->flags, FILLED_BIT)) {
-    values.foreground = ZnGetGradientPixel(rect->fill_color, 0.0);
-    if (rect->tile != ZnUnspecifiedImage) {
-      if (!ZnImageIsBitmap(rect->tile)) { /* Fill tiled */
-        values.fill_style = FillTiled;
-        values.tile = ZnImagePixmap(rect->tile, wi->win);
-        if (ISSET(rect->flags, ALIGNED_BIT)) {
-          values.ts_x_origin = (int) r.x;
-          values.ts_y_origin = (int) r.y;
-        }
-        else {
-          values.ts_x_origin = (int) item->item_bounding_box.orig.x;
-          values.ts_y_origin = (int) item->item_bounding_box.orig.y;
-        }
-        XChangeGC(wi->dpy, wi->gc,
-                  GCTileStipXOrigin|GCTileStipYOrigin|GCFillStyle|GCTile, &values);
-      }
-      else {
-        values.fill_style = FillStippled;
-        values.stipple = ZnImagePixmap(rect->tile, wi->win);
-        if (ISSET(rect->flags, ALIGNED_BIT)) {
-          values.ts_x_origin = (int) r.x;
-          values.ts_y_origin = (int) r.y;
-        }
-        else {
-          values.ts_x_origin = (int) item->item_bounding_box.orig.x;
-          values.ts_y_origin = (int) item->item_bounding_box.orig.y;
-        }
-        XChangeGC(wi->dpy, wi->gc,
-                  GCTileStipXOrigin|GCTileStipYOrigin|GCFillStyle|GCStipple|GCForeground,
-                  &values);
-      }
-    }
-    else { /* Fill solid */
-      values.fill_style = FillSolid;
-      XChangeGC(wi->dpy, wi->gc, GCForeground | GCFillStyle, &values);
-    }
-    if (ISSET(rect->flags, ALIGNED_BIT)) {
-      XFillRectangle(wi->dpy, wi->draw_buffer, wi->gc, r.x, r.y,
-                     r.width, r.height);
-    }
-    else {
-      XFillPolygon(wi->dpy, wi->draw_buffer, wi->gc, xp, 4, Convex, CoordModeOrigin);
-    }
-  }
-
-  /* Draw the outline */
-  if (rect->line_width) {
-    if (rect->relief != ZN_RELIEF_FLAT) {
-      if (ISSET(rect->flags, ALIGNED_BIT)) {
-        ZnDrawRectangleRelief(wi, rect->relief, rect->gradient,
-                              &r, rect->line_width);
-      }
-      else {
-        ZnPoint p[5];
-        for (i = 0; i < 4; i++) {
-          p[4-i].x = rect->dev[i].x;
-          p[4-i].y = rect->dev[i].y;
-        }
-        p[0] = p[4];
-        ZnDrawPolygonRelief(wi, rect->relief, rect->gradient,
-                            p, 5, rect->line_width);
-      }
-    }
-    else {
-      ZnSetLineStyle(wi, rect->line_style);
-      gc_mask = GCFillStyle|GCLineWidth|GCForeground|GCJoinStyle;
-      values.foreground = ZnGetGradientPixel(rect->line_color, 0.0);
-      values.line_width = (rect->line_width == 1) ? 0 : (int) rect->line_width;
-      values.join_style = JoinMiter;
-      if (ISCLEAR(rect->flags, ALIGNED_BIT)) {
-        gc_mask |= GCCapStyle;
-        values.cap_style = CapProjecting;
-      }
-      if (rect->line_pattern == ZnUnspecifiedImage) {
-        values.fill_style = FillSolid;
-        XChangeGC(wi->dpy, wi->gc, gc_mask, &values);
-      }
-      else {
-        values.fill_style = FillStippled;
-        values.stipple = ZnImagePixmap(rect->line_pattern, wi->win);
-        gc_mask |= GCStipple;
-        XChangeGC(wi->dpy, wi->gc, gc_mask, &values);
-      }
-      if (ISSET(rect->flags, ALIGNED_BIT)) {
-        XDrawRectangle(wi->dpy, wi->draw_buffer, wi->gc, r.x, r.y,
-                       r.width, r.height);
-      }
-      else {
-        XDrawLines(wi->dpy, wi->draw_buffer, wi->gc, xp, 5, CoordModeOrigin);
-      }
-    }
-  }
-}
-
-
-/*
- **********************************************************************************
- *
- * Render --
- *
- **********************************************************************************
- */
-#ifdef GL
-static void
-RectRenderCB(void *closure)
-{
-  RectangleItem rect = (RectangleItem) closure;
-
-  glBegin(GL_TRIANGLE_STRIP);
-  glVertex2d(rect->dev[0].x, rect->dev[0].y);
-  glVertex2d(rect->dev[3].x, rect->dev[3].y);
-  glVertex2d(rect->dev[1].x, rect->dev[1].y);
-  glVertex2d(rect->dev[2].x, rect->dev[2].y);
-  glEnd();
-}
-#endif
-
-#ifdef GL
-static void
-Render(ZnItem   item)
-{
-  ZnWInfo       *wi  = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  int           i;
-
-#ifdef GL_LIST
-  if (!item->gl_list) {
-    item->gl_list = glGenLists(1);
-    glNewList(item->gl_list, GL_COMPILE);
-#endif
-    if (ISSET(rect->flags, FILLED_BIT)) {
-      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
-      
-      if (!ZnGradientFlat(rect->fill_color)) {
-        ZnBool  fast = (rect->fill_color->type == ZN_AXIAL_GRADIENT) && !rect->grad_geo;
-        ZnPoly  poly;
-        
-        ZnPolyContour1(&poly, rect->dev, 4, False);
-        ZnRenderGradient(wi, rect->fill_color,
-                         fast ? NULL: RectRenderCB, rect,
-                         fast ? rect->dev : rect->grad_geo, &poly);
-      }
-      else if (rect->tile != ZnUnspecifiedImage) { /* Fill tiled/patterned */
-        if (ISSET(rect->flags, ALIGNED_BIT)) {
-          ZnBBox bbox;
-
-          bbox.orig = rect->dev[0];
-          bbox.corner = rect->dev[2];
-          ZnRenderTile(wi, rect->tile, rect->fill_color, NULL, NULL, (ZnPoint *) &bbox);
-        }
-        else {
-          ZnRenderTile(wi, rect->tile, rect->fill_color, RectRenderCB,
-                       rect, (ZnPoint *) &item->item_bounding_box);
-        }
-      }
-      else {
-        unsigned short alpha;
-        XColor *color = ZnGetGradientColor(rect->fill_color, 0.0, &alpha);
-        alpha = ZnComposeAlpha(alpha, wi->alpha);
-        glColor4us(color->red, color->green, color->blue, alpha);
-        RectRenderCB(rect);
-      }
-    }
-    
-    if (rect->line_width) {
-      ZnPoint p[5];
-      for (i = 0; i < 4; i++) {
-        p[4-i].x = rect->dev[i].x;
-        p[4-i].y = rect->dev[i].y;
-      }
-      p[0] = p[4];
-      if (rect->relief != ZN_RELIEF_FLAT) {
-        ZnRenderPolygonRelief(wi, rect->relief, rect->gradient, False,
-                              p, 5, rect->line_width);
-      }
-      else {
-        ZnRenderPolyline(wi, p, 5, rect->line_width,
-                         rect->line_style, CapRound, JoinMiter,
-                         NULL, NULL, rect->line_color);
-      }
-    }
-#ifdef GL_LIST    
-    glEndList();
-  }
-  
-  glCallList(item->gl_list);
-#endif
-}
-#else
-static void
-Render(ZnItem   item)
-{
-}
-#endif
- 
-
-/*
- **********************************************************************************
- *
- * IsSensitive --
- *
- **********************************************************************************
- */
-static ZnBool
-IsSensitive(ZnItem      item,
-            int         item_part)
-{
-  return (ISSET(item->flags, ZN_SENSITIVE_BIT) &&
-          item->parent->class->IsSensitive(item->parent, ZN_NO_PART));
-}
-
-
-/*
- **********************************************************************************
- *
- * Pick --
- *
- **********************************************************************************
- */
-static double
-Pick(ZnItem     item,
-     ZnPick     ps)
-{
-  RectangleItem rect = (RectangleItem) item;
-  double        best_dist;
-  ZnPoint       *p = ps->point;
-
-  best_dist = ZnPolygonToPointDist(rect->dev, 4, p);
-
-  if (ISSET(rect->flags, FILLED_BIT)) {
-    if (best_dist <= 0.0) {
-      return 0.0;
-    }
-  }
-  best_dist = ABS(best_dist);
-  
-  if (rect->line_width > 1) {
-    double      dist;
-    int         i;
-    ZnPoint     pts[5];
-
-    for (i = 0; i < 4; i++) {
-      pts[i] = rect->dev[i];
-    }
-    pts[4] = pts[0];
-    dist = ZnPolylineToPointDist(pts, 5, rect->line_width,
-                                 CapProjecting, JoinMiter, p);
-    if (dist <= 0.0) {
-      return 0.0;
-    }
-    best_dist = MIN(dist, best_dist);
-  }
-
-  return best_dist;
-}
-
-
-/*
- **********************************************************************************
- *
- * PostScript --
- *
- **********************************************************************************
- */
-static int
-PostScript(ZnItem item,
-           ZnBool prepass,
-           ZnBBox *area)
-{
-  ZnWInfo       *wi = item->wi;
-  RectangleItem rect = (RectangleItem) item;
-  char          path[500];
-
-  if (ISCLEAR(rect->flags, FILLED_BIT) && (rect->line_width == 0)) {
-    return TCL_OK;
-  }
-
-  /*
-   * Create the rectangle path.
-   */
-  sprintf(path, "%.15g %.15g moveto %.15g %.15g lineto %.15g %.15g lineto %.15g %.15g lineto closepath\n",
-          rect->dev[0].x, rect->dev[0].y, rect->dev[1].x, rect->dev[1].y,
-          rect->dev[2].x, rect->dev[2].y, rect->dev[3].x, rect->dev[3].y);
-  Tcl_AppendResult(wi->interp, path, NULL);
-
-  /*
-   * Emit code to draw the filled area.
-   */
-  if (ISSET(rect->flags, FILLED_BIT)) {
-    if (rect->line_width) {
-      Tcl_AppendResult(wi->interp, "gsave\n", NULL);
-    }
-    if (!ZnGradientFlat(rect->fill_color)) {
-      if (ZnPostscriptGradient(wi->interp, wi->ps_info, rect->fill_color,
-                               rect->grad_geo ? rect->grad_geo : rect->dev, NULL) != TCL_OK) {
-        return TCL_ERROR;
-      }
-    }
-    else if (rect->tile != ZnUnspecifiedImage) {
-      if (!ZnImageIsBitmap(rect->tile)) { /* Fill tiled */
-        if (ZnPostscriptTile(wi->interp, wi->win, wi->ps_info, rect->tile) != TCL_OK) {
-          return TCL_ERROR;
-        }
-      }
-      else { /* Fill stippled */
-        if (Tk_PostscriptColor(wi->interp, wi->ps_info,
-                               ZnGetGradientColor(rect->fill_color, 0.0, NULL)) != TCL_OK) {
-          return TCL_ERROR;
-        }
-        Tcl_AppendResult(wi->interp, "clip ", NULL);
-        if (ZnPostscriptStipple(wi->interp, wi->win, wi->ps_info, rect->tile) != TCL_OK) {
-          return TCL_ERROR;
-        }
-      }
-    }
-    else { /* Fill solid */
-      if (Tk_PostscriptColor(wi->interp, wi->ps_info,
-                             ZnGetGradientColor(rect->fill_color, 0.0, NULL)) != TCL_OK) {
-        return TCL_ERROR;
-      }
-      Tcl_AppendResult(wi->interp, "fill\n", NULL);
-    }
-    if (rect->line_width) {
-      Tcl_AppendResult(wi->interp, "grestore\n", NULL);
-    }
-  }
-
-  /*
-   * Then emit code code to stroke the outline.
-   */
-  if (rect->line_width) {
-    if (rect->relief != ZN_RELIEF_FLAT) {
-      /* TODO No support yet */
-    }
-    else {
-      Tcl_AppendResult(wi->interp, "0 setlinejoin 2 setlinecap\n", NULL);
-      if (ZnPostscriptOutline(wi->interp, wi->ps_info, wi->win,
-                              rect->line_width, rect->line_style,
-                              rect->line_color, rect->line_pattern) != TCL_OK) {
-        return TCL_ERROR;
-      }
-    }
-  }
-
-  return TCL_OK;
-}
-
-
-/*
- **********************************************************************************
- *
- * GetClipVertices --
- *      Get the clipping shape.
- *      Never ever call ZnTriFree on the tristrip returned by GetClipVertices.
- *
- **********************************************************************************
- */
-static ZnBool
-GetClipVertices(ZnItem          item,
-                ZnTriStrip      *tristrip)
-{
-  RectangleItem rect = (RectangleItem) item;
-  ZnPoint       *points;
-
-  if (ISSET(rect->flags, ALIGNED_BIT)) {
-    ZnListAssertSize(ZnWorkPoints, 2);
-    points = ZnListArray(ZnWorkPoints);
-    ZnTriStrip1(tristrip, points, 2, False);
-    tristrip->strips[0].fan = False;
-  
-    if (rect->dev[0].x < rect->dev[2].x) {
-      points[0].x = rect->dev[0].x;
-      points[1].x = rect->dev[2].x+1.0;
-    }
-    else {
-      points[0].x = rect->dev[2].x;
-      points[1].x = rect->dev[0].x+1.0;
-    }
-    if (rect->dev[0].y < rect->dev[2].y) {
-      points[0].y = rect->dev[0].y;
-      points[1].y = rect->dev[2].y+1.0;
-    }
-    else {
-      points[0].y = rect->dev[2].y;
-      points[1].y = rect->dev[0].y+1.0;
-    }
-  }
-  else {
-    ZnListAssertSize(ZnWorkPoints, 4);
-    points = ZnListArray(ZnWorkPoints);
-    points[0] = rect->dev[1];
-    points[1] = rect->dev[2];
-    points[2] = rect->dev[0];
-    points[3] = rect->dev[3];
-    ZnTriStrip1(tristrip, points, 4, False);
-  }
-
-  return ISSET(rect->flags, ALIGNED_BIT);
-}
-
-
-/*
- **********************************************************************************
- *
- * Coords --
- *      Return or edit the item vertices.
- *
- **********************************************************************************
- */
-static int
-Coords(ZnItem           item,
-       int              contour,
-       int              index,
-       int              cmd,
-       ZnPoint          **pts,
-       char             **controls,
-       unsigned int     *num_pts)
-{
-  RectangleItem rect = (RectangleItem) item;
-
-  if ((cmd == ZN_COORDS_ADD) || (cmd == ZN_COORDS_ADD_LAST) || (cmd == ZN_COORDS_REMOVE)) {
-    Tcl_AppendResult(item->wi->interp,
-                     " rectangles can't add or remove vertices", NULL);
-    return TCL_ERROR;
-  }
-  else if (cmd == ZN_COORDS_REPLACE_ALL) {
-    if (*num_pts != 2) {
-      Tcl_AppendResult(item->wi->interp,
-                       " coords command need 2 points on rectangles", NULL);
-      return TCL_ERROR;
-    }
-    rect->coords[0] = (*pts)[0];
-    rect->coords[1] = (*pts)[1];
-    ZnITEM.Invalidate(item, ZN_COORDS_FLAG);
-  }
-  else if (cmd == ZN_COORDS_REPLACE) {
-    if (*num_pts < 1) {
-      Tcl_AppendResult(item->wi->interp,
-                       " coords command need at least 1 point", NULL);
-      return TCL_ERROR;
-    }
-    if (index < 0) {
-      index += 2;
-    }
-    if ((index < 0) || (index > 1)) {
-    range_err:
-      Tcl_AppendResult(item->wi->interp,
-                       " incorrect coord index, should be between -2 and 1", NULL);
-      return TCL_ERROR;
-    }
-    rect->coords[index] = (*pts)[0];
-    ZnITEM.Invalidate(item, ZN_COORDS_FLAG);
-  }
-  else if (cmd == ZN_COORDS_READ_ALL) {
-    *num_pts = 2;
-    *pts = rect->coords;
-  }
-  else if (cmd == ZN_COORDS_READ) {
-    if (index < 0) {
-      index += 2;
-    }
-    if ((index < 0) || (index > 1)) {
-      goto range_err;
-    }
-    *num_pts = 1;
-    *pts = &rect->coords[index];
-  }
-
-  return TCL_OK;
-}
-
-
-/*
- **********************************************************************************
- *
- * GetAnchor --
- *
- **********************************************************************************
- */
-static void
-GetAnchor(ZnItem        item,
-          Tk_Anchor     anchor,
-          ZnPoint       *p)
-{
-  ZnBBox *bbox = &item->item_bounding_box;
-
-  ZnOrigin2Anchor(&bbox->orig,
-                  bbox->corner.x - bbox->orig.x,
-                  bbox->corner.y - bbox->orig.y,
-                  anchor, p);
-}
-
-
-/*
- **********************************************************************************
- *
- * Exported functions struct --
- *
- **********************************************************************************
- */ 
-static ZnItemClassStruct RECTANGLE_ITEM_CLASS = {
-  "rectangle",
-  sizeof(RectangleItemStruct),
-  rect_attrs,
-  0,                    /* num_parts */
-  0,                    /* flags */
-  -1,
-  Init,
-  Clone,
-  Destroy,
-  Configure,
-  Query,
-  NULL,                 /* GetFieldSet */
-  GetAnchor,
-  GetClipVertices,
-  NULL,                 /* GetContours */
-  Coords,
-  NULL,                 /* InsertChars */
-  NULL,                 /* DeleteChars */
-  NULL,                 /* Cursor */
-  NULL,                 /* Index */
-  NULL,                 /* Part */
-  NULL,                 /* Selection */
-  NULL,                 /* Contour */
-  ComputeCoordinates,
-  ToArea,
-  Draw,
-  Render,
-  IsSensitive,
-  Pick,
-  NULL,                 /* PickVertex */
-  PostScript
-};
-
-ZnItemClassId ZnRectangle = (ZnItemClassId) &RECTANGLE_ITEM_CLASS;