/*

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"))