[Pkg-octave-commit] r2327 - in octave/trunk/debian: . in patches

Rafael Laboissiere rafael at alioth.debian.org
Mon Jul 21 18:04:33 UTC 2008


Author: rafael
Date: 2008-07-21 18:04:33 +0000 (Mon, 21 Jul 2008)
New Revision: 2327

Added:
   octave/trunk/debian/patches/add-gl-render-cc.dpatch
Modified:
   octave/trunk/debian/changelog
   octave/trunk/debian/in/00list
Log:
Add patch for including file lacking in the upstream tarball


Modified: octave/trunk/debian/changelog
===================================================================
--- octave/trunk/debian/changelog	2008-07-21 16:46:44 UTC (rev 2326)
+++ octave/trunk/debian/changelog	2008-07-21 18:04:33 UTC (rev 2327)
@@ -2,7 +2,10 @@
 
   * debian/in/copyright: Add tag for octave3.1, which produces a meaningful
     license text in debian/copyright
-  * debian/in/PACKAGE{.conf,.dirs,-emacsen.dirs}: Also adapted for octave3.1
+  * debian/in/PACKAGE{.conf,.dirs,-emacsen.dirs}: Also adapted for
+    octave3.1
+  * debian/patches/add-gl-render-cc.dpatch: Add patch for including a file
+    lacking in the upstream tarball
 
  -- Rafael Laboissiere <rafael at debian.org>  Mon, 21 Jul 2008 18:32:52 +0200
 

Modified: octave/trunk/debian/in/00list
===================================================================
--- octave/trunk/debian/in/00list	2008-07-21 16:46:44 UTC (rev 2326)
+++ octave/trunk/debian/in/00list	2008-07-21 18:04:33 UTC (rev 2327)
@@ -26,4 +26,5 @@
 no_pdf_in_print.dpatch
 dont_set_helvetica-3.1.dpatch
 add-acx_blas_f77_func.m4.dpatch
+add-gl-render-cc.dpatch
 :]

