/*

 Copyright (C) 2007, 2008, 2009 John W. Eaton

 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 <cctype>

 #include <cfloat>

 #include <cstdlib>

 #include <algorithm>

 #include <list>

 #include <map>

 #include <set>

 #include <string>

 #include <sstream>

 #include "file-ops.h"

 #include "file-stat.h"

 #include "cmd-edit.h"

 #include "defun.h"

 #include "display.h"

 #include "error.h"

 #include "graphics.h"

 #include "input.h"

 #include "ov.h"

 #include "oct-obj.h"

 #include "oct-map.h"

 #include "ov-fcn-handle.h"

 #include "parse.h"

 #include "toplev.h"

 #include "unwind-prot.h"

 // forward declaration

 static octave_value xget (const graphics_handle& h, const caseless_str& name);

 static void

 gripe_set_invalid (const std::string& pname)

 {

   error ("set: invalid value for %s property", pname.c_str ());

 }

 static Matrix

 jet_colormap (void)

 {

   Matrix cmap (64, 3, 0.0);

   for (octave_idx_type i = 0; i < 64; i++)

     {

       // This is the jet colormap.  It would be nice to be able

       // to feval the jet function but since there is a static

       // property object that includes a colormap_property

       // object, we need to initialize this before main is even

       // called, so calling an interpreted function is not

       // possible.

       double x = i / 63.0;

       if (x >= 3.0/8.0 && x < 5.0/8.0)

         cmap(i,0) = 4.0 * x - 3.0/2.0;

       else if (x >= 5.0/8.0 && x < 7.0/8.0)

         cmap(i,0) = 1.0;

       else if (x >= 7.0/8.0)

         cmap(i,0) = -4.0 * x + 9.0/2.0;

       if (x >= 1.0/8.0 && x < 3.0/8.0)

         cmap(i,1) = 4.0 * x - 1.0/2.0;

       else if (x >= 3.0/8.0 && x < 5.0/8.0)

         cmap(i,1) = 1.0;

       else if (x >= 5.0/8.0 && x < 7.0/8.0)

         cmap(i,1) = -4.0 * x + 7.0/2.0;

       if (x < 1.0/8.0)

         cmap(i,2) = 4.0 * x + 1.0/2.0;

       else if (x >= 1.0/8.0 && x < 3.0/8.0)

         cmap(i,2) = 1.0;

       else if (x >= 3.0/8.0 && x < 5.0/8.0)

         cmap(i,2) = -4.0 * x + 5.0/2.0;

     }

   return cmap;

 }

 static double

 default_screendepth (void)

 {

   return display_info::depth ();

 }

 static Matrix

 default_screensize (void)

 {

   Matrix retval (1, 4, 1.0);

   retval(2) = display_info::width ();

   retval(3) = display_info::height ();

   return retval;

 }

 static double

 default_screenpixelsperinch (void)

 {

   return (display_info::x_dpi () + display_info::y_dpi ()) / 2;

 }

 static Matrix

 default_colororder (void)

 {

   Matrix retval (7, 3, 0.0);

   retval(0,2) = 1.0;

   retval(1,1) = 0.5;

   retval(2,0) = 1.0;

   retval(3,1) = 0.75;

   retval(3,2) = 0.75;

   retval(4,0) = 0.75;

   retval(4,2) = 0.75;

   retval(5,0) = 0.75;

   retval(5,1) = 0.75;

   retval(6,0) = 0.25;

   retval(6,1) = 0.25;

   retval(6,2) = 0.25;

   return retval;

 }

 static Matrix

 default_lim (void)

 {

   Matrix m (1, 2, 0);

   m(1) = 1;

   return m;

 }

 static Matrix

 default_data (void)

 {

   Matrix retval (1, 2);

   retval(0) = 0;

   retval(1) = 1;

   return retval;

 }

 static Matrix

 default_axes_position (void)

 {

   Matrix m (1, 4, 0.0);

   m(0) = 0.13;

   m(1) = 0.11;

   m(2) = 0.775;

   m(3) = 0.815;

   return m;

 }

 static Matrix

 default_axes_outerposition (void)

 {

   Matrix m (1, 4, 0.0);

   m(2) = m(3) = 1.0;

   return m;

 }

 static Matrix

 default_axes_tick (void)

 {

   Matrix m (1, 6, 0.0);

   m(0) = 0.0;

   m(1) = 0.2;

   m(2) = 0.4;

   m(3) = 0.6;

   m(4) = 0.8;

   m(5) = 1.0;

   return m;

 }

 static Matrix

 default_axes_ticklength (void)

 {

   Matrix m (1, 2, 0.01);

   m(1) = 0.025;

   return m;

 }

 static Matrix

 default_figure_position (void)

 {

   Matrix m (1, 4, 0.0);

   m(0) = 300;

   m(1) = 200;

   m(2) = 560;

   m(3) = 420;

   return m;

 }

 static Matrix

 default_figure_papersize (void)

 {

   Matrix m (1, 2, 0.0);

   m(0) = 8.5;

   m(1) = 11.0;

   return m;

 }

 static Matrix

 default_figure_paperposition (void)

 {

   Matrix m (1, 4, 0.0);

   m(0) = 0.25;

   m(1) = 2.50;

   m(2) = 8.00;

   m(3) = 6.00;

   return m;

 }

 static Matrix

 convert_position (const Matrix& pos, const caseless_str& from_units,

 		  const caseless_str& to_units,

 		  const Matrix& parent_dim = Matrix (1, 2, 0.0))

 {

   Matrix retval (1, 4);

   double res = 0;

   if (from_units.compare ("pixels"))

     retval = pos;

   else if (from_units.compare ("normalized"))

     {

       retval(0) = pos(0) * parent_dim(0) + 1;

       retval(1) = pos(1) * parent_dim(1) + 1;

       retval(2) = pos(2) * parent_dim(0);

       retval(3) = pos(3) * parent_dim(1);

     }

   else if (from_units.compare ("characters"))

     {

       if (res <= 0)

 	res = xget (0, "screenpixelsperinch").double_value ();

       double f = 0.0;

       // FIXME -- this assumes the system font is Helvetica 10pt 

       //          (for which "x" requires 6x12 pixels at 74.951 pixels/inch)

       f = 12.0 * res / 74.951;

       if (f > 0)

 	{

 	  retval(0) = 0.5 * pos(0) * f;

 	  retval(1) = pos(1) * f;

 	  retval(2) = 0.5 * pos(2) * f;

 	  retval(3) = pos(3) * f;

 	}

     }

   else

     {

       if (res <= 0)

 	res = xget (0, "screenpixelsperinch").double_value ();

       double f = 0.0;

       if (from_units.compare ("points"))

 	f = res / 72.0;

       else if (from_units.compare ("inches"))

 	f = res;

       else if (from_units.compare ("centimeters"))

 	f = res / 2.54;

       if (f > 0)

 	{

 	  retval(0) = pos(0) * f + 1;

 	  retval(1) = pos(1) * f + 1;

 	  retval(2) = pos(2) * f;

 	  retval(3) = pos(3) * f;

 	}

     }

   if (! to_units.compare ("pixels"))

     {

       if (to_units.compare ("normalized"))

 	{

 	  retval(0) = (retval(0) - 1) / parent_dim(0);

 	  retval(1) = (retval(1) - 1) / parent_dim(1);

 	  retval(2) /= parent_dim(0);

 	  retval(3) /= parent_dim(1);

 	}

       else if (to_units.compare ("characters"))

 	{

 	  if (res <= 0)

 	    res = xget (0, "screenpixelsperinch").double_value ();

 	  double f = 0.0;

 	  f = 12.0 * res / 74.951;

 	  if (f > 0)

 	    {

 	      retval(0) = 2 * retval(0) / f;

 	      retval(1) = retval(1) / f;

 	      retval(2) = 2 * retval(2) / f;

 	      retval(3) = retval(3) / f;

 	    }

 	}

       else

 	{

 	  if (res <= 0)

 	    res = xget (0, "screenpixelsperinch").double_value ();

 	  double f = 0.0;

 	  if (to_units.compare ("points"))

 	    f = res / 72.0;

 	  else if (to_units.compare ("inches"))

 	    f = res;

 	  else if (to_units.compare ("centimeters"))

 	    f = res / 2.54;

 	  if (f > 0)

 	    {

 	      retval(0) = (retval(0) - 1) / f;

 	      retval(1) = (retval(1) - 1) / f;

 	      retval(2) /= f;

 	      retval(3) /= f;

 	    }

 	}

     }

   return retval;

 }

 static graphics_object

 xget_ancestor (const graphics_object& go_arg, const std::string& type)

 {

   graphics_object go = go_arg;

   do

     {

       if (go.valid_object ())

 	{

 	  if (go.isa (type))

 	    return go;

 	  else

 	    go = gh_manager::get_object (go.get_parent ());

 	}

       else

 	return graphics_object ();

     }

  while (true);

 }

 static octave_value

 convert_cdata (const base_properties& props, const octave_value& cdata,

 	       bool is_scaled, int cdim)

 {

   dim_vector dv (cdata.dims ());

   if (dv.length () == cdim && dv(cdim-1) == 3)

     return cdata;

   Matrix cmap (1, 3, 0.0);

   Matrix clim (1, 2, 0.0);

   graphics_object go = gh_manager::get_object (props.get___myhandle__ ());

   graphics_object fig = xget_ancestor (go, "figure");

   if (fig.valid_object ())

     {

       Matrix _cmap = fig.get (caseless_str ("colormap")).matrix_value ();

       if (! error_state)

 	cmap = _cmap;

     }

   if (is_scaled)

     {

       graphics_object ax = xget_ancestor (go, "axes");

       if (ax.valid_object ())

 	{

 	  Matrix _clim = ax.get (caseless_str ("clim")).matrix_value ();

 	  if (! error_state)

 	    clim = _clim;

 	}

     }

   dv.resize (cdim);

   dv(cdim-1) = 3;

   NDArray a (dv);

   octave_idx_type lda = a.numel () / static_cast<octave_idx_type> (3);

   octave_idx_type nc = cmap.rows ();

   double *av = a.fortran_vec ();

   const double *cmapv = cmap.data ();

   const double *cv = 0;

   const octave_uint8 *icv = 0;

   if (cdata.is_integer_type ())

     icv = cdata.uint8_array_value ().data ();

   else

     cv = cdata.array_value ().data ();

   for (octave_idx_type i = 0; i < lda; i++)

     {

       double x = (cv ? cv[i] : double (icv[i]));

       if (is_scaled)

 	x = xround ((nc - 1) * (x - clim(0)) / (clim(1) - clim(0)));

       else

 	x = xround (x - 1);

       if (x < 0)

 	x = 0;

       else if (x >= nc)

 	x = (nc - 1);

       octave_idx_type idx = static_cast<octave_idx_type> (x);

       av[i]       = cmapv[idx];

       av[i+lda]   = cmapv[idx+nc];

       av[i+2*lda] = cmapv[idx+2*nc];

     }

   return octave_value (a);

 }

 template<class T>

 static void

 get_array_limits (const Array<T>& m, double& emin, double& emax,

 		  double& eminp)

 {

   const T *data = m.data ();

   octave_idx_type n = m.numel ();

   for (octave_idx_type i = 0; i < n; i++)

     {

       double e = double (data[i]);

       if (! (xisinf (e) || xisnan (e)))

 	{

 	  if (e < emin)

 	    emin = e;

 	  if (e > emax)

 	    emax = e;

 	  if (e > 0 && e < eminp)

 	    eminp = e;

 	}

     }

 }

 static bool

 lookup_object_name (const caseless_str& name, caseless_str& go_name,

 		    caseless_str& rest)

 {

   int len = name.length ();

   int offset = 0;

   bool result = false;

   if (len >= 4)

     {

       caseless_str pfx = name.substr (0, 4);

       if (pfx.compare ("axes") || pfx.compare ("line")

 	  || pfx.compare ("text"))

 	offset = 4;

       else if (len >= 5)

 	{

 	  pfx = name.substr (0, 5);

 	  if (pfx.compare ("image") || pfx.compare ("patch"))

 	    offset = 5;

 	  else if (len >= 6)

 	    {

 	      pfx = name.substr (0, 6);

 	      if (pfx.compare ("figure"))

 		offset = 6;

 	      else if (len >= 7)

 		{

 		  pfx = name.substr (0, 7);

 		  if (pfx.compare ("surface") || pfx.compare ("hggroup"))

 		    offset = 7;

 		}

 	    }

 	}

       if (offset > 0)

 	{

 	  go_name = pfx;

 	  rest = name.substr (offset);

 	  result = true;

 	}

     }

   return result;

 }

 static base_graphics_object*

 make_graphics_object_from_type (const caseless_str& type,

 				const graphics_handle& h = graphics_handle (),

 				const graphics_handle& p = graphics_handle ())

 {

   base_graphics_object *go = 0;

   if (type.compare ("figure"))

     go = new figure (h, p);

   else if (type.compare ("axes"))

     go = new axes (h, p);

   else if (type.compare ("line"))

     go = new line (h, p);

   else if (type.compare ("text"))

     go = new text (h, p);

   else if (type.compare ("image"))

     go = new image (h, p);

   else if (type.compare ("patch"))

     go = new patch (h, p);

   else if (type.compare ("surface"))

     go = new surface (h, p);

   else if (type.compare ("hggroup"))

     go = new hggroup (h, p);

   return go;

 }

 // ---------------------------------------------------------------------

 bool

 base_property::set (const octave_value& v, bool do_run )

 {

   if (do_set (v))

     {

       // notify backend

       if (id >= 0)

 	{

 	  graphics_object go = gh_manager::get_object (parent);

 	  if (go)

 	    {

 	      graphics_backend backend = go.get_backend();

 	      if (backend)

 		backend.property_changed (go, id);

 	    }

 	}

       // run listeners

       if (do_run && ! error_state)

 	run_listeners (POSTSET);

       return true;

     }

   return false;

 }

 void

 base_property::run_listeners (listener_mode mode)

 {

   const octave_value_list& l = listeners[mode];

   for (int i = 0; i < l.length (); i++)

     {

       gh_manager::execute_callback (parent, l(i), octave_value ());

       if (error_state)

 	break;

     }

 }

 radio_values::radio_values (const std::string& opt_string)

 {

   size_t beg = 0;

   size_t len = opt_string.length ();

   bool done = len == 0;

   while (! done)

     {

       size_t end = opt_string.find ('|', beg);

       if (end == std::string::npos)

 	{

 	  end = len;

 	  done = true;

 	}

       std::string t = opt_string.substr (beg, end-beg);

       // Might want more error checking here...

       if (t[0] == '{')

 	{

 	  t = t.substr (1, t.length () - 2);

 	  default_val = t;

 	}

       else if (beg == 0) // ensure default value

 	default_val = t;

       possible_vals.insert (t);

       beg = end + 1;

     }

 }

 bool

 color_values::str2rgb (std::string str)

 {

   double tmp_rgb[3] = {0, 0, 0};

   bool retval = true;

   unsigned int len = str.length();

   std::transform (str.begin (), str.end (), str.begin (), tolower);

   if (str.compare(0, len, "blue", 0, len) == 0)

     tmp_rgb[2] = 1;

   else if (str.compare(0, len, "black", 0, len) == 0

 	   || str.compare(0, len, "k", 0, len) == 0)

     tmp_rgb[0] = tmp_rgb[1] = tmp_rgb[2] = 0;

   else if (str.compare(0, len, "red", 0, len) == 0)

     tmp_rgb[0] = 1;

   else if (str.compare(0, len, "green", 0, len) == 0)

     tmp_rgb[1] = 1;

   else if (str.compare(0, len, "yellow", 0, len) == 0)

     tmp_rgb[0] = tmp_rgb[1] = 1;

   else if (str.compare(0, len, "magenta", 0, len) == 0)

     tmp_rgb[0] = tmp_rgb[2] = 1;

   else if (str.compare(0, len, "cyan", 0, len) == 0)

     tmp_rgb[1] = tmp_rgb[2] = 1;

   else if (str.compare(0, len, "white", 0, len) == 0

 	   || str.compare(0, len, "w", 0, len) == 0)

     tmp_rgb[0] = tmp_rgb[1] = tmp_rgb[2] = 1;

   else	

     retval = false;

   if (retval)

     {

       for (int i = 0; i < 3; i++)

 	xrgb(i) = tmp_rgb[i];

     }

   return retval;

 }

 bool

 color_property::do_set (const octave_value& val)

 {

   if (val.is_string ())

     {

       std::string s = val.string_value ();

       if (! s.empty ())

 	{

 	  if (radio_val.contains (s))

 	    {

 	      if (current_type != radio_t || current_val != s)

 		{

 		  current_val = s;

 		  current_type = radio_t;

 		  return true;

 		}

 	    }

           else

 	    {

 	      color_values col (s);

 	      if (! error_state)

 		{

 		  if (current_type != color_t || col != color_val)

 		    {

 		      color_val = col;

 		      current_type = color_t;

 		      return true;

 		    }

 		}

 	      else

 		error ("invalid value for color property \"%s\" (value = %s)",

 		       get_name ().c_str (), s.c_str ());

 	    }	

 	}

       else

 	error ("invalid value for color property \"%s\"",

            get_name ().c_str ());

     }

   else if (val.is_numeric_type ())

     {

       Matrix m = val.matrix_value ();

       if (m.numel () == 3)

 	{

 	  color_values col (m (0), m (1), m(2));

 	  if (! error_state)

 	    {

 	      if (current_type != color_t || col != color_val)

 		{

 		  color_val = col;

 		  current_type = color_t;

 		  return true;

 		}

 	    }

 	}

       else

 	error ("invalid value for color property \"%s\"",

            get_name ().c_str ());

     }

   else 

     error ("invalid value for color property \"%s\"",

            get_name ().c_str ());

   return false;

 }

 bool

 double_radio_property::do_set (const octave_value& val)

 {

   if (val.is_string ())

     {

       std::string s = val.string_value ();

       if (! s.empty () && radio_val.contains (s))

 	{

 	  if (current_type != radio_t || s != current_val)

 	    {

 	      current_val = s;

 	      current_type = radio_t;

 	      return true;

 	    }

 	}

       else

 	error ("invalid value for double_radio property \"%s\"",

 	       get_name ().c_str ());

     }

   else if (val.is_scalar_type () && val.is_real_type ())

     {

       double new_dval = val.double_value ();

       if (current_type != double_t || new_dval != dval)

 	{

 	  dval = new_dval;

 	  current_type = double_t;

 	  return true;

 	}

     }

   else 

     error ("invalid value for double_radio property \"%s\"",

 	   get_name ().c_str ());

   return false;

 }

 bool

 array_property::validate (const octave_value& v)

 {

   bool xok = false;

   // FIXME -- should we always support []?

   if (v.is_empty () && v.is_numeric_type ())

     return true;

   // check value type

   if (type_constraints.size () > 0)

     {

       for (std::list<std::string>::const_iterator it = type_constraints.begin ();

            ! xok && it != type_constraints.end (); ++it)

         if ((*it) == v.class_name ())

           xok = true;

     }

   else

     xok = v.is_numeric_type ();

   if (xok)

     {

       dim_vector vdims = v.dims ();

       int vlen = vdims.length ();

       xok = false;

       // check value size

       if (size_constraints.size () > 0)

         for (std::list<dim_vector>::const_iterator it = size_constraints.begin ();

              ! xok && it != size_constraints.end (); ++it)

           {

             dim_vector itdims = (*it);

             if (itdims.length () == vlen)

               {

                 xok = true;

                 for (int i = 0; xok && i < vlen; i++)

                   if (itdims(i) >= 0 && itdims(i) != vdims(i))

                     xok = false;

               }

           }

       else

         return true;

     }

   return xok;

 }

 bool

 array_property::is_equal (const octave_value& v) const

 {

   if (data.type_name () == v.type_name ())

     {

       if (data.dims () == v.dims ())

 	{

 #define CHECK_ARRAY_EQUAL(T,F,A) \

 	    { \

 	      if (data.numel () == 1) \

 		return data.F ## scalar_value () == \

 		  v.F ## scalar_value (); \

 	      else  \

 		{ \

                   /* Keep copy of array_value to allow sparse/bool arrays */ \

 		  /* that are converted, to not be deallocated early */ \

 		  const A m1 = data.F ## array_value (); \

 		  const T* d1 = m1.data (); \

 		  const A m2 = v.F ## array_value (); \

 		  const T* d2 = m2.data ();\

 		  \

 		  bool flag = true; \

 		  \

 		  for (int i = 0; flag && i < data.numel (); i++) \

 		    if (d1[i] != d2[i]) \

 		      flag = false; \

 		  \

 		  return flag; \

 		} \

 	    }

 	  if (data.is_double_type() || data.is_bool_type ())

 	    CHECK_ARRAY_EQUAL (double, , NDArray)

 	  else if (data.is_single_type ())

 	    CHECK_ARRAY_EQUAL (float, float_, FloatNDArray)

 	  else if (data.is_int8_type ())

 	    CHECK_ARRAY_EQUAL (octave_int8, int8_, int8NDArray)

 	  else if (data.is_int16_type ())

 	    CHECK_ARRAY_EQUAL (octave_int16, int16_, int16NDArray)

 	  else if (data.is_int32_type ())

 	    CHECK_ARRAY_EQUAL (octave_int32, int32_, int32NDArray)

 	  else if (data.is_int64_type ())

 	    CHECK_ARRAY_EQUAL (octave_int64, int64_, int64NDArray)

 	  else if (data.is_uint8_type ())

 	    CHECK_ARRAY_EQUAL (octave_uint8, uint8_, uint8NDArray)

 	  else if (data.is_uint16_type ())

 	    CHECK_ARRAY_EQUAL (octave_uint16, uint16_, uint16NDArray)

 	  else if (data.is_uint32_type ())

 	    CHECK_ARRAY_EQUAL (octave_uint32, uint32_, uint32NDArray)

 	  else if (data.is_uint64_type ())

 	    CHECK_ARRAY_EQUAL (octave_uint64, uint64_, uint64NDArray)

 	}

     }

   return false;

 }

 void

 array_property::get_data_limits (void)

 {

   xmin = xminp = octave_Inf;

   xmax = -octave_Inf;

   if (! data.is_empty ())

     {

       if (data.is_integer_type ())

 	{

 	  if (data.is_int8_type ())

 	    get_array_limits (data.int8_array_value (), xmin, xmax, xminp);

 	  else if (data.is_uint8_type ())

 	    get_array_limits (data.uint8_array_value (), xmin, xmax, xminp);

 	  else if (data.is_int16_type ())

 	    get_array_limits (data.int16_array_value (), xmin, xmax, xminp);

 	  else if (data.is_uint16_type ())

 	    get_array_limits (data.uint16_array_value (), xmin, xmax, xminp);

 	  else if (data.is_int32_type ())

 	    get_array_limits (data.int32_array_value (), xmin, xmax, xminp);

 	  else if (data.is_uint32_type ())

 	    get_array_limits (data.uint32_array_value (), xmin, xmax, xminp);

 	  else if (data.is_int64_type ())

 	    get_array_limits (data.int64_array_value (), xmin, xmax, xminp);

 	  else if (data.is_uint64_type ())

 	    get_array_limits (data.uint64_array_value (), xmin, xmax, xminp);

 	}

       else

 	get_array_limits (data.array_value (), xmin, xmax, xminp);

     }

 }

 bool

 handle_property::do_set (const octave_value& v)

 {

   double dv = v.double_value ();

   if (! error_state)

     {

       graphics_handle gh = gh_manager::lookup (dv);

       if (xisnan (gh.value ()) || gh.ok ())

 	{

 	  if (current_val != gh)

 	    {

 	      current_val = gh;

 	      return true;

 	    }

 	}

       else

         error ("set: invalid graphics handle (= %g) for property \"%s\"",

 	       dv, get_name ().c_str ());

     }

   else

     error ("set: invalid graphics handle for property \"%s\"",

 	   get_name ().c_str ());

   return false;

 }

 bool

 callback_property::validate (const octave_value& v) const

 {

   // case 1: function handle

   // case 2: cell array with first element being a function handle

   // case 3: string corresponding to known function name

   // case 4: evaluatable string

   // case 5: empty matrix

   if (v.is_function_handle ())

     return true;

   else if (v.is_string ())

     // complete validation will be done at execution-time

     return true;

   else if (v.is_cell () && v.length () > 0

            && (v.rows() == 1 || v.columns () == 1)

            && v.cell_value ()(0).is_function_handle ())

     return true;

   else if (v.is_empty ())

     return true;

   return false;

 }

 void

 callback_property::execute (const octave_value& data) const

 {

   if (callback.is_defined () && ! callback.is_empty ())

     gh_manager::execute_callback (get_parent (), callback, data);

 }

 // Used to cache dummy graphics objects from which dynamic

 // properties can be cloned.

 static std::map<caseless_str, graphics_object> dprop_obj_map;

 property

 property::create (const std::string& name, const graphics_handle& h,

 		  const caseless_str& type, const octave_value_list& args)

 {

   property retval;

   if (type.compare ("string"))

     {

       std::string val = (args.length () > 0 ? args(0).string_value () : "");

       if (! error_state)

 	retval = property (new string_property (name, h, val));

     }

   else if (type.compare ("any"))

     {

       octave_value val =

 	  (args.length () > 0 ? args(0) : octave_value (Matrix ()));

       retval = property (new any_property (name, h, val));

     }

   else if (type.compare ("radio"))

     {

       if (args.length () > 0)

 	{

 	  std::string vals = args(0).string_value ();

 	  if (! error_state)

 	    {

 	      retval = property (new radio_property (name, h, vals));

 	      if (args.length () > 1)

 		retval.set (args(1));

 	    }

 	  else

 	    error ("addproperty: invalid argument for radio property, expected a string value");

 	}

       else

 	error ("addproperty: missing possible values for radio property");

     }

   else if (type.compare ("double"))

     {

       double d = (args.length () > 0 ? args(0).double_value () : 0);

       if (! error_state)

 	retval = property (new double_property (name, h, d));

     }

   else if (type.compare ("handle"))

     {

       double hh = (args.length () > 0 ? args(0).double_value () : octave_NaN);

       if (! error_state)

 	{

 	  graphics_handle gh (hh);

 	  retval = property (new handle_property (name, h, gh));

 	}

     }

   else if (type.compare ("boolean"))

     {

       retval = property (new bool_property (name, h, false));

       if (args.length () > 0)

 	retval.set (args(0));

     }

   else if (type.compare ("data"))

     {

       retval = property (new array_property (name, h, Matrix ()));

       if (args.length () > 0)

 	{

 	  retval.set (args(0));

 	  // FIXME -- additional argument could define constraints,

 	  // but is this really useful?

 	}

     }

   else if (type.compare ("color"))

     {

       color_values cv (0, 0, 0);

       radio_values rv;

       if (args.length () > 1)

 	rv = radio_values (args(1).string_value ());

       if (! error_state)

 	{

 	  retval = property (new color_property (name, h, cv, rv));

 	  if (! error_state)

 	    {

 	      if (args.length () > 0 && ! args(0).is_empty ())

 		retval.set (args(0));

 	      else

 		retval.set (rv.default_value ());

 	    }

 	}

     }

   else

     {

       caseless_str go_name, go_rest;

       if (lookup_object_name (type, go_name, go_rest))

 	{

 	  graphics_object go;

 	  std::map<caseless_str, graphics_object>::const_iterator it =

 	      dprop_obj_map.find (go_name);

 	  if (it == dprop_obj_map.end ())

 	    {

 	      base_graphics_object *bgo =

 		  make_graphics_object_from_type (go_name);

 	      if (bgo)

 		{

 		  go = graphics_object (bgo);

 		  dprop_obj_map[go_name] = go;

 		}

 	    }

 	  else

 	    go = it->second;

 	  if (go.valid_object ())

 	    {

 	      property prop = go.get_properties ().get_property (go_rest);

 	      if (! error_state)

 		{

 		  retval = prop.clone ();

 		  retval.set_parent (h);

 		  retval.set_name (name);

 		  if (args.length () > 0)

 		    retval.set (args(0));

 		}

 	    }

 	  else

 	    error ("addproperty: invalid object type (= %s)",

 		   go_name.c_str ());

 	}

       else

 	error ("addproperty: unsupported type for dynamic property (= %s)",

 	       type.c_str ());

     }

   return retval;

 }

 // ---------------------------------------------------------------------

 void

 property_list::set (const caseless_str& name, const octave_value& val)

 {

   size_t offset = 0;

   size_t len = name.length ();

   if (len > 4)

     {

       caseless_str pfx = name.substr (0, 4);

       if (pfx.compare ("axes") || pfx.compare ("line")

 	  || pfx.compare ("text"))

 	offset = 4;

       else if (len > 5)

 	{

 	  pfx = name.substr (0, 5);

 	  if (pfx.compare ("image") || pfx.compare ("patch"))

 	    offset = 5;

 	  else if (len > 6)

 	    {

 	      pfx = name.substr (0, 6);

 	      if (pfx.compare ("figure"))

 		offset = 6;

 	      else if (len > 7)

 		{

 		  pfx = name.substr (0, 7);

 		  if (pfx.compare ("surface") || pfx.compare ("hggroup"))

 		    offset = 7;

 		}

 	    }

 	}

       if (offset > 0)

 	{

 	  // FIXME -- should we validate property names and values here?

 	  std::string pname = name.substr (offset);

 	  std::transform (pfx.begin (), pfx.end (), pfx.begin (), tolower);

 	  std::transform (pname.begin (), pname.end (), pname.begin (), tolower);

 	  bool has_property = false;

 	  if (pfx == "axes")

 	    has_property = axes::properties::has_property (pname);

 	  else if (pfx == "line")

 	    has_property = line::properties::has_property (pname);

 	  else if (pfx == "text")

 	    has_property = text::properties::has_property (pname);

 	  else if (pfx == "image")

 	    has_property = image::properties::has_property (pname);

 	  else if (pfx == "patch")

 	    has_property = patch::properties::has_property (pname);

 	  else if (pfx == "figure")

 	    has_property = figure::properties::has_property (pname);

 	  else if (pfx == "surface")

 	    has_property = surface::properties::has_property (pname);

 	  else if (pfx == "hggroup")

 	    has_property = hggroup::properties::has_property (pname);

 	  if (has_property)

 	    {

 	      bool remove = false;

 	      if (val.is_string ())

 		{

 		  caseless_str tval = val.string_value ();

 		  remove = tval.compare ("remove");

 		}

 	      pval_map_type& pval_map = plist_map[pfx];

 	      if (remove)

 		{

 		  pval_map_iterator p = pval_map.find (pname);

 		  if (p != pval_map.end ())

 		    pval_map.erase (p);

 		}

 	      else

 		pval_map[pname] = val;

 	    }

 	  else

 	    error ("invalid %s property `%s'", pfx.c_str (), pname.c_str ());

 	}

     }

   if (! error_state && offset == 0)

     error ("invalid default property specification");

 }

 octave_value

 property_list::lookup (const caseless_str& name) const

 {

   octave_value retval;

   size_t offset = 0;

   size_t len = name.length ();

   if (len > 4)

     {

       caseless_str pfx = name.substr (0, 4);

       if (pfx.compare ("axes") || pfx.compare ("line")

 	  || pfx.compare ("text"))

 	offset = 4;

       else if (len > 5)

 	{

 	  pfx = name.substr (0, 5);

 	  if (pfx.compare ("image") || pfx.compare ("patch"))

 	    offset = 5;

 	  else if (len > 6)

 	    {

 	      pfx = name.substr (0, 6);

 	      if (pfx.compare ("figure"))

 		offset = 6;

 	      else if (len > 7)

 		{

 		  pfx = name.substr (0, 7);

 		  if (pfx.compare ("surface") || pfx.compare ("hggroup"))

 		    offset = 7;

 		}

 	    }

 	}

       if (offset > 0)

 	{

 	  std::string pname = name.substr (offset);

 	  std::transform (pfx.begin (), pfx.end (), pfx.begin (), tolower);

 	  std::transform (pname.begin (), pname.end (), pname.begin (), tolower);

 	  plist_map_const_iterator p = find (pfx);

 	  if (p != end ())

 	    {

 	      const pval_map_type& pval_map = p->second;

 	      pval_map_const_iterator q = pval_map.find (pname);

 	      if (q != pval_map.end ())

 		retval = q->second;

 	    }

 	}

     }

   return retval;

 }

 Octave_map

 property_list::as_struct (const std::string& prefix_arg) const

 {

   Octave_map m;

   for (plist_map_const_iterator p = begin (); p != end (); p++)

     {

       std::string prefix = prefix_arg + p->first;

       const pval_map_type pval_map = p->second;

       for (pval_map_const_iterator q = pval_map.begin ();

 	   q != pval_map.end ();

 	   q++)

 	m.assign (prefix + q->first, q->second);

     }

   return m;    

 }

 graphics_handle::graphics_handle (const octave_value& a)

   : val (octave_NaN)

 {

   if (a.is_empty ())

     /* do nothing */;

   else

     {

       double tval = a.double_value ();

       if (! error_state)

 	val = tval;

       else

 	error ("invalid graphics handle");

     }

 }

 void

 graphics_object::set (const octave_value_list& args)

 {

   int nargin = args.length ();

   if (nargin == 0)

     rep->defaults ();

   else if (nargin % 2 == 0)

     {

       for (int i = 0; i < nargin; i += 2)

 	{

 	  caseless_str name = args(i).string_value ();

 	  if (! error_state)

 	    {

 	      octave_value val = args(i+1);

 	      if (val.is_string ())

 		{

 		  caseless_str tval = val.string_value ();

 		  if (tval.compare ("default"))

 		    val = get_default (name);

 		  else if (tval.compare ("factory"))

 		    val = get_factory_default (name);

 		}

 	      if (error_state)

 		break;

 	      rep->set (name, val);

 	    }

 	  else

 	    error ("set: expecting argument %d to be a property name", i);

 	}

     }

   else

     error ("set: invalid number of arguments");

 }

 static double

 make_handle_fraction (void)

 {

   static double maxrand = RAND_MAX + 2.0;

   return (rand () + 1.0) / maxrand;

 }

 graphics_handle

 gh_manager::get_handle (const std::string& go_name)

 {

   graphics_handle retval;

   if (go_name == "figure")

     {

       // Figure handles are positive integers corresponding to the

       // figure number.

       // We always want the lowest unused figure number.

       retval = 1;

       while (handle_map.find (retval) != handle_map.end ())

 	retval++;

     }

   else

     {

       // Other graphics handles are negative integers plus some random

       // fractional part.  To avoid running out of integers, we

       // recycle the integer part but tack on a new random part each

       // time.

       free_list_iterator p = handle_free_list.begin ();

       if (p != handle_free_list.end ())

 	{

 	  retval = *p;

 	  handle_free_list.erase (p);

 	}

       else

 	{

 	  retval = graphics_handle (next_handle);

 	  next_handle = ceil (next_handle) - 1.0 - make_handle_fraction ();

 	}

     }

   return retval;

 }

 void

 gh_manager::do_free (const graphics_handle& h)

 {

   if (h.ok ())

     {

       if (h.value () != 0)

 	{

 	  iterator p = handle_map.find (h);

 	  if (p != handle_map.end ())

 	    {

 	      base_properties& bp = p->second.get_properties ();

 	      bp.set_beingdeleted (true);

 	      bp.delete_children ();

 	      octave_value val = bp.get_deletefcn ();

 	      bp.execute_deletefcn ();

 	      // notify backend

 	      graphics_backend backend = p->second.get_backend ();

 	      if (backend)

                 backend.object_destroyed (p->second);

 	      // Note: this will be valid only for first explicitly 

 	      // deleted object.  All its children will then have an

 	      // unknown backend.

 	      // Graphics handles for non-figure objects are negative

 	      // integers plus some random fractional part.  To avoid

 	      // running out of integers, we recycle the integer part

 	      // but tack on a new random part each time.

 	      handle_map.erase (p);

 	      if (h.value () < 0)

 		handle_free_list.insert (ceil (h.value ()) - make_handle_fraction ());

 	    }

 	  else

 	    error ("graphics_handle::free: invalid object %g", h.value ());

 	}

       else

 	error ("graphics_handle::free: can't delete root figure");

     }

 }

 gh_manager *gh_manager::instance = 0;

 static void

 xset (const graphics_handle& h, const caseless_str& name,

       const octave_value& val)

 {

   graphics_object obj = gh_manager::get_object (h);

   obj.set (name, val);

 }

 static void

 xset (const graphics_handle& h, const octave_value_list& args)

 {

   if (args.length () > 0)

     {

       graphics_object obj = gh_manager::get_object (h);

       obj.set (args);

     }

 }

 static octave_value

 xget (const graphics_handle& h, const caseless_str& name)

 {

   graphics_object obj = gh_manager::get_object (h);

   return obj.get (name);

 }

 static graphics_handle

 reparent (const octave_value& ov, const std::string& who,

 	  const std::string& property, const graphics_handle& new_parent,

 	  bool adopt = true)

 {

   graphics_handle h = octave_NaN;

   double val = ov.double_value ();

   if (! error_state)

     {

       h = gh_manager::lookup (val);

       if (h.ok ())

 	{

 	  graphics_object obj = gh_manager::get_object (h);

 	  graphics_handle parent_h = obj.get_parent ();

 	  graphics_object parent_obj = gh_manager::get_object (parent_h);

 	  parent_obj.remove_child (h);

 	  if (adopt)

 	    obj.set ("parent", new_parent.value ());

 	  else

 	    obj.reparent (new_parent);

 	}

       else

 	error ("%s: invalid graphics handle (= %g) for %s",

 	       who.c_str (), val, property.c_str ());

     }

   else

     error ("%s: expecting %s to be a graphics handle",

 	   who.c_str (), property.c_str ());

   return h;

 }

 // This function is NOT equivalent to the scripting language function gcf.

 graphics_handle

 gcf (void)

 {

   octave_value val = xget (0, "currentfigure");

   return val.is_empty () ? octave_NaN : val.double_value ();

 }

 // This function is NOT equivalent to the scripting language function gca.

 graphics_handle

 gca (void)

 {

   octave_value val = xget (gcf (), "currentaxes");

   return val.is_empty () ? octave_NaN : val.double_value ();

 }

 static void

 adopt (const graphics_handle& p, const graphics_handle& h)

 {

   graphics_object parent_obj = gh_manager::get_object (p);

   parent_obj.adopt (h);

 }

 static bool

 is_handle (const graphics_handle& h)

 {

   return h.ok ();

 }

 static bool

 is_handle (double val)

 {

   graphics_handle h = gh_manager::lookup (val);

   return h.ok ();

 }

 static octave_value

 is_handle (const octave_value& val)

 {

   octave_value retval = false;

   if (val.is_real_scalar () && is_handle (val.double_value ()))

     retval = true;

   else if (val.is_real_matrix ())

     {

       if (val.is_string ())

 	retval = boolNDArray (val.dims (), false);

       else

 	{

 	  const NDArray handles = val.array_value ();

 	  if (! error_state)

 	    {

 	      boolNDArray result (handles.dims ());

 	      for (octave_idx_type i = 0; i < handles.numel (); i++)

 		result.xelem (i) = is_handle (handles (i));

 	      retval = result;

 	    }

 	}

     }

   return retval;

 }

 static bool

 is_figure (double val)

 {

   graphics_object obj = gh_manager::get_object (val);

   return obj && obj.isa ("figure");

 }

 static void

 xcreatefcn (const graphics_handle& h)

 {

   graphics_object obj = gh_manager::get_object (h);

   obj.get_properties ().execute_createfcn  ();

 }

 // ---------------------------------------------------------------------

 void

 base_graphics_backend::property_changed (const graphics_handle& h, int id)

 {

   graphics_object go = gh_manager::get_object (h);

   property_changed (go, id);

 }

 void

 base_graphics_backend::object_created (const graphics_handle& h)

 {

   graphics_object go = gh_manager::get_object (h);

   object_created (go);

 }

 void

 base_graphics_backend::object_destroyed (const graphics_handle& h)

 {

   graphics_object go = gh_manager::get_object (h);

   object_destroyed (go);

 }

 // ---------------------------------------------------------------------

 static Matrix

 maybe_set_children (const Matrix& kids, const octave_value& val)

 {

   const Matrix new_kids = val.matrix_value ();

   bool ok = true;

   if (! error_state)

     {

       if (kids.numel () == new_kids.numel ())

 	{

 	  Matrix t1 = kids;

 	  Matrix t2 = new_kids;

 	  t1.sort ();

 	  t2.sort ();

 	  if (t1 != t2)

 	    ok = false;

 	}

       else

 	ok = false;

       if (! ok)

 	error ("set: new children must be a permutation of existing children");

     }

   else

     {

       ok = false;

       error ("set: expecting children to be array of graphics handles");

     }

   return ok ? new_kids : kids;

 }

 void

 base_properties::set_from_list (base_graphics_object& obj,

 				property_list& defaults)

 {

   std::string go_name = graphics_object_name ();

   property_list::plist_map_const_iterator p = defaults.find (go_name);

   if (p != defaults.end ())

     {

       const property_list::pval_map_type pval_map = p->second;

       for (property_list::pval_map_const_iterator q = pval_map.begin ();

 	   q != pval_map.end ();

 	   q++)

 	{

 	  std::string pname = q->first;

 	  obj.set (pname, q->second);

 	  if (error_state)

 	    {

 	      error ("error setting default property %s", pname.c_str ());

 	      break;

 	    }

 	}

     }

 }

 octave_value

 base_properties::get_dynamic (const caseless_str& name) const

 {

   octave_value retval;

   std::map<caseless_str, property, cmp_caseless_str>::const_iterator it = all_props.find (name);

   if (it != all_props.end ())

     retval = it->second.get ();

   else

     error ("get: unknown property \"%s\"", name.c_str ());

   return retval;

 }

 octave_value

 base_properties::get_dynamic (bool all) const

 {

   Octave_map m;

   for (std::map<caseless_str, property, cmp_caseless_str>::const_iterator it = all_props.begin ();

        it != all_props.end (); ++it)

     if (all || ! it->second.is_hidden ())

       m.assign (it->second.get_name (), it->second.get ());

   return m;

 }

 std::map<std::string, std::set<std::string> > base_properties::all_dynamic_properties;

 bool

 base_properties::has_dynamic_property (const std::string& pname,

 				       const std::string& cname)

 {

   // FIXME -- we need to maintain a static map of class names to sets

   // of dynamic property names, then look up the set for the given

   // cname, then see if the set contains the given pname.  Doing that

   // implies changes to set_dynamic, I think.  Where is set_dynamic

   // ever used?

   std::set<std::string>& dynprops = all_dynamic_properties[cname];

   return dynprops.find (pname) != dynprops.end ();

 }

 void

 base_properties::set_dynamic (const caseless_str& pname,

 			      const std::string& cname,

 			      const octave_value& val)

 {

   std::map<caseless_str, property, cmp_caseless_str>::iterator it = all_props.find (pname);

   if (it != all_props.end ())

     it->second.set (val);

   else

     error ("set: unknown property \"%s\"", pname.c_str ());

   if (! error_state)

     {

       all_dynamic_properties[cname].insert (pname);

       mark_modified ();

     }

 }

 property

 base_properties::get_property_dynamic (const caseless_str& name)

 {

   std::map<caseless_str, property, cmp_caseless_str>::const_iterator it = all_props.find (name);

   if (it == all_props.end ())

     {

       error ("get_property: unknown property \"%s\"", name.c_str ());

       return property ();

     }

   else

     return it->second;

 }

 bool

 base_properties::has_property (const caseless_str& name)

 {

   property p;

   unwind_protect::begin_frame("base_properties::has_property");

   unwind_protect_bool (discard_error_messages);

   unwind_protect_int (error_state);

   discard_error_messages = true;

   p = get_property (name);

   unwind_protect::run_frame ("base_properties::has_property");

   return (p.ok ());

 }

 void

 base_properties::remove_child (const graphics_handle& h)

 {

   octave_idx_type k = -1;

   octave_idx_type n = children.numel ();

   for (octave_idx_type i = 0; i < n; i++)

     {

       if (h.value () == children(i))

 	{

 	  k = i;

 	  break;

 	}

     }

   if (k >= 0)

     {

       Matrix new_kids (n-1, 1);

       octave_idx_type j = 0;

       for (octave_idx_type i = 0; i < n; i++)

 	{

 	  if (i != k)

 	    new_kids(j++) = children(i);

 	}

       children = new_kids;

       mark_modified ();

     }

 }

 void

 base_properties::set_parent (const octave_value& val)

 {

   double tmp = val.double_value ();

   graphics_handle new_parent = octave_NaN;

   if (! error_state)

     {

       new_parent = gh_manager::lookup (tmp);

       if (new_parent.ok ())

 	{

 	  graphics_object parent_obj = gh_manager::get_object (get_parent ());

 	  parent_obj.remove_child (__myhandle__);

 	  parent = new_parent.as_octave_value ();

 	  ::adopt (parent.handle_value (), __myhandle__);

 	}

       else

 	error ("set: invalid graphics handle (= %g) for parent", tmp);

     }

   else

     error ("set: expecting parent to be a graphics handle");

 }

 void

 base_properties::set_children (const octave_value& val)

 {

   children = maybe_set_children (children, val);

 }

 void

 base_properties::mark_modified (void)

 {

   __modified__ = "on";

   graphics_object parent_obj = gh_manager::get_object (get_parent ());

   if (parent_obj)

     parent_obj.mark_modified ();

 }

 void

 base_properties::override_defaults (base_graphics_object& obj)

 {

   graphics_object parent_obj = gh_manager::get_object (get_parent ());

   if (parent_obj)

     parent_obj.override_defaults (obj);

 }

 void

 base_properties::update_axis_limits (const std::string& axis_type) const

 {

   graphics_object obj = gh_manager::get_object (__myhandle__);

   if (obj)

     obj.update_axis_limits (axis_type);

 }

 void

 base_properties::delete_children (void)

 {

   octave_idx_type n = children.numel ();

   // A callback function might have already deleted the child,

   // so check before deleting

   for (octave_idx_type i = 0; i < n; i++)

     {

       graphics_object go = gh_manager::get_object (children(i));

       if (go.valid_object ())

 	gh_manager::free (children(i));

     }

 }

 graphics_backend

 base_properties::get_backend (void) const

 {

   graphics_object go = gh_manager::get_object (get_parent ());

   if (go)

     return go.get_backend ();

   else

     return graphics_backend ();

 }

 void

 base_properties::update_boundingbox (void)

 {

   Matrix kids = get_children ();

   for (int i = 0; i < kids.numel (); i++)

     {

       graphics_object go = gh_manager::get_object (kids(i));

       if (go.valid_object ())

 	go.get_properties ().update_boundingbox ();

     }

 }

 void

 base_properties::add_listener (const caseless_str& nm, const octave_value& v,

 			       listener_mode mode)

 {

   property p = get_property (nm);

   if (! error_state && p.ok ())

     p.add_listener (v, mode);

 }

 void

 base_properties::delete_listener (const caseless_str& nm, 

 				  const octave_value& v, listener_mode mode)

 {

   property p = get_property (nm);

   if (! error_state && p.ok ())

     p.delete_listener (v, mode);

 }

 // ---------------------------------------------------------------------

 class gnuplot_backend : public base_graphics_backend

 {

 public:

   gnuplot_backend (void)

       : base_graphics_backend ("gnuplot") { }

   ~gnuplot_backend (void) { }

   bool is_valid (void) const { return true; }

   void object_destroyed (const graphics_object& go)

     {

       if (go.isa ("figure"))

 	{

 	  const figure::properties& props =

 	      dynamic_cast<const figure::properties&> (go.get_properties ());

 	  send_quit (props.get___plot_stream__ ());

 	}

     }

   void property_changed (const graphics_object& go, int id)

     {

       if (go.isa ("figure"))

 	{

 	  graphics_object obj (go);

 	  figure::properties& props =

 	      dynamic_cast<figure::properties&> (obj.get_properties ());

 	  switch (id)

 	    {

 	    case base_properties::VISIBLE:

 	      if (! props.is_visible ())

 		{

 		  send_quit (props.get___plot_stream__ ());

 		  props.set___plot_stream__ (Matrix ());

 		  props.set___enhanced__ (false);

 		}

 	      break;

 	    }

 	}

     }

   void redraw_figure (const graphics_object& go) const

     {

       octave_value_list args;

       args(0) = go.get_handle ().as_octave_value ();

       feval ("gnuplot_drawnow", args);

     }

   void print_figure (const graphics_object& go, const std::string& term,

 		     const std::string& file, bool mono,

 		     const std::string& debug_file) const

     {

       octave_value_list args;

       if (! debug_file.empty ())

 	args(4) = debug_file;

       args(3) = mono;

       args(2) = file;

       args(1) = term;

       args(0) = go.get_handle ().as_octave_value ();

       feval ("gnuplot_drawnow", args);

     }

   Matrix get_canvas_size (const graphics_handle&) const

     {

       Matrix sz (1, 2, 0.0);

       return sz;

     }

   double get_screen_resolution (void) const

     { return 72.0; }

   Matrix get_screen_size (void) const

     { return Matrix (1, 2, 0.0); }

 private:

   void send_quit (const octave_value& pstream) const

     {

       if (! pstream.is_empty())

 	{

 	  octave_value_list args;

 	  Matrix fids = pstream.matrix_value ();

 	  if (! error_state)

 	    {

 	      args(1) = "\nquit;\n";

 	      args(0) = octave_value (fids (0));

 	      feval ("fputs", args);

 	      args.resize (1);

 	      feval ("fflush", args);

 	      feval ("pclose", args);

 	      if (fids.numel () > 1)

 		{

 		  args(0) = octave_value (fids (1));

 		  feval ("pclose", args);

 		}

 	    }

 	}

     }

 };

 graphics_backend

 graphics_backend::default_backend (void)

 {

   if (available_backends.size () == 0)

     register_backend (new gnuplot_backend ());

   return available_backends["gnuplot"];

 }

 std::map<std::string, graphics_backend> graphics_backend::available_backends;

 // ---------------------------------------------------------------------

 void

 base_graphics_object::update_axis_limits (const std::string& axis_type)

 {

   if (valid_object ())

     {

       graphics_object parent_obj = gh_manager::get_object (get_parent ());

       if (parent_obj)

 	parent_obj.update_axis_limits (axis_type);

     }

   else

     error ("base_graphics_object::update_axis_limits: invalid graphics object");

 }

 void

 base_graphics_object::remove_all_listeners (void)

 {

   Octave_map m = get (true).map_value ();

   for (Octave_map::const_iterator pa = m.begin (); pa != m.end (); pa++)

     {

       if (get_properties().has_property (pa->first))

 	{

 	  property p = get_properties ().get_property (pa->first);

 	  if (! error_state && p.ok ())

 	    p.delete_listener ();

 	}

     }

 }

 // ---------------------------------------------------------------------

 #include "graphics-props.cc"

 // ---------------------------------------------------------------------

 void

 root_figure::properties::set_currentfigure (const octave_value& v)

 {

   graphics_handle val (v);

   if (error_state)

     return;

   if (xisnan (val.value ()) || is_handle (val))

     {

       currentfigure = val;

       gh_manager::push_figure (val);

     }

   else

     gripe_set_invalid ("currentfigure");

 }

 void

 root_figure::properties::set_callbackobject (const octave_value& v)

 {

   graphics_handle val (v);

   if (error_state)

     return;

   if (xisnan (val.value ()))

     {

       if (! cbo_stack.empty ())

 	{

 	  val = cbo_stack.front ();

 	  cbo_stack.pop_front ();

 	}

       callbackobject = val;

     }

   else if (is_handle (val))

     {

       if (get_callbackobject ().ok ())

 	cbo_stack.push_front (get_callbackobject ());

       callbackobject = val;

     }

   else

     gripe_set_invalid ("callbackobject");

 }

 void

 root_figure::properties::update_units (void)

 {

   caseless_str xunits = get_units ();

   Matrix ss = default_screensize ();

   double dpi = get_screenpixelsperinch ();

   if (xunits.compare ("inches"))

     {

       ss(0) = 0;

       ss(1) = 0;

       ss(2) /= dpi;

       ss(3) /= dpi;

     }

   else if (xunits.compare ("centimeters"))

     {

       ss(0) = 0;

       ss(1) = 0;

       ss(2) *= 2.54 / dpi;

       ss(3) *= 2.54 / dpi;

     }

   else if (xunits.compare ("normalized"))

     {

       ss = Matrix (1, 4, 1.0);

     }

   else if (xunits.compare ("points"))

     {

       ss(0) = 0;

       ss(1) = 0;

       ss(2) *= 72 / dpi;

       ss(3) *= 72 / dpi;

     }

   set_screensize (ss);

 }

 void

 root_figure::properties::remove_child (const graphics_handle& gh)

 {

   gh_manager::pop_figure (gh);

   graphics_handle cf = gh_manager::current_figure ();

   xset (0, "currentfigure", cf.value ());

   base_properties::remove_child (gh);

 }

 property_list

 root_figure::factory_properties = root_figure::init_factory_properties ();

 // ---------------------------------------------------------------------

 void

 figure::properties::set_currentaxes (const octave_value& v)

 {

   graphics_handle val (v);

   if (error_state)

     return;

   if (xisnan (val.value ()) || is_handle (val))

     currentaxes = val;

   else

     gripe_set_invalid ("currentaxes");

 }

 void

 figure::properties::remove_child (const graphics_handle& gh)

 {

   base_properties::remove_child (gh);

   if (gh == currentaxes.handle_value ())

     {

       graphics_handle new_currentaxes;

       for (octave_idx_type i = 0; i < children.numel (); i++)

 	{

 	  graphics_handle kid = children(i);

 	  graphics_object go = gh_manager::get_object (kid);

 	  if (go.isa ("axes"))

 	    {

 	      new_currentaxes = kid;

 	      break;

 	    }

 	}

       currentaxes = new_currentaxes;

     }

 }

 void

 figure::properties::set_visible (const octave_value& val)

 {

   std::string s = val.string_value ();

   if (! error_state)

     {

       if (s == "on")

 	xset (0, "currentfigure", __myhandle__.value ());

       visible = val;

     }

 }

 Matrix

 figure::properties::get_boundingbox (bool) const

 {

   Matrix screen_size = xget (0, "screensize").matrix_value ().extract_n (0, 2, 1, 2);

   Matrix pos;

   pos = convert_position (get_position ().matrix_value (), get_units (),

 			  "pixels", screen_size);

   pos(0)--;

   pos(1)--;

   pos(1) = screen_size(1) - pos(1) - pos(3);

   return pos;

 }

 void

 figure::properties::set_boundingbox (const Matrix& bb)

 {

   Matrix screen_size = xget (0, "screensize").matrix_value ().extract_n (0, 2, 1, 2);

   Matrix pos = bb;

   pos(1) = screen_size(1) - pos(1) - pos(3);

   pos(1)++;

   pos(0)++;

   pos = convert_position (pos, "pixels", get_units (), screen_size);

   set_position (pos);

 }

 void

 figure::properties::set_position (const octave_value& v)

 {

   if (! error_state)

     {

       Matrix old_bb, new_bb;

       old_bb = get_boundingbox ();

       position = v;

       new_bb = get_boundingbox ();

       if (old_bb != new_bb)

 	{

 	  if (old_bb(2) != new_bb(2) || old_bb(3) != new_bb(3))

 	    {

 	      execute_resizefcn ();

 	      update_boundingbox ();

 	    }

 	}

       mark_modified ();

     }

 }

 std::string

 figure::properties::get_title (void) const

 {

   if (is_numbertitle ())

     {

       std::ostringstream os;

       std::string nm = get_name ();

       os << "Figure " << __myhandle__.value ();

       if (! nm.empty ())

 	os << ": " << get_name ();

       return os.str ();

     }

   else

     return get_name ();

 }

 octave_value

 figure::get_default (const caseless_str& name) const

 {

   octave_value retval = default_properties.lookup (name);

   if (retval.is_undefined ())

     {

       graphics_handle parent = get_parent ();

       graphics_object parent_obj = gh_manager::get_object (parent);

       retval = parent_obj.get_default (name);

     }

   return retval;

 }

 // ---------------------------------------------------------------------

 void

 axes::properties::init (void)

 {

   position.add_constraint (dim_vector (1, 4));

   position.add_constraint (dim_vector (0, 0));

   outerposition.add_constraint (dim_vector (1, 4));

   colororder.add_constraint (dim_vector (-1, 3));

   dataaspectratio.add_constraint (dim_vector (1, 3));

   plotboxaspectratio.add_constraint (dim_vector (1, 3));

   xlim.add_constraint (2);

   ylim.add_constraint (2);

   zlim.add_constraint (2);

   clim.add_constraint (2);

   alim.add_constraint (2);

   xtick.add_constraint (dim_vector (1, -1));

   ytick.add_constraint (dim_vector (1, -1));

   ztick.add_constraint (dim_vector (1, -1));

   Matrix vw (1, 2, 0);

   vw(1) = 90;

   view = vw;

   view.add_constraint (dim_vector (1, 2));

   cameraposition.add_constraint (dim_vector (1, 3));

   Matrix upv (1, 3, 0.0);

   upv(2) = 1.0;

   cameraupvector = upv;

   cameraupvector.add_constraint (dim_vector (1, 3));

   currentpoint.add_constraint (dim_vector (2, 3));

   ticklength.add_constraint (dim_vector (1, 2));

   tightinset.add_constraint (dim_vector (1, 4));

   x_zlim.resize (1, 2);

   sx = "linear";

   sy = "linear";

   sz = "linear";

   xset (xlabel.handle_value (), "handlevisibility", "off");

   xset (ylabel.handle_value (), "handlevisibility", "off");

   xset (zlabel.handle_value (), "handlevisibility", "off");

   xset (title.handle_value (), "handlevisibility", "off");

   xset (xlabel.handle_value (), "horizontalalignment", "center");

   xset (ylabel.handle_value (), "horizontalalignment", "center");

   xset (zlabel.handle_value (), "horizontalalignment", "right");

   xset (title.handle_value (), "horizontalalignment", "center");

   xset (xlabel.handle_value (), "verticalalignment", "cap");

   xset (ylabel.handle_value (), "verticalalignment", "bottom");

   xset (title.handle_value (), "verticalalignment", "bottom");

   xset (ylabel.handle_value (), "rotation", 90.0);

   adopt (xlabel.handle_value ());

   adopt (ylabel.handle_value ());

   adopt (zlabel.handle_value ());

   adopt (title.handle_value ());

 }

 void 

 axes::properties::sync_positions (void)

 {

 #if 0

   // FIXME -- this should take font metrics into consideration,

   // and also the fact that the colorbox leaves the outerposition

   // alone but alters the position. For now just don't adjust the

   // positions relative to each other.

   if (activepositionproperty.is ("outerposition"))

     {

       Matrix outpos = outerposition.get ().matrix_value ();

       Matrix defpos = default_axes_position ();

       Matrix pos(outpos);

       pos(0) = outpos(0) + defpos(0) * outpos(2);

       pos(1) = outpos(1) + defpos(1) * outpos(3);

       pos(2) = outpos(2) * defpos(2);

       pos(3) = outpos(3) * defpos(3);

       position = pos;

     }

   else

     {

       Matrix pos = position.get ().matrix_value ();

       pos(0) -= pos(2)*0.05;

       pos(1) -= pos(3)*0.05;

       pos(2) *= 1.1;

       pos(3) *= 1.1;

       outerposition = pos;

     }

 #endif

   update_transform ();

 }

 void

 axes::properties::set_text_child (handle_property& hp,

 				  const std::string& who,

 				  const octave_value& v)

 {

   graphics_handle val = ::reparent (v, "set", who, __myhandle__, false);

   if (! error_state)

     {

       xset (val, "handlevisibility", "off");

       gh_manager::free (hp.handle_value ());

       base_properties::remove_child (hp.handle_value ());

       hp = val;

       adopt (hp.handle_value ());

     }

 }

 void

 axes::properties::set_xlabel (const octave_value& v)

 {

   set_text_child (xlabel, "xlabel", v);

 }

 void

 axes::properties::set_ylabel (const octave_value& v)

 {

   set_text_child (ylabel, "ylabel", v);

 }

 void

 axes::properties::set_zlabel (const octave_value& v)

 {

   set_text_child (zlabel, "zlabel", v);

 }

 void

 axes::properties::set_title (const octave_value& v)

 {

   set_text_child (title, "title", v);

 }

 void

 axes::properties::set_defaults (base_graphics_object& obj,

 				const std::string& mode)

 {

   box = "on";

   key = "off";

   keybox = "off";

   keyreverse = "off";

   keypos = 1.0;

   colororder = default_colororder ();

   dataaspectratio = Matrix (1, 3, 1.0);

   dataaspectratiomode = "auto";

   layer = "bottom";

   Matrix tlim (1, 2, 0.0);

   tlim(1) = 1;

   xlim = tlim;

   ylim = tlim;

   zlim = tlim;

   Matrix cl (1, 2, 0);

   cl(1) = 1;

   clim = cl;

   xlimmode = "auto";

   ylimmode = "auto";

   zlimmode = "auto";

   climmode = "auto";

   xgrid = "off";

   ygrid = "off";

   zgrid = "off";

   xminorgrid = "off";

   yminorgrid = "off";

   zminorgrid = "off";

   xtick = Matrix ();

   ytick = Matrix ();

   ztick = Matrix ();

   xtickmode = "auto";

   ytickmode = "auto";

   ztickmode = "auto";

   xticklabel = "";

   yticklabel = "";

   zticklabel = "";

   xticklabelmode = "auto";

   yticklabelmode = "auto";

   zticklabelmode = "auto";

   color = color_values (1, 1, 1);

   xcolor = color_values ("black");

   ycolor = color_values ("black");

   zcolor = color_values ("black");

   xscale = "linear";

   yscale = "linear";

   zscale = "linear";

   xdir = "normal";

   ydir = "normal";

   zdir = "normal";

   yaxislocation = "left";

   xaxislocation = "bottom";

   // Note: camera properties will be set through update_transform

   camerapositionmode = "auto";

   cameratargetmode = "auto";

   cameraupvectormode = "auto";

   cameraviewanglemode = "auto";

   plotboxaspectratio = Matrix (1, 3, 1.0);

   drawmode = "normal";

   gridlinestyle = ":";

   linestyleorder = "-";

   linewidth = 0.5;

   minorgridlinestyle = ":";

   // Note: plotboxaspectratio will be set through update_aspectratiors

   plotboxaspectratiomode = "auto";

   projection = "orthographic";

   tickdir = "in";

   tickdirmode = "auto";

   ticklength = default_axes_ticklength ();

   tightinset = Matrix (1, 4, 0.0);

   sx = "linear";

   sy = "linear";

   sz = "linear";

   Matrix tview (1, 2, 0.0);

   tview(1) = 90;

   view = tview;

   visible = "on";

   nextplot = "replace";

   if (mode != "replace")

     {

       fontangle = "normal";

       fontname = OCTAVE_DEFAULT_FONTNAME;

       fontsize = 12;

       fontunits = "points";

       fontweight = "normal";

       Matrix touterposition (1, 4, 0.0);

       touterposition(2) = 1;

       touterposition(3) = 1;

       outerposition = touterposition;

       position = default_axes_position ();

       activepositionproperty = "outerposition";

     }

   delete_children ();

   children = Matrix ();

   xlabel = gh_manager::make_graphics_handle ("text", __myhandle__, false);

   ylabel = gh_manager::make_graphics_handle ("text", __myhandle__, false);

   zlabel = gh_manager::make_graphics_handle ("text", __myhandle__, false);

   title = gh_manager::make_graphics_handle ("text", __myhandle__, false);

   xset (xlabel.handle_value (), "handlevisibility", "off");

   xset (ylabel.handle_value (), "handlevisibility", "off");

   xset (zlabel.handle_value (), "handlevisibility", "off");

   xset (title.handle_value (), "handlevisibility", "off");

   xset (xlabel.handle_value (), "horizontalalignment", "center");

   xset (ylabel.handle_value (), "horizontalalignment", "center");

   xset (zlabel.handle_value (), "horizontalalignment", "right");

   xset (title.handle_value (), "horizontalalignment", "center");

   xset (xlabel.handle_value (), "verticalalignment", "cap");

   xset (ylabel.handle_value (), "verticalalignment", "bottom");

   xset (title.handle_value (), "verticalalignment", "bottom");

   xset (ylabel.handle_value (), "rotation", 90.0);

   adopt (xlabel.handle_value ());

   adopt (ylabel.handle_value ());

   adopt (zlabel.handle_value ());

   adopt (title.handle_value ());

   update_transform ();

   override_defaults (obj);

 }

 void

 axes::properties::delete_text_child (handle_property& hp)

 {

   graphics_handle h = hp.handle_value ();

   if (h.ok ())

     {

       graphics_object go = gh_manager::get_object (h);

       if (go.valid_object ())

 	gh_manager::free (h);

       base_properties::remove_child (h);

     }

   // FIXME -- is it necessary to check whether the axes object is