--- a/autogen.sh	Tue Jul 31 20:46:47 2012 -0400
+++ b/autogen.sh	Tue Jul 31 21:57:58 2012 -0400
@@ -30,9 +30,9 @@
 
 (cd doc/interpreter; ./config-images.sh)
 
-echo "generating src/DLD-FUNCTIONS/module.mk..."
+echo "generating src/dldfcn/module.mk..."
 
-(cd src/DLD-FUNCTIONS; ./config-module.sh)
+(cd src/dldfcn; ./config-module.sh)
 
 echo "bootstrapping..."
 

--- a/src/DLD-FUNCTIONS/__delaunayn__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,229 +0,0 @@
-/*
-
-Copyright (C) 2000-2012 Kai Habel
-
-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/>.
-
-*/
-
-/*
-  16. July 2000 - Kai Habel: first release
-
-  25. September 2002 - Changes by Rafael Laboissiere <rafael@laboissiere.net>
-
-  * Added Qbb option to normalize the input and avoid crashes in Octave.
-  * delaunayn accepts now a second (optional) argument that must be a string
-  containing extra options to the qhull command.
-  * Fixed doc string.  The dimension of the result matrix is [m, dim+1], and
-  not [n, dim-1].
-
-  6. June 2006: Changes by Alexander Barth <abarth@marine.usf.edu>
-
-  * triangulate non-simplicial facets
-  * allow options to be specified as cell array of strings
-  * change the default options (for compatibility with matlab)
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <iostream>
-#include <string>
-
-#include "Cell.h"
-#include "defun-dld.h"
-#include "error.h"
-#include "oct-obj.h"
-#include "unwind-prot.h"
-
-#if defined (HAVE_QHULL)
-# include "oct-qhull.h"
-# if defined (NEED_QHULL_VERSION)
-char qh_version[] = "__delaunayn__.oct 2007-08-21";
-# endif
-#endif
-
-static void
-close_fcn (FILE *f)
-{
-  gnulib::fclose (f);
-}
-
-DEFUN_DLD (__delaunayn__, args, ,
-           "-*- texinfo -*-\n\
-@deftypefn  {Loadable Function} {@var{T} =} __delaunayn__ (@var{pts})\n\
-@deftypefnx {Loadable Function} {@var{T} =} __delaunayn__ (@var{pts}, @var{options})\n\
-Undocumented internal function.\n\
-@end deftypefn")
-
-{
-  octave_value_list retval;
-
-#if defined (HAVE_QHULL)
-
-  retval(0) = 0.0;
-
-  int nargin = args.length ();
-  if (nargin < 1 || nargin > 2)
-    {
-      print_usage ();
-      return retval;
-    }
-
-  Matrix p (args(0).matrix_value ());
-  const octave_idx_type dim = p.columns ();
-  const octave_idx_type n = p.rows ();
-
-  // Default options
-  std::string options;
-  if (dim <= 3)
-    options = "Qt Qbb Qc Qz";
-  else
-    options = "Qt Qbb Qc Qx";
-
-  if (nargin == 2)
-    {
-      if (args(1).is_string ())
-        options = args(1).string_value ();
-      else if (args(1).is_empty ())
-        ;  // Use default options
-      else if (args(1).is_cellstr ())
-        {
-          options = "";
-          Array<std::string> tmp = args(1).cellstr_value ();
-
-          for (octave_idx_type i = 0; i < tmp.numel (); i++)
-            options += tmp(i) + " ";
-        }
-      else
-        {
-          error ("__delaunayn__: OPTIONS argument must be a string, cell array of strings, or empty");
-          return retval;
-        }
-    }
-
-  if (n > dim + 1)
-    {
-      p = p.transpose ();
-      double *pt_array = p.fortran_vec ();
-      boolT ismalloc = false;
-
-      // Qhull flags argument is not const char*
-      OCTAVE_LOCAL_BUFFER (char, flags, 9 + options.length ());
-
-      sprintf (flags, "qhull d %s", options.c_str ());
-
-      unwind_protect frame;
-
-      // Replace the outfile pointer with stdout for debugging information.
-#if defined (OCTAVE_HAVE_WINDOWS_FILESYSTEM) && ! defined (OCTAVE_HAVE_POSIX_FILESYSTEM)
-      FILE *outfile = gnulib::fopen ("NUL", "w");
-#else
-      FILE *outfile = gnulib::fopen ("/dev/null", "w");
-#endif
-      FILE *errfile = stderr;
-
-      if (outfile)
-        frame.add_fcn (close_fcn, outfile);
-      else
-        {
-          error ("__delaunayn__: unable to create temporary file for output");
-          return retval;
-        }
-
-      int exitcode = qh_new_qhull (dim, n, pt_array, 
-                                   ismalloc, flags, outfile, errfile);
-      if (! exitcode)
-        {
-          // triangulate non-simplicial facets
-          qh_triangulate ();
-
-          facetT *facet;
-          vertexT *vertex, **vertexp;
-          octave_idx_type nf = 0, i = 0;
-
-          FORALLfacets
-            {
-              if (! facet->upperdelaunay)
-                nf++;
-
-              // Double check.  Non-simplicial facets will cause segfault below
-              if (! facet->simplicial)
-                {
-                  error ("__delaunayn__: Qhull returned non-simplicial facets -- try delaunayn with different options");
-                  exitcode = 1;
-                  break;
-                }
-            }
-
-          if (! exitcode)
-            {
-              Matrix simpl (nf, dim+1);
-
-              FORALLfacets
-                {
-                  if (! facet->upperdelaunay)
-                    {
-                      octave_idx_type j = 0;
-
-                      FOREACHvertex_ (facet->vertices)
-                        {
-                          simpl(i, j++) = 1 + qh_pointid(vertex->point);
-                        }
-                      i++;
-                    }
-                }
-
-              retval(0) = simpl;
-            }
-        }
-      else
-        error ("__delaunayn__: qhull failed");
-
-      // Free memory from Qhull
-      qh_freeqhull (! qh_ALL);
-
-      int curlong, totlong;
-      qh_memfreeshort (&curlong, &totlong);
-
-      if (curlong || totlong)
-        warning ("__delaunay__: did not free %d bytes of long memory (%d pieces)",
-                 totlong, curlong);
-    }
-  else if (n == dim + 1)
-    {
-      // one should check if nx points span a simplex
-      // I will look at this later.
-      RowVector vec (n);
-      for (octave_idx_type i = 0; i < n; i++)
-        vec(i) = i + 1.0;
-
-      retval(0) = vec;
-    }
-
-#else
-  error ("__delaunayn__: not available in this version of Octave");
-#endif
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/

--- a/src/DLD-FUNCTIONS/__dsearchn__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,115 +0,0 @@
-/*
-
-Copyright (C) 2007-2012 David Bateman
-
-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 <iostream>
-#include <fstream>
-#include <string>
-
-#include "lo-math.h"
-
-#include "defun-dld.h"
-#include "error.h"
-#include "oct-obj.h"
-
-DEFUN_DLD (__dsearchn__, args, ,
-        "-*- texinfo -*-\n\
-@deftypefn {Loadable Function} {[@var{idx}, @var{d}] =} dsearch (@var{x}, @var{xi})\n\
-Undocumented internal function.\n\
-@end deftypefn")
-{
-  int nargin = args.length ();
-  octave_value_list retval;
-
-  if (nargin != 2)
-    {
-      print_usage ();
-      return retval;
-    }
-
-  Matrix x = args(0).matrix_value ().transpose ();
-  Matrix xi = args(1).matrix_value ().transpose ();
-
-  if (! error_state)
-    {
-      if (x.rows () != xi.rows () || x.columns () < 1)
-        error ("__dsearch__: number of rows of X and XI must match");
-      else
-        {
-          octave_idx_type n = x.rows ();
-          octave_idx_type nx = x.columns ();
-          octave_idx_type nxi = xi.columns ();
-
-          ColumnVector idx (nxi);
-          double *pidx = idx.fortran_vec ();
-          ColumnVector dist (nxi);
-          double *pdist = dist.fortran_vec ();
-
-#define DIST(dd, y, yi, m) \
-  dd = 0.; \
-  for (octave_idx_type k = 0; k < m; k++) \
-   { \
-     double yd = y[k] - yi[k]; \
-     dd += yd * yd; \
-   } \
-  dd = sqrt (dd);
-
-          const double *pxi = xi.fortran_vec ();
-          for (octave_idx_type i = 0; i < nxi; i++)
-            {
-              double d0;
-              const double *px = x.fortran_vec ();
-              DIST(d0, px, pxi, n);
-              *pidx = 1.;
-              for (octave_idx_type j = 1; j < nx; j++)
-                {
-                  px += n;
-                  double d;
-                  DIST (d, px, pxi, n);
-                  if (d < d0)
-                    {
-                      d0 = d;
-                      *pidx = static_cast<double>(j + 1);
-                    }
-                  OCTAVE_QUIT;
-                }
-
-              *pdist++ = d0;
-              pidx++;
-              pxi += n;
-            }
-
-          retval(1) = dist;
-          retval(0) = idx;
-        }
-    }
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/

--- a/src/DLD-FUNCTIONS/__fltk_uigetfile__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,142 +0,0 @@
-/*
-
-Copyright (C) 2010-2012 Kai Habel
-
-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
-
-#if defined (HAVE_FLTK)
-
-#ifdef WIN32
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <FL/Fl.H>
-#include <FL/Fl_File_Chooser.H>
-
-// FLTK headers may include X11/X.h which defines Complex, and that
-// conflicts with Octave's Complex typedef.  We don't need the X11
-// Complex definition in this file, so remove it before including Octave
-// headers which may require Octave's Complex typedef.
-#undef Complex
-
-#include "defun-dld.h"
-#include "file-ops.h"
-
-DEFUN_DLD (__fltk_uigetfile__, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn {Built-in Function} {} __fltk_uigetfile__ (@dots{})\n\
-Undocumented internal function.\n\
-@end deftypefn")
-{
-  // Expected argument list:
-  //
-  //   args(0) ... FileFilter in fltk format
-  //   args(1) ... Title
-  //   args(2) ... Default Filename
-  //   args(3) ... PostionValue [x,y]
-  //   args(4) ... SelectValue "on"/"off"/"dir"/"create"
-
-  octave_value_list retval (3, octave_value (0));
-
-  std::string file_filter = args(0).string_value ();
-  std::string title = args(1).string_value ();
-  std::string default_name = args(2).string_value ();
-  Matrix pos = args(3).matrix_value ();
-
-  int multi_type = Fl_File_Chooser::SINGLE;
-  std::string flabel = "Filename:";
-
-  std::string multi = args(4).string_value ();
-  if (multi == "on")
-    multi_type = Fl_File_Chooser::MULTI;
-  else if (multi == "dir")
-    {
-      multi_type = Fl_File_Chooser::DIRECTORY;
-      flabel = "Directory:";
-    }
-  else if (multi == "create")
-    multi_type = Fl_File_Chooser::CREATE;
-
-  Fl_File_Chooser::filename_label = flabel.c_str ();
-
-  Fl_File_Chooser fc (default_name.c_str (), file_filter.c_str (),
-                      multi_type, title.c_str ());
-
-  fc.preview (0);
-
-  if (multi_type == Fl_File_Chooser::CREATE)
-    fc.ok_label ("Save");
-
-  fc.show ();
-
-  while (fc.shown ())
-    Fl::wait ();
-
-  if (fc.value ())
-    {
-      int file_count = fc.count ();
-      std::string fname;
-
-      //fltk uses forward slash even for windows
-      std::string sep = "/";
-      std::size_t idx;
-
-      if (file_count == 1 && multi_type != Fl_File_Chooser::DIRECTORY)
-        {
-          fname = fc.value ();
-          idx = fname.find_last_of (sep);
-          retval(0) = fname.substr (idx + 1);
-        }
-      else
-        {
-          Cell file_cell = Cell (file_count, 1);
-          for (octave_idx_type n = 1; n <= file_count; n++)
-            {
-              fname = fc.value (n);
-              idx = fname.find_last_of (sep);
-              file_cell(n - 1) = fname.substr (idx + 1);
-            }
-          retval(0) = file_cell;
-        }
-
-      if (multi_type == Fl_File_Chooser::DIRECTORY)
-        retval(0) = std::string (fc.value ());
-      else
-        {
-          retval(1) = std::string (fc.directory ()) + sep;
-          retval(2) = fc.filter_value () + 1;
-        }
-    }
-
-  fc.hide ();
-  Fl::flush ();
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/
-
-#endif

--- a/src/DLD-FUNCTIONS/__glpk__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,861 +0,0 @@
-/*
-
-Copyright (C) 2005-2012 Nicolo' Giorgetti
-
-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 <cfloat>
-#include <csetjmp>
-#include <ctime>
-
-#include "lo-ieee.h"
-
-#include "defun-dld.h"
-#include "error.h"
-#include "gripes.h"
-#include "oct-map.h"
-#include "oct-obj.h"
-#include "pager.h"
-
-#if defined (HAVE_GLPK)
-
-extern "C"
-{
-#if defined (HAVE_GLPK_GLPK_H)
-#include <glpk/glpk.h>
-#else
-#include <glpk.h>
-#endif
-
-#if 0
-#ifdef GLPK_PRE_4_14
-
-#ifndef _GLPLIB_H
-#include <glplib.h>
-#endif
-#ifndef lib_set_fault_hook
-#define lib_set_fault_hook lib_fault_hook
-#endif
-#ifndef lib_set_print_hook
-#define lib_set_print_hook lib_print_hook
-#endif
-
-#else
-
-void _glp_lib_print_hook (int (*func)(void *info, char *buf), void *info);
-void _glp_lib_fault_hook (int (*func)(void *info, char *buf), void *info);
-
-#endif
-#endif
-}
-
-#define NIntP 17
-#define NRealP 10
-
-int lpxIntParam[NIntP] = {
-  0,
-  1,
-  0,
-  1,
-  0,
-  -1,
-  0,
-  200,
-  1,
-  2,
-  0,
-  1,
-  0,
-  0,
-  2,
-  2,
-  1
-};
-
-int IParam[NIntP] = {
-  LPX_K_MSGLEV,
-  LPX_K_SCALE,
-  LPX_K_DUAL,
-  LPX_K_PRICE,
-  LPX_K_ROUND,
-  LPX_K_ITLIM,
-  LPX_K_ITCNT,
-  LPX_K_OUTFRQ,
-  LPX_K_MPSINFO,
-  LPX_K_MPSOBJ,
-  LPX_K_MPSORIG,
-  LPX_K_MPSWIDE,
-  LPX_K_MPSFREE,
-  LPX_K_MPSSKIP,
-  LPX_K_BRANCH,
-  LPX_K_BTRACK,
-  LPX_K_PRESOL
-};
-
-
-double lpxRealParam[NRealP] = {
-  0.07,
-  1e-7,
-  1e-7,
-  1e-9,
-  -DBL_MAX,
-  DBL_MAX,
-  -1.0,
-  0.0,
-  1e-6,
-  1e-7
-};
-
-int RParam[NRealP] = {
-  LPX_K_RELAX,
-  LPX_K_TOLBND,
-  LPX_K_TOLDJ,
-  LPX_K_TOLPIV,
-  LPX_K_OBJLL,
-  LPX_K_OBJUL,
-  LPX_K_TMLIM,
-  LPX_K_OUTDLY,
-  LPX_K_TOLINT,
-  LPX_K_TOLOBJ
-};
-
-static jmp_buf mark;  //-- Address for long jump to jump to
-
-#if 0
-int
-glpk_fault_hook (void * /* info */, char *msg)
-{
-  error ("CRITICAL ERROR in GLPK: %s", msg);
-  longjmp (mark, -1);
-}
-
-int
-glpk_print_hook (void * /* info */, char *msg)
-{
-  message (0, "%s", msg);
-  return 1;
-}
-#endif
-
-int
-glpk (int sense, int n, int m, double *c, int nz, int *rn, int *cn,
-      double *a, double *b, char *ctype, int *freeLB, double *lb,
-      int *freeUB, double *ub, int *vartype, int isMIP, int lpsolver,
-      int save_pb, double *xmin, double *fmin, double *status,
-      double *lambda, double *redcosts, double *time, double *mem)
-{
-  int errnum;
-  int typx = 0;
-  int method;
-
-  clock_t t_start = clock ();
-
-#if 0
-#ifdef GLPK_PRE_4_14
-  lib_set_fault_hook (0, glpk_fault_hook);
-#else
-  _glp_lib_fault_hook (glpk_fault_hook, 0);
-#endif
-
-  if (lpxIntParam[0] > 1)
-#ifdef GLPK_PRE_4_14
-    lib_set_print_hook (0, glpk_print_hook);
-#else
-    _glp_lib_print_hook (glpk_print_hook, 0);
-#endif
-#endif
-
-  LPX *lp = lpx_create_prob ();
-
-
-  //-- Set the sense of optimization
-  if (sense == 1)
-    lpx_set_obj_dir (lp, LPX_MIN);
-  else
-    lpx_set_obj_dir (lp, LPX_MAX);
-
-  //-- If the problem has integer structural variables switch to MIP
-  if (isMIP)
-    lpx_set_class (lp, LPX_MIP);
-
-  lpx_add_cols (lp, n);
-  for (int i = 0; i < n; i++)
-    {
-      //-- Define type of the structural variables
-      if (! freeLB[i] && ! freeUB[i])
-        {
-          if (lb[i] != ub[i])
-            lpx_set_col_bnds (lp, i+1, LPX_DB, lb[i], ub[i]);
-          else
-            lpx_set_col_bnds (lp, i+1, LPX_FX, lb[i], ub[i]);
-        }
-      else
-        {
-          if (! freeLB[i] && freeUB[i])
-            lpx_set_col_bnds (lp, i+1, LPX_LO, lb[i], ub[i]);
-          else
-            {
-              if (freeLB[i] && ! freeUB[i])
-                lpx_set_col_bnds (lp, i+1, LPX_UP, lb[i], ub[i]);
-              else
-                lpx_set_col_bnds (lp, i+1, LPX_FR, lb[i], ub[i]);
-            }
-        }
-
-      // -- Set the objective coefficient of the corresponding
-      // -- structural variable. No constant term is assumed.
-      lpx_set_obj_coef(lp,i+1,c[i]);
-
-      if (isMIP)
-        lpx_set_col_kind (lp, i+1, vartype[i]);
-    }
-
-  lpx_add_rows (lp, m);
-
-  for (int i = 0; i < m; i++)
-    {
-      /* If the i-th row has no lower bound (types F,U), the
-         corrispondent parameter will be ignored.
-         If the i-th row has no upper bound (types F,L), the corrispondent
-         parameter will be ignored.
-         If the i-th row is of S type, the i-th LB is used, but
-         the i-th UB is ignored.
-      */
-
-      switch (ctype[i])
-        {
-        case 'F':
-          typx = LPX_FR;
-          break;
-
-        case 'U':
-          typx = LPX_UP;
-          break;
-
-        case 'L':
-          typx = LPX_LO;
-          break;
-
-        case 'S':
-          typx = LPX_FX;
-          break;
-
-        case 'D':
-          typx = LPX_DB;
-          break;
-        }
-
-      lpx_set_row_bnds (lp, i+1, typx, b[i], b[i]);
-
-    }
-
-  lpx_load_matrix (lp, nz, rn, cn, a);
-
-  if (save_pb)
-    {
-      static char tmp[] = "outpb.lp";
-      if (lpx_write_cpxlp (lp, tmp) != 0)
-        {
-          error ("__glpk__: unable to write problem");
-          longjmp (mark, -1);
-        }
-    }
-
-  //-- scale the problem data (if required)
-  //-- if (scale && (!presol || method == 1)) lpx_scale_prob (lp);
-  //-- LPX_K_SCALE=IParam[1]  LPX_K_PRESOL=IParam[16]
-  if (lpxIntParam[1] && (! lpxIntParam[16] || lpsolver != 1))
-    lpx_scale_prob (lp);
-
-  //-- build advanced initial basis (if required)
-  if (lpsolver == 1 && ! lpxIntParam[16])
-    lpx_adv_basis (lp);
-
-  for (int i = 0; i < NIntP; i++)
-    lpx_set_int_parm (lp, IParam[i], lpxIntParam[i]);
-
-  for (int i = 0; i < NRealP; i++)
-    lpx_set_real_parm (lp, RParam[i], lpxRealParam[i]);
-
-  if (lpsolver == 1)
-    method = 'S';
-  else
-    method = 'T';
-
-  switch (method)
-    {
-    case 'S':
-      {
-        if (isMIP)
-          {
-            method = 'I';
-            errnum = lpx_simplex (lp);
-            errnum = lpx_integer (lp);
-          }
-        else
-          errnum = lpx_simplex (lp);
-      }
-     break;
-
-    case 'T':
-      errnum = lpx_interior (lp);
-      break;
-
-    default:
-      break;
-#if 0
-#ifdef GLPK_PRE_4_14
-      insist (method != method);
-#else
-      static char tmp[] = "method != method";
-      glpk_fault_hook (0, tmp);
-#endif
-#endif
-    }
-
-  /*  errnum assumes the following results:
-      errnum = 0 <=> No errors
-      errnum = 1 <=> Iteration limit exceeded.
-      errnum = 2 <=> Numerical problems with basis matrix.
-  */
-  if (errnum == LPX_E_OK)
-    {
-      if (isMIP)
-        {
-          *status = lpx_mip_status (lp);
-          *fmin = lpx_mip_obj_val (lp);
-        }
-      else
-        {
-          if (lpsolver == 1)
-            {
-              *status = lpx_get_status (lp);
-              *fmin = lpx_get_obj_val (lp);
-            }
-          else
-            {
-              *status = lpx_ipt_status (lp);
-              *fmin = lpx_ipt_obj_val (lp);
-            }
-        }
-
-      if (isMIP)
-        {
-          for (int i = 0; i < n; i++)
-            xmin[i] = lpx_mip_col_val (lp, i+1);
-        }
-      else
-        {
-          /* Primal values */
-          for (int i = 0; i < n; i++)
-            {
-              if (lpsolver == 1)
-                xmin[i] = lpx_get_col_prim (lp, i+1);
-              else
-                xmin[i] = lpx_ipt_col_prim (lp, i+1);
-            }
-
-          /* Dual values */
-          for (int i = 0; i < m; i++)
-            {
-              if (lpsolver == 1)
-                lambda[i] = lpx_get_row_dual (lp, i+1);
-              else
-                lambda[i] = lpx_ipt_row_dual (lp, i+1);
-            }
-
-          /* Reduced costs */
-          for (int i = 0; i < lpx_get_num_cols (lp); i++)
-            {
-              if (lpsolver == 1)
-                redcosts[i] = lpx_get_col_dual (lp, i+1);
-              else
-                redcosts[i] = lpx_ipt_col_dual (lp, i+1);
-            }
-        }
-
-      *time = (clock () - t_start) / CLOCKS_PER_SEC;
-
-#ifdef GLPK_PRE_4_14
-      *mem = (lib_env_ptr () -> mem_tpeak);
-#else
-      *mem = 0;
-#endif
-
-      lpx_delete_prob (lp);
-      return 0;
-    }
-
-   lpx_delete_prob (lp);
-
-   *status = errnum;
-
-   return errnum;
-}
-
-#endif
-
-#define OCTAVE_GLPK_GET_REAL_PARAM(NAME, IDX) \
-  do \
-    { \
-      octave_value tmp = PARAM.getfield (NAME); \
- \
-      if (tmp.is_defined ()) \
-        { \
-          if (! tmp.is_empty ()) \
-            { \
-              lpxRealParam[IDX] = tmp.scalar_value (); \
- \
-              if (error_state) \
-                { \
-                  error ("glpk: invalid value in PARAM." NAME); \
-                  return retval; \
-                } \
-            } \
-          else \
-            { \
-              error ("glpk: invalid value in PARAM." NAME); \
-              return retval; \
-            } \
-        } \
-    } \
-  while (0)
-
-#define OCTAVE_GLPK_GET_INT_PARAM(NAME, VAL) \
-  do \
-    { \
-      octave_value tmp = PARAM.getfield (NAME); \
- \
-      if (tmp.is_defined ()) \
-        { \
-          if (! tmp.is_empty ()) \
-            { \
-              VAL = tmp.int_value (); \
- \
-              if (error_state) \
-                { \
-                  error ("glpk: invalid value in PARAM." NAME); \
-                  return retval; \
-                } \
-            } \
-          else \
-            { \
-              error ("glpk: invalid value in PARAM." NAME); \
-              return retval; \
-            } \
-        } \
-    } \
-  while (0)
-
-DEFUN_DLD (__glpk__, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn {Loadable Function} {[@var{values}] =} __glpk__ (@var{args})\n\
-Undocumented internal function.\n\
-@end deftypefn")
-{
-  // The list of values to return.  See the declaration in oct-obj.h
-  octave_value_list retval;
-
-#if defined (HAVE_GLPK)
-
-  int nrhs = args.length ();
-
-  if (nrhs != 9)
-    {
-      print_usage ();
-      return retval;
-    }
-
-  //-- 1nd Input. A column array containing the objective function
-  //--            coefficients.
-  volatile int mrowsc = args(0).rows ();
-
-  Matrix C (args(0).matrix_value ());
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of C");
-      return retval;
-    }
-
-  double *c = C.fortran_vec ();
-  Array<int> rn;
-  Array<int> cn;
-  ColumnVector a;
-  volatile int mrowsA;
-  volatile int nz = 0;
-
-  //-- 2nd Input. A matrix containing the constraints coefficients.
-  // If matrix A is NOT a sparse matrix
-  if (args(1).is_sparse_type ())
-    {
-      SparseMatrix A = args(1).sparse_matrix_value (); // get the sparse matrix
-
-      if (error_state)
-        {
-          error ("__glpk__: invalid value of A");
-          return retval;
-        }
-
-      mrowsA = A.rows ();
-      octave_idx_type Anc = A.cols ();
-      octave_idx_type Anz = A.nnz ();
-      rn.resize (dim_vector (Anz+1, 1));
-      cn.resize (dim_vector (Anz+1, 1));
-      a.resize (Anz+1, 0.0);
-
-      if (Anc != mrowsc)
-        {
-          error ("__glpk__: invalid value of A");
-          return retval;
-        }
-
-      for (octave_idx_type j = 0; j < Anc; j++)
-        for (octave_idx_type i = A.cidx (j); i < A.cidx (j+1); i++)
-          {
-            nz++;
-            rn(nz) = A.ridx (i) + 1;
-            cn(nz) = j + 1;
-            a(nz) = A.data(i);
-          }
-    }
-  else
-    {
-      Matrix A (args(1).matrix_value ()); // get the matrix
-
-      if (error_state)
-        {
-          error ("__glpk__: invalid value of A");
-          return retval;
-        }
-
-      mrowsA = A.rows ();
-      rn.resize (dim_vector (mrowsA*mrowsc+1, 1));
-      cn.resize (dim_vector (mrowsA*mrowsc+1, 1));
-      a.resize (mrowsA*mrowsc+1, 0.0);
-
-      for (int i = 0; i < mrowsA; i++)
-        {
-          for (int j = 0; j < mrowsc; j++)
-            {
-              if (A(i,j) != 0)
-                {
-                  nz++;
-                  rn(nz) = i + 1;
-                  cn(nz) = j + 1;
-                  a(nz) = A(i,j);
-                }
-            }
-        }
-
-    }
-
-  //-- 3rd Input. A column array containing the right-hand side value
-  //               for each constraint in the constraint matrix.
-  Matrix B (args(2).matrix_value ());
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of B");
-      return retval;
-    }
-
-  double *b = B.fortran_vec ();
-
-  //-- 4th Input. An array of length mrowsc containing the lower
-  //--            bound on each of the variables.
-  Matrix LB (args(3).matrix_value ());
-
-  if (error_state || LB.length () < mrowsc)
-    {
-      error ("__glpk__: invalid value of LB");
-      return retval;
-    }
-
-  double *lb = LB.fortran_vec ();
-
-  //-- LB argument, default: Free
-  Array<int> freeLB (dim_vector (mrowsc, 1));
-  for (int i = 0; i < mrowsc; i++)
-     {
-       if (xisinf (lb[i]))
-         {
-           freeLB(i) = 1;
-           lb[i] = -octave_Inf;
-         }
-       else
-         freeLB(i) = 0;
-     }
-
-  //-- 5th Input. An array of at least length numcols containing the upper
-  //--            bound on each of the variables.
-  Matrix UB (args(4).matrix_value ());
-
-  if (error_state || UB.length () < mrowsc)
-    {
-      error ("__glpk__: invalid value of UB");
-      return retval;
-    }
-
-  double *ub = UB.fortran_vec ();
-
-  Array<int> freeUB (dim_vector (mrowsc, 1));
-  for (int i = 0; i < mrowsc; i++)
-    {
-      if (xisinf (ub[i]))
-        {
-          freeUB(i) = 1;
-          ub[i] = octave_Inf;
-        }
-      else
-        freeUB(i) = 0;
-    }
-
-  //-- 6th Input. A column array containing the sense of each constraint
-  //--            in the constraint matrix.
-  charMatrix CTYPE (args(5).char_matrix_value ());
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of CTYPE");
-      return retval;
-    }
-
-  char *ctype = CTYPE.fortran_vec ();
-
-  //-- 7th Input. A column array containing the types of the variables.
-  charMatrix VTYPE (args(6).char_matrix_value ());
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of VARTYPE");
-      return retval;
-    }
-
-  Array<int> vartype (dim_vector (mrowsc, 1));
-  volatile int isMIP = 0;
-  for (int i = 0; i < mrowsc ; i++)
-    {
-      if (VTYPE(i,0) == 'I')
-        {
-          isMIP = 1;
-          vartype(i) = LPX_IV;
-        }
-      else
-        vartype(i) = LPX_CV;
-    }
-
-  //-- 8th Input. Sense of optimization.
-  volatile int sense;
-  double SENSE = args(7).scalar_value ();
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of SENSE");
-      return retval;
-    }
-
-  if (SENSE >= 0)
-    sense = 1;
-  else
-    sense = -1;
-
-  //-- 9th Input. A structure containing the control parameters.
-  octave_scalar_map PARAM = args(8).scalar_map_value ();
-
-  if (error_state)
-    {
-      error ("__glpk__: invalid value of PARAM");
-      return retval;
-    }
-
-  //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  //-- Integer parameters
-  //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  //-- Level of messages output by the solver
-  OCTAVE_GLPK_GET_INT_PARAM ("msglev", lpxIntParam[0]);
-  if (lpxIntParam[0] < 0 || lpxIntParam[0] > 3)
-    {
-      error ("__glpk__: PARAM.msglev must be 0 (no output [default]) or 1 (error messages only) or 2 (normal output) or 3 (full output)");
-      return retval;
-    }
-
-  //-- scaling option
-  OCTAVE_GLPK_GET_INT_PARAM ("scale", lpxIntParam[1]);
-  if (lpxIntParam[1] < 0 || lpxIntParam[1] > 2)
-    {
-      error ("__glpk__: PARAM.scale must be 0 (no scaling) or 1 (equilibration scaling [default]) or 2 (geometric mean scaling)");
-      return retval;
-    }
-
-  //-- Dual dimplex option
-  OCTAVE_GLPK_GET_INT_PARAM ("dual", lpxIntParam[2]);
-  if (lpxIntParam[2] < 0 || lpxIntParam[2] > 1)
-    {
-      error ("__glpk__: PARAM.dual must be 0 (do NOT use dual simplex [default]) or 1 (use dual simplex)");
-      return retval;
-    }
-
-  //-- Pricing option
-  OCTAVE_GLPK_GET_INT_PARAM ("price", lpxIntParam[3]);
-  if (lpxIntParam[3] < 0 || lpxIntParam[3] > 1)
-    {
-      error ("__glpk__: PARAM.price must be 0 (textbook pricing) or 1 (steepest edge pricing [default])");
-      return retval;
-    }
-
-  //-- Solution rounding option
-  OCTAVE_GLPK_GET_INT_PARAM ("round", lpxIntParam[4]);
-  if (lpxIntParam[4] < 0 || lpxIntParam[4] > 1)
-    {
-      error ("__glpk__: PARAM.round must be 0 (report all primal and dual values [default]) or 1 (replace tiny primal and dual values by exact zero)");
-      return retval;
-    }
-
-  //-- Simplex iterations limit
-  OCTAVE_GLPK_GET_INT_PARAM ("itlim", lpxIntParam[5]);
-
-  //-- Simplex iterations count
-  OCTAVE_GLPK_GET_INT_PARAM ("itcnt", lpxIntParam[6]);
-
-  //-- Output frequency, in iterations
-  OCTAVE_GLPK_GET_INT_PARAM ("outfrq", lpxIntParam[7]);
-
-  //-- Branching heuristic option
-  OCTAVE_GLPK_GET_INT_PARAM ("branch", lpxIntParam[14]);
-  if (lpxIntParam[14] < 0 || lpxIntParam[14] > 2)
-    {
-      error ("__glpk__: PARAM.branch must be (MIP only) 0 (branch on first variable) or 1 (branch on last variable) or 2 (branch using a heuristic by Driebeck and Tomlin [default]");
-      return retval;
-    }
-
-  //-- Backtracking heuristic option
-  OCTAVE_GLPK_GET_INT_PARAM ("btrack", lpxIntParam[15]);
-  if (lpxIntParam[15] < 0 || lpxIntParam[15] > 2)
-    {
-      error ("__glpk__: PARAM.btrack must be (MIP only) 0 (depth first search) or 1 (breadth first search) or 2 (backtrack using the best projection heuristic [default]");
-      return retval;
-    }
-
-  //-- Presolver option
-  OCTAVE_GLPK_GET_INT_PARAM ("presol", lpxIntParam[16]);
-  if (lpxIntParam[16] < 0 || lpxIntParam[16] > 1)
-    {
-      error ("__glpk__: PARAM.presol must be 0 (do NOT use LP presolver) or 1 (use LP presolver [default])");
-      return retval;
-    }
-
-  //-- LPsolver option
-  volatile int lpsolver = 1;
-  OCTAVE_GLPK_GET_INT_PARAM ("lpsolver", lpsolver);
-  if (lpsolver < 1 || lpsolver > 2)
-    {
-      error ("__glpk__: PARAM.lpsolver must be 1 (simplex method) or 2 (interior point method)");
-      return retval;
-    }
-
-  //-- Save option
-  volatile int save_pb = 0;
-  OCTAVE_GLPK_GET_INT_PARAM ("save", save_pb);
-  save_pb = save_pb != 0;
-
-  //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-  //-- Real parameters
-  //-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-
-  //-- Ratio test option
-  OCTAVE_GLPK_GET_REAL_PARAM ("relax", 0);
-
-  //-- Relative tolerance used to check if the current basic solution
-  //-- is primal feasible
-  OCTAVE_GLPK_GET_REAL_PARAM ("tolbnd", 1);
-
-  //-- Absolute tolerance used to check if the current basic solution
-  //-- is dual feasible
-  OCTAVE_GLPK_GET_REAL_PARAM ("toldj", 2);
-
-  //-- Relative tolerance used to choose eligible pivotal elements of
-  //--  the simplex table in the ratio test
-  OCTAVE_GLPK_GET_REAL_PARAM ("tolpiv", 3);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("objll", 4);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("objul", 5);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("tmlim", 6);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("outdly", 7);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("tolint", 8);
-
-  OCTAVE_GLPK_GET_REAL_PARAM ("tolobj", 9);
-
-  //-- Assign pointers to the output parameters
-  ColumnVector xmin (mrowsc, octave_NA);
-  double fmin = octave_NA;
-  double status;
-  ColumnVector lambda (mrowsA, octave_NA);
-  ColumnVector redcosts (mrowsc, octave_NA);
-  double time;
-  double mem;
-
-  int jmpret = setjmp (mark);
-
-  if (jmpret == 0)
-    glpk (sense, mrowsc, mrowsA, c, nz, rn.fortran_vec (),
-          cn.fortran_vec (), a.fortran_vec (), b, ctype,
-          freeLB.fortran_vec (), lb, freeUB.fortran_vec (), ub,
-          vartype.fortran_vec (), isMIP, lpsolver, save_pb,
-          xmin.fortran_vec (), &fmin, &status, lambda.fortran_vec (),
-          redcosts.fortran_vec (), &time, &mem);
-
-  octave_scalar_map extra;
-
-  if (! isMIP)
-    {
-      extra.assign ("lambda", lambda);
-      extra.assign ("redcosts", redcosts);
-    }
-
-  extra.assign ("time", time);
-  extra.assign ("mem", mem);
-
-  retval(3) = extra;
-  retval(2) = status;
-  retval(1) = fmin;
-  retval(0) = xmin;
-
-#else
-
-  gripe_not_supported ("glpk");
-
-#endif
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/