Added: octave/trunk/debian/patches/add-gl-render-cc.dpatch
===================================================================
--- octave/trunk/debian/patches/add-gl-render-cc.dpatch	                        (rev 0)
+++ octave/trunk/debian/patches/add-gl-render-cc.dpatch	2008-07-21 18:04:33 UTC (rev 2327)
@@ -0,0 +1,2828 @@
+#! /bin/sh /usr/share/dpatch/dpatch-run
+## -*- diff -*-
+## add-gl-render-cc.dpatch by Rafael Laboissiere <rafael at debian.org>
+## 
+## DP: Add src/gl-render.cc, which is lacking in the 3.1.50 tarball
+
+ at DPATCH@
+
+--- octave3.1-3.1.50.orig/src/gl-render.cc
++++ octave3.1-3.1.50/src/gl-render.cc
+@@ -0,0 +1,2817 @@
++/*
++
++Copyright (C) 2008 Michael Goffioul
++
++This file is part of Octave.
++
++Octave is free software; you can redistribute it and/or modify it
++under the terms of the GNU General Public License as published by the
++Free Software Foundation; either version 3 of the License, or (at your
++option) any later version.
++
++Octave is distributed in the hope that it will be useful, but WITHOUT
++ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
++FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
++for more details.
++
++You should have received a copy of the GNU General Public License
++along with Octave; see the file COPYING.  If not, see
++<http://www.gnu.org/licenses/>.
++
++*/
++
++#ifdef HAVE_CONFIG_H
++#include <config.h>
++#endif
++
++#include <lo-mappers.h>
++#include "gl-render.h"
++
++#define LIGHT_MODE GL_FRONT_AND_BACK
++
++// Win32 API requires the CALLBACK attributes for
++// GLU callback functions. Define it to empty on
++// other platforms.
++#ifndef CALLBACK
++#define CALLBACK
++#endif
++
++enum {
++  AXE_ANY_DIR   = 0,
++  AXE_DEPTH_DIR = 1,
++  AXE_HORZ_DIR  = 2,
++  AXE_VERT_DIR  = 3
++};
++
++static octave_idx_type
++xmin (octave_idx_type x, octave_idx_type y)
++{
++  return x < y ? x : y;
++}
++
++class
++opengl_texture
++{
++protected:
++  class texture_rep
++  {
++  public:
++    texture_rep (void) : valid (false), count (1) { }
++
++    texture_rep (GLuint _id, int _w, int _h, int _tw, int _th)
++	: id (_id), w (_w), h (_h), tw (_tw), th (_th),
++	  tx (double(w)/tw), ty (double(h)/th), valid (true),
++	  count (1) { }
++
++    ~texture_rep (void)
++      {
++	if (valid)
++	  glDeleteTextures (1, &id);
++      }
++
++    void bind (int mode) const
++      { if (valid) glBindTexture (mode, id); }
++
++    void tex_coord (double q, double r) const
++      { if (valid) glTexCoord2d (q*tx, r*ty); }
++
++    GLuint id;
++    int w, h;
++    int tw, th;
++    double tx, ty;
++    bool valid;
++    int count;
++  };
++
++  texture_rep *rep;
++
++private:
++  opengl_texture (texture_rep *_rep) : rep (_rep) { }
++
++public:
++  opengl_texture (void) : rep (new texture_rep ()) { }
++
++  opengl_texture (const opengl_texture& tx)
++      : rep (tx.rep)
++    {
++      rep->count++;
++    }
++
++  ~opengl_texture (void)
++    {
++      if (--rep->count == 0)
++	delete rep;
++    }
++
++  opengl_texture& operator = (const opengl_texture& tx)
++    {
++      if (--rep->count == 0)
++	delete rep;
++
++      rep = tx.rep;
++      rep->count++;
++
++      return *this;
++    }
++
++  static opengl_texture create (const octave_value& data);
++
++  void bind (int mode = GL_TEXTURE_2D) const
++    { rep->bind (mode); }
++
++  void tex_coord (double q, double r) const
++    { rep->tex_coord (q, r); }
++  
++  bool is_valid (void) const
++    { return rep->valid; }
++};
++
++static int
++next_power_of_2 (int n)
++{
++  int m = 1;
++
++  while (m < n && m < INT_MAX)
++    m <<= 1;
++
++  return m;
++}
++
++opengl_texture
++opengl_texture::create (const octave_value& data)
++{
++  opengl_texture retval;
++
++  dim_vector dv (data.dims ());
++
++  // Expect RGB data
++  if (dv.length () == 3 && dv(2) == 3)
++    {
++      int h = dv(0), w = dv(1), tw, th;
++      GLuint id;
++      bool ok = true;
++
++      tw = next_power_of_2 (w);
++      th = next_power_of_2 (w);
++
++      glGenTextures (1, &id);
++      glBindTexture (GL_TEXTURE_2D, id);
++
++      if (data.is_double_type ())
++	{
++	  NDArray _a = data.array_value ();
++
++	  OCTAVE_LOCAL_BUFFER (float, a, (3*tw*th));
++
++	  for (int i = 0; i < h; i++)
++	    for (int j = 0, idx = i*tw*3; j < w; j++, idx += 3)
++	      {
++		a[idx]   = _a(i,j,0);
++		a[idx+1] = _a(i,j,1);
++		a[idx+2] = _a(i,j,2);
++	      }
++
++	  glTexImage2D (GL_TEXTURE_2D, 0, 3, tw, th, 0,
++			GL_RGB, GL_FLOAT, a);
++	}
++      else if (data.is_uint8_type ())
++	{
++	  uint8NDArray _a = data.uint8_array_value ();
++
++	  OCTAVE_LOCAL_BUFFER (octave_uint8, a, (3*tw*th));
++
++	  for (int i = 0; i < h; i++)
++	    for (int j = 0, idx = i*tw*3; j < w; j++, idx += 3)
++	      {
++		a[idx]   = _a(i,j,0);
++		a[idx+1] = _a(i,j,1);
++		a[idx+2] = _a(i,j,2);
++	      }
++
++	  glTexImage2D (GL_TEXTURE_2D, 0, 3, tw, th, 0,
++			GL_RGB, GL_UNSIGNED_BYTE, a);
++	}
++      else
++	{
++	  ok = false;
++	  warning ("opengl_texture::create: invalid texture data type (expected double or uint8)");
++	}
++
++      if (ok)
++	{
++	  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
++	  glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
++
++	  if (glGetError () != GL_NO_ERROR)
++	    warning ("opengl_texture::create: OpenGL error while generating texture data");
++	  else
++	    retval = opengl_texture (new texture_rep (id, w, h, tw, th));
++	}
++    }
++  else
++    warning ("opengl_texture::create: invalid texture data size");
++
++  return retval;
++}
++
++class
++opengl_tesselator
++{
++public:
++  typedef void (CALLBACK *fcn) (void);
++
++public:
++
++  opengl_tesselator (void) : glu_tess (0) { init (); }
++
++  virtual ~opengl_tesselator (void)
++    { if (glu_tess) gluDeleteTess (glu_tess); }
++
++  void begin_polygon (bool filled = true)
++    {
++      gluTessProperty (glu_tess, GLU_TESS_BOUNDARY_ONLY,
++		       (filled ? GL_FALSE : GL_TRUE));
++      fill = filled;
++      gluTessBeginPolygon (glu_tess, this);
++    }
++
++  void end_polygon (void) const
++    { gluTessEndPolygon (glu_tess); }
++
++  void begin_contour (void) const
++    { gluTessBeginContour (glu_tess); }
++
++  void end_contour (void) const
++    { gluTessEndContour (glu_tess); }
++
++  void add_vertex (double *loc, void *data) const
++    { gluTessVertex (glu_tess, loc, data); }
++
++protected:
++  virtual void begin (GLenum /*type*/) { }
++
++  virtual void end (void) { }
++
++  virtual void vertex (void */*data*/) { }
++
++  virtual void combine (GLdouble /*c*/[3], void */*data*/[4],
++			GLfloat /*w*/[4], void **/*out_data*/) { }
++
++  virtual void edge_flag (GLboolean /*flag*/) { }
++
++  virtual void error (GLenum err)
++    { ::error ("OpenGL tesselation error (%d)", err); }
++
++  virtual void init (void)
++    {
++      glu_tess = gluNewTess ();
++
++      gluTessCallback (glu_tess, GLU_TESS_BEGIN_DATA,
++		       reinterpret_cast<fcn> (tess_begin));
++      gluTessCallback (glu_tess, GLU_TESS_END_DATA,
++		       reinterpret_cast<fcn> (tess_end));
++      gluTessCallback (glu_tess, GLU_TESS_VERTEX_DATA,
++		       reinterpret_cast<fcn> (tess_vertex));
++      gluTessCallback (glu_tess, GLU_TESS_COMBINE_DATA,
++		       reinterpret_cast<fcn> (tess_combine));
++      gluTessCallback (glu_tess, GLU_TESS_EDGE_FLAG_DATA,
++		       reinterpret_cast<fcn> (tess_edge_flag));
++      gluTessCallback (glu_tess, GLU_TESS_ERROR_DATA,
++		       reinterpret_cast<fcn> (tess_error));
++    }
++
++  bool is_filled (void) const { return fill; }
++
++private:
++  static void CALLBACK tess_begin (GLenum type, void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->begin (type); }
++  
++  static void CALLBACK tess_end (void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->end (); }
++  
++  static void CALLBACK tess_vertex (void *v, void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->vertex (v); }
++  
++  static void CALLBACK tess_combine (GLdouble c[3], void *v[4], GLfloat w[4],
++				     void **out,  void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->combine (c, v, w, out); }
++  
++  static void CALLBACK tess_edge_flag (GLboolean flag, void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->edge_flag (flag); }
++  
++  static void CALLBACK tess_error (GLenum err, void *t)
++    { reinterpret_cast<opengl_tesselator *> (t)->error (err); }
++
++private:
++  GLUtesselator *glu_tess;
++  bool fill;
++};
++
++class
++vertex_data
++{
++public:
++  class vertex_data_rep
++  {
++  public:
++    Matrix coords;
++    Matrix color;
++    Matrix normal;
++    double alpha;
++    float ambient;
++    float diffuse;
++    float specular;
++    float specular_exp;
++
++    // reference counter
++    int count;
++
++    vertex_data_rep (void) : count (1) { }
++
++    vertex_data_rep (const Matrix& c, const Matrix& col, const Matrix& n,
++		     double a, float as, float ds, float ss, float se)
++	: coords (c), color (col), normal (n), alpha (a),
++	  ambient (as), diffuse (ds), specular (ss), specular_exp (se),
++	  count (1) { }
++  };
++
++private:
++  vertex_data_rep *rep;
++
++  vertex_data_rep *nil_rep (void) const
++    {
++      static vertex_data_rep *nr = new vertex_data_rep ();
++
++      return nr;
++    }
++
++public:
++  vertex_data (void) : rep (nil_rep ())
++    { rep->count++; }
++
++  vertex_data (const vertex_data& v) : rep (v.rep)
++    { rep->count++; }
++
++  vertex_data (const Matrix& c, const Matrix& col, const Matrix& n,
++	       double a, float as, float ds, float ss, float se)
++      : rep (new vertex_data_rep (c, col, n, a, as, ds, ss, se))
++    { }
++
++  vertex_data (vertex_data_rep *new_rep)
++      : rep (new_rep) { }
++
++  ~vertex_data (void)
++    {
++      if (--rep->count == 0)
++	delete rep;
++    }
++
++  vertex_data& operator = (const vertex_data& v)
++    {
++      if (--rep->count == 0)
++	delete rep;
++
++      rep = v.rep;
++      rep->count++;
++
++      return *this;
++    }
++
++  vertex_data_rep *get_rep (void) const { return rep; }
++};
++
++class
++opengl_renderer::patch_tesselator : public opengl_tesselator
++{
++public:
++  patch_tesselator (opengl_renderer *r, int cmode, int lmode, int idx = 0)
++      : opengl_tesselator (), renderer (r),
++        color_mode (cmode), light_mode (lmode), index (idx),
++        first (true) { }
++
++protected:
++  void begin (GLenum type)
++    {
++      //printf("patch_tesselator::begin (%d)\n", type);
++      first = true;
++
++      if (color_mode == 2 || light_mode == 2)
++	glShadeModel (GL_SMOOTH);
++      else
++	glShadeModel (GL_FLAT);
++
++      if (is_filled ())
++	renderer->set_polygon_offset (true, 1+index);
++
++      glBegin (type);
++    }
++
++  void end (void)
++    {
++      //printf("patch_tesselator::end\n");
++      glEnd ();
++      renderer->set_polygon_offset (false);
++    }
++
++  void vertex (void *data)
++    {
++      vertex_data::vertex_data_rep *v
++	  = reinterpret_cast<vertex_data::vertex_data_rep *> (data);
++      //printf("patch_tesselator::vertex (%g, %g, %g)\n", v->coords(0), v->coords(1), v->coords(2));
++
++      // FIXME: why did I need to keep the first vertex of the face
++      // in JHandles? I think it's related to the fact that the 
++      // tessellation process might re-order the vertices, such that
++      // the first one you get here might not be the first one of the face;
++      // but I can't figure out the actual reason.
++      if (color_mode > 0 && (first || color_mode == 2))
++	{
++	  Matrix col = v->color;
++
++	  if (col.numel () == 3)
++	    {
++	      glColor3dv (col.data ());
++	      if (light_mode > 0)
++		{
++		  float buf[4] = { 0, 0, 0, 1 };
++
++		  for (int k = 0; k < 3; k++)
++		    buf[k] = (v->ambient * col(k));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, buf);
++
++		  for (int k = 0; k < 3; k++)
++		    buf[k] = (v->diffuse * col(k));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, buf);
++		}
++	    }
++	}
++
++      if (light_mode > 0 && (first || light_mode == 2))
++	glNormal3dv (v->normal.data ());
++
++      glVertex3dv (v->coords.data ());
++
++      first = false;
++    }
++
++  void combine (GLdouble xyz[3], void *data[4], GLfloat w[4],
++		void **out_data)
++    {
++      //printf("patch_tesselator::combine\n");
++
++      vertex_data::vertex_data_rep *v[4];
++      int vmax = 4;
++
++      for (int i = 0; i < 4; i++)
++	{
++	  v[i] = reinterpret_cast<vertex_data::vertex_data_rep *> (data[i]);
++
++	  if (vmax == 4 && ! v[i])
++	    vmax = i;
++	}
++
++      Matrix vv (1, 3, 0.0);
++      Matrix cc;
++      Matrix nn (1, 3, 0.0);
++      double aa = 0.0;
++
++      vv(0) = xyz[0];
++      vv(1) = xyz[1];
++      vv(2) = xyz[2];
++
++      if (v[0]->color.numel ())
++	{
++	  cc.resize (1, 3, 0.0);
++	  for (int ic = 0; ic < 3; ic++)
++	    for (int iv = 0; iv < vmax; iv++)
++	      cc(ic) += (w[iv] * v[iv]->color(ic));
++	}
++
++      if (v[0]->normal.numel () > 0)
++	{
++	  for (int in = 0; in < 3; in++)
++	    for (int iv = 0; iv < vmax; iv++)
++	      nn(in) += (w[iv] * v[iv]->normal(in));
++	}
++
++      for (int iv = 0; iv < vmax; iv++)
++	aa += (w[iv] * v[iv]->alpha);
++
++      vertex_data new_v (vv, cc, nn, aa, v[0]->ambient, v[0]->diffuse,
++			 v[0]->specular, v[0]->specular_exp);
++      tmp_vdata.push_back (new_v);
++
++      *out_data = new_v.get_rep ();
++    }
++
++private:
++  opengl_renderer *renderer;
++  int color_mode;	// 0: uni,  1: flat, 2: interp
++  int light_mode;	// 0: none, 1: flat, 2: gouraud
++  int index;
++  bool first;
++  std::list<vertex_data> tmp_vdata;
++};
++
++void
++opengl_renderer::draw (const graphics_object& go)
++{
++  if (! go.valid_object ())
++    return;
++
++  const base_properties& props = go.get_properties ();
++
++  if (go.isa ("figure"))
++    draw (dynamic_cast<const figure::properties&> (props));
++  else if (go.isa ("axes"))
++    draw (dynamic_cast<const axes::properties&> (props));
++  else if (go.isa ("line"))
++    draw (dynamic_cast<const line::properties&> (props));
++  else if (go.isa ("surface"))
++    draw (dynamic_cast<const surface::properties&> (props));
++  else if (go.isa ("patch"))
++    draw (dynamic_cast<const patch::properties&> (props));
++  else if (go.isa ("hggroup"))
++    draw (dynamic_cast<const hggroup::properties&> (props));
++  else
++    warning ("opengl_renderer: cannot render object of type `%s'",
++	     props.graphics_object_name ().c_str ());
++}
++
++void
++opengl_renderer::draw (const figure::properties& props)
++{
++  backend = props.get_backend ();
++
++  // Initialize OpenGL context
++
++  glEnable (GL_DEPTH_TEST);
++  glDepthFunc (GL_LEQUAL);
++  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
++  glEnable (GL_NORMALIZE);
++
++  if (props.is___enhanced__ ())
++    {
++      glEnable (GL_BLEND);
++      glEnable (GL_LINE_SMOOTH);
++    }
++  else
++    {
++      glDisable (GL_BLEND);
++      glDisable (GL_LINE_SMOOTH);
++    }
++
++  // Clear background
++
++  Matrix c = props.get_color_rgb ();
++
++  if (c.length() >= 3)
++    {
++      glClearColor (c(0), c(1), c(2), 1);
++      glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
++    }
++
++  // Draw children
++
++  draw (props.get_children ());
++}
++
++void
++opengl_renderer::draw (const axes::properties& props)
++{
++  // setup OpenGL transformation
++
++  Matrix x_zlim = props.get_transform_zlim ();
++  Matrix x_mat1 = props.get_opengl_matrix_1 ();
++  Matrix x_mat2 = props.get_opengl_matrix_2 ();
++  
++  xZ1 = x_zlim(0)-(x_zlim(1)-x_zlim(0))/2;
++  xZ2 = x_zlim(1)+(x_zlim(1)-x_zlim(0))/2;
++
++  int vw[4];
++  glGetIntegerv (GL_VIEWPORT, vw);
++
++  glMatrixMode (GL_MODELVIEW);
++  glLoadIdentity ();
++  glScaled(1, 1, -1);
++  glMultMatrixd (x_mat1.data ());
++  glMatrixMode (GL_PROJECTION);
++  glLoadIdentity ();
++  glOrtho (0, vw[2], vw[3], 0, xZ1, xZ2);
++  glMultMatrixd (x_mat2.data ());
++  glMatrixMode (GL_MODELVIEW);
++
++  glClear (GL_DEPTH_BUFFER_BIT);
++
++  // store axes transformation data
++
++  xform = props.get_transform ();
++  
++  // draw axes object
++
++  GLboolean antialias;
++  glGetBooleanv (GL_LINE_SMOOTH, &antialias);
++  glDisable (GL_LINE_SMOOTH);
++  
++  Matrix xlim = xform.xscale (props.get_xlim ().matrix_value ());
++  Matrix ylim = xform.yscale (props.get_ylim ().matrix_value ());
++  Matrix zlim = xform.zscale (props.get_zlim ().matrix_value ());
++  double x_min = xlim(0), x_max = xlim(1);
++  double y_min = ylim(0), y_max = ylim(1);
++  double z_min = zlim(0), z_max = zlim(1);
++  
++  double xd = (props.xdir_is ("normal") ? 1 : -1);
++  double yd = (props.ydir_is ("normal") ? 1 : -1);
++  double zd = (props.zdir_is ("normal") ? 1 : -1);
++
++  ColumnVector p1, p2, xv (3), yv (3), zv (3);
++  int xstate, ystate, zstate;
++
++  xstate = ystate = zstate = AXE_ANY_DIR;
++
++  p1 = xform.transform (x_min, (y_min+y_max)/2, (z_min+z_max)/2, false);
++  p2 = xform.transform (x_max, (y_min+y_max)/2, (z_min+z_max)/2, false);
++  xv(0) = xround (p2(0)-p1(0));
++  xv(1) = xround (p2(1)-p1(1));
++  xv(2) = (p2(2)-p1(2));
++  if (xv(0) == 0 && xv(1) == 0)
++    xstate = AXE_DEPTH_DIR;
++  else if (xv(2) == 0)
++    {
++      if (xv(0) == 0)
++        xstate = AXE_VERT_DIR;
++      else if (xv(1) == 0)
++        xstate = AXE_HORZ_DIR;
++    }
++  double xPlane;
++  if (xv(2) == 0)
++    if (xv(1) == 0)
++      xPlane = (xv(0) > 0 ? x_max : x_min);
++    else
++      xPlane = (xv(1) < 0 ? x_max : x_min);
++  else
++    xPlane = (xv(2) < 0 ? x_min : x_max);
++  double xPlaneN = (xPlane == x_min ? x_max : x_min);
++  double fx = (x_max-x_min)/sqrt(xv(0)*xv(0)+xv(1)*xv(1));
++
++  p1 = xform.transform ((x_min+x_max)/2, y_min, (z_min+z_max)/2, false);
++  p2 = xform.transform ((x_min+x_max)/2, y_max, (z_min+z_max)/2, false);
++  yv(0) = xround (p2(0)-p1(0));
++  yv(1) = xround (p2(1)-p1(1));
++  yv(2) = (p2(2)-p1(2));
++  if (yv(0) == 0 && yv(1) == 0)
++    ystate = AXE_DEPTH_DIR;
++  else if (yv(2) == 0)
++    {
++      if (yv(0) == 0)
++        ystate = AXE_VERT_DIR;
++      else if (yv(1) == 0)
++        ystate = AXE_HORZ_DIR;
++    }
++  double yPlane;
++  if (yv(2) == 0)
++    if (yv(1) == 0)
++      yPlane = (yv(0) > 0 ? y_max : y_min);
++    else
++      yPlane = (yv(1) < 0 ? y_max : y_min);
++  else
++    yPlane = (yv(2) < 0 ? y_min : y_max);
++  double yPlaneN = (yPlane == y_min ? y_max : y_min);
++  double fy = (y_max-y_min)/sqrt(yv(0)*yv(0)+yv(1)*yv(1));
++
++  p1 = xform.transform((x_min+x_max)/2, (y_min+y_max)/2, z_min, false);
++  p2 = xform.transform((x_min+x_max)/2, (y_min+y_max)/2, z_max, false);
++  zv(0) = xround(p2(0)-p1(0));
++  zv(1) = xround (p2(1)-p1(1));
++  zv(2) = (p2(2)-p1(2));
++  if (zv(0) == 0 && zv(1) == 0)
++    zstate = AXE_DEPTH_DIR;
++  else if (zv(2) == 0)
++  {
++    if (zv(0) == 0)
++      zstate = AXE_VERT_DIR;
++    else if (zv(1) == 0)
++      zstate = AXE_HORZ_DIR;
++  }
++  double zPlane;
++  if (zv(2) == 0)
++    if (zv(1) == 0)
++      zPlane = (zv(0) > 0 ? z_min : z_max);
++    else
++      zPlane = (zv(1) < 0 ? z_min : z_max);
++  else
++    zPlane = (zv(2) < 0 ? z_min : z_max);
++  double zPlaneN = (zPlane == z_min ? z_max : z_min);
++  double fz = (z_max-z_min)/sqrt(zv(0)*zv(0)+zv(1)*zv(1));
++
++  bool mode2d = (((xstate > AXE_DEPTH_DIR ? 1 : 0) +
++        (ystate > AXE_DEPTH_DIR ? 1 : 0) +
++        (zstate > AXE_DEPTH_DIR ? 1 : 0)) == 2);
++  if (props.tickdirmode_is ("auto"))
++  {
++    // FIXME: tickdir should be updated (code below comes
++    //        from JHandles)
++    //autoMode++;
++    //TickDir.set(mode2d ? "in" : "out", true);
++    //autoMode--;
++  }
++
++  // FIXME: use ticklength property
++  double xticklen = 7, yticklen = 7, zticklen = 7;
++
++  //double tickdir = (props.tickdir_is ("in") ? -1 : 1);
++  double tickdir = (props.tickdirmode_is ("auto") ?
++		    (mode2d ? -1 : 1) :
++		    (props.tickdir_is ("in") ? -1 : 1));
++  double xtickoffset = (mode2d && tickdir < 0 ? 0 : xticklen) + 5;
++  double ytickoffset = (mode2d && tickdir < 0 ? 0 : yticklen) + 5;
++  double ztickoffset = (mode2d && tickdir < 0 ? 0 : zticklen) + 5;
++
++  bool xySym = (xd*yd*(xPlane-xPlaneN)*(yPlane-yPlaneN) > 0);
++  bool x2Dtop = false;
++  bool y2Dright = false;
++  double zpTick = zPlane;
++
++  /* 2D mode */
++  if (xstate == AXE_HORZ_DIR && ystate == AXE_VERT_DIR)
++  {
++    if (props.xaxislocation_is ("top"))
++    {
++      double tmp = yPlane;
++      yPlane = yPlaneN;
++      yPlaneN = tmp;
++      x2Dtop = true;
++    }
++    if (props.yaxislocation_is ("right"))
++    {
++      double tmp = xPlane;
++      xPlane = xPlaneN;
++      xPlaneN = tmp;
++      y2Dright = true;
++    }
++    if (props.layer_is ("top"))
++      zpTick = zPlaneN;
++  }
++
++  Matrix axe_color = props.get_color_rgb ();
++  bool visible = props.is_visible ();
++  bool box = props.is_box ();
++
++  // Axes planes
++
++  if (axe_color.numel () > 0 && visible)
++    {
++      set_color (axe_color);
++      set_polygon_offset (true, 2.5);
++
++      glBegin (GL_QUADS);
++
++      // X plane
++      glVertex3d (xPlane, y_min, z_min);
++      glVertex3d (xPlane, y_max, z_min);
++      glVertex3d (xPlane, y_max, z_max);
++      glVertex3d (xPlane, y_min, z_max);
++
++      // Y plane
++      glVertex3d (x_min, yPlane, z_min);
++      glVertex3d (x_max, yPlane, z_min);
++      glVertex3d (x_max, yPlane, z_max);
++      glVertex3d (x_min, yPlane, z_max);
++
++      // Z plane
++      glVertex3d (x_min, y_min, zPlane);
++      glVertex3d (x_max, y_min, zPlane);
++      glVertex3d (x_max, y_max, zPlane);
++      glVertex3d (x_min, y_max, zPlane);
++
++      glEnd ();
++
++      set_polygon_offset (false);
++    }
++
++  // Axes box
++
++  set_linestyle ("-", true);
++  set_linewidth (props.get_linewidth ());
++
++  if (visible)
++    {
++      glBegin (GL_LINES);
++
++      // X box
++      set_color (props.get_xcolor_rgb ());
++      glVertex3d (xPlaneN, yPlaneN, zPlane);
++      glVertex3d (xPlane, yPlaneN, zPlane);
++      if (box)
++        {
++          glVertex3d (xPlaneN, yPlane, zPlane);
++          glVertex3d (xPlane, yPlane, zPlane);
++          glVertex3d (xPlaneN, yPlane, zPlaneN);
++          glVertex3d (xPlane, yPlane, zPlaneN);
++          glVertex3d (xPlaneN, yPlaneN, zPlaneN);
++          glVertex3d (xPlane, yPlaneN, zPlaneN);
++        }
++
++      // Y box
++      set_color (props.get_ycolor_rgb ());
++      glVertex3d (xPlaneN, yPlaneN, zPlane);
++      glVertex3d (xPlaneN, yPlane, zPlane);
++      if (box)
++        {
++          glVertex3d (xPlane, yPlaneN, zPlane);
++          glVertex3d (xPlane, yPlane, zPlane);
++          glVertex3d (xPlane, yPlaneN, zPlaneN);
++          glVertex3d (xPlane, yPlane, zPlaneN);
++          glVertex3d (xPlaneN, yPlaneN, zPlaneN);
++          glVertex3d (xPlaneN, yPlane, zPlaneN);
++        }
++
++      // Z box
++      set_color (props.get_zcolor_rgb ());
++      if (xySym)
++        {
++          glVertex3d (xPlaneN, yPlane, zPlaneN);
++          glVertex3d (xPlaneN, yPlane, zPlane);
++        }
++      else
++        {
++          glVertex3d (xPlane, yPlaneN, zPlaneN);
++          glVertex3d (xPlane, yPlaneN, zPlane);
++        }
++      if (box)
++        {
++          glVertex3d (xPlane, yPlane, zPlaneN);
++          glVertex3d (xPlane, yPlane, zPlane);
++          if (xySym)
++            {
++              glVertex3d (xPlane, yPlaneN, zPlaneN);
++              glVertex3d (xPlane, yPlaneN, zPlane);
++            }
++          else
++            {
++              glVertex3d (xPlaneN, yPlane, zPlaneN);
++              glVertex3d (xPlaneN, yPlane, zPlane);
++            }
++          glVertex3d (xPlaneN, yPlaneN, zPlaneN);
++          glVertex3d (xPlaneN, yPlaneN, zPlane);
++        }
++
++      glEnd ();
++    }
++
++  std::string gridstyle = props.get_gridlinestyle ();
++  std::string minorgridstyle = props.get_minorgridlinestyle ();
++
++  // X grid
++
++  if (visible && xstate != AXE_DEPTH_DIR)
++    {
++      bool do_xgrid = (props.is_xgrid () && (gridstyle != "none"));
++      bool do_xminorgrid = (props.is_xminorgrid () && (minorgridstyle != "none"));
++      bool do_xminortick = props.is_xminortick ();
++      Matrix xticks = xform.xscale (props.get_xtick ().matrix_value ());
++      // FIXME: use pre-computed minor ticks
++      Matrix xmticks;
++      // FIXME: use xticklabels property
++      string_vector xticklabels;
++      int wmax = 0, hmax = 0;
++      bool tick_along_z = xisinf (fy);
++      Matrix tickpos (xticks.numel (), 3);
++
++      set_color (props.get_xcolor_rgb ());
++
++      // grid lines
++      if (do_xgrid)
++        {
++          set_linestyle (gridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < xticks.numel (); i++)
++            {
++              double xval = xticks(i);
++
++              glVertex3d (xval, yPlaneN, zpTick);
++              glVertex3d (xval, yPlane, zpTick);
++              if (zstate != AXE_DEPTH_DIR)
++                {
++                  glVertex3d (xval, yPlane, zPlaneN);
++                  glVertex3d (xval, yPlane, zPlane);
++                }
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++
++      // tick marks
++      if (tick_along_z)
++        {
++          glBegin (GL_LINES);
++          for (int i = 0; i < xticks.numel (); i++)
++            {
++              double xval = xticks(i);
++
++              glVertex3d (xval, yPlaneN, zPlane);
++              glVertex3d (xval, yPlaneN, zPlane+signum(zPlane-zPlaneN)*fz*xticklen*tickdir);
++              if (box && xstate != AXE_ANY_DIR)
++                {
++                  glVertex3d (xval, yPlaneN, zPlaneN);
++                  glVertex3d (xval, yPlaneN,
++                        zPlaneN+signum(zPlaneN-zPlane)*fz*xticklen*tickdir);
++                }
++              tickpos(i,0) = xval;
++              tickpos(i,1) = yPlaneN;
++              tickpos(i,2) = zPlane+signum(zPlane-zPlaneN)*fz*xtickoffset;
++            }
++          glEnd ();
++        }
++      else
++        {
++          glBegin (GL_LINES);
++          for (int i = 0; i < xticks.numel (); i++)
++            {
++              double xval = xticks(i);
++
++              glVertex3d (xval, yPlaneN, zpTick);
++              glVertex3d (xval, yPlaneN+signum(yPlaneN-yPlane)*fy*xticklen*tickdir, zpTick);
++              if (box && xstate != AXE_ANY_DIR)
++                {
++                  glVertex3d (xval, yPlane, zpTick);
++                  glVertex3d (xval,
++                        yPlane+signum(yPlane-yPlaneN)*fy*xticklen*tickdir, zpTick);
++                }
++              tickpos(i,0) = xval;
++              tickpos(i,1) = yPlaneN+signum(yPlaneN-yPlane)*fy*xtickoffset;
++              tickpos(i,2) = zPlane;
++            }
++          glEnd ();
++        }
++
++      // FIXME: tick texts
++
++      // minor grid lines
++      if (do_xminorgrid)
++        {
++          set_linestyle (minorgridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < xmticks.numel (); i++)
++            {
++              double xval = xmticks(i);
++
++              glVertex3d (xval, yPlaneN, zpTick);
++              glVertex3d (xval, yPlane, zpTick);
++              if (zstate != AXE_DEPTH_DIR)
++                {
++                  glVertex3d (xval, yPlane, zPlaneN);
++                  glVertex3d (xval, yPlane, zPlane);
++                }
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++			
++      // minor tick marks
++      if (do_xminortick)
++        {
++          if (tick_along_z)
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < xmticks.numel (); i++)
++                {
++                  double xval = xmticks(i);
++
++                  glVertex3d (xval, yPlaneN, zPlane);
++                  glVertex3d (xval, yPlaneN,
++                      zPlane+signum(zPlane-zPlaneN)*fz*xticklen/2*tickdir);
++                  if (box && xstate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xval, yPlaneN, zPlaneN);
++                      glVertex3d (xval, yPlaneN,
++                          zPlaneN+signum(zPlaneN-zPlane)*fz*xticklen/2*tickdir);
++                    }
++                }
++              glEnd ();
++            }
++          else
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < xmticks.numel (); i++)
++                {
++                  double xval = xmticks(i);
++
++                  glVertex3d (xval, yPlaneN, zpTick);
++                  glVertex3d (xval,
++                        yPlaneN+signum(yPlaneN-yPlane)*fy*xticklen/2*tickdir, zpTick);
++                  if (box && xstate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xval, yPlane, zpTick);
++                      glVertex3d (xval,
++                            yPlane+signum(yPlane-yPlaneN)*fy*xticklen/2*tickdir, zpTick);
++                    }
++                }
++              glEnd ();
++            }
++        }
++
++      text::properties& xlabel_props =
++        reinterpret_cast<text::properties&> (gh_manager::get_object (props.get_xlabel ()).get_properties ());
++
++      // FIXME: auto-positioning should be disabled if the 
++      //        label has been positioned manually
++      if (! xlabel_props.get_string ().empty ())
++        {
++          xlabel_props.set_horizontalalignment (xstate > AXE_DEPTH_DIR ? "center" : (xySym ? "left" : "right"));
++	  xlabel_props.set_verticalalignment (xstate == AXE_VERT_DIR ? "bottom" : (zd*zv(2) <= 0 ? "top" : "bottom"));
++
++          double angle = 0;
++          ColumnVector p = graphics_xform::xform_vector ((x_min+x_max)/2, yPlaneN, zPlane);
++
++          if (tick_along_z)
++            p(2) += (signum(zPlane-zPlaneN)*fz*xtickoffset);
++          else
++            p(1) += (signum(yPlaneN-yPlane)*fy*xtickoffset);
++          p = xform.transform (p(0), p(1), p(2), false);
++          switch (xstate)
++            {
++              case AXE_ANY_DIR:
++                p(0) += (xySym ? wmax : -wmax);
++                p(1) += (zd*zv(2) <= 0 ? hmax : -hmax);
++                break;
++              case AXE_VERT_DIR:
++                p(0) -= wmax;
++                angle = 90;
++                break;
++              case AXE_HORZ_DIR:
++                p(1) += hmax;
++                break;
++            }
++          p = xform.untransform (p(0), p(1), p(2), true);
++          xlabel_props.set_position (p.extract_n (0, 3).transpose ());
++          xlabel_props.set_rotation (angle);
++        }
++    }
++
++  // Y grid
++		
++  if (ystate != AXE_DEPTH_DIR && visible)
++    {
++      bool do_ygrid = (props.is_ygrid () && (gridstyle != "none"));
++      bool do_yminorgrid = (props.is_yminorgrid () && (minorgridstyle != "none"));
++      bool do_yminortick = props.is_yminortick ();
++      Matrix yticks = xform.yscale (props.get_ytick ().matrix_value ());
++      // FIXME: use pre-computed minor ticks
++      Matrix ymticks;
++      // FIXME: use yticklabels property
++      string_vector yticklabels;
++      int wmax = 0, hmax = 0;
++      bool tick_along_z = xisinf (fx);
++      Matrix tickpos (yticks.numel (), 3);
++
++      set_color (props.get_ycolor_rgb ());
++
++      // grid lines
++      if (do_ygrid)
++        {
++          set_linestyle (gridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < yticks.numel (); i++)
++            {
++              double yval = yticks(i);
++
++              glVertex3d (xPlaneN, yval, zpTick);
++              glVertex3d (xPlane, yval, zpTick);
++              if (zstate != AXE_DEPTH_DIR)
++                {
++                  glVertex3d (xPlane, yval, zPlaneN);
++                  glVertex3d (xPlane, yval, zPlane);
++                }
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++
++      // tick marks
++      if (tick_along_z)
++        {
++          glBegin (GL_LINES);
++          for (int i = 0; i < yticks.numel (); i++)
++            {
++              double yval = yticks(i);
++
++              glVertex3d (xPlaneN, yval, zPlane);
++              glVertex3d (xPlaneN, yval, zPlane+signum(zPlane-zPlaneN)*fz*yticklen*tickdir);
++              if (box && ystate != AXE_ANY_DIR)
++                {
++                  glVertex3d (xPlaneN, yval, zPlaneN);
++                  glVertex3d (xPlaneN, yval,
++                        zPlaneN+signum(zPlaneN-zPlane)*fz*yticklen*tickdir);
++                }
++              tickpos(i,0) = xPlaneN;
++              tickpos(i,1) = yval;
++              tickpos(i,2) = zPlane+signum(zPlane-zPlaneN)*fz*ytickoffset;
++            }
++          glEnd ();
++        }
++      else
++        {
++          glBegin (GL_LINES);
++          for (int i = 0; i < yticks.numel (); i++)
++            {
++              double yval = yticks(i);
++
++              glVertex3d (xPlaneN, yval, zpTick);
++              glVertex3d (xPlaneN+signum(xPlaneN-xPlane)*fx*yticklen*tickdir, yval, zpTick);
++              if (box && ystate != AXE_ANY_DIR)
++                {
++                  glVertex3d (xPlane, yval, zpTick);
++                  glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*yticklen*tickdir,
++                        yval, zpTick);
++                }
++              tickpos(i,0) = xPlaneN+signum(xPlaneN-xPlane)*fx*ytickoffset;
++              tickpos(i,1) = yval;
++              tickpos(i,2) = zPlane;
++            }
++          glEnd ();
++        }
++
++      // FIXME: tick texts
++
++      // minor grid lines
++      if (do_yminorgrid)
++        {
++          set_linestyle (minorgridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < ymticks.numel (); i++)
++            {
++              double yval = ymticks(i);
++
++              glVertex3d (xPlaneN, yval, zpTick);
++              glVertex3d (xPlane, yval, zpTick);
++              if (zstate != AXE_DEPTH_DIR)
++                {
++                  glVertex3d (xPlane, yval, zPlaneN);
++                  glVertex3d (xPlane, yval, zPlane);
++                }
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++
++      // minor tick marks
++      if (do_yminortick)
++        {
++          if (tick_along_z)
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < ymticks.numel (); i++)
++                {
++                  double yval = ymticks(i);
++
++                  glVertex3d (xPlaneN, yval, zPlane);
++                  glVertex3d (xPlaneN, yval,
++                        zPlane+signum(zPlane-zPlaneN)*fz*yticklen/2*tickdir);
++                  if (box && ystate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xPlaneN, yval, zPlaneN);
++                      glVertex3d (xPlaneN, yval,
++                            zPlaneN+signum(zPlaneN-zPlane)*fz*yticklen/2*tickdir);
++                    }
++                }
++              glEnd ();
++            }
++          else
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < ymticks.numel (); i++)
++                {
++                  double yval = ymticks(i);
++
++                  glVertex3d (xPlaneN, yval, zpTick);
++                  glVertex3d (xPlaneN+signum(xPlaneN-xPlane)*fx*yticklen/2*tickdir,
++                        yval, zpTick);
++                  if (box && ystate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xPlane, yval, zpTick);
++                      glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*yticklen/2*tickdir,
++                            yval, zpTick);
++                    }
++                }
++              glEnd ();
++            }
++        }
++
++      text::properties& ylabel_props =
++        reinterpret_cast<text::properties&> (gh_manager::get_object (props.get_ylabel ()).get_properties ());
++
++      // FIXME: auto-positioning should be disabled if the 
++      //        label has been positioned manually
++      if (! ylabel_props.get_string ().empty ())
++        {
++          ylabel_props.set_horizontalalignment (ystate > AXE_DEPTH_DIR ? "center" : (!xySym ? "left" : "right"));
++	  ylabel_props.set_verticalalignment (ystate == AXE_VERT_DIR ? "bottom" : (zd*zv(2) <= 0 ? "top" : "bottom"));
++
++          double angle = 0;
++          ColumnVector p = graphics_xform::xform_vector (xPlaneN, (y_min+y_max)/2, zPlane);
++
++          if (tick_along_z)
++            p(2) += (signum(zPlane-zPlaneN)*fz*ytickoffset);
++          else
++            p(0) += (signum(xPlaneN-xPlane)*fx*ytickoffset);
++          p = xform.transform (p(0), p(1), p(2), false);
++          switch (ystate)
++            {
++              case AXE_ANY_DIR:
++                p(0) += (!xySym ? wmax : -wmax);
++                p(1) += (zd*zv(2) <= 0 ? hmax : -hmax);
++                break;
++              case AXE_VERT_DIR:
++                p(0) -= wmax;
++                angle = 90;
++                break;
++              case AXE_HORZ_DIR:
++                p(1) += hmax;
++                break;
++            }
++          p = xform.untransform(p(0), p(1), p(2), true);
++          ylabel_props.set_position (p.extract_n (0, 3).transpose ());
++          ylabel_props.set_rotation (angle);
++        }
++    }
++		
++  // Z Grid
++
++  if (zstate != AXE_DEPTH_DIR && visible)
++    {
++      bool do_zgrid = (props.is_zgrid () && (gridstyle != "none"));
++      bool do_zminorgrid = (props.is_zminorgrid () && (minorgridstyle != "none"));
++      bool do_zminortick = props.is_zminortick ();
++      Matrix zticks = xform.zscale (props.get_ztick ().matrix_value ());
++      // FIXME: use pre-computed minor ticks
++      Matrix zmticks;
++      // FIXME: use zticklabels property
++      string_vector zticklabels;
++      int wmax = 0, hmax = 0;
++      Matrix tickpos (zticks.numel (), 3);
++
++      set_color (props.get_zcolor_rgb ());
++
++      // grid lines
++      if (do_zgrid)
++        {
++          set_linestyle (gridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < zticks.numel (); i++)
++            {
++              double zval = zticks(i);
++
++              glVertex3d (xPlaneN, yPlane, zval);
++              glVertex3d (xPlane, yPlane, zval);
++              glVertex3d (xPlane, yPlaneN, zval);
++              glVertex3d (xPlane, yPlane, zval);
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++
++      // tick marks
++      if (xySym)
++        {
++          if (xisinf (fy))
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < zticks.numel (); i++)
++                {
++                  double zval = zticks(i);
++
++                  glVertex3d (xPlaneN, yPlane, zval);
++                  glVertex3d (xPlaneN+signum(xPlaneN-xPlane)*fx*zticklen*tickdir,
++                        yPlane, zval);
++                  if (box && zstate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xPlane, yPlane, zval);
++                      glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*zticklen*tickdir,
++                            yPlane, zval);
++                    }
++                  tickpos(i,0) = xPlaneN+signum(xPlaneN-xPlane)*fx*ztickoffset;
++                  tickpos(i,1) = yPlane;
++                  tickpos(i,2) = zval;
++                }
++              glEnd ();
++            }
++          else
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < zticks.numel (); i++)
++                {
++                  double zval = zticks(i);
++
++                  glVertex3d (xPlaneN, yPlane, zval);
++                  glVertex3d (xPlaneN, yPlane+signum(yPlane-yPlaneN)*fy*zticklen*tickdir, zval);
++                  tickpos(i,0) = xPlaneN;
++                  tickpos(i,1) = yPlane+signum(yPlane-yPlaneN)*fy*ztickoffset;
++                  tickpos(i,2) = zval;
++                }
++              glEnd ();
++            }
++        }
++      else
++        {
++          if (xisinf (fx))
++            {
++              glBegin (GL_LINES);
++              for (int i = 0; i < zticks.numel (); i++)
++                {
++                  double zval = zticks(i);
++
++                  glVertex3d (xPlane, yPlaneN, zval);
++                  glVertex3d (xPlane, yPlaneN+signum(yPlaneN-yPlane)*fy*zticklen*tickdir, zval);
++                  if (box && zstate != AXE_ANY_DIR)
++                    {
++                      glVertex3d (xPlane, yPlane, zval);
++                      glVertex3d (xPlane, yPlane+signum(yPlane-yPlaneN)*fy*zticklen*tickdir, zval);
++                    }
++                  tickpos(i,0) = xPlane;
++                  tickpos(i,1) = yPlaneN+signum(yPlaneN-yPlane)*fy*ztickoffset;
++                  tickpos(i,2) = zval;
++                }
++              glEnd ();
++            }
++          else
++          {
++            glBegin (GL_LINES);
++            for (int i = 0; i < zticks.numel (); i++)
++              {
++                double zval = zticks(i);
++
++                glVertex3d (xPlane, yPlaneN, zval);
++                glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*zticklen*tickdir, yPlaneN, zval);
++                tickpos(i,0) = xPlane+signum(xPlane-xPlaneN)*fx*ztickoffset;
++                tickpos(i,1) = yPlaneN;
++                tickpos(i,2) = zval;
++              }
++            glEnd ();
++          }
++        }
++
++      // FIXME: tick texts
++
++      // minor grid lines
++      if (do_zminorgrid)
++        {
++          set_linestyle (minorgridstyle, true);
++          glBegin (GL_LINES);
++          for (int i = 0; i < zmticks.numel (); i++)
++            {
++              double zval = zmticks(i);
++
++              glVertex3d (xPlaneN, yPlane, zval);
++              glVertex3d (xPlane, yPlane, zval);
++              glVertex3d (xPlane, yPlaneN, zval);
++              glVertex3d (xPlane, yPlane, zval);
++            }
++          glEnd ();
++          set_linestyle ("-", true);
++        }
++
++      // minor tick marks
++      if (do_zminortick)
++        {
++          if (xySym)
++            {
++              if (xisinf (fy))
++                {
++                  glBegin (GL_LINES);
++                  for (int i = 0; i < zmticks.numel (); i++)
++                    {
++                      double zval = zmticks(i);
++
++                      glVertex3d (xPlaneN, yPlane, zval);
++                      glVertex3d (xPlaneN+signum(xPlaneN-xPlane)*fx*zticklen/2*tickdir,
++                            yPlane, zval);
++                      if (box && zstate != AXE_ANY_DIR)
++                        {
++                          glVertex3d (xPlane, yPlane, zval);
++                          glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*zticklen/2*tickdir,
++                                yPlane, zval);
++                        }
++                    }
++                  glEnd ();
++                }
++              else
++                {
++                  glBegin (GL_LINES);
++                  for (int i = 0; i < zmticks.numel (); i++)
++                    {
++                      double zval = zmticks(i);
++
++                      glVertex3d (xPlaneN, yPlane, zval);
++                      glVertex3d (xPlaneN, yPlane+signum(yPlane-yPlaneN)*fy*zticklen/2*tickdir, zval);
++                    }
++                  glEnd ();
++                }
++            }
++          else
++            {
++              if (xisinf (fx))
++                {
++                  glBegin (GL_LINES);
++                  for (int i = 0; i < zmticks.numel (); i++)
++                    {
++                      double zval = zmticks(i);
++
++                      glVertex3d (xPlane, yPlaneN, zval);
++                      glVertex3d (xPlane, yPlaneN+signum(yPlaneN-yPlane)*fy*zticklen/2*tickdir, zval);
++                      if (box && zstate != AXE_ANY_DIR)
++                        {
++                          glVertex3d (xPlane, yPlane, zval);
++                          glVertex3d (xPlane, yPlane+signum(yPlane-yPlaneN)*fy*zticklen/2*tickdir, zval);
++                        }
++                    }
++                  glEnd ();
++                }
++              else
++                {
++                  glBegin (GL_LINES);
++                  for (int i = 0; i < zmticks.numel (); i++)
++                    {
++                      double zval = zmticks(i);
++
++                      glVertex3d (xPlane, yPlaneN, zval);
++                      glVertex3d (xPlane+signum(xPlane-xPlaneN)*fx*zticklen/2*tickdir, yPlaneN, zval);
++                    }
++                  glEnd ();
++                }
++            }
++        }
++
++      text::properties& zlabel_props =
++        reinterpret_cast<text::properties&> (gh_manager::get_object (props.get_zlabel ()).get_properties ());
++
++      // FIXME: auto-positioning should be disabled if the 
++      //        label has been positioned manually
++      if (! zlabel_props.get_string ().empty ())
++        {
++          bool camAuto = props.cameraupvectormode_is ("auto");
++
++          zlabel_props.set_horizontalalignment ((zstate > AXE_DEPTH_DIR || camAuto) ? "center" : "right");
++	  zlabel_props.set_verticalalignment(zstate == AXE_VERT_DIR ? "bottom" : ((zd*zv(2) < 0 || camAuto) ? "bottom" : "top"));
++
++          double angle = 0;
++          ColumnVector p;
++
++          if (xySym)
++            {
++              p = graphics_xform::xform_vector (xPlaneN, yPlane, (z_min+z_max)/2);
++              if (xisinf (fy))
++                p(0) += (signum(xPlaneN-xPlane)*fx*ztickoffset);
++              else
++                p(1) += (signum(yPlane-yPlaneN)*fy*ztickoffset);
++            }
++          else
++            {
++              p = graphics_xform::xform_vector (xPlane, yPlaneN, (z_min+z_max)/2);
++              if (xisinf (fx))
++                p(1) += (signum(yPlaneN-yPlane)*fy*ztickoffset);
++              else
++                p(0) += (signum(xPlane-xPlaneN)*fx*ztickoffset);
++            }
++          p = xform.transform (p(0), p(1), p(2), false);
++          switch (zstate)
++            {
++              case AXE_ANY_DIR:
++                if (camAuto)
++                  {
++                    p(0) -= wmax;
++                    angle = 90;
++                  }
++                /* FIXME: what's the correct offset?
++                   p[0] += (!xySym ? wmax : -wmax);
++                   p[1] += (zd*zv[2] <= 0 ? hmax : -hmax);
++                   */
++                break;
++              case AXE_VERT_DIR:
++                p(0) -= wmax;
++                angle = 90;
++                break;
++              case AXE_HORZ_DIR:
++                p(1) += hmax;
++                break;
++            }
++          p = xform.untransform (p(0), p(1), p(2), true);
++          zlabel_props.set_position (p.extract_n (0, 3).transpose ());
++          zlabel_props.set_rotation (angle);
++        }
++    }
++
++  set_linestyle ("-");
++
++  // Title
++
++  text::properties& title_props =
++    reinterpret_cast<text::properties&> (gh_manager::get_object (props.get_title ()).get_properties ());
++      
++  // FIXME: auto-positioning should be disabled if the 
++  //        title has been positioned manually
++  if (! title_props.get_string ().empty ())
++    {
++      Matrix bb = props.get_boundingbox (true);
++      ColumnVector p = xform.untransform (bb(0)+bb(2)/2, (bb(1)-10),
++          (x_zlim(0)+x_zlim(1))/2, true);
++      title_props.set_position (p.extract_n(0, 3).transpose ());
++    }
++
++  set_clipbox (x_min, x_max, y_min, y_max, z_min, z_max);
++
++  // Children
++
++  if (antialias == GL_TRUE)
++    glEnable (GL_LINE_SMOOTH);
++
++  Matrix children = props.get_children ();
++  std::list<graphics_object> obj_list;
++  std::list<graphics_object>::iterator it;
++
++  // 1st pass: draw light objects
++
++  for (int i = 0; i < children.numel (); i++)
++    {
++      graphics_object go = gh_manager::get_object (children (i));
++
++      if (go.get_properties ().is_visible ())
++        {
++          if (go.isa ("light"))
++	    draw (go);
++          else
++            obj_list.push_back (go);
++        }
++    }
++
++  // 2nd pass: draw other objects (with units set to "data")
++
++  it = obj_list.begin ();
++  while (it != obj_list.end ())
++    {
++      graphics_object go = (*it);
++
++      // FIXME: check whether object has "units" property and it is set to "data"
++      if (! go.isa ("text") || go.get ("units").string_value () == "data")
++        {
++          set_clipping (go.get_properties ().is_clipping ());
++          draw (go);
++
++          it = obj_list.erase (it);
++        }
++      else
++        it++;
++    }
++
++  // 3rd pass: draw remaining objects
++
++  for (it = obj_list.begin (); it != obj_list.end (); it++)
++    {
++      graphics_object go = (*it);
++
++      set_clipping (go.get_properties ().is_clipping ());
++      draw (go);
++    }
++
++  set_clipping (false);
++  // FIXME: finalize rendering (transparency processing)
++  // FIXME: draw zoom box, if needed
++}
++
++void
++opengl_renderer::draw (const line::properties& props)
++{
++  Matrix x = xform.xscale (props.get_xdata ().matrix_value ());
++  Matrix y = xform.yscale (props.get_ydata ().matrix_value ());
++  Matrix z = xform.zscale (props.get_zdata ().matrix_value ());
++
++  bool has_z = (z.numel () > 0);
++  int n = static_cast<int> (::xmin (::xmin (x.numel (), y.numel ()), (has_z ? z.numel () : INT_MAX)));
++  octave_uint8 clip_mask = (props.is_clipping () ? 0x7F : 0x40), clip_ok (0x40);
++
++  std::vector<octave_uint8> clip (n);
++
++  if (has_z)
++    for (int i = 0; i < n; i++)
++      clip[i] = (clip_code (x(i), y(i), z(i)) & clip_mask);
++  else
++    {
++      double z_mid = (zmin+zmax)/2;
++
++      for (int i = 0; i < n; i++)
++	clip[i] = (clip_code (x(i), y(i), z_mid) & clip_mask);
++    }
++
++  if (! props.linestyle_is ("none"))
++    {
++      set_color (props.get_color_rgb ());
++      set_linestyle (props.get_linestyle (), false);
++      set_linewidth (props.get_linewidth ());
++
++      if (has_z)
++	{
++	  bool flag = false;
++
++	  for (int i = 1; i < n; i++)
++	    {
++	      if ((clip[i-1] & clip[i]) == clip_ok)
++		{
++		  if (! flag)
++		    {
++		      flag = true;
++		      glBegin (GL_LINE_STRIP);
++		      glVertex3d (x(i-1), y(i-1), z(i-1));
++		    }
++		  glVertex3d (x(i), y(i), z(i));
++		}
++	      else if (flag)
++		{
++		  flag = false;
++		  glEnd ();
++		}
++	    }
++
++	  if (flag)
++	    glEnd ();
++	}
++      else
++	{
++	  bool flag = false;
++
++	  for (int i = 1; i < n; i++)
++	    {
++	      if ((clip[i-1] & clip[i]) == clip_ok)
++		{
++		  if (! flag)
++		    {
++		      flag = true;
++		      glBegin (GL_LINE_STRIP);
++		      glVertex2d (x(i-1), y(i-1));
++		    }
++		  glVertex2d (x(i), y(i));
++		}
++	      else if (flag)
++		{
++		  flag = false;
++		  glEnd ();
++		}
++	    }
++
++	  if (flag)
++	    glEnd ();
++	}
++	  
++      set_linewidth (0.5);
++      set_linestyle ("-");
++    }
++
++  set_clipping (false);
++
++  if (! props.marker_is ("none") &&
++      ! (props.markeredgecolor_is ("none")
++	 && props.markerfacecolor_is ("none")))
++    {
++      Matrix lc, fc;
++
++      if (props.markeredgecolor_is ("auto"))
++	lc = props.get_color_rgb ();
++      else if (! props.markeredgecolor_is ("none"))
++	lc = props.get_markeredgecolor_rgb ();
++
++      if (props.markerfacecolor_is ("auto"))
++	fc = props.get_color_rgb ();
++      else if (! props.markerfacecolor_is ("none"))
++	fc = props.get_markerfacecolor_rgb ();
++
++      init_marker (props.get_marker (), props.get_markersize (),
++		   props.get_linewidth ());
++
++      for (int i = 0; i < n; i++)
++        {
++          if (clip[i] == clip_ok)
++            draw_marker (x(i), y(i), (has_z ? z(i) : 0), lc, fc);
++        }
++
++      end_marker ();
++    }
++  
++  set_clipping (props.is_clipping ());
++}
++
++void
++opengl_renderer::draw (const surface::properties& props)
++{
++  Matrix x = xform.xscale (props.get_xdata ().matrix_value ());
++  Matrix y = xform.yscale (props.get_ydata ().matrix_value ());
++  Matrix z = xform.zscale (props.get_zdata ().matrix_value ());
++
++  int zr = z.rows (), zc = z.columns ();
++
++  NDArray c;
++  NDArray n = props.get_vertexnormals ().array_value ();
++
++  // FIXME: handle transparency
++  Matrix a;
++
++  if (props.facelighting_is ("phong") || props.edgelighting_is ("phong"))
++    warning ("opengl_renderer::draw: phong light model not supported");
++
++  int fc_mode = (props.facecolor_is_rgb () ? 0 :
++		 (props.facecolor_is ("flat") ? 1 :
++		  (props.facecolor_is ("interp") ? 2 :
++		   (props.facecolor_is ("texturemap") ? 3 : -1))));
++  int fl_mode = (props.facelighting_is ("none") ? 0 :
++		 (props.facelighting_is ("flat") ? 1 : 2));
++  int fa_mode = (props.facealpha_is_double () ? 0 :
++		 (props.facealpha_is ("flat") ? 1 : 2));
++  int ec_mode = (props.edgecolor_is_rgb () ? 0 :
++		 (props.edgecolor_is ("flat") ? 1 :
++		  (props.edgecolor_is ("interp") ? 2 : -1)));
++  int el_mode = (props.edgelighting_is ("none") ? 0 :
++		 (props.edgelighting_is ("flat") ? 1 : 2));
++  int ea_mode = (props.edgealpha_is_double () ? 0 :
++		 (props.edgealpha_is ("flat") ? 1 : 2));
++
++  Matrix fcolor = (fc_mode == 3 ? Matrix (1, 3, 1.0) : props.get_facecolor_rgb ());
++  Matrix ecolor = props.get_edgecolor_rgb ();
++
++  float as = props.get_ambientstrength ();
++  float ds = props.get_diffusestrength ();
++  float ss = props.get_specularstrength ();
++  float se = props.get_specularexponent ();
++  float cb[4] = { 0, 0, 0, 1 };
++
++  opengl_texture tex;
++
++  int i1, i2, j1, j2;
++  bool x_mat = (x.rows () == z.rows ());
++  bool y_mat = (y.columns () == z.columns ());
++
++  i1 = i2 = j1 = j2 = 0;
++
++  boolMatrix clip (z.dims (), false);
++
++  for (int i = 0; i < zr; i++)
++    {
++      if (x_mat)
++	i1 = i;
++
++      for (int j = 0; j < zc; j++)
++	{
++	  if (y_mat)
++	    j1 = j;
++
++	  clip(i,j) = is_nan_or_inf (x(i1,j), y(i,j1), z(i,j));
++	}
++    }
++
++  if ((fc_mode > 0 && fc_mode < 3) || ec_mode > 0)
++    c = props.get_color_data ().array_value ();
++
++  if (fa_mode > 0 || ea_mode > 0)
++    {
++      // FIXME: implement alphadata conversion
++      //a = props.get_alpha_data ();
++    }
++
++  if (fl_mode > 0 || el_mode > 0)
++    {
++      float buf[4] = { ss, ss, ss, 1 };
++
++      glMaterialfv (LIGHT_MODE, GL_SPECULAR, buf);
++      glMaterialf (LIGHT_MODE, GL_SHININESS, se);
++    }
++
++  // FIXME: good candidate for caching, transfering pixel
++  // data to OpenGL is time consuming.
++  if (fc_mode == 3)
++    tex = opengl_texture::create (props.get_color_data ());
++
++  if (! props.facecolor_is ("none"))
++    {
++      if (props.get_facealpha_double () == 1)
++	{
++	  if (fc_mode == 0 || fc_mode == 3)
++	    {
++	      glColor3dv (fcolor.data ());
++	      if (fl_mode > 0)
++		{
++		  for (int i = 0; i < 3; i++)
++		    cb[i] = (as * fcolor(i));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] *= (ds / as);
++		  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++		}
++	    }
++
++	  if (fl_mode > 0)
++	    glEnable (GL_LIGHTING);
++	  glShadeModel ((fc_mode == 2 || fl_mode == 2) ? GL_SMOOTH : GL_FLAT);
++	  set_polygon_offset (true, 1);
++	  if (fc_mode == 3)
++	    glEnable (GL_TEXTURE_2D);
++
++	  for (int i = 1; i < zc; i++)
++	    {
++	      if (y_mat)
++		{
++		  i1 = i-1;
++		  i2 = i;
++		}
++
++	      for (int j = 1; j < zr; j++)
++		{
++		  if (clip(j-1, i-1) || clip (j, i-1)
++		      || clip (j-1, i) || clip (j, i))
++		    continue;
++
++		  if (x_mat)
++		    {
++		      j1 = j-1;
++		      j2 = j;
++		    }
++
++		  glBegin (GL_QUADS);
++
++		  // Vertex 1
++		  if (fc_mode == 3)
++		    tex.tex_coord (double (i-1) / (zc-1), double (j-1) / (zr-1));
++		  else if (fc_mode > 0)
++		    {
++		      // FIXME: is there a smarter way to do this?
++		      for (int k = 0; k < 3; k++)
++			cb[k] = c(j-1, i-1, k);
++		      glColor3fv (cb);
++
++		      if (fl_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= as;
++			  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++			  
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= (ds / as);
++			  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			}
++		    }
++		  if (fl_mode > 0)
++		    glNormal3d (n(j-1,i-1,0), n(j-1,i-1,1), n(j-1,i-1,2));
++		  glVertex3d (x(j1,i-1), y(j-1,i1), z(j-1,i-1));
++
++		  // Vertex 2
++		  if (fc_mode == 3)
++		    tex.tex_coord (double (i) / (zc-1), double (j-1) / (zr-1));
++		  else if (fc_mode == 2)
++		    {
++		      for (int k = 0; k < 3; k++)
++			cb[k] = c(j-1, i, k);
++		      glColor3fv (cb);
++
++		      if (fl_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= as;
++			  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++			  
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= (ds / as);
++			  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			}
++		    }
++		  if (fl_mode == 2)
++		    glNormal3d (n(j-1,i,0), n(j-1,i,1), n(j-1,i,2));
++		  glVertex3d (x(j1,i), y(j-1,i2), z(j-1,i));
++		  
++		  // Vertex 3
++		  if (fc_mode == 3)
++		    tex.tex_coord (double (i) / (zc-1), double (j) / (zr-1));
++		  else if (fc_mode == 2)
++		    {
++		      for (int k = 0; k < 3; k++)
++			cb[k] = c(j, i, k);
++		      glColor3fv (cb);
++
++		      if (fl_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= as;
++			  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++			  
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= (ds / as);
++			  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			}
++		    }
++		  if (fl_mode == 2)
++		    glNormal3d (n(j,i,0), n(j,i,1), n(j,i,2));
++		  glVertex3d (x(j2,i), y(j,i2), z(j,i));
++		  
++		  // Vertex 4
++		  if (fc_mode == 3)
++		    tex.tex_coord (double (i-1) / (zc-1), double (j) / (zr-1));
++		  else if (fc_mode == 2)
++		    {
++		      for (int k = 0; k < 3; k++)
++			cb[k] = c(j, i-1, k);
++		      glColor3fv (cb);
++
++		      if (fl_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= as;
++			  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++			  
++			  for (int k = 0; k < 3; k++)
++			    cb[k] *= (ds / as);
++			  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			}
++		    }
++		  if (fl_mode == 2)
++		    glNormal3d (n(j,i-1,0), n(j,i-1,1), n(j,i-1,2));
++		  glVertex3d (x(j2,i-1), y(j,i1), z(j,i-1));
++
++		  glEnd ();
++		}
++	    }
++
++	  set_polygon_offset (false);
++	  if (fc_mode == 3)
++	    glDisable (GL_TEXTURE_2D);
++
++	  if (fl_mode > 0)
++	    glDisable (GL_LIGHTING);
++	}
++      else
++	{
++	  // FIXME: implement transparency
++	}
++    }
++
++  if (! props.edgecolor_is ("none"))
++    {
++      if (props.get_edgealpha_double () == 1)
++	{
++	  if (ec_mode == 0)
++	    {
++	      glColor3dv (ecolor.data ());
++	      if (fl_mode > 0)
++		{
++		  for (int i = 0; i < 3; i++)
++		    cb[i] = (as * ecolor(i));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] *= (ds / as);
++		  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++		}
++	    }
++
++	  if (el_mode > 0)
++	    glEnable (GL_LIGHTING);
++	  glShadeModel ((ec_mode == 2 || el_mode == 2) ? GL_SMOOTH : GL_FLAT);
++
++	  set_linestyle (props.get_linestyle (), false);
++	  set_linewidth (props.get_linewidth ());
++
++	  // Mesh along Y-axis
++
++	  if (props.meshstyle_is ("both") || props.meshstyle_is ("column"))
++	    {
++	      for (int i = 0; i < zc; i++)
++		{
++		  if (y_mat)
++		    {
++		      i1 = i-1;
++		      i2 = i;
++		    }
++
++		  for (int j = 1; j < zr; j++)
++		    {
++		      if (clip(j-1,i) || clip(j,i))
++			continue;
++
++		      if (x_mat)
++			{
++			  j1 = j-1;
++			  j2 = j;
++			}
++
++		      glBegin (GL_LINES);
++
++		      // Vertex 1
++		      if (ec_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] = c(j-1, i, k);
++			  glColor3fv (cb);
++
++			  if (fl_mode > 0)
++			    {
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= as;
++			      glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= (ds / as);
++			      glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			    }
++			}
++		      if (el_mode > 0)
++			glNormal3d (n(j-1,i,0), n(j-1,i,1), n(j-1,i,2));
++		      glVertex3d (x(j1,i), y(j-1,i2), z(j-1,i));
++
++		      // Vertex 2
++		      if (ec_mode == 2)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] = c(j, i, k);
++			  glColor3fv (cb);
++
++			  if (fl_mode > 0)
++			    {
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= as;
++			      glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= (ds / as);
++			      glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			    }
++			}
++		      if (el_mode == 2)
++			glNormal3d (n(j,i,0), n(j,i,1), n(j,i,2));
++		      glVertex3d (x(j2,i), y(j,i2), z(j,i));
++
++		      glEnd ();
++		    }
++		}
++	    }
++
++	  // Mesh along X-axis
++
++	  if (props.meshstyle_is ("both") || props.meshstyle_is ("row"))
++	    {
++	      for (int j = 0; j < zr; j++)
++		{
++		  if (x_mat)
++		    {
++		      j1 = j-1;
++		      j2 = j;
++		    }
++
++		  for (int i = 1; i < zc; i++)
++		    {
++		      if (clip(j,i-1) || clip(j,i))
++			continue;
++
++		      if (y_mat)
++			{
++			  i1 = i-1;
++			  i2 = i;
++			}
++
++		      glBegin (GL_LINES);
++
++		      // Vertex 1
++		      if (ec_mode > 0)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] = c(j, i-1, k);
++			  glColor3fv (cb);
++
++			  if (fl_mode > 0)
++			    {
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= as;
++			      glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= (ds / as);
++			      glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			    }
++			}
++		      if (el_mode > 0)
++			glNormal3d (n(j,i-1,0), n(j,i-1,1), n(j,i-1,2));
++		      glVertex3d (x(j2,i-1), y(j,i1), z(j,i-1));
++		      
++		      // Vertex 2
++		      if (ec_mode == 2)
++			{
++			  for (int k = 0; k < 3; k++)
++			    cb[k] = c(j, i, k);
++			  glColor3fv (cb);
++
++			  if (fl_mode > 0)
++			    {
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= as;
++			      glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++			      for (int k = 0; k < 3; k++)
++				cb[k] *= (ds / as);
++			      glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++			    }
++			}
++		      if (el_mode == 2)
++			glNormal3d (n(j,i,0), n(j,i,1), n(j,i,2));
++		      glVertex3d (x(j2,i), y(j,i2), z(j,i));
++		      
++		      glEnd ();
++		    }
++		}
++	    }
++
++	  set_linestyle ("-");
++	  set_linewidth (0.5);
++
++	  if (el_mode > 0)
++	    glDisable (GL_LIGHTING);
++	}
++      else
++	{
++	  // FIXME: implement transparency
++	}
++    }
++
++  if (! props.marker_is ("none") &&
++      ! (props.markeredgecolor_is ("none")
++	 && props.markerfacecolor_is ("none")))
++    {
++      // FIXME: check how transparency should be handled in markers
++      // FIXME: check what to do with marker facecolor set to auto
++      //        and facecolor set to none.
++
++      bool do_edge = ! props.markeredgecolor_is ("none");
++      bool do_face = ! props.markerfacecolor_is ("none");
++
++      Matrix mecolor = props.get_markeredgecolor_rgb ();
++      Matrix mfcolor = props.get_markerfacecolor_rgb ();
++      Matrix cc (1, 3, 0.0);
++
++      if (mecolor.numel () == 0 && props.markeredgecolor_is ("auto"))
++	{
++	  mecolor = props.get_edgecolor_rgb ();
++	  do_edge = ! props.edgecolor_is ("none");
++	}
++
++      if (mfcolor.numel () == 0 && props.markerfacecolor_is ("auto"))
++	{
++	  mfcolor = props.get_facecolor_rgb ();
++	  do_face = ! props.facecolor_is ("none");
++	}
++
++      if ((mecolor.numel () == 0 || mfcolor.numel () == 0)
++	  && c.numel () == 0)
++	c = props.get_color_data ().array_value ();
++
++      init_marker (props.get_marker (), props.get_markersize (),
++		   props.get_linewidth ());
++
++      for (int i = 0; i < zc; i++)
++	{
++	  if (y_mat)
++	    i1 = i;
++	  
++	  for (int j = 0; j < zr; j++)
++	    {
++	      if (clip(j,i))
++		continue;
++
++	      if (x_mat)
++		j1 = j;
++
++	      if ((do_edge && mecolor.numel () == 0)
++		  || (do_face && mfcolor.numel () == 0))
++		{
++		  for (int k = 0; k < 3; k++)
++		    cc(k) = c(j,i,k);
++		}
++
++	      Matrix lc = (do_edge ? (mecolor.numel () == 0 ? cc : mecolor) : Matrix ());
++	      Matrix fc = (do_face ? (mfcolor.numel () == 0 ? cc : mfcolor) : Matrix ());
++
++	      draw_marker (x(j1,i), y(j,i1), z(j,i), lc, fc);
++	    }
++	}
++
++      end_marker ();
++    }
++}
++
++// FIXME: global optimization (rendering, data structures...), there
++// is probably a smarter/faster/less-memory-consuming way to do this.
++void
++opengl_renderer::draw (const patch::properties &props)
++{
++  Matrix f = props.get_faces ().matrix_value ();
++  Matrix v = xform.scale (props.get_vertices ().matrix_value ());
++  Matrix c;
++  Matrix n = props.get_vertexnormals ().matrix_value ();
++  Matrix a;
++
++  int nv = v.rows ();
++  // int vmax = v.columns ();
++  int nf = f.rows ();
++  int fcmax = f.columns ();
++
++  bool has_z = (v.columns () > 2);
++  bool has_facecolor = false;
++  bool has_facealpha = false;
++
++  int fc_mode = (props.facecolor_is_rgb () ? 0 :
++		 (props.facecolor_is("flat") ? 1 : 2));
++  int fl_mode = (props.facelighting_is ("none") ? 0 :
++		 (props.facelighting_is ("flat") ? 1 : 2));
++  int fa_mode = (props.facealpha_is_double () ? 0 :
++		 (props.facealpha_is ("flat") ? 1 : 2));
++  int ec_mode = (props.edgecolor_is_rgb () ? 0 :
++		 (props.edgecolor_is("flat") ? 1 : 2));
++  int el_mode = (props.edgelighting_is ("none") ? 0 :
++		 (props.edgelighting_is ("flat") ? 1 : 2));
++  int ea_mode = (props.edgealpha_is_double () ? 0 :
++		 (props.edgealpha_is ("flat") ? 1 : 2));
++
++  Matrix fcolor = props.get_facecolor_rgb ();
++  Matrix ecolor = props.get_edgecolor_rgb ();
++  
++  float as = props.get_ambientstrength ();
++  float ds = props.get_diffusestrength ();
++  float ss = props.get_specularstrength ();
++  float se = props.get_specularexponent ();
++
++  boolMatrix clip (1, nv, false);
++
++  if (has_z)
++    for (int i = 0; i < nv; i++)
++      clip(i) = is_nan_or_inf (v(i,0), v(i,1), v(i,2));
++  else
++    for (int i = 0; i < nv; i++)
++      clip(i) = is_nan_or_inf (v(i,0), v(i,1), 0);
++
++  boolMatrix clip_f (1, nf, false);
++  Array<int> count_f (nf, 0);
++
++  for (int i = 0; i < nf; i++)
++    {
++      bool fclip = false;
++      int count = 0;
++
++      for (int j = 0; j < fcmax && ! xisnan (f(i,j)); j++, count++)
++	fclip = (fclip || clip(int (f(i,j) - 1)));
++
++      clip_f(i) = fclip;
++      count_f(i) = count;
++    }
++
++  if (fc_mode > 0 || ec_mode > 0)
++    {
++      c = props.get_color_data ().matrix_value ();
++
++      if (c.rows () == 1)
++	{
++	  // Single color specifications, we can simplify a little bit
++	  
++	  if (fc_mode > 0)
++	    {
++	      fcolor = c;
++	      fc_mode = 0;
++	    }
++
++	  if (ec_mode > 0)
++	    {
++	      ecolor = c;
++	      ec_mode = 0;
++	    }
++
++	  c = Matrix ();
++	}
++      else
++	has_facecolor = ((c.numel () > 0) && (c.rows () == f.rows ()));
++    }
++
++  if (fa_mode > 0 || ea_mode > 0)
++    {
++      // FIXME: retrieve alpha data from patch object
++      //a = props.get_alpha_data ();
++      has_facealpha = ((a.numel () > 0) && (a.rows () == f.rows ()));
++    }
++
++  octave_idx_type fr = f.rows ();
++  std::vector<vertex_data> vdata (f.numel ());
++
++  for (int i = 0; i < nf; i++)
++    for (int j = 0; j < count_f(i); j++)
++      {
++	int idx = int (f(i,j) - 1);
++
++	Matrix vv (1, 3, 0.0);
++	Matrix cc;
++	Matrix nn(1, 3, 0.0);
++	double aa = 1.0;
++
++	vv(0) = v(idx,0); vv(1) = v(idx,1);
++	if (has_z)
++	  vv(2) = v(idx,2);
++	// FIXME: uncomment when patch object has normal computation
++	//nn(0) = n(idx,0); nn(1) = n(idx,1); nn(2) = n(idx,2);
++	if (c.numel () > 0)
++	  {
++	    cc.resize (1, 3);
++	    if (has_facecolor)
++	      cc(0) = c(i,0), cc(1) = c(i,1), cc(2) = c(i,2);
++	    else
++	      cc(0) = c(idx,0), cc(1) = c(idx,1), cc(2) = c(idx,2);
++	  }
++	if (a.numel () > 0)
++	  {
++	    if (has_facealpha)
++	      aa = a(i);
++	    else
++	      aa = a(idx);
++	  }
++
++	vdata[i+j*fr] =
++	    vertex_data (vv, cc, nn, aa, as, ds, ss, se);
++      }
++
++  if (fl_mode > 0 || el_mode > 0)
++    {
++      float buf[4] = { ss, ss, ss, 1 };
++
++      glMaterialfv (LIGHT_MODE, GL_SPECULAR, buf);
++      glMaterialf (LIGHT_MODE, GL_SHININESS, se);
++    }
++
++  if (! props.facecolor_is ("none"))
++    {
++      // FIXME: adapt to double-radio property
++      if (props.get_facealpha_double () == 1)
++	{
++	  if (fc_mode == 0)
++	    {
++	      glColor3dv (fcolor.data ());
++	      if (fl_mode > 0)
++		{
++		  float cb[4] = { 0, 0, 0, 1 };
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] = (as * fcolor(i));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] *= (ds / as);
++		  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++		}
++	    }
++
++	  if (fl_mode > 0)
++	    glEnable (GL_LIGHTING);
++
++	  // FIXME: use __index__ property from patch object
++	  patch_tesselator tess (this, fc_mode, fl_mode, 0);
++
++	  for (int i = 0; i < nf; i++)
++	    {
++	      if (clip_f(i))
++		continue;
++
++	      tess.begin_polygon (true);
++	      tess.begin_contour ();
++
++	      for (int j = 0; j < count_f(i); j++)
++		{
++		  vertex_data::vertex_data_rep *vv = vdata[i+j*fr].get_rep ();
++	
++		  tess.add_vertex (vv->coords.fortran_vec (), vv);
++		}
++
++	      tess.end_contour ();
++	      tess.end_polygon ();
++	    }
++
++	  if (fl_mode > 0)
++	    glDisable (GL_LIGHTING);
++	}
++      else
++	{
++	  // FIXME: implement transparency
++	}
++    }
++
++  if (! props.edgecolor_is ("none"))
++    {
++      // FIXME: adapt to double-radio property
++      if (props.get_edgealpha_double () == 1)
++	{
++	  if (ec_mode == 0)
++	    {
++	      glColor3dv (ecolor.data ());
++	      if (el_mode > 0)
++		{
++		  float cb[4] = { 0, 0, 0, 1 };
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] = (as * ecolor(i));
++		  glMaterialfv (LIGHT_MODE, GL_AMBIENT, cb);
++
++		  for (int i = 0; i < 3; i++)
++		    cb[i] *= (ds / as);
++		  glMaterialfv (LIGHT_MODE, GL_DIFFUSE, cb);
++		}
++	    }
++
++	  if (el_mode > 0)
++	    glEnable (GL_LIGHTING);
++
++	  set_linestyle (props.get_linestyle (), false);
++	  set_linewidth (props.get_linewidth ());
++
++	  // FIXME: use __index__ property from patch object; should we
++	  // offset patch contour as well?
++	  patch_tesselator tess (this, ec_mode, el_mode);
++
++	  for (int i = 0; i < nf; i++)
++	    {
++	      if (clip_f(i))
++		continue;
++
++	      tess.begin_polygon (false);
++	      tess.begin_contour ();
++
++	      for (int j = 0; j < count_f(i); j++)
++		{
++		  vertex_data::vertex_data_rep *vv = vdata[i+j*fr].get_rep ();
++	
++		  tess.add_vertex (vv->coords.fortran_vec (), vv);
++		}
++
++	      tess.end_contour ();
++	      tess.end_polygon ();
++	    }
++
++	  set_linestyle ("-");
++	  set_linewidth (0.5);
++
++	  if (el_mode > 0)
++	    glDisable (GL_LIGHTING);
++	}
++      else
++	{
++	  // FIXME: implement transparency
++	}
++    }
++
++  if (! props.marker_is ("none") &&
++      ! (props.markeredgecolor_is ("none") && props.markerfacecolor_is ("none")))
++    {
++      bool do_edge = ! props.markeredgecolor_is ("none");
++      bool do_face = ! props.markerfacecolor_is ("none");
++
++      Matrix mecolor = props.get_markeredgecolor_rgb ();
++      Matrix mfcolor = props.get_markerfacecolor_rgb ();
++      Matrix cc (1, 3, 0.0);
++
++      if (mecolor.numel () == 0 && props.markeredgecolor_is ("auto"))
++	{
++	  mecolor = props.get_edgecolor_rgb ();
++	  do_edge = ! props.edgecolor_is ("none");
++	}
++
++      if (mfcolor.numel () == 0 && props.markerfacecolor_is ("auto"))
++	{
++	  mfcolor = props.get_facecolor_rgb ();
++	  do_face = ! props.facecolor_is ("none");
++	}
++
++      init_marker (props.get_marker (), props.get_markersize (),
++		   props.get_linewidth ());
++
++      for (int i = 0; i < nf; i++)
++	for (int j = 0; j < count_f(i); j++)
++	  {
++	    int idx = int (f(i,j) - 1);
++
++	    if (clip(idx))
++	      continue;
++
++	    Matrix lc = (do_edge ? (mecolor.numel () == 0 ?
++				    vdata[i+j*fr].get_rep ()->color : mecolor)
++			 : Matrix ());
++	    Matrix fc = (do_face ? (mfcolor.numel () == 0 ?
++				    vdata[i+j*fr].get_rep ()->color : mfcolor)
++			 : Matrix ());
++
++	    draw_marker (v(idx,0), v(idx,1), (has_z ? v(idx,2) : 0), lc, fc);
++	  }
++
++      end_marker ();
++    }
++}
++
++void
++opengl_renderer::draw (const hggroup::properties &props)
++{
++  draw (props.get_children ());
++}
++
++void
++opengl_renderer::set_viewport (int w, int h)
++{
++  glViewport (0, 0, w, h);
++}
++
++void
++opengl_renderer::set_color (const Matrix& c)
++{
++  glColor3dv (c.data ());
++}
++
++void
++opengl_renderer::set_polygon_offset (bool on, double offset)
++{
++  if (on)
++    {
++      glPolygonOffset (offset, offset);
++      glEnable (GL_POLYGON_OFFSET_FILL);
++      glEnable (GL_POLYGON_OFFSET_LINE);
++    }
++  else
++    {
++      glDisable (GL_POLYGON_OFFSET_FILL);
++      glDisable (GL_POLYGON_OFFSET_LINE);
++    }
++}
++
++void
++opengl_renderer::set_linewidth (float w)
++{
++  glLineWidth (w);
++}
++
++void
++opengl_renderer::set_linestyle (const std::string& s, bool use_stipple)
++{
++  bool solid = false;
++
++  if (s == "-")
++    {
++      glLineStipple (1, static_cast<unsigned short> (0xFFFF));
++      solid = true;
++    }
++  else if (s == ":")
++    glLineStipple (1, static_cast<unsigned short> (0x8888));
++  else if (s == "--")
++    glLineStipple (1, static_cast<unsigned short> (0x0FFF));
++  else if (s == "-.")
++    glLineStipple (1, static_cast<unsigned short> (0x020F));
++  else
++    glLineStipple (1, static_cast<unsigned short> (0x0000));
++
++  if (solid && ! use_stipple)
++    glDisable (GL_LINE_STIPPLE);
++  else
++    glEnable (GL_LINE_STIPPLE);
++}
++
++void
++opengl_renderer::set_clipbox (double x1, double x2, double y1, double y2,
++			      double z1, double z2)
++{
++  double dx = (x2-x1);
++  double dy = (y2-y1);
++  double dz = (z2-z1);
++
++  x1 -= 0.001*dx; x2 += 0.001*dx;
++  y1 -= 0.001*dy; y2 += 0.001*dy;
++  z1 -= 0.001*dz; z2 += 0.001*dz;
++
++  ColumnVector p (4, 0.0);
++
++  p(0) = -1; p(3) = x2;
++  glClipPlane (GL_CLIP_PLANE0, p.data ());
++  p(0) = 1; p(3) = -x1;
++  glClipPlane (GL_CLIP_PLANE1, p.data ());
++  p(0) = 0; p(1) = -1; p(3) = y2;
++  glClipPlane (GL_CLIP_PLANE2, p.data ());
++  p(1) = 1; p(3) = -y1;
++  glClipPlane (GL_CLIP_PLANE3, p.data ());
++  p(1) = 0; p(2) = -1; p(3) = z2;
++  glClipPlane (GL_CLIP_PLANE4, p.data ());
++  p(2) = 1; p(3) = -z1;
++  glClipPlane (GL_CLIP_PLANE5, p.data ());
++
++  xmin = x1; xmax = x2;
++  ymin = y1; ymax = y2;
++  zmin = z1; zmax = z2;
++}
++
++void
++opengl_renderer::set_clipping (bool enable)
++{
++  bool has_clipping = (glIsEnabled (GL_CLIP_PLANE0) == GL_TRUE);
++
++  if (enable != has_clipping)
++    {
++      if (enable)
++        for (int i = 0; i < 6; i++)
++          glEnable (GL_CLIP_PLANE0+i);
++      else
++        for (int i = 0; i < 6; i++)
++          glDisable (GL_CLIP_PLANE0+i);
++    }
++}
++
++void
++opengl_renderer::init_marker (const std::string& m, double size, float width)
++{
++  int vw[4];
++
++  glGetIntegerv (GL_VIEWPORT, vw);
++
++  glMatrixMode (GL_PROJECTION);
++  glPushMatrix ();
++  glLoadIdentity ();
++  glOrtho (0, vw[2], vw[3], 0, xZ1, xZ2);
++  glMatrixMode (GL_MODELVIEW);
++  glPushMatrix ();
++
++  set_clipping (false);
++  set_linewidth (width);
++
++  marker_id = make_marker_list (m, size, false);
++  filled_marker_id = make_marker_list (m, size, true);
++}
++
++void
++opengl_renderer::end_marker (void)
++{
++  glDeleteLists (marker_id, 1);
++  glDeleteLists (filled_marker_id, 1);
++
++  glMatrixMode (GL_MODELVIEW);
++  glPopMatrix ();
++  glMatrixMode (GL_PROJECTION);
++  glPopMatrix ();
++  set_linewidth (0.5f);
++}
++
++void
++opengl_renderer::draw_marker (double x, double y, double z,
++			      const Matrix& lc, const Matrix& fc)
++{
++  ColumnVector tmp = xform.transform (x, y, z, false);
++  
++  glLoadIdentity ();
++  glTranslated (tmp(0), tmp(1), -tmp(2));
++
++  if (filled_marker_id > 0 && fc.numel () > 0)
++    {
++      glColor3dv (fc.data ());
++      set_polygon_offset (true, -1.0);
++      glCallList (filled_marker_id);
++      if (lc.numel () > 0)
++	{
++	  glColor3dv (lc.data ());
++	  glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
++	  glEdgeFlag (GL_TRUE);
++	  set_polygon_offset (true, -2.0);
++	  glCallList (filled_marker_id);
++	  glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
++	}
++      set_polygon_offset (false);
++    }
++  else if (marker_id > 0 && lc.numel () > 0)
++    {
++      glColor3dv (lc.data ());
++      glCallList (marker_id);
++    }
++}
++
++unsigned int
++opengl_renderer::make_marker_list (const std::string& marker, double size,
++				   bool filled) const
++{
++  char c = marker[0];
++
++  if (filled && (c == '+' || c == 'x' || c == '*' || c == '.'))
++    return 0;
++
++  unsigned int ID = glGenLists (1);
++  double sz = size * backend.get_screen_resolution () / 72.0;
++
++  // constants for the * marker
++  const double sqrt2d4 = 0.35355339059327;
++  double tt = sz*sqrt2d4;
++
++  glNewList (ID, GL_COMPILE);
++
++  switch (marker[0])
++    {
++    case '+':
++      glBegin (GL_LINES);
++      glVertex2f (-sz/2 ,0     );
++      glVertex2f (sz/2  ,0     );
++      glVertex2f (0     ,-sz/2 );
++      glVertex2f (0     ,sz/2  );
++      glEnd ();
++      break;
++    case 'x':
++      glBegin(GL_LINES);
++      glVertex2f (-sz/2 ,-sz/2);
++      glVertex2f (sz/2  ,sz/2 );
++      glVertex2f (-sz/2 ,sz/2 );
++      glVertex2f (sz/2 ,-sz/2 );
++      glEnd ();
++      break;
++    case '*':
++      glBegin (GL_LINES);
++      glVertex2f (-sz/2 ,0     );
++      glVertex2f (sz/2  ,0     );
++      glVertex2f (0     ,-sz/2 );
++      glVertex2f (0     ,sz/2  );
++      glVertex2f (-tt   ,-tt   );
++      glVertex2f (+tt   ,+tt   );
++      glVertex2f (-tt   ,+tt   );
++      glVertex2f (+tt   ,-tt   );
++      glEnd ();
++      break;
++    case '.':
++      glBegin (GL_POLYGON);
++      glVertex2f (-sz/10, -sz/10);
++      glVertex2f (-sz/10, sz/10 );
++      glVertex2f (sz/10 , sz/10 );
++      glVertex2f (sz/10 , -sz/10);
++      glEnd ();
++      break;
++    case 's':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2d (-sz/2, -sz/2);
++      glVertex2d (-sz/2,  sz/2);
++      glVertex2d ( sz/2,  sz/2);
++      glVertex2d ( sz/2, -sz/2);
++      glEnd();
++      break;
++    case 'o':
++      {
++	double ang_step = M_PI / 5;
++
++	glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++	for (double ang = 0; ang < (2*M_PI); ang += ang_step)
++	  glVertex2d (sz*cos(ang)/2, sz*sin(ang)/2);
++	glEnd ();
++      }
++      break;
++    case 'd':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2d (    0, -sz/2);
++      glVertex2d ( sz/2,     0);
++      glVertex2d (    0,  sz/2);
++      glVertex2d (-sz/2,     0);
++      glEnd();
++      break;
++    case '^':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2f (0     ,  sz/2);
++      glVertex2f (sz/2  , -sz/2);
++      glVertex2f (-sz/2 , -sz/2);
++      glEnd ();
++      break;
++    case 'v':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2f (0     ,-sz/2);
++      glVertex2f (-sz/2 ,sz/2 );
++      glVertex2f (sz/2  ,sz/2 );
++      glEnd ();
++      break;
++    case '>':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2f (sz/2  ,0    );
++      glVertex2f (-sz/2 ,sz/2 );
++      glVertex2f (-sz/2 ,-sz/2);
++      glEnd ();
++      break;
++    case '<':
++      glBegin ((filled ? GL_POLYGON : GL_LINE_LOOP));
++      glVertex2f (-sz/2 ,0    );
++      glVertex2f (sz/2  ,-sz/2);
++      glVertex2f (sz/2  ,sz/2 );
++      glEnd ();
++      break;
++    default:
++      warning ("opengl_renderer: unsupported marker `%s'",
++	       marker.c_str ());
++      break;
++    }
++
++  glEndList ();
++
++  return ID;
++}
++
++/*
++;;; Local Variables: ***
++;;; mode: C++ ***
++;;; End: ***
++*/




More information about the Pkg-octave-commit mailing list