GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
graphics.h
Go to the documentation of this file.
1 // DO NOT EDIT! Generated automatically by genprops.awk.
2 
3 /*
4 
5 Copyright (C) 2007-2017 John W. Eaton
6 
7 This file is part of Octave.
8 
9 Octave is free software; you can redistribute it and/or modify it
10 under the terms of the GNU General Public License as published by the
11 Free Software Foundation; either version 3 of the License, or (at your
12 option) any later version.
13 
14 Octave is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
18 
19 You should have received a copy of the GNU General Public License
20 along with Octave; see the file COPYING. If not, see
21 <http://www.gnu.org/licenses/>.
22 
23 */
24 
25 #if ! defined (octave_graphics_h)
26 #define octave_graphics_h 1
27 
28 #include "octave-config.h"
29 
30 #include <cctype>
31 
32 #include <algorithm>
33 #include <list>
34 #include <map>
35 #include <set>
36 #include <sstream>
37 #include <string>
38 
39 #include "caseless-str.h"
40 
41 #include "errwarn.h"
42 #include "oct-handle.h"
43 #include "oct-map.h"
44 #include "oct-mutex.h"
45 #include "oct-refcount.h"
46 #include "ov.h"
47 #include "text-renderer.h"
48 
49 // FIXME: maybe this should be a configure option?
50 // Matlab defaults to "Helvetica", but that causes problems for many
51 // gnuplot users.
52 #if ! defined (OCTAVE_DEFAULT_FONTNAME)
53 #define OCTAVE_DEFAULT_FONTNAME "*"
54 #endif
55 
57 
58 // ---------------------------------------------------------------------
59 
61 {
62 public:
63  base_scaler (void) { }
64 
65  virtual ~base_scaler (void) { }
66 
67  virtual Matrix scale (const Matrix&) const
68  {
69  error ("invalid axis scale");
70  }
71 
72  virtual NDArray scale (const NDArray&) const
73  {
74  error ("invalid axis scale");
75  }
76 
77  virtual double scale (double) const
78  {
79  error ("invalid axis scale");
80  }
81 
82  virtual double unscale (double) const
83  {
84  error ("invalid axis scale");
85  }
86 
87  virtual base_scaler* clone () const
88  { return new base_scaler (); }
89 
90  virtual bool is_linear (void) const
91  { return false; }
92 };
93 
94 class lin_scaler : public base_scaler
95 {
96 public:
97  lin_scaler (void) { }
98 
99  Matrix scale (const Matrix& m) const { return m; }
100 
101  NDArray scale (const NDArray& m) const { return m; }
102 
103  double scale (double d) const { return d; }
104 
105  double unscale (double d) const { return d; }
106 
107  base_scaler* clone (void) const { return new lin_scaler (); }
108 
109  bool is_linear (void) const { return true; }
110 };
111 
112 class log_scaler : public base_scaler
113 {
114 public:
115  log_scaler (void) { }
116 
117  Matrix scale (const Matrix& m) const
118  {
119  Matrix retval (m.rows (), m.cols ());
120 
121  do_scale (m.data (), retval.fortran_vec (), m.numel ());
122 
123  return retval;
124  }
125 
126  NDArray scale (const NDArray& m) const
127  {
128  NDArray retval (m.dims ());
129 
130  do_scale (m.data (), retval.fortran_vec (), m.numel ());
131 
132  return retval;
133  }
134 
135  double scale (double d) const
136  { return log10 (d); }
137 
138  double unscale (double d) const
139  { return pow (10.0, d); }
140 
141  base_scaler* clone (void) const
142  { return new log_scaler (); }
143 
144 private:
145  void do_scale (const double *src, double *dest, int n) const
146  {
147  for (int i = 0; i < n; i++)
148  dest[i] = log10 (src[i]);
149  }
150 };
151 
153 {
154 public:
155  neg_log_scaler (void) { }
156 
157  Matrix scale (const Matrix& m) const
158  {
159  Matrix retval (m.rows (), m.cols ());
160 
161  do_scale (m.data (), retval.fortran_vec (), m.numel ());
162 
163  return retval;
164  }
165 
166  NDArray scale (const NDArray& m) const
167  {
168  NDArray retval (m.dims ());
169 
170  do_scale (m.data (), retval.fortran_vec (), m.numel ());
171 
172  return retval;
173  }
174 
175  double scale (double d) const
176  { return -log10 (-d); }
177 
178  double unscale (double d) const
179  { return -pow (10.0, -d); }
180 
181  base_scaler* clone (void) const
182  { return new neg_log_scaler (); }
183 
184 private:
185  void do_scale (const double *src, double *dest, int n) const
186  {
187  for (int i = 0; i < n; i++)
188  dest[i] = -log10 (-src[i]);
189  }
190 };
191 
192 class scaler
193 {
194 public:
195  scaler (void) : rep (new base_scaler ()) { }
196 
197  scaler (const scaler& s) : rep (s.rep->clone ()) { }
198 
200  : rep (s == "log"
201  ? new log_scaler ()
202  : (s == "neglog" ? new neg_log_scaler ()
203  : (s == "linear" ? new lin_scaler () : new base_scaler ())))
204  { }
205 
206  ~scaler (void) { delete rep; }
207 
208  Matrix scale (const Matrix& m) const
209  { return rep->scale (m); }
210 
211  NDArray scale (const NDArray& m) const
212  { return rep->scale (m); }
213 
214  double scale (double d) const
215  { return rep->scale (d); }
216 
217  double unscale (double d) const
218  { return rep->unscale (d); }
219 
220  bool is_linear (void) const
221  { return rep->is_linear (); }
222 
224  {
225  if (rep)
226  {
227  delete rep;
228  rep = 0;
229  }
230 
231  rep = s.rep->clone ();
232 
233  return *this;
234  }
235 
237  {
238  if (rep)
239  {
240  delete rep;
241  rep = 0;
242  }
243 
244  if (s == "log")
245  rep = new log_scaler ();
246  else if (s == "neglog")
247  rep = new neg_log_scaler ();
248  else if (s == "linear")
249  rep = new lin_scaler ();
250  else
251  rep = new base_scaler ();
252 
253  return *this;
254  }
255 
256 private:
258 };
259 
260 // ---------------------------------------------------------------------
261 
262 class property;
263 
265 
267 {
268 public:
269  friend class property;
270 
271 public:
273  : id (-1), count (1), name (), parent (), hidden (), listeners ()
274  { }
275 
277  : id (-1), count (1), name (s), parent (h), hidden (false), listeners ()
278  { }
279 
281  : id (-1), count (1), name (p.name), parent (p.parent),
282  hidden (p.hidden), listeners ()
283  { }
284 
285  virtual ~base_property (void) { }
286 
287  bool ok (void) const { return parent.ok (); }
288 
289  std::string get_name (void) const { return name; }
290 
291  void set_name (const std::string& s) { name = s; }
292 
293  graphics_handle get_parent (void) const { return parent; }
294 
295  void set_parent (const graphics_handle& h) { parent = h; }
296 
297  bool is_hidden (void) const { return hidden; }
298 
299  void set_hidden (bool flag) { hidden = flag; }
300 
301  virtual bool is_radio (void) const { return false; }
302 
303  int get_id (void) const { return id; }
304 
305  void set_id (int d) { id = d; }
306 
307  // Sets property value, notifies graphics toolkit.
308  // If do_run is true, runs associated listeners.
309  OCTINTERP_API bool set (const octave_value& v, bool do_run = true,
310  bool do_notify_toolkit = true);
311 
312  virtual octave_value get (void) const
313  {
314  error ("get: invalid property \"%s\"", name.c_str ());
315  }
316 
317  virtual std::string values_as_string (void) const
318  {
319  error ("values_as_string: invalid property \"%s\"", name.c_str ());
320  }
321 
322  virtual Cell values_as_cell (void) const
323  {
324  error ("values_as_cell: invalid property \"%s\"", name.c_str ());
325  }
326 
328  {
329  set (val);
330  return *this;
331  }
332 
334  {
336  l.resize (l.length () + 1, v);
337  }
338 
341  {
343 
344  if (v.is_defined ())
345  {
346  bool found = false;
347  int i;
348 
349  for (i = 0; i < l.length (); i++)
350  {
351  if (v.internal_rep () == l(i).internal_rep ())
352  {
353  found = true;
354  break;
355  }
356  }
357  if (found)
358  {
359  for (int j = i; j < l.length () - 1; j++)
360  l(j) = l(j + 1);
361 
362  l.resize (l.length () - 1);
363  }
364  }
365  else
366  {
367  if (mode == PERSISTENT)
368  l.resize (0);
369  else
370  {
371  octave_value_list lnew (0);
373  for (int i = l.length () - 1; i >= 0 ; i--)
374  {
375  for (int j = 0; j < lp.length (); j++)
376  {
377  if (l(i).internal_rep () == lp(j).internal_rep ())
378  {
379  lnew.resize (lnew.length () + 1, l(i));
380  break;
381  }
382  }
383  }
384  l = lnew;
385  }
386  }
387 
388  }
389 
391 
392  virtual base_property* clone (void) const
393  { return new base_property (*this); }
394 
395 protected:
396  virtual bool do_set (const octave_value&)
397  {
398  error ("set: invalid property \"%s\"", name.c_str ());
399  }
400 
401 private:
402  typedef std::map<listener_mode, octave_value_list> listener_map;
403  typedef std::map<listener_mode, octave_value_list>::iterator
405  typedef std::map<listener_mode, octave_value_list>::const_iterator
407 
408 private:
409  int id;
413  bool hidden;
414  listener_map listeners;
415 };
416 
417 // ---------------------------------------------------------------------
418 
420 {
421 public:
423  const std::string& val = "")
424  : base_property (s, h), str (val) { }
425 
427  : base_property (p), str (p.str) { }
428 
429  octave_value get (void) const
430  { return octave_value (str); }
431 
432  std::string string_value (void) const { return str; }
433 
435  {
436  set (val);
437  return *this;
438  }
439 
440  base_property* clone (void) const { return new string_property (*this); }
441 
442 protected:
443  bool do_set (const octave_value& val)
444  {
445  if (! val.is_string ())
446  error ("set: invalid string property value for \"%s\"",
447  get_name ().c_str ());
448 
449  std::string new_str = val.string_value ();
450 
451  if (new_str != str)
452  {
453  str = new_str;
454  return true;
455  }
456  return false;
457  }
458 
459 private:
461 };
462 
463 // ---------------------------------------------------------------------
464 
466 {
467 public:
469 
471  const std::string& val = "", const char& sep = '|',
472  const desired_enum& typ = string_t)
473  : base_property (s, h), desired_type (typ), separator (sep), str ()
474  {
475  size_t pos = 0;
476 
477  while (true)
478  {
479  size_t new_pos = val.find_first_of (separator, pos);
480 
481  if (new_pos == std::string::npos)
482  {
483  str.append (val.substr (pos));
484  break;
485  }
486  else
487  str.append (val.substr (pos, new_pos - pos));
488 
489  pos = new_pos + 1;
490  }
491  }
492 
494  const Cell& c, const char& sep = '|',
495  const desired_enum& typ = string_t)
496  : base_property (s, h), desired_type (typ), separator (sep), str ()
497  {
498  if (! c.is_cellstr ())
499  error ("set: invalid order property value for \"%s\"",
500  get_name ().c_str ());
501 
502  string_vector strings (c.numel ());
503 
504  for (octave_idx_type i = 0; i < c.numel (); i++)
505  strings[i] = c(i).string_value ();
506 
507  str = strings;
508  }
509 
512  separator (p.separator), str (p.str) { }
513 
514  octave_value get (void) const
515  {
516  if (desired_type == string_t)
517  return octave_value (string_value ());
518  else
519  return octave_value (cell_value ());
520  }
521 
523  {
524  std::string s;
525 
526  for (octave_idx_type i = 0; i < str.numel (); i++)
527  {
528  s += str[i];
529  if (i != str.numel () - 1)
530  s += separator;
531  }
532 
533  return s;
534  }
535 
536  Cell cell_value (void) const {return Cell (str);}
537 
538  string_vector string_vector_value (void) const { return str; }
539 
541  {
542  set (val);
543  return *this;
544  }
545 
546  base_property* clone (void) const
547  { return new string_array_property (*this); }
548 
549 protected:
550  bool do_set (const octave_value& val)
551  {
552  if (val.is_string () && val.rows () == 1)
553  {
554  bool replace = false;
555  std::string new_str = val.string_value ();
556  string_vector strings;
557  size_t pos = 0;
558 
559  // Split single string on delimiter (usually '|')
560  while (pos != std::string::npos)
561  {
562  size_t new_pos = new_str.find_first_of (separator, pos);
563 
564  if (new_pos == std::string::npos)
565  {
566  strings.append (new_str.substr (pos));
567  break;
568  }
569  else
570  strings.append (new_str.substr (pos, new_pos - pos));
571 
572  pos = new_pos + 1;
573  }
574 
575  if (str.numel () == strings.numel ())
576  {
577  for (octave_idx_type i = 0; i < str.numel (); i++)
578  if (strings[i] != str[i])
579  {
580  replace = true;
581  break;
582  }
583  }
584  else
585  replace = true;
586 
588 
589  if (replace)
590  {
591  str = strings;
592  return true;
593  }
594  }
595  else if (val.is_string ()) // multi-row character matrix
596  {
597  bool replace = false;
598  charMatrix chm = val.char_matrix_value ();
599  octave_idx_type nel = chm.rows ();
600  string_vector strings (nel);
601 
602  if (nel != str.numel ())
603  replace = true;
604  for (octave_idx_type i = 0; i < nel; i++)
605  {
606  strings[i] = chm.row_as_string (i);
607  if (! replace && strings[i] != str[i])
608  replace = true;
609  }
610 
612 
613  if (replace)
614  {
615  str = strings;
616  return true;
617  }
618  }
619  else if (val.is_cellstr ())
620  {
621  bool replace = false;
622  Cell new_cell = val.cell_value ();
623 
624  string_vector strings = new_cell.cellstr_value ();
625 
626  octave_idx_type nel = strings.numel ();
627 
628  if (nel != str.numel ())
629  replace = true;
630  else
631  {
632  for (octave_idx_type i = 0; i < nel; i++)
633  {
634  if (strings[i] != str[i])
635  {
636  replace = true;
637  break;
638  }
639  }
640  }
641 
643 
644  if (replace)
645  {
646  str = strings;
647  return true;
648  }
649  }
650  else
651  error ("set: invalid string property value for \"%s\"",
652  get_name ().c_str ());
653 
654  return false;
655  }
656 
657 private:
659  char separator;
661 };
662 
663 // ---------------------------------------------------------------------
664 
666 {
667 public:
668  enum type { char_t, cellstr_t };
669 
671  const std::string& val = "")
672  : base_property (s, h), value (val), stored_type (char_t)
673  { }
674 
676  const NDArray& nda)
677  : base_property (s, h), stored_type (char_t)
678  {
679  octave_idx_type nel = nda.numel ();
680 
681  value.resize (nel);
682 
683  for (octave_idx_type i = 0; i < nel; i++)
684  {
685  std::ostringstream buf;
686  buf << nda(i);
687  value[i] = buf.str ();
688  }
689  }
690 
692  const Cell& c)
694  {
695  octave_idx_type nel = c.numel ();
696 
697  value.resize (nel);
698 
699  for (octave_idx_type i = 0; i < nel; i++)
700  {
701  octave_value tmp = c(i);
702 
703  if (tmp.is_string ())
704  value[i] = c(i).string_value ();
705  else
706  {
707  double d = c(i).double_value ();
708 
709  std::ostringstream buf;
710  buf << d;
711  value[i] = buf.str ();
712  }
713  }
714  }
715 
718  { }
719 
720  bool empty (void) const
721  {
722  octave_value tmp = get ();
723  return tmp.is_empty ();
724  }
725 
726  octave_value get (void) const
727  {
728  if (stored_type == char_t)
729  return octave_value (char_value ());
730  else
731  return octave_value (cell_value ());
732  }
733 
735  {
736  return value.empty () ? "" : value[0];
737  }
738 
739  string_vector string_vector_value (void) const { return value; }
740 
741  charMatrix char_value (void) const { return charMatrix (value, ' '); }
742 
743  Cell cell_value (void) const {return Cell (value); }
744 
746  {
747  set (val);
748  return *this;
749  }
750 
751  base_property* clone (void) const { return new text_label_property (*this); }
752 
753 protected:
754 
755  bool do_set (const octave_value& val)
756  {
757  if (val.is_string ())
758  {
759  value = val.string_vector_value ();
760 
762  }
763  else if (val.is_cell ())
764  {
765  Cell c = val.cell_value ();
766 
767  octave_idx_type nel = c.numel ();
768 
769  value.resize (nel);
770 
771  for (octave_idx_type i = 0; i < nel; i++)
772  {
773  octave_value tmp = c(i);
774 
775  if (tmp.is_string ())
776  value[i] = c(i).string_value ();
777  else
778  {
779  double d = c(i).double_value ();
780 
781  std::ostringstream buf;
782  buf << d;
783  value[i] = buf.str ();
784  }
785  }
786 
788  }
789  else
790  {
791  NDArray nda;
792 
793  try
794  {
795  nda = val.array_value ();
796  }
797  catch (octave::execution_exception& e)
798  {
799  error (e, "set: invalid string property value for \"%s\"",
800  get_name ().c_str ());
801  }
802 
803  octave_idx_type nel = nda.numel ();
804 
805  value.resize (nel);
806 
807  for (octave_idx_type i = 0; i < nel; i++)
808  {
809  std::ostringstream buf;
810  buf << nda(i);
811  value[i] = buf.str ();
812  }
813 
815  }
816 
817  return true;
818  }
819 
820 private:
823 };
824 
825 // ---------------------------------------------------------------------
826 
828 {
829 public:
830  OCTINTERP_API radio_values (const std::string& opt_string = "");
831 
832  radio_values (const radio_values& a)
834 
835  radio_values& operator = (const radio_values& a)
836  {
837  if (&a != this)
838  {
841  }
842 
843  return *this;
844  }
845 
846  std::string default_value (void) const { return default_val; }
847 
848  bool validate (const std::string& val, std::string& match)
849  {
850  bool retval = true;
851 
852  if (! contains (val, match))
853  error ("invalid value = %s", val.c_str ());
854 
855  return retval;
856  }
857 
858  bool contains (const std::string& val, std::string& match)
859  {
860  size_t k = 0;
861 
862  size_t len = val.length ();
863 
864  std::string first_match;
865 
866  for (const auto& possible_val : possible_vals)
867  {
868  if (possible_val.compare (val, len))
869  {
870  if (len == possible_val.length ())
871  {
872  // We found a full match (consider the case of val == "replace"
873  // with possible values "replace" and "replacechildren"). Any
874  // other matches are irrelevant, so set match and return now.
875  match = possible_val;
876  return true;
877  }
878  else
879  {
880  if (k == 0)
881  first_match = possible_val;
882 
883  k++;
884  }
885  }
886  }
887 
888  if (k == 1)
889  {
890  match = first_match;
891  return true;
892  }
893  else
894  return false;
895  }
896 
897  std::string values_as_string (void) const;
898 
899  Cell values_as_cell (void) const;
900 
901  octave_idx_type nelem (void) const { return possible_vals.size (); }
902 
903 private:
904  // Might also want to cache
906  std::set<caseless_str> possible_vals;
907 };
908 
910 {
911 public:
913  const radio_values& v = radio_values ())
914  : base_property (nm, h),
915  vals (v), current_val (v.default_value ()) { }
916 
918  const std::string& v)
919  : base_property (nm, h),
920  vals (v), current_val (vals.default_value ()) { }
921 
923  const radio_values& v, const std::string& def)
924  : base_property (nm, h),
925  vals (v), current_val (def) { }
926 
928  : base_property (p), vals (p.vals), current_val (p.current_val) { }
929 
930  octave_value get (void) const { return octave_value (current_val); }
931 
932  const std::string& current_value (void) const { return current_val; }
933 
934  std::string values_as_string (void) const { return vals.values_as_string (); }
935 
936  Cell values_as_cell (void) const { return vals.values_as_cell (); }
937 
938  bool is (const caseless_str& v) const
939  { return v.compare (current_val); }
940 
941  bool is_radio (void) const { return true; }
942 
944  {
945  set (val);
946  return *this;
947  }
948 
949  base_property* clone (void) const { return new radio_property (*this); }
950 
951 protected:
952  bool do_set (const octave_value& newval)
953  {
954  if (! newval.is_string ())
955  error ("set: invalid value for radio property \"%s\"",
956  get_name ().c_str ());
957 
958  std::string s = newval.string_value ();
959 
960  std::string match;
961 
962  if (! vals.validate (s, match))
963  error ("set: invalid value for radio property \"%s\" (value = %s)",
964  get_name ().c_str (), s.c_str ());
965 
966  if (match != current_val)
967  {
968  if (s.length () != match.length ())
969  warning_with_id ("Octave:abbreviated-property-match",
970  "%s: allowing %s to match %s value %s",
971  "set", s.c_str (), get_name ().c_str (),
972  match.c_str ());
973  current_val = match;
974  return true;
975  }
976  return false;
977  }
978 
979 private:
982 };
983 
984 // ---------------------------------------------------------------------
985 
987 {
988 public:
989  color_values (double r = 0, double g = 0, double b = 1)
990  : xrgb (1, 3)
991  {
992  xrgb(0) = r;
993  xrgb(1) = g;
994  xrgb(2) = b;
995 
996  validate ();
997  }
998 
1000  : xrgb (1, 3)
1001  {
1002  if (! str2rgb (str))
1003  error ("invalid color specification: %s", str.c_str ());
1004  }
1005 
1007  : xrgb (c.xrgb)
1008  { }
1009 
1011  {
1012  if (&c != this)
1013  xrgb = c.xrgb;
1014 
1015  return *this;
1016  }
1017 
1018  bool operator == (const color_values& c) const
1019  {
1020  return (xrgb(0) == c.xrgb(0)
1021  && xrgb(1) == c.xrgb(1)
1022  && xrgb(2) == c.xrgb(2));
1023  }
1024 
1025  bool operator != (const color_values& c) const
1026  { return ! (*this == c); }
1027 
1028  Matrix rgb (void) const { return xrgb; }
1029 
1030  operator octave_value (void) const { return xrgb; }
1031 
1032  void validate (void) const
1033  {
1034  for (int i = 0; i < 3; i++)
1035  {
1036  if (xrgb(i) < 0 || xrgb(i) > 1)
1037  error ("invalid RGB color specification");
1038  }
1039  }
1040 
1041 private:
1043 
1044  OCTINTERP_API bool str2rgb (const std::string& str);
1045 };
1046 
1048 {
1049 public:
1051  : base_property ("", graphics_handle ()),
1053  current_val (v.default_value ())
1054  { }
1055 
1057  : base_property ("", graphics_handle ()),
1059  current_val (v.default_value ())
1060  { }
1061 
1063  const color_values& c = color_values (),
1064  const radio_values& v = radio_values ())
1065  : base_property (nm, h),
1067  current_val (v.default_value ())
1068  { }
1069 
1071  const radio_values& v)
1072  : base_property (nm, h),
1074  current_val (v.default_value ())
1075  { }
1076 
1078  const std::string& v)
1079  : base_property (nm, h),
1081  current_val (radio_val.default_value ())
1082  { }
1083 
1085  const color_property& v)
1086  : base_property (nm, h),
1089  { }
1090 
1094  current_val (p.current_val) { }
1095 
1096  octave_value get (void) const
1097  {
1098  if (current_type == color_t)
1099  return color_val.rgb ();
1100 
1101  return current_val;
1102  }
1103 
1104  bool is_rgb (void) const { return (current_type == color_t); }
1105 
1106  bool is_radio (void) const { return (current_type == radio_t); }
1107 
1108  bool is (const std::string& v) const
1109  { return (is_radio () && current_val == v); }
1110 
1111  Matrix rgb (void) const
1112  {
1113  if (current_type != color_t)
1114  error ("color has no RGB value");
1115 
1116  return color_val.rgb ();
1117  }
1118 
1119  const std::string& current_value (void) const
1120  {
1121  if (current_type != radio_t)
1122  error ("color has no radio value");
1123 
1124  return current_val;
1125  }
1126 
1128  {
1129  set (val);
1130  return *this;
1131  }
1132 
1133  operator octave_value (void) const { return get (); }
1134 
1135  base_property* clone (void) const { return new color_property (*this); }
1136 
1138  { return radio_val.values_as_string (); }
1139 
1140  Cell values_as_cell (void) const { return radio_val.values_as_cell (); }
1141 
1142 protected:
1143  OCTINTERP_API bool do_set (const octave_value& newval);
1144 
1145 private:
1150 };
1151 
1152 // ---------------------------------------------------------------------
1153 
1155 {
1156 public:
1158  double d = 0)
1159  : base_property (nm, h),
1160  current_val (d) { }
1161 
1163  : base_property (p), current_val (p.current_val) { }
1164 
1165  octave_value get (void) const { return octave_value (current_val); }
1166 
1167  double double_value (void) const { return current_val; }
1168 
1170  {
1171  set (val);
1172  return *this;
1173  }
1174 
1175  base_property* clone (void) const { return new double_property (*this); }
1176 
1177 protected:
1178  bool do_set (const octave_value& v)
1179  {
1180  if (! v.is_scalar_type () || ! v.is_real_type ())
1181  error ("set: invalid value for double property \"%s\"",
1182  get_name ().c_str ());
1183 
1184  double new_val = v.double_value ();
1185 
1186  if (new_val != current_val)
1187  {
1188  current_val = new_val;
1189  return true;
1190  }
1191 
1192  return false;
1193  }
1194 
1195 private:
1196  double current_val;
1197 };
1198 
1199 // ---------------------------------------------------------------------
1200 
1202 {
1203 public:
1205  : base_property ("", graphics_handle ()),
1206  current_type (double_t), dval (d), radio_val (v),
1207  current_val (v.default_value ())
1208  { }
1209 
1211  const std::string& v)
1212  : base_property (nm, h),
1213  current_type (radio_t), dval (0), radio_val (v),
1214  current_val (radio_val.default_value ())
1215  { }
1216 
1218  const double_radio_property& v)
1219  : base_property (nm, h),
1222  { }
1223 
1226  dval (p.dval), radio_val (p.radio_val),
1227  current_val (p.current_val) { }
1228 
1229  octave_value get (void) const
1230  {
1231  if (current_type == double_t)
1232  return dval;
1233 
1234  return current_val;
1235  }
1236 
1237  bool is_double (void) const { return (current_type == double_t); }
1238 
1239  bool is_radio (void) const { return (current_type == radio_t); }
1240 
1241  bool is (const std::string& v) const
1242  { return (is_radio () && current_val == v); }
1243 
1244  double double_value (void) const
1245  {
1246  if (current_type != double_t)
1247  error ("%s: property has no double", get_name ().c_str ());
1248 
1249  return dval;
1250  }
1251 
1252  const std::string& current_value (void) const
1253  {
1254  if (current_type != radio_t)
1255  error ("%s: property has no radio value");
1256 
1257  return current_val;
1258  }
1259 
1261  {
1262  set (val);
1263  return *this;
1264  }
1265 
1266  operator octave_value (void) const { return get (); }
1267 
1268  base_property* clone (void) const
1269  { return new double_radio_property (*this); }
1270 
1271 protected:
1272  OCTINTERP_API bool do_set (const octave_value& v);
1273 
1274 private:
1276  double dval;
1279 };
1280 
1281 // ---------------------------------------------------------------------
1282 
1284 {
1285 public:
1287  : base_property ("", graphics_handle ()), data (Matrix ()),
1288  xmin (), xmax (), xminp (), xmaxp (),
1290  {
1291  get_data_limits ();
1292  }
1293 
1295  const octave_value& m)
1296  : base_property (nm, h), data (m.is_sparse_type () ? m.full_value () : m),
1297  xmin (), xmax (), xminp (), xmaxp (),
1299  {
1300  get_data_limits ();
1301  }
1302 
1303  // This copy constructor is only intended to be used
1304  // internally to access min/max values; no need to
1305  // copy constraints.
1307  : base_property (p), data (p.data),
1308  xmin (p.xmin), xmax (p.xmax), xminp (p.xminp), xmaxp (p.xmaxp),
1310  { }
1311 
1312  octave_value get (void) const { return data; }
1313 
1315  { type_constraints.insert (type); }
1316 
1318  { size_constraints.push_back (dims); }
1319 
1320  double min_val (void) const { return xmin; }
1321  double max_val (void) const { return xmax; }
1322  double min_pos (void) const { return xminp; }
1323  double max_neg (void) const { return xmaxp; }
1324 
1325  Matrix get_limits (void) const
1326  {
1327  Matrix m (1, 4);
1328 
1329  m(0) = min_val ();
1330  m(1) = max_val ();
1331  m(2) = min_pos ();
1332  m(3) = max_neg ();
1333 
1334  return m;
1335  }
1336 
1338  {
1339  set (val);
1340  return *this;
1341  }
1342 
1343  base_property* clone (void) const
1344  {
1345  array_property *p = new array_property (*this);
1346 
1349 
1350  return p;
1351  }
1352 
1353 protected:
1354  bool do_set (const octave_value& v)
1355  {
1356  octave_value tmp = v.is_sparse_type () ? v.full_value () : v;
1357 
1358  if (! validate (tmp))
1359  error ("invalid value for array property \"%s\"",
1360  get_name ().c_str ());
1361 
1362  // FIXME: should we check for actual data change?
1363  if (! is_equal (tmp))
1364  {
1365  data = tmp;
1366 
1367  get_data_limits ();
1368 
1369  return true;
1370  }
1371 
1372  return false;
1373  }
1374 
1375 private:
1376  OCTINTERP_API bool validate (const octave_value& v);
1377 
1378  OCTINTERP_API bool is_equal (const octave_value& v) const;
1379 
1380  OCTINTERP_API void get_data_limits (void);
1381 
1382 protected:
1384  double xmin;
1385  double xmax;
1386  double xminp;
1387  double xmaxp;
1388  std::set<std::string> type_constraints;
1389  std::list<dim_vector> size_constraints;
1390 };
1391 
1393 {
1394 public:
1396  const octave_value& m)
1397  : array_property (nm, h, m)
1398  {
1399  add_constraint (dim_vector (-1, 1));
1400  add_constraint (dim_vector (1, -1));
1401  add_constraint (dim_vector (0, 0));
1402  }
1403 
1405  : array_property (p)
1406  {
1407  add_constraint (dim_vector (-1, 1));
1408  add_constraint (dim_vector (1, -1));
1409  add_constraint (dim_vector (0, 0));
1410  }
1411 
1413  {
1415  }
1416 
1418  {
1420  }
1421 
1423  {
1424  size_constraints.remove (dim_vector (1, -1));
1425  size_constraints.remove (dim_vector (-1, 1));
1426  size_constraints.remove (dim_vector (0, 0));
1427 
1428  add_constraint (dim_vector (1, len));
1429  add_constraint (dim_vector (len, 1));
1430  }
1431 
1433  {
1434  set (val);
1435  return *this;
1436  }
1437 
1438  base_property* clone (void) const
1439  {
1440  row_vector_property *p = new row_vector_property (*this);
1441 
1444 
1445  return p;
1446  }
1447 
1448 protected:
1449  bool do_set (const octave_value& v)
1450  {
1451  bool retval = array_property::do_set (v);
1452 
1453  dim_vector dv = data.dims ();
1454 
1455  if (dv(0) > 1 && dv(1) == 1)
1456  {
1457  int tmp = dv(0);
1458  dv(0) = dv(1);
1459  dv(1) = tmp;
1460 
1461  data = data.reshape (dv);
1462  }
1463 
1464  return retval;
1465  }
1466 
1467 private:
1468  OCTINTERP_API bool validate (const octave_value& v);
1469 };
1470 
1471 // ---------------------------------------------------------------------
1472 
1474 {
1475 public:
1477  bool val)
1478  : radio_property (nm, h, radio_values (val ? "{on}|off" : "on|{off}"))
1479  { }
1480 
1482  const char* val)
1483  : radio_property (nm, h, radio_values ("on|off"), val)
1484  { }
1485 
1487  : radio_property (p) { }
1488 
1489  bool is_on (void) const { return is ("on"); }
1490 
1492  {
1493  set (val);
1494  return *this;
1495  }
1496 
1497  base_property* clone (void) const { return new bool_property (*this); }
1498 
1499 protected:
1500  bool do_set (const octave_value& val)
1501  {
1502  if (val.is_bool_scalar ())
1503  return radio_property::do_set (val.bool_value () ? "on" : "off");
1504  else
1505  return radio_property::do_set (val);
1506  }
1507 };
1508 
1509 // ---------------------------------------------------------------------
1510 
1512 {
1513 public:
1515  const graphics_handle& val = graphics_handle ())
1516  : base_property (nm, h),
1517  current_val (val) { }
1518 
1520  : base_property (p), current_val (p.current_val) { }
1521 
1522  octave_value get (void) const { return current_val.as_octave_value (); }
1523 
1524  graphics_handle handle_value (void) const { return current_val; }
1525 
1527  {
1528  set (val);
1529  return *this;
1530  }
1531 
1533  {
1534  set (octave_value (h.value ()));
1535  return *this;
1536  }
1537 
1539 
1540  base_property* clone (void) const { return new handle_property (*this); }
1541 
1542 protected:
1543  OCTINTERP_API bool do_set (const octave_value& v);
1544 
1545 private:
1547 };
1548 
1549 // ---------------------------------------------------------------------
1550 
1552 {
1553 public:
1555  const octave_value& m = Matrix ())
1556  : base_property (nm, h), data (m) { }
1557 
1559  : base_property (p), data (p.data) { }
1560 
1561  octave_value get (void) const { return data; }
1562 
1564  {
1565  set (val);
1566  return *this;
1567  }
1568 
1569  base_property* clone (void) const { return new any_property (*this); }
1570 
1571 protected:
1572  bool do_set (const octave_value& v)
1573  {
1574  data = v;
1575  return true;
1576  }
1577 
1578 private:
1580 };
1581 
1582 // ---------------------------------------------------------------------
1583 
1585 {
1586 public:
1589  {
1590  do_init_children (Matrix ());
1591  }
1592 
1594  const Matrix& val)
1595  : base_property (nm, h), children_list ()
1596  {
1597  do_init_children (val);
1598  }
1599 
1601  : base_property (p), children_list ()
1602  {
1604  }
1605 
1607  {
1608  set (val);
1609  return *this;
1610  }
1611 
1612  base_property* clone (void) const { return new children_property (*this); }
1613 
1614  bool remove_child (double val)
1615  {
1616  return do_remove_child (val);
1617  }
1618 
1619  void adopt (double val)
1620  {
1621  do_adopt_child (val);
1622  }
1623 
1624  Matrix get_children (void) const
1625  {
1626  return do_get_children (false);
1627  }
1628 
1629  Matrix get_hidden (void) const
1630  {
1631  return do_get_children (true);
1632  }
1633 
1634  Matrix get_all (void) const
1635  {
1636  return do_get_all_children ();
1637  }
1638 
1639  octave_value get (void) const
1640  {
1641  return octave_value (get_children ());
1642  }
1643 
1644  void delete_children (bool clear = false)
1645  {
1647  }
1648 
1650  {
1651  for (auto& hchild : children_list)
1652  {
1653  if (hchild == old_gh)
1654  {
1655  hchild = new_gh.value ();
1656  return;
1657  }
1658  }
1659 
1660  error ("children_list::renumber: child not found!");
1661  }
1662 
1663 private:
1664  typedef std::list<double>::iterator children_list_iterator;
1665  typedef std::list<double>::const_iterator const_children_list_iterator;
1666  std::list<double> children_list;
1667 
1668 protected:
1669  bool do_set (const octave_value& val)
1670  {
1671  Matrix new_kids;
1672 
1673  try
1674  {
1675  new_kids = val.matrix_value ();
1676  }
1677  catch (octave::execution_exception& e)
1678  {
1679  error (e, "set: children must be an array of graphics handles");
1680  }
1681 
1682  octave_idx_type nel = new_kids.numel ();
1683 
1684  const Matrix new_kids_column = new_kids.reshape (dim_vector (nel, 1));
1685 
1686  bool is_ok = true;
1687  bool add_hidden = true;
1688 
1689  const Matrix visible_kids = do_get_children (false);
1690 
1691  if (visible_kids.numel () == new_kids.numel ())
1692  {
1693  Matrix t1 = visible_kids.sort ();
1694  Matrix t2 = new_kids_column.sort ();
1695  Matrix t3 = get_hidden ().sort ();
1696 
1697  if (t1 != t2)
1698  is_ok = false;
1699 
1700  if (t1 == t3)
1701  add_hidden = false;
1702  }
1703  else
1704  is_ok = false;
1705 
1706  if (! is_ok)
1707  error ("set: new children must be a permutation of existing children");
1708 
1709  if (is_ok)
1710  {
1711  Matrix tmp = new_kids_column;
1712 
1713  if (add_hidden)
1714  tmp.stack (get_hidden ());
1715 
1716  children_list.clear ();
1717 
1718  // Don't use do_init_children here, as that reverses the
1719  // order of the list, and we don't want to do that if setting
1720  // the child list directly.
1721 
1722  for (octave_idx_type i = 0; i < tmp.numel (); i++)
1723  children_list.push_back (tmp.xelem (i));
1724  }
1725 
1726  return is_ok;
1727  }
1728 
1729 private:
1731  {
1732  children_list.clear ();
1733  for (octave_idx_type i = 0; i < val.numel (); i++)
1734  children_list.push_front (val.xelem (i));
1735  }
1736 
1737  void do_init_children (const std::list<double>& val)
1738  {
1739  children_list.clear ();
1740  children_list = val;
1741  }
1742 
1743  Matrix do_get_children (bool return_hidden) const;
1744 
1746  {
1747  Matrix retval (children_list.size (), 1);
1748  octave_idx_type i = 0;
1749 
1750  for (const auto& hchild : children_list)
1751  retval(i++) = hchild;
1752 
1753  return retval;
1754  }
1755 
1756  bool do_remove_child (double child)
1757  {
1758  for (auto it = children_list.begin (); it != children_list.end (); it++)
1759  {
1760  if (*it == child)
1761  {
1762  children_list.erase (it);
1763  return true;
1764  }
1765  }
1766  return false;
1767  }
1768 
1769  void do_adopt_child (double val)
1770  {
1771  children_list.push_front (val);
1772  }
1773 
1774  void do_delete_children (bool clear);
1775 };
1776 
1777 // ---------------------------------------------------------------------
1778 
1780 {
1781 public:
1783  const octave_value& m)
1784  : base_property (nm, h), callback (m), executing (false) { }
1785 
1787  : base_property (p), callback (p.callback), executing (false) { }
1788 
1789  octave_value get (void) const { return callback; }
1790 
1791  OCTINTERP_API void execute (const octave_value& data = octave_value ()) const;
1792 
1793  bool is_defined (void) const
1794  {
1795  return (callback.is_defined () && ! callback.is_empty ());
1796  }
1797 
1799  {
1800  set (val);
1801  return *this;
1802  }
1803 
1804  base_property* clone (void) const { return new callback_property (*this); }
1805 
1806 protected:
1807  bool do_set (const octave_value& v)
1808  {
1809  if (! validate (v))
1810  error ("invalid value for callback property \"%s\"",
1811  get_name ().c_str ());
1812 
1813  callback = v;
1814  return true;
1815  return false;
1816  }
1817 
1818 private:
1819  OCTINTERP_API bool validate (const octave_value& v) const;
1820 
1821 private:
1823 
1824  // If TRUE, we are executing this callback.
1825  mutable bool executing;
1826 };
1827 
1828 // ---------------------------------------------------------------------
1829 
1831 {
1832 public:
1833  property (void) : rep (new base_property ("", graphics_handle ()))
1834  { }
1835 
1836  property (base_property *bp, bool persist = false) : rep (bp)
1837  { if (persist) rep->count++; }
1838 
1839  property (const property& p) : rep (p.rep)
1840  {
1841  rep->count++;
1842  }
1843 
1844  ~property (void)
1845  {
1846  if (--rep->count == 0)
1847  delete rep;
1848  }
1849 
1850  bool ok (void) const
1851  { return rep->ok (); }
1852 
1853  std::string get_name (void) const
1854  { return rep->get_name (); }
1855 
1856  void set_name (const std::string& name)
1857  { rep->set_name (name); }
1858 
1860  { return rep->get_parent (); }
1861 
1862  void set_parent (const graphics_handle& h)
1863  { rep->set_parent (h); }
1864 
1865  bool is_hidden (void) const
1866  { return rep->is_hidden (); }
1867 
1868  void set_hidden (bool flag)
1869  { rep->set_hidden (flag); }
1870 
1871  bool is_radio (void) const
1872  { return rep->is_radio (); }
1873 
1874  int get_id (void) const
1875  { return rep->get_id (); }
1876 
1877  void set_id (int d)
1878  { rep->set_id (d); }
1879 
1880  octave_value get (void) const
1881  { return rep->get (); }
1882 
1883  bool set (const octave_value& val, bool do_run = true,
1884  bool do_notify_toolkit = true)
1885  { return rep->set (val, do_run, do_notify_toolkit); }
1886 
1888  { return rep->values_as_string (); }
1889 
1890  Cell values_as_cell (void) const
1891  { return rep->values_as_cell (); }
1892 
1893  property& operator = (const octave_value& val)
1894  {
1895  *rep = val;
1896  return *this;
1897  }
1898 
1899  property& operator = (const property& p)
1900  {
1901  if (rep && --rep->count == 0)
1902  delete rep;
1903 
1904  rep = p.rep;
1905  rep->count++;
1906 
1907  return *this;
1908  }
1909 
1911  { rep->add_listener (v, mode); }
1912 
1915  { rep->delete_listener (v, mode); }
1916 
1918  { rep->run_listeners (mode); }
1919 
1920  OCTINTERP_API static
1921  property create (const std::string& name, const graphics_handle& parent,
1922  const caseless_str& type,
1923  const octave_value_list& args);
1924 
1925  property clone (void) const
1926  { return property (rep->clone ()); }
1927 
1928 #if 0
1929  const string_property& as_string_property (void) const
1930  { return *(dynamic_cast<string_property*> (rep)); }
1931 
1932  const radio_property& as_radio_property (void) const
1933  { return *(dynamic_cast<radio_property*> (rep)); }
1934 
1935  const color_property& as_color_property (void) const
1936  { return *(dynamic_cast<color_property*> (rep)); }
1937 
1938  const double_property& as_double_property (void) const
1939  { return *(dynamic_cast<double_property*> (rep)); }
1940 
1941  const bool_property& as_bool_property (void) const
1942  { return *(dynamic_cast<bool_property*> (rep)); }
1943 
1944  const handle_property& as_handle_property (void) const
1945  { return *(dynamic_cast<handle_property*> (rep)); }
1946 #endif
1947 
1948 private:
1950 };
1951 
1952 // ---------------------------------------------------------------------
1953 
1954 typedef std::pair<std::string, octave_value> pval_pair;
1955 
1956 class pval_vector : public std::vector<pval_pair>
1957 {
1958 public:
1959  const_iterator find (const std::string pname) const
1960  {
1961  const_iterator it;
1962 
1963  for (it = (*this).begin (); it != (*this).end (); it++)
1964  if (pname == (*it).first)
1965  return it;
1966 
1967  return (*this).end ();
1968  }
1969 
1970  iterator find (const std::string pname)
1971  {
1972  iterator it;
1973 
1974  for (it = (*this).begin (); it != (*this).end (); it++)
1975  if (pname == (*it).first)
1976  return it;
1977 
1978  return (*this).end ();
1979  }
1980 
1982  {
1984 
1985  const_iterator it = find (pname);
1986 
1987  if (it != (*this).end ())
1988  retval = (*it).second;
1989 
1990  return retval;
1991  }
1992 
1994  {
1995  iterator it = find (pname);
1996 
1997  if (it == (*this).end ())
1998  {
1999  push_back (pval_pair (pname, octave_value ()));
2000  return (*this).back ().second;
2001  }
2002 
2003  return (*it).second;
2004  }
2005 
2006  void erase (const std::string pname)
2007  {
2008  iterator it = find (pname);
2009  if (it != (*this).end ())
2010  erase (it);
2011  }
2012 
2013  void erase (iterator it)
2014  {
2015  std::vector<pval_pair>::erase (it);
2016  }
2017 
2018 };
2019 
2021 {
2022 public:
2024  typedef std::map<std::string, pval_map_type> plist_map_type;
2025 
2026  typedef pval_map_type::iterator pval_map_iterator;
2027  typedef pval_map_type::const_iterator pval_map_const_iterator;
2028 
2029  typedef plist_map_type::iterator plist_map_iterator;
2030  typedef plist_map_type::const_iterator plist_map_const_iterator;
2031 
2032  property_list (const plist_map_type& m = plist_map_type ())
2033  : plist_map (m) { }
2034 
2035  ~property_list (void) { }
2036 
2037  void set (const caseless_str& name, const octave_value& val);
2038 
2039  octave_value lookup (const caseless_str& name) const;
2040 
2041  plist_map_iterator begin (void) { return plist_map.begin (); }
2042  plist_map_const_iterator begin (void) const { return plist_map.begin (); }
2043 
2044  plist_map_iterator end (void) { return plist_map.end (); }
2045  plist_map_const_iterator end (void) const { return plist_map.end (); }
2046 
2047  plist_map_iterator find (const std::string& go_name)
2048  {
2049  return plist_map.find (go_name);
2050  }
2051 
2052  plist_map_const_iterator find (const std::string& go_name) const
2053  {
2054  return plist_map.find (go_name);
2055  }
2056 
2057  octave_scalar_map as_struct (const std::string& prefix_arg) const;
2058 
2059 private:
2060  plist_map_type plist_map;
2061 };
2062 
2063 // ---------------------------------------------------------------------
2064 
2065 class graphics_toolkit;
2066 class graphics_object;
2067 
2069 {
2070 public:
2071  friend class graphics_toolkit;
2072 
2073 public:
2075  : name (nm), count (0) { }
2076 
2077  virtual ~base_graphics_toolkit (void) { }
2078 
2079  std::string get_name (void) const { return name; }
2080 
2081  virtual bool is_valid (void) const { return false; }
2082 
2083  virtual void redraw_figure (const graphics_object&) const
2084  { gripe_if_tkit_invalid ("redraw_figure"); }
2085 
2086  virtual void print_figure (const graphics_object&, const std::string&,
2087  const std::string&,
2088  const std::string& = "") const
2089  { gripe_if_tkit_invalid ("print_figure"); }
2090 
2091  virtual Matrix get_canvas_size (const graphics_handle&) const
2092  {
2093  gripe_if_tkit_invalid ("get_canvas_size");
2094  return Matrix (1, 2, 0.0);
2095  }
2096 
2097  virtual double get_screen_resolution (void) const
2098  {
2099  gripe_if_tkit_invalid ("get_screen_resolution");
2100  return 72.0;
2101  }
2102 
2103  virtual Matrix get_screen_size (void) const
2104  {
2105  gripe_if_tkit_invalid ("get_screen_size");
2106  return Matrix (1, 2, 0.0);
2107  }
2108 
2109  // Callback function executed when the given graphics object
2110  // changes. This allows the graphics toolkit to act on property
2111  // changes if needed.
2112  virtual void update (const graphics_object&, int)
2113  { gripe_if_tkit_invalid ("base_graphics_toolkit::update"); }
2114 
2115  void update (const graphics_handle&, int);
2116 
2117  // Callback function executed when the given graphics object is
2118  // created. This allows the graphics toolkit to do toolkit-specific
2119  // initializations for a newly created object.
2120  virtual bool initialize (const graphics_object&)
2121  {
2122  gripe_if_tkit_invalid ("base_graphics_toolkit::initialize");
2123  return false;
2124  }
2125 
2126  bool initialize (const graphics_handle&);
2127 
2128  // Callback function executed just prior to deleting the given
2129  // graphics object. This allows the graphics toolkit to perform
2130  // toolkit-specific cleanup operations before an object is deleted.
2131  virtual void finalize (const graphics_object&)
2132  { gripe_if_tkit_invalid ("base_graphics_toolkit::finalize"); }
2133 
2134  void finalize (const graphics_handle&);
2135 
2136  // Close the graphics toolkit.
2137  virtual void close (void)
2138  { gripe_if_tkit_invalid ("base_graphics_toolkit::close"); }
2139 
2140 private:
2143 
2144 private:
2146  {
2147  if (! is_valid ())
2148  error ("%s: invalid graphics toolkit", fname.c_str ());
2149  }
2150 };
2151 
2153 {
2154 public:
2156  : rep (new base_graphics_toolkit ("unknown"))
2157  {
2158  rep->count++;
2159  }
2160 
2162  : rep (b)
2163  {
2164  rep->count++;
2165  }
2166 
2168  : rep (b.rep)
2169  {
2170  rep->count++;
2171  }
2172 
2174  {
2175  if (--rep->count == 0)
2176  delete rep;
2177  }
2178 
2180  {
2181  if (rep != b.rep)
2182  {
2183  if (--rep->count == 0)
2184  delete rep;
2185 
2186  rep = b.rep;
2187  rep->count++;
2188  }
2189 
2190  return *this;
2191  }
2192 
2193  operator bool (void) const { return rep->is_valid (); }
2194 
2195  std::string get_name (void) const { return rep->get_name (); }
2196 
2197  void redraw_figure (const graphics_object& go) const
2198  { rep->redraw_figure (go); }
2199 
2200  void print_figure (const graphics_object& go, const std::string& term,
2201  const std::string& file,
2202  const std::string& debug_file = "") const
2203  { rep->print_figure (go, term, file, debug_file); }
2204 
2206  { return rep->get_canvas_size (fh); }
2207 
2208  double get_screen_resolution (void) const
2209  { return rep->get_screen_resolution (); }
2210 
2212  { return rep->get_screen_size (); }
2213 
2214  // Notifies graphics toolkit that object't property has changed.
2215  void update (const graphics_object& go, int id)
2216  { rep->update (go, id); }
2217 
2218  void update (const graphics_handle& h, int id)
2219  { rep->update (h, id); }
2220 
2221  // Notifies graphics toolkit that new object was created.
2222  bool initialize (const graphics_object& go)
2223  { return rep->initialize (go); }
2224 
2225  bool initialize (const graphics_handle& h)
2226  { return rep->initialize (h); }
2227 
2228  // Notifies graphics toolkit that object was destroyed.
2229  // This is called only for explicitly deleted object.
2230  // Children are deleted implicitly and graphics toolkit isn't notified.
2231  void finalize (const graphics_object& go)
2232  { rep->finalize (go); }
2233 
2234  void finalize (const graphics_handle& h)
2235  { rep->finalize (h); }
2236 
2237  // Close the graphics toolkit.
2238  void close (void) { rep->close (); }
2239 
2240 private:
2241 
2243 };
2244 
2246 {
2247 public:
2248 
2250  {
2251  return instance_ok () ? instance->do_get_toolkit () : graphics_toolkit ();
2252  }
2253 
2254  static void register_toolkit (const std::string& name)
2255  {
2256  if (instance_ok ())
2257  instance->do_register_toolkit (name);
2258  }
2259 
2260  static void unregister_toolkit (const std::string& name)
2261  {
2262  if (instance_ok ())
2264  }
2265 
2266  static void load_toolkit (const graphics_toolkit& tk)
2267  {
2268  if (instance_ok ())
2269  instance->do_load_toolkit (tk);
2270  }
2271 
2272  static void unload_toolkit (const std::string& name)
2273  {
2274  if (instance_ok ())
2275  instance->do_unload_toolkit (name);
2276  }
2277 
2279  {
2280  return instance_ok ()
2281  ? instance->do_find_toolkit (name) : graphics_toolkit ();
2282  }
2283 
2285  {
2286  return instance_ok () ? instance->do_available_toolkits_list () : Cell ();
2287  }
2288 
2290  {
2291  return instance_ok () ? instance->do_loaded_toolkits_list () : Cell ();
2292  }
2293 
2294  static void unload_all_toolkits (void)
2295  {
2296  if (instance_ok ())
2298  }
2299 
2301  {
2302  return instance_ok () ? instance->do_default_toolkit () : "";
2303  }
2304 
2305 private:
2306 
2307  gtk_manager (void) { }
2308 
2309  ~gtk_manager (void) { }
2310 
2311  OCTINTERP_API static void create_instance (void);
2312 
2313  static bool instance_ok (void)
2314  {
2315  bool retval = true;
2316 
2317  if (! instance)
2318  create_instance ();
2319 
2320  if (! instance)
2321  error ("unable to create gh_manager!");
2322 
2323  return retval;
2324  }
2325 
2326  static void cleanup_instance (void) { delete instance; instance = 0; }
2327 
2329 
2330  // The name of the default toolkit.
2332 
2333  // The list of toolkits that we know about.
2334  std::set<std::string> available_toolkits;
2335 
2336  // The list of toolkits we have actually loaded.
2337  std::map<std::string, graphics_toolkit> loaded_toolkits;
2338 
2339  typedef std::set<std::string>::iterator available_toolkits_iterator;
2340 
2341  typedef std::set<std::string>::const_iterator
2343 
2344  typedef std::map<std::string, graphics_toolkit>::iterator
2346 
2347  typedef std::map<std::string, graphics_toolkit>::const_iterator
2349 
2350  graphics_toolkit do_get_toolkit (void) const;
2351 
2352  void do_register_toolkit (const std::string& name);
2353 
2354  void do_unregister_toolkit (const std::string& name);
2355 
2357  {
2358  loaded_toolkits[tk.get_name ()] = tk;
2359  }
2360 
2362  {
2363  loaded_toolkits.erase (name);
2364  }
2365 
2367  {
2368  const_loaded_toolkits_iterator p = loaded_toolkits.find (name);
2369 
2370  if (p != loaded_toolkits.end ())
2371  return p->second;
2372  else
2373  return graphics_toolkit ();
2374  }
2375 
2377  {
2378  Cell m (1, available_toolkits.size ());
2379 
2380  octave_idx_type i = 0;
2381  for (const auto& tkit : available_toolkits)
2382  m(i++) = tkit;
2383 
2384  return m;
2385  }
2386 
2388  {
2389  Cell m (1, loaded_toolkits.size ());
2390 
2391  octave_idx_type i = 0;
2392  for (const auto& nm_tkit_p : loaded_toolkits)
2393  m(i++) = nm_tkit_p.first;
2394 
2395  return m;
2396  }
2397 
2399  {
2400  while (! loaded_toolkits.empty ())
2401  {
2402  loaded_toolkits_iterator p = loaded_toolkits.begin ();
2403 
2404  std::string name = p->first;
2405 
2406  p->second.close ();
2407 
2408  // The toolkit may have unloaded itself. If not, we'll do it here.
2409  if (loaded_toolkits.find (name) != loaded_toolkits.end ())
2410  unload_toolkit (name);
2411  }
2412  }
2413 
2415 };
2416 
2417 // ---------------------------------------------------------------------
2418 
2419 class base_graphics_object;
2420 class graphics_object;
2421 
2423 {
2424 public:
2425  base_properties (const std::string& ty = "unknown",
2426  const graphics_handle& mh = graphics_handle (),
2427  const graphics_handle& p = graphics_handle ());
2428 
2429  virtual ~base_properties (void) { }
2430 
2431  virtual std::string graphics_object_name (void) const { return "unknown"; }
2432 
2433  void mark_modified (void);
2434 
2435  void override_defaults (base_graphics_object& obj);
2436 
2437  virtual void init_integerhandle (const octave_value&)
2438  {
2439  panic_impossible ();
2440  }
2441 
2442  // Look through DEFAULTS for properties with given CLASS_NAME, and
2443  // apply them to the current object with set (virtual method).
2444 
2445  void set_from_list (base_graphics_object& obj, property_list& defaults);
2446 
2448  {
2449  p.set_name (name);
2450  p.set_parent (__myhandle__);
2451  all_props[name] = p;
2452  }
2453 
2454  virtual void set (const caseless_str&, const octave_value&);
2455 
2456  virtual octave_value get (const caseless_str& pname) const;
2457 
2458  virtual octave_value get (const std::string& pname) const
2459  {
2460  return get (caseless_str (pname));
2461  }
2462 
2463  virtual octave_value get (const char *pname) const
2464  {
2465  return get (caseless_str (pname));
2466  }
2467 
2468  virtual octave_value get (bool all = false) const;
2469 
2470  virtual property get_property (const caseless_str& pname);
2471 
2472  virtual bool has_property (const caseless_str&) const
2473  {
2474  panic_impossible ();
2475  return false;
2476  }
2477 
2478  bool is_modified (void) const { return is___modified__ (); }
2479 
2480  virtual void remove_child (const graphics_handle& h)
2481  {
2482  if (children.remove_child (h.value ()))
2483  {
2484  children.run_listeners ();
2485  mark_modified ();
2486  }
2487  }
2488 
2489  virtual void adopt (const graphics_handle& h)
2490  {
2491  children.adopt (h.value ());
2492  children.run_listeners ();
2493  mark_modified ();
2494  }
2495 
2496  virtual graphics_toolkit get_toolkit (void) const;
2497 
2498  virtual Matrix
2499  get_boundingbox (bool /* finternal */ = false,
2500  const Matrix& /* parent_pix_size */ = Matrix ()) const
2501  { return Matrix (1, 4, 0.0); }
2502 
2503  virtual void update_boundingbox (void);
2504 
2505  virtual void update_autopos (const std::string& elem_type);
2506 
2507  virtual void add_listener (const caseless_str&, const octave_value&,
2509 
2510  virtual void delete_listener (const caseless_str&, const octave_value&,
2512 
2513  void set_tag (const octave_value& val) { tag = val; }
2514 
2515  void set_parent (const octave_value& val);
2516 
2517  Matrix get_children (void) const
2518  {
2519  return children.get_children ();
2520  }
2521 
2523  {
2524  return children.get_all ();
2525  }
2526 
2528  {
2529  return children.get_hidden ();
2530  }
2531 
2532  void set_modified (const octave_value& val) { set___modified__ (val); }
2533 
2534  void set___modified__ (const octave_value& val) { __modified__ = val; }
2535 
2536  void reparent (const graphics_handle& new_parent) { parent = new_parent; }
2537 
2538  // Update data limits for AXIS_TYPE (xdata, ydata, etc.) in the parent
2539  // axes object.
2540 
2541  virtual void update_axis_limits (const std::string& axis_type) const;
2542 
2543  virtual void update_axis_limits (const std::string& axis_type,
2544  const graphics_handle& h) const;
2545 
2546  virtual void update_uicontextmenu (void) const;
2547 
2548  virtual void delete_children (bool clear = false)
2549  {
2550  children.delete_children (clear);
2551  }
2552 
2554  {
2555  children.renumber (old_gh, new_gh);
2556  }
2557 
2559  {
2560  parent = new_gh;
2561  }
2562 
2563  static property_list::pval_map_type factory_defaults (void);
2564 
2565  // FIXME: these functions should be generated automatically by the
2566  // genprops.awk script.
2567  //
2568  // EMIT_BASE_PROPERTIES_GET_FUNCTIONS
2569 
2570  virtual octave_value get_alim (void) const { return octave_value (); }
2571  virtual octave_value get_clim (void) const { return octave_value (); }
2572  virtual octave_value get_xlim (void) const { return octave_value (); }
2573  virtual octave_value get_ylim (void) const { return octave_value (); }
2574  virtual octave_value get_zlim (void) const { return octave_value (); }
2575 
2576  virtual bool is_aliminclude (void) const { return false; }
2577  virtual bool is_climinclude (void) const { return false; }
2578  virtual bool is_xliminclude (void) const { return false; }
2579  virtual bool is_yliminclude (void) const { return false; }
2580  virtual bool is_zliminclude (void) const { return false; }
2581 
2582  bool is_handle_visible (void) const;
2583 
2584  std::set<std::string> dynamic_property_names (void) const;
2585 
2586  bool has_dynamic_property (const std::string& pname);
2587 
2588 protected:
2589  std::set<std::string> dynamic_properties;
2590 
2591  void set_dynamic (const caseless_str& pname, const octave_value& val);
2592 
2593  octave_value get_dynamic (const caseless_str& pname) const;
2594 
2595  octave_value get_dynamic (bool all = false) const;
2596 
2597  property get_property_dynamic (const caseless_str& pname);
2598 
2599 public:
2600 
2601 
2602  static std::set<std::string> core_property_names (void);
2603 
2604  static std::set<std::string> readonly_property_names (void);
2605 
2606  static bool has_core_property (const caseless_str& pname);
2607 
2608  static bool has_readonly_property (const caseless_str& pname);
2609 
2610  std::set<std::string> all_property_names (void) const;
2611 
2612 protected:
2613 
2634 
2635 public:
2636 
2637  enum
2638  {
2639  ID_BEINGDELETED = 0,
2640  ID_BUSYACTION = 1,
2641  ID_BUTTONDOWNFCN = 2,
2642  ID_CHILDREN = 3,
2643  ID_CLIPPING = 4,
2644  ID_CREATEFCN = 5,
2645  ID_DELETEFCN = 6,
2646  ID_HANDLEVISIBILITY = 7,
2647  ID_HITTEST = 8,
2648  ID_INTERRUPTIBLE = 9,
2649  ID_PARENT = 10,
2650  ID_SELECTED = 11,
2651  ID_SELECTIONHIGHLIGHT = 12,
2652  ID_TAG = 13,
2653  ID_TYPE = 14,
2654  ID_UICONTEXTMENU = 15,
2655  ID_USERDATA = 16,
2656  ID_VISIBLE = 17,
2657  ID___MODIFIED__ = 18,
2658  ID___MYHANDLE__ = 19
2659  };
2660 
2661  bool is_beingdeleted (void) const { return beingdeleted.is_on (); }
2662  std::string get_beingdeleted (void) const { return beingdeleted.current_value (); }
2663 
2664  bool busyaction_is (const std::string& v) const { return busyaction.is (v); }
2665  std::string get_busyaction (void) const { return busyaction.current_value (); }
2666 
2667  void execute_buttondownfcn (const octave_value& data = octave_value ()) const { buttondownfcn.execute (data); }
2668  octave_value get_buttondownfcn (void) const { return buttondownfcn.get (); }
2669 
2670  bool is_clipping (void) const { return clipping.is_on (); }
2671  std::string get_clipping (void) const { return clipping.current_value (); }
2672 
2673  void execute_createfcn (const octave_value& data = octave_value ()) const { createfcn.execute (data); }
2674  octave_value get_createfcn (void) const { return createfcn.get (); }
2675 
2676  void execute_deletefcn (const octave_value& data = octave_value ()) const { deletefcn.execute (data); }
2677  octave_value get_deletefcn (void) const { return deletefcn.get (); }
2678 
2679  bool handlevisibility_is (const std::string& v) const { return handlevisibility.is (v); }
2680  std::string get_handlevisibility (void) const { return handlevisibility.current_value (); }
2681 
2682  bool is_hittest (void) const { return hittest.is_on (); }
2683  std::string get_hittest (void) const { return hittest.current_value (); }
2684 
2685  bool is_interruptible (void) const { return interruptible.is_on (); }
2686  std::string get_interruptible (void) const { return interruptible.current_value (); }
2687 
2688  graphics_handle get_parent (void) const { return parent.handle_value (); }
2689 
2690  bool is_selected (void) const { return selected.is_on (); }
2691  std::string get_selected (void) const { return selected.current_value (); }
2692 
2693  bool is_selectionhighlight (void) const { return selectionhighlight.is_on (); }
2694  std::string get_selectionhighlight (void) const { return selectionhighlight.current_value (); }
2695 
2696  std::string get_tag (void) const { return tag.string_value (); }
2697 
2698  std::string get_type (void) const { return type.string_value (); }
2699 
2700  graphics_handle get_uicontextmenu (void) const { return uicontextmenu.handle_value (); }
2701 
2702  octave_value get_userdata (void) const { return userdata.get (); }
2703 
2704  bool is_visible (void) const { return visible.is_on (); }
2705  std::string get_visible (void) const { return visible.current_value (); }
2706 
2707  bool is___modified__ (void) const { return __modified__.is_on (); }
2708  std::string get___modified__ (void) const { return __modified__.current_value (); }
2709 
2710  graphics_handle get___myhandle__ (void) const { return __myhandle__; }
2711 
2712 
2714  {
2715  {
2716  if (beingdeleted.set (val, true))
2717  {
2718  mark_modified ();
2719  }
2720  }
2721  }
2722 
2724  {
2725  {
2726  if (busyaction.set (val, true))
2727  {
2728  mark_modified ();
2729  }
2730  }
2731  }
2732 
2734  {
2735  {
2736  if (buttondownfcn.set (val, true))
2737  {
2738  mark_modified ();
2739  }
2740  }
2741  }
2742 
2744  {
2745  {
2746  if (children.set (val, true))
2747  {
2748  mark_modified ();
2749  }
2750  }
2751  }
2752 
2754  {
2755  {
2756  if (clipping.set (val, true))
2757  {
2758  mark_modified ();
2759  }
2760  }
2761  }
2762 
2764  {
2765  {
2766  if (createfcn.set (val, true))
2767  {
2768  mark_modified ();
2769  }
2770  }
2771  }
2772 
2774  {
2775  {
2776  if (deletefcn.set (val, true))
2777  {
2778  mark_modified ();
2779  }
2780  }
2781  }
2782 
2784  {
2785  {
2786  if (handlevisibility.set (val, true))
2787  {
2788  mark_modified ();
2789  }
2790  }
2791  }
2792 
2794  {
2795  {
2796  if (hittest.set (val, true))
2797  {
2798  mark_modified ();
2799  }
2800  }
2801  }
2802 
2804  {
2805  {
2806  if (interruptible.set (val, true))
2807  {
2808  mark_modified ();
2809  }
2810  }
2811  }
2812 
2814  {
2815  {
2816  if (selected.set (val, true))
2817  {
2818  mark_modified ();
2819  }
2820  }
2821  }
2822 
2824  {
2825  {
2826  if (selectionhighlight.set (val, true))
2827  {
2828  mark_modified ();
2829  }
2830  }
2831  }
2832 
2834  {
2835  {
2836  if (uicontextmenu.set (val, true))
2837  {
2838  update_uicontextmenu ();
2839  mark_modified ();
2840  }
2841  }
2842  }
2843 
2845  {
2846  {
2847  if (userdata.set (val, true))
2848  {
2849  mark_modified ();
2850  }
2851  }
2852  }
2853 
2855  {
2856  {
2857  if (visible.set (val, true))
2858  {
2859  mark_modified ();
2860  }
2861  }
2862  }
2863 
2864 
2865 protected:
2867  {
2868  bool operator () (const caseless_str& a, const caseless_str& b) const
2869  {
2870  std::string a1 = a;
2871  std::transform (a1.begin (), a1.end (), a1.begin (), tolower);
2872  std::string b1 = b;
2873  std::transform (b1.begin (), b1.end (), b1.begin (), tolower);
2874 
2875  return a1 < b1;
2876  }
2877  };
2878 
2879  std::map<caseless_str, property, cmp_caseless_str> all_props;
2880 
2881 protected:
2883  { insert_property (name, property (&p, true)); }
2884 
2885  virtual void init (void) { }
2886 };
2887 
2889 {
2890 public:
2891  friend class graphics_object;
2892 
2893  base_graphics_object (void) : count (1), toolkit_flag (false) { }
2894 
2895  virtual ~base_graphics_object (void) { }
2896 
2897  virtual void mark_modified (void)
2898  {
2899  if (! valid_object ())
2900  error ("base_graphics_object::mark_modified: invalid graphics object");
2901 
2903  }
2904 
2906  {
2907  if (! valid_object ())
2908  error ("base_graphics_object::override_defaults: invalid graphics object");
2910  }
2911 
2913  const std::string go_name) const;
2914 
2915  virtual void set_from_list (property_list& plist)
2916  {
2917  if (! valid_object ())
2918  error ("base_graphics_object::set_from_list: invalid graphics object");
2919 
2920  get_properties ().set_from_list (*this, plist);
2921  }
2922 
2923  virtual void set (const caseless_str& pname, const octave_value& pval)
2924  {
2925  if (! valid_object ())
2926  error ("base_graphics_object::set: invalid graphics object");
2927 
2928  get_properties ().set (pname, pval);
2929  }
2930 
2931  virtual void set_defaults (const std::string&)
2932  {
2933  error ("base_graphics_object::set_defaults: invalid graphics object");
2934  }
2935 
2936  virtual octave_value get (bool all = false) const
2937  {
2938  if (! valid_object ())
2939  error ("base_graphics_object::get: invalid graphics object");
2940 
2941  return get_properties ().get (all);
2942  }
2943 
2944  virtual octave_value get (const caseless_str& pname) const
2945  {
2946  if (! valid_object ())
2947  error ("base_graphics_object::get: invalid graphics object");
2948 
2949  return get_properties ().get (pname);
2950  }
2951 
2952  virtual octave_value get_default (const caseless_str&) const;
2953 
2954  virtual octave_value get_factory_default (const caseless_str&) const;
2955 
2956  virtual octave_value get_defaults (void) const
2957  {
2958  error ("base_graphics_object::get_defaults: invalid graphics object");
2959  }
2960 
2961  virtual property_list get_defaults_list (void) const
2962  {
2963  if (! valid_object ())
2964  error ("base_graphics_object::get_defaults_list: invalid graphics object");
2965 
2966  return property_list ();
2967  }
2968 
2969  virtual octave_value get_factory_defaults (void) const
2970  {
2971  error ("base_graphics_object::get_factory_defaults: invalid graphics object");
2972  }
2973 
2975  {
2976  error ("base_graphics_object::get_factory_defaults_list: invalid graphics object");
2977  }
2978 
2979  virtual bool has_readonly_property (const caseless_str& pname) const
2980  {
2982  }
2983 
2984  virtual std::string values_as_string (void);
2985 
2986  virtual std::string value_as_string (const std::string& prop);
2987 
2988  virtual octave_scalar_map values_as_struct (void);
2989 
2990  virtual graphics_handle get_parent (void) const
2991  {
2992  if (! valid_object ())
2993  error ("base_graphics_object::get_parent: invalid graphics object");
2994 
2995  return get_properties ().get_parent ();
2996  }
2997 
2999  {
3000  if (! valid_object ())
3001  error ("base_graphics_object::get_handle: invalid graphics object");
3002 
3003  return get_properties ().get___myhandle__ ();
3004  }
3005 
3006  virtual void remove_child (const graphics_handle& h)
3007  {
3008  if (! valid_object ())
3009  error ("base_graphics_object::remove_child: invalid graphics object");
3010 
3012  }
3013 
3014  virtual void adopt (const graphics_handle& h)
3015  {
3016  if (! valid_object ())
3017  error ("base_graphics_object::adopt: invalid graphics object");
3018 
3019  get_properties ().adopt (h);
3020  }
3021 
3022  virtual void reparent (const graphics_handle& np)
3023  {
3024  if (! valid_object ())
3025  error ("base_graphics_object::reparent: invalid graphics object");
3026 
3027  get_properties ().reparent (np);
3028  }
3029 
3030  virtual void defaults (void) const
3031  {
3032  if (! valid_object ())
3033  error ("base_graphics_object::default: invalid graphics object");
3034 
3035  std::string msg = (type () + "::defaults");
3036  err_not_implemented (msg.c_str ());
3037  }
3038 
3040  {
3041  static base_properties properties;
3042  warning ("base_graphics_object::get_properties: invalid graphics object");
3043  return properties;
3044  }
3045 
3046  virtual const base_properties& get_properties (void) const
3047  {
3048  static base_properties properties;
3049  warning ("base_graphics_object::get_properties: invalid graphics object");
3050  return properties;
3051  }
3052 
3053  virtual void update_axis_limits (const std::string& axis_type);
3054 
3055  virtual void update_axis_limits (const std::string& axis_type,
3056  const graphics_handle& h);
3057 
3058  virtual bool valid_object (void) const { return false; }
3059 
3060  bool valid_toolkit_object (void) const { return toolkit_flag; }
3061 
3062  virtual std::string type (void) const
3063  {
3064  return (valid_object () ? get_properties ().graphics_object_name ()
3065  : "unknown");
3066  }
3067 
3068  bool isa (const std::string& go_name) const
3069  {
3070  return type () == go_name;
3071  }
3072 
3073  virtual graphics_toolkit get_toolkit (void) const
3074  {
3075  if (! valid_object ())
3076  error ("base_graphics_object::get_toolkit: invalid graphics object");
3077 
3078  return get_properties ().get_toolkit ();
3079  }
3080 
3081  virtual void add_property_listener (const std::string& nm,
3082  const octave_value& v,
3084  {
3085  if (valid_object ())
3086  get_properties ().add_listener (nm, v, mode);
3087  }
3088 
3089  virtual void delete_property_listener (const std::string& nm,
3090  const octave_value& v,
3092  {
3093  if (valid_object ())
3094  get_properties ().delete_listener (nm, v, mode);
3095  }
3096 
3097  virtual void remove_all_listeners (void);
3098 
3099  virtual void reset_default_properties (void);
3100 
3101 protected:
3102  virtual void initialize (const graphics_object& go)
3103  {
3104  if (! toolkit_flag)
3105  toolkit_flag = get_toolkit ().initialize (go);
3106  }
3107 
3108  virtual void finalize (const graphics_object& go)
3109  {
3110  if (toolkit_flag)
3111  {
3112  get_toolkit ().finalize (go);
3113  toolkit_flag = false;
3114  }
3115  }
3116 
3117  virtual void update (const graphics_object& go, int id)
3118  {
3119  if (toolkit_flag)
3120  get_toolkit ().update (go, id);
3121  }
3122 
3123 protected:
3124  // A reference count.
3126 
3127  // A flag telling whether this object is a valid object
3128  // in the backend context.
3130 
3131  // No copying!
3132 
3134 
3136  {
3137  return *this;
3138  }
3139 };
3140 
3142 {
3143 public:
3144  graphics_object (void) : rep (new base_graphics_object ()) { }
3145 
3147  : rep (new_rep) { }
3148 
3149  graphics_object (const graphics_object& obj) : rep (obj.rep)
3150  {
3151  rep->count++;
3152  }
3153 
3154  graphics_object& operator = (const graphics_object& obj)
3155  {
3156  if (rep != obj.rep)
3157  {
3158  if (--rep->count == 0)
3159  delete rep;
3160 
3161  rep = obj.rep;
3162  rep->count++;
3163  }
3164 
3165  return *this;
3166  }
3167 
3169  {
3170  if (--rep->count == 0)
3171  delete rep;
3172  }
3173 
3174  void mark_modified (void) { rep->mark_modified (); }
3175 
3177  {
3178  rep->override_defaults (obj);
3179  }
3180 
3181  void override_defaults (void)
3182  {
3183  rep->override_defaults (*rep);
3184  }
3185 
3187  const std::string go_name) const
3188  {
3189  rep->build_user_defaults_map (def, go_name);
3190  }
3191 
3192  void set_from_list (property_list& plist) { rep->set_from_list (plist); }
3193 
3194  void set (const caseless_str& name, const octave_value& val)
3195  {
3196  rep->set (name, val);
3197  }
3198 
3199  void set (const octave_value_list& args);
3200 
3201  void set (const Array<std::string>& names, const Cell& values,
3203 
3204  void set (const octave_map& m);
3205 
3206  void set_value_or_default (const caseless_str& name,
3207  const octave_value& val);
3208 
3209  void set_defaults (const std::string& mode) { rep->set_defaults (mode); }
3210 
3211  octave_value get (bool all = false) const { return rep->get (all); }
3212 
3213  octave_value get (const caseless_str& name) const
3214  {
3215  return name.compare ("default")
3216  ? get_defaults ()
3217  : (name.compare ("factory")
3218  ? get_factory_defaults () : rep->get (name));
3219  }
3220 
3221  octave_value get (const std::string& name) const
3222  {
3223  return get (caseless_str (name));
3224  }
3225 
3226  octave_value get (const char *name) const
3227  {
3228  return get (caseless_str (name));
3229  }
3230 
3232  {
3233  return rep->get_default (name);
3234  }
3235 
3237  {
3238  return rep->get_factory_default (name);
3239  }
3240 
3241  octave_value get_defaults (void) const { return rep->get_defaults (); }
3242 
3244  {
3245  return rep->get_defaults_list ();
3246  }
3247 
3249  {
3250  return rep->get_factory_defaults ();
3251  }
3252 
3254  {
3255  return rep->get_factory_defaults_list ();
3256  }
3257 
3259  {
3260  return rep->has_readonly_property (pname);
3261  }
3262 
3263  std::string values_as_string (void) { return rep->values_as_string (); }
3264 
3266  {
3267  return rep->value_as_string (prop);
3268  }
3269 
3270  octave_map values_as_struct (void) { return rep->values_as_struct (); }
3271 
3272  graphics_handle get_parent (void) const { return rep->get_parent (); }
3273 
3274  graphics_handle get_handle (void) const { return rep->get_handle (); }
3275 
3276  graphics_object get_ancestor (const std::string& type) const;
3277 
3278  void remove_child (const graphics_handle& h) { rep->remove_child (h); }
3279 
3280  void adopt (const graphics_handle& h) { rep->adopt (h); }
3281 
3282  void reparent (const graphics_handle& h) { rep->reparent (h); }
3283 
3284  void defaults (void) const { rep->defaults (); }
3285 
3286  bool isa (const std::string& go_name) const { return rep->isa (go_name); }
3287 
3288  base_properties& get_properties (void) { return rep->get_properties (); }
3289 
3290  const base_properties& get_properties (void) const
3291  {
3292  return rep->get_properties ();
3293  }
3294 
3295  void update_axis_limits (const std::string& axis_type)
3296  {
3297  rep->update_axis_limits (axis_type);
3298  }
3299 
3300  void update_axis_limits (const std::string& axis_type,
3301  const graphics_handle& h)
3302  {
3303  rep->update_axis_limits (axis_type, h);
3304  }
3305 
3306  bool valid_object (void) const { return rep->valid_object (); }
3307 
3308  std::string type (void) const { return rep->type (); }
3309 
3310  operator bool (void) const { return rep->valid_object (); }
3311 
3312  // FIXME: these functions should be generated automatically by the
3313  // genprops.awk script.
3314  //
3315  // EMIT_GRAPHICS_OBJECT_GET_FUNCTIONS
3316 
3317  octave_value get_alim (void) const
3318  { return get_properties ().get_alim (); }
3319 
3320  octave_value get_clim (void) const
3321  { return get_properties ().get_clim (); }
3322 
3323  octave_value get_xlim (void) const
3324  { return get_properties ().get_xlim (); }
3325 
3326  octave_value get_ylim (void) const
3327  { return get_properties ().get_ylim (); }
3328 
3329  octave_value get_zlim (void) const
3330  { return get_properties ().get_zlim (); }
3331 
3332  bool is_aliminclude (void) const
3333  { return get_properties ().is_aliminclude (); }
3334 
3335  bool is_climinclude (void) const
3336  { return get_properties ().is_climinclude (); }
3337 
3338  bool is_xliminclude (void) const
3339  { return get_properties ().is_xliminclude (); }
3340 
3341  bool is_yliminclude (void) const
3342  { return get_properties ().is_yliminclude (); }
3343 
3344  bool is_zliminclude (void) const
3345  { return get_properties ().is_zliminclude (); }
3346 
3347  bool is_handle_visible (void) const
3348  { return get_properties ().is_handle_visible (); }
3349 
3350  graphics_toolkit get_toolkit (void) const { return rep->get_toolkit (); }
3351 
3354  { rep->add_property_listener (nm, v, mode); }
3355 
3358  { rep->delete_property_listener (nm, v, mode); }
3359 
3360  void initialize (void) { rep->initialize (*this); }
3361 
3362  void finalize (void) { rep->finalize (*this); }
3363 
3364  void update (int id) { rep->update (*this, id); }
3365 
3367  { rep->reset_default_properties (); }
3368 
3369 private:
3371 };
3372 
3373 // ---------------------------------------------------------------------
3374 
3376 {
3377 public:
3379  {
3380  public:
3381  void remove_child (const graphics_handle& h);
3382 
3383  Matrix get_boundingbox (bool internal = false,
3384  const Matrix& parent_pix_size = Matrix ()) const;
3385 
3386  // See the genprops.awk script for an explanation of the
3387  // properties declarations.
3388 
3389  // FIXME: Properties that still don't have callbacks are:
3390  // monitorpositions, pointerlocation, pointerwindow.
3391  // Note that these properties are not yet used by Octave, so setting
3392  // them will have no effect.
3393 
3394  // FIXME: The commandwindowsize property has been deprecated in Matlab
3395  // and is now available through matlab.desktop.comandwindow.size.
3396  // Until Octave has something similar, keep this property in root.
3397 
3398  // Programming note: Keep property list sorted if new ones are added.
3399 
3400 public:
3401  properties (const graphics_handle& mh, const graphics_handle& p);
3402 
3403  ~properties (void) { }
3404 
3405  void set (const caseless_str& pname, const octave_value& val);
3406 
3407  octave_value get (bool all = false) const;
3408 
3409  octave_value get (const caseless_str& pname) const;
3410 
3411  octave_value get (const std::string& pname) const
3412  {
3413  return get (caseless_str (pname));
3414  }
3415 
3416  octave_value get (const char *pname) const
3417  {
3418  return get (caseless_str (pname));
3419  }
3420 
3421  property get_property (const caseless_str& pname);
3422 
3423  std::string graphics_object_name (void) const { return go_name; }
3424 
3426 
3427 private:
3429 
3430 public:
3431 
3432 
3433  static std::set<std::string> core_property_names (void);
3434 
3435  static std::set<std::string> readonly_property_names (void);
3436 
3437  static bool has_core_property (const caseless_str& pname);
3438 
3439  static bool has_readonly_property (const caseless_str& pname);
3440 
3441  std::set<std::string> all_property_names (void) const;
3442 
3443  bool has_property (const caseless_str& pname) const;
3444 
3445 private:
3446 
3459 
3460 public:
3461 
3462  enum
3463  {
3464  ID_CALLBACKOBJECT = 1000,
3465  ID_COMMANDWINDOWSIZE = 1001,
3466  ID_CURRENTFIGURE = 1002,
3467  ID_FIXEDWIDTHFONTNAME = 1003,
3468  ID_MONITORPOSITIONS = 1004,
3469  ID_POINTERLOCATION = 1005,
3470  ID_POINTERWINDOW = 1006,
3471  ID_SCREENDEPTH = 1007,
3472  ID_SCREENPIXELSPERINCH = 1008,
3473  ID_SCREENSIZE = 1009,
3474  ID_SHOWHIDDENHANDLES = 1010,
3475  ID_UNITS = 1011
3476  };
3477 
3478  graphics_handle get_callbackobject (void) const { return callbackobject.handle_value (); }
3479 
3480  octave_value get_commandwindowsize (void) const { return commandwindowsize.get (); }
3481 
3482  graphics_handle get_currentfigure (void) const { return currentfigure.handle_value (); }
3483 
3484  std::string get_fixedwidthfontname (void) const { return fixedwidthfontname.string_value (); }
3485 
3486  octave_value get_monitorpositions (void) const { return monitorpositions.get (); }
3487 
3488  octave_value get_pointerlocation (void) const { return pointerlocation.get (); }
3489 
3490  double get_pointerwindow (void) const { return pointerwindow.double_value (); }
3491 
3492  double get_screendepth (void) const { return screendepth.double_value (); }
3493 
3494  double get_screenpixelsperinch (void) const { return screenpixelsperinch.double_value (); }
3495 
3496  octave_value get_screensize (void) const { return screensize.get (); }
3497 
3498  bool is_showhiddenhandles (void) const { return showhiddenhandles.is_on (); }
3499  std::string get_showhiddenhandles (void) const { return showhiddenhandles.current_value (); }
3500 
3501  bool units_is (const std::string& v) const { return units.is (v); }
3502  std::string get_units (void) const { return units.current_value (); }
3503 
3504 
3505  void set_callbackobject (const octave_value& val);
3506 
3508  {
3509  {
3510  if (commandwindowsize.set (val, true))
3511  {
3512  mark_modified ();
3513  }
3514  }
3515  }
3516 
3517  void set_currentfigure (const octave_value& val);
3518 
3520  {
3521  {
3522  if (fixedwidthfontname.set (val, true))
3523  {
3524  mark_modified ();
3525  }
3526  }
3527  }
3528 
3530  {
3531  {
3532  if (monitorpositions.set (val, true))
3533  {
3534  mark_modified ();
3535  }
3536  }
3537  }
3538 
3540  {
3541  {
3542  if (pointerlocation.set (val, true))
3543  {
3544  mark_modified ();
3545  }
3546  }
3547  }
3548 
3550  {
3551  {
3552  if (pointerwindow.set (val, true))
3553  {
3554  mark_modified ();
3555  }
3556  }
3557  }
3558 
3560  {
3561  {
3562  if (screendepth.set (val, true))
3563  {
3564  mark_modified ();
3565  }
3566  }
3567  }
3568 
3570  {
3571  {
3572  if (screenpixelsperinch.set (val, true))
3573  {
3574  mark_modified ();
3575  }
3576  }
3577  }
3578 
3580  {
3581  {
3582  if (screensize.set (val, true))
3583  {
3584  mark_modified ();
3585  }
3586  }
3587  }
3588 
3590  {
3591  {
3592  if (showhiddenhandles.set (val, true))
3593  {
3594  mark_modified ();
3595  }
3596  }
3597  }
3598 
3600  {
3601  {
3602  if (units.set (val, true))
3603  {
3604  update_units ();
3605  mark_modified ();
3606  }
3607  }
3608  }
3609 
3610  void update_units (void);
3611 
3612 
3613  private:
3614  std::list<graphics_handle> cbo_stack;
3615 
3616  };
3617 
3618 private:
3620 
3621 public:
3622 
3624  : xproperties (0, graphics_handle ()), default_properties () { }
3625 
3626  ~root_figure (void) { }
3627 
3628  void mark_modified (void) { }
3629 
3631  {
3632  // Now override with our defaults. If the default_properties
3633  // list includes the properties for all defaults (line,
3634  // surface, etc.) then we don't have to know the type of OBJ
3635  // here, we just call its set function and let it decide which
3636  // properties from the list to use.
3637  obj.set_from_list (default_properties);
3638  }
3639 
3640  void set (const caseless_str& name, const octave_value& value)
3641  {
3642  if (name.compare ("default", 7))
3643  // strip "default", pass rest to function that will
3644  // parse the remainder and add the element to the
3645  // default_properties map.
3646  default_properties.set (name.substr (7), value);
3647  else
3648  xproperties.set (name, value);
3649  }
3650 
3651  octave_value get (const caseless_str& name) const
3652  {
3654 
3655  if (name.compare ("default", 7))
3656  return get_default (name.substr (7));
3657  else if (name.compare ("factory", 7))
3658  return get_factory_default (name.substr (7));
3659  else
3660  retval = xproperties.get (name);
3661 
3662  return retval;
3663  }
3664 
3666  {
3667  octave_value retval = default_properties.lookup (name);
3668 
3669  if (retval.is_undefined ())
3670  {
3671  // no default property found, use factory default
3672  retval = factory_properties.lookup (name);
3673 
3674  if (retval.is_undefined ())
3675  error ("get: invalid default property '%s'", name.c_str ());
3676  }
3677 
3678  return retval;
3679  }
3680 
3682  {
3683  octave_value retval = factory_properties.lookup (name);
3684 
3685  if (retval.is_undefined ())
3686  error ("get: invalid factory default property '%s'", name.c_str ());
3687 
3688  return retval;
3689  }
3690 
3692  {
3693  return default_properties.as_struct ("default");
3694  }
3695 
3697  {
3698  return default_properties;
3699  }
3700 
3702  {
3703  return factory_properties.as_struct ("factory");
3704  }
3705 
3707  {
3708  return factory_properties;
3709  }
3710 
3711  base_properties& get_properties (void) { return xproperties; }
3712 
3713  const base_properties& get_properties (void) const { return xproperties; }
3714 
3715  bool valid_object (void) const { return true; }
3716 
3717  void reset_default_properties (void);
3718 
3720  {
3721  bool retval = xproperties.has_readonly_property (pname);
3722  if (! retval)
3723  retval = base_properties::has_readonly_property (pname);
3724  return retval;
3725  }
3726 
3727 private:
3729 
3731 
3732  static property_list::plist_map_type init_factory_properties (void);
3733 };
3734 
3735 // ---------------------------------------------------------------------
3736 
3738 {
3739 public:
3741  {
3742  public:
3744  {
3745  integerhandle = val;
3746  }
3747 
3748  void remove_child (const graphics_handle& h);
3749 
3750  void set_visible (const octave_value& val);
3751 
3753  {
3754  if (! toolkit)
3755  toolkit = gtk_manager::get_toolkit ();
3756 
3757  return toolkit;
3758  }
3759 
3760  void set_toolkit (const graphics_toolkit& b);
3761 
3763  {
3764  if (! val.is_string ())
3765  error ("set___graphics_toolkit__ must be a string");
3766 
3767  std::string nm = val.string_value ();
3769 
3770  if (b.get_name () != nm)
3771  error ("set___graphics_toolkit__: invalid graphics toolkit");
3772 
3773  if (nm != get___graphics_toolkit__ ())
3774  {
3775  set_toolkit (b);
3776  mark_modified ();
3777  }
3778  }
3779 
3780  void adopt (const graphics_handle& h);
3781 
3782  void set_position (const octave_value& val,
3783  bool do_notify_toolkit = true);
3784 
3785  void set_outerposition (const octave_value& val,
3786  bool do_notify_toolkit = true);
3787 
3788  Matrix get_boundingbox (bool internal = false,
3789  const Matrix& parent_pix_size = Matrix ()) const;
3790 
3791  void set_boundingbox (const Matrix& bb, bool internal = false,
3792  bool do_notify_toolkit = true);
3793 
3794  Matrix map_from_boundingbox (double x, double y) const;
3795 
3796  Matrix map_to_boundingbox (double x, double y) const;
3797 
3798  void update_units (const caseless_str& old_units);
3799 
3800  void update_paperunits (const caseless_str& old_paperunits);
3801 
3802  std::string get_title (void) const;
3803 
3804  // See the genprops.awk script for an explanation of the
3805  // properties declarations.
3806  // FIXME: Several properties have been deleted from Matlab.
3807  // We should either immediately remove them or figure out a way
3808  // to deprecate them for a release or two.
3809  // Obsolete properties: doublebuffer, mincolormap, wvisual, wvisualmode,
3810  // xdisplay, xvisual, xvisualmode
3811 
3812  // Programming note: Keep property list sorted if new ones are added.
3813 
3814 public:
3815  properties (const graphics_handle& mh, const graphics_handle& p);
3816 
3817  ~properties (void) { }
3818 
3819  void set (const caseless_str& pname, const octave_value& val);
3820 
3821  octave_value get (bool all = false) const;
3822 
3823  octave_value get (const caseless_str& pname) const;
3824 
3825  octave_value get (const std::string& pname) const
3826  {
3827  return get (caseless_str (pname));
3828  }
3829 
3830  octave_value get (const char *pname) const
3831  {
3832  return get (caseless_str (pname));
3833  }
3834 
3835  property get_property (const caseless_str& pname);
3836 
3837  std::string graphics_object_name (void) const { return go_name; }
3838 
3840 
3841 private:
3843 
3844 public:
3845 
3846 
3847  static std::set<std::string> core_property_names (void);
3848 
3849  static std::set<std::string> readonly_property_names (void);
3850 
3851  static bool has_core_property (const caseless_str& pname);
3852 
3853  static bool has_readonly_property (const caseless_str& pname);
3854 
3855  std::set<std::string> all_property_names (void) const;
3856 
3857  bool has_property (const caseless_str& pname) const;
3858 
3859 private:
3860 
3925 
3926 public:
3927 
3928  enum
3929  {
3930  ID_ALPHAMAP = 2000,
3931  ID_BUTTONDOWNFCN = 2001,
3932  ID_CLOSEREQUESTFCN = 2002,
3933  ID_COLOR = 2003,
3934  ID_COLORMAP = 2004,
3935  ID_CURRENTAXES = 2005,
3936  ID_CURRENTCHARACTER = 2006,
3937  ID_CURRENTOBJECT = 2007,
3938  ID_CURRENTPOINT = 2008,
3939  ID_DOCKCONTROLS = 2009,
3940  ID_FILENAME = 2010,
3941  ID_GRAPHICSSMOOTHING = 2011,
3942  ID_INTEGERHANDLE = 2012,
3943  ID_INVERTHARDCOPY = 2013,
3944  ID_KEYPRESSFCN = 2014,
3945  ID_KEYRELEASEFCN = 2015,
3946  ID_MENUBAR = 2016,
3947  ID_NAME = 2017,
3948  ID_NEXTPLOT = 2018,
3949  ID_NUMBERTITLE = 2019,
3950  ID_OUTERPOSITION = 2020,
3951  ID_PAPERORIENTATION = 2021,
3952  ID_PAPERPOSITION = 2022,
3953  ID_PAPERPOSITIONMODE = 2023,
3954  ID_PAPERSIZE = 2024,
3955  ID_PAPERTYPE = 2025,
3956  ID_PAPERUNITS = 2026,
3957  ID_POINTER = 2027,
3958  ID_POINTERSHAPECDATA = 2028,
3959  ID_POINTERSHAPEHOTSPOT = 2029,
3960  ID_POSITION = 2030,
3961  ID_RENDERER = 2031,
3962  ID_RENDERERMODE = 2032,
3963  ID_RESIZE = 2033,
3964  ID_RESIZEFCN = 2034,
3965  ID_SELECTIONTYPE = 2035,
3966  ID_SIZECHANGEDFCN = 2036,
3967  ID_TOOLBAR = 2037,
3968  ID_UNITS = 2038,
3969  ID_WINDOWBUTTONDOWNFCN = 2039,
3970  ID_WINDOWBUTTONMOTIONFCN = 2040,
3971  ID_WINDOWBUTTONUPFCN = 2041,
3972  ID_WINDOWKEYPRESSFCN = 2042,
3973  ID_WINDOWKEYRELEASEFCN = 2043,
3974  ID_WINDOWSCROLLWHEELFCN = 2044,
3975  ID_WINDOWSTYLE = 2045,
3976  ID___GL_EXTENSIONS__ = 2046,
3977  ID___GL_RENDERER__ = 2047,
3978  ID___GL_VENDOR__ = 2048,
3979  ID___GL_VERSION__ = 2049,
3980  ID___GRAPHICS_TOOLKIT__ = 2050,
3981  ID___GUIDATA__ = 2051,
3982  ID___MOUSE_MODE__ = 2052,
3983  ID___PAN_MODE__ = 2053,
3984  ID___PLOT_STREAM__ = 2054,
3985  ID___ROTATE_MODE__ = 2055,
3986  ID___ZOOM_MODE__ = 2056,
3987  ID_DOUBLEBUFFER = 2057,
3988  ID_MINCOLORMAP = 2058,
3989  ID_WVISUAL = 2059,
3990  ID_WVISUALMODE = 2060,
3991  ID_XDISPLAY = 2061,
3992  ID_XVISUAL = 2062,
3993  ID_XVISUALMODE = 2063
3994  };
3995 
3996  octave_value get_alphamap (void) const { return alphamap.get (); }
3997 
3998  void execute_buttondownfcn (const octave_value& data = octave_value ()) const { buttondownfcn.execute (data); }
3999  octave_value get_buttondownfcn (void) const { return buttondownfcn.get (); }
4000 
4001  void execute_closerequestfcn (const octave_value& data = octave_value ()) const { closerequestfcn.execute (data); }
4002  octave_value get_closerequestfcn (void) const { return closerequestfcn.get (); }
4003 
4004  bool color_is_rgb (void) const { return color.is_rgb (); }
4005  bool color_is (const std::string& v) const { return color.is (v); }
4006  Matrix get_color_rgb (void) const { return (color.is_rgb () ? color.rgb () : Matrix ()); }
4007  octave_value get_color (void) const { return color.get (); }
4008 
4009  octave_value get_colormap (void) const { return colormap.get (); }
4010 
4011  graphics_handle get_currentaxes (void) const { return currentaxes.handle_value (); }
4012 
4013  std::string get_currentcharacter (void) const { return currentcharacter.string_value (); }
4014 
4015  graphics_handle get_currentobject (void) const { return currentobject.handle_value (); }
4016 
4017  octave_value get_currentpoint (void) const { return currentpoint.get (); }
4018 
4019  bool is_dockcontrols (void) const { return dockcontrols.is_on (); }
4020  std::string get_dockcontrols (void) const { return dockcontrols.current_value (); }
4021 
4022  std::string get_filename (void) const { return filename.string_value (); }
4023 
4024  bool is_graphicssmoothing (void) const { return graphicssmoothing.is_on (); }
4025  std::string get_graphicssmoothing (void) const { return graphicssmoothing.current_value (); }
4026 
4027  bool is_integerhandle (void) const { return integerhandle.is_on (); }
4028  std::string get_integerhandle (void) const { return integerhandle.current_value (); }
4029 
4030  bool is_inverthardcopy (void) const { return inverthardcopy.is_on (); }
4031  std::string get_inverthardcopy (void) const { return inverthardcopy.current_value (); }
4032 
4033  void execute_keypressfcn (const octave_value& data = octave_value ()) const { keypressfcn.execute (data); }
4034  octave_value get_keypressfcn (void) const { return keypressfcn.get (); }
4035 
4036  void execute_keyreleasefcn (const octave_value& data = octave_value ()) const { keyreleasefcn.execute (data); }
4037  octave_value get_keyreleasefcn (void) const { return keyreleasefcn.get (); }
4038 
4039  bool menubar_is (const std::string& v) const { return menubar.is (v); }
4040  std::string get_menubar (void) const { return menubar.current_value (); }
4041 
4042  std::string get_name (void) const { return name.string_value (); }
4043 
4044  bool nextplot_is (const std::string& v) const { return nextplot.is (v); }
4045  std::string get_nextplot (void) const { return nextplot.current_value (); }
4046 
4047  bool is_numbertitle (void) const { return numbertitle.is_on (); }
4048  std::string get_numbertitle (void) const { return numbertitle.current_value (); }
4049 
4050  octave_value get_outerposition (void) const { return outerposition.get (); }
4051 
4052  bool paperorientation_is (const std::string& v) const { return paperorientation.is (v); }
4053  std::string get_paperorientation (void) const { return paperorientation.current_value (); }
4054 
4055  octave_value get_paperposition (void) const { return paperposition.get (); }
4056 
4057  bool paperpositionmode_is (const std::string& v) const { return paperpositionmode.is (v); }
4058  std::string get_paperpositionmode (void) const { return paperpositionmode.current_value (); }
4059 
4060  octave_value get_papersize (void) const { return papersize.get (); }
4061 
4062  bool papertype_is (const std::string& v) const { return papertype.is (v); }
4063  std::string get_papertype (void) const { return papertype.current_value (); }
4064 
4065  bool paperunits_is (const std::string& v) const { return paperunits.is (v); }
4066  std::string get_paperunits (void) const { return paperunits.current_value (); }
4067 
4068  bool pointer_is (const std::string& v) const { return pointer.is (v); }
4069  std::string get_pointer (void) const { return pointer.current_value (); }
4070 
4071  octave_value get_pointershapecdata (void) const { return pointershapecdata.get (); }
4072 
4073  octave_value get_pointershapehotspot (void) const { return pointershapehotspot.get (); }
4074 
4075  octave_value get_position (void) const { return position.get (); }
4076 
4077  bool renderer_is (const std::string& v) const { return renderer.is (v); }
4078  std::string get_renderer (void) const { return renderer.current_value (); }
4079 
4080  bool renderermode_is (const std::string& v) const { return renderermode.is (v); }
4081  std::string get_renderermode (void) const { return renderermode.current_value (); }
4082 
4083  bool is_resize (void) const { return resize.is_on (); }
4084  std::string get_resize (void) const { return resize.current_value (); }
4085 
4086  void execute_resizefcn (const octave_value& data = octave_value ()) const { resizefcn.execute (data); }
4087  octave_value get_resizefcn (void) const { return resizefcn.get (); }
4088 
4089  bool selectiontype_is (const std::string& v) const { return selectiontype.is (v); }
4090  std::string get_selectiontype (void) const { return selectiontype.current_value (); }
4091 
4092  void execute_sizechangedfcn (const octave_value& data = octave_value ()) const { sizechangedfcn.execute (data); }
4093  octave_value get_sizechangedfcn (void) const { return sizechangedfcn.get (); }
4094 
4095  bool toolbar_is (const std::string& v) const { return toolbar.is (v); }
4096  std::string get_toolbar (void) const { return toolbar.current_value (); }
4097 
4098  bool units_is (const std::string& v) const { return units.is (v); }
4099  std::string get_units (void) const { return units.current_value (); }
4100 
4101  void execute_windowbuttondownfcn (const octave_value& data = octave_value ()) const { windowbuttondownfcn.execute (data); }
4102  octave_value get_windowbuttondownfcn (void) const { return windowbuttondownfcn.get (); }
4103 
4104  void execute_windowbuttonmotionfcn (const octave_value& data = octave_value ()) const { windowbuttonmotionfcn.execute (data); }
4105  octave_value get_windowbuttonmotionfcn (void) const { return windowbuttonmotionfcn.get (); }
4106 
4107  void execute_windowbuttonupfcn (const octave_value& data = octave_value ()) const { windowbuttonupfcn.execute (data); }
4108  octave_value get_windowbuttonupfcn (void) const { return windowbuttonupfcn.get (); }
4109 
4110  void execute_windowkeypressfcn (const octave_value& data = octave_value ()) const { windowkeypressfcn.execute (data); }
4111  octave_value get_windowkeypressfcn (void) const { return windowkeypressfcn.get (); }
4112 
4113  void execute_windowkeyreleasefcn (const octave_value& data = octave_value ()) const { windowkeyreleasefcn.execute (data); }
4114  octave_value get_windowkeyreleasefcn (void) const { return windowkeyreleasefcn.get (); }
4115 
4116  void execute_windowscrollwheelfcn (const octave_value& data = octave_value ()) const { windowscrollwheelfcn.execute (data); }
4117  octave_value get_windowscrollwheelfcn (void) const { return windowscrollwheelfcn.get (); }
4118 
4119  bool windowstyle_is (const std::string& v) const { return windowstyle.is (v); }
4120  std::string get_windowstyle (void) const { return windowstyle.current_value (); }
4121 
4122  std::string get___gl_extensions__ (void) const { return __gl_extensions__.string_value (); }
4123 
4124  std::string get___gl_renderer__ (void) const { return __gl_renderer__.string_value (); }
4125 
4126  std::string get___gl_vendor__ (void) const { return __gl_vendor__.string_value (); }
4127 
4128  std::string get___gl_version__ (void) const { return __gl_version__.string_value (); }
4129 
4130  std::string get___graphics_toolkit__ (void) const { return __graphics_toolkit__.string_value (); }
4131 
4132  octave_value get___guidata__ (void) const { return __guidata__.get (); }
4133 
4134  bool __mouse_mode___is (const std::string& v) const { return __mouse_mode__.is (v); }
4135  std::string get___mouse_mode__ (void) const { return __mouse_mode__.current_value (); }
4136 
4137  octave_value get___pan_mode__ (void) const { return __pan_mode__.get (); }
4138 
4139  octave_value get___plot_stream__ (void) const { return __plot_stream__.get (); }
4140 
4141  octave_value get___rotate_mode__ (void) const { return __rotate_mode__.get (); }
4142 
4143  octave_value get___zoom_mode__ (void) const { return __zoom_mode__.get (); }
4144 
4145  bool is_doublebuffer (void) const { return doublebuffer.is_on (); }
4146  std::string get_doublebuffer (void) const { return doublebuffer.current_value (); }
4147 
4148  double get_mincolormap (void) const { return mincolormap.double_value (); }
4149 
4150  std::string get_wvisual (void) const { return wvisual.string_value (); }
4151 
4152  bool wvisualmode_is (const std::string& v) const { return wvisualmode.is (v); }
4153  std::string get_wvisualmode (void) const { return wvisualmode.current_value (); }
4154 
4155  std::string get_xdisplay (void) const { return xdisplay.string_value (); }
4156 
4157  std::string get_xvisual (void) const { return xvisual.string_value (); }
4158 
4159  bool xvisualmode_is (const std::string& v) const { return xvisualmode.is (v); }
4160  std::string get_xvisualmode (void) const { return xvisualmode.current_value (); }
4161 
4162 
4164  {
4165  {
4166  if (alphamap.set (val, true))
4167  {
4168  mark_modified ();
4169  }
4170  }
4171  }
4172 
4174  {
4175  {
4176  if (buttondownfcn.set (val, true))
4177  {
4178  mark_modified ();
4179  }
4180  }
4181  }
4182 
4184  {
4185  {
4186  if (closerequestfcn.set (val, true))
4187  {
4188  mark_modified ();
4189  }
4190  }
4191  }
4192 
4194  {
4195  {
4196  if (color.set (val, true))
4197  {
4198  mark_modified ();
4199  }
4200  }
4201  }
4202 
4204  {
4205  {
4206  if (colormap.set (val, true))
4207  {
4208  mark_modified ();
4209  }
4210  }
4211  }
4212 
4213  void set_currentaxes (const octave_value& val);
4214 
4216  {
4217  {
4218  if (currentcharacter.set (val, true))
4219  {
4220  mark_modified ();
4221  }
4222  }
4223  }
4224 
4226  {
4227  {
4228  if (currentobject.set (val, true))
4229  {
4230  mark_modified ();
4231  }
4232  }
4233  }
4234 
4236  {
4237  {
4238  if (currentpoint.set (val, true))
4239  {
4240  mark_modified ();
4241  }
4242  }
4243  }
4244 
4246  {
4247  {
4248  if (dockcontrols.set (val, true))
4249  {
4250  mark_modified ();
4251  }
4252  }
4253  }
4254 
4256  {
4257  {
4258  if (filename.set (val, true))
4259  {
4260  mark_modified ();
4261  }
4262  }
4263  }
4264 
4266  {
4267  {
4268  if (graphicssmoothing.set (val, true))
4269  {
4270  mark_modified ();
4271  }
4272  }
4273  }
4274 
4275  void set_integerhandle (const octave_value& val);
4276 
4278  {
4279  {
4280  if (inverthardcopy.set (val, true))
4281  {
4282  mark_modified ();
4283  }
4284  }
4285  }
4286 
4288  {
4289  {
4290  if (keypressfcn.set (val, true))
4291  {
4292  mark_modified ();
4293  }
4294  }
4295  }
4296 
4298  {
4299  {
4300  if (keyreleasefcn.set (val, true))
4301  {
4302  mark_modified ();
4303  }
4304  }
4305  }
4306 
4308  {
4309  {
4310  if (menubar.set (val, true))
4311  {
4312  mark_modified ();
4313  }
4314  }
4315  }
4316 
4317  void set_name (const octave_value& val)
4318  {
4319  {
4320  if (name.set (val, true))
4321  {
4322  mark_modified ();
4323  }
4324  }
4325  }
4326 
4328  {
4329  {
4330  if (nextplot.set (val, true))
4331  {
4332  mark_modified ();
4333  }
4334  }
4335  }
4336 
4338  {
4339  {
4340  if (numbertitle.set (val, true))
4341  {
4342  mark_modified ();
4343  }
4344  }
4345  }
4346 
4348  {
4349  {
4350  if (paperorientation.set (val, true))
4351  {
4352  update_paperorientation ();
4353  mark_modified ();
4354  }
4355  }
4356  }
4357 
4358  void update_paperorientation (void);
4359 
4361  {
4362  {
4363  if (paperposition.set (val, false))
4364  {
4365  set_paperpositionmode ("manual");
4366  paperposition.run_listeners (POSTSET);
4367  mark_modified ();
4368  }
4369  else
4370  set_paperpositionmode ("manual");
4371  }
4372  }
4373 
4375  {
4376  {
4377  if (paperpositionmode.set (val, true))
4378  {
4379  update_paperpositionmode ();
4380  mark_modified ();
4381  }
4382  }
4383  }
4384 
4386  {
4387  {
4388  if (papersize.set (val, true))
4389  {
4390  update_papersize ();
4391  mark_modified ();
4392  }
4393  }
4394  }
4395 
4396  void update_papersize (void);
4397 
4398  void set_papertype (const octave_value& val);
4399 
4400  void update_papertype (void);
4401 
4402  void set_paperunits (const octave_value& val);
4403 
4405  {
4406  {
4407  if (pointer.set (val, true))
4408  {
4409  mark_modified ();
4410  }
4411  }
4412  }
4413 
4415  {
4416  {
4417  if (pointershapecdata.set (val, true))
4418  {
4419  mark_modified ();
4420  }
4421  }
4422  }
4423 
4425  {
4426  {
4427  if (pointershapehotspot.set (val, true))
4428  {
4429  mark_modified ();
4430  }
4431  }
4432  }
4433 
4435  {
4436  {
4437  if (renderer.set (val, false))
4438  {
4439  set_renderermode ("manual");
4440  renderer.run_liste