--- a/src/DLD-FUNCTIONS/__init_fltk__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,2129 +0,0 @@
-/*
-
-Copyright (C) 2007-2012 Shai Ayal
-
-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/>.
-
-*/
-
-/*
-
-To initialize:
-
-  graphics_toolkit ("fltk");
-  plot (randn (1e3, 1));
-
-*/
-
-// PKG_ADD: register_graphics_toolkit ("fltk");
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "defun-dld.h"
-#include "error.h"
-
-#if defined (HAVE_FLTK)
-
-#include <map>
-#include <set>
-#include <sstream>
-#include <iostream>
-
-#ifdef WIN32
-#define WIN32_LEAN_AND_MEAN
-#endif
-
-#include <FL/Fl.H>
-#include <FL/Fl_Box.H>
-#include <FL/Fl_Button.H>
-#include <FL/Fl_Choice.H>
-#include <FL/Fl_File_Chooser.H>
-#include <FL/Fl_Gl_Window.H>
-#include <FL/Fl_Menu_Bar.H>
-#include <FL/Fl_Menu_Button.H>
-#include <FL/Fl_Output.H>
-#include <FL/Fl_Window.H>
-#include <FL/fl_ask.H>
-#include <FL/fl_draw.H>
-#include <FL/gl.h>
-
-// FLTK headers may include X11/X.h which defines Complex, and that
-// conflicts with Octave's Complex typedef.  We don't need the X11
-// Complex definition in this file, so remove it before including Octave
-// headers which may require Octave's Complex typedef.
-#undef Complex
-
-#include "cmd-edit.h"
-#include "lo-ieee.h"
-
-#include "file-ops.h"
-#include "gl-render.h"
-#include "gl2ps-renderer.h"
-#include "graphics.h"
-#include "parse.h"
-#include "sysdep.h"
-#include "toplev.h"
-#include "variables.h"
-
-#define FLTK_GRAPHICS_TOOLKIT_NAME "fltk"
-
-// Give FLTK no more than 0.01 sec to do its stuff.
-static double fltk_maxtime = 1e-2;
-
-const char* help_text = "\
-Keyboard Shortcuts\n\
-a - autoscale\n\
-p - pan/zoom\n\
-r - rotate\n\
-g - toggle grid\n\
-\n\
-Mouse\n\
-left drag - pan\n\
-mouse wheel - zoom\n\
-right drag - rectangle zoom\n\
-left double click - autoscale\n\
-";
-
-class OpenGL_fltk : public Fl_Gl_Window
-{
-public:
-  OpenGL_fltk (int xx, int yy, int ww, int hh, double num)
-    : Fl_Gl_Window (xx, yy, ww, hh, 0), number (num), renderer (),
-      in_zoom (false), zoom_box (),  print_mode (false)
-  {
-    // Ask for double buffering and a depth buffer.
-    mode (FL_DEPTH | FL_DOUBLE);
-  }
-
-  ~OpenGL_fltk (void) { }
-
-  void zoom (bool z)
-  {
-    in_zoom = z;
-    if (! in_zoom)
-      hide_overlay ();
-  }
-
-  bool zoom (void) { return in_zoom; }
-  void set_zoom_box (const Matrix& zb) { zoom_box = zb; }
-
-  void print (const std::string& cmd, const std::string& term)
-  {
-    print_mode  = true;
-    print_cmd = cmd;
-    print_term  = term;
-  }
-
-  void resize (int xx, int yy, int ww, int hh)
-  {
-    Fl_Gl_Window::resize (xx, yy, ww, hh);
-    setup_viewport (ww, hh);
-    redraw ();
-  }
-
-  bool renumber (double new_number)
-  {
-    bool retval = false;
-
-    if (number != new_number)
-      {
-        number = new_number;
-        retval = true;
-      }
-
-    return retval;
-  }
-
-private:
-  double number;
-  opengl_renderer renderer;
-  bool in_zoom;
-  // (x1,y1,x2,y2)
-  Matrix zoom_box;
-
-  bool print_mode;
-  std::string print_cmd;
-  std::string print_term;
-
-  void setup_viewport (int ww, int hh)
-  {
-    glMatrixMode (GL_PROJECTION);
-    glLoadIdentity ();
-    glViewport (0, 0, ww, hh);
-  }
-
-  void draw (void)
-  {
-    if (! valid ())
-      {
-        valid (1);
-        setup_viewport (w (), h ());
-      }
-
-    if (print_mode)
-      {
-        FILE *fp = octave_popen (print_cmd.c_str (), "w");
-        glps_renderer rend (fp, print_term);
-
-        rend.draw (gh_manager::get_object (number));
-
-        octave_pclose (fp);
-        print_mode = false;
-      }
-    else
-      {
-        renderer.draw (gh_manager::get_object (number));
-
-        if (zoom ())
-          overlay ();
-      }
-  }
-
-  void zoom_box_vertex (void)
-  {
-    glVertex2d (zoom_box(0), h () - zoom_box(1));
-    glVertex2d (zoom_box(0), h () - zoom_box(3));
-    glVertex2d (zoom_box(2), h () - zoom_box(3));
-    glVertex2d (zoom_box(2), h () - zoom_box(1));
-    glVertex2d (zoom_box(0), h () - zoom_box(1));
-  }
-
-  void overlay (void)
-  {
-    glPushMatrix ();
-
-    glMatrixMode (GL_MODELVIEW);
-    glLoadIdentity ();
-
-    glMatrixMode (GL_PROJECTION);
-    glLoadIdentity ();
-    gluOrtho2D (0.0, w (), 0.0, h ());
-
-    glPushAttrib (GL_DEPTH_BUFFER_BIT | GL_CURRENT_BIT);
-    glDisable (GL_DEPTH_TEST);
-
-    glBegin (GL_POLYGON);
-    glColor4f (0.45, 0.62, 0.81, 0.1);
-    zoom_box_vertex ();
-    glEnd ();
-
-    glBegin (GL_LINE_STRIP);
-    glLineWidth (1.5);
-    glColor4f (0.45, 0.62, 0.81, 0.9);
-    zoom_box_vertex ();
-    glEnd ();
-
-    glPopAttrib ();
-    glPopMatrix ();
-  }
-
-  int handle (int event)
-  {
-    int retval = Fl_Gl_Window::handle (event);
-
-    switch (event)
-      {
-      case FL_ENTER:
-        window ()->cursor (FL_CURSOR_CROSS);
-        return 1;
-
-      case FL_LEAVE:
-        window ()->cursor (FL_CURSOR_DEFAULT);
-        return 1;
-      }
-
-    return retval;
-  }
-};
-
-// Parameter controlling how fast we zoom when using the scrool wheel.
-static double wheel_zoom_speed = 0.05;
-// Parameter controlling the GUI mode.
-static enum { pan_zoom, rotate_zoom, none } gui_mode;
-
-void script_cb (Fl_Widget*, void* data)
-  {
-    static_cast<uimenu::properties*> (data)->execute_callback ();
-  }
-
-
-class fltk_uimenu
-{
-public:
-  fltk_uimenu (int xx, int yy, int ww, int hh)
-    {
-      menubar = new
-        Fl_Menu_Bar (xx, yy, ww, hh);
-    }
-
-  int items_to_show (void)
-    {
-      //returns the number of visible menu items
-      int len = menubar->size ();
-      int n = 0;
-      for (int t = 0; t < len; t++ )
-        {
-          const Fl_Menu_Item *m = static_cast<const Fl_Menu_Item*> (&(menubar->menu ()[t]));
-          if ((m->label () != NULL) && m->visible ())
-            n++;
-        }
-
-      return n;
-    }
-
-  void show (void)
-    {
-      menubar->show ();
-    }
-
-  void hide (void)
-    {
-      menubar->hide ();
-    }
-
-   bool is_visible (void)
-    {
-      return menubar->visible ();
-    }
-
-  int find_index_by_name (const std::string& findname)
-    {
-      // This function is derived from Greg Ercolano's function
-      // int GetIndexByName(...), see:
-      // http://seriss.com/people/erco/fltk/#Menu_ChangeLabel
-      // He agreed via PM that it can be included in octave using GPLv3
-      // Kai Habel (14.10.2010)
-
-      std::string menupath;
-      for (int t = 0; t < menubar->size (); t++ )
-        {
-          Fl_Menu_Item *m = const_cast<Fl_Menu_Item*> (&(menubar->menu ()[t]));
-          if (m->submenu ())
-            {
-              // item has submenu
-              if (!menupath.empty ())
-                menupath += "/";
-              menupath += m->label ();
-
-              if (menupath.compare (findname) == 0 )
-                return (t);
-            }
-          else
-            {
-              // End of submenu? Pop back one level.
-              if (m->label () == NULL)
-                {
-                  std::size_t idx = menupath.find_last_of ("/");
-                  if (idx != std::string::npos)
-                    menupath.erase (idx);
-                  else
-                    menupath.clear ();
-                  continue;
-                }
-              // Menu item?
-              std::string itempath = menupath;
-              if (!itempath.empty ())
-                itempath += "/";
-              itempath += m->label ();
-
-              if (itempath.compare (findname) == 0)
-                return (t);
-            }
-        }
-      return (-1);
-    }
-
-  Matrix find_uimenu_children (uimenu::properties& uimenup) const
-    {
-      Matrix uimenu_childs = uimenup.get_all_children ();
-      Matrix retval = do_find_uimenu_children (uimenu_childs);
-      return retval;
-    }
-
-  Matrix find_uimenu_children (figure::properties& figp) const
-    {
-      Matrix uimenu_childs = figp.get_all_children ();
-      Matrix retval = do_find_uimenu_children (uimenu_childs);
-      return retval;
-    }
-
-  Matrix do_find_uimenu_children (Matrix uimenu_childs) const
-    {
-      octave_idx_type k = 0;
-
-
-      Matrix pos = Matrix (uimenu_childs.numel (), 1);
-
-      for (octave_idx_type ii = 0; ii < uimenu_childs.numel (); ii++)
-      {
-        graphics_object kidgo = gh_manager::get_object (uimenu_childs (ii));
-
-        if (kidgo.valid_object () && kidgo.isa ("uimenu"))
-          {
-            uimenu_childs(k) = uimenu_childs(ii);
-            pos(k++) =
-              dynamic_cast<uimenu::properties&> (kidgo.get_properties ()).get_position ();
-          }
-      }
-
-      uimenu_childs.resize (k, 1);
-      pos.resize (k, 1);
-      Matrix retval = Matrix (k, 1);
-      // Don't know if this is the best method to sort.
-      // Can we avoid the for loop?
-      Array<octave_idx_type> sidx = pos.sort_rows_idx (DESCENDING);
-      for (octave_idx_type ii = 0; ii < k; ii++)
-        retval(ii) = uimenu_childs (sidx(ii));
-
-      return retval;
-    }
-
-  void delete_entry (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      int idx = find_index_by_name (fltk_label.c_str ());
-
-      if (idx >= 0)
-        menubar->remove (idx);
-    }
-
-  void update_accelerator (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          Fl_Menu_Item* item = const_cast<Fl_Menu_Item*> (menubar->find_item (fltk_label.c_str ()));
-          if (item != NULL)
-            {
-              std::string acc = uimenup.get_accelerator ();
-              if (acc.length () > 0)
-                {
-                  int key = FL_CTRL + acc[0];
-                  item->shortcut (key);
-                }
-            }
-        }
-    }
-
-  void update_callback (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          Fl_Menu_Item* item = const_cast<Fl_Menu_Item*> (menubar->find_item (fltk_label.c_str ()));
-          if (item != NULL)
-            {
-              if (!uimenup.get_callback ().is_empty ())
-                item->callback (static_cast<Fl_Callback*> (script_cb),
-                                static_cast<void*> (&uimenup));
-              else
-                item->callback (NULL, static_cast<void*> (0));
-            }
-        }
-    }
-
-  void update_enable (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          Fl_Menu_Item* item = const_cast<Fl_Menu_Item*> (menubar->find_item (fltk_label.c_str ()));
-          if (item != NULL)
-            {
-              if (uimenup.is_enable ())
-                item->activate ();
-              else
-                item->deactivate ();
-            }
-        }
-    }
-
-  void update_foregroundcolor (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          Fl_Menu_Item* item = const_cast<Fl_Menu_Item*> (menubar->find_item (fltk_label.c_str ()));
-          if (item != NULL)
-            {
-              Matrix rgb = uimenup.get_foregroundcolor_rgb ();
-
-              uchar r = static_cast<uchar> (gnulib::floor (rgb (0) * 255));
-              uchar g = static_cast<uchar> (gnulib::floor (rgb (1) * 255));
-              uchar b = static_cast<uchar> (gnulib::floor (rgb (2) * 255));
-
-              item->labelcolor (fl_rgb_color (r, g, b));
-            }
-        }
-    }
-
-  void update_seperator (const uimenu::properties& uimenup)
-    {
-      // Matlab places the separator before the current
-      // menu entry, while fltk places it after. So we need to find
-      // the previous item in this menu/submenu. (Kai)
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          int itemflags = 0, idx;
-          int curr_idx = find_index_by_name (fltk_label.c_str ());
-
-          for (idx = curr_idx - 1; idx >= 0; idx--)
-            {
-              Fl_Menu_Item* item = const_cast<Fl_Menu_Item*> (&menubar->menu () [idx]);
-              itemflags = item->flags;
-              if (item->label () != NULL)
-                break;
-            }
-
-          if (idx >= 0 && idx < menubar->size ())
-            {
-              if (uimenup.is_separator ())
-                {
-                  if (idx >= 0 && !(itemflags & FL_SUBMENU))
-                    menubar->mode (idx, itemflags | FL_MENU_DIVIDER);
-                }
-              else
-                menubar->mode (idx, itemflags & (~FL_MENU_DIVIDER));
-            }
-        }
-    }
-
-  void update_visible (uimenu::properties& uimenup)
-    {
-      std::string fltk_label = uimenup.get_fltk_label ();
-      if (!fltk_label.empty ())
-        {
-          Fl_Menu_Item* item
-            = const_cast<Fl_Menu_Item*> (menubar->find_item (fltk_label.c_str ()));
-          if (item != NULL)
-            {
-              if (uimenup.is_visible ())
-                item->show ();
-              else
-                item->hide ();
-            }
-        }
-    }
-
-  void add_entry (uimenu::properties& uimenup)
-    {
-
-      std::string fltk_label = uimenup.get_fltk_label ();
-
-      if (!fltk_label.empty ())
-        {
-          bool item_added = false;
-          do
-            {
-              const Fl_Menu_Item* item
-                = menubar->find_item (fltk_label.c_str ());
-
-              if (item == NULL)
-                {
-                  Matrix uimenu_ch = find_uimenu_children (uimenup);
-                  int len = uimenu_ch.numel ();
-                  int flags = 0;
-                  if (len > 0)
-                    flags = FL_SUBMENU;
-                  if (len == 0 && uimenup.is_checked ())
-                    flags += FL_MENU_TOGGLE + FL_MENU_VALUE;
-                  menubar->add (fltk_label.c_str (), 0, 0, 0, flags);
-                  item_added = true;
-                }
-              else
-                {
-                  //avoid duplicate menulabels
-                  std::size_t idx1 = fltk_label.find_last_of ("(");
-                  std::size_t idx2 = fltk_label.find_last_of (")");
-                  int len = idx2 - idx1;
-                  int val = 1;
-                  if (len > 0)
-                    {
-                      std::string valstr = fltk_label.substr (idx1 + 1, len - 1);
-                      fltk_label.erase (idx1, len + 1);
-                      val = atoi (valstr.c_str ());
-                      if (val > 0 && val < 99)
-                        val++;
-                    }
-                  std::ostringstream valstream;
-                  valstream << val;
-                  fltk_label += "(" + valstream.str () + ")";
-                }
-            }
-          while (!item_added);
-          uimenup.set_fltk_label (fltk_label);
-        }
-    }
-
-  void add_to_menu (uimenu::properties& uimenup)
-    {
-      Matrix kids = find_uimenu_children (uimenup);
-      int len = kids.length ();
-      std::string fltk_label = uimenup.get_fltk_label ();
-
-      add_entry (uimenup);
-      update_foregroundcolor (uimenup);
-      update_callback (uimenup);
-      update_accelerator (uimenup);
-      update_enable (uimenup);
-      update_visible (uimenup);
-      update_seperator (uimenup);
-
-      for (octave_idx_type ii = 0; ii < len; ii++)
-        {
-          graphics_object kgo = gh_manager::get_object (kids (len - (ii + 1)));
-          if (kgo.valid_object ())
-            {
-              uimenu::properties& kprop = dynamic_cast<uimenu::properties&> (kgo.get_properties ());
-              add_to_menu (kprop);
-            }
-        }
-    }
-
-  void add_to_menu (figure::properties& figp)
-    {
-      Matrix kids = find_uimenu_children (figp);
-      int len = kids.length ();
-      menubar->clear ();
-      for (octave_idx_type ii = 0; ii < len; ii++)
-        {
-          graphics_object kgo = gh_manager::get_object (kids (len - (ii + 1)));
-
-          if (kgo.valid_object ())
-            {
-              uimenu::properties& kprop = dynamic_cast<uimenu::properties&> (kgo.get_properties ());
-              add_to_menu (kprop);
-            }
-        }
-    }
-
-  template <class T_prop>
-  void remove_from_menu (T_prop& prop)
-    {
-      Matrix kids;
-      std::string type = prop.get_type ();
-      kids = find_uimenu_children (prop);
-      int len = kids.length ();
-
-      for (octave_idx_type ii = 0; ii < len; ii++)
-        {
-          graphics_object kgo = gh_manager::get_object (kids (len - (ii + 1)));
-
-          if (kgo.valid_object ())
-            {
-              uimenu::properties kprop = dynamic_cast<uimenu::properties&> (kgo.get_properties ());
-              remove_from_menu (kprop);
-            }
-        }
-
-      if (type.compare ("uimenu") == 0)
-        delete_entry (dynamic_cast<uimenu::properties&> (prop));
-      else if (type.compare ("figure") == 0)
-        menubar->clear ();
-    }
-
-  ~fltk_uimenu (void)
-    {
-      delete menubar;
-    }
-
-private:
-
-  // No copying!
-
-  fltk_uimenu (const fltk_uimenu&);
-
-  fltk_uimenu operator = (const fltk_uimenu&);
-
-  Fl_Menu_Bar* menubar;
-};
-
-class plot_window : public Fl_Window
-{
-  friend class fltk_uimenu;
-public:
-  plot_window (int xx, int yy, int ww, int hh, figure::properties& xfp)
-    : Fl_Window (xx, yy, ww, hh, "octave"), window_label (), shift (0),
-      ndim (2), fp (xfp), canvas (0), autoscale (0), togglegrid (0),
-      panzoom (0), rotate (0), help (0), status (0),
-      ax_obj (), pos_x (0), pos_y (0)
-  {
-    callback (window_close, static_cast<void*> (this));
-    size_range (4*status_h, 2*status_h);
-
-    // FIXME: The function below is only available in FLTK >= 1.3
-    // At some point support for FLTK 1.1 will be dropped in Octave.
-    // At that point this function should be uncommented.
-    // The current solution is to call xclass() before show() for each window.
-    // Set WM_CLASS which allows window managers to properly group related
-    // windows.  Otherwise, the class is just "FLTK"
-    //default_xclass ("Octave");
-
-    begin ();
-    {
-
-      canvas = new OpenGL_fltk (0, 0, ww, hh - status_h, number ());
-
-      uimenu = new fltk_uimenu (0, 0, ww, menu_h);
-      uimenu->hide ();
-
-      bottom = new Fl_Box (0, hh - status_h, ww, status_h);
-      bottom->box (FL_FLAT_BOX);
-
-      ndim = calc_dimensions (gh_manager::get_object (fp.get___myhandle__ ()));
-
-      autoscale = new Fl_Button (0, hh - status_h, status_h, status_h, "A");
-      autoscale->callback (button_callback, static_cast<void*> (this));
-      autoscale->tooltip ("Autoscale");
-
-      togglegrid = new Fl_Button (status_h, hh - status_h, status_h,
-                                  status_h, "G");
-      togglegrid->callback (button_callback, static_cast<void*> (this));
-      togglegrid->tooltip ("Toggle Grid");
-
-      panzoom = new Fl_Button (2 * status_h, hh - status_h, status_h,
-                               status_h, "P");
-      panzoom->callback (button_callback, static_cast<void*> (this));
-      panzoom->tooltip ("Mouse Pan/Zoom");
-
-      rotate = new Fl_Button (3 * status_h, hh - status_h, status_h,
-                              status_h, "R");
-      rotate->callback (button_callback, static_cast<void*> (this));
-      rotate->tooltip ("Mouse Rotate");
-
-      if (ndim == 2)
-        rotate->deactivate ();
-
-      help = new Fl_Button (4 * status_h, hh - status_h, status_h,
-                            status_h, "?");
-      help->callback (button_callback, static_cast<void*> (this));
-      help->tooltip ("Help");
-
-      status = new Fl_Output (5 * status_h, hh - status_h,
-                              ww > 2*status_h ? ww - status_h : 0,
-                              status_h, "");
-
-      status->textcolor (FL_BLACK);
-      status->color (FL_GRAY);
-      status->textfont (FL_COURIER);
-      status->textsize (10);
-      status->box (FL_ENGRAVED_BOX);
-
-      // This allows us to have a valid OpenGL context right away.
-      canvas->mode (FL_DEPTH | FL_DOUBLE );
-      if (fp.is_visible ())
-        {
-          // FIXME: This code should be removed when Octave drops support
-          // for FLTK 1.1.  Search for default_xclass in this file to find
-          // code that should be uncommented to take its place.
-          //
-          // Set WM_CLASS which allows window managers to properly group
-          // related windows.  Otherwise, the class is just "FLTK"
-          xclass ("Octave");
-          show ();
-          if (fp.get_currentaxes ().ok ())
-            show_canvas ();
-          else
-            hide_canvas ();
-        }
-    }
-    end ();
-
-    status->show ();
-    autoscale->show ();
-    togglegrid->show ();
-    panzoom->show ();
-    rotate->show ();
-
-    set_name ();
-    resizable (canvas);
-    gui_mode = (ndim == 3 ? rotate_zoom : pan_zoom);
-    uimenu->add_to_menu (fp);
-    if (uimenu->items_to_show ())
-      show_menubar ();
-    else
-      hide_menubar ();
-  }
-
-  ~plot_window (void)
-  {
-    canvas->hide ();
-    status->hide ();
-    uimenu->hide ();
-    this->hide ();
-  }
-
-  double number (void) { return fp.get___myhandle__ ().value (); }
-
-  void renumber (double new_number)
-  {
-    if (canvas)
-      {
-        if (canvas->renumber (new_number))
-          mark_modified ();
-      }
-    else
-      error ("unable to renumber figure");
-  }
-
-  void print (const std::string& cmd, const std::string& term)
-  {
-    canvas->print (cmd, term);
-
-    // Print immediately so the output file will exist when the drawnow
-    // command is done.
-    mark_modified ();
-    Fl::wait (fltk_maxtime);
-  }
-
-  void show_menubar (void)
-  {
-    if (!uimenu->is_visible ())
-      {
-        canvas->resize (canvas->x (),
-                        canvas->y () + menu_h,
-                        canvas->w (),
-                        canvas->h () - menu_h);
-        uimenu->show ();
-        mark_modified ();
-      }
-  }
-
-  void hide_menubar (void)
-  {
-    if (uimenu->is_visible ())
-      {
-        canvas->resize (canvas->x (),
-                        canvas->y () - menu_h,
-                        canvas->w (),
-                        canvas->h () + menu_h);
-        uimenu->hide ();
-        mark_modified ();
-      }
-  }
-
-  void uimenu_update (const graphics_handle& gh, int id)
-  {
-    graphics_object uimenu_obj = gh_manager::get_object (gh);
-
-    if (uimenu_obj.valid_object () && uimenu_obj.isa ("uimenu"))
-      {
-        uimenu::properties& uimenup =
-          dynamic_cast<uimenu::properties&> (uimenu_obj.get_properties ());
-        std::string fltk_label = uimenup.get_fltk_label ();
-        graphics_object fig = uimenu_obj.get_ancestor ("figure");
-        figure::properties& figp =
-          dynamic_cast<figure::properties&> (fig.get_properties ());
-
-        switch (id)
-          {
-          case base_properties::ID_BEINGDELETED:
-            uimenu->remove_from_menu (uimenup);
-            break;
-
-          case base_properties::ID_VISIBLE:
-            uimenu->update_visible (uimenup);
-            break;
-
-          case uimenu::properties::ID_ACCELERATOR:
-            uimenu->update_accelerator (uimenup);
-            break;
-
-          case uimenu::properties::ID_CALLBACK:
-            uimenu->update_callback (uimenup);
-            break;
-
-          case uimenu::properties::ID_CHECKED:
-            uimenu->add_to_menu (figp);//rebuilding entire menu
-            break;
-
-          case uimenu::properties::ID_ENABLE:
-            uimenu->update_enable (uimenup);
-            break;
-
-          case uimenu::properties::ID_FOREGROUNDCOLOR:
-            uimenu->update_foregroundcolor (uimenup);
-            break;
-
-          case uimenu::properties::ID_LABEL:
-            uimenu->add_to_menu (figp);//rebuilding entire menu
-            break;
-
-          case uimenu::properties::ID_POSITION:
-            uimenu->add_to_menu (figp);//rebuilding entire menu
-            break;
-
-          case uimenu::properties::ID_SEPARATOR:
-            uimenu->update_seperator (uimenup);
-            break;
-          }
-
-        if (uimenu->items_to_show ())
-          show_menubar ();
-        else
-          hide_menubar ();
-
-        mark_modified ();
-      }
-  }
-
-  void show_canvas (void)
-  {
-    if (fp.is_visible ())
-      {
-        canvas->show ();
-        canvas->make_current ();
-      }
-  }
-
-  void hide_canvas (void)
-  {
-    canvas->hide ();
-  }
-
-  void mark_modified (void)
-  {
-    damage (FL_DAMAGE_ALL);
-    canvas->damage (FL_DAMAGE_ALL);
-    ndim = calc_dimensions (gh_manager::get_object (fp.get___myhandle__ ()));
-
-    if (ndim == 3)
-      rotate->activate ();
-    else if (ndim == 2 && gui_mode == rotate_zoom)
-      {
-        rotate->deactivate ();
-        gui_mode = pan_zoom;
-      }
-  }
-
-  void set_name (void)
-  {
-    window_label = fp.get_title ();
-    label (window_label.c_str ());
-  }
-
-private:
-
-  // No copying!
-
-  plot_window (const plot_window&);
-
-  plot_window& operator = (const plot_window&);
-
-  // window name -- this must exists for the duration of the window's
-  // life
-  std::string window_label;
-
-  // Mod keys status
-  int shift;
-
-  // Number of dimensions, 2 or 3.
-  int ndim;
-
-  // Figure properties.
-  figure::properties& fp;
-
-  // Status area height.
-  static const int status_h = 20;
-
-  // Menu height
-  static const int menu_h = 20;
-
-  // Window callback.
-  static void window_close (Fl_Widget*, void* data)
-  {
-    octave_value_list args;
-    args(0) = static_cast<plot_window*> (data)->number ();
-    feval ("close", args);
-  }
-
-  // Button callbacks.
-  static void button_callback (Fl_Widget* ww, void* data)
-  {
-    static_cast<plot_window*> (data)->button_press (ww, data);
-  }
-
-  void button_press (Fl_Widget* widg, void*)
-  {
-    if (widg == autoscale)
-      axis_auto ();
-
-    if (widg == togglegrid)
-      toggle_grid ();
-
-    if (widg == panzoom)
-      gui_mode = pan_zoom;
-
-    if (widg == rotate && ndim == 3)
-      gui_mode = rotate_zoom;
-
-    if (widg == help)
-      fl_message ("%s", help_text);
-  }
-
-  fltk_uimenu* uimenu;
-  OpenGL_fltk* canvas;
-  Fl_Box*    bottom;
-  Fl_Button* autoscale;
-  Fl_Button* togglegrid;
-  Fl_Button* panzoom;
-  Fl_Button* rotate;
-  Fl_Button* help;
-  Fl_Output* status;
-  graphics_object ax_obj;
-  int pos_x;
-  int pos_y;
-
-  void axis_auto (void)
-  {
-    octave_value_list args;
-    args(0) = fp.get_currentaxes ().as_octave_value ();
-    args(1) = "auto";
-    feval ("axis", args);
-    mark_modified ();
-  }
-
-  void toggle_grid (void)
-  {
-    octave_value_list args;
-    if (fp.get_currentaxes ().ok ())
-      args(0) = fp.get_currentaxes ().as_octave_value ();
-
-    feval ("grid", args);
-    mark_modified ();
-  }
-
-  void pixel2pos (const graphics_handle& ax, int px, int py, double& xx,
-                  double& yy) const
-  {
-    pixel2pos ( gh_manager::get_object (ax), px, py, xx, yy);
-  }
-
-  void pixel2pos (graphics_object ax, int px, int py, double& xx,
-                  double& yy) const
-  {
-    if (ax && ax.isa ("axes"))
-      {
-        axes::properties& ap =
-          dynamic_cast<axes::properties&> (ax.get_properties ());
-        ColumnVector pp = ap.pixel2coord (px, py);
-        xx = pp(0);
-        yy = pp(1);
-      }
-  }
-
-  graphics_handle pixel2axes_or_ca (int px, int py )
-  {
-    Matrix kids = fp.get_children ();
-    int len = kids.length ();
-
-    for (int k = 0; k < len; k++)
-      {
-        graphics_handle hnd = gh_manager::lookup (kids(k));
-
-        if (hnd.ok ())
-          {
-            graphics_object kid = gh_manager::get_object (hnd);
-
-            if (kid.valid_object () && kid.isa ("axes"))
-              {
-                Matrix bb = kid.get_properties ().get_boundingbox (true);
-
-                if (bb(0) <= px && px < (bb(0)+bb(2))
-                    && bb(1) <= py && py < (bb(1)+bb(3)))
-                  {
-                    return hnd;
-                  }
-              }
-          }
-      }
-    return fp.get_currentaxes ();
-  }
-
-  void pixel2status (const graphics_handle& ax, int px0, int py0,
-                     int px1 = -1, int py1 = -1)
-  {
-    pixel2status (gh_manager::get_object (ax), px0, py0, px1, py1);
-  }
-
-  void pixel2status (graphics_object ax, int px0, int py0,
-                     int px1 = -1, int py1 = -1)
-  {
-    double x0, y0, x1, y1;
-    std::stringstream cbuf;
-    cbuf.precision (4);
-    cbuf.width (6);
-    pixel2pos (ax, px0, py0, x0, y0);
-    cbuf << "[" << x0 << ", " << y0 << "]";
-    if (px1 >= 0)
-      {
-        pixel2pos (ax, px1, py1, x1, y1);
-        cbuf << " -> ["<< x1 << ", " << y1 << "]";
-      }
-
-    status->value (cbuf.str ().c_str ());
-    status->redraw ();
-  }
-
-  void view2status (graphics_object ax)
-  {
-     if (ax && ax.isa ("axes"))
-       {
-         axes::properties& ap =
-           dynamic_cast<axes::properties&> (ax.get_properties ());
-         std::stringstream cbuf;
-         cbuf.precision (4);
-         cbuf.width (6);
-         Matrix v (1,2,0);
-         v = ap.get ("view").matrix_value ();
-         cbuf << "[azimuth: " << v(0) << ", elevation: " << v(1) << "]";
-
-         status->value (cbuf.str ().c_str ());
-         status->redraw ();
-       }
-  }
-
-  void set_currentpoint (int px, int py)
-  {
-    if (!fp.is_beingdeleted ())
-      {
-        Matrix pos (1,2,0);
-        pos(0) = px;
-        pos(1) = h () - status_h - menu_h - py;
-        fp.set_currentpoint (pos);
-      }
-  }
-
-  void set_axes_currentpoint (graphics_object ax, int px, int py)
-  {
-    if (ax.valid_object ())
-      {
-        axes::properties& ap =
-          dynamic_cast<axes::properties&> (ax.get_properties ());
-
-        double xx, yy;
-        pixel2pos (ax, px, py, xx, yy);
-
-        Matrix pos (2,3,0);
-        pos(0,0) = xx;
-        pos(1,0) = yy;
-        pos(0,1) = xx;
-        pos(1,1) = yy;
-
-        ap.set_currentpoint (pos);
-      }
-  }
-
-  int key2shift (int key)
-  {
-    if (key == FL_Shift_L || key == FL_Shift_R)
-      return FL_SHIFT;
-
-    if (key == FL_Control_L || key == FL_Control_R)
-      return FL_CTRL;
-
-    if (key == FL_Alt_L || key == FL_Alt_R)
-      return FL_ALT;
-
-    if (key == FL_Meta_L || key == FL_Meta_R)
-      return FL_META;
-
-    return 0;
-  }
-
-  int key2ascii (int key)
-  {
-    if (key < 256) return key;
-    if (key == FL_Tab) return '\t';
-    if (key == FL_Enter) return 0x0a;
-    if (key == FL_BackSpace) return 0x08;
-    if (key == FL_Escape) return 0x1b;
-
-    return 0;
-  }
-
-  Cell modifier2cell ()
-  {
-    string_vector mod;
-
-    if (shift & FL_SHIFT)
-      mod.append (std::string ("shift"));
-    if (shift & FL_CTRL)
-      mod.append (std::string ("control"));
-    if (shift & FL_ALT || shift & FL_META)
-      mod.append (std::string ("alt"));
-
-    return Cell (mod);
-  }
-
-  void resize (int xx,int yy,int ww,int hh)
-  {
-    Fl_Window::resize (xx, yy, ww, hh);
-
-    Matrix pos (1,4,0);
-    pos(0) = xx;
-    pos(1) = yy;
-    pos(2) = ww;
-    pos(3) = hh - status_h - menu_h;
-
-    fp.set_boundingbox (pos, true);
-  }
-
-  void draw (void)
-  {
-    Matrix pos = fp.get_boundingbox (true);
-    Fl_Window::resize (pos(0), pos(1), pos(2), pos(3) + status_h + menu_h);
-
-    return Fl_Window::draw ();
-  }
-
-  int handle (int event)
-  {
-    graphics_handle gh;
-
-    graphics_object fig = gh_manager::get_object (fp.get___myhandle__ ());
-    int retval = Fl_Window::handle (event);
-
-    // We only handle events which are in the canvas area.
-    if (!Fl::event_inside (canvas))
-      return retval;
-
-    if (!fp.is_beingdeleted ())
-      {
-        switch (event)
-          {
-          case FL_KEYDOWN:
-            {
-              int key = Fl::event_key ();
-
-              shift |= key2shift (key);
-              int key_a = key2ascii (key);
-              if (key_a && fp.get_keypressfcn ().is_defined ())
-                {
-                  Octave_map evt;
-                  evt.assign ("Character", octave_value (key_a));
-                  evt.assign ("Key", octave_value (std::tolower (key_a)));
-                  evt.assign ("Modifier", octave_value (modifier2cell ()));
-                  fp.execute_keypressfcn (evt);
-                }
-              switch (key)
-                {
-                case 'a':
-                case 'A':
-                  axis_auto ();
-                break;
-
-                case 'g':
-                case 'G':
-                  toggle_grid ();
-                break;
-
-                case 'p':
-                case 'P':
-                  gui_mode = pan_zoom;
-                break;
-
-                case 'r':
-                case 'R':
-                  gui_mode = rotate_zoom;
-                break;
-                }
-            }
-            break;
-
-          case FL_KEYUP:
-            {
-              int key = Fl::event_key ();
-
-              shift &= (~key2shift (key));
-              int key_a = key2ascii (key);
-              if (key_a && fp.get_keyreleasefcn ().is_defined ())
-                {
-                  Octave_map evt;
-                  evt.assign ("Character", octave_value (key_a));
-                  evt.assign ("Key", octave_value (std::tolower (key_a)));
-                  evt.assign ("Modifier", octave_value (modifier2cell ()));
-                  fp.execute_keyreleasefcn (evt);
-                }
-            }
-            break;
-
-          case FL_MOVE:
-            pixel2status (pixel2axes_or_ca (Fl::event_x (), Fl::event_y ()),
-                          Fl::event_x (), Fl::event_y ());
-            break;
-
-          case FL_PUSH:
-            pos_x = Fl::event_x ();
-            pos_y = Fl::event_y ();
-
-            set_currentpoint (Fl::event_x (), Fl::event_y ());
-
-            gh = pixel2axes_or_ca (pos_x, pos_y);
-
-            if (gh.ok ())
-              {
-                ax_obj = gh_manager::get_object (gh);
-                set_axes_currentpoint (ax_obj, pos_x, pos_y);
-              }
-
-            fp.execute_windowbuttondownfcn ();
-
-            if (Fl::event_button () == 1 || Fl::event_button () == 3)
-              return 1;
-
-            break;
-
-          case FL_DRAG:
-            if (fp.get_windowbuttonmotionfcn ().is_defined ())
-              {
-                set_currentpoint (Fl::event_x (), Fl::event_y ());
-                fp.execute_windowbuttonmotionfcn ();
-              }
-
-            if (Fl::event_button () == 1)
-              {
-                if (ax_obj && ax_obj.isa ("axes"))
-                  {
-                    if (gui_mode == pan_zoom)
-                      pixel2status (ax_obj, pos_x, pos_y,
-                                    Fl::event_x (), Fl::event_y ());
-                    else
-                      view2status (ax_obj);
-                    axes::properties& ap =
-                      dynamic_cast<axes::properties&> (ax_obj.get_properties ());
-
-                    double x0, y0, x1, y1;
-                    Matrix pos = fp.get_boundingbox (true);
-                    pixel2pos (ax_obj, pos_x, pos_y, x0, y0);
-                    pixel2pos (ax_obj, Fl::event_x (), Fl::event_y (), x1, y1);
-
-                    if (gui_mode == pan_zoom)
-                      ap.translate_view (x0, x1, y0, y1);
-                    else if (gui_mode == rotate_zoom)
-                      {
-                        double daz, del;
-                        daz = (Fl::event_x () - pos_x) / pos(2) * 360;
-                        del = (Fl::event_y () - pos_y) / pos(3) * 360;
-                        ap.rotate_view (del, daz);
-                      }
-
-                    pos_x = Fl::event_x ();
-                    pos_y = Fl::event_y ();
-                    mark_modified ();
-                  }
-                return 1;
-              }
-            else if (Fl::event_button () == 3)
-              {
-                pixel2status (ax_obj, pos_x, pos_y,
-                              Fl::event_x (), Fl::event_y ());
-                Matrix zoom_box (1,4,0);
-                zoom_box (0) = pos_x;
-                zoom_box (1) = pos_y;
-                zoom_box (2) =  Fl::event_x ();
-                zoom_box (3) =  Fl::event_y ();
-                canvas->set_zoom_box (zoom_box);
-                canvas->zoom (true);
-                canvas->redraw ();
-              }
-
-            break;
-
-          case FL_MOUSEWHEEL:
-            {
-              graphics_object ax =
-                gh_manager::get_object (pixel2axes_or_ca (Fl::event_x (),
-                                                          Fl::event_y ()));
-              if (ax && ax.isa ("axes"))
-                {
-                  axes::properties& ap =
-                    dynamic_cast<axes::properties&> (ax.get_properties ());
-
-                  // Determine if we're zooming in or out.
-                  const double factor =
-                    (Fl::event_dy () > 0) ? 1.0 + wheel_zoom_speed : 1.0 - wheel_zoom_speed;
-
-                  // Get the point we're zooming about.
-                  double x1, y1;
-                  pixel2pos (ax, Fl::event_x (), Fl::event_y (), x1, y1);
-
-                  ap.zoom_about_point (x1, y1, factor, false);
-                  mark_modified ();
-                }
-            }
-          return 1;
-
-          case FL_RELEASE:
-            if (fp.get_windowbuttonupfcn ().is_defined ())
-              {
-                set_currentpoint (Fl::event_x (), Fl::event_y ());
-                fp.execute_windowbuttonupfcn ();
-              }
-
-            if (Fl::event_button () == 1)
-              {
-                if ( Fl::event_clicks () == 1)
-                  {
-                    if (ax_obj && ax_obj.isa ("axes"))
-                      {
-                        axes::properties& ap =
-                          dynamic_cast<axes::properties&> (ax_obj.get_properties ());
-                        ap.set_xlimmode ("auto");
-                        ap.set_ylimmode ("auto");
-                        ap.set_zlimmode ("auto");
-                        mark_modified ();
-                      }
-                  }
-              }
-            if (Fl::event_button () == 3)
-              {
-                // End of drag -- zoom.
-                if (canvas->zoom ())
-                  {
-                    canvas->zoom (false);
-                    double x0,y0,x1,y1;
-                    if (ax_obj && ax_obj.isa ("axes"))
-                      {
-                        axes::properties& ap =
-                          dynamic_cast<axes::properties&> (ax_obj.get_properties ());
-                        pixel2pos (ax_obj, pos_x, pos_y, x0, y0);
-                        int pos_x1 = Fl::event_x ();
-                        int pos_y1 = Fl::event_y ();
-                        pixel2pos (ax_obj, pos_x1, pos_y1, x1, y1);
-                        Matrix xl (1,2,0);
-                        Matrix yl (1,2,0);
-                        int dx = abs (pos_x - pos_x1);
-                        int dy = abs (pos_y - pos_y1);
-                        // Smallest zoom box must be 4 pixels square
-                        if ((dx > 4) && (dy > 4))
-                          {
-                            if (x0 < x1)
-                              {
-                                xl(0) = x0;
-                                xl(1) = x1;
-                              }
-                            else
-                              {
-                                xl(0) = x1;
-                                xl(1) = x0;
-                              }
-                            if (y0 < y1)
-                              {
-                                yl(0) = y0;
-                                yl(1) = y1;
-                              }
-                            else
-                              {
-                                yl(0) = y1;
-                                yl(1) = y0;
-                              }
-                            ap.zoom (xl, yl);
-                          }
-                        mark_modified ();
-                      }
-                  }
-              }
-            break;
-          }
-      }
-
-    return retval;
-  }
-};
-
-class figure_manager
-{
-public:
-
-  static bool instance_ok (void)
-  {
-    bool retval = true;
-
-    if (! instance)
-      instance = new figure_manager ();
-
-    if (! instance)
-      {
-        ::error ("unable to create figure_manager object!");
-
-        retval = false;
-      }
-
-    return retval;
-  }
-
-  ~figure_manager (void)
-  {
-    close_all ();
-  }
-
-  static void close_all (void)
-  {
-    if (instance_ok ())
-      instance->do_close_all ();
-  }
-
-  static void new_window (figure::properties& fp)
-  {
-    if (instance_ok ())
-      instance->do_new_window (fp);
-  }
-
-  static void delete_window (int idx)
-  {
-    if (instance_ok ())
-      instance->do_delete_window (idx);
-  }
-
-  static void delete_window (const std::string& idx_str)
-  {
-    delete_window (str2idx (idx_str));
-  }
-
-  static void renumber_figure (const std::string& idx_str, double new_number)
-  {
-    if (instance_ok ())
-      instance->do_renumber_figure (str2idx (idx_str), new_number);
-  }
-
-  static void toggle_window_visibility (int idx, bool is_visible)
-  {
-    if (instance_ok ())
-      instance->do_toggle_window_visibility (idx, is_visible);
-  }
-
-  static void toggle_window_visibility (const std::string& idx_str,
-                                        bool is_visible)
-  {
-    toggle_window_visibility (str2idx (idx_str), is_visible);
-  }
-
-  static void mark_modified (int idx)
-  {
-    if (instance_ok ())
-      instance->do_mark_modified (idx);
-  }
-
-  static void mark_modified (const graphics_handle& gh)
-  {
-    mark_modified (hnd2idx (gh));
-  }
-
-  static void set_name (int idx)
-  {
-    if (instance_ok ())
-      instance->do_set_name (idx);
-  }
-
-  static void set_name (const std::string& idx_str)
-  {
-    set_name (str2idx (idx_str));
-  }
-
-  static Matrix get_size (int idx)
-  {
-    return instance_ok () ? instance->do_get_size (idx) : Matrix ();
-  }
-
-  static Matrix get_size (const graphics_handle& gh)
-  {
-    return get_size (hnd2idx (gh));
-  }
-
-  static void print (const graphics_handle& gh, const std::string& cmd,
-                     const std::string& term)
-  {
-    if (instance_ok ())
-      instance->do_print (hnd2idx (gh), cmd, term);
-  }
-
-  static void uimenu_update (const graphics_handle& figh,
-                             const graphics_handle& uimenuh, int id)
-  {
-    if (instance_ok ())
-      instance->do_uimenu_update (hnd2idx (figh), uimenuh, id);
-  }
-
-  static void update_canvas (const graphics_handle& gh,
-                             const graphics_handle& ca)
-  {
-    if (instance_ok ())
-      instance->do_update_canvas (hnd2idx (gh), ca);
-  }
-
-  static void toggle_menubar_visibility (int fig_idx, bool menubar_is_figure)
-  {
-    if (instance_ok ())
-      instance->do_toggle_menubar_visibility (fig_idx, menubar_is_figure);
-  }
-
-  static void toggle_menubar_visibility (const std::string& fig_idx_str,
-                                         bool menubar_is_figure)
-  {
-    toggle_menubar_visibility (str2idx (fig_idx_str), menubar_is_figure);
-  }
-
-private:
-
-  static figure_manager *instance;
-
-  figure_manager (void) { }
-
-  // No copying!
-  figure_manager (const figure_manager&);
-  figure_manager& operator = (const figure_manager&);
-
-  // Singelton -- hide all of the above.
-
-  static int curr_index;
-  typedef std::map<int, plot_window*> window_map;
-  typedef window_map::iterator wm_iterator;;
-  window_map windows;
-
-  static std::string fltk_idx_header;
-
-  void do_close_all (void)
-  {
-    wm_iterator win;
-    for (win = windows.begin (); win != windows.end (); win++)
-      delete win->second;
-    windows.clear ();
-  }
-
-  void do_new_window (figure::properties& fp)
-  {
-    int idx = figprops2idx (fp);
-
-    if (idx >= 0 && windows.find (idx) == windows.end ())
-      {
-        Matrix pos = fp.get_boundingbox (true);
-
-        int x = pos(0);
-        int y = pos(1);
-        int w = pos(2);
-        int h = pos(3);
-
-        idx2figprops (curr_index, fp);
-
-        windows[curr_index++] = new plot_window (x, y, w, h, fp);
-      }
-  }
-
-  void do_delete_window (int idx)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      {
-        delete win->second;
-        windows.erase (win);
-      }
-  }
-
-  void do_renumber_figure (int idx, double new_number)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      win->second->renumber (new_number);
-  }
-
-  void do_toggle_window_visibility (int idx, bool is_visible)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      {
-        if (is_visible)
-          win->second->show ();
-        else
-          win->second->hide ();
-
-        win->second->redraw ();
-      }
-  }
-
-  void do_toggle_menubar_visibility (int fig_idx, bool menubar_is_figure)
-  {
-    wm_iterator win = windows.find (fig_idx);
-
-    if (win != windows.end ())
-      {
-        if (menubar_is_figure)
-          win->second->show_menubar ();
-        else
-          win->second->hide_menubar ();
-
-        win->second->redraw ();
-      }
-  }
-
-  void do_mark_modified (int idx)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      win->second->mark_modified ();
-  }
-
-  void do_set_name (int idx)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      win->second->set_name ();
-  }
-
-  Matrix do_get_size (int idx)
-  {
-    Matrix sz (1, 2, 0.0);
-
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      {
-        sz(0) = win->second->w ();
-        sz(1) = win->second->h ();
-      }
-
-    return sz;
-  }
-
-  void do_print (int idx, const std::string& cmd, const std::string& term)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      win->second->print (cmd, term);
-  }
-
-  void do_uimenu_update (int idx, const graphics_handle& gh, int id)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      win->second->uimenu_update (gh, id);
-  }
-
-  void do_update_canvas (int idx, const graphics_handle& ca)
-  {
-    wm_iterator win = windows.find (idx);
-
-    if (win != windows.end ())
-      {
-        if (ca.ok ())
-          win->second->show_canvas ();
-        else
-          win->second->hide_canvas ();
-      }
-  }
-
-  static int str2idx (const caseless_str& clstr)
-  {
-    int ind;
-    if (clstr.find (fltk_idx_header,0) == 0)
-      {
-        std::istringstream istr (clstr.substr (fltk_idx_header.size ()));
-        if (istr >> ind)
-          return ind;
-      }
-    error ("figure_manager: could not recognize fltk index");
-    return -1;
-  }
-
-  void idx2figprops (int idx, figure::properties& fp)
-  {
-    std::ostringstream ind_str;
-    ind_str << fltk_idx_header << idx;
-    fp.set___plot_stream__ (ind_str.str ());
-  }
-
-  static int figprops2idx (const figure::properties& fp)
-  {
-    if (fp.get___graphics_toolkit__ () == FLTK_GRAPHICS_TOOLKIT_NAME)
-      {
-        octave_value ps = fp.get___plot_stream__ ();
-        if (ps.is_string ())
-          return str2idx (ps.string_value ());
-        else
-          return 0;
-      }
-    error ("figure_manager: figure is not fltk");
-    return -1;
-  }
-
-  static int hnd2idx (double h)
-  {
-    graphics_object fobj = gh_manager::get_object (h);
-    if (fobj &&  fobj.isa ("figure"))
-      {
-        figure::properties& fp =
-          dynamic_cast<figure::properties&> (fobj.get_properties ());
-        return figprops2idx (fp);
-      }
-    error ("figure_manager: H (= %g) is not a figure", h);
-    return -1;
-  }
-
-  static int hnd2idx (const graphics_handle& fh)
-  {
-    return hnd2idx (fh.value ());
-  }
-};
-
-figure_manager *figure_manager::instance = 0;
-
-std::string figure_manager::fltk_idx_header="fltk index=";
-int figure_manager::curr_index = 1;
-
-static bool toolkit_loaded = false;
-
-static int
-__fltk_redraw__ (void)
-{
-  if (toolkit_loaded)
-    {
-      // We scan all figures and add those which use FLTK.
-      graphics_object obj = gh_manager::get_object (0);
-      if (obj && obj.isa ("root"))
-        {
-          base_properties& props = obj.get_properties ();
-          Matrix children = props.get_all_children ();
-
-          for (octave_idx_type n = 0; n < children.numel (); n++)
-            {
-              graphics_object fobj = gh_manager::get_object (children (n));
-              if (fobj && fobj.isa ("figure"))
-                {
-                  figure::properties& fp =
-                      dynamic_cast<figure::properties&> (fobj.get_properties ());
-                  if (fp.get___graphics_toolkit__ ()
-                      == FLTK_GRAPHICS_TOOLKIT_NAME)
-                    figure_manager::new_window (fp);
-                }
-            }
-        }
-
-      // it seems that we have to call Fl::check twice to get everything drawn
-      Fl::check ();
-      Fl::check ();
-    }
-
-  return 0;
-}
-
-class fltk_graphics_toolkit : public base_graphics_toolkit
-{
-public:
-  fltk_graphics_toolkit (void)
-    : base_graphics_toolkit (FLTK_GRAPHICS_TOOLKIT_NAME) { }
-
-  ~fltk_graphics_toolkit (void) { }
-
-  bool is_valid (void) const { return true; }
-
-  bool initialize (const graphics_object& go)
-    { return go.isa ("figure"); }
-
-  void finalize (const graphics_object& go)
-  {
-    if (go.isa ("figure"))
-      {
-        octave_value ov = go.get (caseless_str ("__plot_stream__"));
-
-        if (! ov.is_empty ())
-          figure_manager::delete_window (ov.string_value ());
-      }
-  }
-
-  void uimenu_set_fltk_label (graphics_object uimenu_obj)
-  {
-    if (uimenu_obj.valid_object ())
-      {
-        uimenu::properties& uimenup =
-          dynamic_cast<uimenu::properties&> (uimenu_obj.get_properties ());
-        std::string fltk_label = uimenup.get_label ();
-        graphics_object go = gh_manager::get_object (uimenu_obj.get_parent ());
-        if (go.isa ("uimenu"))
-          fltk_label = dynamic_cast<const uimenu::properties&> (go.get_properties ()).get_fltk_label ()
-            + "/"
-            + fltk_label;
-        else if (go.isa ("figure"))
-          ;
-        else
-          error ("unexpected parent object\n");
-
-        uimenup.set_fltk_label (fltk_label);
-      }
-  }
-
-  void update (const graphics_object& go, int id)
-  {
-    if (go.isa ("figure"))
-      {
-        octave_value ov = go.get (caseless_str ("__plot_stream__"));
-
-        if (! ov.is_empty ())
-          {
-            const figure::properties& fp =
-              dynamic_cast<const figure::properties&> (go.get_properties ());
-
-            switch (id)
-              {
-              case base_properties::ID_VISIBLE:
-                figure_manager::toggle_window_visibility
-                  (ov.string_value (), fp.is_visible ());
-                break;
-
-              case figure::properties::ID_MENUBAR:
-                figure_manager::toggle_menubar_visibility
-                  (ov.string_value (), fp.menubar_is ("figure"));
-                break;
-
-              case figure::properties::ID_CURRENTAXES:
-                figure_manager::update_canvas
-                  (go.get_handle (), fp.get_currentaxes ());
-                break;
-
-              case figure::properties::ID_NAME:
-              case figure::properties::ID_NUMBERTITLE:
-                figure_manager::set_name (ov.string_value ());
-                break;
-
-              case figure::properties::ID_INTEGERHANDLE:
-                {
-                  std::string tmp = ov.string_value ();
-                  graphics_handle gh = fp.get___myhandle__ ();
-                  figure_manager::renumber_figure (tmp, gh.value ());
-                  figure_manager::set_name (tmp);
-                }
-                break;
-              }
-          }
-      }
-    else if (go.isa ("uimenu"))
-      {
-        if (id == uimenu::properties::ID_LABEL)
-          uimenu_set_fltk_label (go);
-
-        graphics_object fig = go.get_ancestor ("figure");
-        figure_manager::uimenu_update (fig.get_handle (), go.get_handle (), id);
-      }
-  }
-
-  void redraw_figure (const graphics_object& go) const
-  {
-    figure_manager::mark_modified (go.get_handle ());
-
-    __fltk_redraw__ ();
-  }
-
-  void print_figure (const graphics_object& go,
-                     const std::string& term,
-                     const std::string& file_cmd, bool /*mono*/,
-                     const std::string& /*debug_file*/) const
-  {
-    figure_manager::print (go.get_handle (), file_cmd, term);
-    redraw_figure (go);
-  }
-
-  Matrix get_canvas_size (const graphics_handle& fh) const
-  {
-    return figure_manager::get_size (fh);
-  }
-
-  double get_screen_resolution (void) const
-  {
-    // FLTK doesn't give this info.
-    return 72.0;
-  }
-
-  Matrix get_screen_size (void) const
-  {
-    Matrix sz (1, 2, 0.0);
-    sz(0) = Fl::w ();
-    sz(1) = Fl::h ();
-    return sz;
-  }
-
-  void close (void)
-  {
-    if (toolkit_loaded)
-      {
-        munlock ("__init_fltk__");
-
-        figure_manager::close_all ();
-        gtk_manager::unload_toolkit (FLTK_GRAPHICS_TOOLKIT_NAME);
-        toolkit_loaded = false;
-
-        octave_value_list args;
-        args(0) = "__fltk_redraw__";
-        feval ("remove_input_event_hook", args, 0);
-
-        // FIXME ???
-        Fl::wait (fltk_maxtime);
-      }
-  }
-};
-
-// Initialize the fltk graphics toolkit.
-
-DEFUN_DLD (__init_fltk__, , , "")
-{
-  if (! toolkit_loaded)
-    {
-      mlock ();
-
-      graphics_toolkit tk (new fltk_graphics_toolkit ());
-      gtk_manager::load_toolkit (tk);
-      toolkit_loaded = true;
-
-      octave_value_list args;
-      args(0) = "__fltk_redraw__";
-      feval ("add_input_event_hook", args, 0);
-    }
-
-  octave_value retval;
-  return retval;
-}
-
-DEFUN_DLD (__fltk_redraw__, , , "")
-{
-  __fltk_redraw__ ();
-
-  return octave_value ();
-}
-
-DEFUN_DLD (__fltk_maxtime__, args, ,"")
-{
-  octave_value retval = fltk_maxtime;
-
-  if (args.length () == 1)
-    {
-      if (args(0).is_real_scalar ())
-        fltk_maxtime = args(0).double_value ();
-      else
-        error ("argument must be a real scalar");
-    }
-
-  return retval;
-}
-
-#endif
-
-// FIXME -- This function should be abstracted and made potentially
-// available to all graphics toolkits.  This suggests putting it in
-// graphics.cc as is done for drawnow() and having the master
-// mouse_wheel_zoom function call fltk_mouse_wheel_zoom.  The same
-// should be done for gui_mode and fltk_gui_mode.  For now (2011.01.30),
-// just changing function names and docstrings.
-
-DEFUN_DLD (mouse_wheel_zoom, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn  {Built-in Function} {@var{speed} =} mouse_wheel_zoom ()\n\
-@deftypefnx {Built-in Function} {} mouse_wheel_zoom (@var{speed})\n\
-Query or set the mouse wheel zoom factor.\n\
-\n\
-This function is currently implemented only for the FLTK graphics toolkit.\n\
-@seealso{gui_mode}\n\
-@end deftypefn")
-{
-#if defined (HAVE_FLTK)
-  octave_value retval = wheel_zoom_speed;
-
-  if (args.length () == 1)
-    {
-      if (args(0).is_real_scalar ())
-        wheel_zoom_speed = args(0).double_value ();
-      else
-        error ("mouse_wheel_zoom: SPEED must be a real scalar");
-    }
-
-  return retval;
-#else
-  error ("mouse_wheel_zoom: not available without OpenGL and FLTK libraries");
-  return octave_value ();
-#endif
-}
-
-DEFUN_DLD (gui_mode, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn  {Built-in Function} {@var{mode} =} gui_mode ()\n\
-@deftypefnx {Built-in Function} {} gui_mode (@var{mode})\n\
-Query or set the GUI mode for the current graphics toolkit.\n\
-The @var{mode} argument can be one of the following strings:\n\
-\n\
-@table @asis\n\
-@item '2d'\n\
-Allows panning and zooming of current axes.\n\
-\n\
-@item '3d'\n\
-Allows rotating and zooming of current axes.\n\
-\n\
-@item 'none'\n\
-Mouse inputs have no effect.\n\
-@end table\n\
-\n\
-This function is currently implemented only for the FLTK graphics toolkit.\n\
-@seealso{mouse_wheel_zoom}\n\
-@end deftypefn")
-{
-#if defined (HAVE_FLTK)
-  caseless_str mode_str;
-
-  if (gui_mode == pan_zoom)
-    mode_str = "2d";
-  else if (gui_mode == rotate_zoom)
-    mode_str = "3d";
-  else
-    mode_str = "none";
-
-  bool failed = false;
-
-  if (args.length () == 1)
-    {
-      if (args(0).is_string ())
-        {
-          mode_str = args(0).string_value ();
-
-          if (mode_str.compare ("2d"))
-            gui_mode = pan_zoom;
-          else if (mode_str.compare ("3d"))
-            gui_mode = rotate_zoom;
-          else if (mode_str.compare ("none"))
-            gui_mode = none;
-          else
-            failed = true;
-        }
-      else
-        failed = true;
-    }
-
-  if (failed)
-    error ("MODE must be one of the strings: \"2D\", \"3D\", or \"none\"");
-
-  return octave_value (mode_str);
-#else
-  error ("mouse_wheel_zoom: not available without OpenGL and FLTK libraries");
-  return octave_value ();
-#endif
-}
-

--- a/src/DLD-FUNCTIONS/__init_gnuplot__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,193 +0,0 @@
-/*
-
-Copyright (C) 2007-2012 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/>.
-
-*/
-
-/*
-
-To initialize:
-
-  graphics_toolkit ("gnuplot");
-  plot (randn (1e3, 1));
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "defun-dld.h"
-#include "error.h"
-#include "graphics.h"
-#include "parse.h"
-#include "variables.h"
-
-// PKG_ADD: register_graphics_toolkit ("gnuplot");
-
-static bool toolkit_loaded = false;
-
-class gnuplot_graphics_toolkit : public base_graphics_toolkit
-{
-public:
-  gnuplot_graphics_toolkit (void)
-      : base_graphics_toolkit ("gnuplot") { }
-
-  ~gnuplot_graphics_toolkit (void) { }
-
-  bool is_valid (void) const { return true; }
-
-  bool initialize (const graphics_object& go)
-    {
-      return go.isa ("figure");
-    }
-
-  void finalize (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 update (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::ID_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); }
-
-  void close (void)
-  {
-    if (toolkit_loaded)
-      {
-        munlock ("__init_gnuplot__");
-
-        gtk_manager::unload_toolkit ("gnuplot");
-
-        toolkit_loaded = false;
-      }
-  }
-
-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) = fids(0);
-              feval ("fputs", args);
-
-              args.resize (1);
-              feval ("fflush", args);
-              feval ("pclose", args);
-
-              if (fids.numel () > 1)
-                {
-                  args(0) = fids(1);
-                  feval ("pclose", args);
-
-                  if (fids.numel () > 2)
-                    {
-                      args(0) = fids(2);
-                      feval ("waitpid", args);
-                    }
-                }
-            }
-        }
-    }
-};
-
-// Initialize the fltk graphics toolkit.
-
-DEFUN_DLD (__init_gnuplot__, , , "")
-{
-  octave_value retval;
-
-  if (! toolkit_loaded)
-    {
-      mlock ();
-
-      graphics_toolkit tk (new gnuplot_graphics_toolkit ());
-      gtk_manager::load_toolkit (tk);
-
-      toolkit_loaded = true;
-    }
-
-  return retval;
-}
-

--- a/src/DLD-FUNCTIONS/__magick_read__.cc	Tue Jul 31 20:46:47 2012 -0400
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1216 +0,0 @@
-/*
-
-Copyright (C) 2002-2012 Andy Adler
-Copyright (C) 2008 Thomas L. Scofield
-Copyright (C) 2010 David Grundberg
-
-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 <cmath>
-
-#include "file-stat.h"
-#include "oct-env.h"
-#include "oct-time.h"
-
-#include "defun-dld.h"
-#include "error.h"
-#include "ov-struct.h"
-
-#ifdef HAVE_MAGICK
-
-#include <Magick++.h>
-#include <clocale>
-
-octave_value_list
-read_indexed_images (std::vector<Magick::Image>& imvec,
-                     const Array<int>& frameidx, bool wantalpha)
-{
-  octave_value_list output;
-
-  int rows = imvec[0].baseRows ();
-  int columns = imvec[0].baseColumns ();
-  int nframes = frameidx.length ();
-
-  dim_vector idim = dim_vector ();
-  idim.resize (4);
-  idim(0) = rows;
-  idim(1) = columns;
-  idim(2) = 1;
-  idim(3) = nframes;
-
-  Array<int> idx (dim_vector (4, 1));
-
-  Magick::ImageType type = imvec[0].type ();
-
-  unsigned int mapsize = imvec[0].colorMapSize ();
-  unsigned int i = mapsize;
-  unsigned int depth = 0;
-  while (i >>= 1)
-    depth++;
-  i = 0;
-  depth--;
-  while (depth >>= 1)
-    i++;
-  depth = 1 << i;
-
-  switch (depth)
-    {
-    case 1:
-    case 2:
-    case 4:
-    case 8:
-      {
-        uint8NDArray im = uint8NDArray (idim);
-
-        idx(2) = 0;
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            const Magick::IndexPacket *pix
-              = imvec[frameidx(frame)].getConstIndexes ();
-
-            i = 0;
-            idx(3) = frame;
-
-            for (int y = 0; y < rows; y++)
-              {
-                idx(0) = y;
-                for (int x = 0; x < columns; x++)
-                  {
-                    idx(1) = x;
-                    im(idx) = static_cast<octave_uint8> (pix[i++]);
-                  }
-              }
-          }
-
-        output(0) = octave_value (im);
-      }
-      break;
-
-    case 16:
-      {
-        uint16NDArray im = uint16NDArray (idim);
-
-        idx(2) = 0;
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            const Magick::IndexPacket *pix
-              = imvec[frameidx(frame)].getConstIndexes ();
-
-            i = 0;
-            idx(3) = frame;
-
-            for (int y = 0; y < rows; y++)
-              {
-                idx(0) = y;
-                for (int x = 0; x < columns; x++)
-                  {
-                    idx(1) = x;
-                    im(idx) = static_cast<octave_uint16> (pix[i++]);
-                  }
-              }
-          }
-
-        output(0) = octave_value (im);
-      }
-      break;
-
-    default:
-      error ("__magic_read__: index depths greater than 16-bit are not supported");
-      return octave_value_list ();
-    }
-
-  Matrix map = Matrix (mapsize, 3);
-  Matrix alpha;
-
-  switch (type)
-    {
-    case Magick::PaletteMatteType:
-#if 0
-      warning ("palettematte");
-      Matrix map (mapsize, 3);
-      Matrix alpha (mapsize, 1);
-      for (i = 0; i < mapsize; i++)
-        {
-          warning ("%d", i);
-          Magick::ColorRGB c = imvec[0].colorMap (i);
-          map(i,0) = c.red ();
-          map(i,1) = c.green ();
-          map(i,2) = c.blue ();
-          alpha(i,1) = c.alpha ();
-        }
-      break;
-#endif
-
-    case Magick::PaletteType:
-      alpha = Matrix (0, 0);
-      for (i = 0; i < mapsize; i++)
-        {
-          Magick::ColorRGB c = imvec[0].colorMap (i);
-          map(i,0) = c.red ();
-          map(i,1) = c.green ();
-          map(i,2) = c.blue ();
-        }
-      break;
-
-    default:
-      error ("__magick_read__: unsupported indexed image type");
-      return octave_value_list ();
-    }
-
-  if (wantalpha)
-    output(2) = alpha;
-
-  output(1) = map;
-
-  return output;
-}
-
-template <class T>
-octave_value_list
-read_images (const std::vector<Magick::Image>& imvec,
-             const Array<int>& frameidx, unsigned int depth)
-{
-  typedef typename T::element_type P;
-
-  octave_value_list retval (3, Matrix ());
-
-  T im;
-
-  int rows = imvec[0].baseRows ();
-  int columns = imvec[0].baseColumns ();
-  int nframes = frameidx.length ();
-
-  dim_vector idim = dim_vector ();
-  idim.resize (4);
-  idim(0) = rows;
-  idim(1) = columns;
-  idim(2) = 1;
-  idim(3) = nframes;
-
-  Magick::ImageType type = imvec[0].type ();
-  const int divisor = ((uint64_t (1) << QuantumDepth) - 1) / 
-                      ((uint64_t (1) << depth) - 1);
-
-  switch (type)
-    {
-    case Magick::BilevelType:
-    case Magick::GrayscaleType:
-      {
-        im = T (idim);
-        P *vec = im.fortran_vec ();
-
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            const Magick::PixelPacket *pix
-              = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            P *rbuf = vec;
-            for (int y = 0; y < rows; y++)
-              {
-                for (int x = 0; x < columns; x++)
-                  {
-                    *rbuf = pix->red / divisor;
-                    pix++;
-                    rbuf += rows;
-                  }
-                rbuf -= rows * columns - 1;
-              }
-
-            // Next frame.
-            vec += rows * columns * idim(2);
-          }
-        }
-      break;
-
-    case Magick::GrayscaleMatteType:
-      {
-        idim(2) = 2;
-        im = T (idim);
-        P *vec = im.fortran_vec ();
-
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            const Magick::PixelPacket *pix
-              = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            P *rbuf = vec;
-            P *obuf = vec + rows * columns;
-            for (int y = 0; y < rows; y++)
-              {
-                for (int x = 0; x < columns; x++)
-                  {
-                    *rbuf = pix->red / divisor;
-                    *obuf = pix->opacity / divisor;
-                    pix++;
-                    rbuf += rows;
-                    obuf += rows;
-                  }
-                rbuf -= rows * columns - 1;
-                obuf -= rows * columns - 1;
-              }
-
-            // Next frame.
-            vec += rows * columns * idim(2);
-          }
-        }
-      break;
-
-    case Magick::PaletteType:
-    case Magick::TrueColorType:
-      {
-        idim(2) = 3;
-        im = T (idim);
-        P *vec = im.fortran_vec ();
-
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            const Magick::PixelPacket *pix
-              = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            P *rbuf = vec;
-            P *gbuf = vec + rows * columns;
-            P *bbuf = vec + rows * columns * 2;
-            for (int y = 0; y < rows; y++)
-              {
-                for (int x = 0; x < columns; x++)
-                  {
-                    *rbuf = pix->red / divisor;
-                    *gbuf = pix->green / divisor;
-                    *bbuf = pix->blue / divisor;
-                    pix++;
-                    rbuf += rows;
-                    gbuf += rows;
-                    bbuf += rows;
-                  }
-                rbuf -= rows * columns - 1;
-                gbuf -= rows * columns - 1;
-                bbuf -= rows * columns - 1;
-              }
-
-            // Next frame.
-            vec += rows * columns * idim(2);
-          }
-        }
-      break;
-
-    case Magick::PaletteMatteType:
-    case Magick::TrueColorMatteType:
-    case Magick::ColorSeparationType:
-      {
-        idim(2) = 4;
-        im = T (idim);
-        P *vec = im.fortran_vec ();
-
-        for (int frame = 0; frame < nframes; frame++)
-          {
-            const Magick::PixelPacket *pix
-              = imvec[frameidx(frame)].getConstPixels (0, 0, columns, rows);
-
-            P *rbuf = vec;
-            P *gbuf = vec + rows * columns;
-            P *bbuf = vec + rows * columns * 2;
-            P *obuf = vec + rows * columns * 3;
-            for (int y = 0; y < rows; y++)
-              {
-                for (int x = 0; x < columns; x++)
-                  {
-                    *rbuf = pix->red / divisor;
-                    *gbuf = pix->green / divisor;
-                    *bbuf = pix->blue / divisor;
-                    *obuf = pix->opacity / divisor;
-                    pix++;
-                    rbuf += rows;
-                    gbuf += rows;
-                    bbuf += rows;
-                    obuf += rows;
-                  }
-                rbuf -= rows * columns - 1;
-                gbuf -= rows * columns - 1;
-                bbuf -= rows * columns - 1;
-                obuf -= rows * columns - 1;
-              }
-
-            // Next frame.
-            vec += rows * columns * idim(2);
-          }
-        }
-      break;
-
-    default:
-      error ("__magick_read__: undefined ImageMagick image type");
-      return retval;
-    }
-
-  retval(0) = im;
-
-  return retval;
-}
-
-#endif
-
-static void
-maybe_initialize_magick (void)
-{
-#ifdef HAVE_MAGICK
-
-  static bool initialized = false;
-
-  if (! initialized)
-    {
-      // Save the locale as GraphicsMagick might change this (depending on version)
-      const char *static_locale = setlocale (LC_ALL, NULL);
-      const std::string locale (static_locale);
-
-      std::string program_name = octave_env::get_program_invocation_name ();
-
-      Magick::InitializeMagick (program_name.c_str ());
-
-      // Restore locale from before GraphicsMagick initialisation
-      setlocale (LC_ALL, locale.c_str ());
-
-      if (QuantumDepth < 32)
-        warning ("your version of %s limits images to %d bits per pixel",
-                 MagickPackageName, QuantumDepth);
-
-      initialized = true;
-    }
-#endif
-}
-
-DEFUN_DLD (__magick_read__, args, nargout,
-  "-*- texinfo -*-\n\
-@deftypefn  {Function File} {@var{m} =} __magick_read__ (@var{fname}, @var{index})\n\
-@deftypefnx {Function File} {[@var{m}, @var{colormap}] =} __magick_read__ (@var{fname}, @var{index})\n\
-@deftypefnx {Function File} {[@var{m}, @var{colormap}, @var{alpha}] =} __magick_read__ (@var{fname}, @var{index})\n\
-Read images with ImageMagick++.  In general you should not be using this\n\
-function.  Instead use @code{imread}.\n\
-@seealso{imread}\n\
-@end deftypefn")
-{
-  octave_value_list output;
-
-#ifdef HAVE_MAGICK
-
-  maybe_initialize_magick ();
-
-  if (args.length () > 3 || args.length () < 1 || ! args(0).is_string ()
-      || nargout > 3)
-    {
-      print_usage ();
-      return output;
-    }
-
-  Array<int> frameidx;
-  bool all_frames = false;
-
-  if (args.length () == 2 && args(1).is_real_type ())
-    frameidx = args(1).int_vector_value ();
-  else if (args.length () == 3 && args(1).is_string ()
-           && args(1).string_value () == "frames")
-    {
-      if (args(2).is_string () && args(2).string_value () == "all")
-        all_frames = true;
-      else if (args(2).is_real_type ())
-        frameidx = args(2).int_vector_value ();
-    }
-  else
-    {
-      frameidx = Array<int> (dim_vector (1, 1));
-      frameidx(0) = 1;
-    }
-
-  std::vector<Magick::Image> imvec;
-
-  try
-    {
-      // Read a file into vector of image objects
-      Magick::readImages (&imvec, args(0).string_value ());
-    }
-  catch (Magick::Warning& w)
-    {
-      warning ("Magick++ warning: %s", w.what ());
-    }
-  catch (Magick::ErrorCoder& e)
-    {
-      warning ("Magick++ coder error: %s", e.what ());
-    }
-  catch (Magick::Exception& e)
-    {
-      error ("Magick++ exception: %s", e.what ());
-      return output;
-    }
-
-  int nframes = imvec.size ();
-  if (all_frames)
-    {
-      frameidx = Array<int> (dim_vector (1, nframes));
-      for (int i = 0; i < frameidx.length (); i++)
-        frameidx(i) = i;
-    }
-  else
-    {
-      for (int i = 0; i < frameidx.length (); i++)
-        {
-          frameidx(i) = frameidx(i) - 1;
-
-          if (frameidx(i) >= nframes || frameidx(i) < 0)
-            {
-              error ("__magick_read__: invalid INDEX vector");
-              return output;
-            }
-        }
-    }
-
-  Magick::ClassType klass = imvec[0].classType ();
-
-  if (klass == Magick::PseudoClass && nargout > 1)
-    output = read_indexed_images (imvec, frameidx, (nargout == 3));
-  else
-    {
-      unsigned int depth = imvec[0].modulusDepth ();
-      if (depth > 1)
-        {
-          --depth;
-          int i = 1;
-          while (depth >>= 1)
-            i++;
-          depth = 1 << i;
-        }
-
-      switch (depth)
-        {
-        case 1:
-          output = read_images<boolNDArray> (imvec, frameidx, depth);
-          break;
-
-        case 2:
-        case 4:
-        case 8:
-          output = read_images<uint8NDArray> (imvec, frameidx, depth) ;
-          break;
-
-        case 16:
-          output = read_images<uint16NDArray> (imvec, frameidx, depth);
-          break;
-
-        case 32:
-        case 64:
-        default:
-          error ("__magick_read__: image depths greater than 16-bit are not supported");
-        }
-    }
-#else
-
-  error ("imread: image reading capabilities were disabled when Octave was compiled");
-
-#endif
-
-  return output;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/
-
-#ifdef HAVE_MAGICK
-
-static void
-jpg_settings (std::vector<Magick::Image>& imvec,
-              const Octave_map& options,
-              bool)
-{
-  bool something_set = false;
-
-  // Quality setting
-  octave_value result;
-  Octave_map::const_iterator p;
-  bool found_it = false;
-
-  for (p = options.begin (); p != options.end (); p++)
-    {
-      if (options.key (p) == "Quality")
-        {
-          found_it = true;
-          result = options.contents (p).elem (0);
-          break;
-        }
-    }
-
-  if (found_it && (! result.is_empty ()))
-    {
-      something_set = true;
-
-      if (result.is_real_type ())
-        {
-          int qlev = result.int_value ();
-
-          if (qlev < 0 || qlev > 100)
-            warning ("warning: Quality setting invalid--use default of 75");
-          else
-            {
-              for (size_t fnum = 0; fnum < imvec.size (); fnum++)
-                imvec[fnum].quality (static_cast<unsigned int>(qlev));
-            }
-        }
-      else
-        warning ("warning: Quality setting invalid--use default of 75");
-    }
-
-  // Other settings go here
-
-  if (! something_set)
-    warning ("__magick_write__ warning: all write parameters ignored");
-}
-
-static void
-encode_bool_image (std::vector<Magick::Image>& imvec, const octave_value& img)
-{
-  unsigned int nframes = 1;
-  boolNDArray m = img.bool_array_value ();
-
-  dim_vector dsizes = m.dims ();
-  if (dsizes.length () == 4)
-    nframes = dsizes(3);
-
-  Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
-
-  octave_idx_type rows = m.rows ();
-  octave_idx_type columns = m.columns ();
-
-  for (unsigned int ii = 0; ii < nframes; ii++)
-    {
-      Magick::Image im (Magick::Geometry (columns, rows), "black");
-      im.classType (Magick::DirectClass);
-      im.depth (1);
-
-      for (int y = 0; y < columns; y++)
-        {
-          idx(1) = y;
-
-          for (int x = 0; x < rows; x++)
-            {
-              if (nframes > 1)
-                {
-                  idx(2) = 0;
-                  idx(3) = ii;
-                }
-
-              idx(0) = x;
-
-              if (m(idx))
-                im.pixelColor (y, x, "white");
-            }
-        }
-
-      im.quantizeColorSpace (Magick::GRAYColorspace);
-      im.quantizeColors (2);
-      im.quantize ();
-
-      imvec.push_back (im);
-    }
-}
-
-template <class T>
-static void
-encode_uint_image (std::vector<Magick::Image>& imvec,
-                   const octave_value& img,
-                   bool has_map)
-{
-  unsigned int bitdepth = 0;
-  T m;
-
-  if (img.is_uint8_type ())
-    {
-      bitdepth = 8;
-      m = img.uint8_array_value ();
-    }
-  else if (img.is_uint16_type ())
-    {
-      bitdepth = 16;
-      m = img.uint16_array_value ();
-    }
-  else
-    error ("__magick_write__: invalid image class");
-
-  dim_vector dsizes = m.dims ();
-  unsigned int nframes = 1;
-  if (dsizes.length () == 4)
-    nframes = dsizes(3);
-
-  bool is_color = ((dsizes.length () > 2) && (dsizes(2) > 2));
-  bool has_alpha = (dsizes.length () > 2 && (dsizes(2) == 2 || dsizes(2) == 4));
-
-  Array<octave_idx_type> idx (dim_vector (dsizes.length (), 1));
-  octave_idx_type rows = m.rows ();
-  octave_idx_type columns = m.columns ();
-
-  unsigned int div_factor = (1 << bitdepth) - 1;
-
-  for (unsigned int ii = 0; ii < nframes; ii++)
-    {
-      Magick::Image im (Magick::Geometry (columns, rows), "black");
-
-      im.depth (bitdepth);
-
-      if (has_map)
-        im.classType (Magick::PseudoClass);
-      else
-        im.classType (Magick::DirectClass);
-
-      if (is_color)
-        {
-          if (has_alpha)
-            im.type (Magick::TrueColorMatteType);
-          else
-            im.type (Magick::TrueColorType);
-
-          Magick::ColorRGB c;
-
-          for (int y = 0; y < columns; y++)
-            {
-              idx(1) = y;
-
-              for (int x = 0; x < rows; x++)
-                {
-                  idx(0) = x;
-
-                  if (nframes > 1)
-                    idx(3) = ii;
-
-                  idx(2) = 0;
-                  c.red (static_cast<double>(m(idx)) / div_factor);
-
-                  idx(2) = 1;
-                  c.green (static_cast<double>(m(idx)) / div_factor);
-
-                  idx(2) = 2;
-                  c.blue (static_cast<double>(m(idx)) / div_factor);
-
-                  if (has_alpha)
-                    {
-                      idx(2) = 3;
-                      c.alpha (static_cast<double>(m(idx)) / div_factor);
-                    }
-
-                  im.pixelColor (y, x, c);
-                }
-            }
-        }
-      else
-        {
-          if (has_alpha)
-            im.type (Magick::GrayscaleMatteType);
-          else
-            im.type (Magick::GrayscaleType);
-
-          Magick::ColorGray c;
-
-          for (int y = 0; y < columns; y++)
-            {
-              idx(1) = y;
-
-              for (int x=0; x < rows; x++)
-                {
-                  idx(0) = x;
-
-                  if (nframes > 1)
-                    {
-                      idx(2) = 0;
-                      idx(3) = ii;
-                    }
-
-                  if (has_alpha)
-                    {
-                      idx(2) = 1;
-                      c.alpha (static_cast<double>(m(idx)) / div_factor);
-                      idx(2) = 0;
-                    }
-
-                  c.shade (static_cast<double>(m(idx)) / div_factor);
-
-                  im.pixelColor (y, x, c);
-                }
-            }
-
-          im.quantizeColorSpace (Magick::GRAYColorspace);
-          im.quantizeColors (1 << bitdepth);
-          im.quantize ();
-        }
-
-      imvec.push_back (im);
-    }
-}
-
-static void
-encode_map (std::vector<Magick::Image>& imvec, const NDArray& cmap)
-{
-  unsigned int mapsize = cmap.dim1 ();
-
-  for (size_t fnum = 0; fnum < imvec.size (); fnum++)
-    {
-      imvec[fnum].colorMapSize (mapsize);
-      imvec[fnum].type (Magick::PaletteType);
-    }
-
-  for (unsigned int ii = 0; ii < mapsize; ii++)
-    {
-      Magick::ColorRGB c (cmap(ii,0), cmap(ii,1), cmap(ii,2));
-
-      // FIXME -- is this case needed?
-      if (cmap.dim2 () == 4)
-        c.alpha (cmap(ii,3));
-
-      try
-        {
-          for_each (imvec.begin (), imvec.end (),
-                    Magick::colorMapImage (ii, c));
-        }
-      catch (Magick::Warning& w)
-        {
-          warning ("Magick++ warning: %s", w.what ());
-        }
-      catch (Magick::ErrorCoder& e)
-        {
-          warning ("Magick++ coder error: %s", e.what ());
-        }
-      catch (Magick::Exception& e)
-        {
-          error ("Magick++ exception: %s", e.what ());
-        }
-    }
-}
-
-static void
-write_image (const std::string& filename, const std::string& fmt,
-             const octave_value& img,
-             const octave_value& map = octave_value (),
-             const octave_value& params = octave_value ())
-{
-  std::vector<Magick::Image> imvec;
-
-  bool has_map = map.is_defined ();
-
-  if (has_map)
-    {
-      error ("__magick_write__: direct saving of indexed images not currently supported; use ind2rgb and save converted image");
-      return;
-    }
-
-  if (img.is_bool_type ())
-    encode_bool_image (imvec, img);
-  else if (img.is_uint8_type ())
-    encode_uint_image<uint8NDArray> (imvec, img, has_map);
-  else if (img.is_uint16_type ())
-    encode_uint_image<uint16NDArray> (imvec, img, has_map);
-  else
-    error ("__magick_write__: image type not supported");
-
-  if (! error_state && has_map)
-    {
-      NDArray cmap = map.array_value ();
-
-      if (! error_state)
-        encode_map (imvec, cmap);
-    }
-
-  if (! error_state && params.is_defined ())
-    {
-      Octave_map options = params.map_value ();
-
-      // Insert calls here to handle parameters for various image formats
-      if (fmt == "jpg" || fmt == "jpeg")
-        jpg_settings (imvec, options, has_map);
-      else
-        warning ("warning: your parameter(s) currently not supported");
-    }
-
-  try
-    {
-      Magick::writeImages (imvec.begin (), imvec.end (), fmt + ":" + filename);
-    }
-  catch (Magick::Warning& w)
-    {
-      warning ("Magick++ warning: %s", w.what ());
-    }
-  catch (Magick::ErrorCoder& e)
-    {
-      warning ("Magick++ coder error: %s", e.what ());
-    }
-  catch (Magick::Exception& e)
-    {
-      error ("Magick++ exception: %s", e.what ());
-    }
-}
-
-#endif
-
-DEFUN_DLD (__magick_write__, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn  {Function File} {} __magick_write__ (@var{fname}, @var{fmt}, @var{img})\n\
-@deftypefnx {Function File} {} __magick_write__ (@var{fname}, @var{fmt}, @var{img}, @var{map})\n\
-Write images with ImageMagick++.  In general you should not be using this\n\
-function.  Instead use @code{imwrite}.\n\
-@seealso{imread}\n\
-@end deftypefn")
-{
-  octave_value_list retval;
-
-#ifdef HAVE_MAGICK
-  maybe_initialize_magick ();
-
-  int nargin = args.length ();
-
-  if (nargin > 2)
-    {
-      std::string filename = args(0).string_value ();
-
-      if (! error_state)
-        {
-          std::string fmt = args(1).string_value ();
-
-          if (! error_state)
-            {
-              if (nargin > 4)
-                write_image (filename, fmt, args(2), args(3), args(4));
-              else if (nargin > 3)
-                if (args(3).is_real_type ())
-                  write_image (filename, fmt, args(2), args(3));
-                else
-                  write_image (filename, fmt, args(2), octave_value (), args(3));
-              else
-                write_image (filename, fmt, args(2));
-            }
-          else
-            error ("__magick_write__: FMT must be string");
-        }
-      else
-        error ("__magick_write__: FNAME must be a string");
-    }
-  else
-    print_usage ();
-#else
-
-  error ("__magick_write__: not available in this version of Octave");
-
-#endif
-
-return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/
-
-#ifdef HAVE_MAGICK
-
-template<class T>
-static octave_value
-magick_to_octave_value (const T magick)
-{
-  return octave_value (magick);
-}
-
-static octave_value
-magick_to_octave_value (const Magick::EndianType magick)
-{
-  switch (magick)
-    {
-      case Magick::LSBEndian:
-        return octave_value ("little-endian");
-
-      case Magick::MSBEndian:
-        return octave_value ("big-endian");
-
-      default:
-        return octave_value ("undefined");
-    }
-}
-
-static octave_value
-magick_to_octave_value (const Magick::ResolutionType magick)
-{
-  switch (magick)
-    {
-      case Magick::PixelsPerInchResolution:
-        return octave_value ("pixels per inch");
-
-      case Magick::PixelsPerCentimeterResolution:
-        return octave_value ("pixels per centimeter");
-
-      default:
-        return octave_value ("undefined");
-    }
-}
-
-static octave_value
-magick_to_octave_value (const Magick::ImageType magick)
-{
-  switch (magick)
-    {
-      case Magick::BilevelType:
-      case Magick::GrayscaleType:
-      case Magick::GrayscaleMatteType:
-        return octave_value ("grayscale");
-
-      case Magick::PaletteType:
-      case Magick::PaletteMatteType:
-        return octave_value ("indexed");
-
-      case Magick::TrueColorType:
-      case Magick::TrueColorMatteType:
-      case Magick::ColorSeparationType:
-        return octave_value ("truecolor");
-
-      default:
-        return octave_value ("undefined");
-    }
-}
-
-// We put this in a try-block because GraphicsMagick will throw
-// exceptions if a parameter isn't present in the current image.
-#define GET_PARAM(NAME, OUTNAME) \
-  try \
-    { \
-      info.contents (OUTNAME)(frame,0) = magick_to_octave_value (im.NAME ()); \
-    } \
-  catch (Magick::Warning& w) \
-    { \
-    }
-
-#endif
-
-DEFUN_DLD (__magick_finfo__, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn {Loadable Function} {} __magick_finfo__ (@var{fname})\n\
-Read image information with GraphicsMagick++.  In general you should\n\
-not be using this function.  Instead use @code{imfinfo}.\n\
-@seealso{imfinfo, imread}\n\
-@end deftypefn")
-{
-  octave_value retval;
-
-#ifdef HAVE_MAGICK
-
-  maybe_initialize_magick ();
-
-  if (args.length () < 1 || ! args (0).is_string ())
-    {
-      print_usage ();
-      return retval;
-    }
-
-  const std::string filename = args (0).string_value ();
-
-  try
-    {
-      // Read the file.
-      std::vector<Magick::Image> imvec;
-      Magick::readImages (&imvec, args(0).string_value ());
-      int nframes = imvec.size ();
-
-      // Create the right size for the output.
-
-      static const char *fields[] =
-        {
-          "Filename",
-          "FileModDate",
-          "FileSize",
-          "Height",
-          "Width",
-          "BitDepth",
-          "Format",
-          "LongFormat",
-          "XResolution",
-          "YResolution",
-          "TotalColors",
-          "TileName",
-          "AnimationDelay",
-          "AnimationIterations",
-          "ByteOrder",
-          "Gamma",
-          "Matte",
-          "ModulusDepth",
-          "Quality",
-          "QuantizeColors",
-          "ResolutionUnits",
-          "ColorType",
-          "View",
-          0
-        };
-
-      Octave_map info (string_vector (fields), dim_vector (nframes, 1));
-
-      file_stat fs (filename);
-
-      std::string filetime;
-
-      if (fs)
-        {
-          octave_localtime mtime = fs.mtime ();
-
-          filetime = mtime.strftime ("%e-%b-%Y %H:%M:%S");
-        }
-      else
-        {
-          std::string msg = fs.error ();
-
-          error ("imfinfo: error reading `%s': %s",
-                 filename.c_str (), msg.c_str ());
-
-          return retval;
-        }
-
-      // For each frame in the image (some images contain multiple
-      // layers, each to be treated like a separate image).
-      for (int frame = 0; frame < nframes; frame++)
-        {
-          Magick::Image im = imvec[frame];
-
-          // Add file name and timestamp.
-          info.contents ("Filename")(frame,0) = filename;
-          info.contents ("FileModDate")(frame,0) = filetime;
-
-          // Annoying CamelCase naming is for Matlab compatibility.
-          GET_PARAM (fileSize, "FileSize")
-          GET_PARAM (rows, "Height")
-          GET_PARAM (columns, "Width")
-          GET_PARAM (depth, "BitDepth")
-          GET_PARAM (magick, "Format")
-          GET_PARAM (format, "LongFormat")
-          GET_PARAM (xResolution, "XResolution")
-          GET_PARAM (yResolution, "YResolution")
-          GET_PARAM (totalColors, "TotalColors")
-          GET_PARAM (tileName, "TileName")
-          GET_PARAM (animationDelay, "AnimationDelay")
-          GET_PARAM (animationIterations, "AnimationIterations")
-          GET_PARAM (endian, "ByteOrder")
-          GET_PARAM (gamma, "Gamma")
-          GET_PARAM (matte, "Matte")
-          GET_PARAM (modulusDepth, "ModulusDepth")
-          GET_PARAM (quality, "Quality")
-          GET_PARAM (quantizeColors, "QuantizeColors")
-          GET_PARAM (resolutionUnits, "ResolutionUnits")
-          GET_PARAM (type, "ColorType")
-          GET_PARAM (view, "View")
-        }
-
-      retval = octave_value (info);
-    }
-  catch (Magick::Warning& w)
-    {
-      warning ("Magick++ warning: %s", w.what ());
-    }
-  catch (Magick::ErrorCoder& e)
-    {
-      warning ("Magick++ coder error: %s", e.what ());
-    }
-  catch (Magick::Exception& e)
-    {
-      error ("Magick++ exception: %s", e.what ());
-      return retval;
-    }
-
-#else
-
-  error ("imfinfo: not available in this version of Octave");
-
-#endif
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/
-
-#undef GET_PARAM
-
-// Determine the file formats supported by GraphicsMagick.  This is
-// called once at the beginning of imread or imwrite to determine
-// exactly which file formats are supported, so error messages can be
-// displayed properly.
-
-DEFUN_DLD (__magick_format_list__, args, ,
-  "-*- texinfo -*-\n\
-@deftypefn {Function File} {} __magick_format_list__ (@var{formats})\n\
-Undocumented internal function.\n\
-@end deftypefn")
-{
-  octave_value retval;
-
-#ifdef HAVE_MAGICK
-  maybe_initialize_magick ();
-
-  std::list<std::string> accepted_formats;
-
-  if (args.length () == 1)
-    {
-      Cell c = args (0).cell_value ();
-
-      if (! error_state)
-        {
-          for (octave_idx_type i = 0; i < c.nelem (); i++)
-            {
-              try
-                {
-                  std::string fmt = c.elem (i).string_value ();
-
-                  Magick::CoderInfo info(fmt);
-
-                  if (info.isReadable () && info.isWritable ())
-                    accepted_formats.push_back (fmt);
-                }
-              catch (Magick::Exception& e)
-                {
-                  // Do nothing: exception here are simply missing formats.
-                }
-            }
-        }
-      else
-        error ("__magick_format_list__: expecting a cell array of image format names");
-    }
-  else
-    print_usage ();
-
-  retval = Cell (accepted_formats);
-
-#else
-
-  error ("__magick_format_list__: not available in this version of Octave");
-
-#endif
-
-  return retval;
-}
-
-/*
-## No test needed for internal helper function.
-%!assert (1)
-*/